[unix-history] / usr / src / usr.bin / tftp / main.c

/*	main.c	4.5	82/12/25	*/

/*
 * TFTP User Program -- Command Interface.
 */
#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>

#include <signal.h>
#include <stdio.h>
#include <errno.h>
#include <setjmp.h>
#include <ctype.h>
#include <netdb.h>

struct	sockaddr_in sin;
int	f;
int	trace;
int	verbose;
int	connected;
char	mode[32];
char	line[200];
int	margc;
char	*margv[20];
char	*prompt = "tftp";
jmp_buf	toplevel;
int	intr();
struct	servent *sp;

int	quit(), help(), setverbose(), settrace(), status();
int	get(), put(), setpeer(), setmode();

#define HELPINDENT (sizeof("connect"))

struct cmd {
	char	*name;
	char	*help;
	int	(*handler)();
};

char	vhelp[] = "toggle verbose mode";
char	thelp[] = "toggle packet tracing";
char	chelp[] = "connect to remote tftp";
char	qhelp[] = "exit tftp";
char	hhelp[] = "print help information";
char	shelp[] = "send file";
char	rhelp[] = "receive file";
char	mhelp[] = "set file transfer mode";
char	sthelp[] = "show current status";

struct cmd cmdtab[] = {
	{ "connect",	chelp,		setpeer },
	{ "mode",	mhelp,		setmode },
	{ "put",	shelp,		put },
	{ "get",	rhelp,		get },
	{ "quit",	qhelp,		quit },
	{ "verbose",	vhelp,		setverbose },
	{ "trace",	thelp,		settrace },
	{ "status",	sthelp,		status },
	{ "?",		hhelp,		help },
	0
};

struct	cmd *getcmd();
char	*tail();
char	*index();
char	*rindex();

main(argc, argv)
	char *argv[];
{
	sp = getservbyname("tftp", "udp");
	if (sp == 0) {
		fprintf(stderr, "tftp: udp/tftp: unknown service\n");
		exit(1);
	}
	f = socket(AF_INET, SOCK_DGRAM, 0, 0);
	if (f < 0) {
		perror("socket");
		exit(3);
	}
	strcpy(mode, "netascii");
	if (argc > 1) {
		if (setjmp(toplevel) != 0)
			exit(0);
		setpeer(argc, argv);
	}
	setjmp(toplevel);
	for (;;)
		command(1);
}

char	*hostname;
char	hnamebuf[32];

setpeer(argc, argv)
	int argc;
	char *argv[];
{
	register int c;
	struct hostent *host;

	if (argc < 2) {
		strcpy(line, "Connect ");
		printf("(to) ");
		gets(&line[strlen(line)]);
		makeargv();
		argc = margc;
		argv = margv;
	}
	if (argc > 3) {
		printf("usage: %s host-name [port]\n", argv[0]);
		return;
	}
	host = gethostbyname(argv[1]);
	if (host) {
		sin.sin_family = host->h_addrtype;
		bcopy(host->h_addr, &sin.sin_addr, host->h_length);
		hostname = host->h_name;
	} else {
		sin.sin_family = AF_INET;
		sin.sin_addr.s_addr = inet_addr(argv[1]);
		if (sin.sin_addr.s_addr == -1) {
			connected = 0;
			printf("%s: unknown host\n", argv[1]);
			return;
		}
		strcpy(hnamebuf, argv[1]);
		hostname = hnamebuf;
	}
	sin.sin_port = sp->s_port;
	if (argc == 3) {
		sin.sin_port = atoi(argv[2]);
		if (sin.sin_port < 0) {
			printf("%s: bad port number\n", argv[2]);
			connected = 0;
			return;
		}
		sin.sin_port = htons((u_short)sin.sin_port);
	}
	connected = 1;
}

struct	modes {
	char *m_name;
	char *m_mode;
} modes[] = {
	{ "ascii",	"netascii" },
	{ "binary",	"octect" },
	{ "mail",	"mail" },
	{ 0,		0 }
};

