1 /*
2 * Implementation of SNMPAPI.DLL
3 *
4 * Copyright 2002 Patrik Stridvall
5 * Copyright 2007 Hans Leidekker
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #include <stdio.h>
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "snmp.h"
30
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(snmpapi);
34
35 static INT asn_any_copy(AsnAny *dst, const AsnAny *src)
36 {
37 memset(dst, 0, sizeof(AsnAny));
38 switch (src->asnType)
39 {
40 case ASN_INTEGER32: dst->asnValue.number = src->asnValue.number; break;
41 case ASN_UNSIGNED32: dst->asnValue.unsigned32 = src->asnValue.unsigned32; break;
42 case ASN_COUNTER64: dst->asnValue.counter64 = src->asnValue.counter64; break;
43 case ASN_COUNTER32: dst->asnValue.counter = src->asnValue.counter; break;
44 case ASN_GAUGE32: dst->asnValue.gauge = src->asnValue.gauge; break;
45 case ASN_TIMETICKS: dst->asnValue.ticks = src->asnValue.ticks; break;
46
47 case ASN_OCTETSTRING:
48 case ASN_BITS:
49 case ASN_SEQUENCE:
50 case ASN_IPADDRESS:
51 case ASN_OPAQUE:
52 {
53 BYTE *stream;
54 UINT length = src->asnValue.string.length;
55
56 if (!(stream = HeapAlloc(GetProcessHeap(), 0, length))) return SNMPAPI_ERROR;
57 memcpy(stream, src->asnValue.string.stream, length);
58
59 dst->asnValue.string.stream = stream;
60 dst->asnValue.string.length = length;
61 dst->asnValue.string.dynamic = TRUE;
62 break;
63 }
64 case ASN_OBJECTIDENTIFIER:
65 {
66 UINT *ids, i, size = src->asnValue.object.idLength * sizeof(UINT);
67
68 if (!(ids = HeapAlloc(GetProcessHeap(), 0, size))) return SNMPAPI_ERROR;
69
70 dst->asnValue.object.ids = ids;
71 dst->asnValue.object.idLength = src->asnValue.object.idLength;
72
73 for (i = 0; i < dst->asnValue.object.idLength; i++)
74 dst->asnValue.object.ids[i] = src->asnValue.object.ids[i];
75 break;
76 }
77 default:
78 {
79 WARN("unknown ASN type: %d\n", src->asnType);
80 return SNMPAPI_ERROR;
81 }
82 }
83 dst->asnType = src->asnType;
84 return SNMPAPI_NOERROR;
85 }
86
87 static void asn_any_free(AsnAny *any)
88 {
89 switch (any->asnType)
90 {
91 case ASN_OCTETSTRING:
92 case ASN_BITS:
93 case ASN_SEQUENCE:
94 case ASN_IPADDRESS:
95 case ASN_OPAQUE:
96 {
97 if (any->asnValue.string.dynamic)
98 {
99 HeapFree(GetProcessHeap(), 0, any->asnValue.string.stream);
100 any->asnValue.string.stream = NULL;
101 }
102 break;
103 }
104 case ASN_OBJECTIDENTIFIER:
105 {
106 HeapFree(GetProcessHeap(), 0, any->asnValue.object.ids);
107 any->asnValue.object.ids = NULL;
108 break;
109 }
110 default: break;
111 }
112 any->asnType = ASN_NULL;
113 }
114
115 static ULONGLONG startTime;
116
117 /***********************************************************************
118 * DllMain for SNMPAPI
119 */
120 BOOL WINAPI DllMain(
121 HINSTANCE hInstDLL,
122 DWORD fdwReason,
123 LPVOID lpvReserved)
124 {
125 TRACE("(%p,%d,%p)\n", hInstDLL, fdwReason, lpvReserved);
126
127 switch(fdwReason) {
128 case DLL_WINE_PREATTACH:
129 return FALSE; /* prefer native version */
130 case DLL_PROCESS_ATTACH:
131 DisableThreadLibraryCalls(hInstDLL);
132 startTime = GetTickCount64();
133 break;
134 case DLL_PROCESS_DETACH:
135 break;
136 }
137
138 return TRUE;
139 }
140
141 /***********************************************************************
142 * SnmpSvcGetUptime (SNMPAPI.@)
143 *
144 * BUGS
145 * This returns the number of centiseconds since the DLL was loaded,
146 * rather than the number of centiseconds since the SNMP service was
147 * started, since there isn't yet any SNMP service in Wine.
148 */
149 DWORD WINAPI SnmpSvcGetUptime(void)
150 {
151 ULONGLONG now = GetTickCount64();
152
153 return (now - startTime) / 10;
154 }
155
156 /***********************************************************************
157 * SnmpUtilDbgPrint (SNMPAPI.@)
158 *
159 * NOTES
160 * The Microsoft headers claim this function uses the stdcall calling
161 * convention. But stdcall functions cannot take a variable number of
162 * arguments so this does not make sense. The stdcall specification is
163 * probably ignored by Microsoft's compiler in this case. So declare it
164 * correctly in Wine so it works with all compilers.
165 */
166 VOID WINAPIV SnmpUtilDbgPrint(INT loglevel, LPSTR format, ...)
167 {
168 FIXME("(%d, %s)\n", loglevel, debugstr_a(format));
169 }
170
171 /***********************************************************************
172 * SnmpUtilMemAlloc (SNMPAPI.@)
173 */
174 LPVOID WINAPI SnmpUtilMemAlloc(UINT nbytes)
175 {
176 TRACE("(%d)\n", nbytes);
177 return HeapAlloc(GetProcessHeap(), 0, nbytes);
178 }
179
180 /***********************************************************************
181 * SnmpUtilMemReAlloc (SNMPAPI.@)
182 */
183 LPVOID WINAPI SnmpUtilMemReAlloc(LPVOID mem, UINT nbytes)
184 {
185 TRACE("(%p, %d)\n", mem, nbytes);
186 return HeapReAlloc(GetProcessHeap(), 0, mem, nbytes);
187 }
188
189 /***********************************************************************
190 * SnmpUtilMemFree (SNMPAPI.@)
191 */
192 VOID WINAPI SnmpUtilMemFree(LPVOID mem)
193 {
194 TRACE("(%p)\n", mem);
195 HeapFree(GetProcessHeap(), 0, mem);
196 }
197
198 /***********************************************************************
199 * SnmpUtilAsnAnyCpy (SNMPAPI.@)
200 */
201 INT WINAPI SnmpUtilAsnAnyCpy(AsnAny *dst, AsnAny *src)
202 {
203 TRACE("(%p, %p)\n", dst, src);
204 return asn_any_copy(dst, src);
205 }
206
207 /***********************************************************************
208 * SnmpUtilAsnAnyFree (SNMPAPI.@)
209 */
210 VOID WINAPI SnmpUtilAsnAnyFree(AsnAny *any)
211 {
212 TRACE("(%p)\n", any);
213 asn_any_free(any);
214 }
215
216 /***********************************************************************
217 * SnmpUtilOctetsCpy (SNMPAPI.@)
218 */
219 INT WINAPI SnmpUtilOctetsCpy(AsnOctetString *dst, AsnOctetString *src)
220 {
221 TRACE("(%p, %p)\n", dst, src);
222
223 if (!dst) return SNMPAPI_ERROR;
224 if (!src)
225 {
226 dst->dynamic = FALSE;
227 dst->length = 0;
228 dst->stream = NULL;
229 return SNMPAPI_NOERROR;
230 }
231 if ((dst->stream = HeapAlloc(GetProcessHeap(), 0, src->length)))
232 {
233 unsigned int i;
234
235 dst->dynamic = TRUE;
236 dst->length = src->length;
237 for (i = 0; i < dst->length; i++) dst->stream[i] = src->stream[i];
238 return SNMPAPI_NOERROR;
239 }
240 return SNMPAPI_ERROR;
241 }
242
243 /***********************************************************************
244 * SnmpUtilOctetsFree (SNMPAPI.@)
245 */
246 VOID WINAPI SnmpUtilOctetsFree(AsnOctetString *octets)
247 {
248 TRACE("(%p)\n", octets);
249
250 if (octets)
251 {
252 octets->length = 0;
253 if (octets->dynamic) HeapFree(GetProcessHeap(), 0, octets->stream);
254 octets->stream = NULL;
255 octets->dynamic = FALSE;
256 }
257 }
258
259 /***********************************************************************
260 * SnmpUtilOctetsNCmp (SNMPAPI.@)
261 */
262 INT WINAPI SnmpUtilOctetsNCmp(AsnOctetString *octets1, AsnOctetString *octets2, UINT count)
263 {
264 INT ret;
265 unsigned int i;
266
267 TRACE("(%p, %p, %d)\n", octets1, octets2, count);
268
269 if (!octets1 || !octets2) return 0;
270
271 for (i = 0; i < count; i++)
272 if ((ret = octets1->stream[i] - octets2->stream[i])) return ret;
273
274 return 0;
275 }
276
277 /***********************************************************************
278 * SnmpUtilOctetsCmp (SNMPAPI.@)
279 */
280 INT WINAPI SnmpUtilOctetsCmp(AsnOctetString *octets1, AsnOctetString *octets2)
281 {
282 TRACE("(%p, %p)\n", octets1, octets2);
283
284 if (octets1->length < octets2->length) return -1;
285 if (octets1->length > octets2->length) return 1;
286
287 return SnmpUtilOctetsNCmp(octets1, octets2, octets1->length);
288 }
289
290 /***********************************************************************
291 * SnmpUtilOidAppend (SNMPAPI.@)
292 */
293 INT WINAPI SnmpUtilOidAppend(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
294 {
295 UINT *ids, i, size;
296
297 TRACE("(%p, %p)\n", dst, src);
298
299 if (!dst) return SNMPAPI_ERROR;
300 if (!src) return SNMPAPI_NOERROR;
301
302 size = (src->idLength + dst->idLength) * sizeof(UINT);
303 if (!(ids = HeapReAlloc(GetProcessHeap(), 0, dst->ids, size)))
304 {
305 if (!(ids = HeapAlloc(GetProcessHeap(), 0, size)))
306 {
307 SetLastError(SNMP_MEM_ALLOC_ERROR);
308 return SNMPAPI_ERROR;
309 }
310 else memcpy(ids, dst->ids, dst->idLength * sizeof(UINT));
311 }
312
313 for (i = 0; i < src->idLength; i++) ids[i + dst->idLength] = src->ids[i];
314 dst->idLength = dst->idLength + src->idLength;
315 dst->ids = ids;
316
317 return SNMPAPI_NOERROR;
318 }
319
320 /***********************************************************************
321 * SnmpUtilOidCpy (SNMPAPI.@)
322 */
323 INT WINAPI SnmpUtilOidCpy(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
324 {
325 TRACE("(%p, %p)\n", dst, src);
326
327 if (!dst) return SNMPAPI_ERROR;
328 if (!src)
329 {
330 dst->idLength = 0;
331 dst->ids = NULL;
332 return SNMPAPI_NOERROR;
333 }
334 if ((dst->ids = HeapAlloc(GetProcessHeap(), 0, src->idLength * sizeof(UINT))))
335 {
336 unsigned int i;
337
338 dst->idLength = src->idLength;
339 for (i = 0; i < dst->idLength; i++) dst->ids[i] = src->ids[i];
340 return SNMPAPI_NOERROR;
341 }
342 return SNMPAPI_ERROR;
343 }
344
345 /***********************************************************************
346 * SnmpUtilOidFree (SNMPAPI.@)
347 */
348 VOID WINAPI SnmpUtilOidFree(AsnObjectIdentifier *oid)
349 {
350 TRACE("(%p)\n", oid);
351
352 if (!oid) return;
353
354 oid->idLength = 0;
355 HeapFree(GetProcessHeap(), 0, oid->ids);
356 oid->ids = NULL;
357 }
358
359 /***********************************************************************
360 * SnmpUtilOidNCmp (SNMPAPI.@)
361 */
362 INT WINAPI SnmpUtilOidNCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2, UINT count)
363 {
364 unsigned int i, len;
365
366 TRACE("(%p, %p, %d)\n", oid1, oid2, count);
367
368 if (!oid1 || !oid2) return 0;
369
370 len = min(count, oid1->idLength);
371 len = min(len, oid2->idLength);
372 for (i = 0; i < len; i++)
373 {
374 if (oid1->ids[i] > oid2->ids[i]) return 1;
375 if (oid1->ids[i] < oid2->ids[i]) return -1;
376 }
377 if (i == count) return 0;
378 if (oid1->idLength < oid2->idLength) return -1;
379 if (oid1->idLength > oid2->idLength) return 1;
380 return 0;
381 }
382
383 /***********************************************************************
384 * SnmpUtilOidCmp (SNMPAPI.@)
385 */
386 INT WINAPI SnmpUtilOidCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2)
387 {
388 TRACE("(%p, %p)\n", oid1, oid2);
389
390 if (oid1->idLength < oid2->idLength) return -1;
391 if (oid1->idLength > oid2->idLength) return 1;
392
393 return SnmpUtilOidNCmp(oid1, oid2, oid1->idLength);
394 }
395
396 /***********************************************************************
397 * SnmpUtilVarBindCpy (SNMPAPI.@)
398 */
399 INT WINAPI SnmpUtilVarBindCpy(SnmpVarBind *dst, SnmpVarBind *src)
400 {
401 unsigned int i, size;
402
403 TRACE("(%p, %p)\n", dst, src);
404
405 if (!dst) return SNMPAPI_ERROR;
406 if (!src)
407 {
408 dst->value.asnType = ASN_NULL;
409 return SNMPAPI_NOERROR;
410 }
411
412 size = src->name.idLength * sizeof(UINT);
413 if (!(dst->name.ids = HeapAlloc(GetProcessHeap(), 0, size))) return SNMPAPI_ERROR;
414
415 for (i = 0; i < src->name.idLength; i++) dst->name.ids[i] = src->name.ids[i];
416 dst->name.idLength = src->name.idLength;
417
418 if (!asn_any_copy(&dst->value, &src->value))
419 {
420 HeapFree(GetProcessHeap(), 0, dst->name.ids);
421 return SNMPAPI_ERROR;
422 }
423 return SNMPAPI_NOERROR;
424 }
425
426 /***********************************************************************
427 * SnmpUtilVarBindFree (SNMPAPI.@)
428 */
429 VOID WINAPI SnmpUtilVarBindFree(SnmpVarBind *vb)
430 {
431 TRACE("(%p)\n", vb);
432
433 if (!vb) return;
434
435 asn_any_free(&vb->value);
436 HeapFree(GetProcessHeap(), 0, vb->name.ids);
437 vb->name.idLength = 0;
438 vb->name.ids = NULL;
439 }
440
441 /***********************************************************************
442 * SnmpUtilVarBindListCpy (SNMPAPI.@)
443 */
444 INT WINAPI SnmpUtilVarBindListCpy(SnmpVarBindList *dst, SnmpVarBindList *src)
445 {
446 unsigned int i, size;
447 SnmpVarBind *src_entry, *dst_entry;
448
449 TRACE("(%p, %p)\n", dst, src);
450
451 if (!src)
452 {
453 dst->list = NULL;
454 dst->len = 0;
455 return SNMPAPI_NOERROR;
456 }
457 size = src->len * sizeof(SnmpVarBind);
458 if (!(dst->list = HeapAlloc(GetProcessHeap(), 0, size)))
459 return SNMPAPI_ERROR;
460
461 src_entry = src->list;
462 dst_entry = dst->list;
463 for (i = 0; i < src->len; i++)
464 {
465 if (SnmpUtilVarBindCpy(dst_entry, src_entry))
466 {
467 src_entry++;
468 dst_entry++;
469 }
470 else
471 {
472 for (--i; i > 0; i--) SnmpUtilVarBindFree(--dst_entry);
473 HeapFree(GetProcessHeap(), 0, dst->list);
474 return SNMPAPI_ERROR;
475 }
476 }
477 dst->len = src->len;
478 return SNMPAPI_NOERROR;
479 }
480
481 /***********************************************************************
482 * SnmpUtilVarBindListFree (SNMPAPI.@)
483 */
484 VOID WINAPI SnmpUtilVarBindListFree(SnmpVarBindList *vb)
485 {
486 unsigned int i;
487 SnmpVarBind *entry;
488
489 TRACE("(%p)\n", vb);
490
491 entry = vb->list;
492 for (i = 0; i < vb->len; i++) SnmpUtilVarBindFree(entry++);
493 HeapFree(GetProcessHeap(), 0, vb->list);
494 vb->list = NULL;
495 vb->len = 0;
496 }
497
498 /***********************************************************************
499 * SnmpUtilIdsToA (SNMPAPI.@)
500 */
501 LPSTR WINAPI SnmpUtilIdsToA(UINT *ids, UINT length)
502 {
503 static char one[10], oid[514], null_oid[] = "<null oid>";
504 unsigned int i, len, left = sizeof(oid) - 1;
505
506 TRACE("(%p, %d)\n", ids, length);
507
508 if (!ids || !length) return null_oid;
509
510 *oid = 0;
511 for (i = 0; i < length; i++)
512 {
513 sprintf(one, "%d", ids[i]);
514 len = strlen(one);
515 if (left >= len)
516 {
517 strcat(oid, one);
518 left -= len;
519 }
520 else return oid;
521
522 if (i < length - 1)
523 {
524 if (left > 0)
525 {
526 strcat(oid, ".");
527 left--;
528 }
529 else return oid;
530 }
531 }
532 return oid;
533 }
534
535 /***********************************************************************
536 * SnmpUtilOidToA (SNMPAPI.@)
537 */
538 LPSTR WINAPI SnmpUtilOidToA(AsnObjectIdentifier *oid)
539 {
540 static char null_oid[] = "<null oid>";
541
542 TRACE("(%p)\n", oid);
543
544 if (oid)
545 return SnmpUtilIdsToA(oid->ids, oid->idLength);
546 else
547 return null_oid;
548 }
549
550 /***********************************************************************
551 * SnmpUtilPrintOid (SNMPAPI.@)
552 */
553 VOID WINAPI SnmpUtilPrintOid(AsnObjectIdentifier *oid)
554 {
555 unsigned int i;
556
557 TRACE("(%p)\n", oid);
558
559 if (!oid) return;
560
561 for (i = 0; i < oid->idLength; i++)
562 {
563 TRACE("%u", oid->ids[i]);
564 if (i < oid->idLength - 1) TRACE(".");
565 }
566 TRACE("\n");
567 }
568
569 /***********************************************************************
570 * SnmpUtilPrintAsnAny (SNMPAPI.@)
571 */
572 VOID WINAPI SnmpUtilPrintAsnAny(AsnAny *any)
573 {
574 unsigned int i;
575
576 TRACE("(%p)\n", any);
577
578 switch (any->asnType)
579 {
580 case ASN_NULL: TRACE("Null value\n"); return;
581 case ASN_INTEGER32: TRACE("Integer32 %d\n", any->asnValue.number); return;
582 case ASN_UNSIGNED32: TRACE("Unsigned32 %u\n", any->asnValue.unsigned32); return;
583 case ASN_COUNTER32: TRACE("Counter32 %u\n", any->asnValue.counter); return;
584 case ASN_GAUGE32: TRACE("Gauge32 %u\n", any->asnValue.gauge); return;
585 case ASN_TIMETICKS: TRACE("Timeticks %u\n", any->asnValue.ticks); return;
586 case ASN_COUNTER64:
587 {
588 TRACE("Counter64 %x%08x\n", (DWORD)(any->asnValue.counter64.QuadPart>>32),(DWORD)any->asnValue.counter64.QuadPart);
589 return;
590 }
591 case ASN_OCTETSTRING:
592 {
593 TRACE("String ");
594 for (i = 0; i < any->asnValue.string.length; i++)
595 TRACE("%c", any->asnValue.string.stream[i]);
596 TRACE("\n");
597 return;
598 }
599 case ASN_IPADDRESS:
600 {
601 TRACE("IpAddress ");
602 if (any->asnValue.string.length < 4)
603 {
604 TRACE("Invalid\n");
605 return;
606 }
607 for (i = 0; i < 4; i++)
608 {
609 TRACE("%u", any->asnValue.string.stream[i]);
610 if (i < 3) TRACE(".");
611 }
612 TRACE("\n");
613 return;
614 }
615 case ASN_BITS:
616 {
617 TRACE("Bits ");
618 for (i = 0; i < any->asnValue.string.length; i++)
619 {
620 TRACE("0x%02x", any->asnValue.string.stream[i]);
621 if (i < any->asnValue.object.idLength - 1) TRACE(" ");
622 }
623 TRACE("\n");
624 return;
625 }
626 case ASN_OPAQUE:
627 {
628 TRACE("Opaque ");
629 for (i = 0; i < any->asnValue.string.length; i++)
630 {
631 TRACE("0x%02x", any->asnValue.string.stream[i]);
632 if (i < any->asnValue.object.idLength - 1) TRACE(" ");
633 }
634 TRACE("\n");
635 return;
636 }
637 case ASN_OBJECTIDENTIFIER:
638 {
639 TRACE("ObjectID ");
640 for (i = 0; i < any->asnValue.object.idLength; i++)
641 {
642 TRACE("%u", any->asnValue.object.ids[i]);
643 if (i < any->asnValue.object.idLength - 1) TRACE(".");
644 }
645 TRACE("\n");
646 return;
647 }
648 default:
649 {
650 TRACE("Invalid type %d\n", any->asnType);
651 return;
652 }
653 }
654 }
655
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.