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 }