ping 命令实现

于 2022-11-14 22:35:42 发布
阅读量316 收藏
点赞数 1
分类专栏： demo 文章标签： c++ windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq492927689/article/details/127857209
版权 
/*
* COPYRIGHT:   See COPYING in the top level directory
* PROJECT:     ReactOS ping utility
* FILE:        base/applications/network/ping/ping.c
* PURPOSE:     Network test utility
* PROGRAMMERS:
*/
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS // eliminate deprecation warnings for VS2005
#endif

#define IDS_USAGE                       0
#define IDS_PING_WITH_BYTES             1
#define IDS_PING_STATISTICS             2
#define IDS_PACKETS_SENT_RECEIVED_LOST  3
#define IDS_APPROXIMATE_ROUND_TRIP      4
#define IDS_MIN_MAX_AVERAGE             5
#define IDS_NOT_ENOUGH_RESOURCES        6
#define IDS_UNKNOWN_HOST                7
#define IDS_SETSOCKOPT_FAILED           8
#define IDS_COULD_NOT_CREATE_SOCKET     9
#define IDS_COULD_NOT_INIT_WINSOCK      10
#define IDS_DEST_MUST_BE_SPECIFIED      11
#define IDS_BAD_PARAMETER               12
#define IDS_BAD_OPTION_FORMAT           13
#define IDS_BAD_OPTION                  14
#define IDS_BAD_VALUE_OPTION_L          15
#define IDS_REPLY_FROM                  16
#define IDS_DEST_UNREACHABLE            17
#define IDS_COULD_NOT_TRANSMIT          18
#define IDS_COULD_NOT_RECV              19
#define IDS_REQUEST_TIMEOUT             20
#define IDS_MS                          21
#define IDS_1MS                         22


#define WIN32_NO_STATUS
//#include <WinSock2.h>
#include <ws2tcpip.h>
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <winnls.h>
#include <wincon.h>
#define _INC_WINDOWS

#include <stdio.h>
#include <stdlib.h>
#pragma comment(lib,"ws2_32.lib")


#define NDEBUG

/* General ICMP constants */
#define ICMP_MINSIZE        8     /* Minimum ICMP packet size */
#define ICMP_MAXSIZE        65535 /* Maximum ICMP packet size */

/* ICMP message types */
#define ICMPMSG_ECHOREQUEST 8     /* ICMP ECHO request message */
#define ICMPMSG_ECHOREPLY   0     /* ICMP ECHO reply message */

#pragma pack(4)

/* IPv4 header structure */
typedef struct _IPv4_HEADER
{
    unsigned char IHL : 4;
    unsigned char Version : 4;
    unsigned char TOS;
    unsigned short Length;
    unsigned short Id;
    unsigned short FragFlags;
    unsigned char TTL;
    unsigned char Protocol;
    unsigned short Checksum;
    unsigned int SrcAddress;
    unsigned int DstAddress;
} IPv4_HEADER, *PIPv4_HEADER;

/* ICMP echo request/reply header structure */
typedef struct _ICMP_HEADER
{
    unsigned char Type;
    unsigned char Code;
    unsigned short Checksum;
    unsigned short Id;
    unsigned short SeqNum;
} ICMP_HEADER, *PICMP_HEADER;

typedef struct _ICMP_ECHO_PACKET
{
    ICMP_HEADER Icmp;
} ICMP_ECHO_PACKET, *PICMP_ECHO_PACKET;

#pragma pack(1)

BOOL                NeverStop;
BOOL                ResolveAddresses;
UINT                PingCount;
UINT                DataSize;   /* ICMP echo request data size */
BOOL                DontFragment;
ULONG               TTLValue;
ULONG               TOSValue;
ULONG               Timeout;
WCHAR               TargetName[256];
SOCKET              IcmpSock;
SOCKADDR_IN         Target;
WCHAR               TargetIP[16];
FD_SET              Fds;
TIMEVAL             Timeval;
UINT                CurrentSeqNum;
UINT                SentCount;
UINT                LostCount;
BOOL                MinRTTSet;
LARGE_INTEGER       MinRTT;     /* Minimum round trip time in microseconds */
LARGE_INTEGER       MaxRTT;
LARGE_INTEGER       SumRTT;
LARGE_INTEGER       AvgRTT;
LARGE_INTEGER       TicksPerMs; /* Ticks per millisecond */
LARGE_INTEGER       TicksPerUs; /* Ticks per microsecond */
LARGE_INTEGER       SentTime;
BOOL                UsePerformanceCounter;
HANDLE              hStdOutput;