setmode(argc, argv)
	char *argv[];
{
	register struct modes *p;

	if (argc > 2) {
		char *sep;

		printf("usage: %s [", argv[0]);
		sep = " ";
		for (p = modes; p->m_name; p++) {
			printf("%s%s", sep, p->m_name);
			if (*sep == ' ')
				sep = " | ";
		}
		printf(" ]\n");
		return;
	}
	if (argc < 2) {
		printf("Using %s mode to transfer files.\n", mode);
		return;
	}
	for (p = modes; p->m_name; p++)
		if (strcmp(argv[1], p->m_name) == 0)
			break;
	if (p->m_name)
		strcpy(mode, p->m_mode);
	else
		printf("%s: unknown mode\n", argv[1]);
}

/*
 * Send file(s).
 */
put(argc, argv)
	char *argv[];
{
	int fd;
	register int n, addr;
	register char *cp, *targ;

	if (argc < 2) {
		strcpy(line, "send ");
		printf("(file) ");
		gets(&line[strlen(line)]);
		makeargv();
		argc = margc;
		argv = margv;
	}
	if (argc < 2) {
		putusage(argv[0]);
		return;
	}
	targ = argv[argc - 1];
	if (index(argv[argc - 1], ':')) {
		char *cp;
		struct hostent *hp;

		for (n = 1; n < argc - 1; n++)
			if (index(argv[n], ':')) {
				putusage(argv[0]);
				return;
			}
		cp = argv[argc - 1];
		targ = index(cp, ':');
		*targ++ = 0;
		hp = gethostbyname(cp);
		if (hp == 0) {
			printf("%s: Unknown host.\n", cp);
			return;
		}
		bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
		sin.sin_family = hp->h_addrtype;
		connected = 1;
		hostname = hp->h_name;
	}
	if (!connected) {
		printf("No target machine specified.\n");
		return;
	}
	sigset(SIGINT, intr);
	if (argc < 4) {
		cp = argc == 2 ? tail(targ) : argv[1];
		fd = open(cp);
		if (fd < 0) {
			perror(cp);
			return;
		}
		sendfile(fd, targ);
		return;
	}
	cp = index(targ, '\0'); 
	*cp++ = '/';
	for (n = 1; n < argc - 1; n++) {
		strcpy(cp, tail(argv[n]));
		fd = open(argv[n], 0);
		if (fd < 0) {
			perror(argv[n]);
			continue;
		}
		sendfile(fd, targ);
	}
}

putusage(s)
	char *s;
{
	printf("usage: %s file ... host:target, or\n", s);
	printf("       %s file ... target (when already connected)\n", s);
}

/*
 * Receive file(s).
 */
get(argc, argv)
	char *argv[];
{
	int fd;
	register int n, addr;
	register char *cp;
	char *src;

	if (argc < 2) {
		strcpy(line, "get ");
		printf("(files) ");
		gets(&line[strlen(line)]);
		makeargv();
		argc = margc;
		argv = margv;
	}
	if (argc < 2) {
		getusage(argv[0]);
		return;
	}
	if (!connected)
		for (n = 1; n < argc - 1; n++)
			if (index(argv[n], ':') == 0) {
				getusage(argv[0]);
				return;
			}
	sigset(SIGINT, intr);
	for (n = 1; argc == 2 || n < argc - 1; n++) {
		src = index(argv[n], ':');
		if (src == NULL)
			src = argv[n];
		else {
			struct hostent *hp;

			*src++ = 0;
			hp = gethostbyname(argv[n]);
			if (hp == 0) {
				printf("%s: Unknown host.\n", argv[n]);
				continue;
			}
			bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
			sin.sin_family = hp->h_addrtype;
			connected = 1;
			hostname = hp->h_name;
		}
		if (argc < 4) {
			cp = argc == 3 ? argv[2] : tail(src);
			fd = creat(cp, 0644);
			if (fd < 0) {
				perror(cp);
				return;
			}
			recvfile(fd, src);
			break;
		}
		cp = index(argv[argc - 1], '\0');
		*cp++ = '/';
		strcpy(cp, tail(src));
		fd = creat(src, 0644);
		if (fd < 0) {
			perror(src);
			continue;
		}
		recvfile(fd, src);
	}
}

