-n [master]

[thirdparty/dhcp.git] / server / dhcpleasequery.c

/*
 * Copyright (C) 2011-2013 by Internet Systems Consortium, Inc. ("ISC")
 * Copyright (C) 2006-2007,2009 by Internet Systems Consortium, Inc. ("ISC")
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "dhcpd.h"

/*
 * TODO: RFC4388 specifies that the server SHOULD return the same
 *       options it would for a DHCREQUEST message, if no Parameter
 *       Request List option (option 55) is passed. We do not do that.
 *
 * TODO: RFC4388 specifies the creation of a "non-sensitive options"
 *       configuration list, and that these SHOULD be returned. We
 *       have no such list.
 *
 * TODO: RFC4388 says the server SHOULD use RFC3118, "Authentication
 *       for DHCP Messages".
 *
 * TODO: RFC4388 specifies that you SHOULD insure that you cannot be
 *       DoS'ed by DHCPLEASEQUERY message.
 */

/* 
 * If you query by hardware address or by client ID, then you may have
 * more than one IP address for your query argument. We need to do two
 * things:
 *
 *   1. Find the most recent lease.
 *   2. Find all additional IP addresses for the query argument.
 *
 * We do this by looking through all of the leases associated with a
 * given hardware address or client ID. We use the cltt (client last
 * transaction time) of the lease, which only has a resolution of one
 * second, so we might not actually give the very latest IP.
 */

static struct lease*
next_hw(const struct lease *lease) {
        /* INSIST(lease != NULL); */
        return lease->n_hw;
}

static struct lease*
next_uid(const struct lease *lease) {
        /* INSIST(lease != NULL); */
        return lease->n_uid;
}

void
get_newest_lease(struct lease **retval,
                 struct lease *lease,
                 struct lease *(*next)(const struct lease *)) {

        struct lease *p;
        struct lease *newest;

        /* INSIST(newest != NULL); */
        /* INSIST(next != NULL); */

        *retval = NULL;

        if (lease == NULL) {
                return;
        }

        newest = lease;
        for (p=next(lease); p != NULL; p=next(p)) {
                if (newest->binding_state == FTS_ACTIVE) {
                        if ((p->binding_state == FTS_ACTIVE) && 
                        (p->cltt > newest->cltt)) {
                                newest = p;
                        }
                } else {
                        if (p->ends > newest->ends) {
                                newest = p;
                        }
                }
        }

        lease_reference(retval, newest, MDL);
}

static int
get_associated_ips(const struct lease *lease,
                   struct lease *(*next)(const struct lease *), 
                   const struct lease *newest,
                   u_int32_t *associated_ips,
                   unsigned int associated_ips_size) {

        const struct lease *p;
        int cnt;

        /* INSIST(next != NULL); */
        /* INSIST(associated_ips != NULL); */

        if (lease == NULL) {
                return 0;
        }

        cnt = 0;
        for (p=lease; p != NULL; p=next(p)) {
                if ((p->binding_state == FTS_ACTIVE) && (p != newest)) {
                        if (cnt < associated_ips_size) {
                                memcpy(&associated_ips[cnt],
                                       p->ip_addr.iabuf,
                                       sizeof(associated_ips[cnt]));
                        }
                        cnt++;
                }
        }
        return cnt;
}


