Linux C++实现ping指令教程

//#include "ping.h"
#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <netinet/ip_icmp.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>

#define PACKET_SIZE 4096
#define SEND_DATA_LEN 56
#define ERROR    -1
#define SUCCESS   1
#define MAX_WAIT_TIME 3
#define MAX_NO_PACKETS 4
#define NULL 0

using namespace std;

class Cping
{
    public:
        Cping(const char * ip, int timeout);
        Cping(const Cping& org);
        virtual ~Cping();
    
    private:
        std::string m_strIp;
        std::string m_copy_Ip;
        
        int m_nSend;
        int m_nRecv;
        struct sockaddr_in m_dest_addr;
        struct sockaddr_in m_from_addr;
        
        char m_sendpacket[PACKET_SIZE];
        char m_recvpacket[PACKET_SIZE];
        
        struct timeval m_tvrecv;
        struct timeval m_begin_tvrecv;
        struct timeval m_end_tvrecv;
        double m_dTotalResponseTimes;
        int m_nSocketfd;
        
        int m_nMaxTimeWait;
   public:
        bool ping(int times);
        bool CreateSocket();
        bool CloseSocket();
        
        void send_packet(void);
        void recv_packet(void);
        
        int pack(int pack_no);
        int unpack(char *buf, int len);
        
        void tv_sub(struct timeval *out, struct timeval *in);
        void statistics(int sig);
        
        static unsigned short cal_chksum(unsigned short *addr, int len);
};

Cping::Cping(const char *ip, int timeout)
{
    m_strIp = ip;
    m_copy_Ip = ip;
    
    m_nSend = 0;
    m_nRecv = 0;
    
    m_dTotalResponseTimes = 0;
    
    if(timeout > MAX_WAIT_TIME)
    {
        m_nMaxTimeWait = MAX_WAIT_TIME;
    }
    else
    {
        m_nMaxTimeWait = timeout;
    }
}

Cping::~Cping()
{
    if(!CloseSocket())
    {
        cout << "CloseSocket failed!" << endl;
    }
}

bool Cping::ping(int times)
{
    if(!CreateSocket())
    {
        printf("CreateSocket failed!!!\n");
        return false;
    }
    printf("PING %s(%s): %d bytes data in ICMP packets.\n", m_strIp.c_str(),
                    m_copy_Ip.c_str(), SEND_DATA_LEN);
    while(times--)
    {
        send_packet();
        recv_packet();
        sleep(1);
    }
    statistics(SIGINT);
    return true;
}

bool Cping::CreateSocket()
{
    char buf[2048];
    int errnop = 0;
    unsigned long inaddr;
    struct hostent hostinfo, *dest_phost;
    struct protoent *protocol = NULL;
    
    if((protocol = getprotobyname("icmp")) == NULL)
    {
        perror("getprotobyname()");
        printf("CreateSocket : getprotobyname failed:%d\n",errnop);
        return false;
    }
    if(-1 == (m_nSocketfd = socket(AF_INET,SOCK_RAW,protocol->p_proto)))
    {
        perror("socket");
        printf("CreateSocket: create socket failed:%d\n", m_nSocketfd);
        return false;
    }
    setuid(getuid());
    m_dest_addr.sin_family = AF_INET;
    
    bzero(&(m_dest_addr.sin_zero),8);
    
    if((inaddr = inet_addr(m_strIp.c_str())) == INADDR_NONE)
    {
        //if(getprotobyname_r(m_strIp.c_str(), &hostinfo, buf, sizeof(buf), &dest_phost, &errnop))
        //{
        //    printf("CreateSocket: getprotobyname error %s failed:%d\n", m_strIp.c_str(),errnop);
        //    return false;
        //}
        //else
        //{
            m_dest_addr.sin_addr = *((struct in_addr *)dest_phost->h_addr); 
        //}
    }
    else
    {
        m_dest_addr.sin_addr.s_addr = inaddr;
    }
    
    m_copy_Ip = inet_ntoa(m_dest_addr.sin_addr);
    
    return true;
}

bool Cping::CloseSocket()
{
    bool flag = false;
    if(m_nSocketfd)
    {
        close(m_nSocketfd);
        flag = true;
    }
    return flag;
}

void Cping::send_packet(void)
{
    int packetsize;
    packetsize = pack(m_nSend);
    
    if((sendto(m_nSocketfd, m_sendpacket, packetsize, 0 ,(const struct sockaddr*)&m_dest_addr, sizeof(m_dest_addr))) < 0)
    {
        printf("send_packet: send error :\n");
    }
    m_nSend++;
}

