ping程序的设计与实现广工计网课程设计Ping程序设计与实现(Java)

2021-02-12 22:44:05

【实例简介】

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程序的实现

└── ping程序的实现

├── Ping.jar

├── myPing

│   ├── bin

│   │   └── com

│   │   └── zhusien

│   │   └── ping

│   │   ├── Ping.class

│   │   ├── Ping.jardesc

│   │   ├── PingFrame$1.class

│   │   ├── PingFrame$2.class

│   │   ├── PingFrame$3.class

│   │   ├── PingFrame.class

│   │   └── PingRunnable.class

│   └── src

│   └── com

│   └── zhusien

│   └── ping

│   ├── Ping.jardesc

│   ├── Ping.java

│   ├── PingFrame.java

│   └── PingRunnable.java

└── 实验报告.doc

10 directories, 13 files

更多相关内容
Ping程序的设计与实现课程设计.wps
2021-04-26 23:39:39

Ping程序的设计与实现课程设计

收起

计算机网络课程设计之Tracert与Ping程序设计与实现

千次阅读 2022-01-15 14:36:16

Tracert Ping Windows

前言

本实验主要是应用ICMP报文实现Tracert和Ping功能，主要用的是Windows中的库，所以程序只能在Windows下运行。
在博客结束的地方，附上C/C++的Tracert源码和Ping源码，两个源码来自指导书和网络。
我的程序也改编自这两个源码

白嫖容易，创作不易，本文原创，转载请注明！！！
源码和可运行程序：
链接：https://pan.baidu.com/s/1A9KctmpP2JJgyW2wLrehIg
提取码：Lin2

Qt入门系列：
Qt学习之C++基础
 Qt学习之Qt安装
 Qt学习之Qt基础入门(上)
Qt学习之Qt基础入门(中)
Qt学习之Qt基础入门(下)

创作不易，整个课程设计程序3000多行代码，所有实验都写在了一个程序中，时间有限，能力不足，转载望注明！！！
本文链接
个人博客：https://ronglin.fun/archives/266
PDF链接：见博客网站
CSDN: https://blog.csdn.net/RongLin02/article/details/122510039

实验题目

Tracert 与 Ping 程序设计与实现

实验目的

了解 Tracert 程序的实现原理
了解 Ping 程序的实现原理
参照附录，了解 Tracert 程序的实现原理，并调试通过。然后参考 Tracert 程序和教材 4.4.2 节，编写一个 Ping 程序，并能测试本局域网的所有机器是否在线，例如 QuickPing 程序。

总体设计

（含背景知识或基本原理与算法、或模块介绍、设计步骤等）
先简单的说一下原理，就是不论是Tracert还是Ping，都是利用了IPPROTO_ICMP类型的数据报，格式如下：

//SOCK_RAW表示原始套接字，即不是TCP也不是UDP
SOCKET sockRaw=WSASocket(AF_INET,SOCK_RAW,IPPROTO_ICMP,NULL,0,WSA_FLAG_OVERLAPPED);

然后通过修改其中的部分数据来实现对应的功能

Tracert

Tracert的主要功能就是获取数据报所经过的路由器线路
Tracert的基本原理如下，构造一个数据报，将它的初始TTL值设置为1，这样的话，主机将数据发出到第一个路由器1号，然后这个路由器1号将TTL-1，TTL=0，然后路由器1号就把数据报丢弃了，然后向源主机发送一个ICMP时间超过差错报告报文。然后主机就通过解析回传的数据就知道了路由器1号的信息。然后再构造一个数据报，，将它的TTL值设置为2，这样数据就如此流向，主机->路由器1号->路由器2号，然后路由器2号把数据丢弃，发送差错报告，主机就是知道了路由器2号的信息。如此往复直到数据到达了目的主机。
在我的程序设计中，用一个单独的线程完成Tracert功能，同时在线程中的run()方法中构造套接字，创建连接，得到结果，分析结果，直到到达目的地址。用单独的线程主要是因为在反复发送接收数据时需要较长的时间。
同时根据指导书上的Tracert源代码构造以下方法

//对数据包进行解码
bool MyTracert::DecodeIcmpResponse(char * pBuf,int iPacketSize,DECODE_RESULT &DecodeResult,BYTE ICMP_ECHO_REPLY,BYTE ICMP_TIMEOUT)
//计算校验和
USHORT MyTracert::checksum(USHORT *pBuf,int iSize)

同时还有若干槽函数和setter getter方法就不贴出来了

Ping

ping的原理也是利用ICMP数据报文，主要就是检测连通性
PING的源码我是从网上找的MSDN的源码，思路如下：
初始化WSADATA ->构造ICMP数据报->创建原始套接字 ->设置发送/接受超时时间 -> 用sendto发送ICMP报文->用recvfrom接受返回的数据 -> 分析数据 ->将结果返回给前端界面

主要设计的方法如下：

    //填充ICMP数据报
    void fill_icmp_data(char *, int);
    //计算校验和
    USHORT checksum(USHORT *, int);
    //解析返回的数据报
    bool decode_resp(char *,int,struct sockaddr_in *);

详细设计

（含主要的数据结构、程序流程图、关键代码等）
在这里插入图片描述

Tracert

界面上图左侧
这个主要是要用到3个参数，第一个是要Tracert的IP地址和域名，第二个是要设置的超时时间，第三个是设置转发的节点

IP地址和域名

这个是根据用户输入，然后用Windows API提供的方法解析ip和域名，部分代码如下：

bool MyTracert::isLegalIP(QString ip)
{
    WSADATA* wsa =(WSADATA*) malloc(sizeof(WSADATA));
    WSAStartup(MAKEWORD(2,2),wsa);
    bool flag = true;
    //得到 IP 地址
    u_long ulDestIP=inet_addr(ip.toUtf8().data());
    //转换不成功时按域名解析
    if(ulDestIP==INADDR_NONE)
    {
        hostent * pHostent=gethostbyname(ip.toUtf8().data());
        if(!pHostent)
        {
            flag = false;
        }
    }
    free(wsa);
    return flag;
}

通过此方法就知道了用户输入的ip是否合法

超时时间

超时时间主要是用在创建套接字的时候，在Windows API中用法如下，其中变量iTimeout(:int)就是设置超时时间

    //接收超时 (用于任意类型、任意状态套接口的设置选项值)
    setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char *)&iTimeout,sizeof(iTimeout));
    //发送超时
    setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char *)&iTimeout,sizeof(iTimeout));

当接收时间/发送时间超过设定的值的时候，就会出现错误WSAGetLastError()==WSAETIMEDOUT

转发节点个数

这个比较简单了，就是设置最大跳站数，就是最多允许查看的转发的路由器的节点数量

int DEF_MAX_HOP=30; //最大跳站数

然后点击开始就启动线程，然后将结果通过槽函数返回给前端界面

Ping

界面上图右侧
这个主要是要用到4个参数，第一个是IP地址的开始值，第二个是IP地址结束值，第三个是设置超时时间，第四个设置ping的次数

IP范围

范围就是从开始到结束，同时只允许用户修改点分十进制的最后一部分，同时需要在前端界面中判断用户输入的是否正确，就是开始值<=结束值，同时根据用户输入的范围，构造出来一个IPList，然后传到MyPing类中。

超时时间

原理同Tracert

ping次数

这个就是对同一个ip地址发送ICMP数据报的次数，发送一次解析一次，如果解析成功(Ping通)，返回结果，如果解析失败(无数据/超时/无法解析),则再次发送数据报。

同时以上也写在了一个子线程中，以防长时间导致前端界面无响应。

实验结果与分析

结果如下：
在这里插入图片描述

同时启动两个功能
左侧开始输出结果，因为超时时间问题，返回的结果都是超时
右侧根据输入开始ping每一个结果然后输出结果
在这里插入图片描述
运行结果如上
左侧经过17跳之后成功的到达，并且显示的域名对应的ip地址
右侧从IP：39.101.201.10 到IP：39.101.201.30然后分别输出结果
通过用cmd的Tracert指令和Ping指令检验，结果正确

小结与心得体会

对ICMP有了更深入的理解，同时常用的ping功能也知道了它的实现原理，获益匪浅，对计算机网络中网络层有了更深入的认识。
=w=

附

Tracert源码

