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