# include       <stdio.h># include       <stdlib.h># include       <string.h>  
# include       <fcntl.h>  
# include       <errno.h> 
# include       <signal.h> 
# include       <sys/types.h> 
# include       <sys/socket.h> 
# include       <sys/time.h> 
# include       <netinet/in.h> 
# include       <arpa/inet.h> 
# include       <netdb.h> 

# define        ICMP_ECHO       8       /* 定義icmp echo */ 
# define        ICMP_ECHOREPLY 0       /* 定義icmp echo reply */ 
# define        ICMP_HEADSIZE   8       /* 定義icmp 包頭的大小 */ 
# define        IP_HEADSIZE     20      /* 定義ip 包頭的大小 */ 

    /* 以下是定義的兩個用來比較大小的宏 */ 
# define        MAX(a,b)        ((a) > (b))? (a):(b) 
# define        MIN(a,b)        ((a) > (b))? (b):(a) 

typedef struct tagIpHead               /* 定義icmp 包頭數據結構 */ 
{ 
        u_char          ip_verlen;      /* ip version 和 ip header 的長度 */ 
        u_char          ip_tos;         /* service的ip類型 */ 
        u_short         ip_len;         /* ip包的長度 */ 
        u_short         ip_id;          /* ip包的標識號 */ 
        u_short         ip_fragoff;     /* ip包的起始地址 */ 
        u_char          ip_ttl;         /* ip包的存活時間 */ 
        u_char          ip_proto;       /* ip包的協議類型 */ 
        u_short         ip_chksum;      /* ip包頭的檢驗長度 */ 
        u_long          ip_src_addr;    /* ip包的源地址 */ 
        u_long          ip_dst_addr;    /* ip包的目標地址 */ 
} IPHEAD; 

typedef struct tagIcmpHead              /* icmp 頭結構 */ 
{ 
        u_char          icmp_type;      /* icmp 服務類型 */ 
                                        /* 8 echo require, 0 echo reply */ 
        u_char          icmp_code;      /* icmp包頭代碼 */ 
        u_short         icmp_chksum;    /* icmp包頭的檢驗和 */ 
        u_short         icmp_id;        /* icmp包的標識號 */ 
        u_short         icmp_seq;       /* icmp包隊列 */ 
        u_char          icmp_data[1];   /* icmp包數據，指針類型 */ 
} ICMPHEAD; 

/********************************************************************* 
        函數ChkSum用來作奇偶校驗。 
    參數： 
u_short * pIcmpData數據起始地址 
        int iDataLen為數據長度 
    返回值： 
        校驗結果 
*********************************************************************/ 
u_short ChkSum( u_short * pIcmpData, int iDataLen ) 
{ 
        u_short iSum; 
        u_short iOddByte; 

        iSum = 0; 

        while ( iDataLen > 1 ) {          
                iSum = iSum ^ (*pIcmpData++);        /* 和下一個數據作異或操作 */ 
                iDataLen -= 2; 
        } 

        if ( iDataLen == 1 ) {          /* 剩下的奇數位 */ 
                iOddByte = 0; 
                *((u_char *)&iOddByte) = *(u_char *)pIcmpData; 
                iSum ^= iOddByte; 
        } 

        iSum ^= 0xffff;                 /* 取反操作 */ 
        return(iSum); 
} 
/******************************************************************************* 
    time_now函數用來返回系統時間。 
    返回值： 
        系統的當前時間和1970.1.1 00:00:00之間的時間間隔， 
        用微妙來表示。 
********************************************************************************/ 
long time_now() 
{ 
        struct timeval now; 
        long    lPassed; 
        gettimeofday(&now, 0); 
        lPassed = now.tv_sec * 1000000 + now.tv_usec; 
                                        /* now.tv_sec 中保存了秒數*/ 
                                        /* now.tv_usec 中保存了微妙數 */ 
        return lPassed; 
} 

