VOID ShowIpStatistics() { PMIB_IPSTATS pIpStats; DWORD dwRetVal; pIpStats = (MIB_IPSTATS*) HeapAlloc(GetProcessHeap(), 0, sizeof(MIB_IPSTATS)); if ((dwRetVal = GetIpStatistics(pIpStats)) == NO_ERROR) { _tprintf(_T("\nIPv4 Statistics\n\n")); _tprintf(_T(" %-34s = %lu\n"), _T("Packets Received"), pIpStats->dwInReceives); _tprintf(_T(" %-34s = %lu\n"), _T("Received Header Errors"), pIpStats->dwInHdrErrors); _tprintf(_T(" %-34s = %lu\n"), _T("Received Address Errors"), pIpStats->dwInAddrErrors); _tprintf(_T(" %-34s = %lu\n"), _T("Datagrams Forwarded"), pIpStats->dwForwDatagrams); _tprintf(_T(" %-34s = %lu\n"), _T("Unknown Protocols Received"), pIpStats->dwInUnknownProtos); _tprintf(_T(" %-34s = %lu\n"), _T("Received Packets Discarded"), pIpStats->dwInDiscards); _tprintf(_T(" %-34s = %lu\n"), _T("Received Packets Delivered"), pIpStats->dwInDelivers); _tprintf(_T(" %-34s = %lu\n"), _T("Output Requests"), pIpStats->dwOutRequests); _tprintf(_T(" %-34s = %lu\n"), _T("Routing Discards"), pIpStats->dwRoutingDiscards); _tprintf(_T(" %-34s = %lu\n"), _T("Discarded Output Packets"), pIpStats->dwOutDiscards); _tprintf(_T(" %-34s = %lu\n"), _T("Output Packets No Route"), pIpStats->dwOutNoRoutes); _tprintf(_T(" %-34s = %lu\n"), _T("Reassembly Required"), pIpStats->dwReasmReqds); _tprintf(_T(" %-34s = %lu\n"), _T("Reassembly Succesful"), pIpStats->dwReasmOks); _tprintf(_T(" %-34s = %lu\n"), _T("Reassembly Failures"), pIpStats->dwReasmFails); // _tprintf(_T(" %-34s = %lu\n"), _T("Datagrams succesfully fragmented"), NULL); /* FIXME: what is this one? */ _tprintf(_T(" %-34s = %lu\n"), _T("Datagrams Failing Fragmentation"), pIpStats->dwFragFails); _tprintf(_T(" %-34s = %lu\n"), _T("Fragments Created"), pIpStats->dwFragCreates); } else DoFormatMessage(dwRetVal); HeapFree(GetProcessHeap(), 0, pIpStats); }
bool UpdateSystemInfoP( FvSystemInfo &kSI ) { if ( s_pfImportedGetSystemTimes ) { FILETIME kIdleFileTime, kKernelFileTime, kUserFileTime; s_pfImportedGetSystemTimes( &kIdleFileTime, &kKernelFileTime, &kUserFileTime ); FvUInt64 uiIdleTime = *(FvUInt64*)&kIdleFileTime; FvUInt64 uiKernelTime = *(FvUInt64*)&kKernelFileTime; FvUInt64 uiUserTime = *(FvUInt64*)&kUserFileTime; //gCurMaxCPU = (uiKernelTime + uiKserTime) / gCPUCount; //td.curCPU = gCurMaxCPU - uiIdleTime / gCPUCount; } MEMORYSTATUS kMem; GlobalMemoryStatus( &kMem ); kSI.m_kMem.max.update(kMem.dwTotalPhys); kSI.m_kMem.val.update(kMem.dwAvailPhys); MIB_IPSTATS kIPStats; GetIpStatistics( &kIPStats ); kSI.m_kPackTotOut.update(kIPStats.dwOutRequests); kSI.m_kPackDropOut.update(kIPStats.dwOutDiscards); kSI.m_kPackTotIn.update(kIPStats.dwInReceives); kSI.m_kPackDropIn.update(kIPStats.dwInDiscards); return true; }
int ip_load(netsnmp_cache *cache, void *vmagic) { long ret_value = -1; ret_value = GetIpStatistics(&ipstat); if ( ret_value < 0 ) { DEBUGMSGTL(("mibII/ip", "Failed to load IP Group (win32)\n")); } else { DEBUGMSGTL(("mibII/ip", "Loaded IP Group (win32)\n")); } return ret_value; }
DWORD WINAPI WsControl(DWORD protocol, DWORD action, LPVOID pRequestInfo, LPDWORD pcbRequestInfoLen, LPVOID pResponseInfo, LPDWORD pcbResponseInfoLen) { /* Get the command structure into a pointer we can use, rather than void */ TDIObjectID *pcommand = pRequestInfo; /* validate input parameters. Error codes are from winerror.h, not from * winsock.h. pcbResponseInfoLen is apparently allowed to be NULL for some * commands, since winipcfg.exe fails if we ensure it's non-NULL in every * case. */ if (protocol != IPPROTO_TCP) return ERROR_INVALID_PARAMETER; if (!pcommand) return ERROR_INVALID_PARAMETER; if (!pcbRequestInfoLen) return ERROR_INVALID_ACCESS; if (*pcbRequestInfoLen < sizeof(TDIObjectID)) return ERROR_INVALID_ACCESS; if (!pResponseInfo) return ERROR_INVALID_PARAMETER; if (pcommand->toi_type != INFO_TYPE_PROVIDER) return ERROR_INVALID_PARAMETER; TRACE (" WsControl TOI_ID=>0x%lx<, {TEI_ENTITY=0x%lx, TEI_INSTANCE=0x%lx}, TOI_CLASS=0x%lx, TOI_TYPE=0x%lx\n", pcommand->toi_id, pcommand->toi_entity.tei_entity, pcommand->toi_entity.tei_instance, pcommand->toi_class, pcommand->toi_type ); switch (action) { case WSCNTL_TCPIP_QUERY_INFO: { if (pcommand->toi_class != INFO_CLASS_GENERIC && pcommand->toi_class != INFO_CLASS_PROTOCOL) { ERR("Unexpected class %ld for WSCNTL_TCPIP_QUERY_INFO\n", pcommand->toi_class); return ERROR_BAD_ENVIRONMENT; } switch (pcommand->toi_id) { /* ENTITY_LIST_ID gets the list of "entity IDs", where an entity may represent an interface, or a datagram service, or address translation, or other fun things. Typically an entity ID represents a class of service, which is further queried for what type it is. Different types will then have more specific queries defined. */ case ENTITY_LIST_ID: { TDIEntityID *baseptr = pResponseInfo; DWORD numInt, i, ifTable, spaceNeeded; PMIB_IFTABLE table; if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (pcommand->toi_class != INFO_CLASS_GENERIC) { FIXME ("Unexpected Option for ENTITY_LIST_ID request -> toi_class=0x%lx\n", pcommand->toi_class); return (ERROR_BAD_ENVIRONMENT); } GetNumberOfInterfaces(&numInt); spaceNeeded = sizeof(TDIEntityID) * (numInt * 2 + 3); if (*pcbResponseInfoLen < spaceNeeded) return (ERROR_LOCK_VIOLATION); ifTable = 0; GetIfTable(NULL, &ifTable, FALSE); table = HeapAlloc( GetProcessHeap(), 0, ifTable ); if (!table) return ERROR_NOT_ENOUGH_MEMORY; GetIfTable(table, &ifTable, FALSE); spaceNeeded = sizeof(TDIEntityID) * (table->dwNumEntries + 4); if (*pcbResponseInfoLen < spaceNeeded) { HeapFree( GetProcessHeap(), 0, table ); return ERROR_LOCK_VIOLATION; } memset(baseptr, 0, spaceNeeded); for (i = 0; i < table->dwNumEntries; i++) { /* Return IF_GENERIC and CL_NL_ENTITY on every interface, and * AT_ENTITY, CL_TL_ENTITY, and CO_TL_ENTITY on the first * interface. MS returns them only on the loopback interface, * but it doesn't seem to matter. */ if (i == 0) { baseptr->tei_entity = CO_TL_ENTITY; baseptr->tei_instance = table->table[i].dwIndex; baseptr++; baseptr->tei_entity = CL_TL_ENTITY; baseptr->tei_instance = table->table[i].dwIndex; baseptr++; baseptr->tei_entity = AT_ENTITY; baseptr->tei_instance = table->table[i].dwIndex; baseptr++; } baseptr->tei_entity = CL_NL_ENTITY; baseptr->tei_instance = table->table[i].dwIndex; baseptr++; baseptr->tei_entity = IF_GENERIC; baseptr->tei_instance = table->table[i].dwIndex; baseptr++; } *pcbResponseInfoLen = spaceNeeded; HeapFree( GetProcessHeap(), 0, table ); break; } /* Returns MIB-II statistics for an interface */ case ENTITY_TYPE_ID: switch (pcommand->toi_entity.tei_entity) { case IF_GENERIC: if (pcommand->toi_class == INFO_CLASS_GENERIC) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; *((ULONG *)pResponseInfo) = IF_MIB; *pcbResponseInfoLen = sizeof(ULONG); } else if (pcommand->toi_class == INFO_CLASS_PROTOCOL) { MIB_IFROW row; DWORD index = pcommand->toi_entity.tei_instance, ret; DWORD size = sizeof(row) - sizeof(row.wszName) - sizeof(row.bDescr); if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (*pcbResponseInfoLen < size) return (ERROR_LOCK_VIOLATION); row.dwIndex = index; ret = GetIfEntry(&row); if (ret != NO_ERROR) { /* FIXME: Win98's arp.exe insists on querying index 1 for * its MIB-II stats, regardless of the tei_instances * returned in the ENTITY_LIST query above. If the query * fails, arp.exe fails. So, I do this hack return value * if index is 1 and the query failed just to get arp.exe * to continue. */ if (index == 1) return NO_ERROR; ERR ("Error retrieving data for interface index %u\n", index); return ret; } size = sizeof(row) - sizeof(row.wszName) - sizeof(row.bDescr) + row.dwDescrLen; if (*pcbResponseInfoLen < size) return (ERROR_LOCK_VIOLATION); memcpy(pResponseInfo, &row.dwIndex, size); *pcbResponseInfoLen = size; } break; /* Returns address-translation related data. In our case, this is * ARP. */ case AT_ENTITY: if (pcommand->toi_class == INFO_CLASS_GENERIC) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; *((ULONG *)pResponseInfo) = AT_ARP; *pcbResponseInfoLen = sizeof(ULONG); } else if (pcommand->toi_class == INFO_CLASS_PROTOCOL) { PMIB_IPNETTABLE table; DWORD size; PULONG output = pResponseInfo; if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (*pcbResponseInfoLen < sizeof(ULONG) * 2) return (ERROR_LOCK_VIOLATION); GetIpNetTable(NULL, &size, FALSE); table = HeapAlloc( GetProcessHeap(), 0, size ); if (!table) return ERROR_NOT_ENOUGH_MEMORY; GetIpNetTable(table, &size, FALSE); /* FIXME: I don't understand the meaning of the ARP output * very well, but it seems to indicate how many ARP entries * exist. I don't know whether this should reflect the * number per interface, as I'm only testing with a single * interface. So, I lie and say all ARP entries exist on * a single interface--the first one that appears in the * ARP table. */ *(output++) = table->dwNumEntries; *output = table->table[0].dwIndex; HeapFree( GetProcessHeap(), 0, table ); *pcbResponseInfoLen = sizeof(ULONG) * 2; } break; /* Returns connectionless network layer statistics--in our case, * this is IP. */ case CL_NL_ENTITY: if (pcommand->toi_class == INFO_CLASS_GENERIC) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; *((ULONG *)pResponseInfo) = CL_NL_IP; *pcbResponseInfoLen = sizeof(ULONG); } else if (pcommand->toi_class == INFO_CLASS_PROTOCOL) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (*pcbResponseInfoLen < sizeof(MIB_IPSTATS)) return ERROR_LOCK_VIOLATION; GetIpStatistics(pResponseInfo); *pcbResponseInfoLen = sizeof(MIB_IPSTATS); } break; /* Returns connectionless transport layer statistics--in our case, * this is UDP. */ case CL_TL_ENTITY: if (pcommand->toi_class == INFO_CLASS_GENERIC) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; *((ULONG *)pResponseInfo) = CL_TL_UDP; *pcbResponseInfoLen = sizeof(ULONG); } else if (pcommand->toi_class == INFO_CLASS_PROTOCOL) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (*pcbResponseInfoLen < sizeof(MIB_UDPSTATS)) return ERROR_LOCK_VIOLATION; GetUdpStatistics(pResponseInfo); *pcbResponseInfoLen = sizeof(MIB_UDPSTATS); } break; /* Returns connection-oriented transport layer statistics--in our * case, this is TCP. */ case CO_TL_ENTITY: if (pcommand->toi_class == INFO_CLASS_GENERIC) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; *((ULONG *)pResponseInfo) = CO_TL_TCP; *pcbResponseInfoLen = sizeof(ULONG); } else if (pcommand->toi_class == INFO_CLASS_PROTOCOL) { if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (*pcbResponseInfoLen < sizeof(MIB_TCPSTATS)) return ERROR_LOCK_VIOLATION; GetTcpStatistics(pResponseInfo); *pcbResponseInfoLen = sizeof(MIB_TCPSTATS); } break; default: ERR("Unknown entity %ld for ENTITY_TYPE_ID query\n", pcommand->toi_entity.tei_entity); } break; /* This call returns the IP address, subnet mask, and broadcast * address for an interface. If there are multiple IP addresses for * the interface with the given index, returns the "first" one. */ case IP_MIB_ADDRTABLE_ENTRY_ID: { DWORD index = pcommand->toi_entity.tei_instance; PMIB_IPADDRROW baseIPInfo = pResponseInfo; PMIB_IPADDRTABLE table; DWORD tableSize, i; if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; if (*pcbResponseInfoLen < sizeof(MIB_IPADDRROW)) return (ERROR_LOCK_VIOLATION); /* get entire table, because there isn't an exported function that gets just one entry. */ tableSize = 0; GetIpAddrTable(NULL, &tableSize, FALSE); table = HeapAlloc( GetProcessHeap(), 0, tableSize ); if (!table) return ERROR_NOT_ENOUGH_MEMORY; GetIpAddrTable(table, &tableSize, FALSE); for (i = 0; i < table->dwNumEntries; i++) { if (table->table[i].dwIndex == index) { TRACE("Found IP info for tei_instance 0x%x:\n", index); TRACE("IP 0x%08x, mask 0x%08x\n", table->table[i].dwAddr, table->table[i].dwMask); *baseIPInfo = table->table[i]; break; } } HeapFree( GetProcessHeap(), 0, table ); *pcbResponseInfoLen = sizeof(MIB_IPADDRROW); break; } case IP_MIB_TABLE_ENTRY_ID: { switch (pcommand->toi_entity.tei_entity) { /* This call returns the routing table. * No official documentation found, even the name of the command is unknown. * Work is based on * http://www.cyberport.com/~tangent/programming/winsock/articles/wscontrol.html * and testings done with winipcfg.exe, route.exe and ipconfig.exe. * pcommand->toi_entity.tei_instance seems to be the interface number * but route.exe outputs only the information for the last interface * if only the routes for the pcommand->toi_entity.tei_instance * interface are returned. */ case CL_NL_ENTITY: { DWORD routeTableSize, numRoutes, ndx, ret; PMIB_IPFORWARDTABLE table; IPRouteEntry *winRouteTable = pResponseInfo; if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; ret = GetIpForwardTable(NULL, &routeTableSize, FALSE); if (ret != ERROR_INSUFFICIENT_BUFFER) return ret; numRoutes = (routeTableSize - sizeof(MIB_IPFORWARDTABLE)) / sizeof(MIB_IPFORWARDROW) + 1; if (*pcbResponseInfoLen < sizeof(IPRouteEntry) * numRoutes) return (ERROR_LOCK_VIOLATION); table = HeapAlloc( GetProcessHeap(), 0, routeTableSize ); if (!table) return ERROR_NOT_ENOUGH_MEMORY; ret = GetIpForwardTable(table, &routeTableSize, FALSE); if (ret != NO_ERROR) { HeapFree( GetProcessHeap(), 0, table ); return ret; } memset(pResponseInfo, 0, sizeof(IPRouteEntry) * numRoutes); for (ndx = 0; ndx < table->dwNumEntries; ndx++) { winRouteTable->ire_addr = table->table[ndx].dwForwardDest; winRouteTable->ire_index = table->table[ndx].dwForwardIfIndex; winRouteTable->ire_metric = table->table[ndx].dwForwardMetric1; /* winRouteTable->ire_option4 = winRouteTable->ire_option5 = winRouteTable->ire_option6 = */ winRouteTable->ire_gw = table->table[ndx].dwForwardNextHop; /* winRouteTable->ire_option8 = winRouteTable->ire_option9 = winRouteTable->ire_option10 = */ winRouteTable->ire_mask = table->table[ndx].dwForwardMask; /* winRouteTable->ire_option12 = */ winRouteTable++; } /* calculate the length of the data in the output buffer */ *pcbResponseInfoLen = sizeof(IPRouteEntry) * table->dwNumEntries; HeapFree( GetProcessHeap(), 0, table ); } break; case AT_ARP: { DWORD arpTableSize, numEntries, ret; PMIB_IPNETTABLE table; if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; ret = GetIpNetTable(NULL, &arpTableSize, FALSE); if (ret != ERROR_INSUFFICIENT_BUFFER) return ret; numEntries = (arpTableSize - sizeof(MIB_IPNETTABLE)) / sizeof(MIB_IPNETROW) + 1; if (*pcbResponseInfoLen < sizeof(MIB_IPNETROW) * numEntries) return (ERROR_LOCK_VIOLATION); table = HeapAlloc( GetProcessHeap(), 0, arpTableSize ); if (!table) return ERROR_NOT_ENOUGH_MEMORY; ret = GetIpNetTable(table, &arpTableSize, FALSE); if (ret != NO_ERROR) { HeapFree( GetProcessHeap(), 0, table ); return ret; } if (*pcbResponseInfoLen < sizeof(MIB_IPNETROW) * table->dwNumEntries) { HeapFree( GetProcessHeap(), 0, table ); return ERROR_LOCK_VIOLATION; } memcpy(pResponseInfo, table->table, sizeof(MIB_IPNETROW) * table->dwNumEntries); /* calculate the length of the data in the output buffer */ *pcbResponseInfoLen = sizeof(MIB_IPNETROW) * table->dwNumEntries; HeapFree( GetProcessHeap(), 0, table ); } break; case CO_TL_ENTITY: { DWORD tcpTableSize, numEntries, ret; PMIB_TCPTABLE table; DWORD i; if (!pcbResponseInfoLen) return ERROR_BAD_ENVIRONMENT; ret = GetTcpTable(NULL, &tcpTableSize, FALSE); if (ret != ERROR_INSUFFICIENT_BUFFER) return ret; numEntries = (tcpTableSize - sizeof(MIB_TCPTABLE)) / sizeof(MIB_TCPROW) + 1; if (*pcbResponseInfoLen < sizeof(MIB_TCPROW) * numEntries) return (ERROR_LOCK_VIOLATION); table = HeapAlloc( GetProcessHeap(), 0, tcpTableSize ); if (!table) return ERROR_NOT_ENOUGH_MEMORY; ret = GetTcpTable(table, &tcpTableSize, FALSE); if (ret != NO_ERROR) { HeapFree( GetProcessHeap(), 0, table ); return ret; } if (*pcbResponseInfoLen < sizeof(MIB_TCPROW) * table->dwNumEntries) { HeapFree( GetProcessHeap(), 0, table ); return ERROR_LOCK_VIOLATION; } for (i = 0; i < table->dwNumEntries; i++) { USHORT sPort; sPort = ntohs((USHORT)table->table[i].dwLocalPort); table->table[i].dwLocalPort = (DWORD)sPort; sPort = ntohs((USHORT)table->table[i].dwRemotePort); table->table[i].dwRemotePort = (DWORD)sPort; } memcpy(pResponseInfo, table->table, sizeof(MIB_TCPROW) * table->dwNumEntries); /* calculate the length of the data in the output buffer */ *pcbResponseInfoLen = sizeof(MIB_TCPROW) * table->dwNumEntries; HeapFree( GetProcessHeap(), 0, table ); } break; default: { FIXME ("Command ID Not Supported -> toi_id=0x%lx, toi_entity={tei_entity=0x%lx, tei_instance=0x%lx}, toi_class=0x%lx\n", pcommand->toi_id, pcommand->toi_entity.tei_entity, pcommand->toi_entity.tei_instance, pcommand->toi_class); return (ERROR_BAD_ENVIRONMENT); } } } break; default: { FIXME ("Command ID Not Supported -> toi_id=0x%lx, toi_entity={tei_entity=0x%lx, tei_instance=0x%lx}, toi_class=0x%lx\n", pcommand->toi_id, pcommand->toi_entity.tei_entity, pcommand->toi_entity.tei_instance, pcommand->toi_class); return (ERROR_BAD_ENVIRONMENT); } } break; } case WSCNTL_TCPIP_ICMP_ECHO: { unsigned int addr = *(unsigned int*)pRequestInfo; #if 0 int timeout= *(unsigned int*)(inbuf+4); short x1 = *(unsigned short*)(inbuf+8); short sendbufsize = *(unsigned short*)(inbuf+10); char x2 = *(unsigned char*)(inbuf+12); char ttl = *(unsigned char*)(inbuf+13); char service = *(unsigned char*)(inbuf+14); char type= *(unsigned char*)(inbuf+15); /* 0x2: don't fragment*/ #endif FIXME("(ICMP_ECHO) to 0x%08x stub\n", addr); break; } default: FIXME("Protocol Not Supported -> protocol=0x%x, action=0x%x, Request=%p, RequestLen=%p, Response=%p, ResponseLen=%p\n", protocol, action, pRequestInfo, pcbRequestInfoLen, pResponseInfo, pcbResponseInfoLen); return (WSAEOPNOTSUPP); } return (WSCTL_SUCCESS); }
static void mib2IpStatsInit(void) { GetIpStatistics(&ipStats); }
int exec_iphelp_api_sample() { /* Some general variables */ ULONG ulOutBufLen; DWORD dwRetVal; unsigned int i; /* variables used for GetNetworkParams */ FIXED_INFO *pFixedInfo; IP_ADDR_STRING *pIPAddr; /* variables used for GetAdapterInfo */ IP_ADAPTER_INFO *pAdapterInfo; IP_ADAPTER_INFO *pAdapter; /* variables used to print DHCP time info */ struct tm newtime; char buffer[32]; errno_t error; /* variables used for GetInterfaceInfo */ IP_INTERFACE_INFO *pInterfaceInfo; /* variables used for GetIpAddrTable */ MIB_IPADDRTABLE *pIPAddrTable; DWORD dwSize; IN_ADDR IPAddr; //char *strIPAddr; char addr[16] = { 0 }; std::string ip_str; /* variables used for AddIpAddress */ // UINT iaIPAddress; // UINT imIPMask; // ULONG NTEContext; // ULONG NTEInstance; /* variables used for GetIpStatistics */ MIB_IPSTATS *pStats; /* variables used for GetTcpStatistics */ MIB_TCPSTATS *pTCPStats; printf("------------------------\n"); printf("This is GetNetworkParams\n"); printf("------------------------\n"); pFixedInfo = (FIXED_INFO *) MALLOC(sizeof (FIXED_INFO)); if (pFixedInfo == NULL) { printf("Error allocating memory needed to call GetNetworkParams\n"); return 1; } ulOutBufLen = sizeof (FIXED_INFO); if (GetNetworkParams(pFixedInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) { FREE(pFixedInfo); pFixedInfo = (FIXED_INFO *) MALLOC(ulOutBufLen); if (pFixedInfo == NULL) { printf("Error allocating memory needed to call GetNetworkParams\n"); return 1; } } dwRetVal = GetNetworkParams(pFixedInfo, &ulOutBufLen); if (dwRetVal != NO_ERROR) { printf("GetNetworkParams failed with error %d\n", dwRetVal); if (pFixedInfo) FREE(pFixedInfo); return 1; } else { printf("\tHost Name: %s\n", pFixedInfo->HostName); printf("\tDomain Name: %s\n", pFixedInfo->DomainName); printf("\tDNS Servers:\n"); printf("\t\t%s\n", pFixedInfo->DnsServerList.IpAddress.String); pIPAddr = pFixedInfo->DnsServerList.Next; while (pIPAddr) { printf("\t\t%s\n", pIPAddr->IpAddress.String); pIPAddr = pIPAddr->Next; } printf("\tNode Type: "); switch (pFixedInfo->NodeType) { case 1: printf("%s\n", "Broadcast"); break; case 2: printf("%s\n", "Peer to peer"); break; case 4: printf("%s\n", "Mixed"); break; case 8: printf("%s\n", "Hybrid"); break; default: printf("\n"); } printf("\tNetBIOS Scope ID: %s\n", pFixedInfo->ScopeId); if (pFixedInfo->EnableRouting) printf("\tIP Routing Enabled: Yes\n"); else printf("\tIP Routing Enabled: No\n"); if (pFixedInfo->EnableProxy) printf("\tWINS Proxy Enabled: Yes\n"); else printf("\tWINS Proxy Enabled: No\n"); if (pFixedInfo->EnableDns) printf("\tNetBIOS Resolution Uses DNS: Yes\n"); else printf("\tNetBIOS Resolution Uses DNS: No\n"); } /* Free allocated memory no longer needed */ if (pFixedInfo) { FREE(pFixedInfo); pFixedInfo = NULL; } printf("------------------------\n"); printf("This is GetAdaptersInfo\n"); printf("------------------------\n"); pAdapterInfo = (IP_ADAPTER_INFO *) MALLOC(sizeof (IP_ADAPTER_INFO)); if (pAdapterInfo == NULL) { printf("Error allocating memory needed to call GetAdapterInfo\n"); return 1; } ulOutBufLen = sizeof (IP_ADAPTER_INFO); if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) { FREE(pAdapterInfo); pAdapterInfo = (IP_ADAPTER_INFO *) MALLOC(ulOutBufLen); if (pAdapterInfo == NULL) { printf("Error allocating memory needed to call GetAdapterInfo\n"); return 1; } } if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) != NO_ERROR) { printf("GetAdaptersInfo failed with error %d\n", dwRetVal); if (pAdapterInfo) FREE(pAdapterInfo); return 1; } pAdapter = pAdapterInfo; while (pAdapter) { printf("\tAdapter Name: \t%s\n", pAdapter->AdapterName); printf("\tAdapter Desc: \t%s\n", pAdapter->Description); printf("\tAdapter Addr: \t"); for (i = 0; i < (int) pAdapter->AddressLength; i++) { if (i == (pAdapter->AddressLength - 1)) printf("%.2X\n", (int) pAdapter->Address[i]); else printf("%.2X-", (int) pAdapter->Address[i]); } printf("\tIP Address: \t%s\n", pAdapter->IpAddressList.IpAddress.String); printf("\tIP Mask: \t%s\n", pAdapter->IpAddressList.IpMask.String); printf("\tGateway: \t%s\n", pAdapter->GatewayList.IpAddress.String); printf("\t***\n"); if (pAdapter->DhcpEnabled) { printf("\tDHCP Enabled: \tYes\n"); printf("\tDHCP Server: \t%s\n", pAdapter->DhcpServer.IpAddress.String); printf("\tLease Obtained: "); /* Display local time */ error = _localtime32_s(&newtime, (__time32_t*) &pAdapter->LeaseObtained); if (error) printf("\tInvalid Argument to _localtime32_s\n"); else { // Convert to an ASCII representation error = asctime_s(buffer, 32, &newtime); if (error) printf("Invalid Argument to asctime_s\n"); else /* asctime_s returns the string terminated by \n\0 */ printf("%s", buffer); } printf("\tLease Expires: "); error = _localtime32_s(&newtime, (__time32_t*) &pAdapter->LeaseExpires); if (error) printf("Invalid Argument to _localtime32_s\n"); else { // Convert to an ASCII representation error = asctime_s(buffer, 32, &newtime); if (error) printf("Invalid Argument to asctime_s\n"); else /* asctime_s returns the string terminated by \n\0 */ printf("%s", buffer); } } else printf("\tDHCP Enabled: \tNo\n"); if (pAdapter->HaveWins) { printf("\tHave Wins: \tYes\n"); printf("\tPrimary Wins Server: \t%s\n", pAdapter->PrimaryWinsServer.IpAddress.String); printf("\tSecondary Wins Server: \t%s\n", pAdapter->SecondaryWinsServer.IpAddress.String); } else printf("\tHave Wins: \tNo\n"); printf("\n"); pAdapter = pAdapter->Next; } printf("------------------------\n"); printf("This is GetInterfaceInfo\n"); printf("------------------------\n"); pInterfaceInfo = (IP_INTERFACE_INFO *) MALLOC(sizeof (IP_INTERFACE_INFO)); if (pInterfaceInfo == NULL) { printf("Error allocating memory needed to call GetInterfaceInfo\n"); return 1; } ulOutBufLen = sizeof (IP_INTERFACE_INFO); if (GetInterfaceInfo(pInterfaceInfo, &ulOutBufLen) == ERROR_INSUFFICIENT_BUFFER) { FREE(pInterfaceInfo); pInterfaceInfo = (IP_INTERFACE_INFO *) MALLOC(ulOutBufLen); if (pInterfaceInfo == NULL) { printf("Error allocating memory needed to call GetInterfaceInfo\n"); return 1; } printf("\t The size needed for the output buffer ulLen = %ld\n", ulOutBufLen); } if ((dwRetVal = GetInterfaceInfo(pInterfaceInfo, &ulOutBufLen)) == NO_ERROR) { printf("\tNum Adapters: %ld\n\n", pInterfaceInfo->NumAdapters); for (i = 0; i < (unsigned int) pInterfaceInfo->NumAdapters; i++) { printf("\tAdapter Index[%d]: %ld\n", i, pInterfaceInfo->Adapter[i].Index); printf("\tAdapter Name[%d]: %ws\n\n", i, pInterfaceInfo->Adapter[i].Name); } printf("GetInterfaceInfo call succeeded.\n"); } else { LPVOID lpMsgBuf = NULL; if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwRetVal, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) & lpMsgBuf, 0, NULL)) { printf("\tError: %s", (char*)lpMsgBuf); } LocalFree(lpMsgBuf); } ///* If DHCP enabled, release and renew the IP address */ ///* THIS WORKS BUT IT TAKES A LONG TIME AND INTERRUPTS NET CONNECTIONS */ //if (pAdapterInfo->DhcpEnabled && pInterfaceInfo->NumAdapters) { // printf("Calling IpReleaseAddress for Adapter[%d]\n", 0); // if ((dwRetVal = // IpReleaseAddress(&pInterfaceInfo->Adapter[0])) == NO_ERROR) { // printf("Ip Release succeeded.\n"); // } // if ((dwRetVal = // IpRenewAddress(&pInterfaceInfo->Adapter[0])) == NO_ERROR) { // printf("Ip Renew succeeded.\n"); // } //} /* Free allocated memory no longer needed */ if (pAdapterInfo) { FREE(pAdapterInfo); pAdapterInfo = NULL; } if (pInterfaceInfo) { FREE(pInterfaceInfo); pInterfaceInfo = NULL; } printf("----------------------\n"); printf("This is GetIpAddrTable\n"); printf("----------------------\n"); pIPAddrTable = (MIB_IPADDRTABLE *) MALLOC(sizeof (MIB_IPADDRTABLE)); if (pIPAddrTable == NULL) { printf("Error allocating memory needed to call GetIpAddrTable\n"); return 1; } dwSize = 0; IPAddr.S_un.S_addr = ntohl(pIPAddrTable->table[1].dwAddr); ip_str = InetNtopA(AF_INET, (PVOID)&IPAddr, addr, 16); if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) { FREE(pIPAddrTable); pIPAddrTable = (MIB_IPADDRTABLE *) MALLOC(dwSize); if (pIPAddrTable == NULL) { printf("Error allocating memory needed to call GetIpAddrTable\n"); return 1; } } if ((dwRetVal = GetIpAddrTable(pIPAddrTable, &dwSize, 0)) != NO_ERROR) { printf("GetIpAddrTable failed with error %d\n", dwRetVal); if (pIPAddrTable) FREE(pIPAddrTable); return 1; } printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries); for (i = 0; i < (unsigned int) pIPAddrTable->dwNumEntries; i++) { printf("\n\tInterface Index[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwIndex); IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr; printf("\tIP Address[%d]: \t%s\n", i, InetNtopA(AF_INET, (PVOID)&IPAddr, addr, 16)); IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask; printf("\tSubnet Mask[%d]: \t%s\n", i, InetNtopA(AF_INET, (PVOID)&IPAddr, addr, 16)); IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr; printf("\tBroadCast[%d]: \t%s (%ld)\n", i, InetNtopA(AF_INET, (PVOID)&IPAddr, addr, 16), pIPAddrTable->table[i].dwBCastAddr); printf("\tReassembly size[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwReasmSize); printf("\tAddress Index[%d]: \t%ld\n", i, pIPAddrTable->table[i].dwIndex); printf("\tType and State[%d]:", i); if (pIPAddrTable->table[i].wType & MIB_IPADDR_PRIMARY) printf("\tPrimary IP Address"); if (pIPAddrTable->table[i].wType & MIB_IPADDR_DYNAMIC) printf("\tDynamic IP Address"); if (pIPAddrTable->table[i].wType & MIB_IPADDR_DISCONNECTED) printf("\tAddress is on disconnected interface"); if (pIPAddrTable->table[i].wType & MIB_IPADDR_DELETED) printf("\tAddress is being deleted"); if (pIPAddrTable->table[i].wType & MIB_IPADDR_TRANSIENT) printf("\tTransient address"); printf("\n"); } //iaIPAddress = inet_addr("192.168.0.27"); //imIPMask = inet_addr("255.255.255.0"); //NTEContext = 0; //NTEInstance = 0; //if ((dwRetVal = AddIPAddress(iaIPAddress, // imIPMask, // pIPAddrTable->table[0]. // dwIndex, // &NTEContext, &NTEInstance)) != NO_ERROR) { // LPVOID lpMsgBuf; // printf("\tError adding IP address.\n"); // if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwRetVal, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language // (LPTSTR) & lpMsgBuf, 0, NULL)) { // printf("\tError: %s", (char*)lpMsgBuf); // } // LocalFree(lpMsgBuf); //} //if ((dwRetVal = DeleteIPAddress(NTEContext)) != NO_ERROR) { // printf("DeleteIPAddress failed with error %d\n", dwRetVal); //} /* Free allocated memory no longer needed */ if (pIPAddrTable) { FREE(pIPAddrTable); pIPAddrTable = NULL; } printf("-------------------------\n"); printf("This is GetIPStatistics()\n"); printf("-------------------------\n"); pStats = (MIB_IPSTATS *) MALLOC(sizeof (MIB_IPSTATS)); if (pStats == NULL) { printf("Error allocating memory needed to call GetIpStatistics\n"); return 1; } if ((dwRetVal = GetIpStatistics(pStats)) != NO_ERROR) { printf("GetIPStatistics failed with error %d\n", dwRetVal); if (pStats) FREE(pStats); return 1; } printf("\tNumber of IP addresses: %ld\n", pStats->dwNumAddr); printf("\tNumber of Interfaces: %ld\n", pStats->dwNumIf); printf("\tReceives: %ld\n", pStats->dwInReceives); printf("\tOut Requests: %ld\n", pStats->dwOutRequests); printf("\tRoutes: %ld\n", pStats->dwNumRoutes); printf("\tTimeout Time: %ld\n", pStats->dwReasmTimeout); printf("\tIn Delivers: %ld\n", pStats->dwInDelivers); printf("\tIn Discards: %ld\n", pStats->dwInDiscards); printf("\tTotal In: %ld\n", pStats->dwInDelivers + pStats->dwInDiscards); printf("\tIn Header Errors: %ld\n", pStats->dwInHdrErrors); /* Free allocated memory no longer needed */ if (pStats) { FREE(pStats); pStats = NULL; } printf("-------------------------\n"); printf("This is GetTCPStatistics()\n"); printf("-------------------------\n"); pTCPStats = (MIB_TCPSTATS *) MALLOC(sizeof (MIB_TCPSTATS)); if (pTCPStats == NULL) { printf("Error allocating memory needed to call GetTcpStatistics\n"); return 1; } if ((dwRetVal = GetTcpStatistics(pTCPStats)) != NO_ERROR) { printf("GetTcpStatistics failed with error %d\n", dwRetVal); if (pTCPStats) FREE(pTCPStats); return 1; } printf("\tActive Opens: %ld\n", pTCPStats->dwActiveOpens); printf("\tPassive Opens: %ld\n", pTCPStats->dwPassiveOpens); printf("\tSegments Recv: %ld\n", pTCPStats->dwInSegs); printf("\tSegments Xmit: %ld\n", pTCPStats->dwOutSegs); printf("\tTotal # Conxs: %ld\n", pTCPStats->dwNumConns); /* Free allocated memory no longer needed */ if (pTCPStats) { FREE(pTCPStats); pTCPStats = NULL; } return 0; }
DWORD MyGetIpStatistics(PMIB_IPSTATS& pIpStats) { pIpStats = (PMIB_IPSTATS)malloc(sizeof(MIB_IPSTATS)); assert(pIpStats != NULL); return GetIpStatistics(pIpStats); }
long read_ip_stat(IP_STAT_STRUCTURE * ipstat, int magic) { long ret_value = 0; #if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS)) int i; #endif #if !(defined (linux) || defined(solaris2)) static int ttl, forward; #endif #ifdef hpux11 int fd; struct nmparms p; unsigned int ulen; #endif #if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS)) static int sname[4] = { CTL_NET, PF_INET, IPPROTO_IP, 0 }; size_t len; #endif #ifdef hpux11 if ((fd = open_mib("/dev/ip", O_RDONLY, 0, NM_ASYNC_OFF)) < 0) return (-1); /* error */ switch (magic) { case IPFORWARDING: p.objid = ID_ipForwarding; break; case IPDEFAULTTTL: p.objid = ID_ipDefaultTTL; break; case IPINRECEIVES: p.objid = ID_ipInReceives; break; case IPINHDRERRORS: p.objid = ID_ipInHdrErrors; break; case IPINADDRERRORS: p.objid = ID_ipInAddrErrors; break; case IPFORWDATAGRAMS: p.objid = ID_ipForwDatagrams; break; case IPINUNKNOWNPROTOS: p.objid = ID_ipInUnknownProtos; break; case IPINDISCARDS: p.objid = ID_ipInDiscards; break; case IPINDELIVERS: p.objid = ID_ipInDelivers; break; case IPOUTREQUESTS: p.objid = ID_ipOutRequests; break; case IPOUTDISCARDS: p.objid = ID_ipOutDiscards; break; case IPOUTNOROUTES: p.objid = ID_ipOutNoRoutes; break; case IPREASMTIMEOUT: p.objid = ID_ipReasmTimeout; break; case IPREASMREQDS: p.objid = ID_ipReasmReqds; break; case IPREASMOKS: p.objid = ID_ipReasmOKs; break; case IPREASMFAILS: p.objid = ID_ipReasmFails; break; case IPFRAGOKS: p.objid = ID_ipFragOKs; break; case IPFRAGFAILS: p.objid = ID_ipFragFails; break; case IPFRAGCREATES: p.objid = ID_ipFragCreates; break; case IPROUTEDISCARDS: p.objid = ID_ipRoutingDiscards; break; default: *ipstat = 0; close_mib(fd); return (0); } p.buffer = (void *) ipstat; ulen = sizeof(IP_STAT_STRUCTURE); p.len = &ulen; ret_value = get_mib_info(fd, &p); close_mib(fd); return (ret_value); /* 0: ok, < 0: error */ #else /* hpux11 */ if (ip_stats_cache_marker && (!atime_ready (ip_stats_cache_marker, IP_STATS_CACHE_TIMEOUT * 1000))) #if !(defined(linux) || defined(solaris2)) return ((magic == IPFORWARDING ? forward : (magic == IPDEFAULTTTL ? ttl : 0))); #else return 0; #endif if (ip_stats_cache_marker) atime_setMarker(ip_stats_cache_marker); else ip_stats_cache_marker = atime_newMarker(); #ifdef linux ret_value = linux_read_ip_stat(ipstat); #endif #ifdef solaris2 ret_value = getMibstat(MIB_IP, ipstat, sizeof(mib2_ip_t), GET_FIRST, &Get_everything, NULL); #endif #ifdef WIN32 ret_value = GetIpStatistics(ipstat); #endif #if !(defined(linux) || defined(solaris2) || defined(WIN32)) if (magic == IPFORWARDING) { #if defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS) len = sizeof i; sname[3] = IPCTL_FORWARDING; if (sysctl(sname, 4, &i, &len, 0, 0) < 0) forward = -1; else forward = (i ? 1 /* GATEWAY */ : 2 /* HOST */ ); #else if (!auto_nlist (IP_FORWARDING_SYMBOL, (char *) &ret_value, sizeof(ret_value))) forward = -1; else forward = (ret_value ? 1 /* GATEWAY */ : 2 /* HOST */ ); #endif if (forward == -1) { free(ip_stats_cache_marker); ip_stats_cache_marker = NULL; } return forward; } if (magic == IPDEFAULTTTL) { #if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS)) len = sizeof i; sname[3] = IPCTL_DEFTTL; if (sysctl(sname, 4, &i, &len, 0, 0) < 0) ttl = -1; else ttl = i; #else if (!auto_nlist (TCP_TTL_SYMBOL, (char *) &ret_value, sizeof(ret_value))) ttl = -1; else ttl = ret_value; #endif if (ttl == -1) { free(ip_stats_cache_marker); ip_stats_cache_marker = NULL; } return ttl; } #ifdef HAVE_SYS_TCPIPSTATS_H ret_value = sysmp(MP_SAGET, MPSA_TCPIPSTATS, ipstat, sizeof *ipstat); #endif #if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS)) len = sizeof *ipstat; sname[3] = IPCTL_STATS; ret_value = sysctl(sname, 4, ipstat, &len, 0, 0); #endif #ifdef IPSTAT_SYMBOL if (auto_nlist(IPSTAT_SYMBOL, (char *) ipstat, sizeof(*ipstat))) ret_value = 0; #endif #endif /* !(defined(linux) || defined(solaris2)) */ if (ret_value == -1) { free(ip_stats_cache_marker); ip_stats_cache_marker = NULL; } return ret_value; #endif /* hpux11 */ }