You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

6156 lines
214 KiB

  1. --- /dev/null
  2. +++ b/agent/mibgroup/ieee802dot11.c
  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. --- /dev/null
  4920. +++ b/agent/mibgroup/ieee802dot11.h
  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. --- /dev/null
  5653. +++ b/agent/mibgroup/iwlib.h
  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 */