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 <sys/param.h>
  26 #include <sys/ioctl.h>
  27
  28 #include "util.h"
  29 #include "list.h"
  30
  31 #include "dhcp-protocol.h"
  32 #include "dhcp-internal.h"
  33 #include "dhcp-lease-internal.h"
  34 #include "sd-dhcp-client.h"
  35
  36 struct sd_dhcp_client {
  37         DHCPState state;
  38         sd_event *event;
  39         int event_priority;
  40         sd_event_source *timeout_resend;
  41         int index;
  42         int fd;
  43         union sockaddr_union link;
  44         sd_event_source *receive_message;
  45         uint8_t *req_opts;
  46         size_t req_opts_allocated;
  47         size_t req_opts_size;
  48         be32_t last_addr;
  49         struct ether_addr mac_addr;
  50         uint32_t xid;
  51         usec_t start_time;
  52         uint16_t secs;
  53         unsigned int attempt;
  54         usec_t request_sent;
  55         sd_event_source *timeout_t1;
  56         sd_event_source *timeout_t2;
  57         sd_event_source *timeout_expire;
  58         sd_dhcp_client_cb_t cb;
  59         void *userdata;
  60         sd_dhcp_lease *lease;
  61 };
  62
  63 static const uint8_t default_req_opts[] = {
  64         DHCP_OPTION_SUBNET_MASK,
  65         DHCP_OPTION_ROUTER,
  66         DHCP_OPTION_HOST_NAME,
  67         DHCP_OPTION_DOMAIN_NAME,
  68         DHCP_OPTION_DOMAIN_NAME_SERVER,
  69         DHCP_OPTION_NTP_SERVER,
  70 };
  71
  72 static int client_receive_message_raw(sd_event_source *s, int fd,
  73                                       uint32_t revents, void *userdata);
  74 static int client_receive_message_udp(sd_event_source *s, int fd,
  75                                       uint32_t revents, void *userdata);
  76
  77 int sd_dhcp_client_set_callback(sd_dhcp_client *client, sd_dhcp_client_cb_t cb,
  78                                 void *userdata) {
  79         assert_return(client, -EINVAL);
  80
  81         client->cb = cb;
  82         client->userdata = userdata;
  83
  84         return 0;
  85 }
  86
  87 int sd_dhcp_client_set_request_option(sd_dhcp_client *client, uint8_t option) {
  88         size_t i;
  89
  90         assert_return(client, -EINVAL);
  91         assert_return (client->state == DHCP_STATE_INIT, -EBUSY);
  92
  93         switch(option) {
  94         case DHCP_OPTION_PAD:
  95         case DHCP_OPTION_OVERLOAD:
  96         case DHCP_OPTION_MESSAGE_TYPE:
  97         case DHCP_OPTION_PARAMETER_REQUEST_LIST:
  98         case DHCP_OPTION_END:
  99                 return -EINVAL;
 100
 101         default:
 102                 break;
 103         }
 104
 105         for (i = 0; i < client->req_opts_size; i++)
 106                 if (client->req_opts[i] == option)
 107                         return -EEXIST;
 108
 109         if (!GREEDY_REALLOC(client->req_opts, client->req_opts_allocated,
 110                             client->req_opts_size + 1))
 111                 return -ENOMEM;
 112
 113         client->req_opts[client->req_opts_size++] = option;
 114
 115         return 0;
 116 }
 117
 118 int sd_dhcp_client_set_request_address(sd_dhcp_client *client,
 119                                        const struct in_addr *last_addr) {
 120         assert_return(client, -EINVAL);
 121         assert_return(client->state == DHCP_STATE_INIT, -EBUSY);
 122
 123         if (last_addr)
 124                 client->last_addr = last_addr->s_addr;
 125         else
 126                 client->last_addr = INADDR_ANY;
 127
 128         return 0;
 129 }
 130
 131 int sd_dhcp_client_set_index(sd_dhcp_client *client, int interface_index) {
 132         assert_return(client, -EINVAL);
 133         assert_return(client->state == DHCP_STATE_INIT, -EBUSY);
 134         assert_return(interface_index >= -1, -EINVAL);
 135
 136         client->index = interface_index;
 137
 138         return 0;
 139 }
 140
 141 int sd_dhcp_client_set_mac(sd_dhcp_client *client,
 142                            const struct ether_addr *addr) {
 143         assert_return(client, -EINVAL);
 144         assert_return(client->state == DHCP_STATE_INIT, -EBUSY);
 145
 146         log_dhcp_client(client, "set MAC address to "
 147                         "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
 148                         addr->ether_addr_octet[0],
 149                         addr->ether_addr_octet[1],
 150                         addr->ether_addr_octet[2],
 151                         addr->ether_addr_octet[3],
 152                         addr->ether_addr_octet[4],
 153                         addr->ether_addr_octet[5]);
 154
 155         memcpy(&client->mac_addr, addr, ETH_ALEN);
 156
 157         return 0;
 158 }
 159
 160 int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) {
 161         assert_return(client, -EINVAL);
 162         assert_return(ret, -EINVAL);
 163
 164         if (client->state != DHCP_STATE_BOUND &&
 165             client->state != DHCP_STATE_RENEWING &&
 166             client->state != DHCP_STATE_REBINDING)
 167                 return -EADDRNOTAVAIL;
 168
 169         *ret = sd_dhcp_lease_ref(client->lease);
 170
 171         return 0;
 172 }
 173
 174 static int client_notify(sd_dhcp_client *client, int event) {
 175         if (client->cb)
 176                 client->cb(client, event, client->userdata);
 177
 178         return 0;
 179 }
 180
 181 static int client_initialize(sd_dhcp_client *client) {
 182         assert_return(client, -EINVAL);
 183
 184         client->receive_message =
 185                 sd_event_source_unref(client->receive_message);
 186
 187         client->fd = safe_close(client->fd);
 188
 189         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 190
 191         client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
 192         client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
 193         client->timeout_expire = sd_event_source_unref(client->timeout_expire);
 194
 195         client->attempt = 1;
 196
 197         client->start_time = 0;
 198         client->secs = 0;
 199         client->state = DHCP_STATE_INIT;
 200         client->xid = 0;
 201
 202         if (client->lease)
 203                 client->lease = sd_dhcp_lease_unref(client->lease);
 204
 205         return 0;
 206 }
 207
 208 static int client_stop(sd_dhcp_client *client, int error) {
 209         assert_return(client, -EINVAL);
 210
 211         client_notify(client, error);
 212
 213         client_initialize(client);
 214
 215         log_dhcp_client(client, "STOPPED");
 216
 217         return 0;
 218 }
 219
 220 static int client_message_init(sd_dhcp_client *client, DHCPMessage *message,
 221                                uint8_t type, uint16_t secs, uint8_t **opt,
 222                                size_t *optlen) {
 223         int r;
 224
 225         assert(secs);
 226
 227         r = dhcp_message_init(message, BOOTREQUEST, client->xid, type, opt,
 228                               optlen);
 229         if (r < 0)
 230                 return r;
 231
 232         /* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers
 233            refuse to issue an DHCP lease if 'secs' is set to zero */
 234         message->secs = htobe16(secs);
 235
 236         memcpy(&message->chaddr, &client->mac_addr, ETH_ALEN);
 237
 238         if (client->state == DHCP_STATE_RENEWING ||
 239             client->state == DHCP_STATE_REBINDING)
 240                 message->ciaddr = client->lease->address;
 241
 242         /* Some DHCP servers will refuse to issue an DHCP lease if the Client
 243            Identifier option is not set */
 244         r = dhcp_option_append(opt, optlen, DHCP_OPTION_CLIENT_IDENTIFIER,
 245                                ETH_ALEN, &client->mac_addr);
 246         if (r < 0)
 247                 return r;
 248
 249         if (type == DHCP_DISCOVER || type == DHCP_REQUEST) {
 250                 be16_t max_size;
 251
 252                 r = dhcp_option_append(opt, optlen,
 253                                        DHCP_OPTION_PARAMETER_REQUEST_LIST,
 254                                        client->req_opts_size,
 255                                        client->req_opts);
 256                 if (r < 0)
 257                         return r;
 258
 259                 /* Some DHCP servers will send bigger DHCP packets than the
 260                    defined default size unless the Maximum Messge Size option
 261                    is explicitely set */
 262                 max_size = htobe16(DHCP_IP_UDP_SIZE + DHCP_MESSAGE_SIZE +
 263                                    DHCP_MIN_OPTIONS_SIZE);
 264                 r = dhcp_option_append(opt, optlen,
 265                                        DHCP_OPTION_MAXIMUM_MESSAGE_SIZE,
 266                                        2, &max_size);
 267                 if (r < 0)
 268                         return r;
 269         }
 270
 271         return 0;
 272 }
 273
 274 static int dhcp_client_send_raw(sd_dhcp_client *client, DHCPPacket *packet,
 275                                 size_t len) {
 276         dhcp_packet_append_ip_headers(packet, INADDR_ANY, DHCP_PORT_CLIENT,
 277                                       INADDR_BROADCAST, DHCP_PORT_SERVER, len);
 278
 279         return dhcp_network_send_raw_socket(client->fd, &client->link,
 280                                             packet, len);
 281 }
 282
 283 static int client_send_discover(sd_dhcp_client *client, uint16_t secs) {
 284         int err = 0;
 285         _cleanup_free_ DHCPPacket *discover;
 286         size_t optlen, len;
 287         uint8_t *opt;
 288
 289         optlen = DHCP_MIN_OPTIONS_SIZE;
 290         len = sizeof(DHCPPacket) + optlen;
 291
 292         discover = malloc0(len);
 293
 294         if (!discover)
 295                 return -ENOMEM;
 296
 297         err = client_message_init(client, &discover->dhcp, DHCP_DISCOVER,
 298                                   secs, &opt, &optlen);
 299         if (err < 0)
 300                 return err;
 301
 302         if (client->last_addr != INADDR_ANY) {
 303                 err = dhcp_option_append(&opt, &optlen,
 304                                          DHCP_OPTION_REQUESTED_IP_ADDRESS,
 305                                          4, &client->last_addr);
 306                 if (err < 0)
 307                         return err;
 308         }
 309
 310         err = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL);
 311         if (err < 0)
 312                 return err;
 313
 314         err = dhcp_client_send_raw(client, discover, len);
 315         if (err < 0)
 316                 return err;
 317
 318         log_dhcp_client(client, "DISCOVER");
 319
 320         return 0;
 321 }
 322
 323 static int client_send_request(sd_dhcp_client *client, uint16_t secs) {
 324         _cleanup_free_ DHCPPacket *request;
 325         size_t optlen, len;
 326         int err;
 327         uint8_t *opt;
 328
 329         optlen = DHCP_MIN_OPTIONS_SIZE;
 330         len = sizeof(DHCPPacket) + optlen;
 331
 332         request = malloc0(len);
 333         if (!request)
 334                 return -ENOMEM;
 335
 336         err = client_message_init(client, &request->dhcp, DHCP_REQUEST, secs,
 337                                   &opt, &optlen);
 338         if (err < 0)
 339                 return err;
 340
 341         if (client->state == DHCP_STATE_REQUESTING) {
 342                 err = dhcp_option_append(&opt, &optlen,
 343                                          DHCP_OPTION_REQUESTED_IP_ADDRESS,
 344                                          4, &client->lease->address);
 345                 if (err < 0)
 346                         return err;
 347
 348                 err = dhcp_option_append(&opt, &optlen,
 349                                          DHCP_OPTION_SERVER_IDENTIFIER,
 350                                          4, &client->lease->server_address);
 351                 if (err < 0)
 352                         return err;
 353         }
 354
 355         err = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL);
 356         if (err < 0)
 357                 return err;
 358
 359         if (client->state == DHCP_STATE_RENEWING) {
 360                 err = dhcp_network_send_udp_socket(client->fd,
 361                                                    client->lease->server_address,
 362                                                    DHCP_PORT_SERVER,
 363                                                    &request->dhcp,
 364                                                    len - DHCP_IP_UDP_SIZE);
 365         } else {
 366                 err = dhcp_client_send_raw(client, request, len);
 367         }
 368         if (err < 0)
 369                 return err;
 370
 371         log_dhcp_client(client, "REQUEST");
 372
 373         return 0;
 374 }
 375
 376 static uint16_t client_update_secs(sd_dhcp_client *client, usec_t time_now)
 377 {
 378         client->secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1;
 379
 380         return client->secs;
 381 }
 382
 383 static int client_timeout_resend(sd_event_source *s, uint64_t usec,
 384                                  void *userdata) {
 385         sd_dhcp_client *client = userdata;
 386         usec_t next_timeout = 0;
 387         uint64_t time_now;
 388         uint32_t time_left;
 389         int r;
 390
 391         assert(s);
 392         assert(client);
 393         assert(client->event);
 394
 395         r = sd_event_get_now_monotonic(client->event, &time_now);
 396         if (r < 0)
 397                 goto error;
 398
 399         switch (client->state) {
 400         case DHCP_STATE_RENEWING:
 401
 402                 time_left = (client->lease->t2 - client->lease->t1) / 2;
 403                 if (time_left < 60)
 404                         time_left = 60;
 405
 406                 next_timeout = time_now + time_left * USEC_PER_SEC;
 407
 408                 break;
 409
 410         case DHCP_STATE_REBINDING:
 411
 412                 time_left = (client->lease->lifetime - client->lease->t2) / 2;
 413                 if (time_left < 60)
 414                         time_left = 60;
 415
 416                 next_timeout = time_now + time_left * USEC_PER_SEC;
 417                 break;
 418
 419         case DHCP_STATE_INIT:
 420         case DHCP_STATE_INIT_REBOOT:
 421         case DHCP_STATE_REBOOTING:
 422         case DHCP_STATE_SELECTING:
 423         case DHCP_STATE_REQUESTING:
 424         case DHCP_STATE_BOUND:
 425
 426                 if (client->attempt < 64)
 427                         client->attempt *= 2;
 428
 429                 next_timeout = time_now + (client->attempt - 1) * USEC_PER_SEC;
 430
 431                 break;
 432         }
 433
 434         next_timeout += (random_u32() & 0x1fffff);
 435
 436         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 437
 438         r = sd_event_add_monotonic(client->event,
 439                                      &client->timeout_resend,
 440                                      next_timeout,
 441                                      10 * USEC_PER_MSEC,
 442                                      client_timeout_resend, client);
 443         if (r < 0)
 444                 goto error;
 445
 446         r = sd_event_source_set_priority(client->timeout_resend,
 447                                          client->event_priority);
 448         if (r < 0)
 449                 goto error;
 450
 451         switch (client->state) {
 452         case DHCP_STATE_INIT:
 453
 454                 client_update_secs(client, time_now);
 455
 456                 r = client_send_discover(client, client->secs);
 457                 if (r >= 0) {
 458                         client->state = DHCP_STATE_SELECTING;
 459                         client->attempt = 1;
 460                 } else {
 461                         if (client->attempt >= 64)
 462                                 goto error;
 463                 }
 464
 465                 break;
 466
 467         case DHCP_STATE_SELECTING:
 468                 client_update_secs(client, time_now);
 469
 470                 r = client_send_discover(client, client->secs);
 471                 if (r < 0 && client->attempt >= 64)
 472                         goto error;
 473
 474                 break;
 475
 476         case DHCP_STATE_REQUESTING:
 477         case DHCP_STATE_RENEWING:
 478         case DHCP_STATE_REBINDING:
 479                 r = client_send_request(client, client->secs);
 480                 if (r < 0 && client->attempt >= 64)
 481                          goto error;
 482
 483                 client->request_sent = time_now;
 484
 485                 break;
 486
 487         case DHCP_STATE_INIT_REBOOT:
 488         case DHCP_STATE_REBOOTING:
 489         case DHCP_STATE_BOUND:
 490
 491                 break;
 492         }
 493
 494         return 0;
 495
 496 error:
 497         client_stop(client, r);
 498
 499         /* Errors were dealt with when stopping the client, don't spill
 500            errors into the event loop handler */
 501         return 0;
 502 }
 503
 504 static int client_initialize_events(sd_dhcp_client *client,
 505                                     sd_event_io_handler_t io_callback) {
 506         int r;
 507
 508         assert(client);
 509         assert(client->event);
 510
 511         r = sd_event_add_io(client->event, &client->receive_message,
 512                             client->fd, EPOLLIN, io_callback,
 513                             client);
 514         if (r < 0)
 515                 goto error;
 516
 517         r = sd_event_source_set_priority(client->receive_message,
 518                                          client->event_priority);
 519         if (r < 0)
 520                 goto error;
 521
 522         client->timeout_resend = sd_event_source_unref(client->timeout_resend);
 523
 524         r = sd_event_add_monotonic(client->event,
 525                                    &client->timeout_resend, 0, 0,
 526                                    client_timeout_resend, client);
 527         if (r < 0)
 528                 goto error;
 529
 530         r = sd_event_source_set_priority(client->timeout_resend,
 531                                          client->event_priority);
 532
 533 error:
 534         if (r < 0)
 535                 client_stop(client, r);
 536
 537         return 0;
 538
 539 }
 540
 541 static int client_start(sd_dhcp_client *client) {
 542         int r;
 543
 544         assert_return(client, -EINVAL);
 545         assert_return(client->event, -EINVAL);
 546         assert_return(client->index > 0, -EINVAL);
 547         assert_return(client->fd < 0, -EBUSY);
 548         assert_return(client->xid == 0, -EINVAL);
 549         assert_return(client->state == DHCP_STATE_INIT ||
 550                       client->state == DHCP_STATE_INIT_REBOOT, -EBUSY);
 551
 552         client->xid = random_u32();
 553
 554         r = dhcp_network_bind_raw_socket(client->index, &client->link);
 555
 556         if (r < 0) {
 557                 client_stop(client, r);
 558                 return r;
 559         }
 560
 561         client->fd = r;
 562         client->start_time = now(CLOCK_MONOTONIC);
 563         client->secs = 0;
 564
 565         log_dhcp_client(client, "STARTED");
 566
 567         return client_initialize_events(client, client_receive_message_raw);
 568 }
 569
 570 static int client_timeout_expire(sd_event_source *s, uint64_t usec,
 571                                  void *userdata) {
 572         sd_dhcp_client *client = userdata;
 573
 574         log_dhcp_client(client, "EXPIRED");
 575
 576         client_notify(client, DHCP_EVENT_EXPIRED);
 577
 578         /* start over as the lease was lost */
 579         client_initialize(client);
 580         client_start(client);
 581
 582         return 0;
 583 }
 584
 585 static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) {
 586         sd_dhcp_client *client = userdata;
 587         int r;
 588
 589         client->receive_message = sd_event_source_unref(client->receive_message);
 590         client->fd = safe_close(client->fd);
 591
 592         client->state = DHCP_STATE_REBINDING;
 593         client->attempt = 1;
 594
 595         r = dhcp_network_bind_raw_socket(client->index, &client->link);
 596         if (r < 0) {
 597                 client_stop(client, r);
 598                 return 0;
 599         }
 600
 601         client->fd = r;
 602
 603         log_dhcp_client(client, "TIMEOUT T2");
 604
 605         return client_initialize_events(client, client_receive_message_raw);
 606 }
 607
 608 static int client_timeout_t1(sd_event_source *s, uint64_t usec,
 609                              void *userdata) {
 610         sd_dhcp_client *client = userdata;
 611         int r;
 612
 613         client->state = DHCP_STATE_RENEWING;
 614         client->attempt = 1;
 615
 616         r = dhcp_network_bind_udp_socket(client->index,
 617                                          client->lease->address,
 618                                          DHCP_PORT_CLIENT);
 619         if (r < 0) {
 620                 client_stop(client, r);
 621                 return 0;
 622         }
 623
 624         client->fd = r;
 625
 626         log_dhcp_client(client, "TIMEOUT T1");
 627
 628         return client_initialize_events(client, client_receive_message_udp);
 629 }
 630
 631 static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer,
 632                                size_t len) {
 633         _cleanup_dhcp_lease_unref_ sd_dhcp_lease *lease = NULL;
 634         int r;
 635
 636         r = dhcp_lease_new(&lease);
 637         if (r < 0)
 638                 return r;
 639
 640         r = dhcp_option_parse(offer, len, dhcp_lease_parse_options, lease);
 641         if (r != DHCP_OFFER)
 642                 return -ENOMSG;
 643
 644         lease->next_server = offer->siaddr;
 645
 646         lease->address = offer->yiaddr;
 647
 648         if (lease->address == INADDR_ANY ||
 649             lease->server_address == INADDR_ANY ||
 650             lease->subnet_mask == INADDR_ANY ||
 651             lease->lifetime == 0)
 652                 return -ENOMSG;
 653
 654         client->lease = lease;
 655         lease = NULL;
 656
 657         log_dhcp_client(client, "OFFER");
 658
 659         return 0;
 660 }
 661
 662 static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack,
 663                              size_t len) {
 664         _cleanup_dhcp_lease_unref_ sd_dhcp_lease *lease = NULL;
 665         int r;
 666
 667         r = dhcp_lease_new(&lease);
 668         if (r < 0)
 669                 return r;
 670
 671         r = dhcp_option_parse(ack, len, dhcp_lease_parse_options, lease);
 672         if (r == DHCP_NAK) {
 673                 log_dhcp_client(client, "NAK");
 674                 return DHCP_EVENT_NO_LEASE;
 675         }
 676
 677         if (r != DHCP_ACK)
 678                 return -ENOMSG;
 679
 680         lease->next_server = ack->siaddr;
 681
 682         lease->address = ack->yiaddr;
 683
 684         if (lease->address == INADDR_ANY ||
 685             lease->server_address == INADDR_ANY ||
 686             lease->subnet_mask == INADDR_ANY || lease->lifetime == 0)
 687                 return -ENOMSG;
 688
 689         r = DHCP_EVENT_IP_ACQUIRE;
 690         if (client->lease) {
 691                 if (client->lease->address != lease->address ||
 692                     client->lease->subnet_mask != lease->subnet_mask ||
 693                     client->lease->router != lease->router) {
 694                         r = DHCP_EVENT_IP_CHANGE;
 695                 }
 696
 697                 client->lease = sd_dhcp_lease_unref(client->lease);
 698         }
 699
 700         client->lease = lease;
 701         lease = NULL;
 702
 703         log_dhcp_client(client, "ACK");
 704
 705         return r;
 706 }
 707
 708 static uint64_t client_compute_timeout(uint64_t request_sent,
 709                                        uint32_t lifetime) {
 710         return request_sent + (lifetime - 3) * USEC_PER_SEC +
 711                 + (random_u32() & 0x1fffff);
 712 }
 713
 714 static int client_set_lease_timeouts(sd_dhcp_client *client, uint64_t usec) {
 715         uint64_t next_timeout;
 716         int r;
 717
 718         assert(client);
 719         assert(client->event);
 720
 721         if (client->lease->lifetime < 10)
 722                 return -EINVAL;
 723
 724         client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
 725         client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
 726         client->timeout_expire = sd_event_source_unref(client->timeout_expire);
 727
 728         if (!client->lease->t1)
 729                 client->lease->t1 = client->lease->lifetime / 2;
 730
 731         next_timeout = client_compute_timeout(client->request_sent,
 732                                               client->lease->t1);
 733         if (next_timeout < usec)
 734                 return -EINVAL;
 735
 736         r = sd_event_add_monotonic(client->event,
 737                                    &client->timeout_t1,
 738                                    next_timeout,
 739                                    10 * USEC_PER_MSEC,
 740                                    client_timeout_t1, client);
 741         if (r < 0)
 742                 return r;
 743
 744         r = sd_event_source_set_priority(client->timeout_t1,
 745                                          client->event_priority);
 746         if (r < 0)
 747                 return r;
 748
 749         if (!client->lease->t2)
 750                 client->lease->t2 = client->lease->lifetime * 7 / 8;
 751
 752         if (client->lease->t2 < client->lease->t1)
 753                 return -EINVAL;
 754
 755         if (client->lease->lifetime < client->lease->t2)
 756                 return -EINVAL;
 757
 758         next_timeout = client_compute_timeout(client->request_sent,
 759                                               client->lease->t2);
 760         if (next_timeout < usec)
 761                 return -EINVAL;
 762
 763         r = sd_event_add_monotonic(client->event,
 764                                    &client->timeout_t2,
 765                                    next_timeout,
 766                                    10 * USEC_PER_MSEC,
 767                                    client_timeout_t2, client);
 768         if (r < 0)
 769                 return r;
 770
 771         r = sd_event_source_set_priority(client->timeout_t2,
 772                                          client->event_priority);
 773         if (r < 0)
 774                 return r;
 775
 776         next_timeout = client_compute_timeout(client->request_sent,
 777                                               client->lease->lifetime);
 778         if (next_timeout < usec)
 779                 return -EINVAL;
 780
 781         r = sd_event_add_monotonic(client->event,
 782                                    &client->timeout_expire, next_timeout,
 783                                    10 * USEC_PER_MSEC,
 784                                    client_timeout_expire, client);
 785         if (r < 0)
 786                 return r;
 787
 788         r = sd_event_source_set_priority(client->timeout_expire,
 789                                          client->event_priority);
 790         if (r < 0)
 791                 return r;
 792
 793         return 0;
 794 }
 795
 796 static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message,
 797                                  int len, usec_t time_now) {
 798         int r = 0, notify_event = 0;
 799
 800         assert(client);
 801         assert(client->event);
 802         assert(message);
 803
 804         if (len < DHCP_MESSAGE_SIZE) {
 805                 log_dhcp_client(client, "message too small (%d bytes): "
 806                                 "ignoring", len);
 807                 return 0;
 808         }
 809
 810         if (message->op != BOOTREPLY) {
 811                 log_dhcp_client(client, "not a BOOTREPLY message: ignoring");
 812                 return 0;
 813         }
 814
 815         if (be32toh(message->xid) != client->xid) {
 816                 log_dhcp_client(client, "received xid (%u) does not match "
 817                                 "expected (%u): ignoring",
 818                                 be32toh(message->xid), client->xid);
 819                 return 0;
 820         }
 821
 822         if (memcmp(&message->chaddr[0], &client->mac_addr.ether_addr_octet,
 823                    ETHER_ADDR_LEN)) {
 824                 log_dhcp_client(client, "received chaddr does not match "
 825                                 "expected: ignoring");
 826                 return 0;
 827         }
 828
 829         switch (client->state) {
 830         case DHCP_STATE_SELECTING:
 831
 832                 r = client_handle_offer(client, message, len);
 833                 if (r >= 0) {
 834
 835                         client->timeout_resend =
 836                                 sd_event_source_unref(client->timeout_resend);
 837
 838                         client->state = DHCP_STATE_REQUESTING;
 839                         client->attempt = 1;
 840
 841                         r = sd_event_add_monotonic(client->event,
 842                                                    &client->timeout_resend, 0,
 843                                                    0, client_timeout_resend,
 844                                                    client);
 845                         if (r < 0)
 846                                 goto error;
 847
 848                         r = sd_event_source_set_priority(client->timeout_resend,
 849                                                          client->event_priority);
 850                         if (r < 0)
 851                                 goto error;
 852                 }
 853
 854                 break;
 855
 856         case DHCP_STATE_REQUESTING:
 857         case DHCP_STATE_RENEWING:
 858         case DHCP_STATE_REBINDING:
 859
 860                 r = client_handle_ack(client, message, len);
 861
 862                 if (r == DHCP_EVENT_NO_LEASE)
 863                         goto error;
 864
 865                 if (r >= 0) {
 866                         client->timeout_resend =
 867                                 sd_event_source_unref(client->timeout_resend);
 868
 869                         if (client->state == DHCP_STATE_REQUESTING)
 870                                 notify_event = DHCP_EVENT_IP_ACQUIRE;
 871                         else if (r != DHCP_EVENT_IP_ACQUIRE)
 872                                 notify_event = r;
 873
 874                         client->state = DHCP_STATE_BOUND;
 875                         client->attempt = 1;
 876
 877                         client->last_addr = client->lease->address;
 878
 879                         r = client_set_lease_timeouts(client, time_now);
 880                         if (r < 0)
 881                                 goto error;
 882
 883                         if (notify_event)
 884                                 client_notify(client, notify_event);
 885
 886                         client->receive_message =
 887                                 sd_event_source_unref(client->receive_message);
 888                         client->fd = safe_close(client->fd);
 889                 }
 890
 891                 r = 0;
 892
 893                 break;
 894
 895         case DHCP_STATE_INIT:
 896         case DHCP_STATE_INIT_REBOOT:
 897         case DHCP_STATE_REBOOTING:
 898         case DHCP_STATE_BOUND:
 899
 900                 break;
 901         }
 902
 903 error:
 904         if (r < 0 || r == DHCP_EVENT_NO_LEASE)
 905                 return client_stop(client, r);
 906
 907         return 0;
 908 }
 909
 910 static int client_receive_message_udp(sd_event_source *s, int fd,
 911                                       uint32_t revents, void *userdata) {
 912         sd_dhcp_client *client = userdata;
 913         _cleanup_free_ DHCPMessage *message = NULL;
 914         int buflen = 0, len, r;
 915         usec_t time_now;
 916
 917         assert(s);
 918         assert(client);
 919         assert(client->event);
 920
 921         r = ioctl(fd, FIONREAD, &buflen);
 922         if (r < 0 || buflen <= 0)
 923                 buflen = sizeof(DHCPMessage) + DHCP_MIN_OPTIONS_SIZE;
 924
 925         message = malloc0(buflen);
 926         if (!message)
 927                 return -ENOMEM;
 928
 929         len = read(fd, message, buflen);
 930         if (len < 0)
 931                 return 0;
 932
 933         r = sd_event_get_now_monotonic(client->event, &time_now);
 934         if (r < 0)
 935                 return client_stop(client, r);
 936
 937         return client_handle_message(client, message, len,
 938                                      time_now);
 939 }
 940
 941 static int client_receive_message_raw(sd_event_source *s, int fd,
 942                                       uint32_t revents, void *userdata) {
 943         sd_dhcp_client *client = userdata;
 944         _cleanup_free_ DHCPPacket *packet = NULL;
 945         usec_t time_now;
 946         uint8_t cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
 947         struct iovec iov = {};
 948         struct msghdr msg = {
 949                 .msg_iov = &iov,
 950                 .msg_iovlen = 1,
 951                 .msg_control = cmsgbuf,
 952                 .msg_controllen = sizeof(cmsgbuf),
 953         };
 954         struct cmsghdr *cmsg;
 955         bool checksum = true;
 956         int buflen = 0, len, r;
 957
 958         assert(s);
 959         assert(client);
 960         assert(client->event);
 961
 962         r = ioctl(fd, FIONREAD, &buflen);
 963         if (r < 0 || buflen <= 0)
 964                 buflen = sizeof(DHCPPacket) + DHCP_MIN_OPTIONS_SIZE;
 965
 966         packet = malloc0(buflen);
 967         if (!packet)
 968                 return -ENOMEM;
 969
 970         iov.iov_base = packet;
 971         iov.iov_len = buflen;
 972
 973         len = recvmsg(fd, &msg, 0);
 974         if (len < 0) {
 975                 log_dhcp_client(client, "could not receive message from raw "
 976                                 "socket: %s", strerror(errno));
 977                 return 0;
 978         }
 979
 980         for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 981                 if (cmsg->cmsg_level == SOL_PACKET && cmsg->cmsg_type == PACKET_AUXDATA) {
 982                         struct tpacket_auxdata *aux = (void *)CMSG_DATA(cmsg);
 983
 984                         checksum = !(aux->tp_status & TP_STATUS_CSUMNOTREADY);
 985                         break;
 986                 }
 987         }
 988
 989         r = dhcp_packet_verify_headers(packet, len, checksum);
 990         if (r < 0)
 991                 return 0;
 992
 993         len -= DHCP_IP_UDP_SIZE;
 994
 995         r = sd_event_get_now_monotonic(client->event, &time_now);
 996         if (r < 0)
 997                 return client_stop(client, r);
 998
 999         return client_handle_message(client, &packet->dhcp, len, time_now);
