aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorbug1 <bug1@69ca8d6d-28ef-0310-b511-8ec308f3f277>2002-08-21 10:27:58 +0000
committerbug1 <bug1@69ca8d6d-28ef-0310-b511-8ec308f3f277>2002-08-21 10:27:58 +0000
commit986ece0fad752b2f2070e330328da6e72e3b4e53 (patch)
treef5d9e4a1426f423be6220a7d722792d70cd00c1d
parent4ee8777e07f3941be0c8ef262ad98063d843ed96 (diff)
downloadbusybox-w32-986ece0fad752b2f2070e330328da6e72e3b4e53.tar.gz
busybox-w32-986ece0fad752b2f2070e330328da6e72e3b4e53.tar.bz2
busybox-w32-986ece0fad752b2f2070e330328da6e72e3b4e53.zip
New applet, udhcp client
git-svn-id: svn://busybox.net/trunk/busybox@5320 69ca8d6d-28ef-0310-b511-8ec308f3f277
Diffstat
-rw-r--r--include/applets.h3
-rw-r--r--include/usage.h14
-rw-r--r--networking/Makefile.in1
-rw-r--r--networking/config.in1
-rw-r--r--networking/udhcpc.c1571
5 files changed, 1590 insertions, 0 deletions
diff --git a/include/applets.h b/include/applets.h
index 6b8bce7e0..a1084fcc6 100644
--- a/include/applets.h
+++ b/include/applets.h
@@ -479,6 +479,9 @@
479#ifdef CONFIG_TTY 479#ifdef CONFIG_TTY
480 APPLET(tty, tty_main, _BB_DIR_USR_BIN, _BB_SUID_NEVER) 480 APPLET(tty, tty_main, _BB_DIR_USR_BIN, _BB_SUID_NEVER)
481#endif 481#endif
482#ifdef CONFIG_UDHCPC
483 APPLET(udhcpc, udhcpc_main, _BB_DIR_SBIN, _BB_SUID_NEVER)
484#endif
482#ifdef CONFIG_UMOUNT 485#ifdef CONFIG_UMOUNT
483 APPLET(umount, umount_main, _BB_DIR_BIN, _BB_SUID_NEVER) 486 APPLET(umount, umount_main, _BB_DIR_BIN, _BB_SUID_NEVER)
484#endif 487#endif
diff --git a/include/usage.h b/include/usage.h
index a232c88da..a5ae4c889 100644
--- a/include/usage.h
+++ b/include/usage.h
@@ -1905,6 +1905,20 @@
1905 "$ tty\n" \ 1905 "$ tty\n" \
1906 "/dev/tty2\n" 1906 "/dev/tty2\n"
1907 1907
1908#define udhcpc_trivial_usage \
1909 "[-fqv] [-c CLIENTID] [-H HOSTNAME] [-i INTERFACE]\n\[-p file] [-r IP] [-s script]"
1910#define udhcpc_full_usage \
1911 "\t-c,\t--clientid=CLIENTID\tClient identifier\n" \
1912 "\t-H,\t--hostname=HOSTNAME\tClient hostname\n" \
1913 "\t-f,\t--foreground\tDo not fork after getting lease\n" \
1914 "\t-i,\t--interface=INTERFACE\tInterface to use (default: eth0)\n" \
1915 "\t-n,\t--now\tExit with failure if lease cannot be immediately negotiated.\n" \
1916 "\t-p,\t--pidfile=file\tStore process ID of daemon in file\n" \
1917 "\t-q,\t--quit\tQuit after obtaining lease\n" \
1918 "\t-r,\t--request=IP\tIP address to request (default: none)\n" \
1919 "\t-s,\t--script=file\tRun file at dhcp events (default: /usr/share/udhcpc/default.script)\n" \
1920 "\t-v,\t--version\tDisplay version"
1921
1908#ifdef CONFIG_FEATURE_MOUNT_FORCE 1922#ifdef CONFIG_FEATURE_MOUNT_FORCE
1909 #define USAGE_MOUNT_FORCE(a) a 1923 #define USAGE_MOUNT_FORCE(a) a
1910#else 1924#else
diff --git a/networking/Makefile.in b/networking/Makefile.in
index be4b53b78..425b5d3d9 100644
--- a/networking/Makefile.in
+++ b/networking/Makefile.in
@@ -34,6 +34,7 @@ NETWORKING-$(CONFIG_ROUTE) += route.o
34NETWORKING-$(CONFIG_TELNET) += telnet.o 34NETWORKING-$(CONFIG_TELNET) += telnet.o
35NETWORKING-$(CONFIG_TFTP) += tftp.o 35NETWORKING-$(CONFIG_TFTP) += tftp.o
36NETWORKING-$(CONFIG_TRACEROUTE) += traceroute.o 36NETWORKING-$(CONFIG_TRACEROUTE) += traceroute.o
37NETWORKING-$(CONFIG_UDHCPC) += udhcpc.o
37NETWORKING-$(CONFIG_WGET) += wget.o 38NETWORKING-$(CONFIG_WGET) += wget.o
38 39
39libraries-y+=$(NETWORKING_DIR)$(NETWORKING_AR) 40libraries-y+=$(NETWORKING_DIR)$(NETWORKING_AR)
diff --git a/networking/config.in b/networking/config.in
index 1edc1de7e..bc11d83a7 100644
--- a/networking/config.in
+++ b/networking/config.in
@@ -46,6 +46,7 @@ if [ "$CONFIG_TRACEROUTE" = "y" ]; then
46 bool ' Enable verbose output' CONFIG_FEATURE_TRACEROUTE_VERBOSE 46 bool ' Enable verbose output' CONFIG_FEATURE_TRACEROUTE_VERBOSE
47 bool ' Enable SO_DEBUG option' CONFIG_FEATURE_TRACEROUTE_SO_DEBUG 47 bool ' Enable SO_DEBUG option' CONFIG_FEATURE_TRACEROUTE_SO_DEBUG
48fi 48fi
49bool 'udhcpc' CONFIG_UDHCPC
49bool 'wget' CONFIG_WGET 50bool 'wget' CONFIG_WGET
50if [ "$CONFIG_WGET" = "y" ]; then 51if [ "$CONFIG_WGET" = "y" ]; then
51 bool ' Enable a nifty process meter (+2k)' CONFIG_FEATURE_WGET_STATUSBAR 52 bool ' Enable a nifty process meter (+2k)' CONFIG_FEATURE_WGET_STATUSBAR
diff --git a/networking/udhcpc.c b/networking/udhcpc.c
new file mode 100644
index 000000000..f13d44d5d
--- /dev/null
+++ b/networking/udhcpc.c
@@ -0,0 +1,1571 @@
1/* dhcpd.c
2 *
3 * udhcp DHCP client
4 *
5 * Russ Dill <Russ.Dill@asu.edu> July 2001
6 *
7 * Converted to busybox by Glenn McGrath August 2002
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24#include <stdio.h>
25#include <sys/time.h>
26#include <sys/types.h>
27#include <sys/file.h>
28#include <unistd.h>
29#include <getopt.h>
30#include <stdlib.h>
31#include <sys/socket.h>
32#include <netinet/in.h>
33#include <arpa/inet.h>
34#include <signal.h>
35#include <time.h>
36#include <string.h>
37#include <sys/ioctl.h>
38#include <net/if.h>
39#include <errno.h>
40#include <netinet/ip.h>
41#include <netinet/udp.h>
42#include <sys/types.h>
43#include <sys/wait.h>
44
45#if __GLIBC__ >=2 && __GLIBC_MINOR >= 1
46#include <netpacket/packet.h>
47#include <net/ethernet.h>
48#else
49#include <asm/types.h>
50#include <linux/if_packet.h>
51#include <linux/if_ether.h>
52#endif
53#include "libbb.h"
54
55static int state;
56static unsigned long requested_ip; /* = 0 */
57static unsigned long server_addr;
58static unsigned long timeout;
59static int packet_num; /* = 0 */
60static int fd_main;
61#define DEBUG
62
63#define VERSION "0.9.7"
64
65#define LISTEN_NONE 0
66#define LISTEN_KERNEL 1
67#define LISTEN_RAW 2
68static int listen_mode;
69
70#define DEFAULT_SCRIPT "/usr/share/udhcpc/default.script"
71
72#define DHCP_END 0xFF
73#define TYPE_MASK 0x0F
74#define BROADCAST_FLAG 0x8000
75
76#define SERVER_PORT 67
77
78#define DHCP_MAGIC 0x63825363
79
80#define BOOTREQUEST 1
81#define BOOTREPLY 2
82
83#define ETH_10MB 1
84#define ETH_10MB_LEN 6
85
86#define OPTION_FIELD 0
87#define FILE_FIELD 1
88#define SNAME_FIELD 2
89
90#define INIT_SELECTING 0
91#define REQUESTING 1
92#define BOUND 2
93#define RENEWING 3
94#define REBINDING 4
95#define INIT_REBOOT 5
96#define RENEW_REQUESTED 6
97#define RELEASED 7
98
99#define CLIENT_PORT 68
100
101#define DHCPDISCOVER 1
102#define DHCPOFFER 2
103#define DHCPREQUEST 3
104#define DHCPDECLINE 4
105#define DHCPACK 5
106#define DHCPNAK 6
107#define DHCPRELEASE 7
108#define DHCPINFORM 8
109
110/* DHCP option codes (partial list) */
111#define DHCP_PADDING 0x00
112#define DHCP_SUBNET 0x01
113#define DHCP_TIME_OFFSET 0x02
114#define DHCP_ROUTER 0x03
115#define DHCP_TIME_SERVER 0x04
116#define DHCP_NAME_SERVER 0x05
117#define DHCP_DNS_SERVER 0x06
118#define DHCP_LOG_SERVER 0x07
119#define DHCP_COOKIE_SERVER 0x08
120#define DHCP_LPR_SERVER 0x09
121#define DHCP_HOST_NAME 0x0c
122#define DHCP_BOOT_SIZE 0x0d
123#define DHCP_DOMAIN_NAME 0x0f
124#define DHCP_SWAP_SERVER 0x10
125#define DHCP_ROOT_PATH 0x11
126#define DHCP_IP_TTL 0x17
127#define DHCP_MTU 0x1a
128#define DHCP_BROADCAST 0x1c
129#define DHCP_NTP_SERVER 0x2a
130#define DHCP_WINS_SERVER 0x2c
131#define DHCP_REQUESTED_IP 0x32
132#define DHCP_LEASE_TIME 0x33
133#define DHCP_OPTION_OVER 0x34
134#define DHCP_MESSAGE_TYPE 0x35
135#define DHCP_SERVER_ID 0x36
136#define DHCP_PARAM_REQ 0x37
137#define DHCP_MESSAGE 0x38
138#define DHCP_MAX_SIZE 0x39
139#define DHCP_T1 0x3a
140#define DHCP_T2 0x3b
141#define DHCP_VENDOR 0x3c
142#define DHCP_CLIENT_ID 0x3d
143
144/* miscellaneous defines */
145#define MAC_BCAST_ADDR (unsigned char *) "\xff\xff\xff\xff\xff\xff"
146#define OPT_CODE 0
147#define OPT_LEN 1
148#define OPT_DATA 2
149
150enum {
151 OPTION_IP=1,
152 OPTION_IP_PAIR,
153 OPTION_STRING,
154 OPTION_BOOLEAN,
155 OPTION_U8,
156 OPTION_U16,
157 OPTION_S16,
158 OPTION_U32,
159 OPTION_S32
160};
161
162#define OPTION_REQ 0x10 /* have the client request this option */
163#define OPTION_LIST 0x20 /* There can be a list of 1 or more of these */
164
165#ifdef SYSLOG
166# define LOG(level, str, args...) do { printf(str, ## args); \
167 printf("\n"); \
168 syslog(level, str, ## args); } while(0)
169# define OPEN_LOG(name) openlog(name, 0, 0)
170#define CLOSE_LOG() closelog()
171#else
172# define LOG_EMERG "EMERGENCY!"
173# define LOG_ALERT "ALERT!"
174# define LOG_CRIT "critical!"
175# define LOG_WARNING "warning"
176# define LOG_ERR "error"
177# define LOG_INFO "info"
178# define LOG_DEBUG "debug"
179# define LOG(level, str, args...) do { printf("%s, ", level); printf(str, ## args); printf("\n"); } while(0)
180# define OPEN_LOG(name) do {;} while(0)
181#define CLOSE_LOG() do {;} while(0)
182#endif
183
184#ifdef DEBUG
185# undef DEBUG
186# define DEBUG(level, str, args...) LOG(level, str, ## args)
187# define DEBUGGING
188#else
189# define DEBUG(level, str, args...) do {;} while(0)
190#endif
191
192struct client_config_t {
193 char foreground; /* Do not fork */
194 char quit_after_lease; /* Quit after obtaining lease */
195 char abort_if_no_lease; /* Abort if no lease */
196 char *interface; /* The name of the interface to use */
197 char *pidfile; /* Optionally store the process ID */
198 char *script; /* User script to run at dhcp events */
199 unsigned char *clientid; /* Optional client id to use */
200 unsigned char *hostname; /* Optional hostname to use */
201 int ifindex; /* Index number of the interface to use */
202 unsigned char arp[6]; /* Our arp address */
203};
204extern struct client_config_t client_config;
205
206struct dhcpMessage {
207 u_int8_t op;
208 u_int8_t htype;
209 u_int8_t hlen;
210 u_int8_t hops;
211 u_int32_t xid;
212 u_int16_t secs;
213 u_int16_t flags;
214 u_int32_t ciaddr;
215 u_int32_t yiaddr;
216 u_int32_t siaddr;
217 u_int32_t giaddr;
218 u_int8_t chaddr[16];
219 u_int8_t sname[64];
220 u_int8_t file[128];
221 u_int32_t cookie;
222 u_int8_t options[308]; /* 312 - cookie */
223};
224
225struct client_config_t client_config = {
226 /* Default options. */
227 abort_if_no_lease: 0,
228 foreground: 0,
229 quit_after_lease: 0,
230 interface: "eth0",
231 pidfile: NULL,
232 script: DEFAULT_SCRIPT,
233 clientid: NULL,
234 hostname: NULL,
235 ifindex: 0,
236 arp: "\0\0\0\0\0\0", /* appease gcc-3.0 */
237};
238
239struct dhcp_option {
240 char name[10];
241 char flags;
242 unsigned char code;
243};
244
245struct udp_dhcp_packet {
246 struct iphdr ip;
247 struct udphdr udp;
248 struct dhcpMessage data;
249};
250
251struct dhcp_option options[] = {
252 /* name[10] flags code */
253 {"subnet", OPTION_IP | OPTION_REQ, 0x01},
254 {"timezone", OPTION_S32, 0x02},
255 {"router", OPTION_IP | OPTION_LIST | OPTION_REQ, 0x03},
256 {"timesvr", OPTION_IP | OPTION_LIST, 0x04},
257 {"namesvr", OPTION_IP | OPTION_LIST, 0x05},
258 {"dns", OPTION_IP | OPTION_LIST | OPTION_REQ, 0x06},
259 {"logsvr", OPTION_IP | OPTION_LIST, 0x07},
260 {"cookiesvr", OPTION_IP | OPTION_LIST, 0x08},
261 {"lprsvr", OPTION_IP | OPTION_LIST, 0x09},
262 {"hostname", OPTION_STRING | OPTION_REQ, 0x0c},
263 {"bootsize", OPTION_U16, 0x0d},
264 {"domain", OPTION_STRING | OPTION_REQ, 0x0f},
265 {"swapsvr", OPTION_IP, 0x10},
266 {"rootpath", OPTION_STRING, 0x11},
267 {"ipttl", OPTION_U8, 0x17},
268 {"mtu", OPTION_U16, 0x1a},
269 {"broadcast", OPTION_IP | OPTION_REQ, 0x1c},
270 {"ntpsrv", OPTION_IP | OPTION_LIST, 0x2a},
271 {"wins", OPTION_IP | OPTION_LIST, 0x2c},
272 {"requestip", OPTION_IP, 0x32},
273 {"lease", OPTION_U32, 0x33},
274 {"dhcptype", OPTION_U8, 0x35},
275 {"serverid", OPTION_IP, 0x36},
276 {"message", OPTION_STRING, 0x38},
277 {"tftp", OPTION_STRING, 0x42},
278 {"bootfile", OPTION_STRING, 0x43},
279 {"", 0x00, 0x00}
280};
281
282/* Lengths of the different option types */
283int option_lengths[] = {
284 [OPTION_IP] = 4,
285 [OPTION_IP_PAIR] = 8,
286 [OPTION_BOOLEAN] = 1,
287 [OPTION_STRING] = 1,
288 [OPTION_U8] = 1,
289 [OPTION_U16] = 2,
290 [OPTION_S16] = 2,
291 [OPTION_U32] = 4,
292 [OPTION_S32] = 4
293};
294
295/* get a rough idea of how long an option will be (rounding up...) */
296static int max_option_length[] = {
297 [OPTION_IP] = sizeof("255.255.255.255 "),
298 [OPTION_IP_PAIR] = sizeof("255.255.255.255 ") * 2,
299 [OPTION_STRING] = 1,
300 [OPTION_BOOLEAN] = sizeof("yes "),
301 [OPTION_U8] = sizeof("255 "),
302 [OPTION_U16] = sizeof("65535 "),
303 [OPTION_S16] = sizeof("-32768 "),
304 [OPTION_U32] = sizeof("4294967295 "),
305 [OPTION_S32] = sizeof("-2147483684 "),
306};
307
308static void print_usage(void)
309{
310 printf(
311"Usage: udhcpcd [OPTIONS]\n\n"
312" -c, --clientid=CLIENTID Client identifier\n"
313" -H, --hostname=HOSTNAME Client hostname\n"
314" -f, --foreground Do not fork after getting lease\n"
315" -i, --interface=INTERFACE Interface to use (default: eth0)\n"
316" -n, --now Exit with failure if lease cannot be\n"
317" immediately negotiated.\n"
318" -p, --pidfile=file Store process ID of daemon in file\n"
319" -q, --quit Quit after obtaining lease\n"
320" -r, --request=IP IP address to request (default: none)\n"
321" -s, --script=file Run file at dhcp events (default:\n"
322" " DEFAULT_SCRIPT ")\n"
323" -v, --version Display version\n"
324 );
325}
326/* return the position of the 'end' option (no bounds checking) */
327int end_option(unsigned char *optionptr)
328{
329 int i = 0;
330
331 while (optionptr[i] != DHCP_END) {
332 if (optionptr[i] == DHCP_PADDING) i++;
333 else i += optionptr[i + OPT_LEN] + 2;
334 }
335 return i;
336}
337
338/* add an option string to the options (an option string contains an option code,
339 * length, then data) */
340int add_option_string(unsigned char *optionptr, unsigned char *string)
341{
342 int end = end_option(optionptr);
343
344 /* end position + string length + option code/length + end option */
345 if (end + string[OPT_LEN] + 2 + 1 >= 308) {
346 LOG(LOG_ERR, "Option 0x%02x did not fit into the packet!", string[OPT_CODE]);
347 return 0;
348 }
349 DEBUG(LOG_INFO, "adding option 0x%02x", string[OPT_CODE]);
350 memcpy(optionptr + end, string, string[OPT_LEN] + 2);
351 optionptr[end + string[OPT_LEN] + 2] = DHCP_END;
352 return string[OPT_LEN] + 2;
353}
354
355/* add a one to four byte option to a packet */
356int add_simple_option(unsigned char *optionptr, unsigned char code, u_int32_t data)
357{
358 char length = 0;
359 int i;
360 unsigned char option[2 + 4];
361 unsigned char *u8;
362 u_int16_t *u16;
363 u_int32_t *u32;
364 u_int32_t aligned;
365 u8 = (unsigned char *) &aligned;
366 u16 = (u_int16_t *) &aligned;
367 u32 = &aligned;
368
369 for (i = 0; options[i].code; i++)
370 if (options[i].code == code) {
371 length = option_lengths[options[i].flags & TYPE_MASK];
372 }
373
374 if (!length) {
375 DEBUG(LOG_ERR, "Could not add option 0x%02x", code);
376 return 0;
377 }
378
379 option[OPT_CODE] = code;
380 option[OPT_LEN] = length;
381
382 switch (length) {
383 case 1: *u8 = data; break;
384 case 2: *u16 = data; break;
385 case 4: *u32 = data; break;
386 }
387
388 memcpy(option + 2, &aligned, length);
389 return add_option_string(optionptr, option);
390}
391#if 0
392void init_header(struct dhcpMessage *packet, char type)
393{
394 memset(packet, 0, sizeof(struct dhcpMessage));
395 switch (type) {
396 case DHCPDISCOVER:
397 case DHCPREQUEST:
398 case DHCPRELEASE:
399 case DHCPINFORM:
400 packet->op = BOOTREQUEST;
401 break;
402 case DHCPOFFER:
403 case DHCPACK:
404 case DHCPNAK:
405 packet->op = BOOTREPLY;
406 }
407 packet->htype = ETH_10MB;
408 packet->hlen = ETH_10MB_LEN;
409 packet->cookie = htonl(DHCP_MAGIC);
410 packet->options[0] = DHCP_END;
411 add_simple_option(packet->options, DHCP_MESSAGE_TYPE, type);
412}
413#endif
414u_int16_t checksum(void *addr, int count)
415{
416 /* Compute Internet Checksum for "count" bytes
417 * beginning at location "addr".
418 */
419 register int32_t sum = 0;
420 u_int16_t *source = (u_int16_t *) addr;
421
422 while( count > 1 ) {
423 /* This is the inner loop */
424 sum += *source++;
425 count -= 2;
426 }
427
428 /* Add left-over byte, if any */
429 if( count > 0 )
430 sum += * (unsigned char *) source;
431
432 /* Fold 32-bit sum to 16 bits */
433 while (sum>>16)
434 sum = (sum & 0xffff) + (sum >> 16);
435
436 return ~sum;
437}
438
439/* Constuct a ip/udp header for a packet, and specify the source and dest hardware address */
440int raw_packet(struct dhcpMessage *payload, u_int32_t source_ip, int source_port,
441 u_int32_t dest_ip, int dest_port, unsigned char *dest_arp, int ifindex)
442{
443 int l_fd;
444 int result;
445 struct sockaddr_ll dest;
446 struct udp_dhcp_packet packet;
447
448 if ((l_fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
449 DEBUG(LOG_ERR, "socket call failed: %s", sys_errlist[errno]);
450 return -1;
451 }
452
453 memset(&dest, 0, sizeof(dest));
454 memset(&packet, 0, sizeof(packet));
455
456 dest.sll_family = AF_PACKET;
457 dest.sll_protocol = htons(ETH_P_IP);
458 dest.sll_ifindex = ifindex;
459 dest.sll_halen = 6;
460 memcpy(dest.sll_addr, dest_arp, 6);
461 if (bind(l_fd, (struct sockaddr *)&dest, sizeof(struct sockaddr_ll)) < 0) {
462 DEBUG(LOG_ERR, "bind call failed: %s", sys_errlist[errno]);
463 close(l_fd);
464 return -1;
465 }
466
467 packet.ip.protocol = IPPROTO_UDP;
468 packet.ip.saddr = source_ip;
469 packet.ip.daddr = dest_ip;
470 packet.udp.source = htons(source_port);
471 packet.udp.dest = htons(dest_port);
472 packet.udp.len = htons(sizeof(packet.udp) + sizeof(struct dhcpMessage)); /* cheat on the psuedo-header */
473 packet.ip.tot_len = packet.udp.len;
474 memcpy(&(packet.data), payload, sizeof(struct dhcpMessage));
475 packet.udp.check = checksum(&packet, sizeof(struct udp_dhcp_packet));
476
477 packet.ip.tot_len = htons(sizeof(struct udp_dhcp_packet));
478 packet.ip.ihl = sizeof(packet.ip) >> 2;
479 packet.ip.version = IPVERSION;
480 packet.ip.ttl = IPDEFTTL;
481 packet.ip.check = checksum(&(packet.ip), sizeof(packet.ip));
482
483 result = sendto(l_fd, &packet, sizeof(struct udp_dhcp_packet), 0, (struct sockaddr *) &dest, sizeof(dest));
484 if (result <= 0) {
485 DEBUG(LOG_ERR, "write on socket failed: %s", sys_errlist[errno]);
486 }
487 close(l_fd);
488 return result;
489}
490
491/* Let the kernel do all the work for packet generation */
492int kernel_packet(struct dhcpMessage *payload, u_int32_t source_ip, int source_port,
493 u_int32_t dest_ip, int dest_port)
494{
495 int n = 1;
496 int l_fd, result;
497 struct sockaddr_in client;
498
499 if ((l_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
500 return -1;
501
502 if (setsockopt(l_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &n, sizeof(n)) == -1)
503 return -1;
504
505 memset(&client, 0, sizeof(client));
506 client.sin_family = AF_INET;
507 client.sin_port = htons(source_port);
508 client.sin_addr.s_addr = source_ip;
509
510 if (bind(l_fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1)
511 return -1;
512
513 memset(&client, 0, sizeof(client));
514 client.sin_family = AF_INET;
515 client.sin_port = htons(dest_port);
516 client.sin_addr.s_addr = dest_ip;
517
518 if (connect(l_fd, (struct sockaddr *)&client, sizeof(struct sockaddr)) == -1)
519 return -1;
520
521 result = write(l_fd, payload, sizeof(struct dhcpMessage));
522 close(l_fd);
523 return result;
524}
525
526/* initialize a packet with the proper defaults */
527static void init_packet(struct dhcpMessage *packet, char type)
528{
529 struct vendor {
530 char vendor, length;
531 char str[sizeof("udhcp "VERSION)];
532 } vendor_id = { DHCP_VENDOR, sizeof("udhcp "VERSION) - 1, "udhcp "VERSION};
533
534// init_header(packet, type);
535 memset(packet, 0, sizeof(struct dhcpMessage));
536 switch (type) {
537 case DHCPDISCOVER:
538 case DHCPREQUEST:
539 case DHCPRELEASE:
540 case DHCPINFORM:
541 packet->op = BOOTREQUEST;
542 break;
543 case DHCPOFFER:
544 case DHCPACK:
545 case DHCPNAK:
546 packet->op = BOOTREPLY;
547 }
548 packet->htype = ETH_10MB;
549 packet->hlen = ETH_10MB_LEN;
550 packet->cookie = htonl(DHCP_MAGIC);
551 packet->options[0] = DHCP_END;
552 add_simple_option(packet->options, DHCP_MESSAGE_TYPE, type);
553
554 memcpy(packet->chaddr, client_config.arp, 6);
555 add_option_string(packet->options, client_config.clientid);
556 if (client_config.hostname) add_option_string(packet->options, client_config.hostname);
557 add_option_string(packet->options, (unsigned char *) &vendor_id);
558}
559
560
561/* Add a paramater request list for stubborn DHCP servers. Pull the data
562 * from the struct in options.c. Don't do bounds checking here because it
563 * goes towards the head of the packet. */
564static void add_requests(struct dhcpMessage *packet)
565{
566 int end = end_option(packet->options);
567 int i, len = 0;
568
569 packet->options[end + OPT_CODE] = DHCP_PARAM_REQ;
570 for (i = 0; options[i].code; i++)
571 if (options[i].flags & OPTION_REQ)
572 packet->options[end + OPT_DATA + len++] = options[i].code;
573 packet->options[end + OPT_LEN] = len;
574 packet->options[end + OPT_DATA + len] = DHCP_END;
575
576}
577
578/* Broadcast a DHCP discover packet to the network, with an optionally requested IP */
579int send_discover(unsigned long xid, unsigned long requested)
580{
581 struct dhcpMessage packet;
582
583 init_packet(&packet, DHCPDISCOVER);
584 packet.xid = xid;
585 if (requested)
586 add_simple_option(packet.options, DHCP_REQUESTED_IP, requested);
587
588 add_requests(&packet);
589 LOG(LOG_DEBUG, "Sending discover...");
590 return raw_packet(&packet, INADDR_ANY, CLIENT_PORT, INADDR_BROADCAST,
591 SERVER_PORT, MAC_BCAST_ADDR, client_config.ifindex);
592}
593
594/* Broadcasts a DHCP request message */
595int send_selecting(unsigned long xid, unsigned long server, unsigned long requested)
596{
597 struct dhcpMessage packet;
598 struct in_addr addr;
599
600 init_packet(&packet, DHCPREQUEST);
601 packet.xid = xid;
602
603 add_simple_option(packet.options, DHCP_REQUESTED_IP, requested);
604 add_simple_option(packet.options, DHCP_SERVER_ID, server);
605
606 add_requests(&packet);
607 addr.s_addr = requested;
608 LOG(LOG_DEBUG, "Sending select for %s...", inet_ntoa(addr));
609 return raw_packet(&packet, INADDR_ANY, CLIENT_PORT, INADDR_BROADCAST,
610 SERVER_PORT, MAC_BCAST_ADDR, client_config.ifindex);
611}
612
613
614/* Unicasts or broadcasts a DHCP renew message */
615int send_renew(unsigned long xid, unsigned long server, unsigned long ciaddr)
616{
617 struct dhcpMessage packet;
618 int ret = 0;
619
620 init_packet(&packet, DHCPREQUEST);
621 packet.xid = xid;
622 packet.ciaddr = ciaddr;
623
624 add_requests(&packet);
625 LOG(LOG_DEBUG, "Sending renew...");
626 if (server)
627 ret = kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
628 else ret = raw_packet(&packet, INADDR_ANY, CLIENT_PORT, INADDR_BROADCAST,
629 SERVER_PORT, MAC_BCAST_ADDR, client_config.ifindex);
630 return ret;
631}
632
633/* Create a random xid */
634unsigned long random_xid(void)
635{
636 static int initialized;
637 if (!initialized) {
638 srand(time(0));
639 initialized++;
640 }
641 return rand();
642}
643#if 0
644/* Unicasts a DHCP release message */
645int send_release(unsigned long server, unsigned long ciaddr)
646{
647 struct dhcpMessage packet;
648
649 init_packet(&packet, DHCPRELEASE);
650 packet.xid = random_xid();
651 packet.ciaddr = ciaddr;
652
653 add_simple_option(packet.options, DHCP_REQUESTED_IP, ciaddr);
654 add_simple_option(packet.options, DHCP_SERVER_ID, server);
655
656 LOG(LOG_DEBUG, "Sending release...");
657 return kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
658}
659#endif
660
661/* just a little helper */
662static void change_mode(int new_mode)
663{
664 DEBUG(LOG_INFO, "entering %s listen mode",
665 new_mode ? (new_mode == 1 ? "kernel" : "raw") : "none");
666 close(fd_main);
667 fd_main = -1;
668 listen_mode = new_mode;
669}
670
671
672/* SIGUSR1 handler (renew) */
673static void renew_requested(int sig)
674{
675 sig = 0;
676 LOG(LOG_INFO, "Received SIGUSR1");
677 if (state == BOUND || state == RENEWING || state == REBINDING ||
678 state == RELEASED) {
679 change_mode(LISTEN_KERNEL);
680 packet_num = 0;
681 state = RENEW_REQUESTED;
682 }
683
684 if (state == RELEASED) {
685 change_mode(LISTEN_RAW);
686 state = INIT_SELECTING;
687 }
688
689 /* Kill any timeouts because the user wants this to hurry along */
690 timeout = 0;
691}
692
693/* get an option with bounds checking (warning, not aligned). */
694unsigned char *get_option(struct dhcpMessage *packet, int code)
695{
696 int i, length;
697 unsigned char *optionptr;
698 int over = 0, done = 0, curr = OPTION_FIELD;
699
700 optionptr = packet->options;
701 i = 0;
702 length = 308;
703 while (!done) {
704 if (i >= length) {
705 LOG(LOG_WARNING, "bogus packet, option fields too long.");
706 return NULL;
707 }
708 if (optionptr[i + OPT_CODE] == code) {
709 if (i + 1 + optionptr[i + OPT_LEN] >= length) {
710 LOG(LOG_WARNING, "bogus packet, option fields too long.");
711 return NULL;
712 }
713 return optionptr + i + 2;
714 }
715 switch (optionptr[i + OPT_CODE]) {
716 case DHCP_PADDING:
717 i++;
718 break;
719 case DHCP_OPTION_OVER:
720 if (i + 1 + optionptr[i + OPT_LEN] >= length) {
721 LOG(LOG_WARNING, "bogus packet, option fields too long.");
722 return NULL;
723 }
724 over = optionptr[i + 3];
725 i += optionptr[OPT_LEN] + 2;
726 break;
727 case DHCP_END:
728 if (curr == OPTION_FIELD && over & FILE_FIELD) {
729 optionptr = packet->file;
730 i = 0;
731 length = 128;
732 curr = FILE_FIELD;
733 } else if (curr == FILE_FIELD && over & SNAME_FIELD) {
734 optionptr = packet->sname;
735 i = 0;
736 length = 64;
737 curr = SNAME_FIELD;
738 } else done = 1;
739 break;
740 default:
741 i += optionptr[OPT_LEN + i] + 2;
742 }
743 }
744 return NULL;
745}
746#if 0
747static int upper_length(int length, struct dhcp_option *option)
748{
749 return max_option_length[option->flags & TYPE_MASK] *
750 (length / option_lengths[option->flags & TYPE_MASK]);
751}
752#endif
753
754static int sprintip(char *dest, char *pre, unsigned char *ip) {
755 return sprintf(dest, "%s%d.%d.%d.%d ", pre, ip[0], ip[1], ip[2], ip[3]);
756}
757
758
759/* Fill dest with the text of option 'option'. */
760static void fill_options(char *dest, unsigned char *option, struct dhcp_option *type_p)
761{
762 int type, optlen;
763 u_int16_t val_u16;
764 int16_t val_s16;
765 u_int32_t val_u32;
766 int32_t val_s32;
767 int len = option[OPT_LEN - 2];
768
769 dest += sprintf(dest, "%s=", type_p->name);
770
771 type = type_p->flags & TYPE_MASK;
772 optlen = option_lengths[type];
773 for(;;) {
774 switch (type) {
775 case OPTION_IP_PAIR:
776 dest += sprintip(dest, "", option);
777 *(dest++) = '/';
778 option += 4;
779 optlen = 4;
780 case OPTION_IP: /* Works regardless of host byte order. */
781 dest += sprintip(dest, "", option);
782 break;
783 case OPTION_BOOLEAN:
784 dest += sprintf(dest, *option ? "yes " : "no ");
785 break;
786 case OPTION_U8:
787 dest += sprintf(dest, "%u ", *option);
788 break;
789 case OPTION_U16:
790 memcpy(&val_u16, option, 2);
791 dest += sprintf(dest, "%u ", ntohs(val_u16));
792 break;
793 case OPTION_S16:
794 memcpy(&val_s16, option, 2);
795 dest += sprintf(dest, "%d ", ntohs(val_s16));
796 break;
797 case OPTION_U32:
798 memcpy(&val_u32, option, 4);
799 dest += sprintf(dest, "%lu ", (unsigned long) ntohl(val_u32));
800 break;
801 case OPTION_S32:
802 memcpy(&val_s32, option, 4);
803 dest += sprintf(dest, "%ld ", (long) ntohl(val_s32));
804 break;
805 case OPTION_STRING:
806 memcpy(dest, option, len);
807 dest[len] = '\0';
808 return; /* Short circuit this case */
809 }
810 option += optlen;
811 len -= optlen;
812 if (len <= 0) break;
813 }
814}
815
816static char *find_env(const char *prefix, char *defaultstr)
817{
818 extern char **environ;
819 char **ptr;
820 const int len = strlen(prefix);
821
822 for (ptr = environ; *ptr != NULL; ptr++) {
823 if (strncmp(prefix, *ptr, len) == 0)
824 return *ptr;
825 }
826 return defaultstr;
827}
828
829/* put all the paramaters into an environment */
830static char **fill_envp(struct dhcpMessage *packet)
831{
832 /* supported options are easily added here */
833 int num_options = 0;
834 int i, j;
835 char **envp;
836 unsigned char *temp;
837 char over = 0;
838
839 if (packet == NULL)
840 num_options = 0;
841 else {
842 for (i = 0; options[i].code; i++)
843 if (get_option(packet, options[i].code))
844 num_options++;
845 if (packet->siaddr) num_options++;
846 if ((temp = get_option(packet, DHCP_OPTION_OVER)))
847 over = *temp;
848 if (!(over & FILE_FIELD) && packet->file[0]) num_options++;
849 if (!(over & SNAME_FIELD) && packet->sname[0]) num_options++;
850 }
851
852 envp = xmalloc((num_options + 5) * sizeof(char *));
853 envp[0] = xmalloc(sizeof("interface=") + strlen(client_config.interface));
854 sprintf(envp[0], "interface=%s", client_config.interface);
855 envp[1] = find_env("PATH", "PATH=/bin:/usr/bin:/sbin:/usr/sbin");
856 envp[2] = find_env("HOME", "HOME=/");
857
858 if (packet == NULL) {
859 envp[3] = NULL;
860 return envp;
861 }
862
863 envp[3] = xmalloc(sizeof("ip=255.255.255.255"));
864 sprintip(envp[3], "ip=", (unsigned char *) &packet->yiaddr);
865 for (i = 0, j = 4; options[i].code; i++) {
866 if ((temp = get_option(packet, options[i].code))) {
867 envp[j] = xmalloc(max_option_length[(&options[i])->flags & TYPE_MASK] * (temp[OPT_LEN - 2] / option_lengths[(&options[i])->flags & TYPE_MASK]) + strlen((&options[i])->name) + 2);
868// envp[j] = xmalloc(upper_length(temp[OPT_LEN - 2], &options[i]) + strlen(options[i].name) + 2);
869 fill_options(envp[j], temp, &options[i]);
870 j++;
871 }
872 }
873 if (packet->siaddr) {
874 envp[j] = xmalloc(sizeof("siaddr=255.255.255.255"));
875 sprintip(envp[j++], "siaddr=", (unsigned char *) &packet->yiaddr);
876 }
877 if (!(over & FILE_FIELD) && packet->file[0]) {
878 /* watch out for invalid packets */
879 packet->file[sizeof(packet->file) - 1] = '\0';
880 envp[j] = xmalloc(sizeof("boot_file=") + strlen(packet->file));
881 sprintf(envp[j++], "boot_file=%s", packet->file);
882 }
883 if (!(over & SNAME_FIELD) && packet->sname[0]) {
884 /* watch out for invalid packets */
885 packet->sname[sizeof(packet->sname) - 1] = '\0';
886 envp[j] = xmalloc(sizeof("sname=") + strlen(packet->sname));
887 sprintf(envp[j++], "sname=%s", packet->sname);
888 }
889 envp[j] = NULL;
890 return envp;
891}
892
893/* Call a script with a par file and env vars */
894void run_script(struct dhcpMessage *packet, const char *name)
895{
896 int pid;
897 char **envp;
898
899 if (client_config.script == NULL)
900 return;
901
902 /* call script */
903 pid = fork();
904 if (pid) {
905 waitpid(pid, NULL, 0);
906 return;
907 } else if (pid == 0) {
908 envp = fill_envp(packet);
909
910 /* close fd's? */
911
912 /* exec script */
913 DEBUG(LOG_INFO, "execle'ing %s", client_config.script);
914 execle(client_config.script, client_config.script,
915 name, NULL, envp);
916 LOG(LOG_ERR, "script %s failed: %s",
917 client_config.script, sys_errlist[errno]);
918 exit(1);
919 }
920}
921
922/* SIGUSR2 handler (release) */
923static void release_requested(int sig)
924{
925 sig = 0;
926 LOG(LOG_INFO, "Received SIGUSR2");
927 /* send release packet */
928 if (state == BOUND || state == RENEWING || state == REBINDING) {
929 struct dhcpMessage packet;
930
931 init_packet(&packet, DHCPRELEASE);
932 packet.xid = random_xid();
933 packet.ciaddr = requested_ip;
934
935 add_simple_option(packet.options, DHCP_REQUESTED_IP, requested_ip);
936 add_simple_option(packet.options, DHCP_SERVER_ID, server_addr);
937
938 LOG(LOG_DEBUG, "Sending release...");
939 kernel_packet(&packet, requested_ip, CLIENT_PORT, server_addr, SERVER_PORT);
940 run_script(NULL, "deconfig");
941 }
942
943 change_mode(LISTEN_NONE);
944 state = RELEASED;
945 timeout = 0x7fffffff;
946}
947
948
949int pidfile_acquire(char *pidfile)
950{
951 int pid_fd;
952 if (pidfile == NULL) return -1;
953
954 pid_fd = open(pidfile, O_CREAT | O_WRONLY, 0644);
955 if (pid_fd < 0) {
956 LOG(LOG_ERR, "Unable to open pidfile %s: %s\n",
957 pidfile, strerror(errno));
958 } else {
959 lockf(pid_fd, F_LOCK, 0);
960 }
961
962 return pid_fd;
963}
964
965
966void pidfile_write_release(int pid_fd)
967{
968 FILE *out;
969
970 if (pid_fd < 0) return;
971
972 if ((out = fdopen(pid_fd, "w")) != NULL) {
973 fprintf(out, "%d\n", getpid());
974 fclose(out);
975 }
976 lockf(pid_fd, F_UNLCK, 0);
977 close(pid_fd);
978}
979
980
981void pidfile_delete(char *pidfile)
982{
983 if (pidfile) unlink(pidfile);
984}
985
986/* Exit and cleanup */
987static void exit_client(int retval)
988{
989 pidfile_delete(client_config.pidfile);
990 CLOSE_LOG();
991 exit(retval);
992}
993
994
995/* SIGTERM handler */
996static void terminate(int sig)
997{
998 sig = 0;
999 LOG(LOG_INFO, "Received SIGTERM");
1000 exit_client(0);
1001}
1002
1003
1004static void background(void)
1005{
1006 int pid_fd;
1007 if (client_config.quit_after_lease) {
1008 exit_client(0);
1009 } else if (!client_config.foreground) {
1010 pid_fd = pidfile_acquire(client_config.pidfile); /* hold lock during fork. */
1011 if (daemon(0, 0) == -1) {
1012 perror("fork");
1013 exit_client(1);
1014 }
1015 client_config.foreground = 1; /* Do not fork again. */
1016 pidfile_write_release(pid_fd);
1017 }
1018}
1019
1020int read_interface(char *interface, int *ifindex, u_int32_t *addr, unsigned char *arp)
1021{
1022 int l_fd;
1023 struct ifreq ifr;
1024 struct sockaddr_in *s_in;
1025
1026 memset(&ifr, 0, sizeof(struct ifreq));
1027 if((l_fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) >= 0) {
1028 ifr.ifr_addr.sa_family = AF_INET;
1029 strcpy(ifr.ifr_name, interface);
1030
1031 if (addr) {
1032 if (ioctl(l_fd, SIOCGIFADDR, &ifr) == 0) {
1033 s_in = (struct sockaddr_in *) &ifr.ifr_addr;
1034 *addr = s_in->sin_addr.s_addr;
1035 DEBUG(LOG_INFO, "%s (our ip) = %s", ifr.ifr_name, inet_ntoa(s_in->sin_addr));
1036 } else {
1037 LOG(LOG_ERR, "SIOCGIFADDR failed!: %s", sys_errlist[errno]);
1038 return -1;
1039 }
1040 }
1041
1042 if (ioctl(l_fd, SIOCGIFINDEX, &ifr) == 0) {
1043 DEBUG(LOG_INFO, "adapter index %d", ifr.ifr_ifindex);
1044 *ifindex = ifr.ifr_ifindex;
1045 } else {
1046 LOG(LOG_ERR, "SIOCGIFINDEX failed!: %s", sys_errlist[errno]);
1047 return -1;
1048 }
1049 if (ioctl(l_fd, SIOCGIFHWADDR, &ifr) == 0) {
1050 memcpy(arp, ifr.ifr_hwaddr.sa_data, 6);
1051 DEBUG(LOG_INFO, "adapter hardware address %02x:%02x:%02x:%02x:%02x:%02x",
1052 arp[0], arp[1], arp[2], arp[3], arp[4], arp[5]);
1053 } else {
1054 LOG(LOG_ERR, "SIOCGIFHWADDR failed!: %s", sys_errlist[errno]);
1055 return -1;
1056 }
1057 } else {
1058 LOG(LOG_ERR, "socket failed!: %s", sys_errlist[errno]);
1059 return -1;
1060 }
1061 close(l_fd);
1062 return 0;
1063}
1064
1065
1066int listen_socket(unsigned int ip, int port, char *inf)
1067{
1068 struct ifreq interface;
1069 int l_fd;
1070 struct sockaddr_in addr;
1071 int n = 1;
1072
1073 DEBUG(LOG_INFO, "Opening listen socket on 0x%08x:%d %s\n", ip, port, inf);
1074 if ((l_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
1075 DEBUG(LOG_ERR, "socket call failed: %s", sys_errlist[errno]);
1076 return -1;
1077 }
1078
1079 memset(&addr, 0, sizeof(addr));
1080 addr.sin_family = AF_INET;
1081 addr.sin_port = htons(port);
1082 addr.sin_addr.s_addr = ip;
1083
1084 if (setsockopt(l_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &n, sizeof(n)) == -1) {
1085 close(l_fd);
1086 return -1;
1087 }
1088 if (setsockopt(l_fd, SOL_SOCKET, SO_BROADCAST, (char *) &n, sizeof(n)) == -1) {
1089 close(l_fd);
1090 return -1;
1091 }
1092
1093 strncpy(interface.ifr_ifrn.ifrn_name, inf, IFNAMSIZ);
1094 if (setsockopt(l_fd, SOL_SOCKET, SO_BINDTODEVICE,(char *)&interface, sizeof(interface)) < 0) {
1095 close(l_fd);
1096 return -1;
1097 }
1098
1099 if (bind(l_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) == -1) {
1100 close(l_fd);
1101 return -1;
1102 }
1103
1104 return l_fd;
1105}
1106
1107
1108int raw_socket(int ifindex)
1109{
1110 int l_fd;
1111 struct sockaddr_ll sock;
1112
1113 DEBUG(LOG_INFO, "Opening raw socket on ifindex %d\n", ifindex);
1114 if ((l_fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) {
1115 DEBUG(LOG_ERR, "socket call failed: %s", sys_errlist[errno]);
1116 return -1;
1117 }
1118
1119 sock.sll_family = AF_PACKET;
1120 sock.sll_protocol = htons(ETH_P_IP);
1121 sock.sll_ifindex = ifindex;
1122 if (bind(l_fd, (struct sockaddr *) &sock, sizeof(sock)) < 0) {
1123 DEBUG(LOG_ERR, "bind call failed: %s", sys_errlist[errno]);
1124 close(l_fd);
1125 return -1;
1126 }
1127
1128 return l_fd;
1129
1130}
1131
1132/* read a packet from socket fd, return -1 on read error, -2 on packet error */
1133int get_packet(struct dhcpMessage *packet, int l_fd)
1134{
1135 int bytes;
1136 int i;
1137 const char broken_vendors[][8] = {
1138 "MSFT 98",
1139 ""
1140 };
1141 char unsigned *vendor;
1142
1143 memset(packet, 0, sizeof(struct dhcpMessage));
1144 bytes = read(l_fd, packet, sizeof(struct dhcpMessage));
1145 if (bytes < 0) {
1146 DEBUG(LOG_INFO, "couldn't read on listening socket, ignoring");
1147 return -1;
1148 }
1149
1150 if (ntohl(packet->cookie) != DHCP_MAGIC) {
1151 LOG(LOG_ERR, "received bogus message, ignoring");
1152 return -2;
1153 }
1154 DEBUG(LOG_INFO, "Received a packet");
1155
1156 if (packet->op == BOOTREQUEST && (vendor = get_option(packet, DHCP_VENDOR))) {
1157 for (i = 0; broken_vendors[i][0]; i++) {
1158 if (vendor[OPT_LEN - 2] == (unsigned char) strlen(broken_vendors[i]) &&
1159 !strncmp(vendor, broken_vendors[i], vendor[OPT_LEN - 2])) {
1160 DEBUG(LOG_INFO, "broken client (%s), forcing broadcast",
1161 broken_vendors[i]);
1162 packet->flags |= htons(BROADCAST_FLAG);
1163 }
1164 }
1165 }
1166
1167
1168 return bytes;
1169}
1170
1171int get_raw_packet(struct dhcpMessage *payload, int l_fd)
1172{
1173 int bytes;
1174 struct udp_dhcp_packet packet;
1175 u_int32_t source, dest;
1176 u_int16_t check;
1177
1178 memset(&packet, 0, sizeof(struct udp_dhcp_packet));
1179 bytes = read(l_fd, &packet, sizeof(struct udp_dhcp_packet));
1180 if (bytes < 0) {
1181 DEBUG(LOG_INFO, "couldn't read on raw listening socket -- ignoring");
1182 usleep(500000); /* possible down interface, looping condition */
1183 return -1;
1184 }
1185
1186 if (bytes < (int) (sizeof(struct iphdr) + sizeof(struct udphdr))) {
1187 DEBUG(LOG_INFO, "message too short, ignoring");
1188 return -1;
1189 }
1190
1191 if (bytes < ntohs(packet.ip.tot_len)) {
1192 DEBUG(LOG_INFO, "Truncated packet");
1193 return -1;
1194 }
1195
1196 /* ignore any extra garbage bytes */
1197 bytes = ntohs(packet.ip.tot_len);
1198
1199 /* Make sure its the right packet for us, and that it passes sanity checks */
1200 if (packet.ip.protocol != IPPROTO_UDP || packet.ip.version != IPVERSION ||
1201 packet.ip.ihl != sizeof(packet.ip) >> 2 || packet.udp.dest != htons(CLIENT_PORT) ||
1202 bytes > (int) sizeof(struct udp_dhcp_packet) ||
1203 ntohs(packet.udp.len) != (short) (bytes - sizeof(packet.ip))) {
1204 DEBUG(LOG_INFO, "unrelated/bogus packet");
1205 return -1;
1206 }
1207
1208 /* check IP checksum */
1209 check = packet.ip.check;
1210 packet.ip.check = 0;
1211 if (check != checksum(&(packet.ip), sizeof(packet.ip))) {
1212 DEBUG(LOG_INFO, "bad IP header checksum, ignoring");
1213 return -1;
1214 }
1215
1216 /* verify the UDP checksum by replacing the header with a psuedo header */
1217 source = packet.ip.saddr;
1218 dest = packet.ip.daddr;
1219 check = packet.udp.check;
1220 packet.udp.check = 0;
1221 memset(&packet.ip, 0, sizeof(packet.ip));
1222
1223 packet.ip.protocol = IPPROTO_UDP;
1224 packet.ip.saddr = source;
1225 packet.ip.daddr = dest;
1226 packet.ip.tot_len = packet.udp.len; /* cheat on the psuedo-header */
1227 if (check && check != checksum(&packet, bytes)) {
1228 DEBUG(LOG_ERR, "packet with bad UDP checksum received, ignoring");
1229 return -1;
1230 }
1231
1232 memcpy(payload, &(packet.data), bytes - (sizeof(packet.ip) + sizeof(packet.udp)));
1233
1234 if (ntohl(payload->cookie) != DHCP_MAGIC) {
1235 LOG(LOG_ERR, "received bogus message (bad magic) -- ignoring");
1236 return -1;
1237 }
1238 DEBUG(LOG_INFO, "oooooh!!! got some!");
1239 return bytes - (sizeof(packet.ip) + sizeof(packet.udp));
1240
1241}
1242
1243
1244int udhcpc_main(int argc, char *argv[])
1245{
1246 unsigned char *temp, *message;
1247 unsigned long t1 = 0, t2 = 0, xid = 0;
1248 unsigned long start = 0, lease;
1249 fd_set rfds;
1250 int retval;
1251 struct timeval tv;
1252 int c, len;
1253 struct dhcpMessage packet;
1254 struct in_addr temp_addr;
1255 int pid_fd;
1256 time_t now;
1257
1258 static struct option l_options[] = {
1259 {"clientid", required_argument, 0, 'c'},
1260 {"foreground", no_argument, 0, 'f'},
1261 {"hostname", required_argument, 0, 'H'},
1262 {"help", no_argument, 0, 'h'},
1263 {"interface", required_argument, 0, 'i'},
1264 {"now", no_argument, 0, 'n'},
1265 {"pidfile", required_argument, 0, 'p'},
1266 {"quit", no_argument, 0, 'q'},
1267 {"request", required_argument, 0, 'r'},
1268 {"script", required_argument, 0, 's'},
1269 {"version", no_argument, 0, 'v'},
1270 {0, 0, 0, 0}
1271 };
1272
1273 /* get options */
1274 while (1) {
1275 int option_index = 0;
1276 c = getopt_long(argc, argv, "c:fH:hi:np:qr:s:v", l_options, &option_index);
1277 if (c == -1) break;
1278
1279 switch (c) {
1280 case 'c':
1281 len = strlen(optarg) > 255 ? 255 : strlen(optarg);
1282 if (client_config.clientid) free(client_config.clientid);
1283 client_config.clientid = xmalloc(len + 2);
1284 client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID;
1285 client_config.clientid[OPT_LEN] = len;
1286 client_config.clientid[OPT_DATA] = '\0';
1287 strncpy(client_config.clientid + 3, optarg, len - 1);
1288 break;
1289 case 'f':
1290 client_config.foreground = 1;
1291 break;
1292 case 'H':
1293 len = strlen(optarg) > 255 ? 255 : strlen(optarg);
1294 if (client_config.hostname) free(client_config.hostname);
1295 client_config.hostname = xmalloc(len + 2);
1296 client_config.hostname[OPT_CODE] = DHCP_HOST_NAME;
1297 client_config.hostname[OPT_LEN] = len;
1298 strncpy(client_config.hostname + 2, optarg, len);
1299 break;
1300 case 'h':
1301 print_usage();
1302 return 0;
1303 case 'i':
1304 client_config.interface = optarg;
1305 break;
1306 case 'n':
1307 client_config.abort_if_no_lease = 1;
1308 break;
1309 case 'p':
1310 client_config.pidfile = optarg;
1311 break;
1312 case 'q':
1313 client_config.quit_after_lease = 1;
1314 break;
1315 case 'r':
1316 requested_ip = inet_addr(optarg);
1317 break;
1318 case 's':
1319 client_config.script = optarg;
1320 break;
1321 case 'v':
1322 printf("udhcpcd, version %s\n\n", VERSION);
1323 exit_client(0);
1324 break;
1325 }
1326 }
1327
1328 OPEN_LOG("udhcpc");
1329 LOG(LOG_INFO, "udhcp client (v%s) started", VERSION);
1330
1331 pid_fd = pidfile_acquire(client_config.pidfile);
1332 pidfile_write_release(pid_fd);
1333
1334 if (read_interface(client_config.interface, &client_config.ifindex, NULL, client_config.arp) < 0) {
1335 exit_client(1);
1336 }
1337
1338 if (!client_config.clientid) {
1339 client_config.clientid = xmalloc(6 + 3);
1340 client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID;
1341 client_config.clientid[OPT_LEN] = 7;
1342 client_config.clientid[OPT_DATA] = 1;
1343 memcpy(client_config.clientid + 3, client_config.arp, 6);
1344 }
1345
1346 /* setup signal handlers */
1347 signal(SIGUSR1, renew_requested);
1348 signal(SIGUSR2, release_requested);
1349 signal(SIGTERM, terminate);
1350
1351 state = INIT_SELECTING;
1352 run_script(NULL, "deconfig");
1353 change_mode(LISTEN_RAW);
1354
1355 for (;;) {
1356 tv.tv_sec = timeout - time(0);
1357 tv.tv_usec = 0;
1358 FD_ZERO(&rfds);
1359
1360 if (listen_mode != LISTEN_NONE && fd_main < 0) {
1361 if (listen_mode == LISTEN_KERNEL) {
1362 fd_main = listen_socket(INADDR_ANY, CLIENT_PORT, client_config.interface);
1363 } else {
1364 fd_main = raw_socket(client_config.ifindex);
1365 }
1366 if (fd_main < 0) {
1367 LOG(LOG_ERR, "FATAL: couldn't listen on socket, %s", sys_errlist[errno]);
1368 exit_client(0);
1369 }
1370 }
1371 if (fd_main >= 0) {
1372 FD_SET(fd_main, &rfds);
1373 }
1374
1375 if (tv.tv_sec > 0) {
1376 DEBUG(LOG_INFO, "Waiting on select...\n");
1377 retval = select(fd_main + 1, &rfds, NULL, NULL, &tv);
1378 } else {
1379 retval = 0; /* If we already timed out, fall through */
1380 }
1381
1382 now = time(0);
1383 if (retval == 0) {
1384 /* timeout dropped to zero */
1385 switch (state) {
1386 case INIT_SELECTING:
1387 if (packet_num < 3) {
1388 if (packet_num == 0) {
1389 xid = random_xid();
1390 }
1391 /* send discover packet */
1392 send_discover(xid, requested_ip); /* broadcast */
1393
1394 timeout = now + ((packet_num == 2) ? 10 : 2);
1395 packet_num++;
1396 } else {
1397 if (client_config.abort_if_no_lease) {
1398 LOG(LOG_INFO, "No lease, failing.");
1399 exit_client(1);
1400 }
1401 /* wait to try again */
1402 packet_num = 0;
1403 timeout = now + 60;
1404 }
1405 break;
1406 case RENEW_REQUESTED:
1407 case REQUESTING:
1408 if (packet_num < 3) {
1409 /* send request packet */
1410 if (state == RENEW_REQUESTED) {
1411 send_renew(xid, server_addr, requested_ip); /* unicast */
1412 } else {
1413 send_selecting(xid, server_addr, requested_ip); /* broadcast */
1414 }
1415 timeout = now + ((packet_num == 2) ? 10 : 2);
1416 packet_num++;
1417 } else {
1418 /* timed out, go back to init state */
1419 state = INIT_SELECTING;
1420 timeout = now;
1421 packet_num = 0;
1422 change_mode(LISTEN_RAW);
1423 }
1424 break;
1425 case BOUND:
1426 /* Lease is starting to run out, time to enter renewing state */
1427 state = RENEWING;
1428 change_mode(LISTEN_KERNEL);
1429 DEBUG(LOG_INFO, "Entering renew state");
1430 /* fall right through */
1431 case RENEWING:
1432 /* Either set a new T1, or enter REBINDING state */
1433 if ((t2 - t1) <= (lease / 14400 + 1)) {
1434 /* timed out, enter rebinding state */
1435 state = REBINDING;
1436 timeout = now + (t2 - t1);
1437 DEBUG(LOG_INFO, "Entering rebinding state");
1438 } else {
1439 /* send a request packet */
1440 send_renew(xid, server_addr, requested_ip); /* unicast */
1441
1442 t1 = (t2 - t1) / 2 + t1;
1443 timeout = t1 + start;
1444 }
1445 break;
1446 case REBINDING:
1447 /* Either set a new T2, or enter INIT state */
1448 if ((lease - t2) <= (lease / 14400 + 1)) {
1449 /* timed out, enter init state */
1450 state = INIT_SELECTING;
1451 LOG(LOG_INFO, "Lease lost, entering init state");
1452 run_script(NULL, "deconfig");
1453 timeout = now;
1454 packet_num = 0;
1455 change_mode(LISTEN_RAW);
1456 } else {
1457 /* send a request packet */
1458 send_renew(xid, 0, requested_ip); /* broadcast */
1459
1460 t2 = (lease - t2) / 2 + t2;
1461 timeout = t2 + start;
1462 }
1463 break;
1464 case RELEASED:
1465 /* yah, I know, *you* say it would never happen */
1466 timeout = 0x7fffffff;
1467 break;
1468 }
1469 } else if (retval > 0 && listen_mode != LISTEN_NONE && FD_ISSET(fd_main, &rfds)) {
1470 /* a packet is ready, read it */
1471
1472 if (listen_mode == LISTEN_KERNEL) {
1473 len = get_packet(&packet, fd_main);
1474 } else {
1475 len = get_raw_packet(&packet, fd_main);
1476 }
1477 if (len == -1 && errno != EINTR) {
1478 DEBUG(LOG_INFO, "error on read, %s, reopening socket", sys_errlist[errno]);
1479 change_mode(listen_mode); /* just close and reopen */
1480 }
1481 if (len < 0) {
1482 continue;
1483 }
1484
1485 if (packet.xid != xid) {
1486 DEBUG(LOG_INFO, "Ignoring XID %lx (our xid is %lx)",
1487 (unsigned long) packet.xid, xid);
1488 continue;
1489 }
1490
1491 if ((message = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) {
1492 DEBUG(LOG_ERR, "couldnt get option from packet -- ignoring");
1493 continue;
1494 }
1495
1496 switch (state) {
1497 case INIT_SELECTING:
1498 /* Must be a DHCPOFFER to one of our xid's */
1499 if (*message == DHCPOFFER) {
1500 if ((temp = get_option(&packet, DHCP_SERVER_ID))) {
1501 memcpy(&server_addr, temp, 4);
1502 xid = packet.xid;
1503 requested_ip = packet.yiaddr;
1504
1505 /* enter requesting state */
1506 state = REQUESTING;
1507 timeout = now;
1508 packet_num = 0;
1509 } else {
1510 DEBUG(LOG_ERR, "No server ID in message");
1511 }
1512 }
1513 break;
1514 case RENEW_REQUESTED:
1515 case REQUESTING:
1516 case RENEWING:
1517 case REBINDING:
1518 if (*message == DHCPACK) {
1519 if (!(temp = get_option(&packet, DHCP_LEASE_TIME))) {
1520 LOG(LOG_ERR, "No lease time with ACK, using 1 hour lease");
1521 lease = 60 * 60;
1522 } else {
1523 memcpy(&lease, temp, 4);
1524 lease = ntohl(lease);
1525 }
1526
1527 /* enter bound state */
1528 t1 = lease / 2;
1529
1530 /* little fixed point for n * .875 */
1531 t2 = (lease * 0x7) >> 3;
1532 temp_addr.s_addr = packet.yiaddr;
1533 LOG(LOG_INFO, "Lease of %s obtained, lease time %ld", inet_ntoa(temp_addr), lease);
1534 start = now;
1535 timeout = t1 + start;
1536 requested_ip = packet.yiaddr;
1537 run_script(&packet, ((state == RENEWING || state == REBINDING) ? "renew" : "bound"));
1538
1539 state = BOUND;
1540 change_mode(LISTEN_NONE);
1541 background();
1542 }
1543 else if (*message == DHCPNAK) {
1544 /* return to init state */
1545 LOG(LOG_INFO, "Received DHCP NAK");
1546 run_script(&packet, "nak");
1547 if (state != REQUESTING) {
1548 run_script(NULL, "deconfig");
1549 }
1550 state = INIT_SELECTING;
1551 timeout = now;
1552 requested_ip = 0;
1553 packet_num = 0;
1554 change_mode(LISTEN_RAW);
1555 sleep(3); /* avoid excessive network traffic */
1556 }
1557 break;
1558 /* case BOUND, RELEASED: - ignore all packets */
1559 }
1560 }
1561 else if (retval == -1 && errno == EINTR) {
1562 /* a signal was caught */
1563
1564 } else {
1565 /* An error occured */
1566 DEBUG(LOG_ERR, "Error on select");
1567 }
1568
1569 }
1570 return 0;
1571}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-03 23:55:36 +0000