void 
dhcpleasequery(struct packet *packet, int ms_nulltp) {
        char msgbuf[256];
        char dbg_info[128];
        struct iaddr cip;
        struct iaddr gip;
        struct data_string uid;
        struct hardware h;
        struct lease *tmp_lease;
        struct lease *lease;
        int want_associated_ip;
        int assoc_ip_cnt;
        u_int32_t assoc_ips[40];  /* XXXSK: arbitrary maximum number of IPs */
        const int nassoc_ips = sizeof(assoc_ips) / sizeof(assoc_ips[0]);

        unsigned char dhcpMsgType;
        const char *dhcp_msg_type_name;
        struct subnet *subnet;
        struct group *relay_group;
        struct option_state *options;
        struct option_cache *oc;
        int allow_leasequery;
        int ignorep;
        u_int32_t lease_duration;
        u_int32_t time_renewal;
        u_int32_t time_rebinding;
        u_int32_t time_expiry;
        u_int32_t client_last_transaction_time;
        struct sockaddr_in to;
        struct in_addr siaddr;
        struct data_string prl;
        struct data_string *prl_ptr;

        int i;
        struct interface_info *interface;

        /* INSIST(packet != NULL); */

        /*
         * Prepare log information.
         */
        snprintf(msgbuf, sizeof(msgbuf), 
                "DHCPLEASEQUERY from %s", inet_ntoa(packet->raw->giaddr));

        /* 
         * We can't reply if there is no giaddr field.
         */
        if (!packet->raw->giaddr.s_addr) {
                log_info("%s: missing giaddr, ciaddr is %s, no reply sent", 
                         msgbuf, inet_ntoa(packet->raw->ciaddr));
                return;
        }

        /* 
         * Initially we use the 'giaddr' subnet options scope to determine if
         * the giaddr-identified relay agent is permitted to perform a
         * leasequery.  The subnet is not required, and may be omitted, in
         * which case we are essentially interrogating the root options class
         * to find a globally permit.
         */
        gip.len = sizeof(packet->raw->giaddr);
        memcpy(gip.iabuf, &packet->raw->giaddr, sizeof(packet->raw->giaddr));

        subnet = NULL;
        find_subnet(&subnet, gip, MDL);
        if (subnet != NULL)
                relay_group = subnet->group;
        else
                relay_group = root_group;

        subnet_dereference(&subnet, MDL);

        options = NULL;
        if (!option_state_allocate(&options, MDL)) {
                log_error("No memory for option state.");
                log_info("%s: out of memory, no reply sent", msgbuf);
                return;
        }

        execute_statements_in_scope(NULL, packet, NULL, NULL, packet->options,
                                    options, &global_scope, relay_group,
                                    NULL, NULL);

        for (i=packet->class_count-1; i>=0; i--) {
                execute_statements_in_scope(NULL, packet, NULL, NULL,
                                            packet->options, options,
                                            &global_scope,
                                            packet->classes[i]->group,
                                            relay_group, NULL);
        }

        /* 
         * Because LEASEQUERY has some privacy concerns, default to deny.
         */
        allow_leasequery = 0;

        /*
         * See if we are authorized to do LEASEQUERY.
         */
        oc = lookup_option(&server_universe, options, SV_LEASEQUERY);
        if (oc != NULL) {
                allow_leasequery = evaluate_boolean_option_cache(&ignorep,
                                         packet, NULL, NULL, packet->options,
                                         options, &global_scope, oc, MDL);
        }

        if (!allow_leasequery) {
                log_info("%s: LEASEQUERY not allowed, query ignored", msgbuf);
                option_state_dereference(&options, MDL);
                return;
        }


        /* 
         * Copy out the client IP address.
         */
        cip.len = sizeof(packet->raw->ciaddr);
        memcpy(cip.iabuf, &packet->raw->ciaddr, sizeof(packet->raw->ciaddr));

        /* 
         * If the client IP address is valid (not all zero), then we 
         * are looking for information about that IP address.
         */
        assoc_ip_cnt = 0;
        lease = tmp_lease = NULL;
        if (memcmp(cip.iabuf, "\0\0\0", 4)) {

                want_associated_ip = 0;

                snprintf(dbg_info, sizeof(dbg_info), "IP %s", piaddr(cip));
                find_lease_by_ip_addr(&lease, cip, MDL);


        } else {

                want_associated_ip = 1;

                /*
                 * If the client IP address is all zero, then we will
                 * either look up by the client identifier (if we have
                 * one), or by the MAC address.
                 */

                memset(&uid, 0, sizeof(uid));
                if (get_option(&uid, 
                               &dhcp_universe,
                               packet,
                               NULL,
                               NULL,
                               packet->options,
                               NULL,
                               packet->options, 
                               &global_scope,
                               DHO_DHCP_CLIENT_IDENTIFIER,
                               MDL)) {

                        snprintf(dbg_info, 
                                 sizeof(dbg_info), 
                                 "client-id %s",
                                 print_hex_1(uid.len, uid.data, 60));

                        find_lease_by_uid(&tmp_lease, uid.data, uid.len, MDL);
                        data_string_forget(&uid, MDL);
                        get_newest_lease(&lease, tmp_lease, next_uid);
                        assoc_ip_cnt = get_associated_ips(tmp_lease,
                                                          next_uid, 
                                                          lease,
                                                          assoc_ips, 
                                                          nassoc_ips);

                } else {

                        if (packet->raw->hlen+1 > sizeof(h.hbuf)) {
                                log_info("%s: hardware length too long, "
                                         "no reply sent", msgbuf);
                                option_state_dereference(&options, MDL);
                                return;
                        }

                        h.hlen = packet->raw->hlen + 1;
                        h.hbuf[0] = packet->raw->htype;
                        memcpy(&h.hbuf[1], 
                               packet->raw->chaddr, 
                               packet->raw->hlen);

                        snprintf(dbg_info, 
                                 sizeof(dbg_info), 
                                 "MAC address %s",
                                 print_hw_addr(h.hbuf[0], 
                                               h.hlen - 1, 
                                               &h.hbuf[1]));

                        find_lease_by_hw_addr(&tmp_lease, h.hbuf, h.hlen, MDL);
                        get_newest_lease(&lease, tmp_lease, next_hw);
                        assoc_ip_cnt = get_associated_ips(tmp_lease,
                                                          next_hw, 
                                                          lease,
                                                          assoc_ips, 
                                                          nassoc_ips);

                }

                lease_dereference(&tmp_lease, MDL);

                if (lease != NULL) {
                        memcpy(&packet->raw->ciaddr, 
                               lease->ip_addr.iabuf,
                               sizeof(packet->raw->ciaddr));
                }

                /*
                 * Log if we have too many IP addresses associated
                 * with this client.
                 */
                if (want_associated_ip && (assoc_ip_cnt > nassoc_ips)) {
                        log_info("%d IP addresses associated with %s, "
                                 "only %d sent in reply.",
                                 assoc_ip_cnt, dbg_info, nassoc_ips);
                }
        }

        /*
         * We now know the query target too, so can report this in 
         * our log message.
         */
        snprintf(msgbuf, sizeof(msgbuf), 
                "DHCPLEASEQUERY from %s for %s",
                inet_ntoa(packet->raw->giaddr), dbg_info);

        /*
         * Figure our our return type.
         */
        if (lease == NULL) {
                dhcpMsgType = DHCPLEASEUNKNOWN;
                dhcp_msg_type_name = "DHCPLEASEUNKNOWN";
        } else {
                if (lease->binding_state == FTS_ACTIVE) {
                        dhcpMsgType = DHCPLEASEACTIVE;
                        dhcp_msg_type_name = "DHCPLEASEACTIVE";
                } else {
                        dhcpMsgType = DHCPLEASEUNASSIGNED;
                        dhcp_msg_type_name = "DHCPLEASEUNASSIGNED";
                }
        }

        /* 
         * Set options that only make sense if we have an active lease.
         */

        if (dhcpMsgType == DHCPLEASEACTIVE)
        {
                /*
                 * RFC 4388 uses the PRL to request options for the agent to
                 * receive that are "about" the client.  It is confusing
                 * because in some cases it wants to know what was sent to
                 * the client (lease times, adjusted), and in others it wants
                 * to know information the client sent.  You're supposed to
                 * know this on a case-by-case basis.
                 *
                 * "Name servers", "domain name", and the like from the relay
                 * agent's scope seems less than useful.  Our options are to
                 * restart the option cache from the lease's best point of view
                 * (execute statements from the lease pool's group), or to
                 * simply restart the option cache from empty.
                 *
                 * I think restarting the option cache from empty best
                 * approaches RFC 4388's intent; specific options are included.
                 */
                option_state_dereference(&options, MDL);

                if (!option_state_allocate(&options, MDL)) {
                        log_error("%s: out of memory, no reply sent", msgbuf);
                        lease_dereference(&lease, MDL);
                        return;
                }

                /* 
                 * Set the hardware address fields.
                 */

                packet->raw->hlen = lease->hardware_addr.hlen - 1;
                packet->raw->htype = lease->hardware_addr.hbuf[0];
                memcpy(packet->raw->chaddr, 
                       &lease->hardware_addr.hbuf[1], 
                       sizeof(packet->raw->chaddr));

                /*
                 * Set client identifier option.
                 */
                if (lease->uid_len > 0) {
                        if (!add_option(options,
                                        DHO_DHCP_CLIENT_IDENTIFIER,
                                        lease->uid,
                                        lease->uid_len)) {
                                option_state_dereference(&options, MDL);
                                lease_dereference(&lease, MDL);
                                log_info("%s: out of memory, no reply sent",
                                         msgbuf);
                                return;
                        }
                }


                /*
                 * Calculate T1 and T2, the times when the client
                 * tries to extend its lease on its networking
                 * address.
                 * These seem to be hard-coded in ISC DHCP, to 0.5 and
                 * 0.875 of the lease time.
                 */

                lease_duration = lease->ends - lease->starts;
                time_renewal = lease->starts + 
                        (lease_duration / 2);
                time_rebinding = lease->starts + 
                        (lease_duration / 2) +
                        (lease_duration / 4) +
                        (lease_duration / 8);

                if (time_renewal > cur_time) {
                        time_renewal = htonl(time_renewal - cur_time);

                        if (!add_option(options, 
                                        DHO_DHCP_RENEWAL_TIME,
                                        &time_renewal, 
                                        sizeof(time_renewal))) {
                                option_state_dereference(&options, MDL);
                                lease_dereference(&lease, MDL);
                                log_info("%s: out of memory, no reply sent",
                                         msgbuf);
                                return;
                        }
                }

                if (time_rebinding > cur_time) {
                        time_rebinding = htonl(time_rebinding - cur_time);

                        if (!add_option(options, 
                                        DHO_DHCP_REBINDING_TIME,
                                        &time_rebinding, 
                                        sizeof(time_rebinding))) {
                                option_state_dereference(&options, MDL);
                                lease_dereference(&lease, MDL);
                                log_info("%s: out of memory, no reply sent",
                                         msgbuf);
                                return;
                        }
                }

                if (lease->ends > cur_time) {
                        time_expiry = htonl(lease->ends - cur_time);

                        if (!add_option(options, 
                                        DHO_DHCP_LEASE_TIME,
                                        &time_expiry, 
                                        sizeof(time_expiry))) {
                                option_state_dereference(&options, MDL);
                                lease_dereference(&lease, MDL);
                                log_info("%s: out of memory, no reply sent",
                                         msgbuf);
                                return;
                        }
                }

                /* Supply the Vendor-Class-Identifier. */
                if (lease->scope != NULL) {
                        struct data_string vendor_class;

                        memset(&vendor_class, 0, sizeof(vendor_class));

                        if (find_bound_string(&vendor_class, lease->scope,
                                              "vendor-class-identifier")) {
                                if (!add_option(options,
                                                DHO_VENDOR_CLASS_IDENTIFIER,
                                                (void *)vendor_class.data,
                                                vendor_class.len)) {
                                        option_state_dereference(&options,
                                                                 MDL);
                                        lease_dereference(&lease, MDL);
                                        log_error("%s: error adding vendor "
                                                  "class identifier, no reply "
                                                  "sent", msgbuf);
                                        data_string_forget(&vendor_class, MDL);
                                        return;
                                }
                                data_string_forget(&vendor_class, MDL);
                        }
                }

                /*
                 * Set the relay agent info.
                 *
                 * Note that because agent info is appended without regard
                 * to the PRL in cons_options(), this will be sent as the
                 * last option in the packet whether it is listed on PRL or
                 * not.
                 */

                if (lease->agent_options != NULL) {
                        int idx = agent_universe.index;
                        struct option_chain_head **tmp1 = 
                                (struct option_chain_head **)
                                &(options->universes[idx]);
                                struct option_chain_head *tmp2 = 
                                (struct option_chain_head *)
                                lease->agent_options;

                        option_chain_head_reference(tmp1, tmp2, MDL);
                }

                /* 
                 * Set the client last transaction time.
                 * We check to make sure we have a timestamp. For
                 * lease files that were saved before running a 
                 * timestamp-aware version of the server, this may
                 * not be set.
                 */

                if (lease->cltt != MIN_TIME) {
                        if (cur_time > lease->cltt) {
                                client_last_transaction_time = 
                                        htonl(cur_time - lease->cltt);
                        } else {
                                client_last_transaction_time = htonl(0);
                        }
                        if (!add_option(options, 
                                        DHO_CLIENT_LAST_TRANSACTION_TIME,
                                        &client_last_transaction_time,
                                        sizeof(client_last_transaction_time))) {
                                option_state_dereference(&options, MDL);
                                lease_dereference(&lease, MDL);
                                log_info("%s: out of memory, no reply sent",
                                         msgbuf);
                                return;
                        }
                }

                /*
                 * Set associated IPs, if requested and there are some.
                 */
                if (want_associated_ip && (assoc_ip_cnt > 0)) {
                        if (!add_option(options, 
                                        DHO_ASSOCIATED_IP,
                                        assoc_ips,
                                        assoc_ip_cnt * sizeof(assoc_ips[0]))) {
                                option_state_dereference(&options, MDL);
                                lease_dereference(&lease, MDL);
                                log_info("%s: out of memory, no reply sent",
                                         msgbuf);
                                return;
                        }
                }
        }

        /* 
         * Set the message type.
         */

        packet->raw->op = BOOTREPLY;

        /*
         * Set DHCP message type.
         */
        if (!add_option(options, 
                        DHO_DHCP_MESSAGE_TYPE,
                        &dhcpMsgType, 
                        sizeof(dhcpMsgType))) {
                option_state_dereference(&options, MDL);
                lease_dereference(&lease, MDL);
                log_info("%s: error adding option, no reply sent", msgbuf);
                return;
        }

        /*
         * Log the message we've received.
         */
        log_info("%s", msgbuf);

        /*
         * Figure out which address to use to send from.
         */
        get_server_source_address(&siaddr, options, options, packet);

        /* 
         * Set up the option buffer.
         */

        memset(&prl, 0, sizeof(prl));
        oc = lookup_option(&dhcp_universe, options, 
                           DHO_DHCP_PARAMETER_REQUEST_LIST);
        if (oc != NULL) {
                evaluate_option_cache(&prl, 
                                      packet, 
                                      NULL,
                                      NULL,
                                      packet->options,
                                      options,
                                      &global_scope,
                                      oc,
                                      MDL);
        }
        if (prl.len > 0) {
                prl_ptr = &prl;
        } else {
                prl_ptr = NULL;
        }

        packet->packet_length = cons_options(packet, 
                                             packet->raw, 
                                             lease,
                                             NULL,
                                             0,
                                             packet->options,
                                             options,
                                             &global_scope,
                                             0,
                                             0,
                                             0, 
                                             prl_ptr,
                                             NULL);

        data_string_forget(&prl, MDL);  /* SK: safe, even if empty */
        option_state_dereference(&options, MDL);
        lease_dereference(&lease, MDL);

        to.sin_family = AF_INET;
#ifdef HAVE_SA_LEN
        to.sin_len = sizeof(to);
#endif
        memset(to.sin_zero, 0, sizeof(to.sin_zero));

        /* 
         * Leasequery packets are be sent to the gateway address.
         */
        to.sin_addr = packet->raw->giaddr;
        if (packet->raw->giaddr.s_addr != htonl(INADDR_LOOPBACK)) {
                to.sin_port = local_port;
        } else {
                to.sin_port = remote_port; /* XXXSK: For debugging. */
        }

        /* 
         * The fallback_interface lets us send with a real IP
         * address. The packet interface sends from all-zeros.
         */
        if (fallback_interface != NULL) {
                interface = fallback_interface;
        } else {
                interface = packet->interface;
        }

        /*
         * Report what we're sending.
         */
        log_info("%s to %s for %s (%d associated IPs)",
                dhcp_msg_type_name, 
                inet_ntoa(to.sin_addr), dbg_info, assoc_ip_cnt);

        send_packet(interface,
                    NULL,
                    packet->raw, 
                    packet->packet_length,
                    siaddr,
                    &to,
                    NULL);
}