1000 }
1001
1002 int sd_dhcp_client_start(sd_dhcp_client *client) {
1003         int r;
1004
1005         assert_return(client, -EINVAL);
1006
1007         r = client_initialize(client);
1008         if (r < 0)
1009                 return r;
1010
1011         if (client->last_addr)
1012                 client->state = DHCP_STATE_INIT_REBOOT;
1013
1014         return client_start(client);
1015 }
1016
1017 int sd_dhcp_client_stop(sd_dhcp_client *client) {
1018         return client_stop(client, DHCP_EVENT_STOP);
1019 }
1020
1021 int sd_dhcp_client_attach_event(sd_dhcp_client *client, sd_event *event,
1022                                 int priority) {
1023         int r;
1024
1025         assert_return(client, -EINVAL);
1026         assert_return(!client->event, -EBUSY);
1027
1028         if (event)
1029                 client->event = sd_event_ref(event);
1030         else {
1031                 r = sd_event_default(&client->event);
1032                 if (r < 0)
1033                         return 0;
1034         }
1035
1036         client->event_priority = priority;
1037
1038         return 0;
1039 }
1040
1041 int sd_dhcp_client_detach_event(sd_dhcp_client *client) {
1042         assert_return(client, -EINVAL);
1043
1044         client->event = sd_event_unref(client->event);
1045
1046         return 0;
1047 }
1048
1049 sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) {
1050         if (!client)
1051                 return NULL;
1052
1053         return client->event;
1054 }
1055
1056 void sd_dhcp_client_free(sd_dhcp_client *client) {
1057         if (!client)
1058                 return;
1059
1060         sd_dhcp_client_stop(client);
1061         sd_dhcp_client_detach_event(client);
1062
1063         free(client->req_opts);
1064         free(client);
1065 }
1066
1067 DEFINE_TRIVIAL_CLEANUP_FUNC(sd_dhcp_client*, sd_dhcp_client_free);
1068 #define _cleanup_dhcp_client_free_ _cleanup_(sd_dhcp_client_freep)
1069
1070 int sd_dhcp_client_new(sd_dhcp_client **ret) {
1071         _cleanup_dhcp_client_free_ sd_dhcp_client *client = NULL;
1072
1073         assert_return(ret, -EINVAL);
1074
1075         client = new0(sd_dhcp_client, 1);
1076         if (!client)
1077                 return -ENOMEM;
1078
1079         client->state = DHCP_STATE_INIT;
1080         client->index = -1;
1081         client->fd = -1;
1082         client->attempt = 1;
1083
1084         client->req_opts_size = ELEMENTSOF(default_req_opts);
1085
1086         client->req_opts = memdup(default_req_opts, client->req_opts_size);
1087         if (!client->req_opts)
1088                 return -ENOMEM;
1089
1090         *ret = client;
1091         client = NULL;
1092
1093         return 0;
1094 }