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