34 static void commit_leases_ackout(
void *foo);
35 static void maybe_return_agent_options(
struct packet *
packet,
42 static struct timeval max_fsync;
50 static char dhcp_message [256];
51 static int site_code_min;
53 static int find_min_site_code(
struct universe *);
54 static isc_result_t lowest_site_code(
const void *,
unsigned,
void *);
56 static const char *dhcp_type_names [] = {
67 "DHCPLEASEUNASSIGNED",
74 # define send_packet trace_packet_send 84 memset (&client_identifier, 0,
sizeof client_identifier);
90 packet, (
struct lease *)0,
99 return "\"no client id\"";
103 struct packet *packet;
109 packet ->
raw -> hlen,
110 packet ->
raw -> chaddr);
127 errmsg =
"unknown network segment";
139 log_info(
"%s from %s via %s: %s", s,
142 :
"<no identifier>"),
178 cip.
len =
sizeof packet -> raw -> ciaddr;
179 memcpy (cip.
iabuf, &packet -> raw -> ciaddr,
180 sizeof packet -> raw -> ciaddr);
195 if (lease -> uid_len) {
201 memset (&data, 0,
sizeof data);
203 packet, (
struct lease *)0,
209 if (lease -> uid_len != data.
len ||
210 memcmp (lease -> uid, data.
data, data.
len)) {
216 if ((lease -> hardware_addr.hbuf [0] !=
217 packet -> raw -> htype) ||
218 (lease -> hardware_addr.hlen - 1 !=
219 packet -> raw -> hlen) ||
220 memcmp (&lease -> hardware_addr.hbuf [1],
221 packet -> raw -> chaddr,
222 packet -> raw -> hlen))
251 switch (packet -> packet_type) {
285 errmsg =
"unknown packet type";
290 lease_dereference (&lease,
MDL);
294 struct packet *packet;
301 int peer_has_leases = 0;
302 #if defined (FAILOVER_PROTOCOL) 303 dhcp_failover_state_t *peer;
309 0, &peer_has_leases, (
struct lease *)0,
MDL);
316 s =
"Hostname Unsuitable for Printing";
323 snprintf (msgbuf,
sizeof msgbuf,
"DHCPDISCOVER from %s %s%s%svia %s",
324 (packet -> raw -> htype
328 :
"<no identifier>")),
329 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
330 packet -> raw ->
giaddr.s_addr
331 ? inet_ntoa (packet -> raw ->
giaddr)
332 : packet -> interface -> name);
336 log_info (
"Packet from unknown subnet: %s",
337 inet_ntoa (packet -> raw ->
giaddr));
341 #if defined (FAILOVER_PROTOCOL) 342 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
343 peer = lease ->
pool -> failover_peer;
363 #if defined (DEBUG_FIND_LEASE) 368 lease_dereference (&lease,
MDL);
379 log_error (
"%s: peer holds all free leases",
382 log_error (
"%s: network %s: no free leases",
389 #if defined (FAILOVER_PROTOCOL) 390 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
391 peer = lease ->
pool -> failover_peer;
395 msgbuf, peer -> nrr);
399 peer = (dhcp_failover_state_t *)0;
404 if (peer_has_leases) {
405 log_debug (
"%s: load balance to peer %s",
406 msgbuf, peer -> name);
409 log_debug (
"%s: cancel load balance to peer %s - %s",
410 msgbuf, peer -> name,
"no free leases");
416 if (lease -> ends < cur_time && lease ->
scope)
422 if (when < lease ->
ends)
423 when = lease ->
ends;
429 lease_dereference (&lease,
MDL);
435 struct packet *packet;
437 struct lease *ip_lease;
449 #if defined (FAILOVER_PROTOCOL) 450 dhcp_failover_state_t *peer;
452 int have_requested_addr = 0;
458 memset (&data, 0,
sizeof data);
467 have_requested_addr = 1;
471 memcpy (cip.
iabuf, &packet -> raw -> ciaddr.s_addr, 4);
477 subnet = (
struct subnet *)0;
478 lease = (
struct lease *)0;
488 s =
"Hostname Unsuitable for Printing";
494 memset (&data, 0,
sizeof data);
506 sprintf (smbuf,
" (%s)",
piaddr (sip));
515 snprintf (msgbuf,
sizeof msgbuf,
516 "DHCPREQUEST for %s%s from %s %s%s%svia %s",
518 (packet -> raw -> htype
522 :
"<no identifier>")),
523 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
524 packet -> raw ->
giaddr.s_addr
525 ? inet_ntoa (packet -> raw ->
giaddr)
526 : packet -> interface -> name);
528 #if defined (FAILOVER_PROTOCOL) 529 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
530 peer = lease ->
pool -> failover_peer;
534 msgbuf, peer -> nrr);
559 log_debug (
"%s: lease owned by peer", msgbuf);
573 log_debug(
"%s: lease in transition state %s", msgbuf,
575 ?
"released" :
"expired");
584 log_debug (
"%s: lease reset by administrator", msgbuf);
589 #if defined(SERVER_ID_CHECK) 599 if ((sip.
len == 4) &&
600 (memcmp(sip.
iabuf,
"\0\0\0\0", sip.
len) != 0)) {
603 if (memcmp(sip.
iabuf, &from, sip.
len) != 0) {
604 log_debug(
"%s: not our server id", msgbuf);
634 peer = (dhcp_failover_state_t *)0;
680 (packet -> raw -> ciaddr.s_addr &&
681 packet -> raw ->
giaddr.s_addr) ||
682 (have_requested_addr && !packet -> raw -> ciaddr.s_addr)) {
688 if (subnet && subnet ->
group -> authoritative) {
689 log_info (
"%s: wrong network.", msgbuf);
694 log_info (
"%s: ignored (%s).", msgbuf,
696 ?
"not authoritative" :
"unknown subnet"));
703 subnet_dereference (&subnet,
MDL);
708 log_info (
"%s: wrong network.", msgbuf);
712 log_info (
"%s: ignored (not authoritative).", msgbuf);
719 if (!lease && ours) {
737 subnet_dereference (&subnet,
MDL);
739 lease_dereference (&lease,
MDL);
744 struct packet *packet;
747 struct lease *
lease = (
struct lease *)0, *
next = (
struct lease *)0;
752 char msgbuf [1024], cstr[16];
761 log_info (
"DHCPRELEASE from %s specified requested-address.",
767 memset (&data, 0,
sizeof data);
780 lease_reference (&next, lease -> n_uid,
MDL);
781 if (!memcmp (&packet -> raw -> ciaddr,
785 lease_dereference (&lease,
MDL);
787 lease_reference (&lease, next,
MDL);
788 lease_dereference (&next,
MDL);
792 lease_dereference (&next,
MDL);
800 memcpy (cip.
iabuf, &packet -> raw -> ciaddr, 4);
807 (lease -> hardware_addr.hlen != packet -> raw -> hlen + 1 ||
808 lease -> hardware_addr.hbuf [0] != packet -> raw -> htype ||
809 memcmp (&lease -> hardware_addr.hbuf [1],
810 packet -> raw -> chaddr, packet -> raw -> hlen)))
811 lease_dereference (&lease,
MDL);
813 if (lease && lease -> client_hostname) {
814 if ((strlen (lease -> client_hostname) <= 64) &&
816 s = lease -> client_hostname;
818 s =
"Hostname Unsuitable for Printing";
826 strncpy(cstr, inet_ntoa (packet -> raw -> ciaddr), 15);
832 snprintf (msgbuf,
sizeof msgbuf,
833 "DHCPRELEASE of %s from %s %s%s%svia %s (%sfound)",
835 (packet -> raw -> htype
839 :
"<no identifier>")),
840 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
841 packet -> raw ->
giaddr.s_addr
842 ? inet_ntoa (packet -> raw ->
giaddr)
843 : packet -> interface -> name,
844 lease ?
"" :
"not ");
846 #if defined (FAILOVER_PROTOCOL) 847 if (lease && lease ->
pool && lease ->
pool -> failover_peer) {
848 dhcp_failover_state_t *peer = lease ->
pool -> failover_peer;
852 peer -> name, peer -> nrr);
866 if (lease && lease -> ends >
cur_time) {
870 #if defined(FAILOVER_PROTOCOL) 874 lease_dereference (&lease,
MDL);
880 struct packet *packet;
900 memset (&data, 0,
sizeof data);
913 if (lease && lease -> client_hostname) {
914 if ((strlen (lease -> client_hostname) <= 64) &&
916 s = lease -> client_hostname;
918 s =
"Hostname Unsuitable for Printing";
925 snprintf (msgbuf,
sizeof msgbuf,
926 "DHCPDECLINE of %s from %s %s%s%svia %s",
928 (packet -> raw -> htype
932 :
"<no identifier>")),
933 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
934 packet -> raw ->
giaddr.s_addr
935 ? inet_ntoa (packet -> raw ->
giaddr)
936 : packet -> interface -> name);
949 for (i = packet -> class_count; i > 0; i--) {
951 (NULL, packet, NULL, NULL, packet->
options, options,
961 packet -> options, options,
962 &lease -> scope, oc,
MDL)) {
965 #if defined (FAILOVER_PROTOCOL) 966 if (lease ->
pool && lease ->
pool -> failover_peer) {
967 dhcp_failover_state_t *peer =
968 lease ->
pool -> failover_peer;
973 peer -> name, peer -> nrr);
985 status =
"abandoned";
987 status =
"not found";
993 log_info (
"%s: %s", msgbuf, status);
995 #if defined(FAILOVER_PROTOCOL) 1001 lease_dereference (&lease,
MDL);
1007 struct packet *packet;
1010 char msgbuf[1024], *addr_type;
1015 struct packet outgoing;
1018 struct iaddr cip, gip, sip;
1021 struct sockaddr_in to;
1022 struct in_addr from;
1023 isc_boolean_t zeroed_ciaddr;
1025 int result, h_m_client_ip = 0;
1026 struct host_decl *host = NULL, *hp = NULL, *h;
1027 #if defined (DEBUG_INFORM_HOST) 1028 int h_w_fixed_addr = 0;
1037 zeroed_ciaddr = ISC_TRUE;
1040 addr_type =
"source";
1042 zeroed_ciaddr = ISC_FALSE;
1045 addr_type =
"client";
1053 if (zeroed_ciaddr == ISC_TRUE) {
1054 addr_type =
"relay";
1063 snprintf(msgbuf,
sizeof(msgbuf),
"DHCPINFORM from %s via %s",
1070 if (!memcmp(cip.
iabuf,
"\0\0\0", 4)) {
1071 log_info(
"%s: ignored (null source address).", msgbuf);
1086 memset(&d1, 0,
sizeof d1);
1093 log_info(
"%s: ignored (invalid subnet selection option).", msgbuf);
1115 if ((zeroed_ciaddr == ISC_TRUE) && (gip.
len != 0))
1116 addr_type =
"relay link select";
1118 addr_type =
"selected";
1123 if (subnet == NULL) {
1124 log_info(
"%s: unknown subnet for %s address %s",
1125 msgbuf, addr_type,
piaddr(sip));
1134 if (subnet && !subnet ->
group -> authoritative) {
1136 log_info (
"%s: not authoritative for subnet %s",
1137 msgbuf,
piaddr (subnet -> net));
1139 log_info (
"If this DHCP server is authoritative for%s",
1141 log_info (
"please write an `authoritative;' directi%s",
1142 "ve either in the");
1143 log_info (
"subnet declaration or in some scope that%s",
1145 log_info (
"subnet declaration - for example, write %s",
1147 log_info (
"of the dhcpd.conf file.");
1151 subnet_dereference (&subnet,
MDL);
1156 memset (&outgoing, 0,
sizeof outgoing);
1157 memset (&raw, 0,
sizeof raw);
1158 outgoing.
raw = &raw;
1160 maybe_return_agent_options(packet, options);
1170 for (i = packet -> class_count; i > 0; i--) {
1175 subnet ? subnet->
group : NULL,
1194 memset(&d1, 0,
sizeof(d1));
1202 #if defined (DEBUG_INFORM_HOST) 1204 log_debug (
"dhcpinform: found host by ID " 1205 "-- checking fixed-address match");
1209 for (h = hp; !h_m_client_ip && h; h = h->n_ipaddr) {
1213 memset(&fixed_addr, 0,
sizeof(fixed_addr));
1215 NULL, NULL, NULL, NULL,
1217 h->fixed_addr,
MDL))
1220 #if defined (DEBUG_INFORM_HOST) 1224 (i + cip.
len) <= fixed_addr.
len;
1226 if (memcmp(fixed_addr.
data + i,
1228 #if defined (DEBUG_INFORM_HOST) 1230 "host with matching " 1231 "fixed-address by ID");
1233 host_reference(&host, h,
MDL);
1242 for (h = hp; !host && h; h = h->
n_ipaddr) {
1246 #if defined (DEBUG_INFORM_HOST) 1248 "without fixed-address by ID");
1250 host_reference(&host, h,
MDL);
1254 host_dereference (&hp,
MDL);
1256 if (!host || !h_m_client_ip) {
1261 #if defined (DEBUG_INFORM_HOST) 1263 log_debug (
"dhcpinform: found host by HW " 1264 "-- checking fixed-address match");
1269 for (h = hp; !h_m_client_ip && h; h = h->n_ipaddr) {
1273 memset (&fixed_addr, 0,
sizeof(fixed_addr));
1275 NULL, NULL, NULL, NULL,
1277 h->fixed_addr,
MDL))
1280 #if defined (DEBUG_INFORM_HOST) 1284 (i + cip.
len) <= fixed_addr.
len;
1286 if (memcmp(fixed_addr.
data + i,
1288 #if defined (DEBUG_INFORM_HOST) 1290 "host with matching " 1291 "fixed-address by HW");
1299 host_dereference(&host,
MDL);
1300 host_reference(&host, h,
MDL);
1308 for (h = hp; !host && h; h = h->
n_ipaddr) {
1312 #if defined (DEBUG_INFORM_HOST) 1313 log_debug (
"dhcpinform: found host without " 1314 "fixed-address by HW");
1316 host_reference (&host, h,
MDL);
1321 host_dereference (&hp,
MDL);
1324 #if defined (DEBUG_INFORM_HOST) 1329 if (h_w_fixed_addr && !h_m_client_ip) {
1330 log_info (
"dhcpinform: matching host with " 1331 "fixed-address different than " 1332 "client IP detected?!");
1340 #if defined (DEBUG_INFORM_HOST) 1341 log_info (
"dhcpinform: applying host (group) options");
1349 host_dereference (&host,
MDL);
1355 memset (&d1, 0,
sizeof d1);
1363 if (i >=
sizeof(raw.
file)) {
1364 log_info(
"file name longer than packet field " 1365 "truncated - field: %lu name: %d %.*s",
1366 (
unsigned long)
sizeof(raw.
file), i,
1368 i =
sizeof(raw.
file);
1383 if (i >=
sizeof(raw.
sname)) {
1384 log_info(
"server name longer than packet field " 1385 "truncated - field: %lu name: %d %.*s",
1386 (
unsigned long)
sizeof(raw.
sname), i,
1388 i =
sizeof(raw.
sname);
1409 &dhcpack, 1, 0, 0,
MDL)) {
1410 option_code_hash_lookup(&oc->
option,
1427 subnet -> netmask.iabuf,
1428 subnet -> netmask.len,
1430 option_code_hash_lookup(&oc->
option,
1445 packet -> options, options,
1450 (
const char *)d1.
data, d1.
len,
1455 subnet_dereference (&subnet,
MDL);
1459 options -> site_universe = u ->
index;
1467 memset (&prl, 0,
sizeof prl);
1484 packet -> options, options,
1489 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
1499 packet -> options, options,
1532 raw.
ciaddr = packet -> raw -> ciaddr;
1533 memcpy (raw.
chaddr, packet -> raw -> chaddr,
sizeof raw.
chaddr);
1534 raw.
hlen = packet -> raw -> hlen;
1535 raw.
htype = packet -> raw -> htype;
1537 raw.
xid = packet -> raw -> xid;
1538 raw.
secs = packet -> raw -> secs;
1539 raw.
flags = packet -> raw -> flags;
1540 raw.
hops = packet -> raw -> hops;
1549 to.sin_family = AF_INET;
1551 to.sin_len =
sizeof to;
1553 memset (to.sin_zero, 0,
sizeof to.sin_zero);
1573 if (!raw.ciaddr.s_addr && gip.
len) {
1574 memcpy(&to.sin_addr, gip.
iabuf, 4);
1579 memcpy(&to.sin_addr, cip.
iabuf, 4);
1584 snprintf(msgbuf,
sizeof msgbuf,
"DHCPACK to %s (%s) via",
piaddr(cip),
1587 "<no client hardware address>");
1593 : packet -> interface);
1595 outgoing.packet_length, from, &to, NULL);
1597 log_error ("%s:%d: Failed to send %d byte long packet over %s "
1598 "interface.", MDL, outgoing.packet_length,
1604 subnet_dereference (&subnet, MDL);
1606 TRACE(DHCPD_INFORM_DONE());
1610 struct packet *packet;
1613 struct sockaddr_in to;
1614 struct in_addr from;
1618 struct packet outgoing;
1626 memset (&outgoing, 0,
sizeof outgoing);
1627 memset (&raw, 0,
sizeof raw);
1632 log_error (
"No memory for DHCPNAK message type.");
1638 log_error (
"No memory for expr_const expression.");
1651 log_error (
"No memory for DHCPNAK message type.");
1656 (
unsigned char *)dhcp_message,
1657 strlen (dhcp_message), 1, 0,
MDL)) {
1658 log_error (
"No memory for expr_const expression.");
1679 #if defined(SERVER_ID_FOR_NAK) 1717 memcpy (raw.
chaddr, packet -> raw -> chaddr,
sizeof raw.
chaddr);
1718 raw.
hlen = packet -> raw -> hlen;
1719 raw.
htype = packet -> raw -> htype;
1721 raw.
xid = packet -> raw -> xid;
1722 raw.
secs = packet -> raw -> secs;
1724 raw.
hops = packet -> raw -> hops;
1728 log_info (
"DHCPNAK on %s to %s via %s",
1731 packet -> raw ->
giaddr.s_addr
1732 ? inet_ntoa (packet -> raw ->
giaddr)
1733 : packet -> interface -> name);
1737 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
1743 to.sin_family = AF_INET;
1745 to.sin_len =
sizeof to;
1747 memset (to.sin_zero, 0,
sizeof to.sin_zero);
1755 if (raw.giaddr.s_addr) {
1756 to.sin_addr = raw.giaddr;
1757 if (raw.giaddr.s_addr != htonl (INADDR_LOOPBACK))
1762 if (fallback_interface) {
1763 result =
send_packet(fallback_interface, packet, &raw,
1767 log_error (
"%s:%d: Failed to send %d byte long " 1768 "packet over %s interface.",
MDL,
1770 fallback_interface->name);
1784 log_error (
"%s:%d: Failed to send %d byte long packet over %s " 1793 struct packet *packet;
1806 TIME offered_lease_time;
1808 TIME min_lease_time;
1812 isc_result_t result;
1815 struct in_addr from;
1816 TIME remaining_time;
1818 #if defined(DELAYED_ACK) 1820 isc_boolean_t enqueue = ISC_FALSE;
1822 int use_old_lease = 0;
1836 lease_cltt = lease->
cltt;
1840 host_reference (&host, hp,
MDL);
1841 else if (lease -> host)
1842 host_reference (&host, lease -> host,
MDL);
1847 log_fatal (
"unable to allocate lease state!");
1855 state -> got_server_identifier = 1;
1857 maybe_return_agent_options(packet, state->
options);
1895 for (i = packet -> class_count; i > 0; i--) {
1921 state -> options, &lease -> scope,
1926 seek = (
struct lease *)0;
1931 if (seek == lease && !seek ->
n_uid) {
1932 lease_dereference (&seek,
MDL);
1935 next = (
struct lease *)0;
1939 next = (
struct lease *)0;
1942 lease_reference (&next, seek ->
n_uid,
MDL);
1943 if (seek != lease &&
1950 lease_dereference (&seek,
MDL);
1952 lease_reference (&seek, next,
MDL);
1953 lease_dereference (&next,
MDL);
1957 lease_dereference (&next,
MDL);
1960 lease_dereference (&seek,
MDL);
1967 !host -> client_identifier.len &&
1977 seek = (
struct lease *)0;
1983 if (seek == lease && !seek ->
n_hw) {
1984 lease_dereference (&seek,
MDL);
1987 next = (
struct lease *)0;
1990 lease_reference (&next, seek ->
n_hw,
MDL);
1991 if (seek != lease &&
1998 lease_dereference (&seek,
MDL);
2000 lease_reference (&seek, next,
MDL);
2001 lease_dereference (&next,
MDL);
2005 lease_dereference (&next,
MDL);
2008 lease_dereference (&seek,
MDL);
2018 memset (&d1, 0,
sizeof d1);
2024 packet -> options, state -> options,
2027 ntohs (packet -> raw -> secs) < d1.
data [0]) {
2028 log_info(
"%s: configured min-secs value (%d) " 2029 "is greater than secs field (%d). " 2030 "message dropped.", msg, d1.
data[0],
2035 host_dereference (&host,
MDL);
2058 packet -> options, state -> options,
2059 &lease -> scope, oc,
MDL)) {
2062 for (h = hp; h; h = h ->
n_ipaddr) {
2063 if (!h -> fixed_addr)
2067 host_reference (&host, h,
MDL);
2069 host_dereference(&hp,
MDL);
2073 packet -> raw -> htype,
2074 packet -> raw -> chaddr,
2075 packet -> raw -> hlen,
2077 for (h = hp; h; h = h ->
n_ipaddr) {
2078 if (!h -> fixed_addr)
2082 host_reference (&host, h,
MDL);
2084 host_dereference(&hp,
MDL);
2089 for (h = hp; h; h = h ->
n_ipaddr) {
2090 if (!h -> fixed_addr)
2094 host_reference (&host, h,
MDL);
2096 host_dereference(&hp,
MDL);
2121 &lease -> scope, oc,
MDL)) {
2123 log_info (
"%s: unknown client", msg);
2126 host_dereference (&host,
MDL);
2139 &lease -> scope, oc,
MDL)) {
2141 log_info (
"%s: bootp disallowed", msg);
2144 host_dereference (&host,
MDL);
2157 &lease -> scope, oc,
MDL)) {
2159 log_info (
"%s: booting disallowed", msg);
2162 host_dereference (&host,
MDL);
2171 if (lease -> billing_class) {
2173 if (packet -> classes [i] ==
2174 lease -> billing_class)
2176 if (i == packet -> class_count)
2187 struct class *billclass, *subclass;
2189 billclass = packet->
classes[i];
2196 if (subclass == NULL)
2197 cname = subclass->
name;
2199 cname = billclass->
name;
2203 log_info(
"%s: no available billing: lease " 2204 "limit reached in all matching " 2205 "classes (last: '%s')", msg, cname);
2208 host_dereference(&host,
MDL);
2233 packet -> options, state -> options,
2234 &lease -> scope, oc,
MDL);
2242 packet -> options, state -> options,
2243 &lease -> scope, oc,
MDL);
2248 lt = (
struct lease *)0;
2249 result = lease_allocate (<,
MDL);
2250 if (result != ISC_R_SUCCESS) {
2251 log_info (
"%s: can't allocate temporary lease structure: %s",
2252 msg, isc_result_totext (result));
2255 host_dereference (&host,
MDL);
2279 if (d1.
len == sizeof (u_int32_t))
2280 default_lease_time =
2296 if (s1 && (d1.
len == 4)) {
2297 u_int32_t ones = 0xffffffff;
2323 if ((memcmp(d1.
data, &ones, 4) == 0) &&
2334 "reservation made on %s.",
2354 if (d1.
len == sizeof (u_int32_t))
2363 || lease_time > max_lease_time)
2367 if (min_lease_time > max_lease_time)
2377 if (d1.
len == sizeof (u_int32_t))
2387 memset(&d1, 0,
sizeof(d1));
2394 if (d1.
len == 1 && d1.
data[0] > 0 &&
2397 int poolfilled, total, count;
2400 adaptive_time = min_lease_time;
2412 poolfilled = (total > (INT_MAX / 100)) ?
2413 total / (count / 100) :
2414 (total * 100) / count;
2416 log_debug(
"Adap-lease: Total: %d, Free: %d, " 2417 "Ends: %d, Adaptive: %d, Fill: %d, " 2422 (
int)adaptive_time, poolfilled,
2425 if (poolfilled >= d1.
data[0] &&
2426 lease_time > adaptive_time) {
2427 log_info(
"Pool over threshold, time " 2428 "for %s reduced from %d to " 2431 (
int)adaptive_time);
2433 lease_time = adaptive_time;
2447 lease_dereference (<,
MDL);
2449 host_dereference (&host,
MDL);
2477 lease_dereference (<,
MDL);
2479 host_dereference (&host,
MDL);
2483 if (lease_time > remaining_time)
2484 lease_time = remaining_time;
2487 if (lease_time < min_lease_time) {
2489 lease_time = min_lease_time;
2495 #if defined (FAILOVER_PROTOCOL) 2498 if (lease ->
pool && lease ->
pool -> failover_peer) {
2499 TIME new_lease_time = lease_time;
2500 dhcp_failover_state_t *peer =
2501 lease ->
pool -> failover_peer;
2510 if (lease_time > peer->mclt) {
2518 new_lease_time = peer->mclt;
2520 (lt->
tsfp + peer->mclt))
2534 (new_lease_time / 2);
2547 lease_time = new_lease_time;
2554 state -> offered_expiry =
MAX_TIME - 1;
2556 state -> offered_expiry =
cur_time + lease_time;
2560 lt ->
ends = state -> offered_expiry;
2580 if (d1.
len == sizeof (u_int32_t))
2593 if (d1.
len == sizeof (u_int32_t))
2600 lt ->
ends = state -> offered_expiry = cur_time + lease_time;
2628 unsigned char *tuid;
2644 host_reference (< -> host, host,
MDL);
2645 host_dereference (&host,
MDL);
2647 if (lease -> subnet)
2648 subnet_reference (< -> subnet, lease -> subnet,
MDL);
2661 if (lease ->
scope) {
2730 }
else if (oc && s1) {
2733 log_error (
"no memory for client hostname.");
2745 sizeof packet -> raw -> chaddr);
2762 if ((!offer || offer ==
DHCPACK) &&
2775 if (lease ->
flags & STATIC_LEASE) {
2781 packet -> raw -> chaddr,
2782 sizeof packet -> raw -> chaddr);
2784 int commit = (!offer || (offer ==
DHCPACK));
2800 if (d1.
len == 1 && (d1.
data[0] < 100))
2801 thresh = d1.
data[0];
2813 (thresh > 0) && (offer ==
DHCPACK) &&
2816 int prev_lease = lease->
ends - lease->
starts;
2819 if (prev_lease <= (INT_MAX / thresh))
2820 limit = prev_lease * thresh / 100;
2822 limit = prev_lease / 100 * thresh;
2832 #if !defined(DELAYED_ACK) 2841 if ((use_old_lease == 0) &&
2861 if ((use_old_lease == 0) &&
2863 !offer || offer ==
DHCPACK, 0)) {
2865 log_info (
"%s: database update failed", msg);
2867 lease_dereference (<,
MDL);
2871 lease_dereference (<,
MDL);
2878 state -> ciaddr = packet -> raw -> ciaddr;
2879 state -> xid = packet -> raw -> xid;
2880 state -> secs = packet -> raw -> secs;
2881 state -> bootp_flags = packet -> raw ->
flags;
2882 state -> hops = packet -> raw -> hops;
2883 state -> offer = offer;
2891 packet -> options, state -> options,
2902 packet -> options, state -> options,
2904 if (d1.
len == sizeof (u_int16_t))
2913 packet -> options, state -> options,
2915 if (d1.
len == sizeof (u_int16_t))
2916 state -> max_message_size =
2947 if (state -> offer) {
2952 &state -> offer, 1, 0, 0,
MDL)) {
2953 option_code_hash_lookup(&oc->
option,
2957 state -> options, oc);
2964 memcpy(state->
from.
iabuf, &from,
sizeof(from));
2965 state->
from.
len =
sizeof(from);
2967 offered_lease_time =
2968 state -> offered_expiry -
cur_time;
2976 option_code_hash_lookup(&oc->
option,
2980 state -> options, oc);
2998 if (rebind_time >= offered_lease_time)
3002 offered_lease_time = rebind_time;
3020 if (state ->
ip -> address_count) {
3022 sizeof state ->
ip -> addresses [0];
3023 memcpy (state -> from.iabuf,
3024 &state ->
ip -> addresses [0],
3030 memset (&state -> siaddr, 0,
sizeof state -> siaddr);
3036 packet -> options, state -> options,
3037 &lease -> scope, oc,
MDL)) {
3041 memcpy (&state -> siaddr, d1.
data, 4);
3053 lease -> subnet -> netmask.iabuf,
3054 lease -> subnet -> netmask.len,
3056 option_code_hash_lookup(&oc->
option,
3060 state -> options, oc);
3072 lease -> host && lease -> host -> name &&
3075 packet -> options, state -> options, &lease -> scope,
3081 lease -> host -> name),
3082 strlen (lease -> host -> name),
3084 option_code_hash_lookup(&oc->
option,
3088 state -> options, oc);
3100 (&ignorep, packet, lease, NULL,
3108 h = gethostbyaddr ((
char *)&ia,
sizeof ia, AF_INET);
3110 log_error (
"No hostname for %s", inet_ntoa (ia));
3117 strlen (h -> h_name) + 1,
3119 option_code_hash_lookup(&oc->
option,
3123 state -> options, oc);
3136 packet -> options, state -> options, &lease -> scope,
3148 option_code_hash_lookup(&oc->
option,
3152 state -> options, oc);
3165 packet -> options, state -> options,
3166 &lease -> scope, oc,
MDL)) {
3170 (
const char *)d1.
data, d1.
len,
3176 state -> options -> site_universe = u ->
index;
3198 packet -> options, state -> options,
3199 &lease -> scope, oc,
MDL);
3203 dump_raw ((
unsigned char *)packet -> raw, packet -> packet_length);
3206 lease -> state = state;
3215 if (offer ==
DHCPOFFER && !(lease -> flags & STATIC_LEASE) &&
3223 &lease -> scope, oc,
MDL))) {
3233 &lease -> scope, oc,
MDL)) {
3234 if (d1.
len == sizeof (u_int32_t))
3244 log_debug (
"Ping timeout: %ld", (
long)ping_timeout);
3253 tv.tv_sec =
cur_tv.tv_sec + ping_timeout;
3254 tv.tv_usec =
cur_tv.tv_usec;
3261 #if defined(DELAYED_ACK) 3288 if (free_ackqueue) {
3290 free_ackqueue = q->
next;
3295 log_fatal(
"delayed_ack_enqueue: no memory!");
3297 memset(q, 0,
sizeof *q);
3299 lease_reference(&q->
lease, lease,
MDL);
3312 memset(&max_fsync, 0,
sizeof(max_fsync));
3315 struct timeval next_fsync;
3317 if (max_fsync.tv_sec == 0 && max_fsync.tv_usec == 0) {
3320 max_fsync.tv_usec =
cur_tv.tv_usec +
3323 if (max_fsync.tv_usec >= 1000000) {
3325 max_fsync.tv_usec -= 1000000;
3330 next_fsync.tv_sec =
cur_tv.tv_sec;
3332 if (next_fsync.tv_usec >= 1000000) {
3333 next_fsync.tv_sec++;
3334 next_fsync.tv_usec -= 1000000;
3337 if ((next_fsync.tv_sec > max_fsync.tv_sec) ||
3338 ((next_fsync.tv_sec == max_fsync.tv_sec) &&
3339 (next_fsync.tv_usec > max_fsync.tv_usec))) {
3340 next_fsync.tv_sec = max_fsync.tv_sec;
3341 next_fsync.tv_usec = max_fsync.tv_usec;
3344 add_timeout(&next_fsync, commit_leases_ackout, NULL,
3350 commit_leases_ackout(
void *foo)
3355 memset(&max_fsync, 0,
sizeof(max_fsync));
3368 for (ack = ackqueue_tail ; ack ; ack = p) {
3373 log_error(
"delayed ack for %s has gone stale",
3378 lease_dereference(&ack->
lease,
MDL);
3379 ack->
next = free_ackqueue;
3380 free_ackqueue = ack;
3382 ackqueue_head = NULL;
3383 ackqueue_tail = NULL;
3387 #if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT) 3389 relinquish_ackqueue(
void)
3393 for (q = ackqueue_head ; q ; q = n) {
3397 for (q = free_ackqueue ; q ; q = n) {
3405 struct lease *lease;
3410 struct sockaddr_in to;
3411 struct in_addr from;
3415 int nulltp, bootpp, unicastp = 1;
3420 log_fatal (
"dhcp_reply was supplied lease with no state!");
3425 memset (&raw, 0,
sizeof raw);
3426 memset (&d1, 0,
sizeof d1);
3430 if (state -> filename.len && state -> filename.data) {
3432 state -> filename.data,
3433 state -> filename.len >
sizeof raw.
file 3434 ?
sizeof raw.
file : state -> filename.len);
3435 if (
sizeof raw.
file > state -> filename.len)
3436 memset (&raw.
file [state -> filename.len], 0,
3437 (
sizeof raw.
file) - state -> filename.len);
3439 log_info(
"file name longer than packet field " 3440 "truncated - field: %lu name: %d %.*s",
3441 (
unsigned long)
sizeof(raw.
file),
3442 state->filename.len, (
int)state->filename.len,
3443 state->filename.data);
3449 if (state -> server_name.len && state -> server_name.data) {
3451 state -> server_name.data,
3452 state -> server_name.len >
sizeof raw.
sname 3453 ?
sizeof raw.
sname : state -> server_name.len);
3454 if (
sizeof raw.
sname > state -> server_name.len)
3455 memset (&raw.
sname [state -> server_name.len], 0,
3456 (
sizeof raw.
sname) - state -> server_name.len);
3458 log_info(
"server name longer than packet field " 3459 "truncated - field: %lu name: %d %.*s",
3460 (
unsigned long)
sizeof(raw.
sname),
3468 &lease -> hardware_addr.hbuf [1],
sizeof raw.
chaddr);
3469 raw.
hlen = lease -> hardware_addr.hlen - 1;
3470 raw.
htype = lease -> hardware_addr.hbuf [0];
3486 packet_length =
cons_options (state -> packet, &raw, lease,
3488 state -> max_message_size,
3489 state -> packet -> options,
3491 bufs, nulltp, bootpp,
3492 &state -> parameter_request_list,
3495 memcpy (&raw.
ciaddr, &state -> ciaddr,
sizeof raw.
ciaddr);
3497 raw.
siaddr = state -> siaddr;
3500 raw.
xid = state -> xid;
3501 raw.
secs = state -> secs;
3502 raw.
flags = state -> bootp_flags;
3503 raw.
hops = state -> hops;
3506 if (lease -> client_hostname) {
3507 if ((strlen (lease -> client_hostname) <= 64) &&
3509 s = lease -> client_hostname;
3511 s =
"Hostname Unsuitable for Printing";
3516 log_info (
"%s on %s to %s %s%s%svia %s",
3518 ? (state -> offer ==
DHCPACK ?
"DHCPACK" :
"DHCPOFFER")
3521 (lease -> hardware_addr.hlen > 1
3523 lease -> hardware_addr.hlen - 1,
3524 &lease -> hardware_addr.hbuf [1])
3526 s ?
"(" :
"", s ? s :
"", s ?
") " :
"",
3528 ? inet_ntoa (state ->
giaddr)
3529 : state ->
ip -> name));
3532 hto.
hlen = lease -> hardware_addr.hlen;
3533 memcpy (hto.
hbuf, lease -> hardware_addr.hbuf, hto.
hlen);
3535 to.sin_family = AF_INET;
3537 to.sin_len =
sizeof to;
3539 memset (to.sin_zero, 0,
sizeof to.sin_zero);
3542 dump_raw ((
unsigned char *)&raw, packet_length);
3551 if (raw.giaddr.s_addr) {
3552 to.sin_addr = raw.giaddr;
3553 if (raw.giaddr.s_addr != htonl (INADDR_LOOPBACK))
3558 if (fallback_interface) {
3559 result =
send_packet(fallback_interface, NULL, &raw,
3560 packet_length, raw.siaddr, &to,
3563 log_error (
"%s:%d: Failed to send %d byte long " 3564 "packet over %s interface.",
MDL,
3566 fallback_interface->name);
3586 }
else if (raw.ciaddr.s_addr &&
3593 to.sin_addr = raw.
ciaddr;
3596 if (fallback_interface) {
3597 result =
send_packet(fallback_interface, NULL, &raw,
3598 packet_length, raw.siaddr, &to,
3601 log_error(
"%s:%d: Failed to send %d byte long" 3602 " packet over %s interface.",
MDL,
3604 fallback_interface->name);
3618 to.sin_addr = raw.yiaddr;
3629 memcpy (&from, state -> from.iabuf,
sizeof from);
3632 from, &to, unicastp ? &hto : NULL);
3634 log_error (
"%s:%d: Failed to send %d byte long " 3635 "packet over %s interface.",
MDL,
3636 packet_length, state->
ip->
name);
3651 int *peer_has_leases,
struct lease *ip_lease_in,
3654 struct lease *uid_lease = (
struct lease *)0;
3655 struct lease *ip_lease = (
struct lease *)0;
3656 struct lease *hw_lease = (
struct lease *)0;
3657 struct lease *lease = (
struct lease *)0;
3661 struct lease *fixed_lease = (
struct lease *)0;
3662 struct lease *next = (
struct lease *)0;
3665 int have_client_identifier = 0;
3671 #if defined(FAILOVER_PROTOCOL) 3673 if (peer_has_leases) {
3676 for (pool = share->
pools ; pool ; pool = pool->
next) {
3681 (peer->i_am == secondary && pool->
free_leases))) {
3682 *peer_has_leases = 1;
3689 if (packet -> raw -> ciaddr.s_addr) {
3691 memcpy (cip.
iabuf, &packet -> raw -> ciaddr, 4);
3696 memset (&d1, 0,
sizeof d1);
3703 packet -> got_requested_address = 1;
3715 memset (&client_identifier, 0,
sizeof client_identifier);
3718 packet, (
struct lease *)0,
3723 have_client_identifier = 1;
3728 client_identifier.
len,
MDL)) {
3730 packet -> known = 1;
3734 #if defined (DEBUG_FIND_LEASE) 3736 log_info (
"Found host for client identifier: %s.",
3742 host_reference (&host, hp,
MDL);
3743 host_dereference (&hp,
MDL);
3747 client_identifier.
len,
MDL);
3752 if (!fixed_lease && !host) {
3754 packet -> raw -> chaddr,
3755 packet -> raw -> hlen,
MDL)) {
3757 packet -> known = 1;
3759 host_dereference (&host,
MDL);
3760 host_reference (&host, hp,
MDL);
3761 host_dereference (&hp,
MDL);
3763 #if defined (DEBUG_FIND_LEASE) 3765 log_info (
"Found host for link address: %s.",
3774 if (!fixed_lease && !host) {
3779 host_dereference(&host,
MDL);
3780 host_reference(&host, hp,
MDL);
3781 host_dereference(&hp,
MDL);
3783 #if defined (DEBUG_FIND_LEASE) 3785 log_info (
"Found host via host-identifier");
3794 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease &&
3800 strcpy (dhcp_message,
"requested address is incorrect");
3801 #if defined (DEBUG_FIND_LEASE) 3802 log_info (
"Client's fixed-address %s doesn't match %s%s",
3820 #if defined (DEBUG_FIND_LEASE) 3821 log_info (
"trying next lease matching client id: %s",
3825 #if defined (FAILOVER_PROTOCOL) 3837 #if defined (DEBUG_FIND_LEASE) 3838 log_info(
"not active or not mine to allocate: %s",
3846 #if defined (DEBUG_FIND_LEASE) 3847 log_info (
"wrong network segment: %s",
3857 #if defined (DEBUG_FIND_LEASE) 3862 if (uid_lease -> n_uid)
3863 lease_reference (&next,
3864 uid_lease -> n_uid,
MDL);
3865 if (!packet -> raw -> ciaddr.s_addr)
3867 lease_dereference (&uid_lease,
MDL);
3869 lease_reference (&uid_lease, next,
MDL);
3870 lease_dereference (&next,
MDL);
3876 #if defined (DEBUG_FIND_LEASE) 3878 log_info (
"Found lease for client id: %s.",
3889 h.
hlen = packet -> raw -> hlen + 1;
3890 h.
hbuf [0] = packet -> raw -> htype;
3891 memcpy (&h.
hbuf [1], packet -> raw -> chaddr, packet -> raw -> hlen);
3894 #if defined (DEBUG_FIND_LEASE) 3895 log_info (
"trying next lease matching hw addr: %s",
3898 #if defined (FAILOVER_PROTOCOL) 3911 #if defined (DEBUG_FIND_LEASE) 3912 log_info(
"not active or not mine to allocate: %s",
3925 if (hw_lease -> binding_state !=
FTS_FREE &&
3928 (!have_client_identifier ||
3929 hw_lease -> uid_len != client_identifier.
len ||
3930 memcmp (hw_lease -> uid, client_identifier.
data,
3931 hw_lease -> uid_len))) {
3932 #if defined (DEBUG_FIND_LEASE) 3933 log_info (
"wrong client identifier: %s",
3939 #if defined (DEBUG_FIND_LEASE) 3940 log_info (
"wrong network segment: %s",
3949 #if defined (DEBUG_FIND_LEASE) 3953 if (!packet -> raw -> ciaddr.s_addr)
3956 if (hw_lease -> n_hw)
3957 lease_reference (&next, hw_lease -> n_hw,
MDL);
3958 lease_dereference (&hw_lease,
MDL);
3960 lease_reference (&hw_lease, next,
MDL);
3961 lease_dereference (&next,
MDL);
3967 #if defined (DEBUG_FIND_LEASE) 3969 log_info (
"Found lease for hardware address: %s.",
3976 lease_reference (&ip_lease, ip_lease_in,
MDL);
3980 #if defined (DEBUG_FIND_LEASE) 3982 log_info (
"Found lease for requested address: %s.",
3989 if (ip_lease && ours)
3999 if (ip_lease && (ip_lease -> subnet ->
shared_network != share)) {
4002 #if defined (DEBUG_FIND_LEASE) 4003 log_info (
"...but it was on the wrong shared network.");
4005 strcpy (dhcp_message,
"requested address on bad subnet");
4006 lease_dereference (&ip_lease,
MDL);
4020 (!have_client_identifier ||
4021 ip_lease -> uid_len != client_identifier.
len ||
4022 memcmp (ip_lease -> uid, client_identifier.
data,
4023 ip_lease -> uid_len)) :
4024 (ip_lease -> hardware_addr.hbuf [0] != packet -> raw -> htype ||
4025 ip_lease -> hardware_addr.hlen != packet -> raw -> hlen + 1 ||
4026 memcmp (&ip_lease -> hardware_addr.hbuf [1],
4027 packet -> raw -> chaddr,
4028 (
unsigned)(ip_lease -> hardware_addr.hlen - 1))))) {
4037 if (ip_lease -> binding_state !=
FTS_FREE &&
4039 #if defined (DEBUG_FIND_LEASE) 4040 log_info (
"rejecting lease for requested address.");
4044 if (ours && ip_lease -> binding_state !=
FTS_ACTIVE)
4046 lease_dereference (&ip_lease,
MDL);
4054 if (ip_lease && (uid_lease || hw_lease) &&
4061 #if defined (DEBUG_FIND_LEASE) 4062 log_info(
"ip lease not active or not ours to offer.");
4064 lease_dereference(&ip_lease,
MDL);
4071 ip_lease->
uid && ip_lease != uid_lease) {
4072 if (have_client_identifier &&
4073 (ip_lease -> uid_len == client_identifier.
len) &&
4074 !memcmp (client_identifier.
data,
4075 ip_lease -> uid, ip_lease -> uid_len)) {
4078 log_error (
"client %s has duplicate%s on %s",
4081 (ip_lease -> subnet ->
4089 !packet -> raw -> ciaddr.s_addr &&
4095 lease_dereference (&uid_lease,
MDL);
4096 lease_reference (&uid_lease, ip_lease,
MDL);
4103 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease) {
4104 lease_dereference (&fixed_lease,
MDL);
4106 log_error (
"Dynamic and static leases present for %s.",
4108 log_error (
"Remove host declaration %s or remove %s",
4109 (fixed_lease && fixed_lease -> host
4110 ? (fixed_lease -> host -> name
4111 ? fixed_lease -> host -> name
4115 log_error (
"from the dynamic address pool for %s",
4119 lease_dereference (&ip_lease,
MDL);
4120 strcpy (dhcp_message,
4121 "database conflict - call for help!");
4124 if (ip_lease && ip_lease != uid_lease) {
4125 #if defined (DEBUG_FIND_LEASE) 4126 log_info (
"requested address not available.");
4128 lease_dereference (&ip_lease,
MDL);
4134 if (packet -> packet_type ==
DHCPREQUEST && fixed_lease && ip_lease)
4138 if (hw_lease && hw_lease == uid_lease) {
4139 #if defined (DEBUG_FIND_LEASE) 4140 log_info (
"hardware lease and uid lease are identical.");
4142 lease_dereference (&hw_lease,
MDL);
4144 if (ip_lease && ip_lease == hw_lease) {
4145 lease_dereference (&hw_lease,
MDL);
4146 #if defined (DEBUG_FIND_LEASE) 4147 log_info (
"hardware lease and ip lease are identical.");
4150 if (ip_lease && ip_lease == uid_lease) {
4151 lease_dereference (&uid_lease,
MDL);
4152 #if defined (DEBUG_FIND_LEASE) 4153 log_info (
"uid lease and ip lease are identical.");
4167 lease_dereference (&ip_lease,
MDL);
4175 if (!packet -> raw -> ciaddr.s_addr)
4177 lease_dereference (&uid_lease,
MDL);
4185 if (!packet -> raw -> ciaddr.s_addr)
4187 lease_dereference (&hw_lease,
MDL);
4194 strcpy (dhcp_message,
"requested address not available");
4201 !ip_lease && !fixed_lease) {
4202 #if defined (DEBUG_FIND_LEASE) 4203 log_info (
"no applicable lease found for DHCPREQUEST.");
4211 lease_reference (&lease, fixed_lease,
MDL);
4212 lease_dereference (&fixed_lease,
MDL);
4213 #if defined (DEBUG_FIND_LEASE) 4214 log_info (
"choosing fixed address.");
4222 if (!packet -> raw -> ciaddr.s_addr)
4224 #if defined (DEBUG_FIND_LEASE) 4225 log_info (
"not choosing requested address (!).");
4228 #if defined (DEBUG_FIND_LEASE) 4229 log_info (
"choosing lease on requested address.");
4231 lease_reference (&lease, ip_lease,
MDL);
4233 host_dereference (&lease -> host,
MDL);
4235 lease_dereference (&ip_lease,
MDL);
4243 log_error(
"uid lease %s for client %s is duplicate " 4249 if (!packet -> raw -> ciaddr.s_addr &&
4253 #if defined (DEBUG_FIND_LEASE) 4254 log_info (
"not choosing uid lease.");
4257 lease_reference (&lease, uid_lease,
MDL);
4259 host_dereference (&lease -> host,
MDL);
4260 #if defined (DEBUG_FIND_LEASE) 4264 lease_dereference (&uid_lease,
MDL);
4270 #if defined (DEBUG_FIND_LEASE) 4271 log_info (
"not choosing hardware lease.");
4278 if (!hw_lease -> uid_len ||
4279 (have_client_identifier
4280 ? (hw_lease -> uid_len ==
4281 client_identifier.
len &&
4282 !memcmp (hw_lease -> uid,
4283 client_identifier.
data,
4284 client_identifier.
len))
4285 : packet -> packet_type == 0)) {
4286 lease_reference (&lease, hw_lease,
MDL);
4288 host_dereference (&lease -> host,
MDL);
4289 #if defined (DEBUG_FIND_LEASE) 4290 log_info (
"choosing hardware lease.");
4293 #if defined (DEBUG_FIND_LEASE) 4294 log_info (
"not choosing hardware lease: %s.",
4299 lease_dereference (&hw_lease,
MDL);
4308 if (lease && host && !lease->
host) {
4312 host_reference(&p, host,
MDL);
4331 host_reference(&lease->
host, p,
MDL);
4333 host_dereference(&p,
MDL);
4338 host_dereference(&p,
MDL);
4340 host_reference(&p, n,
MDL);
4341 host_dereference(&n,
MDL);
4352 lease == ip_lease &&
4354 log_error (
"Reclaiming REQUESTed abandoned IP address %s.",
4356 }
else if (lease && (lease -> binding_state ==
FTS_ABANDONED)) {
4363 lease_dereference (&lease,
MDL);
4367 if (have_client_identifier)
4371 lease_dereference (&fixed_lease,
MDL);
4373 lease_dereference (&hw_lease,
MDL);
4375 lease_dereference (&uid_lease,
MDL);
4377 lease_dereference (&ip_lease,
MDL);
4379 host_dereference (&host,
MDL);
4382 #if defined (DEBUG_FIND_LEASE) 4386 lease_reference (lp, lease, file, line);
4387 lease_dereference (&lease,
MDL);
4390 #if defined (DEBUG_FIND_LEASE) 4391 log_info (
"Not returning a lease.");
4406 struct lease *lease = (
struct lease *)0;
4409 if (lease_allocate (&lease,
MDL) != ISC_R_SUCCESS)
4411 if (host_reference (&rhp, hp,
MDL) != ISC_R_SUCCESS) {
4412 lease_dereference (&lease,
MDL);
4416 &rhp, &lease ->
ip_addr, share)) {
4417 lease_dereference (&lease,
MDL);
4418 host_dereference (&rhp,
MDL);
4421 host_reference (&lease -> host, rhp,
MDL);
4425 lease -> uid = lease -> uid_buf;
4426 if (!lease -> uid) {
4427 lease_dereference (&lease,
MDL);
4428 host_dereference (&rhp,
MDL);
4434 lease -> hardware_addr = rhp ->
interface;
4435 lease -> starts = lease -> cltt = lease -> ends =
MIN_TIME;
4439 lease_reference (lp, lease,
MDL);
4441 lease_dereference (&lease,
MDL);
4442 host_dereference (&rhp,
MDL);
4454 struct pool *
pool,
int *peer_has_leases)
4456 struct lease *lease = (
struct lease *)0;
4457 struct lease *candl = (
struct lease *)0;
4459 for (;
pool ; pool = pool ->
next) {
4460 if ((pool -> prohibit_list &&
4461 permitted (packet, pool -> prohibit_list)) ||
4462 (pool -> permit_list &&
4463 !
permitted (packet, pool -> permit_list)))
4466 #if defined (FAILOVER_PROTOCOL) 4491 if (pool->
backup != NULL) {
4492 if (((candl == NULL) ||
4499 *peer_has_leases = 1;
4505 if (pool->
free != NULL) {
4506 if (((candl == NULL) ||
4513 *peer_has_leases = 1;
4519 if ((candl == NULL) &&
4527 candl = pool -> free;
4529 candl = pool -> abandoned;
4563 (candl -> ends < lease ->
ends))) {
4571 (candl -> ends < lease -> ends))) {
4577 if (candl -> ends < lease -> ends)
4581 if (lease != NULL) {
4583 log_error(
"Reclaiming abandoned lease %s.",
4591 if (lease->
host != NULL) {
4592 log_debug(
"soft impossible condition (%s:%d): stale " 4593 "host \"%s\" found on lease %s",
MDL,
4596 host_dereference(&lease->
host,
MDL);
4599 lease_reference (lp, lease,
MDL);
4611 struct packet *packet;
4612 struct permit *permit_list;
4617 for (p = permit_list; p; p = p ->
next) {
4618 switch (p ->
type) {
4620 if (!packet -> known)
4625 if (packet -> known)
4630 if (packet -> authenticated)
4635 if (!packet -> authenticated)
4643 if (!packet -> options_valid ||
4644 !packet -> packet_type)
4650 if (p ->
class == packet -> classes [i])
4652 if (packet -> classes [i] &&
4653 packet -> classes [i] -> superclass &&
4654 (packet -> classes [i] -> superclass ==
4670 struct packet *packet;
4674 struct subnet *subnet = (
struct subnet *)0;
4690 if (!oc && !packet -> raw ->
giaddr.s_addr) {
4692 struct in_addr any_addr;
4693 any_addr.s_addr = INADDR_ANY;
4695 if (!packet -> packet_type && memcmp(&packet -> raw -> ciaddr, &any_addr, 4)) {
4697 memcpy(cip.
iabuf, &packet -> raw -> ciaddr, 4);
4716 memset (&data, 0,
sizeof data);
4724 if (data.
len != 4) {
4742 subnet_dereference (&subnet,
MDL);
4787 struct packet *packet) {
4788 unsigned option_num;
4791 struct in_addr *a = NULL;
4792 isc_boolean_t found = ISC_FALSE;
4795 memset(&d, 0,
sizeof(d));
4796 memset(from, 0,
sizeof(*from));
4804 if (d.
len ==
sizeof(*from)) {
4806 memcpy(from, d.
data,
sizeof(*from));
4812 if ((out_options != NULL) &&
4813 (options != out_options)) {
4823 if ((found == ISC_FALSE) &&
4827 if (out_options != NULL) {
4835 (
unsigned char *)a,
sizeof(*a),
4836 0, allocate,
MDL)) {
4837 option_code_hash_lookup(&oc->
option,
4839 &option_num, 0,
MDL);
4864 struct packet *packet) {
4909 if (sid_options != NULL)
4924 find_min_site_code(
struct universe *u)
4935 option_code_hash_foreach(u->
code_hash, lowest_site_code);
4938 log_error(
"WARNING: site-local option codes less than 224 have " 4939 "been deprecated by RFC3942. You have options " 4940 "listed in site local space %s that number as low as " 4941 "%d. Please investigate if these should be declared " 4942 "as regular options rather than site-local options, " 4943 "or migrated up past 224.",
4965 lowest_site_code(
const void *key,
unsigned len,
void *
object)
4969 if (option->
code < site_code_min)
4970 site_code_min = option->
code;
4972 return ISC_R_SUCCESS;
4976 maybe_return_agent_options(
struct packet *packet,
struct option_state *options)
#define DHCPD_DISCOVER_START()
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)
#define DHCPD_NAK_LEASE_START()
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 DHCPD_ACK_LEASE_DONE()
int unbill_class(struct lease *lease, struct class *class)
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 DHCPD_ACK_LEASE_START()
#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)
struct leasequeue * ackqueue_head
struct option_cache * fixed_addr
struct class * billing_class
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 flush_ackqueue(void *foo)
void(* tvref_t)(void *, void *, const char *, int)
const char * binding_state_print(enum failover_state state)
struct option_state * options
#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 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
void nak_lease(struct packet *packet, struct iaddr *cip)
#define DEFAULT_MAX_LEASE_TIME
struct class * classes[PACKET_MAX_CLASSES]
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_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)
#define DHCPD_INFORM_START()
#define DEFAULT_DEFAULT_LEASE_TIME
#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)
#define DHCPD_DECLINE_START()
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 leasequeue * ackqueue_tail
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)
struct in_addr limited_broadcast
int supersede_lease(struct lease *, struct lease *, int, int, int)
int int log_info(const char *,...) __attribute__((__format__(__printf__
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 DHCPD_FIND_LEASE_START()
#define DHO_DHCP_MAX_MESSAGE_SIZE
#define DHCPD_RELEASE_START()
struct universe ** universes
void setup_server_source_address(struct in_addr *from, struct option_state *options, struct packet *packet)
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
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
int db_printable(const unsigned char *)
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 DHCPD_DISCOVER_DONE()
#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 DHCPD_REPLY_DONE()
#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
#define DHCPD_DECLINE_DONE()
u_int8_t hbuf[HARDWARE_ADDR_LEN+1]
#define DHCPD_RELEASE_DONE()
int icmp_echorequest(struct iaddr *addr)
#define DHO_VENDOR_CLASS_IDENTIFIER
struct universe agent_universe
void delayed_ack_enqueue(struct lease *lease)
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
#define DHO_DHCP_CLIENT_IDENTIFIER
struct permit * permit_list
struct data_string filename server_name
#define DHCPD_REQUEST_DONE()
int can_unicast_without_arp(struct interface_info *)
struct lease_state * new_lease_state(const char *, int)
int bill_class(struct lease *, struct class *)
struct executable_statement * on_commit
const unsigned char * data
#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 DHCPD_REQUEST_START()
#define SV_STASH_AGENT_OPTIONS
binding_state_t next_binding_state
#define DHCPD_NAK_LEASE_DONE()
void classify_client(struct packet *)
#define DHCPD_FIND_LEASE_DONE()
#define DHCPD_REPLY_START()
int lease_mine_to_reallocate(struct lease *)
#define DHO_DHCP_REQUESTED_ADDRESS
#define SV_RESERVE_INFINITE