#ifdef DHCPv6

/*
 * TODO: RFC5007 query-by-clientid.
 *
 * TODO: RFC5007 look at the pools according to the link-address.
 *
 * TODO: get fixed leases too.
 *
 * TODO: RFC5007 ORO in query-options.
 *
 * TODO: RFC5007 lq-relay-data.
 *
 * TODO: RFC5007 lq-client-link.
 *
 * Note: the code is still nearly compliant and usable for the target
 * case with these missing features!
 */

/*
 * The structure to handle a leasequery.
 */
struct lq6_state {
        struct packet *packet;
        struct data_string client_id;
        struct data_string server_id;
        struct data_string lq_query;
        uint8_t query_type;
        struct in6_addr link_addr;
        struct option_state *query_opts;

        struct option_state *reply_opts;
        unsigned cursor;
        union reply_buffer {
                unsigned char data[65536];
                struct dhcpv6_packet reply;
        } buf;
};

/*
 * Options that we want to send.
 */
static const int required_opts_lq[] = {
        D6O_CLIENTID,
        D6O_SERVERID,
        D6O_STATUS_CODE,
        D6O_CLIENT_DATA,
        D6O_LQ_RELAY_DATA,
        D6O_LQ_CLIENT_LINK,
        0
};
static const int required_opt_CLIENT_DATA[] = {
        D6O_CLIENTID,
        D6O_IAADDR,
        D6O_IAPREFIX,
        D6O_CLT_TIME,
        0
};

