projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add dependency on libusb to usbutils
[openwrt.git] / package / net-snmp / patches / 750-ieee802dot11.patch
1 --- net-snmp-5.1.2-orig/agent/mibgroup/ieee802dot11.c 1970-01-01 01:00:00.000000000 +0100
2 +++ net-snmp-5.1.2-5/agent/mibgroup/ieee802dot11.c 2005-03-13 16:17:21.000000000 +0100
3 @@ -0,0 +1,4915 @@
4 +/****************************************************************************
5 +* *
6 +* File Name: ieee802dot11.c *
7 +* Used By: *
8 +* *
9 +* Operating System: *
10 +* Purpose: *
11 +* *
12 +* Comments: *
13 +* *
14 +* Author: Larry Simmons *
15 +* lsimmons@avantcom.com *
16 +* www.avantcom.com *
17 +* *
18 +* Creation Date: 09/02/03 *
19 +* *
20 +* Ver Date Inits Modification *
21 +* ----- -------- ----- ------------ *
22 +* 0.0.1 09/02/03 LRS created *
23 +* 0.0.2 09/24/03 LRS wouldn't build after fresh ./configure *
24 +****************************************************************************/
25 +/****************************************************************************
26 +* Includes *
27 +****************************************************************************/
28 +#include <net-snmp/net-snmp-config.h>
29 +#include <net-snmp/net-snmp-includes.h>
30 +#include <net-snmp/agent/net-snmp-agent-includes.h>
31 +#include "ieee802dot11.h"
32 +#include "iwlib.h"
33 +
34 +/****************************************************************************
35 +* Defines *
36 +****************************************************************************/
37 +#define DISPLAYWIEXT // display wireless ext info
38 +#define TABLE_SIZE 1
39 +//#define MINLOADFREQ 15 // min reload frequency in seconds
40 +#define MINLOADFREQ 5 // min reload frequency in seconds // for testing
41 +#define PROC_NET_DEV "/proc/net/dev"
42 +#define PROC_NET_WIRELESS "/proc/net/wireless"
43 +
44 +#ifndef UCHAR
45 + typedef unsigned char UCHAR;
46 +#endif
47 +
48 +/****************************************************************************
49 +* Private Functions *
50 +****************************************************************************/
51 +static void loadTables();
52 +static void loadWiExt ( int, char *, struct wireless_info * );
53 +static void load80211Structs ( int, char *, struct wireless_info * );
54 +static void initStructs();
55 +
56 +// Wireless Extensions Specific Functions
57 +static void loadWiExtTo80211Structs ( int, char *, struct wireless_info * );
58 +static void displayWiExt ( struct wireless_info );
59 +
60 +// Linked List Functions
61 +static void addList ( char *, char *, int );
62 +static void initLists(); // initialize all the linked lists
63 +static void flushLists(); // flush all the linked lists
64 +static void flushList ( char * ); // flush a single linked list
65 +
66 +// Utility Functions
67 +static int openSocket ( void );
68 +static int mWatt2dbm ( int );
69 +static char *htob ( char * );
70 +static int hasChanged ( char *, int );
71 +
72 +/****************************************************************************
73 +* Private Variables *
74 +****************************************************************************/
75 +static unsigned long lastLoad = 0; // ET in secs at last table load
76 +
77 +static struct avNode *lastNode, *newNode, *np;
78 +
79 +/****************************************************************************
80 +* External Functions *
81 +****************************************************************************/
82 +
83 +/****************************************************************************
84 +* ieee802dot11_variables_oid: *
85 +* this is the top level oid that we want to register under. This *
86 +* is essentially a prefix, with the suffix appearing in the *
87 +* variable below. *
88 +****************************************************************************/
89 +oid ieee802dot11_variables_oid[] = { 1,2,840,10036 };
90 +
91 +/****************************************************************************
92 +* variable7 ieee802dot11_variables: *
93 +* this variable defines function callbacks and type return information *
94 +* for the ieee802dot11 mib section *
95 +****************************************************************************/
96 +struct variable7 ieee802dot11_variables[] = {
97 +/* magic number , variable type , ro/rw , callback fn , L, oidsuffix */
98 +#define DOT11STATIONID 3
99 + { DOT11STATIONID , ASN_OCTET_STR , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,1 } },
100 +#define DOT11MEDIUMOCCUPANCYLIMIT 4
101 + { DOT11MEDIUMOCCUPANCYLIMIT, ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,2 } },
102 +#define DOT11CFPOLLABLE 5
103 + { DOT11CFPOLLABLE , ASN_INTEGER , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,3 } },
104 +#define DOT11CFPPERIOD 6
105 + { DOT11CFPPERIOD , ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,4 } },
106 +#define DOT11CFPMAXDURATION 7
107 + { DOT11CFPMAXDURATION , ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,5 } },
108 +#define DOT11AUTHENTICATIONRESPONSETIMEOUT 8
109 + { DOT11AUTHENTICATIONRESPONSETIMEOUT, ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,6 } },
110 +#define DOT11PRIVACYOPTIONIMPLEMENTED 9
111 + { DOT11PRIVACYOPTIONIMPLEMENTED, ASN_INTEGER , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,7 } },
112 +#define DOT11POWERMANAGEMENTMODE 10
113 + { DOT11POWERMANAGEMENTMODE, ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,8 } },
114 +#define DOT11DESIREDSSID 11
115 + { DOT11DESIREDSSID , ASN_OCTET_STR , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,9 } },
116 +#define DOT11DESIREDBSSTYPE 12
117 + { DOT11DESIREDBSSTYPE , ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,10 } },
118 +#define DOT11OPERATIONALRATESET 13
119 + { DOT11OPERATIONALRATESET, ASN_OCTET_STR , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,11 } },
120 +#define DOT11BEACONPERIOD 14
121 + { DOT11BEACONPERIOD , ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,12 } },
122 +#define DOT11DTIMPERIOD 15
123 + { DOT11DTIMPERIOD , ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,13 } },
124 +#define DOT11ASSOCIATIONRESPONSETIMEOUT 16
125 + { DOT11ASSOCIATIONRESPONSETIMEOUT, ASN_INTEGER , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,14 } },
126 +#define DOT11DISASSOCIATEREASON 17
127 + { DOT11DISASSOCIATEREASON, ASN_INTEGER , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,15 } },
128 +#define DOT11DISASSOCIATESTATION 18
129 + { DOT11DISASSOCIATESTATION, ASN_OCTET_STR , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,16 } },
130 +#define DOT11DEAUTHENTICATEREASON 19
131 + { DOT11DEAUTHENTICATEREASON, ASN_INTEGER , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,17 } },
132 +#define DOT11DEAUTHENTICATESTATION 20
133 + { DOT11DEAUTHENTICATESTATION, ASN_OCTET_STR , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,18 } },
134 +#define DOT11AUTHENTICATEFAILSTATUS 21
135 + { DOT11AUTHENTICATEFAILSTATUS, ASN_INTEGER , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,19 } },
136 +#define DOT11AUTHENTICATEFAILSTATION 22
137 + { DOT11AUTHENTICATEFAILSTATION, ASN_OCTET_STR , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,20 } },
138 +
139 +#define DOT11AUTHENTICATIONALGORITHM 26
140 + { DOT11AUTHENTICATIONALGORITHM, ASN_INTEGER , RONLY , var_dot11AuthenticationAlgorithmsTable, 4, { 1,2,1,2 } },
141 +#define DOT11AUTHENTICATIONALGORITHMSENABLE 27
142 + { DOT11AUTHENTICATIONALGORITHMSENABLE, ASN_INTEGER , RWRITE, var_dot11AuthenticationAlgorithmsTable, 4, { 1,2,1,3 } },
143 +
144 +#define DOT11WEPDEFAULTKEYVALUE 31
145 + { DOT11WEPDEFAULTKEYVALUE, ASN_OCTET_STR , RWRITE, var_dot11WEPDefaultKeysTable, 4, { 1,3,1,2 } },
146 +
147 +#define DOT11WEPKEYMAPPINGADDRESS 35
148 + { DOT11WEPKEYMAPPINGADDRESS, ASN_OCTET_STR , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,2 } },
149 +#define DOT11WEPKEYMAPPINGWEPON 36
150 + { DOT11WEPKEYMAPPINGWEPON, ASN_INTEGER , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,3 } },
151 +#define DOT11WEPKEYMAPPINGVALUE 37
152 + { DOT11WEPKEYMAPPINGVALUE, ASN_OCTET_STR , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,4 } },
153 +#define DOT11WEPKEYMAPPINGSTATUS 38
154 + { DOT11WEPKEYMAPPINGSTATUS, ASN_INTEGER , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,5 } },
155 +
156 +#define DOT11PRIVACYINVOKED 41
157 + { DOT11PRIVACYINVOKED , ASN_INTEGER , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,1 } },
158 +#define DOT11WEPDEFAULTKEYID 42
159 + { DOT11WEPDEFAULTKEYID, ASN_INTEGER , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,2 } },
160 +#define DOT11WEPKEYMAPPINGLENGTH 43
161 + { DOT11WEPKEYMAPPINGLENGTH, ASN_INTEGER , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,3 } },
162 +#define DOT11EXCLUDEUNENCRYPTED 44
163 + { DOT11EXCLUDEUNENCRYPTED, ASN_INTEGER , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,4 } },
164 +#define DOT11WEPICVERRORCOUNT 45
165 + { DOT11WEPICVERRORCOUNT, ASN_COUNTER , RONLY , var_dot11PrivacyTable, 4, { 1,5,1,5 } },
166 +#define DOT11WEPEXCLUDEDCOUNT 46
167 + { DOT11WEPEXCLUDEDCOUNT, ASN_COUNTER , RONLY , var_dot11PrivacyTable, 4, { 1,5,1,6 } },
168 +
169 +#define DOT11MACADDRESS 49
170 + { DOT11MACADDRESS , ASN_OCTET_STR , RONLY , var_dot11OperationTable, 4, { 2,1,1,1 } },
171 +#define DOT11RTSTHRESHOLD 50
172 + { DOT11RTSTHRESHOLD , ASN_INTEGER , RWRITE, var_dot11OperationTable, 4, { 2,1,1,2 } },
173 +#define DOT11SHORTRETRYLIMIT 51
174 + { DOT11SHORTRETRYLIMIT, ASN_INTEGER , RWRITE, var_dot11OperationTable, 4, { 2,1,1,3 } },
175 +#define DOT11LONGRETRYLIMIT 52
176 + { DOT11LONGRETRYLIMIT , ASN_INTEGER , RWRITE, var_dot11OperationTable, 4, { 2,1,1,4 } },
177 +#define DOT11FRAGMENTATIONTHRESHOLD 53
178 + { DOT11FRAGMENTATIONTHRESHOLD, ASN_INTEGER , RWRITE, var_dot11OperationTable, 4, { 2,1,1,5 } },
179 +#define DOT11MAXTRANSMITMSDULIFETIME 54
180 + { DOT11MAXTRANSMITMSDULIFETIME, ASN_INTEGER , RWRITE, var_dot11OperationTable, 4, { 2,1,1,6 } },
181 +#define DOT11MAXRECEIVELIFETIME 55
182 + { DOT11MAXRECEIVELIFETIME, ASN_INTEGER , RWRITE, var_dot11OperationTable, 4, { 2,1,1,7 } },
183 +#define DOT11MANUFACTURERID 56
184 + { DOT11MANUFACTURERID , ASN_OCTET_STR , RONLY , var_dot11OperationTable, 4, { 2,1,1,8 } },
185 +#define DOT11PRODUCTID 57
186 + { DOT11PRODUCTID , ASN_OCTET_STR , RONLY , var_dot11OperationTable, 4, { 2,1,1,9 } },
187 +
188 +#define DOT11TRANSMITTEDFRAGMENTCOUNT 60
189 + { DOT11TRANSMITTEDFRAGMENTCOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,1 } },
190 +#define DOT11MULTICASTTRANSMITTEDFRAMECOUNT 61
191 + { DOT11MULTICASTTRANSMITTEDFRAMECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,2 } },
192 +#define DOT11FAILEDCOUNT 62
193 + { DOT11FAILEDCOUNT , ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,3 } },
194 +#define DOT11RETRYCOUNT 63
195 + { DOT11RETRYCOUNT , ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,4 } },
196 +#define DOT11MULTIPLERETRYCOUNT 64
197 + { DOT11MULTIPLERETRYCOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,5 } },
198 +#define DOT11FRAMEDUPLICATECOUNT 65
199 + { DOT11FRAMEDUPLICATECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,6 } },
200 +#define DOT11RTSSUCCESSCOUNT 66
201 + { DOT11RTSSUCCESSCOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,7 } },
202 +#define DOT11RTSFAILURECOUNT 67
203 + { DOT11RTSFAILURECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,8 } },
204 +#define DOT11ACKFAILURECOUNT 68
205 + { DOT11ACKFAILURECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,9 } },
206 +#define DOT11RECEIVEDFRAGMENTCOUNT 69
207 + { DOT11RECEIVEDFRAGMENTCOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,10 } },
208 +#define DOT11MULTICASTRECEIVEDFRAMECOUNT 70
209 + { DOT11MULTICASTRECEIVEDFRAMECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,11 } },
210 +#define DOT11FCSERRORCOUNT 71
211 + { DOT11FCSERRORCOUNT , ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,12 } },
212 +#define DOT11TRANSMITTEDFRAMECOUNT 72
213 + { DOT11TRANSMITTEDFRAMECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,13 } },
214 +#define DOT11WEPUNDECRYPTABLECOUNT 73
215 + { DOT11WEPUNDECRYPTABLECOUNT, ASN_COUNTER , RONLY , var_dot11CountersTable, 4, { 2,2,1,14 } },
216 +
217 +#define DOT11ADDRESS 77
218 + { DOT11ADDRESS , ASN_OCTET_STR , RWRITE, var_dot11GroupAddressesTable, 4, { 2,3,1,2 } },
219 +#define DOT11GROUPADDRESSESSTATUS 78
220 + { DOT11GROUPADDRESSESSTATUS, ASN_INTEGER , RWRITE, var_dot11GroupAddressesTable, 4, { 2,3,1,3 } },
221 +
222 +#define DOT11RESOURCETYPEIDNAME 79
223 + { DOT11RESOURCETYPEIDNAME, ASN_OCTET_STR , RONLY , var_ieee802dot11, 3, { 3,1,1 } },
224 +#define DOT11MANUFACTUREROUI 82
225 + { DOT11MANUFACTUREROUI, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,1 } },
226 +#define DOT11MANUFACTURERNAME 83
227 + { DOT11MANUFACTURERNAME, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,2 } },
228 +#define DOT11MANUFACTURERPRODUCTNAME 84
229 + { DOT11MANUFACTURERPRODUCTNAME, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,3 } },
230 +#define DOT11MANUFACTURERPRODUCTVERSION 85
231 + { DOT11MANUFACTURERPRODUCTVERSION, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,4 } },
232 +
233 +#define DOT11PHYTYPE 88
234 + { DOT11PHYTYPE , ASN_INTEGER , RONLY , var_dot11PhyOperationTable, 4, { 4,1,1,1 } },
235 +#define DOT11CURRENTREGDOMAIN 89
236 + { DOT11CURRENTREGDOMAIN, ASN_INTEGER , RWRITE, var_dot11PhyOperationTable, 4, { 4,1,1,2 } },
237 +#define DOT11TEMPTYPE 90
238 + { DOT11TEMPTYPE , ASN_INTEGER , RONLY , var_dot11PhyOperationTable, 4, { 4,1,1,3 } },
239 +#define DOT11CURRENTTXANTENNA 93
240 + { DOT11CURRENTTXANTENNA, ASN_INTEGER , RWRITE, var_dot11PhyAntennaTable, 4, { 4,2,1,1 } },
241 +#define DOT11DIVERSITYSUPPORT 94
242 + { DOT11DIVERSITYSUPPORT, ASN_INTEGER , RONLY , var_dot11PhyAntennaTable, 4, { 4,2,1,2 } },
243 +#define DOT11CURRENTRXANTENNA 95
244 + { DOT11CURRENTRXANTENNA, ASN_INTEGER , RWRITE, var_dot11PhyAntennaTable, 4, { 4,2,1,3 } },
245 +#define DOT11NUMBERSUPPORTEDPOWERLEVELS 98
246 + { DOT11NUMBERSUPPORTEDPOWERLEVELS, ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,1 } },
247 +#define DOT11TXPOWERLEVEL1 99
248 + { DOT11TXPOWERLEVEL1 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,2 } },
249 +#define DOT11TXPOWERLEVEL2 100
250 + { DOT11TXPOWERLEVEL2 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,3 } },
251 +#define DOT11TXPOWERLEVEL3 101
252 + { DOT11TXPOWERLEVEL3 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,4 } },
253 +#define DOT11TXPOWERLEVEL4 102
254 + { DOT11TXPOWERLEVEL4 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,5 } },
255 +#define DOT11TXPOWERLEVEL5 103
256 + { DOT11TXPOWERLEVEL5 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,6 } },
257 +#define DOT11TXPOWERLEVEL6 104
258 + { DOT11TXPOWERLEVEL6 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,7 } },
259 +#define DOT11TXPOWERLEVEL7 105
260 + { DOT11TXPOWERLEVEL7 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,8 } },
261 +#define DOT11TXPOWERLEVEL8 106
262 + { DOT11TXPOWERLEVEL8 , ASN_INTEGER , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,9 } },
263 +#define DOT11CURRENTTXPOWERLEVEL 107
264 + { DOT11CURRENTTXPOWERLEVEL, ASN_INTEGER , RWRITE, var_dot11PhyTxPowerTable, 4, { 4,3,1,10 } },
265 +
266 +#define DOT11HOPTIME 110
267 + { DOT11HOPTIME , ASN_INTEGER , RONLY , var_dot11PhyFHSSTable, 4, { 4,4,1,1 } },
268 +#define DOT11CURRENTCHANNELNUMBER 111
269 + { DOT11CURRENTCHANNELNUMBER, ASN_INTEGER , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,2 } },
270 +#define DOT11MAXDWELLTIME 112
271 + { DOT11MAXDWELLTIME , ASN_INTEGER , RONLY , var_dot11PhyFHSSTable, 4, { 4,4,1,3 } },
272 +#define DOT11CURRENTDWELLTIME 113
273 + { DOT11CURRENTDWELLTIME, ASN_INTEGER , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,4 } },
274 +#define DOT11CURRENTSET 114
275 + { DOT11CURRENTSET , ASN_INTEGER , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,5 } },
276 +#define DOT11CURRENTPATTERN 115
277 + { DOT11CURRENTPATTERN , ASN_INTEGER , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,6 } },
278 +#define DOT11CURRENTINDEX 116
279 + { DOT11CURRENTINDEX , ASN_INTEGER , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,7 } },
280 +
281 +#define DOT11CURRENTCHANNEL 119
282 + { DOT11CURRENTCHANNEL , ASN_INTEGER , RWRITE, var_dot11PhyDSSSTable, 4, { 4,5,1,1 } },
283 +#define DOT11CCAMODESUPPORTED 120
284 + { DOT11CCAMODESUPPORTED, ASN_INTEGER , RONLY , var_dot11PhyDSSSTable, 4, { 4,5,1,2 } },
285 +#define DOT11CURRENTCCAMODE 121
286 + { DOT11CURRENTCCAMODE , ASN_INTEGER , RWRITE, var_dot11PhyDSSSTable, 4, { 4,5,1,3 } },
287 +#define DOT11EDTHRESHOLD 122
288 + { DOT11EDTHRESHOLD , ASN_INTEGER , RWRITE, var_dot11PhyDSSSTable, 4, { 4,5,1,4 } },
289 +
290 +#define DOT11CCAWATCHDOGTIMERMAX 125
291 + { DOT11CCAWATCHDOGTIMERMAX, ASN_INTEGER , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,1 } },
292 +#define DOT11CCAWATCHDOGCOUNTMAX 126
293 + { DOT11CCAWATCHDOGCOUNTMAX, ASN_INTEGER , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,2 } },
294 +#define DOT11CCAWATCHDOGTIMERMIN 127
295 + { DOT11CCAWATCHDOGTIMERMIN, ASN_INTEGER , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,3 } },
296 +#define DOT11CCAWATCHDOGCOUNTMIN 128
297 + { DOT11CCAWATCHDOGCOUNTMIN, ASN_INTEGER , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,4 } },
298 +
299 +#define DOT11REGDOMAINSSUPPORTVALUE 132
300 + { DOT11REGDOMAINSSUPPORTVALUE, ASN_INTEGER , RONLY , var_dot11RegDomainsSupportedTable, 4, { 4,7,1,2 } },
301 +
302 +#define DOT11SUPPORTEDTXANTENNA 136
303 + { DOT11SUPPORTEDTXANTENNA, ASN_INTEGER , RWRITE, var_dot11AntennasListTable, 4, { 4,8,1,2 } },
304 +#define DOT11SUPPORTEDRXANTENNA 137
305 + { DOT11SUPPORTEDRXANTENNA, ASN_INTEGER , RWRITE, var_dot11AntennasListTable, 4, { 4,8,1,3 } },
306 +#define DOT11DIVERSITYSELECTIONRX 138
307 + { DOT11DIVERSITYSELECTIONRX, ASN_INTEGER , RWRITE, var_dot11AntennasListTable, 4, { 4,8,1,4 } },
308 +
309 +#define DOT11SUPPORTEDDATARATESTXVALUE 142
310 + { DOT11SUPPORTEDDATARATESTXVALUE, ASN_INTEGER , RONLY , var_dot11SupportedDataRatesTxTable, 4, { 4,9,1,2 } },
311 +
312 +#define DOT11SUPPORTEDDATARATESRXVALUE 146
313 + { DOT11SUPPORTEDDATARATESRXVALUE, ASN_INTEGER , RONLY , var_dot11SupportedDataRatesRxTable, 4, { 4,10,1,2 } },
314 +};
315 +// ( L = length of the oidsuffix )
316 +
317 +/****************************************************************************
318 +* *
319 +* init_ieee802dot11() - perform any required initialization *
320 +* *
321 +****************************************************************************/
322 +void init_ieee802dot11 ( void ) {
323 +
324 + /* register ourselves with the agent to handle our mib tree */
325 + REGISTER_MIB("ieee802dot11", ieee802dot11_variables, variable7,
326 + ieee802dot11_variables_oid);
327 +
328 + initLists();
329 +}
330 +
331 +/****************************************************************************
332 +* *
333 +* shutdown_ieee802dot11() - perform any required cleanup @ shutdown *
334 +* *
335 +****************************************************************************/
336 +void shutdown_ieee802dot11 ( void )
337 +{
338 + flushLists();
339 +}
340 +
341 +/****************************************************************************
342 +* *
343 +* var_ieee802dot11() - *
344 +* *
345 +****************************************************************************/
346 +unsigned char *
347 +var_ieee802dot11 ( struct variable *vp,
348 + oid *name,
349 + size_t *length,
350 + int exact,
351 + size_t *var_len,
352 + WriteMethod **write_method)
353 +{
354 + loadTables();
355 +
356 + if ( header_generic ( vp, name, length, exact,var_len,write_method )
357 + == MATCH_FAILED )
358 + return NULL;
359 +
360 + switch ( vp->magic ) {
361 +
362 + case DOT11RESOURCETYPEIDNAME:
363 + if ( !haveResourceTypeIDName )
364 + return NULL;
365 + *var_len = strlen ( resourceTypeIDName );
366 + return ( UCHAR * ) resourceTypeIDName;
367 +
368 + default:
369 + ERROR_MSG ( "" );
370 + }
371 +
372 + return NULL;
373 +}
374 +
375 +/****************************************************************************
376 +* *
377 +* var_dot11StationConfigTable() - return a variable value from the table *
378 +* *
379 +****************************************************************************/
380 +unsigned char *
381 +var_dot11StationConfigTable ( struct variable *vp,
382 + oid *name,
383 + size_t *length,
384 + int exact,
385 + size_t *var_len,
386 + WriteMethod **write_method )
387 +{
388 + int found = FALSE;
389 + oid rName [ MAX_OID_LEN ]; // OID to be returned
390 + static char MACWork[17];
391 +
392 + loadTables();
393 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
394 + for ( np = LIST_FIRST ( &scList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
395 + sc = ( struct scTbl_data * ) np->data;
396 + rName[vp->namelen] = sc->ifIndex;
397 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
398 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
399 +
400 + switch ( vp->magic ) { // found requested OID, now check for requested variable
401 + case DOT11STATIONID:
402 + if ( sc->haveStationID ) found = TRUE; break;
403 + case DOT11MEDIUMOCCUPANCYLIMIT:
404 + if ( sc->haveMediumOccupancyLimit ) found = TRUE; break;
405 + case DOT11CFPOLLABLE:
406 + if ( sc->haveCFPPollable ) found = TRUE; break;
407 + case DOT11CFPPERIOD:
408 + if ( sc->haveCFPPeriod ) found = TRUE; break;
409 + case DOT11CFPMAXDURATION:
410 + if ( sc->haveMaxDuration ) found = TRUE; break;
411 + case DOT11AUTHENTICATIONRESPONSETIMEOUT:
412 + if ( sc->haveAuthenticationResponseTimeOut ) found = TRUE; break;
413 + case DOT11PRIVACYOPTIONIMPLEMENTED:
414 + if ( sc->havePrivacyOptionImplemented ) found = TRUE; break;
415 + case DOT11POWERMANAGEMENTMODE:
416 + if ( sc->havePowerManagementMode ) found = TRUE; break;
417 + case DOT11DESIREDSSID:
418 + if ( sc->haveDesiredSSID ) found = TRUE; break;
419 + case DOT11DESIREDBSSTYPE:
420 + if ( sc->haveDesiredBSSType ) found = TRUE; break;
421 + case DOT11OPERATIONALRATESET:
422 + if ( sc->haveOperationalRateSet ) found = TRUE; break;
423 + case DOT11BEACONPERIOD:
424 + if ( sc->haveBeaconPeriod ) found = TRUE; break;
425 + case DOT11DTIMPERIOD:
426 + if ( sc->haveDTIMPeriod ) found = TRUE; break;
427 + case DOT11ASSOCIATIONRESPONSETIMEOUT:
428 + if ( sc->haveAssociationResponseTimeOut ) found = TRUE; break;
429 + case DOT11DISASSOCIATEREASON:
430 + if ( sc->disAssociationReason ) found = TRUE; break;
431 + case DOT11DISASSOCIATESTATION:
432 + if ( sc->haveDisAssociationStation ) found = TRUE; break;
433 + case DOT11DEAUTHENTICATEREASON:
434 + if ( sc->deAuthenticationReason ) found = TRUE; break;
435 + case DOT11DEAUTHENTICATESTATION:
436 + if ( sc->haveDeAuthenticationStation ) found = TRUE; break;
437 + case DOT11AUTHENTICATEFAILSTATUS:
438 + if ( sc->authenticateFailStatus ) found = TRUE; break;
439 + case DOT11AUTHENTICATEFAILSTATION:
440 + if ( sc->haveAuthenticateFailStation ) found = TRUE; break;
441 + }
442 + }
443 + if ( found )
444 + break;
445 + }
446 +
447 + if ( !found )
448 + return NULL;
449 +
450 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
451 + *length = vp->namelen + 1;
452 + *var_len = sizeof ( long );
453 + *write_method = NULL;
454 +
455 + switch ( vp->magic ) {
456 +
457 + case DOT11STATIONID:
458 +// *write_method = write_dot11StationID;
459 + MACWork[ 0] = sc->stationID [ 0];
460 + MACWork[ 1] = sc->stationID [ 1];
461 + MACWork[ 2] = sc->stationID [ 3];
462 + MACWork[ 3] = sc->stationID [ 4];
463 + MACWork[ 4] = sc->stationID [ 6];
464 + MACWork[ 5] = sc->stationID [ 7];
465 + MACWork[ 6] = sc->stationID [ 9];
466 + MACWork[ 7] = sc->stationID [10];
467 + MACWork[ 8] = sc->stationID [12];
468 + MACWork[ 9] = sc->stationID [13];
469 + MACWork[10] = sc->stationID [15];
470 + MACWork[11] = sc->stationID [16];
471 + MACWork[12] = '\0';
472 + *var_len = 6;
473 + return ( UCHAR * ) htob ( MACWork );
474 +
475 + case DOT11MEDIUMOCCUPANCYLIMIT:
476 +// *write_method = write_dot11MediumOccupancyLimit;
477 + sc->mediumOccupancyLimit = 5;
478 + return ( UCHAR * ) &sc->mediumOccupancyLimit;
479 +
480 + case DOT11CFPOLLABLE:
481 + return ( UCHAR * ) &sc->CFPPollable;
482 +
483 + case DOT11CFPPERIOD:
484 +// *write_method = write_dot11CFPPeriod;
485 + return ( UCHAR * ) &sc->CFPPeriod;
486 +
487 + case DOT11CFPMAXDURATION:
488 +// *write_method = write_dot11CFPMaxDuration;
489 + return ( UCHAR * ) &sc->maxDuration;
490 +
491 + case DOT11AUTHENTICATIONRESPONSETIMEOUT:
492 +// *write_method = write_dot11AuthenticationResponseTimeOut;
493 + return ( UCHAR * ) &sc->authenticationResponseTimeOut;
494 +
495 + case DOT11PRIVACYOPTIONIMPLEMENTED:
496 + return ( UCHAR * ) &sc->privacyOptionImplemented;
497 +
498 + case DOT11POWERMANAGEMENTMODE:
499 +// *write_method = write_dot11PowerManagementMode;
500 + return ( UCHAR * ) &sc->powerManagementMode;
501 +
502 + case DOT11DESIREDSSID:
503 +// *write_method = write_dot11DesiredSSID;
504 + *var_len = strlen ( sc->desiredSSID );
505 + return ( UCHAR * ) sc->desiredSSID;
506 +
507 + case DOT11DESIREDBSSTYPE:
508 +// *write_method = write_dot11DesiredBSSType;
509 + return ( UCHAR * ) &sc->desiredBSSType;
510 +
511 + case DOT11OPERATIONALRATESET:
512 +// *write_method = write_dot11OperationalRateSet;
513 + *var_len = strlen ( sc->operationalRateSet );
514 + return ( UCHAR * ) sc->operationalRateSet;
515 +
516 + case DOT11BEACONPERIOD:
517 +// *write_method = write_dot11BeaconPeriod;
518 + return ( UCHAR * ) &sc->beaconPeriod;
519 +
520 + case DOT11DTIMPERIOD:
521 +// *write_method = write_dot11DTIMPeriod;
522 + return ( UCHAR * ) &sc->DTIMPeriod;
523 +
524 + case DOT11ASSOCIATIONRESPONSETIMEOUT:
525 +// *write_method = write_dot11AssociationResponseTimeOut;
526 + return ( UCHAR * ) &sc->associationResponseTimeOut;
527 +
528 + case DOT11DISASSOCIATEREASON:
529 + return ( UCHAR * ) &sc->disAssociationReason;
530 +
531 + case DOT11DISASSOCIATESTATION:
532 + MACWork[ 0] = sc->disAssociationStation[ 0];
533 + MACWork[ 1] = sc->disAssociationStation[ 1];
534 + MACWork[ 2] = sc->disAssociationStation[ 3];
535 + MACWork[ 3] = sc->disAssociationStation[ 4];
536 + MACWork[ 4] = sc->disAssociationStation[ 6];
537 + MACWork[ 5] = sc->disAssociationStation[ 7];
538 + MACWork[ 6] = sc->disAssociationStation[ 9];
539 + MACWork[ 7] = sc->disAssociationStation[10];
540 + MACWork[ 8] = sc->disAssociationStation[12];
541 + MACWork[ 9] = sc->disAssociationStation[13];
542 + MACWork[10] = sc->disAssociationStation[15];
543 + MACWork[11] = sc->disAssociationStation[16];
544 + MACWork[12] = '\0';
545 + *var_len = 6;
546 + return ( UCHAR * ) htob ( MACWork );
547 +
548 + case DOT11DEAUTHENTICATEREASON:
549 + return ( UCHAR * ) &sc->deAuthenticationReason;
550 +
551 + case DOT11DEAUTHENTICATESTATION:
552 + MACWork[ 0] = sc->deAuthenticationStation[ 0];
553 + MACWork[ 1] = sc->deAuthenticationStation[ 1];
554 + MACWork[ 2] = sc->deAuthenticationStation[ 3];
555 + MACWork[ 3] = sc->deAuthenticationStation[ 4];
556 + MACWork[ 4] = sc->deAuthenticationStation[ 6];
557 + MACWork[ 5] = sc->deAuthenticationStation[ 7];
558 + MACWork[ 6] = sc->deAuthenticationStation[ 9];
559 + MACWork[ 7] = sc->deAuthenticationStation[10];
560 + MACWork[ 8] = sc->deAuthenticationStation[12];
561 + MACWork[ 9] = sc->deAuthenticationStation[13];
562 + MACWork[10] = sc->deAuthenticationStation[15];
563 + MACWork[11] = sc->deAuthenticationStation[16];
564 + MACWork[12] = '\0';
565 + *var_len = 6;
566 + return ( UCHAR * ) htob ( MACWork );
567 +
568 + case DOT11AUTHENTICATEFAILSTATUS:
569 + return ( UCHAR * ) &sc->authenticateFailStatus;
570 +
571 + case DOT11AUTHENTICATEFAILSTATION:
572 + MACWork[ 0] = sc->authenticateFailStation[ 0];
573 + MACWork[ 1] = sc->authenticateFailStation[ 1];
574 + MACWork[ 2] = sc->authenticateFailStation[ 3];
575 + MACWork[ 3] = sc->authenticateFailStation[ 4];
576 + MACWork[ 4] = sc->authenticateFailStation[ 6];
577 + MACWork[ 5] = sc->authenticateFailStation[ 7];
578 + MACWork[ 6] = sc->authenticateFailStation[ 9];
579 + MACWork[ 7] = sc->authenticateFailStation[10];
580 + MACWork[ 8] = sc->authenticateFailStation[12];
581 + MACWork[ 9] = sc->authenticateFailStation[13];
582 + MACWork[10] = sc->authenticateFailStation[15];
583 + MACWork[11] = sc->authenticateFailStation[16];
584 + MACWork[12] = '\0';
585 + *var_len = 6;
586 + return ( UCHAR * ) htob ( MACWork );
587 +
588 + default:
589 + ERROR_MSG ( "" );
590 + }
591 +
592 + return NULL;
593 +}
594 +
595 +/****************************************************************************
596 +* *
597 +* var_dot11AuthenticationAlgorithmsTable() - *
598 +* *
599 +****************************************************************************/
600 +unsigned char *
601 +var_dot11AuthenticationAlgorithmsTable ( struct variable *vp,
602 + oid *name,
603 + size_t *length,
604 + int exact,
605 + size_t *var_len,
606 + WriteMethod **write_method )
607 +{
608 + int found = FALSE;
609 + oid rName [ MAX_OID_LEN ]; // OID to be returned
610 +
611 + loadTables();
612 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
613 + for ( np = LIST_FIRST ( &aaList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
614 + aa = ( struct aaTbl_data * ) np->data;
615 + rName[vp->namelen + 0] = aa->ifIndex;
616 + rName[vp->namelen + 1] = aa->authenticationAlgorithmsIndex;
617 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
618 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
619 + switch ( vp->magic ) {
620 + case DOT11AUTHENTICATIONALGORITHM:
621 + if ( aa->haveAuthenticationAlgorithm ) found = TRUE; break;
622 + case DOT11AUTHENTICATIONALGORITHMSENABLE:
623 + if ( aa->authenticationAlgorithmsEnable ) found = TRUE; break;
624 + }
625 + }
626 + if ( found )
627 + break;
628 + }
629 +
630 + if ( !found )
631 + return NULL;
632 +
633 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
634 + *length = vp->namelen + 2;
635 + *var_len = sizeof ( long );
636 + *write_method = NULL;
637 +
638 + switch ( vp->magic ) {
639 +
640 + case DOT11AUTHENTICATIONALGORITHM:
641 + return ( UCHAR * ) &aa->authenticationAlgorithm;
642 +
643 + case DOT11AUTHENTICATIONALGORITHMSENABLE:
644 +// *write_method = write_dot11AuthenticationAlgorithmsEnable;
645 + return ( UCHAR * ) &aa->authenticationAlgorithmsEnable;
646 +
647 + default:
648 + ERROR_MSG ( "" );
649 + }
650 +
651 + return NULL;
652 +}
653 +
654 +/****************************************************************************
655 +* *
656 +* var_dot11WEPDefaultKeysTable() - *
657 +* *
658 +****************************************************************************/
659 +unsigned char *
660 +var_dot11WEPDefaultKeysTable ( struct variable *vp,
661 + oid *name,
662 + size_t *length,
663 + int exact,
664 + size_t *var_len,
665 + WriteMethod **write_method )
666 +{
667 + int found = FALSE;
668 + oid rName [ MAX_OID_LEN ]; // OID to be returned
669 +
670 + loadTables();
671 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
672 + for ( np = LIST_FIRST ( &dfList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
673 + df = ( struct dfTbl_data * ) np->data;
674 + rName[vp->namelen + 0] = df->ifIndex;
675 + rName[vp->namelen + 1] = df->WEPDefaultKeyIndex;
676 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
677 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
678 + switch ( vp->magic ) {
679 + case DOT11WEPDEFAULTKEYVALUE:
680 + if ( df->haveWEPDefaultKeyValue ) found = TRUE; break;
681 + }
682 + }
683 + if ( found )
684 + break;
685 + }
686 +
687 + if ( !found )
688 + return NULL;
689 +
690 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
691 + *length = vp->namelen + 2;
692 + *var_len = sizeof ( long );
693 + *write_method = NULL;
694 +
695 + switch ( vp->magic ) {
696 +
697 + case DOT11WEPDEFAULTKEYVALUE:
698 +// *write_method = write_dot11WEPDefaultKeyValue;
699 + *var_len = strlen ( df->WEPDefaultKeyValue );
700 + return ( UCHAR * ) df->WEPDefaultKeyValue;
701 +
702 + default:
703 + ERROR_MSG ( "" );
704 + }
705 +
706 + return NULL;
707 +}
708 +
709 +/****************************************************************************
710 +* *
711 +* var_dot11WEPKeyMappingsTable() - *
712 +* *
713 +****************************************************************************/
714 +unsigned char *
715 +var_dot11WEPKeyMappingsTable ( struct variable *vp,
716 + oid *name,
717 + size_t *length,
718 + int exact,
719 + size_t *var_len,
720 + WriteMethod **write_method)
721 +{
722 + static char MACWork[17];
723 + int found = FALSE;
724 + oid rName [ MAX_OID_LEN ]; // OID to be returned
725 +
726 + loadTables();
727 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
728 + for ( np = LIST_FIRST ( &kmList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
729 + km = ( struct kmTbl_data * ) np->data;
730 + rName[vp->namelen + 0] = km->ifIndex;
731 + rName[vp->namelen + 1] = km->WEPKeyMappingIndex;
732 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
733 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
734 + switch ( vp->magic ) {
735 + case DOT11WEPKEYMAPPINGADDRESS:
736 + if ( km->haveWEPKeyMappingAddress ) found = TRUE; break;
737 + case DOT11WEPKEYMAPPINGWEPON:
738 + if ( km->haveWEPKeyMappingWEPOn ) found = TRUE; break;
739 + case DOT11WEPKEYMAPPINGVALUE:
740 + if ( km->haveWEPKeyMappingValue ) found = TRUE; break;
741 + case DOT11WEPKEYMAPPINGSTATUS:
742 + if ( km->haveWEPKeyMappingStatus ) found = TRUE; break;
743 + }
744 + }
745 + if ( found )
746 + break;
747 + }
748 +
749 + if ( !found )
750 + return NULL;
751 +
752 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
753 + *length = vp->namelen + 2;
754 + *var_len = sizeof ( long );
755 + *write_method = NULL;
756 +
757 + switch ( vp->magic ) {
758 +
759 + case DOT11WEPKEYMAPPINGADDRESS:
760 +// *write_method = write_dot11WEPKeyMappingAddress;
761 + MACWork[ 0] = km->WEPKeyMappingAddress[ 0];
762 + MACWork[ 1] = km->WEPKeyMappingAddress[ 1];
763 + MACWork[ 2] = km->WEPKeyMappingAddress[ 3];
764 + MACWork[ 3] = km->WEPKeyMappingAddress[ 4];
765 + MACWork[ 4] = km->WEPKeyMappingAddress[ 6];
766 + MACWork[ 5] = km->WEPKeyMappingAddress[ 7];
767 + MACWork[ 6] = km->WEPKeyMappingAddress[ 9];
768 + MACWork[ 7] = km->WEPKeyMappingAddress[10];
769 + MACWork[ 8] = km->WEPKeyMappingAddress[12];
770 + MACWork[ 9] = km->WEPKeyMappingAddress[13];
771 + MACWork[10] = km->WEPKeyMappingAddress[15];
772 + MACWork[11] = km->WEPKeyMappingAddress[16];
773 + MACWork[12] = '\0';
774 + *var_len = 6;
775 + return ( UCHAR * ) htob ( MACWork );
776 +
777 + case DOT11WEPKEYMAPPINGWEPON:
778 +// *write_method = write_dot11WEPKeyMappingWEPOn;
779 + return ( UCHAR * ) &km->WEPKeyMappingWEPOn;
780 +
781 + case DOT11WEPKEYMAPPINGVALUE:
782 +// *write_method = write_dot11WEPKeyMappingValue;
783 + *var_len = strlen ( km->WEPKeyMappingValue );
784 + return ( UCHAR * ) km->WEPKeyMappingValue;
785 +
786 + case DOT11WEPKEYMAPPINGSTATUS:
787 +// *write_method = write_dot11WEPKeyMappingStatus;
788 + return ( UCHAR * ) &km->WEPKeyMappingStatus;
789 +
790 + default:
791 + ERROR_MSG ( "" );
792 + }
793 + return NULL;
794 +}
795 +
796 +/****************************************************************************
797 +* *
798 +* var_dot11PrivacyTable() - *
799 +* *
800 +****************************************************************************/
801 +unsigned char *
802 +var_dot11PrivacyTable ( struct variable *vp,
803 + oid *name,
804 + size_t *length,
805 + int exact,
806 + size_t *var_len,
807 + WriteMethod **write_method )
808 +{
809 + int found = FALSE;
810 + oid rName [ MAX_OID_LEN ]; // OID to be returned
811 +
812 + loadTables();
813 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
814 + for ( np = LIST_FIRST ( &prList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
815 + pr = ( struct prTbl_data * ) np->data;
816 + rName[vp->namelen] = pr->ifIndex;
817 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
818 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
819 + switch ( vp->magic ) {
820 + case DOT11PRIVACYINVOKED:
821 + if ( pr->havePrivacyInvoked ) found = TRUE; break;
822 + case DOT11WEPDEFAULTKEYID:
823 + if ( pr->haveWEPDefaultKeyID ) found = TRUE; break;
824 + case DOT11WEPKEYMAPPINGLENGTH:
825 + if ( pr->haveWEPKeyMappingLength ) found = TRUE; break;
826 + case DOT11EXCLUDEUNENCRYPTED:
827 + if ( pr->haveExcludeUnencrypted ) found = TRUE; break;
828 + case DOT11WEPICVERRORCOUNT:
829 + if ( pr->haveWEPICVErrorCount ) found = TRUE; break;
830 + case DOT11WEPEXCLUDEDCOUNT:
831 + if ( pr->haveWEPExcludedCount ) found = TRUE; break;
832 + }
833 + }
834 + if ( found )
835 + break;
836 + }
837 +
838 + if ( !found )
839 + return NULL;
840 +
841 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
842 + *length = vp->namelen + 1;
843 + *var_len = sizeof ( long );
844 + *write_method = NULL;
845 +
846 + switch ( vp->magic ) {
847 +
848 + case DOT11PRIVACYINVOKED:
849 +// *write_method = write_dot11PrivacyInvoked;
850 + return ( UCHAR * ) &pr->privacyInvoked;
851 +
852 + case DOT11WEPDEFAULTKEYID:
853 +// *write_method = write_dot11WEPDefaultKeyID;
854 + return ( UCHAR * ) &pr->WEPDefaultKeyID;
855 +
856 + case DOT11WEPKEYMAPPINGLENGTH:
857 +// *write_method = write_dot11WEPKeyMappingLength;
858 + return ( UCHAR * ) &pr->WEPKeyMappingLength;
859 +
860 + case DOT11EXCLUDEUNENCRYPTED:
861 +// *write_method = write_dot11ExcludeUnencrypted;
862 + return ( UCHAR * ) &pr->excludeUnencrypted;
863 +
864 + case DOT11WEPICVERRORCOUNT:
865 + return ( UCHAR * ) &pr->WEPICVErrorCount;
866 +
867 + case DOT11WEPEXCLUDEDCOUNT:
868 + return ( UCHAR * ) &pr->WEPExcludedCount;
869 +
870 + default:
871 + ERROR_MSG ( "" );
872 + }
873 +
874 + return NULL;
875 +}
876 +
877 +/****************************************************************************
878 +* *
879 +* var_dot11OperationTable() - *
880 +* *
881 +****************************************************************************/
882 +unsigned char *
883 +var_dot11OperationTable ( struct variable *vp,
884 + oid *name,
885 + size_t *length,
886 + int exact,
887 + size_t *var_len,
888 + WriteMethod **write_method )
889 +{
890 + int found = FALSE;
891 + oid rName [ MAX_OID_LEN ]; // OID to be returned
892 + static char MACWork[17];
893 +
894 + loadTables();
895 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
896 + for ( np = LIST_FIRST ( &opList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
897 + op = ( struct opTbl_data * ) np->data;
898 + rName[vp->namelen] = op->ifIndex;
899 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
900 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
901 +
902 + switch ( vp->magic ) { // found requested OID, now check for requested variable
903 + case DOT11MACADDRESS:
904 + if ( op->haveMACAddress ) found = TRUE; break;
905 + case DOT11RTSTHRESHOLD:
906 + if ( op->haveRTSThreshold ) found = TRUE; break;
907 + case DOT11SHORTRETRYLIMIT:
908 + if ( op->haveShortRetryLimit ) found = TRUE; break;
909 + case DOT11LONGRETRYLIMIT:
910 + if ( op->haveLongRetryLimit ) found = TRUE; break;
911 + case DOT11FRAGMENTATIONTHRESHOLD:
912 + if ( op->haveFragmentationThreshold ) found = TRUE; break;
913 + case DOT11MAXTRANSMITMSDULIFETIME:
914 + if ( op->haveMaxTransmitMSDULifetime ) found = TRUE; break;
915 + case DOT11MAXRECEIVELIFETIME:
916 + if ( op->haveMaxReceiveLifetime ) found = TRUE; break;
917 + case DOT11MANUFACTURERID:
918 + if ( op->haveManufacturerID ) found = TRUE; break;
919 + case DOT11PRODUCTID:
920 + if ( op->haveProductID ) found = TRUE; break;
921 + }
922 + }
923 + if ( found )
924 + break;
925 + }
926 +
927 + if ( !found )
928 + return NULL;
929 +
930 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
931 + *length = vp->namelen + 1;
932 + *var_len = sizeof ( long );
933 + *write_method = NULL;
934 +
935 + switch ( vp->magic ) {
936 +
937 + case DOT11MACADDRESS:
938 + MACWork[ 0] = op->MACAddress[ 0];
939 + MACWork[ 1] = op->MACAddress[ 1];
940 + MACWork[ 2] = op->MACAddress[ 3];
941 + MACWork[ 3] = op->MACAddress[ 4];
942 + MACWork[ 4] = op->MACAddress[ 6];
943 + MACWork[ 5] = op->MACAddress[ 7];
944 + MACWork[ 6] = op->MACAddress[ 9];
945 + MACWork[ 7] = op->MACAddress[10];
946 + MACWork[ 8] = op->MACAddress[12];
947 + MACWork[ 9] = op->MACAddress[13];
948 + MACWork[10] = op->MACAddress[15];
949 + MACWork[11] = op->MACAddress[16];
950 + MACWork[12] = '\0';
951 + *var_len = 6;
952 + return ( UCHAR * ) htob ( MACWork );
953 +
954 + case DOT11RTSTHRESHOLD:
955 +// *write_method = write_dot11RTSThreshold;
956 + return ( UCHAR * ) &op->RTSThreshold;
957 +
958 + case DOT11SHORTRETRYLIMIT:
959 +// *write_method = write_dot11ShortRetryLimit;
960 + return ( UCHAR * ) &op->shortRetryLimit;
961 +
962 + case DOT11LONGRETRYLIMIT:
963 +// *write_method = write_dot11LongRetryLimit;
964 + return ( UCHAR * ) &op->longRetryLimit;
965 +
966 + case DOT11FRAGMENTATIONTHRESHOLD:
967 +// *write_method = write_dot11FragmentationThreshold;
968 + return ( UCHAR * ) &op->fragmentationThreshold;
969 +
970 + case DOT11MAXTRANSMITMSDULIFETIME:
971 +// *write_method = write_dot11MaxTransmitMSDULifetime;
972 + return ( UCHAR * ) &op->maxTransmitMSDULifetime;
973 +
974 + case DOT11MAXRECEIVELIFETIME:
975 +// *write_method = write_dot11MaxReceiveLifetime;
976 + return ( UCHAR * ) &op->maxReceiveLifetime;
977 +
978 + case DOT11MANUFACTURERID:
979 + *var_len = strlen ( op->manufacturerID );
980 + return ( UCHAR * ) op->manufacturerID;
981 +
982 + case DOT11PRODUCTID:
983 + *var_len = strlen ( op->productID );
984 + return ( UCHAR * ) op->productID;
985 +
986 + default:
987 + ERROR_MSG ( "" );
988 + }
989 +
990 + return NULL;
991 +}
992 +
993 +/****************************************************************************
994 +* *
995 +* var_dot11CountersTable() - *
996 +* *
997 +****************************************************************************/
998 +unsigned char *
999 +var_dot11CountersTable(struct variable *vp,
1000 + oid *name,
1001 + size_t *length,
1002 + int exact,
1003 + size_t *var_len,
1004 + WriteMethod **write_method)
1005 +{
1006 + int found = FALSE;
1007 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1008 +
1009 + loadTables();
1010 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1011 + for ( np = LIST_FIRST ( &coList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1012 + co = ( struct coTbl_data * ) np->data;
1013 + rName[vp->namelen] = co->ifIndex;
1014 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1015 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1016 + switch ( vp->magic ) {
1017 + case DOT11TRANSMITTEDFRAGMENTCOUNT:
1018 + if ( co->haveTransmittedFragmentCount ) found = TRUE; break;
1019 + case DOT11MULTICASTTRANSMITTEDFRAMECOUNT:
1020 + if ( co->haveTransmittedFrameCount ) found = TRUE; break;
1021 + case DOT11FAILEDCOUNT:
1022 + if ( co->haveFailedCount ) found = TRUE; break;
1023 + case DOT11RETRYCOUNT:
1024 + if ( co->haveRetryCount ) found = TRUE; break;
1025 + case DOT11MULTIPLERETRYCOUNT:
1026 + if ( co->haveMultipleRetryCount ) found = TRUE; break;
1027 + case DOT11FRAMEDUPLICATECOUNT:
1028 + if ( co->haveFrameDuplicateCount ) found = TRUE; break;
1029 + case DOT11RTSSUCCESSCOUNT:
1030 + if ( co->haveRTSSuccessCount ) found = TRUE; break;
1031 + case DOT11RTSFAILURECOUNT:
1032 + if ( co->haveRTSFailureCount ) found = TRUE; break;
1033 + case DOT11ACKFAILURECOUNT:
1034 + if ( co->haveACKFailureCount ) found = TRUE; break;
1035 + case DOT11RECEIVEDFRAGMENTCOUNT:
1036 + if ( co->haveReceivedFragmentCount ) found = TRUE; break;
1037 + case DOT11MULTICASTRECEIVEDFRAMECOUNT:
1038 + if ( co->haveMulticastReceivedFrameCount ) found = TRUE; break;
1039 + case DOT11FCSERRORCOUNT:
1040 + if ( co->haveFCSErrorCount ) found = TRUE; break;
1041 + case DOT11TRANSMITTEDFRAMECOUNT:
1042 + if ( co->haveTransmittedFrameCount ) found = TRUE; break;
1043 + case DOT11WEPUNDECRYPTABLECOUNT:
1044 + if ( co->haveWEPUndecryptableCount ) found = TRUE; break;
1045 + }
1046 + }
1047 + if ( found )
1048 + break;
1049 + }
1050 +
1051 + if ( !found )
1052 + return NULL;
1053 +
1054 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1055 + *length = vp->namelen + 1;
1056 + *var_len = sizeof ( long );
1057 + *write_method = NULL;
1058 +
1059 + switch ( vp->magic ) {
1060 +
1061 + case DOT11TRANSMITTEDFRAGMENTCOUNT: return ( UCHAR * ) &co->transmittedFragmentCount;
1062 + case DOT11MULTICASTTRANSMITTEDFRAMECOUNT: return ( UCHAR * ) &co->transmittedFrameCount;
1063 + case DOT11FAILEDCOUNT: return ( UCHAR * ) &co->failedCount;
1064 + case DOT11RETRYCOUNT: return ( UCHAR * ) &co->retryCount;
1065 + case DOT11MULTIPLERETRYCOUNT: return ( UCHAR * ) &co->multipleRetryCount;
1066 + case DOT11FRAMEDUPLICATECOUNT: return ( UCHAR * ) &co->frameDuplicateCount;
1067 + case DOT11RTSSUCCESSCOUNT: return ( UCHAR * ) &co->RTSSuccessCount;
1068 + case DOT11RTSFAILURECOUNT: return ( UCHAR * ) &co->RTSFailureCount;
1069 + case DOT11ACKFAILURECOUNT: return ( UCHAR * ) &co->ACKFailureCount;
1070 + case DOT11RECEIVEDFRAGMENTCOUNT: return ( UCHAR * ) &co->receivedFragmentCount;
1071 + case DOT11MULTICASTRECEIVEDFRAMECOUNT: return ( UCHAR * ) &co->multicastReceivedFrameCount;
1072 + case DOT11FCSERRORCOUNT: return ( UCHAR * ) &co->FCSErrorCount;
1073 + case DOT11TRANSMITTEDFRAMECOUNT: return ( UCHAR * ) &co->transmittedFrameCount;
1074 + case DOT11WEPUNDECRYPTABLECOUNT: return ( UCHAR * ) &co->WEPUndecryptableCount;
1075 +
1076 + default:
1077 + ERROR_MSG ( "" );
1078 + }
1079 +
1080 + return NULL;
1081 +}
1082 +
1083 +/****************************************************************************
1084 +* *
1085 +* var_dot11GroupAddressesTable() - *
1086 +* *
1087 +****************************************************************************/
1088 +unsigned char *
1089 +var_dot11GroupAddressesTable(struct variable *vp,
1090 + oid *name,
1091 + size_t *length,
1092 + int exact,
1093 + size_t *var_len,
1094 + WriteMethod **write_method)
1095 +{
1096 + static char MACWork[17];
1097 + int found = FALSE;
1098 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1099 +
1100 + loadTables();
1101 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1102 + for ( np = LIST_FIRST ( &gaList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1103 + ga = ( struct gaTbl_data * ) np->data;
1104 + rName[vp->namelen + 0] = ga->ifIndex;
1105 + rName[vp->namelen + 1] = ga->groupAddressesIndex;
1106 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
1107 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
1108 + switch ( vp->magic ) {
1109 + case DOT11ADDRESS:
1110 + if ( ga->haveAddress ) found = TRUE; break;
1111 + case DOT11GROUPADDRESSESSTATUS:
1112 + if ( ga->haveGroupAddressesStatus ) found = TRUE; break;
1113 + }
1114 + }
1115 + if ( found )
1116 + break;
1117 + }
1118 +
1119 + if ( !found )
1120 + return NULL;
1121 +
1122 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
1123 + *length = vp->namelen + 2;
1124 + *var_len = sizeof ( long );
1125 + *write_method = NULL;
1126 +
1127 + switch ( vp->magic ) {
1128 +
1129 + case DOT11ADDRESS:
1130 +// *write_method = write_dot11Address;
1131 + MACWork[ 0] = ga->address[ 0];
1132 + MACWork[ 1] = ga->address[ 1];
1133 + MACWork[ 2] = ga->address[ 3];
1134 + MACWork[ 3] = ga->address[ 4];
1135 + MACWork[ 4] = ga->address[ 6];
1136 + MACWork[ 5] = ga->address[ 7];
1137 + MACWork[ 6] = ga->address[ 9];
1138 + MACWork[ 7] = ga->address[10];
1139 + MACWork[ 8] = ga->address[12];
1140 + MACWork[ 9] = ga->address[13];
1141 + MACWork[10] = ga->address[15];
1142 + MACWork[11] = ga->address[16];
1143 + MACWork[12] = '\0';
1144 + *var_len = 6;
1145 + return ( UCHAR * ) htob ( MACWork );
1146 +
1147 + case DOT11GROUPADDRESSESSTATUS:
1148 +// *write_method = write_dot11GroupAddressesStatus;
1149 + return ( UCHAR * ) &ga->groupAddressesStatus;
1150 +
1151 + default:
1152 + ERROR_MSG ( "" );
1153 + }
1154 + return NULL;
1155 +}
1156 +
1157 +/****************************************************************************
1158 +* *
1159 +* var_dot11ResourceInfoTable() - *
1160 +* *
1161 +****************************************************************************/
1162 +unsigned char *
1163 +var_dot11ResourceInfoTable ( struct variable *vp,
1164 + oid *name,
1165 + size_t *length,
1166 + int exact,
1167 + size_t *var_len,
1168 + WriteMethod **write_method )
1169 +{
1170 + int found = FALSE;
1171 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1172 +
1173 + loadTables();
1174 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1175 + for ( np = LIST_FIRST ( &riList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1176 + ri = ( struct riTbl_data * ) np->data;
1177 + rName[vp->namelen] = ri->ifIndex;
1178 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1179 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1180 + switch ( vp->magic ) {
1181 + case DOT11MANUFACTUREROUI:
1182 + if ( ri->haveManufacturerOUI ) found = TRUE; break;
1183 + case DOT11MANUFACTURERNAME:
1184 + if ( ri->haveManufacturerName ) found = TRUE; break;
1185 + case DOT11MANUFACTURERPRODUCTNAME:
1186 + if ( ri->haveManufacturerProductName ) found = TRUE; break;
1187 + case DOT11MANUFACTURERPRODUCTVERSION:
1188 + if ( ri->haveManufacturerProductVersion ) found = TRUE; break;
1189 + }
1190 + }
1191 + if ( found )
1192 + break;
1193 + }
1194 +
1195 + if ( !found )
1196 + return NULL;
1197 +
1198 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1199 + *length = vp->namelen + 1;
1200 + *var_len = sizeof ( long );
1201 + *write_method = NULL;
1202 +
1203 + switch ( vp->magic ) {
1204 +
1205 + case DOT11MANUFACTUREROUI:
1206 + *var_len = strlen ( ri->manufacturerOUI );
1207 + return ( UCHAR * ) ri->manufacturerOUI;
1208 +
1209 + case DOT11MANUFACTURERNAME:
1210 + *var_len = strlen ( ri->manufacturerName );
1211 + return ( UCHAR * ) ri->manufacturerName;
1212 +
1213 + case DOT11MANUFACTURERPRODUCTNAME:
1214 + *var_len = strlen ( ri->manufacturerProductName );
1215 + return ( UCHAR * ) ri->manufacturerProductName;
1216 +
1217 + case DOT11MANUFACTURERPRODUCTVERSION:
1218 + *var_len = strlen ( ri->manufacturerProductVersion );
1219 + return ( UCHAR * ) ri->manufacturerProductVersion;
1220 +
1221 + default:
1222 + ERROR_MSG ( "" );
1223 + }
1224 +
1225 + return NULL;
1226 +}
1227 +
1228 +/****************************************************************************
1229 +* *
1230 +* var_dot11PhyOperationTable() - *
1231 +* *
1232 +****************************************************************************/
1233 +unsigned char *
1234 +var_dot11PhyOperationTable ( struct variable *vp,
1235 + oid *name,
1236 + size_t *length,
1237 + int exact,
1238 + size_t *var_len,
1239 + WriteMethod **write_method )
1240 +{
1241 + int found = FALSE;
1242 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1243 +
1244 + loadTables();
1245 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1246 + for ( np = LIST_FIRST ( &poList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1247 + po = ( struct poTbl_data * ) np->data;
1248 + rName[vp->namelen] = po->ifIndex;
1249 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1250 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1251 + switch ( vp->magic ) {
1252 + case DOT11PHYTYPE:
1253 + if ( po->havePHYType ) found = TRUE; break;
1254 + case DOT11CURRENTREGDOMAIN:
1255 + if ( po->haveCurrentRegDomain ) found = TRUE; break;
1256 + case DOT11TEMPTYPE:
1257 + if ( po->haveTempType ) found = TRUE; break;
1258 + }
1259 + }
1260 + if ( found )
1261 + break;
1262 + }
1263 +
1264 + if ( !found )
1265 + return NULL;
1266 +
1267 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1268 + *length = vp->namelen + 1;
1269 + *var_len = sizeof ( long );
1270 + *write_method = NULL;
1271 +
1272 + switch ( vp->magic ) {
1273 +
1274 + case DOT11PHYTYPE:
1275 + return ( UCHAR * ) &po->PHYType;
1276 +
1277 + case DOT11CURRENTREGDOMAIN:
1278 +// *write_method = write_dot11CurrentRegDomain;
1279 + return ( UCHAR * ) &po->currentRegDomain;
1280 +
1281 + case DOT11TEMPTYPE:
1282 + return ( UCHAR * ) &po->tempType;
1283 +
1284 + default:
1285 + ERROR_MSG ( "" );
1286 + }
1287 +
1288 + return NULL;
1289 +}
1290 +
1291 +/****************************************************************************
1292 +* *
1293 +* var_dot11PhyAntennaTable() - *
1294 +* *
1295 +****************************************************************************/
1296 +unsigned char *
1297 +var_dot11PhyAntennaTable ( struct variable *vp,
1298 + oid *name,
1299 + size_t *length,
1300 + int exact,
1301 + size_t *var_len,
1302 + WriteMethod **write_method )
1303 +{
1304 + int found = FALSE;
1305 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1306 +
1307 + loadTables();
1308 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1309 + for ( np = LIST_FIRST ( &paList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1310 + pa = ( struct paTbl_data * ) np->data;
1311 + rName[vp->namelen] = pa->ifIndex;
1312 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1313 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1314 + switch ( vp->magic ) {
1315 + case DOT11CURRENTTXANTENNA:
1316 + if ( pa->haveCurrentTxAntenna ) found = TRUE; break;
1317 + case DOT11DIVERSITYSUPPORT:
1318 + if ( pa->haveDiversitySupport ) found = TRUE; break;
1319 + case DOT11CURRENTRXANTENNA:
1320 + if ( pa->haveCurrentRxAntenna ) found = TRUE; break;
1321 + }
1322 + }
1323 + if ( found )
1324 + break;
1325 + }
1326 +
1327 + if ( !found )
1328 + return NULL;
1329 +
1330 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1331 + *length = vp->namelen + 1;
1332 + *var_len = sizeof ( long );
1333 + *write_method = NULL;
1334 +
1335 + switch ( vp->magic ) {
1336 +
1337 + case DOT11CURRENTTXANTENNA:
1338 +// *write_method = write_dot11CurrentTxAntenna;
1339 + return ( UCHAR * ) &pa->currentTxAntenna;
1340 +
1341 + case DOT11DIVERSITYSUPPORT:
1342 + return ( UCHAR * ) &pa->diversitySupport;
1343 +
1344 + case DOT11CURRENTRXANTENNA:
1345 +// *write_method = write_dot11CurrentRxAntenna;
1346 + return ( UCHAR * ) &pa->currentRxAntenna;
1347 +
1348 + default:
1349 + ERROR_MSG ( "" );
1350 + }
1351 + return NULL;
1352 +}
1353 +
1354 +/****************************************************************************
1355 +* *
1356 +* var_dot11PhyTxPowerTable() - *
1357 +* *
1358 +****************************************************************************/
1359 +unsigned char *
1360 +var_dot11PhyTxPowerTable ( struct variable *vp,
1361 + oid *name,
1362 + size_t *length,
1363 + int exact,
1364 + size_t *var_len,
1365 + WriteMethod **write_method )
1366 +{
1367 + int found = FALSE;
1368 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1369 +
1370 + loadTables();
1371 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1372 + for ( np = LIST_FIRST ( &ptList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1373 + pt = ( struct ptTbl_data * ) np->data;
1374 + rName[vp->namelen] = pt->ifIndex;
1375 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1376 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1377 + switch ( vp->magic ) {
1378 + case DOT11NUMBERSUPPORTEDPOWERLEVELS:
1379 + if ( pt->haveNumberSupportedPowerLevels ) found = TRUE; break;
1380 + case DOT11TXPOWERLEVEL1:
1381 + if ( pt->haveTxPowerLevel1 ) found = TRUE; break;
1382 + case DOT11TXPOWERLEVEL2:
1383 + if ( pt->haveTxPowerLevel2 ) found = TRUE; break;
1384 + case DOT11TXPOWERLEVEL3:
1385 + if ( pt->haveTxPowerLevel3 ) found = TRUE; break;
1386 + case DOT11TXPOWERLEVEL4:
1387 + if ( pt->haveTxPowerLevel4 ) found = TRUE; break;
1388 + case DOT11TXPOWERLEVEL5:
1389 + if ( pt->haveTxPowerLevel5 ) found = TRUE; break;
1390 + case DOT11TXPOWERLEVEL6:
1391 + if ( pt->haveTxPowerLevel6 ) found = TRUE; break;
1392 + case DOT11TXPOWERLEVEL7:
1393 + if ( pt->haveTxPowerLevel7 ) found = TRUE; break;
1394 + case DOT11TXPOWERLEVEL8:
1395 + if ( pt->haveTxPowerLevel8 ) found = TRUE; break;
1396 + case DOT11CURRENTTXPOWERLEVEL:
1397 + if ( pt->currentTxPowerLevel ) found = TRUE; break;
1398 + }
1399 + }
1400 + if ( found )
1401 + break;
1402 + }
1403 +
1404 + if ( !found )
1405 + return NULL;
1406 +
1407 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1408 + *length = vp->namelen + 1;
1409 + *var_len = sizeof ( long );
1410 + *write_method = NULL;
1411 +
1412 + switch ( vp->magic ) {
1413 +
1414 + case DOT11NUMBERSUPPORTEDPOWERLEVELS:
1415 + return ( UCHAR * ) &pt->numberSupportedPowerLevels;
1416 +
1417 + case DOT11TXPOWERLEVEL1: return ( UCHAR * ) &pt->TxPowerLevel1;
1418 + case DOT11TXPOWERLEVEL2: return ( UCHAR * ) &pt->TxPowerLevel2;
1419 + case DOT11TXPOWERLEVEL3: return ( UCHAR * ) &pt->TxPowerLevel3;
1420 + case DOT11TXPOWERLEVEL4: return ( UCHAR * ) &pt->TxPowerLevel4;
1421 + case DOT11TXPOWERLEVEL5: return ( UCHAR * ) &pt->TxPowerLevel5;
1422 + case DOT11TXPOWERLEVEL6: return ( UCHAR * ) &pt->TxPowerLevel6;
1423 + case DOT11TXPOWERLEVEL7: return ( UCHAR * ) &pt->TxPowerLevel7;
1424 + case DOT11TXPOWERLEVEL8: return ( UCHAR * ) &pt->TxPowerLevel8;
1425 +
1426 + case DOT11CURRENTTXPOWERLEVEL:
1427 +// *write_method = write_dot11CurrentTxPowerLevel;
1428 + return ( UCHAR * ) &pt->currentTxPowerLevel;
1429 +
1430 + default:
1431 + ERROR_MSG ( "" );
1432 + }
1433 +
1434 + return NULL;
1435 +}
1436 +
1437 +/****************************************************************************
1438 +* *
1439 +* var_dot11PhyFHSSTable() - *
1440 +* *
1441 +****************************************************************************/
1442 +unsigned char *
1443 +var_dot11PhyFHSSTable ( struct variable *vp,
1444 + oid *name,
1445 + size_t *length,
1446 + int exact,
1447 + size_t *var_len,
1448 + WriteMethod **write_method )
1449 +{
1450 + int found = FALSE;
1451 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1452 +
1453 + loadTables();
1454 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1455 + for ( np = LIST_FIRST ( &pfList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1456 + pf = ( struct pfTbl_data * ) np->data;
1457 + rName[vp->namelen] = pf->ifIndex;
1458 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1459 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1460 + switch ( vp->magic ) {
1461 + case DOT11HOPTIME:
1462 + if ( pf->haveHopTime ) found = TRUE; break;
1463 + case DOT11CURRENTCHANNELNUMBER:
1464 + if ( pf->haveCurrentChannelNumber ) found = TRUE; break;
1465 + case DOT11MAXDWELLTIME:
1466 + if ( pf->haveMaxDwellTime ) found = TRUE; break;
1467 + case DOT11CURRENTDWELLTIME:
1468 + if ( pf->haveCurrentDwellTime ) found = TRUE; break;
1469 + case DOT11CURRENTSET:
1470 + if ( pf->haveCurrentSet ) found = TRUE; break;
1471 + case DOT11CURRENTPATTERN:
1472 + if ( pf->haveCurrentPattern ) found = TRUE; break;
1473 + case DOT11CURRENTINDEX:
1474 + if ( pf->haveCurrentIndex ) found = TRUE; break;
1475 + }
1476 + }
1477 + if ( found )
1478 + break;
1479 + }
1480 +
1481 + if ( !found )
1482 + return NULL;
1483 +
1484 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1485 + *length = vp->namelen + 1;
1486 + *var_len = sizeof ( long );
1487 + *write_method = NULL;
1488 +
1489 + switch ( vp->magic ) {
1490 +
1491 + case DOT11HOPTIME:
1492 + return ( UCHAR * ) &pf->hopTime;
1493 +
1494 + case DOT11CURRENTCHANNELNUMBER:
1495 +// *write_method = write_dot11CurrentChannelNumber;
1496 + return ( UCHAR * ) &pf->currentChannelNumber;
1497 +
1498 + case DOT11MAXDWELLTIME:
1499 + return ( UCHAR * ) &pf->maxDwellTime;
1500 +
1501 + case DOT11CURRENTDWELLTIME:
1502 +// *write_method = write_dot11CurrentDwellTime;
1503 + return ( UCHAR * ) &pf->currentDwellTime;
1504 +
1505 + case DOT11CURRENTSET:
1506 +// *write_method = write_dot11CurrentSet;
1507 + return ( UCHAR * ) &pf->currentSet;
1508 +
1509 + case DOT11CURRENTPATTERN:
1510 +// *write_method = write_dot11CurrentPattern;
1511 + return ( UCHAR * ) &pf->currentPattern;
1512 +
1513 + case DOT11CURRENTINDEX:
1514 +// *write_method = write_dot11CurrentIndex;
1515 + return ( UCHAR * ) &pf->currentIndex;
1516 +
1517 + default:
1518 + ERROR_MSG ( "" );
1519 + }
1520 +
1521 + return NULL;
1522 +}
1523 +
1524 +/****************************************************************************
1525 +* *
1526 +* var_dot11PhyDSSSTable() - *
1527 +* *
1528 +****************************************************************************/
1529 +unsigned char *
1530 +var_dot11PhyDSSSTable ( struct variable *vp,
1531 + oid *name,
1532 + size_t *length,
1533 + int exact,
1534 + size_t *var_len,
1535 + WriteMethod **write_method )
1536 +{
1537 + int found = FALSE;
1538 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1539 +
1540 + loadTables();
1541 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1542 + for ( np = LIST_FIRST ( &pdList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1543 + pd = ( struct pdTbl_data * ) np->data;
1544 + rName[vp->namelen] = pd->ifIndex;
1545 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1546 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1547 + switch ( vp->magic ) {
1548 + case DOT11CURRENTCHANNEL:
1549 + if ( pd->haveCurrentChannel ) found = TRUE; break;
1550 + case DOT11CCAMODESUPPORTED:
1551 + if ( pd->haveCCAModeSupported ) found = TRUE; break;
1552 + case DOT11CURRENTCCAMODE:
1553 + if ( pd->haveCurrentCCAMode ) found = TRUE; break;
1554 + case DOT11EDTHRESHOLD:
1555 + if ( pd->haveEDThreshold ) found = TRUE; break;
1556 + }
1557 + }
1558 + if ( found )
1559 + break;
1560 + }
1561 +
1562 + if ( !found )
1563 + return NULL;
1564 +
1565 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1566 + *length = vp->namelen + 1;
1567 + *var_len = sizeof ( long );
1568 + *write_method = NULL;
1569 +
1570 + switch ( vp->magic ) {
1571 +
1572 + case DOT11CURRENTCHANNEL:
1573 +// *write_method = write_dot11CurrentChannel;
1574 + return ( UCHAR * ) &pd->currentChannel;
1575 +
1576 + case DOT11CCAMODESUPPORTED:
1577 + return ( UCHAR * ) &pd->CCAModeSupported;
1578 +
1579 + case DOT11CURRENTCCAMODE:
1580 +// *write_method = write_dot11CurrentCCAMode;
1581 + return ( UCHAR * ) &pd->currentCCAMode;
1582 +
1583 + case DOT11EDTHRESHOLD:
1584 +// *write_method = write_dot11EDThreshold;
1585 + return ( UCHAR * ) &pd->EDThreshold;
1586 +
1587 + default:
1588 + ERROR_MSG ( "" );
1589 + }
1590 +
1591 + return NULL;
1592 +}
1593 +
1594 +/****************************************************************************
1595 +* *
1596 +* var_dot11PhyIRTable() - *
1597 +* *
1598 +****************************************************************************/
1599 +unsigned char *
1600 +var_dot11PhyIRTable ( struct variable *vp,
1601 + oid *name,
1602 + size_t *length,
1603 + int exact,
1604 + size_t *var_len,
1605 + WriteMethod **write_method)
1606 +{
1607 +
1608 + int found = FALSE;
1609 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1610 +
1611 + loadTables();
1612 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1613 + for ( np = LIST_FIRST ( &piList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1614 + pi = ( struct piTbl_data * ) np->data;
1615 + rName[vp->namelen] = pi->ifIndex;
1616 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
1617 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) > 0 ))) {
1618 + switch ( vp->magic ) {
1619 + case DOT11CCAWATCHDOGTIMERMAX:
1620 + if ( pi->CCAWatchdogTimerMax ) found = TRUE; break;
1621 + case DOT11CCAWATCHDOGCOUNTMAX:
1622 + if ( pi->CCAWatchdogCountMax ) found = TRUE; break;
1623 + case DOT11CCAWATCHDOGTIMERMIN:
1624 + if ( pi->CCAWatchdogTimerMin ) found = TRUE; break;
1625 + case DOT11CCAWATCHDOGCOUNTMIN:
1626 + if ( pi->CCAWatchdogCountMin ) found = TRUE; break;
1627 + }
1628 + }
1629 + if ( found )
1630 + break;
1631 + }
1632 +
1633 + if ( !found )
1634 + return NULL;
1635 +
1636 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
1637 + *length = vp->namelen + 1;
1638 + *var_len = sizeof ( long );
1639 + *write_method = NULL;
1640 +
1641 + switch ( vp->magic ) {
1642 +
1643 + case DOT11CCAWATCHDOGTIMERMAX:
1644 +// *write_method = write_dot11CCAWatchdogTimerMax;
1645 + return ( UCHAR * ) &pi->CCAWatchdogTimerMax;
1646 +
1647 + case DOT11CCAWATCHDOGCOUNTMAX:
1648 +// *write_method = write_dot11CCAWatchdogCountMax;
1649 + return ( UCHAR * ) &pi->CCAWatchdogCountMax;
1650 +
1651 + case DOT11CCAWATCHDOGTIMERMIN:
1652 +// *write_method = write_dot11CCAWatchdogTimerMin;
1653 + return ( UCHAR * ) &pi->CCAWatchdogTimerMin;
1654 +
1655 + case DOT11CCAWATCHDOGCOUNTMIN:
1656 +// *write_method = write_dot11CCAWatchdogCountMin;
1657 + return ( UCHAR * ) &pi->CCAWatchdogCountMin;
1658 +
1659 + default:
1660 + ERROR_MSG ( "" );
1661 + }
1662 +
1663 + return NULL;
1664 +}
1665 +
1666 +/****************************************************************************
1667 +* *
1668 +* var_dot11RegDomainsSupportedTable() - *
1669 +* *
1670 +****************************************************************************/
1671 +unsigned char *
1672 +var_dot11RegDomainsSupportedTable ( struct variable *vp,
1673 + oid *name,
1674 + size_t *length,
1675 + int exact,
1676 + size_t *var_len,
1677 + WriteMethod **write_method)
1678 +{
1679 + int found = FALSE;
1680 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1681 +
1682 + loadTables();
1683 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1684 + for ( np = LIST_FIRST ( &rdList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1685 + rd = ( struct rdTbl_data * ) np->data;
1686 + rName[vp->namelen + 0] = rd->ifIndex;
1687 + rName[vp->namelen + 1] = rd->regDomainsSupportIndex;
1688 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
1689 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
1690 + switch ( vp->magic ) {
1691 + case DOT11REGDOMAINSSUPPORTVALUE:
1692 + if ( rd->haveRegDomainsSupportValue ) found = TRUE; break;
1693 + }
1694 + }
1695 + if ( found )
1696 + break;
1697 + }
1698 +
1699 + if ( !found )
1700 + return NULL;
1701 +
1702 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
1703 + *length = vp->namelen + 2;
1704 + *var_len = sizeof ( long );
1705 + *write_method = NULL;
1706 +
1707 + switch ( vp->magic ) {
1708 +
1709 + case DOT11REGDOMAINSSUPPORTVALUE:
1710 + return ( UCHAR * ) &rd->regDomainsSupportValue;
1711 +
1712 + default:
1713 + ERROR_MSG ( "" );
1714 + }
1715 +
1716 + return NULL;
1717 +}
1718 +
1719 +/****************************************************************************
1720 +* *
1721 +* var_dot11AntennasListTable() - *
1722 +* *
1723 +****************************************************************************/
1724 +unsigned char *
1725 +var_dot11AntennasListTable(struct variable *vp,
1726 + oid *name,
1727 + size_t *length,
1728 + int exact,
1729 + size_t *var_len,
1730 + WriteMethod **write_method)
1731 +{
1732 + int found = FALSE;
1733 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1734 +
1735 + loadTables();
1736 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1737 + for ( np = LIST_FIRST ( &alList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1738 + al = ( struct alTbl_data * ) np->data;
1739 + rName[vp->namelen + 0] = al->ifIndex;
1740 + rName[vp->namelen + 1] = al->antennaListIndex;
1741 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
1742 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
1743 + switch ( vp->magic ) {
1744 + case DOT11SUPPORTEDTXANTENNA:
1745 + if ( al->haveSupportedTxAntenna ) found = TRUE; break;
1746 + case DOT11SUPPORTEDRXANTENNA:
1747 + if ( al->haveSupportedRxAntenna ) found = TRUE; break;
1748 + case DOT11DIVERSITYSELECTIONRX:
1749 + if ( al->haveDiversitySelectionRx ) found = TRUE; break;
1750 + }
1751 + }
1752 + if ( found )
1753 + break;
1754 + }
1755 +
1756 + if ( !found )
1757 + return NULL;
1758 +
1759 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
1760 + *length = vp->namelen + 2;
1761 + *var_len = sizeof ( long );
1762 + *write_method = NULL;
1763 +
1764 + switch ( vp->magic ) {
1765 +
1766 + case DOT11SUPPORTEDTXANTENNA:
1767 +// *write_method = write_dot11SupportedTxAntenna;
1768 + return ( UCHAR * ) &al->supportedTxAntenna;
1769 +
1770 + case DOT11SUPPORTEDRXANTENNA:
1771 +// *write_method = write_dot11SupportedRxAntenna;
1772 + return ( UCHAR * ) &al->supportedRxAntenna;
1773 +
1774 + case DOT11DIVERSITYSELECTIONRX:
1775 +// *write_method = write_dot11DiversitySelectionRx;
1776 + return ( UCHAR * ) &al->diversitySelectionRx;
1777 +
1778 + default:
1779 + ERROR_MSG ( "" );
1780 + }
1781 +
1782 + return NULL;
1783 +}
1784 +
1785 +/****************************************************************************
1786 +* *
1787 +* var_dot11SupportedDataRatesTxTable() - *
1788 +* *
1789 +****************************************************************************/
1790 +unsigned char *
1791 +var_dot11SupportedDataRatesTxTable ( struct variable *vp,
1792 + oid *name,
1793 + size_t *length,
1794 + int exact,
1795 + size_t *var_len,
1796 + WriteMethod **write_method )
1797 +{
1798 + int found = FALSE;
1799 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1800 +
1801 + loadTables();
1802 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1803 + for ( np = LIST_FIRST ( &rtList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1804 + rt = ( struct rtTbl_data * ) np->data;
1805 + rName[vp->namelen + 0] = rt->ifIndex;
1806 + rName[vp->namelen + 1] = rt->supportedDataRatesTxIndex;
1807 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
1808 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
1809 + switch ( vp->magic ) {
1810 + case DOT11SUPPORTEDDATARATESTXVALUE:
1811 + if ( rt->haveSupportedDataRatesTxValue ) found = TRUE; break;
1812 + }
1813 + }
1814 + if ( found )
1815 + break;
1816 + }
1817 +
1818 + if ( !found )
1819 + return NULL;
1820 +
1821 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
1822 + *length = vp->namelen + 2;
1823 + *var_len = sizeof ( long );
1824 + *write_method = NULL;
1825 +
1826 + switch ( vp->magic ) {
1827 +
1828 + case DOT11SUPPORTEDDATARATESTXVALUE:
1829 + return ( UCHAR * ) &rt->supportedDataRatesTxValue;
1830 +
1831 + default:
1832 + ERROR_MSG ( "" );
1833 + }
1834 +
1835 + return NULL;
1836 +}
1837 +
1838 +/****************************************************************************
1839 +* *
1840 +* var_dot11SupportedDataRatesRxTable() - *
1841 +* *
1842 +****************************************************************************/
1843 +unsigned char *
1844 +var_dot11SupportedDataRatesRxTable ( struct variable *vp,
1845 + oid *name,
1846 + size_t *length,
1847 + int exact,
1848 + size_t *var_len,
1849 + WriteMethod **write_method )
1850 +{
1851 + int found = FALSE;
1852 + oid rName [ MAX_OID_LEN ]; // OID to be returned
1853 +
1854 + loadTables();
1855 + memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
1856 + for ( np = LIST_FIRST ( &rrList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
1857 + rr = ( struct rrTbl_data * ) np->data;
1858 + rName[vp->namelen + 0] = rr->ifIndex;
1859 + rName[vp->namelen + 1] = rr->supportedDataRatesRxIndex;
1860 + if (( exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
1861 + ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) > 0 ))) {
1862 + switch ( vp->magic ) {
1863 + case DOT11SUPPORTEDDATARATESRXVALUE:
1864 + if ( rr->haveSupportedDataRatesRxValue ) found = TRUE; break;
1865 + }
1866 + }
1867 + if ( found )
1868 + break;
1869 + }
1870 +
1871 + if ( !found )
1872 + return NULL;
1873 +
1874 + memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
1875 + *length = vp->namelen + 2;
1876 + *var_len = sizeof ( long );
1877 + *write_method = NULL;
1878 +
1879 + switch ( vp->magic ) {
1880 +
1881 + case DOT11SUPPORTEDDATARATESRXVALUE:
1882 + return ( UCHAR * ) &rr->supportedDataRatesRxValue;
1883 +
1884 + default:
1885 + ERROR_MSG ( "" );
1886 + }
1887 +
1888 + return NULL;
1889 +}
1890 +
1891 +/****************************************************************************
1892 +* *
1893 +****************************************************************************/
1894 +int
1895 +write_dot11StationID(int action,
1896 + u_char *var_val,
1897 + u_char var_val_type,
1898 + size_t var_val_len,
1899 + u_char *statP,
1900 + oid *name,
1901 + size_t name_len)
1902 +{
1903 + static unsigned char string[SPRINT_MAX_LEN];
1904 + int size;
1905 +
1906 + switch ( action ) {
1907 +
1908 + case RESERVE1:
1909 + if ( var_val_type != ASN_OCTET_STR ) {
1910 + fprintf ( stderr, "write to dot11StationID not ASN_OCTET_STR\n" );
1911 + return SNMP_ERR_WRONGTYPE;
1912 + }
1913 + if ( var_val_len > sizeof ( string )) {
1914 + fprintf ( stderr,"write to dot11StationID: bad length\n" );
1915 + return SNMP_ERR_WRONGLENGTH;
1916 + }
1917 + break;
1918 +
1919 + case RESERVE2:
1920 + case FREE:
1921 + case ACTION:
1922 + case UNDO:
1923 + break;
1924 +
1925 + case COMMIT:
1926 + break;
1927 + }
1928 +
1929 + return SNMP_ERR_NOERROR;
1930 +}
1931 +
1932 +/****************************************************************************
1933 +* *
1934 +****************************************************************************/
1935 +int
1936 +write_dot11MediumOccupancyLimit(int action,
1937 + u_char *var_val,
1938 + u_char var_val_type,
1939 + size_t var_val_len,
1940 + u_char *statP,
1941 + oid *name,
1942 + size_t name_len)
1943 +{
1944 + static long *long_ret;
1945 + int size;
1946 +
1947 + switch ( action ) {
1948 +
1949 + case RESERVE1:
1950 + if ( var_val_type != ASN_INTEGER ) {
1951 + fprintf ( stderr, "write to dot11MediumOccupancyLimit not ASN_INTEGER\n" );
1952 + return SNMP_ERR_WRONGTYPE;
1953 + }
1954 + if ( var_val_len > sizeof ( long_ret )){
1955 + fprintf ( stderr,"write to dot11MediumOccupancyLimit: bad length\n" );
1956 + return SNMP_ERR_WRONGLENGTH;
1957 + }
1958 + break;
1959 +
1960 + case RESERVE2:
1961 + case FREE:
1962 + case ACTION:
1963 + case UNDO:
1964 + break;
1965 +
1966 + case COMMIT:
1967 + break;
1968 + }
1969 +
1970 + return SNMP_ERR_NOERROR;
1971 +}
1972 +
1973 +/****************************************************************************
1974 +* *
1975 +****************************************************************************/
1976 +int
1977 +write_dot11CFPPeriod(int action,
1978 + u_char *var_val,
1979 + u_char var_val_type,
1980 + size_t var_val_len,
1981 + u_char *statP,
1982 + oid *name,
1983 + size_t name_len)
1984 +{
1985 + static long *long_ret;
1986 + int size;
1987 +
1988 + switch ( action ) {
1989 +
1990 + case RESERVE1:
1991 + if ( var_val_type != ASN_INTEGER ) {
1992 + fprintf ( stderr, "write to dot11CFPPeriod not ASN_INTEGER\n" );
1993 + return SNMP_ERR_WRONGTYPE;
1994 + }
1995 + if ( var_val_len > sizeof ( long_ret )){
1996 + fprintf ( stderr, "write to dot11CFPPeriod: bad length\n" );
1997 + return SNMP_ERR_WRONGLENGTH;
1998 + }
1999 + break;
2000 +
2001 + case RESERVE2:
2002 + case FREE:
2003 + case ACTION:
2004 + case UNDO:
2005 + break;
2006 +
2007 + case COMMIT:
2008 + break;
2009 + }
2010 +
2011 + return SNMP_ERR_NOERROR;
2012 +}
2013 +
2014 +/****************************************************************************
2015 +* *
2016 +****************************************************************************/
2017 +int
2018 +write_dot11CFPMaxDuration(int action,
2019 + u_char *var_val,
2020 + u_char var_val_type,
2021 + size_t var_val_len,
2022 + u_char *statP,
2023 + oid *name,
2024 + size_t name_len)
2025 +{
2026 + static long *long_ret;
2027 + int size;
2028 +
2029 + switch ( action ) {
2030 +
2031 + case RESERVE1:
2032 + if ( var_val_type != ASN_INTEGER ) {
2033 + fprintf ( stderr, "write to dot11CFPMaxDuration not ASN_INTEGER\n" );
2034 + return SNMP_ERR_WRONGTYPE;
2035 + }
2036 + if ( var_val_len > sizeof ( long_ret )){
2037 + fprintf ( stderr, "write to dot11CFPMaxDuration: bad length\n" );
2038 + return SNMP_ERR_WRONGLENGTH;
2039 + }
2040 + break;
2041 +
2042 + case RESERVE2:
2043 + case FREE:
2044 + case ACTION:
2045 + case UNDO:
2046 + break;
2047 +
2048 + case COMMIT:
2049 + break;
2050 + }
2051 +
2052 + return SNMP_ERR_NOERROR;
2053 +}
2054 +
2055 +/****************************************************************************
2056 +* *
2057 +****************************************************************************/
2058 +int
2059 +write_dot11AuthenticationResponseTimeOut(int action,
2060 + u_char *var_val,
2061 + u_char var_val_type,
2062 + size_t var_val_len,
2063 + u_char *statP,
2064 + oid *name,
2065 + size_t name_len)
2066 +{
2067 + static long *long_ret;
2068 + int size;
2069 +
2070 + switch ( action ) {
2071 +
2072 + case RESERVE1:
2073 + if ( var_val_type != ASN_INTEGER ) {
2074 + fprintf ( stderr, "write to dot11AuthenticationResponseTimeOut not ASN_INTEGER\n" );
2075 + return SNMP_ERR_WRONGTYPE;
2076 + }
2077 + if ( var_val_len > sizeof ( long_ret )){
2078 + fprintf ( stderr, "write to dot11AuthenticationResponseTimeOut: bad length\n" );
2079 + return SNMP_ERR_WRONGLENGTH;
2080 + }
2081 + break;
2082 +
2083 + case RESERVE2:
2084 + case FREE:
2085 + case ACTION:
2086 + case UNDO:
2087 + break;
2088 +
2089 + case COMMIT:
2090 + break;
2091 + }
2092 +
2093 + return SNMP_ERR_NOERROR;
2094 +}
2095 +
2096 +/****************************************************************************
2097 +* *
2098 +****************************************************************************/
2099 +int
2100 +write_dot11PowerManagementMode(int action,
2101 + u_char *var_val,
2102 + u_char var_val_type,
2103 + size_t var_val_len,
2104 + u_char *statP,
2105 + oid *name,
2106 + size_t name_len)
2107 +{
2108 + static long *long_ret;
2109 + int size;
2110 +
2111 + switch ( action ) {
2112 +
2113 + case RESERVE1:
2114 + if ( var_val_type != ASN_INTEGER ) {
2115 + fprintf ( stderr, "write to dot11PowerManagementMode not ASN_INTEGER\n" );
2116 + return SNMP_ERR_WRONGTYPE;
2117 + }
2118 + if ( var_val_len > sizeof ( long_ret )) {
2119 + fprintf ( stderr, "write to dot11PowerManagementMode: bad length\n" );
2120 + return SNMP_ERR_WRONGLENGTH;
2121 + }
2122 + break;
2123 +
2124 + case RESERVE2:
2125 + case FREE:
2126 + case ACTION:
2127 + case UNDO:
2128 + break;
2129 +
2130 + case COMMIT:
2131 + break;
2132 + }
2133 +
2134 + return SNMP_ERR_NOERROR;
2135 +}
2136 +
2137 +/****************************************************************************
2138 +* *
2139 +****************************************************************************/
2140 +int
2141 +write_dot11DesiredSSID(int action,
2142 + u_char *var_val,
2143 + u_char var_val_type,
2144 + size_t var_val_len,
2145 + u_char *statP,
2146 + oid *name,
2147 + size_t name_len)
2148 +{
2149 + static unsigned char string[SPRINT_MAX_LEN];
2150 + int size;
2151 +
2152 + switch ( action ) {
2153 +
2154 + case RESERVE1:
2155 + if ( var_val_type != ASN_OCTET_STR ) {
2156 + fprintf ( stderr, "write to dot11DesiredSSID not ASN_OCTET_STR\n" );
2157 + return SNMP_ERR_WRONGTYPE;
2158 + }
2159 + if ( var_val_len > sizeof ( string )){
2160 + fprintf ( stderr, "write to dot11DesiredSSID: bad length\n" );
2161 + return SNMP_ERR_WRONGLENGTH;
2162 + }
2163 + break;
2164 +
2165 + case RESERVE2:
2166 + case FREE:
2167 + case ACTION:
2168 + case UNDO:
2169 + break;
2170 +
2171 + case COMMIT:
2172 + break;
2173 + }
2174 +
2175 + return SNMP_ERR_NOERROR;
2176 +}
2177 +
2178 +/****************************************************************************
2179 +* *
2180 +****************************************************************************/
2181 +int
2182 +write_dot11DesiredBSSType(int action,
2183 + u_char *var_val,
2184 + u_char var_val_type,
2185 + size_t var_val_len,
2186 + u_char *statP,
2187 + oid *name,
2188 + size_t name_len)
2189 +{
2190 + static long *long_ret;
2191 + int size;
2192 +
2193 + switch ( action ) {
2194 +
2195 + case RESERVE1:
2196 + if ( var_val_type != ASN_INTEGER ) {
2197 + fprintf ( stderr, "write to dot11DesiredBSSType not ASN_INTEGER\n" );
2198 + return SNMP_ERR_WRONGTYPE;
2199 + }
2200 + if ( var_val_len > sizeof ( long_ret )){
2201 + fprintf ( stderr, "write to dot11DesiredBSSType: bad length\n" );
2202 + return SNMP_ERR_WRONGLENGTH;
2203 + }
2204 + break;
2205 +
2206 + case RESERVE2:
2207 + case FREE:
2208 + case ACTION:
2209 + case UNDO:
2210 + break;
2211 +
2212 + case COMMIT:
2213 + break;
2214 + }
2215 +
2216 + return SNMP_ERR_NOERROR;
2217 +}
2218 +
2219 +/****************************************************************************
2220 +* *
2221 +****************************************************************************/
2222 +int
2223 +write_dot11OperationalRateSet(int action,
2224 + u_char *var_val,
2225 + u_char var_val_type,
2226 + size_t var_val_len,
2227 + u_char *statP,
2228 + oid *name,
2229 + size_t name_len)
2230 +{
2231 + static unsigned char string[SPRINT_MAX_LEN];
2232 + int size;
2233 +
2234 + switch ( action ) {
2235 +
2236 + case RESERVE1:
2237 + if ( var_val_type != ASN_OCTET_STR ) {
2238 + fprintf ( stderr, "write to dot11OperationalRateSet not ASN_OCTET_STR\n" );
2239 + return SNMP_ERR_WRONGTYPE;
2240 + }
2241 + if ( var_val_len > sizeof ( string )){
2242 + fprintf ( stderr, "write to dot11OperationalRateSet: bad length\n" );
2243 + return SNMP_ERR_WRONGLENGTH;
2244 + }
2245 + break;
2246 +
2247 + case RESERVE2:
2248 + case FREE:
2249 + case ACTION:
2250 + case UNDO:
2251 + break;
2252 +
2253 + case COMMIT:
2254 + break;
2255 + }
2256 +
2257 + return SNMP_ERR_NOERROR;
2258 +}
2259 +
2260 +/****************************************************************************
2261 +* *
2262 +****************************************************************************/
2263 +int
2264 +write_dot11BeaconPeriod(int action,
2265 + u_char *var_val,
2266 + u_char var_val_type,
2267 + size_t var_val_len,
2268 + u_char *statP,
2269 + oid *name,
2270 + size_t name_len)
2271 +{
2272 + static long *long_ret;
2273 + int size;
2274 +
2275 + switch ( action ) {
2276 +
2277 + case RESERVE1:
2278 + if ( var_val_type != ASN_INTEGER ) {
2279 + fprintf ( stderr, "write to dot11BeaconPeriod not ASN_INTEGER\n" );
2280 + return SNMP_ERR_WRONGTYPE;
2281 + }
2282 + if ( var_val_len > sizeof ( long_ret )){
2283 + fprintf ( stderr,"write to dot11BeaconPeriod: bad length\n" );
2284 + return SNMP_ERR_WRONGLENGTH;
2285 + }
2286 + break;
2287 +
2288 + case RESERVE2:
2289 + case FREE:
2290 + case ACTION:
2291 + case UNDO:
2292 + break;
2293 +
2294 + case COMMIT:
2295 + break;
2296 + }
2297 +
2298 + return SNMP_ERR_NOERROR;
2299 +}
2300 +
2301 +/****************************************************************************
2302 +* *
2303 +****************************************************************************/
2304 +int
2305 +write_dot11DTIMPeriod(int action,
2306 + u_char *var_val,
2307 + u_char var_val_type,
2308 + size_t var_val_len,
2309 + u_char *statP,
2310 + oid *name,
2311 + size_t name_len)
2312 +{
2313 + static long *long_ret;
2314 + int size;
2315 +
2316 + switch ( action ) {
2317 +
2318 + case RESERVE1:
2319 + if ( var_val_type != ASN_INTEGER ) {
2320 + fprintf ( stderr, "write to dot11DTIMPeriod not ASN_INTEGER\n" );
2321 + return SNMP_ERR_WRONGTYPE;
2322 + }
2323 + if ( var_val_len > sizeof ( long_ret )){
2324 + fprintf ( stderr,"write to dot11DTIMPeriod: bad length\n" );
2325 + return SNMP_ERR_WRONGLENGTH;
2326 + }
2327 + break;
2328 +
2329 + case RESERVE2:
2330 + case FREE:
2331 + case ACTION:
2332 + case UNDO:
2333 + break;
2334 +
2335 + case COMMIT:
2336 + break;
2337 + }
2338 +
2339 + return SNMP_ERR_NOERROR;
2340 +}
2341 +
2342 +/****************************************************************************
2343 +* *
2344 +****************************************************************************/
2345 +int
2346 +write_dot11AssociationResponseTimeOut(int action,
2347 + u_char *var_val,
2348 + u_char var_val_type,
2349 + size_t var_val_len,
2350 + u_char *statP,
2351 + oid *name,
2352 + size_t name_len)
2353 +{
2354 + static long *long_ret;
2355 + int size;
2356 +
2357 + switch ( action ) {
2358 +
2359 + case RESERVE1:
2360 + if ( var_val_type != ASN_INTEGER ) {
2361 + fprintf ( stderr, "write to dot11AssociationResponseTimeOut not ASN_INTEGER\n" );
2362 + return SNMP_ERR_WRONGTYPE;
2363 + }
2364 + if ( var_val_len > sizeof ( long_ret )) {
2365 + fprintf ( stderr,"write to dot11AssociationResponseTimeOut: bad length\n" );
2366 + return SNMP_ERR_WRONGLENGTH;
2367 + }
2368 + break;
2369 +
2370 + case RESERVE2:
2371 + case FREE:
2372 + case ACTION:
2373 + case UNDO:
2374 + break;
2375 +
2376 + case COMMIT:
2377 + break;
2378 + }
2379 +
2380 + return SNMP_ERR_NOERROR;
2381 +}
2382 +
2383 +/****************************************************************************
2384 +* *
2385 +****************************************************************************/
2386 +int
2387 +write_dot11AuthenticationAlgorithmsEnable(int action,
2388 + u_char *var_val,
2389 + u_char var_val_type,
2390 + size_t var_val_len,
2391 + u_char *statP,
2392 + oid *name,
2393 + size_t name_len)
2394 +{
2395 + static long *long_ret;
2396 + int size;
2397 +
2398 + switch ( action ) {
2399 +
2400 + case RESERVE1:
2401 + if ( var_val_type != ASN_INTEGER ) {
2402 + fprintf ( stderr, "write to dot11AuthenticationAlgorithmsEnable not ASN_INTEGER\n" );
2403 + return SNMP_ERR_WRONGTYPE;
2404 + }
2405 + if ( var_val_len > sizeof ( long_ret )){
2406 + fprintf ( stderr,"write to dot11AuthenticationAlgorithmsEnable: bad length\n" );
2407 + return SNMP_ERR_WRONGLENGTH;
2408 + }
2409 + break;
2410 +
2411 + case RESERVE2:
2412 + case FREE:
2413 + case ACTION:
2414 + case UNDO:
2415 + break;
2416 +
2417 + case COMMIT:
2418 + break;
2419 + }
2420 +
2421 + return SNMP_ERR_NOERROR;
2422 +}
2423 +
2424 +/****************************************************************************
2425 +* *
2426 +****************************************************************************/
2427 +int
2428 +write_dot11WEPDefaultKeyValue(int action,
2429 + u_char *var_val,
2430 + u_char var_val_type,
2431 + size_t var_val_len,
2432 + u_char *statP,
2433 + oid *name,
2434 + size_t name_len)
2435 +{
2436 + static unsigned char string[SPRINT_MAX_LEN];
2437 + int size;
2438 +
2439 + switch ( action ) {
2440 +
2441 + case RESERVE1:
2442 + if ( var_val_type != ASN_OCTET_STR ) {
2443 + fprintf ( stderr, "write to dot11WEPDefaultKeyValue not ASN_OCTET_STR\n" );
2444 + return SNMP_ERR_WRONGTYPE;
2445 + }
2446 + if ( var_val_len > sizeof ( string )){
2447 + fprintf ( stderr,"write to dot11WEPDefaultKeyValue: bad length\n" );
2448 + return SNMP_ERR_WRONGLENGTH;
2449 + }
2450 + break;
2451 +
2452 + case RESERVE2:
2453 + case FREE:
2454 + case ACTION:
2455 + case UNDO:
2456 + break;
2457 +
2458 + case COMMIT:
2459 + break;
2460 + }
2461 +
2462 + return SNMP_ERR_NOERROR;
2463 +}
2464 +
2465 +/****************************************************************************
2466 +* *
2467 +****************************************************************************/
2468 +int
2469 +write_dot11WEPKeyMappingAddress(int action,
2470 + u_char *var_val,
2471 + u_char var_val_type,
2472 + size_t var_val_len,
2473 + u_char *statP,
2474 + oid *name,
2475 + size_t name_len)
2476 +{
2477 + static unsigned char string[SPRINT_MAX_LEN];
2478 + int size;
2479 +
2480 + switch ( action ) {
2481 +
2482 + case RESERVE1:
2483 + if ( var_val_type != ASN_OCTET_STR ) {
2484 + fprintf ( stderr, "write to dot11WEPKeyMappingAddress not ASN_OCTET_STR\n" );
2485 + return SNMP_ERR_WRONGTYPE;
2486 + }
2487 + if ( var_val_len > sizeof ( string )) {
2488 + fprintf ( stderr,"write to dot11WEPKeyMappingAddress: bad length\n" );
2489 + return SNMP_ERR_WRONGLENGTH;
2490 + }
2491 + break;
2492 +
2493 + case RESERVE2:
2494 + case FREE:
2495 + case ACTION:
2496 + case UNDO:
2497 + break;
2498 +
2499 + case COMMIT:
2500 + break;
2501 + }
2502 +
2503 + return SNMP_ERR_NOERROR;
2504 +}
2505 +
2506 +/****************************************************************************
2507 +* *
2508 +****************************************************************************/
2509 +int
2510 +write_dot11WEPKeyMappingWEPOn(int action,
2511 + u_char *var_val,
2512 + u_char var_val_type,
2513 + size_t var_val_len,
2514 + u_char *statP,
2515 + oid *name,
2516 + size_t name_len)
2517 +{
2518 + static long *long_ret;
2519 + int size;
2520 +
2521 + switch ( action ) {
2522 +
2523 + case RESERVE1:
2524 + if ( var_val_type != ASN_INTEGER ) {
2525 + fprintf ( stderr, "write to dot11WEPKeyMappingWEPOn not ASN_INTEGER\n" );
2526 + return SNMP_ERR_WRONGTYPE;
2527 + }
2528 + if ( var_val_len > sizeof ( long_ret )){
2529 + fprintf ( stderr, "write to dot11WEPKeyMappingWEPOn: bad length\n" );
2530 + return SNMP_ERR_WRONGLENGTH;
2531 + }
2532 + break;
2533 +
2534 + case RESERVE2:
2535 + case FREE:
2536 + case ACTION:
2537 + case UNDO:
2538 + break;
2539 +
2540 + case COMMIT:
2541 + break;
2542 + }
2543 +
2544 + return SNMP_ERR_NOERROR;
2545 +}
2546 +
2547 +/****************************************************************************
2548 +* *
2549 +****************************************************************************/
2550 +int
2551 +write_dot11WEPKeyMappingValue(int action,
2552 + u_char *var_val,
2553 + u_char var_val_type,
2554 + size_t var_val_len,
2555 + u_char *statP,
2556 + oid *name,
2557 + size_t name_len)
2558 +{
2559 + static unsigned char string[SPRINT_MAX_LEN];
2560 + int size;
2561 +
2562 + switch ( action ) {
2563 +
2564 + case RESERVE1:
2565 + if ( var_val_type != ASN_OCTET_STR ) {
2566 + fprintf ( stderr, "write to dot11WEPKeyMappingValue not ASN_OCTET_STR\n" );
2567 + return SNMP_ERR_WRONGTYPE;
2568 + }
2569 + if ( var_val_len > sizeof ( string )) {
2570 + fprintf ( stderr, "write to dot11WEPKeyMappingValue: bad length\n" );
2571 + return SNMP_ERR_WRONGLENGTH;
2572 + }
2573 + break;
2574 +
2575 + case RESERVE2:
2576 + case FREE:
2577 + case ACTION:
2578 + case UNDO:
2579 + break;
2580 +
2581 + case COMMIT:
2582 + break;
2583 + }
2584 +
2585 + return SNMP_ERR_NOERROR;
2586 +}
2587 +
2588 +/****************************************************************************
2589 +* *
2590 +****************************************************************************/
2591 +int
2592 +write_dot11WEPKeyMappingStatus(int action,
2593 + u_char *var_val,
2594 + u_char var_val_type,
2595 + size_t var_val_len,
2596 + u_char *statP,
2597 + oid *name,
2598 + size_t name_len)
2599 +{
2600 + static long *long_ret;
2601 + int size;
2602 +
2603 + switch ( action ) {
2604 + case RESERVE1:
2605 + if ( var_val_type != ASN_INTEGER ) {
2606 + fprintf ( stderr, "write to dot11WEPKeyMappingStatus not ASN_INTEGER\n" );
2607 + return SNMP_ERR_WRONGTYPE;
2608 + }
2609 + if ( var_val_len > sizeof ( long_ret )){
2610 + fprintf ( stderr, "write to dot11WEPKeyMappingStatus: bad length\n" );
2611 + return SNMP_ERR_WRONGLENGTH;
2612 + }
2613 + break;
2614 +
2615 + case RESERVE2:
2616 + case FREE:
2617 + case ACTION:
2618 + case UNDO:
2619 + break;
2620 +
2621 + case COMMIT:
2622 + break;
2623 + }
2624 +
2625 + return SNMP_ERR_NOERROR;
2626 +}
2627 +
2628 +/****************************************************************************
2629 +* *
2630 +****************************************************************************/
2631 +int
2632 +write_dot11PrivacyInvoked(int action,
2633 + u_char *var_val,
2634 + u_char var_val_type,
2635 + size_t var_val_len,
2636 + u_char *statP,
2637 + oid *name,
2638 + size_t name_len)
2639 +{
2640 + static long *long_ret;
2641 + int size;
2642 +
2643 + switch ( action ) {
2644 +
2645 + case RESERVE1:
2646 + if ( var_val_type != ASN_INTEGER ) {
2647 + fprintf ( stderr, "write to dot11PrivacyInvoked not ASN_INTEGER\n" );
2648 + return SNMP_ERR_WRONGTYPE;
2649 + }
2650 + if ( var_val_len > sizeof ( long_ret )){
2651 + fprintf ( stderr, "write to dot11PrivacyInvoked: bad length\n" );
2652 + return SNMP_ERR_WRONGLENGTH;
2653 + }
2654 + break;
2655 +
2656 + case RESERVE2:
2657 + case FREE:
2658 + case ACTION:
2659 + case UNDO:
2660 + break;
2661 +
2662 + case COMMIT:
2663 + break;
2664 + }
2665 +
2666 + return SNMP_ERR_NOERROR;
2667 +}
2668 +
2669 +/****************************************************************************
2670 +* *
2671 +****************************************************************************/
2672 +int
2673 +write_dot11WEPDefaultKeyID(int action,
2674 + u_char *var_val,
2675 + u_char var_val_type,
2676 + size_t var_val_len,
2677 + u_char *statP,
2678 + oid *name,
2679 + size_t name_len)
2680 +{
2681 + static long *long_ret;
2682 + int size;
2683 +
2684 + switch ( action ) {
2685 +
2686 + case RESERVE1:
2687 + if ( var_val_type != ASN_INTEGER ) {
2688 + fprintf ( stderr, "write to dot11WEPDefaultKeyID not ASN_INTEGER\n" );
2689 + return SNMP_ERR_WRONGTYPE;
2690 + }
2691 + if ( var_val_len > sizeof ( long_ret )){
2692 + fprintf ( stderr, "write to dot11WEPDefaultKeyID: bad length\n" );
2693 + return SNMP_ERR_WRONGLENGTH;
2694 + }
2695 + break;
2696 +
2697 + case RESERVE2:
2698 + case FREE:
2699 + case ACTION:
2700 + case UNDO:
2701 + break;
2702 +
2703 + case COMMIT:
2704 + break;
2705 + }
2706 +
2707 + return SNMP_ERR_NOERROR;
2708 +}
2709 +
2710 +/****************************************************************************
2711 +* *
2712 +****************************************************************************/
2713 +int
2714 +write_dot11WEPKeyMappingLength(int action,
2715 + u_char *var_val,
2716 + u_char var_val_type,
2717 + size_t var_val_len,
2718 + u_char *statP,
2719 + oid *name,
2720 + size_t name_len)
2721 +{
2722 + static long *long_ret;
2723 + int size;
2724 +
2725 + switch ( action ) {
2726 +
2727 + case RESERVE1:
2728 + if ( var_val_type != ASN_INTEGER ) {
2729 + fprintf ( stderr, "write to dot11WEPKeyMappingLength not ASN_INTEGER\n" );
2730 + return SNMP_ERR_WRONGTYPE;
2731 + }
2732 + if ( var_val_len > sizeof ( long_ret )){
2733 + fprintf ( stderr, "write to dot11WEPKeyMappingLength: bad length\n" );
2734 + return SNMP_ERR_WRONGLENGTH;
2735 + }
2736 + break;
2737 +
2738 + case RESERVE2:
2739 + case FREE:
2740 + case ACTION:
2741 + case UNDO:
2742 + break;
2743 +
2744 + case COMMIT:
2745 + break;
2746 + }
2747 +
2748 + return SNMP_ERR_NOERROR;
2749 +}
2750 +
2751 +/****************************************************************************
2752 +* *
2753 +****************************************************************************/
2754 +int
2755 +write_dot11ExcludeUnencrypted(int action,
2756 + u_char *var_val,
2757 + u_char var_val_type,
2758 + size_t var_val_len,
2759 + u_char *statP,
2760 + oid *name,
2761 + size_t name_len)
2762 +{
2763 + static long *long_ret;
2764 + int size;
2765 +
2766 + switch ( action ) {
2767 +
2768 + case RESERVE1:
2769 + if ( var_val_type != ASN_INTEGER ) {
2770 + fprintf ( stderr, "write to dot11ExcludeUnencrypted not ASN_INTEGER\n" );
2771 + return SNMP_ERR_WRONGTYPE;
2772 + }
2773 + if ( var_val_len > sizeof ( long_ret )){
2774 + fprintf ( stderr,"write to dot11ExcludeUnencrypted: bad length\n" );
2775 + return SNMP_ERR_WRONGLENGTH;
2776 + }
2777 + break;
2778 +
2779 + case RESERVE2:
2780 + case FREE:
2781 + case ACTION:
2782 + case UNDO:
2783 + break;
2784 +
2785 + case COMMIT:
2786 + break;
2787 + }
2788 +
2789 + return SNMP_ERR_NOERROR;
2790 +}
2791 +
2792 +/****************************************************************************
2793 +* *
2794 +****************************************************************************/
2795 +int
2796 +write_dot11RTSThreshold(int action,
2797 + u_char *var_val,
2798 + u_char var_val_type,
2799 + size_t var_val_len,
2800 + u_char *statP,
2801 + oid *name,
2802 + size_t name_len)
2803 +{
2804 + static long *long_ret;
2805 + int size;
2806 +
2807 + switch ( action ) {
2808 +
2809 + case RESERVE1:
2810 + if ( var_val_type != ASN_INTEGER ){
2811 + fprintf ( stderr, "write to dot11RTSThreshold not ASN_INTEGER\n" );
2812 + return SNMP_ERR_WRONGTYPE;
2813 + }
2814 + if ( var_val_len > sizeof ( long_ret )){
2815 + fprintf ( stderr, "write to dot11RTSThreshold: bad length\n" );
2816 + return SNMP_ERR_WRONGLENGTH;
2817 + }
2818 + break;
2819 +
2820 + case RESERVE2:
2821 + case FREE:
2822 + case ACTION:
2823 + case UNDO:
2824 + break;
2825 +
2826 + case COMMIT:
2827 + break;
2828 + }
2829 +
2830 + return SNMP_ERR_NOERROR;
2831 +}
2832 +
2833 +/****************************************************************************
2834 +* *
2835 +****************************************************************************/
2836 +int
2837 +write_dot11ShortRetryLimit(int action,
2838 + u_char *var_val,
2839 + u_char var_val_type,
2840 + size_t var_val_len,
2841 + u_char *statP,
2842 + oid *name,
2843 + size_t name_len)
2844 +{
2845 + static long *long_ret;
2846 + int size;
2847 +
2848 + switch ( action ) {
2849 +
2850 + case RESERVE1:
2851 + if ( var_val_type != ASN_INTEGER ) {
2852 + fprintf ( stderr, "write to dot11ShortRetryLimit not ASN_INTEGER\n" );
2853 + return SNMP_ERR_WRONGTYPE;
2854 + }
2855 + if ( var_val_len > sizeof ( long_ret )){
2856 + fprintf ( stderr, "write to dot11ShortRetryLimit: bad length\n" );
2857 + return SNMP_ERR_WRONGLENGTH;
2858 + }
2859 + break;
2860 +
2861 + case RESERVE2:
2862 + case FREE:
2863 + case ACTION:
2864 + case UNDO:
2865 + break;
2866 +
2867 + case COMMIT:
2868 + break;
2869 + }
2870 +
2871 + return SNMP_ERR_NOERROR;
2872 +}
2873 +
2874 +/****************************************************************************
2875 +* *
2876 +****************************************************************************/
2877 +int
2878 +write_dot11LongRetryLimit(int action,
2879 + u_char *var_val,
2880 + u_char var_val_type,
2881 + size_t var_val_len,
2882 + u_char *statP,
2883 + oid *name,
2884 + size_t name_len)
2885 +{
2886 + static long *long_ret;
2887 + int size;
2888 +
2889 + switch ( action ) {
2890 +
2891 + case RESERVE1:
2892 + if ( var_val_type != ASN_INTEGER ) {
2893 + fprintf ( stderr, "write to dot11LongRetryLimit not ASN_INTEGER\n" );
2894 + return SNMP_ERR_WRONGTYPE;
2895 + }
2896 + if ( var_val_len > sizeof ( long_ret )){
2897 + fprintf ( stderr,"write to dot11LongRetryLimit: bad length\n" );
2898 + return SNMP_ERR_WRONGLENGTH;
2899 + }
2900 + break;
2901 +
2902 + case RESERVE2:
2903 + case FREE:
2904 + case ACTION:
2905 + case UNDO:
2906 + break;
2907 +
2908 + case COMMIT:
2909 + break;
2910 + }
2911 +
2912 + return SNMP_ERR_NOERROR;
2913 +}
2914 +
2915 +/****************************************************************************
2916 +* *
2917 +****************************************************************************/
2918 +int
2919 +write_dot11FragmentationThreshold(int action,
2920 + u_char *var_val,
2921 + u_char var_val_type,
2922 + size_t var_val_len,
2923 + u_char *statP,
2924 + oid *name,
2925 + size_t name_len)
2926 +{
2927 + static long *long_ret;
2928 + int size;
2929 +
2930 + switch ( action ) {
2931 +
2932 + case RESERVE1:
2933 + if ( var_val_type != ASN_INTEGER ) {
2934 + fprintf ( stderr, "write to dot11FragmentationThreshold not ASN_INTEGER\n" );
2935 + return SNMP_ERR_WRONGTYPE;
2936 + }
2937 + if ( var_val_len > sizeof ( long_ret )){
2938 + fprintf ( stderr,"write to dot11FragmentationThreshold: bad length\n" );
2939 + return SNMP_ERR_WRONGLENGTH;
2940 + }
2941 + break;
2942 +
2943 + case RESERVE2:
2944 + case FREE:
2945 + case ACTION:
2946 + case UNDO:
2947 + break;
2948 +
2949 + case COMMIT:
2950 + break;
2951 + }
2952 +
2953 + return SNMP_ERR_NOERROR;
2954 +}
2955 +
2956 +/****************************************************************************
2957 +* *
2958 +****************************************************************************/
2959 +int
2960 +write_dot11MaxTransmitMSDULifetime(int action,
2961 + u_char *var_val,
2962 + u_char var_val_type,
2963 + size_t var_val_len,
2964 + u_char *statP,
2965 + oid *name,
2966 + size_t name_len)
2967 +{
2968 + static long *long_ret;
2969 + int size;
2970 +
2971 + switch ( action ) {
2972 +
2973 + case RESERVE1:
2974 + if ( var_val_type != ASN_INTEGER ) {
2975 + fprintf ( stderr, "write to dot11MaxTransmitMSDULifetime not ASN_INTEGER\n" );
2976 + return SNMP_ERR_WRONGTYPE;
2977 + }
2978 + if ( var_val_len > sizeof ( long_ret )){
2979 + fprintf ( stderr, "write to dot11MaxTransmitMSDULifetime: bad length\n" );
2980 + return SNMP_ERR_WRONGLENGTH;
2981 + }
2982 + break;
2983 +
2984 + case RESERVE2:
2985 + case FREE:
2986 + case ACTION:
2987 + case UNDO:
2988 + break;
2989 +
2990 + case COMMIT:
2991 +
2992 + break;
2993 + }
2994 +
2995 + return SNMP_ERR_NOERROR;
2996 +}
2997 +
2998 +/****************************************************************************
2999 +* *
3000 +****************************************************************************/
3001 +int
3002 +write_dot11MaxReceiveLifetime(int action,
3003 + u_char *var_val,
3004 + u_char var_val_type,
3005 + size_t var_val_len,
3006 + u_char *statP,
3007 + oid *name,
3008 + size_t name_len)
3009 +{
3010 + static long *long_ret;
3011 + int size;
3012 +
3013 + switch ( action ) {
3014 +
3015 + case RESERVE1:
3016 + if ( var_val_type != ASN_INTEGER ) {
3017 + fprintf ( stderr, "write to dot11MaxReceiveLifetime not ASN_INTEGER\n" );
3018 + return SNMP_ERR_WRONGTYPE;
3019 + }
3020 + if ( var_val_len > sizeof ( long_ret )){
3021 + fprintf ( stderr, "write to dot11MaxReceiveLifetime: bad length\n" );
3022 + return SNMP_ERR_WRONGLENGTH;
3023 + }
3024 + break;
3025 +
3026 + case RESERVE2:
3027 + case FREE:
3028 + case ACTION:
3029 + case UNDO:
3030 + break;
3031 +
3032 + case COMMIT:
3033 + break;
3034 + }
3035 +
3036 + return SNMP_ERR_NOERROR;
3037 +}
3038 +
3039 +/****************************************************************************
3040 +* *
3041 +****************************************************************************/
3042 +int
3043 +write_dot11Address(int action,
3044 + u_char *var_val,
3045 + u_char var_val_type,
3046 + size_t var_val_len,
3047 + u_char *statP,
3048 + oid *name,
3049 + size_t name_len)
3050 +{
3051 + static unsigned char string[SPRINT_MAX_LEN];
3052 + int size;
3053 +
3054 + switch ( action ) {
3055 +
3056 + case RESERVE1:
3057 + if ( var_val_type != ASN_OCTET_STR ) {
3058 + fprintf ( stderr, "write to dot11Address not ASN_OCTET_STR\n" );
3059 + return SNMP_ERR_WRONGTYPE;
3060 + }
3061 + if ( var_val_len > sizeof ( string )){
3062 + fprintf ( stderr, "write to dot11Address: bad length\n" );
3063 + return SNMP_ERR_WRONGLENGTH;
3064 + }
3065 + break;
3066 +
3067 + case RESERVE2:
3068 + case FREE:
3069 + case ACTION:
3070 + case UNDO:
3071 + break;
3072 +
3073 + case COMMIT:
3074 + break;
3075 + }
3076 +
3077 + return SNMP_ERR_NOERROR;
3078 +}
3079 +
3080 +/****************************************************************************
3081 +* *
3082 +****************************************************************************/
3083 +int
3084 +write_dot11GroupAddressesStatus(int action,
3085 + u_char *var_val,
3086 + u_char var_val_type,
3087 + size_t var_val_len,
3088 + u_char *statP,
3089 + oid *name,
3090 + size_t name_len)
3091 +{
3092 + static long *long_ret;
3093 + int size;
3094 +
3095 + switch ( action ) {
3096 +
3097 + case RESERVE1:
3098 + if ( var_val_type != ASN_INTEGER ) {
3099 + fprintf ( stderr, "write to dot11GroupAddressesStatus not ASN_INTEGER\n" );
3100 + return SNMP_ERR_WRONGTYPE;
3101 + }
3102 + if ( var_val_len > sizeof ( long_ret )){
3103 + fprintf ( stderr,"write to dot11GroupAddressesStatus: bad length\n" );
3104 + return SNMP_ERR_WRONGLENGTH;
3105 + }
3106 + break;
3107 +
3108 + case RESERVE2:
3109 + case FREE:
3110 + case ACTION:
3111 + case UNDO:
3112 + break;
3113 +
3114 + case COMMIT:
3115 + break;
3116 + }
3117 +
3118 + return SNMP_ERR_NOERROR;
3119 +}
3120 +
3121 +/****************************************************************************
3122 +* *
3123 +****************************************************************************/
3124 +int
3125 +write_dot11CurrentRegDomain(int action,
3126 + u_char *var_val,
3127 + u_char var_val_type,
3128 + size_t var_val_len,
3129 + u_char *statP,
3130 + oid *name,
3131 + size_t name_len)
3132 +{
3133 + static long *long_ret;
3134 + int size;
3135 +
3136 + switch ( action ) {
3137 +
3138 + case RESERVE1:
3139 + if ( var_val_type != ASN_INTEGER ) {
3140 + fprintf ( stderr, "write to dot11CurrentRegDomain not ASN_INTEGER\n" );
3141 + return SNMP_ERR_WRONGTYPE;
3142 + }
3143 + if ( var_val_len > sizeof ( long_ret )){
3144 + fprintf ( stderr, "write to dot11CurrentRegDomain: bad length\n" );
3145 + return SNMP_ERR_WRONGLENGTH;
3146 + }
3147 + break;
3148 +
3149 + case RESERVE2:
3150 + case FREE:
3151 + case ACTION:
3152 + case UNDO:
3153 + break;
3154 +
3155 + case COMMIT:
3156 + break;
3157 + }
3158 +
3159 + return SNMP_ERR_NOERROR;
3160 +}
3161 +
3162 +/****************************************************************************
3163 +* *
3164 +****************************************************************************/
3165 +int
3166 +write_dot11CurrentTxAntenna(int action,
3167 + u_char *var_val,
3168 + u_char var_val_type,
3169 + size_t var_val_len,
3170 + u_char *statP,
3171 + oid *name,
3172 + size_t name_len)
3173 +{
3174 + static long *long_ret;
3175 + int size;
3176 +
3177 + switch ( action ) {
3178 +
3179 + case RESERVE1:
3180 + if ( var_val_type != ASN_INTEGER ) {
3181 + fprintf ( stderr, "write to dot11CurrentTxAntenna not ASN_INTEGER\n" );
3182 + return SNMP_ERR_WRONGTYPE;
3183 + }
3184 + if ( var_val_len > sizeof ( long_ret )){
3185 + fprintf ( stderr, "write to dot11CurrentTxAntenna: bad length\n" );
3186 + return SNMP_ERR_WRONGLENGTH;
3187 + }
3188 + break;
3189 +
3190 + case RESERVE2:
3191 + case FREE:
3192 + case ACTION:
3193 + case UNDO:
3194 + break;
3195 +
3196 + case COMMIT:
3197 + break;
3198 + }
3199 +
3200 + return SNMP_ERR_NOERROR;
3201 +}
3202 +
3203 +/****************************************************************************
3204 +* *
3205 +****************************************************************************/
3206 +int
3207 +write_dot11CurrentRxAntenna(int action,
3208 + u_char *var_val,
3209 + u_char var_val_type,
3210 + size_t var_val_len,
3211 + u_char *statP,
3212 + oid *name,
3213 + size_t name_len)
3214 +{
3215 + static long *long_ret;
3216 + int size;
3217 +
3218 + switch ( action ) {
3219 +
3220 + case RESERVE1:
3221 + if ( var_val_type != ASN_INTEGER ) {
3222 + fprintf ( stderr, "write to dot11CurrentRxAntenna not ASN_INTEGER\n" );
3223 + return SNMP_ERR_WRONGTYPE;
3224 + }
3225 + if ( var_val_len > sizeof ( long_ret )){
3226 + fprintf ( stderr,"write to dot11CurrentRxAntenna: bad length\n" );
3227 + return SNMP_ERR_WRONGLENGTH;
3228 + }
3229 + break;
3230 +
3231 + case RESERVE2:
3232 + case FREE:
3233 + case ACTION:
3234 + case UNDO:
3235 + break;
3236 +
3237 + case COMMIT:
3238 + break;
3239 +
3240 + }
3241 +
3242 + return SNMP_ERR_NOERROR;
3243 +}
3244 +
3245 +/****************************************************************************
3246 +* *
3247 +****************************************************************************/
3248 +int
3249 +write_dot11CurrentTxPowerLevel(int action,
3250 + u_char *var_val,
3251 + u_char var_val_type,
3252 + size_t var_val_len,
3253 + u_char *statP,
3254 + oid *name,
3255 + size_t name_len)
3256 +{
3257 + static long *long_ret;
3258 + int size;
3259 +
3260 + switch ( action ) {
3261 +
3262 + case RESERVE1:
3263 + if ( var_val_type != ASN_INTEGER ) {
3264 + fprintf ( stderr, "write to dot11CurrentTxPowerLevel not ASN_INTEGER\n" );
3265 + return SNMP_ERR_WRONGTYPE;
3266 + }
3267 + if ( var_val_len > sizeof ( long_ret )){
3268 + fprintf ( stderr, "write to dot11CurrentTxPowerLevel: bad length\n" );
3269 + return SNMP_ERR_WRONGLENGTH;
3270 + }
3271 + break;
3272 +
3273 + case RESERVE2:
3274 + case FREE:
3275 + case ACTION:
3276 + case UNDO:
3277 + break;
3278 +
3279 + case COMMIT:
3280 + break;
3281 + }
3282 +
3283 + return SNMP_ERR_NOERROR;
3284 +}
3285 +
3286 +/****************************************************************************
3287 +* *
3288 +****************************************************************************/
3289 +int
3290 +write_dot11CurrentChannelNumber(int action,
3291 + u_char *var_val,
3292 + u_char var_val_type,
3293 + size_t var_val_len,
3294 + u_char *statP,
3295 + oid *name,
3296 + size_t name_len)
3297 +{
3298 + static long *long_ret;
3299 + int size;
3300 +
3301 + switch ( action ) {
3302 +
3303 + case RESERVE1:
3304 + if ( var_val_type != ASN_INTEGER ) {
3305 + fprintf ( stderr, "write to dot11CurrentChannelNumber not ASN_INTEGER\n" );
3306 + return SNMP_ERR_WRONGTYPE;
3307 + }
3308 + if ( var_val_len > sizeof ( long_ret )){
3309 + fprintf ( stderr,"write to dot11CurrentChannelNumber: bad length\n" );
3310 + return SNMP_ERR_WRONGLENGTH;
3311 + }
3312 + break;
3313 +
3314 + case RESERVE2:
3315 + case FREE:
3316 + case ACTION:
3317 + case UNDO:
3318 + break;
3319 +
3320 + case COMMIT:
3321 + break;
3322 + }
3323 +
3324 + return SNMP_ERR_NOERROR;
3325 +}
3326 +
3327 +/****************************************************************************
3328 +* *
3329 +****************************************************************************/
3330 +int
3331 +write_dot11CurrentDwellTime(int action,
3332 + u_char *var_val,
3333 + u_char var_val_type,
3334 + size_t var_val_len,
3335 + u_char *statP,
3336 + oid *name,
3337 + size_t name_len)
3338 +{
3339 + static long *long_ret;
3340 + int size;
3341 +
3342 + switch ( action ) {
3343 +
3344 + case RESERVE1:
3345 + if ( var_val_type != ASN_INTEGER ) {
3346 + fprintf ( stderr, "write to dot11CurrentDwellTime not ASN_INTEGER\n" );
3347 + return SNMP_ERR_WRONGTYPE;
3348 + }
3349 + if ( var_val_len > sizeof ( long_ret )){
3350 + fprintf ( stderr, "write to dot11CurrentDwellTime: bad length\n" );
3351 + return SNMP_ERR_WRONGLENGTH;
3352 + }
3353 + break;
3354 +
3355 + case RESERVE2:
3356 + case FREE:
3357 + case ACTION:
3358 + case UNDO:
3359 + break;
3360 +
3361 + case COMMIT:
3362 + break;
3363 + }
3364 +
3365 + return SNMP_ERR_NOERROR;
3366 +}
3367 +
3368 +/****************************************************************************
3369 +* *
3370 +****************************************************************************/
3371 +int
3372 +write_dot11CurrentSet(int action,
3373 + u_char *var_val,
3374 + u_char var_val_type,
3375 + size_t var_val_len,
3376 + u_char *statP,
3377 + oid *name,
3378 + size_t name_len)
3379 +{
3380 + static long *long_ret;
3381 + int size;
3382 +
3383 + switch ( action ) {
3384 +
3385 + case RESERVE1:
3386 + if ( var_val_type != ASN_INTEGER ) {
3387 + fprintf ( stderr, "write to dot11CurrentSet not ASN_INTEGER\n" );
3388 + return SNMP_ERR_WRONGTYPE;
3389 + }
3390 + if ( var_val_len > sizeof ( long_ret )){
3391 + fprintf ( stderr, "write to dot11CurrentSet: bad length\n" );
3392 + return SNMP_ERR_WRONGLENGTH;
3393 + }
3394 + break;
3395 +
3396 + case RESERVE2:
3397 + case FREE:
3398 + case ACTION:
3399 + case UNDO:
3400 + break;
3401 +
3402 + case COMMIT:
3403 + break;
3404 + }
3405 +
3406 + return SNMP_ERR_NOERROR;
3407 +}
3408 +
3409 +/****************************************************************************
3410 +* *
3411 +****************************************************************************/
3412 +int
3413 +write_dot11CurrentPattern(int action,
3414 + u_char *var_val,
3415 + u_char var_val_type,
3416 + size_t var_val_len,
3417 + u_char *statP,
3418 + oid *name,
3419 + size_t name_len)
3420 +{
3421 + static long *long_ret;
3422 + int size;
3423 +
3424 + switch ( action ) {
3425 +
3426 + case RESERVE1:
3427 + if ( var_val_type != ASN_INTEGER ) {
3428 + fprintf ( stderr, "write to dot11CurrentPattern not ASN_INTEGER\n" );
3429 + return SNMP_ERR_WRONGTYPE;
3430 + }
3431 + if ( var_val_len > sizeof ( long_ret )){
3432 + fprintf ( stderr, "write to dot11CurrentPattern: bad length\n" );
3433 + return SNMP_ERR_WRONGLENGTH;
3434 + }
3435 + break;
3436 +
3437 + case RESERVE2:
3438 + case FREE:
3439 + case ACTION:
3440 + case UNDO:
3441 + break;
3442 +
3443 + case COMMIT:
3444 + break;
3445 + }
3446 +
3447 + return SNMP_ERR_NOERROR;
3448 +}
3449 +
3450 +/****************************************************************************
3451 +* *
3452 +****************************************************************************/
3453 +int
3454 +write_dot11CurrentIndex(int action,
3455 + u_char *var_val,
3456 + u_char var_val_type,
3457 + size_t var_val_len,
3458 + u_char *statP,
3459 + oid *name,
3460 + size_t name_len)
3461 +{
3462 + static long *long_ret;
3463 + int size;
3464 +
3465 + switch ( action ) {
3466 +
3467 + case RESERVE1:
3468 + if ( var_val_type != ASN_INTEGER ) {
3469 + fprintf ( stderr, "write to dot11CurrentIndex not ASN_INTEGER\n" );
3470 + return SNMP_ERR_WRONGTYPE;
3471 + }
3472 + if ( var_val_len > sizeof ( long_ret )){
3473 + fprintf ( stderr, "write to dot11CurrentIndex: bad length\n" );
3474 + return SNMP_ERR_WRONGLENGTH;
3475 + }
3476 + break;
3477 +
3478 + case RESERVE2:
3479 + case FREE:
3480 + case ACTION:
3481 + case UNDO:
3482 + break;
3483 +
3484 + case COMMIT:
3485 + break;
3486 + }
3487 +
3488 + return SNMP_ERR_NOERROR;
3489 +}
3490 +
3491 +/****************************************************************************
3492 +* *
3493 +****************************************************************************/
3494 +int
3495 +write_dot11CurrentChannel(int action,
3496 + u_char *var_val,
3497 + u_char var_val_type,
3498 + size_t var_val_len,
3499 + u_char *statP,
3500 + oid *name,
3501 + size_t name_len)
3502 +{
3503 + static long *long_ret;
3504 + int size;
3505 +
3506 + switch ( action ) {
3507 +
3508 + case RESERVE1:
3509 + if ( var_val_type != ASN_INTEGER ) {
3510 + fprintf ( stderr, "write to dot11CurrentChannel not ASN_INTEGER\n" );
3511 + return SNMP_ERR_WRONGTYPE;
3512 + }
3513 + if ( var_val_len > sizeof ( long_ret )){
3514 + fprintf ( stderr, "write to dot11CurrentChannel: bad length\n" );
3515 + return SNMP_ERR_WRONGLENGTH;
3516 + }
3517 + break;
3518 +
3519 + case RESERVE2:
3520 + case FREE:
3521 + case ACTION:
3522 + case UNDO:
3523 + break;
3524 +
3525 + case COMMIT:
3526 + break;
3527 + }
3528 +
3529 + return SNMP_ERR_NOERROR;
3530 +}
3531 +
3532 +/****************************************************************************
3533 +* *
3534 +****************************************************************************/
3535 +int
3536 +write_dot11CurrentCCAMode(int action,
3537 + u_char *var_val,
3538 + u_char var_val_type,
3539 + size_t var_val_len,
3540 + u_char *statP,
3541 + oid *name,
3542 + size_t name_len)
3543 +{
3544 + static long *long_ret;
3545 + int size;
3546 +
3547 + switch ( action ) {
3548 +
3549 + case RESERVE1:
3550 + if ( var_val_type != ASN_INTEGER ) {
3551 + fprintf ( stderr, "write to dot11CurrentCCAMode not ASN_INTEGER\n" );
3552 + return SNMP_ERR_WRONGTYPE;
3553 + }
3554 + if ( var_val_len > sizeof ( long_ret )){
3555 + fprintf ( stderr,"write to dot11CurrentCCAMode: bad length\n" );
3556 + return SNMP_ERR_WRONGLENGTH;
3557 + }
3558 + break;
3559 +
3560 + case RESERVE2:
3561 + case FREE:
3562 + case ACTION:
3563 + case UNDO:
3564 + break;
3565 +
3566 + case COMMIT:
3567 + break;
3568 + }
3569 +
3570 + return SNMP_ERR_NOERROR;
3571 +}
3572 +
3573 +/****************************************************************************
3574 +* *
3575 +****************************************************************************/
3576 +int
3577 +write_dot11EDThreshold(int action,
3578 + u_char *var_val,
3579 + u_char var_val_type,
3580 + size_t var_val_len,
3581 + u_char *statP,
3582 + oid *name,
3583 + size_t name_len)
3584 +{
3585 + static long *long_ret;
3586 + int size;
3587 +
3588 + switch ( action ) {
3589 +
3590 + case RESERVE1:
3591 + if ( var_val_type != ASN_INTEGER ) {
3592 + fprintf ( stderr, "write to dot11EDThreshold not ASN_INTEGER\n" );
3593 + return SNMP_ERR_WRONGTYPE;
3594 + }
3595 + if ( var_val_len > sizeof ( long_ret )){
3596 + fprintf ( stderr, "write to dot11EDThreshold: bad length\n" );
3597 + return SNMP_ERR_WRONGLENGTH;
3598 + }
3599 + break;
3600 +
3601 + case RESERVE2:
3602 + case FREE:
3603 + case ACTION:
3604 + case UNDO:
3605 + break;
3606 +
3607 + case COMMIT:
3608 + break;
3609 + }
3610 +
3611 + return SNMP_ERR_NOERROR;
3612 +}
3613 +
3614 +/****************************************************************************
3615 +* *
3616 +****************************************************************************/
3617 +int
3618 +write_dot11CCAWatchdogTimerMax(int action,
3619 + u_char *var_val,
3620 + u_char var_val_type,
3621 + size_t var_val_len,
3622 + u_char *statP,
3623 + oid *name,
3624 + size_t name_len)
3625 +{
3626 + static long *long_ret;
3627 + int size;
3628 +
3629 + switch ( action ) {
3630 +
3631 + case RESERVE1:
3632 + if ( var_val_type != ASN_INTEGER ) {
3633 + fprintf ( stderr, "write to dot11CCAWatchdogTimerMax not ASN_INTEGER\n" );
3634 + return SNMP_ERR_WRONGTYPE;
3635 + }
3636 + if ( var_val_len > sizeof ( long_ret )){
3637 + fprintf ( stderr, "write to dot11CCAWatchdogTimerMax: bad length\n" );
3638 + return SNMP_ERR_WRONGLENGTH;
3639 + }
3640 + break;
3641 +
3642 + case RESERVE2:
3643 + case FREE:
3644 + case ACTION:
3645 + case UNDO:
3646 + break;
3647 +
3648 + case COMMIT:
3649 + break;
3650 + }
3651 +
3652 + return SNMP_ERR_NOERROR;
3653 +}
3654 +
3655 +/****************************************************************************
3656 +* *
3657 +****************************************************************************/
3658 +int
3659 +write_dot11CCAWatchdogCountMax(int action,
3660 + u_char *var_val,
3661 + u_char var_val_type,
3662 + size_t var_val_len,
3663 + u_char *statP,
3664 + oid *name,
3665 + size_t name_len)
3666 +{
3667 + static long *long_ret;
3668 + int size;
3669 +
3670 + switch ( action ) {
3671 +
3672 + case RESERVE1:
3673 + if ( var_val_type != ASN_INTEGER ) {
3674 + fprintf ( stderr, "write to dot11CCAWatchdogCountMax not ASN_INTEGER\n" );
3675 + return SNMP_ERR_WRONGTYPE;
3676 + }
3677 + if ( var_val_len > sizeof ( long_ret )){
3678 + fprintf ( stderr, "write to dot11CCAWatchdogCountMax: bad length\n" );
3679 + return SNMP_ERR_WRONGLENGTH;
3680 + }
3681 + break;
3682 +
3683 + case RESERVE2:
3684 + case FREE:
3685 + case ACTION:
3686 + case UNDO:
3687 + break;
3688 +
3689 + case COMMIT:
3690 + break;
3691 + }
3692 +
3693 + return SNMP_ERR_NOERROR;
3694 +}
3695 +
3696 +/****************************************************************************
3697 +* *
3698 +****************************************************************************/
3699 +int
3700 +write_dot11CCAWatchdogTimerMin(int action,
3701 + u_char *var_val,
3702 + u_char var_val_type,
3703 + size_t var_val_len,
3704 + u_char *statP,
3705 + oid *name,
3706 + size_t name_len)
3707 +{
3708 + static long *long_ret;
3709 + int size;
3710 +
3711 + switch ( action ) {
3712 +
3713 + case RESERVE1:
3714 + if ( var_val_type != ASN_INTEGER ) {
3715 + fprintf ( stderr, "write to dot11CCAWatchdogTimerMin not ASN_INTEGER\n" );
3716 + return SNMP_ERR_WRONGTYPE;
3717 + }
3718 + if ( var_val_len > sizeof ( long_ret )){
3719 + fprintf ( stderr, "write to dot11CCAWatchdogTimerMin: bad length\n" );
3720 + return SNMP_ERR_WRONGLENGTH;
3721 + }
3722 + break;
3723 +
3724 + case RESERVE2:
3725 + case FREE:
3726 + case ACTION:
3727 + case UNDO:
3728 + break;
3729 +
3730 + case COMMIT:
3731 + break;
3732 + }
3733 +
3734 + return SNMP_ERR_NOERROR;
3735 +}
3736 +
3737 +/****************************************************************************
3738 +* *
3739 +****************************************************************************/
3740 +int
3741 +write_dot11CCAWatchdogCountMin(int action,
3742 + u_char *var_val,
3743 + u_char var_val_type,
3744 + size_t var_val_len,
3745 + u_char *statP,
3746 + oid *name,
3747 + size_t name_len)
3748 +{
3749 + static long *long_ret;
3750 + int size;
3751 +
3752 + switch ( action ) {
3753 +
3754 + case RESERVE1:
3755 + if ( var_val_type != ASN_INTEGER ) {
3756 + fprintf ( stderr, "write to dot11CCAWatchdogCountMin not ASN_INTEGER\n" );
3757 + return SNMP_ERR_WRONGTYPE;
3758 + }
3759 + if ( var_val_len > sizeof ( long_ret )){
3760 + fprintf ( stderr, "write to dot11CCAWatchdogCountMin: bad length\n" );
3761 + return SNMP_ERR_WRONGLENGTH;
3762 + }
3763 + break;
3764 +
3765 + case RESERVE2:
3766 + case FREE:
3767 + case ACTION:
3768 + case UNDO:
3769 + break;
3770 +
3771 + case COMMIT:
3772 + break;
3773 + }
3774 +
3775 + return SNMP_ERR_NOERROR;
3776 +}
3777 +
3778 +/****************************************************************************
3779 +* *
3780 +****************************************************************************/
3781 +int
3782 +write_dot11SupportedTxAntenna(int action,
3783 + u_char *var_val,
3784 + u_char var_val_type,
3785 + size_t var_val_len,
3786 + u_char *statP,
3787 + oid *name,
3788 + size_t name_len)
3789 +{
3790 + static long *long_ret;
3791 + int size;
3792 +
3793 + switch ( action ) {
3794 +
3795 + case RESERVE1:
3796 + if ( var_val_type != ASN_INTEGER ) {
3797 + fprintf ( stderr, "write to dot11SupportedTxAntenna not ASN_INTEGER\n" );
3798 + return SNMP_ERR_WRONGTYPE;
3799 + }
3800 + if ( var_val_len > sizeof ( long_ret )){
3801 + fprintf ( stderr, "write to dot11SupportedTxAntenna: bad length\n" );
3802 + return SNMP_ERR_WRONGLENGTH;
3803 + }
3804 + break;
3805 +
3806 + case RESERVE2:
3807 + case FREE:
3808 + case ACTION:
3809 + case UNDO:
3810 + break;
3811 +
3812 + case COMMIT:
3813 + break;
3814 + }
3815 +
3816 + return SNMP_ERR_NOERROR;
3817 +}
3818 +
3819 +/****************************************************************************
3820 +* *
3821 +****************************************************************************/
3822 +int
3823 +write_dot11SupportedRxAntenna(int action,
3824 + u_char *var_val,
3825 + u_char var_val_type,
3826 + size_t var_val_len,
3827 + u_char *statP,
3828 + oid *name,
3829 + size_t name_len)
3830 +{
3831 + static long *long_ret;
3832 + int size;
3833 +
3834 + switch ( action ) {
3835 +
3836 + case RESERVE1:
3837 + if ( var_val_type != ASN_INTEGER ) {
3838 + fprintf ( stderr, "write to dot11SupportedRxAntenna not ASN_INTEGER\n" );
3839 + return SNMP_ERR_WRONGTYPE;
3840 + }
3841 + if ( var_val_len > sizeof ( long_ret )){
3842 + fprintf ( stderr,"write to dot11SupportedRxAntenna: bad length\n" );
3843 + return SNMP_ERR_WRONGLENGTH;
3844 + }
3845 + break;
3846 +
3847 + case RESERVE2:
3848 + case FREE:
3849 + case ACTION:
3850 + case UNDO:
3851 + break;
3852 +
3853 + case COMMIT:
3854 + break;
3855 + }
3856 +
3857 + return SNMP_ERR_NOERROR;
3858 +}
3859 +
3860 +/****************************************************************************
3861 +* *
3862 +****************************************************************************/
3863 +int
3864 +write_dot11DiversitySelectionRx(int action,
3865 + u_char *var_val,
3866 + u_char var_val_type,
3867 + size_t var_val_len,
3868 + u_char *statP,
3869 + oid *name,
3870 + size_t name_len)
3871 +{
3872 + static long *long_ret;
3873 + int size;
3874 +
3875 + switch ( action ) {
3876 +
3877 + case RESERVE1:
3878 + if ( var_val_type != ASN_INTEGER ) {
3879 + fprintf ( stderr, "write to dot11DiversitySelectionRx not ASN_INTEGER\n" );
3880 + return SNMP_ERR_WRONGTYPE;
3881 + }
3882 + if ( var_val_len > sizeof ( long_ret )){
3883 + fprintf ( stderr, "write to dot11DiversitySelectionRx: bad length\n" );
3884 + return SNMP_ERR_WRONGLENGTH;
3885 + }
3886 + break;
3887 +
3888 + case RESERVE2:
3889 + case FREE:
3890 + case ACTION:
3891 + case UNDO:
3892 + break;
3893 +
3894 + case COMMIT:
3895 + break;
3896 + }
3897 +
3898 + return SNMP_ERR_NOERROR;
3899 +}
3900 +
3901 +/****************************************************************************
3902 +* *
3903 +* loadTables() - Load the Tables *
3904 +* *
3905 +****************************************************************************/
3906 +static void loadTables()
3907 +{
3908 + int skfd; // generic raw socket desc
3909 + struct iwreq wrq; // ioctl request structure
3910 + struct ifreq ifr;
3911 + struct timeval et; // elapsed time
3912 + struct wireless_info info; // workarea for wireless ioctl information
3913 + FILE *fp;
3914 + char bfr[1024], ifName[1024];
3915 + char *s, *t;
3916 +
3917 + gettimeofday ( &et, ( struct timezone * ) 0 ); // get time-of-day
3918 + if ( et.tv_sec < lastLoad + MINLOADFREQ ) // only reload so often
3919 + return;
3920 + lastLoad = et.tv_sec;
3921 +
3922 + skfd = openSocket(); // open socket
3923 + if ( skfd < 0 ) {
3924 + syslog ( LOG_ERR, "SNMP ieee802dot11.loadTables() - %s\n", "socket open failure" );
3925 + return;
3926 + }
3927 +
3928 + flushLists();
3929 +
3930 + // find interfaces in /proc/net/dev and find the wireless interfaces
3931 + fp = fopen ( PROC_NET_DEV, "r" );
3932 + if ( fp ) {
3933 + while ( fgets ( bfr, sizeof ( bfr ), fp )) {
3934 + if ( strstr ( bfr, ":" )) {
3935 + s = bfr; t = ifName;
3936 + while ( isspace ( *s )) // discard white space
3937 + *s++;
3938 + while ( *s != ':' ) // get interface name
3939 + *t++ = *s++;
3940 + *t = '\0';
3941 +
3942 + // verify as a wireless device
3943 + memset (( char * ) &info, 0, sizeof ( struct wireless_info ));
3944 + strncpy ( wrq.ifr_name, ifName, IFNAMSIZ );
3945 + if ( ioctl ( skfd, SIOCGIWNAME, &wrq ) >= 0 ) {
3946 + printf ( "%s ifName: %s\n", "loadTables() -", ifName );
3947 + initStructs();
3948 + loadWiExt( skfd, ifName, &info );
3949 + displayWiExt ( info );
3950 + load80211Structs ( skfd, ifName, &info );
3951 + }
3952 + }
3953 + }
3954 + fclose ( fp );
3955 + }
3956 +
3957 + close ( skfd );
3958 +}
3959 +
3960 +/****************************************************************************
3961 +* *
3962 +* load80211Structs() - load the 802.11 structures *
3963 +* *
3964 +****************************************************************************/
3965 +static void
3966 +load80211Structs ( int skfd, char *ifName, struct wireless_info *wi )
3967 +{
3968 + int rc, ifIndex = 0;
3969 + struct ifreq ifr;
3970 + char MACAddress [ MACADDR_LEN + 1 ];
3971 +
3972 + strcpy ( ifr.ifr_name, ifName );
3973 + rc = ioctl ( skfd, SIOCGIFHWADDR, &ifr );
3974 + if ( rc >= 0 ) {
3975 +
3976 + sprintf ( MACAddress, "%02X:%02X:%02X:%02X:%02X:%02X\0",
3977 + ( UCHAR ) ifr.ifr_hwaddr.sa_data[0], ( UCHAR ) ifr.ifr_hwaddr.sa_data[1],
3978 + ( UCHAR ) ifr.ifr_hwaddr.sa_data[2], ( UCHAR ) ifr.ifr_hwaddr.sa_data[3],
3979 + ( UCHAR ) ifr.ifr_hwaddr.sa_data[4], ( UCHAR ) ifr.ifr_hwaddr.sa_data[5] );
3980 +
3981 + nSc.haveStationID = TRUE;
3982 + strcpy ( nSc.stationID, MACAddress );
3983 + nOp.haveMACAddress = TRUE;
3984 + strcpy ( nOp.MACAddress, MACAddress );
3985 + nRi.haveManufacturerOUI = TRUE;
3986 + strncpy ( nRi.manufacturerOUI, MACAddress, MAN_OUI_LEN );
3987 +
3988 + ifIndex = if_nametoindex ( ifName );
3989 + if ( !ifIndex ) {
3990 + syslog ( LOG_ERR, "SNMP %s - %s %s\n",
3991 + "ieee802dot11.load80211Structs()", ifName, "has no ifIndex" );
3992 + return;
3993 + }
3994 +
3995 + loadWiExtTo80211Structs ( ifIndex, ifName, wi );
3996 +
3997 + if ( hasChanged (( char * ) &nSc, sizeof ( nSc ))) {
3998 + nSc.ifIndex = ifIndex;
3999 + sprintf ( nSc.UID, "%04d\0", nSc.ifIndex );
4000 + strcpy ( nSc.ifName, ifName );
4001 + addList (( char * ) &scList, ( char * ) &nSc, sizeof ( nSc ));
4002 + }
4003 +
4004 + if ( hasChanged (( char * ) &nPr, sizeof ( nPr ))) {
4005 + nPr.ifIndex = ifIndex;
4006 + sprintf ( nPr.UID, "%04d\0", nPr.ifIndex );
4007 + strcpy ( nPr.ifName, ifName );
4008 + addList (( char * ) &prList, ( char * ) &nPr, sizeof ( nPr ));
4009 + }
4010 +
4011 + if ( hasChanged (( char * ) &nOp, sizeof ( nOp ))) {
4012 + nOp.ifIndex = ifIndex;
4013 + sprintf ( nOp.UID, "%04d\0", nOp.ifIndex );
4014 + strcpy ( nOp.ifName, ifName );
4015 + addList (( char * ) &opList, ( char * ) &nOp, sizeof ( nOp ));
4016 + }
4017 +
4018 + if ( hasChanged (( char * ) &nCo, sizeof ( nCo ))) {
4019 + nCo.ifIndex = ifIndex;
4020 + sprintf ( nCo.UID, "%04d\0", nCo.ifIndex );
4021 + strcpy ( nCo.ifName, ifName );
4022 + addList (( char * ) &coList, ( char * ) &nCo, sizeof ( nCo ));
4023 + }
4024 +
4025 + if ( hasChanged (( char * ) &nRi, sizeof ( nRi ))) {
4026 + nRi.ifIndex = ifIndex;
4027 + sprintf ( nRi.UID, "%04d\0", nRi.ifIndex );
4028 + strcpy ( nRi.ifName, ifName );
4029 + addList (( char * ) &riList, ( char * ) &nRi, sizeof ( nRi ));
4030 + }
4031 +
4032 + if ( hasChanged (( char * ) &nPo, sizeof ( nPo ))) {
4033 + nPo.ifIndex = ifIndex;
4034 + sprintf ( nPo.UID, "%04d\0", nPo.ifIndex );
4035 + strcpy ( nPo.ifName, ifName );
4036 + addList (( char * ) &poList, ( char * ) &nPo, sizeof ( nPo ));
4037 + }
4038 +
4039 + if ( hasChanged (( char * ) &nPa, sizeof ( nPa ))) {
4040 + nPa.ifIndex = ifIndex;
4041 + sprintf ( nPa.UID, "%04d\0", nPa.ifIndex );
4042 + strcpy ( nPa.ifName, ifName );
4043 + addList (( char * ) &paList, ( char * ) &nPa, sizeof ( nPa ));
4044 + }
4045 +
4046 + if ( hasChanged (( char * ) &nPt, sizeof ( nPt ))) {
4047 + nPt.ifIndex = ifIndex;
4048 + sprintf ( nPt.UID, "%04d\0", nPt.ifIndex );
4049 + strcpy ( nPt.ifName, ifName );
4050 + addList (( char * ) &ptList, ( char * ) &nPt, sizeof ( nPt ));
4051 + }
4052 +
4053 + if ( hasChanged (( char * ) &nPf, sizeof ( nPf ))) {
4054 + nPf.ifIndex = ifIndex;
4055 + sprintf ( nPf.UID, "%04d\0", nPf.ifIndex );
4056 + strcpy ( nPf.ifName, ifName );
4057 + addList (( char * ) &pfList, ( char * ) &nPf, sizeof ( nPf ));
4058 + }
4059 +
4060 + if ( hasChanged (( char * ) &nPd, sizeof ( nPd ))) {
4061 + nPd.ifIndex = ifIndex;
4062 + sprintf ( nPd.UID, "%04d\0", nPd.ifIndex );
4063 + strcpy ( nPd.ifName, ifName );
4064 + addList (( char * ) &pdList, ( char * ) &nPd, sizeof ( nPd ));
4065 + }
4066 +
4067 + if ( hasChanged (( char * ) &nPi, sizeof ( nPi ))) {
4068 + nPi.ifIndex = ifIndex;
4069 + sprintf ( nPi.UID, "%04d\0", nPi.ifIndex );
4070 + strcpy ( nPi.ifName, ifName );
4071 + addList (( char * ) &piList, ( char * ) &nPi, sizeof ( nPi ));
4072 + }
4073 + }
4074 +
4075 +//printf ( "%s - ifIndex: %d ifName: %s UID: %s\n",
4076 +// "load80211Structs() - HASCHANGED", ifIndex, ifName, nSc.UID );
4077 +}
4078 +
4079 +/****************************************************************************
4080 +* *
4081 +* initStructs() - initialize structures *
4082 +* *
4083 +****************************************************************************/
4084 +static void initStructs()
4085 +{
4086 + int i;
4087 +
4088 + // 802.11 MIB Stuctures
4089 + memset (( char * ) &nSc, 0, sizeof ( nSc )); memset (( char * ) &nAa, 0, sizeof ( nAa ));
4090 + memset (( char * ) &nDf, 0, sizeof ( nDf )); memset (( char * ) &nKm, 0, sizeof ( nKm ));
4091 + memset (( char * ) &nPr, 0, sizeof ( nPr )); memset (( char * ) &nOp, 0, sizeof ( nOp ));
4092 + memset (( char * ) &nCo, 0, sizeof ( nCo )); memset (( char * ) &nGa, 0, sizeof ( nGa ));
4093 + memset (( char * ) &nRi, 0, sizeof ( nRi )); memset (( char * ) &nPo, 0, sizeof ( nPo ));
4094 + memset (( char * ) &nPa, 0, sizeof ( nPa )); memset (( char * ) &nPt, 0, sizeof ( nPt ));
4095 + memset (( char * ) &nPf, 0, sizeof ( nPf )); memset (( char * ) &nPd, 0, sizeof ( nPd ));
4096 + memset (( char * ) &nPi, 0, sizeof ( nPi )); memset (( char * ) &nRd, 0, sizeof ( nRd ));
4097 + memset (( char * ) &nAl, 0, sizeof ( nAl )); memset (( char * ) &nRt, 0, sizeof ( nRt ));
4098 + memset (( char * ) &nRr, 0, sizeof ( nRr ));
4099 +
4100 + // Wireless Extensions
4101 + wepCurrentKey = 0;
4102 + haveWepCurrentKey = FALSE;
4103 + for ( i = 0; i < MAX_WEP_KEYS; i++ ) {
4104 + wep[i].len = 0;
4105 + wep[i].key[0] = '\0';
4106 + wep[i].haveKey = FALSE;
4107 + }
4108 +}
4109 +
4110 +/****************************************************************************
4111 +* *
4112 +* Wireless Extensions Specific Functions *
4113 +* *
4114 +****************************************************************************/
4115 +/****************************************************************************
4116 +* *
4117 +* loadWiExtTo80211Structs() - load wireless extensions to 802.11 structures *
4118 +* *
4119 +****************************************************************************/
4120 +static void
4121 +loadWiExtTo80211Structs ( int ifIndex, char *ifName, struct wireless_info *wi )
4122 +{
4123 + int i, j = 0;
4124 +
4125 + // dot11Smt Group
4126 + // dot11StationConfigTable
4127 + nSc.havePrivacyOptionImplemented = TRUE;
4128 + nSc.privacyOptionImplemented = 1; // assume we support WEP
4129 +
4130 + if ( wi->has_power ) {
4131 + nSc.havePowerManagementMode = TRUE;
4132 + nSc.powerManagementMode = 1; // assume power is active
4133 + if ( !wi->power.disabled &&
4134 + wi->power.flags & IW_POWER_MIN )
4135 + nSc.powerManagementMode = 2; // power save mode
4136 + }
4137 +
4138 + if ( wi->has_essid && strlen ( wi->essid )) {
4139 + nSc.haveDesiredSSID = TRUE;
4140 + strcpy ( nSc.desiredSSID, wi->essid );
4141 + }
4142 +
4143 + if ( wi->has_mode ) {
4144 + nSc.haveDesiredBSSType = TRUE;
4145 + if ( wi->mode == IW_MODE_ADHOC )
4146 + nSc.desiredBSSType = 2; // independent
4147 + else if ( wi->has_ap_addr )
4148 + nSc.desiredBSSType = 1; // infrastructure
4149 + else
4150 + nSc.desiredBSSType = 3; // any
4151 + }
4152 +
4153 + if ( wi->has_range ) {
4154 + for ( i = 0; i < wi->range.num_bitrates && j < 126; i++ ) {
4155 + nSc.haveOperationalRateSet = TRUE;
4156 + nSc.operationalRateSet[j++] = ( char ) ( wi->range.bitrate[i] / 500000L );
4157 + }
4158 + }
4159 +
4160 + // dot11AuthenticationAlgorithmsTable
4161 + nAa.haveAuthenticationAlgorithm = TRUE; // it's a rule to always have
4162 + nAa.haveAuthenticationAlgorithmsEnable = TRUE; // 'open' supported
4163 + nAa.ifIndex = ifIndex;
4164 + nAa.authenticationAlgorithmsIndex = 1; // index number one
4165 + nAa.authenticationAlgorithm = 1; // 1 => open key
4166 + sprintf ( nAa.UID, "%04d%04d\0", nAa.ifIndex, nAa.authenticationAlgorithmsIndex );
4167 + nAa.authenticationAlgorithmsEnable = 1; // enabled by default
4168 + if ( ( wi->has_key ) &&
4169 + ( wi->key_size != 0 ) &&
4170 + !( wi->key_flags & IW_ENCODE_DISABLED ))
4171 + nAa.authenticationAlgorithmsEnable = 2;
4172 + addList (( char * ) &aaList, ( char * ) &nAa, sizeof ( nAa ));
4173 +
4174 + nAa.haveAuthenticationAlgorithm = TRUE; // I'm gonna assume we always support WEP
4175 + nAa.haveAuthenticationAlgorithmsEnable = TRUE;
4176 + nAa.ifIndex = ifIndex;
4177 + nAa.authenticationAlgorithmsIndex = 2; // index number 2
4178 + nAa.authenticationAlgorithm = 2; // 2 => shared key
4179 + sprintf ( nAa.UID, "%04d%04d\0", nAa.ifIndex, nAa.authenticationAlgorithmsIndex );
4180 + nAa.authenticationAlgorithmsEnable = 2;
4181 + if ( ( wi->has_key ) &&
4182 + ( wi->key_size != 0 ) &&
4183 + !( wi->key_flags & IW_ENCODE_DISABLED ))
4184 + nAa.authenticationAlgorithmsEnable = 1; // disabled by default
4185 + addList (( char * ) &aaList, ( char * ) &nAa, sizeof ( nAa ));
4186 +
4187 + //dot11WEPDefaultKeysTable
4188 + if ( wi->has_range ) {
4189 + for ( i = 0; i < MAX_WEP_KEYS; i++ ) {
4190 + nDf.haveWEPDefaultKeyValue = TRUE;
4191 + nDf.ifIndex = ifIndex;
4192 + nDf.WEPDefaultKeyIndex = i + 1; // index number
4193 + sprintf ( nDf.UID, "%04d%04d\0", nDf.ifIndex, nDf.WEPDefaultKeyIndex );
4194 + if ( wep[i].haveKey )
4195 + strcpy ( nDf.WEPDefaultKeyValue, "*****" );
4196 + else
4197 + nDf.WEPDefaultKeyValue[0] = '\0';
4198 + addList (( char * ) &dfList, ( char * ) &nDf, sizeof ( nDf ));
4199 + }
4200 + }
4201 +
4202 + // dot11PrivacyTable
4203 + nPr.havePrivacyInvoked = TRUE;
4204 + nPr.privacyInvoked = 2; // 2 => FALSE
4205 + nPr.haveWEPDefaultKeyID = TRUE;
4206 + nPr.WEPDefaultKeyID = 0;
4207 + nPr.haveExcludeUnencrypted = TRUE;
4208 + nPr.excludeUnencrypted = 2; // 2 => FALSE
4209 + if ( wi->has_range ) {
4210 + if ( ( wi->key_size != 0 ) &&
4211 + !( wi->key_flags & IW_ENCODE_DISABLED )) {
4212 + nPr.privacyInvoked = 1;
4213 + if ( wi->key_flags & IW_ENCODE_RESTRICTED )
4214 + nPr.excludeUnencrypted = 1;
4215 + nPr.WEPDefaultKeyID = wepCurrentKey;
4216 + }
4217 + }
4218 +
4219 + // dot11Mac Group
4220 + // dot11OperationTable
4221 + if ( wi->has_range ) {
4222 + nOp.haveRTSThreshold = TRUE;
4223 + nOp.RTSThreshold = wi->range.max_rts;
4224 + }
4225 +
4226 + if ( wi->has_frag && wi->frag.value ) {
4227 + nOp.haveFragmentationThreshold = TRUE;
4228 + nOp.fragmentationThreshold = wi->frag.value;
4229 + }
4230 +
4231 + // dot11Phy Group
4232 + // dot11PhyOperationTable
4233 + if ( strstr ( wi->name, "IEEE 802.11-FS" )) nPo.PHYType = 1; // So what if I
4234 + if ( strstr ( wi->name, "IEEE 802.11-DS" )) nPo.PHYType = 2; // made up a couple?
4235 + if ( strstr ( wi->name, "IEEE 802.11-IR" )) nPo.PHYType = 3;
4236 + if ( strstr ( wi->name, "IEEE 802.11-OFDM" )) nPo.PHYType = 4; // 802.11a
4237 + if ( strstr ( wi->name, "IEEE 802.11-OFDM/DS" )) nPo.PHYType = 5; // 802.11g
4238 + if ( strstr ( wi->name, "IEEE 802.11-TURBO" )) nPo.PHYType = 6; // Atheros TURBO mode
4239 + if ( nPo.PHYType ) nPo.havePHYType = TRUE;
4240 +
4241 + // dot11PhyDSSSTable
4242 + if ( wi->has_range ) { // && wi->freq <= ( double ) 2483000000 ) { // DSSS frequencies only
4243 + for ( i = 0; i < wi->range.num_frequency; i++ ) {
4244 + if ((( double ) ( wi->range.freq[i].e * 10 ) * ( double ) wi->range.freq[i].m ) == wi->freq ) {
4245 + nPd.haveCurrentChannel = TRUE;
4246 + nPd.currentChannel = wi->range.freq[i].i;
4247 + }
4248 + }
4249 + }
4250 +
4251 + // dot11SupportedDataRatesTxTable
4252 + if ( wi->has_range ) {
4253 + for ( i = 0; i < wi->range.num_bitrates; i++ ) {
4254 + nRt.ifIndex = ifIndex;
4255 + nRt.supportedDataRatesTxIndex = i + 1;
4256 + nRt.supportedDataRatesTxValue = wi->range.bitrate[i] / 500000L;
4257 + nRt.haveSupportedDataRatesTxValue = TRUE;
4258 + sprintf ( nRt.UID, "%04d%04d\0", nRt.ifIndex, nRt.supportedDataRatesTxIndex );
4259 + strcpy ( nRt.ifName, ifName );
4260 + addList (( char * ) &rtList, ( char * ) &nRt, sizeof ( nRt ));
4261 + }
4262 + }
4263 +
4264 + // dot11SupportedDataRatesRxTable
4265 + if ( wi->has_range ) {
4266 + for ( i = 0; i < wi->range.num_bitrates; i++ ) {
4267 + nRr.ifIndex = ifIndex;
4268 + nRr.supportedDataRatesRxIndex = i + 1;
4269 + nRr.supportedDataRatesRxValue = wi->range.bitrate[i] / 500000L;
4270 + nRr.haveSupportedDataRatesRxValue = TRUE;
4271 + sprintf ( nRr.UID, "%04d%04d\0", nRr.ifIndex, nRr.supportedDataRatesRxIndex );
4272 + strcpy ( nRr.ifName, ifName );
4273 + addList (( char * ) &rrList, ( char * ) &nRr, sizeof ( nRr ));
4274 + }
4275 + }
4276 +
4277 +//printf ( "%s max_encoding_tokens: %d\n",
4278 +// "loadWiExtTo80211Structs() - ", wi->range.max_encoding_tokens );
4279 +}
4280 +
4281 +/****************************************************************************
4282 +* *
4283 +* loadWiExt() - load wireless extensions structures; *
4284 +* use ioctl calls and read /proc/net/wireless *
4285 +* *
4286 +****************************************************************************/
4287 +static void loadWiExt ( int skfd, char *ifname, struct wireless_info *wi )
4288 +{
4289 + struct iwreq wrq; // ioctl request structure
4290 + FILE *fp;
4291 + char bfr[1024];
4292 + char buffer[sizeof ( iwrange ) * 2]; /* Large enough */
4293 + char *s, *t;
4294 + int i, j;
4295 +
4296 + strncpy ( wrq.ifr_name, ifname, IFNAMSIZ );
4297 +
4298 + /* Get wireless name */
4299 + if ( ioctl ( skfd, SIOCGIWNAME, &wrq ) >= 0 ) {
4300 + strncpy ( wi->name, wrq.u.name, IFNAMSIZ );
4301 + wi->name[IFNAMSIZ] = '\0';
4302 + }
4303 +
4304 + /* Get ranges */ // NOTE: some version checking in iwlib.c
4305 + memset ( buffer, 0, sizeof ( buffer ));
4306 + wrq.u.data.pointer = ( caddr_t ) &buffer;
4307 + wrq.u.data.length = sizeof ( buffer );
4308 + wrq.u.data.flags = 0;
4309 + if ( ioctl ( skfd, SIOCGIWRANGE, &wrq ) >= 0 ) {
4310 + memcpy (( char * ) &wi->range, buffer, sizeof ( iwrange ));
4311 + wi->has_range = 1;
4312 + }
4313 +
4314 + /* Get network ID */
4315 + if ( ioctl ( skfd, SIOCGIWNWID, &wrq ) >= 0 ) {
4316 + memcpy ( &wi->nwid, &wrq.u.nwid, sizeof ( iwparam ));
4317 + wi->has_nwid = 1;
4318 + }
4319 +
4320 + /* Get frequency / channel */ // THIS NUMBER LOOKS FUNNY
4321 + if ( ioctl ( skfd, SIOCGIWFREQ, &wrq ) >= 0 ) {
4322 + wi->has_freq = 1;
4323 + wi->freq = (( double ) wrq.u.freq.m ) * pow ( 10, wrq.u.freq.e );
4324 + }
4325 +
4326 + /* Get sensitivity */
4327 + if ( ioctl ( skfd, SIOCGIWSENS, &wrq ) >= 0 ) {
4328 + wi->has_sens = 1;
4329 + memcpy ( &wi->sens, &wrq.u.sens, sizeof ( iwparam ));
4330 + }
4331 +
4332 + /* Get encryption information */
4333 + wrq.u.data.pointer = ( caddr_t ) &wi->key;
4334 + wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
4335 + wrq.u.data.flags = 0;
4336 + if ( ioctl ( skfd, SIOCGIWENCODE, &wrq ) >= 0 ) {
4337 + wi->has_key = 1;
4338 + wi->key_size = wrq.u.data.length;
4339 + wi->key_flags = wrq.u.data.flags;
4340 + wepCurrentKey = wrq.u.data.flags & IW_ENCODE_INDEX;
4341 + }
4342 +
4343 + for ( i = 0; i < wi->range.max_encoding_tokens; i++ ) {
4344 + wrq.u.data.pointer = ( caddr_t ) &wi->key;
4345 + wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
4346 + wrq.u.data.flags = i;
4347 + if ( ioctl ( skfd, SIOCGIWENCODE, &wrq ) >= 0 ) {
4348 + if ( ( wrq.u.data.length != 0 ) &&
4349 + !( wrq.u.data.flags & IW_ENCODE_DISABLED )) {
4350 + wep[i].len = wrq.u.data.length;
4351 + wep[i].haveKey = TRUE;
4352 + t = wep[i].key;
4353 + for ( j = 0; j < wrq.u.data.length; j++ ) {
4354 + if (( j & 0x1 ) == 0 && j != 0 )
4355 + strcpy ( t++, "-");
4356 + sprintf ( t, "%.2X", wi->key[j] );
4357 + t += 2;
4358 + }
4359 + t = '\0';
4360 + }
4361 + }
4362 + }
4363 +
4364 + /* Get ESSID */
4365 + wrq.u.essid.pointer = ( caddr_t ) &wi->essid;
4366 + wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
4367 + wrq.u.essid.flags = 0;
4368 + if ( ioctl ( skfd, SIOCGIWESSID, &wrq ) >= 0 ) {
4369 + wi->has_essid = 1;
4370 + wi->essid_on = wrq.u.data.flags;
4371 + }
4372 +
4373 + /* Get AP address */
4374 + if ( ioctl ( skfd, SIOCGIWAP, &wrq ) >= 0 ) {
4375 + wi->has_ap_addr = 1;
4376 + memcpy ( &wi->ap_addr, &wrq.u.ap_addr, sizeof ( sockaddr ));
4377 + }
4378 +
4379 + /* Get NickName */
4380 + wrq.u.essid.pointer = ( caddr_t ) &wi->nickname;
4381 + wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
4382 + wrq.u.essid.flags = 0;
4383 + if ( ioctl ( skfd, SIOCGIWNICKN, &wrq ) >= 0 ) {
4384 + if ( wrq.u.data.length > 1 )
4385 + wi->has_nickname = 1;
4386 + }
4387 +
4388 + /* Get bit rate */
4389 + if ( ioctl ( skfd, SIOCGIWRATE, &wrq ) >= 0 ) {
4390 + wi->has_bitrate = 1;
4391 + memcpy ( &wi->bitrate, &wrq.u.bitrate, sizeof ( iwparam ));
4392 + }
4393 +
4394 + /* Get RTS threshold */
4395 + if ( ioctl ( skfd, SIOCGIWRTS, &wrq ) >= 0 ) {
4396 + wi->has_rts = 1;
4397 + memcpy ( &wi->rts, &wrq.u.rts, sizeof ( iwparam ));
4398 + }
4399 +
4400 + /* Get fragmentation threshold */
4401 + if ( ioctl ( skfd, SIOCGIWFRAG, &wrq ) >= 0 ) {
4402 + wi->has_frag = 1;
4403 + memcpy ( &wi->frag, &wrq.u.frag, sizeof ( iwparam ));
4404 + }
4405 +
4406 + /* Get operation mode */
4407 + if ( ioctl ( skfd, SIOCGIWMODE, &wrq ) >= 0 ) {
4408 + wi->mode = wrq.u.mode;
4409 + if ( wi->mode < IW_NUM_OPER_MODE && wi->mode >= 0 )
4410 + wi->has_mode = 1;
4411 + }
4412 +
4413 + /* Get Power Management settings */ // #if WIRELESS_EXT > 9
4414 + wrq.u.power.flags = 0;
4415 + if ( ioctl ( skfd, SIOCGIWPOWER, &wrq ) >= 0 ) {
4416 + wi->has_power = 1;
4417 + memcpy ( &wi->power, &wrq.u.power, sizeof ( iwparam ));
4418 + }
4419 +
4420 + /* Get retry limit/lifetime */ // #if WIRELESS_EXT > 10
4421 + if ( ioctl ( skfd, SIOCGIWRETRY, &wrq ) >= 0 ) {
4422 + wi->has_retry = 1;
4423 + memcpy ( &wi->retry, &wrq.u.retry, sizeof ( iwparam ));
4424 + }
4425 +
4426 + /* Get stats */ // #if WIRELESS_EXT > 11
4427 + wrq.u.data.pointer = ( caddr_t ) &wi->stats;
4428 + wrq.u.data.length = 0;
4429 + wrq.u.data.flags = 1; /* Clear updated flag */
4430 + if ( ioctl ( skfd, SIOCGIWSTATS, &wrq ) < 0 )
4431 + wi->has_stats = 1;
4432 +
4433 + if ( !wi->has_stats ) { // no ioctl support, go to file
4434 + fp = fopen ( PROC_NET_WIRELESS, "r" );
4435 + if ( fp ) {
4436 + while ( fgets ( bfr, sizeof ( bfr ), fp )) {
4437 + bfr [ sizeof ( bfr ) - 1 ] = '\0'; // no buffer overruns here!
4438 + strtok (( char * ) &bfr, "\n" ); // '\n' => '\0'
4439 + if ( strstr ( bfr, ifname ) && strstr ( bfr, ":" )) {
4440 + wi->has_stats = 1;
4441 + s = bfr;
4442 + s = strchr ( s, ':' ); s++; /* Skip ethX: */
4443 + s = strtok ( s, " " ); /* ' ' => '\0' */
4444 + sscanf ( s, "%X", &wi->stats.status ); // status
4445 +
4446 + s = strtok ( NULL, " " ); // link quality
4447 + if ( strchr ( s, '.' ) != NULL )
4448 + wi->stats.qual.updated |= 1;
4449 + sscanf ( s, "%d", &wi->stats.qual.qual );
4450 +
4451 + s = strtok ( NULL, " " ); // signal level
4452 + if ( strchr ( s,'.' ) != NULL )
4453 + wi->stats.qual.updated |= 2;
4454 + sscanf ( s, "%d", &wi->stats.qual.level );
4455 +
4456 + s = strtok ( NULL, " " ); // noise level
4457 + if ( strchr ( s, '.' ) != NULL )
4458 + wi->stats.qual.updated += 4;
4459 + sscanf ( s, "%d", &wi->stats.qual.noise );
4460 +
4461 + s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.nwid );
4462 + s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.code );
4463 + s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.fragment );
4464 + s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.retries );
4465 + s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.misc );
4466 + s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.miss.beacon );
4467 + }
4468 + }
4469 + fclose ( fp );
4470 + }
4471 + }
4472 +
4473 +// printf ( "%s bfr: %s\n", "loadTables()", bfr );
4474 +}
4475 +
4476 +/****************************************************************************
4477 +* *
4478 +* displayWiExt() - show what I got from Wireless Extensions *
4479 +* *
4480 +****************************************************************************/
4481 +static void displayWiExt ( struct wireless_info info )
4482 +{
4483 +#ifdef DISPLAYWIEXT
4484 + int i;
4485 + char title[] = "displayWiExt() -";
4486 +
4487 + printf ( "========================================\n" );
4488 + printf ( "===> Wireless Extension IOCTL calls <===\n" );
4489 + printf ( "========================================\n" );
4490 +
4491 + if ( strlen ( info.name ))
4492 + printf ( "%s name: %s\n", "SIOCGIWNAME", info.name );
4493 + else
4494 + printf ( "%s\n", "no info.name support" );
4495 +
4496 + if ( info.has_nickname = 1 )
4497 + printf ( "%s nickname: %s\n", "SIOCGIWNICKN", info.nickname );
4498 + else
4499 + printf ( "%s %s\n", "SIOCGIWNICKN", " ===> no info.nickname support" );
4500 +
4501 + if ( info.has_essid )
4502 + printf ( "%s essid_on: %d essid: %s\n", "SIOCGIWESSID", info.essid_on, info.essid );
4503 + else
4504 + printf ( "%s %s\n", "SIOCGIWESSID", " ===> no info.essid support" );
4505 +
4506 + if ( info.has_range ) {
4507 + printf ( "%s throughput: %d\n", "SIOCGIWRANGE", info.range.throughput );
4508 + printf ( "%s min_nwid: %d\n", "SIOCGIWRANGE", info.range.min_nwid );
4509 + printf ( "%s max_nwid: %d\n", "SIOCGIWRANGE", info.range.max_nwid );
4510 + printf ( "%s sensitivity: %d\n", "SIOCGIWRANGE", info.range.sensitivity );
4511 + printf ( "%s num_bitrates: %d\n", "SIOCGIWRANGE", info.range.num_bitrates );
4512 + for ( i = 0; i < info.range.num_bitrates; i++ )
4513 + printf ( "%s bitrate[%d]: %d\n", "SIOCGIWRANGE", i, info.range.bitrate[i] );
4514 + printf ( "%s min_rts: %d\n", "SIOCGIWRANGE", info.range.min_rts );
4515 + printf ( "%s max_rts: %d\n", "SIOCGIWRANGE", info.range.max_rts );
4516 + printf ( "%s min_frag: %d\n", "SIOCGIWRANGE", info.range.min_frag );
4517 + printf ( "%s max_frag: %d\n", "SIOCGIWRANGE", info.range.max_frag );
4518 + printf ( "%s min_pmp: %d\n", "SIOCGIWRANGE", info.range.min_pmp );
4519 + printf ( "%s max_pmp: %d\n", "SIOCGIWRANGE", info.range.max_pmp );
4520 + printf ( "%s min_pmt: %d\n", "SIOCGIWRANGE", info.range.min_pmt );
4521 + printf ( "%s max_pmt: %d\n", "SIOCGIWRANGE", info.range.max_pmt );
4522 + printf ( "%s pmp_flags: %d\n", "SIOCGIWRANGE", info.range.pmp_flags );
4523 + printf ( "%s pmt_flags: %d\n", "SIOCGIWRANGE", info.range.pmt_flags );
4524 + printf ( "%s pm_capa: %d\n", "SIOCGIWRANGE", info.range.pm_capa );
4525 + printf ( "%s num_encoding_sizes: %d\n", "SIOCGIWRANGE", info.range.num_encoding_sizes );
4526 + for ( i = 0; i < info.range.num_encoding_sizes; i++ )
4527 + printf ( "%s encoding_size[%d]: %d\n", "SIOCGIWRANGE", i, info.range.encoding_size[i] );
4528 + printf ( "%s max_encoding_tokens: %d\n", "SIOCGIWRANGE", info.range.max_encoding_tokens );
4529 +// printf ( "%s encoding_login_index: %d\n", "SIOCGIWRANGE", info.range.encoding_login_index );
4530 + printf ( "%s txpower_capa: %d\n", "SIOCGIWRANGE", info.range.txpower_capa );
4531 + printf ( "%s num_txpower: %d dBm\n", "SIOCGIWRANGE", info.range.num_txpower );
4532 + for ( i = 0; i < info.range.num_txpower; i++ )
4533 + printf ( "%s txpower[%d]: %d\n", "SIOCGIWRANGE", i, info.range.txpower[i] );
4534 + printf ( "%s we_version_compiled: %d\n", "SIOCGIWRANGE", info.range.we_version_compiled );
4535 + printf ( "%s we_version_source: %d\n", "SIOCGIWRANGE", info.range.we_version_source );
4536 + printf ( "%s retry_capa: %d\n", "SIOCGIWRANGE", info.range.retry_capa );
4537 + printf ( "%s retry_flags: %d\n", "SIOCGIWRANGE", info.range.retry_flags );
4538 + printf ( "%s r_time_flags: %d\n", "SIOCGIWRANGE", info.range.r_time_flags );
4539 + printf ( "%s min_retry: %d\n", "SIOCGIWRANGE", info.range.min_retry );
4540 + printf ( "%s max_retry: %d\n", "SIOCGIWRANGE", info.range.max_retry );
4541 + printf ( "%s min_r_time: %d\n", "SIOCGIWRANGE", info.range.min_r_time );
4542 + printf ( "%s max_r_time: %d\n", "SIOCGIWRANGE", info.range.max_r_time );
4543 + printf ( "%s num_channels: %d\n", "SIOCGIWRANGE", info.range.num_channels );
4544 + printf ( "%s num_frequency: %d\n", "SIOCGIWRANGE", info.range.num_frequency );
4545 + for ( i = 0; i < info.range.num_frequency; i++ )
4546 + printf ( "%s freq[%d].i: %d freq[%d].e: %d freq[%d].m: %d\n", "SIOCGIWRANGE",
4547 + i, info.range.freq[i].i, i, info.range.freq[i].e, i, info.range.freq[i].m );
4548 + }
4549 + else
4550 + printf ( "%s %s\n", "SIOCGIWRANGE", " ===> no info.range support" );
4551 +
4552 + if ( info.has_nwid )
4553 + printf ( "%s nwid - disabled: %d value: %X\n", "SIOCGIWNWID", info.nwid.disabled, info.nwid.value );
4554 + else
4555 + printf ( "%s %s\n", "SIOCGIWNWID", " ===> no info.nwid support" );
4556 +
4557 + if ( info.has_freq ) {
4558 +// printf ( "%s freq: %g\n", "SIOCGIWFREQ", info.freq / GIGA );
4559 + printf ( "%s freq: %g\n", "SIOCGIWFREQ", info.freq );
4560 + }
4561 + else
4562 + printf ( "%s %s\n", "SIOCGIWFREQ", " ===> no info.freq support" );
4563 +
4564 + if ( info.has_sens )
4565 + printf ( "%s sens: %d\n", "SIOCGIWSENS", info.sens );
4566 + else
4567 + printf ( "%s %s\n", "SIOCGIWSENS", " ===> no info.sens support" );
4568 +
4569 + if ( info.has_key ) {
4570 + printf ( "%s key_size: %d key_flags: %d wepCurrentKey: %d\n",
4571 + "SIOCGIWENCODE", info.key_size, info.key_flags, wepCurrentKey );
4572 + printf ( "%s MODE: %d DISABLED: %d INDEX: %d OPEN: %d RESTRICTED: %d NOKEY: %d TEMP: %d\n",
4573 + "SIOCGIWENCODE", info.key_flags & IW_ENCODE_MODE,
4574 + info.key_flags & IW_ENCODE_DISABLED ? 1:0, info.key_flags & IW_ENCODE_INDEX,
4575 + info.key_flags & IW_ENCODE_OPEN ? 1:0, info.key_flags & IW_ENCODE_RESTRICTED ? 1:0,
4576 + info.key_flags & IW_ENCODE_NOKEY ? 1:0, info.key_flags & IW_ENCODE_TEMP ? 1:0 );
4577 + }
4578 + else
4579 + printf ( "%s %s\n", "SIOCGIWENCODE", " ===> no info.key support" );
4580 +
4581 + for ( i = 0; i < MAX_WEP_KEYS; i++ ) {
4582 + if ( wep[i].haveKey )
4583 + printf ( "%s wep[%d].len: %d wep[%d].key: %s\n",
4584 + "SIOCGIWENCODE", i, wep[i].len, i, wep[i].key );
4585 + }
4586 +
4587 + if ( info.has_ap_addr )
4588 + printf ( "%s ap_addr.sa_data: %02X:%02X:%02X:%02X:%02X:%02X ap_addr.sa_family: %d\n",
4589 + "SIOCGIWAP", ( UCHAR ) info.ap_addr.sa_data[0], ( UCHAR ) info.ap_addr.sa_data[1],
4590 + ( UCHAR ) info.ap_addr.sa_data[2], ( UCHAR ) info.ap_addr.sa_data[3],
4591 + ( UCHAR ) info.ap_addr.sa_data[4], ( UCHAR ) info.ap_addr.sa_data[5],
4592 + info.ap_addr.sa_family );
4593 + else
4594 + printf ( "%s %s\n", "SIOCGIWAP", " ===> no ap_addr information" );
4595 +
4596 + if ( info.has_bitrate )
4597 + printf ( "%s bitrate: %d value: %d fixed: %d disabled: %d flags: %d\n",
4598 + "SIOCGIWRATE", info.bitrate, info.bitrate.value, info.bitrate.fixed,
4599 + info.bitrate.disabled, info.bitrate.flags );
4600 + else
4601 + printf ( "%s %s\n", "SIOCGIWRATE", " ===> no info.bitrate support" );
4602 +
4603 + if ( info.has_rts )
4604 + printf ( "%s rts: %d\n", "SIOCGIWRTS", info.rts );
4605 + else
4606 + printf ( "%s %s\n", "SIOCGIWRTS", " ===> no info.rts support" );
4607 +
4608 + if ( info.has_frag )
4609 + printf ( "%s frag: %d\n", "SIOCGIWFRAG", info.frag );
4610 + else
4611 + printf ( "%s %s\n", "SIOCGIWFRAG", " ===> no info.frag support" );
4612 +
4613 + if ( info.has_mode )
4614 + printf ( "%s mode: %d\n", "SIOCGIWMODE", info.mode );
4615 + else
4616 + printf ( "%s %s\n", "SIOCGIWMODE", " ===> no info.mode support" );
4617 +
4618 + if ( info.has_power ) {
4619 + printf ( "%s power: %d\n", "SIOCGIWPOWER", info.power );
4620 + printf ( "%s disabled: %d MIN: %d MAX: %d TIMEOUT: %d RELATIVE: %d\n",
4621 + "SIOCGIWPOWER",
4622 + info.power.disabled ? 1:0,
4623 + info.power.flags & IW_POWER_MIN ? 1:0,
4624 + info.power.flags & IW_POWER_MAX ? 1:0,
4625 + info.power.flags & IW_POWER_TIMEOUT ? 1:0,
4626 + info.power.flags & IW_POWER_RELATIVE ? 1:0 );
4627 + printf ( "%s UNICAST: %d MULTICAST: %d ALL: %d FORCE: %d REPEATER: %d\n",
4628 + "SIOCGIWPOWER",
4629 + info.power.flags & IW_POWER_UNICAST_R ? 1:0,
4630 + info.power.flags & IW_POWER_MULTICAST_R ? 1:0,
4631 + info.power.flags & IW_POWER_ALL_R ? 1:0,
4632 + info.power.flags & IW_POWER_FORCE_S ? 1:0,
4633 + info.power.flags & IW_POWER_REPEATER ? 1:0 );
4634 + }
4635 + else
4636 + printf ( "%s %s\n", "SIOCGIWPOWER", " ===> no info.power support" );
4637 +
4638 + if ( info.has_retry )
4639 + printf ( "%s retry: %d\n", "SIOCGIWRETRY", info.retry );
4640 + else
4641 + printf ( "%s %s\n", "SIOCGIWRETRY", " ===> no info.retry support" );
4642 +
4643 + if ( info.has_stats ) {
4644 + printf ( "%s status: %d\n", "SIOCGIWSTATS", info.stats.status );
4645 + printf ( "%s qual.level: %d\n", "SIOCGIWSTATS", info.stats.qual.level );
4646 + printf ( "%s qual.noise: %d\n", "SIOCGIWSTATS", info.stats.qual.noise );
4647 + printf ( "%s qual.qual: %d\n", "SIOCGIWSTATS", info.stats.qual.qual );
4648 + printf ( "%s qual.updated: %d\n", "SIOCGIWSTATS", info.stats.qual.updated );
4649 + printf ( "%s discard.code: %d\n", "SIOCGIWSTATS", info.stats.discard.code );
4650 + printf ( "%s discard.fragment: %d\n", "SIOCGIWSTATS", info.stats.discard.fragment );
4651 + printf ( "%s discard.misc: %d\n", "SIOCGIWSTATS", info.stats.discard.misc );
4652 + printf ( "%s discard.nwid: %d\n", "SIOCGIWSTATS", info.stats.discard.nwid );
4653 + printf ( "%s discard.retries: %d\n", "SIOCGIWSTATS", info.stats.discard.retries );
4654 + printf ( "%s miss.beacon: %d\n", "SIOCGIWSTATS", info.stats.miss.beacon );
4655 + }
4656 + else
4657 + printf ( "%s %s\n", "SIOCGIWSTATS", " ===> no info.stats support" );
4658 +
4659 + if ( info.txpower.flags & IW_TXPOW_MWATT )
4660 + printf ( "%s txpower1: %d dBm disabled: %d fixed: %d flags: %d\n", "SIOCGIWRANGE",
4661 + mWatt2dbm ( info.txpower.value ), info.txpower.disabled, info.txpower.fixed, info.txpower.flags);
4662 + else
4663 + printf ( "%s txpower2: %d dBm disabled: %d fixed: %d flags: %d\n", "SIOCGIWRANGE", info.txpower.value, info.txpower.disabled, info.txpower.fixed, info.txpower.flags );
4664 +
4665 + if ( info.has_range )
4666 + if ( info.sens.value < 0 )
4667 + printf ( "%s sens: %d dBm\n", "SIOCGIWRANGE", info.sens.value );
4668 + else
4669 + printf ( "%s sens: %d/%d\n", "SIOCGIWRANGE", info.sens.value, info.range.sensitivity );
4670 +
4671 + if ( info.has_range && ( info.stats.qual.level != 0 ))
4672 + if ( info.stats.qual.level > info.range.max_qual.level )
4673 + /* Statistics are in dBm (absolute power measurement) */
4674 + printf ( "%s Quality: %d/%d Signal level: %d dBm Noise level: %d dBm\n",
4675 + "SIOCGIWRANGE",
4676 + info.stats.qual.qual, info.range.max_qual.qual,
4677 + info.stats.qual.level - 0x100,
4678 + info.stats.qual.noise - 0x100 );
4679 + else
4680 + printf ( "%s Quality: %d/%d Signal level: %d/%d Noise level: %d/%d",
4681 + "SIOCGIWRANGE",
4682 + info.stats.qual.qual, info.range.max_qual.qual,
4683 + info.stats.qual.level, info.range.max_qual.level,
4684 + info.stats.qual.noise, info.range.max_qual.noise );
4685 +
4686 +#endif // #ifdef DISPLAYWIEXT
4687 +}
4688 +
4689 +/****************************************************************************
4690 +* *
4691 +* Linked List Functions *
4692 +* *
4693 +****************************************************************************/
4694 +/****************************************************************************
4695 +* *
4696 +* addList() - add an entry to a linked list *
4697 +* *
4698 +****************************************************************************/
4699 +static void
4700 +addList ( char *l, char *data, int len )
4701 +{
4702 + char uid[256];
4703 + LIST_HEAD ( , avNode ) *list;
4704 +
4705 + // NOTE: this assumes the UID is at the begining of the
4706 + // data structure and that UIDs are strings
4707 +
4708 + list = ( LIST_HEAD ( , avNode ) * ) l; // NOTE: don't know how to get
4709 + strcpy ( uid, data ); // rid of compiler warning on
4710 + // LISTHEAD typecast
4711 + // create a new node and the data that goes in it
4712 + newNode = malloc ( sizeof ( struct avNode ));
4713 + newNode->data = malloc ( len );
4714 + memcpy ( newNode->data, data, len );
4715 +
4716 + // this deals with an empty list
4717 + if ( LIST_EMPTY ( list )) {
4718 + LIST_INSERT_HEAD ( list, newNode, nodes );
4719 + return;
4720 + }
4721 +
4722 + // this deals with UIDs that match
4723 + for ( np = LIST_FIRST ( list ); np != NULL; np = LIST_NEXT ( np, nodes )) {
4724 + if ( strncmp ( uid, np->data, strlen ( uid )) == 0 ) { // found matching UID
4725 + LIST_INSERT_AFTER ( np, newNode, nodes );
4726 + if ( np->data )
4727 + free ( np->data );
4728 + LIST_REMOVE ( np, nodes );
4729 + free ( np );
4730 + return;
4731 + }
4732 + }
4733 +
4734 + // this deals with inserting a new UID in the list
4735 + for ( np = LIST_FIRST ( list ); np != NULL; np = LIST_NEXT ( np, nodes )) {
4736 + lastNode = np;
4737 + if ( strncmp ( np->data, uid, strlen ( uid )) > 0 ) { // old ID > new ID AND
4738 + LIST_INSERT_BEFORE ( np, newNode, nodes );
4739 + return;
4740 + }
4741 + }
4742 +
4743 + // this deals with a UID that needs to go on the end of the list
4744 + LIST_INSERT_AFTER ( lastNode, newNode, nodes );
4745 +
4746 + return;
4747 +}
4748 +
4749 +/****************************************************************************
4750 +* *
4751 +* initLists() - initialize all the linked lists *
4752 +* *
4753 +****************************************************************************/
4754 +static void initLists()
4755 +{
4756 + LIST_INIT ( &scList ); LIST_INIT ( &aaList ); LIST_INIT ( &dfList );
4757 + LIST_INIT ( &kmList ); LIST_INIT ( &prList );
4758 + LIST_INIT ( &opList ); LIST_INIT ( &coList );
4759 + LIST_INIT ( &gaList ); LIST_INIT ( &riList ); LIST_INIT ( &poList );
4760 + LIST_INIT ( &paList ); LIST_INIT ( &ptList ); LIST_INIT ( &pfList );
4761 + LIST_INIT ( &pdList ); LIST_INIT ( &piList ); LIST_INIT ( &rdList );
4762 + LIST_INIT ( &alList ); LIST_INIT ( &rtList ); LIST_INIT ( &rrList );
4763 +}
4764 +/****************************************************************************
4765 +* *
4766 +* flushLists() - flush all linked lists *
4767 +* *
4768 +****************************************************************************/
4769 +static void flushLists()
4770 +{
4771 + flushList (( char * ) &scList ); flushList (( char * ) &aaList );
4772 + flushList (( char * ) &dfList ); flushList (( char * ) &kmList );
4773 + flushList (( char * ) &prList );
4774 + flushList (( char * ) &opList ); flushList (( char * ) &coList );
4775 + flushList (( char * ) &gaList ); flushList (( char * ) &riList );
4776 + flushList (( char * ) &poList ); flushList (( char * ) &paList );
4777 + flushList (( char * ) &ptList ); flushList (( char * ) &pfList );
4778 + flushList (( char * ) &pdList ); flushList (( char * ) &piList );
4779 + flushList (( char * ) &rdList ); flushList (( char * ) &alList );
4780 + flushList (( char * ) &rtList ); flushList (( char * ) &rrList );
4781 +}
4782 +
4783 +/****************************************************************************
4784 +* *
4785 +* flushList() - flush a linked list *
4786 +* *
4787 +****************************************************************************/
4788 +static void flushList ( char *l )
4789 +{
4790 + LIST_HEAD ( , avNode ) *list;
4791 +
4792 + list = ( LIST_HEAD ( , avNode ) * ) l; // NOTE: don't know how to get
4793 + while ( !LIST_EMPTY ( list )) { // rid of compiler warning on
4794 + np = LIST_FIRST ( list ); // LISTHEAD typecast
4795 + if ( np->data )
4796 + free ( np->data );
4797 + LIST_REMOVE ( np, nodes );
4798 + free ( np );
4799 + }
4800 +}
4801 +
4802 +/****************************************************************************
4803 +* *
4804 +* Utility Functions *
4805 +* *
4806 +****************************************************************************/
4807 +/****************************************************************************
4808 +* *
4809 +* The following two routines were taken directly from iwlib.c *
4810 +* *
4811 +****************************************************************************/
4812 + /*
4813 + * Open a socket.
4814 + * Depending on the protocol present, open the right socket. The socket
4815 + * will allow us to talk to the driver.
4816 + */
4817 +static int openSocket ( void )
4818 +{
4819 + static const int families[] = {
4820 + AF_INET, AF_IPX, AF_AX25, AF_APPLETALK
4821 + };
4822 + unsigned int i;
4823 + int sock;
4824 +
4825 + /*
4826 + * Now pick any (exisiting) useful socket family for generic queries
4827 + * Note : don't open all the socket, only returns when one matches,
4828 + * all protocols might not be valid.
4829 + * Workaround by Jim Kaba <jkaba@sarnoff.com>
4830 + * Note : in 99% of the case, we will just open the inet_sock.
4831 + * The remaining 1% case are not fully correct...
4832 + */
4833 +
4834 + /* Try all families we support */
4835 + for(i = 0; i < sizeof(families)/sizeof(int); ++i) {
4836 + /* Try to open the socket, if success returns it */
4837 + sock = socket(families[i], SOCK_DGRAM, 0);
4838 + if(sock >= 0)
4839 + return sock;
4840 + }
4841 +
4842 + return -1;
4843 +}
4844 +
4845 +/*------------------------------------------------------------------*/
4846 +/*
4847 + * Convert a value in milliWatt to a value in dBm.
4848 + */
4849 +static int mWatt2dbm ( int in )
4850 +{
4851 +#ifdef WE_NOLIBM
4852 + /* Version without libm : slower */
4853 + double fin = (double) in;
4854 + int res = 0;
4855 +
4856 + /* Split integral and floating part to avoid accumulating rounding errors */
4857 + while(fin > 10.0)
4858 + {
4859 + res += 10;
4860 + fin /= 10.0;
4861 + }
4862 + while(fin > 1.000001) /* Eliminate rounding errors, take ceil */
4863 + {
4864 + res += 1;
4865 + fin /= LOG10_MAGIC;
4866 + }
4867 + return(res);
4868 +#else /* WE_NOLIBM */
4869 + /* Version with libm : faster */
4870 + return((int) (ceil(10.0 * log10((double) in))));
4871 +#endif /* WE_NOLIBM */
4872 +}
4873 +
4874 +/****************************************************************************
4875 +* *
4876 +* htob - converts hex string to binary *
4877 +* *
4878 +****************************************************************************/
4879 +static char *htob ( char *s )
4880 +{
4881 + char nibl, *byt;
4882 + static char bin[20];
4883 +
4884 + byt = bin;
4885 +
4886 + while ((nibl = *s++) && nibl != ' ') { /* While not end of string. */
4887 + nibl -= ( nibl > '9') ? ('A' - 10): '0';
4888 + *byt = nibl << 4; /* place high nibble */
4889 + if((nibl = *s++) && nibl != ' ') {
4890 + nibl -= ( nibl > '9') ? ('A' - 10): '0';
4891 + *byt |= nibl; /* place low nibble */
4892 + }
4893 + else break;
4894 + ++byt;
4895 + }
4896 + *++byt = '\0';
4897 + return ( bin );
4898 +}
4899 +
4900 +/****************************************************************************
4901 +* *
4902 +* hasChanged() - see if area has been changed from NULLs *
4903 +* *
4904 +****************************************************************************/
4905 +static int hasChanged ( char *loc, int len )
4906 +{
4907 + char *wrk;
4908 + int changed = TRUE;
4909 +
4910 + wrk = malloc ( len );
4911 + memset ( wrk, 0, len );
4912 + if ( memcmp ( loc, wrk, len ) == 0 )
4913 + changed = FALSE;
4914 + free ( wrk );
4915 +
4916 + return ( changed );
4917 +}
4918 +
4919 --- net-snmp-5.1.2-orig/agent/mibgroup/ieee802dot11.h 1970-01-01 01:00:00.000000000 +0100
4920 +++ net-snmp-5.1.2-5/agent/mibgroup/ieee802dot11.h 2005-03-13 16:17:21.000000000 +0100
4921 @@ -0,0 +1,730 @@
4922 +/****************************************************************************
4923 +* *
4924 +* File Name: ieee802dot11.h *
4925 +* Used By: *
4926 +* *
4927 +* Operating System: *
4928 +* Purpose: *
4929 +* *
4930 +* Comments: *
4931 +* *
4932 +* Author: Larry Simmons *
4933 +* lsimmons@avantcom.com *
4934 +* www.avantcom.com *
4935 +* *
4936 +* Creation Date: 09/02/03 *
4937 +* *
4938 +* Ver Date Inits Modification *
4939 +* ----- -------- ----- ------------ *
4940 +* 0.0.1 09/02/03 LRS created *
4941 +* 0.0.2 09/24/03 LRS wouldn't build after fresh ./configure *
4942 +****************************************************************************/
4943 +/* This file was generated by mib2c and is intended for use as a mib module
4944 + for the ucd-snmp snmpd agent. */
4945 +#ifndef _MIBGROUP_IEEE802DOT11_H
4946 +#define _MIBGROUP_IEEE802DOT11_H
4947 +/* we may use header_generic and header_simple_table from the util_funcs module */
4948 +
4949 +/****************************************************************************
4950 +* Includes *
4951 +****************************************************************************/
4952 +#include <sys/queue.h>
4953 +
4954 +/****************************************************************************
4955 +* Linked List Defines *
4956 +****************************************************************************/
4957 +// here are some Linked List MACROS I wanted to use,
4958 +// but curiously were not in /usr/includes/sys/queue.h
4959 +
4960 +#ifndef LIST_EMPTY
4961 + #define LIST_EMPTY(head) ((head)->lh_first == NULL)
4962 +#endif
4963 +
4964 +#ifndef LIST_NEXT
4965 + #define LIST_NEXT(elm, field) ((elm)->field.le_next)
4966 +#endif
4967 +
4968 +#ifndef LIST_INSERT_BEFORE
4969 + #define LIST_INSERT_BEFORE(listelm, elm, field) do { \
4970 + (elm)->field.le_prev = (listelm)->field.le_prev; \
4971 + LIST_NEXT((elm), field) = (listelm); \
4972 + *(listelm)->field.le_prev = (elm); \
4973 + (listelm)->field.le_prev = &LIST_NEXT((elm), field); \
4974 + } while (0)
4975 +#endif
4976 +
4977 +#ifndef LIST_FIRST
4978 + #define LIST_FIRST(head) ((head)->lh_first)
4979 +#endif
4980 +
4981 +/****************************************************************************
4982 +* 802.11 MIB Defines *
4983 +****************************************************************************/
4984 +#define SYS_STRING_LEN 256
4985 +#define MACADDR_LEN ( 6 * 2 ) + 5
4986 +#define OPER_RATE_SET_LEN 126
4987 +#define MAN_OUI_LEN ( 3 * 2 ) + 2
4988 +#define WEP_STR_LEN 64
4989 +#define SNMP_STR_LEN 128
4990 +#define TEXT_LEN 80
4991 +#define IFINDEX_LEN 4
4992 +#define IFNAME_LEN 16
4993 +#define MAX_WEP_KEYS 4
4994 +
4995 +#define AUTHENICATION_ALGORITHMS_INDEX_LEN 4
4996 +#define WEP_DEFAULT_KEY_INDEX_LEN 4
4997 +#define WEP_KEY_MAPPING_INDEX_LEN 4
4998 +#define GROUP_ADDRESS_INDEX_LEN 4
4999 +#define REG_DOMAIN_SUPPORT_INDEX_LEN 4
5000 +#define ANTENNA_LIST_INDEX_LEN 4
5001 +#define SUPPORTED_DATA_RATES_TX_INDEX_LEN 4
5002 +#define SUPPORTED_DATA_RATES_RX_INDEX_LEN 4
5003 +
5004 +#define SC_UID_LEN IFINDEX_LEN
5005 +#define AA_UID_LEN IFINDEX_LEN + AUTHENICATION_ALGORITHMS_INDEX_LEN
5006 +#define DF_UID_LEN IFINDEX_LEN + WEP_DEFAULT_KEY_INDEX_LEN
5007 +#define KM_UID_LEN IFINDEX_LEN + WEP_KEY_MAPPING_INDEX_LEN
5008 +#define PR_UID_LEN IFINDEX_LEN
5009 +#define OP_UID_LEN IFINDEX_LEN
5010 +#define CO_UID_LEN IFINDEX_LEN
5011 +#define GA_UID_LEN IFINDEX_LEN + GROUP_ADDRESS_INDEX_LEN
5012 +#define RI_UID_LEN IFINDEX_LEN
5013 +#define PO_UID_LEN IFINDEX_LEN
5014 +#define PA_UID_LEN IFINDEX_LEN
5015 +#define PT_UID_LEN IFINDEX_LEN
5016 +#define PF_UID_LEN IFINDEX_LEN
5017 +#define PD_UID_LEN IFINDEX_LEN
5018 +#define PI_UID_LEN IFINDEX_LEN
5019 +#define RD_UID_LEN IFINDEX_LEN + REG_DOMAIN_SUPPORT_INDEX_LEN
5020 +#define AL_UID_LEN IFINDEX_LEN + ANTENNA_LIST_INDEX_LEN
5021 +#define RT_UID_LEN IFINDEX_LEN + SUPPORTED_DATA_RATES_TX_INDEX_LEN
5022 +#define RR_UID_LEN IFINDEX_LEN + SUPPORTED_DATA_RATES_RX_INDEX_LEN
5023 +
5024 +/****************************************************************************
5025 +* Linked List Structure *
5026 +****************************************************************************/
5027 +static struct avNode {
5028 + LIST_ENTRY ( avNode ) nodes;
5029 + char *data; // pointer to data
5030 +};
5031 +
5032 +typedef LIST_HEAD ( , avNode ) avList_t;
5033 +
5034 +/****************************************************************************
5035 +* 802.11 MIB structures *
5036 +****************************************************************************/
5037 +/****************************************************************************
5038 +* dot11Smt Group *
5039 +****************************************************************************/
5040 +/****************************************************************************
5041 +* dot11StationConfigTable *
5042 +****************************************************************************/
5043 +static struct scTbl_data {
5044 +
5045 + char UID [ SC_UID_LEN + 1 ]; // unique ID
5046 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5047 +
5048 + long ifIndex; // ifindex of card
5049 +
5050 + char stationID [ MACADDR_LEN + 1 ]; // Default actual MacAddr
5051 + long mediumOccupancyLimit;
5052 + long CFPPollable;
5053 + long CFPPeriod;
5054 + long maxDuration;
5055 + long authenticationResponseTimeOut;
5056 + long privacyOptionImplemented;
5057 + long powerManagementMode;
5058 + char desiredSSID [ SNMP_STR_LEN + 1 ];
5059 + long desiredBSSType;
5060 + char operationalRateSet [ OPER_RATE_SET_LEN + 1];
5061 + long beaconPeriod;
5062 + long DTIMPeriod;
5063 + long associationResponseTimeOut;
5064 + long disAssociationReason;
5065 + char disAssociationStation [ MACADDR_LEN + 1 ];
5066 + long deAuthenticationReason;
5067 + char deAuthenticationStation [ MACADDR_LEN + 1 ];
5068 + long authenticateFailStatus;
5069 + char authenticateFailStation [ MACADDR_LEN + 1 ];
5070 +
5071 + long haveStationID;
5072 + long haveMediumOccupancyLimit;
5073 + long haveCFPPollable;
5074 + long haveCFPPeriod;
5075 + long haveMaxDuration;
5076 + long haveAuthenticationResponseTimeOut;
5077 + long havePrivacyOptionImplemented;
5078 + long havePowerManagementMode;
5079 + long haveDesiredSSID;
5080 + long haveDesiredBSSType;
5081 + long haveOperationalRateSet;
5082 + long haveBeaconPeriod;
5083 + long haveDTIMPeriod;
5084 + long haveAssociationResponseTimeOut;
5085 + long haveDisAssociationReason;
5086 + long haveDisAssociationStation;
5087 + long haveDeAuthenticationReason;
5088 + long haveDeAuthenticationStation;
5089 + long haveAuthenticateFailStatus;
5090 + long haveAuthenticateFailStation;
5091 +
5092 +} nSc, *sc = &nSc;
5093 +
5094 +static avList_t scList;
5095 +
5096 +/****************************************************************************
5097 +* dot11AuthenticationAlgorithmsTable *
5098 +****************************************************************************/
5099 +static struct aaTbl_data {
5100 +
5101 + char UID [ AA_UID_LEN + 1 ];
5102 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5103 +
5104 + long ifIndex; // ifindex of card
5105 + long authenticationAlgorithmsIndex;
5106 +
5107 + long authenticationAlgorithm;
5108 + long authenticationAlgorithmsEnable;
5109 +
5110 + long haveAuthenticationAlgorithm;
5111 + long haveAuthenticationAlgorithmsEnable;
5112 +
5113 +} nAa, *aa = &nAa;
5114 +
5115 +static avList_t aaList;
5116 +
5117 +/****************************************************************************
5118 +* dot11WEPDefaultKeysTable *
5119 +****************************************************************************/
5120 +static struct dfTbl_data {
5121 +
5122 + char UID [ DF_UID_LEN + 1 ];
5123 + char ifName [ IFNAME_LEN + 1 ];
5124 +
5125 + long ifIndex; // ifindex of card
5126 + long WEPDefaultKeyIndex;
5127 +
5128 + char WEPDefaultKeyValue [ WEP_STR_LEN + 1 ];
5129 + long haveWEPDefaultKeyValue;
5130 +
5131 +} nDf, *df = &nDf;
5132 +
5133 +static avList_t dfList;
5134 +
5135 +/****************************************************************************
5136 +* dot11WEPKeyMappingsTable *
5137 +****************************************************************************/
5138 +static struct kmTbl_data {
5139 +
5140 + char UID [ KM_UID_LEN + 1 ];
5141 + char ifName [ IFNAME_LEN + 1 ];
5142 +
5143 + long ifIndex;
5144 + long WEPKeyMappingIndex;
5145 +
5146 + char WEPKeyMappingAddress [ MACADDR_LEN + 1 ];
5147 + long WEPKeyMappingWEPOn;
5148 + char WEPKeyMappingValue [ WEP_STR_LEN + 1 ];
5149 + long WEPKeyMappingStatus;
5150 +
5151 + long haveWEPKeyMappingIndex;
5152 + long haveWEPKeyMappingAddress;
5153 + long haveWEPKeyMappingWEPOn;
5154 + long haveWEPKeyMappingValue;
5155 + long haveWEPKeyMappingStatus;
5156 +
5157 +} nKm, *km = &nKm;
5158 +
5159 +static avList_t kmList;
5160 +
5161 +/****************************************************************************
5162 +* dot11PrivacyTable *
5163 +****************************************************************************/
5164 +static struct prTbl_data {
5165 +
5166 + char UID [ PR_UID_LEN + 1 ];
5167 + char ifName [ IFNAME_LEN + 1 ];
5168 +
5169 + long ifIndex;
5170 +
5171 + long privacyInvoked;
5172 + long WEPDefaultKeyID;
5173 + long WEPKeyMappingLength;
5174 + long excludeUnencrypted;
5175 + unsigned long WEPICVErrorCount;
5176 + unsigned long WEPExcludedCount;
5177 +
5178 + long havePrivacyInvoked;
5179 + long haveWEPDefaultKeyID;
5180 + long haveWEPKeyMappingLength;
5181 + long haveExcludeUnencrypted;
5182 + long haveWEPICVErrorCount;
5183 + long haveWEPExcludedCount;
5184 +
5185 +} nPr, *pr = &nPr;
5186 +
5187 +static avList_t prList;
5188 +
5189 +/****************************************************************************
5190 +* dot11Mac Group *
5191 +****************************************************************************/
5192 +/****************************************************************************
5193 +* dot11OperationTable *
5194 +****************************************************************************/
5195 +static struct opTbl_data {
5196 +
5197 + char UID [ OP_UID_LEN + 1 ]; // unique ID
5198 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5199 +
5200 + long ifIndex; // ifindex of card
5201 +
5202 + char MACAddress [ MACADDR_LEN + 1 ];
5203 + long RTSThreshold;
5204 + long shortRetryLimit;
5205 + long longRetryLimit;
5206 + long fragmentationThreshold;
5207 + long maxTransmitMSDULifetime;
5208 + long maxReceiveLifetime;
5209 + char manufacturerID [ SNMP_STR_LEN + 1 ];
5210 + char productID [ SNMP_STR_LEN + 1 ];
5211 +
5212 + long haveMACAddress;
5213 + long haveRTSThreshold;
5214 + long haveShortRetryLimit;
5215 + long haveLongRetryLimit;
5216 + long haveFragmentationThreshold;
5217 + long haveMaxTransmitMSDULifetime;
5218 + long haveMaxReceiveLifetime;
5219 + long haveManufacturerID;
5220 + long haveProductID;
5221 +
5222 +} nOp, *op = &nOp;
5223 +
5224 +static avList_t opList;
5225 +
5226 +/****************************************************************************
5227 +* dot11CountersTable *
5228 +****************************************************************************/
5229 +static struct coTbl_data {
5230 +
5231 + char UID [ CO_UID_LEN + 1 ]; // unique ID
5232 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5233 +
5234 + long ifIndex; // ifindex of card
5235 +
5236 + unsigned long transmittedFragmentCount;
5237 + unsigned long multicastTransmittedFrameCount;
5238 + unsigned long failedCount;
5239 + unsigned long retryCount;
5240 + unsigned long multipleRetryCount;
5241 + unsigned long frameDuplicateCount;
5242 + unsigned long RTSSuccessCount;
5243 + unsigned long RTSFailureCount;
5244 + unsigned long ACKFailureCount;
5245 + unsigned long receivedFragmentCount;
5246 + unsigned long multicastReceivedFrameCount;
5247 + unsigned long FCSErrorCount;
5248 + unsigned long transmittedFrameCount;
5249 + unsigned long WEPUndecryptableCount;
5250 +
5251 + long haveTransmittedFragmentCount;
5252 + long haveMulticastTransmittedFrameCount;
5253 + long haveFailedCount;
5254 + long haveRetryCount;
5255 + long haveMultipleRetryCount;
5256 + long haveFrameDuplicateCount;
5257 + long haveRTSSuccessCount;
5258 + long haveRTSFailureCount;
5259 + long haveACKFailureCount;
5260 + long haveReceivedFragmentCount;
5261 + long haveMulticastReceivedFrameCount;
5262 + long haveFCSErrorCount;
5263 + long haveTransmittedFrameCount;
5264 + long haveWEPUndecryptableCount;
5265 +
5266 +} nCo, *co = &nCo;
5267 +
5268 +static avList_t coList;
5269 +
5270 +/****************************************************************************
5271 +* dot11GroupAddressesTable *
5272 +****************************************************************************/
5273 +static struct gaTbl_data {
5274 +
5275 + char UID [ GA_UID_LEN + 1 ];
5276 + char ifName [ IFNAME_LEN + 1 ];
5277 +
5278 + long ifIndex; // ifindex of card
5279 + long groupAddressesIndex;
5280 +
5281 + char address [ MACADDR_LEN + 1 ];
5282 + long groupAddressesStatus;
5283 +
5284 + long haveAddress;
5285 + long haveGroupAddressesStatus;
5286 +
5287 +} nGa, *ga = &nGa;
5288 +
5289 +static avList_t gaList;
5290 +
5291 +/****************************************************************************
5292 +* dot11Res Group *
5293 +****************************************************************************/
5294 +static char resourceTypeIDName[] = "RTID";
5295 +static long haveResourceTypeIDName = 1;
5296 +
5297 +/****************************************************************************
5298 +* dot11ResourceInfoTable *
5299 +****************************************************************************/
5300 +static struct riTbl_data {
5301 +
5302 + char UID [ RI_UID_LEN + 1 ]; // unique ID
5303 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5304 +
5305 + long ifIndex; // ifindex of card
5306 +
5307 + char manufacturerOUI [ MAN_OUI_LEN + 1 ];
5308 + char manufacturerName [ SYS_STRING_LEN + 1 ];
5309 + char manufacturerProductName [ SYS_STRING_LEN + 1 ];
5310 + char manufacturerProductVersion [ SYS_STRING_LEN + 1 ];
5311 +
5312 + char haveManufacturerOUI;
5313 + char haveManufacturerName;
5314 + char haveManufacturerProductName;
5315 + char haveManufacturerProductVersion;
5316 +
5317 +} nRi, *ri = &nRi;
5318 +
5319 +static avList_t riList;
5320 +
5321 +/****************************************************************************
5322 +* dot11Phy Group *
5323 +****************************************************************************/
5324 +/****************************************************************************
5325 +* dot11PhyOperationTable *
5326 +****************************************************************************/
5327 +static struct poTbl_data {
5328 +
5329 + char UID [ PO_UID_LEN + 1 ]; // unique ID
5330 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5331 +
5332 + long ifIndex; // ifindex of card
5333 +
5334 + long PHYType;
5335 + long currentRegDomain;
5336 + long tempType;
5337 +
5338 + long havePHYType;
5339 + long haveCurrentRegDomain;
5340 + long haveTempType;
5341 +
5342 +} nPo, *po = &nPo;
5343 +
5344 +static avList_t poList;
5345 +
5346 +/****************************************************************************
5347 +* dot11PhyAntennaEntry *
5348 +****************************************************************************/
5349 +static struct paTbl_data {
5350 +
5351 + char UID [ PA_UID_LEN + 1 ]; // unique ID
5352 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5353 +
5354 + long ifIndex; // ifindex of card
5355 +
5356 + long currentTxAntenna;
5357 + long diversitySupport;
5358 + long currentRxAntenna;
5359 +
5360 + long haveCurrentTxAntenna;
5361 + long haveDiversitySupport;
5362 + long haveCurrentRxAntenna;
5363 +
5364 +} nPa, *pa = &nPa;
5365 +
5366 +static avList_t paList;
5367 +
5368 +/****************************************************************************
5369 +* dot11PhyTxPowerTable *
5370 +****************************************************************************/
5371 +static struct ptTbl_data {
5372 +
5373 + char UID [ PT_UID_LEN + 1 ]; // unique ID
5374 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5375 +
5376 + long ifIndex; // ifindex of card
5377 +
5378 + long numberSupportedPowerLevels;
5379 + long TxPowerLevel1;
5380 + long TxPowerLevel2;
5381 + long TxPowerLevel3;
5382 + long TxPowerLevel4;
5383 + long TxPowerLevel5;
5384 + long TxPowerLevel6;
5385 + long TxPowerLevel7;
5386 + long TxPowerLevel8;
5387 + long currentTxPowerLevel;
5388 +
5389 + long haveNumberSupportedPowerLevels;
5390 + long haveTxPowerLevel1;
5391 + long haveTxPowerLevel2;
5392 + long haveTxPowerLevel3;
5393 + long haveTxPowerLevel4;
5394 + long haveTxPowerLevel5;
5395 + long haveTxPowerLevel6;
5396 + long haveTxPowerLevel7;
5397 + long haveTxPowerLevel8;
5398 + long haveCurrentTxPowerLevel ;
5399 +
5400 +} nPt, *pt = &nPt;
5401 +
5402 +static avList_t ptList;
5403 +
5404 +/****************************************************************************
5405 +* dot11PhyFHSSTable *
5406 +****************************************************************************/
5407 +static struct pfTbl_data {
5408 +
5409 + char UID [ PF_UID_LEN + 1 ]; // unique ID
5410 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5411 +
5412 + long ifIndex; // ifindex of card
5413 +
5414 + long hopTime;
5415 + long currentChannelNumber;
5416 + long maxDwellTime;
5417 + long currentDwellTime;
5418 + long currentSet;
5419 + long currentPattern;
5420 + long currentIndex;
5421 +
5422 + long haveHopTime;
5423 + long haveCurrentChannelNumber;
5424 + long haveMaxDwellTime;
5425 + long haveCurrentDwellTime;
5426 + long haveCurrentSet;
5427 + long haveCurrentPattern;
5428 + long haveCurrentIndex;
5429 +
5430 +} nPf, *pf = &nPf;
5431 +
5432 +static avList_t pfList;
5433 +
5434 +/****************************************************************************
5435 +* dot11PhyDSSSTable *
5436 +****************************************************************************/
5437 +static struct pdTbl_data {
5438 +
5439 + char UID [ PD_UID_LEN + 1 ]; // unique ID
5440 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5441 +
5442 + long ifIndex; // ifindex of card
5443 +
5444 + long currentChannel;
5445 + long CCAModeSupported;
5446 + long currentCCAMode;
5447 + long EDThreshold;
5448 +
5449 + long haveCurrentChannel;
5450 + long haveCCAModeSupported ;
5451 + long haveCurrentCCAMode;
5452 + long haveEDThreshold;
5453 +
5454 +} nPd, *pd = &nPd;
5455 +
5456 +static avList_t pdList;
5457 +
5458 +/****************************************************************************
5459 +* dot11PhyIRTable *
5460 +****************************************************************************/
5461 +static struct piTbl_data {
5462 +
5463 + char UID [ PI_UID_LEN + 1 ]; // unique ID
5464 + char ifName [ IFNAME_LEN + 1 ]; // ifName of card
5465 +
5466 + long ifIndex; // ifindex of card
5467 +
5468 + long CCAWatchdogTimerMax;
5469 + long CCAWatchdogCountMax;
5470 + long CCAWatchdogTimerMin;
5471 + long CCAWatchdogCountMin;
5472 +
5473 + long haveCCAWatchdogTimerMax;
5474 + long haveCCAWatchdogCountMax;
5475 + long haveCCAWatchdogTimerMin;
5476 + long haveCCAWatchdogCountMin;
5477 +
5478 +} nPi, *pi = &nPi;
5479 +
5480 +static avList_t piList;
5481 +
5482 +/****************************************************************************
5483 +* dot11RegDomainsSupportedTable *
5484 +****************************************************************************/
5485 +static struct rdTbl_data {
5486 +
5487 + char UID [ RD_UID_LEN + 1 ];
5488 + char ifName [ IFNAME_LEN + 1 ];
5489 +
5490 + long ifIndex; // ifindex of card
5491 + long regDomainsSupportIndex;
5492 +
5493 + long regDomainsSupportValue;
5494 + long haveRegDomainsSupportValue;
5495 +
5496 +} nRd, *rd = &nRd;
5497 +
5498 +static avList_t rdList;
5499 +
5500 +/****************************************************************************
5501 +* dot11AntennasListTable *
5502 +****************************************************************************/
5503 +static struct alTbl_data {
5504 +
5505 + char UID [ AL_UID_LEN + 1 ];
5506 + char ifName [ IFNAME_LEN + 1 ];
5507 +
5508 + long ifIndex; // ifindex of card
5509 + long antennaListIndex;
5510 +
5511 + long supportedTxAntenna;
5512 + long supportedRxAntenna;
5513 + long diversitySelectionRx ;
5514 +
5515 + long haveSupportedTxAntenna;
5516 + long haveSupportedRxAntenna;
5517 + long haveDiversitySelectionRx ;
5518 +
5519 +} nAl, *al = &nAl;
5520 +
5521 +static avList_t alList;
5522 +
5523 +/****************************************************************************
5524 +* dot11SupportedDataRatesTxTable *
5525 +****************************************************************************/
5526 +static struct rtTbl_data {
5527 +
5528 + char UID [ RT_UID_LEN + 1 ];
5529 + char ifName [ IFNAME_LEN + 1 ];
5530 +
5531 + long ifIndex; // ifindex of card
5532 + long supportedDataRatesTxIndex;
5533 +
5534 + long supportedDataRatesTxValue;
5535 + long haveSupportedDataRatesTxValue;
5536 +
5537 +} nRt, *rt = &nRt;
5538 +
5539 +static avList_t rtList;
5540 +
5541 +/****************************************************************************
5542 +* dot11SupportedDataRatesRxTable *
5543 +****************************************************************************/
5544 +static struct rrTbl_data {
5545 +
5546 + char UID [ RR_UID_LEN + 1 ];
5547 + char ifName [ IFNAME_LEN + 1 ];
5548 +
5549 + long ifIndex; // ifindex of card
5550 + long supportedDataRatesRxIndex;
5551 +
5552 + long supportedDataRatesRxValue;
5553 + long haveSupportedDataRatesRxValue;
5554 +
5555 +} nRr, *rr = &nRr;
5556 +
5557 +static avList_t rrList;
5558 +
5559 +/****************************************************************************
5560 +* Wireless Extensions Structures *
5561 +****************************************************************************/
5562 +static long wepCurrentKey;
5563 +static long haveWepCurrentKey;
5564 +static struct wepTbl_data {
5565 +
5566 + long len;
5567 + char key [ WEP_STR_LEN + 1 ];
5568 + long haveKey;
5569 +
5570 +} wep[4];
5571 +
5572 +/****************************************************************************
5573 +* *
5574 +****************************************************************************/
5575 +config_require(util_funcs)
5576 +
5577 +/* function prototypes */
5578 +
5579 +void init_ieee802dot11 ( void );
5580 +FindVarMethod var_ieee802dot11;
5581 +FindVarMethod var_dot11StationConfigTable;
5582 +FindVarMethod var_dot11AuthenticationAlgorithmsTable;
5583 +FindVarMethod var_dot11WEPDefaultKeysTable;
5584 +FindVarMethod var_dot11WEPKeyMappingsTable;
5585 +FindVarMethod var_dot11PrivacyTable;
5586 +FindVarMethod var_dot11OperationTable;
5587 +FindVarMethod var_dot11CountersTable;
5588 +FindVarMethod var_dot11GroupAddressesTable;
5589 +FindVarMethod var_dot11ResourceInfoTable;
5590 +FindVarMethod var_dot11PhyOperationTable;
5591 +FindVarMethod var_dot11PhyAntennaTable;
5592 +FindVarMethod var_dot11PhyTxPowerTable;
5593 +FindVarMethod var_dot11PhyFHSSTable;
5594 +FindVarMethod var_dot11PhyDSSSTable;
5595 +FindVarMethod var_dot11PhyIRTable;
5596 +FindVarMethod var_dot11RegDomainsSupportedTable;
5597 +FindVarMethod var_dot11AntennasListTable;
5598 +FindVarMethod var_dot11SupportedDataRatesTxTable;
5599 +FindVarMethod var_dot11SupportedDataRatesRxTable;
5600 +
5601 +WriteMethod write_dot11StationID;
5602 +WriteMethod write_dot11MediumOccupancyLimit;
5603 +WriteMethod write_dot11CFPPeriod;
5604 +WriteMethod write_dot11CFPMaxDuration;
5605 +WriteMethod write_dot11AuthenticationResponseTimeOut;
5606 +WriteMethod write_dot11PowerManagementMode;
5607 +WriteMethod write_dot11DesiredSSID;
5608 +WriteMethod write_dot11DesiredBSSType;
5609 +WriteMethod write_dot11OperationalRateSet;
5610 +WriteMethod write_dot11BeaconPeriod;
5611 +WriteMethod write_dot11DTIMPeriod;
5612 +WriteMethod write_dot11AssociationResponseTimeOut;
5613 +WriteMethod write_dot11AuthenticationAlgorithmsEnable;
5614 +WriteMethod write_dot11WEPDefaultKeyValue;
5615 +WriteMethod write_dot11WEPKeyMappingAddress;
5616 +WriteMethod write_dot11WEPKeyMappingWEPOn;
5617 +WriteMethod write_dot11WEPKeyMappingValue;
5618 +WriteMethod write_dot11WEPKeyMappingStatus;
5619 +WriteMethod write_dot11PrivacyInvoked;
5620 +WriteMethod write_dot11WEPDefaultKeyID;
5621 +WriteMethod write_dot11WEPKeyMappingLength;
5622 +WriteMethod write_dot11ExcludeUnencrypted;
5623 +WriteMethod write_dot11RTSThreshold;
5624 +WriteMethod write_dot11ShortRetryLimit;
5625 +WriteMethod write_dot11LongRetryLimit;
5626 +WriteMethod write_dot11FragmentationThreshold;
5627 +WriteMethod write_dot11MaxTransmitMSDULifetime;
5628 +WriteMethod write_dot11MaxReceiveLifetime;
5629 +WriteMethod write_dot11Address;
5630 +WriteMethod write_dot11GroupAddressesStatus;
5631 +WriteMethod write_dot11CurrentRegDomain;
5632 +WriteMethod write_dot11CurrentTxAntenna;
5633 +WriteMethod write_dot11CurrentRxAntenna;
5634 +WriteMethod write_dot11CurrentTxPowerLevel;
5635 +WriteMethod write_dot11CurrentChannelNumber;
5636 +WriteMethod write_dot11CurrentDwellTime;
5637 +WriteMethod write_dot11CurrentSet;
5638 +WriteMethod write_dot11CurrentPattern;
5639 +WriteMethod write_dot11CurrentIndex;
5640 +WriteMethod write_dot11CurrentChannel;
5641 +WriteMethod write_dot11CurrentCCAMode;
5642 +WriteMethod write_dot11EDThreshold;
5643 +WriteMethod write_dot11CCAWatchdogTimerMax;
5644 +WriteMethod write_dot11CCAWatchdogCountMax;
5645 +WriteMethod write_dot11CCAWatchdogTimerMin;
5646 +WriteMethod write_dot11CCAWatchdogCountMin;
5647 +WriteMethod write_dot11SupportedTxAntenna;
5648 +WriteMethod write_dot11SupportedRxAntenna;
5649 +WriteMethod write_dot11DiversitySelectionRx;
5650 +
5651 +#endif /* _MIBGROUP_IEEE802DOT11_H */
5652 --- net-snmp-5.1.2-orig/agent/mibgroup/iwlib.h 1970-01-01 01:00:00.000000000 +0100
5653 +++ net-snmp-5.1.2-5/agent/mibgroup/iwlib.h 2005-03-13 16:17:21.000000000 +0100
5654 @@ -0,0 +1,502 @@
5655 +/*
5656 + * Wireless Tools
5657 + *
5658 + * Jean II - HPLB 97->99 - HPL 99->02
5659 + *
5660 + * Common header for the Wireless Extension library...
5661 + *
5662 + * This file is released under the GPL license.
5663 + * Copyright (c) 1997-2002 Jean Tourrilhes <jt@hpl.hp.com>
5664 + */
5665 +
5666 +#ifndef IWLIB_H
5667 +#define IWLIB_H
5668 +
5669 +/*#include "CHANGELOG.h"*/
5670 +
5671 +/***************************** INCLUDES *****************************/
5672 +
5673 +/* Standard headers */
5674 +#include <sys/types.h>
5675 +#include <sys/ioctl.h>
5676 +#include <stdio.h>
5677 +#include <math.h>
5678 +#include <errno.h>
5679 +#include <fcntl.h>
5680 +#include <ctype.h>
5681 +#include <stdlib.h>
5682 +#include <string.h>
5683 +#include <unistd.h>
5684 +#include <netdb.h> /* gethostbyname, getnetbyname */
5685 +#include <net/ethernet.h> /* struct ether_addr */
5686 +#include <sys/time.h> /* struct timeval */
5687 +#include <unistd.h>
5688 +
5689 +/* This is our header selection. Try to hide the mess and the misery :-(
5690 + * Don't look, you would go blind ;-) */
5691 +
5692 +#ifndef LINUX_VERSION_CODE
5693 +#include <linux/version.h>
5694 +#endif
5695 +
5696 +/* Kernel headers 2.4.X + Glibc 2.2 - Mandrake 8.0, Debian 2.3, RH 7.1
5697 + * Kernel headers 2.2.X + Glibc 2.2 - Slackware 8.0 */
5698 +#if defined(__GLIBC__) \
5699 + && __GLIBC__ == 2 \
5700 + && __GLIBC_MINOR__ >= 2 \
5701 + && LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
5702 +//#define GLIBC22_HEADERS
5703 +#define GENERIC_HEADERS
5704 +
5705 +/* Kernel headers 2.4.X + Glibc 2.1 - Debian 2.2 upgraded, RH 7.0
5706 + * Kernel headers 2.2.X + Glibc 2.1 - Debian 2.2, RH 6.1 */
5707 +#elif defined(__GLIBC__) \
5708 + && __GLIBC__ == 2 \
5709 + && __GLIBC_MINOR__ == 1 \
5710 + && LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
5711 +//#define GLIBC_HEADERS
5712 +#define GENERIC_HEADERS
5713 +
5714 +/* Kernel headers 2.2.X + Glibc 2.0 - Debian 2.1 */
5715 +#elif defined(__GLIBC__) \
5716 + && __GLIBC__ == 2 \
5717 + && __GLIBC_MINOR__ == 0 \
5718 + && LINUX_VERSION_CODE >= KERNEL_VERSION(2,0,0) \
5719 + && LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
5720 +#define GLIBC_HEADERS
5721 +#define KLUDGE_HEADERS
5722 +
5723 +/* Note : is it really worth supporting kernel 2.0.X, knowing that
5724 + * we require WE v9, which is only available in 2.2.X and higher ?
5725 + * I guess one could use 2.0.x with an upgraded wireless.h... */
5726 +
5727 +/* Kernel headers 2.0.X + Glibc 2.0 - Debian 2.0, RH 5 */
5728 +#elif defined(__GLIBC__) \
5729 + && __GLIBC__ == 2 \
5730 + && __GLIBC_MINOR__ == 0 \
5731 + && LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) \
5732 + && LINUX_VERSION_CODE >= KERNEL_VERSION(2,0,0)
5733 +#define GLIBC_HEADERS
5734 +
5735 +/* Kernel headers 2.0.X + libc5 - old systems */
5736 +#elif defined(_LINUX_C_LIB_VERSION_MAJOR) \
5737 + && _LINUX_C_LIB_VERSION_MAJOR == 5 \
5738 + && LINUX_VERSION_CODE >= KERNEL_VERSION(2,0,0) \
5739 + && LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
5740 +#define LIBC5_HEADERS
5741 +
5742 +/* Unsupported combination */
5743 +#else
5744 +#error "Your kernel/libc combination is not supported"
5745 +#endif
5746 +
5747 +#ifdef GENERIC_HEADERS
5748 +/* Proposed by Dr. Michael Rietz <rietz@mail.amps.de>, 27.3.2 */
5749 +/* If this works for all, it might be more stable on the long term - Jean II */
5750 +#include <net/if_arp.h> /* For ARPHRD_ETHER */
5751 +#include <sys/socket.h> /* For AF_INET & struct sockaddr */
5752 +#include <netinet/in.h> /* For struct sockaddr_in */
5753 +#include <netinet/if_ether.h>
5754 +#endif /* GENERIC_HEADERS */
5755 +
5756 +#ifdef GLIBC22_HEADERS
5757 +/* Added by Ross G. Miller <Ross_Miller@baylor.edu>, 3/28/01 */
5758 +#include <linux/if_arp.h> /* For ARPHRD_ETHER */
5759 +#include <linux/socket.h> /* For AF_INET & struct sockaddr */
5760 +#include <sys/socket.h>
5761 +#endif /* GLIBC22_HEADERS */
5762 +
5763 +#ifdef KLUDGE_HEADERS
5764 +#include <socketbits.h>
5765 +#endif /* KLUDGE_HEADERS */
5766 +
5767 +#ifdef GLIBC_HEADERS
5768 +#include <linux/if_arp.h> /* For ARPHRD_ETHER */
5769 +#include <linux/socket.h> /* For AF_INET & struct sockaddr */
5770 +#include <linux/in.h> /* For struct sockaddr_in */
5771 +#endif /* KLUDGE_HEADERS || GLIBC_HEADERS */
5772 +
5773 +#ifdef LIBC5_HEADERS
5774 +#include <sys/socket.h> /* For AF_INET & struct sockaddr & socket() */
5775 +#include <linux/if_arp.h> /* For ARPHRD_ETHER */
5776 +#include <linux/in.h> /* For struct sockaddr_in */
5777 +#endif /* LIBC5_HEADERS */
5778 +
5779 +/* Those 3 headers were previously included in wireless.h */
5780 +#include <linux/types.h> /* for "caddr_t" et al */
5781 +#include <linux/socket.h> /* for "struct sockaddr" et al */
5782 +#include <linux/if.h> /* for IFNAMSIZ and co... */
5783 +
5784 +#ifdef WEXT_HEADER
5785 +/* Private copy of Wireless extensions */
5786 +#include WEXT_HEADER
5787 +#else /* !WEXT_HEADER */
5788 +/* System wide Wireless extensions */
5789 +#include <linux/wireless.h>
5790 +#endif /* !WEXT_HEADER */
5791 +
5792 +#ifdef __cplusplus
5793 +extern "C" {
5794 +#endif
5795 +
5796 +/****************************** DEBUG ******************************/
5797 +
5798 +
5799 +/************************ CONSTANTS & MACROS ************************/
5800 +
5801 +/* Paths */
5802 +#define PROC_NET_WIRELESS "/proc/net/wireless"
5803 +#define PROC_NET_DEV "/proc/net/dev"
5804 +
5805 +/* Some usefull constants */
5806 +#define KILO 1e3
5807 +#define MEGA 1e6
5808 +#define GIGA 1e9
5809 +/* For doing log10/exp10 without libm */
5810 +#define LOG10_MAGIC 1.25892541179
5811 +
5812 +/* Backward compatibility for Wireless Extension 9 */
5813 +#ifndef IW_POWER_MODIFIER
5814 +#define IW_POWER_MODIFIER 0x000F /* Modify a parameter */
5815 +#define IW_POWER_MIN 0x0001 /* Value is a minimum */
5816 +#define IW_POWER_MAX 0x0002 /* Value is a maximum */
5817 +#define IW_POWER_RELATIVE 0x0004 /* Value is not in seconds/ms/us */
5818 +#endif /* IW_POWER_MODIFIER */
5819 +
5820 +#ifndef IW_ENCODE_NOKEY
5821 +#define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not here */
5822 +#define IW_ENCODE_MODE 0xF000 /* Modes defined below */
5823 +#endif /* IW_ENCODE_NOKEY */
5824 +#ifndef IW_ENCODE_TEMP
5825 +#define IW_ENCODE_TEMP 0x0400 /* Temporary key */
5826 +#endif /* IW_ENCODE_TEMP */
5827 +
5828 +/* More backward compatibility */
5829 +#ifndef SIOCSIWCOMMIT
5830 +#define SIOCSIWCOMMIT SIOCSIWNAME
5831 +#endif /* SIOCSIWCOMMIT */
5832 +
5833 +/****************************** TYPES ******************************/
5834 +
5835 +/* Shortcuts */
5836 +typedef struct iw_statistics iwstats;
5837 +typedef struct iw_range iwrange;
5838 +typedef struct iw_param iwparam;
5839 +typedef struct iw_freq iwfreq;
5840 +typedef struct iw_quality iwqual;
5841 +typedef struct iw_priv_args iwprivargs;
5842 +typedef struct sockaddr sockaddr;
5843 +
5844 +/* Structure for storing all wireless information for each device
5845 + * This is pretty exhaustive... */
5846 +typedef struct wireless_info
5847 +{
5848 + char name[IFNAMSIZ + 1]; /* Wireless/protocol name */
5849 + int has_nwid;
5850 + iwparam nwid; /* Network ID */
5851 + int has_freq;
5852 + double freq; /* Frequency/channel */
5853 + int has_sens;
5854 + iwparam sens; /* sensitivity */
5855 + int has_key;
5856 + unsigned char key[IW_ENCODING_TOKEN_MAX]; /* Encoding key used */
5857 + int key_size; /* Number of bytes */
5858 + int key_flags; /* Various flags */
5859 + int has_essid;
5860 + int essid_on;
5861 + char essid[IW_ESSID_MAX_SIZE + 1]; /* ESSID (extended network) */
5862 + int has_nickname;
5863 + char nickname[IW_ESSID_MAX_SIZE + 1]; /* NickName */
5864 + int has_ap_addr;
5865 + sockaddr ap_addr; /* Access point address */
5866 + int has_bitrate;
5867 + iwparam bitrate; /* Bit rate in bps */
5868 + int has_rts;
5869 + iwparam rts; /* RTS threshold in bytes */
5870 + int has_frag;
5871 + iwparam frag; /* Fragmentation threshold in bytes */
5872 + int has_mode;
5873 + int mode; /* Operation mode */
5874 + int has_power;
5875 + iwparam power; /* Power management parameters */
5876 + int has_txpower;
5877 + iwparam txpower; /* Transmit Power in dBm */
5878 + int has_retry;
5879 + iwparam retry; /* Retry limit or lifetime */
5880 +
5881 + /* Stats */
5882 + iwstats stats;
5883 + int has_stats;
5884 + iwrange range;
5885 + int has_range;
5886 +} wireless_info;
5887 +
5888 +/* Structure for storing all wireless information for each device
5889 + * This is a cut down version of the one above, containing only
5890 + * the things *truly* needed to configure a card.
5891 + * Don't add other junk, I'll remove it... */
5892 +typedef struct wireless_config
5893 +{
5894 + char name[IFNAMSIZ + 1]; /* Wireless/protocol name */
5895 + int has_nwid;
5896 + iwparam nwid; /* Network ID */
5897 + int has_freq;
5898 + double freq; /* Frequency/channel */
5899 + int has_key;
5900 + unsigned char key[IW_ENCODING_TOKEN_MAX]; /* Encoding key used */
5901 + int key_size; /* Number of bytes */
5902 + int key_flags; /* Various flags */
5903 + int has_essid;
5904 + int essid_on;
5905 + char essid[IW_ESSID_MAX_SIZE + 1]; /* ESSID (extended network) */
5906 + int has_mode;
5907 + int mode; /* Operation mode */
5908 +} wireless_config;
5909 +
5910 +typedef struct stream_descr
5911 +{
5912 + char * end; /* End of the stream */
5913 + char * current; /* Current event in stream of events */
5914 + char * value; /* Current value in event */
5915 +} stream_descr;
5916 +
5917 +/* Prototype for handling display of each single interface on the
5918 + * system - see iw_enum_devices() */
5919 +typedef int (*iw_enum_handler)(int skfd,
5920 + char * ifname,
5921 + char * args[],
5922 + int count);
5923 +
5924 +/**************************** PROTOTYPES ****************************/
5925 +/*
5926 + * All the functions in iwcommon.c
5927 + */
5928 +
5929 +/* ---------------------- SOCKET SUBROUTINES -----------------------*/
5930 +int
5931 + iw_sockets_open(void);
5932 +void
5933 + iw_enum_devices(int skfd,
5934 + iw_enum_handler fn,
5935 + char * args[],
5936 + int count);
5937 +/* --------------------- WIRELESS SUBROUTINES ----------------------*/
5938 +int
5939 + iw_get_range_info(int skfd,
5940 + char * ifname,
5941 + iwrange * range);
5942 +int
5943 + iw_print_version_info(char * toolname);
5944 +int
5945 + iw_get_priv_info(int skfd,
5946 + char * ifname,
5947 + iwprivargs * priv,
5948 + int maxpriv);
5949 +int
5950 + iw_get_basic_config(int skfd,
5951 + char * ifname,
5952 + wireless_config * info);
5953 +int
5954 + iw_set_basic_config(int skfd,
5955 + char * ifname,
5956 + wireless_config * info);
5957 +/* --------------------- PROTOCOL SUBROUTINES --------------------- */
5958 +int
5959 + iw_protocol_compare(char * protocol1,
5960 + char * protocol2);
5961 +/* -------------------- FREQUENCY SUBROUTINES --------------------- */
5962 +void
5963 + iw_float2freq(double in,
5964 + iwfreq * out);
5965 +double
5966 + iw_freq2float(iwfreq * in);
5967 +void
5968 + iw_print_freq(char * buffer,
5969 + double freq);
5970 +int
5971 + iw_freq_to_channel(double freq,
5972 + struct iw_range * range);
5973 +void
5974 + iw_print_bitrate(char * buffer,
5975 + int bitrate);
5976 +/* ---------------------- POWER SUBROUTINES ----------------------- */
5977 +int
5978 + iw_dbm2mwatt(int in);
5979 +int
5980 + iw_mwatt2dbm(int in);
5981 +/* -------------------- STATISTICS SUBROUTINES -------------------- */
5982 +int
5983 + iw_get_stats(int skfd,
5984 + char * ifname,
5985 + iwstats * stats);
5986 +void
5987 + iw_print_stats(char * buffer,
5988 + iwqual * qual,
5989 + iwrange * range,
5990 + int has_range);
5991 +/* --------------------- ENCODING SUBROUTINES --------------------- */
5992 +void
5993 + iw_print_key(char * buffer,
5994 + unsigned char * key,
5995 + int key_size,
5996 + int key_flags);
5997 +int
5998 + iw_in_key(char * input,
5999 + unsigned char * key);
6000 +int
6001 + iw_in_key_full(int skfd,
6002 + char * ifname,
6003 + char * input,
6004 + unsigned char * key,
6005 + __u16 * flags);
6006 +/* ----------------- POWER MANAGEMENT SUBROUTINES ----------------- */
6007 +void
6008 + iw_print_pm_value(char * buffer,
6009 + int value,
6010 + int flags);
6011 +void
6012 + iw_print_pm_mode(char * buffer,
6013 + int flags);
6014 +/* --------------- RETRY LIMIT/LIFETIME SUBROUTINES --------------- */
6015 +#if WIRELESS_EXT > 10
6016 +void
6017 + iw_print_retry_value(char * buffer,
6018 + int value,
6019 + int flags);
6020 +#endif
6021 +/* ----------------------- TIME SUBROUTINES ----------------------- */
6022 +void
6023 + iw_print_timeval(char * buffer,
6024 + const struct timeval * time);
6025 +/* --------------------- ADDRESS SUBROUTINES ---------------------- */
6026 +int
6027 + iw_check_mac_addr_type(int skfd,
6028 + char * ifname);
6029 +int
6030 + iw_check_if_addr_type(int skfd,
6031 + char * ifname);
6032 +#if 0
6033 +int
6034 + iw_check_addr_type(int skfd,
6035 + char * ifname);
6036 +#endif
6037 +void
6038 + iw_ether_ntop(const struct ether_addr* eth, char* buf);
6039 +char*
6040 + iw_ether_ntoa(const struct ether_addr* eth);
6041 +int
6042 + iw_ether_aton(const char* bufp, struct ether_addr* eth);
6043 +int
6044 + iw_in_inet(char *bufp, struct sockaddr *sap);
6045 +int
6046 + iw_in_addr(int skfd,
6047 + char * ifname,
6048 + char * bufp,
6049 + struct sockaddr * sap);
6050 +/* ----------------------- MISC SUBROUTINES ------------------------ */
6051 +int
6052 + iw_get_priv_size(int args);
6053 +
6054 +#if WIRELESS_EXT > 13
6055 +/* ---------------------- EVENT SUBROUTINES ---------------------- */
6056 +void
6057 + iw_init_event_stream(struct stream_descr * stream,
6058 + char * data,
6059 + int len);
6060 +int
6061 + iw_extract_event_stream(struct stream_descr * stream,
6062 + struct iw_event * iwe);
6063 +#endif /* WIRELESS_EXT > 13 */
6064 +
6065 +/**************************** VARIABLES ****************************/
6066 +
6067 +extern const char * const iw_operation_mode[];
6068 +#define IW_NUM_OPER_MODE 7
6069 +
6070 +/************************* INLINE FUNTIONS *************************/
6071 +/*
6072 + * Functions that are so simple that it's more efficient inlining them
6073 + */
6074 +
6075 +/*
6076 + * Note : I've defined wrapper for the ioctl request so that
6077 + * it will be easier to migrate to other kernel API if needed
6078 + */
6079 +
6080 +/*------------------------------------------------------------------*/
6081 +/*
6082 + * Wrapper to push some Wireless Parameter in the driver
6083 + */
6084 +static inline int
6085 +iw_set_ext(int skfd, /* Socket to the kernel */
6086 + char * ifname, /* Device name */
6087 + int request, /* WE ID */
6088 + struct iwreq * pwrq) /* Fixed part of the request */
6089 +{
6090 + /* Set device name */
6091 + strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
6092 + /* Do the request */
6093 + return(ioctl(skfd, request, pwrq));
6094 +}
6095 +
6096 +/*------------------------------------------------------------------*/
6097 +/*
6098 + * Wrapper to extract some Wireless Parameter out of the driver
6099 + */
6100 +static inline int
6101 +iw_get_ext(int skfd, /* Socket to the kernel */
6102 + char * ifname, /* Device name */
6103 + int request, /* WE ID */
6104 + struct iwreq * pwrq) /* Fixed part of the request */
6105 +{
6106 + /* Set device name */
6107 + strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
6108 + /* Do the request */
6109 + return(ioctl(skfd, request, pwrq));
6110 +}
6111 +
6112 +/*------------------------------------------------------------------*/
6113 +/* Backwards compatability
6114 + * Actually, those form are much easier to use when dealing with
6115 + * struct sockaddr... */
6116 +static inline char*
6117 +iw_pr_ether(char* bufp, const unsigned char* addr)
6118 +{
6119 + iw_ether_ntop((const struct ether_addr *) addr, bufp);
6120 + return bufp;
6121 +}
6122 +/* Backwards compatability */
6123 +static inline int
6124 +iw_in_ether(const char *bufp, struct sockaddr *sap)
6125 +{
6126 + sap->sa_family = ARPHRD_ETHER;
6127 + return iw_ether_aton(bufp, (struct ether_addr *) sap->sa_data) ? 0 : -1;
6128 +}
6129 +
6130 +/*------------------------------------------------------------------*/
6131 +/*
6132 + * Create an Ethernet broadcast address
6133 + */
6134 +static inline void
6135 +iw_broad_ether(struct sockaddr *sap)
6136 +{
6137 + sap->sa_family = ARPHRD_ETHER;
6138 + memset((char *) sap->sa_data, 0xFF, ETH_ALEN);
6139 +}
6140 +
6141 +/*------------------------------------------------------------------*/
6142 +/*
6143 + * Create an Ethernet NULL address
6144 + */
6145 +static inline void
6146 +iw_null_ether(struct sockaddr *sap)
6147 +{
6148 + sap->sa_family = ARPHRD_ETHER;
6149 + memset((char *) sap->sa_data, 0x00, ETH_ALEN);
6150 +}
6151 +
6152 +#ifdef __cplusplus
6153 +}
6154 +#endif
6155 +
6156 +#endif /* IWLIB_H */
Personal OpenWRT clone
This page took 0.31325 seconds and 5 git commands to generate.