std.net.arp

ARP-Client nach RFC 826 — Address Resolution Protocol für IPv4 über Ethernet. Baut ARP-Request- und Reply-Frames, parst empfangene Frames und löst IP-Adressen ohne Raw-Socket über den Kernel-ARP-Cache auf.

import std.net.arp;
import std.alloc;

// MAC-Adresse für 192.168.1.1 aus Kernel-Cache auflesen
var result: int64 := alloc(ARP_RESULT_SIZE);
if (ArpResolve(IPPack(192, 168, 1, 1), result) == 0) {
    var macPtr: int64 := result + ARP_RESULT_SENDER_MAC;
    // macPtr[0..5] = aufgelöste MAC-Adresse
}
free(result, ARP_RESULT_SIZE);

Berechtigung: ArpResolve benötigt keinen Raw-Socket und kein root — nur ein UDP-Socket für den SIOCGARP-ioctl. ArpBuildRequest/Reply erzeugen nur den Frame-Puffer; das Senden über einen Raw-Socket erfordert CAP_NET_RAW.

• std.net.socket
• std.alloc

Ein ARP-Frame besteht aus einem 14-Byte-Ethernet-Header und einem 28-Byte-ARP-Payload. Alle Mehrbytefelder sind Big-Endian (Network Byte Order).

Ethernet-Header (Bytes 0–13):

ARP-Payload (Bytes 14–41):

Wird vom Caller alloziert. MAC-Adressen werden als 6 aufeinander folgende Bytes ab dem angegebenen Offset gespeichert (mit peek8 byteweise lesen).

Byte:  0    6    12   14   16 18 19 20   22   28   32   38
       ┌────┬────┬──┬──┬──┬─┬─┬──┬────┬────┬────┬────┐
ETH:   │dst │src │08│06│  │  │  │  │    │    │    │    │
ARP:              │HRD│PRO│HL│PL│OP│SHA │SIP │THA │TIP │
       └────┴────┴──┴──┴──┴─┴─┴──┴────┴────┴────┴────┘
       |←── 14B Ethernet ──→|←──────── 28B ARP ───────→|
                                                        42

import std.net.arp;
import std.net.socket;
import std.net.types;
import std.alloc;

fn resolveViaRaw(srcMac: int64, srcIP: int64, targetIP: int64): int64 {
    // Raw-Socket für Ethernet-Layer (erfordert CAP_NET_RAW)
    var rawSock: int64 := sys_socket(AF_PACKET, SOCK_RAW, 0x0806);
    if (rawSock < 0) { return 0 - 1; }

    // ARP-Request bauen und senden
    var frame: int64 := alloc(ARP_FRAME_SIZE);
    ArpBuildRequest(frame, srcMac, srcIP, targetIP);
    // ... frame über rawSock senden ...

    // Antwort empfangen und parsen
    var reply:  int64 := alloc(ARP_FRAME_SIZE);
    var result: int64 := alloc(ARP_RESULT_SIZE);
    // ... reply über rawSock empfangen ...
    ArpParse(reply, ARP_FRAME_SIZE, result);

    if (peek64(result + ARP_RESULT_OK) == 1) {
        var mac: int64 := result + ARP_RESULT_SENDER_MAC;
        // mac[0..5] = aufgelöste MAC
    }

    free(result, ARP_RESULT_SIZE);
    free(reply,  ARP_FRAME_SIZE);
    free(frame,  ARP_FRAME_SIZE);
    return 0;
}

fn resolveViaCache(ip: int64) {
    // Einfacher Weg: Kernel-Cache abfragen (kein root nötig)
    var result: int64 := alloc(ARP_RESULT_SIZE);
    if (ArpResolve(ip, result) == 0) {
        var base: int64 := result + ARP_RESULT_SENDER_MAC;
        Print(peek8(base));     Print(":");
        Print(peek8(base + 1)); Print(":");
        Print(peek8(base + 2)); Print(":");
        Print(peek8(base + 3)); Print(":");
        Print(peek8(base + 4)); Print(":");
        PrintLn(peek8(base + 5));
    }
    free(result, ARP_RESULT_SIZE);
}

• ArpResolve ohne root: Nutzt SIOCGARP (ioctl 0x8954) über einen normalen UDP-Socket. Erzeugt keinen Netzwerkverkehr — liest nur den bestehenden Kernel-Cache. Die IP muss vorher durch Ping, connect() oder ähnliches in den Cache gebracht worden sein.
• Raw-Socket für Request: ArpBuildRequest und ArpBuildReply bauen nur den Puffer. Zum tatsächlichen Senden auf Layer 2 wird ein AF_PACKET-Raw-Socket benötigt (CAP_NET_RAW oder root).
• IP-Format: Alle IP-Felder verwenden das IPPack-Format aus std.net.types — Big-Endian uint32 in int64.
• MAC-Zugriff: MACs im Result-Struct werden mit peek8 byteweise gelesen (6 Bytes ab dem jeweiligen Offset-Konstante).
• ArpResolve result: Setzt SENDER_MAC und TARGET_MAC auf dieselbe aufgelöste MAC; TARGET_IP wird auf die angefragte IP gesetzt, SENDER_IP bleibt 0.
• RARP: ARP_OP_RREQUEST/RREPLY sind als Konstanten definiert (3/4); ArpBuildRequest/Reply unterstützen sie nicht direkt — den OP-Code nach dem Build-Call manuell per arpWrite16BE (intern) oder poke8 setzen.

Letzte Aktualisierung: 2026-06-17