#ifndef NDEBUG
/* Display the contents of a buffer */
static VOID DisplayBuffer(
    PVOID Buffer,
    DWORD Size)
{
    UINT i;
    PCHAR p;

    printf("Buffer (0x%p)  Size (0x%lX).\n", Buffer, Size);

    p = (PCHAR)Buffer;
    for (i = 0; i < Size; i++)
    {
        if (i % 16 == 0)
            printf("\n");
        printf("%02X ", (p[i]) & 0xFF);
    }
}
#endif /* !NDEBUG */

LPWSTR
MyLoadString(UINT uID)
{
    HRSRC hres;
    HGLOBAL hResData;
    WCHAR *pwsz;
    UINT string_num, i;

    hres = FindResourceW(NULL, MAKEINTRESOURCEW((LOWORD(uID) >> 4) + 1), RT_STRING);
    if (!hres) return NULL;

    hResData = LoadResource(NULL, hres);
    if (!hResData) return NULL;

    pwsz = LockResource(hResData);
    if (!pwsz) return NULL;

    string_num = uID & 15;
    for (i = 0; i < string_num; i++)
        pwsz += *pwsz + 1;

    return pwsz + 1;
}

void FormatOutput(UINT uID, ...)
{
    va_list valist;

    WCHAR Buf[1024];
    LPWSTR pBuf = Buf;
    LPWSTR Format;
    DWORD written;
    UINT DataLength;

    va_start(valist, uID);

    Format = MyLoadString(uID);
    if (!Format) return;

    DataLength = FormatMessage(FORMAT_MESSAGE_FROM_STRING, Format, 0, 0, Buf, \
        sizeof(Buf) / sizeof(WCHAR), &valist);

    if (!DataLength)
    {
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
            return;

        DataLength = FormatMessage(FORMAT_MESSAGE_FROM_STRING | \
            FORMAT_MESSAGE_ALLOCATE_BUFFER, \
            Format, 0, 0, (LPWSTR)&pBuf, 0, &valist);

        if (!DataLength)
            return;
    }

    WriteConsole(hStdOutput, pBuf, DataLength, &written, NULL);

    if (pBuf != Buf)
        LocalFree(pBuf);
}

/* Display usage information on screen */
static VOID Usage(VOID)
{
    FormatOutput(IDS_USAGE);
}

/* Reset configuration to default values */
static VOID Reset(VOID)
{
    LARGE_INTEGER PerformanceCounterFrequency;

    NeverStop = FALSE;
    ResolveAddresses = FALSE;
    PingCount = 4;
    DataSize = 32;
    DontFragment = FALSE;
    TTLValue = 128;
    TOSValue = 0;
    Timeout = 1000;
    UsePerformanceCounter = QueryPerformanceFrequency(&PerformanceCounterFrequency);

    if (UsePerformanceCounter)
    {
        /* Performance counters may return incorrect results on some multiprocessor
        platforms so we restrict execution on the first processor. This may fail
        on Windows NT so we fall back to GetCurrentTick() for timing */
        if (SetThreadAffinityMask(GetCurrentThread(), 1) == 0)
            UsePerformanceCounter = FALSE;

        /* Convert frequency to ticks per millisecond */
        TicksPerMs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000;
        /* And to ticks per microsecond */
        TicksPerUs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000000;
    }
    if (!UsePerformanceCounter)
    {
        /* 1 tick per millisecond for GetCurrentTick() */
        TicksPerMs.QuadPart = 1;
        /* GetCurrentTick() cannot handle microseconds */
        TicksPerUs.QuadPart = 1;
    }
}

