version 1.1, 2013/07/29 19:37:40
|
version 1.1.1.2, 2014/06/15 16:31:38
|
Line 1
|
Line 1
|
/* dnsmasq is Copyright (c) 2000-2013 Simon Kelley | /* dnsmasq is Copyright (c) 2000-2014 Simon Kelley |
|
|
This program is free software; you can redistribute it and/or modify |
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
it under the terms of the GNU General Public License as published by |
Line 21
|
Line 21
|
|
|
struct state { |
struct state { |
unsigned char *clid; |
unsigned char *clid; |
int clid_len, iaid, ia_type, interface, hostname_auth; | int clid_len, iaid, ia_type, interface, hostname_auth, lease_allocate; |
char *client_hostname, *hostname, *domain, *send_domain; |
char *client_hostname, *hostname, *domain, *send_domain; |
struct dhcp_context *context; |
struct dhcp_context *context; |
struct in6_addr *link_address; | struct in6_addr *link_address, *fallback, *ll_addr, *ula_addr; |
unsigned int xid, fqdn_flags; |
unsigned int xid, fqdn_flags; |
char *iface_name; |
char *iface_name; |
void *packet_options, *end; |
void *packet_options, *end; |
struct dhcp_netid *tags, *context_tags; |
struct dhcp_netid *tags, *context_tags; |
|
unsigned char mac[DHCP_CHADDR_MAX]; |
|
unsigned int mac_len, mac_type; |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
struct prefix_class *send_prefix_class; |
struct prefix_class *send_prefix_class; |
#endif |
#endif |
}; |
}; |
|
|
static int dhcp6_maybe_relay(struct in6_addr *link_address, struct dhcp_netid **relay_tagsp, struct dhcp_context *context, | static int dhcp6_maybe_relay(struct state *state, void *inbuff, size_t sz, |
int interface, char *iface_name, struct in6_addr *fallback, void *inbuff, size_t sz, int is_unicast, time_t now); | struct in6_addr *client_addr, int is_unicast, time_t now); |
static int dhcp6_no_relay(int msg_type, struct in6_addr *link_address, struct dhcp_netid *tags, struct dhcp_context *context, | static int dhcp6_no_relay(struct state *state, int msg_type, void *inbuff, size_t sz, int is_unicast, time_t now); |
int interface, char *iface_name, struct in6_addr *fallback, void *inbuff, size_t sz, int is_unicast, time_t now); | |
static void log6_opts(int nest, unsigned int xid, void *start_opts, void *end_opts); |
static void log6_opts(int nest, unsigned int xid, void *start_opts, void *end_opts); |
static void log6_packet(struct state *state, char *type, struct in6_addr *addr, char *string); |
static void log6_packet(struct state *state, char *type, struct in6_addr *addr, char *string); |
| static void log6_quiet(struct state *state, char *type, struct in6_addr *addr, char *string); |
static void *opt6_find (void *opts, void *end, unsigned int search, unsigned int minsize); |
static void *opt6_find (void *opts, void *end, unsigned int search, unsigned int minsize); |
static void *opt6_next(void *opts, void *end); |
static void *opt6_next(void *opts, void *end); |
static unsigned int opt6_uint(unsigned char *opt, int offset, int size); |
static unsigned int opt6_uint(unsigned char *opt, int offset, int size); |
Line 51 static void end_ia(int t1cntr, unsigned int min_time,
|
Line 52 static void end_ia(int t1cntr, unsigned int min_time,
|
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
static struct prefix_class *prefix_class_from_context(struct dhcp_context *context); |
static struct prefix_class *prefix_class_from_context(struct dhcp_context *context); |
#endif |
#endif |
static void mark_context_used(struct state *state, struct dhcp_context *context, struct in6_addr *addr); | static void mark_context_used(struct state *state, struct in6_addr *addr); |
static void mark_config_used(struct dhcp_context *context, struct in6_addr *addr); |
static void mark_config_used(struct dhcp_context *context, struct in6_addr *addr); |
static int check_address(struct state *state, struct in6_addr *addr); |
static int check_address(struct state *state, struct in6_addr *addr); |
static void add_address(struct state *state, struct dhcp_context *context, unsigned int lease_time, unsigned int requested_time, | static void add_address(struct state *state, struct dhcp_context *context, unsigned int lease_time, void *ia_option, |
unsigned int *min_time, struct in6_addr *addr, int update_lease, time_t now); | unsigned int *min_time, struct in6_addr *addr, time_t now); |
static void update_leases(struct state *state, struct dhcp_context *context, struct in6_addr *addr, unsigned int lease_time, time_t now); |
static void update_leases(struct state *state, struct dhcp_context *context, struct in6_addr *addr, unsigned int lease_time, time_t now); |
static int add_local_addrs(struct dhcp_context *context); |
static int add_local_addrs(struct dhcp_context *context); |
struct dhcp_netid *add_options(struct state *state, struct in6_addr *fallback, struct dhcp_context *context); | static struct dhcp_netid *add_options(struct state *state, int do_refresh); |
static void calculate_times(struct dhcp_context *context, unsigned int *min_time, unsigned int *valid_timep, |
static void calculate_times(struct dhcp_context *context, unsigned int *min_time, unsigned int *valid_timep, |
unsigned int *preferred_timep, unsigned int lease_time, unsigned int requested_time); | unsigned int *preferred_timep, unsigned int lease_time); |
|
|
#define opt6_len(opt) ((int)(opt6_uint(opt, -2, 2))) |
#define opt6_len(opt) ((int)(opt6_uint(opt, -2, 2))) |
#define opt6_type(opt) (opt6_uint(opt, -4, 2)) |
#define opt6_type(opt) (opt6_uint(opt, -4, 2)) |
#define opt6_ptr(opt, i) ((void *)&(((unsigned char *)(opt))[4+(i)])) |
#define opt6_ptr(opt, i) ((void *)&(((unsigned char *)(opt))[4+(i)])) |
|
|
|
#define opt6_user_vendor_ptr(opt, i) ((void *)&(((unsigned char *)(opt))[2+(i)])) |
|
#define opt6_user_vendor_len(opt) ((int)(opt6_uint(opt, -4, 2))) |
|
#define opt6_user_vendor_next(opt, end) (opt6_next(((void *) opt) - 2, end)) |
|
|
|
|
unsigned short dhcp6_reply(struct dhcp_context *context, int interface, char *iface_name, |
unsigned short dhcp6_reply(struct dhcp_context *context, int interface, char *iface_name, |
struct in6_addr *fallback, size_t sz, int is_unicast, time_t now) | struct in6_addr *fallback, struct in6_addr *ll_addr, struct in6_addr *ula_addr, |
| size_t sz, struct in6_addr *client_addr, time_t now) |
{ |
{ |
struct dhcp_netid *relay_tags = NULL; |
|
struct dhcp_vendor *vendor; |
struct dhcp_vendor *vendor; |
int msg_type; |
int msg_type; |
|
struct state state; |
|
|
if (sz <= 4) |
if (sz <= 4) |
return 0; |
return 0; |
Line 84 unsigned short dhcp6_reply(struct dhcp_context *contex
|
Line 90 unsigned short dhcp6_reply(struct dhcp_context *contex
|
vendor->netid.next = &vendor->netid; |
vendor->netid.next = &vendor->netid; |
|
|
save_counter(0); |
save_counter(0); |
| state.context = context; |
if (dhcp6_maybe_relay(NULL, &relay_tags, context, interface, iface_name, fallback, daemon->dhcp_packet.iov_base, sz, is_unicast, now)) | state.interface = interface; |
| state.iface_name = iface_name; |
| state.fallback = fallback; |
| state.ll_addr = ll_addr; |
| state.ula_addr = ula_addr; |
| state.mac_len = 0; |
| state.tags = NULL; |
| state.link_address = NULL; |
| |
| if (dhcp6_maybe_relay(&state, daemon->dhcp_packet.iov_base, sz, client_addr, |
| IN6_IS_ADDR_MULTICAST(client_addr), now)) |
return msg_type == DHCP6RELAYFORW ? DHCPV6_SERVER_PORT : DHCPV6_CLIENT_PORT; |
return msg_type == DHCP6RELAYFORW ? DHCPV6_SERVER_PORT : DHCPV6_CLIENT_PORT; |
|
|
return 0; |
return 0; |
} |
} |
|
|
/* This cost me blood to write, it will probably cost you blood to understand - srk. */ |
/* This cost me blood to write, it will probably cost you blood to understand - srk. */ |
static int dhcp6_maybe_relay(struct in6_addr *link_address, struct dhcp_netid **relay_tagsp, struct dhcp_context *context, | static int dhcp6_maybe_relay(struct state *state, void *inbuff, size_t sz, |
int interface, char *iface_name, struct in6_addr *fallback, void *inbuff, size_t sz, int is_unicast, time_t now) | struct in6_addr *client_addr, int is_unicast, time_t now) |
{ |
{ |
void *end = inbuff + sz; |
void *end = inbuff + sz; |
void *opts = inbuff + 34; |
void *opts = inbuff + 34; |
Line 108 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
Line 124 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
/* if link_address != NULL if points to the link address field of the |
/* if link_address != NULL if points to the link address field of the |
innermost nested RELAYFORW message, which is where we find the |
innermost nested RELAYFORW message, which is where we find the |
address of the network on which we can allocate an address. |
address of the network on which we can allocate an address. |
Recalculate the available contexts using that information. */ | Recalculate the available contexts using that information. |
| |
| link_address == NULL means there's no relay in use, so we try and find the client's |
| MAC address from the local ND cache. */ |
|
|
if (link_address) | if (!state->link_address) |
| get_client_mac(client_addr, state->interface, state->mac, &state->mac_len, &state->mac_type); |
| else |
{ |
{ |
struct dhcp_context *c; |
struct dhcp_context *c; |
context = NULL; | state->context = NULL; |
|
|
if (!IN6_IS_ADDR_LOOPBACK(link_address) && | if (!IN6_IS_ADDR_LOOPBACK(state->link_address) && |
!IN6_IS_ADDR_LINKLOCAL(link_address) && | !IN6_IS_ADDR_LINKLOCAL(state->link_address) && |
!IN6_IS_ADDR_MULTICAST(link_address)) | !IN6_IS_ADDR_MULTICAST(state->link_address)) |
for (c = daemon->dhcp6; c; c = c->next) |
for (c = daemon->dhcp6; c; c = c->next) |
if ((c->flags & CONTEXT_DHCP) && |
if ((c->flags & CONTEXT_DHCP) && |
!(c->flags & CONTEXT_TEMPLATE) && | !(c->flags & (CONTEXT_TEMPLATE | CONTEXT_OLD)) && |
is_same_net6(link_address, &c->start6, c->prefix) && | is_same_net6(state->link_address, &c->start6, c->prefix) && |
is_same_net6(link_address, &c->end6, c->prefix)) | is_same_net6(state->link_address, &c->end6, c->prefix)) |
{ |
{ |
c->preferred = c->valid = 0xffffffff; |
c->preferred = c->valid = 0xffffffff; |
c->current = context; | c->current = state->context; |
context = c; | state->context = c; |
} |
} |
|
|
if (!context) | if (!state->context) |
{ |
{ |
inet_ntop(AF_INET6, link_address, daemon->addrbuff, ADDRSTRLEN); | inet_ntop(AF_INET6, state->link_address, daemon->addrbuff, ADDRSTRLEN); |
my_syslog(MS_DHCP | LOG_WARNING, |
my_syslog(MS_DHCP | LOG_WARNING, |
_("no address range available for DHCPv6 request from relay at %s"), |
_("no address range available for DHCPv6 request from relay at %s"), |
daemon->addrbuff); |
daemon->addrbuff); |
return 0; |
return 0; |
} |
} |
} |
} |
| |
if (!context) | if (!state->context) |
{ |
{ |
my_syslog(MS_DHCP | LOG_WARNING, |
my_syslog(MS_DHCP | LOG_WARNING, |
_("no address range available for DHCPv6 request via %s"), iface_name); | _("no address range available for DHCPv6 request via %s"), state->iface_name); |
return 0; |
return 0; |
} |
} |
|
|
return dhcp6_no_relay(msg_type, link_address, *relay_tagsp, context, interface, iface_name, fallback, inbuff, sz, is_unicast, now); | return dhcp6_no_relay(state, msg_type, inbuff, sz, is_unicast, now); |
} |
} |
|
|
/* must have at least msg_type+hopcount+link_address+peer_address+minimal size option |
/* must have at least msg_type+hopcount+link_address+peer_address+minimal size option |
Line 155 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
Line 176 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
return 0; |
return 0; |
|
|
/* copy header stuff into reply message and set type to reply */ |
/* copy header stuff into reply message and set type to reply */ |
outmsgtypep = put_opt6(inbuff, 34); | if (!(outmsgtypep = put_opt6(inbuff, 34))) |
| return 0; |
*outmsgtypep = DHCP6RELAYREPL; |
*outmsgtypep = DHCP6RELAYREPL; |
|
|
/* look for relay options and set tags if found. */ |
/* look for relay options and set tags if found. */ |
Line 175 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
Line 197 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
memcmp(vendor->data, opt6_ptr(opt, 0), vendor->len) == 0 && |
memcmp(vendor->data, opt6_ptr(opt, 0), vendor->len) == 0 && |
vendor->netid.next != &vendor->netid) |
vendor->netid.next != &vendor->netid) |
{ |
{ |
vendor->netid.next = *relay_tagsp; | vendor->netid.next = state->tags; |
*relay_tagsp = &vendor->netid; | state->tags = &vendor->netid; |
break; |
break; |
} |
} |
} |
} |
|
|
|
/* RFC-6939 */ |
|
if ((opt = opt6_find(opts, end, OPTION6_CLIENT_MAC, 3))) |
|
{ |
|
state->mac_type = opt6_uint(opt, 0, 2); |
|
state->mac_len = opt6_len(opt) - 2; |
|
memcpy(&state->mac[0], opt6_ptr(opt, 2), state->mac_len); |
|
} |
|
|
for (opt = opts; opt; opt = opt6_next(opt, end)) |
for (opt = opts; opt; opt = opt6_next(opt, end)) |
{ |
{ |
int o = new_opt6(opt6_type(opt)); |
int o = new_opt6(opt6_type(opt)); |
if (opt6_type(opt) == OPTION6_RELAY_MSG) |
if (opt6_type(opt) == OPTION6_RELAY_MSG) |
{ |
{ |
struct in6_addr link_address; | struct in6_addr align; |
/* the packet data is unaligned, copy to aligned storage */ |
/* the packet data is unaligned, copy to aligned storage */ |
memcpy(&link_address, inbuff + 2, IN6ADDRSZ); | memcpy(&align, inbuff + 2, IN6ADDRSZ); |
/* Not, zero is_unicast since that is now known to refer to the | state->link_address = &align; |
| /* zero is_unicast since that is now known to refer to the |
relayed packet, not the original sent by the client */ |
relayed packet, not the original sent by the client */ |
if (!dhcp6_maybe_relay(&link_address, relay_tagsp, context, interface, iface_name, fallback, opt6_ptr(opt, 0), opt6_len(opt), 0, now)) | if (!dhcp6_maybe_relay(state, opt6_ptr(opt, 0), opt6_len(opt), client_addr, 0, now)) |
return 0; |
return 0; |
} |
} |
else | else if (opt6_type(opt) != OPTION6_CLIENT_MAC) |
put_opt6(opt6_ptr(opt, 0), opt6_len(opt)); |
put_opt6(opt6_ptr(opt, 0), opt6_len(opt)); |
end_opt6(o); |
end_opt6(o); |
} |
} |
Line 202 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
Line 233 static int dhcp6_maybe_relay(struct in6_addr *link_add
|
return 1; |
return 1; |
} |
} |
|
|
static int dhcp6_no_relay(int msg_type, struct in6_addr *link_address, struct dhcp_netid *tags, struct dhcp_context *context, | static int dhcp6_no_relay(struct state *state, int msg_type, void *inbuff, size_t sz, int is_unicast, time_t now) |
int interface, char *iface_name, struct in6_addr *fallback, void *inbuff, size_t sz, int is_unicast, time_t now) | |
{ |
{ |
void *opt; |
void *opt; |
int i, o, o1, start_opts; |
int i, o, o1, start_opts; |
Line 214 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 244 static int dhcp6_no_relay(int msg_type, struct in6_add
|
unsigned char *outmsgtypep; |
unsigned char *outmsgtypep; |
struct dhcp_vendor *vendor; |
struct dhcp_vendor *vendor; |
struct dhcp_context *context_tmp; |
struct dhcp_context *context_tmp; |
|
struct dhcp_mac *mac_opt; |
unsigned int ignore = 0; |
unsigned int ignore = 0; |
struct state state; |
|
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
struct prefix_class *p; |
struct prefix_class *p; |
int dump_all_prefix_classes = 0; |
int dump_all_prefix_classes = 0; |
#endif |
#endif |
|
|
state.packet_options = inbuff + 4; | state->packet_options = inbuff + 4; |
state.end = inbuff + sz; | state->end = inbuff + sz; |
state.clid = NULL; | state->clid = NULL; |
state.clid_len = 0; | state->clid_len = 0; |
state.context_tags = NULL; | state->lease_allocate = 0; |
state.tags = tags; | state->context_tags = NULL; |
state.link_address = link_address; | state->domain = NULL; |
state.interface = interface; | state->send_domain = NULL; |
state.domain = NULL; | state->hostname_auth = 0; |
state.send_domain = NULL; | state->hostname = NULL; |
state.context = context; | state->client_hostname = NULL; |
state.hostname_auth = 0; | state->fqdn_flags = 0x01; /* default to send if we recieve no FQDN option */ |
state.hostname = NULL; | |
state.client_hostname = NULL; | |
state.iface_name = iface_name; | |
state.fqdn_flags = 0x01; /* default to send if we recieve no FQDN option */ | |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
state.send_prefix_class = NULL; | state->send_prefix_class = NULL; |
#endif |
#endif |
|
|
/* set tag with name == interface */ |
/* set tag with name == interface */ |
iface_id.net = iface_name; | iface_id.net = state->iface_name; |
iface_id.next = state.tags; | iface_id.next = state->tags; |
state.tags = &iface_id; | state->tags = &iface_id; |
|
|
/* set tag "dhcpv6" */ |
/* set tag "dhcpv6" */ |
v6_id.net = "dhcpv6"; |
v6_id.net = "dhcpv6"; |
v6_id.next = state.tags; | v6_id.next = state->tags; |
state.tags = &v6_id; | state->tags = &v6_id; |
|
|
/* copy over transaction-id, and save pointer to message type */ |
/* copy over transaction-id, and save pointer to message type */ |
outmsgtypep = put_opt6(inbuff, 4); | if (!(outmsgtypep = put_opt6(inbuff, 4))) |
| return 0; |
start_opts = save_counter(-1); |
start_opts = save_counter(-1); |
state.xid = outmsgtypep[3] | outmsgtypep[2] << 8 | outmsgtypep[1] << 16; | state->xid = outmsgtypep[3] | outmsgtypep[2] << 8 | outmsgtypep[1] << 16; |
|
|
/* We're going to be linking tags from all context we use. |
/* We're going to be linking tags from all context we use. |
mark them as unused so we don't link one twice and break the list */ |
mark them as unused so we don't link one twice and break the list */ |
for (context_tmp = context; context_tmp; context_tmp = context_tmp->current) | for (context_tmp = state->context; context_tmp; context_tmp = context_tmp->current) |
{ |
{ |
context->netid.next = &context->netid; | context_tmp->netid.next = &context_tmp->netid; |
|
|
if (option_bool(OPT_LOG_OPTS)) |
if (option_bool(OPT_LOG_OPTS)) |
{ |
{ |
Line 268 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 295 static int dhcp6_no_relay(int msg_type, struct in6_add
|
inet_ntop(AF_INET6, &context_tmp->end6, daemon->dhcp_buff2, ADDRSTRLEN); |
inet_ntop(AF_INET6, &context_tmp->end6, daemon->dhcp_buff2, ADDRSTRLEN); |
if (context_tmp->flags & (CONTEXT_STATIC)) |
if (context_tmp->flags & (CONTEXT_STATIC)) |
my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCPv6 subnet: %s/%d"), |
my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCPv6 subnet: %s/%d"), |
state.xid, daemon->dhcp_buff, context_tmp->prefix); | state->xid, daemon->dhcp_buff, context_tmp->prefix); |
else |
else |
my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCP range: %s -- %s"), |
my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCP range: %s -- %s"), |
state.xid, daemon->dhcp_buff, daemon->dhcp_buff2); | state->xid, daemon->dhcp_buff, daemon->dhcp_buff2); |
} |
} |
} |
} |
|
|
if ((opt = opt6_find(state.packet_options, state.end, OPTION6_CLIENT_ID, 1))) | if ((opt = opt6_find(state->packet_options, state->end, OPTION6_CLIENT_ID, 1))) |
{ |
{ |
state.clid = opt6_ptr(opt, 0); | state->clid = opt6_ptr(opt, 0); |
state.clid_len = opt6_len(opt); | state->clid_len = opt6_len(opt); |
o = new_opt6(OPTION6_CLIENT_ID); |
o = new_opt6(OPTION6_CLIENT_ID); |
put_opt6(state.clid, state.clid_len); | put_opt6(state->clid, state->clid_len); |
end_opt6(o); |
end_opt6(o); |
} |
} |
else if (msg_type != DHCP6IREQ) |
else if (msg_type != DHCP6IREQ) |
Line 288 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 315 static int dhcp6_no_relay(int msg_type, struct in6_add
|
|
|
/* server-id must match except for SOLICIT and CONFIRM messages */ |
/* server-id must match except for SOLICIT and CONFIRM messages */ |
if (msg_type != DHCP6SOLICIT && msg_type != DHCP6CONFIRM && msg_type != DHCP6IREQ && |
if (msg_type != DHCP6SOLICIT && msg_type != DHCP6CONFIRM && msg_type != DHCP6IREQ && |
(!(opt = opt6_find(state.packet_options, state.end, OPTION6_SERVER_ID, 1)) || | (!(opt = opt6_find(state->packet_options, state->end, OPTION6_SERVER_ID, 1)) || |
opt6_len(opt) != daemon->duid_len || |
opt6_len(opt) != daemon->duid_len || |
memcmp(opt6_ptr(opt, 0), daemon->duid, daemon->duid_len) != 0)) |
memcmp(opt6_ptr(opt, 0), daemon->duid, daemon->duid_len) != 0)) |
return 0; |
return 0; |
Line 320 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 347 static int dhcp6_no_relay(int msg_type, struct in6_add
|
else |
else |
continue; |
continue; |
|
|
if ((opt = opt6_find(state.packet_options, state.end, mopt, 2))) | if ((opt = opt6_find(state->packet_options, state->end, mopt, 2))) |
{ |
{ |
void *enc_opt, *enc_end = opt6_ptr(opt, opt6_len(opt)); |
void *enc_opt, *enc_end = opt6_ptr(opt, opt6_len(opt)); |
int offset = 0; |
int offset = 0; |
Line 336 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 363 static int dhcp6_no_relay(int msg_type, struct in6_add
|
offset = 4; |
offset = 4; |
} |
} |
|
|
for (enc_opt = opt6_ptr(opt, offset); enc_opt; enc_opt = opt6_next(enc_opt, enc_end)) | /* Note that format if user/vendor classes is different to DHCP options - no option types. */ |
for (i = 0; i <= (opt6_len(enc_opt) - vendor->len); i++) | for (enc_opt = opt6_ptr(opt, offset); enc_opt; enc_opt = opt6_user_vendor_next(enc_opt, enc_end)) |
if (memcmp(vendor->data, opt6_ptr(enc_opt, i), vendor->len) == 0) | for (i = 0; i <= (opt6_user_vendor_len(enc_opt) - vendor->len); i++) |
| if (memcmp(vendor->data, opt6_user_vendor_ptr(enc_opt, i), vendor->len) == 0) |
{ |
{ |
vendor->netid.next = state.tags; | vendor->netid.next = state->tags; |
state.tags = &vendor->netid; | state->tags = &vendor->netid; |
break; |
break; |
} |
} |
} |
} |
} |
} |
|
|
if (option_bool(OPT_LOG_OPTS) && (opt = opt6_find(state.packet_options, state.end, OPTION6_VENDOR_CLASS, 4))) | if (option_bool(OPT_LOG_OPTS) && (opt = opt6_find(state->packet_options, state->end, OPTION6_VENDOR_CLASS, 4))) |
my_syslog(MS_DHCP | LOG_INFO, _("%u vendor class: %u"), state.xid, opt6_uint(opt, 0, 4)); | my_syslog(MS_DHCP | LOG_INFO, _("%u vendor class: %u"), state->xid, opt6_uint(opt, 0, 4)); |
|
|
/* dhcp-match. If we have hex-and-wildcards, look for a left-anchored match. |
/* dhcp-match. If we have hex-and-wildcards, look for a left-anchored match. |
Otherwise assume the option is an array, and look for a matching element. |
Otherwise assume the option is an array, and look for a matching element. |
Line 360 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 388 static int dhcp6_no_relay(int msg_type, struct in6_add
|
|
|
if (opt_cfg->flags & DHOPT_RFC3925) |
if (opt_cfg->flags & DHOPT_RFC3925) |
{ |
{ |
for (opt = opt6_find(state.packet_options, state.end, OPTION6_VENDOR_OPTS, 4); | for (opt = opt6_find(state->packet_options, state->end, OPTION6_VENDOR_OPTS, 4); |
opt; |
opt; |
opt = opt6_find(opt6_next(opt, state.end), state.end, OPTION6_VENDOR_OPTS, 4)) | opt = opt6_find(opt6_next(opt, state->end), state->end, OPTION6_VENDOR_OPTS, 4)) |
{ |
{ |
void *vopt; |
void *vopt; |
void *vend = opt6_ptr(opt, opt6_len(opt)); |
void *vend = opt6_ptr(opt, opt6_len(opt)); |
Line 378 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 406 static int dhcp6_no_relay(int msg_type, struct in6_add
|
} |
} |
else |
else |
{ |
{ |
if (!(opt = opt6_find(state.packet_options, state.end, opt_cfg->opt, 1))) | if (!(opt = opt6_find(state->packet_options, state->end, opt_cfg->opt, 1))) |
continue; |
continue; |
|
|
match = match_bytes(opt_cfg, opt6_ptr(opt, 0), opt6_len(opt)); |
match = match_bytes(opt_cfg, opt6_ptr(opt, 0), opt6_len(opt)); |
Line 386 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 414 static int dhcp6_no_relay(int msg_type, struct in6_add
|
|
|
if (match) |
if (match) |
{ |
{ |
opt_cfg->netid->next = state.tags; | opt_cfg->netid->next = state->tags; |
state.tags = opt_cfg->netid; | state->tags = opt_cfg->netid; |
} |
} |
} |
} |
|
|
|
if (state->mac_len != 0) |
|
{ |
|
if (option_bool(OPT_LOG_OPTS)) |
|
{ |
|
print_mac(daemon->dhcp_buff, state->mac, state->mac_len); |
|
my_syslog(MS_DHCP | LOG_INFO, _("%u client MAC address: %s"), state->xid, daemon->dhcp_buff); |
|
} |
|
|
|
for (mac_opt = daemon->dhcp_macs; mac_opt; mac_opt = mac_opt->next) |
|
if ((unsigned)mac_opt->hwaddr_len == state->mac_len && |
|
((unsigned)mac_opt->hwaddr_type == state->mac_type || mac_opt->hwaddr_type == 0) && |
|
memcmp_masked(mac_opt->hwaddr, state->mac, state->mac_len, mac_opt->mask)) |
|
{ |
|
mac_opt->netid.next = state->tags; |
|
state->tags = &mac_opt->netid; |
|
} |
|
} |
|
|
if ((opt = opt6_find(state.packet_options, state.end, OPTION6_FQDN, 1))) | if ((opt = opt6_find(state->packet_options, state->end, OPTION6_FQDN, 1))) |
{ |
{ |
/* RFC4704 refers */ |
/* RFC4704 refers */ |
int len = opt6_len(opt) - 1; |
int len = opt6_len(opt) - 1; |
|
|
state.fqdn_flags = opt6_uint(opt, 0, 1); | state->fqdn_flags = opt6_uint(opt, 0, 1); |
|
|
/* Always force update, since the client has no way to do it itself. */ |
/* Always force update, since the client has no way to do it itself. */ |
if (!option_bool(OPT_FQDN_UPDATE) && !(state.fqdn_flags & 0x01)) | if (!option_bool(OPT_FQDN_UPDATE) && !(state->fqdn_flags & 0x01)) |
state.fqdn_flags |= 0x03; | state->fqdn_flags |= 0x03; |
|
|
state.fqdn_flags &= ~0x04; | state->fqdn_flags &= ~0x04; |
|
|
if (len != 0 && len < 255) |
if (len != 0 && len < 255) |
{ |
{ |
Line 424 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 470 static int dhcp6_no_relay(int msg_type, struct in6_add
|
|
|
if (legal_hostname(daemon->dhcp_buff)) |
if (legal_hostname(daemon->dhcp_buff)) |
{ |
{ |
state.client_hostname = daemon->dhcp_buff; | state->client_hostname = daemon->dhcp_buff; |
if (option_bool(OPT_LOG_OPTS)) |
if (option_bool(OPT_LOG_OPTS)) |
my_syslog(MS_DHCP | LOG_INFO, _("%u client provides name: %s"), state.xid, state.client_hostname); | my_syslog(MS_DHCP | LOG_INFO, _("%u client provides name: %s"), state->xid, state->client_hostname); |
} |
} |
} |
} |
} |
} |
|
|
if (state.clid) | if (state->clid) |
{ |
{ |
config = find_config6(daemon->dhcp_conf, context, state.clid, state.clid_len, NULL); | config = find_config(daemon->dhcp_conf, state->context, state->clid, state->clid_len, state->mac, state->mac_len, state->mac_type, NULL); |
|
|
if (have_config(config, CONFIG_NAME)) |
if (have_config(config, CONFIG_NAME)) |
{ |
{ |
state.hostname = config->hostname; | state->hostname = config->hostname; |
state.domain = config->domain; | state->domain = config->domain; |
state.hostname_auth = 1; | state->hostname_auth = 1; |
} |
} |
else if (state.client_hostname) | else if (state->client_hostname) |
{ |
{ |
state.domain = strip_hostname(state.client_hostname); | state->domain = strip_hostname(state->client_hostname); |
|
|
if (strlen(state.client_hostname) != 0) | if (strlen(state->client_hostname) != 0) |
{ |
{ |
state.hostname = state.client_hostname; | state->hostname = state->client_hostname; |
if (!config) |
if (!config) |
{ |
{ |
/* Search again now we have a hostname. |
/* Search again now we have a hostname. |
Only accept configs without CLID here, (it won't match) |
Only accept configs without CLID here, (it won't match) |
to avoid impersonation by name. */ |
to avoid impersonation by name. */ |
struct dhcp_config *new = find_config6(daemon->dhcp_conf, context, NULL, 0, state.hostname); | struct dhcp_config *new = find_config(daemon->dhcp_conf, state->context, NULL, 0, NULL, 0, 0, state->hostname); |
if (new && !have_config(new, CONFIG_CLID) && !new->hwaddr) |
if (new && !have_config(new, CONFIG_CLID) && !new->hwaddr) |
config = new; |
config = new; |
} |
} |
Line 467 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 513 static int dhcp6_no_relay(int msg_type, struct in6_add
|
|
|
for (list = config->netid; list; list = list->next) |
for (list = config->netid; list; list = list->next) |
{ |
{ |
list->list->next = state.tags; | list->list->next = state->tags; |
state.tags = list->list; | state->tags = list->list; |
} |
} |
|
|
/* set "known" tag for known hosts */ |
/* set "known" tag for known hosts */ |
known_id.net = "known"; |
known_id.net = "known"; |
known_id.next = state.tags; | known_id.next = state->tags; |
state.tags = &known_id; | state->tags = &known_id; |
|
|
if (have_config(config, CONFIG_DISABLE)) |
if (have_config(config, CONFIG_DISABLE)) |
ignore = 1; |
ignore = 1; |
Line 486 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 532 static int dhcp6_no_relay(int msg_type, struct in6_add
|
{ |
{ |
void *oro; |
void *oro; |
|
|
if ((oro = opt6_find(state.packet_options, state.end, OPTION6_ORO, 0))) | if ((oro = opt6_find(state->packet_options, state->end, OPTION6_ORO, 0))) |
for (i = 0; i < opt6_len(oro) - 1; i += 2) |
for (i = 0; i < opt6_len(oro) - 1; i += 2) |
if (opt6_uint(oro, i, 2) == OPTION6_PREFIX_CLASS) |
if (opt6_uint(oro, i, 2) == OPTION6_PREFIX_CLASS) |
{ |
{ |
Line 499 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 545 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Not done for SOLICIT as we add them one-at-time. */ |
Not done for SOLICIT as we add them one-at-time. */ |
for (p = daemon->prefix_classes; p ; p = p->next) |
for (p = daemon->prefix_classes; p ; p = p->next) |
{ |
{ |
p->tag.next = state.tags; | p->tag.next = state->tags; |
state.tags = &p->tag; | state->tags = &p->tag; |
} |
} |
} |
} |
#endif |
#endif |
|
|
tagif = run_tag_if(state.tags); | tagif = run_tag_if(state->tags); |
|
|
/* if all the netids in the ignore list are present, ignore this client */ |
/* if all the netids in the ignore list are present, ignore this client */ |
if (daemon->dhcp_ignore) |
if (daemon->dhcp_ignore) |
Line 518 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 564 static int dhcp6_no_relay(int msg_type, struct in6_add
|
} |
} |
|
|
/* if all the netids in the ignore_name list are present, ignore client-supplied name */ |
/* if all the netids in the ignore_name list are present, ignore client-supplied name */ |
if (!state.hostname_auth) | if (!state->hostname_auth) |
{ |
{ |
struct dhcp_netid_list *id_list; |
struct dhcp_netid_list *id_list; |
|
|
Line 526 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 572 static int dhcp6_no_relay(int msg_type, struct in6_add
|
if ((!id_list->list) || match_netid(id_list->list, tagif, 0)) |
if ((!id_list->list) || match_netid(id_list->list, tagif, 0)) |
break; |
break; |
if (id_list) |
if (id_list) |
state.hostname = NULL; | state->hostname = NULL; |
} |
} |
|
|
|
|
Line 534 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 580 static int dhcp6_no_relay(int msg_type, struct in6_add
|
{ |
{ |
default: |
default: |
return 0; |
return 0; |
| |
| |
case DHCP6SOLICIT: |
case DHCP6SOLICIT: |
{ |
{ |
void *rapid_commit = opt6_find(state.packet_options, state.end, OPTION6_RAPID_COMMIT, 0); |
|
int address_assigned = 0; |
int address_assigned = 0; |
/* tags without all prefix-class tags */ |
/* tags without all prefix-class tags */ |
struct dhcp_netid *solicit_tags = tagif; | struct dhcp_netid *solicit_tags; |
struct dhcp_context *c; |
struct dhcp_context *c; |
| |
if (rapid_commit) | *outmsgtypep = DHCP6ADVERTISE; |
| |
| if (opt6_find(state->packet_options, state->end, OPTION6_RAPID_COMMIT, 0)) |
{ |
{ |
|
*outmsgtypep = DHCP6REPLY; |
|
state->lease_allocate = 1; |
o = new_opt6(OPTION6_RAPID_COMMIT); |
o = new_opt6(OPTION6_RAPID_COMMIT); |
end_opt6(o); |
end_opt6(o); |
} |
} |
|
|
|
log6_quiet(state, "DHCPSOLICIT", NULL, ignore ? _("ignored") : NULL); |
|
|
/* set reply message type */ | request_no_address: |
*outmsgtypep = rapid_commit ? DHCP6REPLY : DHCP6ADVERTISE; | solicit_tags = tagif; |
| |
log6_packet(&state, "DHCPSOLICIT", NULL, ignore ? _("ignored") : NULL); | |
|
|
if (ignore) |
if (ignore) |
return 0; |
return 0; |
Line 562 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 611 static int dhcp6_no_relay(int msg_type, struct in6_add
|
lease6_reset(); |
lease6_reset(); |
|
|
/* Can use configured address max once per prefix */ |
/* Can use configured address max once per prefix */ |
for (c = context; c; c = c->current) | for (c = state->context; c; c = c->current) |
c->flags &= ~CONTEXT_CONF_USED; |
c->flags &= ~CONTEXT_CONF_USED; |
|
|
for (opt = state.packet_options; opt; opt = opt6_next(opt, state.end)) | for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
{ |
{ |
void *ia_option, *ia_end; |
void *ia_option, *ia_end; |
unsigned int min_time = 0xffffffff; |
unsigned int min_time = 0xffffffff; |
Line 574 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 623 static int dhcp6_no_relay(int msg_type, struct in6_add
|
/* set unless we're sending a particular prefix-class, when we |
/* set unless we're sending a particular prefix-class, when we |
want only dhcp-ranges with the correct tags set and not those without any tags. */ |
want only dhcp-ranges with the correct tags set and not those without any tags. */ |
int plain_range = 1; |
int plain_range = 1; |
u32 lease_time, requested_time; | u32 lease_time; |
struct dhcp_lease *ltmp; |
struct dhcp_lease *ltmp; |
struct in6_addr *req_addr; |
struct in6_addr *req_addr; |
struct in6_addr addr; |
struct in6_addr addr; |
|
|
if (!check_ia(&state, opt, &ia_end, &ia_option)) | if (!check_ia(state, opt, &ia_end, &ia_option)) |
continue; |
continue; |
|
|
/* reset USED bits in contexts - one address per prefix per IAID */ |
/* reset USED bits in contexts - one address per prefix per IAID */ |
for (c = context; c; c = c->current) | for (c = state->context; c; c = c->current) |
c->flags &= ~CONTEXT_USED; |
c->flags &= ~CONTEXT_USED; |
|
|
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
if (daemon->prefix_classes && state.ia_type == OPTION6_IA_NA) | if (daemon->prefix_classes && state->ia_type == OPTION6_IA_NA) |
{ |
{ |
void *prefix_opt; |
void *prefix_opt; |
int prefix_class; |
int prefix_class; |
Line 611 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 660 static int dhcp6_no_relay(int msg_type, struct in6_add
|
else |
else |
{ |
{ |
/* add tag to list, and exclude undecorated dhcp-ranges */ |
/* add tag to list, and exclude undecorated dhcp-ranges */ |
p->tag.next = state.tags; | p->tag.next = state->tags; |
solicit_tags = run_tag_if(&p->tag); |
solicit_tags = run_tag_if(&p->tag); |
plain_range = 0; |
plain_range = 0; |
state.send_prefix_class = p; | state->send_prefix_class = p; |
} |
} |
} |
} |
else |
else |
Line 630 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 679 static int dhcp6_no_relay(int msg_type, struct in6_add
|
if (p) |
if (p) |
{ |
{ |
plain_range = 0; |
plain_range = 0; |
state.send_prefix_class = p; | state->send_prefix_class = p; |
} |
} |
} |
} |
|
|
if (p && option_bool(OPT_LOG_OPTS)) |
if (p && option_bool(OPT_LOG_OPTS)) |
my_syslog(MS_DHCP | LOG_INFO, "%u prefix class %d tag:%s", state.xid, p->class, p->tag.net); | my_syslog(MS_DHCP | LOG_INFO, "%u prefix class %d tag:%s", state->xid, p->class, p->tag.net); |
} |
} |
} |
} |
#endif |
#endif |
|
|
o = build_ia(&state, &t1cntr); | o = build_ia(state, &t1cntr); |
|
|
for (ia_counter = 0; ia_option; ia_counter++, ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
for (ia_counter = 0; ia_option; ia_counter++, ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
{ |
{ |
req_addr = opt6_ptr(ia_option, 0); |
req_addr = opt6_ptr(ia_option, 0); |
requested_time = opt6_uint(ia_option, 16, 4); | |
| if ((c = address6_valid(state->context, req_addr, solicit_tags, plain_range))) |
if ((c = address6_valid(context, req_addr, solicit_tags, plain_range))) | |
{ |
{ |
lease_time = c->lease_time; |
lease_time = c->lease_time; |
/* If the client asks for an address on the same network as a configured address, |
/* If the client asks for an address on the same network as a configured address, |
offer the configured address instead, to make moving to newly-configured |
offer the configured address instead, to make moving to newly-configured |
addresses automatic. */ |
addresses automatic. */ |
if (!(c->flags & CONTEXT_CONF_USED) && config_valid(config, c, &addr) && check_address(&state, &addr)) | if (!(c->flags & CONTEXT_CONF_USED) && config_valid(config, c, &addr) && check_address(state, &addr)) |
{ |
{ |
req_addr = &addr; |
req_addr = &addr; |
mark_config_used(c, &addr); |
mark_config_used(c, &addr); |
if (have_config(config, CONFIG_TIME)) |
if (have_config(config, CONFIG_TIME)) |
lease_time = config->lease_time; |
lease_time = config->lease_time; |
} |
} |
else if (!(c = address6_available(context, req_addr, solicit_tags, plain_range))) | else if (!(c = address6_available(state->context, req_addr, solicit_tags, plain_range))) |
continue; /* not an address we're allowed */ |
continue; /* not an address we're allowed */ |
else if (!check_address(&state, req_addr)) | else if (!check_address(state, req_addr)) |
continue; /* address leased elsewhere */ |
continue; /* address leased elsewhere */ |
|
|
/* add address to output packet */ |
/* add address to output packet */ |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
if (dump_all_prefix_classes && state.ia_type == OPTION6_IA_NA) | if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
state.send_prefix_class = prefix_class_from_context(c); | state->send_prefix_class = prefix_class_from_context(c); |
#endif |
#endif |
add_address(&state, c, lease_time, requested_time, &min_time, req_addr, rapid_commit != NULL, now); | add_address(state, c, lease_time, ia_option, &min_time, req_addr, now); |
mark_context_used(&state, context, req_addr); | mark_context_used(state, req_addr); |
get_context_tag(&state, c); | get_context_tag(state, c); |
address_assigned = 1; |
address_assigned = 1; |
} |
} |
} |
} |
|
|
/* Suggest configured address(es) */ |
/* Suggest configured address(es) */ |
for (c = context; c; c = c->current) | for (c = state->context; c; c = c->current) |
if (!(c->flags & CONTEXT_CONF_USED) && |
if (!(c->flags & CONTEXT_CONF_USED) && |
match_netid(c->filter, solicit_tags, plain_range) && |
match_netid(c->filter, solicit_tags, plain_range) && |
config_valid(config, c, &addr) && |
config_valid(config, c, &addr) && |
check_address(&state, &addr)) | check_address(state, &addr)) |
{ |
{ |
mark_config_used(context, &addr); | mark_config_used(state->context, &addr); |
if (have_config(config, CONFIG_TIME)) |
if (have_config(config, CONFIG_TIME)) |
lease_time = config->lease_time; |
lease_time = config->lease_time; |
else |
else |
lease_time = c->lease_time; |
lease_time = c->lease_time; |
/* add address to output packet */ |
/* add address to output packet */ |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
if (dump_all_prefix_classes && state.ia_type == OPTION6_IA_NA) | if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
state.send_prefix_class = prefix_class_from_context(c); | state->send_prefix_class = prefix_class_from_context(c); |
#endif |
#endif |
add_address(&state, c, lease_time, lease_time, &min_time, &addr, rapid_commit != NULL, now); | add_address(state, c, lease_time, NULL, &min_time, &addr, now); |
mark_context_used(&state, context, &addr); | mark_context_used(state, &addr); |
get_context_tag(&state, c); | get_context_tag(state, c); |
address_assigned = 1; |
address_assigned = 1; |
} |
} |
|
|
/* return addresses for existing leases */ |
/* return addresses for existing leases */ |
ltmp = NULL; |
ltmp = NULL; |
while ((ltmp = lease6_find_by_client(ltmp, state.ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, state.clid, state.clid_len, state.iaid))) | while ((ltmp = lease6_find_by_client(ltmp, state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, state->clid, state->clid_len, state->iaid))) |
{ |
{ |
req_addr = (struct in6_addr *)ltmp->hwaddr; | req_addr = <mp->addr6; |
if ((c = address6_available(context, req_addr, solicit_tags, plain_range))) | if ((c = address6_available(state->context, req_addr, solicit_tags, plain_range))) |
{ |
{ |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
if (dump_all_prefix_classes && state.ia_type == OPTION6_IA_NA) | if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
state.send_prefix_class = prefix_class_from_context(c); | state->send_prefix_class = prefix_class_from_context(c); |
#endif |
#endif |
add_address(&state, c, c->lease_time, c->lease_time, &min_time, req_addr, rapid_commit != NULL, now); | add_address(state, c, c->lease_time, NULL, &min_time, req_addr, now); |
mark_context_used(&state, context, req_addr); | mark_context_used(state, req_addr); |
get_context_tag(&state, c); | get_context_tag(state, c); |
address_assigned = 1; |
address_assigned = 1; |
} |
} |
} |
} |
|
|
/* Return addresses for all valid contexts which don't yet have one */ |
/* Return addresses for all valid contexts which don't yet have one */ |
while ((c = address6_allocate(context, state.clid, state.clid_len, state.iaid, ia_counter, solicit_tags, plain_range, &addr))) | while ((c = address6_allocate(state->context, state->clid, state->clid_len, state->ia_type == OPTION6_IA_TA, |
| state->iaid, ia_counter, solicit_tags, plain_range, &addr))) |
{ |
{ |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
if (dump_all_prefix_classes && state.ia_type == OPTION6_IA_NA) | if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
state.send_prefix_class = prefix_class_from_context(c); | state->send_prefix_class = prefix_class_from_context(c); |
#endif |
#endif |
add_address(&state, c, c->lease_time, c->lease_time, &min_time, &addr, rapid_commit != NULL, now); | add_address(state, c, c->lease_time, NULL, &min_time, &addr, now); |
mark_context_used(&state, context, &addr); | mark_context_used(state, &addr); |
get_context_tag(&state, c); | get_context_tag(state, c); |
address_assigned = 1; |
address_assigned = 1; |
} |
} |
|
|
Line 747 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 796 static int dhcp6_no_relay(int msg_type, struct in6_add
|
o = new_opt6(OPTION6_PREFERENCE); |
o = new_opt6(OPTION6_PREFERENCE); |
put_opt6_char(option_bool(OPT_AUTHORITATIVE) ? 255 : 0); |
put_opt6_char(option_bool(OPT_AUTHORITATIVE) ? 255 : 0); |
end_opt6(o); |
end_opt6(o); |
tagif = add_options(&state, fallback, context); | tagif = add_options(state, 0); |
} |
} |
else |
else |
{ |
{ |
Line 756 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 805 static int dhcp6_no_relay(int msg_type, struct in6_add
|
put_opt6_short(DHCP6NOADDRS); |
put_opt6_short(DHCP6NOADDRS); |
put_opt6_string(_("no addresses available")); |
put_opt6_string(_("no addresses available")); |
end_opt6(o1); |
end_opt6(o1); |
log6_packet(&state, "DHCPADVERTISE", NULL, _("no addresses available")); | log6_packet(state, "DHCPADVERTISE", NULL, _("no addresses available")); |
} |
} |
|
|
break; |
break; |
Line 765 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 814 static int dhcp6_no_relay(int msg_type, struct in6_add
|
case DHCP6REQUEST: |
case DHCP6REQUEST: |
{ |
{ |
int address_assigned = 0; |
int address_assigned = 0; |
| int start = save_counter(-1); |
| |
/* set reply message type */ |
/* set reply message type */ |
*outmsgtypep = DHCP6REPLY; |
*outmsgtypep = DHCP6REPLY; |
|
state->lease_allocate = 1; |
|
|
log6_packet(&state, "DHCPREQUEST", NULL, ignore ? _("ignored") : NULL); | log6_quiet(state, "DHCPREQUEST", NULL, ignore ? _("ignored") : NULL); |
|
|
if (ignore) |
if (ignore) |
return 0; |
return 0; |
|
|
for (opt = state.packet_options; opt; opt = opt6_next(opt, state.end)) | for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
{ |
{ |
void *ia_option, *ia_end; |
void *ia_option, *ia_end; |
unsigned int min_time = 0xffffffff; |
unsigned int min_time = 0xffffffff; |
int t1cntr; |
int t1cntr; |
|
|
if (!check_ia(&state, opt, &ia_end, &ia_option)) | if (!check_ia(state, opt, &ia_end, &ia_option)) |
continue; |
continue; |
| |
o = build_ia(&state, &t1cntr); | if (!ia_option) |
| { |
| /* If we get a request with a IA_*A without addresses, treat it exactly like |
| a SOLICT with rapid commit set. */ |
| save_counter(start); |
| goto request_no_address; |
| } |
| |
| o = build_ia(state, &t1cntr); |
|
|
for (; ia_option; ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
for (; ia_option; ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
{ |
{ |
struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
u32 requested_time = opt6_uint(ia_option, 16, 4); |
|
struct dhcp_context *dynamic, *c; |
struct dhcp_context *dynamic, *c; |
unsigned int lease_time; |
unsigned int lease_time; |
struct in6_addr addr; |
struct in6_addr addr; |
int config_ok = 0; |
int config_ok = 0; |
|
|
if ((c = address6_valid(context, req_addr, tagif, 1))) | if ((c = address6_valid(state->context, req_addr, tagif, 1))) |
config_ok = config_valid(config, c, &addr) && IN6_ARE_ADDR_EQUAL(&addr, req_addr); |
config_ok = config_valid(config, c, &addr) && IN6_ARE_ADDR_EQUAL(&addr, req_addr); |
|
|
if ((dynamic = address6_available(context, req_addr, tagif, 1)) || c) | if ((dynamic = address6_available(state->context, req_addr, tagif, 1)) || c) |
{ |
{ |
if (!dynamic && !config_ok) |
if (!dynamic && !config_ok) |
{ |
{ |
Line 807 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 865 static int dhcp6_no_relay(int msg_type, struct in6_add
|
put_opt6_string(_("address unavailable")); |
put_opt6_string(_("address unavailable")); |
end_opt6(o1); |
end_opt6(o1); |
} |
} |
else if (!check_address(&state, req_addr)) | else if (!check_address(state, req_addr)) |
{ |
{ |
/* Address leased to another DUID/IAID */ |
/* Address leased to another DUID/IAID */ |
o1 = new_opt6(OPTION6_STATUS_CODE); |
o1 = new_opt6(OPTION6_STATUS_CODE); |
Line 826 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 884 static int dhcp6_no_relay(int msg_type, struct in6_add
|
lease_time = config->lease_time; |
lease_time = config->lease_time; |
|
|
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
if (dump_all_prefix_classes && state.ia_type == OPTION6_IA_NA) | if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
state.send_prefix_class = prefix_class_from_context(c); | state->send_prefix_class = prefix_class_from_context(c); |
#endif |
#endif |
add_address(&state, dynamic, lease_time, requested_time, &min_time, req_addr, 1, now); | add_address(state, dynamic, lease_time, ia_option, &min_time, req_addr, now); |
get_context_tag(&state, dynamic); | get_context_tag(state, dynamic); |
address_assigned = 1; |
address_assigned = 1; |
} |
} |
} |
} |
Line 862 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 920 static int dhcp6_no_relay(int msg_type, struct in6_add
|
put_opt6_short(DHCP6NOADDRS); |
put_opt6_short(DHCP6NOADDRS); |
put_opt6_string(_("no addresses available")); |
put_opt6_string(_("no addresses available")); |
end_opt6(o1); |
end_opt6(o1); |
log6_packet(&state, "DHCPREPLY", NULL, _("no addresses available")); | log6_packet(state, "DHCPREPLY", NULL, _("no addresses available")); |
} |
} |
|
|
tagif = add_options(&state, fallback, context); | tagif = add_options(state, 0); |
break; |
break; |
} |
} |
|
|
Line 875 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 933 static int dhcp6_no_relay(int msg_type, struct in6_add
|
/* set reply message type */ |
/* set reply message type */ |
*outmsgtypep = DHCP6REPLY; |
*outmsgtypep = DHCP6REPLY; |
|
|
log6_packet(&state, "DHCPRENEW", NULL, NULL); | log6_quiet(state, "DHCPRENEW", NULL, NULL); |
|
|
for (opt = state.packet_options; opt; opt = opt6_next(opt, state.end)) | for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
{ |
{ |
void *ia_option, *ia_end; |
void *ia_option, *ia_end; |
unsigned int min_time = 0xffffffff; |
unsigned int min_time = 0xffffffff; |
int t1cntr, iacntr; |
int t1cntr, iacntr; |
|
|
if (!check_ia(&state, opt, &ia_end, &ia_option)) | if (!check_ia(state, opt, &ia_end, &ia_option)) |
continue; |
continue; |
|
|
o = build_ia(&state, &t1cntr); | o = build_ia(state, &t1cntr); |
iacntr = save_counter(-1); |
iacntr = save_counter(-1); |
|
|
for (; ia_option; ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
for (; ia_option; ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
{ |
{ |
struct dhcp_lease *lease = NULL; |
struct dhcp_lease *lease = NULL; |
struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
u32 requested_time = opt6_uint(ia_option, 16, 4); | unsigned int preferred_time = opt6_uint(ia_option, 16, 4); |
unsigned int preferred_time = 0; /* in case renewal inappropriate */ | unsigned int valid_time = opt6_uint(ia_option, 20, 4); |
unsigned int valid_time = 0; | |
char *message = NULL; |
char *message = NULL; |
struct dhcp_context *this_context; |
struct dhcp_context *this_context; |
|
|
if (!(lease = lease6_find(state.clid, state.clid_len, | if (!(lease = lease6_find(state->clid, state->clid_len, |
state.ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, | state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, |
state.iaid, req_addr))) | state->iaid, req_addr))) |
{ |
{ |
/* If the server cannot find a client entry for the IA the server |
/* If the server cannot find a client entry for the IA the server |
returns the IA containing no addresses with a Status Code option set |
returns the IA containing no addresses with a Status Code option set |
Line 909 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 966 static int dhcp6_no_relay(int msg_type, struct in6_add
|
save_counter(iacntr); |
save_counter(iacntr); |
t1cntr = 0; |
t1cntr = 0; |
|
|
log6_packet(&state, "DHCPREPLY", req_addr, _("lease not found")); | log6_packet(state, "DHCPREPLY", req_addr, _("lease not found")); |
|
|
o1 = new_opt6(OPTION6_STATUS_CODE); |
o1 = new_opt6(OPTION6_STATUS_CODE); |
put_opt6_short(DHCP6NOBINDING); |
put_opt6_short(DHCP6NOBINDING); |
put_opt6_string(_("no binding found")); |
put_opt6_string(_("no binding found")); |
end_opt6(o1); |
end_opt6(o1); |
|
|
|
preferred_time = valid_time = 0; |
break; |
break; |
} |
} |
|
|
|
|
if ((this_context = address6_available(context, req_addr, tagif, 1)) || | if ((this_context = address6_available(state->context, req_addr, tagif, 1)) || |
(this_context = address6_valid(context, req_addr, tagif, 1))) | (this_context = address6_valid(state->context, req_addr, tagif, 1))) |
{ |
{ |
struct in6_addr addr; |
struct in6_addr addr; |
unsigned int lease_time; |
unsigned int lease_time; |
|
|
get_context_tag(&state, this_context); | get_context_tag(state, this_context); |
|
|
if (config_valid(config, this_context, &addr) && IN6_ARE_ADDR_EQUAL(&addr, req_addr) && have_config(config, CONFIG_TIME)) |
if (config_valid(config, this_context, &addr) && IN6_ARE_ADDR_EQUAL(&addr, req_addr) && have_config(config, CONFIG_TIME)) |
lease_time = config->lease_time; |
lease_time = config->lease_time; |
else |
else |
lease_time = this_context->lease_time; |
lease_time = this_context->lease_time; |
|
|
calculate_times(this_context, &min_time, &valid_time, &preferred_time, lease_time, requested_time); | calculate_times(this_context, &min_time, &valid_time, &preferred_time, lease_time); |
|
|
lease_set_expires(lease, valid_time, now); |
lease_set_expires(lease, valid_time, now); |
if (state.ia_type == OPTION6_IA_NA && state.hostname) | /* Update MAC record in case it's new information. */ |
| if (state->mac_len != 0) |
| lease_set_hwaddr(lease, state->mac, state->clid, state->mac_len, state->mac_type, state->clid_len, now, 0); |
| if (state->ia_type == OPTION6_IA_NA && state->hostname) |
{ |
{ |
char *addr_domain = get_domain6(req_addr); |
char *addr_domain = get_domain6(req_addr); |
if (!state.send_domain) | if (!state->send_domain) |
state.send_domain = addr_domain; | state->send_domain = addr_domain; |
lease_set_hostname(lease, state.hostname, state.hostname_auth, addr_domain, state.domain); | lease_set_hostname(lease, state->hostname, state->hostname_auth, addr_domain, state->domain); |
message = state.hostname; | message = state->hostname; |
} |
} |
|
|
|
|
Line 949 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1011 static int dhcp6_no_relay(int msg_type, struct in6_add
|
message = _("deprecated"); |
message = _("deprecated"); |
} |
} |
else |
else |
message = _("address invalid"); | { |
| preferred_time = valid_time = 0; |
log6_packet(&state, "DHCPREPLY", req_addr, message); | message = _("address invalid"); |
| } |
| |
| if (message) |
| log6_packet(state, "DHCPREPLY", req_addr, message); |
| else |
| log6_quiet(state, "DHCPREPLY", req_addr, message); |
| |
o1 = new_opt6(OPTION6_IAADDR); |
o1 = new_opt6(OPTION6_IAADDR); |
put_opt6(req_addr, sizeof(*req_addr)); |
put_opt6(req_addr, sizeof(*req_addr)); |
put_opt6_long(preferred_time); |
put_opt6_long(preferred_time); |
Line 964 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1032 static int dhcp6_no_relay(int msg_type, struct in6_add
|
end_opt6(o); |
end_opt6(o); |
} |
} |
|
|
tagif = add_options(&state, fallback, context); | tagif = add_options(state, 0); |
break; |
break; |
|
|
} |
} |
Line 974 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1042 static int dhcp6_no_relay(int msg_type, struct in6_add
|
/* set reply message type */ |
/* set reply message type */ |
*outmsgtypep = DHCP6REPLY; |
*outmsgtypep = DHCP6REPLY; |
|
|
log6_packet(&state, "DHCPCONFIRM", NULL, NULL); | log6_quiet(state, "DHCPCONFIRM", NULL, NULL); |
|
|
for (opt = state.packet_options; opt; opt = opt6_next(opt, state.end)) | for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
{ |
{ |
void *ia_option, *ia_end; |
void *ia_option, *ia_end; |
|
|
for (check_ia(&state, opt, &ia_end, &ia_option); | for (check_ia(state, opt, &ia_end, &ia_option); |
ia_option; |
ia_option; |
ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
{ |
{ |
struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
|
|
if (!address6_available(context, req_addr, tagif, 1)) | if (!address6_available(state->context, req_addr, tagif, 1)) |
{ |
{ |
o1 = new_opt6(OPTION6_STATUS_CODE); |
o1 = new_opt6(OPTION6_STATUS_CODE); |
put_opt6_short(DHCP6NOTONLINK); |
put_opt6_short(DHCP6NOTONLINK); |
Line 995 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1063 static int dhcp6_no_relay(int msg_type, struct in6_add
|
return 1; |
return 1; |
} |
} |
|
|
log6_packet(&state, "DHCPREPLY", req_addr, state.hostname); | log6_quiet(state, "DHCPREPLY", req_addr, state->hostname); |
} |
} |
} |
} |
|
|
Line 1010 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1078 static int dhcp6_no_relay(int msg_type, struct in6_add
|
{ |
{ |
/* We can't discriminate contexts based on address, as we don't know it. |
/* We can't discriminate contexts based on address, as we don't know it. |
If there is only one possible context, we can use its tags */ |
If there is only one possible context, we can use its tags */ |
if (context && context->netid.net && !context->current) | if (state->context && state->context->netid.net && !state->context->current) |
{ |
{ |
context->netid.next = NULL; | state->context->netid.next = NULL; |
state.context_tags = &context->netid; | state->context_tags = &state->context->netid; |
} |
} |
log6_packet(&state, "DHCPINFORMATION-REQUEST", NULL, ignore ? _("ignored") : state.hostname); | |
| /* Similarly, we can't determine domain from address, but if the FQDN is |
| given in --dhcp-host, we can use that, and failing that we can use the |
| unqualified configured domain, if any. */ |
| if (state->hostname_auth) |
| state->send_domain = state->domain; |
| else |
| state->send_domain = get_domain6(NULL); |
| |
| log6_quiet(state, "DHCPINFORMATION-REQUEST", NULL, ignore ? _("ignored") : state->hostname); |
if (ignore) |
if (ignore) |
return 0; |
return 0; |
*outmsgtypep = DHCP6REPLY; |
*outmsgtypep = DHCP6REPLY; |
tagif = add_options(&state, fallback, context); | tagif = add_options(state, 1); |
break; |
break; |
} |
} |
|
|
Line 1029 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1106 static int dhcp6_no_relay(int msg_type, struct in6_add
|
/* set reply message type */ |
/* set reply message type */ |
*outmsgtypep = DHCP6REPLY; |
*outmsgtypep = DHCP6REPLY; |
|
|
log6_packet(&state, "DHCPRELEASE", NULL, NULL); | log6_quiet(state, "DHCPRELEASE", NULL, NULL); |
|
|
for (opt = state.packet_options; opt; opt = opt6_next(opt, state.end)) | for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
{ |
{ |
void *ia_option, *ia_end; |
void *ia_option, *ia_end; |
int made_ia = 0; |
int made_ia = 0; |
|
|
for (check_ia(&state, opt, &ia_end, &ia_option); | for (check_ia(state, opt, &ia_end, &ia_option); |
ia_option; |
ia_option; |
ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
{ |
{ |
struct dhcp_lease *lease; |
struct dhcp_lease *lease; |
|
|
if ((lease = lease6_find(state.clid, state.clid_len, state.ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, | if ((lease = lease6_find(state->clid, state->clid_len, state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, |
state.iaid, opt6_ptr(ia_option, 0)))) | state->iaid, opt6_ptr(ia_option, 0)))) |
lease_prune(lease, now); |
lease_prune(lease, now); |
else |
else |
{ |
{ |
if (!made_ia) |
if (!made_ia) |
{ |
{ |
o = new_opt6(state.ia_type); | o = new_opt6(state->ia_type); |
put_opt6_long(state.iaid); | put_opt6_long(state->iaid); |
if (state.ia_type == OPTION6_IA_NA) | if (state->ia_type == OPTION6_IA_NA) |
{ |
{ |
put_opt6_long(0); |
put_opt6_long(0); |
put_opt6_long(0); |
put_opt6_long(0); |
Line 1091 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1168 static int dhcp6_no_relay(int msg_type, struct in6_add
|
/* set reply message type */ |
/* set reply message type */ |
*outmsgtypep = DHCP6REPLY; |
*outmsgtypep = DHCP6REPLY; |
|
|
log6_packet(&state, "DHCPDECLINE", NULL, NULL); | log6_quiet(state, "DHCPDECLINE", NULL, NULL); |
|
|
for (opt = state.packet_options; opt; opt = opt6_next(opt, state.end)) | for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
{ |
{ |
void *ia_option, *ia_end; |
void *ia_option, *ia_end; |
int made_ia = 0; |
int made_ia = 0; |
|
|
for (check_ia(&state, opt, &ia_end, &ia_option); | for (check_ia(state, opt, &ia_end, &ia_option); |
ia_option; |
ia_option; |
ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
{ |
{ |
Line 1116 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1193 static int dhcp6_no_relay(int msg_type, struct in6_add
|
} |
} |
else |
else |
/* make sure this host gets a different address next time. */ |
/* make sure this host gets a different address next time. */ |
for (; context; context = context->current) | for (context_tmp = state->context; context_tmp; context_tmp = context_tmp->current) |
context->addr_epoch++; | context_tmp->addr_epoch++; |
|
|
if ((lease = lease6_find(state.clid, state.clid_len, state.ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, | if ((lease = lease6_find(state->clid, state->clid_len, state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, |
state.iaid, opt6_ptr(ia_option, 0)))) | state->iaid, opt6_ptr(ia_option, 0)))) |
lease_prune(lease, now); |
lease_prune(lease, now); |
else |
else |
{ |
{ |
if (!made_ia) |
if (!made_ia) |
{ |
{ |
o = new_opt6(state.ia_type); | o = new_opt6(state->ia_type); |
put_opt6_long(state.iaid); | put_opt6_long(state->iaid); |
if (state.ia_type == OPTION6_IA_NA) | if (state->ia_type == OPTION6_IA_NA) |
{ |
{ |
put_opt6_long(0); |
put_opt6_long(0); |
put_opt6_long(0); |
put_opt6_long(0); |
Line 1160 static int dhcp6_no_relay(int msg_type, struct in6_add
|
Line 1237 static int dhcp6_no_relay(int msg_type, struct in6_add
|
|
|
} |
} |
|
|
log_tags(tagif, state.xid); | log_tags(tagif, state->xid); |
| log6_opts(0, state->xid, daemon->outpacket.iov_base + start_opts, daemon->outpacket.iov_base + save_counter(-1)); |
|
|
if (option_bool(OPT_LOG_OPTS)) |
|
log6_opts(0, state.xid, daemon->outpacket.iov_base + start_opts, daemon->outpacket.iov_base + save_counter(-1)); |
|
|
|
return 1; |
return 1; |
|
|
} |
} |
|
|
struct dhcp_netid *add_options(struct state *state, struct in6_addr *fallback, struct dhcp_context *context) | static struct dhcp_netid *add_options(struct state *state, int do_refresh) |
{ |
{ |
void *oro; |
void *oro; |
/* filter options based on tags, those we want get DHOPT_TAGOK bit set */ |
/* filter options based on tags, those we want get DHOPT_TAGOK bit set */ |
struct dhcp_netid *tagif = option_filter(state->tags, state->context_tags, daemon->dhcp_opts6); |
struct dhcp_netid *tagif = option_filter(state->tags, state->context_tags, daemon->dhcp_opts6); |
struct dhcp_opt *opt_cfg; |
struct dhcp_opt *opt_cfg; |
int done_dns = 0, do_encap = 0; | int done_dns = 0, done_refresh = !do_refresh, do_encap = 0; |
int i, o, o1; |
int i, o, o1; |
|
|
oro = opt6_find(state->packet_options, state->end, OPTION6_ORO, 0); |
oro = opt6_find(state->packet_options, state->end, OPTION6_ORO, 0); |
Line 1197 struct dhcp_netid *add_options(struct state *state, st
|
Line 1272 struct dhcp_netid *add_options(struct state *state, st
|
continue; |
continue; |
} |
} |
|
|
if (opt_cfg->opt == OPTION6_DNS_SERVER) | if (opt_cfg->opt == OPTION6_REFRESH_TIME) |
{ | done_refresh = 1; |
done_dns = 1; | |
if (opt_cfg->len == 0) | |
continue; | |
} | |
|
|
o = new_opt6(opt_cfg->opt); |
|
if (opt_cfg->flags & DHOPT_ADDR6) |
if (opt_cfg->flags & DHOPT_ADDR6) |
{ |
{ |
int j; | int len, j; |
struct in6_addr *a = (struct in6_addr *)opt_cfg->val; | struct in6_addr *a; |
for (j = 0; j < opt_cfg->len; j+=IN6ADDRSZ, a++) | |
{ | if (opt_cfg->opt == OPTION6_DNS_SERVER) |
/* zero means "self" (but not in vendorclass options.) */ | done_dns = 1; |
if (IN6_IS_ADDR_UNSPECIFIED(a)) | |
{ | for (a = (struct in6_addr *)opt_cfg->val, len = opt_cfg->len, j = 0; |
if (!add_local_addrs(context)) | j < opt_cfg->len; j += IN6ADDRSZ, a++) |
put_opt6(fallback, IN6ADDRSZ); | if ((IN6_IS_ADDR_ULA_ZERO(a) && IN6_IS_ADDR_UNSPECIFIED(state->ula_addr)) || |
| (IN6_IS_ADDR_LINK_LOCAL_ZERO(a) && IN6_IS_ADDR_UNSPECIFIED(state->ll_addr))) |
| len -= IN6ADDRSZ; |
| |
| if (len != 0) |
| { |
| |
| o = new_opt6(opt_cfg->opt); |
| |
| for (a = (struct in6_addr *)opt_cfg->val, j = 0; j < opt_cfg->len; j+=IN6ADDRSZ, a++) |
| { |
| if (IN6_IS_ADDR_UNSPECIFIED(a)) |
| { |
| if (!add_local_addrs(state->context)) |
| put_opt6(state->fallback, IN6ADDRSZ); |
| } |
| else if (IN6_IS_ADDR_ULA_ZERO(a)) |
| { |
| if (!IN6_IS_ADDR_UNSPECIFIED(state->ula_addr)) |
| put_opt6(state->ula_addr, IN6ADDRSZ); |
| } |
| else if (IN6_IS_ADDR_LINK_LOCAL_ZERO(a)) |
| { |
| if (!IN6_IS_ADDR_UNSPECIFIED(state->ll_addr)) |
| put_opt6(state->ll_addr, IN6ADDRSZ); |
| } |
| else |
| put_opt6(a, IN6ADDRSZ); |
} |
} |
else | |
put_opt6(a, IN6ADDRSZ); | end_opt6(o); |
} | } |
} |
} |
else if (opt_cfg->val) | else |
put_opt6(opt_cfg->val, opt_cfg->len); | { |
end_opt6(o); | o = new_opt6(opt_cfg->opt); |
| if (opt_cfg->val) |
| put_opt6(opt_cfg->val, opt_cfg->len); |
| end_opt6(o); |
| } |
} |
} |
|
|
if (daemon->port == NAMESERVER_PORT && !done_dns && | if (daemon->port == NAMESERVER_PORT && !done_dns) |
(!IN6_IS_ADDR_UNSPECIFIED(&context->local6) || | |
!IN6_IS_ADDR_UNSPECIFIED(fallback))) | |
{ |
{ |
o = new_opt6(OPTION6_DNS_SERVER); |
o = new_opt6(OPTION6_DNS_SERVER); |
if (!add_local_addrs(context)) | if (!add_local_addrs(state->context)) |
put_opt6(fallback, IN6ADDRSZ); | put_opt6(state->fallback, IN6ADDRSZ); |
end_opt6(o); |
end_opt6(o); |
} |
} |
|
|
|
if (state->context && !done_refresh) |
|
{ |
|
struct dhcp_context *c; |
|
unsigned int lease_time = 0xffffffff; |
|
|
|
/* Find the smallest lease tie of all contexts, |
|
subjext to the RFC-4242 stipulation that this must not |
|
be less than 600. */ |
|
for (c = state->context; c; c = c->next) |
|
if (c->lease_time < lease_time) |
|
{ |
|
if (c->lease_time < 600) |
|
lease_time = 600; |
|
else |
|
lease_time = c->lease_time; |
|
} |
|
|
|
o = new_opt6(OPTION6_REFRESH_TIME); |
|
put_opt6_long(lease_time); |
|
end_opt6(o); |
|
} |
|
|
/* handle vendor-identifying vendor-encapsulated options, |
/* handle vendor-identifying vendor-encapsulated options, |
dhcp-option = vi-encap:13,17,....... */ |
dhcp-option = vi-encap:13,17,....... */ |
Line 1299 struct dhcp_netid *add_options(struct state *state, st
|
Line 1420 struct dhcp_netid *add_options(struct state *state, st
|
size_t len = strlen(state->hostname); |
size_t len = strlen(state->hostname); |
|
|
if (state->send_domain) |
if (state->send_domain) |
len += strlen(state->send_domain) + 1; | len += strlen(state->send_domain) + 2; |
|
|
o = new_opt6(OPTION6_FQDN); |
o = new_opt6(OPTION6_FQDN); |
if ((p = expand(len + 3))) | if ((p = expand(len + 2))) |
{ |
{ |
*(p++) = state->fqdn_flags; |
*(p++) = state->fqdn_flags; |
p = do_rfc1035_name(p, state->hostname); |
p = do_rfc1035_name(p, state->hostname); |
if (state->send_domain) |
if (state->send_domain) |
p = do_rfc1035_name(p, state->send_domain); | { |
*p = 0; | p = do_rfc1035_name(p, state->send_domain); |
| *p = 0; |
| } |
} |
} |
end_opt6(o); |
end_opt6(o); |
} |
} |
Line 1463 static void end_ia(int t1cntr, unsigned int min_time,
|
Line 1586 static void end_ia(int t1cntr, unsigned int min_time,
|
} |
} |
} |
} |
|
|
static void add_address(struct state *state, struct dhcp_context *context, unsigned int lease_time, unsigned int requested_time, | static void add_address(struct state *state, struct dhcp_context *context, unsigned int lease_time, void *ia_option, |
unsigned int *min_time, struct in6_addr *addr, int do_update, time_t now) | unsigned int *min_time, struct in6_addr *addr, time_t now) |
{ |
{ |
unsigned int valid_time, preferred_time; | unsigned int valid_time = 0, preferred_time = 0; |
int o = new_opt6(OPTION6_IAADDR); |
int o = new_opt6(OPTION6_IAADDR); |
struct dhcp_lease *lease; |
struct dhcp_lease *lease; |
|
|
calculate_times(context, min_time, &valid_time, &preferred_time, lease_time, requested_time); | /* get client requested times */ |
| if (ia_option) |
| { |
| preferred_time = opt6_uint(ia_option, 16, 4); |
| valid_time = opt6_uint(ia_option, 20, 4); |
| } |
| |
| calculate_times(context, min_time, &valid_time, &preferred_time, lease_time); |
|
|
put_opt6(addr, sizeof(*addr)); |
put_opt6(addr, sizeof(*addr)); |
put_opt6_long(preferred_time); |
put_opt6_long(preferred_time); |
Line 1487 static void add_address(struct state *state, struct dh
|
Line 1617 static void add_address(struct state *state, struct dh
|
|
|
end_opt6(o); |
end_opt6(o); |
|
|
if (do_update) | if (state->lease_allocate) |
update_leases(state, context, addr, valid_time, now); |
update_leases(state, context, addr, valid_time, now); |
|
|
if ((lease = lease6_find_by_addr(addr, 128, 0))) |
if ((lease = lease6_find_by_addr(addr, 128, 0))) |
Line 1511 static void add_address(struct state *state, struct dh
|
Line 1641 static void add_address(struct state *state, struct dh
|
} |
} |
} |
} |
|
|
log6_packet(state, do_update ? "DHCPREPLY" : "DHCPADVERTISE", addr, state->hostname); | log6_quiet(state, state->lease_allocate ? "DHCPREPLY" : "DHCPADVERTISE", addr, state->hostname); |
|
|
} |
} |
|
|
static void mark_context_used(struct state *state, struct dhcp_context *context, struct in6_addr *addr) | static void mark_context_used(struct state *state, struct in6_addr *addr) |
{ |
{ |
|
struct dhcp_context *context; |
|
|
/* Mark that we have an address for this prefix. */ |
/* Mark that we have an address for this prefix. */ |
#ifdef OPTION6_PREFIX_CLASS |
#ifdef OPTION6_PREFIX_CLASS |
for (; context; context = context->current) | for (context = state->context; context; context = context->current) |
if (is_same_net6(addr, &context->start6, context->prefix) && |
if (is_same_net6(addr, &context->start6, context->prefix) && |
(!state->send_prefix_class || state->send_prefix_class == prefix_class_from_context(context))) |
(!state->send_prefix_class || state->send_prefix_class == prefix_class_from_context(context))) |
context->flags |= CONTEXT_USED; |
context->flags |= CONTEXT_USED; |
#else |
#else |
(void)state; /* warning */ | for (context = state->context; context; context = context->current) |
for (; context; context = context->current) | |
if (is_same_net6(addr, &context->start6, context->prefix)) |
if (is_same_net6(addr, &context->start6, context->prefix)) |
context->flags |= CONTEXT_USED; |
context->flags |= CONTEXT_USED; |
#endif |
#endif |
Line 1548 static int check_address(struct state *state, struct i
|
Line 1679 static int check_address(struct state *state, struct i
|
|
|
if (lease->clid_len != state->clid_len || |
if (lease->clid_len != state->clid_len || |
memcmp(lease->clid, state->clid, state->clid_len) != 0 || |
memcmp(lease->clid, state->clid, state->clid_len) != 0 || |
lease->hwaddr_type != state->iaid) | lease->iaid != state->iaid) |
return 0; |
return 0; |
|
|
return 1; |
return 1; |
} |
} |
|
|
|
|
|
/* Calculate valid and preferred times to send in leases/renewals. |
|
|
|
Inputs are: |
|
|
|
*valid_timep, *preferred_timep - requested times from IAADDR options. |
|
context->valid, context->preferred - times associated with subnet address on local interface. |
|
context->flags | CONTEXT_DEPRECATE - "deprecated" flag in dhcp-range. |
|
lease_time - configured time for context for individual client. |
|
*min_time - smallest valid time sent so far. |
|
|
|
Outputs are : |
|
|
|
*valid_timep, *preferred_timep - times to be send in IAADDR option. |
|
*min_time - smallest valid time sent so far, to calculate T1 and T2. |
|
|
|
*/ |
static void calculate_times(struct dhcp_context *context, unsigned int *min_time, unsigned int *valid_timep, |
static void calculate_times(struct dhcp_context *context, unsigned int *min_time, unsigned int *valid_timep, |
unsigned int *preferred_timep, unsigned int lease_time, unsigned int requested_time) | unsigned int *preferred_timep, unsigned int lease_time) |
{ |
{ |
unsigned int preferred_time, valid_time; | unsigned int req_preferred = *preferred_timep, req_valid = *valid_timep; |
| unsigned int valid_time = lease_time, preferred_time = lease_time; |
| |
| /* RFC 3315: "A server ignores the lifetimes set |
| by the client if the preferred lifetime is greater than the valid |
| lifetime. */ |
| if (req_preferred <= req_valid) |
| { |
| if (req_preferred != 0) |
| { |
| /* 0 == "no preference from client" */ |
| if (req_preferred < 120u) |
| req_preferred = 120u; /* sanity */ |
| |
| if (req_preferred < preferred_time) |
| preferred_time = req_preferred; |
| } |
| |
| if (req_valid != 0) |
| /* 0 == "no preference from client" */ |
| { |
| if (req_valid < 120u) |
| req_valid = 120u; /* sanity */ |
| |
| if (req_valid < valid_time) |
| valid_time = req_valid; |
| } |
| } |
|
|
if (requested_time < 120u ) | /* deprecate (preferred == 0) which configured, or when local address |
requested_time = 120u; /* sanity */ | is deprecated */ |
if (lease_time == 0xffffffff || (requested_time != 0xffffffff && requested_time < lease_time)) | if ((context->flags & CONTEXT_DEPRECATE) || context->preferred == 0) |
lease_time = requested_time; | |
| |
valid_time = (context->valid < lease_time) ? context->valid : lease_time; | |
preferred_time = (context->preferred < lease_time) ? context->preferred : lease_time; | |
| |
if (context->flags & CONTEXT_DEPRECATE) | |
preferred_time = 0; |
preferred_time = 0; |
| |
if (preferred_time != 0 && preferred_time < *min_time) |
if (preferred_time != 0 && preferred_time < *min_time) |
*min_time = preferred_time; |
*min_time = preferred_time; |
|
|
Line 1583 static void calculate_times(struct dhcp_context *conte
|
Line 1752 static void calculate_times(struct dhcp_context *conte
|
static void update_leases(struct state *state, struct dhcp_context *context, struct in6_addr *addr, unsigned int lease_time, time_t now) |
static void update_leases(struct state *state, struct dhcp_context *context, struct in6_addr *addr, unsigned int lease_time, time_t now) |
{ |
{ |
struct dhcp_lease *lease = lease6_find_by_addr(addr, 128, 0); |
struct dhcp_lease *lease = lease6_find_by_addr(addr, 128, 0); |
|
#ifdef HAVE_SCRIPT |
struct dhcp_netid *tagif = run_tag_if(state->tags); |
struct dhcp_netid *tagif = run_tag_if(state->tags); |
|
#endif |
|
|
|
(void)context; |
|
|
if (!lease) |
if (!lease) |
lease = lease6_allocate(addr, state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA); |
lease = lease6_allocate(addr, state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA); |
|
|
if (lease) |
if (lease) |
{ |
{ |
lease_set_expires(lease, lease_time, now); |
lease_set_expires(lease, lease_time, now); |
lease_set_hwaddr(lease, NULL, state->clid, 0, state->iaid, state->clid_len, now, 0); | lease_set_iaid(lease, state->iaid); |
| lease_set_hwaddr(lease, state->mac, state->clid, state->mac_len, state->mac_type, state->clid_len, now, 0); |
lease_set_interface(lease, state->interface, now); |
lease_set_interface(lease, state->interface, now); |
if (state->hostname && state->ia_type == OPTION6_IA_NA) |
if (state->hostname && state->ia_type == OPTION6_IA_NA) |
{ |
{ |
Line 1678 static void log6_opts(int nest, unsigned int xid, void
|
Line 1852 static void log6_opts(int nest, unsigned int xid, void
|
void *opt; |
void *opt; |
char *desc = nest ? "nest" : "sent"; |
char *desc = nest ? "nest" : "sent"; |
|
|
if (start_opts == end_opts) | if (!option_bool(OPT_LOG_OPTS) || start_opts == end_opts) |
return; |
return; |
|
|
for (opt = start_opts; opt; opt = opt6_next(opt, end_opts)) |
for (opt = start_opts; opt; opt = opt6_next(opt, end_opts)) |
Line 1737 static void log6_opts(int nest, unsigned int xid, void
|
Line 1911 static void log6_opts(int nest, unsigned int xid, void
|
} |
} |
} |
} |
|
|
|
static void log6_quiet(struct state *state, char *type, struct in6_addr *addr, char *string) |
|
{ |
|
if (option_bool(OPT_LOG_OPTS) || !option_bool(OPT_QUIET_DHCP6)) |
|
log6_packet(state, type, addr, string); |
|
} |
|
|
static void log6_packet(struct state *state, char *type, struct in6_addr *addr, char *string) |
static void log6_packet(struct state *state, char *type, struct in6_addr *addr, char *string) |
{ |
{ |
int clid_len = state->clid_len; |
int clid_len = state->clid_len; |
Line 1827 static unsigned int opt6_uint(unsigned char *opt, int
|
Line 2007 static unsigned int opt6_uint(unsigned char *opt, int
|
|
|
return ret; |
return ret; |
} |
} |
|
|
|
void relay_upstream6(struct dhcp_relay *relay, ssize_t sz, struct in6_addr *peer_address, u32 scope_id) |
|
{ |
|
/* ->local is same value for all relays on ->current chain */ |
|
|
|
struct all_addr from; |
|
unsigned char *header; |
|
unsigned char *inbuff = daemon->dhcp_packet.iov_base; |
|
int msg_type = *inbuff; |
|
int hopcount; |
|
struct in6_addr multicast; |
|
unsigned int maclen, mactype; |
|
unsigned char mac[DHCP_CHADDR_MAX]; |
|
|
|
inet_pton(AF_INET6, ALL_SERVERS, &multicast); |
|
get_client_mac(peer_address, scope_id, mac, &maclen, &mactype); |
|
|
|
/* source address == relay address */ |
|
from.addr.addr6 = relay->local.addr.addr6; |
|
|
|
/* Get hop count from nested relayed message */ |
|
if (msg_type == DHCP6RELAYFORW) |
|
hopcount = *((unsigned char *)inbuff+1) + 1; |
|
else |
|
hopcount = 0; |
|
|
|
/* RFC 3315 HOP_COUNT_LIMIT */ |
|
if (hopcount > 32) |
|
return; |
|
|
|
save_counter(0); |
|
|
|
if ((header = put_opt6(NULL, 34))) |
|
{ |
|
int o; |
|
|
|
header[0] = DHCP6RELAYFORW; |
|
header[1] = hopcount; |
|
memcpy(&header[2], &relay->local.addr.addr6, IN6ADDRSZ); |
|
memcpy(&header[18], peer_address, IN6ADDRSZ); |
|
|
|
/* RFC-6939 */ |
|
if (maclen != 0) |
|
{ |
|
o = new_opt6(OPTION6_CLIENT_MAC); |
|
put_opt6_short(mactype); |
|
put_opt6(mac, maclen); |
|
end_opt6(o); |
|
} |
|
|
|
o = new_opt6(OPTION6_RELAY_MSG); |
|
put_opt6(inbuff, sz); |
|
end_opt6(o); |
|
|
|
for (; relay; relay = relay->current) |
|
{ |
|
union mysockaddr to; |
|
|
|
to.sa.sa_family = AF_INET6; |
|
to.in6.sin6_addr = relay->server.addr.addr6; |
|
to.in6.sin6_port = htons(DHCPV6_SERVER_PORT); |
|
to.in6.sin6_flowinfo = 0; |
|
to.in6.sin6_scope_id = 0; |
|
|
|
if (IN6_ARE_ADDR_EQUAL(&relay->server.addr.addr6, &multicast)) |
|
{ |
|
int multicast_iface; |
|
if (!relay->interface || strchr(relay->interface, '*') || |
|
(multicast_iface = if_nametoindex(relay->interface)) == 0 || |
|
setsockopt(daemon->dhcp6fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &multicast_iface, sizeof(multicast_iface)) == -1) |
|
my_syslog(MS_DHCP | LOG_ERR, _("Cannot multicast to DHCPv6 server without correct interface")); |
|
} |
|
|
|
send_from(daemon->dhcp6fd, 0, daemon->outpacket.iov_base, save_counter(0), &to, &from, 0); |
|
|
|
if (option_bool(OPT_LOG_OPTS)) |
|
{ |
|
inet_ntop(AF_INET6, &relay->local, daemon->addrbuff, ADDRSTRLEN); |
|
inet_ntop(AF_INET6, &relay->server, daemon->namebuff, ADDRSTRLEN); |
|
my_syslog(MS_DHCP | LOG_INFO, _("DHCP relay %s -> %s"), daemon->addrbuff, daemon->namebuff); |
|
} |
|
|
|
/* Save this for replies */ |
|
relay->iface_index = scope_id; |
|
} |
|
} |
|
} |
|
|
|
unsigned short relay_reply6(struct sockaddr_in6 *peer, ssize_t sz, char *arrival_interface) |
|
{ |
|
struct dhcp_relay *relay; |
|
struct in6_addr link; |
|
unsigned char *inbuff = daemon->dhcp_packet.iov_base; |
|
|
|
/* must have at least msg_type+hopcount+link_address+peer_address+minimal size option |
|
which is 1 + 1 + 16 + 16 + 2 + 2 = 38 */ |
|
|
|
if (sz < 38 || *inbuff != DHCP6RELAYREPL) |
|
return 0; |
|
|
|
memcpy(&link, &inbuff[2], IN6ADDRSZ); |
|
|
|
for (relay = daemon->relay6; relay; relay = relay->next) |
|
if (IN6_ARE_ADDR_EQUAL(&link, &relay->local.addr.addr6) && |
|
(!relay->interface || wildcard_match(relay->interface, arrival_interface))) |
|
break; |
|
|
|
save_counter(0); |
|
|
|
if (relay) |
|
{ |
|
void *opt, *opts = inbuff + 34; |
|
void *end = inbuff + sz; |
|
for (opt = opts; opt; opt = opt6_next(opt, end)) |
|
if (opt6_type(opt) == OPTION6_RELAY_MSG && opt6_len(opt) > 0) |
|
{ |
|
int encap_type = *((unsigned char *)opt6_ptr(opt, 0)); |
|
put_opt6(opt6_ptr(opt, 0), opt6_len(opt)); |
|
memcpy(&peer->sin6_addr, &inbuff[18], IN6ADDRSZ); |
|
peer->sin6_scope_id = relay->iface_index; |
|
return encap_type == DHCP6RELAYREPL ? DHCPV6_SERVER_PORT : DHCPV6_CLIENT_PORT; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
#endif |
#endif |