Initial version of nodemcuv2 dhcp serverHEADmain

Able to offer IP address + DNS/Gateway ...
Worked with devices at my hand.

16 files changed, 1323 insertions, 0 deletions

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..cc75bce
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,104 @@
+# dotfiles -- clang-format
+# author: johannst
+# doc   : https://clang.llvm.org/docs/ClangFormatStyleOptions.html
+
+Language: Cpp
+Standard: Auto
+
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: true
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: true
+BinPackParameters: true
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel:        false
+  AfterClass:            false
+  AfterControlStatement: false
+  AfterEnum:             false
+  AfterFunction:         false
+  AfterNamespace:        false
+  AfterStruct:           false
+  AfterUnion:            false
+  AfterExternBlock:      false
+  BeforeCatch:           false
+  BeforeElse:            false
+  IndentBraces:          false
+  SplitEmptyFunction:    true
+  SplitEmptyRecord:      true
+  SplitEmptyNamespace:   true
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+BreakConstructorInitializersBeforeComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeInheritanceComma: false
+BreakStringLiterals: true
+ColumnLimit:     140
+CompactNamespaces: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 2
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+IncludeBlocks:   Preserve
+# Could use `IncludeCategories` to define rules for includes
+IndentCaseLabels: true
+IndentPPDirectives: AfterHash
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: true
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth:        4
+UseTab:          Never
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..daa6f43
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+.pio
+.cache
+.ccls
+blob
+compile_commands.json
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7c153e5
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Johannes Stoelp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..203276a
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,20 @@
+# Copyright (c) 2022 Johannes Stoelp
+
+build:
+	pio run
+
+run:
+	pio run -e nodemcuv2 -t upload && pio device monitor -b 115200
+
+check:
+	pio test
+
+clean:
+	pio run -t clean
+
+help:
+	@echo "Targets:"
+	@echo "  build  - Build project."
+	@echo "  run    - Build & flash project and attach serial monitor."
+	@echo "  check  - Run tests."
+	@echo "  clean  - Clean project."
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..5b1bb29
--- /dev/null
+++ b/README.md
@@ -0,0 +1,141 @@
+# pio-nodemcuv2-dhcp-server
+
+This repository implements a minimal [dhcp server][dhcp] on the [nodemcu v2]
+board using the [arduino] framework and the [PlatformIO][pio] build
+environment.
+
+
+## DHCP protocol
+
+All details of the dhcp protocol required for this implementation can be found
+in the following two RFCs
+- [rfc2131]: Dynamic Host Configuration Protocol
+- [rfc2132]: DHCP Options and BOOTP Vendor Extensions
+
+## Run
+
+Install PlatformIO core following the [installation guide][pio-install].
+
+```shell
+# Build the project.
+pio run
+
+# Run the test (only added host native tests).
+pio test
+
+# ... Attach nodemcu v2 board via USB.
+
+# Build and flash the embedded software.
+pio run -e nodemcuv2 -t upload
+
+# Connect to the serial monitor.
+pio device monitor -b 115200
+```
+
+> Check the [Makefile](Makefile) for reference.
+
+## Configuration
+
+The wifi client and dhcp server are currently configured with the following
+global variables in [main.cc](src/main.cc).
+
+```cpp
+/// -- 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 */
+```
+
+## Why all this?
+
+My ultimate goal was to setup a **guest wifi** to isolate my home network while
+offering wifi to my guests.
+For that I planned to use of the baked in guest wifi feature of the router I
+got from my ISP.
+
+In my home network I am running [pi-hole] for blocking ads and trackers, which
+works by blocking those services on the DNS level. For this to function, all
+the devices in my home network need to use the pi-hole node as DNS server.
+This is typically done by letting the dhcp server distribute the DNS server to
+use (so it does not need to be configured on each device).
+Because the built-in dhcp server in the ISP router doesn't allow to configure
+the DNS server I disabled that one and run the optional dhcp server which comes
+with pi-hole.
+
+With that setup as starting point, one problem arises when using the guest wifi
+on the ISP router. Guest devices connected to the guest wifi don't see a dhcp
+server and hence don't get an IP address assigned. In turn, the setup is
+useless as I don't want guests to statically configure an IP address :^)
+
+Therefore the plan was to write a minimal dhcp server running on a [nodemcu v2]
+which would then linger in the guest wifi and distribute IP addresses to my
+guests.
+
+> Why a nodemcu v2? Because it has an wireless antenna and I had one laying
+> around collecting dust.
+
+So all in all my home setup would look something like the following.
+
+```
+   Home     +-----------+     Guest     +---------------+
+   Wifi (((-| ISP modem |-))) Wifi  (((-| nodemcuv2     |
+            |  & router |               | (dhcp server) |
+            +-----+-----+               +---------------+
+                  |
+          +-------+-------+
+          | pihole        |
+          | (dhcp server) |
+          +---------------+
+```
+
+## End of the story ...
+
+... I read the RFCs, developed & tested the dhcp server in my home network and
+then learned that the guests are isolated and I couldn't disable that isolation
+in the ISP router.
+
+At the end I couldn't deploy the guest wifi as planned but I had fun
+implementing the dhcp server and I guess learned something :^)
+
+For now I switched over to offering guest wifi by running an access point on
+the raspberry pi spanning a new sub-net and then doing NAT and iptables
+isolation to protect my home network. It's not ideal but it's sufficient for
+now.
+
+```
+   Home     +-----------+ 
+   Wifi (((-| ISP modem |
+            |  & router |
+            +-----+-----+
+                  |
+          +-------+-------+----------+    Guest
+          | pihole        | NAT      |-))) Wifi
+          | (dhcp server) | iptables |
+          +---------------+----------+
+```
+
+## License
+
+This project is licensed under the [MIT](LICENSE) license.
+
+[dhcp]: https://en.wikipedia.org/wiki/Dynamic_Host_Configuration_Protocol
+[rfc2131]: https://datatracker.ietf.org/doc/html/rfc2131
+[rfc2132]: https://datatracker.ietf.org/doc/html/rfc2132
+[pio]: https://platformio.org
+[pio-install]: https://docs.platformio.org/en/latest//core/installation.html
+[arduino]: https://docs.platformio.org/en/latest/frameworks/arduino.html
+[pi-hole]: https://pi-hole.net
+[nodemcu v2]: https://www.az-delivery.de/en/products/nodemcu
diff --git a/doc/dhcp.txt b/doc/dhcp.txt
new file mode 100644
index 0000000..686137b
--- /dev/null
+++ b/doc/dhcp.txt
@@ -0,0 +1,134 @@
+dhcp protocol: https://datatracker.ietf.org/doc/html/rfc2131
+dhcp options : https://datatracker.ietf.org/doc/html/rfc2132
+
+dhcp message:
+
+   0                   1                   2                   3
+   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     op (1)    |   htype (1)   |   hlen (1)    |   hops (1)    |
+   +---------------+---------------+---------------+---------------+
+   |                            xid (4)                            |
+   +-------------------------------+-------------------------------+
+   |           secs (2)            |           flags (2)           |
+   +-------------------------------+-------------------------------+
+   |                          ciaddr  (4)                          |
+   +---------------------------------------------------------------+
+   |                          yiaddr  (4)                          |
+   +---------------------------------------------------------------+
+   |                          siaddr  (4)                          |
+   +---------------------------------------------------------------+
+   |                          giaddr  (4)                          |
+   +---------------------------------------------------------------+
+   |                                                               |
+   |                          chaddr  (16)                         |
+   |                                                               |
+   |                                                               |
+   +---------------------------------------------------------------+
+   |                                                               |
+   |                          sname   (64)                         |
+   +---------------------------------------------------------------+
+   |                                                               |
+   |                          file    (128)                        |
+   +---------------------------------------------------------------+
+   |                                                               |
+   |                          options (variable)                   |
+   +---------------------------------------------------------------+
+
+dhcp message flags field:
+
+                       1 1 1 1 1 1
+   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |B|             MBZ             |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+   B:  BROADCAST flag
+   MBZ:  MUST BE ZERO (reserved for future use)
+
+dhcp message field description:
+
+   FIELD      OCTETS       DESCRIPTION
+   -----      ------       -----------
+   op            1         Message op code / message type.
+                           1 = BOOTREQUEST, 2 = BOOTREPLY
+   htype         1         Hardware address type, see ARP section in "Assigned
+                           Numbers" RFC; e.g., '1' = 10mb ethernet.
+   hlen          1         Hardware address length (e.g.  '6' for 10mb
+                           ethernet).
+   hops          1         Client sets to zero, optionally used by relay agents
+                           when booting via a relay agent.
+   xid           4         Transaction ID, a random number chosen by the
+                           client, used by the client and server to associate
+                           messages and responses between a client and a
+                           server.
+   secs          2         Filled in by client, seconds elapsed since client
+                           began address acquisition or renewal process.
+   flags         2         Flags ([0]: broadcast flag).
+   ciaddr        4         Client IP address; only filled in if client is in
+                           BOUND, RENEW or REBINDING state and can respond
+                           to ARP requests.
+   yiaddr        4         'your' (client) IP address.
+   siaddr        4         IP address of next server to use in bootstrap;
+                           returned in DHCPOFFER, DHCPACK by server.
+   giaddr        4         Relay agent IP address, used in booting via a
+                           relay agent.
+   chaddr       16         Client hardware address.
+   sname        64         Optional server host name, null terminated string.
+   file        128         Boot file name, null terminated string; "generic"
+                           name or null in DHCPDISCOVER, fully qualified
+                           directory-path name in DHCPOFFER.
+   options     var         Optional parameters field.  See the options
+                           documents for a list of defined options.
+
+- A DHCP server always returns its own address in the 'server identifier'
+  option.
+
+- Client must accept DHCP of at least 576 octets (312 octects of option)
+
+- Time values (eg lease) are relative times in seconds and should be treated
+  relative wo each nodes clock.
+
+- Services:
+    - Parameter repository (2.1), used for persistent storage of network
+      parameters.
+    - Dynamic nw address allocation (2.2)
+
+- Protocol
+    - op == BOOTREQUEST client -> server message
+    - op == BOOTREPLY   server -> client message
+    - options[0:4] -> magic cookie {0x63, 0x82, 0x53, 0x63}
+    - option (53 - DHCP Message Type) required in all dhcp messages
+
+    1. Client broadcasts DHCPDISCOVER (53).
+    2. Server respond with DHCPOFFER (53).
+        - yiaddr -> allocated address
+        - additional options
+    3. Client broadcasts DHCPREQUEST (53).
+        - must include 'server identifier' option
+        - 'requested ip address' option must be set to 'yiaddr' offerened in 2.
+    4. Server sends DHCPACK (53) to client.
+        - fill 'yiaddr' with allocated address
+        - add configuration parameters
+    5. Client may send DHCPDECLINE (53) if it detects addr already in use.
+    6. Client may send DHCPRELEASE (53).
+
+- Constructing dhcp message
+    - variable options must end with 'end (255)' option
+    - client -> server udp port 67
+    - server -> client udp port 68
+    - @server (msg received by client)
+        - giaddr !=0 -> using BOOTP relay -> send resp to @giaddr:67
+        - giaddr == 0 && ciaddr != 0 -> send resp to @ciaddr:68
+        - giaddr == 0 && ciaddr == 0 && flags.b == 1 -> send resp to broadcast 0xffff_ffff
+        - giaddr == 0 && ciaddr == 0 && flags.b == 0 -> send resp to client hw addr + yiaddr
+
+- Options:
+    - 'maximum DHCP message size'
+        - Client may negotiate lager dhcp messages.
+    - 'server identifier'
+        - A DHCP server always returns its own address in the option.
+    - 'client identifier'
+        - Client may pass explicit client identifier to server.
+    - 'DHCP message type' (REQUIRED)
+        - type of dhcp message
diff --git a/lib/dhcp/dhcp.cc b/lib/dhcp/dhcp.cc
new file mode 100644
index 0000000..1e5f785
--- /dev/null
+++ b/lib/dhcp/dhcp.cc
@@ -0,0 +1,36 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#include "dhcp.h"
+#include "utils.h"
+
+std::optional<struct option_view> get_option(const u8* opt, usize len, dhcp_option search_tag) {
+    const u8* end = opt + len;
+
+    while (opt < end) {
+        // Get tag of current option.
+        dhcp_option tag = from_raw<dhcp_option>(*opt++);
+
+        if (tag == dhcp_option::END) {
+            break;
+        }
+
+        // Extract length of current option.
+        usize len = *opt++;
+
+        if (tag == search_tag) {
+            if (static_cast<usize>(end - opt) < len) {
+                // If length is malformed.
+                return std::nullopt;
+            } else {
+                // Option found.
+                return {{opt, len}};
+            }
+        }
+
+        // Advance option iterator to beginning of next option.
+        opt = opt + len;
+    }
+
+    // Option not found.
+    return std::nullopt;
+}
diff --git a/lib/dhcp/dhcp.h b/lib/dhcp/dhcp.h
new file mode 100644
index 0000000..ce904f0
--- /dev/null
+++ b/lib/dhcp/dhcp.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2022 Johannes Stoelp
+//
+// dhcp protocol: https://datatracker.ietf.org/doc/html/rfc2131
+// dhcp options : https://datatracker.ietf.org/doc/html/rfc2132
+
+#ifndef DHCP_H
+#define DHCP_H
+
+#include "types.h"
+
+#include <optional>
+
+// -- Global constants.
+
+constexpr u16 DHCP_SERVER_PORT = 67;
+constexpr u16 DHCP_CLIENT_PORT = 68;
+
+constexpr usize DHCP_MESSAGE_LEN = 576;
+constexpr usize DHCP_MESSAGE_MIN_LEN = 243;
+
+constexpr u32 DHCP_OPTION_COOKIE = 0x63538263;
+
+enum class dhcp_operation : u8 {
+    BOOTREQUEST = 1,
+    BOOTREPLY,
+};
+
+enum class dhcp_option : u8 {
+    PAD = 0,
+    END = 255,
+
+    // Vendor Extensions.
+    SUBNET_MASK = 1,
+    ROUTER = 3,
+    DNS = 6,
+
+    // IP Layer Parameters per Interface.
+    BROADCAST_ADDR = 28,
+
+    // DHCP Extensions.
+    REQUESTED_IP = 50,
+    IP_ADDRESS_LEASE_TIME,
+    OPTION_OVERLOAD,
+    DHCP_MESSAGE_TYPE,
+    SERVER_IDENTIFIER,
+    PARAMETER_REQUEST_LIST,
+    MESSAGE,
+    MAX_DHCP_MESSAGE_SIZE,
+    RENEWAL_TIME_T1,
+    REBINDING_TIME_T2,
+    CLASS_ID,
+    CLIENT_ID,
+};
+
+// -- DHCP message.
+
+enum class dhcp_message_type : u8 {
+    DHCP_DISCOVER = 1,
+    DHCP_OFFER,
+    DHCP_REQUEST,
+    DHCP_DECLINE,
+    DHCP_ACK,
+    DHCP_NAK,
+    DHCP_RELEAE,
+};
+
+struct dhcp_message {
+    dhcp_operation op;
+    u8 htype;
+    u8 hlen;
+    u8 hops;
+    u32 xid;
+    u16 secs;
+    u16 flags;
+    u32 ciaddr;
+    u32 yiaddr;
+    u32 siaddr;
+    u32 giaddr;
+    u8 chaddr[16];
+    u8 sname[64];
+    u8 file[128];
+    u32 cookie;
+    u8 options[312 - 4 /* cookie len */];
+} __attribute__((packed));
+
+static_assert(DHCP_MESSAGE_MIN_LEN == offsetof(dhcp_message, options) + 3 /* DHCP_MESSAGE_TYPE size */,
+              "Declare min size as dhcp_message with the DHCP_MESSAGE_TYPE option.");
+
+// -- DHCP Utilities.
+
+struct option_view {
+    const u8* data;
+    usize len;
+};
+
+// Search for the option with tag 'search_tag' in the options 'opt' of length 'len'.
+std::optional<struct option_view> get_option(const u8* opt, usize len, dhcp_option search_tag);
+
+template<typename T>
+constexpr T get_opt_val(const u8* opt_data) {
+    T ret = 0;
+    for (size_t i = 0; i < sizeof(T); ++i) {
+        ret = (ret << 8) | *opt_data++;
+    }
+    return ret;
+}
+
+template<typename T>
+u8* put_opt_val(u8* opt_data, T val) {
+    for (size_t i = sizeof(T); i; --i) {
+        *opt_data++ = (val >> ((i - 1) * 8)) & 0xff;
+    }
+    return opt_data;
+}
+
+#endif
diff --git a/lib/dhcp/lease_db.h b/lib/dhcp/lease_db.h
new file mode 100644
index 0000000..86b959f
--- /dev/null
+++ b/lib/dhcp/lease_db.h
@@ -0,0 +1,111 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#ifndef LEASE_DB_H
+#define LEASE_DB_H
+
+#include "types.h"
+
+#include <array>
+#include <optional>
+
+struct lease {
+    u32 client_hash;
+    usize lease_end;
+};
+
+// Lease database, for managing client leases, which includes
+//   - allocation of new leases
+//   - lookup of existing leases
+//   - update of existing leases
+//   - flushing of expired leases
+//
+// The database supports 'LEASE' number of clients.
+//
+// The lease APIs return an idx which represents the allocated client lease and
+// should be interpreted as offset to the start address of the dhcp address
+// range.
+//
+// For example, the dhcp server starts to assing addresses starting with
+// 10.0.0.100, and the lease database returns idx=4, this would represent the
+// allocated client address 10.0.0.104.
+template<usize LEASES>
+class lease_db {
+  public:
+    constexpr lease_db() = default;
+
+    lease_db(const lease_db&) = delete;
+    lease_db& operator=(const lease_db&) = delete;
+
+    // Try to allocate a new client lease for the client represented by
+    // 'client_hash'.
+    //
+    // If a lease could be allocated return the corresponding idx.
+    //
+    // If a lease for the client already exist or all leases are allocated,
+    // return nullopt.
+    //
+    // 'lease_end' sets the expiration time of the lease (should be absolute time).
+    std::optional<usize> new_lease(u32 client_hash, usize lease_end) {
+        if (get_lease(client_hash)) {
+            return std::nullopt;
+        }
+
+        for (usize l = 0; client_hash != 0 && l < LEASES; ++l) {
+            if (leases[l].client_hash == 0) {
+                leases[l].client_hash = client_hash;
+                leases[l].lease_end = lease_end;
+                return l;
+            }
+        }
+        return std::nullopt;
+    }
+
+    // Try to get the lease for the client if it exists.
+    std::optional<usize> get_lease(u32 client_hash) const {
+        for (usize l = 0; client_hash != 0 && l < LEASES; ++l) {
+            if (leases[l].client_hash == client_hash) {
+                return l;
+            }
+        }
+        return std::nullopt;
+    }
+
+    // Update expiration time for client if the client has an allocated lease.
+    // Similar to 'new_lease' the 'lease_end' should be an absolute time value.
+    bool update_lease(u32 client_hash, usize lease_end) {
+        for (usize l = 0; client_hash != 0 && l < LEASES; ++l) {
+            if (leases[l].client_hash == client_hash) {
+                leases[l].lease_end = lease_end;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // Check for expired leases and free them accordingly.
+    // 'curr_time' should be the current time as absolute time value.
+    void flush_expired(usize curr_time) {
+        for (lease& l : leases) {
+            if (l.lease_end <= curr_time) {
+                l.client_hash = 0;
+                l.lease_end = 0;
+            }
+        }
+    }
+
+    // Get the number of active leases.
+    usize active_leases() const {
+        usize cnt = 0;
+        for (const lease& l : leases) {
+            if (l.client_hash != 0) {
+                ++cnt;
+            }
+        }
+        return cnt;
+    }
+
+  private:
+    std::array<lease, LEASES> leases = {0, 0};
+};
+
+#endif
diff --git a/lib/dhcp/types.h b/lib/dhcp/types.h
new file mode 100644
index 0000000..049de0f
--- /dev/null
+++ b/lib/dhcp/types.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#ifndef TYPES_H
+#define TYPES_H
+
+#include <cstddef>
+#include <cstdint>
+
+using u8 = uint8_t;
+using u16 = uint16_t;
+using u32 = uint32_t;
+using usize = size_t;
+
+#endif
diff --git a/lib/dhcp/utils.h b/lib/dhcp/utils.h
new file mode 100644
index 0000000..9016007
--- /dev/null
+++ b/lib/dhcp/utils.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <type_traits>
+
+// Convert from an underlying enum type into an enum variant.
+template<typename E>
+constexpr E from_raw(std::underlying_type_t<E> u) {
+    static_assert(std::is_enum_v<E>);
+    return static_cast<E>(u);
+}
+
+// Convert from an enum variant into an underlying enum type.
+template<typename E>
+constexpr std::underlying_type_t<E> into_raw(E e) {
+    static_assert(std::is_enum_v<E>);
+    return static_cast<std::underlying_type_t<E>>(e);
+}
+
+// Simple cyclic rotation hash function.
+constexpr u32 hash(const u8* data, usize len) {
+    u32 hash = 0xa5a55a5a /* seed */;
+    for (usize i = 0; i < len; ++i) {
+        hash += ((hash << 25) | (hash >> 7) /* rrot(7) */) ^ data[i];
+    }
+    return hash;
+}
+
+#endif
diff --git a/platformio.ini b/platformio.ini
new file mode 100644
index 0000000..4fa5c0f
--- /dev/null
+++ b/platformio.ini
@@ -0,0 +1,20 @@
+; Copyright (c) 2022 Johannes Stoelp
+
+; Build embedded target.
+[env:nodemcuv2]
+platform    = espressif8266
+board       = nodemcuv2
+framework   = arduino
+build_flags = -Wextra
+; Ignore tests in test/native for this target.
+test_ignore = native
+
+; Build host native target.
+[env:native]
+platform        = native
+targets         = test
+lib_deps        = google/googletest@^1.10.0
+build_flags     = -lpthread -lgtest_main
+; Turn off compat mode.
+; https://community.platformio.org/t/googletest-problem-with-compilation-process/12048/12
+lib_compat_mode = off
diff --git a/src/main.cc b/src/main.cc
new file mode 100644
index 0000000..e294a1d
--- /dev/null
+++ b/src/main.cc
@@ -0,0 +1,349 @@
+// 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();
+}
diff --git a/test/native/dhcp.cc b/test/native/dhcp.cc
new file mode 100644
index 0000000..983c6c8
--- /dev/null
+++ b/test/native/dhcp.cc
@@ -0,0 +1,65 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#include <dhcp.h>
+#include <utils.h>
+
+#include <gtest/gtest.h>
+
+TEST(option, get_available_opt) {
+    u8 opts[] = {
+        into_raw(dhcp_option::PAD), into_raw(dhcp_option::PAD), into_raw(dhcp_option::DHCP_MESSAGE_TYPE), 5 /* len */, 0, 1, 2, 3, 4,
+        into_raw(dhcp_option::END),
+    };
+
+    auto ov = get_option(opts, sizeof(opts), dhcp_option::DHCP_MESSAGE_TYPE);
+
+    ASSERT_EQ(true, ov.has_value());
+    ASSERT_EQ(0, ov.value().data[0]);
+    ASSERT_EQ(1, ov.value().data[1]);
+    ASSERT_EQ(2, ov.value().data[2]);
+    ASSERT_EQ(3, ov.value().data[3]);
+    ASSERT_EQ(4, ov.value().data[4]);
+    ASSERT_EQ(5, ov.value().len);
+}
+
+TEST(option, maleformed_len) {
+    u8 opts[] = {
+        into_raw(dhcp_option::PAD), into_raw(dhcp_option::PAD), into_raw(dhcp_option::DHCP_MESSAGE_TYPE), 5 /* len */, 0,
+        into_raw(dhcp_option::END),
+    };
+
+    {
+        auto ov = get_option(opts, sizeof(opts), dhcp_option::DHCP_MESSAGE_TYPE);
+
+        ASSERT_EQ(false, ov.has_value());
+    }
+    {
+        auto ov = get_option(opts, sizeof(opts), dhcp_option::CLASS_ID);
+
+        ASSERT_EQ(false, ov.has_value());
+    }
+}
+
+TEST(option, maleformed_missing_end) {
+    u8 opts[] = {
+        into_raw(dhcp_option::PAD),
+        into_raw(dhcp_option::PAD),
+    };
+
+    auto ov = get_option(opts, sizeof(opts), dhcp_option::DHCP_MESSAGE_TYPE);
+
+    ASSERT_EQ(false, ov.has_value());
+}
+
+TEST(option, put_opt_val) {
+    u8 options[8] = {0};
+    u32 val = 0xdeadbeef;
+
+    u8* nextp = put_opt_val(options, val);
+
+    ASSERT_EQ(options + 4, nextp);
+    ASSERT_EQ(0xde, options[0]);
+    ASSERT_EQ(0xad, options[1]);
+    ASSERT_EQ(0xbe, options[2]);
+    ASSERT_EQ(0xef, options[3]);
+}
\ No newline at end of file
diff --git a/test/native/hash.cc b/test/native/hash.cc
new file mode 100644
index 0000000..8aa0a35
--- /dev/null
+++ b/test/native/hash.cc
@@ -0,0 +1,71 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#include <types.h>
+#include <utils.h>
+
+#include <filesystem>
+#include <fstream>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+using ID = std::array<u8, 6>;
+namespace fs = std::filesystem;
+
+std::vector<ID> read_blob() {
+    if (!fs::exists("blob")) {
+        std::system("dd if=/dev/urandom of=blob count=16 bs=1M");
+    }
+
+    std::vector<ID> ids;
+    ids.reserve(fs::file_size("blob") / sizeof(ID));
+
+    auto ifs = std::ifstream("blob");
+    assert(ifs.is_open());
+    ID id;
+    while (ifs.read((char*)id.data(), sizeof(id))) {
+        ids.push_back(id);
+    }
+
+    return ids;
+}
+
+TEST(hash, uniform_distribuation) {
+    constexpr usize BUCKETS = 64;
+    constexpr float BUCKET_SIZE = static_cast<float>(100) / BUCKETS;  // Bucket size in percent.
+    constexpr float BUCKET_ERR = BUCKET_SIZE * 0.05 /* 5% */;         // Allowed distribution error.
+
+    const auto ids = read_blob();
+
+    usize cnt[BUCKETS] = {0};
+    for (const auto& id : ids) {
+        u32 h = hash(id.data(), id.size());
+        cnt[h % BUCKETS] += 1;
+    }
+
+    for (usize b = 0; b < BUCKETS; ++b) {
+        const float dist = static_cast<float>(cnt[b]) / ids.size() * 100;
+        ASSERT_GT(dist, BUCKET_SIZE - BUCKET_ERR);
+        ASSERT_LT(dist, BUCKET_SIZE + BUCKET_ERR);
+        // printf("bucket %2ld: %5.2f (%ld)\n", b, dist, cnt[b]);
+    }
+}
+
+TEST(hash, DISABLED_collisions) {
+    const auto ids = read_blob();
+
+    std::unordered_map<u32, usize> hits;
+    for (const auto& id : ids) {
+        u32 h = hash(id.data(), id.size());
+        hits[h] = hits[h] + 1;
+    }
+
+    usize collisions = 0;
+    for (const auto& hit : hits) {
+        if (hit.second > 1) {
+            ++collisions;
+        }
+    }
+
+    printf("Hashed %ld values got %ld collisions\n", ids.size(), collisions);
+}
diff --git a/test/native/lease_db.cc b/test/native/lease_db.cc
new file mode 100644
index 0000000..8f87912
--- /dev/null
+++ b/test/native/lease_db.cc
@@ -0,0 +1,85 @@
+// Copyright (c) 2022 Johannes Stoelp
+
+#include <lease_db.h>
+
+#include <gtest/gtest.h>
+
+TEST(lease_db, null_client_hash) {
+    lease_db<2> db;
+
+    ASSERT_EQ(std::nullopt, db.new_lease(0, 0));
+    ASSERT_EQ(std::nullopt, db.get_lease(0));
+    ASSERT_EQ(0, db.active_leases());
+}
+
+TEST(lease_db, get_new_lease) {
+    lease_db<2> db;
+
+    ASSERT_EQ(std::optional(0), db.new_lease(10, 0));
+    ASSERT_EQ(std::optional(1), db.new_lease(20, 0));
+    ASSERT_EQ(std::nullopt, db.new_lease(30, 0));  // exhausted
+
+    ASSERT_EQ(std::optional(0), db.get_lease(10));
+    ASSERT_EQ(std::optional(1), db.get_lease(20));
+    ASSERT_EQ(std::nullopt, db.get_lease(30));  // exhausted
+
+    ASSERT_EQ(2, db.active_leases());
+}
+
+TEST(lease_db, get_new_lease_twice) {
+    lease_db<2> db;
+
+    ASSERT_EQ(std::optional(0), db.new_lease(10, 0));
+    ASSERT_EQ(std::nullopt, db.new_lease(10, 0));
+
+    ASSERT_EQ(1, db.active_leases());
+}
+
+TEST(lease_db, flush_expired) {
+    lease_db<2> db;
+
+    ASSERT_EQ(std::optional(0), db.new_lease(10, 100 /* lease end */));
+    ASSERT_EQ(std::optional(1), db.new_lease(20, 200 /* lease end */));
+
+    db.flush_expired(50 /* current time */);
+    ASSERT_EQ(2, db.active_leases());
+    ASSERT_EQ(std::optional(0), db.get_lease(10));
+    ASSERT_EQ(std::optional(1), db.get_lease(20));
+
+    db.flush_expired(150 /* current time */);
+    ASSERT_EQ(1, db.active_leases());
+    ASSERT_EQ(std::nullopt, db.get_lease(10));
+    ASSERT_EQ(std::optional(1), db.get_lease(20));
+
+    db.flush_expired(250 /* current time */);
+    ASSERT_EQ(0, db.active_leases());
+    ASSERT_EQ(std::nullopt, db.get_lease(10));
+    ASSERT_EQ(std::nullopt, db.get_lease(20));
+}
+
+TEST(lease_db, update_lease) {
+    lease_db<2> db;
+
+    ASSERT_EQ(std::optional(0), db.new_lease(10, 100 /* lease end */));
+    ASSERT_EQ(std::optional(1), db.new_lease(20, 200 /* lease end */));
+
+    ASSERT_EQ(2, db.active_leases());
+
+    db.flush_expired(150 /* current time */);
+    ASSERT_EQ(1, db.active_leases());
+    ASSERT_EQ(std::nullopt, db.get_lease(10));
+    ASSERT_EQ(std::optional(1), db.get_lease(20));
+
+    ASSERT_EQ(false, db.update_lease(10, 300 /* lease end */));
+    ASSERT_EQ(true, db.update_lease(20, 300 /* lease end */));
+
+    db.flush_expired(250 /* current time */);
+    ASSERT_EQ(1, db.active_leases());
+    ASSERT_EQ(std::nullopt, db.get_lease(10));
+    ASSERT_EQ(std::optional(1), db.get_lease(20));
+
+    db.flush_expired(350 /* current time */);
+    ASSERT_EQ(0, db.active_leases());
+    ASSERT_EQ(std::nullopt, db.get_lease(10));
+    ASSERT_EQ(std::nullopt, db.get_lease(20));
+}