libexec/bootpd/tools/bootptest/bootptest.c

   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  * $DragonFly: src/libexec/bootpd/tools/bootptest/bootptest.c,v 1.2 2003/06/17 04:27:07 dillon Exp $
  36  */
  37
  38 char *usage = "bootptest [-h] server-name [vendor-data-template-file]";
  39
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/file.h>
  44 #include <sys/time.h>
  45 #include <sys/stat.h>
  46 #include <sys/utsname.h>
  47
  48 #include <net/if.h>
  49 #include <netinet/in.h>
  50 #include <arpa/inet.h>                  /* inet_ntoa */
  51
  52 #ifndef NO_UNISTD
  53 #include <unistd.h>
  54 #endif
  55
  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();
  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 char *get_errmsg();
 124 extern void bootp_print();
 125
 126 /*
 127  * Initialization such as command-line processing is done, then
 128  * the receiver loop is started.  Die when interrupted.
 129  */
 130
 131 int
 132 main(argc, argv)
 133         int argc;
 134         char **argv;
 135 {
 136         struct bootp *bp;
 137         struct servent *sep;
 138         struct hostent *hep;
 139
 140         char *servername = NULL;
 141         char *vendor_file = NULL;
 142         char *bp_file = NULL;
 143         int32 server_addr;                      /* inet addr, network order */
 144         int s;                                          /* Socket file descriptor */
 145         int n, fromlen, recvcnt;
 146         int use_hwa = 0;
 147         int32 vend_magic;
 148         int32 xid;
 149
 150         progname = strrchr(argv[0], '/');
 151         if (progname)
 152                 progname++;
 153         else
 154                 progname = argv[0];
 155         argc--;
 156         argv++;
 157
 158         if (debug)
 159                 printf("%s: version %s.%d\n", progname, VERSION, PATCHLEVEL);
 160
 161         /*
 162          * Verify that "struct bootp" has the correct official size.
 163          * (Catch evil compilers that do struct padding.)
 164          */
 165         assert(sizeof(struct bootp) == BP_MINPKTSZ);
 166
 167         if (uname(&my_uname) < 0) {
 168                 fprintf(stderr, "%s: can't get hostname\n", argv[0]);
 169                 exit(1);
 170         }
 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 reqest. */
 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                 fprintf(stderr, "udp/bootps: unknown service -- using port %d\n",
 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                                 fprintf(stderr, "%s: unknown host\n", servername);
 263                                 exit(1);
 264                         }
 265                         bcopy(hep->h_addr, &server_addr, sizeof(server_addr));
 266                 }
 267         } else {
 268                 /* Get broadcast address */
 269                 /* XXX - not yet */
 270                 server_addr = INADDR_ANY;
 271         }
 272         sin_server.sin_family = AF_INET;
 273         sin_server.sin_port = htons(bootps_port);
 274         sin_server.sin_addr.s_addr = server_addr;
 275
 276         /*
 277          * Get client's listening port number
 278          */
 279         sep = getservbyname("bootpc", "udp");
 280         if (sep) {
 281                 bootpc_port = ntohs(sep->s_port);
 282         } else {
 283                 fprintf(stderr, "udp/bootpc: unknown service -- using port %d\n",
 284                                 IPPORT_BOOTPC);
 285                 bootpc_port = (u_short) IPPORT_BOOTPC;
 286         }
 287
 288         /*
 289          * Set up client socket address (for listen)
 290          */
 291         sin_client.sin_family = AF_INET;
 292         sin_client.sin_port = htons(bootpc_port);
 293         sin_client.sin_addr.s_addr = INADDR_ANY;
 294
 295         /*
 296          * Bind client socket to BOOTPC port.
 297          */
 298         if (bind(s, (struct sockaddr *) &sin_client, sizeof(sin_client)) < 0) {
 299                 perror("bind BOOTPC port");
 300                 if (errno == EACCES)
 301                         fprintf(stderr, "You need to run this as root\n");
 302                 exit(1);
 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         fprintf(stderr, "no response from %s\n", servername);
 442         exit(1);
 443 }
 444
 445 static void
 446 send_request(s)
 447         int s;
 448 {
 449         /* Print the request packet. */
 450         printf("Sending to %s", inet_ntoa(sin_server.sin_addr));
 451         bootp_print(sndbuf, snaplen, sin_from.sin_port, 0);
 452         putchar('\n');
 453
 454         /* Send the request packet. */
 455         if (sendto(s, sndbuf, snaplen, 0,
 456                            (struct sockaddr *) &sin_server,
 457                            sizeof(sin_server)) < 0)
 458         {
 459                 perror("sendto server");
 460                 exit(1);
 461         }
 462 }
 463
 464 /*
 465  * Print out a filename (or other ascii string).
 466  * Return true if truncated.
 467  */
 468 int
 469 printfn(s, ep)
 470         register u_char *s, *ep;
 471 {
 472         register u_char c;
 473
 474         putchar('"');
 475         while ((c = *s++) != '\0') {
 476                 if (s > ep) {
 477                         putchar('"');
 478                         return (1);
 479                 }
 480                 if (!isascii(c)) {
 481                         c = toascii(c);
 482                         putchar('M');
 483                         putchar('-');
 484                 }
 485                 if (!isprint(c)) {
 486                         c ^= 0x40;                      /* DEL to ?, others to alpha */
 487                         putchar('^');
 488                 }
 489                 putchar(c);
 490         }
 491         putchar('"');
 492         return (0);
 493 }
 494
 495 /*
 496  * Convert an IP addr to a string.
 497  * (like inet_ntoa, but ina is a pointer)
 498  */
 499 char *
 500 ipaddr_string(ina)
 501         struct in_addr *ina;
 502 {
 503         static char b[24];
 504         u_char *p;
 505
 506         p = (u_char *) ina;
 507         snprintf(b, sizeof(b), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
 508         return (b);
 509 }
 510
 511 /*
 512  * Local Variables:
 513  * tab-width: 4
 514  * c-indent-level: 4
 515  * c-argdecl-indent: 4
 516  * c-continued-statement-offset: 4
 517  * c-continued-brace-offset: -4
 518  * c-label-offset: -4
 519  * c-brace-offset: 0
 520  * End:
 521  */