sbin/dhclient/dispatch.c

   1 /*      $OpenBSD: src/sbin/dhclient/dispatch.c,v 1.42 2008/05/26 03:11:49 deraadt Exp $ */
   2
   3 /*
   4  * Copyright 2004 Henning Brauer <henning@openbsd.org>
   5  * Copyright (c) 1995, 1996, 1997, 1998, 1999
   6  * The Internet Software Consortium.   All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of The Internet Software Consortium nor the names
  18  *    of its contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
  22  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  23  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  25  * DISCLAIMED.  IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
  26  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  29  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  30  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * This software has been written for the Internet Software Consortium
  36  * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
  37  * Enterprises.  To learn more about the Internet Software Consortium,
  38  * see ``http://www.vix.com/isc''.  To learn more about Vixie
  39  * Enterprises, see ``http://www.vix.com''.
  40  */
  41
  42 #include <sys/ioctl.h>
  43
  44 #include <net/if_media.h>
  45
  46 #include <ifaddrs.h>
  47 #include <poll.h>
  48
  49 #include "dhcpd.h"
  50
  51 struct timeout *timeouts;
  52 static struct timeout *free_timeouts;
  53 static int interfaces_invalidated;
  54
  55 /*
  56  * Use getifaddrs() to get a list of all the attached interfaces.  For
  57  * each interface that's of type INET and not the loopback interface,
  58  * register that interface with the network I/O software, figure out
  59  * what subnet it's on, and add it to the list of interfaces.
  60  */
  61 void
  62 discover_interface(void)
  63 {
  64         struct ifaddrs *ifap, *ifa;
  65         struct ifreq *tif;
  66         int len = IFNAMSIZ + sizeof(struct sockaddr_storage);
  67
  68         if (getifaddrs(&ifap) != 0)
  69                 error("getifaddrs failed");
  70
  71         for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
  72                 if ((ifa->ifa_flags & IFF_LOOPBACK) ||
  73                     (ifa->ifa_flags & IFF_POINTOPOINT) ||
  74                     (!(ifa->ifa_flags & IFF_UP)))
  75                         continue;
  76
  77                 if (strcmp(ifi->name, ifa->ifa_name))
  78                         continue;
  79
  80                 /*
  81                  * If we have the capability, extract link information
  82                  * and record it in a linked list.
  83                  */
  84                 if (ifa->ifa_addr->sa_family == AF_LINK) {
  85                         struct sockaddr_dl *foo =
  86                             (struct sockaddr_dl *)ifa->ifa_addr;
  87
  88                         ifi->index = foo->sdl_index;
  89                         ifi->hw_address.hlen = foo->sdl_alen;
  90                         ifi->hw_address.htype = HTYPE_ETHER; /* XXX */
  91                         memcpy(ifi->hw_address.haddr,
  92                             LLADDR(foo), foo->sdl_alen);
  93                 }
  94                 if (!ifi->ifp) {
  95                         if ((tif = malloc(len)) == NULL)
  96                                 error("no space to remember ifp");
  97                         strlcpy(tif->ifr_name, ifa->ifa_name, IFNAMSIZ);
  98                         ifi->ifp = tif;
  99                 }
 100         }
 101
 102         if (!ifi->ifp)
 103                 error("%s: not found", ifi->name);
 104
 105         /* Register the interface... */
 106         if_register_receive();
 107         if_register_send();
 108         freeifaddrs(ifap);
 109 }
 110
 111 void
 112 reinitialize_interface(void)
 113 {
 114         interfaces_invalidated = 1;
 115 }
 116
 117 /*
 118  * Wait for packets to come in using poll().  When a packet comes in, call
 119  * receive_packet to receive the packet and possibly strip hardware addressing
 120  * information from it, and then call do_packet to try to do something with it.
 121  */
 122 void
 123 dispatch(void)
 124 {
 125         int count, to_msec;
 126         struct pollfd fds[2];
 127         time_t howlong;
 128
 129         do {
 130                 /*
 131                  * Call any expired timeouts, and then if there's still
 132                  * a timeout registered, time out the select call then.
 133                  */
 134 another:
 135                 if (!ifi->linkstat)
 136                         interfaces_invalidated = 0;
 137
 138                 if (timeouts) {
 139                         struct timeout *t;
 140
 141                         if (timeouts->when <= cur_time) {
 142                                 t = timeouts;
 143                                 timeouts = timeouts->next;
 144                                 (*(t->func))();
 145                                 t->next = free_timeouts;
 146                                 free_timeouts = t;
 147                                 goto another;
 148                         }
 149
 150                         /*
 151                          * Figure timeout in milliseconds, and check for
 152                          * potential overflow, so we can cram into an
 153                          * int for poll, while not polling with a
 154                          * negative timeout and blocking indefinitely.
 155                          */
 156                         howlong = timeouts->when - cur_time;
 157                         if (howlong > INT_MAX / 1000)
 158                                 howlong = INT_MAX / 1000;
 159                         to_msec = howlong * 1000;
 160                 } else
 161                         to_msec = -1;
 162
 163                 /* Set up the descriptors to be polled. */
 164                 if (!ifi || ifi->rfdesc == -1)
 165                         error("No live interface to poll on");
 166
 167                 fds[0].fd = ifi->rfdesc;
 168                 fds[1].fd = routefd; /* Could be -1, which will be ignored. */
 169                 fds[0].events = fds[1].events = POLLIN;
 170
 171                 /* Wait for a packet or a timeout... XXX */
 172                 count = poll(fds, 2, to_msec);
 173
 174                 /* Get the current time... */
 175                 time(&cur_time);
 176
 177                 /* Not likely to be transitory... */
 178                 if (count == -1) {
 179                         if (errno == EAGAIN || errno == EINTR) {
 180                                 continue;
 181                         } else
 182                                 error("poll: %m");
 183                 }
 184
 185                 if ((fds[0].revents & (POLLIN | POLLHUP))) {
 186                         if (ifi->linkstat &&
 187                             ifi && ifi->rfdesc != -1)
 188                                 got_one();
 189                 }
 190                 if ((fds[1].revents & (POLLIN | POLLHUP))) {
 191                         if (ifi && !interfaces_invalidated)
 192                                 routehandler();
 193                 }
 194
 195                 interfaces_invalidated = 0;
 196         } while (1);
 197 }
 198
 199 void
 200 got_one(void)
 201 {
 202         struct sockaddr_in from;
 203         struct hardware hfrom;
 204         struct iaddr ifrom;
 205         ssize_t result;
 206
 207         if ((result = receive_packet(&from, &hfrom)) == -1) {
 208                 warning("receive_packet failed on %s: %s", ifi->name,
 209                     strerror(errno));
 210                 ifi->errors++;
 211                 if ((!interface_status(ifi->name)) ||
 212                     (ifi->noifmedia && ifi->errors > 20)) {
 213                         /* our interface has gone away. */
 214                         warning("Interface %s no longer appears valid.",
 215                             ifi->name);
 216                         interfaces_invalidated = 1;
 217                         close(ifi->rfdesc);
 218                         ifi->rfdesc = -1;
 219                 }
 220                 return;
 221         }
 222         if (result == 0)
 223                 return;
 224
 225         ifrom.len = 4;
 226         memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len);
 227
 228         do_packet(result, from.sin_port, ifrom, &hfrom);
 229 }
 230
 231 int
 232 interface_link_forceup(char *ifname)
 233 {
 234         struct ifreq ifr;
 235         int sock;
 236
 237         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 238                 error("Can't create socket");
 239
 240         memset(&ifr, 0, sizeof(ifr));
 241         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 242         if (ioctl(sock, SIOCGIFFLAGS, (caddr_t)&ifr) == -1) {
 243                 close(sock);
 244                 return (-1);
 245         }
 246
 247         if ((ifr.ifr_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
 248                 ifr.ifr_flags |= IFF_UP;
 249                 if (ioctl(sock, SIOCSIFFLAGS, (caddr_t)&ifr) == -1) {
 250                         close(sock);
 251                         return (-1);
 252                 }
 253                 close(sock);
 254                 return (0);
 255         }
 256         close(sock);
 257         return (1);
 258 }
 259
 260 void
 261 interface_link_forcedown(char *ifname)
 262 {
 263         struct ifreq ifr;
 264         int sock;
 265
 266         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 267                 error("Can't create socket");
 268
 269         memset(&ifr, 0, sizeof(ifr));
 270         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 271         if (ioctl(sock, SIOCGIFFLAGS, (caddr_t)&ifr) == -1) {
 272                 close(sock);
 273                 return;
 274         }
 275
 276         if ((ifr.ifr_flags & IFF_UP) == IFF_UP) {
 277                 ifr.ifr_flags &= ~IFF_UP;
 278                 if (ioctl(sock, SIOCSIFFLAGS, (caddr_t)&ifr) == -1) {
 279                         close(sock);
 280                         return;
 281                 }
 282         }
 283
 284         close(sock);
 285 }
 286
 287 int
 288 interface_status(char *ifname)
 289 {
 290         struct ifreq ifr;
 291         struct ifmediareq ifmr;
 292         int sock;
 293
 294         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 295                 error("Can't create socket");
 296
 297         /* get interface flags */
 298         memset(&ifr, 0, sizeof(ifr));
 299         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 300         if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
 301                 warning("ioctl(SIOCGIFFLAGS) on %s: %m", ifname);
 302                 goto inactive;
 303         }
 304
 305         /*
 306          * if one of UP and RUNNING flags is dropped,
 307          * the interface is not active.
 308          */
 309         if ((ifr.ifr_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
 310                 goto inactive;
 311
 312         /* Next, check carrier on the interface, if possible */
 313         if (ifi->noifmedia)
 314                 goto active;
 315         memset(&ifmr, 0, sizeof(ifmr));
 316         strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));
 317         if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {
 318                 /*
 319                  * EINVAL or ENOTTY simply means that the interface
 320                  * does not support the SIOCGIFMEDIA ioctl. We regard it alive.
 321                  */
 322                 if (errno != EINVAL && errno != ENOTTY)
 323                         debug("ioctl(SIOCGIFMEDIA) on %s: %m", ifname);
 324
 325                 ifi->noifmedia = 1;
 326                 goto active;
 327         }
 328         if (ifmr.ifm_status & IFM_AVALID) {
 329                 if (ifmr.ifm_status & IFM_ACTIVE)
 330                         goto active;
 331                 else
 332                         goto inactive;
 333         }
 334 inactive:
 335         close(sock);
 336         return (0);
 337 active:
 338         close(sock);
 339         return (1);
 340 }
 341
 342 void
 343 add_timeout(time_t when, void (*where)(void))
 344 {
 345         struct timeout *t, *q;
 346
 347         /* See if this timeout supersedes an existing timeout. */
 348         t = NULL;
 349         for (q = timeouts; q; q = q->next) {
 350                 if (q->func == where) {
 351                         if (t)
 352                                 t->next = q->next;
 353                         else
 354                                 timeouts = q->next;
 355                         break;
 356                 }
 357                 t = q;
 358         }
 359
 360         /* If we didn't supersede a timeout, allocate a timeout
 361            structure now. */
 362         if (!q) {
 363                 if (free_timeouts) {
 364                         q = free_timeouts;
 365                         free_timeouts = q->next;
 366                         q->func = where;
 367                 } else {
 368                         q = malloc(sizeof(struct timeout));
 369                         if (!q)
 370                                 error("Can't allocate timeout structure!");
 371                         q->func = where;
 372                 }
 373         }
 374
 375         q->when = when;
 376
 377         /* Now sort this timeout into the timeout list. */
 378
 379         /* Beginning of list? */
 380         if (!timeouts || timeouts->when > q->when) {
 381                 q->next = timeouts;
 382                 timeouts = q;
 383                 return;
 384         }
 385
 386         /* Middle of list? */
 387         for (t = timeouts; t->next; t = t->next) {
 388                 if (t->next->when > q->when) {
 389                         q->next = t->next;
 390                         t->next = q;
 391                         return;
 392                 }
 393         }
 394
 395         /* End of list. */
 396         t->next = q;
 397         q->next = NULL;
 398 }
 399
 400 void
 401 cancel_timeout(void (*where)(void))
 402 {
 403         struct timeout *t, *q;
 404
 405         /* Look for this timeout on the list, and unlink it if we find it. */
 406         t = NULL;
 407         for (q = timeouts; q; q = q->next) {
 408                 if (q->func == where) {
 409                         if (t)
 410                                 t->next = q->next;
 411                         else
 412                                 timeouts = q->next;
 413                         break;
 414                 }
 415                 t = q;
 416         }
 417
 418         /* If we found the timeout, put it on the free list. */
 419         if (q) {
 420                 q->next = free_timeouts;
 421                 free_timeouts = q;
 422         }
 423 }
 424
 425 int
 426 interface_link_status(char *ifname)
 427 {
 428         struct ifmediareq ifmr;
 429         int sock;
 430
 431         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
 432                 error("Can't create socket");
 433
 434         memset(&ifmr, 0, sizeof(ifmr));
 435         strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));
 436         if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmr) == -1) {
 437                 /* EINVAL/ENOTTY -> link state unknown. treat as active */
 438                 if (errno != EINVAL && errno != ENOTTY)
 439                         debug("ioctl(SIOCGIFMEDIA) on %s: %m", ifname);
 440                 close(sock);
 441                 return (1);
 442         }
 443         close(sock);
 444
 445         if (ifmr.ifm_status & IFM_AVALID) {
 446                 if (ifmr.ifm_status & IFM_ACTIVE)
 447                         return (1);
 448                 else
 449                         return (0);
 450         }
 451         return (1);
 452 }