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 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 <err.h>
56 #include <stdlib.h>
57 #include <signal.h>
58 #include <stdio.h>
59 #include <string.h>
60 #include <errno.h>
61 #include <ctype.h>
62 #include <netdb.h>
63 #include <assert.h>
64
65 #include "bootp.h"
66 #include "bootptest.h"
67 #include "getif.h"
68 #include "getether.h"
69
70 #include "patchlevel.h"
71
72 static void send_request(int s);
73
74 #define LOG_ERR 1
75 #define BUFLEN 1024
76 #define WAITSECS 1
77 #define MAXWAIT 10
78
79 int vflag = 1;
80 int tflag = 0;
81 int thiszone;
82 char *progname;
83 unsigned char *packetp;
84 unsigned char *snapend;
85 int snaplen;
86
87
88 /*
89 * IP port numbers for client and server obtained from /etc/services
90 */
91
92 u_short bootps_port, bootpc_port;
93
94
95 /*
96 * Internet socket and interface config structures
97 */
98
99 struct sockaddr_in sin_server; /* where to send requests */
100 struct sockaddr_in sin_client; /* for bind and listen */
101 struct sockaddr_in sin_from; /* Packet source */
102 u_char eaddr[16]; /* Ethernet address */
103
104 /*
105 * General
106 */
107
108 int debug = 1; /* Debugging flag (level) */
109 char *sndbuf; /* Send packet buffer */
110 char *rcvbuf; /* Receive packet buffer */
111
112 struct utsname my_uname;
113 char *hostname;
114
115 /*
116 * Vendor magic cookies for CMU and RFC1048
117 */
118
119 unsigned char vm_cmu[4] = VM_CMU;
120 unsigned char vm_rfc1048[4] = VM_RFC1048;
121 short secs; /* How long client has waited */
122
123 /*
124 * Initialization such as command-line processing is done, then
125 * the receiver loop is started. Die when interrupted.
126 */
127
128 int
main(int argc,char ** argv)129 main(int argc, char **argv)
130 {
131 struct bootp *bp;
132 struct servent *sep;
133 struct hostent *hep;
134
135 char *servername = NULL;
136 char *vendor_file = NULL;
137 char *bp_file = NULL;
138 int32 server_addr; /* inet addr, network order */
139 int s; /* Socket file descriptor */
140 int n, fromlen, recvcnt;
141 int use_hwa = 0;
142 int32 vend_magic;
143 int32 xid;
144
145 progname = strrchr(argv[0], '/');
146 if (progname)
147 progname++;
148 else
149 progname = argv[0];
150 argc--;
151 argv++;
152
153 if (debug)
154 printf("%s: version %s.%d\n", progname, VERSION, PATCHLEVEL);
155
156 /*
157 * Verify that "struct bootp" has the correct official size.
158 * (Catch evil compilers that do struct padding.)
159 */
160 assert(sizeof(struct bootp) == BP_MINPKTSZ);
161
162 if (uname(&my_uname) < 0)
163 errx(1, "can't get hostname");
164 hostname = my_uname.nodename;
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 puts(usage);
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 puts(usage);
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 warnx("bootps/udp: unknown service -- using port %d",
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 (isdigit(servername[0]))
251 server_addr = inet_addr(servername);
252 else {
253 hep = gethostbyname(servername);
254 if (!hep)
255 errx(1, "%s: unknown host", servername);
256 bcopy(hep->h_addr, &server_addr, sizeof(server_addr));
257 }
258 } else {
259 /* Get broadcast address */
260 /* XXX - not yet */
261 server_addr = INADDR_ANY;
262 }
263 sin_server.sin_family = AF_INET;
264 sin_server.sin_port = htons(bootps_port);
265 sin_server.sin_addr.s_addr = server_addr;
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 warnx("bootpc/udp: unknown service -- using port %d",
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 if (errno == EACCES) {
291 warn("bind BOOTPC port");
292 errx(1, "you need to run this as root");
293 }
294 else
295 err(1, "bind BOOTPC port");
296 }
297 /*
298 * Build a request.
299 */
300 bp = (struct bootp *) sndbuf;
301 bzero(bp, sizeof(*bp));
302 bp->bp_op = BOOTREQUEST;
303 xid = (int32) getpid();
304 bp->bp_xid = (u_int32) htonl(xid);
305 if (bp_file)
306 strncpy(bp->bp_file, bp_file, BP_FILE_LEN);
307
308 /*
309 * Fill in the hardware address (or client IP address)
310 */
311 if (use_hwa) {
312 struct ifreq *ifr;
313
314 ifr = getif(s, &sin_server.sin_addr);
315 if (!ifr) {
316 printf("No interface for %s\n", servername);
317 exit(1);
318 }
319 if (getether(ifr->ifr_name, (char*)eaddr)) {
320 printf("Can not get ether addr for %s\n", ifr->ifr_name);
321 exit(1);
322 }
323 /* Copy Ethernet address into request packet. */
324 bp->bp_htype = 1;
325 bp->bp_hlen = 6;
326 bcopy(eaddr, bp->bp_chaddr, bp->bp_hlen);
327 } else {
328 /* Fill in the client IP address. */
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 while (1) {
382 struct timeval tv;
383 int readfds;
384
385 tv.tv_sec = WAITSECS;
386 tv.tv_usec = 0L;
387 readfds = (1 << s);
388 n = select(s + 1, (fd_set *) & readfds, NULL, NULL, &tv);
389 if (n < 0) {
390 perror("select");
391 break;
392 }
393 if (n == 0) {
394 /*
395 * We have not received a response in the last second.
396 * If we have ever received any responses, exit now.
397 * Otherwise, bump the "wait time" field and re-send.
398 */
399 if (recvcnt > 0)
400 exit(0);
401 secs += WAITSECS;
402 if (secs > MAXWAIT)
403 break;
404 bp->bp_secs = htons(secs);
405 send_request(s);
406 continue;
407 }
408 fromlen = sizeof(sin_from);
409 n = recvfrom(s, rcvbuf, BUFLEN, 0,
410 (struct sockaddr *) &sin_from, &fromlen);
411 if (n <= 0) {
412 continue;
413 }
414 if (n < sizeof(struct bootp)) {
415 printf("received short packet\n");
416 continue;
417 }
418 recvcnt++;
419
420 /* Print the received packet. */
421 printf("Recvd from %s", inet_ntoa(sin_from.sin_addr));
422 /* set globals needed by bootp_print() */
423 snaplen = n;
424 snapend = (unsigned char *) rcvbuf + snaplen;
425 bootp_print((struct bootp *)rcvbuf, n, sin_from.sin_port, 0);
426 putchar('\n');
427 /*
428 * This no longer exits immediately after receiving
429 * one response because it is useful to know if the
430 * client might get multiple responses. This code
431 * will now listen for one second after a response.
432 */
433 }
434 errx(1, "no response from %s", servername);
435 }
436
437 static void
send_request(int s)438 send_request(int s)
439 {
440 /* Print the request packet. */
441 printf("Sending to %s", inet_ntoa(sin_server.sin_addr));
442 bootp_print((struct bootp *)sndbuf, snaplen, sin_from.sin_port, 0);
443 putchar('\n');
444
445 /* Send the request packet. */
446 if (sendto(s, sndbuf, snaplen, 0,
447 (struct sockaddr *) &sin_server,
448 sizeof(sin_server)) < 0)
449 {
450 perror("sendto server");
451 exit(1);
452 }
453 }
454
455 /*
456 * Print out a filename (or other ascii string).
457 * Return true if truncated.
458 */
459 int
printfn(u_char * s,u_char * ep)460 printfn(u_char *s, u_char *ep)
461 {
462 u_char c;
463
464 putchar('"');
465 while ((c = *s++) != '\0') {
466 if (s > ep) {
467 putchar('"');
468 return (1);
469 }
470 if (!isascii(c)) {
471 c = toascii(c);
472 putchar('M');
473 putchar('-');
474 }
475 if (!isprint(c)) {
476 c ^= 0x40; /* DEL to ?, others to alpha */
477 putchar('^');
478 }
479 putchar(c);
480 }
481 putchar('"');
482 return (0);
483 }
484
485 /*
486 * Convert an IP addr to a string.
487 * (like inet_ntoa, but ina is a pointer)
488 */
489 char *
ipaddr_string(struct in_addr * ina)490 ipaddr_string(struct in_addr *ina)
491 {
492 static char b[24];
493 u_char *p;
494
495 p = (u_char *) ina;
496 snprintf(b, sizeof(b), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
497 return (b);
498 }
499
500 /*
501 * Local Variables:
502 * tab-width: 4
503 * c-indent-level: 4
504 * c-argdecl-indent: 4
505 * c-continued-statement-offset: 4
506 * c-continued-brace-offset: -4
507 * c-label-offset: -4
508 * c-brace-offset: 0
509 * End:
510 */
511