[ros-diffs] [dchapyshev] 39714: - Add snmpapi from Wine

Author: dchapyshev
Date: Sun Feb 22 17:21:45 2009
New Revision: 39714

URL: http://svn.reactos.org/svn/reactos?rev=39714&view=rev
Log:
- Add snmpapi from Wine

Added:
    trunk/reactos/dll/win32/snmpapi/main.c   (with props)
Modified:
    trunk/reactos/dll/win32/snmpapi/snmpapi.c
    trunk/reactos/dll/win32/snmpapi/snmpapi.rbuild
    trunk/reactos/media/doc/README.WINE

Added: trunk/reactos/dll/win32/snmpapi/main.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/snmpapi/main.c?r…
==============================================================================
--- trunk/reactos/dll/win32/snmpapi/main.c (added)
+++ trunk/reactos/dll/win32/snmpapi/main.c [iso-8859-1] Sun Feb 22 17:21:45 2009
@@ -1,0 +1,634 @@
+/*
+ * Implementation of SNMPAPI.DLL
+ *
+ * Copyright 2002 Patrik Stridvall
+ * Copyright 2007 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "snmp.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(snmpapi);
+
+static INT asn_any_copy(AsnAny *dst, const AsnAny *src)
+{
+    memset(dst, 0, sizeof(AsnAny));
+    switch (src->asnType)
+    {
+    case ASN_INTEGER32:  dst->asnValue.number = src->asnValue.number; break;
+    case ASN_UNSIGNED32: dst->asnValue.unsigned32 = src->asnValue.unsigned32;
break;
+    case ASN_COUNTER64:  dst->asnValue.counter64 = src->asnValue.counter64; break;
+    case ASN_COUNTER32:  dst->asnValue.counter = src->asnValue.counter; break;
+    case ASN_GAUGE32:    dst->asnValue.gauge = src->asnValue.gauge; break;
+    case ASN_TIMETICKS:  dst->asnValue.ticks = src->asnValue.ticks; break;
+
+    case ASN_OCTETSTRING:
+    case ASN_BITS:
+    case ASN_SEQUENCE:
+    case ASN_IPADDRESS:
+    case ASN_OPAQUE:
+    {
+        BYTE *stream;
+        UINT length = src->asnValue.string.length;
+
+        if (!(stream = HeapAlloc(GetProcessHeap(), 0, length))) return SNMPAPI_ERROR;
+        memcpy(stream, src->asnValue.string.stream, length);
+
+        dst->asnValue.string.stream = stream;
+        dst->asnValue.string.length = length;
+        dst->asnValue.string.dynamic = TRUE;
+        break;
+    }
+    case ASN_OBJECTIDENTIFIER:
+    {
+        UINT *ids, i, size = src->asnValue.object.idLength * sizeof(UINT);
+
+        if (!(ids = HeapAlloc(GetProcessHeap(), 0, size))) return SNMPAPI_ERROR;
+
+        dst->asnValue.object.ids = ids;
+        dst->asnValue.object.idLength = src->asnValue.object.idLength;
+
+        for (i = 0; i < dst->asnValue.object.idLength; i++)
+            dst->asnValue.object.ids[i] = src->asnValue.object.ids[i];
+        break;
+    }
+    default:
+    {
+        WARN("unknown ASN type: %d\n", src->asnType);
+        return SNMPAPI_ERROR;
+    }
+    }
+    dst->asnType = src->asnType;
+    return SNMPAPI_NOERROR;
+}
+
+static void asn_any_free(AsnAny *any)
+{
+    switch (any->asnType)
+    {
+    case ASN_OCTETSTRING:
+    case ASN_BITS:
+    case ASN_SEQUENCE:
+    case ASN_IPADDRESS:
+    case ASN_OPAQUE:
+    {
+        if (any->asnValue.string.dynamic)
+        {
+            HeapFree(GetProcessHeap(), 0, any->asnValue.string.stream);
+            any->asnValue.string.stream = NULL;
+        }
+        break;
+    }
+    case ASN_OBJECTIDENTIFIER:
+    {
+        HeapFree(GetProcessHeap(), 0, any->asnValue.object.ids);
+        any->asnValue.object.ids = NULL;
+        break;
+    }
+    default: break;
+    }
+    any->asnType = ASN_NULL;
+}
+
+/***********************************************************************
+ *		DllMain for SNMPAPI
+ */
+BOOL WINAPI DllMain(
+	HINSTANCE hInstDLL,
+	DWORD fdwReason,
+	LPVOID lpvReserved)
+{
+    TRACE("(%p,%d,%p)\n", hInstDLL, fdwReason, lpvReserved);
+
+    switch(fdwReason) {
+    case DLL_WINE_PREATTACH:
+        return FALSE;  /* prefer native version */
+    case DLL_PROCESS_ATTACH:
+        DisableThreadLibraryCalls(hInstDLL);
+        break;
+    case DLL_PROCESS_DETACH:
+        break;
+    }
+
+    return TRUE;
+}
+
+/***********************************************************************
+ *      SnmpUtilDbgPrint        (SNMPAPI.@)
+ *
+ * NOTES
+ *  The Microsoft headers claim this function uses the stdcall calling
+ *  convention. But stdcall functions cannot take a variable number of
+ *  arguments so this does not make sense. The stdcall specification is
+ *  probably ignored by Microsoft's compiler in this case. So declare it
+ *  correctly in Wine so it works with all compilers.
+ */
+VOID WINAPI SnmpUtilDbgPrint(INT loglevel, LPSTR format, ...)
+{
+    FIXME("(%d, %s)\n", loglevel, debugstr_a(format));
+}
+
+/***********************************************************************
+ *      SnmpUtilMemAlloc        (SNMPAPI.@)
+ */
+LPVOID WINAPI SnmpUtilMemAlloc(UINT nbytes)
+{
+    TRACE("(%d)\n", nbytes);
+    return HeapAlloc(GetProcessHeap(), 0, nbytes);
+}
+
+/***********************************************************************
+ *      SnmpUtilMemReAlloc      (SNMPAPI.@)
+ */
+LPVOID WINAPI SnmpUtilMemReAlloc(LPVOID mem, UINT nbytes)
+{
+    TRACE("(%p, %d)\n", mem, nbytes);
+    return HeapReAlloc(GetProcessHeap(), 0, mem, nbytes);
+}
+
+/***********************************************************************
+ *      SnmpUtilMemFree         (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilMemFree(LPVOID mem)
+{
+    TRACE("(%p)\n", mem);
+    HeapFree(GetProcessHeap(), 0, mem);
+}
+
+/***********************************************************************
+ *      SnmpUtilAsnAnyCpy       (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilAsnAnyCpy(AsnAny *dst, AsnAny *src)
+{
+    TRACE("(%p, %p)\n", dst, src);
+    return asn_any_copy(dst, src);
+}
+
+/***********************************************************************
+ *      SnmpUtilAsnAnyFree      (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilAsnAnyFree(AsnAny *any)
+{
+    TRACE("(%p)\n", any);
+    asn_any_free(any);
+}
+
+/***********************************************************************
+ *      SnmpUtilOctetsCpy       (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOctetsCpy(AsnOctetString *dst, AsnOctetString *src)
+{
+    TRACE("(%p, %p)\n", dst, src);
+
+    if (!dst) return SNMPAPI_ERROR;
+    if (!src)
+    {
+        dst->dynamic = FALSE;
+        dst->length = 0;
+        dst->stream = NULL;
+        return SNMPAPI_NOERROR;
+    }
+    if ((dst->stream = HeapAlloc(GetProcessHeap(), 0, src->length)))
+    {
+        unsigned int i;
+
+        dst->dynamic = TRUE;
+        dst->length = src->length;
+        for (i = 0; i < dst->length; i++) dst->stream[i] = src->stream[i];
+        return SNMPAPI_NOERROR;
+    }
+    return SNMPAPI_ERROR;
+}
+
+/***********************************************************************
+ *      SnmpUtilOctetsFree      (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilOctetsFree(AsnOctetString *octets)
+{
+    TRACE("(%p)\n", octets);
+
+    if (octets)
+    {
+        octets->length = 0;
+        if (octets->dynamic) HeapFree(GetProcessHeap(), 0, octets->stream);
+        octets->stream = NULL;
+        octets->dynamic = FALSE;
+    }
+}
+
+/***********************************************************************
+ *      SnmpUtilOctetsNCmp      (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOctetsNCmp(AsnOctetString *octets1, AsnOctetString *octets2, UINT
count)
+{
+    INT ret;
+    unsigned int i;
+
+    TRACE("(%p, %p, %d)\n", octets1, octets2, count);
+
+    if (!octets1 || !octets2) return 0;
+
+    for (i = 0; i < count; i++)
+        if ((ret = octets1->stream[i] - octets2->stream[i])) return ret;
+
+    return 0;
+}
+
+/***********************************************************************
+ *      SnmpUtilOctetsCmp       (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOctetsCmp(AsnOctetString *octets1, AsnOctetString *octets2)
+{
+    TRACE("(%p, %p)\n", octets1, octets2);
+
+    if (octets1->length < octets2->length) return -1;
+    if (octets1->length > octets2->length) return 1;
+
+    return SnmpUtilOctetsNCmp(octets1, octets2, octets1->length);
+}
+
+/***********************************************************************
+ *      SnmpUtilOidAppend       (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOidAppend(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
+{
+    UINT *ids, i, size;
+
+    TRACE("(%p, %p)\n", dst, src);
+
+    if (!dst) return SNMPAPI_ERROR;
+    if (!src) return SNMPAPI_NOERROR;
+
+    size = (src->idLength + dst->idLength) * sizeof(UINT);
+    if (!(ids = HeapReAlloc(GetProcessHeap(), 0, dst->ids, size)))
+    {
+        if (!(ids = HeapAlloc(GetProcessHeap(), 0, size)))
+        {
+            SetLastError(SNMP_MEM_ALLOC_ERROR);
+            return SNMPAPI_ERROR;
+        }
+        else memcpy(ids, dst->ids, dst->idLength * sizeof(UINT));
+    }
+
+    for (i = 0; i < src->idLength; i++) ids[i + dst->idLength] =
src->ids[i];
+    dst->idLength = dst->idLength + src->idLength;
+    dst->ids = ids;
+
+    return SNMPAPI_NOERROR;
+}
+
+/***********************************************************************
+ *      SnmpUtilOidCpy          (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOidCpy(AsnObjectIdentifier *dst, AsnObjectIdentifier *src)
+{
+    TRACE("(%p, %p)\n", dst, src);
+
+    if (!dst) return SNMPAPI_ERROR;
+    if (!src)
+    {
+        dst->idLength = 0;
+        dst->ids = NULL;
+        return SNMPAPI_NOERROR;
+    }
+    if ((dst->ids = HeapAlloc(GetProcessHeap(), 0, src->idLength * sizeof(UINT))))
+    {
+        unsigned int i;
+
+        dst->idLength = src->idLength;
+        for (i = 0; i < dst->idLength; i++) dst->ids[i] = src->ids[i];
+        return SNMPAPI_NOERROR;
+    }
+    return SNMPAPI_ERROR;
+}
+
+/***********************************************************************
+ *      SnmpUtilOidFree         (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilOidFree(AsnObjectIdentifier *oid)
+{
+    TRACE("(%p)\n", oid);
+
+    if (!oid) return;
+
+    oid->idLength = 0;
+    HeapFree(GetProcessHeap(), 0, oid->ids);
+    oid->ids = NULL;
+}
+
+/***********************************************************************
+ *      SnmpUtilOidNCmp         (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOidNCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2, UINT
count)
+{
+    unsigned int i, len;
+
+    TRACE("(%p, %p, %d)\n", oid1, oid2, count);
+
+    if (!oid1 || !oid2) return 0;
+
+    len = min(count, oid1->idLength);
+    len = min(len, oid2->idLength);
+    for (i = 0; i < len; i++)
+    {
+        if (oid1->ids[i] > oid2->ids[i]) return 1;
+        if (oid1->ids[i] < oid2->ids[i]) return -1;
+    }
+    if (i == count) return 0;
+    if (oid1->idLength < oid2->idLength) return -1;
+    if (oid1->idLength > oid2->idLength) return 1;
+    return 0;
+}
+
+/***********************************************************************
+ *      SnmpUtilOidCmp          (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilOidCmp(AsnObjectIdentifier *oid1, AsnObjectIdentifier *oid2)
+{
+    TRACE("(%p, %p)\n", oid1, oid2);
+
+    if (oid1->idLength < oid2->idLength) return -1;
+    if (oid1->idLength > oid2->idLength) return 1;
+
+    return SnmpUtilOidNCmp(oid1, oid2, oid1->idLength);
+}
+
+/***********************************************************************
+ *      SnmpUtilVarBindCpy      (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilVarBindCpy(SnmpVarBind *dst, SnmpVarBind *src)
+{
+    unsigned int i, size;
+
+    TRACE("(%p, %p)\n", dst, src);
+
+    if (!dst) return SNMPAPI_ERROR;
+    if (!src)
+    {
+        dst->value.asnType = ASN_NULL;
+        return SNMPAPI_NOERROR;
+    }
+
+    size = src->name.idLength * sizeof(UINT);
+    if (!(dst->name.ids = HeapAlloc(GetProcessHeap(), 0, size))) return
SNMPAPI_ERROR;
+
+    for (i = 0; i < src->name.idLength; i++) dst->name.ids[i] =
src->name.ids[i];
+    dst->name.idLength = src->name.idLength;
+
+    if (!asn_any_copy(&dst->value, &src->value))
+    {
+        HeapFree(GetProcessHeap(), 0, dst->name.ids);
+        return SNMPAPI_ERROR;
+    }
+    return SNMPAPI_NOERROR;
+}
+
+/***********************************************************************
+ *      SnmpUtilVarBindFree     (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilVarBindFree(SnmpVarBind *vb)
+{
+    TRACE("(%p)\n", vb);
+
+    if (!vb) return;
+
+    asn_any_free(&vb->value);
+    HeapFree(GetProcessHeap(), 0, vb->name.ids);
+    vb->name.idLength = 0;
+    vb->name.ids = NULL;
+}
+
+/***********************************************************************
+ *      SnmpUtilVarBindListCpy  (SNMPAPI.@)
+ */
+INT WINAPI SnmpUtilVarBindListCpy(SnmpVarBindList *dst, SnmpVarBindList *src)
+{
+    unsigned int i, size;
+    SnmpVarBind *src_entry, *dst_entry;
+
+    TRACE("(%p, %p)\n", dst, src);
+
+    if (!src)
+    {
+        dst->list = NULL;
+        dst->len = 0;
+        return SNMPAPI_NOERROR;
+    }
+    size = src->len * sizeof(SnmpVarBind);
+    if (!(dst->list = HeapAlloc(GetProcessHeap(), 0, size)))
+        return SNMPAPI_ERROR;
+
+    src_entry = src->list;
+    dst_entry = dst->list;
+    for (i = 0; i < src->len; i++)
+    {
+        if (SnmpUtilVarBindCpy(dst_entry, src_entry))
+        {
+            src_entry++;
+            dst_entry++;
+        }
+        else
+        {
+            for (--i; i > 0; i--) SnmpUtilVarBindFree(--dst_entry);
+            HeapFree(GetProcessHeap(), 0, dst->list);
+            return SNMPAPI_ERROR;
+        }
+    }
+    dst->len = src->len;
+    return SNMPAPI_NOERROR;
+}
+
+/***********************************************************************
+ *      SnmpUtilVarBindListFree (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilVarBindListFree(SnmpVarBindList *vb)
+{
+    unsigned int i;
+    SnmpVarBind *entry;
+
+    TRACE("(%p)\n", vb);
+
+    entry = vb->list;
+    for (i = 0; i < vb->len; i++) SnmpUtilVarBindFree(entry++);
+    HeapFree(GetProcessHeap(), 0, vb->list);
+    vb->list = NULL;
+    vb->len = 0;
+}
+
+/***********************************************************************
+ *      SnmpUtilIdsToA          (SNMPAPI.@)
+ */
+LPSTR WINAPI SnmpUtilIdsToA(UINT *ids, UINT length)
+{
+    static char one[10], oid[514], null_oid[] = "<null oid>";
+    unsigned int i, len, left = sizeof(oid) - 1;
+
+    TRACE("(%p, %d)\n", ids, length);
+
+    if (!ids || !length) return null_oid;
+
+    *oid = 0;
+    for (i = 0; i < length; i++)
+    {
+        sprintf(one, "%d", ids[i]);
+        len = strlen(one);
+        if (left >= len)
+        {
+            strcat(oid, one);
+            left -= len;
+        }
+        else return oid;
+
+        if (i < length - 1)
+        {
+            if (left > 0)
+            {
+                strcat(oid, ".");
+                left--;
+            }
+            else return oid;
+        }
+    }
+    return oid;
+}
+
+/***********************************************************************
+ *      SnmpUtilOidToA          (SNMPAPI.@)
+ */
+LPSTR WINAPI SnmpUtilOidToA(AsnObjectIdentifier *oid)
+{
+    static char null_oid[] = "<null oid>";
+
+    TRACE("(%p)\n", oid);
+
+    if (oid)
+        return SnmpUtilIdsToA(oid->ids, oid->idLength);
+    else
+        return null_oid;
+}
+
+/***********************************************************************
+ *      SnmpUtilPrintOid        (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilPrintOid(AsnObjectIdentifier *oid)
+{
+    unsigned int i;
+
+    TRACE("(%p)\n", oid);
+
+    if (!oid) return;
+
+    for (i = 0; i < oid->idLength; i++)
+    {
+        TRACE("%u", oid->ids[i]);
+        if (i < oid->idLength - 1) TRACE(".");
+    }
+    TRACE("\n");
+}
+
+/***********************************************************************
+ *      SnmpUtilPrintAsnAny     (SNMPAPI.@)
+ */
+VOID WINAPI SnmpUtilPrintAsnAny(AsnAny *any)
+{
+    unsigned int i;
+
+    TRACE("(%p)\n", any);
+
+    switch (any->asnType)
+    {
+    case ASN_NULL:       TRACE("Null value\n"); return;
+    case ASN_INTEGER32:  TRACE("Integer32 %d\n", any->asnValue.number);
return;
+    case ASN_UNSIGNED32: TRACE("Unsigned32 %u\n", any->asnValue.unsigned32);
return;
+    case ASN_COUNTER32:  TRACE("Counter32 %u\n", any->asnValue.counter);
return;
+    case ASN_GAUGE32:    TRACE("Gauge32 %u\n", any->asnValue.gauge);
return;
+    case ASN_TIMETICKS:  TRACE("Timeticks %u\n", any->asnValue.ticks);
return;
+    case ASN_COUNTER64:
+    {
+        TRACE("Counter64 %x%08x\n",
(DWORD)(any->asnValue.counter64.QuadPart>>32),(DWORD)any->asnValue.counter64.QuadPart);
+        return;
+    }
+    case ASN_OCTETSTRING:
+    {
+        TRACE("String ");
+        for (i = 0; i < any->asnValue.string.length; i++)
+            TRACE("%c", any->asnValue.string.stream[i]);
+        TRACE("\n");
+        return;
+    }
+    case ASN_IPADDRESS:
+    {
+        TRACE("IpAddress ");
+        if (any->asnValue.string.length < 4)
+        {
+            TRACE("Invalid\n");
+            return;
+        }
+        for (i = 0; i < 4; i++)
+        {
+            TRACE("%u", any->asnValue.string.stream[i]);
+            if (i < 3) TRACE(".");
+        }
+        TRACE("\n");
+        return;
+    }
+    case ASN_BITS:
+    {
+        TRACE("Bits ");
+        for (i = 0; i < any->asnValue.string.length; i++)
+        {
+            TRACE("0x%02x", any->asnValue.string.stream[i]);
+            if (i < any->asnValue.object.idLength - 1) TRACE(" ");
+        }
+        TRACE("\n");
+        return;
+    }
+    case ASN_OPAQUE:
+    {
+        TRACE("Opaque ");
+        for (i = 0; i < any->asnValue.string.length; i++)
+        {
+            TRACE("0x%02x", any->asnValue.string.stream[i]);
+            if (i < any->asnValue.object.idLength - 1) TRACE(" ");
+        }
+        TRACE("\n");
+        return;
+    }
+    case ASN_OBJECTIDENTIFIER:
+    {
+        TRACE("ObjectID ");
+        for (i = 0; i < any->asnValue.object.idLength; i++)
+        {
+            TRACE("%u", any->asnValue.object.ids[i]);
+            if (i < any->asnValue.object.idLength - 1) TRACE(".");
+        }
+        TRACE("\n");
+        return;
+    }
+    default:
+    {
+        TRACE("Invalid type %d\n", any->asnType);
+        return;
+    }
+    }
+}