getusage(s)
{
	printf("usage: %s host:file host:file ... file, or\n", s);
	printf("       %s file file ... file if connected\n", s);
}

status(argc, argv)
	char *argv[];
{
	if (connected)
		printf("Connected to %s.\n", hostname);
	else
		printf("Not connected.\n");
	printf("Mode: %s Verbose: %s Tracing: %s\n", mode,
		verbose ? "on" : "off", trace ? "on" : "off");
}

intr()
{
	longjmp(toplevel, -1);
}

char *
tail(filename)
	char *filename;
{
	register char *s;
	
	while (*filename) {
		s = rindex(filename, '/');
		if (s == NULL)
			break;
		if (s[1])
			return (s + 1);
		*s = '\0';
	}
	return (filename);
}

/*
 * Command parser.
 */
command(top)
	int top;
{
	register struct cmd *c;

	if (!top)
		putchar('\n');
	else
		sigset(SIGINT, SIG_DFL);
	for (;;) {
		printf("%s> ", prompt);
		if (gets(line) == 0)
			break;
		if (line[0] == 0)
			break;
		makeargv();
		c = getcmd(margv[0]);
		if (c == (struct cmd *)-1) {
			printf("?Ambiguous command\n");
			continue;
		}
		if (c == 0) {
			printf("?Invalid command\n");
			continue;
		}
		(*c->handler)(margc, margv);
		if (c->handler != help)
			break;
	}
	longjmp(toplevel, 1);
}

struct cmd *
getcmd(name)
	register char *name;
{
	register char *p, *q;
	register struct cmd *c, *found;
	register int nmatches, longest;

	longest = 0;
	nmatches = 0;
	found = 0;
	for (c = cmdtab; p = c->name; c++) {
		for (q = name; *q == *p++; q++)
			if (*q == 0)		/* exact match? */
				return (c);
		if (!*q) {			/* the name was a prefix */
			if (q - name > longest) {
				longest = q - name;
				nmatches = 1;
				found = c;
			} else if (q - name == longest)
				nmatches++;
		}
	}
	if (nmatches > 1)
		return ((struct cmd *)-1);
	return (found);
}

/*
 * Slice a string up into argc/argv.
 */
makeargv()
{
	register char *cp;
	register char **argp = margv;

	margc = 0;
	for (cp = line; *cp;) {
		while (isspace(*cp))
			cp++;
		if (*cp == '\0')
			break;
		*argp++ = cp;
		margc += 1;
		while (*cp != '\0' && !isspace(*cp))
			cp++;
		if (*cp == '\0')
			break;
		*cp++ = '\0';
	}
	*argp++ = 0;
}

/*VARARGS*/
quit()
{
	exit(0);
}

/*
 * Help command.
 */
help(argc, argv)
	int argc;
	char *argv[];
{
	register struct cmd *c;

	if (argc == 1) {
		printf("Commands may be abbreviated.  Commands are:\n\n");
		for (c = cmdtab; c->name; c++)
			printf("%-*s\t%s\n", HELPINDENT, c->name, c->help);
		return;
	}
	while (--argc > 0) {
		register char *arg;
		arg = *++argv;
		c = getcmd(arg);
		if (c == (struct cmd *)-1)
			printf("?Ambiguous help command %s\n", arg);
		else if (c == (struct cmd *)0)
			printf("?Invalid help command %s\n", arg);
		else
			printf("%s\n", c->help);
	}
}

/*
 * Call routine with argc, argv set from args (terminated by 0).
 */
/* VARARGS2 */
call(routine, args)
	int (*routine)();
	int args;
{
	register int *argp;
	register int argc;

	for (argc = 0, argp = &args; *argp++ != 0; argc++)
		;
	(*routine)(argc, &args);
}

/*VARARGS*/
settrace()
{
	trace = !trace;
	printf("Packet tracing %s.\n", trace ? "on" : "off");
}

