CWE-ou-minkata/Sources/Plasma/NucleusLib/pnNetDiag/pnNdIcmp.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
/*****************************************************************************
*
*   $/Plasma20/Sources/Plasma/NucleusLib/pnNetDiag/pnNdIcmp.cpp
*   
***/

#include "Pch.h"
#pragma hdrstop


/*****************************************************************************
*
*   Local types
*
***/

typedef HANDLE (PASCAL FAR * FIcmpCreateFile) ();
typedef DWORD (PASCAL FAR * FIcmpSendEcho) (
    HANDLE                  icmpHandle,
    DWORD                   destinationAddress,
    LPVOID                  requestData,
    WORD                    requestSize,
    PIP_OPTION_INFORMATION  options,
    LPVOID                  replyBuffer,
    DWORD                   replySize,
    DWORD                   timeoutMs
);

struct PingParam {
    NetDiag *               diag;
    FNetDiagDumpProc        dump;
    FNetDiagTestCallback    callback;
    void *                  param;
    ENetProtocol            protocol;
    unsigned                srv;
};



/*****************************************************************************
*
*   Local data
*
***/

static const unsigned   kPingCount      = 5;
static const unsigned   kPayloadBytes   = 32;

static FIcmpCreateFile  IcmpCreateFile;
static FIcmpSendEcho    IcmpSendEcho;

static byte             s_payload[kPayloadBytes];


/*****************************************************************************
*
*   Local functions
*
***/

//============================================================================
static const wchar * IpStatusToString (ULONG status) {

    switch (status) {
        case IP_SUCCESS:                return L"IP_SUCCESS";
        case IP_BUF_TOO_SMALL:          return L"IP_BUF_TOO_SMALL";
        case IP_DEST_NET_UNREACHABLE:   return L"IP_DEST_NET_UNREACHABLE";
        case IP_DEST_HOST_UNREACHABLE:  return L"IP_DEST_HOST_UNREACHABLE";
        case IP_DEST_PROT_UNREACHABLE:  return L"IP_DEST_PROT_UNREACHABLE";
        case IP_DEST_PORT_UNREACHABLE:  return L"IP_DEST_PORT_UNREACHABLE";
        case IP_NO_RESOURCES:           return L"IP_NO_RESOURCES";
        case IP_BAD_OPTION:             return L"IP_BAD_OPTION";
        case IP_HW_ERROR:               return L"IP_HW_ERROR";
        case IP_PACKET_TOO_BIG:         return L"IP_PACKET_TOO_BIG";
        case IP_REQ_TIMED_OUT:          return L"IP_REQ_TIMED_OUT";
        case IP_BAD_REQ:                return L"IP_BAD_REQ";
        case IP_BAD_ROUTE:              return L"IP_BAD_ROUTE";
        case IP_TTL_EXPIRED_TRANSIT:    return L"IP_TTL_EXPIRED_TRANSIT";
        case IP_TTL_EXPIRED_REASSEM:    return L"IP_TTL_EXPIRED_REASSEM";
        case IP_PARAM_PROBLEM:          return L"IP_PARAM_PROBLEM";
        case IP_SOURCE_QUENCH:          return L"IP_SOURCE_QUENCH";
        case IP_OPTION_TOO_BIG:         return L"IP_OPTION_TOO_BIG";
        case IP_BAD_DESTINATION:        return L"IP_BAD_DESTINATION";
        default:                        return L"Unknown error";
    }
}


//============================================================================
static void __cdecl PingThreadProc (void * param) {

    PingParam * p = (PingParam *)param;

    HANDLE icmp = IcmpCreateFile();
    if (!icmp) {
        p->dump(L"[ICMP] Failed to create ICMP handle");
        p->callback(p->diag, p->protocol, kNetErrFileNotFound, p->param);
        return;
    }

    char addr[64];  
    wchar waddr[64];
    NetAddressNodeToString(p->diag->nodes[p->srv], waddr, arrsize(waddr));
    StrToAnsi(addr, waddr, arrsize(addr));
    
    ENetError result = kNetSuccess;

    byte reply[kPayloadBytes + sizeof(ICMP_ECHO_REPLY)];
    
    for (unsigned i = 0; i < kPingCount; ++i) {
        DWORD retval = IcmpSendEcho(
            icmp,
            inet_addr(addr),
            s_payload,
            sizeof(s_payload), 
            NULL,
            reply, 
            sizeof(reply),
            4000
        );
        
        PICMP_ECHO_REPLY pEchoReply = (PICMP_ECHO_REPLY)reply;
        
        if (retval) {
            p->dump(L"[ICMP] Reply from %s. ms=%u", waddr, pEchoReply->RoundTripTime);
        }
        else {
            result = kNetErrConnectFailed;
            p->dump(L"[ICMP] No reply from %s. %s", waddr, IpStatusToString(pEchoReply->Status));
        }
    }
    
    p->callback(p->diag, p->protocol, result, p->param);
    p->diag->DecRef("ICMP");
    DEL(p);
}


/*****************************************************************************
*
*   Module functions
*
***/

//============================================================================
void IcmpStartup () {

    if (g_lib) {
        IcmpCreateFile = (FIcmpCreateFile)GetProcAddress(g_lib, "IcmpCreateFile");
        IcmpSendEcho = (FIcmpSendEcho)GetProcAddress(g_lib, "IcmpSendEcho");
    }
    MemSet(s_payload, (byte)((unsigned_ptr)&s_payload >> 4), arrsize(s_payload));
}

//============================================================================
void IcmpShutdown () {

    IcmpCreateFile = nil;
    IcmpSendEcho = nil;
}


/*****************************************************************************
*
*   Exports
*
***/

//============================================================================
void NetDiagIcmp (
    NetDiag *               diag,
    ENetProtocol            protocol,
    FNetDiagDumpProc        dump,
    FNetDiagTestCallback    callback,
    void *                  param
) {
    ASSERT(diag);
    ASSERT(dump);
    ASSERT(callback);

    if (!IcmpCreateFile || !IcmpSendEcho) {
        dump(L"[ICMP] Failed to load IP helper API");
        callback(diag, protocol, kNetErrNotSupported, param);
        return;
    }

    unsigned srv = NetProtocolToSrv(protocol);
    if (srv == kNumDiagSrvs) {
        dump(L"[ICMP] Unsupported protocol: %s", NetProtocolToString(protocol));
        callback(diag, protocol, kNetErrNotSupported, param);
        return;
    }

    unsigned node = 0;
    diag->critsect.Enter();
    {
        node = diag->nodes[srv];
    }
    diag->critsect.Leave(); 
    
    if (!node) {
        dump(L"[ICMP] No address set for protocol: %s", NetProtocolToString(protocol));
        callback(diag, protocol, kNetSuccess, param);
        return;
    }

    wchar nodeStr[64];
    NetAddressNodeToString(node, nodeStr, arrsize(nodeStr));        
    dump(L"[ICMP] Pinging %s with %u bytes of data...", nodeStr, kPayloadBytes);

    PingParam * pingParam   = NEWZERO(PingParam);
    pingParam->diag         = diag;
    pingParam->srv          = srv;
    pingParam->protocol     = protocol;
    pingParam->dump         = dump;
    pingParam->callback     = callback;
    pingParam->param        = param;
    
    diag->IncRef("ICMP");
    _beginthread(PingThreadProc, 0, pingParam);
}