Linux实现ICMP PING代码

最新推荐文章于 2024-08-16 10:56:01 发布
最新推荐文章于 2024-08-16 10:56:01 发布
阅读量537 收藏
点赞数
分类专栏： 【计算机网络】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rong_Toa/article/details/105371868
版权

目录

icmp.h

icmp.c

校验和的计算

icmp.h


#ifndef __CRTL_CRTL_ICMP_H
#define __CRTL_CRTL_ICMP_H 1


#define CRTL_ICMPING(ipv4) crtl_icmp_ping(ipv4, 1, 1, NULL, NULL, NULL, NULL)


int crtl_icmp_ping(const char *ipv4, unsigned int timeout, int ntry, void *data, int data_len,
                    int (*display)(void *handle, const char *fmt, ...), void *display_handle);




#endif /*<__CRTL_CRTL_ICMP_H>*/

icmp.c


#ifndef __USE_BSD
#define __USE_BSD
#endif

#include <sys/time.h>

#include <netdb.h>
#include <errno.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <fcntl.h>
#include <stdio.h>
#include <signal.h>
#include <arpa/inet.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/timerfd.h>
#include <sys/stat.h>
#include <sys/file.h>

#include <unistd.h>

#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h> //__USE_BSD


#include "crtl/crtl_types.h"

#include "crtl/crtl_log.h"
#include "crtl/easy/attribute.h"
#include "crtl/tcp-ip/crtl_icmp.h"
#include "crtl/tcp-ip/crtl_tcp_ip_checksum.h"
#include "crtl/crtl_time.h"


/* Constants ---------------------------------------------------------------------------------------------------------*/
#define CRTL_ICMP_BUF_SIZE           256
#define CRTL_ICMP_RECVBUF_SIZE       (50 * 1024)
#define CRTL_ICMP_MAGIC_ID           0xf1f2
#define CRTL_ICMP_PROTO_NAME         "icmp"
#define CRTL_ICMP_DATA               "CRTL's ICMP Ping"
    

/* type of icmp ping */
typedef struct __crtl_icmp_ping_s {
    int sockfd;
    struct sockaddr_in dst_addr, from_addr;
    int ntx, nrx, ntry;   //number of send pkg and recv pkg
    int tx, rx;
    int timeout_s;  //time out second
    void *data;
    int data_len;
    void *display_handle;
    int (*display)(void *handle, const char *fmt, ...);
    int rslt; //__CRTL_ICMP_PING_XXXX
}crtl_icmp_ping_t;


/* functions */


/* create a socke to icmp */
static _unused int crtl_icmp_socket()
{
    int sockfd;
    int size = CRTL_ICMP_RECVBUF_SIZE;
    
    struct protoent * protocol  = NULL;
    
    if ((protocol = getprotobyname(CRTL_ICMP_PROTO_NAME)) == NULL)
    {
        crtl_print_err("getprotobyname error.\n\r");
        return -1;
    }
    if ((sockfd = socket(AF_INET, SOCK_RAW, protocol->p_proto)) < 0)
    {
        crtl_print_err("socket error.\n\r");
        return -1;
    }
    if(setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size))!=0)
    {
        crtl_print_err("setsockopt SO_RCVBUF error.\n\r");
        close(sockfd);
        return -1;
    }
#if 1    
    struct timeval timeout = {1,0}; //sec
    if(setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(struct timeval))!=0)
    {
        crtl_print_err("setsockopt SO_RCVTIMEO error.\n\r");
        close(sockfd);
        return -1;
    }
#endif    
    return sockfd;
}

/* get dst address */
static _unused int crtl_icmp_dst_addr(const char *addrHost, struct sockaddr_in * dst_addr)
{
    struct hostent  * host      = NULL;
    unsigned long   inaddr      = 0;

    bzero(dst_addr, sizeof(struct sockaddr_in));
    dst_addr->sin_family = AF_INET;

    if ((inaddr = inet_addr(addrHost)) == INADDR_NONE)
    {
        if ((host = gethostbyname(addrHost)) == NULL)
        {
            crtl_print_err("gethostbyname error.\n\r");
            return (-1);
        }
        memcpy((char *) &dst_addr->sin_addr, host->h_addr, host->h_length);
    }
    else 
    {
        memcpy((char *) &dst_addr->sin_addr, (char *) &inaddr, sizeof(dst_addr->sin_addr));
    }
    
    return 0;
}