void Cping::recv_packet(void)
{
    int fromlen, packetsize, n;
    while(m_nRecv < m_nSend)
    {
        struct timeval timeout;
        fd_set readfd;
        FD_ZERO(&readfd);
        
        FD_SET(m_nSocketfd, &readfd);
        
        int maxfd = m_nSocketfd + 1;
        timeout.tv_sec = m_nMaxTimeWait;
        
        timeout.tv_usec = 0;
        
        n = select(maxfd, &readfd, NULL, NULL, &timeout);
        
        switch(n)
        {
            case 0:
                printf("recv_packet: select time out: \n");
                break;
            case -1:
                printf("recv_packet: select error: \n");
                break;
            default:
                if(FD_ISSET(m_nSocketfd, &readfd))
                {
                    if((packetsize = recvfrom(m_nSocketfd, m_recvpacket, sizeof(m_recvpacket), 0,(struct sockaddr *)&m_from_addr,(socklen_t*)&fromlen)) < 0)
                    {
                        printf("packetsize = %d\n", packetsize);
                        //printf("recv_packet: recv error: %d\n", errno);
                        return ;
                    }
                    gettimeofday(&m_tvrecv, NULL);
                    m_end_tvrecv.tv_usec = m_tvrecv.tv_usec;
                    m_end_tvrecv.tv_sec = m_tvrecv.tv_sec;
                    
                    if(unpack(m_recvpacket, packetsize) == -1)
                    {
                        continue;
                    }
                    m_nRecv++;
                }
                break;
        }
    }
}

int Cping::pack(int pack_number)
{
    int packsize;
    struct icmp *pIcmp;
    struct timeval *pTime;
    
    pIcmp = (struct icmp*)m_sendpacket;
    
    pIcmp->icmp_type = ICMP_ECHO;
    pIcmp->icmp_code = 0;
    pIcmp->icmp_cksum = 0;
    pIcmp->icmp_seq = pack_number;
    pIcmp->icmp_id = getpid();
    packsize = 8 + SEND_DATA_LEN;
    pTime = (struct timeval *)pIcmp->icmp_data;
    gettimeofday(pTime, NULL);
    if(m_nSend == 0)
    {
        m_begin_tvrecv.tv_usec = pTime->tv_usec;
        m_begin_tvrecv.tv_sec = pTime->tv_sec;
    }
    pIcmp->icmp_cksum = cal_chksum((unsigned short*)pIcmp, packsize);
    return packsize;
}

int Cping::unpack(char *buf, int len)
{
    int i, iphdrlen;
    struct icmp *pIcmp;
    struct timeval *tvsend;
    struct ip* recv_ip = (struct ip*)buf;
    double rtt;
    
    iphdrlen = recv_ip->ip_hl << 2;
    pIcmp = (struct icmp*)(buf + iphdrlen);
    len -= iphdrlen;
    if(len < 8)
    {
        printf("ICMP packets's length is less than 8'");
        return -1;
    }
    
    if((pIcmp->icmp_type == ICMP_ECHOREPLY) && (m_copy_Ip == inet_ntoa(m_from_addr.sin_addr)) && (pIcmp->icmp_id = getpid()) )
    {
        tvsend = (struct timeval *)pIcmp->icmp_data;
        tv_sub(&m_tvrecv, tvsend);
        rtt = m_tvrecv.tv_sec * 1000 + (double)m_tvrecv.tv_usec / 1000;
        
        printf("%d byte from %s : icmp_seq=%u ttl=%d time=%.3fms\n",
            len,
            inet_ntoa(m_from_addr.sin_addr),
            pIcmp->icmp_seq,
            recv_ip->ip_ttl,
            rtt);
    }
    else
    {
        printf("throw away the old package %d\tbyte from %s\t: icmp_seq=%u\t: icmp_seq=%u\t ttl=%u\trtt=%.3f\tms",
        len,
        inet_ntoa(m_from_addr.sin_addr),
        pIcmp->icmp_seq,
        recv_ip->ip_ttl,
        rtt);
        return -1;
    }
    return 1;
}

void Cping::tv_sub(struct timeval *out, struct timeval *in)
{
    if((out->tv_usec -= in->tv_usec) < 0)
    {
        --out->tv_sec;
        out->tv_usec += 10000000;
    }
    out->tv_sec -= in->tv_sec;
}

void Cping::statistics(int sig)
{
    tv_sub(&m_end_tvrecv, &m_begin_tvrecv);
    m_dTotalResponseTimes = m_end_tvrecv.tv_sec * 1000 + (double)m_end_tvrecv.tv_usec / 1000;
    printf("--------statistics----------\n");
    printf("%d packets transmitted, %d received, %d%% lost, time: %.3lfms\n", m_nSend, m_nRecv,(m_nSend - m_nRecv) / m_nSend*100, m_dTotalResponseTimes);
    close(m_nSocketfd);
}

unsigned short Cping::cal_chksum(unsigned short *addr, int len)
{
    int nleft=len;
    int sum = 0;
    unsigned short *w = addr;
    unsigned short answer = 0;
    
    while(nleft > 1)
    {
        sum += *w++;
        nleft -=2;
    }
    
    if(nleft == 1)
    {
        *(unsigned char *)(&answer) = *(unsigned char *)w;
        sum += answer;
    }
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);
    answer = ~sum;
    
    return answer;
}

int main(int argc, char *argv[])
{
    Cping Ping(argv[1], 20);
    Ping.ping(3);
}

命名为 myping.cpp
编译命令：sudo g++ -o myping myping.cpp
修改权限：sudo chmod u+s myping
使用：./myping 192.168.1.222