char*   host;                   /* 目標主機 */ 
char*   prog;                   /* 程序名稱 */ 
extern errno;                  /* 系統全局變量 */ 
long    lSendTime;              /* 數據包的發送時間，在發數據時被改變 */ 
u_short seq;                    /* icmp包隊列 */ 
int     iTimeOut;               /* 超時時間 */ 
int     sock, sent, recvd, max, min, total; 
                                /* sent : 發送出去的包的數目 */ 
                                /* recvd: 接收到的包的數目 */ 
                                /* max, min: 最大和最小的往返時間 */ 
                                /* total: 總共用時 */ 
                                /* 用來計算平均值 */ 
u_long lHostIp;                /* 主機的ip地址 */ 
struct sockaddr_in it;          /* 目標主機的信息 */ 

int ping(); 
void stat(); 
main(int argc, char** argv) 
{ 
        struct hostent* h; 
        char            buf[200]; 
        char            dst_host[32]; 
        int             i, namelen; 
        IPHEAD*         pIpHead; 
        ICMPHEAD*       pIcmpHead; 

        if (argc < 2) {         /* 每一個超時時間后ping一次指定的主機 */ 
                                /* 缺省的超時時間為1秒 */ 

                printf("usage: %s [-timeout] host|IP\n", argv[0]); 
                exit(0); 
        } 
        prog = argv[0]; 
        host = argc == 2 ? argv[1] : argv[2]; 
        iTimeOut = argc == 2 ? 1 : atoi(argv[1]); 

        /* 創建icmp套接字 */ 

        if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) { 
                perror("socket"); 
                exit(2); 
        } 

        /* 設置目標主機信息 */ 

        bzero(&it, sizeof(it)); 
        it.sin_family = AF_INET; 

        /* 檢查主機地址類型 */ 

        if ( ( lHostIp = inet_addr(host) ) != INADDR_NONE ) { 
                                                /* 合法的ip地址 */ 
                it.sin_addr.s_addr = lHostIp; 
                strcpy( dst_host, host ); 
        } else if ( h = gethostbyname(host) ) { 
                                                /* 獲取合法的主機名稱 */ 
                                                /* 從本地機上獲取*/ 
                                                /* 或從DNS服務器上獲取 */ 
                bcopy(h->h_addr, &it.sin_addr, h->h_length); 
                sprintf( dst_host, "%s (%s)", host, 
                         inet_ntoa(it.sin_addr) ); 
        } else { 
                                                /* 錯誤的ip地址或主機名稱 */ 
                                                /* 在這種情況下程序便退出 */ 
                fprintf( stderr, "bad IP or host\n" ); 
                exit(3); 
        } 
        namelen = sizeof(it); 
   
        printf("\npinging %s, send %d bytes\n", 
                dst_host, 
                IP_HEADSIZE + ICMP_HEADSIZE + sizeof(long) 
                ); 
   
        seq = 0;                /* 第一個 icmp_seq = 0 */ 
        sigset(SIGINT, stat);   /* 按鍵響應函數，當收到del 或 ctrl+c */ 
    /*按鍵操作后便調用 stat函數 */ 
                                /* 顯示完結果，便退出 */ 
        sigset(SIGALRM, ping); /* 設置超時處理函數 */ 
                                /* 收到超時信號后便去調用ping函數 */ 
        alarm(iTimeOut);        /* 啟動計時器 */ 
                                /* 以秒為單位 */ 
        ping(); 
        for ( ;; ) {            /* 等待每個返回的 */ 
                                /* icmp包，并且處理它 */ 
                register size; 
                register u_char ttl; 
                register delta; 
                register iIpHeadLen; 
   
                /* 阻塞并獲取返回的數據包 */ 
   
                size = recvfrom(sock, buf, sizeof(buf), 0, 
                                (struct sockaddr *)&it, &namelen); 
                if (size == -1 && errno == EINTR) { 
                                /* 獲取數據時出錯或者是系統調用被信號所中斷 */ 
                     //   continue; 
                } 
   
                /* 計算數據包的往返時間 */ 
                /* 用當前系統時間減去發送此包時的系統時間來獲得 */ 
   
                delta = (int)((time_now() - lSendTime)/1000); 
   
                /* 獲取返回的數據包并檢查它的ip頭 */ 
   
                pIpHead = (IPHEAD *)buf; 
   
                /* 檢查包的大小，如果包太小，那么就不是返回的icmp數據包 */ 
                /* 這時，便丟棄這個包 */ 
   
                iIpHeadLen = (int)((pIpHead->ip_verlen & 0x0f) << 2); 
                if (size < iIpHeadLen + ICMP_HEADSIZE) { 
                    //    continue; 
                } 
                ttl = pIpHead->ip_ttl;          /* 數據包的存活時間 */ 
   
                /* 獲取icmp 頭信息 */ 
                pIcmpHead = (ICMPHEAD *)(buf + iIpHeadLen); 
   
                /* 不是icmp返回包，丟棄它 */ 
                if (pIcmpHead->icmp_type != ICMP_ECHOREPLY) { 
                    //    continue; 
                } 
   
                /* 不是正確的icmp隊列號，丟棄它 */ 
                if (pIcmpHead->icmp_id != seq || pIcmpHead->icmp_seq != seq) { 
                   //     continue; 
                } 
   
                /* 給每個返回icmp包打印返回信息 */ 
                sprintf( buf, "icmp_seq=%u bytes=%d ttl=%d", 
                        pIcmpHead->icmp_seq, size, ttl ); 
                fprintf(stderr, "reply from %s: %s time=%d ms\n", 
                            host, buf, delta); 
   
                /* 計算ping的結果，包括： */ 
                /* 數據包的最大、最小、平均往返時間 */ 
                /* 收到的返回icmp數據包的數目 */ 
                max = MAX(delta, max); 
                min = min ? MIN(delta, min) : delta; 
                total += delta; 
                ++ recvd; 
   
                /* 緊接著下一個的icmp數據包 */ 
   
                ++ seq; 
        } 
} 
   