/*VARARGS*/
setverbose()
{
	verbose = !verbose;
	printf("Verbose mode %s.\n", verbose ? "on" : "off");
}
Commit	Line	Data
26d9d18d	1	/* main.c 4.5 82/12/25 */
c3353d83 SL	2
	3	/*
	4	* TFTP User Program -- Command Interface.
	5	*/
	6	#include <sys/types.h>
c3353d83	7	#include <sys/socket.h>
de3b21e8 SL	8
	9	#include <netinet/in.h>
	10
c3353d83 SL	11	#include <signal.h>
	12	#include <stdio.h>
	13	#include <errno.h>
	14	#include <setjmp.h>
	15	#include <ctype.h>
4d5e33bd	16	#include <netdb.h>
c3353d83	17
de3b21e8	18	struct sockaddr_in sin;
c3353d83	19	int f;
c3353d83 SL	20	int trace;
	21	int verbose;
	22	int connected;
	23	char mode[32];
	24	char line[200];
	25	int margc;
	26	char *margv[20];
	27	char *prompt = "tftp";
	28	jmp_buf toplevel;
	29	int intr();
4d5e33bd	30	struct servent *sp;
c3353d83 SL	31
	32	int quit(), help(), setverbose(), settrace(), status();
	33	int get(), put(), setpeer(), setmode();
	34
	35	#define HELPINDENT (sizeof("connect"))
	36
	37	struct cmd {
	38	char *name;
	39	char *help;
	40	int (*handler)();
	41	};
	42
	43	char vhelp[] = "toggle verbose mode";
	44	char thelp[] = "toggle packet tracing";
	45	char chelp[] = "connect to remote tftp";
	46	char qhelp[] = "exit tftp";
	47	char hhelp[] = "print help information";
	48	char shelp[] = "send file";
	49	char rhelp[] = "receive file";
	50	char mhelp[] = "set file transfer mode";
	51	char sthelp[] = "show current status";
	52
	53	struct cmd cmdtab[] = {
	54	{ "connect", chelp, setpeer },
	55	{ "mode", mhelp, setmode },
	56	{ "put", shelp, put },
	57	{ "get", rhelp, get },
	58	{ "quit", qhelp, quit },
	59	{ "verbose", vhelp, setverbose },
	60	{ "trace", thelp, settrace },
	61	{ "status", sthelp, status },
	62	{ "?", hhelp, help },
	63	0
	64	};
	65
	66	struct cmd *getcmd();
	67	char *tail();
	68	char *index();
	69	char *rindex();
	70
	71	main(argc, argv)
	72	char *argv[];
	73	{
4d5e33bd SL	74	sp = getservbyname("tftp", "udp");
	75	if (sp == 0) {
	76	fprintf(stderr, "tftp: udp/tftp: unknown service\n");
	77	exit(1);
	78	}
85b11450	79	f = socket(AF_INET, SOCK_DGRAM, 0, 0);
c3353d83 SL	80	if (f < 0) {
	81	perror("socket");
	82	exit(3);
	83	}
c3353d83 SL	84	strcpy(mode, "netascii");
	85	if (argc > 1) {
	86	if (setjmp(toplevel) != 0)
	87	exit(0);
	88	setpeer(argc, argv);
	89	}
	90	setjmp(toplevel);
	91	for (;;)
	92	command(1);
	93	}
	94
