main.cc

// Copyright (c) 2022 Johannes Stoelp

#include <dhcp.h>
#include <lease_db.h>
#include <utils.h>

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

/// -- WIFI access configuration.

static constexpr char STATION_SSID[] = "<SSID>";
static constexpr char STATION_WPA2[] = "<WPA2PW>";

/// -- WIFI client config.

static const IPAddress LOCAL_IP(10, 0, 0, 2);
static const IPAddress GATEWAY(10, 0, 0, 1);
static const IPAddress BROADCAST(10, 0, 0, 255);
static const IPAddress SUBNET(255, 255, 255, 0);
static const IPAddress DNS1(192, 168, 2, 1);

/// -- DHCP lease config.

static const IPAddress LEASE_START(10, 0, 0, 10);
static constexpr u32 LEASE_TIME_SECS = 8 * 60 * 60; /* 8h */

/// -- DHCP message buffer.

alignas(dhcp_message) static u8 MSG_BUFFER[DHCP_MESSAGE_LEN];

static_assert(sizeof(dhcp_message) <= sizeof(MSG_BUFFER), "UDP buffer must be big enough to hold dhcp_message!");

/// -- Lease DB.

static lease_db<16> LEASE_DB;

/// -- UDP io handler.

static WiFiUDP UDP;

/// -- Template specialization.

template<>
inline IPAddress get_opt_val(const u8* opt_data) {
    return IPAddress(opt_data[0], opt_data[1], opt_data[2], opt_data[3]);
}

template<>
inline u8* put_opt_val(u8* opt_data, IPAddress addr) {
    *opt_data++ = addr[0];
    *opt_data++ = addr[1];
    *opt_data++ = addr[2];
    *opt_data++ = addr[3];
    return opt_data;
}