/*
 * Get the lq-query option from the packet.
 */
static isc_result_t
get_lq_query(struct lq6_state *lq)
{
        struct data_string *lq_query = &lq->lq_query;
        struct packet *packet = lq->packet;
        struct option_cache *oc;

        /*
         * Verify our lq_query structure is empty.
         */
        if ((lq_query->data != NULL) || (lq_query->len != 0)) {
                return DHCP_R_INVALIDARG;
        }

        oc = lookup_option(&dhcpv6_universe, packet->options, D6O_LQ_QUERY);
        if (oc == NULL) {
                return ISC_R_NOTFOUND;
        }

        if (!evaluate_option_cache(lq_query, packet, NULL, NULL,
                                   packet->options, NULL,
                                   &global_scope, oc, MDL)) {
                return ISC_R_FAILURE;
        }

        return ISC_R_SUCCESS;
}

/*
 * Message validation, RFC 5007 section 4.2.1:
 *  dhcpv6.c:valid_client_msg() - unicast + lq-query option.
 */
static int
valid_query_msg(struct lq6_state *lq) {
        struct packet *packet = lq->packet;
        int ret_val = 0;
        struct option_cache *oc;

        /* INSIST((lq != NULL) || (packet != NULL)); */

        switch (get_client_id(packet, &lq->client_id)) {
                case ISC_R_SUCCESS:
                        break;
                case ISC_R_NOTFOUND:
                        log_debug("Discarding %s from %s; "
                                  "client identifier missing", 
                                  dhcpv6_type_names[packet->dhcpv6_msg_type],
                                  piaddr(packet->client_addr));
                        goto exit;
                default:
                        log_error("Error processing %s from %s; "
                                  "unable to evaluate Client Identifier",
                                  dhcpv6_type_names[packet->dhcpv6_msg_type],
                                  piaddr(packet->client_addr));
                        goto exit;
        }

        oc = lookup_option(&dhcpv6_universe, packet->options, D6O_SERVERID);
        if (oc != NULL) {
                if (evaluate_option_cache(&lq->server_id, packet, NULL, NULL,
                                          packet->options, NULL, 
                                          &global_scope, oc, MDL)) {
                        log_debug("Discarding %s from %s; " 
                                  "server identifier found "
                                  "(CLIENTID %s, SERVERID %s)", 
                                  dhcpv6_type_names[packet->dhcpv6_msg_type],
                                  piaddr(packet->client_addr),
                                  print_hex_1(lq->client_id.len, 
                                              lq->client_id.data, 60),
                                  print_hex_2(lq->server_id.len,
                                              lq->server_id.data, 60));
                } else {
                        log_debug("Discarding %s from %s; " 
                                  "server identifier found "
                                  "(CLIENTID %s)", 
                                  dhcpv6_type_names[packet->dhcpv6_msg_type],
                                  print_hex_1(lq->client_id.len, 
                                              lq->client_id.data, 60),
                                  piaddr(packet->client_addr));
                }
                goto exit;
        }

        switch (get_lq_query(lq)) {
                case ISC_R_SUCCESS:
                        break;
                case ISC_R_NOTFOUND:
                        log_debug("Discarding %s from %s; lq-query missing",
                                  dhcpv6_type_names[packet->dhcpv6_msg_type],
                                  piaddr(packet->client_addr));
                        goto exit;
                default:
                        log_error("Error processing %s from %s; "
                                  "unable to evaluate LQ-Query",
                                  dhcpv6_type_names[packet->dhcpv6_msg_type],
                                  piaddr(packet->client_addr));
                        goto exit;
        }

        /* looks good */
        ret_val = 1;

exit:
        if (!ret_val) {
                if (lq->client_id.len > 0) {
                        data_string_forget(&lq->client_id, MDL);
                }
                if (lq->server_id.len > 0) {
                        data_string_forget(&lq->server_id, MDL);
                }
                if (lq->lq_query.len > 0) {
                        data_string_forget(&lq->lq_query, MDL);
                }
        }
        return ret_val;
}

