Linux Network Programming: Data Link Layer and ARP Protocol

1. Related to MAC Frame (Simple Simulation to Build MAC Frame)

1. Ethernet Header Structure Definition (C Language)

2. 

#include <stdio.h>
#include <stdint.h>

// Ethernet header structure
typedef struct {
    uint8_t destination_mac[6];  // Destination MAC address, 6 bytes
    uint8_t source_mac[6];    // Source MAC address, 6 bytes
    uint16_t ether_type;      // Ethernet type, e.g., 0x0800 indicates IP protocol
} EthernetHeader;

1. Build a Simple MAC Frame Data (Fill Example Data)

#include <string.h>

// Fill MAC frame data
void build_mac_frame(EthernetHeader *eth_header) {
    // Simple example MAC address filling (should be obtained from network interface in actual applications)
    uint8_t dest_mac[6] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
    uint8_t src_mac[6] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};

    memcpy(eth_header->destination_mac, dest_mac, 6);
    memcpy(eth_header->source_mac, src_mac, 6);
    eth_header->ether_type = 0x0800;
}

2. Related to ARP Protocol (Simple ARP Request Sending Example, C Language)

1. ARP Header Structure Definition

// ARP header structure
typedef struct {
    uint16_t hardware_type;   // Hardware type, e.g., 1 for Ethernet
    uint16_t protocol_type;   // Protocol type, e.g., 0x0800 for IP
    uint8_t hardware_size;     // Hardware address length, 6 bytes for Ethernet MAC address
    uint8_t protocol_size;     // Protocol address length, 4 bytes for IPv4
    uint16_t opcode;          // ARP opcode, 1 for request, 2 for reply
    uint8_t sender_mac[6];    // Sender MAC address
    uint8_t sender_ip[4];     // Sender IP address
    uint8_t target_mac[6];    // Target MAC address (usually all 0 in requests)
    uint8_t target_ip[4];     // Target IP address
} ARPPacket;

1. Send ARP Request (Simplified Example, More Error Handling Needed in Actual Use)

#include <sys/socket.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <arpa/inet.h>

// Function to send ARP request
void send_arp_request(int sockfd, const char *iface, const char *sender_ip_str, const char *target_ip_str) {
    struct sockaddr_ll sa;
    ARPPacket arp_packet;
    // Initialize ARP packet content (some detailed settings omitted here)
    arp_packet.hardware_type = htons(1);
    arp_packet.protocol_type = htons(0x0800);
    arp_packet.hardware_size = 6;
    arp_packet.protocol_size = 4;
    arp_packet.opcode = htons(1);

    // Get local MAC address (simplified, should be obtained from interface)
    uint8_t local_mac[6] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
    memcpy(arp_packet.sender_mac, local_mac, 6);
    inet_pton(AF_INET, sender_ip_str, arp_packet.sender_ip);
    memset(arp_packet.target_mac, 0, 6);
    inet_pton(AF_INET, target_ip_str, arp_packet.target_ip);

    // Create socket
    sockfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ARP));
    if (sockfd < 0) {
        perror("socket");
        return;
    }

    // Set socket address structure
    memset(&sa, 0, sizeof(sa));
    sa.sll_family = AF_PACKET;
    sa.sll_protocol = htons(ETH_P_ARP);
    sa.sll_ifindex = if_nametoindex(iface);

    // Send ARP request packet
    sendto(sockfd, &arp_packet, sizeof(arp_packet), 0, (struct sockaddr *)&sa, sizeof(sa));
    close(sockfd);
}

These codes are just simple examples; in actual network programming applications, more error handling, network interface operations, and adherence to relevant protocol specifications and security requirements are needed.