/* set icmp hdr */
static _unused int crtl_icmp_pkg_pack(void *buffer, int pack_no, const void *data, int data_size)
{
    int packsize = 0;

    struct icmp * icmp  = malloc(sizeof(struct icmp));
    icmp->icmp_type     = ICMP_ECHO;
    icmp->icmp_code     = 0;
    icmp->icmp_cksum    = 0;
    icmp->icmp_seq      = htons(pack_no);
    icmp->icmp_id       = htons(CRTL_ICMP_MAGIC_ID);

    gettimeofday((struct timeval *) &icmp->icmp_data, NULL);

    memcpy(buffer, icmp, sizeof(struct icmp));
    packsize += sizeof(struct icmp);

    if(data && data_size)
    {
        memcpy(buffer+packsize, data, data_size);
        packsize += data_size;
        
    }

    return packsize;
}



/* send icmp package */
static _unused int crtl_icmp_send_pkg(crtl_icmp_ping_t *ping, const void *data, int size)
{
    int             packetsize;
    unsigned short  checksum = 0;
    int             n = 0;
    
    char pkg_buffer[CRTL_ICMP_BUF_SIZE];
    
    packetsize  = crtl_icmp_pkg_pack(pkg_buffer, ping->ntx, data, size);
    checksum    = crtl_tcp_ip_chksum1((unsigned short *)pkg_buffer, packetsize);
    
#define CRTL_ICMP_PKG_CHKSUM_OFFSET  offsetof(struct icmp, icmp_cksum)
#define CRTL_ICMP_PKG_CHKSUM_SIZE    2

    memcpy(pkg_buffer + CRTL_ICMP_PKG_CHKSUM_OFFSET, &checksum, CRTL_ICMP_PKG_CHKSUM_SIZE);

    if ((n = sendto(ping->sockfd, pkg_buffer, packetsize, 0, 
                     (struct sockaddr *) &ping->dst_addr, sizeof(struct sockaddr_in)))< 0)
    {
        crtl_print_err("sendto error. n = %d\n\r", n);
        return 0;
    }
    ping->ntx++;
                     
    return n;
}


/* send icmp package */
static _unused int crtl_icmp_recv_pkg(crtl_icmp_ping_t *ping, void *recvbuf, int size)
{
    int n;
    socklen_t fromlen;
    
    fromlen = sizeof(struct sockaddr_in);
    
    if ((n = recvfrom(ping->sockfd, recvbuf, size, 0, 
                      (struct sockaddr *) &ping->from_addr, &fromlen)) < 0)
    {
        crtl_print_err("recvfrom error.n = %d\n\r", n);
        return 0;
    }

    ping->nrx++;
    
    return n;
}


/* unpack icmp pkg */
static _unused int crtl_icmp_pkg_unpack(crtl_icmp_ping_t *ping, char * buf, int len)
{
    int     iphdrlen;

    struct  ip * ip = NULL;
    struct  icmp * icmp = NULL;
    struct  timeval * tvsend = NULL;
    double  rtt;

    ip          = (struct ip *)buf;
    iphdrlen    = ip->ip_hl << 2;
    icmp        = (struct icmp *) (buf + iphdrlen);
    len        -= iphdrlen;

    if (len < 8)
    {
        crtl_print_err("ICMP packet\'s length is less than 8\n\r");
        return - 1;
    }

    /* ensure icmp reply is mine response msg */
    if ((icmp->icmp_type == ICMP_ECHOREPLY) && (icmp->icmp_id = ntohs(CRTL_ICMP_MAGIC_ID)))
    {
        tvsend  = (struct timeval *)icmp->icmp_data;

        struct timeval tvrecv;
        gettimeofday(&tvrecv, NULL);
        crtl_timeval_subabs(&tvrecv, tvsend, &tvrecv);
        rtt = tvrecv.tv_sec * 1000 + tvrecv.tv_usec / 1000;
        if(ping->display)
            ping->display(ping->display_handle, "%d byte from %s: crtl_icmp_req=%u ttl=%d rtt=%.3f ms\n", 
                        len, inet_ntoa(ping->from_addr.sin_addr), ntohs(icmp->icmp_seq), ip->ip_ttl, rtt);
        else
            printf("%d byte from %s: crtl_icmp_req=%u ttl=%d rtt=%.3f ms\n", 
                         len, inet_ntoa(ping->from_addr.sin_addr), ntohs(icmp->icmp_seq), ip->ip_ttl, rtt);
    }
    else 
    {
        return - 1;
    }
    return 0;
}



