1: /* mdb.c
2:
3: Server-specific in-memory database support. */
4:
5: /*
6: * Copyright (c) 2004-2009 by Internet Systems Consortium, Inc. ("ISC")
7: * Copyright (c) 1996-2003 by Internet Software Consortium
8: *
9: * Permission to use, copy, modify, and distribute this software for any
10: * purpose with or without fee is hereby granted, provided that the above
11: * copyright notice and this permission notice appear in all copies.
12: *
13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20: *
21: * Internet Systems Consortium, Inc.
22: * 950 Charter Street
23: * Redwood City, CA 94063
24: * <info@isc.org>
25: * https://www.isc.org/
26: *
27: * This software has been written for Internet Systems Consortium
28: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
29: * To learn more about Internet Systems Consortium, see
30: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
31: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
32: * ``http://www.nominum.com''.
33: */
34:
35: #include "dhcpd.h"
36: #include "omapip/hash.h"
37:
38: struct subnet *subnets;
39: struct shared_network *shared_networks;
40: host_hash_t *host_hw_addr_hash;
41: host_hash_t *host_uid_hash;
42: host_hash_t *host_name_hash;
43: lease_id_hash_t *lease_uid_hash;
44: lease_ip_hash_t *lease_ip_addr_hash;
45: lease_id_hash_t *lease_hw_addr_hash;
46:
47: /*
48: * We allow users to specify any option as a host identifier.
49: *
50: * Any host is uniquely identified by the combination of
51: * option type & option data.
52: *
53: * We expect people will only use a few types of options as host
54: * identifier. Because of this, we store a list with an entry for
55: * each option type. Each of these has a hash table, which contains
56: * hash of the option data.
57: */
58: typedef struct host_id_info {
59: struct option *option;
60: host_hash_t *values_hash;
61: struct host_id_info *next;
62: } host_id_info_t;
63:
64: static host_id_info_t *host_id_info = NULL;
65:
66: int numclasseswritten;
67:
68: omapi_object_type_t *dhcp_type_host;
69:
70: isc_result_t enter_class(cd, dynamicp, commit)
71: struct class *cd;
72: int dynamicp;
73: int commit;
74: {
75: if (!collections -> classes) {
76: /* A subclass with no parent is invalid. */
77: if (cd->name == NULL)
78: return ISC_R_INVALIDARG;
79:
80: class_reference (&collections -> classes, cd, MDL);
81: } else if (cd->name != NULL) { /* regular class */
82: struct class *c = 0;
83:
84: if (find_class(&c, cd->name, MDL) != ISC_R_NOTFOUND) {
85: class_dereference(&c, MDL);
86: return ISC_R_EXISTS;
87: }
88:
89: /* Find the tail. */
90: for (c = collections -> classes;
91: c -> nic; c = c -> nic)
92: /* nothing */ ;
93: class_reference (&c -> nic, cd, MDL);
94: }
95:
96: if (dynamicp && commit) {
97: const char *name = cd->name;
98:
99: if (name == NULL) {
100: name = cd->superclass->name;
101: }
102:
103: write_named_billing_class ((const unsigned char *)name, 0, cd);
104: if (!commit_leases ())
105: return ISC_R_IOERROR;
106: }
107:
108: return ISC_R_SUCCESS;
109: }
110:
111:
112: /* Variable to check if we're starting the server. The server will init as
113: * starting - but just to be safe start out as false to avoid triggering new
114: * special-case code
115: * XXX: There is actually a server_startup state...which is never entered...
116: */
117: #define SS_NOSYNC 1
118: #define SS_QFOLLOW 2
119: static int server_starting = 0;
120:
121: static int find_uid_statement (struct executable_statement *esp,
122: void *vp, int condp)
123: {
124: struct executable_statement **evp = vp;
125:
126: if (esp -> op == supersede_option_statement &&
127: esp -> data.option &&
128: (esp -> data.option -> option -> universe ==
129: &dhcp_universe) &&
130: (esp -> data.option -> option -> code ==
131: DHO_DHCP_CLIENT_IDENTIFIER)) {
132: if (condp) {
133: log_error ("dhcp client identifier may not be %s",
134: "specified conditionally.");
135: } else if (!(*evp)) {
136: executable_statement_reference (evp, esp, MDL);
137: return 1;
138: } else {
139: log_error ("only one dhcp client identifier may be %s",
140: "specified");
141: }
142: }
143: return 0;
144: }
145:
146:
147: static host_id_info_t *
148: find_host_id_info(unsigned int option_code) {
149: host_id_info_t *p;
150:
151: for (p=host_id_info; p != NULL; p = p->next) {
152: if (p->option->code == option_code) {
153: break;
154: }
155: }
156: return p;
157: }
158:
159: /* Debugging code */
160: #if 0
161: isc_result_t
162: print_host(const void *name, unsigned len, void *value) {
163: struct host_decl *h;
164: printf("--------------\n");
165: printf("name:'%s'\n", print_hex_1(len, name, 60));
166: printf("len:%d\n", len);
167: h = (struct host_decl *)value;
168: printf("host @%p is '%s'\n", h, h->name);
169: return ISC_R_SUCCESS;
170: }
171:
172: void
173: hash_print_hosts(struct hash_table *h) {
174: hash_foreach(h, print_host);
175: printf("--------------\n");
176: }
177: #endif /* 0 */
178:
179: void
180: change_host_uid(struct host_decl *host, const char *uid, int len) {
181: /* XXX: should consolidate this type of code throughout */
182: if (host_uid_hash == NULL) {
183: if (!host_new_hash(&host_uid_hash, HOST_HASH_SIZE, MDL)) {
184: log_fatal("Can't allocate host/uid hash");
185: }
186: }
187:
188: /*
189: * Remove the old entry, if one exists.
190: */
191: if (host->client_identifier.data != NULL) {
192: host_hash_delete(host_uid_hash,
193: host->client_identifier.data,
194: host->client_identifier.len,
195: MDL);
196: data_string_forget(&host->client_identifier, MDL);
197: }
198:
199: /*
200: * Set our new value.
201: */
202: memset(&host->client_identifier, 0, sizeof(host->client_identifier));
203: host->client_identifier.len = len;
204: if (!buffer_allocate(&host->client_identifier.buffer, len, MDL)) {
205: log_fatal("Can't allocate uid buffer");
206: }
207: host->client_identifier.data = host->client_identifier.buffer->data;
208: memcpy((char *)host->client_identifier.data, uid, len);
209:
210: /*
211: * And add to hash.
212: */
213: host_hash_add(host_uid_hash, host->client_identifier.data,
214: host->client_identifier.len, host, MDL);
215: }
216:
217: isc_result_t enter_host (hd, dynamicp, commit)
218: struct host_decl *hd;
219: int dynamicp;
220: int commit;
221: {
222: struct host_decl *hp = (struct host_decl *)0;
223: struct host_decl *np = (struct host_decl *)0;
224: struct executable_statement *esp;
225: host_id_info_t *h_id_info;
226:
227: if (!host_name_hash) {
228: if (!host_new_hash(&host_name_hash, HOST_HASH_SIZE, MDL))
229: log_fatal ("Can't allocate host name hash");
230: host_hash_add (host_name_hash,
231: (unsigned char *)hd -> name,
232: strlen (hd -> name), hd, MDL);
233: } else {
234: host_hash_lookup (&hp, host_name_hash,
235: (unsigned char *)hd -> name,
236: strlen (hd -> name), MDL);
237:
238: /* If it's deleted, we can supersede it. */
239: if (hp && (hp -> flags & HOST_DECL_DELETED)) {
240: host_hash_delete (host_name_hash,
241: (unsigned char *)hd -> name,
242: strlen (hd -> name), MDL);
243: /* If the old entry wasn't dynamic, then we
244: always have to keep the deletion. */
245: if (hp -> flags & HOST_DECL_STATIC) {
246: hd -> flags |= HOST_DECL_STATIC;
247: }
248: host_dereference (&hp, MDL);
249: }
250:
251: /* If we are updating an existing host declaration, we
252: can just delete it and add it again. */
253: if (hp && hp == hd) {
254: host_dereference (&hp, MDL);
255: delete_host (hd, 0);
256: if (!write_host (hd))
257: return ISC_R_IOERROR;
258: hd -> flags &= ~HOST_DECL_DELETED;
259: }
260:
261: /* If there isn't already a host decl matching this
262: address, add it to the hash table. */
263: if (!hp) {
264: host_hash_add (host_name_hash,
265: (unsigned char *)hd -> name,
266: strlen (hd -> name), hd, MDL);
267: } else {
268: /* XXX actually, we have to delete the old one
269: XXX carefully and replace it. Not done yet. */
270: host_dereference (&hp, MDL);
271: return ISC_R_EXISTS;
272: }
273: }
274:
275: if (hd -> n_ipaddr)
276: host_dereference (&hd -> n_ipaddr, MDL);
277:
278: if (!hd -> type)
279: hd -> type = dhcp_type_host;
280:
281: if (hd -> interface.hlen) {
282: if (!host_hw_addr_hash) {
283: if (!host_new_hash(&host_hw_addr_hash,
284: HOST_HASH_SIZE, MDL))
285: log_fatal ("Can't allocate host/hw hash");
286: } else {
287: /* If there isn't already a host decl matching this
288: address, add it to the hash table. */
289: host_hash_lookup (&hp, host_hw_addr_hash,
290: hd -> interface.hbuf,
291: hd -> interface.hlen, MDL);
292: }
293: if (!hp)
294: host_hash_add (host_hw_addr_hash, hd -> interface.hbuf,
295: hd -> interface.hlen, hd, MDL);
296: else {
297: /* If there was already a host declaration for
298: this hardware address, add this one to the
299: end of the list. */
300: for (np = hp; np -> n_ipaddr; np = np -> n_ipaddr)
301: ;
302: host_reference (&np -> n_ipaddr, hd, MDL);
303: host_dereference (&hp, MDL);
304: }
305: }
306:
307: /* See if there's a statement that sets the client identifier.
308: This is a kludge - the client identifier really shouldn't be
309: set with an executable statement. */
310: esp = (struct executable_statement *)0;
311: if (executable_statement_foreach (hd -> group -> statements,
312: find_uid_statement, &esp, 0)) {
313: evaluate_option_cache (&hd -> client_identifier,
314: (struct packet *)0,
315: (struct lease *)0,
316: (struct client_state *)0,
317: (struct option_state *)0,
318: (struct option_state *)0, &global_scope,
319: esp -> data.option, MDL);
320: }
321:
322: /* If we got a client identifier, hash this entry by
323: client identifier. */
324: if (hd -> client_identifier.len) {
325: /* If there's no uid hash, make one; otherwise, see if
326: there's already an entry in the hash for this host. */
327: if (!host_uid_hash) {
328: if (!host_new_hash(&host_uid_hash,
329: HOST_HASH_SIZE, MDL))
330: log_fatal ("Can't allocate host/uid hash");
331:
332: host_hash_add (host_uid_hash,
333: hd -> client_identifier.data,
334: hd -> client_identifier.len,
335: hd, MDL);
336: } else {
337: /* If there's already a host declaration for this
338: client identifier, add this one to the end of the
339: list. Otherwise, add it to the hash table. */
340: if (host_hash_lookup (&hp, host_uid_hash,
341: hd -> client_identifier.data,
342: hd -> client_identifier.len,
343: MDL)) {
344: /* Don't link it in twice... */
345: if (!np) {
346: for (np = hp; np -> n_ipaddr;
347: np = np -> n_ipaddr) {
348: if (hd == np)
349: break;
350: }
351: if (hd != np)
352: host_reference (&np -> n_ipaddr,
353: hd, MDL);
354: }
355: host_dereference (&hp, MDL);
356: } else {
357: host_hash_add (host_uid_hash,
358: hd -> client_identifier.data,
359: hd -> client_identifier.len,
360: hd, MDL);
361: }
362: }
363: }
364:
365:
366: /*
367: * If we use an option as our host identifier, record it here.
368: */
369: if (hd->host_id_option != NULL) {
370: /*
371: * Look for the host identifier information for this option,
372: * and create a new entry if there is none.
373: */
374: h_id_info = find_host_id_info(hd->host_id_option->code);
375: if (h_id_info == NULL) {
376: h_id_info = dmalloc(sizeof(*h_id_info), MDL);
377: if (h_id_info == NULL) {
378: log_fatal("No memory for host-identifier "
379: "option information.");
380: }
381: option_reference(&h_id_info->option,
382: hd->host_id_option, MDL);
383: if (!host_new_hash(&h_id_info->values_hash,
384: HOST_HASH_SIZE, MDL)) {
385: log_fatal("No memory for host-identifier "
386: "option hash.");
387: }
388: h_id_info->next = host_id_info;
389: host_id_info = h_id_info;
390: }
391:
392: if (host_hash_lookup(&hp, h_id_info->values_hash,
393: hd->host_id.data, hd->host_id.len, MDL)) {
394: /*
395: * If this option is already present, then add
396: * this host to the list in n_ipaddr, unless
397: * we have already done so previously.
398: *
399: * XXXSK: This seems scary to me, but I don't
400: * fully understand how these are used.
401: * Shouldn't there be multiple lists, or
402: * maybe we should just forbid duplicates?
403: */
404: if (np == NULL) {
405: np = hp;
406: while (np->n_ipaddr != NULL) {
407: np = np->n_ipaddr;
408: }
409: if (hd != np) {
410: host_reference(&np->n_ipaddr, hd, MDL);
411: }
412: }
413: host_dereference(&hp, MDL);
414: } else {
415: host_hash_add(h_id_info->values_hash,
416: hd->host_id.data,
417: hd->host_id.len,
418: hd, MDL);
419: }
420: }
421:
422: if (dynamicp && commit) {
423: if (!write_host (hd))
424: return ISC_R_IOERROR;
425: if (!commit_leases ())
426: return ISC_R_IOERROR;
427: }
428:
429: return ISC_R_SUCCESS;
430: }
431:
432:
433: isc_result_t delete_class (cp, commit)
434: struct class *cp;
435: int commit;
436: {
437: cp->flags |= CLASS_DECL_DELETED;
438:
439: /* do the write first as we won't be leaving it in any data
440: structures, unlike the host objects */
441:
442: if (commit) {
443: write_named_billing_class ((unsigned char *)cp->name, 0, cp);
444: if (!commit_leases ())
445: return ISC_R_IOERROR;
446: }
447:
448: unlink_class(&cp); /* remove from collections */
449:
450: class_dereference(&cp, MDL);
451:
452: return ISC_R_SUCCESS;
453: }
454:
455:
456: isc_result_t delete_host (hd, commit)
457: struct host_decl *hd;
458: int commit;
459: {
460: struct host_decl *hp = (struct host_decl *)0;
461: struct host_decl *np = (struct host_decl *)0;
462: struct host_decl *foo;
463: int hw_head = 0, uid_head = 1;
464:
465: /* Don't need to do it twice. */
466: if (hd -> flags & HOST_DECL_DELETED)
467: return ISC_R_SUCCESS;
468:
469: /* But we do need to do it once! :') */
470: hd -> flags |= HOST_DECL_DELETED;
471:
472: if (hd -> interface.hlen) {
473: if (host_hw_addr_hash) {
474: if (host_hash_lookup (&hp, host_hw_addr_hash,
475: hd -> interface.hbuf,
476: hd -> interface.hlen, MDL)) {
477: if (hp == hd) {
478: host_hash_delete (host_hw_addr_hash,
479: hd -> interface.hbuf,
480: hd -> interface.hlen, MDL);
481: hw_head = 1;
482: } else {
483: np = (struct host_decl *)0;
484: foo = (struct host_decl *)0;
485: host_reference (&foo, hp, MDL);
486: while (foo) {
487: if (foo == hd)
488: break;
489: if (np)
490: host_dereference (&np, MDL);
491: host_reference (&np, foo, MDL);
492: host_dereference (&foo, MDL);
493: if (np -> n_ipaddr)
494: host_reference (&foo, np -> n_ipaddr, MDL);
495: }
496:
497: if (foo) {
498: host_dereference (&np -> n_ipaddr, MDL);
499: if (hd -> n_ipaddr)
500: host_reference (&np -> n_ipaddr,
501: hd -> n_ipaddr, MDL);
502: host_dereference (&foo, MDL);
503: }
504: if (np)
505: host_dereference (&np, MDL);
506: }
507: host_dereference (&hp, MDL);
508: }
509: }
510: }
511:
512: /* If we got a client identifier, hash this entry by
513: client identifier. */
514: if (hd -> client_identifier.len) {
515: if (host_uid_hash) {
516: if (host_hash_lookup (&hp, host_uid_hash,
517: hd -> client_identifier.data,
518: hd -> client_identifier.len, MDL)) {
519: if (hp == hd) {
520: host_hash_delete (host_uid_hash,
521: hd -> client_identifier.data,
522: hd -> client_identifier.len, MDL);
523: uid_head = 1;
524: } else {
525: np = (struct host_decl *)0;
526: foo = (struct host_decl *)0;
527: host_reference (&foo, hp, MDL);
528: while (foo) {
529: if (foo == hd)
530: break;
531: if (np)
532: host_dereference (&np, MDL);
533: host_reference (&np, foo, MDL);
534: host_dereference (&foo, MDL);
535: if (np -> n_ipaddr)
536: host_reference (&foo, np -> n_ipaddr, MDL);
537: }
538:
539: if (foo) {
540: host_dereference (&np -> n_ipaddr, MDL);
541: if (hd -> n_ipaddr)
542: host_reference (&np -> n_ipaddr,
543: hd -> n_ipaddr, MDL);
544: host_dereference (&foo, MDL);
545: }
546: if (np)
547: host_dereference (&np, MDL);
548: }
549: host_dereference (&hp, MDL);
550: }
551: }
552: }
553:
554: if (hd->host_id_option != NULL) {
555: option_dereference(&hd->host_id_option, MDL);
556: data_string_forget(&hd->host_id, MDL);
557: }
558:
559: if (hd -> n_ipaddr) {
560: if (uid_head && hd -> n_ipaddr -> client_identifier.len) {
561: host_hash_add
562: (host_uid_hash,
563: hd -> n_ipaddr -> client_identifier.data,
564: hd -> n_ipaddr -> client_identifier.len,
565: hd -> n_ipaddr, MDL);
566: }
567: if (hw_head && hd -> n_ipaddr -> interface.hlen) {
568: host_hash_add (host_hw_addr_hash,
569: hd -> n_ipaddr -> interface.hbuf,
570: hd -> n_ipaddr -> interface.hlen,
571: hd -> n_ipaddr, MDL);
572: }
573: host_dereference (&hd -> n_ipaddr, MDL);
574: }
575:
576: if (host_name_hash) {
577: if (host_hash_lookup (&hp, host_name_hash,
578: (unsigned char *)hd -> name,
579: strlen (hd -> name), MDL)) {
580: if (hp == hd && !(hp -> flags & HOST_DECL_STATIC)) {
581: host_hash_delete (host_name_hash,
582: (unsigned char *)hd -> name,
583: strlen (hd -> name), MDL);
584: }
585: host_dereference (&hp, MDL);
586: }
587: }
588:
589: if (commit) {
590: if (!write_host (hd))
591: return ISC_R_IOERROR;
592: if (!commit_leases ())
593: return ISC_R_IOERROR;
594: }
595: return ISC_R_SUCCESS;
596: }
597:
598: int find_hosts_by_haddr (struct host_decl **hp, int htype,
599: const unsigned char *haddr, unsigned hlen,
600: const char *file, int line)
601: {
602: struct hardware h;
603:
604: h.hlen = hlen + 1;
605: h.hbuf [0] = htype;
606: memcpy (&h.hbuf [1], haddr, hlen);
607:
608: return host_hash_lookup (hp, host_hw_addr_hash,
609: h.hbuf, h.hlen, file, line);
610: }
611:
612: int find_hosts_by_uid (struct host_decl **hp,
613: const unsigned char *data, unsigned len,
614: const char *file, int line)
615: {
616: return host_hash_lookup (hp, host_uid_hash, data, len, file, line);
617: }
618:
619: int
620: find_hosts_by_option(struct host_decl **hp,
621: struct packet *packet,
622: struct option_state *opt_state,
623: const char *file, int line) {
624: host_id_info_t *p;
625: struct option_cache *oc;
626: struct data_string data;
627: int found;
628:
629: for (p = host_id_info; p != NULL; p = p->next) {
630: oc = lookup_option(p->option->universe,
631: opt_state, p->option->code);
632: if (oc != NULL) {
633: memset(&data, 0, sizeof(data));
634: if (!evaluate_option_cache(&data, packet, NULL, NULL,
635: opt_state, NULL,
636: &global_scope, oc,
637: MDL)) {
638: log_error("Error evaluating option cache");
639: return 0;
640: }
641:
642: found = host_hash_lookup(hp, p->values_hash,
643: data.data, data.len,
644: file, line);
645:
646: data_string_forget(&data, MDL);
647:
648: if (found) {
649: return 1;
650: }
651: }
652: }
653: return 0;
654: }
655:
656: /* More than one host_decl can be returned by find_hosts_by_haddr or
657: find_hosts_by_uid, and each host_decl can have multiple addresses.
658: Loop through the list of hosts, and then for each host, through the
659: list of addresses, looking for an address that's in the same shared
660: network as the one specified. Store the matching address through
661: the addr pointer, update the host pointer to point at the host_decl
662: that matched, and return the subnet that matched. */
663:
664: int find_host_for_network (struct subnet **sp, struct host_decl **host,
665: struct iaddr *addr, struct shared_network *share)
666: {
667: int i;
668: struct iaddr ip_address;
669: struct host_decl *hp;
670: struct data_string fixed_addr;
671:
672: memset (&fixed_addr, 0, sizeof fixed_addr);
673:
674: for (hp = *host; hp; hp = hp -> n_ipaddr) {
675: if (!hp -> fixed_addr)
676: continue;
677: if (!evaluate_option_cache (&fixed_addr, (struct packet *)0,
678: (struct lease *)0,
679: (struct client_state *)0,
680: (struct option_state *)0,
681: (struct option_state *)0,
682: &global_scope,
683: hp -> fixed_addr, MDL))
684: continue;
685: for (i = 0; i < fixed_addr.len; i += 4) {
686: ip_address.len = 4;
687: memcpy (ip_address.iabuf,
688: fixed_addr.data + i, 4);
689: if (find_grouped_subnet (sp, share, ip_address, MDL)) {
690: struct host_decl *tmp = (struct host_decl *)0;
691: *addr = ip_address;
692: /* This is probably not necessary, but
693: just in case *host is the only reference
694: to that host declaration, make a temporary
695: reference so that dereferencing it doesn't
696: dereference hp out from under us. */
697: host_reference (&tmp, *host, MDL);
698: host_dereference (host, MDL);
699: host_reference (host, hp, MDL);
700: host_dereference (&tmp, MDL);
701: data_string_forget (&fixed_addr, MDL);
702: return 1;
703: }
704: }
705: data_string_forget (&fixed_addr, MDL);
706: }
707: return 0;
708: }
709:
710: void new_address_range (cfile, low, high, subnet, pool, lpchain)
711: struct parse *cfile;
712: struct iaddr low, high;
713: struct subnet *subnet;
714: struct pool *pool;
715: struct lease **lpchain;
716: {
717: #if defined(COMPACT_LEASES)
718: struct lease *address_range;
719: #endif
720: unsigned min, max, i;
721: char lowbuf [16], highbuf [16], netbuf [16];
722: struct shared_network *share = subnet -> shared_network;
723: struct lease *lt = (struct lease *)0;
724: #if !defined(COMPACT_LEASES)
725: isc_result_t status;
726: #endif
727:
728: /* All subnets should have attached shared network structures. */
729: if (!share) {
730: strcpy (netbuf, piaddr (subnet -> net));
731: log_fatal ("No shared network for network %s (%s)",
732: netbuf, piaddr (subnet -> netmask));
733: }
734:
735: /* Initialize the hash table if it hasn't been done yet. */
736: if (!lease_uid_hash) {
737: if (!lease_id_new_hash(&lease_uid_hash, LEASE_HASH_SIZE, MDL))
738: log_fatal ("Can't allocate lease/uid hash");
739: }
740: if (!lease_ip_addr_hash) {
741: if (!lease_ip_new_hash(&lease_ip_addr_hash, LEASE_HASH_SIZE,
742: MDL))
743: log_fatal ("Can't allocate lease/ip hash");
744: }
745: if (!lease_hw_addr_hash) {
746: if (!lease_id_new_hash(&lease_hw_addr_hash, LEASE_HASH_SIZE,
747: MDL))
748: log_fatal ("Can't allocate lease/hw hash");
749: }
750:
751: /* Make sure that high and low addresses are in this subnet. */
752: if (!addr_eq(subnet->net, subnet_number(low, subnet->netmask))) {
753: strcpy(lowbuf, piaddr(low));
754: strcpy(netbuf, piaddr(subnet->net));
755: log_fatal("bad range, address %s not in subnet %s netmask %s",
756: lowbuf, netbuf, piaddr(subnet->netmask));
757: }
758:
759: if (!addr_eq(subnet->net, subnet_number(high, subnet->netmask))) {
760: strcpy(highbuf, piaddr(high));
761: strcpy(netbuf, piaddr(subnet->net));
762: log_fatal("bad range, address %s not in subnet %s netmask %s",
763: highbuf, netbuf, piaddr(subnet->netmask));
764: }
765:
766: /* Get the high and low host addresses... */
767: max = host_addr (high, subnet -> netmask);
768: min = host_addr (low, subnet -> netmask);
769:
770: /* Allow range to be specified high-to-low as well as low-to-high. */
771: if (min > max) {
772: max = min;
773: min = host_addr (high, subnet -> netmask);
774: }
775:
776: /* Get a lease structure for each address in the range. */
777: #if defined (COMPACT_LEASES)
778: address_range = new_leases (max - min + 1, MDL);
779: if (!address_range) {
780: strcpy (lowbuf, piaddr (low));
781: strcpy (highbuf, piaddr (high));
782: log_fatal ("No memory for address range %s-%s.",
783: lowbuf, highbuf);
784: }
785: #endif
786:
787: /* Fill out the lease structures with some minimal information. */
788: for (i = 0; i < max - min + 1; i++) {
789: struct lease *lp = (struct lease *)0;
790: #if defined (COMPACT_LEASES)
791: omapi_object_initialize ((omapi_object_t *)&address_range [i],
792: dhcp_type_lease,
793: 0, sizeof (struct lease), MDL);
794: lease_reference (&lp, &address_range [i], MDL);
795: #else
796: status = lease_allocate (&lp, MDL);
797: if (status != ISC_R_SUCCESS)
798: log_fatal ("No memory for lease %s: %s",
799: piaddr (ip_addr (subnet -> net,
800: subnet -> netmask,
801: i + min)),
802: isc_result_totext (status));
803: #endif
804: lp -> ip_addr = ip_addr (subnet -> net,
805: subnet -> netmask, i + min);
806: lp -> starts = MIN_TIME;
807: lp -> ends = MIN_TIME;
808: subnet_reference (&lp -> subnet, subnet, MDL);
809: pool_reference (&lp -> pool, pool, MDL);
810: lp -> binding_state = FTS_FREE;
811: lp -> next_binding_state = FTS_FREE;
812: lp -> flags = 0;
813:
814: /* Remember the lease in the IP address hash. */
815: if (find_lease_by_ip_addr (<, lp -> ip_addr, MDL)) {
816: if (lt -> pool) {
817: parse_warn (cfile,
818: "lease %s is declared twice!",
819: piaddr (lp -> ip_addr));
820: } else
821: pool_reference (< -> pool, pool, MDL);
822: lease_dereference (<, MDL);
823: } else
824: lease_ip_hash_add(lease_ip_addr_hash,
825: lp->ip_addr.iabuf, lp->ip_addr.len,
826: lp, MDL);
827: /* Put the lease on the chain for the caller. */
828: if (lpchain) {
829: if (*lpchain) {
830: lease_reference (&lp -> next, *lpchain, MDL);
831: lease_dereference (lpchain, MDL);
832: }
833: lease_reference (lpchain, lp, MDL);
834: }
835: lease_dereference (&lp, MDL);
836: }
837: }
838:
839: int find_subnet (struct subnet **sp,
840: struct iaddr addr, const char *file, int line)
841: {
842: struct subnet *rv;
843:
844: for (rv = subnets; rv; rv = rv -> next_subnet) {
845: if (addr_eq (subnet_number (addr, rv -> netmask), rv -> net)) {
846: if (subnet_reference (sp, rv,
847: file, line) != ISC_R_SUCCESS)
848: return 0;
849: return 1;
850: }
851: }
852: return 0;
853: }
854:
855: int find_grouped_subnet (struct subnet **sp,
856: struct shared_network *share, struct iaddr addr,
857: const char *file, int line)
858: {
859: struct subnet *rv;
860:
861: for (rv = share -> subnets; rv; rv = rv -> next_sibling) {
862: if (addr_eq (subnet_number (addr, rv -> netmask), rv -> net)) {
863: if (subnet_reference (sp, rv,
864: file, line) != ISC_R_SUCCESS)
865: return 0;
866: return 1;
867: }
868: }
869: return 0;
870: }
871:
872: /* XXX: could speed up if everyone had a prefix length */
873: int
874: subnet_inner_than(const struct subnet *subnet,
875: const struct subnet *scan,
876: int warnp) {
877: if (addr_eq(subnet_number(subnet->net, scan->netmask), scan->net) ||
878: addr_eq(subnet_number(scan->net, subnet->netmask), subnet->net)) {
879: char n1buf[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255")];
880: int i, j;
881: for (i = 0; i < 128; i++)
882: if (subnet->netmask.iabuf[3 - (i >> 3)]
883: & (1 << (i & 7)))
884: break;
885: for (j = 0; j < 128; j++)
886: if (scan->netmask.iabuf[3 - (j >> 3)] &
887: (1 << (j & 7)))
888: break;
889: if (warnp) {
890: strcpy(n1buf, piaddr(subnet->net));
891: log_error("Warning: subnet %s/%d overlaps subnet %s/%d",
892: n1buf, 32 - i,
893: piaddr(scan->net), 32 - j);
894: }
895: if (i < j)
896: return 1;
897: }
898: return 0;
899: }
900:
901: /* Enter a new subnet into the subnet list. */
902: void enter_subnet (subnet)
903: struct subnet *subnet;
904: {
905: struct subnet *scan = (struct subnet *)0;
906: struct subnet *next = (struct subnet *)0;
907: struct subnet *prev = (struct subnet *)0;
908:
909: /* Check for duplicates... */
910: if (subnets)
911: subnet_reference (&next, subnets, MDL);
912: while (next) {
913: subnet_reference (&scan, next, MDL);
914: subnet_dereference (&next, MDL);
915:
916: /* When we find a conflict, make sure that the
917: subnet with the narrowest subnet mask comes
918: first. */
919: if (subnet_inner_than (subnet, scan, 1)) {
920: if (prev) {
921: if (prev -> next_subnet)
922: subnet_dereference (&prev -> next_subnet, MDL);
923: subnet_reference (&prev -> next_subnet, subnet, MDL);
924: subnet_dereference (&prev, MDL);
925: } else {
926: subnet_dereference (&subnets, MDL);
927: subnet_reference (&subnets, subnet, MDL);
928: }
929: subnet_reference (&subnet -> next_subnet, scan, MDL);
930: subnet_dereference (&scan, MDL);
931: return;
932: }
933: subnet_reference (&prev, scan, MDL);
934: subnet_dereference (&scan, MDL);
935: }
936: if (prev)
937: subnet_dereference (&prev, MDL);
938:
939: /* XXX use the BSD radix tree code instead of a linked list. */
940: if (subnets) {
941: subnet_reference (&subnet -> next_subnet, subnets, MDL);
942: subnet_dereference (&subnets, MDL);
943: }
944: subnet_reference (&subnets, subnet, MDL);
945: }
946:
947: /* Enter a new shared network into the shared network list. */
948:
949: void enter_shared_network (share)
950: struct shared_network *share;
951: {
952: if (shared_networks) {
953: shared_network_reference (&share -> next,
954: shared_networks, MDL);
955: shared_network_dereference (&shared_networks, MDL);
956: }
957: shared_network_reference (&shared_networks, share, MDL);
958: }
959:
960: void new_shared_network_interface (cfile, share, name)
961: struct parse *cfile;
962: struct shared_network *share;
963: const char *name;
964: {
965: struct interface_info *ip;
966: isc_result_t status;
967:
968: if (share -> interface) {
969: parse_warn (cfile,
970: "A subnet or shared network can't be connected %s",
971: "to two interfaces.");
972: return;
973: }
974:
975: for (ip = interfaces; ip; ip = ip -> next)
976: if (!strcmp (ip -> name, name))
977: break;
978: if (!ip) {
979: status = interface_allocate (&ip, MDL);
980: if (status != ISC_R_SUCCESS)
981: log_fatal ("new_shared_network_interface %s: %s",
982: name, isc_result_totext (status));
983: if (strlen (name) > sizeof ip -> name) {
984: memcpy (ip -> name, name, (sizeof ip -> name) - 1);
985: ip -> name [(sizeof ip -> name) - 1] = 0;
986: } else
987: strcpy (ip -> name, name);
988: if (interfaces) {
989: interface_reference (&ip -> next, interfaces, MDL);
990: interface_dereference (&interfaces, MDL);
991: }
992: interface_reference (&interfaces, ip, MDL);
993: ip -> flags = INTERFACE_REQUESTED;
994: /* XXX this is a reference loop. */
995: shared_network_reference (&ip -> shared_network, share, MDL);
996: interface_reference (&share -> interface, ip, MDL);
997: }
998: }
999:
1000: /* Enter a lease into the system. This is called by the parser each
1001: time it reads in a new lease. If the subnet for that lease has
1002: already been read in (usually the case), just update that lease;
1003: otherwise, allocate temporary storage for the lease and keep it around
1004: until we're done reading in the config file. */
1005:
1006: void enter_lease (lease)
1007: struct lease *lease;
1008: {
1009: struct lease *comp = (struct lease *)0;
1010:
1011: if (find_lease_by_ip_addr (&comp, lease -> ip_addr, MDL)) {
1012: if (!comp -> pool) {
1013: log_error ("undeclared lease found in database: %s",
1014: piaddr (lease -> ip_addr));
1015: } else
1016: pool_reference (&lease -> pool, comp -> pool, MDL);
1017:
1018: if (comp -> subnet)
1019: subnet_reference (&lease -> subnet,
1020: comp -> subnet, MDL);
1021: lease_ip_hash_delete(lease_ip_addr_hash,
1022: lease->ip_addr.iabuf, lease->ip_addr.len,
1023: MDL);
1024: lease_dereference (&comp, MDL);
1025: }
1026:
1027: /* The only way a lease can get here without a subnet is if it's in
1028: the lease file, but not in the dhcpd.conf file. In this case, we
1029: *should* keep it around until it's expired, but never reallocate it
1030: or renew it. Currently, to maintain consistency, we are not doing
1031: this.
1032: XXX fix this so that the lease is kept around until it expires.
1033: XXX this will be important in IPv6 with addresses that become
1034: XXX non-renewable as a result of a renumbering event. */
1035:
1036: if (!lease -> subnet) {
1037: log_error ("lease %s: no subnet.", piaddr (lease -> ip_addr));
1038: return;
1039: }
1040: lease_ip_hash_add(lease_ip_addr_hash, lease->ip_addr.iabuf,
1041: lease->ip_addr.len, lease, MDL);
1042: }
1043:
1044: /* Replace the data in an existing lease with the data in a new lease;
1045: adjust hash tables to suit, and insertion sort the lease into the
1046: list of leases by expiry time so that we can always find the oldest
1047: lease. */
1048:
1049: int supersede_lease (comp, lease, commit, propogate, pimmediate)
1050: struct lease *comp, *lease;
1051: int commit;
1052: int propogate;
1053: int pimmediate;
1054: {
1055: struct lease *lp, **lq, *prev;
1056: struct timeval tv;
1057: #if defined (FAILOVER_PROTOCOL)
1058: int do_pool_check = 0;
1059:
1060: /* We must commit leases before sending updates regarding them
1061: to failover peers. It is, therefore, an error to set pimmediate
1062: and not commit. */
1063: if (pimmediate && !commit)
1064: return 0;
1065: #endif
1066:
1067: /* If there is no sample lease, just do the move. */
1068: if (!lease)
1069: goto just_move_it;
1070:
1071: /* Static leases are not currently kept in the database... */
1072: if (lease -> flags & STATIC_LEASE)
1073: return 1;
1074:
1075: /* If the existing lease hasn't expired and has a different
1076: unique identifier or, if it doesn't have a unique
1077: identifier, a different hardware address, then the two
1078: leases are in conflict. If the existing lease has a uid
1079: and the new one doesn't, but they both have the same
1080: hardware address, and dynamic bootp is allowed on this
1081: lease, then we allow that, in case a dynamic BOOTP lease is
1082: requested *after* a DHCP lease has been assigned. */
1083:
1084: if (lease -> binding_state != FTS_ABANDONED &&
1085: lease -> next_binding_state != FTS_ABANDONED &&
1086: comp -> binding_state == FTS_ACTIVE &&
1087: (((comp -> uid && lease -> uid) &&
1088: (comp -> uid_len != lease -> uid_len ||
1089: memcmp (comp -> uid, lease -> uid, comp -> uid_len))) ||
1090: (!comp -> uid &&
1091: ((comp -> hardware_addr.hlen !=
1092: lease -> hardware_addr.hlen) ||
1093: memcmp (comp -> hardware_addr.hbuf,
1094: lease -> hardware_addr.hbuf,
1095: comp -> hardware_addr.hlen))))) {
1096: log_error ("Lease conflict at %s",
1097: piaddr (comp -> ip_addr));
1098: }
1099:
1100: /* If there's a Unique ID, dissociate it from the hash
1101: table and free it if necessary. */
1102: if (comp->uid) {
1103: uid_hash_delete(comp);
1104: if (comp->uid != comp->uid_buf) {
1105: dfree(comp->uid, MDL);
1106: comp->uid_max = 0;
1107: comp->uid_len = 0;
1108: }
1109: comp -> uid = (unsigned char *)0;
1110: }
1111:
1112: /* If there's a hardware address, remove the lease from its
1113: * old position in the hash bucket's ordered list.
1114: */
1115: if (comp->hardware_addr.hlen)
1116: hw_hash_delete(comp);
1117:
1118: /* If the lease has been billed to a class, remove the billing. */
1119: if (comp -> billing_class != lease -> billing_class) {
1120: if (comp -> billing_class)
1121: unbill_class (comp, comp -> billing_class);
1122: if (lease -> billing_class)
1123: bill_class (comp, lease -> billing_class);
1124: }
1125:
1126: /* Copy the data files, but not the linkages. */
1127: comp -> starts = lease -> starts;
1128: if (lease -> uid) {
1129: if (lease -> uid_len <= sizeof (lease -> uid_buf)) {
1130: memcpy (comp -> uid_buf,
1131: lease -> uid, lease -> uid_len);
1132: comp -> uid = &comp -> uid_buf [0];
1133: comp -> uid_max = sizeof comp -> uid_buf;
1134: comp -> uid_len = lease -> uid_len;
1135: } else if (lease -> uid != &lease -> uid_buf [0]) {
1136: comp -> uid = lease -> uid;
1137: comp -> uid_max = lease -> uid_max;
1138: lease -> uid = (unsigned char *)0;
1139: lease -> uid_max = 0;
1140: comp -> uid_len = lease -> uid_len;
1141: lease -> uid_len = 0;
1142: } else {
1143: log_fatal ("corrupt lease uid."); /* XXX */
1144: }
1145: } else {
1146: comp -> uid = (unsigned char *)0;
1147: comp -> uid_len = comp -> uid_max = 0;
1148: }
1149: if (comp -> host)
1150: host_dereference (&comp -> host, MDL);
1151: host_reference (&comp -> host, lease -> host, MDL);
1152: comp -> hardware_addr = lease -> hardware_addr;
1153: comp -> flags = ((lease -> flags & ~PERSISTENT_FLAGS) |
1154: (comp -> flags & ~EPHEMERAL_FLAGS));
1155: if (comp -> scope)
1156: binding_scope_dereference (&comp -> scope, MDL);
1157: if (lease -> scope) {
1158: binding_scope_reference (&comp -> scope, lease -> scope, MDL);
1159: binding_scope_dereference (&lease -> scope, MDL);
1160: }
1161:
1162: if (comp -> agent_options)
1163: option_chain_head_dereference (&comp -> agent_options, MDL);
1164: if (lease -> agent_options) {
1165: /* Only retain the agent options if the lease is still
1166: affirmatively associated with a client. */
1167: if (lease -> next_binding_state == FTS_ACTIVE ||
1168: lease -> next_binding_state == FTS_EXPIRED)
1169: option_chain_head_reference (&comp -> agent_options,
1170: lease -> agent_options,
1171: MDL);
1172: option_chain_head_dereference (&lease -> agent_options, MDL);
1173: }
1174:
1175: /* Record the hostname information in the lease. */
1176: if (comp -> client_hostname)
1177: dfree (comp -> client_hostname, MDL);
1178: comp -> client_hostname = lease -> client_hostname;
1179: lease -> client_hostname = (char *)0;
1180:
1181: if (lease -> on_expiry) {
1182: if (comp -> on_expiry)
1183: executable_statement_dereference (&comp -> on_expiry,
1184: MDL);
1185: executable_statement_reference (&comp -> on_expiry,
1186: lease -> on_expiry,
1187: MDL);
1188: }
1189: if (lease -> on_commit) {
1190: if (comp -> on_commit)
1191: executable_statement_dereference (&comp -> on_commit,
1192: MDL);
1193: executable_statement_reference (&comp -> on_commit,
1194: lease -> on_commit,
1195: MDL);
1196: }
1197: if (lease -> on_release) {
1198: if (comp -> on_release)
1199: executable_statement_dereference (&comp -> on_release,
1200: MDL);
1201: executable_statement_reference (&comp -> on_release,
1202: lease -> on_release, MDL);
1203: }
1204:
1205: /* Record the lease in the uid hash if necessary. */
1206: if (comp->uid)
1207: uid_hash_add(comp);
1208:
1209: /* Record it in the hardware address hash if necessary. */
1210: if (comp->hardware_addr.hlen)
1211: hw_hash_add(comp);
1212:
1213: comp->cltt = lease->cltt;
1214: #if defined (FAILOVER_PROTOCOL)
1215: comp->tstp = lease->tstp;
1216: comp->tsfp = lease->tsfp;
1217: comp->atsfp = lease->atsfp;
1218: #endif /* FAILOVER_PROTOCOL */
1219: comp->ends = lease->ends;
1220: comp->next_binding_state = lease->next_binding_state;
1221:
1222: just_move_it:
1223: #if defined (FAILOVER_PROTOCOL)
1224: /* Atsfp should be cleared upon any state change that implies
1225: * propagation whether supersede_lease was given a copy lease
1226: * structure or not (often from the pool_timer()).
1227: */
1228: if (propogate)
1229: comp->atsfp = 0;
1230: #endif /* FAILOVER_PROTOCOL */
1231:
1232: if (!comp -> pool) {
1233: log_error ("Supersede_lease: lease %s with no pool.",
1234: piaddr (comp -> ip_addr));
1235: return 0;
1236: }
1237:
1238: /* Figure out which queue it's on. */
1239: switch (comp -> binding_state) {
1240: case FTS_FREE:
1241: if (comp->flags & RESERVED_LEASE)
1242: lq = &comp->pool->reserved;
1243: else {
1244: lq = &comp->pool->free;
1245: comp->pool->free_leases--;
1246: }
1247:
1248: #if defined(FAILOVER_PROTOCOL)
1249: do_pool_check = 1;
1250: #endif
1251: break;
1252:
1253: case FTS_ACTIVE:
1254: lq = &comp -> pool -> active;
1255: break;
1256:
1257: case FTS_EXPIRED:
1258: case FTS_RELEASED:
1259: case FTS_RESET:
1260: lq = &comp -> pool -> expired;
1261: break;
1262:
1263: case FTS_ABANDONED:
1264: lq = &comp -> pool -> abandoned;
1265: break;
1266:
1267: case FTS_BACKUP:
1268: if (comp->flags & RESERVED_LEASE)
1269: lq = &comp->pool->reserved;
1270: else {
1271: lq = &comp->pool->backup;
1272: comp->pool->backup_leases--;
1273: }
1274:
1275: #if defined(FAILOVER_PROTOCOL)
1276: do_pool_check = 1;
1277: #endif
1278: break;
1279:
1280: default:
1281: log_error ("Lease with bogus binding state: %d",
1282: comp -> binding_state);
1283: #if defined (BINDING_STATE_DEBUG)
1284: abort ();
1285: #endif
1286: return 0;
1287: }
1288:
1289: /* Remove the lease from its current place in its current
1290: timer sequence. */
1291: /* XXX this is horrid. */
1292: prev = (struct lease *)0;
1293: for (lp = *lq; lp; lp = lp -> next) {
1294: if (lp == comp)
1295: break;
1296: prev = lp;
1297: }
1298:
1299: if (!lp) {
1300: log_fatal("Lease with binding state %s not on its queue.",
1301: (comp->binding_state < 1 ||
1302: comp->binding_state > FTS_LAST)
1303: ? "unknown"
1304: : binding_state_names[comp->binding_state - 1]);
1305: }
1306:
1307: if (prev) {
1308: lease_dereference (&prev -> next, MDL);
1309: if (comp -> next) {
1310: lease_reference (&prev -> next, comp -> next, MDL);
1311: lease_dereference (&comp -> next, MDL);
1312: }
1313: } else {
1314: lease_dereference (lq, MDL);
1315: if (comp -> next) {
1316: lease_reference (lq, comp -> next, MDL);
1317: lease_dereference (&comp -> next, MDL);
1318: }
1319: }
1320:
1321: /* Make the state transition. */
1322: if (commit || !pimmediate)
1323: make_binding_state_transition (comp);
1324:
1325: /* Put the lease back on the appropriate queue. If the lease
1326: is corrupt (as detected by lease_enqueue), don't go any farther. */
1327: if (!lease_enqueue (comp))
1328: return 0;
1329:
1330: /* If this is the next lease that will timeout on the pool,
1331: zap the old timeout and set the timeout on this pool to the
1332: time that the lease's next event will happen.
1333:
1334: We do not actually set the timeout unless commit is true -
1335: we don't want to thrash the timer queue when reading the
1336: lease database. Instead, the database code calls the
1337: expiry event on each pool after reading in the lease file,
1338: and the expiry code sets the timer if there's anything left
1339: to expire after it's run any outstanding expiry events on
1340: the pool. */
1341: if ((commit || !pimmediate) &&
1342: comp -> sort_time != MIN_TIME &&
1343: comp -> sort_time > cur_time &&
1344: (comp -> sort_time < comp -> pool -> next_event_time ||
1345: comp -> pool -> next_event_time == MIN_TIME)) {
1346: comp -> pool -> next_event_time = comp -> sort_time;
1347: tv . tv_sec = comp -> pool -> next_event_time;
1348: tv . tv_usec = 0;
1349: add_timeout (&tv,
1350: pool_timer, comp -> pool,
1351: (tvref_t)pool_reference,
1352: (tvunref_t)pool_dereference);
1353: }
1354:
1355: if (commit) {
1356: if (!write_lease (comp))
1357: return 0;
1358: if ((server_starting & SS_NOSYNC) == 0) {
1359: if (!commit_leases ())
1360: return 0;
1361: }
1362: }
1363:
1364: #if defined (FAILOVER_PROTOCOL)
1365: if (propogate) {
1366: comp -> desired_binding_state = comp -> binding_state;
1367: if (!dhcp_failover_queue_update (comp, pimmediate))
1368: return 0;
1369: }
1370: if (do_pool_check && comp->pool->failover_peer)
1371: dhcp_failover_pool_check(comp->pool);
1372: #endif
1373:
1374: /* If the current binding state has already expired, do an
1375: expiry event right now. */
1376: /* XXX At some point we should optimize this so that we don't
1377: XXX write the lease twice, but this is a safe way to fix the
1378: XXX problem for 3.0 (I hope!). */
1379: if ((commit || !pimmediate) &&
1380: comp -> sort_time < cur_time &&
1381: comp -> next_binding_state != comp -> binding_state)
1382: pool_timer (comp -> pool);
1383:
1384: return 1;
1385: }
1386:
1387: void make_binding_state_transition (struct lease *lease)
1388: {
1389: #if defined (FAILOVER_PROTOCOL)
1390: dhcp_failover_state_t *peer;
1391:
1392: if (lease && lease -> pool && lease -> pool -> failover_peer)
1393: peer = lease -> pool -> failover_peer;
1394: else
1395: peer = (dhcp_failover_state_t *)0;
1396: #endif
1397:
1398: /* If the lease was active and is now no longer active, but isn't
1399: released, then it just expired, so do the expiry event. */
1400: if (lease -> next_binding_state != lease -> binding_state &&
1401: ((
1402: #if defined (FAILOVER_PROTOCOL)
1403: peer &&
1404: (lease -> binding_state == FTS_EXPIRED ||
1405: (peer -> i_am == secondary &&
1406: lease -> binding_state == FTS_ACTIVE)) &&
1407: (lease -> next_binding_state == FTS_FREE ||
1408: lease -> next_binding_state == FTS_BACKUP)) ||
1409: (!peer &&
1410: #endif
1411: lease -> binding_state == FTS_ACTIVE &&
1412: lease -> next_binding_state != FTS_RELEASED))) {
1413: #if defined (NSUPDATE)
1414: ddns_removals(lease, NULL);
1415: #endif
1416: if (lease -> on_expiry) {
1417: execute_statements ((struct binding_value **)0,
1418: (struct packet *)0, lease,
1419: (struct client_state *)0,
1420: (struct option_state *)0,
1421: (struct option_state *)0, /* XXX */
1422: &lease -> scope,
1423: lease -> on_expiry);
1424: if (lease -> on_expiry)
1425: executable_statement_dereference
1426: (&lease -> on_expiry, MDL);
1427: }
1428:
1429: /* No sense releasing a lease after it's expired. */
1430: if (lease -> on_release)
1431: executable_statement_dereference (&lease -> on_release,
1432: MDL);
1433: /* Get rid of client-specific bindings that are only
1434: correct when the lease is active. */
1435: if (lease -> billing_class)
1436: unbill_class (lease, lease -> billing_class);
1437: if (lease -> agent_options)
1438: option_chain_head_dereference (&lease -> agent_options,
1439: MDL);
1440: if (lease -> client_hostname) {
1441: dfree (lease -> client_hostname, MDL);
1442: lease -> client_hostname = (char *)0;
1443: }
1444: if (lease -> host)
1445: host_dereference (&lease -> host, MDL);
1446:
1447: /* Send the expiry time to the peer. */
1448: lease -> tstp = lease -> ends;
1449: }
1450:
1451: /* If the lease was active and is now released, do the release
1452: event. */
1453: if (lease -> next_binding_state != lease -> binding_state &&
1454: ((
1455: #if defined (FAILOVER_PROTOCOL)
1456: peer &&
1457: lease -> binding_state == FTS_RELEASED &&
1458: (lease -> next_binding_state == FTS_FREE ||
1459: lease -> next_binding_state == FTS_BACKUP)) ||
1460: (!peer &&
1461: #endif
1462: lease -> binding_state == FTS_ACTIVE &&
1463: lease -> next_binding_state == FTS_RELEASED))) {
1464: #if defined (NSUPDATE)
1465: /*
1466: * Note: ddns_removals() is also iterated when the lease
1467: * enters state 'released' in 'release_lease()'. The below
1468: * is caught when a peer receives a BNDUPD from a failover
1469: * peer; it may not have received the client's release (it
1470: * may have been offline).
1471: *
1472: * We could remove the call from release_lease() because
1473: * it will also catch here on the originating server after the
1474: * peer acknowledges the state change. However, there could
1475: * be many hours inbetween, and in this case we /know/ the
1476: * client is no longer using the lease when we receive the
1477: * release message. This is not true of expiry, where the
1478: * peer may have extended the lease.
1479: */
1480: ddns_removals(lease, NULL);
1481: #endif
1482: if (lease -> on_release) {
1483: execute_statements ((struct binding_value **)0,
1484: (struct packet *)0, lease,
1485: (struct client_state *)0,
1486: (struct option_state *)0,
1487: (struct option_state *)0, /* XXX */
1488: &lease -> scope,
1489: lease -> on_release);
1490: executable_statement_dereference (&lease -> on_release,
1491: MDL);
1492: }
1493:
1494: /* A released lease can't expire. */
1495: if (lease -> on_expiry)
1496: executable_statement_dereference (&lease -> on_expiry,
1497: MDL);
1498:
1499: /* Get rid of client-specific bindings that are only
1500: correct when the lease is active. */
1501: if (lease -> billing_class)
1502: unbill_class (lease, lease -> billing_class);
1503: if (lease -> agent_options)
1504: option_chain_head_dereference (&lease -> agent_options,
1505: MDL);
1506: if (lease -> client_hostname) {
1507: dfree (lease -> client_hostname, MDL);
1508: lease -> client_hostname = (char *)0;
1509: }
1510: if (lease -> host)
1511: host_dereference (&lease -> host, MDL);
1512:
1513: /* Send the release time (should be == cur_time) to the
1514: peer. */
1515: lease -> tstp = lease -> ends;
1516: }
1517:
1518: #if defined (DEBUG_LEASE_STATE_TRANSITIONS)
1519: log_debug ("lease %s moves from %s to %s",
1520: piaddr (lease -> ip_addr),
1521: binding_state_print (lease -> binding_state),
1522: binding_state_print (lease -> next_binding_state));
1523: #endif
1524:
1525: lease -> binding_state = lease -> next_binding_state;
1526: switch (lease -> binding_state) {
1527: case FTS_ACTIVE:
1528: #if defined (FAILOVER_PROTOCOL)
1529: if (lease -> pool && lease -> pool -> failover_peer)
1530: lease -> next_binding_state = FTS_EXPIRED;
1531: else
1532: #endif
1533: lease -> next_binding_state = FTS_FREE;
1534: break;
1535:
1536: case FTS_EXPIRED:
1537: case FTS_RELEASED:
1538: case FTS_ABANDONED:
1539: case FTS_RESET:
1540: lease -> next_binding_state = FTS_FREE;
1541: #if defined(FAILOVER_PROTOCOL)
1542: /* If we are not in partner_down, leases don't go from
1543: EXPIRED to FREE on a timeout - only on an update.
1544: If we're in partner_down, they expire at mclt past
1545: the time we entered partner_down. */
1546: if (lease -> pool -> failover_peer &&
1547: lease -> pool -> failover_peer -> me.state == partner_down)
1548: lease -> tsfp =
1549: (lease -> pool -> failover_peer -> me.stos +
1550: lease -> pool -> failover_peer -> mclt);
1551: #endif /* FAILOVER_PROTOCOL */
1552: break;
1553:
1554: case FTS_FREE:
1555: case FTS_BACKUP:
1556: lease -> next_binding_state = lease -> binding_state;
1557: break;
1558: }
1559: #if defined (DEBUG_LEASE_STATE_TRANSITIONS)
1560: log_debug ("lease %s: next binding state %s",
1561: piaddr (lease -> ip_addr),
1562: binding_state_print (lease -> next_binding_state));
1563: #endif
1564:
1565: }
1566:
1567: /* Copy the contents of one lease into another, correctly maintaining
1568: reference counts. */
1569: int lease_copy (struct lease **lp,
1570: struct lease *lease, const char *file, int line)
1571: {
1572: struct lease *lt = (struct lease *)0;
1573: isc_result_t status;
1574:
1575: status = lease_allocate (<, MDL);
1576: if (status != ISC_R_SUCCESS)
1577: return 0;
1578:
1579: lt -> ip_addr = lease -> ip_addr;
1580: lt -> starts = lease -> starts;
1581: lt -> ends = lease -> ends;
1582: lt -> uid_len = lease -> uid_len;
1583: lt -> uid_max = lease -> uid_max;
1584: if (lease -> uid == lease -> uid_buf) {
1585: lt -> uid = lt -> uid_buf;
1586: memcpy (lt -> uid_buf, lease -> uid_buf, sizeof lt -> uid_buf);
1587: } else if (!lease -> uid_max) {
1588: lt -> uid = (unsigned char *)0;
1589: } else {
1590: lt -> uid = dmalloc (lt -> uid_max, MDL);
1591: if (!lt -> uid) {
1592: lease_dereference (<, MDL);
1593: return 0;
1594: }
1595: memcpy (lt -> uid, lease -> uid, lease -> uid_max);
1596: }
1597: if (lease -> client_hostname) {
1598: lt -> client_hostname =
1599: dmalloc (strlen (lease -> client_hostname) + 1, MDL);
1600: if (!lt -> client_hostname) {
1601: lease_dereference (<, MDL);
1602: return 0;
1603: }
1604: strcpy (lt -> client_hostname, lease -> client_hostname);
1605: }
1606: if (lease -> scope)
1607: binding_scope_reference (< -> scope, lease -> scope, MDL);
1608: if (lease -> agent_options)
1609: option_chain_head_reference (< -> agent_options,
1610: lease -> agent_options, MDL);
1611: host_reference (< -> host, lease -> host, file, line);
1612: subnet_reference (< -> subnet, lease -> subnet, file, line);
1613: pool_reference (< -> pool, lease -> pool, file, line);
1614: class_reference (< -> billing_class,
1615: lease -> billing_class, file, line);
1616: lt -> hardware_addr = lease -> hardware_addr;
1617: if (lease -> on_expiry)
1618: executable_statement_reference (< -> on_expiry,
1619: lease -> on_expiry,
1620: file, line);
1621: if (lease -> on_commit)
1622: executable_statement_reference (< -> on_commit,
1623: lease -> on_commit,
1624: file, line);
1625: if (lease -> on_release)
1626: executable_statement_reference (< -> on_release,
1627: lease -> on_release,
1628: file, line);
1629: lt->flags = lease->flags;
1630: lt->tstp = lease->tstp;
1631: lt->tsfp = lease->tsfp;
1632: lt->atsfp = lease->atsfp;
1633: lt->cltt = lease -> cltt;
1634: lt->binding_state = lease->binding_state;
1635: lt->next_binding_state = lease->next_binding_state;
1636: status = lease_reference(lp, lt, file, line);
1637: lease_dereference(<, MDL);
1638: return status == ISC_R_SUCCESS;
1639: }
1640:
1641: /* Release the specified lease and re-hash it as appropriate. */
1642: void release_lease (lease, packet)
1643: struct lease *lease;
1644: struct packet *packet;
1645: {
1646: /* If there are statements to execute when the lease is
1647: released, execute them. */
1648: #if defined (NSUPDATE)
1649: ddns_removals(lease, NULL);
1650: #endif
1651: if (lease -> on_release) {
1652: execute_statements ((struct binding_value **)0,
1653: packet, lease, (struct client_state *)0,
1654: packet -> options,
1655: (struct option_state *)0, /* XXX */
1656: &lease -> scope, lease -> on_release);
1657: if (lease -> on_release)
1658: executable_statement_dereference (&lease -> on_release,
1659: MDL);
1660: }
1661:
1662: /* We do either the on_release or the on_expiry events, but
1663: not both (it's possible that they could be the same,
1664: in any case). */
1665: if (lease -> on_expiry)
1666: executable_statement_dereference (&lease -> on_expiry, MDL);
1667:
1668: if (lease -> binding_state != FTS_FREE &&
1669: lease -> binding_state != FTS_BACKUP &&
1670: lease -> binding_state != FTS_RELEASED &&
1671: lease -> binding_state != FTS_EXPIRED &&
1672: lease -> binding_state != FTS_RESET) {
1673: if (lease -> on_commit)
1674: executable_statement_dereference (&lease -> on_commit,
1675: MDL);
1676:
1677: /* Blow away any bindings. */
1678: if (lease -> scope)
1679: binding_scope_dereference (&lease -> scope, MDL);
1680:
1681: /* Set sort times to the present. */
1682: lease -> ends = cur_time;
1683: /* Lower layers of muckery set tstp to ->ends. But we send
1684: * protocol messages before this. So it is best to set
1685: * tstp now anyway.
1686: */
1687: lease->tstp = cur_time;
1688: #if defined (FAILOVER_PROTOCOL)
1689: if (lease -> pool && lease -> pool -> failover_peer) {
1690: lease -> next_binding_state = FTS_RELEASED;
1691: } else {
1692: lease -> next_binding_state = FTS_FREE;
1693: }
1694: #else
1695: lease -> next_binding_state = FTS_FREE;
1696: #endif
1697: supersede_lease (lease, (struct lease *)0, 1, 1, 1);
1698: }
1699: }
1700:
1701: /* Abandon the specified lease (set its timeout to infinity and its
1702: particulars to zero, and re-hash it as appropriate. */
1703:
1704: void abandon_lease (lease, message)
1705: struct lease *lease;
1706: const char *message;
1707: {
1708: struct lease *lt = (struct lease *)0;
1709: #if defined (NSUPDATE)
1710: ddns_removals(lease, NULL);
1711: #endif
1712:
1713: if (!lease_copy (<, lease, MDL))
1714: return;
1715:
1716: if (lt->scope)
1717: binding_scope_dereference(<->scope, MDL);
1718:
1719: lt -> ends = cur_time; /* XXX */
1720: lt -> next_binding_state = FTS_ABANDONED;
1721:
1722: log_error ("Abandoning IP address %s: %s",
1723: piaddr (lease -> ip_addr), message);
1724: lt -> hardware_addr.hlen = 0;
1725: if (lt -> uid && lt -> uid != lt -> uid_buf)
1726: dfree (lt -> uid, MDL);
1727: lt -> uid = (unsigned char *)0;
1728: lt -> uid_len = 0;
1729: lt -> uid_max = 0;
1730: supersede_lease (lease, lt, 1, 1, 1);
1731: lease_dereference (<, MDL);
1732: }
1733:
1734: /* Abandon the specified lease (set its timeout to infinity and its
1735: particulars to zero, and re-hash it as appropriate. */
1736:
1737: void dissociate_lease (lease)
1738: struct lease *lease;
1739: {
1740: struct lease *lt = (struct lease *)0;
1741: #if defined (NSUPDATE)
1742: ddns_removals(lease, NULL);
1743: #endif
1744:
1745: if (!lease_copy (<, lease, MDL))
1746: return;
1747:
1748: #if defined (FAILOVER_PROTOCOL)
1749: if (lease -> pool && lease -> pool -> failover_peer) {
1750: lt -> next_binding_state = FTS_RESET;
1751: } else {
1752: lt -> next_binding_state = FTS_FREE;
1753: }
1754: #else
1755: lt -> next_binding_state = FTS_FREE;
1756: #endif
1757: lt -> ends = cur_time; /* XXX */
1758: lt -> hardware_addr.hlen = 0;
1759: if (lt -> uid && lt -> uid != lt -> uid_buf)
1760: dfree (lt -> uid, MDL);
1761: lt -> uid = (unsigned char *)0;
1762: lt -> uid_len = 0;
1763: lt -> uid_max = 0;
1764: supersede_lease (lease, lt, 1, 1, 1);
1765: lease_dereference (<, MDL);
1766: }
1767:
1768: /* Timer called when a lease in a particular pool expires. */
1769: void pool_timer (vpool)
1770: void *vpool;
1771: {
1772: struct pool *pool;
1773: struct lease *next = (struct lease *)0;
1774: struct lease *lease = (struct lease *)0;
1775: #define FREE_LEASES 0
1776: #define ACTIVE_LEASES 1
1777: #define EXPIRED_LEASES 2
1778: #define ABANDONED_LEASES 3
1779: #define BACKUP_LEASES 4
1780: #define RESERVED_LEASES 5
1781: struct lease **lptr[RESERVED_LEASES+1];
1782: TIME next_expiry = MAX_TIME;
1783: int i;
1784: struct timeval tv;
1785:
1786: pool = (struct pool *)vpool;
1787:
1788: lptr [FREE_LEASES] = &pool -> free;
1789: lptr [ACTIVE_LEASES] = &pool -> active;
1790: lptr [EXPIRED_LEASES] = &pool -> expired;
1791: lptr [ABANDONED_LEASES] = &pool -> abandoned;
1792: lptr [BACKUP_LEASES] = &pool -> backup;
1793: lptr[RESERVED_LEASES] = &pool->reserved;
1794:
1795: for (i = FREE_LEASES; i <= RESERVED_LEASES; i++) {
1796: /* If there's nothing on the queue, skip it. */
1797: if (!*(lptr [i]))
1798: continue;
1799:
1800: #if defined (FAILOVER_PROTOCOL)
1801: if (pool -> failover_peer &&
1802: pool -> failover_peer -> me.state != partner_down) {
1803: /* The secondary can't remove a lease from the
1804: active state except in partner_down. */
1805: if (i == ACTIVE_LEASES &&
1806: pool -> failover_peer -> i_am == secondary)
1807: continue;
1808: /* Leases in an expired state don't move to
1809: free because of a timeout unless we're in
1810: partner_down. */
1811: if (i == EXPIRED_LEASES)
1812: continue;
1813: }
1814: #endif
1815: lease_reference (&lease, *(lptr [i]), MDL);
1816:
1817: while (lease) {
1818: /* Remember the next lease in the list. */
1819: if (next)
1820: lease_dereference (&next, MDL);
1821: if (lease -> next)
1822: lease_reference (&next, lease -> next, MDL);
1823:
1824: /* If we've run out of things to expire on this list,
1825: stop. */
1826: if (lease -> sort_time > cur_time) {
1827: if (lease -> sort_time < next_expiry)
1828: next_expiry = lease -> sort_time;
1829: break;
1830: }
1831:
1832: /* If there is a pending state change, and
1833: this lease has gotten to the time when the
1834: state change should happen, just call
1835: supersede_lease on it to make the change
1836: happen. */
1837: if (lease -> next_binding_state !=
1838: lease -> binding_state)
1839: supersede_lease (lease,
1840: (struct lease *)0, 1, 1, 1);
1841:
1842: lease_dereference (&lease, MDL);
1843: if (next)
1844: lease_reference (&lease, next, MDL);
1845: }
1846: if (next)
1847: lease_dereference (&next, MDL);
1848: if (lease)
1849: lease_dereference (&lease, MDL);
1850: }
1851: if (next_expiry != MAX_TIME) {
1852: pool -> next_event_time = next_expiry;
1853: tv . tv_sec = pool -> next_event_time;
1854: tv . tv_usec = 0;
1855: add_timeout (&tv, pool_timer, pool,
1856: (tvref_t)pool_reference,
1857: (tvunref_t)pool_dereference);
1858: } else
1859: pool -> next_event_time = MIN_TIME;
1860:
1861: }
1862:
1863: /* Locate the lease associated with a given IP address... */
1864:
1865: int find_lease_by_ip_addr (struct lease **lp, struct iaddr addr,
1866: const char *file, int line)
1867: {
1868: return lease_ip_hash_lookup(lp, lease_ip_addr_hash, addr.iabuf,
1869: addr.len, file, line);
1870: }
1871:
1872: int find_lease_by_uid (struct lease **lp, const unsigned char *uid,
1873: unsigned len, const char *file, int line)
1874: {
1875: if (len == 0)
1876: return 0;
1877: return lease_id_hash_lookup (lp, lease_uid_hash, uid, len, file, line);
1878: }
1879:
1880: int find_lease_by_hw_addr (struct lease **lp,
1881: const unsigned char *hwaddr, unsigned hwlen,
1882: const char *file, int line)
1883: {
1884: if (hwlen == 0)
1885: return 0;
1886: return lease_id_hash_lookup(lp, lease_hw_addr_hash, hwaddr, hwlen,
1887: file, line);
1888: }
1889:
1890: /* If the lease is preferred over the candidate, return truth. The
1891: * 'cand' and 'lease' names are retained to read more clearly against
1892: * the 'uid_hash_add' and 'hw_hash_add' functions (this is common logic
1893: * to those two functions).
1894: *
1895: * 1) ACTIVE leases are preferred. The active lease with
1896: * the longest lifetime is preferred over shortest.
1897: * 2) "transitional states" are next, this time with the
1898: * most recent CLTT.
1899: * 3) free/backup/etc states are next, again with CLTT. In truth we
1900: * should never see reset leases for this.
1901: * 4) Abandoned leases are always dead last.
1902: */
1903: static isc_boolean_t
1904: client_lease_preferred(struct lease *cand, struct lease *lease)
1905: {
1906: if (cand->binding_state == FTS_ACTIVE) {
1907: if (lease->binding_state == FTS_ACTIVE &&
1908: lease->ends >= cand->ends)
1909: return ISC_TRUE;
1910: } else if (cand->binding_state == FTS_EXPIRED ||
1911: cand->binding_state == FTS_RELEASED) {
1912: if (lease->binding_state == FTS_ACTIVE)
1913: return ISC_TRUE;
1914:
1915: if ((lease->binding_state == FTS_EXPIRED ||
1916: lease->binding_state == FTS_RELEASED) &&
1917: lease->cltt >= cand->cltt)
1918: return ISC_TRUE;
1919: } else if (cand->binding_state != FTS_ABANDONED) {
1920: if (lease->binding_state == FTS_ACTIVE ||
1921: lease->binding_state == FTS_EXPIRED ||
1922: lease->binding_state == FTS_RELEASED)
1923: return ISC_TRUE;
1924:
1925: if (lease->binding_state != FTS_ABANDONED &&
1926: lease->cltt >= cand->cltt)
1927: return ISC_TRUE;
1928: } else /* (cand->binding_state == FTS_ABANDONED) */ {
1929: if (lease->binding_state != FTS_ABANDONED ||
1930: lease->cltt >= cand->cltt)
1931: return ISC_TRUE;
1932: }
1933:
1934: return ISC_FALSE;
1935: }
1936:
1937: /* Add the specified lease to the uid hash. */
1938: void
1939: uid_hash_add(struct lease *lease)
1940: {
1941: struct lease *head = NULL;
1942: struct lease *cand = NULL;
1943: struct lease *prev = NULL;
1944: struct lease *next = NULL;
1945:
1946: /* If it's not in the hash, just add it. */
1947: if (!find_lease_by_uid (&head, lease -> uid, lease -> uid_len, MDL))
1948: lease_id_hash_add(lease_uid_hash, lease->uid, lease->uid_len,
1949: lease, MDL);
1950: else {
1951: /* Otherwise, insert it into the list in order of its
1952: * preference for "resuming allocation to the client."
1953: *
1954: * Because we don't have control of the hash bucket index
1955: * directly, we have to remove and re-insert the client
1956: * id into the hash if we're inserting onto the head.
1957: */
1958: lease_reference(&cand, head, MDL);
1959: while (cand != NULL) {
1960: if (client_lease_preferred(cand, lease))
1961: break;
1962:
1963: if (prev != NULL)
1964: lease_dereference(&prev, MDL);
1965: lease_reference(&prev, cand, MDL);
1966:
1967: if (cand->n_uid != NULL)
1968: lease_reference(&next, cand->n_uid, MDL);
1969:
1970: lease_dereference(&cand, MDL);
1971:
1972: if (next != NULL) {
1973: lease_reference(&cand, next, MDL);
1974: lease_dereference(&next, MDL);
1975: }
1976: }
1977:
1978: /* If we want to insert 'before cand', and prev is NULL,
1979: * then it was the head of the list. Assume that position.
1980: */
1981: if (prev == NULL) {
1982: lease_reference(&lease->n_uid, head, MDL);
1983: lease_id_hash_delete(lease_uid_hash, lease->uid,
1984: lease->uid_len, MDL);
1985: lease_id_hash_add(lease_uid_hash, lease->uid,
1986: lease->uid_len, lease, MDL);
1987: } else /* (prev != NULL) */ {
1988: if(prev->n_uid != NULL) {
1989: lease_reference(&lease->n_uid, prev->n_uid,
1990: MDL);
1991: lease_dereference(&prev->n_uid, MDL);
1992: }
1993: lease_reference(&prev->n_uid, lease, MDL);
1994:
1995: lease_dereference(&prev, MDL);
1996: }
1997:
1998: if (cand != NULL)
1999: lease_dereference(&cand, MDL);
2000: lease_dereference(&head, MDL);
2001: }
2002: }
2003:
2004: /* Delete the specified lease from the uid hash. */
2005:
2006: void uid_hash_delete (lease)
2007: struct lease *lease;
2008: {
2009: struct lease *head = (struct lease *)0;
2010: struct lease *scan;
2011:
2012: /* If it's not in the hash, we have no work to do. */
2013: if (!find_lease_by_uid (&head, lease -> uid, lease -> uid_len, MDL)) {
2014: if (lease -> n_uid)
2015: lease_dereference (&lease -> n_uid, MDL);
2016: return;
2017: }
2018:
2019: /* If the lease we're freeing is at the head of the list,
2020: remove the hash table entry and add a new one with the
2021: next lease on the list (if there is one). */
2022: if (head == lease) {
2023: lease_id_hash_delete(lease_uid_hash, lease->uid,
2024: lease->uid_len, MDL);
2025: if (lease -> n_uid) {
2026: lease_id_hash_add(lease_uid_hash, lease->n_uid->uid,
2027: lease->n_uid->uid_len, lease->n_uid,
2028: MDL);
2029: lease_dereference (&lease -> n_uid, MDL);
2030: }
2031: } else {
2032: /* Otherwise, look for the lease in the list of leases
2033: attached to the hash table entry, and remove it if
2034: we find it. */
2035: for (scan = head; scan -> n_uid; scan = scan -> n_uid) {
2036: if (scan -> n_uid == lease) {
2037: lease_dereference (&scan -> n_uid, MDL);
2038: if (lease -> n_uid) {
2039: lease_reference (&scan -> n_uid,
2040: lease -> n_uid, MDL);
2041: lease_dereference (&lease -> n_uid,
2042: MDL);
2043: }
2044: break;
2045: }
2046: }
2047: }
2048: lease_dereference (&head, MDL);
2049: }
2050:
2051: /* Add the specified lease to the hardware address hash. */
2052:
2053: void
2054: hw_hash_add(struct lease *lease)
2055: {
2056: struct lease *head = NULL;
2057: struct lease *cand = NULL;
2058: struct lease *prev = NULL;
2059: struct lease *next = NULL;
2060:
2061: /* If it's not in the hash, just add it. */
2062: if (!find_lease_by_hw_addr (&head, lease -> hardware_addr.hbuf,
2063: lease -> hardware_addr.hlen, MDL))
2064: lease_id_hash_add(lease_hw_addr_hash,
2065: lease->hardware_addr.hbuf,
2066: lease->hardware_addr.hlen, lease, MDL);
2067: else {
2068: /* Otherwise, insert it into the list in order of its
2069: * preference for "resuming allocation to the client."
2070: *
2071: * Because we don't have control of the hash bucket index
2072: * directly, we have to remove and re-insert the client
2073: * id into the hash if we're inserting onto the head.
2074: */
2075: lease_reference(&cand, head, MDL);
2076: while (cand != NULL) {
2077: if (client_lease_preferred(cand, lease))
2078: break;
2079:
2080: if (prev != NULL)
2081: lease_dereference(&prev, MDL);
2082: lease_reference(&prev, cand, MDL);
2083:
2084: if (cand->n_hw != NULL)
2085: lease_reference(&next, cand->n_hw, MDL);
2086:
2087: lease_dereference(&cand, MDL);
2088:
2089: if (next != NULL) {
2090: lease_reference(&cand, next, MDL);
2091: lease_dereference(&next, MDL);
2092: }
2093: }
2094:
2095: /* If we want to insert 'before cand', and prev is NULL,
2096: * then it was the head of the list. Assume that position.
2097: */
2098: if (prev == NULL) {
2099: lease_reference(&lease->n_hw, head, MDL);
2100: lease_id_hash_delete(lease_hw_addr_hash,
2101: lease->hardware_addr.hbuf,
2102: lease->hardware_addr.hlen, MDL);
2103: lease_id_hash_add(lease_hw_addr_hash,
2104: lease->hardware_addr.hbuf,
2105: lease->hardware_addr.hlen,
2106: lease, MDL);
2107: } else /* (prev != NULL) */ {
2108: if(prev->n_hw != NULL) {
2109: lease_reference(&lease->n_hw, prev->n_hw,
2110: MDL);
2111: lease_dereference(&prev->n_hw, MDL);
2112: }
2113: lease_reference(&prev->n_hw, lease, MDL);
2114:
2115: lease_dereference(&prev, MDL);
2116: }
2117:
2118: if (cand != NULL)
2119: lease_dereference(&cand, MDL);
2120: lease_dereference(&head, MDL);
2121: }
2122: }
2123:
2124: /* Delete the specified lease from the hardware address hash. */
2125:
2126: void hw_hash_delete (lease)
2127: struct lease *lease;
2128: {
2129: struct lease *head = (struct lease *)0;
2130: struct lease *next = (struct lease *)0;
2131:
2132: /* If it's not in the hash, we have no work to do. */
2133: if (!find_lease_by_hw_addr (&head, lease -> hardware_addr.hbuf,
2134: lease -> hardware_addr.hlen, MDL)) {
2135: if (lease -> n_hw)
2136: lease_dereference (&lease -> n_hw, MDL);
2137: return;
2138: }
2139:
2140: /* If the lease we're freeing is at the head of the list,
2141: remove the hash table entry and add a new one with the
2142: next lease on the list (if there is one). */
2143: if (head == lease) {
2144: lease_id_hash_delete(lease_hw_addr_hash,
2145: lease->hardware_addr.hbuf,
2146: lease->hardware_addr.hlen, MDL);
2147: if (lease->n_hw) {
2148: lease_id_hash_add(lease_hw_addr_hash,
2149: lease->n_hw->hardware_addr.hbuf,
2150: lease->n_hw->hardware_addr.hlen,
2151: lease->n_hw, MDL);
2152: lease_dereference(&lease->n_hw, MDL);
2153: }
2154: } else {
2155: /* Otherwise, look for the lease in the list of leases
2156: attached to the hash table entry, and remove it if
2157: we find it. */
2158: while (head -> n_hw) {
2159: if (head -> n_hw == lease) {
2160: lease_dereference (&head -> n_hw, MDL);
2161: if (lease -> n_hw) {
2162: lease_reference (&head -> n_hw,
2163: lease -> n_hw, MDL);
2164: lease_dereference (&lease -> n_hw,
2165: MDL);
2166: }
2167: break;
2168: }
2169: lease_reference (&next, head -> n_hw, MDL);
2170: lease_dereference (&head, MDL);
2171: lease_reference (&head, next, MDL);
2172: lease_dereference (&next, MDL);
2173: }
2174: }
2175: if (head)
2176: lease_dereference (&head, MDL);
2177: }
2178:
2179: /* Write all interesting leases to permanent storage. */
2180:
2181: int write_leases ()
2182: {
2183: struct lease *l;
2184: struct shared_network *s;
2185: struct pool *p;
2186: struct host_decl *hp;
2187: struct group_object *gp;
2188: struct hash_bucket *hb;
2189: struct class *cp;
2190: struct collection *colp;
2191: int i;
2192: int num_written;
2193: struct lease **lptr[RESERVED_LEASES+1];
2194:
2195: /* write all the dynamically-created class declarations. */
2196: if (collections->classes) {
2197: numclasseswritten = 0;
2198: for (colp = collections ; colp ; colp = colp->next) {
2199: for (cp = colp->classes ; cp ; cp = cp->nic) {
2200: write_named_billing_class(
2201: (unsigned char *)cp->name,
2202: 0, cp);
2203: }
2204: }
2205:
2206: /* XXXJAB this number doesn't include subclasses... */
2207: log_info ("Wrote %d class decls to leases file.",
2208: numclasseswritten);
2209: }
2210:
2211:
2212: /* Write all the dynamically-created group declarations. */
2213: if (group_name_hash) {
2214: num_written = 0;
2215: for (i = 0; i < group_name_hash -> hash_count; i++) {
2216: for (hb = group_name_hash -> buckets [i];
2217: hb; hb = hb -> next) {
2218: gp = (struct group_object *)hb -> value;
2219: if ((gp -> flags & GROUP_OBJECT_DYNAMIC) ||
2220: ((gp -> flags & GROUP_OBJECT_STATIC) &&
2221: (gp -> flags & GROUP_OBJECT_DELETED))) {
2222: if (!write_group (gp))
2223: return 0;
2224: ++num_written;
2225: }
2226: }
2227: }
2228: log_info ("Wrote %d group decls to leases file.", num_written);
2229: }
2230:
2231: /* Write all the deleted host declarations. */
2232: if (host_name_hash) {
2233: num_written = 0;
2234: for (i = 0; i < host_name_hash -> hash_count; i++) {
2235: for (hb = host_name_hash -> buckets [i];
2236: hb; hb = hb -> next) {
2237: hp = (struct host_decl *)hb -> value;
2238: if (((hp -> flags & HOST_DECL_STATIC) &&
2239: (hp -> flags & HOST_DECL_DELETED))) {
2240: if (!write_host (hp))
2241: return 0;
2242: ++num_written;
2243: }
2244: }
2245: }
2246: log_info ("Wrote %d deleted host decls to leases file.",
2247: num_written);
2248: }
2249:
2250: /* Write all the new, dynamic host declarations. */
2251: if (host_name_hash) {
2252: num_written = 0;
2253: for (i = 0; i < host_name_hash -> hash_count; i++) {
2254: for (hb = host_name_hash -> buckets [i];
2255: hb; hb = hb -> next) {
2256: hp = (struct host_decl *)hb -> value;
2257: if ((hp -> flags & HOST_DECL_DYNAMIC)) {
2258: if (!write_host (hp))
2259: ++num_written;
2260: }
2261: }
2262: }
2263: log_info ("Wrote %d new dynamic host decls to leases file.",
2264: num_written);
2265: }
2266:
2267: #if defined (FAILOVER_PROTOCOL)
2268: /* Write all the failover states. */
2269: if (!dhcp_failover_write_all_states ())
2270: return 0;
2271: #endif
2272:
2273: /* Write all the leases. */
2274: num_written = 0;
2275: for (s = shared_networks; s; s = s -> next) {
2276: for (p = s -> pools; p; p = p -> next) {
2277: lptr [FREE_LEASES] = &p -> free;
2278: lptr [ACTIVE_LEASES] = &p -> active;
2279: lptr [EXPIRED_LEASES] = &p -> expired;
2280: lptr [ABANDONED_LEASES] = &p -> abandoned;
2281: lptr [BACKUP_LEASES] = &p -> backup;
2282: lptr [RESERVED_LEASES] = &p->reserved;
2283:
2284: for (i = FREE_LEASES; i <= RESERVED_LEASES; i++) {
2285: for (l = *(lptr [i]); l; l = l -> next) {
2286: #if !defined (DEBUG_DUMP_ALL_LEASES)
2287: if (l -> hardware_addr.hlen ||
2288: l -> uid_len ||
2289: (l -> binding_state != FTS_FREE))
2290: #endif
2291: {
2292: if (!write_lease (l))
2293: return 0;
2294: num_written++;
2295: }
2296: }
2297: }
2298: }
2299: }
2300: log_info ("Wrote %d leases to leases file.", num_written);
2301: #ifdef DHCPv6
2302: if (!write_leases6()) {
2303: return 0;
2304: }
2305: #endif /* DHCPv6 */
2306: if (!commit_leases ())
2307: return 0;
2308: return 1;
2309: }
2310:
2311: /* In addition to placing this lease upon a lease queue depending on its
2312: * state, it also keeps track of the number of FREE and BACKUP leases in
2313: * existence, and sets the sort_time on the lease.
2314: *
2315: * Sort_time is used in pool_timer() to determine when the lease will
2316: * bubble to the top of the list and be supersede_lease()'d into its next
2317: * state (possibly, if all goes well). Example, ACTIVE leases move to
2318: * EXPIRED state when the 'ends' value is reached, so that is its sort
2319: * time. Most queues are sorted by 'ends', since it is generally best
2320: * practice to re-use the oldest lease, to reduce address collision
2321: * chances.
2322: */
2323: int lease_enqueue (struct lease *comp)
2324: {
2325: struct lease **lq, *prev, *lp;
2326: static struct lease **last_lq = NULL;
2327: static struct lease *last_insert_point = NULL;
2328:
2329: /* No queue to put it on? */
2330: if (!comp -> pool)
2331: return 0;
2332:
2333: /* Figure out which queue it's going to. */
2334: switch (comp -> binding_state) {
2335: case FTS_FREE:
2336: if (comp->flags & RESERVED_LEASE) {
2337: lq = &comp->pool->reserved;
2338: } else {
2339: lq = &comp->pool->free;
2340: comp->pool->free_leases++;
2341: }
2342: comp -> sort_time = comp -> ends;
2343: break;
2344:
2345: case FTS_ACTIVE:
2346: lq = &comp -> pool -> active;
2347: comp -> sort_time = comp -> ends;
2348: break;
2349:
2350: case FTS_EXPIRED:
2351: case FTS_RELEASED:
2352: case FTS_RESET:
2353: lq = &comp -> pool -> expired;
2354: #if defined(FAILOVER_PROTOCOL)
2355: /* In partner_down, tsfp is the time at which the lease
2356: * may be reallocated (stos+mclt). We can do that with
2357: * lease_mine_to_reallocate() anywhere between tsfp and
2358: * ends. But we prefer to wait until ends before doing it
2359: * automatically (choose the greater of the two). Note
2360: * that 'ends' is usually a historic timestamp in the
2361: * case of expired leases, is really only in the future
2362: * on released leases, and if we know a lease to be released
2363: * the peer might still know it to be active...in which case
2364: * it's possible the peer has renewed this lease, so avoid
2365: * doing that.
2366: */
2367: if (comp->pool->failover_peer &&
2368: comp->pool->failover_peer->me.state == partner_down)
2369: comp->sort_time = (comp->tsfp > comp->ends) ?
2370: comp->tsfp : comp->ends;
2371: else
2372: #endif
2373: comp->sort_time = comp->ends;
2374:
2375: break;
2376:
2377: case FTS_ABANDONED:
2378: lq = &comp -> pool -> abandoned;
2379: comp -> sort_time = comp -> ends;
2380: break;
2381:
2382: case FTS_BACKUP:
2383: if (comp->flags & RESERVED_LEASE) {
2384: lq = &comp->pool->reserved;
2385: } else {
2386: lq = &comp->pool->backup;
2387: comp->pool->backup_leases++;
2388: }
2389: comp -> sort_time = comp -> ends;
2390: break;
2391:
2392: default:
2393: log_error ("Lease with bogus binding state: %d",
2394: comp -> binding_state);
2395: #if defined (BINDING_STATE_DEBUG)
2396: abort ();
2397: #endif
2398: return 0;
2399: }
2400:
2401: /* This only works during server startup: during runtime, the last
2402: * lease may be dequeued in between calls. If the queue is the same
2403: * as was used previously, and the lease structure isn't (this is not
2404: * a re-queue), use that as a starting point for the insertion-sort.
2405: */
2406: if ((server_starting & SS_QFOLLOW) && (lq == last_lq) &&
2407: (comp != last_insert_point) &&
2408: (last_insert_point->sort_time <= comp->sort_time)) {
2409: prev = last_insert_point;
2410: lp = prev->next;
2411: } else {
2412: prev = NULL;
2413: lp = *lq;
2414: }
2415:
2416: /* Insertion sort the lease onto the appropriate queue. */
2417: for (; lp ; lp = lp->next) {
2418: if (lp -> sort_time >= comp -> sort_time)
2419: break;
2420: prev = lp;
2421: }
2422:
2423: if (prev) {
2424: if (prev -> next) {
2425: lease_reference (&comp -> next, prev -> next, MDL);
2426: lease_dereference (&prev -> next, MDL);
2427: }
2428: lease_reference (&prev -> next, comp, MDL);
2429: } else {
2430: if (*lq) {
2431: lease_reference (&comp -> next, *lq, MDL);
2432: lease_dereference (lq, MDL);
2433: }
2434: lease_reference (lq, comp, MDL);
2435: }
2436: last_insert_point = comp;
2437: last_lq = lq;
2438: return 1;
2439: }
2440:
2441: /* For a given lease, sort it onto the right list in its pool and put it
2442: in each appropriate hash, understanding that it's already by definition
2443: in lease_ip_addr_hash. */
2444:
2445: isc_result_t
2446: lease_instantiate(const void *key, unsigned len, void *object)
2447: {
2448: struct lease *lease = object;
2449: struct class *class;
2450: /* XXX If the lease doesn't have a pool at this point, it's an
2451: XXX orphan, which we *should* keep around until it expires,
2452: XXX but which right now we just forget. */
2453: if (!lease -> pool) {
2454: lease_ip_hash_delete(lease_ip_addr_hash, lease->ip_addr.iabuf,
2455: lease->ip_addr.len, MDL);
2456: return ISC_R_SUCCESS;
2457: }
2458:
2459: /* Put the lease on the right queue. Failure to queue is probably
2460: * due to a bogus binding state. In such a case, we claim success,
2461: * so that later leases in a hash_foreach are processed, but we
2462: * return early as we really don't want hw address hash entries or
2463: * other cruft to surround such a bogus entry.
2464: */
2465: if (!lease_enqueue(lease))
2466: return ISC_R_SUCCESS;
2467:
2468: /* Record the lease in the uid hash if possible. */
2469: if (lease -> uid) {
2470: uid_hash_add (lease);
2471: }
2472:
2473: /* Record it in the hardware address hash if possible. */
2474: if (lease -> hardware_addr.hlen) {
2475: hw_hash_add (lease);
2476: }
2477:
2478: /* If the lease has a billing class, set up the billing. */
2479: if (lease -> billing_class) {
2480: class = (struct class *)0;
2481: class_reference (&class, lease -> billing_class, MDL);
2482: class_dereference (&lease -> billing_class, MDL);
2483: /* If the lease is available for allocation, the billing
2484: is invalid, so we don't keep it. */
2485: if (lease -> binding_state == FTS_ACTIVE ||
2486: lease -> binding_state == FTS_EXPIRED ||
2487: lease -> binding_state == FTS_RELEASED ||
2488: lease -> binding_state == FTS_RESET)
2489: bill_class (lease, class);
2490: class_dereference (&class, MDL);
2491: }
2492: return ISC_R_SUCCESS;
2493: }
2494:
2495: /* Run expiry events on every pool. This is called on startup so that
2496: any expiry events that occurred after the server stopped and before it
2497: was restarted can be run. At the same time, if failover support is
2498: compiled in, we compute the balance of leases for the pool. */
2499:
2500: void expire_all_pools ()
2501: {
2502: struct shared_network *s;
2503: struct pool *p;
2504: int i;
2505: struct lease *l;
2506: struct lease **lptr[RESERVED_LEASES+1];
2507:
2508: /* Indicate that we are in the startup phase */
2509: server_starting = SS_NOSYNC | SS_QFOLLOW;
2510:
2511: /* First, go over the hash list and actually put all the leases
2512: on the appropriate lists. */
2513: lease_ip_hash_foreach(lease_ip_addr_hash, lease_instantiate);
2514:
2515: /* Loop through each pool in each shared network and call the
2516: * expiry routine on the pool. It is no longer safe to follow
2517: * the queue insertion point, as expiration of a lease can move
2518: * it between queues (and this may be the lease that function
2519: * points at).
2520: */
2521: server_starting &= ~SS_QFOLLOW;
2522: for (s = shared_networks; s; s = s -> next) {
2523: for (p = s -> pools; p; p = p -> next) {
2524: pool_timer (p);
2525:
2526: p -> lease_count = 0;
2527: p -> free_leases = 0;
2528: p -> backup_leases = 0;
2529:
2530: lptr [FREE_LEASES] = &p -> free;
2531: lptr [ACTIVE_LEASES] = &p -> active;
2532: lptr [EXPIRED_LEASES] = &p -> expired;
2533: lptr [ABANDONED_LEASES] = &p -> abandoned;
2534: lptr [BACKUP_LEASES] = &p -> backup;
2535: lptr [RESERVED_LEASES] = &p->reserved;
2536:
2537: for (i = FREE_LEASES; i <= RESERVED_LEASES; i++) {
2538: for (l = *(lptr [i]); l; l = l -> next) {
2539: p -> lease_count++;
2540: if (l -> ends <= cur_time) {
2541: if (l->binding_state == FTS_FREE) {
2542: if (i == FREE_LEASES)
2543: p->free_leases++;
2544: else if (i != RESERVED_LEASES)
2545: log_fatal("Impossible case "
2546: "at %s:%d.", MDL);
2547: } else if (l->binding_state == FTS_BACKUP) {
2548: if (i == BACKUP_LEASES)
2549: p->backup_leases++;
2550: else if (i != RESERVED_LEASES)
2551: log_fatal("Impossible case "
2552: "at %s:%d.", MDL);
2553: }
2554: }
2555: #if defined (FAILOVER_PROTOCOL)
2556: if (p -> failover_peer &&
2557: l -> tstp > l -> atsfp &&
2558: !(l -> flags & ON_UPDATE_QUEUE)) {
2559: l -> desired_binding_state = l -> binding_state;
2560: dhcp_failover_queue_update (l, 1);
2561: }
2562: #endif
2563: }
2564: }
2565: }
2566: }
2567:
2568: /* turn off startup phase */
2569: server_starting = 0;
2570: }
2571:
2572: void dump_subnets ()
2573: {
2574: struct lease *l;
2575: struct shared_network *s;
2576: struct subnet *n;
2577: struct pool *p;
2578: struct lease **lptr[RESERVED_LEASES+1];
2579: int i;
2580:
2581: log_info ("Subnets:");
2582: for (n = subnets; n; n = n -> next_subnet) {
2583: log_debug (" Subnet %s", piaddr (n -> net));
2584: log_debug (" netmask %s",
2585: piaddr (n -> netmask));
2586: }
2587: log_info ("Shared networks:");
2588: for (s = shared_networks; s; s = s -> next) {
2589: log_info (" %s", s -> name);
2590: for (p = s -> pools; p; p = p -> next) {
2591: lptr [FREE_LEASES] = &p -> free;
2592: lptr [ACTIVE_LEASES] = &p -> active;
2593: lptr [EXPIRED_LEASES] = &p -> expired;
2594: lptr [ABANDONED_LEASES] = &p -> abandoned;
2595: lptr [BACKUP_LEASES] = &p -> backup;
2596: lptr [RESERVED_LEASES] = &p->reserved;
2597:
2598: for (i = FREE_LEASES; i <= RESERVED_LEASES; i++) {
2599: for (l = *(lptr [i]); l; l = l -> next) {
2600: print_lease (l);
2601: }
2602: }
2603: }
2604: }
2605: }
2606:
2607: HASH_FUNCTIONS(lease_ip, const unsigned char *, struct lease, lease_ip_hash_t,
2608: lease_reference, lease_dereference, do_ip4_hash)
2609: HASH_FUNCTIONS(lease_id, const unsigned char *, struct lease, lease_id_hash_t,
2610: lease_reference, lease_dereference, do_id_hash)
2611: HASH_FUNCTIONS (host, const unsigned char *, struct host_decl, host_hash_t,
2612: host_reference, host_dereference, do_string_hash)
2613: HASH_FUNCTIONS (class, const char *, struct class, class_hash_t,
2614: class_reference, class_dereference, do_string_hash)
2615:
2616: #if defined (DEBUG_MEMORY_LEAKAGE) && \
2617: defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
2618: extern struct hash_table *dns_zone_hash;
2619: extern struct interface_info **interface_vector;
2620: extern int interface_count;
2621: dhcp_control_object_t *dhcp_control_object;
2622: extern struct hash_table *auth_key_hash;
2623: struct hash_table *universe_hash;
2624: struct universe **universes;
2625: int universe_count, universe_max;
2626: #if 0
2627: extern int end;
2628: #endif
2629:
2630: #if defined (COMPACT_LEASES)
2631: extern struct lease *lease_hunks;
2632: #endif
2633:
2634: void free_everything(void)
2635: {
2636: struct subnet *sc = (struct subnet *)0, *sn = (struct subnet *)0;
2637: struct shared_network *nc = (struct shared_network *)0,
2638: *nn = (struct shared_network *)0;
2639: struct pool *pc = (struct pool *)0, *pn = (struct pool *)0;
2640: struct lease *lc = (struct lease *)0, *ln = (struct lease *)0;
2641: struct interface_info *ic = (struct interface_info *)0,
2642: *in = (struct interface_info *)0;
2643: struct class *cc = (struct class *)0, *cn = (struct class *)0;
2644: struct collection *lp;
2645: int i;
2646:
2647: /* Get rid of all the hash tables. */
2648: if (host_hw_addr_hash)
2649: host_free_hash_table (&host_hw_addr_hash, MDL);
2650: host_hw_addr_hash = 0;
2651: if (host_uid_hash)
2652: host_free_hash_table (&host_uid_hash, MDL);
2653: host_uid_hash = 0;
2654: if (lease_uid_hash)
2655: lease_id_free_hash_table (&lease_uid_hash, MDL);
2656: lease_uid_hash = 0;
2657: if (lease_ip_addr_hash)
2658: lease_ip_free_hash_table (&lease_ip_addr_hash, MDL);
2659: lease_ip_addr_hash = 0;
2660: if (lease_hw_addr_hash)
2661: lease_id_free_hash_table (&lease_hw_addr_hash, MDL);
2662: lease_hw_addr_hash = 0;
2663: if (host_name_hash)
2664: host_free_hash_table (&host_name_hash, MDL);
2665: host_name_hash = 0;
2666: if (dns_zone_hash)
2667: dns_zone_free_hash_table (&dns_zone_hash, MDL);
2668: dns_zone_hash = 0;
2669:
2670: while (host_id_info != NULL) {
2671: host_id_info_t *tmp;
2672: option_dereference(&host_id_info->option, MDL);
2673: host_free_hash_table(&host_id_info->values_hash, MDL);
2674: tmp = host_id_info->next;
2675: dfree(host_id_info, MDL);
2676: host_id_info = tmp;
2677: }
2678: #if 0
2679: if (auth_key_hash)
2680: auth_key_free_hash_table (&auth_key_hash, MDL);
2681: #endif
2682: auth_key_hash = 0;
2683:
2684: omapi_object_dereference ((omapi_object_t **)&dhcp_control_object,
2685: MDL);
2686:
2687: for (lp = collections; lp; lp = lp -> next) {
2688: if (lp -> classes) {
2689: class_reference (&cn, lp -> classes, MDL);
2690: do {
2691: if (cn) {
2692: class_reference (&cc, cn, MDL);
2693: class_dereference (&cn, MDL);
2694: }
2695: if (cc -> nic) {
2696: class_reference (&cn, cc -> nic, MDL);
2697: class_dereference (&cc -> nic, MDL);
2698: }
2699: group_dereference (&cc -> group, MDL);
2700: if (cc -> hash) {
2701: class_free_hash_table (&cc -> hash, MDL);
2702: cc -> hash = (struct hash_table *)0;
2703: }
2704: class_dereference (&cc, MDL);
2705: } while (cn);
2706: class_dereference (&lp -> classes, MDL);
2707: }
2708: }
2709:
2710: if (interface_vector) {
2711: for (i = 0; i < interface_count; i++) {
2712: if (interface_vector [i])
2713: interface_dereference (&interface_vector [i], MDL);
2714: }
2715: dfree (interface_vector, MDL);
2716: interface_vector = 0;
2717: }
2718:
2719: if (interfaces) {
2720: interface_reference (&in, interfaces, MDL);
2721: do {
2722: if (in) {
2723: interface_reference (&ic, in, MDL);
2724: interface_dereference (&in, MDL);
2725: }
2726: if (ic -> next) {
2727: interface_reference (&in, ic -> next, MDL);
2728: interface_dereference (&ic -> next, MDL);
2729: }
2730: omapi_unregister_io_object ((omapi_object_t *)ic);
2731: if (ic -> shared_network) {
2732: if (ic -> shared_network -> interface)
2733: interface_dereference
2734: (&ic -> shared_network -> interface, MDL);
2735: shared_network_dereference (&ic -> shared_network, MDL);
2736: }
2737: interface_dereference (&ic, MDL);
2738: } while (in);
2739: interface_dereference (&interfaces, MDL);
2740: }
2741:
2742: /* Subnets are complicated because of the extra links. */
2743: if (subnets) {
2744: subnet_reference (&sn, subnets, MDL);
2745: do {
2746: if (sn) {
2747: subnet_reference (&sc, sn, MDL);
2748: subnet_dereference (&sn, MDL);
2749: }
2750: if (sc -> next_subnet) {
2751: subnet_reference (&sn, sc -> next_subnet, MDL);
2752: subnet_dereference (&sc -> next_subnet, MDL);
2753: }
2754: if (sc -> next_sibling)
2755: subnet_dereference (&sc -> next_sibling, MDL);
2756: if (sc -> shared_network)
2757: shared_network_dereference (&sc -> shared_network, MDL);
2758: group_dereference (&sc -> group, MDL);
2759: if (sc -> interface)
2760: interface_dereference (&sc -> interface, MDL);
2761: subnet_dereference (&sc, MDL);
2762: } while (sn);
2763: subnet_dereference (&subnets, MDL);
2764: }
2765:
2766: /* So are shared networks. */
2767: /* XXX: this doesn't work presently, but i'm ok just filtering
2768: * it out of the noise (you get a bigger spike on the real leaks).
2769: * It would be good to fix this, but it is not a "real bug," so not
2770: * today. This hack is incomplete, it doesn't trim out sub-values.
2771: */
2772: if (shared_networks) {
2773: shared_network_dereference (&shared_networks, MDL);
2774: /* This is the old method (tries to free memory twice, broken) */
2775: } else if (0) {
2776: shared_network_reference (&nn, shared_networks, MDL);
2777: do {
2778: if (nn) {
2779: shared_network_reference (&nc, nn, MDL);
2780: shared_network_dereference (&nn, MDL);
2781: }
2782: if (nc -> next) {
2783: shared_network_reference (&nn, nc -> next, MDL);
2784: shared_network_dereference (&nc -> next, MDL);
2785: }
2786:
2787: /* As are pools. */
2788: if (nc -> pools) {
2789: pool_reference (&pn, nc -> pools, MDL);
2790: do {
2791: struct lease **lptr[RESERVED_LEASES+1];
2792:
2793: if (pn) {
2794: pool_reference (&pc, pn, MDL);
2795: pool_dereference (&pn, MDL);
2796: }
2797: if (pc -> next) {
2798: pool_reference (&pn, pc -> next, MDL);
2799: pool_dereference (&pc -> next, MDL);
2800: }
2801:
2802: lptr [FREE_LEASES] = &pc -> free;
2803: lptr [ACTIVE_LEASES] = &pc -> active;
2804: lptr [EXPIRED_LEASES] = &pc -> expired;
2805: lptr [ABANDONED_LEASES] = &pc -> abandoned;
2806: lptr [BACKUP_LEASES] = &pc -> backup;
2807: lptr [RESERVED_LEASES] = &pc->reserved;
2808:
2809: /* As (sigh) are leases. */
2810: for (i = FREE_LEASES ; i <= RESERVED_LEASES ; i++) {
2811: if (*lptr [i]) {
2812: lease_reference (&ln, *lptr [i], MDL);
2813: do {
2814: if (ln) {
2815: lease_reference (&lc, ln, MDL);
2816: lease_dereference (&ln, MDL);
2817: }
2818: if (lc -> next) {
2819: lease_reference (&ln, lc -> next, MDL);
2820: lease_dereference (&lc -> next, MDL);
2821: }
2822: if (lc -> billing_class)
2823: class_dereference (&lc -> billing_class,
2824: MDL);
2825: if (lc -> state)
2826: free_lease_state (lc -> state, MDL);
2827: lc -> state = (struct lease_state *)0;
2828: if (lc -> n_hw)
2829: lease_dereference (&lc -> n_hw, MDL);
2830: if (lc -> n_uid)
2831: lease_dereference (&lc -> n_uid, MDL);
2832: lease_dereference (&lc, MDL);
2833: } while (ln);
2834: lease_dereference (lptr [i], MDL);
2835: }
2836: }
2837: if (pc -> group)
2838: group_dereference (&pc -> group, MDL);
2839: if (pc -> shared_network)
2840: shared_network_dereference (&pc -> shared_network,
2841: MDL);
2842: pool_dereference (&pc, MDL);
2843: } while (pn);
2844: pool_dereference (&nc -> pools, MDL);
2845: }
2846: /* Because of a circular reference, we need to nuke this
2847: manually. */
2848: group_dereference (&nc -> group, MDL);
2849: shared_network_dereference (&nc, MDL);
2850: } while (nn);
2851: shared_network_dereference (&shared_networks, MDL);
2852: }
2853:
2854: cancel_all_timeouts ();
2855: relinquish_timeouts ();
2856: relinquish_ackqueue();
2857: trace_free_all ();
2858: group_dereference (&root_group, MDL);
2859: executable_statement_dereference (&default_classification_rules, MDL);
2860:
2861: shutdown_state = shutdown_drop_omapi_connections;
2862: omapi_io_state_foreach (dhcp_io_shutdown, 0);
2863: shutdown_state = shutdown_listeners;
2864: omapi_io_state_foreach (dhcp_io_shutdown, 0);
2865: shutdown_state = shutdown_dhcp;
2866: omapi_io_state_foreach (dhcp_io_shutdown, 0);
2867:
2868: omapi_object_dereference ((omapi_object_t **)&icmp_state, MDL);
2869:
2870: universe_free_hash_table (&universe_hash, MDL);
2871: for (i = 0; i < universe_count; i++) {
2872: #if 0
2873: union {
2874: const char *c;
2875: char *s;
2876: } foo;
2877: #endif
2878: if (universes [i]) {
2879: if (universes[i]->name_hash)
2880: option_name_free_hash_table(
2881: &universes[i]->name_hash,
2882: MDL);
2883: if (universes[i]->code_hash)
2884: option_code_free_hash_table(
2885: &universes[i]->code_hash,
2886: MDL);
2887: #if 0
2888: if (universes [i] -> name > (char *)&end) {
2889: foo.c = universes [i] -> name;
2890: dfree (foo.s, MDL);
2891: }
2892: if (universes [i] > (struct universe *)&end)
2893: dfree (universes [i], MDL);
2894: #endif
2895: }
2896: }
2897: dfree (universes, MDL);
2898:
2899: relinquish_free_lease_states ();
2900: relinquish_free_pairs ();
2901: relinquish_free_expressions ();
2902: relinquish_free_binding_values ();
2903: relinquish_free_option_caches ();
2904: relinquish_free_packets ();
2905: #if defined(COMPACT_LEASES)
2906: relinquish_lease_hunks ();
2907: #endif
2908: relinquish_hash_bucket_hunks ();
2909: omapi_type_relinquish ();
2910: }
2911: #endif /* DEBUG_MEMORY_LEAKAGE_ON_EXIT */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mdb.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / server