gdhcp/server.c

   1 /*
   2  *
   3  *  DHCP Server library with GLib integration
   4  *
   5  *  Copyright (C) 2009-2012  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <sys/ioctl.h>
  32 #include <arpa/inet.h>
  33
  34 #include <netpacket/packet.h>
  35 #include <net/ethernet.h>
  36 #include <net/if_arp.h>
  37
  38 #include <linux/if.h>
  39 #include <linux/filter.h>
  40
  41 #include <glib.h>
  42
  43 #include "common.h"
  44
  45 /* 8 hours */
  46 #define DEFAULT_DHCP_LEASE_SEC (8*60*60)
  47
  48 /* 5 minutes  */
  49 #define OFFER_TIME (5*60)
  50
  51 struct _GDHCPServer {
  52         int ref_count;
  53         GDHCPType type;
  54         gboolean started;
  55         int ifindex;
  56         char *interface;
  57         uint32_t start_ip;
  58         uint32_t end_ip;
  59         uint32_t server_nip;
  60         uint32_t lease_seconds;
  61         int listener_sockfd;
  62         guint listener_watch;
  63         GIOChannel *listener_channel;
  64         GList *lease_list;
  65         GHashTable *nip_lease_hash;
  66         GHashTable *option_hash; /* Options send to client */
  67         GDHCPSaveLeaseFunc save_lease_func;
  68         GDHCPDebugFunc debug_func;
  69         gpointer debug_data;
  70 };
  71
  72 struct dhcp_lease {
  73         time_t expire;
  74         uint32_t lease_nip;
  75         uint8_t lease_mac[ETH_ALEN];
  76 };
  77
  78 static inline void debug(GDHCPServer *server, const char *format, ...)
  79 {
  80         char str[256];
  81         va_list ap;
  82
  83         if (server->debug_func == NULL)
  84                 return;
  85
  86         va_start(ap, format);
  87
  88         if (vsnprintf(str, sizeof(str), format, ap) > 0)
  89                 server->debug_func(str, server->debug_data);
  90
  91         va_end(ap);
  92 }
  93
  94 static struct dhcp_lease *find_lease_by_mac(GDHCPServer *dhcp_server,
  95                                                 const uint8_t *mac)
  96 {
  97         GList *list;
  98
  99         for (list = dhcp_server->lease_list; list; list = list->next) {
 100                 struct dhcp_lease *lease = list->data;
 101
 102                 if (memcmp(lease->lease_mac, mac, ETH_ALEN) == 0)
 103                         return lease;
 104         }
 105
 106         return NULL;
 107 }
 108
 109 static void remove_lease(GDHCPServer *dhcp_server, struct dhcp_lease *lease)
 110 {
 111         dhcp_server->lease_list =
 112                         g_list_remove(dhcp_server->lease_list, lease);
 113
 114         g_hash_table_remove(dhcp_server->nip_lease_hash,
 115                                 GINT_TO_POINTER((int) lease->lease_nip));
 116         g_free(lease);
 117 }
 118
 119 /* Clear the old lease and create the new one */
 120 static int get_lease(GDHCPServer *dhcp_server, uint32_t yiaddr,
 121                                 const uint8_t *mac, struct dhcp_lease **lease)
 122 {
 123         struct dhcp_lease *lease_nip, *lease_mac;
 124
 125         if (yiaddr == 0)
 126                 return -ENXIO;
 127
 128         if (ntohl(yiaddr) < dhcp_server->start_ip)
 129                 return -ENXIO;
 130
 131         if (ntohl(yiaddr) > dhcp_server->end_ip)
 132                 return -ENXIO;
 133
 134         if (memcmp(mac, MAC_BCAST_ADDR, ETH_ALEN) == 0)
 135                 return -ENXIO;
 136
 137         if (memcmp(mac, MAC_ANY_ADDR, ETH_ALEN) == 0)
 138                 return -ENXIO;
 139
 140         lease_mac = find_lease_by_mac(dhcp_server, mac);
 141
 142         lease_nip = g_hash_table_lookup(dhcp_server->nip_lease_hash,
 143                                         GINT_TO_POINTER((int) ntohl(yiaddr)));
 144         debug(dhcp_server, "lease_mac %p lease_nip %p", lease_mac, lease_nip);
 145
 146         if (lease_nip != NULL) {
 147                 dhcp_server->lease_list =
 148                                 g_list_remove(dhcp_server->lease_list,
 149                                                                 lease_nip);
 150                 g_hash_table_remove(dhcp_server->nip_lease_hash,
 151                                 GINT_TO_POINTER((int) ntohl(yiaddr)));
 152
 153                 if (lease_mac == NULL)
 154                         *lease = lease_nip;
 155                 else if (lease_nip != lease_mac) {
 156                         remove_lease(dhcp_server, lease_mac);
 157                         *lease = lease_nip;
 158                 } else
 159                         *lease = lease_nip;
 160
 161                 return 0;
 162         }
 163
 164         if (lease_mac != NULL) {
 165                 dhcp_server->lease_list =
 166                                 g_list_remove(dhcp_server->lease_list,
 167                                                                 lease_mac);
 168                 g_hash_table_remove(dhcp_server->nip_lease_hash,
 169                                 GINT_TO_POINTER((int) lease_mac->lease_nip));
 170                 *lease = lease_mac;
 171
 172                 return 0;
 173         }
 174
 175         *lease = g_try_new0(struct dhcp_lease, 1);
 176         if (*lease == NULL)
 177                 return -ENOMEM;
 178
 179         return 0;
 180 }
 181
 182 static gint compare_expire(gconstpointer a, gconstpointer b)
 183 {
 184         const struct dhcp_lease *lease1 = a;
 185         const struct dhcp_lease *lease2 = b;
 186
 187         return lease2->expire - lease1->expire;
 188 }
 189
 190 static struct dhcp_lease *add_lease(GDHCPServer *dhcp_server, uint32_t expire,
 191                                         const uint8_t *chaddr, uint32_t yiaddr)
 192 {
 193         struct dhcp_lease *lease = NULL;
 194         int ret;
 195
 196         ret = get_lease(dhcp_server, yiaddr, chaddr, &lease);
 197         if (ret != 0)
 198                 return NULL;
 199
 200         memset(lease, 0, sizeof(*lease));
 201
 202         memcpy(lease->lease_mac, chaddr, ETH_ALEN);
 203         lease->lease_nip = ntohl(yiaddr);
 204
 205         if (expire == 0)
 206                 lease->expire = time(NULL) + dhcp_server->lease_seconds;
 207         else
 208                 lease->expire = expire;
 209
 210         dhcp_server->lease_list = g_list_insert_sorted(dhcp_server->lease_list,
 211                                                         lease, compare_expire);
 212
 213         g_hash_table_insert(dhcp_server->nip_lease_hash,
 214                                 GINT_TO_POINTER((int) lease->lease_nip), lease);
 215
 216         return lease;
 217 }
 218
 219 static struct dhcp_lease *find_lease_by_nip(GDHCPServer *dhcp_server,
 220                                                                 uint32_t nip)
 221 {
 222         return g_hash_table_lookup(dhcp_server->nip_lease_hash,
 223                                                 GINT_TO_POINTER((int) nip));
 224 }
 225
 226 /* Check if the IP is taken; if it is, add it to the lease table */
 227 static gboolean arp_check(uint32_t nip, const uint8_t *safe_mac)
 228 {
 229         /* TODO: Add ARP checking */
 230         return TRUE;
 231 }
 232
 233 static gboolean is_expired_lease(struct dhcp_lease *lease)
 234 {
 235         if (lease->expire < time(NULL))
 236                 return TRUE;
 237
 238         return FALSE;
 239 }
 240
 241 static uint32_t find_free_or_expired_nip(GDHCPServer *dhcp_server,
 242                                         const uint8_t *safe_mac)
 243 {
 244         uint32_t ip_addr;
 245         struct dhcp_lease *lease;
 246         GList *list;
 247         ip_addr = dhcp_server->start_ip;
 248         for (; ip_addr <= dhcp_server->end_ip; ip_addr++) {
 249                 /* e.g. 192.168.55.0 */
 250                 if ((ip_addr & 0xff) == 0)
 251                         continue;
 252
 253                 /* e.g. 192.168.55.255 */
 254                 if ((ip_addr & 0xff) == 0xff)
 255                         continue;
 256
 257                 lease = find_lease_by_nip(dhcp_server, ip_addr);
 258                 if (lease != NULL)
 259                         continue;
 260
 261                 if (arp_check(htonl(ip_addr), safe_mac) == TRUE)
 262                         return ip_addr;
 263         }
 264
 265         /* The last lease is the oldest one */
 266         list = g_list_last(dhcp_server->lease_list);
 267         if (list == NULL)
 268                 return 0;
 269
 270         lease = list->data;
 271         if (lease == NULL)
 272                 return 0;
 273
 274          if (is_expired_lease(lease) == FALSE)
 275                 return 0;
 276
 277          if (arp_check(lease->lease_nip, safe_mac) == FALSE)
 278                 return 0;
 279
 280         return lease->lease_nip;
 281 }
 282
 283 static void lease_set_expire(GDHCPServer *dhcp_server,
 284                         struct dhcp_lease *lease, uint32_t expire)
 285 {
 286         dhcp_server->lease_list = g_list_remove(dhcp_server->lease_list, lease);
 287
 288         lease->expire = expire;
 289
 290         dhcp_server->lease_list = g_list_insert_sorted(dhcp_server->lease_list,
 291                                                         lease, compare_expire);
 292 }
 293
 294 static void destroy_lease_table(GDHCPServer *dhcp_server)
 295 {
 296         GList *list;
 297
 298         g_hash_table_destroy(dhcp_server->nip_lease_hash);
 299
 300         dhcp_server->nip_lease_hash = NULL;
 301
 302         for (list = dhcp_server->lease_list; list; list = list->next) {
 303                 struct dhcp_lease *lease = list->data;
 304
 305                 g_free(lease);
 306         }
 307
 308         g_list_free(dhcp_server->lease_list);
 309
 310         dhcp_server->lease_list = NULL;
 311 }
 312 static uint32_t get_interface_address(int index)
 313 {
 314         struct ifreq ifr;
 315         int sk, err;
 316         struct sockaddr_in *server_ip;
 317         uint32_t ret = 0;
 318
 319         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 320         if (sk < 0) {
 321                 perror("Open socket error");
 322                 return 0;
 323         }
 324
 325         memset(&ifr, 0, sizeof(ifr));
 326         ifr.ifr_ifindex = index;
 327
 328         err = ioctl(sk, SIOCGIFNAME, &ifr);
 329         if (err < 0) {
 330                 perror("Get interface name error");
 331                 goto done;
 332         }
 333
 334         err = ioctl(sk, SIOCGIFADDR, &ifr);
 335         if (err < 0) {
 336                 perror("Get ip address error");
 337                 goto done;
 338         }
 339
 340         server_ip = (struct sockaddr_in *) &ifr.ifr_addr;
 341         ret = server_ip->sin_addr.s_addr;
 342
 343 done:
 344         close(sk);
 345
 346         return ret;
 347 }
 348
 349 GDHCPServer *g_dhcp_server_new(GDHCPType type,
 350                 int ifindex, GDHCPServerError *error)
 351 {
 352         GDHCPServer *dhcp_server = NULL;
 353
 354         if (ifindex < 0) {
 355                 *error = G_DHCP_SERVER_ERROR_INVALID_INDEX;
 356                 return NULL;
 357         }
 358
 359         dhcp_server = g_try_new0(GDHCPServer, 1);
 360         if (dhcp_server == NULL) {
 361                 *error = G_DHCP_SERVER_ERROR_NOMEM;
 362                 return NULL;
 363         }
 364
 365         dhcp_server->interface = get_interface_name(ifindex);
 366         if (dhcp_server->interface == NULL) {
 367                 *error = G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE;
 368                 goto error;
 369         }
 370
 371         if (interface_is_up(ifindex) == FALSE) {
 372                 *error = G_DHCP_SERVER_ERROR_INTERFACE_DOWN;
 373                 goto error;
 374         }
 375
 376         dhcp_server->server_nip = get_interface_address(ifindex);
 377         if (dhcp_server->server_nip == 0) {
 378                 *error = G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID;
 379                 goto error;
 380         }
 381
 382         dhcp_server->nip_lease_hash = g_hash_table_new_full(g_direct_hash,
 383                                                 g_direct_equal, NULL, NULL);
 384         dhcp_server->option_hash = g_hash_table_new_full(g_direct_hash,
 385                                                 g_direct_equal, NULL, NULL);
 386
 387         dhcp_server->started = FALSE;
 388
 389         /* All the leases have the same fixed lease time,
 390          * do not support DHCP_LEASE_TIME option from client.
 391          */
 392         dhcp_server->lease_seconds = DEFAULT_DHCP_LEASE_SEC;
 393
 394         dhcp_server->type = type;
 395         dhcp_server->ref_count = 1;
 396         dhcp_server->ifindex = ifindex;
 397         dhcp_server->listener_sockfd = -1;
 398         dhcp_server->listener_watch = -1;
 399         dhcp_server->listener_channel = NULL;
 400         dhcp_server->save_lease_func = NULL;
 401         dhcp_server->debug_func = NULL;
 402         dhcp_server->debug_data = NULL;
 403
 404         *error = G_DHCP_SERVER_ERROR_NONE;
 405
 406         return dhcp_server;
 407
 408 error:
 409         g_free(dhcp_server->interface);
 410         g_free(dhcp_server);
 411         return NULL;
 412 }
 413
 414
 415 static uint8_t check_packet_type(struct dhcp_packet *packet)
 416 {
 417         uint8_t *type;
 418
 419         if (packet->hlen != ETH_ALEN)
 420                 return 0;
 421
 422         if (packet->op != BOOTREQUEST)
 423                 return 0;
 424
 425         type = dhcp_get_option(packet, DHCP_MESSAGE_TYPE);
 426
 427         if (type == NULL)
 428                 return 0;
 429
 430         if (*type < DHCP_MINTYPE)
 431                 return 0;
 432
 433         if (*type > DHCP_MAXTYPE)
 434                 return 0;
 435
 436         return *type;
 437 }
 438
 439 static void init_packet(GDHCPServer *dhcp_server, struct dhcp_packet *packet,
 440                                 struct dhcp_packet *client_packet, char type)
 441 {
 442         /* Sets op, htype, hlen, cookie fields
 443          * and adds DHCP_MESSAGE_TYPE option */
 444         dhcp_init_header(packet, type);
 445
 446         packet->xid = client_packet->xid;
 447         memcpy(packet->chaddr, client_packet->chaddr,
 448                                 sizeof(client_packet->chaddr));
 449         packet->flags = client_packet->flags;
 450         packet->gateway_nip = client_packet->gateway_nip;
 451         packet->ciaddr = client_packet->ciaddr;
 452         dhcp_add_option_uint32(packet, DHCP_SERVER_ID,
 453                                                 dhcp_server->server_nip);
 454 }
 455
 456 static void add_option(gpointer key, gpointer value, gpointer user_data)
 457 {
 458         const char *option_value = value;
 459         uint8_t option_code = GPOINTER_TO_INT(key);
 460         struct in_addr nip;
 461         struct dhcp_packet *packet = user_data;
 462
 463         if (option_value == NULL)
 464                 return;
 465
 466         switch (option_code) {
 467         case G_DHCP_SUBNET:
 468         case G_DHCP_ROUTER:
 469         case G_DHCP_DNS_SERVER:
 470                 if (inet_aton(option_value, &nip) == 0)
 471                         return;
 472
 473                 dhcp_add_option_uint32(packet, (uint8_t) option_code,
 474                                                         ntohl(nip.s_addr));
 475                 break;
 476         default:
 477                 return;
 478         }
 479 }
 480
 481 static void add_server_options(GDHCPServer *dhcp_server,
 482                                 struct dhcp_packet *packet)
 483 {
 484         g_hash_table_foreach(dhcp_server->option_hash,
 485                                 add_option, packet);
 486 }
 487
 488 static gboolean check_requested_nip(GDHCPServer *dhcp_server,
 489                                         uint32_t requested_nip)
 490 {
 491         struct dhcp_lease *lease;
 492
 493         if (requested_nip == 0)
 494                 return FALSE;
 495
 496         if (requested_nip < dhcp_server->start_ip)
 497                 return FALSE;
 498
 499         if (requested_nip > dhcp_server->end_ip)
 500                 return FALSE;
 501
 502         lease = find_lease_by_nip(dhcp_server, requested_nip);
 503         if (lease == NULL)
 504                 return TRUE;
 505
 506         if (is_expired_lease(lease) == FALSE)
 507                 return FALSE;
 508
 509         return TRUE;
 510 }
 511
 512 static void send_packet_to_client(GDHCPServer *dhcp_server,
 513                                 struct dhcp_packet *dhcp_pkt)
 514 {
 515         const uint8_t *chaddr;
 516         uint32_t ciaddr;
 517
 518         if ((dhcp_pkt->flags & htons(BROADCAST_FLAG))
 519                                 || dhcp_pkt->ciaddr == 0) {
 520                 debug(dhcp_server, "Broadcasting packet to client");
 521                 ciaddr = INADDR_BROADCAST;
 522                 chaddr = MAC_BCAST_ADDR;
 523         } else {
 524                 debug(dhcp_server, "Unicasting packet to client ciaddr");
 525                 ciaddr = dhcp_pkt->ciaddr;
 526                 chaddr = dhcp_pkt->chaddr;
 527         }
 528
 529         dhcp_send_raw_packet(dhcp_pkt,
 530                 dhcp_server->server_nip, SERVER_PORT,
 531                 ciaddr, CLIENT_PORT, chaddr,
 532                 dhcp_server->ifindex);
 533 }
 534
 535 static void send_offer(GDHCPServer *dhcp_server,
 536                         struct dhcp_packet *client_packet,
 537                                 struct dhcp_lease *lease,
 538                                         uint32_t requested_nip)
 539 {
 540         struct dhcp_packet packet;
 541         struct in_addr addr;
 542
 543         init_packet(dhcp_server, &packet, client_packet, DHCPOFFER);
 544
 545         if (lease)
 546                 packet.yiaddr = htonl(lease->lease_nip);
 547         else if (check_requested_nip(dhcp_server, requested_nip) == TRUE)
 548                 packet.yiaddr = htonl(requested_nip);
 549         else
 550                 packet.yiaddr = htonl(find_free_or_expired_nip(
 551                                         dhcp_server, client_packet->chaddr));
 552
 553         debug(dhcp_server, "find yiaddr %u", packet.yiaddr);
 554
 555         if (!packet.yiaddr) {
 556                 debug(dhcp_server, "Err: Can not found lease and send offer");
 557                 return;
 558         }
 559
 560         lease = add_lease(dhcp_server, OFFER_TIME,
 561                                 packet.chaddr, packet.yiaddr);
 562         if (lease == NULL) {
 563                 debug(dhcp_server,
 564                                 "Err: No free IP addresses. OFFER abandoned");
 565                 return;
 566         }
 567
 568         dhcp_add_option_uint32(&packet, DHCP_LEASE_TIME,
 569                                                 dhcp_server->lease_seconds);
 570         add_server_options(dhcp_server, &packet);
 571
 572         addr.s_addr = packet.yiaddr;
 573
 574         debug(dhcp_server, "Sending OFFER of %s", inet_ntoa(addr));
 575         send_packet_to_client(dhcp_server, &packet);
 576 }
 577
 578 static void save_lease(GDHCPServer *dhcp_server)
 579 {
 580         GList *list;
 581
 582         if (dhcp_server->save_lease_func == NULL)
 583                 return;
 584
 585         for (list = dhcp_server->lease_list; list; list = list->next) {
 586                 struct dhcp_lease *lease = list->data;
 587                 dhcp_server->save_lease_func(lease->lease_mac,
 588                                         lease->lease_nip, lease->expire);
 589         }
 590 }
 591
 592 static void send_ACK(GDHCPServer *dhcp_server,
 593                 struct dhcp_packet *client_packet, uint32_t dest)
 594 {
 595         struct dhcp_packet packet;
 596         uint32_t lease_time_sec;
 597         struct in_addr addr;
 598
 599         init_packet(dhcp_server, &packet, client_packet, DHCPACK);
 600         packet.yiaddr = htonl(dest);
 601
 602         lease_time_sec = dhcp_server->lease_seconds;
 603
 604         dhcp_add_option_uint32(&packet, DHCP_LEASE_TIME, lease_time_sec);
 605
 606         add_server_options(dhcp_server, &packet);
 607
 608         addr.s_addr = htonl(dest);
 609
 610         debug(dhcp_server, "Sending ACK to %s", inet_ntoa(addr));
 611
 612         send_packet_to_client(dhcp_server, &packet);
 613
 614         add_lease(dhcp_server, 0, packet.chaddr, packet.yiaddr);
 615 }
 616
 617 static void send_NAK(GDHCPServer *dhcp_server,
 618                         struct dhcp_packet *client_packet)
 619 {
 620         struct dhcp_packet packet;
 621
 622         init_packet(dhcp_server, &packet, client_packet, DHCPNAK);
 623
 624         debug(dhcp_server, "Sending NAK");
 625
 626         dhcp_send_raw_packet(&packet,
 627                         dhcp_server->server_nip, SERVER_PORT,
 628                         INADDR_BROADCAST, CLIENT_PORT, MAC_BCAST_ADDR,
 629                         dhcp_server->ifindex);
 630 }
 631
 632 static void send_inform(GDHCPServer *dhcp_server,
 633                                 struct dhcp_packet *client_packet)
 634 {
 635         struct dhcp_packet packet;
 636
 637         init_packet(dhcp_server, &packet, client_packet, DHCPACK);
 638         add_server_options(dhcp_server, &packet);
 639         send_packet_to_client(dhcp_server, &packet);
 640 }
 641
 642 static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
 643                                                         gpointer user_data)
 644 {
 645         GDHCPServer *dhcp_server = user_data;
 646         struct dhcp_packet packet;
 647         struct dhcp_lease *lease;
 648         uint32_t requested_nip = 0;
 649         uint8_t type, *server_id_option, *request_ip_option;
 650         int re;
 651
 652         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 653                 dhcp_server->listener_watch = 0;
 654                 return FALSE;
 655         }
 656
 657         re = dhcp_recv_l3_packet(&packet, dhcp_server->listener_sockfd);
 658         if (re < 0)
 659                 return TRUE;
 660
 661         type = check_packet_type(&packet);
 662         if (type == 0)
 663                 return TRUE;
 664
 665         server_id_option = dhcp_get_option(&packet, DHCP_SERVER_ID);
 666         if (server_id_option) {
 667                 uint32_t server_nid = get_be32(server_id_option);
 668
 669                 if (server_nid != dhcp_server->server_nip)
 670                         return TRUE;
 671         }
 672
 673         request_ip_option = dhcp_get_option(&packet, DHCP_REQUESTED_IP);
 674         if (request_ip_option)
 675                 requested_nip = get_be32(request_ip_option);
 676
 677         lease = find_lease_by_mac(dhcp_server, packet.chaddr);
 678
 679         switch (type) {
 680                 case DHCPDISCOVER:
 681                         debug(dhcp_server, "Received DISCOVER");
 682
 683                         send_offer(dhcp_server, &packet, lease, requested_nip);
 684                 break;
 685                 case DHCPREQUEST:
 686                         debug(dhcp_server, "Received REQUEST NIP %d",
 687                                                         requested_nip);
 688                         if (requested_nip == 0) {
 689                                 requested_nip = packet.ciaddr;
 690                                 if (requested_nip == 0)
 691                                         break;
 692                         }
 693
 694                         if (lease && requested_nip == lease->lease_nip) {
 695                                 debug(dhcp_server, "Sending ACK");
 696                                 send_ACK(dhcp_server, &packet,
 697                                                 lease->lease_nip);
 698                                 break;
 699                         }
 700
 701                         if (server_id_option || lease == NULL) {
 702                                 debug(dhcp_server, "Sending NAK");
 703                                 send_NAK(dhcp_server, &packet);
 704                         }
 705
 706                 break;
 707                 case DHCPDECLINE:
 708                         debug(dhcp_server, "Received DECLINE");
 709
 710                         if (server_id_option == NULL)
 711                                 break;
 712
 713                         if (request_ip_option == NULL)
 714                                 break;
 715
 716                         if (lease == NULL)
 717                                 break;
 718
 719                         if (requested_nip == lease->lease_nip)
 720                                 remove_lease(dhcp_server, lease);
 721
 722                 break;
 723                 case DHCPRELEASE:
 724                         debug(dhcp_server, "Received RELEASE");
 725
 726                         if (server_id_option == NULL)
 727                                 break;
 728
 729                         if (lease == NULL)
 730                                 break;
 731
 732                         if (packet.ciaddr == lease->lease_nip)
 733                                 lease_set_expire(dhcp_server, lease,
 734                                                                 time(NULL));
 735                 break;
 736                 case DHCPINFORM:
 737                         debug(dhcp_server, "Received INFORM");
 738                         send_inform(dhcp_server, &packet);
 739                 break;
 740         }
 741
 742         return TRUE;
 743 }
 744
 745 /* Caller need to load leases before call it */
 746 int g_dhcp_server_start(GDHCPServer *dhcp_server)
 747 {
 748         GIOChannel *listener_channel;
 749         int listener_sockfd;
 750
 751         if (dhcp_server->started == TRUE)
 752                 return 0;
 753
 754         listener_sockfd = dhcp_l3_socket(SERVER_PORT,
 755                                         dhcp_server->interface, AF_INET);
 756         if (listener_sockfd < 0)
 757                 return -EIO;
 758
 759         listener_channel = g_io_channel_unix_new(listener_sockfd);
 760         if (listener_channel == NULL) {
 761                 close(listener_sockfd);
 762                 return -EIO;
 763         }
 764
 765         dhcp_server->listener_sockfd = listener_sockfd;
 766         dhcp_server->listener_channel = listener_channel;
 767
 768         g_io_channel_set_close_on_unref(listener_channel, TRUE);
 769         dhcp_server->listener_watch =
 770                         g_io_add_watch_full(listener_channel, G_PRIORITY_HIGH,
 771                                 G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
 772                                                 listener_event, dhcp_server,
 773                                                                 NULL);
 774         g_io_channel_unref(dhcp_server->listener_channel);
 775
 776         dhcp_server->started = TRUE;
 777
 778         return 0;
 779 }
 780
 781 int g_dhcp_server_set_option(GDHCPServer *dhcp_server,
 782                 unsigned char option_code, const char *option_value)
 783 {
 784         struct in_addr nip;
 785
 786         if (option_value == NULL)
 787                 return -EINVAL;
 788
 789         debug(dhcp_server, "option_code %d option_value %s",
 790                                         option_code, option_value);
 791         switch (option_code) {
 792         case G_DHCP_SUBNET:
 793         case G_DHCP_ROUTER:
 794         case G_DHCP_DNS_SERVER:
 795                 if (inet_aton(option_value, &nip) == 0)
 796                         return -ENXIO;
 797                 break;
 798         default:
 799                 return -EINVAL;
 800         }
 801
 802         g_hash_table_replace(dhcp_server->option_hash,
 803                         GINT_TO_POINTER((int) option_code),
 804                                         (gpointer) option_value);
 805         return 0;
 806 }
 807
 808 void g_dhcp_server_set_save_lease(GDHCPServer *dhcp_server,
 809                                 GDHCPSaveLeaseFunc func, gpointer user_data)
 810 {
 811         if (dhcp_server == NULL)
 812                 return;
 813
 814         dhcp_server->save_lease_func = func;
 815 }
 816
 817 GDHCPServer *g_dhcp_server_ref(GDHCPServer *dhcp_server)
 818 {
 819         if (dhcp_server == NULL)
 820                 return NULL;
 821
 822         __sync_fetch_and_add(&dhcp_server->ref_count, 1);
 823
 824         return dhcp_server;
 825 }
 826
 827 void g_dhcp_server_stop(GDHCPServer *dhcp_server)
 828 {
 829         /* Save leases, before stop; load them before start */
 830         save_lease(dhcp_server);
 831
 832         if (dhcp_server->listener_watch > 0) {
 833                 g_source_remove(dhcp_server->listener_watch);
 834                 dhcp_server->listener_watch = 0;
 835         }
 836
 837         dhcp_server->listener_channel = NULL;
 838
 839         dhcp_server->started = FALSE;
 840 }
 841
 842 void g_dhcp_server_unref(GDHCPServer *dhcp_server)
 843 {
 844         if (dhcp_server == NULL)
 845                 return;
 846
 847         if (__sync_fetch_and_sub(&dhcp_server->ref_count, 1) != 1)
 848                 return;
 849
 850         g_dhcp_server_stop(dhcp_server);
 851
 852         g_hash_table_destroy(dhcp_server->option_hash);
 853
 854         destroy_lease_table(dhcp_server);
 855
 856         g_free(dhcp_server->interface);
 857
 858         g_free(dhcp_server);
 859 }
 860
 861 int g_dhcp_server_set_ip_range(GDHCPServer *dhcp_server,
 862                 const char *start_ip, const char *end_ip)
 863 {
 864         struct in_addr _host_addr;
 865
 866         if (inet_aton(start_ip, &_host_addr) == 0)
 867                 return -ENXIO;
 868
 869         dhcp_server->start_ip = ntohl(_host_addr.s_addr);
 870
 871         if (inet_aton(end_ip, &_host_addr) == 0)
 872                 return -ENXIO;
 873
 874         dhcp_server->end_ip = ntohl(_host_addr.s_addr);
 875
 876         return 0;
 877 }
 878
 879 void g_dhcp_server_set_lease_time(GDHCPServer *dhcp_server, unsigned int lease_time)
 880 {
 881         if (dhcp_server == NULL)
 882                 return;
 883
 884         dhcp_server->lease_seconds = lease_time;
 885 }
 886
 887 void g_dhcp_server_set_debug(GDHCPServer *dhcp_server,
 888                                 GDHCPDebugFunc func, gpointer user_data)
 889 {
 890         if (dhcp_server == NULL)
 891                 return;
 892
 893         dhcp_server->debug_func = func;
 894         dhcp_server->debug_data = user_data;
 895 }