| /* dnsmasq is Copyright (c) 2000-2014 Simon Kelley |
| |
| 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 |
| the Free Software Foundation; version 2 dated June, 1991, or |
| (at your option) version 3 dated 29 June, 2007. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| |
| #include "dnsmasq.h" |
| |
| #ifdef HAVE_DHCP6 |
| |
| struct state { |
| unsigned char *clid; |
| int clid_len, iaid, ia_type, interface, hostname_auth, lease_allocate; |
| char *client_hostname, *hostname, *domain, *send_domain; |
| struct dhcp_context *context; |
| struct in6_addr *link_address, *fallback, *ll_addr, *ula_addr; |
| unsigned int xid, fqdn_flags; |
| char *iface_name; |
| void *packet_options, *end; |
| struct dhcp_netid *tags, *context_tags; |
| unsigned char mac[DHCP_CHADDR_MAX]; |
| unsigned int mac_len, mac_type; |
| #ifdef OPTION6_PREFIX_CLASS |
| struct prefix_class *send_prefix_class; |
| #endif |
| }; |
| |
| static int dhcp6_maybe_relay(struct state *state, void *inbuff, size_t sz, |
| struct in6_addr *client_addr, int is_unicast, time_t now); |
| static int dhcp6_no_relay(struct state *state, int msg_type, 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_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_next(void *opts, void *end); |
| static unsigned int opt6_uint(unsigned char *opt, int offset, int size); |
| static void get_context_tag(struct state *state, struct dhcp_context *context); |
| static int check_ia(struct state *state, void *opt, void **endp, void **ia_option); |
| static int build_ia(struct state *state, int *t1cntr); |
| static void end_ia(int t1cntr, unsigned int min_time, int do_fuzz); |
| #ifdef OPTION6_PREFIX_CLASS |
| static struct prefix_class *prefix_class_from_context(struct dhcp_context *context); |
| #endif |
| 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 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, void *ia_option, |
| 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 int add_local_addrs(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, |
| unsigned int *preferred_timep, unsigned int lease_time); |
| |
| #define opt6_len(opt) ((int)(opt6_uint(opt, -2, 2))) |
| #define opt6_type(opt) (opt6_uint(opt, -4, 2)) |
| #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, |
| 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_vendor *vendor; |
| int msg_type; |
| struct state state; |
| |
| if (sz <= 4) |
| return 0; |
| |
| msg_type = *((unsigned char *)daemon->dhcp_packet.iov_base); |
| |
| /* Mark these so we only match each at most once, to avoid tangled linked lists */ |
| for (vendor = daemon->dhcp_vendors; vendor; vendor = vendor->next) |
| vendor->netid.next = &vendor->netid; |
| |
| save_counter(0); |
| state.context = context; |
| 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 0; |
| } |
| |
| /* This cost me blood to write, it will probably cost you blood to understand - srk. */ |
| static int dhcp6_maybe_relay(struct state *state, void *inbuff, size_t sz, |
| struct in6_addr *client_addr, int is_unicast, time_t now) |
| { |
| void *end = inbuff + sz; |
| void *opts = inbuff + 34; |
| int msg_type = *((unsigned char *)inbuff); |
| unsigned char *outmsgtypep; |
| void *opt; |
| struct dhcp_vendor *vendor; |
| |
| /* if not an encaplsulated relayed message, just do the stuff */ |
| if (msg_type != DHCP6RELAYFORW) |
| { |
| /* if link_address != NULL if points to the link address field of the |
| innermost nested RELAYFORW message, which is where we find the |
| address of the network on which we can allocate an address. |
| 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 (!state->link_address) |
| get_client_mac(client_addr, state->interface, state->mac, &state->mac_len, &state->mac_type); |
| else |
| { |
| struct dhcp_context *c; |
| state->context = NULL; |
| |
| if (!IN6_IS_ADDR_LOOPBACK(state->link_address) && |
| !IN6_IS_ADDR_LINKLOCAL(state->link_address) && |
| !IN6_IS_ADDR_MULTICAST(state->link_address)) |
| for (c = daemon->dhcp6; c; c = c->next) |
| if ((c->flags & CONTEXT_DHCP) && |
| !(c->flags & (CONTEXT_TEMPLATE | CONTEXT_OLD)) && |
| is_same_net6(state->link_address, &c->start6, c->prefix) && |
| is_same_net6(state->link_address, &c->end6, c->prefix)) |
| { |
| c->preferred = c->valid = 0xffffffff; |
| c->current = state->context; |
| state->context = c; |
| } |
| |
| if (!state->context) |
| { |
| inet_ntop(AF_INET6, state->link_address, daemon->addrbuff, ADDRSTRLEN); |
| my_syslog(MS_DHCP | LOG_WARNING, |
| _("no address range available for DHCPv6 request from relay at %s"), |
| daemon->addrbuff); |
| return 0; |
| } |
| } |
| |
| if (!state->context) |
| { |
| my_syslog(MS_DHCP | LOG_WARNING, |
| _("no address range available for DHCPv6 request via %s"), state->iface_name); |
| return 0; |
| } |
| |
| 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 |
| which is 1 + 1 + 16 + 16 + 2 + 2 = 38 */ |
| if (sz < 38) |
| return 0; |
| |
| /* copy header stuff into reply message and set type to reply */ |
| if (!(outmsgtypep = put_opt6(inbuff, 34))) |
| return 0; |
| *outmsgtypep = DHCP6RELAYREPL; |
| |
| /* look for relay options and set tags if found. */ |
| for (vendor = daemon->dhcp_vendors; vendor; vendor = vendor->next) |
| { |
| int mopt; |
| |
| if (vendor->match_type == MATCH_SUBSCRIBER) |
| mopt = OPTION6_SUBSCRIBER_ID; |
| else if (vendor->match_type == MATCH_REMOTE) |
| mopt = OPTION6_REMOTE_ID; |
| else |
| continue; |
| |
| if ((opt = opt6_find(opts, end, mopt, 1)) && |
| vendor->len == opt6_len(opt) && |
| memcmp(vendor->data, opt6_ptr(opt, 0), vendor->len) == 0 && |
| vendor->netid.next != &vendor->netid) |
| { |
| vendor->netid.next = state->tags; |
| state->tags = &vendor->netid; |
| 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)) |
| { |
| int o = new_opt6(opt6_type(opt)); |
| if (opt6_type(opt) == OPTION6_RELAY_MSG) |
| { |
| struct in6_addr align; |
| /* the packet data is unaligned, copy to aligned storage */ |
| memcpy(&align, inbuff + 2, IN6ADDRSZ); |
| 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 */ |
| if (!dhcp6_maybe_relay(state, opt6_ptr(opt, 0), opt6_len(opt), client_addr, 0, now)) |
| return 0; |
| } |
| else if (opt6_type(opt) != OPTION6_CLIENT_MAC) |
| put_opt6(opt6_ptr(opt, 0), opt6_len(opt)); |
| end_opt6(o); |
| } |
| |
| return 1; |
| } |
| |
| static int dhcp6_no_relay(struct state *state, int msg_type, void *inbuff, size_t sz, int is_unicast, time_t now) |
| { |
| void *opt; |
| int i, o, o1, start_opts; |
| struct dhcp_opt *opt_cfg; |
| struct dhcp_netid *tagif; |
| struct dhcp_config *config = NULL; |
| struct dhcp_netid known_id, iface_id, v6_id; |
| unsigned char *outmsgtypep; |
| struct dhcp_vendor *vendor; |
| struct dhcp_context *context_tmp; |
| struct dhcp_mac *mac_opt; |
| unsigned int ignore = 0; |
| #ifdef OPTION6_PREFIX_CLASS |
| struct prefix_class *p; |
| int dump_all_prefix_classes = 0; |
| #endif |
| |
| state->packet_options = inbuff + 4; |
| state->end = inbuff + sz; |
| state->clid = NULL; |
| state->clid_len = 0; |
| state->lease_allocate = 0; |
| state->context_tags = NULL; |
| state->domain = NULL; |
| state->send_domain = NULL; |
| state->hostname_auth = 0; |
| state->hostname = NULL; |
| state->client_hostname = NULL; |
| state->fqdn_flags = 0x01; /* default to send if we recieve no FQDN option */ |
| #ifdef OPTION6_PREFIX_CLASS |
| state->send_prefix_class = NULL; |
| #endif |
| |
| /* set tag with name == interface */ |
| iface_id.net = state->iface_name; |
| iface_id.next = state->tags; |
| state->tags = &iface_id; |
| |
| /* set tag "dhcpv6" */ |
| v6_id.net = "dhcpv6"; |
| v6_id.next = state->tags; |
| state->tags = &v6_id; |
| |
| /* copy over transaction-id, and save pointer to message type */ |
| if (!(outmsgtypep = put_opt6(inbuff, 4))) |
| return 0; |
| start_opts = save_counter(-1); |
| state->xid = outmsgtypep[3] | outmsgtypep[2] << 8 | outmsgtypep[1] << 16; |
| |
| /* 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 */ |
| for (context_tmp = state->context; context_tmp; context_tmp = context_tmp->current) |
| { |
| context_tmp->netid.next = &context_tmp->netid; |
| |
| if (option_bool(OPT_LOG_OPTS)) |
| { |
| inet_ntop(AF_INET6, &context_tmp->start6, daemon->dhcp_buff, ADDRSTRLEN); |
| inet_ntop(AF_INET6, &context_tmp->end6, daemon->dhcp_buff2, ADDRSTRLEN); |
| if (context_tmp->flags & (CONTEXT_STATIC)) |
| my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCPv6 subnet: %s/%d"), |
| state->xid, daemon->dhcp_buff, context_tmp->prefix); |
| else |
| my_syslog(MS_DHCP | LOG_INFO, _("%u available DHCP range: %s -- %s"), |
| state->xid, daemon->dhcp_buff, daemon->dhcp_buff2); |
| } |
| } |
| |
| if ((opt = opt6_find(state->packet_options, state->end, OPTION6_CLIENT_ID, 1))) |
| { |
| state->clid = opt6_ptr(opt, 0); |
| state->clid_len = opt6_len(opt); |
| o = new_opt6(OPTION6_CLIENT_ID); |
| put_opt6(state->clid, state->clid_len); |
| end_opt6(o); |
| } |
| else if (msg_type != DHCP6IREQ) |
| return 0; |
| |
| /* server-id must match except for SOLICIT, CONFIRM and REBIND messages */ |
| if (msg_type != DHCP6SOLICIT && msg_type != DHCP6CONFIRM && msg_type != DHCP6IREQ && msg_type != DHCP6REBIND && |
| (!(opt = opt6_find(state->packet_options, state->end, OPTION6_SERVER_ID, 1)) || |
| opt6_len(opt) != daemon->duid_len || |
| memcmp(opt6_ptr(opt, 0), daemon->duid, daemon->duid_len) != 0)) |
| return 0; |
| |
| o = new_opt6(OPTION6_SERVER_ID); |
| put_opt6(daemon->duid, daemon->duid_len); |
| end_opt6(o); |
| |
| if (is_unicast && |
| (msg_type == DHCP6REQUEST || msg_type == DHCP6RENEW || msg_type == DHCP6RELEASE || msg_type == DHCP6DECLINE)) |
| |
| { |
| *outmsgtypep = DHCP6REPLY; |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6USEMULTI); |
| put_opt6_string("Use multicast"); |
| end_opt6(o1); |
| return 1; |
| } |
| |
| /* match vendor and user class options */ |
| for (vendor = daemon->dhcp_vendors; vendor; vendor = vendor->next) |
| { |
| int mopt; |
| |
| if (vendor->match_type == MATCH_VENDOR) |
| mopt = OPTION6_VENDOR_CLASS; |
| else if (vendor->match_type == MATCH_USER) |
| mopt = OPTION6_USER_CLASS; |
| else |
| continue; |
| |
| if ((opt = opt6_find(state->packet_options, state->end, mopt, 2))) |
| { |
| void *enc_opt, *enc_end = opt6_ptr(opt, opt6_len(opt)); |
| int offset = 0; |
| |
| if (mopt == OPTION6_VENDOR_CLASS) |
| { |
| if (opt6_len(opt) < 4) |
| continue; |
| |
| if (vendor->enterprise != opt6_uint(opt, 0, 4)) |
| continue; |
| |
| offset = 4; |
| } |
| |
| /* Note that format if user/vendor classes is different to DHCP options - no option types. */ |
| for (enc_opt = opt6_ptr(opt, offset); enc_opt; enc_opt = opt6_user_vendor_next(enc_opt, enc_end)) |
| 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; |
| state->tags = &vendor->netid; |
| break; |
| } |
| } |
| } |
| |
| 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)); |
| |
| /* 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. |
| If no data given, existance of the option is enough. This code handles |
| V-I opts too. */ |
| for (opt_cfg = daemon->dhcp_match6; opt_cfg; opt_cfg = opt_cfg->next) |
| { |
| int match = 0; |
| |
| if (opt_cfg->flags & DHOPT_RFC3925) |
| { |
| for (opt = opt6_find(state->packet_options, state->end, OPTION6_VENDOR_OPTS, 4); |
| opt; |
| opt = opt6_find(opt6_next(opt, state->end), state->end, OPTION6_VENDOR_OPTS, 4)) |
| { |
| void *vopt; |
| void *vend = opt6_ptr(opt, opt6_len(opt)); |
| |
| for (vopt = opt6_find(opt6_ptr(opt, 4), vend, opt_cfg->opt, 0); |
| vopt; |
| vopt = opt6_find(opt6_next(vopt, vend), vend, opt_cfg->opt, 0)) |
| if ((match = match_bytes(opt_cfg, opt6_ptr(vopt, 0), opt6_len(vopt)))) |
| break; |
| } |
| if (match) |
| break; |
| } |
| else |
| { |
| if (!(opt = opt6_find(state->packet_options, state->end, opt_cfg->opt, 1))) |
| continue; |
| |
| match = match_bytes(opt_cfg, opt6_ptr(opt, 0), opt6_len(opt)); |
| } |
| |
| if (match) |
| { |
| opt_cfg->netid->next = state->tags; |
| 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))) |
| { |
| /* RFC4704 refers */ |
| int len = opt6_len(opt) - 1; |
| |
| state->fqdn_flags = opt6_uint(opt, 0, 1); |
| |
| /* Always force update, since the client has no way to do it itself. */ |
| if (!option_bool(OPT_FQDN_UPDATE) && !(state->fqdn_flags & 0x01)) |
| state->fqdn_flags |= 0x03; |
| |
| state->fqdn_flags &= ~0x04; |
| |
| if (len != 0 && len < 255) |
| { |
| unsigned char *pp, *op = opt6_ptr(opt, 1); |
| char *pq = daemon->dhcp_buff; |
| |
| pp = op; |
| while (*op != 0 && ((op + (*op)) - pp) < len) |
| { |
| memcpy(pq, op+1, *op); |
| pq += *op; |
| op += (*op)+1; |
| *(pq++) = '.'; |
| } |
| |
| if (pq != daemon->dhcp_buff) |
| pq--; |
| *pq = 0; |
| |
| if (legal_hostname(daemon->dhcp_buff)) |
| { |
| state->client_hostname = daemon->dhcp_buff; |
| if (option_bool(OPT_LOG_OPTS)) |
| my_syslog(MS_DHCP | LOG_INFO, _("%u client provides name: %s"), state->xid, state->client_hostname); |
| } |
| } |
| } |
| |
| if (state->clid) |
| { |
| 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)) |
| { |
| state->hostname = config->hostname; |
| state->domain = config->domain; |
| state->hostname_auth = 1; |
| } |
| else if (state->client_hostname) |
| { |
| state->domain = strip_hostname(state->client_hostname); |
| |
| if (strlen(state->client_hostname) != 0) |
| { |
| state->hostname = state->client_hostname; |
| if (!config) |
| { |
| /* Search again now we have a hostname. |
| Only accept configs without CLID here, (it won't match) |
| to avoid impersonation by name. */ |
| 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) |
| config = new; |
| } |
| } |
| } |
| } |
| |
| if (config) |
| { |
| struct dhcp_netid_list *list; |
| |
| for (list = config->netid; list; list = list->next) |
| { |
| list->list->next = state->tags; |
| state->tags = list->list; |
| } |
| |
| /* set "known" tag for known hosts */ |
| known_id.net = "known"; |
| known_id.next = state->tags; |
| state->tags = &known_id; |
| |
| if (have_config(config, CONFIG_DISABLE)) |
| ignore = 1; |
| } |
| |
| #ifdef OPTION6_PREFIX_CLASS |
| /* OPTION_PREFIX_CLASS in ORO, send addresses in all prefix classes */ |
| if (daemon->prefix_classes && (msg_type == DHCP6SOLICIT || msg_type == DHCP6REQUEST)) |
| { |
| void *oro; |
| |
| if ((oro = opt6_find(state->packet_options, state->end, OPTION6_ORO, 0))) |
| for (i = 0; i < opt6_len(oro) - 1; i += 2) |
| if (opt6_uint(oro, i, 2) == OPTION6_PREFIX_CLASS) |
| { |
| dump_all_prefix_classes = 1; |
| break; |
| } |
| |
| if (msg_type != DHCP6SOLICIT || dump_all_prefix_classes) |
| /* Add the tags associated with prefix classes so we can use the DHCP ranges. |
| Not done for SOLICIT as we add them one-at-time. */ |
| for (p = daemon->prefix_classes; p ; p = p->next) |
| { |
| p->tag.next = state->tags; |
| state->tags = &p->tag; |
| } |
| } |
| #endif |
| |
| tagif = run_tag_if(state->tags); |
| |
| /* if all the netids in the ignore list are present, ignore this client */ |
| if (daemon->dhcp_ignore) |
| { |
| struct dhcp_netid_list *id_list; |
| |
| for (id_list = daemon->dhcp_ignore; id_list; id_list = id_list->next) |
| if (match_netid(id_list->list, tagif, 0)) |
| ignore = 1; |
| } |
| |
| /* if all the netids in the ignore_name list are present, ignore client-supplied name */ |
| if (!state->hostname_auth) |
| { |
| struct dhcp_netid_list *id_list; |
| |
| for (id_list = daemon->dhcp_ignore_names; id_list; id_list = id_list->next) |
| if ((!id_list->list) || match_netid(id_list->list, tagif, 0)) |
| break; |
| if (id_list) |
| state->hostname = NULL; |
| } |
| |
| |
| switch (msg_type) |
| { |
| default: |
| return 0; |
| |
| |
| case DHCP6SOLICIT: |
| { |
| int address_assigned = 0; |
| /* tags without all prefix-class tags */ |
| struct dhcp_netid *solicit_tags; |
| struct dhcp_context *c; |
| |
| *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); |
| end_opt6(o); |
| } |
| |
| log6_quiet(state, "DHCPSOLICIT", NULL, ignore ? _("ignored") : NULL); |
| |
| request_no_address: |
| solicit_tags = tagif; |
| |
| if (ignore) |
| return 0; |
| |
| /* reset USED bits in leases */ |
| lease6_reset(); |
| |
| /* Can use configured address max once per prefix */ |
| for (c = state->context; c; c = c->current) |
| c->flags &= ~CONTEXT_CONF_USED; |
| |
| for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
| { |
| void *ia_option, *ia_end; |
| unsigned int min_time = 0xffffffff; |
| int t1cntr; |
| int ia_counter; |
| /* 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. */ |
| int plain_range = 1; |
| u32 lease_time; |
| struct dhcp_lease *ltmp; |
| struct in6_addr *req_addr; |
| struct in6_addr addr; |
| |
| if (!check_ia(state, opt, &ia_end, &ia_option)) |
| continue; |
| |
| /* reset USED bits in contexts - one address per prefix per IAID */ |
| for (c = state->context; c; c = c->current) |
| c->flags &= ~CONTEXT_USED; |
| |
| #ifdef OPTION6_PREFIX_CLASS |
| if (daemon->prefix_classes && state->ia_type == OPTION6_IA_NA) |
| { |
| void *prefix_opt; |
| int prefix_class; |
| |
| if (dump_all_prefix_classes) |
| /* OPTION_PREFIX_CLASS in ORO, send addresses in all prefix classes */ |
| plain_range = 0; |
| else |
| { |
| if ((prefix_opt = opt6_find(opt6_ptr(opt, 12), ia_end, OPTION6_PREFIX_CLASS, 2))) |
| { |
| |
| prefix_class = opt6_uint(prefix_opt, 0, 2); |
| |
| for (p = daemon->prefix_classes; p ; p = p->next) |
| if (p->class == prefix_class) |
| break; |
| |
| if (!p) |
| my_syslog(MS_DHCP | LOG_WARNING, _("unknown prefix-class %d"), prefix_class); |
| else |
| { |
| /* add tag to list, and exclude undecorated dhcp-ranges */ |
| p->tag.next = state->tags; |
| solicit_tags = run_tag_if(&p->tag); |
| plain_range = 0; |
| state->send_prefix_class = p; |
| } |
| } |
| else |
| { |
| /* client didn't ask for a prefix class, lets see if we can find one. */ |
| for (p = daemon->prefix_classes; p ; p = p->next) |
| { |
| p->tag.next = NULL; |
| if (match_netid(&p->tag, solicit_tags, 1)) |
| break; |
| } |
| |
| if (p) |
| { |
| plain_range = 0; |
| state->send_prefix_class = p; |
| } |
| } |
| |
| 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); |
| } |
| } |
| #endif |
| |
| o = build_ia(state, &t1cntr); |
| if (address_assigned) |
| address_assigned = 2; |
| |
| 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); |
| |
| if ((c = address6_valid(state->context, req_addr, solicit_tags, plain_range))) |
| { |
| lease_time = c->lease_time; |
| /* 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 |
| addresses automatic. */ |
| if (!(c->flags & CONTEXT_CONF_USED) && config_valid(config, c, &addr) && check_address(state, &addr)) |
| { |
| req_addr = &addr; |
| mark_config_used(c, &addr); |
| if (have_config(config, CONFIG_TIME)) |
| lease_time = config->lease_time; |
| } |
| else if (!(c = address6_available(state->context, req_addr, solicit_tags, plain_range))) |
| continue; /* not an address we're allowed */ |
| else if (!check_address(state, req_addr)) |
| continue; /* address leased elsewhere */ |
| |
| /* add address to output packet */ |
| #ifdef OPTION6_PREFIX_CLASS |
| if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
| state->send_prefix_class = prefix_class_from_context(c); |
| #endif |
| add_address(state, c, lease_time, ia_option, &min_time, req_addr, now); |
| mark_context_used(state, req_addr); |
| get_context_tag(state, c); |
| address_assigned = 1; |
| } |
| } |
| |
| /* Suggest configured address(es) */ |
| for (c = state->context; c; c = c->current) |
| if (!(c->flags & CONTEXT_CONF_USED) && |
| match_netid(c->filter, solicit_tags, plain_range) && |
| config_valid(config, c, &addr) && |
| check_address(state, &addr)) |
| { |
| mark_config_used(state->context, &addr); |
| if (have_config(config, CONFIG_TIME)) |
| lease_time = config->lease_time; |
| else |
| lease_time = c->lease_time; |
| /* add address to output packet */ |
| #ifdef OPTION6_PREFIX_CLASS |
| if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
| state->send_prefix_class = prefix_class_from_context(c); |
| #endif |
| add_address(state, c, lease_time, NULL, &min_time, &addr, now); |
| mark_context_used(state, &addr); |
| get_context_tag(state, c); |
| address_assigned = 1; |
| } |
| |
| /* return addresses for existing leases */ |
| 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))) |
| { |
| req_addr = <mp->addr6; |
| if ((c = address6_available(state->context, req_addr, solicit_tags, plain_range))) |
| { |
| #ifdef OPTION6_PREFIX_CLASS |
| if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
| state->send_prefix_class = prefix_class_from_context(c); |
| #endif |
| add_address(state, c, c->lease_time, NULL, &min_time, req_addr, now); |
| mark_context_used(state, req_addr); |
| get_context_tag(state, c); |
| address_assigned = 1; |
| } |
| } |
| |
| /* Return addresses for all valid contexts which don't yet have one */ |
| 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 |
| if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
| state->send_prefix_class = prefix_class_from_context(c); |
| #endif |
| add_address(state, c, c->lease_time, NULL, &min_time, &addr, now); |
| mark_context_used(state, &addr); |
| get_context_tag(state, c); |
| address_assigned = 1; |
| } |
| |
| if (address_assigned != 1) |
| { |
| /* If the server will not assign any addresses to any IAs in a |
| subsequent Request from the client, the server MUST send an Advertise |
| message to the client that doesn't include any IA options. */ |
| if (!state->lease_allocate) |
| { |
| save_counter(o); |
| continue; |
| } |
| |
| /* If the server cannot assign any addresses to an IA in the message |
| from the client, the server MUST include the IA in the Reply message |
| with no addresses in the IA and a Status Code option in the IA |
| containing status code NoAddrsAvail. */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOADDRS); |
| put_opt6_string(_("address unavailable")); |
| end_opt6(o1); |
| } |
| |
| end_ia(t1cntr, min_time, 0); |
| end_opt6(o); |
| } |
| |
| if (address_assigned) |
| { |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6SUCCESS); |
| put_opt6_string(_("success")); |
| end_opt6(o1); |
| |
| /* If --dhcp-authoritative is set, we can tell client not to wait for |
| other possible servers */ |
| o = new_opt6(OPTION6_PREFERENCE); |
| put_opt6_char(option_bool(OPT_AUTHORITATIVE) ? 255 : 0); |
| end_opt6(o); |
| tagif = add_options(state, 0); |
| } |
| else |
| { |
| /* no address, return error */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOADDRS); |
| put_opt6_string(_("no addresses available")); |
| end_opt6(o1); |
| log6_packet(state, state->lease_allocate ? "DHCPREPLY" : "DHCPADVERTISE", NULL, _("no addresses available")); |
| } |
| |
| break; |
| } |
| |
| case DHCP6REQUEST: |
| { |
| int address_assigned = 0; |
| int start = save_counter(-1); |
| |
| /* set reply message type */ |
| *outmsgtypep = DHCP6REPLY; |
| state->lease_allocate = 1; |
| |
| log6_quiet(state, "DHCPREQUEST", NULL, ignore ? _("ignored") : NULL); |
| |
| if (ignore) |
| return 0; |
| |
| for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
| { |
| void *ia_option, *ia_end; |
| unsigned int min_time = 0xffffffff; |
| int t1cntr; |
| |
| if (!check_ia(state, opt, &ia_end, &ia_option)) |
| continue; |
| |
| 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)) |
| { |
| struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
| struct dhcp_context *dynamic, *c; |
| unsigned int lease_time; |
| struct in6_addr addr; |
| int config_ok = 0; |
| |
| if ((c = address6_valid(state->context, req_addr, tagif, 1))) |
| config_ok = config_valid(config, c, &addr) && IN6_ARE_ADDR_EQUAL(&addr, req_addr); |
| |
| if ((dynamic = address6_available(state->context, req_addr, tagif, 1)) || c) |
| { |
| if (!dynamic && !config_ok) |
| { |
| /* Static range, not configured. */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOADDRS); |
| put_opt6_string(_("address unavailable")); |
| end_opt6(o1); |
| } |
| else if (!check_address(state, req_addr)) |
| { |
| /* Address leased to another DUID/IAID */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6UNSPEC); |
| put_opt6_string(_("address in use")); |
| end_opt6(o1); |
| } |
| else |
| { |
| if (!dynamic) |
| dynamic = c; |
| |
| lease_time = dynamic->lease_time; |
| |
| if (config_ok && have_config(config, CONFIG_TIME)) |
| lease_time = config->lease_time; |
| |
| #ifdef OPTION6_PREFIX_CLASS |
| if (dump_all_prefix_classes && state->ia_type == OPTION6_IA_NA) |
| state->send_prefix_class = prefix_class_from_context(c); |
| #endif |
| add_address(state, dynamic, lease_time, ia_option, &min_time, req_addr, now); |
| get_context_tag(state, dynamic); |
| address_assigned = 1; |
| } |
| } |
| else |
| { |
| /* requested address not on the correct link */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOTONLINK); |
| put_opt6_string(_("not on link")); |
| end_opt6(o1); |
| } |
| } |
| |
| end_ia(t1cntr, min_time, 0); |
| end_opt6(o); |
| } |
| |
| if (address_assigned) |
| { |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6SUCCESS); |
| put_opt6_string(_("success")); |
| end_opt6(o1); |
| } |
| else |
| { |
| /* no address, return error */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOADDRS); |
| put_opt6_string(_("no addresses available")); |
| end_opt6(o1); |
| log6_packet(state, "DHCPREPLY", NULL, _("no addresses available")); |
| } |
| |
| tagif = add_options(state, 0); |
| break; |
| } |
| |
| |
| case DHCP6RENEW: |
| { |
| /* set reply message type */ |
| *outmsgtypep = DHCP6REPLY; |
| |
| log6_quiet(state, "DHCPRENEW", NULL, NULL); |
| |
| for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
| { |
| void *ia_option, *ia_end; |
| unsigned int min_time = 0xffffffff; |
| int t1cntr, iacntr; |
| |
| if (!check_ia(state, opt, &ia_end, &ia_option)) |
| continue; |
| |
| o = build_ia(state, &t1cntr); |
| iacntr = save_counter(-1); |
| |
| for (; ia_option; ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
| { |
| struct dhcp_lease *lease = NULL; |
| struct in6_addr *req_addr = opt6_ptr(ia_option, 0); |
| unsigned int preferred_time = opt6_uint(ia_option, 16, 4); |
| unsigned int valid_time = opt6_uint(ia_option, 20, 4); |
| char *message = NULL; |
| struct dhcp_context *this_context; |
| |
| if (!(lease = lease6_find(state->clid, state->clid_len, |
| state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA, |
| state->iaid, req_addr))) |
| { |
| /* 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 |
| to NoBinding in the Reply message. */ |
| save_counter(iacntr); |
| t1cntr = 0; |
| |
| log6_packet(state, "DHCPREPLY", req_addr, _("lease not found")); |
| |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOBINDING); |
| put_opt6_string(_("no binding found")); |
| end_opt6(o1); |
| |
| preferred_time = valid_time = 0; |
| break; |
| } |
| |
| |
| if ((this_context = address6_available(state->context, req_addr, tagif, 1)) || |
| (this_context = address6_valid(state->context, req_addr, tagif, 1))) |
| { |
| struct in6_addr addr; |
| unsigned int lease_time; |
| |
| 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)) |
| lease_time = config->lease_time; |
| else |
| lease_time = this_context->lease_time; |
| |
| calculate_times(this_context, &min_time, &valid_time, &preferred_time, lease_time); |
| |
| lease_set_expires(lease, valid_time, now); |
| /* 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); |
| if (!state->send_domain) |
| state->send_domain = addr_domain; |
| lease_set_hostname(lease, state->hostname, state->hostname_auth, addr_domain, state->domain); |
| message = state->hostname; |
| } |
| |
| |
| if (preferred_time == 0) |
| message = _("deprecated"); |
| } |
| else |
| { |
| preferred_time = valid_time = 0; |
| 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); |
| put_opt6(req_addr, sizeof(*req_addr)); |
| put_opt6_long(preferred_time); |
| put_opt6_long(valid_time); |
| end_opt6(o1); |
| } |
| |
| end_ia(t1cntr, min_time, 1); |
| end_opt6(o); |
| } |
| |
| tagif = add_options(state, 0); |
| break; |
| |
| } |
| |
| case DHCP6CONFIRM: |
| { |
| int good_addr = 0; |
| |
| /* set reply message type */ |
| *outmsgtypep = DHCP6REPLY; |
| |
| log6_quiet(state, "DHCPCONFIRM", NULL, NULL); |
| |
| for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
| { |
| void *ia_option, *ia_end; |
| |
| for (check_ia(state, opt, &ia_end, &ia_option); |
| 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); |
| |
| if (!address6_available(state->context, req_addr, tagif, 1)) |
| { |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOTONLINK); |
| put_opt6_string(_("confirm failed")); |
| end_opt6(o1); |
| return 1; |
| } |
| |
| good_addr = 1; |
| log6_quiet(state, "DHCPREPLY", req_addr, state->hostname); |
| } |
| } |
| |
| /* No addresses, no reply: RFC 3315 18.2.2 */ |
| if (!good_addr) |
| return 0; |
| |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6SUCCESS ); |
| put_opt6_string(_("all addresses still on link")); |
| end_opt6(o1); |
| break; |
| } |
| |
| case DHCP6IREQ: |
| { |
| /* 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 (state->context && state->context->netid.net && !state->context->current) |
| { |
| state->context->netid.next = NULL; |
| state->context_tags = &state->context->netid; |
| } |
| |
| /* 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) |
| return 0; |
| *outmsgtypep = DHCP6REPLY; |
| tagif = add_options(state, 1); |
| break; |
| } |
| |
| |
| case DHCP6RELEASE: |
| { |
| /* set reply message type */ |
| *outmsgtypep = DHCP6REPLY; |
| |
| log6_quiet(state, "DHCPRELEASE", NULL, NULL); |
| |
| for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
| { |
| void *ia_option, *ia_end; |
| int made_ia = 0; |
| |
| for (check_ia(state, opt, &ia_end, &ia_option); |
| ia_option; |
| ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
| { |
| struct dhcp_lease *lease; |
| |
| 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)))) |
| lease_prune(lease, now); |
| else |
| { |
| if (!made_ia) |
| { |
| o = new_opt6(state->ia_type); |
| put_opt6_long(state->iaid); |
| if (state->ia_type == OPTION6_IA_NA) |
| { |
| put_opt6_long(0); |
| put_opt6_long(0); |
| } |
| made_ia = 1; |
| } |
| |
| o1 = new_opt6(OPTION6_IAADDR); |
| put_opt6(opt6_ptr(ia_option, 0), IN6ADDRSZ); |
| put_opt6_long(0); |
| put_opt6_long(0); |
| end_opt6(o1); |
| } |
| } |
| |
| if (made_ia) |
| { |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOBINDING); |
| put_opt6_string(_("no binding found")); |
| end_opt6(o1); |
| |
| end_opt6(o); |
| } |
| } |
| |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6SUCCESS); |
| put_opt6_string(_("release received")); |
| end_opt6(o1); |
| |
| break; |
| } |
| |
| case DHCP6DECLINE: |
| { |
| /* set reply message type */ |
| *outmsgtypep = DHCP6REPLY; |
| |
| log6_quiet(state, "DHCPDECLINE", NULL, NULL); |
| |
| for (opt = state->packet_options; opt; opt = opt6_next(opt, state->end)) |
| { |
| void *ia_option, *ia_end; |
| int made_ia = 0; |
| |
| for (check_ia(state, opt, &ia_end, &ia_option); |
| ia_option; |
| ia_option = opt6_find(opt6_next(ia_option, ia_end), ia_end, OPTION6_IAADDR, 24)) |
| { |
| struct dhcp_lease *lease; |
| struct in6_addr *addrp = opt6_ptr(ia_option, 0); |
| |
| if (have_config(config, CONFIG_ADDR6) && IN6_ARE_ADDR_EQUAL(&config->addr6, addrp)) |
| { |
| prettyprint_time(daemon->dhcp_buff3, DECLINE_BACKOFF); |
| inet_ntop(AF_INET6, addrp, daemon->addrbuff, ADDRSTRLEN); |
| my_syslog(MS_DHCP | LOG_WARNING, _("disabling DHCP static address %s for %s"), |
| daemon->addrbuff, daemon->dhcp_buff3); |
| config->flags |= CONFIG_DECLINED; |
| config->decline_time = now; |
| } |
| else |
| /* make sure this host gets a different address next time. */ |
| for (context_tmp = state->context; context_tmp; context_tmp = context_tmp->current) |
| context_tmp->addr_epoch++; |
| |
| 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)))) |
| lease_prune(lease, now); |
| else |
| { |
| if (!made_ia) |
| { |
| o = new_opt6(state->ia_type); |
| put_opt6_long(state->iaid); |
| if (state->ia_type == OPTION6_IA_NA) |
| { |
| put_opt6_long(0); |
| put_opt6_long(0); |
| } |
| made_ia = 1; |
| } |
| |
| o1 = new_opt6(OPTION6_IAADDR); |
| put_opt6(opt6_ptr(ia_option, 0), IN6ADDRSZ); |
| put_opt6_long(0); |
| put_opt6_long(0); |
| end_opt6(o1); |
| } |
| } |
| |
| if (made_ia) |
| { |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6NOBINDING); |
| put_opt6_string(_("no binding found")); |
| end_opt6(o1); |
| |
| end_opt6(o); |
| } |
| |
| } |
| |
| /* We must anwser with 'success' in global section anyway */ |
| o1 = new_opt6(OPTION6_STATUS_CODE); |
| put_opt6_short(DHCP6SUCCESS); |
| put_opt6_string(_("success")); |
| end_opt6(o1); |
| break; |
| } |
| |
| } |
| |
| log_tags(tagif, state->xid); |
| log6_opts(0, state->xid, daemon->outpacket.iov_base + start_opts, daemon->outpacket.iov_base + save_counter(-1)); |
| |
| return 1; |
| |
| } |
| |
| static struct dhcp_netid *add_options(struct state *state, int do_refresh) |
| { |
| void *oro; |
| /* 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_opt *opt_cfg; |
| int done_dns = 0, done_refresh = !do_refresh, do_encap = 0; |
| int i, o, o1; |
| |
| oro = opt6_find(state->packet_options, state->end, OPTION6_ORO, 0); |
| |
| for (opt_cfg = daemon->dhcp_opts6; opt_cfg; opt_cfg = opt_cfg->next) |
| { |
| /* netids match and not encapsulated? */ |
| if (!(opt_cfg->flags & DHOPT_TAGOK)) |
| continue; |
| |
| if (!(opt_cfg->flags & DHOPT_FORCE) && oro) |
| { |
| for (i = 0; i < opt6_len(oro) - 1; i += 2) |
| if (opt6_uint(oro, i, 2) == (unsigned)opt_cfg->opt) |
| break; |
| |
| /* option not requested */ |
| if (i >= opt6_len(oro) - 1) |
| continue; |
| } |
| |
| if (opt_cfg->opt == OPTION6_REFRESH_TIME) |
| done_refresh = 1; |
| |
| if (opt_cfg->flags & DHOPT_ADDR6) |
| { |
| int len, j; |
| struct in6_addr *a; |
| |
| if (opt_cfg->opt == OPTION6_DNS_SERVER) |
| done_dns = 1; |
| |
| for (a = (struct in6_addr *)opt_cfg->val, len = opt_cfg->len, j = 0; |
| j < opt_cfg->len; j += IN6ADDRSZ, a++) |
| 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); |
| } |
| |
| end_opt6(o); |
| } |
| } |
| else |
| { |
| 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) |
| { |
| o = new_opt6(OPTION6_DNS_SERVER); |
| if (!add_local_addrs(state->context)) |
| put_opt6(state->fallback, IN6ADDRSZ); |
| 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, |
| dhcp-option = vi-encap:13,17,....... */ |
| for (opt_cfg = daemon->dhcp_opts6; opt_cfg; opt_cfg = opt_cfg->next) |
| opt_cfg->flags &= ~DHOPT_ENCAP_DONE; |
| |
| if (oro) |
| for (i = 0; i < opt6_len(oro) - 1; i += 2) |
| if (opt6_uint(oro, i, 2) == OPTION6_VENDOR_OPTS) |
| do_encap = 1; |
| |
| for (opt_cfg = daemon->dhcp_opts6; opt_cfg; opt_cfg = opt_cfg->next) |
| { |
| if (opt_cfg->flags & DHOPT_RFC3925) |
| { |
| int found = 0; |
| struct dhcp_opt *oc; |
| |
| if (opt_cfg->flags & DHOPT_ENCAP_DONE) |
| continue; |
| |
| for (oc = daemon->dhcp_opts6; oc; oc = oc->next) |
| { |
| oc->flags &= ~DHOPT_ENCAP_MATCH; |
| |
| if (!(oc->flags & DHOPT_RFC3925) || opt_cfg->u.encap != oc->u.encap) |
| continue; |
| |
| oc->flags |= DHOPT_ENCAP_DONE; |
| if (match_netid(oc->netid, tagif, 1)) |
| { |
| /* option requested/forced? */ |
| if (!oro || do_encap || (oc->flags & DHOPT_FORCE)) |
| { |
| oc->flags |= DHOPT_ENCAP_MATCH; |
| found = 1; |
| } |
| } |
| } |
| |
| if (found) |
| { |
| o = new_opt6(OPTION6_VENDOR_OPTS); |
| put_opt6_long(opt_cfg->u.encap); |
| |
| for (oc = daemon->dhcp_opts6; oc; oc = oc->next) |
| if (oc->flags & DHOPT_ENCAP_MATCH) |
| { |
| o1 = new_opt6(oc->opt); |
| put_opt6(oc->val, oc->len); |
| end_opt6(o1); |
| } |
| end_opt6(o); |
| } |
| } |
| } |
| |
| |
| if (state->hostname) |
| { |
| unsigned char *p; |
| size_t len = strlen(state->hostname); |
| |
| if (state->send_domain) |
| len += strlen(state->send_domain) + 2; |
| |
| o = new_opt6(OPTION6_FQDN); |
| if ((p = expand(len + 2))) |
| { |
| *(p++) = state->fqdn_flags; |
| p = do_rfc1035_name(p, state->hostname); |
| if (state->send_domain) |
| { |
| p = do_rfc1035_name(p, state->send_domain); |
| *p = 0; |
| } |
| } |
| end_opt6(o); |
| } |
| |
| |
| /* logging */ |
| if (option_bool(OPT_LOG_OPTS) && oro) |
| { |
| char *q = daemon->namebuff; |
| for (i = 0; i < opt6_len(oro) - 1; i += 2) |
| { |
| char *s = option_string(AF_INET6, opt6_uint(oro, i, 2), NULL, 0, NULL, 0); |
| q += snprintf(q, MAXDNAME - (q - daemon->namebuff), |
| "%d%s%s%s", |
| opt6_uint(oro, i, 2), |
| strlen(s) != 0 ? ":" : "", |
| s, |
| (i > opt6_len(oro) - 3) ? "" : ", "); |
| if ( i > opt6_len(oro) - 3 || (q - daemon->namebuff) > 40) |
| { |
| q = daemon->namebuff; |
| my_syslog(MS_DHCP | LOG_INFO, _("%u requested options: %s"), state->xid, daemon->namebuff); |
| } |
| } |
| } |
| |
| return tagif; |
| } |
| |
| static int add_local_addrs(struct dhcp_context *context) |
| { |
| int done = 0; |
| |
| for (; context; context = context->current) |
| if ((context->flags & CONTEXT_USED) && !IN6_IS_ADDR_UNSPECIFIED(&context->local6)) |
| { |
| /* squash duplicates */ |
| struct dhcp_context *c; |
| for (c = context->current; c; c = c->current) |
| if ((c->flags & CONTEXT_USED) && |
| IN6_ARE_ADDR_EQUAL(&context->local6, &c->local6)) |
| break; |
| |
| if (!c) |
| { |
| done = 1; |
| put_opt6(&context->local6, IN6ADDRSZ); |
| } |
| } |
| |
| return done; |
| } |
| |
| |
| static void get_context_tag(struct state *state, struct dhcp_context *context) |
| { |
| /* get tags from context if we've not used it before */ |
| if (context->netid.next == &context->netid && context->netid.net) |
| { |
| context->netid.next = state->context_tags; |
| state->context_tags = &context->netid; |
| if (!state->hostname_auth) |
| { |
| struct dhcp_netid_list *id_list; |
| |
| for (id_list = daemon->dhcp_ignore_names; id_list; id_list = id_list->next) |
| if ((!id_list->list) || match_netid(id_list->list, &context->netid, 0)) |
| break; |
| if (id_list) |
| state->hostname = NULL; |
| } |
| } |
| } |
| |
| #ifdef OPTION6_PREFIX_CLASS |
| static struct prefix_class *prefix_class_from_context(struct dhcp_context *context) |
| { |
| struct prefix_class *p; |
| struct dhcp_netid *t; |
| |
| for (p = daemon->prefix_classes; p ; p = p->next) |
| for (t = context->filter; t; t = t->next) |
| if (strcmp(p->tag.net, t->net) == 0) |
| return p; |
| |
| return NULL; |
| } |
| #endif |
| |
| static int check_ia(struct state *state, void *opt, void **endp, void **ia_option) |
| { |
| state->ia_type = opt6_type(opt); |
| *ia_option = NULL; |
| |
| if (state->ia_type != OPTION6_IA_NA && state->ia_type != OPTION6_IA_TA) |
| return 0; |
| |
| if (state->ia_type == OPTION6_IA_NA && opt6_len(opt) < 12) |
| return 0; |
| |
| if (state->ia_type == OPTION6_IA_TA && opt6_len(opt) < 4) |
| return 0; |
| |
| *endp = opt6_ptr(opt, opt6_len(opt)); |
| state->iaid = opt6_uint(opt, 0, 4); |
| *ia_option = opt6_find(opt6_ptr(opt, state->ia_type == OPTION6_IA_NA ? 12 : 4), *endp, OPTION6_IAADDR, 24); |
| |
| return 1; |
| } |
| |
| |
| static int build_ia(struct state *state, int *t1cntr) |
| { |
| int o = new_opt6(state->ia_type); |
| |
| put_opt6_long(state->iaid); |
| *t1cntr = 0; |
| |
| if (state->ia_type == OPTION6_IA_NA) |
| { |
| /* save pointer */ |
| *t1cntr = save_counter(-1); |
| /* so we can fill these in later */ |
| put_opt6_long(0); |
| put_opt6_long(0); |
| } |
| |
| return o; |
| } |
| |
| static void end_ia(int t1cntr, unsigned int min_time, int do_fuzz) |
| { |
| if (t1cntr != 0) |
| { |
| /* go back an fill in fields in IA_NA option */ |
| int sav = save_counter(t1cntr); |
| unsigned int t1, t2, fuzz = 0; |
| |
| if (do_fuzz) |
| { |
| fuzz = rand16(); |
| |
| while (fuzz > (min_time/16)) |
| fuzz = fuzz/2; |
| } |
| |
| t1 = (min_time == 0xffffffff) ? 0xffffffff : min_time/2 - fuzz; |
| t2 = (min_time == 0xffffffff) ? 0xffffffff : ((min_time/8)*7) - fuzz; |
| put_opt6_long(t1); |
| put_opt6_long(t2); |
| save_counter(sav); |
| } |
| } |
| |
| 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, time_t now) |
| { |
| unsigned int valid_time = 0, preferred_time = 0; |
| int o = new_opt6(OPTION6_IAADDR); |
| struct dhcp_lease *lease; |
| |
| /* 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_long(preferred_time); |
| put_opt6_long(valid_time); |
| |
| #ifdef OPTION6_PREFIX_CLASS |
| if (state->send_prefix_class) |
| { |
| int o1 = new_opt6(OPTION6_PREFIX_CLASS); |
| put_opt6_short(state->send_prefix_class->class); |
| end_opt6(o1); |
| } |
| #endif |
| |
| end_opt6(o); |
| |
| if (state->lease_allocate) |
| update_leases(state, context, addr, valid_time, now); |
| |
| if ((lease = lease6_find_by_addr(addr, 128, 0))) |
| lease->flags |= LEASE_USED; |
| |
| /* get tags from context if we've not used it before */ |
| if (context->netid.next == &context->netid && context->netid.net) |
| { |
| context->netid.next = state->context_tags; |
| state->context_tags = &context->netid; |
| |
| if (!state->hostname_auth) |
| { |
| struct dhcp_netid_list *id_list; |
| |
| for (id_list = daemon->dhcp_ignore_names; id_list; id_list = id_list->next) |
| if ((!id_list->list) || match_netid(id_list->list, &context->netid, 0)) |
| break; |
| if (id_list) |
| state->hostname = NULL; |
| } |
| } |
| |
| log6_quiet(state, state->lease_allocate ? "DHCPREPLY" : "DHCPADVERTISE", addr, state->hostname); |
| |
| } |
| |
| 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. */ |
| #ifdef OPTION6_PREFIX_CLASS |
| for (context = state->context; context; context = context->current) |
| if (is_same_net6(addr, &context->start6, context->prefix) && |
| (!state->send_prefix_class || state->send_prefix_class == prefix_class_from_context(context))) |
| context->flags |= CONTEXT_USED; |
| #else |
| for (context = state->context; context; context = context->current) |
| if (is_same_net6(addr, &context->start6, context->prefix)) |
| context->flags |= CONTEXT_USED; |
| #endif |
| } |
| |
| static void mark_config_used(struct dhcp_context *context, struct in6_addr *addr) |
| { |
| for (; context; context = context->current) |
| if (is_same_net6(addr, &context->start6, context->prefix)) |
| context->flags |= CONTEXT_CONF_USED; |
| } |
| |
| /* make sure address not leased to another CLID/IAID */ |
| static int check_address(struct state *state, struct in6_addr *addr) |
| { |
| struct dhcp_lease *lease; |
| |
| if (!(lease = lease6_find_by_addr(addr, 128, 0))) |
| return 1; |
| |
| if (lease->clid_len != state->clid_len || |
| memcmp(lease->clid, state->clid, state->clid_len) != 0 || |
| lease->iaid != state->iaid) |
| return 0; |
| |
| 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, |
| unsigned int *preferred_timep, unsigned int lease_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; |
| } |
| } |
| |
| /* deprecate (preferred == 0) which configured, or when local address |
| is deprecated */ |
| if ((context->flags & CONTEXT_DEPRECATE) || context->preferred == 0) |
| preferred_time = 0; |
| |
| if (preferred_time != 0 && preferred_time < *min_time) |
| *min_time = preferred_time; |
| |
| if (valid_time != 0 && valid_time < *min_time) |
| *min_time = valid_time; |
| |
| *valid_timep = valid_time; |
| *preferred_timep = preferred_time; |
| } |
| |
| 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); |
| #ifdef HAVE_SCRIPT |
| struct dhcp_netid *tagif = run_tag_if(state->tags); |
| #endif |
| |
| (void)context; |
| |
| if (!lease) |
| lease = lease6_allocate(addr, state->ia_type == OPTION6_IA_NA ? LEASE_NA : LEASE_TA); |
| |
| if (lease) |
| { |
| lease_set_expires(lease, lease_time, now); |
| 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); |
| if (state->hostname && state->ia_type == OPTION6_IA_NA) |
| { |
| char *addr_domain = get_domain6(addr); |
| if (!state->send_domain) |
| state->send_domain = addr_domain; |
| lease_set_hostname(lease, state->hostname, state->hostname_auth, addr_domain, state->domain); |
| } |
| |
| #ifdef HAVE_SCRIPT |
| if (daemon->lease_change_command) |
| { |
| void *class_opt; |
| lease->flags |= LEASE_CHANGED; |
| free(lease->extradata); |
| lease->extradata = NULL; |
| lease->extradata_size = lease->extradata_len = 0; |
| lease->vendorclass_count = 0; |
| |
| if ((class_opt = opt6_find(state->packet_options, state->end, OPTION6_VENDOR_CLASS, 4))) |
| { |
| void *enc_opt, *enc_end = opt6_ptr(class_opt, opt6_len(class_opt)); |
| lease->vendorclass_count++; |
| /* send enterprise number first */ |
| sprintf(daemon->dhcp_buff2, "%u", opt6_uint(class_opt, 0, 4)); |
| lease_add_extradata(lease, (unsigned char *)daemon->dhcp_buff2, strlen(daemon->dhcp_buff2), 0); |
| |
| if (opt6_len(class_opt) >= 6) |
| for (enc_opt = opt6_ptr(class_opt, 4); enc_opt; enc_opt = opt6_next(enc_opt, enc_end)) |
| { |
| lease->vendorclass_count++; |
| lease_add_extradata(lease, opt6_ptr(enc_opt, 0), opt6_len(enc_opt), 0); |
| } |
| } |
| |
| lease_add_extradata(lease, (unsigned char *)state->client_hostname, |
| state->client_hostname ? strlen(state->client_hostname) : 0, 0); |
| |
| /* space-concat tag set */ |
| if (!tagif && !context->netid.net) |
| lease_add_extradata(lease, NULL, 0, 0); |
| else |
| { |
| if (context->netid.net) |
| lease_add_extradata(lease, (unsigned char *)context->netid.net, strlen(context->netid.net), tagif ? ' ' : 0); |
| |
| if (tagif) |
| { |
| struct dhcp_netid *n; |
| for (n = tagif; n; n = n->next) |
| { |
| struct dhcp_netid *n1; |
| /* kill dupes */ |
| for (n1 = n->next; n1; n1 = n1->next) |
| if (strcmp(n->net, n1->net) == 0) |
| break; |
| if (!n1) |
| lease_add_extradata(lease, (unsigned char *)n->net, strlen(n->net), n->next ? ' ' : 0); |
| } |
| } |
| } |
| |
| if (state->link_address) |
| inet_ntop(AF_INET6, state->link_address, daemon->addrbuff, ADDRSTRLEN); |
| |
| lease_add_extradata(lease, (unsigned char *)daemon->addrbuff, state->link_address ? strlen(daemon->addrbuff) : 0, 0); |
| |
| if ((class_opt = opt6_find(state->packet_options, state->end, OPTION6_USER_CLASS, 2))) |
| { |
| void *enc_opt, *enc_end = opt6_ptr(class_opt, opt6_len(class_opt)); |
| for (enc_opt = opt6_ptr(class_opt, 0); enc_opt; enc_opt = opt6_next(enc_opt, enc_end)) |
| lease_add_extradata(lease, opt6_ptr(enc_opt, 0), opt6_len(enc_opt), 0); |
| } |
| } |
| #endif |
| |
| } |
| } |
| |
| |
| |
| static void log6_opts(int nest, unsigned int xid, void *start_opts, void *end_opts) |
| { |
| void *opt; |
| char *desc = nest ? "nest" : "sent"; |
| |
| if (!option_bool(OPT_LOG_OPTS) || start_opts == end_opts) |
| return; |
| |
| for (opt = start_opts; opt; opt = opt6_next(opt, end_opts)) |
| { |
| int type = opt6_type(opt); |
| void *ia_options = NULL; |
| char *optname; |
| |
| if (type == OPTION6_IA_NA) |
| { |
| sprintf(daemon->namebuff, "IAID=%u T1=%u T2=%u", |
| opt6_uint(opt, 0, 4), opt6_uint(opt, 4, 4), opt6_uint(opt, 8, 4)); |
| optname = "ia-na"; |
| ia_options = opt6_ptr(opt, 12); |
| } |
| else if (type == OPTION6_IA_TA) |
| { |
| sprintf(daemon->namebuff, "IAID=%u", opt6_uint(opt, 0, 4)); |
| optname = "ia-ta"; |
| ia_options = opt6_ptr(opt, 4); |
| } |
| else if (type == OPTION6_IAADDR) |
| { |
| inet_ntop(AF_INET6, opt6_ptr(opt, 0), daemon->addrbuff, ADDRSTRLEN); |
| sprintf(daemon->namebuff, "%s PL=%u VL=%u", |
| daemon->addrbuff, opt6_uint(opt, 16, 4), opt6_uint(opt, 20, 4)); |
| optname = "iaaddr"; |
| ia_options = opt6_ptr(opt, 24); |
| } |
| #ifdef OPTION6_PREFIX_CLASS |
| else if (type == OPTION6_PREFIX_CLASS) |
| { |
| optname = "prefix-class"; |
| sprintf(daemon->namebuff, "class=%u", opt6_uint(opt, 0, 2)); |
| } |
| #endif |
| else if (type == OPTION6_STATUS_CODE) |
| { |
| int len = sprintf(daemon->namebuff, "%u ", opt6_uint(opt, 0, 2)); |
| memcpy(daemon->namebuff + len, opt6_ptr(opt, 2), opt6_len(opt)-2); |
| daemon->namebuff[len + opt6_len(opt) - 2] = 0; |
| optname = "status"; |
| } |
| else |
| { |
| /* account for flag byte on FQDN */ |
| int offset = type == OPTION6_FQDN ? 1 : 0; |
| optname = option_string(AF_INET6, type, opt6_ptr(opt, offset), opt6_len(opt) - offset, daemon->namebuff, MAXDNAME); |
| } |
| |
| my_syslog(MS_DHCP | LOG_INFO, "%u %s size:%3d option:%3d %s %s", |
| xid, desc, opt6_len(opt), type, optname, daemon->namebuff); |
| |
| if (ia_options) |
| log6_opts(1, xid, ia_options, opt6_ptr(opt, opt6_len(opt))); |
| } |
| } |
| |
| 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) |
| { |
| int clid_len = state->clid_len; |
| |
| /* avoid buffer overflow */ |
| if (clid_len > 100) |
| clid_len = 100; |
| |
| print_mac(daemon->namebuff, state->clid, clid_len); |
| |
| if (addr) |
| { |
| inet_ntop(AF_INET6, addr, daemon->dhcp_buff2, 255); |
| strcat(daemon->dhcp_buff2, " "); |
| } |
| else |
| daemon->dhcp_buff2[0] = 0; |
| |
| if(option_bool(OPT_LOG_OPTS)) |
| my_syslog(MS_DHCP | LOG_INFO, "%u %s(%s) %s%s %s", |
| state->xid, |
| type, |
| state->iface_name, |
| daemon->dhcp_buff2, |
| daemon->namebuff, |
| string ? string : ""); |
| else |
| my_syslog(MS_DHCP | LOG_INFO, "%s(%s) %s%s %s", |
| type, |
| state->iface_name, |
| daemon->dhcp_buff2, |
| daemon->namebuff, |
| string ? string : ""); |
| } |
| |
| static void *opt6_find (void *opts, void *end, unsigned int search, unsigned int minsize) |
| { |
| u16 opt, opt_len; |
| void *start; |
| |
| if (!opts) |
| return NULL; |
| |
| while (1) |
| { |
| if (end - opts < 4) |
| return NULL; |
| |
| start = opts; |
| GETSHORT(opt, opts); |
| GETSHORT(opt_len, opts); |
| |
| if (opt_len > (end - opts)) |
| return NULL; |
| |
| if (opt == search && (opt_len >= minsize)) |
| return start; |
| |
| opts += opt_len; |
| } |
| } |
| |
| static void *opt6_next(void *opts, void *end) |
| { |
| u16 opt_len; |
| |
| if (end - opts < 4) |
| return NULL; |
| |
| opts += 2; |
| GETSHORT(opt_len, opts); |
| |
| if (opt_len >= (end - opts)) |
| return NULL; |
| |
| return opts + opt_len; |
| } |
| |
| static unsigned int opt6_uint(unsigned char *opt, int offset, int size) |
| { |
| /* this worries about unaligned data and byte order */ |
| unsigned int ret = 0; |
| int i; |
| unsigned char *p = opt6_ptr(opt, offset); |
| |
| for (i = 0; i < size; i++) |
| ret = (ret << 8) | *p++; |
| |
| 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 |