#define LOG_UART(uart, fmt, ...)                  \
    do {                                          \
        if (uart) {                               \
            uart.printf(fmt "\r", ##__VA_ARGS__); \
        }                                         \
    } while (0)

#define LOG(fmt, ...) LOG_UART(Serial, fmt, ##__VA_ARGS__)

static void setup_station_wifi() {
    // Configure wifi in station mode.
    WiFi.mode(WIFI_STA);

    // Configure static IP.
    WiFi.config(LOCAL_IP, GATEWAY, SUBNET, DNS1);

    // Connect to SSID.
    WiFi.begin(STATION_SSID, STATION_WPA2);

    // Wait until wifi is connected.
    Serial.printf("Connecting to SSID = %s\n\r", STATION_SSID);
    while (WiFi.status() != WL_CONNECTED) {
        Serial.print('.');
        delay(500);
    }

    Serial.printf("\n\rConnected to %s\n\r", STATION_SSID);
    Serial.print("  local_ip : ");
    Serial.println(WiFi.localIP());
    Serial.print("  gateway  : ");
    Serial.println(WiFi.gatewayIP());
    Serial.print("  subnet   : ");
    Serial.println(WiFi.subnetMask());
    Serial.print("  dns1     : ");
    Serial.println(WiFi.dnsIP());
    Serial.print("  broadcast: ");
    Serial.println(WiFi.broadcastIP());
}

void setup() {
    // Initialize serial port for logging.
    Serial.begin(115200);

    // Connect as client to wifi using global configuration.
    setup_station_wifi();

    // Start listening for udp messages.
    UDP.begin(DHCP_SERVER_PORT);

    pinMode(LED_BUILTIN, OUTPUT);
}

static void handle_dhcp_message(dhcp_message& msg, usize len);

void loop() {
    const usize npbytes = UDP.parsePacket();

    // Only handle UDP packets with valid size wrt dhcp messages.
    if (npbytes >= DHCP_MESSAGE_MIN_LEN && npbytes < sizeof(dhcp_message)) {
        const usize nrbytes = UDP.read(MSG_BUFFER, npbytes);

        // Type pun buffer to to dhcp_message (cpp).
        // Should be optimized out mainly due to alignment specification of buffer.
        dhcp_message msg;
        std::memcpy(&msg, MSG_BUFFER, sizeof(msg));

        handle_dhcp_message(msg, nrbytes);
    } else {
        if (npbytes > 0) {
            LOG("Ignored UDP message of size %d bytes\n", npbytes);
        }
        delay(500);
    }
}

// Try to unwrap an optional, return of optional doesn't hold a value.
#define TRY(expr)             \
    ({                        \
        auto optional = expr; \
        if (!optional)        \
            return;           \
        optional.value();     \
    })

// Get seconds since boot (absolute time value).
// We use this to maintain lease expiration times.
usize now_secs() {
    return millis() / 1000;
}

static void handle_dhcp_message(dhcp_message& msg, usize len) {
    // Sanity check dhcp message.
    if (msg.op != dhcp_operation::BOOTREQUEST || msg.cookie != DHCP_OPTION_COOKIE) {
        return;
    }

    // Length of the filled in client options.
    const usize opt_len = len - (msg.options - (const u8*)&msg);

    // Each dhcp message must contain the dhcp message type (state in the protocol).
    const auto msg_type = ({
        auto opt = TRY(get_option(msg.options, opt_len, dhcp_option::DHCP_MESSAGE_TYPE));
        from_raw<dhcp_message_type>(opt.data[0]);
    });

    // Remove expired leases.
    LEASE_DB.flush_expired(now_secs());

    // Compute client hash, using the CLIENT_ID option if available else use
    // the hardware address.
    u32 client_hash;
    if (const auto client_id = get_option(msg.options, opt_len, dhcp_option::CLIENT_ID)) {
        client_hash = hash(client_id->data, client_id->len);
    } else {
        client_hash = hash(msg.chaddr, msg.hlen);
    }

    // Extract the dhcp options requested by the client (using 16 was sufficient in my case).
    dhcp_option requested_param[16];
    usize requested_param_len = 0;
    if (const auto opt = get_option(msg.options, opt_len, dhcp_option::PARAMETER_REQUEST_LIST)) {
        requested_param_len = opt->len > sizeof(requested_param) ? sizeof(requested_param) : opt->len;

        for (usize i = 0; i < requested_param_len; ++i) {
            requested_param[i] = from_raw<dhcp_option>(opt->data[i]);
        }
    }

    usize lease_id;
    dhcp_message_type resp_msg;

    switch (msg_type) {
        case dhcp_message_type::DHCP_DISCOVER: {
            LOG("Received DHCP_DISCOVER client_hash=%x\n", client_hash);

            if (const auto lease = LEASE_DB.get_lease(client_hash)) {
                // We already have a lease for this client.
                lease_id = lease.value();
            } else {
                // Allocate a new lease for this client and reserve for a short
                // amount of time.
                lease_id = TRY(LEASE_DB.new_lease(client_hash, now_secs() + 15 /* secs */));
            }

            // DHCP message type answer.
            resp_msg = dhcp_message_type::DHCP_OFFER;
        } break;

        case dhcp_message_type::DHCP_REQUEST: {
            LOG("Received DHCP_REQUEST client_hash=%x\n", client_hash);

            // Get server identifier specified by client.
            const auto server_id = ({
                auto op = TRY(get_option(msg.options, opt_len, dhcp_option::SERVER_IDENTIFIER));
                get_opt_val<IPAddress>(op.data);
            });

            // Check if dhcp message was ment for us.
            if (server_id != LOCAL_IP) {
                return;
            }

            // Client is now requesting the offered lease, at that stage the
            // lease should have been allocated.
            lease_id = TRY(LEASE_DB.get_lease(client_hash));

            // Update the lease db with the proper lease expiration time
            // (absolute time).
            LEASE_DB.update_lease(client_hash, now_secs() + LEASE_TIME_SECS /* secs */);

            // DHCP message type answer.
            resp_msg = dhcp_message_type::DHCP_ACK;
        } break;

        default: {
            LOG("Received unexpected DHCP MESSAGE TYPE %d\n", into_raw(msg_type));
            return;
        }
    }

    // Craft response package.

    // Compute client id based on start address of dhcp range and lease idx.
    auto client_addr = LEASE_START;
    client_addr[3] = client_addr[3] + lease_id;

    // From rfc2131 Table 3:
    //
    // Field      DHCPOFFER   DHCPACK
    // -----      ---------   -------
    // 'op'       BOOTREPLY   BOOTREPLY
    // 'htype'    keep        keep
    // 'hlen'     keep        keep
    // 'hops'     0           0
    // 'xid'      keep        keep
    // 'secs'     0           0
    // 'ciaddr'   0           0
    // 'yiaddr'   IP address offered to client
    // 'siaddr'   IP address of next bootstrap server
    // 'flags'    keep        keep
    // 'giaddr'   keep        keep
    // 'chaddr'   keep        keep
    // 'sname'    Server host name or options
    // 'file'     Client boot file name or options

    msg.op = dhcp_operation::BOOTREPLY;
    msg.hops = 0;
    msg.secs = 0;
    msg.ciaddr = 0;
    msg.yiaddr = client_addr.v4();
    msg.siaddr = LOCAL_IP.v4();

    // From rfc2131 Table 3:
    //
    // Option                    DHCPOFFER   DHCPACK
    // ------                    ---------   -------
    // IP address lease time     MUST        MUST (DHCPREQUEST)
    // DHCP message type         DHCPOFFER   DHCPACK
    // Server identifier         MUST        MUST

    u8* optp = msg.options;

    // DHCP message type.
    *optp++ = into_raw(dhcp_option::DHCP_MESSAGE_TYPE);
    *optp++ = 1 /* len */;
    *optp++ = into_raw(resp_msg);

    // Server identifier.
    *optp++ = into_raw(dhcp_option::SERVER_IDENTIFIER);
    *optp++ = 4 /* len */;
    optp = put_opt_val(optp, LOCAL_IP);

    // Lease time.
    *optp++ = into_raw(dhcp_option::IP_ADDRESS_LEASE_TIME);
    *optp++ = 4 /* len */;
    optp = put_opt_val(optp, LEASE_TIME_SECS);

    // Renewal time.
    *optp++ = into_raw(dhcp_option::RENEWAL_TIME_T1);
    *optp++ = 4 /* len */;
    optp = put_opt_val(optp, LEASE_TIME_SECS / 2);

    // Rebind time.
    *optp++ = into_raw(dhcp_option::REBINDING_TIME_T2);
    *optp++ = 4 /* len */;
    optp = put_opt_val(optp, LEASE_TIME_SECS * 8 / 12);

    // Add options requested by client that we support.
    for (usize i = 0; i < requested_param_len; ++i) {
        auto opt = requested_param[i];
        switch (opt) {
            case dhcp_option::SUBNET_MASK: {
                // Subnet mask.
                *optp++ = into_raw(opt);
                *optp++ = 4 /* len */;
                optp = put_opt_val(optp, SUBNET);
            } break;

            case dhcp_option::ROUTER: {
                // Router address.
                *optp++ = into_raw(opt);
                *optp++ = 4 /* len */;
                optp = put_opt_val(optp, GATEWAY);
            } break;

            case dhcp_option::DNS: {
                // DNS address.
                *optp++ = into_raw(opt);
                *optp++ = 4 /* len */;
                optp = put_opt_val(optp, DNS1);
            } break;

            case dhcp_option::BROADCAST_ADDR: {
                // Broadcast address.
                *optp++ = into_raw(opt);
                *optp++ = 4 /* len */;
                optp = put_opt_val(optp, BROADCAST);
            } break;

            default:
                break;
        }
    }

    // End option end marker.
    *optp++ = into_raw(dhcp_option::END);

    // Send out dhcp message.
    UDP.beginPacket(BROADCAST, DHCP_CLIENT_PORT);
    UDP.write((const u8*)&msg, optp - (u8*)&msg);
    UDP.endPacket();
}