A Go-based acoustic communication system

func CreateUDPPacket(srcIP, dstIP net.IP, srcPort, dstPort uint16, payload []byte) ([]byte, error) {
    // 1. Create IPv4 layer
    ipLayer := &layers.IPv4{
        Version:  4,
        TTL:      64,
        SrcIP:    srcIP,
        DstIP:    dstIP,
        Protocol: layers.IPProtocolUDP,
    }
    
    // 2. Create UDP layer
    udpLayer := &layers.UDP{
        SrcPort: layers.UDPPort(srcPort),
        DstPort: layers.UDPPort(dstPort),
    }
    
    // 3. Set network layer for checksum calculation
    udpLayer.SetNetworkLayerForChecksum(ipLayer)
    
    // 4. Serialize layers: [IP][UDP][Payload]
    gopacket.SerializeLayers(buffer, opts, ipLayer, udpLayer, gopacket.Payload(payload))
}

func (ds *DNSServer) CreateDNSQuery(domain string) ([]byte, uint16, error) {
    // Assign unique query ID
    queryID := ds.queryID
    ds.queryID++
    
    // Build DNS query packet
    dns := &layers.DNS{
        ID:     queryID,
        QR:     false,              // 0 = query
        OpCode: layers.DNSOpCodeQuery,
        RD:     true,               // Recursion desired
        Questions: []layers.DNSQuestion,
    }
    
    // Serialize DNS packet
    return buffer.Bytes(), queryID, nil
}

func (ds *DNSServer) HandleDNSResponse(payload []byte) {
    // 1. Parse DNS response
    ip, queryID, err := ds.ParseDNSResponse(payload)
    
    // 2. Find matching pending query
    ds.mu.Lock()
    if ch, ok := ds.pendingQuery[queryID]; ok {
        ch <- ip  // Send resolved IP to waiting goroutine
    }
    ds.mu.Unlock()
}

func (ds *DNSServer) WaitForResponse(queryID uint16) (net.IP, error) {
    ch := make(chan net.IP, 1)
    ds.pendingQuery[queryID] = ch
    
    // Wait for response with timeout
    select {
    case ip := <-ch:
        return ip, nil
    case <-time.After(5 * time.Second):
        return nil, fmt.Errorf("DNS timeout")
    }
}

// 1. Node 1 creates DNS query
dnsPayload, queryID := dnsServer.CreateDNSQuery("www.example.com")

// 2. Wrap in UDP packet
udpPacket := CreateUDPPacket(node1IP, node2IP, 55123, 53, dnsPayload)

// 3. Send through acoustic link to Node 2
node.QueueIPFrame(node2IP, udpPacket)

// 4. Node 2 receives and forwards to internet DNS (1.1.1.1:53)
router.ForwardToInternet(udpPacket)

// 5. Wait for response
ip := dnsServer.WaitForResponse(queryID)

// 6. Use resolved IP for subsequent operations
fmt.Printf("Resolved: %s -> %s\n", domain, ip)

type TCPClient struct {
    SrcIP, DstIP     net.IP
    SrcPort, DstPort layers.TCPPort
    SeqNum, AckNum   uint32
    State            string  // "CLOSED", "SYN_SENT", "ESTABLISHED", "FIN_WAIT"
    DataBuffer       bytes.Buffer
    SendIPPacket     func(destIP net.IP, payload []byte)
}

// 3-Way Handshake
func (c *TCPClient) Connect() error {
    // 1. Send SYN
    c.State = "SYN_SENT"
    c.sendSegment(true, false, false, nil)  // SYN=true, ACK=false, FIN=false
    
    // 2. Wait for SYN-ACK (handled in HandlePacket)
    // 3. Send ACK (handled in HandlePacket when SYN-ACK received)
    
    // Block until ESTABLISHED
    for c.State != "ESTABLISHED" {
        c.cond.Wait()
    }
    return nil
}

