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