/*
 * Set an error in a status-code option (from set_status_code).
 */
static int
set_error(struct lq6_state *lq, u_int16_t code, const char *message) {
        struct data_string d;
        int ret_val;

        memset(&d, 0, sizeof(d));
        d.len = sizeof(code) + strlen(message);
        if (!buffer_allocate(&d.buffer, d.len, MDL)) {
                log_fatal("set_error: no memory for status code.");
        }
        d.data = d.buffer->data;
        putUShort(d.buffer->data, code);
        memcpy(d.buffer->data + sizeof(code), message, d.len - sizeof(code));
        if (!save_option_buffer(&dhcpv6_universe, lq->reply_opts,
                                d.buffer, (unsigned char *)d.data, d.len, 
                                D6O_STATUS_CODE, 0)) {
                log_error("set_error: error saving status code.");
                ret_val = 0;
        } else {
                ret_val = 1;
        }
        data_string_forget(&d, MDL);
        return ret_val;
}

/*
 * Process a by-address lease query.
 */
static int
process_lq_by_address(struct lq6_state *lq) {
        struct packet *packet = lq->packet;
        struct option_cache *oc;
        struct ipv6_pool *pool = NULL;
        struct data_string data;
        struct in6_addr addr;
        struct iasubopt *iaaddr = NULL;
        struct option_state *opt_state = NULL;
        u_int32_t lifetime;
        unsigned opt_cursor;
        int ret_val = 0;

        /*
         * Get the IAADDR.
         */
        oc = lookup_option(&dhcpv6_universe, lq->query_opts, D6O_IAADDR);
        if (oc == NULL) {
                if (!set_error(lq, STATUS_MalformedQuery,
                               "No OPTION_IAADDR.")) {
                        log_error("process_lq_by_address: unable "
                                  "to set MalformedQuery status code.");
                        return 0;
                }
                return 1;
        }
        memset(&data, 0, sizeof(data));
        if (!evaluate_option_cache(&data, packet,
                                   NULL, NULL,
                                   lq->query_opts, NULL,
                                   &global_scope, oc, MDL) ||
            (data.len < IAADDR_OFFSET)) {
                log_error("process_lq_by_address: error evaluating IAADDR.");
                goto exit;
        }
        memcpy(&addr, data.data, sizeof(addr));
        data_string_forget(&data, MDL);

        /*
         * Find the lease.
         * Note the RFC 5007 says to use the link-address to find the link
         * or the ia-aadr when it is :: but in any case the ia-addr has
         * to be on the link, so we ignore the link-address here.
         */
        if (find_ipv6_pool(&pool, D6O_IA_NA, &addr) != ISC_R_SUCCESS) {
                if (!set_error(lq, STATUS_NotConfigured,
                               "Address not in a pool.")) {
                        log_error("process_lq_by_address: unable "
                                  "to set NotConfigured status code.");
                        goto exit;
                }
                ret_val = 1;
                goto exit;
        }
        if (iasubopt_hash_lookup(&iaaddr, pool->leases, &addr,
                                 sizeof(addr), MDL) == 0) {
                ret_val = 1;
                goto exit;
        }
        if ((iaaddr == NULL) || (iaaddr->state != FTS_ACTIVE) ||
            (iaaddr->ia == NULL) || (iaaddr->ia->iaid_duid.len <= 4)) {
                ret_val = 1;
                goto exit;
        }

        /*
         * Build the client-data option (with client-id, ia-addr and clt-time).
         */
        if (!option_state_allocate(&opt_state, MDL)) {
                log_error("process_lq_by_address: "
                          "no memory for option state.");
                goto exit;
        }

        data_string_copy(&data, &iaaddr->ia->iaid_duid, MDL);
        data.data += 4;
        data.len -= 4;
        if (!save_option_buffer(&dhcpv6_universe, opt_state,
                                NULL, (unsigned char *)data.data, data.len,
                                D6O_CLIENTID, 0)) {
                log_error("process_lq_by_address: error saving client ID.");
                goto exit;
        }
        data_string_forget(&data, MDL);

        data.len = IAADDR_OFFSET;
        if (!buffer_allocate(&data.buffer, data.len, MDL)) {
                log_error("process_lq_by_address: no memory for ia-addr.");
                goto exit;
        }
        data.data = data.buffer->data;
        memcpy(data.buffer->data, &iaaddr->addr, 16);
        lifetime = iaaddr->prefer;
        putULong(data.buffer->data + 16, lifetime);
        lifetime = iaaddr->valid;
        putULong(data.buffer->data + 20, lifetime);
        if (!save_option_buffer(&dhcpv6_universe, opt_state,
                                NULL, (unsigned char *)data.data, data.len,
                                D6O_IAADDR, 0)) {
                log_error("process_lq_by_address: error saving ia-addr.");
                goto exit;
        }
        data_string_forget(&data, MDL);

        lifetime = htonl(iaaddr->ia->cltt);
        if (!save_option_buffer(&dhcpv6_universe, opt_state,
                                NULL, (unsigned char *)&lifetime, 4,
                                D6O_CLT_TIME, 0)) {
                log_error("process_lq_by_address: error saving clt time.");
                goto exit;
        }

        /*
         * Store the client-data option.
         */
        opt_cursor = lq->cursor;
        putUShort(lq->buf.data + lq->cursor, (unsigned)D6O_CLIENT_DATA);
        lq->cursor += 2;
        /* Skip option length. */
        lq->cursor += 2;

        lq->cursor += store_options6((char *)lq->buf.data + lq->cursor,
                                     sizeof(lq->buf) - lq->cursor,
                                     opt_state, lq->packet,
                                     required_opt_CLIENT_DATA, NULL);
        /* Reset the length. */
        putUShort(lq->buf.data + opt_cursor + 2,
                  lq->cursor - (opt_cursor + 4));

        /* Done. */
        ret_val = 1;

     exit:
        if (data.data != NULL)
                data_string_forget(&data, MDL);
        if (pool != NULL)
                ipv6_pool_dereference(&pool, MDL);
        if (iaaddr != NULL)
                iasubopt_dereference(&iaaddr, MDL);
        if (opt_state != NULL)
                option_state_dereference(&opt_state, MDL);
        return ret_val;
}


