34 static void maybe_return_agent_options(
struct packet *
packet,
39 #if defined(DHCPv6) && defined(DHCP4o6)
45 #if defined(DELAYED_ACK)
46 static void delayed_ack_enqueue(
struct lease *);
47 static void delayed_acks_timer(
void *);
50 struct leasequeue *ackqueue_head, *ackqueue_tail;
52 static struct timeval max_fsync;
61 static char dhcp_message [256];
62 static int site_code_min;
64 static int find_min_site_code(
struct universe *);
65 static isc_result_t lowest_site_code(
const void *,
unsigned,
void *);
67 static const char *dhcp_type_names [] = {
78 "DHCPLEASEUNASSIGNED",
85 # define send_packet trace_packet_send
88 static TIME leaseTimeCheck(
TIME calculated,
TIME alternate);
97 memset (&client_identifier, 0,
sizeof client_identifier);
103 packet, (
struct lease *)0,
112 return "\"no client id\"";
122 packet -> raw -> hlen,
123 packet -> raw -> chaddr);
140 errmsg =
"unknown network segment";
152 #if defined(DHCPv6) && defined(DHCP4o6)
154 log_info(
"DHCP4o6 %s from %s via %s: %s", s,
159 :
"<no identifier>"),
166 log_info(
"%s from %s via %s: %s", s,
169 :
"<no identifier>"),
205 cip.
len =
sizeof packet -> raw -> ciaddr;
206 memcpy (cip.
iabuf, &packet -> raw -> ciaddr,
207 sizeof packet -> raw -> ciaddr);
222 if (lease -> uid_len) {
228 memset (&data, 0,
sizeof data);
230 packet, (
struct lease *)0,
236 if (lease -> uid_len != data.
len ||
237 memcmp (lease -> uid, data.
data, data.
len)) {
243 if ((lease -> hardware_addr.hbuf [0] !=
244 packet -> raw -> htype) ||
245 (lease -> hardware_addr.hlen - 1 !=
246 packet -> raw -> hlen) ||
247 memcmp (&lease -> hardware_addr.hbuf [1],
248 packet -> raw -> chaddr,
249 packet -> raw -> hlen))
278 switch (packet -> packet_type) {
312 errmsg =
"unknown packet type";
317 lease_dereference (&lease,
MDL);
328 int peer_has_leases = 0;
329 #if defined (FAILOVER_PROTOCOL)
330 dhcp_failover_state_t *peer;
334 0, &peer_has_leases, (
struct lease *)0,
MDL);
341 s =
"Hostname Unsuitable for Printing";
348 #if defined(DHCPv6) && defined(DHCP4o6)
350 snprintf (msgbuf,
sizeof msgbuf,
351 "DHCP4o6 DHCPDISCOVER from %s %s%s%svia %s",
352 (packet -> raw -> htype
354 packet -> raw -> hlen,
355 packet -> raw -> chaddr)
358 :
"<no identifier>")),
359 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
360 piaddr(packet->client_addr));
363 snprintf (msgbuf,
sizeof msgbuf,
"DHCPDISCOVER from %s %s%s%svia %s",
364 (packet -> raw -> htype
368 :
"<no identifier>")),
369 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
370 packet -> raw ->
giaddr.s_addr
371 ? inet_ntoa (packet -> raw ->
giaddr)
372 : packet -> interface -> name);
376 #if defined(DHCPv6) && defined(DHCP4o6)
378 log_info (
"DHCP4o6 packet from unknown subnet: %s",
379 piaddr(packet->client_addr));
382 log_info (
"Packet from unknown subnet: %s",
383 inet_ntoa (packet -> raw ->
giaddr));
387 #if defined (FAILOVER_PROTOCOL)
388 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
389 peer = lease ->
pool -> failover_peer;
409 #if defined (DEBUG_FIND_LEASE)
414 lease_dereference (&lease,
MDL);
425 log_error (
"%s: peer holds all free leases",
428 log_error (
"%s: network %s: no free leases",
435 #if defined (FAILOVER_PROTOCOL)
436 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
437 peer = lease ->
pool -> failover_peer;
441 msgbuf, peer -> nrr);
445 peer = (dhcp_failover_state_t *)0;
450 if (peer_has_leases) {
451 log_debug (
"%s: load balance to peer %s",
452 msgbuf, peer -> name);
455 log_debug (
"%s: cancel load balance to peer %s - %s",
456 msgbuf, peer -> name,
"no free leases");
462 if (lease -> ends < cur_time && lease ->
scope)
468 if (when < lease ->
ends)
469 when = lease ->
ends;
475 lease_dereference (&lease,
MDL);
481 struct
lease *ip_lease;
493 #if defined (FAILOVER_PROTOCOL)
494 dhcp_failover_state_t *peer;
496 int have_requested_addr = 0;
500 memset (&data, 0,
sizeof data);
509 have_requested_addr = 1;
513 memcpy (cip.
iabuf, &packet -> raw -> ciaddr.s_addr, 4);
519 subnet = (
struct subnet *)0;
520 lease = (
struct lease *)0;
530 s =
"Hostname Unsuitable for Printing";
536 memset (&data, 0,
sizeof data);
548 sprintf (smbuf,
" (%s)",
piaddr (sip));
557 #if defined(DHCPv6) && defined(DHCP4o6)
559 snprintf (msgbuf,
sizeof msgbuf,
560 "DHCP4o6 DHCPREQUEST for %s%s from %s %s%s%svia %s",
562 (packet -> raw -> htype
564 packet -> raw -> hlen,
565 packet -> raw -> chaddr)
568 :
"<no identifier>")),
569 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
570 piaddr(packet->client_addr));
573 snprintf (msgbuf,
sizeof msgbuf,
574 "DHCPREQUEST for %s%s from %s %s%s%svia %s",
576 (packet -> raw -> htype
580 :
"<no identifier>")),
581 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
582 packet -> raw ->
giaddr.s_addr
583 ? inet_ntoa (packet -> raw ->
giaddr)
584 : packet -> interface -> name);
586 #if defined (FAILOVER_PROTOCOL)
587 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
588 peer = lease ->
pool -> failover_peer;
592 msgbuf, peer -> nrr);
617 log_debug (
"%s: lease owned by peer", msgbuf);
631 log_debug(
"%s: lease in transition state %s", msgbuf,
633 ?
"released" :
"expired");
642 log_debug (
"%s: lease reset by administrator", msgbuf);
656 (memcmp(sip.
iabuf,
"\0\0\0\0", sip.
len) != 0)) {
664 if (memcmp(sip.
iabuf, &from, sip.
len) != 0) {
665 log_debug(
"%s: not our server id", msgbuf);
694 peer = (dhcp_failover_state_t *)0;
740 (packet -> raw -> ciaddr.s_addr &&
741 packet -> raw ->
giaddr.s_addr) ||
742 (have_requested_addr && !packet -> raw -> ciaddr.s_addr)) {
748 if (subnet && subnet ->
group -> authoritative) {
749 log_info (
"%s: wrong network.", msgbuf);
754 log_info (
"%s: ignored (%s).", msgbuf,
756 ?
"not authoritative" :
"unknown subnet"));
763 subnet_dereference (&subnet,
MDL);
768 log_info (
"%s: wrong network.", msgbuf);
772 log_info (
"%s: ignored (not authoritative).", msgbuf);
779 if (!lease && ours) {
794 subnet_dereference (&subnet,
MDL);
796 lease_dereference (&lease,
MDL);
804 struct lease *
lease = (
struct lease *)0, *
next = (
struct lease *)0;
809 char msgbuf [1024], cstr[16];
817 log_info (
"DHCPRELEASE from %s specified requested-address.",
823 memset (&data, 0,
sizeof data);
836 lease_reference (&next, lease -> n_uid,
MDL);
837 if (!memcmp (&packet -> raw -> ciaddr,
841 lease_dereference (&lease,
MDL);
843 lease_reference (&lease, next,
MDL);
844 lease_dereference (&next,
MDL);
848 lease_dereference (&next,
MDL);
856 memcpy (cip.
iabuf, &packet -> raw -> ciaddr, 4);
863 (lease -> hardware_addr.hlen != packet -> raw -> hlen + 1 ||
864 lease -> hardware_addr.hbuf [0] != packet -> raw -> htype ||
865 memcmp (&lease -> hardware_addr.hbuf [1],
866 packet -> raw -> chaddr, packet -> raw -> hlen)))
867 lease_dereference (&lease,
MDL);
869 if (lease && lease -> client_hostname) {
870 if ((strlen (lease -> client_hostname) <= 64) &&
872 s = lease -> client_hostname;
874 s =
"Hostname Unsuitable for Printing";
882 strncpy(cstr, inet_ntoa (packet -> raw -> ciaddr), 15);
888 #if defined(DHCPv6) && defined(DHCP4o6)
890 snprintf (msgbuf,
sizeof msgbuf,
891 "DHCP4o6 DHCPRELEASE of %s from %s %s%s%svia "
894 (packet -> raw -> htype
896 packet -> raw -> hlen,
897 packet -> raw -> chaddr)
900 :
"<no identifier>")),
901 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
902 piaddr(packet->client_addr),
903 lease ?
"" :
"not ");
906 snprintf (msgbuf,
sizeof msgbuf,
907 "DHCPRELEASE of %s from %s %s%s%svia %s (%sfound)",
909 (packet -> raw -> htype
913 :
"<no identifier>")),
914 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
915 packet -> raw ->
giaddr.s_addr
916 ? inet_ntoa (packet -> raw ->
giaddr)
917 : packet -> interface -> name,
918 lease ?
"" :
"not ");
920 #if defined (FAILOVER_PROTOCOL)
921 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
922 dhcp_failover_state_t *peer = lease ->
pool -> failover_peer;
926 peer -> name, peer -> nrr);
940 if (lease && lease -> ends >
cur_time) {
944 #if defined(FAILOVER_PROTOCOL)
948 lease_dereference (&lease,
MDL);
970 memset (&data, 0,
sizeof data);
983 if (lease && lease -> client_hostname) {
984 if ((strlen (lease -> client_hostname) <= 64) &&
986 s = lease -> client_hostname;
988 s =
"Hostname Unsuitable for Printing";
995 #if defined(DHCPv6) && defined(DHCP4o6)
997 snprintf (msgbuf,
sizeof msgbuf,
998 "DHCP4o6 DHCPDECLINE of %s from %s %s%s%svia %s",
1000 (packet -> raw -> htype
1002 packet -> raw -> hlen,
1003 packet -> raw -> chaddr)
1006 :
"<no identifier>")),
1007 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
1008 piaddr(packet->client_addr));
1011 snprintf (msgbuf,
sizeof msgbuf,
1012 "DHCPDECLINE of %s from %s %s%s%svia %s",
1014 (packet -> raw -> htype
1018 :
"<no identifier>")),
1019 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
1020 packet -> raw ->
giaddr.s_addr
1021 ? inet_ntoa (packet -> raw ->
giaddr)
1022 : packet -> interface -> name);
1029 packet->options, options,
1035 for (i = packet -> class_count; i > 0; i--) {
1037 (NULL, packet, NULL, NULL, packet->options, options,
1047 packet -> options, options,
1048 &lease -> scope, oc,
MDL)) {
1051 #if defined (FAILOVER_PROTOCOL)
1052 if (lease ->
pool && lease ->
pool -> failover_peer) {
1053 dhcp_failover_state_t *peer =
1054 lease ->
pool -> failover_peer;
1059 peer -> name, peer -> nrr);
1071 status =
"abandoned";
1073 status =
"not found";
1079 log_info (
"%s: %s", msgbuf, status);
1081 #if defined(FAILOVER_PROTOCOL)
1087 lease_dereference (&lease,
MDL);
1090 #if defined(RELAY_PORT)
1097 return (packet->client_port);
1105 struct packet *packet;
1108 char msgbuf[1024], *addr_type;
1113 struct packet outgoing;
1116 struct iaddr cip, gip, sip;
1119 struct sockaddr_in to;
1120 struct in_addr from;
1121 isc_boolean_t zeroed_ciaddr;
1123 int result, h_m_client_ip = 0;
1124 struct host_decl *host = NULL, *hp = NULL, *h;
1125 #if defined(RELAY_PORT)
1128 #if defined (DEBUG_INFORM_HOST)
1129 int h_w_fixed_addr = 0;
1135 if (!packet->raw->ciaddr.s_addr) {
1136 zeroed_ciaddr = ISC_TRUE;
1139 if (packet->client_addr.len == 4) {
1141 memcpy(cip.
iabuf, &packet->client_addr.iabuf, 4);
1142 addr_type =
"source";
1145 memset(cip.
iabuf, 0, 4);
1149 zeroed_ciaddr = ISC_FALSE;
1151 memcpy(cip.
iabuf, &packet->raw->ciaddr, 4);
1152 addr_type =
"client";
1157 if (packet->raw->giaddr.s_addr) {
1159 memcpy(gip.
iabuf, &packet->raw->giaddr, 4);
1160 if (zeroed_ciaddr == ISC_TRUE) {
1161 addr_type =
"relay";
1170 #if defined(DHCPv6) && defined(DHCP4o6)
1172 snprintf(msgbuf,
sizeof(msgbuf),
1173 "DHCP4o6 DHCPINFORM from %s via %s",
1175 piaddr(packet->client_addr));
1178 snprintf(msgbuf,
sizeof(msgbuf),
"DHCPINFORM from %s via %s",
1180 packet->raw->giaddr.s_addr ?
1181 inet_ntoa(packet->raw->giaddr) :
1182 packet->interface->name);
1185 if (!memcmp(cip.
iabuf,
"\0\0\0", 4)) {
1186 log_info(
"%s: ignored (null source address).", msgbuf);
1190 #if defined(RELAY_PORT)
1205 memset(&d1, 0,
sizeof d1);
1207 packet->options, NULL,
1212 log_info(
"%s: ignored (invalid subnet selection option).", msgbuf);
1234 if ((zeroed_ciaddr == ISC_TRUE) && (gip.
len != 0))
1235 addr_type =
"relay link select";
1237 addr_type =
"selected";
1242 if (subnet == NULL) {
1243 log_info(
"%s: unknown subnet for %s address %s",
1244 msgbuf, addr_type,
piaddr(sip));
1255 log_info(
"%s: not authoritative for subnet %s",
1256 msgbuf,
piaddr (subnet -> net));
1258 log_info(
"If this DHCP server is authoritative for%s",
1260 log_info(
"please write an `authoritative;' directi%s",
1261 "ve either in the");
1262 log_info(
"subnet declaration or in some scope that%s",
1264 log_info(
"subnet declaration - for example, write %s",
1266 log_info(
"of the dhcpd.conf file.");
1270 subnet_dereference(&subnet,
MDL);
1275 memset(&outgoing, 0,
sizeof outgoing);
1276 memset(&raw, 0,
sizeof raw);
1277 outgoing.
raw = &raw;
1279 maybe_return_agent_options(packet, options);
1283 packet->options, options,
1288 if (zeroed_ciaddr == ISC_FALSE) {
1289 struct lease* cip_lease = NULL;
1297 NULL, packet, NULL, NULL,
1298 packet->options, options,
1305 lease_dereference (&cip_lease,
MDL);
1310 for (i = packet->class_count; i > 0; i--) {
1312 packet->options, options,
1314 packet->classes[i - 1]->group,
1334 memset(&d1, 0,
sizeof(d1));
1337 packet->options, NULL,
1342 #if defined (DEBUG_INFORM_HOST)
1344 log_debug (
"dhcpinform: found host by ID "
1345 "-- checking fixed-address match");
1349 for (h = hp; !h_m_client_ip && h; h = h->n_ipaddr) {
1353 memset(&fixed_addr, 0,
sizeof(fixed_addr));
1355 NULL, NULL, NULL, NULL,
1357 h->fixed_addr,
MDL))
1360 #if defined (DEBUG_INFORM_HOST)
1364 (i + cip.
len) <= fixed_addr.
len;
1366 if (memcmp(fixed_addr.
data + i,
1368 #if defined (DEBUG_INFORM_HOST)
1370 "host with matching "
1371 "fixed-address by ID");
1373 host_reference(&host, h,
MDL);
1382 for (h = hp; !host && h; h = h->
n_ipaddr) {
1386 #if defined (DEBUG_INFORM_HOST)
1388 "without fixed-address by ID");
1390 host_reference(&host, h,
MDL);
1394 host_dereference (&hp,
MDL);
1396 if (!host || !h_m_client_ip) {
1398 packet->raw->chaddr,
1399 packet->raw->hlen,
MDL);
1401 #if defined (DEBUG_INFORM_HOST)
1403 log_debug (
"dhcpinform: found host by HW "
1404 "-- checking fixed-address match");
1409 for (h = hp; !h_m_client_ip && h; h = h->n_ipaddr) {
1413 memset (&fixed_addr, 0,
sizeof(fixed_addr));
1415 NULL, NULL, NULL, NULL,
1417 h->fixed_addr,
MDL))
1420 #if defined (DEBUG_INFORM_HOST)
1424 (i + cip.
len) <= fixed_addr.
len;
1426 if (memcmp(fixed_addr.
data + i,
1428 #if defined (DEBUG_INFORM_HOST)
1430 "host with matching "
1431 "fixed-address by HW");
1439 host_dereference(&host,
MDL);
1440 host_reference(&host, h,
MDL);
1448 for (h = hp; !host && h; h = h->
n_ipaddr) {
1452 #if defined (DEBUG_INFORM_HOST)
1453 log_debug (
"dhcpinform: found host without "
1454 "fixed-address by HW");
1456 host_reference (&host, h,
MDL);
1461 host_dereference (&hp,
MDL);
1464 #if defined (DEBUG_INFORM_HOST)
1469 if (h_w_fixed_addr && !h_m_client_ip) {
1470 log_info (
"dhcpinform: matching host with "
1471 "fixed-address different than "
1472 "client IP detected?!");
1480 #if defined (DEBUG_INFORM_HOST)
1481 log_info (
"dhcpinform: applying host (group) options");
1484 packet->options, options,
1488 host_dereference (&host,
MDL);
1494 memset (&d1, 0,
sizeof d1);
1502 if (i >=
sizeof(raw.
file)) {
1503 log_info(
"file name longer than packet field "
1504 "truncated - field: %lu name: %d %.*s",
1505 (
unsigned long)
sizeof(raw.
file), i,
1507 i =
sizeof(raw.
file);
1522 if (i >=
sizeof(raw.
sname)) {
1523 log_info(
"server name longer than packet field "
1524 "truncated - field: %lu name: %d %.*s",
1525 (
unsigned long)
sizeof(raw.
sname), i,
1527 i =
sizeof(raw.
sname);
1548 &dhcpack, 1, 0, 0,
MDL)) {
1549 option_code_hash_lookup(&oc->
option,
1566 subnet -> netmask.iabuf,
1567 subnet -> netmask.len,
1569 option_code_hash_lookup(&oc->
option,
1584 packet -> options, options,
1589 (
const char *)d1.
data, d1.
len,
1594 subnet_dereference (&subnet,
MDL);
1598 options -> site_universe = u ->
index;
1606 memset (&prl, 0,
sizeof prl);
1623 packet -> options, options,
1628 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
1638 packet -> options, options,
1671 raw.
ciaddr = packet -> raw -> ciaddr;
1672 memcpy (raw.
chaddr, packet -> raw -> chaddr,
sizeof raw.
chaddr);
1673 raw.
hlen = packet -> raw -> hlen;
1674 raw.
htype = packet -> raw -> htype;
1676 raw.
xid = packet -> raw -> xid;
1677 raw.
secs = packet -> raw -> secs;
1678 raw.
flags = packet -> raw -> flags;
1679 raw.
hops = packet -> raw -> hops;
1687 #if defined(DHCPv6) && defined(DHCP4o6)
1690 snprintf(msgbuf,
sizeof msgbuf,
1691 "DHCP4o6 DHCPACK to %s (%s) via",
piaddr(cip),
1692 (packet->raw->htype && packet->raw->hlen) ?
1694 packet->raw->chaddr) :
1695 "<no client hardware address>");
1700 packet->dhcp4o6_response->buffer = NULL;
1703 log_fatal(
"No memory to store DHCP4o6 reply.");
1705 packet->dhcp4o6_response->data =
1706 packet->dhcp4o6_response->buffer->data;
1707 memcpy(packet->dhcp4o6_response->buffer->data,
1712 subnet_dereference (&subnet,
MDL);
1718 to.sin_family = AF_INET;
1720 to.sin_len =
sizeof to;
1722 memset (to.sin_zero, 0,
sizeof to.sin_zero);
1743 memcpy(&to.sin_addr, gip.
iabuf, 4);
1744 #if defined(RELAY_PORT)
1745 to.sin_port = relay_port ? relay_port :
local_port;
1752 memcpy(&to.sin_addr, cip.
iabuf, 4);
1757 snprintf(msgbuf,
sizeof msgbuf,
"DHCPACK to %s (%s) via",
piaddr(cip),
1758 (packet->raw->htype && packet->raw->hlen) ?
1760 "<no client hardware address>");
1762 packet->interface->name);
1766 : packet -> interface);
1768 outgoing.packet_length, from, &to, NULL);
1770 log_error ("%s:%d: Failed to send %d byte long packet over %s "
1771 "interface.", MDL, outgoing.packet_length,
1777 subnet_dereference (&subnet, MDL);
1793 struct packet *packet;
1795 struct
group *network_group;
1797 struct sockaddr_in to;
1798 struct in_addr from;
1802 struct packet outgoing;
1804 #if defined(RELAY_PORT)
1805 u_int16_t relay_port = 0;
1812 memset (&outgoing, 0,
sizeof outgoing);
1813 memset (&raw, 0,
sizeof raw);
1818 log_error (
"No memory for DHCPNAK message type.");
1824 log_error (
"No memory for expr_const expression.");
1835 #if defined(RELAY_PORT)
1841 log_error (
"No memory for DHCPNAK message type.");
1846 (
unsigned char *)dhcp_message,
1847 strlen (dhcp_message), 1, 0,
MDL)) {
1848 log_error (
"No memory for expr_const expression.");
1864 #if defined(SERVER_ID_FOR_NAK)
1891 for (i = packet->class_count; i > 0; i--) {
1893 packet->options, eval_options,
1895 packet->classes[i - 1]->group,
1917 memcpy (raw.
chaddr, packet -> raw -> chaddr,
sizeof raw.
chaddr);
1918 raw.
hlen = packet -> raw -> hlen;
1919 raw.
htype = packet -> raw -> htype;
1921 raw.
xid = packet -> raw -> xid;
1922 raw.
secs = packet -> raw -> secs;
1924 raw.
hops = packet -> raw -> hops;
1932 #if defined(DHCPv6) && defined(DHCP4o6)
1934 log_info (
"DHCP4o6 DHCPNAK on %s to %s via %s",
1937 packet -> raw -> hlen,
1938 packet -> raw -> chaddr),
1939 piaddr(packet->client_addr));
1942 log_info (
"DHCPNAK on %s to %s via %s",
1945 packet -> raw ->
giaddr.s_addr
1946 ? inet_ntoa (packet -> raw ->
giaddr)
1947 : packet -> interface -> name);
1951 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
1956 #if defined(DHCPv6) && defined(DHCP4o6)
1960 packet->dhcp4o6_response->buffer = NULL;
1963 log_fatal(
"No memory to store DHCP4o6 reply.");
1965 packet->dhcp4o6_response->data =
1966 packet->dhcp4o6_response->buffer->data;
1967 memcpy(packet->dhcp4o6_response->buffer->data,
1974 to.sin_family = AF_INET;
1976 to.sin_len =
sizeof to;
1978 memset (to.sin_zero, 0,
sizeof to.sin_zero);
1983 to.sin_addr = raw.
giaddr;
1984 if (raw.
giaddr.s_addr != htonl (INADDR_LOOPBACK))
1985 #if defined(RELAY_PORT)
1986 to.sin_port = relay_port ? relay_port :
local_port;
1993 if (fallback_interface) {
1994 result =
send_packet(fallback_interface, packet, &raw,
1998 log_error (
"%s:%d: Failed to send %d byte long "
1999 "packet over %s interface.",
MDL,
2001 fallback_interface->name);
2012 result =
send_packet(packet->interface, packet, &raw,
2015 log_error (
"%s:%d: Failed to send %d byte long packet over %s "
2017 packet->interface->name);
2041 struct packet *packet;
2052 NULL, packet->options,
2054 (lease ? &lease->
scope : NULL),
2060 packet->sv_echo_client_id = ISC_TRUE;
2064 memset(&client_id, 0,
sizeof client_id);
2067 packet->options, NULL,
2068 (lease ? &lease->
scope : NULL),
2077 option_code_hash_lookup(&oc->
option,
2092 struct packet *packet;
2099 int used, count, high_threshold, poolhigh = 0, poollow = 0;
2100 char *shared_name =
"no name";
2128 log_error(
"Pool threshold reset - shared subnet: %s; "
2129 "address: %s; low threshold %d/%d.",
2145 if ((poolhigh <= 0) || (poolhigh > 100)) {
2152 if (used < high_threshold) {
2158 log_error(
"Pool threshold exceeded - shared subnet: %s; "
2159 "address: %s; high threshold %d%% %d/%d.",
2161 poolhigh, used, count);
2177 if (poollow < poolhigh) {
2184 struct packet *packet;
2197 TIME offered_lease_time;
2199 TIME min_lease_time;
2203 isc_result_t result;
2206 struct in_addr from;
2207 TIME remaining_time;
2209 #if defined(DELAYED_ACK)
2211 isc_boolean_t enqueue = ISC_FALSE;
2213 int use_old_lease = 0;
2225 lease_cltt = lease->
cltt;
2229 host_reference (&host, hp,
MDL);
2230 else if (lease -> host)
2231 host_reference (&host, lease -> host,
MDL);
2236 log_fatal (
"unable to allocate lease state!");
2237 state -> got_requested_address = packet -> got_requested_address;
2244 state -> got_server_identifier = 1;
2246 maybe_return_agent_options(packet, state->
options);
2270 NULL, packet->options,
2277 packet->options, state->
options,
2284 for (i = packet -> class_count; i > 0; i--) {
2286 packet->options, state->
options,
2288 packet->classes[i - 1]->group,
2310 state -> options, &lease -> scope,
2315 seek = (
struct lease *)0;
2320 if (seek == lease && !seek ->
n_uid) {
2321 lease_dereference (&seek,
MDL);
2324 next = (
struct lease *)0;
2328 next = (
struct lease *)0;
2331 lease_reference (&next, seek ->
n_uid,
MDL);
2332 if (seek != lease &&
2339 lease_dereference (&seek,
MDL);
2341 lease_reference (&seek, next,
MDL);
2342 lease_dereference (&next,
MDL);
2346 lease_dereference (&next,
MDL);
2349 lease_dereference (&seek,
MDL);
2356 !host -> client_identifier.len &&
2366 seek = (
struct lease *)0;
2372 if (seek == lease && !seek ->
n_hw) {
2373 lease_dereference (&seek,
MDL);
2376 next = (
struct lease *)0;
2379 lease_reference (&next, seek ->
n_hw,
MDL);
2380 if (seek != lease &&
2387 lease_dereference (&seek,
MDL);
2389 lease_reference (&seek, next,
MDL);
2390 lease_dereference (&next,
MDL);
2394 lease_dereference (&next,
MDL);
2397 lease_dereference (&seek,
MDL);
2407 memset (&d1, 0,
sizeof d1);
2413 packet -> options, state -> options,
2416 ntohs (packet -> raw -> secs) < d1.
data [0]) {
2417 log_info(
"%s: configured min-secs value (%d) "
2418 "is greater than secs field (%d). "
2419 "message dropped.", msg, d1.
data[0],
2420 ntohs(packet->raw->secs));
2424 host_dereference (&host,
MDL);
2447 packet -> options, state -> options,
2448 &lease -> scope, oc,
MDL)) {
2451 for (h = hp; h; h = h ->
n_ipaddr) {
2452 if (!h -> fixed_addr)
2456 host_reference (&host, h,
MDL);
2458 host_dereference(&hp,
MDL);
2462 packet -> raw -> htype,
2463 packet -> raw -> chaddr,
2464 packet -> raw -> hlen,
2466 for (h = hp; h; h = h ->
n_ipaddr) {
2467 if (!h -> fixed_addr)
2471 host_reference (&host, h,
MDL);
2473 host_dereference(&hp,
MDL);
2477 packet->options,
MDL);
2478 for (h = hp; h; h = h ->
n_ipaddr) {
2479 if (!h -> fixed_addr)
2483 host_reference (&host, h,
MDL);
2485 host_dereference(&hp,
MDL);
2493 packet->options, state->
options,
2510 &lease -> scope, oc,
MDL)) {
2512 log_info (
"%s: unknown client", msg);
2515 host_dereference (&host,
MDL);
2528 &lease -> scope, oc,
MDL)) {
2530 log_info (
"%s: bootp disallowed", msg);
2533 host_dereference (&host,
MDL);
2546 &lease -> scope, oc,
MDL)) {
2548 log_info (
"%s: booting disallowed", msg);
2551 host_dereference (&host,
MDL);
2560 if (lease -> billing_class) {
2561 for (i = 0; i < packet -> class_count; i++)
2562 if (packet -> classes [i] ==
2563 lease -> billing_class)
2565 if (i == packet -> class_count) {
2580 for (i = 0; i < packet->class_count; i++) {
2581 struct class *billclass, *subclass;
2583 billclass = packet->classes[i];
2590 if (subclass == NULL)
2591 cname = subclass->
name;
2593 cname = billclass->
name;
2596 if (bill != 0 && i == packet->class_count) {
2597 log_info(
"%s: no available billing: lease "
2598 "limit reached in all matching "
2599 "classes (last: '%s')", msg, cname);
2602 host_dereference(&host,
MDL);
2632 packet -> options, state -> options,
2633 &lease -> scope, oc,
MDL);
2641 packet -> options, state -> options,
2642 &lease -> scope, oc,
MDL);
2647 lt = (
struct lease *)0;
2648 result = lease_allocate (<,
MDL);
2650 log_info (
"%s: can't allocate temporary lease structure: %s",
2651 msg, isc_result_totext (result));
2654 host_dereference (&host,
MDL);
2678 if (d1.
len == sizeof (u_int32_t))
2679 default_lease_time =
2695 if (s1 && (d1.
len == 4)) {
2696 u_int32_t ones = 0xffffffff;
2722 if ((memcmp(d1.
data, &ones, 4) == 0) &&
2727 lease, NULL, packet->options,
2733 "reservation made on %s.",
2753 if (d1.
len == sizeof (u_int32_t))
2762 || lease_time > max_lease_time)
2766 if (min_lease_time > max_lease_time)
2776 if (d1.
len == sizeof (u_int32_t))
2786 memset(&d1, 0,
sizeof(d1));
2791 packet->options, state->
options,
2793 if (d1.
len == 1 && d1.
data[0] > 0 &&
2796 int poolfilled, total, count;
2799 adaptive_time = min_lease_time;
2811 poolfilled = (total > (INT_MAX / 100)) ?
2812 total / (count / 100) :
2813 (total * 100) / count;
2815 log_debug(
"Adap-lease: Total: %d, Free: %d, "
2816 "Ends: %d, Adaptive: %d, Fill: %d, "
2821 (
int)adaptive_time, poolfilled,
2824 if (poolfilled >= d1.
data[0] &&
2825 lease_time > adaptive_time) {
2826 log_info(
"Pool over threshold, time "
2827 "for %s reduced from %d to "
2830 (
int)adaptive_time);
2832 lease_time = adaptive_time;
2854 lease_dereference (<,
MDL);
2856 host_dereference (&host,
MDL);
2884 lease_dereference (<,
MDL);
2886 host_dereference (&host,
MDL);
2890 if (lease_time > remaining_time)
2891 lease_time = remaining_time;
2894 if (lease_time < min_lease_time) {
2896 lease_time = min_lease_time;
2902 #if defined (FAILOVER_PROTOCOL)
2905 if (lease ->
pool && lease ->
pool -> failover_peer) {
2906 TIME new_lease_time = lease_time;
2907 dhcp_failover_state_t *peer =
2908 lease ->
pool -> failover_peer;
2917 if (lease_time > peer->mclt) {
2925 new_lease_time = peer->mclt;
2927 (lt->
tsfp + peer->mclt))
2946 + (new_lease_time / 2)),
2961 lease_time = new_lease_time;
2971 = leaseTimeCheck(
cur_time + lease_time,
2978 lt ->
ends = state -> offered_expiry;
2998 if (d1.
len == sizeof (u_int32_t))
3011 if (d1.
len == sizeof (u_int32_t))
3018 lt ->
ends = state -> offered_expiry = cur_time + lease_time;
3030 packet->options, state->
options,
3038 packet->options, state->
options,
3046 unsigned char *tuid;
3062 host_reference (< -> host, host,
MDL);
3063 host_dereference (&host,
MDL);
3065 if (lease -> subnet)
3066 subnet_reference (< -> subnet, lease -> subnet,
MDL);
3079 if (lease ->
scope) {
3107 if (!packet->agent_options_stashed &&
3108 (packet->options != NULL) &&
3148 }
else if (oc && s1) {
3151 log_error (
"no memory for client hostname.");
3165 sizeof packet -> raw -> chaddr);
3173 log_debug (
"Cannot reuse: lease is changing to RESERVED");
3192 if ((!offer || offer ==
DHCPACK) &&
3205 if (lease ->
flags & STATIC_LEASE) {
3211 packet -> raw -> chaddr,
3212 sizeof packet -> raw -> chaddr);
3214 int commit = (!offer || (offer ==
DHCPACK));
3218 use_old_lease = reuse_lease(packet, lt, lease, state, offer);
3219 if (use_old_lease == 1) {
3223 #if !defined(DELAYED_ACK)
3232 if ((use_old_lease == 0) &&
3252 if ((use_old_lease == 0) &&
3254 !offer || offer ==
DHCPACK, 0, 0)) {
3256 log_info (
"%s: database update failed", msg);
3258 lease_dereference (<,
MDL);
3262 lease_dereference (<,
MDL);
3265 state ->
ip = packet -> interface;
3269 state -> ciaddr = packet -> raw -> ciaddr;
3270 state -> xid = packet -> raw -> xid;
3271 state -> secs = packet -> raw -> secs;
3272 state -> bootp_flags = packet -> raw ->
flags;
3273 state -> hops = packet -> raw -> hops;
3274 state -> offer = offer;
3282 packet -> options, state -> options,
3293 packet -> options, state -> options,
3295 if (d1.
len == sizeof (u_int16_t))
3304 packet -> options, state -> options,
3306 if (d1.
len == sizeof (u_int16_t))
3307 state -> max_message_size =
3338 if (state -> offer) {
3343 &state -> offer, 1, 0, 0,
MDL)) {
3344 option_code_hash_lookup(&oc->
option,
3348 state -> options, oc);
3355 memcpy(state->
from.
iabuf, &from,
sizeof(from));
3356 state->
from.
len =
sizeof(from);
3358 offered_lease_time =
3359 state -> offered_expiry -
cur_time;
3367 option_code_hash_lookup(&oc->
option,
3371 state -> options, oc);
3384 packet->options, state->
options,
3389 if (rebind_time >= offered_lease_time)
3393 offered_lease_time = rebind_time;
3401 packet->options, state->
options,
3411 if (state ->
ip -> address_count) {
3413 sizeof state ->
ip -> addresses [0];
3414 memcpy (state -> from.iabuf,
3415 &state ->
ip -> addresses [0],
3421 memset (&state -> siaddr, 0,
sizeof state -> siaddr);
3427 packet -> options, state -> options,
3428 &lease -> scope, oc,
MDL)) {
3432 memcpy (&state -> siaddr, d1.
data, 4);
3444 lease -> subnet -> netmask.iabuf,
3445 lease -> subnet -> netmask.len,
3447 option_code_hash_lookup(&oc->
option,
3451 state -> options, oc);
3471 (&ignorep, packet, lease, NULL,
3479 h = gethostbyaddr ((
char *)&ia,
sizeof ia, AF_INET);
3481 log_error (
"No hostname for %s", inet_ntoa (ia));
3488 strlen (h -> h_name) + 1,
3490 option_code_hash_lookup(&oc->
option,
3494 state -> options, oc);
3507 packet -> options, state -> options, &lease -> scope,
3519 option_code_hash_lookup(&oc->
option,
3523 state -> options, oc);
3536 packet -> options, state -> options,
3537 &lease -> scope, oc,
MDL)) {
3541 (
const char *)d1.
data, d1.
len,
3547 state -> options -> site_universe = u ->
index;
3569 packet -> options, state -> options,
3570 &lease -> scope, oc,
MDL);
3574 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
3577 lease -> state = state;
3586 if (offer ==
DHCPOFFER && !(lease -> flags & STATIC_LEASE) &&
3595 &lease -> scope, oc,
MDL))) {
3605 &lease -> scope, oc,
MDL)) {
3606 if (d1.
len == sizeof (u_int32_t))
3616 log_debug (
"Ping timeout: %ld", (
long)ping_timeout);
3625 tv.tv_sec =
cur_tv.tv_sec + ping_timeout;
3626 tv.tv_usec =
cur_tv.tv_usec;
3633 #if defined(DELAYED_ACK)
3635 delayed_ack_enqueue(lease);
3642 #if defined(DELAYED_ACK)
3654 delayed_ack_enqueue(
struct lease *lease)
3660 if (free_ackqueue) {
3662 free_ackqueue = q->
next;
3667 log_fatal(
"delayed_ack_enqueue: no memory!");
3669 memset(q, 0,
sizeof *q);
3671 lease_reference(&q->
lease, lease,
MDL);
3672 q->
next = ackqueue_head;
3683 delayed_acks_timer(NULL);
3685 struct timeval next_fsync;
3687 if (max_fsync.tv_sec == 0 && max_fsync.tv_usec == 0) {
3690 max_fsync.tv_usec =
cur_tv.tv_usec +
3693 if (max_fsync.tv_usec >= 1000000) {
3695 max_fsync.tv_usec -= 1000000;
3700 next_fsync.tv_sec =
cur_tv.tv_sec;
3701 next_fsync.tv_usec =
cur_tv.tv_usec + min_ack_delay_usecs;
3702 if (next_fsync.tv_usec >= 1000000) {
3703 next_fsync.tv_sec++;
3704 next_fsync.tv_usec -= 1000000;
3707 if ((next_fsync.tv_sec > max_fsync.tv_sec) ||
3708 ((next_fsync.tv_sec == max_fsync.tv_sec) &&
3709 (next_fsync.tv_usec > max_fsync.tv_usec))) {
3710 next_fsync.tv_sec = max_fsync.tv_sec;
3711 next_fsync.tv_usec = max_fsync.tv_usec;
3714 add_timeout(&next_fsync, delayed_acks_timer, NULL,
3725 delayed_acks_timer(
void *foo)
3730 memset(&max_fsync, 0,
sizeof(max_fsync));
3732 if (!outstanding_acks) {
3747 for (ack = ackqueue_tail ; ack ; ack =
p) {
3750 #if defined(FAILOVER_PROTOCOL)
3754 dhcp_failover_state_t *fpeer;
3757 if (fpeer && fpeer->link_to_peer) {
3765 log_error(
"delayed ack for %s has gone stale",
3771 lease_dereference(&ack->
lease,
MDL);
3772 ack->
next = free_ackqueue;
3773 free_ackqueue = ack;
3776 ackqueue_head = NULL;
3777 ackqueue_tail = NULL;
3778 outstanding_acks = 0;
3781 #if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
3783 relinquish_ackqueue(
void)
3787 for (q = ackqueue_head ; q ; q = n) {
3791 for (q = free_ackqueue ; q ; q = n) {
3801 struct lease *lease;
3804 unsigned packet_length;
3806 struct sockaddr_in to;
3807 struct in_addr from;
3811 int nulltp, bootpp, unicastp = 1;
3812 #if defined(RELAY_PORT)
3813 u_int16_t relay_port = 0;
3819 log_fatal (
"dhcp_reply was supplied lease with no state!");
3822 memset (&raw, 0,
sizeof raw);
3823 memset (&d1, 0,
sizeof d1);
3827 if (state -> filename.len && state -> filename.data) {
3829 state -> filename.data,
3830 state -> filename.len >
sizeof raw.
file
3831 ?
sizeof raw.
file : state -> filename.len);
3832 if (
sizeof raw.
file > state -> filename.len)
3833 memset (&raw.
file [state -> filename.len], 0,
3834 (
sizeof raw.
file) - state -> filename.len);
3836 log_info(
"file name longer than packet field "
3837 "truncated - field: %lu name: %d %.*s",
3838 (
unsigned long)
sizeof(raw.
file),
3839 state->filename.len, (
int)state->filename.len,
3840 state->filename.data);
3846 if (state -> server_name.len && state -> server_name.data) {
3848 state -> server_name.data,
3849 state -> server_name.len >
sizeof raw.
sname
3850 ?
sizeof raw.
sname : state -> server_name.len);
3851 if (
sizeof raw.
sname > state -> server_name.len)
3852 memset (&raw.
sname [state -> server_name.len], 0,
3853 (
sizeof raw.
sname) - state -> server_name.len);
3855 log_info(
"server name longer than packet field "
3856 "truncated - field: %lu name: %d %.*s",
3857 (
unsigned long)
sizeof(raw.
sname),
3865 &lease -> hardware_addr.hbuf [1],
sizeof raw.
chaddr);
3866 raw.
hlen = lease -> hardware_addr.hlen - 1;
3867 raw.
htype = lease -> hardware_addr.hbuf [0];
3883 packet_length =
cons_options (state -> packet, &raw, lease,
3885 state -> max_message_size,
3886 state -> packet -> options,
3888 bufs, nulltp, bootpp,
3889 &state -> parameter_request_list,
3892 memcpy (&raw.
ciaddr, &state -> ciaddr,
sizeof raw.
ciaddr);
3894 raw.
siaddr = state -> siaddr;
3897 raw.
xid = state -> xid;
3898 raw.
secs = state -> secs;
3899 raw.
flags = state -> bootp_flags;
3900 raw.
hops = state -> hops;
3903 if (lease -> client_hostname) {
3904 if ((strlen (lease -> client_hostname) <= 64) &&
3906 s = lease -> client_hostname;
3908 s =
"Hostname Unsuitable for Printing";
3917 #if defined(DHCPv6) && defined(DHCP4o6)
3920 log_info (
"DHCP4o6 %s on %s to %s %s%s%svia %s",
3923 ?
"DHCPACK" :
"DHCPOFFER")
3926 (lease -> hardware_addr.hlen
3928 lease -> hardware_addr.hlen - 1,
3929 &lease -> hardware_addr.hbuf [1])
3931 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
3938 packet_length,
MDL)) {
3939 log_fatal(
"No memory to store DHCP4o6 reply.");
3944 &raw, packet_length);
3955 log_info (
"%s on %s to %s %s%s%svia %s",
3957 ? (state -> offer ==
DHCPACK ?
"DHCPACK" :
"DHCPOFFER")
3960 (lease -> hardware_addr.hlen > 1
3962 lease -> hardware_addr.hlen - 1,
3963 &lease -> hardware_addr.hbuf [1])
3965 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
3967 ? inet_ntoa (state ->
giaddr)
3968 : state ->
ip -> name));
3971 dump_raw ((
unsigned char *)&raw, packet_length);
3975 hto.
hlen = lease -> hardware_addr.hlen;
3976 memcpy (hto.
hbuf, lease -> hardware_addr.hbuf, hto.
hlen);
3978 to.sin_family = AF_INET;
3980 to.sin_len =
sizeof to;
3982 memset (to.sin_zero, 0,
sizeof to.sin_zero);
3984 #if defined(RELAY_PORT)
3990 to.sin_addr = raw.
giaddr;
3991 if (raw.
giaddr.s_addr != htonl (INADDR_LOOPBACK))
3992 #if defined(RELAY_PORT)
3993 to.sin_port = relay_port ? relay_port :
local_port;
4000 if (fallback_interface) {
4001 result =
send_packet(fallback_interface, NULL, &raw,
4002 packet_length, raw.
siaddr, &to,
4005 log_error (
"%s:%d: Failed to send %d byte long "
4006 "packet over %s interface.",
MDL,
4008 fallback_interface->name);
4028 }
else if (raw.
ciaddr.s_addr &&
4035 to.sin_addr = raw.
ciaddr;
4038 if (fallback_interface) {
4039 result =
send_packet(fallback_interface, NULL, &raw,
4040 packet_length, raw.
siaddr, &to,
4043 log_error(
"%s:%d: Failed to send %d byte long"
4044 " packet over %s interface.",
MDL,
4046 fallback_interface->name);
4060 to.sin_addr = raw.
yiaddr;
4071 memcpy (&from, state -> from.iabuf,
sizeof from);
4074 from, &to, unicastp ? &hto : NULL);
4076 log_error (
"%s:%d: Failed to send %d byte long "
4077 "packet over %s interface.",
MDL,
4078 packet_length, state->
ip->
name);
4091 int *peer_has_leases,
struct lease *ip_lease_in,
4094 struct lease *uid_lease = (
struct lease *)0;
4095 struct lease *ip_lease = (
struct lease *)0;
4096 struct lease *hw_lease = (
struct lease *)0;
4097 struct lease *lease = (
struct lease *)0;
4101 struct lease *fixed_lease = (
struct lease *)0;
4102 struct lease *next = (
struct lease *)0;
4105 int have_client_identifier = 0;
4109 #if defined(FAILOVER_PROTOCOL)
4111 if (peer_has_leases) {
4114 for (pool = share->
pools ; pool ; pool = pool->
next) {
4119 (peer->i_am == secondary && pool->
free_leases))) {
4120 *peer_has_leases = 1;
4127 if (packet -> raw -> ciaddr.s_addr) {
4129 memcpy (cip.
iabuf, &packet -> raw -> ciaddr, 4);
4134 memset (&d1, 0,
sizeof d1);
4141 packet -> got_requested_address = 1;
4153 memset (&client_identifier, 0,
sizeof client_identifier);
4156 packet, (
struct lease *)0,
4161 have_client_identifier = 1;
4166 client_identifier.
len,
MDL)) {
4168 packet ->
known = 1;
4172 #if defined (DEBUG_FIND_LEASE)
4174 log_info (
"Found host for client identifier: %s.",
4180 host_reference (&host, hp,
MDL);
4181 host_dereference (&hp,
MDL);
4185 client_identifier.
len,
MDL);
4190 if (!fixed_lease && !host) {
4192 packet -> raw -> chaddr,
4193 packet -> raw -> hlen,
MDL)) {
4195 packet ->
known = 1;
4197 host_dereference (&host,
MDL);
4198 host_reference (&host, hp,
MDL);
4199 host_dereference (&hp,
MDL);
4201 #if defined (DEBUG_FIND_LEASE)
4203 log_info (
"Found host for link address: %s.",
4212 if (!fixed_lease && !host) {
4217 host_dereference(&host,
MDL);
4218 host_reference(&host, hp,
MDL);
4219 host_dereference(&hp,
MDL);
4221 #if defined (DEBUG_FIND_LEASE)
4223 log_info (
"Found host via host-identifier");
4232 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease &&
4238 strcpy (dhcp_message,
"requested address is incorrect");
4239 #if defined (DEBUG_FIND_LEASE)
4240 log_info (
"Client's fixed-address %s doesn't match %s%s",
4259 #if defined (DEBUG_FIND_LEASE)
4260 log_info (
"trying next lease matching client id: %s",
4264 #if defined (FAILOVER_PROTOCOL)
4276 #if defined (DEBUG_FIND_LEASE)
4277 log_info(
"not active or not mine to allocate: %s",
4285 #if defined (DEBUG_FIND_LEASE)
4286 log_info (
"wrong network segment: %s",
4291 do_release = ISC_FALSE;
4299 #if defined (DEBUG_FIND_LEASE)
4304 if (uid_lease -> n_uid)
4305 lease_reference (&next,
4306 uid_lease -> n_uid,
MDL);
4309 lease_dereference (&uid_lease,
MDL);
4311 lease_reference (&uid_lease, next,
MDL);
4312 lease_dereference (&next,
MDL);
4318 #if defined (DEBUG_FIND_LEASE)
4320 log_info (
"Found lease for client id: %s.",
4331 h.
hlen = packet -> raw -> hlen + 1;
4332 h.
hbuf [0] = packet -> raw -> htype;
4333 memcpy (&h.
hbuf [1], packet -> raw -> chaddr, packet -> raw -> hlen);
4336 #if defined (DEBUG_FIND_LEASE)
4337 log_info (
"trying next lease matching hw addr: %s",
4340 #if defined (FAILOVER_PROTOCOL)
4353 #if defined (DEBUG_FIND_LEASE)
4354 log_info(
"not active or not mine to allocate: %s",
4367 if (hw_lease -> binding_state !=
FTS_FREE &&
4370 (!have_client_identifier ||
4371 hw_lease -> uid_len != client_identifier.
len ||
4372 memcmp (hw_lease -> uid, client_identifier.
data,
4373 hw_lease -> uid_len))) {
4374 #if defined (DEBUG_FIND_LEASE)
4375 log_info (
"wrong client identifier: %s",
4381 #if defined (DEBUG_FIND_LEASE)
4382 log_info (
"wrong network segment: %s",
4391 #if defined (DEBUG_FIND_LEASE)
4395 if (!packet -> raw -> ciaddr.s_addr)
4398 if (hw_lease -> n_hw)
4399 lease_reference (&next, hw_lease -> n_hw,
MDL);
4400 lease_dereference (&hw_lease,
MDL);
4402 lease_reference (&hw_lease, next,
MDL);
4403 lease_dereference (&next,
MDL);
4409 #if defined (DEBUG_FIND_LEASE)
4411 log_info (
"Found lease for hardware address: %s.",
4418 lease_reference (&ip_lease, ip_lease_in,
MDL);
4422 #if defined (DEBUG_FIND_LEASE)
4424 log_info (
"Found lease for requested address: %s.",
4431 if (ip_lease && ours)
4441 if (ip_lease && (ip_lease -> subnet ->
shared_network != share)) {
4444 #if defined (DEBUG_FIND_LEASE)
4445 log_info (
"...but it was on the wrong shared network.");
4447 strcpy (dhcp_message,
"requested address on bad subnet");
4448 lease_dereference (&ip_lease,
MDL);
4462 (!have_client_identifier ||
4463 ip_lease -> uid_len != client_identifier.
len ||
4464 memcmp (ip_lease -> uid, client_identifier.
data,
4465 ip_lease -> uid_len)) :
4466 (ip_lease -> hardware_addr.hbuf [0] != packet -> raw -> htype ||
4467 ip_lease -> hardware_addr.hlen != packet -> raw -> hlen + 1 ||
4468 memcmp (&ip_lease -> hardware_addr.hbuf [1],
4469 packet -> raw -> chaddr,
4470 (
unsigned)(ip_lease -> hardware_addr.hlen - 1))))) {
4479 if (ip_lease -> binding_state !=
FTS_FREE &&
4481 #if defined (DEBUG_FIND_LEASE)
4482 log_info (
"rejecting lease for requested address.");
4486 if (ours && ip_lease -> binding_state !=
FTS_ACTIVE)
4488 lease_dereference (&ip_lease,
MDL);
4496 if (ip_lease && (uid_lease || hw_lease) &&
4503 #if defined (DEBUG_FIND_LEASE)
4504 log_info(
"ip lease not active or not ours to offer.");
4506 lease_dereference(&ip_lease,
MDL);
4513 ip_lease->
uid && ip_lease != uid_lease) {
4514 if (have_client_identifier &&
4515 (ip_lease -> uid_len == client_identifier.
len) &&
4516 !memcmp (client_identifier.
data,
4517 ip_lease -> uid, ip_lease -> uid_len)) {
4520 log_error (
"client %s has duplicate%s on %s",
4523 (ip_lease -> subnet ->
4531 !packet -> raw -> ciaddr.s_addr &&
4537 lease_dereference (&uid_lease,
MDL);
4538 lease_reference (&uid_lease, ip_lease,
MDL);
4545 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease) {
4546 lease_dereference (&fixed_lease,
MDL);
4548 log_error (
"Dynamic and static leases present for %s.",
4550 log_error (
"Remove host declaration %s or remove %s",
4551 (fixed_lease && fixed_lease -> host
4552 ? (fixed_lease -> host -> name
4553 ? fixed_lease -> host -> name
4557 log_error (
"from the dynamic address pool for %s",
4561 lease_dereference (&ip_lease,
MDL);
4563 "database conflict - call for help!");
4566 if (ip_lease && ip_lease != uid_lease) {
4567 #if defined (DEBUG_FIND_LEASE)
4568 log_info (
"requested address not available.");
4570 lease_dereference (&ip_lease,
MDL);
4576 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease && ip_lease)
4580 if (hw_lease && hw_lease == uid_lease) {
4581 #if defined (DEBUG_FIND_LEASE)
4582 log_info (
"hardware lease and uid lease are identical.");
4584 lease_dereference (&hw_lease,
MDL);
4586 if (ip_lease && ip_lease == hw_lease) {
4587 lease_dereference (&hw_lease,
MDL);
4588 #if defined (DEBUG_FIND_LEASE)
4589 log_info (
"hardware lease and ip lease are identical.");
4592 if (ip_lease && ip_lease == uid_lease) {
4593 lease_dereference (&uid_lease,
MDL);
4594 #if defined (DEBUG_FIND_LEASE)
4595 log_info (
"uid lease and ip lease are identical.");
4609 lease_dereference (&ip_lease,
MDL);
4617 if (!packet -> raw -> ciaddr.s_addr)
4619 lease_dereference (&uid_lease,
MDL);
4627 if (!packet -> raw -> ciaddr.s_addr)
4629 lease_dereference (&hw_lease,
MDL);
4636 strcpy (dhcp_message,
"requested address not available");
4643 !ip_lease && !fixed_lease) {
4644 #if defined (DEBUG_FIND_LEASE)
4645 log_info (
"no applicable lease found for DHCPREQUEST.");
4653 lease_reference (&lease, fixed_lease,
MDL);
4654 lease_dereference (&fixed_lease,
MDL);
4655 #if defined (DEBUG_FIND_LEASE)
4656 log_info (
"choosing fixed address.");
4664 if (!packet -> raw -> ciaddr.s_addr)
4666 #if defined (DEBUG_FIND_LEASE)
4667 log_info (
"not choosing requested address (!).");
4669 lease_dereference (&ip_lease,
MDL);
4671 #if defined (DEBUG_FIND_LEASE)
4672 log_info (
"choosing lease on requested address.");
4674 lease_reference (&lease, ip_lease,
MDL);
4676 host_dereference (&lease -> host,
MDL);
4685 log_error(
"uid lease %s for client %s is duplicate "
4691 if (!packet -> raw -> ciaddr.s_addr &&
4695 #if defined (DEBUG_FIND_LEASE)
4696 log_info (
"not choosing uid lease.");
4699 lease_reference (&lease, uid_lease,
MDL);
4701 host_dereference (&lease -> host,
MDL);
4702 #if defined (DEBUG_FIND_LEASE)
4706 lease_dereference (&uid_lease,
MDL);
4712 #if defined (DEBUG_FIND_LEASE)
4713 log_info (
"not choosing hardware lease.");
4720 if (!hw_lease -> uid_len ||
4721 (have_client_identifier
4722 ? (hw_lease -> uid_len ==
4723 client_identifier.
len &&
4724 !memcmp (hw_lease -> uid,
4725 client_identifier.
data,
4726 client_identifier.
len))
4727 : packet -> packet_type == 0)) {
4728 lease_reference (&lease, hw_lease,
MDL);
4730 host_dereference (&lease -> host,
MDL);
4731 #if defined (DEBUG_FIND_LEASE)
4732 log_info (
"choosing hardware lease.");
4735 #if defined (DEBUG_FIND_LEASE)
4736 log_info (
"not choosing hardware lease: %s.",
4741 lease_dereference (&hw_lease,
MDL);
4750 if (lease && host && !lease->
host) {
4754 host_reference(&p, host,
MDL);
4773 host_reference(&lease->
host, p,
MDL);
4775 host_dereference(&p,
MDL);
4780 host_dereference(&p,
MDL);
4782 host_reference(&p, n,
MDL);
4783 host_dereference(&n,
MDL);
4794 lease == ip_lease &&
4796 log_error (
"Reclaiming REQUESTed abandoned IP address %s.",
4798 }
else if (lease && (lease -> binding_state ==
FTS_ABANDONED)) {
4805 lease_dereference (&lease,
MDL);
4809 if (have_client_identifier)
4813 lease_dereference (&fixed_lease,
MDL);
4815 lease_dereference (&hw_lease,
MDL);
4817 lease_dereference (&uid_lease,
MDL);
4819 lease_dereference (&ip_lease,
MDL);
4821 host_dereference (&host,
MDL);
4824 #if defined (DEBUG_FIND_LEASE)
4828 lease_reference (lp, lease, file, line);
4829 lease_dereference (&lease,
MDL);
4832 #if defined (DEBUG_FIND_LEASE)
4833 log_info (
"Not returning a lease.");
4845 struct lease *lease = (
struct lease *)0;
4851 lease_dereference (&lease,
MDL);
4855 &rhp, &lease ->
ip_addr, share)) {
4856 lease_dereference (&lease,
MDL);
4857 host_dereference (&rhp,
MDL);
4860 host_reference (&lease -> host, rhp,
MDL);
4864 lease -> uid = lease -> uid_buf;
4865 if (!lease -> uid) {
4866 lease_dereference (&lease,
MDL);
4867 host_dereference (&rhp,
MDL);
4873 lease -> hardware_addr = rhp ->
interface;
4874 lease -> starts = lease -> cltt = lease -> ends =
MIN_TIME;
4878 lease_reference (lp, lease,
MDL);
4880 lease_dereference (&lease,
MDL);
4881 host_dereference (&rhp,
MDL);
4893 struct pool *
pool,
int *peer_has_leases)
4895 struct lease *lease = NULL;
4896 struct lease *candl = NULL;
4898 for (;
pool ; pool = pool ->
next) {
4899 if ((pool -> prohibit_list &&
4900 permitted (packet, pool -> prohibit_list)) ||
4901 (pool -> permit_list &&
4902 !
permitted (packet, pool -> permit_list)))
4905 #if defined (FAILOVER_PROTOCOL)
4921 struct lease *peerl = NULL;
4932 if (peerl != NULL) {
4933 if (((candl == NULL) ||
4938 *peer_has_leases = 1;
4945 if (peerl != NULL) {
4946 if (((candl == NULL) ||
4951 *peer_has_leases = 1;
4958 if ((candl == NULL) && (peerl != NULL) &&
5004 (candl -> ends < lease ->
ends))) {
5012 (candl -> ends < lease -> ends))) {
5018 if (candl -> ends < lease -> ends)
5022 if (lease != NULL) {
5024 log_error(
"Reclaiming abandoned lease %s.",
5032 if (lease->
host != NULL) {
5033 log_debug(
"soft impossible condition (%s:%d): stale "
5034 "host \"%s\" found on lease %s",
MDL,
5037 host_dereference(&lease->
host,
MDL);
5040 lease_reference (lp, lease,
MDL);
5052 struct packet *packet;
5053 struct
permit *permit_list;
5058 for (p = permit_list;
p; p = p ->
next) {
5059 switch (p ->
type) {
5061 if (!packet ->
known)
5066 if (packet ->
known)
5071 if (packet -> authenticated)
5076 if (!packet -> authenticated)
5084 if (!packet -> options_valid ||
5085 !packet -> packet_type)
5090 for (i = 0; i < packet -> class_count; i++) {
5091 if (p ->
class == packet -> classes [i])
5093 if (packet -> classes [i] &&
5094 packet -> classes [i] -> superclass &&
5095 (packet -> classes [i] -> superclass ==
5110 #if defined(DHCPv6) && defined(DHCP4o6)
5111 static int locate_network6 (packet)
5112 struct packet *packet;
5114 const struct packet *chk_packet;
5115 const struct in6_addr *link_addr, *first_link_addr;
5118 struct subnet *subnet = NULL;
5142 packet->options, NULL,
5158 shared_network_reference(&packet->shared_network,
5160 subnet_dereference(&subnet,
MDL);
5169 if (packet->raw->giaddr.s_addr) {
5171 memcpy(ia.iabuf, &packet->raw->giaddr, 4);
5174 shared_network_reference(&packet->shared_network,
5176 subnet_dereference(&subnet,
MDL);
5187 first_link_addr = NULL;
5189 while (chk_packet != NULL) {
5191 if (!IN6_IS_ADDR_UNSPECIFIED(link_addr) &&
5192 !IN6_IS_ADDR_LINKLOCAL(link_addr)) {
5193 first_link_addr = link_addr;
5202 if (first_link_addr != NULL) {
5203 ia.len =
sizeof(*first_link_addr);
5204 memcpy(ia.iabuf, first_link_addr,
sizeof(*first_link_addr));
5206 shared_network_reference(&packet->shared_network,
5208 subnet_dereference(&subnet,
MDL);
5217 if (packet->interface != NULL) {
5218 if (packet->interface->shared_network == NULL)
5220 shared_network_reference(&packet->shared_network,
5221 packet->interface->shared_network,
5230 log_error(
"No interface and no link address "
5231 "can't determine DHCP4o6 shared network");
5237 struct packet *packet;
5241 struct subnet *subnet = (
struct subnet *)0;
5245 #if defined(DHCPv6) && defined(DHCP4o6)
5247 return (locate_network6 (packet));
5263 if (!oc && !packet -> raw ->
giaddr.s_addr) {
5265 struct in_addr any_addr;
5266 any_addr.s_addr = INADDR_ANY;
5268 if (!packet -> packet_type && memcmp(&packet -> raw -> ciaddr, &any_addr, 4)) {
5270 memcpy(cip.
iabuf, &packet -> raw -> ciaddr, 4);
5289 memset (&data, 0,
sizeof data);
5297 if (data.
len == 0) {
5300 if (data.
len != 4) {
5310 memcpy (ia.
iabuf, &packet->raw->ciaddr, 4);
5312 memcpy (ia.
iabuf, &packet->raw->giaddr, 4);
5319 subnet_dereference (&subnet,
MDL);
5364 struct packet *packet) {
5365 unsigned option_num;
5368 struct in_addr *a = NULL;
5369 isc_boolean_t found = ISC_FALSE;
5372 memset(&d, 0,
sizeof(d));
5373 memset(from, 0,
sizeof(*from));
5381 if (d.
len ==
sizeof(*from)) {
5383 memcpy(from, d.
data,
sizeof(*from));
5389 if ((out_options != NULL) &&
5390 (options != out_options)) {
5400 if ((found == ISC_FALSE) &&
5404 if (out_options != NULL) {
5412 (
unsigned char *)a,
sizeof(*a),
5413 0, allocate,
MDL)) {
5414 option_code_hash_lookup(&oc->
option,
5416 &option_num, 0,
MDL);
5448 struct packet *packet,
5449 struct group *network_group) {
5451 if (*network_options == NULL) {
5466 packet->
options, *network_options,
5472 packet->
options, *network_options,
5481 packet->
options, *network_options,
5487 }
else if (network_group != NULL) {
5489 packet->
options, *network_options,
5494 packet->
options, *network_options,
5511 find_min_site_code(
struct universe *u)
5521 site_code_min = 224;
5522 option_code_hash_foreach(u->
code_hash, lowest_site_code);
5524 if (site_code_min < 224) {
5525 log_error(
"WARNING: site-local option codes less than 224 have "
5526 "been deprecated by RFC3942. You have options "
5527 "listed in site local space %s that number as low as "
5528 "%d. Please investigate if these should be declared "
5529 "as regular options rather than site-local options, "
5530 "or migrated up past 224.",
5531 u->
name, site_code_min);
5538 if (site_code_min < 128)
5539 site_code_min = 128;
5548 return site_code_min;
5552 lowest_site_code(
const void *key,
unsigned len,
void *
object)
5556 if (option->
code < site_code_min)
5557 site_code_min = option->
code;
5563 maybe_return_agent_options(
struct packet *packet,
struct option_state *options)
5607 struct lease *lease,
5621 ((
unsigned char*)lease->
host->
name),
5625 option_code_hash_lookup(&oc->
option,
5671 reuse_lease (
struct packet* packet,
5672 struct lease* new_lease,
5673 struct lease* lease,
5687 (new_lease->
ddns_cb == NULL) &&
5688 (lease->
host == new_lease->
host) &&
5690 (memcmp(lease->
uid, new_lease->
uid, lease->
uid_len) == 0) &&
5706 if (d1.
len == 1 && (d1.
data[0] < 100))
5707 thresh = d1.
data[0];
5715 int lease_length = 0;
5720 if (lease_length <= (INT_MAX / thresh))
5721 limit = lease_length * thresh / 100;
5723 limit = lease_length / 100 * thresh;
5729 if (lease_age <= limit) {
5734 if (new_lease->
scope != NULL) {
5735 if (lease->
scope != NULL) {
5753 log_debug(
"reuse_lease: lease age %ld (secs)"
5754 " under %d%% threshold, reply with "
5755 "unaltered, existing lease for %s",
5792 return (calculated);
int supersede_lease(struct lease *, struct lease *, int, int, int, int)
int find_grouped_subnet(struct subnet **, struct shared_network *, struct iaddr, const char *, int)
int mockup_lease(struct lease **, struct packet *, struct shared_network *, struct host_decl *)
char * print_dotted_quads(unsigned len, const u_int8_t *data)
void unbill_class(struct lease *lease)
int find_lease(struct lease **, struct packet *, struct shared_network *, int *, int *, struct lease *, const char *, int)
char sname[DHCP_SNAME_LEN]
struct binding_scope * global_scope
#define DEFAULT_MIN_ACK_DELAY_USECS
#define SV_MAX_LEASE_TIME
#define SV_USE_HOST_DECL_NAMES
void dhcprequest(struct packet *, int, struct lease *)
#define SV_MIN_LEASE_TIME
void dhcpleasequery(struct packet *, int)
void save_option(struct universe *universe, struct option_state *options, struct option_cache *oc)
int executable_statement_dereference(struct executable_statement **ptr, const char *file, int line)
int find_host_for_network(struct subnet **, struct host_decl **, struct iaddr *, struct shared_network *)
void do_release(struct client_state *client)
struct shared_network * shared_network
const char * piaddr(const struct iaddr addr)
struct dhcp_ddns_cb * ddns_cb
struct lease_state * state
struct class * superclass
int option_cache_dereference(struct option_cache **ptr, const char *file, int line)
#define DEFAULT_MIN_LEASE_TIME
struct universe server_universe
int execute_statements(struct binding_value **result, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *out_options, struct binding_scope **scope, struct executable_statement *statements, struct on_star *on_star)
struct iaddr ip_addr(struct iaddr subnet, struct iaddr mask, u_int32_t host_address)
char * print_hw_addr(int htype, const int hlen, const unsigned char *data) const
#define SV_IGNORE_CLIENT_UIDS
void cancel_timeout(void(*)(void *) where, void *what)
int find_hosts_by_option(struct host_decl **, struct packet *, struct option_state *, const char *, int)
#define print_hex_1(len, data, limit)
#define DHO_DHCP_PARAMETER_REQUEST_LIST
#define DEFAULT_ACK_DELAY_USECS
int int int log_debug(const char *,...) __attribute__((__format__(__printf__
void dhcpinform(struct packet *, int)
#define SV_BOOTP_LEASE_LENGTH
void eval_network_statements(struct option_state **options, struct packet *packet, struct group *network_group)
Builds option set from statements at the global and network scope.
struct executable_statement * on_release
void lease_ping_timeout(void *)
#define DHO_DHCP_LEASE_TIME
struct in_addr * addresses
int option_reference(struct option **dest, struct option *src, const char *file, int line)
void dhcpack(struct packet *packet)
struct universe dhcp_universe
struct interface_info * ip
#define SV_SITE_OPTION_SPACE
void data_string_forget(struct data_string *data, const char *file, int line)
#define FIND_PERCENT(count, percent)
void dhcpdecline(struct packet *, int)
struct option_cache * fixed_addr
struct class * billing_class
struct group * root_group
void delete_option(struct universe *universe, struct option_state *options, int code)
int log_error(const char *,...) __attribute__((__format__(__printf__
int binding_scope_dereference(struct binding_scope **ptr, const char *file, int line)
void add_timeout(struct timeval *when, void(*)(void *) where, void *what, tvref_t ref, tvunref_t unref)
void dump_packet(struct packet *)
#define DHO_DHCP_REBINDING_TIME
int allocate_lease(struct lease **, struct packet *, struct pool *, int *)
dhcp_failover_state_t * failover_peer
void release_lease(struct lease *, struct packet *)
int find_hosts_by_haddr(struct host_decl **, int, const unsigned char *, unsigned, const char *, int)
log_fatal("no memory for uname information.")
struct expression * expression
struct data_string client_identifier
const char * binding_state_print(enum failover_state state)
struct option_state * options
#define LEASE_NOT_EMPTY(LQ)
int locate_network(struct packet *)
#define DHO_DHCP_SERVER_IDENTIFIER
void dhcprelease(struct packet *, int)
struct option_state * options
#define DEFAULT_DELAYED_ACK
int option_cache_allocate(struct option_cache **cptr, const char *file, int line)
void get_server_source_address(struct in_addr *from, struct option_state *options, struct option_state *out_options, struct packet *packet)
#define SV_LOG_THRESHOLD_HIGH
#define DEFAULT_ACK_DELAY_SECS
void free_lease_state(struct lease_state *, const char *, int)
universe_hash_t * universe_hash
struct hardware hardware_addr
#define SV_BOOTP_LEASE_CUTOFF
int find_subnet(struct subnet **sp, struct iaddr addr, const char *file, int line)
void execute_statements_in_scope(struct binding_value **result, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *out_options, struct binding_scope **scope, struct group *group, struct group *limiting_group, struct on_star *on_star)
struct interface_info * fallback_interface
#define FAILOVER_PROTOCOL
int option_state_allocate(struct option_state **ptr, const char *file, int line)
int evaluate_option_cache(struct data_string *result, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *cfg_options, struct binding_scope **scope, struct option_cache *oc, const char *file, int line)
struct permit * prohibit_list
int option_chain_head_dereference(struct option_chain_head **ptr, const char *file, int line)
#define MS_NULL_TERMINATION
int packet_reference(struct packet **ptr, struct packet *bp, const char *file, int line)
#define SV_ALWAYS_BROADCAST
void abandon_lease(struct lease *, const char *)
binding_state_t binding_state
#define DEFAULT_MAX_LEASE_TIME
int buffer_allocate(struct buffer **ptr, unsigned len, const char *file, int line)
char * print_hw_addr_or_client_id(struct packet *packet)
struct interface_info * interface
char * print_client_identifier_from_packet(struct packet *packet)
int write_lease(struct lease *lease)
void putULong(unsigned char *, u_int32_t)
if(parse_ip_addr(cfile,&match->addr))
#define SV_ECHO_CLIENT_ID
#define SV_USE_LEASE_ADDR_FOR_DEFAULT_ROUTE
#define DEFAULT_CACHE_THRESHOLD
int find_lease_by_hw_addr(struct lease **, const unsigned char *, unsigned, const char *, int)
#define DEFAULT_DEFAULT_LEASE_TIME
void check_pool_threshold(struct packet *packet, struct lease *lease, struct lease_state *state)
#define SV_GET_LEASE_HOSTNAMES
ssize_t send_packet(struct interface_info *, struct packet *, struct dhcp_packet *, size_t, struct in_addr, struct sockaddr_in *, struct hardware *)
void(* tvref_t)(void *, void *, const char *, int)
int cons_options(struct packet *inpacket, struct dhcp_packet *outpacket, struct lease *lease, struct client_state *client_state, int mms, struct option_state *in_options, struct option_state *cfg_options, struct binding_scope **scope, int overload_avail, int terminate, int bootpp, struct data_string *prl, const char *vuname)
u_int32_t getUShort(const unsigned char *)
struct host_decl * n_ipaddr
int option_chain_head_reference(struct option_chain_head **ptr, struct option_chain_head *bp, const char *file, int line)
int load_balance_mine(struct packet *, dhcp_failover_state_t *)
struct option_cache * lookup_option(struct universe *universe, struct option_state *options, unsigned code)
int permitted(struct packet *, struct permit *)
struct in_addr limited_broadcast
int int log_info(const char *,...) __attribute__((__format__(__printf__
void * dmalloc(size_t, const char *, int)
unsigned short cannot_reuse
u_int16_t dhcp_check_relayport(struct packet *packet)
u_int32_t getULong(const unsigned char *)
struct shared_network * shared_network
#define DHO_SUBNET_SELECTION
int find_hosts_by_uid(struct host_decl **, const unsigned char *, unsigned, const char *, int)
#define DHO_DHCP_MAX_MESSAGE_SIZE
void(* tvunref_t)(void *, const char *, int)
void echo_client_id(struct packet *, struct lease *, struct option_state *, struct option_state *)
Adds a dhcp-client-id option to a set of options Given a set of input options, it searches for echo-c...
void dhcpdiscover(struct packet *, int)
struct universe ** universes
void use_host_decl_name(struct packet *, struct lease *, struct option_state *)
Adds hostname option when use-host-decl-names is enabled.
void nak_lease(struct packet *, struct iaddr *cip, struct group *)
Constructs and sends a DHCP Nak.
struct data_string * dhcp4o6_response
int option_state_dereference(struct option_state **ptr, const char *file, int line)
struct shared_network * shared_network
int binding_scope_reference(struct binding_scope **ptr, struct binding_scope *bp, const char *file, int line)
int got_server_identifier
#define LEASE_GET_FIRST(LQ)
binding_state_t rewind_binding_state
int evaluate_boolean_option_cache(int *ignorep, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *cfg_options, struct binding_scope **scope, struct option_cache *oc, const char *file, int line)
int make_const_data(struct expression **expr, const unsigned char *data, unsigned len, int terminated, int allocate, const char *file, int line)
int ddns_updates(struct packet *, struct lease *, struct lease *, struct iasubopt *, struct iasubopt *, struct option_state *)
#define SV_BOOT_UNKNOWN_CLIENTS
#define DHCPLEASEUNASSIGNED
#define DEFAULT_PING_TIMEOUT
#define SV_LOG_THRESHOLD_LOW
int db_printable(const unsigned char *)
void ack_lease(struct packet *, struct lease *, unsigned int, TIME, char *, int, struct host_decl *)
isc_boolean_t agent_options_stashed
#define SV_CACHE_THRESHOLD
int find_lease_by_uid(struct lease **, const unsigned char *, unsigned, const char *, int)
int expression_reference(struct expression **ptr, struct expression *src, const char *file, int line)
#define SV_DEFAULT_LEASE_TIME
#define SV_ADAPTIVE_LEASE_TIME_THRESHOLD
#define SV_ONE_LEASE_PER_CLIENT
void dump_raw(unsigned char *buf, unsigned len) const
#define UNICAST_BROADCAST_HACK
u_int8_t hbuf[HARDWARE_ADDR_LEN+1]
int icmp_echorequest(struct iaddr *addr)
#define DHO_VENDOR_CLASS_IDENTIFIER
struct universe agent_universe
struct ipv6_pool ** pools
void dhcp(struct packet *packet)
const int dhcp_type_name_max
option_code_hash_t * code_hash
#define DHO_DHCP_RENEWAL_TIME
struct executable_statement * on_expiry
struct shared_network * shared_network
void dhcp_reply(struct lease *)
#define DHO_DHCP_CLIENT_IDENTIFIER
struct permit * permit_list
struct data_string filename server_name
int can_unicast_without_arp(struct interface_info *)
struct lease_state * new_lease_state(const char *, int)
int bill_class(struct lease *, struct class *)
isc_result_t dhcp_failover_send_updates(dhcp_failover_state_t *)
struct executable_statement * on_commit
const unsigned char * data
int get_option_int(int *result, struct universe *universe, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *cfg_options, struct option_state *options, struct binding_scope **scope, unsigned code, const char *file, int line)
#define DHO_DHCP_MESSAGE_TYPE
int bind_ds_value(struct binding_scope **scope, const char *name, struct data_string *value)
struct binding_scope * scope
void data_string_copy(struct data_string *dest, const struct data_string *src, const char *file, int line)
struct hardware interface
int find_lease_by_ip_addr(struct lease **, struct iaddr, const char *, int)
#define SV_STASH_AGENT_OPTIONS
struct in6_addr dhcpv6_link_address
binding_state_t next_binding_state
struct interface_info * interface
void classify_client(struct packet *)
int lease_mine_to_reallocate(struct lease *)
#define DHO_DHCP_REQUESTED_ADDRESS
struct packet * dhcpv6_container_packet
#define SV_RESERVE_INFINITE