lede_packages/net/net-snmp/patches/750-ieee802dot11.patch

--- /dev/null
+++ b/agent/mibgroup/ieee802dot11.c
@@ -0,0 +1,4915 @@
+/****************************************************************************
+*                                                                           *
+*  File Name:           ieee802dot11.c                                      *
+*  Used By:                                                                 *
+*                                                                           *
+*  Operating System:                                                        *
+*  Purpose:                                                                 *
+*                                                                           *
+*  Comments:                                                                *
+*                                                                           *
+*  Author:              Larry Simmons                                       *
+*                       lsimmons@avantcom.com                               *
+*                       www.avantcom.com                                    *
+*                                                                           *
+*  Creation Date:       09/02/03                                            *
+*                                                                           *
+*   Ver    Date   Inits Modification                                        *
+*  ----- -------- ----- ------------                                        *
+*  0.0.1 09/02/03  LRS  created                                             *
+*  0.0.2 09/24/03  LRS  wouldn't build after fresh ./configure              *
+****************************************************************************/
+/****************************************************************************
+*                               Includes                                    *
+****************************************************************************/
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+#include "ieee802dot11.h"
+#include "iwlib.h"
+
+/****************************************************************************
+*                                Defines                                    *
+****************************************************************************/
+#define DISPLAYWIEXT                        // display wireless ext info
+#define TABLE_SIZE   1
+//#define MINLOADFREQ 15                    // min reload frequency in seconds
+#define MINLOADFREQ 5                       // min reload frequency in seconds      // for testing
+#define PROC_NET_DEV      "/proc/net/dev"
+#define PROC_NET_WIRELESS "/proc/net/wireless"
+
+#ifndef UCHAR
+  typedef unsigned char UCHAR;
+#endif
+
+/****************************************************************************
+*                            Private Functions                              *
+****************************************************************************/
+static void loadTables();
+static void loadWiExt ( int, char *, struct wireless_info * );
+static void load80211Structs ( int, char *, struct wireless_info * );
+static void initStructs();
+
+// Wireless Extensions Specific Functions
+static void loadWiExtTo80211Structs ( int, char *, struct wireless_info * );
+static void displayWiExt ( struct wireless_info );
+
+// Linked List Functions
+static void addList ( char *, char *, int );
+static void initLists();                    // initialize all the linked lists
+static void flushLists();                   // flush all the linked lists
+static void flushList ( char * );           // flush a single linked list
+
+// Utility Functions
+static int  openSocket ( void );
+static int  mWatt2dbm ( int );
+static char *htob ( char * );
+static int  hasChanged ( char *, int );
+
+/****************************************************************************
+*                            Private Variables                              *
+****************************************************************************/
+static unsigned long lastLoad = 0;          // ET in secs at last table load
+
+static struct avNode *lastNode, *newNode, *np;
+
+/****************************************************************************
+*                            External Functions                             *
+****************************************************************************/
+
+/****************************************************************************
+*   ieee802dot11_variables_oid:                                             *
+*       this is the top level oid that we want to register under.  This     *
+*       is essentially a prefix, with the suffix appearing in the           *
+*       variable below.                                                     *
+****************************************************************************/
+oid ieee802dot11_variables_oid[] = { 1,2,840,10036 };
+
+/****************************************************************************
+*   variable7 ieee802dot11_variables:                                       *
+*     this variable defines function callbacks and type return information  *
+*     for the ieee802dot11 mib section                                      *
+****************************************************************************/
+struct variable7 ieee802dot11_variables[] = {
+/*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
+#define   DOT11STATIONID        3
+  { DOT11STATIONID      , ASN_OCTET_STR , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,1 } },
+#define   DOT11MEDIUMOCCUPANCYLIMIT  4
+  { DOT11MEDIUMOCCUPANCYLIMIT, ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,2 } },
+#define   DOT11CFPOLLABLE       5
+  { DOT11CFPOLLABLE     , ASN_INTEGER   , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,3 } },
+#define   DOT11CFPPERIOD        6
+  { DOT11CFPPERIOD      , ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,4 } },
+#define   DOT11CFPMAXDURATION   7
+  { DOT11CFPMAXDURATION , ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,5 } },
+#define   DOT11AUTHENTICATIONRESPONSETIMEOUT  8
+  { DOT11AUTHENTICATIONRESPONSETIMEOUT, ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,6 } },
+#define   DOT11PRIVACYOPTIONIMPLEMENTED  9
+  { DOT11PRIVACYOPTIONIMPLEMENTED, ASN_INTEGER   , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,7 } },
+#define   DOT11POWERMANAGEMENTMODE  10
+  { DOT11POWERMANAGEMENTMODE, ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,8 } },
+#define   DOT11DESIREDSSID      11
+  { DOT11DESIREDSSID    , ASN_OCTET_STR , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,9 } },
+#define   DOT11DESIREDBSSTYPE   12
+  { DOT11DESIREDBSSTYPE , ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,10 } },
+#define   DOT11OPERATIONALRATESET  13
+  { DOT11OPERATIONALRATESET, ASN_OCTET_STR , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,11 } },
+#define   DOT11BEACONPERIOD     14
+  { DOT11BEACONPERIOD   , ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,12 } },
+#define   DOT11DTIMPERIOD       15
+  { DOT11DTIMPERIOD     , ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,13 } },
+#define   DOT11ASSOCIATIONRESPONSETIMEOUT  16
+  { DOT11ASSOCIATIONRESPONSETIMEOUT, ASN_INTEGER   , RWRITE, var_dot11StationConfigTable, 4, { 1,1,1,14 } },
+#define   DOT11DISASSOCIATEREASON  17
+  { DOT11DISASSOCIATEREASON, ASN_INTEGER   , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,15 } },
+#define   DOT11DISASSOCIATESTATION  18
+  { DOT11DISASSOCIATESTATION, ASN_OCTET_STR , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,16 } },
+#define   DOT11DEAUTHENTICATEREASON  19
+  { DOT11DEAUTHENTICATEREASON, ASN_INTEGER   , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,17 } },
+#define   DOT11DEAUTHENTICATESTATION  20
+  { DOT11DEAUTHENTICATESTATION, ASN_OCTET_STR , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,18 } },
+#define   DOT11AUTHENTICATEFAILSTATUS  21
+  { DOT11AUTHENTICATEFAILSTATUS, ASN_INTEGER   , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,19 } },
+#define   DOT11AUTHENTICATEFAILSTATION  22
+  { DOT11AUTHENTICATEFAILSTATION, ASN_OCTET_STR , RONLY , var_dot11StationConfigTable, 4, { 1,1,1,20 } },
+
+#define   DOT11AUTHENTICATIONALGORITHM  26
+  { DOT11AUTHENTICATIONALGORITHM, ASN_INTEGER   , RONLY , var_dot11AuthenticationAlgorithmsTable, 4, { 1,2,1,2 } },
+#define   DOT11AUTHENTICATIONALGORITHMSENABLE  27
+  { DOT11AUTHENTICATIONALGORITHMSENABLE, ASN_INTEGER   , RWRITE, var_dot11AuthenticationAlgorithmsTable, 4, { 1,2,1,3 } },
+
+#define   DOT11WEPDEFAULTKEYVALUE  31
+  { DOT11WEPDEFAULTKEYVALUE, ASN_OCTET_STR , RWRITE, var_dot11WEPDefaultKeysTable, 4, { 1,3,1,2 } },
+
+#define   DOT11WEPKEYMAPPINGADDRESS  35
+  { DOT11WEPKEYMAPPINGADDRESS, ASN_OCTET_STR , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,2 } },
+#define   DOT11WEPKEYMAPPINGWEPON  36
+  { DOT11WEPKEYMAPPINGWEPON, ASN_INTEGER   , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,3 } },
+#define   DOT11WEPKEYMAPPINGVALUE  37
+  { DOT11WEPKEYMAPPINGVALUE, ASN_OCTET_STR , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,4 } },
+#define   DOT11WEPKEYMAPPINGSTATUS  38
+  { DOT11WEPKEYMAPPINGSTATUS, ASN_INTEGER   , RWRITE, var_dot11WEPKeyMappingsTable, 4, { 1,4,1,5 } },
+
+#define   DOT11PRIVACYINVOKED   41
+  { DOT11PRIVACYINVOKED , ASN_INTEGER   , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,1 } },
+#define   DOT11WEPDEFAULTKEYID  42
+  { DOT11WEPDEFAULTKEYID, ASN_INTEGER   , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,2 } },
+#define   DOT11WEPKEYMAPPINGLENGTH  43
+  { DOT11WEPKEYMAPPINGLENGTH, ASN_INTEGER   , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,3 } },
+#define   DOT11EXCLUDEUNENCRYPTED  44
+  { DOT11EXCLUDEUNENCRYPTED, ASN_INTEGER   , RWRITE, var_dot11PrivacyTable, 4, { 1,5,1,4 } },
+#define   DOT11WEPICVERRORCOUNT  45
+  { DOT11WEPICVERRORCOUNT, ASN_COUNTER   , RONLY , var_dot11PrivacyTable, 4, { 1,5,1,5 } },
+#define   DOT11WEPEXCLUDEDCOUNT  46
+  { DOT11WEPEXCLUDEDCOUNT, ASN_COUNTER   , RONLY , var_dot11PrivacyTable, 4, { 1,5,1,6 } },
+
+#define   DOT11MACADDRESS       49
+  { DOT11MACADDRESS     , ASN_OCTET_STR , RONLY , var_dot11OperationTable, 4, { 2,1,1,1 } },
+#define   DOT11RTSTHRESHOLD     50
+  { DOT11RTSTHRESHOLD   , ASN_INTEGER   , RWRITE, var_dot11OperationTable, 4, { 2,1,1,2 } },
+#define   DOT11SHORTRETRYLIMIT  51
+  { DOT11SHORTRETRYLIMIT, ASN_INTEGER   , RWRITE, var_dot11OperationTable, 4, { 2,1,1,3 } },
+#define   DOT11LONGRETRYLIMIT   52
+  { DOT11LONGRETRYLIMIT , ASN_INTEGER   , RWRITE, var_dot11OperationTable, 4, { 2,1,1,4 } },
+#define   DOT11FRAGMENTATIONTHRESHOLD  53
+  { DOT11FRAGMENTATIONTHRESHOLD, ASN_INTEGER   , RWRITE, var_dot11OperationTable, 4, { 2,1,1,5 } },
+#define   DOT11MAXTRANSMITMSDULIFETIME  54
+  { DOT11MAXTRANSMITMSDULIFETIME, ASN_INTEGER   , RWRITE, var_dot11OperationTable, 4, { 2,1,1,6 } },
+#define   DOT11MAXRECEIVELIFETIME  55
+  { DOT11MAXRECEIVELIFETIME, ASN_INTEGER   , RWRITE, var_dot11OperationTable, 4, { 2,1,1,7 } },
+#define   DOT11MANUFACTURERID   56
+  { DOT11MANUFACTURERID , ASN_OCTET_STR , RONLY , var_dot11OperationTable, 4, { 2,1,1,8 } },
+#define   DOT11PRODUCTID        57
+  { DOT11PRODUCTID      , ASN_OCTET_STR , RONLY , var_dot11OperationTable, 4, { 2,1,1,9 } },
+
+#define   DOT11TRANSMITTEDFRAGMENTCOUNT  60
+  { DOT11TRANSMITTEDFRAGMENTCOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,1 } },
+#define   DOT11MULTICASTTRANSMITTEDFRAMECOUNT  61
+  { DOT11MULTICASTTRANSMITTEDFRAMECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,2 } },
+#define   DOT11FAILEDCOUNT      62
+  { DOT11FAILEDCOUNT    , ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,3 } },
+#define   DOT11RETRYCOUNT       63
+  { DOT11RETRYCOUNT     , ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,4 } },
+#define   DOT11MULTIPLERETRYCOUNT  64
+  { DOT11MULTIPLERETRYCOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,5 } },
+#define   DOT11FRAMEDUPLICATECOUNT  65
+  { DOT11FRAMEDUPLICATECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,6 } },
+#define   DOT11RTSSUCCESSCOUNT  66
+  { DOT11RTSSUCCESSCOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,7 } },
+#define   DOT11RTSFAILURECOUNT  67
+  { DOT11RTSFAILURECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,8 } },
+#define   DOT11ACKFAILURECOUNT  68
+  { DOT11ACKFAILURECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,9 } },
+#define   DOT11RECEIVEDFRAGMENTCOUNT  69
+  { DOT11RECEIVEDFRAGMENTCOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,10 } },
+#define   DOT11MULTICASTRECEIVEDFRAMECOUNT  70
+  { DOT11MULTICASTRECEIVEDFRAMECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,11 } },
+#define   DOT11FCSERRORCOUNT    71
+  { DOT11FCSERRORCOUNT  , ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,12 } },
+#define   DOT11TRANSMITTEDFRAMECOUNT  72
+  { DOT11TRANSMITTEDFRAMECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,13 } },
+#define   DOT11WEPUNDECRYPTABLECOUNT  73
+  { DOT11WEPUNDECRYPTABLECOUNT, ASN_COUNTER   , RONLY , var_dot11CountersTable, 4, { 2,2,1,14 } },
+
+#define   DOT11ADDRESS          77
+  { DOT11ADDRESS        , ASN_OCTET_STR , RWRITE, var_dot11GroupAddressesTable, 4, { 2,3,1,2 } },
+#define   DOT11GROUPADDRESSESSTATUS  78
+  { DOT11GROUPADDRESSESSTATUS, ASN_INTEGER   , RWRITE, var_dot11GroupAddressesTable, 4, { 2,3,1,3 } },
+
+#define   DOT11RESOURCETYPEIDNAME  79
+  { DOT11RESOURCETYPEIDNAME, ASN_OCTET_STR , RONLY , var_ieee802dot11, 3, { 3,1,1 } },
+#define   DOT11MANUFACTUREROUI  82
+  { DOT11MANUFACTUREROUI, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,1 } },
+#define   DOT11MANUFACTURERNAME  83
+  { DOT11MANUFACTURERNAME, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,2 } },
+#define   DOT11MANUFACTURERPRODUCTNAME  84
+  { DOT11MANUFACTURERPRODUCTNAME, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,3 } },
+#define   DOT11MANUFACTURERPRODUCTVERSION  85
+  { DOT11MANUFACTURERPRODUCTVERSION, ASN_OCTET_STR , RONLY , var_dot11ResourceInfoTable, 5, { 3,1,2,1,4 } },
+
+#define   DOT11PHYTYPE          88
+  { DOT11PHYTYPE        , ASN_INTEGER   , RONLY , var_dot11PhyOperationTable, 4, { 4,1,1,1 } },
+#define   DOT11CURRENTREGDOMAIN  89
+  { DOT11CURRENTREGDOMAIN, ASN_INTEGER   , RWRITE, var_dot11PhyOperationTable, 4, { 4,1,1,2 } },
+#define   DOT11TEMPTYPE         90
+  { DOT11TEMPTYPE       , ASN_INTEGER   , RONLY , var_dot11PhyOperationTable, 4, { 4,1,1,3 } },
+#define   DOT11CURRENTTXANTENNA  93
+  { DOT11CURRENTTXANTENNA, ASN_INTEGER   , RWRITE, var_dot11PhyAntennaTable, 4, { 4,2,1,1 } },
+#define   DOT11DIVERSITYSUPPORT  94
+  { DOT11DIVERSITYSUPPORT, ASN_INTEGER   , RONLY , var_dot11PhyAntennaTable, 4, { 4,2,1,2 } },
+#define   DOT11CURRENTRXANTENNA  95
+  { DOT11CURRENTRXANTENNA, ASN_INTEGER   , RWRITE, var_dot11PhyAntennaTable, 4, { 4,2,1,3 } },
+#define   DOT11NUMBERSUPPORTEDPOWERLEVELS  98
+  { DOT11NUMBERSUPPORTEDPOWERLEVELS, ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,1 } },
+#define   DOT11TXPOWERLEVEL1    99
+  { DOT11TXPOWERLEVEL1  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,2 } },
+#define   DOT11TXPOWERLEVEL2    100
+  { DOT11TXPOWERLEVEL2  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,3 } },
+#define   DOT11TXPOWERLEVEL3    101
+  { DOT11TXPOWERLEVEL3  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,4 } },
+#define   DOT11TXPOWERLEVEL4    102
+  { DOT11TXPOWERLEVEL4  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,5 } },
+#define   DOT11TXPOWERLEVEL5    103
+  { DOT11TXPOWERLEVEL5  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,6 } },
+#define   DOT11TXPOWERLEVEL6    104
+  { DOT11TXPOWERLEVEL6  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,7 } },
+#define   DOT11TXPOWERLEVEL7    105
+  { DOT11TXPOWERLEVEL7  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,8 } },
+#define   DOT11TXPOWERLEVEL8    106
+  { DOT11TXPOWERLEVEL8  , ASN_INTEGER   , RONLY , var_dot11PhyTxPowerTable, 4, { 4,3,1,9 } },
+#define   DOT11CURRENTTXPOWERLEVEL  107
+  { DOT11CURRENTTXPOWERLEVEL, ASN_INTEGER   , RWRITE, var_dot11PhyTxPowerTable, 4, { 4,3,1,10 } },
+
+#define   DOT11HOPTIME          110
+  { DOT11HOPTIME        , ASN_INTEGER   , RONLY , var_dot11PhyFHSSTable, 4, { 4,4,1,1 } },
+#define   DOT11CURRENTCHANNELNUMBER  111
+  { DOT11CURRENTCHANNELNUMBER, ASN_INTEGER   , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,2 } },
+#define   DOT11MAXDWELLTIME     112
+  { DOT11MAXDWELLTIME   , ASN_INTEGER   , RONLY , var_dot11PhyFHSSTable, 4, { 4,4,1,3 } },
+#define   DOT11CURRENTDWELLTIME  113
+  { DOT11CURRENTDWELLTIME, ASN_INTEGER   , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,4 } },
+#define   DOT11CURRENTSET       114
+  { DOT11CURRENTSET     , ASN_INTEGER   , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,5 } },
+#define   DOT11CURRENTPATTERN   115
+  { DOT11CURRENTPATTERN , ASN_INTEGER   , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,6 } },
+#define   DOT11CURRENTINDEX     116
+  { DOT11CURRENTINDEX   , ASN_INTEGER   , RWRITE, var_dot11PhyFHSSTable, 4, { 4,4,1,7 } },
+
+#define   DOT11CURRENTCHANNEL   119
+  { DOT11CURRENTCHANNEL , ASN_INTEGER   , RWRITE, var_dot11PhyDSSSTable, 4, { 4,5,1,1 } },
+#define   DOT11CCAMODESUPPORTED  120
+  { DOT11CCAMODESUPPORTED, ASN_INTEGER   , RONLY , var_dot11PhyDSSSTable, 4, { 4,5,1,2 } },
+#define   DOT11CURRENTCCAMODE   121
+  { DOT11CURRENTCCAMODE , ASN_INTEGER   , RWRITE, var_dot11PhyDSSSTable, 4, { 4,5,1,3 } },
+#define   DOT11EDTHRESHOLD      122
+  { DOT11EDTHRESHOLD    , ASN_INTEGER   , RWRITE, var_dot11PhyDSSSTable, 4, { 4,5,1,4 } },
+
+#define   DOT11CCAWATCHDOGTIMERMAX  125
+  { DOT11CCAWATCHDOGTIMERMAX, ASN_INTEGER   , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,1 } },
+#define   DOT11CCAWATCHDOGCOUNTMAX  126
+  { DOT11CCAWATCHDOGCOUNTMAX, ASN_INTEGER   , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,2 } },
+#define   DOT11CCAWATCHDOGTIMERMIN  127
+  { DOT11CCAWATCHDOGTIMERMIN, ASN_INTEGER   , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,3 } },
+#define   DOT11CCAWATCHDOGCOUNTMIN  128
+  { DOT11CCAWATCHDOGCOUNTMIN, ASN_INTEGER   , RWRITE, var_dot11PhyIRTable, 4, { 4,6,1,4 } },
+
+#define   DOT11REGDOMAINSSUPPORTVALUE  132
+  { DOT11REGDOMAINSSUPPORTVALUE, ASN_INTEGER   , RONLY , var_dot11RegDomainsSupportedTable, 4, { 4,7,1,2 } },
+
+#define   DOT11SUPPORTEDTXANTENNA  136
+  { DOT11SUPPORTEDTXANTENNA, ASN_INTEGER   , RWRITE, var_dot11AntennasListTable, 4, { 4,8,1,2 } },
+#define   DOT11SUPPORTEDRXANTENNA  137
+  { DOT11SUPPORTEDRXANTENNA, ASN_INTEGER   , RWRITE, var_dot11AntennasListTable, 4, { 4,8,1,3 } },
+#define   DOT11DIVERSITYSELECTIONRX  138
+  { DOT11DIVERSITYSELECTIONRX, ASN_INTEGER   , RWRITE, var_dot11AntennasListTable, 4, { 4,8,1,4 } },
+
+#define   DOT11SUPPORTEDDATARATESTXVALUE  142
+  { DOT11SUPPORTEDDATARATESTXVALUE, ASN_INTEGER   , RONLY , var_dot11SupportedDataRatesTxTable, 4, { 4,9,1,2 } },
+
+#define   DOT11SUPPORTEDDATARATESRXVALUE  146
+  { DOT11SUPPORTEDDATARATESRXVALUE, ASN_INTEGER   , RONLY , var_dot11SupportedDataRatesRxTable, 4, { 4,10,1,2 } },
+};
+// ( L = length of the oidsuffix )
+
+/****************************************************************************
+*                                                                           *
+*         init_ieee802dot11() - perform any required initialization         *
+*                                                                           *
+****************************************************************************/
+void init_ieee802dot11 ( void ) {
+
+  /* register ourselves with the agent to handle our mib tree */
+  REGISTER_MIB("ieee802dot11", ieee802dot11_variables, variable7,
+               ieee802dot11_variables_oid);
+
+  initLists();
+}
+
+/****************************************************************************
+*                                                                           *
+*    shutdown_ieee802dot11() - perform any required cleanup @ shutdown      *
+*                                                                           *
+****************************************************************************/
+void shutdown_ieee802dot11 ( void )
+{
+  flushLists();
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_ieee802dot11() -                                                    *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_ieee802dot11 ( struct variable *vp, 
+                    oid     *name, 
+                    size_t  *length, 
+                    int     exact, 
+                    size_t  *var_len, 
+                    WriteMethod **write_method)
+{
+  loadTables();                                               
+
+  if ( header_generic ( vp, name, length, exact,var_len,write_method )
+                                  == MATCH_FAILED )
+    return NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11RESOURCETYPEIDNAME:
+      if ( !haveResourceTypeIDName )
+        return NULL;
+      *var_len = strlen ( resourceTypeIDName );
+      return ( UCHAR * ) resourceTypeIDName;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*  var_dot11StationConfigTable() - return a variable value from the table   *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11StationConfigTable ( struct variable *vp,
+                              oid     *name,
+                              size_t  *length,
+                              int     exact,
+                              size_t  *var_len,
+                              WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+  static char MACWork[17];
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &scList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    sc = ( struct scTbl_data * ) np->data;
+    rName[vp->namelen] = sc->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) || 
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+
+      switch ( vp->magic ) {      // found requested OID, now check for requested variable
+        case DOT11STATIONID: 
+          if ( sc->haveStationID                     ) found = TRUE; break;
+        case DOT11MEDIUMOCCUPANCYLIMIT:
+          if ( sc->haveMediumOccupancyLimit          ) found = TRUE; break;
+        case DOT11CFPOLLABLE:
+          if ( sc->haveCFPPollable                   ) found = TRUE; break;
+        case DOT11CFPPERIOD:
+          if ( sc->haveCFPPeriod                     ) found = TRUE; break;
+        case DOT11CFPMAXDURATION:
+          if ( sc->haveMaxDuration                   ) found = TRUE; break;
+        case DOT11AUTHENTICATIONRESPONSETIMEOUT:
+          if ( sc->haveAuthenticationResponseTimeOut ) found = TRUE; break;
+        case DOT11PRIVACYOPTIONIMPLEMENTED:
+          if ( sc->havePrivacyOptionImplemented      ) found = TRUE; break;
+        case DOT11POWERMANAGEMENTMODE:
+          if ( sc->havePowerManagementMode           ) found = TRUE; break;
+        case DOT11DESIREDSSID:
+          if ( sc->haveDesiredSSID                   ) found = TRUE; break;
+        case DOT11DESIREDBSSTYPE:
+          if ( sc->haveDesiredBSSType                ) found = TRUE; break;
+        case DOT11OPERATIONALRATESET:
+          if ( sc->haveOperationalRateSet            ) found = TRUE; break;
+        case DOT11BEACONPERIOD: 
+          if ( sc->haveBeaconPeriod                  ) found = TRUE; break;
+        case DOT11DTIMPERIOD:
+          if ( sc->haveDTIMPeriod                    ) found = TRUE; break;
+        case DOT11ASSOCIATIONRESPONSETIMEOUT:
+          if ( sc->haveAssociationResponseTimeOut    ) found = TRUE; break;
+        case DOT11DISASSOCIATEREASON:
+          if ( sc->disAssociationReason              ) found = TRUE; break;
+        case DOT11DISASSOCIATESTATION:
+          if ( sc->haveDisAssociationStation         ) found = TRUE; break;
+        case DOT11DEAUTHENTICATEREASON:
+          if ( sc->deAuthenticationReason            ) found = TRUE; break;
+        case DOT11DEAUTHENTICATESTATION:
+          if ( sc->haveDeAuthenticationStation       ) found = TRUE; break;
+        case DOT11AUTHENTICATEFAILSTATUS:
+          if ( sc->authenticateFailStatus            ) found = TRUE; break;
+        case DOT11AUTHENTICATEFAILSTATION:
+          if ( sc->haveAuthenticateFailStation       ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11STATIONID: 
+//    *write_method = write_dot11StationID;
+      MACWork[ 0] = sc->stationID [ 0];
+      MACWork[ 1] = sc->stationID [ 1];
+      MACWork[ 2] = sc->stationID [ 3];
+      MACWork[ 3] = sc->stationID [ 4];
+      MACWork[ 4] = sc->stationID [ 6];
+      MACWork[ 5] = sc->stationID [ 7];
+      MACWork[ 6] = sc->stationID [ 9];
+      MACWork[ 7] = sc->stationID [10];
+      MACWork[ 8] = sc->stationID [12];
+      MACWork[ 9] = sc->stationID [13];
+      MACWork[10] = sc->stationID [15];
+      MACWork[11] = sc->stationID [16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+
+    case DOT11MEDIUMOCCUPANCYLIMIT:
+//    *write_method = write_dot11MediumOccupancyLimit;
+      sc->mediumOccupancyLimit = 5;
+      return ( UCHAR * ) &sc->mediumOccupancyLimit;
+
+    case DOT11CFPOLLABLE:
+      return ( UCHAR * ) &sc->CFPPollable;
+
+    case DOT11CFPPERIOD:
+//    *write_method = write_dot11CFPPeriod;
+      return ( UCHAR * ) &sc->CFPPeriod;
+
+    case DOT11CFPMAXDURATION:
+//    *write_method = write_dot11CFPMaxDuration;
+      return ( UCHAR * ) &sc->maxDuration;
+
+    case DOT11AUTHENTICATIONRESPONSETIMEOUT:
+//    *write_method = write_dot11AuthenticationResponseTimeOut;
+      return ( UCHAR * ) &sc->authenticationResponseTimeOut;
+
+    case DOT11PRIVACYOPTIONIMPLEMENTED:
+      return ( UCHAR * ) &sc->privacyOptionImplemented;
+
+    case DOT11POWERMANAGEMENTMODE:
+//    *write_method = write_dot11PowerManagementMode;
+      return ( UCHAR * ) &sc->powerManagementMode;
+
+    case DOT11DESIREDSSID:
+//    *write_method = write_dot11DesiredSSID;
+      *var_len = strlen ( sc->desiredSSID );
+      return ( UCHAR * ) sc->desiredSSID;
+
+    case DOT11DESIREDBSSTYPE:
+//    *write_method = write_dot11DesiredBSSType;
+      return ( UCHAR * ) &sc->desiredBSSType;
+
+    case DOT11OPERATIONALRATESET:
+//    *write_method = write_dot11OperationalRateSet;
+      *var_len = strlen ( sc->operationalRateSet );
+      return ( UCHAR * ) sc->operationalRateSet;
+
+    case DOT11BEACONPERIOD: 
+//    *write_method = write_dot11BeaconPeriod;
+      return ( UCHAR * ) &sc->beaconPeriod;
+
+    case DOT11DTIMPERIOD:
+//    *write_method = write_dot11DTIMPeriod;
+      return ( UCHAR * ) &sc->DTIMPeriod;
+
+    case DOT11ASSOCIATIONRESPONSETIMEOUT:
+//    *write_method = write_dot11AssociationResponseTimeOut;
+      return ( UCHAR * ) &sc->associationResponseTimeOut;
+
+    case DOT11DISASSOCIATEREASON:
+      return ( UCHAR * ) &sc->disAssociationReason;
+
+    case DOT11DISASSOCIATESTATION:
+      MACWork[ 0] = sc->disAssociationStation[ 0];
+      MACWork[ 1] = sc->disAssociationStation[ 1];
+      MACWork[ 2] = sc->disAssociationStation[ 3];
+      MACWork[ 3] = sc->disAssociationStation[ 4];
+      MACWork[ 4] = sc->disAssociationStation[ 6];
+      MACWork[ 5] = sc->disAssociationStation[ 7];
+      MACWork[ 6] = sc->disAssociationStation[ 9];
+      MACWork[ 7] = sc->disAssociationStation[10];
+      MACWork[ 8] = sc->disAssociationStation[12];
+      MACWork[ 9] = sc->disAssociationStation[13];
+      MACWork[10] = sc->disAssociationStation[15];
+      MACWork[11] = sc->disAssociationStation[16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+
+    case DOT11DEAUTHENTICATEREASON:
+      return ( UCHAR * ) &sc->deAuthenticationReason;
+
+    case DOT11DEAUTHENTICATESTATION:
+      MACWork[ 0] = sc->deAuthenticationStation[ 0];
+      MACWork[ 1] = sc->deAuthenticationStation[ 1];
+      MACWork[ 2] = sc->deAuthenticationStation[ 3];
+      MACWork[ 3] = sc->deAuthenticationStation[ 4];
+      MACWork[ 4] = sc->deAuthenticationStation[ 6];
+      MACWork[ 5] = sc->deAuthenticationStation[ 7];
+      MACWork[ 6] = sc->deAuthenticationStation[ 9];
+      MACWork[ 7] = sc->deAuthenticationStation[10];
+      MACWork[ 8] = sc->deAuthenticationStation[12];
+      MACWork[ 9] = sc->deAuthenticationStation[13];
+      MACWork[10] = sc->deAuthenticationStation[15];
+      MACWork[11] = sc->deAuthenticationStation[16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+
+    case DOT11AUTHENTICATEFAILSTATUS:
+      return ( UCHAR * ) &sc->authenticateFailStatus;
+
+    case DOT11AUTHENTICATEFAILSTATION:
+      MACWork[ 0] = sc->authenticateFailStation[ 0];
+      MACWork[ 1] = sc->authenticateFailStation[ 1];
+      MACWork[ 2] = sc->authenticateFailStation[ 3];
+      MACWork[ 3] = sc->authenticateFailStation[ 4];
+      MACWork[ 4] = sc->authenticateFailStation[ 6];
+      MACWork[ 5] = sc->authenticateFailStation[ 7];
+      MACWork[ 6] = sc->authenticateFailStation[ 9];
+      MACWork[ 7] = sc->authenticateFailStation[10];
+      MACWork[ 8] = sc->authenticateFailStation[12];
+      MACWork[ 9] = sc->authenticateFailStation[13];
+      MACWork[10] = sc->authenticateFailStation[15];
+      MACWork[11] = sc->authenticateFailStation[16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*  var_dot11AuthenticationAlgorithmsTable() -                               *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11AuthenticationAlgorithmsTable (  struct variable *vp,
+                                          oid     *name,
+                                          size_t  *length,
+                                          int     exact,
+                                          size_t  *var_len,
+                                          WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &aaList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    aa = ( struct aaTbl_data * ) np->data;
+    rName[vp->namelen + 0] = aa->ifIndex;
+    rName[vp->namelen + 1] = aa->authenticationAlgorithmsIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11AUTHENTICATIONALGORITHM:
+          if ( aa->haveAuthenticationAlgorithm    ) found = TRUE; break;
+        case DOT11AUTHENTICATIONALGORITHMSENABLE:
+          if ( aa->authenticationAlgorithmsEnable ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11AUTHENTICATIONALGORITHM:
+      return ( UCHAR * ) &aa->authenticationAlgorithm;
+        
+    case DOT11AUTHENTICATIONALGORITHMSENABLE:
+//    *write_method = write_dot11AuthenticationAlgorithmsEnable;
+      return ( UCHAR * ) &aa->authenticationAlgorithmsEnable;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*  var_dot11WEPDefaultKeysTable() -                                         *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11WEPDefaultKeysTable ( struct variable *vp,
+                                oid     *name,
+                                size_t  *length,
+                                int     exact,
+                                size_t  *var_len,
+                                WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &dfList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    df = ( struct dfTbl_data * ) np->data;
+    rName[vp->namelen + 0] = df->ifIndex;
+    rName[vp->namelen + 1] = df->WEPDefaultKeyIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11WEPDEFAULTKEYVALUE:
+          if ( df->haveWEPDefaultKeyValue ) found = TRUE; break;
+      }          
+    }          
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11WEPDEFAULTKEYVALUE:
+//    *write_method = write_dot11WEPDefaultKeyValue;
+      *var_len = strlen ( df->WEPDefaultKeyValue );
+      return ( UCHAR * ) df->WEPDefaultKeyValue;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*  var_dot11WEPKeyMappingsTable() -                                         *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11WEPKeyMappingsTable ( struct variable *vp,
+                                oid     *name,
+                                size_t  *length,
+                                int     exact,
+                                size_t  *var_len,
+                                WriteMethod **write_method)
+{
+  static char MACWork[17];
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &kmList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    km = ( struct kmTbl_data * ) np->data;
+    rName[vp->namelen + 0] = km->ifIndex;
+    rName[vp->namelen + 1] = km->WEPKeyMappingIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11WEPKEYMAPPINGADDRESS:
+          if ( km->haveWEPKeyMappingAddress ) found = TRUE; break;
+        case DOT11WEPKEYMAPPINGWEPON:
+          if ( km->haveWEPKeyMappingWEPOn   ) found = TRUE; break;
+        case DOT11WEPKEYMAPPINGVALUE:
+          if ( km->haveWEPKeyMappingValue   ) found = TRUE; break;
+        case DOT11WEPKEYMAPPINGSTATUS:
+          if ( km->haveWEPKeyMappingStatus  ) found = TRUE; break; 
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11WEPKEYMAPPINGADDRESS:
+//    *write_method = write_dot11WEPKeyMappingAddress;
+      MACWork[ 0] = km->WEPKeyMappingAddress[ 0];
+      MACWork[ 1] = km->WEPKeyMappingAddress[ 1];
+      MACWork[ 2] = km->WEPKeyMappingAddress[ 3];
+      MACWork[ 3] = km->WEPKeyMappingAddress[ 4];
+      MACWork[ 4] = km->WEPKeyMappingAddress[ 6];
+      MACWork[ 5] = km->WEPKeyMappingAddress[ 7];
+      MACWork[ 6] = km->WEPKeyMappingAddress[ 9];
+      MACWork[ 7] = km->WEPKeyMappingAddress[10];
+      MACWork[ 8] = km->WEPKeyMappingAddress[12];
+      MACWork[ 9] = km->WEPKeyMappingAddress[13];
+      MACWork[10] = km->WEPKeyMappingAddress[15];
+      MACWork[11] = km->WEPKeyMappingAddress[16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+
+    case DOT11WEPKEYMAPPINGWEPON:
+//    *write_method = write_dot11WEPKeyMappingWEPOn;
+      return ( UCHAR * ) &km->WEPKeyMappingWEPOn;
+
+    case DOT11WEPKEYMAPPINGVALUE:
+//    *write_method = write_dot11WEPKeyMappingValue;
+      *var_len = strlen ( km->WEPKeyMappingValue );
+      return ( UCHAR * ) km->WEPKeyMappingValue;
+
+    case DOT11WEPKEYMAPPINGSTATUS:
+//    *write_method = write_dot11WEPKeyMappingStatus;
+      return ( UCHAR * ) &km->WEPKeyMappingStatus;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11PrivacyTable() -                                               *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PrivacyTable ( struct variable *vp,
+                        oid     *name,
+                        size_t  *length,
+                        int     exact,
+                        size_t  *var_len,
+                        WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &prList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    pr = ( struct prTbl_data * ) np->data;
+    rName[vp->namelen] = pr->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11PRIVACYINVOKED:
+          if ( pr->havePrivacyInvoked      ) found = TRUE; break;
+        case DOT11WEPDEFAULTKEYID:
+          if ( pr->haveWEPDefaultKeyID     ) found = TRUE; break;
+        case DOT11WEPKEYMAPPINGLENGTH:
+          if ( pr->haveWEPKeyMappingLength ) found = TRUE; break;
+        case DOT11EXCLUDEUNENCRYPTED:
+          if ( pr->haveExcludeUnencrypted  ) found = TRUE; break;
+        case DOT11WEPICVERRORCOUNT:
+          if ( pr->haveWEPICVErrorCount    ) found = TRUE; break;
+        case DOT11WEPEXCLUDEDCOUNT:
+          if ( pr->haveWEPExcludedCount    ) found = TRUE; break;
+      }      
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11PRIVACYINVOKED:
+//    *write_method = write_dot11PrivacyInvoked;
+      return ( UCHAR * ) &pr->privacyInvoked;
+
+    case DOT11WEPDEFAULTKEYID:
+//    *write_method = write_dot11WEPDefaultKeyID;
+      return ( UCHAR * ) &pr->WEPDefaultKeyID;
+
+    case DOT11WEPKEYMAPPINGLENGTH:
+//    *write_method = write_dot11WEPKeyMappingLength;
+      return ( UCHAR * ) &pr->WEPKeyMappingLength;
+
+    case DOT11EXCLUDEUNENCRYPTED:
+//    *write_method = write_dot11ExcludeUnencrypted;
+      return ( UCHAR * ) &pr->excludeUnencrypted;
+
+    case DOT11WEPICVERRORCOUNT:
+      return ( UCHAR * ) &pr->WEPICVErrorCount;
+        
+    case DOT11WEPEXCLUDEDCOUNT:
+      return ( UCHAR * ) &pr->WEPExcludedCount;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11OperationTable() -                                             *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11OperationTable ( struct variable *vp,
+                          oid     *name,
+                          size_t  *length,
+                          int     exact,
+                          size_t  *var_len,
+                          WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+  static char MACWork[17];
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &opList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    op = ( struct opTbl_data * ) np->data;
+    rName[vp->namelen] = op->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+
+      switch ( vp->magic ) {      // found requested OID, now check for requested variable
+        case DOT11MACADDRESS:             
+          if ( op->haveMACAddress              ) found = TRUE; break;
+        case DOT11RTSTHRESHOLD:           
+          if ( op->haveRTSThreshold            ) found = TRUE; break;
+        case DOT11SHORTRETRYLIMIT: 
+          if ( op->haveShortRetryLimit         ) found = TRUE; break;
+        case DOT11LONGRETRYLIMIT:
+          if ( op->haveLongRetryLimit          ) found = TRUE; break;
+        case DOT11FRAGMENTATIONTHRESHOLD: 
+          if ( op->haveFragmentationThreshold  ) found = TRUE; break;
+        case DOT11MAXTRANSMITMSDULIFETIME: 
+          if ( op->haveMaxTransmitMSDULifetime ) found = TRUE; break;
+        case DOT11MAXRECEIVELIFETIME:
+          if ( op->haveMaxReceiveLifetime      ) found = TRUE; break;
+        case DOT11MANUFACTURERID:
+          if ( op->haveManufacturerID          ) found = TRUE; break;
+        case DOT11PRODUCTID:
+          if ( op->haveProductID               ) found = TRUE; break;
+      }
+    }
+    if ( found ) 
+      break;
+  }
+
+  if ( !found )
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11MACADDRESS:
+      MACWork[ 0] = op->MACAddress[ 0];
+      MACWork[ 1] = op->MACAddress[ 1];
+      MACWork[ 2] = op->MACAddress[ 3];
+      MACWork[ 3] = op->MACAddress[ 4];
+      MACWork[ 4] = op->MACAddress[ 6];
+      MACWork[ 5] = op->MACAddress[ 7];
+      MACWork[ 6] = op->MACAddress[ 9];
+      MACWork[ 7] = op->MACAddress[10];
+      MACWork[ 8] = op->MACAddress[12];
+      MACWork[ 9] = op->MACAddress[13];
+      MACWork[10] = op->MACAddress[15];
+      MACWork[11] = op->MACAddress[16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+        
+    case DOT11RTSTHRESHOLD:
+//    *write_method = write_dot11RTSThreshold;
+      return ( UCHAR * ) &op->RTSThreshold;
+
+    case DOT11SHORTRETRYLIMIT:
+//    *write_method = write_dot11ShortRetryLimit;
+      return ( UCHAR * ) &op->shortRetryLimit;
+
+    case DOT11LONGRETRYLIMIT:
+//    *write_method = write_dot11LongRetryLimit;
+      return ( UCHAR * ) &op->longRetryLimit;
+
+    case DOT11FRAGMENTATIONTHRESHOLD:
+//    *write_method = write_dot11FragmentationThreshold;
+      return ( UCHAR * ) &op->fragmentationThreshold;
+
+    case DOT11MAXTRANSMITMSDULIFETIME:
+//    *write_method = write_dot11MaxTransmitMSDULifetime;
+      return ( UCHAR * ) &op->maxTransmitMSDULifetime;
+
+    case DOT11MAXRECEIVELIFETIME:
+//    *write_method = write_dot11MaxReceiveLifetime;
+      return ( UCHAR * ) &op->maxReceiveLifetime;
+
+    case DOT11MANUFACTURERID:
+      *var_len = strlen ( op->manufacturerID );
+      return ( UCHAR * ) op->manufacturerID;
+
+    case DOT11PRODUCTID:
+      *var_len = strlen ( op->productID );
+      return ( UCHAR * ) op->productID;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11CountersTable() -                                              *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11CountersTable(struct variable *vp,
+          oid     *name,
+          size_t  *length,
+          int     exact,
+          size_t  *var_len,
+          WriteMethod **write_method)
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &coList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    co = ( struct coTbl_data * ) np->data;
+    rName[vp->namelen] = co->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11TRANSMITTEDFRAGMENTCOUNT:
+          if ( co->haveTransmittedFragmentCount    ) found = TRUE; break;
+        case DOT11MULTICASTTRANSMITTEDFRAMECOUNT:
+          if ( co->haveTransmittedFrameCount       ) found = TRUE; break;
+        case DOT11FAILEDCOUNT:
+          if ( co->haveFailedCount                 ) found = TRUE; break;
+        case DOT11RETRYCOUNT:
+          if ( co->haveRetryCount                  ) found = TRUE; break;
+        case DOT11MULTIPLERETRYCOUNT:
+          if ( co->haveMultipleRetryCount          ) found = TRUE; break;
+        case DOT11FRAMEDUPLICATECOUNT:
+          if ( co->haveFrameDuplicateCount         ) found = TRUE; break;
+        case DOT11RTSSUCCESSCOUNT:
+          if ( co->haveRTSSuccessCount             ) found = TRUE; break;
+        case DOT11RTSFAILURECOUNT:
+          if ( co->haveRTSFailureCount             ) found = TRUE; break;
+        case DOT11ACKFAILURECOUNT:
+          if ( co->haveACKFailureCount             ) found = TRUE; break;
+        case DOT11RECEIVEDFRAGMENTCOUNT:
+          if ( co->haveReceivedFragmentCount       ) found = TRUE; break;
+        case DOT11MULTICASTRECEIVEDFRAMECOUNT:
+          if ( co->haveMulticastReceivedFrameCount ) found = TRUE; break;
+        case DOT11FCSERRORCOUNT:
+          if ( co->haveFCSErrorCount               ) found = TRUE; break;
+        case DOT11TRANSMITTEDFRAMECOUNT:
+          if ( co->haveTransmittedFrameCount       ) found = TRUE; break;
+        case DOT11WEPUNDECRYPTABLECOUNT:
+          if ( co->haveWEPUndecryptableCount       ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11TRANSMITTEDFRAGMENTCOUNT:       return ( UCHAR * ) &co->transmittedFragmentCount;
+    case DOT11MULTICASTTRANSMITTEDFRAMECOUNT: return ( UCHAR * ) &co->transmittedFrameCount;
+    case DOT11FAILEDCOUNT:                    return ( UCHAR * ) &co->failedCount;
+    case DOT11RETRYCOUNT:                     return ( UCHAR * ) &co->retryCount;
+    case DOT11MULTIPLERETRYCOUNT:             return ( UCHAR * ) &co->multipleRetryCount;
+    case DOT11FRAMEDUPLICATECOUNT:            return ( UCHAR * ) &co->frameDuplicateCount;
+    case DOT11RTSSUCCESSCOUNT:                return ( UCHAR * ) &co->RTSSuccessCount;
+    case DOT11RTSFAILURECOUNT:                return ( UCHAR * ) &co->RTSFailureCount;
+    case DOT11ACKFAILURECOUNT:                return ( UCHAR * ) &co->ACKFailureCount;
+    case DOT11RECEIVEDFRAGMENTCOUNT:          return ( UCHAR * ) &co->receivedFragmentCount;
+    case DOT11MULTICASTRECEIVEDFRAMECOUNT:    return ( UCHAR * ) &co->multicastReceivedFrameCount;
+    case DOT11FCSERRORCOUNT:                  return ( UCHAR * ) &co->FCSErrorCount;
+    case DOT11TRANSMITTEDFRAMECOUNT:          return ( UCHAR * ) &co->transmittedFrameCount;
+    case DOT11WEPUNDECRYPTABLECOUNT:          return ( UCHAR * ) &co->WEPUndecryptableCount;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11GroupAddressesTable() -                                        *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11GroupAddressesTable(struct variable *vp,
+          oid     *name,
+          size_t  *length,
+          int     exact,
+          size_t  *var_len,
+          WriteMethod **write_method)
+{
+  static char MACWork[17];
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &gaList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    ga = ( struct gaTbl_data * ) np->data;
+    rName[vp->namelen + 0] = ga->ifIndex;
+    rName[vp->namelen + 1] = ga->groupAddressesIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11ADDRESS:
+          if ( ga->haveAddress              ) found = TRUE; break;
+        case DOT11GROUPADDRESSESSTATUS:
+          if ( ga->haveGroupAddressesStatus ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11ADDRESS:
+//    *write_method = write_dot11Address;
+      MACWork[ 0] = ga->address[ 0];
+      MACWork[ 1] = ga->address[ 1];
+      MACWork[ 2] = ga->address[ 3];
+      MACWork[ 3] = ga->address[ 4];
+      MACWork[ 4] = ga->address[ 6];
+      MACWork[ 5] = ga->address[ 7];
+      MACWork[ 6] = ga->address[ 9];
+      MACWork[ 7] = ga->address[10];
+      MACWork[ 8] = ga->address[12];
+      MACWork[ 9] = ga->address[13];
+      MACWork[10] = ga->address[15];
+      MACWork[11] = ga->address[16];
+      MACWork[12] = '\0';
+      *var_len = 6;
+      return ( UCHAR * ) htob ( MACWork );
+
+    case DOT11GROUPADDRESSESSTATUS:
+//    *write_method = write_dot11GroupAddressesStatus;
+      return ( UCHAR * ) &ga->groupAddressesStatus;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11ResourceInfoTable() -                                          *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11ResourceInfoTable ( struct variable *vp,
+                              oid     *name,
+                              size_t  *length,
+                              int     exact,
+                              size_t  *var_len,
+                              WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &riList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    ri = ( struct riTbl_data * ) np->data;
+    rName[vp->namelen] = ri->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11MANUFACTUREROUI:
+          if ( ri->haveManufacturerOUI            ) found = TRUE; break;
+        case DOT11MANUFACTURERNAME:
+          if ( ri->haveManufacturerName           ) found = TRUE; break;
+        case DOT11MANUFACTURERPRODUCTNAME:
+          if ( ri->haveManufacturerProductName    ) found = TRUE; break;
+        case DOT11MANUFACTURERPRODUCTVERSION:
+          if ( ri->haveManufacturerProductVersion ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11MANUFACTUREROUI:
+      *var_len = strlen ( ri->manufacturerOUI );
+      return ( UCHAR * ) ri->manufacturerOUI;
+        
+    case DOT11MANUFACTURERNAME:
+      *var_len = strlen ( ri->manufacturerName );
+      return ( UCHAR * ) ri->manufacturerName;
+        
+    case DOT11MANUFACTURERPRODUCTNAME:
+      *var_len = strlen ( ri->manufacturerProductName );
+      return ( UCHAR * ) ri->manufacturerProductName;
+        
+    case DOT11MANUFACTURERPRODUCTVERSION:
+      *var_len = strlen ( ri->manufacturerProductVersion );
+      return ( UCHAR * ) ri->manufacturerProductVersion;
+        
+    default: 
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11PhyOperationTable() -                                          *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PhyOperationTable ( struct variable *vp,
+                              oid     *name,
+                              size_t  *length,
+                              int     exact,
+                              size_t  *var_len,
+                              WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &poList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    po = ( struct poTbl_data * ) np->data;
+    rName[vp->namelen] = po->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11PHYTYPE:
+          if ( po->havePHYType          ) found = TRUE; break;
+        case DOT11CURRENTREGDOMAIN:
+          if ( po->haveCurrentRegDomain ) found = TRUE; break;
+        case DOT11TEMPTYPE:
+          if ( po->haveTempType         ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11PHYTYPE:
+      return ( UCHAR * ) &po->PHYType;
+        
+    case DOT11CURRENTREGDOMAIN:
+//    *write_method = write_dot11CurrentRegDomain;
+      return ( UCHAR * ) &po->currentRegDomain;
+
+    case DOT11TEMPTYPE:
+      return ( UCHAR * ) &po->tempType;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11PhyAntennaTable() -                                            *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PhyAntennaTable ( struct variable *vp,
+                            oid     *name,
+                            size_t  *length,
+                            int     exact,
+                            size_t  *var_len,
+                            WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &paList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    pa = ( struct paTbl_data * ) np->data;
+    rName[vp->namelen] = pa->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11CURRENTTXANTENNA:
+          if ( pa->haveCurrentTxAntenna ) found = TRUE; break;
+        case DOT11DIVERSITYSUPPORT:
+          if ( pa->haveDiversitySupport ) found = TRUE; break;
+        case DOT11CURRENTRXANTENNA:
+          if ( pa->haveCurrentRxAntenna ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11CURRENTTXANTENNA:
+//    *write_method = write_dot11CurrentTxAntenna;
+      return ( UCHAR * ) &pa->currentTxAntenna;
+
+    case DOT11DIVERSITYSUPPORT:
+      return ( UCHAR * ) &pa->diversitySupport;
+        
+    case DOT11CURRENTRXANTENNA:
+//    *write_method = write_dot11CurrentRxAntenna;
+      return ( UCHAR * ) &pa->currentRxAntenna;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*   var_dot11PhyTxPowerTable() -                                            *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PhyTxPowerTable ( struct variable *vp,
+                            oid     *name,
+                            size_t  *length,
+                            int     exact,
+                            size_t  *var_len,
+                            WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &ptList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    pt = ( struct ptTbl_data * ) np->data;
+    rName[vp->namelen] = pt->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11NUMBERSUPPORTEDPOWERLEVELS:
+          if ( pt->haveNumberSupportedPowerLevels ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL1:
+          if ( pt->haveTxPowerLevel1   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL2:
+          if ( pt->haveTxPowerLevel2   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL3:
+          if ( pt->haveTxPowerLevel3   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL4:
+          if ( pt->haveTxPowerLevel4   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL5:
+          if ( pt->haveTxPowerLevel5   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL6:
+          if ( pt->haveTxPowerLevel6   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL7:
+          if ( pt->haveTxPowerLevel7   ) found = TRUE; break;
+        case DOT11TXPOWERLEVEL8:
+          if ( pt->haveTxPowerLevel8   ) found = TRUE; break;
+        case DOT11CURRENTTXPOWERLEVEL:
+          if ( pt->currentTxPowerLevel ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11NUMBERSUPPORTEDPOWERLEVELS: 
+      return ( UCHAR * ) &pt->numberSupportedPowerLevels;
+
+    case DOT11TXPOWERLEVEL1: return ( UCHAR * ) &pt->TxPowerLevel1;
+    case DOT11TXPOWERLEVEL2: return ( UCHAR * ) &pt->TxPowerLevel2;
+    case DOT11TXPOWERLEVEL3: return ( UCHAR * ) &pt->TxPowerLevel3;
+    case DOT11TXPOWERLEVEL4: return ( UCHAR * ) &pt->TxPowerLevel4;
+    case DOT11TXPOWERLEVEL5: return ( UCHAR * ) &pt->TxPowerLevel5;
+    case DOT11TXPOWERLEVEL6: return ( UCHAR * ) &pt->TxPowerLevel6;
+    case DOT11TXPOWERLEVEL7: return ( UCHAR * ) &pt->TxPowerLevel7;
+    case DOT11TXPOWERLEVEL8: return ( UCHAR * ) &pt->TxPowerLevel8;
+        
+    case DOT11CURRENTTXPOWERLEVEL:
+//    *write_method = write_dot11CurrentTxPowerLevel;
+      return ( UCHAR * ) &pt->currentTxPowerLevel;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11PhyFHSSTable() -                                             *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PhyFHSSTable ( struct variable *vp,
+                        oid     *name,
+                        size_t  *length,
+                        int     exact,
+                        size_t  *var_len,
+                        WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &pfList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    pf = ( struct pfTbl_data * ) np->data;
+    rName[vp->namelen] = pf->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11HOPTIME:
+          if ( pf->haveHopTime              ) found = TRUE; break;
+        case DOT11CURRENTCHANNELNUMBER:
+          if ( pf->haveCurrentChannelNumber ) found = TRUE; break;
+        case DOT11MAXDWELLTIME:
+          if ( pf->haveMaxDwellTime         ) found = TRUE; break;
+        case DOT11CURRENTDWELLTIME:
+          if ( pf->haveCurrentDwellTime     ) found = TRUE; break;
+        case DOT11CURRENTSET:
+          if ( pf->haveCurrentSet           ) found = TRUE; break;
+        case DOT11CURRENTPATTERN:
+          if ( pf->haveCurrentPattern       ) found = TRUE; break;
+        case DOT11CURRENTINDEX:
+          if ( pf->haveCurrentIndex         ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11HOPTIME:
+      return ( UCHAR * ) &pf->hopTime;
+        
+    case DOT11CURRENTCHANNELNUMBER:
+//    *write_method = write_dot11CurrentChannelNumber;
+      return ( UCHAR * ) &pf->currentChannelNumber;
+
+    case DOT11MAXDWELLTIME:
+      return ( UCHAR * ) &pf->maxDwellTime;
+        
+    case DOT11CURRENTDWELLTIME:
+//    *write_method = write_dot11CurrentDwellTime;
+      return ( UCHAR * ) &pf->currentDwellTime;
+
+    case DOT11CURRENTSET:
+//    *write_method = write_dot11CurrentSet;
+      return ( UCHAR * ) &pf->currentSet;
+
+    case DOT11CURRENTPATTERN:
+//    *write_method = write_dot11CurrentPattern;
+      return ( UCHAR * ) &pf->currentPattern;
+
+    case DOT11CURRENTINDEX:
+//    *write_method = write_dot11CurrentIndex;
+      return ( UCHAR * ) &pf->currentIndex;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11PhyDSSSTable() -                                             *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PhyDSSSTable ( struct variable *vp,
+                        oid     *name,
+                        size_t  *length,
+                        int     exact,
+                        size_t  *var_len,
+                        WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &pdList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    pd = ( struct pdTbl_data * ) np->data;
+    rName[vp->namelen] = pd->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11CURRENTCHANNEL:
+          if ( pd->haveCurrentChannel   ) found = TRUE; break;
+        case DOT11CCAMODESUPPORTED:
+          if ( pd->haveCCAModeSupported ) found = TRUE; break;
+        case DOT11CURRENTCCAMODE:
+          if ( pd->haveCurrentCCAMode   ) found = TRUE; break;
+        case DOT11EDTHRESHOLD:
+          if ( pd->haveEDThreshold      ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11CURRENTCHANNEL:
+//    *write_method = write_dot11CurrentChannel;
+      return ( UCHAR * ) &pd->currentChannel;
+
+    case DOT11CCAMODESUPPORTED:
+      return ( UCHAR * ) &pd->CCAModeSupported;
+        
+    case DOT11CURRENTCCAMODE:
+//    *write_method = write_dot11CurrentCCAMode;
+      return ( UCHAR * ) &pd->currentCCAMode;
+
+    case DOT11EDTHRESHOLD:
+//    *write_method = write_dot11EDThreshold;
+      return ( UCHAR * ) &pd->EDThreshold;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11PhyIRTable() -                                             *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11PhyIRTable ( struct variable *vp,
+                      oid     *name,
+                      size_t  *length,
+                      int     exact,
+                      size_t  *var_len,
+                      WriteMethod **write_method)
+{
+
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &piList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    pi = ( struct piTbl_data * ) np->data;
+    rName[vp->namelen] = pi->ifIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 1, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11CCAWATCHDOGTIMERMAX:
+          if ( pi->CCAWatchdogTimerMax ) found = TRUE; break;
+        case DOT11CCAWATCHDOGCOUNTMAX:
+          if ( pi->CCAWatchdogCountMax ) found = TRUE; break;
+        case DOT11CCAWATCHDOGTIMERMIN:
+          if ( pi->CCAWatchdogTimerMin ) found = TRUE; break;
+        case DOT11CCAWATCHDOGCOUNTMIN:
+          if ( pi->CCAWatchdogCountMin ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 1 ) * sizeof ( oid ));
+  *length = vp->namelen + 1;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11CCAWATCHDOGTIMERMAX:
+//    *write_method = write_dot11CCAWatchdogTimerMax;
+      return ( UCHAR * ) &pi->CCAWatchdogTimerMax;
+
+    case DOT11CCAWATCHDOGCOUNTMAX:
+//   *write_method = write_dot11CCAWatchdogCountMax;
+      return ( UCHAR * ) &pi->CCAWatchdogCountMax;
+
+    case DOT11CCAWATCHDOGTIMERMIN:
+//    *write_method = write_dot11CCAWatchdogTimerMin;
+      return ( UCHAR * ) &pi->CCAWatchdogTimerMin;
+
+    case DOT11CCAWATCHDOGCOUNTMIN:
+//    *write_method = write_dot11CCAWatchdogCountMin;
+      return ( UCHAR * ) &pi->CCAWatchdogCountMin;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11RegDomainsSupportedTable() -                                 *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11RegDomainsSupportedTable ( struct variable *vp,
+                                    oid     *name,
+                                    size_t  *length,
+                                    int     exact,
+                                    size_t  *var_len,
+                                    WriteMethod **write_method)
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &rdList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    rd = ( struct rdTbl_data * ) np->data;
+    rName[vp->namelen + 0] = rd->ifIndex;
+    rName[vp->namelen + 1] = rd->regDomainsSupportIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11REGDOMAINSSUPPORTVALUE:
+          if ( rd->haveRegDomainsSupportValue ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11REGDOMAINSSUPPORTVALUE:
+      return ( UCHAR * ) &rd->regDomainsSupportValue;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11AntennasListTable() -                                        *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11AntennasListTable(struct variable *vp,
+          oid     *name,
+          size_t  *length,
+          int     exact,
+          size_t  *var_len,
+          WriteMethod **write_method)
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &alList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    al = ( struct alTbl_data * ) np->data;
+    rName[vp->namelen + 0] = al->ifIndex;
+    rName[vp->namelen + 1] = al->antennaListIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11SUPPORTEDTXANTENNA:
+          if ( al->haveSupportedTxAntenna   ) found = TRUE; break;
+        case DOT11SUPPORTEDRXANTENNA:
+          if ( al->haveSupportedRxAntenna   ) found = TRUE; break;
+        case DOT11DIVERSITYSELECTIONRX:
+          if ( al->haveDiversitySelectionRx ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11SUPPORTEDTXANTENNA:
+//    *write_method = write_dot11SupportedTxAntenna;
+      return ( UCHAR * ) &al->supportedTxAntenna;
+
+    case DOT11SUPPORTEDRXANTENNA:
+//    *write_method = write_dot11SupportedRxAntenna;
+      return ( UCHAR * ) &al->supportedRxAntenna;
+
+    case DOT11DIVERSITYSELECTIONRX:
+//    *write_method = write_dot11DiversitySelectionRx;
+      return ( UCHAR * ) &al->diversitySelectionRx;
+
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11SupportedDataRatesTxTable() -                                *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11SupportedDataRatesTxTable ( struct variable *vp,
+                                      oid     *name,
+                                      size_t  *length,
+                                      int     exact,
+                                      size_t  *var_len,
+                                      WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &rtList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    rt = ( struct rtTbl_data * ) np->data;
+    rName[vp->namelen + 0] = rt->ifIndex;
+    rName[vp->namelen + 1] = rt->supportedDataRatesTxIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+         case DOT11SUPPORTEDDATARATESTXVALUE:
+          if ( rt->haveSupportedDataRatesTxValue ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11SUPPORTEDDATARATESTXVALUE:
+      return ( UCHAR * ) &rt->supportedDataRatesTxValue;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+*     var_dot11SupportedDataRatesRxTable() -                                *
+*                                                                           *
+****************************************************************************/
+unsigned char *
+var_dot11SupportedDataRatesRxTable ( struct variable *vp,
+                                      oid     *name,
+                                      size_t  *length,
+                                      int     exact,
+                                      size_t  *var_len,
+                                      WriteMethod **write_method )
+{
+  int found = FALSE;
+  oid rName [ MAX_OID_LEN ];                            // OID to be returned
+
+  loadTables();
+  memcpy (( char * ) rName, ( char * ) vp->name, ( int ) vp->namelen * sizeof ( oid ));
+  for ( np = LIST_FIRST ( &rrList ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    rr = ( struct rrTbl_data * ) np->data;
+    rName[vp->namelen + 0] = rr->ifIndex;
+    rName[vp->namelen + 1] = rr->supportedDataRatesRxIndex;
+    if ((  exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) == 0 )) ||
+        ( !exact && ( snmp_oid_compare ( rName, vp->namelen + 2, name, *length ) >  0 ))) {
+      switch ( vp->magic ) {
+        case DOT11SUPPORTEDDATARATESRXVALUE:
+          if ( rr->haveSupportedDataRatesRxValue ) found = TRUE; break;
+      }
+    }
+    if ( found )
+      break;
+  }
+
+  if ( !found ) 
+    return NULL;
+
+  memcpy (( char * ) name, ( char * ) rName, ( vp->namelen + 2 ) * sizeof ( oid ));
+  *length = vp->namelen + 2;
+  *var_len = sizeof ( long );
+  *write_method = NULL;
+
+  switch ( vp->magic ) {
+
+    case DOT11SUPPORTEDDATARATESRXVALUE:
+      return ( UCHAR * ) &rr->supportedDataRatesRxValue;
+        
+    default:
+      ERROR_MSG ( "" );
+  }
+
+  return NULL;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11StationID(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11StationID not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )) {
+        fprintf ( stderr,"write to dot11StationID: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11MediumOccupancyLimit(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11MediumOccupancyLimit not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11MediumOccupancyLimit: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CFPPeriod(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CFPPeriod not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CFPPeriod: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CFPMaxDuration(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CFPMaxDuration not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CFPMaxDuration: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11AuthenticationResponseTimeOut(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11AuthenticationResponseTimeOut not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11AuthenticationResponseTimeOut: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11PowerManagementMode(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11PowerManagementMode not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )) {
+        fprintf ( stderr, "write to dot11PowerManagementMode: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11DesiredSSID(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11DesiredSSID not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )){
+        fprintf ( stderr, "write to dot11DesiredSSID: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11DesiredBSSType(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11DesiredBSSType not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11DesiredBSSType: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11OperationalRateSet(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11OperationalRateSet not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )){
+        fprintf ( stderr, "write to dot11OperationalRateSet: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11BeaconPeriod(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11BeaconPeriod not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11BeaconPeriod: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11DTIMPeriod(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11DTIMPeriod not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11DTIMPeriod: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11AssociationResponseTimeOut(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11AssociationResponseTimeOut not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )) {
+        fprintf ( stderr,"write to dot11AssociationResponseTimeOut: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11AuthenticationAlgorithmsEnable(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11AuthenticationAlgorithmsEnable not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11AuthenticationAlgorithmsEnable: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPDefaultKeyValue(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11WEPDefaultKeyValue not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )){
+        fprintf ( stderr,"write to dot11WEPDefaultKeyValue: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPKeyMappingAddress(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11WEPKeyMappingAddress not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )) {
+        fprintf ( stderr,"write to dot11WEPKeyMappingAddress: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPKeyMappingWEPOn(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11WEPKeyMappingWEPOn not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11WEPKeyMappingWEPOn: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPKeyMappingValue(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11WEPKeyMappingValue not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )) {
+        fprintf ( stderr, "write to dot11WEPKeyMappingValue: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPKeyMappingStatus(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11WEPKeyMappingStatus not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11WEPKeyMappingStatus: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11PrivacyInvoked(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11PrivacyInvoked not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11PrivacyInvoked: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPDefaultKeyID(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11WEPDefaultKeyID not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11WEPDefaultKeyID: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11WEPKeyMappingLength(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11WEPKeyMappingLength not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11WEPKeyMappingLength: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11ExcludeUnencrypted(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11ExcludeUnencrypted not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11ExcludeUnencrypted: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11RTSThreshold(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ){
+        fprintf ( stderr, "write to dot11RTSThreshold not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11RTSThreshold: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11ShortRetryLimit(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11ShortRetryLimit not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11ShortRetryLimit: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11LongRetryLimit(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11LongRetryLimit not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11LongRetryLimit: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11FragmentationThreshold(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11FragmentationThreshold not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11FragmentationThreshold: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11MaxTransmitMSDULifetime(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11MaxTransmitMSDULifetime not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11MaxTransmitMSDULifetime: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11MaxReceiveLifetime(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11MaxReceiveLifetime not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11MaxReceiveLifetime: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11Address(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static unsigned char string[SPRINT_MAX_LEN];
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_OCTET_STR ) {
+        fprintf ( stderr, "write to dot11Address not ASN_OCTET_STR\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( string )){
+        fprintf ( stderr, "write to dot11Address: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11GroupAddressesStatus(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11GroupAddressesStatus not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11GroupAddressesStatus: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentRegDomain(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentRegDomain not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentRegDomain: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentTxAntenna(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentTxAntenna not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentTxAntenna: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentRxAntenna(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentRxAntenna not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11CurrentRxAntenna: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentTxPowerLevel(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentTxPowerLevel not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentTxPowerLevel: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentChannelNumber(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentChannelNumber not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11CurrentChannelNumber: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentDwellTime(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentDwellTime not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentDwellTime: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentSet(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentSet not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentSet: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentPattern(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentPattern not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentPattern: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentIndex(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentIndex not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentIndex: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentChannel(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentChannel not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CurrentChannel: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CurrentCCAMode(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CurrentCCAMode not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11CurrentCCAMode: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11EDThreshold(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11EDThreshold not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11EDThreshold: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CCAWatchdogTimerMax(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CCAWatchdogTimerMax not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CCAWatchdogTimerMax: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CCAWatchdogCountMax(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CCAWatchdogCountMax not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CCAWatchdogCountMax: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CCAWatchdogTimerMin(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CCAWatchdogTimerMin not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CCAWatchdogTimerMin: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11CCAWatchdogCountMin(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11CCAWatchdogCountMin not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11CCAWatchdogCountMin: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11SupportedTxAntenna(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11SupportedTxAntenna not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11SupportedTxAntenna: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11SupportedRxAntenna(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11SupportedRxAntenna not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr,"write to dot11SupportedRxAntenna: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+int
+write_dot11DiversitySelectionRx(int      action,
+            u_char   *var_val,
+            u_char   var_val_type,
+            size_t   var_val_len,
+            u_char   *statP,
+            oid      *name,
+            size_t   name_len)
+{
+  static long *long_ret;
+  int size;
+
+  switch ( action ) {
+
+    case RESERVE1:
+      if ( var_val_type != ASN_INTEGER ) {
+        fprintf ( stderr, "write to dot11DiversitySelectionRx not ASN_INTEGER\n" );
+        return SNMP_ERR_WRONGTYPE;
+      }
+      if ( var_val_len > sizeof ( long_ret )){
+        fprintf ( stderr, "write to dot11DiversitySelectionRx: bad length\n" );
+        return SNMP_ERR_WRONGLENGTH;
+      }
+      break;
+
+    case RESERVE2:
+    case FREE:
+    case ACTION:
+    case UNDO:
+      break;
+
+    case COMMIT:
+      break;
+  }
+
+  return SNMP_ERR_NOERROR;
+}
+
+/****************************************************************************
+*                                                                           *
+*                      loadTables() - Load the Tables                       *
+*                                                                           *
+****************************************************************************/
+static void loadTables()
+{
+  int skfd;                               // generic raw socket desc
+  struct iwreq wrq;                       // ioctl request structure
+  struct ifreq ifr;
+  struct timeval et;                      // elapsed time
+  struct wireless_info info;              // workarea for wireless ioctl information
+  FILE *fp;
+  char  bfr[1024], ifName[1024];
+  char *s, *t;
+
+  gettimeofday ( &et, ( struct timezone * ) 0 );  // get time-of-day
+  if ( et.tv_sec < lastLoad + MINLOADFREQ )       // only reload so often
+    return;
+  lastLoad = et.tv_sec;
+
+  skfd = openSocket();                            // open socket
+  if ( skfd < 0 ) {
+    syslog ( LOG_ERR, "SNMP ieee802dot11.loadTables() - %s\n", "socket open failure" );
+    return;
+  }
+
+  flushLists();
+
+  // find interfaces in /proc/net/dev and find the wireless interfaces
+  fp = fopen ( PROC_NET_DEV, "r" );
+  if ( fp ) {
+    while ( fgets ( bfr, sizeof ( bfr ), fp )) {
+      if ( strstr ( bfr, ":" )) {
+        s = bfr; t = ifName;
+        while ( isspace ( *s ))                     // discard white space
+          *s++;
+        while ( *s != ':' )                         // get interface name
+          *t++ = *s++;
+        *t = '\0';
+
+        // verify as a wireless device
+        memset (( char * ) &info, 0, sizeof ( struct wireless_info ));
+        strncpy ( wrq.ifr_name, ifName, IFNAMSIZ );
+        if ( ioctl ( skfd, SIOCGIWNAME, &wrq ) >= 0 ) {
+          printf ( "%s ifName: %s\n", "loadTables() -", ifName );
+          initStructs();
+          loadWiExt( skfd, ifName, &info );
+          displayWiExt ( info );
+          load80211Structs ( skfd, ifName, &info );
+        }
+      }
+    }
+    fclose ( fp );
+  }
+
+  close ( skfd );
+}
+
+/****************************************************************************
+*                                                                           *
+*              load80211Structs() - load the 802.11 structures              *
+*                                                                           *
+****************************************************************************/
+static void 
+load80211Structs ( int skfd, char *ifName, struct wireless_info *wi )
+{
+  int rc, ifIndex = 0;
+  struct ifreq ifr;
+  char  MACAddress [ MACADDR_LEN + 1 ];
+
+  strcpy ( ifr.ifr_name, ifName );
+  rc = ioctl ( skfd, SIOCGIFHWADDR, &ifr );
+  if ( rc >= 0 ) {
+
+    sprintf ( MACAddress, "%02X:%02X:%02X:%02X:%02X:%02X\0", 
+                 ( UCHAR ) ifr.ifr_hwaddr.sa_data[0], ( UCHAR ) ifr.ifr_hwaddr.sa_data[1], 
+                 ( UCHAR ) ifr.ifr_hwaddr.sa_data[2], ( UCHAR ) ifr.ifr_hwaddr.sa_data[3], 
+                 ( UCHAR ) ifr.ifr_hwaddr.sa_data[4], ( UCHAR ) ifr.ifr_hwaddr.sa_data[5] );
+
+    nSc.haveStationID = TRUE;
+    strcpy  ( nSc.stationID, MACAddress );
+    nOp.haveMACAddress = TRUE;
+    strcpy  ( nOp.MACAddress, MACAddress );
+    nRi.haveManufacturerOUI = TRUE;
+    strncpy ( nRi.manufacturerOUI, MACAddress, MAN_OUI_LEN ); 
+
+    ifIndex = if_nametoindex ( ifName );
+    if ( !ifIndex ) {
+      syslog ( LOG_ERR, "SNMP %s - %s %s\n", 
+        "ieee802dot11.load80211Structs()", ifName, "has no ifIndex" );
+      return;
+    }
+
+    loadWiExtTo80211Structs ( ifIndex, ifName, wi );
+
+    if ( hasChanged (( char * ) &nSc, sizeof ( nSc ))) {
+      nSc.ifIndex = ifIndex;
+      sprintf ( nSc.UID, "%04d\0", nSc.ifIndex );
+      strcpy ( nSc.ifName, ifName );
+      addList (( char * ) &scList, ( char * ) &nSc, sizeof ( nSc ));
+    }
+
+    if ( hasChanged (( char * ) &nPr, sizeof ( nPr ))) {
+      nPr.ifIndex = ifIndex;
+      sprintf ( nPr.UID, "%04d\0", nPr.ifIndex );
+      strcpy ( nPr.ifName, ifName );
+      addList (( char * ) &prList, ( char * ) &nPr, sizeof ( nPr ));
+    }
+
+    if ( hasChanged (( char * ) &nOp, sizeof ( nOp ))) {
+      nOp.ifIndex = ifIndex;
+      sprintf ( nOp.UID, "%04d\0", nOp.ifIndex );
+      strcpy ( nOp.ifName, ifName );
+      addList (( char * ) &opList, ( char * ) &nOp, sizeof ( nOp ));
+    }
+
+    if ( hasChanged (( char * ) &nCo, sizeof ( nCo ))) {
+      nCo.ifIndex = ifIndex;
+      sprintf ( nCo.UID, "%04d\0", nCo.ifIndex );
+      strcpy ( nCo.ifName, ifName );
+      addList (( char * ) &coList, ( char * ) &nCo, sizeof ( nCo ));
+    }
+
+    if ( hasChanged (( char * ) &nRi, sizeof ( nRi ))) {
+      nRi.ifIndex = ifIndex;
+      sprintf ( nRi.UID, "%04d\0", nRi.ifIndex );
+      strcpy ( nRi.ifName, ifName );
+      addList (( char * ) &riList, ( char * ) &nRi, sizeof ( nRi ));
+    }
+
+    if ( hasChanged (( char * ) &nPo, sizeof ( nPo ))) {
+      nPo.ifIndex = ifIndex;
+      sprintf ( nPo.UID, "%04d\0", nPo.ifIndex );
+      strcpy ( nPo.ifName, ifName );
+      addList (( char * ) &poList, ( char * ) &nPo, sizeof ( nPo ));
+    }
+
+    if ( hasChanged (( char * ) &nPa, sizeof ( nPa ))) {
+      nPa.ifIndex = ifIndex;
+      sprintf ( nPa.UID, "%04d\0", nPa.ifIndex );
+      strcpy ( nPa.ifName, ifName );
+      addList (( char * ) &paList, ( char * ) &nPa, sizeof ( nPa ));
+    }
+
+    if ( hasChanged (( char * ) &nPt, sizeof ( nPt ))) {
+      nPt.ifIndex = ifIndex;
+      sprintf ( nPt.UID, "%04d\0", nPt.ifIndex );
+      strcpy ( nPt.ifName, ifName );
+      addList (( char * ) &ptList, ( char * ) &nPt, sizeof ( nPt ));
+    }
+
+    if ( hasChanged (( char * ) &nPf, sizeof ( nPf ))) {
+      nPf.ifIndex = ifIndex;
+      sprintf ( nPf.UID, "%04d\0", nPf.ifIndex );
+      strcpy ( nPf.ifName, ifName );
+      addList (( char * ) &pfList, ( char * ) &nPf, sizeof ( nPf ));
+    }
+
+    if ( hasChanged (( char * ) &nPd, sizeof ( nPd ))) {
+      nPd.ifIndex = ifIndex;
+      sprintf ( nPd.UID, "%04d\0", nPd.ifIndex );
+      strcpy ( nPd.ifName, ifName );
+      addList (( char * ) &pdList, ( char * ) &nPd, sizeof ( nPd ));
+    }
+
+    if ( hasChanged (( char * ) &nPi, sizeof ( nPi ))) {
+      nPi.ifIndex = ifIndex;
+      sprintf ( nPi.UID, "%04d\0", nPi.ifIndex );
+      strcpy ( nPi.ifName, ifName );
+      addList (( char * ) &piList, ( char * ) &nPi, sizeof ( nPi ));
+    }
+  }
+
+//printf ( "%s - ifIndex: %d ifName: %s UID: %s\n", 
+//         "load80211Structs() - HASCHANGED", ifIndex, ifName, nSc.UID );
+}
+
+/****************************************************************************
+*                                                                           *
+*                     initStructs() - initialize structures                 *
+*                                                                           *
+****************************************************************************/
+static void initStructs()
+{
+  int i;
+
+  // 802.11 MIB Stuctures
+  memset (( char * ) &nSc, 0, sizeof ( nSc ));  memset (( char * ) &nAa, 0, sizeof ( nAa ));
+  memset (( char * ) &nDf, 0, sizeof ( nDf ));  memset (( char * ) &nKm, 0, sizeof ( nKm ));
+  memset (( char * ) &nPr, 0, sizeof ( nPr ));  memset (( char * ) &nOp, 0, sizeof ( nOp ));
+  memset (( char * ) &nCo, 0, sizeof ( nCo ));  memset (( char * ) &nGa, 0, sizeof ( nGa ));
+  memset (( char * ) &nRi, 0, sizeof ( nRi ));  memset (( char * ) &nPo, 0, sizeof ( nPo ));
+  memset (( char * ) &nPa, 0, sizeof ( nPa ));  memset (( char * ) &nPt, 0, sizeof ( nPt ));
+  memset (( char * ) &nPf, 0, sizeof ( nPf ));  memset (( char * ) &nPd, 0, sizeof ( nPd ));
+  memset (( char * ) &nPi, 0, sizeof ( nPi ));  memset (( char * ) &nRd, 0, sizeof ( nRd ));
+  memset (( char * ) &nAl, 0, sizeof ( nAl ));  memset (( char * ) &nRt, 0, sizeof ( nRt ));
+  memset (( char * ) &nRr, 0, sizeof ( nRr ));
+
+  // Wireless Extensions
+  wepCurrentKey = 0;
+  haveWepCurrentKey = FALSE;
+  for ( i = 0; i < MAX_WEP_KEYS; i++ ) {
+    wep[i].len = 0;
+    wep[i].key[0] = '\0';
+    wep[i].haveKey = FALSE;
+  }
+}
+
+/****************************************************************************
+*                                                                           *
+*                Wireless Extensions Specific Functions                     *
+*                                                                           *
+****************************************************************************/
+/****************************************************************************
+*                                                                           *
+* loadWiExtTo80211Structs() - load wireless extensions to 802.11 structures *
+*                                                                           *
+****************************************************************************/
+static void 
+loadWiExtTo80211Structs ( int ifIndex, char *ifName, struct wireless_info *wi )
+{
+  int i, j = 0;
+
+  // dot11Smt Group
+  // dot11StationConfigTable
+  nSc.havePrivacyOptionImplemented = TRUE;
+  nSc.privacyOptionImplemented = 1;           // assume we support WEP
+
+  if ( wi->has_power ) {
+    nSc.havePowerManagementMode = TRUE;
+    nSc.powerManagementMode = 1;              // assume power is active
+    if ( !wi->power.disabled && 
+          wi->power.flags & IW_POWER_MIN )
+      nSc.powerManagementMode = 2;            // power save mode
+  }
+
+  if ( wi->has_essid && strlen ( wi->essid )) {
+    nSc.haveDesiredSSID = TRUE;
+    strcpy ( nSc.desiredSSID, wi->essid ); 
+  }
+
+  if ( wi->has_mode ) {
+    nSc.haveDesiredBSSType = TRUE;
+    if ( wi->mode == IW_MODE_ADHOC ) 
+      nSc.desiredBSSType = 2;         // independent
+    else if ( wi->has_ap_addr )
+      nSc.desiredBSSType = 1;         // infrastructure
+    else
+      nSc.desiredBSSType = 3;         // any
+  }
+
+  if ( wi->has_range ) {
+    for ( i = 0; i < wi->range.num_bitrates && j < 126; i++ ) {
+      nSc.haveOperationalRateSet = TRUE;
+      nSc.operationalRateSet[j++] = ( char ) ( wi->range.bitrate[i] / 500000L );
+    }
+  }
+
+  // dot11AuthenticationAlgorithmsTable
+  nAa.haveAuthenticationAlgorithm = TRUE;           // it's a rule to always have 
+  nAa.haveAuthenticationAlgorithmsEnable = TRUE;    //    'open' supported
+  nAa.ifIndex = ifIndex;
+  nAa.authenticationAlgorithmsIndex = 1;            // index number one
+  nAa.authenticationAlgorithm = 1;                  // 1 => open key
+  sprintf ( nAa.UID, "%04d%04d\0", nAa.ifIndex, nAa.authenticationAlgorithmsIndex );
+  nAa.authenticationAlgorithmsEnable = 1;           // enabled by default
+  if ( ( wi->has_key                        ) &&
+       ( wi->key_size  != 0                 ) &&
+      !( wi->key_flags & IW_ENCODE_DISABLED ))
+    nAa.authenticationAlgorithmsEnable = 2;
+  addList (( char * ) &aaList, ( char * ) &nAa, sizeof ( nAa ));
+
+  nAa.haveAuthenticationAlgorithm = TRUE;           // I'm gonna assume we always support WEP
+  nAa.haveAuthenticationAlgorithmsEnable = TRUE;
+  nAa.ifIndex = ifIndex;
+  nAa.authenticationAlgorithmsIndex = 2;            // index number 2
+  nAa.authenticationAlgorithm = 2;                  // 2 => shared key
+  sprintf ( nAa.UID, "%04d%04d\0", nAa.ifIndex, nAa.authenticationAlgorithmsIndex );
+  nAa.authenticationAlgorithmsEnable = 2;
+  if ( ( wi->has_key                        ) &&
+       ( wi->key_size  != 0                 ) &&
+      !( wi->key_flags & IW_ENCODE_DISABLED ))
+    nAa.authenticationAlgorithmsEnable = 1;         // disabled by default
+  addList (( char * ) &aaList, ( char * ) &nAa, sizeof ( nAa ));
+
+  //dot11WEPDefaultKeysTable
+  if ( wi->has_range ) {
+    for ( i = 0; i < MAX_WEP_KEYS; i++ ) {
+      nDf.haveWEPDefaultKeyValue = TRUE;
+      nDf.ifIndex = ifIndex;
+      nDf.WEPDefaultKeyIndex = i + 1;               // index number
+      sprintf ( nDf.UID, "%04d%04d\0", nDf.ifIndex, nDf.WEPDefaultKeyIndex );
+      if ( wep[i].haveKey )
+        strcpy ( nDf.WEPDefaultKeyValue, "*****" );
+      else
+        nDf.WEPDefaultKeyValue[0] = '\0';
+      addList (( char * ) &dfList, ( char * ) &nDf, sizeof ( nDf ));
+    }
+  }
+
+  // dot11PrivacyTable
+  nPr.havePrivacyInvoked = TRUE;
+  nPr.privacyInvoked = 2;                   // 2 => FALSE
+  nPr.haveWEPDefaultKeyID = TRUE;
+  nPr.WEPDefaultKeyID = 0;
+  nPr.haveExcludeUnencrypted = TRUE;
+  nPr.excludeUnencrypted = 2;               // 2 => FALSE
+  if ( wi->has_range ) {
+    if ( ( wi->key_size != 0 ) &&
+        !( wi->key_flags & IW_ENCODE_DISABLED )) {
+       nPr.privacyInvoked = 1;
+       if ( wi->key_flags & IW_ENCODE_RESTRICTED )
+          nPr.excludeUnencrypted = 1;
+       nPr.WEPDefaultKeyID = wepCurrentKey;
+    }
+  }
+
+  // dot11Mac Group
+  // dot11OperationTable
+  if ( wi->has_range ) {
+    nOp.haveRTSThreshold = TRUE;
+    nOp.RTSThreshold = wi->range.max_rts;
+  }
+
+  if ( wi->has_frag && wi->frag.value ) {
+    nOp.haveFragmentationThreshold = TRUE;
+    nOp.fragmentationThreshold = wi->frag.value;
+  }
+
+  // dot11Phy Group
+  // dot11PhyOperationTable
+  if ( strstr ( wi->name, "IEEE 802.11-FS"      )) nPo.PHYType = 1;   // So what if I
+  if ( strstr ( wi->name, "IEEE 802.11-DS"      )) nPo.PHYType = 2;   // made up a couple?
+  if ( strstr ( wi->name, "IEEE 802.11-IR"      )) nPo.PHYType = 3;   
+  if ( strstr ( wi->name, "IEEE 802.11-OFDM"    )) nPo.PHYType = 4;   // 802.11a
+  if ( strstr ( wi->name, "IEEE 802.11-OFDM/DS" )) nPo.PHYType = 5;   // 802.11g
+  if ( strstr ( wi->name, "IEEE 802.11-TURBO"   )) nPo.PHYType = 6;   // Atheros TURBO mode
+  if ( nPo.PHYType ) nPo.havePHYType = TRUE;
+
+  // dot11PhyDSSSTable
+  if ( wi->has_range ) { // && wi->freq <= ( double ) 2483000000 ) {  // DSSS frequencies only
+    for ( i = 0; i < wi->range.num_frequency; i++ ) {
+      if ((( double ) ( wi->range.freq[i].e * 10 ) * ( double ) wi->range.freq[i].m ) == wi->freq ) {
+        nPd.haveCurrentChannel = TRUE;
+        nPd.currentChannel = wi->range.freq[i].i; 
+      }
+    }
+  }
+
+  // dot11SupportedDataRatesTxTable
+  if ( wi->has_range ) {
+    for ( i = 0; i < wi->range.num_bitrates; i++ ) {
+      nRt.ifIndex = ifIndex;
+      nRt.supportedDataRatesTxIndex = i + 1;
+      nRt.supportedDataRatesTxValue = wi->range.bitrate[i] / 500000L;
+      nRt.haveSupportedDataRatesTxValue = TRUE;
+      sprintf ( nRt.UID, "%04d%04d\0", nRt.ifIndex, nRt.supportedDataRatesTxIndex );
+      strcpy ( nRt.ifName, ifName );
+      addList (( char * ) &rtList, ( char * ) &nRt, sizeof ( nRt ));
+    }
+  }
+
+  // dot11SupportedDataRatesRxTable
+  if ( wi->has_range ) {
+    for ( i = 0; i < wi->range.num_bitrates; i++ ) {
+      nRr.ifIndex = ifIndex;
+      nRr.supportedDataRatesRxIndex = i + 1;
+      nRr.supportedDataRatesRxValue = wi->range.bitrate[i] / 500000L;
+      nRr.haveSupportedDataRatesRxValue = TRUE;
+      sprintf ( nRr.UID, "%04d%04d\0", nRr.ifIndex, nRr.supportedDataRatesRxIndex );
+      strcpy ( nRr.ifName, ifName );
+      addList (( char * ) &rrList, ( char * ) &nRr, sizeof ( nRr ));
+    }
+  }
+
+//printf ( "%s max_encoding_tokens: %d\n", 
+//          "loadWiExtTo80211Structs() - ", wi->range.max_encoding_tokens );
+}
+
+/****************************************************************************
+*                                                                           *
+*      loadWiExt() - load wireless extensions structures;                   *
+*                    use ioctl calls and read /proc/net/wireless            *
+*                                                                           *
+****************************************************************************/
+static void loadWiExt ( int skfd, char *ifname, struct wireless_info *wi )
+{
+  struct iwreq wrq;                       // ioctl request structure
+  FILE *fp;
+  char  bfr[1024];
+  char  buffer[sizeof ( iwrange ) * 2]; /* Large enough */
+  char *s, *t;
+  int i, j;
+
+  strncpy ( wrq.ifr_name, ifname, IFNAMSIZ );
+
+  /* Get wireless name */
+  if ( ioctl ( skfd, SIOCGIWNAME, &wrq ) >= 0 ) {
+    strncpy ( wi->name, wrq.u.name, IFNAMSIZ );
+    wi->name[IFNAMSIZ] = '\0';
+  }
+
+  /* Get ranges */    // NOTE: some version checking in iwlib.c
+  memset ( buffer, 0, sizeof ( buffer ));
+  wrq.u.data.pointer = ( caddr_t ) &buffer;
+  wrq.u.data.length = sizeof ( buffer );
+  wrq.u.data.flags = 0;
+  if ( ioctl ( skfd, SIOCGIWRANGE, &wrq ) >= 0 ) {
+    memcpy (( char * ) &wi->range, buffer, sizeof ( iwrange ));
+    wi->has_range = 1;
+  }
+
+  /* Get network ID */
+  if ( ioctl ( skfd, SIOCGIWNWID, &wrq ) >= 0 ) {
+    memcpy ( &wi->nwid, &wrq.u.nwid, sizeof ( iwparam ));
+    wi->has_nwid = 1;
+  }
+
+  /* Get frequency / channel */         // THIS NUMBER LOOKS FUNNY
+  if ( ioctl ( skfd, SIOCGIWFREQ, &wrq ) >= 0 ) {
+    wi->has_freq = 1;
+    wi->freq = (( double ) wrq.u.freq.m ) * pow ( 10, wrq.u.freq.e );
+  }
+
+  /* Get sensitivity */
+  if ( ioctl ( skfd, SIOCGIWSENS, &wrq ) >= 0 ) {
+    wi->has_sens = 1;
+    memcpy ( &wi->sens, &wrq.u.sens, sizeof ( iwparam ));
+  }
+
+  /* Get encryption information */
+  wrq.u.data.pointer = ( caddr_t ) &wi->key;
+  wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
+  wrq.u.data.flags = 0;
+  if ( ioctl ( skfd, SIOCGIWENCODE, &wrq ) >= 0 ) {
+    wi->has_key = 1;
+    wi->key_size = wrq.u.data.length;
+    wi->key_flags = wrq.u.data.flags;
+    wepCurrentKey = wrq.u.data.flags & IW_ENCODE_INDEX;
+  }
+
+  for ( i = 0; i < wi->range.max_encoding_tokens; i++ ) {
+    wrq.u.data.pointer = ( caddr_t ) &wi->key;
+    wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
+    wrq.u.data.flags = i;
+    if ( ioctl ( skfd, SIOCGIWENCODE, &wrq ) >= 0 ) {
+      if ( ( wrq.u.data.length != 0 ) &&
+          !( wrq.u.data.flags & IW_ENCODE_DISABLED )) {
+        wep[i].len = wrq.u.data.length;
+        wep[i].haveKey = TRUE;
+        t = wep[i].key;
+        for ( j = 0; j < wrq.u.data.length; j++ ) {
+          if (( j & 0x1 ) == 0 && j != 0 )
+        	  strcpy ( t++, "-");
+          sprintf ( t, "%.2X", wi->key[j] );
+          t += 2;
+        }
+        t = '\0';
+      }
+    }
+  }
+
+  /* Get ESSID */
+  wrq.u.essid.pointer = ( caddr_t ) &wi->essid;
+  wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
+  wrq.u.essid.flags = 0;
+  if ( ioctl ( skfd, SIOCGIWESSID, &wrq ) >= 0 ) {
+    wi->has_essid = 1;
+    wi->essid_on = wrq.u.data.flags;
+  }
+
+  /* Get AP address */
+  if ( ioctl ( skfd, SIOCGIWAP, &wrq ) >= 0 ) {
+    wi->has_ap_addr = 1;
+    memcpy ( &wi->ap_addr, &wrq.u.ap_addr, sizeof ( sockaddr ));
+  }
+
+  /* Get NickName */
+  wrq.u.essid.pointer = ( caddr_t ) &wi->nickname;
+  wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
+  wrq.u.essid.flags = 0;
+  if ( ioctl ( skfd, SIOCGIWNICKN, &wrq ) >= 0 ) {
+    if ( wrq.u.data.length > 1 )
+      wi->has_nickname = 1;
+  }
+
+  /* Get bit rate */
+  if ( ioctl ( skfd, SIOCGIWRATE, &wrq ) >= 0 ) {
+    wi->has_bitrate = 1;
+    memcpy ( &wi->bitrate, &wrq.u.bitrate, sizeof ( iwparam ));
+  }
+
+  /* Get RTS threshold */
+  if ( ioctl ( skfd, SIOCGIWRTS, &wrq ) >= 0 ) {
+    wi->has_rts = 1;
+    memcpy ( &wi->rts, &wrq.u.rts, sizeof ( iwparam ));
+  }
+
+  /* Get fragmentation threshold */
+  if ( ioctl ( skfd, SIOCGIWFRAG, &wrq ) >= 0 ) {
+      wi->has_frag = 1;
+      memcpy ( &wi->frag, &wrq.u.frag, sizeof ( iwparam ));
+    }
+
+  /* Get operation mode */
+  if ( ioctl ( skfd, SIOCGIWMODE, &wrq ) >= 0 ) {
+      wi->mode = wrq.u.mode;
+      if ( wi->mode < IW_NUM_OPER_MODE && wi->mode >= 0 )
+        wi->has_mode = 1;
+  }
+
+  /* Get Power Management settings */                 // #if WIRELESS_EXT > 9
+  wrq.u.power.flags = 0;
+  if ( ioctl ( skfd, SIOCGIWPOWER, &wrq ) >= 0 ) {
+    wi->has_power = 1;
+    memcpy ( &wi->power, &wrq.u.power, sizeof ( iwparam ));
+  }
+
+  /* Get retry limit/lifetime */                      // #if WIRELESS_EXT > 10
+  if ( ioctl ( skfd, SIOCGIWRETRY, &wrq ) >= 0 ) {    
+    wi->has_retry = 1;
+    memcpy ( &wi->retry, &wrq.u.retry, sizeof ( iwparam ));
+  }
+
+  /* Get stats */                                     // #if WIRELESS_EXT > 11
+  wrq.u.data.pointer = ( caddr_t ) &wi->stats;
+  wrq.u.data.length = 0;
+  wrq.u.data.flags = 1;   /* Clear updated flag */
+  if ( ioctl ( skfd, SIOCGIWSTATS, &wrq ) < 0 )
+    wi->has_stats = 1;
+
+  if ( !wi->has_stats ) {                        // no ioctl support, go to file
+    fp = fopen ( PROC_NET_WIRELESS, "r" );
+    if ( fp ) {
+      while ( fgets ( bfr, sizeof ( bfr ), fp )) {
+        bfr [ sizeof ( bfr ) - 1 ] = '\0';        // no buffer overruns here!
+        strtok (( char * ) &bfr, "\n" );          // '\n' => '\0'
+        if ( strstr ( bfr, ifname ) && strstr ( bfr, ":" )) {
+          wi->has_stats = 1;
+          s = bfr;
+          s = strchr ( s, ':' ); s++;             /* Skip ethX:   */
+          s = strtok ( s, " " );                  /* ' ' => '\0'  */
+          sscanf ( s, "%X", &wi->stats.status ); // status 
+
+          s = strtok ( NULL, " " );               // link quality
+          if ( strchr ( s, '.' ) != NULL )
+            wi->stats.qual.updated |= 1;
+          sscanf ( s, "%d", &wi->stats.qual.qual );
+
+          s = strtok ( NULL, " " );               // signal level
+          if ( strchr ( s,'.' ) != NULL )
+            wi->stats.qual.updated |= 2;
+          sscanf ( s, "%d", &wi->stats.qual.level );
+
+          s = strtok ( NULL, " " );               // noise level
+          if ( strchr ( s, '.' ) != NULL )
+            wi->stats.qual.updated += 4;
+          sscanf ( s, "%d", &wi->stats.qual.noise );
+
+          s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.nwid     );
+          s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.code     );
+          s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.fragment );
+          s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.retries  );
+          s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.discard.misc     );
+          s = strtok ( NULL, " " ); sscanf ( s, "%d", &wi->stats.miss.beacon      );
+        }
+      }
+      fclose ( fp );
+    }
+  }
+
+// printf ( "%s bfr: %s\n", "loadTables()", bfr );
+}
+
+/****************************************************************************
+*                                                                           *
+*       displayWiExt() - show what I got from Wireless Extensions           *
+*                                                                           *
+****************************************************************************/
+static void displayWiExt ( struct wireless_info info )
+{
+#ifdef DISPLAYWIEXT
+  int i;
+  char title[] = "displayWiExt() -";
+
+  printf ( "========================================\n" );
+  printf ( "===> Wireless Extension IOCTL calls <===\n" );
+  printf ( "========================================\n" );
+
+  if ( strlen ( info.name ))
+    printf ( "%s name: %s\n", "SIOCGIWNAME", info.name );
+  else
+    printf ( "%s\n", "no info.name support" );
+
+  if ( info.has_nickname = 1 )
+    printf ( "%s nickname: %s\n", "SIOCGIWNICKN", info.nickname );
+  else
+    printf ( "%s %s\n", "SIOCGIWNICKN", " ===> no info.nickname support" );
+
+  if ( info.has_essid ) 
+    printf ( "%s essid_on: %d essid: %s\n", "SIOCGIWESSID", info.essid_on, info.essid );
+  else
+    printf ( "%s %s\n", "SIOCGIWESSID", " ===> no info.essid support" );
+
+  if ( info.has_range ) {
+    printf ( "%s throughput: %d\n",           "SIOCGIWRANGE", info.range.throughput );
+    printf ( "%s min_nwid: %d\n",             "SIOCGIWRANGE", info.range.min_nwid  );
+    printf ( "%s max_nwid: %d\n",             "SIOCGIWRANGE", info.range.max_nwid  );
+    printf ( "%s sensitivity: %d\n",          "SIOCGIWRANGE", info.range.sensitivity );
+    printf ( "%s num_bitrates: %d\n",         "SIOCGIWRANGE", info.range.num_bitrates );
+    for ( i = 0; i < info.range.num_bitrates; i++ ) 
+      printf ( "%s bitrate[%d]: %d\n",        "SIOCGIWRANGE", i, info.range.bitrate[i]  );
+    printf ( "%s min_rts: %d\n",              "SIOCGIWRANGE", info.range.min_rts );
+    printf ( "%s max_rts: %d\n",              "SIOCGIWRANGE", info.range.max_rts );
+    printf ( "%s min_frag: %d\n",             "SIOCGIWRANGE", info.range.min_frag );
+    printf ( "%s max_frag: %d\n",             "SIOCGIWRANGE", info.range.max_frag );
+    printf ( "%s min_pmp: %d\n",              "SIOCGIWRANGE", info.range.min_pmp );
+    printf ( "%s max_pmp: %d\n",              "SIOCGIWRANGE", info.range.max_pmp );
+    printf ( "%s min_pmt: %d\n",              "SIOCGIWRANGE", info.range.min_pmt );
+    printf ( "%s max_pmt: %d\n",              "SIOCGIWRANGE", info.range.max_pmt );
+    printf ( "%s pmp_flags: %d\n",            "SIOCGIWRANGE", info.range.pmp_flags );
+    printf ( "%s pmt_flags: %d\n",            "SIOCGIWRANGE", info.range.pmt_flags );
+    printf ( "%s pm_capa: %d\n",              "SIOCGIWRANGE", info.range.pm_capa );
+    printf ( "%s num_encoding_sizes: %d\n",   "SIOCGIWRANGE", info.range.num_encoding_sizes );
+    for ( i = 0; i < info.range.num_encoding_sizes; i++ ) 
+      printf ( "%s encoding_size[%d]: %d\n",  "SIOCGIWRANGE", i, info.range.encoding_size[i]  );
+    printf ( "%s max_encoding_tokens: %d\n",  "SIOCGIWRANGE", info.range.max_encoding_tokens );
+//  printf ( "%s encoding_login_index: %d\n", "SIOCGIWRANGE", info.range.encoding_login_index );
+    printf ( "%s txpower_capa: %d\n",         "SIOCGIWRANGE", info.range.txpower_capa );
+    printf ( "%s num_txpower: %d dBm\n",      "SIOCGIWRANGE", info.range.num_txpower );
+    for ( i = 0; i < info.range.num_txpower; i++ ) 
+      printf ( "%s txpower[%d]: %d\n",        "SIOCGIWRANGE", i, info.range.txpower[i]  );
+    printf ( "%s we_version_compiled: %d\n",  "SIOCGIWRANGE", info.range.we_version_compiled );
+    printf ( "%s we_version_source: %d\n",    "SIOCGIWRANGE", info.range.we_version_source );
+    printf ( "%s retry_capa: %d\n",           "SIOCGIWRANGE", info.range.retry_capa );
+    printf ( "%s retry_flags: %d\n",          "SIOCGIWRANGE", info.range.retry_flags );
+    printf ( "%s r_time_flags: %d\n",         "SIOCGIWRANGE", info.range.r_time_flags );
+    printf ( "%s min_retry: %d\n",            "SIOCGIWRANGE", info.range.min_retry );
+    printf ( "%s max_retry: %d\n",            "SIOCGIWRANGE", info.range.max_retry );
+    printf ( "%s min_r_time: %d\n",           "SIOCGIWRANGE", info.range.min_r_time );
+    printf ( "%s max_r_time: %d\n",           "SIOCGIWRANGE", info.range.max_r_time );
+    printf ( "%s num_channels: %d\n",         "SIOCGIWRANGE", info.range.num_channels );
+    printf ( "%s num_frequency: %d\n",        "SIOCGIWRANGE", info.range.num_frequency );
+    for ( i = 0; i < info.range.num_frequency; i++ ) 
+      printf ( "%s freq[%d].i: %d freq[%d].e: %d freq[%d].m: %d\n", "SIOCGIWRANGE", 
+                i, info.range.freq[i].i, i, info.range.freq[i].e, i, info.range.freq[i].m );
+  }
+  else
+    printf ( "%s %s\n", "SIOCGIWRANGE", " ===> no info.range support" );
+
+  if ( info.has_nwid ) 
+    printf ( "%s nwid - disabled: %d value: %X\n", "SIOCGIWNWID", info.nwid.disabled, info.nwid.value );
+  else
+    printf ( "%s %s\n", "SIOCGIWNWID", " ===> no info.nwid support" );
+
+  if ( info.has_freq ) {
+//  printf ( "%s freq: %g\n", "SIOCGIWFREQ", info.freq / GIGA );
+    printf ( "%s freq: %g\n", "SIOCGIWFREQ", info.freq );
+  }
+  else
+    printf ( "%s %s\n", "SIOCGIWFREQ", " ===> no info.freq support" );
+
+  if ( info.has_sens )
+    printf ( "%s sens: %d\n", "SIOCGIWSENS", info.sens );
+  else
+    printf ( "%s %s\n", "SIOCGIWSENS", " ===> no info.sens support" );
+
+  if ( info.has_key ) {
+    printf ( "%s key_size: %d key_flags: %d wepCurrentKey: %d\n", 
+              "SIOCGIWENCODE", info.key_size, info.key_flags, wepCurrentKey );
+    printf ( "%s MODE: %d DISABLED: %d INDEX: %d OPEN: %d RESTRICTED: %d NOKEY: %d TEMP: %d\n",
+              "SIOCGIWENCODE",                           info.key_flags & IW_ENCODE_MODE,
+              info.key_flags & IW_ENCODE_DISABLED ? 1:0, info.key_flags & IW_ENCODE_INDEX,
+              info.key_flags & IW_ENCODE_OPEN     ? 1:0, info.key_flags & IW_ENCODE_RESTRICTED ? 1:0,
+              info.key_flags & IW_ENCODE_NOKEY    ? 1:0, info.key_flags & IW_ENCODE_TEMP       ? 1:0 );
+  }
+  else
+    printf ( "%s %s\n", "SIOCGIWENCODE", " ===> no info.key support" );
+
+  for ( i = 0; i < MAX_WEP_KEYS; i++ ) {
+    if ( wep[i].haveKey )
+      printf ( "%s wep[%d].len: %d wep[%d].key: %s\n", 
+                "SIOCGIWENCODE", i, wep[i].len, i, wep[i].key );
+  }
+
+  if ( info.has_ap_addr )
+    printf ( "%s ap_addr.sa_data: %02X:%02X:%02X:%02X:%02X:%02X ap_addr.sa_family: %d\n", 
+              "SIOCGIWAP",  ( UCHAR ) info.ap_addr.sa_data[0], ( UCHAR ) info.ap_addr.sa_data[1], 
+                            ( UCHAR ) info.ap_addr.sa_data[2], ( UCHAR ) info.ap_addr.sa_data[3], 
+                            ( UCHAR ) info.ap_addr.sa_data[4], ( UCHAR ) info.ap_addr.sa_data[5], 
+                                      info.ap_addr.sa_family );
+  else
+    printf ( "%s %s\n", "SIOCGIWAP", " ===> no ap_addr information" );
+
+  if ( info.has_bitrate )
+    printf ( "%s bitrate: %d value: %d fixed: %d disabled: %d flags: %d\n", 
+              "SIOCGIWRATE", info.bitrate, info.bitrate.value, info.bitrate.fixed, 
+                             info.bitrate.disabled, info.bitrate.flags );
+  else
+    printf ( "%s %s\n", "SIOCGIWRATE", " ===> no info.bitrate support" );
+
+  if ( info.has_rts )
+    printf ( "%s rts: %d\n", "SIOCGIWRTS", info.rts );
+  else
+    printf ( "%s %s\n", "SIOCGIWRTS", " ===> no info.rts support" );
+
+  if ( info.has_frag )
+    printf ( "%s frag: %d\n", "SIOCGIWFRAG", info.frag );
+  else
+    printf ( "%s %s\n", "SIOCGIWFRAG", " ===> no info.frag support" );
+
+  if ( info.has_mode ) 
+    printf ( "%s mode: %d\n", "SIOCGIWMODE", info.mode );
+  else
+    printf ( "%s %s\n", "SIOCGIWMODE", " ===> no info.mode support" );
+
+  if ( info.has_power ) {
+    printf ( "%s power: %d\n", "SIOCGIWPOWER", info.power );
+    printf ( "%s disabled: %d MIN: %d MAX: %d TIMEOUT: %d RELATIVE: %d\n",
+              "SIOCGIWPOWER",
+              info.power.disabled                  ? 1:0, 
+              info.power.flags & IW_POWER_MIN      ? 1:0, 
+              info.power.flags & IW_POWER_MAX      ? 1:0, 
+              info.power.flags & IW_POWER_TIMEOUT  ? 1:0, 
+              info.power.flags & IW_POWER_RELATIVE ? 1:0 ); 
+    printf ( "%s UNICAST: %d MULTICAST: %d ALL: %d FORCE: %d REPEATER: %d\n",
+              "SIOCGIWPOWER",
+              info.power.flags & IW_POWER_UNICAST_R   ? 1:0, 
+              info.power.flags & IW_POWER_MULTICAST_R ? 1:0, 
+              info.power.flags & IW_POWER_ALL_R       ? 1:0, 
+              info.power.flags & IW_POWER_FORCE_S     ? 1:0, 
+              info.power.flags & IW_POWER_REPEATER    ? 1:0 ); 
+  }
+  else
+    printf ( "%s %s\n", "SIOCGIWPOWER", " ===> no info.power support" );
+
+  if ( info.has_retry )
+    printf ( "%s retry: %d\n", "SIOCGIWRETRY", info.retry );
+  else
+    printf ( "%s %s\n", "SIOCGIWRETRY", " ===> no info.retry support" );
+
+  if ( info.has_stats ) {
+    printf ( "%s status: %d\n",           "SIOCGIWSTATS", info.stats.status           );
+    printf ( "%s qual.level: %d\n",       "SIOCGIWSTATS", info.stats.qual.level       );
+    printf ( "%s qual.noise: %d\n",       "SIOCGIWSTATS", info.stats.qual.noise       );
+    printf ( "%s qual.qual: %d\n",        "SIOCGIWSTATS", info.stats.qual.qual        );
+    printf ( "%s qual.updated: %d\n",     "SIOCGIWSTATS", info.stats.qual.updated     );
+    printf ( "%s discard.code: %d\n",     "SIOCGIWSTATS", info.stats.discard.code     );
+    printf ( "%s discard.fragment: %d\n", "SIOCGIWSTATS", info.stats.discard.fragment );
+    printf ( "%s discard.misc: %d\n",     "SIOCGIWSTATS", info.stats.discard.misc     );
+    printf ( "%s discard.nwid: %d\n",     "SIOCGIWSTATS", info.stats.discard.nwid     );
+    printf ( "%s discard.retries: %d\n",  "SIOCGIWSTATS", info.stats.discard.retries  );
+    printf ( "%s miss.beacon: %d\n",      "SIOCGIWSTATS", info.stats.miss.beacon      );
+  }
+  else
+    printf ( "%s %s\n", "SIOCGIWSTATS", " ===> no info.stats support" );
+
+  if ( info.txpower.flags & IW_TXPOW_MWATT )
+    printf ( "%s txpower1: %d dBm disabled: %d fixed: %d flags: %d\n", "SIOCGIWRANGE", 
+      mWatt2dbm ( info.txpower.value ), info.txpower.disabled, info.txpower.fixed, info.txpower.flags);
+  else
+    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 );
+
+  if ( info.has_range ) 
+    if ( info.sens.value < 0 )
+      printf ( "%s sens: %d dBm\n", "SIOCGIWRANGE", info.sens.value );
+    else
+      printf ( "%s sens: %d/%d\n", "SIOCGIWRANGE", info.sens.value, info.range.sensitivity );
+
+  if ( info.has_range && ( info.stats.qual.level != 0 ))
+      if ( info.stats.qual.level > info.range.max_qual.level )
+        /* Statistics are in dBm (absolute power measurement) */
+        printf ( "%s Quality: %d/%d Signal level: %d dBm Noise level: %d dBm\n",
+                  "SIOCGIWRANGE",
+                  info.stats.qual.qual, info.range.max_qual.qual,
+                  info.stats.qual.level - 0x100,
+                  info.stats.qual.noise - 0x100 );
+      else
+        printf (  "%s Quality: %d/%d Signal level: %d/%d Noise level: %d/%d",
+                  "SIOCGIWRANGE",
+                  info.stats.qual.qual,  info.range.max_qual.qual,
+                  info.stats.qual.level, info.range.max_qual.level,
+                  info.stats.qual.noise, info.range.max_qual.noise );
+
+#endif // #ifdef DISPLAYWIEXT
+}
+
+/****************************************************************************
+*                                                                           *
+*                        Linked List Functions                              *
+*                                                                           *
+****************************************************************************/
+/****************************************************************************
+*                                                                           *
+*                addList() - add an entry to a linked list                  *
+*                                                                           *
+****************************************************************************/
+static void 
+addList ( char *l, char *data, int len  )
+{
+  char uid[256];
+  LIST_HEAD ( , avNode ) *list;       
+
+  // NOTE: this assumes the UID is at the beginning of the 
+  //       data structure and that UIDs are strings
+  
+  list = ( LIST_HEAD ( , avNode ) * ) l;            // NOTE: don't know how to get 
+  strcpy ( uid, data );                             //  rid of compiler warning on
+                                                    //  LISTHEAD typecast
+  // create a new node and the data that goes in it
+  newNode = malloc ( sizeof ( struct avNode ));
+  newNode->data = malloc ( len );
+  memcpy ( newNode->data, data, len );
+
+  // this deals with an empty list
+  if ( LIST_EMPTY ( list )) {
+    LIST_INSERT_HEAD ( list, newNode, nodes );
+    return;
+  }
+
+  // this deals with UIDs that match
+  for ( np = LIST_FIRST ( list ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    if ( strncmp ( uid, np->data, strlen ( uid )) == 0 ) {                      // found matching UID
+      LIST_INSERT_AFTER ( np, newNode, nodes );
+      if ( np->data )
+        free ( np->data );
+      LIST_REMOVE ( np, nodes );
+      free ( np );
+      return;
+    }
+  }
+
+  // this deals with inserting a new UID in the list
+  for ( np = LIST_FIRST ( list ); np != NULL; np = LIST_NEXT ( np, nodes )) {
+    lastNode = np;
+    if ( strncmp ( np->data, uid, strlen ( uid )) > 0 ) {                       // old ID > new ID AND
+      LIST_INSERT_BEFORE ( np, newNode, nodes );
+      return;
+    }
+  }
+
+  // this deals with a UID that needs to go on the end of the list
+  LIST_INSERT_AFTER ( lastNode, newNode, nodes );
+
+  return;
+}
+
+/****************************************************************************
+*                                                                           *
+*              initLists() - initialize all the linked lists                *
+*                                                                           *
+****************************************************************************/
+static void initLists()
+{
+  LIST_INIT ( &scList );  LIST_INIT ( &aaList );  LIST_INIT ( &dfList );
+  LIST_INIT ( &kmList );  LIST_INIT ( &prList );
+  LIST_INIT ( &opList );  LIST_INIT ( &coList );
+  LIST_INIT ( &gaList );  LIST_INIT ( &riList );  LIST_INIT ( &poList );
+  LIST_INIT ( &paList );  LIST_INIT ( &ptList );  LIST_INIT ( &pfList );
+  LIST_INIT ( &pdList );  LIST_INIT ( &piList );  LIST_INIT ( &rdList );
+  LIST_INIT ( &alList );  LIST_INIT ( &rtList );  LIST_INIT ( &rrList );
+}
+/****************************************************************************
+*                                                                           *
+*                 flushLists() - flush all linked lists                     *
+*                                                                           *
+****************************************************************************/
+static void flushLists()
+{
+  flushList (( char * ) &scList );  flushList (( char * ) &aaList );
+  flushList (( char * ) &dfList );  flushList (( char * ) &kmList );
+  flushList (( char * ) &prList );
+  flushList (( char * ) &opList );  flushList (( char * ) &coList );
+  flushList (( char * ) &gaList );  flushList (( char * ) &riList );
+  flushList (( char * ) &poList );  flushList (( char * ) &paList );
+  flushList (( char * ) &ptList );  flushList (( char * ) &pfList );
+  flushList (( char * ) &pdList );  flushList (( char * ) &piList );
+  flushList (( char * ) &rdList );  flushList (( char * ) &alList );
+  flushList (( char * ) &rtList );  flushList (( char * ) &rrList );
+}
+
+/****************************************************************************
+*                                                                           *
+*                   flushList() - flush a linked list                       *
+*                                                                           *
+****************************************************************************/
+static void flushList ( char *l )
+{
+  LIST_HEAD ( , avNode ) *list;
+  
+  list = ( LIST_HEAD ( , avNode ) * ) l;    // NOTE: don't know how to get 
+  while ( !LIST_EMPTY ( list )) {           //  rid of compiler warning on
+    np = LIST_FIRST ( list );               //  LISTHEAD typecast
+    if ( np->data )
+      free ( np->data );
+    LIST_REMOVE ( np, nodes );
+    free ( np );
+  }
+}
+
+/****************************************************************************
+*                                                                           *
+*                            Utility Functions                              *
+*                                                                           *
+****************************************************************************/
+/****************************************************************************
+*                                                                           *
+*        The following two routines were taken directly from iwlib.c        *
+*                                                                           *
+****************************************************************************/
+ /*
+ * Open a socket.
+ * Depending on the protocol present, open the right socket. The socket
+ * will allow us to talk to the driver.
+ */
+static int openSocket ( void )
+{
+  static const int families[] = {
+    AF_INET, AF_IPX, AF_AX25, AF_APPLETALK
+  };
+  unsigned int  i;
+  int   sock;
+
+  /*
+   * Now pick any (exisiting) useful socket family for generic queries
+   * Note : don't open all the socket, only returns when one matches,
+   * all protocols might not be valid.
+   * Workaround by Jim Kaba <jkaba@sarnoff.com>
+   * Note : in 99% of the case, we will just open the inet_sock.
+   * The remaining 1% case are not fully correct...
+   */
+
+  /* Try all families we support */
+  for(i = 0; i < sizeof(families)/sizeof(int); ++i) {
+      /* Try to open the socket, if success returns it */
+      sock = socket(families[i], SOCK_DGRAM, 0);
+      if(sock >= 0)
+  return sock;
+  }
+
+  return -1;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Convert a value in milliWatt to a value in dBm.
+ */
+static int mWatt2dbm ( int in )
+{
+#ifdef WE_NOLIBM
+  /* Version without libm : slower */
+  double  fin = (double) in;
+  int   res = 0;
+
+  /* Split integral and floating part to avoid accumulating rounding errors */
+  while(fin > 10.0)
+    {
+      res += 10;
+      fin /= 10.0;
+    }
+  while(fin > 1.000001) /* Eliminate rounding errors, take ceil */
+    {
+      res += 1;
+      fin /= LOG10_MAGIC;
+    }
+  return(res);
+#else /* WE_NOLIBM */
+  /* Version with libm : faster */
+  return((int) (ceil(10.0 * log10((double) in))));
+#endif  /* WE_NOLIBM */
+}
+
+/****************************************************************************
+*                                                                           *
+*                 htob - converts hex string to binary                      *
+*                                                                           *
+****************************************************************************/
+static char *htob ( char *s )
+{
+    char nibl, *byt;
+    static char bin[20];
+
+    byt = bin;
+
+    while ((nibl = *s++) && nibl != ' ') {    /* While not end of string. */
+      nibl -= ( nibl > '9') ?  ('A' - 10): '0';
+      *byt = nibl << 4;                              /* place high nibble */
+      if((nibl = *s++) && nibl != ' ') {
+        nibl -= ( nibl > '9') ?  ('A' - 10): '0';
+        *byt |= nibl;                                /*  place low nibble */
+      }
+      else break;
+      ++byt;
+    }
+    *++byt = '\0';
+    return ( bin );
+}
+
+/****************************************************************************
+*                                                                           *
+*           hasChanged() - see if area has been changed from NULLs          *
+*                                                                           *
+****************************************************************************/
+static int hasChanged ( char *loc, int len )
+{
+  char *wrk;
+  int changed = TRUE;
+
+  wrk = malloc ( len );
+  memset ( wrk, 0, len );
+  if ( memcmp ( loc, wrk, len ) == 0 )
+    changed = FALSE;
+  free ( wrk );
+
+  return ( changed );
+}
+
--- /dev/null
+++ b/agent/mibgroup/ieee802dot11.h
@@ -0,0 +1,730 @@
+/****************************************************************************
+*                                                                           *
+*  File Name:           ieee802dot11.h                                      *
+*  Used By:                                                                 *
+*                                                                           *
+*  Operating System:                                                        *
+*  Purpose:                                                                 *
+*                                                                           *
+*  Comments:                                                                *
+*                                                                           *
+*  Author:              Larry Simmons                                       *
+*                       lsimmons@avantcom.com                               *
+*                       www.avantcom.com                                    *
+*                                                                           *
+*  Creation Date:       09/02/03                                            *
+*                                                                           *
+*   Ver    Date   Inits Modification                                        *
+*  ----- -------- ----- ------------                                        *
+*  0.0.1 09/02/03  LRS  created                                             *
+*  0.0.2 09/24/03  LRS  wouldn't build after fresh ./configure              *
+****************************************************************************/
+/* This file was generated by mib2c and is intended for use as a mib module
+  for the ucd-snmp snmpd agent. */
+#ifndef _MIBGROUP_IEEE802DOT11_H
+#define _MIBGROUP_IEEE802DOT11_H
+/* we may use header_generic and header_simple_table from the util_funcs module */
+
+/****************************************************************************
+*                               Includes                                    *
+****************************************************************************/
+#include <sys/queue.h>
+
+/****************************************************************************
+*                             Linked List Defines                           *
+****************************************************************************/
+// here are some Linked List MACROS I wanted to use, 
+// but curiously were not in /usr/includes/sys/queue.h
+
+#ifndef LIST_EMPTY
+  #define	LIST_EMPTY(head)	((head)->lh_first == NULL)
+#endif
+
+#ifndef LIST_NEXT
+  #define	LIST_NEXT(elm, field)	((elm)->field.le_next)
+#endif
+
+#ifndef LIST_INSERT_BEFORE
+  #define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
+	  (elm)->field.le_prev = (listelm)->field.le_prev;		\
+	  LIST_NEXT((elm), field) = (listelm);				\
+	  *(listelm)->field.le_prev = (elm);				\
+	  (listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
+  } while (0)
+#endif
+
+#ifndef LIST_FIRST
+  #define	LIST_FIRST(head)	((head)->lh_first)
+#endif
+
+/****************************************************************************
+*                             802.11 MIB Defines                            *
+****************************************************************************/
+#define SYS_STRING_LEN                     256
+#define MACADDR_LEN                        ( 6 * 2 ) + 5
+#define OPER_RATE_SET_LEN                  126
+#define MAN_OUI_LEN                        ( 3 * 2 ) + 2
+#define WEP_STR_LEN                         64
+#define SNMP_STR_LEN                       128
+#define TEXT_LEN                            80
+#define IFINDEX_LEN                          4
+#define IFNAME_LEN                          16
+#define MAX_WEP_KEYS                         4
+
+#define AUTHENICATION_ALGORITHMS_INDEX_LEN   4
+#define WEP_DEFAULT_KEY_INDEX_LEN            4
+#define WEP_KEY_MAPPING_INDEX_LEN            4
+#define GROUP_ADDRESS_INDEX_LEN              4
+#define REG_DOMAIN_SUPPORT_INDEX_LEN         4
+#define ANTENNA_LIST_INDEX_LEN               4
+#define SUPPORTED_DATA_RATES_TX_INDEX_LEN    4
+#define SUPPORTED_DATA_RATES_RX_INDEX_LEN    4
+
+#define SC_UID_LEN  IFINDEX_LEN
+#define AA_UID_LEN  IFINDEX_LEN + AUTHENICATION_ALGORITHMS_INDEX_LEN
+#define DF_UID_LEN  IFINDEX_LEN + WEP_DEFAULT_KEY_INDEX_LEN
+#define KM_UID_LEN  IFINDEX_LEN + WEP_KEY_MAPPING_INDEX_LEN
+#define PR_UID_LEN  IFINDEX_LEN
+#define OP_UID_LEN  IFINDEX_LEN
+#define CO_UID_LEN  IFINDEX_LEN
+#define GA_UID_LEN  IFINDEX_LEN + GROUP_ADDRESS_INDEX_LEN
+#define RI_UID_LEN  IFINDEX_LEN
+#define PO_UID_LEN  IFINDEX_LEN
+#define PA_UID_LEN  IFINDEX_LEN
+#define PT_UID_LEN  IFINDEX_LEN
+#define PF_UID_LEN  IFINDEX_LEN
+#define PD_UID_LEN  IFINDEX_LEN
+#define PI_UID_LEN  IFINDEX_LEN
+#define RD_UID_LEN  IFINDEX_LEN + REG_DOMAIN_SUPPORT_INDEX_LEN
+#define AL_UID_LEN  IFINDEX_LEN + ANTENNA_LIST_INDEX_LEN
+#define RT_UID_LEN  IFINDEX_LEN + SUPPORTED_DATA_RATES_TX_INDEX_LEN
+#define RR_UID_LEN  IFINDEX_LEN + SUPPORTED_DATA_RATES_RX_INDEX_LEN
+
+/****************************************************************************
+*                           Linked List Structure                           *
+****************************************************************************/
+static struct avNode {  
+  LIST_ENTRY ( avNode ) nodes; 
+  char *data;                                 // pointer to data
+};
+
+typedef LIST_HEAD ( , avNode ) avList_t;
+
+/****************************************************************************
+*                          802.11 MIB structures                            *
+****************************************************************************/
+/****************************************************************************
+*                             dot11Smt Group                                *
+****************************************************************************/
+/****************************************************************************
+*                          dot11StationConfigTable                          *
+****************************************************************************/
+static struct scTbl_data {
+
+  char  UID       [ SC_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  char  stationID [ MACADDR_LEN + 1 ];              // Default actual MacAddr
+  long  mediumOccupancyLimit;
+  long  CFPPollable;
+  long  CFPPeriod;
+  long  maxDuration;
+  long  authenticationResponseTimeOut;
+  long  privacyOptionImplemented;
+  long  powerManagementMode;
+  char  desiredSSID             [ SNMP_STR_LEN + 1 ];
+  long  desiredBSSType;
+  char  operationalRateSet      [ OPER_RATE_SET_LEN + 1];
+  long  beaconPeriod;
+  long  DTIMPeriod;
+  long  associationResponseTimeOut;
+  long  disAssociationReason;
+  char  disAssociationStation   [ MACADDR_LEN + 1 ];
+  long  deAuthenticationReason;
+  char  deAuthenticationStation [ MACADDR_LEN + 1 ];
+  long  authenticateFailStatus;
+  char  authenticateFailStation [ MACADDR_LEN + 1 ];
+
+  long  haveStationID;
+  long  haveMediumOccupancyLimit;
+  long  haveCFPPollable;
+  long  haveCFPPeriod;
+  long  haveMaxDuration;
+  long  haveAuthenticationResponseTimeOut;
+  long  havePrivacyOptionImplemented;
+  long  havePowerManagementMode;
+  long  haveDesiredSSID;
+  long  haveDesiredBSSType;
+  long  haveOperationalRateSet;
+  long  haveBeaconPeriod;
+  long  haveDTIMPeriod;
+  long  haveAssociationResponseTimeOut;
+  long  haveDisAssociationReason;
+  long  haveDisAssociationStation;
+  long  haveDeAuthenticationReason;
+  long  haveDeAuthenticationStation;
+  long  haveAuthenticateFailStatus;
+  long  haveAuthenticateFailStation;
+
+} nSc, *sc = &nSc;
+
+static avList_t scList;
+
+/****************************************************************************
+*                    dot11AuthenticationAlgorithmsTable                     *
+****************************************************************************/
+static struct aaTbl_data {
+
+  char  UID       [ AA_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+  long  authenticationAlgorithmsIndex;
+
+  long  authenticationAlgorithm;
+  long  authenticationAlgorithmsEnable;
+
+  long  haveAuthenticationAlgorithm;
+  long  haveAuthenticationAlgorithmsEnable;
+
+} nAa, *aa = &nAa;
+
+static avList_t aaList;
+
+/****************************************************************************
+*                           dot11WEPDefaultKeysTable                        *
+****************************************************************************/
+static struct dfTbl_data {
+
+  char  UID       [ DF_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;                                    // ifindex of card
+  long  WEPDefaultKeyIndex;
+
+  char  WEPDefaultKeyValue [ WEP_STR_LEN + 1 ];
+  long  haveWEPDefaultKeyValue;
+
+} nDf, *df = &nDf;
+
+static avList_t dfList;
+
+/****************************************************************************
+*                          dot11WEPKeyMappingsTable                         *
+****************************************************************************/
+static struct kmTbl_data {
+
+  char  UID       [ KM_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;
+  long  WEPKeyMappingIndex;
+
+  char  WEPKeyMappingAddress  [ MACADDR_LEN + 1 ];
+  long  WEPKeyMappingWEPOn;
+  char  WEPKeyMappingValue    [ WEP_STR_LEN + 1 ];
+  long  WEPKeyMappingStatus;
+
+  long  haveWEPKeyMappingIndex;
+  long  haveWEPKeyMappingAddress;
+  long  haveWEPKeyMappingWEPOn;
+  long  haveWEPKeyMappingValue;
+  long  haveWEPKeyMappingStatus;
+
+} nKm, *km = &nKm;
+
+static avList_t kmList;
+
+/****************************************************************************
+*                                dot11PrivacyTable                          *
+****************************************************************************/
+static struct prTbl_data {
+
+  char          UID       [ PR_UID_LEN + 1 ];
+  char          ifName    [ IFNAME_LEN + 1 ];
+
+  long          ifIndex;
+
+  long          privacyInvoked;
+  long          WEPDefaultKeyID;
+  long          WEPKeyMappingLength;
+  long          excludeUnencrypted;
+  unsigned long WEPICVErrorCount;
+  unsigned long WEPExcludedCount;
+
+  long          havePrivacyInvoked;
+  long          haveWEPDefaultKeyID;
+  long          haveWEPKeyMappingLength;
+  long          haveExcludeUnencrypted;
+  long          haveWEPICVErrorCount;
+  long          haveWEPExcludedCount;
+
+} nPr, *pr = &nPr;
+
+static avList_t prList;
+
+/****************************************************************************
+*                               dot11Mac Group                              *
+****************************************************************************/
+/****************************************************************************
+*                              dot11OperationTable                          *
+****************************************************************************/
+static struct opTbl_data {
+
+  char  UID       [ OP_UID_LEN + 1 ];                 // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];                 // ifName of card
+
+  long  ifIndex;                                      // ifindex of card
+
+  char  MACAddress      [ MACADDR_LEN + 1 ];
+  long  RTSThreshold;
+  long  shortRetryLimit;
+  long  longRetryLimit;
+  long  fragmentationThreshold;
+  long  maxTransmitMSDULifetime;
+  long  maxReceiveLifetime;
+  char  manufacturerID  [ SNMP_STR_LEN + 1 ];
+  char  productID       [ SNMP_STR_LEN + 1 ];
+
+  long  haveMACAddress;
+  long  haveRTSThreshold;
+  long  haveShortRetryLimit;
+  long  haveLongRetryLimit;
+  long  haveFragmentationThreshold;
+  long  haveMaxTransmitMSDULifetime;
+  long  haveMaxReceiveLifetime;
+  long  haveManufacturerID;
+  long  haveProductID;
+
+} nOp, *op = &nOp;
+
+static avList_t opList;
+
+/****************************************************************************
+*                            dot11CountersTable                             *
+****************************************************************************/
+static struct coTbl_data {
+
+  char          UID       [ CO_UID_LEN + 1 ];     // unique ID
+  char          ifName    [ IFNAME_LEN + 1 ];     // ifName of card
+
+  long          ifIndex;                          // ifindex of card
+
+  unsigned long  transmittedFragmentCount;
+  unsigned long  multicastTransmittedFrameCount;
+  unsigned long  failedCount;
+  unsigned long  retryCount;
+  unsigned long  multipleRetryCount;
+  unsigned long  frameDuplicateCount;
+  unsigned long  RTSSuccessCount;
+  unsigned long  RTSFailureCount;
+  unsigned long  ACKFailureCount;
+  unsigned long  receivedFragmentCount;
+  unsigned long  multicastReceivedFrameCount;
+  unsigned long  FCSErrorCount;
+  unsigned long  transmittedFrameCount;
+  unsigned long  WEPUndecryptableCount;
+
+  long           haveTransmittedFragmentCount;
+  long           haveMulticastTransmittedFrameCount;
+  long           haveFailedCount;
+  long           haveRetryCount;
+  long           haveMultipleRetryCount;
+  long           haveFrameDuplicateCount;
+  long           haveRTSSuccessCount;
+  long           haveRTSFailureCount;
+  long           haveACKFailureCount;
+  long           haveReceivedFragmentCount;
+  long           haveMulticastReceivedFrameCount;
+  long           haveFCSErrorCount;
+  long           haveTransmittedFrameCount;
+  long           haveWEPUndecryptableCount;
+
+} nCo, *co = &nCo;
+
+static avList_t coList;
+
+/****************************************************************************
+*                        dot11GroupAddressesTable                           *
+****************************************************************************/
+static struct gaTbl_data {
+
+  char  UID       [ GA_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;                                    // ifindex of card
+  long  groupAddressesIndex;
+
+  char  address   [ MACADDR_LEN + 1 ];
+  long  groupAddressesStatus;
+
+  long  haveAddress;
+  long  haveGroupAddressesStatus;
+
+} nGa, *ga = &nGa;
+
+static avList_t gaList;
+
+/****************************************************************************
+*                               dot11Res Group                              *
+****************************************************************************/
+static char  resourceTypeIDName[] = "RTID";
+static long  haveResourceTypeIDName = 1;
+
+/****************************************************************************
+*                           dot11ResourceInfoTable                          *
+****************************************************************************/
+static struct riTbl_data {
+
+  char  UID       [ RI_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  char  manufacturerOUI            [ MAN_OUI_LEN    + 1 ];
+  char  manufacturerName           [ SYS_STRING_LEN + 1 ];
+  char  manufacturerProductName    [ SYS_STRING_LEN + 1 ];
+  char  manufacturerProductVersion [ SYS_STRING_LEN + 1 ];
+
+  char  haveManufacturerOUI;
+  char  haveManufacturerName;
+  char  haveManufacturerProductName;
+  char  haveManufacturerProductVersion;
+
+} nRi, *ri = &nRi;
+
+static avList_t riList;
+
+/****************************************************************************
+*                               dot11Phy Group                              *
+****************************************************************************/
+/****************************************************************************
+*                           dot11PhyOperationTable                          *
+****************************************************************************/
+static struct poTbl_data {
+
+  char  UID       [ PO_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  long  PHYType;
+  long  currentRegDomain;
+  long  tempType;
+
+  long  havePHYType;
+  long  haveCurrentRegDomain;
+  long  haveTempType;
+
+} nPo, *po = &nPo;
+
+static avList_t poList;
+
+/****************************************************************************
+*                           dot11PhyAntennaEntry                            *
+****************************************************************************/
+static struct paTbl_data {
+
+  char  UID       [ PA_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  long  currentTxAntenna;
+  long  diversitySupport;
+  long  currentRxAntenna;
+
+  long  haveCurrentTxAntenna;
+  long  haveDiversitySupport;
+  long  haveCurrentRxAntenna;
+
+} nPa, *pa = &nPa;
+
+static avList_t paList;
+
+/****************************************************************************
+*                             dot11PhyTxPowerTable                          *
+****************************************************************************/
+static struct ptTbl_data {
+
+  char  UID       [ PT_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  long  numberSupportedPowerLevels;
+  long  TxPowerLevel1;
+  long  TxPowerLevel2;
+  long  TxPowerLevel3;
+  long  TxPowerLevel4;
+  long  TxPowerLevel5;
+  long  TxPowerLevel6;
+  long  TxPowerLevel7;
+  long  TxPowerLevel8;
+  long  currentTxPowerLevel;
+
+  long  haveNumberSupportedPowerLevels;
+  long  haveTxPowerLevel1;
+  long  haveTxPowerLevel2;
+  long  haveTxPowerLevel3;
+  long  haveTxPowerLevel4;
+  long  haveTxPowerLevel5;
+  long  haveTxPowerLevel6;
+  long  haveTxPowerLevel7;
+  long  haveTxPowerLevel8;
+  long  haveCurrentTxPowerLevel ;
+
+} nPt, *pt = &nPt;
+
+static avList_t ptList;
+
+/****************************************************************************
+*                               dot11PhyFHSSTable                           *
+****************************************************************************/
+static struct pfTbl_data {
+
+  char  UID       [ PF_UID_LEN + 1 ];              // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];              // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  long  hopTime;
+  long  currentChannelNumber;
+  long  maxDwellTime;
+  long  currentDwellTime;
+  long  currentSet;
+  long  currentPattern;
+  long  currentIndex;
+
+  long  haveHopTime;
+  long  haveCurrentChannelNumber;
+  long  haveMaxDwellTime;
+  long  haveCurrentDwellTime;
+  long  haveCurrentSet;
+  long  haveCurrentPattern;
+  long  haveCurrentIndex;
+
+} nPf, *pf = &nPf;
+
+static avList_t pfList;
+
+/****************************************************************************
+*                              dot11PhyDSSSTable                            *
+****************************************************************************/
+static struct pdTbl_data {
+
+  char  UID       [ PD_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  long  currentChannel;
+  long  CCAModeSupported;
+  long  currentCCAMode;
+  long  EDThreshold;
+
+  long  haveCurrentChannel;
+  long  haveCCAModeSupported ;
+  long  haveCurrentCCAMode;
+  long  haveEDThreshold;
+
+} nPd, *pd = &nPd;
+
+static avList_t pdList;
+
+/****************************************************************************
+*                              dot11PhyIRTable                              *
+****************************************************************************/
+static struct piTbl_data {
+
+  char  UID       [ PI_UID_LEN + 1 ];               // unique ID
+  char  ifName    [ IFNAME_LEN + 1 ];               // ifName of card
+
+  long  ifIndex;                                    // ifindex of card
+
+  long  CCAWatchdogTimerMax;
+  long  CCAWatchdogCountMax;
+  long  CCAWatchdogTimerMin;
+  long  CCAWatchdogCountMin;
+
+  long  haveCCAWatchdogTimerMax;
+  long  haveCCAWatchdogCountMax;
+  long  haveCCAWatchdogTimerMin;
+  long  haveCCAWatchdogCountMin;
+
+} nPi, *pi = &nPi;
+
+static avList_t piList;
+
+/****************************************************************************
+*                      dot11RegDomainsSupportedTable                        *
+****************************************************************************/
+static struct rdTbl_data {
+
+  char  UID       [ RD_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;                                    // ifindex of card
+  long  regDomainsSupportIndex;
+
+  long  regDomainsSupportValue;
+  long  haveRegDomainsSupportValue;
+
+} nRd, *rd = &nRd;
+
+static avList_t rdList;
+
+/****************************************************************************
+*                             dot11AntennasListTable                        *
+****************************************************************************/
+static struct alTbl_data {
+
+  char  UID       [ AL_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;                                    // ifindex of card
+  long  antennaListIndex;
+
+  long  supportedTxAntenna;
+  long  supportedRxAntenna;
+  long  diversitySelectionRx ;
+
+  long  haveSupportedTxAntenna;
+  long  haveSupportedRxAntenna;
+  long  haveDiversitySelectionRx ;
+
+} nAl, *al = &nAl;
+
+static avList_t alList;
+
+/****************************************************************************
+*                    dot11SupportedDataRatesTxTable                         *
+****************************************************************************/
+static struct rtTbl_data {
+
+  char  UID       [ RT_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;                                    // ifindex of card
+  long  supportedDataRatesTxIndex;
+
+  long  supportedDataRatesTxValue;
+  long  haveSupportedDataRatesTxValue;
+
+} nRt, *rt = &nRt;
+
+static avList_t rtList;
+
+/****************************************************************************
+*                    dot11SupportedDataRatesRxTable                         *
+****************************************************************************/
+static struct rrTbl_data {
+
+  char  UID       [ RR_UID_LEN + 1 ];
+  char  ifName    [ IFNAME_LEN + 1 ];
+
+  long  ifIndex;                                    // ifindex of card
+  long  supportedDataRatesRxIndex;
+
+  long  supportedDataRatesRxValue;
+  long  haveSupportedDataRatesRxValue;
+
+} nRr, *rr = &nRr;
+
+static avList_t rrList;
+
+/****************************************************************************
+*                       Wireless Extensions Structures                      *
+****************************************************************************/
+static long wepCurrentKey;
+static long haveWepCurrentKey;
+static struct wepTbl_data {
+
+  long len;
+  char key [ WEP_STR_LEN + 1 ];
+  long haveKey;
+
+} wep[4];
+
+/****************************************************************************
+*                                                                           *
+****************************************************************************/
+config_require(util_funcs)
+
+/* function prototypes */
+
+void   init_ieee802dot11 ( void );
+FindVarMethod var_ieee802dot11;
+FindVarMethod var_dot11StationConfigTable;
+FindVarMethod var_dot11AuthenticationAlgorithmsTable;
+FindVarMethod var_dot11WEPDefaultKeysTable;
+FindVarMethod var_dot11WEPKeyMappingsTable;
+FindVarMethod var_dot11PrivacyTable;
+FindVarMethod var_dot11OperationTable;
+FindVarMethod var_dot11CountersTable;
+FindVarMethod var_dot11GroupAddressesTable;
+FindVarMethod var_dot11ResourceInfoTable;
+FindVarMethod var_dot11PhyOperationTable;
+FindVarMethod var_dot11PhyAntennaTable;
+FindVarMethod var_dot11PhyTxPowerTable;
+FindVarMethod var_dot11PhyFHSSTable;
+FindVarMethod var_dot11PhyDSSSTable;
+FindVarMethod var_dot11PhyIRTable;
+FindVarMethod var_dot11RegDomainsSupportedTable;
+FindVarMethod var_dot11AntennasListTable;
+FindVarMethod var_dot11SupportedDataRatesTxTable;
+FindVarMethod var_dot11SupportedDataRatesRxTable;
+
+WriteMethod write_dot11StationID;
+WriteMethod write_dot11MediumOccupancyLimit;
+WriteMethod write_dot11CFPPeriod;
+WriteMethod write_dot11CFPMaxDuration;
+WriteMethod write_dot11AuthenticationResponseTimeOut;
+WriteMethod write_dot11PowerManagementMode;
+WriteMethod write_dot11DesiredSSID;
+WriteMethod write_dot11DesiredBSSType;
+WriteMethod write_dot11OperationalRateSet;
+WriteMethod write_dot11BeaconPeriod;
+WriteMethod write_dot11DTIMPeriod;
+WriteMethod write_dot11AssociationResponseTimeOut;
+WriteMethod write_dot11AuthenticationAlgorithmsEnable;
+WriteMethod write_dot11WEPDefaultKeyValue;
+WriteMethod write_dot11WEPKeyMappingAddress;
+WriteMethod write_dot11WEPKeyMappingWEPOn;
+WriteMethod write_dot11WEPKeyMappingValue;
+WriteMethod write_dot11WEPKeyMappingStatus;
+WriteMethod write_dot11PrivacyInvoked;
+WriteMethod write_dot11WEPDefaultKeyID;
+WriteMethod write_dot11WEPKeyMappingLength;
+WriteMethod write_dot11ExcludeUnencrypted;
+WriteMethod write_dot11RTSThreshold;
+WriteMethod write_dot11ShortRetryLimit;
+WriteMethod write_dot11LongRetryLimit;
+WriteMethod write_dot11FragmentationThreshold;
+WriteMethod write_dot11MaxTransmitMSDULifetime;
+WriteMethod write_dot11MaxReceiveLifetime;
+WriteMethod write_dot11Address;
+WriteMethod write_dot11GroupAddressesStatus;
+WriteMethod write_dot11CurrentRegDomain;
+WriteMethod write_dot11CurrentTxAntenna;
+WriteMethod write_dot11CurrentRxAntenna;
+WriteMethod write_dot11CurrentTxPowerLevel;
+WriteMethod write_dot11CurrentChannelNumber;
+WriteMethod write_dot11CurrentDwellTime;
+WriteMethod write_dot11CurrentSet;
+WriteMethod write_dot11CurrentPattern;
+WriteMethod write_dot11CurrentIndex;
+WriteMethod write_dot11CurrentChannel;
+WriteMethod write_dot11CurrentCCAMode;
+WriteMethod write_dot11EDThreshold;
+WriteMethod write_dot11CCAWatchdogTimerMax;
+WriteMethod write_dot11CCAWatchdogCountMax;
+WriteMethod write_dot11CCAWatchdogTimerMin;
+WriteMethod write_dot11CCAWatchdogCountMin;
+WriteMethod write_dot11SupportedTxAntenna;
+WriteMethod write_dot11SupportedRxAntenna;
+WriteMethod write_dot11DiversitySelectionRx;
+
+#endif /* _MIBGROUP_IEEE802DOT11_H */
--- /dev/null
+++ b/agent/mibgroup/iwlib.h
@@ -0,0 +1,502 @@
+/*
+ *	Wireless Tools
+ *
+ *		Jean II - HPLB 97->99 - HPL 99->02
+ *
+ * Common header for the Wireless Extension library...
+ *
+ * This file is released under the GPL license.
+ *     Copyright (c) 1997-2002 Jean Tourrilhes <jt@hpl.hp.com>
+ */
+
+#ifndef IWLIB_H
+#define IWLIB_H
+
+/*#include "CHANGELOG.h"*/
+
+/***************************** INCLUDES *****************************/
+
+/* Standard headers */
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <math.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <netdb.h>		/* gethostbyname, getnetbyname */
+#include <net/ethernet.h>	/* struct ether_addr */
+#include <sys/time.h>		/* struct timeval */
+#include <unistd.h>
+
+/* This is our header selection. Try to hide the mess and the misery :-(
+ * Don't look, you would go blind ;-) */
+
+#ifndef LINUX_VERSION_CODE
+#include <linux/version.h>
+#endif
+
+/* Kernel headers 2.4.X + Glibc 2.2 - Mandrake 8.0, Debian 2.3, RH 7.1
+ * Kernel headers 2.2.X + Glibc 2.2 - Slackware 8.0 */
+#if defined(__GLIBC__) \
+    && __GLIBC__ == 2 \
+    && __GLIBC_MINOR__ >= 2 \
+    && LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
+//#define GLIBC22_HEADERS
+#define GENERIC_HEADERS
+
+/* Kernel headers 2.4.X + Glibc 2.1 - Debian 2.2 upgraded, RH 7.0
+ * Kernel headers 2.2.X + Glibc 2.1 - Debian 2.2, RH 6.1 */
+#elif defined(__GLIBC__) \
+      && __GLIBC__ == 2 \
+      && __GLIBC_MINOR__ == 1 \
+      && LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
+//#define GLIBC_HEADERS
+#define GENERIC_HEADERS
+
+/* Kernel headers 2.2.X + Glibc 2.0 - Debian 2.1 */
+#elif defined(__GLIBC__) \
+      && __GLIBC__ == 2 \
+      && __GLIBC_MINOR__ == 0 \
+      && LINUX_VERSION_CODE >= KERNEL_VERSION(2,0,0) \
+      && LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
+#define GLIBC_HEADERS
+#define KLUDGE_HEADERS
+
+/* Note : is it really worth supporting kernel 2.0.X, knowing that
+ * we require WE v9, which is only available in 2.2.X and higher ?
+ * I guess one could use 2.0.x with an upgraded wireless.h... */
+
+/* Kernel headers 2.0.X + Glibc 2.0 - Debian 2.0, RH 5 */
+#elif defined(__GLIBC__) \
+      && __GLIBC__ == 2 \
+      && __GLIBC_MINOR__ == 0 \
+      && LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) \
+      && LINUX_VERSION_CODE >= KERNEL_VERSION(2,0,0)
+#define GLIBC_HEADERS
+
+/* Kernel headers 2.0.X + libc5 - old systems */
+#elif defined(_LINUX_C_LIB_VERSION_MAJOR) \
+      && _LINUX_C_LIB_VERSION_MAJOR == 5 \
+      && LINUX_VERSION_CODE >= KERNEL_VERSION(2,0,0) \
+      && LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
+#define LIBC5_HEADERS
+
+/* Unsupported combination */
+#else
+#error "Your kernel/libc combination is not supported"
+#endif
+
+#ifdef GENERIC_HEADERS 
+/* Proposed by Dr. Michael Rietz <rietz@mail.amps.de>, 27.3.2 */
+/* If this works for all, it might be more stable on the long term - Jean II */
+#include <net/if_arp.h>		/* For ARPHRD_ETHER */
+#include <sys/socket.h>		/* For AF_INET & struct sockaddr */
+#include <netinet/in.h>         /* For struct sockaddr_in */
+#include <netinet/if_ether.h>
+#endif /* GENERIC_HEADERS */    
+
+#ifdef GLIBC22_HEADERS 
+/* Added by Ross G. Miller <Ross_Miller@baylor.edu>, 3/28/01 */
+#include <linux/if_arp.h> 	/* For ARPHRD_ETHER */
+#include <linux/socket.h>	/* For AF_INET & struct sockaddr */
+#include <sys/socket.h>
+#endif /* GLIBC22_HEADERS */    
+
+#ifdef KLUDGE_HEADERS
+#include <socketbits.h>
+#endif	/* KLUDGE_HEADERS */
+
+#ifdef GLIBC_HEADERS
+#include <linux/if_arp.h>	/* For ARPHRD_ETHER */
+#include <linux/socket.h>	/* For AF_INET & struct sockaddr */
+#include <linux/in.h>		/* For struct sockaddr_in */
+#endif	/* KLUDGE_HEADERS || GLIBC_HEADERS */
+
+#ifdef LIBC5_HEADERS
+#include <sys/socket.h>		/* For AF_INET & struct sockaddr & socket() */
+#include <linux/if_arp.h>	/* For ARPHRD_ETHER */
+#include <linux/in.h>		/* For struct sockaddr_in */
+#endif	/* LIBC5_HEADERS */
+
+/* Those 3 headers were previously included in wireless.h */
+#include <linux/types.h>		/* for "caddr_t" et al		*/
+#include <linux/socket.h>		/* for "struct sockaddr" et al	*/
+#include <linux/if.h>			/* for IFNAMSIZ and co... */
+
+#ifdef WEXT_HEADER
+/* Private copy of Wireless extensions */
+#include WEXT_HEADER
+#else	/* !WEXT_HEADER */
+/* System wide Wireless extensions */
+#include <linux/wireless.h>
+#endif	/* !WEXT_HEADER */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/****************************** DEBUG ******************************/
+
+
+/************************ CONSTANTS & MACROS ************************/
+
+/* Paths */
+#define PROC_NET_WIRELESS	"/proc/net/wireless"
+#define PROC_NET_DEV		"/proc/net/dev"
+
+/* Some useful constants */
+#define KILO	1e3
+#define MEGA	1e6
+#define GIGA	1e9
+/* For doing log10/exp10 without libm */
+#define LOG10_MAGIC	1.25892541179
+
+/* Backward compatibility for Wireless Extension 9 */
+#ifndef IW_POWER_MODIFIER
+#define IW_POWER_MODIFIER	0x000F	/* Modify a parameter */
+#define IW_POWER_MIN		0x0001	/* Value is a minimum  */
+#define IW_POWER_MAX		0x0002	/* Value is a maximum */
+#define IW_POWER_RELATIVE	0x0004	/* Value is not in seconds/ms/us */
+#endif /* IW_POWER_MODIFIER */
+
+#ifndef IW_ENCODE_NOKEY
+#define IW_ENCODE_NOKEY         0x0800  /* Key is write only, so not here */
+#define IW_ENCODE_MODE		0xF000	/* Modes defined below */
+#endif /* IW_ENCODE_NOKEY */
+#ifndef IW_ENCODE_TEMP
+#define IW_ENCODE_TEMP		0x0400  /* Temporary key */
+#endif /* IW_ENCODE_TEMP */
+
+/* More backward compatibility */
+#ifndef SIOCSIWCOMMIT
+#define SIOCSIWCOMMIT	SIOCSIWNAME
+#endif /* SIOCSIWCOMMIT */
+
+/****************************** TYPES ******************************/
+
+/* Shortcuts */
+typedef struct iw_statistics	iwstats;
+typedef struct iw_range		iwrange;
+typedef struct iw_param		iwparam;
+typedef struct iw_freq		iwfreq;
+typedef struct iw_quality	iwqual;
+typedef struct iw_priv_args	iwprivargs;
+typedef struct sockaddr		sockaddr;
+
+/* Structure for storing all wireless information for each device
+ * This is pretty exhaustive... */
+typedef struct wireless_info
+{
+  char		name[IFNAMSIZ + 1];	/* Wireless/protocol name */
+  int		has_nwid;
+  iwparam	nwid;			/* Network ID */
+  int		has_freq;
+  double	freq;			/* Frequency/channel */
+  int		has_sens;
+  iwparam	sens;			/* sensitivity */
+  int		has_key;
+  unsigned char	key[IW_ENCODING_TOKEN_MAX];	/* Encoding key used */
+  int		key_size;		/* Number of bytes */
+  int		key_flags;		/* Various flags */
+  int		has_essid;
+  int		essid_on;
+  char		essid[IW_ESSID_MAX_SIZE + 1];	/* ESSID (extended network) */
+  int		has_nickname;
+  char		nickname[IW_ESSID_MAX_SIZE + 1]; /* NickName */
+  int		has_ap_addr;
+  sockaddr	ap_addr;		/* Access point address */
+  int		has_bitrate;
+  iwparam	bitrate;		/* Bit rate in bps */
+  int		has_rts;
+  iwparam	rts;			/* RTS threshold in bytes */
+  int		has_frag;
+  iwparam	frag;			/* Fragmentation threshold in bytes */
+  int		has_mode;
+  int		mode;			/* Operation mode */
+  int		has_power;
+  iwparam	power;			/* Power management parameters */
+  int		has_txpower;
+  iwparam	txpower;		/* Transmit Power in dBm */
+  int		has_retry;
+  iwparam	retry;			/* Retry limit or lifetime */
+
+  /* Stats */
+  iwstats	stats;
+  int		has_stats;
+  iwrange	range;
+  int		has_range;
+} wireless_info;
+
+/* Structure for storing all wireless information for each device
+ * This is a cut down version of the one above, containing only
+ * the things *truly* needed to configure a card.
+ * Don't add other junk, I'll remove it... */
+typedef struct wireless_config
+{
+  char		name[IFNAMSIZ + 1];	/* Wireless/protocol name */
+  int		has_nwid;
+  iwparam	nwid;			/* Network ID */
+  int		has_freq;
+  double	freq;			/* Frequency/channel */
+  int		has_key;
+  unsigned char	key[IW_ENCODING_TOKEN_MAX];	/* Encoding key used */
+  int		key_size;		/* Number of bytes */
+  int		key_flags;		/* Various flags */
+  int		has_essid;
+  int		essid_on;
+  char		essid[IW_ESSID_MAX_SIZE + 1];	/* ESSID (extended network) */
+  int		has_mode;
+  int		mode;			/* Operation mode */
+} wireless_config;
+
+typedef struct stream_descr
+{
+  char *	end;		/* End of the stream */
+  char *	current;	/* Current event in stream of events */
+  char *	value;		/* Current value in event */
+} stream_descr;
+
+/* Prototype for handling display of each single interface on the
+ * system - see iw_enum_devices() */
+typedef int (*iw_enum_handler)(int	skfd,
+			       char *	ifname,
+			       char *	args[],
+			       int	count);
+
+/**************************** PROTOTYPES ****************************/
+/*
+ * All the functions in iwcommon.c
+ */
+
+/* ---------------------- SOCKET SUBROUTINES -----------------------*/
+int
+	iw_sockets_open(void);
+void
+	iw_enum_devices(int		skfd,
+			iw_enum_handler fn,
+			char *		args[],
+			int		count);
+/* --------------------- WIRELESS SUBROUTINES ----------------------*/
+int
+	iw_get_range_info(int		skfd,
+			  char *	ifname,
+			  iwrange *	range);
+int
+	iw_print_version_info(char *	toolname);
+int
+	iw_get_priv_info(int		skfd,
+			 char *		ifname,
+			 iwprivargs *	priv,
+			 int		maxpriv);
+int
+	iw_get_basic_config(int			skfd,
+			    char *		ifname,
+			    wireless_config *	info);
+int
+	iw_set_basic_config(int			skfd,
+			    char *		ifname,
+			    wireless_config *	info);
+/* --------------------- PROTOCOL SUBROUTINES --------------------- */
+int
+	iw_protocol_compare(char *	protocol1,
+			    char *	protocol2);
+/* -------------------- FREQUENCY SUBROUTINES --------------------- */
+void
+	iw_float2freq(double	in,
+		   iwfreq *	out);
+double
+	iw_freq2float(iwfreq *	in);
+void
+	iw_print_freq(char *	buffer,
+		      double	freq);
+int
+	iw_freq_to_channel(double		freq,
+			   struct iw_range *	range);
+void
+	iw_print_bitrate(char *	buffer,
+			 int	bitrate);
+/* ---------------------- POWER SUBROUTINES ----------------------- */
+int
+	iw_dbm2mwatt(int	in);
+int
+	iw_mwatt2dbm(int	in);
+/* -------------------- STATISTICS SUBROUTINES -------------------- */
+int
+	iw_get_stats(int	skfd,
+		     char *	ifname,
+		     iwstats *	stats);
+void
+	iw_print_stats(char *		buffer,
+		       iwqual *		qual,
+		       iwrange *	range,
+		       int		has_range);
+/* --------------------- ENCODING SUBROUTINES --------------------- */
+void
+	iw_print_key(char *		buffer,
+		     unsigned char *	key,
+		     int		key_size,
+		     int		key_flags);
+int
+	iw_in_key(char *		input,
+		  unsigned char *	key);
+int
+	iw_in_key_full(int		skfd,
+		       char *		ifname,
+		       char *		input,
+		       unsigned char *	key,
+		       __u16 *		flags);
+/* ----------------- POWER MANAGEMENT SUBROUTINES ----------------- */
+void
+	iw_print_pm_value(char *	buffer,
+			  int		value,
+			  int		flags);
+void
+	iw_print_pm_mode(char *		buffer,
+			 int		flags);
+/* --------------- RETRY LIMIT/LIFETIME SUBROUTINES --------------- */
+#if WIRELESS_EXT > 10
+void
+	iw_print_retry_value(char *	buffer,
+			     int	value,
+			     int	flags);
+#endif
+/* ----------------------- TIME SUBROUTINES ----------------------- */
+void
+	iw_print_timeval(char *			buffer,
+			 const struct timeval *	time);
+/* --------------------- ADDRESS SUBROUTINES ---------------------- */
+int
+	iw_check_mac_addr_type(int	skfd,
+			       char *	ifname);
+int
+	iw_check_if_addr_type(int	skfd,
+			      char *	ifname);
+#if 0
+int
+	iw_check_addr_type(int		skfd,
+			   char *	ifname);
+#endif
+void
+	iw_ether_ntop(const struct ether_addr* eth, char* buf);
+char*
+	iw_ether_ntoa(const struct ether_addr* eth);
+int
+	iw_ether_aton(const char* bufp, struct ether_addr* eth);
+int
+	iw_in_inet(char *bufp, struct sockaddr *sap);
+int
+	iw_in_addr(int			skfd,
+		   char *		ifname,
+		   char *		bufp,
+		   struct sockaddr *	sap);
+/* ----------------------- MISC SUBROUTINES ------------------------ */
+int
+	iw_get_priv_size(int		args);
+
+#if WIRELESS_EXT > 13
+/* ---------------------- EVENT SUBROUTINES ---------------------- */
+void
+	iw_init_event_stream(struct stream_descr *	stream,
+			     char *			data,
+			     int			len);
+int
+	iw_extract_event_stream(struct stream_descr *	stream,
+				struct iw_event *	iwe);
+#endif /* WIRELESS_EXT > 13 */
+
+/**************************** VARIABLES ****************************/
+
+extern const char * const	iw_operation_mode[];
+#define IW_NUM_OPER_MODE	7
+
+/************************* INLINE FUNTIONS *************************/
+/*
+ * Functions that are so simple that it's more efficient inlining them
+ */
+
+/*
+ * Note : I've defined wrapper for the ioctl request so that
+ * it will be easier to migrate to other kernel API if needed
+ */
+
+/*------------------------------------------------------------------*/
+/*
+ * Wrapper to push some Wireless Parameter in the driver
+ */
+static inline int
+iw_set_ext(int			skfd,		/* Socket to the kernel */
+	   char *		ifname,		/* Device name */
+	   int			request,	/* WE ID */
+	   struct iwreq *	pwrq)		/* Fixed part of the request */
+{
+  /* Set device name */
+  strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
+  /* Do the request */
+  return(ioctl(skfd, request, pwrq));
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Wrapper to extract some Wireless Parameter out of the driver
+ */
+static inline int
+iw_get_ext(int			skfd,		/* Socket to the kernel */
+	   char *		ifname,		/* Device name */
+	   int			request,	/* WE ID */
+	   struct iwreq *	pwrq)		/* Fixed part of the request */
+{
+  /* Set device name */
+  strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
+  /* Do the request */
+  return(ioctl(skfd, request, pwrq));
+}
+
+/*------------------------------------------------------------------*/
+/* Backwards compatibility
+ * Actually, those form are much easier to use when dealing with
+ * struct sockaddr... */
+static inline char*
+iw_pr_ether(char* bufp, const unsigned char* addr)
+{
+  iw_ether_ntop((const struct ether_addr *) addr, bufp);
+  return bufp;
+}
+/* Backwards compatibility */
+static inline int
+iw_in_ether(const char *bufp, struct sockaddr *sap)
+{
+  sap->sa_family = ARPHRD_ETHER;
+  return iw_ether_aton(bufp, (struct ether_addr *) sap->sa_data) ? 0 : -1;
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Create an Ethernet broadcast address
+ */
+static inline void
+iw_broad_ether(struct sockaddr *sap)
+{
+  sap->sa_family = ARPHRD_ETHER;
+  memset((char *) sap->sa_data, 0xFF, ETH_ALEN);
+}
+
+/*------------------------------------------------------------------*/
+/*
+ * Create an Ethernet NULL address
+ */
+static inline void
+iw_null_ether(struct sockaddr *sap)
+{
+  sap->sa_family = ARPHRD_ETHER;
+  memset((char *) sap->sa_data, 0x00, ETH_ALEN);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* IWLIB_H */