/* Parse command line parameters */
static BOOL ParseCmdline(int argc, LPWSTR argv[])
{
    INT i;
    BOOL FoundTarget = FALSE, InvalidOption = FALSE;

    if (argc < 2)
    {
        Usage();
        return FALSE;
    }

    for (i = 1; i < argc; i++)
    {
        if (argv[i][0] == L'-' || argv[i][0] == L'/')
        {
            switch (argv[i][1])
            {
            case L't': NeverStop = TRUE; break;
            case L'a': ResolveAddresses = TRUE; break;
            case L'n':
                if (i + 1 < argc)
                    PingCount = wcstoul(argv[++i], NULL, 0);
                else
                    InvalidOption = TRUE;
                break;
            case L'l':
                if (i + 1 < argc)
                {
                    DataSize = wcstoul(argv[++i], NULL, 0);

                    if (DataSize > ICMP_MAXSIZE - sizeof(ICMP_ECHO_PACKET) - sizeof(IPv4_HEADER))
                    {
                        FormatOutput(IDS_BAD_VALUE_OPTION_L, ICMP_MAXSIZE - \
                            (int)sizeof(ICMP_ECHO_PACKET) - \
                            (int)sizeof(IPv4_HEADER));
                        return FALSE;
                    }
                }
                else
                    InvalidOption = TRUE;
                break;
            case L'f': DontFragment = TRUE; break;
            case L'i':
                if (i + 1 < argc)
                    TTLValue = wcstoul(argv[++i], NULL, 0);
                else
                    InvalidOption = TRUE;
                break;
            case L'v':
                if (i + 1 < argc)
                    TOSValue = wcstoul(argv[++i], NULL, 0);
                else
                    InvalidOption = TRUE;
                break;
            case L'w':
                if (i + 1 < argc)
                    Timeout = wcstoul(argv[++i], NULL, 0);
                else
                    InvalidOption = TRUE;
                break;
            case '?':
                Usage();
                return FALSE;
            default:
                FormatOutput(IDS_BAD_OPTION, argv[i]);
                return FALSE;
            }
            if (InvalidOption)
            {
                FormatOutput(IDS_BAD_OPTION_FORMAT, argv[i]);
                return FALSE;
            }
        }
        else
        {
            if (FoundTarget)
            {
                FormatOutput(IDS_BAD_PARAMETER, argv[i]);
                return FALSE;
            }
            else
            {
                wcscpy_s(TargetName, 256, argv[i]);
                FoundTarget = TRUE;
            }
        }
    }

    if (!FoundTarget)
    {
        FormatOutput(IDS_DEST_MUST_BE_SPECIFIED);
        return FALSE;
    }

    return TRUE;
}

/* Calculate checksum of data */
static WORD Checksum(PUSHORT data, UINT size)
{
    ULONG sum = 0;

    while (size > 1)
    {
        sum += *data++;
        size -= sizeof(USHORT);
    }

    if (size)
        sum += *(UCHAR*)data;

    sum = (sum >> 16) + (sum & 0xFFFF);
    sum += (sum >> 16);

    return (USHORT)(~sum);
}

