NetBSD-5.0.2/usr.sbin/bootp/bootptest/bootptest.c
/* $NetBSD: bootptest.c,v 1.17 2008/05/02 19:22:10 xtraeme Exp $ */
/*
* bootptest.c - Test out a bootp server.
*
* This simple program was put together from pieces taken from
* various places, including the CMU BOOTP client and server.
* The packet printing routine is from the Berkeley "tcpdump"
* program with some enhancements I added. The print-bootp.c
* file was shared with my copy of "tcpdump" and therefore uses
* some unusual utility routines that would normally be provided
* by various parts of the tcpdump program. Gordon W. Ross
*
* Boilerplate:
*
* This program includes software developed by the University of
* California, Lawrence Berkeley Laboratory and its contributors.
* (See the copyright notice in print-bootp.c)
*
* The remainder of this program is public domain. You may do
* whatever you like with it except claim that you wrote it.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* HISTORY:
*
* 12/02/93 Released version 1.4 (with bootp-2.3.2)
* 11/05/93 Released version 1.3
* 10/14/93 Released version 1.2
* 10/11/93 Released version 1.1
* 09/28/93 Released version 1.0
* 09/93 Original developed by Gordon W. Ross <gwr@mc.com>
*/
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: bootptest.c,v 1.17 2008/05/02 19:22:10 xtraeme Exp $");
#endif
const char *usage = "usage: %s [-f bootfile] [-h] [-m magic_number] server-name\n"
" [vendor-data-template-file]\n";
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h> /* inet_ntoa */
#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <ctype.h>
#include <netdb.h>
#include <assert.h>
#include <unistd.h>
#include "bootp.h"
#include "bootptest.h"
#include "getif.h"
#include "report.h"
#include "patchlevel.h"
#define LOG_ERR 1
#define BUFLEN 1024
#define WAITSECS 1
#define MAXWAIT 10
int vflag = 1;
int tflag = 0;
int thiszone;
char *progname;
unsigned char *packetp;
unsigned char *snapend;
int snaplen;
/*
* IP port numbers for client and server obtained from /etc/services
*/
u_short bootps_port, bootpc_port;
/*
* Internet socket and interface config structures
*/
struct sockaddr_in sin_server; /* where to send requests */
struct sockaddr_in sin_client; /* for bind and listen */
struct sockaddr_in sin_from; /* Packet source */
u_char eaddr[16]; /* Ethernet address */
/*
* General
*/
int debug = 1; /* Debugging flag (level) */
char hostname[MAXHOSTNAMELEN + 1];
char *sndbuf; /* Send packet buffer */
char *rcvbuf; /* Receive packet buffer */
/*
* Vendor magic cookies for CMU and RFC1048
*/
unsigned char vm_cmu[4] = VM_CMU;
unsigned char vm_rfc1048[4] = VM_RFC1048;
short secs; /* How long client has waited */
extern int getether(char *, char *);
int main(int, char **);
void send_request(int);
/*
* Initialization such as command-line processing is done, then
* the receiver loop is started. Die when interrupted.
*/
int
main(int argc, char **argv)
{
struct bootp *bp;
struct servent *sep;
struct hostent *hep;
char *servername = NULL;
char *vendor_file = NULL;
char *bp_file = NULL;
socklen_t fromlen;
int s; /* Socket file descriptor */
int n, recvcnt;
int use_hwa = 0;
int32 vend_magic;
int32 xid;
struct pollfd set[1];
progname = strrchr(argv[0], '/');
if (progname)
progname++;
else
progname = argv[0];
argc--;
argv++;
if (debug)
printf("%s: version %s.%d\n", progname, VERSION, PATCHLEVEL);
/*
* Verify that "struct bootp" has the correct official size.
* (Catch evil compilers that do struct padding.)
*/
assert(sizeof(struct bootp) == BP_MINPKTSZ);
sndbuf = malloc(BUFLEN);
rcvbuf = malloc(BUFLEN);
if (!sndbuf || !rcvbuf) {
printf("malloc failed\n");
exit(1);
}
/* default magic number */
bcopy(vm_rfc1048, (char*)&vend_magic, 4);
/* Handle option switches. */
while (argc > 0) {
if (argv[0][0] != '-')
break;
switch (argv[0][1]) {
case 'f': /* File name to reqest. */
if (argc < 2)
goto error;
argc--; argv++;
bp_file = *argv;
break;
case 'h': /* Use hardware address. */
use_hwa = 1;
break;
case 'm': /* Magic number value. */
if (argc < 2)
goto error;
argc--; argv++;
vend_magic = inet_addr(*argv);
break;
error:
default:
(void)fprintf(stderr, usage, getprogname());
exit(1);
}
argc--;
argv++;
}
/* Get server name (or address) for query. */
if (argc > 0) {
servername = *argv;
argc--;
argv++;
}
/* Get optional vendor-data-template-file. */
if (argc > 0) {
vendor_file = *argv;
argc--;
argv++;
}
if (!servername) {
printf("missing server name.\n");
(void)fprintf(stderr, usage, getprogname());
exit(1);
}
/*
* Create a socket.
*/
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket");
exit(1);
}
/*
* Get server's listening port number
*/
sep = getservbyname("bootps", "udp");
if (sep) {
bootps_port = ntohs((u_short) sep->s_port);
} else {
fprintf(stderr, "udp/bootps: unknown service -- using port %d\n",
IPPORT_BOOTPS);
bootps_port = (u_short) IPPORT_BOOTPS;
}
/*
* Set up server socket address (for send)
*/
if (servername) {
if (inet_aton(servername, &sin_server.sin_addr) == 0) {
hep = gethostbyname(servername);
if (!hep) {
fprintf(stderr, "%s: unknown host\n", servername);
exit(1);
}
memcpy(&sin_server.sin_addr, hep->h_addr,
sizeof(sin_server.sin_addr));
}
} else {
/* Get broadcast address */
/* XXX - not yet */
sin_server.sin_addr.s_addr = INADDR_ANY;
}
sin_server.sin_family = AF_INET;
sin_server.sin_port = htons(bootps_port);
/*
* Get client's listening port number
*/
sep = getservbyname("bootpc", "udp");
if (sep) {
bootpc_port = ntohs(sep->s_port);
} else {
fprintf(stderr, "udp/bootpc: unknown service -- using port %d\n",
IPPORT_BOOTPC);
bootpc_port = (u_short) IPPORT_BOOTPC;
}
/*
* Set up client socket address (for listen)
*/
sin_client.sin_family = AF_INET;
sin_client.sin_port = htons(bootpc_port);
sin_client.sin_addr.s_addr = INADDR_ANY;
/*
* Bind client socket to BOOTPC port.
*/
if (bind(s, (struct sockaddr *) &sin_client, sizeof(sin_client)) < 0) {
perror("bind BOOTPC port");
if (errno == EACCES)
fprintf(stderr, "You need to run this as root\n");
exit(1);
}
/*
* Build a request.
*/
bp = (struct bootp *) sndbuf;
bzero(bp, sizeof(*bp));
bp->bp_op = BOOTREQUEST;
xid = (int32) getpid();
bp->bp_xid = (u_int32) htonl(xid);
if (bp_file)
strlcpy(bp->bp_file, bp_file, sizeof(bp->bp_file));
/*
* Fill in the hardware address (or client IP address)
*/
if (use_hwa) {
struct ifreq *ifr;
ifr = getif(s, &sin_server.sin_addr);
if (!ifr) {
printf("No interface for %s\n", servername);
exit(1);
}
if (getether(ifr->ifr_name, (char *)eaddr)) {
printf("Can not get ether addr for %s\n", ifr->ifr_name);
exit(1);
}
/* Copy Ethernet address into request packet. */
bp->bp_htype = 1;
bp->bp_hlen = 6;
bcopy(eaddr, bp->bp_chaddr, bp->bp_hlen);
} else {
/* Fill in the client IP address. */
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname) - 1] = '\0';
hep = gethostbyname(hostname);
if (!hep) {
printf("Can not get my IP address\n");
exit(1);
}
bcopy(hep->h_addr, &bp->bp_ciaddr, hep->h_length);
}
/*
* Copy in the default vendor data.
*/
bcopy((char*)&vend_magic, bp->bp_vend, 4);
if (vend_magic)
bp->bp_vend[4] = TAG_END;
/*
* Read in the "options" part of the request.
* This also determines the size of the packet.
*/
snaplen = sizeof(*bp);
if (vendor_file) {
int fd = open(vendor_file, 0);
if (fd < 0) {
perror(vendor_file);
exit(1);
}
/* Compute actual space for options. */
n = BUFLEN - sizeof(*bp) + BP_VEND_LEN;
n = read(fd, bp->bp_vend, n);
close(fd);
if (n < 0) {
perror(vendor_file);
exit(1);
}
printf("read %d bytes of vendor template\n", n);
if (n > BP_VEND_LEN) {
printf("warning: extended options in use (len > %d)\n",
BP_VEND_LEN);
snaplen += (n - BP_VEND_LEN);
}
}
/*
* Set globals needed by print_bootp
* (called by send_request)
*/
packetp = (unsigned char *) eaddr;
snapend = (unsigned char *) sndbuf + snaplen;
/* Send a request once per second while waiting for replies. */
recvcnt = 0;
bp->bp_secs = secs = 0;
send_request(s);
set[0].fd = s;
set[0].events = POLLIN;
while (1) {
n = poll(set, 1, WAITSECS * 1000);
if (n < 0) {
perror("poll");
break;
}
if (n == 0) {
/*
* We have not received a response in the last second.
* If we have ever received any responses, exit now.
* Otherwise, bump the "wait time" field and re-send.
*/
if (recvcnt > 0)
exit(0);
secs += WAITSECS;
if (secs > MAXWAIT)
break;
bp->bp_secs = htons(secs);
send_request(s);
continue;
}
fromlen = sizeof(sin_from);
n = recvfrom(s, rcvbuf, BUFLEN, 0,
(struct sockaddr *) &sin_from, &fromlen);
if (n <= 0) {
continue;
}
if (n < sizeof(struct bootp)) {
printf("received short packet\n");
continue;
}
recvcnt++;
/* Print the received packet. */
printf("Recvd from %s", inet_ntoa(sin_from.sin_addr));
/* set globals needed by bootp_print() */
snaplen = n;
snapend = (unsigned char *) rcvbuf + snaplen;
bootp_print((struct bootp *)rcvbuf, n, sin_from.sin_port, 0);
putchar('\n');
/*
* This no longer exits immediately after receiving
* one response because it is useful to know if the
* client might get multiple responses. This code
* will now listen for one second after a response.
*/
}
fprintf(stderr, "no response from %s\n", servername);
exit(1);
}
void
send_request(int s)
{
/* Print the request packet. */
printf("Sending to %s", inet_ntoa(sin_server.sin_addr));
bootp_print((struct bootp *)sndbuf, snaplen, sin_from.sin_port, 0);
putchar('\n');
/* Send the request packet. */
if (sendto(s, sndbuf, snaplen, 0,
(struct sockaddr *) &sin_server,
sizeof(sin_server)) < 0)
{
perror("sendto server");
exit(1);
}
}
/*
* Print out a filename (or other ascii string).
* Return true if truncated.
*/
int
printfn(u_char *s, u_char *ep)
{
u_char c;
putchar('"');
while ((c = *s++) != 0) {
if (s > ep) {
putchar('"');
return (1);
}
if (!isascii(c)) {
c = toascii(c);
putchar('M');
putchar('-');
}
if (!isprint(c)) {
c ^= 0x40; /* DEL to ?, others to alpha */
putchar('^');
}
putchar(c);
}
putchar('"');
return (0);
}
/*
* Convert an IP addr to a string.
* (like inet_ntoa, but ina is a pointer)
*/
char *
ipaddr_string(struct in_addr *ina)
{
static char b[24];
u_char *p;
p = (u_char *) ina;
snprintf(b, sizeof(b), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
return (b);
}
/*
* Local Variables:
* tab-width: 4
* c-indent-level: 4
* c-argdecl-indent: 4
* c-continued-statement-offset: 4
* c-continued-brace-offset: -4
* c-label-offset: -4
* c-brace-offset: 0
* End:
*/