src/libsystemd-network/sd-dhcp-client.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright (C) 2013 Intel Corporation. All rights reserved.
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <stdlib.h>
  21 #include <errno.h>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <net/ethernet.h>
  25 #include <net/if_arp.h>
  26 #include <linux/if_infiniband.h>
  27 #include <netinet/ether.h>
  28 #include <sys/param.h>
  29 #include <sys/ioctl.h>
  30
  31 #include "util.h"
  32 #include "list.h"
  33 #include "refcnt.h"
  34 #include "async.h"
  35
  36 #include "dhcp-protocol.h"
  37 #include "dhcp-internal.h"
  38 #include "dhcp-lease-internal.h"
  39 #include "sd-dhcp-client.h"
  40
  41 #define MAX_CLIENT_ID_LEN 64  /* Arbitrary limit */
  42 #define MAX_MAC_ADDR_LEN INFINIBAND_ALEN
  43
  44 struct sd_dhcp_client {
  45         RefCount n_ref;
  46
  47         DHCPState state;
  48         sd_event *event;
  49         int event_priority;
  50         sd_event_source *timeout_resend;
  51         int index;
  52         int fd;
  53         union sockaddr_union link;
  54         sd_event_source *receive_message;
  55         bool request_broadcast;
  56         uint8_t *req_opts;
  57         size_t req_opts_allocated;
  58         size_t req_opts_size;
  59         be32_t last_addr;
  60         uint8_t mac_addr[MAX_MAC_ADDR_LEN];
  61         size_t mac_addr_len;
  62         uint16_t arp_type;
  63         union {
  64                 struct {
  65                         uint8_t type; /* 0: Generic (non-LL) (RFC 2132) */
  66                         uint8_t data[MAX_CLIENT_ID_LEN];
  67                 } _packed_ gen;
  68                 struct {
  69                         uint8_t type; /* 1: Ethernet Link-Layer (RFC 2132) */
  70                         uint8_t haddr[ETH_ALEN];
  71                 } _packed_ eth;
  72                 struct {
  73                         uint8_t type; /* 2 - 254: ARP/Link-Layer (RFC 2132) */
  74                         uint8_t haddr[0];
  75                 } _packed_ ll;
  76                 struct {
  77                         uint8_t type; /* 255: Node-specific (RFC 4361) */
  78                         uint8_t iaid[4];
  79                         uint8_t duid[MAX_CLIENT_ID_LEN - 4];
  80                 } _packed_ ns;
  81                 struct {
  82                         uint8_t type;
  83                         uint8_t data[MAX_CLIENT_ID_LEN];
  84                 } _packed_ raw;
  85         } client_id;
  86         size_t client_id_len;
  87         char *hostname;
  88         char *vendor_class_identifier;
  89         uint32_t mtu;
  90         uint32_t xid;
  91         usec_t start_time;
  92         unsigned int attempt;
  93         usec_t request_sent;
  94         sd_event_source *timeout_t1;
  95         sd_event_source *timeout_t2;
  96         sd_event_source *timeout_expire;
  97         sd_dhcp_client_cb_t cb;
  98         void *userdata;
  99         sd_dhcp_lease *lease;
 100 };
 101
 102 static const uint8_t default_req_opts[] = {
 103         DHCP_OPTION_SUBNET_MASK,
 104         DHCP_OPTION_ROUTER,
 105         DHCP_OPTION_HOST_NAME,
 106         DHCP_OPTION_DOMAIN_NAME,
 107         DHCP_OPTION_DOMAIN_NAME_SERVER,
 108         DHCP_OPTION_NTP_SERVER,
 109 };
 110
 111 static int client_receive_message_raw(sd_event_source *s, int fd,
 112                                       uint32_t revents, void *userdata);
 113 static int client_receive_message_udp(sd_event_source *s, int fd,
 114                                       uint32_t revents, void *userdata);
 115 static void client_stop(sd_dhcp_client *client, int error);
 116
 117 int sd_dhcp_client_set_callback(sd_dhcp_client *client, sd_dhcp_client_cb_t cb,
 118                                 void *userdata) {
 119         assert_return(client, -EINVAL);
 120
 121         client->cb = cb;
 122         client->userdata = userdata;
 123
 124         return 0;
 125 }
 126
 127 int sd_dhcp_client_set_request_broadcast(sd_dhcp_client *client, int broadcast) {
 128         assert_return(client, -EINVAL);
 129
 130         client->request_broadcast = !!broadcast;
 131
 132         return 0;
 133 }
 134
 135 int sd_dhcp_client_set_request_option(sd_dhcp_client *client, uint8_t option) {
 136         size_t i;
 137
 138         assert_return(client, -EINVAL);
 139         assert_return (IN_SET(client->state, DHCP_STATE_INIT,
 140                               DHCP_STATE_STOPPED), -EBUSY);
 141
 142         switch(option) {
 143         case DHCP_OPTION_PAD:
 144         case DHCP_OPTION_OVERLOAD:
 145         case DHCP_OPTION_MESSAGE_TYPE:
 146         case DHCP_OPTION_PARAMETER_REQUEST_LIST:
 147         case DHCP_OPTION_END:
 148                 return -EINVAL;
 149
 150         default:
 151                 break;
 152         }
 153
 154         for (i = 0; i < client->req_opts_size; i++)
 155                 if (client->req_opts[i] == option)
 156                         return -EEXIST;
 157
 158         if (!GREEDY_REALLOC(client->req_opts, client->req_opts_allocated,
 159                             client->req_opts_size + 1))
 160                 return -ENOMEM;
 161
 162         client->req_opts[client->req_opts_size++] = option;
 163
 164         return 0;
 165 }
 166
 167 int sd_dhcp_client_set_request_address(sd_dhcp_client *client,
 168                                        const struct in_addr *last_addr) {
 169         assert_return(client, -EINVAL);
 170         assert_return (IN_SET(client->state, DHCP_STATE_INIT,
 171                               DHCP_STATE_STOPPED), -EBUSY);
 172
 173         if (last_addr)
 174                 client->last_addr = last_addr->s_addr;
 175         else
 176                 client->last_addr = INADDR_ANY;
 177
 178         return 0;
 179 }
 180
 181 int sd_dhcp_client_set_index(sd_dhcp_client *client, int interface_index) {
 182         assert_return(client, -EINVAL);
 183         assert_return (IN_SET(client->state, DHCP_STATE_INIT,
 184                               DHCP_STATE_STOPPED), -EBUSY);
 185         assert_return(interface_index > 0, -EINVAL);
 186
 187         client->index = interface_index;
 188
 189         return 0;
 190 }
 191
 192 int sd_dhcp_client_set_mac(sd_dhcp_client *client, const uint8_t *addr,
 193                            size_t addr_len, uint16_t arp_type) {
 194         DHCP_CLIENT_DONT_DESTROY(client);
 195         bool need_restart = false;
 196
 197         assert_return(client, -EINVAL);
 198         assert_return(addr, -EINVAL);
 199         assert_return(addr_len > 0 && addr_len <= MAX_MAC_ADDR_LEN, -EINVAL);
 200         assert_return(arp_type > 0, -EINVAL);
 201
 202         if (arp_type == ARPHRD_ETHER)
 203                 assert_return(addr_len == ETH_ALEN, -EINVAL);
 204         else if (arp_type == ARPHRD_INFINIBAND)
 205                 assert_return(addr_len == INFINIBAND_ALEN, -EINVAL);
 206         else
 207                 return -EINVAL;
 208
 209         if (client->mac_addr_len == addr_len &&
 210             memcmp(&client->mac_addr, addr, addr_len) == 0)
 211                 return 0;
 212
 213         if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
 214                 log_dhcp_client(client, "Changing MAC address on running DHCP "
 215                                 "client, restarting");
 216                 need_restart = true;
 217                 client_stop(client, DHCP_EVENT_STOP);
 218         }
 219
 220         memcpy(&client->mac_addr, addr, addr_len);
 221         client->mac_addr_len = addr_len;
 222         client->arp_type = arp_type;
 223
 224         if (need_restart && client->state != DHCP_STATE_STOPPED)
 225                 sd_dhcp_client_start(client);
 226
 227         return 0;
 228 }
 229
 230 int sd_dhcp_client_get_client_id(sd_dhcp_client *client, uint8_t *type,
 231                                  const uint8_t **data, size_t *data_len) {
 232
 233         assert_return(client, -EINVAL);
 234         assert_return(type, -EINVAL);
 235         assert_return(data, -EINVAL);
 236         assert_return(data_len, -EINVAL);
 237
 238         *type = 0;
 239         *data = NULL;
 240         *data_len = 0;
 241         if (client->client_id_len) {
 242                 *type = client->client_id.raw.type;
 243                 *data = client->client_id.raw.data;
 244                 *data_len = client->client_id_len -
 245                         sizeof (client->client_id.raw.type);
 246         }
 247
 248         return 0;
 249 }
 250
 251 int sd_dhcp_client_set_client_id(sd_dhcp_client *client, uint8_t type,
 252                                  const uint8_t *data, size_t data_len) {
 253         DHCP_CLIENT_DONT_DESTROY(client);
 254         bool need_restart = false;
 255
 256         assert_return(client, -EINVAL);
 257         assert_return(data, -EINVAL);
 258         assert_return(data_len > 0 && data_len <= MAX_CLIENT_ID_LEN, -EINVAL);
 259
 260         switch (type) {
 261         case ARPHRD_ETHER:
 262                 if (data_len != ETH_ALEN)
 263                         return -EINVAL;
 264                 break;
 265         case ARPHRD_INFINIBAND:
 266                 if (data_len != INFINIBAND_ALEN)
 267                         return -EINVAL;
 268                 break;
 269         default:
 270                 break;
 271         }
 272
 273         if (client->client_id_len == data_len + sizeof (client->client_id.raw.type) &&
 274             client->client_id.raw.type == type &&
 275             memcmp(&client->client_id.raw.data, data, data_len) == 0)
 276                 return 0;
 277
 278         if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
 279                 log_dhcp_client(client, "Changing client ID on running DHCP "
 280                                 "client, restarting");
 281                 need_restart = true;
 282                 client_stop(client, DHCP_EVENT_STOP);
 283         }
 284
 285         client->client_id.raw.type = type;
 286         memcpy(&client->client_id.raw.data, data, data_len);
 287         client->client_id_len = data_len + sizeof (client->client_id.raw.type);
 288
 289         if (need_restart && client->state != DHCP_STATE_STOPPED)
 290                 sd_dhcp_client_start(client);
 291
 292         return 0;
 293 }
 294
 295 int sd_dhcp_client_set_hostname(sd_dhcp_client *client,
 296                                 const char *hostname) {
 297         char *new_hostname = NULL;
 298
 299         assert_return(client, -EINVAL);
 300
 301         if (streq_ptr(client->hostname, hostname))
 302                 return 0;
 303
 304         if (hostname) {
 305                 new_hostname = strdup(hostname);
 306                 if (!new_hostname)
 307                         return -ENOMEM;
 308         }
 309
 310         free(client->hostname);
 311         client->hostname = new_hostname;
 312
 313         return 0;
 314 }
 315
 316 int sd_dhcp_client_set_vendor_class_identifier(sd_dhcp_client *client,
 317                                                const char *vci) {
 318         char *new_vci = NULL;
 319
 320         assert_return(client, -EINVAL);
 321
 322         new_vci = strdup(vci);
 323         if (!new_vci)
 324                 return -ENOMEM;
 325
 326         free(client->vendor_class_identifier);
 327
 328         client->vendor_class_identifier = new_vci;
 329
 330         return 0;
 331 }
 332
 333 int sd_dhcp_client_set_mtu(sd_dhcp_client *client, uint32_t mtu) {
 334         assert_return(client, -EINVAL);
 335         assert_return(mtu >= DHCP_DEFAULT_MIN_SIZE, -ERANGE);
 336
 337         client->mtu = mtu;
 338
 339         return 0;
 340 }
 341
 342 int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) {
 343         assert_return(client, -EINVAL);
 344         assert_return(ret, -EINVAL);
 345
 346         if (client->state != DHCP_STATE_BOUND &&
 347             client->state != DHCP_STATE_RENEWING &&
 348             client->state != DHCP_STATE_REBINDING)
 349                 return -EADDRNOTAVAIL;
 350
 351         *ret = sd_dhcp_lease_ref(client->lease);
 352
 353         return 0;
 354 }
 355
 356 static void client_notify(sd_dhcp_client *client, int event) {
 357         if (client->cb)
 358                 client->cb(client, event, client->userdata);
 359 }
 360
 361 static int client_initialize(sd_dhcp_client *client) {
 362         assert_return(client, -EINVAL);
 363
 364         client->receive_message =
 365                 sd_event_source_unref(client->receive_message);
 366
 367         client->fd = asynchronous_close(client->fd);
 368
 369         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 370
 371         client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
 372         client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
 373         client->timeout_expire = sd_event_source_unref(client->timeout_expire);
 374
 375         client->attempt = 1;
 376
 377         client->state = DHCP_STATE_INIT;
 378         client->xid = 0;
 379
 380         if (client->lease)
 381                 client->lease = sd_dhcp_lease_unref(client->lease);
 382
 383         return 0;
 384 }
 385
 386 static void client_stop(sd_dhcp_client *client, int error) {
 387         assert(client);
 388
 389         if (error < 0)
 390                 log_dhcp_client(client, "STOPPED: %s", strerror(-error));
 391         else if (error == DHCP_EVENT_STOP)
 392                 log_dhcp_client(client, "STOPPED");
 393         else
 394                 log_dhcp_client(client, "STOPPED: Unknown event");
 395
 396         client_notify(client, error);
 397
 398         client_initialize(client);
 399 }
 400
 401 static int client_message_init(sd_dhcp_client *client, DHCPPacket **ret,
 402                                uint8_t type, size_t *_optlen, size_t *_optoffset) {
 403         _cleanup_free_ DHCPPacket *packet;
 404         size_t optlen, optoffset, size;
 405         be16_t max_size;
 406         usec_t time_now;
 407         uint16_t secs;
 408         int r;
 409
 410         assert(client);
 411         assert(client->start_time);
 412         assert(ret);
 413         assert(_optlen);
 414         assert(_optoffset);
 415         assert(type == DHCP_DISCOVER || type == DHCP_REQUEST);
 416
 417         optlen = DHCP_MIN_OPTIONS_SIZE;
 418         size = sizeof(DHCPPacket) + optlen;
 419
 420         packet = malloc0(size);
 421         if (!packet)
 422                 return -ENOMEM;
 423
 424         r = dhcp_message_init(&packet->dhcp, BOOTREQUEST, client->xid, type,
 425                               client->arp_type, optlen, &optoffset);
 426         if (r < 0)
 427                 return r;
 428
 429         /* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers
 430            refuse to issue an DHCP lease if 'secs' is set to zero */
 431         r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
 432         if (r < 0)
 433                 return r;
 434         assert(time_now >= client->start_time);
 435
 436         /* seconds between sending first and last DISCOVER
 437          * must always be strictly positive to deal with broken servers */
 438         secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1;
 439         packet->dhcp.secs = htobe16(secs);
 440
 441         /* RFC2132 section 4.1
 442            A client that cannot receive unicast IP datagrams until its protocol
 443            software has been configured with an IP address SHOULD set the
 444            BROADCAST bit in the 'flags' field to 1 in any DHCPDISCOVER or
 445            DHCPREQUEST messages that client sends.  The BROADCAST bit will
 446            provide a hint to the DHCP server and BOOTP relay agent to broadcast
 447            any messages to the client on the client's subnet.
 448
 449            Note: some interfaces needs this to be enabled, but some networks
 450            needs this to be disabled as broadcasts are filteretd, so this
 451            needs to be configurable */
 452         if (client->request_broadcast || client->arp_type != ARPHRD_ETHER)
 453                 packet->dhcp.flags = htobe16(0x8000);
 454
 455         /* RFC2132 section 4.1.1:
 456            The client MUST include its hardware address in the ’chaddr’ field, if
 457            necessary for delivery of DHCP reply messages.  Non-Ethernet
 458            interfaces will leave 'chaddr' empty and use the client identifier
 459            instead (eg, RFC 4390 section 2.1).
 460          */
 461         if (client->arp_type == ARPHRD_ETHER)
 462                 memcpy(&packet->dhcp.chaddr, &client->mac_addr, ETH_ALEN);
 463
 464         /* If no client identifier exists, construct one from an ethernet
 465            address if present */
 466         if (client->client_id_len == 0 && client->arp_type == ARPHRD_ETHER) {
 467                 client->client_id.eth.type = ARPHRD_ETHER;
 468                 memcpy(&client->client_id.eth.haddr, &client->mac_addr, ETH_ALEN);
 469                 client->client_id_len = sizeof (client->client_id.eth);
 470         }
 471
 472         /* Some DHCP servers will refuse to issue an DHCP lease if the Client
 473            Identifier option is not set */
 474         if (client->client_id_len) {
 475                 r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0,
 476                                        DHCP_OPTION_CLIENT_IDENTIFIER,
 477                                        client->client_id_len,
 478                                        &client->client_id.raw);
 479                 if (r < 0)
 480                         return r;
 481         }
 482
 483         /* RFC2131 section 3.5:
 484            in its initial DHCPDISCOVER or DHCPREQUEST message, a
 485            client may provide the server with a list of specific
 486            parameters the client is interested in. If the client
 487            includes a list of parameters in a DHCPDISCOVER message,
 488            it MUST include that list in any subsequent DHCPREQUEST
 489            messages.
 490          */
 491         r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0,
 492                                DHCP_OPTION_PARAMETER_REQUEST_LIST,
 493                                client->req_opts_size, client->req_opts);
 494         if (r < 0)
 495                 return r;
 496
 497         /* RFC2131 section 3.5:
 498            The client SHOULD include the ’maximum DHCP message size’ option to
 499            let the server know how large the server may make its DHCP messages.
 500
 501            Note (from ConnMan): Some DHCP servers will send bigger DHCP packets
 502            than the defined default size unless the Maximum Messge Size option
 503            is explicitly set
 504
 505            RFC3442 "Requirements to Avoid Sizing Constraints":
 506            Because a full routing table can be quite large, the standard 576
 507            octet maximum size for a DHCP message may be too short to contain
 508            some legitimate Classless Static Route options.  Because of this,
 509            clients implementing the Classless Static Route option SHOULD send a
 510            Maximum DHCP Message Size [4] option if the DHCP client's TCP/IP
 511            stack is capable of receiving larger IP datagrams.  In this case, the
 512            client SHOULD set the value of this option to at least the MTU of the
 513            interface that the client is configuring.  The client MAY set the
 514            value of this option higher, up to the size of the largest UDP packet
 515            it is prepared to accept.  (Note that the value specified in the
 516            Maximum DHCP Message Size option is the total maximum packet size,
 517            including IP and UDP headers.)
 518          */
 519         max_size = htobe16(size);
 520         r = dhcp_option_append(&packet->dhcp, client->mtu, &optoffset, 0,
 521                                DHCP_OPTION_MAXIMUM_MESSAGE_SIZE,
 522                                2, &max_size);
 523         if (r < 0)
 524                 return r;
 525
 526         *_optlen = optlen;
 527         *_optoffset = optoffset;
 528         *ret = packet;
 529         packet = NULL;
 530
 531         return 0;
 532 }
 533
 534 static int dhcp_client_send_raw(sd_dhcp_client *client, DHCPPacket *packet,
 535                                 size_t len) {
 536         dhcp_packet_append_ip_headers(packet, INADDR_ANY, DHCP_PORT_CLIENT,
 537                                       INADDR_BROADCAST, DHCP_PORT_SERVER, len);
 538
 539         return dhcp_network_send_raw_socket(client->fd, &client->link,
 540                                             packet, len);
 541 }
 542
 543 static int client_send_discover(sd_dhcp_client *client) {
 544         _cleanup_free_ DHCPPacket *discover = NULL;
 545         size_t optoffset, optlen;
 546         int r;
 547
 548         assert(client);
 549         assert(client->state == DHCP_STATE_INIT ||
 550                client->state == DHCP_STATE_SELECTING);
 551
 552         r = client_message_init(client, &discover, DHCP_DISCOVER,
 553                                 &optlen, &optoffset);
 554         if (r < 0)
 555                 return r;
 556
 557         /* the client may suggest values for the network address
 558            and lease time in the DHCPDISCOVER message. The client may include
 559            the ’requested IP address’ option to suggest that a particular IP
 560            address be assigned, and may include the ’IP address lease time’
 561            option to suggest the lease time it would like.
 562          */
 563         if (client->last_addr != INADDR_ANY) {
 564                 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
 565                                        DHCP_OPTION_REQUESTED_IP_ADDRESS,
 566                                        4, &client->last_addr);
 567                 if (r < 0)
 568                         return r;
 569         }
 570
 571         /* it is unclear from RFC 2131 if client should send hostname in
 572            DHCPDISCOVER but dhclient does and so we do as well
 573         */
 574         if (client->hostname) {
 575                 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
 576                                        DHCP_OPTION_HOST_NAME,
 577                                        strlen(client->hostname), client->hostname);
 578                 if (r < 0)
 579                         return r;
 580         }
 581
 582         if (client->vendor_class_identifier) {
 583                 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
 584                                        DHCP_OPTION_VENDOR_CLASS_IDENTIFIER,
 585                                        strlen(client->vendor_class_identifier),
 586                                        client->vendor_class_identifier);
 587                 if (r < 0)
 588                         return r;
 589         }
 590
 591         r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
 592                                DHCP_OPTION_END, 0, NULL);
 593         if (r < 0)
 594                 return r;
 595
 596         /* We currently ignore:
 597            The client SHOULD wait a random time between one and ten seconds to
 598            desynchronize the use of DHCP at startup.
 599          */
 600         r = dhcp_client_send_raw(client, discover, sizeof(DHCPPacket) + optoffset);
 601         if (r < 0)
 602                 return r;
 603
 604         log_dhcp_client(client, "DISCOVER");
 605
 606         return 0;
 607 }
 608
 609 static int client_send_request(sd_dhcp_client *client) {
 610         _cleanup_free_ DHCPPacket *request = NULL;
 611         size_t optoffset, optlen;
 612         int r;
 613
 614         r = client_message_init(client, &request, DHCP_REQUEST,
 615                                 &optlen, &optoffset);
 616         if (r < 0)
 617                 return r;
 618
 619         switch (client->state) {
 620         /* See RFC2131 section 4.3.2 (note that there is a typo in the RFC,
 621            SELECTING should be REQUESTING)
 622          */
 623
 624         case DHCP_STATE_REQUESTING:
 625                 /* Client inserts the address of the selected server in ’server
 626                    identifier’, ’ciaddr’ MUST be zero, ’requested IP address’ MUST be
 627                    filled in with the yiaddr value from the chosen DHCPOFFER.
 628                  */
 629
 630                 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
 631                                        DHCP_OPTION_SERVER_IDENTIFIER,
 632                                        4, &client->lease->server_address);
 633                 if (r < 0)
 634                         return r;
 635
 636                 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
 637                                        DHCP_OPTION_REQUESTED_IP_ADDRESS,
 638                                        4, &client->lease->address);
 639                 if (r < 0)
 640                         return r;
 641
 642                 break;
 643
 644         case DHCP_STATE_INIT_REBOOT:
 645                 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
 646                    option MUST be filled in with client’s notion of its previously
 647                    assigned address. ’ciaddr’ MUST be zero.
 648                  */
 649                 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
 650                                        DHCP_OPTION_REQUESTED_IP_ADDRESS,
 651                                        4, &client->last_addr);
 652                 if (r < 0)
 653                         return r;
 654                 break;
 655
 656         case DHCP_STATE_RENEWING:
 657                 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
 658                    option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
 659                    client’s IP address.
 660                 */
 661
 662                 /* fall through */
 663         case DHCP_STATE_REBINDING:
 664                 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
 665                    option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
 666                    client’s IP address.
 667
 668                    This message MUST be broadcast to the 0xffffffff IP broadcast address.
 669                  */
 670                 request->dhcp.ciaddr = client->lease->address;
 671
 672                 break;
 673
 674         case DHCP_STATE_INIT:
 675         case DHCP_STATE_SELECTING:
 676         case DHCP_STATE_REBOOTING:
 677         case DHCP_STATE_BOUND:
 678         case DHCP_STATE_STOPPED:
 679                 return -EINVAL;
 680         }
 681
 682         if (client->hostname) {
 683                 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
 684                                        DHCP_OPTION_HOST_NAME,
 685                                        strlen(client->hostname), client->hostname);
 686                 if (r < 0)
 687                         return r;
 688         }
 689
 690         r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
 691                                DHCP_OPTION_END, 0, NULL);
 692         if (r < 0)
 693                 return r;
 694
 695         if (client->state == DHCP_STATE_RENEWING) {
 696                 r = dhcp_network_send_udp_socket(client->fd,
 697                                                  client->lease->server_address,
 698                                                  DHCP_PORT_SERVER,
 699                                                  &request->dhcp,
 700                                                  sizeof(DHCPMessage) + optoffset);
 701         } else {
 702                 r = dhcp_client_send_raw(client, request, sizeof(DHCPPacket) + optoffset);
 703         }
 704         if (r < 0)
 705                 return r;
 706
 707         switch (client->state) {
 708         case DHCP_STATE_REQUESTING:
 709                 log_dhcp_client(client, "REQUEST (requesting)");
 710                 break;
 711         case DHCP_STATE_INIT_REBOOT:
 712                 log_dhcp_client(client, "REQUEST (init-reboot)");
 713                 break;
 714         case DHCP_STATE_RENEWING:
 715                 log_dhcp_client(client, "REQUEST (renewing)");
 716                 break;
 717         case DHCP_STATE_REBINDING:
 718                 log_dhcp_client(client, "REQUEST (rebinding)");
 719                 break;
 720         default:
 721                 log_dhcp_client(client, "REQUEST (invalid)");
 722                 break;
 723         }
 724
 725         return 0;
 726 }
 727
 728 static int client_start(sd_dhcp_client *client);
 729
 730 static int client_timeout_resend(sd_event_source *s, uint64_t usec,
 731                                  void *userdata) {
 732         sd_dhcp_client *client = userdata;
 733         DHCP_CLIENT_DONT_DESTROY(client);
 734         usec_t next_timeout = 0;
 735         uint64_t time_now;
 736         uint32_t time_left;
 737         int r;
 738
 739         assert(s);
 740         assert(client);
 741         assert(client->event);
 742
 743         r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
 744         if (r < 0)
 745                 goto error;
 746
 747         switch (client->state) {
 748         case DHCP_STATE_RENEWING:
 749
 750                 time_left = (client->lease->t2 - client->lease->t1) / 2;
 751                 if (time_left < 60)
 752                         time_left = 60;
 753
 754                 next_timeout = time_now + time_left * USEC_PER_SEC;
 755
 756                 break;
 757
 758         case DHCP_STATE_REBINDING:
 759
 760                 time_left = (client->lease->lifetime - client->lease->t2) / 2;
 761                 if (time_left < 60)
 762                         time_left = 60;
 763
 764                 next_timeout = time_now + time_left * USEC_PER_SEC;
 765                 break;
 766
 767         case DHCP_STATE_REBOOTING:
 768                 /* start over as we did not receive a timely ack or nak */
 769                 r = client_initialize(client);
 770                 if (r < 0)
 771                         goto error;
 772
 773                 r = client_start(client);
 774                 if (r < 0)
 775                         goto error;
 776                 else {
 777                         log_dhcp_client(client, "REBOOTED");
 778                         return 0;
 779                 }
 780
 781         case DHCP_STATE_INIT:
 782         case DHCP_STATE_INIT_REBOOT:
 783         case DHCP_STATE_SELECTING:
 784         case DHCP_STATE_REQUESTING:
 785         case DHCP_STATE_BOUND:
 786
 787                 if (client->attempt < 64)
 788                         client->attempt *= 2;
 789
 790                 next_timeout = time_now + (client->attempt - 1) * USEC_PER_SEC;
 791
 792                 break;
 793
 794         case DHCP_STATE_STOPPED:
 795                 r = -EINVAL;
 796                 goto error;
 797         }
 798
 799         next_timeout += (random_u32() & 0x1fffff);
 800
 801         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 802
 803         r = sd_event_add_time(client->event,
 804                               &client->timeout_resend,
 805                               clock_boottime_or_monotonic(),
 806                               next_timeout, 10 * USEC_PER_MSEC,
 807                               client_timeout_resend, client);
 808         if (r < 0)
 809                 goto error;
 810
 811         r = sd_event_source_set_priority(client->timeout_resend,
 812                                          client->event_priority);
 813         if (r < 0)
 814                 goto error;
 815
 816         r = sd_event_source_set_description(client->timeout_resend, "dhcp4-resend-timer");
 817         if (r < 0)
 818                 goto error;
 819
 820         switch (client->state) {
 821         case DHCP_STATE_INIT:
 822                 r = client_send_discover(client);
 823                 if (r >= 0) {
 824                         client->state = DHCP_STATE_SELECTING;
 825                         client->attempt = 1;
 826                 } else {
 827                         if (client->attempt >= 64)
 828                                 goto error;
 829                 }
 830
 831                 break;
 832
 833         case DHCP_STATE_SELECTING:
 834                 r = client_send_discover(client);
 835                 if (r < 0 && client->attempt >= 64)
 836                         goto error;
 837
 838                 break;
 839
 840         case DHCP_STATE_INIT_REBOOT:
 841         case DHCP_STATE_REQUESTING:
 842         case DHCP_STATE_RENEWING:
 843         case DHCP_STATE_REBINDING:
 844                 r = client_send_request(client);
 845                 if (r < 0 && client->attempt >= 64)
 846                          goto error;
 847
 848                 if (client->state == DHCP_STATE_INIT_REBOOT)
 849                         client->state = DHCP_STATE_REBOOTING;
 850
 851                 client->request_sent = time_now;
 852
 853                 break;
 854
 855         case DHCP_STATE_REBOOTING:
 856         case DHCP_STATE_BOUND:
 857
 858                 break;
 859
 860         case DHCP_STATE_STOPPED:
 861                 r = -EINVAL;
 862                 goto error;
 863         }
 864
 865         return 0;
 866
 867 error:
 868         client_stop(client, r);
 869
 870         /* Errors were dealt with when stopping the client, don't spill
 871            errors into the event loop handler */
 872         return 0;
 873 }
 874
 875 static int client_initialize_io_events(sd_dhcp_client *client,
 876                                        sd_event_io_handler_t io_callback) {
 877         int r;
 878
 879         assert(client);
 880         assert(client->event);
 881
 882         r = sd_event_add_io(client->event, &client->receive_message,
 883                             client->fd, EPOLLIN, io_callback,
 884                             client);
 885         if (r < 0)
 886                 goto error;
 887
 888         r = sd_event_source_set_priority(client->receive_message,
 889                                          client->event_priority);
 890         if (r < 0)
 891                 goto error;
 892
 893         r = sd_event_source_set_description(client->receive_message, "dhcp4-receive-message");
 894         if (r < 0)
 895                 goto error;
 896
 897 error:
 898         if (r < 0)
 899                 client_stop(client, r);
 900
 901         return 0;
 902 }
 903
 904 static int client_initialize_time_events(sd_dhcp_client *client) {
 905         int r;
 906
 907         assert(client);
 908         assert(client->event);
 909
 910         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 911
 912         r = sd_event_add_time(client->event,
 913                               &client->timeout_resend,
 914                               clock_boottime_or_monotonic(),
 915                               0, 0,
 916                               client_timeout_resend, client);
 917         if (r < 0)
 918                 goto error;
 919
 920         r = sd_event_source_set_priority(client->timeout_resend,
 921                                          client->event_priority);
 922
 923         r = sd_event_source_set_description(client->timeout_resend, "dhcp4-resend-timer");
 924         if (r < 0)
 925                 goto error;
 926
 927 error:
 928         if (r < 0)
 929                 client_stop(client, r);
 930
 931         return 0;
 932
 933 }
 934
 935 static int client_initialize_events(sd_dhcp_client *client,
 936                                     sd_event_io_handler_t io_callback) {
 937         client_initialize_io_events(client, io_callback);
 938         client_initialize_time_events(client);
 939
 940         return 0;
 941 }
 942
 943 static int client_start(sd_dhcp_client *client) {
 944         int r;
 945
 946         assert_return(client, -EINVAL);
 947         assert_return(client->event, -EINVAL);
 948         assert_return(client->index > 0, -EINVAL);
 949         assert_return(client->fd < 0, -EBUSY);
 950         assert_return(client->xid == 0, -EINVAL);
 951         assert_return(client->state == DHCP_STATE_INIT ||
 952                       client->state == DHCP_STATE_INIT_REBOOT, -EBUSY);
 953
 954         client->xid = random_u32();
 955
 956         r = dhcp_network_bind_raw_socket(client->index, &client->link,
 957                                          client->xid, client->mac_addr,
 958                                          client->mac_addr_len, client->arp_type);
 959         if (r < 0) {
 960                 client_stop(client, r);
 961                 return r;
 962         }
 963         client->fd = r;
 964
 965         if (client->state == DHCP_STATE_INIT || client->state == DHCP_STATE_INIT_REBOOT)
 966                 client->start_time = now(clock_boottime_or_monotonic());
 967
 968         return client_initialize_events(client, client_receive_message_raw);
 969 }
 970
 971 static int client_timeout_expire(sd_event_source *s, uint64_t usec,
 972                                  void *userdata) {
 973         sd_dhcp_client *client = userdata;
 974         DHCP_CLIENT_DONT_DESTROY(client);
 975
 976         log_dhcp_client(client, "EXPIRED");
 977
 978         client_notify(client, DHCP_EVENT_EXPIRED);
 979
 980         /* lease was lost, start over if not freed or stopped in callback */
 981         if (client->state != DHCP_STATE_STOPPED) {
 982                 client_initialize(client);
 983                 client_start(client);
 984         }
 985
 986         return 0;
 987 }
 988
 989 static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) {
 990         sd_dhcp_client *client = userdata;
 991         DHCP_CLIENT_DONT_DESTROY(client);
 992         int r;
 993
 994         client->receive_message = sd_event_source_unref(client->receive_message);
 995         client->fd = asynchronous_close(client->fd);
 996
 997         client->state = DHCP_STATE_REBINDING;
 998         client->attempt = 1;
 999
1000         r = dhcp_network_bind_raw_socket(client->index, &client->link,
1001                                          client->xid, client->mac_addr,
1002                                          client->mac_addr_len, client->arp_type);
1003         if (r < 0) {
1004                 client_stop(client, r);
1005                 return 0;
1006         }
1007         client->fd = r;
1008
1009         return client_initialize_events(client, client_receive_message_raw);
1010 }
1011
1012 static int client_timeout_t1(sd_event_source *s, uint64_t usec,
1013                              void *userdata) {
1014         sd_dhcp_client *client = userdata;
1015         DHCP_CLIENT_DONT_DESTROY(client);
1016
1017         client->state = DHCP_STATE_RENEWING;
1018         client->attempt = 1;
1019
1020         return client_initialize_time_events(client);
1021 }
1022
1023 static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer,
1024                                size_t len) {
1025         _cleanup_dhcp_lease_unref_ sd_dhcp_lease *lease = NULL;
1026         int r;
1027
1028         r = dhcp_lease_new(&lease);
1029         if (r < 0)
1030                 return r;
1031
1032         if (client->client_id_len) {
1033                 r = dhcp_lease_set_client_id(lease,
1034                                              (uint8_t *) &client->client_id.raw,
1035                                              client->client_id_len);
1036                 if (r < 0)
1037                         return r;
1038         }
1039
1040         r = dhcp_option_parse(offer, len, dhcp_lease_parse_options, lease);
1041         if (r != DHCP_OFFER) {
1042                 log_dhcp_client(client, "received message was not an OFFER, ignoring");
1043                 return -ENOMSG;
1044         }
1045
1046         lease->next_server = offer->siaddr;
1047
1048         lease->address = offer->yiaddr;
1049
1050         if (lease->address == INADDR_ANY ||
1051             lease->server_address == INADDR_ANY ||
1052             lease->lifetime == 0) {
1053                 log_dhcp_client(client, "received lease lacks address, server "
1054                                 "address or lease lifetime, ignoring");
1055                 return -ENOMSG;
1056         }
1057
1058         if (lease->subnet_mask == INADDR_ANY) {
1059                 r = dhcp_lease_set_default_subnet_mask(lease);
1060                 if (r < 0) {
1061                         log_dhcp_client(client, "received lease lacks subnet "
1062                                         "mask, and a fallback one can not be "
1063                                         "generated, ignoring");
1064                         return -ENOMSG;
1065                 }
1066         }
1067
1068         sd_dhcp_lease_unref(client->lease);
1069         client->lease = lease;
1070         lease = NULL;
1071
1072         log_dhcp_client(client, "OFFER");
1073
1074         return 0;
1075 }
1076
1077 static int client_handle_forcerenew(sd_dhcp_client *client, DHCPMessage *force,
1078                                     size_t len) {
1079         int r;
1080
1081         r = dhcp_option_parse(force, len, NULL, NULL);
1082         if (r != DHCP_FORCERENEW)
1083                 return -ENOMSG;
1084
1085         log_dhcp_client(client, "FORCERENEW");
1086
1087         return 0;
1088 }
1089
1090 static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack,
1091                              size_t len) {
1092         _cleanup_dhcp_lease_unref_ sd_dhcp_lease *lease = NULL;
1093         int r;
1094
1095         r = dhcp_lease_new(&lease);
1096         if (r < 0)
1097                 return r;
1098
1099         if (client->client_id_len) {
1100                 r = dhcp_lease_set_client_id(lease,
1101                                              (uint8_t *) &client->client_id.raw,
1102                                              client->client_id_len);
1103                 if (r < 0)
1104                         return r;
1105         }
1106
1107         r = dhcp_option_parse(ack, len, dhcp_lease_parse_options, lease);
1108         if (r == DHCP_NAK) {
1109                 log_dhcp_client(client, "NAK");
1110                 return -EADDRNOTAVAIL;
1111         }
1112
1113         if (r != DHCP_ACK) {
1114                 log_dhcp_client(client, "received message was not an ACK, ignoring");
1115                 return -ENOMSG;
1116         }
1117
1118         lease->next_server = ack->siaddr;
1119
1120         lease->address = ack->yiaddr;
1121
1122         if (lease->address == INADDR_ANY ||
1123             lease->server_address == INADDR_ANY ||
1124             lease->lifetime == 0) {
1125                 log_dhcp_client(client, "received lease lacks address, server "
1126                                 "address or lease lifetime, ignoring");
1127                 return -ENOMSG;
1128         }
1129
1130         if (lease->subnet_mask == INADDR_ANY) {
1131                 r = dhcp_lease_set_default_subnet_mask(lease);
1132                 if (r < 0) {
1133                         log_dhcp_client(client, "received lease lacks subnet "
1134                                         "mask, and a fallback one can not be "
1135                                         "generated, ignoring");
1136                         return -ENOMSG;
1137                 }
1138         }
1139
1140         r = DHCP_EVENT_IP_ACQUIRE;
1141         if (client->lease) {
1142                 if (client->lease->address != lease->address ||
1143                     client->lease->subnet_mask != lease->subnet_mask ||
1144                     client->lease->router != lease->router) {
1145                         r = DHCP_EVENT_IP_CHANGE;
1146                 } else
1147                         r = DHCP_EVENT_RENEW;
1148
1149                 client->lease = sd_dhcp_lease_unref(client->lease);
1150         }
1151
1152         client->lease = lease;
1153         lease = NULL;
1154
1155         log_dhcp_client(client, "ACK");
1156
1157         return r;
1158 }
1159
1160 static uint64_t client_compute_timeout(sd_dhcp_client *client,
1161                                        uint32_t lifetime, double factor) {
1162         assert(client);
1163         assert(client->request_sent);
1164         assert(lifetime);
1165
1166         return client->request_sent + ((lifetime - 3) * USEC_PER_SEC * factor) +
1167                 + (random_u32() & 0x1fffff);
1168 }
1169
1170 static int client_set_lease_timeouts(sd_dhcp_client *client) {
1171         usec_t time_now;
1172         uint64_t lifetime_timeout;
1173         uint64_t t2_timeout;
1174         uint64_t t1_timeout;
1175         char time_string[FORMAT_TIMESPAN_MAX];
1176         int r;
1177
1178         assert(client);
1179         assert(client->event);
1180         assert(client->lease);
1181         assert(client->lease->lifetime);
1182
1183         client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
1184         client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
1185         client->timeout_expire = sd_event_source_unref(client->timeout_expire);
1186
1187         /* don't set timers for infinite leases */
1188         if (client->lease->lifetime == 0xffffffff)
1189                 return 0;
1190
1191         r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
1192         if (r < 0)
1193                 return r;
1194         assert(client->request_sent <= time_now);
1195
1196         /* convert the various timeouts from relative (secs) to absolute (usecs) */
1197         lifetime_timeout = client_compute_timeout(client, client->lease->lifetime, 1);
1198         if (client->lease->t1 && client->lease->t2) {
1199                 /* both T1 and T2 are given */
1200                 if (client->lease->t1 < client->lease->t2 &&
1201                     client->lease->t2 < client->lease->lifetime) {
1202                         /* they are both valid */
1203                         t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
1204                         t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
1205                 } else {
1206                         /* discard both */
1207                         t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1208                         client->lease->t2 = (client->lease->lifetime * 7) / 8;
1209                         t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1210                         client->lease->t1 = client->lease->lifetime / 2;
1211                 }
1212         } else if (client->lease->t2 && client->lease->t2 < client->lease->lifetime) {
1213                 /* only T2 is given, and it is valid */
1214                 t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
1215                 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1216                 client->lease->t1 = client->lease->lifetime / 2;
1217                 if (t2_timeout <= t1_timeout) {
1218                         /* the computed T1 would be invalid, so discard T2 */
1219                         t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1220                         client->lease->t2 = (client->lease->lifetime * 7) / 8;
1221                 }
1222         } else if (client->lease->t1 && client->lease->t1 < client->lease->lifetime) {
1223                 /* only T1 is given, and it is valid */
1224                 t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
1225                 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1226                 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1227                 if (t2_timeout <= t1_timeout) {
1228                         /* the computed T2 would be invalid, so discard T1 */
1229                         t2_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1230                         client->lease->t2 = client->lease->lifetime / 2;
1231                 }
1232         } else {
1233                 /* fall back to the default timeouts */
1234                 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1235                 client->lease->t1 = client->lease->lifetime / 2;
1236                 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1237                 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1238         }
1239
1240         /* arm lifetime timeout */
1241         r = sd_event_add_time(client->event, &client->timeout_expire,
1242                               clock_boottime_or_monotonic(),
1243                               lifetime_timeout, 10 * USEC_PER_MSEC,
1244                               client_timeout_expire, client);
1245         if (r < 0)
1246                 return r;
1247
1248         r = sd_event_source_set_priority(client->timeout_expire,
1249                                          client->event_priority);
1250         if (r < 0)
1251                 return r;
1252
1253         r = sd_event_source_set_description(client->timeout_expire, "dhcp4-lifetime");
1254         if (r < 0)
1255                 return r;
1256
1257         log_dhcp_client(client, "lease expires in %s",
1258                         format_timespan(time_string, FORMAT_TIMESPAN_MAX,
1259                         lifetime_timeout - time_now, 0));
1260
1261         /* don't arm earlier timeouts if this has already expired */
1262         if (lifetime_timeout <= time_now)
1263                 return 0;
1264
1265         /* arm T2 timeout */
1266         r = sd_event_add_time(client->event,
1267                               &client->timeout_t2,
1268                               clock_boottime_or_monotonic(),
1269                               t2_timeout,
1270                               10 * USEC_PER_MSEC,
1271                               client_timeout_t2, client);
1272         if (r < 0)
1273                 return r;
1274
1275         r = sd_event_source_set_priority(client->timeout_t2,
1276                                          client->event_priority);
1277         if (r < 0)
1278                 return r;
1279
1280         r = sd_event_source_set_description(client->timeout_t2, "dhcp4-t2-timeout");
1281         if (r < 0)
1282                 return r;
1283
1284         log_dhcp_client(client, "T2 expires in %s",
1285                         format_timespan(time_string, FORMAT_TIMESPAN_MAX,
1286                         t2_timeout - time_now, 0));
1287
1288         /* don't arm earlier timeout if this has already expired */
1289         if (t2_timeout <= time_now)
1290                 return 0;
1291
1292         /* arm T1 timeout */
1293         r = sd_event_add_time(client->event,
1294                               &client->timeout_t1,
1295                               clock_boottime_or_monotonic(),
1296                               t1_timeout, 10 * USEC_PER_MSEC,
1297                               client_timeout_t1, client);
1298         if (r < 0)
1299                 return r;
1300
1301         r = sd_event_source_set_priority(client->timeout_t1,
1302                                          client->event_priority);
1303         if (r < 0)
1304                 return r;
1305
1306         r = sd_event_source_set_description(client->timeout_t1, "dhcp4-t1-timer");
1307         if (r < 0)
1308                 return r;
1309
1310         log_dhcp_client(client, "T1 expires in %s",
1311                         format_timespan(time_string, FORMAT_TIMESPAN_MAX,
1312                         t1_timeout - time_now, 0));
1313
1314         return 0;
1315 }
1316
1317 static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
1318                                  int len) {
1319         DHCP_CLIENT_DONT_DESTROY(client);
1320         int r = 0, notify_event = 0;
1321
1322         assert(client);
1323         assert(client->event);
1324         assert(message);
1325
1326         switch (client->state) {
1327         case DHCP_STATE_SELECTING:
1328
1329                 r = client_handle_offer(client, message, len);
1330                 if (r >= 0) {
1331
1332                         client->timeout_resend =
1333                                 sd_event_source_unref(client->timeout_resend);
1334
1335                         client->state = DHCP_STATE_REQUESTING;
1336                         client->attempt = 1;
1337
1338                         r = sd_event_add_time(client->event,
1339                                               &client->timeout_resend,
1340                                               clock_boottime_or_monotonic(),
1341                                               0, 0,
1342                                               client_timeout_resend, client);
1343                         if (r < 0)
1344                                 goto error;
1345
1346                         r = sd_event_source_set_priority(client->timeout_resend,
1347                                                          client->event_priority);
1348                         if (r < 0)
1349                                 goto error;
1350
1351                         r = sd_event_source_set_description(client->timeout_resend, "dhcp4-resend-timer");
1352                         if (r < 0)
1353                                 goto error;
1354                 } else if (r == -ENOMSG)
1355                         /* invalid message, let's ignore it */
1356                         return 0;
1357
1358                 break;
1359
1360         case DHCP_STATE_REBOOTING:
1361         case DHCP_STATE_REQUESTING:
1362         case DHCP_STATE_RENEWING:
1363         case DHCP_STATE_REBINDING:
1364
1365                 r = client_handle_ack(client, message, len);
1366                 if (r >= 0) {
1367                         client->timeout_resend =
1368                                 sd_event_source_unref(client->timeout_resend);
1369                         client->receive_message =
1370                                 sd_event_source_unref(client->receive_message);
1371                         client->fd = asynchronous_close(client->fd);
1372
1373                         if (IN_SET(client->state, DHCP_STATE_REQUESTING,
1374                                    DHCP_STATE_REBOOTING))
1375                                 notify_event = DHCP_EVENT_IP_ACQUIRE;
1376                         else if (r != DHCP_EVENT_IP_ACQUIRE)
1377                                 notify_event = r;
1378
1379                         client->state = DHCP_STATE_BOUND;
1380                         client->attempt = 1;
1381
1382                         client->last_addr = client->lease->address;
1383
1384                         r = client_set_lease_timeouts(client);
1385                         if (r < 0) {
1386                                 log_dhcp_client(client, "could not set lease timeouts");
1387                                 goto error;
1388                         }
1389
1390                         r = dhcp_network_bind_udp_socket(client->lease->address,
1391                                                          DHCP_PORT_CLIENT);
1392                         if (r < 0) {
1393                                 log_dhcp_client(client, "could not bind UDP socket");
1394                                 goto error;
1395                         }
1396
1397                         client->fd = r;
1398
1399                         client_initialize_io_events(client, client_receive_message_udp);
1400
1401                         if (notify_event) {
1402                                 client_notify(client, notify_event);
1403                                 if (client->state == DHCP_STATE_STOPPED)
1404                                         return 0;
1405                         }
1406
1407                 } else if (r == -EADDRNOTAVAIL) {
1408                         /* got a NAK, let's restart the client */
1409                         client->timeout_resend =
1410                                 sd_event_source_unref(client->timeout_resend);
1411
1412                         r = client_initialize(client);
1413                         if (r < 0)
1414                                 goto error;
1415
1416                         r = client_start(client);
1417                         if (r < 0)
1418                                 goto error;
1419
1420                         log_dhcp_client(client, "REBOOTED");
1421
1422                         return 0;
1423                 } else if (r == -ENOMSG)
1424                         /* invalid message, let's ignore it */
1425                         return 0;
1426
1427                 break;
1428
1429         case DHCP_STATE_BOUND:
1430                 r = client_handle_forcerenew(client, message, len);
1431                 if (r >= 0) {
1432                         r = client_timeout_t1(NULL, 0, client);
1433                         if (r < 0)
1434                                 goto error;
1435                 } else if (r == -ENOMSG)
1436                         /* invalid message, let's ignore it */
1437                         return 0;
1438
1439                 break;
1440
1441         case DHCP_STATE_INIT:
1442         case DHCP_STATE_INIT_REBOOT:
1443
1444                 break;
1445
1446         case DHCP_STATE_STOPPED:
1447                 r = -EINVAL;
1448                 goto error;
1449         }
1450
1451 error:
1452         if (r < 0)
1453                 client_stop(client, r);
1454
1455         return r;
1456 }
1457
1458 static int client_receive_message_udp(sd_event_source *s, int fd,
1459                                       uint32_t revents, void *userdata) {
1460         sd_dhcp_client *client = userdata;
1461         _cleanup_free_ DHCPMessage *message = NULL;
1462         int buflen = 0, len, r;
1463         const struct ether_addr zero_mac = { { 0, 0, 0, 0, 0, 0 } };
1464         const struct ether_addr *expected_chaddr = NULL;
1465         uint8_t expected_hlen = 0;
1466
1467         assert(s);
1468         assert(client);
1469
1470         r = ioctl(fd, FIONREAD, &buflen);
1471         if (r < 0)
1472                 return r;
1473
1474         if (buflen < 0)
1475                 /* this can't be right */
1476                 return -EIO;
1477
1478         message = malloc0(buflen);
1479         if (!message)
1480                 return -ENOMEM;
1481
1482         len = read(fd, message, buflen);
1483         if (len < 0) {
1484                 log_dhcp_client(client, "could not receive message from UDP "
1485                                 "socket: %m");
1486                 return 0;
1487         } else if ((size_t)len < sizeof(DHCPMessage)) {
1488                 log_dhcp_client(client, "too small to be a DHCP message: ignoring");
1489                 return 0;
1490         }
1491
1492         if (be32toh(message->magic) != DHCP_MAGIC_COOKIE) {
1493                 log_dhcp_client(client, "not a DHCP message: ignoring");
1494                 return 0;
1495         }
1496
1497         if (message->op != BOOTREPLY) {
1498                 log_dhcp_client(client, "not a BOOTREPLY message: ignoring");
1499                 return 0;
1500         }
1501
1502         if (message->htype != client->arp_type) {
1503                 log_dhcp_client(client, "packet type does not match client type");
1504                 return 0;
1505         }
1506
1507         if (client->arp_type == ARPHRD_ETHER) {
1508                 expected_hlen = ETH_ALEN;
1509                 expected_chaddr = (const struct ether_addr *) &client->mac_addr;
1510         } else {
1511                /* Non-ethernet links expect zero chaddr */
1512                expected_hlen = 0;
1513                expected_chaddr = &zero_mac;
1514         }
1515
1516         if (message->hlen != expected_hlen) {
1517                 log_dhcp_client(client, "unexpected packet hlen %d", message->hlen);
1518                 return 0;
1519         }
1520
1521         if (memcmp(&message->chaddr[0], expected_chaddr, ETH_ALEN)) {
1522                 log_dhcp_client(client, "received chaddr does not match "
1523                                 "expected: ignoring");
1524                 return 0;
1525         }
1526
1527         if (client->state != DHCP_STATE_BOUND &&
1528             be32toh(message->xid) != client->xid) {
1529                 /* in BOUND state, we may receive FORCERENEW with xid set by server,
1530                    so ignore the xid in this case */
1531                 log_dhcp_client(client, "received xid (%u) does not match "
1532                                 "expected (%u): ignoring",
1533                                 be32toh(message->xid), client->xid);
1534                 return 0;
1535         }
1536
1537         return client_handle_message(client, message, len);
1538 }
1539
1540 static int client_receive_message_raw(sd_event_source *s, int fd,
1541                                       uint32_t revents, void *userdata) {
1542         sd_dhcp_client *client = userdata;
1543         _cleanup_free_ DHCPPacket *packet = NULL;
1544         uint8_t cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
1545         struct iovec iov = {};
1546         struct msghdr msg = {
1547                 .msg_iov = &iov,
1548                 .msg_iovlen = 1,
1549                 .msg_control = cmsgbuf,
1550                 .msg_controllen = sizeof(cmsgbuf),
1551         };
1552         struct cmsghdr *cmsg;
1553         bool checksum = true;
1554         int buflen = 0, len, r;
1555
1556         assert(s);
1557         assert(client);
1558
1559         r = ioctl(fd, FIONREAD, &buflen);
1560         if (r < 0)
1561                 return r;
1562
1563         if (buflen < 0)
1564                 /* this can't be right */
1565                 return -EIO;
1566
1567         packet = malloc0(buflen);
1568         if (!packet)
1569                 return -ENOMEM;
1570
1571         iov.iov_base = packet;
1572         iov.iov_len = buflen;
1573
1574         len = recvmsg(fd, &msg, 0);
1575         if (len < 0) {
1576                 log_dhcp_client(client, "could not receive message from raw "
1577                                 "socket: %m");
1578                 return 0;
1579         } else if ((size_t)len < sizeof(DHCPPacket))
1580                 return 0;
1581
1582         for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
1583                 if (cmsg->cmsg_level == SOL_PACKET &&
1584                     cmsg->cmsg_type == PACKET_AUXDATA &&
1585                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct tpacket_auxdata))) {
1586                         struct tpacket_auxdata *aux = (struct tpacket_auxdata*)CMSG_DATA(cmsg);
1587
1588                         checksum = !(aux->tp_status & TP_STATUS_CSUMNOTREADY);
1589                         break;
1590                 }
1591         }
1592
1593         r = dhcp_packet_verify_headers(packet, len, checksum);
1594         if (r < 0)
1595                 return 0;
1596
1597         len -= DHCP_IP_UDP_SIZE;
1598
1599         return client_handle_message(client, &packet->dhcp, len);
1600 }
1601
1602 int sd_dhcp_client_start(sd_dhcp_client *client) {
1603         int r;
1604
1605         assert_return(client, -EINVAL);
1606
1607         r = client_initialize(client);
1608         if (r < 0)
1609                 return r;
1610
1611         if (client->last_addr)
1612                 client->state = DHCP_STATE_INIT_REBOOT;
1613
1614         r = client_start(client);
1615         if (r >= 0)
1616                 log_dhcp_client(client, "STARTED on ifindex %u", client->index);
1617
1618         return r;
1619 }
1620
1621 int sd_dhcp_client_stop(sd_dhcp_client *client) {
1622         DHCP_CLIENT_DONT_DESTROY(client);
1623
1624         assert_return(client, -EINVAL);
1625
1626         client_stop(client, DHCP_EVENT_STOP);
1627         client->state = DHCP_STATE_STOPPED;
1628
1629         return 0;
1630 }
1631
1632 int sd_dhcp_client_attach_event(sd_dhcp_client *client, sd_event *event,
1633                                 int priority) {
1634         int r;
1635
1636         assert_return(client, -EINVAL);
1637         assert_return(!client->event, -EBUSY);
1638
1639         if (event)
1640                 client->event = sd_event_ref(event);
1641         else {
1642                 r = sd_event_default(&client->event);
1643                 if (r < 0)
1644                         return 0;
1645         }
1646
1647         client->event_priority = priority;
1648
1649         return 0;
1650 }
1651
1652 int sd_dhcp_client_detach_event(sd_dhcp_client *client) {
1653         assert_return(client, -EINVAL);
1654
1655         client->event = sd_event_unref(client->event);
1656
1657         return 0;
1658 }
1659
1660 sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) {
1661         if (!client)
1662                 return NULL;
1663
1664         return client->event;
1665 }
1666
1667 sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client) {
1668         if (client)
1669                 assert_se(REFCNT_INC(client->n_ref) >= 2);
1670
1671         return client;
1672 }
1673
1674 sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) {
1675         if (client && REFCNT_DEC(client->n_ref) == 0) {
1676                 log_dhcp_client(client, "FREE");
1677
1678                 client_initialize(client);
1679
1680                 client->receive_message =
1681                         sd_event_source_unref(client->receive_message);
1682
1683                 sd_dhcp_client_detach_event(client);
1684
1685                 sd_dhcp_lease_unref(client->lease);
1686
1687                 free(client->req_opts);
1688                 free(client->hostname);
1689                 free(client->vendor_class_identifier);
1690                 free(client);
1691         }
1692
1693         return NULL;
1694 }
1695
1696 int sd_dhcp_client_new(sd_dhcp_client **ret) {
1697         _cleanup_dhcp_client_unref_ sd_dhcp_client *client = NULL;
1698
1699         assert_return(ret, -EINVAL);
1700
1701         client = new0(sd_dhcp_client, 1);
1702         if (!client)
1703                 return -ENOMEM;
1704
1705         client->n_ref = REFCNT_INIT;
1706         client->state = DHCP_STATE_INIT;
1707         client->index = -1;
1708         client->fd = -1;
1709         client->attempt = 1;
1710         client->mtu = DHCP_DEFAULT_MIN_SIZE;
1711
1712         client->req_opts_size = ELEMENTSOF(default_req_opts);
1713
1714         client->req_opts = memdup(default_req_opts, client->req_opts_size);
1715         if (!client->req_opts)
1716                 return -ENOMEM;
1717
1718         *ret = client;
1719         client = NULL;
1720
1721         return 0;
1722 }