ipstats_reactos.c File Reference

#include "iphlpapi_private.h"

Include dependency graph for ipstats_reactos.c:

Go to the source code of this file.

Classes
struct	_TABLE_CALL

Macros
#define	TCPS_ESTABLISHED   TCP_ESTABLISHED
#define	TCPS_SYN_SENT   TCP_SYN_SENT
#define	TCPS_SYN_RECEIVED   TCP_SYN_RECV
#define	TCPS_FIN_WAIT_1   TCP_FIN_WAIT1
#define	TCPS_FIN_WAIT_2   TCP_FIN_WAIT2
#define	TCPS_TIME_WAIT   TCP_TIME_WAIT
#define	TCPS_CLOSED   TCP_CLOSE
#define	TCPS_CLOSE_WAIT   TCP_CLOSE_WAIT
#define	TCPS_LAST_ACK   TCP_LAST_ACK
#define	TCPS_LISTEN   TCP_LISTEN
#define	TCPS_CLOSING   TCP_CLOSING
#define	Add2Ptr(PTR, INC)   (PVOID)((ULONG_PTR)(PTR) + (INC))

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (iphlpapi)
BOOL	isIpEntity (HANDLE tcpFile, TDIEntityID *ent)
NTSTATUS	getNthIpEntity (HANDLE tcpFile, DWORD index, TDIEntityID *ent)
static NTSTATUS	tdiGetMibForIpEntity (_In_ HANDLE tcpFile, _In_ TDIEntityID *ent, _Out_ MIB_IPSTATS *entry)
static NTSTATUS	tdiGetMibForTcpEntity (_In_ HANDLE tcpFile, _In_ TDIEntityID *ent, _Out_ MIB_TCPSTATS *entry)
static NTSTATUS	tdiGetMibForUdpEntity (_In_ HANDLE tcpFile, _In_ TDIEntityID *ent, _Out_ MIB_UDPSTATS *entry)
NTSTATUS	tdiGetRoutesForIpEntity (HANDLE tcpFile, TDIEntityID *ent, IPRouteEntry **routes, PDWORD numRoutes)
NTSTATUS	tdiGetIpAddrsForIpEntity (HANDLE tcpFile, TDIEntityID *ent, IPAddrEntry **addrs, PDWORD numAddrs)
DWORD	getInterfaceStatsByName (const char *name, PMIB_IFROW entry)
DWORD	getInterfaceStatsByIndex (DWORD index, PMIB_IFROW entry)
DWORD	getICMPStats (MIB_ICMP *stats)
DWORD	getIPStats (_In_ HANDLE TcpFile, _Out_ PMIB_IPSTATS pStats)
DWORD	getTCPStats (_In_ HANDLE TcpFile, _Out_ MIB_TCPSTATS *pStats)
DWORD	getUDPStats (_In_ HANDLE TcpFile, _Out_ MIB_UDPSTATS *pStats)
DWORD	getNumRoutes (void)
VOID	HexDump (PCHAR Data, DWORD Len)
RouteTable *	getRouteTable (void)
DWORD	getNumArpEntries (void)
PMIB_IPNETTABLE	getArpTable (void)
DWORD	getNumUdpEntries (void)
PVOID	getUdpTable (CLASS_TABLE Class)
DWORD	getNumTcpEntries (void)
PVOID	getTcpTable (CLASS_TABLE Class)

Variables
struct _TABLE_CALL	UdpTcpTableCall []

Macro Definition Documentation

Add2Ptr

#define Add2Ptr	(		PTR,
			INC
	)		(PVOID)((ULONG_PTR)(PTR) + (INC))

Definition at line 721 of file ipstats_reactos.c.

TCPS_CLOSE_WAIT

#define TCPS_CLOSE_WAIT   TCP_CLOSE_WAIT

Definition at line 48 of file ipstats_reactos.c.

TCPS_CLOSED

#define TCPS_CLOSED   TCP_CLOSE

Definition at line 45 of file ipstats_reactos.c.

TCPS_CLOSING

#define TCPS_CLOSING   TCP_CLOSING

Definition at line 57 of file ipstats_reactos.c.

TCPS_ESTABLISHED

#define TCPS_ESTABLISHED   TCP_ESTABLISHED

Definition at line 27 of file ipstats_reactos.c.

TCPS_FIN_WAIT_1

#define TCPS_FIN_WAIT_1   TCP_FIN_WAIT1

Definition at line 36 of file ipstats_reactos.c.