#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
using namespace std;
#pragma comment(lib, "Ws2_32.lib")
//IP 报头
typedef struct
{
    unsigned char hdr_len:4; //4 位头部长度
    unsigned char version:4; //4 位版本号
    unsigned char tos; //8 位服务类型
    unsigned short total_len; //16 位总长度
    unsigned short identifier; //16 位标识符
    unsigned short frag_and_flags; //3 位标志加 13 位片偏移
    unsigned char ttl; //8 位生存时间
    unsigned char protocol; //8 位上层协议号
    unsigned short checksum; //16 位校验和
    unsigned long sourceIP; //32 位源 IP 地址
    unsigned long destIP; //32 位目的 IP 地址
} IP_HEADER;
//ICMP 报头
typedef struct
{
    BYTE type; //8 位类型字段
    BYTE code; //8 位代码字段
    USHORT cksum; //16 位校验和
    USHORT id; //16 位标识符
    USHORT seq; //16 位序列号
} ICMP_HEADER;
//报文解码结构
typedef struct
{
    USHORT usSeqNo; //序列号
    DWORD dwRoundTripTime; //往返时间
    in_addr dwIPaddr; //返回报文的 IP 地址
} DECODE_RESULT;
//计算网际校验和函数
USHORT checksum(USHORT *pBuf,int iSize)
{
    unsigned long cksum=0;
    while(iSize>1)
    {
        cksum+=*pBuf++;
        iSize-=sizeof(USHORT);
    }
    if(iSize)
    {
        cksum+=*(UCHAR *)pBuf;
    }
    cksum=(cksum>>16)+(cksum&0xffff);
    cksum+=(cksum>>16);
    return (USHORT)(~cksum);
}
//对数据包进行解码
BOOL DecodeIcmpResponse(char * pBuf,int iPacketSize,DECODE_RESULT &DecodeResult,BYTE ICMP_ECHO_REPLY,BYTE ICMP_TIMEOUT)
{
//检查数据报大小的合法性
    IP_HEADER* pIpHdr = (IP_HEADER*)pBuf;
    int iIpHdrLen = pIpHdr->hdr_len * 4;
    if (iPacketSize < (int)(iIpHdrLen+sizeof(ICMP_HEADER)))
        return FALSE;
//根据 ICMP 报文类型提取 ID 字段和序列号字段
    ICMP_HEADER *pIcmpHdr=(ICMP_HEADER *)(pBuf+iIpHdrLen);
    USHORT usID,usSquNo;
    if(pIcmpHdr->type==ICMP_ECHO_REPLY) //ICMP 回显应答报文
    {
        usID=pIcmpHdr->id; //报文 ID
        usSquNo=pIcmpHdr->seq; //报文序列号
    }
    else if(pIcmpHdr->type==ICMP_TIMEOUT)//ICMP 超时差错报文
    {
        char * pInnerIpHdr=pBuf+iIpHdrLen+sizeof(ICMP_HEADER); //载荷中的 IP 头
        int iInnerIPHdrLen=((IP_HEADER *)pInnerIpHdr)->hdr_len*4; //载荷中的 IP 头长
        ICMP_HEADER * pInnerIcmpHdr=(ICMP_HEADER *)(pInnerIpHdr+iInnerIPHdrLen);//载荷中的 ICMP 头
        usID=pInnerIcmpHdr->id; //报文 ID
        usSquNo=pInnerIcmpHdr->seq; //序列号
    }
    else
    {
        return false;
    }
//检查 ID 和序列号以确定收到期待数据报
    if(usID!=(USHORT)GetCurrentProcessId()||usSquNo!=DecodeResult.usSeqNo)
    {
        return false;
    }
//记录 IP 地址并计算往返时间
    DecodeResult.dwIPaddr.s_addr=pIpHdr->sourceIP;
    DecodeResult.dwRoundTripTime=GetTickCount()-DecodeResult.dwRoundTripTime;
//处理正确收到的 ICMP 数据报
    if (pIcmpHdr->type == ICMP_ECHO_REPLY ||pIcmpHdr->type == ICMP_TIMEOUT)
    {
//输出往返时间信息
        if(DecodeResult.dwRoundTripTime)
            cout<<" "<<DecodeResult.dwRoundTripTime<<"ms"<<flush;
        else
            cout<<" "<<"<1ms"<<flush;
    }
    return true;
}
int main()
{
//初始化 Windows sockets 网络环境
    WSADATA wsa;
    WSAStartup(MAKEWORD(2,2),&wsa);
    char IpAddress[255];
    cout<<"请输入一个 IP 地址或域名：";
    cin>>IpAddress;
//得到 IP 地址
    u_long ulDestIP=inet_addr(IpAddress);
//转换不成功时按域名解析
    if(ulDestIP==INADDR_NONE)
    {
        hostent * pHostent=gethostbyname(IpAddress);
        if(pHostent)
        {
            ulDestIP=(*(in_addr*)pHostent->h_addr).s_addr;
        }
        else
        {
            cout<<"输入的 IP 地址或域名无效!"<<endl;
            WSACleanup();
            return 0;
        }
    }
    cout<<"Tracing route to "<<IpAddress<<" with a maximum of 30 hops.\n"<<endl;
//填充目地端 socket 地址
    sockaddr_in destSockAddr;
    ZeroMemory(&destSockAddr,sizeof(sockaddr_in));
    destSockAddr.sin_family=AF_INET; //地址族 使用 IPv4 进行通信
    destSockAddr.sin_addr.s_addr=ulDestIP; // 32位的IP地址
//创建原始套接字 详细说明：https://www.cnblogs.com/hgwang/p/6118634.html
    SOCKET sockRaw=WSASocket(AF_INET,SOCK_RAW,IPPROTO_ICMP,NULL,0,
                             WSA_FLAG_OVERLAPPED); //SOCK_RAW表示原始套接字，即不是TCP也不是UDP
//超时时间
    int iTimeout=3000;
//接收超时 (用于任意类型、任意状态套接口的设置选项值)
    setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char *)&iTimeout,sizeof(iTimeout));
//发送超时
    setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char *)&iTimeout,sizeof(iTimeout));
//构造 ICMP 回显请求消息，并以 TTL 递增的顺序发送报文
//ICMP 类型字段
    const BYTE ICMP_ECHO_REQUEST=8; //请求回显
    const BYTE ICMP_ECHO_REPLY=0; //回显应答
    const BYTE ICMP_TIMEOUT=11; //传输超时
//其他常量定义
    const int DEF_ICMP_DATA_SIZE=32; //ICMP 报文默认数据字段长度
    const int MAX_ICMP_PACKET_SIZE=1024;//ICMP 报文最大长度（包括报头）
    const DWORD DEF_ICMP_TIMEOUT=3000; //回显应答超时时间
    const int DEF_MAX_HOP=30; //最大跳站数
//填充 ICMP 报文中每次发送时不变的字段
    char IcmpSendBuf[sizeof(ICMP_HEADER)+DEF_ICMP_DATA_SIZE];//发送缓冲区
    memset(IcmpSendBuf, 0, sizeof(IcmpSendBuf)); //初始化发送缓冲区
    char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE]; //接收缓冲区
    memset(IcmpRecvBuf, 0, sizeof(IcmpRecvBuf)); //初始化接收缓冲区
    ICMP_HEADER * pIcmpHeader=(ICMP_HEADER*)IcmpSendBuf;
    pIcmpHeader->type=ICMP_ECHO_REQUEST; //类型为请求回显
    pIcmpHeader->code=0; //代码字段为 0
    pIcmpHeader->id=(USHORT)GetCurrentProcessId(); //ID 字段为当前进程号
    memset(IcmpSendBuf+sizeof(ICMP_HEADER),'E',DEF_ICMP_DATA_SIZE);//数据字段
    USHORT usSeqNo=0; //ICMP 报文序列号
    int iTTL=1; //TTL 初始值为 1
    BOOL bReachDestHost=FALSE; //循环退出标志
    int iMaxHot=DEF_MAX_HOP; //循环的最大次数
    DECODE_RESULT DecodeResult; //传递给报文解码函数的结构化参数
    while(!bReachDestHost&&iMaxHot--)
    {
//设置 IP 报头的 TTL 字段
        setsockopt(sockRaw,IPPROTO_IP,IP_TTL,(char *)&iTTL,sizeof(iTTL));
        cout<<iTTL<<flush; //输出当前序号
//填充 ICMP 报文中每次发送变化的字段
        ((ICMP_HEADER *)IcmpSendBuf)->cksum=0; //校验和先置为 0
        ((ICMP_HEADER *)IcmpSendBuf)->seq=htons(usSeqNo++); //填充序列号
        ((ICMP_HEADER *)IcmpSendBuf)->cksum=checksum((USHORT *)IcmpSendBuf,
                                            sizeof(ICMP_HEADER)+DEF_ICMP_DATA_SIZE); //计算校验和
//记录序列号和当前时间
        DecodeResult.usSeqNo=((ICMP_HEADER*)IcmpSendBuf)->seq; //当前序号
        DecodeResult.dwRoundTripTime=GetTickCount(); //当前时间
//发送 TCP 回显请求信息
        sendto(sockRaw,IcmpSendBuf,sizeof(IcmpSendBuf),0,(sockaddr*)&destSockAddr,sizeof(destSockAddr));
//接收 ICMP 差错报文并进行解析处理
        sockaddr_in from; //对端 socket 地址
        int iFromLen=sizeof(from); //地址结构大小
        int iReadDataLen; //接收数据长度
        while(1)
        {
//接收数据
            iReadDataLen=recvfrom(sockRaw,IcmpRecvBuf,MAX_ICMP_PACKET_SIZE,0,(sockaddr*)&from,&iFromLen);
            if(iReadDataLen!=SOCKET_ERROR)//有数据到达
            {
//对数据包进行解码
                if(DecodeIcmpResponse(IcmpRecvBuf,iReadDataLen,DecodeResult,ICMP_ECHO_REPLY,ICMP_TIMEOUT))
                {
//到达目的地，退出循环
                    if(DecodeResult.dwIPaddr.s_addr==destSockAddr.sin_addr.s_addr)
                        bReachDestHost=true;
//输出 IP 地址
                    cout<<'\t'<<inet_ntoa(DecodeResult.dwIPaddr)<<endl;
                    break;
                }
            }
            else if(WSAGetLastError()==WSAETIMEDOUT) //接收超时，输出*号
            {
                cout<<" *"<<'\t'<<"Request timed out."<<endl;
                break;
            }
            else
            {
                break;
            }
        }
        iTTL++; //递增 TTL 值
    }
    return 0;
}

Ping源码

/******************************************************************************\
* ping.c - Simple ping utility using SOCK_RAW
*
* This is a part of the Microsoft Source Code Samples.
* Copyright 1996-1997 Microsoft Corporation.
* All rights reserved.
* This source code is only intended as a supplement to
* Microsoft Development Tools and/or WinHelp documentation.
* See these sources for detailed information regarding the
* Microsoft samples programs.
\******************************************************************************/

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

#define ICMP_ECHO 8
#define ICMP_ECHOREPLY 0

#define ICMP_MIN 8                                           // minimum 8 byte icmp packet (just header)

/* The IP header */
typedef struct iphdr
{
    unsigned int h_len:4; // length of the header
    unsigned int version:4; // Version of IP
    unsigned char tos; // Type of service
    unsigned short total_len; // total length of the packet
    unsigned short ident; // unique identifier
    unsigned short frag_and_flags; // flags
    unsigned char ttl;
    unsigned char proto; // protocol (TCP, UDP etc)
    unsigned short checksum; // IP checksum
    unsigned int sourceIP;
    unsigned int destIP;
} IpHeader;

//
// ICMP header
//
typedef struct _ihdr
{
    BYTE i_type;     //消息类型
    BYTE i_code;     //代码  /* type sub code */
    USHORT i_cksum;  //校验和
    USHORT i_id;     //ID号
    USHORT i_seq;    //序列号
    ULONG timestamp; //时间戳  /* This is not the std header, but we reserve space for time */
} IcmpHeader;        //ICMP报文  包括报头和数据

