ping程序的实现

构造icmp包，发送给自己在同一网段的主机，使用select函数，非阻塞方式接收回包。还包括反码算术求和求首部校验和的函数。

 

转载请注明出处。

 

可能的情况

1、在线

　　目的主机直接回复icmp包。

2、终点不可达（发送不到目的主机）

　　接收到路由器或本机的icmp的终点不可达回包。

3、接受不到回包（能发送到目的主机）

　　能发送到目的主机，但是被目的主机的防火墙拦截了，不做回复，所以收不到回包。

 

代码绝大部分是老师上课的内容，自己整理了一遍，加上了一些注释：

// SetAvailableIP.cpp : 定义控制台应用程序的入口点。
//

#pragma pack(4)
/*
*编译器中提供了#pragma pack(n)来设定变量以n字节对齐方式。
*n字节对齐就是说变量存放的起始地址的偏移量有两种情况,
*第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，
*第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。
*结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，
*那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。
*/


#define WIN32_LEAN_AND_MEAN
#include "stdafx.h"
#include <stdlib.h>
#include <WINSOCK2.H>//与#include <winsock2.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)
#define uchar unsigned char
#define uint unsigned int


/* ip header*/
typedef struct iphdr{
    uchar h_len:4;//位域，占四个二进制位 length of header
    uchar version:4;//Version of ip   因为位序是小端所以颠倒位置
    uchar tos;        //type of service
    uchar total_len;//total length of packet
    uchar ident;    //unique idetifier  超出mtu，需要分片时的组号标识
    uchar frag_and_flags;//标志3位   片偏移
    uchar ttl;            //time to live
    uchar proto;        //protocol (TCP\UDP etc)
    uchar checksum;        //IP checksum
    uint sourceIP;        
    uint destIP;
}IpHeader;


// ICMP header
//
typedef struct _ihdr {
  BYTE i_type;
  BYTE i_code; /* type sub code */
  USHORT i_cksum;
  USHORT i_id;
  USHORT i_seq;
  /* This is not the std header, but we reserve space for time */
  ULONG timestamp;
}IcmpHeader;


#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 *);
bool ping(IN_ADDR ip);

void Usage(char *progname){
  
  fprintf(stderr,"Usage:\n");
  fprintf(stderr,"%s <host> [data_size]\n",progname);
  fprintf(stderr,"datasize can be up to 1Kb\n");
  ExitProcess(STATUS_FAILED);
}



int _tmain(int argc, _TCHAR* argv[])
{
    IN_ADDR ipStart,ipEnd,ip,netMask;
    unsigned int iStart,iEnd,i;


    WSADATA wsaData;
    WSAStartup(MAKEWORD(2,2),&wsaData);//当一个应用程序调用WSAStartup函数时，
    //操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。
    //以后应用程序就可以调用所请求的Socket库中的其它Socket函数了


    ip.s_addr = inet_addr("192.168.26.155");//点分十进制转换成网络字节顺序
    netMask.s_addr = inet_addr("255.255.255.128");
    ipStart.s_addr = ip.s_addr & netMask.s_addr;//两个unlong,ip与掩码与 求出ip最小值
    ipEnd.s_addr = (ipStart.s_addr & netMask.s_addr) | ~netMask.s_addr;

    iStart = ntohl(ipStart.s_addr);//网络自己顺序转换成主机字节顺序
    iEnd = ntohl(ipEnd.s_addr);
    
    for(i = iStart+2;i<iEnd;i++)//iStart不可用，iStart+1一般做默认网关地址，iStart+2开始
    {
        ip.s_addr = htonl(i);
        printf("%s\n",inet_ntoa(ip));//in_addr（点分十进制）转换成字符串
        ping(ip);
    }
    WSACleanup();
    return 0;
}


bool ping(IN_ADDR ip)//ping程序
{
    SOCKET sockRaw;
    struct sockaddr_in dest,from;
    int bread,datasize;
    int fromlen = sizeof(from);
    int timeout = 1000;
    char *dest_ip;
    char *icmp_data;
    char *recvbuf;
    unsigned int addr = 0;
    USHORT seq_no = 0;

    struct timeval tv;
    tv.tv_sec =  3;
    tv.tv_usec = 0;

    
    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);
    }

    bread = setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout,sizeof(timeout));//设置1秒超时时间

    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));
    if(bread == SOCKET_ERROR) {
          fprintf(stderr,"failed to set send timeout: %d\n",WSAGetLastError());
        ExitProcess(STATUS_FAILED);
    }

    memset(&dest,0,sizeof(dest));//初始化

    dest.sin_addr = ip;
    dest.sin_family = AF_INET;
    dest_ip = inet_ntoa(dest.sin_addr);

    datasize = DEF_PACKET_SIZE;
    datasize += sizeof(IcmpHeader);

    icmp_data = (char*)xmalloc(MAX_PACKET);
    recvbuf = (char*)xmalloc(MAX_PACKET);


    if (!icmp_data) {
        fprintf(stderr,"HeapAlloc failed %d\n",GetLastError());
        ExitProcess(STATUS_FAILED);
    }


    memset(icmp_data,0,MAX_PACKET);
    fill_icmp_data(icmp_data,datasize);


    //while(1) {
        int bwrote;

        ((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;
            }
            fprintf(stderr,"sendto failed: %d\n",WSAGetLastError());
            ExitProcess(STATUS_FAILED);
        }
        if (bwrote < datasize ) {
            fprintf(stdout,"Wrote %d bytes\n",bwrote);
        }



        fd_set socketset;
        memset(&socketset, 0, sizeof(socketset));
        socketset.fd_count = 1;
        socketset.fd_array[0] = sockRaw;
        bread = select(0, &socketset, NULL, NULL, &tv);//非阻塞方式接收数据，接收不到显示超时继续ping后面的IP
        if (bread == 0){
            //if (WSAGetLastError() == WSAETIMEDOUT) {
            printf("recv timed out\n");
            //continue;
            //}
            //fprintf(stderr,"recvfrom failed: %d\n",WSAGetLastError());
            //ExitProcess(STATUS_FAILED);
        }
        else{
            bread = recvfrom(sockRaw,recvbuf,MAX_PACKET,0,(struct sockaddr*)&from,
                &fromlen);
            decode_resp(recvbuf,bread,&from);
        }
        //Sleep(1000);

    //}

    xfree(icmp_data);
    xfree(recvbuf);

}


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);//最多进一位，右移加上进位，不可能再次产生进位  比如99+99 =198  98+1=99 不会继续产生进位  
  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_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);//截取数据部分
  //
  // Place some junk in the buffer.
  //
  memset(datapart,'E', datasize - sizeof(IcmpHeader));//填充数据
}

/* 
    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;

    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 != ICMP_ECHOREPLY) {
        fprintf(stderr,"non-echo type %d recvd\n",icmphdr->i_type);
        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);//GetTickCount()操作系统从启动经过的毫秒数
    printf("\n");
        
}