ping.cpp

用基层套接字写的类似于WINDOWS的PING函数

// 模块名称: Ping.c
// 编译:cl -o Ping Ping.c ws2_32.lib /Zp1    
// 命令行参数:
//     Ping [host] [packet-size]     
//     host         待 ping 主机名
//     packet-size  发送包实体长度(少于 1024 bytes)

#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")
#define IP_RECORD_ROUTE  0x7

typedef struct _iphdr			   // 定义IP数据报首部结构体
{
    unsigned int   h_len:4;        // 报头长度
    unsigned int   version:4;      // 版本
    unsigned char  tos;            // 服务类型
    unsigned short total_len;      // 总长度
    unsigned short ident;          // 标识符
    unsigned short frag_and_flags; // 标志+分片偏移量
    unsigned char  ttl;            // 存活时间
    unsigned char  proto;          // 协议 (TCP, UDP etc)
    unsigned short checksum;       // 报头校验和

    unsigned int   sourceIP;       //数据报源地址
    unsigned int   destIP;         //数据报目的地址
} IpHeader; 

#define ICMP_ECHO        8
#define ICMP_ECHOREPLY   0
#define ICMP_MIN         8         // ICMP 包至少8字节(头部)

typedef struct _icmphdr            // ICMP 头结构体
{
    BYTE   i_type;
    BYTE   i_code;                 // 代码
    USHORT i_cksum;
    USHORT i_id;
    USHORT i_seq;
    
    ULONG  timestamp;		       // 此部分并非标准头部所需包含的,但我们利用它来存放时间
} IcmpHeader;

typedef struct _ipoptionhdr		   // IP选项 - 利用套接字选项定义符 IP_OPTIONS
{
    unsigned char        code;      // 选项类型
    unsigned char        len;       // 选项长度
    unsigned char        ptr;       // 选项偏移量
    unsigned long        addr[9];   // IP地址列表
} IpOptionHeader;

#define DEF_PACKET_SIZE  32        // 默认包大小
#define MAX_PACKET       1024      // 最大 ICMP 包尺寸
#define MAX_IP_HDR_SIZE  60        // 最大 IP 头尺寸

BOOL  bRecordRoute;
int   datasize;
char *lpdest;


// 函数: usage
// 功能:打印用户信息
void usage(char *progname)
{
    printf("usage: ping -r <host> [data size]\n");
    printf("       -r           record route\n");
    printf("        host        remote machine to ping\n");
    printf("        datasize    can be up to 1KB\n");
    ExitProcess(-1);  //退出进程                      
}

// 函数: FillICMPData
// 功能: 对ICMP请求添加不同的域
void FillICMPData(char *icmp_data, int datasize)
{
    IcmpHeader *icmp_hdr = NULL;
    char       *datapart = NULL;

    icmp_hdr = (IcmpHeader*)icmp_data;
    icmp_hdr->i_type = ICMP_ECHO;        // 需要回应请求
    icmp_hdr->i_code = 0;
    icmp_hdr->i_id = (USHORT)GetCurrentProcessId();
    icmp_hdr->i_cksum = 0;
    icmp_hdr->i_seq = 0;

    datapart = icmp_data + sizeof(IcmpHeader);	
    // 在剩余的缓冲区中放置字母E,这是随便放的字母
    memset(datapart,'E', datasize - sizeof(IcmpHeader));
}

// 函数: checksum
// 功能: 对ICMP报文求16位和
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);
}

// 函数: DecodeIPOptions
// 功能: 如果IP可选项可用，找出包含在IP数据里的IP地址并打印以显示路由
void DecodeIPOptions(char *buf, int bytes)
{
    IpOptionHeader *ipopt = NULL;
    IN_ADDR         inaddr;
    int             i;
    HOSTENT        *host = NULL;

    ipopt = (IpOptionHeader *)(buf + 20);

    printf("RR:   ");
    for(i = 0; i < (ipopt->ptr / 4) - 1; i++)
    {
        inaddr.S_un.S_addr = ipopt->addr[i];
        if (i != 0)
            printf("      ");
        host = gethostbyaddr((char *)&inaddr.S_un.S_addr,
                    sizeof(inaddr.S_un.S_addr), AF_INET);
        if (host)
            printf("(%-15s) %s\n", inet_ntoa(inaddr), host->h_name);
        else
            printf("(%-15s)\n", inet_ntoa(inaddr));
    }
    return;
}

