Home | History | Annotate | Line # | Download | only in bootptest
bootptest.c revision 1.15 
      1 /*	$NetBSD: bootptest.c,v 1.15 2006/05/09 20:18:09 mrg 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 (at) mc.com>
     35  */
     36 
     37 #include <sys/cdefs.h>
     38 #ifndef lint
     39 __RCSID("$NetBSD: bootptest.c,v 1.15 2006/05/09 20:18:09 mrg Exp $");
     40 #endif
     41 
     42 char *usage = "usage: %s [-f bootfile] [-h] [-m magic_number] server-name\n"
     43 	      "                 [vendor-data-template-file]\n";
     44 
     45 #include <sys/param.h>
     46 #include <sys/socket.h>
     47 #include <sys/ioctl.h>
     48 #include <sys/file.h>
     49 #include <sys/time.h>
     50 #include <sys/stat.h>
     51 #include <sys/poll.h>
     52 
     53 #include <net/if.h>
     54 #include <netinet/in.h>
     55 #include <arpa/inet.h>			/* inet_ntoa */
     56 
     57 #include <stdlib.h>
     58 #include <signal.h>
     59 #include <stdio.h>
     60 #include <string.h>
     61 #include <errno.h>
     62 #include <ctype.h>
     63 #include <netdb.h>
     64 #include <assert.h>
     65 #include <unistd.h>
     66 
     67 #include "bootp.h"
     68 #include "bootptest.h"
     69 #include "getif.h"
     70 #include "report.h"
     71 #include "patchlevel.h"
     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 hostname[MAXHOSTNAMELEN + 1];
    109 char *sndbuf;					/* Send packet buffer */
    110 char *rcvbuf;					/* Receive packet buffer */
    111 
    112 /*
    113  * Vendor magic cookies for CMU and RFC1048
    114  */
    115 
    116 unsigned char vm_cmu[4] = VM_CMU;
    117 unsigned char vm_rfc1048[4] = VM_RFC1048;
    118 short secs;						/* How long client has waited */
    119 
    120 
    121 extern int getether(char *, char *);
    122 int main(int, char **);
    123 void send_request(int);
    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 	socklen_t fromlen;
    141 	int s;				/* Socket file descriptor */
    142 	int n, recvcnt;
    143 	int use_hwa = 0;
    144 	int32 vend_magic;
    145 	int32 xid;
    146 	struct pollfd set[1];
    147 
    148 	progname = strrchr(argv[0], '/');
    149 	if (progname)
    150 		progname++;
    151 	else
    152 		progname = argv[0];
    153 	argc--;
    154 	argv++;
    155 
    156 	if (debug)
    157 		printf("%s: version %s.%d\n", progname, VERSION, PATCHLEVEL);
    158 
    159 	/*
    160 	 * Verify that "struct bootp" has the correct official size.
    161 	 * (Catch evil compilers that do struct padding.)
    162 	 */
    163 	assert(sizeof(struct bootp) == BP_MINPKTSZ);
    164 
    165 	sndbuf = malloc(BUFLEN);
    166 	rcvbuf = malloc(BUFLEN);
    167 	if (!sndbuf || !rcvbuf) {
    168 		printf("malloc failed\n");
    169 		exit(1);
    170 	}
    171 
    172 	/* default magic number */
    173 	bcopy(vm_rfc1048, (char*)&vend_magic, 4);
    174 
    175 	/* Handle option switches. */
    176 	while (argc > 0) {
    177 		if (argv[0][0] != '-')
    178 			break;
    179 		switch (argv[0][1]) {
    180 
    181 		case 'f':				/* File name to reqest. */
    182 			if (argc < 2)
    183 				goto error;
    184 			argc--; argv++;
    185 			bp_file = *argv;
    186 			break;
    187 
    188 		case 'h':				/* Use hardware address. */
    189 			use_hwa = 1;
    190 			break;
    191 
    192 		case 'm':				/* Magic number value. */
    193 			if (argc < 2)
    194 				goto error;
    195 			argc--; argv++;
    196 			vend_magic = inet_addr(*argv);
    197 			break;
    198 
    199 		error:
    200 		default:
    201 			(void)fprintf(stderr, usage, getprogname());
    202 			exit(1);
    203 
    204 		}
    205 		argc--;
    206 		argv++;
    207 	}
    208 
    209 	/* Get server name (or address) for query. */
    210 	if (argc > 0) {
    211 		servername = *argv;
    212 		argc--;
    213 		argv++;
    214 	}
    215 	/* Get optional vendor-data-template-file. */
    216 	if (argc > 0) {
    217 		vendor_file = *argv;
    218 		argc--;
    219 		argv++;
    220 	}
    221 	if (!servername) {
    222 		printf("missing server name.\n");
    223 		(void)fprintf(stderr, usage, getprogname());
    224 		exit(1);
    225 	}
    226 	/*
    227 	 * Create a socket.
    228 	 */
    229 	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    230 		perror("socket");
    231 		exit(1);
    232 	}
    233 	/*
    234 	 * Get server's listening port number
    235 	 */
    236 	sep = getservbyname("bootps", "udp");
    237 	if (sep) {
    238 		bootps_port = ntohs((u_short) sep->s_port);
    239 	} else {
    240 		fprintf(stderr, "udp/bootps: unknown service -- using port %d\n",
    241 				IPPORT_BOOTPS);
    242 		bootps_port = (u_short) IPPORT_BOOTPS;
    243 	}
    244 
    245 	/*
    246 	 * Set up server socket address (for send)
    247 	 */
    248 	if (servername) {
    249 		if (inet_aton(servername, &sin_server.sin_addr) == 0) {
    250 			hep = gethostbyname(servername);
    251 			if (!hep) {
    252 				fprintf(stderr, "%s: unknown host\n", servername);
    253 				exit(1);
    254 			}
    255 			memcpy(&sin_server.sin_addr, hep->h_addr,
    256 			    sizeof(sin_server.sin_addr));
    257 		}
    258 	} else {
    259 		/* Get broadcast address */
    260 		/* XXX - not yet */
    261 		sin_server.sin_addr.s_addr = INADDR_ANY;
    262 	}
    263 	sin_server.sin_family = AF_INET;
    264 	sin_server.sin_port = htons(bootps_port);
    265 
    266 	/*
    267 	 * Get client's listening port number
    268 	 */
    269 	sep = getservbyname("bootpc", "udp");
    270 	if (sep) {
    271 		bootpc_port = ntohs(sep->s_port);
    272 	} else {
    273 		fprintf(stderr, "udp/bootpc: unknown service -- using port %d\n",
    274 				IPPORT_BOOTPC);
    275 		bootpc_port = (u_short) IPPORT_BOOTPC;
    276 	}
    277 
    278 	/*
    279 	 * Set up client socket address (for listen)
    280 	 */
    281 	sin_client.sin_family = AF_INET;
    282 	sin_client.sin_port = htons(bootpc_port);
    283 	sin_client.sin_addr.s_addr = INADDR_ANY;
    284 
    285 	/*
    286 	 * Bind client socket to BOOTPC port.
    287 	 */
    288 	if (bind(s, (struct sockaddr *) &sin_client, sizeof(sin_client)) < 0) {
    289 		perror("bind BOOTPC port");
    290 		if (errno == EACCES)
    291 			fprintf(stderr, "You need to run this as root\n");
    292 		exit(1);
    293 	}
    294 	/*
    295 	 * Build a request.
    296 	 */
    297 	bp = (struct bootp *) sndbuf;
    298 	bzero(bp, sizeof(*bp));
    299 	bp->bp_op = BOOTREQUEST;
    300 	xid = (int32) getpid();
    301 	bp->bp_xid = (u_int32) htonl(xid);
    302 	if (bp_file)
    303 		strlcpy(bp->bp_file, bp_file, sizeof(bp->bp_file));
    304 
    305 	/*
    306 	 * Fill in the hardware address (or client IP address)
    307 	 */
    308 	if (use_hwa) {
    309 		struct ifreq *ifr;
    310 
    311 		ifr = getif(s, &sin_server.sin_addr);
    312 		if (!ifr) {
    313 			printf("No interface for %s\n", servername);
    314 			exit(1);
    315 		}
    316 		if (getether(ifr->ifr_name, (char *)eaddr)) {
    317 			printf("Can not get ether addr for %s\n", ifr->ifr_name);
    318 			exit(1);
    319 		}
    320 		/* Copy Ethernet address into request packet. */
    321 		bp->bp_htype = 1;
    322 		bp->bp_hlen = 6;
    323 		bcopy(eaddr, bp->bp_chaddr, bp->bp_hlen);
    324 	} else {
    325 		/* Fill in the client IP address. */
    326 		gethostname(hostname, sizeof(hostname));
    327 		hostname[sizeof(hostname) - 1] = '\0';
    328 		hep = gethostbyname(hostname);
    329 		if (!hep) {
    330 			printf("Can not get my IP address\n");
    331 			exit(1);
    332 		}
    333 		bcopy(hep->h_addr, &bp->bp_ciaddr, hep->h_length);
    334 	}
    335 
    336 	/*
    337 	 * Copy in the default vendor data.
    338 	 */
    339 	bcopy((char*)&vend_magic, bp->bp_vend, 4);
    340 	if (vend_magic)
    341 		bp->bp_vend[4] = TAG_END;
    342 
    343 	/*
    344 	 * Read in the "options" part of the request.
    345 	 * This also determines the size of the packet.
    346 	 */
    347 	snaplen = sizeof(*bp);
    348 	if (vendor_file) {
    349 		int fd = open(vendor_file, 0);
    350 		if (fd < 0) {
    351 			perror(vendor_file);
    352 			exit(1);
    353 		}
    354 		/* Compute actual space for options. */
    355 		n = BUFLEN - sizeof(*bp) + BP_VEND_LEN;
    356 		n = read(fd, bp->bp_vend, n);
    357 		close(fd);
    358 		if (n < 0) {
    359 			perror(vendor_file);
    360 			exit(1);
    361 		}
    362 		printf("read %d bytes of vendor template\n", n);
    363 		if (n > BP_VEND_LEN) {
    364 			printf("warning: extended options in use (len > %d)\n",
    365 				   BP_VEND_LEN);
    366 			snaplen += (n - BP_VEND_LEN);
    367 		}
    368 	}
    369 	/*
    370 	 * Set globals needed by print_bootp
    371 	 * (called by send_request)
    372 	 */
    373 	packetp = (unsigned char *) eaddr;
    374 	snapend = (unsigned char *) sndbuf + snaplen;
    375 
    376 	/* Send a request once per second while waiting for replies. */
    377 	recvcnt = 0;
    378 	bp->bp_secs = secs = 0;
    379 	send_request(s);
    380 	set[0].fd = s;
    381 	set[0].events = POLLIN;
    382 	while (1) {
    383 		n = poll(set, 1, WAITSECS * 1000);
    384 		if (n < 0) {
    385 			perror("poll");
    386 			break;
    387 		}
    388 		if (n == 0) {
    389 			/*
    390 			 * We have not received a response in the last second.
    391 			 * If we have ever received any responses, exit now.
    392 			 * Otherwise, bump the "wait time" field and re-send.
    393 			 */
    394 			if (recvcnt > 0)
    395 				exit(0);
    396 			secs += WAITSECS;
    397 			if (secs > MAXWAIT)
    398 				break;
    399 			bp->bp_secs = htons(secs);
    400 			send_request(s);
    401 			continue;
    402 		}
    403 		fromlen = sizeof(sin_from);
    404 		n = recvfrom(s, rcvbuf, BUFLEN, 0,
    405 					 (struct sockaddr *) &sin_from, &fromlen);
    406 		if (n <= 0) {
    407 			continue;
    408 		}
    409 		if (n < sizeof(struct bootp)) {
    410 			printf("received short packet\n");
    411 			continue;
    412 		}
    413 		recvcnt++;
    414 
    415 		/* Print the received packet. */
    416 		printf("Recvd from %s", inet_ntoa(sin_from.sin_addr));
    417 		/* set globals needed by bootp_print() */
    418 		snaplen = n;
    419 		snapend = (unsigned char *) rcvbuf + snaplen;
    420 		bootp_print((struct bootp *)rcvbuf, n, sin_from.sin_port, 0);
    421 		putchar('\n');
    422 		/*
    423 		 * This no longer exits immediately after receiving
    424 		 * one response because it is useful to know if the
    425 		 * client might get multiple responses.  This code
    426 		 * will now listen for one second after a response.
    427 		 */
    428 	}
    429 	fprintf(stderr, "no response from %s\n", servername);
    430 	exit(1);
    431 }
    432 
    433 void
    434 send_request(int s)
    435 {
    436 	/* Print the request packet. */
    437 	printf("Sending to %s", inet_ntoa(sin_server.sin_addr));
    438 	bootp_print((struct bootp *)sndbuf, snaplen, sin_from.sin_port, 0);
    439 	putchar('\n');
    440 
    441 	/* Send the request packet. */
    442 	if (sendto(s, sndbuf, snaplen, 0,
    443 			   (struct sockaddr *) &sin_server,
    444 			   sizeof(sin_server)) < 0)
    445 	{
    446 		perror("sendto server");
    447 		exit(1);
    448 	}
    449 }
    450 
    451 /*
    452  * Print out a filename (or other ascii string).
    453  * Return true if truncated.
    454  */
    455 int
    456 printfn(u_char *s, u_char *ep)
    457 {
    458 	u_char c;
    459 
    460 	putchar('"');
    461 	while ((c = *s++) != 0) {
    462 		if (s > ep) {
    463 			putchar('"');
    464 			return (1);
    465 		}
    466 		if (!isascii(c)) {
    467 			c = toascii(c);
    468 			putchar('M');
    469 			putchar('-');
    470 		}
    471 		if (!isprint(c)) {
    472 			c ^= 0x40;			/* DEL to ?, others to alpha */
    473 			putchar('^');
    474 		}
    475 		putchar(c);
    476 	}
    477 	putchar('"');
    478 	return (0);
    479 }
    480 
    481 /*
    482  * Convert an IP addr to a string.
    483  * (like inet_ntoa, but ina is a pointer)
    484  */
    485 char *
    486 ipaddr_string(struct in_addr *ina)
    487 {
    488 	static char b[24];
    489 	u_char *p;
    490 
    491 	p = (u_char *) ina;
    492 	snprintf(b, sizeof(b), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
    493 	return (b);
    494 }
    495 
    496 /*
    497  * Local Variables:
    498  * tab-width: 4
    499  * c-indent-level: 4
    500  * c-argdecl-indent: 4
    501  * c-continued-statement-offset: 4
    502  * c-continued-brace-offset: -4
    503  * c-label-offset: -4
    504  * c-brace-offset: 0
    505  * End:
    506  */
    507