/* Prepare to ping target */
static BOOL Setup(VOID)
{
    WORD     wVersionRequested;
    WSADATA  WsaData;
    INT      Status;
    ULONG    Addr;
    PHOSTENT phe;
    CHAR     aTargetName[256];

    wVersionRequested = MAKEWORD(2, 2);

    Status = WSAStartup(wVersionRequested, &WsaData);
    if (Status != 0)
    {
        FormatOutput(IDS_COULD_NOT_INIT_WINSOCK);
        return FALSE;
    }

    IcmpSock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
    if (IcmpSock == INVALID_SOCKET)
    {
        FormatOutput(IDS_COULD_NOT_CREATE_SOCKET, WSAGetLastError());
        return FALSE;
    }

    if (setsockopt(IcmpSock,
        IPPROTO_IP,
        IP_DONTFRAGMENT,
        (const char *)&DontFragment,
        sizeof(DontFragment)) == SOCKET_ERROR)
    {
        FormatOutput(IDS_SETSOCKOPT_FAILED, WSAGetLastError());
        return FALSE;
    }

    if (setsockopt(IcmpSock,
        IPPROTO_IP,
        IP_TTL,
        (const char *)&TTLValue,
        sizeof(TTLValue)) == SOCKET_ERROR)
    {
        FormatOutput(IDS_SETSOCKOPT_FAILED, WSAGetLastError());
        return FALSE;
    }


    if (!WideCharToMultiByte(CP_ACP, 0, TargetName, -1, aTargetName, \
        sizeof(aTargetName), NULL, NULL))
    {
        FormatOutput(IDS_UNKNOWN_HOST, TargetName);
        return FALSE;
    }

    ZeroMemory(&Target, sizeof(Target));
    phe = NULL;
    Addr = inet_addr(aTargetName);
    if (Addr == INADDR_NONE)
    {
        phe = gethostbyname(aTargetName);
        if (phe == NULL)
        {
            FormatOutput(IDS_UNKNOWN_HOST, TargetName);
            return FALSE;
        }

        CopyMemory(&Target.sin_addr, phe->h_addr, phe->h_length);
        Target.sin_family = phe->h_addrtype;
    }
    else
    {
        Target.sin_addr.s_addr = Addr;
        Target.sin_family = AF_INET;
    }


    swprintf(TargetIP, L"%d.%d.%d.%d", (int)Target.sin_addr.S_un.S_un_b.s_b1, \
        (int)Target.sin_addr.S_un.S_un_b.s_b2, \
        (int)Target.sin_addr.S_un.S_un_b.s_b3, \
        (int)Target.sin_addr.S_un.S_un_b.s_b4);
    CurrentSeqNum = 1;
    SentCount = 0;
    LostCount = 0;
    MinRTT.QuadPart = 0;
    MaxRTT.QuadPart = 0;
    SumRTT.QuadPart = 0;
    MinRTTSet = FALSE;
    return TRUE;
}

/* Close socket */
static VOID Cleanup(VOID)
{
    if (IcmpSock != INVALID_SOCKET)
        closesocket(IcmpSock);

    WSACleanup();
}

static VOID QueryTime(PLARGE_INTEGER Time)
{
    if (UsePerformanceCounter)
    {
        if (QueryPerformanceCounter(Time) == 0)
        {
            /* This should not happen, but we fall
            back to GetCurrentTick() if it does */
            Time->u.LowPart = (ULONG)GetTickCount();
            Time->u.HighPart = 0;

            /* 1 tick per millisecond for GetCurrentTick() */
            TicksPerMs.QuadPart = 1;
            /* GetCurrentTick() cannot handle microseconds */
            TicksPerUs.QuadPart = 1;

            UsePerformanceCounter = FALSE;
        }
    }
    else
    {
        Time->u.LowPart = (ULONG)GetTickCount();
        Time->u.HighPart = 0;
    }
}

static VOID TimeToMsString(LPWSTR String, LARGE_INTEGER Time)
{
    WCHAR         Convstr[40];
    LARGE_INTEGER LargeTime;
    LPWSTR ms;

    LargeTime.QuadPart = Time.QuadPart / TicksPerMs.QuadPart;

    _i64tow(LargeTime.QuadPart, Convstr, 10);
    wcscpy(String, Convstr);
    ms = MyLoadString(IDS_MS);
    wcscat(String, ms);
}

