networking/udhcp/serverpacket.c

   1 /* vi: set sw=4 ts=4: */
   2 /* serverpacket.c
   3  *
   4  * Construct and send DHCP server packets
   5  *
   6  * Russ Dill <Russ.Dill@asu.edu> July 2001
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include "common.h"
  24 #include "dhcpc.h"
  25 #include "dhcpd.h"
  26 #include "options.h"
  27
  28
  29 /* send a packet to giaddr using the kernel ip stack */
  30 static int send_packet_to_relay(struct dhcpMessage *payload)
  31 {
  32         DEBUG("Forwarding packet to relay");
  33
  34         return udhcp_send_kernel_packet(payload, server_config.server, SERVER_PORT,
  35                         payload->giaddr, SERVER_PORT);
  36 }
  37
  38
  39 /* send a packet to a specific arp address and ip address by creating our own ip packet */
  40 static int send_packet_to_client(struct dhcpMessage *payload, int force_broadcast)
  41 {
  42         const uint8_t *chaddr;
  43         uint32_t ciaddr;
  44
  45         if (force_broadcast) {
  46                 DEBUG("broadcasting packet to client (NAK)");
  47                 ciaddr = INADDR_BROADCAST;
  48                 chaddr = MAC_BCAST_ADDR;
  49         } else if (payload->ciaddr) {
  50                 DEBUG("unicasting packet to client ciaddr");
  51                 ciaddr = payload->ciaddr;
  52                 chaddr = payload->chaddr;
  53         } else if (ntohs(payload->flags) & BROADCAST_FLAG) {
  54                 DEBUG("broadcasting packet to client (requested)");
  55                 ciaddr = INADDR_BROADCAST;
  56                 chaddr = MAC_BCAST_ADDR;
  57         } else {
  58                 DEBUG("unicasting packet to client yiaddr");
  59                 ciaddr = payload->yiaddr;
  60                 chaddr = payload->chaddr;
  61         }
  62         return udhcp_send_raw_packet(payload, server_config.server, SERVER_PORT,
  63                         ciaddr, CLIENT_PORT, chaddr, server_config.ifindex);
  64 }
  65
  66
  67 /* send a dhcp packet, if force broadcast is set, the packet will be broadcast to the client */
  68 static int send_packet(struct dhcpMessage *payload, int force_broadcast)
  69 {
  70         if (payload->giaddr)
  71                 return send_packet_to_relay(payload);
  72         return send_packet_to_client(payload, force_broadcast);
  73 }
  74
  75
  76 static void init_packet(struct dhcpMessage *packet, struct dhcpMessage *oldpacket, char type)
  77 {
  78         udhcp_init_header(packet, type);
  79         packet->xid = oldpacket->xid;
  80         memcpy(packet->chaddr, oldpacket->chaddr, 16);
  81         packet->flags = oldpacket->flags;
  82         packet->giaddr = oldpacket->giaddr;
  83         packet->ciaddr = oldpacket->ciaddr;
  84         add_simple_option(packet->options, DHCP_SERVER_ID, server_config.server);
  85 }
  86
  87
  88 /* add in the bootp options */
  89 static void add_bootp_options(struct dhcpMessage *packet)
  90 {
  91         packet->siaddr = server_config.siaddr;
  92         if (server_config.sname)
  93                 strncpy((char*)packet->sname, server_config.sname, sizeof(packet->sname) - 1);
  94         if (server_config.boot_file)
  95                 strncpy((char*)packet->file, server_config.boot_file, sizeof(packet->file) - 1);
  96 }
  97
  98
  99 /* send a DHCP OFFER to a DHCP DISCOVER */
 100 int send_offer(struct dhcpMessage *oldpacket)
 101 {
 102         struct dhcpMessage packet;
 103         struct dhcpOfferedAddr *lease = NULL;
 104         uint32_t req_align, lease_time_align = server_config.lease;
 105         uint8_t *req, *lease_time;
 106         struct option_set *curr;
 107         struct in_addr addr;
 108
 109         uint32_t static_lease_ip;
 110
 111         init_packet(&packet, oldpacket, DHCPOFFER);
 112
 113         static_lease_ip = getIpByMac(server_config.static_leases, oldpacket->chaddr);
 114
 115         /* ADDME: if static, short circuit */
 116         if (!static_lease_ip) {
 117                 /* the client is in our lease/offered table */
 118                 lease = find_lease_by_chaddr(oldpacket->chaddr);
 119                 if (lease) {
 120                         if (!lease_expired(lease))
 121                                 lease_time_align = lease->expires - time(0);
 122                         packet.yiaddr = lease->yiaddr;
 123                 /* Or the client has a requested ip */
 124                 } else if ((req = get_option(oldpacket, DHCP_REQUESTED_IP))
 125                  /* Don't look here (ugly hackish thing to do) */
 126                  && memcpy(&req_align, req, 4)
 127                  /* and the ip is in the lease range */
 128                  && ntohl(req_align) >= server_config.start_ip
 129                  && ntohl(req_align) <= server_config.end_ip
 130                  && !static_lease_ip /* Check that its not a static lease */
 131                  /* and is not already taken/offered */
 132                  && (!(lease = find_lease_by_yiaddr(req_align))
 133                         /* or its taken, but expired */ /* ADDME: or maybe in here */
 134                         || lease_expired(lease))
 135                 ) {
 136                         packet.yiaddr = req_align; /* FIXME: oh my, is there a host using this IP? */
 137                         /* otherwise, find a free IP */
 138                 } else {
 139                         /* Is it a static lease? (No, because find_address skips static lease) */
 140                         packet.yiaddr = find_address(0);
 141                         /* try for an expired lease */
 142                         if (!packet.yiaddr)
 143                                 packet.yiaddr = find_address(1);
 144                 }
 145
 146                 if (!packet.yiaddr) {
 147                         bb_error_msg("no IP addresses to give - OFFER abandoned");
 148                         return -1;
 149                 }
 150                 if (!add_lease(packet.chaddr, packet.yiaddr, server_config.offer_time)) {
 151                         bb_error_msg("lease pool is full - OFFER abandoned");
 152                         return -1;
 153                 }
 154                 lease_time = get_option(oldpacket, DHCP_LEASE_TIME);
 155                 if (lease_time) {
 156                         memcpy(&lease_time_align, lease_time, 4);
 157                         lease_time_align = ntohl(lease_time_align);
 158                         if (lease_time_align > server_config.lease)
 159                                 lease_time_align = server_config.lease;
 160                 }
 161
 162                 /* Make sure we aren't just using the lease time from the previous offer */
 163                 if (lease_time_align < server_config.min_lease)
 164                         lease_time_align = server_config.lease;
 165                 /* ADDME: end of short circuit */
 166         } else {
 167                 /* It is a static lease... use it */
 168                 packet.yiaddr = static_lease_ip;
 169         }
 170
 171         add_simple_option(packet.options, DHCP_LEASE_TIME, htonl(lease_time_align));
 172
 173         curr = server_config.options;
 174         while (curr) {
 175                 if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
 176                         add_option_string(packet.options, curr->data);
 177                 curr = curr->next;
 178         }
 179
 180         add_bootp_options(&packet);
 181
 182         addr.s_addr = packet.yiaddr;
 183         bb_info_msg("Sending OFFER of %s", inet_ntoa(addr));
 184         return send_packet(&packet, 0);
 185 }
 186
 187
 188 int send_NAK(struct dhcpMessage *oldpacket)
 189 {
 190         struct dhcpMessage packet;
 191
 192         init_packet(&packet, oldpacket, DHCPNAK);
 193
 194         DEBUG("Sending NAK");
 195         return send_packet(&packet, 1);
 196 }
 197
 198
 199 int send_ACK(struct dhcpMessage *oldpacket, uint32_t yiaddr)
 200 {
 201         struct dhcpMessage packet;
 202         struct option_set *curr;
 203         uint8_t *lease_time;
 204         uint32_t lease_time_align = server_config.lease;
 205         struct in_addr addr;
 206
 207         init_packet(&packet, oldpacket, DHCPACK);
 208         packet.yiaddr = yiaddr;
 209
 210         lease_time = get_option(oldpacket, DHCP_LEASE_TIME);
 211         if (lease_time) {
 212                 memcpy(&lease_time_align, lease_time, 4);
 213                 lease_time_align = ntohl(lease_time_align);
 214                 if (lease_time_align > server_config.lease)
 215                         lease_time_align = server_config.lease;
 216                 else if (lease_time_align < server_config.min_lease)
 217                         lease_time_align = server_config.lease;
 218         }
 219
 220         add_simple_option(packet.options, DHCP_LEASE_TIME, htonl(lease_time_align));
 221
 222         curr = server_config.options;
 223         while (curr) {
 224                 if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
 225                         add_option_string(packet.options, curr->data);
 226                 curr = curr->next;
 227         }
 228
 229         add_bootp_options(&packet);
 230
 231         addr.s_addr = packet.yiaddr;
 232         bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
 233
 234         if (send_packet(&packet, 0) < 0)
 235                 return -1;
 236
 237         add_lease(packet.chaddr, packet.yiaddr, lease_time_align);
 238         if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
 239                 /* rewrite the file with leases at every new acceptance */
 240                 write_leases();
 241         }
 242
 243         return 0;
 244 }
 245
 246
 247 int send_inform(struct dhcpMessage *oldpacket)
 248 {
 249         struct dhcpMessage packet;
 250         struct option_set *curr;
 251
 252         init_packet(&packet, oldpacket, DHCPACK);
 253
 254         curr = server_config.options;
 255         while (curr) {
 256                 if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
 257                         add_option_string(packet.options, curr->data);
 258                 curr = curr->next;
 259         }
 260
 261         add_bootp_options(&packet);
 262
 263         return send_packet(&packet, 0);
 264 }