raw socket

╰半夏微凉° 2022-08-27 07:57 137阅读 0赞

**ipv4:**  
1.创建收发二层报文的raw socket:  
socket(PF\_PACKET, SOCK\_RAW, 0); 或者  
socket(PF\_PACKET, SOCK\_RAW, htons(ETH\_P\_ALL));  
  
2.创建收发三层（IP层）报文的raw socket:  
socket (PF\_INET, SOCK\_RAW, IPPROTO\_RAW);  
setsockopt(sock, IPPROTO\_IP, IP\_HDRINCL, &on, sizeof(on));  设置了这个opt，则自己填写IP header；否则没有设置  
这个opt，kernel会自动填写IP header，只需要从IP的报文payload开始填写。  
  
  
**ipv6:**  
现有的raw socket是基于ipv4的，若改成ipv6，需要修改socket。  
1.创建收发二层报文的raw socket:  
socket(PF\_PACKET, SOCK\_PACKET, htons(ETH\_P\_ALL));  
  
2.创建收发三层报文的raw socket：  
尝试了很久，没有成功过。其实如果只是想指定源IP地址和目的IP地址，可以直接bind一下指定源IP，就可以达到目的。  
  
  
注意：  
Ipv6的raw socket和Ipv4区别还是蛮大的。  
1.ipv6没有类似ipv4的IP\_HDRINCL的option，从三层ip头开始编写报文选项。  
2.sendto的第五个参数不一样，不能用sockaddr\_in6结构，要用sockaddr\_pkt，或是sockaddr\_ll结构，否则sendto函数会报错invalid parameter。  
  
  
  
**编写raw socket的几个关键数据结构：**  
1. 以太网头：struct ethhdr  
2. ip头： struct ip6\_hdr 或 struct ip

3. udp头：struct udphdr

