networking/udhcp/dhcpd.c

   1 /* vi: set sw=4 ts=4: */
   2 /* dhcpd.c
   3  *
   4  * udhcp Server
   5  * Copyright (C) 1999 Matthew Ramsay <matthewr@moreton.com.au>
   6  *                      Chris Trew <ctrew@moreton.com.au>
   7  *
   8  * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
   9  *
  10  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  11  */
  12
  13 #include <syslog.h>
  14 #include "common.h"
  15 #include "dhcpc.h"
  16 #include "dhcpd.h"
  17 #include "options.h"
  18
  19
  20 /* globals */
  21 struct dhcpOfferedAddr *leases;
  22 /* struct server_config_t server_config is in bb_common_bufsiz1 */
  23
  24
  25 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  26 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
  27 {
  28         fd_set rfds;
  29         int server_socket = -1, retval, max_sock;
  30         struct dhcpMessage packet;
  31         uint8_t *state, *server_id, *requested;
  32         uint32_t server_id_aligned = server_id_aligned; /* for compiler */
  33         uint32_t requested_aligned = requested_aligned;
  34         uint32_t static_lease_ip;
  35         unsigned timeout_end;
  36         unsigned num_ips;
  37         unsigned opt;
  38         struct option_set *option;
  39         struct dhcpOfferedAddr *lease, static_lease;
  40         IF_FEATURE_UDHCP_PORT(char *str_P;)
  41
  42 #if ENABLE_FEATURE_UDHCP_PORT
  43         SERVER_PORT = 67;
  44         CLIENT_PORT = 68;
  45 #endif
  46
  47         opt = getopt32(argv, "fS" IF_FEATURE_UDHCP_PORT("P:", &str_P));
  48         argv += optind;
  49         if (!(opt & 1)) { /* no -f */
  50                 bb_daemonize_or_rexec(0, argv);
  51                 logmode = LOGMODE_NONE;
  52         }
  53         if (opt & 2) { /* -S */
  54                 openlog(applet_name, LOG_PID, LOG_DAEMON);
  55                 logmode |= LOGMODE_SYSLOG;
  56         }
  57 #if ENABLE_FEATURE_UDHCP_PORT
  58         if (opt & 4) { /* -P */
  59                 SERVER_PORT = xatou16(str_P);
  60                 CLIENT_PORT = SERVER_PORT + 1;
  61         }
  62 #endif
  63         /* Would rather not do read_config before daemonization -
  64          * otherwise NOMMU machines will parse config twice */
  65         read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
  66
  67         /* Make sure fd 0,1,2 are open */
  68         bb_sanitize_stdio();
  69         /* Equivalent of doing a fflush after every \n */
  70         setlinebuf(stdout);
  71
  72         /* Create pidfile */
  73         write_pidfile(server_config.pidfile);
  74         /* if (!..) bb_perror_msg("cannot create pidfile %s", pidfile); */
  75
  76         bb_info_msg("%s (v"BB_VER") started", applet_name);
  77
  78         option = find_option(server_config.options, DHCP_LEASE_TIME);
  79         server_config.lease = LEASE_TIME;
  80         if (option) {
  81                 move_from_unaligned32(server_config.lease, option->data + 2);
  82                 server_config.lease = ntohl(server_config.lease);
  83         }
  84
  85         /* Sanity check */
  86         num_ips = server_config.end_ip - server_config.start_ip + 1;
  87         if (server_config.max_leases > num_ips) {
  88                 bb_error_msg("max_leases=%u is too big, setting to %u",
  89                         (unsigned)server_config.max_leases, num_ips);
  90                 server_config.max_leases = num_ips;
  91         }
  92
  93         leases = xzalloc(server_config.max_leases * sizeof(*leases));
  94         read_leases(server_config.lease_file);
  95
  96         if (udhcp_read_interface(server_config.interface,
  97                         &server_config.ifindex,
  98                         &server_config.server_nip,
  99                         server_config.server_mac)
 100         ) {
 101                 retval = 1;
 102                 goto ret;
 103         }
 104
 105         /* Setup the signal pipe */
 106         udhcp_sp_setup();
 107
 108         timeout_end = monotonic_sec() + server_config.auto_time;
 109         while (1) { /* loop until universe collapses */
 110                 int bytes;
 111                 struct timeval tv;
 112
 113                 if (server_socket < 0) {
 114                         server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
 115                                         server_config.interface);
 116                 }
 117
 118                 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
 119                 if (server_config.auto_time) {
 120                         tv.tv_sec = timeout_end - monotonic_sec();
 121                         tv.tv_usec = 0;
 122                 }
 123                 retval = 0;
 124                 if (!server_config.auto_time || tv.tv_sec > 0) {
 125                         retval = select(max_sock + 1, &rfds, NULL, NULL,
 126                                         server_config.auto_time ? &tv : NULL);
 127                 }
 128                 if (retval == 0) {
 129                         write_leases();
 130                         timeout_end = monotonic_sec() + server_config.auto_time;
 131                         continue;
 132                 }
 133                 if (retval < 0 && errno != EINTR) {
 134                         DEBUG("error on select");
 135                         continue;
 136                 }
 137
 138                 switch (udhcp_sp_read(&rfds)) {
 139                 case SIGUSR1:
 140                         bb_info_msg("Received a SIGUSR1");
 141                         write_leases();
 142                         /* why not just reset the timeout, eh */
 143                         timeout_end = monotonic_sec() + server_config.auto_time;
 144                         continue;
 145                 case SIGTERM:
 146                         bb_info_msg("Received a SIGTERM");
 147                         goto ret0;
 148                 case 0: /* no signal: read a packet */
 149                         break;
 150                 default: /* signal or error (probably EINTR): back to select */
 151                         continue;
 152                 }
 153
 154                 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
 155                 if (bytes < 0) {
 156                         /* bytes can also be -2 ("bad packet data") */
 157                         if (bytes == -1 && errno != EINTR) {
 158                                 DEBUG("error on read, %s, reopening socket", strerror(errno));
 159                                 close(server_socket);
 160                                 server_socket = -1;
 161                         }
 162                         continue;
 163                 }
 164
 165                 state = get_option(&packet, DHCP_MESSAGE_TYPE);
 166                 if (state == NULL) {
 167                         bb_error_msg("cannot get option from packet, ignoring");
 168                         continue;
 169                 }
 170
 171                 /* Look for a static lease */
 172                 static_lease_ip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
 173                 if (static_lease_ip) {
 174                         bb_info_msg("Found static lease: %x", static_lease_ip);
 175
 176                         memcpy(&static_lease.lease_mac16, &packet.chaddr, 16);
 177                         static_lease.lease_nip = static_lease_ip;
 178                         static_lease.expires = 0;
 179
 180                         lease = &static_lease;
 181                 } else {
 182                         lease = find_lease_by_chaddr(packet.chaddr);
 183                 }
 184
 185                 switch (state[0]) {
 186                 case DHCPDISCOVER:
 187                         DEBUG("Received DISCOVER");
 188
 189                         if (send_offer(&packet) < 0) {
 190                                 bb_error_msg("send OFFER failed");
 191                         }
 192                         break;
 193                 case DHCPREQUEST:
 194                         DEBUG("received REQUEST");
 195
 196                         requested = get_option(&packet, DHCP_REQUESTED_IP);
 197                         server_id = get_option(&packet, DHCP_SERVER_ID);
 198
 199                         if (requested)
 200                                 move_from_unaligned32(requested_aligned, requested);
 201                         if (server_id)
 202                                 move_from_unaligned32(server_id_aligned, server_id);
 203
 204                         if (lease) {
 205                                 if (server_id) {
 206                                         /* SELECTING State */
 207                                         DEBUG("server_id = %08x", ntohl(server_id_aligned));
 208                                         if (server_id_aligned == server_config.server_nip
 209                                          && requested
 210                                          && requested_aligned == lease->lease_nip
 211                                         ) {
 212                                                 send_ACK(&packet, lease->lease_nip);
 213                                         }
 214                                 } else if (requested) {
 215                                         /* INIT-REBOOT State */
 216                                         if (lease->lease_nip == requested_aligned)
 217                                                 send_ACK(&packet, lease->lease_nip);
 218                                         else
 219                                                 send_NAK(&packet);
 220                                 } else if (lease->lease_nip == packet.ciaddr) {
 221                                         /* RENEWING or REBINDING State */
 222                                         send_ACK(&packet, lease->lease_nip);
 223                                 } else { /* don't know what to do!!!! */
 224                                         send_NAK(&packet);
 225                                 }
 226
 227                         /* what to do if we have no record of the client */
 228                         } else if (server_id) {
 229                                 /* SELECTING State */
 230
 231                         } else if (requested) {
 232                                 /* INIT-REBOOT State */
 233                                 lease = find_lease_by_yiaddr(requested_aligned);
 234                                 if (lease) {
 235                                         if (lease_expired(lease)) {
 236                                                 /* probably best if we drop this lease */
 237                                                 memset(lease->lease_mac16, 0, 16);
 238                                         } else {
 239                                                 /* make some contention for this address */
 240                                                 send_NAK(&packet);
 241                                         }
 242                                 } else {
 243                                         uint32_t r = ntohl(requested_aligned);
 244                                         if (r < server_config.start_ip
 245                                          || r > server_config.end_ip
 246                                         ) {
 247                                                 send_NAK(&packet);
 248                                         }
 249                                         /* else remain silent */
 250                                 }
 251
 252                         } else {
 253                                 /* RENEWING or REBINDING State */
 254                         }
 255                         break;
 256                 case DHCPDECLINE:
 257                         DEBUG("Received DECLINE");
 258                         if (lease) {
 259                                 memset(lease->lease_mac16, 0, 16);
 260                                 lease->expires = time(NULL) + server_config.decline_time;
 261                         }
 262                         break;
 263                 case DHCPRELEASE:
 264                         DEBUG("Received RELEASE");
 265                         if (lease)
 266                                 lease->expires = time(NULL);
 267                         break;
 268                 case DHCPINFORM:
 269                         DEBUG("Received INFORM");
 270                         send_inform(&packet);
 271                         break;
 272                 default:
 273                         bb_info_msg("Unsupported DHCP message (%02x) - ignoring", state[0]);
 274                 }
 275         }
 276  ret0:
 277         retval = 0;
 278  ret:
 279         /*if (server_config.pidfile) - server_config.pidfile is never NULL */
 280                 remove_pidfile(server_config.pidfile);
 281         return retval;
 282 }