From 6fd54932c7dcf5cdbf52bb6432ad08c1458d9b0d Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 16:14:57 +0100
Subject: [PATCH 01/41] DHCP: Moved shared consts (between client and server)
 to dhcp4.hpp and client xid now based on micros_since_boot

---
 api/net/dhcp/dhcp4.hpp     | 160 ++++++++++++++++++++++++++++++++-----
 src/net/dhcp/dh4client.cpp | 128 +----------------------------
 2 files changed, 144 insertions(+), 144 deletions(-)

diff --git a/api/net/dhcp/dhcp4.hpp b/api/net/dhcp/dhcp4.hpp
index d4751d8ee0..6b1b3e631a 100644
--- a/api/net/dhcp/dhcp4.hpp
+++ b/api/net/dhcp/dhcp4.hpp
@@ -6,34 +6,34 @@
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
-// 
+//
 //     http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <net/ip4/udp.hpp>
-
 #ifndef NET_DHCP_DHCP4_HPP
 #define NET_DHCP_DHCP4_HPP
 
-#define DHCP_VEND_LEN         304
-#define BOOTP_MIN_LEN       300
-#define DHCP_MIN_LEN        548
-// some clients silently ignore responses less than 300 bytes
-#define DEFAULT_PACKET_SIZE 300
+#include <net/ip4/udp.hpp>
+
+namespace net {
+
+  static const int DHCP_VEND_LEN =        304;
+  static const int BOOTP_MIN_LEN =        300;
+  static const int DHCP_MIN_LEN =         548;
+  // some clients silently ignore responses less than 300 bytes
+  static const int DEFAULT_PACKET_SIZE =  300;
 
-namespace net
-{
   struct dhcp_packet_t
   {
-    static const int CHADDR_LEN =  16;
-    static const int SNAME_LEN  =  64;
-    static const int FILE_LEN   = 128;
-    
+    static const uint8_t CHADDR_LEN =  16;
+    static const uint8_t SNAME_LEN  =  64;
+    static const uint8_t FILE_LEN   = 128;
+
     uint8_t  op;        // message opcode
     uint8_t  htype;     // hardware addr type
     uint8_t  hlen;      // hardware addr length
@@ -51,14 +51,138 @@ namespace net
     uint8_t  magic[4];            // option_format aka magic
     uint8_t  options[DHCP_VEND_LEN];
   };
-  
+
   struct dhcp_option_t
   {
     uint8_t code;
     uint8_t length;
     uint8_t val[0];
   };
-  
-}
+
+  // BOOTP (rfc951) message types
+  static const uint8_t BOOTREQUEST =  1;
+  static const uint8_t BOOTREPLY =    2;
+
+  // Possible values for flags field
+  static const uint32_t BOOTP_UNICAST =   0x0000;
+  static const uint32_t BOOTP_BROADCAST = 0x8000;
+
+  // Possible values for hardware type (htype) field
+  static const uint8_t HTYPE_ETHER =    1;  // Ethernet 10Mbps
+  static const uint8_t HTYPE_IEEE802 =  6;  // IEEE 802.2 Token Ring
+  static const uint8_t HTYPE_FDDI =     8;  // FDDI
+
+  /* Magic cookie validating dhcp options field (and bootp vendor
+     extensions field). */
+  static const std::string DHCP_OPTIONS_COOKIE = "\143\202\123\143";
+
+  // DHCP Option codes
+  static const uint8_t DHO_PAD =                          0;
+  static const uint8_t DHO_SUBNET_MASK =                  1;
+  static const uint8_t DHO_TIME_OFFSET =                  2;
+  static const uint8_t DHO_ROUTERS =                      3;
+  static const uint8_t DHO_TIME_SERVERS =                 4;
+  static const uint8_t DHO_NAME_SERVERS =                 5;
+  static const uint8_t DHO_DOMAIN_NAME_SERVERS =          6;
+  static const uint8_t DHO_LOG_SERVERS =                  7;
+  static const uint8_t DHO_COOKIE_SERVERS =               8;
+  static const uint8_t DHO_LPR_SERVERS =                  9;
+  static const uint8_t DHO_IMPRESS_SERVERS =              10;
+  static const uint8_t DHO_RESOURCE_LOCATION_SERVERS =    11;
+  static const uint8_t DHO_HOST_NAME =                    12;
+  static const uint8_t DHO_BOOT_SIZE =                    13;
+  static const uint8_t DHO_MERIT_DUMP =                   14;
+  static const uint8_t DHO_DOMAIN_NAME =                  15;
+  static const uint8_t DHO_SWAP_SERVER =                  16;
+  static const uint8_t DHO_ROOT_PATH =                    17;
+  static const uint8_t DHO_EXTENSIONS_PATH =              18;
+  static const uint8_t DHO_IP_FORWARDING =                19;
+  static const uint8_t DHO_NON_LOCAL_SOURCE_ROUTING =     20;
+  static const uint8_t DHO_POLICY_FILTER =                21;
+  static const uint8_t DHO_MAX_DGRAM_REASSEMBLY =         22;
+  static const uint8_t DHO_DEFAULT_IP_TTL =               23;
+  static const uint8_t DHO_PATH_MTU_AGING_TIMEOUT =       24;
+  static const uint8_t DHO_PATH_MTU_PLATEAU_TABLE =       25;
+  static const uint8_t DHO_INTERFACE_MTU =                26;
+  static const uint8_t DHO_ALL_SUBNETS_LOCAL =            27;
+  static const uint8_t DHO_BROADCAST_ADDRESS =            28;
+  static const uint8_t DHO_PERFORM_MASK_DISCOVERY =       29;
+  static const uint8_t DHO_MASK_SUPPLIER =                30;
+  static const uint8_t DHO_ROUTER_DISCOVERY =             31;
+  static const uint8_t DHO_ROUTER_SOLICITATION_ADDRESS =  32;
+  static const uint8_t DHO_STATIC_ROUTES =                33;
+  static const uint8_t DHO_TRAILER_ENCAPSULATION =        34;
+  static const uint8_t DHO_ARP_CACHE_TIMEOUT =            35;
+  static const uint8_t DHO_IEEE802_3_ENCAPSULATION =      36;
+  static const uint8_t DHO_DEFAULT_TCP_TTL =              37;
+  static const uint8_t DHO_TCP_KEEPALIVE_INTERVAL =       38;
+  static const uint8_t DHO_TCP_KEEPALIVE_GARBAGE =        39;
+  static const uint8_t DHO_NIS_DOMAIN =                   40;
+  static const uint8_t DHO_NIS_SERVERS =                  41;
+  static const uint8_t DHO_NTP_SERVERS =                  42;
+  static const uint8_t DHO_VENDOR_ENCAPSULATED_OPTIONS =  43;
+  static const uint8_t DHO_NETBIOS_NAME_SERVERS =         44;
+  static const uint8_t DHO_NETBIOS_DD_SERVER =            45;
+  static const uint8_t DHO_NETBIOS_NODE_TYPE =            46;
+  static const uint8_t DHO_NETBIOS_SCOPE =                47;
+  static const uint8_t DHO_FONT_SERVERS =                 48;
+  static const uint8_t DHO_X_DISPLAY_MANAGER =            49;
+  static const uint8_t DHO_DHCP_REQUESTED_ADDRESS =       50;
+  static const uint8_t DHO_DHCP_LEASE_TIME =              51;
+  static const uint8_t DHO_DHCP_OPTION_OVERLOAD =         52;
+  static const uint8_t DHO_DHCP_MESSAGE_TYPE =            53;
+  static const uint8_t DHO_DHCP_SERVER_IDENTIFIER =       54;
+  static const uint8_t DHO_DHCP_PARAMETER_REQUEST_LIST =  55;
+  static const uint8_t DHO_DHCP_MESSAGE =                 56;
+  static const uint8_t DHO_DHCP_MAX_MESSAGE_SIZE =        57;
+  static const uint8_t DHO_DHCP_RENEWAL_TIME =            58;
+  static const uint8_t DHO_DHCP_REBINDING_TIME =          59;
+  static const uint8_t DHO_VENDOR_CLASS_IDENTIFIER =      60;
+  static const uint8_t DHO_DHCP_CLIENT_IDENTIFIER =       61;
+  static const uint8_t DHO_NWIP_DOMAIN_NAME =             62;
+  static const uint8_t DHO_NWIP_SUBOPTIONS =              63;
+  static const uint8_t DHO_USER_CLASS =                   77;
+  static const uint8_t DHO_FQDN =                         81;
+  static const uint8_t DHO_DHCP_AGENT_OPTIONS =           82;
+  static const uint8_t DHO_SUBNET_SELECTION =             118;  // RFC3011
+  /* The DHO_AUTHENTICATE option is not a standard yet, so I've
+     allocated an option out of the "local" option space for it on a
+     temporary basis.  Once an option code number is assigned, I will
+     immediately and shamelessly break this, so don't count on it
+     continuing to work. */
+  static const uint8_t DHO_AUTHENTICATE = 210;
+  static const uint8_t DHO_END =          255;
+
+  // DHCP message types
+  static const uint8_t DHCPDISCOVER = 1;
+  static const uint8_t DHCPOFFER =    2;
+  static const uint8_t DHCPREQUEST =  3;
+  static const uint8_t DHCPDECLINE =  4;
+  static const uint8_t DHCPACK =      5;
+  static const uint8_t DHCPNAK =      6;
+  static const uint8_t DHCPRELEASE =  7;
+  static const uint8_t DHCPINFORM =   8;
+
+  // Relay Agent Information option subtypes
+  static const uint8_t RAI_CIRCUIT_ID = 1;
+  static const uint8_t RAI_REMOTE_ID =  2;
+  static const uint8_t RAI_AGENT_ID =   3;
+
+  // FQDN suboptions
+  static const uint8_t FQDN_NO_CLIENT_UPDATE =  1;
+  static const uint8_t FQDN_SERVER_UPDATE =     2;
+  static const uint8_t FQDN_ENCODED =           3;
+  static const uint8_t FQDN_RCODE1 =            4;
+  static const uint8_t FQDN_RCODE2 =            5;
+  static const uint8_t FQDN_HOSTNAME =          6;
+  static const uint8_t FQDN_DOMAINNAME =        7;
+  static const uint8_t FQDN_FQDN =              8;
+  static const uint8_t FQDN_SUBOPTION_COUNT =   8;
+
+  static const uint8_t ETH_ALEN =         6;  // octets in one ethernet header
+  static const uint8_t DHCP_DEST_PORT =   67;
+  static const uint8_t DHCP_SOURCE_PORT = 68;
+
+} // < namespace net
 
 #endif
diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index 77162a7531..fccf65649d 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -21,133 +21,9 @@
 
 #include <net/dhcp/dh4client.hpp>
 #include <net/dhcp/dhcp4.hpp>
-#include <rtc> // RTC::time_since_boot()
+#include <os> // OS::micros_since_boot()
 #include <debug>
 
-// BOOTP (rfc951) message types
-#define BOOTREQUEST 1
-#define BOOTREPLY   2
-
-// Possible values for flags field
-#define BOOTP_UNICAST   0x0000
-#define BOOTP_BROADCAST 0x8000
-
-// Possible values for hardware type (htype) field
-#define HTYPE_ETHER     1  // Ethernet 10Mbps
-#define HTYPE_IEEE802   6  // IEEE 802.2 Token Ring
-#define HTYPE_FDDI      8  // FDDI
-
-/* Magic cookie validating dhcp options field (and bootp vendor
-   extensions field). */
-#define DHCP_OPTIONS_COOKIE "\143\202\123\143"
-
-// DHCP Option codes
-#define DHO_PAD                  0
-#define DHO_SUBNET_MASK          1
-#define DHO_TIME_OFFSET          2
-#define DHO_ROUTERS              3
-#define DHO_TIME_SERVERS         4
-#define DHO_NAME_SERVERS         5
-#define DHO_DOMAIN_NAME_SERVERS  6
-#define DHO_LOG_SERVERS          7
-#define DHO_COOKIE_SERVERS       8
-#define DHO_LPR_SERVERS          9
-#define DHO_IMPRESS_SERVERS     10
-#define DHO_RESOURCE_LOCATION_SERVERS   11
-#define DHO_HOST_NAME           12
-#define DHO_BOOT_SIZE           13
-#define DHO_MERIT_DUMP          14
-#define DHO_DOMAIN_NAME         15
-#define DHO_SWAP_SERVER         16
-#define DHO_ROOT_PATH           17
-#define DHO_EXTENSIONS_PATH     18
-#define DHO_IP_FORWARDING       19
-#define DHO_NON_LOCAL_SOURCE_ROUTING 20
-#define DHO_POLICY_FILTER            21
-#define DHO_MAX_DGRAM_REASSEMBLY     22
-#define DHO_DEFAULT_IP_TTL           23
-#define DHO_PATH_MTU_AGING_TIMEOUT   24
-#define DHO_PATH_MTU_PLATEAU_TABLE   25
-#define DHO_INTERFACE_MTU            26
-#define DHO_ALL_SUBNETS_LOCAL        27
-#define DHO_BROADCAST_ADDRESS        28
-#define DHO_PERFORM_MASK_DISCOVERY   29
-#define DHO_MASK_SUPPLIER            30
-#define DHO_ROUTER_DISCOVERY         31
-#define DHO_ROUTER_SOLICITATION_ADDRESS 32
-#define DHO_STATIC_ROUTES           33
-#define DHO_TRAILER_ENCAPSULATION   34
-#define DHO_ARP_CACHE_TIMEOUT       35
-#define DHO_IEEE802_3_ENCAPSULATION 36
-#define DHO_DEFAULT_TCP_TTL         37
-#define DHO_TCP_KEEPALIVE_INTERVAL  38
-#define DHO_TCP_KEEPALIVE_GARBAGE   39
-#define DHO_NIS_DOMAIN              40
-#define DHO_NIS_SERVERS             41
-#define DHO_NTP_SERVERS             42
-#define DHO_VENDOR_ENCAPSULATED_OPTIONS 43
-#define DHO_NETBIOS_NAME_SERVERS    44
-#define DHO_NETBIOS_DD_SERVER       45
-#define DHO_NETBIOS_NODE_TYPE       46
-#define DHO_NETBIOS_SCOPE           47
-#define DHO_FONT_SERVERS            48
-#define DHO_X_DISPLAY_MANAGER       49
-#define DHO_DHCP_REQUESTED_ADDRESS  50
-#define DHO_DHCP_LEASE_TIME         51
-#define DHO_DHCP_OPTION_OVERLOAD    52
-#define DHO_DHCP_MESSAGE_TYPE       53
-#define DHO_DHCP_SERVER_IDENTIFIER  54
-#define DHO_DHCP_PARAMETER_REQUEST_LIST 55
-#define DHO_DHCP_MESSAGE            56
-#define DHO_DHCP_MAX_MESSAGE_SIZE   57
-#define DHO_DHCP_RENEWAL_TIME       58
-#define DHO_DHCP_REBINDING_TIME     59
-#define DHO_VENDOR_CLASS_IDENTIFIER 60
-#define DHO_DHCP_CLIENT_IDENTIFIER  61
-#define DHO_NWIP_DOMAIN_NAME        62
-#define DHO_NWIP_SUBOPTIONS         63
-#define DHO_USER_CLASS              77
-#define DHO_FQDN                    81
-#define DHO_DHCP_AGENT_OPTIONS      82
-#define DHO_SUBNET_SELECTION       118  // RFC3011
-/* The DHO_AUTHENTICATE option is not a standard yet, so I've
-   allocated an option out of the "local" option space for it on a
-   temporary basis.  Once an option code number is assigned, I will
-   immediately and shamelessly break this, so don't count on it
-   continuing to work. */
-#define DHO_AUTHENTICATE           210
-#define DHO_END                    255
-
-// DHCP message types
-#define DHCPDISCOVER 1
-#define DHCPOFFER    2
-#define DHCPREQUEST  3
-#define DHCPDECLINE  4
-#define DHCPACK      5
-#define DHCPNAK      6
-#define DHCPRELEASE  7
-#define DHCPINFORM   8
-
-// Relay Agent Information option subtypes
-#define RAI_CIRCUIT_ID  1
-#define RAI_REMOTE_ID   2
-#define RAI_AGENT_ID    3
-
-// FQDN suboptions
-#define FQDN_NO_CLIENT_UPDATE 1
-#define FQDN_SERVER_UPDATE    2
-#define FQDN_ENCODED          3
-#define FQDN_RCODE1           4
-#define FQDN_RCODE2           5
-#define FQDN_HOSTNAME         6
-#define FQDN_DOMAINNAME       7
-#define FQDN_FQDN             8
-#define FQDN_SUBOPTION_COUNT  8
-
-#define ETH_ALEN           6  // octets in one ethernet header
-#define DHCP_DEST_PORT    67
-#define DHCP_SOURCE_PORT  68
-
 namespace net
 {
   inline dhcp_option_t* conv_option(uint8_t* option)
@@ -196,7 +72,7 @@ namespace net
     });
 
     // create a random session ID
-    this->xid = RTC::time_since_boot() & 0xFFFFFFFF;
+    this->xid = OS::micros_since_boot() & 0xFFFFFFFF;
     if (console_spam)
       MYINFO("Negotiating IP-address (xid=%u)", xid);
 

From 41505391a1079b93531a240d88f305b4d502d225 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 16:20:21 +0100
Subject: [PATCH 02/41] DHCP integration tests: Separated into two folders ->
 One for client and one for server

---
 .../dhcp/{ => dhclient}/CMakeLists.txt        |  0
 .../integration/dhcp/{ => dhclient}/README.md |  0
 .../dhcp/{ => dhclient}/service.cpp           |  0
 .../integration/dhcp/{ => dhclient}/test.py   |  0
 .../integration/dhcp/{ => dhclient}/vm.json   |  0
 .../net/integration/dhcp/dhcpd/CMakeLists.txt | 33 +++++++++
 test/net/integration/dhcp/dhcpd/README.md     |  1 +
 test/net/integration/dhcp/dhcpd/service.cpp   | 69 +++++++++++++++++++
 test/net/integration/dhcp/dhcpd/test.py       | 43 ++++++++++++
 test/net/integration/dhcp/dhcpd/vm.json       |  9 +++
 10 files changed, 155 insertions(+)
 rename test/net/integration/dhcp/{ => dhclient}/CMakeLists.txt (100%)
 rename test/net/integration/dhcp/{ => dhclient}/README.md (100%)
 rename test/net/integration/dhcp/{ => dhclient}/service.cpp (100%)
 rename test/net/integration/dhcp/{ => dhclient}/test.py (100%)
 rename test/net/integration/dhcp/{ => dhclient}/vm.json (100%)
 create mode 100644 test/net/integration/dhcp/dhcpd/CMakeLists.txt
 create mode 100644 test/net/integration/dhcp/dhcpd/README.md
 create mode 100644 test/net/integration/dhcp/dhcpd/service.cpp
 create mode 100644 test/net/integration/dhcp/dhcpd/test.py
 create mode 100644 test/net/integration/dhcp/dhcpd/vm.json

diff --git a/test/net/integration/dhcp/CMakeLists.txt b/test/net/integration/dhcp/dhclient/CMakeLists.txt
similarity index 100%
rename from test/net/integration/dhcp/CMakeLists.txt
rename to test/net/integration/dhcp/dhclient/CMakeLists.txt
diff --git a/test/net/integration/dhcp/README.md b/test/net/integration/dhcp/dhclient/README.md
similarity index 100%
rename from test/net/integration/dhcp/README.md
rename to test/net/integration/dhcp/dhclient/README.md
diff --git a/test/net/integration/dhcp/service.cpp b/test/net/integration/dhcp/dhclient/service.cpp
similarity index 100%
rename from test/net/integration/dhcp/service.cpp
rename to test/net/integration/dhcp/dhclient/service.cpp
diff --git a/test/net/integration/dhcp/test.py b/test/net/integration/dhcp/dhclient/test.py
similarity index 100%
rename from test/net/integration/dhcp/test.py
rename to test/net/integration/dhcp/dhclient/test.py
diff --git a/test/net/integration/dhcp/vm.json b/test/net/integration/dhcp/dhclient/vm.json
similarity index 100%
rename from test/net/integration/dhcp/vm.json
rename to test/net/integration/dhcp/dhclient/vm.json
diff --git a/test/net/integration/dhcp/dhcpd/CMakeLists.txt b/test/net/integration/dhcp/dhcpd/CMakeLists.txt
new file mode 100644
index 0000000000..0f96526bd0
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd/CMakeLists.txt
@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 2.8.9)
+
+# IncludeOS install location
+if (NOT DEFINED ENV{INCLUDEOS_PREFIX})
+  set(ENV{INCLUDEOS_PREFIX} /usr/local)
+endif()
+
+set(CMAKE_TOOLCHAIN_FILE $ENV{INCLUDEOS_PREFIX}/includeos/i686-elf-toolchain.cmake)
+
+project(test_dhcp_server)
+
+# Human-readable name of your service
+set(SERVICE_NAME "IncludeOS DHCP server test")
+
+# Name of your service binary
+set(BINARY       "test_dhcp_server")
+
+# Maximum memory can be hard-coded into the binary
+set(MAX_MEM 128)
+
+# Source files to be linked with OS library parts to form bootable image
+set(SOURCES
+    service.cpp
+  )
+
+# DRIVERS / PLUGINS:
+
+set(DRIVERS
+  virtionet
+  )
+
+# include service build script
+include($ENV{INCLUDEOS_PREFIX}/includeos/service.cmake)
diff --git a/test/net/integration/dhcp/dhcpd/README.md b/test/net/integration/dhcp/dhcpd/README.md
new file mode 100644
index 0000000000..7f57648461
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd/README.md
@@ -0,0 +1 @@
+# Test DHCP server
diff --git a/test/net/integration/dhcp/dhcpd/service.cpp b/test/net/integration/dhcp/dhcpd/service.cpp
new file mode 100644
index 0000000000..6e3aa2efc5
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd/service.cpp
@@ -0,0 +1,69 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <service>
+#include <net/inet4>
+#include <net/dhcp/dhcpd.hpp>
+
+#include <timers>
+
+std::unique_ptr<net::dhcp::DHCPD> server;
+
+void Service::start(const std::string&)
+{
+  using namespace net;
+  using namespace dhcp;
+
+  // Server
+
+  auto& inet = Inet4::ifconfig<0>(
+    { 10,0,100,1 },     // IP
+    { 255,255,0,0 },    // Netmask
+    { 10,0,0,1 },       // Gateway
+    { 10,0,0,1 });      // DNS
+
+  IP4::addr pool_start{10,0,100,13};
+  IP4::addr pool_end{10,0,100,20};
+  server = std::make_unique<DHCPD>(inet.udp(), pool_start, pool_end);
+
+  // Client 1
+
+  auto& inet1 = Inet4::ifconfig<1>(10.0, [&] (bool timeout) {
+    if (timeout)
+      printf("Interface 1 timed out\n");
+    else
+      printf("Interface 1 succeed\n");
+  });
+
+  // Client 2
+
+  auto& inet2 = Inet4::ifconfig<2>(10.0, [&] (bool timeout) {
+    if (timeout)
+      printf("Interface 2 timed out\n");
+    else
+      printf("Interface 2 succeed\n");
+  });
+
+  // Client 3
+
+  auto& inet3 = Inet4::ifconfig<3>(10.0, [&] (bool timeout) {
+    if (timeout)
+      printf("Interface 3 timed out\n");
+    else
+      printf("Interface 3 succeed\n");
+  });
+}
diff --git a/test/net/integration/dhcp/dhcpd/test.py b/test/net/integration/dhcp/dhcpd/test.py
new file mode 100644
index 0000000000..0f7865e6c5
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd/test.py
@@ -0,0 +1,43 @@
+#! /usr/bin/env python
+
+import sys
+import os
+import time
+import subprocess
+
+includeos_src = os.environ.get('INCLUDEOS_SRC',
+                               os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))).split('/test')[0])
+sys.path.insert(0,includeos_src)
+
+from vmrunner import vmrunner
+import socket
+
+from vmrunner.prettify import color
+
+# Get an auto-created VM from the vmrunner
+vm = vmrunner.vms[0]
+
+ping_count = 3
+
+def DHCP_test(trigger_line):
+  print color.INFO("<Test.py>"),"Got IP"
+  ip_string = vm.readline()
+  print color.INFO("<Test.py>"), "Assigned address: ", ip_string
+  print color.INFO("<Test.py>"), "Trying to ping"
+  time.sleep(1)
+  try:
+    command = ["ping", ip_string.rstrip(), "-c", str(ping_count), "-i", "0.2"]
+    print color.DATA(" ".join(command))
+    print subprocess.check_output(command)
+    vm.exit(0,"<Test.py> Ping test passed. Process returned 0 exit status")
+  except Exception as e:
+    print color.FAIL("<Test.py> Ping FAILED Process threw exception:")
+    print e
+    return False
+
+
+# Add custom event-handler
+vm.on_output("Got IP from DHCP", DHCP_test)
+
+# Boot the VM, taking a timeout as parameter
+vm.cmake().boot(20).clean()
diff --git a/test/net/integration/dhcp/dhcpd/vm.json b/test/net/integration/dhcp/dhcpd/vm.json
new file mode 100644
index 0000000000..2779808849
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd/vm.json
@@ -0,0 +1,9 @@
+{
+  "image" : "test_dhcp_server.img",
+  "net" : [{"device" : "virtio", "mac" : "c0:01:0a:00:00:2a"},
+          {"device" : "virtio", "mac" : "c0:01:0a:00:00:2f"},
+          {"device" : "virtio", "mac" : "c0:01:0a:00:00:20"},
+          {"device" : "virtio", "mac" : "c0:01:0a:00:00:23"}],
+  "cpu" : "host",
+  "mem" : 128
+}

From fb7f187efcf931bc028ca0e2f4033fe4b0902853 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 17:54:57 +0100
Subject: [PATCH 03/41] IP4 addr: Added method for getting the different parts
 of the address

---
 api/net/ip4/addr.hpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/api/net/ip4/addr.hpp b/api/net/ip4/addr.hpp
index d1a858cf34..887ada56d6 100644
--- a/api/net/ip4/addr.hpp
+++ b/api/net/ip4/addr.hpp
@@ -21,6 +21,7 @@
 #include <regex>
 #include <string>
 #include <net/util.hpp> // byte order
