linux原始套接字-发送ICMP报文

原始套接字 要解决上面这些问题需要原始套接字。原始套接字主要应用在底层网络编程上,之前的TCP、UDP的套接字称为标准套接字,下图所示为标准套接字与原始套接字之间的关系。标准套接字与网络协议栈的TCP、UDP层打交道,而原始套接字则与IP层级网络协议栈核心打交道。 原始套接字提供以下3种标准套接字不具备的功能。使用原始套接字可以读/写分组。例:ping程序就使用原始套接字发送ICMP回显请求,并接受ICMP回显应答。用于多播的守护程序,同样适用原始套接字来发送和接收IGMP分组。上述功能同样允许使用构造的应用程序完全作 阅读详情

本程序可以使得一个不存在的ip被ping通,演示了如何通过PF_PACKET SOCK_RAW来接收和发送arp和icmp帧。

1、开启网卡混杂模式。
2、接收 arp request。
3、伪造 arp reply,响应请求者。
4、接收 icmp echo request。
5、伪造 icmp echo reply,响应请求者。

本程序在ubuntu 14.04下编译调试通过。
编译命令:gcc -m32 -g -Wall xping.c
启动参数:./a.out eth1 192.168.2.70
随便找一台电脑 ping 192.168.2.70

稍加改造就可以让一个局域网内的所有的ip都被ping通,因此本示例仅供学习参考。

 


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <net/ethernet.h>
#include <net/if_arp.h>
#include <net/if.h>
#include <netinet/if_ether.h>
#include <netinet/ip_icmp.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netpacket/packet.h>
#include <arpa/inet.h>

#ifndef arp_hrd /*android not define struct ether_arp*/
struct ether_arp {
	struct	arphdr ea_hdr;		/* fixed-size header */
	u_int8_t arp_sha[ETH_ALEN];	/* sender hardware address */
	u_int8_t arp_spa[4];		/* sender protocol address */
	u_int8_t arp_tha[ETH_ALEN];	/* target hardware address */
	u_int8_t arp_tpa[4];		/* target protocol address */
};
#define	arp_hrd	ea_hdr.ar_hrd
#define	arp_pro	ea_hdr.ar_pro
#define	arp_hln	ea_hdr.ar_hln
#define	arp_pln	ea_hdr.ar_pln
#define	arp_op	ea_hdr.ar_op
#endif

