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
main(int argc,char ** argv)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
send_request(int s)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
printfn(u_char * s,u_char * ep)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 *
ipaddr_string(struct in_addr * ina)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