#define DHCPLEASEQUERY		13

#define DHCPLEASEKNOWN		14

#define DHCPLEASEUNKNOWN	15

#define DHCPLEASEACTIVE		16

#define DHCPUNIMPLEMENTED	17

void dhcpleasequery PROTO ((struct packet *, int));

	      case DHCPLEASEACTIVE:

	      case DHCPLEASEKNOWN:

	      case DHCPLEASEUNKNOWN:

	      case DHCPLEASEQUERY:

		dhcpleasequery(packet, ms_nulltp);

		log_info("incoming dhcp leased query");

		break;

#include "dhcpd.h"

void dhcpleasequery (packet, ms_nulltp)

struct packet *packet;

int ms_nulltp;

{

  //printf("Received LEASEQUERY message\n");

  struct lease *lease = (struct lease *)0;

  struct iaddr cip;

  struct sockaddr_in to;

  //unsigned packet_length;

  unsigned char dhcpMsgType;

  struct dhcp_packet *raw = packet -> raw;

  struct option_state *options = (struct option_state *)0;

  struct option_cache *oc = (struct option_cache *)0;

  struct data_string prl;

  uint leaseTime;

  option_state_allocate (&options, MDL);

  cip.len = sizeof packet -> raw -> ciaddr;

  memcpy (cip.iabuf, &packet -> raw -> ciaddr,

  sizeof packet -> raw -> ciaddr);

  //TODO if IP is all zeros, then set dhcp message type to DHCPUNIMPLEMENTED

  find_lease_by_ip_addr (&lease, cip, MDL);

  if (!lease) {

    //printf("No lease found.\n");

    dhcpMsgType = DHCPNAK;

  } else {

    if(lease -> binding_state == FTS_ACTIVE) {

      dhcpMsgType = DHCPACK;

    } else {

      dhcpMsgType = DHCPNAK;

    }

    //printf("Lease was found.\n");

    /*

    char * pch = lease -> hardware_addr.hbuf;

    printf("MAC addr (len=%d): %02x:%02x:%02x:%02x:%02x:%02x\n",

   lease -> hardware_addr.hlen, pch[1], pch[2], pch[3], pch[4],

pch[5], pch[6]);

    printf("Lease has agent options: %s\n", (lease -> agent_options ? "yes"

: "no"));

    printf("Lease ends at %s\n", ctime(&(lease -> ends)));

    */

    // Set the hardware address fields

    memcpy (packet -> raw -> chaddr,

    &lease -> hardware_addr.hbuf [1], sizeof packet -> raw -> chaddr);

    packet -> raw -> hlen = lease -> hardware_addr.hlen - 1;

    packet -> raw -> htype = lease -> hardware_addr.hbuf [0];

    // Set lease time option

    if(dhcpMsgType == DHCPACK && lease -> ends > cur_time) {

      if (!option_cache_allocate (&oc, MDL)) {

log_error ("No memory for lease time option.");

option_state_dereference (&options, MDL);

return;

      }

      //printf("Current Time is %s\n", ctime(&cur_time));

      leaseTime = htonl(lease -> ends - cur_time);

      if (!make_const_data (&oc -> expression, (char*)&leaseTime, sizeof

leaseTime, 0, 0, MDL)) {

log_error ("No memory for expr_const expression.");

option_cache_dereference (&oc, MDL);

option_state_dereference (&options, MDL);

return;

      }

      oc -> option = dhcp_universe.options [DHO_DHCP_LEASE_TIME];

      save_option (&dhcp_universe, options, oc);

      option_cache_dereference (&oc, MDL);

    }

    // Set the relay agent info.

    if(lease -> agent_options) {

      pair p;

      int len = 0;

      char agent_options[255];

      for (p = lease -> agent_options -> first; p; p = p -> cdr) {

oc = (struct option_cache *)p -> car;

if (oc -> data.len) {

  memcpy(&agent_options[len], (char*)&oc->option->code, 1);

  memcpy(&agent_options[len+1], (char*)&oc->data.len, 1);

  memcpy(&agent_options[len+2], oc->data.data, oc->data.len);

  len += oc -> data.len + 2;

}

      }

      oc = (struct option_cache *)0;

      if (!option_cache_allocate (&oc, MDL)) {

log_error ("No memory for lease time option.");

option_state_dereference (&options, MDL);

return;

      }

      if (!make_const_data (&oc -> expression, (char*)&agent_options, len,

0, 0, MDL)) {

log_error ("No memory for expr_const expression.");

option_cache_dereference (&oc, MDL);

option_state_dereference (&options, MDL);

return;

      }

      oc -> option = dhcp_universe.options [DHO_DHCP_AGENT_OPTIONS];

      save_option(&dhcp_universe, options, oc);

      option_cache_dereference (&oc, MDL);

    }

  }

  // Set the message type

  packet -> raw -> op = BOOTREPLY;

  // Set dhcp message type

  if (!option_cache_allocate (&oc, MDL)) {

    log_error ("No memory for dhcp message type.");

    option_state_dereference (&options, MDL);

    return;

  }

  if (!make_const_data (&oc -> expression, &dhcpMsgType, sizeof dhcpMsgType,

0, 0, MDL)) {

      log_error ("No memory for expr_const expression.");

      option_cache_dereference (&oc, MDL);

      option_state_dereference (&options, MDL);

      return;

  }

  oc -> option = dhcp_universe.options [DHO_DHCP_MESSAGE_TYPE];

  save_option (&dhcp_universe, options, oc);

  option_cache_dereference (&oc, MDL);

#if 0

  memset (&prl, 0, sizeof prl);

  /* Use the parameter list from the scope if there is one. */

  oc = lookup_option (&dhcp_universe, options,

      DHO_DHCP_PARAMETER_REQUEST_LIST);

  /* Otherwise, if the client has provided a list of options

     that it wishes returned, use it to prioritize.  Otherwise,

     prioritize based on the default priority list. */

  if (!oc)

    oc = lookup_option (&dhcp_universe, packet -> options,

DHO_DHCP_PARAMETER_REQUEST_LIST);

  if (oc)

    evaluate_option_cache (&prl, packet, (struct lease *)0,

   (struct client_state *)0,

   packet -> options, options,

   &global_scope, oc, MDL);

  //printf("Parameter Request List length is %d: %d, %d\n", prl.len, prl.data[0], prl.data[1]);

  /* Set up the option buffer... */

  packet -> packet_length = cons_options (packet, raw, lease,

  (struct client_state *)0,

  0, packet -> options, options,

&global_scope,

  0, 0, 0,

  prl.len ? &prl : (struct

data_string *)0,

  (char *)0);

#endif

  /* Set up the option buffer... */

  packet -> packet_length = cons_options (packet, raw, lease,

  (struct client_state *)0,

  0, packet -> options, options,

&global_scope,

  0, 0, 0,

  (struct data_string *)0,

  (char *)0);

  option_state_dereference (&options, 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 must be sent to gateway address */

  if (packet -> raw -> giaddr.s_addr) {

    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; /* For debugging. */

    }

    if (fallback_interface) {

      send_packet (fallback_interface,

   (struct packet *)0,

   packet -> raw, packet -> packet_length,

   packet -> raw -> siaddr, &to,

   (struct hardware *)0);

    }

  }

}