+#include <gsl/gsl_assert>
 
 namespace net {
 namespace ip4 {
@@ -115,6 +116,16 @@ struct Addr {
   Addr operator ~ () const noexcept
   { return Addr(~whole); }
 
+  uint8_t part(uint8_t i) const noexcept {
+    Expects(i < 4);
+
+    union addr {
+      uint8_t parts[4];
+      uint32_t whole;
+    };
+
+    return ((addr&) whole).parts[3 - i];
+  }
 
   /** x.x.x.x string representation */
   std::string str() const {

From 112e3cc58b2dc6f662abcebf1dfb5371db6c7b74 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 17:57:47 +0100
Subject: [PATCH 04/41] DHCP Record: Added class for storing IP allocations
 (moving dhcp server into IncludeOS)

---
 api/net/dhcp/record.hpp | 113 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 api/net/dhcp/record.hpp

diff --git a/api/net/dhcp/record.hpp b/api/net/dhcp/record.hpp
new file mode 100644
index 0000000000..4fc5a45341
--- /dev/null
+++ b/api/net/dhcp/record.hpp
@@ -0,0 +1,113 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#ifndef NET_DHCP_RECORD_HPP
+#define NET_DHCP_RECORD_HPP
+
+namespace net {
+namespace dhcp {
+
+  enum class Status {
+    AVAILABLE,
+    OFFERED,    // IP has been offered to another client and is awaiting a DHCPREQUEST for updated status
+    RELEASED,   // Previously allocated IP to a client (reuse)
+    IN_USE
+  };
+
+  // Temp - Instead of database (persistent storage):
+
+  class Record {
+
+  public:
+    // TODO Remove or use?
+    using byte_seq = std::vector<uint8_t>;
+
+    Record() {}
+
+    Record(const byte_seq& client_id, const IP4::addr& ip, Status status, int64_t lease_start, uint32_t lease_duration)
+    : client_id_{client_id}, ip_{ip}, status_{status}, lease_start_{lease_start}, lease_duration_{lease_duration} {}
+
+    // Getters
+
+    const byte_seq& client_id() const
+    { return client_id_; }
+
+    const IP4::addr& ip() const
+    { return ip_; }
+
+    const Status& status() const
+    { return status_; }
+
+    uint32_t lease_start() const
+    { return lease_start_; }
+
+    uint32_t lease_duration() const
+    { return lease_duration_; }
+
+    // Setters
+
+    void set_client_id(const byte_seq& client_id)
+    { client_id_ = client_id; }
+
+    void set_ip(const IP4::addr ip)
+    { ip_ = ip; }
+
+    void set_status(Status status)
+    { status_ = status; }
+
+    /*void set_lease_start(uint32_t lease_start)
+    { lease_start_ = lease_start; }*/
+    void set_lease_start(int64_t lease_start)
+    { lease_start_ = lease_start; }
+
+    void set_lease_duration(uint32_t lease_duration)
+    { lease_duration_ = lease_duration; }
+
+  private:
+    byte_seq client_id_;
+    IP4::addr ip_;
+
+    // Because of reuse (client gets its previous IP) ?
+    Status status_;
+
+    //std::vector<Option> options_;
+
+
+    // TODO Save client's config parameters as well?
+
+    // TODO
+    // T1 and T2
+    // Client T1: The time at which the client enters the RENEWING state and attempts to contact the server that originally issued the
+    // client's network address.
+    // Client T2: The time at which the client enters the REBINDING state and attempts to contact any server.
+    // T1 MUST be earlier than T2, which, in turn, MUST be earlier than the time at which the client's lease will expire.
+    // T1 defaults to (0.5 * duration_of_lease)
+    // T2 defaults to (0.875 * duration_of_lease)
+    // T1 and T2 should be chosen with some random fuzz around a fixed value, to avoid synchronization of client reacquisition
+    // A client MAY choose to renew or extend its lease prior to T1. The server MAY choose to extend the client's lease according to
+    // policy set by the network administrator. The server SHOULD return T1 and T2, and their values SHOULD be adjusted from their
+    // original values to take account of the time remaining on the lease
+    //uint32_t lease_start_;
+    int64_t lease_start_;           // For now: RTC::now()
+    uint32_t lease_duration_;
+  };
+
+} // < namespace dhcp
+} // < namespace net
+
+#endif

From 46d3039389f3a331f64a023e249243a1d61f027d Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 18:00:39 +0100
Subject: [PATCH 05/41] DHCP server: hpp-file added (moving DHCP server into
 IncludeOS)

---
 api/net/dhcp/dhcp4.hpp |  22 +++---
 api/net/dhcp/dhcpd.hpp | 174 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 185 insertions(+), 11 deletions(-)
 create mode 100644 api/net/dhcp/dhcpd.hpp

diff --git a/api/net/dhcp/dhcp4.hpp b/api/net/dhcp/dhcp4.hpp
index 6b1b3e631a..80e23ff21c 100644
--- a/api/net/dhcp/dhcp4.hpp
+++ b/api/net/dhcp/dhcp4.hpp
@@ -34,17 +34,17 @@ namespace net {
     static const uint8_t SNAME_LEN  =  64;
     static const uint8_t FILE_LEN   = 128;
 
-    uint8_t  op;        // message opcode
-    uint8_t  htype;     // hardware addr type
-    uint8_t  hlen;      // hardware addr length
-    uint8_t  hops;      // relay agent hops from client
-    uint32_t xid;       // transaction ID
-    uint16_t secs;      // seconds since start
-    uint16_t flags;     // flag bits
-    IP4::addr ciaddr;    // client IP address
-    IP4::addr yiaddr;    // client IP address
-    IP4::addr siaddr;    // IP address of next server
-    IP4::addr giaddr;    // DHCP relay agent IP address
+    uint8_t  op;          // message opcode
+    uint8_t  htype;       // hardware addr type
+    uint8_t  hlen;        // hardware addr length
+    uint8_t  hops;        // relay agent hops from client
+    uint32_t xid;         // transaction ID
+    uint16_t secs;        // seconds since start
+    uint16_t flags;       // flag bits
+    IP4::addr ciaddr;     // client IP address
+    IP4::addr yiaddr;     // client IP address
+    IP4::addr siaddr;     // IP address of next server
+    IP4::addr giaddr;     // DHCP relay agent IP address
     uint8_t  chaddr[CHADDR_LEN];  // client hardware address
     uint8_t  sname[SNAME_LEN];    // server name
     uint8_t  file[FILE_LEN];      // BOOT filename
diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
new file mode 100644
index 0000000000..760ef41961
--- /dev/null
+++ b/api/net/dhcp/dhcpd.hpp
@@ -0,0 +1,174 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#ifndef NET_DHCP_DHCPD_HPP
+#define NET_DHCP_DHCPD_HPP
+
+#include <net/dhcp/dhcp4.hpp>
+#include <net/dhcp/record.hpp>  // Status and Record
+#include <net/ip4/udp.hpp>
+#include <map>
+
+namespace net {
+namespace dhcp {
+
+  class DHCP_exception : public std::runtime_error {
+    using runtime_error::runtime_error;
+  };
+
+  class DHCPD {
+    static const uint32_t DEFAULT_LEASE = 86400;      // seconds. 1 day = 86 400 seconds.
+    static const uint32_t DEFAULT_MAX_LEASE = 345600; // seconds. 4 days = 345 600 seconds.
+    static const uint8_t  DEFAULT_PENDING = 30;
+
+  public:
+    DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
+      uint32_t lease = DEFAULT_LEASE, uint32_t max_lease = DEFAULT_MAX_LEASE, uint8_t pending = DEFAULT_PENDING);
+
+    // Getters
+
+    IP4::addr server_id() const
+    { return server_id_; }
+
+    // TODO
+    IP4::addr temp_siaddr() const
+    { return temp_siaddr_; }
+
+    IP4::addr netmask() const
+    { return netmask_; }
+
+    IP4::addr router() const
+    { return router_; }
+
+    IP4::addr dns() const
+    { return dns_; }
+
+    uint32_t lease() const
+    { return lease_; }
+
+    uint32_t max_lease() const
+    { return max_lease_; }
+
+    uint8_t pending() const
+    { return pending_; }
+
+    IP4::addr pool_start() const
+    { return pool_start_; }
+
+    IP4::addr pool_end() const
+    { return pool_end_; }
+
+    const std::map<IP4::addr, Status>& pool() const
+    { return pool_; }
+
+    const std::vector<Record>& records() const
+    { return records_; }
+
+    // Setters
+
+    void set_server_id(IP4::addr server_id)
+    { server_id_ = server_id; }
+
+    // TODO
+    void set_temp_siaddr(IP4::addr temp_siaddr)
+    { temp_siaddr_ = temp_siaddr; }
+
+    void set_netmask(IP4::addr netmask)
+    { netmask_ = netmask; }
+
+    void set_router(IP4::addr router)
+    { router_ = router; }
+
+    void set_dns(IP4::addr dns)
+    { dns_ = dns; }
+
+    void set_lease(uint32_t lease)
+    { lease_ = lease; }
+
+    void set_max_lease(uint32_t max_lease)
+    { max_lease_ = max_lease; }
+
+    void set_pending(uint8_t pending)
+    { pending_ = pending; }
+
+    void add_record(const Record& record)
+    { records_.push_back(record); }
+
+    bool record_exists(const Record::byte_seq& client_id) const;
+
+    int get_record_idx(const Record::byte_seq& client_id) const;
+
+    int get_record_idx_from_ip(IP4::addr ip) const;
+
+    IP4::addr broadcast_address() const noexcept
+    { return server_id_ | ( ~ netmask_); }
+
+    IP4::addr network_address(IP4::addr ip) const noexcept  // x.x.x.0
+    { return ip & netmask_; }
+
+  private:
+
+    /* A DHCP server can have many Scopes
+        Each with its own pool, name, subnet mask (determines the subnet for a specific IP address),
+        lease duration values, options for assignment to clients like DNS, Gateway (router IP address) +
+    */
+
+    UDP::Stack& stack_;
+    UDPSocket& socket_;
+    IP4::addr pool_start_, pool_end_;
+    std::map<IP4::addr, Status> pool_;
+
+    IP4::addr server_id_;
+    IP4::addr temp_siaddr_;         // TODO Remove? IP address of next bootstrap server
+    IP4::addr netmask_, router_, dns_;
+    uint32_t lease_;
+    uint32_t max_lease_;
+    uint8_t pending_;               // How long to consider an offered address in the pending state (seconds)
+    std::vector<Record> records_;   // Temp - Instead of persistent storage:
+
+    bool valid_pool(IP4::addr start, IP4::addr end) const;
+    void init_pool();
+    void update_pool(IP4::addr ip, Status new_status);
+
+    void listen();
+
+    void resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+    void handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+    void offer(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+    void inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+    void request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4::addr send_to = IP4::addr{0});
+    void nak(const dhcp_packet_t* msg/*, const dhcp_option_t* opts*/);
+
+    const dhcp_option_t* get_option(const dhcp_option_t* opts, int code) const;
+    Record::byte_seq get_client_id_in_opts(const dhcp_option_t* opts) const;
+    IP4::addr get_requested_ip_in_opts(const dhcp_option_t* opts) const;
+    IP4::addr get_remote_netmask(const dhcp_option_t* opts) const;
+    void add_server_id(dhcp_option_t* opts);
+    IP4::addr inc_addr(IP4::addr ip) const
+    { return IP4::addr{htonl(ntohl(ip.whole) + 1)}; }
+    bool on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) const;
+    IP4::addr get_send_to_address(const dhcp_packet_t* msg, const uint8_t reply_type) const;
+
+    // Remove
+    void print(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+  };
+
+} // < namespace dhcp
+} // < namespace net
+
+#endif

From 3c35dd654f840a9ea1e39e17c2909efc625b7cc8 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 19:17:24 +0100
Subject: [PATCH 06/41] DHCP server: Update api

---
 api/net/dhcp/dhcpd.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 760ef41961..c8a3a2c066 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -149,6 +149,7 @@ namespace dhcp {
 
     void resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+    void verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void offer(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4::addr send_to = IP4::addr{0});

From c093162d81b3f65e395405363976a687e66f3be3 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 19:18:18 +0100
Subject: [PATCH 07/41] DHCP server: Added cpp-file (moving DHCP server into
 IncludeOS)

---
 src/net/dhcp/dhcpd.cpp | 1020 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1020 insertions(+)
 create mode 100644 src/net/dhcp/dhcpd.cpp

diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
new file mode 100644
index 0000000000..3176d98aac
--- /dev/null
+++ b/src/net/dhcp/dhcpd.cpp
@@ -0,0 +1,1020 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <net/dhcp/dhcpd.hpp>
+#include <rtc>
+
+#include <os>
+
+using namespace net;
+using namespace dhcp;
+
+DHCPD::DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
+  uint32_t lease, uint32_t max_lease, uint8_t pending)
+: stack_{udp.stack()},
+  socket_{udp.bind(DHCP_DEST_PORT)},
+  pool_start_{pool_start},
+  pool_end_{pool_end},
+  server_id_{stack_.ip_addr()},
+
+  // TODO: Correct to set this server's IP address? - IP address of next server to use in bootstrap
+  temp_siaddr_{stack_.ip_addr()},
+
+  netmask_{stack_.netmask()},
+  router_{stack_.gateway()},
+  dns_{stack_.gateway()},
+  lease_{lease}, max_lease_{max_lease}, pending_{pending}
+{
+  if (not valid_pool(pool_start, pool_end))
+    throw DHCP_exception{"Invalid pool"};
+
+  init_pool();
+  listen();
+}
+
+bool DHCPD::record_exists(const Record::byte_seq& client_id) const {
+  for (auto& rec : records_)
+    if (rec.client_id() == client_id)
+      return true;
+
+  return false;
+}
+
+int DHCPD::get_record_idx(const Record::byte_seq& client_id) const {
+  for (size_t i = 0; i < records_.size(); i++)
+    if (records_.at(i).client_id() == client_id)
+      return i;
+
+  return -1;
+}
+
+int DHCPD::get_record_idx_from_ip(IP4::addr ip) const {
+  for (size_t i = 0; i < records_.size(); i++)
+    if (records_.at(i).ip() == ip)
+      return i;
+
+  return -1;
+}
+
+bool DHCPD::valid_pool(IP4::addr start, IP4::addr end) const {
+  if (start > end or start == end or inc_addr(start) == end)
+      return false;
+
+  // Check if start and end are on the same subnet
+  if (network_address(start) != network_address(end)
+    or network_address(start) != network_address(server_id_)
+    or network_address(end) != network_address(server_id_))
+    return false;
+
+  // IP address part 0 is the rightmost uint8_t
+  // IP address part 3 is the leftmost uint8_t
+  const uint8_t start3 = start.part(3);
+  const uint8_t start2 = start.part(2);
+  const uint8_t start0 = start.part(0);
+  const uint8_t end3 = end.part(3);
+  const uint8_t end2 = end.part(2);
+  const uint8_t end0 = end.part(0);
+
+  // 10.x.x.x addresses not valid
+  // 172.16.0.0 - 172.31.255.255 not valid
+  // 192.168.x.x addresses not valid
+
+  // TODO: 10.x.x.x addresses should be invalid
+  if (/* start3 == 10 or */(start3 == 192 and start2 == 168) or start0 < 1 or start0 > 254)
+    return false;
+
+  // TODO: 10.x.x.x addresses should be invalid
+  if (/* end3 == 10 or */(end3 == 192 and end2 == 168) or end0 < 1 or end0 > 254)
+    return false;
+
+  if ( (start3 == 172 and (start2 > 15 or start2 < 32)) or
+    (end3 == 172 and (end2 > 15 or end2 < 32)) )
+    return false;
+
+  return true;
+}
+
+void DHCPD::init_pool() {
+  IP4::addr start = pool_start_;
+  while (start < pool_end_ and network_address(start) == network_address(server_id_)) {
+    pool_.emplace(std::make_pair(start, Status::AVAILABLE));
+    start = inc_addr(start);
+  }
+  // Incl. pool_end_ IP:
+  pool_.emplace(std::make_pair(pool_end_, Status::AVAILABLE));
+}
+
+void DHCPD::update_pool(IP4::addr ip, Status new_status) {
+  auto it = pool_.find(ip);
+  if (it not_eq pool_.end())
+    it->second = new_status;
+}
+
+void DHCPD::listen() {
+  socket_.on_read([&] (IP4::addr, UDP::port_t port,
+    const char* data, size_t) {
+
+    if (port == DHCP_SOURCE_PORT) {
+      printf("Received data from DHCP client\n");
+
+      // Message
+      const dhcp_packet_t* msg = (dhcp_packet_t*) data;
+
+      // Options
+      const dhcp_option_t* opt = (dhcp_option_t*) msg->options;
+
+      // Find out what kind of DHCP message this is
+      resolve(msg, opt);
+    }
+  });
+}
+
+void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+  int ridx;
+
+  // TODO: If we have a record on this client already, reuse IP - but only relevant when get a REQUEST? (handle_request())
+
+  switch (opts->val[0]) {
+    case DHCPDISCOVER:
+      printf("\nDISCOVER\n");
+      offer(msg, opts);
+      break;
+    case DHCPREQUEST:
+      printf("\nREQUEST\n");
+      handle_request(msg, opts);
+      break;
+    case DHCPDECLINE:
+      printf("\nDECLINE\n");
+
+      // A client has discovered that the suggested network address is already in use.
+      // The server must mark the network address as not available and should notify the network admin
+      // of a possible configuration problem - TODO
+
+      ridx = get_record_idx(get_client_id_in_opts(opts));
+
+      // TODO
+      // Erase record if exists because client hasn't got a valid IP
+      if (ridx not_eq -1)
+        records_.erase(records_.begin() + ridx);
+      update_pool(get_requested_ip_in_opts(opts), Status::IN_USE);    // In use - possible config problem
+      break;
+    case DHCPRELEASE:
+      printf("\nRELEASE\n");
+
+      // Mark the network address as not allocated anymore
+      // Should retain a record of the client's initialization parameters for possible reuse
+      // in response to subsequent requests from the client
+
+      ridx = get_record_idx_from_ip(msg->ciaddr);
+
+      if (ridx not_eq -1)
+        records_.at(ridx).set_status(Status::RELEASED);       // Another Status? Status::RELEASED f.ex.
+      update_pool(msg->ciaddr, Status::RELEASED);             // TODO: What about reuse - is this IP available for other clients
+      break;
+    case DHCPINFORM:            // ? Not specified in RFC 1533
+      printf("\nINFORM\n");
+
+      // Send a DHCPACK directly to the address given in the ciaddr field of the DHCPINFORM message.
+      // Do not send a lease expiration time to the client and do not fill in yiaddr
+      inform_ack(msg, opts);
+      break;
+  }
+}
+
+void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+
+  // Client could be:
+  // 1. Requesting offered parameters from one server and implicitly declining offers from all others
+  // 2. Confirming correctness of previously allocated address after, e.g., system reboot
+  // 3. Extending the lease on a particular network address
+  // /
+  // 1. Client is responding to a DHCPOFFER message from a server
+  // 2. Client is verifying a previously allocated IP address
+  // 3. Client is extending the lease on a network address
+
+  // RFC 2131 PAGE 31 (pdf)
+
+  // CHECKING SERVER IDENTIFIER
+  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_SERVER_IDENTIFIER);
+  // Server identifier from client:
+  if (opt->code == DHO_DHCP_SERVER_IDENTIFIER) {
+    // Then this is a response to a DHCPOFFER message
+
+    IP4::addr sid{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
+    printf("Server identifier for chosen server: %s\n", sid.to_string().c_str());
+
+    if (sid not_eq server_id()) {
+      printf("The client has not chosen this server\n");
+
+      int ridx = get_record_idx(get_client_id_in_opts(opts));
+      if (ridx != -1) {
+        // Free up the IP address - the client has declined our offer
+        update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
+        records_.erase(records_.begin() + ridx);
+      }
+      return;
+    }
+
+    // SERVER IDENTIFIER == THIS SERVER'S ID
+
+    int ridx = get_record_idx(get_client_id_in_opts(opts));
+
+    if (ridx not_eq -1) {   // if record exists
+      auto& record = records_.at(ridx);
+      // if ciaddr is zero and requested IP address is filled in with the yiaddr value from the chosen DHCPOFFER
+      // Client state: SELECTING
+      if (msg->ciaddr == IP4::addr{0} and get_requested_ip_in_opts(opts) == record.ip()) {
+        // Then the DHCPREQUEST from the client is a selecting request
+        // Note: Servers may not receive a specific DHCPREQUEST from which they can decide whether or not the
+        // client has accepted the offer. ... Servers are free to reuse offered network addresses in response to
+        // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
+        // timeout mechanism to decide when to reuse an offered address.
+
+        // RECORD
+        record.set_status(Status::IN_USE);
+
+        // POOL
+        update_pool(record.ip(), Status::IN_USE);
+
+        // SEND DHCPACK
+        request_ack(msg, opts);
+        return;
+      }
+
+      // ELSE ciaddr is not zero or record's ip is not the same as the requested ip in the request
+      return; // TODO: nak() or silent return?
+    }
+
+    // Else a record with this client id doesn't exist
+    // TODO: Remain silent or send a DHCPNAK?
+    printf("Record does not exist - sending DHCPNAK\n");
+    nak(msg);
+    return;
+  }
+
+  // Else server identifier is not filled in and this is not a response to a DHCPOFFER message
+
+  // This is a request to verify or extend and existing lease
+
+  verify_or_extend_lease(msg, opts);
+
+  // 4.3.2
+
+  // CA. OK Selecting
+  // Server identifier filled in, ciaddr is zero, requested IP address is filled in with the yiaddr
+  // value from the chosen DHCPOFFER
+  // Note: Servers may not receive a specific DHCPREQUEST from which they can decide whether or not the
+  // client has accepted the offer. ... Servers are free to reuse offered network addresses in response to
+  // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
+  // timeout mechanism to decide when to reuse an offered address.
+
+  // CA. OK Init-reboot
+  // If server identifier is not filled in and requested IP address option is filled in with
+  // client's notion of its previously assigned address.
+  // ciaddr must be zero.
+  // The client is seeking to verify a previously allocated, cached configuration.
+  // Server should send a DHCPNAK message to the client if the requested IP address is incorrect or is
+  // on the wrong network.
+  // Determining whether the client is on the correct network: Examine the contents of giaddr + the
+  // requested IP address option + a database lookup. If the server detects that the client is on the wrong
+  // net (i.e., the result of applying the local subnet mask or remote subnet mask (if giaddr is not zero) to
+  // requested IP address option value doesn't match reality), then the server should send a DHCPNAK message
+  // to the client.
+  // If the network is correct: Server should check if the client's notion of its IP address is correct. If not,
+  // the server should send a DHCPNAK message to the client.
+  // If the server has no record of the client, it must remain silent and may output a warning to the network admin.
+  // If giaddr is 0x0 in the DHCPREQUEST message, the client is on the same subnet as the server. The server must
+  // broadcast the DHCPNAK message to the 0xffffffff broadcast address because teh client may not have a correct
+  // network address or subnet mask, and the client may not be answering ARP requests.
+  // If giaddr is set in the DHCPREQUEST, the client is on a different subnet. The server must set the broadcast bit
+  // in the DHCPNAK - the client may not have a correct network address or subnet mask, and the client may not be
+  // answering ARP requests.
+
+  // Renewing
+  // If server identifier and requested IP address option is not filled in
+  // and ciaddr is filled in with client's IP address
+  // Then the client is completely configured and is trying to extend its lease.
+  // This message will be unicast. Because giaddr is therefore not filled in, the server
+  // will trust the value in ciaddr and use it when replying to the client.
+
+  // Rebinding
+  // If server identifier and requested IP address option is not filled in
+  // and ciaddr is filled in with client's IP address
+  // Then the client is completely configured and is trying to extend its lease.
+  // This message must be broadcast to the 0xffffffff IP broadcast address.
+  // Server should check ciaddr for correctness before replying to the DHCPREQUEST.
+  // A server may extend a client's lease only if it has local administrative authority to do so.
+
+  // Create DHCPACK
+  // Any configuration parameters in the DHCPACK should not conflict with those in the earlier DHCPOFFER
+  // to which the client is responding
+
+  // See Table 3 and 4.3.2
+}
+
+void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+  int ridx = get_record_idx(get_client_id_in_opts(opts));
+
+  if (ridx == -1) {
+    // If the server has no record of this client, then it MUST remain silent and MAY
+    // output a warning to the network administrator.
+    return;
+  }
+
+  if (ridx not_eq -1 and msg->ciaddr == IP4::addr{0}) {
+
+    // Then the client is seeking to verify a previously allocated, cached configuration
+    // Client state: INIT-REBOOT
+
+    printf("Client is in init-reboot state\n");
+
+    // 1. Check if on correct network
+    // Server should send a DHCPNAK if the client is on the wrong network
+    // If the server detects that the client is on the wrong net (i.e., the result of applying
+    // the local subnet mask or remote subnet mask (if giaddr is not zero) to requested IP address value doesn't
+    // match reality), then the server should send a DHCPNAK message to the client.
+    if (not on_correct_network(msg->giaddr, opts)) {
+      printf("Client is on the wrong network\n");
+
+      // TODO: Update pool? Erase record?
+      update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
+      records_.erase(records_.begin() + ridx);
+      nak(msg);
+      return;
+    }
+
+    // 2. If is on correct network: Check if the client's notion of IP is correct
+    if (get_requested_ip_in_opts(opts) not_eq records_.at(ridx).ip()) {
+      // If not correct IP: DHCPNAK + update pool and remove record
+      update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
+      records_.erase(records_.begin() + ridx);
+      nak(msg);
+      return;
+    }
+
+    // TODO
+    // Else everything is OK and we want to verify the client's configuration
+    // Update pool and record too
+    auto& record = records_.at(ridx);
+    record.set_status(Status::IN_USE);
+    record.set_lease_start(RTC::now());
+    update_pool(record.ip(), Status::IN_USE);
+
+    // Send DHCPACK?
+    request_ack(msg, opts);
+
+    return;
+  }
+
+  if (get_requested_ip_in_opts(opts) == IP4::addr{0} and msg->ciaddr not_eq IP4::addr{0}) {
+
+    // Client is in RENEWING state
+    // The client is then completely configured and is trying to extend its lease.
+    // This message will be unicast, so no relay agents will be involved in its transmission.
+    // Because giaddr is therefore not filled in, the server will trust the value in ciaddr and
+    // use it when replying to the client.
+    // A client MAY choose to renew or extend its lease prior to T1. The server may choose not to extend
+    // the lease (as a policy decision by the network administrator), but should return a DHCPACK
+    // message regardless.
+
+    // Same if the client is in REBINDING state so check the giaddr (gateway IP address) to find out if message
+    // has been unicast to the server or not? If zero: Unicast. If non-zero: Not unicast ?
+    // REBINDING: The client is completely configured and is trying to extend its lease. This message MUST
+    // be broadcast to the 0xffffffff IP broadcast address. The server should check ciaddr for correctness
+    // before replying to the DHCPREQUEST
+
+    // TABLE 4 PAGE 33 IN RFC 2131 - Fields in client message from client in different state
+
+    // Record exists
+    // Extend the lease or not - should send a DHCPACK regardless
+    // Update record and pool?
+    auto& record = records_.at(ridx);
+    record.set_status(Status::IN_USE);
+    record.set_lease_start(RTC::now());
+    update_pool(record.ip(), Status::IN_USE);
+
+    if (msg->giaddr != IP4::addr{0})    // The message has been broadcasted to the gateway and the ack should be broadcasted
+                                        // The client is then in the REBINDING state
+      request_ack(msg, opts, IP4::ADDR_ANY);    // broadcast_address()  // RFC: 0xffffffff
+    else    // Set send_to IP because we know that we want to send to ciaddr (unicast)
+            // The client is then in the RENEWING state
+      request_ack(msg, opts, msg->ciaddr);
+  }
+}
+
+void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+
+  // Validate any values here?
+  /* Magic cookie: First four octets of the options field
+  int first = msg->magic[0];
+  int second = msg->magic[1];
+  int third = msg->magic[2];
+  int fourth = msg->magic[3];
+  printf("\nMagic cookie: %d %d %d %d\n", first, second, third, fourth);*/
+
+  // Create DHCPOFFER reply
+
+  // 4.3.1 and Table 3 in RFC 2131
+  // Choose a network address
+  // Choose an expiration time for the lease
+  // +
+
+  const size_t packetlen = sizeof(dhcp_packet_t);
+  char packet[packetlen];
+
+  // If we want to offer this client an IP address:
+  // RECORD
+  Record record;
+
+  // Keep client identifier (index into database)
+  record.set_client_id(get_client_id_in_opts(opts));
+
+  // OFFER
+  dhcp_packet_t* offer = (dhcp_packet_t*) packet;
+
+  offer->op = BOOTREPLY;
+  offer->htype = 1;   // From "Assigned Numbers" RFC. 1 = 10mb ethernet
+  offer->hlen = 6;    // Hardware address length in octets. 6 for 10mb ethernet
+  offer->hops = 0;
+  offer->xid = msg->xid;
+  offer->secs = 0;
+  offer->ciaddr = IP4::addr{0};
+
+  bool ok = false;
+
+  // yiaddr
+  // IP address offered to client - Available from the pool
+  for (auto& entry : pool_) {
+    if (entry.second == Status::AVAILABLE) {
+      entry.second = Status::OFFERED;
+      offer->yiaddr = entry.first;
+      ok = true;
+
+      // Servers need not reserve the offered network address, although the protocol will work more efficiently if the server
+      // avoids allocating the offered network address to another client.
+      // When allocating a new address, servers should check that the offered network address is not already in use; e.g.
+      // the server may probe the offered address with an ICMP Echo Request. Servers SHOULD be implemented so that
+      // network admins MAY choose to disable probes of newly allocated addresses.
+
+      // RECORD
+      record.set_ip(entry.first);
+      record.set_status(Status::OFFERED);
+      record.set_lease_start(RTC::now());
+      record.set_lease_duration(lease_);
+
+      break;
+    }
+  }
+
+  if (not ok) {
+    printf("No IP is available - sending DHCPNAK\n");
+
+    // If get here: No available IP and send:
+    nak(msg);   // record has not been added to the records_ vector so OK
+    return;
+  }
+
+  // !
+  offer->siaddr = temp_siaddr_;   // IP address of next bootstrap server
+
+  offer->flags = msg->flags;
+  offer->giaddr = msg->giaddr;
+  memset(offer->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN); // uint8_t array - size 16, client hardware address
+  //offer->sname = ;  // Server host name or options - MAY
+  //offer->file = ;   // Client boot file name or options - MAY
+
+  // OPTIONS
+  dhcp_option_t* offer_opts = (dhcp_option_t*) (offer->options + 0);
+
+  // In DHCPOFFER Options:
+  // Requested IP address                                         MUST NOT
+  // ! IP address lease time                                      MUST
+  // Use file/sname fields                                        MAY
+  // DHCP message type                                            DHCPOFFER
+  // Parameter request list (DHO_DHCP_PARAMETER_REQUEST_LIST)     MUST NOT
+  // ! Message (DHO_DHCP_MESSAGE)                                 SHOULD
+  // Client identifier                                            MUST NOT - note RFC 6842
+  // Vendor class identifier                                      MAY
+  // ! Server identifier                                          MUST
+  // Maximum message size                                         MUST NOT
+  // All others                                                   MAY
+
+  // MESSAGE_TYPE
+  offer_opts->code = DHO_DHCP_MESSAGE_TYPE;
+  offer_opts->length = 1;
+  offer_opts->val[0] = DHCPOFFER;
+
+  // SERVER_IDENTIFIER (the server's network address(es))
+  offer_opts = (dhcp_option_t*) (offer->options + 3);         // 3 bytes filled in prior
+  add_server_id(offer_opts);
+
+  // SUBNET_MASK
+  offer_opts = (dhcp_option_t*) (offer->options + 9);         // 9 bytes filled in prior
+  offer_opts->code = DHO_SUBNET_MASK;
+  offer_opts->length = 4;
+  offer_opts->val[0] = netmask_.part(3);
+  offer_opts->val[1] = netmask_.part(2);
+  offer_opts->val[2] = netmask_.part(1);
+  offer_opts->val[3] = netmask_.part(0);
+
+  // ROUTERS
+  offer_opts = (dhcp_option_t*) (offer->options + 15);            // 15 bytes filled in prior
+  offer_opts->code = DHO_ROUTERS;
+  offer_opts->length = 4;
+  offer_opts->val[0] = router_.part(3);
+  offer_opts->val[1] = router_.part(2);
+  offer_opts->val[2] = router_.part(1);
+  offer_opts->val[3] = router_.part(0);
+
+  // LEASE_TIME
+  // Time in units of seconds (32-bit unsigned integer / 4 uint8_t)
+  offer_opts = (dhcp_option_t*) (offer->options + 21);            // 21 bytes filled in prior
+  offer_opts->code = DHO_DHCP_LEASE_TIME;
+  offer_opts->length = 4;
+  offer_opts->val[0] = (lease_ & 0x000000ff);
+  offer_opts->val[1] = (lease_ & 0x0000ff00) >> 8;
+  offer_opts->val[2] = (lease_ & 0x00ff0000) >> 16;
+  offer_opts->val[3] = (lease_ & 0xff000000) >> 24;
+
+  // MESSAGE (SHOULD)
+  // No error message (only in DHCPNAK)
+  offer_opts = (dhcp_option_t*) (offer->options + 27);            // 27 bytes filled in prior
+  offer_opts->code = DHO_DHCP_MESSAGE;
+  offer_opts->length = 1;                                 // No error message (only in DHCPNAK)
+  offer_opts->val[0] = 0;
+
+  // END
+  offer_opts = (dhcp_option_t*) (offer->options + 30);    // 30 bytes filled in prior
+  offer_opts->code   = DHO_END;
+  offer_opts->length = 0;
+
+  // The client should include the maximum DHCP message size option to let the server know how large the server may
+  // make its DHCP messages. The parameters returned to a client may still exceed the space allocated to options in a
+  // DHCP message. In this case, two additional options flags (which must appear in the options field of the message)
+  // indicate that the file and sname fields are to be used for options.
+
+  // The client may suggest values for the network address and lease time in the DHCPDISCOVER message. The client may
+  // include the requested IP address option to suggest that a particular IP address be assigned, and may include the
+  // IP address lease time option to suggest the lease time it would like. Other options representing hints at configuration
+  // parameters are allowed in a DHCPDISCOVER or DHCPREQUEST message. However, additional options may be ignored by
+  // servers, and multiple servers may, therefore, not return identical values for some options.
+  // The requested IP address options is to be filled in only in a DHCPREQUEST message when the client is verifying network
+  // parameters obtained previously. The client fills in the ciaddr field only when correctly configured with an IP address
+  // in BOUND, RENEWING or REBINDING state.
+
+  // THE DHCPDISCOVER MESSAGE (msg) MAY include options that suggest values for the network address and lease duration
+  // TODO
+  // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
+  // include that list in all subsequent messages.
+  // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
+  // DHCPOFFER message to which the client is responding.
+  // -> When giving the client what it has requested, store these parameters in the Record created
+  //Alt.
+  //Option op;
+  //op.set_dns(dns_);
+  //op.set_netmask(netmask_);
+  //record.options_.push_back(op);
+  // RECORD: Add configuration options
+  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
+  if (opt->code == DHO_DHCP_PARAMETER_REQUEST_LIST) {
+
+    printf("PARAMETER REQUEST LIST:\n");
+    for (int i = 0; i < opt->length; i++) {
+      printf("Option: %u\n", opt->val[i]);
+
+      // Return the requested options to the client, f.ex. dns
+
+      // Possible to avoid switch case?
+
+      //Alt.
+      //Option op;
+      //op.set_dns(dns_);
+      //op.set_netmask(netmask_);
+      //record.options_.push_back(op);
+
+    }
+    printf("\n");
+  }
+
+  // RECORD
+  add_record(record);
+
+  // Send the DHCPOFFER
+  // Broadcast the DHCPOFFER to the client because the client haven't got an IP address yet
+  socket_.bcast(get_send_to_address(msg, DHCPOFFER), DHCP_SOURCE_PORT, packet, packetlen);
+}
+
+void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+
+  // TODO
+
+  // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
+  // include that list in all subsequent messages.
+  // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
+  // DHCPOFFER message to which the client is responding.
+
+  // Send a DHCPACK directly to the address given in the ciaddr field of the DHCPINFORM message.
+  // Do not send a lease expiration time to the client and do not fill in yiaddr
+
+  // NB: Option IP address lease time MUST NOT
+
+  // The client has obtained a network address through som other means (e.g., manual configuration)
+  // and may use a DHCPINFORM request message to obtain other local configuration parameters.
+  // Servers receiving a DHCPINFORM message construct a DHCPACK message with any local configuration
+  // parameters appropriate for the client without:
+  // - allocating a new address
+  // - checking for an existing binding
+  // - filling in yiaddr
+  // - including lease time parameters
+  // The servers should unicast the DHCPACK reply to the address given in the ciaddr field of the
+  // DHCPINFORM message.
+
+  // The server should check the network address in the DHCPINFORM message for consistency, but
+  // must not check for an existing lease. The server forms a DHCPACK message containing the
+  // configuration parameters for the requesting client and sends the DHCPACK message directly to
+  // the client.
+
+  const size_t packetlen = sizeof(dhcp_packet_t);
+  char packet[packetlen];
+
+  // ACK
+  dhcp_packet_t* ack = (dhcp_packet_t*) packet;
+
+  ack->op = BOOTREPLY;
+  ack->htype = 1; // From "Assigned Numbers" RFC. 1 = 10mb ethernet
+  ack->hlen = 6;  // Hardware address length in octets. 6 for 10mb ethernet
+  ack->hops = 0;
+  ack->xid = msg->xid;
+  ack->secs = 0;
+  ack->ciaddr = msg->ciaddr;      // or 0
+
+  //ack->yiaddr - Do not fill in
+
+  ack->siaddr = temp_siaddr_;             // TODO IP address of next bootstrap server
+  ack->flags = msg->flags;
+  ack->giaddr = msg->giaddr;
+  memset(ack->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+  //ack->sname = ;    // Server host name or options
+  //ack->file = ; // Client boot file name or options
+
+  // OPTIONS
+  dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
+
+  // MESSAGE_TYPE
+  ack_opts->code = DHO_DHCP_MESSAGE_TYPE;
+  ack_opts->length = 1;
+  ack_opts->val[0] = DHCPACK;
+
+  // And more options
+
+  // TODO Options requested by the client:
+  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
+  if (opt->code == DHO_DHCP_PARAMETER_REQUEST_LIST) {
+
+    printf("PARAMETER REQUEST LIST IN DHCPINFORM MESSAGE:\n");
+    for (int i = 0; i < opt->length; i++) {
+      printf("Option: %u\n", opt->val[i]);
+
+      // Return the requested options to the client, f.ex. dns
+
+      // Possible to avoid switch case?
+
+    }
+    printf("\n");
+  }
+
+  printf("Sending an inform ack\n");
+
+  // Send the DHCPACK
+  socket_.bcast(msg->ciaddr, DHCP_SOURCE_PORT, packet, packetlen);
+}
+
+void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4::addr send_to) {
+
+  // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
+  // include that list in all subsequent messages.
+  // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
+  // DHCPOFFER message to which the client is responding.
+
+  // NB: Option IP address lease time MUST
+
+  // DHCPACK: Server to client with configuration parameters, including committed network address
+
+  // Table 3 RFC 2131 DHCPACK
+  // op           BOOTREPLY
+  // htype        From "Assigned Numbers" RFC
+  // hlen         Hardware address length in octets
+  // hops         0
+  // xid          xid from client DHCPREQUEST
+  // etc.
+
+  // The client broadcasts a DHCPREQUEST message that MUST include the server identifier option
+  // to indicate which server it has selected, and that MAY include other options specifying desired configuration values.
+  // The requested IP address option MUST be set to the value of yiaddr in the DHCPOFFER message from the server.
+
+  const size_t packetlen = sizeof(dhcp_packet_t);
+  char packet[packetlen];
+
+  // ACK
+  dhcp_packet_t* ack = (dhcp_packet_t*) packet;
+
+  ack->op = BOOTREPLY;
+  ack->htype = 1; // From "Assigned Numbers" RFC. 1 = 10mb ethernet
+  ack->hlen = 6;  // Hardware address length in octets. 6 for 10mb ethernet
+  ack->hops = 0;
+  ack->xid = msg->xid;
+  ack->secs = 0;
+  ack->ciaddr = msg->ciaddr;      // or 0
+
+  int ridx = get_record_idx(get_client_id_in_opts(opts));
+  ack->yiaddr = (ridx not_eq -1) ? records_.at(ridx).ip() : IP4::addr{0}; // TODO: else what?     // IP address assigned to client
+
+  ack->siaddr = temp_siaddr_;             // TODO IP address of next bootstrap server
+  ack->flags = msg->flags;
+  ack->giaddr = msg->giaddr;
+  memset(ack->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+  //ack->sname = ;    // Server host name or options
+  //ack->file = ; // Client boot file name or options
+
+  // OPTIONS
+  dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
+
+  // MESSAGE_TYPE
+  ack_opts->code = DHO_DHCP_MESSAGE_TYPE;
+  ack_opts->length = 1;
+  ack_opts->val[0] = DHCPACK;
+
+  // LEASE_TIME
+  ack_opts = (dhcp_option_t*) (ack->options + 3);             // 3 bytes filled in prior
+  ack_opts->code = DHO_DHCP_LEASE_TIME;
+  ack_opts->length = 4;
+  ack_opts->val[0] = (lease_ & 0x000000ff);
+  ack_opts->val[1] = (lease_ & 0x0000ff00) >> 8;
+  ack_opts->val[2] = (lease_ & 0x00ff0000) >> 16;
+  ack_opts->val[3] = (lease_ & 0xff000000) >> 24;
+
+  // SERVER_IDENTIFIER (the server's network address(es))
+  ack_opts = (dhcp_option_t*) (ack->options + 9);             // 9 bytes filled in prior
+  add_server_id(ack_opts);
+
+  // MESSAGE (SHOULD)
+  // No error message (only in DHCPNAK)
+  ack_opts = (dhcp_option_t*) (ack->options + 15);            // 15 bytes filled in prior
+  ack_opts->code = DHO_DHCP_MESSAGE;
+  ack_opts->length = 1;
+  ack_opts->val[0] = 0;
+
+  // END
+  ack_opts = (dhcp_option_t*) (ack->options + 18);            // 18 bytes filled in prior
+  ack_opts->code   = DHO_END;
+  ack_opts->length = 0;
+
+  printf("Sending a request ack\n");
+
+  // Send the DHCPACK
+  socket_.bcast(send_to not_eq IP4::addr{0} ? send_to : get_send_to_address(msg, DHCPACK), DHCP_SOURCE_PORT, packet, packetlen);
+}
+
+void DHCPD::nak(const dhcp_packet_t* msg) {
+
+  // Server to client indicating client’s notion of network address is incorrect (e.g.,
+  // client has moved to new subnet) or client’s lease as expired
+
+  const size_t packetlen = sizeof(dhcp_packet_t);
+  char packet[packetlen];
+
+  // NAK
+  dhcp_packet_t* nak = (dhcp_packet_t*) packet;
+
+  nak->op = BOOTREPLY;
+  nak->htype = 1; // From "Assigned Numbers" RFC. 1 = 10mb ethernet
+  nak->hlen = 6;  // Hardware address length in octets. 6 for 10mb ethernet
+  nak->hops = 0;
+  nak->xid = msg->xid;
+  nak->secs = 0;
+  nak->ciaddr = 0;
+  nak->yiaddr = 0;
+  nak->siaddr = 0;
+  nak->flags = msg->flags;
+  nak->giaddr = msg->giaddr;
+  memset(nak->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+
+  // OPTIONS
+  dhcp_option_t* nak_opts = (dhcp_option_t*) (nak->options + 0);
+
+  // MESSAGE_TYPE
+  nak_opts->code = DHO_DHCP_MESSAGE_TYPE;
+  nak_opts->length = 1;
+  nak_opts->val[0] = DHCPNAK;
+
+  // MESSAGE (SHOULD)
+  nak_opts = (dhcp_option_t*) (nak->options + 3);         // 3 bytes filled in prior
+  nak_opts->code = DHO_DHCP_MESSAGE;
+  // TODO Fill in error message instead of 0
+  nak_opts->length = 1;
+  nak_opts->val[0] = 0;
+
+  // SERVER_IDENTIFIER
+  nak_opts = (dhcp_option_t*) (nak->options + 6);         // 6 bytes filled in prior
+  add_server_id(nak_opts);
+
+  // CLIENT_IDENTIFIER? (MAY)
+
+  // END
+  nak_opts = (dhcp_option_t*) (nak->options + 12);        // 12 bytes filled in prior
+  nak_opts->code = DHO_END;
+  nak_opts->length = 0;
+
+  printf("Sending DHCPNAK\n");
+
+  // Send the DHCPNAK
+  socket_.bcast(get_send_to_address(msg, DHCPNAK), DHCP_SOURCE_PORT, packet, packetlen);
+}
+
+const dhcp_option_t* DHCPD::get_option(const dhcp_option_t* opts, int code) const {
+  const dhcp_option_t* opt = opts;
+  while (opt->code != code && opt->code != DHO_END) {
+    // go to next option
+    opt = (const dhcp_option_t*) (((const uint8_t*) opt) + 2 + opt->length);
+  }
+  return opt;
+}
+
+Record::byte_seq DHCPD::get_client_id_in_opts(const dhcp_option_t* opts) const {
+  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_CLIENT_IDENTIFIER);
+  Record::byte_seq client_id;
+
+  if (opt->code == DHO_DHCP_CLIENT_IDENTIFIER) {
+    printf("Client ID:\n");
+    for (int i = 0; i < opt->length; i++) {
+      client_id.push_back(opt->val[i]);
+      printf("%u", opt->val[i]);
+    }
+    printf("\n");
+  } else {
+
+    // TODO
+    // Use chaddr as identifier in database ?
+    // Or don't give an DHCPOFFER
+    // Check RFC if silent (return;) or send DHCPNAK f.ex.
+    // Check RFC updating RFC 2131
+  }
+
+  return client_id;
+}
+
+IP4::addr DHCPD::get_requested_ip_in_opts(const dhcp_option_t* opts) const {
+  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_REQUESTED_ADDRESS);
+
+  if (opt->code == DHO_DHCP_REQUESTED_ADDRESS)
+    return IP4::addr{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
+
+  return IP4::addr{0};
+}
+
+IP4::addr DHCPD::get_remote_netmask(const dhcp_option_t* opts) const {
+  const dhcp_option_t* opt = get_option(opts, DHO_SUBNET_MASK);
+
+  if (opt->code == DHO_SUBNET_MASK)
+    return IP4::addr{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
+
+  return IP4::addr{0};
+}
+
+void DHCPD::add_server_id(dhcp_option_t* opts) {
+  opts->code = DHO_DHCP_SERVER_IDENTIFIER;
+  opts->length = 4;
+  opts->val[0] = server_id_.part(3);
+  opts->val[1] = server_id_.part(2);
+  opts->val[2] = server_id_.part(1);
+  opts->val[3] = server_id_.part(0);
+}
+
+bool DHCPD::on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) const {
+
+  // The client is on the wrong network if the result of applying the local subnet mask
+  // or remote subnet mask (if giaddr is not zero) to requested IP address option value
+  // doesn't match reality
+
+  IP4::addr subnet = (giaddr == IP4::addr{0}) ? netmask_ : get_remote_netmask(opts);
+  IP4::addr requested_ip = get_requested_ip_in_opts(opts);
+
+  if (subnet == IP4::addr{0} or requested_ip == IP4::addr{0}) // Check if remote subnet mask from client exists and valid IP
+    return false;
+
+  // Check if requested IP is on the same subnet as the server
+  if (network_address(requested_ip) == network_address(server_id_))
+    return true;
+
+  return false;
+}
+
+IP4::addr DHCPD::get_send_to_address(const dhcp_packet_t* msg, const uint8_t reply_type) const {
+
+  // If giaddr is 0x0 in the DHCPREQUEST the client is on the same subnet as the server.
+  // The server MUST broadcast the DHCPNAK message to the 0xffffffff broadcast address because
+  // the client may not have a correct network address or subnet mask, and the client may
+  // not be answering ARP requests.
+  // BUT
+  // If giaddr is set in the DHCPREQUEST message, the client is on a different subnet. The
+  // server MUST set the broadcast bit in the DHCPNAK, so that the relay agent will broadcast
+  // the DHCPNAK to the client, because the client may not have a correct network address or
+  // subnet mask, and the client may not be answering ARP requests.
+
+  // Check if giaddr (gateway IP address) is non-zero
+  if (msg->giaddr != IP4::addr{0})
+    return msg->giaddr;     // Then send the reply to giaddr
+
+  // ELSE giaddr is zero
+  // -> the client is on the same subnet as the server
+  // The server must then broadcast the DHCPNAK message to the 0xffffffff broadcast address
+  // because the client may not have a correct network address or subnet mask, and the client
+  // may not be answering ARP requests.
+  // Note under reusing a previously allocated network address
+
+  if (reply_type == DHCPNAK)
+    return IP4::ADDR_ANY;   // broadcast_address(); // RFC: 0xffffffff;
+
+  // If giaddr is zero and ciaddr is non-zero
+  if (msg->ciaddr != IP4::addr{0})
+    return msg->ciaddr; // unicast reply (DHCPOFFER and DHCPACK) to ciaddr
+
+  // ELSE If giaddr is zero and ciaddr is zero
+  // and the broadcast bit (leftmost bit in flags field) is set
+  // Check if broadcast bit is set in flags field
+  std::bitset<8> bits(msg->flags);
+  if (bits[7] == 1)
+    return IP4::ADDR_ANY; // broadcast_address(); // 0xffffffff;    // Broadcast DHCPOFFER and DHCPACK
+
+  // ELSE
+  printf("Broadcast to both yiaddr and client's hardware address\n");
+  return msg->yiaddr; // Unicast DHCPOFFER and DHCPACK to the client's hardware address and yiaddr address
+  // TODO: On page 23 in RFC 2131 it says: unicast to the client's harware address AND yiaddr address
+  // So send two udp-packets to different destinations (?)
+}
+
+// Temporary
+void DHCPD::print(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+  printf("Printing content of incoming dhcp message:\n");
+
+  printf("OP: %u\n", msg->op);
+  printf("HTYPE: %u\n", msg->htype);
+  printf("HLEN: %u\n", msg->hlen);
+  printf("HOPS: %u\n", msg->hops);
+  printf("XID: %u\n", msg->xid);
+  printf("SECS: %u\n", msg->secs);
+  printf("FLAGS: %u\n", msg->flags);
+  printf("CIADDR (IP4::addr): %s\n", msg->ciaddr.to_string().c_str());
+  printf("YIADDR (IP4::addr): %s\n", msg->yiaddr.to_string().c_str());
+  printf("SIADDR (IP4::addr): %s\n", msg->siaddr.to_string().c_str());
+  printf("GIADDR (IP4::addr): %s\n", msg->giaddr.to_string().c_str());
+
+  printf("\nCHADDR:\n");
+  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
+    printf("%u ", msg->chaddr[i]);
+  printf("\n");
+
+  printf("\nSNAME:\n");
+  for (int i = 0; i < dhcp_packet_t::SNAME_LEN; i++)
+    printf("%u ", msg->sname[i]);
+  printf("\n");
+
+  printf("\nFILE:\n");
+  for (int i = 0; i < dhcp_packet_t::FILE_LEN; i++)
+    printf("%u ", msg->file[i]);
+  printf("\n");
+
+  printf("\nMAGIC:\n");
+  for (int i = 0; i < 4; i++)
+    printf("%u ", msg->magic[i]);
+  printf("\n");
+
+  printf("\nOPTIONS:\n");
+  for (int i = 0; i < DHCP_VEND_LEN; i++)
+    printf("%u ", msg->options[i]);
+  printf("\n");
+
+  // Opts
+
+  printf("\nOptions->code: %d\n", opts->code);
+  printf("\nOptions->length: %d\n", opts->length);
+
+  printf("\nOptions->val:\n");
+  for (size_t i = 0; i < opts->length; i++)
+    printf("%d ", opts->val[i]);
+  printf("\n");
+}

From 6bb1906c0ec46ba4b337fe5815c38b5f530dfd64 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 19:19:33 +0100
Subject: [PATCH 08/41] src/CMakeLists.txt: Added DHCP server cpp

---
 src/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 721533ec2c..f33a8c423e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -41,7 +41,7 @@ set(OS_OBJECTS
   net/tcp/tcp.cpp net/tcp/connection.cpp net/tcp/connection_states.cpp
   net/tcp/write_queue.cpp net/tcp/rttm.cpp net/tcp/listener.cpp
   net/ip4/icmpv4.cpp net/ip4/udp.cpp net/ip4/udp_socket.cpp
-  net/dns/dns.cpp net/dns/client.cpp net/dhcp/dh4client.cpp
+  net/dns/dns.cpp net/dns/client.cpp net/dhcp/dh4client.cpp net/dhcp/dhcpd.cpp
   net/buffer_store.cpp net/inet4.cpp
   net/super_stack.cpp
   net/http/header.cpp net/http/header_fields.cpp net/http/message.cpp net/http/request.cpp

From 6e5fe540c3777af85e2d151bcb63cd13bc12ed3e Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 20 Feb 2017 19:23:27 +0100
Subject: [PATCH 09/41] DHCP server integration test: Small update to service

---
 test/net/integration/dhcp/dhcpd/service.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/net/integration/dhcp/dhcpd/service.cpp b/test/net/integration/dhcp/dhcpd/service.cpp
index 6e3aa2efc5..c5caafd81a 100644
--- a/test/net/integration/dhcp/dhcpd/service.cpp
+++ b/test/net/integration/dhcp/dhcpd/service.cpp
@@ -42,28 +42,28 @@ void Service::start(const std::string&)
 
   // Client 1
 
-  auto& inet1 = Inet4::ifconfig<1>(10.0, [&] (bool timeout) {
+  Inet4::ifconfig<1>(10.0, [] (bool timeout) {
     if (timeout)
       printf("Interface 1 timed out\n");
     else
-      printf("Interface 1 succeed\n");
+      printf("Interface 1 succeeded\n");
   });
 
   // Client 2
 
-  auto& inet2 = Inet4::ifconfig<2>(10.0, [&] (bool timeout) {
+  Inet4::ifconfig<2>(10.0, [] (bool timeout) {
     if (timeout)
       printf("Interface 2 timed out\n");
     else
-      printf("Interface 2 succeed\n");
+      printf("Interface 2 succeeded\n");
   });
 
   // Client 3
 
-  auto& inet3 = Inet4::ifconfig<3>(10.0, [&] (bool timeout) {
+  Inet4::ifconfig<3>(10.0, [] (bool timeout) {
     if (timeout)
       printf("Interface 3 timed out\n");
     else
-      printf("Interface 3 succeed\n");
+      printf("Interface 3 succeeded\n");
   });
 }

From 37bb77798ba64812ca0297f8367b8761a4224899 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 22 Feb 2017 15:09:18 +0100
Subject: [PATCH 10/41] From DHCP_DEST_PORT to DHCP_SERVER_PORT and
 DHCP_SOURCE_PORT to DHCP_CLIENT_PORT

---
 api/net/dhcp/dhcp4.hpp     |  5 ++---
 src/net/dhcp/dh4client.cpp | 14 +++++++-------
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/api/net/dhcp/dhcp4.hpp b/api/net/dhcp/dhcp4.hpp
index 80e23ff21c..15fec587ba 100644
--- a/api/net/dhcp/dhcp4.hpp
+++ b/api/net/dhcp/dhcp4.hpp
@@ -180,9 +180,8 @@ namespace net {
   static const uint8_t FQDN_SUBOPTION_COUNT =   8;
 
   static const uint8_t ETH_ALEN =         6;  // octets in one ethernet header
-  static const uint8_t DHCP_DEST_PORT =   67;
-  static const uint8_t DHCP_SOURCE_PORT = 68;
-
+  static const uint8_t DHCP_SERVER_PORT = 67;
+  static const uint8_t DHCP_CLIENT_PORT = 68;
 } // < namespace net
 
 #endif
diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index fccf65649d..dd8b176f72 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -130,19 +130,19 @@ namespace net
     opt->length = 0;
 
     ////////////////////////////////////////////////////////
-    auto& socket = stack.udp().bind(DHCP_SOURCE_PORT);
+    auto& socket = stack.udp().bind(DHCP_CLIENT_PORT);
     /// broadcast our DHCP plea as 0.0.0.0:67
-    socket.bcast(IP4::ADDR_ANY, DHCP_DEST_PORT, packet, packetlen);
+    socket.bcast(IP4::ADDR_ANY, DHCP_SERVER_PORT, packet, packetlen);
 
     socket.on_read(
     [this, &socket] (IP4::addr, UDP::port_t port,
                      const char* data, size_t len)
     {
-      if (port == DHCP_DEST_PORT)
+      if (port == DHCP_SERVER_PORT)
       {
         // we have got a DHCP Offer
         debug("Received possible DHCP OFFER from %s:%d\n",
-              addr.str().c_str(), DHCP_DEST_PORT);
+              addr.str().c_str(), DHCP_SERVER_PORT);
         this->offer(socket, data, len);
       }
     });
@@ -326,17 +326,17 @@ namespace net
     [this] (IP4::addr, UDP::port_t port,
             const char* data, size_t len)
     {
-      if (port == DHCP_DEST_PORT)
+      if (port == DHCP_SERVER_PORT)
       {
         // we have hopefully got a DHCP Ack
         debug("\tReceived DHCP ACK from %s:%d\n",
-              addr.str().c_str(), DHCP_DEST_PORT);
+              addr.str().c_str(), DHCP_SERVER_PORT);
         this->acknowledge(data, len);
       }
     });
 
     // send our DHCP Request
-    sock.bcast(IP4::ADDR_ANY, DHCP_DEST_PORT, packet, packetlen);
+    sock.bcast(IP4::ADDR_ANY, DHCP_SERVER_PORT, packet, packetlen);
   }
 
   void DHClient::acknowledge(const char* data, size_t)

From 8ad62842062cfcb6cccbd46992b1e20c1510545f Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 22 Feb 2017 15:14:22 +0100
Subject: [PATCH 11/41] DHCP server: Removed unnecessary attribute and methods,
 cleanup in unicast, broadcast, port to send to and more

---
 api/net/dhcp/dhcpd.hpp |  15 +--
 src/net/dhcp/dhcpd.cpp | 285 ++++++++++++++++++++++++++++++-----------
 2 files changed, 212 insertions(+), 88 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index c8a3a2c066..06b741a607 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -45,10 +45,6 @@ namespace dhcp {
     IP4::addr server_id() const
     { return server_id_; }
 
-    // TODO
-    IP4::addr temp_siaddr() const
-    { return temp_siaddr_; }
-
     IP4::addr netmask() const
     { return netmask_; }
 
@@ -84,10 +80,6 @@ namespace dhcp {
     void set_server_id(IP4::addr server_id)
     { server_id_ = server_id; }
 
-    // TODO
-    void set_temp_siaddr(IP4::addr temp_siaddr)
-    { temp_siaddr_ = temp_siaddr; }
-
     void set_netmask(IP4::addr netmask)
     { netmask_ = netmask; }
 
@@ -134,10 +126,8 @@ namespace dhcp {
     std::map<IP4::addr, Status> pool_;
 
     IP4::addr server_id_;
-    IP4::addr temp_siaddr_;         // TODO Remove? IP address of next bootstrap server
     IP4::addr netmask_, router_, dns_;
-    uint32_t lease_;
-    uint32_t max_lease_;
+    uint32_t lease_, max_lease_;
     uint8_t pending_;               // How long to consider an offered address in the pending state (seconds)
     std::vector<Record> records_;   // Temp - Instead of persistent storage:
 
@@ -152,7 +142,7 @@ namespace dhcp {
     void verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void offer(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
-    void request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4::addr send_to = IP4::addr{0});
+    void request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void nak(const dhcp_packet_t* msg/*, const dhcp_option_t* opts*/);
 
     const dhcp_option_t* get_option(const dhcp_option_t* opts, int code) const;
@@ -163,7 +153,6 @@ namespace dhcp {
     IP4::addr inc_addr(IP4::addr ip) const
     { return IP4::addr{htonl(ntohl(ip.whole) + 1)}; }
     bool on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) const;
-    IP4::addr get_send_to_address(const dhcp_packet_t* msg, const uint8_t reply_type) const;
 
     // Remove
     void print(const dhcp_packet_t* msg, const dhcp_option_t* opts);
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 3176d98aac..f9b4327a6b 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -26,14 +26,10 @@ using namespace dhcp;
 DHCPD::DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
   uint32_t lease, uint32_t max_lease, uint8_t pending)
 : stack_{udp.stack()},
-  socket_{udp.bind(DHCP_DEST_PORT)},
+  socket_{udp.bind(DHCP_SERVER_PORT)},
   pool_start_{pool_start},
   pool_end_{pool_end},
   server_id_{stack_.ip_addr()},
-
-  // TODO: Correct to set this server's IP address? - IP address of next server to use in bootstrap
-  temp_siaddr_{stack_.ip_addr()},
-
   netmask_{stack_.netmask()},
   router_{stack_.gateway()},
   dns_{stack_.gateway()},
@@ -128,7 +124,7 @@ void DHCPD::listen() {
   socket_.on_read([&] (IP4::addr, UDP::port_t port,
     const char* data, size_t) {
 
-    if (port == DHCP_SOURCE_PORT) {
+    if (port == DHCP_CLIENT_PORT) {
       printf("Received data from DHCP client\n");
 
       // Message
@@ -151,6 +147,9 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   switch (opts->val[0]) {
     case DHCPDISCOVER:
       printf("\nDISCOVER\n");
+
+      //print(msg, opts);
+
       offer(msg, opts);
       break;
     case DHCPREQUEST:
@@ -214,6 +213,8 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
   if (opt->code == DHO_DHCP_SERVER_IDENTIFIER) {
     // Then this is a response to a DHCPOFFER message
 
+    printf("REQUEST from client is a response to a DHCPOFFER and has a SERVER IDENTIFIER\n");
+
     IP4::addr sid{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
     printf("Server identifier for chosen server: %s\n", sid.to_string().c_str());
 
@@ -230,10 +231,14 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
     }
 
     // SERVER IDENTIFIER == THIS SERVER'S ID
+    printf("SERVER IDENTIFIER matches this server\n");
 
     int ridx = get_record_idx(get_client_id_in_opts(opts));
 
     if (ridx not_eq -1) {   // if record exists
+
+      printf("A RECORD FOR THIS CLIENT ALREADY EXISTS\n");
+
       auto& record = records_.at(ridx);
       // if ciaddr is zero and requested IP address is filled in with the yiaddr value from the chosen DHCPOFFER
       // Client state: SELECTING
@@ -244,6 +249,8 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
         // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
         // timeout mechanism to decide when to reuse an offered address.
 
+        printf("THIS IS A SELECTING REQUEST FROM THE CLIENT - will construct DHCPACK\n");
+
         // RECORD
         record.set_status(Status::IN_USE);
 
@@ -255,20 +262,25 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
         return;
       }
 
+      printf("CIADDR IS NOT ZERO OR THE RECORD'S IP DOES NOT MATCH THE REQUESTED IP IN OPTS FROM CLIENT - the client probably has already gotten an IP from the server - dhcpnak?\n");
+
       // ELSE ciaddr is not zero or record's ip is not the same as the requested ip in the request
-      return; // TODO: nak() or silent return?
+      // TODO: nak() or silent return?
+      nak(msg);
+      return;
     }
 
     // Else a record with this client id doesn't exist
     // TODO: Remain silent or send a DHCPNAK?
-    printf("Record does not exist - sending DHCPNAK\n");
+    printf("RECORD FOR THIS CLIENT does not exist - sending DHCPNAK\n");
     nak(msg);
     return;
   }
 
   // Else server identifier is not filled in and this is not a response to a DHCPOFFER message
+  // This is a request to verify or extend an existing lease
 
-  // This is a request to verify or extend and existing lease
+  printf("SERVER IDENTIFIER IS NOT FILLED IN and this is not a response to a DHCPOFFER, but a request to verify or extend an existing lease\n");
 
   verify_or_extend_lease(msg, opts);
 
@@ -407,12 +419,15 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     record.set_lease_start(RTC::now());
     update_pool(record.ip(), Status::IN_USE);
 
+    request_ack(msg, opts);
+/*
     if (msg->giaddr != IP4::addr{0})    // The message has been broadcasted to the gateway and the ack should be broadcasted
                                         // The client is then in the REBINDING state
       request_ack(msg, opts, IP4::ADDR_ANY);    // broadcast_address()  // RFC: 0xffffffff
     else    // Set send_to IP because we know that we want to send to ciaddr (unicast)
             // The client is then in the RENEWING state
       request_ack(msg, opts, msg->ciaddr);
+*/
   }
 }
 
@@ -488,12 +503,10 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
     return;
   }
 
-  // !
-  offer->siaddr = temp_siaddr_;   // IP address of next bootstrap server
-
+  offer->siaddr = IP4::addr{0};   // IP address of next bootstrap server
   offer->flags = msg->flags;
   offer->giaddr = msg->giaddr;
-  memset(offer->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN); // uint8_t array - size 16, client hardware address
+  std::memcpy(offer->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN); // uint8_t array - size 16, client hardware address
   //offer->sname = ;  // Server host name or options - MAY
   //offer->file = ;   // Client boot file name or options - MAY
 
@@ -545,10 +558,15 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts = (dhcp_option_t*) (offer->options + 21);            // 21 bytes filled in prior
   offer_opts->code = DHO_DHCP_LEASE_TIME;
   offer_opts->length = 4;
-  offer_opts->val[0] = (lease_ & 0x000000ff);
+  // TODO: CHANGED REVERSE ORDER:
+  offer_opts->val[0] = (lease_ & 0xff000000) >> 24;
+  offer_opts->val[1] = (lease_ & 0x00ff0000) >> 16;
+  offer_opts->val[2] = (lease_ & 0x0000ff00) >> 8;
+  offer_opts->val[3] = (lease_ & 0x000000ff);
+  /*offer_opts->val[0] = (lease_ & 0x000000ff);
   offer_opts->val[1] = (lease_ & 0x0000ff00) >> 8;
   offer_opts->val[2] = (lease_ & 0x00ff0000) >> 16;
-  offer_opts->val[3] = (lease_ & 0xff000000) >> 24;
+  offer_opts->val[3] = (lease_ & 0xff000000) >> 24;*/
 
   // MESSAGE (SHOULD)
   // No error message (only in DHCPNAK)
@@ -557,11 +575,84 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->length = 1;                                 // No error message (only in DHCPNAK)
   offer_opts->val[0] = 0;
 
+  // Testing on ubuntu - Adding options:
+  // 1 TIME_OFFSET
+  offer_opts = (dhcp_option_t*) (offer->options + 30);
+  offer_opts->code = DHO_TIME_OFFSET;
+  offer_opts->length = 4;
+  auto l_start = record.lease_start();
+  // TODO: CHANGED REVERSE ORDER:
+  offer_opts->val[0] = (l_start & 0xff000000) >> 24;
+  offer_opts->val[1] = (l_start & 0x00ff0000) >> 16;
+  offer_opts->val[2] = (l_start & 0x0000ff00) >> 8;
+  offer_opts->val[3] = (l_start & 0x000000ff);
+  /*offer_opts->val[0] = (l_start & 0x000000ff);
+  offer_opts->val[1] = (l_start & 0x0000ff00) >> 8;
+  offer_opts->val[2] = (l_start & 0x00ff0000) >> 16;
+  offer_opts->val[3] = (l_start & 0xff000000) >> 24;*/
+
+  // 2 DOMAIN_NAME_SERVERS
+  offer_opts = (dhcp_option_t*) (offer->options + 36);
+  offer_opts->code = DHO_DOMAIN_NAME_SERVERS;
+  offer_opts->length = 4;
+  offer_opts->val[0] = dns_.part(3);
+  offer_opts->val[1] = dns_.part(2);
+  offer_opts->val[2] = dns_.part(1);
+  offer_opts->val[3] = dns_.part(0);
+
+  // 3 HOST_NAME - responding with client's host name (but not specified in rfc?)
+  offer_opts = (dhcp_option_t*) (offer->options + 42);
+  offer_opts->code = DHO_HOST_NAME;
+  auto host_name_length = 0;
+  printf("Host name from client:\n");
+  const dhcp_option_t* host_name = get_option(opts, DHO_HOST_NAME);
+  if (host_name->code == DHO_HOST_NAME) {
+    host_name_length = host_name->length;
+    offer_opts->length = host_name_length;
+    for (int i = 0; i < host_name->length; i++) {
+      printf("%u ", host_name->val[i]);
+      offer_opts->val[i] = host_name->val[i];
+    }
+  } else {
+    printf("Fant ikke DHO_HOST_NAME fra klient\n");
+    host_name_length = 1;
+    offer_opts->length = 1;
+    offer_opts->val[0] = 0;
+  }
+  printf("\n");
+
+  // 4 DOMAIN_NAME - blank for now
+  offer_opts = (dhcp_option_t*) (offer->options + 45 + host_name_length);
+  offer_opts->code = DHO_DOMAIN_NAME;
+  offer_opts->length = 1;
+  offer_opts->val[0] = 0;
+
+  // 5 BROADCAST_ADDRESS -
+  offer_opts = (dhcp_option_t*) (offer->options + 48 + host_name_length);
+  offer_opts->code = DHO_BROADCAST_ADDRESS;
+  offer_opts->length = 4;
+  auto broadcast = broadcast_address();
+  offer_opts->val[0] = broadcast.part(3);
+  offer_opts->val[1] = broadcast.part(2);
+  offer_opts->val[2] = broadcast.part(1);
+  offer_opts->val[3] = broadcast.part(0);
+  /* 5 BROADCAST_ADDRESS
+  offer_opts = (dhcp_option_t*) (offer->options + 48 + host_name_length);
+  offer_opts->code = DHO_BROADCAST_ADDRESS;
+  offer_opts->length = 4;
+  offer_opts->val[0] = 0;
+  offer_opts->val[1] = 0;
+  offer_opts->val[2] = 0;
+  offer_opts->val[3] = 0;*/
+
   // END
-  offer_opts = (dhcp_option_t*) (offer->options + 30);    // 30 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 54 + host_name_length);    // 30 bytes filled in prior
   offer_opts->code   = DHO_END;
   offer_opts->length = 0;
 
+  printf("\n------------------- Offer from Server -------------------\n");
+  print(offer, offer_opts);
+
   // The client should include the maximum DHCP message size option to let the server know how large the server may
   // make its DHCP messages. The parameters returned to a client may still exceed the space allocated to options in a
   // DHCP message. In this case, two additional options flags (which must appear in the options field of the message)
@@ -613,9 +704,45 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // RECORD
   add_record(record);
 
+  // If the giaddr field in a DHCP message from a client is non-zero, the server
+  // sends any return messages to the DHCP server port on the BOOTP relay agent
+  // whose address appears in giaddr
+  // DHCP server port is port 67
+  // DHCP client port is port 68
+  if (msg->giaddr != IP4::addr{0}) {
+    socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, packetlen);
+    return;
+  }
+
+  // msg->giaddr is zero
+  // If the giaddr field is zero and the ciaddr field is non-zero, then the server
+  // unicasts DHCPOFFER and DHCPACK messages to the address in ciaddr
+  if (msg->ciaddr != IP4::addr{0}) {
+    socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
+    return;
+  }
+
+  // msg->giaddr and msg->ciaddr is zero
+  // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in
+  // flags field) is set, then the server broadcasts DHCPOFFER and DHCPACK messsages
+  // to 0xffffffff
+  std::bitset<8> bits(msg->flags);
+  if (bits[7] == 1) {
+    socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
+    return;
+  }
+
+  // the broadcast bit is not set
+  // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the
+  // server unicasts DHCPOFFER and DHCPACK messages to the client's hardware address
+  // and yiaddr address
+  socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
+  // TODO: Send the message to the client's hardware address:
+  // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
+
   // Send the DHCPOFFER
   // Broadcast the DHCPOFFER to the client because the client haven't got an IP address yet
-  socket_.bcast(get_send_to_address(msg, DHCPOFFER), DHCP_SOURCE_PORT, packet, packetlen);
+  // socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
@@ -661,13 +788,10 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack->xid = msg->xid;
   ack->secs = 0;
   ack->ciaddr = msg->ciaddr;      // or 0
-
-  //ack->yiaddr - Do not fill in
-
-  ack->siaddr = temp_siaddr_;             // TODO IP address of next bootstrap server
+  ack->siaddr = IP4::addr{0};     // TODO IP address of next bootstrap server
   ack->flags = msg->flags;
   ack->giaddr = msg->giaddr;
-  memset(ack->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+  std::memcpy(ack->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
   //ack->sname = ;    // Server host name or options
   //ack->file = ; // Client boot file name or options
 
@@ -697,13 +821,14 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
     printf("\n");
   }
 
-  printf("Sending an inform ack\n");
+  printf("Sending an inform ack to ciaddr: %s\n", msg->ciaddr.to_string().c_str());
 
   // Send the DHCPACK
-  socket_.bcast(msg->ciaddr, DHCP_SOURCE_PORT, packet, packetlen);
+  // Unicast to DHCPINFORM message's ciaddr field
+  socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
-void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4::addr send_to) {
+void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
   // include that list in all subsequent messages.
@@ -743,10 +868,22 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4
   int ridx = get_record_idx(get_client_id_in_opts(opts));
   ack->yiaddr = (ridx not_eq -1) ? records_.at(ridx).ip() : IP4::addr{0}; // TODO: else what?     // IP address assigned to client
 
-  ack->siaddr = temp_siaddr_;             // TODO IP address of next bootstrap server
+  ack->siaddr = IP4::addr{0};     // TODO IP address of next bootstrap server
   ack->flags = msg->flags;
   ack->giaddr = msg->giaddr;
-  memset(ack->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+  std::memcpy(ack->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+
+  printf("\n------------- OBS Memcopying chaddr in ack -------------\n");
+  printf("Msg->chaddr:\n");
+  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
+    printf("%u ", msg->chaddr[i]);
+  printf("\n");
+  printf("Ack->chaddr:\n");
+  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
+    printf("%u ", ack->chaddr[i]);
+  printf("\n");
+  printf("------------------------------------------------------\n");
+
   //ack->sname = ;    // Server host name or options
   //ack->file = ; // Client boot file name or options
 
@@ -785,14 +922,51 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts, IP4
 
   printf("Sending a request ack\n");
 
+  // If the giaddr field in a DHCP message from a client is non-zero, the server
+  // sends any return messages to the DHCP server port on the BOOTP relay agent
+  // whose address appears in giaddr
+  // DHCP server port is port 67
+  // DHCP client port is port 68
+  if (msg->giaddr != IP4::addr{0}) {
+    socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, packetlen);
+    return;
+  }
+
+  // msg->giaddr is zero
+  // If the giaddr field is zero and the ciaddr field is non-zero, then the server
+  // unicasts DHCPOFFER and DHCPACK messages to the address in ciaddr
+  if (msg->ciaddr != IP4::addr{0}) {
+    socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
+    return;
+  }
+
+  // msg->giaddr and msg->ciaddr is zero
+  // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in
+  // flags field) is set, then the server broadcasts DHCPOFFER and DHCPACK messsages
+  // to 0xffffffff
+  std::bitset<8> bits(msg->flags);
+  if (bits[7] == 1) {
+    socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
+    return;
+  }
+
+  // the broadcast bit is not set
+  // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the
+  // server unicasts DHCPOFFER and DHCPACK messages to the client's hardware address
+  // and yiaddr address
+  socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
+  // TODO: Send the message to the client's hardware address:
+  // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
+
   // Send the DHCPACK
-  socket_.bcast(send_to not_eq IP4::addr{0} ? send_to : get_send_to_address(msg, DHCPACK), DHCP_SOURCE_PORT, packet, packetlen);
+  // Broadcast
+  // socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 void DHCPD::nak(const dhcp_packet_t* msg) {
 
   // Server to client indicating client’s notion of network address is incorrect (e.g.,
-  // client has moved to new subnet) or client’s lease as expired
+  // client has moved to new subnet) or client’s lease has expired
 
   const size_t packetlen = sizeof(dhcp_packet_t);
   char packet[packetlen];
@@ -811,7 +985,7 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   nak->siaddr = 0;
   nak->flags = msg->flags;
   nak->giaddr = msg->giaddr;
-  memset(nak->chaddr, *msg->chaddr, dhcp_packet_t::CHADDR_LEN);
+  std::memcpy(nak->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
 
   // OPTIONS
   dhcp_option_t* nak_opts = (dhcp_option_t*) (nak->options + 0);
@@ -842,7 +1016,8 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   printf("Sending DHCPNAK\n");
 
   // Send the DHCPNAK
-  socket_.bcast(get_send_to_address(msg, DHCPNAK), DHCP_SOURCE_PORT, packet, packetlen);
+  // Broadcast
+  socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 const dhcp_option_t* DHCPD::get_option(const dhcp_option_t* opts, int code) const {
@@ -867,6 +1042,10 @@ Record::byte_seq DHCPD::get_client_id_in_opts(const dhcp_option_t* opts) const {
     printf("\n");
   } else {
 
+    printf("\n- - - - - OBS Get client id in opts - - - - -\n");
+    printf("Client identifier was not found in options - returning an empty vector<uint8_t> for now");
+    printf("\n- - - - - - - - - -\n");
+
     // TODO
     // Use chaddr as identifier in database ?
     // Or don't give an DHCPOFFER
@@ -923,50 +1102,6 @@ bool DHCPD::on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) cons
   return false;
 }
 
-IP4::addr DHCPD::get_send_to_address(const dhcp_packet_t* msg, const uint8_t reply_type) const {
-
-  // If giaddr is 0x0 in the DHCPREQUEST the client is on the same subnet as the server.
-  // The server MUST broadcast the DHCPNAK message to the 0xffffffff broadcast address because
-  // the client may not have a correct network address or subnet mask, and the client may
-  // not be answering ARP requests.
-  // BUT
-  // If giaddr is set in the DHCPREQUEST message, the client is on a different subnet. The
-  // server MUST set the broadcast bit in the DHCPNAK, so that the relay agent will broadcast
-  // the DHCPNAK to the client, because the client may not have a correct network address or
-  // subnet mask, and the client may not be answering ARP requests.
-
-  // Check if giaddr (gateway IP address) is non-zero
-  if (msg->giaddr != IP4::addr{0})
-    return msg->giaddr;     // Then send the reply to giaddr
-
-  // ELSE giaddr is zero
-  // -> the client is on the same subnet as the server
-  // The server must then broadcast the DHCPNAK message to the 0xffffffff broadcast address
-  // because the client may not have a correct network address or subnet mask, and the client
-  // may not be answering ARP requests.
-  // Note under reusing a previously allocated network address
-
-  if (reply_type == DHCPNAK)
-    return IP4::ADDR_ANY;   // broadcast_address(); // RFC: 0xffffffff;
-
-  // If giaddr is zero and ciaddr is non-zero
-  if (msg->ciaddr != IP4::addr{0})
-    return msg->ciaddr; // unicast reply (DHCPOFFER and DHCPACK) to ciaddr
-
-  // ELSE If giaddr is zero and ciaddr is zero
-  // and the broadcast bit (leftmost bit in flags field) is set
-  // Check if broadcast bit is set in flags field
-  std::bitset<8> bits(msg->flags);
-  if (bits[7] == 1)
-    return IP4::ADDR_ANY; // broadcast_address(); // 0xffffffff;    // Broadcast DHCPOFFER and DHCPACK
-
-  // ELSE
-  printf("Broadcast to both yiaddr and client's hardware address\n");
-  return msg->yiaddr; // Unicast DHCPOFFER and DHCPACK to the client's hardware address and yiaddr address
-  // TODO: On page 23 in RFC 2131 it says: unicast to the client's harware address AND yiaddr address
-  // So send two udp-packets to different destinations (?)
-}
-
 // Temporary
 void DHCPD::print(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   printf("Printing content of incoming dhcp message:\n");

From b63b898a4c71d7360ca5b51e4516277ac822466c Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 22 Feb 2017 16:44:39 +0100
Subject: [PATCH 12/41] DHCP server: Client id now with chaddr as alternative
 and sname and file added to message

---
 api/net/dhcp/dhcpd.hpp |  2 +-
 src/net/dhcp/dhcpd.cpp | 53 +++++++++++++++++-------------------------
 2 files changed, 22 insertions(+), 33 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 06b741a607..0056bdd9c6 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -146,7 +146,7 @@ namespace dhcp {
     void nak(const dhcp_packet_t* msg/*, const dhcp_option_t* opts*/);
 
     const dhcp_option_t* get_option(const dhcp_option_t* opts, int code) const;
-    Record::byte_seq get_client_id_in_opts(const dhcp_option_t* opts) const;
+    Record::byte_seq get_client_id(const uint8_t* chaddr, const dhcp_option_t* opts) const;
     IP4::addr get_requested_ip_in_opts(const dhcp_option_t* opts) const;
     IP4::addr get_remote_netmask(const dhcp_option_t* opts) const;
     void add_server_id(dhcp_option_t* opts);
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index f9b4327a6b..6ab998f349 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -163,7 +163,7 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       // The server must mark the network address as not available and should notify the network admin
       // of a possible configuration problem - TODO
 
-      ridx = get_record_idx(get_client_id_in_opts(opts));
+      ridx = get_record_idx(get_client_id(msg->chaddr, opts));
 
       // TODO
       // Erase record if exists because client hasn't got a valid IP
@@ -221,7 +221,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
     if (sid not_eq server_id()) {
       printf("The client has not chosen this server\n");
 
-      int ridx = get_record_idx(get_client_id_in_opts(opts));
+      int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
       if (ridx != -1) {
         // Free up the IP address - the client has declined our offer
         update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
@@ -233,7 +233,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
     // SERVER IDENTIFIER == THIS SERVER'S ID
     printf("SERVER IDENTIFIER matches this server\n");
 
-    int ridx = get_record_idx(get_client_id_in_opts(opts));
+    int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
 
     if (ridx not_eq -1) {   // if record exists
 
@@ -339,7 +339,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
 }
 
 void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-  int ridx = get_record_idx(get_client_id_in_opts(opts));
+  int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
 
   if (ridx == -1) {
     // If the server has no record of this client, then it MUST remain silent and MAY
@@ -456,7 +456,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   Record record;
 
   // Keep client identifier (index into database)
-  record.set_client_id(get_client_id_in_opts(opts));
+  record.set_client_id(get_client_id(msg->chaddr, opts));
 
   // OFFER
   dhcp_packet_t* offer = (dhcp_packet_t*) packet;
@@ -507,8 +507,8 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer->flags = msg->flags;
   offer->giaddr = msg->giaddr;
   std::memcpy(offer->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN); // uint8_t array - size 16, client hardware address
-  //offer->sname = ;  // Server host name or options - MAY
-  //offer->file = ;   // Client boot file name or options - MAY
+  std::memcpy(offer->sname, msg->sname, dhcp_packet_t::SNAME_LEN);  // Server host name or options - MAY
+  std::memcpy(offer->file, msg->file, dhcp_packet_t::FILE_LEN);     // Client boot file name or options - MAY
 
   // OPTIONS
   dhcp_option_t* offer_opts = (dhcp_option_t*) (offer->options + 0);
@@ -622,13 +622,13 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   printf("\n");
 
   // 4 DOMAIN_NAME - blank for now
-  offer_opts = (dhcp_option_t*) (offer->options + 45 + host_name_length);
+  offer_opts = (dhcp_option_t*) (offer->options + 44 + host_name_length);
   offer_opts->code = DHO_DOMAIN_NAME;
   offer_opts->length = 1;
   offer_opts->val[0] = 0;
 
   // 5 BROADCAST_ADDRESS -
-  offer_opts = (dhcp_option_t*) (offer->options + 48 + host_name_length);
+  offer_opts = (dhcp_option_t*) (offer->options + 47 + host_name_length);
   offer_opts->code = DHO_BROADCAST_ADDRESS;
   offer_opts->length = 4;
   auto broadcast = broadcast_address();
@@ -646,7 +646,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = 0;*/
 
   // END
-  offer_opts = (dhcp_option_t*) (offer->options + 54 + host_name_length);    // 30 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 53 + host_name_length);    // 30 bytes filled in prior
   offer_opts->code   = DHO_END;
   offer_opts->length = 0;
 
@@ -792,8 +792,8 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack->flags = msg->flags;
   ack->giaddr = msg->giaddr;
   std::memcpy(ack->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
-  //ack->sname = ;    // Server host name or options
-  //ack->file = ; // Client boot file name or options
+  std::memcpy(ack->sname, msg->sname, dhcp_packet_t::SNAME_LEN);  // Server host name or options - MAY
+  std::memcpy(ack->file, msg->file, dhcp_packet_t::FILE_LEN);     // Client boot file name or options - MAY
 
   // OPTIONS
   dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
@@ -865,7 +865,7 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack->secs = 0;
   ack->ciaddr = msg->ciaddr;      // or 0
 
-  int ridx = get_record_idx(get_client_id_in_opts(opts));
+  int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
   ack->yiaddr = (ridx not_eq -1) ? records_.at(ridx).ip() : IP4::addr{0}; // TODO: else what?     // IP address assigned to client
 
   ack->siaddr = IP4::addr{0};     // TODO IP address of next bootstrap server
@@ -884,8 +884,8 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   printf("\n");
   printf("------------------------------------------------------\n");
 
-  //ack->sname = ;    // Server host name or options
-  //ack->file = ; // Client boot file name or options
+  std::memcpy(ack->sname, msg->sname, dhcp_packet_t::SNAME_LEN);  // Server host name or options - MAY
+  std::memcpy(ack->file, msg->file, dhcp_packet_t::FILE_LEN);     // Client boot file name or options - MAY
 
   // OPTIONS
   dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
@@ -1029,30 +1029,19 @@ const dhcp_option_t* DHCPD::get_option(const dhcp_option_t* opts, int code) cons
   return opt;
 }
 
-Record::byte_seq DHCPD::get_client_id_in_opts(const dhcp_option_t* opts) const {
+Record::byte_seq DHCPD::get_client_id(const uint8_t* chaddr, const dhcp_option_t* opts) const {
   const dhcp_option_t* opt = get_option(opts, DHO_DHCP_CLIENT_IDENTIFIER);
   Record::byte_seq client_id;
 
   if (opt->code == DHO_DHCP_CLIENT_IDENTIFIER) {
-    printf("Client ID:\n");
-    for (int i = 0; i < opt->length; i++) {
+    for (int i = 0; i < opt->length; i++)
       client_id.push_back(opt->val[i]);
-      printf("%u", opt->val[i]);
-    }
-    printf("\n");
-  } else {
-
-    printf("\n- - - - - OBS Get client id in opts - - - - -\n");
-    printf("Client identifier was not found in options - returning an empty vector<uint8_t> for now");
-    printf("\n- - - - - - - - - -\n");
-
-    // TODO
-    // Use chaddr as identifier in database ?
-    // Or don't give an DHCPOFFER
-    // Check RFC if silent (return;) or send DHCPNAK f.ex.
-    // Check RFC updating RFC 2131
+    return client_id;
   }
 
+  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
+    client_id.push_back(chaddr[i]);
+  printf("\n- - - - - OBS Client identifier isn't given and client id is chaddr - - - - -\n");
   return client_id;
 }
 

From ab00a63faf51ed0556fc2010e19cc1a2c88a29c2 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 22 Feb 2017 21:41:34 +0100
Subject: [PATCH 13/41] DHCP server integration test updated

---
 test/net/integration/dhcp/dhcpd/README.md   |  3 ++
 test/net/integration/dhcp/dhcpd/service.cpp | 40 ++++++++++++---------
 test/net/integration/dhcp/dhcpd/test.py     | 14 +++++---
 3 files changed, 37 insertions(+), 20 deletions(-)
 mode change 100644 => 100755 test/net/integration/dhcp/dhcpd/test.py

diff --git a/test/net/integration/dhcp/dhcpd/README.md b/test/net/integration/dhcp/dhcpd/README.md
index 7f57648461..da429df298 100644
--- a/test/net/integration/dhcp/dhcpd/README.md
+++ b/test/net/integration/dhcp/dhcpd/README.md
@@ -1 +1,4 @@
 # Test DHCP server
+
+Note:
+Requires that $INCLUDEOS_PREFIX/includeos/scripts/create_bridge.sh has been run and that a route has been added to the created bridge (bridge43): sudo route add -net 10.0.100.0 netmask 255.255.255.0 dev bridge43
diff --git a/test/net/integration/dhcp/dhcpd/service.cpp b/test/net/integration/dhcp/dhcpd/service.cpp
index c5caafd81a..5e087fd4d9 100644
--- a/test/net/integration/dhcp/dhcpd/service.cpp
+++ b/test/net/integration/dhcp/dhcpd/service.cpp
@@ -18,8 +18,7 @@
 #include <service>
 #include <net/inet4>
 #include <net/dhcp/dhcpd.hpp>
-
-#include <timers>
+#include <list>
 
 std::unique_ptr<net::dhcp::DHCPD> server;
 
@@ -32,38 +31,47 @@ void Service::start(const std::string&)
 
   auto& inet = Inet4::ifconfig<0>(
     { 10,0,100,1 },     // IP
-    { 255,255,0,0 },    // Netmask
+    { 255,255,255,0 },  // Netmask
     { 10,0,0,1 },       // Gateway
     { 10,0,0,1 });      // DNS
 
-  IP4::addr pool_start{10,0,100,13};
+  IP4::addr pool_start{10,0,100,10};
   IP4::addr pool_end{10,0,100,20};
   server = std::make_unique<DHCPD>(inet.udp(), pool_start, pool_end);
 
   // Client 1
 
   Inet4::ifconfig<1>(10.0, [] (bool timeout) {
-    if (timeout)
-      printf("Interface 1 timed out\n");
-    else
-      printf("Interface 1 succeeded\n");
+    if (timeout) {
+      printf("Client 1 timed out\n");
+    }
+    else {
+      INFO("DHCP test", "Client 1 got IP from IncludeOS DHCP server");
+      printf("%s\n", net::Inet4::stack<1>().ip_addr().str().c_str());
+    }
   });
 
   // Client 2
 
   Inet4::ifconfig<2>(10.0, [] (bool timeout) {
-    if (timeout)
-      printf("Interface 2 timed out\n");
-    else
-      printf("Interface 2 succeeded\n");
+    if (timeout) {
+      printf("Client 2 timed out\n");
+    }
+    else {
+      INFO("DHCP test", "Client 2 got IP from IncludeOS DHCP server");
+      printf("%s\n", net::Inet4::stack<2>().ip_addr().str().c_str());
+    }
   });
 
   // Client 3
 
   Inet4::ifconfig<3>(10.0, [] (bool timeout) {
-    if (timeout)
-      printf("Interface 3 timed out\n");
-    else
-      printf("Interface 3 succeeded\n");
+    if (timeout) {
+      printf("Client 3 timed out\n");
+    }
+    else {
+      INFO("DHCP test", "Client 3 got IP from IncludeOS DHCP server");
+      printf("%s\n", net::Inet4::stack<3>().ip_addr().str().c_str());
+    }
   });
 }
diff --git a/test/net/integration/dhcp/dhcpd/test.py b/test/net/integration/dhcp/dhcpd/test.py
old mode 100644
new mode 100755
index 0f7865e6c5..af3bf1dce4
--- a/test/net/integration/dhcp/dhcpd/test.py
+++ b/test/net/integration/dhcp/dhcpd/test.py
@@ -17,10 +17,13 @@
 # Get an auto-created VM from the vmrunner
 vm = vmrunner.vms[0]
 
+num_assigned_clients = 0
 ping_count = 3
 
 def DHCP_test(trigger_line):
-  print color.INFO("<Test.py>"),"Got IP"
+  global num_assigned_clients
+  num_assigned_clients += 1
+  print color.INFO("<Test.py>"),"Client got IP"
   ip_string = vm.readline()
   print color.INFO("<Test.py>"), "Assigned address: ", ip_string
   print color.INFO("<Test.py>"), "Trying to ping"
@@ -29,15 +32,18 @@ def DHCP_test(trigger_line):
     command = ["ping", ip_string.rstrip(), "-c", str(ping_count), "-i", "0.2"]
     print color.DATA(" ".join(command))
     print subprocess.check_output(command)
-    vm.exit(0,"<Test.py> Ping test passed. Process returned 0 exit status")
+    print color.INFO("<Test.py>"), "Number of ping tests passed: ", str(num_assigned_clients)
+    if num_assigned_clients == 3:
+      vm.exit(0,"<Test.py> Ping test for all 3 clients passed. Process returned 0 exit status")
   except Exception as e:
     print color.FAIL("<Test.py> Ping FAILED Process threw exception:")
     print e
     return False
 
-
 # Add custom event-handler
-vm.on_output("Got IP from DHCP", DHCP_test)
+vm.on_output("Client 1 got IP from IncludeOS DHCP server", DHCP_test)
+vm.on_output("Client 2 got IP from IncludeOS DHCP server", DHCP_test)
+vm.on_output("Client 3 got IP from IncludeOS DHCP server", DHCP_test)
 
 # Boot the VM, taking a timeout as parameter
 vm.cmake().boot(20).clean()

From f2ba785996fa9b0cf6d4fdcdac681390febb899e Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 22 Feb 2017 22:23:12 +0100
Subject: [PATCH 14/41] DHCP server: Magic cookie added to reply messages after
 wireshark complained about malformed packets

---
 api/net/dhcp/dhcpd.hpp |  2 +-
 src/net/dhcp/dhcpd.cpp | 24 ++++++++++++------------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 0056bdd9c6..001734b4d8 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -129,7 +129,7 @@ namespace dhcp {
     IP4::addr netmask_, router_, dns_;
     uint32_t lease_, max_lease_;
     uint8_t pending_;               // How long to consider an offered address in the pending state (seconds)
-    std::vector<Record> records_;   // Temp - Instead of persistent storage:
+    std::vector<Record> records_;   // Temp - Instead of persistent storage
 
     bool valid_pool(IP4::addr start, IP4::addr end) const;
     void init_pool();
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 6ab998f349..2ab9b2420c 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -509,6 +509,10 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   std::memcpy(offer->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN); // uint8_t array - size 16, client hardware address
   std::memcpy(offer->sname, msg->sname, dhcp_packet_t::SNAME_LEN);  // Server host name or options - MAY
   std::memcpy(offer->file, msg->file, dhcp_packet_t::FILE_LEN);     // Client boot file name or options - MAY
+  offer->magic[0] =  99;
+  offer->magic[1] = 130;
+  offer->magic[2] =  83;
+  offer->magic[3] =  99;
 
   // OPTIONS
   dhcp_option_t* offer_opts = (dhcp_option_t*) (offer->options + 0);
@@ -794,6 +798,10 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   std::memcpy(ack->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
   std::memcpy(ack->sname, msg->sname, dhcp_packet_t::SNAME_LEN);  // Server host name or options - MAY
   std::memcpy(ack->file, msg->file, dhcp_packet_t::FILE_LEN);     // Client boot file name or options - MAY
+  ack->magic[0] =  99;
+  ack->magic[1] = 130;
+  ack->magic[2] =  83;
+  ack->magic[3] =  99;
 
   // OPTIONS
   dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
@@ -872,20 +880,12 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack->flags = msg->flags;
   ack->giaddr = msg->giaddr;
   std::memcpy(ack->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
-
-  printf("\n------------- OBS Memcopying chaddr in ack -------------\n");
-  printf("Msg->chaddr:\n");
-  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
-    printf("%u ", msg->chaddr[i]);
-  printf("\n");
-  printf("Ack->chaddr:\n");
-  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
-    printf("%u ", ack->chaddr[i]);
-  printf("\n");
-  printf("------------------------------------------------------\n");
-
   std::memcpy(ack->sname, msg->sname, dhcp_packet_t::SNAME_LEN);  // Server host name or options - MAY
   std::memcpy(ack->file, msg->file, dhcp_packet_t::FILE_LEN);     // Client boot file name or options - MAY
+  ack->magic[0] =  99;
+  ack->magic[1] = 130;
+  ack->magic[2] =  83;
+  ack->magic[3] =  99;
 
   // OPTIONS
   dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);

From a5e6c305d30dbf4ed79a3f4d388999294f17d2ca Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Thu, 23 Feb 2017 12:40:47 +0100
Subject: [PATCH 15/41] DHCP server: Lease time and time offset update

---
 src/net/dhcp/dhcpd.cpp | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 2ab9b2420c..76328bd39a 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -433,16 +433,6 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
 
 void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
-  // Validate any values here?
-  /* Magic cookie: First four octets of the options field
-  int first = msg->magic[0];
-  int second = msg->magic[1];
-  int third = msg->magic[2];
-  int fourth = msg->magic[3];
-  printf("\nMagic cookie: %d %d %d %d\n", first, second, third, fourth);*/
-
-  // Create DHCPOFFER reply
-
   // 4.3.1 and Table 3 in RFC 2131
   // Choose a network address
   // Choose an expiration time for the lease
@@ -585,11 +575,15 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->code = DHO_TIME_OFFSET;
   offer_opts->length = 4;
   auto l_start = record.lease_start();
+  offer_opts->val[0] = 0;
+  offer_opts->val[1] = 0;
+  offer_opts->val[2] = 0;
+  offer_opts->val[3] = 0;
   // TODO: CHANGED REVERSE ORDER:
-  offer_opts->val[0] = (l_start & 0xff000000) >> 24;
+  /*offer_opts->val[0] = (l_start & 0xff000000) >> 24;
   offer_opts->val[1] = (l_start & 0x00ff0000) >> 16;
   offer_opts->val[2] = (l_start & 0x0000ff00) >> 8;
-  offer_opts->val[3] = (l_start & 0x000000ff);
+  offer_opts->val[3] = (l_start & 0x000000ff);*/
   /*offer_opts->val[0] = (l_start & 0x000000ff);
   offer_opts->val[1] = (l_start & 0x0000ff00) >> 8;
   offer_opts->val[2] = (l_start & 0x00ff0000) >> 16;
@@ -899,10 +893,10 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts = (dhcp_option_t*) (ack->options + 3);             // 3 bytes filled in prior
   ack_opts->code = DHO_DHCP_LEASE_TIME;
   ack_opts->length = 4;
-  ack_opts->val[0] = (lease_ & 0x000000ff);
-  ack_opts->val[1] = (lease_ & 0x0000ff00) >> 8;
-  ack_opts->val[2] = (lease_ & 0x00ff0000) >> 16;
-  ack_opts->val[3] = (lease_ & 0xff000000) >> 24;
+  ack_opts->val[0] = (lease_ & 0xff000000) >> 24;
+  ack_opts->val[1] = (lease_ & 0x00ff0000) >> 16;
+  ack_opts->val[2] = (lease_ & 0x0000ff00) >> 8;
+  ack_opts->val[3] = (lease_ & 0x000000ff);
 
   // SERVER_IDENTIFIER (the server's network address(es))
   ack_opts = (dhcp_option_t*) (ack->options + 9);             // 9 bytes filled in prior

From 7b310fb607506280c17b91af074107d56371153c Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Thu, 23 Feb 2017 12:52:25 +0100
Subject: [PATCH 16/41] DHCP server integration test with dhclient begun

---
 .../dhcp/dhcpd_dhclient_linux/CMakeLists.txt  | 33 +++++++++++++++
 .../dhcp/dhcpd_dhclient_linux/README.md       |  3 ++
 .../dhcp/dhcpd_dhclient_linux/service.cpp     | 40 ++++++++++++++++++
 .../dhcp/dhcpd_dhclient_linux/test.py         | 42 +++++++++++++++++++
 .../dhcp/dhcpd_dhclient_linux/vm.json         |  6 +++
 5 files changed, 124 insertions(+)
 create mode 100644 test/net/integration/dhcp/dhcpd_dhclient_linux/CMakeLists.txt
 create mode 100644 test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
 create mode 100644 test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
 create mode 100644 test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
 create mode 100644 test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json

diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/CMakeLists.txt b/test/net/integration/dhcp/dhcpd_dhclient_linux/CMakeLists.txt
new file mode 100644
index 0000000000..f05eb7dc4e
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/CMakeLists.txt
@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 2.8.9)
+
+# IncludeOS install location
+if (NOT DEFINED ENV{INCLUDEOS_PREFIX})
+  set(ENV{INCLUDEOS_PREFIX} /usr/local)
+endif()
+
+set(CMAKE_TOOLCHAIN_FILE $ENV{INCLUDEOS_PREFIX}/includeos/i686-elf-toolchain.cmake)
+
+project(test_dhcp_server_dhclient)
+
+# Human-readable name of your service
+set(SERVICE_NAME "IncludeOS DHCP server test with Linux dhclient")
+
+# Name of your service binary
+set(BINARY       "test_dhcp_server_dhclient")
+
+# Maximum memory can be hard-coded into the binary
+set(MAX_MEM 128)
+
+# Source files to be linked with OS library parts to form bootable image
+set(SOURCES
+    service.cpp
+  )
+
+# DRIVERS / PLUGINS:
+
+set(DRIVERS
+  virtionet
+  )
+
+# include service build script
+include($ENV{INCLUDEOS_PREFIX}/includeos/service.cmake)
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md b/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
new file mode 100644
index 0000000000..c490cb9186
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
@@ -0,0 +1,3 @@
+# Test IncludeOS DHCP server with Linux dhclient
+
+Note:
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp b/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
new file mode 100644
index 0000000000..1840fbffaa
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
@@ -0,0 +1,40 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <service>
+#include <net/inet4>
+#include <net/dhcp/dhcpd.hpp>
+
+std::unique_ptr<net::dhcp::DHCPD> server;
+
+void Service::start(const std::string&)
+{
+  using namespace net;
+  using namespace dhcp;
+
+  // Server
+
+  auto& inet = Inet4::ifconfig<0>(
+    { 10,200,0,1 },     // IP
+    { 255,255,0,0 },    // Netmask
+    { 10,0,0,1 },       // Gateway
+    { 10,0,0,1 });      // DNS
+
+  IP4::addr pool_start{10,200,100,20};
+  IP4::addr pool_end{10,200,100,30};
+  server = std::make_unique<DHCPD>(inet.udp(), pool_start, pool_end, 120);
+}
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
new file mode 100644
index 0000000000..0d676729b5
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
@@ -0,0 +1,42 @@
+#! /usr/bin/env python
+
+import sys
+import os
+import time
+import subprocess
+
+includeos_src = os.environ.get('INCLUDEOS_SRC',
+                               os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))).split('/test')[0])
+sys.path.insert(0,includeos_src)
+
+from vmrunner import vmrunner
+import socket
+
+from vmrunner.prettify import color
+
+# Get an auto-created VM from the vmrunner
+vm = vmrunner.vms[0]
+
+ping_count = 3
+
+def DHCP_test(trigger_line):
+  print color.INFO("<Test.py>"),"Dhclient got IP"
+  ip_string = vm.readline()
+  print color.INFO("<Test.py>"), "Assigned address: ", ip_string
+  print color.INFO("<Test.py>"), "Trying to ping"
+  time.sleep(1)
+  try:
+    command = ["ping", ip_string.rstrip(), "-c", str(ping_count), "-i", "0.2"]
+    print color.DATA(" ".join(command))
+    print subprocess.check_output(command)
+    vm.exit(0,"<Test.py> Ping test passed. Process returned 0 exit status")
+  except Exception as e:
+    print color.FAIL("<Test.py> Ping FAILED Process threw exception:")
+    print e
+    return False
+
+# Add custom event-handler
+vm.on_output("Client 1 got IP from IncludeOS DHCP server", DHCP_test)
+
+# Boot the VM, taking a timeout as parameter
+vm.cmake().boot(20).clean()
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json b/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json
new file mode 100644
index 0000000000..d126a1c1cd
--- /dev/null
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json
@@ -0,0 +1,6 @@
+{
+  "image" : "test_dhcp_server_dhclient.img",
+  "net" : [{"device" : "virtio", "mac" : "c0:01:0a:00:00:2a"}],
+  "cpu" : "host",
+  "mem" : 128
+}

From f44c3da5d1c6ab50451cc4190dc5f5c659b302fe Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Thu, 23 Feb 2017 13:32:15 +0100
Subject: [PATCH 17/41] DHCP client: lease_time byte order fix

---
 src/net/dhcp/dh4client.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index dd8b176f72..b8f6d9a314 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -200,7 +200,11 @@ namespace net
     opt = get_option(dhcp->options, DHO_DHCP_LEASE_TIME);
     if (opt->code == DHO_DHCP_LEASE_TIME)
     {
-      memcpy(&this->lease_time, opt->val, sizeof(this->lease_time));
+      this->lease_time = (((uint32_t) opt->val[0]) << 24 |
+        ((uint32_t) opt->val[1]) << 16 |
+        ((uint32_t) opt->val[2]) <<  8 |
+        ((uint32_t) opt->val[3]) <<  0);
+
       if (console_spam)
         MYINFO("LEASE TIME: \t%u mins", this->lease_time / 60);
     }

From 889737e545f67af1d422b5994043134be2cb766d Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Thu, 23 Feb 2017 13:32:50 +0100
Subject: [PATCH 18/41] DHCP server: Removed unnecessary comments and printing

---
 src/net/dhcp/dhcpd.cpp | 35 +++--------------------------------
 1 file changed, 3 insertions(+), 32 deletions(-)

diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 76328bd39a..b17e89e74f 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -552,15 +552,10 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts = (dhcp_option_t*) (offer->options + 21);            // 21 bytes filled in prior
   offer_opts->code = DHO_DHCP_LEASE_TIME;
   offer_opts->length = 4;
-  // TODO: CHANGED REVERSE ORDER:
   offer_opts->val[0] = (lease_ & 0xff000000) >> 24;
   offer_opts->val[1] = (lease_ & 0x00ff0000) >> 16;
   offer_opts->val[2] = (lease_ & 0x0000ff00) >> 8;
   offer_opts->val[3] = (lease_ & 0x000000ff);
-  /*offer_opts->val[0] = (lease_ & 0x000000ff);
-  offer_opts->val[1] = (lease_ & 0x0000ff00) >> 8;
-  offer_opts->val[2] = (lease_ & 0x00ff0000) >> 16;
-  offer_opts->val[3] = (lease_ & 0xff000000) >> 24;*/
 
   // MESSAGE (SHOULD)
   // No error message (only in DHCPNAK)
@@ -574,20 +569,10 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts = (dhcp_option_t*) (offer->options + 30);
   offer_opts->code = DHO_TIME_OFFSET;
   offer_opts->length = 4;
-  auto l_start = record.lease_start();
   offer_opts->val[0] = 0;
   offer_opts->val[1] = 0;
   offer_opts->val[2] = 0;
   offer_opts->val[3] = 0;
-  // TODO: CHANGED REVERSE ORDER:
-  /*offer_opts->val[0] = (l_start & 0xff000000) >> 24;
-  offer_opts->val[1] = (l_start & 0x00ff0000) >> 16;
-  offer_opts->val[2] = (l_start & 0x0000ff00) >> 8;
-  offer_opts->val[3] = (l_start & 0x000000ff);*/
-  /*offer_opts->val[0] = (l_start & 0x000000ff);
-  offer_opts->val[1] = (l_start & 0x0000ff00) >> 8;
-  offer_opts->val[2] = (l_start & 0x00ff0000) >> 16;
-  offer_opts->val[3] = (l_start & 0xff000000) >> 24;*/
 
   // 2 DOMAIN_NAME_SERVERS
   offer_opts = (dhcp_option_t*) (offer->options + 36);
@@ -602,22 +587,17 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts = (dhcp_option_t*) (offer->options + 42);
   offer_opts->code = DHO_HOST_NAME;
   auto host_name_length = 0;
-  printf("Host name from client:\n");
   const dhcp_option_t* host_name = get_option(opts, DHO_HOST_NAME);
   if (host_name->code == DHO_HOST_NAME) {
     host_name_length = host_name->length;
     offer_opts->length = host_name_length;
-    for (int i = 0; i < host_name->length; i++) {
-      printf("%u ", host_name->val[i]);
+    for (int i = 0; i < host_name->length; i++)
       offer_opts->val[i] = host_name->val[i];
-    }
   } else {
-    printf("Fant ikke DHO_HOST_NAME fra klient\n");
     host_name_length = 1;
     offer_opts->length = 1;
     offer_opts->val[0] = 0;
   }
-  printf("\n");
 
   // 4 DOMAIN_NAME - blank for now
   offer_opts = (dhcp_option_t*) (offer->options + 44 + host_name_length);
@@ -634,23 +614,12 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[1] = broadcast.part(2);
   offer_opts->val[2] = broadcast.part(1);
   offer_opts->val[3] = broadcast.part(0);
-  /* 5 BROADCAST_ADDRESS
-  offer_opts = (dhcp_option_t*) (offer->options + 48 + host_name_length);
-  offer_opts->code = DHO_BROADCAST_ADDRESS;
-  offer_opts->length = 4;
-  offer_opts->val[0] = 0;
-  offer_opts->val[1] = 0;
-  offer_opts->val[2] = 0;
-  offer_opts->val[3] = 0;*/
 
   // END
   offer_opts = (dhcp_option_t*) (offer->options + 53 + host_name_length);    // 30 bytes filled in prior
   offer_opts->code   = DHO_END;
   offer_opts->length = 0;
 
-  printf("\n------------------- Offer from Server -------------------\n");
-  print(offer, offer_opts);
-
   // The client should include the maximum DHCP message size option to let the server know how large the server may
   // make its DHCP messages. The parameters returned to a client may still exceed the space allocated to options in a
   // DHCP message. In this case, two additional options flags (which must appear in the options field of the message)
@@ -702,6 +671,8 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // RECORD
   add_record(record);
 
+  printf("Sending DHCPOFFER\n");
+
   // If the giaddr field in a DHCP message from a client is non-zero, the server
   // sends any return messages to the DHCP server port on the BOOTP relay agent
   // whose address appears in giaddr

From 3cc626b9031c1f93fe1ad51b3862b466146aac42 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Sun, 26 Feb 2017 17:11:12 +0100
Subject: [PATCH 19/41] DHCP server and dhclient (linux) integration test:
 Test.py testing DHCP message communication and pinging dhclient's given IP

---
 .../dhcp/dhcpd_dhclient_linux/service.cpp     |  5 +-
 .../dhcp/dhcpd_dhclient_linux/test.py         | 76 +++++++++++++++++--
 2 files changed, 73 insertions(+), 8 deletions(-)
 mode change 100644 => 100755 test/net/integration/dhcp/dhcpd_dhclient_linux/test.py

diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp b/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
index 1840fbffaa..bf264b714e 100644
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
@@ -18,6 +18,7 @@
 #include <service>
 #include <net/inet4>
 #include <net/dhcp/dhcpd.hpp>
+#include <list>
 
 std::unique_ptr<net::dhcp::DHCPD> server;
 
@@ -36,5 +37,7 @@ void Service::start(const std::string&)
 
   IP4::addr pool_start{10,200,100,20};
   IP4::addr pool_end{10,200,100,30};
-  server = std::make_unique<DHCPD>(inet.udp(), pool_start, pool_end, 120);
+  server = std::make_unique<DHCPD>(inet.udp(), pool_start, pool_end);
+
+  INFO("<Service>", "Service started");
 }
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
old mode 100644
new mode 100755
index 0d676729b5..e4f8db535f
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
@@ -17,26 +17,88 @@
 # Get an auto-created VM from the vmrunner
 vm = vmrunner.vms[0]
 
+num_messages = 0
+ping_passed = False
 ping_count = 3
 
-def DHCP_test(trigger_line):
-  print color.INFO("<Test.py>"),"Dhclient got IP"
-  ip_string = vm.readline()
-  print color.INFO("<Test.py>"), "Assigned address: ", ip_string
+# create_bridge.sh has to be run prior
+
+def check_dhclient_output(output):
+  global num_messages
+
+  if "DHCPDISCOVER on bridge43 to 255.255.255.255 port 67" in output:
+    num_messages += 1
+
+  if "DHCPOFFER of 10.200.100.20 from 10.200.0.1" in output:
+    num_messages += 1
+
+  if "DHCPREQUEST of 10.200.100.20 on bridge43 to 255.255.255.255 port 67" in output:
+    num_messages += 1
+
+  if "DHCPACK of 10.200.100.20 from 10.200.0.1" in output:
+    num_messages += 1
+
+  if num_messages != 4:
+    print color.FAIL("<Test.py> DHCP process FAILED")
+
+def ping_test(ip):
+  global ping_passed
+  print color.INFO("<Test.py>"), "Assigned address: ", ip
   print color.INFO("<Test.py>"), "Trying to ping"
   time.sleep(1)
   try:
-    command = ["ping", ip_string.rstrip(), "-c", str(ping_count), "-i", "0.2"]
+    command = ["ping", ip, "-c", str(ping_count), "-i", "0.2"]
     print color.DATA(" ".join(command))
     print subprocess.check_output(command)
-    vm.exit(0,"<Test.py> Ping test passed. Process returned 0 exit status")
+    ping_passed = True
   except Exception as e:
     print color.FAIL("<Test.py> Ping FAILED Process threw exception:")
     print e
     return False
 
+def run_dhclient(trigger_line):
+  route_output = subprocess.check_output(["route"])
+
+  if "10.200.0.0" not in route_output:
+    subprocess.call(["route", "add", "-net", "10.200.0.0", "netmask", "255.255.0.0", "dev", "bridge43"])
+    print color.INFO("<Test.py>"), "Route added to bridge43, 10.200.0.0"
+
+  print color.INFO("<Test.py>"), "Running dhclient"
+
+  #"--no-pid" ? (Protect against registering lease in /var/lib/dhcp/dhclient.leases?)
+  try:
+    dhclient = subprocess.Popen(
+        ["dhclient", "bridge43", "-4", "-n", "-v"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    process_output, _ = dhclient.communicate()
+    print color.INFO("<dhclient>")
+    print process_output
+    check_dhclient_output(process_output)
+  except (OSError, subprocess.CalledProcessError) as exception:
+    print color.FAIL("<Test.py> dhclient FAILED threw exception:")
+    print str(exception)
+    return False
+
+  ping_test("10.200.100.20")
+
+  # Remove leases-file
+  print color.INFO("<Test.py>"), "Removing /var/lib/dhcp/dhclient.leases"
+  subprocess.call(["rm", "/var/lib/dhcp/dhclient.leases"])
+
+  if ping_passed and num_messages == 4:
+    vm.exit(0,"<Test.py> DHCP process and ping test completed successfully. Process returned 0 exit status")
+
+  # If run release, bridge43 is taken down and running the create_bridge.sh script again doesn't fix it
+  # release_output = subprocess.check_output(["dhclient", "bridge43", "-r", "-v"])
+  # print "Release output: ", release_output
+
+  # Kill dhclient - also removes bridge
+  # kill_output = subprocess.check_output(["dhclient", "bridge43", "-x", "-v"])
+
 # Add custom event-handler
-vm.on_output("Client 1 got IP from IncludeOS DHCP server", DHCP_test)
+vm.on_output("Service started", run_dhclient)
 
 # Boot the VM, taking a timeout as parameter
 vm.cmake().boot(20).clean()

From 4ac9d74a8184aa15e03ab7c3da980575bd27d20f Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Sun, 26 Feb 2017 17:33:18 +0100
Subject: [PATCH 20/41] DHCP server: Record and DHCPD cleanup

---
 api/net/dhcp/dhcpd.hpp  |   3 -
 api/net/dhcp/record.hpp |  16 +---
 src/net/dhcp/dhcpd.cpp  | 175 ++++++++++++----------------------------
 3 files changed, 57 insertions(+), 137 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 001734b4d8..069e421e13 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -153,9 +153,6 @@ namespace dhcp {
     IP4::addr inc_addr(IP4::addr ip) const
     { return IP4::addr{htonl(ntohl(ip.whole) + 1)}; }
     bool on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) const;
-
-    // Remove
-    void print(const dhcp_packet_t* msg, const dhcp_option_t* opts);
   };
 
 } // < namespace dhcp
diff --git a/api/net/dhcp/record.hpp b/api/net/dhcp/record.hpp
index 4fc5a45341..222a74349a 100644
--- a/api/net/dhcp/record.hpp
+++ b/api/net/dhcp/record.hpp
@@ -24,8 +24,8 @@ namespace dhcp {
 
   enum class Status {
     AVAILABLE,
-    OFFERED,    // IP has been offered to another client and is awaiting a DHCPREQUEST for updated status
-    RELEASED,   // Previously allocated IP to a client (reuse)
+    OFFERED,      // IP has been offered to another client and is awaiting a DHCPREQUEST for updated status
+    //RELEASED,   // Previously allocated IP to a client (reuse)
     IN_USE
   };
 
@@ -34,7 +34,6 @@ namespace dhcp {
   class Record {
 
   public:
-    // TODO Remove or use?
     using byte_seq = std::vector<uint8_t>;
 
     Record() {}
@@ -70,8 +69,6 @@ namespace dhcp {
     void set_status(Status status)
     { status_ = status; }
 
-    /*void set_lease_start(uint32_t lease_start)
-    { lease_start_ = lease_start; }*/
     void set_lease_start(int64_t lease_start)
     { lease_start_ = lease_start; }
 
@@ -81,14 +78,10 @@ namespace dhcp {
   private:
     byte_seq client_id_;
     IP4::addr ip_;
-
-    // Because of reuse (client gets its previous IP) ?
     Status status_;
 
-    //std::vector<Option> options_;
-
-
-    // TODO Save client's config parameters as well?
+    // TODO Save client's config parameters as well - if using Status::RELEASED
+    // std::vector<Option> options_;
 
     // TODO
     // T1 and T2
@@ -102,7 +95,6 @@ namespace dhcp {
     // A client MAY choose to renew or extend its lease prior to T1. The server MAY choose to extend the client's lease according to
     // policy set by the network administrator. The server SHOULD return T1 and T2, and their values SHOULD be adjusted from their
     // original values to take account of the time remaining on the lease
-    //uint32_t lease_start_;
     int64_t lease_start_;           // For now: RTC::now()
     uint32_t lease_duration_;
   };
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index b17e89e74f..941e6a56b2 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -125,7 +125,7 @@ void DHCPD::listen() {
     const char* data, size_t) {
 
     if (port == DHCP_CLIENT_PORT) {
-      printf("Received data from DHCP client\n");
+      //printf("Received data from DHCP client\n");
 
       // Message
       const dhcp_packet_t* msg = (dhcp_packet_t*) data;
@@ -146,18 +146,15 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   switch (opts->val[0]) {
     case DHCPDISCOVER:
-      printf("\nDISCOVER\n");
-
-      //print(msg, opts);
-
+      //printf("\nDISCOVER\n");
       offer(msg, opts);
       break;
     case DHCPREQUEST:
-      printf("\nREQUEST\n");
+      //printf("\nREQUEST\n");
       handle_request(msg, opts);
       break;
     case DHCPDECLINE:
-      printf("\nDECLINE\n");
+      //printf("\nDECLINE\n");
 
       // A client has discovered that the suggested network address is already in use.
       // The server must mark the network address as not available and should notify the network admin
@@ -172,7 +169,7 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       update_pool(get_requested_ip_in_opts(opts), Status::IN_USE);    // In use - possible config problem
       break;
     case DHCPRELEASE:
-      printf("\nRELEASE\n");
+      //printf("\nRELEASE\n");
 
       // Mark the network address as not allocated anymore
       // Should retain a record of the client's initialization parameters for possible reuse
@@ -181,11 +178,19 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       ridx = get_record_idx_from_ip(msg->ciaddr);
 
       if (ridx not_eq -1)
-        records_.at(ridx).set_status(Status::RELEASED);       // Another Status? Status::RELEASED f.ex.
-      update_pool(msg->ciaddr, Status::RELEASED);             // TODO: What about reuse - is this IP available for other clients
+        records_.erase(records_.begin() + ridx);
+      update_pool(msg->ciaddr, Status::AVAILABLE);
+      // TODO
+      // Or: Keep config parameters (record) and set status to RELEASED f.ex. instead (but need to handle this -
+      // when a new discover (DHCPDISCOVER after DHCPRELEASE) is received - look through records and find record
+      // with client id):
+      /*if (ridx not_eq -1)
+        records_.at(ridx).set_status(Status::RELEASED);
+      update_pool(msg->ciaddr, Status::RELEASED);
+      */
       break;
     case DHCPINFORM:            // ? Not specified in RFC 1533
-      printf("\nINFORM\n");
+      //printf("\nINFORM\n");
 
       // Send a DHCPACK directly to the address given in the ciaddr field of the DHCPINFORM message.
       // Do not send a lease expiration time to the client and do not fill in yiaddr
@@ -213,13 +218,12 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
   if (opt->code == DHO_DHCP_SERVER_IDENTIFIER) {
     // Then this is a response to a DHCPOFFER message
 
-    printf("REQUEST from client is a response to a DHCPOFFER and has a SERVER IDENTIFIER\n");
+    //printf("REQUEST from client is a response to a DHCPOFFER and has a SERVER IDENTIFIER\n");
 
     IP4::addr sid{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
-    printf("Server identifier for chosen server: %s\n", sid.to_string().c_str());
 
     if (sid not_eq server_id()) {
-      printf("The client has not chosen this server\n");
+      //printf("The client has not chosen this server\n");
 
       int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
       if (ridx != -1) {
@@ -231,13 +235,12 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
     }
 
     // SERVER IDENTIFIER == THIS SERVER'S ID
-    printf("SERVER IDENTIFIER matches this server\n");
+    //printf("Server identifier matches this server\n");
 
     int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
 
     if (ridx not_eq -1) {   // if record exists
-
-      printf("A RECORD FOR THIS CLIENT ALREADY EXISTS\n");
+      //printf("A record for this client already exists\n");
 
       auto& record = records_.at(ridx);
       // if ciaddr is zero and requested IP address is filled in with the yiaddr value from the chosen DHCPOFFER
@@ -249,7 +252,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
         // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
         // timeout mechanism to decide when to reuse an offered address.
 
-        printf("THIS IS A SELECTING REQUEST FROM THE CLIENT - will construct DHCPACK\n");
+        //printf("This is a selecting request from the client - will construct DHCPACK\n");
 
         // RECORD
         record.set_status(Status::IN_USE);
@@ -262,8 +265,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
         return;
       }
 
-      printf("CIADDR IS NOT ZERO OR THE RECORD'S IP DOES NOT MATCH THE REQUESTED IP IN OPTS FROM CLIENT - the client probably has already gotten an IP from the server - dhcpnak?\n");
-
+      //printf("CIADDR IS NOT ZERO OR THE RECORD'S IP DOES NOT MATCH THE REQUESTED IP IN OPTS FROM CLIENT - the client probably has already gotten an IP from the server - dhcpnak\n");
       // ELSE ciaddr is not zero or record's ip is not the same as the requested ip in the request
       // TODO: nak() or silent return?
       nak(msg);
@@ -272,7 +274,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
 
     // Else a record with this client id doesn't exist
     // TODO: Remain silent or send a DHCPNAK?
-    printf("RECORD FOR THIS CLIENT does not exist - sending DHCPNAK\n");
+    //printf("RECORD FOR THIS CLIENT does not exist - sending DHCPNAK\n");
     nak(msg);
     return;
   }
@@ -280,13 +282,13 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
   // Else server identifier is not filled in and this is not a response to a DHCPOFFER message
   // This is a request to verify or extend an existing lease
 
-  printf("SERVER IDENTIFIER IS NOT FILLED IN and this is not a response to a DHCPOFFER, but a request to verify or extend an existing lease\n");
+  //printf("Server identifier is NOT filled in and this is a request to verify or extend an existing lease\n");
 
   verify_or_extend_lease(msg, opts);
 
   // 4.3.2
 
-  // CA. OK Selecting
+  // Selecting
   // Server identifier filled in, ciaddr is zero, requested IP address is filled in with the yiaddr
   // value from the chosen DHCPOFFER
   // Note: Servers may not receive a specific DHCPREQUEST from which they can decide whether or not the
@@ -294,7 +296,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
   // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
   // timeout mechanism to decide when to reuse an offered address.
 
-  // CA. OK Init-reboot
+  // Init-reboot
   // If server identifier is not filled in and requested IP address option is filled in with
   // client's notion of its previously assigned address.
   // ciaddr must be zero.
@@ -331,11 +333,7 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
   // Server should check ciaddr for correctness before replying to the DHCPREQUEST.
   // A server may extend a client's lease only if it has local administrative authority to do so.
 
-  // Create DHCPACK
-  // Any configuration parameters in the DHCPACK should not conflict with those in the earlier DHCPOFFER
-  // to which the client is responding
-
-  // See Table 3 and 4.3.2
+  // See Table 3 and 4.3.2 RFC 2131
 }
 
 void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
@@ -352,7 +350,7 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     // Then the client is seeking to verify a previously allocated, cached configuration
     // Client state: INIT-REBOOT
 
-    printf("Client is in init-reboot state\n");
+    //printf("Client is in init-reboot state\n");
 
     // 1. Check if on correct network
     // Server should send a DHCPNAK if the client is on the wrong network
@@ -360,7 +358,7 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     // the local subnet mask or remote subnet mask (if giaddr is not zero) to requested IP address value doesn't
     // match reality), then the server should send a DHCPNAK message to the client.
     if (not on_correct_network(msg->giaddr, opts)) {
-      printf("Client is on the wrong network\n");
+      //printf("Client is on the wrong network\n");
 
       // TODO: Update pool? Erase record?
       update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
@@ -388,7 +386,6 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
 
     // Send DHCPACK?
     request_ack(msg, opts);
-
     return;
   }
 
@@ -420,19 +417,20 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     update_pool(record.ip(), Status::IN_USE);
 
     request_ack(msg, opts);
-/*
-    if (msg->giaddr != IP4::addr{0})    // The message has been broadcasted to the gateway and the ack should be broadcasted
-                                        // The client is then in the REBINDING state
-      request_ack(msg, opts, IP4::ADDR_ANY);    // broadcast_address()  // RFC: 0xffffffff
-    else    // Set send_to IP because we know that we want to send to ciaddr (unicast)
-            // The client is then in the RENEWING state
-      request_ack(msg, opts, msg->ciaddr);
-*/
   }
 }
 
 void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
+  // May occur that the client doesn't get our offers and then we don't want to
+  // exhaust our pool
+  int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
+  if (ridx not_eq -1) {
+    //printf("Getting DHCPDISCOVER from a client that already exists/has a record\n");
+    //printf("Status of the lease: %d\n", records_.at(i).status());
+    return;
+  }
+
   // 4.3.1 and Table 3 in RFC 2131
   // Choose a network address
   // Choose an expiration time for the lease
@@ -486,7 +484,12 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   }
 
   if (not ok) {
-    printf("No IP is available - sending DHCPNAK\n");
+    //printf("No IP is available - sending DHCPNAK and at the same time cleaning up OFFERED IPs that have not changed status\n");
+
+    // Can then loop through all the records and erasing the ones that have status OFFERED
+    for (size_t i = 0; i < records_.size(); i++)
+      if (records_.at(i).status() == Status::OFFERED)
+        records_.erase(records_.begin() + i);
 
     // If get here: No available IP and send:
     nak(msg);   // record has not been added to the records_ vector so OK
@@ -647,31 +650,26 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   //op.set_netmask(netmask_);
   //record.options_.push_back(op);
   // RECORD: Add configuration options
-  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
+  /*const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
   if (opt->code == DHO_DHCP_PARAMETER_REQUEST_LIST) {
-
     printf("PARAMETER REQUEST LIST:\n");
     for (int i = 0; i < opt->length; i++) {
       printf("Option: %u\n", opt->val[i]);
-
       // Return the requested options to the client, f.ex. dns
-
       // Possible to avoid switch case?
-
       //Alt.
       //Option op;
       //op.set_dns(dns_);
       //op.set_netmask(netmask_);
       //record.options_.push_back(op);
-
     }
     printf("\n");
-  }
+  }*/
 
   // RECORD
   add_record(record);
 
-  printf("Sending DHCPOFFER\n");
+  //printf("Sending DHCPOFFER\n");
 
   // If the giaddr field in a DHCP message from a client is non-zero, the server
   // sends any return messages to the DHCP server port on the BOOTP relay agent
@@ -708,16 +706,9 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
   // TODO: Send the message to the client's hardware address:
   // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
-
-  // Send the DHCPOFFER
-  // Broadcast the DHCPOFFER to the client because the client haven't got an IP address yet
-  // socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-
-  // TODO
-
   // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
   // include that list in all subsequent messages.
   // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
@@ -779,22 +770,18 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // And more options
 
   // TODO Options requested by the client:
-  const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
+  /*const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
   if (opt->code == DHO_DHCP_PARAMETER_REQUEST_LIST) {
-
     printf("PARAMETER REQUEST LIST IN DHCPINFORM MESSAGE:\n");
     for (int i = 0; i < opt->length; i++) {
       printf("Option: %u\n", opt->val[i]);
-
       // Return the requested options to the client, f.ex. dns
-
       // Possible to avoid switch case?
-
     }
     printf("\n");
-  }
+  }*/
 
-  printf("Sending an inform ack to ciaddr: %s\n", msg->ciaddr.to_string().c_str());
+  //printf("Sending an inform ack to ciaddr: %s\n", msg->ciaddr.to_string().c_str());
 
   // Send the DHCPACK
   // Unicast to DHCPINFORM message's ciaddr field
@@ -885,7 +872,7 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->code   = DHO_END;
   ack_opts->length = 0;
 
-  printf("Sending a request ack\n");
+  //printf("Sending a request ack\n");
 
   // If the giaddr field in a DHCP message from a client is non-zero, the server
   // sends any return messages to the DHCP server port on the BOOTP relay agent
@@ -922,10 +909,6 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
   // TODO: Send the message to the client's hardware address:
   // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
-
-  // Send the DHCPACK
-  // Broadcast
-  // socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 void DHCPD::nak(const dhcp_packet_t* msg) {
@@ -978,7 +961,7 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   nak_opts->code = DHO_END;
   nak_opts->length = 0;
 
-  printf("Sending DHCPNAK\n");
+  //printf("Sending DHCPNAK\n");
 
   // Send the DHCPNAK
   // Broadcast
@@ -1006,7 +989,7 @@ Record::byte_seq DHCPD::get_client_id(const uint8_t* chaddr, const dhcp_option_t
 
   for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
     client_id.push_back(chaddr[i]);
-  printf("\n- - - - - OBS Client identifier isn't given and client id is chaddr - - - - -\n");
+
   return client_id;
 }
 
@@ -1055,55 +1038,3 @@ bool DHCPD::on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) cons
 
   return false;
 }
-
-// Temporary
-void DHCPD::print(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-  printf("Printing content of incoming dhcp message:\n");
-
-  printf("OP: %u\n", msg->op);
-  printf("HTYPE: %u\n", msg->htype);
-  printf("HLEN: %u\n", msg->hlen);
-  printf("HOPS: %u\n", msg->hops);
-  printf("XID: %u\n", msg->xid);
-  printf("SECS: %u\n", msg->secs);
-  printf("FLAGS: %u\n", msg->flags);
-  printf("CIADDR (IP4::addr): %s\n", msg->ciaddr.to_string().c_str());
-  printf("YIADDR (IP4::addr): %s\n", msg->yiaddr.to_string().c_str());
-  printf("SIADDR (IP4::addr): %s\n", msg->siaddr.to_string().c_str());
-  printf("GIADDR (IP4::addr): %s\n", msg->giaddr.to_string().c_str());
-
-  printf("\nCHADDR:\n");
-  for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
-    printf("%u ", msg->chaddr[i]);
-  printf("\n");
-
-  printf("\nSNAME:\n");
-  for (int i = 0; i < dhcp_packet_t::SNAME_LEN; i++)
-    printf("%u ", msg->sname[i]);
-  printf("\n");
-
-  printf("\nFILE:\n");
-  for (int i = 0; i < dhcp_packet_t::FILE_LEN; i++)
-    printf("%u ", msg->file[i]);
-  printf("\n");
-
-  printf("\nMAGIC:\n");
-  for (int i = 0; i < 4; i++)
-    printf("%u ", msg->magic[i]);
-  printf("\n");
-
-  printf("\nOPTIONS:\n");
-  for (int i = 0; i < DHCP_VEND_LEN; i++)
-    printf("%u ", msg->options[i]);
-  printf("\n");
-
-  // Opts
-
-  printf("\nOptions->code: %d\n", opts->code);
-  printf("\nOptions->length: %d\n", opts->length);
-
-  printf("\nOptions->val:\n");
-  for (size_t i = 0; i < opts->length; i++)
-    printf("%d ", opts->val[i]);
-  printf("\n");
-}

From c9c247756bded4013a33939fb839a5469f2f785d Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Sun, 26 Feb 2017 19:00:58 +0100
Subject: [PATCH 21/41] DHCP server and dhclient (linux) integration test:
 README.md update

---
 test/net/integration/dhcp/dhcpd_dhclient_linux/README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md b/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
index c490cb9186..82de1238f2 100644
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
@@ -1,3 +1,7 @@
 # Test IncludeOS DHCP server with Linux dhclient
 
 Note:
+Works on a linux distributions that have dhclient and route.
+$INCLUDEOS_PREFIX/includeos/scripts/create_bridge.sh must be run prior to the test.
+
+Run test: sudo -E ./test.py

From 443b9f68fb6ed64000fff4e17ad27251a3492055 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Sun, 26 Feb 2017 20:21:59 +0100
Subject: [PATCH 22/41] DHCP: Copyright and noexcept update

---
 api/net/dhcp/dh4client.hpp                    |  2 +-
 api/net/dhcp/dhcp4.hpp                        |  2 +-
 api/net/dhcp/dhcpd.hpp                        | 30 +++++++++----------
 api/net/dhcp/record.hpp                       | 14 ++++-----
 src/net/dhcp/dh4client.cpp                    |  2 +-
 src/net/dhcp/dhcpd.cpp                        |  8 ++---
 test/net/integration/dhcp/dhcpd/service.cpp   |  2 +-
 .../dhcp/dhcpd_dhclient_linux/service.cpp     |  2 +-
 8 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/api/net/dhcp/dh4client.hpp b/api/net/dhcp/dh4client.hpp
index 9637e7c34a..c2e87eaa6d 100644
--- a/api/net/dhcp/dh4client.hpp
+++ b/api/net/dhcp/dh4client.hpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2015-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/api/net/dhcp/dhcp4.hpp b/api/net/dhcp/dhcp4.hpp
index 15fec587ba..1a2ef87385 100644
--- a/api/net/dhcp/dhcp4.hpp
+++ b/api/net/dhcp/dhcp4.hpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2015-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 069e421e13..38b9d5ee56 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2016-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -42,37 +42,37 @@ namespace dhcp {
 
     // Getters
 
-    IP4::addr server_id() const
+    IP4::addr server_id() const noexcept
     { return server_id_; }
 
-    IP4::addr netmask() const
+    IP4::addr netmask() const noexcept
     { return netmask_; }
 
-    IP4::addr router() const
+    IP4::addr router() const noexcept
     { return router_; }
 
-    IP4::addr dns() const
+    IP4::addr dns() const noexcept
     { return dns_; }
 
-    uint32_t lease() const
+    uint32_t lease() const noexcept
     { return lease_; }
 
-    uint32_t max_lease() const
+    uint32_t max_lease() const noexcept
     { return max_lease_; }
 
-    uint8_t pending() const
+    uint8_t pending() const noexcept
     { return pending_; }
 
-    IP4::addr pool_start() const
+    IP4::addr pool_start() const noexcept
     { return pool_start_; }
 
-    IP4::addr pool_end() const
+    IP4::addr pool_end() const noexcept
     { return pool_end_; }
 
-    const std::map<IP4::addr, Status>& pool() const
+    const std::map<IP4::addr, Status>& pool() const noexcept
     { return pool_; }
 
-    const std::vector<Record>& records() const
+    const std::vector<Record>& records() const noexcept
     { return records_; }
 
     // Setters
@@ -101,11 +101,11 @@ namespace dhcp {
     void add_record(const Record& record)
     { records_.push_back(record); }
 
-    bool record_exists(const Record::byte_seq& client_id) const;
+    bool record_exists(const Record::byte_seq& client_id) const noexcept;
 
-    int get_record_idx(const Record::byte_seq& client_id) const;
+    int get_record_idx(const Record::byte_seq& client_id) const noexcept;
 
-    int get_record_idx_from_ip(IP4::addr ip) const;
+    int get_record_idx_from_ip(IP4::addr ip) const noexcept;
 
     IP4::addr broadcast_address() const noexcept
     { return server_id_ | ( ~ netmask_); }
diff --git a/api/net/dhcp/record.hpp b/api/net/dhcp/record.hpp
index 222a74349a..d58e10c675 100644
--- a/api/net/dhcp/record.hpp
+++ b/api/net/dhcp/record.hpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2016-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -43,19 +43,19 @@ namespace dhcp {
 
     // Getters
 
-    const byte_seq& client_id() const
+    const byte_seq& client_id() const noexcept
     { return client_id_; }
 
-    const IP4::addr& ip() const
+    const IP4::addr& ip() const noexcept
     { return ip_; }
 
-    const Status& status() const
+    const Status& status() const noexcept
     { return status_; }
 
-    uint32_t lease_start() const
+    uint32_t lease_start() const noexcept
     { return lease_start_; }
 
-    uint32_t lease_duration() const
+    uint32_t lease_duration() const noexcept
     { return lease_duration_; }
 
     // Setters
@@ -63,7 +63,7 @@ namespace dhcp {
     void set_client_id(const byte_seq& client_id)
     { client_id_ = client_id; }
 
-    void set_ip(const IP4::addr ip)
+    void set_ip(IP4::addr ip)
     { ip_ = ip; }
 
     void set_status(Status status)
diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index b8f6d9a314..15a1953be2 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2015-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 941e6a56b2..4f09db641d 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2016-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -42,7 +42,7 @@ DHCPD::DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
   listen();
 }
 
-bool DHCPD::record_exists(const Record::byte_seq& client_id) const {
+bool DHCPD::record_exists(const Record::byte_seq& client_id) const noexcept {
   for (auto& rec : records_)
     if (rec.client_id() == client_id)
       return true;
@@ -50,7 +50,7 @@ bool DHCPD::record_exists(const Record::byte_seq& client_id) const {
   return false;
 }
 
-int DHCPD::get_record_idx(const Record::byte_seq& client_id) const {
+int DHCPD::get_record_idx(const Record::byte_seq& client_id) const noexcept {
   for (size_t i = 0; i < records_.size(); i++)
     if (records_.at(i).client_id() == client_id)
       return i;
@@ -58,7 +58,7 @@ int DHCPD::get_record_idx(const Record::byte_seq& client_id) const {
   return -1;
 }
 
-int DHCPD::get_record_idx_from_ip(IP4::addr ip) const {
+int DHCPD::get_record_idx_from_ip(IP4::addr ip) const noexcept {
   for (size_t i = 0; i < records_.size(); i++)
     if (records_.at(i).ip() == ip)
       return i;
diff --git a/test/net/integration/dhcp/dhcpd/service.cpp b/test/net/integration/dhcp/dhcpd/service.cpp
index 5e087fd4d9..4a1250a751 100644
--- a/test/net/integration/dhcp/dhcpd/service.cpp
+++ b/test/net/integration/dhcp/dhcpd/service.cpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2016-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp b/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
index bf264b714e..21866a3772 100644
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
@@ -1,6 +1,6 @@
 // This file is a part of the IncludeOS unikernel - www.includeos.org
 //
-// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// Copyright 2016-2017 Oslo and Akershus University College of Applied Sciences
 // and Alfred Bratterud
 //
 // Licensed under the Apache License, Version 2.0 (the "License");

From 0e82bc162db4f4be478a7b346d25f7d5e073d703 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Sun, 26 Feb 2017 20:49:52 +0100
Subject: [PATCH 23/41] dh4client: xid (random session id) now based on
 uniform_int_distribution, not time

---
 src/net/dhcp/dh4client.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index 15a1953be2..46d36bc33d 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -24,6 +24,8 @@
 #include <os> // OS::micros_since_boot()
 #include <debug>
 
+#include <random>
+
 namespace net
 {
   inline dhcp_option_t* conv_option(uint8_t* option)
@@ -72,7 +74,11 @@ namespace net
     });
 
     // create a random session ID
-    this->xid = OS::micros_since_boot() & 0xFFFFFFFF;
+    std::random_device rd;  // Will be used to obtain a seed for the random number engine
+    std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
+    std::uniform_int_distribution<> dis(std::numeric_limits<uint32_t>::min(), std::numeric_limits<uint32_t>::max());
+    this->xid = dis(gen);
+
     if (console_spam)
       MYINFO("Negotiating IP-address (xid=%u)", xid);
 

From 029aa9d4a4d589f24ab781fde33b37fe699ab3e1 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 27 Feb 2017 11:27:05 +0100
Subject: [PATCH 24/41] DHCP server, client, integration test: Cleanup

---
 api/net/dhcp/dhcpd.hpp                        |  43 +-
 api/net/dhcp/record.hpp                       |  11 +-
 src/net/dhcp/dh4client.cpp                    |   1 -
 src/net/dhcp/dhcpd.cpp                        | 502 +++++-------------
 .../dhcp/dhcpd_dhclient_linux/test.py         |  10 -
 5 files changed, 145 insertions(+), 422 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 38b9d5ee56..cf5703931f 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -40,6 +40,21 @@ namespace dhcp {
     DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
       uint32_t lease = DEFAULT_LEASE, uint32_t max_lease = DEFAULT_MAX_LEASE, uint8_t pending = DEFAULT_PENDING);
 
+    void add_record(const Record& record)
+    { records_.push_back(record); }
+
+    bool record_exists(const Record::byte_seq& client_id) const noexcept;
+
+    int get_record_idx(const Record::byte_seq& client_id) const noexcept;
+
+    int get_record_idx_from_ip(IP4::addr ip) const noexcept;
+
+    IP4::addr broadcast_address() const noexcept
+    { return server_id_ | ( ~ netmask_); }
+
+    IP4::addr network_address(IP4::addr ip) const noexcept  // x.x.x.0
+    { return ip & netmask_; }
+
     // Getters
 
     IP4::addr server_id() const noexcept
@@ -98,28 +113,7 @@ namespace dhcp {
     void set_pending(uint8_t pending)
     { pending_ = pending; }
 
-    void add_record(const Record& record)
-    { records_.push_back(record); }
-
-    bool record_exists(const Record::byte_seq& client_id) const noexcept;
-
-    int get_record_idx(const Record::byte_seq& client_id) const noexcept;
-
-    int get_record_idx_from_ip(IP4::addr ip) const noexcept;
-
-    IP4::addr broadcast_address() const noexcept
-    { return server_id_ | ( ~ netmask_); }
-
-    IP4::addr network_address(IP4::addr ip) const noexcept  // x.x.x.0
-    { return ip & netmask_; }
-
   private:
-
-    /* A DHCP server can have many Scopes
-        Each with its own pool, name, subnet mask (determines the subnet for a specific IP address),
-        lease duration values, options for assignment to clients like DNS, Gateway (router IP address) +
-    */
-
     UDP::Stack& stack_;
     UDPSocket& socket_;
     IP4::addr pool_start_, pool_end_;
@@ -141,9 +135,9 @@ namespace dhcp {
     void handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void offer(const dhcp_packet_t* msg, const dhcp_option_t* opts);
-    void inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
+    void inform_ack(const dhcp_packet_t* msg);
     void request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
-    void nak(const dhcp_packet_t* msg/*, const dhcp_option_t* opts*/);
+    void nak(const dhcp_packet_t* msg);
 
     const dhcp_option_t* get_option(const dhcp_option_t* opts, int code) const;
     Record::byte_seq get_client_id(const uint8_t* chaddr, const dhcp_option_t* opts) const;
@@ -153,6 +147,9 @@ namespace dhcp {
     IP4::addr inc_addr(IP4::addr ip) const
     { return IP4::addr{htonl(ntohl(ip.whole) + 1)}; }
     bool on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) const;
+
+    void clear_offered_ip(IP4::addr ip);
+    void clear_offered_ips();
   };
 
 } // < namespace dhcp
diff --git a/api/net/dhcp/record.hpp b/api/net/dhcp/record.hpp
index d58e10c675..31882551b8 100644
--- a/api/net/dhcp/record.hpp
+++ b/api/net/dhcp/record.hpp
@@ -29,8 +29,7 @@ namespace dhcp {
     IN_USE
   };
 
-  // Temp - Instead of database (persistent storage):
-
+  // Temp - Instead of database (persistent storage)
   class Record {
 
   public:
@@ -79,11 +78,13 @@ namespace dhcp {
     byte_seq client_id_;
     IP4::addr ip_;
     Status status_;
+    int64_t lease_start_;           // For now: RTC::now()
+    uint32_t lease_duration_;
 
-    // TODO Save client's config parameters as well - if using Status::RELEASED
+    // TODO
+    // Save client's config parameters as well - if using Status::RELEASED
     // std::vector<Option> options_;
 
-    // TODO
     // T1 and T2
     // Client T1: The time at which the client enters the RENEWING state and attempts to contact the server that originally issued the
     // client's network address.
@@ -95,8 +96,6 @@ namespace dhcp {
     // A client MAY choose to renew or extend its lease prior to T1. The server MAY choose to extend the client's lease according to
     // policy set by the network administrator. The server SHOULD return T1 and T2, and their values SHOULD be adjusted from their
     // original values to take account of the time remaining on the lease
-    int64_t lease_start_;           // For now: RTC::now()
-    uint32_t lease_duration_;
   };
 
 } // < namespace dhcp
diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index 46d36bc33d..d7b215181a 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -21,7 +21,6 @@
 
 #include <net/dhcp/dh4client.hpp>
 #include <net/dhcp/dhcp4.hpp>
-#include <os> // OS::micros_since_boot()
 #include <debug>
 
 #include <random>
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 4f09db641d..e9962e13d4 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -18,8 +18,6 @@
 #include <net/dhcp/dhcpd.hpp>
 #include <rtc>
 
-#include <os>
-
 using namespace net;
 using namespace dhcp;
 
@@ -43,26 +41,26 @@ DHCPD::DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
 }
 
 bool DHCPD::record_exists(const Record::byte_seq& client_id) const noexcept {
-  for (auto& rec : records_)
+  for (auto& rec : records_) {
     if (rec.client_id() == client_id)
       return true;
-
+  }
   return false;
 }
 
 int DHCPD::get_record_idx(const Record::byte_seq& client_id) const noexcept {
-  for (size_t i = 0; i < records_.size(); i++)
+  for (size_t i = 0; i < records_.size(); i++) {
     if (records_.at(i).client_id() == client_id)
       return i;
-
+  }
   return -1;
 }
 
 int DHCPD::get_record_idx_from_ip(IP4::addr ip) const noexcept {
-  for (size_t i = 0; i < records_.size(); i++)
+  for (size_t i = 0; i < records_.size(); i++) {
     if (records_.at(i).ip() == ip)
       return i;
-
+  }
   return -1;
 }
 
@@ -110,7 +108,7 @@ void DHCPD::init_pool() {
     pool_.emplace(std::make_pair(start, Status::AVAILABLE));
     start = inc_addr(start);
   }
-  // Incl. pool_end_ IP:
+  // Including pool_end_ IP:
   pool_.emplace(std::make_pair(pool_end_, Status::AVAILABLE));
 }
 
@@ -125,14 +123,10 @@ void DHCPD::listen() {
     const char* data, size_t) {
 
     if (port == DHCP_CLIENT_PORT) {
-      //printf("Received data from DHCP client\n");
-
       // Message
       const dhcp_packet_t* msg = (dhcp_packet_t*) data;
-
       // Options
       const dhcp_option_t* opt = (dhcp_option_t*) msg->options;
-
       // Find out what kind of DHCP message this is
       resolve(msg, opt);
     }
@@ -142,89 +136,60 @@ void DHCPD::listen() {
 void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   int ridx;
 
-  // TODO: If we have a record on this client already, reuse IP - but only relevant when get a REQUEST? (handle_request())
-
   switch (opts->val[0]) {
     case DHCPDISCOVER:
-      //printf("\nDISCOVER\n");
       offer(msg, opts);
       break;
     case DHCPREQUEST:
-      //printf("\nREQUEST\n");
       handle_request(msg, opts);
       break;
     case DHCPDECLINE:
-      //printf("\nDECLINE\n");
-
       // A client has discovered that the suggested network address is already in use.
       // The server must mark the network address as not available and should notify the network admin
       // of a possible configuration problem - TODO
 
       ridx = get_record_idx(get_client_id(msg->chaddr, opts));
-
-      // TODO
       // Erase record if exists because client hasn't got a valid IP
       if (ridx not_eq -1)
         records_.erase(records_.begin() + ridx);
       update_pool(get_requested_ip_in_opts(opts), Status::IN_USE);    // In use - possible config problem
       break;
     case DHCPRELEASE:
-      //printf("\nRELEASE\n");
-
       // Mark the network address as not allocated anymore
       // Should retain a record of the client's initialization parameters for possible reuse
       // in response to subsequent requests from the client
-
       ridx = get_record_idx_from_ip(msg->ciaddr);
-
       if (ridx not_eq -1)
         records_.erase(records_.begin() + ridx);
       update_pool(msg->ciaddr, Status::AVAILABLE);
-      // TODO
+      break;
+
       // Or: Keep config parameters (record) and set status to RELEASED f.ex. instead (but need to handle this -
       // when a new discover (DHCPDISCOVER after DHCPRELEASE) is received - look through records and find record
-      // with client id):
-      /*if (ridx not_eq -1)
-        records_.at(ridx).set_status(Status::RELEASED);
-      update_pool(msg->ciaddr, Status::RELEASED);
-      */
-      break;
-    case DHCPINFORM:            // ? Not specified in RFC 1533
-      //printf("\nINFORM\n");
+      // with client id)
+      // if (ridx not_eq -1)
+      //    records_.at(ridx).set_status(Status::RELEASED);
+      // update_pool(msg->ciaddr, Status::RELEASED);
 
-      // Send a DHCPACK directly to the address given in the ciaddr field of the DHCPINFORM message.
-      // Do not send a lease expiration time to the client and do not fill in yiaddr
-      inform_ack(msg, opts);
+    case DHCPINFORM:
+      inform_ack(msg);
       break;
   }
 }
 
 void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-
   // Client could be:
-  // 1. Requesting offered parameters from one server and implicitly declining offers from all others
-  // 2. Confirming correctness of previously allocated address after, e.g., system reboot
+  // 1. Responding to a DHCPOFFER message from a server
+  // 2. Verifying a previously allocated IP address
   // 3. Extending the lease on a particular network address
-  // /
-  // 1. Client is responding to a DHCPOFFER message from a server
-  // 2. Client is verifying a previously allocated IP address
-  // 3. Client is extending the lease on a network address
 
-  // RFC 2131 PAGE 31 (pdf)
-
-  // CHECKING SERVER IDENTIFIER
+  // Checking server identifier
   const dhcp_option_t* opt = get_option(opts, DHO_DHCP_SERVER_IDENTIFIER);
   // Server identifier from client:
-  if (opt->code == DHO_DHCP_SERVER_IDENTIFIER) {
-    // Then this is a response to a DHCPOFFER message
-
-    //printf("REQUEST from client is a response to a DHCPOFFER and has a SERVER IDENTIFIER\n");
-
+  if (opt->code == DHO_DHCP_SERVER_IDENTIFIER) {  // Then this is a response to a DHCPOFFER message
     IP4::addr sid{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
 
-    if (sid not_eq server_id()) {
-      //printf("The client has not chosen this server\n");
-
+    if (sid not_eq server_id()) { // The client has not chosen this server
       int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
       if (ridx != -1) {
         // Free up the IP address - the client has declined our offer
@@ -234,106 +199,40 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
       return;
     }
 
-    // SERVER IDENTIFIER == THIS SERVER'S ID
-    //printf("Server identifier matches this server\n");
+    // Server identifier == this server's ID
 
     int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
 
-    if (ridx not_eq -1) {   // if record exists
-      //printf("A record for this client already exists\n");
-
+    if (ridx not_eq -1) { // A record for this client already exists
       auto& record = records_.at(ridx);
-      // if ciaddr is zero and requested IP address is filled in with the yiaddr value from the chosen DHCPOFFER
+
+      // If ciaddr is zero and requested IP address is filled in with the yiaddr value from the chosen DHCPOFFER:
       // Client state: SELECTING
       if (msg->ciaddr == IP4::addr{0} and get_requested_ip_in_opts(opts) == record.ip()) {
-        // Then the DHCPREQUEST from the client is a selecting request
-        // Note: Servers may not receive a specific DHCPREQUEST from which they can decide whether or not the
-        // client has accepted the offer. ... Servers are free to reuse offered network addresses in response to
-        // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
-        // timeout mechanism to decide when to reuse an offered address.
-
-        //printf("This is a selecting request from the client - will construct DHCPACK\n");
-
         // RECORD
         record.set_status(Status::IN_USE);
-
         // POOL
         update_pool(record.ip(), Status::IN_USE);
-
-        // SEND DHCPACK
+        // Send DHCPACK
         request_ack(msg, opts);
         return;
       }
 
-      //printf("CIADDR IS NOT ZERO OR THE RECORD'S IP DOES NOT MATCH THE REQUESTED IP IN OPTS FROM CLIENT - the client probably has already gotten an IP from the server - dhcpnak\n");
-      // ELSE ciaddr is not zero or record's ip is not the same as the requested ip in the request
+      // Else ciaddr is not zero or record's ip is not the same as the requested ip in the request
       // TODO: nak() or silent return?
       nak(msg);
       return;
     }
 
     // Else a record with this client id doesn't exist
-    // TODO: Remain silent or send a DHCPNAK?
-    //printf("RECORD FOR THIS CLIENT does not exist - sending DHCPNAK\n");
+    // TODO: nak() or silent return?
     nak(msg);
     return;
   }
 
-  // Else server identifier is not filled in and this is not a response to a DHCPOFFER message
-  // This is a request to verify or extend an existing lease
-
-  //printf("Server identifier is NOT filled in and this is a request to verify or extend an existing lease\n");
-
+  // Else server identifier is not filled in and this is not a response to a DHCPOFFER message, but
+  // a request to verify or extend an existing lease
   verify_or_extend_lease(msg, opts);
-
-  // 4.3.2
-
-  // Selecting
-  // Server identifier filled in, ciaddr is zero, requested IP address is filled in with the yiaddr
-  // value from the chosen DHCPOFFER
-  // Note: Servers may not receive a specific DHCPREQUEST from which they can decide whether or not the
-  // client has accepted the offer. ... Servers are free to reuse offered network addresses in response to
-  // subsequent requests. Servers should not reuse offered addresses and may use an implementation-specific
-  // timeout mechanism to decide when to reuse an offered address.
-
-  // Init-reboot
-  // If server identifier is not filled in and requested IP address option is filled in with
-  // client's notion of its previously assigned address.
-  // ciaddr must be zero.
-  // The client is seeking to verify a previously allocated, cached configuration.
-  // Server should send a DHCPNAK message to the client if the requested IP address is incorrect or is
-  // on the wrong network.
-  // Determining whether the client is on the correct network: Examine the contents of giaddr + the
-  // requested IP address option + a database lookup. If the server detects that the client is on the wrong
-  // net (i.e., the result of applying the local subnet mask or remote subnet mask (if giaddr is not zero) to
-  // requested IP address option value doesn't match reality), then the server should send a DHCPNAK message
-  // to the client.
-  // If the network is correct: Server should check if the client's notion of its IP address is correct. If not,
-  // the server should send a DHCPNAK message to the client.
-  // If the server has no record of the client, it must remain silent and may output a warning to the network admin.
-  // If giaddr is 0x0 in the DHCPREQUEST message, the client is on the same subnet as the server. The server must
-  // broadcast the DHCPNAK message to the 0xffffffff broadcast address because teh client may not have a correct
-  // network address or subnet mask, and the client may not be answering ARP requests.
-  // If giaddr is set in the DHCPREQUEST, the client is on a different subnet. The server must set the broadcast bit
-  // in the DHCPNAK - the client may not have a correct network address or subnet mask, and the client may not be
-  // answering ARP requests.
-
-  // Renewing
-  // If server identifier and requested IP address option is not filled in
-  // and ciaddr is filled in with client's IP address
-  // Then the client is completely configured and is trying to extend its lease.
-  // This message will be unicast. Because giaddr is therefore not filled in, the server
-  // will trust the value in ciaddr and use it when replying to the client.
-
-  // Rebinding
-  // If server identifier and requested IP address option is not filled in
-  // and ciaddr is filled in with client's IP address
-  // Then the client is completely configured and is trying to extend its lease.
-  // This message must be broadcast to the 0xffffffff IP broadcast address.
-  // Server should check ciaddr for correctness before replying to the DHCPREQUEST.
-  // A server may extend a client's lease only if it has local administrative authority to do so.
-
-  // See Table 3 and 4.3.2 RFC 2131
 }
 
 void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
@@ -345,38 +244,24 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     return;
   }
 
-  if (ridx not_eq -1 and msg->ciaddr == IP4::addr{0}) {
-
+  if (msg->ciaddr == IP4::addr{0}) {
     // Then the client is seeking to verify a previously allocated, cached configuration
     // Client state: INIT-REBOOT
 
-    //printf("Client is in init-reboot state\n");
-
-    // 1. Check if on correct network
+    // 1. (Before or in the if statement) Check if on correct network
     // Server should send a DHCPNAK if the client is on the wrong network
-    // If the server detects that the client is on the wrong net (i.e., the result of applying
-    // the local subnet mask or remote subnet mask (if giaddr is not zero) to requested IP address value doesn't
+    // If the server detects that the client is on the wrong net (i.e., the result of applying the local
+    // subnet mask or remote subnet mask (if giaddr is not zero) to requested IP address value doesn't
     // match reality), then the server should send a DHCPNAK message to the client.
-    if (not on_correct_network(msg->giaddr, opts)) {
-      //printf("Client is on the wrong network\n");
-
-      // TODO: Update pool? Erase record?
-      update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
-      records_.erase(records_.begin() + ridx);
-      nak(msg);
-      return;
-    }
-
-    // 2. If is on correct network: Check if the client's notion of IP is correct
-    if (get_requested_ip_in_opts(opts) not_eq records_.at(ridx).ip()) {
-      // If not correct IP: DHCPNAK + update pool and remove record
+    // 2. (After or in the if statement) If client is on correct network: Check if the client's notion of IP is correct
+    if ((not on_correct_network(msg->giaddr, opts)) or (get_requested_ip_in_opts(opts) not_eq records_.at(ridx).ip())) {
+      // Updating pool and erasing record
       update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
       records_.erase(records_.begin() + ridx);
       nak(msg);
       return;
     }
 
-    // TODO
     // Else everything is OK and we want to verify the client's configuration
     // Update pool and record too
     auto& record = records_.at(ridx);
@@ -384,13 +269,12 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     record.set_lease_start(RTC::now());
     update_pool(record.ip(), Status::IN_USE);
 
-    // Send DHCPACK?
+    // Sending DHCPACK
     request_ack(msg, opts);
     return;
   }
 
   if (get_requested_ip_in_opts(opts) == IP4::addr{0} and msg->ciaddr not_eq IP4::addr{0}) {
-
     // Client is in RENEWING state
     // The client is then completely configured and is trying to extend its lease.
     // This message will be unicast, so no relay agents will be involved in its transmission.
@@ -401,48 +285,37 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     // message regardless.
 
     // Same if the client is in REBINDING state so check the giaddr (gateway IP address) to find out if message
-    // has been unicast to the server or not? If zero: Unicast. If non-zero: Not unicast ?
+    // has been unicast to the server or not. If zero: Unicast. If non-zero: Broadcast.
     // REBINDING: The client is completely configured and is trying to extend its lease. This message MUST
     // be broadcast to the 0xffffffff IP broadcast address. The server should check ciaddr for correctness
     // before replying to the DHCPREQUEST
 
-    // TABLE 4 PAGE 33 IN RFC 2131 - Fields in client message from client in different state
+    // Table 4 page 33 in RFC 2131 - Fields in client message from client in different state
 
-    // Record exists
     // Extend the lease or not - should send a DHCPACK regardless
-    // Update record and pool?
+    // Update record and pool
     auto& record = records_.at(ridx);
     record.set_status(Status::IN_USE);
     record.set_lease_start(RTC::now());
     update_pool(record.ip(), Status::IN_USE);
 
+    // Send DHCPACK
     request_ack(msg, opts);
   }
 }
 
 void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-
-  // May occur that the client doesn't get our offers and then we don't want to
+  // It may occur that the client doesn't get our offers and then we don't want to
   // exhaust our pool
   int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
-  if (ridx not_eq -1) {
-    //printf("Getting DHCPDISCOVER from a client that already exists/has a record\n");
-    //printf("Status of the lease: %d\n", records_.at(i).status());
+  if (ridx not_eq -1)
     return;
-  }
-
-  // 4.3.1 and Table 3 in RFC 2131
-  // Choose a network address
-  // Choose an expiration time for the lease
-  // +
 
   const size_t packetlen = sizeof(dhcp_packet_t);
   char packet[packetlen];
 
-  // If we want to offer this client an IP address:
-  // RECORD
+  // If we want to offer this client an IP address: Create a RECORD
   Record record;
-
   // Keep client identifier (index into database)
   record.set_client_id(get_client_id(msg->chaddr, opts));
 
@@ -457,10 +330,8 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer->secs = 0;
   offer->ciaddr = IP4::addr{0};
 
+  // yiaddr - IP address offered to the client from the pool
   bool ok = false;
-
-  // yiaddr
-  // IP address offered to client - Available from the pool
   for (auto& entry : pool_) {
     if (entry.second == Status::AVAILABLE) {
       entry.second = Status::OFFERED;
@@ -478,21 +349,13 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       record.set_status(Status::OFFERED);
       record.set_lease_start(RTC::now());
       record.set_lease_duration(lease_);
-
       break;
     }
   }
-
-  if (not ok) {
-    //printf("No IP is available - sending DHCPNAK and at the same time cleaning up OFFERED IPs that have not changed status\n");
-
-    // Can then loop through all the records and erasing the ones that have status OFFERED
-    for (size_t i = 0; i < records_.size(); i++)
-      if (records_.at(i).status() == Status::OFFERED)
-        records_.erase(records_.begin() + i);
-
-    // If get here: No available IP and send:
-    nak(msg);   // record has not been added to the records_ vector so OK
+  if (not ok) { // Then no IP is available - sending DHCPNAK
+    // Clear offered ips that have not been confirmed - Maybe use pending value instead
+    clear_offered_ips();
+    nak(msg);   // Record has not been added to the records_ vector so OK
     return;
   }
 
@@ -510,16 +373,16 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // OPTIONS
   dhcp_option_t* offer_opts = (dhcp_option_t*) (offer->options + 0);
 
-  // In DHCPOFFER Options:
+  // DHCPOFFER Options:
   // Requested IP address                                         MUST NOT
-  // ! IP address lease time                                      MUST
+  // IP address lease time                                        MUST
   // Use file/sname fields                                        MAY
   // DHCP message type                                            DHCPOFFER
   // Parameter request list (DHO_DHCP_PARAMETER_REQUEST_LIST)     MUST NOT
-  // ! Message (DHO_DHCP_MESSAGE)                                 SHOULD
+  // Message (DHO_DHCP_MESSAGE)                                   SHOULD
   // Client identifier                                            MUST NOT - note RFC 6842
   // Vendor class identifier                                      MAY
-  // ! Server identifier                                          MUST
+  // Server identifier                                            MUST
   // Maximum message size                                         MUST NOT
   // All others                                                   MAY
 
@@ -529,11 +392,11 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[0] = DHCPOFFER;
 
   // SERVER_IDENTIFIER (the server's network address(es))
-  offer_opts = (dhcp_option_t*) (offer->options + 3);         // 3 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 3);     // 3 bytes filled in prior
   add_server_id(offer_opts);
 
   // SUBNET_MASK
-  offer_opts = (dhcp_option_t*) (offer->options + 9);         // 9 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 9);     // 9 bytes filled in prior
   offer_opts->code = DHO_SUBNET_MASK;
   offer_opts->length = 4;
   offer_opts->val[0] = netmask_.part(3);
@@ -542,7 +405,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = netmask_.part(0);
 
   // ROUTERS
-  offer_opts = (dhcp_option_t*) (offer->options + 15);            // 15 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 15);      // 15 bytes filled in prior
   offer_opts->code = DHO_ROUTERS;
   offer_opts->length = 4;
   offer_opts->val[0] = router_.part(3);
@@ -552,7 +415,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   // LEASE_TIME
   // Time in units of seconds (32-bit unsigned integer / 4 uint8_t)
-  offer_opts = (dhcp_option_t*) (offer->options + 21);            // 21 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 21);      // 21 bytes filled in prior
   offer_opts->code = DHO_DHCP_LEASE_TIME;
   offer_opts->length = 4;
   offer_opts->val[0] = (lease_ & 0xff000000) >> 24;
@@ -562,13 +425,12 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   // MESSAGE (SHOULD)
   // No error message (only in DHCPNAK)
-  offer_opts = (dhcp_option_t*) (offer->options + 27);            // 27 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 27);      // 27 bytes filled in prior
   offer_opts->code = DHO_DHCP_MESSAGE;
-  offer_opts->length = 1;                                 // No error message (only in DHCPNAK)
+  offer_opts->length = 1;
   offer_opts->val[0] = 0;
 
-  // Testing on ubuntu - Adding options:
-  // 1 TIME_OFFSET
+  // TIME_OFFSET
   offer_opts = (dhcp_option_t*) (offer->options + 30);
   offer_opts->code = DHO_TIME_OFFSET;
   offer_opts->length = 4;
@@ -577,7 +439,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[2] = 0;
   offer_opts->val[3] = 0;
 
-  // 2 DOMAIN_NAME_SERVERS
+  // DOMAIN_NAME_SERVERS
   offer_opts = (dhcp_option_t*) (offer->options + 36);
   offer_opts->code = DHO_DOMAIN_NAME_SERVERS;
   offer_opts->length = 4;
@@ -586,30 +448,8 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[2] = dns_.part(1);
   offer_opts->val[3] = dns_.part(0);
 
-  // 3 HOST_NAME - responding with client's host name (but not specified in rfc?)
+  // BROADCAST_ADDRESS
   offer_opts = (dhcp_option_t*) (offer->options + 42);
-  offer_opts->code = DHO_HOST_NAME;
-  auto host_name_length = 0;
-  const dhcp_option_t* host_name = get_option(opts, DHO_HOST_NAME);
-  if (host_name->code == DHO_HOST_NAME) {
-    host_name_length = host_name->length;
-    offer_opts->length = host_name_length;
-    for (int i = 0; i < host_name->length; i++)
-      offer_opts->val[i] = host_name->val[i];
-  } else {
-    host_name_length = 1;
-    offer_opts->length = 1;
-    offer_opts->val[0] = 0;
-  }
-
-  // 4 DOMAIN_NAME - blank for now
-  offer_opts = (dhcp_option_t*) (offer->options + 44 + host_name_length);
-  offer_opts->code = DHO_DOMAIN_NAME;
-  offer_opts->length = 1;
-  offer_opts->val[0] = 0;
-
-  // 5 BROADCAST_ADDRESS -
-  offer_opts = (dhcp_option_t*) (offer->options + 47 + host_name_length);
   offer_opts->code = DHO_BROADCAST_ADDRESS;
   offer_opts->length = 4;
   auto broadcast = broadcast_address();
@@ -619,107 +459,41 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = broadcast.part(0);
 
   // END
-  offer_opts = (dhcp_option_t*) (offer->options + 53 + host_name_length);    // 30 bytes filled in prior
+  offer_opts = (dhcp_option_t*) (offer->options + 48);
   offer_opts->code   = DHO_END;
   offer_opts->length = 0;
 
-  // The client should include the maximum DHCP message size option to let the server know how large the server may
-  // make its DHCP messages. The parameters returned to a client may still exceed the space allocated to options in a
-  // DHCP message. In this case, two additional options flags (which must appear in the options field of the message)
-  // indicate that the file and sname fields are to be used for options.
-
-  // The client may suggest values for the network address and lease time in the DHCPDISCOVER message. The client may
-  // include the requested IP address option to suggest that a particular IP address be assigned, and may include the
-  // IP address lease time option to suggest the lease time it would like. Other options representing hints at configuration
-  // parameters are allowed in a DHCPDISCOVER or DHCPREQUEST message. However, additional options may be ignored by
-  // servers, and multiple servers may, therefore, not return identical values for some options.
-  // The requested IP address options is to be filled in only in a DHCPREQUEST message when the client is verifying network
-  // parameters obtained previously. The client fills in the ciaddr field only when correctly configured with an IP address
-  // in BOUND, RENEWING or REBINDING state.
-
-  // THE DHCPDISCOVER MESSAGE (msg) MAY include options that suggest values for the network address and lease duration
-  // TODO
-  // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
-  // include that list in all subsequent messages.
-  // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
-  // DHCPOFFER message to which the client is responding.
-  // -> When giving the client what it has requested, store these parameters in the Record created
-  //Alt.
-  //Option op;
-  //op.set_dns(dns_);
-  //op.set_netmask(netmask_);
-  //record.options_.push_back(op);
-  // RECORD: Add configuration options
-  /*const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
-  if (opt->code == DHO_DHCP_PARAMETER_REQUEST_LIST) {
-    printf("PARAMETER REQUEST LIST:\n");
-    for (int i = 0; i < opt->length; i++) {
-      printf("Option: %u\n", opt->val[i]);
-      // Return the requested options to the client, f.ex. dns
-      // Possible to avoid switch case?
-      //Alt.
-      //Option op;
-      //op.set_dns(dns_);
-      //op.set_netmask(netmask_);
-      //record.options_.push_back(op);
-    }
-    printf("\n");
-  }*/
-
   // RECORD
   add_record(record);
 
-  //printf("Sending DHCPOFFER\n");
-
-  // If the giaddr field in a DHCP message from a client is non-zero, the server
-  // sends any return messages to the DHCP server port on the BOOTP relay agent
-  // whose address appears in giaddr
-  // DHCP server port is port 67
-  // DHCP client port is port 68
+  // If the giaddr field in a DHCP message from a client is non-zero, the server sends any return
+  // messages to the DHCP server port on the BOOTP relay agent whose address appears in giaddr
   if (msg->giaddr != IP4::addr{0}) {
     socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, packetlen);
     return;
   }
-
-  // msg->giaddr is zero
-  // If the giaddr field is zero and the ciaddr field is non-zero, then the server
-  // unicasts DHCPOFFER and DHCPACK messages to the address in ciaddr
+  // If the giaddr field is zero and the ciaddr field is non-zero, then the server unicasts
+  // DHCPOFFER and DHCPACK messages to the address in ciaddr
   if (msg->ciaddr != IP4::addr{0}) {
     socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
     return;
   }
-
-  // msg->giaddr and msg->ciaddr is zero
-  // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in
-  // flags field) is set, then the server broadcasts DHCPOFFER and DHCPACK messsages
-  // to 0xffffffff
+  // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in flags field) is set,
+  // then the server broadcasts DHCPOFFER and DHCPACK messsages to 0xffffffff
   std::bitset<8> bits(msg->flags);
   if (bits[7] == 1) {
     socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
     return;
   }
-
-  // the broadcast bit is not set
-  // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the
-  // server unicasts DHCPOFFER and DHCPACK messages to the client's hardware address
-  // and yiaddr address
+  // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the server unicasts
+  // DHCPOFFER and DHCPACK messages to the client's hardware address and yiaddr address
   socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
   // TODO: Send the message to the client's hardware address:
   // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
-void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-  // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
-  // include that list in all subsequent messages.
-  // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
-  // DHCPOFFER message to which the client is responding.
-
-  // Send a DHCPACK directly to the address given in the ciaddr field of the DHCPINFORM message.
-  // Do not send a lease expiration time to the client and do not fill in yiaddr
-
-  // NB: Option IP address lease time MUST NOT
-
-  // The client has obtained a network address through som other means (e.g., manual configuration)
+void DHCPD::inform_ack(const dhcp_packet_t* msg) {
+  // The client has obtained a network address through some other means (e.g., manual configuration)
   // and may use a DHCPINFORM request message to obtain other local configuration parameters.
   // Servers receiving a DHCPINFORM message construct a DHCPACK message with any local configuration
   // parameters appropriate for the client without:
@@ -730,10 +504,9 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // The servers should unicast the DHCPACK reply to the address given in the ciaddr field of the
   // DHCPINFORM message.
 
-  // The server should check the network address in the DHCPINFORM message for consistency, but
-  // must not check for an existing lease. The server forms a DHCPACK message containing the
-  // configuration parameters for the requesting client and sends the DHCPACK message directly to
-  // the client.
+  // The server should check the network address in the DHCPINFORM message for consistency, but must not
+  // check for an existing lease. The server forms a DHCPACK message containing the configuration parameters
+  // for the requesting client and sends the DHCPACK message directly to the client.
 
   const size_t packetlen = sizeof(dhcp_packet_t);
   char packet[packetlen];
@@ -767,49 +540,21 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->length = 1;
   ack_opts->val[0] = DHCPACK;
 
-  // And more options
-
-  // TODO Options requested by the client:
-  /*const dhcp_option_t* opt = get_option(opts, DHO_DHCP_PARAMETER_REQUEST_LIST);
-  if (opt->code == DHO_DHCP_PARAMETER_REQUEST_LIST) {
-    printf("PARAMETER REQUEST LIST IN DHCPINFORM MESSAGE:\n");
-    for (int i = 0; i < opt->length; i++) {
-      printf("Option: %u\n", opt->val[i]);
-      // Return the requested options to the client, f.ex. dns
-      // Possible to avoid switch case?
-    }
-    printf("\n");
-  }*/
-
-  //printf("Sending an inform ack to ciaddr: %s\n", msg->ciaddr.to_string().c_str());
+  // TODO Add options requested by the client
 
-  // Send the DHCPACK
-  // Unicast to DHCPINFORM message's ciaddr field
+  // Send the DHCPACK - Unicast to DHCPINFORM message's ciaddr field
   socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-
   // If the client included a list of requested parameters in a DHCPDISCOVER message, it MUST
   // include that list in all subsequent messages.
+
   // Any configuration parameters in the DHCPACK message SHOULD NOT conflict with those in the earlier
   // DHCPOFFER message to which the client is responding.
-
-  // NB: Option IP address lease time MUST
-
   // DHCPACK: Server to client with configuration parameters, including committed network address
 
   // Table 3 RFC 2131 DHCPACK
-  // op           BOOTREPLY
-  // htype        From "Assigned Numbers" RFC
-  // hlen         Hardware address length in octets
-  // hops         0
-  // xid          xid from client DHCPREQUEST
-  // etc.
-
-  // The client broadcasts a DHCPREQUEST message that MUST include the server identifier option
-  // to indicate which server it has selected, and that MAY include other options specifying desired configuration values.
-  // The requested IP address option MUST be set to the value of yiaddr in the DHCPOFFER message from the server.
 
   const size_t packetlen = sizeof(dhcp_packet_t);
   char packet[packetlen];
@@ -847,8 +592,8 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->length = 1;
   ack_opts->val[0] = DHCPACK;
 
-  // LEASE_TIME
-  ack_opts = (dhcp_option_t*) (ack->options + 3);             // 3 bytes filled in prior
+  // LEASE_TIME (MUST)
+  ack_opts = (dhcp_option_t*) (ack->options + 3);     // 3 bytes filled in prior
   ack_opts->code = DHO_DHCP_LEASE_TIME;
   ack_opts->length = 4;
   ack_opts->val[0] = (lease_ & 0xff000000) >> 24;
@@ -857,64 +602,50 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->val[3] = (lease_ & 0x000000ff);
 
   // SERVER_IDENTIFIER (the server's network address(es))
-  ack_opts = (dhcp_option_t*) (ack->options + 9);             // 9 bytes filled in prior
+  ack_opts = (dhcp_option_t*) (ack->options + 9);     // 9 bytes filled in prior
   add_server_id(ack_opts);
 
   // MESSAGE (SHOULD)
   // No error message (only in DHCPNAK)
-  ack_opts = (dhcp_option_t*) (ack->options + 15);            // 15 bytes filled in prior
+  ack_opts = (dhcp_option_t*) (ack->options + 15);    // 15 bytes filled in prior
   ack_opts->code = DHO_DHCP_MESSAGE;
   ack_opts->length = 1;
   ack_opts->val[0] = 0;
 
   // END
-  ack_opts = (dhcp_option_t*) (ack->options + 18);            // 18 bytes filled in prior
+  ack_opts = (dhcp_option_t*) (ack->options + 18);    // 18 bytes filled in prior
   ack_opts->code   = DHO_END;
   ack_opts->length = 0;
 
-  //printf("Sending a request ack\n");
-
-  // If the giaddr field in a DHCP message from a client is non-zero, the server
-  // sends any return messages to the DHCP server port on the BOOTP relay agent
-  // whose address appears in giaddr
-  // DHCP server port is port 67
-  // DHCP client port is port 68
+  // If the giaddr field in a DHCP message from a client is non-zero, the server sends any return
+  // messages to the DHCP server port on the BOOTP relay agent whose address appears in giaddr
   if (msg->giaddr != IP4::addr{0}) {
     socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, packetlen);
     return;
   }
-
-  // msg->giaddr is zero
-  // If the giaddr field is zero and the ciaddr field is non-zero, then the server
-  // unicasts DHCPOFFER and DHCPACK messages to the address in ciaddr
+  // If the giaddr field is zero and the ciaddr field is non-zero, then the server unicasts
+  // DHCPOFFER and DHCPACK messages to the address in ciaddr
   if (msg->ciaddr != IP4::addr{0}) {
     socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
     return;
   }
-
-  // msg->giaddr and msg->ciaddr is zero
-  // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in
-  // flags field) is set, then the server broadcasts DHCPOFFER and DHCPACK messsages
-  // to 0xffffffff
+  // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in flags field) is set,
+  // then the server broadcasts DHCPOFFER and DHCPACK messsages to 0xffffffff
   std::bitset<8> bits(msg->flags);
   if (bits[7] == 1) {
     socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
     return;
   }
-
-  // the broadcast bit is not set
-  // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the
-  // server unicasts DHCPOFFER and DHCPACK messages to the client's hardware address
-  // and yiaddr address
+  // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the server unicasts
+  // DHCPOFFER and DHCPACK messages to the client's hardware address and yiaddr address
   socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
   // TODO: Send the message to the client's hardware address:
   // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
 void DHCPD::nak(const dhcp_packet_t* msg) {
-
-  // Server to client indicating client’s notion of network address is incorrect (e.g.,
-  // client has moved to new subnet) or client’s lease has expired
+  // DHCPNAK: Server to client indicating client’s notion of network address is incorrect (e.g., client
+  // has moved to new subnet) or client’s lease has expired
 
   const size_t packetlen = sizeof(dhcp_packet_t);
   char packet[packetlen];
@@ -944,27 +675,22 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   nak_opts->val[0] = DHCPNAK;
 
   // MESSAGE (SHOULD)
-  nak_opts = (dhcp_option_t*) (nak->options + 3);         // 3 bytes filled in prior
+  nak_opts = (dhcp_option_t*) (nak->options + 3);   // 3 bytes filled in prior
   nak_opts->code = DHO_DHCP_MESSAGE;
   // TODO Fill in error message instead of 0
   nak_opts->length = 1;
   nak_opts->val[0] = 0;
 
   // SERVER_IDENTIFIER
-  nak_opts = (dhcp_option_t*) (nak->options + 6);         // 6 bytes filled in prior
+  nak_opts = (dhcp_option_t*) (nak->options + 6);   // 6 bytes filled in prior
   add_server_id(nak_opts);
 
-  // CLIENT_IDENTIFIER? (MAY)
-
   // END
-  nak_opts = (dhcp_option_t*) (nak->options + 12);        // 12 bytes filled in prior
+  nak_opts = (dhcp_option_t*) (nak->options + 12);  // 12 bytes filled in prior
   nak_opts->code = DHO_END;
   nak_opts->length = 0;
 
-  //printf("Sending DHCPNAK\n");
-
-  // Send the DHCPNAK
-  // Broadcast
+  // Send the DHCPNAK - Broadcast
   socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
@@ -989,25 +715,20 @@ Record::byte_seq DHCPD::get_client_id(const uint8_t* chaddr, const dhcp_option_t
 
   for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
     client_id.push_back(chaddr[i]);
-
   return client_id;
 }
 
 IP4::addr DHCPD::get_requested_ip_in_opts(const dhcp_option_t* opts) const {
   const dhcp_option_t* opt = get_option(opts, DHO_DHCP_REQUESTED_ADDRESS);
-
   if (opt->code == DHO_DHCP_REQUESTED_ADDRESS)
     return IP4::addr{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
-
   return IP4::addr{0};
 }
 
 IP4::addr DHCPD::get_remote_netmask(const dhcp_option_t* opts) const {
   const dhcp_option_t* opt = get_option(opts, DHO_SUBNET_MASK);
-
   if (opt->code == DHO_SUBNET_MASK)
     return IP4::addr{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
-
   return IP4::addr{0};
 }
 
@@ -1021,15 +742,14 @@ void DHCPD::add_server_id(dhcp_option_t* opts) {
 }
 
 bool DHCPD::on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) const {
-
-  // The client is on the wrong network if the result of applying the local subnet mask
-  // or remote subnet mask (if giaddr is not zero) to requested IP address option value
-  // doesn't match reality
+  // The client is on the wrong network if the result of applying the local subnet mask or remote subnet
+  // mask (if giaddr is not zero) to requested IP address option value doesn't match reality
 
   IP4::addr subnet = (giaddr == IP4::addr{0}) ? netmask_ : get_remote_netmask(opts);
   IP4::addr requested_ip = get_requested_ip_in_opts(opts);
 
-  if (subnet == IP4::addr{0} or requested_ip == IP4::addr{0}) // Check if remote subnet mask from client exists and valid IP
+  // Check if remote subnet mask from client exists and valid IP
+  if (subnet == IP4::addr{0} or requested_ip == IP4::addr{0})
     return false;
 
   // Check if requested IP is on the same subnet as the server
@@ -1038,3 +758,21 @@ bool DHCPD::on_correct_network(IP4::addr giaddr, const dhcp_option_t* opts) cons
 
   return false;
 }
+
+void DHCPD::clear_offered_ip(IP4::addr ip) {
+  int ridx = get_record_idx_from_ip(ip);
+  if (ridx not_eq -1)
+    records_.erase(records_.begin() + ridx);
+  update_pool(ip, Status::AVAILABLE);
+}
+
+void DHCPD::clear_offered_ips() {
+  for (size_t i = 0; i < records_.size(); i++) {
+    if (records_.at(i).status() == Status::OFFERED) {
+      // Update pool
+      update_pool(records_.at(i).ip(), Status::AVAILABLE);
+      // And erase record
+      records_.erase(records_.begin() + i);
+    }
+  }
+}
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
index e4f8db535f..d683cf180a 100755
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
@@ -21,8 +21,6 @@
 ping_passed = False
 ping_count = 3
 
-# create_bridge.sh has to be run prior
-
 def check_dhclient_output(output):
   global num_messages
 
@@ -65,7 +63,6 @@ def run_dhclient(trigger_line):
 
   print color.INFO("<Test.py>"), "Running dhclient"
 
-  #"--no-pid" ? (Protect against registering lease in /var/lib/dhcp/dhclient.leases?)
   try:
     dhclient = subprocess.Popen(
         ["dhclient", "bridge43", "-4", "-n", "-v"],
@@ -90,13 +87,6 @@ def run_dhclient(trigger_line):
   if ping_passed and num_messages == 4:
     vm.exit(0,"<Test.py> DHCP process and ping test completed successfully. Process returned 0 exit status")
 
-  # If run release, bridge43 is taken down and running the create_bridge.sh script again doesn't fix it
-  # release_output = subprocess.check_output(["dhclient", "bridge43", "-r", "-v"])
-  # print "Release output: ", release_output
-
-  # Kill dhclient - also removes bridge
-  # kill_output = subprocess.check_output(["dhclient", "bridge43", "-x", "-v"])
-
 # Add custom event-handler
 vm.on_output("Service started", run_dhclient)
 

From d9340ff1f993337272fd28cd37932ca2af1077dd Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 27 Feb 2017 13:20:37 +0100
Subject: [PATCH 25/41] DHCP server: Added destructor

---
 api/net/dhcp/dhcpd.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index cf5703931f..28850ce28d 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -40,6 +40,10 @@ namespace dhcp {
     DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
       uint32_t lease = DEFAULT_LEASE, uint32_t max_lease = DEFAULT_MAX_LEASE, uint8_t pending = DEFAULT_PENDING);
 
+    ~DHCPD() {
+      socket_.udp().close(socket_.local_port());
+    }
+
     void add_record(const Record& record)
     { records_.push_back(record); }
 

From 925f72095b46b71bd11966fb4fe36e637d1eb388 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 27 Feb 2017 13:30:58 +0100
Subject: [PATCH 26/41] DHCP server valid pool: Removed check for local ip
 addresses - should be valid

---
 src/net/dhcp/dhcpd.cpp | 27 +--------------------------
 1 file changed, 1 insertion(+), 26 deletions(-)

diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index e9962e13d4..9edc5e44e6 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -68,37 +68,12 @@ bool DHCPD::valid_pool(IP4::addr start, IP4::addr end) const {
   if (start > end or start == end or inc_addr(start) == end)
       return false;
 
-  // Check if start and end are on the same subnet
+  // Check if start and end are on the same subnet and on the same subnet as the server
   if (network_address(start) != network_address(end)
     or network_address(start) != network_address(server_id_)
     or network_address(end) != network_address(server_id_))
     return false;
 
-  // IP address part 0 is the rightmost uint8_t
-  // IP address part 3 is the leftmost uint8_t
-  const uint8_t start3 = start.part(3);
-  const uint8_t start2 = start.part(2);
-  const uint8_t start0 = start.part(0);
-  const uint8_t end3 = end.part(3);
-  const uint8_t end2 = end.part(2);
-  const uint8_t end0 = end.part(0);
-
-  // 10.x.x.x addresses not valid
-  // 172.16.0.0 - 172.31.255.255 not valid
-  // 192.168.x.x addresses not valid
-
-  // TODO: 10.x.x.x addresses should be invalid
-  if (/* start3 == 10 or */(start3 == 192 and start2 == 168) or start0 < 1 or start0 > 254)
-    return false;
-
-  // TODO: 10.x.x.x addresses should be invalid
-  if (/* end3 == 10 or */(end3 == 192 and end2 == 168) or end0 < 1 or end0 > 254)
-    return false;
-
-  if ( (start3 == 172 and (start2 > 15 or start2 < 32)) or
-    (end3 == 172 and (end2 > 15 or end2 < 32)) )
-    return false;
-
   return true;
 }
 

From 082f6345690ba14290162c43d7ad5d1c1f37a359 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 27 Feb 2017 15:15:17 +0100
Subject: [PATCH 27/41] DHCP: Server validating client messages and changed
 byte order BOOTP_BROADCAST

---
 api/net/dhcp/dhcp4.hpp     |  3 ++-
 src/net/dhcp/dh4client.cpp |  4 ++--
 src/net/dhcp/dhcpd.cpp     | 25 +++++++++++++++++++++----
 3 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/api/net/dhcp/dhcp4.hpp b/api/net/dhcp/dhcp4.hpp
index 1a2ef87385..1a909e50c1 100644
--- a/api/net/dhcp/dhcp4.hpp
+++ b/api/net/dhcp/dhcp4.hpp
@@ -65,12 +65,13 @@ namespace net {
 
   // Possible values for flags field
   static const uint32_t BOOTP_UNICAST =   0x0000;
-  static const uint32_t BOOTP_BROADCAST = 0x8000;
+  static const uint32_t BOOTP_BROADCAST = 0x0080;
 
   // Possible values for hardware type (htype) field
   static const uint8_t HTYPE_ETHER =    1;  // Ethernet 10Mbps
   static const uint8_t HTYPE_IEEE802 =  6;  // IEEE 802.2 Token Ring
   static const uint8_t HTYPE_FDDI =     8;  // FDDI
+  static const uint8_t HTYPE_HFI =      37; // HFI
 
   /* Magic cookie validating dhcp options field (and bootp vendor
      extensions field). */
diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index d7b215181a..37375ff30a 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -92,7 +92,7 @@ namespace net
     dhcp->hops  = 0;
     dhcp->xid   = htonl(this->xid);
     dhcp->secs  = 0;
-    dhcp->flags = htons(BOOTP_BROADCAST);
+    dhcp->flags = BOOTP_BROADCAST;
     dhcp->ciaddr = IP4::ADDR_ANY;
     dhcp->yiaddr = IP4::ADDR_ANY;
     dhcp->siaddr = IP4::ADDR_ANY;
@@ -271,7 +271,7 @@ namespace net
     resp->hops  = 0;
     resp->xid   = htonl(this->xid);
     resp->secs  = 0;
-    resp->flags = htons(BOOTP_BROADCAST);
+    resp->flags = BOOTP_BROADCAST;
 
     resp->ciaddr = IP4::ADDR_ANY;
     resp->yiaddr = IP4::ADDR_ANY;
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 9edc5e44e6..372c4170b1 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -109,6 +109,25 @@ void DHCPD::listen() {
 }
 
 void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+  if (msg->op not_eq BOOTREQUEST)
+    return;
+
+  if (msg->htype == 0 or msg->htype > HTYPE_HFI)  // http://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml
+    return;
+
+  if (msg->hops not_eq 0)
+    return;
+
+  if (msg->yiaddr not_eq IP4::addr{0} or msg->siaddr not_eq IP4::addr{0} or msg->giaddr not_eq IP4::addr{0})
+    return;
+
+  const auto cid = get_client_id(msg->chaddr, opts);
+  if (cid.empty() or std::all_of(cid.begin(), cid.end(), [] (int i) { return i == 0; }))
+    return;
+
+  if (msg->magic[0] not_eq 99 or msg->magic[1] not_eq 130 or msg->magic[2] not_eq 83 or msg->magic[3] not_eq 99)
+    return;
+
   int ridx;
 
   switch (opts->val[0]) {
@@ -122,8 +141,7 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       // A client has discovered that the suggested network address is already in use.
       // The server must mark the network address as not available and should notify the network admin
       // of a possible configuration problem - TODO
-
-      ridx = get_record_idx(get_client_id(msg->chaddr, opts));
+      ridx = get_record_idx(cid);
       // Erase record if exists because client hasn't got a valid IP
       if (ridx not_eq -1)
         records_.erase(records_.begin() + ridx);
@@ -455,8 +473,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   }
   // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in flags field) is set,
   // then the server broadcasts DHCPOFFER and DHCPACK messsages to 0xffffffff
-  std::bitset<8> bits(msg->flags);
-  if (bits[7] == 1) {
+  if (msg->flags & BOOTP_BROADCAST) {
     socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
     return;
   }

From 472fd2a0a19fb3493e2ed90557443072bc56ed21 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 27 Feb 2017 20:25:27 +0100
Subject: [PATCH 28/41] DHCP server: Validating client messages

---
 api/net/dhcp/dhcpd.hpp |  2 ++
 src/net/dhcp/dhcpd.cpp | 28 ++++++++++++++++++++++++----
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 28850ce28d..40946eb838 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -35,6 +35,7 @@ namespace dhcp {
     static const uint32_t DEFAULT_LEASE = 86400;      // seconds. 1 day = 86 400 seconds.
     static const uint32_t DEFAULT_MAX_LEASE = 345600; // seconds. 4 days = 345 600 seconds.
     static const uint8_t  DEFAULT_PENDING = 30;
+    static const uint8_t  MAX_NUM_OPTIONS = 30;       // max number of options in a message from a client
 
   public:
     DHCPD(UDP& udp, IP4::addr pool_start, IP4::addr pool_end,
@@ -143,6 +144,7 @@ namespace dhcp {
     void request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts);
     void nak(const dhcp_packet_t* msg);
 
+    bool valid_options(const dhcp_option_t* opts) const;
     const dhcp_option_t* get_option(const dhcp_option_t* opts, int code) const;
     Record::byte_seq get_client_id(const uint8_t* chaddr, const dhcp_option_t* opts) const;
     IP4::addr get_requested_ip_in_opts(const dhcp_option_t* opts) const;
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 372c4170b1..1737947e91 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -95,7 +95,7 @@ void DHCPD::update_pool(IP4::addr ip, Status new_status) {
 
 void DHCPD::listen() {
   socket_.on_read([&] (IP4::addr, UDP::port_t port,
-    const char* data, size_t) {
+    const char* data, size_t len) {
 
     if (port == DHCP_CLIENT_PORT) {
       // Message
@@ -109,16 +109,16 @@ void DHCPD::listen() {
 }
 
 void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-  if (msg->op not_eq BOOTREQUEST)
+  if (msg->op not_eq BOOTREQUEST or msg->hops not_eq 0)
     return;
 
   if (msg->htype == 0 or msg->htype > HTYPE_HFI)  // http://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml
     return;
 
-  if (msg->hops not_eq 0)
+  if (msg->yiaddr not_eq IP4::addr{0} or msg->siaddr not_eq IP4::addr{0} or msg->giaddr not_eq IP4::addr{0})
     return;
 
-  if (msg->yiaddr not_eq IP4::addr{0} or msg->siaddr not_eq IP4::addr{0} or msg->giaddr not_eq IP4::addr{0})
+  if (not valid_options(opts))
     return;
 
   const auto cid = get_client_id(msg->chaddr, opts);
@@ -686,6 +686,26 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
 }
 
+bool DHCPD::valid_options(const dhcp_option_t* opts) const {
+  //int num_bytes = 0;
+  int num_options = 0;
+
+  const dhcp_option_t* opt = opts;
+  while (opt->code != DHO_END) {
+    //num_bytes += 2 + opt->length;
+    num_options++;
+
+    // F.ex. if DHO_END isn't included
+    if (/*num_bytes > DHCP_VEND_LEN or*/ num_options > MAX_NUM_OPTIONS)
+      return false;
+
+    // go to next option
+    opt = (const dhcp_option_t*) (((const uint8_t*) opt) + 2 + opt->length);
+  }
+
+  return true;
+}
+
 const dhcp_option_t* DHCPD::get_option(const dhcp_option_t* opts, int code) const {
   const dhcp_option_t* opt = opts;
   while (opt->code != code && opt->code != DHO_END) {

From 7945855c92b0d66f8a5edb86a610bfd1323f0561 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Mon, 27 Feb 2017 20:28:07 +0100
Subject: [PATCH 29/41] DHCP server: Warning fixed

---
 src/net/dhcp/dhcpd.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 1737947e91..d4cea1e8c8 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -95,7 +95,7 @@ void DHCPD::update_pool(IP4::addr ip, Status new_status) {
 
 void DHCPD::listen() {
   socket_.on_read([&] (IP4::addr, UDP::port_t port,
-    const char* data, size_t len) {
+    const char* data, size_t) {
 
     if (port == DHCP_CLIENT_PORT) {
       // Message

From 1698e30b0a103c14525ca3fd65d2f8dd17fe77d4 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Tue, 28 Feb 2017 17:53:17 +0100
Subject: [PATCH 30/41] DHCP server and client: * uint8_t options array with
 length DHCP_VEND_LEN -> dhcp_option_t options array with length 0 *
 conv_option and get_option refactored and moved to dhcp4.hpp * printing of
 client's received info moved to acknowledge method

---
 api/net/dhcp/dhcp4.hpp     | 63 ++++++++++++++++---------
 api/net/dhcp/dhcpd.hpp     |  1 -
 src/net/dhcp/dh4client.cpp | 70 +++++++++------------------
 src/net/dhcp/dhcpd.cpp     | 96 +++++++++++++++++---------------------
 4 files changed, 105 insertions(+), 125 deletions(-)

diff --git a/api/net/dhcp/dhcp4.hpp b/api/net/dhcp/dhcp4.hpp
index 1a909e50c1..a0da8a9597 100644
--- a/api/net/dhcp/dhcp4.hpp
+++ b/api/net/dhcp/dhcp4.hpp
@@ -28,36 +28,38 @@ namespace net {
   // some clients silently ignore responses less than 300 bytes
   static const int DEFAULT_PACKET_SIZE =  300;
 
+  struct dhcp_option_t
+  {
+    uint8_t code;
+    uint8_t length;
+    uint8_t val[0];
+  };
+
   struct dhcp_packet_t
   {
     static const uint8_t CHADDR_LEN =  16;
     static const uint8_t SNAME_LEN  =  64;
     static const uint8_t FILE_LEN   = 128;
 
-    uint8_t  op;          // message opcode
-    uint8_t  htype;       // hardware addr type
-    uint8_t  hlen;        // hardware addr length
-    uint8_t  hops;        // relay agent hops from client
-    uint32_t xid;         // transaction ID
-    uint16_t secs;        // seconds since start
-    uint16_t flags;       // flag bits
-    IP4::addr ciaddr;     // client IP address
-    IP4::addr yiaddr;     // client IP address
-    IP4::addr siaddr;     // IP address of next server
-    IP4::addr giaddr;     // DHCP relay agent IP address
-    uint8_t  chaddr[CHADDR_LEN];  // client hardware address
-    uint8_t  sname[SNAME_LEN];    // server name
-    uint8_t  file[FILE_LEN];      // BOOT filename
-    uint8_t  magic[4];            // option_format aka magic
-    uint8_t  options[DHCP_VEND_LEN];
+    uint8_t   op;           // message opcode
+    uint8_t   htype;        // hardware addr type
+    uint8_t   hlen;         // hardware addr length
+    uint8_t   hops;         // relay agent hops from client
+    uint32_t  xid;          // transaction ID
+    uint16_t  secs;         // seconds since start
+    uint16_t  flags;        // flag bits
+    IP4::addr ciaddr;       // client IP address
+    IP4::addr yiaddr;       // client IP address
+    IP4::addr siaddr;       // IP address of next server
+    IP4::addr giaddr;       // DHCP relay agent IP address
+    uint8_t   chaddr[CHADDR_LEN];  // client hardware address
+    uint8_t   sname[SNAME_LEN];    // server name
+    uint8_t   file[FILE_LEN];      // BOOT filename
+    uint8_t   magic[4];            // option_format aka magic
+    dhcp_option_t   options[0];
   };
 
-  struct dhcp_option_t
-  {
-    uint8_t code;
-    uint8_t length;
-    uint8_t val[0];
-  };
+  static const uint16_t PACKET_SIZE = sizeof(dhcp_packet_t) + DHCP_VEND_LEN;
 
   // BOOTP (rfc951) message types
   static const uint8_t BOOTREQUEST =  1;
@@ -183,6 +185,23 @@ namespace net {
   static const uint8_t ETH_ALEN =         6;  // octets in one ethernet header
   static const uint8_t DHCP_SERVER_PORT = 67;
   static const uint8_t DHCP_CLIENT_PORT = 68;
+
+  static inline dhcp_option_t* conv_option(dhcp_option_t* option, int offset)
+  {
+    return (dhcp_option_t*) ((char*) option + offset);
+  }
+
+  static inline const dhcp_option_t* get_option(const dhcp_option_t* opts, uint8_t code)
+  {
+    const dhcp_option_t* opt = opts;
+    while (opt->code != code && opt->code != DHO_END)
+    {
+      // go to next option
+      opt = (const dhcp_option_t*) (((const uint8_t*) opt) + 2 + opt->length);
+    }
+    return opt;
+  }
+
 } // < namespace net
 
 #endif
diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 40946eb838..4410aaca4e 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -145,7 +145,6 @@ namespace dhcp {
     void nak(const dhcp_packet_t* msg);
 
     bool valid_options(const dhcp_option_t* opts) const;
-    const dhcp_option_t* get_option(const dhcp_option_t* opts, int code) const;
     Record::byte_seq get_client_id(const uint8_t* chaddr, const dhcp_option_t* opts) const;
     IP4::addr get_requested_ip_in_opts(const dhcp_option_t* opts) const;
     IP4::addr get_remote_netmask(const dhcp_option_t* opts) const;
diff --git a/src/net/dhcp/dh4client.cpp b/src/net/dhcp/dh4client.cpp
index 37375ff30a..ad3ca569fe 100644
--- a/src/net/dhcp/dh4client.cpp
+++ b/src/net/dhcp/dh4client.cpp
@@ -27,11 +27,6 @@
 
 namespace net
 {
-  inline dhcp_option_t* conv_option(uint8_t* option)
-  {
-    return (dhcp_option_t*) option;
-  }
-
   DHClient::DHClient(Stack& inet)
     : stack(inet), xid(0), console_spam(true), in_progress(false)
   {
@@ -82,8 +77,7 @@ namespace net
       MYINFO("Negotiating IP-address (xid=%u)", xid);
 
     // create DHCP discover packet
-    const size_t packetlen = sizeof(dhcp_packet_t);
-    char packet[packetlen];
+    char packet[PACKET_SIZE];
 
     dhcp_packet_t* dhcp = (dhcp_packet_t*) packet;
     dhcp->op    = BOOTREQUEST;
@@ -111,33 +105,33 @@ namespace net
     dhcp->magic[2] =  83;
     dhcp->magic[3] =  99;
 
-    dhcp_option_t* opt = conv_option(dhcp->options + 0);
+    dhcp_option_t* opt = conv_option(dhcp->options, 0);
     // DHCP discover
     opt->code   = DHO_DHCP_MESSAGE_TYPE;
     opt->length = 1;
     opt->val[0] = DHCPDISCOVER;
     // DHCP client identifier
-    opt = conv_option(dhcp->options + 3);
+    opt = conv_option(dhcp->options, 3);
     opt->code   = DHO_DHCP_CLIENT_IDENTIFIER;
     opt->length = 7;
     opt->val[0] = HTYPE_ETHER;
     memcpy(&opt->val[1], &link_addr, ETH_ALEN);
     // DHCP Parameter Request Field
-    opt = conv_option(dhcp->options + 12);
+    opt = conv_option(dhcp->options, 12);
     opt->code   = DHO_DHCP_PARAMETER_REQUEST_LIST;
     opt->length = 3;
     opt->val[0] = DHO_ROUTERS;
     opt->val[1] = DHO_SUBNET_MASK;
     opt->val[2] = DHO_DOMAIN_NAME_SERVERS;
     // END
-    opt = conv_option(dhcp->options + 17);
+    opt = conv_option(dhcp->options, 17);
     opt->code   = DHO_END;
     opt->length = 0;
 
     ////////////////////////////////////////////////////////
     auto& socket = stack.udp().bind(DHCP_CLIENT_PORT);
     /// broadcast our DHCP plea as 0.0.0.0:67
-    socket.bcast(IP4::ADDR_ANY, DHCP_SERVER_PORT, packet, packetlen);
+    socket.bcast(IP4::ADDR_ANY, DHCP_SERVER_PORT, packet, PACKET_SIZE);
 
     socket.on_read(
     [this, &socket] (IP4::addr, UDP::port_t port,
@@ -153,17 +147,6 @@ namespace net
     });
   }
 
-  const dhcp_option_t* get_option(const uint8_t* options, uint8_t code)
-  {
-    const dhcp_option_t* opt = (const dhcp_option_t*) options;
-    while (opt->code != code && opt->code != DHO_END)
-      {
-        // go to next option
-        opt = (const dhcp_option_t*) (((const uint8_t*) opt) + 2 + opt->length);
-      }
-    return opt;
-  }
-
   void DHClient::offer(UDPSocket& sock, const char* data, size_t)
   {
     const dhcp_packet_t* dhcp = (const dhcp_packet_t*) data;
@@ -191,16 +174,10 @@ namespace net
 
     // the offered IP address:
     this->ipaddr = dhcp->yiaddr;
-    if (console_spam)
-      MYINFO("IP ADDRESS: \t%s", this->ipaddr.str().c_str());
 
     opt = get_option(dhcp->options, DHO_SUBNET_MASK);
     if (opt->code == DHO_SUBNET_MASK)
-    {
       memcpy(&this->netmask, opt->val, sizeof(IP4::addr));
-      if (console_spam)
-        MYINFO("SUBNET MASK: \t%s", this->netmask.str().c_str());
-    }
 
     opt = get_option(dhcp->options, DHO_DHCP_LEASE_TIME);
     if (opt->code == DHO_DHCP_LEASE_TIME)
@@ -209,9 +186,6 @@ namespace net
         ((uint32_t) opt->val[1]) << 16 |
         ((uint32_t) opt->val[2]) <<  8 |
         ((uint32_t) opt->val[3]) <<  0);
-
-      if (console_spam)
-        MYINFO("LEASE TIME: \t%u mins", this->lease_time / 60);
     }
 
     // Preserve DHCP server address
@@ -226,18 +200,12 @@ namespace net
     if (opt->code == DHO_ROUTERS)
     {
       memcpy(&this->router, opt->val, sizeof(IP4::addr));
-      if (console_spam)
-        MYINFO("GATEWAY: \t%s", this->router.str().c_str());
     }
     // assume that the server we received the request from is the gateway
     else
     {
       if (server_id)
-      {
         memcpy(&this->router, server_id->val, sizeof(IP4::addr));
-        if (console_spam)
-          MYINFO("GATEWAY: \t%s", this->router.str().c_str());
-      }
       // silently ignore when both ROUTER and SERVER_ID is missing
       else return;
     }
@@ -251,8 +219,6 @@ namespace net
     { // just try using ROUTER as DNS server
       this->dns_server = this->router;
     }
-    if (console_spam)
-      MYINFO("DNS SERVER: \t%s", this->dns_server.str().c_str());
 
     // we can accept the offer now by requesting the IP!
     this->request(sock, server_id);
@@ -261,8 +227,7 @@ namespace net
   void DHClient::request(UDPSocket& sock, const dhcp_option_t* server_id)
   {
     // form a response
-    const size_t packetlen = sizeof(dhcp_packet_t);
-    char packet[packetlen];
+    char packet[PACKET_SIZE];
 
     dhcp_packet_t* resp = (dhcp_packet_t*) packet;
     resp->op    = BOOTREQUEST;
@@ -291,19 +256,19 @@ namespace net
     resp->magic[2] =  83;
     resp->magic[3] =  99;
 
-    dhcp_option_t* opt = conv_option(resp->options + 0);
+    dhcp_option_t* opt = conv_option(resp->options, 0);
     // DHCP Request
     opt->code   = DHO_DHCP_MESSAGE_TYPE;
     opt->length = 1;
     opt->val[0] = DHCPREQUEST;
     // DHCP client identifier
-    opt = conv_option(resp->options + 3);
+    opt = conv_option(resp->options, 3);
     opt->code   = DHO_DHCP_CLIENT_IDENTIFIER;
     opt->length = 7;
     opt->val[0] = HTYPE_ETHER;
     memcpy(&opt->val[1], &link_addr, ETH_ALEN);
     // DHCP server identifier
-    opt = conv_option(resp->options + 12);
+    opt = conv_option(resp->options, 12);
     opt->code   = DHO_DHCP_SERVER_IDENTIFIER;
     opt->length = 4;
     if (server_id) {
@@ -314,19 +279,19 @@ namespace net
       MYINFO("Server IP set to gateway (%s)", ((IP4::addr*)&opt->val[0])->to_string().c_str());
     }
     // DHCP Requested Address
-    opt = conv_option(resp->options + 18);
+    opt = conv_option(resp->options, 18);
     opt->code   = DHO_DHCP_REQUESTED_ADDRESS;
     opt->length = 4;
     memcpy(&opt->val[0], &this->ipaddr, sizeof(IP4::addr));
     // DHCP Parameter Request Field
-    opt = conv_option(resp->options + 24);
+    opt = conv_option(resp->options, 24);
     opt->code   = DHO_DHCP_PARAMETER_REQUEST_LIST;
     opt->length = 3;
     opt->val[0] = DHO_ROUTERS;
     opt->val[1] = DHO_SUBNET_MASK;
     opt->val[2] = DHO_DOMAIN_NAME_SERVERS;
     // END
-    opt = conv_option(resp->options + 29);
+    opt = conv_option(resp->options, 29);
     opt->code   = DHO_END;
     opt->length = 0;
 
@@ -345,7 +310,7 @@ namespace net
     });
 
     // send our DHCP Request
-    sock.bcast(IP4::ADDR_ANY, DHCP_SERVER_PORT, packet, packetlen);
+    sock.bcast(IP4::ADDR_ANY, DHCP_SERVER_PORT, packet, PACKET_SIZE);
   }
 
   void DHClient::acknowledge(const char* data, size_t)
@@ -372,7 +337,14 @@ namespace net
     else return;
 
     if (console_spam)
+    {
       MYINFO("Server acknowledged our request!");
+      MYINFO("IP ADDRESS: \t%s", this->ipaddr.str().c_str());
+      MYINFO("SUBNET MASK: \t%s", this->netmask.str().c_str());
+      MYINFO("LEASE TIME: \t%u mins", this->lease_time / 60);
+      MYINFO("GATEWAY: \t%s", this->router.str().c_str());
+      MYINFO("DNS SERVER: \t%s", this->dns_server.str().c_str());
+    }
 
     // configure our network stack
     stack.network_config(this->ipaddr, this->netmask,
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index d4cea1e8c8..4d67a8fa82 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -95,9 +95,12 @@ void DHCPD::update_pool(IP4::addr ip, Status new_status) {
 
 void DHCPD::listen() {
   socket_.on_read([&] (IP4::addr, UDP::port_t port,
-    const char* data, size_t) {
+    const char* data, size_t len) {
 
     if (port == DHCP_CLIENT_PORT) {
+      if (len < sizeof(dhcp_packet_t))
+        return;
+
       // Message
       const dhcp_packet_t* msg = (dhcp_packet_t*) data;
       // Options
@@ -304,8 +307,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   if (ridx not_eq -1)
     return;
 
-  const size_t packetlen = sizeof(dhcp_packet_t);
-  char packet[packetlen];
+  char packet[PACKET_SIZE];
 
   // If we want to offer this client an IP address: Create a RECORD
   Record record;
@@ -364,7 +366,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer->magic[3] =  99;
 
   // OPTIONS
-  dhcp_option_t* offer_opts = (dhcp_option_t*) (offer->options + 0);
+  dhcp_option_t* offer_opts = conv_option(offer->options, 0);
 
   // DHCPOFFER Options:
   // Requested IP address                                         MUST NOT
@@ -385,11 +387,11 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[0] = DHCPOFFER;
 
   // SERVER_IDENTIFIER (the server's network address(es))
-  offer_opts = (dhcp_option_t*) (offer->options + 3);     // 3 bytes filled in prior
+  offer_opts = conv_option(offer->options, 3);     // 3 bytes filled in prior
   add_server_id(offer_opts);
 
   // SUBNET_MASK
-  offer_opts = (dhcp_option_t*) (offer->options + 9);     // 9 bytes filled in prior
+  offer_opts = conv_option(offer->options, 9);     // 9 bytes filled in prior
   offer_opts->code = DHO_SUBNET_MASK;
   offer_opts->length = 4;
   offer_opts->val[0] = netmask_.part(3);
@@ -398,7 +400,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = netmask_.part(0);
 
   // ROUTERS
-  offer_opts = (dhcp_option_t*) (offer->options + 15);      // 15 bytes filled in prior
+  offer_opts = conv_option(offer->options, 15);      // 15 bytes filled in prior
   offer_opts->code = DHO_ROUTERS;
   offer_opts->length = 4;
   offer_opts->val[0] = router_.part(3);
@@ -408,7 +410,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   // LEASE_TIME
   // Time in units of seconds (32-bit unsigned integer / 4 uint8_t)
-  offer_opts = (dhcp_option_t*) (offer->options + 21);      // 21 bytes filled in prior
+  offer_opts = conv_option(offer->options, 21);      // 21 bytes filled in prior
   offer_opts->code = DHO_DHCP_LEASE_TIME;
   offer_opts->length = 4;
   offer_opts->val[0] = (lease_ & 0xff000000) >> 24;
@@ -418,13 +420,13 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   // MESSAGE (SHOULD)
   // No error message (only in DHCPNAK)
-  offer_opts = (dhcp_option_t*) (offer->options + 27);      // 27 bytes filled in prior
+  offer_opts = conv_option(offer->options, 27);      // 27 bytes filled in prior
   offer_opts->code = DHO_DHCP_MESSAGE;
   offer_opts->length = 1;
   offer_opts->val[0] = 0;
 
   // TIME_OFFSET
-  offer_opts = (dhcp_option_t*) (offer->options + 30);
+  offer_opts = conv_option(offer->options, 30);
   offer_opts->code = DHO_TIME_OFFSET;
   offer_opts->length = 4;
   offer_opts->val[0] = 0;
@@ -433,7 +435,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = 0;
 
   // DOMAIN_NAME_SERVERS
-  offer_opts = (dhcp_option_t*) (offer->options + 36);
+  offer_opts = conv_option(offer->options, 36);
   offer_opts->code = DHO_DOMAIN_NAME_SERVERS;
   offer_opts->length = 4;
   offer_opts->val[0] = dns_.part(3);
@@ -442,7 +444,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = dns_.part(0);
 
   // BROADCAST_ADDRESS
-  offer_opts = (dhcp_option_t*) (offer->options + 42);
+  offer_opts = conv_option(offer->options, 42);
   offer_opts->code = DHO_BROADCAST_ADDRESS;
   offer_opts->length = 4;
   auto broadcast = broadcast_address();
@@ -452,7 +454,7 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   offer_opts->val[3] = broadcast.part(0);
 
   // END
-  offer_opts = (dhcp_option_t*) (offer->options + 48);
+  offer_opts = conv_option(offer->options, 48);
   offer_opts->code   = DHO_END;
   offer_opts->length = 0;
 
@@ -462,26 +464,26 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // If the giaddr field in a DHCP message from a client is non-zero, the server sends any return
   // messages to the DHCP server port on the BOOTP relay agent whose address appears in giaddr
   if (msg->giaddr != IP4::addr{0}) {
-    socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, packetlen);
+    socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, PACKET_SIZE);
     return;
   }
   // If the giaddr field is zero and the ciaddr field is non-zero, then the server unicasts
   // DHCPOFFER and DHCPACK messages to the address in ciaddr
   if (msg->ciaddr != IP4::addr{0}) {
-    socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
+    socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
     return;
   }
   // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in flags field) is set,
   // then the server broadcasts DHCPOFFER and DHCPACK messsages to 0xffffffff
   if (msg->flags & BOOTP_BROADCAST) {
-    socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
+    socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
     return;
   }
   // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the server unicasts
   // DHCPOFFER and DHCPACK messages to the client's hardware address and yiaddr address
-  socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
+  socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
   // TODO: Send the message to the client's hardware address:
-  // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
+  // socket_.sendto(, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
 }
 
 void DHCPD::inform_ack(const dhcp_packet_t* msg) {
@@ -500,8 +502,7 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg) {
   // check for an existing lease. The server forms a DHCPACK message containing the configuration parameters
   // for the requesting client and sends the DHCPACK message directly to the client.
 
-  const size_t packetlen = sizeof(dhcp_packet_t);
-  char packet[packetlen];
+  char packet[PACKET_SIZE];
 
   // ACK
   dhcp_packet_t* ack = (dhcp_packet_t*) packet;
@@ -525,7 +526,7 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg) {
   ack->magic[3] =  99;
 
   // OPTIONS
-  dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
+  dhcp_option_t* ack_opts = conv_option(ack->options, 0);
 
   // MESSAGE_TYPE
   ack_opts->code = DHO_DHCP_MESSAGE_TYPE;
@@ -535,7 +536,7 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg) {
   // TODO Add options requested by the client
 
   // Send the DHCPACK - Unicast to DHCPINFORM message's ciaddr field
-  socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
+  socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
 }
 
 void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
@@ -548,8 +549,7 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
 
   // Table 3 RFC 2131 DHCPACK
 
-  const size_t packetlen = sizeof(dhcp_packet_t);
-  char packet[packetlen];
+  char packet[PACKET_SIZE];
 
   // ACK
   dhcp_packet_t* ack = (dhcp_packet_t*) packet;
@@ -577,7 +577,7 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack->magic[3] =  99;
 
   // OPTIONS
-  dhcp_option_t* ack_opts = (dhcp_option_t*) (ack->options + 0);
+  dhcp_option_t* ack_opts = conv_option(ack->options, 0);
 
   // MESSAGE_TYPE
   ack_opts->code = DHO_DHCP_MESSAGE_TYPE;
@@ -585,7 +585,7 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->val[0] = DHCPACK;
 
   // LEASE_TIME (MUST)
-  ack_opts = (dhcp_option_t*) (ack->options + 3);     // 3 bytes filled in prior
+  ack_opts = conv_option(ack->options, 3);     // 3 bytes filled in prior
   ack_opts->code = DHO_DHCP_LEASE_TIME;
   ack_opts->length = 4;
   ack_opts->val[0] = (lease_ & 0xff000000) >> 24;
@@ -594,53 +594,52 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->val[3] = (lease_ & 0x000000ff);
 
   // SERVER_IDENTIFIER (the server's network address(es))
-  ack_opts = (dhcp_option_t*) (ack->options + 9);     // 9 bytes filled in prior
+  ack_opts = conv_option(ack->options, 9);     // 9 bytes filled in prior
   add_server_id(ack_opts);
 
   // MESSAGE (SHOULD)
   // No error message (only in DHCPNAK)
-  ack_opts = (dhcp_option_t*) (ack->options + 15);    // 15 bytes filled in prior
+  ack_opts = conv_option(ack->options, 15);    // 15 bytes filled in prior
   ack_opts->code = DHO_DHCP_MESSAGE;
   ack_opts->length = 1;
   ack_opts->val[0] = 0;
 
   // END
-  ack_opts = (dhcp_option_t*) (ack->options + 18);    // 18 bytes filled in prior
+  ack_opts = conv_option(ack->options, 18);    // 18 bytes filled in prior
   ack_opts->code   = DHO_END;
   ack_opts->length = 0;
 
   // If the giaddr field in a DHCP message from a client is non-zero, the server sends any return
   // messages to the DHCP server port on the BOOTP relay agent whose address appears in giaddr
   if (msg->giaddr != IP4::addr{0}) {
-    socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, packetlen);
+    socket_.sendto(msg->giaddr, DHCP_SERVER_PORT, packet, PACKET_SIZE);
     return;
   }
   // If the giaddr field is zero and the ciaddr field is non-zero, then the server unicasts
   // DHCPOFFER and DHCPACK messages to the address in ciaddr
   if (msg->ciaddr != IP4::addr{0}) {
-    socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, packetlen);
+    socket_.sendto(msg->ciaddr, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
     return;
   }
   // If giaddr is zero and ciaddr is zero, and the broadcast bit (leftmost bit in flags field) is set,
   // then the server broadcasts DHCPOFFER and DHCPACK messsages to 0xffffffff
   std::bitset<8> bits(msg->flags);
   if (bits[7] == 1) {
-    socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
+    socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
     return;
   }
   // If the broadcast bit is not set and giaddr is zero and ciaddr is zero, then the server unicasts
   // DHCPOFFER and DHCPACK messages to the client's hardware address and yiaddr address
-  socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, packetlen);
+  socket_.sendto(msg->yiaddr, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
   // TODO: Send the message to the client's hardware address:
-  // socket_.sendto(, DHCP_CLIENT_PORT, packet, packetlen);
+  // socket_.sendto(, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
 }
 
 void DHCPD::nak(const dhcp_packet_t* msg) {
   // DHCPNAK: Server to client indicating client’s notion of network address is incorrect (e.g., client
   // has moved to new subnet) or client’s lease has expired
 
-  const size_t packetlen = sizeof(dhcp_packet_t);
-  char packet[packetlen];
+  char packet[PACKET_SIZE];
 
   // NAK
   dhcp_packet_t* nak = (dhcp_packet_t*) packet;
@@ -659,7 +658,7 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   std::memcpy(nak->chaddr, msg->chaddr, dhcp_packet_t::CHADDR_LEN);
 
   // OPTIONS
-  dhcp_option_t* nak_opts = (dhcp_option_t*) (nak->options + 0);
+  dhcp_option_t* nak_opts = conv_option(nak->options, 0);
 
   // MESSAGE_TYPE
   nak_opts->code = DHO_DHCP_MESSAGE_TYPE;
@@ -667,36 +666,36 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   nak_opts->val[0] = DHCPNAK;
 
   // MESSAGE (SHOULD)
-  nak_opts = (dhcp_option_t*) (nak->options + 3);   // 3 bytes filled in prior
+  nak_opts = conv_option(nak->options, 3);   // 3 bytes filled in prior
   nak_opts->code = DHO_DHCP_MESSAGE;
   // TODO Fill in error message instead of 0
   nak_opts->length = 1;
   nak_opts->val[0] = 0;
 
   // SERVER_IDENTIFIER
-  nak_opts = (dhcp_option_t*) (nak->options + 6);   // 6 bytes filled in prior
+  nak_opts = conv_option(nak->options, 6);   // 6 bytes filled in prior
   add_server_id(nak_opts);
 
   // END
-  nak_opts = (dhcp_option_t*) (nak->options + 12);  // 12 bytes filled in prior
+  nak_opts = conv_option(nak->options, 12);  // 12 bytes filled in prior
   nak_opts->code = DHO_END;
   nak_opts->length = 0;
 
   // Send the DHCPNAK - Broadcast
-  socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, packetlen);
+  socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
 }
 
 bool DHCPD::valid_options(const dhcp_option_t* opts) const {
-  //int num_bytes = 0;
+  int num_bytes = 0;
   int num_options = 0;
 
   const dhcp_option_t* opt = opts;
   while (opt->code != DHO_END) {
-    //num_bytes += 2 + opt->length;
+    num_bytes += 2 + opt->length;
     num_options++;
 
     // F.ex. if DHO_END isn't included
-    if (/*num_bytes > DHCP_VEND_LEN or*/ num_options > MAX_NUM_OPTIONS)
+    if (num_bytes > DHCP_VEND_LEN or num_options > MAX_NUM_OPTIONS)
       return false;
 
     // go to next option
@@ -706,15 +705,6 @@ bool DHCPD::valid_options(const dhcp_option_t* opts) const {
   return true;
 }
 
-const dhcp_option_t* DHCPD::get_option(const dhcp_option_t* opts, int code) const {
-  const dhcp_option_t* opt = opts;
-  while (opt->code != code && opt->code != DHO_END) {
-    // go to next option
-    opt = (const dhcp_option_t*) (((const uint8_t*) opt) + 2 + opt->length);
-  }
-  return opt;
-}
-
 Record::byte_seq DHCPD::get_client_id(const uint8_t* chaddr, const dhcp_option_t* opts) const {
   const dhcp_option_t* opt = get_option(opts, DHO_DHCP_CLIENT_IDENTIFIER);
   Record::byte_seq client_id;

From 562832a709b2c5c2bff671105e19839e571e9c0f Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Tue, 28 Feb 2017 18:00:28 +0100
Subject: [PATCH 31/41] DHCP server and dhclient linux integration test:
 Cleanup of dhclient and check on actually assigned ip

---
 .../dhcp/dhcpd_dhclient_linux/test.py         | 69 ++++++++++++++-----
 1 file changed, 53 insertions(+), 16 deletions(-)

diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
index d683cf180a..fde858526d 100755
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
@@ -5,6 +5,8 @@
 import time
 import subprocess
 
+from threading import Timer
+
 includeos_src = os.environ.get('INCLUDEOS_SRC',
                                os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))).split('/test')[0])
 sys.path.insert(0,includeos_src)
@@ -17,46 +19,73 @@
 # Get an auto-created VM from the vmrunner
 vm = vmrunner.vms[0]
 
+assigned_ip = ""
 num_messages = 0
 ping_passed = False
 ping_count = 3
 
+def cleanup():
+  # Remove leases-file
+  print color.INFO("<Test.py>"), "Removing /var/lib/dhcp/dhclient.leases"
+  subprocess.call(["rm", "/var/lib/dhcp/dhclient.leases"])
+  # Kill dhclient process:
+  subprocess.call(["dhclient", "bridge43", "-4", "-x", "-n", "-v"])
+
 def check_dhclient_output(output):
   global num_messages
+  global assigned_ip
+
+  ip_length = 13
+  ip_index = output.find("10.200.100.")
+
+  if ip_index != -1:
+    assigned_ip = output[ip_index : ip_index + ip_length]
+  else:
+    cleanup()
+    vm.exit(1, "<Test.py> IP not found in output from dhclient")
 
   if "DHCPDISCOVER on bridge43 to 255.255.255.255 port 67" in output:
     num_messages += 1
 
-  if "DHCPOFFER of 10.200.100.20 from 10.200.0.1" in output:
+  if "DHCPOFFER of " + assigned_ip + " from 10.200.0.1" in output:
     num_messages += 1
 
-  if "DHCPREQUEST of 10.200.100.20 on bridge43 to 255.255.255.255 port 67" in output:
+  if "DHCPREQUEST of " + assigned_ip + " on bridge43 to 255.255.255.255 port 67" in output:
     num_messages += 1
 
-  if "DHCPACK of 10.200.100.20 from 10.200.0.1" in output:
+  if "DHCPACK of " + assigned_ip + " from 10.200.0.1" in output:
     num_messages += 1
 
   if num_messages != 4:
-    print color.FAIL("<Test.py> DHCP process FAILED")
+    cleanup()
+    vm.exit(1, "<Test.py> DHCP process FAILED")
 
-def ping_test(ip):
+def ping_test():
   global ping_passed
-  print color.INFO("<Test.py>"), "Assigned address: ", ip
+
+  print color.INFO("<Test.py>"), "Assigned address: ", assigned_ip
   print color.INFO("<Test.py>"), "Trying to ping"
   time.sleep(1)
   try:
-    command = ["ping", ip, "-c", str(ping_count), "-i", "0.2"]
+    command = ["ping", assigned_ip, "-c", str(ping_count), "-i", "0.2"]
     print color.DATA(" ".join(command))
     print subprocess.check_output(command)
     ping_passed = True
   except Exception as e:
     print color.FAIL("<Test.py> Ping FAILED Process threw exception:")
     print e
-    return False
+    cleanup()
+    vm.exit(1, "<Test.py> Ping test failed")
+  finally:
+    cleanup()
 
 def run_dhclient(trigger_line):
   route_output = subprocess.check_output(["route"])
 
+  if "10.0.0.0" not in route_output:
+    subprocess.call(["sudo", "ifconfig", "bridge43", "10.0.0.1", "netmask", "255.255.0.0", "up"])
+    time.sleep(1)
+
   if "10.200.0.0" not in route_output:
     subprocess.call(["route", "add", "-net", "10.200.0.0", "netmask", "255.255.0.0", "dev", "bridge43"])
     print color.INFO("<Test.py>"), "Route added to bridge43, 10.200.0.0"
@@ -67,25 +96,33 @@ def run_dhclient(trigger_line):
     dhclient = subprocess.Popen(
         ["dhclient", "bridge43", "-4", "-n", "-v"],
         stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
+        stderr=subprocess.STDOUT
     )
+    # timeout on dhclient process
+    kill_proc = lambda p: p.kill()
+    timer = Timer(20, kill_proc, [dhclient])
+    timer.start()
     process_output, _ = dhclient.communicate()
+
     print color.INFO("<dhclient>")
     print process_output
+
     check_dhclient_output(process_output)
   except (OSError, subprocess.CalledProcessError) as exception:
+    cleanup()
     print color.FAIL("<Test.py> dhclient FAILED threw exception:")
     print str(exception)
-    return False
-
-  ping_test("10.200.100.20")
+    timer.cancel()
+    vm.exit(1, "<Test.py> dhclient test failed")
+  finally:
+    timer.cancel()
 
-  # Remove leases-file
-  print color.INFO("<Test.py>"), "Removing /var/lib/dhcp/dhclient.leases"
-  subprocess.call(["rm", "/var/lib/dhcp/dhclient.leases"])
+  ping_test()
 
   if ping_passed and num_messages == 4:
-    vm.exit(0,"<Test.py> DHCP process and ping test completed successfully. Process returned 0 exit status")
+    vm.exit(0, "<Test.py> DHCP process and ping test completed successfully. Process returned 0 exit status")
+  else:
+    vm.exit(1, "<Test.py> DHCP process or ping test failed")
 
 # Add custom event-handler
 vm.on_output("Service started", run_dhclient)

From f4d8d5b651919b148993794c2f13552b6abe9310 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Tue, 28 Feb 2017 18:41:30 +0100
Subject: [PATCH 32/41] DHCP integration tests vm.json: Removing cpu:host after
 pull from dev

---
 test/net/integration/dhcp/dhcpd/vm.json                | 1 -
 test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json | 1 -
 2 files changed, 2 deletions(-)

diff --git a/test/net/integration/dhcp/dhcpd/vm.json b/test/net/integration/dhcp/dhcpd/vm.json
index 2779808849..5f945654af 100644
--- a/test/net/integration/dhcp/dhcpd/vm.json
+++ b/test/net/integration/dhcp/dhcpd/vm.json
@@ -4,6 +4,5 @@
           {"device" : "virtio", "mac" : "c0:01:0a:00:00:2f"},
           {"device" : "virtio", "mac" : "c0:01:0a:00:00:20"},
           {"device" : "virtio", "mac" : "c0:01:0a:00:00:23"}],
-  "cpu" : "host",
   "mem" : 128
 }
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json b/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json
index d126a1c1cd..1a6bd77549 100644
--- a/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json
+++ b/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json
@@ -1,6 +1,5 @@
 {
   "image" : "test_dhcp_server_dhclient.img",
   "net" : [{"device" : "virtio", "mac" : "c0:01:0a:00:00:2a"}],
-  "cpu" : "host",
   "mem" : 128
 }

From 4934cf9f7b75a841805d6fe205f794c75a5c3451 Mon Sep 17 00:00:00 2001
From: fwsgonzo <fwsgonzo@hotmail.com>
Date: Wed, 1 Mar 2017 16:00:43 +0100
Subject: [PATCH 33/41] net: IP4 no longer friend of IP4 packet

---
 api/net/ip4/packet_ip4.hpp | 24 +++++++-----------------
 src/net/ip4/ip4.cpp        | 26 +++++++++++++-------------
 2 files changed, 20 insertions(+), 30 deletions(-)

diff --git a/api/net/ip4/packet_ip4.hpp b/api/net/ip4/packet_ip4.hpp
index 809368364c..9de6f41aa8 100644
--- a/api/net/ip4/packet_ip4.hpp
+++ b/api/net/ip4/packet_ip4.hpp
@@ -61,13 +61,8 @@ namespace net {
     { return capacity() - ip_header_length(); }
 
     void set_ip_data_length(uint16_t length) {
-      Expects(data_end() >= layer_begin());
       Expects(sizeof(IP4::header) + length <= (size_t) capacity());
       set_data_end(sizeof(IP4::header) + length);
-      Expects(length <= size());
-      Ensures(data_end() >= layer_begin() + sizeof(IP4::header));
-      Ensures(size() >= length);
-      Ensures(size() < bufsize());
 
       set_segment_length();
     }
@@ -91,18 +86,7 @@ namespace net {
       set_ip_data_length(0);
     }
 
-    /**
-     *  Set IP4 header length
-     *
-     *  Inferred from packet size and linklayer header size
-     */
-    void set_segment_length() noexcept
-    { ip_header().tot_len = htons(size()); }
-
-
   protected:
-
-
     Byte* ip_data() noexcept __attribute__((assume_aligned(4)))
     {
       Expects((size_t)(data_end() - layer_begin()) >= sizeof(IP4::header));
@@ -115,6 +99,13 @@ namespace net {
       return layer_begin() + ip_header_length();
     }
 
+    /**
+     *  Set IP4 header length
+     *  Inferred from packet size
+     */
+    void set_segment_length() noexcept
+    { ip_header().tot_len = htons(size()); }
+
   private:
 
     void set_header_length() noexcept
@@ -132,7 +123,6 @@ namespace net {
       hdr.check = net::checksum(&hdr, ip_header_length());
     }
 
-    friend class IP4;
   }; //< class PacketIP4
 } //< namespace net
 
diff --git a/src/net/ip4/ip4.cpp b/src/net/ip4/ip4.cpp
index 84a3d6f0d2..0e800e6a52 100644
--- a/src/net/ip4/ip4.cpp
+++ b/src/net/ip4/ip4.cpp
@@ -35,23 +35,23 @@ namespace net {
   stack_            {inet}
  { }
 
-  void IP4::receive(Packet_ptr pckt) {
-
+  void IP4::receive(Packet_ptr pckt)
+  {
     // Cast to IP4 Packet
     auto packet = static_unique_ptr_cast<net::PacketIP4>(std::move(pckt));
 
     // Stat increment packets received
     packets_rx_++;
 
-    header* hdr = &packet->ip_header();
-
     debug2("\t Source IP: %s Dest.IP: %s Type: 0x%x\n",
-           hdr->saddr.str().c_str(), hdr->daddr.str().c_str(), hdr->protocol);
+           packet->src().str().c_str(), 
+           packet->dst().str().c_str(), 
+           packet->protocol());
 
     // Drop if my ip address doesn't match destination ip address or broadcast
-    if(UNLIKELY(hdr->daddr != local_ip()
-                and (hdr->daddr | stack_.netmask()) != ADDR_BCAST
-                and local_ip() != ADDR_ANY)) {
+    if (UNLIKELY(packet->dst() != local_ip()
+            and (packet->dst() | stack_.netmask()) != ADDR_BCAST
+            and local_ip() != ADDR_ANY)) {
 
       if (forward_packet_) {
         forward_packet_(stack_, std::move(packet));
@@ -93,19 +93,19 @@ namespace net {
     ship(std::move(ip4_pckt));
   }
 
-  void IP4::ship(Packet_ptr pckt) {
+  void IP4::ship(Packet_ptr pckt)
+  {
     auto ip4_pckt = static_unique_ptr_cast<PacketIP4>(std::move(pckt));
-    IP4::header& hdr = ip4_pckt->ip_header();
 
     // Create local and target subnets
-    addr target = hdr.daddr        & stack_.netmask();
+    addr target = ip4_pckt->dst()  & stack_.netmask();
     addr local  = stack_.ip_addr() & stack_.netmask();
 
     // Compare subnets to know where to send packet
-    addr next_hop {target == local ? hdr.daddr : stack_.gateway()};
+    addr next_hop {target == local ? ip4_pckt->dst() : stack_.gateway()};
 
     debug("<IP4 TOP> Next hop for %s, (netmask %s, local IP: %s, gateway: %s) == %s\n",
-          hdr.daddr.str().c_str(),
+          ip4_pckt->dst().str().c_str(),
           stack_.netmask().str().c_str(),
           stack_.ip_addr().str().c_str(),
           stack_.gateway().str().c_str(),

From 7d885a68ee647f2f3182e2721a5f3503c57e171d Mon Sep 17 00:00:00 2001
From: fwsgonzo <fwsgonzo@hotmail.com>
Date: Wed, 1 Mar 2017 17:03:18 +0100
Subject: [PATCH 34/41] net: Refactor UDP packet and UDP code

---
 api/net/ip4/packet_udp.hpp | 92 ++++++++++++++++++++------------------
 src/net/ip4/udp.cpp        | 44 +++++++++---------
 src/net/ip4/udp_socket.cpp |  6 +--
 3 files changed, 70 insertions(+), 72 deletions(-)

diff --git a/api/net/ip4/packet_udp.hpp b/api/net/ip4/packet_udp.hpp
index 4746fb356f..3dea09b8b3 100644
--- a/api/net/ip4/packet_udp.hpp
+++ b/api/net/ip4/packet_udp.hpp
@@ -26,58 +26,49 @@ namespace net
   class PacketUDP : public PacketIP4
   {
   public:
-
-    UDP::header& header() noexcept
-    {
-      return *reinterpret_cast<UDP::header*>(ip_data());
-    }
-
-    const UDP::header& header() const noexcept
-    {
-      return *reinterpret_cast<const UDP::header*>(ip_data());
-    }
-
-    //! initializes to a default, empty UDP packet, given
-    //! a valid MTU-sized buffer
-    void init()
+    void init(uint16_t l_port, uint16_t d_port)
     {
-
-      // Promote to IP4 packet
-      // PacketIP4::init();
-      Expects(layer_begin() > buf());
       Expects(data_end() == layer_begin() + ip_header_length());
 
-      // Promote to UDP packet
-      increment_data_end(sizeof(UDP::header));
-      Ensures(data_end() == layer_begin() + ip_header_length() + sizeof(UDP::header));
-
       // Initialize UDP packet header
       // source and destination ports
-      header().sport = 0;
-      header().dport = 0;
+      set_src_port(l_port);
+      set_dst_port(d_port);
       // set zero length
-      set_length(0);
+      set_length(sizeof(UDP::header));
       // zero the optional checksum
       header().checksum = 0;
       set_protocol(Protocol::UDP);
     }
 
-    UDP::port_t src_port() const
+    void set_src_port(uint16_t port) noexcept
+    {
+      header().sport = htons(port);
+    }
+    UDP::port_t src_port() const noexcept
     {
       return htons(header().sport);
     }
 
-    UDP::port_t dst_port() const
+    void set_dst_port(uint16_t port) noexcept
+    {
+      header().dport = htons(port);
+    }
+    UDP::port_t dst_port() const noexcept
     {
       return htons(header().dport);
     }
 
-    uint16_t length() const
+    uint16_t length() const noexcept
     {
       return ntohs(header().length);
     }
 
-    uint16_t data_length() const
+    void set_data_length(uint16_t len)
+    {
+      set_length(sizeof(UDP::header) + len);
+    }
+    uint16_t data_length() const noexcept
     {
       return length() - sizeof(UDP::header);
     }
@@ -97,31 +88,44 @@ namespace net
       return begin() + length();
     }
 
+    // generates IP checksum for this packet
+    // TODO: implement me
+    uint16_t generate_checksum() const noexcept;
+
+    //! assuming the packet has been properly initialized,
+    //! this will fill bytes from @buffer into this packets buffer,
+    //! then return the number of bytes written
+    uint32_t fill(const std::string& buffer)
+    {
+      uint32_t rem   = buffer_end() - data_end();
+      uint32_t total = (buffer.size() < rem) ? buffer.size() : rem;
+      // copy from buffer to packet buffer
+      memcpy(data_end(), buffer.data(), total);
+      // set new packet length
+      set_length(length() + total);
+      return total;
+    }
+
+  private:
     // Sets the correct length for UDP and the packet
     void set_length(uint16_t newlen)
     {
       // new total UDP payload length
-      header().length = htons(sizeof(UDP::header) + newlen);
+      header().length = htons(newlen);
 
       // new total packet length
-      set_data_end(ip_header_length() + sizeof(UDP::header) + newlen );
+      set_data_end(ip_header_length() + newlen);
     }
 
-    // generates a new checksum and sets it for this UDP packet
-    uint16_t gen_checksum();
+    UDP::header& header() noexcept
+    {
+      return *reinterpret_cast<UDP::header*>(ip_data());
+    }
 
-    //! assuming the packet has been properly initialized,
-    //! this will fill bytes from @buffer into this packets buffer,
-    //! then return the number of bytes written. buffer is unmodified
-    uint32_t fill(const std::string& buffer)
+    const UDP::header& header() const noexcept
     {
-      uint32_t rem = capacity();
-      uint32_t total = (buffer.size() < rem) ? buffer.size() : rem;
-      // copy from buffer to packet buffer
-      memcpy(data() + data_length(), buffer.data(), total);
-      // set new packet length
-      set_length(data_length() + total);
-      return total;
+      return *reinterpret_cast<const UDP::header*>(ip_data());
     }
+
   };
 }
diff --git a/src/net/ip4/udp.cpp b/src/net/ip4/udp.cpp
index b197bdc6a2..c1bce7503e 100644
--- a/src/net/ip4/udp.cpp
+++ b/src/net/ip4/udp.cpp
@@ -113,25 +113,25 @@ namespace net {
   void UDP::process_sendq(size_t num)
   {
     while (!sendq.empty() && num != 0)
-      {
-        WriteBuffer& buffer = sendq.front();
-
-        // create and transmit packet from writebuffer
-        buffer.write();
-        num--;
-
-        if (buffer.done()) {
-          auto copy = buffer.callback;
-          // remove buffer from queue
-          sendq.pop_front();
-          // call on_written callback
-          copy();
-          // reduce @num, just in case packets were sent in
-          // another stack frame
-          size_t avail = stack_.transmit_queue_available();
-          num = (num > avail) ? avail : num;
-        }
+    {
+      WriteBuffer& buffer = sendq.front();
+
+      // create and transmit packet from writebuffer
+      buffer.write();
+      num--;
+
+      if (buffer.done()) {
+        auto copy = buffer.callback;
+        // remove buffer from queue
+        sendq.pop_front();
+        // call on_written callback
+        copy();
+        // reduce @num, just in case packets were sent in
+        // another stack frame
+        size_t avail = stack_.transmit_queue_available();
+        num = (num > avail) ? avail : num;
       }
+    }
   }
 
   size_t UDP::WriteBuffer::packets_needed() const
@@ -159,7 +159,6 @@ namespace net {
 
   void UDP::WriteBuffer::write()
   {
-
     UDP::Packet_ptr chain_head = nullptr;
 
     debug("<UDP> %i bytes to write, need %i packets \n",
@@ -175,14 +174,11 @@ namespace net {
       if (!p) break;
 
       auto p2 = static_unique_ptr_cast<PacketUDP>(std::move(p));
-
       // Initialize UDP packet
-      p2->init();
-      p2->header().sport = htons(l_port);
-      p2->header().dport = htons(d_port);
+      p2->init(l_port, d_port);
       p2->set_src(l_addr);
       p2->set_dst(d_addr);
-      p2->set_length(total);
+      p2->set_data_length(total);
 
       // fill buffer (at payload position)
       memcpy(p2->data(), buf.get() + this->offset, total);
diff --git a/src/net/ip4/udp_socket.cpp b/src/net/ip4/udp_socket.cpp
index 3cdef12526..a1b38c3827 100644
--- a/src/net/ip4/udp_socket.cpp
+++ b/src/net/ip4/udp_socket.cpp
@@ -32,12 +32,10 @@ namespace net
       port_t port,
       uint16_t length)
   {
-    p->init();
-    p->header().sport = htons(this->l_port);
-    p->header().dport = htons(port);
+    p->init(this->l_port, port);
     p->set_src(srcIP);
     p->set_dst(destIP);
-    p->set_length(length);
+    p->set_data_length(length);
 
     assert(p->data_length() == length);
   }

From f35e79e7075245565bb26acae38bf5e6769269cf Mon Sep 17 00:00:00 2001
From: fwsgonzo <fwsgonzo@hotmail.com>
Date: Wed, 1 Mar 2017 19:08:50 +0100
Subject: [PATCH 35/41] net: Fix broadcasts not passing IP layer properly

---
 src/net/ip4/ip4.cpp | 26 +++++++++++++++++---------
 src/net/ip4/udp.cpp | 33 ++++++++++++++++++++-------------
 2 files changed, 37 insertions(+), 22 deletions(-)

diff --git a/src/net/ip4/ip4.cpp b/src/net/ip4/ip4.cpp
index 0e800e6a52..a6c36274c7 100644
--- a/src/net/ip4/ip4.cpp
+++ b/src/net/ip4/ip4.cpp
@@ -97,19 +97,27 @@ namespace net {
   {
     auto ip4_pckt = static_unique_ptr_cast<PacketIP4>(std::move(pckt));
 
-    // Create local and target subnets
-    addr target = ip4_pckt->dst()  & stack_.netmask();
-    addr local  = stack_.ip_addr() & stack_.netmask();
-
-    // Compare subnets to know where to send packet
-    addr next_hop {target == local ? ip4_pckt->dst() : stack_.gateway()};
-
-    debug("<IP4 TOP> Next hop for %s, (netmask %s, local IP: %s, gateway: %s) == %s\n",
+    addr next_hop;
+    // Keep IP when broadcasting to all
+    if (ip4_pckt->dst() != IP4::ADDR_BCAST)
+    {
+      // Create local and target subnets
+      addr target = ip4_pckt->dst()  & stack_.netmask();
+      addr local  = stack_.ip_addr() & stack_.netmask();
+
+      // Compare subnets to know where to send packet
+      next_hop = target == local ? ip4_pckt->dst() : stack_.gateway();
+
+      printf("<IP4 TOP> Next hop for %s, (netmask %s, local IP: %s, gateway: %s) == %s\n",
           ip4_pckt->dst().str().c_str(),
           stack_.netmask().str().c_str(),
           stack_.ip_addr().str().c_str(),
           stack_.gateway().str().c_str(),
-          target == local ? "DIRECT" : "GATEWAY");
+          next_hop.str().c_str());
+    }
+    else {
+      next_hop = IP4::ADDR_BCAST;
+    }
 
     // Stat increment packets transmitted
     packets_tx_++;
diff --git a/src/net/ip4/udp.cpp b/src/net/ip4/udp.cpp
index c1bce7503e..4250ad8610 100644
--- a/src/net/ip4/udp.cpp
+++ b/src/net/ip4/udp.cpp
@@ -28,28 +28,33 @@ namespace net {
       stack_(inet),
       ports_{},
       current_port_{new_ephemeral_port()}
-{
-  inet.on_transmit_queue_available({this, &UDP::process_sendq});
-}
+  {
+    inet.on_transmit_queue_available({this, &UDP::process_sendq});
+  }
 
   void UDP::receive(net::Packet_ptr pckt)
   {
     auto udp = static_unique_ptr_cast<PacketUDP>(std::move(pckt));
 
-    debug("\t Source port: %i, Dest. Port: %i Length: %i\n",
+    debug("<%s> UDP", stack_.ifname().c_str());
+    debug("\t Source port: %u, Dest. Port: %u Length: %u\n",
           udp->src_port(), udp->dst_port(), udp->length());
 
     auto it = ports_.find(udp->dst_port());
     if (LIKELY(it != ports_.end())) {
+      debug("<%s> UDP found listener on port %u\n", 
+              stack_.ifname().c_str(), udp->dst_port());
       it->second.internal_read(std::move(udp));
       return;
     }
 
-    debug("<UDP> Nobody's listening to this port. Drop!\n");
+    debug("<%s> UDP: nobody listening on %u. Drop!\n", 
+            stack_.ifname().c_str(), udp->dst_port());
   }
 
   UDPSocket& UDP::bind(UDP::port_t port)
   {
+    debug("<%s> UDP bind to port %d\n", stack_.ifname().c_str(), port);
     /// bind(0) == bind()
     if (port == 0) return bind();
     /// ... !!!
@@ -57,9 +62,9 @@ namespace net {
     if (LIKELY(it == ports_.end())) {
       // create new socket
       auto res = ports_.emplace(
-                                std::piecewise_construct,
-                                std::forward_as_tuple(port),
-                                std::forward_as_tuple(*this, port));
+            std::piecewise_construct,
+            std::forward_as_tuple(port),
+            std::forward_as_tuple(*this, port));
       it = res.first;
     }else {
       throw UDP::Port_in_use_exception(it->first);
@@ -76,7 +81,6 @@ namespace net {
       // prevent automatic ports under 1024
       if (current_port_  == port_ranges::DYNAMIC_END) current_port_ = port_ranges::DYNAMIC_START;
 
-    debug("UDP bind to port %d\n", current_port_);
     return bind(current_port_);
   }
 
@@ -87,14 +91,15 @@ namespace net {
 
   void UDP::close(UDP::port_t port)
   {
+    debug("Closed port %u\n", port);
     if (is_bound(port))
       ports_.erase(port);
   }
 
   void UDP::transmit(UDP::Packet_ptr udp)
   {
-    debug2("<UDP> Transmitting %i bytes (seg=%i) from %s to %s:%i\n",
-           udp->length(), udp->ip4_segment_size(),
+    debug("<UDP> Transmitting %u bytes (data=%u) from %s to %s:%i\n",
+           udp->length(), udp->data_length(),
            udp->src().str().c_str(),
            udp->dst().str().c_str(), udp->dst_port());
 
@@ -161,8 +166,10 @@ namespace net {
   {
     UDP::Packet_ptr chain_head = nullptr;
 
-    debug("<UDP> %i bytes to write, need %i packets \n",
-          remaining(), remaining() / udp.max_datagram_size() + (remaining() % udp.max_datagram_size() ? 1 : 0));
+    debug("<%s> UDP: %i bytes to write, need %i packets \n",
+          udp.stack().ifname().c_str(),
+          remaining(), 
+          remaining() / udp.max_datagram_size() + (remaining() % udp.max_datagram_size() ? 1 : 0));
 
     while (remaining()) {
       // the max bytes we can write in one operation

From 0ae3776c6d45d398f2fd954e575242114400737a Mon Sep 17 00:00:00 2001
From: fwsgonzo <fwsgonzo@hotmail.com>
Date: Wed, 1 Mar 2017 20:17:59 +0100
Subject: [PATCH 36/41] net: Silence debug message in IP4

---
 src/net/ip4/ip4.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/ip4/ip4.cpp b/src/net/ip4/ip4.cpp
index a6c36274c7..d1120ceeca 100644
--- a/src/net/ip4/ip4.cpp
+++ b/src/net/ip4/ip4.cpp
@@ -108,7 +108,7 @@ namespace net {
       // Compare subnets to know where to send packet
       next_hop = target == local ? ip4_pckt->dst() : stack_.gateway();
 
-      printf("<IP4 TOP> Next hop for %s, (netmask %s, local IP: %s, gateway: %s) == %s\n",
+      debug("<IP4 TOP> Next hop for %s, (netmask %s, local IP: %s, gateway: %s) == %s\n",
           ip4_pckt->dst().str().c_str(),
           stack_.netmask().str().c_str(),
           stack_.ip_addr().str().c_str(),

From 02fdde1022c404bba08b6f693cddfff33793db4d Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 1 Mar 2017 20:26:35 +0100
Subject: [PATCH 37/41] Moved dhcp integration tests (3) one level up (no
 longer in shared dhcp folder) because Jenkins complains about missing
 CMakeLists.txt

---
 test/net/integration/{dhcp => }/dhclient/CMakeLists.txt           | 0
 test/net/integration/{dhcp => }/dhclient/README.md                | 0
 test/net/integration/{dhcp => }/dhclient/service.cpp              | 0
 test/net/integration/{dhcp => }/dhclient/test.py                  | 0
 test/net/integration/{dhcp => }/dhclient/vm.json                  | 0
 test/net/integration/{dhcp => }/dhcpd/CMakeLists.txt              | 0
 test/net/integration/{dhcp => }/dhcpd/README.md                   | 0
 test/net/integration/{dhcp => }/dhcpd/service.cpp                 | 0
 test/net/integration/{dhcp => }/dhcpd/test.py                     | 0
 test/net/integration/{dhcp => }/dhcpd/vm.json                     | 0
 .../integration/{dhcp => }/dhcpd_dhclient_linux/CMakeLists.txt    | 0
 test/net/integration/{dhcp => }/dhcpd_dhclient_linux/README.md    | 0
 test/net/integration/{dhcp => }/dhcpd_dhclient_linux/service.cpp  | 0
 test/net/integration/{dhcp => }/dhcpd_dhclient_linux/test.py      | 0
 test/net/integration/{dhcp => }/dhcpd_dhclient_linux/vm.json      | 0
 15 files changed, 0 insertions(+), 0 deletions(-)
 rename test/net/integration/{dhcp => }/dhclient/CMakeLists.txt (100%)
 rename test/net/integration/{dhcp => }/dhclient/README.md (100%)
 rename test/net/integration/{dhcp => }/dhclient/service.cpp (100%)
 rename test/net/integration/{dhcp => }/dhclient/test.py (100%)
 rename test/net/integration/{dhcp => }/dhclient/vm.json (100%)
 rename test/net/integration/{dhcp => }/dhcpd/CMakeLists.txt (100%)
 rename test/net/integration/{dhcp => }/dhcpd/README.md (100%)
 rename test/net/integration/{dhcp => }/dhcpd/service.cpp (100%)
 rename test/net/integration/{dhcp => }/dhcpd/test.py (100%)
 rename test/net/integration/{dhcp => }/dhcpd/vm.json (100%)
 rename test/net/integration/{dhcp => }/dhcpd_dhclient_linux/CMakeLists.txt (100%)
 rename test/net/integration/{dhcp => }/dhcpd_dhclient_linux/README.md (100%)
 rename test/net/integration/{dhcp => }/dhcpd_dhclient_linux/service.cpp (100%)
 rename test/net/integration/{dhcp => }/dhcpd_dhclient_linux/test.py (100%)
 rename test/net/integration/{dhcp => }/dhcpd_dhclient_linux/vm.json (100%)

diff --git a/test/net/integration/dhcp/dhclient/CMakeLists.txt b/test/net/integration/dhclient/CMakeLists.txt
similarity index 100%
rename from test/net/integration/dhcp/dhclient/CMakeLists.txt
rename to test/net/integration/dhclient/CMakeLists.txt
diff --git a/test/net/integration/dhcp/dhclient/README.md b/test/net/integration/dhclient/README.md
similarity index 100%
rename from test/net/integration/dhcp/dhclient/README.md
rename to test/net/integration/dhclient/README.md
diff --git a/test/net/integration/dhcp/dhclient/service.cpp b/test/net/integration/dhclient/service.cpp
similarity index 100%
rename from test/net/integration/dhcp/dhclient/service.cpp
rename to test/net/integration/dhclient/service.cpp
diff --git a/test/net/integration/dhcp/dhclient/test.py b/test/net/integration/dhclient/test.py
similarity index 100%
rename from test/net/integration/dhcp/dhclient/test.py
rename to test/net/integration/dhclient/test.py
diff --git a/test/net/integration/dhcp/dhclient/vm.json b/test/net/integration/dhclient/vm.json
similarity index 100%
rename from test/net/integration/dhcp/dhclient/vm.json
rename to test/net/integration/dhclient/vm.json
diff --git a/test/net/integration/dhcp/dhcpd/CMakeLists.txt b/test/net/integration/dhcpd/CMakeLists.txt
similarity index 100%
rename from test/net/integration/dhcp/dhcpd/CMakeLists.txt
rename to test/net/integration/dhcpd/CMakeLists.txt
diff --git a/test/net/integration/dhcp/dhcpd/README.md b/test/net/integration/dhcpd/README.md
similarity index 100%
rename from test/net/integration/dhcp/dhcpd/README.md
rename to test/net/integration/dhcpd/README.md
diff --git a/test/net/integration/dhcp/dhcpd/service.cpp b/test/net/integration/dhcpd/service.cpp
similarity index 100%
rename from test/net/integration/dhcp/dhcpd/service.cpp
rename to test/net/integration/dhcpd/service.cpp
diff --git a/test/net/integration/dhcp/dhcpd/test.py b/test/net/integration/dhcpd/test.py
similarity index 100%
rename from test/net/integration/dhcp/dhcpd/test.py
rename to test/net/integration/dhcpd/test.py
diff --git a/test/net/integration/dhcp/dhcpd/vm.json b/test/net/integration/dhcpd/vm.json
similarity index 100%
rename from test/net/integration/dhcp/dhcpd/vm.json
rename to test/net/integration/dhcpd/vm.json
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/CMakeLists.txt b/test/net/integration/dhcpd_dhclient_linux/CMakeLists.txt
similarity index 100%
rename from test/net/integration/dhcp/dhcpd_dhclient_linux/CMakeLists.txt
rename to test/net/integration/dhcpd_dhclient_linux/CMakeLists.txt
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/README.md b/test/net/integration/dhcpd_dhclient_linux/README.md
similarity index 100%
rename from test/net/integration/dhcp/dhcpd_dhclient_linux/README.md
rename to test/net/integration/dhcpd_dhclient_linux/README.md
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp b/test/net/integration/dhcpd_dhclient_linux/service.cpp
similarity index 100%
rename from test/net/integration/dhcp/dhcpd_dhclient_linux/service.cpp
rename to test/net/integration/dhcpd_dhclient_linux/service.cpp
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcpd_dhclient_linux/test.py
similarity index 100%
rename from test/net/integration/dhcp/dhcpd_dhclient_linux/test.py
rename to test/net/integration/dhcpd_dhclient_linux/test.py
diff --git a/test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json b/test/net/integration/dhcpd_dhclient_linux/vm.json
similarity index 100%
rename from test/net/integration/dhcp/dhcpd_dhclient_linux/vm.json
rename to test/net/integration/dhcpd_dhclient_linux/vm.json

From ebeb0a1d1338e201bed6db94093a0773012b9dd4 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 1 Mar 2017 20:47:41 +0100
Subject: [PATCH 38/41] dhcpd dhclient linux integration test: Added sudo to
 dhclient command because Jenkins showed Operation not permitted

---
 test/net/integration/dhcpd_dhclient_linux/test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/net/integration/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcpd_dhclient_linux/test.py
index fde858526d..26d9ecbb75 100755
--- a/test/net/integration/dhcpd_dhclient_linux/test.py
+++ b/test/net/integration/dhcpd_dhclient_linux/test.py
@@ -94,7 +94,7 @@ def run_dhclient(trigger_line):
 
   try:
     dhclient = subprocess.Popen(
-        ["dhclient", "bridge43", "-4", "-n", "-v"],
+        ["sudo", "dhclient", "bridge43", "-4", "-n", "-v"],
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT
     )

From 7fc0f8b1c04d29c4d9dbbddb8f9866113ff04267 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 1 Mar 2017 21:53:06 +0100
Subject: [PATCH 39/41] DHCP server dhclient linux integration test: Adding
 sudo

---
 test/net/integration/dhcpd_dhclient_linux/test.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/net/integration/dhcpd_dhclient_linux/test.py b/test/net/integration/dhcpd_dhclient_linux/test.py
index 26d9ecbb75..1c00d9a18a 100755
--- a/test/net/integration/dhcpd_dhclient_linux/test.py
+++ b/test/net/integration/dhcpd_dhclient_linux/test.py
@@ -27,9 +27,9 @@
 def cleanup():
   # Remove leases-file
   print color.INFO("<Test.py>"), "Removing /var/lib/dhcp/dhclient.leases"
-  subprocess.call(["rm", "/var/lib/dhcp/dhclient.leases"])
+  subprocess.call(["sudo", "rm", "/var/lib/dhcp/dhclient.leases"])
   # Kill dhclient process:
-  subprocess.call(["dhclient", "bridge43", "-4", "-x", "-n", "-v"])
+  subprocess.call(["sudo", "dhclient", "bridge43", "-4", "-x", "-n", "-v"])
 
 def check_dhclient_output(output):
   global num_messages
@@ -87,7 +87,7 @@ def run_dhclient(trigger_line):
     time.sleep(1)
 
   if "10.200.0.0" not in route_output:
-    subprocess.call(["route", "add", "-net", "10.200.0.0", "netmask", "255.255.0.0", "dev", "bridge43"])
+    subprocess.call(["sudo", "route", "add", "-net", "10.200.0.0", "netmask", "255.255.0.0", "dev", "bridge43"])
     print color.INFO("<Test.py>"), "Route added to bridge43, 10.200.0.0"
 
   print color.INFO("<Test.py>"), "Running dhclient"

From 3b903c7d9a5cd81b15d1f2c360f4140bc91dc6f2 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 1 Mar 2017 22:18:39 +0100
Subject: [PATCH 40/41] dhclient integration test vm.json: Removed cpu:host

---
 test/net/integration/dhclient/vm.json | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/net/integration/dhclient/vm.json b/test/net/integration/dhclient/vm.json
index f7212f381d..902fa0d7f3 100644
--- a/test/net/integration/dhclient/vm.json
+++ b/test/net/integration/dhclient/vm.json
@@ -1,6 +1,5 @@
 {
   "image" : "test_dhcp.img",
   "net" : [{"device" : "virtio", "mac" : "c0:01:0a:00:00:2a"}],
-  "cpu"   : "host",
   "time_sensitive" : "True"
 }

From f11f8619858512cea639fefc1c167acfe547b579 Mon Sep 17 00:00:00 2001
From: Annika Hammervoll <annika_limfe@hotmail.com>
Date: Wed, 1 Mar 2017 23:03:24 +0100
Subject: [PATCH 41/41] DHCP server: Debug info added and updated
 clear_offered_ips method

---
 api/net/dhcp/dhcpd.hpp | 50 ++++++++++++++++++++++++
 src/net/dhcp/dhcpd.cpp | 88 ++++++++++++++++++++++++++++++++++++++----
 2 files changed, 131 insertions(+), 7 deletions(-)

diff --git a/api/net/dhcp/dhcpd.hpp b/api/net/dhcp/dhcpd.hpp
index 4410aaca4e..c6ca5b3875 100644
--- a/api/net/dhcp/dhcpd.hpp
+++ b/api/net/dhcp/dhcpd.hpp
@@ -155,6 +155,56 @@ namespace dhcp {
 
     void clear_offered_ip(IP4::addr ip);
     void clear_offered_ips();
+
+    void print(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
+      debug("Printing:\n");
+
+      debug("OP: %u\n", msg->op);
+      debug("HTYPE: %u\n", msg->htype);
+      debug("HLEN: %u\n", msg->hlen);
+      debug("HOPS: %u\n", msg->hops);
+      debug("XID: %u\n", msg->xid);
+      debug("SECS: %u\n", msg->secs);
+      debug("FLAGS: %u\n", msg->flags);
+      debug("CIADDR (IP4::addr): %s\n", msg->ciaddr.to_string().c_str());
+      debug("YIADDR (IP4::addr): %s\n", msg->yiaddr.to_string().c_str());
+      debug("SIADDR (IP4::addr): %s\n", msg->siaddr.to_string().c_str());
+      debug("GIADDR (IP4::addr): %s\n", msg->giaddr.to_string().c_str());
+
+      debug("\nCHADDR:\n");
+      for (int i = 0; i < dhcp_packet_t::CHADDR_LEN; i++)
+        debug("%u ", msg->chaddr[i]);
+      debug("\n");
+
+      debug("\nSNAME:\n");
+      for (int i = 0; i < dhcp_packet_t::SNAME_LEN; i++)
+        debug("%u ", msg->sname[i]);
+      debug("\n");
+
+      debug("\nFILE:\n");
+      for (int i = 0; i < dhcp_packet_t::FILE_LEN; i++)
+        debug("%u ", msg->file[i]);
+      debug("\n");
+
+      debug("\nMAGIC:\n");
+      for (int i = 0; i < 4; i++)
+        debug("%u ", msg->magic[i]);
+      debug("\n");
+
+      // Opts
+
+      while(opts->code != DHO_END) {
+        debug("\nOptions->code: %d\n", opts->code);
+        debug("\nOptions->length: %d\n", opts->length);
+
+        debug("\nOptions->val: ");
+        for (size_t i = 0; i < opts->length; i++)
+          debug("%d ", opts->val[i]);
+        debug("\n");
+
+        opts = (const dhcp_option_t*) (((const uint8_t*) opts) + 2 + opts->length);
+      }
+    }
   };
 
 } // < namespace dhcp
diff --git a/src/net/dhcp/dhcpd.cpp b/src/net/dhcp/dhcpd.cpp
index 4d67a8fa82..dbb40fa1e5 100644
--- a/src/net/dhcp/dhcpd.cpp
+++ b/src/net/dhcp/dhcpd.cpp
@@ -112,35 +112,59 @@ void DHCPD::listen() {
 }
 
 void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
-  if (msg->op not_eq BOOTREQUEST or msg->hops not_eq 0)
+  if (msg->op not_eq BOOTREQUEST or msg->hops not_eq 0) {
+    debug("Invalid op\n");
     return;
+  }
 
-  if (msg->htype == 0 or msg->htype > HTYPE_HFI)  // http://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml
+  if (msg->htype == 0 or msg->htype > HTYPE_HFI) {  // http://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml
+    debug("Invalid htype\n");
     return;
+  }
 
-  if (msg->yiaddr not_eq IP4::addr{0} or msg->siaddr not_eq IP4::addr{0} or msg->giaddr not_eq IP4::addr{0})
+  if (msg->yiaddr not_eq IP4::addr{0} or msg->siaddr not_eq IP4::addr{0} or msg->giaddr not_eq IP4::addr{0}) {
+    debug("Invalid yiaddr, siaddr or giaddr\n");
     return;
+  }
 
-  if (not valid_options(opts))
+  if (not valid_options(opts)) {
+    debug("Invalid options\n");
     return;
+  }
 
   const auto cid = get_client_id(msg->chaddr, opts);
-  if (cid.empty() or std::all_of(cid.begin(), cid.end(), [] (int i) { return i == 0; }))
+  if (cid.empty() or std::all_of(cid.begin(), cid.end(), [] (int i) { return i == 0; })) {
+    debug("Invalid client id\n");
     return;
+  }
 
-  if (msg->magic[0] not_eq 99 or msg->magic[1] not_eq 130 or msg->magic[2] not_eq 83 or msg->magic[3] not_eq 99)
+  if (msg->magic[0] not_eq 99 or msg->magic[1] not_eq 130 or msg->magic[2] not_eq 83 or msg->magic[3] not_eq 99) {
+    debug("Invalid magic\n");
     return;
+  }
 
   int ridx;
 
   switch (opts->val[0]) {
     case DHCPDISCOVER:
+
+      debug("------------Discover------------\n");
+      print(msg, opts);
+
       offer(msg, opts);
       break;
     case DHCPREQUEST:
+
+      debug("-------------Request--------------\n");
+      print(msg, opts);
+
       handle_request(msg, opts);
       break;
     case DHCPDECLINE:
+
+      debug("-------------Decline--------------\n");
+      print(msg, opts);
+
       // A client has discovered that the suggested network address is already in use.
       // The server must mark the network address as not available and should notify the network admin
       // of a possible configuration problem - TODO
@@ -151,6 +175,10 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       update_pool(get_requested_ip_in_opts(opts), Status::IN_USE);    // In use - possible config problem
       break;
     case DHCPRELEASE:
+
+      debug("--------------Release--------------\n");
+      print(msg, opts);
+
       // Mark the network address as not allocated anymore
       // Should retain a record of the client's initialization parameters for possible reuse
       // in response to subsequent requests from the client
@@ -168,6 +196,10 @@ void DHCPD::resolve(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
       // update_pool(msg->ciaddr, Status::RELEASED);
 
     case DHCPINFORM:
+
+      debug("---------------Inform---------------\n");
+      print(msg, opts);
+
       inform_ack(msg);
       break;
   }
@@ -186,8 +218,14 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
     IP4::addr sid{opt->val[0], opt->val[1], opt->val[2], opt->val[3]};
 
     if (sid not_eq server_id()) { // The client has not chosen this server
+
+      debug("Client hasn't chosen this server - returning\n");
+
       int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
       if (ridx != -1) {
+
+        debug("Freeing up record\n");
+
         // Free up the IP address - the client has declined our offer
         update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
         records_.erase(records_.begin() + ridx);
@@ -197,6 +235,8 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
 
     // Server identifier == this server's ID
 
+    debug("Client has chosen this server\n");
+
     int ridx = get_record_idx(get_client_id(msg->chaddr, opts));
 
     if (ridx not_eq -1) { // A record for this client already exists
@@ -214,18 +254,24 @@ void DHCPD::handle_request(const dhcp_packet_t* msg, const dhcp_option_t* opts)
         return;
       }
 
+      debug("ciaddr not zero or not correct requested ip - sending nak\n");
+
       // Else ciaddr is not zero or record's ip is not the same as the requested ip in the request
       // TODO: nak() or silent return?
       nak(msg);
       return;
     }
 
+    debug("No record of this client exists - sending nak\n");
+
     // Else a record with this client id doesn't exist
     // TODO: nak() or silent return?
     nak(msg);
     return;
   }
 
+  debug("Verifying or extending lease\n");
+
   // Else server identifier is not filled in and this is not a response to a DHCPOFFER message, but
   // a request to verify or extend an existing lease
   verify_or_extend_lease(msg, opts);
@@ -244,6 +290,8 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     // Then the client is seeking to verify a previously allocated, cached configuration
     // Client state: INIT-REBOOT
 
+    debug("Init-reboot\n");
+
     // 1. (Before or in the if statement) Check if on correct network
     // Server should send a DHCPNAK if the client is on the wrong network
     // If the server detects that the client is on the wrong net (i.e., the result of applying the local
@@ -251,6 +299,9 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
     // match reality), then the server should send a DHCPNAK message to the client.
     // 2. (After or in the if statement) If client is on correct network: Check if the client's notion of IP is correct
     if ((not on_correct_network(msg->giaddr, opts)) or (get_requested_ip_in_opts(opts) not_eq records_.at(ridx).ip())) {
+
+      debug("Client not on correct network\n");
+
       // Updating pool and erasing record
       update_pool(records_.at(ridx).ip(), Status::AVAILABLE);
       records_.erase(records_.begin() + ridx);
@@ -288,6 +339,8 @@ void DHCPD::verify_or_extend_lease(const dhcp_packet_t* msg, const dhcp_option_t
 
     // Table 4 page 33 in RFC 2131 - Fields in client message from client in different state
 
+    debug("Renewing or rebinding state\n");
+
     // Extend the lease or not - should send a DHCPACK regardless
     // Update record and pool
     auto& record = records_.at(ridx);
@@ -329,6 +382,9 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   bool ok = false;
   for (auto& entry : pool_) {
     if (entry.second == Status::AVAILABLE) {
+
+      debug("Found available IP: %s\n", entry.first.to_string().c_str());
+
       entry.second = Status::OFFERED;
       offer->yiaddr = entry.first;
       ok = true;
@@ -348,6 +404,9 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
     }
   }
   if (not ok) { // Then no IP is available - sending DHCPNAK
+
+    debug("No more available IPs - clearing offered ips and sending nak\n");
+
     // Clear offered ips that have not been confirmed - Maybe use pending value instead
     clear_offered_ips();
     nak(msg);   // Record has not been added to the records_ vector so OK
@@ -461,6 +520,8 @@ void DHCPD::offer(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   // RECORD
   add_record(record);
 
+  debug("Sending offer\n");
+
   // If the giaddr field in a DHCP message from a client is non-zero, the server sends any return
   // messages to the DHCP server port on the BOOTP relay agent whose address appears in giaddr
   if (msg->giaddr != IP4::addr{0}) {
@@ -533,6 +594,8 @@ void DHCPD::inform_ack(const dhcp_packet_t* msg) {
   ack_opts->length = 1;
   ack_opts->val[0] = DHCPACK;
 
+  debug("Sending inform ack\n");
+
   // TODO Add options requested by the client
 
   // Send the DHCPACK - Unicast to DHCPINFORM message's ciaddr field
@@ -609,6 +672,8 @@ void DHCPD::request_ack(const dhcp_packet_t* msg, const dhcp_option_t* opts) {
   ack_opts->code   = DHO_END;
   ack_opts->length = 0;
 
+  debug("Sending request ack\n");
+
   // If the giaddr field in a DHCP message from a client is non-zero, the server sends any return
   // messages to the DHCP server port on the BOOTP relay agent whose address appears in giaddr
   if (msg->giaddr != IP4::addr{0}) {
@@ -681,6 +746,8 @@ void DHCPD::nak(const dhcp_packet_t* msg) {
   nak_opts->code = DHO_END;
   nak_opts->length = 0;
 
+  debug("Sending NAK\n");
+
   // Send the DHCPNAK - Broadcast
   socket_.bcast(server_id_, DHCP_CLIENT_PORT, packet, PACKET_SIZE);
 }
@@ -769,10 +836,17 @@ void DHCPD::clear_offered_ip(IP4::addr ip) {
 }
 
 void DHCPD::clear_offered_ips() {
+  // looping through pool
+  for (auto& entry : pool_) {
+    if (entry.second == Status::OFFERED)
+      entry.second = Status::AVAILABLE;
+  }
+
+  // and records
   for (size_t i = 0; i < records_.size(); i++) {
     if (records_.at(i).status() == Status::OFFERED) {
       // Update pool
-      update_pool(records_.at(i).ip(), Status::AVAILABLE);
+      // update_pool(records_.at(i).ip(), Status::AVAILABLE);
       // And erase record
       records_.erase(records_.begin() + i);
     }