// 函数: DecodeICMPHeader
// 功能: 应答是IP包的话，解开IP头以得到ICMP数据
void DecodeICMPHeader(char *buf, int bytes,struct sockaddr_in *from)
{
    IpHeader       *iphdr = NULL;
    IcmpHeader     *icmphdr = NULL;
    unsigned short  iphdrlen;
    DWORD           tick;
    static   int    icmpcount = 0;

    iphdr = (IpHeader *)buf;
    iphdrlen = iphdr->h_len * 4;    //每字32位 * 4 = 字节数
    tick = GetTickCount();

    if ((iphdrlen == MAX_IP_HDR_SIZE) && (!icmpcount))
        DecodeIPOptions(buf, 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 != ICMP_ECHOREPLY) 
    {
        printf("nonecho type %d recvd\n", icmphdr->i_type);
        return;
    }
    
    if (icmphdr->i_id != (USHORT)GetCurrentProcessId()) //确保是送出的ICMP应答
    {
        printf("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", tick - icmphdr->timestamp);
    printf("\n");

    icmpcount++;
    return;
}

void ValidateArgs(int argc, char **argv)
{
    int                i;

    bRecordRoute = FALSE;//TRUE;
    lpdest = NULL;
    datasize = DEF_PACKET_SIZE;

    for(i = 1; i < argc; i++)
    {
		//printf("%s \n",argv[i]);
        if ((argv[i][0] == '-') || (argv[i][0] == '/'))
        {
            switch (tolower(argv[i][1]))
            {
                case 'r':        // 记录路由选项
                    bRecordRoute = TRUE;
                    break;
                default:
                    usage(argv[0]);
                    break;
            }
        }
        else if (isdigit(argv[i][0]))
            datasize = atoi(argv[i]);
        else
            lpdest = argv[i];
    }
}
        
// 函数: main
// 功能: 建立ICMP原始套接字，产生ICMP报头，增加恰当的IP可选头部，
//    发送CIMP回应到目的端。每次发送与接收时，为避免当源端不可达
//    时无限等待，我们给设置超时值，接收到应答后对数据解码
int main(int argc, char **argv)
{
    WSADATA            wsaData;
    SOCKET             sockRaw = INVALID_SOCKET;
    struct sockaddr_in dest,
                       from;
    int                bread,
                       fromlen = sizeof(from),
                       timeout = 1000,
                       ret;
    char              *icmp_data = NULL,
                      *recvbuf = NULL;
    unsigned int       addr = 0;
    USHORT             seq_no = 0;
    struct hostent    *hp = NULL;
    IpOptionHeader     ipopt;

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
        printf("WSAStartup() failed: %d\n", GetLastError());
        return -1;
    }
    ValidateArgs(argc, argv);

    // 对于SO_RCVTIMEO和SO_SNDTIMEO选项，WSA_FLAG_OVERLAPPED标志
	//是必须的。若将WSASocket函数的最后一个参数设置为NULL, 则所有
	//与套接字有关的输入/输出都成为同步，那么内部用户模式等待代码将
    // 没有机会执行，因此内核模式的输入/输出将阻塞 。
    sockRaw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,
                         WSA_FLAG_OVERLAPPED);
    if (sockRaw == INVALID_SOCKET) 
    {
        printf("WSASocket() failed: %d\n", WSAGetLastError());
        return -1;
    }
    if (bRecordRoute)
    {
        // 在每个ICMP包前设置IP可选项头部
        ZeroMemory(&ipopt, sizeof(ipopt));  //用0来填充内存块
        ipopt.code = IP_RECORD_ROUTE;       // 报告路由选项
        ipopt.ptr  = 4;                     // 开始地址偏移两
        ipopt.len  = 39;                    // 可选项长度
  
        ret = setsockopt(sockRaw, IPPROTO_IP, IP_OPTIONS, 
            (char *)&ipopt, sizeof(ipopt));
        if (ret == SOCKET_ERROR)
        {
            printf("setsockopt(IP_OPTIONS) failed: %d\n", 
                WSAGetLastError());
        }
    }
    //设置send/recv超时值
    bread = setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO, 
                (char*)&timeout, sizeof(timeout));
    if(bread == SOCKET_ERROR) 
    {
        printf("setsockopt(SO_RCVTIMEO) failed: %d\n", 
            WSAGetLastError());
        return -1;
    }
    timeout = 1000;
    bread = setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO, 
                (char*)&timeout, sizeof(timeout));
    if (bread == SOCKET_ERROR) 
    {
        printf("setsockopt(SO_SNDTIMEO) failed: %d\n", 
            WSAGetLastError());
        return -1;
    }
    memset(&dest, 0, sizeof(dest));
    
    // 若有必要则对目的端名字进行解析
    dest.sin_family = AF_INET;
    if ((dest.sin_addr.s_addr = inet_addr(lpdest)) == INADDR_NONE)
    {
        if ((hp = gethostbyname(lpdest)) != NULL)
        {
            memcpy(&(dest.sin_addr), hp->h_addr, hp->h_length);
            dest.sin_family = hp->h_addrtype;
            printf("dest.sin_addr = %s\n", inet_ntoa(dest.sin_addr));
        }
        else
        {
            printf("gethostbyname() failed: %d\n", 
                WSAGetLastError());
            return -1;
        }
    }        

    // 生成ICMP数据包      
    datasize += sizeof(IcmpHeader);  

	//分配堆中的内存块，并将分配的内存初始化为0，分配字节大小为MAX_PACKET = 1024
    icmp_data = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,      
                  MAX_PACKET);
    recvbuf   = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                  MAX_PACKET);
    if (!icmp_data) 
    {
        printf("HeapAlloc() failed: %d\n", GetLastError());
        return -1;
    }
    memset(icmp_data,0,MAX_PACKET);
    FillICMPData(icmp_data,datasize);
    
    while(1)				// 开始 sending/receiving ICMP 包
    {
        static int nCount = 0;
        int        bwrote;
                
        if (nCount++ == 4) 
            break;
                
        ((IcmpHeader*)icmp_data)->i_cksum = 0;
        ((IcmpHeader*)icmp_data)->timestamp = GetTickCount();
        ((IcmpHeader*)icmp_data)->i_seq = seq_no++;
        ((IcmpHeader*)icmp_data)->i_cksum = 
            checksum((USHORT*)icmp_data, datasize);

        bwrote = sendto(sockRaw, icmp_data, datasize, 0, 
                     (struct sockaddr*)&dest, sizeof(dest));
        if (bwrote == SOCKET_ERROR)
        {
            if (WSAGetLastError() == WSAETIMEDOUT) 
            {
                printf("timed out\n");
                continue;
            }
            printf("sendto() failed: %d\n", WSAGetLastError());
            return -1;
        }
        if (bwrote < datasize) 
        {
            printf("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;
            }
            printf("recvfrom() failed: %d\n", WSAGetLastError());
            return -1;
        }
        DecodeICMPHeader(recvbuf, bread, &from);

        Sleep(1000);  //休眠1000毫秒
    }

    if (sockRaw != INVALID_SOCKET) 
        closesocket(sockRaw);
    HeapFree(GetProcessHeap(), 0, recvbuf);    //从堆中释放分配的内存
    HeapFree(GetProcessHeap(), 0, icmp_data);

    WSACleanup();
    return 0;
}