/**********************************************************************************************************************/
/* icmp ping with timeout */
static _unused void crtl_icmp_ping_finish (crtl_icmp_ping_t *ping)
{
    if(ping->display)
    {
        ping->display(ping->display_handle, "\n--- ping statistics ---\n");
        ping->display(ping->display_handle, "%d packets transmitted, %d received, %d%% lost\n", 
                        ping->ntx, ping->nrx, 
                        (ping->ntx - ping->nrx) / ping->ntx * 100);
    }
    else
    {
        printf("\n--- ping statistics ---\n");
        printf("%d packets transmitted, %d received, %d%% lost\n", 
                    ping->ntx, ping->nrx, 
                    (ping->ntx - ping->nrx) / ping->ntx * 100);
    }
    
    if(ping->ntx == ping->ntry)
        ping->rslt = CRTL_SUCCESS;
    
    return;
}

static _unused crtl_icmp_ping_t* crtl_icmp_ping_init(const char *ipv4, int timeout_sec, int ntry, void *data, int data_len, int (*display)(void *handle, const char *fmt, ...), void *display_handle)
{
    crtl_icmp_ping_t *ping = (crtl_icmp_ping_t *)malloc(sizeof(crtl_icmp_ping_t));
    if(!ping) return NULL;

    memset(ping, 0x00, sizeof(crtl_icmp_ping_t));
    
    ping->sockfd    = crtl_icmp_socket();
    ping->timeout_s = timeout_sec;
    ping->ntry      = ntry;
    ping->display       = display;
    ping->display_handle = display_handle;
    ping->data = data;
    ping->data_len = data_len;
    
    crtl_icmp_dst_addr(ipv4, &ping->dst_addr);
    
    if(ping->display)
        ping->display(ping->display_handle, "PING %s(%s): %ld bytes data in ICMP packets.\n", 
                       ipv4, inet_ntoa(ping->dst_addr.sin_addr), sizeof(CRTL_ICMP_DATA));
    else
        printf("PING %s(%s): %ld bytes data in ICMP packets.\n", 
                       ipv4, inet_ntoa(ping->dst_addr.sin_addr), sizeof(CRTL_ICMP_DATA));
    return ping;
}

static _unused int crtl_icmp_ping_destroy(crtl_icmp_ping_t* ping)
{
    if(ping)
    {
        close(ping->sockfd);
        free(ping);
    }
//    free(ping);
    ping = NULL;
    return 0;
}

/* PING */
_api int crtl_icmp_ping(const char *ipv4, unsigned int timeout, int ntry, void *data, int data_len,
                            int (*display)(void *handle, const char *fmt, ...), void *display_handle)
{
    crtl_icmp_ping_t *ping = crtl_icmp_ping_init(ipv4, timeout, ntry, data, data_len, display, display_handle);

    char pkg_buffer[CRTL_ICMP_BUF_SIZE];

    ping->rslt = CRTL_ERROR;

    while(ping->ntx < ping->ntry)
    {
        ping->tx = crtl_icmp_send_pkg(ping, ping->data?ping->data:CRTL_ICMP_DATA, ping->data?ping->data_len:sizeof(CRTL_ICMP_DATA));
        if(ping->tx < 8) 
        {
            ping->rslt = CRTL_ERROR;
            break;
        }
        
        ping->rx = crtl_icmp_recv_pkg(ping, pkg_buffer, ping->tx);
        if(ping->rx<8) 
        {
            ping->rslt = CRTL_ERROR;
            break;
        }
        if (crtl_icmp_pkg_unpack(ping, pkg_buffer, ping->rx) == -1)
            continue;
        //sleep(1);
    }
    
    crtl_icmp_ping_finish(ping);
    crtl_icmp_ping_destroy(ping);
    
    return ping->rslt;
}

校验和的计算

https://rtoax.blog.csdn.net/article/details/105302111