#define xprint_log(fmt, ...) \
    printf("[%04d]%s() " fmt, __LINE__, __FUNCTION__, ####__VA_ARGS__)
#define xprint_err(fmt, ...) \
    printf("[%04d]%s() err: " fmt, __LINE__, __FUNCTION__, ####__VA_ARGS__)

#define xdebug 0
#define xunused __attribute__((unused))

#define HDR_LEN_ETH  sizeof(struct ether_header)
#define HDR_LEN_ARP  sizeof(struct ether_arp)
#define HDR_LEN_IP   sizeof(struct ip)
#define HDR_LEN_ICMP sizeof(struct icmp)


static unsigned char  s_frame_data[ETH_FRAME_LEN];
static unsigned int   s_frame_size = 0;
static int            s_interface_index = -1;
static unsigned char  s_interface_mac[ETH_ALEN];
static struct in_addr s_interface_ip; 
static unsigned char  s_src_mac[ETH_ALEN] = {0x00,0x11,0x22,0x33,0x44,0x55};


static int 
xsend_frame_ether(uint8_t *frame, int size, int ifindex, int skfd);
static int
xrecv_frame_ether(uint8_t *frame, int size, int ifindex, int skfd);

static int 
xsend_reply_arp(in_addr_t ipaddr, int skfd);
static int
xsend_reply_icmp(in_addr_t ipaddr, int skfd);

static uint16_t 
xutil_check_sum(uint16_t* data, int size);
static void
xutil_swap_int(uint32_t *a, uint32_t *b);

static int xunused
xdump_frame_byte(uint8_t *data, int size);
static int xunused
xdump_frame_ether(struct ether_header *eth);
static int xunused
xdump_frame_arp  (struct ether_arp *arp);
static int xunused
xdump_frame_ip   (struct ip *iph);
static int xunused
xdump_frame_icmp (struct icmp *icmph);


#define __DEFINITION__


static uint16_t 
xutil_check_sum(uint16_t* data, int size)
{
    unsigned int cksm = 0;
    
    while (size > 1) {
        cksm += *data++;
        size -= sizeof(uint16_t);
    }
    
    if (size) {
        cksm += *(uint8_t*)data;
    }
    
    cksm  = (cksm>>16) + (cksm&0xffff); 
    cksm += (cksm>>16); 
    
    return (uint16_t)(~cksm);
}

static void
xutil_swap_int(uint32_t *a, uint32_t *b)
{
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;
    return ;
}

static int
xdump_frame_byte(uint8_t *data, int size)
{
    int i;

    for(i=0; i<size; i++) {
        if((i%16) == 0) {
            printf( "[%02x] ", i/16 );
        }
        printf( "%02x ", data[i] );
        if(((i+1)%16) == 0) {
            printf( "\n" );
        }
    }

    printf( "\n" );
    return 0;
}

static int
xdump_frame_ether(struct ether_header *eth)
{
    if (NULL == eth) {
        return -1;
    }

    printf("========frame ether========\n");
    printf("type :0x%04x\n", htons(eth->ether_type));
    printf("d-mac:%02x-%02x-%02x-%02x-%02x-%02x\n",\
        eth->ether_dhost[0], eth->ether_dhost[1], eth->ether_dhost[2], \
        eth->ether_dhost[3], eth->ether_dhost[4], eth->ether_dhost[5]);

    printf("s-mac:%02x-%02x-%02x-%02x-%02x-%02x\n",\
        eth->ether_shost[0], eth->ether_shost[1], eth->ether_shost[2], \
        eth->ether_shost[3], eth->ether_shost[4], eth->ether_shost[5]);
    return 0;
}

static int
xdump_frame_arp  (struct ether_arp *arp)
{
    if (NULL == arp) {
        return -1;
    }

    printf("========frame arp  ========\n");
    printf("arp_hrd=%d    \n", htons(arp->arp_hrd));
    printf("arp_pro=0x%04x\n", htons(arp->arp_pro));
    printf("arp_op =%d    \n", htons(arp->arp_op));
    printf("arp_sdr=%02x-%02x-%02x-%02x-%02x-%02x %d.%d.%d.%d\n", \
        arp->arp_sha[0], arp->arp_sha[1], arp->arp_sha[2], \
        arp->arp_sha[3], arp->arp_sha[4], arp->arp_sha[5], \
        arp->arp_spa[0], arp->arp_spa[1], arp->arp_spa[2], \
        arp->arp_spa[3]);
    printf("arp_tgr=%02x-%02x-%02x-%02x-%02x-%02x %d.%d.%d.%d\n", \
        arp->arp_tha[0], arp->arp_tha[1], arp->arp_tha[2], \
        arp->arp_tha[3], arp->arp_tha[4], arp->arp_tha[5], \
        arp->arp_tpa[0], arp->arp_tpa[1], arp->arp_tpa[2], \
        arp->arp_tpa[3]);
    return 0;
}

static int
xdump_frame_ip(struct ip *iph)
{
    if (NULL == iph) {
        return -1;
    }
    
    printf("========frame ip   ========\n");
    printf("ip_v  =0x%x\n", iph->ip_v             ); /* 4位版本号           */
    printf("ip_hl =0x%x\n", iph->ip_hl            ); /* 4位IP头部长度 32bit */
    printf("ip_tos=0x%x\n", iph->ip_tos           ); /* 8位服务类型         */
    printf("ip_len=0x%x\n", htons(iph->ip_len)    ); /*16位数据包总长度     */
    printf("ip_id =0x%x\n", htons(iph->ip_id)     ); /*16位标志符           */
    printf("ip_off=0x%x\n", htons(iph->ip_off)    ); /* 3位标记+13位片偏移  */
    printf("ip_ttl=0x%x\n", iph->ip_ttl           ); /* 8位生存时间         */
    printf("ip_p  =0x%x\n", iph->ip_p             ); /* 8位协议号           */
    printf("ip_sum=0x%x\n", htons(iph->ip_sum)    ); /*16位首部校验和       */
    printf("ip_src=%s  \n", inet_ntoa(iph->ip_src)); /*32位源地址           */
    printf("ip_dst=%s  \n", inet_ntoa(iph->ip_dst)); /*32位目的地址         */
    return 0;
}

static int 
xdump_frame_icmp (struct icmp *icmph)
{
    if (NULL == icmph) {
        return -1;
    }
    
    printf("========frame icmp ========\n");
    printf("icmp_type =0x%x\n", icmph->icmp_type ); /*  8位类型          */
    printf("icmp_code =0x%x\n", icmph->icmp_code ); /*  8位代码          */
    printf("icmp_cksum=0x%x\n", icmph->icmp_cksum); /* 16位校验和        */
    printf("icmp_id   =0x%x\n", icmph->icmp_id   ); /* 16位识别号 进程id */
    printf("icmp_seq  =0x%x\n", icmph->icmp_seq  ); /* 16位序列号        */
    return 0;
}

static int 
xsend_frame_ether(uint8_t *frame, int size, int ifindex, int skfd)
{
    struct sockaddr_ll sll;
    socklen_t          sln = 0;
    
    struct sockaddr_ll *psll = NULL;

    if (-1 !=  ifindex) {
        bzero(&sll, sizeof(sll));
        sll.sll_ifindex  = ifindex;
        sll.sll_family   = PF_PACKET;
        sll.sll_protocol = htons(ETH_P_ALL);

        psll = &sll;
        sln  = sizeof(struct sockaddr_ll);
    }
    
    size = sendto(skfd, frame, size, 0, (struct sockaddr*)psll, sln);
    if (size < 0) {
        xprint_err("ioctl() SIOCGIFINDEX failed! errno=%d (%s)\n", \
            errno, strerror(errno));
    }
        
    return size;
}

static int
xrecv_frame_ether(uint8_t *frame, int size, int ifindex, int skfd)
{
    struct sockaddr_ll sll;
    socklen_t          sln = sizeof(struct sockaddr_ll);

    struct sockaddr_ll *psll = NULL;
    socklen_t          *psln = NULL;

    if (NULL==frame || size<=0) {
        xprint_err("param failed! frame=%p size=%d\n", frame, size);
        return -1;
    }

    if (-1 !=  ifindex) {
        bzero(&sll, sizeof(sll));
        sll.sll_ifindex  = ifindex;
        sll.sll_family   = PF_PACKET;
        sll.sll_protocol = htons(ETH_P_ALL);

        psll = &sll;
        psln = &sln;
    }

    memset(frame, 0, size*sizeof(uint8_t));
    size = recvfrom(skfd, frame, size, 0, (struct sockaddr*)psll, psln);

    if (size < 0) {
        xprint_err("recvfrom() failed! errno=%d (%s)\n", \
            errno, strerror(errno));
    }
    return size;
}

static int 
xsend_reply_arp(in_addr_t ipaddr, int skfd)
{
    struct ether_header *eth = NULL;
    struct ether_arp    *arp = NULL;
    
    eth = (struct ether_header*)s_frame_data;
    arp = (struct ether_arp*)(s_frame_data + HDR_LEN_ETH);

    if (*(unsigned int*)arp->arp_tpa != ipaddr) {
        return -1;
    }  
   
    /*ether*/
    memcpy(eth->ether_dhost, eth->ether_shost, ETH_ALEN);
    memcpy(eth->ether_shost, s_src_mac       , ETH_ALEN);
   
    /*arp*/
    arp->arp_op = htons(ARPOP_REPLY);
    memcpy(arp->arp_tha, arp->arp_sha, ETH_ALEN);
    memcpy(arp->arp_tpa, arp->arp_spa, 4);

    memcpy(arp->arp_sha, s_src_mac, ETH_ALEN);
    memcpy(arp->arp_spa, &ipaddr, 4);

#if xdebug
    printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("========frame size:%d\n", s_frame_size);
    xdump_frame_ether(eth);
    xdump_frame_arp  (arp);
    printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("\n");
#endif

    if (s_frame_size != xsend_frame_ether(\
        s_frame_data, s_frame_size, s_interface_index, skfd)) {
        return -1;
    }

    xprint_log("ok. size=%d\n", s_frame_size);
    return 0;
}

static int 
xsend_reply_icmp(in_addr_t ipaddr, int skfd)
{
    struct ip *iph           = NULL;
    struct ether_header *eth = NULL;
    struct icmp *icmph       = NULL;
    
    eth   = (struct ether_header*)s_frame_data;
    iph   = (struct ip*)(s_frame_data + HDR_LEN_ETH);
    icmph = (struct icmp*)(s_frame_data + HDR_LEN_ETH + HDR_LEN_IP);
    
    if ((iph->ip_p!=IPPROTO_ICMP) || iph->ip_dst.s_addr!=ipaddr) {
        return 1;
    }

    /*ether*/
    memcpy(eth->ether_dhost, eth->ether_shost, ETH_ALEN);
    memcpy(eth->ether_shost, s_src_mac, ETH_ALEN);
    
    /*ip*/
    xutil_swap_int(&(iph->ip_src.s_addr), &(iph->ip_dst.s_addr));
    iph->ip_off = 0;
    iph->ip_sum = 0;
    iph->ip_sum = xutil_check_sum((uint16_t*)iph, HDR_LEN_IP);

    /*icmp*/
    icmph->icmp_type  = ICMP_ECHOREPLY;
    icmph->icmp_cksum = 0;
    icmph->icmp_cksum = \
        xutil_check_sum((uint16_t*)icmph, s_frame_size-HDR_LEN_ETH-HDR_LEN_IP);

#if xdebug
    printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("========frame size:%d\n", s_frame_size);
    xdump_frame_ether(eth  );
    xdump_frame_ip   (iph  );
    xdump_frame_icmp (icmph);
    printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("\n");
#endif

    if (s_frame_size != xsend_frame_ether( \
        s_frame_data, s_frame_size, s_interface_index, skfd)) {
        return -1;
    }

    xprint_log("ok. size=%d\n", s_frame_size);
    return 0;
}

int main(int argc, char **argv)
{
    int       skfd       = -1;
    in_addr_t xping_addr = 0;
   
    if (argc <= 2) {
        printf("usage: %s interface ipaddr\n",argv[0]);
        printf("   ex: %s eth0 192.168.88.1\n", argv[0]);
        return -1;
    }

    skfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (skfd < 0) {
        xprint_err("socket() failed! errno=%d (%s)\n", errno, strerror(errno));
        return -1;
    } 

    struct ifreq ifr;
    bzero(&ifr,sizeof(ifr));
    strcpy(ifr.ifr_name, argv[1]);
    if (-1 == ioctl(skfd, SIOCGIFINDEX, &ifr)) {
        xprint_err("ioctl() SIOCGIFINDEX failed! errno=%d (%s)\n", \
            errno, strerror(errno));
        return -1;
    }
    s_interface_index = ifr.ifr_ifindex;
    
    if (-1 == ioctl(skfd, SIOCGIFHWADDR, &ifr)) {
        xprint_err("ioctl() SIOCGIFHWADDR failed! errno=%d (%s)\n", \
            errno, strerror(errno));
        return -1;
    }
    memcpy(s_interface_mac, ifr.ifr_hwaddr.sa_data, ETH_ALEN);

    if (-1 == ioctl(skfd, SIOCGIFADDR, &ifr)) {
        xprint_err("ioctl() SIOCGIFADDR failed! errno=%d (%s)\n", \
            errno, strerror(errno));
        return -1;
    }
    s_interface_ip.s_addr = \
        ((struct sockaddr_in*)&(ifr.ifr_addr))->sin_addr.s_addr;
        
    if (-1 == ioctl(skfd, SIOCGIFFLAGS, &ifr)) {
        xprint_err("ioctl() IFF_PROMISC failed! errno=%d (%s)\n", \
            errno, strerror(errno));
        return -1;
    }

    if ((ifr.ifr_flags&IFF_PROMISC) != IFF_PROMISC) {
        ifr.ifr_flags |= IFF_PROMISC;
        if(-1 == ioctl(skfd, SIOCSIFFLAGS, &ifr)) {
            xprint_err("ioctl() IFF_PROMISC failed! errno=%d (%s)\n", \
                errno, strerror(errno));
            return -1;
        }
    }

    printf("========host info  ========\n");
    printf("ifr_ifindex=%d %s\n", s_interface_index, argv[1]);
    printf("ifr_hwaddr =%02x-%02x-%02x-%02x-%02x-%02x\n", \
        s_interface_mac[0], s_interface_mac[1], s_interface_mac[2], 
        s_interface_mac[3], s_interface_mac[4], s_interface_mac[5]);
    printf("ifr_addr   =%s\n", inet_ntoa(s_interface_ip));
    printf("ifr_flags  =IFF_PROMISC\n");
    printf("pid        =0x%x\n", getpid());
    printf("header_eth =%d\n", HDR_LEN_ETH);
    printf("header_arp =%d\n", HDR_LEN_ARP);
    printf("header_ip  =%d\n", HDR_LEN_IP);
    printf("header_icmp=%d\n", HDR_LEN_ICMP);
    printf("\n");

    printf("press any key continue!\n");
    getchar();
    printf("waiting for someone ping %s ...\n", argv[2]);
    
#if 0
    int on = 1;
    if (0 != setsockopt(skfd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on))) {
        xprint_err("setsockopt() IP_HDRINCL failed! errno=%d (%s)\n", \
            errno, strerror(errno));
        return -1;
    }
#endif    
    
    xping_addr = inet_addr(argv[2]);
    
    while(1) {
        uint16_t ether_type = 0;
        struct ether_header* eth = NULL;
        
        memset(s_frame_data, 0x00, sizeof(unsigned char)*ETH_FRAME_LEN);
        s_frame_size = xrecv_frame_ether(s_frame_data, ETH_FRAME_LEN, \
            s_interface_index, skfd);
            
        eth = (struct ether_header*)s_frame_data;
        ether_type = htons(eth->ether_type);

        switch(ether_type) {
            case ETHERTYPE_ARP: {
                xsend_reply_arp(xping_addr, skfd);
                break;
            }
            case ETHERTYPE_IP: {     
                xsend_reply_icmp(xping_addr, skfd);
                break;
            }
            default: {
                break;
            }
        }
    }
    
    close(skfd);
    return 0;
}

 

 

 

 

 

Linux C 实现最简单的ICMP_ECHO请求报文发送 弄了两天,终于搞定了!把最简单的icmp报文发送实现了。本 阅读详情

相关推荐

linux内核协议栈 icmp 协议概述与数据结构

1 ICMP协议概述 ICMP协议是网络层中一个非常重要的协议,其全称为InternetControlMessageProtocol(因特网控制报文协议),ICMP协议弥补了IP的缺限,它使用IP协议进行信息传递,向数据包中的源端节点提供发生在网络层的错误信息反馈。 在实现中,路由器会使用该协议来报告问题,而主机则会使用该机制来测试目的站是否可达。该报文的最终目的地不是一个应用程序或者目的设备上的用户,而是目的设备上的网际协议软件,一般icmp报文的接收是linux内核里的icmp接收模块来...

3540

linux网卡抓包命令,基于Linux Socket实现的网卡抓包程序

【前言】通过对数据包的分析,我们可以判断通信双方的操作系统、网络信息流量、经过的路由、数据包的大小,以及数据包的内容等等。尤其对于喜欢网络安全的人来说,掌握这方面的知识是相当重要的。本文介绍一个基于Linux平台实现的网络抓包工具。0.基础知识在Linux环境下,可以使用rawsocket,即原始套接字,接收本机网卡上的数据帧或者数据包,实现对与监听网络的流量和分析是很有作用的。一共可以有3种方式...

weixin_29582621的博客 1229

从0到1:.NET 9 OpenAPI全攻略!Swagger vs Scalar UI谁更强?

OpenAPI:.NET 9的智能文档革命 本文深入解析.NET 9的OpenAPI支持,对比Swagger UI与Scalar UI的优劣,提供实战代码示例: 一键生成:AddOpenApi()+MapOpenApi()快速生成标准文档 UI工具对决: Swagger UI功能全面但复杂 Scalar UI简约现代,原生支持cURL/HTTPie 进阶技巧: XML注释增强文档可读性 自定义Transformer实现文档动态修改 🔥核心价值:.NET 9的OpenAPI方案显著降低API文档维护成本,开

java专栏 1429

PF_PACKET

PF_PACKET 瞅代码的时候,看到一个很奇特的socket,sock=socket(PF_PACKET, SOCK_RAW, htons(0x8888)) 那什么是PF_PACKET?我在网上翻了一下,找到了一片不错的文章,详细 sock_raw(注意一定要在root下使用)原始套接字编程可以接收到本机网卡上的数据帧或者数据包,对于监听网络的流量和分析是很有作用的.一共可以有3种方式创...

as3522的博客 9467

【架构师面试-缓存与搜索-1】-缓存与缓存置换策略源码实现

1:什么是缓存 缓存:加速数据访问的存储,降低延迟(latency),提升吞吐量(Throughput)的利器。 1:缓存演进历史 1. 查库 2. ConcurrentHashMap 3. LRU 4. Guava Cache 5. 分布式缓存(redis,MemCache) 6. 多级缓存 2:在什么地方加缓存 缓存对于每个开发者来说是相当熟悉了,为了提高程序的性能我们会去加缓存,但是在什么地方加缓存,如何加缓存呢? 举个栗子:假设一个网站,需要提高性能,缓存可以放在浏览器,可以放

chongfa2008的博客 6441

第二章-Ethernet/IP基本概念

在I/O连接中,一旦连接建立,就不会有请求-响应数据,只会按照连接建立时指定的生产触发器所确定的时间间隔生产和消耗带有ConnectionID的数据。连接是通过连接管理器对象的Forward请求服务建立的,ForwardOpen请求包含所有连接参数,包括传输类、生产触发器、定时信息、电子密钥和连接ID。I/O适配器:I/O适配器从I/O扫描器接收隐式通信连接请求,然后以请求的速率生成I/O数据。I/O扫描器:启动与I/O适配器的隐式通信,需要处理连接的配置以及如何配置适配器。扫描器还支持启动显式报文。

_Nooice的博客 1234

头歌实现 ICMP 协议的 PING 程序

coding: utf-8 import socket import struct import time ICMP_ECHO_REQUEST = 8 # 设定Ping类型为8 def checksum(data): n = len(data) m = n % 2 sum = 0 for i in range(0, n - m, 2): sum += ord(chr(data[i])) + (ord(chr(data[i + 1])) << 8) if m: sum += ord(data[-

m0_51583852的博客 3350

手把手教你用STM32F303和LAN9252搭建EtherCAT从站(附IO/AD/DA完整代码)

本文详细介绍了如何使用STM32F303和LAN9252搭建EtherCAT从站,涵盖硬件选型、开发环境配置、协议栈移植及IO/AD/DA功能实现。通过实战指南和完整代码,帮助开发者快速掌握工业自动化中的实时通信技术,提升系统性能与可靠性。

weixin_26802933的博客 235

linux 协议栈之socket,Linux TCP/IP 协议栈之 Socket 的实现分析(一)

内核版本:2.6.37参考[作者:kendo的文章(基于内涵版本2.6.12)]第一部份 Socket套接字的创建socket 并不是 TCP/IP协议的一部份。从广义上来讲,socket 是Unix/Linux 抽像的进程间通讯的一种方法。网络 socket 通讯仅仅是其若干协议中的一类。而tcp/ip 又是网络这类中的一种。从tcp/ip 的解度看 socket ,它更多地体现了用户 API ...

weixin_39688856的博客 459

工业视觉检测实战指南:从硬件配置到AI算法部署

本文提供了一套完整的工业视觉检测系统搭建实战指南。从硬件选型(相机、光源、镜头、工控机)到AI算法(深度学习模型)部署,详细解析了如何为生产线配置一双“会思考的眼睛”。重点探讨了深度学习算法在复杂缺陷识别中的应用,并分享了模型训练、优化及云边协同部署的实战心得,旨在帮助工程师实现从实验室Demo到7x24小时稳定运行的工业落地。

weixin_29051193的博客 462

DataGridView添加新行时在单元格绑定下拉列表DataGridViewComboBoxCell

效果图如下 先在界面上添加DataGridView,添加字段no、type、param 在lord事件中新建一行 dataGridView1.Rows.Add(); 在RowsAdded事件中操作新建的行 private void dataGridView1_RowsAdded_1(object sender, DataGridViewRowsAddedEventArgs...

wuqinglaohao的博客 1986

linux看请求报文发送的ip,Linux C 实现最简单的ICMP_ECHO请求报文发送

弄了两天,终于搞定了!把最简单的icmp报文发送实现了。本程序在linux环境编写,使用原始套接字。实现步骤:1、得到protocol实体(protoent,声明于);2、初始化地址结构(sockaddr_in,声明于);3、创建套接字(socket(),声明于,参数声明于);4、更改socket选项,更改发送缓冲区大小(setsockopt(),声明于);5、发送报文(sendto(),声明于)...

weixin_39877898的博客 600

别再为CAD和GIS数据对不上而头疼了!一份完整的ArcGIS for AutoCAD坐标系定义与数据套合指南

本文详细介绍了如何通过ArcGIS for AutoCAD插件解决CAD与GIS数据坐标系不匹配的问题,实现数据的精准套合。文章从坐标系冲突分析、插件核心功能解析到五步标准化工作流,提供了完整的解决方案,帮助工程师和设计师提升跨平台协作效率。

weixin_42531886的博客 217

linux c icmp协议 判断主机存活

详细参考 《linux c ping 分析实现》 https://blog.youkuaiyun.com/whatday/article/details/104192608  ICMP(Internet Control Message,网际控制报文协议)是为网关和目标主机而提供的一种差错控制机制,使它们在遇到差错时能把错误报告给报文源发方。   ICMP协议是IP层的一个协议,但是由于差错报告在发送...

whatday的专栏 752

Flutter应用安卓逆向之hook分析研究---附dart版本对照表(必看篇)

搜索md5、rsa、aes等关键字分析要破解的加密算法,使用frida进行hook可疑函数的偏移地址。,双击进去找到ssl_crypto_x509_session_verify_cert_chain函数的偏移地址进行hook掉;Flutter应用是内置进行ssl证书校验的,无法通过常规方法抓到包,需要通过frida把它内置的ssl校验hook掉。重构完成后会生成新的apk,把它安装到模拟器或者真机中并打开运行,此时系统会在。关键字的函数进行hook(因为其返回的是字符串类型)中,拖进ide搜索字符串。

云霄IT的博客 8445

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Linux网络编程:原始套接字编程及实例分析

Linux网络编程:原始套接字编程及实例分析 一、原始套接字能干什么? 通常情况下程序员接所接触到的套接字(Socket)为两类: 流式套接字(SOCK_STREAM):一种面向连接的Socket,针对于面向连接的TCP 服务应用; 数据报式套接字(SOCK_DGRAM):一种无连接的Socket,对应于无连接的UDP 服务应用。 从用户的角度来看,SOCK_STREAM、SOCK_DGRAM 这两类套接字似乎的确涵盖了TCP/IP 应用的全部,因为基于TCP/IP 的应用,从协议栈的层次上讲,在传输

m0_52789121的博客 446

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Linux 原始套接字--myping的实现

原文地址:Linux 原始套接字--myping的实现 作者:草根老师 一、套接字的类型 A.流套接字(SOCK_STREAM)  用于提供面向连接、可靠的数据传输服务,其使用传输层的TCP协议 B.数据报套接字(SOCK_DGRAM) 用于提供一个无连接、不可靠的服务,其使用传输层上的UDP协议

vvvbird的专栏 746

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

linux通过原始套接字直接发送arp请求报文,linux并不能学习到arp表项

而是通过代码直接发送icmp报文,发送icmp报文如果发现没有arp信息的时候系统会自己发送arp请求,通过这样的方式linux系统才能学到arp表项也就是arp -a才有ping的表项;问题:由于我这边需要让linux系统学习到arp表项,所以想着通过代码直接发送arp请求(利用原始套接字),其他设备回复arp报文之后,我以为linux就会记录到arp表项,现象是arp表项并没有;

cao849861802的博客 752

LinuxC网络编程笔记(三)

原始套接字编程 原始套接字使一种非面向连接的,c/s传输方式的网络编程。使用原始套接字编程进行服务器端与客户端的通信前,都要创建各自的套接字,然后对应的套接字进行数据传输。在数据传输过程中,需要使用sendto()函数和recvfrom()函数进行发送与接收,再发送与接收函数中设置相应的IP地址。 原始套接字往往应用于高级网络编程,例如网络嗅探器sniffer、拒绝服务攻击DoS、IP欺骗等。并且还可以通过原始套接字来模拟IP的一些实用工具,例如PING命令。 创建函数 原始套接字编程是SOCK_R

这只猴子没有名字的博客 355

【Linux】高级网络编程之原始套接字

MAC、IP、TCP、UDP、ICMP 网络协议还分不清楚?这一篇宝藏文章,图文详解网络协议,赶紧偷偷收藏哟

道法自然 454

《Linux C/C++服务器开发实践》之第6章 原始套接字编程

发送自定义的IP报文、UDP报文、TCP报文、ICMP报文、捕获所有经过本机网卡的数据报、伪装本机IP地址、操作IP首部或传输层协议首部等。(1)收发ICMPv4、ICMPv6和IGMP数据报,只需IP头部预定义好网络层上的协议号。(4)让网卡处于混杂模式,从而能捕获流经网卡的所有数据报。发送接收IP数据报,从而分析TCP、UDP和ICMP。(3)设置对端IP地址,不涉及端口号(传输层才有)。(4)组织IP数据报,即填充首部和数据部分。(5)过滤数据报,即判断是否是需要的数据报。(2)创建原始套接字。

yxqq378287007的博客 1378

linux C++ 实现ping类

//头文件 /* * File: CPing.h * Author: jaylong35 * * Created on 2011年1月26日, 下午3:12 */ #ifndef CPING_H #define CPING_H #include #include #include #include #include #include #include #includ

jaylong35的专栏 6574

linux 操作系统ping,linux中ping命令用法与实现原理linux操作系统 -电脑资料

linux下的ping命令用于查看网络上的主机是否在工作,ping命令的一般格式为:ping [-dfnqrRv][-c 发送次数][-i 间隔秒数][-I 网络界面][-l 前置载入][-p 范本样式][-s 数据包大小][-t 存活数值][主机名或IP地址]参数说明:-d 使用Socket的SO_DEBUG功能。-f 极限检测。大量且快速地送网络封包给一台机器,看它的回应。-n 只输出数值。-...

weixin_33278819的博客 957
上一篇: linux原始套接字-发送ARP报文
下一篇: makefile 自动生成头文件依赖关系
maxzero
博客等级 码龄20年 57粉丝 24原创
评论 4
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值