networking/udhcp/dhcpc.c

   1 /* dhcpc.c
   2  *
   3  * udhcp DHCP client
   4  *
   5  * Russ Dill <Russ.Dill@asu.edu> July 2001
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <sys/time.h>
  23 #include <sys/file.h>
  24 #include <unistd.h>
  25 #include <getopt.h>
  26 #include <stdlib.h>
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <arpa/inet.h>
  30 #include <signal.h>
  31 #include <time.h>
  32 #include <string.h>
  33 #include <sys/ioctl.h>
  34 #include <net/if.h>
  35 #include <errno.h>
  36
  37 #include "dhcpd.h"
  38 #include "dhcpc.h"
  39 #include "options.h"
  40 #include "clientpacket.h"
  41 #include "script.h"
  42 #include "socket.h"
  43 #include "common.h"
  44
  45 static int state;
  46 static unsigned long requested_ip; /* = 0 */
  47 static unsigned long server_addr;
  48 static unsigned long timeout;
  49 static int packet_num; /* = 0 */
  50 static int fd = -1;
  51
  52 #define LISTEN_NONE 0
  53 #define LISTEN_KERNEL 1
  54 #define LISTEN_RAW 2
  55 static int listen_mode;
  56
  57 #ifdef CONFIG_INSTALL_NO_USR
  58 #define DEFAULT_SCRIPT  "/share/udhcpc/default.script"
  59 #else
  60 #define DEFAULT_SCRIPT  "/usr/share/udhcpc/default.script"
  61 #endif
  62
  63 struct client_config_t client_config = {
  64         /* Default options. */
  65         abort_if_no_lease: 0,
  66         foreground: 0,
  67         quit_after_lease: 0,
  68         background_if_no_lease: 0,
  69         interface: "eth0",
  70         pidfile: NULL,
  71         script: DEFAULT_SCRIPT,
  72         clientid: NULL,
  73         hostname: NULL,
  74         ifindex: 0,
  75         arp: "\0\0\0\0\0\0",            /* appease gcc-3.0 */
  76 };
  77
  78 /* just a little helper */
  79 static void change_mode(int new_mode)
  80 {
  81         DEBUG(LOG_INFO, "entering %s listen mode",
  82                 new_mode ? (new_mode == 1 ? "kernel" : "raw") : "none");
  83         if (fd >= 0) close(fd);
  84         fd = -1;
  85         listen_mode = new_mode;
  86 }
  87
  88
  89 /* perform a renew */
  90 static void perform_renew(void)
  91 {
  92         LOG(LOG_INFO, "Performing a DHCP renew");
  93         switch (state) {
  94         case BOUND:
  95                 change_mode(LISTEN_KERNEL);
  96         case RENEWING:
  97         case REBINDING:
  98                 state = RENEW_REQUESTED;
  99                 break;
 100         case RENEW_REQUESTED: /* impatient are we? fine, square 1 */
 101                 run_script(NULL, "deconfig");
 102         case REQUESTING:
 103         case RELEASED:
 104                 change_mode(LISTEN_RAW);
 105                 state = INIT_SELECTING;
 106                 break;
 107         case INIT_SELECTING:
 108                 break;
 109         }
 110
 111         /* start things over */
 112         packet_num = 0;
 113
 114         /* Kill any timeouts because the user wants this to hurry along */
 115         timeout = 0;
 116 }
 117
 118
 119 /* perform a release */
 120 static void perform_release(void)
 121 {
 122         char buffer[16];
 123         struct in_addr temp_addr;
 124
 125         /* send release packet */
 126         if (state == BOUND || state == RENEWING || state == REBINDING) {
 127                 temp_addr.s_addr = server_addr;
 128                 sprintf(buffer, "%s", inet_ntoa(temp_addr));
 129                 temp_addr.s_addr = requested_ip;
 130                 LOG(LOG_INFO, "Unicasting a release of %s to %s",
 131                                 inet_ntoa(temp_addr), buffer);
 132                 send_release(server_addr, requested_ip); /* unicast */
 133                 run_script(NULL, "deconfig");
 134         }
 135         LOG(LOG_INFO, "Entering released state");
 136
 137         change_mode(LISTEN_NONE);
 138         state = RELEASED;
 139         timeout = 0x7fffffff;
 140 }
 141
 142
 143 static void client_background(void)
 144 {
 145         background(client_config.pidfile);
 146         client_config.foreground = 1; /* Do not fork again. */
 147         client_config.background_if_no_lease = 0;
 148 }
 149
 150
 151 int udhcpc_main(int argc, char *argv[])
 152 {
 153         unsigned char *temp, *message;
 154         unsigned long t1 = 0, t2 = 0, xid = 0;
 155         unsigned long start = 0, lease;
 156         fd_set rfds;
 157         int retval;
 158         struct timeval tv;
 159         int c, len;
 160         struct dhcpMessage packet;
 161         struct in_addr temp_addr;
 162         time_t now;
 163         int max_fd;
 164         int sig;
 165
 166         static const struct option arg_options[] = {
 167                 {"clientid",    required_argument,      0, 'c'},
 168                 {"foreground",  no_argument,            0, 'f'},
 169                 {"background",  no_argument,            0, 'b'},
 170                 {"hostname",    required_argument,      0, 'H'},
 171                 {"hostname",    required_argument,      0, 'h'},
 172                 {"interface",   required_argument,      0, 'i'},
 173                 {"now",         no_argument,            0, 'n'},
 174                 {"pidfile",     required_argument,      0, 'p'},
 175                 {"quit",        no_argument,            0, 'q'},
 176                 {"request",     required_argument,      0, 'r'},
 177                 {"script",      required_argument,      0, 's'},
 178                 {"version",     no_argument,            0, 'v'},
 179                 {0, 0, 0, 0}
 180         };
 181
 182         /* get options */
 183         while (1) {
 184                 int option_index = 0;
 185                 c = getopt_long(argc, argv, "c:fbH:h:i:np:qr:s:v", arg_options, &option_index);
 186                 if (c == -1) break;
 187
 188                 switch (c) {
 189                 case 'c':
 190                         len = strlen(optarg) > 255 ? 255 : strlen(optarg);
 191                         if (client_config.clientid) free(client_config.clientid);
 192                         client_config.clientid = xmalloc(len + 2);
 193                         client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID;
 194                         client_config.clientid[OPT_LEN] = len;
 195                         client_config.clientid[OPT_DATA] = '\0';
 196                         strncpy(client_config.clientid + OPT_DATA, optarg, len);
 197                         break;
 198                 case 'f':
 199                         client_config.foreground = 1;
 200                         break;
 201                 case 'b':
 202                         client_config.background_if_no_lease = 1;
 203                         break;
 204                 case 'h':
 205                 case 'H':
 206                         len = strlen(optarg) > 255 ? 255 : strlen(optarg);
 207                         if (client_config.hostname) free(client_config.hostname);
 208                         client_config.hostname = xmalloc(len + 2);
 209                         client_config.hostname[OPT_CODE] = DHCP_HOST_NAME;
 210                         client_config.hostname[OPT_LEN] = len;
 211                         strncpy(client_config.hostname + 2, optarg, len);
 212                         break;
 213                 case 'i':
 214                         client_config.interface =  optarg;
 215                         break;
 216                 case 'n':
 217                         client_config.abort_if_no_lease = 1;
 218                         break;
 219                 case 'p':
 220                         client_config.pidfile = optarg;
 221                         break;
 222                 case 'q':
 223                         client_config.quit_after_lease = 1;
 224                         break;
 225                 case 'r':
 226                         requested_ip = inet_addr(optarg);
 227                         break;
 228                 case 's':
 229                         client_config.script = optarg;
 230                         break;
 231                 case 'v':
 232                         bb_error_msg("version %s\n", VERSION);
 233                         return(0);
 234                         break;
 235                 default:
 236                         bb_show_usage();
 237                 }
 238         }
 239
 240         start_log("client");
 241         if (read_interface(client_config.interface, &client_config.ifindex,
 242                            NULL, client_config.arp) < 0)
 243                 return(1);
 244
 245         if (!client_config.clientid) {
 246                 client_config.clientid = xmalloc(6 + 3);
 247                 client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID;
 248                 client_config.clientid[OPT_LEN] = 7;
 249                 client_config.clientid[OPT_DATA] = 1;
 250                 memcpy(client_config.clientid + 3, client_config.arp, 6);
 251         }
 252
 253         /* setup signal handlers */
 254         udhcp_set_signal_pipe(SIGUSR2);
 255
 256         state = INIT_SELECTING;
 257         run_script(NULL, "deconfig");
 258         change_mode(LISTEN_RAW);
 259
 260         for (;;) {
 261
 262                 tv.tv_sec = timeout - time(0);
 263                 tv.tv_usec = 0;
 264                 FD_ZERO(&rfds);
 265
 266                 if (listen_mode != LISTEN_NONE && fd < 0) {
 267                         if (listen_mode == LISTEN_KERNEL)
 268                                 fd = listen_socket(INADDR_ANY, CLIENT_PORT, client_config.interface);
 269                         else
 270                                 fd = raw_socket(client_config.ifindex);
 271                         if (fd < 0) {
 272                                 LOG(LOG_ERR, "FATAL: couldn't listen on socket, %m");
 273                                 return(0);
 274                         }
 275                 }
 276                 if (fd >= 0) FD_SET(fd, &rfds);
 277                 FD_SET(udhcp_signal_pipe[0], &rfds);
 278
 279                 if (tv.tv_sec > 0) {
 280                         DEBUG(LOG_INFO, "Waiting on select...\n");
 281                         max_fd = udhcp_signal_pipe[0] > fd ? udhcp_signal_pipe[0] : fd;
 282                         retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
 283                 } else retval = 0; /* If we already timed out, fall through */
 284
 285                 now = time(0);
 286                 if (retval == 0) {
 287                         /* timeout dropped to zero */
 288                         switch (state) {
 289                         case INIT_SELECTING:
 290                                 if (packet_num < 3) {
 291                                         if (packet_num == 0)
 292                                                 xid = random_xid();
 293
 294                                         /* send discover packet */
 295                                         send_discover(xid, requested_ip); /* broadcast */
 296
 297                                         timeout = now + ((packet_num == 2) ? 4 : 2);
 298                                         packet_num++;
 299                                 } else {
 300                                         if (client_config.background_if_no_lease) {
 301                                                 LOG(LOG_INFO, "No lease, forking to background.");
 302                                                 client_background();
 303                                         } else if (client_config.abort_if_no_lease) {
 304                                                 LOG(LOG_INFO, "No lease, failing.");
 305                                                 return(1);
 306                                         }
 307                                         /* wait to try again */
 308                                         packet_num = 0;
 309                                         timeout = now + 60;
 310                                 }
 311                                 break;
 312                         case RENEW_REQUESTED:
 313                         case REQUESTING:
 314                                 if (packet_num < 3) {
 315                                         /* send request packet */
 316                                         if (state == RENEW_REQUESTED)
 317                                                 send_renew(xid, server_addr, requested_ip); /* unicast */
 318                                         else send_selecting(xid, server_addr, requested_ip); /* broadcast */
 319
 320                                         timeout = now + ((packet_num == 2) ? 10 : 2);
 321                                         packet_num++;
 322                                 } else {
 323                                         /* timed out, go back to init state */
 324                                         if (state == RENEW_REQUESTED) run_script(NULL, "deconfig");
 325                                         state = INIT_SELECTING;
 326                                         timeout = now;
 327                                         packet_num = 0;
 328                                         change_mode(LISTEN_RAW);
 329                                 }
 330                                 break;
 331                         case BOUND:
 332                                 /* Lease is starting to run out, time to enter renewing state */
 333                                 state = RENEWING;
 334                                 change_mode(LISTEN_KERNEL);
 335                                 DEBUG(LOG_INFO, "Entering renew state");
 336                                 /* fall right through */
 337                         case RENEWING:
 338                                 /* Either set a new T1, or enter REBINDING state */
 339                                 if ((t2 - t1) <= (lease / 14400 + 1)) {
 340                                         /* timed out, enter rebinding state */
 341                                         state = REBINDING;
 342                                         timeout = now + (t2 - t1);
 343                                         DEBUG(LOG_INFO, "Entering rebinding state");
 344                                 } else {
 345                                         /* send a request packet */
 346                                         send_renew(xid, server_addr, requested_ip); /* unicast */
 347
 348                                         t1 = (t2 - t1) / 2 + t1;
 349                                         timeout = t1 + start;
 350                                 }
 351                                 break;
 352                         case REBINDING:
 353                                 /* Either set a new T2, or enter INIT state */
 354                                 if ((lease - t2) <= (lease / 14400 + 1)) {
 355                                         /* timed out, enter init state */
 356                                         state = INIT_SELECTING;
 357                                         LOG(LOG_INFO, "Lease lost, entering init state");
 358                                         run_script(NULL, "deconfig");
 359                                         timeout = now;
 360                                         packet_num = 0;
 361                                         change_mode(LISTEN_RAW);
 362                                 } else {
 363                                         /* send a request packet */
 364                                         send_renew(xid, 0, requested_ip); /* broadcast */
 365
 366                                         t2 = (lease - t2) / 2 + t2;
 367                                         timeout = t2 + start;
 368                                 }
 369                                 break;
 370                         case RELEASED:
 371                                 /* yah, I know, *you* say it would never happen */
 372                                 timeout = 0x7fffffff;
 373                                 break;
 374                         }
 375                 } else if (retval > 0 && listen_mode != LISTEN_NONE && FD_ISSET(fd, &rfds)) {
 376                         /* a packet is ready, read it */
 377
 378                         if (listen_mode == LISTEN_KERNEL)
 379                                 len = get_packet(&packet, fd);
 380                         else len = get_raw_packet(&packet, fd);
 381
 382                         if (len == -1 && errno != EINTR) {
 383                                 DEBUG(LOG_INFO, "error on read, %m, reopening socket");
 384                                 change_mode(listen_mode); /* just close and reopen */
 385                         }
 386                         if (len < 0) continue;
 387
 388                         if (packet.xid != xid) {
 389                                 DEBUG(LOG_INFO, "Ignoring XID %lx (our xid is %lx)",
 390                                         (unsigned long) packet.xid, xid);
 391                                 continue;
 392                         }
 393
 394                         if ((message = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) {
 395                                 DEBUG(LOG_ERR, "couldnt get option from packet -- ignoring");
 396                                 continue;
 397                         }
 398
 399                         switch (state) {
 400                         case INIT_SELECTING:
 401                                 /* Must be a DHCPOFFER to one of our xid's */
 402                                 if (*message == DHCPOFFER) {
 403                                         if ((temp = get_option(&packet, DHCP_SERVER_ID))) {
 404                                                 memcpy(&server_addr, temp, 4);
 405                                                 xid = packet.xid;
 406                                                 requested_ip = packet.yiaddr;
 407
 408                                                 /* enter requesting state */
 409                                                 state = REQUESTING;
 410                                                 timeout = now;
 411                                                 packet_num = 0;
 412                                         } else {
 413                                                 DEBUG(LOG_ERR, "No server ID in message");
 414                                         }
 415                                 }
 416                                 break;
 417                         case RENEW_REQUESTED:
 418                         case REQUESTING:
 419                         case RENEWING:
 420                         case REBINDING:
 421                                 if (*message == DHCPACK) {
 422                                         if (!(temp = get_option(&packet, DHCP_LEASE_TIME))) {
 423                                                 LOG(LOG_ERR, "No lease time with ACK, using 1 hour lease");
 424                                                 lease = 60 * 60;
 425                                         } else {
 426                                                 memcpy(&lease, temp, 4);
 427                                                 lease = ntohl(lease);
 428                                         }
 429
 430                                         /* enter bound state */
 431                                         t1 = lease / 2;
 432
 433                                         /* little fixed point for n * .875 */
 434                                         t2 = (lease * 0x7) >> 3;
 435                                         temp_addr.s_addr = packet.yiaddr;
 436                                         LOG(LOG_INFO, "Lease of %s obtained, lease time %ld",
 437                                                 inet_ntoa(temp_addr), lease);
 438                                         start = now;
 439                                         timeout = t1 + start;
 440                                         requested_ip = packet.yiaddr;
 441                                         run_script(&packet,
 442                                                    ((state == RENEWING || state == REBINDING) ? "renew" : "bound"));
 443
 444                                         state = BOUND;
 445                                         change_mode(LISTEN_NONE);
 446                                         if (client_config.quit_after_lease)
 447                                                 return(0);
 448                                         if (!client_config.foreground)
 449                                                 client_background();
 450
 451                                 } else if (*message == DHCPNAK) {
 452                                         /* return to init state */
 453                                         LOG(LOG_INFO, "Received DHCP NAK");
 454                                         run_script(&packet, "nak");
 455                                         if (state != REQUESTING)
 456                                                 run_script(NULL, "deconfig");
 457                                         state = INIT_SELECTING;
 458                                         timeout = now;
 459                                         requested_ip = 0;
 460                                         packet_num = 0;
 461                                         change_mode(LISTEN_RAW);
 462                                         sleep(3); /* avoid excessive network traffic */
 463                                 }
 464                                 break;
 465                         /* case BOUND, RELEASED: - ignore all packets */
 466                         }
 467                 } else if (retval > 0 && FD_ISSET(udhcp_signal_pipe[0], &rfds)) {
 468                         if (read(udhcp_signal_pipe[0], &sig, sizeof(sig)) < 0) {
 469                                 DEBUG(LOG_ERR, "Could not read signal: %m");
 470                                 continue; /* probably just EINTR */
 471                         }
 472                         switch (sig) {
 473                         case SIGUSR1:
 474                                 perform_renew();
 475                                 break;
 476                         case SIGUSR2:
 477                                 perform_release();
 478                                 break;
 479                         case SIGTERM:
 480                                 LOG(LOG_INFO, "Received SIGTERM");
 481                                 return(0);
 482                         }
 483                 } else if (retval == -1 && errno == EINTR) {
 484                         /* a signal was caught */
 485                 } else {
 486                         /* An error occured */
 487                         DEBUG(LOG_ERR, "Error on select");
 488                 }
 489
 490         }
 491         return 0;
 492 }