rtoax
关注
专栏目录
ICMP->linux c PING功能实现
yldfree的博客
09-14 3307
报文格式: \ 代码 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/socket.h&gt; #include &lt;netinet/ip_icmp.h&gt; //struct icmp #include &lt;netinet/in.h&...
使用linux的ICMP实现ping功能
Feng_8071的博客
07-03 2667
1.ICMP(Internet Control Message,网际控制报文协议)是为网关和目标主机而提供的一种差错控制机制，使它们在遇到差错时能把错误报告给报文源发方。ICMP协议是IP层的一个协议，但是由于差错报告在发送给报文源发方时可能也要经过若干子网，因此牵涉到路由选择等问题，所以ICMP报文需通过IP协议来发送。ICMP数据报协议由ICMP报头和IP报文封装而成。 2.IP层协议是一种...
Linux系统C++实现ICMP功能
12-16
此demon是C++代码实现Linux系统PING包功能,源码在压缩文件src文件夹下，示例为./aout 192.168.1.1 (或加次数)
Linux 内核源码分析---内核ICMP协议分析
最新发布
学习记录
08-16 1139
学习记录
Linux - ICMP协议
m0_50597798的博客
10-08 879
注意需要创建ICMP报文，但是只有root用户才可以创建ICMP报文，因此在执行的时候需要使用root权限。,输入root密码即可。否则在创建socket的时候会产生。循环发送 MAX_NO_PACKETS次包。
ping计算机术语,解析ICMP的ping命令代码(一) -电脑资料
weixin_29534143的博客
07-17 274
在ICMP的应用中，我们可以使用ping命令来进行操作，原理简介:这个例子演示了应用微软的ICMP.DLL怎样"ping"另一台机器. 这个DLL是没有文档话的发送ICMP回送包API接口, 也称为"pings," 就像潜水员对声纳信号的术语一样. 这段代码出自一个被一个名叫MarkG的家伙的GUI程序, 他的网页已经消失了.ICMP.DLL API 现在在Windows平台上与微软的Winsoc...
linux上实现ping功能的源码
08-24
linux平台自己实现ping的功能，ping是基于ICMP协议实现的一种网络链路测试工具，提供用户自己测试链路，IP在代码里写死了，可以根据自己的需要加以修改。
Linux实用技巧 用ICMP实现简单的Ping功能
03-04
总的来说，通过这段代码，我们可以了解到如何在Linux环境中利用ICMP协议实现ping功能的基本原理和步骤。这涉及到网络编程、套接字API以及ICMP协议的细节。这样的技巧对于网络管理员、系统程序员或对底层网络通信感...
Linux下利用ICMP协议实现ping命令
zhouxinkai311的专栏
05-13 2477
ping运行结果：从我
ICMP下的简单ping程序
06-02
linux C ICMP PIng
C实现Ping功能 基于ICMP协议
08-03
C实现Ping功能 基于ICMP协议C实现Ping功能 基于ICMP协议C实现Ping功能 基于ICMP协议C实现Ping功能 基于ICMP协议
基于socket实现Ping功能的源代码
08-10
基于socket的网络编程技术，用到SOCK_RAW的原始套接字类型。里面对简单ICMP协议和IP协议有着很完整的诠释和定义。可以交流zhaquanmin@163.com
Linux用ICMP协议实现简单Ping网络监测功能
herobox的专栏
06-03 1031
ICMP是（Internet Control Message Protocol）Internet控制报文协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。 ICMP协议是一种面向无连接的协议，用于传输出错报告控制信息。它是
Linux网络协议之ICMP协议分析
m0_74282605的博客
03-01 243
因为当ICMP数据包的大小超过64K的时候，目标主机就有可能出现内存分配的错误的情况，导致TCP/IP堆栈崩溃，使得主机死机。但是需要我们注意的是，这个数据包的IP头中的TTL的值为1，这也就意味着这个数据包会在它所遇到的第一个路由器的地方被丢弃。而第七个数据包的TTL的值变成了2。但是即便TTL的值变成了2，从下面的数据包来看，它也是无法到达目的地，直至TTL的值增长到9，这个数据包才到达了目的地。当然我们在未来的课程中还会遇到ICMP协议，还会研究它的不同的功能，因此说ICMP是一个用途广泛的协议。
linux下ping程序实现
fulianzhou的专栏
02-27 689
ping.h #ifndef __PING_H_ #define __PING_H_ #include <stdio.h> #include <stdlib.h> #include <linux/icmp.h> #include <linux/if_ether.h> #include <linux/ip.h> #include <sys/socket.h> #include <sys/types.h> #include &
Ping命令的实现
weixin_30718391的博客
02-19 140
PING (Packet InterNet Groper) 是一个非常有用的命令,它可以用来测试两个主机之间的连通性.PING使用了ICMP回送请求与回送回答报文.PING是应用层直接使用网络层ICMP的一个例子.它没有通过运输层的TCP或UDP. 在Windows平台编程实现PING的最简单方法是调用Iphlpapi.dll这个动态链接库，引用以下几个函数: 1...
linux系统重复ping,Linux下Ping的实现代码
weixin_33539366的博客
04-29 282
#include #include #include #include #include #include#define PACKET_SIZE 4096#define ERROR 0#define SUCCESS 1// 效验算法unsigned short cal_chksum(unsigned short *addr, int len){int n...
C语言实现Linux下的ping程序
在Linux环境下，编写一个类似于系统自带的`ping`命令的程序，主要涉及到的是网络编程和对Internet Control Message Protocol (ICMP)的理解。ICMP是一个用于网络诊断和错误报告的协议，它属于TCP/IP协议栈的一部分。`...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值