xref: /titanic_52/usr/src/cmd/cmd-inet/usr.bin/ftp/cmds.c (revision 9e39c5ba00a55fa05777cc94b148296af305e135)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  *	Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23  *	Use is subject to license terms.
24  */
25 
26 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	All Rights Reserved  	*/
28 
29 /*
30  *	University Copyright- Copyright (c) 1982, 1986, 1988
31  *	The Regents of the University of California
32  *	All Rights Reserved
33  *
34  *	University Acknowledgment- Portions of this document are derived from
35  *	software developed by the University of California, Berkeley, and its
36  *	contributors.
37  */
38 
39 #pragma ident	"%Z%%M%	%I%	%E% SMI"
40 
41 
42 /*
43  * FTP User Program -- Command Routines.
44  */
45 #define	FTP_NAMES
46 #include "ftp_var.h"
47 
48 FILE	*tmp_nlst = NULL;	/* tmp file; holds NLST results for mget, etc */
49 
50 static char *mname;
51 static jmp_buf jabort;
52 static jmp_buf abortprox;
53 
54 static char *remglob(char *argv[], int doswitch);
55 static char *onoff(int bool);
56 static int confirm(char *cmd, char *file);
57 static int globulize(char **cpp);
58 static void proxabort(int sig);
59 static void mabort(int sig);
60 static char *dotrans(char *name);
61 static char *domap(char *name);
62 static void getit(int argc, char *argv[], int restartit, char *mode);
63 
64 static char *getlevel(int);
65 
66 /* Prompt for command argument, add to buffer with space separator */
67 static int
68 prompt_for_arg(char *buffer, int buffer_size, char *prompt)
69 {
70 	if (strlen(buffer) > buffer_size - 2) {
71 		(void) printf("Line too long\n");
72 		return (-1);
73 	}
74 	strcat(buffer, " ");
75 	stop_timer();
76 	(void) printf("(%s) ", prompt);
77 	if (fgets(buffer + strlen(buffer), buffer_size - strlen(buffer), stdin)
78 	    == NULL) {
79 		reset_timer();
80 		return (-1);
81 	}
82 
83 	/* Flush what didn't fit in the buffer */
84 	if (buffer[strlen(buffer)-1] != '\n') {
85 		while (fgetc(stdin) != '\n' && !ferror(stdin) && !feof(stdin))
86 			;
87 		(void) printf("Line too long\n");
88 		reset_timer();
89 		return (-1);
90 	} else
91 		buffer[strlen(buffer)-1] = 0;
92 
93 	reset_timer();
94 	return (0);
95 }
96 
97 
98 /*
99  * Connect to peer server and
100  * auto-login, if possible.
101  */
102 void
103 setpeer(int argc, char *argv[])
104 {
105 	char *host;
106 
107 	if (connected) {
108 		(void) printf("Already connected to %s, use close first.\n",
109 			hostname);
110 		code = -1;
111 		return;
112 	}
113 	if (argc < 2) {
114 		if (prompt_for_arg(line, sizeof (line), "to") == -1) {
115 			code = -1;
116 			return;
117 		}
118 		makeargv();
119 		argc = margc;
120 		argv = margv;
121 	}
122 	if (argc > 3 || argc < 2) {
123 		(void) printf("usage: %s host-name [port]\n", argv[0]);
124 		code = -1;
125 		return;
126 	}
127 	strcpy(typename, "ascii");
128 	host = hookup(argv[1], (argc > 2 ? argv[2] : "ftp"));
129 	if (host) {
130 		int overbose;
131 		extern char reply_string[];
132 
133 		connected = 1;
134 		/*
135 		 * Set up defaults for FTP.
136 		 */
137 		clevel = dlevel = PROT_C;
138 		if (autoauth) {
139 			if (do_auth() && autoencrypt) {
140 			    clevel = PROT_P;
141 			    setpbsz(1<<20);
142 			    if (command("PROT P") == COMPLETE)
143 				dlevel = PROT_P;
144 			    else {
145 				(void) fprintf(stderr,
146 					"%s: couldn't enable encryption\n",
147 					argv[0]);
148 				/* unable to encrypt command channel, too! */
149 				dlevel = clevel = PROT_C;
150 			    }
151 			}
152 			if ((auth_type != AUTHTYPE_NONE) && (clevel == PROT_C))
153 				clevel = PROT_S;
154 		}
155 
156 		if (autologin)
157 			(void) login(argv[1]);
158 		/* if skipsyst is enabled, then don't send SYST command */
159 		if (skipsyst)
160 			return;
161 
162 		overbose = verbose;
163 		if (debug == 0)
164 			verbose = -1;
165 		if (command("SYST") == COMPLETE && overbose) {
166 			char *cp, c;
167 
168 			cp = index(reply_string+4, ' ');
169 			if (cp == NULL)
170 				cp = index(reply_string+4, '\r');
171 			if (cp) {
172 				if (cp[-1] == '.')
173 					cp--;
174 				c = *cp;
175 				*cp = '\0';
176 			}
177 
178 			(void) printf("Remote system type is %s.\n",
179 				reply_string+4);
180 			if (cp)
181 				*cp = c;
182 		}
183 		if (strncmp(reply_string, "215 UNIX Type: L8", 17) == 0) {
184 			setbinary(0, NULL);
185 			if (overbose)
186 				(void) printf(
187 				    "Using %s mode to transfer files.\n",
188 				    typename);
189 		} else if (overbose &&
190 		    strncmp(reply_string, "215 TOPS20", 10) == 0) {
191 			(void) printf(
192 			    "Remember to set tenex mode when transfering "
193 			    "binary files from this machine.\n");
194 		}
195 		verbose = overbose;
196 	}
197 }
198 
199 static struct types {
200 	char	*t_name;
201 	char	*t_mode;
202 	int	t_type;
203 	char	*t_arg;
204 } types[] = {
205 	{ "ascii",	"A",	TYPE_A,	0 },
206 	{ "binary",	"I",	TYPE_I,	0 },
207 	{ "image",	"I",	TYPE_I,	0 },
208 	{ "ebcdic",	"E",	TYPE_E,	0 },
209 	{ "tenex",	"L",	TYPE_L,	bytename },
210 	0
211 };
212 
213 /*
214  * Set transfer type.
215  */
216 void
217 settype(int argc, char *argv[])
218 {
219 	struct types *p;
220 	int comret;
221 
222 	if (argc > 2) {
223 		char *sep;
224 
225 		(void) printf("usage: %s [", argv[0]);
226 		sep = " ";
227 		for (p = types; p->t_name; p++) {
228 			(void) printf("%s%s", sep, p->t_name);
229 			if (*sep == ' ')
230 				sep = " | ";
231 		}
232 		(void) printf(" ]\n");
233 		code = -1;
234 		return;
235 	}
236 	if (argc < 2) {
237 		(void) printf("Using %s mode to transfer files.\n", typename);
238 		code = 0;
239 		return;
240 	}
241 	for (p = types; p->t_name; p++)
242 		if (strcmp(argv[1], p->t_name) == 0)
243 			break;
244 	if (p->t_name == 0) {
245 		(void) printf("%s: unknown mode\n", argv[1]);
246 		code = -1;
247 		return;
248 	}
249 	if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
250 		comret = command("TYPE %s %s", p->t_mode, p->t_arg);
251 	else
252 		comret = command("TYPE %s", p->t_mode);
253 	if (comret == COMPLETE) {
254 		(void) strcpy(typename, p->t_name);
255 		type = p->t_type;
256 	}
257 }
258 
259 /*
260  * Set binary transfer type.
261  */
262 /*ARGSUSED*/
263 void
264 setbinary(int argc, char *argv[])
265 {
266 	call(settype, "type", "binary", 0);
267 }
268 
269 /*
270  * Set ascii transfer type.
271  */
272 /*ARGSUSED*/
273 void
274 setascii(int argc, char *argv[])
275 {
276 	call(settype, "type", "ascii", 0);
277 }
278 
279 /*
280  * Set tenex transfer type.
281  */
282 /*ARGSUSED*/
283 void
284 settenex(int argc, char *argv[])
285 {
286 	call(settype, "type", "tenex", 0);
287 }
288 
289 /*
290  * Set ebcdic transfer type.
291  */
292 /*ARGSUSED*/
293 void
294 setebcdic(int argc, char *argv[])
295 {
296 	call(settype, "type", "ebcdic", 0);
297 }
298 
299 /*
300  * Set file transfer mode.
301  */
302 /*ARGSUSED*/
303 void
304 setmode(int argc, char *argv[])
305 {
306 	(void) printf("We only support %s mode, sorry.\n", modename);
307 	code = -1;
308 }
309 
310 /*
311  * Set file transfer format.
312  */
313 /*ARGSUSED*/
314 void
315 setform(int argc, char *argv[])
316 {
317 	(void) printf("We only support %s format, sorry.\n", formname);
318 	code = -1;
319 }
320 
321 /*
322  * Set file transfer structure.
323  */
324 /*ARGSUSED*/
325 void
326 setstruct(int argc, char *argv[])
327 {
328 
329 	(void) printf("We only support %s structure, sorry.\n", structname);
330 	code = -1;
331 }
332 
333 /*
334  * Send a single file.
335  */
336 void
337 put(int argc, char *argv[])
338 {
339 	char *cmd;
340 	int loc = 0;
341 	char *oldargv1;
342 
343 	if (argc == 2) {
344 		argc++;
345 		argv[2] = argv[1];
346 		loc++;
347 	}
348 	if (argc < 2) {
349 		if (prompt_for_arg(line, sizeof (line), "local-file") == -1) {
350 			code = -1;
351 			return;
352 		}
353 		makeargv();
354 		argc = margc;
355 		argv = margv;
356 	}
357 	if (argc < 2) {
358 usage:
359 		(void) printf("usage: %s local-file remote-file\n", argv[0]);
360 		code = -1;
361 		return;
362 	}
363 	if (argc < 3) {
364 		if (prompt_for_arg(line, sizeof (line), "remote-file") == -1) {
365 			code = -1;
366 			return;
367 		}
368 		makeargv();
369 		argc = margc;
370 		argv = margv;
371 	}
372 	if (argc < 3)
373 		goto usage;
374 	oldargv1 = argv[1];
375 	if (!globulize(&argv[1])) {
376 		code = -1;
377 		return;
378 	}
379 	/*
380 	 * If "globulize" modifies argv[1], and argv[2] is a copy of
381 	 * the old argv[1], make it a copy of the new argv[1].
382 	 */
383 	if (argv[1] != oldargv1 && argv[2] == oldargv1) {
384 		argv[2] = argv[1];
385 	}
386 	cmd = (argv[0][0] == 'a') ? "APPE" : ((sunique) ? "STOU" : "STOR");
387 	if (loc && ntflag) {
388 		argv[2] = dotrans(argv[2]);
389 	}
390 	if (loc && mapflag) {
391 		argv[2] = domap(argv[2]);
392 	}
393 	sendrequest(cmd, argv[1], argv[2], 1);
394 }
395 
396 /*ARGSUSED*/
397 static void
398 mabort(int sig)
399 {
400 	int ointer;
401 
402 	(void) printf("\n");
403 	(void) fflush(stdout);
404 	if (mflag && fromatty) {
405 		ointer = interactive;
406 		interactive = 1;
407 		if (confirm("Continue with", mname)) {
408 			interactive = ointer;
409 			longjmp(jabort, 0);
410 		}
411 		interactive = ointer;
412 	}
413 	mflag = 0;
414 	longjmp(jabort, 0);
415 }
416 
417 /*
418  * Send multiple files.
419  */
420 void
421 mput(int argc, char *argv[])
422 {
423 	int i;
424 	int ointer;
425 	void (*oldintr)();
426 	char *tp;
427 	int	len;
428 
429 	if (argc < 2) {
430 		if (prompt_for_arg(line, sizeof (line), "local-files") == -1) {
431 			code = -1;
432 			return;
433 		}
434 		makeargv();
435 		argc = margc;
436 		argv = margv;
437 	}
438 	if (argc < 2) {
439 		(void) printf("usage: %s local-files\n", argv[0]);
440 		code = -1;
441 		return;
442 	}
443 	mname = argv[0];
444 	mflag = 1;
445 	oldintr = signal(SIGINT, mabort);
446 	(void) setjmp(jabort);
447 	if (proxy) {
448 		char *cp, *tp2, tmpbuf[MAXPATHLEN];
449 
450 		while ((cp = remglob(argv, 0)) != NULL) {
451 			if (*cp == 0) {
452 				mflag = 0;
453 				continue;
454 			}
455 			if (mflag && confirm(argv[0], cp)) {
456 				tp = cp;
457 				if (mcase) {
458 					while (*tp) {
459 						if ((len =
460 						    mblen(tp, MB_CUR_MAX)) <= 0)
461 							len = 1;
462 						if (islower(*tp))
463 							break;
464 						tp += len;
465 					}
466 					if (!*tp) {
467 						tp = cp;
468 						tp2 = tmpbuf;
469 						while (*tp) {
470 							if ((len = mblen(tp,
471 							    MB_CUR_MAX)) <= 0)
472 								len = 1;
473 							memcpy(tp2, tp, len);
474 							if (isupper(*tp2)) {
475 								*tp2 = 'a' +
476 								    *tp2 - 'A';
477 							}
478 							tp += len;
479 							tp2 += len;
480 						}
481 						*tp2 = 0;
482 						tp = tmpbuf;
483 					}
484 				}
485 				if (ntflag) {
486 					tp = dotrans(tp);
487 				}
488 				if (mapflag) {
489 					tp = domap(tp);
490 				}
491 				sendrequest((sunique) ? "STOU" : "STOR",
492 				    cp, tp, 0);
493 				if (!mflag && fromatty) {
494 					ointer = interactive;
495 					interactive = 1;
496 					if (confirm("Continue with", "mput")) {
497 						mflag++;
498 					}
499 					interactive = ointer;
500 				}
501 			}
502 		}
503 		(void) signal(SIGINT, oldintr);
504 		mflag = 0;
505 		return;
506 	}
507 	for (i = 1; i < argc; i++) {
508 		char **cpp, **gargs;
509 
510 		if (!doglob) {
511 			if (mflag && confirm(argv[0], argv[i])) {
512 				tp = (ntflag) ? dotrans(argv[i]) : argv[i];
513 				tp = (mapflag) ? domap(tp) : tp;
514 				sendrequest((sunique) ? "STOU" : "STOR",
515 				    argv[i], tp, 1);
516 				if (!mflag && fromatty) {
517 					ointer = interactive;
518 					interactive = 1;
519 					if (confirm("Continue with", "mput")) {
520 						mflag++;
521 					}
522 					interactive = ointer;
523 				}
524 			}
525 			continue;
526 		}
527 		gargs = glob(argv[i]);
528 		if (globerr != NULL) {
529 			(void) printf("%s\n", globerr);
530 			if (gargs)
531 				blkfree(gargs);
532 			continue;
533 		}
534 		for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
535 			if (mflag && confirm(argv[0], *cpp)) {
536 				tp = (ntflag) ? dotrans(*cpp) : *cpp;
537 				tp = (mapflag) ? domap(tp) : tp;
538 				sendrequest((sunique) ? "STOU" : "STOR",
539 				    *cpp, tp, 0);
540 				if (!mflag && fromatty) {
541 					ointer = interactive;
542 					interactive = 1;
543 					if (confirm("Continue with", "mput")) {
544 						mflag++;
545 					}
546 					interactive = ointer;
547 				}
548 			}
549 		}
550 		if (gargs != NULL)
551 			blkfree(gargs);
552 	}
553 	(void) signal(SIGINT, oldintr);
554 	mflag = 0;
555 }
556 
557 /*
558  * Restart transfer at a specific offset.
559  */
560 void
561 restart(int argc, char *argv[])
562 {
563 	off_t orestart_point = restart_point;
564 
565 	if (argc > 2) {
566 		(void) printf("usage: %s [marker]\n", argv[0]);
567 		code = -1;
568 		return;
569 	}
570 	if (argc == 2) {
571 		longlong_t rp;
572 		char *endp;
573 
574 		errno = 0;
575 		rp = strtoll(argv[1], &endp, 10);
576 		if (errno || rp < 0 || *endp != '\0')
577 			(void) printf("%s: Invalid offset `%s'\n",
578 				argv[0], argv[1]);
579 		else
580 			restart_point = rp;
581 	}
582 	if (restart_point == 0) {
583 		if (orestart_point == 0)
584 			(void) printf("No restart marker defined\n");
585 		else
586 			(void) printf("Restart marker cleared\n");
587 	} else
588 		(void) printf(
589 			"Restarting at %lld for next get, put or append\n",
590 			(longlong_t)restart_point);
591 }
592 
593 void
594 reget(int argc, char *argv[])
595 {
596 	getit(argc, argv, 1, "r+w");
597 }
598 
599 void
600 get(int argc, char *argv[])
601 {
602 	getit(argc, argv, 0, restart_point ? "r+w" : "w");
603 }
604 
605 /*
606  * Receive one file.
607  */
608 static void
609 getit(int argc, char *argv[], int restartit, char *mode)
610 {
611 	int loc = 0;
612 	int len;
613 	int allowpipe = 1;
614 
615 	if (argc == 2) {
616 		argc++;
617 		argv[2] = argv[1];
618 		/* Only permit !file if two arguments. */
619 		allowpipe = 0;
620 		loc++;
621 	}
622 	if (argc < 2) {
623 		if (prompt_for_arg(line, sizeof (line), "remote-file") == -1) {
624 			code = -1;
625 			return;
626 		}
627 		makeargv();
628 		argc = margc;
629 		argv = margv;
630 	}
631 	if (argc < 2) {
632 usage:
633 		(void) printf("usage: %s remote-file [ local-file ]\n",
634 			argv[0]);
635 		code = -1;
636 		return;
637 	}
638 	if (argc < 3) {
639 		if (prompt_for_arg(line, sizeof (line), "local-file") == -1) {
640 			code = -1;
641 			return;
642 		}
643 		makeargv();
644 		argc = margc;
645 		argv = margv;
646 	}
647 	if (argc < 3)
648 		goto usage;
649 	if (!globulize(&argv[2])) {
650 		code = -1;
651 		return;
652 	}
653 	if (loc && mcase) {
654 		char *tp = argv[1], *tp2, tmpbuf[MAXPATHLEN];
655 
656 		while (*tp) {
657 			if ((len = mblen(tp, MB_CUR_MAX)) <= 0)
658 				len = 1;
659 			if (islower(*tp))
660 				break;
661 			tp += len;
662 		}
663 		if (!*tp) {
664 			tp = argv[2];
665 			tp2 = tmpbuf;
666 			while (*tp) {
667 				if ((len = mblen(tp, MB_CUR_MAX)) <= 0)
668 					len = 1;
669 				memcpy(tp2, tp, len);
670 				if (isupper(*tp2))
671 					*tp2 = 'a' + *tp2 - 'A';
672 				tp += len;
673 				tp2 += len;
674 			}
675 			*tp2 = 0;
676 			argv[2] = tmpbuf;
677 		}
678 	}
679 	if (loc && ntflag) {
680 		argv[2] = dotrans(argv[2]);
681 	}
682 	if (loc && mapflag) {
683 		argv[2] = domap(argv[2]);
684 	}
685 	if (restartit) {
686 		struct stat stbuf;
687 
688 		if (stat(argv[2], &stbuf) < 0) {
689 			perror(argv[2]);
690 			code = -1;
691 			return;
692 		}
693 		restart_point = stbuf.st_size;
694 	}
695 	recvrequest("RETR", argv[2], argv[1], mode, allowpipe);
696 	restart_point = 0;
697 }
698 
699 /*
700  * Get multiple files.
701  */
702 void
703 mget(int argc, char *argv[])
704 {
705 	char *cp, *tp, *tp2, tmpbuf[MAXPATHLEN];
706 	int ointer;
707 	void (*oldintr)();
708 	int need_convert;
709 	int	len;
710 
711 	if (argc < 2) {
712 		if (prompt_for_arg(line, sizeof (line), "remote-files") < 0) {
713 			code = -1;
714 			return;
715 		}
716 		makeargv();
717 		argc = margc;
718 		argv = margv;
719 	}
720 	if (argc < 2) {
721 		(void) printf("usage: %s remote-files\n", argv[0]);
722 		code = -1;
723 		return;
724 	}
725 	mname = argv[0];
726 	mflag = 1;
727 	oldintr = signal(SIGINT, mabort);
728 	(void) setjmp(jabort);
729 	while ((cp = remglob(argv, proxy)) != NULL) {
730 		if (*cp == '\0') {
731 			mflag = 0;
732 			continue;
733 		}
734 		if (mflag && confirm(argv[0], cp)) {
735 			strcpy(tmpbuf, cp);
736 			tp =  tmpbuf;
737 			need_convert = 1;
738 			if (mcase) {
739 				tp2 = tp;
740 				while (*tp2 && need_convert) {
741 				/* Need any case convert? */
742 					if (islower(*tp2))
743 						need_convert = 0;
744 					if ((len = mblen(tp2, MB_CUR_MAX)) <= 0)
745 						len = 1;
746 					tp2 += len;
747 				}
748 				tp2 = tp;
749 				while (need_convert && *tp2) {
750 				/* Convert to lower case */
751 					if (isupper(*tp2))
752 						*tp2 = tolower(*tp2);
753 					if ((len = mblen(tp2, MB_CUR_MAX)) <= 0)
754 						len = 1;
755 					tp2 += len;
756 				}
757 			}
758 
759 			if (ntflag) {
760 				tp = dotrans(tp);
761 			}
762 			if (mapflag) {
763 				tp = domap(tp);
764 			}
765 			recvrequest("RETR", tp, cp, "w", 0);
766 			restart_point = 0;
767 			if (!mflag && fromatty) {
768 				ointer = interactive;
769 				interactive = 1;
770 				if (confirm("Continue with", "mget")) {
771 					mflag++;
772 				}
773 				interactive = ointer;
774 			}
775 		}
776 	}
777 	(void) signal(SIGINT, oldintr);
778 	mflag = 0;
779 }
780 
781 static char *
782 remglob(char *argv[], int doswitch)
783 {
784 	static char buf[MAXPATHLEN];
785 	static char **args;
786 	int oldverbose, oldhash;
787 	char *cp;
788 
789 	if (!mflag) {
790 		if (!doglob) {
791 			args = NULL;
792 		} else {
793 			if (tmp_nlst != NULL) {
794 				(void) fclose(tmp_nlst);
795 				tmp_nlst = NULL;
796 			}
797 		}
798 		return (NULL);
799 	}
800 	if (!doglob) {
801 		if (args == NULL)
802 			args = argv;
803 		if ((cp = *++args) == NULL)
804 			args = NULL;
805 		return (cp);
806 	}
807 	if (tmp_nlst == NULL) {
808 		if ((tmp_nlst = tmpfile()) == NULL) {
809 			(void) printf("%s\n", strerror(errno));
810 			return (NULL);
811 		}
812 		oldverbose = verbose, verbose = 0;
813 		oldhash = hash, hash = 0;
814 		if (doswitch) {
815 			pswitch(!proxy);
816 		}
817 		for (; *++argv != NULL; )
818 			recvrequest("NLST", NULL, *argv, "", 0);
819 		rewind(tmp_nlst);
820 		if (doswitch) {
821 			pswitch(!proxy);
822 		}
823 		verbose = oldverbose; hash = oldhash;
824 	}
825 	reset_timer();
826 	if (fgets(buf, sizeof (buf), tmp_nlst) == NULL) {
827 		(void) fclose(tmp_nlst), tmp_nlst = NULL;
828 		return (NULL);
829 	}
830 	if ((cp = index(buf, '\n')) != NULL)
831 		*cp = '\0';
832 	return (buf);
833 }
834 
835 static char *
836 onoff(int bool)
837 {
838 	return (bool ? "on" : "off");
839 }
840 
841 /*
842  * Show status.
843  */
844 /*ARGSUSED*/
845 void
846 status(int argc, char *argv[])
847 {
848 	int i;
849 	char *levelp;
850 
851 	if (connected)
852 		(void) printf("Connected to %s.\n", hostname);
853 	else
854 		(void) printf("Not connected.\n");
855 	if (!proxy) {
856 		pswitch(1);
857 		if (connected) {
858 			(void) printf("Connected for proxy commands to %s.\n",
859 			    hostname);
860 		} else {
861 			(void) printf("No proxy connection.\n");
862 		}
863 		pswitch(0);
864 	}
865 
866 	if (auth_type != AUTHTYPE_NONE)
867 		(void) printf("Authentication type: %s\n",
868 			GSS_AUTHTYPE_NAME(auth_type));
869 	else
870 		(void) printf("Not authenticated.\n");
871 	(void) printf("Mechanism: %s\n", mechstr);
872 	(void) printf("Autoauth: %s; Autologin: %s\n",
873 		onoff(autoauth), onoff(autologin));
874 	levelp = getlevel(clevel);
875 	(void) printf("Control Channel Protection Level: %s\n",
876 		levelp ? levelp : "<unknown>");
877 	levelp = getlevel(dlevel);
878 	(void) printf("Data Channel Protection Level: %s\n",
879 		levelp ? levelp : "<unknown>");
880 
881 	(void) printf("Passive mode: %s.\n", onoff(passivemode));
882 	(void) printf("Mode: %s; Type: %s; Form: %s; Structure: %s\n",
883 		modename, typename, formname, structname);
884 	(void) printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n",
885 		onoff(verbose), onoff(bell), onoff(interactive),
886 		onoff(doglob));
887 	(void) printf("Store unique: %s; Receive unique: %s\n", onoff(sunique),
888 		onoff(runique));
889 	(void) printf("Case: %s; CR stripping: %s\n",
890 		onoff(mcase), onoff(crflag));
891 	if (ntflag) {
892 		(void) printf("Ntrans: (in) %s (out) %s\n", ntin, ntout);
893 	} else {
894 		(void) printf("Ntrans: off\n");
895 	}
896 	if (mapflag) {
897 		(void) printf("Nmap: (in) %s (out) %s\n", mapin, mapout);
898 	} else {
899 		(void) printf("Nmap: off\n");
900 	}
901 	(void) printf("Hash mark printing: %s; Use of PORT cmds: %s\n",
902 		onoff(hash), onoff(sendport));
903 	if (macnum > 0) {
904 		(void) printf("Macros:\n");
905 		for (i = 0; i < macnum; i++) {
906 			(void) printf("\t%s\n", macros[i].mac_name);
907 		}
908 	}
909 	code = 0;
910 }
911 
912 /*
913  * Set beep on cmd completed mode.
914  */
915 /*ARGSUSED*/
916 void
917 setbell(int argc, char *argv[])
918 {
919 	bell = !bell;
920 	(void) printf("Bell mode %s.\n", onoff(bell));
921 	code = bell;
922 }
923 
924 /*
925  * Turn on packet tracing.
926  */
927 /*ARGSUSED*/
928 void
929 settrace(int argc, char *argv[])
930 {
931 	trace = !trace;
932 	(void) printf("Packet tracing %s.\n", onoff(trace));
933 	code = trace;
934 }
935 
936 /*
937  * Toggle hash mark printing during transfers.
938  */
939 /*ARGSUSED*/
940 void
941 sethash(int argc, char *argv[])
942 {
943 	hash = !hash;
944 	(void) printf("Hash mark printing %s", onoff(hash));
945 	code = hash;
946 	if (hash)
947 		(void) printf(" (%d bytes/hash mark)", HASHSIZ);
948 	(void) printf(".\n");
949 }
950 
951 /*
952  * Turn on printing of server echo's.
953  */
954 /*ARGSUSED*/
955 void
956 setverbose(int argc, char *argv[])
957 {
958 	verbose = !verbose;
959 	(void) printf("Verbose mode %s.\n", onoff(verbose));
960 	code = verbose;
961 }
962 
963 /*
964  * Toggle PORT cmd use before each data connection.
965  */
966 /*ARGSUSED*/
967 void
968 setport(int argc, char *argv[])
969 {
970 	sendport = !sendport;
971 	(void) printf("Use of PORT cmds %s.\n", onoff(sendport));
972 	code = sendport;
973 }
974 
975 /*
976  * Turn on interactive prompting
977  * during mget, mput, and mdelete.
978  */
979 /*ARGSUSED*/
980 void
981 setprompt(int argc, char *argv[])
982 {
983 	interactive = !interactive;
984 	(void) printf("Interactive mode %s.\n", onoff(interactive));
985 	code = interactive;
986 }
987 
988 /*
989  * Toggle metacharacter interpretation
990  * on local file names.
991  */
992 /*ARGSUSED*/
993 void
994 setglob(int argc, char *argv[])
995 {
996 	doglob = !doglob;
997 	(void) printf("Globbing %s.\n", onoff(doglob));
998 	code = doglob;
999 }
1000 
1001 /*
1002  * Set debugging mode on/off and/or
1003  * set level of debugging.
1004  */
1005 void
1006 setdebug(int argc, char *argv[])
1007 {
1008 	int val;
1009 
1010 	if (argc > 1) {
1011 		val = atoi(argv[1]);
1012 		if (val < 0) {
1013 			(void) printf("%s: bad debugging value.\n", argv[1]);
1014 			code = -1;
1015 			return;
1016 		}
1017 	} else
1018 		val = !debug;
1019 	debug = val;
1020 	if (debug)
1021 		options |= SO_DEBUG;
1022 	else
1023 		options &= ~SO_DEBUG;
1024 	(void) printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
1025 	code = debug > 0;
1026 }
1027 
1028 /*
1029  * Set current working directory
1030  * on remote machine.
1031  */
1032 void
1033 cd(int argc, char *argv[])
1034 {
1035 	if (argc < 2) {
1036 		if (prompt_for_arg(line, sizeof (line), "remote-directory") <
1037 		    0) {
1038 			code = -1;
1039 			return;
1040 		}
1041 		makeargv();
1042 		argc = margc;
1043 		argv = margv;
1044 	}
1045 	if (argc < 2) {
1046 		(void) printf("usage: %s remote-directory\n", argv[0]);
1047 		code = -1;
1048 		return;
1049 	}
1050 	(void) command("CWD %s", argv[1]);
1051 }
1052 
1053 /*
1054  * Set current working directory
1055  * on local machine.
1056  */
1057 void
1058 lcd(int argc, char *argv[])
1059 {
1060 	char buf[MAXPATHLEN], *bufptr;
1061 
1062 	if (argc < 2)
1063 		argc++, argv[1] = home;
1064 	if (argc != 2) {
1065 		(void) printf("usage: %s local-directory\n", argv[0]);
1066 		code = -1;
1067 		return;
1068 	}
1069 	if (!globulize(&argv[1])) {
1070 		code = -1;
1071 		return;
1072 	}
1073 	if (chdir(argv[1]) < 0) {
1074 		perror(argv[1]);
1075 		code = -1;
1076 		return;
1077 	}
1078 	bufptr = getcwd(buf, MAXPATHLEN);
1079 	/*
1080 	 * Even though chdir may succeed, getcwd may fail if a component
1081 	 * of the pwd is unreadable. In this case, print the argument to
1082 	 * chdir as the resultant directory, since we know it succeeded above.
1083 	 */
1084 	(void) printf("Local directory now %s\n", (bufptr ? bufptr : argv[1]));
1085 	code = 0;
1086 }
1087 
1088 /*
1089  * Delete a single file.
1090  */
1091 void
1092 delete(int argc, char *argv[])
1093 {
1094 
1095 	if (argc < 2) {
1096 		if (prompt_for_arg(line, sizeof (line), "remote-file") < 0) {
1097 			code = -1;
1098 			return;
1099 		}
1100 		makeargv();
1101 		argc = margc;
1102 		argv = margv;
1103 	}
1104 	if (argc < 2) {
1105 		(void) printf("usage: %s remote-file\n", argv[0]);
1106 		code = -1;
1107 		return;
1108 	}
1109 	(void) command("DELE %s", argv[1]);
1110 }
1111 
1112 /*
1113  * Delete multiple files.
1114  */
1115 void
1116 mdelete(int argc, char *argv[])
1117 {
1118 	char *cp;
1119 	int ointer;
1120 	void (*oldintr)();
1121 
1122 	if (argc < 2) {
1123 		if (prompt_for_arg(line, sizeof (line), "remote-files") < 0) {
1124 			code = -1;
1125 			return;
1126 		}
1127 		makeargv();
1128 		argc = margc;
1129 		argv = margv;
1130 	}
1131 	if (argc < 2) {
1132 		(void) printf("usage: %s remote-files\n", argv[0]);
1133 		code = -1;
1134 		return;
1135 	}
1136 	mname = argv[0];
1137 	mflag = 1;
1138 	oldintr = signal(SIGINT, mabort);
1139 	(void) setjmp(jabort);
1140 	while ((cp = remglob(argv, 0)) != NULL) {
1141 		if (*cp == '\0') {
1142 			mflag = 0;
1143 			continue;
1144 		}
1145 		if (mflag && confirm(argv[0], cp)) {
1146 			(void) command("DELE %s", cp);
1147 			if (!mflag && fromatty) {
1148 				ointer = interactive;
1149 				interactive = 1;
1150 				if (confirm("Continue with", "mdelete")) {
1151 					mflag++;
1152 				}
1153 				interactive = ointer;
1154 			}
1155 		}
1156 	}
1157 	(void) signal(SIGINT, oldintr);
1158 	mflag = 0;
1159 }
1160 
1161 /*
1162  * Rename a remote file.
1163  */
1164 void
1165 renamefile(int argc, char *argv[])
1166 {
1167 
1168 	if (argc < 2) {
1169 		if (prompt_for_arg(line, sizeof (line), "from-name") < 0) {
1170 			code = -1;
1171 			return;
1172 		}
1173 		makeargv();
1174 		argc = margc;
1175 		argv = margv;
1176 	}
1177 	if (argc < 2) {
1178 usage:
1179 		(void) printf("%s from-name to-name\n", argv[0]);
1180 		code = -1;
1181 		return;
1182 	}
1183 	if (argc < 3) {
1184 		if (prompt_for_arg(line, sizeof (line), "to-name") < 0) {
1185 			code = -1;
1186 			return;
1187 		}
1188 		makeargv();
1189 		argc = margc;
1190 		argv = margv;
1191 	}
1192 	if (argc < 3)
1193 		goto usage;
1194 	if (command("RNFR %s", argv[1]) == CONTINUE)
1195 		(void) command("RNTO %s", argv[2]);
1196 }
1197 
1198 /*
1199  * Get a directory listing
1200  * of remote files.
1201  */
1202 void
1203 ls(int argc, char *argv[])
1204 {
1205 	char *cmd;
1206 
1207 	if (argc < 2)
1208 		argc++, argv[1] = NULL;
1209 	if (argc < 3)
1210 		argc++, argv[2] = "-";
1211 	if (argc > 3) {
1212 		(void) printf("usage: %s remote-directory local-file\n",
1213 			argv[0]);
1214 		code = -1;
1215 		return;
1216 	}
1217 	if (ls_invokes_NLST) {
1218 		cmd = ((argv[0][0] == 'l' || argv[0][0] == 'n') ?
1219 		    "NLST" : "LIST");
1220 	} else {
1221 		cmd = ((argv[0][0] == 'n') ? "NLST" : "LIST");
1222 	}
1223 	if (strcmp(argv[2], "-") && !globulize(&argv[2])) {
1224 		code = -1;
1225 		return;
1226 	}
1227 	recvrequest(cmd, argv[2], argv[1], "w", 1);
1228 }
1229 
1230 /*
1231  * Get a directory listing
1232  * of multiple remote files.
1233  */
1234 void
1235 mls(int argc, char *argv[])
1236 {
1237 	char *cmd, mode[1], *dest;
1238 	int ointer, i;
1239 	void (*oldintr)();
1240 
1241 	if (argc < 2) {
1242 		if (prompt_for_arg(line, sizeof (line), "remote-files") < 0) {
1243 			code = -1;
1244 			return;
1245 		}
1246 		makeargv();
1247 		argc = margc;
1248 		argv = margv;
1249 	}
1250 	if (argc < 3) {
1251 		if (prompt_for_arg(line, sizeof (line), "local-file") < 0) {
1252 			code = -1;
1253 			return;
1254 		}
1255 		makeargv();
1256 		argc = margc;
1257 		argv = margv;
1258 	}
1259 	if (argc < 3) {
1260 		(void) printf("usage: %s remote-files local-file\n", argv[0]);
1261 		code = -1;
1262 		return;
1263 	}
1264 	dest = argv[argc - 1];
1265 	argv[argc - 1] = NULL;
1266 	if (strcmp(dest, "-") && *dest != '|')
1267 		if (!globulize(&dest) ||
1268 		    !confirm("output to local-file:", dest)) {
1269 			code = -1;
1270 			return;
1271 		}
1272 	cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
1273 	mname = argv[0];
1274 	mflag = 1;
1275 	oldintr = signal(SIGINT, mabort);
1276 	(void) setjmp(jabort);
1277 	for (i = 1; mflag && i < argc-1; ++i) {
1278 		*mode = (i == 1) ? 'w' : 'a';
1279 		recvrequest(cmd, dest, argv[i], mode, 1);
1280 		if (!mflag && fromatty) {
1281 			ointer = interactive;
1282 			interactive = 1;
1283 			if (confirm("Continue with", argv[0])) {
1284 				mflag ++;
1285 			}
1286 			interactive = ointer;
1287 		}
1288 	}
1289 	(void) signal(SIGINT, oldintr);
1290 	mflag = 0;
1291 }
1292 
1293 /*
1294  * Do a shell escape
1295  */
1296 /*ARGSUSED*/
1297 void
1298 shell(int argc, char *argv[])
1299 {
1300 	pid_t pid;
1301 	void (*old1)(), (*old2)();
1302 	char *shellstring, *namep;
1303 	int status;
1304 
1305 	stop_timer();
1306 	old1 = signal(SIGINT, SIG_IGN);
1307 	old2 = signal(SIGQUIT, SIG_IGN);
1308 	if ((pid = fork()) == 0) {
1309 		closefrom(STDERR_FILENO + 1);
1310 		(void) signal(SIGINT, SIG_DFL);
1311 		(void) signal(SIGQUIT, SIG_DFL);
1312 		shellstring = getenv("SHELL");
1313 		if (shellstring == NULL)
1314 			shellstring = "/bin/sh";
1315 		namep = rindex(shellstring, '/');
1316 		if (namep == NULL)
1317 			namep = shellstring;
1318 		if (argc > 1) {
1319 			if (debug) {
1320 				(void) printf("%s -c %s\n", shellstring,
1321 					altarg);
1322 				(void) fflush(stdout);
1323 			}
1324 			execl(shellstring, namep, "-c", altarg, (char *)0);
1325 		} else {
1326 			if (debug) {
1327 				(void) printf("%s\n", shellstring);
1328 				(void) fflush(stdout);
1329 			}
1330 			execl(shellstring, namep, (char *)0);
1331 		}
1332 		perror(shellstring);
1333 		code = -1;
1334 		exit(1);
1335 		}
1336 	if (pid > 0)
1337 		while (wait(&status) != pid)
1338 			;
1339 	(void) signal(SIGINT, old1);
1340 	(void) signal(SIGQUIT, old2);
1341 	reset_timer();
1342 	if (pid == (pid_t)-1) {
1343 		perror("Try again later");
1344 		code = -1;
1345 	} else {
1346 		code = 0;
1347 	}
1348 }
1349 
1350 /*
1351  * Send new user information (re-login)
1352  */
1353 void
1354 user(int argc, char *argv[])
1355 {
1356 	char acct[80];
1357 	int n, aflag = 0;
1358 
1359 	if (argc < 2) {
1360 		if (prompt_for_arg(line, sizeof (line), "username") < 0) {
1361 			code = -1;
1362 			return;
1363 		}
1364 		makeargv();
1365 		argc = margc;
1366 		argv = margv;
1367 	}
1368 	if (argc > 4) {
1369 		(void) printf("usage: %s username [password] [account]\n",
1370 			argv[0]);
1371 		code = -1;
1372 		return;
1373 	}
1374 	if (argv[1] == 0) {
1375 		(void) printf("access for user (nil) denied\n");
1376 		code = -1;
1377 		return;
1378 	}
1379 	n = command("USER %s", argv[1]);
1380 	if (n == CONTINUE) {
1381 		int oldclevel;
1382 		if (argc < 3)
1383 			argv[2] = mygetpass("Password: "), argc++;
1384 		if ((oldclevel = clevel) == PROT_S)
1385 			clevel = PROT_P;
1386 		n = command("PASS %s", argv[2]);
1387 		/* level may have changed */
1388 		if (clevel == PROT_P)
1389 			clevel = oldclevel;
1390 	}
1391 	if (n == CONTINUE) {
1392 		if (argc < 4) {
1393 			(void) printf("Account: "); (void) fflush(stdout);
1394 			stop_timer();
1395 			(void) fgets(acct, sizeof (acct) - 1, stdin);
1396 			reset_timer();
1397 			acct[strlen(acct) - 1] = '\0';
1398 			argv[3] = acct; argc++;
1399 		}
1400 		n = command("ACCT %s", argv[3]);
1401 		aflag++;
1402 	}
1403 	if (n != COMPLETE) {
1404 		(void) fprintf(stdout, "Login failed.\n");
1405 		return;
1406 	}
1407 	if (!aflag && argc == 4) {
1408 		(void) command("ACCT %s", argv[3]);
1409 	}
1410 }
1411 
1412 /*
1413  * Print working directory.
1414  */
1415 /*ARGSUSED*/
1416 void
1417 pwd(int argc, char *argv[])
1418 {
1419 	(void) command("PWD");
1420 }
1421 
1422 /*
1423  * Make a directory.
1424  */
1425 void
1426 makedir(int argc, char *argv[])
1427 {
1428 	if (argc < 2) {
1429 		if (prompt_for_arg(line, sizeof (line), "directory-name") <
1430 		    0) {
1431 			code = -1;
1432 			return;
1433 		}
1434 		makeargv();
1435 		argc = margc;
1436 		argv = margv;
1437 	}
1438 	if (argc < 2) {
1439 		(void) printf("usage: %s directory-name\n", argv[0]);
1440 		code = -1;
1441 		return;
1442 	}
1443 	(void) command("MKD %s", argv[1]);
1444 }
1445 
1446 /*
1447  * Remove a directory.
1448  */
1449 void
1450 removedir(int argc, char *argv[])
1451 {
1452 	if (argc < 2) {
1453 		if (prompt_for_arg(line, sizeof (line), "directory-name") <
1454 		    0) {
1455 			code = -1;
1456 			return;
1457 		}
1458 		makeargv();
1459 		argc = margc;
1460 		argv = margv;
1461 	}
1462 	if (argc < 2) {
1463 		(void) printf("usage: %s directory-name\n", argv[0]);
1464 		code = -1;
1465 		return;
1466 	}
1467 	(void) command("RMD %s", argv[1]);
1468 }
1469 
1470 /*
1471  * Send a line, verbatim, to the remote machine.
1472  */
1473 void
1474 quote(int argc, char *argv[])
1475 {
1476 	int i, n, len;
1477 	char buf[FTPBUFSIZ];
1478 
1479 	if (argc < 2) {
1480 		if (prompt_for_arg(line, sizeof (line),
1481 		    "command line to send") == -1) {
1482 			code = -1;
1483 			return;
1484 		}
1485 		makeargv();
1486 		argc = margc;
1487 		argv = margv;
1488 	}
1489 	if (argc < 2) {
1490 		(void) printf("usage: %s line-to-send\n", argv[0]);
1491 		code = -1;
1492 		return;
1493 	}
1494 	len = snprintf(buf, sizeof (buf), "%s", argv[1]);
1495 	if (len >= 0 && len < sizeof (buf) - 1) {
1496 		for (i = 2; i < argc; i++) {
1497 			n = snprintf(&buf[len], sizeof (buf) - len, " %s",
1498 					argv[i]);
1499 			if (n < 0 || n >= sizeof (buf) - len)
1500 				break;
1501 			len += n;
1502 		}
1503 	}
1504 	if (command("%s", buf) == PRELIM) {
1505 		while (getreply(0) == PRELIM)
1506 			;
1507 	}
1508 }
1509 
1510 /*
1511  * Send a line, verbatim, to the remote machine as a SITE command.
1512  */
1513 void
1514 site(int argc, char *argv[])
1515 {
1516 	int i, n, len;
1517 	char buf[FTPBUFSIZ];
1518 
1519 	if (argc < 2) {
1520 		if (prompt_for_arg(line, sizeof (line),
1521 		    "arguments to SITE command") == -1) {
1522 			code = -1;
1523 			return;
1524 		}
1525 		makeargv();
1526 		argc = margc;
1527 		argv = margv;
1528 	}
1529 	if (argc < 2) {
1530 		(void) printf("usage: %s arg1 [arg2] ...\n", argv[0]);
1531 		code = -1;
1532 		return;
1533 	}
1534 	len = snprintf(buf, sizeof (buf), "%s", argv[1]);
1535 	if (len >= 0 && len < sizeof (buf) - 1) {
1536 		for (i = 2; i < argc; i++) {
1537 			n = snprintf(&buf[len], sizeof (buf) - len, " %s",
1538 					argv[i]);
1539 			if (n < 0 || n >= sizeof (buf) - len)
1540 				break;
1541 			len += n;
1542 		}
1543 	}
1544 	if (command("SITE %s", buf) == PRELIM) {
1545 		while (getreply(0) == PRELIM)
1546 			;
1547 	}
1548 }
1549 
1550 /*
1551  * Ask the other side for help.
1552  */
1553 void
1554 rmthelp(int argc, char *argv[])
1555 {
1556 	int oldverbose = verbose;
1557 
1558 	verbose = 1;
1559 	(void) command(argc == 1 ? "HELP" : "HELP %s", argv[1]);
1560 	verbose = oldverbose;
1561 }
1562 
1563 /*
1564  * Terminate session and exit.
1565  */
1566 /*ARGSUSED*/
1567 void
1568 quit(int argc, char *argv[])
1569 {
1570 	if (connected)
1571 		disconnect(0, NULL);
1572 	pswitch(1);
1573 	if (connected) {
1574 		disconnect(0, NULL);
1575 	}
1576 	exit(0);
1577 }
1578 
1579 /*
1580  * Terminate session, but don't exit.
1581  */
1582 /*ARGSUSED*/
1583 void
1584 disconnect(int argc, char *argv[])
1585 {
1586 	extern FILE *ctrl_in, *ctrl_out;
1587 	extern int data;
1588 
1589 	if (!connected)
1590 		return;
1591 	(void) command("QUIT");
1592 	if (ctrl_in) {
1593 		reset_timer();
1594 		(void) fclose(ctrl_in);
1595 	}
1596 	if (ctrl_out) {
1597 		reset_timer();
1598 		(void) fclose(ctrl_out);
1599 	}
1600 	ctrl_out = ctrl_in = NULL;
1601 	connected = 0;
1602 	data = -1;
1603 	if (!proxy) {
1604 		macnum = 0;
1605 	}
1606 
1607 	auth_type = AUTHTYPE_NONE;
1608 	clevel = dlevel = PROT_C;
1609 	goteof = 0;
1610 }
1611 
1612 static int
1613 confirm(char *cmd, char *file)
1614 {
1615 	char line[FTPBUFSIZ];
1616 
1617 	if (!interactive)
1618 		return (1);
1619 	stop_timer();
1620 	(void) printf("%s %s? ", cmd, file);
1621 	(void) fflush(stdout);
1622 	*line = '\0';
1623 	(void) fgets(line, sizeof (line), stdin);
1624 	reset_timer();
1625 	return (*line != 'n' && *line != 'N');
1626 }
1627 
1628 void
1629 fatal(char *msg)
1630 {
1631 	(void) fprintf(stderr, "ftp: %s\n", msg);
1632 	exit(1);
1633 }
1634 
1635 /*
1636  * Glob a local file name specification with
1637  * the expectation of a single return value.
1638  * Can't control multiple values being expanded
1639  * from the expression, we return only the first.
1640  */
1641 static int
1642 globulize(char **cpp)
1643 {
1644 	char **globbed;
1645 
1646 	if (!doglob)
1647 		return (1);
1648 	globbed = glob(*cpp);
1649 	if (globbed != NULL && *globbed == NULL && globerr == NULL)
1650 		globerr = "No match";
1651 	if (globerr != NULL) {
1652 		(void) printf("%s: %s\n", *cpp, globerr);
1653 		if (globbed)
1654 			blkfree(globbed);
1655 		return (0);
1656 	}
1657 	if (globbed) {
1658 		*cpp = strdup(*globbed);
1659 		blkfree(globbed);
1660 		if (!*cpp)
1661 			return (0);
1662 	}
1663 	return (1);
1664 }
1665 
1666 void
1667 account(int argc, char *argv[])
1668 {
1669 	char acct[50], *ap;
1670 
1671 	if (argc > 1) {
1672 		++argv;
1673 		--argc;
1674 		(void) strncpy(acct, *argv, 49);
1675 		acct[49] = '\0';
1676 		while (argc > 1) {
1677 			--argc;
1678 			++argv;
1679 			(void) strncat(acct, *argv, 49 - strlen(acct));
1680 		}
1681 		ap = acct;
1682 	} else {
1683 		ap = mygetpass("Account:");
1684 	}
1685 	(void) command("ACCT %s", ap);
1686 }
1687 
1688 /*ARGSUSED*/
1689 static void
1690 proxabort(int sig)
1691 {
1692 	extern int proxy;
1693 
1694 	if (!proxy) {
1695 		pswitch(1);
1696 	}
1697 	if (connected) {
1698 		proxflag = 1;
1699 	} else {
1700 		proxflag = 0;
1701 	}
1702 	pswitch(0);
1703 	longjmp(abortprox, 1);
1704 }
1705 
1706 void
1707 doproxy(int argc, char *argv[])
1708 {
1709 	void (*oldintr)();
1710 	struct cmd *c;
1711 
1712 	if (argc < 2) {
1713 		if (prompt_for_arg(line, sizeof (line), "command") == -1) {
1714 			code = -1;
1715 			return;
1716 		}
1717 		makeargv();
1718 		argc = margc;
1719 		argv = margv;
1720 	}
1721 	if (argc < 2) {
1722 		(void) printf("usage: %s command\n", argv[0]);
1723 		code = -1;
1724 		return;
1725 	}
1726 	c = getcmd(argv[1]);
1727 	if (c == (struct cmd *)-1) {
1728 		(void) printf("?Ambiguous command\n");
1729 		(void) fflush(stdout);
1730 		code = -1;
1731 		return;
1732 	}
1733 	if (c == 0) {
1734 		(void) printf("?Invalid command\n");
1735 		(void) fflush(stdout);
1736 		code = -1;
1737 		return;
1738 	}
1739 	if (!c->c_proxy) {
1740 		(void) printf("?Invalid proxy command\n");
1741 		(void) fflush(stdout);
1742 		code = -1;
1743 		return;
1744 	}
1745 	if (setjmp(abortprox)) {
1746 		code = -1;
1747 		return;
1748 	}
1749 	oldintr = signal(SIGINT, (void (*)())proxabort);
1750 	pswitch(1);
1751 	if (c->c_conn && !connected) {
1752 		(void) printf("Not connected\n");
1753 		(void) fflush(stdout);
1754 		pswitch(0);
1755 		(void) signal(SIGINT, oldintr);
1756 		code = -1;
1757 		return;
1758 	}
1759 	(*c->c_handler)(argc-1, argv+1);
1760 	if (connected) {
1761 		proxflag = 1;
1762 	} else {
1763 		proxflag = 0;
1764 	}
1765 	pswitch(0);
1766 	(void) signal(SIGINT, oldintr);
1767 }
1768 
1769 /*ARGSUSED*/
1770 void
1771 setcase(int argc, char *argv[])
1772 {
1773 	mcase = !mcase;
1774 	(void) printf("Case mapping %s.\n", onoff(mcase));
1775 	code = mcase;
1776 }
1777 
1778 /*ARGSUSED*/
1779 void
1780 setcr(int argc, char *argv[])
1781 {
1782 	crflag = !crflag;
1783 	(void) printf("Carriage Return stripping %s.\n", onoff(crflag));
1784 	code = crflag;
1785 }
1786 
1787 void
1788 setntrans(int argc, char *argv[])
1789 {
1790 	if (argc == 1) {
1791 		ntflag = 0;
1792 		(void) printf("Ntrans off.\n");
1793 		code = ntflag;
1794 		return;
1795 	}
1796 	ntflag++;
1797 	code = ntflag;
1798 	(void) strncpy(ntin, argv[1], 16);
1799 	ntin[16] = '\0';
1800 	if (argc == 2) {
1801 		ntout[0] = '\0';
1802 		return;
1803 	}
1804 	(void) strncpy(ntout, argv[2], 16);
1805 	ntout[16] = '\0';
1806 }
1807 
1808 static char *
1809 dotrans(char *name)
1810 {
1811 	static char new[MAXPATHLEN];
1812 	char *cp1, *cp2 = new;
1813 	int i, ostop, found;
1814 
1815 	for (ostop = 0; *(ntout + ostop) && ostop < 16; ostop++)
1816 		;
1817 	for (cp1 = name; *cp1; cp1++) {
1818 		found = 0;
1819 		for (i = 0; *(ntin + i) && i < 16; i++) {
1820 			if (*cp1 == *(ntin + i)) {
1821 				found++;
1822 				if (i < ostop) {
1823 					*cp2++ = *(ntout + i);
1824 				}
1825 				break;
1826 			}
1827 		}
1828 		if (!found) {
1829 			*cp2++ = *cp1;
1830 		}
1831 	}
1832 	*cp2 = '\0';
1833 	return (new);
1834 }
1835 
1836 void
1837 setnmap(int argc, char *argv[])
1838 {
1839 	char *cp;
1840 
1841 	if (argc == 1) {
1842 		mapflag = 0;
1843 		(void) printf("Nmap off.\n");
1844 		code = mapflag;
1845 		return;
1846 	}
1847 	if (argc < 3) {
1848 		if (prompt_for_arg(line, sizeof (line), "mapout") == -1) {
1849 			code = -1;
1850 			return;
1851 		}
1852 		makeargv();
1853 		argc = margc;
1854 		argv = margv;
1855 	}
1856 	if (argc < 3) {
1857 		(void) printf("Usage: %s [mapin mapout]\n", argv[0]);
1858 		code = -1;
1859 		return;
1860 	}
1861 	mapflag = 1;
1862 	code = 1;
1863 	cp = index(altarg, ' ');
1864 	if (proxy) {
1865 		while (*++cp == ' ')
1866 			/* NULL */;
1867 		altarg = cp;
1868 		cp = index(altarg, ' ');
1869 	}
1870 	*cp = '\0';
1871 	(void) strncpy(mapin, altarg, MAXPATHLEN - 1);
1872 	while (*++cp == ' ')
1873 		/* NULL */;
1874 	(void) strncpy(mapout, cp, MAXPATHLEN - 1);
1875 }
1876 
1877 static char *
1878 domap(char *name)
1879 {
1880 	static char new[MAXPATHLEN];
1881 	char *cp1 = name, *cp2 = mapin;
1882 	char *tp[9], *te[9];
1883 	int i, toks[9], toknum, match = 1;
1884 	wchar_t	wc1, wc2;
1885 	int	len1, len2;
1886 
1887 	for (i = 0; i < 9; ++i) {
1888 		toks[i] = 0;
1889 	}
1890 	while (match && *cp1 && *cp2) {
1891 		if ((len1 = mbtowc(&wc1, cp1, MB_CUR_MAX)) <= 0) {
1892 			wc1 = (unsigned char)*cp1;
1893 			len1 = 1;
1894 		}
1895 		cp1 += len1;
1896 		if ((len2 = mbtowc(&wc2, cp2, MB_CUR_MAX)) <= 0) {
1897 			wc2 = (unsigned char)*cp2;
1898 			len2 = 1;
1899 		}
1900 		cp2 += len2;
1901 
1902 		switch (wc2) {
1903 		case '\\':
1904 			if ((len2 = mbtowc(&wc2, cp2, MB_CUR_MAX)) <= 0) {
1905 				wc2 = (unsigned char)*cp2;
1906 				len2 = 1;
1907 			}
1908 			cp2 += len2;
1909 			if (wc2 != wc1)
1910 				match = 0;
1911 			break;
1912 
1913 		case '$':
1914 			if (*cp2 >= '1' && *cp2 <= '9') {
1915 				if ((len2 =
1916 				    mbtowc(&wc2, cp2 + 1, MB_CUR_MAX)) <= 0) {
1917 					wc2 = (unsigned char)*(cp2 + 1);
1918 					len2 = 1;
1919 				}
1920 				if (wc1 != wc2) {
1921 					toks[toknum = *cp2 - '1']++;
1922 					tp[toknum] = cp1 - len1;
1923 					while (*cp1) {
1924 						if ((len1 = mbtowc(&wc1,
1925 						    cp1, MB_CUR_MAX)) <= 0) {
1926 							wc1 =
1927 							    (unsigned char)*cp1;
1928 							len1 = 1;
1929 						}
1930 						cp1 += len1;
1931 						if (wc2 == wc1)
1932 							break;
1933 					}
1934 					if (*cp1 == 0 && wc2 != wc1)
1935 						te[toknum] = cp1;
1936 					else
1937 						te[toknum] = cp1 - len1;
1938 				}
1939 				cp2++;			/* Consume the digit */
1940 				if (wc2)
1941 					cp2 += len2;	/* Consume wide char */
1942 				break;
1943 			}
1944 			/* intentional drop through */
1945 		default:
1946 			if (wc2 != wc1)
1947 				match = 0;
1948 			break;
1949 		}
1950 	}
1951 
1952 	cp1 = new;
1953 	*cp1 = '\0';
1954 	cp2 = mapout;
1955 	while (*cp2) {
1956 		match = 0;
1957 		switch (*cp2) {
1958 		case '\\':
1959 			cp2++;
1960 			if (*cp2) {
1961 				if ((len2 = mblen(cp2, MB_CUR_MAX)) <= 0)
1962 					len2 = 1;
1963 				memcpy(cp1, cp2, len2);
1964 				cp1 += len2;
1965 				cp2 += len2;
1966 			}
1967 			break;
1968 
1969 		case '[':
1970 LOOP:
1971 			cp2++;
1972 			if (*cp2 == '$' && isdigit(*(cp2+1))) {
1973 				if (*++cp2 == '0') {
1974 					char *cp3 = name;
1975 
1976 					while (*cp3) {
1977 						*cp1++ = *cp3++;
1978 					}
1979 					match = 1;
1980 				} else if (toks[toknum = *cp2 - '1']) {
1981 					char *cp3 = tp[toknum];
1982 
1983 					while (cp3 != te[toknum]) {
1984 						*cp1++ = *cp3++;
1985 					}
1986 					match = 1;
1987 				}
1988 			} else {
1989 				while (*cp2 && *cp2 != ',' && *cp2 != ']') {
1990 					if (*cp2 == '\\') {
1991 						cp2++;
1992 						continue;
1993 					}
1994 
1995 					if (*cp2 == '$' && isdigit(*(cp2+1))) {
1996 						if (*++cp2 == '0') {
1997 							char *cp3 = name;
1998 
1999 							while (*cp3)
2000 								*cp1++ = *cp3++;
2001 							continue;
2002 						}
2003 						if (toks[toknum = *cp2 - '1']) {
2004 							char *cp3 = tp[toknum];
2005 
2006 							while (cp3 !=
2007 							    te[toknum])
2008 								*cp1++ = *cp3++;
2009 						}
2010 						continue;
2011 					}
2012 					if (*cp2) {
2013 						if ((len2 =
2014 						    mblen(cp2, MB_CUR_MAX)) <=
2015 						    0) {
2016 							len2 = 1;
2017 						}
2018 						memcpy(cp1, cp2, len2);
2019 						cp1 += len2;
2020 						cp2 += len2;
2021 					}
2022 				}
2023 				if (!*cp2) {
2024 					(void) printf(
2025 						"nmap: unbalanced brackets\n");
2026 					return (name);
2027 				}
2028 				match = 1;
2029 			}
2030 			if (match) {
2031 				while (*cp2 && *cp2 != ']') {
2032 					if (*cp2 == '\\' && *(cp2 + 1)) {
2033 						cp2++;
2034 					}
2035 					if ((len2 = mblen(cp2, MB_CUR_MAX)) <=
2036 					    0)
2037 						len2 = 1;
2038 					cp2 += len2;
2039 				}
2040 				if (!*cp2) {
2041 					(void) printf(
2042 						"nmap: unbalanced brackets\n");
2043 					return (name);
2044 				}
2045 				cp2++;
2046 				break;
2047 			}
2048 			switch (*++cp2) {
2049 				case ',':
2050 					goto LOOP;
2051 				case ']':
2052 					break;
2053 				default:
2054 					cp2--;
2055 					goto LOOP;
2056 			}
2057 			cp2++;
2058 			break;
2059 		case '$':
2060 			if (isdigit(*(cp2 + 1))) {
2061 				if (*++cp2 == '0') {
2062 					char *cp3 = name;
2063 
2064 					while (*cp3) {
2065 						*cp1++ = *cp3++;
2066 					}
2067 				} else if (toks[toknum = *cp2 - '1']) {
2068 					char *cp3 = tp[toknum];
2069 
2070 					while (cp3 != te[toknum]) {
2071 						*cp1++ = *cp3++;
2072 					}
2073 				}
2074 				cp2++;
2075 				break;
2076 			}
2077 			/* intentional drop through */
2078 		default:
2079 			if ((len2 = mblen(cp2, MB_CUR_MAX)) <= 0)
2080 				len2 = 1;
2081 			memcpy(cp1, cp2, len2);
2082 			cp1 += len2;
2083 			cp2 += len2;
2084 			break;
2085 		}
2086 	}
2087 	*cp1 = '\0';
2088 	if (!*new) {
2089 		return (name);
2090 	}
2091 	return (new);
2092 }
2093 
2094 /*ARGSUSED*/
2095 void
2096 setsunique(int argc, char *argv[])
2097 {
2098 	sunique = !sunique;
2099 	(void) printf("Store unique %s.\n", onoff(sunique));
2100 	code = sunique;
2101 }
2102 
2103 /*ARGSUSED*/
2104 void
2105 setrunique(int argc, char *argv[])
2106 {
2107 	runique = !runique;
2108 	(void) printf("Receive unique %s.\n", onoff(runique));
2109 	code = runique;
2110 }
2111 
2112 /*ARGSUSED*/
2113 void
2114 setpassive(int argc, char *argv[])
2115 {
2116 	passivemode = !passivemode;
2117 	(void) printf("Passive mode %s.\n", onoff(passivemode));
2118 	code = passivemode;
2119 }
2120 
2121 void
2122 settcpwindow(int argc, char *argv[])
2123 {
2124 	int owindowsize = tcpwindowsize;
2125 
2126 	if (argc > 2) {
2127 		(void) printf("usage: %s [size]\n", argv[0]);
2128 		code = -1;
2129 		return;
2130 	}
2131 	if (argc == 2) {
2132 		int window;
2133 		char *endp;
2134 
2135 		errno = 0;
2136 		window = (int)strtol(argv[1], &endp, 10);
2137 		if (errno || window < 0 || *endp != '\0')
2138 			(void) printf("%s: Invalid size `%s'\n",
2139 				argv[0], argv[1]);
2140 		else
2141 			tcpwindowsize = window;
2142 	}
2143 	if (tcpwindowsize == 0) {
2144 		if (owindowsize == 0)
2145 			(void) printf("No TCP window size defined\n");
2146 		else
2147 			(void) printf("TCP window size cleared\n");
2148 	} else
2149 		(void) printf("TCP window size is set to %d\n", tcpwindowsize);
2150 }
2151 
2152 /* change directory to parent directory */
2153 /*ARGSUSED*/
2154 void
2155 cdup(int argc, char *argv[])
2156 {
2157 	(void) command("CDUP");
2158 }
2159 
2160 void
2161 macdef(int argc, char *argv[])
2162 {
2163 	char *tmp;
2164 	int c;
2165 
2166 	if (macnum == 16) {
2167 		(void) printf("Limit of 16 macros have already been defined\n");
2168 		code = -1;
2169 		return;
2170 	}
2171 	if (argc < 2) {
2172 		if (prompt_for_arg(line, sizeof (line), "macro name") == -1) {
2173 			code = -1;
2174 			return;
2175 		}
2176 		makeargv();
2177 		argc = margc;
2178 		argv = margv;
2179 	}
2180 	if (argc != 2) {
2181 		(void) printf("Usage: %s macro_name\n", argv[0]);
2182 		code = -1;
2183 		return;
2184 	}
2185 	if (interactive) {
2186 		(void) printf("Enter macro line by line, terminating "
2187 		    "it with a null line\n");
2188 	}
2189 	(void) strncpy(macros[macnum].mac_name, argv[1], 8);
2190 	if (macnum == 0) {
2191 		macros[macnum].mac_start = macbuf;
2192 	} else {
2193 		macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
2194 	}
2195 	tmp = macros[macnum].mac_start;
2196 	while (tmp != macbuf+4096) {
2197 		if ((c = getchar()) == EOF) {
2198 			(void) printf("macdef:end of file encountered\n");
2199 			code = -1;
2200 			return;
2201 		}
2202 		if ((*tmp = c) == '\n') {
2203 			if (tmp == macros[macnum].mac_start) {
2204 				macros[macnum++].mac_end = tmp;
2205 				code = 0;
2206 				return;
2207 			}
2208 			if (*(tmp-1) == '\0') {
2209 				macros[macnum++].mac_end = tmp - 1;
2210 				code = 0;
2211 				return;
2212 			}
2213 			*tmp = '\0';
2214 		}
2215 		tmp++;
2216 	}
2217 	for (;;) {
2218 		while ((c = getchar()) != '\n' && c != EOF)
2219 			/* NULL */;
2220 		if (c == EOF || getchar() == '\n') {
2221 			(void) printf(
2222 				"Macro not defined - 4k buffer exceeded\n");
2223 			code = -1;
2224 			return;
2225 		}
2226 	}
2227 }
2228 
2229 /*
2230  * The p_name strings are for the getlevel and setlevel commands.
2231  * The name strings for printing are in the arpa/ftp.h file in the
2232  * protnames[] array of strings.
2233  */
2234 static	struct	levels {
2235 	char	*p_name;
2236 	char	*p_mode;
2237 	int	p_level;
2238 } levels[] = {
2239 	{ "clear",	"C",	PROT_C },
2240 	{ "safe",	"S",	PROT_S },
2241 	{ "private",	"P",	PROT_P },
2242 	NULL
2243 };
2244 
2245 /*
2246  * Return a pointer to a string which is the readable version of the
2247  * protection level, or NULL if the input level is not found.
2248  */
2249 static char *
2250 getlevel(int level)
2251 {
2252 	struct levels *p;
2253 
2254 	for (p = levels; (p != NULL) && (p->p_level != level); p++)
2255 		;
2256 	return (p ? p->p_name : NULL);
2257 }
2258 
2259 static char *plevel[] = {
2260 	"protect",
2261 	"",
2262 	NULL
2263 };
2264 
2265 /*
2266  * Set control channel protection level.
2267  */
2268 void
2269 setclevel(int argc, char *argv[])
2270 {
2271 	struct levels *p;
2272 	char *levelp;
2273 	int comret;
2274 
2275 	if (argc > 2) {
2276 		char *sep;
2277 
2278 		(void) printf("usage: %s [", argv[0]);
2279 		sep = " ";
2280 		for (p = levels; p->p_name; p++) {
2281 			(void) printf("%s%s", sep, p->p_name);
2282 			if (*sep == ' ')
2283 				sep = " | ";
2284 		}
2285 		(void) printf(" ]\n");
2286 		code = -1;
2287 		return;
2288 	}
2289 	if (argc < 2) {
2290 		levelp = getlevel(clevel);
2291 		(void) printf("Using %s protection level for commands.\n",
2292 			levelp ? levelp : "<unknown>");
2293 		code = 0;
2294 		return;
2295 	}
2296 	for (p = levels; (p != NULL) && (p->p_name); p++)
2297 		if (strcmp(argv[1], p->p_name) == 0)
2298 			break;
2299 	if (p->p_name == 0) {
2300 		(void) printf("%s: unknown protection level\n", argv[1]);
2301 		code = -1;
2302 		return;
2303 	}
2304 	if (auth_type == AUTHTYPE_NONE) {
2305 		if (strcmp(p->p_name, "clear"))
2306 			(void) printf("Cannot set protection level to %s\n",
2307 				argv[1]);
2308 		return;
2309 	}
2310 	if (strcmp(p->p_name, "clear") == 0) {
2311 		comret = command("CCC");
2312 		if (comret == COMPLETE)
2313 			clevel = PROT_C;
2314 		return;
2315 	}
2316 	clevel = p->p_level;
2317 	(void) printf("Control channel protection level set to %s.\n",
2318 		p->p_name);
2319 }
2320 
2321 /*
2322  * Set data channel protection level.
2323  */
2324 void
2325 setdlevel(int argc, char *argv[])
2326 {
2327 	struct levels *p;
2328 	int comret;
2329 
2330 	if (argc != 2) {
2331 		char *sep;
2332 
2333 		(void) printf("usage: %s [", argv[0]);
2334 		sep = " ";
2335 		for (p = levels; p->p_name; p++) {
2336 			(void) printf("%s%s", sep, p->p_name);
2337 			if (*sep == ' ')
2338 				sep = " | ";
2339 		}
2340 		(void) printf(" ]\n");
2341 		code = -1;
2342 		return;
2343 	}
2344 	for (p = levels; p->p_name; p++)
2345 		if (strcmp(argv[1], p->p_name) == 0)
2346 			break;
2347 	if (p->p_name == 0) {
2348 		(void) printf("%s: unknown protection level\n", argv[1]);
2349 		code = -1;
2350 		return;
2351 	}
2352 	if (auth_type == AUTHTYPE_NONE) {
2353 		if (strcmp(p->p_name, "clear"))
2354 			(void) printf("Cannot set protection level to %s\n",
2355 				argv[1]);
2356 		return;
2357 	}
2358 	/* Start with a PBSZ of 1 meg */
2359 	if (p->p_level != PROT_C)
2360 		setpbsz(1<<20);
2361 	comret = command("PROT %s", p->p_mode);
2362 	if (comret == COMPLETE)
2363 		dlevel = p->p_level;
2364 }
2365 
2366 /*
2367  * Set clear command protection level.
2368  */
2369 /* VARARGS */
2370 void
2371 ccc(int argc, char *argv[])
2372 {
2373 	plevel[1] = "clear";
2374 	setclevel(2, plevel);
2375 }
2376 
2377 /*
2378  * Set clear data protection level.
2379  */
2380 /* VARARGS */
2381 void
2382 setclear(int argc, char *argv[])
2383 {
2384 	plevel[1] = "clear";
2385 	setdlevel(2, plevel);
2386 }
2387 
2388 /*
2389  * Set safe data protection level.
2390  */
2391 /* VARARGS */
2392 void
2393 setsafe(int argc, char *argv[])
2394 {
2395 	plevel[1] = "safe";
2396 	setdlevel(2, plevel);
2397 }
2398 
2399 /*
2400  * Set private data protection level.
2401  */
2402 /* VARARGS */
2403 void
2404 setprivate(int argc, char *argv[])
2405 {
2406 	plevel[1] = "private";
2407 	setdlevel(2, plevel);
2408 }
2409 
2410 /*
2411  * Set mechanism type
2412  */
2413 void
2414 setmech(int  argc, char *argv[])
2415 {
2416 	char	tempmech[MECH_SZ];
2417 
2418 	if (argc < 2) {
2419 		if (prompt_for_arg(line, sizeof (line), "mech-type") == -1) {
2420 			code = -1;
2421 			return;
2422 		}
2423 		makeargv();
2424 		argc = margc;
2425 		argv = margv;
2426 	}
2427 
2428 	if (argc != 2) {
2429 		(void) printf("usage: %s [ mechanism type ]\n", argv[0]);
2430 		code = -1;
2431 		return;
2432 	}
2433 
2434 	if ((strlcpy(tempmech, argv[1], MECH_SZ) >= MECH_SZ) ||
2435 		__gss_mech_to_oid(tempmech, (gss_OID*)&mechoid) !=
2436 			GSS_S_COMPLETE) {
2437 		(void) printf("%s: %s: not a valid security mechanism\n",
2438 			argv[0], tempmech);
2439 		code = -1;
2440 		return;
2441 	} else {
2442 		(void) strlcpy(mechstr, tempmech, MECH_SZ);
2443 		(void) printf("Using %s mechanism type\n", mechstr);
2444 		code = 0;
2445 		return;
2446 	}
2447 }
2448