reactos/base/applications/network/ping/ping.c

   1 /*
   2  * Copyright (c) 2015 Tim Crawford
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in all
  12  * copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 /*
  24  * PROJECT:     ReactOS Ping Command
  25  * LICENSE:     MIT
  26  * FILE:        base/applications/network/ping/ping.c
  27  * PURPOSE:     Network test utility
  28  * PROGRAMMERS: Tim Crawford <crawfxrd@gmail.com>
  29  */
  30
  31 #define WIN32_LEAN_AND_MEAN
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <winsock2.h>
  36 #include <ws2tcpip.h>
  37 #include <iphlpapi.h>
  38 #include <icmpapi.h>
  39
  40 #include "resource.h"
  41
  42 #define NDEBUG
  43 #include <debug.h>
  44
  45 #define SIZEOF_ICMP_ERROR 8
  46 #define SIZEOF_IO_STATUS_BLOCK 8
  47 #define DEFAULT_TIMEOUT 1000
  48 #define MAX_SEND_SIZE 65500
  49
  50 static BOOL ParseCmdLine(int argc, PWSTR argv[]);
  51 static BOOL ResolveTarget(PCWSTR target);
  52 static void Ping(void);
  53 static void PrintStats(void);
  54 static BOOL WINAPI ConsoleCtrlHandler(DWORD ControlType);
  55 static void PrintString(UINT id, ...);
  56
  57 static HANDLE hStdOut;
  58 static HANDLE hIcmpFile = INVALID_HANDLE_VALUE;
  59 static ULONG Timeout = 4000;
  60 static int Family = AF_UNSPEC;
  61 static ULONG RequestSize = 32;
  62 static ULONG PingCount = 4;
  63 static BOOL PingForever = FALSE;
  64 static PADDRINFOW Target = NULL;
  65 static PCWSTR TargetName = NULL;
  66 static WCHAR Address[46];
  67 static WCHAR CanonName[NI_MAXHOST];
  68 static BOOL ResolveAddress = FALSE;
  69
  70 static ULONG RTTMax = 0;
  71 static ULONG RTTMin = 0;
  72 static ULONG RTTTotal = 0;
  73 static ULONG EchosSent = 0;
  74 static ULONG EchosReceived = 0;
  75 static ULONG EchosSuccessful = 0;
  76
  77 static IP_OPTION_INFORMATION IpOptions;
  78
  79 int
  80 wmain(int argc, WCHAR *argv[])
  81 {
  82     WSADATA wsaData;
  83     ULONG i;
  84     DWORD StrLen = 46;
  85     int Status;
  86
  87     IpOptions.Ttl = 128;
  88
  89     hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
  90
  91     if (!ParseCmdLine(argc, argv))
  92     {
  93         return 1;
  94     }
  95
  96     if (!SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE))
  97     {
  98         DPRINT("Failed to set control handler: %lu\n", GetLastError());
  99
 100         return 1;
 101     }
 102
 103     Status = WSAStartup(MAKEWORD(2, 2), &wsaData);
 104     if (Status != 0)
 105     {
 106         PrintString(IDS_WINSOCK_FAIL, Status);
 107
 108         return 1;
 109     }
 110
 111     if (!ResolveTarget(TargetName))
 112     {
 113         WSACleanup();
 114
 115         return 1;
 116     }
 117
 118     if (WSAAddressToStringW(Target->ai_addr, (DWORD)Target->ai_addrlen, NULL, Address, &StrLen) != 0)
 119     {
 120         DPRINT("WSAAddressToStringW failed: %d\n", WSAGetLastError());
 121         FreeAddrInfoW(Target);
 122         WSACleanup();
 123
 124         return 1;
 125     }
 126
 127     if (Family == AF_INET6)
 128     {
 129         hIcmpFile = Icmp6CreateFile();
 130     }
 131     else
 132     {
 133         hIcmpFile = IcmpCreateFile();
 134     }
 135
 136
 137     if (hIcmpFile == INVALID_HANDLE_VALUE)
 138     {
 139         DPRINT("IcmpCreateFile failed: %lu\n", GetLastError());
 140         FreeAddrInfoW(Target);
 141         WSACleanup();
 142
 143         return 1;
 144     }
 145
 146     if (*CanonName)
 147     {
 148         PrintString(IDS_PINGING_HOSTNAME, CanonName, Address);
 149     }
 150     else
 151     {
 152         PrintString(IDS_PINGING_ADDRESS, Address);
 153     }
 154
 155     PrintString(IDS_PING_SIZE, RequestSize);
 156
 157     Ping();
 158     i = 1;
 159
 160     while (i < PingCount)
 161     {
 162         Sleep(1000);
 163         Ping();
 164
 165         if (!PingForever)
 166             i++;
 167     }
 168
 169     PrintStats();
 170
 171     IcmpCloseHandle(hIcmpFile);
 172     FreeAddrInfoW(Target);
 173     WSACleanup();
 174
 175     return 0;
 176 }
 177
 178 static
 179 void
 180 PrintString(UINT id, ...)
 181 {
 182 #define RC_STRING_MAX_SIZE  4096
 183
 184     WCHAR Format[RC_STRING_MAX_SIZE];
 185     LPWSTR lpMsgBuf = NULL;
 186     DWORD Len;
 187     va_list args;
 188
 189     if (!LoadStringW(GetModuleHandleW(NULL), id, Format, _countof(Format)))
 190     {
 191         DPRINT("LoadStringW failed: %lu\n", GetLastError());
 192         return;
 193     }
 194
 195     va_start(args, id);
 196
 197     Len = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
 198                          Format, 0, 0, (PWSTR)&lpMsgBuf, 0, &args);
 199     if (lpMsgBuf /* && Len != 0 */)
 200     {
 201         // TODO: Handle writing to file. Well, use the ConUtils lib!
 202         WriteConsoleW(hStdOut, lpMsgBuf, Len, &Len, NULL);
 203         LocalFree(lpMsgBuf);
 204     }
 205     else
 206     {
 207         DPRINT("FormatMessageW failed: %lu\n", GetLastError());
 208     }
 209
 210     va_end(args);
 211 }
 212
 213 static
 214 BOOL
 215 ParseCmdLine(int argc, PWSTR argv[])
 216 {
 217     int i;
 218
 219     if (argc < 2)
 220     {
 221         PrintString(IDS_USAGE);
 222         return FALSE;
 223     }
 224
 225     for (i = 1; i < argc; i++)
 226     {
 227         if (argv[i][0] == L'-' || argv[i][0] == L'/')
 228         {
 229             switch (argv[i][1])
 230             {
 231             case L't':
 232                 PingForever = TRUE;
 233                 break;
 234
 235             case L'a':
 236                 ResolveAddress = TRUE;
 237                 break;
 238
 239             case L'n':
 240                 if (i + 1 < argc)
 241                 {
 242                     PingForever = FALSE;
 243                     PingCount = wcstoul(argv[++i], NULL, 0);
 244
 245                     if (PingCount == 0)
 246                     {
 247                         PrintString(IDS_BAD_VALUE, argv[i - 1], 1, UINT_MAX);
 248
 249                         return FALSE;
 250                     }
 251                 }
 252                 else
 253                 {
 254                     PrintString(IDS_MISSING_VALUE, argv[i]);
 255
 256                     return FALSE;
 257                 }
 258
 259                 break;
 260
 261             case L'l':
 262                 if (i + 1 < argc)
 263                 {
 264                     RequestSize = wcstoul(argv[++i], NULL, 0);
 265
 266                     if (RequestSize > MAX_SEND_SIZE)
 267                     {
 268                         PrintString(IDS_BAD_VALUE, argv[i - 1], 0, MAX_SEND_SIZE);
 269
 270                         return FALSE;
 271                     }
 272                 }
 273                 else
 274                 {
 275                     PrintString(IDS_MISSING_VALUE, argv[i]);
 276
 277                     return FALSE;
 278                 }
 279
 280                 break;
 281
 282             case L'f':
 283                 if (Family == AF_INET6)
 284                 {
 285                     PrintString(IDS_WRONG_FAMILY, argv[i], L"IPv4");
 286
 287                     return FALSE;
 288                 }
 289
 290                 Family = AF_INET;
 291                 IpOptions.Flags |= IP_FLAG_DF;
 292                 break;
 293
 294             case L'i':
 295                 if (i + 1 < argc)
 296                 {
 297                     ULONG Ttl = wcstoul(argv[++i], NULL, 0);
 298
 299                     if ((Ttl == 0) || (Ttl > UCHAR_MAX))
 300                     {
 301                         PrintString(IDS_BAD_VALUE, argv[i - 1], 1, UCHAR_MAX);
 302
 303                         return FALSE;
 304                     }
 305
 306                     IpOptions.Ttl = (UCHAR)Ttl;
 307                 }
 308                 else
 309                 {
 310                     PrintString(IDS_MISSING_VALUE, argv[i]);
 311
 312                     return FALSE;
 313                 }
 314
 315                 break;
 316
 317             case L'v':
 318                 if (Family == AF_INET6)
 319                 {
 320                     PrintString(IDS_WRONG_FAMILY, argv[i], L"IPv4");
 321
 322                     return FALSE;
 323                 }
 324
 325                 Family = AF_INET;
 326
 327                 if (i + 1 < argc)
 328                 {
 329                     /* This option has been deprecated. Don't do anything. */
 330                     i++;
 331                 }
 332                 else
 333                 {
 334                     PrintString(IDS_MISSING_VALUE, argv[i]);
 335
 336                     return FALSE;
 337                 }
 338
 339                 break;
 340
 341             case L'w':
 342                 if (i + 1 < argc)
 343                 {
 344                     Timeout = wcstoul(argv[++i], NULL, 0);
 345
 346                     if (Timeout < DEFAULT_TIMEOUT)
 347                     {
 348                         Timeout = DEFAULT_TIMEOUT;
 349                     }
 350                 }
 351                 else
 352                 {
 353                     PrintString(IDS_MISSING_VALUE, argv[i]);
 354
 355                     return FALSE;
 356                 }
 357
 358                 break;
 359
 360             case L'R':
 361                 if (Family == AF_INET)
 362                 {
 363                     PrintString(IDS_WRONG_FAMILY, argv[i], L"IPv6");
 364
 365                     return FALSE;
 366                 }
 367
 368                 Family = AF_INET6;
 369
 370                 /* This option has been deprecated. Don't do anything. */
 371                 break;
 372
 373             case L'4':
 374                 if (Family == AF_INET6)
 375                 {
 376                     PrintString(IDS_WRONG_FAMILY, argv[i], L"IPv4");
 377
 378                     return FALSE;
 379                 }
 380
 381                 Family = AF_INET;
 382                 break;
 383
 384             case L'6':
 385                 if (Family == AF_INET)
 386                 {
 387                     PrintString(IDS_WRONG_FAMILY, argv[i], L"IPv6");
 388
 389                     return FALSE;
 390                 }
 391
 392                 Family = AF_INET6;
 393                 break;
 394
 395             case L'?':
 396                 PrintString(IDS_USAGE);
 397                 return FALSE;
 398
 399             default:
 400                 PrintString(IDS_BAD_OPTION, argv[i]);
 401                 PrintString(IDS_USAGE);
 402                 return FALSE;
 403             }
 404         }
 405         else
 406         {
 407             if (TargetName != NULL)
 408             {
 409                 PrintString(IDS_BAD_PARAMETER, argv[i]);
 410
 411                 return FALSE;
 412             }
 413
 414             TargetName = argv[i];
 415         }
 416     }
 417
 418     if (TargetName == NULL)
 419     {
 420         PrintString(IDS_MISSING_ADDRESS);
 421
 422         return FALSE;
 423     }
 424
 425     return TRUE;
 426 }
 427
 428 static
 429 BOOL
 430 ResolveTarget(PCWSTR target)
 431 {
 432     ADDRINFOW hints;
 433     int Status;
 434
 435     ZeroMemory(&hints, sizeof(hints));
 436     hints.ai_family = Family;
 437     hints.ai_flags = AI_NUMERICHOST;
 438
 439     Status = GetAddrInfoW(target, NULL, &hints, &Target);
 440     if (Status != 0)
 441     {
 442         hints.ai_flags = AI_CANONNAME;
 443
 444         Status = GetAddrInfoW(target, NULL, &hints, &Target);
 445         if (Status != 0)
 446         {
 447             PrintString(IDS_UNKNOWN_HOST, target);
 448
 449             return FALSE;
 450         }
 451
 452         wcsncpy(CanonName, Target->ai_canonname, wcslen(Target->ai_canonname));
 453     }
 454     else if (ResolveAddress)
 455     {
 456         Status = GetNameInfoW(
 457             Target->ai_addr, Target->ai_addrlen,
 458             CanonName, _countof(CanonName),
 459             NULL, 0,
 460             NI_NAMEREQD);
 461
 462         if (Status != 0)
 463         {
 464             DPRINT("GetNameInfoW failed: %d\n", WSAGetLastError());
 465         }
 466     }
 467
 468     Family = Target->ai_family;
 469
 470     return TRUE;
 471 }
 472
 473 static
 474 void
 475 Ping(void)
 476 {
 477     PVOID ReplyBuffer = NULL;
 478     PVOID SendBuffer = NULL;
 479     DWORD ReplySize = 0;
 480     DWORD Status;
 481
 482     SendBuffer = malloc(RequestSize);
 483     if (SendBuffer == NULL)
 484     {
 485         PrintString(IDS_NO_RESOURCES);
 486
 487         exit(1);
 488     }
 489
 490     ZeroMemory(SendBuffer, RequestSize);
 491
 492     if (Family == AF_INET6)
 493     {
 494         ReplySize += sizeof(ICMPV6_ECHO_REPLY);
 495     }
 496     else
 497     {
 498         ReplySize += sizeof(ICMP_ECHO_REPLY);
 499     }
 500
 501     ReplySize += RequestSize + SIZEOF_ICMP_ERROR + SIZEOF_IO_STATUS_BLOCK;
 502
 503     ReplyBuffer = malloc(ReplySize);
 504     if (ReplyBuffer == NULL)
 505     {
 506         PrintString(IDS_NO_RESOURCES);
 507         free(SendBuffer);
 508
 509         exit(1);
 510     }
 511
 512     ZeroMemory(ReplyBuffer, ReplySize);
 513
 514     EchosSent++;
 515
 516     if (Family == AF_INET6)
 517     {
 518         struct sockaddr_in6 Source;
 519
 520         ZeroMemory(&Source, sizeof(Source));
 521         Source.sin6_family = AF_INET6;
 522
 523         Status = Icmp6SendEcho2(
 524             hIcmpFile, NULL, NULL, NULL,
 525             &Source,
 526             (struct sockaddr_in6 *)Target->ai_addr,
 527             SendBuffer, (USHORT)RequestSize, &IpOptions,
 528             ReplyBuffer, ReplySize, Timeout);
 529     }
 530     else
 531     {
 532         Status = IcmpSendEcho2(
 533             hIcmpFile, NULL, NULL, NULL,
 534             ((PSOCKADDR_IN)Target->ai_addr)->sin_addr.s_addr,
 535             SendBuffer, (USHORT)RequestSize, &IpOptions,
 536             ReplyBuffer, ReplySize, Timeout);
 537     }
 538
 539     free(SendBuffer);
 540
 541     if (Status == 0)
 542     {
 543         Status = GetLastError();
 544         switch (Status)
 545         {
 546         case IP_DEST_HOST_UNREACHABLE:
 547             PrintString(IDS_DEST_HOST_UNREACHABLE);
 548             break;
 549
 550         case IP_DEST_NET_UNREACHABLE:
 551             PrintString(IDS_DEST_NET_UNREACHABLE);
 552             break;
 553
 554         case IP_REQ_TIMED_OUT:
 555             PrintString(IDS_REQUEST_TIMED_OUT);
 556             break;
 557
 558         default:
 559             PrintString(IDS_TRANSMIT_FAILED, Status);
 560             break;
 561         }
 562     }
 563     else
 564     {
 565         EchosReceived++;
 566
 567         PrintString(IDS_REPLY_FROM, Address);
 568
 569         if (Family == AF_INET6)
 570         {
 571             PICMPV6_ECHO_REPLY pEchoReply;
 572
 573             pEchoReply = (PICMPV6_ECHO_REPLY)ReplyBuffer;
 574
 575             switch (pEchoReply->Status)
 576             {
 577             case IP_SUCCESS:
 578                 EchosSuccessful++;
 579
 580                 if (pEchoReply->RoundTripTime == 0)
 581                 {
 582                     PrintString(IDS_REPLY_TIME_0MS);
 583                 }
 584                 else
 585                 {
 586                     PrintString(IDS_REPLY_TIME_MS, pEchoReply->RoundTripTime);
 587                 }
 588
 589                 if (pEchoReply->RoundTripTime < RTTMin || RTTMin == 0)
 590                 {
 591                     RTTMin = pEchoReply->RoundTripTime;
 592                 }
 593
 594                 if (pEchoReply->RoundTripTime > RTTMax || RTTMax == 0)
 595                 {
 596                     RTTMax = pEchoReply->RoundTripTime;
 597                 }
 598
 599                 wprintf(L"\n");
 600
 601                 RTTTotal += pEchoReply->RoundTripTime;
 602                 break;
 603
 604             case IP_TTL_EXPIRED_TRANSIT:
 605                 PrintString(IDS_TTL_EXPIRED);
 606                 break;
 607
 608             default:
 609                 PrintString(IDS_REPLY_STATUS, pEchoReply->Status);
 610                 break;
 611             }
 612         }
 613         else
 614         {
 615             PICMP_ECHO_REPLY pEchoReply;
 616
 617             pEchoReply = (PICMP_ECHO_REPLY)ReplyBuffer;
 618
 619             switch (pEchoReply->Status)
 620             {
 621             case IP_SUCCESS:
 622                 EchosSuccessful++;
 623
 624                 PrintString(IDS_REPLY_BYTES, pEchoReply->DataSize);
 625
 626                 if (pEchoReply->RoundTripTime == 0)
 627                 {
 628                     PrintString(IDS_REPLY_TIME_0MS);
 629                 }
 630                 else
 631                 {
 632                     PrintString(IDS_REPLY_TIME_MS, pEchoReply->RoundTripTime);
 633                 }
 634
 635                 PrintString(IDS_REPLY_TTL, pEchoReply->Options.Ttl);
 636
 637                 if (pEchoReply->RoundTripTime < RTTMin || RTTMin == 0)
 638                 {
 639                     RTTMin = pEchoReply->RoundTripTime;
 640                 }
 641
 642                 if (pEchoReply->RoundTripTime > RTTMax || RTTMax == 0)
 643                 {
 644                     RTTMax = pEchoReply->RoundTripTime;
 645                 }
 646
 647                 RTTTotal += pEchoReply->RoundTripTime;
 648                 break;
 649
 650             case IP_TTL_EXPIRED_TRANSIT:
 651                 PrintString(IDS_TTL_EXPIRED);
 652                 break;
 653
 654             default:
 655                 PrintString(IDS_REPLY_STATUS, pEchoReply->Status);
 656                 break;
 657             }
 658         }
 659     }
 660
 661     free(ReplyBuffer);
 662 }
 663
 664 static
 665 void
 666 PrintStats(void)
 667 {
 668     ULONG EchosLost = EchosSent - EchosReceived;
 669     ULONG PercentLost = (ULONG)((EchosLost / (double)EchosSent) * 100.0);
 670
 671     PrintString(IDS_STATISTICS, Address, EchosSent, EchosReceived, EchosLost, PercentLost);
 672
 673     if (EchosSuccessful > 0)
 674     {
 675         ULONG RTTAverage = RTTTotal / EchosSuccessful;
 676
 677         PrintString(IDS_APPROXIMATE_RTT, RTTMin, RTTMax, RTTAverage);
 678     }
 679 }
 680
 681 static
 682 BOOL
 683 WINAPI
 684 ConsoleCtrlHandler(DWORD ControlType)
 685 {
 686     switch (ControlType)
 687     {
 688     case CTRL_C_EVENT:
 689         PrintStats();
 690         PrintString(IDS_CTRL_C);
 691         return FALSE;
 692
 693     case CTRL_BREAK_EVENT:
 694         PrintStats();
 695         PrintString(IDS_CTRL_BREAK);
 696         return TRUE;
 697
 698     case CTRL_CLOSE_EVENT:
 699         PrintStats();
 700         return FALSE;
 701
 702     default:
 703         return FALSE;
 704     }
 705 }