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 95 memset (&client_identifier, 0,
sizeof client_identifier);
101 packet, (
struct lease *)0,
110 return "\"no client id\"";
120 packet -> raw -> hlen,
121 packet -> raw -> chaddr);
138 errmsg =
"unknown network segment";
150 #if defined(DHCPv6) && defined(DHCP4o6) 152 log_info(
"DHCP4o6 %s from %s via %s: %s", s,
157 :
"<no identifier>"),
164 log_info(
"%s from %s via %s: %s", s,
167 :
"<no identifier>"),
203 cip.
len =
sizeof packet -> raw -> ciaddr;
204 memcpy (cip.
iabuf, &packet -> raw -> ciaddr,
205 sizeof packet -> raw -> ciaddr);
220 if (lease -> uid_len) {
230 memset (&data, 0,
sizeof data);
232 packet, (
struct lease *)0,
238 if (lease -> uid_len != data.
len ||
239 memcmp (lease -> uid, data.
data, data.
len)) {
245 if ((lease -> hardware_addr.hbuf [0] !=
246 packet -> raw -> htype) ||
247 (lease -> hardware_addr.hlen - 1 !=
248 packet -> raw -> hlen) ||
249 memcmp (&lease -> hardware_addr.hbuf [1],
250 packet -> raw -> chaddr,
251 packet -> raw -> hlen))
280 switch (packet -> packet_type) {
314 errmsg =
"unknown packet type";
319 lease_dereference (&lease,
MDL);
330 int peer_has_leases = 0;
331 #if defined (FAILOVER_PROTOCOL) 332 dhcp_failover_state_t *peer;
336 0, &peer_has_leases, (
struct lease *)0,
MDL);
343 s =
"Hostname Unsuitable for Printing";
350 #if defined(DHCPv6) && defined(DHCP4o6) 352 snprintf (msgbuf,
sizeof msgbuf,
353 "DHCP4o6 DHCPDISCOVER from %s %s%s%svia %s",
354 (packet -> raw -> htype
356 packet -> raw -> hlen,
357 packet -> raw -> chaddr)
360 :
"<no identifier>")),
361 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
362 piaddr(packet->client_addr));
365 snprintf (msgbuf,
sizeof msgbuf,
"DHCPDISCOVER from %s %s%s%svia %s",
366 (packet -> raw -> htype
370 :
"<no identifier>")),
371 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
372 packet -> raw ->
giaddr.s_addr
373 ? inet_ntoa (packet -> raw ->
giaddr)
374 : packet -> interface -> name);
378 #if defined(DHCPv6) && defined(DHCP4o6) 380 log_info (
"DHCP4o6 packet from unknown subnet: %s",
381 piaddr(packet->client_addr));
384 log_info (
"Packet from unknown subnet: %s",
385 inet_ntoa (packet -> raw ->
giaddr));
389 #if defined (FAILOVER_PROTOCOL) 390 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
391 peer = lease ->
pool -> failover_peer;
411 #if defined (DEBUG_FIND_LEASE) 416 lease_dereference (&lease,
MDL);
427 log_error (
"%s: peer holds all free leases",
430 log_error (
"%s: network %s: no free leases",
437 #if defined (FAILOVER_PROTOCOL) 438 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
439 peer = lease ->
pool -> failover_peer;
443 msgbuf, peer -> nrr);
447 peer = (dhcp_failover_state_t *)0;
452 if (peer_has_leases) {
453 log_debug (
"%s: load balance to peer %s",
454 msgbuf, peer -> name);
457 log_debug (
"%s: cancel load balance to peer %s - %s",
458 msgbuf, peer -> name,
"no free leases");
464 if (lease -> ends < cur_time && lease ->
scope)
470 if (when < lease ->
ends)
471 when = lease ->
ends;
477 lease_dereference (&lease,
MDL);
483 struct
lease *ip_lease;
495 #if defined (FAILOVER_PROTOCOL) 496 dhcp_failover_state_t *peer;
498 int have_requested_addr = 0;
502 memset (&data, 0,
sizeof data);
511 have_requested_addr = 1;
515 memcpy (cip.
iabuf, &packet -> raw -> ciaddr.s_addr, 4);
521 subnet = (
struct subnet *)0;
522 lease = (
struct lease *)0;
532 s =
"Hostname Unsuitable for Printing";
538 memset (&data, 0,
sizeof data);
550 sprintf (smbuf,
" (%s)",
piaddr (sip));
559 #if defined(DHCPv6) && defined(DHCP4o6) 561 snprintf (msgbuf,
sizeof msgbuf,
562 "DHCP4o6 DHCPREQUEST for %s%s from %s %s%s%svia %s",
564 (packet -> raw -> htype
566 packet -> raw -> hlen,
567 packet -> raw -> chaddr)
570 :
"<no identifier>")),
571 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
572 piaddr(packet->client_addr));
575 snprintf (msgbuf,
sizeof msgbuf,
576 "DHCPREQUEST for %s%s from %s %s%s%svia %s",
578 (packet -> raw -> htype
582 :
"<no identifier>")),
583 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
584 packet -> raw ->
giaddr.s_addr
585 ? inet_ntoa (packet -> raw ->
giaddr)
586 : packet -> interface -> name);
588 #if defined (FAILOVER_PROTOCOL) 589 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
590 peer = lease ->
pool -> failover_peer;
594 msgbuf, peer -> nrr);
619 log_debug (
"%s: lease owned by peer", msgbuf);
633 log_debug(
"%s: lease in transition state %s", msgbuf,
635 ?
"released" :
"expired");
644 log_debug (
"%s: lease reset by administrator", msgbuf);
658 (memcmp(sip.
iabuf,
"\0\0\0\0", sip.
len) != 0)) {
666 if (memcmp(sip.
iabuf, &from, sip.
len) != 0) {
667 log_debug(
"%s: not our server id", msgbuf);
696 peer = (dhcp_failover_state_t *)0;
742 (packet -> raw -> ciaddr.s_addr &&
743 packet -> raw ->
giaddr.s_addr) ||
744 (have_requested_addr && !packet -> raw -> ciaddr.s_addr)) {
750 if (subnet && subnet ->
group -> authoritative) {
751 log_info (
"%s: wrong network.", msgbuf);
756 log_info (
"%s: ignored (%s).", msgbuf,
758 ?
"not authoritative" :
"unknown subnet"));
765 subnet_dereference (&subnet,
MDL);
770 log_info (
"%s: wrong network.", msgbuf);
774 log_info (
"%s: ignored (not authoritative).", msgbuf);
781 if (!lease && ours) {
796 subnet_dereference (&subnet,
MDL);
798 lease_dereference (&lease,
MDL);
806 struct lease *
lease = (
struct lease *)0, *
next = (
struct lease *)0;
811 char msgbuf [1024], cstr[16];
819 log_info (
"DHCPRELEASE from %s specified requested-address.",
828 memset (&data, 0,
sizeof data);
841 lease_reference (&next, lease -> n_uid,
MDL);
842 if (!memcmp (&packet -> raw -> ciaddr,
846 lease_dereference (&lease,
MDL);
848 lease_reference (&lease, next,
MDL);
849 lease_dereference (&next,
MDL);
853 lease_dereference (&next,
MDL);
861 memcpy (cip.
iabuf, &packet -> raw -> ciaddr, 4);
868 (lease -> hardware_addr.hlen != packet -> raw -> hlen + 1 ||
869 lease -> hardware_addr.hbuf [0] != packet -> raw -> htype ||
870 memcmp (&lease -> hardware_addr.hbuf [1],
871 packet -> raw -> chaddr, packet -> raw -> hlen)))
872 lease_dereference (&lease,
MDL);
874 if (lease && lease -> client_hostname) {
875 if ((strlen (lease -> client_hostname) <= 64) &&
877 s = lease -> client_hostname;
879 s =
"Hostname Unsuitable for Printing";
887 strncpy(cstr, inet_ntoa (packet -> raw -> ciaddr), 15);
893 #if defined(DHCPv6) && defined(DHCP4o6) 895 snprintf (msgbuf,
sizeof msgbuf,
896 "DHCP4o6 DHCPRELEASE of %s from %s %s%s%svia " 899 (packet -> raw -> htype
901 packet -> raw -> hlen,
902 packet -> raw -> chaddr)
905 :
"<no identifier>")),
906 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
907 piaddr(packet->client_addr),
908 lease ?
"" :
"not ");
911 snprintf (msgbuf,
sizeof msgbuf,
912 "DHCPRELEASE of %s from %s %s%s%svia %s (%sfound)",
914 (packet -> raw -> htype
918 :
"<no identifier>")),
919 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
920 packet -> raw ->
giaddr.s_addr
921 ? inet_ntoa (packet -> raw ->
giaddr)
922 : packet -> interface -> name,
923 lease ?
"" :
"not ");
925 #if defined (FAILOVER_PROTOCOL) 926 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
927 dhcp_failover_state_t *peer = lease ->
pool -> failover_peer;
931 peer -> name, peer -> nrr);
945 if (lease && lease -> ends >
cur_time) {
949 #if defined(FAILOVER_PROTOCOL) 953 lease_dereference (&lease,
MDL);
975 memset (&data, 0,
sizeof data);
988 if (lease && lease -> client_hostname) {
989 if ((strlen (lease -> client_hostname) <= 64) &&
991 s = lease -> client_hostname;
993 s =
"Hostname Unsuitable for Printing";
1000 #if defined(DHCPv6) && defined(DHCP4o6) 1002 snprintf (msgbuf,
sizeof msgbuf,
1003 "DHCP4o6 DHCPDECLINE of %s from %s %s%s%svia %s",
1005 (packet -> raw -> htype
1007 packet -> raw -> hlen,
1008 packet -> raw -> chaddr)
1011 :
"<no identifier>")),
1012 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
1013 piaddr(packet->client_addr));
1016 snprintf (msgbuf,
sizeof msgbuf,
1017 "DHCPDECLINE of %s from %s %s%s%svia %s",
1019 (packet -> raw -> htype
1023 :
"<no identifier>")),
1024 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
1025 packet -> raw ->
giaddr.s_addr
1026 ? inet_ntoa (packet -> raw ->
giaddr)
1027 : packet -> interface -> name);
1034 packet->options, options,
1040 for (i = packet -> class_count; i > 0; i--) {
1042 (NULL, packet, NULL, NULL, packet->options, options,
1052 packet -> options, options,
1053 &lease -> scope, oc,
MDL)) {
1056 #if defined (FAILOVER_PROTOCOL) 1057 if (lease ->
pool && lease ->
pool -> failover_peer) {
1058 dhcp_failover_state_t *peer =
1059 lease ->
pool -> failover_peer;
1064 peer -> name, peer -> nrr);
1076 status =
"abandoned";
1078 status =
"not found";
1084 log_info (
"%s: %s", msgbuf, status);
1086 #if defined(FAILOVER_PROTOCOL) 1092 lease_dereference (&lease,
MDL);
1099 char msgbuf[1024], *addr_type;
1104 struct packet outgoing;
1107 struct iaddr cip, gip, sip;
1110 struct sockaddr_in to;
1111 struct in_addr from;
1112 isc_boolean_t zeroed_ciaddr;
1114 int result, h_m_client_ip = 0;
1115 struct host_decl *host = NULL, *hp = NULL, *h;
1116 #if defined (DEBUG_INFORM_HOST) 1117 int h_w_fixed_addr = 0;
1123 if (!packet->raw->ciaddr.s_addr) {
1124 zeroed_ciaddr = ISC_TRUE;
1127 if (packet->client_addr.len == 4) {
1129 memcpy(cip.
iabuf, &packet->client_addr.iabuf, 4);
1130 addr_type =
"source";
1133 memset(cip.
iabuf, 0, 4);
1137 zeroed_ciaddr = ISC_FALSE;
1139 memcpy(cip.
iabuf, &packet->raw->ciaddr, 4);
1140 addr_type =
"client";
1145 if (packet->raw->giaddr.s_addr) {
1147 memcpy(gip.
iabuf, &packet->raw->giaddr, 4);
1148 if (zeroed_ciaddr == ISC_TRUE) {
1149 addr_type =
"relay";
1158 #if defined(DHCPv6) && defined(DHCP4o6) 1160 snprintf(msgbuf,
sizeof(msgbuf),
1161 "DHCP4o6 DHCPINFORM from %s via %s",
1163 piaddr(packet->client_addr));
1166 snprintf(msgbuf,
sizeof(msgbuf),
"DHCPINFORM from %s via %s",
1168 packet->raw->giaddr.s_addr ?
1169 inet_ntoa(packet->raw->giaddr) :
1170 packet->interface->name);
1173 if (!memcmp(cip.
iabuf,
"\0\0\0", 4)) {
1174 log_info(
"%s: ignored (null source address).", msgbuf);
1189 memset(&d1, 0,
sizeof d1);
1191 packet->options, NULL,
1196 log_info(
"%s: ignored (invalid subnet selection option).", msgbuf);
1218 if ((zeroed_ciaddr == ISC_TRUE) && (gip.
len != 0))
1219 addr_type =
"relay link select";
1221 addr_type =
"selected";
1226 if (subnet == NULL) {
1227 log_info(
"%s: unknown subnet for %s address %s",
1228 msgbuf, addr_type,
piaddr(sip));
1239 log_info(
"%s: not authoritative for subnet %s",
1240 msgbuf,
piaddr (subnet -> net));
1242 log_info(
"If this DHCP server is authoritative for%s",
1244 log_info(
"please write an `authoritative;' directi%s",
1245 "ve either in the");
1246 log_info(
"subnet declaration or in some scope that%s",
1248 log_info(
"subnet declaration - for example, write %s",
1250 log_info(
"of the dhcpd.conf file.");
1254 subnet_dereference(&subnet,
MDL);
1259 memset(&outgoing, 0,
sizeof outgoing);
1260 memset(&raw, 0,
sizeof raw);
1261 outgoing.
raw = &raw;
1263 maybe_return_agent_options(packet, options);
1267 packet->options, options,
1272 for (i = packet->class_count; i > 0; i--) {
1274 packet->options, options,
1276 packet->classes[i - 1]->group,
1299 memset(&d1, 0,
sizeof(d1));
1302 packet->options, NULL,
1307 #if defined (DEBUG_INFORM_HOST) 1309 log_debug (
"dhcpinform: found host by ID " 1310 "-- checking fixed-address match");
1314 for (h = hp; !h_m_client_ip && h; h = h->n_ipaddr) {
1318 memset(&fixed_addr, 0,
sizeof(fixed_addr));
1320 NULL, NULL, NULL, NULL,
1322 h->fixed_addr,
MDL))
1325 #if defined (DEBUG_INFORM_HOST) 1329 (i + cip.
len) <= fixed_addr.
len;
1331 if (memcmp(fixed_addr.
data + i,
1333 #if defined (DEBUG_INFORM_HOST) 1335 "host with matching " 1336 "fixed-address by ID");
1338 host_reference(&host, h,
MDL);
1347 for (h = hp; !host && h; h = h->
n_ipaddr) {
1351 #if defined (DEBUG_INFORM_HOST) 1353 "without fixed-address by ID");
1355 host_reference(&host, h,
MDL);
1359 host_dereference (&hp,
MDL);
1361 if (!host || !h_m_client_ip) {
1363 packet->raw->chaddr,
1364 packet->raw->hlen,
MDL);
1366 #if defined (DEBUG_INFORM_HOST) 1368 log_debug (
"dhcpinform: found host by HW " 1369 "-- checking fixed-address match");
1374 for (h = hp; !h_m_client_ip && h; h = h->n_ipaddr) {
1378 memset (&fixed_addr, 0,
sizeof(fixed_addr));
1380 NULL, NULL, NULL, NULL,
1382 h->fixed_addr,
MDL))
1385 #if defined (DEBUG_INFORM_HOST) 1389 (i + cip.
len) <= fixed_addr.
len;
1391 if (memcmp(fixed_addr.
data + i,
1393 #if defined (DEBUG_INFORM_HOST) 1395 "host with matching " 1396 "fixed-address by HW");
1404 host_dereference(&host,
MDL);
1405 host_reference(&host, h,
MDL);
1413 for (h = hp; !host && h; h = h->
n_ipaddr) {
1417 #if defined (DEBUG_INFORM_HOST) 1418 log_debug (
"dhcpinform: found host without " 1419 "fixed-address by HW");
1421 host_reference (&host, h,
MDL);
1426 host_dereference (&hp,
MDL);
1429 #if defined (DEBUG_INFORM_HOST) 1434 if (h_w_fixed_addr && !h_m_client_ip) {
1435 log_info (
"dhcpinform: matching host with " 1436 "fixed-address different than " 1437 "client IP detected?!");
1445 #if defined (DEBUG_INFORM_HOST) 1446 log_info (
"dhcpinform: applying host (group) options");
1449 packet->options, options,
1453 host_dereference (&host,
MDL);
1459 memset (&d1, 0,
sizeof d1);
1467 if (i >=
sizeof(raw.
file)) {
1468 log_info(
"file name longer than packet field " 1469 "truncated - field: %lu name: %d %.*s",
1470 (
unsigned long)
sizeof(raw.
file), i,
1472 i =
sizeof(raw.
file);
1487 if (i >=
sizeof(raw.
sname)) {
1488 log_info(
"server name longer than packet field " 1489 "truncated - field: %lu name: %d %.*s",
1490 (
unsigned long)
sizeof(raw.
sname), i,
1492 i =
sizeof(raw.
sname);
1513 &dhcpack, 1, 0, 0,
MDL)) {
1514 option_code_hash_lookup(&oc->
option,
1531 subnet -> netmask.iabuf,
1532 subnet -> netmask.len,
1534 option_code_hash_lookup(&oc->
option,
1549 packet -> options, options,
1554 (
const char *)d1.
data, d1.
len,
1559 subnet_dereference (&subnet,
MDL);
1563 options -> site_universe = u ->
index;
1571 memset (&prl, 0,
sizeof prl);
1588 packet -> options, options,
1593 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
1603 packet -> options, options,
1636 raw.
ciaddr = packet -> raw -> ciaddr;
1637 memcpy (raw.
chaddr, packet -> raw -> chaddr,
sizeof raw.
chaddr);
1638 raw.
hlen = packet -> raw -> hlen;
1639 raw.
htype = packet -> raw -> htype;
1641 raw.
xid = packet -> raw -> xid;
1642 raw.
secs = packet -> raw -> secs;
1643 raw.
flags = packet -> raw -> flags;
1644 raw.
hops = packet -> raw -> hops;
1652 #if defined(DHCPv6) && defined(DHCP4o6) 1655 snprintf(msgbuf,
sizeof msgbuf,
1656 "DHCP4o6 DHCPACK to %s (%s) via",
piaddr(cip),
1657 (packet->raw->htype && packet->raw->hlen) ?
1659 packet->raw->chaddr) :
1660 "<no client hardware address>");
1665 packet->dhcp4o6_response->buffer = NULL;
1668 log_fatal(
"No memory to store DHCP4o6 reply.");
1670 packet->dhcp4o6_response->data =
1671 packet->dhcp4o6_response->buffer->data;
1672 memcpy(packet->dhcp4o6_response->buffer->data,
1677 subnet_dereference (&subnet,
MDL);
1683 to.sin_family = AF_INET;
1685 to.sin_len =
sizeof to;
1687 memset (to.sin_zero, 0,
sizeof to.sin_zero);
1708 memcpy(&to.sin_addr, gip.
iabuf, 4);
1713 memcpy(&to.sin_addr, cip.
iabuf, 4);
1718 snprintf(msgbuf,
sizeof msgbuf,
"DHCPACK to %s (%s) via",
piaddr(cip),
1719 (packet->raw->htype && packet->raw->hlen) ?
1721 "<no client hardware address>");
1723 packet->interface->name);
1727 : packet -> interface);
1729 outgoing.packet_length, from, &to, NULL);
1731 log_error ("%s:%d: Failed to send %d byte long packet over %s "
1732 "interface.", MDL, outgoing.packet_length,
1738 subnet_dereference (&subnet, MDL);
1754 struct packet *packet;
1756 struct
group *network_group;
1758 struct sockaddr_in to;
1759 struct in_addr from;
1763 struct packet outgoing;
1770 memset (&outgoing, 0,
sizeof outgoing);
1771 memset (&raw, 0,
sizeof raw);
1776 log_error (
"No memory for DHCPNAK message type.");
1782 log_error (
"No memory for expr_const expression.");
1795 log_error (
"No memory for DHCPNAK message type.");
1800 (
unsigned char *)dhcp_message,
1801 strlen (dhcp_message), 1, 0,
MDL)) {
1802 log_error (
"No memory for expr_const expression.");
1818 #if defined(SERVER_ID_FOR_NAK) 1845 for (i = packet->class_count; i > 0; i--) {
1847 packet->options, eval_options,
1849 packet->classes[i - 1]->group,
1871 memcpy (raw.
chaddr, packet -> raw -> chaddr,
sizeof raw.
chaddr);
1872 raw.
hlen = packet -> raw -> hlen;
1873 raw.
htype = packet -> raw -> htype;
1875 raw.
xid = packet -> raw -> xid;
1876 raw.
secs = packet -> raw -> secs;
1878 raw.
hops = packet -> raw -> hops;
1886 #if defined(DHCPv6) && defined(DHCP4o6) 1888 log_info (
"DHCP4o6 DHCPNAK on %s to %s via %s",
1891 packet -> raw -> hlen,
1892 packet -> raw -> chaddr),
1893 piaddr(packet->client_addr));
1896 log_info (
"DHCPNAK on %s to %s via %s",
1899 packet -> raw ->
giaddr.s_addr
1900 ? inet_ntoa (packet -> raw ->
giaddr)
1901 : packet -> interface -> name);
1905 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
1910 #if defined(DHCPv6) && defined(DHCP4o6) 1914 packet->dhcp4o6_response->buffer = NULL;
1917 log_fatal(
"No memory to store DHCP4o6 reply.");
1919 packet->dhcp4o6_response->data =
1920 packet->dhcp4o6_response->buffer->data;
1921 memcpy(packet->dhcp4o6_response->buffer->data,
1928 to.sin_family = AF_INET;
1930 to.sin_len =
sizeof to;
1932 memset (to.sin_zero, 0,
sizeof to.sin_zero);
1937 to.sin_addr = raw.
giaddr;
1938 if (raw.
giaddr.s_addr != htonl (INADDR_LOOPBACK))
1943 if (fallback_interface) {
1944 result =
send_packet(fallback_interface, packet, &raw,
1948 log_error (
"%s:%d: Failed to send %d byte long " 1949 "packet over %s interface.",
MDL,
1951 fallback_interface->name);
1962 result =
send_packet(packet->interface, packet, &raw,
1965 log_error (
"%s:%d: Failed to send %d byte long packet over %s " 1967 packet->interface->name);
1991 struct packet *packet;
2002 NULL, packet->options,
2004 (lease ? &lease->
scope : NULL),
2010 packet->sv_echo_client_id = ISC_TRUE;
2014 memset(&client_id, 0,
sizeof client_id);
2017 packet->options, NULL,
2018 (lease ? &lease->
scope : NULL),
2027 option_code_hash_lookup(&oc->
option,
2042 struct packet *packet;
2049 int used, count, high_threshold, poolhigh = 0, poollow = 0;
2050 char *shared_name =
"no name";
2078 log_error(
"Pool threshold reset - shared subnet: %s; " 2079 "address: %s; low threshold %d/%d.",
2095 if ((poolhigh <= 0) || (poolhigh > 100)) {
2102 if (used < high_threshold) {
2108 log_error(
"Pool threshold exceeded - shared subnet: %s; " 2109 "address: %s; high threshold %d%% %d/%d.",
2111 poolhigh, used, count);
2127 if (poollow < poolhigh) {
2134 struct packet *packet;
2147 TIME offered_lease_time;
2149 TIME min_lease_time;
2153 isc_result_t result;
2156 struct in_addr from;
2157 TIME remaining_time;
2159 #if defined(DELAYED_ACK) && !defined(DHCP4o6) 2161 isc_boolean_t enqueue = ISC_FALSE;
2163 int use_old_lease = 0;
2175 lease_cltt = lease->
cltt;
2179 host_reference (&host, hp,
MDL);
2180 else if (lease -> host)
2181 host_reference (&host, lease -> host,
MDL);
2186 log_fatal (
"unable to allocate lease state!");
2194 state -> got_server_identifier = 1;
2196 maybe_return_agent_options(packet, state->
options);
2220 NULL, packet->options,
2227 packet->options, state->
options,
2234 for (i = packet -> class_count; i > 0; i--) {
2236 packet->options, state->
options,
2238 packet->classes[i - 1]->group,
2260 state -> options, &lease -> scope,
2265 seek = (
struct lease *)0;
2270 if (seek == lease && !seek ->
n_uid) {
2271 lease_dereference (&seek,
MDL);
2274 next = (
struct lease *)0;
2278 next = (
struct lease *)0;
2281 lease_reference (&next, seek ->
n_uid,
MDL);
2282 if (seek != lease &&
2289 lease_dereference (&seek,
MDL);
2291 lease_reference (&seek, next,
MDL);
2292 lease_dereference (&next,
MDL);
2296 lease_dereference (&next,
MDL);
2299 lease_dereference (&seek,
MDL);
2306 !host -> client_identifier.len &&
2316 seek = (
struct lease *)0;
2322 if (seek == lease && !seek ->
n_hw) {
2323 lease_dereference (&seek,
MDL);
2326 next = (
struct lease *)0;
2329 lease_reference (&next, seek ->
n_hw,
MDL);
2330 if (seek != lease &&
2337 lease_dereference (&seek,
MDL);
2339 lease_reference (&seek, next,
MDL);
2340 lease_dereference (&next,
MDL);
2344 lease_dereference (&next,
MDL);
2347 lease_dereference (&seek,
MDL);
2357 memset (&d1, 0,
sizeof d1);
2363 packet -> options, state -> options,
2366 ntohs (packet -> raw -> secs) < d1.
data [0]) {
2367 log_info(
"%s: configured min-secs value (%d) " 2368 "is greater than secs field (%d). " 2369 "message dropped.", msg, d1.
data[0],
2370 ntohs(packet->raw->secs));
2374 host_dereference (&host,
MDL);
2400 packet -> options, state -> options,
2401 &lease -> scope, oc,
MDL)) {
2404 for (h = hp; h; h = h ->
n_ipaddr) {
2405 if (!h -> fixed_addr)
2409 host_reference (&host, h,
MDL);
2411 host_dereference(&hp,
MDL);
2415 packet -> raw -> htype,
2416 packet -> raw -> chaddr,
2417 packet -> raw -> hlen,
2419 for (h = hp; h; h = h ->
n_ipaddr) {
2420 if (!h -> fixed_addr)
2424 host_reference (&host, h,
MDL);
2426 host_dereference(&hp,
MDL);
2430 packet->options,
MDL);
2431 for (h = hp; h; h = h ->
n_ipaddr) {
2432 if (!h -> fixed_addr)
2436 host_reference (&host, h,
MDL);
2438 host_dereference(&hp,
MDL);
2446 packet->options, state->
options,
2463 &lease -> scope, oc,
MDL)) {
2465 log_info (
"%s: unknown client", msg);
2468 host_dereference (&host,
MDL);
2481 &lease -> scope, oc,
MDL)) {
2483 log_info (
"%s: bootp disallowed", msg);
2486 host_dereference (&host,
MDL);
2499 &lease -> scope, oc,
MDL)) {
2501 log_info (
"%s: booting disallowed", msg);
2504 host_dereference (&host,
MDL);
2513 if (lease -> billing_class) {
2515 if (packet -> classes [i] ==
2516 lease -> billing_class)
2518 if (i == packet -> class_count) {
2533 for (i = 0; i < packet->class_count; i++) {
2534 struct class *billclass, *subclass;
2536 billclass = packet->classes[i];
2543 if (subclass == NULL)
2544 cname = subclass->
name;
2546 cname = billclass->
name;
2549 if (bill != 0 && i == packet->class_count) {
2550 log_info(
"%s: no available billing: lease " 2551 "limit reached in all matching " 2552 "classes (last: '%s')", msg, cname);
2555 host_dereference(&host,
MDL);
2585 packet -> options, state -> options,
2586 &lease -> scope, oc,
MDL);
2594 packet -> options, state -> options,
2595 &lease -> scope, oc,
MDL);
2600 lt = (
struct lease *)0;
2601 result = lease_allocate (<,
MDL);
2602 if (result != ISC_R_SUCCESS) {
2603 log_info (
"%s: can't allocate temporary lease structure: %s",
2604 msg, isc_result_totext (result));
2607 host_dereference (&host,
MDL);
2631 if (d1.
len == sizeof (u_int32_t))
2632 default_lease_time =
2648 if (s1 && (d1.
len == 4)) {
2649 u_int32_t ones = 0xffffffff;
2675 if ((memcmp(d1.
data, &ones, 4) == 0) &&
2680 lease, NULL, packet->options,
2686 "reservation made on %s.",
2706 if (d1.
len == sizeof (u_int32_t))
2715 || lease_time > max_lease_time)
2719 if (min_lease_time > max_lease_time)
2729 if (d1.
len == sizeof (u_int32_t))
2739 memset(&d1, 0,
sizeof(d1));
2744 packet->options, state->
options,
2746 if (d1.
len == 1 && d1.
data[0] > 0 &&
2749 int poolfilled, total, count;
2752 adaptive_time = min_lease_time;
2764 poolfilled = (total > (INT_MAX / 100)) ?
2765 total / (count / 100) :
2766 (total * 100) / count;
2768 log_debug(
"Adap-lease: Total: %d, Free: %d, " 2769 "Ends: %d, Adaptive: %d, Fill: %d, " 2774 (
int)adaptive_time, poolfilled,
2777 if (poolfilled >= d1.
data[0] &&
2778 lease_time > adaptive_time) {
2779 log_info(
"Pool over threshold, time " 2780 "for %s reduced from %d to " 2783 (
int)adaptive_time);
2785 lease_time = adaptive_time;
2807 lease_dereference (<,
MDL);
2809 host_dereference (&host,
MDL);
2837 lease_dereference (<,
MDL);
2839 host_dereference (&host,
MDL);
2843 if (lease_time > remaining_time)
2844 lease_time = remaining_time;
2847 if (lease_time < min_lease_time) {
2849 lease_time = min_lease_time;
2855 #if defined (FAILOVER_PROTOCOL) 2858 if (lease ->
pool && lease ->
pool -> failover_peer) {
2859 TIME new_lease_time = lease_time;
2860 dhcp_failover_state_t *peer =
2861 lease ->
pool -> failover_peer;
2870 if (lease_time > peer->mclt) {
2878 new_lease_time = peer->mclt;
2880 (lt->
tsfp + peer->mclt))
2894 (new_lease_time / 2);
2907 lease_time = new_lease_time;
2914 state -> offered_expiry =
MAX_TIME - 1;
2916 state -> offered_expiry =
cur_time + lease_time;
2920 lt ->
ends = state -> offered_expiry;
2940 if (d1.
len == sizeof (u_int32_t))
2953 if (d1.
len == sizeof (u_int32_t))
2960 lt ->
ends = state -> offered_expiry = cur_time + lease_time;
2972 packet->options, state->
options,
2983 packet->options, state->
options,
2991 unsigned char *tuid;
3007 host_reference (< -> host, host,
MDL);
3008 host_dereference (&host,
MDL);
3010 if (lease -> subnet)
3011 subnet_reference (< -> subnet, lease -> subnet,
MDL);
3024 if (lease ->
scope) {
3052 if (!packet->agent_options_stashed &&
3053 (packet->options != NULL) &&
3093 }
else if (oc && s1) {
3096 log_error (
"no memory for client hostname.");
3108 sizeof packet -> raw -> chaddr);
3116 log_debug (
"Cannot reuse: lease is changing to RESERVED");
3135 if ((!offer || offer ==
DHCPACK) &&
3148 if (lease ->
flags & STATIC_LEASE) {
3154 packet -> raw -> chaddr,
3155 sizeof packet -> raw -> chaddr);
3157 int commit = (!offer || (offer ==
DHCPACK));
3161 use_old_lease = reuse_lease(packet, lt, lease, state, offer);
3162 if (use_old_lease == 1) {
3166 #if !defined(DELAYED_ACK) || defined(DHCP4o6) 3175 if ((use_old_lease == 0) &&
3195 if ((use_old_lease == 0) &&
3197 !offer || offer ==
DHCPACK, 0, 0)) {
3199 log_info (
"%s: database update failed", msg);
3201 lease_dereference (<,
MDL);
3205 lease_dereference (<,
MDL);
3212 state -> ciaddr = packet -> raw -> ciaddr;
3213 state -> xid = packet -> raw -> xid;
3214 state -> secs = packet -> raw -> secs;
3215 state -> bootp_flags = packet -> raw ->
flags;
3216 state -> hops = packet -> raw -> hops;
3217 state -> offer = offer;
3225 packet -> options, state -> options,
3236 packet -> options, state -> options,
3238 if (d1.
len == sizeof (u_int16_t))
3247 packet -> options, state -> options,
3249 if (d1.
len == sizeof (u_int16_t))
3250 state -> max_message_size =
3281 if (state -> offer) {
3286 &state -> offer, 1, 0, 0,
MDL)) {
3287 option_code_hash_lookup(&oc->
option,
3291 state -> options, oc);
3298 memcpy(state->
from.
iabuf, &from,
sizeof(from));
3299 state->
from.
len =
sizeof(from);
3301 offered_lease_time =
3302 state -> offered_expiry -
cur_time;
3310 option_code_hash_lookup(&oc->
option,
3314 state -> options, oc);
3327 packet->options, state->
options,
3332 if (rebind_time >= offered_lease_time)
3336 offered_lease_time = rebind_time;
3344 packet->options, state->
options,
3354 if (state ->
ip -> address_count) {
3356 sizeof state ->
ip -> addresses [0];
3357 memcpy (state -> from.iabuf,
3358 &state ->
ip -> addresses [0],
3364 memset (&state -> siaddr, 0,
sizeof state -> siaddr);
3370 packet -> options, state -> options,
3371 &lease -> scope, oc,
MDL)) {
3375 memcpy (&state -> siaddr, d1.
data, 4);
3387 lease -> subnet -> netmask.iabuf,
3388 lease -> subnet -> netmask.len,
3390 option_code_hash_lookup(&oc->
option,
3394 state -> options, oc);
3414 (&ignorep, packet, lease, NULL,
3422 h = gethostbyaddr ((
char *)&ia,
sizeof ia, AF_INET);
3424 log_error (
"No hostname for %s", inet_ntoa (ia));
3431 strlen (h -> h_name) + 1,
3433 option_code_hash_lookup(&oc->
option,
3437 state -> options, oc);
3450 packet -> options, state -> options, &lease -> scope,
3462 option_code_hash_lookup(&oc->
option,
3466 state -> options, oc);
3479 packet -> options, state -> options,
3480 &lease -> scope, oc,
MDL)) {
3484 (
const char *)d1.
data, d1.
len,
3490 state -> options -> site_universe = u ->
index;
3512 packet -> options, state -> options,
3513 &lease -> scope, oc,
MDL);
3517 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
3520 lease -> state = state;
3529 if (offer ==
DHCPOFFER && !(lease -> flags & STATIC_LEASE) &&
3537 &lease -> scope, oc,
MDL))) {
3547 &lease -> scope, oc,
MDL)) {
3548 if (d1.
len == sizeof (u_int32_t))
3558 log_debug (
"Ping timeout: %ld", (
long)ping_timeout);
3567 tv.tv_sec =
cur_tv.tv_sec + ping_timeout;
3568 tv.tv_usec =
cur_tv.tv_usec;
3575 #if defined(DELAYED_ACK) && !defined(DHCP4o6) 3577 delayed_ack_enqueue(lease);
3584 #if defined(DELAYED_ACK) 3596 delayed_ack_enqueue(
struct lease *lease)
3602 if (free_ackqueue) {
3604 free_ackqueue = q->
next;
3609 log_fatal(
"delayed_ack_enqueue: no memory!");
3611 memset(q, 0,
sizeof *q);
3613 lease_reference(&q->
lease, lease,
MDL);
3614 q->
next = ackqueue_head;
3625 delayed_acks_timer(NULL);
3627 struct timeval next_fsync;
3629 if (max_fsync.tv_sec == 0 && max_fsync.tv_usec == 0) {
3632 max_fsync.tv_usec =
cur_tv.tv_usec +
3635 if (max_fsync.tv_usec >= 1000000) {
3637 max_fsync.tv_usec -= 1000000;
3642 next_fsync.tv_sec =
cur_tv.tv_sec;
3643 next_fsync.tv_usec =
cur_tv.tv_usec + min_ack_delay_usecs;
3644 if (next_fsync.tv_usec >= 1000000) {
3645 next_fsync.tv_sec++;
3646 next_fsync.tv_usec -= 1000000;
3649 if ((next_fsync.tv_sec > max_fsync.tv_sec) ||
3650 ((next_fsync.tv_sec == max_fsync.tv_sec) &&
3651 (next_fsync.tv_usec > max_fsync.tv_usec))) {
3652 next_fsync.tv_sec = max_fsync.tv_sec;
3653 next_fsync.tv_usec = max_fsync.tv_usec;
3656 add_timeout(&next_fsync, delayed_acks_timer, NULL,
3667 delayed_acks_timer(
void *foo)
3672 memset(&max_fsync, 0,
sizeof(max_fsync));
3674 if (!outstanding_acks) {
3689 for (ack = ackqueue_tail ; ack ; ack = p) {
3692 #if defined(FAILOVER_PROTOCOL) 3696 dhcp_failover_state_t *fpeer;
3699 if (fpeer && fpeer->link_to_peer) {
3707 log_error(
"delayed ack for %s has gone stale",
3713 lease_dereference(&ack->
lease,
MDL);
3714 ack->
next = free_ackqueue;
3715 free_ackqueue = ack;
3718 ackqueue_head = NULL;
3719 ackqueue_tail = NULL;
3720 outstanding_acks = 0;
3723 #if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT) 3725 relinquish_ackqueue(
void)
3729 for (q = ackqueue_head ; q ; q = n) {
3733 for (q = free_ackqueue ; q ; q = n) {
3743 struct lease *lease;
3748 struct sockaddr_in to;
3749 struct in_addr from;
3753 int nulltp, bootpp, unicastp = 1;
3758 log_fatal (
"dhcp_reply was supplied lease with no state!");
3761 memset (&raw, 0,
sizeof raw);
3762 memset (&d1, 0,
sizeof d1);
3766 if (state -> filename.len && state -> filename.data) {
3768 state -> filename.data,
3769 state -> filename.len >
sizeof raw.
file 3770 ?
sizeof raw.
file : state -> filename.len);
3771 if (
sizeof raw.
file > state -> filename.len)
3772 memset (&raw.
file [state -> filename.len], 0,
3773 (
sizeof raw.
file) - state -> filename.len);
3775 log_info(
"file name longer than packet field " 3776 "truncated - field: %lu name: %d %.*s",
3777 (
unsigned long)
sizeof(raw.
file),
3778 state->filename.len, (
int)state->filename.len,
3779 state->filename.data);
3785 if (state -> server_name.len && state -> server_name.data) {
3787 state -> server_name.data,
3788 state -> server_name.len >
sizeof raw.
sname 3789 ?
sizeof raw.
sname : state -> server_name.len);
3790 if (
sizeof raw.
sname > state -> server_name.len)
3791 memset (&raw.
sname [state -> server_name.len], 0,
3792 (
sizeof raw.
sname) - state -> server_name.len);
3794 log_info(
"server name longer than packet field " 3795 "truncated - field: %lu name: %d %.*s",
3796 (
unsigned long)
sizeof(raw.
sname),
3804 &lease -> hardware_addr.hbuf [1],
sizeof raw.
chaddr);
3805 raw.
hlen = lease -> hardware_addr.hlen - 1;
3806 raw.
htype = lease -> hardware_addr.hbuf [0];
3822 packet_length =
cons_options (state -> packet, &raw, lease,
3824 state -> max_message_size,
3825 state -> packet -> options,
3827 bufs, nulltp, bootpp,
3828 &state -> parameter_request_list,
3831 memcpy (&raw.
ciaddr, &state -> ciaddr,
sizeof raw.
ciaddr);
3833 raw.
siaddr = state -> siaddr;
3836 raw.
xid = state -> xid;
3837 raw.
secs = state -> secs;
3838 raw.
flags = state -> bootp_flags;
3839 raw.
hops = state -> hops;
3842 if (lease -> client_hostname) {
3843 if ((strlen (lease -> client_hostname) <= 64) &&
3845 s = lease -> client_hostname;
3847 s =
"Hostname Unsuitable for Printing";
3856 #if defined(DHCPv6) && defined(DHCP4o6) 3859 log_info (
"DHCP4o6 %s on %s to %s %s%s%svia %s",
3862 ?
"DHCPACK" :
"DHCPOFFER")
3865 (lease -> hardware_addr.hlen
3867 lease -> hardware_addr.hlen - 1,
3868 &lease -> hardware_addr.hbuf [1])
3870 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
3877 packet_length,
MDL)) {
3878 log_fatal(
"No memory to store DHCP4o6 reply.");
3883 &raw, packet_length);
3894 log_info (
"%s on %s to %s %s%s%svia %s",
3896 ? (state -> offer ==
DHCPACK ?
"DHCPACK" :
"DHCPOFFER")
3899 (lease -> hardware_addr.hlen > 1
3901 lease -> hardware_addr.hlen - 1,
3902 &lease -> hardware_addr.hbuf [1])
3904 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
3906 ? inet_ntoa (state ->
giaddr)
3907 : state ->
ip -> name));
3910 dump_raw ((
unsigned char *)&raw, packet_length);
3914 hto.
hlen = lease -> hardware_addr.hlen;
3915 memcpy (hto.
hbuf, lease -> hardware_addr.hbuf, hto.
hlen);
3917 to.sin_family = AF_INET;
3919 to.sin_len =
sizeof to;
3921 memset (to.sin_zero, 0,
sizeof to.sin_zero);
3925 to.sin_addr = raw.
giaddr;
3926 if (raw.
giaddr.s_addr != htonl (INADDR_LOOPBACK))
3931 if (fallback_interface) {
3932 result =
send_packet(fallback_interface, NULL, &raw,
3933 packet_length, raw.
siaddr, &to,
3936 log_error (
"%s:%d: Failed to send %d byte long " 3937 "packet over %s interface.",
MDL,
3939 fallback_interface->name);
3959 }
else if (raw.
ciaddr.s_addr &&
3966 to.sin_addr = raw.
ciaddr;
3969 if (fallback_interface) {
3970 result =
send_packet(fallback_interface, NULL, &raw,
3971 packet_length, raw.
siaddr, &to,
3974 log_error(
"%s:%d: Failed to send %d byte long" 3975 " packet over %s interface.",
MDL,
3977 fallback_interface->name);
3991 to.sin_addr = raw.
yiaddr;
4002 memcpy (&from, state -> from.iabuf,
sizeof from);
4005 from, &to, unicastp ? &hto : NULL);
4007 log_error (
"%s:%d: Failed to send %d byte long " 4008 "packet over %s interface.",
MDL,
4009 packet_length, state->
ip->
name);
4022 int *peer_has_leases,
struct lease *ip_lease_in,
4025 struct lease *uid_lease = (
struct lease *)0;
4026 struct lease *ip_lease = (
struct lease *)0;
4027 struct lease *hw_lease = (
struct lease *)0;
4028 struct lease *lease = (
struct lease *)0;
4032 struct lease *fixed_lease = (
struct lease *)0;
4033 struct lease *next = (
struct lease *)0;
4036 int have_client_identifier = 0;
4040 #if defined(FAILOVER_PROTOCOL) 4042 if (peer_has_leases) {
4045 for (pool = share->
pools ; pool ; pool = pool->
next) {
4050 (peer->i_am == secondary && pool->
free_leases))) {
4051 *peer_has_leases = 1;
4058 if (packet -> raw -> ciaddr.s_addr) {
4060 memcpy (cip.
iabuf, &packet -> raw -> ciaddr, 4);
4065 memset (&d1, 0,
sizeof d1);
4072 packet -> got_requested_address = 1;
4087 memset (&client_identifier, 0,
sizeof client_identifier);
4090 packet, (
struct lease *)0,
4095 have_client_identifier = 1;
4100 client_identifier.
len,
MDL)) {
4102 packet -> known = 1;
4106 #if defined (DEBUG_FIND_LEASE) 4108 log_info (
"Found host for client identifier: %s.",
4114 host_reference (&host, hp,
MDL);
4115 host_dereference (&hp,
MDL);
4119 client_identifier.
len,
MDL);
4124 if (!fixed_lease && !host) {
4126 packet -> raw -> chaddr,
4127 packet -> raw -> hlen,
MDL)) {
4129 packet -> known = 1;
4131 host_dereference (&host,
MDL);
4132 host_reference (&host, hp,
MDL);
4133 host_dereference (&hp,
MDL);
4135 #if defined (DEBUG_FIND_LEASE) 4137 log_info (
"Found host for link address: %s.",
4146 if (!fixed_lease && !host) {
4151 host_dereference(&host,
MDL);
4152 host_reference(&host, hp,
MDL);
4153 host_dereference(&hp,
MDL);
4155 #if defined (DEBUG_FIND_LEASE) 4157 log_info (
"Found host via host-identifier");
4166 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease &&
4172 strcpy (dhcp_message,
"requested address is incorrect");
4173 #if defined (DEBUG_FIND_LEASE) 4174 log_info (
"Client's fixed-address %s doesn't match %s%s",
4192 #if defined (DEBUG_FIND_LEASE) 4193 log_info (
"trying next lease matching client id: %s",
4197 #if defined (FAILOVER_PROTOCOL) 4209 #if defined (DEBUG_FIND_LEASE) 4210 log_info(
"not active or not mine to allocate: %s",
4218 #if defined (DEBUG_FIND_LEASE) 4219 log_info (
"wrong network segment: %s",
4229 #if defined (DEBUG_FIND_LEASE) 4234 if (uid_lease -> n_uid)
4235 lease_reference (&next,
4236 uid_lease -> n_uid,
MDL);
4237 if (!packet -> raw -> ciaddr.s_addr)
4239 lease_dereference (&uid_lease,
MDL);
4241 lease_reference (&uid_lease, next,
MDL);
4242 lease_dereference (&next,
MDL);
4248 #if defined (DEBUG_FIND_LEASE) 4250 log_info (
"Found lease for client id: %s.",
4261 h.
hlen = packet -> raw -> hlen + 1;
4262 h.
hbuf [0] = packet -> raw -> htype;
4263 memcpy (&h.
hbuf [1], packet -> raw -> chaddr, packet -> raw -> hlen);
4266 #if defined (DEBUG_FIND_LEASE) 4267 log_info (
"trying next lease matching hw addr: %s",
4270 #if defined (FAILOVER_PROTOCOL) 4283 #if defined (DEBUG_FIND_LEASE) 4284 log_info(
"not active or not mine to allocate: %s",
4297 if (hw_lease -> binding_state !=
FTS_FREE &&
4300 (!have_client_identifier ||
4301 hw_lease -> uid_len != client_identifier.
len ||
4302 memcmp (hw_lease -> uid, client_identifier.
data,
4303 hw_lease -> uid_len))) {
4304 #if defined (DEBUG_FIND_LEASE) 4305 log_info (
"wrong client identifier: %s",
4311 #if defined (DEBUG_FIND_LEASE) 4312 log_info (
"wrong network segment: %s",
4321 #if defined (DEBUG_FIND_LEASE) 4325 if (!packet -> raw -> ciaddr.s_addr)
4328 if (hw_lease -> n_hw)
4329 lease_reference (&next, hw_lease -> n_hw,
MDL);
4330 lease_dereference (&hw_lease,
MDL);
4332 lease_reference (&hw_lease, next,
MDL);
4333 lease_dereference (&next,
MDL);
4339 #if defined (DEBUG_FIND_LEASE) 4341 log_info (
"Found lease for hardware address: %s.",
4348 lease_reference (&ip_lease, ip_lease_in,
MDL);
4352 #if defined (DEBUG_FIND_LEASE) 4354 log_info (
"Found lease for requested address: %s.",
4361 if (ip_lease && ours)
4371 if (ip_lease && (ip_lease -> subnet ->
shared_network != share)) {
4374 #if defined (DEBUG_FIND_LEASE) 4375 log_info (
"...but it was on the wrong shared network.");
4377 strcpy (dhcp_message,
"requested address on bad subnet");
4378 lease_dereference (&ip_lease,
MDL);
4392 (!have_client_identifier ||
4393 ip_lease -> uid_len != client_identifier.
len ||
4394 memcmp (ip_lease -> uid, client_identifier.
data,
4395 ip_lease -> uid_len)) :
4396 (ip_lease -> hardware_addr.hbuf [0] != packet -> raw -> htype ||
4397 ip_lease -> hardware_addr.hlen != packet -> raw -> hlen + 1 ||
4398 memcmp (&ip_lease -> hardware_addr.hbuf [1],
4399 packet -> raw -> chaddr,
4400 (
unsigned)(ip_lease -> hardware_addr.hlen - 1))))) {
4409 if (ip_lease -> binding_state !=
FTS_FREE &&
4411 #if defined (DEBUG_FIND_LEASE) 4412 log_info (
"rejecting lease for requested address.");
4416 if (ours && ip_lease -> binding_state !=
FTS_ACTIVE)
4418 lease_dereference (&ip_lease,
MDL);
4426 if (ip_lease && (uid_lease || hw_lease) &&
4433 #if defined (DEBUG_FIND_LEASE) 4434 log_info(
"ip lease not active or not ours to offer.");
4436 lease_dereference(&ip_lease,
MDL);
4443 ip_lease->
uid && ip_lease != uid_lease) {
4444 if (have_client_identifier &&
4445 (ip_lease -> uid_len == client_identifier.
len) &&
4446 !memcmp (client_identifier.
data,
4447 ip_lease -> uid, ip_lease -> uid_len)) {
4450 log_error (
"client %s has duplicate%s on %s",
4453 (ip_lease -> subnet ->
4461 !packet -> raw -> ciaddr.s_addr &&
4467 lease_dereference (&uid_lease,
MDL);
4468 lease_reference (&uid_lease, ip_lease,
MDL);
4475 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease) {
4476 lease_dereference (&fixed_lease,
MDL);
4478 log_error (
"Dynamic and static leases present for %s.",
4480 log_error (
"Remove host declaration %s or remove %s",
4481 (fixed_lease && fixed_lease -> host
4482 ? (fixed_lease -> host -> name
4483 ? fixed_lease -> host -> name
4487 log_error (
"from the dynamic address pool for %s",
4491 lease_dereference (&ip_lease,
MDL);
4492 strcpy (dhcp_message,
4493 "database conflict - call for help!");
4496 if (ip_lease && ip_lease != uid_lease) {
4497 #if defined (DEBUG_FIND_LEASE) 4498 log_info (
"requested address not available.");
4500 lease_dereference (&ip_lease,
MDL);
4506 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease && ip_lease)
4510 if (hw_lease && hw_lease == uid_lease) {
4511 #if defined (DEBUG_FIND_LEASE) 4512 log_info (
"hardware lease and uid lease are identical.");
4514 lease_dereference (&hw_lease,
MDL);
4516 if (ip_lease && ip_lease == hw_lease) {
4517 lease_dereference (&hw_lease,
MDL);
4518 #if defined (DEBUG_FIND_LEASE) 4519 log_info (
"hardware lease and ip lease are identical.");
4522 if (ip_lease && ip_lease == uid_lease) {
4523 lease_dereference (&uid_lease,
MDL);
4524 #if defined (DEBUG_FIND_LEASE) 4525 log_info (
"uid lease and ip lease are identical.");
4539 lease_dereference (&ip_lease,
MDL);
4547 if (!packet -> raw -> ciaddr.s_addr)
4549 lease_dereference (&uid_lease,
MDL);
4557 if (!packet -> raw -> ciaddr.s_addr)
4559 lease_dereference (&hw_lease,
MDL);
4566 strcpy (dhcp_message,
"requested address not available");
4573 !ip_lease && !fixed_lease) {
4574 #if defined (DEBUG_FIND_LEASE) 4575 log_info (
"no applicable lease found for DHCPREQUEST.");
4583 lease_reference (&lease, fixed_lease,
MDL);
4584 lease_dereference (&fixed_lease,
MDL);
4585 #if defined (DEBUG_FIND_LEASE) 4586 log_info (
"choosing fixed address.");
4594 if (!packet -> raw -> ciaddr.s_addr)
4596 #if defined (DEBUG_FIND_LEASE) 4597 log_info (
"not choosing requested address (!).");
4600 #if defined (DEBUG_FIND_LEASE) 4601 log_info (
"choosing lease on requested address.");
4603 lease_reference (&lease, ip_lease,
MDL);
4605 host_dereference (&lease -> host,
MDL);
4607 lease_dereference (&ip_lease,
MDL);
4615 log_error(
"uid lease %s for client %s is duplicate " 4621 if (!packet -> raw -> ciaddr.s_addr &&
4625 #if defined (DEBUG_FIND_LEASE) 4626 log_info (
"not choosing uid lease.");
4629 lease_reference (&lease, uid_lease,
MDL);
4631 host_dereference (&lease -> host,
MDL);
4632 #if defined (DEBUG_FIND_LEASE) 4636 lease_dereference (&uid_lease,
MDL);
4642 #if defined (DEBUG_FIND_LEASE) 4643 log_info (
"not choosing hardware lease.");
4650 if (!hw_lease -> uid_len ||
4651 (have_client_identifier
4652 ? (hw_lease -> uid_len ==
4653 client_identifier.
len &&
4654 !memcmp (hw_lease -> uid,
4655 client_identifier.
data,
4656 client_identifier.
len))
4657 : packet -> packet_type == 0)) {
4658 lease_reference (&lease, hw_lease,
MDL);
4660 host_dereference (&lease -> host,
MDL);
4661 #if defined (DEBUG_FIND_LEASE) 4662 log_info (
"choosing hardware lease.");
4665 #if defined (DEBUG_FIND_LEASE) 4666 log_info (
"not choosing hardware lease: %s.",
4671 lease_dereference (&hw_lease,
MDL);
4680 if (lease && host && !lease->
host) {
4684 host_reference(&p, host,
MDL);
4703 host_reference(&lease->
host, p,
MDL);
4705 host_dereference(&p,
MDL);
4710 host_dereference(&p,
MDL);
4712 host_reference(&p, n,
MDL);
4713 host_dereference(&n,
MDL);
4724 lease == ip_lease &&
4726 log_error (
"Reclaiming REQUESTed abandoned IP address %s.",
4728 }
else if (lease && (lease -> binding_state ==
FTS_ABANDONED)) {
4735 lease_dereference (&lease,
MDL);
4739 if (have_client_identifier)
4743 lease_dereference (&fixed_lease,
MDL);
4745 lease_dereference (&hw_lease,
MDL);
4747 lease_dereference (&uid_lease,
MDL);
4749 lease_dereference (&ip_lease,
MDL);
4751 host_dereference (&host,
MDL);
4754 #if defined (DEBUG_FIND_LEASE) 4758 lease_reference (lp, lease, file, line);
4759 lease_dereference (&lease,
MDL);
4762 #if defined (DEBUG_FIND_LEASE) 4763 log_info (
"Not returning a lease.");
4775 struct lease *lease = (
struct lease *)0;
4778 if (lease_allocate (&lease,
MDL) != ISC_R_SUCCESS)
4780 if (host_reference (&rhp, hp,
MDL) != ISC_R_SUCCESS) {
4781 lease_dereference (&lease,
MDL);
4785 &rhp, &lease ->
ip_addr, share)) {
4786 lease_dereference (&lease,
MDL);
4787 host_dereference (&rhp,
MDL);
4790 host_reference (&lease -> host, rhp,
MDL);
4794 lease -> uid = lease -> uid_buf;
4795 if (!lease -> uid) {
4796 lease_dereference (&lease,
MDL);
4797 host_dereference (&rhp,
MDL);
4803 lease -> hardware_addr = rhp ->
interface;
4804 lease -> starts = lease -> cltt = lease -> ends =
MIN_TIME;
4808 lease_reference (lp, lease,
MDL);
4810 lease_dereference (&lease,
MDL);
4811 host_dereference (&rhp,
MDL);
4823 struct pool *
pool,
int *peer_has_leases)
4825 struct lease *lease = NULL;
4826 struct lease *candl = NULL;
4828 for (;
pool ; pool = pool ->
next) {
4829 if ((pool -> prohibit_list &&
4830 permitted (packet, pool -> prohibit_list)) ||
4831 (pool -> permit_list &&
4832 !
permitted (packet, pool -> permit_list)))
4835 #if defined (FAILOVER_PROTOCOL) 4851 struct lease *peerl = NULL;
4862 if (peerl != NULL) {
4863 if (((candl == NULL) ||
4868 *peer_has_leases = 1;
4875 if (peerl != NULL) {
4876 if (((candl == NULL) ||
4881 *peer_has_leases = 1;
4888 if ((candl == NULL) && (peerl != NULL) &&
4931 (candl -> ends < lease ->
ends))) {
4939 (candl -> ends < lease -> ends))) {
4945 if (candl -> ends < lease -> ends)
4949 if (lease != NULL) {
4951 log_error(
"Reclaiming abandoned lease %s.",
4959 if (lease->
host != NULL) {
4960 log_debug(
"soft impossible condition (%s:%d): stale " 4961 "host \"%s\" found on lease %s",
MDL,
4964 host_dereference(&lease->
host,
MDL);
4967 lease_reference (lp, lease,
MDL);
4979 struct packet *packet;
4980 struct
permit *permit_list;
4985 for (p = permit_list; p; p = p ->
next) {
4986 switch (p ->
type) {
4988 if (!packet -> known)
4993 if (packet -> known)
4998 if (packet -> authenticated)
5003 if (!packet -> authenticated)
5011 if (!packet -> options_valid ||
5012 !packet -> packet_type)
5018 if (p ->
class == packet -> classes [i])
5020 if (packet -> classes [i] &&
5021 packet -> classes [i] -> superclass &&
5022 (packet -> classes [i] -> superclass ==
5037 #if defined(DHCPv6) && defined(DHCP4o6) 5038 static int locate_network6 (packet)
5039 struct packet *packet;
5041 const struct packet *chk_packet;
5042 const struct in6_addr *link_addr, *first_link_addr;
5045 struct subnet *subnet = NULL;
5067 memset(&data, 0,
sizeof data);
5073 if (data.
len == 0) {
5076 if (data.
len != 4) {
5087 subnet_dereference(&subnet,
MDL);
5103 subnet_dereference(&subnet,
MDL);
5114 first_link_addr = NULL;
5116 while (chk_packet != NULL) {
5118 if (!IN6_IS_ADDR_UNSPECIFIED(link_addr) &&
5119 !IN6_IS_ADDR_LINKLOCAL(link_addr)) {
5120 first_link_addr = link_addr;
5129 if (first_link_addr != NULL) {
5130 ia.
len =
sizeof(*first_link_addr);
5131 memcpy(ia.
iabuf, first_link_addr,
sizeof(*first_link_addr));
5135 subnet_dereference(&subnet,
MDL);
5157 log_error(
"No interface and no link address " 5158 "can't determine DHCP4o6 shared network");
5164 struct packet *packet;
5168 struct subnet *subnet = (
struct subnet *)0;
5172 #if defined(DHCPv6) && defined(DHCP4o6) 5174 return (locate_network6 (packet));
5190 if (!oc && !packet -> raw ->
giaddr.s_addr) {
5192 struct in_addr any_addr;
5193 any_addr.s_addr = INADDR_ANY;
5195 if (!packet -> packet_type && memcmp(&packet -> raw -> ciaddr, &any_addr, 4)) {
5197 memcpy(cip.
iabuf, &packet -> raw -> ciaddr, 4);
5216 memset (&data, 0,
sizeof data);
5224 if (data.
len == 0) {
5227 if (data.
len != 4) {
5237 memcpy (ia.
iabuf, &packet->raw->ciaddr, 4);
5239 memcpy (ia.
iabuf, &packet->raw->giaddr, 4);
5246 subnet_dereference (&subnet,
MDL);
5291 struct packet *packet) {
5292 unsigned option_num;
5295 struct in_addr *a = NULL;
5296 isc_boolean_t found = ISC_FALSE;
5299 memset(&d, 0,
sizeof(d));
5300 memset(from, 0,
sizeof(*from));
5308 if (d.
len ==
sizeof(*from)) {
5310 memcpy(from, d.
data,
sizeof(*from));
5316 if ((out_options != NULL) &&
5317 (options != out_options)) {
5327 if ((found == ISC_FALSE) &&
5331 if (out_options != NULL) {
5339 (
unsigned char *)a,
sizeof(*a),
5340 0, allocate,
MDL)) {
5341 option_code_hash_lookup(&oc->
option,
5343 &option_num, 0,
MDL);
5375 struct packet *packet,
5376 struct group *network_group) {
5378 if (*network_options == NULL) {
5393 packet->
options, *network_options,
5399 packet->
options, *network_options,
5408 packet->
options, *network_options,
5414 }
else if (network_group != NULL) {
5416 packet->
options, *network_options,
5421 packet->
options, *network_options,
5438 find_min_site_code(
struct universe *u)
5448 site_code_min = 224;
5449 option_code_hash_foreach(u->
code_hash, lowest_site_code);
5451 if (site_code_min < 224) {
5452 log_error(
"WARNING: site-local option codes less than 224 have " 5453 "been deprecated by RFC3942. You have options " 5454 "listed in site local space %s that number as low as " 5455 "%d. Please investigate if these should be declared " 5456 "as regular options rather than site-local options, " 5457 "or migrated up past 224.",
5458 u->
name, site_code_min);
5465 if (site_code_min < 128)
5466 site_code_min = 128;
5475 return site_code_min;
5479 lowest_site_code(
const void *key,
unsigned len,
void *
object)
5483 if (option->
code < site_code_min)
5484 site_code_min = option->
code;
5486 return ISC_R_SUCCESS;
5490 maybe_return_agent_options(
struct packet *packet,
struct option_state *options)
5534 struct lease *lease,
5548 ((
unsigned char*)lease->
host->
name),
5552 option_code_hash_lookup(&oc->
option,
5593 reuse_lease (
struct packet* packet,
5594 struct lease* new_lease,
5595 struct lease* lease,
5606 (new_lease->
ddns_cb == NULL)) {
5618 if (d1.
len == 1 && (d1.
data[0] < 100))
5619 thresh = d1.
data[0];
5627 int lease_length = 0;
5632 if (lease_length <= (INT_MAX / thresh))
5633 limit = lease_length * thresh / 100;
5635 limit = lease_length / 100 * thresh;
5641 if (lease_age <= limit) {
5646 if (new_lease->
scope != NULL) {
5647 if (lease->
scope != NULL) {
5658 log_debug(
"reuse_lease: lease age %ld (secs)" 5659 " under %d%% threshold, reply with " 5660 "unaltered, existing lease for %s",
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)
char * print_dotted_quads(unsigned len, const u_int8_t *data)
void unbill_class(struct lease *lease)
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
#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 *)
struct shared_network * shared_network
const char * piaddr(const struct iaddr addr)
struct dhcp_ddns_cb * ddns_cb
#define DHO_PXE_CLIENT_ID
void * dmalloc(unsigned, const char *, int)
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__
#define SV_BOOTP_LEASE_LENGTH
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)
void dhcpdecline(struct packet *packet, int ms_nulltp)
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)
struct option_cache * fixed_addr
struct class * billing_class
struct group * root_group
int mockup_lease(struct lease **lp, struct packet *packet, struct shared_network *share, struct host_decl *hp)
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 *)
void(* tvunref_t)(void *, const char *, int)
#define DHO_DHCP_REBINDING_TIME
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)
void dhcprelease(struct packet *packet, int ms_nulltp)
struct expression * expression
struct data_string client_identifier
void(* tvref_t)(void *, void *, const char *, int)
const char * binding_state_print(enum failover_state state)
struct option_state * options
#define LEASE_NOT_EMPTY(LQ)
void nak_lease(struct packet *packet, struct iaddr *cip, struct group *network_group)
Constructs and sends a DHCP Nak.
#define DHO_DHCP_SERVER_IDENTIFIER
void log_fatal(const char *,...) __attribute__((__format__(__printf__
void dhcpdiscover(struct packet *packet, int ms_nulltp)
struct option_state * options
#define DEFAULT_DELAYED_ACK
int option_cache_allocate(struct option_cache **cptr, const char *file, int line)
#define SV_LOG_THRESHOLD_HIGH
#define DEFAULT_ACK_DELAY_SECS
int locate_network(struct packet *packet)
void free_lease_state(struct lease_state *, const char *, int)
universe_hash_t * universe_hash
void dhcp_reply(struct lease *lease)
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)
void dhcp(struct packet *packet)
#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)
#define SV_ECHO_CLIENT_ID
#define SV_USE_LEASE_ADDR_FOR_DEFAULT_ROUTE
#define DEFAULT_CACHE_THRESHOLD
int permitted(struct packet *packet, struct permit *permit_list)
int find_lease_by_hw_addr(struct lease **, const unsigned char *, unsigned, const char *, int)
void eval_network_statements(struct option_state **network_options, struct packet *packet, struct group *network_group)
Builds option set from statements at the global and network scope.
#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 *)
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)
void get_server_source_address(struct in_addr *from, struct option_state *options, struct option_state *out_options, struct packet *packet)
u_int32_t getUShort(const unsigned char *)
void dfree(void *, const char *, int)
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)
void echo_client_id(struct packet *packet, struct lease *lease, struct option_state *in_options, struct option_state *out_options)
Adds a dhcp-client-id option to a set of options Given a set of input options, it searches for echo-c...
struct in_addr limited_broadcast
int int log_info(const char *,...) __attribute__((__format__(__printf__
unsigned short cannot_reuse
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)
int allocate_lease(struct lease **lp, struct packet *packet, struct pool *pool, int *peer_has_leases)
#define DHO_DHCP_MAX_MESSAGE_SIZE
struct universe ** universes
struct data_string * dhcp4o6_response
int option_state_dereference(struct option_state **ptr, const char *file, int line)
void ack_lease(struct packet *packet, struct lease *lease, unsigned int offer, TIME when, char *msg, int ms_nulltp, struct host_decl *hp)
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 use_host_decl_name(struct packet *packet, struct lease *lease, struct option_state *options)
Adds hostname option when use-host-decl-names is enabled.
isc_boolean_t agent_options_stashed
int find_lease(struct lease **lp, struct packet *packet, struct shared_network *share, int *ours, int *peer_has_leases, struct lease *ip_lease_in, const char *file, int line)
#define SV_CACHE_THRESHOLD
int find_lease_by_uid(struct lease **, const unsigned char *, unsigned, const char *, int)
void dhcpinform(struct packet *packet, int ms_nulltp)
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
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
#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 got_requested_address
int find_lease_by_ip_addr(struct lease **, struct iaddr, const char *, int)
void dhcprequest(struct packet *packet, int ms_nulltp, struct lease *ip_lease)
#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 *)
struct group_object * object
int lease_mine_to_reallocate(struct lease *)
#define DHO_DHCP_REQUESTED_ADDRESS
struct packet * dhcpv6_container_packet
#define SV_RESERVE_INFINITE