1 /*
2  * bootptest.c - Test out a bootp server.
3  *
4  * This simple program was put together from pieces taken from
5  * various places, including the CMU BOOTP client and server.
6  * The packet printing routine is from the Berkeley "tcpdump"
7  * program with some enhancements I added.  The print-bootp.c
8  * file was shared with my copy of "tcpdump" and therefore uses
9  * some unusual utility routines that would normally be provided
10  * by various parts of the tcpdump program.  Gordon W. Ross
11  *
12  * Boilerplate:
13  *
14  * This program includes software developed by the University of
15  * California, Lawrence Berkeley Laboratory and its contributors.
16  * (See the copyright notice in print-bootp.c)
17  *
18  * The remainder of this program is public domain.  You may do
19  * whatever you like with it except claim that you wrote it.
20  *
21  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24  *
25  * HISTORY:
26  *
27  * 12/02/93 Released version 1.4 (with bootp-2.3.2)
28  * 11/05/93 Released version 1.3
29  * 10/14/93 Released version 1.2
30  * 10/11/93 Released version 1.1
31  * 09/28/93 Released version 1.0
32  * 09/93 Original developed by Gordon W. Ross <gwr@mc.com>
33  *
34  * $FreeBSD: src/libexec/bootpd/tools/bootptest/bootptest.c,v 1.7 1999/08/28 00:09:25 peter Exp $
35  */
36 
37 char *usage = "bootptest [-h] server-name [vendor-data-template-file]";
38 
39 #include <sys/types.h>
40 #include <sys/socket.h>
41 #include <sys/ioctl.h>
42 #include <sys/file.h>
43 #include <sys/time.h>
44 #include <sys/stat.h>
45 #include <sys/utsname.h>
46 
47 #include <net/if.h>
48 #include <netinet/in.h>
49 #include <arpa/inet.h>			/* inet_ntoa */
50 
51 #ifndef	NO_UNISTD
52 #include <unistd.h>
53 #endif
54 
55 #include <stdlib.h>
56 #include <signal.h>
57 #include <stdio.h>
58 #include <string.h>
59 #include <errno.h>
60 #include <ctype.h>
61 #include <netdb.h>
62 #include <assert.h>
63 
64 #include "bootp.h"
65 #include "bootptest.h"
66 #include "getif.h"
67 #include "getether.h"
68 
69 #include "patchlevel.h"
70 
71 static void send_request();
72 
73 #define LOG_ERR 1
74 #define BUFLEN 1024
75 #define WAITSECS 1
76 #define MAXWAIT  10
77 
78 int vflag = 1;
79 int tflag = 0;
80 int thiszone;
81 char *progname;
82 unsigned char *packetp;
83 unsigned char *snapend;
84 int snaplen;
85 
86 
87 /*
88  * IP port numbers for client and server obtained from /etc/services
89  */
90 
91 u_short bootps_port, bootpc_port;
92 
93 
94 /*
95  * Internet socket and interface config structures
96  */
97 
98 struct sockaddr_in sin_server;	/* where to send requests */
99 struct sockaddr_in sin_client;	/* for bind and listen */
100 struct sockaddr_in sin_from;	/* Packet source */
101 u_char eaddr[16];				/* Ethernet address */
102 
103 /*
104  * General
105  */
106 
107 int debug = 1;					/* Debugging flag (level) */
108 char *sndbuf;					/* Send packet buffer */
109 char *rcvbuf;					/* Receive packet buffer */
110 
111 struct utsname my_uname;
112 char *hostname;
113 
114 /*
115  * Vendor magic cookies for CMU and RFC1048
116  */
117 
118 unsigned char vm_cmu[4] = VM_CMU;
119 unsigned char vm_rfc1048[4] = VM_RFC1048;
120 short secs;						/* How long client has waited */
121 
122 char *get_errmsg();
123 extern void bootp_print();
124 
125 /*
126  * Initialization such as command-line processing is done, then
127  * the receiver loop is started.  Die when interrupted.
128  */
129 
130 int
131 main(int argc, char **argv)
132 {
133 	struct bootp *bp;
134 	struct servent *sep;
135 	struct hostent *hep;
136 
137 	char *servername = NULL;
138 	char *vendor_file = NULL;
139 	char *bp_file = NULL;
140 	int32 server_addr;			/* inet addr, network order */
141 	int s;						/* Socket file descriptor */
142 	int n, fromlen, recvcnt;
143 	int use_hwa = 0;
144 	int32 vend_magic;
145 	int32 xid;
146 
147 	progname = strrchr(argv[0], '/');
148 	if (progname)
149 		progname++;
150 	else
151 		progname = argv[0];
152 	argc--;
153 	argv++;
154 
155 	if (debug)
156 		printf("%s: version %s.%d\n", progname, VERSION, PATCHLEVEL);
157 
158 	/*
159 	 * Verify that "struct bootp" has the correct official size.
160 	 * (Catch evil compilers that do struct padding.)
161 	 */
162 	assert(sizeof(struct bootp) == BP_MINPKTSZ);
163 
164 	if (uname(&my_uname) < 0) {
165 		fprintf(stderr, "%s: can't get hostname\n", argv[0]);
166 		exit(1);
167 	}
168 	hostname = my_uname.nodename;
169 
170 	sndbuf = malloc(BUFLEN);
171 	rcvbuf = malloc(BUFLEN);
172 	if (!sndbuf || !rcvbuf) {
173 		printf("malloc failed\n");
174 		exit(1);
175 	}
176 
177 	/* default magic number */
178 	bcopy(vm_rfc1048, (char*)&vend_magic, 4);
179 
180 	/* Handle option switches. */
181 	while (argc > 0) {
182 		if (argv[0][0] != '-')
183 			break;
184 		switch (argv[0][1]) {
185 
186 		case 'f':				/* File name to reqest. */
187 			if (argc < 2)
188 				goto error;
189 			argc--; argv++;
190 			bp_file = *argv;
191 			break;
192 
193 		case 'h':				/* Use hardware address. */
194 			use_hwa = 1;
195 			break;
196 
197 		case 'm':				/* Magic number value. */
198 			if (argc < 2)
199 				goto error;
200 			argc--; argv++;
201 			vend_magic = inet_addr(*argv);
202 			break;
203 
204 		error:
205 		default:
206 			puts(usage);
207 			exit(1);
208 
209 		}
210 		argc--;
211 		argv++;
212 	}
213 
214 	/* Get server name (or address) for query. */
215 	if (argc > 0) {
216 		servername = *argv;
217 		argc--;
218 		argv++;
219 	}
220 	/* Get optional vendor-data-template-file. */
221 	if (argc > 0) {
222 		vendor_file = *argv;
223 		argc--;
224 		argv++;
225 	}
226 	if (!servername) {
227 		printf("missing server name.\n");
228 		puts(usage);
229 		exit(1);
230 	}
231 	/*
232 	 * Create a socket.
233 	 */
234 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
235 		perror("socket");
236 		exit(1);
237 	}
238 	/*
239 	 * Get server's listening port number
240 	 */
241 	sep = getservbyname("bootps", "udp");
242 	if (sep) {
243 		bootps_port = ntohs((u_short) sep->s_port);
244 	} else {
245 		fprintf(stderr, "udp/bootps: unknown service -- using port %d\n",
246 				IPPORT_BOOTPS);
247 		bootps_port = (u_short) IPPORT_BOOTPS;
248 	}
249 
250 	/*
251 	 * Set up server socket address (for send)
252 	 */
253 	if (servername) {
254 		if (isdigit(servername[0]))
255 			server_addr = inet_addr(servername);
256 		else {
257 			hep = gethostbyname(servername);
258 			if (!hep) {
259 				fprintf(stderr, "%s: unknown host\n", servername);
260 				exit(1);
261 			}
262 			bcopy(hep->h_addr, &server_addr, sizeof(server_addr));
263 		}
264 	} else {
265 		/* Get broadcast address */
266 		/* XXX - not yet */
267 		server_addr = INADDR_ANY;
268 	}
269 	sin_server.sin_family = AF_INET;
270 	sin_server.sin_port = htons(bootps_port);
271 	sin_server.sin_addr.s_addr = server_addr;
272 
273 	/*
274 	 * Get client's listening port number
275 	 */
276 	sep = getservbyname("bootpc", "udp");
277 	if (sep) {
278 		bootpc_port = ntohs(sep->s_port);
279 	} else {
280 		fprintf(stderr, "udp/bootpc: unknown service -- using port %d\n",
281 				IPPORT_BOOTPC);
282 		bootpc_port = (u_short) IPPORT_BOOTPC;
283 	}
284 
285 	/*
286 	 * Set up client socket address (for listen)
287 	 */
288 	sin_client.sin_family = AF_INET;
289 	sin_client.sin_port = htons(bootpc_port);
290 	sin_client.sin_addr.s_addr = INADDR_ANY;
291 
292 	/*
293 	 * Bind client socket to BOOTPC port.
294 	 */
295 	if (bind(s, (struct sockaddr *) &sin_client, sizeof(sin_client)) < 0) {
296 		perror("bind BOOTPC port");
297 		if (errno == EACCES)
298 			fprintf(stderr, "You need to run this as root\n");
299 		exit(1);
300 	}
301 	/*
302 	 * Build a request.
303 	 */
304 	bp = (struct bootp *) sndbuf;
305 	bzero(bp, sizeof(*bp));
306 	bp->bp_op = BOOTREQUEST;
307 	xid = (int32) getpid();
308 	bp->bp_xid = (u_int32) htonl(xid);
309 	if (bp_file)
310 		strncpy(bp->bp_file, bp_file, BP_FILE_LEN);
311 
312 	/*
313 	 * Fill in the hardware address (or client IP address)
314 	 */
315 	if (use_hwa) {
316 		struct ifreq *ifr;
317 
318 		ifr = getif(s, &sin_server.sin_addr);
319 		if (!ifr) {
320 			printf("No interface for %s\n", servername);
321 			exit(1);
322 		}
323 		if (getether(ifr->ifr_name, (char*)eaddr)) {
324 			printf("Can not get ether addr for %s\n", ifr->ifr_name);
325 			exit(1);
326 		}
327 		/* Copy Ethernet address into request packet. */
328 		bp->bp_htype = 1;
329 		bp->bp_hlen = 6;
330 		bcopy(eaddr, bp->bp_chaddr, bp->bp_hlen);
331 	} else {
332 		/* Fill in the client IP address. */
333 		hep = gethostbyname(hostname);
334 		if (!hep) {
335 			printf("Can not get my IP address\n");
336 			exit(1);
337 		}
338 		bcopy(hep->h_addr, &bp->bp_ciaddr, hep->h_length);
339 	}
340 
341 	/*
342 	 * Copy in the default vendor data.
343 	 */
344 	bcopy((char*)&vend_magic, bp->bp_vend, 4);
345 	if (vend_magic)
346 		bp->bp_vend[4] = TAG_END;
347 
348 	/*
349 	 * Read in the "options" part of the request.
350 	 * This also determines the size of the packet.
351 	 */
352 	snaplen = sizeof(*bp);
353 	if (vendor_file) {
354 		int fd = open(vendor_file, 0);
355 		if (fd < 0) {
356 			perror(vendor_file);
357 			exit(1);
358 		}
359 		/* Compute actual space for options. */
360 		n = BUFLEN - sizeof(*bp) + BP_VEND_LEN;
361 		n = read(fd, bp->bp_vend, n);
362 		close(fd);
363 		if (n < 0) {
364 			perror(vendor_file);
365 			exit(1);
366 		}
367 		printf("read %d bytes of vendor template\n", n);
368 		if (n > BP_VEND_LEN) {
369 			printf("warning: extended options in use (len > %d)\n",
370 				   BP_VEND_LEN);
371 			snaplen += (n - BP_VEND_LEN);
372 		}
373 	}
374 	/*
375 	 * Set globals needed by print_bootp
376 	 * (called by send_request)
377 	 */
378 	packetp = (unsigned char *) eaddr;
379 	snapend = (unsigned char *) sndbuf + snaplen;
380 
381 	/* Send a request once per second while waiting for replies. */
382 	recvcnt = 0;
383 	bp->bp_secs = secs = 0;
384 	send_request(s);
385 	while (1) {
386 		struct timeval tv;
387 		int readfds;
388 
389 		tv.tv_sec = WAITSECS;
390 		tv.tv_usec = 0L;
391 		readfds = (1 << s);
392 		n = select(s + 1, (fd_set *) & readfds, NULL, NULL, &tv);
393 		if (n < 0) {
394 			perror("select");
395 			break;
396 		}
397 		if (n == 0) {
398 			/*
399 			 * We have not received a response in the last second.
400 			 * If we have ever received any responses, exit now.
401 			 * Otherwise, bump the "wait time" field and re-send.
402 			 */
403 			if (recvcnt > 0)
404 				exit(0);
405 			secs += WAITSECS;
406 			if (secs > MAXWAIT)
407 				break;
408 			bp->bp_secs = htons(secs);
409 			send_request(s);
410 			continue;
411 		}
412 		fromlen = sizeof(sin_from);
413 		n = recvfrom(s, rcvbuf, BUFLEN, 0,
414 					 (struct sockaddr *) &sin_from, &fromlen);
415 		if (n <= 0) {
416 			continue;
417 		}
418 		if (n < sizeof(struct bootp)) {
419 			printf("received short packet\n");
420 			continue;
421 		}
422 		recvcnt++;
423 
424 		/* Print the received packet. */
425 		printf("Recvd from %s", inet_ntoa(sin_from.sin_addr));
426 		/* set globals needed by bootp_print() */
427 		snaplen = n;
428 		snapend = (unsigned char *) rcvbuf + snaplen;
429 		bootp_print(rcvbuf, n, sin_from.sin_port, 0);
430 		putchar('\n');
431 		/*
432 		 * This no longer exits immediately after receiving
433 		 * one response because it is useful to know if the
434 		 * client might get multiple responses.  This code
435 		 * will now listen for one second after a response.
436 		 */
437 	}
438 	fprintf(stderr, "no response from %s\n", servername);
439 	exit(1);
440 }
441 
442 static void
443 send_request(int s)
444 {
445 	/* Print the request packet. */
446 	printf("Sending to %s", inet_ntoa(sin_server.sin_addr));
447 	bootp_print(sndbuf, snaplen, sin_from.sin_port, 0);
448 	putchar('\n');
449 
450 	/* Send the request packet. */
451 	if (sendto(s, sndbuf, snaplen, 0,
452 			   (struct sockaddr *) &sin_server,
453 			   sizeof(sin_server)) < 0)
454 	{
455 		perror("sendto server");
456 		exit(1);
457 	}
458 }
459 
460 /*
461  * Print out a filename (or other ascii string).
462  * Return true if truncated.
463  */
464 int
465 printfn(u_char *s, u_char *ep)
466 {
467 	u_char c;
468 
469 	putchar('"');
470 	while ((c = *s++) != '\0') {
471 		if (s > ep) {
472 			putchar('"');
473 			return (1);
474 		}
475 		if (!isascii(c)) {
476 			c = toascii(c);
477 			putchar('M');
478 			putchar('-');
479 		}
480 		if (!isprint(c)) {
481 			c ^= 0x40;			/* DEL to ?, others to alpha */
482 			putchar('^');
483 		}
484 		putchar(c);
485 	}
486 	putchar('"');
487 	return (0);
488 }
489 
490 /*
491  * Convert an IP addr to a string.
492  * (like inet_ntoa, but ina is a pointer)
493  */
494 char *
495 ipaddr_string(struct in_addr *ina)
496 {
497 	static char b[24];
498 	u_char *p;
499 
500 	p = (u_char *) ina;
501 	snprintf(b, sizeof(b), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
502 	return (b);
503 }
504