TCPS_FIN_WAIT_2

#define TCPS_FIN_WAIT_2   TCP_FIN_WAIT2

Definition at line 39 of file ipstats_reactos.c.

TCPS_LAST_ACK

#define TCPS_LAST_ACK   TCP_LAST_ACK

Definition at line 51 of file ipstats_reactos.c.

TCPS_LISTEN

#define TCPS_LISTEN   TCP_LISTEN

Definition at line 54 of file ipstats_reactos.c.

TCPS_SYN_RECEIVED

#define TCPS_SYN_RECEIVED   TCP_SYN_RECV

Definition at line 33 of file ipstats_reactos.c.

TCPS_SYN_SENT

#define TCPS_SYN_SENT   TCP_SYN_SENT

Definition at line 30 of file ipstats_reactos.c.

TCPS_TIME_WAIT

#define TCPS_TIME_WAIT   TCP_TIME_WAIT

Definition at line 42 of file ipstats_reactos.c.

Function Documentation

getArpTable()

PMIB_IPNETTABLE getArpTable

(

void

)

Definition at line 650 of file ipstats_reactos.c.

{
    DWORD numEntities, returnSize;
    TDIEntityID *entitySet;
    HANDLE tcpFile;
    int i, totalNumber, TmpIdx, CurrIdx = 0;
    NTSTATUS status;
    PMIB_IPNETTABLE IpArpTable = NULL;
    PMIB_IPNETROW AdapterArpTable = NULL;
 
    TRACE("called.\n");
 
    totalNumber = getNumArpEntries();
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    IpArpTable = HeapAlloc(GetProcessHeap(), 0,
        sizeof(DWORD) + (sizeof(MIB_IPNETROW) * totalNumber));
    if (!IpArpTable) {
        closeTcpFile(tcpFile);
        return NULL;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
 
    for (i = 0; i < numEntities; i++) {
        if (isInterface(&entitySet[i]) && hasArp(tcpFile, &entitySet[i]))
        {
            status = tdiGetSetOfThings(tcpFile,
                INFO_CLASS_PROTOCOL,
                INFO_TYPE_PROVIDER,
                IP_MIB_ARPTABLE_ENTRY_ID,
                AT_ENTITY,
                entitySet[i].tei_instance,
                0,
                sizeof(MIB_IPNETROW),
                (PVOID *)&AdapterArpTable,
                &returnSize);
 
            if (status == STATUS_SUCCESS) {
                for (TmpIdx = 0; TmpIdx < returnSize; TmpIdx++, CurrIdx++)
                    IpArpTable->table[CurrIdx] = AdapterArpTable[TmpIdx];
                tdiFreeThingSet(AdapterArpTable);
            }
        }
    }
 
    closeTcpFile(tcpFile);
    tdiFreeThingSet(entitySet);
    IpArpTable->dwNumEntries = CurrIdx;
    return IpArpTable;
}

Referenced by GetIpNetTable().

getICMPStats()

DWORD getICMPStats

(

MIB_ICMP *

stats

)

Definition at line 294 of file ipstats_reactos.c.

{
  FILE *fp;
 
  if (!stats)
    return ERROR_INVALID_PARAMETER;
 
  memset(stats, 0, sizeof(MIB_ICMP));
  /* get most of these stats from /proc/net/snmp, no error if can't */
  fp = fopen("/proc/net/snmp", "r");
  if (fp) {
    const char hdr[] = "Icmp:";
    char buf[512] = { 0 }, *ptr;
 
    do {
      ptr = fgets(buf, sizeof(buf), fp);
    } while (ptr && _strnicmp(buf, hdr, sizeof(hdr) - 1));
    if (ptr) {
      /* last line was a header, get another */
      ptr = fgets(buf, sizeof(buf), fp);
      if (ptr && _strnicmp(buf, hdr, sizeof(hdr) - 1) == 0) {
        char *endPtr;
 
        ptr += sizeof(hdr);
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwMsgs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwErrors = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwDestUnreachs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwTimeExcds = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwParmProbs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwSrcQuenchs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwRedirects = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwEchoReps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwTimestamps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwTimestampReps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwAddrMasks = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpInStats.dwAddrMaskReps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwMsgs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwErrors = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwDestUnreachs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwTimeExcds = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwParmProbs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwSrcQuenchs = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwRedirects = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwEchoReps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwTimestamps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwTimestampReps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwAddrMasks = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
        if (ptr && *ptr) {
          stats->stats.icmpOutStats.dwAddrMaskReps = strtoul(ptr, &endPtr, 10);
          ptr = endPtr;
        }
      }
    }
    fclose(fp);
  }
  return NO_ERROR;
}

Referenced by GetIcmpStatistics().

getInterfaceStatsByIndex()

DWORD getInterfaceStatsByIndex	(	DWORD	index,
		PMIB_IFROW	entry
	)

Definition at line 289 of file ipstats_reactos.c.

{
    return ERROR_INVALID_PARAMETER;
}

getInterfaceStatsByName()

DWORD getInterfaceStatsByName	(	const char *	name,
		PMIB_IFROW	entry
	)

Definition at line 279 of file ipstats_reactos.c.

{
  if (!name)
    return ERROR_INVALID_PARAMETER;
  if (!entry)
    return ERROR_INVALID_PARAMETER;
 
  return NO_ERROR;
}

Referenced by GetIfEntry().

getIPStats()

DWORD getIPStats	(	_In_ HANDLE	TcpFile,
		_Out_ PMIB_IPSTATS	pStats
	)

Definition at line 421 of file ipstats_reactos.c.

{
    TDIEntityID ent;
    NTSTATUS Status;
 
    ent.tei_entity = CL_NL_ENTITY;
    ent.tei_instance = 0;
 
    Status = tdiGetMibForIpEntity(TcpFile, &ent, pStats);
 
    if (!NT_SUCCESS(Status))
        return RtlNtStatusToDosError(Status);
 
    return NO_ERROR;
}

getNthIpEntity()

NTSTATUS getNthIpEntity	(	HANDLE	tcpFile,
		DWORD	index,
		TDIEntityID *	ent
	)

Prototypes

Definition at line 65 of file ipstats_reactos.c.

                                                                         {
    DWORD numEntities = 0;
    DWORD numRoutes = 0;
    TDIEntityID *entitySet = 0;
    NTSTATUS status = tdiGetEntityIDSet( tcpFile, &entitySet, &numEntities );
    int i;
 
    if( !NT_SUCCESS(status) )
        return status;
 
    for( i = 0; i < numEntities; i++ ) {
        if( isIpEntity( tcpFile, &entitySet[i] ) ) {
            TRACE("Entity %d is an IP Entity\n", i);
            if( numRoutes == index ) break;
            else numRoutes++;
        }
    }
 
    if( numRoutes == index && i < numEntities ) {
        TRACE("Index %lu is entity #%d - %04x:%08x\n", index, i,
              entitySet[i].tei_entity, entitySet[i].tei_instance);
        memcpy( ent, &entitySet[i], sizeof(*ent) );
        tdiFreeThingSet( entitySet );
        return STATUS_SUCCESS;
    } else {
        tdiFreeThingSet( entitySet );
        return STATUS_UNSUCCESSFUL;
    }
}

Referenced by createIpForwardEntry(), deleteIpForwardEntry(), getInterfaceInfoSet(), getRouteTable(), and SetIpNetEntry().

getNumArpEntries()

DWORD getNumArpEntries

(

void

)

Definition at line 602 of file ipstats_reactos.c.

{
    DWORD numEntities;
    TDIEntityID *entitySet = NULL;
    HANDLE tcpFile;
    int i, totalNumber = 0;
    NTSTATUS status;
    PMIB_IPNETROW IpArpTable = NULL;
    DWORD returnSize;
 
    TRACE("called.\n");
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
 
    for (i = 0; i < numEntities; i++) {
        if (isInterface(&entitySet[i]) && hasArp(tcpFile, &entitySet[i]))
        {
            status = tdiGetSetOfThings(tcpFile,
                INFO_CLASS_PROTOCOL,
                INFO_TYPE_PROVIDER,
                IP_MIB_ARPTABLE_ENTRY_ID,
                AT_ENTITY,
                entitySet[i].tei_instance,
                0,
                sizeof(MIB_IPNETROW),
                (PVOID *)&IpArpTable,
                &returnSize);
 
            if (status == STATUS_SUCCESS) totalNumber += returnSize;
            if (IpArpTable) {
                tdiFreeThingSet(IpArpTable);
                IpArpTable = NULL;
            }
        }
    }
 
    closeTcpFile(tcpFile);
    if (entitySet) tdiFreeThingSet(entitySet);
    return totalNumber;
}

Referenced by getArpTable(), and GetIpNetTable().

getNumRoutes()

DWORD getNumRoutes

(

void

)

Definition at line 475 of file ipstats_reactos.c.

{
    DWORD numEntities, numRoutes = 0;
    TDIEntityID *entitySet;
    HANDLE tcpFile;
    int i;
    NTSTATUS status;
 
    TRACE("called.\n");
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
    if (!NT_SUCCESS(status)) {
        ERR("tdiGetEntityIDSet returned 0x%08lx\n", status);
        closeTcpFile( tcpFile );
        return 0;
    }
 
    for (i = 0; i < numEntities; i++) {
        if (isIpEntity(tcpFile, &entitySet[i])) {
            MIB_IPSTATS ipstats;
            memset(&ipstats, 0, sizeof(ipstats));
            status = tdiGetMibForIpEntity(tcpFile, &entitySet[i], &ipstats);
            if (!NT_SUCCESS(status)) {
                ERR("tdiGetMibForIpEntity returned 0x%08lx, for i = %d\n", status, i);
                numRoutes = 0;
                break;
            }
            numRoutes += ipstats.dwNumRoutes;
        }
    }
 
    TRACE("numRoutes = %lu\n", numRoutes);
 
    tdiFreeThingSet(entitySet);
    closeTcpFile(tcpFile);
 
    return numRoutes;
}

Referenced by getInterfaceGatewayByIndex(), GetIpForwardTable(), and getRouteTable().

getNumTcpEntries()

DWORD getNumTcpEntries

(

void

)

Definition at line 831 of file ipstats_reactos.c.

{
    DWORD numEntities;
    TDIEntityID *entitySet = NULL;
    HANDLE tcpFile;
    int i, totalNumber = 0;
    NTSTATUS status;
    PMIB_TCPROW IpTcpTable = NULL;
    DWORD returnSize;
 
    TRACE("called.\n");
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
 
    for (i = 0; i < numEntities; i++) {
        if (entitySet[i].tei_entity == CO_TL_ENTITY && hasArp(tcpFile, &entitySet[i]))
        {
            status = tdiGetSetOfThings(tcpFile,
                INFO_CLASS_PROTOCOL,
                INFO_TYPE_PROVIDER,
                IP_MIB_ARPTABLE_ENTRY_ID,
                CO_TL_ENTITY,
                entitySet[i].tei_instance,
                0,
                sizeof(MIB_TCPROW),
                (PVOID *)&IpTcpTable,
                &returnSize);
 
            if (status == STATUS_SUCCESS) totalNumber += returnSize;
            if (IpTcpTable) {
                tdiFreeThingSet(IpTcpTable);
                IpTcpTable = NULL;
            }
        }
    }
 
    closeTcpFile(tcpFile);
    if (entitySet) tdiFreeThingSet(entitySet);
    return totalNumber;
}

Referenced by getTcpTable().

getNumUdpEntries()

DWORD getNumUdpEntries

(

void

)

Definition at line 723 of file ipstats_reactos.c.

{
    DWORD numEntities;
    TDIEntityID *entitySet = NULL;
    HANDLE tcpFile;
    int i, totalNumber = 0;
    NTSTATUS status;
    PMIB_UDPROW IpUdpTable = NULL;
    DWORD returnSize;
 
    TRACE("called.\n");
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
 
    for (i = 0; i < numEntities; i++) {
        if (entitySet[i].tei_entity == CL_TL_ENTITY && hasArp(tcpFile, &entitySet[i]))
        {
            status = tdiGetSetOfThings(tcpFile,
                INFO_CLASS_PROTOCOL,
                INFO_TYPE_PROVIDER,
                IP_MIB_ARPTABLE_ENTRY_ID,
                CL_TL_ENTITY,
                entitySet[i].tei_instance,
                0,
                sizeof(MIB_UDPROW),
                (PVOID *)&IpUdpTable,
                &returnSize);
 
            if (status == STATUS_SUCCESS) totalNumber += returnSize;
            if (IpUdpTable) {
                tdiFreeThingSet(IpUdpTable);
                IpUdpTable = NULL;
            }
        }
    }
 
    closeTcpFile(tcpFile);
    if (entitySet) tdiFreeThingSet(entitySet);
    return totalNumber;
}

Referenced by getUdpTable().

getRouteTable()

RouteTable * getRouteTable

(

void

)

Definition at line 534 of file ipstats_reactos.c.

{
    RouteTable *out_route_table;
    DWORD numRoutes = getNumRoutes(), routesAdded = 0;
    TDIEntityID ent;
    HANDLE tcpFile;
    NTSTATUS status = openTcpFile(&tcpFile, FILE_READ_DATA);
    int i;
 
    if (!NT_SUCCESS(status))
        return 0;
 
    TRACE("GETTING ROUTE TABLE\n");
 
    out_route_table = HeapAlloc(GetProcessHeap(), 0,
                                sizeof(RouteTable) +
                                (sizeof(RouteEntry) * (numRoutes - 1)));
    if (!out_route_table) {
        closeTcpFile(tcpFile);
        return NULL;
    }
 
    out_route_table->numRoutes = numRoutes;
 
    for (i = 0; routesAdded < out_route_table->numRoutes; i++) {
        int j;
        IPRouteEntry *route_set;
 
        getNthIpEntity(tcpFile, i, &ent);
 
        tdiGetRoutesForIpEntity(tcpFile, &ent, &route_set, &numRoutes);
        if (!route_set) {
            closeTcpFile(tcpFile);
            HeapFree(GetProcessHeap(), 0, out_route_table);
            return 0;
        }
 
        TRACE("%lu routes in instance %d\n", numRoutes, i);
#if 0
        HexDump(route_set,
                sizeof(IPRouteEntry) *
                snmpInfo.ipsi_numroutes);
#endif
 
        for (j = 0; j < numRoutes; j++) {
            int routeNum = j + routesAdded;
            out_route_table->routes[routeNum].dest =
                route_set[j].ire_dest;
            out_route_table->routes[routeNum].mask =
                route_set[j].ire_mask;
            out_route_table->routes[routeNum].gateway =
                route_set[j].ire_gw;
            out_route_table->routes[routeNum].ifIndex =
                route_set[j].ire_index;
            out_route_table->routes[routeNum].metric =
                route_set[j].ire_metric1;
        }
 
        if (route_set) tdiFreeThingSet(route_set);
 
        routesAdded += numRoutes;
    }
 
    closeTcpFile(tcpFile);
    TRACE("status = 0x%08lx, out_route_table = 0x%p\n", status, out_route_table);
    return out_route_table;
}

Referenced by getInterfaceGatewayByIndex(), and GetIpForwardTable().

getTCPStats()

DWORD getTCPStats	(	_In_ HANDLE	TcpFile,
		_Out_ MIB_TCPSTATS *	pStats
	)

Definition at line 439 of file ipstats_reactos.c.

{
    TDIEntityID ent;
    NTSTATUS Status;
 
    ent.tei_entity = CO_TL_ENTITY;
    ent.tei_instance = 0;
 
    Status = tdiGetMibForTcpEntity(TcpFile, &ent, pStats);
 
    if (!NT_SUCCESS(Status))
        return RtlNtStatusToDosError(Status);
 
    return NO_ERROR;
}

getTcpTable()

PVOID getTcpTable

(

CLASS_TABLE

Class

)

Definition at line 879 of file ipstats_reactos.c.

{
    DWORD numEntities, returnSize;
    TDIEntityID *entitySet;
    HANDLE tcpFile;
    int i, totalNumber, TmpIdx, CurrIdx = 0;
    NTSTATUS status;
    PMIB_TCPTABLE IpTcpTable = NULL;
    PVOID AdapterTcpTable = NULL;
 
    TRACE("called.\n");
 
    totalNumber = getNumTcpEntries();
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    IpTcpTable = HeapAlloc(GetProcessHeap(), 0,
        UdpTcpTableCall[Class].TcpOffset + (UdpTcpTableCall[Class].TcpSize * totalNumber));
    if (!IpTcpTable) {
        closeTcpFile(tcpFile);
        return NULL;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
 
    for (i = 0; i < numEntities; i++) {
        if (entitySet[i].tei_entity == CO_TL_ENTITY && hasArp(tcpFile, &entitySet[i]))
        {
            status = tdiGetSetOfThings(tcpFile,
                INFO_CLASS_PROTOCOL,
                INFO_TYPE_PROVIDER,
                UdpTcpTableCall[Class].TOIID,
                CO_TL_ENTITY,
                entitySet[i].tei_instance,
                0,
                UdpTcpTableCall[Class].TcpSize,
                &AdapterTcpTable,
                &returnSize);
 
            if (status == STATUS_SUCCESS) {
                for (TmpIdx = 0; TmpIdx < returnSize; TmpIdx++, CurrIdx++)
                    CopyMemory(Add2Ptr(IpTcpTable, UdpTcpTableCall[Class].TcpOffset + UdpTcpTableCall[Class].TcpSize * CurrIdx),
                               Add2Ptr(AdapterTcpTable, UdpTcpTableCall[Class].TcpSize * TmpIdx),
                               UdpTcpTableCall[Class].TcpSize);
                tdiFreeThingSet(AdapterTcpTable);
            }
        }
    }
 
    closeTcpFile(tcpFile);
    tdiFreeThingSet(entitySet);
    IpTcpTable->dwNumEntries = CurrIdx;
    return IpTcpTable;
}

Referenced by GetExtendedTcpTable().

getUDPStats()

DWORD getUDPStats	(	_In_ HANDLE	TcpFile,
		_Out_ MIB_UDPSTATS *	pStats
	)

Definition at line 457 of file ipstats_reactos.c.

{
    TDIEntityID ent;
    NTSTATUS Status;
 
    ent.tei_entity = CL_TL_ENTITY;
    ent.tei_instance = 0;
 
    Status = tdiGetMibForUdpEntity(TcpFile, &ent, pStats);
 
    if (!NT_SUCCESS(Status))
        return RtlNtStatusToDosError(Status);
 
    return NO_ERROR;
}

getUdpTable()

PVOID getUdpTable

(

CLASS_TABLE

Class

)

Definition at line 771 of file ipstats_reactos.c.

{
    DWORD numEntities, returnSize;
    TDIEntityID *entitySet;
    HANDLE tcpFile;
    int i, totalNumber, TmpIdx, CurrIdx = 0;
    NTSTATUS status;
    PMIB_UDPTABLE IpUdpTable = NULL;
    PVOID AdapterUdpTable = NULL;
 
    TRACE("called.\n");
 
    totalNumber = getNumUdpEntries();
 
    status = openTcpFile(&tcpFile, FILE_READ_DATA);
    if (!NT_SUCCESS(status))
    {
        ERR("openTcpFile returned 0x%08lx\n", status);
        return 0;
    }
 
    IpUdpTable = HeapAlloc(GetProcessHeap(), 0,
        UdpTcpTableCall[Class].UdpOffset + (UdpTcpTableCall[Class].UdpSize * totalNumber));
    if (!IpUdpTable) {
        closeTcpFile(tcpFile);
        return NULL;
    }
 
    status = tdiGetEntityIDSet(tcpFile, &entitySet, &numEntities);
 
    for (i = 0; i < numEntities; i++) {
        if (entitySet[i].tei_entity == CL_TL_ENTITY && hasArp(tcpFile, &entitySet[i]))
        {
            status = tdiGetSetOfThings(tcpFile,
                INFO_CLASS_PROTOCOL,
                INFO_TYPE_PROVIDER,
                UdpTcpTableCall[Class].TOIID,
                CL_TL_ENTITY,
                entitySet[i].tei_instance,
                0,
                UdpTcpTableCall[Class].UdpSize,
                &AdapterUdpTable,
                &returnSize);
 
            if (status == STATUS_SUCCESS) {
                for (TmpIdx = 0; TmpIdx < returnSize; TmpIdx++, CurrIdx++)
                    CopyMemory(Add2Ptr(IpUdpTable, UdpTcpTableCall[Class].UdpOffset + UdpTcpTableCall[Class].UdpSize * CurrIdx),
                               Add2Ptr(AdapterUdpTable, UdpTcpTableCall[Class].UdpSize * TmpIdx),
                               UdpTcpTableCall[Class].UdpSize);
                tdiFreeThingSet(AdapterUdpTable);
            }
        }
    }
 
    closeTcpFile(tcpFile);
    tdiFreeThingSet(entitySet);
    IpUdpTable->dwNumEntries = CurrIdx;
    return IpUdpTable;
}

Referenced by GetExtendedUdpTable().

HexDump()

VOID HexDump	(	PCHAR	Data,
		DWORD	Len
	)

Definition at line 521 of file ipstats_reactos.c.

                                      {
    int i;
 
    for( i = 0; i < Len; i++ ) {
        if( !(i & 0xf) ) {
            if( i ) fprintf(stderr,"\n");
            fprintf(stderr,"%08x:", i);
        }
        fprintf( stderr, " %02x", Data[i] & 0xff );
    }
    fprintf(stderr,"\n");
}

Referenced by getRouteTable().

isIpEntity()

BOOL isIpEntity	(	HANDLE	tcpFile,
		TDIEntityID *	ent
	)

Definition at line 60 of file ipstats_reactos.c.

                                                    {
    return (ent->tei_entity == CL_NL_ENTITY ||
            ent->tei_entity == CO_NL_ENTITY);
}

Referenced by getNthIpEntity(), and getNumRoutes().

tdiGetIpAddrsForIpEntity()

NTSTATUS tdiGetIpAddrsForIpEntity	(	HANDLE	tcpFile,
		TDIEntityID *	ent,
		IPAddrEntry **	addrs,
		PDWORD	numAddrs
	)

Definition at line 258 of file ipstats_reactos.c.

                                                                           {
    NTSTATUS status;
 
    TRACE("TdiGetIpAddrsForIpEntity(tcpFile 0x%p, entityId 0x%x)\n",
          tcpFile, ent->tei_instance);
 
    status = tdiGetSetOfThings(tcpFile,
                               INFO_CLASS_PROTOCOL,
                               INFO_TYPE_PROVIDER,
                               IP_MIB_ADDRTABLE_ENTRY_ID,
                               CL_NL_ENTITY,
                               ent->tei_instance,
                               0,
                               sizeof(IPAddrEntry),
                               (PVOID *)addrs,
                               numAddrs);
 
    return status;
}

Referenced by getInterfaceInfoSet().

tdiGetMibForIpEntity()

static NTSTATUS tdiGetMibForIpEntity ( _In_ HANDLE  tcpFile, _In_ TDIEntityID *  ent, _Out_ MIB_IPSTATS *  entry  )

static

Definition at line 96 of file ipstats_reactos.c.

{
    TCP_REQUEST_QUERY_INFORMATION_EX req = TCP_REQUEST_QUERY_INFORMATION_INIT;
    NTSTATUS Status;
    DWORD returnSize;
 
    ZeroMemory(entry, sizeof(*entry));
 
    TRACE("TdiGetMibForIpEntity(tcpFile 0x%p, entityId 0x%x)\n",
          tcpFile, ent->tei_instance);
 
    req.ID.toi_class                = INFO_CLASS_PROTOCOL;
    req.ID.toi_type                 = INFO_TYPE_PROVIDER;
    req.ID.toi_id                   = IP_MIB_STATS_ID;
    req.ID.toi_entity               = *ent;
 
    Status = DeviceIoControl(tcpFile,
                             IOCTL_TCP_QUERY_INFORMATION_EX,
                             &req,
                             sizeof(req),
                             entry,
                             sizeof(*entry),
                             &returnSize,
                             NULL);
 
    TRACE("TdiGetMibForIpEntity() => status = 0x%08lx, entry = {\n"
           "  ipsi_forwarding ............ %lu\n"
           "  ipsi_defaultttl ............ %lu\n"
           "  ipsi_inreceives ............ %lu\n"
           "  ipsi_indelivers ............ %lu\n"
           "  ipsi_outrequests ........... %lu\n"
           "  ipsi_routingdiscards ....... %lu\n"
           "  ipsi_outdiscards ........... %lu\n"
           "  ipsi_outnoroutes ........... %lu\n"
           "  ipsi_numif ................. %lu\n"
           "  ipsi_numaddr ............... %lu\n"
           "  ipsi_numroutes ............. %lu\n"
           "}\n",
          Status,
          entry->dwForwarding,
          entry->dwDefaultTTL,
          entry->dwInReceives,
          entry->dwInDelivers,
          entry->dwOutRequests,
          entry->dwRoutingDiscards,
          entry->dwOutDiscards,
          entry->dwOutNoRoutes,
          entry->dwNumIf,
          entry->dwNumAddr,
          entry->dwNumRoutes);
 
    return Status;
}

Referenced by getIPStats(), and getNumRoutes().

tdiGetMibForTcpEntity()

static NTSTATUS tdiGetMibForTcpEntity ( _In_ HANDLE  tcpFile, _In_ TDIEntityID *  ent, _Out_ MIB_TCPSTATS *  entry  )

static

Definition at line 154 of file ipstats_reactos.c.

{
    TCP_REQUEST_QUERY_INFORMATION_EX req = TCP_REQUEST_QUERY_INFORMATION_INIT;
    NTSTATUS Status;
    DWORD returnSize;
 
    ZeroMemory(entry, sizeof(*entry));
 
    TRACE("TdiGetMibForTcpEntity(tcpFile 0x%p, entityId 0x%x)\n",
          tcpFile, ent->tei_instance);
 
    req.ID.toi_class                = INFO_CLASS_PROTOCOL;
    req.ID.toi_type                 = INFO_TYPE_PROVIDER;
    req.ID.toi_id                   = TCP_MIB_STAT_ID;
    req.ID.toi_entity               = *ent;
 
    Status = DeviceIoControl(tcpFile,
                             IOCTL_TCP_QUERY_INFORMATION_EX,
                             &req,
                             sizeof(req),
                             entry,
                             sizeof(*entry),
                             &returnSize,
                             NULL);
 
    TRACE("TdiGetMibForTcpEntity() => status = 0x%08lx, entry = {\n"
           "  dwInSegs ............. %lu\n"
           "  dwOutSegs ............ %lu\n"
           "  dwNumConns ........... %lu\n"
           "}\n",
          Status,
          entry->dwInSegs,
          entry->dwOutSegs,
          entry->dwNumConns);
 
    return Status;
}

Referenced by getTCPStats().

tdiGetMibForUdpEntity()

static NTSTATUS tdiGetMibForUdpEntity ( _In_ HANDLE  tcpFile, _In_ TDIEntityID *  ent, _Out_ MIB_UDPSTATS *  entry  )

static

Definition at line 196 of file ipstats_reactos.c.

{
    TCP_REQUEST_QUERY_INFORMATION_EX req = TCP_REQUEST_QUERY_INFORMATION_INIT;
    NTSTATUS Status;
    DWORD returnSize;
 
    ZeroMemory(entry, sizeof(*entry));
 
    TRACE("TdiGetMibForUdpEntity(tcpFile 0x%p, entityId 0x%x)\n",
          tcpFile, ent->tei_instance);
 
    req.ID.toi_class                = INFO_CLASS_PROTOCOL;
    req.ID.toi_type                 = INFO_TYPE_PROVIDER;
    req.ID.toi_id                   = UDP_MIB_STAT_ID;
    req.ID.toi_entity               = *ent;
 
    Status = DeviceIoControl(tcpFile,
                             IOCTL_TCP_QUERY_INFORMATION_EX,
                             &req,
                             sizeof(req),
                             entry,
                             sizeof(*entry),
                             &returnSize,
                             NULL);
 
    TRACE("TdiGetMibForUdpEntity() => status = 0x%08lx, entry = {\n"
           "  dwInDatagrams ....... %lu\n"
           "  dwOutDatagrams ...... %lu\n"
           "  dwNumAddrs .......... %lu\n"
           "}\n",
          Status,
          entry->dwInDatagrams,
          entry->dwOutDatagrams,
          entry->dwNumAddrs);
 
    return Status;
}

Referenced by getUDPStats().

tdiGetRoutesForIpEntity()

NTSTATUS tdiGetRoutesForIpEntity	(	HANDLE	tcpFile,
		TDIEntityID *	ent,
		IPRouteEntry **	routes,
		PDWORD	numRoutes
	)

Definition at line 237 of file ipstats_reactos.c.

                                                                              {
    NTSTATUS status = STATUS_SUCCESS;
 
    TRACE("TdiGetRoutesForIpEntity(tcpFile 0x%p, entityId 0x%x)\n",
          tcpFile, ent->tei_instance);
 
    status = tdiGetSetOfThings(tcpFile,
                               INFO_CLASS_PROTOCOL,
                               INFO_TYPE_PROVIDER,
                               IP_MIB_ARPTABLE_ENTRY_ID,
                               CL_NL_ENTITY,
                               ent->tei_instance,
                               0,
                               sizeof(IPRouteEntry),
                               (PVOID *)routes,
                               numRoutes);
 
    return status;
}

Referenced by getRouteTable().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

iphlpapi

)

Variable Documentation

UdpTcpTableCall

struct _TABLE_CALL UdpTcpTableCall[]

Initial value:

= {
    {IP_MIB_ARPTABLE_ENTRY_ID, sizeof(MIB_UDPROW), sizeof(MIB_TCPROW), FIELD_OFFSET(MIB_UDPTABLE, table), FIELD_OFFSET(MIB_TCPTABLE, table)},
    {IP_MIB_ADDRTABLE_ENTRY_ID, sizeof(MIB_UDPROW_OWNER_PID), sizeof(MIB_TCPROW_OWNER_PID), FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table), FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table)},
    {IP_SPECIFIC_MODULE_ENTRY_ID, sizeof(MIB_UDPROW_OWNER_MODULE), sizeof(MIB_TCPROW_OWNER_MODULE), FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table), FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table)},
}

Referenced by getTcpTable(), and getUdpTable().