func (c *TCPClient) HandlePacket(ip *layers.IPv4, tcp *layers.TCP) {
    switch c.State {
    case "SYN_SENT":
        // Expecting SYN-ACK
        if tcp.SYN && tcp.ACK {
            c.AckNum = tcp.Seq + 1        // ACK server's SYN
            c.SeqNum = tcp.Ack            // Update our sequence number
            c.State = "ESTABLISHED"
            
            // Send final ACK to complete handshake
            c.sendSegment(false, true, false, nil)  // SYN=false, ACK=true
            c.cond.Broadcast()  // Wake up Connect()
        }
        
    case "ESTABLISHED":
        // Handle incoming data
        if len(tcp.Payload) > 0 {
            // Check sequence number (in-order delivery)
            if tcp.Seq == c.AckNum {
                c.DataBuffer.Write(tcp.Payload)  // Accumulate HTTP response
                c.AckNum += uint32(len(tcp.Payload))
                c.sendSegment(false, true, false, nil)  // Send ACK
            }
        }
        
        // Handle FIN (server closing)
        if tcp.FIN {
            c.AckNum++
            c.sendSegment(false, true, false, nil)  // ACK the FIN
        }
    }
}

func (n *Node) RunCurl(domain string) {
    // 1. Resolve domain name
    n.SendDNSQuery(domain, func(resolvedIP net.IP) {
        // 2. Create TCP connection
        srcPort := uint16(rand.Intn(10000) + 50000)
        tcpClient := transport.NewTCPClient(
            n.ipAddr,              // 172.18.0.1
            resolvedIP,            // 93.184.216.34 (example.com)
            srcPort,               // Random port (e.g., 55123)
            80,                    // HTTP port
            0x12345678,            // Initial sequence number
            n.QueueIPFrame,        // Send function
        )
        
        // 3. Establish TCP connection (3-way handshake)
        if err := tcpClient.Connect(); err != nil {
            fmt.Printf("Connection failed: %v\n", err)
            return
        }
        
        // 4. Send HTTP GET request
        httpRequest := fmt.Sprintf(
            "GET / HTTP/1.0\r\n"+
            "Host: %s\r\n"+
            "User-Agent: Aethernet\r\n"+
            "\r\n",
            domain,
        )
        tcpClient.Write([]byte(httpRequest))  // Sends as PSH+ACK segment
        
        // 5. Wait for HTTP response (15 second timeout)
        time.Sleep(15 * time.Second)
        
        // 6. Display accumulated response
        fmt.Println("\n--- HTTP Response ---")
        fmt.Println(tcpClient.Read())  // Read from DataBuffer
        fmt.Println("---------------------")
        
        // 7. Close TCP connection
        tcpClient.Close()  // Sends FIN
    })
}

func (c *TCPClient) sendSegment(syn, ack, fin bool, data []byte) {
    // Create TCP layer
    tcp := &layers.TCP{
        SrcPort: c.SrcPort,
        DstPort: c.DstPort,
        Seq:     c.SeqNum,
        Ack:     c.AckNum,
        SYN:     syn,
        ACK:     ack,
        FIN:     fin,
        PSH:     len(data) > 0,  // Push flag if sending data
        Window:  65535,
    }
    
    // Create IP layer
    ip := &layers.IPv4{
        SrcIP:    c.SrcIP,
        DstIP:    c.DstIP,
        Protocol: layers.IPProtocolTCP,
        TTL:      64,
    }
    
    // Set network layer for TCP checksum
    tcp.SetNetworkLayerForChecksum(ip)
    
    // Serialize: [IP][TCP][HTTP Data]
    gopacket.SerializeLayers(buffer, opts, ip, tcp, gopacket.Payload(data))
    
    // Send through lower layers
    c.SendIPPacket(c.DstIP, buffer.Bytes())
}

const (
    // Transport layer
    TCPTimeOut    = 15 * time.Second   // TCP response timeout
    CloudflareDNS = "1.1.1.1"          // Upstream DNS server
    
    // Data link layer
    RTTTimeout    = 350 * time.Millisecond  // ACK timeout
    MaxRetries    = 2                        // Max retransmission attempts
    
    // Network layer
    GatewayMAC    = "00-00-5e-00-01-01"     // Gateway MAC address
)