#define STATUS_FAILED 0xFFFF
#define DEF_PACKET_SIZE 32
#define MAX_PACKET 1024

#define xmalloc(s) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(s))
#define xfree(p) HeapFree (GetProcessHeap(),0,(p))

void fill_icmp_data(char *, int);
USHORT checksum(USHORT *, int);
void decode_resp(char *,int,struct sockaddr_in *);

int main(int argc, char **argv)
{
    WSADATA wsaData;
    SOCKET sockRaw;
    struct sockaddr_in dest;
    struct hostent * hp;
    int bread,datasize;
    int timeout = 1000;
    char *dest_ip;
    char *icmp_data;
    char *recvbuf;
    unsigned int addr=0;
    USHORT seq_no = 0;
    struct sockaddr_in from;
    int fromlen = sizeof(from);

    if (WSAStartup(MAKEWORD(2,1),&wsaData) != 0)
    {
        fprintf(stderr,"WSAStartup failed: %d\n",GetLastError());
        ExitProcess(STATUS_FAILED);
    }

    /*
    为了使用发送接收超时设置(即设置SO_RCVTIMEO, SO_SNDTIMEO)，
    //    必须将标志位设为WSA_FLAG_OVERLAPPED !
    */
    sockRaw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,WSA_FLAG_OVERLAPPED);                    //建立一个原始套接字
    //sockRaw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,0);

    if (sockRaw == INVALID_SOCKET)
    {
        fprintf(stderr,"WSASocket() failed: %d\n",WSAGetLastError());
        ExitProcess(STATUS_FAILED);
    }

    timeout = 1000;   //设置接收超时时间
    bread = setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout, sizeof(timeout)); //RECVTIMEO是接收超时时间
    if(bread == SOCKET_ERROR)
    {
        fprintf(stderr,"failed to set recv timeout: %d\n",WSAGetLastError());
        ExitProcess(STATUS_FAILED);
    }

    timeout = 1000;   //设置发送超时时间
    bread = setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char*)&timeout, sizeof(timeout)); //SNDTIMEO是发送超时时间
    if(bread == SOCKET_ERROR)
    {
        fprintf(stderr,"failed to set send timeout: %d\n",WSAGetLastError());
        ExitProcess(STATUS_FAILED);
    }
    memset(&dest,0,sizeof(dest));            //目标地址清零

    hp = gethostbyname("www.baidu.com");      //通过域名或者主机名获取IP地址
    if (!hp)  //失败返回NULL
    {
        ExitProcess(STATUS_FAILED);
    }
    else
    {
        addr = inet_addr("14.215.177.37");    //www.baidu.com的ip地址
    }

    if ((!hp) && (addr == INADDR_NONE))        //既不是域名也不是点分十进制的IP地址
    {
        ExitProcess(STATUS_FAILED);
    }

    if (hp != NULL)                           //获取的是域名
        memcpy(&(dest.sin_addr),hp->h_addr,hp->h_length);   //从hostent得到的对方ip地址
    else
        dest.sin_addr.s_addr = addr;

    if (hp)
        dest.sin_family = hp->h_addrtype;    //sin_family不是一定只能填AF_INET吗？
    else
        dest.sin_family = AF_INET;

        addr = inet_addr("39.101.201.13");
    dest.sin_addr.s_addr = addr;
        //addr = inet_addr("14.215.177.37");

    dest_ip = inet_ntoa(dest.sin_addr);        //目标IP地址

    datasize = DEF_PACKET_SIZE;             //ICMP包数据大小设定为32

    datasize += sizeof(IcmpHeader);         //另外加上ICMP包的包头 其实包头占12个字节

    icmp_data = (char *)xmalloc(MAX_PACKET);//发送icmp_data数据包内存
    recvbuf = (char *)xmalloc(MAX_PACKET);  //存放接收到的数据

    if (!icmp_data)                         //分配内存
    {
        ExitProcess(STATUS_FAILED);
    }

    memset(icmp_data,0,MAX_PACKET);
    fill_icmp_data(icmp_data,datasize);         //只填充了ICMP包

    fprintf(stdout,"\nPinging %s ....\n\n",dest_ip);

    while(1)
    {
        int bwrote;

        ((IcmpHeader*)icmp_data)->i_cksum = 0;
        ((IcmpHeader*)icmp_data)->timestamp = GetTickCount(); //时间戳

        ((IcmpHeader*)icmp_data)->i_seq = seq_no++;           //ICMP的序列号
        ((IcmpHeader*)icmp_data)->i_cksum = checksum((USHORT*)icmp_data, datasize);   //icmp校验位

        //下面这个函数的问题是 发送数据只是ICMP数据包，而接收到的数据时包含ip头的 也就是发送和接收不对等
        //问题是sockRaw 设定了协议为 IPPROTO_ICMP
        bwrote = sendto(sockRaw,icmp_data,datasize,0,(struct sockaddr*)&dest, sizeof(dest));
        if (bwrote == SOCKET_ERROR)
        {
            if (WSAGetLastError() == WSAETIMEDOUT)     //发送时间超时
            {
                printf("timed out\n");
                continue;
            }

            fprintf(stderr,"sendto failed: %d\n",WSAGetLastError());
            ExitProcess(STATUS_FAILED);
        }

        if (bwrote < datasize )
        {
            fprintf(stdout,"Wrote %d bytes\n",bwrote);
        }

        bread = recvfrom(sockRaw,recvbuf,MAX_PACKET,0,(struct sockaddr*)&from, &fromlen);
        if (bread == SOCKET_ERROR)
        {
            if (WSAGetLastError() == WSAETIMEDOUT)
            {
                printf("timed out\n");
                continue;
            }
            fprintf(stderr,"recvfrom failed: %d\n",WSAGetLastError());
            ExitProcess(STATUS_FAILED);
        }
        decode_resp(recvbuf,bread,&from);

        Sleep(1000);
    }

    WSACleanup();
    system("pause");

    return 0;
}

/*
The response is an IP packet. We must decode the IP header to locate
the ICMP data
*/
void decode_resp(char *buf, int bytes,struct sockaddr_in *from)
{
    IpHeader *iphdr;
    IcmpHeader *icmphdr;
    unsigned short iphdrlen;

    iphdr = (IpHeader *)buf;      //接收到的数据就是原始的IP数据报

    iphdrlen = iphdr->h_len * 4 ; // number of 32-bit words *4 = bytes

    if (bytes < iphdrlen + ICMP_MIN)
    {
        printf("Too few bytes from %s\n",inet_ntoa(from->sin_addr));
    }

    icmphdr = (IcmpHeader*)(buf + iphdrlen);

    if(icmphdr->i_type == 3)
    {
        printf("network unreachable -- Response from %s.\n",inet_ntoa(from->sin_addr));
        return ;
    }

    if (icmphdr->i_id != (USHORT)GetCurrentProcessId())
    {
        fprintf(stderr,"someone else's packet!\n");
        return ;
    }
    printf("%d bytes from %s:",bytes, inet_ntoa(from->sin_addr));
    printf(" icmp_seq = %d ",icmphdr->i_seq);
    printf(" time: %d ms ",GetTickCount()-icmphdr->timestamp);
    printf(" ttl: %d",iphdr->ttl);
    printf("\n");
}

//完成ICMP的校验
USHORT checksum(USHORT *buffer, int size)
{
    unsigned long cksum=0;

    while(size >1)
    {
        cksum+=*buffer++;
        size -=sizeof(USHORT);
    }

    if(size )
    {
        cksum += *(UCHAR*)buffer;
    }

    cksum = (cksum >> 16) + (cksum & 0xffff);
    cksum += (cksum >>16);
    return (USHORT)(~cksum);
}

/*
Helper function to fill in various stuff in our ICMP request.
*/
void fill_icmp_data(char * icmp_data, int datasize)
{

    IcmpHeader *icmp_hdr;
    char *datapart;

    icmp_hdr = (IcmpHeader*)icmp_data;

    icmp_hdr->i_type = ICMP_ECHO;                   //ICMP_ECHO要求收到包的主机回复此ICMP包
    icmp_hdr->i_code = 0;
    icmp_hdr->i_id = (USHORT)GetCurrentProcessId(); //id填当前进程的id
    icmp_hdr->i_cksum = 0;
    icmp_hdr->i_seq = 0;

    datapart = icmp_data + sizeof(IcmpHeader);
    //
    // Place some junk in the buffer.
    //
    memset(datapart,'E', datasize - sizeof(IcmpHeader));  //填充了一些废物
}

收起

展开全文

Tracert与Ping程序设计与实现
2018-01-13 14:38:32

计算机网络课程设计，利用socket套接字编写出ping程序，测试本局域网的当前所有机器是否在线

收起

计算机网络
计算机网络基础课程设计Ping程序的实现.doc
2021-04-26 23:46:43

计算机网络基础课程设计Ping程序的实现

收起
ping程序的设计与实现.pdf
2015-01-05 23:38:49

ping程序的设计与实现.pdf 可以实现ping程序，课程设计用。

收起
Ping程序的设计与实现
2016-05-26 13:45:08

2.设计要求：通过原始套接字编程，模拟Ping命令，实现其基本功能，即输入一个IP地址或一段IP地址的范围，分别测试其中每个IP地址所对应主机的可达性，并返回耗时、生存时间等参数，并统计成功发送和回送的Ping报文。...

收起
ping程序的设计与实现
2012-06-24 20:31:59

计算机网络课程设计 ping程序的设计与实现 java版

收起

计算机网络课程设计之Tracert与Ping 程序设计与实现

千次阅读 多人点赞 2018-12-28 15:49:45

二、实验部分：Tracert 与 Ping 程序设计与实现 参照附录 2，了解 Tracert 程序的实现原理，并调试通过。然后参考 Tracert 程序和教材 4.4.2 节，编写一个 Ping 程序，并能测试本局域网的所有机器是否在线，运行...

一、预备知识

ICMP

ICMP的报文是封装在IP数据部分中的。按照我的理解，ICMP就是在网络层中，反馈一些转发、访问等操作时的附带信息。
在这里插入图片描述
ICMP分为两种，ICMP差错报告报文（IP传输时的反馈）和ICMP询问报文（主动发起检查）。具体类型值和作用如下：

