ipstats.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_RouteEntry
struct	_RouteTable

Typedefs
typedef struct _RouteEntry	RouteEntry
typedef struct _RouteTable	RouteTable
typedef enum _CLASS_TABLE	CLASS_TABLE

Enumerations
enum	_CLASS_TABLE { ClassBasic , ClassModulePid , ClassModule }

Functions
DWORD	getInterfaceStatsByName (const char *name, PMIB_IFROW entry)
DWORD	getInterfaceStatsByIndex (DWORD index, PMIB_IFROW entry)
DWORD	getICMPStats (MIB_ICMP *stats)
DWORD	getIPStats (HANDLE tcpFile, PMIB_IPSTATS stats)
DWORD	getTCPStats (HANDLE tcpFile, MIB_TCPSTATS *stats)
DWORD	getUDPStats (HANDLE tcpFile, MIB_UDPSTATS *stats)
DWORD	getNumRoutes (void)
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)

Typedef Documentation

CLASS_TABLE

typedef enum _CLASS_TABLE CLASS_TABLE

RouteEntry

typedef struct _RouteEntry RouteEntry

RouteTable

typedef struct _RouteTable RouteTable

Enumeration Type Documentation

_CLASS_TABLE

enum _CLASS_TABLE

Enumerator
ClassBasic
ClassModulePid
ClassModule

Definition at line 79 of file ipstats.h.

                          {
    ClassBasic,
    ClassModulePid,
    ClassModule
} CLASS_TABLE;

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	(	HANDLE	tcpFile,
		PMIB_IPSTATS	stats
	)

Referenced by GetIpStatisticsEx().

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	(	HANDLE	tcpFile,
		MIB_TCPSTATS *	stats
	)

Referenced by GetTcpStatisticsEx().

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	(	HANDLE	tcpFile,
		MIB_UDPSTATS *	stats
	)

Referenced by GetUdpStatisticsEx().

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().