Propchange: trunk/reactos/dll/win32/snmpapi/main.c
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: trunk/reactos/dll/win32/snmpapi/snmpapi.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/snmpapi/snmpapi.…
==============================================================================
--- trunk/reactos/dll/win32/snmpapi/snmpapi.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/snmpapi/snmpapi.c [iso-8859-1] Sun Feb 22 17:21:45 2009
@@ -39,34 +39,6 @@
 
 /* To make the linker happy */
 //VOID WINAPI KeBugCheck (ULONG	BugCheckCode) {}
-
-
-BOOL
-EXPORT
-DllMain(HANDLE hInstDll,
-        ULONG dwReason,
-        PVOID Reserved)
-{
-    WSH_DbgPrint(MIN_TRACE, ("DllMain of snmpapi.dll\n"));
-
-    switch (dwReason) {
-    case DLL_PROCESS_ATTACH:
-        /* Don't need thread attach notifications
-           so disable them to improve performance */
-        DisableThreadLibraryCalls(hInstDll);
-        break;
-
-    case DLL_THREAD_ATTACH:
-        break;
-
-    case DLL_THREAD_DETACH:
-        break;
-
-    case DLL_PROCESS_DETACH:
-        break;
-    }
-    return TRUE;
-}
 
 ////////////////////////////////////////////////////////////////////////////////
 /*
@@ -119,42 +91,6 @@
 /*
  * @implemented
  */
