* command line parser needs more work
*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <wchar.h>
+
#define WIN32_NO_STATUS
-#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#define _INC_WINDOWS
#include <winsock2.h>
-#include <wchar.h>
-#include <stdio.h>
-#include <stdlib.h>
#include <iphlpapi.h>
#include <conutils.h>
else
{
ConResPuts(StdOut, IDS_USAGE);
- return EXIT_FAILURE;
+ return FALSE;
}
break;
case L'r':
break;
default :
ConResPuts(StdOut, IDS_USAGE);
- return EXIT_FAILURE;
+ return FALSE;
}
}
}
if (swscanf(argv[i], L"%lu", &Interval) != EOF)
bLoopOutput = TRUE;
else
- return EXIT_FAILURE;
+ return FALSE;
}
// else
// {
// ConResPrintf(StdOut, IDS_USAGE);
-// return EXIT_FAILURE;
+// return FALSE;
// }
}
- return EXIT_SUCCESS;
+ return TRUE;
}
/*
if (bNoOptions)
{
DisplayTableHeader();
- ShowTcpTable();
- return EXIT_SUCCESS;
+ return ShowTcpTable();
}
if (bDoShowRouteTable)
{
- /* mingw doesn't have lib for _tsystem */
- if (system("route print") == -1)
+ if (_wsystem(L"route print") == -1)
{
ConResPuts(StdErr, IDS_ERROR_ROUTE);
- return EXIT_FAILURE;
+ return FALSE;
}
- return EXIT_SUCCESS;
+ return TRUE;
}
if (bDoShowEthStats)
{
ShowEthernetStatistics();
- return EXIT_SUCCESS;
+ return TRUE;
}
if (bDoShowProtoCons)
{
switch (Protocol)
{
- case IP:
- if (bDoShowProtoStats)
- {
- ShowIpStatistics();
- return EXIT_SUCCESS;
- }
- break;
- case ICMP:
- if (bDoShowProtoStats)
- {
- ShowIcmpStatistics();
- return EXIT_SUCCESS;
- }
- break;
- case TCP:
- if (bDoShowProtoStats)
- ShowTcpStatistics();
- ConResPuts(StdOut, IDS_ACTIVE_CONNECT);
- DisplayTableHeader();
- ShowTcpTable();
- break;
- case UDP:
- if (bDoShowProtoStats)
- ShowUdpStatistics();
- ConResPuts(StdOut, IDS_ACTIVE_CONNECT);
- DisplayTableHeader();
- ShowUdpTable();
- break;
- default :
- break;
+ case IP:
+ if (bDoShowProtoStats)
+ ShowIpStatistics();
+ return TRUE;
+ case ICMP:
+ if (bDoShowProtoStats)
+ ShowIcmpStatistics();
+ return TRUE;
+ case TCP:
+ if (bDoShowProtoStats)
+ ShowTcpStatistics();
+ ConResPuts(StdOut, IDS_ACTIVE_CONNECT);
+ DisplayTableHeader();
+ return ShowTcpTable();
+ case UDP:
+ if (bDoShowProtoStats)
+ ShowUdpStatistics();
+ ConResPuts(StdOut, IDS_ACTIVE_CONNECT);
+ DisplayTableHeader();
+ return ShowUdpTable();
+ default:
+ break;
}
}
else if (bDoShowProtoStats)
ShowIcmpStatistics();
ShowTcpStatistics();
ShowUdpStatistics();
- return EXIT_SUCCESS;
+ return TRUE;
}
else
{
ConResPuts(StdOut, IDS_ACTIVE_CONNECT);
DisplayTableHeader();
- ShowTcpTable();
- if (bDoShowAllCons)
+ if (ShowTcpTable() && bDoShowAllCons)
ShowUdpTable();
}
- return EXIT_SUCCESS;
+
+ return TRUE;
}
VOID ShowIpStatistics(VOID)
VOID ShowTcpStatistics(VOID)
{
- PMIB_TCPSTATS pTcpStats;
+ MIB_TCPSTATS tcpStats;
DWORD dwRetVal;
- pTcpStats = (MIB_TCPSTATS*) HeapAlloc(GetProcessHeap(), 0, sizeof(MIB_TCPSTATS));
-
- if ((dwRetVal = GetTcpStatistics(pTcpStats)) == NO_ERROR)
+ if ((dwRetVal = GetTcpStatistics(&tcpStats)) == NO_ERROR)
{
ConResPuts(StdOut, IDS_TCP4_HEADER);
- ConResPrintf(StdOut, IDS_TCP_ACTIVE_OPEN, pTcpStats->dwActiveOpens);
- ConResPrintf(StdOut, IDS_TCP_PASS_OPEN, pTcpStats->dwPassiveOpens);
- ConResPrintf(StdOut, IDS_TCP_FAIL_CONNECT, pTcpStats->dwAttemptFails);
- ConResPrintf(StdOut, IDS_TCP_RESET_CONNECT, pTcpStats->dwEstabResets);
- ConResPrintf(StdOut, IDS_TCP_CURRENT_CONNECT, pTcpStats->dwCurrEstab);
- ConResPrintf(StdOut, IDS_TCP_SEG_RECEIVE, pTcpStats->dwInSegs);
- ConResPrintf(StdOut, IDS_TCP_SEG_SENT, pTcpStats->dwOutSegs);
- ConResPrintf(StdOut, IDS_TCP_SEG_RETRANSMIT, pTcpStats->dwRetransSegs);
+ ConResPrintf(StdOut, IDS_TCP_ACTIVE_OPEN, tcpStats.dwActiveOpens);
+ ConResPrintf(StdOut, IDS_TCP_PASS_OPEN, tcpStats.dwPassiveOpens);
+ ConResPrintf(StdOut, IDS_TCP_FAIL_CONNECT, tcpStats.dwAttemptFails);
+ ConResPrintf(StdOut, IDS_TCP_RESET_CONNECT, tcpStats.dwEstabResets);
+ ConResPrintf(StdOut, IDS_TCP_CURRENT_CONNECT, tcpStats.dwCurrEstab);
+ ConResPrintf(StdOut, IDS_TCP_SEG_RECEIVE, tcpStats.dwInSegs);
+ ConResPrintf(StdOut, IDS_TCP_SEG_SENT, tcpStats.dwOutSegs);
+ ConResPrintf(StdOut, IDS_TCP_SEG_RETRANSMIT, tcpStats.dwRetransSegs);
}
else
{
DoFormatMessage(dwRetVal);
}
-
- HeapFree(GetProcessHeap(), 0, pTcpStats);
}
VOID ShowUdpStatistics(VOID)
{
- PMIB_UDPSTATS pUdpStats;
+ MIB_UDPSTATS udpStats;
DWORD dwRetVal;
- pUdpStats = (MIB_UDPSTATS*) HeapAlloc(GetProcessHeap(), 0, sizeof(MIB_UDPSTATS));
-
- if ((dwRetVal = GetUdpStatistics(pUdpStats)) == NO_ERROR)
+ if ((dwRetVal = GetUdpStatistics(&udpStats)) == NO_ERROR)
{
ConResPuts(StdOut, IDS_UDP_IP4_HEADER);
- ConResPrintf(StdOut, IDS_UDP_DATAG_RECEIVE, pUdpStats->dwInDatagrams);
- ConResPrintf(StdOut, IDS_UDP_NO_PORT, pUdpStats->dwNoPorts);
- ConResPrintf(StdOut, IDS_UDP_RECEIVE_ERROR, pUdpStats->dwInErrors);
- ConResPrintf(StdOut, IDS_UDP_DATAG_SEND, pUdpStats->dwOutDatagrams);
+ ConResPrintf(StdOut, IDS_UDP_DATAG_RECEIVE, udpStats.dwInDatagrams);
+ ConResPrintf(StdOut, IDS_UDP_NO_PORT, udpStats.dwNoPorts);
+ ConResPrintf(StdOut, IDS_UDP_RECEIVE_ERROR, udpStats.dwInErrors);
+ ConResPrintf(StdOut, IDS_UDP_DATAG_SEND, udpStats.dwOutDatagrams);
}
else
{
DoFormatMessage(dwRetVal);
}
-
- HeapFree(GetProcessHeap(), 0, pUdpStats);
}
VOID ShowEthernetStatistics(VOID)
HeapFree(GetProcessHeap(), 0, pIfTable);
}
-VOID ShowTcpTable(VOID)
+BOOL ShowTcpTable(VOID)
{
PMIB_TCPTABLE_OWNER_PID tcpTable;
DWORD error, dwSize;
{
ConResPrintf(StdErr, IDS_ERROR_TCP_SNAPSHOT);
DoFormatMessage(error);
- exit(EXIT_FAILURE);
+ HeapFree(GetProcessHeap(), 0, tcpTable);
+ return FALSE;
}
/* Dump the TCP table */
|| (tcpTable->table[i].dwState == MIB_TCP_STATE_TIME_WAIT))
{
/* I've split this up so it's easier to follow */
- GetIpHostName(TRUE, tcpTable->table[i].dwLocalAddr, HostIp, HOSTNAMELEN);
- GetPortName(tcpTable->table[i].dwLocalPort, "tcp", HostPort, PORTNAMELEN);
+ GetIpHostName(TRUE, tcpTable->table[i].dwLocalAddr, HostIp, sizeof(HostIp));
+ GetPortName(tcpTable->table[i].dwLocalPort, "tcp", HostPort, sizeof(HostPort));
sprintf(Host, "%s:%s", HostIp, HostPort);
if (tcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
}
else
{
- GetIpHostName(FALSE, tcpTable->table[i].dwRemoteAddr, RemoteIp, HOSTNAMELEN);
- GetPortName(tcpTable->table[i].dwRemotePort, "tcp", RemotePort, PORTNAMELEN);
+ GetIpHostName(FALSE, tcpTable->table[i].dwRemoteAddr, RemoteIp, sizeof(RemoteIp));
+ GetPortName(tcpTable->table[i].dwRemotePort, "tcp", RemotePort, sizeof(RemotePort));
sprintf(Remote, "%s:%s", RemoteIp, RemotePort);
}
Host, Remote, TcpState[tcpTable->table[i].dwState], PID);
}
}
+
HeapFree(GetProcessHeap(), 0, tcpTable);
+ return TRUE;
}
-VOID ShowUdpTable(VOID)
+BOOL ShowUdpTable(VOID)
{
PMIB_UDPTABLE_OWNER_PID udpTable;
DWORD error, dwSize;
{
ConResPuts(StdErr, IDS_ERROR_UDP_ENDPOINT);
DoFormatMessage(error);
- exit(EXIT_FAILURE);
+ return FALSE;
}
udpTable = (PMIB_UDPTABLE_OWNER_PID) HeapAlloc(GetProcessHeap(), 0, dwSize);
error = GetExtendedUdpTable(udpTable, &dwSize, TRUE, AF_INET, UDP_TABLE_OWNER_PID, 0);
ConResPuts(StdErr, IDS_ERROR_UDP_ENDPOINT_TABLE);
DoFormatMessage(error);
HeapFree(GetProcessHeap(), 0, udpTable);
- exit(EXIT_FAILURE);
+ return FALSE;
}
/* Dump the UDP table */
{
/* I've split this up so it's easier to follow */
- GetIpHostName(TRUE, udpTable->table[i].dwLocalAddr, HostIp, HOSTNAMELEN);
- GetPortName(udpTable->table[i].dwLocalPort, "tcp", HostPort, PORTNAMELEN);
+ GetIpHostName(TRUE, udpTable->table[i].dwLocalAddr, HostIp, sizeof(HostIp));
+ GetPortName(udpTable->table[i].dwLocalPort, "tcp", HostPort, sizeof(HostPort));
sprintf(Host, "%s:%s", HostIp, HostPort);
}
HeapFree(GetProcessHeap(), 0, udpTable);
+ return TRUE;
}
/*
* convert addresses into dotted decimal or hostname
*/
PCHAR
-GetIpHostName(BOOL Local, UINT IpAddr, CHAR Name[], int NameLen)
+GetIpHostName(BOOL Local, UINT IpAddr, CHAR Name[], INT NameLen)
{
// struct hostent *phostent;
UINT nIpAddr;
*/
int wmain(int argc, wchar_t *argv[])
{
+ BOOL Success;
WSADATA wsaData;
/* Initialize the Console Standard Streams */
ConInitStdStreams();
+ if (!ParseCmdline(argc, argv))
+ return EXIT_FAILURE;
+
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
ConResPrintf(StdErr, IDS_ERROR_WSA_START, WSAGetLastError());
- return -1;
+ return EXIT_FAILURE;
}
- if (ParseCmdline(argc, argv))
- return -1;
-
- if (bLoopOutput)
+ Success = DisplayOutput();
+ while (bLoopOutput && Success)
{
- while (1)
- {
- if (DisplayOutput())
- return -1;
- Sleep(Interval*1000);
- }
+ Sleep(Interval*1000);
+ Success = DisplayOutput();
}
- if (DisplayOutput())
- return -1;
- else
- return 0;
+ WSACleanup();
+ return (Success ? EXIT_SUCCESS : EXIT_FAILURE);
}
projects / reactos.git / blobdiff