3 终点不可达
11 时间超过
12 参数问题： IP首部数据有问题
5 改变路由：规定发送到某目的的IP，经过某路由
8或0 回送请求或回答：向某台主机询问，主机必须给出某种回答
13或14 时间戳请求或回答：向某台主机询问时间。

ICMP的应用之tracert

用于测试到达某IP地址所需的TTL（跳数），往返时间。

原理：

源主机向目的主机发送一连串IP数据报，数据报封装的是无法交付的UDP（使用错误的端口号，好坏的）。
第一个数据包的生存时间TLL设置为1，当P1达到路径上的第一个路由时，路由器R1就收下，然后把TLL减1，这时TLL为0，R1就丢弃数据报，然后向源主机发送一个ICMP时间超过的差错报告报文。一直做下去，直到最后一个数据报到达目的主机，这是数据报的TTL是1。由于已经到达了目的地，那么主机收下数据报，且不做减一操作（TLL为1）。但是数据报的错误的，因此目的主机就会发一个ICMP终点不可达差错报告报文。

下图的三个时间是因为每一次都发送三个相同的数据报。

在这里插入图片描述

ICMP的应用之ping

向目的主机发送询问时间请求（ICMP中的13），目的主机收到请求时，发回当前时间戳（ICMP中的14），因此利用时间戳可以计算出往返时间。

二、实验部分：Tracert 与 Ping 程序设计与实现

参照附录 2，了解 Tracert 程序的实现原理，并调试通过。然后参考 Tracert 程序和教材 4.4.2 节，编写一个 Ping 程序，并能测试本局域网的所有机器是否在线，运行界面如图 1 所示的 QuickPing 程序。
在这里插入图片描述

实现之前带着的疑问？

1）报文的具体组成？如何将ICMP数据部分 + ICMP数据头组成ICMP数据报。再将ICMP数据报加入IP数据中，最后让IP数据部分加上IP数据头构成IP数据报？
2） IP报文通过什么方法解析，可以得到IP数据报的头和数据部分。然后数据部分如何解析出ICMP报文的头和数据部分？
3）包装好的IP报文通过什么通道传输。

疑问解答

完整的代码我放到最后，在visual stdio下，关闭sdk检查，完美运行，下面对于程序的个人理解。

问题一：报文的组成

这一步是为了将希望传递的信息封装成char sendRev[]，数据缓冲区也就是字符串数组。不过socket帮我们封装了一个方法，让我们不用具体构造到字符数组。这里后面再说。

通过参数构造成ICMP头部结构体，然后再加上想要的ICMP数据部分。再构造出IP头部，把ICMP报文加到IP数据部分之前。这样完整的IP数据报就完成了。

通过结构体构造出ICMP数据头

//ICMP 报头，一共八个字节，前四个字节为：类型（1字节）、代码（1字节）和检验和（2字节）。后四个字节取决于类型
typedef struct
{
	BYTE type; //8 位类型字段：标识ICMP的作用
	BYTE code; //8 位代码字段
	USHORT cksum; //16 位校验和
	USHORT id; //16 位标识符
	USHORT seq; //16 位序列号
} ICMP_HEADER;

通过结构体构造出IP数据头

//IP 报头，标准IPV4占20字节
typedef struct
{
	unsigned char hdr_len : 4; //4 位头部长度
	unsigned char version : 4; //4 位版本号
	unsigned char tos; //8 位服务类型
	unsigned short total_len; //16 位总长度： 和头部长度一起就能区分 头 主体数据了
	unsigned short identifier; //16 位标识符: 作用是分片后的重组
	unsigned short frag_and_flags; //3 位标志加 13 位片偏移： 标志：MF 1是否还有分配 0 没有分片了
									//                         DF 0 可以分片
									// 片偏移：分片后的相对于原来的偏移
	unsigned char ttl; //8 位生存时间
	unsigned char protocol; //8 位上层协议号： 指出是何种协议
	unsigned short checksum; //16 位校验和： 检验是否出错
	unsigned long sourceIP; //32 位源 IP 地址
	unsigned long destIP; //32 位目的 IP 地址
} IP_HEADER;

问题二：IP数据报的解析

接收到的数据缓存是字符数组 char bufRev[]，因此需要通过特定的解析（也就是拆成一段一段的）获取想要的信息。

另外为了方便存取信息，这里又写了一种DECODE_RESULT，解码信息的结构体。把信息封装到结构体中，就比较方便的得到序列号、往返时间和目的IP了。

//报文解码结构
typedef struct
{
	USHORT usSeqNo; //序列号
	DWORD dwRoundTripTime; //往返时间
	in_addr dwIPaddr; //返回报文的 IP 地址
}DECODE_RESULT;

这里还需知识储备，就是字符串转结构体指针这种写法。它会把字符数组中的内容按顺序赋值到结构体中。

char 占1个字节
int 占4个字节

 unsigned char a[] = "0123456789abcdefghijk";  //无符号字符数组
    struct A         //结构体A,一个int 三个char 再接一个int
    {
        unsigned int a;
        unsigned char b;
        unsigned char c;
        unsigned char d;
        unsigned int e;
    } *pp;

    pp = (A*) a;
    cout<< (*pp).a <<' '<<(*pp).b <<' '<<(*pp).c <<' '<<endl;

有了上面的知识储备，那么如何解析IP数据报（字符数组）就比较好理解了，通过特定的地址偏移，就能把字符数组赋值到IP、ICMP结构体中了

具体的解析函数，大部分都打上了注释

// 1）接收到的Buf 2）接收到的数据长度 3）解析结果封装到Decode 4）ICMP类型 ECHO_REPLY(是一个常量，放到全局也行) 5）ICMP类型 TIMEOUT
BOOL DecodeIcmpResponse(char * pBuf, int iPacketSize, DECODE_RESULT &DecodeResult, BYTE
	ICMP_ECHO_REPLY, BYTE ICMP_TIMEOUT)
{
	//查找数据报大小合法性
		//pBuf的首地址，就是IP报的首地址，因此偏移0
	IP_HEADER *pIpHdr = (IP_HEADER*)pBuf;  
	int iIpHdrLen = pIpHdr->hdr_len * 4;
	if(iPacketSize < (int)(iIpHdrLen + sizeof(ICMP_HEADER)))
		return FALSE;
	// 根据 ICMP 报文类型提取 ID 字段和序列号字段
			//ICMP字段包含在 IP数据段的起始位置，因此偏移IP头长度，得到的就是ICMP头
	ICMP_HEADER *pIcmpHdr = (ICMP_HEADER *)(pBuf + iIpHdrLen);

	USHORT usID, usSquNo;
	if (pIcmpHdr->type == ICMP_ECHO_REPLY) // ICMP 回显应答报文
	{
		usID = pIcmpHdr->id;//报文 ID
		usSquNo = pIcmpHdr->seq;//报文序列号
	}
	else if (pIcmpHdr->type == ICMP_TIMEOUT)
	{
		// 如果是TIMEOUT ，那么在ICMP数据包中，会夹带一个IP报（荷载IP）
		char * pInnerIpHdr = pBuf + iIpHdrLen + sizeof(ICMP_HEADER); // 荷载中的 IP 的头
		int iInnerIPHdrLen = ((IP_HEADER*)pInnerIpHdr)->hdr_len * 4;// 荷载中的IP 头长度
		ICMP_HEADER * pInnerIcmpHdr = (ICMP_HEADER*)(pInnerIpHdr + iInnerIPHdrLen); //荷载中的ICMP头
		usID = pInnerIcmpHdr->id;// 报文ID
		usSquNo = pInnerIcmpHdr->seq; // 序列号
	}
	else
	{
		return false;
	}

	// 检查 ID 和序列号以确定收到期待数据报
	if (usID != (USHORT)GetCurrentProcessId() || usSquNo != DecodeResult.usSeqNo)
	{
		return false;
	}
	// 记录 IP 地址并计算往返时间
	DecodeResult.dwIPaddr.S_un.S_addr = pIpHdr->sourceIP;
	DecodeResult.dwRoundTripTime = GetTickCount() - DecodeResult.dwRoundTripTime;
	//处理正确收到的 ICMP 数据包
	if (pIcmpHdr->type == ICMP_ECHO_REPLY || pIcmpHdr->type == ICMP_TIMEOUT)
	{
		// 输出往返时间信息
		if (DecodeResult.dwRoundTripTime)
			cout << " " << DecodeResult.dwRoundTripTime << "ms" << flush;
		else
			cout << " " << "<1ms" << flush;   
	}
	return true;
}

问题三：传输的通道

最后这个问题也是我比较困惑的，原因是Socket把底层封装好了，我们只需把参数（发送的IP结构、ICMP结构、目的主机地址结构体）填好，传递到sendto()函数里面，就能把IP数据报发送到目的主机。通过调用recv就能得到目的主机的反馈。目前我也没找到更加底层的分析，因此也只停留在会用而已。

说一下这个程序干了什么事，如何使用

效果

在这里插入图片描述

ping

首先ping的原理是基础，ping也就是发送一个ICMP类型为"时间戳请求"的数据报，当目的主机收到后就会反馈一个ICMP类型为"时间戳回答"的报文，然后发送方接收到反馈后，进行解析。发现收到的数据报包含了ICMP类型为“时间戳回答”的报文，因此计算出往返时间，结果就是ping通

tracert

在ping的基础上做一些修改，发送的ICMP类型是"请求"而不是"时间戳请求"，每次都是发送到目的主机，但是TTL从1慢慢增加，这样就能获得路径上所经过的网络设备。

接收方

只要目标主机开启了ICMP的功能，那么它接收到携带ICMP报文的IP就会自动处理，因此接收方接收的事情在操作系统已经帮我们完成了。

发送方

根据ping 和 tracert业务不同改变ICMP类型即可，但是tracert要慢慢增加TTL，而ping是一下子把TTL开的足够大。

代码：实现ip区间内的tracert

#include "pch.h"
#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h> 

using namespace std;
#pragma comment(lib, "Ws2_32.lib")

/******全局常量********/

const int ipAddressSize = 17;

