DHCP client and server, from Ashwini Sharma.

2 files changed, 2783 insertions, 0 deletions

diff --git a/toys/pending/dhcp.c b/toys/pending/dhcp.c
new file mode 100644
index 00000000..d7a43fad
--- /dev/null
+++ b/toys/pending/dhcp.c
@@ -0,0 +1,1536 @@
+/* dhcp.c - DHCP client for dynamic network configuration.
+ *
+ * Copyright 2012 Madhur Verma <mad.flexi@gmail.com>
+ * Copyright 2013 Kyungwan Han <asura321@gmail.com>
+ *
+ * Not in SUSv4.
+USE_DHCP(NEWTOY(dhcp, "V:H:F:x*r:O*A#<0T#<0t#<0s:p:i:SBRCaovqnbf", TOYFLAG_SBIN|TOYFLAG_ROOTONLY))
+
+config DHCP
+  bool "dhcp"
+  default n
+  help
+   usage: dhcp [-fbnqvoCRB] [-i IFACE] [-r IP] [-s PROG] [-p PIDFILE]
+               [-H HOSTNAME] [-V VENDOR] [-x OPT:VAL] [-O OPT]
+
+        Configure network dynamicaly using DHCP.
+
+      -i Interface to use (default eth0)
+      -p Create pidfile
+      -s Run PROG at DHCP events (default /usr/share/dhcp/default.script)
+      -B Request broadcast replies
+      -t Send up to N discover packets
+      -T Pause between packets (default 3 seconds)
+      -A Wait N seconds after failure (default 20)
+      -f Run in foreground
+      -b Background if lease is not obtained
+      -n Exit if lease is not obtained
+      -q Exit after obtaining lease
+      -R Release IP on exit
+      -S Log to syslog too
+      -a Use arping to validate offered address
+      -O Request option OPT from server (cumulative)
+      -o Don't request any options (unless -O is given)
+      -r Request this IP address
+      -x OPT:VAL  Include option OPT in sent packets (cumulative)
+      -F Ask server to update DNS mapping for NAME
+      -H Send NAME as client hostname (default none)
+      -V VENDOR Vendor identifier (default 'toybox VERSION')
+      -C Don't send MAC as client identifier
+      -v Verbose
+
+      Signals:
+      USR1  Renew current lease
+      USR2  Release current lease
+
+*/
+
+#define FOR_dhcp
+#include "toys.h"
+#include "toynet.h"
+
+// TODO: headers not in posix:
+#include <netinet/ip.h>
+#include <netinet/udp.h>
+#include <netpacket/packet.h>
+
+#include <linux/filter.h> //FIXME: linux specific. fix for other OS ports
+#include <linux/if_ether.h>
+
+GLOBALS(
+    char *iface;
+    char *pidfile;
+    char *script;
+    long retries;
+    long timeout;
+    long tryagain;
+    struct arg_list *req_opt;
+    char *req_ip;
+    struct arg_list *pkt_opt;
+    char *fdn_name;
+    char *hostname;
+    char *vendor_cls;
+)
+
+#define flag_get(f,v,d) ((toys.optflags & f) ? v : d)
+#define flag_chk(f)     ((toys.optflags & f) ? 1 : 0)
+
+#define STATE_INIT            0
+#define STATE_REQUESTING      1
+#define STATE_BOUND           2
+#define STATE_RENEWING        3
+#define STATE_REBINDING       4
+#define STATE_RENEW_REQUESTED 5
+#define STATE_RELEASED        6
+
+#define BOOTP_BROADCAST   0x8000
+#define DHCP_MAGIC        0x63825363
+
+#define DHCP_REQUEST          1
+#define DHCP_REPLY            2
+#define DHCP_HTYPE_ETHERNET   1
+
+#define DHCPC_SERVER_PORT     67
+#define DHCPC_CLIENT_PORT     68
+
+#define DHCPDISCOVER      1
+#define DHCPOFFER         2
+#define DHCPREQUEST       3
+#define DHCPACK           5
+#define DHCPNAK           6
+#define DHCPRELEASE       7
+
+#define DHCP_OPTION_PADDING     0x00
+#define DHCP_OPTION_SUBNET_MASK 0x01
+#define DHCP_OPTION_ROUTER      0x03
+#define DHCP_OPTION_DNS_SERVER  0x06
+#define DHCP_OPTION_HOST_NAME   0x0c
+#define DHCP_OPTION_BROADCAST   0x1c
+#define DHCP_OPTION_REQ_IPADDR  0x32
+#define DHCP_OPTION_LEASE_TIME  0x33
+#define DHCP_OPTION_OVERLOAD    0x34
+#define DHCP_OPTION_MSG_TYPE    0x35
+#define DHCP_OPTION_SERVER_ID   0x36
+#define DHCP_OPTION_REQ_LIST    0x37
+#define DHCP_OPTION_MAX_SIZE    0x39
+#define DHCP_OPTION_CLIENTID    0x3D
+#define DHCP_OPTION_VENDOR      0x3C
+#define DHCP_OPTION_FQDN        0x51
+#define DHCP_OPTION_END         0xFF
+
+#define DHCP_NUM8           (1<<8)
+#define DHCP_NUM16          (1<<9)
+#define DHCP_NUM32          DHCP_NUM16 | DHCP_NUM8
+#define DHCP_STRING         (1<<10)
+#define DHCP_STRLST         (1<<11)
+#define DHCP_IP             (1<<12)
+#define DHCP_IPLIST         (1<<13)
+#define DHCP_IPPLST         (1<<14)
+#define DHCP_STCRTS         (1<<15)
+
+#define LOG_SILENT          0x0
+#define LOG_CONSOLE         0x1
+#define LOG_SYSTEM          0x2
+
+#define MODE_OFF        0
+#define MODE_RAW        1
+#define MODE_APP        2
+
+static void (*dbg)(char *format, ...);
+static void dummy(char *format, ...){
+	return;
+}
+
+typedef struct dhcpc_result_s {
+  struct in_addr serverid;
+  struct in_addr ipaddr;
+  struct in_addr netmask;
+  struct in_addr dnsaddr;
+  struct in_addr default_router;
+  uint32_t lease_time;
+} dhcpc_result_t;
+
+typedef struct __attribute__((packed)) dhcp_msg_s {
+  uint8_t op;
+  uint8_t htype;
+  uint8_t hlen;
+  uint8_t hops;
+  uint32_t xid;
+  uint16_t secs;
+  uint16_t flags;
+  uint32_t ciaddr;
+  uint32_t yiaddr;
+  uint32_t nsiaddr;
+  uint32_t ngiaddr;
+  uint8_t chaddr[16];
+  uint8_t sname[64];
+  uint8_t file[128];
+  uint32_t cookie;
+  uint8_t options[308];
+} dhcp_msg_t;
+
+typedef struct __attribute__((packed)) dhcp_raw_s {
+  struct iphdr iph;
+  struct udphdr udph;
+  dhcp_msg_t dhcp;
+} dhcp_raw_t;
+
+typedef struct dhcpc_state_s {
+  uint8_t macaddr[6];
+   char *iface;
+  int ifindex;
+  int sockfd;
+  int status;
+  int mode;
+  uint32_t mask;
+  struct in_addr ipaddr;
+  struct in_addr serverid;
+  dhcp_msg_t pdhcp;
+} dhcpc_state_t;
+
+typedef struct option_val_s {
+  char *key;
+  uint16_t code;
+  void *val;
+  size_t len;
+} option_val_t;
+
+struct fd_pair { int rd; int wr; };
+static uint32_t xid;
+static dhcpc_state_t *state;
+static struct fd_pair sigfd;
+uint8_t bmacaddr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+ int set = 1;
+uint8_t infomode = LOG_CONSOLE;
+uint8_t raw_opt[29];
+int raw_optcount = 0;
+struct arg_list *x_opt;
+in_addr_t server = 0;
+
+static option_val_t *msgopt_list = NULL;
+static option_val_t options_list[] = {
+    {"lease"          , DHCP_NUM32  | 0x33, NULL, 0},
+    {"subnet"         , DHCP_IP     | 0x01, NULL, 0},
+    {"broadcast"      , DHCP_IP     | 0x1c, NULL, 0},
+    {"router"         , DHCP_IP     | 0x03, NULL, 0},
+    {"ipttl"          , DHCP_NUM8   | 0x17, NULL, 0},
+    {"mtu"            , DHCP_NUM16  | 0x1a, NULL, 0},
+    {"hostname"       , DHCP_STRING | 0x0c, NULL, 0},
+    {"domain"         , DHCP_STRING | 0x0f, NULL, 0},
+    {"search"         , DHCP_STRLST | 0x77, NULL, 0},
+    {"nisdomain"      , DHCP_STRING | 0x28, NULL, 0},
+    {"timezone"       , DHCP_NUM32  | 0x02, NULL, 0},
+    {"tftp"           , DHCP_STRING | 0x42, NULL, 0},
+    {"bootfile"       , DHCP_STRING | 0x43, NULL, 0},
+    {"bootsize"       , DHCP_NUM16  | 0x0d, NULL, 0},
+    {"rootpath"       , DHCP_STRING | 0x11, NULL, 0},
+    {"wpad"           , DHCP_STRING | 0xfc, NULL, 0},
+    {"serverid"       , DHCP_IP     | 0x36, NULL, 0},
+    {"message"        , DHCP_STRING | 0x38, NULL, 0},
+    {"vlanid"         , DHCP_NUM32  | 0x84, NULL, 0},
+    {"vlanpriority"   , DHCP_NUM32  | 0x85, NULL, 0},
+    {"dns"            , DHCP_IPLIST | 0x06, NULL, 0},
+    {"wins"           , DHCP_IPLIST | 0x2c, NULL, 0},
+    {"nissrv"         , DHCP_IPLIST | 0x29, NULL, 0},
+    {"ntpsrv"         , DHCP_IPLIST | 0x2a, NULL, 0},
+    {"lprsrv"         , DHCP_IPLIST | 0x09, NULL, 0},
+    {"swapsrv"        , DHCP_IP     | 0x10, NULL, 0},
+    {"routes"         , DHCP_STCRTS | 0x21, NULL, 0},
+    {"staticroutes"   , DHCP_STCRTS | 0x79, NULL, 0},
+    {"msstaticroutes" , DHCP_STCRTS | 0xf9, NULL, 0},
+};
+
+static  struct sock_filter filter_instr[] = {
+    BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
+    BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 0, 6),
+    BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 6),
+    BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x1fff, 4, 0),
+    BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0), BPF_STMT(BPF_LD|BPF_H|BPF_IND, 2),
+    BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 68, 0, 1),
+    BPF_STMT(BPF_RET|BPF_K, 0xffffffff), BPF_STMT(BPF_RET|BPF_K, 0),
+};
+
+static  struct sock_fprog filter_prog = {
+    .len = ARRAY_LEN(filter_instr), 
+    .filter = (struct sock_filter *) filter_instr,
+};
+
+// calculate options size.
+static int dhcp_opt_size(uint8_t *optionptr)
+{
+  int i = 0;
+  for(;optionptr[i] != 0xff; i++) if(optionptr[i] != 0x00) i += optionptr[i + 1] + 2 -1;
+  return i;
+}
+
+// calculates checksum for dhcp messages.
+static uint16_t dhcp_checksum(void *addr, int count)
+{
+  int32_t sum = 0;
+  uint16_t tmp = 0, *source = (uint16_t *)addr;
+
+  while (count > 1)  {
+    sum += *source++;
+    count -= 2;
+  }
+  if (count > 0) {
+    *(uint8_t*)&tmp = *(uint8_t*)source;
+    sum += tmp;
+  }
+  while (sum >> 16) sum = (sum & 0xffff) + (sum >> 16);
+  return ~sum;
+}
+
+// gets information of INTERFACE and updates IFINDEX, MAC and IP
+static int get_interface( char *interface, int *ifindex, uint32_t *oip, uint8_t *mac)
+{
+  struct ifreq req;
+  struct sockaddr_in *ip;
+  int fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
+
+  req.ifr_addr.sa_family = AF_INET;
+  strncpy(req.ifr_name, interface, IFNAMSIZ);
+  req.ifr_name[IFNAMSIZ-1] = '\0';
+
+  xioctl(fd, SIOCGIFFLAGS, &req);
+  if (!(req.ifr_flags & IFF_UP)) return -1;
+
+  if (oip) {
+    xioctl(fd, SIOCGIFADDR, &req);
+    ip = (struct sockaddr_in*) &req.ifr_addr;
+    dbg("IP %s\n", inet_ntoa(ip->sin_addr));
+    *oip = ntohl(ip->sin_addr.s_addr);
+  }
+  if (ifindex) {
+    xioctl(fd, SIOCGIFINDEX, &req);
+    dbg("Adapter index %d\n", req.ifr_ifindex);
+    *ifindex = req.ifr_ifindex;
+  }
+  if (mac) {
+    xioctl(fd, SIOCGIFHWADDR, &req);
+    memcpy(mac, req.ifr_hwaddr.sa_data, 6);
+    dbg("MAC %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+  }
+  close(fd);
+  return 0;
+}
+
+static int dhcp_daemon(void)
+{
+  int fd = open("/dev/null", O_RDWR);
+  if (fd < 0) fd = xcreate("/", O_RDONLY, 0666);
+  pid_t pid = fork();
+
+  if (pid < 0) perror_exit("DAEMON: failed to fork");
+  if (pid) exit(EXIT_SUCCESS);
+
+  setsid();
+  dup2(fd, 0);
+  dup2(fd, 1);
+  dup2(fd, 2);
+  if (fd > 2) xclose(fd);
+
+  return 0;
+}
+
+/*
+ *logs messeges to syslog or console
+ *opening the log is still left with applet.
+ *FIXME: move to more relevent lib. probably libc.c
+ */
+static void infomsg(uint8_t infomode,  char *s, ...)
+{
+  int used;
+  char *msg;
+  va_list p, t;
+
+  if (infomode == LOG_SILENT) return;
+  va_start(p, s);
+  va_copy(t, p);
+  used = vsnprintf(NULL, 0, s, t);
+  used++;
+  va_end(t);
+
+  msg = xmalloc(used);
+  vsnprintf(msg, used, s, p);
+  va_end(p);
+
+  if (infomode & LOG_SYSTEM) syslog(LOG_INFO, "%s", msg);
+  if (infomode & LOG_CONSOLE) printf("%s\n", msg);
+  free(msg);
+}
+
+/*
+ * Writes self PID in file PATH
+ * FIXME: libc implementation only writes in /var/run
+ * this is more generic as some implemenation may provide
+ * arguments to write in specific file. as dhcpd does.
+ */
+static void write_pid(char *path)
+{
+  int pidfile = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0666);
+  if (pidfile > 0) {
+    char *pidbuf = utoa(getpid());
+    write(pidfile, pidbuf, strlen(pidbuf));
+    close(pidfile);
+  }
+}
+
+// String STR to UINT32 conversion strored in VAR
+static long strtou32( char *str)
+{
+  char *endptr = NULL;
+  int base = 10;
+  errno=0;
+  if (str[0]=='0' && (str[1]=='x' || str[1]=='X')) {
+    base = 16;
+    str+=2;
+  }
+  long ret_val = strtol(str, &endptr, base);
+  if (errno) return -1;
+  else if (endptr && (*endptr!='\0'||endptr == str)) return -1;
+  return ret_val;
+}
+
+// IP String STR to binary data.
+static int striptovar( char *str, void *var)
+{
+  in_addr_t addr;
+  if(!str) error_exit("NULL address string.");
+  addr = inet_addr(str);
+  if(addr == -1) error_exit("Wrong address %s.",str );
+  *((uint32_t*)(var)) = (uint32_t)addr;
+  return 0;
+}
+
+// String to dhcp option conversion
+static int strtoopt( char *str, uint8_t optonly)
+{
+  char *option, *valstr, *grp, *tp;
+  long optcode = 0, convtmp;
+  uint16_t flag = 0;
+  uint32_t mask, nip, router;
+  int count, size = ARRAY_LEN(options_list);
+
+  if (!*str) return 0;
+  option = strtok((char*)str, ":");
+  if (!option) return -1;
+
+  dbg("-x option : %s ", option);
+  optcode = strtou32(option);
+
+  if (optcode > 0 && optcode < 256) {         // raw option
+    for (count = 0; count < size; count++) {
+      if ((options_list[count].code & 0X00FF) == optcode) {
+        flag = (options_list[count].code & 0XFF00);
+        break;
+      }
+    }
+    if (count == size) error_exit("Obsolete OR Unknown Option : %s", option);
+  } else {    // string option
+    for (count = 0; count < size; count++) {
+      if (!strcmp(options_list[count].key, option)) {
+        flag = (options_list[count].code & 0XFF00);
+        optcode = (options_list[count].code & 0X00FF);
+        break;
+      }
+    }
+    if (count == size) error_exit("Obsolete OR Unknown Option : %s", option);
+  }
+  if (!flag || !optcode) return -1;
+  if (optonly) return optcode;
+
+  valstr = strtok(NULL, "\n");
+  if (!valstr) error_exit("option %s has no value defined.\n", option);
+  dbg(" value : %-20s \n ", valstr);
+  switch (flag) {
+  case DHCP_NUM32:
+    options_list[count].len = sizeof(uint32_t);
+    options_list[count].val = xmalloc(sizeof(uint32_t));
+    convtmp = strtou32(valstr);
+    if (convtmp < 0) error_exit("Invalid/wrong formated number %s", valstr);
+    convtmp = htonl(convtmp);
+    memcpy(options_list[count].val, &convtmp, sizeof(uint32_t));
+    break;
+  case DHCP_NUM16:
+    options_list[count].len = sizeof(uint16_t);
+    options_list[count].val = xmalloc(sizeof(uint16_t));
+    convtmp = strtou32(valstr);
+    if (convtmp < 0) error_exit("Invalid/malformed number %s", valstr);
+    convtmp = htons(convtmp);
+    memcpy(options_list[count].val, &convtmp, sizeof(uint16_t));
+    break;
+  case DHCP_NUM8:
+    options_list[count].len = sizeof(uint8_t);
+    options_list[count].val = xmalloc(sizeof(uint8_t));
+    convtmp = strtou32(valstr);
+    if (convtmp < 0) error_exit("Invalid/malformed number %s", valstr);
+    memcpy(options_list[count].val, &convtmp, sizeof(uint8_t));
+    break;
+  case DHCP_IP:
+    options_list[count].len = sizeof(uint32_t);
+    options_list[count].val = xmalloc(sizeof(uint32_t));
+    striptovar(valstr, options_list[count].val);
+    break;
+  case DHCP_STRING:
+    options_list[count].len = strlen(valstr);
+    options_list[count].val = strdup(valstr);
+    break;
+  case DHCP_IPLIST:
+    while(valstr){
+      options_list[count].val = xrealloc(options_list[count].val, options_list[count].len + sizeof(uint32_t));
+      striptovar(valstr, ((uint8_t*)options_list[count].val)+options_list[count].len);
+      options_list[count].len += sizeof(uint32_t);
+      valstr = strtok(NULL," \t");
+    }
+    break;
+  case DHCP_STRLST: 
+  case DHCP_IPPLST:
+    break;
+  case DHCP_STCRTS:
+    /* Option binary format:
+     * mask [one byte, 0..32]
+     * ip [0..4 bytes depending on mask]
+     * router [4 bytes]
+     * may be repeated
+     * staticroutes 10.0.0.0/8 10.127.0.1, 10.11.12.0/24 10.11.12.1
+     */
+    grp = strtok(valstr, ",");;
+    while(grp){
+      while(*grp == ' ' || *grp == '\t') grp++;
+      tp = strchr(grp, '/');
+      if (!tp) error_exit("malformed static route option");
+      *tp = '\0';
+      mask = strtol(++tp, &tp, 10);
+      if (striptovar(grp, (uint8_t*)&nip) < 0) error_exit("malformed static route option");
+      while(*tp == ' ' || *tp == '\t' || *tp == '-') tp++;
+      if (striptovar(tp, (uint8_t*)&router) < 0) error_exit("malformed static route option");
+      options_list[count].val = xrealloc(options_list[count].val, options_list[count].len + 1 + mask/8 + 4);
+      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &mask, 1);
+      options_list[count].len += 1;
+      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &nip, mask/8);
+      options_list[count].len += mask/8;
+      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &router, 4);
+      options_list[count].len += 4;
+      tp = NULL;
+      grp = strtok(NULL, ",");
+    }
+    break;
+  }
+  return 0;
+}
+
+// Creates environment pointers from RES to use in script
+static int fill_envp(dhcpc_result_t *res)
+{
+  struct in_addr temp;
+  int size = ARRAY_LEN(options_list), count, ret = -1;
+
+  ret = setenv("interface", state->iface, 1);
+  if (!res) return ret;
+  if (res->ipaddr.s_addr) {
+      temp.s_addr = htonl(res->ipaddr.s_addr);
+      ret = setenv("ip", inet_ntoa(temp), 1);
+      if (ret) return ret;
+  }
+  if (msgopt_list) {
+    for (count = 0; count < size; count++) {
+        if ((msgopt_list[count].len == 0) || (msgopt_list[count].val == NULL)) continue;
+        ret = setenv(msgopt_list[count].key, (char*)msgopt_list[count].val, 1);
+        if (ret) return ret;
+      }
+  }
+  return ret;
+}
+
+// Executes Script NAME.
+static void run_script(dhcpc_result_t *res,  char *name)
+{
+  volatile int error = 0;
+  pid_t pid;
+  char *argv[3];
+  struct stat sts;
+  char *script = flag_get(FLAG_s, TT.script, "/usr/share/dhcp/default.script");
+
+  if (stat(script, &sts) == -1 && errno == ENOENT) return;
+  if (fill_envp(res)) {
+    dbg("Failed to create environment variables.");
+    return;
+  }
+  dbg("Executing %s %s\n", script, name);
+  argv[0] = (char*) script;
+  argv[1] = (char*) name;
+  argv[2] = NULL;
+  fflush(NULL);
+
+  pid = vfork();
+  if (pid < 0) {
+    dbg("Fork failed.\n");
+    return;
+  }
+  if (!pid) {
+    execvp(argv[0], argv);
+    error = errno;
+    _exit(111);
+  }
+  if (error) {
+    waitpid(pid, NULL,0);
+    errno = error;
+    perror_msg("script exec failed");
+  }
+  dbg("script complete.\n");
+}
+
+// returns a randome ID
+static uint32_t getxid(void)
+{
+  uint32_t randnum;
+  int fd = xopen("/dev/urandom", O_RDONLY);
+  xreadall(fd, &randnum, sizeof(randnum));
+  xclose(fd);
+  return randnum;
+}
+
+// opens socket in raw mode.
+static int mode_raw(void)
+{
+  state->mode = MODE_OFF;
+  struct sockaddr_ll sock;
+
+  if (state->sockfd > 0) close(state->sockfd);
+  dbg("Opening raw socket on ifindex %d\n", state->ifindex);
+
+  state->sockfd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+  if (state->sockfd < 0) {
+    dbg("MODE RAW : socket fail ERROR : %d\n", state->sockfd);
+    return -1;
+  }
+  dbg("Got raw socket fd %d\n", state->sockfd);
+  memset(&sock, 0, sizeof(sock));
+  sock.sll_family = AF_PACKET;
+  sock.sll_protocol = htons(ETH_P_IP);
+  sock.sll_ifindex = state->ifindex;
+
+  if (bind(state->sockfd, (struct sockaddr *) &sock, sizeof(sock))) {
+    dbg("MODE RAW : bind fail.\n");
+    close(state->sockfd);
+    return -1;
+  }
+  state->mode = MODE_RAW;
+  if (setsockopt(state->sockfd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog, sizeof(filter_prog)) < 0)
+    dbg("MODE RAW : filter attach fail.\n");
+
+  dbg("MODE RAW : success\n");
+  return 0;
+}
+
+// opens UDP socket
+static int mode_app(void)
+{
+  struct sockaddr_in addr;
+  struct ifreq ifr;
+
+  state->mode = MODE_OFF;
+  if (state->sockfd > 0) close(state->sockfd);
+
+  dbg("Opening listen socket on *:%d %s\n", DHCPC_CLIENT_PORT, state->iface);
+  state->sockfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (state->sockfd < 0) {
+    dbg("MODE APP : socket fail ERROR: %d\n", state->sockfd);
+    return -1;
+  }
+  setsockopt(state->sockfd, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set));
+  if (setsockopt(state->sockfd, SOL_SOCKET, SO_BROADCAST, &set, sizeof(set)) == -1) {
+    dbg("MODE APP : brodcast failed.\n");
+    close(state->sockfd);
+    return -1;
+  }
+  strncpy(ifr.ifr_name, state->iface, IFNAMSIZ);
+  ifr.ifr_name[IFNAMSIZ -1] = '\0';
+  setsockopt(state->sockfd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr));
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(DHCPC_CLIENT_PORT);
+  addr.sin_addr.s_addr = INADDR_ANY ;
+
+  if (bind(state->sockfd, (struct sockaddr *) &addr, sizeof(addr))) {
+    close(state->sockfd);
+    dbg("MODE APP : bind failed.\n");
+    return -1;
+  }
+  state->mode = MODE_APP;
+  dbg("MODE APP : success\n");
+  return 0;
+}
+
+static int read_raw(void)
+{
+  dhcp_raw_t packet;
+  uint16_t check;
+  int bytes = 0;
+
+  memset(&packet, 0, sizeof(packet));
+  if ((bytes = read(state->sockfd, &packet, sizeof(packet))) < 0) {
+    dbg("\tPacket read error, ignoring\n");
+    return bytes;
+  }
+  if (bytes < (int) (sizeof(packet.iph) + sizeof(packet.udph))) {
+    dbg("\tPacket is too short, ignoring\n");
+    return -2;
+  }
+  if (bytes < ntohs(packet.iph.tot_len)) {
+    dbg("\tOversized packet, ignoring\n");
+    return -2;
+  }
+  // ignore any extra garbage bytes
+  bytes = ntohs(packet.iph.tot_len);
+  // make sure its the right packet for us, and that it passes sanity checks 
+  if (packet.iph.protocol != IPPROTO_UDP || packet.iph.version != IPVERSION
+   || packet.iph.ihl != (sizeof(packet.iph) >> 2)
+   || packet.udph.dest != htons(DHCPC_CLIENT_PORT)
+   || ntohs(packet.udph.len) != (uint16_t)(bytes - sizeof(packet.iph))) {
+    dbg("\tUnrelated/bogus packet, ignoring\n");
+    return -2;
+  }
+  // verify IP checksum
+  check = packet.iph.check;
+  packet.iph.check = 0;
+  if (check != dhcp_checksum(&packet.iph, sizeof(packet.iph))) {
+    dbg("\tBad IP header checksum, ignoring\n");
+    return -2;
+  }
+  memset(&packet.iph, 0, ((size_t) &((struct iphdr *)0)->protocol));
+  packet.iph.tot_len = packet.udph.len;
+  check = packet.udph.check;
+  packet.udph.check = 0;
+  if (check && check != dhcp_checksum(&packet, bytes)) {
+    dbg("\tPacket with bad UDP checksum received, ignoring\n");
+    return -2;
+  }
+  memcpy(&state->pdhcp, &packet.dhcp, bytes - (sizeof(packet.iph) + sizeof(packet.udph)));
+  if (state->pdhcp.cookie != htonl(DHCP_MAGIC)) {
+    dbg("\tPacket with bad magic, ignoring\n");
+    return -2;
+  }
+  return bytes - sizeof(packet.iph) - sizeof(packet.udph);
+}
+
+static int read_app(void)
+{
+  int ret;
+
+  memset(&state->pdhcp, 0, sizeof(dhcp_msg_t));
+  if ((ret = read(state->sockfd, &state->pdhcp, sizeof(dhcp_msg_t))) < 0) {
+    dbg("Packet read error, ignoring\n");
+    return ret; /* returns -1 */
+  }
+  if (state->pdhcp.cookie != htonl(DHCP_MAGIC)) {
+    dbg("Packet with bad magic, ignoring\n");
+    return -2;
+  }
+  return ret;
+}
+
+// Sends data through raw socket.
+static int send_raw(void)
+{
+  struct sockaddr_ll dest_sll;
+  dhcp_raw_t packet;
+  unsigned padding;
+  int fd, result = -1;
+
+  memset(&packet, 0, sizeof(dhcp_raw_t));
+  memcpy(&packet.dhcp, &state->pdhcp, sizeof(dhcp_msg_t));
+
+  if ((fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
+    dbg("SEND RAW: socket failed\n");
+    return result;
+  }
+  memset(&dest_sll, 0, sizeof(dest_sll));
+  dest_sll.sll_family = AF_PACKET;
+  dest_sll.sll_protocol = htons(ETH_P_IP);
+  dest_sll.sll_ifindex = state->ifindex;
+  dest_sll.sll_halen = 6;
+  memcpy(dest_sll.sll_addr, bmacaddr , 6);
+
+  if (bind(fd, (struct sockaddr *) &dest_sll, sizeof(dest_sll)) < 0) {
+    dbg("SEND RAW: bind failed\n");
+    close(fd);
+    return result;
+  }
+  padding = 308 - 1 - dhcp_opt_size(state->pdhcp.options);
+  packet.iph.protocol = IPPROTO_UDP;
+  packet.iph.saddr = INADDR_ANY;
+  packet.iph.daddr = INADDR_BROADCAST;
+  packet.udph.source = htons(DHCPC_CLIENT_PORT);
+  packet.udph.dest = htons(DHCPC_SERVER_PORT);
+  packet.udph.len = htons(sizeof(dhcp_raw_t) - sizeof(struct iphdr) - padding);
+  packet.iph.tot_len = packet.udph.len;
+  packet.udph.check = dhcp_checksum(&packet, sizeof(dhcp_raw_t) - padding);
+  packet.iph.tot_len = htons(sizeof(dhcp_raw_t) - padding);
+  packet.iph.ihl = sizeof(packet.iph) >> 2;
+  packet.iph.version = IPVERSION;
+  packet.iph.ttl = IPDEFTTL;
+  packet.iph.check = dhcp_checksum(&packet.iph, sizeof(packet.iph));
+
+  result = sendto(fd, &packet, sizeof(dhcp_raw_t) - padding, 0,
+      (struct sockaddr *) &dest_sll, sizeof(dest_sll));
+
+  close(fd);
+  if (result < 0) dbg("SEND RAW: PACKET send error\n");
+  return result;
+}
+
+// Sends data through UDP socket.
+static int send_app(void)
+{
+  struct sockaddr_in cli;
+  int fd, ret = -1;
+
+  if ((fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+    dbg("SEND APP: sock failed.\n");
+    return ret;
+  }
+  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set));
+
+  memset(&cli, 0, sizeof(cli));
+  cli.sin_family = AF_INET;
+  cli.sin_port = htons(DHCPC_CLIENT_PORT);
+  cli.sin_addr.s_addr = state->pdhcp.ciaddr;
+  if (bind(fd, (struct sockaddr *)&cli, sizeof(cli)) == -1) {
+    dbg("SEND APP: bind failed.\n");
+    goto error_fd;
+  }
+  memset(&cli, 0, sizeof(cli));
+  cli.sin_family = AF_INET;
+  cli.sin_port = htons(DHCPC_SERVER_PORT);
+  cli.sin_addr.s_addr = state->serverid.s_addr;
+  if (connect(fd, (struct sockaddr *)&cli, sizeof(cli)) == -1) {
+    dbg("SEND APP: connect failed.\n");
+    goto error_fd;
+  }
+  int padding = 308 - 1 - dhcp_opt_size(state->pdhcp.options);
+  if((ret = write(fd, &state->pdhcp, sizeof(dhcp_msg_t) - padding)) < 0) {
+    dbg("SEND APP: write failed error %d\n", ret);
+    goto error_fd;
+  }
+  dbg("SEND APP: write success wrote %d\n", ret);
+error_fd:
+  close(fd);
+  return ret;
+}
+
+// Generic signal handler real handling is done in main funcrion.
+static void signal_handler(int sig)
+{
+  unsigned char ch = sig;
+  if (write(sigfd.wr, &ch, 1) != 1) dbg("can't send signal\n");
+}
+
+// signal setup for SIGUSR1 SIGUSR2 SIGTERM
+static int setup_signal()
+{
+  if (pipe((int *)&sigfd) < 0) {
+    dbg("signal pipe failed\n");
+    return -1;
+  }
+  fcntl(sigfd.wr , F_SETFD, FD_CLOEXEC);
+  fcntl(sigfd.rd , F_SETFD, FD_CLOEXEC);
+  int flags = fcntl(sigfd.wr, F_GETFL);
+  fcntl(sigfd.wr, F_SETFL, flags | O_NONBLOCK);
+  signal(SIGUSR1, signal_handler);
+  signal(SIGUSR2, signal_handler);
+  signal(SIGTERM, signal_handler);
+
+  return 0;
+}
+
+// adds client id to dhcp packet
+static uint8_t *dhcpc_addclientid(uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_CLIENTID;
+  *optptr++ = 7;
+  *optptr++ = 1;
+  memcpy(optptr, &state->macaddr, 6);
+  return optptr + 6;
+}
+
+// adds messege type to dhcp packet
+static uint8_t *dhcpc_addmsgtype(uint8_t *optptr, uint8_t type)
+{
+  *optptr++ = DHCP_OPTION_MSG_TYPE;
+  *optptr++ = 1;
+  *optptr++ = type;
+  return optptr;
+}
+
+// adds max size to dhcp packet
+static uint8_t *dhcpc_addmaxsize(uint8_t *optptr, uint16_t size)
+{
+  *optptr++ = DHCP_OPTION_MAX_SIZE;
+  *optptr++ = 2;
+  memcpy(optptr, &size, 2);
+  return optptr + 2;
+}
+
+static uint8_t *dhcpc_addstropt(uint8_t *optptr, uint8_t opcode, char* str, int len)
+{
+  *optptr++ = opcode;
+  *optptr++ = len;
+  memcpy(optptr, str, len);
+  return optptr + len;
+}
+
+// adds server id to dhcp packet.
+static uint8_t *dhcpc_addserverid(struct in_addr *serverid, uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_SERVER_ID;
+  *optptr++ = 4;
+  memcpy(optptr, &serverid->s_addr, 4);
+  return optptr + 4;
+}
+
+// adds requested ip address to dhcp packet.
+static uint8_t *dhcpc_addreqipaddr(struct in_addr *ipaddr, uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_REQ_IPADDR;
+  *optptr++ = 4;
+  memcpy(optptr, &ipaddr->s_addr, 4);
+  return optptr + 4;
+}
+
+// adds hostname to dhcp packet.
+static uint8_t *dhcpc_addfdnname(uint8_t *optptr,  char *hname)
+{
+  int size = strlen(hname);
+  *optptr++ = DHCP_OPTION_FQDN;
+  *optptr++ = size + 3;
+  *optptr++ = 0x1;  //flags
+  optptr += 2;      // two blank bytes
+  strncpy((char*)optptr, hname, size); // name
+  return optptr + size;
+}
+
+// adds request options using -o,-O flag to dhcp packet
+static uint8_t *dhcpc_addreqoptions(uint8_t *optptr)
+{
+  uint8_t *len;
+
+  *optptr++ = DHCP_OPTION_REQ_LIST;
+  len = optptr;
+  *len = 0;
+  optptr++;
+
+  if (!flag_chk(FLAG_o)) {
+    *len = 4;
+    *optptr++ = DHCP_OPTION_SUBNET_MASK;
+    *optptr++ = DHCP_OPTION_ROUTER;
+    *optptr++ = DHCP_OPTION_DNS_SERVER;
+    *optptr++ = DHCP_OPTION_BROADCAST;
+  }
+  if (flag_chk(FLAG_O)) {
+    memcpy(optptr++, raw_opt, raw_optcount);
+    *len += raw_optcount;
+  }
+  return optptr;
+}
+
+static uint8_t *dhcpc_addend(uint8_t *optptr)
+{
+  *optptr++ = DHCP_OPTION_END;
+  return optptr;
+}
+
+// Sets values of -x options in dhcp discover and request packet.
+static uint8_t* set_xopt(uint8_t *optptr)
+{
+  int count;
+  int size = ARRAY_LEN(options_list);
+  for (count = 0; count < size; count++) {
+    if ((options_list[count].len == 0) || (options_list[count].val == NULL)) continue;
+    *optptr++ = (uint8_t) (options_list[count].code & 0x00FF);
+    *optptr++ = (uint8_t) options_list[count].len;
+    memcpy(optptr, options_list[count].val, options_list[count].len);
+    optptr += options_list[count].len;
+  }
+  return optptr;
+}
+
+static uint32_t get_option_serverid (uint8_t *opt, dhcpc_result_t *presult)
+{
+  uint32_t var = 0;
+  while (*opt != DHCP_OPTION_SERVER_ID) {
+    if (*opt == DHCP_OPTION_END) return var;
+    opt += opt[1] + 2;
+  }
+  memcpy(&var, opt+2, sizeof(uint32_t));
+  state->serverid.s_addr = var;
+  presult->serverid.s_addr = state->serverid.s_addr;
+  presult->serverid.s_addr = ntohl(presult->serverid.s_addr);
+  return var;
+}
+
+static uint8_t get_option_msgtype(uint8_t *opt)
+{
+  uint32_t var = 0;
+  while (*opt != DHCP_OPTION_MSG_TYPE) {
+    if (*opt == DHCP_OPTION_END) return var;
+    opt += opt[1] + 2;
+  }
+  memcpy(&var, opt+2, sizeof(uint8_t));
+  return var;
+}
+
+static uint8_t get_option_lease(uint8_t *opt, dhcpc_result_t *presult)
+{
+  uint32_t var = 0;
+  while (*opt != DHCP_OPTION_LEASE_TIME) {
+    if (*opt == DHCP_OPTION_END) return var;
+    opt += opt[1] + 2;
+  }
+  memcpy(&var, opt+2, sizeof(uint32_t));
+  var = htonl(var);
+  presult->lease_time = var;
+  return var;
+}
+
+
+// sends dhcp msg of MSGTYPE
+static int dhcpc_sendmsg(int msgtype)
+{
+  uint8_t *pend;
+  struct in_addr rqsd;
+  char *vendor;
+
+  // Create the common message header settings
+  memset(&state->pdhcp, 0, sizeof(dhcp_msg_t));
+  state->pdhcp.op = DHCP_REQUEST;
+  state->pdhcp.htype = DHCP_HTYPE_ETHERNET;
+  state->pdhcp.hlen = 6;
+  state->pdhcp.xid = xid;
+  memcpy(state->pdhcp.chaddr, state->macaddr, 6);
+  memset(&state->pdhcp.chaddr[6], 0, 10);
+  state->pdhcp.cookie = htonl(DHCP_MAGIC);;
+
+  // Add the common header options
+  pend = state->pdhcp.options;
+  pend = dhcpc_addmsgtype(pend, msgtype);
+
+  if (!flag_chk(FLAG_C)) pend = dhcpc_addclientid(pend);
+  // Handle the message specific settings
+  switch (msgtype) {
+  case DHCPDISCOVER: // Broadcast DISCOVER message to all servers
+    state->pdhcp.flags = htons(BOOTP_BROADCAST); //  Broadcast bit.
+    if (flag_chk(FLAG_r)) {
+      inet_aton(TT.req_ip, &rqsd);
+      pend = dhcpc_addreqipaddr(&rqsd, pend);
+    }
+    pend = dhcpc_addmaxsize(pend, htons(sizeof(dhcp_raw_t)));
+    vendor = flag_get(FLAG_V, TT.vendor_cls, "toybox\0");
+    pend = dhcpc_addstropt(pend, DHCP_OPTION_VENDOR, vendor, strlen(vendor));
+    if (flag_chk(FLAG_H)) pend = dhcpc_addstropt(pend, DHCP_OPTION_HOST_NAME, TT.hostname, strlen(TT.hostname));
+    if (flag_chk(FLAG_F)) pend = dhcpc_addfdnname(pend, TT.fdn_name);
+    if ((!flag_chk(FLAG_o)) || flag_chk(FLAG_O)) pend = dhcpc_addreqoptions(pend);
+    if (flag_chk(FLAG_x)) pend = set_xopt(pend);
+    break;
+  case DHCPREQUEST: // Send REQUEST message to the server that sent the *first* OFFER
+    state->pdhcp.flags = htons(BOOTP_BROADCAST); //  Broadcast bit.
+    if (state->status == STATE_RENEWING) memcpy(&state->pdhcp.ciaddr, &state->ipaddr.s_addr, 4);
+    pend = dhcpc_addmaxsize(pend, htons(sizeof(dhcp_raw_t)));
+    rqsd.s_addr = htonl(server);
+    pend = dhcpc_addserverid(&rqsd, pend);
+    pend = dhcpc_addreqipaddr(&state->ipaddr, pend);
+    vendor = flag_get(FLAG_V, TT.vendor_cls, "toybox\0");
+    pend = dhcpc_addstropt(pend, DHCP_OPTION_VENDOR, vendor, strlen(vendor));
+    if (flag_chk(FLAG_H)) pend = dhcpc_addstropt(pend, DHCP_OPTION_HOST_NAME, TT.hostname, strlen(TT.hostname));
+    if (flag_chk(FLAG_F)) pend = dhcpc_addfdnname(pend, TT.fdn_name);
+    if ((!flag_chk(FLAG_o)) || flag_chk(FLAG_O)) pend = dhcpc_addreqoptions(pend);
+    if (flag_chk(FLAG_x)) pend = set_xopt(pend);
+    break;
+  case DHCPRELEASE: // Send RELEASE message to the server.
+    memcpy(&state->pdhcp.ciaddr, &state->ipaddr.s_addr, 4);
+    rqsd.s_addr = htonl(server);
+    pend = dhcpc_addserverid(&rqsd, pend);
+    break;
+  default:
+    return -1;
+  }
+  pend = dhcpc_addend(pend);
+
+  if (state->mode == MODE_APP) return send_app();
+  return send_raw();
+}
+
+/*
+ * parses options from received dhcp packet at OPTPTR and
+ * stores result in PRESULT or MSGOPT_LIST
+ */
+static uint8_t dhcpc_parseoptions(dhcpc_result_t *presult, uint8_t *optptr)
+{
+  uint8_t type = 0, *options, overloaded = 0;;
+  uint16_t flag = 0;
+  uint32_t convtmp = 0;
+  char *dest, *pfx;
+  struct in_addr addr;
+  int count, optlen, size = ARRAY_LEN(options_list);
+
+  if (flag_chk(FLAG_x)) {
+    if(msgopt_list){
+      for (count = 0; count < size; count++){
+        if(msgopt_list[count].val) free(msgopt_list[count].val);
+        msgopt_list[count].val = NULL;
+        msgopt_list[count].len = 0;
+      }
+    } else {
+     msgopt_list = xmalloc(sizeof(options_list));
+     memcpy(msgopt_list, options_list, sizeof(options_list));
+     for (count = 0; count < size; count++) {
+         msgopt_list[count].len = 0;
+         msgopt_list[count].val = NULL;
+     }
+    }
+  } else {
+    msgopt_list = options_list;
+    for (count = 0; count < size; count++) {
+      msgopt_list[count].len = 0;
+      if(msgopt_list[count].val) free(msgopt_list[count].val);
+      msgopt_list[count].val = NULL;
+    }
+  }
+
+  while (*optptr != DHCP_OPTION_END) {
+    while (*optptr == DHCP_OPTION_PADDING) optptr++;
+    if (*optptr == DHCP_OPTION_OVERLOAD) {
+      overloaded = optptr[2];
+      optptr += optptr[1] + 2;
+      continue;
+    }
+    for (count = 0, flag = 0; count < size; count++) {
+      if ((msgopt_list[count].code & 0X00FF) == *optptr) {
+        flag = (msgopt_list[count].code & 0XFF00);
+        break;
+      }
+    }
+    switch (flag) {
+    case DHCP_NUM32:
+      memcpy(&convtmp, &optptr[2], sizeof(uint32_t));
+      convtmp = htonl(convtmp);
+      sprintf(toybuf, "%u", convtmp);
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    case DHCP_NUM16:
+      memcpy(&convtmp, &optptr[2], sizeof(uint16_t));
+      convtmp = htons(convtmp);
+      sprintf(toybuf, "%u", convtmp);
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    case DHCP_NUM8:
+      memcpy(&convtmp, &optptr[2], sizeof(uint8_t));
+      sprintf(toybuf, "%u", convtmp);
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    case DHCP_IP:
+      memcpy(&convtmp, &optptr[2], sizeof(uint32_t));
+      addr.s_addr = convtmp;
+      sprintf(toybuf, "%s", inet_ntoa(addr));
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    case DHCP_STRING:
+      sprintf(toybuf, "%.*s", optptr[1], &optptr[2]);
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    case DHCP_IPLIST:
+      optlen = optptr[1];
+      dest = toybuf;
+      while (optlen) {
+        memcpy(&convtmp, &optptr[2], sizeof(uint32_t));
+        addr.s_addr = convtmp;
+        dest += sprintf(dest, "%s ", inet_ntoa(addr));
+        optlen -= 4;
+      }
+      *(dest - 1) = '\0';
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    case DHCP_STRLST: //FIXME: do smthing.
+    case DHCP_IPPLST:
+      break;
+    case DHCP_STCRTS:
+      pfx = "";
+      dest = toybuf;
+      options = &optptr[2];
+      optlen = optptr[1];
+
+      while (optlen >= 1 + 4) {
+        uint32_t nip = 0;
+        int bytes;
+        uint8_t *p_tmp;
+        unsigned mask = *options;
+
+        if (mask > 32) break;
+        optlen--;
+        p_tmp = (void*) &nip;
+        bytes = (mask + 7) / 8;
+        while (--bytes >= 0) {
+          *p_tmp++ = *options++;
+          optlen--;
+        }
+        if (optlen < 4) break;
+        dest += sprintf(dest, "%s%u.%u.%u.%u", pfx, ((uint8_t*) &nip)[0],
+            ((uint8_t*) &nip)[1], ((uint8_t*) &nip)[2], ((uint8_t*) &nip)[3]);
+        pfx = " ";
+        dest += sprintf(dest, "/%u ", mask);
+        dest += sprintf(dest, "%u.%u.%u.%u", options[0], options[1], options[2], options[3]);
+        options += 4;
+        optlen -= 4;
+      }
+      msgopt_list[count].val = strdup(toybuf);
+      msgopt_list[count].len = strlen(toybuf);
+      break;
+    default: break;
+    }
+    optptr += optptr[1] + 2;
+  }
+  if ((overloaded == 1) || (overloaded == 3)) dhcpc_parseoptions(presult, optptr);
+  if ((overloaded == 2) || (overloaded == 3)) dhcpc_parseoptions(presult, optptr);
+  return type;
+}
+
+// parses recvd messege to check that it was for us.
+static uint8_t dhcpc_parsemsg(dhcpc_result_t *presult)
+{
+  if (state->pdhcp.op == DHCP_REPLY
+      && !memcmp(state->pdhcp.chaddr, state->macaddr, 6)
+      && !memcmp(&state->pdhcp.xid, &xid, sizeof(xid))) {
+    memcpy(&presult->ipaddr.s_addr, &state->pdhcp.yiaddr, 4);
+    presult->ipaddr.s_addr = ntohl(presult->ipaddr.s_addr);
+    return get_option_msgtype(state->pdhcp.options);
+  }
+  return 0;
+}
+
+// Sends a IP renew request.
+static void renew(void)
+{
+  infomsg(infomode, "Performing a DHCP renew");
+  switch (state->status) {
+  case STATE_INIT:
+    break;
+  case STATE_BOUND:
+    mode_raw();
+  case STATE_RENEWING:    // FALLTHROUGH 
+  case STATE_REBINDING:   // FALLTHROUGH 
+    state->status = STATE_RENEW_REQUESTED;
+    break;
+  case STATE_RENEW_REQUESTED:
+    run_script(NULL, "deconfig");
+  case STATE_REQUESTING:           // FALLTHROUGH 
+  case STATE_RELEASED:             // FALLTHROUGH 
+    mode_raw();
+    state->status = STATE_INIT;
+    break;
+  default: break;
+  }
+}
+
+// Sends a IP release request.
+static void release(void)
+{
+  int len = sizeof("255.255.255.255\0");
+  char buffer[len];
+  struct in_addr temp_addr;
+
+  mode_app();
+  // send release packet
+  if (state->status == STATE_BOUND || state->status == STATE_RENEWING || state->status == STATE_REBINDING) {
+    temp_addr.s_addr = htonl(server);
+    strncpy(buffer, inet_ntoa(temp_addr), sizeof(buffer));
+    buffer[len - 1] = '\0';
+    temp_addr.s_addr = state->ipaddr.s_addr;
+    infomsg( infomode, "Unicasting a release of %s to %s", inet_ntoa(temp_addr), buffer);
+    dhcpc_sendmsg(DHCPRELEASE);
+    run_script(NULL, "deconfig");
+  }
+  infomsg(infomode, "Entering released state");
+  close(state->sockfd);
+  state->sockfd = -1;
+  state->mode = MODE_OFF;
+  state->status = STATE_RELEASED;
+}
+
+static void free_option_stores(void)
+{
+  int count, size = ARRAY_LEN(options_list);
+  for (count = 0; count < size; count++)
+    if (options_list[count].val) free(options_list[count].val);
+  if(flag_chk(FLAG_x)){
+    for (count = 0; count < size; count++)
+        if (msgopt_list[count].val) free(msgopt_list[count].val);
+    free(msgopt_list);
+  }
+}
+
+void dhcp_main(void)
+{
+  struct timeval tv;
+  int retval, bufflen = 0;
+  dhcpc_result_t result;
+  uint8_t packets = 0, retries = 0;
+  uint32_t timeout = 0, waited = 0;
+  fd_set rfds;
+
+  xid = 0;
+  setlinebuf(stdout);
+  dbg = dummy;
+  if (flag_chk(FLAG_v)) dbg = xprintf;
+  if (flag_chk(FLAG_p)) write_pid(TT.pidfile);
+  retries = flag_get(FLAG_t, TT.retries, 3);
+  if (flag_chk(FLAG_S)) {
+      openlog("UDHCPC :", LOG_PID, LOG_DAEMON);
+      infomode |= LOG_SYSTEM;
+  }
+  infomsg(infomode, "dhcp started");
+  if (flag_chk(FLAG_O)) {
+    while (TT.req_opt) {
+      raw_opt[raw_optcount] = (uint8_t) strtoopt(TT.req_opt->arg, 1);
+      raw_optcount++;
+      TT.req_opt = TT.req_opt->next;
+    }
+  }
+  if (flag_chk(FLAG_x)) {
+    while (TT.pkt_opt) {
+      (void) strtoopt(TT.pkt_opt->arg, 0);
+      TT.pkt_opt = TT.pkt_opt->next;
+    }
+  }
+  memset(&result, 0, sizeof(dhcpc_result_t));
+  state = (dhcpc_state_t*) xmalloc(sizeof(dhcpc_state_t));
+  memset(state, 0, sizeof(dhcpc_state_t));
+  state->iface = flag_get(FLAG_i, TT.iface, "eth0");
+
+  if (get_interface(state->iface, &state->ifindex, NULL, state->macaddr))
+    perror_exit("Failed to get interface %s", state->iface);
+
+  run_script(NULL, "deconfig");
+  setup_signal();
+  state->status = STATE_INIT;
+  mode_raw();
+  fcntl(state->sockfd, F_SETFD, FD_CLOEXEC);
+
+  for (;;) {
+    FD_ZERO(&rfds);
+    if (state->sockfd >= 0) FD_SET(state->sockfd, &rfds);
+    FD_SET(sigfd.rd, &rfds);
+    tv.tv_sec = timeout - waited;
+    tv.tv_usec = 0;
+    retval = 0;
+
+    int maxfd = (sigfd.rd > state->sockfd)? sigfd.rd : state->sockfd;
+    dbg("select wait ....\n");
+    uint32_t timestmp = time(NULL);
+    if((retval = select(maxfd + 1, &rfds, NULL, NULL, &tv)) < 0) {
+      if (errno == EINTR) {
+        waited += (unsigned) time(NULL) - timestmp;
+        continue;
+      }
+      perror_exit("Error in select");
+    }
+    if (!retval) { // Timed out
+      if (get_interface(state->iface, &state->ifindex, NULL, state->macaddr))
+        error_exit("Interface lost %s\n", state->iface);
+
+      switch (state->status) {
+      case STATE_INIT:
+        if (packets < retries) {
+          if (!packets) xid = getxid();
+          run_script(NULL, "deconfig");
+          infomsg(infomode, "Sending discover...");
+          dhcpc_sendmsg(DHCPDISCOVER);
+          server = 0;
+          timeout = flag_get(FLAG_T, TT.timeout, 3);
+          waited = 0;
+          packets++;
+          continue;
+        }
+lease_fail:
+        run_script(NULL,"leasefail");
+        if (flag_chk(FLAG_n)) {
+          infomsg(infomode, "Lease failed. Exiting");
+          goto ret_with_sockfd;
+        }
+        if (flag_chk(FLAG_b)) {
+          infomsg(infomode, "Lease failed. Going Daemon mode");
+          dhcp_daemon();
+          if (flag_chk(FLAG_p)) write_pid(TT.pidfile);
+          toys.optflags &= ~FLAG_b;
+          toys.optflags |= FLAG_f;
+        }
+        timeout = flag_get(FLAG_A, TT.tryagain, 20);
+        waited = 0;
+        packets = 0;
+        continue;
+      case STATE_REQUESTING:
+        if (packets < retries) {
+          memcpy(&state->ipaddr.s_addr,&state->pdhcp.yiaddr, 4);
+          dhcpc_sendmsg(DHCPREQUEST);
+          infomsg(infomode, "Sending select for %d.%d.%d.%d...",
+              (result.ipaddr.s_addr >> 24) & 0xff, (result.ipaddr.s_addr >> 16) & 0xff, (result.ipaddr.s_addr >> 8) & 0xff, (result.ipaddr.s_addr) & 0xff);
+          timeout = flag_get(FLAG_T, TT.timeout, 3);
+          waited = 0;
+          packets++;
+          continue;
+        }
+        mode_raw();
+        state->status = STATE_INIT;
+        goto lease_fail;
+      case STATE_BOUND:
+        state->status = STATE_RENEWING;
+        dbg("Entering renew state\n");
+        // FALLTHROUGH
+      case STATE_RENEW_REQUESTED:   // FALLTHROUGH
+      case STATE_RENEWING:
+renew_requested:
+        if (timeout > 60) {
+          dhcpc_sendmsg(DHCPREQUEST);
+          timeout >>= 1;
+          waited = 0;
+          continue;
+        }
+        dbg("Entering rebinding state\n");
+        state->status = STATE_REBINDING;
+        // FALLTHROUGH
+      case STATE_REBINDING:
+        mode_raw();
+        if (timeout > 0) {
+          dhcpc_sendmsg(DHCPREQUEST);
+          timeout >>= 1;
+          waited = 0;
+          continue;
+        }
+        infomsg(infomode, "Lease lost, entering INIT state");
+        run_script(NULL, "deconfig");
+        state->status = STATE_INIT;
+        timeout = 0;
+        waited = 0;
+        packets = 0;
+        continue;
+      default: break;
+      }
+      timeout = INT_MAX;
+      waited = 0;
+      continue;
+    }
+    if (FD_ISSET(sigfd.rd, &rfds)) { // Some Activity on RDFDs : is signal
+      unsigned char sig;
+      if (read(sigfd.rd, &sig, 1) != 1) {
+        dbg("signal read failed.\n");
+        continue;
+      }
+      switch (sig) {
+      case SIGUSR1:
+        infomsg(infomode, "Received SIGUSR1");
+        renew();
+        packets = 0;
+        waited = 0;
+        if (state->status == STATE_RENEW_REQUESTED) goto renew_requested;
+        if (state->status == STATE_INIT) timeout = 0;
+        continue;
+      case SIGUSR2:
+        infomsg(infomode, "Received SIGUSR2");
+        release();
+        timeout = INT_MAX;
+        waited = 0;
+        packets = 0;
+        continue;
+      case SIGTERM:
+        infomsg(infomode, "Received SIGTERM");
+        if (flag_chk(FLAG_R)) release();
+        goto ret_with_sockfd;
+      default: break;
+      }
+    }
+    if (FD_ISSET(state->sockfd, &rfds)) { // Some Activity on RDFDs : is socket
+      dbg("main sock read\n");
+      uint8_t msgType;
+      if (state->mode == MODE_RAW) bufflen = read_raw();
+      if (state->mode == MODE_APP) bufflen = read_app();
+      if (bufflen < 0) {
+        if (state->mode == MODE_RAW) mode_raw();
+        if (state->mode == MODE_APP) mode_app();
+        continue;
+      }
+      waited += time(NULL) - timestmp;
+      memset(&result, 0, sizeof(dhcpc_result_t));
+      msgType = dhcpc_parsemsg(&result);
+      if (msgType != DHCPNAK && result.ipaddr.s_addr == 0 ) continue;       // no ip for me ignore
+      if (!msgType || !get_option_serverid(state->pdhcp.options, &result)) continue; //no server id ignore
+      if (msgType == DHCPOFFER && server == 0) server = result.serverid.s_addr; // select the server
+      if (result.serverid.s_addr != server) continue; // not from the server we requested ignore
+      dhcpc_parseoptions(&result, state->pdhcp.options);
+      get_option_lease(state->pdhcp.options, &result);
+
+      switch (state->status) {
+      case STATE_INIT:
+        if (msgType == DHCPOFFER) {
+          state->status = STATE_REQUESTING;
+          mode_raw();
+          timeout = 0;
+          waited = 0;
+          packets = 0;
+        }
+        continue;
+      case STATE_REQUESTING:         // FALLTHROUGH
+      case STATE_RENEWING:           // FALLTHROUGH
+      case STATE_RENEW_REQUESTED:    // FALLTHROUGH
+      case STATE_REBINDING:
+        if (msgType == DHCPACK) {
+          timeout = result.lease_time / 2;
+          run_script(&result, state->status == STATE_REQUESTING ? "bound" : "renew");
+          state->status = STATE_BOUND;
+          infomsg(infomode, "Lease of %d.%d.%d.%d obtained, lease time %d from server %d.%d.%d.%d",
+              (result.ipaddr.s_addr >> 24) & 0xff, (result.ipaddr.s_addr >> 16) & 0xff, (result.ipaddr.s_addr >> 8) & 0xff, (result.ipaddr.s_addr) & 0xff,
+              result.lease_time,
+              (result.serverid.s_addr >> 24) & 0xff, (result.serverid.s_addr >> 16) & 0xff, (result.serverid.s_addr >> 8) & 0xff, (result.serverid.s_addr) & 0xff);
+          if (flag_chk(FLAG_q)) {
+            if (flag_chk(FLAG_R)) release();
+            goto ret_with_sockfd;
+          }
+          toys.optflags &= ~FLAG_n;
+          if (!flag_chk(FLAG_f)) {
+            dhcp_daemon();
+            toys.optflags |= FLAG_f;
+            if (flag_chk(FLAG_p)) write_pid(TT.pidfile);
+          }
+          waited = 0;
+          continue;
+        } else if (msgType == DHCPNAK) {
+          dbg("NACK received.\n");
+          run_script(&result, "nak");
+          if (state->status != STATE_REQUESTING) run_script(NULL, "deconfig");
+          mode_raw();
+          sleep(3);
+          state->status = STATE_INIT;
+          state->ipaddr.s_addr = 0;
+          server = 0;
+          timeout = 0;
+          packets = 0;
+          waited = 0;
+        }
+        continue;
+      default: break;
+      }
+    }
+  }
+ret_with_sockfd:
+  if (CFG_TOYBOX_FREE) {
+    free_option_stores();
+    if (state->sockfd > 0) close(state->sockfd);
+    free(state);
+  }
+}
diff --git a/toys/pending/dhcpd.c b/toys/pending/dhcpd.c
new file mode 100644
index 00000000..18f4f25e
--- /dev/null
+++ b/toys/pending/dhcpd.c
@@ -0,0 +1,1247 @@
+/* dhcpd.c - DHCP server for dynamic network configuration.
+ *
+ * Copyright 2013 Madhur Verma <mad.flexi@gmail.com>
+ * Copyright 2013 Kyungwan Han <asura321@gamil.com>
+ *
+ * No Standard
+USE_DHCPD(NEWTOY(dhcpd, ">1P#<0>65535=67fS", TOYFLAG_SBIN|TOYFLAG_ROOTONLY))
+
+config DHCPD
+  bool "dhcpd"
+  default n
+  help
+   Usage: dhcpd [-fS] [-P N] [CONFFILE]
+
+    -f    Run in foreground
+    -S    Log to syslog too
+    -P N  Use port N (default 67)
+
+config DEBUG_DHCP
+  bool "debugging messeges ON/OFF"
+  default n
+  depends on DHCPD
+*/
+
+#define FOR_dhcpd
+
+#include "toys.h"
+#include "toynet.h"
+#include <linux/sockios.h> 
+#include <linux/if_ether.h>
+
+// Todo: headers not in posix
+#include <netinet/ip.h>
+#include <netinet/udp.h>
+#include <netpacket/packet.h>
+
+#if CFG_DEBUG_DHCP==1
+# define dbg(fmt, arg...)   printf(fmt, ##arg)
+#else
+# define dbg(fmt, arg...)
+#endif
+
+#define flag_get(f,v,d)     ((toys.optflags & (f)) ? (v) : (d))
+#define flag_chk(f)         ((toys.optflags & (f)) ? 1 : 0)
+
+#define LOG_SILENT          0x0
+#define LOG_CONSOLE         0x1
+#define LOG_SYSTEM          0x2
+
+#define DHCP_MAGIC          0x63825363
+
+#define DHCPDISCOVER        1
+#define DHCPOFFER           2
+#define DHCPREQUEST         3
+#define DHCPDECLINE         4
+#define DHCPACK             5
+#define DHCPNAK             6
+#define DHCPRELEASE         7
+#define DHCPINFORM          8
+
+#define DHCP_NUM8           (1<<8)
+#define DHCP_NUM16          (1<<9)
+#define DHCP_NUM32          DHCP_NUM16 | DHCP_NUM8
+#define DHCP_STRING         (1<<10)
+#define DHCP_STRLST         (1<<11)
+#define DHCP_IP             (1<<12)
+#define DHCP_IPLIST         (1<<13)
+#define DHCP_IPPLST         (1<<14)
+#define DHCP_STCRTS         (1<<15)
+
+// DHCP option codes (partial list). See RFC 2132 and
+#define DHCP_OPT_PADDING                          0x00
+#define DHCP_OPT_HOST_NAME          DHCP_STRING | 0x0c // either client informs server or server gives name to client
+#define DHCP_OPT_REQUESTED_IP       DHCP_IP     | 0x32 // sent by client if specific IP is wanted
+#define DHCP_OPT_LEASE_TIME         DHCP_NUM32  | 0x33
+#define DHCP_OPT_OPTION_OVERLOAD                  0x34
+#define DHCP_OPT_MESSAGE_TYPE       DHCP_NUM8   | 0x35
+#define DHCP_OPT_SERVER_ID          DHCP_IP     | 0x36 // by default server's IP
+#define DHCP_OPT_PARAM_REQ          DHCP_STRING | 0x37 // list of options client wants
+#define DHCP_OPT_END                              0xff
+
+GLOBALS(
+    long port;
+);
+
+typedef struct __attribute__((packed)) dhcp_msg_s {
+  uint8_t op;
+  uint8_t htype;
+  uint8_t hlen;
+  uint8_t hops;
+  uint32_t xid;
+  uint16_t secs;
+  uint16_t flags;
+  uint32_t ciaddr;
+  uint32_t yiaddr;
+  uint32_t nsiaddr;
+  uint32_t ngiaddr;
+  uint8_t chaddr[16];
+  uint8_t sname[64];
+  uint8_t file[128];
+  uint32_t cookie;
+  uint8_t options[308];
+} dhcp_msg_t;
+
+typedef struct __attribute__((packed)) dhcp_raw_s {
+  struct iphdr iph;
+  struct udphdr udph;
+  dhcp_msg_t dhcp;
+} dhcp_raw_t;
+
+typedef struct static_lease_s {
+  struct static_lease_s *next;
+  uint32_t nip;
+  int mac[6];
+} static_lease;
+
+typedef struct {
+  uint32_t expires;
+  uint32_t lease_nip;
+  uint8_t lease_mac[6];
+  char hostname[20];
+  uint8_t pad[2];
+} dyn_lease;
+
+typedef struct option_val_s {
+  char *key;
+  uint16_t code;
+  void *val;
+  size_t len;
+} option_val_t;
+
+typedef struct __attribute__((__may_alias__)) server_config_s {
+  char *interface;                // interface to use
+  int ifindex;
+  uint32_t server_nip;
+  uint32_t port;
+  uint8_t server_mac[6];          // our MAC address (used only for ARP probing)
+  void *options[256];             // list of DHCP options loaded from the config file
+  /* start,end are in host order: we need to compare start <= ip <= end*/
+  uint32_t start_ip;              // start address of leases, in host order
+  uint32_t end_ip;                // end of leases, in host order
+  uint32_t max_lease_sec;         // maximum lease time (host order)
+  uint32_t min_lease_sec;         // minimum lease time a client can request
+  uint32_t max_leases;            // maximum number of leases (including reserved addresses)
+  uint32_t auto_time;             // how long should dhcpd wait before writing a config file.
+                                  // if this is zero, it will only write one on SIGUSR1
+  uint32_t decline_time;          // how long an address is reserved if a client returns a
+                                  // decline message
+  uint32_t conflict_time;         // how long an arp conflict offender is leased for
+  uint32_t offer_time;            // how long an offered address is reserved
+  uint32_t siaddr_nip;            // "next server" bootp option
+  char *lease_file;
+  char *pidfile;
+  char *notify_file;              // what to run whenever leases are written
+  char *sname;                    // bootp server name
+  char *boot_file;                // bootp boot file option
+  struct static_lease *static_leases; // List of ip/mac pairs to assign static leases
+} server_config_t;
+
+typedef struct __attribute__((__may_alias__)) server_state_s {
+  uint8_t rqcode;
+  int listensock;
+  dhcp_msg_t rcvd_pkt;
+  uint8_t* rqopt;
+  dhcp_msg_t send_pkt;
+  static_lease *sleases;
+  struct arg_list *dleases;
+} server_state_t;
+
+struct config_keyword {
+  char *keyword;
+  int (*handler)(const char *str, void *var);
+  void *var;
+  char *def;
+};
+
+static option_val_t options_list[] = {
+    {"lease"          , DHCP_NUM32  | 0x33, NULL, 0},
+    {"subnet"         , DHCP_IP     | 0x01, NULL, 0},
+    {"broadcast"      , DHCP_IP     | 0x1c, NULL, 0},
+    {"router"         , DHCP_IP     | 0x03, NULL, 0},
+    {"ipttl"          , DHCP_NUM8   | 0x17, NULL, 0},
+    {"mtu"            , DHCP_NUM16  | 0x1a, NULL, 0},
+    {"hostname"       , DHCP_STRING | 0x0c, NULL, 0},
+    {"domain"         , DHCP_STRING | 0x0f, NULL, 0},
+    {"search"         , DHCP_STRLST | 0x77, NULL, 0},
+    {"nisdomain"      , DHCP_STRING | 0x28, NULL, 0},
+    {"timezone"       , DHCP_NUM32  | 0x02, NULL, 0},
+    {"tftp"           , DHCP_STRING | 0x42, NULL, 0},
+    {"bootfile"       , DHCP_STRING | 0x43, NULL, 0},
+    {"bootsize"       , DHCP_NUM16  | 0x0d, NULL, 0},
+    {"rootpath"       , DHCP_STRING | 0x11, NULL, 0},
+    {"wpad"           , DHCP_STRING | 0xfc, NULL, 0},
+    {"serverid"       , DHCP_IP     | 0x36, NULL, 0},
+    {"message"        , DHCP_STRING | 0x38, NULL, 0},
+    {"vlanid"         , DHCP_NUM32  | 0x84, NULL, 0},
+    {"vlanpriority"   , DHCP_NUM32  | 0x85, NULL, 0},
+    {"dns"            , DHCP_IPLIST | 0x06, NULL, 0},
+    {"wins"           , DHCP_IPLIST | 0x2c, NULL, 0},
+    {"nissrv"         , DHCP_IPLIST | 0x29, NULL, 0},
+    {"ntpsrv"         , DHCP_IPLIST | 0x2a, NULL, 0},
+    {"lprsrv"         , DHCP_IPLIST | 0x09, NULL, 0},
+    {"swapsrv"        , DHCP_IP     | 0x10, NULL, 0},
+    {"routes"         , DHCP_STCRTS | 0x21, NULL, 0},
+    {"staticroutes"   , DHCP_STCRTS | 0x79, NULL, 0},
+    {"msstaticroutes" , DHCP_STCRTS | 0xf9, NULL, 0},
+};
+
+struct fd_pair { int rd; int wr; };
+static server_config_t gconfig;
+static server_state_t gstate;
+static uint8_t infomode;
+static struct fd_pair sigfd;
+static int constone = 1;
+
+// calculate options size.
+static int dhcp_opt_size(uint8_t *optionptr)
+{
+  int i = 0;
+  for(;optionptr[i] != 0xff; i++) if(optionptr[i] != 0x00) i += optionptr[i + 1] + 2 -1;
+  return i;
+}
+
+// calculates checksum for dhcp messeges.
+static uint16_t dhcp_checksum(void *addr, int count)
+{
+  int32_t sum = 0;
+  uint16_t tmp = 0, *source = (uint16_t *)addr;
+
+  while (count > 1)  {
+    sum += *source++;
+    count -= 2;
+  }
+  if (count > 0) {
+    *(uint8_t*)&tmp = *(uint8_t*)source;
+    sum += tmp;
+  }
+  while (sum >> 16) sum = (sum & 0xffff) + (sum >> 16);
+  return ~sum;
+}
+
+// gets information of INTERFACE and updates IFINDEX, MAC and IP
+static int get_interface(const char *interface, int *ifindex, uint32_t *oip, uint8_t *mac)
+{
+  struct ifreq req;
+  struct sockaddr_in *ip;
+  int fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
+
+  req.ifr_addr.sa_family = AF_INET;
+  strncpy(req.ifr_name, interface, IFNAMSIZ);
+  req.ifr_name[IFNAMSIZ-1] = '\0';
+
+  xioctl(fd, SIOCGIFFLAGS, &req);
+  
+  if (!(req.ifr_flags & IFF_UP)) return -1;
+  if (oip) {
+    xioctl(fd, SIOCGIFADDR, &req);
+    ip = (struct sockaddr_in*) &req.ifr_addr;
+    dbg("IP %s\n", inet_ntoa(ip->sin_addr));
+    *oip = ntohl(ip->sin_addr.s_addr);
+  }
+  if (ifindex) {
+    xioctl(fd, SIOCGIFINDEX, &req);
+    dbg("Adapter index %d\n", req.ifr_ifindex);
+    *ifindex = req.ifr_ifindex;
+  }
+  if (mac) {
+    xioctl(fd, SIOCGIFHWADDR, &req);
+    memcpy(mac, req.ifr_hwaddr.sa_data, 6);
+    dbg("MAC %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+  }
+  close(fd);
+  return 0;
+}
+
+/*
+ *logs messeges to syslog or console
+ *opening the log is still left with applet.
+ *FIXME: move to more relevent lib. probably libc.c
+ */
+static void infomsg(uint8_t infomode, char *s, ...)
+{
+  int used;
+  char *msg;
+  va_list p, t;
+
+  if (infomode == LOG_SILENT) return;
+  va_start(p, s);
+  va_copy(t, p);
+  used = vsnprintf(NULL, 0, s, t);
+  used++;
+  va_end(t);
+
+  msg = xmalloc(used);
+  vsnprintf(msg, used, s, p);
+  va_end(p);
+
+  if (infomode & LOG_SYSTEM) syslog(LOG_INFO, "%s", msg);
+  if (infomode & LOG_CONSOLE) printf("%s\n", msg);
+  free(msg);
+}
+
+/*
+ * Writes self PID in file PATH
+ * FIXME: libc implementation only writes in /var/run
+ * this is more generic as some implemenation may provide
+ * arguments to write in specific file. as dhcpd does.
+ */
+static void write_pid(char *path)
+{
+  int pidfile = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0666);
+  if (pidfile > 0) {
+    char *pidbuf = utoa(getpid());
+    write(pidfile, pidbuf, strlen(pidbuf));
+    close(pidfile);
+  }
+}
+
+// Generic signal handler real handling is done in main funcrion.
+static void signal_handler(int sig)
+{
+  unsigned char ch = sig;
+  if (write(sigfd.wr, &ch, 1) != 1) dbg("can't send signal\n");
+}
+
+// signal setup for SIGUSR1 SIGTERM
+static int setup_signal()
+{
+  if (pipe((int *)&sigfd) < 0) {
+    dbg("signal pipe failed\n");
+    return -1;
+  }
+  fcntl(sigfd.wr , F_SETFD, FD_CLOEXEC);
+  fcntl(sigfd.rd , F_SETFD, FD_CLOEXEC);
+  int flags = fcntl(sigfd.wr, F_GETFL);
+  fcntl(sigfd.wr, F_SETFL, flags | O_NONBLOCK);
+  signal(SIGUSR1, signal_handler);
+  signal(SIGTERM, signal_handler);
+  return 0;
+}
+
+// String STR to UINT32 conversion strored in VAR
+static int strtou32(const char *str, void *var)
+{
+  char *endptr = NULL;
+  int base = 10;
+  errno=0;
+  *((uint32_t*)(var)) = 0;
+  if (str[0]=='0' && (str[1]=='x' || str[1]=='X')) {
+    base = 16;
+    str+=2;
+  }
+  long ret_val = strtol(str, &endptr, base);
+  if (errno) infomsg(infomode, "config : Invalid num %s",str);
+  else if (endptr && (*endptr!='\0'||endptr == str))
+      infomsg(infomode, "config : Not a valid num %s",str);
+  else *((uint32_t*)(var)) = (uint32_t)ret_val;
+  return 0;
+}
+
+// copy string STR in variable VAR
+static int strinvar(const char *str, void *var)
+{
+  char **dest = var;
+  if (*dest) free(*dest);
+  *dest = strdup(str);
+  return 0;
+}
+
+// IP String STR to binary data.
+static int striptovar(const char *str, void *var)
+{
+  in_addr_t addr;
+  *((uint32_t*)(var)) = 0;
+  if(!str) {
+    error_msg("config : NULL address string \n");
+    return -1;
+  }
+  if((addr = inet_addr(str)) == -1) {
+    error_msg("config : wrong address %s \n",str );
+    return -1;
+  }
+  *((uint32_t*)(var)) = (uint32_t)addr;
+  return 0;
+}
+
+// String to dhcp option conversion
+static int strtoopt(const char *str, void *var)
+{
+  char *option, *valstr, *grp, *tp;
+  uint32_t optcode = 0, inf = infomode, convtmp, mask, nip, router;
+  uint16_t flag = 0;
+  int count, size = ARRAY_LEN(options_list);
+
+  if (!*str) return 0;
+  if (!(option = strtok((char*)str, " \t="))) return -1;
+
+  infomode = LOG_SILENT;
+  strtou32(option, (uint32_t*)&optcode);
+  infomode = inf;
+
+  if (optcode > 0 && optcode < 256) { // raw option
+    for (count = 0; count < size; count++) {
+      if ((options_list[count].code & 0X00FF) == optcode) {
+        flag = (options_list[count].code & 0XFF00);
+        break;
+      }
+    }
+  } else { //string option
+    for (count = 0; count < size; count++) {
+      if (!strncmp(options_list[count].key, option, strlen(options_list[count].key))) {
+        flag = (options_list[count].code & 0XFF00);
+        optcode = (options_list[count].code & 0X00FF);
+        break;
+      }
+    }
+  }
+  if (count == size) {
+    infomsg(inf, "config : Obsolete OR Unknown Option : %s", option);
+    return -1;
+  }
+
+  if (!flag || !optcode) return -1;
+
+  if (!(valstr = strtok(NULL, " \t"))) {
+    dbg("config : option %s has no value defined.\n", option);
+    return -1;
+  }
+  dbg(" value : %-20s : ", valstr);
+  switch (flag) {
+  case DHCP_NUM32:
+    options_list[count].len = sizeof(uint32_t);
+    options_list[count].val = xmalloc(sizeof(uint32_t));
+    strtou32(valstr, &convtmp);
+    memcpy(options_list[count].val, &convtmp, sizeof(uint32_t));
+    break;
+  case DHCP_NUM16:
+    options_list[count].len = sizeof(uint16_t);
+    options_list[count].val = xmalloc(sizeof(uint16_t));
+    strtou32(valstr, &convtmp);
+    memcpy(options_list[count].val, &convtmp, sizeof(uint16_t));
+    break;
+  case DHCP_NUM8:
+    options_list[count].len = sizeof(uint8_t);
+    options_list[count].val = xmalloc(sizeof(uint8_t));
+    strtou32(valstr, &convtmp);
+    memcpy(options_list[count].val, &convtmp, sizeof(uint8_t));
+    break;
+  case DHCP_IP:
+    options_list[count].len = sizeof(uint32_t);
+    options_list[count].val = xmalloc(sizeof(uint32_t));
+    striptovar(valstr, options_list[count].val);
+    break;
+  case DHCP_STRING:
+    options_list[count].len = strlen(valstr);
+    options_list[count].val = strdup(valstr);
+    break;
+  case DHCP_IPLIST:
+    while(valstr){
+      options_list[count].val = xrealloc(options_list[count].val, options_list[count].len + sizeof(uint32_t));
+      striptovar(valstr, ((uint8_t*)options_list[count].val)+options_list[count].len);
+      options_list[count].len += sizeof(uint32_t);
+      valstr = strtok(NULL," \t");
+    }
+    break;
+  case DHCP_IPPLST:
+    break;
+  case DHCP_STCRTS:
+    /* Option binary format:
+     * mask [one byte, 0..32]
+     * ip [0..4 bytes depending on mask]
+     * router [4 bytes]
+     * may be repeated
+     * staticroutes 10.0.0.0/8 10.127.0.1, 10.11.12.0/24 10.11.12.1
+     */
+    grp = strtok(valstr, ",");;
+    while(grp){
+      while(*grp == ' ' || *grp == '\t') grp++;
+      tp = strchr(grp, '/');
+      if (!tp) error_exit("wrong formated static route option");
+      *tp = '\0';
+      mask = strtol(++tp, &tp, 10);
+      if (striptovar(grp, (uint8_t*)&nip)<0) error_exit("wrong formated static route option");
+      while(*tp == ' ' || *tp == '\t' || *tp == '-') tp++;
+      if (striptovar(tp, (uint8_t*)&router)<0) error_exit("wrong formated static route option");
+      options_list[count].val = xrealloc(options_list[count].val, options_list[count].len + 1 + mask/8 + 4);
+      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &mask, 1);
+      options_list[count].len += 1;
+      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &nip, mask/8);
+      options_list[count].len += mask/8;
+      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &router, 4);
+      options_list[count].len += 4;
+      tp = NULL;
+      grp = strtok(NULL, ",");
+    }
+    break;
+  }
+  return 0;
+}
+
+// Reads Static leases from STR and updates inner structures.
+static int get_staticlease(const char *str, void *var)
+{
+  struct static_lease_s *sltmp;
+  char *tkmac, *tkip;
+  int count;
+
+  if (!*str) return 0;
+
+  if (!(tkmac = strtok((char*)str, " \t"))) {
+    infomsg(infomode, "config : static lease : mac not found");
+    return 0;
+  }
+  if (!(tkip = strtok(NULL, " \t"))) {
+    infomsg(infomode, "config : static lease : no ip bind to mac %s", tkmac);
+    return 0;
+  }
+  sltmp = xzalloc(sizeof(struct static_lease_s));
+  for (count = 0; count < 6; count++, tkmac++) {
+    errno = 0;
+    sltmp->mac[count] = strtol(tkmac, &tkmac, 16);
+    if (sltmp->mac[count]>255 || sltmp->mac[count]<0 || (*tkmac && *tkmac!=':') || errno) {
+      infomsg(infomode, "config : static lease : mac address wrong format");
+      free(sltmp);
+      return 0;
+    }
+  }
+  striptovar(tkip, &sltmp->nip);
+  sltmp->next = gstate.sleases;
+  gstate.sleases = sltmp;
+
+  return 0;
+}
+
+static struct config_keyword keywords[] = {
+// keyword          handler           variable address                default 
+  {"start"        , striptovar      , (void*)&gconfig.start_ip     , "192.168.0.20"},
+  {"end"          , striptovar      , (void*)&gconfig.end_ip       , "192.168.0.254"},
+  {"interface"    , strinvar        , (void*)&gconfig.interface    , "eth0"},
+  {"port"         , strtou32        , (void*)&gconfig.port         , "67"},
+  {"min_lease"    , strtou32        , (void*)&gconfig.min_lease_sec, "60"},
+  {"max_leases"   , strtou32        , (void*)&gconfig.max_leases   , "235"},
+  {"auto_time"    , strtou32        , (void*)&gconfig.auto_time    , "7200"},
+  {"decline_time" , strtou32        , (void*)&gconfig.decline_time , "3600"},
+  {"conflict_time", strtou32        , (void*)&gconfig.conflict_time, "3600"},
+  {"offer_time"   , strtou32        , (void*)&gconfig.offer_time   , "60"},
+  {"lease_file"   , strinvar        , (void*)&gconfig.lease_file   , "/var/lib/misc/dhcpd.leases"}, //LEASES_FILE
+  {"pidfile"      , strinvar        , (void*)&gconfig.pidfile      , "/var/run/dhcpd.pid"}, //DPID_FILE
+  {"siaddr"       , striptovar      , (void*)&gconfig.siaddr_nip   , "0.0.0.0"},
+  {"option"       , strtoopt        , (void*)&gconfig.options      , ""},
+  {"opt"          , strtoopt        , (void*)&gconfig.options      , ""},
+  {"notify_file"  , strinvar        , (void*)&gconfig.notify_file  , ""},
+  {"sname"        , strinvar        , (void*)&gconfig.sname        , ""},
+  {"boot_file"    , strinvar        , (void*)&gconfig.boot_file    , ""},
+  {"static_lease" , get_staticlease , (void*)&gconfig.static_leases, ""},
+};
+
+// Parses the server config file and updates the global server config accordingly.
+static int parse_server_config(char *config_file, struct config_keyword *confkey)
+{
+  FILE *fs = NULL;
+  char *confline_temp = NULL,*confline = NULL, *tk = NULL, *tokens[2] = {NULL, NULL};
+  int len, linelen, tcount, count, size = ARRAY_LEN(keywords);
+
+  for (count = 0; count < size; count++)
+    if (confkey[count].handler) confkey[count].handler(confkey[count].def, confkey[count].var);
+
+  if (!(fs = fopen(config_file, "r"))) perror_msg("%s", config_file);
+  for (len = 0, linelen = 0; fs;) {
+    len = getline(&confline_temp, (size_t*) &linelen, fs);
+    confline = confline_temp;
+    if (len <= 0) break;
+    for (; *confline == ' '; confline++, len--);
+    if ((confline[0] == '#') || (confline[0] == '\n')) goto free_conf_continue;
+    tk = strchr(confline, '#');
+    if (tk) {
+      for (; *(tk-1)==' ' || *(tk-1)=='\t'; tk--);
+      *tk = '\0';
+    }
+    tk = strchr(confline, '\n');
+    if (tk) {
+      for (; *(tk-1)==' ' || *(tk-1)=='\t'; tk--);
+      *tk = '\0';
+    }
+    for (tcount=0, tk=strtok(confline, " \t"); tk && (tcount < 2);
+        tcount++, tk=strtok(NULL,(tcount==1)?"":" \t")) {
+      while ((*tk == '\t') || (*tk == ' ')) tk++;
+      tokens[tcount] = xstrdup(tk);
+    }
+    if (tcount<=1) goto free_tk0_continue;
+    for (count = 0; count < size; count++) {
+      if (!strcmp(confkey[count].keyword,tokens[0])) {
+        dbg("got config : %15s : ", confkey[count].keyword);
+        if (confkey[count].handler(tokens[1], confkey[count].var) == 0)
+          dbg("%s \n", tokens[1]);
+        break;
+      }
+    }
+    if (tokens[1]) { free(tokens[1]); tokens[1] = NULL; }
+free_tk0_continue:
+    if (tokens[0]) { free(tokens[0]); tokens[0] = NULL; }
+free_conf_continue:
+    free(confline_temp);
+    confline_temp = NULL;
+  }
+  if (fs) fclose(fs);
+  return 0;
+}
+
+// opens UDP socket for listen
+static int open_listensock(void)
+{
+  struct sockaddr_in addr;
+  struct ifreq ifr;
+
+  if (gstate.listensock > 0) close(gstate.listensock);
+
+  dbg("Opening listen socket on *:%d %s\n", gconfig.port, gconfig.interface);
+  gstate.listensock = xsocket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  setsockopt(gstate.listensock, SOL_SOCKET, SO_REUSEADDR, &constone, sizeof(constone));
+  if (setsockopt(gstate.listensock, SOL_SOCKET, SO_BROADCAST, &constone, sizeof(constone)) == -1) {
+      dbg("OPEN : brodcast ioctl failed.\n");
+      close(gstate.listensock);
+      return -1;
+  }
+  memset(&ifr, 0, sizeof(ifr));
+  strncpy(ifr.ifr_name, gconfig.interface, IFNAMSIZ);
+  ifr.ifr_name[IFNAMSIZ -1] = '\0';
+  setsockopt(gstate.listensock, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr));
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_port = (flag_chk(FLAG_P))?htons(TT.port):htons(67); //SERVER_PORT
+  addr.sin_addr.s_addr = INADDR_ANY ;
+
+  if (bind(gstate.listensock, (struct sockaddr *) &addr, sizeof(addr))) {
+    close(gstate.listensock);
+    perror_exit("bind failed");
+  }
+  dbg("OPEN : success\n");
+  return 0;
+}
+
+// Sends data through raw socket.
+static int send_packet(uint8_t broadcast)
+{
+  struct sockaddr_ll dest_sll;
+  dhcp_raw_t packet;
+  unsigned padding;
+  int fd, result = -1;
+  uint8_t bmacaddr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+  memset(&packet, 0, sizeof(dhcp_raw_t));
+  memcpy(&packet.dhcp, &gstate.send_pkt, sizeof(dhcp_msg_t));
+
+  if ((fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
+    dbg("SEND : socket failed\n");
+    return -1;
+  }
+  memset(&dest_sll, 0, sizeof(dest_sll));
+  dest_sll.sll_family = AF_PACKET;
+  dest_sll.sll_protocol = htons(ETH_P_IP);
+  dest_sll.sll_ifindex = gconfig.ifindex;
+  dest_sll.sll_halen = 6;
+  memcpy(dest_sll.sll_addr, (broadcast)?bmacaddr:gstate.rcvd_pkt.chaddr , 6);
+
+  if (bind(fd, (struct sockaddr *) &dest_sll, sizeof(dest_sll)) < 0) {
+    dbg("SEND : bind failed\n");
+    close(fd);
+    return -1;
+  }
+  padding = 308 - 1 - dhcp_opt_size(gstate.send_pkt.options);
+  packet.iph.protocol = IPPROTO_UDP;
+  packet.iph.saddr = gconfig.server_nip;
+  packet.iph.daddr = (broadcast || (gstate.rcvd_pkt.ciaddr == 0))?INADDR_BROADCAST:gstate.rcvd_pkt.ciaddr;
+  packet.udph.source = htons(67);//SERVER_PORT
+  packet.udph.dest = htons(68); //CLIENT_PORT
+  packet.udph.len = htons(sizeof(dhcp_raw_t) - sizeof(struct iphdr) - padding);
+  packet.iph.tot_len = packet.udph.len;
+  packet.udph.check = dhcp_checksum(&packet, sizeof(dhcp_raw_t) - padding);
+  packet.iph.tot_len = htons(sizeof(dhcp_raw_t) - padding);
+  packet.iph.ihl = sizeof(packet.iph) >> 2;
+  packet.iph.version = IPVERSION;
+  packet.iph.ttl = IPDEFTTL;
+  packet.iph.check = dhcp_checksum(&packet.iph, sizeof(packet.iph));
+
+  result = sendto(fd, &packet, sizeof(dhcp_raw_t) - padding, 0,
+      (struct sockaddr *) &dest_sll, sizeof(dest_sll));
+
+  dbg("sendto %d\n", result);
+  close(fd);
+  if (result < 0) dbg("PACKET send error\n");
+  return result;
+}
+
+// Reads from UDP socket
+static int read_packet(void)
+{
+  int ret;
+
+  memset(&gstate.rcvd_pkt, 0, sizeof(dhcp_msg_t));
+  ret = read(gstate.listensock, &gstate.rcvd_pkt, sizeof(dhcp_msg_t));
+  if (ret < 0) {
+    dbg("Packet read error, ignoring. \n");
+    return ret; // returns -1
+  }
+  if (gstate.rcvd_pkt.cookie != htonl(DHCP_MAGIC)) {
+    dbg("Packet with bad magic, ignoring. \n");
+    return -2;
+  }
+  if (gstate.rcvd_pkt.op != 1) { //BOOTPREQUEST
+    dbg("Not a BOOT REQUEST ignoring. \n");
+    return -2;
+  }
+  if (gstate.rcvd_pkt.hlen != 6) {
+    dbg("hlen != 6 ignoring. \n");
+    return -2;
+  }
+  dbg("Received a packet. Size : %d \n", ret);
+  return ret;
+}
+
+// Preapres a dhcp packet with defaults and configs
+static uint8_t* prepare_send_pkt(void)
+{
+  memset((void*)&gstate.send_pkt, 0, sizeof(gstate.send_pkt));
+  gstate.send_pkt.op = 2; //BOOTPREPLY
+  gstate.send_pkt.htype = 1;
+  gstate.send_pkt.hlen = 6;
+  gstate.send_pkt.xid = gstate.rcvd_pkt.xid;
+  gstate.send_pkt.cookie = htonl(DHCP_MAGIC);
+  gstate.send_pkt.nsiaddr = gconfig.server_nip;
+  memcpy(gstate.send_pkt.chaddr, gstate.rcvd_pkt.chaddr, 16);
+  gstate.send_pkt.options[0] = DHCP_OPT_END;
+  return gstate.send_pkt.options;
+}
+
+// Sets a option value in dhcp packet's option field
+static uint8_t* set_optval(uint8_t *optptr, uint16_t opt, void *var, size_t len)
+{
+  while (*optptr != DHCP_OPT_END) optptr++;
+  *optptr++ = (uint8_t)(opt & 0x00FF);
+  *optptr++ = (uint8_t) len;
+  memcpy(optptr, var, len);
+  optptr += len;
+  *optptr = DHCP_OPT_END;
+  return optptr;
+}
+
+// Gets a option value from dhcp packet's option field
+static uint8_t* get_optval(uint8_t *optptr, uint16_t opt, void *var)
+{
+  size_t len;
+  uint8_t overloaded = 0;
+
+  while (1) {
+    while (*optptr == DHCP_OPT_PADDING) optptr++;
+    if ((*optptr & 0x00FF) == DHCP_OPT_END) break;
+    if ((*optptr & 0x00FF) == DHCP_OPT_OPTION_OVERLOAD) {
+      overloaded = optptr[2];
+      optptr += optptr[1] + 2;
+    }
+    len = optptr[1];
+    if (*optptr == (opt & 0x00FF))
+      switch (opt & 0xFF00) {
+        case DHCP_NUM32: // FALLTHROUGH
+        case DHCP_IP:
+          memcpy(var, optptr+2, sizeof(uint32_t));
+          optptr += len + 2;
+          return optptr;
+          break;
+        case DHCP_NUM16:
+          memcpy(var, optptr+2, sizeof(uint16_t));
+          optptr += len + 2;
+          return optptr;
+          break;
+        case DHCP_NUM8:
+          memcpy(var, optptr+2, sizeof(uint8_t));
+          optptr += len + 2;
+          return optptr;
+          break;
+        case DHCP_STRING:
+          var = xstrndup((char*) optptr, len);
+          optptr += len + 2;
+          return optptr;
+          break;
+      }
+    optptr += len + 2;
+  }
+  if ((overloaded == 1) | (overloaded == 3)) get_optval((uint8_t*)&gstate.rcvd_pkt.file, opt, var);
+  if ((overloaded == 2) | (overloaded == 3)) get_optval((uint8_t*)&gstate.rcvd_pkt.sname, opt, var);
+  return optptr;
+}
+
+// Retrives Requested Parameter list from dhcp req packet.
+static uint8_t get_reqparam(uint8_t **list)
+{
+  uint8_t len, *optptr;
+  if(*list) free(*list);
+  for (optptr = gstate.rcvd_pkt.options;
+      *optptr && *optptr!=((DHCP_OPT_PARAM_REQ) & 0x00FF); optptr+=optptr[1]+2);
+  len = *++optptr;
+  *list = xzalloc(len+1);
+  memcpy(*list, ++optptr, len);
+  return len;
+}
+
+// Sets values of req param in dhcp offer packet.
+static uint8_t* set_reqparam(uint8_t *optptr, uint8_t *list)
+{
+  uint8_t reqcode;
+  int count, size = ARRAY_LEN(options_list);
+
+  while (*list) {
+    reqcode = *list++;
+    for (count = 0; count < size; count++) {
+      if ((options_list[count].code & 0X00FF)==reqcode) {
+        if (!(options_list[count].len) || !(options_list[count].val)) break;
+        for (; *optptr && *optptr!=DHCP_OPT_END; optptr+=optptr[1]+2);
+        *optptr++ = (uint8_t) (options_list[count].code & 0x00FF);
+        *optptr++ = (uint8_t) options_list[count].len;
+        memcpy(optptr, options_list[count].val, options_list[count].len);
+        optptr += options_list[count].len;
+        *optptr = DHCP_OPT_END;
+        break;
+      }
+    }
+  }
+  return optptr;
+}
+
+static void run_notify(char **argv)
+{
+  struct stat sts;
+  volatile int error = 0;
+  pid_t pid;
+
+  if (stat(argv[0], &sts) == -1 && errno == ENOENT) {
+    infomsg(infomode, "notify file: %s : not exist.", argv[0]);
+    return;
+  }
+  fflush(NULL);
+
+  pid = vfork();
+  if (pid < 0) {
+    dbg("Fork failed.\n");
+    return;
+  }
+  if (!pid) {
+    execvp(argv[0], argv);
+    error = errno;
+    _exit(111);
+  }
+  if (error) {
+    waitpid(pid, NULL, 0);
+    errno = error;
+  }
+  dbg("script complete.\n");
+}
+
+static int write_leasefile(void)
+{
+  int fd;
+  uint32_t curr, tmp_time;
+  int64_t timestamp;
+  struct arg_list *listdls = gstate.dleases;
+  dyn_lease *dls;
+
+  if ((fd = open(gconfig.lease_file, O_WRONLY | O_CREAT | O_TRUNC)) < 0) {
+    perror_msg("can't open %s ", gconfig.lease_file);
+    return fd;
+  }
+
+  curr = timestamp = time(NULL);
+  timestamp = SWAP_BE64(timestamp);
+  writeall(fd, &timestamp, sizeof(timestamp));
+
+  while (listdls) {
+    dls = (dyn_lease*)listdls->arg;
+    tmp_time = dls->expires;
+    dls->expires -= curr;
+    if ((int32_t) dls->expires < 0) goto skip;
+    dls->expires = htonl(dls->expires);
+    writeall(fd, dls, sizeof(dyn_lease));
+skip:
+    dls->expires = tmp_time;
+    listdls = listdls->next;
+  }
+  close(fd);
+  if (gconfig.notify_file) {
+    char *argv[3];
+    argv[0] = gconfig.notify_file;
+    argv[1] = gconfig.lease_file;
+    argv[2] = NULL;
+    run_notify(argv);
+  }
+  return 0;
+}
+
+// Update max lease time from options.
+static void set_maxlease(void)
+{
+  int count, size = ARRAY_LEN(options_list);
+  for (count = 0; count < size; count++)
+    if (options_list[count].val && options_list[count].code == (DHCP_OPT_LEASE_TIME)) {
+      gconfig.max_lease_sec = *((uint32_t*)options_list[count].val);
+      break;
+    }
+  if (!gconfig.max_lease_sec) gconfig.max_lease_sec = (60*60*24*10);// DEFAULT_LEASE_TIME;
+}
+
+// Returns lease time for client.
+static uint32_t get_lease(uint32_t req_exp)
+{
+  uint32_t now = time(NULL);
+  req_exp = req_exp - now;
+  if ((req_exp <= 0) || (req_exp > gconfig.max_lease_sec))
+    return gconfig.max_lease_sec;
+
+  if (req_exp < gconfig.min_lease_sec)
+    return gconfig.min_lease_sec;
+
+  return req_exp;
+}
+
+// Verify ip NIP in current leases ( assigned or not)
+static int verifyip_in_lease(uint32_t nip, uint8_t mac[6])
+{
+  static_lease *sls;
+  struct arg_list *listdls;
+
+  for (listdls = gstate.dleases; listdls; listdls = listdls->next) {
+    if (((dyn_lease*) listdls->arg)->lease_nip == nip) {
+      if (((int32_t)(((dyn_lease*) listdls->arg)->expires) - time(NULL)) < 0)
+        return 0;
+      return -1;
+    }
+    if (!memcmp(((dyn_lease*) listdls->arg)->lease_mac, mac, 6)) return -1;
+  }
+  for (sls = gstate.sleases; sls; sls = sls->next)
+    if (sls->nip == nip) return -2;
+
+  if ((ntohl(nip) < gconfig.start_ip) || (ntohl(nip) > gconfig.end_ip))
+    return -3;
+
+  return 0;
+}
+
+// add ip assigned_nip to dynamic lease.
+static int addip_to_lease(uint32_t assigned_nip, uint8_t mac[6], uint32_t *req_exp, char *hostname, uint8_t update)
+{
+  dyn_lease *dls;
+  struct arg_list *listdls = gstate.dleases;
+  uint32_t now = time(NULL);
+
+  while (listdls) {
+    if (!memcmp(((dyn_lease*) listdls->arg)->lease_mac, mac, 6)) {
+      if (update) *req_exp = get_lease(*req_exp + ((dyn_lease*) listdls->arg)->expires);
+      ((dyn_lease*) listdls->arg)->expires = *req_exp + now;
+      return 0;
+    }
+    listdls = listdls->next;
+  }
+
+  dls = xzalloc(sizeof(dyn_lease));
+  memcpy(dls->lease_mac, mac, 6);
+  dls->lease_nip = assigned_nip;
+  if (hostname) memcpy(dls->hostname, hostname, 20);
+
+  if (update) *req_exp = get_lease(*req_exp + now);
+  dls->expires = *req_exp + now;
+
+  listdls = xzalloc(sizeof(struct arg_list));
+  listdls->next = gstate.dleases;
+  listdls->arg = (char*)dls;
+  gstate.dleases = listdls;
+
+  return 0;
+}
+
+// delete ip assigned_nip from dynamic lease.
+static int delip_from_lease(uint32_t assigned_nip, uint8_t mac[6], uint32_t del_time)
+{
+  struct arg_list *listdls = gstate.dleases;
+
+  while (listdls) {
+    if (!memcmp(((dyn_lease*) listdls->arg)->lease_mac, mac, 6)) {
+      ((dyn_lease*) listdls->arg)->expires = del_time + time(NULL);
+      return 0;
+    }
+    listdls = listdls->next;
+  }
+  return -1;
+}
+
+// returns a IP from static, dynamic leases or free ip pool, 0 otherwise.
+static uint32_t getip_from_pool(uint32_t req_nip, uint8_t mac[6], uint32_t *req_exp, char *hostname)
+{
+  uint32_t nip = 0;
+  static_lease *sls = gstate.sleases;
+  struct arg_list *listdls = gstate.dleases, *tmp = NULL;
+
+  if (req_nip && (!verifyip_in_lease(req_nip, mac))) nip = req_nip;
+
+  if (!nip) {
+    while (listdls) {
+      if (!memcmp(((dyn_lease*)listdls->arg)->lease_mac, mac, 6)) {
+        nip = ((dyn_lease*)listdls->arg)->lease_nip;
+        if (tmp) tmp->next = listdls->next;
+        else gstate.dleases = listdls->next;
+        free(listdls->arg);
+        free(listdls);
+        if (verifyip_in_lease(nip, mac) < 0) nip = 0;
+        break;
+      }
+      tmp = listdls;
+      listdls = listdls->next;
+    }
+  }
+  if (!nip) {
+    while (sls) {
+      if (memcmp(sls->mac, mac, 6) == 0) {
+        nip = sls->nip;
+        break;
+      }
+      sls = sls->next;
+    }
+  }
+  if (!nip) {
+    for (nip = htonl(gconfig.start_ip); ntohl(nip) <= gconfig.end_ip; ) {
+      if (!verifyip_in_lease(nip, mac)) break;
+      nip = ntohl(nip);
+      nip = htonl(++nip);
+    }
+    if (ntohl(nip) > gconfig.end_ip) {
+      nip = 0;
+      infomsg(infomode, "can't find free IP in IP Pool.");
+    }
+  }
+  if (nip) addip_to_lease(nip, mac, req_exp, hostname, 1);
+  return nip;
+}
+
+static int read_leasefile(void)
+{
+  uint32_t passed, ip;
+  int32_t tmp_time;
+  int64_t timestamp;
+  dyn_lease *dls;
+  int ret = -1, fd = open(gconfig.lease_file, O_RDONLY);
+
+  if (fd < 0) return fd;
+  dls = xzalloc(sizeof(dyn_lease));
+
+  if (read(fd, &timestamp, sizeof(timestamp)) != sizeof(timestamp)) goto error_exit;
+
+  timestamp = SWAP_BE64(timestamp);
+  passed = time(NULL) - timestamp;
+  if ((uint64_t)passed > 12 * 60 * 60) goto error_exit;
+
+  while (read(fd, dls, sizeof(dyn_lease)) == sizeof(dyn_lease)) {
+    ip = ntohl(dls->lease_nip);
+    if (ip >= gconfig.start_ip && ip <= gconfig.end_ip) {
+      tmp_time = ntohl(dls->expires) - passed;
+      if (tmp_time < 0) continue;
+      addip_to_lease(dls->lease_nip, dls->lease_mac, (uint32_t*)&tmp_time, dls->hostname, 0);
+    }
+  }
+  ret = 0;
+error_exit:
+  free(dls);
+  close(fd);
+  return ret;
+}
+
+void dhcpd_main(void)
+{
+  struct timeval tv;
+  int retval;
+  uint8_t *optptr, msgtype = 0;
+  uint32_t waited = 0, serverid = 0, requested_nip = 0;
+  uint32_t reqested_lease = 0, ip_pool_size = 0;
+  char *hstname = NULL;
+  fd_set rfds;
+
+  infomode = LOG_CONSOLE;
+  if (!(flag_chk(FLAG_f))) {
+    daemonize();
+    infomode = LOG_SILENT;
+  }
+  if (flag_chk(FLAG_S)) {
+        openlog("UDHCPD :", LOG_PID, LOG_DAEMON);
+        infomode |= LOG_SYSTEM;
+  }
+  setlinebuf(stdout);
+  parse_server_config((toys.optc==1)?toys.optargs[0]:"/etc/dhcpd.conf", keywords); //DHCPD_CONF_FILE
+  infomsg(infomode, "toybox dhcpd started");
+  gconfig.start_ip = ntohl(gconfig.start_ip);
+  gconfig.end_ip = ntohl(gconfig.end_ip);
+  ip_pool_size = gconfig.end_ip - gconfig.start_ip + 1;
+  if (gconfig.max_leases > ip_pool_size) {
+    error_msg("max_leases=%u is too big, setting to %u", (unsigned) gconfig.max_leases, ip_pool_size);
+    gconfig.max_leases = ip_pool_size;
+  }
+  write_pid(gconfig.pidfile);
+  set_maxlease();
+  read_leasefile();
+
+  if (get_interface(gconfig.interface, &gconfig.ifindex, &gconfig.server_nip,
+        gconfig.server_mac)<0)
+    perror_exit("Failed to get interface %s", gconfig.interface);
+  gconfig.server_nip = htonl(gconfig.server_nip);
+
+  setup_signal();
+  open_listensock();
+  fcntl(gstate.listensock, F_SETFD, FD_CLOEXEC);
+
+  for (;;) {
+    uint32_t timestmp = time(NULL);
+    FD_ZERO(&rfds);
+    FD_SET(gstate.listensock, &rfds);
+    FD_SET(sigfd.rd, &rfds);
+    tv.tv_sec = gconfig.auto_time - waited;
+    tv.tv_usec = 0;
+    retval = 0;
+    serverid = 0;
+    msgtype = 0;
+
+    int maxfd = (sigfd.rd > gstate.listensock)? sigfd.rd : gstate.listensock;
+    dbg("select waiting ....\n");
+    retval = select(maxfd + 1, &rfds, NULL, NULL, (gconfig.auto_time?&tv:NULL));
+    if (retval < 0) {
+      if (errno == EINTR) {
+        waited += (unsigned) time(NULL) - timestmp;
+        continue;
+      }
+      dbg("Error in select wait again...\n");
+      continue;
+    }
+    if (!retval) { // Timed out 
+      dbg("select wait Timed Out...\n");
+      waited = 0;
+      write_leasefile();
+      if (get_interface(gconfig.interface, &gconfig.ifindex, &gconfig.server_nip, gconfig.server_mac)<0)
+        perror_exit("Interface lost %s\n", gconfig.interface);
+      gconfig.server_nip = htonl(gconfig.server_nip);
+      continue;
+    }
+    if (FD_ISSET(sigfd.rd, &rfds)) { // Some Activity on RDFDs : is signal 
+      unsigned char sig;
+      if (read(sigfd.rd, &sig, 1) != 1) {
+        dbg("signal read failed.\n");
+        continue;
+      }
+      switch (sig) {
+      case SIGUSR1:
+        infomsg(infomode, "Received SIGUSR1");
+        write_leasefile();
+        continue;
+      case SIGTERM:
+        infomsg(infomode, "Received SIGTERM");
+        write_leasefile();
+        unlink(gconfig.pidfile);
+        exit(0);
+        break;
+      default: break;
+      }
+    }
+    if (FD_ISSET(gstate.listensock, &rfds)) { // Some Activity on RDFDs : is socket
+      dbg("select listen sock read\n");
+      if (read_packet() < 0) {
+        open_listensock();
+        continue;
+      }
+      waited += time(NULL) - timestmp;
+      get_optval((uint8_t*)&gstate.rcvd_pkt.options, DHCP_OPT_MESSAGE_TYPE, &gstate.rqcode);
+      if (gstate.rqcode == 0 || gstate.rqcode < DHCPDISCOVER 
+          || gstate.rqcode > DHCPINFORM) {
+        dbg("no or bad message type option, ignoring packet.\n");
+        continue;
+      }
+      get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_SERVER_ID, &serverid);
+      if (serverid && (serverid != gconfig.server_nip)) {
+        dbg("server ID doesn't match, ignoring packet.\n");
+        continue;
+      }
+      switch (gstate.rqcode) {
+        case DHCPDISCOVER:
+          msgtype = DHCPOFFER;
+          dbg("Message Type : DHCPDISCOVER\n");
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_REQUESTED_IP, &requested_nip);
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_HOST_NAME, &hstname);
+          reqested_lease = gconfig.offer_time;
+          get_reqparam(&gstate.rqopt);
+          optptr = prepare_send_pkt();
+          gstate.send_pkt.yiaddr = getip_from_pool(requested_nip, gstate.rcvd_pkt.chaddr, &reqested_lease, hstname);
+          if(!gstate.send_pkt.yiaddr){
+            msgtype = DHCPNAK;
+            optptr = set_optval(optptr, DHCP_OPT_MESSAGE_TYPE, &msgtype, 1);
+            send_packet(1);
+            break;
+          }
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_LEASE_TIME, &reqested_lease);
+          reqested_lease = htonl(get_lease(reqested_lease + time(NULL)));
+          optptr = set_optval(optptr, DHCP_OPT_MESSAGE_TYPE, &msgtype, 1);
+          optptr = set_optval(optptr, DHCP_OPT_SERVER_ID, &gconfig.server_nip, 4);
+          optptr = set_optval(optptr, DHCP_OPT_LEASE_TIME, &reqested_lease, 4);
+          optptr = set_reqparam(optptr, gstate.rqopt);
+          send_packet(1);
+          break;
+        case DHCPREQUEST:
+          msgtype = DHCPACK;
+          dbg("Message Type : DHCPREQUEST\n");
+          optptr = prepare_send_pkt();
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_REQUESTED_IP, &requested_nip);
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_LEASE_TIME, &reqested_lease);
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_HOST_NAME, &hstname);
+          gstate.send_pkt.yiaddr = getip_from_pool(requested_nip, gstate.rcvd_pkt.chaddr, &reqested_lease, hstname);
+          if (!serverid) reqested_lease = gconfig.max_lease_sec;
+          if (!gstate.send_pkt.yiaddr) {
+            msgtype = DHCPNAK;
+            optptr = set_optval(optptr, DHCP_OPT_MESSAGE_TYPE, &msgtype, 1);
+            send_packet(1);
+            break;
+          }
+          optptr = set_optval(optptr, DHCP_OPT_MESSAGE_TYPE, &msgtype, 1);
+          optptr = set_optval(optptr, DHCP_OPT_SERVER_ID, &gconfig.server_nip, 4);
+          reqested_lease = htonl(reqested_lease);
+          optptr = set_optval(optptr, DHCP_OPT_LEASE_TIME, &reqested_lease, 4);
+          send_packet(1);
+          write_leasefile();
+          break;
+        case DHCPDECLINE:// FALL THROUGH
+        case DHCPRELEASE:
+          dbg("Message Type : DHCPDECLINE or DHCPRELEASE \n");
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_SERVER_ID, &serverid);
+          if (serverid != gconfig.server_nip) break;
+          get_optval((uint8_t*) &gstate.rcvd_pkt.options, DHCP_OPT_REQUESTED_IP, &requested_nip);
+          delip_from_lease(requested_nip, gstate.rcvd_pkt.chaddr, (gstate.rqcode==DHCPRELEASE)?0:gconfig.decline_time);
+          break;
+        default:
+          dbg("Message Type : %u\n", gstate.rqcode);
+          break;
+      }
+    }
+  }
+}