msxml3/tests: Tests for IMXAttributes::clear().
[wine/multimedia.git] / dlls / snmpapi / main.c
blob1c4d1fa36cddc552a66dfeb73d5069dd54884b30
1 /*
2 * Implementation of SNMPAPI.DLL
4 * Copyright 2002 Patrik Stridvall
5 * Copyright 2007 Hans Leidekker
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.
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.
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
22 #include "config.h"
24 #include <stdio.h>
25 #include <stdarg.h>
27 #include "windef.h"
28 #include "winbase.h"
29 #include "snmp.h"
31 #include "wine/debug.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(snmpapi);
35 static INT asn_any_copy(AsnAny *dst, const AsnAny *src)
37 memset(dst, 0, sizeof(AsnAny));
38 switch (src->asnType)
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;
47 case ASN_OCTETSTRING:
48 case ASN_BITS:
49 case ASN_SEQUENCE:
50 case ASN_IPADDRESS:
51 case ASN_OPAQUE:
53 BYTE *stream;
54 UINT length = src->asnValue.string.length;
56 if (!(stream = HeapAlloc(GetProcessHeap(), 0, length))) return SNMPAPI_ERROR;
57 memcpy(stream, src->asnValue.string.stream, length);
59 dst->asnValue.string.stream = stream;
60 dst->asnValue.string.length = length;
61 dst->asnValue.string.dynamic = TRUE;
62 break;
64 case ASN_OBJECTIDENTIFIER:
66 UINT *ids, i, size = src->asnValue.object.idLength * sizeof(UINT);
68 if (!(ids = HeapAlloc(GetProcessHeap(), 0, size))) return SNMPAPI_ERROR;
70 dst->asnValue.object.ids = ids;
71 dst->asnValue.object.idLength = src->asnValue.object.idLength;
73 for (i = 0; i < dst->asnValue.object.idLength; i++)
74 dst->asnValue.object.ids[i] = src->asnValue.object.ids[i];
75 break;
77 default:
79 WARN("unknown ASN type: %d\n", src->asnType);
80 return SNMPAPI_ERROR;
83 dst->asnType = src->asnType;
84 return SNMPAPI_NOERROR;
87 static void asn_any_free(AsnAny *any)
89 switch (any->asnType)
91 case ASN_OCTETSTRING:
92 case ASN_BITS:
93 case ASN_SEQUENCE:
94 case ASN_IPADDRESS:
95 case ASN_OPAQUE:
97 if (any->asnValue.string.dynamic)
99 HeapFree(GetProcessHeap(), 0, any->asnValue.string.stream);
100 any->asnValue.string.stream = NULL;
102 break;
104 case ASN_OBJECTIDENTIFIER:
106 HeapFree(GetProcessHeap(), 0, any->asnValue.object.ids);
107 any->asnValue.object.ids = NULL;
108 break;
110 default: break;
112 any->asnType = ASN_NULL;
115 static ULONGLONG startTime;
117 /***********************************************************************
118 * DllMain for SNMPAPI
120 BOOL WINAPI DllMain(
121 HINSTANCE hInstDLL,
122 DWORD fdwReason,
123 LPVOID lpvReserved)
125 TRACE("(%p,%d,%p)\n", hInstDLL, fdwReason, lpvReserved);
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;
138 return TRUE;
141 /***********************************************************************
142 * SnmpSvcGetUptime (SNMPAPI.@)
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.
149 DWORD WINAPI SnmpSvcGetUptime(void)
151 ULONGLONG now = GetTickCount64();
153 return (now - startTime) / 10;
156 /***********************************************************************
157 * SnmpUtilDbgPrint (SNMPAPI.@)
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.
166 VOID WINAPIV SnmpUtilDbgPrint(INT loglevel, LPSTR format, ...)
168 FIXME("(%d, %s)\n", loglevel, debugstr_a(format));
171 /***********************************************************************
172 * SnmpUtilMemAlloc (SNMPAPI.@)
174 LPVOID WINAPI SnmpUtilMemAlloc(UINT nbytes)
176 TRACE("(%d)\n", nbytes);
177 return HeapAlloc(GetProcessHeap(), 0, nbytes);
180 /***********************************************************************
181 * SnmpUtilMemReAlloc (SNMPAPI.@)
183 LPVOID WINAPI SnmpUtilMemReAlloc(LPVOID mem, UINT nbytes)
185 TRACE("(%p, %d)\n", mem, nbytes);
186 return HeapReAlloc(GetProcessHeap(), 0, mem, nbytes);
189 /***********************************************************************
190 * SnmpUtilMemFree (SNMPAPI.@)
192 VOID WINAPI SnmpUtilMemFree(LPVOID mem)
194 TRACE("(%p)\n", mem);
195 HeapFree(GetProcessHeap(), 0, mem);
198 /***********************************************************************
199 * SnmpUtilAsnAnyCpy (SNMPAPI.@)
201 INT WINAPI SnmpUtilAsnAnyCpy(AsnAny *dst, AsnAny *src)
203 TRACE("(%p, %p)\n", dst, src);
204 return asn_any_copy(dst, src);
207 /***********************************************************************
208 * SnmpUtilAsnAnyFree (SNMPAPI.@)
210 VOID WINAPI SnmpUtilAsnAnyFree(AsnAny *any)
212 TRACE("(%p)\n", any);
213 asn_any_free(any);
216 /***********************************************************************
217 * SnmpUtilOctetsCpy (SNMPAPI.@)
219 INT WINAPI SnmpUtilOctetsCpy(AsnOctetString *dst, AsnOctetString *src)
221 TRACE("(%p, %p)\n", dst, src);
223 if (!dst) return SNMPAPI_ERROR;
224 if (!src)
226 dst->dynamic = FALSE;
227 dst->length = 0;
228 dst->stream = NULL;
229 return SNMPAPI_NOERROR;
231 if ((dst->stream = HeapAlloc(GetProcessHeap(), 0, src->length)))
233 unsigned int i;
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;
240 return SNMPAPI_ERROR;
243 /***********************************************************************
244 * SnmpUtilOctetsFree (SNMPAPI.@)
246 VOID WINAPI SnmpUtilOctetsFree(AsnOctetString *octets)
248 TRACE("(%p)\n", octets);
250 if (octets)
252 octets->length = 0;
253 if (octets->dynamic) HeapFree(GetProcessHeap(), 0, octets->stream);
254 octets->stream = NULL;
255 octets->dynamic = FALSE;
259 /***********************************************************************
260 * SnmpUtilOctetsNCmp (SNMPAPI.@)
262 INT WINAPI SnmpUtilOctetsNCmp(AsnOctetString *octets1, AsnOctetString *octets2, UINT count)
264 INT ret;
265 unsigned int i;
267 TRACE("(%p, %p, %d)\n", octets1, octets2, count);
269 if (!octets1 || !octets2) return 0;
271 for (i = 0; i < count; i++)
272 if ((ret = octets1->stream[i] - octets2->stream[i])) return ret;
274 return 0;
277 /***********************************************************************
278 * SnmpUtilOctetsCmp (SNMPAPI.@)
280 INT WINAPI SnmpUtilOctetsCmp(AsnOctetString *octets1, AsnOctetString *octets2)
282 TRACE("(%p, %p)\n", octets1, octets2);
284 if (octets1->length < octets2->length) return -1;
285 if (octets1->length > octets2->length) return 1;
287 return SnmpUtilOctetsNCmp(octets1, octets2, octets1->length);
290 /***********************************************************************
291 * SnmpUtilOidAppend (SNMPAPI.@)
293 INT WINAPI SnmpUtilOidAppend(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
295 UINT *ids, i, size;
297 TRACE("(%p, %p)\n", dst, src);
299 if (!dst) return SNMPAPI_ERROR;
300 if (!src) return SNMPAPI_NOERROR;
302 size = (src->idLength + dst->idLength) * sizeof(UINT);
303 if (!(ids = HeapReAlloc(GetProcessHeap(), 0, dst->ids, size)))
305 if (!(ids = HeapAlloc(GetProcessHeap(), 0, size)))
307 SetLastError(SNMP_MEM_ALLOC_ERROR);
308 return SNMPAPI_ERROR;
310 else memcpy(ids, dst->ids, dst->idLength * sizeof(UINT));
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;
317 return SNMPAPI_NOERROR;
320 /***********************************************************************
321 * SnmpUtilOidCpy (SNMPAPI.@)
323 INT WINAPI SnmpUtilOidCpy(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
325 TRACE("(%p, %p)\n", dst, src);
327 if (!dst) return SNMPAPI_ERROR;
328 if (!src)
330 dst->idLength = 0;
331 dst->ids = NULL;
332 return SNMPAPI_NOERROR;
334 if ((dst->ids = HeapAlloc(GetProcessHeap(), 0, src->idLength * sizeof(UINT))))
336 unsigned int i;
338 dst->idLength = src->idLength;
339 for (i = 0; i < dst->idLength; i++) dst->ids[i] = src->ids[i];
340 return SNMPAPI_NOERROR;
342 return SNMPAPI_ERROR;
345 /***********************************************************************
346 * SnmpUtilOidFree (SNMPAPI.@)
348 VOID WINAPI SnmpUtilOidFree(AsnObjectIdentifier *oid)
350 TRACE("(%p)\n", oid);
352 if (!oid) return;
354 oid->idLength = 0;
355 HeapFree(GetProcessHeap(), 0, oid->ids);
356 oid->ids = NULL;
359 /***********************************************************************
360 * SnmpUtilOidNCmp (SNMPAPI.@)
362 INT WINAPI SnmpUtilOidNCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2, UINT count)
364 unsigned int i, len;
366 TRACE("(%p, %p, %d)\n", oid1, oid2, count);
368 if (!oid1 || !oid2) return 0;
370 len = min(count, oid1->idLength);
371 len = min(len, oid2->idLength);
372 for (i = 0; i < len; i++)
374 if (oid1->ids[i] > oid2->ids[i]) return 1;
375 if (oid1->ids[i] < oid2->ids[i]) return -1;
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;
383 /***********************************************************************
384 * SnmpUtilOidCmp (SNMPAPI.@)
386 INT WINAPI SnmpUtilOidCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2)
388 TRACE("(%p, %p)\n", oid1, oid2);
390 if (oid1->idLength < oid2->idLength) return -1;
391 if (oid1->idLength > oid2->idLength) return 1;
393 return SnmpUtilOidNCmp(oid1, oid2, oid1->idLength);
396 /***********************************************************************
397 * SnmpUtilVarBindCpy (SNMPAPI.@)
399 INT WINAPI SnmpUtilVarBindCpy(SnmpVarBind *dst, SnmpVarBind *src)
401 unsigned int i, size;
403 TRACE("(%p, %p)\n", dst, src);
405 if (!dst) return SNMPAPI_ERROR;
406 if (!src)
408 dst->value.asnType = ASN_NULL;
409 return SNMPAPI_NOERROR;
412 size = src->name.idLength * sizeof(UINT);
413 if (!(dst->name.ids = HeapAlloc(GetProcessHeap(), 0, size))) return SNMPAPI_ERROR;
415 for (i = 0; i < src->name.idLength; i++) dst->name.ids[i] = src->name.ids[i];
416 dst->name.idLength = src->name.idLength;
418 if (!asn_any_copy(&dst->value, &src->value))
420 HeapFree(GetProcessHeap(), 0, dst->name.ids);
421 return SNMPAPI_ERROR;
423 return SNMPAPI_NOERROR;
426 /***********************************************************************
427 * SnmpUtilVarBindFree (SNMPAPI.@)
429 VOID WINAPI SnmpUtilVarBindFree(SnmpVarBind *vb)
431 TRACE("(%p)\n", vb);
433 if (!vb) return;
435 asn_any_free(&vb->value);
436 HeapFree(GetProcessHeap(), 0, vb->name.ids);
437 vb->name.idLength = 0;
438 vb->name.ids = NULL;
441 /***********************************************************************
442 * SnmpUtilVarBindListCpy (SNMPAPI.@)
444 INT WINAPI SnmpUtilVarBindListCpy(SnmpVarBindList *dst, SnmpVarBindList *src)
446 unsigned int i, size;
447 SnmpVarBind *src_entry, *dst_entry;
449 TRACE("(%p, %p)\n", dst, src);
451 if (!src)
453 dst->list = NULL;
454 dst->len = 0;
455 return SNMPAPI_NOERROR;
457 size = src->len * sizeof(SnmpVarBind);
458 if (!(dst->list = HeapAlloc(GetProcessHeap(), 0, size)))
459 return SNMPAPI_ERROR;
461 src_entry = src->list;
462 dst_entry = dst->list;
463 for (i = 0; i < src->len; i++)
465 if (SnmpUtilVarBindCpy(dst_entry, src_entry))
467 src_entry++;
468 dst_entry++;
470 else
472 for (--i; i > 0; i--) SnmpUtilVarBindFree(--dst_entry);
473 HeapFree(GetProcessHeap(), 0, dst->list);
474 return SNMPAPI_ERROR;
477 dst->len = src->len;
478 return SNMPAPI_NOERROR;
481 /***********************************************************************
482 * SnmpUtilVarBindListFree (SNMPAPI.@)
484 VOID WINAPI SnmpUtilVarBindListFree(SnmpVarBindList *vb)
486 unsigned int i;
487 SnmpVarBind *entry;
489 TRACE("(%p)\n", vb);
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;
498 /***********************************************************************
499 * SnmpUtilIdsToA (SNMPAPI.@)
501 LPSTR WINAPI SnmpUtilIdsToA(UINT *ids, UINT length)
503 static char one[10], oid[514], null_oid[] = "<null oid>";
504 unsigned int i, len, left = sizeof(oid) - 1;
506 TRACE("(%p, %d)\n", ids, length);
508 if (!ids || !length) return null_oid;
510 *oid = 0;
511 for (i = 0; i < length; i++)
513 sprintf(one, "%d", ids[i]);
514 len = strlen(one);
515 if (left >= len)
517 strcat(oid, one);
518 left -= len;
520 else return oid;
522 if (i < length - 1)
524 if (left > 0)
526 strcat(oid, ".");
527 left--;
529 else return oid;
532 return oid;
535 /***********************************************************************
536 * SnmpUtilOidToA (SNMPAPI.@)
538 LPSTR WINAPI SnmpUtilOidToA(AsnObjectIdentifier *oid)
540 static char null_oid[] = "<null oid>";
542 TRACE("(%p)\n", oid);
544 if (oid)
545 return SnmpUtilIdsToA(oid->ids, oid->idLength);
546 else
547 return null_oid;
550 /***********************************************************************
551 * SnmpUtilPrintOid (SNMPAPI.@)
553 VOID WINAPI SnmpUtilPrintOid(AsnObjectIdentifier *oid)
555 unsigned int i;
557 TRACE("(%p)\n", oid);
559 if (!oid) return;
561 for (i = 0; i < oid->idLength; i++)
563 TRACE("%u", oid->ids[i]);
564 if (i < oid->idLength - 1) TRACE(".");
566 TRACE("\n");
569 /***********************************************************************
570 * SnmpUtilPrintAsnAny (SNMPAPI.@)
572 VOID WINAPI SnmpUtilPrintAsnAny(AsnAny *any)
574 unsigned int i;
576 TRACE("(%p)\n", any);
578 switch (any->asnType)
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:
588 TRACE("Counter64 %x%08x\n", (DWORD)(any->asnValue.counter64.QuadPart>>32),(DWORD)any->asnValue.counter64.QuadPart);
589 return;
591 case ASN_OCTETSTRING:
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;
599 case ASN_IPADDRESS:
601 TRACE("IpAddress ");
602 if (any->asnValue.string.length < 4)
604 TRACE("Invalid\n");
605 return;
607 for (i = 0; i < 4; i++)
609 TRACE("%u", any->asnValue.string.stream[i]);
610 if (i < 3) TRACE(".");
612 TRACE("\n");
613 return;
615 case ASN_BITS:
617 TRACE("Bits ");
618 for (i = 0; i < any->asnValue.string.length; i++)
620 TRACE("0x%02x", any->asnValue.string.stream[i]);
621 if (i < any->asnValue.object.idLength - 1) TRACE(" ");
623 TRACE("\n");
624 return;
626 case ASN_OPAQUE:
628 TRACE("Opaque ");
629 for (i = 0; i < any->asnValue.string.length; i++)
631 TRACE("0x%02x", any->asnValue.string.stream[i]);
632 if (i < any->asnValue.object.idLength - 1) TRACE(" ");
634 TRACE("\n");
635 return;
637 case ASN_OBJECTIDENTIFIER:
639 TRACE("ObjectID ");
640 for (i = 0; i < any->asnValue.object.idLength; i++)
642 TRACE("%u", any->asnValue.object.ids[i]);
643 if (i < any->asnValue.object.idLength - 1) TRACE(".");
645 TRACE("\n");
646 return;
648 default:
650 TRACE("Invalid type %d\n", any->asnType);
651 return;