}
+/******************************************************************
+ * AllocateAndGetTcpExTableFromStack (IPHLPAPI.@)
+ *
+ *
+ * PARAMS
+ *
+ * ppTcpTable [Out]
+ * bOrder [In] -- passed to GetExtendedTcpTable to order the table
+ * heap [In] -- heap from which the table is allocated
+ * flags [In] -- flags to HeapAlloc
+ * 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);
+ if (!ppTcpTable)
+ ret = ERROR_INVALID_PARAMETER;
+ else {
+ DWORD dwSize = 0;
+
+ *ppTcpTable = NULL;
+ ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER) {
+ *ppTcpTable = (PMIB_TCPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
+ ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
+ if (ret != NO_ERROR) {
+ HeapFree(heap, flags, *ppTcpTable);
+ *ppTcpTable = NULL;
+ }
+ }
+ }
+ TRACE("returning %ld\n", ret);
+ return ret;
+}
+
+
+/******************************************************************
+ * AllocateAndGetTcpExTable2FromStack (IPHLPAPI.@)
+ *
+ *
+ * PARAMS
+ *
+ * ppTcpTable [Out]
+ * bOrder [In] -- passed to GetExtendedTcpTable to order the table
+ * heap [In] -- heap from which the table is allocated
+ * flags [In] -- flags to HeapAlloc
+ * family [In] -- passed to GetExtendedTcpTable to select INET family
+ * 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);
+ if (!ppTcpTable)
+ ret = ERROR_INVALID_PARAMETER;
+ else {
+ DWORD dwSize = 0;
+
+ *ppTcpTable = NULL;
+ ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER) {
+ *ppTcpTable = HeapAlloc(heap, flags, dwSize);
+ ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
+ if (ret != NO_ERROR) {
+ HeapFree(heap, flags, *ppTcpTable);
+ *ppTcpTable = NULL;
+ }
+ }
+ }
+ TRACE("returning %ld\n", ret);
+ return ret;
+}
+
+
/******************************************************************
* AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
*
}
+/******************************************************************
+ * AllocateAndGetUdpExTableFromStack (IPHLPAPI.@)
+ *
+ *
+ * PARAMS
+ *
+ * ppUdpTable [Out]
+ * bOrder [In] -- passed to GetExtendedUdpTable to order the table
+ * heap [In] -- heap from which the table is allocated
+ * flags [In] -- flags to HeapAlloc
+ * 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);
+ if (!ppUdpTable)
+ ret = ERROR_INVALID_PARAMETER;
+ else {
+ DWORD dwSize = 0;
+
+ *ppUdpTable = NULL;
+ ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER) {
+ *ppUdpTable = (PMIB_UDPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
+ ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
+ if (ret != NO_ERROR) {
+ HeapFree(heap, flags, *ppUdpTable);
+ *ppUdpTable = NULL;
+ }
+ }
+ }
+ TRACE("returning %ld\n", ret);
+ return ret;
+}
+
+
+/******************************************************************
+ * AllocateAndGetUdpExTable2FromStack (IPHLPAPI.@)
+ *
+ *
+ * PARAMS
+ *
+ * ppUdpTable [Out]
+ * bOrder [In] -- passed to GetExtendedUdpTable to order the table
+ * heap [In] -- heap from which the table is allocated
+ * flags [In] -- flags to HeapAlloc
+ * family [In] -- passed to GetExtendedUdpTable to select INET family
+ * 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);
+ if (!ppUdpTable)
+ ret = ERROR_INVALID_PARAMETER;
+ else {
+ DWORD dwSize = 0;
+
+ *ppUdpTable = NULL;
+ ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER) {
+ *ppUdpTable = HeapAlloc(heap, flags, dwSize);
+ ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
+ if (ret != NO_ERROR) {
+ HeapFree(heap, flags, *ppUdpTable);
+ *ppUdpTable = NULL;
+ }
+ }
+ }
+ TRACE("returning %ld\n", ret);
+ return ret;
+}
+
+
/******************************************************************
* CreateIpForwardEntry (IPHLPAPI.@)
*
AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
if (table) {
- DWORD ndx, matchedBits, matchedNdx = 0;
+ DWORD ndx, minMaskSize, matchedNdx = 0;
- for (ndx = 0, matchedBits = 0; ndx < table->dwNumEntries; ndx++) {
+ for (ndx = 0, minMaskSize = 255; ndx < table->dwNumEntries; ndx++) {
if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
(table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
- DWORD numShifts, mask;
+ DWORD hostMaskSize;
- for (numShifts = 0, mask = table->table[ndx].dwForwardMask;
- mask && !(mask & 1); mask >>= 1, numShifts++)
- ;
- if (numShifts > matchedBits) {
- matchedBits = numShifts;
+ if (!_BitScanForward(&hostMaskSize, ntohl(table->table[ndx].dwForwardMask)))
+ {
+ hostMaskSize = 32;
+ }
+ if (hostMaskSize < minMaskSize) {
+ minMaskSize = hostMaskSize;
matchedNdx = ndx;
}
}
return ret;
}
+static int TcpTableSorter(const void *a, const void *b)
+{
+ int ret;
+
+ if (a && b) {
+ PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
+
+ ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
+ if (ret == 0) {
+ ret = rowA->dwLocalPort - rowB->dwLocalPort;
+ if (ret == 0) {
+ ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
+ if (ret == 0)
+ ret = rowA->dwRemotePort - rowB->dwRemotePort;
+ }
+ }
+ }
+ else
+ ret = 0;
+ return ret;
+}
+
/******************************************************************
* GetExtendedTcpTable (IPHLPAPI.@)
*
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
{
+ DWORD i, count;
DWORD ret = NO_ERROR;
- if (TableClass == TCP_TABLE_OWNER_PID_ALL) {
- if (*pdwSize == 0) {
- *pdwSize = sizeof(MIB_TCPTABLE_OWNER_PID);
- return ERROR_INSUFFICIENT_BUFFER;
- } else {
- ZeroMemory(pTcpTable, sizeof(MIB_TCPTABLE_OWNER_PID));
- return NO_ERROR;
+ if (!pdwSize)
+ {
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ if (ulAf != AF_INET)
+ {
+ UNIMPLEMENTED;
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ switch (TableClass)
+ {
+ case TCP_TABLE_BASIC_ALL:
+ {
+ PMIB_TCPTABLE pOurTcpTable = getTcpTable();
+ PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ if (sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirTcpTable, pOurTcpTable, sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW));
+
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_BASIC_CONNECTIONS:
+ {
+ PMIB_TCPTABLE pOurTcpTable = getTcpTable();
+ PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
+ {
+ ++count;
+ }
+ }
+
+ if (sizeof(DWORD) + count * sizeof(MIB_TCPROW) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ pTheirTcpTable->dwNumEntries = count;
+
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
+ {
+ memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
+ ++count;
+ }
+ }
+ ASSERT(count == pTheirTcpTable->dwNumEntries);
+
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_BASIC_LISTENER:
+ {
+ PMIB_TCPTABLE pOurTcpTable = getTcpTable();
+ PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
+ {
+ ++count;
+ }
+ }
+
+ if (sizeof(DWORD) + count * sizeof(MIB_TCPROW) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ pTheirTcpTable->dwNumEntries = count;
+
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
+ {
+ memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
+ ++count;
+ }
+ }
+ ASSERT(count == pTheirTcpTable->dwNumEntries);
+
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_PID_ALL:
+ {
+ PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getOwnerTcpTable();
+ PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ if (sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirTcpTable, pOurTcpTable, sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID));
+
+ /* Don't sort on PID, so use basic helper */
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_PID_CONNECTIONS:
+ {
+ PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getOwnerTcpTable();
+ PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
+ {
+ ++count;
+ }
+ }
+
+ if (sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID);
+ 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_PID));
+ ++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_PID), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_PID_LISTENER:
+ {
+ PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getOwnerTcpTable();
+ PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
+ {
+ if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
+ {
+ ++count;
+ }
+ }
+
+ if (sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_PID);
+ 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_PID));
+ ++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_PID), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_MODULE_ALL:
+ {
+ PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getOwnerModTcpTable();
+ PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
+
+ if (pOurTcpTable)
+ {
+ if (sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirTcpTable, pOurTcpTable, sizeof(DWORD) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE));
+
+ /* Don't sort on PID, so use basic helper */
+ if (bOrder)
+ qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
+ sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
+ {
+ PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getOwnerModTcpTable();
+ 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;
+ }
+ }
+
+ if (sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_MODULE) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
+ 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);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ case TCP_TABLE_OWNER_MODULE_LISTENER:
+ {
+ PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getOwnerModTcpTable();
+ 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;
+ }
+ }
+
+ if (sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_MODULE) > *pdwSize || !pTheirTcpTable)
+ {
+ *pdwSize = sizeof(DWORD) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
+ 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);
+ }
+
+ free(pOurTcpTable);
+ }
+ }
+ break;
+
+ default:
+ ret = ERROR_INVALID_PARAMETER;
+ break;
}
+
+ return ret;
+}
+
+
+static int UdpTableSorter(const void *a, const void *b)
+{
+ int ret;
+
+ if (a && b) {
+ PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
+
+ ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
+ if (ret == 0)
+ ret = rowA->dwLocalPort - rowB->dwLocalPort;
}
+ else
+ ret = 0;
+ return ret;
+}
+
+/******************************************************************
+ * GetExtendedUdpTable (IPHLPAPI.@)
+ *
+ * Get the table of UDP endpoints available to the application.
+ *
+ * PARAMS
+ * pUdpTable [Out] table struct with the filtered UDP endpoints available to application
+ * pdwSize [In/Out] estimated size of the structure returned in pUdpTable, in bytes
+ * bOrder [In] whether to order the table
+ * ulAf [in] version of IP used by the UDP endpoints
+ * TableClass [in] type of the UDP table structure from UDP_TABLE_CLASS
+ * Reserved [in] reserved - this value must be zero
+ *
+ * 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;
+
+ if (!pdwSize)
+ {
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ if (ulAf != AF_INET)
+ {
+ UNIMPLEMENTED;
+ return ERROR_INVALID_PARAMETER;
+ }
+
+ switch (TableClass)
+ {
+ case UDP_TABLE_BASIC:
+ {
+ PMIB_UDPTABLE pOurUdpTable = getUdpTable();
+ PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
+
+ if (pOurUdpTable)
+ {
+ if (sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW) > *pdwSize || !pTheirUdpTable)
+ {
+ *pdwSize = sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirUdpTable, pOurUdpTable, sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID));
+
+ if (bOrder)
+ qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
+ sizeof(MIB_UDPROW), UdpTableSorter);
+ }
+
+ free(pOurUdpTable);
+ }
+ }
+ break;
+
+ case UDP_TABLE_OWNER_PID:
+ {
+ PMIB_UDPTABLE_OWNER_PID pOurUdpTable = getOwnerUdpTable();
+ PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
+
+ if (pOurUdpTable)
+ {
+ if (sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID) > *pdwSize || !pTheirUdpTable)
+ {
+ *pdwSize = sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirUdpTable, pOurUdpTable, sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID));
+
+ if (bOrder)
+ qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
+ sizeof(MIB_UDPROW_OWNER_PID), UdpTableSorter);
+ }
+
+ free(pOurUdpTable);
+ }
+ }
+ break;
+ case UDP_TABLE_OWNER_MODULE:
+ {
+ PMIB_UDPTABLE_OWNER_MODULE pOurUdpTable = getOwnerModUdpTable();
+ PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
- UNIMPLEMENTED;
- return ret;
+ if (pOurUdpTable)
+ {
+ if (sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE) > *pdwSize || !pTheirUdpTable)
+ {
+ *pdwSize = sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE);
+ ret = ERROR_INSUFFICIENT_BUFFER;
+ }
+ else
+ {
+ memcpy(pTheirUdpTable, pOurUdpTable, sizeof(DWORD) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE));
+
+ if (bOrder)
+ qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
+ sizeof(MIB_UDPROW_OWNER_MODULE), UdpTableSorter);
+ }
+
+ free(pOurUdpTable);
+ }
+ }
+ break;
+
+ default:
+ ret = ERROR_INVALID_PARAMETER;
+ break;
+ }
+
+ return ret;
}
}
-static int TcpTableSorter(const void *a, const void *b)
-{
- int ret;
-
- if (a && b) {
- PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
-
- ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
- if (ret == 0) {
- ret = rowA->dwLocalPort - rowB->dwLocalPort;
- if (ret == 0) {
- ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
- if (ret == 0)
- ret = rowA->dwRemotePort - rowB->dwRemotePort;
- }
- }
- }
- else
- ret = 0;
- return ret;
-}
-
-
/******************************************************************
* GetTcpTable (IPHLPAPI.@)
*
*/
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
{
- DWORD ret = ERROR_NO_DATA;
-
- TRACE("pTcpTable %p, pdwSize %p, bOrder %d\n", pTcpTable, pdwSize,
- (DWORD)bOrder);
- if (!pdwSize)
- ret = ERROR_INVALID_PARAMETER;
- else {
- DWORD numEntries = getNumTcpEntries();
- DWORD size = sizeof(MIB_TCPTABLE);
-
- if (numEntries > 1)
- size += (numEntries - 1) * sizeof(MIB_TCPROW);
- if (!pTcpTable || *pdwSize < size) {
- *pdwSize = size;
- ret = ERROR_INSUFFICIENT_BUFFER;
- }
- else {
- PMIB_TCPTABLE pOurTcpTable = getTcpTable();
- if (pOurTcpTable)
- {
- size = sizeof(MIB_TCPTABLE);
- if (pOurTcpTable->dwNumEntries > 1)
- size += (pOurTcpTable->dwNumEntries - 1) * sizeof(MIB_TCPROW);
-
- if (*pdwSize < size)
- {
- *pdwSize = size;
-
- ret = ERROR_INSUFFICIENT_BUFFER;
- }
- else
- {
- memcpy(pTcpTable, pOurTcpTable, size);
-
- if (bOrder)
- qsort(pTcpTable->table, pTcpTable->dwNumEntries,
- sizeof(MIB_TCPROW), TcpTableSorter);
-
- ret = NO_ERROR;
- }
-
- free(pOurTcpTable);
- }
- }
- }
- TRACE("returning %d\n", ret);
- return ret;
+ return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
}
}
-static int UdpTableSorter(const void *a, const void *b)
-{
- int ret;
-
- if (a && b) {
- PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
-
- ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
- if (ret == 0)
- ret = rowA->dwLocalPort - rowB->dwLocalPort;
- }
- else
- ret = 0;
- return ret;
-}
-
-
/******************************************************************
* GetUdpTable (IPHLPAPI.@)
*
*/
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
{
- DWORD ret;
-
- TRACE("pUdpTable %p, pdwSize %p, bOrder %ld\n", pUdpTable, pdwSize,
- (DWORD)bOrder);
- if (!pdwSize)
- ret = ERROR_INVALID_PARAMETER;
- else {
- DWORD numEntries = getNumUdpEntries();
- ULONG size = sizeof(MIB_UDPTABLE) + (numEntries - 1) * sizeof(MIB_UDPROW);
-
- if (!pUdpTable || *pdwSize < size) {
- *pdwSize = size;
- ret = ERROR_INSUFFICIENT_BUFFER;
- }
- else {
- PMIB_UDPTABLE table = getUdpTable();
-
- if (table) {
- size = sizeof(MIB_UDPTABLE) + (table->dwNumEntries - 1) *
- sizeof(MIB_UDPROW);
- if (*pdwSize < size) {
- *pdwSize = size;
- ret = ERROR_INSUFFICIENT_BUFFER;
- }
- else {
- memcpy(pUdpTable, table, size);
- if (bOrder)
- qsort(pUdpTable->table, pUdpTable->dwNumEntries,
- sizeof(MIB_UDPROW), UdpTableSorter);
- ret = NO_ERROR;
- }
- free(table);
- }
- else
- ret = ERROR_OUTOFMEMORY;
- }
- }
- TRACE("returning %ld\n", ret);
- return ret;
+ return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
}