4d5e33bd SL	95	char *hostname;
4d5e33bd SL	96	char hnamebuf[32];
c3353d83 SL	97
	98	setpeer(argc, argv)
	99	int argc;
	100	char *argv[];
	101	{
	102	register int c;
4d5e33bd	103	struct hostent *host;
c3353d83 SL	104
	105	if (argc < 2) {
	106	strcpy(line, "Connect ");
	107	printf("(to) ");
	108	gets(&line[strlen(line)]);
	109	makeargv();
	110	argc = margc;
	111	argv = margv;
	112	}
	113	if (argc > 3) {
	114	printf("usage: %s host-name [port]\n", argv[0]);
	115	return;
	116	}
4d5e33bd SL	117	host = gethostbyname(argv[1]);
4d5e33bd SL	118	if (host) {
de3b21e8	119	sin.sin_family = host->h_addrtype;
4d5e33bd SL	120	bcopy(host->h_addr, &sin.sin_addr, host->h_length);
	121	hostname = host->h_name;
	122	} else {
de3b21e8	123	sin.sin_family = AF_INET;
4d5e33bd SL	124	sin.sin_addr.s_addr = inet_addr(argv[1]);
	125	if (sin.sin_addr.s_addr == -1) {
	126	connected = 0;
	127	printf("%s: unknown host\n", argv[1]);
	128	return;
	129	}
	130	strcpy(hnamebuf, argv[1]);
	131	hostname = hnamebuf;
c3353d83	132	}
4d5e33bd	133	sin.sin_port = sp->s_port;
c3353d83 SL	134	if (argc == 3) {
	135	sin.sin_port = atoi(argv[2]);
	136	if (sin.sin_port < 0) {
	137	printf("%s: bad port number\n", argv[2]);
	138	connected = 0;
	139	return;
	140	}
26d9d18d	141	sin.sin_port = htons((u_short)sin.sin_port);
4d5e33bd	142	}
c3353d83 SL	143	connected = 1;
	144	}
	145
	146	struct modes {
	147	char *m_name;
	148	char *m_mode;
	149	} modes[] = {
	150	{ "ascii", "netascii" },
	151	{ "binary", "octect" },
	152	{ "mail", "mail" },
	153	{ 0, 0 }
	154	};
	155
	156	setmode(argc, argv)
	157	char *argv[];
	158	{
	159	register struct modes *p;
	160
	161	if (argc > 2) {
	162	char *sep;
	163
	164	printf("usage: %s [", argv[0]);
	165	sep = " ";
	166	for (p = modes; p->m_name; p++) {
	167	printf("%s%s", sep, p->m_name);
	168	if (*sep == ' ')
	169	sep = " \| ";
	170	}
	171	printf(" ]\n");
	172	return;
	173	}
	174	if (argc < 2) {
	175	printf("Using %s mode to transfer files.\n", mode);
	176	return;
	177	}
	178	for (p = modes; p->m_name; p++)
	179	if (strcmp(argv[1], p->m_name) == 0)
	180	break;
	181	if (p->m_name)
	182	strcpy(mode, p->m_mode);
	183	else
	184	printf("%s: unknown mode\n", argv[1]);
	185	}
	186
	187	/*
	188	* Send file(s).
	189	*/
	190	put(argc, argv)
	191	char *argv[];
	192	{
	193	int fd;
	194	register int n, addr;
	195	register char cp, targ;
	196
	197	if (argc < 2) {
	198	strcpy(line, "send ");
	199	printf("(file) ");
	200	gets(&line[strlen(line)]);
	201	makeargv();
	202	argc = margc;
	203	argv = margv;
	204	}
	205	if (argc < 2) {
	206	putusage(argv[0]);
207	return;
208	}
209	targ = argv[argc - 1];
210	if (index(argv[argc - 1], ':')) {
4d5e33bd SL	211	char *cp;
4d5e33bd SL	212	struct hostent *hp;
c3353d83 SL	213
	214	for (n = 1; n < argc - 1; n++)
	215	if (index(argv[n], ':')) {
	216	putusage(argv[0]);
	217	return;
	218	}
4d5e33bd SL	219	cp = argv[argc - 1];
4d5e33bd SL	220	targ = index(cp, ':');
c3353d83	221	*targ++ = 0;
4d5e33bd SL	222	hp = gethostbyname(cp);
	223	if (hp == 0) {
	224	printf("%s: Unknown host.\n", cp);
c3353d83 SL	225	return;
c3353d83 SL	226	}
de3b21e8	227	bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
4d5e33bd	228	sin.sin_family = hp->h_addrtype;
c3353d83	229	connected = 1;
4d5e33bd	230	hostname = hp->h_name;
c3353d83 SL	231	}
	232	if (!connected) {
	233	printf("No target machine specified.\n");
	234	return;
	235	}
	236	sigset(SIGINT, intr);
	237	if (argc < 4) {
	238	cp = argc == 2 ? tail(targ) : argv[1];
	239	fd = open(cp);
	240	if (fd < 0) {
	241	perror(cp);
	242	return;
	243	}
	244	sendfile(fd, targ);
	245	return;
	246	}
	247	cp = index(targ, '\0');
	248	*cp++ = '/';
	249	for (n = 1; n < argc - 1; n++) {
	250	strcpy(cp, tail(argv[n]));
	251	fd = open(argv[n], 0);
	252	if (fd < 0) {
	253	perror(argv[n]);
	254	continue;
	255	}
	256	sendfile(fd, targ);
	257	}
	258	}
	259
	260	putusage(s)
	261	char *s;
	262	{
	263	printf("usage: %s file ... host:target, or\n", s);
	264	printf(" %s file ... target (when already connected)\n", s);
	265	}
	266
	267	/*
	268	* Receive file(s).
	269	*/
	270	get(argc, argv)
	271	char *argv[];
	272	{
	273	int fd;
	274	register int n, addr;
	275	register char *cp;
	276	char *src;
	277
	278	if (argc < 2) {
	279	strcpy(line, "get ");
	280	printf("(files) ");
	281	gets(&line[strlen(line)]);
	282	makeargv();
	283	argc = margc;
	284	argv = margv;
	285	}
	286	if (argc < 2) {
	287	getusage(argv[0]);
	288	return;
	289	}
	290	if (!connected)
	291	for (n = 1; n < argc - 1; n++)
	292	if (index(argv[n], ':') == 0) {
	293	getusage(argv[0]);
	294	return;
295	}
296	sigset(SIGINT, intr);
297	for (n = 1; argc == 2 \|\| n < argc - 1; n++) {
298	src = index(argv[n], ':');
299	if (src == NULL)
300	src = argv[n];
301	else {
4d5e33bd SL	302	struct hostent *hp;
4d5e33bd SL	303
c3353d83	304	*src++ = 0;
4d5e33bd SL	305	hp = gethostbyname(argv[n]);
4d5e33bd SL	306	if (hp == 0) {
c3353d83 SL	307	printf("%s: Unknown host.\n", argv[n]);
	308	continue;
	309	}
de3b21e8	310	bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
4d5e33bd	311	sin.sin_family = hp->h_addrtype;
c3353d83	312	connected = 1;
4d5e33bd	313	hostname = hp->h_name;
c3353d83 SL	314	}
	315	if (argc < 4) {
	316	cp = argc == 3 ? argv[2] : tail(src);
	317	fd = creat(cp, 0644);
	318	if (fd < 0) {
	319	perror(cp);
	320	return;
	321	}
	322	recvfile(fd, src);
	323	break;
	324	}
	325	cp = index(argv[argc - 1], '\0');
	326	*cp++ = '/';
	327	strcpy(cp, tail(src));
	328	fd = creat(src, 0644);
	329	if (fd < 0) {
	330	perror(src);
	331	continue;
	332	}
	333	recvfile(fd, src);
	334	}
	335	}
	336
	337	getusage(s)
	338	{
	339	printf("usage: %s host:file host:file ... file, or\n", s);
	340	printf(" %s file file ... file if connected\n", s);
	341	}
	342
	343	status(argc, argv)
	344	char *argv[];
	345	{
	346	if (connected)
4d5e33bd	347	printf("Connected to %s.\n", hostname);
c3353d83 SL	348	else
	349	printf("Not connected.\n");
	350	printf("Mode: %s Verbose: %s Tracing: %s\n", mode,
	351	verbose ? "on" : "off", trace ? "on" : "off");
	352	}
	353
	354	intr()
	355	{
	356	longjmp(toplevel, -1);
	357	}
	358
	359	char *
	360	tail(filename)
	361	char *filename;
	362	{
	363	register char *s;
	364
	365	while (*filename) {
	366	s = rindex(filename, '/');
	367	if (s == NULL)
	368	break;
	369	if (s[1])
	370	return (s + 1);
	371	*s = '\0';
	372	}
	373	return (filename);
	374	}
	375
	376	/*
	377	* Command parser.
	378	*/
	379	command(top)
	380	int top;
	381	{
	382	register struct cmd *c;
	383
	384	if (!top)
	385	putchar('\n');
	386	else
	387	sigset(SIGINT, SIG_DFL);
	388	for (;;) {
	389	printf("%s> ", prompt);
	390	if (gets(line) == 0)
	391	break;
	392	if (line[0] == 0)
	393	break;
	394	makeargv();
	395	c = getcmd(margv[0]);
	396	if (c == (struct cmd *)-1) {
	397	printf("?Ambiguous command\n");
	398	continue;
	399	}
	400	if (c == 0) {
	401	printf("?Invalid command\n");
	402	continue;
	403	}
	404	(*c->handler)(margc, margv);
	405	if (c->handler != help)
	406	break;
	407	}
	408	longjmp(toplevel, 1);
	409	}
	410
	411	struct cmd *