/*
 * Process a lease query.
 */
void
dhcpv6_leasequery(struct data_string *reply_ret, struct packet *packet) {
        static struct lq6_state lq;
        struct option_cache *oc;
        int allow_lq;

        /*
         * Initialize the lease query state.
         */
        lq.packet = NULL;
        memset(&lq.client_id, 0, sizeof(lq.client_id));
        memset(&lq.server_id, 0, sizeof(lq.server_id));
        memset(&lq.lq_query, 0, sizeof(lq.lq_query));
        lq.query_opts = NULL;
        lq.reply_opts = NULL;
        packet_reference(&lq.packet, packet, MDL);

        /*
         * Validate our input.
         */
        if (!valid_query_msg(&lq)) {
                goto exit;
        }

        /*
         * Prepare our reply.
         */
        if (!option_state_allocate(&lq.reply_opts, MDL)) {
                log_error("dhcpv6_leasequery: no memory for option state.");
                goto exit;
        }
        execute_statements_in_scope(NULL, lq.packet, NULL, NULL,
                                    lq.packet->options, lq.reply_opts,
                                    &global_scope, root_group, NULL, NULL);

        lq.buf.reply.msg_type = DHCPV6_LEASEQUERY_REPLY;

        memcpy(lq.buf.reply.transaction_id,
               lq.packet->dhcpv6_transaction_id,
               sizeof(lq.buf.reply.transaction_id));

        /* 
         * Because LEASEQUERY has some privacy concerns, default to deny.
         */
        allow_lq = 0;

        /*
         * See if we are authorized to do LEASEQUERY.
         */
        oc = lookup_option(&server_universe, lq.reply_opts, SV_LEASEQUERY);
        if (oc != NULL) {
                allow_lq = evaluate_boolean_option_cache(NULL,
                                                         lq.packet,
                                                         NULL, NULL,
                                                         lq.packet->options,
                                                         lq.reply_opts,
                                                         &global_scope,
                                                         oc, MDL);
        }

        if (!allow_lq) {
                log_info("dhcpv6_leasequery: not allowed, query ignored.");
                goto exit;
        }
            
        /*
         * Same than transmission of REPLY message in RFC 3315:
         *  server-id
         *  client-id
         */

        oc = lookup_option(&dhcpv6_universe, lq.reply_opts, D6O_SERVERID);
        if (oc == NULL) {
                /* If not already in options, get from query then global. */
                if (lq.server_id.data == NULL)
                        copy_server_duid(&lq.server_id, MDL);
                if (!save_option_buffer(&dhcpv6_universe,
                                        lq.reply_opts,
                                        NULL,
                                        (unsigned char *)lq.server_id.data,
                                        lq.server_id.len, 
                                        D6O_SERVERID,
                                        0)) {
                        log_error("dhcpv6_leasequery: "
                                  "error saving server identifier.");
                        goto exit;
                }
        }

        if (!save_option_buffer(&dhcpv6_universe,
                                lq.reply_opts,
                                lq.client_id.buffer,
                                (unsigned char *)lq.client_id.data,
                                lq.client_id.len,
                                D6O_CLIENTID,
                                0)) {
                log_error("dhcpv6_leasequery: "
                          "error saving client identifier.");
                goto exit;
        }

        lq.cursor = 4;

        /*
         * Decode the lq-query option.
         */

        if (lq.lq_query.len <= LQ_QUERY_OFFSET) {
                if (!set_error(&lq, STATUS_MalformedQuery,
                               "OPTION_LQ_QUERY too short.")) {
                        log_error("dhcpv6_leasequery: unable "
                                  "to set MalformedQuery status code.");
                        goto exit;
                }
                goto done;
        }

        lq.query_type = lq.lq_query.data [0];
        memcpy(&lq.link_addr, lq.lq_query.data + 1, sizeof(lq.link_addr));
        switch (lq.query_type) {
                case LQ6QT_BY_ADDRESS:
                        break;
                case LQ6QT_BY_CLIENTID:
                        if (!set_error(&lq, STATUS_UnknownQueryType,
                                       "QUERY_BY_CLIENTID not supported.")) {
                                log_error("dhcpv6_leasequery: unable to "
                                          "set UnknownQueryType status code.");
                                goto exit;
                        }
                        goto done;
                default:
                        if (!set_error(&lq, STATUS_UnknownQueryType,
                                       "Unknown query-type.")) {
                                log_error("dhcpv6_leasequery: unable to "
                                          "set UnknownQueryType status code.");
                                goto exit;
                        }
                        goto done;
        }

        if (!option_state_allocate(&lq.query_opts, MDL)) {
                log_error("dhcpv6_leasequery: no memory for option state.");
                goto exit;
        }
        if (!parse_option_buffer(lq.query_opts,
                                 lq.lq_query.data + LQ_QUERY_OFFSET,
                                 lq.lq_query.len - LQ_QUERY_OFFSET,
                                 &dhcpv6_universe)) {
                log_error("dhcpv6_leasequery: error parsing query-options.");
                if (!set_error(&lq, STATUS_MalformedQuery,
                               "Bad query-options.")) {
                        log_error("dhcpv6_leasequery: unable "
                                  "to set MalformedQuery status code.");
                        goto exit;
                }
                goto done;
        }

        /* Do it. */
        if (!process_lq_by_address(&lq))
                goto exit;

      done:
        /* Store the options. */
        lq.cursor += store_options6((char *)lq.buf.data + lq.cursor,
                                    sizeof(lq.buf) - lq.cursor,
                                    lq.reply_opts,
                                    lq.packet,
                                    required_opts_lq,
                                    NULL);

        /* Return our reply to the caller. */
        reply_ret->len = lq.cursor;
        reply_ret->buffer = NULL;
        if (!buffer_allocate(&reply_ret->buffer, lq.cursor, MDL)) {
                log_fatal("dhcpv6_leasequery: no memory to store Reply.");
        }
        memcpy(reply_ret->buffer->data, lq.buf.data, lq.cursor);
        reply_ret->data = reply_ret->buffer->data;

      exit:
        /* Cleanup. */
        if (lq.packet != NULL)
                packet_dereference(&lq.packet, MDL);
        if (lq.client_id.data != NULL)
                data_string_forget(&lq.client_id, MDL);
        if (lq.server_id.data != NULL)
                data_string_forget(&lq.server_id, MDL);
        if (lq.lq_query.data != NULL)
                data_string_forget(&lq.lq_query, MDL);
        if (lq.query_opts != NULL)
                option_state_dereference(&lq.query_opts, MDL);
        if (lq.reply_opts != NULL)
                option_state_dereference(&lq.reply_opts, MDL);
}

#endif /* DHCPv6 */