//IP 报头
typedef struct
{
	unsigned char hdr_len : 4; //4 位头部长度
	unsigned char version : 4; //4 位版本号
	unsigned char tos; //8 位服务类型
	unsigned short total_len; //16 位总长度： 和头部长度一起就能区分 头 主体数据了
	unsigned short identifier; //16 位标识符: 作用是分片后的重组
	unsigned short frag_and_flags; //3 位标志加 13 位片偏移： 标志：MF 1是否还有分配 0 没有分片了
									//                         DF 0 可以分片
									// 片偏移：分片后的相对于原来的偏移
	unsigned char ttl; //8 位生存时间
	unsigned char protocol; //8 位上层协议号： 指出是何种协议
	unsigned short checksum; //16 位校验和： 检验是否出错
	unsigned long sourceIP; //32 位源 IP 地址
	unsigned long destIP; //32 位目的 IP 地址
} IP_HEADER;
//ICMP 报头，一共八个字节，前四个字节为：类型（1字节）、代码（1字节）和检验和（2字节）。后四个字节取决于类型
typedef struct
{
	BYTE type; //8 位类型字段：标识ICMP的作用
	BYTE code; //8 位代码字段
	USHORT cksum; //16 位校验和
	USHORT id; //16 位标识符
	USHORT seq; //16 位序列号
} ICMP_HEADER;

//报文解码结构
typedef struct
{
	USHORT usSeqNo; //序列号
	DWORD dwRoundTripTime; //往返时间
	in_addr dwIPaddr; //返回报文的 IP 地址
}DECODE_RESULT;
//计算网际校验和函数
USHORT checksum(USHORT *pBuf, int iSize)
{
	unsigned long cksum = 0;
	while (iSize > 1)
	{
		cksum += *pBuf++;
		iSize -= sizeof(USHORT);
	}
	if (iSize)
	{
		cksum += *(UCHAR *)pBuf;
	}
	cksum = (cksum >> 16) + (cksum & 0xffff);
	cksum += (cksum >> 16);
	return (USHORT)(~cksum);
}

// 1）接收到的Buf 2）接收到的数据长度 3）解析结果封装到Decode 4）ICMP回显类型 5）TIMEOUT时间	
BOOL DecodeIcmpResponse2(char * pBuf, int iPacketSize, DECODE_RESULT &DecodeResult, BYTE
	ICMP_ECHO_REPLY, BYTE ICMP_TIMEOUT)
{
	//查找数据报大小合法性
		//pBuf的首地址，就是IP报的首地址
	IP_HEADER *pIpHdr = (IP_HEADER*)pBuf;  
	int iIpHdrLen = pIpHdr->hdr_len * 4;
	if(iPacketSize < (int)(iIpHdrLen + sizeof(ICMP_HEADER)))
		return FALSE;
	// 根据 ICMP 报文类型提取 ID 字段和序列号字段
			//ICMP字段包含在 IP数据段的起始位置，因此扣掉IP头，得到的就是ICMP头
	ICMP_HEADER *pIcmpHdr = (ICMP_HEADER *)(pBuf + iIpHdrLen);

	USHORT usID, usSquNo;
	if (pIcmpHdr->type == ICMP_ECHO_REPLY) // ICMP 回显应答报文
	{
		usID = pIcmpHdr->id;//报文 ID
		usSquNo = pIcmpHdr->seq;//报文序列号
	}
	else if (pIcmpHdr->type == ICMP_TIMEOUT)
	{
		// 如果是TIMEOUT ，那么在ICMP数据包中，会夹带一个IP报（荷载IP）
		char * pInnerIpHdr = pBuf + iIpHdrLen + sizeof(ICMP_HEADER); // 荷载中的 IP 的头
		int iInnerIPHdrLen = ((IP_HEADER*)pInnerIpHdr)->hdr_len * 4;// 荷载中的IP 头长度
		ICMP_HEADER * pInnerIcmpHdr = (ICMP_HEADER*)(pInnerIpHdr + iInnerIPHdrLen); //荷载中的ICMP头
		usID = pInnerIcmpHdr->id;// 报文ID
		usSquNo = pInnerIcmpHdr->seq; // 序列号
	}
	else
	{
		return false;
	}

	// 检查 ID 和序列号以确定收到期待数据报
	if (usID != (USHORT)GetCurrentProcessId() || usSquNo != DecodeResult.usSeqNo)
	{
		return false;
	}
	// 记录 IP 地址并计算往返时间
	DecodeResult.dwIPaddr.S_un.S_addr = pIpHdr->sourceIP;
	DecodeResult.dwRoundTripTime = GetTickCount() - DecodeResult.dwRoundTripTime;
	//处理正确收到的 ICMP 数据包
	if (pIcmpHdr->type == ICMP_ECHO_REPLY || pIcmpHdr->type == ICMP_TIMEOUT)
	{
		// 输出往返时间信息
		if (DecodeResult.dwRoundTripTime)
			cout << " " << DecodeResult.dwRoundTripTime << "ms" << flush;
		else
			cout << " " << "<1ms" << flush;   
	}
	return true;
}

 
char * findNextIp(char * nowIp);

int main()
{
	//char ip[18] = "192.168.254.254";
	//findNextIp(ip);

	//初始化 Windows sockets 网络环境
	WSADATA wsa;
	WSAStartup(MAKEWORD(2, 2), &wsa);

	 
	cout << "请输入你要查找的起始IP" << endl;

	char IpAddressBeg[ipAddressSize]; // 255.255.255.255
	cin >> IpAddressBeg;
	cout << "请输入你要查找的终止IP" << endl;

	char IpAddressEnd[ipAddressSize]; // 255.255.255.255
	cin >> IpAddressEnd;
	
	char nextIpAddress[17];
	strcpy(nextIpAddress, IpAddressBeg);

	while (strcmp(nextIpAddress, IpAddressEnd) != 0)
	{
		// 执行,单线程执行，实现后改成多线程
		u_long ulDestIP = inet_addr(nextIpAddress);
		//转换不成功时按域名解析
		if (ulDestIP == INADDR_NONE)
		{
			hostent * pHostent = gethostbyname(nextIpAddress);
			if (pHostent)
			{
				ulDestIP = (*(in_addr*)pHostent->h_addr).s_addr;
			}
			else {
				cout << "输入的 IP 地址或域名无效!" << endl;
				WSACleanup();
				return 0;
			}
		}
		// 填充目的 sockaddr_in
		sockaddr_in destSockAddr;
		ZeroMemory(&destSockAddr, sizeof(sockaddr_in));
		destSockAddr.sin_family = AF_INET;
		destSockAddr.sin_addr.S_un.S_addr = ulDestIP;

		// 创建原始套接字
		SOCKET sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,
			WSA_FLAG_OVERLAPPED);
		// 设置发送接收超时时间
		int iTimeout = 3000;
		setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO, (char *)&iTimeout, sizeof(iTimeout));
		setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO, (char *)&iTimeout, sizeof(iTimeout));
		// 构造 ICMP 回显请求消息， 并以TTL 递增顺序发送报文
		// ICMP 字段
		const BYTE ICMP_ECHO_REQUEST = 8;
		const BYTE ICMP_ECHO_REPLY = 0;
		const BYTE ICMP_TIMEOUT = 11;
		//其他常量
		const int DEF_ICMP_DATA_SIZE = 32; // ICMP 报文数据段长度
		const int MAX_ICMP_PACKET_SIZE = 1024;//ICMP 报文最大长度（加上报头）
		const DWORD DEF_ICMP_TIMEOUT = 3000;// 回显超时时间
		const int DEF_MAX_HOP = 30; // 最大跳
		// 填充 ICMP 报文中每次发送时不变的字段
		char IcmpSendBuf[sizeof(ICMP_HEADER) + DEF_ICMP_DATA_SIZE];// 发送缓冲区
		memset(IcmpSendBuf, 0, sizeof(IcmpSendBuf));
		char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE]; // 接收缓冲区
		memset(IcmpRecvBuf, 0, sizeof(IcmpRecvBuf)); //初始化接收缓冲区
		// 构造ICMP头
		ICMP_HEADER * pIcmpHeader = (ICMP_HEADER*)IcmpSendBuf;
		pIcmpHeader->type = ICMP_ECHO_REQUEST; // 类型： 请求回显
		pIcmpHeader->code = 0;
		pIcmpHeader->id = (USHORT)GetCurrentProcessId();// ID为进程PID
		memset(IcmpSendBuf + sizeof(ICMP_HEADER), 'E', DEF_ICMP_DATA_SIZE);//数据字段
		USHORT usSeqNo = 0; // ICMP 报文序列号
		int iTTL = 1; // TTL初始化
		BOOL bReachDestHost = FALSE; // 循环退出标志
		int iMaxHot = DEF_MAX_HOP; // 最大循环数
		DECODE_RESULT DecodeResult;// 传输数据的介质，封装成结构
		while (!bReachDestHost && iMaxHot--)
		{
			bReachDestHost = FALSE;
			// 设置 IP 报头的 TTL 字段
			setsockopt(sockRaw, IPPROTO_IP, IP_TTL, (char *)&iTTL, sizeof(iTTL));
			cout << iTTL << flush; // 输出当前序号
			// 填充 ICMP报文中每次发送变化的字段
			((ICMP_HEADER *)IcmpSendBuf)->cksum = 0;//校验和为0
			((ICMP_HEADER *)IcmpSendBuf)->seq = htons(usSeqNo++);// 填充序列号
			((ICMP_HEADER *)IcmpSendBuf)->cksum = checksum((USHORT *)IcmpSendBuf,
				sizeof(ICMP_HEADER) + DEF_ICMP_DATA_SIZE); //计算校验和

			// 记录序列号和时间

			DecodeResult.usSeqNo = ((ICMP_HEADER*)IcmpSendBuf)->seq;
			DecodeResult.dwRoundTripTime = GetTickCount();// 当前时间

			// 指定对方信息
			// 发送 TCP 回显请求信息
			// 1）指定哪个Socket发给对方 2）发送的数据 3）flag 4）目的地址  5）目的地址的sockaddr_in结构
			sendto(sockRaw, IcmpSendBuf, sizeof(IcmpSendBuf), 0, (sockaddr*)&destSockAddr, sizeof(destSockAddr));
			
			//接收 ICMP 差错报文并进行解析
			sockaddr_in from; // 对端 socket地址，对方的
			int iFromLen = sizeof(from);//地址结构大小
			int iReadDataLen;// 接收数据长度
			
			// 接收正常的话，这个循环只会执行一次
			while (true)
			{
				//接收数据
				iReadDataLen = recvfrom(sockRaw, IcmpRecvBuf, MAX_ICMP_PACKET_SIZE, 0, (sockaddr*)&from, &
					iFromLen); 
				
				if (iReadDataLen != SOCKET_ERROR) // 有数据到达
				{
					//解析数据包
					if (DecodeIcmpResponse2(IcmpRecvBuf, iReadDataLen, DecodeResult, ICMP_ECHO_REPLY, ICMP_TIMEOUT))
					{
						// 到达目的地，退出循环
						if (DecodeResult.dwIPaddr.S_un.S_addr == destSockAddr.sin_addr.S_un.S_addr)
							bReachDestHost = true;
						// 输出 IP 地址
						cout << '\t' << inet_ntoa(DecodeResult.dwIPaddr) << endl;
						break;
					}

				}
				else if (WSAGetLastError() == WSAETIMEDOUT) //接收超时，输出*号
				{
					cout << " *" << '\t' << "Request timed out." << endl;
					break;
				}
				else
				{
					break;
				}
			}
			iTTL++;
		}
		cout << "查找: " << nextIpAddress << "结果为 ->" << (bReachDestHost ? "在线" : "不在线") << endl;
		// 向下推
		strcpy(nextIpAddress, findNextIp(nextIpAddress));
	}
}

