2 * Copyright 2008 Juan Lang
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.
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.
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
28 #include "wine/debug.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(inetmib1
);
35 static DWORD
copyInt(AsnAny
*value
, void *src
)
37 value
->asnType
= ASN_INTEGER
;
38 value
->asnValue
.number
= *(DWORD
*)src
;
39 return SNMP_ERRORSTATUS_NOERROR
;
42 static void setStringValue(AsnAny
*value
, BYTE type
, DWORD len
, BYTE
*str
)
46 strValue
.asnType
= type
;
47 strValue
.asnValue
.string
.stream
= str
;
48 strValue
.asnValue
.string
.length
= len
;
49 strValue
.asnValue
.string
.dynamic
= FALSE
;
50 SnmpUtilAsnAnyCpy(value
, &strValue
);
53 typedef DWORD (*copyValueFunc
)(AsnAny
*value
, void *src
);
55 struct structToAsnValue
61 static AsnInteger32
mapStructEntryToValue(struct structToAsnValue
*map
,
62 UINT mapLen
, void *record
, UINT id
, SnmpVarBind
*pVarBind
)
64 /* OIDs are 1-based */
66 return SNMP_ERRORSTATUS_NOSUCHNAME
;
69 return SNMP_ERRORSTATUS_NOSUCHNAME
;
71 return SNMP_ERRORSTATUS_NOSUCHNAME
;
72 return map
[id
].copy(&pVarBind
->value
, (BYTE
*)record
+ map
[id
].offset
);
75 static DWORD
copyIpAddr(AsnAny
*value
, void *src
)
77 setStringValue(value
, ASN_IPADDRESS
, sizeof(DWORD
), src
);
78 return SNMP_ERRORSTATUS_NOERROR
;
81 static UINT mib2
[] = { 1,3,6,1,2,1 };
82 static UINT mib2System
[] = { 1,3,6,1,2,1,1 };
84 typedef BOOL (*varqueryfunc
)(BYTE bPduType
, SnmpVarBind
*pVarBind
,
85 AsnInteger32
*pErrorStatus
);
87 struct mibImplementation
89 AsnObjectIdentifier name
;
92 void (*cleanup
)(void);
95 static UINT mib2IfNumber
[] = { 1,3,6,1,2,1,2,1 };
96 static PMIB_IFTABLE ifTable
;
98 static void mib2IfNumberInit(void)
100 DWORD size
= 0, ret
= GetIfTable(NULL
, &size
, FALSE
);
102 if (ret
== ERROR_INSUFFICIENT_BUFFER
)
104 MIB_IFTABLE
*table
= HeapAlloc(GetProcessHeap(), 0, size
);
107 if (!GetIfTable(table
, &size
, FALSE
)) ifTable
= table
;
108 else HeapFree(GetProcessHeap(), 0, table
);
113 static void mib2IfNumberCleanup(void)
115 HeapFree(GetProcessHeap(), 0, ifTable
);
118 static BOOL
mib2IfNumberQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
119 AsnInteger32
*pErrorStatus
)
121 AsnObjectIdentifier numberOid
= DEFINE_OID(mib2IfNumber
);
124 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
130 case SNMP_PDU_GETNEXT
:
131 if ((bPduType
== SNMP_PDU_GET
&&
132 !SnmpUtilOidNCmp(&pVarBind
->name
, &numberOid
, numberOid
.idLength
))
133 || SnmpUtilOidNCmp(&pVarBind
->name
, &numberOid
, numberOid
.idLength
)
136 DWORD numIfs
= ifTable
? ifTable
->dwNumEntries
: 0;
138 copyInt(&pVarBind
->value
, &numIfs
);
139 if (bPduType
== SNMP_PDU_GETNEXT
)
141 SnmpUtilOidFree(&pVarBind
->name
);
142 SnmpUtilOidCpy(&pVarBind
->name
, &numberOid
);
144 *pErrorStatus
= SNMP_ERRORSTATUS_NOERROR
;
148 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
149 /* Caller deals with OID if bPduType == SNMP_PDU_GETNEXT, so don't
150 * need to set it here.
155 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
159 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
160 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
165 static DWORD
copyOperStatus(AsnAny
*value
, void *src
)
167 value
->asnType
= ASN_INTEGER
;
168 /* The IPHlpApi definition of operational status differs from the MIB2 one,
169 * so map it to the MIB2 value.
171 switch (*(DWORD
*)src
)
173 case MIB_IF_OPER_STATUS_OPERATIONAL
:
174 value
->asnValue
.number
= MIB_IF_ADMIN_STATUS_UP
;
176 case MIB_IF_OPER_STATUS_CONNECTING
:
177 case MIB_IF_OPER_STATUS_CONNECTED
:
178 value
->asnValue
.number
= MIB_IF_ADMIN_STATUS_TESTING
;
181 value
->asnValue
.number
= MIB_IF_ADMIN_STATUS_DOWN
;
183 return SNMP_ERRORSTATUS_NOERROR
;
186 /* Given an OID and a base OID that it must begin with, finds the item and
187 * integer instance from the OID. E.g., given an OID foo.1.2 and a base OID
188 * foo, returns item 1 and instance 2.
189 * If bPduType is not SNMP_PDU_GETNEXT and either the item or instance is
190 * missing, returns SNMP_ERRORSTATUS_NOSUCHNAME.
191 * If bPduType is SNMP_PDU_GETNEXT, returns the successor to the item and
192 * instance, or item 1, instance 1 if either is missing.
194 static AsnInteger32
getItemAndIntegerInstanceFromOid(AsnObjectIdentifier
*oid
,
195 AsnObjectIdentifier
*base
, BYTE bPduType
, UINT
*item
, UINT
*instance
)
197 AsnInteger32 ret
= SNMP_ERRORSTATUS_NOERROR
;
201 case SNMP_PDU_GETNEXT
:
202 if (SnmpUtilOidNCmp(oid
, base
, base
->idLength
) < 0)
207 else if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
))
209 if (oid
->idLength
== base
->idLength
||
210 oid
->idLength
== base
->idLength
+ 1)
212 /* Either the table or an item within the table is specified,
213 * but the instance is not. Get the first instance.
216 if (oid
->idLength
== base
->idLength
+ 1)
217 *item
= oid
->ids
[base
->idLength
];
223 *item
= oid
->ids
[base
->idLength
];
224 *instance
= oid
->ids
[base
->idLength
+ 1] + 1;
228 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
231 if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
))
233 if (oid
->idLength
== base
->idLength
||
234 oid
->idLength
== base
->idLength
+ 1)
236 /* Either the table or an item within the table is specified,
237 * but the instance is not.
239 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
243 *item
= oid
->ids
[base
->idLength
];
244 *instance
= oid
->ids
[base
->idLength
+ 1];
248 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
253 /* Given an OID and a base OID that it must begin with, finds the item from the
254 * OID. E.g., given an OID foo.1 and a base OID foo, returns item 1.
255 * If bPduType is not SNMP_PDU_GETNEXT and the item is missing, returns
256 * SNMP_ERRORSTATUS_NOSUCHNAME.
257 * If bPduType is SNMP_PDU_GETNEXT, returns the successor to the item, or item
258 * 1 if the item is missing.
260 static AsnInteger32
getItemFromOid(AsnObjectIdentifier
*oid
,
261 AsnObjectIdentifier
*base
, BYTE bPduType
, UINT
*item
)
263 AsnInteger32 ret
= SNMP_ERRORSTATUS_NOERROR
;
267 case SNMP_PDU_GETNEXT
:
268 if (SnmpUtilOidNCmp(oid
, base
, base
->idLength
) < 0)
270 else if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
))
272 if (oid
->idLength
== base
->idLength
)
274 /* The item is missing, assume the first item */
278 *item
= oid
->ids
[base
->idLength
] + 1;
281 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
284 if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
))
286 if (oid
->idLength
== base
->idLength
)
288 /* The item is missing */
289 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
293 *item
= oid
->ids
[base
->idLength
];
295 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
299 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
310 static DWORD
oidToIpAddr(AsnObjectIdentifier
*oid
)
312 assert(oid
&& oid
->idLength
>= 4);
313 /* Map the IDs to an IP address in little-endian order */
314 return (BYTE
)oid
->ids
[3] << 24 | (BYTE
)oid
->ids
[2] << 16 |
315 (BYTE
)oid
->ids
[1] << 8 | (BYTE
)oid
->ids
[0];
318 typedef void (*oidToKeyFunc
)(AsnObjectIdentifier
*oid
, void *dst
);
319 typedef int (*compareFunc
)(const void *key
, const void *value
);
321 /* Finds the first value in the table that matches key. Returns its 1-based
322 * index if found, or 0 if not found.
324 static UINT
findValueInTable(const void *key
,
325 struct GenericTable
*table
, size_t tableEntrySize
, compareFunc compare
)
330 value
= bsearch(key
, table
->entries
, table
->numEntries
, tableEntrySize
,
333 index
= ((BYTE
*)value
- (BYTE
*)table
->entries
) / tableEntrySize
+ 1;
337 /* Finds the first value in the table that matches oid, using makeKey to
338 * convert the oid to a key for comparison. Returns the value's 1-based
339 * index if found, or 0 if not found.
341 static UINT
findOidInTable(AsnObjectIdentifier
*oid
,
342 struct GenericTable
*table
, size_t tableEntrySize
, oidToKeyFunc makeKey
,
346 void *key
= HeapAlloc(GetProcessHeap(), 0, tableEntrySize
);
351 index
= findValueInTable(key
, table
, tableEntrySize
, compare
);
352 HeapFree(GetProcessHeap(), 0, key
);
357 /* Finds the first successor to the value in the table that does matches oid,
358 * using makeKey to convert the oid to a key for comparison. A successor is
359 * a value that does not match oid, so if multiple entries match an oid, only
360 * the first will ever be returned using this method.
361 * Returns the successor's 1-based index if found, or 0 if not found.
363 static UINT
findNextOidInTable(AsnObjectIdentifier
*oid
,
364 struct GenericTable
*table
, size_t tableEntrySize
, oidToKeyFunc makeKey
,
368 void *key
= HeapAlloc(GetProcessHeap(), 0, tableEntrySize
);
373 index
= findValueInTable(key
, table
, tableEntrySize
, compare
);
376 /* Not found in table. If it's less than the first entry, return
377 * the first index. Otherwise just return 0 and let the caller
378 * handle finding the successor.
380 if (compare(key
, table
->entries
) < 0)
385 /* Skip any entries that match the same key. This enumeration will
386 * be incomplete, but it's what Windows appears to do if there are
387 * multiple entries with the same index in a table, and it avoids
390 for (++index
; index
<= table
->numEntries
&& compare(key
,
391 &table
->entries
[tableEntrySize
* (index
- 1)]) == 0; ++index
)
394 HeapFree(GetProcessHeap(), 0, key
);
399 /* Given an OID and a base OID that it must begin with, finds the item and
400 * element of the table whose value matches the instance from the OID.
401 * The OID is converted to a key with the function makeKey, and compared
402 * against entries in the table with the function compare.
403 * If bPduType is not SNMP_PDU_GETNEXT and either the item or instance is
404 * missing, returns SNMP_ERRORSTATUS_NOSUCHNAME.
405 * If bPduType is SNMP_PDU_GETNEXT, returns the successor to the item and
406 * instance, or item 1, instance 1 if either is missing.
408 static AsnInteger32
getItemAndInstanceFromTable(AsnObjectIdentifier
*oid
,
409 AsnObjectIdentifier
*base
, UINT instanceLen
, BYTE bPduType
,
410 struct GenericTable
*table
, size_t tableEntrySize
, oidToKeyFunc makeKey
,
411 compareFunc compare
, UINT
*item
, UINT
*instance
)
413 AsnInteger32 ret
= SNMP_ERRORSTATUS_NOERROR
;
416 return SNMP_ERRORSTATUS_NOSUCHNAME
;
420 case SNMP_PDU_GETNEXT
:
421 if (SnmpUtilOidNCmp(oid
, base
, base
->idLength
) < 0)
423 /* Return the first item and instance from the table */
427 else if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
) &&
428 oid
->idLength
< base
->idLength
+ instanceLen
+ 1)
430 /* Either the table or an item is specified, but the instance is
434 if (oid
->idLength
>= base
->idLength
+ 1)
436 *item
= oid
->ids
[base
->idLength
];
443 else if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
) &&
444 oid
->idLength
== base
->idLength
+ instanceLen
+ 1)
446 *item
= oid
->ids
[base
->idLength
];
454 AsnObjectIdentifier instanceOid
= { instanceLen
,
455 oid
->ids
+ base
->idLength
+ 1 };
457 *instance
= findNextOidInTable(&instanceOid
, table
,
458 tableEntrySize
, makeKey
, compare
);
459 if (!*instance
|| *instance
> table
->numEntries
)
460 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
464 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
467 if (!SnmpUtilOidNCmp(oid
, base
, base
->idLength
) &&
468 oid
->idLength
== base
->idLength
+ instanceLen
+ 1)
470 *item
= oid
->ids
[base
->idLength
];
472 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
475 AsnObjectIdentifier instanceOid
= { instanceLen
,
476 oid
->ids
+ base
->idLength
+ 1 };
478 *instance
= findOidInTable(&instanceOid
, table
, tableEntrySize
,
481 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
485 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
490 static INT
setOidWithItem(AsnObjectIdentifier
*dst
, AsnObjectIdentifier
*base
,
494 AsnObjectIdentifier oid
;
497 SnmpUtilOidFree(dst
);
498 ret
= SnmpUtilOidCpy(dst
, base
);
504 ret
= SnmpUtilOidAppend(dst
, &oid
);
509 static INT
setOidWithItemAndIpAddr(AsnObjectIdentifier
*dst
,
510 AsnObjectIdentifier
*base
, UINT item
, DWORD addr
)
514 AsnObjectIdentifier oid
;
517 ret
= setOidWithItem(dst
, base
, item
);
522 for (ptr
= (BYTE
*)&addr
; ret
&& ptr
< (BYTE
*)&addr
+ sizeof(DWORD
);
526 ret
= SnmpUtilOidAppend(dst
, &oid
);
532 static INT
setOidWithItemAndInteger(AsnObjectIdentifier
*dst
,
533 AsnObjectIdentifier
*base
, UINT item
, UINT instance
)
535 AsnObjectIdentifier oid
;
538 ret
= setOidWithItem(dst
, base
, item
);
543 ret
= SnmpUtilOidAppend(dst
, &oid
);
548 static DWORD
copyIfRowDescr(AsnAny
*value
, void *src
)
550 PMIB_IFROW row
= (PMIB_IFROW
)((BYTE
*)src
-
551 FIELD_OFFSET(MIB_IFROW
, dwDescrLen
));
556 setStringValue(value
, ASN_OCTETSTRING
, row
->dwDescrLen
, row
->bDescr
);
557 ret
= SNMP_ERRORSTATUS_NOERROR
;
560 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
564 static DWORD
copyIfRowPhysAddr(AsnAny
*value
, void *src
)
566 PMIB_IFROW row
= (PMIB_IFROW
)((BYTE
*)src
-
567 FIELD_OFFSET(MIB_IFROW
, dwPhysAddrLen
));
570 if (row
->dwPhysAddrLen
)
572 setStringValue(value
, ASN_OCTETSTRING
, row
->dwPhysAddrLen
,
574 ret
= SNMP_ERRORSTATUS_NOERROR
;
577 ret
= SNMP_ERRORSTATUS_NOSUCHNAME
;
581 static struct structToAsnValue mib2IfEntryMap
[] = {
582 { FIELD_OFFSET(MIB_IFROW
, dwIndex
), copyInt
},
583 { FIELD_OFFSET(MIB_IFROW
, dwDescrLen
), copyIfRowDescr
},
584 { FIELD_OFFSET(MIB_IFROW
, dwType
), copyInt
},
585 { FIELD_OFFSET(MIB_IFROW
, dwMtu
), copyInt
},
586 { FIELD_OFFSET(MIB_IFROW
, dwSpeed
), copyInt
},
587 { FIELD_OFFSET(MIB_IFROW
, dwPhysAddrLen
), copyIfRowPhysAddr
},
588 { FIELD_OFFSET(MIB_IFROW
, dwAdminStatus
), copyInt
},
589 { FIELD_OFFSET(MIB_IFROW
, dwOperStatus
), copyOperStatus
},
590 { FIELD_OFFSET(MIB_IFROW
, dwLastChange
), copyInt
},
591 { FIELD_OFFSET(MIB_IFROW
, dwInOctets
), copyInt
},
592 { FIELD_OFFSET(MIB_IFROW
, dwInUcastPkts
), copyInt
},
593 { FIELD_OFFSET(MIB_IFROW
, dwInNUcastPkts
), copyInt
},
594 { FIELD_OFFSET(MIB_IFROW
, dwInDiscards
), copyInt
},
595 { FIELD_OFFSET(MIB_IFROW
, dwInErrors
), copyInt
},
596 { FIELD_OFFSET(MIB_IFROW
, dwInUnknownProtos
), copyInt
},
597 { FIELD_OFFSET(MIB_IFROW
, dwOutOctets
), copyInt
},
598 { FIELD_OFFSET(MIB_IFROW
, dwOutUcastPkts
), copyInt
},
599 { FIELD_OFFSET(MIB_IFROW
, dwOutNUcastPkts
), copyInt
},
600 { FIELD_OFFSET(MIB_IFROW
, dwOutDiscards
), copyInt
},
601 { FIELD_OFFSET(MIB_IFROW
, dwOutErrors
), copyInt
},
602 { FIELD_OFFSET(MIB_IFROW
, dwOutQLen
), copyInt
},
605 static UINT mib2IfEntry
[] = { 1,3,6,1,2,1,2,2,1 };
607 static BOOL
mib2IfEntryQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
608 AsnInteger32
*pErrorStatus
)
610 AsnObjectIdentifier entryOid
= DEFINE_OID(mib2IfEntry
);
613 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
619 case SNMP_PDU_GETNEXT
:
622 /* There is no interface present, so let the caller deal
623 * with finding the successor.
625 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
629 UINT tableIndex
= 0, item
= 0;
631 *pErrorStatus
= getItemAndIntegerInstanceFromOid(&pVarBind
->name
,
632 &entryOid
, bPduType
, &item
, &tableIndex
);
637 if (tableIndex
> ifTable
->dwNumEntries
)
638 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
641 *pErrorStatus
= mapStructEntryToValue(mib2IfEntryMap
,
642 DEFINE_SIZEOF(mib2IfEntryMap
),
643 &ifTable
->table
[tableIndex
- 1], item
,
645 if (bPduType
== SNMP_PDU_GETNEXT
)
646 ret
= setOidWithItemAndInteger(&pVarBind
->name
,
647 &entryOid
, item
, tableIndex
);
653 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
657 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
658 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
663 static UINT mib2Ip
[] = { 1,3,6,1,2,1,4 };
664 static MIB_IPSTATS ipStats
;
666 static void mib2IpStatsInit(void)
668 GetIpStatistics(&ipStats
);
671 static struct structToAsnValue mib2IpMap
[] = {
672 { FIELD_OFFSET(MIB_IPSTATS
, dwForwarding
), copyInt
}, /* 1 */
673 { FIELD_OFFSET(MIB_IPSTATS
, dwDefaultTTL
), copyInt
}, /* 2 */
674 { FIELD_OFFSET(MIB_IPSTATS
, dwInReceives
), copyInt
}, /* 3 */
675 { FIELD_OFFSET(MIB_IPSTATS
, dwInHdrErrors
), copyInt
}, /* 4 */
676 { FIELD_OFFSET(MIB_IPSTATS
, dwInAddrErrors
), copyInt
}, /* 5 */
677 { FIELD_OFFSET(MIB_IPSTATS
, dwForwDatagrams
), copyInt
}, /* 6 */
678 { FIELD_OFFSET(MIB_IPSTATS
, dwInUnknownProtos
), copyInt
}, /* 7 */
679 { FIELD_OFFSET(MIB_IPSTATS
, dwInDiscards
), copyInt
}, /* 8 */
680 { FIELD_OFFSET(MIB_IPSTATS
, dwInDelivers
), copyInt
}, /* 9 */
681 { FIELD_OFFSET(MIB_IPSTATS
, dwOutRequests
), copyInt
}, /* 10 */
682 { FIELD_OFFSET(MIB_IPSTATS
, dwOutDiscards
), copyInt
}, /* 11 */
683 { FIELD_OFFSET(MIB_IPSTATS
, dwOutNoRoutes
), copyInt
}, /* 12 */
684 { FIELD_OFFSET(MIB_IPSTATS
, dwReasmTimeout
), copyInt
}, /* 13 */
685 { FIELD_OFFSET(MIB_IPSTATS
, dwReasmReqds
), copyInt
}, /* 14 */
686 { FIELD_OFFSET(MIB_IPSTATS
, dwReasmOks
), copyInt
}, /* 15 */
687 { FIELD_OFFSET(MIB_IPSTATS
, dwReasmFails
), copyInt
}, /* 16 */
688 { FIELD_OFFSET(MIB_IPSTATS
, dwFragOks
), copyInt
}, /* 17 */
689 { FIELD_OFFSET(MIB_IPSTATS
, dwFragFails
), copyInt
}, /* 18 */
690 { FIELD_OFFSET(MIB_IPSTATS
, dwFragCreates
), copyInt
}, /* 19 */
691 { 0, NULL
}, /* 20: not used, IP addr table */
692 { 0, NULL
}, /* 21: not used, route table */
693 { 0, NULL
}, /* 22: not used, net to media (ARP) table */
694 { FIELD_OFFSET(MIB_IPSTATS
, dwRoutingDiscards
), copyInt
}, /* 23 */
697 static BOOL
mib2IpStatsQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
698 AsnInteger32
*pErrorStatus
)
700 AsnObjectIdentifier myOid
= DEFINE_OID(mib2Ip
);
704 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
710 case SNMP_PDU_GETNEXT
:
711 *pErrorStatus
= getItemFromOid(&pVarBind
->name
, &myOid
, bPduType
,
715 *pErrorStatus
= mapStructEntryToValue(mib2IpMap
,
716 DEFINE_SIZEOF(mib2IpMap
), &ipStats
, item
, pVarBind
);
717 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
718 ret
= setOidWithItem(&pVarBind
->name
, &myOid
, item
);
722 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
726 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
727 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
732 static UINT mib2IpAddr
[] = { 1,3,6,1,2,1,4,20,1 };
733 static PMIB_IPADDRTABLE ipAddrTable
;
735 static struct structToAsnValue mib2IpAddrMap
[] = {
736 { FIELD_OFFSET(MIB_IPADDRROW
, dwAddr
), copyIpAddr
},
737 { FIELD_OFFSET(MIB_IPADDRROW
, dwIndex
), copyInt
},
738 { FIELD_OFFSET(MIB_IPADDRROW
, dwMask
), copyIpAddr
},
739 { FIELD_OFFSET(MIB_IPADDRROW
, dwBCastAddr
), copyInt
},
740 { FIELD_OFFSET(MIB_IPADDRROW
, dwReasmSize
), copyInt
},
743 static void mib2IpAddrInit(void)
745 DWORD size
= 0, ret
= GetIpAddrTable(NULL
, &size
, TRUE
);
747 if (ret
== ERROR_INSUFFICIENT_BUFFER
)
749 MIB_IPADDRTABLE
*table
= HeapAlloc(GetProcessHeap(), 0, size
);
752 if (!GetIpAddrTable(table
, &size
, TRUE
)) ipAddrTable
= table
;
753 else HeapFree(GetProcessHeap(), 0, table
);
758 static void mib2IpAddrCleanup(void)
760 HeapFree(GetProcessHeap(), 0, ipAddrTable
);
763 static void oidToIpAddrRow(AsnObjectIdentifier
*oid
, void *dst
)
765 MIB_IPADDRROW
*row
= dst
;
767 row
->dwAddr
= oidToIpAddr(oid
);
770 static int compareIpAddrRow(const void *a
, const void *b
)
772 const MIB_IPADDRROW
*key
= a
, *value
= b
;
774 return key
->dwAddr
- value
->dwAddr
;
777 static BOOL
mib2IpAddrQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
778 AsnInteger32
*pErrorStatus
)
780 AsnObjectIdentifier myOid
= DEFINE_OID(mib2IpAddr
);
781 UINT tableIndex
= 0, item
= 0;
784 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
790 case SNMP_PDU_GETNEXT
:
791 *pErrorStatus
= getItemAndInstanceFromTable(&pVarBind
->name
,
792 &myOid
, 4, bPduType
, (struct GenericTable
*)ipAddrTable
,
793 sizeof(MIB_IPADDRROW
), oidToIpAddrRow
, compareIpAddrRow
, &item
,
799 *pErrorStatus
= mapStructEntryToValue(mib2IpAddrMap
,
800 DEFINE_SIZEOF(mib2IpAddrMap
),
801 &ipAddrTable
->table
[tableIndex
- 1], item
, pVarBind
);
802 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
803 ret
= setOidWithItemAndIpAddr(&pVarBind
->name
, &myOid
, item
,
804 ipAddrTable
->table
[tableIndex
- 1].dwAddr
);
808 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
812 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
813 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
818 static UINT mib2IpRoute
[] = { 1,3,6,1,2,1,4,21,1 };
819 static PMIB_IPFORWARDTABLE ipRouteTable
;
821 static struct structToAsnValue mib2IpRouteMap
[] = {
822 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardDest
), copyIpAddr
},
823 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardIfIndex
), copyInt
},
824 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardMetric1
), copyInt
},
825 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardMetric2
), copyInt
},
826 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardMetric3
), copyInt
},
827 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardMetric4
), copyInt
},
828 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardNextHop
), copyIpAddr
},
829 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardType
), copyInt
},
830 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardProto
), copyInt
},
831 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardAge
), copyInt
},
832 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardMask
), copyIpAddr
},
833 { FIELD_OFFSET(MIB_IPFORWARDROW
, dwForwardMetric5
), copyInt
},
836 static void mib2IpRouteInit(void)
838 DWORD size
= 0, ret
= GetIpForwardTable(NULL
, &size
, TRUE
);
840 if (ret
== ERROR_INSUFFICIENT_BUFFER
)
842 MIB_IPFORWARDTABLE
*table
= HeapAlloc(GetProcessHeap(), 0, size
);
845 if (!GetIpForwardTable(table
, &size
, TRUE
)) ipRouteTable
= table
;
846 else HeapFree(GetProcessHeap(), 0, table
);
851 static void mib2IpRouteCleanup(void)
853 HeapFree(GetProcessHeap(), 0, ipRouteTable
);
856 static void oidToIpForwardRow(AsnObjectIdentifier
*oid
, void *dst
)
858 MIB_IPFORWARDROW
*row
= dst
;
860 row
->dwForwardDest
= oidToIpAddr(oid
);
863 static int compareIpForwardRow(const void *a
, const void *b
)
865 const MIB_IPFORWARDROW
*key
= a
, *value
= b
;
867 return key
->dwForwardDest
- value
->dwForwardDest
;
870 static BOOL
mib2IpRouteQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
871 AsnInteger32
*pErrorStatus
)
873 AsnObjectIdentifier myOid
= DEFINE_OID(mib2IpRoute
);
874 UINT tableIndex
= 0, item
= 0;
877 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
883 case SNMP_PDU_GETNEXT
:
884 *pErrorStatus
= getItemAndInstanceFromTable(&pVarBind
->name
,
885 &myOid
, 4, bPduType
, (struct GenericTable
*)ipRouteTable
,
886 sizeof(MIB_IPFORWARDROW
), oidToIpForwardRow
, compareIpForwardRow
,
892 *pErrorStatus
= mapStructEntryToValue(mib2IpRouteMap
,
893 DEFINE_SIZEOF(mib2IpRouteMap
),
894 &ipRouteTable
->table
[tableIndex
- 1], item
, pVarBind
);
895 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
896 ret
= setOidWithItemAndIpAddr(&pVarBind
->name
, &myOid
, item
,
897 ipRouteTable
->table
[tableIndex
- 1].dwForwardDest
);
901 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
905 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
906 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
911 static UINT mib2IpNet
[] = { 1,3,6,1,2,1,4,22,1 };
912 static PMIB_IPNETTABLE ipNetTable
;
914 static DWORD
copyIpNetPhysAddr(AsnAny
*value
, void *src
)
916 PMIB_IPNETROW row
= (PMIB_IPNETROW
)((BYTE
*)src
- FIELD_OFFSET(MIB_IPNETROW
,
919 setStringValue(value
, ASN_OCTETSTRING
, row
->dwPhysAddrLen
, row
->bPhysAddr
);
920 return SNMP_ERRORSTATUS_NOERROR
;
923 static struct structToAsnValue mib2IpNetMap
[] = {
924 { FIELD_OFFSET(MIB_IPNETROW
, dwIndex
), copyInt
},
925 { FIELD_OFFSET(MIB_IPNETROW
, dwPhysAddrLen
), copyIpNetPhysAddr
},
926 { FIELD_OFFSET(MIB_IPNETROW
, dwAddr
), copyIpAddr
},
927 { FIELD_OFFSET(MIB_IPNETROW
, dwType
), copyInt
},
930 static void mib2IpNetInit(void)
932 DWORD size
= 0, ret
= GetIpNetTable(NULL
, &size
, FALSE
);
934 if (ret
== ERROR_INSUFFICIENT_BUFFER
)
936 MIB_IPNETTABLE
*table
= HeapAlloc(GetProcessHeap(), 0, size
);
939 if (!GetIpNetTable(table
, &size
, FALSE
)) ipNetTable
= table
;
940 else HeapFree(GetProcessHeap(), 0, table
);
945 static void mib2IpNetCleanup(void)
947 HeapFree(GetProcessHeap(), 0, ipNetTable
);
950 static BOOL
mib2IpNetQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
951 AsnInteger32
*pErrorStatus
)
953 AsnObjectIdentifier myOid
= DEFINE_OID(mib2IpNet
);
956 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
962 case SNMP_PDU_GETNEXT
:
964 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
967 UINT tableIndex
= 0, item
= 0;
969 *pErrorStatus
= getItemAndIntegerInstanceFromOid(&pVarBind
->name
,
970 &myOid
, bPduType
, &item
, &tableIndex
);
975 if (tableIndex
> ipNetTable
->dwNumEntries
)
976 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
979 *pErrorStatus
= mapStructEntryToValue(mib2IpNetMap
,
980 DEFINE_SIZEOF(mib2IpNetMap
),
981 &ipNetTable
[tableIndex
- 1], item
, pVarBind
);
982 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
983 ret
= setOidWithItemAndInteger(&pVarBind
->name
, &myOid
,
990 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
994 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
995 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1000 static UINT mib2Icmp
[] = { 1,3,6,1,2,1,5 };
1001 static MIB_ICMP icmpStats
;
1003 static void mib2IcmpInit(void)
1005 GetIcmpStatistics(&icmpStats
);
1008 static struct structToAsnValue mib2IcmpMap
[] = {
1009 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwMsgs
), copyInt
},
1010 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwErrors
), copyInt
},
1011 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwDestUnreachs
), copyInt
},
1012 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwTimeExcds
), copyInt
},
1013 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwParmProbs
), copyInt
},
1014 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwSrcQuenchs
), copyInt
},
1015 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwRedirects
), copyInt
},
1016 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwEchos
), copyInt
},
1017 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwEchoReps
), copyInt
},
1018 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwTimestamps
), copyInt
},
1019 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwTimestampReps
), copyInt
},
1020 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwAddrMasks
), copyInt
},
1021 { FIELD_OFFSET(MIBICMPINFO
, icmpInStats
.dwAddrMaskReps
), copyInt
},
1022 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwMsgs
), copyInt
},
1023 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwErrors
), copyInt
},
1024 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwDestUnreachs
), copyInt
},
1025 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwTimeExcds
), copyInt
},
1026 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwParmProbs
), copyInt
},
1027 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwSrcQuenchs
), copyInt
},
1028 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwRedirects
), copyInt
},
1029 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwEchos
), copyInt
},
1030 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwEchoReps
), copyInt
},
1031 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwTimestamps
), copyInt
},
1032 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwTimestampReps
), copyInt
},
1033 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwAddrMasks
), copyInt
},
1034 { FIELD_OFFSET(MIBICMPINFO
, icmpOutStats
.dwAddrMaskReps
), copyInt
},
1037 static BOOL
mib2IcmpQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
1038 AsnInteger32
*pErrorStatus
)
1040 AsnObjectIdentifier myOid
= DEFINE_OID(mib2Icmp
);
1044 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
1050 case SNMP_PDU_GETNEXT
:
1051 *pErrorStatus
= getItemFromOid(&pVarBind
->name
, &myOid
, bPduType
,
1055 *pErrorStatus
= mapStructEntryToValue(mib2IcmpMap
,
1056 DEFINE_SIZEOF(mib2IcmpMap
), &icmpStats
, item
,
1058 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
1059 ret
= setOidWithItem(&pVarBind
->name
, &myOid
, item
);
1063 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
1067 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
1068 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1073 static UINT mib2Tcp
[] = { 1,3,6,1,2,1,6 };
1074 static MIB_TCPSTATS tcpStats
;
1076 static void mib2TcpInit(void)
1078 GetTcpStatistics(&tcpStats
);
1081 static struct structToAsnValue mib2TcpMap
[] = {
1082 { FIELD_OFFSET(MIB_TCPSTATS
, dwRtoAlgorithm
), copyInt
},
1083 { FIELD_OFFSET(MIB_TCPSTATS
, dwRtoMin
), copyInt
},
1084 { FIELD_OFFSET(MIB_TCPSTATS
, dwRtoMax
), copyInt
},
1085 { FIELD_OFFSET(MIB_TCPSTATS
, dwMaxConn
), copyInt
},
1086 { FIELD_OFFSET(MIB_TCPSTATS
, dwActiveOpens
), copyInt
},
1087 { FIELD_OFFSET(MIB_TCPSTATS
, dwPassiveOpens
), copyInt
},
1088 { FIELD_OFFSET(MIB_TCPSTATS
, dwAttemptFails
), copyInt
},
1089 { FIELD_OFFSET(MIB_TCPSTATS
, dwEstabResets
), copyInt
},
1090 { FIELD_OFFSET(MIB_TCPSTATS
, dwCurrEstab
), copyInt
},
1091 { FIELD_OFFSET(MIB_TCPSTATS
, dwInSegs
), copyInt
},
1092 { FIELD_OFFSET(MIB_TCPSTATS
, dwOutSegs
), copyInt
},
1093 { FIELD_OFFSET(MIB_TCPSTATS
, dwRetransSegs
), copyInt
},
1094 { FIELD_OFFSET(MIB_TCPSTATS
, dwInErrs
), copyInt
},
1095 { FIELD_OFFSET(MIB_TCPSTATS
, dwOutRsts
), copyInt
},
1096 { FIELD_OFFSET(MIB_TCPSTATS
, dwNumConns
), copyInt
},
1099 static BOOL
mib2TcpQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
1100 AsnInteger32
*pErrorStatus
)
1102 AsnObjectIdentifier myOid
= DEFINE_OID(mib2Tcp
);
1106 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
1112 case SNMP_PDU_GETNEXT
:
1113 *pErrorStatus
= getItemFromOid(&pVarBind
->name
, &myOid
, bPduType
,
1117 *pErrorStatus
= mapStructEntryToValue(mib2TcpMap
,
1118 DEFINE_SIZEOF(mib2TcpMap
), &tcpStats
, item
, pVarBind
);
1119 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
1120 ret
= setOidWithItem(&pVarBind
->name
, &myOid
, item
);
1124 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
1128 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
1129 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1134 static UINT mib2Udp
[] = { 1,3,6,1,2,1,7 };
1135 static MIB_UDPSTATS udpStats
;
1137 static void mib2UdpInit(void)
1139 GetUdpStatistics(&udpStats
);
1142 static struct structToAsnValue mib2UdpMap
[] = {
1143 { FIELD_OFFSET(MIB_UDPSTATS
, dwInDatagrams
), copyInt
},
1144 { FIELD_OFFSET(MIB_UDPSTATS
, dwNoPorts
), copyInt
},
1145 { FIELD_OFFSET(MIB_UDPSTATS
, dwInErrors
), copyInt
},
1146 { FIELD_OFFSET(MIB_UDPSTATS
, dwOutDatagrams
), copyInt
},
1149 static BOOL
mib2UdpQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
1150 AsnInteger32
*pErrorStatus
)
1152 AsnObjectIdentifier myOid
= DEFINE_OID(mib2Udp
);
1156 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
1162 case SNMP_PDU_GETNEXT
:
1163 *pErrorStatus
= getItemFromOid(&pVarBind
->name
, &myOid
, bPduType
,
1167 *pErrorStatus
= mapStructEntryToValue(mib2UdpMap
,
1168 DEFINE_SIZEOF(mib2UdpMap
), &udpStats
, item
, pVarBind
);
1169 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
1170 ret
= setOidWithItem(&pVarBind
->name
, &myOid
, item
);
1174 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
1178 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
1179 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1184 static UINT mib2UdpEntry
[] = { 1,3,6,1,2,1,7,5,1 };
1185 static PMIB_UDPTABLE udpTable
;
1187 static void mib2UdpEntryInit(void)
1189 DWORD size
= 0, ret
= GetUdpTable(NULL
, &size
, TRUE
);
1191 if (ret
== ERROR_INSUFFICIENT_BUFFER
)
1193 MIB_UDPTABLE
*table
= HeapAlloc(GetProcessHeap(), 0, size
);
1196 if (!GetUdpTable(table
, &size
, TRUE
)) udpTable
= table
;
1197 else HeapFree(GetProcessHeap(), 0, table
);
1202 static void mib2UdpEntryCleanup(void)
1204 HeapFree(GetProcessHeap(), 0, udpTable
);
1207 static struct structToAsnValue mib2UdpEntryMap
[] = {
1208 { FIELD_OFFSET(MIB_UDPROW
, dwLocalAddr
), copyIpAddr
},
1209 { FIELD_OFFSET(MIB_UDPROW
, dwLocalPort
), copyInt
},
1212 static void oidToUdpRow(AsnObjectIdentifier
*oid
, void *dst
)
1214 MIB_UDPROW
*row
= dst
;
1216 assert(oid
&& oid
->idLength
>= 5);
1217 row
->dwLocalAddr
= oidToIpAddr(oid
);
1218 row
->dwLocalPort
= oid
->ids
[4];
1221 static int compareUdpRow(const void *a
, const void *b
)
1223 const MIB_UDPROW
*key
= a
, *value
= b
;
1226 ret
= key
->dwLocalAddr
- value
->dwLocalAddr
;
1228 ret
= key
->dwLocalPort
- value
->dwLocalPort
;
1232 static BOOL
mib2UdpEntryQuery(BYTE bPduType
, SnmpVarBind
*pVarBind
,
1233 AsnInteger32
*pErrorStatus
)
1235 AsnObjectIdentifier myOid
= DEFINE_OID(mib2UdpEntry
);
1238 TRACE("(0x%02x, %s, %p)\n", bPduType
, SnmpUtilOidToA(&pVarBind
->name
),
1244 case SNMP_PDU_GETNEXT
:
1246 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1249 UINT tableIndex
= 0, item
= 0;
1251 *pErrorStatus
= getItemAndInstanceFromTable(&pVarBind
->name
, &myOid
,
1252 5, bPduType
, (struct GenericTable
*)udpTable
,
1253 sizeof(MIB_UDPROW
), oidToUdpRow
, compareUdpRow
, &item
,
1259 *pErrorStatus
= mapStructEntryToValue(mib2UdpEntryMap
,
1260 DEFINE_SIZEOF(mib2UdpEntryMap
),
1261 &udpTable
->table
[tableIndex
- 1], item
, pVarBind
);
1262 if (!*pErrorStatus
&& bPduType
== SNMP_PDU_GETNEXT
)
1264 AsnObjectIdentifier oid
;
1266 ret
= setOidWithItemAndIpAddr(&pVarBind
->name
, &myOid
, item
,
1267 udpTable
->table
[tableIndex
- 1].dwLocalAddr
);
1271 oid
.ids
= &udpTable
->table
[tableIndex
- 1].dwLocalPort
;
1272 ret
= SnmpUtilOidAppend(&pVarBind
->name
, &oid
);
1279 *pErrorStatus
= SNMP_ERRORSTATUS_READONLY
;
1283 FIXME("0x%02x: unsupported PDU type\n", bPduType
);
1284 *pErrorStatus
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1289 /* This list MUST BE lexicographically sorted */
1290 static struct mibImplementation supportedIDs
[] = {
1291 { DEFINE_OID(mib2IfNumber
), mib2IfNumberInit
, mib2IfNumberQuery
,
1292 mib2IfNumberCleanup
},
1293 { DEFINE_OID(mib2IfEntry
), NULL
, mib2IfEntryQuery
, NULL
},
1294 { DEFINE_OID(mib2Ip
), mib2IpStatsInit
, mib2IpStatsQuery
, NULL
},
1295 { DEFINE_OID(mib2IpAddr
), mib2IpAddrInit
, mib2IpAddrQuery
,
1296 mib2IpAddrCleanup
},
1297 { DEFINE_OID(mib2IpRoute
), mib2IpRouteInit
, mib2IpRouteQuery
,
1298 mib2IpRouteCleanup
},
1299 { DEFINE_OID(mib2IpNet
), mib2IpNetInit
, mib2IpNetQuery
, mib2IpNetCleanup
},
1300 { DEFINE_OID(mib2Icmp
), mib2IcmpInit
, mib2IcmpQuery
, NULL
},
1301 { DEFINE_OID(mib2Tcp
), mib2TcpInit
, mib2TcpQuery
, NULL
},
1302 { DEFINE_OID(mib2Udp
), mib2UdpInit
, mib2UdpQuery
, NULL
},
1303 { DEFINE_OID(mib2UdpEntry
), mib2UdpEntryInit
, mib2UdpEntryQuery
,
1304 mib2UdpEntryCleanup
},
1306 static UINT minSupportedIDLength
;
1308 /*****************************************************************************
1309 * SnmpExtensionInit [INETMIB1.@]
1311 BOOL WINAPI
SnmpExtensionInit(DWORD dwUptimeReference
,
1312 HANDLE
*phSubagentTrapEvent
, AsnObjectIdentifier
*pFirstSupportedRegion
)
1314 AsnObjectIdentifier myOid
= DEFINE_OID(mib2System
);
1317 TRACE("(%d, %p, %p)\n", dwUptimeReference
, phSubagentTrapEvent
,
1318 pFirstSupportedRegion
);
1320 minSupportedIDLength
= UINT_MAX
;
1321 for (i
= 0; i
< sizeof(supportedIDs
) / sizeof(supportedIDs
[0]); i
++)
1323 if (supportedIDs
[i
].init
)
1324 supportedIDs
[i
].init();
1325 if (supportedIDs
[i
].name
.idLength
< minSupportedIDLength
)
1326 minSupportedIDLength
= supportedIDs
[i
].name
.idLength
;
1328 *phSubagentTrapEvent
= NULL
;
1329 SnmpUtilOidCpy(pFirstSupportedRegion
, &myOid
);
1333 static void cleanup(void)
1337 for (i
= 0; i
< sizeof(supportedIDs
) / sizeof(supportedIDs
[0]); i
++)
1338 if (supportedIDs
[i
].cleanup
)
1339 supportedIDs
[i
].cleanup();
1342 static struct mibImplementation
*findSupportedQuery(UINT
*ids
, UINT idLength
,
1343 UINT
*matchingIndex
)
1345 int indexHigh
= DEFINE_SIZEOF(supportedIDs
) - 1, indexLow
= 0;
1346 AsnObjectIdentifier oid1
= { idLength
, ids
};
1351 while (indexLow
<= indexHigh
)
1353 INT cmp
, i
= (indexLow
+ indexHigh
) / 2;
1354 if (!(cmp
= SnmpUtilOidNCmp(&oid1
, &supportedIDs
[i
].name
, idLength
)))
1357 return &supportedIDs
[i
];
1367 /*****************************************************************************
1368 * SnmpExtensionQuery [INETMIB1.@]
1370 BOOL WINAPI
SnmpExtensionQuery(BYTE bPduType
, SnmpVarBindList
*pVarBindList
,
1371 AsnInteger32
*pErrorStatus
, AsnInteger32
*pErrorIndex
)
1373 AsnObjectIdentifier mib2oid
= DEFINE_OID(mib2
);
1374 AsnInteger32 error
= SNMP_ERRORSTATUS_NOERROR
, errorIndex
= 0;
1378 TRACE("(0x%02x, %p, %p, %p)\n", bPduType
, pVarBindList
,
1379 pErrorStatus
, pErrorIndex
);
1381 for (i
= 0; !error
&& i
< pVarBindList
->len
; i
++)
1383 /* Ignore any OIDs not in MIB2 */
1384 if (!SnmpUtilOidNCmp(&pVarBindList
->list
[i
].name
, &mib2oid
,
1387 struct mibImplementation
*impl
= NULL
;
1388 UINT len
, matchingIndex
= 0;
1390 TRACE("%s\n", SnmpUtilOidToA(&pVarBindList
->list
[i
].name
));
1391 /* Search for an implementation matching as many octets as possible
1393 for (len
= pVarBindList
->list
[i
].name
.idLength
;
1394 len
>= minSupportedIDLength
&& !impl
; len
--)
1395 impl
= findSupportedQuery(pVarBindList
->list
[i
].name
.ids
, len
,
1397 if (impl
&& impl
->query
)
1398 ret
= impl
->query(bPduType
, &pVarBindList
->list
[i
], &error
);
1400 error
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1401 if (error
== SNMP_ERRORSTATUS_NOSUCHNAME
&&
1402 bPduType
== SNMP_PDU_GETNEXT
)
1404 /* GetNext is special: it finds the successor to the given OID,
1405 * so we have to continue until an implementation handles the
1406 * query or we exhaust the table of supported OIDs.
1408 for (matchingIndex
++; error
== SNMP_ERRORSTATUS_NOSUCHNAME
&&
1409 matchingIndex
< DEFINE_SIZEOF(supportedIDs
);
1412 error
= SNMP_ERRORSTATUS_NOERROR
;
1413 impl
= &supportedIDs
[matchingIndex
];
1415 ret
= impl
->query(bPduType
, &pVarBindList
->list
[i
],
1418 error
= SNMP_ERRORSTATUS_NOSUCHNAME
;
1420 /* If the query still isn't resolved, set the OID to the
1421 * successor to the last entry in the table.
1423 if (error
== SNMP_ERRORSTATUS_NOSUCHNAME
)
1425 SnmpUtilOidFree(&pVarBindList
->list
[i
].name
);
1426 ret
= SnmpUtilOidCpy(&pVarBindList
->list
[i
].name
,
1427 &supportedIDs
[matchingIndex
- 1].name
);
1428 pVarBindList
->list
[i
].name
.ids
[
1429 pVarBindList
->list
[i
].name
.idLength
- 1] += 1;
1436 *pErrorStatus
= error
;
1437 *pErrorIndex
= errorIndex
;
1441 /*****************************************************************************
1442 * DllMain [INETMIB1.@]
1444 BOOL WINAPI
DllMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
1446 TRACE("(0x%p, %d, %p)\n", hinstDLL
, fdwReason
, lpvReserved
);
1450 case DLL_PROCESS_ATTACH
:
1451 DisableThreadLibraryCalls(hinstDLL
);
1453 case DLL_PROCESS_DETACH
: