mshtml/tests: Add a trailing '\n' to ok() calls.
[wine] / dlls / snmpapi / main.c
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 /***********************************************************************
116  *              DllMain for SNMPAPI
117  */
118 BOOL WINAPI DllMain(
119         HINSTANCE hInstDLL,
120         DWORD fdwReason,
121         LPVOID lpvReserved)
122 {
123     TRACE("(%p,%d,%p)\n", hInstDLL, fdwReason, lpvReserved);
124
125     switch(fdwReason) {
126     case DLL_WINE_PREATTACH:
127         return FALSE;  /* prefer native version */
128     case DLL_PROCESS_ATTACH:
129         DisableThreadLibraryCalls(hInstDLL);
130         break;
131     case DLL_PROCESS_DETACH:
132         break;
133     }
134
135     return TRUE;
136 }
137
138 /***********************************************************************
139  *      SnmpUtilDbgPrint        (SNMPAPI.@)
140  *
141  * NOTES
142  *  The Microsoft headers claim this function uses the stdcall calling
143  *  convention. But stdcall functions cannot take a variable number of
144  *  arguments so this does not make sense. The stdcall specification is
145  *  probably ignored by Microsoft's compiler in this case. So declare it
146  *  correctly in Wine so it works with all compilers.
147  */
148 VOID WINAPIV SnmpUtilDbgPrint(INT loglevel, LPSTR format, ...)
149 {
150     FIXME("(%d, %s)\n", loglevel, debugstr_a(format));
151 }
152
153 /***********************************************************************
154  *      SnmpUtilMemAlloc        (SNMPAPI.@)
155  */
156 LPVOID WINAPI SnmpUtilMemAlloc(UINT nbytes)
157 {
158     TRACE("(%d)\n", nbytes);
159     return HeapAlloc(GetProcessHeap(), 0, nbytes);
160 }
161
162 /***********************************************************************
163  *      SnmpUtilMemReAlloc      (SNMPAPI.@)
164  */
165 LPVOID WINAPI SnmpUtilMemReAlloc(LPVOID mem, UINT nbytes)
166 {
167     TRACE("(%p, %d)\n", mem, nbytes);
168     return HeapReAlloc(GetProcessHeap(), 0, mem, nbytes);
169 }
170
171 /***********************************************************************
172  *      SnmpUtilMemFree         (SNMPAPI.@)
173  */
174 VOID WINAPI SnmpUtilMemFree(LPVOID mem)
175 {
176     TRACE("(%p)\n", mem);
177     HeapFree(GetProcessHeap(), 0, mem);
178 }
179
180 /***********************************************************************
181  *      SnmpUtilAsnAnyCpy       (SNMPAPI.@)
182  */
183 INT WINAPI SnmpUtilAsnAnyCpy(AsnAny *dst, AsnAny *src)
184 {
185     TRACE("(%p, %p)\n", dst, src);
186     return asn_any_copy(dst, src);
187 }
188
189 /***********************************************************************
190  *      SnmpUtilAsnAnyFree      (SNMPAPI.@)
191  */
192 VOID WINAPI SnmpUtilAsnAnyFree(AsnAny *any)
193 {
194     TRACE("(%p)\n", any);
195     asn_any_free(any);
196 }
197
198 /***********************************************************************
199  *      SnmpUtilOctetsCpy       (SNMPAPI.@)
200  */
201 INT WINAPI SnmpUtilOctetsCpy(AsnOctetString *dst, AsnOctetString *src)
202 {
203     TRACE("(%p, %p)\n", dst, src);
204
205     if (!dst) return SNMPAPI_ERROR;
206     if (!src)
207     {
208         dst->dynamic = FALSE;
209         dst->length = 0;
210         dst->stream = NULL;
211         return SNMPAPI_NOERROR;
212     }
213     if ((dst->stream = HeapAlloc(GetProcessHeap(), 0, src->length)))
214     {
215         unsigned int i;
216
217         dst->dynamic = TRUE;
218         dst->length = src->length;
219         for (i = 0; i < dst->length; i++) dst->stream[i] = src->stream[i];
220         return SNMPAPI_NOERROR;
221     }
222     return SNMPAPI_ERROR;
223 }
224
225 /***********************************************************************
226  *      SnmpUtilOctetsFree      (SNMPAPI.@)
227  */
228 VOID WINAPI SnmpUtilOctetsFree(AsnOctetString *octets)
229 {
230     TRACE("(%p)\n", octets);
231
232     if (octets)
233     {
234         octets->length = 0;
235         if (octets->dynamic) HeapFree(GetProcessHeap(), 0, octets->stream);
236         octets->stream = NULL;
237         octets->dynamic = FALSE;
238     }
239 }
240
241 /***********************************************************************
242  *      SnmpUtilOctetsNCmp      (SNMPAPI.@)
243  */
244 INT WINAPI SnmpUtilOctetsNCmp(AsnOctetString *octets1, AsnOctetString *octets2, UINT count)
245 {
246     INT ret;
247     unsigned int i;
248
249     TRACE("(%p, %p, %d)\n", octets1, octets2, count);
250
251     if (!octets1 || !octets2) return 0;
252
253     for (i = 0; i < count; i++)
254         if ((ret = octets1->stream[i] - octets2->stream[i])) return ret;
255
256     return 0;
257 }
258
259 /***********************************************************************
260  *      SnmpUtilOctetsCmp       (SNMPAPI.@)
261  */
262 INT WINAPI SnmpUtilOctetsCmp(AsnOctetString *octets1, AsnOctetString *octets2)
263 {
264     TRACE("(%p, %p)\n", octets1, octets2);
265
266     if (octets1->length < octets2->length) return -1;
267     if (octets1->length > octets2->length) return 1;
268
269     return SnmpUtilOctetsNCmp(octets1, octets2, octets1->length);
270 }
271
272 /***********************************************************************
273  *      SnmpUtilOidAppend       (SNMPAPI.@)
274  */
275 INT WINAPI SnmpUtilOidAppend(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
276 {
277     UINT *ids, i, size;
278
279     TRACE("(%p, %p)\n", dst, src);
280
281     if (!dst) return SNMPAPI_ERROR;
282     if (!src) return SNMPAPI_NOERROR;
283
284     size = (src->idLength + dst->idLength) * sizeof(UINT);
285     if (!(ids = HeapReAlloc(GetProcessHeap(), 0, dst->ids, size)))
286     {
287         if (!(ids = HeapAlloc(GetProcessHeap(), 0, size)))
288         {
289             SetLastError(SNMP_MEM_ALLOC_ERROR);
290             return SNMPAPI_ERROR;
291         }
292         else memcpy(ids, dst->ids, dst->idLength * sizeof(UINT));
293     }
294
295     for (i = 0; i < src->idLength; i++) ids[i + dst->idLength] = src->ids[i];
296     dst->idLength = dst->idLength + src->idLength;
297     dst->ids = ids;
298
299     return SNMPAPI_NOERROR;
300 }
301
302 /***********************************************************************
303  *      SnmpUtilOidCpy          (SNMPAPI.@)
304  */
305 INT WINAPI SnmpUtilOidCpy(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
306 {
307     TRACE("(%p, %p)\n", dst, src);
308
309     if (!dst) return SNMPAPI_ERROR;
310     if (!src)
311     {
312         dst->idLength = 0;
313         dst->ids = NULL;
314         return SNMPAPI_NOERROR;
315     }
316     if ((dst->ids = HeapAlloc(GetProcessHeap(), 0, src->idLength * sizeof(UINT))))
317     {
318         unsigned int i;
319
320         dst->idLength = src->idLength;
321         for (i = 0; i < dst->idLength; i++) dst->ids[i] = src->ids[i];
322         return SNMPAPI_NOERROR;
323     }
324     return SNMPAPI_ERROR;
325 }
326
327 /***********************************************************************
328  *      SnmpUtilOidFree         (SNMPAPI.@)
329  */
330 VOID WINAPI SnmpUtilOidFree(AsnObjectIdentifier *oid)
331 {
332     TRACE("(%p)\n", oid);
333
334     if (!oid) return;
335
336     oid->idLength = 0;
337     HeapFree(GetProcessHeap(), 0, oid->ids);
338     oid->ids = NULL;
339 }
340
341 /***********************************************************************
342  *      SnmpUtilOidNCmp         (SNMPAPI.@)
343  */
344 INT WINAPI SnmpUtilOidNCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2, UINT count)
345 {
346     unsigned int i, len;
347
348     TRACE("(%p, %p, %d)\n", oid1, oid2, count);
349
350     if (!oid1 || !oid2) return 0;
351
352     len = min(count, oid1->idLength);
353     len = min(len, oid2->idLength);
354     for (i = 0; i < len; i++)
355     {
356         if (oid1->ids[i] > oid2->ids[i]) return 1;
357         if (oid1->ids[i] < oid2->ids[i]) return -1;
358     }
359     if (i == count) return 0;
360     if (oid1->idLength < oid2->idLength) return -1;
361     if (oid1->idLength > oid2->idLength) return 1;
362     return 0;
363 }
364
365 /***********************************************************************
366  *      SnmpUtilOidCmp          (SNMPAPI.@)
367  */
368 INT WINAPI SnmpUtilOidCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2)
369 {
370     TRACE("(%p, %p)\n", oid1, oid2);
371
372     if (oid1->idLength < oid2->idLength) return -1;
373     if (oid1->idLength > oid2->idLength) return 1;
374
375     return SnmpUtilOidNCmp(oid1, oid2, oid1->idLength);
376 }
377
378 /***********************************************************************
379  *      SnmpUtilVarBindCpy      (SNMPAPI.@)
380  */
381 INT WINAPI SnmpUtilVarBindCpy(SnmpVarBind *dst, SnmpVarBind *src)
382 {
383     unsigned int i, size;
384
385     TRACE("(%p, %p)\n", dst, src);
386
387     if (!dst) return SNMPAPI_ERROR;
388     if (!src)
389     {
390         dst->value.asnType = ASN_NULL;
391         return SNMPAPI_NOERROR;
392     }
393
394     size = src->name.idLength * sizeof(UINT);
395     if (!(dst->name.ids = HeapAlloc(GetProcessHeap(), 0, size))) return SNMPAPI_ERROR;
396
397     for (i = 0; i < src->name.idLength; i++) dst->name.ids[i] = src->name.ids[i];
398     dst->name.idLength = src->name.idLength;
399
400     if (!asn_any_copy(&dst->value, &src->value))
401     {
402         HeapFree(GetProcessHeap(), 0, dst->name.ids);
403         return SNMPAPI_ERROR;
404     }
405     return SNMPAPI_NOERROR;
406 }
407
408 /***********************************************************************
409  *      SnmpUtilVarBindFree     (SNMPAPI.@)
410  */
411 VOID WINAPI SnmpUtilVarBindFree(SnmpVarBind *vb)
412 {
413     TRACE("(%p)\n", vb);
414
415     if (!vb) return;
416
417     asn_any_free(&vb->value);
418     HeapFree(GetProcessHeap(), 0, vb->name.ids);
419     vb->name.idLength = 0;
420     vb->name.ids = NULL;
421 }
422
423 /***********************************************************************
424  *      SnmpUtilVarBindListCpy  (SNMPAPI.@)
425  */
426 INT WINAPI SnmpUtilVarBindListCpy(SnmpVarBindList *dst, SnmpVarBindList *src)
427 {
428     unsigned int i, size;
429     SnmpVarBind *src_entry, *dst_entry;
430
431     TRACE("(%p, %p)\n", dst, src);
432
433     if (!src)
434     {
435         dst->list = NULL;
436         dst->len = 0;
437         return SNMPAPI_NOERROR;
438     }
439     size = src->len * sizeof(SnmpVarBind);
440     if (!(dst->list = HeapAlloc(GetProcessHeap(), 0, size)))
441         return SNMPAPI_ERROR;
442
443     src_entry = src->list;
444     dst_entry = dst->list;
445     for (i = 0; i < src->len; i++)
446     {
447         if (SnmpUtilVarBindCpy(dst_entry, src_entry))
448         {
449             src_entry++;
450             dst_entry++;
451         }
452         else
453         {
454             for (--i; i > 0; i--) SnmpUtilVarBindFree(--dst_entry);
455             HeapFree(GetProcessHeap(), 0, dst->list);
456             return SNMPAPI_ERROR;
457         }
458     }
459     dst->len = src->len;
460     return SNMPAPI_NOERROR;
461 }
462
463 /***********************************************************************
464  *      SnmpUtilVarBindListFree (SNMPAPI.@)
465  */
466 VOID WINAPI SnmpUtilVarBindListFree(SnmpVarBindList *vb)
467 {
468     unsigned int i;
469     SnmpVarBind *entry;
470
471     TRACE("(%p)\n", vb);
472
473     entry = vb->list;
474     for (i = 0; i < vb->len; i++) SnmpUtilVarBindFree(entry++);
475     HeapFree(GetProcessHeap(), 0, vb->list);
476     vb->list = NULL;
477     vb->len = 0;
478 }
479
480 /***********************************************************************
481  *      SnmpUtilIdsToA          (SNMPAPI.@)
482  */
483 LPSTR WINAPI SnmpUtilIdsToA(UINT *ids, UINT length)
484 {
485     static char one[10], oid[514], null_oid[] = "<null oid>";
486     unsigned int i, len, left = sizeof(oid) - 1;
487
488     TRACE("(%p, %d)\n", ids, length);
489
490     if (!ids || !length) return null_oid;
491
492     *oid = 0;
493     for (i = 0; i < length; i++)
494     {
495         sprintf(one, "%d", ids[i]);
496         len = strlen(one);
497         if (left >= len)
498         {
499             strcat(oid, one);
500             left -= len;
501         }
502         else return oid;
503
504         if (i < length - 1)
505         {
506             if (left > 0)
507             {
508                 strcat(oid, ".");
509                 left--;
510             }
511             else return oid;
512         }
513     }
514     return oid;
515 }
516
517 /***********************************************************************
518  *      SnmpUtilOidToA          (SNMPAPI.@)
519  */
520 LPSTR WINAPI SnmpUtilOidToA(AsnObjectIdentifier *oid)
521 {
522     static char null_oid[] = "<null oid>";
523
524     TRACE("(%p)\n", oid);
525
526     if (oid)
527         return SnmpUtilIdsToA(oid->ids, oid->idLength);
528     else
529         return null_oid;
530 }
531
532 /***********************************************************************
533  *      SnmpUtilPrintOid        (SNMPAPI.@)
534  */
535 VOID WINAPI SnmpUtilPrintOid(AsnObjectIdentifier *oid)
536 {
537     unsigned int i;
538
539     TRACE("(%p)\n", oid);
540
541     if (!oid) return;
542
543     for (i = 0; i < oid->idLength; i++)
544     {
545         TRACE("%u", oid->ids[i]);
546         if (i < oid->idLength - 1) TRACE(".");
547     }
548     TRACE("\n");
549 }
550
551 /***********************************************************************
552  *      SnmpUtilPrintAsnAny     (SNMPAPI.@)
553  */
554 VOID WINAPI SnmpUtilPrintAsnAny(AsnAny *any)
555 {
556     unsigned int i;
557
558     TRACE("(%p)\n", any);
559
560     switch (any->asnType)
561     {
562     case ASN_NULL:       TRACE("Null value\n"); return;
563     case ASN_INTEGER32:  TRACE("Integer32 %d\n", any->asnValue.number); return;
564     case ASN_UNSIGNED32: TRACE("Unsigned32 %u\n", any->asnValue.unsigned32); return;
565     case ASN_COUNTER32:  TRACE("Counter32 %u\n", any->asnValue.counter); return;
566     case ASN_GAUGE32:    TRACE("Gauge32 %u\n", any->asnValue.gauge); return;
567     case ASN_TIMETICKS:  TRACE("Timeticks %u\n", any->asnValue.ticks); return;
568     case ASN_COUNTER64:
569     {
570         TRACE("Counter64 %x%08x\n", (DWORD)(any->asnValue.counter64.QuadPart>>32),(DWORD)any->asnValue.counter64.QuadPart);
571         return;
572     }
573     case ASN_OCTETSTRING:
574     {
575         TRACE("String ");
576         for (i = 0; i < any->asnValue.string.length; i++)
577             TRACE("%c", any->asnValue.string.stream[i]);
578         TRACE("\n");
579         return;
580     }
581     case ASN_IPADDRESS:
582     {
583         TRACE("IpAddress ");
584         if (any->asnValue.string.length < 4)
585         {
586             TRACE("Invalid\n");
587             return;
588         }
589         for (i = 0; i < 4; i++)
590         {
591             TRACE("%u", any->asnValue.string.stream[i]);
592             if (i < 3) TRACE(".");
593         }
594         TRACE("\n");
595         return;
596     }
597     case ASN_BITS:
598     {
599         TRACE("Bits ");
600         for (i = 0; i < any->asnValue.string.length; i++)
601         {
602             TRACE("0x%02x", any->asnValue.string.stream[i]);
603             if (i < any->asnValue.object.idLength - 1) TRACE(" ");
604         }
605         TRACE("\n");
606         return;
607     }
608     case ASN_OPAQUE:
609     {
610         TRACE("Opaque ");
611         for (i = 0; i < any->asnValue.string.length; i++)
612         {
613             TRACE("0x%02x", any->asnValue.string.stream[i]);
614             if (i < any->asnValue.object.idLength - 1) TRACE(" ");
615         }
616         TRACE("\n");
617         return;
618     }
619     case ASN_OBJECTIDENTIFIER:
620     {
621         TRACE("ObjectID ");
622         for (i = 0; i < any->asnValue.object.idLength; i++)
623         {
624             TRACE("%u", any->asnValue.object.ids[i]);
625             if (i < any->asnValue.object.idLength - 1) TRACE(".");
626         }
627         TRACE("\n");
628         return;
629     }
630     default:
631     {
632         TRACE("Invalid type %d\n", any->asnType);
633         return;
634     }
635     }
636 }