char *  findNextIp(char * nowIp)
{
	char nextIpAddress[ipAddressSize];
	char z[4][4];
	int idxIp = 0, idxj = 0;
	for (int i = 0; i < strlen(nowIp); i++)
	{
		if (nowIp[i] == '.')
		{
			z[idxIp][idxj] = '\0';

			idxIp++;
			idxj = 0;

			continue;

		}
		z[idxIp][idxj++] = nowIp[i];
	}
	z[idxIp][idxj] = '\0';

	//for (int i = 0; i < 4; i++)
	//{
	//	puts(z[i]);
	//}
	//cout << endl;

	for (int i = 3; i >= 0; i--)
	{
		if (strcmp("254", z[i]) == 0)
		{
			strcpy(z[i], "1"); // 这里让ip 1-254
		}
		else
		{
			int x;
			x = atoi(z[i]) + 1;
			itoa(x,z[i],10); // 第三个参数是 int的进制
			 
			break;
		}
	}
 

	char retIp[ipAddressSize];
	strcpy(retIp, z[0]);
	char c[2] = ".";
	for (int i = 1; i < 4; i++)
	{
		strcat(retIp, c);
		strcat(retIp, z[i]);	
	}
	/*cout << retIp << endl;*/

	return retIp;
}

收起

展开全文

广东工业大学网络课程设计ping程序设计与实现(含报告)
热门讨论 2012-04-09 22:16:43

广东工业大学网络课程设计ping程序设计和实现 1.已知参数：目的节点IP地址或主机名 2.设计要求：通过原始套接字编程，实现Ping的基本功能 2.1初始化Windows Sockets网络环境； 2.2解析命令行参数，构造目的端socket...

收起

C++
ping程序的设计与实现(C语言)
2012-06-24 20:33:51

计算机网络课程设计 ping程序的设计与实现 (C语言)

收起

计算机网络——Tracert与Ping程序设计与实现

千次阅读 2021-01-21 19:15:10

计算机网络——Tracert与Ping程序设计与实现一、实验目的二、总体设计1. 基本原理2. 设计步骤三、详细设计1. 程序流程图2. 实验代码四、实验结果一、实验目的了解Tracert程序的实现原理，并调试通过。二、总体...

一、实验目的

了解Tracert程序的实现原理，并调试通过。

二、总体设计

1. 基本原理

tracert（跟踪路由）是路由跟踪实用程序，用于确定IP数据包访问目标所采取的路径。tracert 有一个固定的时间等待响应(ICMP TTL到期消息)。如果这个时间过了，它将打印出一系列的*号表明：在这个路径上，这个设备不能在给定的时间内发出ICMP TTL到期消息的响应。然后，Tracert给TTL记数器加1，继续进行。

2. 设计步骤

（1）加载套接字，创建套接字库；
使用Socket的程序在使用Socket之前必须调用WSAStartup函数，以后应用程序就可以调用所请求的Socket库中的其他Socket函数了。
（2）用inet_addr()将输入的点分十进制的IP地址转换为无符号长整型数，转换不成功时，按域名解析得到IP地址；
gethostbyname()是查找主机名最基本的函数，如果调用成功，就返回一个指向hosten结构的指针，该结构中含有对应于给定主机名的主机名字和地址信息，用来承接域名解析的结构。
（3）设置发送接收超时时间，即请求超时，设置接收、发送超时的套接字；
（4）构造ICMP回显请求消息，并以TTL递增顺序发送报文，填充ICMP报文中每次发送时不变的字段，构造ICMP头；
（5）设置IP报头的TTL字段，填充ICMP报文中每次发送变化的字段，记录序列号和当前时间；
（6）指定对方信息，发送TCP回显请求信息；
sendto()函数利用数据表的方式进行数据传输，指定哪个socket发送给对方
（7）接收ICMP差错报文并进行解析：如果有数据到达，解析数据包，如果到达目的地址，输出IP地址；如果没有数据到达，输出接收超时，递增TTL值，TTL增为最大时，若还没有到达目的地址，退出循环，输出目的地址不在线；
recvform()利用数据报方式进行数据传输，当recvfrom()返回时，(sockaddr*)&from包含实际存入from中的数据字节数。Recvfrom函数返回接收到的字节数或当出现错误时返回－1，并置相应的errno。
（8）重复（2）-（7），实现查找一个范围内的IP地址。

三、详细设计

1. 程序流程图

在这里插入图片描述

2. 实验代码

#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <sstream>
using namespace std;
#pragma comment(lib, "Ws2_32.lib")
const int ipAddressSize = 14;
//int count11=0;
//IP 报头
typedef struct
{
    unsigned char hdr_len : 4; //4 位头部长度
    unsigned char version : 4; //4 位版本号
    unsigned char tos; //8 位服务类型
    unsigned short total_len; //16 位总长度： 和头部长度一起就能区分 头 主体数据了
    unsigned short identifier; //16 位标识符: 作用是分片后的重组
    unsigned short frag_and_flags; //3 位标志加 13 位片偏移： 标志：MF 1是否还有分配 0 没有分片了
    //                         DF 0 可以分片
    // 片偏移：分片后的相对于原来的偏移
    unsigned char ttl; //8 位生存时间
    unsigned char protocol; //8 位上层协议号： 指出是何种协议
    unsigned short checksum; //16 位校验和： 检验是否出错
    unsigned long sourceIP; //32 位源 IP 地址
    unsigned long destIP; //32 位目的 IP 地址
} IP_HEADER;
//ICMP 报头，一共八个字节，前四个字节为：类型（1字节）、代码（1字节）和检验和（2字节）。后四个字节取决于类型
typedef struct
{
    BYTE type; //8 位类型字段：标识ICMP的作用
    BYTE code; //8 位代码字段
    USHORT cksum; //16 位校验和
    USHORT id; //16 位标识符
    USHORT seq; //16 位序列号
} ICMP_HEADER;

//报文解码结构
//接收到的数据缓存是字符数组char bufRev[]，因此需要通过特定的解析（也就是拆成一段一段的）获取想要的信息
//把信息封装到结构体中，就比较方便的得到序列号、往返时间和目的IP了。
typedef struct
{
    USHORT usSeqNo; //序列号
    DWORD dwRoundTripTime; //往返时间
    in_addr dwIPaddr; //返回报文的 IP 地址
} DECODE_RESULT;
//计算网际校验和函数
USHORT checksum(USHORT *pBuf, int iSize)
{
    unsigned long cksum = 0;
    while (iSize > 1)
    {
        cksum += *pBuf++;
        iSize -= sizeof(USHORT);
    }
    if (iSize)
    {
        cksum += *(UCHAR *)pBuf;
    }
    cksum = (cksum >> 16) + (cksum & 0xffff);
    cksum += (cksum >> 16);
    return (USHORT)(~cksum);
}
//对数据包进行解码
// 1）接收到的Buf 2）接收到的数据长度 3）解析结果封装到Decode 4）ICMP回显类型 5）TIMEOUT时间
BOOL DecodeIcmpResponse2(char * pBuf, int iPacketSize, DECODE_RESULT &DecodeResult, BYTE
                         ICMP_ECHO_REPLY, BYTE ICMP_TIMEOUT)
{
    //查找数据报大小合法性
    //pBuf的首地址，就是IP报的首地址
    IP_HEADER *pIpHdr = (IP_HEADER*)pBuf;
    int iIpHdrLen = pIpHdr->hdr_len * 4;
    if(iPacketSize < (int)(iIpHdrLen + sizeof(ICMP_HEADER)))
        return FALSE;
    // 根据 ICMP 报文类型提取 ID 字段和序列号字段
    //ICMP字段包含在 IP数据段的起始位置，因此扣掉IP头，得到的就是ICMP头
    ICMP_HEADER *pIcmpHdr = (ICMP_HEADER *)(pBuf + iIpHdrLen);

    USHORT usID, usSquNo;
    if (pIcmpHdr->type == ICMP_ECHO_REPLY) // ICMP 回显应答报文
    {
        usID = pIcmpHdr->id;//报文 ID
        usSquNo = pIcmpHdr->seq;//报文序列号
    }
    else if (pIcmpHdr->type == ICMP_TIMEOUT)//ICMP超时差错报文
    {
        // 如果是TIMEOUT ，那么在ICMP数据包中，会夹带一个IP报（荷载IP）
        char * pInnerIpHdr = pBuf + iIpHdrLen + sizeof(ICMP_HEADER); // 荷载中的 IP 的头
        int iInnerIPHdrLen = ((IP_HEADER*)pInnerIpHdr)->hdr_len * 4;// 荷载中的IP 头长度
        ICMP_HEADER * pInnerIcmpHdr = (ICMP_HEADER*)(pInnerIpHdr + iInnerIPHdrLen); //荷载中的ICMP头
        usID = pInnerIcmpHdr->id;// 报文ID
        usSquNo = pInnerIcmpHdr->seq; // 序列号
    }
    else
    {
        return false;
    }

    // 检查 ID 和序列号以确定收到期待数据报
    if (usID != (USHORT)GetCurrentProcessId() || usSquNo != DecodeResult.usSeqNo)
    {
        return false;
    }
    // 记录 IP 地址并计算往返时间
    DecodeResult.dwIPaddr.S_un.S_addr = pIpHdr->sourceIP;
    DecodeResult.dwRoundTripTime = GetTickCount() - DecodeResult.dwRoundTripTime;
    //处理正确收到的 ICMP 数据包
    if (pIcmpHdr->type == ICMP_ECHO_REPLY || pIcmpHdr->type == ICMP_TIMEOUT)
    {
        // 输出往返时间信息
        if (DecodeResult.dwRoundTripTime)
            cout << " " << DecodeResult.dwRoundTripTime << "ms" << flush;
        else
            cout << " " << "<1ms" << flush;
    }
    return true;
}


