Annotation of embedaddon/dnsmasq/src/lease.c, revision 1.1.1.1
1.1 misho 1: /* dnsmasq is Copyright (c) 2000-2013 Simon Kelley
2:
3: This program is free software; you can redistribute it and/or modify
4: it under the terms of the GNU General Public License as published by
5: the Free Software Foundation; version 2 dated June, 1991, or
6: (at your option) version 3 dated 29 June, 2007.
7:
8: This program is distributed in the hope that it will be useful,
9: but WITHOUT ANY WARRANTY; without even the implied warranty of
10: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11: GNU General Public License for more details.
12:
13: You should have received a copy of the GNU General Public License
14: along with this program. If not, see <http://www.gnu.org/licenses/>.
15: */
16:
17: #include "dnsmasq.h"
18:
19: #ifdef HAVE_DHCP
20:
21: static struct dhcp_lease *leases = NULL, *old_leases = NULL;
22: static int dns_dirty, file_dirty, leases_left;
23:
24: void lease_init(time_t now)
25: {
26: unsigned long ei;
27: struct all_addr addr;
28: struct dhcp_lease *lease;
29: int clid_len, hw_len, hw_type;
30: FILE *leasestream;
31:
32: leases_left = daemon->dhcp_max;
33:
34: if (option_bool(OPT_LEASE_RO))
35: {
36: /* run "<lease_change_script> init" once to get the
37: initial state of the database. If leasefile-ro is
38: set without a script, we just do without any
39: lease database. */
40: #ifdef HAVE_SCRIPT
41: if (daemon->lease_change_command)
42: {
43: strcpy(daemon->dhcp_buff, daemon->lease_change_command);
44: strcat(daemon->dhcp_buff, " init");
45: leasestream = popen(daemon->dhcp_buff, "r");
46: }
47: else
48: #endif
49: {
50: file_dirty = dns_dirty = 0;
51: return;
52: }
53:
54: }
55: else
56: {
57: /* NOTE: need a+ mode to create file if it doesn't exist */
58: leasestream = daemon->lease_stream = fopen(daemon->lease_file, "a+");
59:
60: if (!leasestream)
61: die(_("cannot open or create lease file %s: %s"), daemon->lease_file, EC_FILE);
62:
63: /* a+ mode leaves pointer at end. */
64: rewind(leasestream);
65: }
66:
67: /* client-id max length is 255 which is 255*2 digits + 254 colons
68: borrow DNS packet buffer which is always larger than 1000 bytes */
69: if (leasestream)
70: while (fscanf(leasestream, "%255s %255s", daemon->dhcp_buff3, daemon->dhcp_buff2) == 2)
71: {
72: #ifdef HAVE_DHCP6
73: if (strcmp(daemon->dhcp_buff3, "duid") == 0)
74: {
75: daemon->duid_len = parse_hex(daemon->dhcp_buff2, (unsigned char *)daemon->dhcp_buff2, 130, NULL, NULL);
76: daemon->duid = safe_malloc(daemon->duid_len);
77: memcpy(daemon->duid, daemon->dhcp_buff2, daemon->duid_len);
78: continue;
79: }
80: #endif
81:
82: ei = atol(daemon->dhcp_buff3);
83:
84: if (fscanf(leasestream, " %64s %255s %764s",
85: daemon->namebuff, daemon->dhcp_buff, daemon->packet) != 3)
86: break;
87:
88: clid_len = 0;
89: if (strcmp(daemon->packet, "*") != 0)
90: clid_len = parse_hex(daemon->packet, (unsigned char *)daemon->packet, 255, NULL, NULL);
91:
92: if (inet_pton(AF_INET, daemon->namebuff, &addr.addr.addr4) &&
93: (lease = lease4_allocate(addr.addr.addr4)))
94: {
95: hw_len = parse_hex(daemon->dhcp_buff2, (unsigned char *)daemon->dhcp_buff2, DHCP_CHADDR_MAX, NULL, &hw_type);
96: /* For backwards compatibility, no explict MAC address type means ether. */
97: if (hw_type == 0 && hw_len != 0)
98: hw_type = ARPHRD_ETHER;
99:
100: lease_set_hwaddr(lease, (unsigned char *)daemon->dhcp_buff2, (unsigned char *)daemon->packet,
101: hw_len, hw_type, clid_len, now, 0);
102:
103: if (strcmp(daemon->dhcp_buff, "*") != 0)
104: lease_set_hostname(lease, daemon->dhcp_buff, 0, get_domain(lease->addr), NULL);
105: }
106: #ifdef HAVE_DHCP6
107: else if (inet_pton(AF_INET6, daemon->namebuff, &addr.addr.addr6))
108: {
109: char *s = daemon->dhcp_buff2;
110: int lease_type = LEASE_NA;
111:
112: if (s[0] == 'T')
113: {
114: lease_type = LEASE_TA;
115: s++;
116: }
117:
118: hw_type = strtoul(s, NULL, 10);
119:
120: if ((lease = lease6_allocate(&addr.addr.addr6, lease_type)))
121: {
122: lease_set_hwaddr(lease, NULL, (unsigned char *)daemon->packet, 0, hw_type, clid_len, now, 0);
123:
124: if (strcmp(daemon->dhcp_buff, "*") != 0)
125: lease_set_hostname(lease, daemon->dhcp_buff, 0, get_domain6((struct in6_addr *)lease->hwaddr), NULL);
126: }
127: }
128: #endif
129: else
130: break;
131:
132: if (!lease)
133: die (_("too many stored leases"), NULL, EC_MISC);
134:
135: #ifdef HAVE_BROKEN_RTC
136: if (ei != 0)
137: lease->expires = (time_t)ei + now;
138: else
139: lease->expires = (time_t)0;
140: lease->length = ei;
141: #else
142: /* strictly time_t is opaque, but this hack should work on all sane systems,
143: even when sizeof(time_t) == 8 */
144: lease->expires = (time_t)ei;
145: #endif
146:
147: /* set these correctly: the "old" events are generated later from
148: the startup synthesised SIGHUP. */
149: lease->flags &= ~(LEASE_NEW | LEASE_CHANGED);
150: }
151:
152: #ifdef HAVE_SCRIPT
153: if (!daemon->lease_stream)
154: {
155: int rc = 0;
156:
157: /* shell returns 127 for "command not found", 126 for bad permissions. */
158: if (!leasestream || (rc = pclose(leasestream)) == -1 || WEXITSTATUS(rc) == 127 || WEXITSTATUS(rc) == 126)
159: {
160: if (WEXITSTATUS(rc) == 127)
161: errno = ENOENT;
162: else if (WEXITSTATUS(rc) == 126)
163: errno = EACCES;
164: die(_("cannot run lease-init script %s: %s"), daemon->lease_change_command, EC_FILE);
165: }
166:
167: if (WEXITSTATUS(rc) != 0)
168: {
169: sprintf(daemon->dhcp_buff, "%d", WEXITSTATUS(rc));
170: die(_("lease-init script returned exit code %s"), daemon->dhcp_buff, WEXITSTATUS(rc) + EC_INIT_OFFSET);
171: }
172: }
173: #endif
174:
175: /* Some leases may have expired */
176: file_dirty = 0;
177: lease_prune(NULL, now);
178: dns_dirty = 1;
179: }
180:
181: void lease_update_from_configs(void)
182: {
183: /* changes to the config may change current leases. */
184:
185: struct dhcp_lease *lease;
186: struct dhcp_config *config;
187: char *name;
188:
189: for (lease = leases; lease; lease = lease->next)
190: if ((config = find_config(daemon->dhcp_conf, NULL, lease->clid, lease->clid_len,
191: lease->hwaddr, lease->hwaddr_len, lease->hwaddr_type, NULL)) &&
192: (config->flags & CONFIG_NAME) &&
193: (!(config->flags & CONFIG_ADDR) || config->addr.s_addr == lease->addr.s_addr))
194: lease_set_hostname(lease, config->hostname, 1, get_domain(lease->addr), NULL);
195: else if ((name = host_from_dns(lease->addr)))
196: lease_set_hostname(lease, name, 1, get_domain(lease->addr), NULL); /* updates auth flag only */
197: }
198:
199: static void ourprintf(int *errp, char *format, ...)
200: {
201: va_list ap;
202:
203: va_start(ap, format);
204: if (!(*errp) && vfprintf(daemon->lease_stream, format, ap) < 0)
205: *errp = errno;
206: va_end(ap);
207: }
208:
209: void lease_update_file(time_t now)
210: {
211: struct dhcp_lease *lease;
212: time_t next_event;
213: int i, err = 0;
214:
215: if (file_dirty != 0 && daemon->lease_stream)
216: {
217: errno = 0;
218: rewind(daemon->lease_stream);
219: if (errno != 0 || ftruncate(fileno(daemon->lease_stream), 0) != 0)
220: err = errno;
221:
222: for (lease = leases; lease; lease = lease->next)
223: {
224:
225: #ifdef HAVE_DHCP6
226: if (lease->flags & (LEASE_TA | LEASE_NA))
227: continue;
228: #endif
229:
230: #ifdef HAVE_BROKEN_RTC
231: ourprintf(&err, "%u ", lease->length);
232: #else
233: ourprintf(&err, "%lu ", (unsigned long)lease->expires);
234: #endif
235:
236: if (lease->hwaddr_type != ARPHRD_ETHER || lease->hwaddr_len == 0)
237: ourprintf(&err, "%.2x-", lease->hwaddr_type);
238: for (i = 0; i < lease->hwaddr_len; i++)
239: {
240: ourprintf(&err, "%.2x", lease->hwaddr[i]);
241: if (i != lease->hwaddr_len - 1)
242: ourprintf(&err, ":");
243: }
244:
245: inet_ntop(AF_INET, &lease->addr, daemon->addrbuff, ADDRSTRLEN);
246:
247: ourprintf(&err, " %s ", daemon->addrbuff);
248: ourprintf(&err, "%s ", lease->hostname ? lease->hostname : "*");
249:
250: if (lease->clid && lease->clid_len != 0)
251: {
252: for (i = 0; i < lease->clid_len - 1; i++)
253: ourprintf(&err, "%.2x:", lease->clid[i]);
254: ourprintf(&err, "%.2x\n", lease->clid[i]);
255: }
256: else
257: ourprintf(&err, "*\n");
258: }
259:
260: #ifdef HAVE_DHCP6
261: if (daemon->duid)
262: {
263: ourprintf(&err, "duid ");
264: for (i = 0; i < daemon->duid_len - 1; i++)
265: ourprintf(&err, "%.2x:", daemon->duid[i]);
266: ourprintf(&err, "%.2x\n", daemon->duid[i]);
267:
268: for (lease = leases; lease; lease = lease->next)
269: {
270:
271: if (!(lease->flags & (LEASE_TA | LEASE_NA)))
272: continue;
273:
274: #ifdef HAVE_BROKEN_RTC
275: ourprintf(&err, "%u ", lease->length);
276: #else
277: ourprintf(&err, "%lu ", (unsigned long)lease->expires);
278: #endif
279:
280: inet_ntop(AF_INET6, lease->hwaddr, daemon->addrbuff, ADDRSTRLEN);
281:
282: ourprintf(&err, "%s%u %s ", (lease->flags & LEASE_TA) ? "T" : "",
283: lease->hwaddr_type, daemon->addrbuff);
284: ourprintf(&err, "%s ", lease->hostname ? lease->hostname : "*");
285:
286: if (lease->clid && lease->clid_len != 0)
287: {
288: for (i = 0; i < lease->clid_len - 1; i++)
289: ourprintf(&err, "%.2x:", lease->clid[i]);
290: ourprintf(&err, "%.2x\n", lease->clid[i]);
291: }
292: else
293: ourprintf(&err, "*\n");
294: }
295: }
296: #endif
297:
298: if (fflush(daemon->lease_stream) != 0 ||
299: fsync(fileno(daemon->lease_stream)) < 0)
300: err = errno;
301:
302: if (!err)
303: file_dirty = 0;
304: }
305:
306: /* Set alarm for when the first lease expires + slop. */
307: next_event = 0;
308:
309: #ifdef HAVE_DHCP6
310: /* do timed RAs and determine when the next is, also pings to potential SLAAC addresses */
311: if (daemon->doing_ra)
312: {
313: time_t event;
314:
315: if ((event = periodic_slaac(now, leases)) != 0)
316: {
317: if (next_event == 0 || difftime(next_event, event) > 0.0)
318: next_event = event;
319: }
320:
321: if ((event = periodic_ra(now)) != 0)
322: {
323: if (next_event == 0 || difftime(next_event, event) > 0.0)
324: next_event = event;
325: }
326: }
327: #endif
328:
329: for (lease = leases; lease; lease = lease->next)
330: if (lease->expires != 0 &&
331: (next_event == 0 || difftime(next_event, lease->expires + 10) > 0.0))
332: next_event = lease->expires + 10;
333:
334: if (err)
335: {
336: if (next_event == 0 || difftime(next_event, LEASE_RETRY + now) > 0.0)
337: next_event = LEASE_RETRY + now;
338:
339: my_syslog(MS_DHCP | LOG_ERR, _("failed to write %s: %s (retry in %us)"),
340: daemon->lease_file, strerror(err),
341: (unsigned int)difftime(next_event, now));
342: }
343:
344: send_alarm(next_event, now);
345: }
346:
347:
348: static int find_interface_v4(struct in_addr local, int if_index,
349: struct in_addr netmask, struct in_addr broadcast, void *vparam)
350: {
351: struct dhcp_lease *lease;
352:
353: (void) broadcast;
354: (void) vparam;
355:
356: for (lease = leases; lease; lease = lease->next)
357: if (!(lease->flags & (LEASE_TA | LEASE_NA)))
358: if (is_same_net(local, lease->addr, netmask))
359: lease_set_interface(lease, if_index, *((time_t *)vparam));
360:
361: return 1;
362: }
363:
364: #ifdef HAVE_DHCP6
365: static int find_interface_v6(struct in6_addr *local, int prefix,
366: int scope, int if_index, int flags,
367: int preferred, int valid, void *vparam)
368: {
369: struct dhcp_lease *lease;
370:
371: (void)scope;
372: (void)flags;
373: (void)preferred;
374: (void)valid;
375:
376: for (lease = leases; lease; lease = lease->next)
377: if ((lease->flags & (LEASE_TA | LEASE_NA)))
378: if (is_same_net6(local, (struct in6_addr *)&lease->hwaddr, prefix))
379: lease_set_interface(lease, if_index, *((time_t *)vparam));
380:
381: return 1;
382: }
383:
384: void lease_ping_reply(struct in6_addr *sender, unsigned char *packet, char *interface)
385: {
386: /* We may be doing RA but not DHCPv4, in which case the lease
387: database may not exist and we have nothing to do anyway */
388: if (daemon->dhcp)
389: slaac_ping_reply(sender, packet, interface, leases);
390: }
391:
392: void lease_update_slaac(time_t now)
393: {
394: /* Called when we contruct a new RA-names context, to add putative
395: new SLAAC addresses to existing leases. */
396:
397: struct dhcp_lease *lease;
398:
399: if (daemon->dhcp)
400: for (lease = leases; lease; lease = lease->next)
401: slaac_add_addrs(lease, now, 0);
402: }
403:
404: #endif
405:
406:
407: /* Find interfaces associated with leases at start-up. This gets updated as
408: we do DHCP transactions, but information about directly-connected subnets
409: is useful from scrips and necessary for determining SLAAC addresses from
410: start-time. */
411: void lease_find_interfaces(time_t now)
412: {
413: iface_enumerate(AF_INET, &now, find_interface_v4);
414: #ifdef HAVE_DHCP6
415: iface_enumerate(AF_INET6, &now, find_interface_v6);
416:
417: /* If we're not doing DHCPv6, and there are not v6 leases, don't add the DUID to the database */
418: if (!daemon->duid && daemon->dhcp6)
419: {
420: file_dirty = 1;
421: make_duid(now);
422: }
423: #endif
424: }
425:
426:
427:
428: void lease_update_dns(int force)
429: {
430: struct dhcp_lease *lease;
431:
432: if (daemon->port != 0 && (dns_dirty || force))
433: {
434: #ifndef HAVE_BROKEN_RTC
435: /* force transfer to authoritative secondaries */
436: daemon->soa_sn++;
437: #endif
438:
439: cache_unhash_dhcp();
440:
441: for (lease = leases; lease; lease = lease->next)
442: {
443: int prot = AF_INET;
444:
445: #ifdef HAVE_DHCP6
446: if (lease->flags & (LEASE_TA | LEASE_NA))
447: prot = AF_INET6;
448: else if (lease->hostname || lease->fqdn)
449: {
450: struct slaac_address *slaac;
451:
452: for (slaac = lease->slaac_address; slaac; slaac = slaac->next)
453: if (slaac->backoff == 0)
454: {
455: if (lease->fqdn)
456: cache_add_dhcp_entry(lease->fqdn, AF_INET6, (struct all_addr *)&slaac->addr, lease->expires);
457: if (!option_bool(OPT_DHCP_FQDN) && lease->hostname)
458: cache_add_dhcp_entry(lease->hostname, AF_INET6, (struct all_addr *)&slaac->addr, lease->expires);
459: }
460: }
461: #endif
462:
463: if (lease->fqdn)
464: cache_add_dhcp_entry(lease->fqdn, prot,
465: prot == AF_INET ? (struct all_addr *)&lease->addr : (struct all_addr *)&lease->hwaddr,
466: lease->expires);
467:
468: if (!option_bool(OPT_DHCP_FQDN) && lease->hostname)
469: cache_add_dhcp_entry(lease->hostname, prot,
470: prot == AF_INET ? (struct all_addr *)&lease->addr : (struct all_addr *)&lease->hwaddr,
471: lease->expires);
472: }
473:
474: dns_dirty = 0;
475: }
476: }
477:
478: void lease_prune(struct dhcp_lease *target, time_t now)
479: {
480: struct dhcp_lease *lease, *tmp, **up;
481:
482: for (lease = leases, up = &leases; lease; lease = tmp)
483: {
484: tmp = lease->next;
485: if ((lease->expires != 0 && difftime(now, lease->expires) > 0) || lease == target)
486: {
487: file_dirty = 1;
488: if (lease->hostname)
489: dns_dirty = 1;
490:
491: *up = lease->next; /* unlink */
492:
493: /* Put on old_leases list 'till we
494: can run the script */
495: lease->next = old_leases;
496: old_leases = lease;
497:
498: leases_left++;
499: }
500: else
501: up = &lease->next;
502: }
503: }
504:
505:
506: struct dhcp_lease *lease_find_by_client(unsigned char *hwaddr, int hw_len, int hw_type,
507: unsigned char *clid, int clid_len)
508: {
509: struct dhcp_lease *lease;
510:
511: if (clid)
512: for (lease = leases; lease; lease = lease->next)
513: {
514: #ifdef HAVE_DHCP6
515: if (lease->flags & (LEASE_TA | LEASE_NA))
516: continue;
517: #endif
518: if (lease->clid && clid_len == lease->clid_len &&
519: memcmp(clid, lease->clid, clid_len) == 0)
520: return lease;
521: }
522:
523: for (lease = leases; lease; lease = lease->next)
524: {
525: #ifdef HAVE_DHCP6
526: if (lease->flags & (LEASE_TA | LEASE_NA))
527: continue;
528: #endif
529: if ((!lease->clid || !clid) &&
530: hw_len != 0 &&
531: lease->hwaddr_len == hw_len &&
532: lease->hwaddr_type == hw_type &&
533: memcmp(hwaddr, lease->hwaddr, hw_len) == 0)
534: return lease;
535: }
536:
537: return NULL;
538: }
539:
540: struct dhcp_lease *lease_find_by_addr(struct in_addr addr)
541: {
542: struct dhcp_lease *lease;
543:
544: for (lease = leases; lease; lease = lease->next)
545: {
546: #ifdef HAVE_DHCP6
547: if (lease->flags & (LEASE_TA | LEASE_NA))
548: continue;
549: #endif
550: if (lease->addr.s_addr == addr.s_addr)
551: return lease;
552: }
553:
554: return NULL;
555: }
556:
557: #ifdef HAVE_DHCP6
558: /* find address for {CLID, IAID, address} */
559: struct dhcp_lease *lease6_find(unsigned char *clid, int clid_len,
560: int lease_type, int iaid, struct in6_addr *addr)
561: {
562: struct dhcp_lease *lease;
563:
564: for (lease = leases; lease; lease = lease->next)
565: {
566: if (!(lease->flags & lease_type) || lease->hwaddr_type != iaid)
567: continue;
568:
569: if (memcmp(lease->hwaddr, addr, IN6ADDRSZ) != 0)
570: continue;
571:
572: if ((clid_len != lease->clid_len ||
573: memcmp(clid, lease->clid, clid_len) != 0))
574: continue;
575:
576: return lease;
577: }
578:
579: return NULL;
580: }
581:
582: /* reset "USED flags */
583: void lease6_reset(void)
584: {
585: struct dhcp_lease *lease;
586:
587: for (lease = leases; lease; lease = lease->next)
588: lease->flags &= ~LEASE_USED;
589: }
590:
591: /* enumerate all leases belonging to {CLID, IAID} */
592: struct dhcp_lease *lease6_find_by_client(struct dhcp_lease *first, int lease_type, unsigned char *clid, int clid_len, int iaid)
593: {
594: struct dhcp_lease *lease;
595:
596: if (!first)
597: first = leases;
598: else
599: first = first->next;
600:
601: for (lease = first; lease; lease = lease->next)
602: {
603: if (lease->flags & LEASE_USED)
604: continue;
605:
606: if (!(lease->flags & lease_type) || lease->hwaddr_type != iaid)
607: continue;
608:
609: if ((clid_len != lease->clid_len ||
610: memcmp(clid, lease->clid, clid_len) != 0))
611: continue;
612:
613: return lease;
614: }
615:
616: return NULL;
617: }
618:
619: struct dhcp_lease *lease6_find_by_addr(struct in6_addr *net, int prefix, u64 addr)
620: {
621: struct dhcp_lease *lease;
622:
623: for (lease = leases; lease; lease = lease->next)
624: {
625: if (!(lease->flags & (LEASE_TA | LEASE_NA)))
626: continue;
627:
628: if (is_same_net6((struct in6_addr *)lease->hwaddr, net, prefix) &&
629: (prefix == 128 || addr6part((struct in6_addr *)lease->hwaddr) == addr))
630: return lease;
631: }
632:
633: return NULL;
634: }
635:
636: /* Find largest assigned address in context */
637: u64 lease_find_max_addr6(struct dhcp_context *context)
638: {
639: struct dhcp_lease *lease;
640: u64 addr = addr6part(&context->start6);
641:
642: if (!(context->flags & (CONTEXT_STATIC | CONTEXT_PROXY)))
643: for (lease = leases; lease; lease = lease->next)
644: {
645: if (!(lease->flags & (LEASE_TA | LEASE_NA)))
646: continue;
647:
648: if (is_same_net6((struct in6_addr *)lease->hwaddr, &context->start6, 64) &&
649: addr6part((struct in6_addr *)lease->hwaddr) > addr6part(&context->start6) &&
650: addr6part((struct in6_addr *)lease->hwaddr) <= addr6part(&context->end6) &&
651: addr6part((struct in6_addr *)lease->hwaddr) > addr)
652: addr = addr6part((struct in6_addr *)lease->hwaddr);
653: }
654:
655: return addr;
656: }
657:
658: #endif
659:
660: /* Find largest assigned address in context */
661: struct in_addr lease_find_max_addr(struct dhcp_context *context)
662: {
663: struct dhcp_lease *lease;
664: struct in_addr addr = context->start;
665:
666: if (!(context->flags & (CONTEXT_STATIC | CONTEXT_PROXY)))
667: for (lease = leases; lease; lease = lease->next)
668: {
669: #ifdef HAVE_DHCP6
670: if (lease->flags & (LEASE_TA | LEASE_NA))
671: continue;
672: #endif
673: if (((unsigned)ntohl(lease->addr.s_addr)) > ((unsigned)ntohl(context->start.s_addr)) &&
674: ((unsigned)ntohl(lease->addr.s_addr)) <= ((unsigned)ntohl(context->end.s_addr)) &&
675: ((unsigned)ntohl(lease->addr.s_addr)) > ((unsigned)ntohl(addr.s_addr)))
676: addr = lease->addr;
677: }
678:
679: return addr;
680: }
681:
682: static struct dhcp_lease *lease_allocate(void)
683: {
684: struct dhcp_lease *lease;
685: if (!leases_left || !(lease = whine_malloc(sizeof(struct dhcp_lease))))
686: return NULL;
687:
688: memset(lease, 0, sizeof(struct dhcp_lease));
689: lease->flags = LEASE_NEW;
690: lease->expires = 1;
691: #ifdef HAVE_BROKEN_RTC
692: lease->length = 0xffffffff; /* illegal value */
693: #endif
694: lease->next = leases;
695: leases = lease;
696:
697: file_dirty = 1;
698: leases_left--;
699:
700: return lease;
701: }
702:
703: struct dhcp_lease *lease4_allocate(struct in_addr addr)
704: {
705: struct dhcp_lease *lease = lease_allocate();
706: if (lease)
707: {
708: lease->addr = addr;
709: lease->hwaddr_len = 256; /* illegal value */
710: }
711:
712: return lease;
713: }
714:
715: #ifdef HAVE_DHCP6
716: struct dhcp_lease *lease6_allocate(struct in6_addr *addrp, int lease_type)
717: {
718: struct dhcp_lease *lease = lease_allocate();
719:
720: if (lease)
721: {
722: memcpy(lease->hwaddr, addrp, sizeof(*addrp)) ;
723: lease->flags |= lease_type;
724: }
725:
726: return lease;
727: }
728: #endif
729:
730: void lease_set_expires(struct dhcp_lease *lease, unsigned int len, time_t now)
731: {
732: time_t exp = now + (time_t)len;
733:
734: if (len == 0xffffffff)
735: {
736: exp = 0;
737: len = 0;
738: }
739:
740: if (exp != lease->expires)
741: {
742: dns_dirty = 1;
743: lease->expires = exp;
744: #ifndef HAVE_BROKEN_RTC
745: lease->flags |= LEASE_AUX_CHANGED;
746: file_dirty = 1;
747: #endif
748: }
749:
750: #ifdef HAVE_BROKEN_RTC
751: if (len != lease->length)
752: {
753: lease->length = len;
754: lease->flags |= LEASE_AUX_CHANGED;
755: file_dirty = 1;
756: }
757: #endif
758: }
759:
760: void lease_set_hwaddr(struct dhcp_lease *lease, unsigned char *hwaddr,
761: unsigned char *clid, int hw_len, int hw_type, int clid_len,
762: time_t now, int force)
763: {
764: #ifdef HAVE_DHCP6
765: int change = force;
766: lease->flags |= LEASE_HAVE_HWADDR;
767: #endif
768:
769: (void)force;
770:
771: if (hw_len != lease->hwaddr_len ||
772: hw_type != lease->hwaddr_type ||
773: (hw_len != 0 && memcmp(lease->hwaddr, hwaddr, hw_len) != 0))
774: {
775: if (hw_len != 0)
776: memcpy(lease->hwaddr, hwaddr, hw_len);
777: lease->hwaddr_len = hw_len;
778: lease->hwaddr_type = hw_type;
779: lease->flags |= LEASE_CHANGED;
780: file_dirty = 1; /* run script on change */
781: #ifdef HAVE_DHCP6
782: change = 1;
783: #endif
784: }
785:
786: /* only update clid when one is available, stops packets
787: without a clid removing the record. Lease init uses
788: clid_len == 0 for no clid. */
789: if (clid_len != 0 && clid)
790: {
791: if (!lease->clid)
792: lease->clid_len = 0;
793:
794: if (lease->clid_len != clid_len)
795: {
796: lease->flags |= LEASE_AUX_CHANGED;
797: file_dirty = 1;
798: free(lease->clid);
799: if (!(lease->clid = whine_malloc(clid_len)))
800: return;
801: #ifdef HAVE_DHCP6
802: change = 1;
803: #endif
804: }
805: else if (memcmp(lease->clid, clid, clid_len) != 0)
806: {
807: lease->flags |= LEASE_AUX_CHANGED;
808: file_dirty = 1;
809: #ifdef HAVE_DHCP6
810: change = 1;
811: #endif
812: }
813:
814: lease->clid_len = clid_len;
815: memcpy(lease->clid, clid, clid_len);
816: }
817:
818: #ifdef HAVE_DHCP6
819: if (change)
820: slaac_add_addrs(lease, now, force);
821: #endif
822: }
823:
824: static void kill_name(struct dhcp_lease *lease)
825: {
826: /* run script to say we lost our old name */
827:
828: /* this shouldn't happen unless updates are very quick and the
829: script very slow, we just avoid a memory leak if it does. */
830: free(lease->old_hostname);
831:
832: /* If we know the fqdn, pass that. The helper will derive the
833: unqualified name from it, free the unqualified name here. */
834:
835: if (lease->fqdn)
836: {
837: lease->old_hostname = lease->fqdn;
838: free(lease->hostname);
839: }
840: else
841: lease->old_hostname = lease->hostname;
842:
843: lease->hostname = lease->fqdn = NULL;
844: }
845:
846: void lease_set_hostname(struct dhcp_lease *lease, char *name, int auth, char *domain, char *config_domain)
847: {
848: struct dhcp_lease *lease_tmp;
849: char *new_name = NULL, *new_fqdn = NULL;
850:
851: if (config_domain && (!domain || !hostname_isequal(domain, config_domain)))
852: my_syslog(MS_DHCP | LOG_WARNING, _("Ignoring domain %s for DHCP host name %s"), config_domain, name);
853:
854: if (lease->hostname && name && hostname_isequal(lease->hostname, name))
855: {
856: if (auth)
857: lease->flags |= LEASE_AUTH_NAME;
858: return;
859: }
860:
861: if (!name && !lease->hostname)
862: return;
863:
864: /* If a machine turns up on a new net without dropping the old lease,
865: or two machines claim the same name, then we end up with two interfaces with
866: the same name. Check for that here and remove the name from the old lease.
867: Note that IPv6 leases are different. All the leases to the same DUID are
868: allowed the same name.
869:
870: Don't allow a name from the client to override a name from dnsmasq config. */
871:
872: if (name)
873: {
874: if ((new_name = whine_malloc(strlen(name) + 1)))
875: {
876: strcpy(new_name, name);
877: if (domain && (new_fqdn = whine_malloc(strlen(new_name) + strlen(domain) + 2)))
878: {
879: strcpy(new_fqdn, name);
880: strcat(new_fqdn, ".");
881: strcat(new_fqdn, domain);
882: }
883: }
884:
885: /* Depending on mode, we check either unqualified name or FQDN. */
886: for (lease_tmp = leases; lease_tmp; lease_tmp = lease_tmp->next)
887: {
888: if (option_bool(OPT_DHCP_FQDN))
889: {
890: if (!new_fqdn || !lease_tmp->fqdn || !hostname_isequal(lease_tmp->fqdn, new_fqdn))
891: continue;
892: }
893: else
894: {
895: if (!new_name || !lease_tmp->hostname || !hostname_isequal(lease_tmp->hostname, new_name) )
896: continue;
897: }
898:
899: if (lease->flags & (LEASE_TA | LEASE_NA))
900: {
901: if (!(lease_tmp->flags & (LEASE_TA | LEASE_NA)))
902: continue;
903:
904: /* another lease for the same DUID is OK for IPv6 */
905: if (lease->clid_len == lease_tmp->clid_len &&
906: lease->clid && lease_tmp->clid &&
907: memcmp(lease->clid, lease_tmp->clid, lease->clid_len) == 0)
908: continue;
909: }
910: else if (lease_tmp->flags & (LEASE_TA | LEASE_NA))
911: continue;
912:
913: if ((lease_tmp->flags & LEASE_AUTH_NAME) && !auth)
914: {
915: free(new_name);
916: free(new_fqdn);
917: return;
918: }
919:
920: kill_name(lease_tmp);
921: break;
922: }
923: }
924:
925: if (lease->hostname)
926: kill_name(lease);
927:
928: lease->hostname = new_name;
929: lease->fqdn = new_fqdn;
930:
931: if (auth)
932: lease->flags |= LEASE_AUTH_NAME;
933:
934: file_dirty = 1;
935: dns_dirty = 1;
936: lease->flags |= LEASE_CHANGED; /* run script on change */
937: }
938:
939: void lease_set_interface(struct dhcp_lease *lease, int interface, time_t now)
940: {
941: if (lease->last_interface == interface)
942: return;
943:
944: lease->last_interface = interface;
945: lease->flags |= LEASE_CHANGED;
946:
947: #ifdef HAVE_DHCP6
948: slaac_add_addrs(lease, now, 0);
949: #endif
950: }
951:
952: void rerun_scripts(void)
953: {
954: struct dhcp_lease *lease;
955:
956: for (lease = leases; lease; lease = lease->next)
957: lease->flags |= LEASE_CHANGED;
958: }
959:
960: /* deleted leases get transferred to the old_leases list.
961: remove them here, after calling the lease change
962: script. Also run the lease change script on new/modified leases.
963:
964: Return zero if nothing to do. */
965: int do_script_run(time_t now)
966: {
967: struct dhcp_lease *lease;
968:
969: #ifdef HAVE_DBUS
970: /* If we're going to be sending DBus signals, but the connection is not yet up,
971: delay everything until it is. */
972: if (option_bool(OPT_DBUS) && !daemon->dbus)
973: return 0;
974: #endif
975:
976: if (old_leases)
977: {
978: lease = old_leases;
979:
980: /* If the lease still has an old_hostname, do the "old" action on that first */
981: if (lease->old_hostname)
982: {
983: #ifdef HAVE_SCRIPT
984: queue_script(ACTION_OLD_HOSTNAME, lease, lease->old_hostname, now);
985: #endif
986: free(lease->old_hostname);
987: lease->old_hostname = NULL;
988: return 1;
989: }
990: else
991: {
992: #ifdef HAVE_DHCP6
993: struct slaac_address *slaac, *tmp;
994: for (slaac = lease->slaac_address; slaac; slaac = tmp)
995: {
996: tmp = slaac->next;
997: free(slaac);
998: }
999: #endif
1000: kill_name(lease);
1001: #ifdef HAVE_SCRIPT
1002: queue_script(ACTION_DEL, lease, lease->old_hostname, now);
1003: #endif
1004: #ifdef HAVE_DBUS
1005: emit_dbus_signal(ACTION_DEL, lease, lease->old_hostname);
1006: #endif
1007: old_leases = lease->next;
1008:
1009: free(lease->old_hostname);
1010: free(lease->clid);
1011: free(lease->extradata);
1012: free(lease);
1013:
1014: return 1;
1015: }
1016: }
1017:
1018: /* make sure we announce the loss of a hostname before its new location. */
1019: for (lease = leases; lease; lease = lease->next)
1020: if (lease->old_hostname)
1021: {
1022: #ifdef HAVE_SCRIPT
1023: queue_script(ACTION_OLD_HOSTNAME, lease, lease->old_hostname, now);
1024: #endif
1025: free(lease->old_hostname);
1026: lease->old_hostname = NULL;
1027: return 1;
1028: }
1029:
1030: for (lease = leases; lease; lease = lease->next)
1031: if ((lease->flags & (LEASE_NEW | LEASE_CHANGED)) ||
1032: ((lease->flags & LEASE_AUX_CHANGED) && option_bool(OPT_LEASE_RO)))
1033: {
1034: #ifdef HAVE_SCRIPT
1035: queue_script((lease->flags & LEASE_NEW) ? ACTION_ADD : ACTION_OLD, lease,
1036: lease->fqdn ? lease->fqdn : lease->hostname, now);
1037: #endif
1038: #ifdef HAVE_DBUS
1039: emit_dbus_signal((lease->flags & LEASE_NEW) ? ACTION_ADD : ACTION_OLD, lease,
1040: lease->fqdn ? lease->fqdn : lease->hostname);
1041: #endif
1042: lease->flags &= ~(LEASE_NEW | LEASE_CHANGED | LEASE_AUX_CHANGED);
1043:
1044: /* this is used for the "add" call, then junked, since they're not in the database */
1045: free(lease->extradata);
1046: lease->extradata = NULL;
1047:
1048: return 1;
1049: }
1050:
1051: return 0; /* nothing to do */
1052: }
1053:
1054: #ifdef HAVE_SCRIPT
1055: void lease_add_extradata(struct dhcp_lease *lease, unsigned char *data, unsigned int len, int delim)
1056: {
1057: unsigned int i;
1058:
1059: /* check for embeded NULLs */
1060: for (i = 0; i < len; i++)
1061: if (data[i] == 0)
1062: {
1063: len = i;
1064: break;
1065: }
1066:
1067: if ((lease->extradata_size - lease->extradata_len) < (len + 1))
1068: {
1069: size_t newsz = lease->extradata_len + len + 100;
1070: unsigned char *new = whine_malloc(newsz);
1071:
1072: if (!new)
1073: return;
1074:
1075: if (lease->extradata)
1076: {
1077: memcpy(new, lease->extradata, lease->extradata_len);
1078: free(lease->extradata);
1079: }
1080:
1081: lease->extradata = new;
1082: lease->extradata_size = newsz;
1083: }
1084:
1085: if (len != 0)
1086: memcpy(lease->extradata + lease->extradata_len, data, len);
1087: lease->extradata[lease->extradata_len + len] = delim;
1088: lease->extradata_len += len + 1;
1089: }
1090: #endif
1091:
1092: #endif
1093:
1094:
1095:
1096:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lease.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src