/*****
    ping函數 
        向指定的目標地址發送icmp數據包。 
    無參數，無返回值。 
    使用全局變量******************/ 
ping() 
{ 
        char    buf[200]; 
        int     iPacketSize; 
        /* 設置icmp數據包的頭信息 */ 
        ICMPHEAD *pIcmpHead = (ICMPHEAD *)buf; 
        pIcmpHead->icmp_type = ICMP_ECHO; 
        pIcmpHead->icmp_code = 0; 
        pIcmpHead->icmp_id = seq; 
        pIcmpHead->icmp_seq = seq; 
        pIcmpHead->icmp_chksum = 0; 
   
        /* store time information as icmp packet content, 4 bytes */ 
        /* 你也可以在此存儲一些別的信息 */ 
   
        *((long *)pIcmpHead->icmp_data) = time_now(); 
   
        iPacketSize = ICMP_HEADSIZE + 4;        /* icmp包的長度 */ 
   
        /* icmp包數據的奇偶校驗 */ 
   
        pIcmpHead->icmp_chksum = ChkSum((u_short *)pIcmpHead, 
                                                iPacketSize ); 
   
        /* 存儲發送包的時間，以便用來計算數據包的往返時間 */ 
        lSendTime = time_now(); 
   
        /* 向指定的目標地址發送icmp數據包 */ 
        if ( sendto(sock, buf, iPacketSize, 0, (struct sockaddr *)&it, 
                sizeof(it) ) < 0) { 
                perror("send failed"); 
                exit(6); 
        } 
   
        /* 總共發送的數據包數目 */ 
        ++sent; 
   
        /* 重新設置計時器 */ 
        alarm(iTimeOut); 
} 
/******    stat函數： 
        打印結果信息。 ******/ 
void stat() 
{ 
        if (sent) { 
                printf("\n----- %s ping statistics summerized by Digger-----\n" 
                        , host ); 
                printf("%d packets sent, %d packets received, %.2f%% lost\n", 
                        sent, recvd, (float)(sent-recvd)/(float)sent*100 ); 
        } 
        if (recvd) { 
                printf("round_trip min/avg/max: %d/%d/%d ms\n\n", 
                        min, total/recvd, max ); 
        } 
        exit(0); }