412	getcmd(name)
413	register char *name;
414	{
415	register char p, q;
416	register struct cmd c, found;
417	register int nmatches, longest;
418
419	longest = 0;
420	nmatches = 0;
421	found = 0;
422	for (c = cmdtab; p = c->name; c++) {
423	for (q = name; q == p++; q++)
424	if (q == 0) / exact match? */
425	return (c);
426	if (!q) { / the name was a prefix */
427	if (q - name > longest) {
428	longest = q - name;
429	nmatches = 1;
430	found = c;
431	} else if (q - name == longest)
432	nmatches++;
433	}
434	}
435	if (nmatches > 1)
436	return ((struct cmd *)-1);
437	return (found);
438	}
439
440	/*
441	* Slice a string up into argc/argv.
442	*/
443	makeargv()
444	{
445	register char *cp;
446	register char **argp = margv;
447
448	margc = 0;
449	for (cp = line; *cp;) {
450	while (isspace(*cp))
451	cp++;
452	if (*cp == '\0')
453	break;
454	*argp++ = cp;
455	margc += 1;
456	while (cp != '\0' && !isspace(cp))
457	cp++;
458	if (*cp == '\0')
459	break;
460	*cp++ = '\0';
461	}
462	*argp++ = 0;
463	}
464
465	/VARARGS/
466	quit()
467	{
468	exit(0);
469	}
470
471	/*
472	* Help command.
c3353d83 SL	473	*/
	474	help(argc, argv)
	475	int argc;
	476	char *argv[];
	477	{
	478	register struct cmd *c;
	479
	480	if (argc == 1) {
	481	printf("Commands may be abbreviated. Commands are:\n\n");
	482	for (c = cmdtab; c->name; c++)
	483	printf("%-*s\t%s\n", HELPINDENT, c->name, c->help);
	484	return;
	485	}
	486	while (--argc > 0) {
	487	register char *arg;
	488	arg = *++argv;
	489	c = getcmd(arg);
	490	if (c == (struct cmd *)-1)
	491	printf("?Ambiguous help command %s\n", arg);
	492	else if (c == (struct cmd *)0)
	493	printf("?Invalid help command %s\n", arg);
	494	else
	495	printf("%s\n", c->help);
	496	}
	497	}
	498
	499	/*
	500	* Call routine with argc, argv set from args (terminated by 0).
	501	*/
	502	/* VARARGS2 */
	503	call(routine, args)
	504	int (*routine)();
	505	int args;
	506	{
	507	register int *argp;
	508	register int argc;
	509
	510	for (argc = 0, argp = &args; *argp++ != 0; argc++)
	511	;
	512	(*routine)(argc, &args);
	513	}
	514
	515	/VARARGS/
	516	settrace()
	517	{
	518	trace = !trace;
	519	printf("Packet tracing %s.\n", trace ? "on" : "off");
	520	}
	521
	522	/VARARGS/
	523	setverbose()
	524	{
	525	verbose = !verbose;
	526	printf("Verbose mode %s.\n", verbose ? "on" : "off");
	527	}