test/dumps/netsnmp/mau-mib-mgr-stub.c

   1 /*
   2  * This C file has been generated by smidump 0.4.5.
   3  * It is intended to be used with the NET-SNMP library.
   4  *
   5  * This C file is derived from the MAU-MIB module.
   6  *
   7  * $Id: mau-mib-mgr-stub.c 7690 2008-02-05 15:31:35Z schoenw $
   8  */
   9
  10 #include <stdlib.h>
  11
  12 #include <ucd-snmp/asn1.h>
  13 #include <ucd-snmp/snmp.h>
  14 #include <ucd-snmp/snmp_api.h>
  15 #include <ucd-snmp/snmp_client.h>
  16
  17 #include "mau-mib.h"
  18
  19 static oid rpMauGroupIndex[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 1};
  20 static oid rpMauPortIndex[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 2};
  21 static oid rpMauIndex[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 3};
  22 static oid rpMauType[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 4};
  23 static oid rpMauStatus[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 5};
  24 static oid rpMauMediaAvailable[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 6};
  25 static oid rpMauMediaAvailableStateExits[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 7};
  26 static oid rpMauJabberState[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 8};
  27 static oid rpMauJabberingStateEnters[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 9};
  28 static oid rpMauFalseCarriers[] = {1, 3, 6, 1, 2, 1, 26, 1, 1, 1, 10};
  29 static oid rpJackIndex[] = {1, 3, 6, 1, 2, 1, 26, 1, 2, 1, 1};
  30 static oid rpJackType[] = {1, 3, 6, 1, 2, 1, 26, 1, 2, 1, 2};
  31 static oid ifMauIfIndex[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 1};
  32 static oid ifMauIndex[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 2};
  33 static oid ifMauType[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 3};
  34 static oid ifMauStatus[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 4};
  35 static oid ifMauMediaAvailable[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 5};
  36 static oid ifMauMediaAvailableStateExits[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 6};
  37 static oid ifMauJabberState[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 7};
  38 static oid ifMauJabberingStateEnters[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 8};
  39 static oid ifMauFalseCarriers[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 9};
  40 static oid ifMauTypeList[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 10};
  41 static oid ifMauDefaultType[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 11};
  42 static oid ifMauAutoNegSupported[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 12};
  43 static oid ifMauTypeListBits[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 13};
  44 static oid ifMauHCFalseCarriers[] = {1, 3, 6, 1, 2, 1, 26, 2, 1, 1, 14};
  45 static oid ifJackIndex[] = {1, 3, 6, 1, 2, 1, 26, 2, 2, 1, 1};
  46 static oid ifJackType[] = {1, 3, 6, 1, 2, 1, 26, 2, 2, 1, 2};
  47 static oid broadMauIfIndex[] = {1, 3, 6, 1, 2, 1, 26, 3, 1, 1, 1};
  48 static oid broadMauIndex[] = {1, 3, 6, 1, 2, 1, 26, 3, 1, 1, 2};
  49 static oid broadMauXmtRcvSplitType[] = {1, 3, 6, 1, 2, 1, 26, 3, 1, 1, 3};
  50 static oid broadMauXmtCarrierFreq[] = {1, 3, 6, 1, 2, 1, 26, 3, 1, 1, 4};
  51 static oid broadMauTranslationFreq[] = {1, 3, 6, 1, 2, 1, 26, 3, 1, 1, 5};
  52 static oid ifMauAutoNegAdminStatus[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 1};
  53 static oid ifMauAutoNegRemoteSignaling[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 2};
  54 static oid ifMauAutoNegConfig[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 4};
  55 static oid ifMauAutoNegCapability[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 5};
  56 static oid ifMauAutoNegCapAdvertised[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 6};
  57 static oid ifMauAutoNegCapReceived[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 7};
  58 static oid ifMauAutoNegRestart[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 8};
  59 static oid ifMauAutoNegCapabilityBits[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 9};
  60 static oid ifMauAutoNegCapAdvertisedBits[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 10};
  61 static oid ifMauAutoNegCapReceivedBits[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 11};
  62 static oid ifMauAutoNegRemoteFaultAdvertised[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 12};
  63 static oid ifMauAutoNegRemoteFaultReceived[] = {1, 3, 6, 1, 2, 1, 26, 5, 1, 1, 13};
  64
  65 int mau_mib_mgr_get_rpMauEntry(struct snmp_session *s, rpMauEntry_t **rpMauEntry)
  66 {
  67     struct snmp_session *peer;
  68     struct snmp_pdu *request, *response;
  69     struct variable_list *vars;
  70     int status;
  71
  72     request = snmp_pdu_create(SNMP_MSG_GETNEXT);
  73     snmp_add_null_var(request, rpMauGroupIndex, sizeof(rpMauGroupIndex)/sizeof(oid));
  74     snmp_add_null_var(request, rpMauPortIndex, sizeof(rpMauPortIndex)/sizeof(oid));
  75     snmp_add_null_var(request, rpMauIndex, sizeof(rpMauIndex)/sizeof(oid));
  76     snmp_add_null_var(request, rpMauType, sizeof(rpMauType)/sizeof(oid));
  77     snmp_add_null_var(request, rpMauStatus, sizeof(rpMauStatus)/sizeof(oid));
  78     snmp_add_null_var(request, rpMauMediaAvailable, sizeof(rpMauMediaAvailable)/sizeof(oid));
  79     snmp_add_null_var(request, rpMauMediaAvailableStateExits, sizeof(rpMauMediaAvailableStateExits)/sizeof(oid));
  80     snmp_add_null_var(request, rpMauJabberState, sizeof(rpMauJabberState)/sizeof(oid));
  81     snmp_add_null_var(request, rpMauJabberingStateEnters, sizeof(rpMauJabberingStateEnters)/sizeof(oid));
  82     snmp_add_null_var(request, rpMauFalseCarriers, sizeof(rpMauFalseCarriers)/sizeof(oid));
  83
  84     peer = snmp_open(s);
  85     if (!peer) {
  86         snmp_free_pdu(request);
  87         return -1;
  88     }
  89
  90     status = snmp_synch_response(peer, request, &response);
  91     if (status != STAT_SUCCESS) {
  92         if (response) snmp_free_pdu(response);
  93         snmp_close(peer);
  94         return -2;
  95     }
  96
  97     *rpMauEntry = (rpMauEntry_t *) malloc(sizeof(rpMauEntry_t));
  98     if (! *rpMauEntry) {
  99         if (response) snmp_free_pdu(response);
 100         snmp_close(peer);
 101         return -4;
 102     }
 103
 104     for (vars = response->variables; vars; vars = vars->next_variable) {
 105         if (vars->name_length > sizeof(rpMauGroupIndex)/sizeof(oid)
 106             && memcmp(vars->name, rpMauGroupIndex, sizeof(rpMauGroupIndex)) == 0) {
 107             (*rpMauEntry)->__rpMauGroupIndex = *vars->val.integer;
 108             (*rpMauEntry)->rpMauGroupIndex = &((*rpMauEntry)->__rpMauGroupIndex);
 109         }
 110         if (vars->name_length > sizeof(rpMauPortIndex)/sizeof(oid)
 111             && memcmp(vars->name, rpMauPortIndex, sizeof(rpMauPortIndex)) == 0) {
 112             (*rpMauEntry)->__rpMauPortIndex = *vars->val.integer;
 113             (*rpMauEntry)->rpMauPortIndex = &((*rpMauEntry)->__rpMauPortIndex);
 114         }
 115         if (vars->name_length > sizeof(rpMauIndex)/sizeof(oid)
 116             && memcmp(vars->name, rpMauIndex, sizeof(rpMauIndex)) == 0) {
 117             (*rpMauEntry)->__rpMauIndex = *vars->val.integer;
 118             (*rpMauEntry)->rpMauIndex = &((*rpMauEntry)->__rpMauIndex);
 119         }
 120         if (vars->name_length > sizeof(rpMauType)/sizeof(oid)
 121             && memcmp(vars->name, rpMauType, sizeof(rpMauType)) == 0) {
 122         }
 123         if (vars->name_length > sizeof(rpMauStatus)/sizeof(oid)
 124             && memcmp(vars->name, rpMauStatus, sizeof(rpMauStatus)) == 0) {
 125             (*rpMauEntry)->__rpMauStatus = *vars->val.integer;
 126             (*rpMauEntry)->rpMauStatus = &((*rpMauEntry)->__rpMauStatus);
 127         }
 128         if (vars->name_length > sizeof(rpMauMediaAvailable)/sizeof(oid)
 129             && memcmp(vars->name, rpMauMediaAvailable, sizeof(rpMauMediaAvailable)) == 0) {
 130             (*rpMauEntry)->__rpMauMediaAvailable = *vars->val.integer;
 131             (*rpMauEntry)->rpMauMediaAvailable = &((*rpMauEntry)->__rpMauMediaAvailable);
 132         }
 133         if (vars->name_length > sizeof(rpMauMediaAvailableStateExits)/sizeof(oid)
 134             && memcmp(vars->name, rpMauMediaAvailableStateExits, sizeof(rpMauMediaAvailableStateExits)) == 0) {
 135             (*rpMauEntry)->__rpMauMediaAvailableStateExits = *vars->val.integer;
 136             (*rpMauEntry)->rpMauMediaAvailableStateExits = &((*rpMauEntry)->__rpMauMediaAvailableStateExits);
 137         }
 138         if (vars->name_length > sizeof(rpMauJabberState)/sizeof(oid)
 139             && memcmp(vars->name, rpMauJabberState, sizeof(rpMauJabberState)) == 0) {
 140             (*rpMauEntry)->__rpMauJabberState = *vars->val.integer;
 141             (*rpMauEntry)->rpMauJabberState = &((*rpMauEntry)->__rpMauJabberState);
 142         }
 143         if (vars->name_length > sizeof(rpMauJabberingStateEnters)/sizeof(oid)
 144             && memcmp(vars->name, rpMauJabberingStateEnters, sizeof(rpMauJabberingStateEnters)) == 0) {
 145             (*rpMauEntry)->__rpMauJabberingStateEnters = *vars->val.integer;
 146             (*rpMauEntry)->rpMauJabberingStateEnters = &((*rpMauEntry)->__rpMauJabberingStateEnters);
 147         }
 148         if (vars->name_length > sizeof(rpMauFalseCarriers)/sizeof(oid)
 149             && memcmp(vars->name, rpMauFalseCarriers, sizeof(rpMauFalseCarriers)) == 0) {
 150             (*rpMauEntry)->__rpMauFalseCarriers = *vars->val.integer;
 151             (*rpMauEntry)->rpMauFalseCarriers = &((*rpMauEntry)->__rpMauFalseCarriers);
 152         }
 153     }
 154
 155     if (response) snmp_free_pdu(response);
 156
 157     if (snmp_close(peer) == 0) {
 158         return -5;
 159     }
 160
 161     return 0;
 162 }
 163
 164 int mau_mib_mgr_get_rpJackEntry(struct snmp_session *s, rpJackEntry_t **rpJackEntry)
 165 {
 166     struct snmp_session *peer;
 167     struct snmp_pdu *request, *response;
 168     struct variable_list *vars;
 169     int status;
 170
 171     request = snmp_pdu_create(SNMP_MSG_GETNEXT);
 172     snmp_add_null_var(request, rpJackType, sizeof(rpJackType)/sizeof(oid));
 173
 174     peer = snmp_open(s);
 175     if (!peer) {
 176         snmp_free_pdu(request);
 177         return -1;
 178     }
 179
 180     status = snmp_synch_response(peer, request, &response);
 181     if (status != STAT_SUCCESS) {
 182         if (response) snmp_free_pdu(response);
 183         snmp_close(peer);
 184         return -2;
 185     }
 186
 187     *rpJackEntry = (rpJackEntry_t *) malloc(sizeof(rpJackEntry_t));
 188     if (! *rpJackEntry) {
 189         if (response) snmp_free_pdu(response);
 190         snmp_close(peer);
 191         return -4;
 192     }
 193
 194     for (vars = response->variables; vars; vars = vars->next_variable) {
 195         if (vars->name_length > sizeof(rpJackType)/sizeof(oid)
 196             && memcmp(vars->name, rpJackType, sizeof(rpJackType)) == 0) {
 197             (*rpJackEntry)->__rpJackType = *vars->val.integer;
 198             (*rpJackEntry)->rpJackType = &((*rpJackEntry)->__rpJackType);
 199         }
 200     }
 201
 202     if (response) snmp_free_pdu(response);
 203
 204     if (snmp_close(peer) == 0) {
 205         return -5;
 206     }
 207
 208     return 0;
 209 }
 210
 211 int mau_mib_mgr_get_ifMauEntry(struct snmp_session *s, ifMauEntry_t **ifMauEntry)
 212 {
 213     struct snmp_session *peer;
 214     struct snmp_pdu *request, *response;
 215     struct variable_list *vars;
 216     int status;
 217
 218     request = snmp_pdu_create(SNMP_MSG_GETNEXT);
 219     snmp_add_null_var(request, ifMauIfIndex, sizeof(ifMauIfIndex)/sizeof(oid));
 220     snmp_add_null_var(request, ifMauIndex, sizeof(ifMauIndex)/sizeof(oid));
 221     snmp_add_null_var(request, ifMauType, sizeof(ifMauType)/sizeof(oid));
 222     snmp_add_null_var(request, ifMauStatus, sizeof(ifMauStatus)/sizeof(oid));
 223     snmp_add_null_var(request, ifMauMediaAvailable, sizeof(ifMauMediaAvailable)/sizeof(oid));
 224     snmp_add_null_var(request, ifMauMediaAvailableStateExits, sizeof(ifMauMediaAvailableStateExits)/sizeof(oid));
 225     snmp_add_null_var(request, ifMauJabberState, sizeof(ifMauJabberState)/sizeof(oid));
 226     snmp_add_null_var(request, ifMauJabberingStateEnters, sizeof(ifMauJabberingStateEnters)/sizeof(oid));
 227     snmp_add_null_var(request, ifMauFalseCarriers, sizeof(ifMauFalseCarriers)/sizeof(oid));
 228     snmp_add_null_var(request, ifMauTypeList, sizeof(ifMauTypeList)/sizeof(oid));
 229     snmp_add_null_var(request, ifMauDefaultType, sizeof(ifMauDefaultType)/sizeof(oid));
 230     snmp_add_null_var(request, ifMauAutoNegSupported, sizeof(ifMauAutoNegSupported)/sizeof(oid));
 231     snmp_add_null_var(request, ifMauTypeListBits, sizeof(ifMauTypeListBits)/sizeof(oid));
 232     snmp_add_null_var(request, ifMauHCFalseCarriers, sizeof(ifMauHCFalseCarriers)/sizeof(oid));
 233
 234     peer = snmp_open(s);
 235     if (!peer) {
 236         snmp_free_pdu(request);
 237         return -1;
 238     }
 239
 240     status = snmp_synch_response(peer, request, &response);
 241     if (status != STAT_SUCCESS) {
 242         if (response) snmp_free_pdu(response);
 243         snmp_close(peer);
 244         return -2;
 245     }
 246
 247     *ifMauEntry = (ifMauEntry_t *) malloc(sizeof(ifMauEntry_t));
 248     if (! *ifMauEntry) {
 249         if (response) snmp_free_pdu(response);
 250         snmp_close(peer);
 251         return -4;
 252     }
 253
 254     for (vars = response->variables; vars; vars = vars->next_variable) {
 255         if (vars->name_length > sizeof(ifMauIfIndex)/sizeof(oid)
 256             && memcmp(vars->name, ifMauIfIndex, sizeof(ifMauIfIndex)) == 0) {
 257             (*ifMauEntry)->__ifMauIfIndex = *vars->val.integer;
 258             (*ifMauEntry)->ifMauIfIndex = &((*ifMauEntry)->__ifMauIfIndex);
 259         }
 260         if (vars->name_length > sizeof(ifMauIndex)/sizeof(oid)
 261             && memcmp(vars->name, ifMauIndex, sizeof(ifMauIndex)) == 0) {
 262             (*ifMauEntry)->__ifMauIndex = *vars->val.integer;
 263             (*ifMauEntry)->ifMauIndex = &((*ifMauEntry)->__ifMauIndex);
 264         }
 265         if (vars->name_length > sizeof(ifMauType)/sizeof(oid)
 266             && memcmp(vars->name, ifMauType, sizeof(ifMauType)) == 0) {
 267         }
 268         if (vars->name_length > sizeof(ifMauStatus)/sizeof(oid)
 269             && memcmp(vars->name, ifMauStatus, sizeof(ifMauStatus)) == 0) {
 270             (*ifMauEntry)->__ifMauStatus = *vars->val.integer;
 271             (*ifMauEntry)->ifMauStatus = &((*ifMauEntry)->__ifMauStatus);
 272         }
 273         if (vars->name_length > sizeof(ifMauMediaAvailable)/sizeof(oid)
 274             && memcmp(vars->name, ifMauMediaAvailable, sizeof(ifMauMediaAvailable)) == 0) {
 275             (*ifMauEntry)->__ifMauMediaAvailable = *vars->val.integer;
 276             (*ifMauEntry)->ifMauMediaAvailable = &((*ifMauEntry)->__ifMauMediaAvailable);
 277         }
 278         if (vars->name_length > sizeof(ifMauMediaAvailableStateExits)/sizeof(oid)
 279             && memcmp(vars->name, ifMauMediaAvailableStateExits, sizeof(ifMauMediaAvailableStateExits)) == 0) {
 280             (*ifMauEntry)->__ifMauMediaAvailableStateExits = *vars->val.integer;
 281             (*ifMauEntry)->ifMauMediaAvailableStateExits = &((*ifMauEntry)->__ifMauMediaAvailableStateExits);
 282         }
 283         if (vars->name_length > sizeof(ifMauJabberState)/sizeof(oid)
 284             && memcmp(vars->name, ifMauJabberState, sizeof(ifMauJabberState)) == 0) {
 285             (*ifMauEntry)->__ifMauJabberState = *vars->val.integer;
 286             (*ifMauEntry)->ifMauJabberState = &((*ifMauEntry)->__ifMauJabberState);
 287         }
 288         if (vars->name_length > sizeof(ifMauJabberingStateEnters)/sizeof(oid)
 289             && memcmp(vars->name, ifMauJabberingStateEnters, sizeof(ifMauJabberingStateEnters)) == 0) {
 290             (*ifMauEntry)->__ifMauJabberingStateEnters = *vars->val.integer;
 291             (*ifMauEntry)->ifMauJabberingStateEnters = &((*ifMauEntry)->__ifMauJabberingStateEnters);
 292         }
 293         if (vars->name_length > sizeof(ifMauFalseCarriers)/sizeof(oid)
 294             && memcmp(vars->name, ifMauFalseCarriers, sizeof(ifMauFalseCarriers)) == 0) {
 295             (*ifMauEntry)->__ifMauFalseCarriers = *vars->val.integer;
 296             (*ifMauEntry)->ifMauFalseCarriers = &((*ifMauEntry)->__ifMauFalseCarriers);
 297         }
 298         if (vars->name_length > sizeof(ifMauTypeList)/sizeof(oid)
 299             && memcmp(vars->name, ifMauTypeList, sizeof(ifMauTypeList)) == 0) {
 300             (*ifMauEntry)->__ifMauTypeList = *vars->val.integer;
 301             (*ifMauEntry)->ifMauTypeList = &((*ifMauEntry)->__ifMauTypeList);
 302         }
 303         if (vars->name_length > sizeof(ifMauDefaultType)/sizeof(oid)
 304             && memcmp(vars->name, ifMauDefaultType, sizeof(ifMauDefaultType)) == 0) {
 305         }
 306         if (vars->name_length > sizeof(ifMauAutoNegSupported)/sizeof(oid)
 307             && memcmp(vars->name, ifMauAutoNegSupported, sizeof(ifMauAutoNegSupported)) == 0) {
 308             (*ifMauEntry)->__ifMauAutoNegSupported = *vars->val.integer;
 309             (*ifMauEntry)->ifMauAutoNegSupported = &((*ifMauEntry)->__ifMauAutoNegSupported);
 310         }
 311         if (vars->name_length > sizeof(ifMauTypeListBits)/sizeof(oid)
 312             && memcmp(vars->name, ifMauTypeListBits, sizeof(ifMauTypeListBits)) == 0) {
 313             memcpy((*ifMauEntry)->__ifMauTypeListBits, vars->val.string, vars->val_len);
 314             (*ifMauEntry)->_ifMauTypeListBitsLength = vars->val_len;
 315             (*ifMauEntry)->ifMauTypeListBits = (*ifMauEntry)->__ifMauTypeListBits;
 316         }
 317         if (vars->name_length > sizeof(ifMauHCFalseCarriers)/sizeof(oid)
 318             && memcmp(vars->name, ifMauHCFalseCarriers, sizeof(ifMauHCFalseCarriers)) == 0) {
 319         }
 320     }
 321
 322     if (response) snmp_free_pdu(response);
 323
 324     if (snmp_close(peer) == 0) {
 325         return -5;
 326     }
 327
 328     return 0;
 329 }
 330
 331 int mau_mib_mgr_get_ifJackEntry(struct snmp_session *s, ifJackEntry_t **ifJackEntry)
 332 {
 333     struct snmp_session *peer;
 334     struct snmp_pdu *request, *response;
 335     struct variable_list *vars;
 336     int status;
 337
 338     request = snmp_pdu_create(SNMP_MSG_GETNEXT);
 339     snmp_add_null_var(request, ifJackType, sizeof(ifJackType)/sizeof(oid));
 340
 341     peer = snmp_open(s);
 342     if (!peer) {
 343         snmp_free_pdu(request);
 344         return -1;
 345     }
 346
 347     status = snmp_synch_response(peer, request, &response);
 348     if (status != STAT_SUCCESS) {
 349         if (response) snmp_free_pdu(response);
 350         snmp_close(peer);
 351         return -2;
 352     }
 353
 354     *ifJackEntry = (ifJackEntry_t *) malloc(sizeof(ifJackEntry_t));
 355     if (! *ifJackEntry) {
 356         if (response) snmp_free_pdu(response);
 357         snmp_close(peer);
 358         return -4;
 359     }
 360
 361     for (vars = response->variables; vars; vars = vars->next_variable) {
 362         if (vars->name_length > sizeof(ifJackType)/sizeof(oid)
 363             && memcmp(vars->name, ifJackType, sizeof(ifJackType)) == 0) {
 364             (*ifJackEntry)->__ifJackType = *vars->val.integer;
 365             (*ifJackEntry)->ifJackType = &((*ifJackEntry)->__ifJackType);
 366         }
 367     }
 368
 369     if (response) snmp_free_pdu(response);
 370
 371     if (snmp_close(peer) == 0) {
 372         return -5;
 373     }
 374
 375     return 0;
 376 }
 377
 378 int mau_mib_mgr_get_broadMauBasicEntry(struct snmp_session *s, broadMauBasicEntry_t **broadMauBasicEntry)
 379 {
 380     struct snmp_session *peer;
 381     struct snmp_pdu *request, *response;
 382     struct variable_list *vars;
 383     int status;
 384
 385     request = snmp_pdu_create(SNMP_MSG_GETNEXT);
 386     snmp_add_null_var(request, broadMauIfIndex, sizeof(broadMauIfIndex)/sizeof(oid));
 387     snmp_add_null_var(request, broadMauIndex, sizeof(broadMauIndex)/sizeof(oid));
 388     snmp_add_null_var(request, broadMauXmtRcvSplitType, sizeof(broadMauXmtRcvSplitType)/sizeof(oid));
 389     snmp_add_null_var(request, broadMauXmtCarrierFreq, sizeof(broadMauXmtCarrierFreq)/sizeof(oid));
 390     snmp_add_null_var(request, broadMauTranslationFreq, sizeof(broadMauTranslationFreq)/sizeof(oid));
 391
 392     peer = snmp_open(s);
 393     if (!peer) {
 394         snmp_free_pdu(request);
 395         return -1;
 396     }
 397
 398     status = snmp_synch_response(peer, request, &response);
 399     if (status != STAT_SUCCESS) {
 400         if (response) snmp_free_pdu(response);
 401         snmp_close(peer);
 402         return -2;
 403     }
 404
 405     *broadMauBasicEntry = (broadMauBasicEntry_t *) malloc(sizeof(broadMauBasicEntry_t));
 406     if (! *broadMauBasicEntry) {
 407         if (response) snmp_free_pdu(response);
 408         snmp_close(peer);
 409         return -4;
 410     }
 411
 412     for (vars = response->variables; vars; vars = vars->next_variable) {
 413         if (vars->name_length > sizeof(broadMauIfIndex)/sizeof(oid)
 414             && memcmp(vars->name, broadMauIfIndex, sizeof(broadMauIfIndex)) == 0) {
 415             (*broadMauBasicEntry)->__broadMauIfIndex = *vars->val.integer;
 416             (*broadMauBasicEntry)->broadMauIfIndex = &((*broadMauBasicEntry)->__broadMauIfIndex);
 417         }
 418         if (vars->name_length > sizeof(broadMauIndex)/sizeof(oid)
 419             && memcmp(vars->name, broadMauIndex, sizeof(broadMauIndex)) == 0) {
 420             (*broadMauBasicEntry)->__broadMauIndex = *vars->val.integer;
 421             (*broadMauBasicEntry)->broadMauIndex = &((*broadMauBasicEntry)->__broadMauIndex);
 422         }
 423         if (vars->name_length > sizeof(broadMauXmtRcvSplitType)/sizeof(oid)
 424             && memcmp(vars->name, broadMauXmtRcvSplitType, sizeof(broadMauXmtRcvSplitType)) == 0) {
 425             (*broadMauBasicEntry)->__broadMauXmtRcvSplitType = *vars->val.integer;
 426             (*broadMauBasicEntry)->broadMauXmtRcvSplitType = &((*broadMauBasicEntry)->__broadMauXmtRcvSplitType);
 427         }
 428         if (vars->name_length > sizeof(broadMauXmtCarrierFreq)/sizeof(oid)
 429             && memcmp(vars->name, broadMauXmtCarrierFreq, sizeof(broadMauXmtCarrierFreq)) == 0) {
 430             (*broadMauBasicEntry)->__broadMauXmtCarrierFreq = *vars->val.integer;
 431             (*broadMauBasicEntry)->broadMauXmtCarrierFreq = &((*broadMauBasicEntry)->__broadMauXmtCarrierFreq);
 432         }
 433         if (vars->name_length > sizeof(broadMauTranslationFreq)/sizeof(oid)
 434             && memcmp(vars->name, broadMauTranslationFreq, sizeof(broadMauTranslationFreq)) == 0) {
 435             (*broadMauBasicEntry)->__broadMauTranslationFreq = *vars->val.integer;
 436             (*broadMauBasicEntry)->broadMauTranslationFreq = &((*broadMauBasicEntry)->__broadMauTranslationFreq);
 437         }
 438     }
 439
 440     if (response) snmp_free_pdu(response);
 441
 442     if (snmp_close(peer) == 0) {
 443         return -5;
 444     }
 445
 446     return 0;
 447 }
 448
 449 int mau_mib_mgr_get_ifMauAutoNegEntry(struct snmp_session *s, ifMauAutoNegEntry_t **ifMauAutoNegEntry)
 450 {
 451     struct snmp_session *peer;
 452     struct snmp_pdu *request, *response;
 453     struct variable_list *vars;
 454     int status;
 455
 456     request = snmp_pdu_create(SNMP_MSG_GETNEXT);
 457     snmp_add_null_var(request, ifMauAutoNegAdminStatus, sizeof(ifMauAutoNegAdminStatus)/sizeof(oid));
 458     snmp_add_null_var(request, ifMauAutoNegRemoteSignaling, sizeof(ifMauAutoNegRemoteSignaling)/sizeof(oid));
 459     snmp_add_null_var(request, ifMauAutoNegConfig, sizeof(ifMauAutoNegConfig)/sizeof(oid));
 460     snmp_add_null_var(request, ifMauAutoNegCapability, sizeof(ifMauAutoNegCapability)/sizeof(oid));
 461     snmp_add_null_var(request, ifMauAutoNegCapAdvertised, sizeof(ifMauAutoNegCapAdvertised)/sizeof(oid));
 462     snmp_add_null_var(request, ifMauAutoNegCapReceived, sizeof(ifMauAutoNegCapReceived)/sizeof(oid));
 463     snmp_add_null_var(request, ifMauAutoNegRestart, sizeof(ifMauAutoNegRestart)/sizeof(oid));
 464     snmp_add_null_var(request, ifMauAutoNegCapabilityBits, sizeof(ifMauAutoNegCapabilityBits)/sizeof(oid));
 465     snmp_add_null_var(request, ifMauAutoNegCapAdvertisedBits, sizeof(ifMauAutoNegCapAdvertisedBits)/sizeof(oid));
 466     snmp_add_null_var(request, ifMauAutoNegCapReceivedBits, sizeof(ifMauAutoNegCapReceivedBits)/sizeof(oid));
 467     snmp_add_null_var(request, ifMauAutoNegRemoteFaultAdvertised, sizeof(ifMauAutoNegRemoteFaultAdvertised)/sizeof(oid));
 468     snmp_add_null_var(request, ifMauAutoNegRemoteFaultReceived, sizeof(ifMauAutoNegRemoteFaultReceived)/sizeof(oid));
 469
 470     peer = snmp_open(s);
 471     if (!peer) {
 472         snmp_free_pdu(request);
 473         return -1;
 474     }
 475
 476     status = snmp_synch_response(peer, request, &response);
 477     if (status != STAT_SUCCESS) {
 478         if (response) snmp_free_pdu(response);
 479         snmp_close(peer);
 480         return -2;
 481     }
 482
 483     *ifMauAutoNegEntry = (ifMauAutoNegEntry_t *) malloc(sizeof(ifMauAutoNegEntry_t));
 484     if (! *ifMauAutoNegEntry) {
 485         if (response) snmp_free_pdu(response);
 486         snmp_close(peer);
 487         return -4;
 488     }
 489
 490     for (vars = response->variables; vars; vars = vars->next_variable) {
 491         if (vars->name_length > sizeof(ifMauAutoNegAdminStatus)/sizeof(oid)
 492             && memcmp(vars->name, ifMauAutoNegAdminStatus, sizeof(ifMauAutoNegAdminStatus)) == 0) {
 493             (*ifMauAutoNegEntry)->__ifMauAutoNegAdminStatus = *vars->val.integer;
 494             (*ifMauAutoNegEntry)->ifMauAutoNegAdminStatus = &((*ifMauAutoNegEntry)->__ifMauAutoNegAdminStatus);
 495         }
 496         if (vars->name_length > sizeof(ifMauAutoNegRemoteSignaling)/sizeof(oid)
 497             && memcmp(vars->name, ifMauAutoNegRemoteSignaling, sizeof(ifMauAutoNegRemoteSignaling)) == 0) {
 498             (*ifMauAutoNegEntry)->__ifMauAutoNegRemoteSignaling = *vars->val.integer;
 499             (*ifMauAutoNegEntry)->ifMauAutoNegRemoteSignaling = &((*ifMauAutoNegEntry)->__ifMauAutoNegRemoteSignaling);
 500         }
 501         if (vars->name_length > sizeof(ifMauAutoNegConfig)/sizeof(oid)
 502             && memcmp(vars->name, ifMauAutoNegConfig, sizeof(ifMauAutoNegConfig)) == 0) {
 503             (*ifMauAutoNegEntry)->__ifMauAutoNegConfig = *vars->val.integer;
 504             (*ifMauAutoNegEntry)->ifMauAutoNegConfig = &((*ifMauAutoNegEntry)->__ifMauAutoNegConfig);
 505         }
 506         if (vars->name_length > sizeof(ifMauAutoNegCapability)/sizeof(oid)
 507             && memcmp(vars->name, ifMauAutoNegCapability, sizeof(ifMauAutoNegCapability)) == 0) {
 508             (*ifMauAutoNegEntry)->__ifMauAutoNegCapability = *vars->val.integer;
 509             (*ifMauAutoNegEntry)->ifMauAutoNegCapability = &((*ifMauAutoNegEntry)->__ifMauAutoNegCapability);
 510         }
 511         if (vars->name_length > sizeof(ifMauAutoNegCapAdvertised)/sizeof(oid)
 512             && memcmp(vars->name, ifMauAutoNegCapAdvertised, sizeof(ifMauAutoNegCapAdvertised)) == 0) {
 513             (*ifMauAutoNegEntry)->__ifMauAutoNegCapAdvertised = *vars->val.integer;
 514             (*ifMauAutoNegEntry)->ifMauAutoNegCapAdvertised = &((*ifMauAutoNegEntry)->__ifMauAutoNegCapAdvertised);
 515         }
 516         if (vars->name_length > sizeof(ifMauAutoNegCapReceived)/sizeof(oid)
 517             && memcmp(vars->name, ifMauAutoNegCapReceived, sizeof(ifMauAutoNegCapReceived)) == 0) {
 518             (*ifMauAutoNegEntry)->__ifMauAutoNegCapReceived = *vars->val.integer;
 519             (*ifMauAutoNegEntry)->ifMauAutoNegCapReceived = &((*ifMauAutoNegEntry)->__ifMauAutoNegCapReceived);
 520         }
 521         if (vars->name_length > sizeof(ifMauAutoNegRestart)/sizeof(oid)
 522             && memcmp(vars->name, ifMauAutoNegRestart, sizeof(ifMauAutoNegRestart)) == 0) {
 523             (*ifMauAutoNegEntry)->__ifMauAutoNegRestart = *vars->val.integer;
 524             (*ifMauAutoNegEntry)->ifMauAutoNegRestart = &((*ifMauAutoNegEntry)->__ifMauAutoNegRestart);
 525         }
 526         if (vars->name_length > sizeof(ifMauAutoNegCapabilityBits)/sizeof(oid)
 527             && memcmp(vars->name, ifMauAutoNegCapabilityBits, sizeof(ifMauAutoNegCapabilityBits)) == 0) {
 528             memcpy((*ifMauAutoNegEntry)->__ifMauAutoNegCapabilityBits, vars->val.string, vars->val_len);
 529             (*ifMauAutoNegEntry)->_ifMauAutoNegCapabilityBitsLength = vars->val_len;
 530             (*ifMauAutoNegEntry)->ifMauAutoNegCapabilityBits = (*ifMauAutoNegEntry)->__ifMauAutoNegCapabilityBits;
 531         }
 532         if (vars->name_length > sizeof(ifMauAutoNegCapAdvertisedBits)/sizeof(oid)
 533             && memcmp(vars->name, ifMauAutoNegCapAdvertisedBits, sizeof(ifMauAutoNegCapAdvertisedBits)) == 0) {
 534             memcpy((*ifMauAutoNegEntry)->__ifMauAutoNegCapAdvertisedBits, vars->val.string, vars->val_len);
 535             (*ifMauAutoNegEntry)->_ifMauAutoNegCapAdvertisedBitsLength = vars->val_len;
 536             (*ifMauAutoNegEntry)->ifMauAutoNegCapAdvertisedBits = (*ifMauAutoNegEntry)->__ifMauAutoNegCapAdvertisedBits;
 537         }
 538         if (vars->name_length > sizeof(ifMauAutoNegCapReceivedBits)/sizeof(oid)
 539             && memcmp(vars->name, ifMauAutoNegCapReceivedBits, sizeof(ifMauAutoNegCapReceivedBits)) == 0) {
 540             memcpy((*ifMauAutoNegEntry)->__ifMauAutoNegCapReceivedBits, vars->val.string, vars->val_len);
 541             (*ifMauAutoNegEntry)->_ifMauAutoNegCapReceivedBitsLength = vars->val_len;
 542             (*ifMauAutoNegEntry)->ifMauAutoNegCapReceivedBits = (*ifMauAutoNegEntry)->__ifMauAutoNegCapReceivedBits;
 543         }
 544         if (vars->name_length > sizeof(ifMauAutoNegRemoteFaultAdvertised)/sizeof(oid)
 545             && memcmp(vars->name, ifMauAutoNegRemoteFaultAdvertised, sizeof(ifMauAutoNegRemoteFaultAdvertised)) == 0) {
 546             (*ifMauAutoNegEntry)->__ifMauAutoNegRemoteFaultAdvertised = *vars->val.integer;
 547             (*ifMauAutoNegEntry)->ifMauAutoNegRemoteFaultAdvertised = &((*ifMauAutoNegEntry)->__ifMauAutoNegRemoteFaultAdvertised);
 548         }
 549         if (vars->name_length > sizeof(ifMauAutoNegRemoteFaultReceived)/sizeof(oid)
 550             && memcmp(vars->name, ifMauAutoNegRemoteFaultReceived, sizeof(ifMauAutoNegRemoteFaultReceived)) == 0) {
 551             (*ifMauAutoNegEntry)->__ifMauAutoNegRemoteFaultReceived = *vars->val.integer;
 552             (*ifMauAutoNegEntry)->ifMauAutoNegRemoteFaultReceived = &((*ifMauAutoNegEntry)->__ifMauAutoNegRemoteFaultReceived);
 553         }
 554     }
 555
 556     if (response) snmp_free_pdu(response);
 557
 558     if (snmp_close(peer) == 0) {
 559         return -5;
 560     }
 561
 562     return 0;
 563 }
 564
 565