/* Locate the ICMP data and print it. Returns TRUE if the packet was good,
FALSE if not */
static BOOL DecodeResponse(PCHAR buffer, UINT size, PSOCKADDR_IN from)
{
    PIPv4_HEADER      IpHeader;
    PICMP_ECHO_PACKET Icmp;
    UINT              IphLength;
    WCHAR             Time[100];
    LARGE_INTEGER     RelativeTime;
    LARGE_INTEGER     LargeTime;
    WCHAR             Sign[2];
    WCHAR wfromIP[16];

    IpHeader = (PIPv4_HEADER)buffer;

    IphLength = IpHeader->IHL * 4;

    if (size  < IphLength + ICMP_MINSIZE)
    {
#ifndef NDEBUG
        printf("Bad size (0x%X < 0x%X)\n", size, IphLength + ICMP_MINSIZE);
#endif /* !NDEBUG */
        return FALSE;
    }

    Icmp = (PICMP_ECHO_PACKET)(buffer + IphLength);

    if (Icmp->Icmp.Type != ICMPMSG_ECHOREPLY)
    {
#ifndef NDEBUG
        printf("Bad ICMP type (0x%X should be 0x%X)\n", Icmp->Icmp.Type, ICMPMSG_ECHOREPLY);
#endif /* !NDEBUG */
        return FALSE;
    }

    if (Icmp->Icmp.Id != (USHORT)GetCurrentProcessId())
    {
#ifndef NDEBUG
        printf("Bad ICMP id (0x%X should be 0x%X)\n", Icmp->Icmp.Id, (USHORT)GetCurrentProcessId());
#endif /* !NDEBUG */
        return FALSE;
    }

    if (from->sin_addr.s_addr != Target.sin_addr.s_addr)
    {
#ifndef NDEBUG
        printf("Bad source address (%s should be %s)\n", inet_ntoa(from->sin_addr), inet_ntoa(Target.sin_addr));
#endif /* !NDEBUG */
        return FALSE;
    }

    QueryTime(&LargeTime);

    RelativeTime.QuadPart = (LargeTime.QuadPart - SentTime.QuadPart);

    if ((RelativeTime.QuadPart / TicksPerMs.QuadPart) < 1)
    {
        LPWSTR ms1;

        wcscpy(Sign, L"<");
        ms1 = MyLoadString(IDS_1MS);
        wcscpy(Time, ms1);
    }
    else
    {
        wcscpy(Sign, L"=");
        TimeToMsString(Time, RelativeTime);
    }


    swprintf(wfromIP, L"%d.%d.%d.%d", from->sin_addr.S_un.S_un_b.s_b1, \
        from->sin_addr.S_un.S_un_b.s_b2, \
        from->sin_addr.S_un.S_un_b.s_b3, \
        from->sin_addr.S_un.S_un_b.s_b4);
    FormatOutput(IDS_REPLY_FROM, wfromIP, \
        size - IphLength - (int)sizeof(ICMP_ECHO_PACKET), \
        Sign, Time, IpHeader->TTL);

    if (RelativeTime.QuadPart < MinRTT.QuadPart || !MinRTTSet)
    {
        MinRTT.QuadPart = RelativeTime.QuadPart;
        MinRTTSet = TRUE;
    }
    if (RelativeTime.QuadPart > MaxRTT.QuadPart)
        MaxRTT.QuadPart = RelativeTime.QuadPart;

    SumRTT.QuadPart += RelativeTime.QuadPart;

    return TRUE;
}