static void AppendIpv6Header(U8 *packet, DhcpMessageIpv6T *msg)
    {
        struct ip6_hdr *ip6hdr = DML_CAST_PTR(struct ip6_hdr *, packet);
    
        /* Parameter checks */
        DML_ASSERTR(packet != NULL);
        DML_ASSERTR(msg != NULL);
    
        /* Fill in the IPv6 header. */
        ip6hdr->ip6_flow = htonl ((6 << 28) | (0 << 20) | 0);    // IPv6 version (4 bits), Traffic class (8 bits), Flow label (20 bits)
        ip6hdr->ip6_plen = htons(UDPHDR_LEN + msg->len);
        ip6hdr->ip6_nxt = IPPROTO_UDP;
        ip6hdr->ip6_hops = MAXTTL;
        memcpy(ip6hdr->ip6_src.s6_addr, msg->srcIp6, sizeof(msg->srcIp6));
        memcpy(ip6hdr->ip6_dst.s6_addr, msg->dstIp6, sizeof(msg->dstIp6));
    }
    
    static void AppendUdpHeader(U8 *packet, DhcpMessageIpv6T *msg)
    {
        struct udphdr *udphdr = DML_CAST_PTR(struct udphdr *, packet);
        U32 udpLength = 0;
    
        /* Parameter checks */
        DML_ASSERTR(packet != NULL);
        DML_ASSERTR(msg != NULL);
    
        /* Calculate the UDP datagram length */
        udpLength = UDPHDR_LEN + msg->len;
    
        /* Fill in the UDP header. */
        udphdr->dest   = htons(msg->dstPort);
        udphdr->source = htons(msg->srcPort);
        udphdr->len    = htons(udpLength);
        udphdr->check  = 0;
    }
    
    static DmlErrorT OpenSendL2SocketIpv6(DhcpCRawSocketIpv6T *dhcpSock)
    {
        S32 sock;
        U32 on = 1;
        
        /* Parameter checks */
        DML_ASSERTRC(dhcpSock  != NULL, DML_PARAM);
        DML_ASSERTRC(dhcpSock->sendL2Sock == INVALID_SOCKET, DML_ERROR);
    
        /*
         * Create a socket for sending/receiving broadcast DHCP messages 
         */
        sock = socket (PF_INET6, SOCK_RAW, htons(ETH_P_ALL));
        if (sock < 0)
        {
            DML_LOG(DML_EVT_COMP_DHCP_CLIENT, DML_LOG_LVL_CRIT, "Could not create RAW Socket, errno=%s", strerror(errno));
            return DML_ERROR;
        }
    
        /* Enable sending broadcast frames on this socket. */
        if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST,  &on, sizeof(on)) < 0) 
        {
            DML_LOG(DML_EVT_COMP_DHCP_CLIENT, DML_LOG_LVL_CRIT, "Could set BROADCAST option on socket, errno=%s", strerror(errno));
            close(sock);
            return DML_ERROR;
        }
    
        dhcpSock->sendL2Sock = sock;
        DML_LOG(DML_EVT_COMP_DHCP_CLIENT, DML_LOG_LVL_TRACE,"Open DHCP send socket - %d\n", sock);
    
        return DML_OK;
    }
    
    DmlErrorT DhcpCRawSockSendL2Ipv6(DhcpCRawSocketIpv6T *dhcpSock, DhcpMessageIpv6T *msg)
    {
        S32 rc;
        U8 datagram[DHCP_MAX_MSG_SIZE];
        U8 *datagramPtr = datagram;
        U8 *udpPtr = NULL;
        U32 datagramLen = 0;
        struct ethhdr *eth = NULL;
        struct sockaddr_pkt sockAddr;
    
        /* Parameter checks */
        DML_ASSERTRC(dhcpSock  != NULL, DML_PARAM);
        DML_ASSERTRC(msg       != NULL, DML_PARAM);
    
        /* Fill in the Ethernet header. */
        eth = DML_CAST_PTR(struct ethhdr *, datagramPtr);
        memcpy(eth->h_dest, msg->dstMac, sizeof(eth->h_dest));
        memcpy(eth->h_source, msg->srcMac, sizeof(eth->h_source));
        eth->h_proto = htons(ETH_P_IPV6);
        datagramPtr += ETHHDR_LEN;
        datagramLen += ETHHDR_LEN;
    
        /* Fill in the IP header. */
        AppendIpv6Header(datagramPtr, msg);
        datagramPtr += IPV6HDR_LEN;
        datagramLen += IPV6HDR_LEN;
    
        /* Fill in the UDP header. 
         *
         * Note, save a pointer to the UDP header because the checksum
         * will have to be computed over the entire frame after the data
         * is copied in. */
        udpPtr = datagramPtr;
        AppendUdpHeader(datagramPtr, msg);
        datagramPtr += UDPHDR_LEN;
        datagramLen += UDPHDR_LEN;
    
        /* Check if there is enough room to copy the DHCP message into the
         * datagram buffer. */
        if ((sizeof(datagram) - datagramLen) <= msg->len)
        {
            DML_LOG(DML_EVT_COMP_DHCP_CLIENT, DML_LOG_LVL_ERR, 
                    "Datagram buffer size %u too small for DHCP message length %u", sizeof(datagram), msg->len);
            return DML_ERROR;
        }
    
        /* Copy in the DHCP message into the datagram buffer */
        memcpy(datagramPtr, &msg->pkt, msg->len);
        datagramPtr += msg->len;
        datagramLen += msg->len;
    
        /* Update the UDP checksum */
        UpdateUdpChecksumIpv6(udpPtr, msg);
    
        /* Set up a socket address */
        memset (&sockAddr, 0, sizeof sockAddr);
        sockAddr.spkt_family = AF_PACKET;
        strncpy ((char *)sockAddr.spkt_device, dhcpSock->name, sizeof sockAddr.spkt_device);
        sockAddr.spkt_protocol = htons(ETH_P_IPV6);
        DML_LOG(DML_EVT_COMP_DHCP_CLIENT, DML_LOG_LVL_TRACE,"send to broadcast socket %d to %s\n",
                dhcpSock->bcastSock, dhcpSock->name);
        /* Send the raw IP packet */
        rc = sendto(dhcpSock->bcastSock, datagram, datagramLen, 0, (struct sockaddr *)&sockAddr, sizeof(sockAddr));
        if (rc != (S32)(datagramLen))
        {
            DML_LOG(DML_EVT_COMP_DHCP_CLIENT, DML_LOG_LVL_ERR, "sendto() failed: %s\n", strerror(errno));
            return DML_ERROR;
        }
    
        return DML_OK;  
    }