dhclient - Print out debug messages only when DEBUG is defined.
[dragonfly.git] / sbin / dhclient / dispatch.c
1 /*      $OpenBSD: src/sbin/dhclient/dispatch.c,v 1.44 2009/06/06 04:02:42 krw 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 && ifi->linkstat && ifi->rfdesc != -1)
187                                 got_one();
188                 }
189                 if ((fds[1].revents & (POLLIN | POLLHUP))) {
190                         if (ifi && !interfaces_invalidated)
191                                 routehandler();
192                 }
193
194                 interfaces_invalidated = 0;
195         } while (1);
196 }
197
198 void
199 got_one(void)
200 {
201         struct sockaddr_in from;
202         struct hardware hfrom;
203         struct iaddr ifrom;
204         ssize_t result;
205
206         if ((result = receive_packet(&from, &hfrom)) == -1) {
207                 warning("receive_packet failed on %s: %s", ifi->name,
208                     strerror(errno));
209                 ifi->errors++;
210                 if ((!interface_status(ifi->name)) ||
211                     (ifi->noifmedia && ifi->errors > 20)) {
212                         /* our interface has gone away. */
213                         warning("Interface %s no longer appears valid.",
214                             ifi->name);
215                         interfaces_invalidated = 1;
216                         close(ifi->rfdesc);
217                         ifi->rfdesc = -1;
218                 }
219                 return;
220         }
221         if (result == 0)
222                 return;
223
224         ifrom.len = 4;
225         memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len);
226
227         do_packet(result, from.sin_port, ifrom, &hfrom);
228 }
229
230 int
231 interface_link_forceup(char *ifname)
232 {
233         struct ifreq ifr;
234         int sock;
235
236         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
237                 error("Can't create socket");
238
239         memset(&ifr, 0, sizeof(ifr));
240         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
241         if (ioctl(sock, SIOCGIFFLAGS, (caddr_t)&ifr) == -1) {
242                 close(sock);
243                 return (-1);
244         }
245
246         if ((ifr.ifr_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
247                 ifr.ifr_flags |= IFF_UP;
248                 if (ioctl(sock, SIOCSIFFLAGS, (caddr_t)&ifr) == -1) {
249                         close(sock);
250                         return (-1);
251                 }
252                 close(sock);
253                 return (0);
254         }
255         close(sock);
256         return (1);
257 }
258
259 void
260 interface_link_forcedown(char *ifname)
261 {
262         struct ifreq ifr;
263         int sock;
264
265         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
266                 error("Can't create socket");
267
268         memset(&ifr, 0, sizeof(ifr));
269         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
270         if (ioctl(sock, SIOCGIFFLAGS, (caddr_t)&ifr) == -1) {
271                 close(sock);
272                 return;
273         }
274
275         if ((ifr.ifr_flags & IFF_UP) == IFF_UP) {
276                 ifr.ifr_flags &= ~IFF_UP;
277                 if (ioctl(sock, SIOCSIFFLAGS, (caddr_t)&ifr) == -1) {
278                         close(sock);
279                         return;
280                 }
281         }
282
283         close(sock);
284 }
285
286 int
287 interface_status(char *ifname)
288 {
289         struct ifreq ifr;
290         struct ifmediareq ifmr;
291         int sock;
292
293         if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
294                 error("Can't create socket");
295
296         /* get interface flags */
297         memset(&ifr, 0, sizeof(ifr));
298         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
299         if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
300                 warning("ioctl(SIOCGIFFLAGS) on %s: %m", ifname);
301                 goto inactive;
302         }
303
304         /*
305          * if one of UP and RUNNING flags is dropped,
306          * the interface is not active.
307          */
308         if ((ifr.ifr_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
309                 goto inactive;
310
311         /* Next, check carrier on the interface, if possible */
312         if (ifi->noifmedia)
313                 goto active;
314         memset(&ifmr, 0, sizeof(ifmr));
315         strlcpy(ifmr.ifm_name, ifname, sizeof(ifmr.ifm_name));
316         if (ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmr) < 0) {
317                 /*
318                  * EINVAL or ENOTTY simply means that the interface
319                  * does not support the SIOCGIFMEDIA ioctl. We regard it alive.
320                  */
321 #ifdef DEBUG
322                 if (errno != EINVAL && errno != ENOTTY)
323                         debug("ioctl(SIOCGIFMEDIA) on %s: %m", ifname);
324 #endif
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 #ifdef DEBUG
439                 if (errno != EINVAL && errno != ENOTTY)
440                         debug("ioctl(SIOCGIFMEDIA) on %s: %m", ifname);
441 #endif
442                 close(sock);
443                 return (1);
444         }
445         close(sock);
446
447         if (ifmr.ifm_status & IFM_AVALID) {
448                 if (ifmr.ifm_status & IFM_ACTIVE)
449                         return (1);
450                 else
451                         return (0);
452         }
453         return (1);
454 }