/* Send and receive one ping */
static BOOL Ping(VOID)
{
    INT                 Status;
    SOCKADDR            From;
    INT                 Length;
    PVOID               Buffer;
    UINT                Size;
    PICMP_ECHO_PACKET   Packet;

    /* Account for extra space for IP header when packet is received */
    Size = DataSize + 128;
    Buffer = GlobalAlloc(0, Size);
    if (!Buffer)
    {
        FormatOutput(IDS_NOT_ENOUGH_RESOURCES);
        return FALSE;
    }

    ZeroMemory(Buffer, Size);
    Packet = (PICMP_ECHO_PACKET)Buffer;

    /* Assemble ICMP echo request packet */
    Packet->Icmp.Type = ICMPMSG_ECHOREQUEST;
    Packet->Icmp.Code = 0;
    Packet->Icmp.Id = (USHORT)GetCurrentProcessId();
    Packet->Icmp.SeqNum = htons((USHORT)CurrentSeqNum);
    Packet->Icmp.Checksum = 0;

    /* Calculate checksum for ICMP header and data area */
    Packet->Icmp.Checksum = Checksum((PUSHORT)&Packet->Icmp, sizeof(ICMP_ECHO_PACKET) + DataSize);

    CurrentSeqNum++;

    /* Send ICMP echo request */

    FD_ZERO(&Fds);
    FD_SET(IcmpSock, &Fds);
    Timeval.tv_sec = Timeout / 1000;
    Timeval.tv_usec = Timeout % 1000;
    Status = select(0, NULL, &Fds, NULL, &Timeval);
    if ((Status != SOCKET_ERROR) && (Status != 0))
    {

#ifndef NDEBUG
        printf("Sending packet\n");
        DisplayBuffer(Buffer, sizeof(ICMP_ECHO_PACKET) + DataSize);
        printf("\n");
#endif /* !NDEBUG */

        Status = sendto(IcmpSock, Buffer, sizeof(ICMP_ECHO_PACKET) + DataSize,
            0, (SOCKADDR*)&Target, sizeof(Target));
        QueryTime(&SentTime);
        SentCount++;
    }
    if (Status == SOCKET_ERROR)
    {
        if (WSAGetLastError() == WSAEHOSTUNREACH)
            FormatOutput(IDS_DEST_UNREACHABLE);
        else
            FormatOutput(IDS_COULD_NOT_TRANSMIT, WSAGetLastError());
        GlobalFree(Buffer);
        return FALSE;
    }

    /* Expect to receive ICMP echo reply */
    FD_ZERO(&Fds);
    FD_SET(IcmpSock, &Fds);
    Timeval.tv_sec = Timeout / 1000;
    Timeval.tv_usec = Timeout % 1000;

    do {
        Status = select(0, &Fds, NULL, NULL, &Timeval);
        if ((Status != SOCKET_ERROR) && (Status != 0))
        {
            Length = sizeof(From);
            Status = recvfrom(IcmpSock, Buffer, Size, 0, &From, &Length);

#ifndef NDEBUG
            printf("Received packet\n");
            DisplayBuffer(Buffer, Status);
            printf("\n");
#endif /* !NDEBUG */
        }
        else
            LostCount++;
        if (Status == SOCKET_ERROR)
        {
            if (WSAGetLastError() != WSAETIMEDOUT)
            {
                FormatOutput(IDS_COULD_NOT_RECV, WSAGetLastError());
                GlobalFree(Buffer);
                return FALSE;
            }
            Status = 0;
        }

        if (Status == 0)
        {
            FormatOutput(IDS_REQUEST_TIMEOUT);
            GlobalFree(Buffer);
            return TRUE;
        }

    } while (!DecodeResponse(Buffer, Status, (PSOCKADDR_IN)&From));

    GlobalFree(Buffer);
    return TRUE;
}


/* Program entry point */
int wmain(int argc, LPWSTR argv[])
{
    UINT Count;
    WCHAR MinTime[20];
    WCHAR MaxTime[20];
    WCHAR AvgTime[20];

    hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);

    Reset();

    if ((ParseCmdline(argc, argv)) && (Setup()))
    {

        FormatOutput(IDS_PING_WITH_BYTES, TargetName, TargetIP, DataSize);

        Count = 0;
        while ((NeverStop) || (Count < PingCount))
        {
            Ping();
            Count++;
            if ((NeverStop) || (Count < PingCount))
                Sleep(Timeout);
        };

        Cleanup();

        /* Calculate avarage round trip time */
        if ((SentCount - LostCount) > 0)
            AvgRTT.QuadPart = SumRTT.QuadPart / (SentCount - LostCount);
        else
            AvgRTT.QuadPart = 0;

        /* Calculate loss percent */
        Count = SentCount ? (LostCount * 100) / SentCount : 0;

        if (!MinRTTSet)
            MinRTT = MaxRTT;

        TimeToMsString(MinTime, MinRTT);
        TimeToMsString(MaxTime, MaxRTT);
        TimeToMsString(AvgTime, AvgRTT);

        /* Print statistics */
        FormatOutput(IDS_PING_STATISTICS, TargetIP);
        FormatOutput(IDS_PACKETS_SENT_RECEIVED_LOST, \
            SentCount, SentCount - LostCount, LostCount, Count);


        /* Print approximate times or NO approximate times if 100% loss */
        if ((SentCount - LostCount) > 0)
        {
            FormatOutput(IDS_APPROXIMATE_ROUND_TRIP);
            FormatOutput(IDS_MIN_MAX_AVERAGE, MinTime, MaxTime, AvgTime);
        }
    }
    else
    {
        return 1;
    }
    return 0;
}

