* iphlpapi dll implementation
*
* Copyright (C) 2003 Juan Lang
+ * 2018 Pierre Schweitzer
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include <config.h>
#include "iphlpapi_private.h"
#include <strsafe.h>
+#include <psapi.h>
WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
/******************************************************************
* AddIPAddress (IPHLPAPI.@)
*
- *
* PARAMS
- *
* Address [In]
* IpMask [In]
* IfIndex [In]
* NTEInstance [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AddIPAddress(IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
{
DWORD getInterfaceGatewayByIndex(DWORD index)
{
- DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
- RouteTable *table = getRouteTable();
- if (!table) return 0;
+ DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
+ RouteTable *table = getRouteTable();
+ if (!table) return 0;
for (ndx = 0; ndx < numRoutes; ndx++)
{
/******************************************************************
* AllocateAndGetIfTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppIfTable [Out] -- pointer into which the MIB_IFTABLE is
* allocated and returned.
* bOrder [In] -- passed to GetIfTable to order the table
*
* RETURNS -- ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
* GetIfTable returns otherwise
- *
*/
DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable,
BOOL bOrder, HANDLE heap, DWORD flags)
{
DWORD ret;
- TRACE("ppIfTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n", ppIfTable,
- (DWORD)bOrder, (DWORD)heap, flags);
+ TRACE("ppIfTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n", ppIfTable,
+ (DWORD)bOrder, heap, flags);
if (!ppIfTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppIpAddrTable [Out]
* bOrder [In] -- passed to GetIpAddrTable to order the table
* heap [In] -- heap from which the table is allocated
* flags [In] -- flags to HeapAlloc
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable,
BOOL bOrder, HANDLE heap, DWORD flags)
{
DWORD ret;
- TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
- ppIpAddrTable, (DWORD)bOrder, (DWORD)heap, flags);
+ TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
+ ppIpAddrTable, (DWORD)bOrder, heap, flags);
if (!ppIpAddrTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
*
- *
* ppIpForwardTable [Out] -- pointer into which the MIB_IPFORWARDTABLE is
* allocated and returned.
* bOrder [In] -- passed to GetIfTable to order the table
*
* RETURNS -- ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
* GetIpForwardTable returns otherwise
- *
*/
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *
ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
{
DWORD ret;
- TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
- ppIpForwardTable, (DWORD)bOrder, (DWORD)heap, flags);
+ TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
+ ppIpForwardTable, (DWORD)bOrder, heap, flags);
if (!ppIpForwardTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppIpNetTable [Out]
* bOrder [In] -- passed to GetIpNetTable to order the table
* heap [In] -- heap from which the table is allocated
* flags [In] -- flags to HeapAlloc
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable,
BOOL bOrder, HANDLE heap, DWORD flags)
{
DWORD ret;
- TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
- ppIpNetTable, (DWORD)bOrder, (DWORD)heap, flags);
+ TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
+ ppIpNetTable, (DWORD)bOrder, heap, flags);
if (!ppIpNetTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppTcpTable [Out]
* bOrder [In] -- passed to GetTcpTable to order the table
* heap [In] -- heap from which the table is allocated
* flags [In] -- flags to HeapAlloc
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable,
BOOL bOrder, HANDLE heap, DWORD flags)
{
DWORD ret;
- TRACE("ppTcpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
- ppTcpTable, (DWORD)bOrder, (DWORD)heap, flags);
+ TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
+ ppTcpTable, (DWORD)bOrder, heap, flags);
if (!ppTcpTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetTcpExTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppTcpTable [Out]
* bOrder [In] -- passed to GetExtendedTcpTable to order the table
* heap [In] -- heap from which the table is allocated
* family [In] -- passed to GetExtendedTcpTable to select INET family
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetTcpExTableFromStack(PVOID *ppTcpTable,
BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
{
DWORD ret;
- TRACE("ppTcpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx, family 0x%08lx\n",
- ppTcpTable, (DWORD)bOrder, (DWORD)heap, flags, family);
+ TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
+ ppTcpTable, (DWORD)bOrder, heap, flags, family);
if (!ppTcpTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetTcpExTable2FromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppTcpTable [Out]
* bOrder [In] -- passed to GetExtendedTcpTable to order the table
* heap [In] -- heap from which the table is allocated
* class [In] -- passed to GetExtendedTcpTable to select information
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetTcpExTable2FromStack(PVOID *ppTcpTable,
BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, TCP_TABLE_CLASS class)
{
DWORD ret;
- TRACE("ppTcpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx, family %ld, class %ld\n",
- ppTcpTable, (DWORD)bOrder, (DWORD)heap, flags, family, class);
+ TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
+ ppTcpTable, (DWORD)bOrder, heap, flags, family, class);
if (!ppTcpTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppUdpTable [Out]
* bOrder [In] -- passed to GetUdpTable to order the table
* heap [In] -- heap from which the table is allocated
* flags [In] -- flags to HeapAlloc
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable,
BOOL bOrder, HANDLE heap, DWORD flags)
{
DWORD ret;
- TRACE("ppUdpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
- ppUdpTable, (DWORD)bOrder, (DWORD)heap, flags);
+ TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
+ ppUdpTable, (DWORD)bOrder, heap, flags);
if (!ppUdpTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetUdpExTableFromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppUdpTable [Out]
* bOrder [In] -- passed to GetExtendedUdpTable to order the table
* heap [In] -- heap from which the table is allocated
* family [In] -- passed to GetExtendedUdpTable to select INET family
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetUdpExTableFromStack(PVOID *ppUdpTable,
BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
{
DWORD ret;
- TRACE("ppUdpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx, family 0x%08lx\n",
- ppUdpTable, (DWORD)bOrder, (DWORD)heap, flags, family);
+ TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
+ ppUdpTable, (DWORD)bOrder, heap, flags, family);
if (!ppUdpTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* AllocateAndGetUdpExTable2FromStack (IPHLPAPI.@)
*
- *
* PARAMS
- *
* ppUdpTable [Out]
* bOrder [In] -- passed to GetExtendedUdpTable to order the table
* heap [In] -- heap from which the table is allocated
* class [In] -- passed to GetExtendedUdpTable to select information
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI AllocateAndGetUdpExTable2FromStack(PVOID *ppUdpTable,
BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, UDP_TABLE_CLASS class)
{
DWORD ret;
- TRACE("ppUdpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx, family %ld, class %ld\n",
- ppUdpTable, (DWORD)bOrder, (DWORD)heap, flags, family, class);
+ TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
+ ppUdpTable, (DWORD)bOrder, heap, flags, family, class);
if (!ppUdpTable)
ret = ERROR_INVALID_PARAMETER;
else {
/******************************************************************
* CreateIpForwardEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pRoute [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
{
/******************************************************************
* CreateIpNetEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pArpEntry [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
{
/******************************************************************
* CreateProxyArpEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* dwAddress [In]
* dwMask [In]
* dwIfIndex [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
{
/******************************************************************
* DeleteIPAddress (IPHLPAPI.@)
*
- *
* PARAMS
- *
* NTEContext [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
{
/******************************************************************
* DeleteIpForwardEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pRoute [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
{
/******************************************************************
* DeleteIpNetEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pArpEntry [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
{
/******************************************************************
* DeleteProxyArpEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* dwAddress [In]
* dwMask [In]
* dwIfIndex [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
{
/******************************************************************
* EnableRouter (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pHandle [In/Out]
* pOverlapped [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI EnableRouter(HANDLE * pHandle, OVERLAPPED * pOverlapped)
{
/******************************************************************
* FlushIpNetTable (IPHLPAPI.@)
*
- *
* PARAMS
- *
* dwIfIndex [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
{
/******************************************************************
* GetAdapterIndex (IPHLPAPI.@)
*
- *
* PARAMS
- *
* AdapterName [In/Out]
* IfIndex [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
{
/******************************************************************
* GetAdaptersInfo (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pAdapterInfo [In/Out]
* pOutBufLen [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
{
IP_ADDRESS_STRING primaryWINS, secondaryWINS;
memset(pAdapterInfo, 0, size);
- if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
- "Software\\Wine\\Wine\\Config\\Network", 0, KEY_READ,
- &hKey) == ERROR_SUCCESS) {
+ /* @@ Wine registry key: HKCU\Software\Wine\Network */
+ if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Network", &hKey) == ERROR_SUCCESS) {
DWORD size = sizeof(primaryWINS.String);
unsigned long addr;
winsEnabled = TRUE;
RegCloseKey(hKey);
}
- TRACE("num of index is %lu\n", table->numIndexes);
+ TRACE("num of index is %lu\n", table->numIndexes);
for (ndx = 0; ndx < table->numIndexes; ndx++) {
PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
DWORD addrLen = sizeof(ptr->Address), type;
/******************************************************************
* GetBestInterface (IPHLPAPI.@)
*
- *
* PARAMS
- *
* dwDestAddr [In]
* pdwBestIfIndex [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
{
/******************************************************************
* GetBestRoute (IPHLPAPI.@)
*
- *
* PARAMS
- *
* dwDestAddr [In]
* dwSourceAddr [In]
* OUT [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
{
* RETURNS
* Success: NO_ERROR
* Failure: either ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER
- *
- * NOTES
*/
-
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
{
- DWORD i, count;
+ DWORD i, count, size;
DWORD ret = NO_ERROR;
if (!pdwSize)
{
case TCP_TABLE_BASIC_ALL:
{
- PMIB_TCPTABLE pOurTcpTable = getTcpTable();
+ PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
if (pOurTcpTable)
{
- if (sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW) > *pdwSize || !pTheirTcpTable)
+ size = FIELD_OFFSET(MIB_TCPTABLE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
+ if (size > *pdwSize || !pTheirTcpTable)
{
- *pdwSize = sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
- memcpy(pTheirTcpTable, pOurTcpTable, sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW));
+ memcpy(pTheirTcpTable, pOurTcpTable, size);
if (bOrder)
qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
sizeof(MIB_TCPROW), TcpTableSorter);
}
- free(pOurTcpTable);
+ HeapFree(GetProcessHeap(),0, pOurTcpTable);
}
}
break;
case TCP_TABLE_BASIC_CONNECTIONS:
{
- PMIB_TCPTABLE pOurTcpTable = getTcpTable();
+ PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
if (pOurTcpTable)
}
}
- if (sizeof(DWORD) + count * sizeof(MIB_TCPROW) > *pdwSize || !pTheirTcpTable)
+ size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
+ if (size > *pdwSize || !pTheirTcpTable)
{
- *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
sizeof(MIB_TCPROW), TcpTableSorter);
}
- free(pOurTcpTable);
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
}
}
break;
case TCP_TABLE_BASIC_LISTENER:
{
- PMIB_TCPTABLE pOurTcpTable = getTcpTable();
+ PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
if (pOurTcpTable)
}
}
- if (sizeof(DWORD) + count * sizeof(MIB_TCPROW) > *pdwSize || !pTheirTcpTable)
+ size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
+ if (size > *pdwSize || !pTheirTcpTable)
{
- *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
sizeof(MIB_TCPROW), TcpTableSorter);
}
- free(pOurTcpTable);
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
}
}
break;
case TCP_TABLE_OWNER_PID_ALL:
{
- PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getOwnerTcpTable();
+ PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
if (pOurTcpTable)
{
- if (sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID) > *pdwSize || !pTheirTcpTable)
+ size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID);
+ if (size > *pdwSize || !pTheirTcpTable)
{
- *pdwSize = sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
- memcpy(pTheirTcpTable, pOurTcpTable, sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID));
+ memcpy(pTheirTcpTable, pOurTcpTable, size);
/* Don't sort on PID, so use basic helper */
if (bOrder)
sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
}
- free(pOurTcpTable);
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
}
}
break;
case TCP_TABLE_OWNER_PID_CONNECTIONS:
{
- PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getOwnerTcpTable();
+ PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
if (pOurTcpTable)
}
}
- if (sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID) > *pdwSize || !pTheirTcpTable)
+ size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
+ if (size > *pdwSize || !pTheirTcpTable)
{
- *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
}
- free(pOurTcpTable);
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
}
}
break;
case TCP_TABLE_OWNER_PID_LISTENER:
{
- PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getOwnerTcpTable();
+ PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
if (pOurTcpTable)
}
}
- if (sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID) > *pdwSize || !pTheirTcpTable)
+ size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
+ if (size > *pdwSize || !pTheirTcpTable)
{
- *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
}
- free(pOurTcpTable);
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_MODULE_ALL:
+ {
+ PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
+ PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE);
+ if (size > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = size;
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirTcpTable, pOurTcpTable, size);
+
+ /* Don't sort on PID, so use basic helper */
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
+ }
+
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
+ {
+ PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
+ PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
+ {
+ ++count;
+ }
+ }
+
+ size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
+ if (size > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = size;
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ pTheirTcpTable->dwNumEntries = count;
+
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
+ {
+ memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
+ ++count;
+ }
+ }
+ ASSERT(count == pTheirTcpTable->dwNumEntries);
+
+ /* Don't sort on PID, so use basic helper */
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
+ }
+
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_MODULE_LISTENER:
+ {
+ PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
+ PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
+ {
+ ++count;
+ }
+ }
+
+ size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
+ if (size > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = size;
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ pTheirTcpTable->dwNumEntries = count;
+
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
+ {
+ memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
+ ++count;
+ }
+ }
+ ASSERT(count == pTheirTcpTable->dwNumEntries);
+
+ /* Don't sort on PID, so use basic helper */
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
+ }
+
+ HeapFree(GetProcessHeap(), 0, pOurTcpTable);
}
}
break;
default:
- UNIMPLEMENTED;
ret = ERROR_INVALID_PARAMETER;
break;
}
return ret;
}
-
static int UdpTableSorter(const void *a, const void *b)
{
int ret;
* RETURNS
* Success: NO_ERROR
* Failure: either ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER
- *
- * NOTES
*/
-
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
{
- DWORD ret = NO_ERROR;
+ DWORD size;
+ DWORD ret = NO_ERROR;
if (!pdwSize)
{
{
case UDP_TABLE_BASIC:
{
- PMIB_UDPTABLE pOurUdpTable = getUdpTable();
+ PMIB_UDPTABLE pOurUdpTable = getUdpTable(ClassBasic);
PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
if (pOurUdpTable)
{
- if (sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW) > *pdwSize || !pTheirUdpTable)
+ size = FIELD_OFFSET(MIB_UDPTABLE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
+ if (size > *pdwSize || !pTheirUdpTable)
{
- *pdwSize = sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
- memcpy(pTheirUdpTable, pOurUdpTable, sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID));
+ memcpy(pTheirUdpTable, pOurUdpTable, size);
if (bOrder)
qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
sizeof(MIB_UDPROW), UdpTableSorter);
}
- free(pOurUdpTable);
+ HeapFree(GetProcessHeap(), 0, pOurUdpTable);
}
}
break;
case UDP_TABLE_OWNER_PID:
{
- PMIB_UDPTABLE_OWNER_PID pOurUdpTable = getOwnerUdpTable();
+ PMIB_UDPTABLE_OWNER_PID pOurUdpTable = getUdpTable(ClassModulePid);
PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
if (pOurUdpTable)
{
- if (sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID) > *pdwSize || !pTheirUdpTable)
+ size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID);
+ if (size > *pdwSize || !pTheirUdpTable)
{
- *pdwSize = sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID);
+ *pdwSize = size;
ret = ERROR_INSUFFICIENT_BUFFER;
}
else
{
- memcpy(pTheirUdpTable, pOurUdpTable, sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID));
+ memcpy(pTheirUdpTable, pOurUdpTable, size);
if (bOrder)
qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
sizeof(MIB_UDPROW_OWNER_PID), UdpTableSorter);
}
- free(pOurUdpTable);
+ HeapFree(GetProcessHeap(), 0, pOurUdpTable);
+ }
+ }
+ break;
+
+ case UDP_TABLE_OWNER_MODULE:
+ {
+ PMIB_UDPTABLE_OWNER_MODULE pOurUdpTable = getUdpTable(ClassModule);
+ PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
+
+ if (pOurUdpTable)
+ {
+ size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE);
+ if (size > *pdwSize || !pTheirUdpTable)
+ {
+ *pdwSize = size;
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirUdpTable, pOurUdpTable, size);
+
+ if (bOrder)
+ qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
+ sizeof(MIB_UDPROW_OWNER_MODULE), UdpTableSorter);
+ }
+
+ HeapFree(GetProcessHeap(), 0, pOurUdpTable);
}
}
break;
default:
- UNIMPLEMENTED;
ret = ERROR_INVALID_PARAMETER;
break;
}
/******************************************************************
* GetFriendlyIfIndex (IPHLPAPI.@)
*
- *
* PARAMS
- *
* IfIndex [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
{
/******************************************************************
* GetIcmpStatistics (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats)
{
/******************************************************************
* GetIfEntry (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pIfRow [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
{
/******************************************************************
* GetIfTable (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pIfTable [In/Out]
* pdwSize [In/Out]
* bOrder [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
{
/******************************************************************
* GetInterfaceInfo (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pIfTable [In/Out]
* dwOutBufLen [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
{
pIfTable->Adapter[ndx].Index = table->indexes[ndx];
name = getInterfaceNameByIndex(table->indexes[ndx]);
- for (walker = name, assigner = pIfTable->Adapter[ndx].Name;
+ wcscpy(pIfTable->Adapter[ndx].Name, L"\\DEVICE\\TCPIP_");
+ for (walker = name, assigner = &pIfTable->Adapter[ndx].Name[14];
walker && *walker &&
- assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1;
+ assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1 - 14;
walker++, assigner++)
*assigner = *walker;
*assigner = 0;
/******************************************************************
* GetIpAddrTable (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pIpAddrTable [In/Out]
* pdwSize [In/Out]
* bOrder [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
{
/******************************************************************
* GetIpForwardTable (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pIpForwardTable [In/Out]
* pdwSize [In/Out]
* bOrder [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
{
/******************************************************************
* GetIpNetTable (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pIpNetTable [In/Out]
* pdwSize [In/Out]
* bOrder [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
{
/******************************************************************
* GetIpStatistics (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats)
{
/******************************************************************
* GetIpStatisticsEx (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
* dwFamily [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily)
{
/******************************************************************
* GetNetworkParams (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pFixedInfo [In/Out]
* pOutBufLen [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
{
/******************************************************************
* GetNumberOfInterfaces (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pdwNumIf [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
{
}
+static DWORD GetOwnerModuleFromPidEntry(DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
+{
+ HANDLE Process;
+ DWORD FileLen, PathLen, Error;
+ WCHAR File[MAX_PATH], Path[MAX_PATH];
+ PTCPIP_OWNER_MODULE_BASIC_INFO BasicInfo;
+
+ if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
+ IsBadWritePtr(Buffer, *pdwSize))
+ {
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ if (OwningPid == 0)
+ {
+ return ERROR_NOT_FOUND;
+ }
+
+ Process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, OwningPid);
+ if (Process == NULL)
+ {
+ return GetLastError();
+ }
+
+ FileLen = GetModuleBaseNameW(Process, NULL, File, MAX_PATH);
+ if (FileLen != 0)
+ {
+ PathLen = GetModuleFileNameExW(Process, NULL, Path, MAX_PATH);
+ if (PathLen == 0)
+ {
+ CloseHandle(Process);
+ return GetLastError();
+ }
+
+ /* Add NULL char */
+ ++FileLen;
+ ++PathLen;
+ PathLen *= sizeof(WCHAR);
+ FileLen *= sizeof(WCHAR);
+ }
+ else
+ {
+ Error = GetLastError();
+
+ if (Error == ERROR_PARTIAL_COPY)
+ {
+ wcscpy(File, L"System");
+ wcscpy(Path, L"System");
+
+ PathLen = sizeof(L"System");
+ FileLen = sizeof(L"System");
+ }
+ else
+ {
+ CloseHandle(Process);
+ return Error;
+ }
+ }
+
+ CloseHandle(Process);
+
+ if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen)
+ {
+ *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
+ return ERROR_INSUFFICIENT_BUFFER;
+ }
+
+ BasicInfo = Buffer;
+ BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
+ BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + FileLen);
+ wcscpy(BasicInfo->pModuleName, File);
+ wcscpy(BasicInfo->pModulePath, Path);
+ *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
+
+ return NO_ERROR;
+}
+
+static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
+{
+ UINT Size;
+ HRESULT Res;
+ HANDLE hAdvapi32;
+ WCHAR SysDir[MAX_PATH];
+ PTCPIP_OWNER_MODULE_BASIC_INFO BasicInfo;
+ ULONG (NTAPI *_I_QueryTagInformation)(PVOID, DWORD, PVOID);
+ struct
+ {
+ DWORD ProcessId;
+ DWORD ServiceTag;
+ DWORD TagType;
+ PWSTR Buffer;
+ } ServiceQuery;
+
+ if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
+ IsBadWritePtr(Buffer, *pdwSize))
+ {
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ /* First, secure (avoid injections) load advapi32.dll */
+ Size = GetSystemDirectoryW(SysDir, MAX_PATH);
+ if (Size == 0)
+ {
+ return GetLastError();
+ }
+
+ Res = StringCchCatW(&SysDir[Size], MAX_PATH - Size, L"\\advapi32.dll");
+ if (FAILED(Res))
+ {
+ return Res;
+ }
+
+ hAdvapi32 = GetModuleHandleW(SysDir);
+ if (hAdvapi32 == NULL)
+ {
+ return GetLastError();
+ }
+
+ /* Now, we'll query the service associated with the tag */
+ _I_QueryTagInformation = (PVOID)GetProcAddress(hAdvapi32, "I_QueryTagInformation");
+ if (_I_QueryTagInformation == NULL)
+ {
+ return GetLastError();
+ }
+
+ /* Set tag and PID for the query */
+ ServiceQuery.ProcessId = OwningPid;
+ ServiceQuery.ServiceTag = OwningTag;
+ ServiceQuery.TagType = 0;
+ ServiceQuery.Buffer = NULL;
+
+ /* And query */
+ Res = _I_QueryTagInformation(NULL, 1, &ServiceQuery);
+ if (Res != ERROR_SUCCESS)
+ {
+ return Res;
+ }
+
+ /* Compute service name length */
+ Size = wcslen(ServiceQuery.Buffer) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
+
+ /* We'll copy it twice, so make sure we have enough room */
+ if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size)
+ {
+ *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
+ LocalFree(ServiceQuery.Buffer);
+ return ERROR_INSUFFICIENT_BUFFER;
+ }
+
+ /* Copy back data */
+ BasicInfo = Buffer;
+ BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
+ BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + Size);
+ wcscpy(BasicInfo->pModuleName, ServiceQuery.Buffer);
+ wcscpy(BasicInfo->pModulePath, ServiceQuery.Buffer);
+ *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
+ LocalFree(ServiceQuery.Buffer);
+
+ return NO_ERROR;
+}
+
/******************************************************************
* GetOwnerModuleFromTcpEntry (IPHLPAPI.@)
*
* NOTES
* The type of data returned in Buffer is indicated by the value of the Class parameter.
*/
-DWORD WINAPI GetOwnerModuleFromTcpEntry( PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
+DWORD WINAPI GetOwnerModuleFromTcpEntry(PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
{
- DWORD ret = NO_ERROR;
- UNIMPLEMENTED;
- return ret;
+ /* If we have a service tag, that's a service connection */
+ if (pTcpEntry->OwningModuleInfo[0] != 0)
+ {
+ return GetOwnerModuleFromTagEntry(pTcpEntry->dwOwningPid, (DWORD)(pTcpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
+ }
+ else
+ {
+ return GetOwnerModuleFromPidEntry(pTcpEntry->dwOwningPid, Class, Buffer, pdwSize);
+ }
+}
+
+/******************************************************************
+ * GetOwnerModuleFromUdpEntry (IPHLPAPI.@)
+ *
+ * Get data about the module that issued the context bind for a specific IPv4 UDP endpoint in a MIB table row
+ *
+ * PARAMS
+ * pUdpEntry [in] pointer to a MIB_UDPROW_OWNER_MODULE structure
+ * Class [in] TCPIP_OWNER_MODULE_INFO_CLASS enumeration value
+ * Buffer [out] pointer a buffer containing a TCPIP_OWNER_MODULE_BASIC_INFO structure with the owner module data.
+ * pdwSize [in, out] estimated size of the structure returned in Buffer, in bytes
+ *
+ * RETURNS
+ * Success: NO_ERROR
+ * Failure: ERROR_INSUFFICIENT_BUFFER, ERROR_INVALID_PARAMETER, ERROR_NOT_ENOUGH_MEMORY
+ * ERROR_NOT_FOUND or ERROR_PARTIAL_COPY
+ *
+ * NOTES
+ * The type of data returned in Buffer is indicated by the value of the Class parameter.
+ */
+DWORD WINAPI GetOwnerModuleFromUdpEntry(PMIB_UDPROW_OWNER_MODULE pUdpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
+{
+ /* If we have a service tag, that's a service connection */
+ if (pUdpEntry->OwningModuleInfo[0] != 0)
+ {
+ return GetOwnerModuleFromTagEntry(pUdpEntry->dwOwningPid, (DWORD)(pUdpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
+ }
+ else
+ {
+ return GetOwnerModuleFromPidEntry(pUdpEntry->dwOwningPid, Class, Buffer, pdwSize);
+ }
}
static void CreateNameServerListEnumNamesFunc( PWCHAR Interface, PWCHAR Server, PVOID Data)
/******************************************************************
* GetPerAdapterInfo (IPHLPAPI.@)
*
- *
* PARAMS
- *
* IfIndex [In]
* pPerAdapterInfo [In/Out]
* pOutBufLen [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
{
/******************************************************************
* GetRTTAndHopCount (IPHLPAPI.@)
*
- *
* PARAMS
- *
* DestIpAddress [In]
* HopCount [In/Out]
* MaxHops [In]
* RTT [In/Out]
*
* RETURNS
- *
* BOOL
- *
*/
BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
{
/******************************************************************
* GetTcpStatisticsEx (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
* dwFamily [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)
{
/******************************************************************
* GetTcpStatistics (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats)
{
*/
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
{
- return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
+ return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
}
/******************************************************************
* GetUdpStatisticsEx (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
* dwFamily [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)
{
/******************************************************************
* GetUdpStatistics (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pStats [In/Out]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats)
{
/******************************************************************
* GetUdpTable (IPHLPAPI.@)
*
- *
* PARAMS
- *
* pUdpTable [In/Out]
* pdwSize [In/Out]
* bOrder [In]
*
* RETURNS
- *
* DWORD
- *
*/
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
{
- return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
+ return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
}
* RETURNS
* Success: NO_ERROR
* Failure: error code from winerror.h
- *
*/
DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
{
* RETURNS
* Success: NO_ERROR
* Failure: error code from winerror.h
- *
*/
DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
{
return 0L;
}
-/*
- * @implemented
- */
#ifdef GetAdaptersAddressesV1
DWORD WINAPI DECLSPEC_HOTPATCH GetAdaptersAddresses(ULONG Family,ULONG Flags,PVOID Reserved,PIP_ADAPTER_ADDRESSES pAdapterAddresses,PULONG pOutBufLen)
{
ret = openTcpFile(&tcpFile, FILE_READ_DATA);
if (!NT_SUCCESS(ret))
+ {
+ free(indexTable);
return ERROR_NO_DATA;
+ }
for (i = indexTable->numIndexes; i >= 0; i--)
{
/* Friendly name */
if (!(Flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
- requiredSize += strlen((char *)ifInfo.if_info.ent.if_descr) + 1; //FIXME
+ requiredSize += ifInfo.if_info.ent.if_descrlen + 1; //FIXME
/* Adapter name */
- requiredSize += strlen((char *)ifInfo.if_info.ent.if_descr) + 1;
+ requiredSize += ifInfo.if_info.ent.if_descrlen + 1;
/* Unicast address */
if (!(Flags & GAA_FLAG_SKIP_UNICAST))
/* Adapter name */
currentAddress->AdapterName = (PVOID)currentLocation;
- currentLocation += strlen((char *)ifInfo.if_info.ent.if_descr) + 1;
+ currentLocation += ifInfo.if_info.ent.if_descrlen + 1;
/* Unicast address */
if (!(Flags & GAA_FLAG_SKIP_UNICAST))
currentAddress->IfIndex = indexTable->indexes[i];
/* Adapter name */
- strcpy(currentAddress->AdapterName, (char *)ifInfo.if_info.ent.if_descr);
+ memcpy(currentAddress->AdapterName, ifInfo.if_info.ent.if_descr, ifInfo.if_info.ent.if_descrlen);
+ currentAddress->AdapterName[ifInfo.if_info.ent.if_descrlen] = '\0';
if (!(Flags & GAA_FLAG_SKIP_UNICAST))
{
return ERROR_SUCCESS;
}
-/*
- * @implemented
- */
DWORD WINAPI
NhGetInterfaceNameFromDeviceGuid(_In_ const GUID * pInterfaceGUID,
_Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
}
-/*
- * @implemented
- */
DWORD WINAPI
NhGetInterfaceNameFromGuid(_In_ const GUID * pInterfaceGUID,
_Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,