-LPVOID
-SNMP_FUNC_TYPE
-SnmpUtilMemAlloc(UINT nBytes)
-{
-	VOID* pMem = NULL;
-	pMem = GlobalAlloc(GPTR, nBytes);
-    return pMem;
-}
-
-
-/*
- * @implemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilMemFree(LPVOID pMem)
-{
-	GlobalFree(pMem);
-}
-
-
-/*
- * @unimplemented
- */
-LPVOID
-SNMP_FUNC_TYPE
-SnmpUtilMemReAlloc(LPVOID pMem, UINT nBytes)
-{
-	pMem = GlobalReAlloc(pMem, nBytes, GPTR);
-    return pMem;
-}
-
-
-/*
- * @implemented
- */
 VOID
 SNMP_FUNC_TYPE
 SnmpSvcInitUptime()
@@ -268,208 +204,6 @@
 /*
  * @unimplemented
  */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilAsnAnyCpy(AsnAny *pAnyDst, AsnAny *pAnySrc)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilAsnAnyFree(AsnAny *pAny)
-{
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilDbgPrint(INT nLogLevel, LPSTR szFormat, ...)
-{
-    switch (nLogLevel) {
-    case SNMP_LOG_SILENT:
-        break;
-    case SNMP_LOG_FATAL:
-        break;
-    case SNMP_LOG_ERROR:
-        break;
-    case SNMP_LOG_WARNING:
-        break;
-    case SNMP_LOG_TRACE:
-        break;
-    case SNMP_LOG_VERBOSE:
-        break;
-    }
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
-LPSTR
-SNMP_FUNC_TYPE
-SnmpUtilIdsToA(UINT *Ids, UINT IdLength)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOctetsCmp(AsnOctetString *pOctets1, AsnOctetString *pOctets2)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOctetsCpy(AsnOctetString *pOctetsDst, AsnOctetString *pOctetsSrc)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilOctetsFree(AsnOctetString *pOctets)
-{
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOctetsNCmp(AsnOctetString *pOctets1, AsnOctetString *pOctets2, UINT nChars)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOidAppend(AsnObjectIdentifier *pOidDst, AsnObjectIdentifier *pOidSrc)
-{
-	//SnmpUtilMemReAlloc(pOidDst, sizeof(AsnObjectIdentifier));
-	//SetLastError(SNMP_BERAPI_OVERFLOW);
-	SetLastError(SNMP_MEM_ALLOC_ERROR);
-    return 0; // failed
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOidCmp(AsnObjectIdentifier *pOid1, AsnObjectIdentifier *pOid2)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOidCpy(AsnObjectIdentifier *pOidDst, AsnObjectIdentifier *pOidSrc)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilOidFree(AsnObjectIdentifier *pOid)
-{
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilOidNCmp(AsnObjectIdentifier *pOid1, AsnObjectIdentifier *pOid2, UINT nSubIds)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-LPSTR
-SNMP_FUNC_TYPE
-SnmpUtilOidToA(AsnObjectIdentifier *Oid)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilPrintAsnAny(AsnAny *pAny)
-{
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilPrintOid(AsnObjectIdentifier *Oid)
-{
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
 VOID
 SNMP_FUNC_TYPE
 SnmpUtilUTF8ToUnicode(void* unknown, void* unknown2)
@@ -499,51 +233,5 @@
     UNIMPLEMENTED
 }
 
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilVarBindCpy(SnmpVarBind *pVbDst, SnmpVarBind *pVbSrc)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilVarBindFree(SnmpVarBind *pVb)
-{
-    UNIMPLEMENTED
-}
-
-
-/*
- * @unimplemented
- */
-SNMPAPI
-SNMP_FUNC_TYPE
-SnmpUtilVarBindListCpy(SnmpVarBindList *pVblDst, SnmpVarBindList *pVblSrc)
-{
-    UNIMPLEMENTED
-    return 0;
-}
-
-
-/*
- * @unimplemented
- */
-VOID
-SNMP_FUNC_TYPE
-SnmpUtilVarBindListFree(SnmpVarBindList *pVbl)
-{
-    UNIMPLEMENTED
-}
-
 /* EOF */
 

Modified: trunk/reactos/dll/win32/snmpapi/snmpapi.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/snmpapi/snmpapi.…
==============================================================================
--- trunk/reactos/dll/win32/snmpapi/snmpapi.rbuild [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/snmpapi/snmpapi.rbuild [iso-8859-1] Sun Feb 22 17:21:45 2009
@@ -1,9 +1,13 @@
 <module name="snmpapi" type="win32dll"
baseaddress="${BASEADDRESS_SNMPAPI}" installbase="system32"
installname="snmpapi.dll" unicode="yes">
 	<importlibrary definition="snmpapi.spec" />
 	<include base="snmpapi">.</include>
+	<include base="ReactOS">include/reactos/wine</include>
+	<define name="__WINESRC__" />
 	<define name="_DISABLE_TIDENTS" />
 	<library>ntdll</library>
 	<library>kernel32</library>
+	<library>wine</library>
+	<file>main.c</file>
 	<file>snmpapi.c</file>
 	<file>snmpapi.rc</file>
 </module>

Modified: trunk/reactos/media/doc/README.WINE
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/media/doc/README.WINE?rev=…
==============================================================================
--- trunk/reactos/media/doc/README.WINE [iso-8859-1] (original)
+++ trunk/reactos/media/doc/README.WINE [iso-8859-1] Sun Feb 22 17:21:45 2009
@@ -172,6 +172,9 @@
   reactos/lib/sdk/crt/wine/undname.c            # Synced at XXXXXXXX
   reactos/lib/sdk/crt/thread/thread.c           # Synced at 20080604
 
+snmpapi -
+  reactos/dll/win32/snmpapi/main.c              # Synced at 20090222
+
 User32 -
   reactos/dll/win32/user32/controls/button.c    # Synced to Wine-1_1_13
   reactos/dll/win32/user32/controls/combo.c     # Synced to Wine-1_1_13