From 2e5444f85599a39fc50ba727d7cad453eb033531 Mon Sep 17 00:00:00 2001 From: Dmitry Chapyshev Date: Sun, 22 Feb 2009 14:21:45 +0000 Subject: [PATCH] - Add snmpapi from Wine svn path=/trunk/; revision=39714 --- reactos/dll/win32/snmpapi/main.c | 634 +++++++++++++++++++++++ reactos/dll/win32/snmpapi/snmpapi.c | 312 ----------- reactos/dll/win32/snmpapi/snmpapi.rbuild | 4 + reactos/media/doc/README.WINE | 3 + 4 files changed, 641 insertions(+), 312 deletions(-) create mode 100644 reactos/dll/win32/snmpapi/main.c diff --git a/reactos/dll/win32/snmpapi/main.c b/reactos/dll/win32/snmpapi/main.c new file mode 100644 index 00000000000..f8d65150f33 --- /dev/null +++ b/reactos/dll/win32/snmpapi/main.c @@ -0,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 +#include + +#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[] = ""; + 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[] = ""; + + 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; + } + } +} diff --git a/reactos/dll/win32/snmpapi/snmpapi.c b/reactos/dll/win32/snmpapi/snmpapi.c index e10851115c9..2afb21d311f 100644 --- a/reactos/dll/win32/snmpapi/snmpapi.c +++ b/reactos/dll/win32/snmpapi/snmpapi.c @@ -40,34 +40,6 @@ DWORD dwUptimeStartTicks; /* 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; -} - //////////////////////////////////////////////////////////////////////////////// /* ? SnmpSvcAddrIsIpx @@ -116,42 +88,6 @@ SnmpSvcGetEnterpriseOID(void* unknown, void* unknown2) } -/* - * @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 */ @@ -265,208 +201,6 @@ SnmpUtilAnsiToUnicode(void* unknown, void* unknown2) } -/* - * @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 */ @@ -499,51 +233,5 @@ SnmpUtilUnicodeToUTF8(void* unknown, void* unknown2) 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 */ diff --git a/reactos/dll/win32/snmpapi/snmpapi.rbuild b/reactos/dll/win32/snmpapi/snmpapi.rbuild index 2066ff617d2..513f52f4796 100644 --- a/reactos/dll/win32/snmpapi/snmpapi.rbuild +++ b/reactos/dll/win32/snmpapi/snmpapi.rbuild @@ -1,9 +1,13 @@ . + include/reactos/wine + ntdll kernel32 + wine + main.c snmpapi.c snmpapi.rc diff --git a/reactos/media/doc/README.WINE b/reactos/media/doc/README.WINE index c2614ca9447..99c4ab08bff 100644 --- a/reactos/media/doc/README.WINE +++ b/reactos/media/doc/README.WINE @@ -172,6 +172,9 @@ msvcrt - 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