main.cpp

Go to the documentation of this file.

// main.cpp

#if _MSC_VER == 1200
#pragma warning(disable : 4786)
#endif // MSC ver 6.0

#include <winsock2.h>
#include <iostream>
#include <iomanip>

#include "icmp.h"
#include "PingTarget.h"
#include "format_system_message.h"
#include "format_system_time.h"
#include "PerformanceCounter.h"
#include "VersionInfo.h"
#include "console.h"
#include "ProgramOptions.h"
#include "format_paragraph.h"

const char* pszLicense =
  "\"Ping' em\" copyright Erik Frankenfeld - http://www.frankenfeld.dk/pingem\n"
  "\n"
  "This program and the source code is free software. "
  "You may use, modify and redistribute it at your own risk.";

const char* pszHelpIntro = 
  "Usage: pingem [options] target(s)\n\n"
  "pingem pings each target, waits for responses and then pauses.\n"
  "Statistics are shown for each cycle of send and receive.\n\n"
  "Available options:";

const char* pszShortHelpIntro = 
  "Usage: pingem [options] target(s)\n\n"
  "pingem -h shows available options and pingem -license displays the license.";

const char* pszMainReturnValues =
  "Program exit codes\n\n"
  "  0 : No errors occurred.\n"
  "  1 : Error in options or parameters.\n"
  "  2 : Runtime error occurred in network initialization or usage.\n"
  "  3 : One or more target names could not be resolved.\n"
  "  4 : Error occurred while creating or writing to the log file.";

#define MAIN_OK 0
#define MAIN_OPTION_ERROR 1
#define MAIN_NETWORK_ERROR 2
#define MAIN_TARGET_UNRESOLVED 3
#define MAIN_LOG_FILE_ERROR 4

PingTargets pingtargets;
ProgramOptions pingoptions;

