1/* dhcp.c - DHCP client for dynamic network configuration.
2 *
3 * Copyright 2012 Madhur Verma <mad.flexi@gmail.com>
4 * Copyright 2013 Kyungwan Han <asura321@gmail.com>
5 *
6 * Not in SUSv4.
7USE_DHCP(NEWTOY(dhcp, "V:H:F:x*r:O*A#<0=20T#<0=3t#<0=3s:p:i:SBRCaovqnbf", TOYFLAG_SBIN|TOYFLAG_ROOTONLY))
8
9config DHCP
10  bool "dhcp"
11  default n
12  help
13   usage: dhcp [-fbnqvoCRB] [-i IFACE] [-r IP] [-s PROG] [-p PIDFILE]
14               [-H HOSTNAME] [-V VENDOR] [-x OPT:VAL] [-O OPT]
15
16        Configure network dynamicaly using DHCP.
17
18      -i Interface to use (default eth0)
19      -p Create pidfile
20      -s Run PROG at DHCP events (default /usr/share/dhcp/default.script)
21      -B Request broadcast replies
22      -t Send up to N discover packets
23      -T Pause between packets (default 3 seconds)
24      -A Wait N seconds after failure (default 20)
25      -f Run in foreground
26      -b Background if lease is not obtained
27      -n Exit if lease is not obtained
28      -q Exit after obtaining lease
29      -R Release IP on exit
30      -S Log to syslog too
31      -a Use arping to validate offered address
32      -O Request option OPT from server (cumulative)
33      -o Don't request any options (unless -O is given)
34      -r Request this IP address
35      -x OPT:VAL  Include option OPT in sent packets (cumulative)
36      -F Ask server to update DNS mapping for NAME
37      -H Send NAME as client hostname (default none)
38      -V VENDOR Vendor identifier (default 'toybox VERSION')
39      -C Don't send MAC as client identifier
40      -v Verbose
41
42      Signals:
43      USR1  Renew current lease
44      USR2  Release current lease
45
46*/
47
48#define FOR_dhcp
49#include "toys.h"
50
51// TODO: headers not in posix:
52#include <netinet/ip.h>
53#include <netinet/udp.h>
54#include <netpacket/packet.h>
55
56#include <linux/filter.h> //FIXME: linux specific. fix for other OS ports
57#include <linux/if_ether.h>
58
59GLOBALS(
60    char *iface;
61    char *pidfile;
62    char *script;
63    long retries;
64    long timeout;
65    long tryagain;
66    struct arg_list *req_opt;
67    char *req_ip;
68    struct arg_list *pkt_opt;
69    char *fdn_name;
70    char *hostname;
71    char *vendor_cls;
72)
73
74#define STATE_INIT            0
75#define STATE_REQUESTING      1
76#define STATE_BOUND           2
77#define STATE_RENEWING        3
78#define STATE_REBINDING       4
79#define STATE_RENEW_REQUESTED 5
80#define STATE_RELEASED        6
81
82#define BOOTP_BROADCAST   0x8000
83#define DHCP_MAGIC        0x63825363
84
85#define DHCP_REQUEST          1
86#define DHCP_REPLY            2
87#define DHCP_HTYPE_ETHERNET   1
88
89#define DHCPC_SERVER_PORT     67
90#define DHCPC_CLIENT_PORT     68
91
92#define DHCPDISCOVER      1
93#define DHCPOFFER         2
94#define DHCPREQUEST       3
95#define DHCPACK           5
96#define DHCPNAK           6
97#define DHCPRELEASE       7
98
99#define DHCP_OPTION_PADDING     0x00
100#define DHCP_OPTION_SUBNET_MASK 0x01
101#define DHCP_OPTION_ROUTER      0x03
102#define DHCP_OPTION_DNS_SERVER  0x06
103#define DHCP_OPTION_HOST_NAME   0x0c
104#define DHCP_OPTION_BROADCAST   0x1c
105#define DHCP_OPTION_REQ_IPADDR  0x32
106#define DHCP_OPTION_LEASE_TIME  0x33
107#define DHCP_OPTION_OVERLOAD    0x34
108#define DHCP_OPTION_MSG_TYPE    0x35
109#define DHCP_OPTION_SERVER_ID   0x36
110#define DHCP_OPTION_REQ_LIST    0x37
111#define DHCP_OPTION_MAX_SIZE    0x39
112#define DHCP_OPTION_CLIENTID    0x3D
113#define DHCP_OPTION_VENDOR      0x3C
114#define DHCP_OPTION_FQDN        0x51
115#define DHCP_OPTION_END         0xFF
116
117#define DHCP_NUM8           (1<<8)
118#define DHCP_NUM16          (1<<9)
119#define DHCP_NUM32          DHCP_NUM16 | DHCP_NUM8
120#define DHCP_STRING         (1<<10)
121#define DHCP_STRLST         (1<<11)
122#define DHCP_IP             (1<<12)
123#define DHCP_IPLIST         (1<<13)
124#define DHCP_IPPLST         (1<<14)
125#define DHCP_STCRTS         (1<<15)
126
127#define LOG_SILENT          0x0
128#define LOG_CONSOLE         0x1
129#define LOG_SYSTEM          0x2
130
131#define MODE_OFF        0
132#define MODE_RAW        1
133#define MODE_APP        2
134
135static void (*dbg)(char *format, ...);
136static void dummy(char *format, ...){
137	return;
138}
139
140typedef struct dhcpc_result_s {
141  struct in_addr serverid;
142  struct in_addr ipaddr;
143  struct in_addr netmask;
144  struct in_addr dnsaddr;
145  struct in_addr default_router;
146  uint32_t lease_time;
147} dhcpc_result_t;
148
149typedef struct __attribute__((packed)) dhcp_msg_s {
150  uint8_t op;
151  uint8_t htype;
152  uint8_t hlen;
153  uint8_t hops;
154  uint32_t xid;
155  uint16_t secs;
156  uint16_t flags;
157  uint32_t ciaddr;
158  uint32_t yiaddr;
159  uint32_t nsiaddr;
160  uint32_t ngiaddr;
161  uint8_t chaddr[16];
162  uint8_t sname[64];
163  uint8_t file[128];
164  uint32_t cookie;
165  uint8_t options[308];
166} dhcp_msg_t;
167
168typedef struct __attribute__((packed)) dhcp_raw_s {
169  struct iphdr iph;
170  struct udphdr udph;
171  dhcp_msg_t dhcp;
172} dhcp_raw_t;
173
174typedef struct dhcpc_state_s {
175  uint8_t macaddr[6];
176   char *iface;
177  int ifindex;
178  int sockfd;
179  int status;
180  int mode;
181  uint32_t mask;
182  struct in_addr ipaddr;
183  struct in_addr serverid;
184  dhcp_msg_t pdhcp;
185} dhcpc_state_t;
186
187typedef struct option_val_s {
188  char *key;
189  uint16_t code;
190  void *val;
191  size_t len;
192} option_val_t;
193
194struct fd_pair { int rd; int wr; };
195static uint32_t xid;
196static dhcpc_state_t *state;
197static struct fd_pair sigfd;
198uint8_t bmacaddr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
199 int set = 1;
200uint8_t infomode = LOG_CONSOLE;
201uint8_t raw_opt[29];
202int raw_optcount = 0;
203struct arg_list *x_opt;
204in_addr_t server = 0;
205
206static option_val_t *msgopt_list = NULL;
207static option_val_t options_list[] = {
208    {"lease"          , DHCP_NUM32  | 0x33, NULL, 0},
209    {"subnet"         , DHCP_IP     | 0x01, NULL, 0},
210    {"broadcast"      , DHCP_IP     | 0x1c, NULL, 0},
211    {"router"         , DHCP_IP     | 0x03, NULL, 0},
212    {"ipttl"          , DHCP_NUM8   | 0x17, NULL, 0},
213    {"mtu"            , DHCP_NUM16  | 0x1a, NULL, 0},
214    {"hostname"       , DHCP_STRING | 0x0c, NULL, 0},
215    {"domain"         , DHCP_STRING | 0x0f, NULL, 0},
216    {"search"         , DHCP_STRLST | 0x77, NULL, 0},
217    {"nisdomain"      , DHCP_STRING | 0x28, NULL, 0},
218    {"timezone"       , DHCP_NUM32  | 0x02, NULL, 0},
219    {"tftp"           , DHCP_STRING | 0x42, NULL, 0},
220    {"bootfile"       , DHCP_STRING | 0x43, NULL, 0},
221    {"bootsize"       , DHCP_NUM16  | 0x0d, NULL, 0},
222    {"rootpath"       , DHCP_STRING | 0x11, NULL, 0},
223    {"wpad"           , DHCP_STRING | 0xfc, NULL, 0},
224    {"serverid"       , DHCP_IP     | 0x36, NULL, 0},
225    {"message"        , DHCP_STRING | 0x38, NULL, 0},
226    {"vlanid"         , DHCP_NUM32  | 0x84, NULL, 0},
227    {"vlanpriority"   , DHCP_NUM32  | 0x85, NULL, 0},
228    {"dns"            , DHCP_IPLIST | 0x06, NULL, 0},
229    {"wins"           , DHCP_IPLIST | 0x2c, NULL, 0},
230    {"nissrv"         , DHCP_IPLIST | 0x29, NULL, 0},
231    {"ntpsrv"         , DHCP_IPLIST | 0x2a, NULL, 0},
232    {"lprsrv"         , DHCP_IPLIST | 0x09, NULL, 0},
233    {"swapsrv"        , DHCP_IP     | 0x10, NULL, 0},
234    {"routes"         , DHCP_STCRTS | 0x21, NULL, 0},
235    {"staticroutes"   , DHCP_STCRTS | 0x79, NULL, 0},
236    {"msstaticroutes" , DHCP_STCRTS | 0xf9, NULL, 0},
237};
238
239static  struct sock_filter filter_instr[] = {
240    BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
241    BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 0, 6),
242    BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 6),
243    BPF_JUMP(BPF_JMP|BPF_JSET|BPF_K, 0x1fff, 4, 0),
244    BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0), BPF_STMT(BPF_LD|BPF_H|BPF_IND, 2),
245    BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 68, 0, 1),
246    BPF_STMT(BPF_RET|BPF_K, 0xffffffff), BPF_STMT(BPF_RET|BPF_K, 0),
247};
248
249static  struct sock_fprog filter_prog = {
250    .len = ARRAY_LEN(filter_instr),
251    .filter = (struct sock_filter *) filter_instr,
252};
253
254// calculate options size.
255static int dhcp_opt_size(uint8_t *optionptr)
256{
257  int i = 0;
258  for(;optionptr[i] != 0xff; i++) if(optionptr[i] != 0x00) i += optionptr[i + 1] + 2 -1;
259  return i;
260}
261
262// calculates checksum for dhcp messages.
263static uint16_t dhcp_checksum(void *addr, int count)
264{
265  int32_t sum = 0;
266  uint16_t tmp = 0, *source = (uint16_t *)addr;
267
268  while (count > 1)  {
269    sum += *source++;
270    count -= 2;
271  }
272  if (count > 0) {
273    *(uint8_t*)&tmp = *(uint8_t*)source;
274    sum += tmp;
275  }
276  while (sum >> 16) sum = (sum & 0xffff) + (sum >> 16);
277  return ~sum;
278}
279
280// gets information of INTERFACE and updates IFINDEX, MAC and IP
281static int get_interface( char *interface, int *ifindex, uint32_t *oip, uint8_t *mac)
282{
283  struct ifreq req;
284  struct sockaddr_in *ip;
285  int fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
286
287  req.ifr_addr.sa_family = AF_INET;
288  xstrncpy(req.ifr_name, interface, IFNAMSIZ);
289  req.ifr_name[IFNAMSIZ-1] = '\0';
290
291  xioctl(fd, SIOCGIFFLAGS, &req);
292  if (!(req.ifr_flags & IFF_UP)) return -1;
293
294  if (oip) {
295    xioctl(fd, SIOCGIFADDR, &req);
296    ip = (struct sockaddr_in*) &req.ifr_addr;
297    dbg("IP %s\n", inet_ntoa(ip->sin_addr));
298    *oip = ntohl(ip->sin_addr.s_addr);
299  }
300  if (ifindex) {
301    xioctl(fd, SIOCGIFINDEX, &req);
302    dbg("Adapter index %d\n", req.ifr_ifindex);
303    *ifindex = req.ifr_ifindex;
304  }
305  if (mac) {
306    xioctl(fd, SIOCGIFHWADDR, &req);
307    memcpy(mac, req.ifr_hwaddr.sa_data, 6);
308    dbg("MAC %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
309  }
310  close(fd);
311  return 0;
312}
313
314/*
315 *logs messeges to syslog or console
316 *opening the log is still left with applet.
317 *FIXME: move to more relevent lib. probably libc.c
318 */
319static void infomsg(uint8_t infomode,  char *s, ...)
320{
321  int used;
322  char *msg;
323  va_list p, t;
324
325  if (infomode == LOG_SILENT) return;
326  va_start(p, s);
327  va_copy(t, p);
328  used = vsnprintf(NULL, 0, s, t);
329  used++;
330  va_end(t);
331
332  msg = xmalloc(used);
333  vsnprintf(msg, used, s, p);
334  va_end(p);
335
336  if (infomode & LOG_SYSTEM) syslog(LOG_INFO, "%s", msg);
337  if (infomode & LOG_CONSOLE) printf("%s\n", msg);
338  free(msg);
339}
340
341/*
342 * Writes self PID in file PATH
343 * FIXME: libc implementation only writes in /var/run
344 * this is more generic as some implemenation may provide
345 * arguments to write in specific file. as dhcpd does.
346 */
347static void write_pid(char *path)
348{
349  int pidfile = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0666);
350  if (pidfile > 0) {
351    char pidbuf[12];
352
353    sprintf(pidbuf, "%u", (unsigned)getpid());
354    write(pidfile, pidbuf, strlen(pidbuf));
355    close(pidfile);
356  }
357}
358
359// String STR to UINT32 conversion strored in VAR
360static long strtou32( char *str)
361{
362  char *endptr = NULL;
363  int base = 10;
364  errno=0;
365  if (str[0]=='0' && (str[1]=='x' || str[1]=='X')) {
366    base = 16;
367    str+=2;
368  }
369  long ret_val = strtol(str, &endptr, base);
370  if (errno) return -1;
371  else if (endptr && (*endptr!='\0'||endptr == str)) return -1;
372  return ret_val;
373}
374
375// IP String STR to binary data.
376static int striptovar( char *str, void *var)
377{
378  in_addr_t addr;
379  if(!str) error_exit("NULL address string.");
380  addr = inet_addr(str);
381  if(addr == -1) error_exit("Wrong address %s.",str );
382  *((uint32_t*)(var)) = (uint32_t)addr;
383  return 0;
384}
385
386// String to dhcp option conversion
387static int strtoopt( char *str, uint8_t optonly)
388{
389  char *option, *valstr, *grp, *tp;
390  long optcode = 0, convtmp;
391  uint16_t flag = 0;
392  uint32_t mask, nip, router;
393  int count, size = ARRAY_LEN(options_list);
394
395  if (!*str) return 0;
396  option = strtok((char*)str, ":");
397  if (!option) return -1;
398
399  dbg("-x option : %s ", option);
400  optcode = strtou32(option);
401
402  if (optcode > 0 && optcode < 256) {         // raw option
403    for (count = 0; count < size; count++) {
404      if ((options_list[count].code & 0X00FF) == optcode) {
405        flag = (options_list[count].code & 0XFF00);
406        break;
407      }
408    }
409    if (count == size) error_exit("Obsolete OR Unknown Option : %s", option);
410  } else {    // string option
411    for (count = 0; count < size; count++) {
412      if (!strcmp(options_list[count].key, option)) {
413        flag = (options_list[count].code & 0XFF00);
414        optcode = (options_list[count].code & 0X00FF);
415        break;
416      }
417    }
418    if (count == size) error_exit("Obsolete OR Unknown Option : %s", option);
419  }
420  if (!flag || !optcode) return -1;
421  if (optonly) return optcode;
422
423  valstr = strtok(NULL, "\n");
424  if (!valstr) error_exit("option %s has no value defined.\n", option);
425  dbg(" value : %-20s \n ", valstr);
426  switch (flag) {
427  case DHCP_NUM32:
428    options_list[count].len = sizeof(uint32_t);
429    options_list[count].val = xmalloc(sizeof(uint32_t));
430    convtmp = strtou32(valstr);
431    if (convtmp < 0) error_exit("Invalid/wrong formated number %s", valstr);
432    convtmp = htonl(convtmp);
433    memcpy(options_list[count].val, &convtmp, sizeof(uint32_t));
434    break;
435  case DHCP_NUM16:
436    options_list[count].len = sizeof(uint16_t);
437    options_list[count].val = xmalloc(sizeof(uint16_t));
438    convtmp = strtou32(valstr);
439    if (convtmp < 0) error_exit("Invalid/malformed number %s", valstr);
440    convtmp = htons(convtmp);
441    memcpy(options_list[count].val, &convtmp, sizeof(uint16_t));
442    break;
443  case DHCP_NUM8:
444    options_list[count].len = sizeof(uint8_t);
445    options_list[count].val = xmalloc(sizeof(uint8_t));
446    convtmp = strtou32(valstr);
447    if (convtmp < 0) error_exit("Invalid/malformed number %s", valstr);
448    memcpy(options_list[count].val, &convtmp, sizeof(uint8_t));
449    break;
450  case DHCP_IP:
451    options_list[count].len = sizeof(uint32_t);
452    options_list[count].val = xmalloc(sizeof(uint32_t));
453    striptovar(valstr, options_list[count].val);
454    break;
455  case DHCP_STRING:
456    options_list[count].len = strlen(valstr);
457    options_list[count].val = strdup(valstr);
458    break;
459  case DHCP_IPLIST:
460    while(valstr){
461      options_list[count].val = xrealloc(options_list[count].val, options_list[count].len + sizeof(uint32_t));
462      striptovar(valstr, ((uint8_t*)options_list[count].val)+options_list[count].len);
463      options_list[count].len += sizeof(uint32_t);
464      valstr = strtok(NULL," \t");
465    }
466    break;
467  case DHCP_STRLST:
468  case DHCP_IPPLST:
469    break;
470  case DHCP_STCRTS:
471    /* Option binary format:
472     * mask [one byte, 0..32]
473     * ip [0..4 bytes depending on mask]
474     * router [4 bytes]
475     * may be repeated
476     * staticroutes 10.0.0.0/8 10.127.0.1, 10.11.12.0/24 10.11.12.1
477     */
478    grp = strtok(valstr, ",");;
479    while(grp){
480      while(*grp == ' ' || *grp == '\t') grp++;
481      tp = strchr(grp, '/');
482      if (!tp) error_exit("malformed static route option");
483      *tp = '\0';
484      mask = strtol(++tp, &tp, 10);
485      if (striptovar(grp, (uint8_t*)&nip) < 0) error_exit("malformed static route option");
486      while(*tp == ' ' || *tp == '\t' || *tp == '-') tp++;
487      if (striptovar(tp, (uint8_t*)&router) < 0) error_exit("malformed static route option");
488      options_list[count].val = xrealloc(options_list[count].val, options_list[count].len + 1 + mask/8 + 4);
489      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &mask, 1);
490      options_list[count].len += 1;
491      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &nip, mask/8);
492      options_list[count].len += mask/8;
493      memcpy(((uint8_t*)options_list[count].val)+options_list[count].len, &router, 4);
494      options_list[count].len += 4;
495      tp = NULL;
496      grp = strtok(NULL, ",");
497    }
498    break;
499  }
500  return 0;
501}
502
503// Creates environment pointers from RES to use in script
504static int fill_envp(dhcpc_result_t *res)
505{
506  struct in_addr temp;
507  int size = ARRAY_LEN(options_list), count, ret = -1;
508
509  ret = setenv("interface", state->iface, 1);
510  if (!res) return ret;
511  if (res->ipaddr.s_addr) {
512      temp.s_addr = htonl(res->ipaddr.s_addr);
513      ret = setenv("ip", inet_ntoa(temp), 1);
514      if (ret) return ret;
515  }
516  if (msgopt_list) {
517    for (count = 0; count < size; count++) {
518        if ((msgopt_list[count].len == 0) || (msgopt_list[count].val == NULL)) continue;
519        ret = setenv(msgopt_list[count].key, (char*)msgopt_list[count].val, 1);
520        if (ret) return ret;
521      }
522  }
523  return ret;
524}
525
526// Executes Script NAME.
527static void run_script(dhcpc_result_t *res,  char *name)
528{
529  volatile int error = 0;
530  pid_t pid;
531  char *argv[3];
532  struct stat sts;
533  char *script = (toys.optflags & FLAG_s) ? TT.script
534    : "/usr/share/dhcp/default.script";
535
536  if (stat(script, &sts) == -1 && errno == ENOENT) return;
537  if (fill_envp(res)) {
538    dbg("Failed to create environment variables.");
539    return;
540  }
541  dbg("Executing %s %s\n", script, name);
542  argv[0] = (char*) script;
543  argv[1] = (char*) name;
544  argv[2] = NULL;
545  fflush(NULL);
546
547  pid = vfork();
548  if (pid < 0) {
549    dbg("Fork failed.\n");
550    return;
551  }
552  if (!pid) {
553    execvp(argv[0], argv);
554    error = errno;
555    _exit(111);
556  }
557  if (error) {
558    waitpid(pid, NULL,0);
559    errno = error;
560    perror_msg("script exec failed");
561  }
562  dbg("script complete.\n");
563}
564
565// returns a randome ID
566static uint32_t getxid(void)
567{
568  uint32_t randnum;
569  int fd = xopenro("/dev/urandom");
570
571// TODO xreadfile
572  xreadall(fd, &randnum, sizeof(randnum));
573  xclose(fd);
574  return randnum;
575}
576
577// opens socket in raw mode.
578static int mode_raw(void)
579{
580  state->mode = MODE_OFF;
581  struct sockaddr_ll sock;
582
583  if (state->sockfd > 0) close(state->sockfd);
584  dbg("Opening raw socket on ifindex %d\n", state->ifindex);
585
586  state->sockfd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
587  if (state->sockfd < 0) {
588    dbg("MODE RAW : socket fail ERROR : %d\n", state->sockfd);
589    return -1;
590  }
591  dbg("Got raw socket fd %d\n", state->sockfd);
592  memset(&sock, 0, sizeof(sock));
593  sock.sll_family = AF_PACKET;
594  sock.sll_protocol = htons(ETH_P_IP);
595  sock.sll_ifindex = state->ifindex;
596
597  if (bind(state->sockfd, (struct sockaddr *) &sock, sizeof(sock))) {
598    dbg("MODE RAW : bind fail.\n");
599    close(state->sockfd);
600    return -1;
601  }
602  state->mode = MODE_RAW;
603  if (setsockopt(state->sockfd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog, sizeof(filter_prog)) < 0)
604    dbg("MODE RAW : filter attach fail.\n");
605
606  dbg("MODE RAW : success\n");
607  return 0;
608}
609
610// opens UDP socket
611static int mode_app(void)
612{
613  struct sockaddr_in addr;
614  struct ifreq ifr;
615
616  state->mode = MODE_OFF;
617  if (state->sockfd > 0) close(state->sockfd);
618
619  dbg("Opening listen socket on *:%d %s\n", DHCPC_CLIENT_PORT, state->iface);
620  state->sockfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
621  if (state->sockfd < 0) {
622    dbg("MODE APP : socket fail ERROR: %d\n", state->sockfd);
623    return -1;
624  }
625  setsockopt(state->sockfd, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set));
626  if (setsockopt(state->sockfd, SOL_SOCKET, SO_BROADCAST, &set, sizeof(set)) == -1) {
627    dbg("MODE APP : brodcast failed.\n");
628    close(state->sockfd);
629    return -1;
630  }
631  xstrncpy(ifr.ifr_name, state->iface, IFNAMSIZ);
632  ifr.ifr_name[IFNAMSIZ -1] = '\0';
633  setsockopt(state->sockfd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr));
634
635  memset(&addr, 0, sizeof(addr));
636  addr.sin_family = AF_INET;
637  addr.sin_port = htons(DHCPC_CLIENT_PORT);
638  addr.sin_addr.s_addr = INADDR_ANY ;
639
640  if (bind(state->sockfd, (struct sockaddr *) &addr, sizeof(addr))) {
641    close(state->sockfd);
642    dbg("MODE APP : bind failed.\n");
643    return -1;
644  }
645  state->mode = MODE_APP;
646  dbg("MODE APP : success\n");
647  return 0;
648}
649
650static int read_raw(void)
651{
652  dhcp_raw_t packet;
653  uint16_t check;
654  int bytes = 0;
655
656  memset(&packet, 0, sizeof(packet));
657  if ((bytes = read(state->sockfd, &packet, sizeof(packet))) < 0) {
658    dbg("\tPacket read error, ignoring\n");
659    return bytes;
660  }
661  if (bytes < (int) (sizeof(packet.iph) + sizeof(packet.udph))) {
662    dbg("\tPacket is too short, ignoring\n");
663    return -2;
664  }
665  if (bytes < ntohs(packet.iph.tot_len)) {
666    dbg("\tOversized packet, ignoring\n");
667    return -2;
668  }
669  // ignore any extra garbage bytes
670  bytes = ntohs(packet.iph.tot_len);
671  // make sure its the right packet for us, and that it passes sanity checks
672  if (packet.iph.protocol != IPPROTO_UDP || packet.iph.version != IPVERSION
673   || packet.iph.ihl != (sizeof(packet.iph) >> 2)
674   || packet.udph.dest != htons(DHCPC_CLIENT_PORT)
675   || ntohs(packet.udph.len) != (uint16_t)(bytes - sizeof(packet.iph))) {
676    dbg("\tUnrelated/bogus packet, ignoring\n");
677    return -2;
678  }
679  // verify IP checksum
680  check = packet.iph.check;
681  packet.iph.check = 0;
682  if (check != dhcp_checksum(&packet.iph, sizeof(packet.iph))) {
683    dbg("\tBad IP header checksum, ignoring\n");
684    return -2;
685  }
686  memset(&packet.iph, 0, ((size_t) &((struct iphdr *)0)->protocol));
687  packet.iph.tot_len = packet.udph.len;
688  check = packet.udph.check;
689  packet.udph.check = 0;
690  if (check && check != dhcp_checksum(&packet, bytes)) {
691    dbg("\tPacket with bad UDP checksum received, ignoring\n");
692    return -2;
693  }
694  memcpy(&state->pdhcp, &packet.dhcp, bytes - (sizeof(packet.iph) + sizeof(packet.udph)));
695  if (state->pdhcp.cookie != htonl(DHCP_MAGIC)) {
696    dbg("\tPacket with bad magic, ignoring\n");
697    return -2;
698  }
699  return bytes - sizeof(packet.iph) - sizeof(packet.udph);
700}
701
702static int read_app(void)
703{
704  int ret;
705
706  memset(&state->pdhcp, 0, sizeof(dhcp_msg_t));
707  if ((ret = read(state->sockfd, &state->pdhcp, sizeof(dhcp_msg_t))) < 0) {
708    dbg("Packet read error, ignoring\n");
709    return ret; /* returns -1 */
710  }
711  if (state->pdhcp.cookie != htonl(DHCP_MAGIC)) {
712    dbg("Packet with bad magic, ignoring\n");
713    return -2;
714  }
715  return ret;
716}
717
718// Sends data through raw socket.
719static int send_raw(void)
720{
721  struct sockaddr_ll dest_sll;
722  dhcp_raw_t packet;
723  unsigned padding;
724  int fd, result = -1;
725
726  memset(&packet, 0, sizeof(dhcp_raw_t));
727  memcpy(&packet.dhcp, &state->pdhcp, sizeof(dhcp_msg_t));
728
729  if ((fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
730    dbg("SEND RAW: socket failed\n");
731    return result;
732  }
733  memset(&dest_sll, 0, sizeof(dest_sll));
734  dest_sll.sll_family = AF_PACKET;
735  dest_sll.sll_protocol = htons(ETH_P_IP);
736  dest_sll.sll_ifindex = state->ifindex;
737  dest_sll.sll_halen = 6;
738  memcpy(dest_sll.sll_addr, bmacaddr , 6);
739
740  if (bind(fd, (struct sockaddr *) &dest_sll, sizeof(dest_sll)) < 0) {
741    dbg("SEND RAW: bind failed\n");
742    close(fd);
743    return result;
744  }
745  padding = 308 - 1 - dhcp_opt_size(state->pdhcp.options);
746  packet.iph.protocol = IPPROTO_UDP;
747  packet.iph.saddr = INADDR_ANY;
748  packet.iph.daddr = INADDR_BROADCAST;
749  packet.udph.source = htons(DHCPC_CLIENT_PORT);
750  packet.udph.dest = htons(DHCPC_SERVER_PORT);
751  packet.udph.len = htons(sizeof(dhcp_raw_t) - sizeof(struct iphdr) - padding);
752  packet.iph.tot_len = packet.udph.len;
753  packet.udph.check = dhcp_checksum(&packet, sizeof(dhcp_raw_t) - padding);
754  packet.iph.tot_len = htons(sizeof(dhcp_raw_t) - padding);
755  packet.iph.ihl = sizeof(packet.iph) >> 2;
756  packet.iph.version = IPVERSION;
757  packet.iph.ttl = IPDEFTTL;
758  packet.iph.check = dhcp_checksum(&packet.iph, sizeof(packet.iph));
759
760  result = sendto(fd, &packet, sizeof(dhcp_raw_t) - padding, 0,
761      (struct sockaddr *) &dest_sll, sizeof(dest_sll));
762
763  close(fd);
764  if (result < 0) dbg("SEND RAW: PACKET send error\n");
765  return result;
766}
767
768// Sends data through UDP socket.
769static int send_app(void)
770{
771  struct sockaddr_in cli;
772  int fd, ret = -1;
773
774  if ((fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
775    dbg("SEND APP: sock failed.\n");
776    return ret;
777  }
778  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set));
779
780  memset(&cli, 0, sizeof(cli));
781  cli.sin_family = AF_INET;
782  cli.sin_port = htons(DHCPC_CLIENT_PORT);
783  cli.sin_addr.s_addr = state->pdhcp.ciaddr;
784  if (bind(fd, (struct sockaddr *)&cli, sizeof(cli)) == -1) {
785    dbg("SEND APP: bind failed.\n");
786    goto error_fd;
787  }
788  memset(&cli, 0, sizeof(cli));
789  cli.sin_family = AF_INET;
790  cli.sin_port = htons(DHCPC_SERVER_PORT);
791  cli.sin_addr.s_addr = state->serverid.s_addr;
792  if (connect(fd, (struct sockaddr *)&cli, sizeof(cli)) == -1) {
793    dbg("SEND APP: connect failed.\n");
794    goto error_fd;
795  }
796  int padding = 308 - 1 - dhcp_opt_size(state->pdhcp.options);
797  if((ret = write(fd, &state->pdhcp, sizeof(dhcp_msg_t) - padding)) < 0) {
798    dbg("SEND APP: write failed error %d\n", ret);
799    goto error_fd;
800  }
801  dbg("SEND APP: write success wrote %d\n", ret);
802error_fd:
803  close(fd);
804  return ret;
805}
806
807// Generic signal handler real handling is done in main funcrion.
808static void signal_handler(int sig)
809{
810  unsigned char ch = sig;
811  if (write(sigfd.wr, &ch, 1) != 1) dbg("can't send signal\n");
812}
813
814// signal setup for SIGUSR1 SIGUSR2 SIGTERM
815static int setup_signal()
816{
817  if (pipe((int *)&sigfd) < 0) {
818    dbg("signal pipe failed\n");
819    return -1;
820  }
821  fcntl(sigfd.wr , F_SETFD, FD_CLOEXEC);
822  fcntl(sigfd.rd , F_SETFD, FD_CLOEXEC);
823  int flags = fcntl(sigfd.wr, F_GETFL);
824  fcntl(sigfd.wr, F_SETFL, flags | O_NONBLOCK);
825  signal(SIGUSR1, signal_handler);
826  signal(SIGUSR2, signal_handler);
827  signal(SIGTERM, signal_handler);
828
829  return 0;
830}
831
832// adds client id to dhcp packet
833static uint8_t *dhcpc_addclientid(uint8_t *optptr)
834{
835  *optptr++ = DHCP_OPTION_CLIENTID;
836  *optptr++ = 7;
837  *optptr++ = 1;
838  memcpy(optptr, &state->macaddr, 6);
839  return optptr + 6;
840}
841
842// adds messege type to dhcp packet
843static uint8_t *dhcpc_addmsgtype(uint8_t *optptr, uint8_t type)
844{
845  *optptr++ = DHCP_OPTION_MSG_TYPE;
846  *optptr++ = 1;
847  *optptr++ = type;
848  return optptr;
849}
850
851// adds max size to dhcp packet
852static uint8_t *dhcpc_addmaxsize(uint8_t *optptr, uint16_t size)
853{
854  *optptr++ = DHCP_OPTION_MAX_SIZE;
855  *optptr++ = 2;
856  memcpy(optptr, &size, 2);
857  return optptr + 2;
858}
859
860static uint8_t *dhcpc_addstropt(uint8_t *optptr, uint8_t opcode, char* str, int len)
861{
862  *optptr++ = opcode;
863  *optptr++ = len;
864  memcpy(optptr, str, len);
865  return optptr + len;
866}
867
868// adds server id to dhcp packet.
869static uint8_t *dhcpc_addserverid(struct in_addr *serverid, uint8_t *optptr)
870{
871  *optptr++ = DHCP_OPTION_SERVER_ID;
872  *optptr++ = 4;
873  memcpy(optptr, &serverid->s_addr, 4);
874  return optptr + 4;
875}
876
877// adds requested ip address to dhcp packet.
878static uint8_t *dhcpc_addreqipaddr(struct in_addr *ipaddr, uint8_t *optptr)
879{
880  *optptr++ = DHCP_OPTION_REQ_IPADDR;
881  *optptr++ = 4;
882  memcpy(optptr, &ipaddr->s_addr, 4);
883  return optptr + 4;
884}
885
886// adds hostname to dhcp packet.
887static uint8_t *dhcpc_addfdnname(uint8_t *optptr, char *hname)
888{
889  int size = strlen(hname);
890
891  *optptr++ = DHCP_OPTION_FQDN;
892  *optptr++ = size + 3;
893  *optptr++ = 0x1;  //flags
894  optptr += 2;      // two blank bytes
895  strcpy((char*)optptr, hname); // name
896
897  return optptr + size;
898}
899
900// adds request options using -o,-O flag to dhcp packet
901static uint8_t *dhcpc_addreqoptions(uint8_t *optptr)
902{
903  uint8_t *len;
904
905  *optptr++ = DHCP_OPTION_REQ_LIST;
906  len = optptr;
907  *len = 0;
908  optptr++;
909
910  if (!(toys.optflags & FLAG_o)) {
911    *len = 4;
912    *optptr++ = DHCP_OPTION_SUBNET_MASK;
913    *optptr++ = DHCP_OPTION_ROUTER;
914    *optptr++ = DHCP_OPTION_DNS_SERVER;
915    *optptr++ = DHCP_OPTION_BROADCAST;
916  }
917  if (toys.optflags & FLAG_O) {
918    memcpy(optptr++, raw_opt, raw_optcount);
919    *len += raw_optcount;
920  }
921  return optptr;
922}
923
924static uint8_t *dhcpc_addend(uint8_t *optptr)
925{
926  *optptr++ = DHCP_OPTION_END;
927  return optptr;
928}
929
930// Sets values of -x options in dhcp discover and request packet.
931static uint8_t* set_xopt(uint8_t *optptr)
932{
933  int count;
934  int size = ARRAY_LEN(options_list);
935  for (count = 0; count < size; count++) {
936    if ((options_list[count].len == 0) || (options_list[count].val == NULL)) continue;
937    *optptr++ = (uint8_t) (options_list[count].code & 0x00FF);
938    *optptr++ = (uint8_t) options_list[count].len;
939    memcpy(optptr, options_list[count].val, options_list[count].len);
940    optptr += options_list[count].len;
941  }
942  return optptr;
943}
944
945static uint32_t get_option_serverid (uint8_t *opt, dhcpc_result_t *presult)
946{
947  uint32_t var = 0;
948  while (*opt != DHCP_OPTION_SERVER_ID) {
949    if (*opt == DHCP_OPTION_END) return var;
950    opt += opt[1] + 2;
951  }
952  memcpy(&var, opt+2, sizeof(uint32_t));
953  state->serverid.s_addr = var;
954  presult->serverid.s_addr = state->serverid.s_addr;
955  presult->serverid.s_addr = ntohl(presult->serverid.s_addr);
956  return var;
957}
958
959static uint8_t get_option_msgtype(uint8_t *opt)
960{
961  uint32_t var = 0;
962  while (*opt != DHCP_OPTION_MSG_TYPE) {
963    if (*opt == DHCP_OPTION_END) return var;
964    opt += opt[1] + 2;
965  }
966  memcpy(&var, opt+2, sizeof(uint8_t));
967  return var;
968}
969
970static uint8_t get_option_lease(uint8_t *opt, dhcpc_result_t *presult)
971{
972  uint32_t var = 0;
973  while (*opt != DHCP_OPTION_LEASE_TIME) {
974    if (*opt == DHCP_OPTION_END) return var;
975    opt += opt[1] + 2;
976  }
977  memcpy(&var, opt+2, sizeof(uint32_t));
978  var = htonl(var);
979  presult->lease_time = var;
980  return var;
981}
982
983
984// sends dhcp msg of MSGTYPE
985static int dhcpc_sendmsg(int msgtype)
986{
987  uint8_t *pend;
988  struct in_addr rqsd;
989  char *vendor;
990
991  // Create the common message header settings
992  memset(&state->pdhcp, 0, sizeof(dhcp_msg_t));
993  state->pdhcp.op = DHCP_REQUEST;
994  state->pdhcp.htype = DHCP_HTYPE_ETHERNET;
995  state->pdhcp.hlen = 6;
996  state->pdhcp.xid = xid;
997  memcpy(state->pdhcp.chaddr, state->macaddr, 6);
998  memset(&state->pdhcp.chaddr[6], 0, 10);
999  state->pdhcp.cookie = htonl(DHCP_MAGIC);;
1000
1001  // Add the common header options
1002  pend = state->pdhcp.options;
1003  pend = dhcpc_addmsgtype(pend, msgtype);
1004
1005  if (!(toys.optflags & FLAG_C)) pend = dhcpc_addclientid(pend);
1006  // Handle the message specific settings
1007  switch (msgtype) {
1008  case DHCPDISCOVER: // Broadcast DISCOVER message to all servers
1009    state->pdhcp.flags = htons(BOOTP_BROADCAST); //  Broadcast bit.
1010    if (toys.optflags & FLAG_r) {
1011      inet_aton(TT.req_ip, &rqsd);
1012      pend = dhcpc_addreqipaddr(&rqsd, pend);
1013    }
1014    pend = dhcpc_addmaxsize(pend, htons(sizeof(dhcp_raw_t)));
1015    vendor = (toys.optflags & FLAG_V) ? TT.vendor_cls : "toybox\0";
1016    pend = dhcpc_addstropt(pend, DHCP_OPTION_VENDOR, vendor, strlen(vendor));
1017    if (toys.optflags & FLAG_H) pend = dhcpc_addstropt(pend, DHCP_OPTION_HOST_NAME, TT.hostname, strlen(TT.hostname));
1018    if (toys.optflags & FLAG_F) pend = dhcpc_addfdnname(pend, TT.fdn_name);
1019    if (!(toys.optflags & FLAG_o) || (toys.optflags & FLAG_O))
1020      pend = dhcpc_addreqoptions(pend);
1021    if (toys.optflags & FLAG_x) pend = set_xopt(pend);
1022    break;
1023  case DHCPREQUEST: // Send REQUEST message to the server that sent the *first* OFFER
1024    state->pdhcp.flags = htons(BOOTP_BROADCAST); //  Broadcast bit.
1025    if (state->status == STATE_RENEWING) memcpy(&state->pdhcp.ciaddr, &state->ipaddr.s_addr, 4);
1026    pend = dhcpc_addmaxsize(pend, htons(sizeof(dhcp_raw_t)));
1027    rqsd.s_addr = htonl(server);
1028    pend = dhcpc_addserverid(&rqsd, pend);
1029    pend = dhcpc_addreqipaddr(&state->ipaddr, pend);
1030    vendor = (toys.optflags & FLAG_V) ? TT.vendor_cls : "toybox\0";
1031    pend = dhcpc_addstropt(pend, DHCP_OPTION_VENDOR, vendor, strlen(vendor));
1032    if (toys.optflags & FLAG_H) pend = dhcpc_addstropt(pend, DHCP_OPTION_HOST_NAME, TT.hostname, strlen(TT.hostname));
1033    if (toys.optflags & FLAG_F) pend = dhcpc_addfdnname(pend, TT.fdn_name);
1034    if (!(toys.optflags & FLAG_o) || (toys.optflags & FLAG_O))
1035      pend = dhcpc_addreqoptions(pend);
1036    if (toys.optflags & FLAG_x) pend = set_xopt(pend);
1037    break;
1038  case DHCPRELEASE: // Send RELEASE message to the server.
1039    memcpy(&state->pdhcp.ciaddr, &state->ipaddr.s_addr, 4);
1040    rqsd.s_addr = htonl(server);
1041    pend = dhcpc_addserverid(&rqsd, pend);
1042    break;
1043  default:
1044    return -1;
1045  }
1046  pend = dhcpc_addend(pend);
1047
1048  if (state->mode == MODE_APP) return send_app();
1049  return send_raw();
1050}
1051
1052/*
1053 * parses options from received dhcp packet at OPTPTR and
1054 * stores result in PRESULT or MSGOPT_LIST
1055 */
1056static uint8_t dhcpc_parseoptions(dhcpc_result_t *presult, uint8_t *optptr)
1057{
1058  uint8_t type = 0, *options, overloaded = 0;;
1059  uint16_t flag = 0;
1060  uint32_t convtmp = 0;
1061  char *dest, *pfx;
1062  struct in_addr addr;
1063  int count, optlen, size = ARRAY_LEN(options_list);
1064
1065  if (toys.optflags & FLAG_x) {
1066    if(msgopt_list){
1067      for (count = 0; count < size; count++){
1068        if(msgopt_list[count].val) free(msgopt_list[count].val);
1069        msgopt_list[count].val = NULL;
1070        msgopt_list[count].len = 0;
1071      }
1072    } else {
1073     msgopt_list = xmalloc(sizeof(options_list));
1074     memcpy(msgopt_list, options_list, sizeof(options_list));
1075     for (count = 0; count < size; count++) {
1076         msgopt_list[count].len = 0;
1077         msgopt_list[count].val = NULL;
1078     }
1079    }
1080  } else {
1081    msgopt_list = options_list;
1082    for (count = 0; count < size; count++) {
1083      msgopt_list[count].len = 0;
1084      if(msgopt_list[count].val) free(msgopt_list[count].val);
1085      msgopt_list[count].val = NULL;
1086    }
1087  }
1088
1089  while (*optptr != DHCP_OPTION_END) {
1090    if (*optptr == DHCP_OPTION_PADDING) {
1091      optptr++;
1092      continue;
1093    }
1094    if (*optptr == DHCP_OPTION_OVERLOAD) {
1095      overloaded = optptr[2];
1096      optptr += optptr[1] + 2;
1097      continue;
1098    }
1099    for (count = 0, flag = 0; count < size; count++) {
1100      if ((msgopt_list[count].code & 0X00FF) == *optptr) {
1101        flag = (msgopt_list[count].code & 0XFF00);
1102        break;
1103      }
1104    }
1105    switch (flag) {
1106    case DHCP_NUM32:
1107      memcpy(&convtmp, &optptr[2], sizeof(uint32_t));
1108      convtmp = htonl(convtmp);
1109      sprintf(toybuf, "%u", convtmp);
1110      msgopt_list[count].val = strdup(toybuf);
1111      msgopt_list[count].len = strlen(toybuf);
1112      break;
1113    case DHCP_NUM16:
1114      memcpy(&convtmp, &optptr[2], sizeof(uint16_t));
1115      convtmp = htons(convtmp);
1116      sprintf(toybuf, "%u", convtmp);
1117      msgopt_list[count].val = strdup(toybuf);
1118      msgopt_list[count].len = strlen(toybuf);
1119      break;
1120    case DHCP_NUM8:
1121      memcpy(&convtmp, &optptr[2], sizeof(uint8_t));
1122      sprintf(toybuf, "%u", convtmp);
1123      msgopt_list[count].val = strdup(toybuf);
1124      msgopt_list[count].len = strlen(toybuf);
1125      break;
1126    case DHCP_IP:
1127      memcpy(&convtmp, &optptr[2], sizeof(uint32_t));
1128      addr.s_addr = convtmp;
1129      sprintf(toybuf, "%s", inet_ntoa(addr));
1130      msgopt_list[count].val = strdup(toybuf);
1131      msgopt_list[count].len = strlen(toybuf);
1132      break;
1133    case DHCP_STRING:
1134      sprintf(toybuf, "%.*s", optptr[1], &optptr[2]);
1135      msgopt_list[count].val = strdup(toybuf);
1136      msgopt_list[count].len = strlen(toybuf);
1137      break;
1138    case DHCP_IPLIST:
1139      optlen = optptr[1];
1140      dest = toybuf;
1141      while (optlen) {
1142        memcpy(&convtmp, &optptr[2], sizeof(uint32_t));
1143        addr.s_addr = convtmp;
1144        dest += sprintf(dest, "%s ", inet_ntoa(addr));
1145        optlen -= 4;
1146      }
1147      *(dest - 1) = '\0';
1148      msgopt_list[count].val = strdup(toybuf);
1149      msgopt_list[count].len = strlen(toybuf);
1150      break;
1151    case DHCP_STRLST: //FIXME: do smthing.
1152    case DHCP_IPPLST:
1153      break;
1154    case DHCP_STCRTS:
1155      pfx = "";
1156      dest = toybuf;
1157      options = &optptr[2];
1158      optlen = optptr[1];
1159
1160      while (optlen >= 1 + 4) {
1161        uint32_t nip = 0;
1162        int bytes;
1163        uint8_t *p_tmp;
1164        unsigned mask = *options;
1165
1166        if (mask > 32) break;
1167        optlen--;
1168        p_tmp = (void*) &nip;
1169        bytes = (mask + 7) / 8;
1170        while (--bytes >= 0) {
1171          *p_tmp++ = *options++;
1172          optlen--;
1173        }
1174        if (optlen < 4) break;
1175        dest += sprintf(dest, "%s%u.%u.%u.%u", pfx, ((uint8_t*) &nip)[0],
1176            ((uint8_t*) &nip)[1], ((uint8_t*) &nip)[2], ((uint8_t*) &nip)[3]);
1177        pfx = " ";
1178        dest += sprintf(dest, "/%u ", mask);
1179        dest += sprintf(dest, "%u.%u.%u.%u", options[0], options[1], options[2], options[3]);
1180        options += 4;
1181        optlen -= 4;
1182      }
1183      msgopt_list[count].val = strdup(toybuf);
1184      msgopt_list[count].len = strlen(toybuf);
1185      break;
1186    default: break;
1187    }
1188    optptr += optptr[1] + 2;
1189  }
1190  if ((overloaded == 1) || (overloaded == 3)) dhcpc_parseoptions(presult, optptr);
1191  if ((overloaded == 2) || (overloaded == 3)) dhcpc_parseoptions(presult, optptr);
1192  return type;
1193}
1194
1195// parses recvd messege to check that it was for us.
1196static uint8_t dhcpc_parsemsg(dhcpc_result_t *presult)
1197{
1198  if (state->pdhcp.op == DHCP_REPLY
1199      && !memcmp(state->pdhcp.chaddr, state->macaddr, 6)
1200      && !memcmp(&state->pdhcp.xid, &xid, sizeof(xid))) {
1201    memcpy(&presult->ipaddr.s_addr, &state->pdhcp.yiaddr, 4);
1202    presult->ipaddr.s_addr = ntohl(presult->ipaddr.s_addr);
1203    return get_option_msgtype(state->pdhcp.options);
1204  }
1205  return 0;
1206}
1207
1208// Sends a IP renew request.
1209static void renew(void)
1210{
1211  infomsg(infomode, "Performing a DHCP renew");
1212  switch (state->status) {
1213  case STATE_INIT:
1214    break;
1215  case STATE_BOUND:
1216    mode_raw();
1217  case STATE_RENEWING:    // FALLTHROUGH
1218  case STATE_REBINDING:   // FALLTHROUGH
1219    state->status = STATE_RENEW_REQUESTED;
1220    break;
1221  case STATE_RENEW_REQUESTED:
1222    run_script(NULL, "deconfig");
1223  case STATE_REQUESTING:           // FALLTHROUGH
1224  case STATE_RELEASED:             // FALLTHROUGH
1225    mode_raw();
1226    state->status = STATE_INIT;
1227    break;
1228  default: break;
1229  }
1230}
1231
1232// Sends a IP release request.
1233static void release(void)
1234{
1235  char buffer[sizeof("255.255.255.255\0")];
1236  struct in_addr temp_addr;
1237
1238  mode_app();
1239  // send release packet
1240  if (state->status == STATE_BOUND || state->status == STATE_RENEWING || state->status == STATE_REBINDING) {
1241    temp_addr.s_addr = htonl(server);
1242    xstrncpy(buffer, inet_ntoa(temp_addr), sizeof(buffer));
1243    temp_addr.s_addr = state->ipaddr.s_addr;
1244    infomsg( infomode, "Unicasting a release of %s to %s", inet_ntoa(temp_addr), buffer);
1245    dhcpc_sendmsg(DHCPRELEASE);
1246    run_script(NULL, "deconfig");
1247  }
1248  infomsg(infomode, "Entering released state");
1249  close(state->sockfd);
1250  state->sockfd = -1;
1251  state->mode = MODE_OFF;
1252  state->status = STATE_RELEASED;
1253}
1254
1255static void free_option_stores(void)
1256{
1257  int count, size = ARRAY_LEN(options_list);
1258  for (count = 0; count < size; count++)
1259    if (options_list[count].val) free(options_list[count].val);
1260  if (toys.optflags & FLAG_x) {
1261    for (count = 0; count < size; count++)
1262        if (msgopt_list[count].val) free(msgopt_list[count].val);
1263    free(msgopt_list);
1264  }
1265}
1266
1267void dhcp_main(void)
1268{
1269  struct timeval tv;
1270  int retval, bufflen = 0;
1271  dhcpc_result_t result;
1272  uint8_t packets = 0, retries = 0;
1273  uint32_t timeout = 0, waited = 0;
1274  fd_set rfds;
1275
1276  xid = 0;
1277  setlinebuf(stdout);
1278  dbg = dummy;
1279  if (toys.optflags & FLAG_v) dbg = xprintf;
1280  if (toys.optflags & FLAG_p) write_pid(TT.pidfile);
1281  retries = TT.retries;
1282  if (toys.optflags & FLAG_S) {
1283      openlog("UDHCPC :", LOG_PID, LOG_DAEMON);
1284      infomode |= LOG_SYSTEM;
1285  }
1286  infomsg(infomode, "dhcp started");
1287  if (toys.optflags & FLAG_O) {
1288    while (TT.req_opt) {
1289      raw_opt[raw_optcount] = (uint8_t) strtoopt(TT.req_opt->arg, 1);
1290      raw_optcount++;
1291      TT.req_opt = TT.req_opt->next;
1292    }
1293  }
1294  if (toys.optflags & FLAG_x) {
1295    while (TT.pkt_opt) {
1296      (void) strtoopt(TT.pkt_opt->arg, 0);
1297      TT.pkt_opt = TT.pkt_opt->next;
1298    }
1299  }
1300  memset(&result, 0, sizeof(dhcpc_result_t));
1301  state = (dhcpc_state_t*) xmalloc(sizeof(dhcpc_state_t));
1302  memset(state, 0, sizeof(dhcpc_state_t));
1303  state->iface = (toys.optflags & FLAG_i) ? TT.iface : "eth0";
1304
1305  if (get_interface(state->iface, &state->ifindex, NULL, state->macaddr))
1306    perror_exit("Failed to get interface %s", state->iface);
1307
1308  run_script(NULL, "deconfig");
1309  setup_signal();
1310  state->status = STATE_INIT;
1311  mode_raw();
1312  fcntl(state->sockfd, F_SETFD, FD_CLOEXEC);
1313
1314  for (;;) {
1315    FD_ZERO(&rfds);
1316    if (state->sockfd >= 0) FD_SET(state->sockfd, &rfds);
1317    FD_SET(sigfd.rd, &rfds);
1318    tv.tv_sec = timeout - waited;
1319    tv.tv_usec = 0;
1320    retval = 0;
1321
1322    int maxfd = (sigfd.rd > state->sockfd)? sigfd.rd : state->sockfd;
1323    dbg("select wait ....\n");
1324    uint32_t timestmp = time(NULL);
1325    if((retval = select(maxfd + 1, &rfds, NULL, NULL, &tv)) < 0) {
1326      if (errno == EINTR) {
1327        waited += (unsigned) time(NULL) - timestmp;
1328        continue;
1329      }
1330      perror_exit("Error in select");
1331    }
1332    if (!retval) { // Timed out
1333      if (get_interface(state->iface, &state->ifindex, NULL, state->macaddr))
1334        error_exit("Interface lost %s\n", state->iface);
1335
1336      switch (state->status) {
1337      case STATE_INIT:
1338        if (packets < retries) {
1339          if (!packets) xid = getxid();
1340          run_script(NULL, "deconfig");
1341          infomsg(infomode, "Sending discover...");
1342          dhcpc_sendmsg(DHCPDISCOVER);
1343          server = 0;
1344          timeout = TT.timeout;
1345          waited = 0;
1346          packets++;
1347          continue;
1348        }
1349lease_fail:
1350        run_script(NULL,"leasefail");
1351        if (toys.optflags & FLAG_n) {
1352          infomsg(infomode, "Lease failed. Exiting");
1353          goto ret_with_sockfd;
1354        }
1355        if (toys.optflags & FLAG_b) {
1356          infomsg(infomode, "Lease failed. Going Daemon mode");
1357          daemon(0, 0);
1358          if (toys.optflags & FLAG_p) write_pid(TT.pidfile);
1359          toys.optflags &= ~FLAG_b;
1360          toys.optflags |= FLAG_f;
1361        }
1362        timeout = TT.tryagain;
1363        waited = 0;
1364        packets = 0;
1365        continue;
1366      case STATE_REQUESTING:
1367        if (packets < retries) {
1368          memcpy(&state->ipaddr.s_addr,&state->pdhcp.yiaddr, 4);
1369          dhcpc_sendmsg(DHCPREQUEST);
1370          infomsg(infomode, "Sending select for %d.%d.%d.%d...",
1371              (result.ipaddr.s_addr >> 24) & 0xff, (result.ipaddr.s_addr >> 16) & 0xff, (result.ipaddr.s_addr >> 8) & 0xff, (result.ipaddr.s_addr) & 0xff);
1372          timeout = TT.timeout;
1373          waited = 0;
1374          packets++;
1375          continue;
1376        }
1377        mode_raw();
1378        state->status = STATE_INIT;
1379        goto lease_fail;
1380      case STATE_BOUND:
1381        state->status = STATE_RENEWING;
1382        dbg("Entering renew state\n");
1383        // FALLTHROUGH
1384      case STATE_RENEW_REQUESTED:   // FALLTHROUGH
1385      case STATE_RENEWING:
1386renew_requested:
1387        if (timeout > 60) {
1388          dhcpc_sendmsg(DHCPREQUEST);
1389          timeout >>= 1;
1390          waited = 0;
1391          continue;
1392        }
1393        dbg("Entering rebinding state\n");
1394        state->status = STATE_REBINDING;
1395        // FALLTHROUGH
1396      case STATE_REBINDING:
1397        mode_raw();
1398        if (timeout > 0) {
1399          dhcpc_sendmsg(DHCPREQUEST);
1400          timeout >>= 1;
1401          waited = 0;
1402          continue;
1403        }
1404        infomsg(infomode, "Lease lost, entering INIT state");
1405        run_script(NULL, "deconfig");
1406        state->status = STATE_INIT;
1407        timeout = 0;
1408        waited = 0;
1409        packets = 0;
1410        continue;
1411      default: break;
1412      }
1413      timeout = INT_MAX;
1414      waited = 0;
1415      continue;
1416    }
1417    if (FD_ISSET(sigfd.rd, &rfds)) { // Some Activity on RDFDs : is signal
1418      unsigned char sig;
1419      if (read(sigfd.rd, &sig, 1) != 1) {
1420        dbg("signal read failed.\n");
1421        continue;
1422      }
1423      switch (sig) {
1424      case SIGUSR1:
1425        infomsg(infomode, "Received SIGUSR1");
1426        renew();
1427        packets = 0;
1428        waited = 0;
1429        if (state->status == STATE_RENEW_REQUESTED) goto renew_requested;
1430        if (state->status == STATE_INIT) timeout = 0;
1431        continue;
1432      case SIGUSR2:
1433        infomsg(infomode, "Received SIGUSR2");
1434        release();
1435        timeout = INT_MAX;
1436        waited = 0;
1437        packets = 0;
1438        continue;
1439      case SIGTERM:
1440        infomsg(infomode, "Received SIGTERM");
1441        if (toys.optflags & FLAG_R) release();
1442        goto ret_with_sockfd;
1443      default: break;
1444      }
1445    }
1446    if (FD_ISSET(state->sockfd, &rfds)) { // Some Activity on RDFDs : is socket
1447      dbg("main sock read\n");
1448      uint8_t msgType;
1449      if (state->mode == MODE_RAW) bufflen = read_raw();
1450      if (state->mode == MODE_APP) bufflen = read_app();
1451      if (bufflen < 0) {
1452        if (state->mode == MODE_RAW) mode_raw();
1453        if (state->mode == MODE_APP) mode_app();
1454        continue;
1455      }
1456      waited += time(NULL) - timestmp;
1457      memset(&result, 0, sizeof(dhcpc_result_t));
1458      msgType = dhcpc_parsemsg(&result);
1459      if (msgType != DHCPNAK && result.ipaddr.s_addr == 0 ) continue;       // no ip for me ignore
1460      if (!msgType || !get_option_serverid(state->pdhcp.options, &result)) continue; //no server id ignore
1461      if (msgType == DHCPOFFER && server == 0) server = result.serverid.s_addr; // select the server
1462      if (result.serverid.s_addr != server) continue; // not from the server we requested ignore
1463      dhcpc_parseoptions(&result, state->pdhcp.options);
1464      get_option_lease(state->pdhcp.options, &result);
1465
1466      switch (state->status) {
1467      case STATE_INIT:
1468        if (msgType == DHCPOFFER) {
1469          state->status = STATE_REQUESTING;
1470          mode_raw();
1471          timeout = 0;
1472          waited = 0;
1473          packets = 0;
1474        }
1475        continue;
1476      case STATE_REQUESTING:         // FALLTHROUGH
1477      case STATE_RENEWING:           // FALLTHROUGH
1478      case STATE_RENEW_REQUESTED:    // FALLTHROUGH
1479      case STATE_REBINDING:
1480        if (msgType == DHCPACK) {
1481          timeout = result.lease_time / 2;
1482          run_script(&result, state->status == STATE_REQUESTING ? "bound" : "renew");
1483          state->status = STATE_BOUND;
1484          infomsg(infomode, "Lease of %d.%d.%d.%d obtained, lease time %d from server %d.%d.%d.%d",
1485              (result.ipaddr.s_addr >> 24) & 0xff, (result.ipaddr.s_addr >> 16) & 0xff, (result.ipaddr.s_addr >> 8) & 0xff, (result.ipaddr.s_addr) & 0xff,
1486              result.lease_time,
1487              (result.serverid.s_addr >> 24) & 0xff, (result.serverid.s_addr >> 16) & 0xff, (result.serverid.s_addr >> 8) & 0xff, (result.serverid.s_addr) & 0xff);
1488          if (toys.optflags & FLAG_q) {
1489            if (toys.optflags & FLAG_R) release();
1490            goto ret_with_sockfd;
1491          }
1492          toys.optflags &= ~FLAG_n;
1493          if (!(toys.optflags & FLAG_f)) {
1494            daemon(0, 0);
1495            toys.optflags |= FLAG_f;
1496            if (toys.optflags & FLAG_p) write_pid(TT.pidfile);
1497          }
1498          waited = 0;
1499          continue;
1500        } else if (msgType == DHCPNAK) {
1501          dbg("NACK received.\n");
1502          run_script(&result, "nak");
1503          if (state->status != STATE_REQUESTING) run_script(NULL, "deconfig");
1504          mode_raw();
1505          sleep(3);
1506          state->status = STATE_INIT;
1507          state->ipaddr.s_addr = 0;
1508          server = 0;
1509          timeout = 0;
1510          packets = 0;
1511          waited = 0;
1512        }
1513        continue;
1514      default: break;
1515      }
1516    }
1517  }
1518ret_with_sockfd:
1519  if (CFG_TOYBOX_FREE) {
1520    free_option_stores();
1521    if (state->sockfd > 0) close(state->sockfd);
1522    free(state);
1523  }
1524}
1525