dll/win32/inetmib1/main.c

   1 /*
   2  * Copyright 2008 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define WIN32_NO_STATUS
  20
  21 #include <config.h>
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25 //#include <limits.h>
  26
  27 #define NONAMELESSUNION
  28
  29 #include <windef.h>
  30 #include <winbase.h>
  31 #include <snmp.h>
  32 #include <iphlpapi.h>
  33 #include <wine/debug.h>
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(inetmib1);
  36
  37 /**
  38  * Utility functions
  39  */
  40 static DWORD copyInt(AsnAny *value, void *src)
  41 {
  42     value->asnType = ASN_INTEGER;
  43     value->asnValue.number = *(DWORD *)src;
  44     return SNMP_ERRORSTATUS_NOERROR;
  45 }
  46
  47 static void setStringValue(AsnAny *value, BYTE type, DWORD len, BYTE *str)
  48 {
  49     AsnAny strValue;
  50
  51     strValue.asnType = type;
  52     strValue.asnValue.string.stream = str;
  53     strValue.asnValue.string.length = len;
  54     strValue.asnValue.string.dynamic = FALSE;
  55     SnmpUtilAsnAnyCpy(value, &strValue);
  56 }
  57
  58 typedef DWORD (*copyValueFunc)(AsnAny *value, void *src);
  59
  60 struct structToAsnValue
  61 {
  62     size_t        offset;
  63     copyValueFunc copy;
  64 };
  65
  66 static AsnInteger32 mapStructEntryToValue(struct structToAsnValue *map,
  67     UINT mapLen, void *record, UINT id, SnmpVarBind *pVarBind)
  68 {
  69     /* OIDs are 1-based */
  70     if (!id)
  71         return SNMP_ERRORSTATUS_NOSUCHNAME;
  72     --id;
  73     if (id >= mapLen)
  74         return SNMP_ERRORSTATUS_NOSUCHNAME;
  75     if (!map[id].copy)
  76         return SNMP_ERRORSTATUS_NOSUCHNAME;
  77     return map[id].copy(&pVarBind->value, (BYTE *)record + map[id].offset);
  78 }
  79
  80 static DWORD copyIpAddr(AsnAny *value, void *src)
  81 {
  82     setStringValue(value, ASN_IPADDRESS, sizeof(DWORD), src);
  83     return SNMP_ERRORSTATUS_NOERROR;
  84 }
  85
  86 static UINT mib2[] = { 1,3,6,1,2,1 };
  87 static UINT mib2System[] = { 1,3,6,1,2,1,1 };
  88
  89 typedef BOOL (*varqueryfunc)(BYTE bPduType, SnmpVarBind *pVarBind,
  90     AsnInteger32 *pErrorStatus);
  91
  92 struct mibImplementation
  93 {
  94     AsnObjectIdentifier name;
  95     void              (*init)(void);
  96     varqueryfunc        query;
  97     void              (*cleanup)(void);
  98 };
  99
 100 static UINT mib2IfNumber[] = { 1,3,6,1,2,1,2,1 };
 101 static PMIB_IFTABLE ifTable;
 102
 103 static void mib2IfNumberInit(void)
 104 {
 105     DWORD size = 0, ret = GetIfTable(NULL, &size, FALSE);
 106
 107     if (ret == ERROR_INSUFFICIENT_BUFFER)
 108     {
 109         MIB_IFTABLE *table = HeapAlloc(GetProcessHeap(), 0, size);
 110         if (table)
 111         {
 112             if (!GetIfTable(table, &size, FALSE)) ifTable = table;
 113             else HeapFree(GetProcessHeap(), 0, table );
 114         }
 115     }
 116 }
 117
 118 static void mib2IfNumberCleanup(void)
 119 {
 120     HeapFree(GetProcessHeap(), 0, ifTable);
 121 }
 122
 123 static BOOL mib2IfNumberQuery(BYTE bPduType, SnmpVarBind *pVarBind,
 124     AsnInteger32 *pErrorStatus)
 125 {
 126     AsnObjectIdentifier numberOid = DEFINE_OID(mib2IfNumber);
 127     BOOL ret = TRUE;
 128
 129     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
 130         pErrorStatus);
 131
 132     switch (bPduType)
 133     {
 134     case SNMP_PDU_GET:
 135     case SNMP_PDU_GETNEXT:
 136         if ((bPduType == SNMP_PDU_GET &&
 137             !SnmpUtilOidNCmp(&pVarBind->name, &numberOid, numberOid.idLength))
 138             || SnmpUtilOidNCmp(&pVarBind->name, &numberOid, numberOid.idLength)
 139             < 0)
 140         {
 141             DWORD numIfs = ifTable ? ifTable->dwNumEntries : 0;
 142
 143             copyInt(&pVarBind->value, &numIfs);
 144             if (bPduType == SNMP_PDU_GETNEXT)
 145             {
 146                 SnmpUtilOidFree(&pVarBind->name);
 147                 SnmpUtilOidCpy(&pVarBind->name, &numberOid);
 148             }
 149             *pErrorStatus = SNMP_ERRORSTATUS_NOERROR;
 150         }
 151         else
 152         {
 153             *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 154             /* Caller deals with OID if bPduType == SNMP_PDU_GETNEXT, so don't
 155              * need to set it here.
 156              */
 157         }
 158         break;
 159     case SNMP_PDU_SET:
 160         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
 161         ret = FALSE;
 162         break;
 163     default:
 164         FIXME("0x%02x: unsupported PDU type\n", bPduType);
 165         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 166     }
 167     return ret;
 168 }
 169
 170 static DWORD copyOperStatus(AsnAny *value, void *src)
 171 {
 172     value->asnType = ASN_INTEGER;
 173     /* The IPHlpApi definition of operational status differs from the MIB2 one,
 174      * so map it to the MIB2 value.
 175      */
 176     switch (*(DWORD *)src)
 177     {
 178     case MIB_IF_OPER_STATUS_OPERATIONAL:
 179         value->asnValue.number = MIB_IF_ADMIN_STATUS_UP;
 180         break;
 181     case MIB_IF_OPER_STATUS_CONNECTING:
 182     case MIB_IF_OPER_STATUS_CONNECTED:
 183         value->asnValue.number = MIB_IF_ADMIN_STATUS_TESTING;
 184         break;
 185     default:
 186         value->asnValue.number = MIB_IF_ADMIN_STATUS_DOWN;
 187     };
 188     return SNMP_ERRORSTATUS_NOERROR;
 189 }
 190
 191 /* Given an OID and a base OID that it must begin with, finds the item and
 192  * integer instance from the OID.  E.g., given an OID foo.1.2 and a base OID
 193  * foo, returns item 1 and instance 2.
 194  * If bPduType is not SNMP_PDU_GETNEXT and either the item or instance is
 195  * missing, returns SNMP_ERRORSTATUS_NOSUCHNAME.
 196  * If bPduType is SNMP_PDU_GETNEXT, returns the successor to the item and
 197  * instance, or item 1, instance 1 if either is missing.
 198  */
 199 static AsnInteger32 getItemAndIntegerInstanceFromOid(AsnObjectIdentifier *oid,
 200     AsnObjectIdentifier *base, BYTE bPduType, UINT *item, UINT *instance)
 201 {
 202     AsnInteger32 ret = SNMP_ERRORSTATUS_NOERROR;
 203
 204     switch (bPduType)
 205     {
 206     case SNMP_PDU_GETNEXT:
 207         if (SnmpUtilOidNCmp(oid, base, base->idLength) < 0)
 208         {
 209             *item = 1;
 210             *instance = 1;
 211         }
 212         else if (!SnmpUtilOidNCmp(oid, base, base->idLength))
 213         {
 214             if (oid->idLength == base->idLength ||
 215                 oid->idLength == base->idLength + 1)
 216             {
 217                 /* Either the table or an item within the table is specified,
 218                  * but the instance is not.  Get the first instance.
 219                  */
 220                 *instance = 1;
 221                 if (oid->idLength == base->idLength + 1)
 222                     *item = oid->ids[base->idLength];
 223                 else
 224                     *item = 1;
 225             }
 226             else
 227             {
 228                 *item = oid->ids[base->idLength];
 229                 *instance = oid->ids[base->idLength + 1] + 1;
 230             }
 231         }
 232         else
 233             ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 234         break;
 235     default:
 236         if (!SnmpUtilOidNCmp(oid, base, base->idLength))
 237         {
 238             if (oid->idLength == base->idLength ||
 239                 oid->idLength == base->idLength + 1)
 240             {
 241                 /* Either the table or an item within the table is specified,
 242                  * but the instance is not.
 243                  */
 244                 ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 245             }
 246             else
 247             {
 248                 *item = oid->ids[base->idLength];
 249                 *instance = oid->ids[base->idLength + 1];
 250             }
 251         }
 252         else
 253             ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 254     }
 255     return ret;
 256 }
 257
 258 /* Given an OID and a base OID that it must begin with, finds the item from the
 259  * OID.  E.g., given an OID foo.1 and a base OID foo, returns item 1.
 260  * If bPduType is not SNMP_PDU_GETNEXT and the item is missing, returns
 261  * SNMP_ERRORSTATUS_NOSUCHNAME.
 262  * If bPduType is SNMP_PDU_GETNEXT, returns the successor to the item, or item
 263  * 1 if the item is missing.
 264  */
 265 static AsnInteger32 getItemFromOid(AsnObjectIdentifier *oid,
 266     AsnObjectIdentifier *base, BYTE bPduType, UINT *item)
 267 {
 268     AsnInteger32 ret = SNMP_ERRORSTATUS_NOERROR;
 269
 270     switch (bPduType)
 271     {
 272     case SNMP_PDU_GETNEXT:
 273         if (SnmpUtilOidNCmp(oid, base, base->idLength) < 0)
 274             *item = 1;
 275         else if (!SnmpUtilOidNCmp(oid, base, base->idLength))
 276         {
 277             if (oid->idLength == base->idLength)
 278             {
 279                 /* The item is missing, assume the first item */
 280                 *item = 1;
 281             }
 282             else
 283                 *item = oid->ids[base->idLength] + 1;
 284         }
 285         else
 286             ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 287         break;
 288     default:
 289         if (!SnmpUtilOidNCmp(oid, base, base->idLength))
 290         {
 291             if (oid->idLength == base->idLength)
 292             {
 293                 /* The item is missing */
 294                 ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 295             }
 296             else
 297             {
 298                 *item = oid->ids[base->idLength];
 299                 if (!*item)
 300                     ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 301             }
 302         }
 303         else
 304             ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 305     }
 306     return ret;
 307 }
 308
 309 struct GenericTable
 310 {
 311     DWORD numEntries;
 312     BYTE  entries[1];
 313 };
 314
 315 static DWORD oidToIpAddr(AsnObjectIdentifier *oid)
 316 {
 317     assert(oid && oid->idLength >= 4);
 318     /* Map the IDs to an IP address in little-endian order */
 319     return (BYTE)oid->ids[3] << 24 | (BYTE)oid->ids[2] << 16 |
 320         (BYTE)oid->ids[1] << 8 | (BYTE)oid->ids[0];
 321 }
 322
 323 typedef void (*oidToKeyFunc)(AsnObjectIdentifier *oid, void *dst);
 324 typedef int (*compareFunc)(const void *key, const void *value);
 325
 326 /* Finds the first value in the table that matches key.  Returns its 1-based
 327  * index if found, or 0 if not found.
 328  */
 329 static UINT findValueInTable(const void *key,
 330     struct GenericTable *table, size_t tableEntrySize, compareFunc compare)
 331 {
 332     UINT index = 0;
 333     void *value;
 334
 335     value = bsearch(key, table->entries, table->numEntries, tableEntrySize,
 336         compare);
 337     if (value)
 338         index = ((BYTE *)value - (BYTE *)table->entries) / tableEntrySize + 1;
 339     return index;
 340 }
 341
 342 /* Finds the first value in the table that matches oid, using makeKey to
 343  * convert the oid to a key for comparison.  Returns the value's 1-based
 344  * index if found, or 0 if not found.
 345  */
 346 static UINT findOidInTable(AsnObjectIdentifier *oid,
 347     struct GenericTable *table, size_t tableEntrySize, oidToKeyFunc makeKey,
 348     compareFunc compare)
 349 {
 350     UINT index = 0;
 351     void *key = HeapAlloc(GetProcessHeap(), 0, tableEntrySize);
 352
 353     if (key)
 354     {
 355         makeKey(oid, key);
 356         index = findValueInTable(key, table, tableEntrySize, compare);
 357         HeapFree(GetProcessHeap(), 0, key);
 358     }
 359     return index;
 360 }
 361
 362 /* Finds the first successor to the value in the table that does matches oid,
 363  * using makeKey to convert the oid to a key for comparison.  A successor is
 364  * a value that does not match oid, so if multiple entries match an oid, only
 365  * the first will ever be returned using this method.
 366  * Returns the successor's 1-based index if found, or 0 if not found.
 367  */
 368 static UINT findNextOidInTable(AsnObjectIdentifier *oid,
 369     struct GenericTable *table, size_t tableEntrySize, oidToKeyFunc makeKey,
 370     compareFunc compare)
 371 {
 372     UINT index = 0;
 373     void *key = HeapAlloc(GetProcessHeap(), 0, tableEntrySize);
 374
 375     if (key)
 376     {
 377         makeKey(oid, key);
 378         index = findValueInTable(key, table, tableEntrySize, compare);
 379         if (index == 0)
 380         {
 381             /* Not found in table.  If it's less than the first entry, return
 382              * the first index.  Otherwise just return 0 and let the caller
 383              * handle finding the successor.
 384              */
 385             if (compare(key, table->entries) < 0)
 386                 index = 1;
 387         }
 388         else
 389         {
 390             /* Skip any entries that match the same key.  This enumeration will
 391              * be incomplete, but it's what Windows appears to do if there are
 392              * multiple entries with the same index in a table, and it avoids
 393              * an infinite loop.
 394              */
 395             for (++index; index <= table->numEntries && compare(key,
 396                 &table->entries[tableEntrySize * (index - 1)]) == 0; ++index)
 397                 ;
 398         }
 399         HeapFree(GetProcessHeap(), 0, key);
 400     }
 401     return index;
 402 }
 403
 404 /* Given an OID and a base OID that it must begin with, finds the item and
 405  * element of the table whose value matches the instance from the OID.
 406  * The OID is converted to a key with the function makeKey, and compared
 407  * against entries in the table with the function compare.
 408  * If bPduType is not SNMP_PDU_GETNEXT and either the item or instance is
 409  * missing, returns SNMP_ERRORSTATUS_NOSUCHNAME.
 410  * If bPduType is SNMP_PDU_GETNEXT, returns the successor to the item and
 411  * instance, or item 1, instance 1 if either is missing.
 412  */
 413 static AsnInteger32 getItemAndInstanceFromTable(AsnObjectIdentifier *oid,
 414     AsnObjectIdentifier *base, UINT instanceLen, BYTE bPduType,
 415     struct GenericTable *table, size_t tableEntrySize, oidToKeyFunc makeKey,
 416     compareFunc compare, UINT *item, UINT *instance)
 417 {
 418     AsnInteger32 ret = SNMP_ERRORSTATUS_NOERROR;
 419
 420     if (!table)
 421         return SNMP_ERRORSTATUS_NOSUCHNAME;
 422
 423     switch (bPduType)
 424     {
 425     case SNMP_PDU_GETNEXT:
 426         if (SnmpUtilOidNCmp(oid, base, base->idLength) < 0)
 427         {
 428             /* Return the first item and instance from the table */
 429             *item = 1;
 430             *instance = 1;
 431         }
 432         else if (!SnmpUtilOidNCmp(oid, base, base->idLength) &&
 433             oid->idLength < base->idLength + instanceLen + 1)
 434         {
 435             /* Either the table or an item is specified, but the instance is
 436              * not.
 437              */
 438             *instance = 1;
 439             if (oid->idLength >= base->idLength + 1)
 440             {
 441                 *item = oid->ids[base->idLength];
 442                 if (!*item)
 443                     *item = 1;
 444             }
 445             else
 446                 *item = 1;
 447         }
 448         else if (!SnmpUtilOidNCmp(oid, base, base->idLength) &&
 449             oid->idLength == base->idLength + instanceLen + 1)
 450         {
 451             *item = oid->ids[base->idLength];
 452             if (!*item)
 453             {
 454                 *instance = 1;
 455                 *item = 1;
 456             }
 457             else
 458             {
 459                 AsnObjectIdentifier instanceOid = { instanceLen,
 460                     oid->ids + base->idLength + 1 };
 461
 462                 *instance = findNextOidInTable(&instanceOid, table,
 463                     tableEntrySize, makeKey, compare);
 464                 if (!*instance || *instance > table->numEntries)
 465                     ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 466             }
 467         }
 468         else
 469             ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 470         break;
 471     default:
 472         if (!SnmpUtilOidNCmp(oid, base, base->idLength) &&
 473             oid->idLength == base->idLength + instanceLen + 1)
 474         {
 475             *item = oid->ids[base->idLength];
 476             if (!*item)
 477                 ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 478             else
 479             {
 480                 AsnObjectIdentifier instanceOid = { instanceLen,
 481                     oid->ids + base->idLength + 1 };
 482
 483                 *instance = findOidInTable(&instanceOid, table, tableEntrySize,
 484                     makeKey, compare);
 485                 if (!*instance)
 486                     ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 487             }
 488         }
 489         else
 490             ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 491     }
 492     return ret;
 493 }
 494
 495 static INT setOidWithItem(AsnObjectIdentifier *dst, AsnObjectIdentifier *base,
 496     UINT item)
 497 {
 498     UINT id;
 499     AsnObjectIdentifier oid;
 500     INT ret;
 501
 502     SnmpUtilOidFree(dst);
 503     ret = SnmpUtilOidCpy(dst, base);
 504     if (ret)
 505     {
 506         oid.idLength = 1;
 507         oid.ids = &id;
 508         id = item;
 509         ret = SnmpUtilOidAppend(dst, &oid);
 510     }
 511     return ret;
 512 }
 513
 514 static INT setOidWithItemAndIpAddr(AsnObjectIdentifier *dst,
 515     AsnObjectIdentifier *base, UINT item, DWORD addr)
 516 {
 517     UINT id;
 518     BYTE *ptr;
 519     AsnObjectIdentifier oid;
 520     INT ret;
 521
 522     ret = setOidWithItem(dst, base, item);
 523     if (ret)
 524     {
 525         oid.idLength = 1;
 526         oid.ids = &id;
 527         for (ptr = (BYTE *)&addr; ret && ptr < (BYTE *)&addr + sizeof(DWORD);
 528          ptr++)
 529         {
 530             id = *ptr;
 531             ret = SnmpUtilOidAppend(dst, &oid);
 532         }
 533     }
 534     return ret;
 535 }
 536
 537 static INT setOidWithItemAndInteger(AsnObjectIdentifier *dst,
 538     AsnObjectIdentifier *base, UINT item, UINT instance)
 539 {
 540     AsnObjectIdentifier oid;
 541     INT ret;
 542
 543     ret = setOidWithItem(dst, base, item);
 544     if (ret)
 545     {
 546         oid.idLength = 1;
 547         oid.ids = &instance;
 548         ret = SnmpUtilOidAppend(dst, &oid);
 549     }
 550     return ret;
 551 }
 552
 553 static DWORD copyIfRowDescr(AsnAny *value, void *src)
 554 {
 555     PMIB_IFROW row = (PMIB_IFROW)((BYTE *)src -
 556                                   FIELD_OFFSET(MIB_IFROW, dwDescrLen));
 557     DWORD ret;
 558
 559     if (row->dwDescrLen)
 560     {
 561         setStringValue(value, ASN_OCTETSTRING, row->dwDescrLen, row->bDescr);
 562         ret = SNMP_ERRORSTATUS_NOERROR;
 563     }
 564     else
 565         ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 566     return ret;
 567 }
 568
 569 static DWORD copyIfRowPhysAddr(AsnAny *value, void *src)
 570 {
 571     PMIB_IFROW row = (PMIB_IFROW)((BYTE *)src -
 572                                   FIELD_OFFSET(MIB_IFROW, dwPhysAddrLen));
 573     DWORD ret;
 574
 575     if (row->dwPhysAddrLen)
 576     {
 577         setStringValue(value, ASN_OCTETSTRING, row->dwPhysAddrLen,
 578                        row->bPhysAddr);
 579         ret = SNMP_ERRORSTATUS_NOERROR;
 580     }
 581     else
 582         ret = SNMP_ERRORSTATUS_NOSUCHNAME;
 583     return ret;
 584 }
 585
 586 static struct structToAsnValue mib2IfEntryMap[] = {
 587     { FIELD_OFFSET(MIB_IFROW, dwIndex), copyInt },
 588     { FIELD_OFFSET(MIB_IFROW, dwDescrLen), copyIfRowDescr },
 589     { FIELD_OFFSET(MIB_IFROW, dwType), copyInt },
 590     { FIELD_OFFSET(MIB_IFROW, dwMtu), copyInt },
 591     { FIELD_OFFSET(MIB_IFROW, dwSpeed), copyInt },
 592     { FIELD_OFFSET(MIB_IFROW, dwPhysAddrLen), copyIfRowPhysAddr },
 593     { FIELD_OFFSET(MIB_IFROW, dwAdminStatus), copyInt },
 594     { FIELD_OFFSET(MIB_IFROW, dwOperStatus), copyOperStatus },
 595     { FIELD_OFFSET(MIB_IFROW, dwLastChange), copyInt },
 596     { FIELD_OFFSET(MIB_IFROW, dwInOctets), copyInt },
 597     { FIELD_OFFSET(MIB_IFROW, dwInUcastPkts), copyInt },
 598     { FIELD_OFFSET(MIB_IFROW, dwInNUcastPkts), copyInt },
 599     { FIELD_OFFSET(MIB_IFROW, dwInDiscards), copyInt },
 600     { FIELD_OFFSET(MIB_IFROW, dwInErrors), copyInt },
 601     { FIELD_OFFSET(MIB_IFROW, dwInUnknownProtos), copyInt },
 602     { FIELD_OFFSET(MIB_IFROW, dwOutOctets), copyInt },
 603     { FIELD_OFFSET(MIB_IFROW, dwOutUcastPkts), copyInt },
 604     { FIELD_OFFSET(MIB_IFROW, dwOutNUcastPkts), copyInt },
 605     { FIELD_OFFSET(MIB_IFROW, dwOutDiscards), copyInt },
 606     { FIELD_OFFSET(MIB_IFROW, dwOutErrors), copyInt },
 607     { FIELD_OFFSET(MIB_IFROW, dwOutQLen), copyInt },
 608 };
 609
 610 static UINT mib2IfEntry[] = { 1,3,6,1,2,1,2,2,1 };
 611
 612 static BOOL mib2IfEntryQuery(BYTE bPduType, SnmpVarBind *pVarBind,
 613     AsnInteger32 *pErrorStatus)
 614 {
 615     AsnObjectIdentifier entryOid = DEFINE_OID(mib2IfEntry);
 616     BOOL ret = TRUE;
 617
 618     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
 619         pErrorStatus);
 620
 621     switch (bPduType)
 622     {
 623     case SNMP_PDU_GET:
 624     case SNMP_PDU_GETNEXT:
 625         if (!ifTable)
 626         {
 627             /* There is no interface present, so let the caller deal
 628              * with finding the successor.
 629              */
 630             *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 631         }
 632         else
 633         {
 634             UINT tableIndex = 0, item = 0;
 635
 636             *pErrorStatus = getItemAndIntegerInstanceFromOid(&pVarBind->name,
 637                 &entryOid, bPduType, &item, &tableIndex);
 638             if (!*pErrorStatus)
 639             {
 640                 assert(tableIndex);
 641                 assert(item);
 642                 if (tableIndex > ifTable->dwNumEntries)
 643                     *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 644                 else
 645                 {
 646                     *pErrorStatus = mapStructEntryToValue(mib2IfEntryMap,
 647                         DEFINE_SIZEOF(mib2IfEntryMap),
 648                         &ifTable->table[tableIndex - 1], item,
 649                         pVarBind);
 650                     if (bPduType == SNMP_PDU_GETNEXT)
 651                         ret = setOidWithItemAndInteger(&pVarBind->name,
 652                             &entryOid, item, tableIndex);
 653                 }
 654             }
 655         }
 656         break;
 657     case SNMP_PDU_SET:
 658         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
 659         ret = FALSE;
 660         break;
 661     default:
 662         FIXME("0x%02x: unsupported PDU type\n", bPduType);
 663         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 664     }
 665     return ret;
 666 }
 667
 668 static UINT mib2Ip[] = { 1,3,6,1,2,1,4 };
 669 static MIB_IPSTATS ipStats;
 670
 671 static void mib2IpStatsInit(void)
 672 {
 673     GetIpStatistics(&ipStats);
 674 }
 675
 676 static struct structToAsnValue mib2IpMap[] = {
 677     { FIELD_OFFSET(MIB_IPSTATS, u.dwForwarding), copyInt }, /* 1 */
 678     { FIELD_OFFSET(MIB_IPSTATS, dwDefaultTTL), copyInt }, /* 2 */
 679     { FIELD_OFFSET(MIB_IPSTATS, dwInReceives), copyInt }, /* 3 */
 680     { FIELD_OFFSET(MIB_IPSTATS, dwInHdrErrors), copyInt }, /* 4 */
 681     { FIELD_OFFSET(MIB_IPSTATS, dwInAddrErrors), copyInt }, /* 5 */
 682     { FIELD_OFFSET(MIB_IPSTATS, dwForwDatagrams), copyInt }, /* 6 */
 683     { FIELD_OFFSET(MIB_IPSTATS, dwInUnknownProtos), copyInt }, /* 7 */
 684     { FIELD_OFFSET(MIB_IPSTATS, dwInDiscards), copyInt }, /* 8 */
 685     { FIELD_OFFSET(MIB_IPSTATS, dwInDelivers), copyInt }, /* 9 */
 686     { FIELD_OFFSET(MIB_IPSTATS, dwOutRequests), copyInt }, /* 10 */
 687     { FIELD_OFFSET(MIB_IPSTATS, dwOutDiscards), copyInt }, /* 11 */
 688     { FIELD_OFFSET(MIB_IPSTATS, dwOutNoRoutes), copyInt }, /* 12 */
 689     { FIELD_OFFSET(MIB_IPSTATS, dwReasmTimeout), copyInt }, /* 13 */
 690     { FIELD_OFFSET(MIB_IPSTATS, dwReasmReqds), copyInt }, /* 14 */
 691     { FIELD_OFFSET(MIB_IPSTATS, dwReasmOks), copyInt }, /* 15 */
 692     { FIELD_OFFSET(MIB_IPSTATS, dwReasmFails), copyInt }, /* 16 */
 693     { FIELD_OFFSET(MIB_IPSTATS, dwFragOks), copyInt }, /* 17 */
 694     { FIELD_OFFSET(MIB_IPSTATS, dwFragFails), copyInt }, /* 18 */
 695     { FIELD_OFFSET(MIB_IPSTATS, dwFragCreates), copyInt }, /* 19 */
 696     { 0, NULL }, /* 20: not used, IP addr table */
 697     { 0, NULL }, /* 21: not used, route table */
 698     { 0, NULL }, /* 22: not used, net to media (ARP) table */
 699     { FIELD_OFFSET(MIB_IPSTATS, dwRoutingDiscards), copyInt }, /* 23 */
 700 };
 701
 702 static BOOL mib2IpStatsQuery(BYTE bPduType, SnmpVarBind *pVarBind,
 703     AsnInteger32 *pErrorStatus)
 704 {
 705     AsnObjectIdentifier myOid = DEFINE_OID(mib2Ip);
 706     UINT item = 0;
 707     BOOL ret = TRUE;
 708
 709     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
 710         pErrorStatus);
 711
 712     switch (bPduType)
 713     {
 714     case SNMP_PDU_GET:
 715     case SNMP_PDU_GETNEXT:
 716         *pErrorStatus = getItemFromOid(&pVarBind->name, &myOid, bPduType,
 717             &item);
 718         if (!*pErrorStatus)
 719         {
 720             *pErrorStatus = mapStructEntryToValue(mib2IpMap,
 721                 DEFINE_SIZEOF(mib2IpMap), &ipStats, item, pVarBind);
 722             if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
 723                 ret = setOidWithItem(&pVarBind->name, &myOid, item);
 724         }
 725         break;
 726     case SNMP_PDU_SET:
 727         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
 728         ret = FALSE;
 729         break;
 730     default:
 731         FIXME("0x%02x: unsupported PDU type\n", bPduType);
 732         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 733     }
 734     return ret;
 735 }
 736
 737 static UINT mib2IpAddr[] = { 1,3,6,1,2,1,4,20,1 };
 738 static PMIB_IPADDRTABLE ipAddrTable;
 739
 740 static struct structToAsnValue mib2IpAddrMap[] = {
 741     { FIELD_OFFSET(MIB_IPADDRROW, dwAddr), copyIpAddr },
 742     { FIELD_OFFSET(MIB_IPADDRROW, dwIndex), copyInt },
 743     { FIELD_OFFSET(MIB_IPADDRROW, dwMask), copyIpAddr },
 744     { FIELD_OFFSET(MIB_IPADDRROW, dwBCastAddr), copyInt },
 745     { FIELD_OFFSET(MIB_IPADDRROW, dwReasmSize), copyInt },
 746 };
 747
 748 static void mib2IpAddrInit(void)
 749 {
 750     DWORD size = 0, ret = GetIpAddrTable(NULL, &size, TRUE);
 751
 752     if (ret == ERROR_INSUFFICIENT_BUFFER)
 753     {
 754         MIB_IPADDRTABLE *table = HeapAlloc(GetProcessHeap(), 0, size);
 755         if (table)
 756         {
 757             if (!GetIpAddrTable(table, &size, TRUE)) ipAddrTable = table;
 758             else HeapFree(GetProcessHeap(), 0, table );
 759         }
 760     }
 761 }
 762
 763 static void mib2IpAddrCleanup(void)
 764 {
 765     HeapFree(GetProcessHeap(), 0, ipAddrTable);
 766 }
 767
 768 static void oidToIpAddrRow(AsnObjectIdentifier *oid, void *dst)
 769 {
 770     MIB_IPADDRROW *row = dst;
 771
 772     row->dwAddr = oidToIpAddr(oid);
 773 }
 774
 775 static int compareIpAddrRow(const void *a, const void *b)
 776 {
 777     const MIB_IPADDRROW *key = a, *value = b;
 778
 779     return key->dwAddr - value->dwAddr;
 780 }
 781
 782 static BOOL mib2IpAddrQuery(BYTE bPduType, SnmpVarBind *pVarBind,
 783     AsnInteger32 *pErrorStatus)
 784 {
 785     AsnObjectIdentifier myOid = DEFINE_OID(mib2IpAddr);
 786     UINT tableIndex = 0, item = 0;
 787     BOOL ret = TRUE;
 788
 789     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
 790         pErrorStatus);
 791
 792     switch (bPduType)
 793     {
 794     case SNMP_PDU_GET:
 795     case SNMP_PDU_GETNEXT:
 796         *pErrorStatus = getItemAndInstanceFromTable(&pVarBind->name,
 797             &myOid, 4, bPduType, (struct GenericTable *)ipAddrTable,
 798             sizeof(MIB_IPADDRROW), oidToIpAddrRow, compareIpAddrRow, &item,
 799             &tableIndex);
 800         if (!*pErrorStatus)
 801         {
 802             assert(tableIndex);
 803             assert(item);
 804             *pErrorStatus = mapStructEntryToValue(mib2IpAddrMap,
 805                 DEFINE_SIZEOF(mib2IpAddrMap),
 806                 &ipAddrTable->table[tableIndex - 1], item, pVarBind);
 807             if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
 808                 ret = setOidWithItemAndIpAddr(&pVarBind->name, &myOid, item,
 809                     ipAddrTable->table[tableIndex - 1].dwAddr);
 810         }
 811         break;
 812     case SNMP_PDU_SET:
 813         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
 814         ret = FALSE;
 815         break;
 816     default:
 817         FIXME("0x%02x: unsupported PDU type\n", bPduType);
 818         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 819     }
 820     return ret;
 821 }
 822
 823 static UINT mib2IpRoute[] = { 1,3,6,1,2,1,4,21,1 };
 824 static PMIB_IPFORWARDTABLE ipRouteTable;
 825
 826 static struct structToAsnValue mib2IpRouteMap[] = {
 827     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardDest), copyIpAddr },
 828     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardIfIndex), copyInt },
 829     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardMetric1), copyInt },
 830     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardMetric2), copyInt },
 831     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardMetric3), copyInt },
 832     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardMetric4), copyInt },
 833     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardNextHop), copyIpAddr },
 834     { FIELD_OFFSET(MIB_IPFORWARDROW, u1.dwForwardType), copyInt },
 835     { FIELD_OFFSET(MIB_IPFORWARDROW, u2.dwForwardProto), copyInt },
 836     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardAge), copyInt },
 837     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardMask), copyIpAddr },
 838     { FIELD_OFFSET(MIB_IPFORWARDROW, dwForwardMetric5), copyInt },
 839 };
 840
 841 static void mib2IpRouteInit(void)
 842 {
 843     DWORD size = 0, ret = GetIpForwardTable(NULL, &size, TRUE);
 844
 845     if (ret == ERROR_INSUFFICIENT_BUFFER)
 846     {
 847         MIB_IPFORWARDTABLE *table = HeapAlloc(GetProcessHeap(), 0, size);
 848         if (table)
 849         {
 850             if (!GetIpForwardTable(table, &size, TRUE)) ipRouteTable = table;
 851             else HeapFree(GetProcessHeap(), 0, table );
 852         }
 853     }
 854 }
 855
 856 static void mib2IpRouteCleanup(void)
 857 {
 858     HeapFree(GetProcessHeap(), 0, ipRouteTable);
 859 }
 860
 861 static void oidToIpForwardRow(AsnObjectIdentifier *oid, void *dst)
 862 {
 863     MIB_IPFORWARDROW *row = dst;
 864
 865     row->dwForwardDest = oidToIpAddr(oid);
 866 }
 867
 868 static int compareIpForwardRow(const void *a, const void *b)
 869 {
 870     const MIB_IPFORWARDROW *key = a, *value = b;
 871
 872     return key->dwForwardDest - value->dwForwardDest;
 873 }
 874
 875 static BOOL mib2IpRouteQuery(BYTE bPduType, SnmpVarBind *pVarBind,
 876     AsnInteger32 *pErrorStatus)
 877 {
 878     AsnObjectIdentifier myOid = DEFINE_OID(mib2IpRoute);
 879     UINT tableIndex = 0, item = 0;
 880     BOOL ret = TRUE;
 881
 882     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
 883         pErrorStatus);
 884
 885     switch (bPduType)
 886     {
 887     case SNMP_PDU_GET:
 888     case SNMP_PDU_GETNEXT:
 889         *pErrorStatus = getItemAndInstanceFromTable(&pVarBind->name,
 890             &myOid, 4, bPduType, (struct GenericTable *)ipRouteTable,
 891             sizeof(MIB_IPFORWARDROW), oidToIpForwardRow, compareIpForwardRow,
 892             &item, &tableIndex);
 893         if (!*pErrorStatus)
 894         {
 895             assert(tableIndex);
 896             assert(item);
 897             *pErrorStatus = mapStructEntryToValue(mib2IpRouteMap,
 898                 DEFINE_SIZEOF(mib2IpRouteMap),
 899                 &ipRouteTable->table[tableIndex - 1], item, pVarBind);
 900             if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
 901                 ret = setOidWithItemAndIpAddr(&pVarBind->name, &myOid, item,
 902                     ipRouteTable->table[tableIndex - 1].dwForwardDest);
 903         }
 904         break;
 905     case SNMP_PDU_SET:
 906         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
 907         ret = FALSE;
 908         break;
 909     default:
 910         FIXME("0x%02x: unsupported PDU type\n", bPduType);
 911         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 912     }
 913     return ret;
 914 }
 915
 916 static UINT mib2IpNet[] = { 1,3,6,1,2,1,4,22,1 };
 917 static PMIB_IPNETTABLE ipNetTable;
 918
 919 static DWORD copyIpNetPhysAddr(AsnAny *value, void *src)
 920 {
 921     PMIB_IPNETROW row = (PMIB_IPNETROW)((BYTE *)src - FIELD_OFFSET(MIB_IPNETROW,
 922                                         dwPhysAddrLen));
 923
 924     setStringValue(value, ASN_OCTETSTRING, row->dwPhysAddrLen, row->bPhysAddr);
 925     return SNMP_ERRORSTATUS_NOERROR;
 926 }
 927
 928 static struct structToAsnValue mib2IpNetMap[] = {
 929     { FIELD_OFFSET(MIB_IPNETROW, dwIndex), copyInt },
 930     { FIELD_OFFSET(MIB_IPNETROW, dwPhysAddrLen), copyIpNetPhysAddr },
 931     { FIELD_OFFSET(MIB_IPNETROW, dwAddr), copyIpAddr },
 932     { FIELD_OFFSET(MIB_IPNETROW, u.dwType), copyInt },
 933 };
 934
 935 static void mib2IpNetInit(void)
 936 {
 937     DWORD size = 0, ret = GetIpNetTable(NULL, &size, FALSE);
 938
 939     if (ret == ERROR_INSUFFICIENT_BUFFER)
 940     {
 941         MIB_IPNETTABLE *table = HeapAlloc(GetProcessHeap(), 0, size);
 942         if (table)
 943         {
 944             if (!GetIpNetTable(table, &size, FALSE)) ipNetTable = table;
 945             else HeapFree(GetProcessHeap(), 0, table );
 946         }
 947     }
 948 }
 949
 950 static void mib2IpNetCleanup(void)
 951 {
 952     HeapFree(GetProcessHeap(), 0, ipNetTable);
 953 }
 954
 955 static BOOL mib2IpNetQuery(BYTE bPduType, SnmpVarBind *pVarBind,
 956     AsnInteger32 *pErrorStatus)
 957 {
 958     AsnObjectIdentifier myOid = DEFINE_OID(mib2IpNet);
 959     BOOL ret = TRUE;
 960
 961     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
 962         pErrorStatus);
 963
 964     switch (bPduType)
 965     {
 966     case SNMP_PDU_GET:
 967     case SNMP_PDU_GETNEXT:
 968         if (!ipNetTable)
 969             *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 970         else
 971         {
 972             UINT tableIndex = 0, item = 0;
 973
 974             *pErrorStatus = getItemAndIntegerInstanceFromOid(&pVarBind->name,
 975                 &myOid, bPduType, &item, &tableIndex);
 976             if (!*pErrorStatus)
 977             {
 978                 assert(tableIndex);
 979                 assert(item);
 980                 if (tableIndex > ipNetTable->dwNumEntries)
 981                     *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
 982                 else
 983                 {
 984                     *pErrorStatus = mapStructEntryToValue(mib2IpNetMap,
 985                         DEFINE_SIZEOF(mib2IpNetMap),
 986                         &ipNetTable[tableIndex - 1], item, pVarBind);
 987                     if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
 988                         ret = setOidWithItemAndInteger(&pVarBind->name, &myOid,
 989                             item, tableIndex);
 990                 }
 991             }
 992         }
 993         break;
 994     case SNMP_PDU_SET:
 995         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
 996         ret = FALSE;
 997         break;
 998     default:
 999         FIXME("0x%02x: unsupported PDU type\n", bPduType);
1000         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
1001     }
1002     return ret;
1003 }
1004
1005 static UINT mib2Icmp[] = { 1,3,6,1,2,1,5 };
1006 static MIB_ICMP icmpStats;
1007
1008 static void mib2IcmpInit(void)
1009 {
1010     GetIcmpStatistics(&icmpStats);
1011 }
1012
1013 static struct structToAsnValue mib2IcmpMap[] = {
1014     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwMsgs), copyInt },
1015     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwErrors), copyInt },
1016     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwDestUnreachs), copyInt },
1017     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwTimeExcds), copyInt },
1018     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwParmProbs), copyInt },
1019     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwSrcQuenchs), copyInt },
1020     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwRedirects), copyInt },
1021     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwEchos), copyInt },
1022     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwEchoReps), copyInt },
1023     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwTimestamps), copyInt },
1024     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwTimestampReps), copyInt },
1025     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwAddrMasks), copyInt },
1026     { FIELD_OFFSET(MIBICMPINFO, icmpInStats.dwAddrMaskReps), copyInt },
1027     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwMsgs), copyInt },
1028     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwErrors), copyInt },
1029     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwDestUnreachs), copyInt },
1030     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwTimeExcds), copyInt },
1031     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwParmProbs), copyInt },
1032     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwSrcQuenchs), copyInt },
1033     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwRedirects), copyInt },
1034     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwEchos), copyInt },
1035     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwEchoReps), copyInt },
1036     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwTimestamps), copyInt },
1037     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwTimestampReps), copyInt },
1038     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwAddrMasks), copyInt },
1039     { FIELD_OFFSET(MIBICMPINFO, icmpOutStats.dwAddrMaskReps), copyInt },
1040 };
1041
1042 static BOOL mib2IcmpQuery(BYTE bPduType, SnmpVarBind *pVarBind,
1043     AsnInteger32 *pErrorStatus)
1044 {
1045     AsnObjectIdentifier myOid = DEFINE_OID(mib2Icmp);
1046     UINT item = 0;
1047     BOOL ret = TRUE;
1048
1049     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
1050         pErrorStatus);
1051
1052     switch (bPduType)
1053     {
1054     case SNMP_PDU_GET:
1055     case SNMP_PDU_GETNEXT:
1056         *pErrorStatus = getItemFromOid(&pVarBind->name, &myOid, bPduType,
1057             &item);
1058         if (!*pErrorStatus)
1059         {
1060             *pErrorStatus = mapStructEntryToValue(mib2IcmpMap,
1061                 DEFINE_SIZEOF(mib2IcmpMap), &icmpStats, item,
1062                 pVarBind);
1063             if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
1064                 ret = setOidWithItem(&pVarBind->name, &myOid, item);
1065         }
1066         break;
1067     case SNMP_PDU_SET:
1068         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
1069         ret = FALSE;
1070         break;
1071     default:
1072         FIXME("0x%02x: unsupported PDU type\n", bPduType);
1073         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
1074     }
1075     return ret;
1076 }
1077
1078 static UINT mib2Tcp[] = { 1,3,6,1,2,1,6 };
1079 static MIB_TCPSTATS tcpStats;
1080
1081 static void mib2TcpInit(void)
1082 {
1083     GetTcpStatistics(&tcpStats);
1084 }
1085
1086 static struct structToAsnValue mib2TcpMap[] = {
1087     { FIELD_OFFSET(MIB_TCPSTATS, u.dwRtoAlgorithm), copyInt },
1088     { FIELD_OFFSET(MIB_TCPSTATS, dwRtoMin), copyInt },
1089     { FIELD_OFFSET(MIB_TCPSTATS, dwRtoMax), copyInt },
1090     { FIELD_OFFSET(MIB_TCPSTATS, dwMaxConn), copyInt },
1091     { FIELD_OFFSET(MIB_TCPSTATS, dwActiveOpens), copyInt },
1092     { FIELD_OFFSET(MIB_TCPSTATS, dwPassiveOpens), copyInt },
1093     { FIELD_OFFSET(MIB_TCPSTATS, dwAttemptFails), copyInt },
1094     { FIELD_OFFSET(MIB_TCPSTATS, dwEstabResets), copyInt },
1095     { FIELD_OFFSET(MIB_TCPSTATS, dwCurrEstab), copyInt },
1096     { FIELD_OFFSET(MIB_TCPSTATS, dwInSegs), copyInt },
1097     { FIELD_OFFSET(MIB_TCPSTATS, dwOutSegs), copyInt },
1098     { FIELD_OFFSET(MIB_TCPSTATS, dwRetransSegs), copyInt },
1099     { FIELD_OFFSET(MIB_TCPSTATS, dwInErrs), copyInt },
1100     { FIELD_OFFSET(MIB_TCPSTATS, dwOutRsts), copyInt },
1101     { FIELD_OFFSET(MIB_TCPSTATS, dwNumConns), copyInt },
1102 };
1103
1104 static BOOL mib2TcpQuery(BYTE bPduType, SnmpVarBind *pVarBind,
1105     AsnInteger32 *pErrorStatus)
1106 {
1107     AsnObjectIdentifier myOid = DEFINE_OID(mib2Tcp);
1108     UINT item = 0;
1109     BOOL ret = TRUE;
1110
1111     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
1112         pErrorStatus);
1113
1114     switch (bPduType)
1115     {
1116     case SNMP_PDU_GET:
1117     case SNMP_PDU_GETNEXT:
1118         *pErrorStatus = getItemFromOid(&pVarBind->name, &myOid, bPduType,
1119             &item);
1120         if (!*pErrorStatus)
1121         {
1122             *pErrorStatus = mapStructEntryToValue(mib2TcpMap,
1123                 DEFINE_SIZEOF(mib2TcpMap), &tcpStats, item, pVarBind);
1124             if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
1125                 ret = setOidWithItem(&pVarBind->name, &myOid, item);
1126         }
1127         break;
1128     case SNMP_PDU_SET:
1129         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
1130         ret = FALSE;
1131         break;
1132     default:
1133         FIXME("0x%02x: unsupported PDU type\n", bPduType);
1134         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
1135     }
1136     return ret;
1137 }
1138
1139 static UINT mib2Udp[] = { 1,3,6,1,2,1,7 };
1140 static MIB_UDPSTATS udpStats;
1141
1142 static void mib2UdpInit(void)
1143 {
1144     GetUdpStatistics(&udpStats);
1145 }
1146
1147 static struct structToAsnValue mib2UdpMap[] = {
1148     { FIELD_OFFSET(MIB_UDPSTATS, dwInDatagrams), copyInt },
1149     { FIELD_OFFSET(MIB_UDPSTATS, dwNoPorts), copyInt },
1150     { FIELD_OFFSET(MIB_UDPSTATS, dwInErrors), copyInt },
1151     { FIELD_OFFSET(MIB_UDPSTATS, dwOutDatagrams), copyInt },
1152 };
1153
1154 static BOOL mib2UdpQuery(BYTE bPduType, SnmpVarBind *pVarBind,
1155     AsnInteger32 *pErrorStatus)
1156 {
1157     AsnObjectIdentifier myOid = DEFINE_OID(mib2Udp);
1158     UINT item;
1159     BOOL ret = TRUE;
1160
1161     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
1162         pErrorStatus);
1163
1164     switch (bPduType)
1165     {
1166     case SNMP_PDU_GET:
1167     case SNMP_PDU_GETNEXT:
1168         *pErrorStatus = getItemFromOid(&pVarBind->name, &myOid, bPduType,
1169             &item);
1170         if (!*pErrorStatus)
1171         {
1172             *pErrorStatus = mapStructEntryToValue(mib2UdpMap,
1173                 DEFINE_SIZEOF(mib2UdpMap), &udpStats, item, pVarBind);
1174             if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
1175                 ret = setOidWithItem(&pVarBind->name, &myOid, item);
1176         }
1177         break;
1178     case SNMP_PDU_SET:
1179         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
1180         ret = FALSE;
1181         break;
1182     default:
1183         FIXME("0x%02x: unsupported PDU type\n", bPduType);
1184         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
1185     }
1186     return ret;
1187 }
1188
1189 static UINT mib2UdpEntry[] = { 1,3,6,1,2,1,7,5,1 };
1190 static PMIB_UDPTABLE udpTable;
1191
1192 static void mib2UdpEntryInit(void)
1193 {
1194     DWORD size = 0, ret = GetUdpTable(NULL, &size, TRUE);
1195
1196     if (ret == ERROR_INSUFFICIENT_BUFFER)
1197     {
1198         MIB_UDPTABLE *table = HeapAlloc(GetProcessHeap(), 0, size);
1199         if (table)
1200         {
1201             if (!GetUdpTable(table, &size, TRUE)) udpTable = table;
1202             else HeapFree(GetProcessHeap(), 0, table);
1203         }
1204     }
1205 }
1206
1207 static void mib2UdpEntryCleanup(void)
1208 {
1209     HeapFree(GetProcessHeap(), 0, udpTable);
1210 }
1211
1212 static struct structToAsnValue mib2UdpEntryMap[] = {
1213     { FIELD_OFFSET(MIB_UDPROW, dwLocalAddr), copyIpAddr },
1214     { FIELD_OFFSET(MIB_UDPROW, dwLocalPort), copyInt },
1215 };
1216
1217 static void oidToUdpRow(AsnObjectIdentifier *oid, void *dst)
1218 {
1219     MIB_UDPROW *row = dst;
1220
1221     assert(oid && oid->idLength >= 5);
1222     row->dwLocalAddr = oidToIpAddr(oid);
1223     row->dwLocalPort = oid->ids[4];
1224 }
1225
1226 static int compareUdpRow(const void *a, const void *b)
1227 {
1228     const MIB_UDPROW *key = a, *value = b;
1229     int ret;
1230
1231     ret = key->dwLocalAddr - value->dwLocalAddr;
1232     if (ret == 0)
1233         ret = key->dwLocalPort - value->dwLocalPort;
1234     return ret;
1235 }
1236
1237 static BOOL mib2UdpEntryQuery(BYTE bPduType, SnmpVarBind *pVarBind,
1238     AsnInteger32 *pErrorStatus)
1239 {
1240     AsnObjectIdentifier myOid = DEFINE_OID(mib2UdpEntry);
1241     BOOL ret = TRUE;
1242
1243     TRACE("(0x%02x, %s, %p)\n", bPduType, SnmpUtilOidToA(&pVarBind->name),
1244         pErrorStatus);
1245
1246     switch (bPduType)
1247     {
1248     case SNMP_PDU_GET:
1249     case SNMP_PDU_GETNEXT:
1250         if (!udpTable)
1251             *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
1252         else
1253         {
1254             UINT tableIndex = 0, item = 0;
1255
1256             *pErrorStatus = getItemAndInstanceFromTable(&pVarBind->name, &myOid,
1257                 5, bPduType, (struct GenericTable *)udpTable,
1258                 sizeof(MIB_UDPROW), oidToUdpRow, compareUdpRow, &item,
1259                 &tableIndex);
1260             if (!*pErrorStatus)
1261             {
1262                 assert(tableIndex);
1263                 assert(item);
1264                 *pErrorStatus = mapStructEntryToValue(mib2UdpEntryMap,
1265                     DEFINE_SIZEOF(mib2UdpEntryMap),
1266                     &udpTable->table[tableIndex - 1], item, pVarBind);
1267                 if (!*pErrorStatus && bPduType == SNMP_PDU_GETNEXT)
1268                 {
1269                     AsnObjectIdentifier oid;
1270
1271                     ret = setOidWithItemAndIpAddr(&pVarBind->name, &myOid, item,
1272                         udpTable->table[tableIndex - 1].dwLocalAddr);
1273                     if (ret)
1274                     {
1275                         oid.idLength = 1;
1276                         oid.ids = &udpTable->table[tableIndex - 1].dwLocalPort;
1277                         ret = SnmpUtilOidAppend(&pVarBind->name, &oid);
1278                     }
1279                 }
1280             }
1281         }
1282         break;
1283     case SNMP_PDU_SET:
1284         *pErrorStatus = SNMP_ERRORSTATUS_READONLY;
1285         ret = FALSE;
1286         break;
1287     default:
1288         FIXME("0x%02x: unsupported PDU type\n", bPduType);
1289         *pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
1290     }
1291     return ret;
1292 }
1293
1294 /* This list MUST BE lexicographically sorted */
1295 static struct mibImplementation supportedIDs[] = {
1296     { DEFINE_OID(mib2IfNumber), mib2IfNumberInit, mib2IfNumberQuery,
1297       mib2IfNumberCleanup },
1298     { DEFINE_OID(mib2IfEntry), NULL, mib2IfEntryQuery, NULL },
1299     { DEFINE_OID(mib2Ip), mib2IpStatsInit, mib2IpStatsQuery, NULL },
1300     { DEFINE_OID(mib2IpAddr), mib2IpAddrInit, mib2IpAddrQuery,
1301       mib2IpAddrCleanup },
1302     { DEFINE_OID(mib2IpRoute), mib2IpRouteInit, mib2IpRouteQuery,
1303       mib2IpRouteCleanup },
1304     { DEFINE_OID(mib2IpNet), mib2IpNetInit, mib2IpNetQuery, mib2IpNetCleanup },
1305     { DEFINE_OID(mib2Icmp), mib2IcmpInit, mib2IcmpQuery, NULL },
1306     { DEFINE_OID(mib2Tcp), mib2TcpInit, mib2TcpQuery, NULL },
1307     { DEFINE_OID(mib2Udp), mib2UdpInit, mib2UdpQuery, NULL },
1308     { DEFINE_OID(mib2UdpEntry), mib2UdpEntryInit, mib2UdpEntryQuery,
1309       mib2UdpEntryCleanup },
1310 };
1311 static UINT minSupportedIDLength;
1312
1313 /*****************************************************************************
1314  * SnmpExtensionInit [INETMIB1.@]
1315  */
1316 BOOL WINAPI SnmpExtensionInit(DWORD dwUptimeReference,
1317     HANDLE *phSubagentTrapEvent, AsnObjectIdentifier *pFirstSupportedRegion)
1318 {
1319     AsnObjectIdentifier myOid = DEFINE_OID(mib2System);
1320     UINT i;
1321
1322     TRACE("(%d, %p, %p)\n", dwUptimeReference, phSubagentTrapEvent,
1323         pFirstSupportedRegion);
1324
1325     minSupportedIDLength = UINT_MAX;
1326     for (i = 0; i < sizeof(supportedIDs) / sizeof(supportedIDs[0]); i++)
1327     {
1328         if (supportedIDs[i].init)
1329             supportedIDs[i].init();
1330         if (supportedIDs[i].name.idLength < minSupportedIDLength)
1331             minSupportedIDLength = supportedIDs[i].name.idLength;
1332     }
1333     *phSubagentTrapEvent = NULL;
1334     SnmpUtilOidCpy(pFirstSupportedRegion, &myOid);
1335     return TRUE;
1336 }
1337
1338 static void cleanup(void)
1339 {
1340     UINT i;
1341
1342     for (i = 0; i < sizeof(supportedIDs) / sizeof(supportedIDs[0]); i++)
1343         if (supportedIDs[i].cleanup)
1344             supportedIDs[i].cleanup();
1345 }
1346
1347 static struct mibImplementation *findSupportedQuery(UINT *ids, UINT idLength,
1348     UINT *matchingIndex)
1349 {
1350     int indexHigh = DEFINE_SIZEOF(supportedIDs) - 1, indexLow = 0;
1351     AsnObjectIdentifier oid1 = { idLength, ids};
1352
1353     if (!idLength)
1354         return NULL;
1355
1356     while (indexLow <= indexHigh)
1357     {
1358         INT cmp, i = (indexLow + indexHigh) / 2;
1359         if (!(cmp = SnmpUtilOidNCmp(&oid1, &supportedIDs[i].name, idLength)))
1360         {
1361             *matchingIndex = i;
1362             return &supportedIDs[i];
1363         }
1364         if (cmp > 0)
1365             indexLow = i + 1;
1366         else
1367             indexHigh = i - 1;
1368     }
1369     return NULL;
1370 }
1371
1372 /*****************************************************************************
1373  * SnmpExtensionQuery [INETMIB1.@]
1374  */
1375 BOOL WINAPI SnmpExtensionQuery(BYTE bPduType, SnmpVarBindList *pVarBindList,
1376     AsnInteger32 *pErrorStatus, AsnInteger32 *pErrorIndex)
1377 {
1378     AsnObjectIdentifier mib2oid = DEFINE_OID(mib2);
1379     AsnInteger32 error = SNMP_ERRORSTATUS_NOERROR, errorIndex = 0;
1380     UINT i;
1381     BOOL ret = TRUE;
1382
1383     TRACE("(0x%02x, %p, %p, %p)\n", bPduType, pVarBindList,
1384         pErrorStatus, pErrorIndex);
1385
1386     for (i = 0; !error && i < pVarBindList->len; i++)
1387     {
1388         /* Ignore any OIDs not in MIB2 */
1389         if (!SnmpUtilOidNCmp(&pVarBindList->list[i].name, &mib2oid,
1390             mib2oid.idLength))
1391         {
1392             struct mibImplementation *impl = NULL;
1393             UINT len, matchingIndex = 0;
1394
1395             TRACE("%s\n", SnmpUtilOidToA(&pVarBindList->list[i].name));
1396             /* Search for an implementation matching as many octets as possible
1397              */
1398             for (len = pVarBindList->list[i].name.idLength;
1399                 len >= minSupportedIDLength && !impl; len--)
1400                 impl = findSupportedQuery(pVarBindList->list[i].name.ids, len,
1401                     &matchingIndex);
1402             if (impl && impl->query)
1403                 ret = impl->query(bPduType, &pVarBindList->list[i], &error);
1404             else
1405                 error = SNMP_ERRORSTATUS_NOSUCHNAME;
1406             if (error == SNMP_ERRORSTATUS_NOSUCHNAME &&
1407                 bPduType == SNMP_PDU_GETNEXT)
1408             {
1409                 /* GetNext is special: it finds the successor to the given OID,
1410                  * so we have to continue until an implementation handles the
1411                  * query or we exhaust the table of supported OIDs.
1412                  */
1413                 for (matchingIndex++; error == SNMP_ERRORSTATUS_NOSUCHNAME &&
1414                     matchingIndex < DEFINE_SIZEOF(supportedIDs);
1415                     matchingIndex++)
1416                 {
1417                     error = SNMP_ERRORSTATUS_NOERROR;
1418                     impl = &supportedIDs[matchingIndex];
1419                     if (impl->query)
1420                         ret = impl->query(bPduType, &pVarBindList->list[i],
1421                             &error);
1422                     else
1423                         error = SNMP_ERRORSTATUS_NOSUCHNAME;
1424                 }
1425                 /* If the query still isn't resolved, set the OID to the
1426                  * successor to the last entry in the table.
1427                  */
1428                 if (error == SNMP_ERRORSTATUS_NOSUCHNAME)
1429                 {
1430                     SnmpUtilOidFree(&pVarBindList->list[i].name);
1431                     ret = SnmpUtilOidCpy(&pVarBindList->list[i].name,
1432                         &supportedIDs[matchingIndex - 1].name);
1433                     pVarBindList->list[i].name.ids[
1434                         pVarBindList->list[i].name.idLength - 1] += 1;
1435                 }
1436             }
1437             if (error)
1438                 errorIndex = i + 1;
1439         }
1440     }
1441     *pErrorStatus = error;
1442     *pErrorIndex = errorIndex;
1443     return ret;
1444 }
1445
1446 /*****************************************************************************
1447  * DllMain [INETMIB1.@]
1448  */
1449 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1450 {
1451     TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
1452
1453     switch (fdwReason)
1454     {
1455         case DLL_PROCESS_ATTACH:
1456             DisableThreadLibraryCalls(hinstDLL);
1457             break;
1458         case DLL_PROCESS_DETACH:
1459             if (lpvReserved) break;
1460             cleanup();
1461             break;
1462     }
1463
1464     return TRUE;
1465 }