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