src/libsystemd-network/test-dhcp-server.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2013 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <errno.h>
   7
   8 #include "sd-dhcp-server.h"
   9 #include "sd-event.h"
  10
  11 #include "dhcp-server-internal.h"
  12 #include "tests.h"
  13
  14 static void test_pool(struct in_addr *address, unsigned size, int ret) {
  15         _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
  16
  17         assert_se(sd_dhcp_server_new(&server, 1) >= 0);
  18
  19         assert_se(sd_dhcp_server_configure_pool(server, address, 8, 0, size) == ret);
  20 }
  21
  22 static int test_basic(sd_event *event) {
  23         _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
  24         struct in_addr address_lo = {
  25                 .s_addr = htonl(INADDR_LOOPBACK),
  26         };
  27         struct in_addr address_any = {
  28                 .s_addr = htonl(INADDR_ANY),
  29         };
  30         int r;
  31
  32         /* attach to loopback interface */
  33         assert_se(sd_dhcp_server_new(&server, 1) >= 0);
  34         assert_se(server);
  35
  36         assert_se(sd_dhcp_server_attach_event(server, event, 0) >= 0);
  37         assert_se(sd_dhcp_server_attach_event(server, event, 0) == -EBUSY);
  38         assert_se(sd_dhcp_server_get_event(server) == event);
  39         assert_se(sd_dhcp_server_detach_event(server) >= 0);
  40         assert_se(!sd_dhcp_server_get_event(server));
  41         assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
  42         assert_se(sd_dhcp_server_attach_event(server, NULL, 0) == -EBUSY);
  43
  44         assert_se(sd_dhcp_server_ref(server) == server);
  45         assert_se(!sd_dhcp_server_unref(server));
  46
  47         assert_se(sd_dhcp_server_start(server) == -EUNATCH);
  48
  49         assert_se(sd_dhcp_server_configure_pool(server, &address_any, 28, 0, 0) == -EINVAL);
  50         assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 38, 0, 0) == -ERANGE);
  51         assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0) >= 0);
  52         assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0) >= 0);
  53
  54         test_pool(&address_any, 1, -EINVAL);
  55         test_pool(&address_lo, 1, 0);
  56
  57         r = sd_dhcp_server_start(server);
  58         if (r == -EPERM)
  59                 return log_info_errno(r, "sd_dhcp_server_start failed: %m");
  60         assert_se(r >= 0);
  61
  62         assert_se(sd_dhcp_server_start(server) == -EBUSY);
  63         assert_se(sd_dhcp_server_stop(server) >= 0);
  64         assert_se(sd_dhcp_server_stop(server) >= 0);
  65         assert_se(sd_dhcp_server_start(server) >= 0);
  66
  67         return 0;
  68 }
  69
  70 static void test_message_handler(void) {
  71         _cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
  72         struct {
  73                 DHCPMessage message;
  74                 struct {
  75                         uint8_t code;
  76                         uint8_t length;
  77                         uint8_t type;
  78                 } _packed_ option_type;
  79                 struct {
  80                         uint8_t code;
  81                         uint8_t length;
  82                         be32_t address;
  83                 } _packed_ option_requested_ip;
  84                 struct {
  85                         uint8_t code;
  86                         uint8_t length;
  87                         be32_t address;
  88                 } _packed_ option_server_id;
  89                 struct {
  90                         uint8_t code;
  91                         uint8_t length;
  92                         uint8_t id[7];
  93                 } _packed_ option_client_id;
  94                 uint8_t end;
  95         } _packed_ test = {
  96                 .message.op = BOOTREQUEST,
  97                 .message.htype = ARPHRD_ETHER,
  98                 .message.hlen = ETHER_ADDR_LEN,
  99                 .message.xid = htobe32(0x12345678),
 100                 .message.chaddr = { 'A', 'B', 'C', 'D', 'E', 'F' },
 101                 .option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE,
 102                 .option_type.length = 1,
 103                 .option_type.type = DHCP_DISCOVER,
 104                 .end = SD_DHCP_OPTION_END,
 105         };
 106         struct in_addr address_lo = {
 107                 .s_addr = htonl(INADDR_LOOPBACK),
 108         };
 109
 110         assert_se(sd_dhcp_server_new(&server, 1) >= 0);
 111         assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0) >= 0);
 112         assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
 113         assert_se(sd_dhcp_server_start(server) >= 0);
 114
 115         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 116
 117         test.end = 0;
 118         /* TODO, shouldn't this fail? */
 119         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 120         test.end = SD_DHCP_OPTION_END;
 121         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 122
 123         test.option_type.code = 0;
 124         test.option_type.length = 0;
 125         test.option_type.type = 0;
 126         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 127         test.option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE;
 128         test.option_type.length = 1;
 129         test.option_type.type = DHCP_DISCOVER;
 130         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 131
 132         test.message.op = 0;
 133         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 134         test.message.op = BOOTREQUEST;
 135         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 136
 137         test.message.htype = 0;
 138         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 139         test.message.htype = ARPHRD_ETHER;
 140         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 141
 142         test.message.hlen = 0;
 143         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 144         test.message.hlen = ETHER_ADDR_LEN;
 145         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
 146
 147         test.option_type.type = DHCP_REQUEST;
 148         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 149         test.option_requested_ip.code = SD_DHCP_OPTION_REQUESTED_IP_ADDRESS;
 150         test.option_requested_ip.length = 4;
 151         test.option_requested_ip.address = htobe32(0x12345678);
 152         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_NAK);
 153         test.option_server_id.code = SD_DHCP_OPTION_SERVER_IDENTIFIER;
 154         test.option_server_id.length = 4;
 155         test.option_server_id.address = htobe32(INADDR_LOOPBACK);
 156         test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
 157         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
 158
 159         test.option_server_id.address = htobe32(0x12345678);
 160         test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
 161         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 162         test.option_server_id.address = htobe32(INADDR_LOOPBACK);
 163         test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 4);
 164         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 165         test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
 166         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
 167
 168         test.option_client_id.code = SD_DHCP_OPTION_CLIENT_IDENTIFIER;
 169         test.option_client_id.length = 7;
 170         test.option_client_id.id[0] = 0x01;
 171         test.option_client_id.id[1] = 'A';
 172         test.option_client_id.id[2] = 'B';
 173         test.option_client_id.id[3] = 'C';
 174         test.option_client_id.id[4] = 'D';
 175         test.option_client_id.id[5] = 'E';
 176         test.option_client_id.id[6] = 'F';
 177         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
 178
 179         test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 30);
 180         assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
 181 }
 182
 183 static uint64_t client_id_hash_helper(DHCPClientId *id, uint8_t key[HASH_KEY_SIZE]) {
 184         struct siphash state;
 185
 186         siphash24_init(&state, key);
 187         client_id_hash_func(id, &state);
 188
 189         return htole64(siphash24_finalize(&state));
 190 }
 191
 192 static void test_client_id_hash(void) {
 193         DHCPClientId a = {
 194                 .length = 4,
 195         }, b = {
 196                 .length = 4,
 197         };
 198         uint8_t hash_key[HASH_KEY_SIZE] = {
 199                 '0', '1', '2', '3', '4', '5', '6', '7',
 200                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
 201         };
 202
 203         a.data = (uint8_t*)strdup("abcd");
 204         b.data = (uint8_t*)strdup("abcd");
 205
 206         assert_se(client_id_compare_func(&a, &b) == 0);
 207         assert_se(client_id_hash_helper(&a, hash_key) == client_id_hash_helper(&b, hash_key));
 208         a.length = 3;
 209         assert_se(client_id_compare_func(&a, &b) != 0);
 210         a.length = 4;
 211         assert_se(client_id_compare_func(&a, &b) == 0);
 212         assert_se(client_id_hash_helper(&a, hash_key) == client_id_hash_helper(&b, hash_key));
 213
 214         b.length = 3;
 215         assert_se(client_id_compare_func(&a, &b) != 0);
 216         b.length = 4;
 217         assert_se(client_id_compare_func(&a, &b) == 0);
 218         assert_se(client_id_hash_helper(&a, hash_key) == client_id_hash_helper(&b, hash_key));
 219
 220         free(b.data);
 221         b.data = (uint8_t*)strdup("abce");
 222         assert_se(client_id_compare_func(&a, &b) != 0);
 223
 224         free(a.data);
 225         free(b.data);
 226 }
 227
 228 int main(int argc, char *argv[]) {
 229         _cleanup_(sd_event_unrefp) sd_event *e;
 230         int r;
 231
 232         test_setup_logging(LOG_DEBUG);
 233
 234         assert_se(sd_event_new(&e) >= 0);
 235
 236         r = test_basic(e);
 237         if (r != 0)
 238                 return log_tests_skipped("cannot start dhcp server");
 239
 240         test_message_handler();
 241         test_client_id_hash();
 242
 243         return 0;
 244 }