char * findNextIp(char * nowIp);

int main()
{
    //初始化 Windows sockets 网络环境
    WSADATA wsa;//存储被WSAStartup函数调用后返回的Windows Sockets数据
    //使用Socket的程序在使用Socket之前必须调用WSAStartup函数，以后应用程序就可以调用所请求的Socket库中的其他Socket函数了
    WSAStartup(MAKEWORD(2, 2), &wsa);//进行相应的socket库绑定
    cout << "请输入你要查找的起始IP：" << endl;
    char IpAddressBeg[ipAddressSize]; // 255.255.255.255
    cin >> IpAddressBeg;
    cout << "请输入你要查找的终止IP：" << endl;
    char IpAddressEnd[ipAddressSize]; // 255.255.255.255
    cin >> IpAddressEnd;
    char nextIpAddress[17];
    strcpy(nextIpAddress, IpAddressBeg);
    while (strcmp(nextIpAddress, IpAddressEnd) != 0)
    {
        // 执行,单线程执行，实现后改成多线程
        //得到IP地址
        u_long ulDestIP = inet_addr(nextIpAddress);//inet_addr()的功能是将一个点分十进制的IP转换成一个无符号长整型数
        //转换不成功时按域名解析
        if (ulDestIP == INADDR_NONE)
        {
            //gethostbyname()是查找主机名最基本的函数
            //如果调用成功，就返回一个指向hosten结构的指针
            //该结构中含有对应于给定主机名的主机名字和地址信息，用来承接域名解析的结构
            hostent * pHostent = gethostbyname(nextIpAddress);
            if (pHostent)//调用成功
            {
                //得到IP地址
                //套了两层，IP和ICMP，ICMP是套在IP里面的
                //h_addr返回主机IP地址
                //in_addr返回报文的IP地址
                //sin_addr.s_addr指向IP地址
                ulDestIP = (*(in_addr*)pHostent->h_addr).s_addr;
            }
            else
            {
                cout << "输入的 IP 地址或域名无效!" << endl;
                WSACleanup();//解除与Socket库的绑定并且释放Socket库所占用的系统资源
                return 0;
            }
        }
        // 填充目的 sockaddr_in
        sockaddr_in destSockAddr;//sockaddr_in是Internet环境下套接字的地址形式
        //将指定的内存块清零，使用结构前清零，而不让结构体的成员数值具有不确定性，是一个好的编程习惯
        ZeroMemory(&destSockAddr, sizeof(sockaddr_in));
        destSockAddr.sin_family = AF_INET;//指代协议簇，在socket编程中只能是AF_INET
        destSockAddr.sin_addr.S_un.S_addr = ulDestIP;//按照网络字节顺序存储IP地址
        //创建原始套接字
        //WSASocket()的发送操作和接收操作都可以被重叠使用。接收函数可以被多次调用，发出接收缓冲区，准备接收到来的数据。发送函数也可以被多次调用，组成一个发送缓冲区队列
        //如无错误发生，返回新套接口的描述字，否则的话，返回INVALID_SOCKET
        //AF_INET为地址簇描述，SOCK_RAW为新套接口的类型描述，SOCK_RAW为原始套接字，可处理PING报文等
        //IPPROTO_ICMP为套接口使用的协议，为ICMP；NULL是一个指向PROTOCOL_INFO结构的指针，该结构定义所创建套接口的特性
        //0为套接口的描述字；WSA_FLAG_OVERLAPPED为套接口属性描述，WSA_FLAG_OVERLAPPED表示要使用重叠模型
        SOCKET sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,
                                   WSA_FLAG_OVERLAPPED);
        // 设置发送接收超时时间，即请求超时
        //比如请求B站的一个视频，他超过一个时间没回我，我就认为超时了
        //超时时间是可能变化的，这个超时时间用来存储在不同的变量，它刚好在一个变量而已
        int iTimeout = 500;//如果没超过超时时间就会一直等着，超过超时时间就不等了
        //接收超时
        //sockRaw为将要被设置或者获取选项的套接字；SOL_SOCKET为在套接字级别上设置选项；SO_RCVTIMEO设置接收超时时间
        //(char*)&iTimeout指向存放选项值的缓冲区；sizeof(iTimeout)为缓冲区的长度
        setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO, (char *)&iTimeout, sizeof(iTimeout));
        //发送超时
        //sockRaw为将要被设置或者获取选项的套接字；SOL_SOCKET为在套接字级别上设置选项；SO_SNDTIMEO设置发送超时时间
        //(char*)&iTimeout指向存放选项值的缓冲区；sizeof(iTimeout)为缓冲区的长度
        setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO, (char *)&iTimeout, sizeof(iTimeout));
        // 构造 ICMP 回显请求消息， 并以TTL 递增顺序发送报文
        // ICMP 类型字段
        //采用const修饰变量，功能是对变量声明为只读特性，并保护变量值以防被修改
        const BYTE ICMP_ECHO_REQUEST = 8;//请求回显
        const BYTE ICMP_ECHO_REPLY = 0;//回显应答
        //其他常量定义
        const int DEF_ICMP_DATA_SIZE = 32; // ICMP 报文默认数据字段长度
        const int MAX_ICMP_PACKET_SIZE = 1024;//ICMP 报文最大长度（加上报头）
        const DWORD DEF_ICMP_TIMEOUT = 500;// 回显应答超时时间
        const int DEF_MAX_HOP = 20; // 最大跳站数
        // 填充 ICMP 报文中每次发送时不变的字段
        char IcmpSendBuf[sizeof(ICMP_HEADER) + DEF_ICMP_DATA_SIZE];// 发送缓冲区
        memset(IcmpSendBuf, 0, sizeof(IcmpSendBuf));//初始化发送缓冲区
        char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE]; // 接收缓冲区
        memset(IcmpRecvBuf, 0, sizeof(IcmpRecvBuf)); //初始化接收缓冲区
        // 构造ICMP头
        ICMP_HEADER * pIcmpHeader = (ICMP_HEADER*)IcmpSendBuf;
        pIcmpHeader->type = ICMP_ECHO_REQUEST; // 类型为请求回显
        pIcmpHeader->code = 0;//代码字段为0
        pIcmpHeader->id = (USHORT)GetCurrentProcessId();// ID字段为当前进程号
        memset(IcmpSendBuf + sizeof(ICMP_HEADER), 'E', DEF_ICMP_DATA_SIZE);//数据字段
        USHORT usSeqNo = 0; // ICMP 报文序列号
        int iTTL = 1; // TTL初始化值为1
        BOOL bReachDestHost = FALSE; // 循环退出标志
        int iMaxHot = DEF_MAX_HOP; // 最大循环数
        DECODE_RESULT DecodeResult;// 传递给报文解码函数的结构化参数
        //int count11=0;
        while (!bReachDestHost && iMaxHot--)
        {
            bReachDestHost = FALSE;
            // 设置 IP 报头的 TTL 字段
            //sockRaw为将要被设置或者获取选项的套接字；IPPROTO_IP为套接口使用的协议，为IP；IP_TTL为设置IP报头的TTL字段
            //(char*)&iTTL指向存放选项值的缓冲区；sizeof(iTTL)为缓冲区的长度
            setsockopt(sockRaw, IPPROTO_IP, IP_TTL, (char *)&iTTL, sizeof(iTTL));
            cout << iTTL << flush; // 输出当前序号,flush的作用是刷新缓冲区
            // 填充 ICMP报文中每次发送变化的字段
            ((ICMP_HEADER *)IcmpSendBuf)->cksum = 0;//校验和为0
            ((ICMP_HEADER *)IcmpSendBuf)->seq = htons(usSeqNo++);// 填充序列号
            ((ICMP_HEADER *)IcmpSendBuf)->cksum = checksum((USHORT *)IcmpSendBuf,
                                                  sizeof(ICMP_HEADER) + DEF_ICMP_DATA_SIZE); //计算校验和

            // 记录序列号和当前时间
            DecodeResult.usSeqNo = ((ICMP_HEADER*)IcmpSendBuf)->seq;//当前序号
            DecodeResult.dwRoundTripTime = GetTickCount();// 当前时间

            // 指定对方信息
            // 发送 TCP 回显请求信息
            //sendto()利用数据报的方式进行数据传输
            // 1）指定哪个Socket发给对方 2）发送的数据 3）flag 4）目的地址  5）目的地址的sockaddr_in结构
            sendto(sockRaw, IcmpSendBuf, sizeof(IcmpSendBuf), 0, (sockaddr*)&destSockAddr, sizeof(destSockAddr));

            //接收 ICMP 差错报文并进行解析
            sockaddr_in from; // 对端 socket地址，对方的
            int iFromLen = sizeof(from);//地址结构大小
            int iReadDataLen;// 接收数据长度

            // 接收正常的话，这个循环只会执行一次
            while (true)
            {
                //接收数据
                //recvfrom()利用数据报方式进行数据传输
                //当recvfrom（）返回时，(sockaddr*)&from包含实际存入from中的数据字节数。
                //Recvfrom（）函数返回接收到的字节数或当出现错误时返回－1，并置相应的errno。
                iReadDataLen = recvfrom(sockRaw, IcmpRecvBuf, MAX_ICMP_PACKET_SIZE, 0, (sockaddr*)&from, &
                                        iFromLen);

                if (iReadDataLen != SOCKET_ERROR) // 有数据到达
                {
                    //解析数据包
                    // 1）接收到的Buf 2）接收到的数据长度 3）解析结果封装到Decode 4）ICMP回显类型 5）TIMEOUT时间
                    if (DecodeIcmpResponse2(IcmpRecvBuf, iReadDataLen, DecodeResult, ICMP_ECHO_REPLY, DEF_ICMP_TIMEOUT))
                    {
                        // 到达目的地，退出循环
                        //返回报文的IP地址等于输入的IP地址
                        if (DecodeResult.dwIPaddr.S_un.S_addr == destSockAddr.sin_addr.S_un.S_addr)
                        {
                            bReachDestHost = true;
                            // 输出 IP 地址
                            //inet_ntoa()功能是将网络地址转换成“.”点隔的字符串格式。
                            cout << '\t' << inet_ntoa(DecodeResult.dwIPaddr) << endl;
                            strcpy(nextIpAddress, inet_ntoa(DecodeResult.dwIPaddr));
                            break;
                        }

                    }

                }
                //WSAGetLastError()当一特定的Sockets API函数指出一个错误已经发生，该函数就应调用来获得对应的错误代码。
                //WSAETIMEDOUT在尝试连接超时,而不建立连接。
                else if (WSAGetLastError() == WSAETIMEDOUT) //接收超时，输出*号
                {
                    cout << " *" << '\t' << "Request timed out." << endl;
                    break;
                }
                else
                {
                    break;
                }
            }
            iTTL++;//递增TTL值
        }

        cout << "查找: " << nextIpAddress << "结果为 ->" << (bReachDestHost ? "在线" : "不在线") << endl;
        //if nextIpAddress ==bReachDestHost;
        // 向下推
        strcpy(nextIpAddress, findNextIp(nextIpAddress));
    }
    return 0;
}

