1 /*
2  * COPYRIGHT:   See COPYING in the top level directory
3  * PROJECT:     ReactOS ping utility
4  * FILE:        applications/cmdutils/arping/arping.c
5  * PURPOSE:     Network test utility
6  * PROGRAMMERS: Pierre Schweitzer <pierre@reactos.org>
7  */
8 
9 #define WIN32_NO_STATUS
10 #include <stdarg.h>
11 #include <windef.h>
12 #include <winbase.h>
13 #include <winuser.h>
14 #include <winnls.h>
15 #include <wincon.h>
16 #define _INC_WINDOWS
17 #include <ws2tcpip.h>
18 #include <iphlpapi.h>
19 #include <ws2def.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 
23 #include "resource.h"
24 
25 BOOL                NeverStop;
26 UINT                PingCount;
27 WCHAR               TargetName[256];
28 WCHAR               SourceName[256];
29 DWORD               SourceAddr;
30 DWORD               TargetAddr;
31 WCHAR               TargetIP[16];
32 WCHAR               SourceIP[16];
33 SOCKADDR_IN         Target;
34 HANDLE              hStdOutput;
35 ULONG               Timeout;
36 LARGE_INTEGER       TicksPerMs;
37 LARGE_INTEGER       TicksPerUs;
38 BOOL                UsePerformanceCounter;
39 UINT                Sent;
40 UINT                Received;
41 
42 void FormatOutput(UINT uID, ...)
43 {
44     va_list valist;
45 
46     WCHAR Buf[1024];
47     CHAR AnsiBuf[1024];
48     LPWSTR pBuf = Buf;
49     PCHAR pAnsiBuf = AnsiBuf;
50     WCHAR Format[1024];
51     DWORD written;
52     UINT DataLength;
53     int AnsiLength;
54 
55     if (!LoadString(GetModuleHandle(NULL), uID,
56                     Format, sizeof(Format) / sizeof(WCHAR)))
57     {
58         return;
59     }
60 
61     va_start(valist, uID);
62     DataLength = FormatMessage(FORMAT_MESSAGE_FROM_STRING, Format, 0, 0, Buf,\
63                                sizeof(Buf) / sizeof(WCHAR), &valist);
64     va_end(valist);
65 
66     if(!DataLength)
67     {
68         if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
69         {
70             return;
71         }
72 
73         va_start(valist, uID);
74         DataLength = FormatMessage(FORMAT_MESSAGE_FROM_STRING |\
75                                     FORMAT_MESSAGE_ALLOCATE_BUFFER,\
76                                    Format, 0, 0, (LPWSTR)&pBuf, 0, &valist);
77         va_end(valist);
78     }
79 
80     if(!DataLength)
81     {
82         return;
83     }
84 
85     if(GetFileType(hStdOutput) == FILE_TYPE_CHAR)
86     {
87         /* Is a console or a printer */
88         WriteConsole(hStdOutput, pBuf, DataLength, &written, NULL);
89     }
90     else
91     {
92         /* Is a pipe, socket, file or other */
93         AnsiLength = WideCharToMultiByte(CP_ACP, 0, pBuf, DataLength,\
94                                          NULL, 0, NULL, NULL);
95 
96         if(AnsiLength >= sizeof(AnsiBuf))
97             pAnsiBuf = (PCHAR)HeapAlloc(GetProcessHeap(), 0, AnsiLength);
98 
99         AnsiLength = WideCharToMultiByte(CP_OEMCP, 0, pBuf, DataLength,\
100                                          pAnsiBuf, AnsiLength, " ", NULL);
101 
102         WriteFile(hStdOutput, pAnsiBuf, AnsiLength, &written, NULL);
103 
104         if(pAnsiBuf != AnsiBuf)
105             HeapFree(NULL, 0, pAnsiBuf);
106     }
107 
108     if(pBuf != Buf)
109         LocalFree(pBuf);
110 }
111 
112 static VOID Usage(VOID)
113 {
114     FormatOutput(IDS_USAGE);
115 }
116 
117 static BOOL ParseCmdline(int argc, LPWSTR argv[])
118 {
119     INT i;
120 
121     if (argc < 3)
122     {
123         Usage();
124         return FALSE;
125     }
126 
127     for (i = 1; i < argc; i++)
128     {
129         if (argv[i][0] == L'-' || argv[i][0] == L'/')
130         {
131             switch (argv[i][1])
132             {
133                 case L't': NeverStop = TRUE; break;
134                 case L'n':
135                     if (i + 1 < argc)
136                     {
137                         PingCount = wcstoul(argv[++i], NULL, 0);
138 
139                         if (PingCount == 0)
140                         {
141                             FormatOutput(IDS_BAD_VALUE_OPTION_N, UINT_MAX);
142                             return FALSE;
143                         }
144                     }
145                     else
146                     {
147                         FormatOutput(IDS_BAD_OPTION_FORMAT, argv[i]);
148                         return FALSE;
149                     }
150                     break;
151 
152                 case L's':
153                     if (SourceName[0] != 0)
154                     {
155                         FormatOutput(IDS_BAD_PARAMETER, argv[i]);
156                         return FALSE;
157                     }
158 
159                     if (i + 1 < argc)
160                     {
161                         wcscpy(SourceName, argv[++i]);
162                     }
163                     else
164                     {
165                         FormatOutput(IDS_BAD_OPTION_FORMAT, argv[i]);
166                         return FALSE;
167                     }
168                     break;
169 
170                 case '?':
171                     Usage();
172                     return FALSE;
173 
174                 default:
175                     FormatOutput(IDS_BAD_OPTION, argv[i]);
176                     return FALSE;
177             }
178         }
179         else
180         {
181             if (TargetName[0] != 0)
182             {
183                 FormatOutput(IDS_BAD_PARAMETER, argv[i]);
184                 return FALSE;
185             }
186             else
187             {
188                 wcscpy(TargetName, argv[i]);
189             }
190         }
191     }
192 
193     if (TargetName[0] == 0)
194     {
195         FormatOutput(IDS_DEST_MUST_BE_SPECIFIED);
196         return FALSE;
197     }
198 
199     if (SourceName[0] == 0)
200     {
201         FormatOutput(IDS_SRC_MUST_BE_SPECIFIED);
202         return FALSE;
203     }
204 
205     return TRUE;
206 }
207 
208 static BOOL WINAPI StopLoop(DWORD dwCtrlType)
209 {
210     NeverStop = FALSE;
211     PingCount = 0;
212 
213     return TRUE;
214 }
215 
216 static BOOL Setup(VOID)
217 {
218     WORD     wVersionRequested;
219     WSADATA  WsaData;
220     INT      Status;
221     PHOSTENT phe;
222     CHAR     aTargetName[256];
223     IN_ADDR  Target;
224 
225     wVersionRequested = MAKEWORD(2, 2);
226 
227     Status = WSAStartup(wVersionRequested, &WsaData);
228     if (Status != 0)
229     {
230         FormatOutput(IDS_COULD_NOT_INIT_WINSOCK);
231         return FALSE;
232     }
233 
234     if (!WideCharToMultiByte(CP_ACP, 0, TargetName, -1, aTargetName,
235                              sizeof(aTargetName), NULL, NULL))
236     {
237         FormatOutput(IDS_UNKNOWN_HOST, TargetName);
238         return FALSE;
239     }
240 
241     phe = NULL;
242     TargetAddr = inet_addr(aTargetName);
243     if (TargetAddr == INADDR_NONE)
244     {
245         phe = gethostbyname(aTargetName);
246         if (phe == NULL)
247         {
248             FormatOutput(IDS_UNKNOWN_HOST, TargetName);
249             return FALSE;
250         }
251 
252         CopyMemory(&TargetAddr, phe->h_addr, phe->h_length);
253     }
254 
255     Target.S_un.S_addr = TargetAddr;
256     swprintf(TargetIP, L"%d.%d.%d.%d", Target.S_un.S_un_b.s_b1,
257                                        Target.S_un.S_un_b.s_b2,
258                                        Target.S_un.S_un_b.s_b3,
259                                        Target.S_un.S_un_b.s_b4);
260 
261     if (!WideCharToMultiByte(CP_ACP, 0, SourceName, -1, aTargetName,
262                              sizeof(aTargetName), NULL, NULL))
263     {
264         FormatOutput(IDS_UNKNOWN_HOST, SourceName);
265         return FALSE;
266     }
267 
268     SourceAddr = inet_addr(aTargetName);
269     if (SourceAddr == INADDR_NONE)
270     {
271         FormatOutput(IDS_UNKNOWN_HOST, SourceName);
272         return FALSE;
273     }
274 
275     SetConsoleCtrlHandler(StopLoop, TRUE);
276 
277     return TRUE;
278 }
279 
280 static VOID Cleanup(VOID)
281 {
282     WSACleanup();
283 }
284 
285 static VOID QueryTime(PLARGE_INTEGER Time)
286 {
287     if (UsePerformanceCounter)
288     {
289         if (QueryPerformanceCounter(Time) == 0)
290         {
291             /* This should not happen, but we fall
292                back to GetCurrentTick() if it does */
293             Time->u.LowPart  = (ULONG)GetTickCount();
294             Time->u.HighPart = 0;
295 
296             /* 1 tick per millisecond for GetCurrentTick() */
297             TicksPerMs.QuadPart = 1;
298             /* GetCurrentTick() cannot handle microseconds */
299             TicksPerUs.QuadPart = 1;
300 
301             UsePerformanceCounter = FALSE;
302         }
303     }
304     else
305     {
306         Time->u.LowPart  = (ULONG)GetTickCount();
307         Time->u.HighPart = 0;
308     }
309 }
310 
311 static VOID TimeToMsString(LPWSTR String, ULONG Length, LARGE_INTEGER Time)
312 {
313     WCHAR         Convstr[40];
314     LARGE_INTEGER LargeTime;
315     LPWSTR ms;
316 
317     LargeTime.QuadPart = Time.QuadPart / TicksPerMs.QuadPart;
318 
319     _i64tow(LargeTime.QuadPart, Convstr, 10);
320     wcscpy(String, Convstr);
321     ms = String + wcslen(String);
322     LoadString(GetModuleHandle(NULL), IDS_MS, ms, Length - (ms - String));
323 }
324 
325 static BOOL Ping(VOID)
326 {
327     LARGE_INTEGER RelativeTime;
328     LARGE_INTEGER LargeTime;
329     LARGE_INTEGER SentTime;
330     DWORD Ret;
331     BYTE TargetHW[6];
332     ULONG Size;
333     WCHAR Sign[2];
334     WCHAR Time[100];
335     WCHAR StrHwAddr[18];
336 
337     QueryTime(&SentTime);
338     Size = sizeof(TargetHW);
339     memset(TargetHW, 0xff, Size);
340     ++Sent;
341     Ret = SendARP(TargetAddr, SourceAddr, (PULONG)TargetHW, &Size);
342     if (Ret == ERROR_SUCCESS)
343     {
344         QueryTime(&LargeTime);
345 
346         RelativeTime.QuadPart = (LargeTime.QuadPart - SentTime.QuadPart);
347 
348         if ((RelativeTime.QuadPart / TicksPerMs.QuadPart) < 1)
349         {
350             wcscpy(Sign, L"<");
351             LoadString(GetModuleHandle(NULL), IDS_1MS, Time, sizeof(Time) / sizeof(WCHAR));
352         }
353         else
354         {
355             wcscpy(Sign, L"=");
356             TimeToMsString(Time, sizeof(Time) / sizeof(WCHAR), RelativeTime);
357         }
358 
359         swprintf(StrHwAddr, L"%02x:%02x:%02x:%02x:%02x:%02x", TargetHW[0], TargetHW[1],
360                                                               TargetHW[2], TargetHW[3],
361                                                               TargetHW[4], TargetHW[5]);
362         FormatOutput(IDS_REPLY_FROM, TargetIP, StrHwAddr, Sign, Time);
363         Received++;
364 
365         return TRUE;
366     }
367 
368     return FALSE;
369 }
370 
371 int wmain(int argc, LPWSTR argv[])
372 {
373     UINT Count;
374     LARGE_INTEGER PerformanceCounterFrequency;
375 
376     PingCount = 4;
377     Timeout = 1000;
378     hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
379 
380     UsePerformanceCounter = QueryPerformanceFrequency(&PerformanceCounterFrequency);
381 
382     if (UsePerformanceCounter)
383     {
384         /* Performance counters may return incorrect results on some multiprocessor
385            platforms so we restrict execution on the first processor. This may fail
386            on Windows NT so we fall back to GetCurrentTick() for timing */
387         if (SetThreadAffinityMask (GetCurrentThread(), 1) == 0)
388             UsePerformanceCounter = FALSE;
389 
390         /* Convert frequency to ticks per millisecond */
391         TicksPerMs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000;
392         /* And to ticks per microsecond */
393         TicksPerUs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000000;
394     }
395     if (!UsePerformanceCounter)
396     {
397         /* 1 tick per millisecond for GetCurrentTick() */
398         TicksPerMs.QuadPart = 1;
399         /* GetCurrentTick() cannot handle microseconds */
400         TicksPerUs.QuadPart = 1;
401     }
402 
403     if (!ParseCmdline(argc, argv) || !Setup())
404     {
405         return 1;
406     }
407 
408     FormatOutput(IDS_ARPING_TO_FROM, TargetIP, SourceName);
409 
410     Count = 0;
411     while (Count < PingCount || NeverStop)
412     {
413         Ping();
414         Count++;
415         if (Count < PingCount || NeverStop)
416             Sleep(Timeout);
417     }
418 
419     Cleanup();
420 
421     FormatOutput(IDS_ARPING_STATISTICS, Sent, Received);
422 
423     return 0;
424 }
425