int main(int argc, char* argv[])
{
  std::cout.imbue(std::locale(""));
  PerformanceCounter::Init();

  // Define options and parameters
  pingoptions.AddLong(
    'w', "timeout",
    1000, 0, LONG_MAX,
    false,
    "ms",
    "Time in milliseconds to wait while sending to and receiving from targets.\n"
    "Default value is 1000 ms."
  );
  pingoptions.AddLong(
    'p', "pause",
    1000, 0, LONG_MAX,
    false,
    "ms", 
    "Time in milliseconds to pause between sending to and receiving from all targets.\n"
    "Default value is 1000 ms."
  );
  pingoptions.AddLong(
    'n', "count",
    0, 0, LONG_MAX,
    false,
    "n",
    "Number of pings to send to each target. "
    "The default value 0 sets no limit to the number of pings."
  );
  pingoptions.AddString(
    'g', "targetsfile",
    0, false,
    "filename",
    "Reads targets from the specified file. One target name or ip per line. "
    "Targets in file are added to targets specified as parameters."
  );
  pingoptions.AddString(
    'o', "logfile",
    0, false,
    "filename",
    "Sends output of each ping to the specified file.\n"
    "First line is a header with names of targets.\n"
    "Remaining lines contains date and time formatted according to the current "
    "locale and the response time for each target.\n"
    "Columns are separated by the tab character."
  );
  pingoptions.AddBoolean(
    'd', "daily",
    0, false,
    "Creates a log file for every day using the filename specified for logfile as a pattern: "
    "filenameYYYYMMDD.ext\n"
    "YYYY is the 4 digit year, MM is the month and DD is the date."
  );
  pingoptions.AddBoolean(
    'u', "hourly",
    0, false,
    "Creates a log file for every hour using the specified filename for logfile as a pattern: "
    "filenameYYYYMMDD_HH.ext\n"
    "YYYY is the 4 digit year, MM is the month, DD is the date and HH is the hour 00-23."
  );
  pingoptions.AddBoolean(
    'q', "quiet",
    false, false,
    "Quiet operation. Only errors terminating the application and their messages are sent to console."
  );
  pingoptions.AddBoolean(
    'h', "help",
    false, false,
    "Show this option help text and exit."
  );
  pingoptions.AddBoolean(
    '?', 0,
    false, false,
    "Show this option help text and exit."
  );
  pingoptions.AddBoolean(
    '\0', "exitcodes",
    false, false,
    "Show available exit codes."
  );
  pingoptions.AddBoolean(
    '\0', "license",
    false, false,
    "Show license information."
  );

  if (!pingoptions.Parse(argc, argv, std::cout.getloc()))
  {
    std::cerr << std::endl << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszShortHelpIntro, 0, GetStdOutWidth()-2);
    return MAIN_OPTION_ERROR;
  }
  if (pingoptions.GetBoolValue("help") || pingoptions.GetBoolValue('?'))
  {
    std::cerr << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszHelpIntro, 0, GetStdOutWidth()-2);
    pingoptions.PrintHelp(std::cerr, GetStdOutWidth()-2);
    return MAIN_OK;
  }
  if (pingoptions.GetBoolValue("exitcodes"))
  {
    std::cerr << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszMainReturnValues, 0, GetStdOutWidth()-2) << std::endl;
    return MAIN_OK;
  }
  if (pingoptions.GetBoolValue("license"))
  {
    std::cerr << format_paragraph(pszLicense, 0, GetStdOutWidth()-2) << std::endl;
    return MAIN_OK;
  }

  WSADATA wsa;
  if (WSAStartup(MAKEWORD(2,0), &wsa) != 0)
  {
    std::cerr << "Unable to initialize Winsock2 version 2.0" << std::endl;
    std::cerr << format_system_message(WSAGetLastError()) << std::endl;
    WSACleanup();
    return MAIN_NETWORK_ERROR;
  }

  bool bAllTargetsResolved = true;
  std::string sTargetsFilename = pingoptions.GetStringValue("targetsfile");
  if (!sTargetsFilename.empty())
  {
    bAllTargetsResolved = pingtargets.AddTargets(sTargetsFilename.c_str());
  }
  for (ProgramOptions::const_parameter_iterator iParam = pingoptions.parameter_begin();
    iParam != pingoptions.parameter_end() && bAllTargetsResolved; ++iParam)
  {
    std::string s = *iParam;
    if (!pingtargets.AddTarget(s.c_str()))
      bAllTargetsResolved = false;
  }
  if (!bAllTargetsResolved)
  {
    std::cerr << std::endl << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszShortHelpIntro, 0, GetStdOutWidth()-2);
    return MAIN_TARGET_UNRESOLVED;
  }
  if (pingtargets.size() == 0)
  {
    std::cerr << "No available targets." << std::endl << std::endl;
    std::cerr << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszShortHelpIntro, 0, GetStdOutWidth()-2);
    return MAIN_OPTION_ERROR;
  }

  long lTimeout = pingoptions.GetLongValue("timeout");
  long lPause = pingoptions.GetLongValue("pause");
  long lPingCount = pingoptions.GetLongValue("count");
  std::string sLogFilename = pingoptions.GetStringValue("logfile");
  bool bDaily = pingoptions.GetBoolValue("daily");
  bool bHourly = pingoptions.GetBoolValue("hourly");
  bool bQuiet = pingoptions.GetBoolValue("quiet");
  
  PingTargets::LOG_FILENAME_TYPE LogFilenameType = PingTargets::LOG_FILENAME_PLAIN;
  if (bDaily && !bHourly)
    LogFilenameType = PingTargets::LOG_FILENAME_DAILY;
  else if (bHourly && !bDaily)
    LogFilenameType = PingTargets::LOG_FILENAME_HOURLY;
  else if (!bHourly && !bDaily)
    LogFilenameType = PingTargets::LOG_FILENAME_PLAIN;
  else
  {
    std::cerr << "Options daily and hourly cannot both be specified." << std::endl << std::endl;
    std::cerr << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszShortHelpIntro, 0, GetStdOutWidth()-2);
    return MAIN_OPTION_ERROR;
  }
  if (sLogFilename.empty() && (bDaily || bHourly))
  {
    std::cerr << "Options daily and hourly requires logfile to be specified." << std::endl << std::endl;
    std::cerr << GetProductInfo() << std::endl << std::endl;
    std::cerr << format_paragraph(pszShortHelpIntro, 0, GetStdOutWidth()-2);
    return MAIN_OPTION_ERROR;
  }
  

  SOCKET sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
  if (sockRaw == INVALID_SOCKET)
  {
    std::cerr << "Unable to create raw socket" << std::endl;
    std::cerr << format_system_message(WSAGetLastError()) << std::endl;
    WSACleanup();
    return MAIN_NETWORK_ERROR;
  }

  int iDataSize = 32;
  int iPacketSize = sizeof(ICMP_HEADER) + iDataSize;
  char* pPacket = new char[iPacketSize];
  int iRecvSize = iPacketSize + sizeof(IP_HEADER);
  char *pRecvBuf = new char[iRecvSize];

  long lSequence = 1;
  long lPings = 0;
  SYSTEMTIME systemtimeStarted;
  GetLocalTime(&systemtimeStarted);
  PerformanceCounter tickStarted;

  COORD coordStart;
  coordStart.X = 0;
  coordStart.Y = 0;
  if (!bQuiet)
  {
    // Erase screen window
    ClearStdOutBuffer();
  }

  do
  {
    PingTargets::const_iterator itTarget = pingtargets.begin();
    pingtargets.ClearResponseFlags();

    PerformanceCounter endtick;
    endtick += PerformanceCounter(0, 0, 0, 0, lTimeout, 0);

    SYSTEMTIME systemtimeStartPing;
    GetLocalTime(&systemtimeStartPing);
    do
    {
      if (!bQuiet)
      {
        ClearStdOutLine();
        std::cout << "Sending and receiving...\r";
      }
      // Time to wait for replies
      timeval tmv;
      tmv.tv_sec = 0;
      tmv.tv_usec = 0;
      // Send to all targets one by loop
      if (itTarget != pingtargets.end())
      {
        const PingTarget& target = **itTarget;
        EncodePacket(pPacket, iDataSize, target.MakeSequence(lSequence));
        sockaddr_in sockaddrSend;
        memset(&sockaddrSend, 0, sizeof(sockaddrSend));
        sockaddrSend.sin_addr = target.GetInetAddr();
        sockaddrSend.sin_family = AF_INET;
        int iSent = sendto(sockRaw, pPacket, iPacketSize, 0, (sockaddr*)&sockaddrSend, sizeof(sockaddrSend));
        if (iSent == SOCKET_ERROR)
        {
          // Ignore network error here.
          // Logging or debug option showing them could also be an option.
          int err = WSAGetLastError();
        }
        itTarget++;
      }
      else
      {
        // Nothing to send. Calculate remaining time to wait for responses
        PerformanceCounter tick;
        PerformanceCounter diff = endtick - tick;
        diff.GetAsSecondsAndMicroseconds(tmv.tv_sec, tmv.tv_usec);
      }
      // Anything to receive?
      fd_set fds;
      FD_ZERO(&fds);
      #pragma warning(push)
      #pragma warning(disable : 4127)
      FD_SET(sockRaw, &fds);
      #pragma warning(pop)
      int iStatus = select(0, &fds, NULL, NULL, &tmv);
      if (iStatus == SOCKET_ERROR)
      {
        // Ignore network error here.
        // Logging or debug option showing them could also be an option.
        int err = WSAGetLastError();
      }
      if (iStatus > 0)
      {
        // Socket is ready
        sockaddr_in sockaddrRecv;
        int iRecvLen = sizeof(sockaddrRecv);
        memset(&sockaddrRecv, 0, sizeof(sockaddrRecv));
        int iRead = recvfrom(sockRaw, pRecvBuf, iRecvSize, 0, (sockaddr*)&sockaddrRecv, &iRecvLen);
        if (iRead == SOCKET_ERROR)
        {
          int err = WSAGetLastError();
          if (err == WSAEMSGSIZE) // buffer was to small
            iRead = iRecvSize;
        }
        USHORT uRecvSeq;
        LONGLONG llRecvTick;
        PerformanceCounter tick;
        if (DecodePacket(pRecvBuf, iRead, uRecvSeq, llRecvTick))
        {
          long lRecvId = pingtargets.GetTargetId(uRecvSeq);
          long lRecvSeq = pingtargets.GetSequence(uRecvSeq);
          if (lRecvSeq == lSequence)
          {
            // Received the expected sequence
            PerformanceCounter diff = tick - PerformanceCounter(llRecvTick);
            pingtargets.AddResponse(lRecvId, diff.GetAsMilliseconds());
          }
        }
      }
    } while (PerformanceCounter() <= endtick);
    pingtargets.AddUnreachableResponses();
    lPings++;
    if (!bQuiet)
    {
      ClearStdOutLine();
      SetStdOutCoord(coordStart);
      std::cout << format_system_time(format_system_time::show_seconds) << " : ";
      std::cout << lPings << " pings sent to " << (long)pingtargets.size() << " targets in ";
      std::cout << format_performance_counter(
        PerformanceCounter()- tickStarted,
        format_performance_counter::show_seconds
        )
        << std::endl;
      pingtargets.PrintStatisticsHeader(std::cout, GetStdOutWidth());
      std::cout << std::endl;
      pingtargets.PrintStatistics(std::cout, GetStdOutWidth());
      std::cout << std::endl;
    }
    if (!sLogFilename.empty())
    {
      // Print header if first ping
      if (!pingtargets.PrintLogCurrent(sLogFilename.c_str(),
        systemtimeStartPing, LogFilenameType))
        return MAIN_LOG_FILE_ERROR;
    }
    lSequence++;
    if (lSequence > pingtargets.GetMaxSequence())
      lSequence = 1;
    // Only wait when not finished pinging
    if (!lPingCount || lPings < lPingCount)
    {
      // Show status while waiting
      long lTimeWait = lPause;
      long lSec = 1;
      while (lTimeWait >= 1000)
      {
        if (!bQuiet)
          std::cout << "Waiting " << lSec << "/" << lPause/1000 << " seconds\r";
        Sleep(1000);
        lTimeWait -= 1000;
        lSec++;
      }
      if (!bQuiet)
      {
        ClearStdOutLine();
        std::cout << "Waiting less than a second\r";
      }
      Sleep(lTimeWait);
      if (!bQuiet)
        ClearStdOutLine();
    }
  } while (!lPingCount || lPings < lPingCount);

  closesocket(sockRaw);
  delete []pPacket;
  delete []pRecvBuf;
  return MAIN_OK;
}

---