openwrt/package/net-snmp/patches/750-ieee802dot11.patch

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