/* EOF */
园中猪吃菜
关注
专栏目录
实现ping命令
04-14
1、实验目的： 要求学生掌握Socket编程技术，以及ICMP协议 2、实验内容： i. 要求学生掌握利用Socket进行编程的技术 ii. 不能采用现有的工具，必须自己一步一步，根据协议进行操作 iii. 了解ping报文的格式和步骤，要求符合ICMP协议并组建报文 iv. 在一秒钟内，如果收到，则为成功，如果收不到，则失败 v. 必须采用图形界面，查看收到回应的结果 vi. 可以通过程序，查看子网中有哪些主机可以ping通
Ping命令的实现
qq_37409526的博客
06-03 2060
Ping （Packet Internet Groper）是一种因特网包探索器，用于测试网络连接量的程序。本文将基于 Socket 编程，实现一个基本的 Ping 命令程序。
ping 命令的实现
StormWangxhu的博客
03-20 3459
TTL值代表的是echo在网络存在的时间。 TTL值代表的是echo在网络存在的时间。 作用： 1.检测网络是否通畅 2.网络连接速度是否 OK 可用于分析和判定网络故障。 实现原理 ping属于哪一层？ping命令使用的tcp报文还是udp报文呢？ 答：PING是应用层直接使用网络层ICMP的一个例子，它没有通过运输层的TCP或UDP。 PING命令是使用网络层 ICMP协议实现的，那么ICMP是如何实现的对了解PING是至关重要的？ 过程： Ping命令就是发送ICMP的echo包，通过回
ping命令的实现
qq_38353700的博客
11-22 7009
/*注意：1，由于本人技术有限，所以如果你是技术的狂热追求者，我觉得你不用看我写的了，这是因为我很菜。。。我主要是帮助与我一样，想做一些事，但不知道从哪里做起的人的。 2，为了叙述简洁，以下内容可能并经不起推敲（可能还有错误），也有很多省略，所以，希望读者能够在看完本文后再看其他相应书籍，以对其深入的知识进行全面了解。 */ 一，前言为了判断与对方主机的连通性，不论是Linux系统还是Wind
用C语言实现Ping程序功能
08-11 1219
ping命令是用来查看网络上另一个主机系统的网络连接是否正常的一个工具。ping命令的工作原理是：向网络上的另一个主机系统发送ICMP报文，如果指定系统得到了报文，它将把报文一模一样地传回给发送者，这有点象潜水艇声纳系统中使用的发声装置。 例如，在Linux终端上执行pin
Ping命令实现的扩充
09-27
实验内容：Ping命令实现的扩充，在给定的Ping程序的基础上做如下功能扩充： ? -h 显示帮助信息 ? -b 允许ping一个广播地址，只用于IPv4 ? -t 设置ttl值，只用于IPv4 ? -q 安静模式。不显示每个收到的包的分析结果，...
ping命令实现
09-29
ICMP（Internet Control Message Protocol）Internet控制报文协议。它是TCP/IP协议簇的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。...
Ping命令实现的扩充_在给定的ping程序的基础做功能扩充, ping命令扩展-网络基础代码类资源
07-01
实验内容：Ping命令实现的扩充，在给定的Ping程序的基础上做如下功能扩充： ? -h 显示帮助信息 ? -b 允许ping一个广播地址，只用于IPv4 ? -t 设置ttl值，只用于IPv4 ? -q 安静模式。不显示每个收到的包的分析结果，...
VC++基于套接字的PING命令实现
05-16
内容索引:VC/C++源码,网络相关,PING,套接字　源代码较简单，适合初学者学习。这的原理是根据新建的原始套接字构造ICMP协议的ECHO数据头，然后分析返回的IP及ICMP的数据头。代码较简单，适合初学者参考。
wince6.0执行ping命令实现ICMP协议
01-24
本文将详细介绍如何在WinCE 6.0环境下，使用C#语言实现ping命令，以及涉及的关键知识点。 首先，我们需要理解ICMP协议。ICMP是一种用于网络诊断的协议，它允许设备发送错误报告和查询信息。在ping命令中，我们发送...
C语言实现PING命令
12-17
C实现PING命令，可以控制超时时间，可以用
ping程序的实现
03-02
ping程序的linux实现，自己编写的代码，部分参考了《unix网编编程》
C++实现ping命令的功能(Windows)
06-23
C++实现ping命令的功能(Windows)，使用WinSock2.h借助Windows API实现ping命令已经域名解析功能。
python实现ping命令
05-10
python实现ping命令。python实现ping命令。python实现ping命令
Ping程序的设计与实现
05-26
广工计算机网络课设； 1.已知参数：目的节点IP地址或主机名 2.设计要求：通过原始套接字编程，模拟Ping命令，实现其基本功能，即输入一个IP地址或一段IP地址的范围，分别测试其中每个IP地址所对应主机的可达性，并返回耗时、生存时间等参数，并统计成功发送和回送的Ping报文。 2.1初始化Windows Sockets网络环境； 2.2解析命令行参数，构造目的端socket地址； 2.3定义IP、ICMP报文； 2.4接收ICMP差错报文并进行解析。 3. 程序实现主要用到Java网络包中的类InetAddress。
ping程序实现
tuyerv的博客
09-24 906
&#13; &#13; 大部分人用ping命令只是作为查看另一个系统的网络连接是否正常的一种简单方法。在这篇文章中，作者将介绍如何用C语言编写一个模拟ping命令功能的程序。&#13; ping命令是用来查看网络上另一个主机系统的网络连接是否正常的一个工具。ping命令的工作原理是：向网络上的另一个主机系统发送ICMP报文，如果指定系统得到了报文，它将把报文一模一样地传...
ping命令实作
qq_46665939的博客
12-02 893
ping命令实作： 提示：这里可以添加学习目标 例如：一周掌握 Java 入门知识 ping重交的web服务器： 字节数据：一些无用的数据，仅仅测试是否可以ping通。 时间：ping数据包是所花费的时间。 TTL：time to live 存活时间，一般经过一个路由或节点TTL减一，为零时数据包会被抛弃。 ping/?各项命令进行实际使用： 各项命令 实际使用 ping -i TTL ping -r count 疑惑&&问题： ...
自己实现一个 ping 命令
道阳
01-01 3149
目录基础协议基础套接字基础传输层 Stream 和 Datagram Socket网络层 Raw Socket数据链接层 Packet Socket模拟实现 PingICMP 协议实现参考 为了加深自己对计算机网络的理解, 想自己实现一些操作系统提供的网络工具, 于是先从 ping 开始 首先, ping 命令的作用是检测两个网络设备在 TCP/IP 网络下是否能连通. 其底层基于 ICMP ...
网络-ICMP协议、Ping命令实现与ICMP攻击
关注网络安全、云原生安全
12-14 5500
简介 ICMP（Internet Control Message Protocol，网际控制报文协议）是TCP/IP协议簇的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。 报文格式 ICMP报文分为两类：一类通知出错原因 ，一类用于诊断查询。 ICMP报文格式 类型：占一字节，标识ICMP报文的类型，从类型值来看ICMP报文可以分为两大类。第一类是取.
窗口界面PING命令实现教程与分析
1. PING命令基础: PING（Packet Internet Groper）是一种网络诊断工具，主要用于测试数据包是否能够通过IP网络到达特定主机。它通过发送ICMP（Internet Control Message Protocol）回显请求消息到目标主机，并等待...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值