char * findNextIp(char * nowIp)
{
    char nextIpAddress[ipAddressSize];
    char z[4][4];
    int idxIp = 0, idxj = 0;
    for (int i = 0; i < strlen(nowIp); i++)
    {
        if (nowIp[i] == '.')
        {
            z[idxIp][idxj] = '\0';

            idxIp++;
            idxj = 0;

            continue;

        }
        z[idxIp][idxj++] = nowIp[i];
    }
    z[idxIp][idxj] = '\0';

    //for (int i = 0; i < 4; i++)
    //{
    //	puts(z[i]);
    //}
    //cout << endl;

    for (int i = 3; i >= 0; i--)
    {
        if (strcmp("254", z[i]) == 0)
        {
            strcpy(z[i], "1"); // 这里让ip 1-254
        }
        else
        {
            int x;
            x = atoi(z[i]) + 1;
            //stringstream ss;
            //ss << x;
            //string z[i] = ss.str();
            itoa(x,z[i],10); // 第三个参数是 int的进制

            break;
        }
    }


    char retIp[ipAddressSize];
    strcpy(retIp, z[0]);
    char c[2] = ".";
    for (int i = 1; i < 4; i++)
    {
        strcat(retIp, c);
        strcat(retIp, z[i]);
    }
    /*cout << retIp << endl;*/

    return retIp;
}

四、实验结果

在这里插入图片描述

收起

展开全文

c++ 计算机网络

计算机网络实验设计-Tracert 与Ping 程序设计与实现
千次阅读 多人点赞 2019-12-28 18:11:08

Tracert 与Ping 程序设计与实现 二．设计内容参照附录 2，了解 Tracert 程序的实现原理，并调试通过。然后参考 Tracert 程序和教材 4.4.2 节，编写一个 Ping 程序，并能测试本局域网的所有机器是否在线。三．设计...

收起

计算机网络实验
网络课程设计-ping程序设计与实现
2013-12-06 15:44:29

计算机网络课程设计-ping程序设计与实现报告及代码附录

收起
Ping程序设计实现
千次阅读 2021-11-14 11:15:43

ping程序发ICMP响应请求给某一主机,该主机返回一个ICMP响应应答,程序收到应答则显示结果.为了完成这个功能,首先应创建协议为ICMP的原始套接字以接收/发送ICMP包,然后需要构造ICMP包,通过原始套接字发送给对方主机. ...

收起

tcp/ip 网络协议
计网课设_Java实现简单的PING操作
2021-08-07 10:08:50

计算机网络课程设计程序：使用Java的InetAddress类实现简单的PING操作；可以PING一个ip地址；也可以批量PING多个ip地址

收起
[ Java ] PING 程序的设计与实现
千次阅读 2020-07-08 09:51:42

java 实现类似 Windows 自带PING程序的功能，可以向制定的域名或IP地址发送Echo请求报文，并根据相应报文显示出Ping的结果。

收起

java swing
ping程序的设计与实现.
2014-04-12 01:09:18

ping程序的设计与实现.

收起
一个简单ping程序的设计与实现
2010-12-27 15:53:59

简单编写的ping程序，用来在windows的dos窗口下执行，以模拟实现探测网络连通的情况。

收起
使用Windows API实现SOCKET Ping 范例源代码
2021-03-17 11:08:35

利用windows socket 2发送ICMP包，实现ping功能。开发环境：Visual Studio 2005

收起
ping程序的设计与实现.doc
2022-06-20 14:44:25

计算机网络课程设计任务书 " 学院 "计算机与信息工程 "专业 "网络工程 " "课程名称 " "题目 "基于原始套接字实现简 " " " " "单的ping程序 " "完成期限 "自2014年8月25日至2014年8月30日共1周 " "内 "一、项目的...

收起
1ping程序的设计与实现.doc
2022-06-20 08:14:28

计算机网络课程设计任务书 " 学院 "计算机与信息工程 "专业 "网络工程 " "课程名称 " "题目 "基于原始套接字实现简单 " " " " "的ping程序 " "完成期限 "自2014年8月25日至2014年8月30日共1周 " "内 "一、项目的...

收起
用C语言Socket实现多线程ping一个网段
2019-05-04 17:14:08

这是我们某次的网络开发的课程设计，ping的使用的是《网络编程》一书上的方法，主要实现了输入一个网段(起始IP和末IP)、ping的次数、线程数，之后开始ping这个网段，输出相关信息这个是原版的，还有一个改成了MFC的...

收起
ping程序课程设计实验报告.doc
2021-06-16 09:54:34

ping程序课程设计实验报告

收起
PING程序设计测试网络连通
2016-12-31 11:04:00

PING程序是我们使用的比较多的用于测试网络连通性的程序。...课程设计中选取PING程序的设计，其目的是希望同学们通过PING程序的设计，能初步掌握TCP/IP网络协议的基本实现方法，对网络的实现机制有进一步的认识。

收起
实现ping命令
2016-04-14 08:37:51

1、实验目的：要求学生掌握Socket编程技术，以及ICMP协议 2、实验内容： i. 要求学生掌握利用Socket进行编程的技术 ii. 不能采用现有的工具，必须自己一步一步，...vi. 可以通过程序，查看子网中有哪些主机可以ping通

收起
ping程序实现
2020-11-19 15:46:29

ping程序实现 【实验目的】  熟悉原始套接字编程的基本流程  理解ping程序的实现机制  理解ICMP协议的基于作用和报文格式。  完成原始套接字的配置。【实验要求】构造ICMP协议首部结构构造ICMP回射请求...

收起
基于java的Ping程序的设计和实现
千次阅读 2019-08-07 11:05:00

一需求分析已知参数：目的节点IP地址或主机名设计要求：通过原始套接字编程，模拟Ping命令，实现其基本功能，即输入一个IP地址或一段IP地址的范围，分别测试其中每个IP地址所对应主机的可达性，并返回耗时、生存...

收起

Ping程序的设计与实现课程设计.wps

计算机网络课程设计之Tracert与Ping程序设计与实现

前言

实验题目

实验目的

总体设计

Tracert

Ping

详细设计

Tracert

IP地址和域名

超时时间

转发节点个数

Ping

IP范围

超时时间

ping次数

实验结果与分析

小结与心得体会

附

Tracert源码

Ping源码

Tracert与Ping程序设计与实现

计算机网络基础课程设计Ping程序的实现.doc

ping程序的设计与实现.pdf

Ping程序的设计与实现

ping程序的设计与实现

计算机网络课程设计之Tracert与Ping 程序设计与实现

一、预备知识

ICMP

ICMP的应用之tracert

原理：

ICMP的应用之ping

二、实验部分：Tracert 与 Ping 程序设计与实现

实现之前带着的疑问？

疑问解答

问题一：报文的组成

通过结构体构造出ICMP数据头

通过结构体构造出IP数据头

问题二：IP数据报的解析

这里还需知识储备，就是字符串转结构体指针这种写法。它会把字符数组中的内容按顺序赋值到结构体中。

具体的解析函数，大部分都打上了注释

问题三：传输的通道

说一下这个程序干了什么事，如何使用

效果

ping

tracert

接收方

发送方

代码：实现ip区间内的tracert

广东工业大学网络课程设计ping程序设计与实现(含报告)

ping程序的设计与实现(C语言)

计算机网络——Tracert与Ping程序设计与实现

计算机网络——Tracert与Ping程序设计与实现

一、实验目的

二、总体设计

1. 基本原理

2. 设计步骤

三、详细设计

1. 程序流程图

2. 实验代码

四、实验结果

计算机网络实验设计-Tracert 与Ping 程序设计与实现

网络课程设计-ping程序设计与实现

Ping程序设计实现

计网课设_Java实现简单的PING操作

[ Java ] PING 程序的设计与实现

ping程序的设计与实现.

一个简单ping程序的设计与实现

使用Windows API实现SOCKET Ping 范例源代码

ping程序的设计与实现.doc

1ping程序的设计与实现.doc

用C语言Socket实现多线程ping一个网段

ping程序课程设计实验报告.doc

PING程序设计测试网络连通

实现ping命令

ping程序实现

基于java的Ping程序的设计和实现

ping程序的设计与实现