text: /* 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#<0=20T#<0=3t#<0=3s: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"
  
  // 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 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;
    xstrncpy(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[12];
  
      sprintf(pidbuf, "%u", (unsigned)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 = (toys.optflags & 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 = xopenro("/dev/urandom");
  
  // TODO xreadfile
    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;
    }
    xstrncpy(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;
    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.
    if (dhcp_checksum(&packet.iph, sizeof(packet.iph)) != 0) {
      dbg("\tBad IP header checksum, ignoring\n");
      return -2;
    }
    // Verify UDP checksum. From RFC 768, the UDP checksum is done over the IPv4
    // pseudo header, the UDP header and the UDP data. The IPv4 pseudo header
    // includes saddr, daddr, protocol, and UDP length. The IP header has to be
    // modified for this.
    memset(&packet.iph, 0, ((size_t) &((struct iphdr *)0)->protocol));
    packet.iph.check = 0;
    packet.iph.tot_len = packet.udph.len;
    if (packet.udph.check != 0 && dhcp_checksum(&packet, bytes) != 0) {
      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
    strcpy((char*)optptr, hname); // 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 (!(toys.optflags & FLAG_o)) {
      *len = 4;
      *optptr++ = DHCP_OPTION_SUBNET_MASK;
      *optptr++ = DHCP_OPTION_ROUTER;
      *optptr++ = DHCP_OPTION_DNS_SERVER;
      *optptr++ = DHCP_OPTION_BROADCAST;
    }
    if (toys.optflags & 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 (!(toys.optflags & 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 (toys.optflags & FLAG_r) {
        inet_aton(TT.req_ip, &rqsd);
        pend = dhcpc_addreqipaddr(&rqsd, pend);
      }
      pend = dhcpc_addmaxsize(pend, htons(sizeof(dhcp_raw_t)));
      vendor = (toys.optflags & FLAG_V) ? TT.vendor_cls : "toybox\0";
      pend = dhcpc_addstropt(pend, DHCP_OPTION_VENDOR, vendor, strlen(vendor));
      if (toys.optflags & FLAG_H) pend = dhcpc_addstropt(pend, DHCP_OPTION_HOST_NAME, TT.hostname, strlen(TT.hostname));
      if (toys.optflags & FLAG_F) pend = dhcpc_addfdnname(pend, TT.fdn_name);
      if (!(toys.optflags & FLAG_o) || (toys.optflags & FLAG_O))
        pend = dhcpc_addreqoptions(pend);
      if (toys.optflags & 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 = (toys.optflags & FLAG_V) ? TT.vendor_cls : "toybox\0";
      pend = dhcpc_addstropt(pend, DHCP_OPTION_VENDOR, vendor, strlen(vendor));
      if (toys.optflags & FLAG_H) pend = dhcpc_addstropt(pend, DHCP_OPTION_HOST_NAME, TT.hostname, strlen(TT.hostname));
      if (toys.optflags & FLAG_F) pend = dhcpc_addfdnname(pend, TT.fdn_name);
      if (!(toys.optflags & FLAG_o) || (toys.optflags & FLAG_O))
        pend = dhcpc_addreqoptions(pend);
      if (toys.optflags & 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 (toys.optflags & 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) {
      if (*optptr == DHCP_OPTION_PADDING) {
        optptr++;
        continue;
      }
      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)
  {
    char buffer[sizeof("255.255.255.255\0")];
    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);
      xstrncpy(buffer, inet_ntoa(temp_addr), sizeof(buffer));
      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 (toys.optflags & 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 (toys.optflags & FLAG_v) dbg = xprintf;
    if (toys.optflags & FLAG_p) write_pid(TT.pidfile);
    retries = TT.retries;
    if (toys.optflags & FLAG_S) {
        openlog("UDHCPC :", LOG_PID, LOG_DAEMON);
        infomode |= LOG_SYSTEM;
    }
    infomsg(infomode, "dhcp started");
    if (toys.optflags & 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 (toys.optflags & 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 = (toys.optflags & 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 = TT.timeout;
            waited = 0;
            packets++;
            continue;
          }
  lease_fail:
          run_script(NULL,"leasefail");
          if (toys.optflags & FLAG_n) {
            infomsg(infomode, "Lease failed. Exiting");
            goto ret_with_sockfd;
          }
          if (toys.optflags & FLAG_b) {
            infomsg(infomode, "Lease failed. Going Daemon mode");
            daemon(0, 0);
            if (toys.optflags & FLAG_p) write_pid(TT.pidfile);
            toys.optflags &= ~FLAG_b;
            toys.optflags |= FLAG_f;
          }
          timeout = TT.tryagain;
          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 = TT.timeout;
            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 (toys.optflags & 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 (toys.optflags & FLAG_q) {
              if (toys.optflags & FLAG_R) release();
              goto ret_with_sockfd;
            }
            toys.optflags &= ~FLAG_n;
            if (!(toys.optflags & FLAG_f)) {
              daemon(0, 0);
              toys.optflags |= FLAG_f;
              if (toys.optflags & 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);
    }
  }
  