xref: /titanic_51/usr/src/cmd/cmd-inet/usr.bin/ftp/ftp.c (revision bbaa8b60dd95d714741fc474adad3cf710ef4efd)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  *	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  *	Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	All Rights Reserved  	*/
29 
30 /*
31  *	University Copyright- Copyright (c) 1982, 1986, 1988
32  *	The Regents of the University of California
33  *	All Rights Reserved
34  *
35  *	University Acknowledgment- Portions of this document are derived from
36  *	software developed by the University of California, Berkeley, and its
37  *	contributors.
38  */
39 
40 #pragma ident	"%Z%%M%	%I%	%E% SMI"
41 
42 #include "ftp_var.h"
43 #include <arpa/nameser.h>
44 #include <sys/types.h>
45 
46 /*
47  * WRITE() returns:
48  * 	>0	no error
49  *	-1	error, errorno is set
50  *	-2	security error (secure_write() only)
51  */
52 #define	PUTC(x, y)	secure_putc(x, y)
53 #define	READ(x, y, z)	secure_read(x, y, z)
54 #define	WRITE(x, y, z)	secure_write(x, y, z)
55 
56 static struct	sockaddr_in6 data_addr;
57 int	data = -1;
58 static int	abrtflag = 0;
59 static int	ptflag = 0;
60 int		connected;
61 static jmp_buf	sendabort;
62 static jmp_buf	recvabort;
63 static jmp_buf 	ptabort;
64 static int ptabflg;
65 static boolean_t pasv_refused;
66 boolean_t	eport_supported = B_TRUE;
67 /*
68  * For IPv6 addresses, EPSV will be the default (rather than EPRT/LPRT).
69  * The EPSV/ERPT ftp protocols are specified in RFC 2428.
70  *
71  * Perform EPSV if passivemode is set and ipv6rem is TRUE.
72  */
73 static boolean_t ipv6rem;
74 int	use_eprt = 0;	/* Testing option that specifies EPRT by default */
75 FILE	*ctrl_in, *ctrl_out;
76 
77 static void abortsend(int sig);
78 static void abortpt(int sig);
79 static void proxtrans(char *cmd, char *local, char *remote);
80 static void cmdabort(int sig);
81 static int empty(struct fd_set *mask, int sec, int nfds);
82 static void abortrecv(int sig);
83 static int initconn(void);
84 static FILE *dataconn(char *mode);
85 static void ptransfer(char *direction, off_t bytes, hrtime_t t0,
86     hrtime_t t1, char *local, char *remote);
87 static void psabort(int sig);
88 static char *gunique(char *local);
89 static const char *inet_ntop_native(int af, const void *src, char *dst,
90     size_t size);
91 static ssize_t timedread(int fd, void *buf, size_t maxlen, int timeout);
92 
93 static int secure_command(char *);
94 static int decode_reply(uchar_t *, int, uchar_t *, int, boolean_t *);
95 
96 static ssize_t	bufcnt;		/* number of bytes in buf[]	*/
97 static char	*bufp;		/* next character in buf	*/
98 static int	buferr;		/* last errno			*/
99 static size_t	bufsize;
100 
101 static void fdio_setbuf(char *buffer, size_t bufsize);
102 static int fdio_fillbuf(int fd);
103 static int fdio_error(int fd);
104 #define	fdio_getc(fd)	(--bufcnt < 0 ? fdio_fillbuf((fd)) : \
105 			    ((unsigned char)*bufp++))
106 
107 #define	MAX(a, b) ((a) > (b) ? (a) : (b))
108 #define	NONZERO(x)	((x) == 0 ? 1 : (x))
109 
110 static void
111 fdio_setbuf(char *buffer, size_t maxsize)
112 {
113 	buf = buffer;
114 	bufp = buf;
115 	bufcnt = 0;
116 	buferr = 0;
117 	bufsize = maxsize;
118 }
119 
120 static int
121 fdio_fillbuf(int fd)
122 {
123 	bufcnt = timedread(fd, buf, bufsize, timeout);
124 	if (bufcnt < 0)
125 		buferr = errno;
126 	if (bufcnt <= 0)
127 		return (EOF);
128 	bufp = buf;
129 	bufcnt--;
130 	return ((unsigned char)*bufp++);
131 }
132 
133 /*
134  * fdio_error - used on a file descriptor instead of ferror()
135  */
136 
137 /*ARGSUSED*/
138 static int
139 fdio_error(int fd)
140 {
141 	return (buferr);
142 }
143 
144 /*
145  * timedread - read buffer (like "read"), but with timeout (in seconds)
146  */
147 
148 static ssize_t
149 timedread(int fd, void *buf, size_t size, int timeout)
150 {
151 	struct fd_set mask;
152 	struct timeval tv;
153 	int err;
154 
155 	if (!timeout)
156 		return (READ(fd, buf, size));
157 
158 	tv.tv_sec = (time_t)timeout;
159 	tv.tv_usec = 0;
160 
161 	FD_ZERO(&mask);
162 	FD_SET(fd, &mask);
163 
164 	err = select(fd + 1, &mask, NULL, NULL, &tv);
165 	if (err == 0)
166 		errno = ETIMEDOUT;
167 	if (err <= 0)
168 		return (-1);
169 
170 	return (READ(fd, buf, size));
171 }
172 
173 
174 char *
175 hookup(char *host, char *service)
176 {
177 	struct addrinfo hints, *ai = NULL, *ai_head;
178 	int s;
179 	socklen_t len;
180 	static char hostnamebuf[80];
181 	struct in6_addr ipv6addr;
182 	char abuf[INET6_ADDRSTRLEN];
183 	int error_num;
184 	int on = 1;
185 
186 	/*
187 	 * There appears to be a bug in getaddrinfo() where, if the
188 	 * ai_family is set to AF_INET6, and the host is a v4-only
189 	 * host, getaddrinfo() returns an error instead of returning
190 	 * an v4-mapped ipv6 address. Therefore the ai_family is
191 	 * set to AF_UNSPEC and any returned v4 addresses are
192 	 * explicitly mapped within ftp.
193 	 */
194 	bzero((char *)&remctladdr, sizeof (remctladdr));
195 	bzero((char *)&hints, sizeof (hints));
196 	hints.ai_flags = AI_CANONNAME;
197 	hints.ai_family = AF_UNSPEC;
198 	hints.ai_socktype = SOCK_STREAM;
199 
200 	error_num = getaddrinfo(host, service, &hints, &ai);
201 	if (error_num != 0) {
202 		if (error_num == EAI_AGAIN) {
203 			(void) printf(
204 			    "%s: unknown host or invalid literal address "
205 			    "(try again later)\n", host);
206 		} else {
207 			(void) printf(
208 			    "%s: unknown host or invalid literal address\n",
209 			    host);
210 		}
211 		code = -1;
212 		return ((char *)0);
213 	}
214 	ai_head = ai;
215 
216 
217 	/*
218 	 * If ai_canonname is a IPv4-mapped IPv6 literal, we'll convert it to
219 	 * IPv4 literal address.
220 	 */
221 	if (ai->ai_canonname != NULL &&
222 	    (inet_pton(AF_INET6, ai->ai_canonname, &ipv6addr) > 0) &&
223 	    IN6_IS_ADDR_V4MAPPED(&ipv6addr)) {
224 		struct in_addr src4;
225 		hostnamebuf[0] = '\0';
226 		IN6_V4MAPPED_TO_INADDR(&ipv6addr, &src4);
227 		(void) inet_ntop(AF_INET, &src4, hostnamebuf,
228 		    sizeof (hostnamebuf));
229 
230 		/*
231 		 * It can even be the case that the "host" supplied by the user
232 		 * can be a IPv4-mapped IPv6 literal. So, let's fix that too.
233 		 */
234 		if ((inet_pton(AF_INET6, host, &ipv6addr) > 0) &&
235 		    IN6_IS_ADDR_V4MAPPED(&ipv6addr) &&
236 		    strlen(hostnamebuf) <= strlen(host)) {
237 			(void) strlcpy(host, hostnamebuf, strlen(host) + 1);
238 		}
239 	} else {
240 		reset_timer();
241 		(void) strlcpy(hostnamebuf,
242 		    (ai->ai_canonname ? ai->ai_canonname : host),
243 		    sizeof (hostnamebuf));
244 	}
245 
246 	hostname = hostnamebuf;
247 	for (;;) {
248 		int oerrno;
249 
250 		bcopy(ai->ai_addr, &remctladdr, ai->ai_addrlen);
251 		if (ai->ai_addr->sa_family == AF_INET) {
252 			IN6_INADDR_TO_V4MAPPED(
253 			    &(((struct sockaddr_in *)ai->ai_addr)->sin_addr),
254 			    &remctladdr.sin6_addr);
255 			remctladdr.sin6_family = AF_INET6;
256 		}
257 
258 		s = socket(AF_INET6, SOCK_STREAM, 0);
259 		if (s < 0) {
260 			perror("ftp: socket");
261 			code = -1;
262 			freeaddrinfo(ai_head);
263 			return (0);
264 		}
265 		if (timeout && setsockopt(s, IPPROTO_TCP, TCP_ABORT_THRESHOLD,
266 		    (char *)&timeoutms, sizeof (timeoutms)) < 0 && debug)
267 			perror("ftp: setsockopt (TCP_ABORT_THRESHOLD)");
268 		reset_timer();
269 
270 		error_num = connect(s, (struct sockaddr *)&remctladdr,
271 		    sizeof (remctladdr));
272 		oerrno = errno;
273 		if (error_num >= 0)
274 			break;
275 
276 		/*
277 		 * Maintain message behavior: only include the address in
278 		 * our error message if we have another one to try; if this
279 		 * is the last address on our list, just print the error.
280 		 */
281 		if (ai->ai_next != NULL) {
282 			(void) fprintf(stderr, "ftp: connect to address %s: ",
283 			    inet_ntop_native(ai->ai_addr->sa_family,
284 			    (void *)ai->ai_addr, abuf, sizeof (abuf)));
285 			errno = oerrno;
286 			perror((char *)0);
287 		} else {
288 			perror("ftp: connect");
289 			code = -1;
290 			freeaddrinfo(ai_head);
291 			goto bad;
292 		}
293 		ai = ai->ai_next;
294 		(void) fprintf(stdout, "Trying %s...\n",
295 		    inet_ntop_native(ai->ai_addr->sa_family,
296 		    (void *)ai->ai_addr, abuf, sizeof (abuf)));
297 		(void) close(s);
298 
299 	}
300 
301 	/* Set ipv6rem to TRUE if control connection is a native IPv6 address */
302 	if (IN6_IS_ADDR_V4MAPPED(&remctladdr.sin6_addr))
303 		ipv6rem = B_FALSE;
304 	else
305 		ipv6rem = B_TRUE;
306 
307 
308 	freeaddrinfo(ai_head);
309 	ai = NULL;
310 
311 	/*
312 	 * Set passive mode flag on by default only if a native IPv6 address
313 	 * is being used -and- the use_eprt is not set.
314 	 */
315 	if (ipv6rem == B_TRUE && use_eprt == 0)
316 		passivemode = 1;
317 
318 	len = sizeof (myctladdr);
319 	if (getsockname(s, (struct sockaddr *)&myctladdr, &len) < 0) {
320 		perror("ftp: getsockname");
321 		code = -1;
322 		goto bad;
323 	}
324 	ctrl_in = fdopen(s, "r");
325 	ctrl_out = fdopen(s, "w");
326 	if (ctrl_in == NULL || ctrl_out == NULL) {
327 		(void) fprintf(stderr, "ftp: fdopen failed.\n");
328 		if (ctrl_in)
329 			(void) fclose(ctrl_in);
330 		if (ctrl_out)
331 			(void) fclose(ctrl_out);
332 		code = -1;
333 		goto bad;
334 	}
335 	if (verbose)
336 		(void) printf("Connected to %s.\n", hostname);
337 	if (getreply(0) > 2) {	/* read startup message from server */
338 		if (ctrl_in)
339 			(void) fclose(ctrl_in);
340 		if (ctrl_out)
341 			(void) fclose(ctrl_out);
342 		ctrl_in = ctrl_out = NULL;
343 		ctrl_in = ctrl_out = NULL;
344 		code = -1;
345 		goto bad;
346 	}
347 	if (setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (char *)&on,
348 	    sizeof (on)) < 0 && debug)
349 		perror("ftp: setsockopt (SO_OOBINLINE)");
350 
351 	return (hostname);
352 bad:
353 	(void) close(s);
354 	return ((char *)0);
355 }
356 
357 int
358 login(char *host)
359 {
360 	char tmp[80];
361 	char *user, *pass, *acct;
362 	int n, aflag = 0;
363 
364 	user = pass = acct = 0;
365 	if (ruserpass(host, &user, &pass, &acct) < 0) {
366 		disconnect(0, NULL);
367 		code = -1;
368 		return (0);
369 	}
370 	if (user == NULL) {
371 		char *myname = getlogin();
372 
373 		if (myname == NULL) {
374 			struct passwd *pp = getpwuid(getuid());
375 
376 			if (pp != NULL)
377 				myname = pp->pw_name;
378 		}
379 		stop_timer();
380 		(void) printf("Name (%s:%s): ", host,
381 			(myname == NULL) ? "" : myname);
382 		*tmp = '\0';
383 		if (fgets(tmp, sizeof (tmp) - 1, stdin) != NULL)
384 			tmp[strlen(tmp) - 1] = '\0';
385 		if (*tmp != '\0')
386 			user = tmp;
387 		else if (myname != NULL)
388 			user = myname;
389 		else
390 			return (0);
391 	}
392 	n = command("USER %s", user);
393 	if (n == CONTINUE) {
394 		int oldclevel;
395 		if (pass == NULL)
396 			pass = mygetpass("Password:");
397 		oldclevel = clevel;
398 		clevel = PROT_P;
399 		n = command("PASS %s", pass);
400 		/* level may have changed */
401 		if (clevel == PROT_P)
402 			clevel = oldclevel;
403 	}
404 	if (n == CONTINUE) {
405 		aflag++;
406 		if (acct == NULL)
407 			acct = mygetpass("Account:");
408 		n = command("ACCT %s", acct);
409 	}
410 	if (n != COMPLETE) {
411 		(void) fprintf(stderr, "Login failed.\n");
412 		return (0);
413 	}
414 	if (!aflag && acct != NULL)
415 		(void) command("ACCT %s", acct);
416 	if (proxy)
417 		return (1);
418 	for (n = 0; n < macnum; ++n) {
419 		if (strcmp("init", macros[n].mac_name) == 0) {
420 			(void) strlcpy(line, "$init", sizeof (line));
421 			makeargv();
422 			domacro(margc, margv);
423 			break;
424 		}
425 	}
426 	return (1);
427 }
428 
429 /*ARGSUSED*/
430 static void
431 cmdabort(int sig)
432 {
433 	(void) printf("\n");
434 	(void) fflush(stdout);
435 	abrtflag++;
436 	if (ptflag)
437 		longjmp(ptabort, 1);
438 }
439 
440 int
441 command(char *fmt, ...)
442 {
443 	int r;
444 	void (*oldintr)();
445 	va_list ap;
446 	char command_buf[FTPBUFSIZ];
447 
448 	va_start(ap, fmt);
449 	abrtflag = 0;
450 	if (debug) {
451 		(void) printf("---> ");
452 		if (strncmp("PASS ", fmt, 5) == 0)
453 			(void) printf("PASS XXXX");
454 		else if (strncmp("ACCT ", fmt, 5) == 0)
455 			(void) printf("ACCT XXXX");
456 		else
457 			(void) vfprintf(stdout, fmt, ap);
458 		(void) printf("\n");
459 		(void) fflush(stdout);
460 	}
461 	if (ctrl_out == NULL) {
462 		perror("No control connection for command");
463 		code = -1;
464 		return (0);
465 	}
466 	oldintr = signal(SIGINT, cmdabort);
467 	(void) vsnprintf(command_buf, FTPBUFSIZ, fmt, ap);
468 	va_end(ap);
469 
470 again:	if (secure_command(command_buf) == 0)
471 		return (0);
472 
473 	cpend = 1;
474 	r = getreply(strcmp(fmt, "QUIT") == 0);
475 
476 	if (r == 533 && clevel == PROT_P) {
477 		(void) fprintf(stderr, "ENC command not supported at server; "
478 			"retrying under MIC...\n");
479 		clevel = PROT_S;
480 		goto again;
481 	}
482 
483 	if (abrtflag && oldintr != SIG_IGN)
484 		(*oldintr)();
485 	(void) signal(SIGINT, oldintr);
486 	return (r);
487 }
488 
489 /* Need to save reply reponse from server for use in EPSV mode */
490 char reply_string[BUFSIZ];
491 
492 int
493 getreply(int expecteof)
494 {
495 	/*
496 	 * 'code' is the 3 digit reply code, form xyz
497 	 * 'dig'  counts the number of digits we are along in the code
498 	 * 'n'	is the first digit of 'code'
499 	 *	4yz: resource unavailable
500 	 *	5yz: an error occurred, failure
501 	 *	6yz: protected reply (is_base64 == TRUE)
502 	 *		631 - base 64 encoded safe message
503 	 * 		632 - base 64 encoded private message
504 	 * 		633 - base 64 encoded confidential message
505 	 * 'c'	is a wide char type, for international char sets
506 	 */
507 	wint_t c;
508 	int i, n;
509 	int dig;
510 	int originalcode = 0, continuation = 0;
511 	void (*oldintr)();
512 	int pflag = 0;
513 	char *pt = pasv;
514 	/*
515 	 * this is the input and output buffers needed for
516 	 * radix_encode()
517 	 */
518 	unsigned char ibuf[FTPBUFSIZ];
519 	unsigned char obuf[FTPBUFSIZ];
520 	boolean_t is_base64;
521 	int len;
522 	char *cp;
523 
524 	if (!ctrl_in)
525 		return (0);
526 	oldintr = signal(SIGINT, cmdabort);
527 
528 	ibuf[0] = '\0';
529 
530 	if (reply_parse)
531 		reply_ptr = reply_buf;
532 
533 	for (;;) {
534 		obuf[0] = '\0';
535 		dig = n = code = 0;
536 		i = is_base64 = 0;
537 		cp = reply_string;
538 		reset_timer();	/* once per line */
539 
540 		while ((c = ibuf[0] ?
541 		    (wint_t)ibuf[i++] : fgetwc(ctrl_in)) != '\n') {
542 
543 		    if (i >= FTPBUFSIZ)
544 			break;
545 
546 		    if (c == IAC) {	/* handle telnet commands */
547 			switch (c = fgetwc(ctrl_in)) {
548 			    case WILL:
549 			    case WONT:
550 				c = fgetwc(ctrl_in);
551 				(void) fprintf(ctrl_out, "%c%c%wc", IAC,
552 				    WONT, c);
553 				(void) fflush(ctrl_out);
554 				break;
555 			    case DO:
556 			    case DONT:
557 				c = fgetwc(ctrl_in);
558 				(void) fprintf(ctrl_out, "%c%c%wc", IAC,
559 				    DONT, c);
560 				(void) fflush(ctrl_out);
561 				break;
562 			    default:
563 				break;
564 			}
565 			continue;
566 		    }
567 		    dig++;
568 		    if (c == EOF) {
569 			if (expecteof) {
570 				(void) signal(SIGINT, oldintr);
571 				code = 221;
572 				return (0);
573 			}
574 			lostpeer(0);
575 			if (verbose) {
576 				(void) printf(
577 				    "421 Service not available, remote"
578 				    " server has closed connection\n");
579 			} else
580 				(void) printf("Lost connection\n");
581 			(void) fflush(stdout);
582 			code = 421;
583 			return (4);
584 		    }
585 		    if (n == 0)
586 			n = c;
587 
588 		    if (n == '6')
589 			is_base64 = 1;
590 
591 		    if ((auth_type != AUTHTYPE_NONE) && !ibuf[0] &&
592 			(is_base64 || continuation))  {
593 			/* start storing chars in obuf */
594 			if (c != '\r' && dig > 4)
595 				obuf[i++] = (char)c;
596 		    } else {
597 			if ((auth_type != AUTHTYPE_NONE) && !ibuf[0] &&
598 			    dig == 1 && verbose)
599 			    (void) printf("Unauthenticated reply received "
600 				"from server:\n");
601 			if (reply_parse)
602 				*reply_ptr++ = (char)c;
603 			if (c != '\r' && (verbose > 0 ||
604 			    (verbose > -1 && n == '5' && dig > 4))) {
605 				if (proxflag &&
606 				    (dig == 1 || dig == 5 && verbose == 0))
607 					(void) printf("%s:", hostname);
608 				(void) putwchar(c);
609 			}
610 		    } /* endif auth_type && !ibuf[0] ... */
611 
612 		    if ((auth_type != AUTHTYPE_NONE) && !ibuf[0] && !is_base64)
613 			continue;
614 
615 		    /* we are still extracting the 3 digit code */
616 		    if (dig < 4 && isascii(c) && isdigit(c))
617 			code = code * 10 + (c - '0');
618 
619 		    /* starting passive mode */
620 		    if (!pflag && code == 227)
621 			pflag = 1;
622 
623 		    /* start to store characters, when dig > 4 */
624 		    if (dig > 4 && pflag == 1 && isascii(c) && isdigit(c))
625 			pflag = 2;
626 		    if (pflag == 2) {
627 			if (c != '\r' && c != ')') {
628 				/* the mb array is to deal with the wchar_t */
629 				char mb[MB_LEN_MAX];
630 				int avail;
631 
632 				/*
633 				 * space available in pasv[], accounting
634 				 * for trailing NULL
635 				 */
636 				avail = &pasv[sizeof (pasv)] - pt - 1;
637 
638 				len = wctomb(mb, c);
639 				if (len <= 0 && avail > 0) {
640 					*pt++ = (unsigned char)c;
641 				} else if (len > 0 && avail >= len) {
642 					bcopy(mb, pt, (size_t)len);
643 					pt += len;
644 				} else {
645 					/*
646 					 * no room in pasv[];
647 					 * close connection
648 					 */
649 					(void) printf("\nReply too long - "
650 					    "closing connection\n");
651 					lostpeer(0);
652 					(void) fflush(stdout);
653 					(void) signal(SIGINT, oldintr);
654 					return (4);
655 				}
656 			} else {
657 				*pt = '\0';
658 				pflag = 3;
659 			}
660 		    } /* endif pflag == 2 */
661 		    if (dig == 4 && c == '-' && !is_base64) {
662 			if (continuation)
663 				code = 0;
664 			continuation++;
665 		    }
666 		    if (cp < &reply_string[sizeof (reply_string) - 1])
667 			*cp++ = c;
668 
669 		} /* end while */
670 
671 		if ((auth_type != AUTHTYPE_NONE) && !ibuf[0] && !is_base64)
672 			return (getreply(expecteof));
673 
674 		ibuf[0] = obuf[i] = '\0';
675 
676 		if (code && is_base64) {
677 		    boolean_t again = 0;
678 		    n = decode_reply(ibuf, sizeof (ibuf), obuf, n, &again);
679 		    if (again)
680 			continue;
681 		} else
682 
683 		if (verbose > 0 || verbose > -1 && n == '5') {
684 			(void) putwchar(c);
685 			(void) fflush(stdout);
686 		}
687 
688 		if (continuation && code != originalcode) {
689 			ibuf[0] = obuf[i] = '\0';
690 			if (originalcode == 0)
691 				originalcode = code;
692 			continue;
693 		}
694 		*cp = '\0';
695 		if (n != '1')
696 			cpend = 0;
697 		(void) signal(SIGINT, oldintr);
698 		if (code == 421 || originalcode == 421)
699 			lostpeer(0);
700 		if (abrtflag && oldintr != cmdabort && oldintr != SIG_IGN)
701 			(*oldintr)();
702 
703 		if (reply_parse) {
704 		    *reply_ptr = '\0';
705 		    if (reply_ptr = strstr(reply_buf, reply_parse)) {
706 			reply_parse = reply_ptr + strlen(reply_parse);
707 			if (reply_ptr = strpbrk(reply_parse, " \r"))
708 				*reply_ptr = '\0';
709 		    } else
710 			reply_parse = reply_ptr;
711 		}
712 
713 		return (n - '0');
714 	} /* end for */
715 }
716 
717 static int
718 empty(struct fd_set *mask, int sec, int nfds)
719 {
720 	struct timeval t;
721 
722 	reset_timer();
723 	t.tv_sec = (time_t)sec;
724 	t.tv_usec = 0;
725 	return (select(nfds, mask, NULL, NULL, &t));
726 }
727 
728 /*ARGSUSED*/
729 static void
730 abortsend(int sig)
731 {
732 	mflag = 0;
733 	abrtflag = 0;
734 	(void) printf("\nsend aborted\n");
735 	(void) fflush(stdout);
736 	longjmp(sendabort, 1);
737 }
738 
739 void
740 sendrequest(char *cmd, char *local, char *remote, int allowpipe)
741 {
742 	FILE *fin, *dout = 0;
743 	int (*closefunc)();
744 	void (*oldintr)(), (*oldintp)();
745 	off_t bytes = 0, hashbytes = HASHSIZ;
746 	int c;
747 	/*
748 	 * d >=	 0 if there is no error
749 	 *	-1 if there was a normal file i/o error
750 	 *	-2 if there was a security error
751 	 */
752 	int d;
753 	struct stat st;
754 	hrtime_t start, stop;
755 	char *dmode;
756 
757 	if (proxy) {
758 		proxtrans(cmd, local, remote);
759 		return;
760 	}
761 	closefunc = NULL;
762 	oldintr = NULL;
763 	oldintp = NULL;
764 	dmode = "w";
765 	if (setjmp(sendabort)) {
766 		while (cpend) {
767 			(void) getreply(0);
768 		}
769 		if (data >= 0) {
770 			(void) close(data);
771 			data = -1;
772 		}
773 		if (oldintr)
774 			(void) signal(SIGINT, oldintr);
775 		if (oldintp)
776 			(void) signal(SIGPIPE, oldintp);
777 		code = -1;
778 		restart_point = 0;
779 		return;
780 	}
781 	oldintr = signal(SIGINT, abortsend);
782 	if (strcmp(local, "-") == 0)
783 		fin = stdin;
784 	else if (allowpipe && *local == '|') {
785 		oldintp = signal(SIGPIPE, SIG_IGN);
786 		fin = mypopen(local + 1, "r");
787 		if (fin == NULL) {
788 			perror(local + 1);
789 			(void) signal(SIGINT, oldintr);
790 			(void) signal(SIGPIPE, oldintp);
791 			code = -1;
792 			restart_point = 0;
793 			return;
794 		}
795 		closefunc = mypclose;
796 	} else {
797 		fin = fopen(local, "r");
798 		if (fin == NULL) {
799 			perror(local);
800 			(void) signal(SIGINT, oldintr);
801 			code = -1;
802 			restart_point = 0;
803 			return;
804 		}
805 		closefunc = fclose;
806 		if (fstat(fileno(fin), &st) < 0 ||
807 		    (st.st_mode&S_IFMT) != S_IFREG) {
808 			(void) fprintf(stdout,
809 				"%s: not a plain file.\n", local);
810 			(void) signal(SIGINT, oldintr);
811 			code = -1;
812 			(void) fclose(fin);
813 			restart_point = 0;
814 			return;
815 		}
816 	}
817 	if (initconn()) {
818 		(void) signal(SIGINT, oldintr);
819 		if (oldintp)
820 			(void) signal(SIGPIPE, oldintp);
821 		code = -1;
822 		if (closefunc != NULL)
823 			(*closefunc)(fin);
824 		restart_point = 0;
825 		return;
826 	}
827 	if (setjmp(sendabort))
828 		goto abort;
829 	if ((restart_point > 0) &&
830 	    (strcmp(cmd, "STOR") == 0 || strcmp(cmd, "APPE") == 0)) {
831 		if (fseeko(fin, restart_point, SEEK_SET) < 0) {
832 			perror(local);
833 			if (closefunc != NULL)
834 				(*closefunc)(fin);
835 			restart_point = 0;
836 			return;
837 		}
838 		if (command("REST %lld", (longlong_t)restart_point)
839 			!= CONTINUE) {
840 			if (closefunc != NULL)
841 				(*closefunc)(fin);
842 			restart_point = 0;
843 			return;
844 		}
845 		dmode = "r+w";
846 	}
847 	restart_point = 0;
848 	if (remote) {
849 		if (command("%s %s", cmd, remote) != PRELIM) {
850 			(void) signal(SIGINT, oldintr);
851 			if (oldintp)
852 				(void) signal(SIGPIPE, oldintp);
853 			if (closefunc != NULL)
854 				(*closefunc)(fin);
855 			if (data >= 0) {
856 				(void) close(data);
857 				data = -1;
858 			}
859 			return;
860 		}
861 	} else
862 		if (command("%s", cmd) != PRELIM) {
863 			(void) signal(SIGINT, oldintr);
864 			if (oldintp)
865 				(void) signal(SIGPIPE, oldintp);
866 			if (closefunc != NULL)
867 				(*closefunc)(fin);
868 			if (data >= 0) {
869 				(void) close(data);
870 				data = -1;
871 			}
872 			return;
873 		}
874 	dout = dataconn(dmode);
875 	if (dout == NULL)
876 		goto abort;
877 	stop_timer();
878 	oldintp = signal(SIGPIPE, SIG_IGN);
879 	start = gethrtime();
880 	switch (type) {
881 
882 	case TYPE_I:
883 	case TYPE_L:
884 		errno = d = 0;
885 		while ((c = read(fileno(fin), buf, FTPBUFSIZ)) > 0) {
886 			if ((d = WRITE(fileno(dout), buf, c)) < 0)
887 				break;
888 			bytes += c;
889 			if (hash) {
890 				while (bytes >= hashbytes) {
891 					(void) putchar('#');
892 					hashbytes += HASHSIZ;
893 				}
894 				(void) fflush(stdout);
895 			}
896 		}
897 		if (hash && bytes > 0) {
898 			if (bytes < hashbytes)
899 				(void) putchar('#');
900 			(void) putchar('\n');
901 			(void) fflush(stdout);
902 		}
903 		if (c < 0)
904 			perror(local);
905 
906 		if (d >= 0)
907 			d = secure_flush(fileno(dout));
908 
909 		if (d < 0) {
910 			if ((d == -1) && (errno != EPIPE))
911 				perror("netout");
912 			bytes = -1;
913 		}
914 		break;
915 
916 	case TYPE_A:
917 		while ((c = getc(fin)) != EOF) {
918 			if (c == '\n') {
919 				while (hash && (bytes >= hashbytes)) {
920 					(void) putchar('#');
921 					(void) fflush(stdout);
922 					hashbytes += HASHSIZ;
923 				}
924 				if (ferror(dout) || PUTC('\r', dout) < 0)
925 					break;
926 				bytes++;
927 			}
928 
929 			if (PUTC(c, dout) < 0)
930 				break;
931 			bytes++;
932 #ifdef notdef
933 			if (c == '\r') {
934 				/* this violates rfc */
935 				(void) PUTC('\0', dout);
936 				bytes++;
937 			}
938 #endif
939 		}
940 		if (hash && bytes > 0) {
941 			if (bytes < hashbytes)
942 				(void) putchar('#');
943 			(void) putchar('\n');
944 			(void) fflush(stdout);
945 		}
946 		if (ferror(fin))
947 			perror(local);
948 
949 		d = ferror(dout) ? -1 : 0;
950 		if (d == 0)
951 			d = secure_flush(fileno(dout));
952 
953 		if (d < 0) {
954 			if ((d == -1) && (errno != EPIPE))
955 				perror("netout");
956 			bytes = -1;
957 		}
958 		break;
959 	}
960 	reset_timer();
961 	if (closefunc != NULL)
962 		(*closefunc)(fin);
963 	if (ctrl_in != NULL) {
964 		int	dfn	= fileno(dout);
965 		int	nfds	= fileno(ctrl_in);
966 		fd_set  mask;
967 
968 		/*
969 		 * There could be data not yet written to dout,
970 		 * in the stdio buffer; so, before a shutdown()
971 		 * on further sends, do fflush(dout)
972 		 */
973 		(void) fflush(dout);
974 
975 		/* sending over; shutdown sending on dfn */
976 		(void) shutdown(dfn, SHUT_WR);
977 		FD_ZERO(&mask);
978 		FD_SET(dfn, &mask);
979 		FD_SET(nfds, &mask);
980 		nfds = MAX(dfn, nfds);
981 
982 		/*
983 		 * Wait for remote end to either close data socket
984 		 * or ack that we've closed our end; it doesn't
985 		 * matter which happens first.
986 		 */
987 		(void) select(nfds + 1, &mask, NULL, NULL, NULL);
988 	}
989 	(void) fclose(dout); data = -1;
990 	stop = gethrtime();
991 	(void) getreply(0);
992 	(void) signal(SIGINT, oldintr);
993 	if (oldintp)
994 		(void) signal(SIGPIPE, oldintp);
995 
996 	/*
997 	 * Only print the transfer successful message if the code returned
998 	 * from remote is 226 or 250. All other codes are error codes.
999 	 */
1000 	if ((bytes > 0) && verbose && ((code == 226) || (code == 250)))
1001 		ptransfer("sent", bytes, start, stop, local, remote);
1002 	if (!ctrl_in)
1003 		(void) printf("Lost connection\n");
1004 	return;
1005 abort:
1006 	(void) signal(SIGINT, oldintr);
1007 	if (oldintp)
1008 		(void) signal(SIGPIPE, oldintp);
1009 	if (!cpend) {
1010 		code = -1;
1011 		return;
1012 	}
1013 	if (data >= 0) {
1014 		(void) close(data);
1015 		data = -1;
1016 	}
1017 	if (dout) {
1018 		(void) fclose(dout);
1019 		data = -1;
1020 	}
1021 	(void) getreply(0);
1022 	code = -1;
1023 	if (closefunc != NULL && fin != NULL)
1024 		(*closefunc)(fin);
1025 	stop = gethrtime();
1026 	/*
1027 	 * Only print the transfer successful message if the code returned
1028 	 * from remote is 226 or 250. All other codes are error codes.
1029 	 */
1030 	if ((bytes > 0) && verbose && ((code == 226) || (code == 250)))
1031 		ptransfer("sent", bytes, start, stop, local, remote);
1032 	if (!ctrl_in)
1033 		(void) printf("Lost connection\n");
1034 	restart_point = 0;
1035 }
1036 
1037 /*ARGSUSED*/
1038 static void
1039 abortrecv(int sig)
1040 {
1041 	mflag = 0;
1042 	abrtflag = 0;
1043 	(void) printf("\n");
1044 	(void) fflush(stdout);
1045 	longjmp(recvabort, 1);
1046 }
1047 
1048 void
1049 recvrequest(char *cmd, char *local, char *remote, char *mode, int allowpipe)
1050 {
1051 	FILE *fout, *din = 0;
1052 	int (*closefunc)();
1053 	void (*oldintr)(), (*oldintp)();
1054 	int oldverbose, oldtype = 0, tcrflag, nfnd;
1055 	char msg;
1056 	off_t bytes = 0, hashbytes = HASHSIZ;
1057 	struct fd_set mask;
1058 	int c, d, n;
1059 	hrtime_t start, stop;
1060 	int errflg = 0;
1061 	int infd;
1062 	int nfds;
1063 	int retrcmd;
1064 
1065 	retrcmd = (strcmp(cmd, "RETR") == 0);
1066 	if (proxy && retrcmd) {
1067 		proxtrans(cmd, local, remote);
1068 		return;
1069 	}
1070 	closefunc = NULL;
1071 	oldintr = NULL;
1072 	oldintp = NULL;
1073 	tcrflag = !crflag && retrcmd;
1074 	if (setjmp(recvabort)) {
1075 		while (cpend) {
1076 			(void) getreply(0);
1077 		}
1078 		if (data >= 0) {
1079 			(void) close(data);
1080 			data = -1;
1081 		}
1082 		if (oldintr)
1083 			(void) signal(SIGINT, oldintr);
1084 		code = -1;
1085 		return;
1086 	}
1087 	oldintr = signal(SIGINT, abortrecv);
1088 	if (local != NULL &&
1089 	    strcmp(local, "-") != 0 &&
1090 	    (*local != '|' || !allowpipe)) {
1091 		if (access(local, W_OK) < 0) {
1092 			char *dir = rindex(local, '/');
1093 			int file_errno = errno;
1094 
1095 			if (file_errno != ENOENT && file_errno != EACCES) {
1096 				perror(local);
1097 				(void) signal(SIGINT, oldintr);
1098 				code = -1;
1099 				return;
1100 			}
1101 			if ((dir != NULL) && (dir != local))
1102 				*dir = 0;
1103 			if (dir == local)
1104 				d = access("/", W_OK);
1105 			else
1106 				d = access(dir ? local : ".", W_OK);
1107 			if ((dir != NULL) && (dir != local))
1108 				*dir = '/';
1109 			if (d < 0) {
1110 				perror(local);
1111 				(void) signal(SIGINT, oldintr);
1112 				code = -1;
1113 				return;
1114 			}
1115 			if (!runique && file_errno == EACCES) {
1116 				errno = file_errno;
1117 				perror(local);
1118 				(void) signal(SIGINT, oldintr);
1119 				code = -1;
1120 				return;
1121 			}
1122 			if (runique && file_errno == EACCES &&
1123 			    (local = gunique(local)) == NULL) {
1124 				(void) signal(SIGINT, oldintr);
1125 				code = -1;
1126 				return;
1127 			}
1128 		} else if (runique && (local = gunique(local)) == NULL) {
1129 			(void) signal(SIGINT, oldintr);
1130 			code = -1;
1131 			return;
1132 		}
1133 	}
1134 	if (initconn()) {
1135 		(void) signal(SIGINT, oldintr);
1136 		code = -1;
1137 		return;
1138 	}
1139 	if (setjmp(recvabort))
1140 		goto abort;
1141 	if (!retrcmd && type != TYPE_A) {
1142 		oldtype = type;
1143 		oldverbose = verbose;
1144 		if (!debug)
1145 			verbose = 0;
1146 		setascii(0, NULL);
1147 		verbose = oldverbose;
1148 	}
1149 	if ((restart_point > 0) && retrcmd &&
1150 	    command("REST %lld", (longlong_t)restart_point) != CONTINUE) {
1151 		return;
1152 	}
1153 	if (remote) {
1154 		if (command("%s %s", cmd, remote) != PRELIM) {
1155 			(void) signal(SIGINT, oldintr);
1156 			if (oldtype) {
1157 				if (!debug)
1158 					verbose = 0;
1159 				switch (oldtype) {
1160 					case TYPE_I:
1161 						setbinary(0, NULL);
1162 						break;
1163 					case TYPE_E:
1164 						setebcdic(0, NULL);
1165 						break;
1166 					case TYPE_L:
1167 						settenex(0, NULL);
1168 						break;
1169 				}
1170 				verbose = oldverbose;
1171 			}
1172 			return;
1173 		}
1174 	} else {
1175 		if (command("%s", cmd) != PRELIM) {
1176 			(void) signal(SIGINT, oldintr);
1177 			if (oldtype) {
1178 				if (!debug)
1179 					verbose = 0;
1180 				switch (oldtype) {
1181 					case TYPE_I:
1182 						setbinary(0, NULL);
1183 						break;
1184 					case TYPE_E:
1185 						setebcdic(0, NULL);
1186 						break;
1187 					case TYPE_L:
1188 						settenex(0, NULL);
1189 						break;
1190 				}
1191 				verbose = oldverbose;
1192 			}
1193 			return;
1194 		}
1195 	}
1196 	din = dataconn("r");
1197 	if (din == NULL)
1198 		goto abort;
1199 
1200 	if (local == NULL) {
1201 		fout = tmp_nlst;
1202 	} else if (strcmp(local, "-") == 0) {
1203 		fout = stdout;
1204 	} else if (allowpipe && *local == '|') {
1205 		oldintp = signal(SIGPIPE, SIG_IGN);
1206 		fout = mypopen(local + 1, "w");
1207 		if (fout == NULL) {
1208 			perror(local+1);
1209 			goto abort;
1210 		}
1211 		closefunc = mypclose;
1212 	} else {
1213 		fout = fopen(local, mode);
1214 		if (fout == NULL) {
1215 			perror(local);
1216 			goto abort;
1217 		}
1218 		closefunc = fclose;
1219 	}
1220 	start = gethrtime();
1221 	stop_timer();
1222 	switch (type) {
1223 
1224 	case TYPE_I:
1225 	case TYPE_L:
1226 		if ((restart_point > 0) && retrcmd &&
1227 		    lseek(fileno(fout), restart_point, SEEK_SET) < 0) {
1228 			perror(local);
1229 			goto abort;
1230 		}
1231 		errno = d = 0;
1232 		infd = fileno(din);
1233 		while ((c = timedread(infd, buf, FTPBUFSIZ, timeout)) > 0) {
1234 			for (n = 0; n < c; n += d) {
1235 				d = write(fileno(fout), &buf[n], c - n);
1236 				if (d == -1)
1237 					goto writeerr;
1238 			}
1239 			bytes += c;
1240 			if (hash) {
1241 				while (bytes >= hashbytes) {
1242 					(void) putchar('#');
1243 					hashbytes += HASHSIZ;
1244 				}
1245 				(void) fflush(stdout);
1246 			}
1247 		}
1248 		if (hash && bytes > 0) {
1249 			if (bytes < hashbytes)
1250 				(void) putchar('#');
1251 			(void) putchar('\n');
1252 			(void) fflush(stdout);
1253 		}
1254 		if (c < 0) {
1255 			errflg = 1;
1256 			perror("netin");
1257 		}
1258 		if ((d < 0) || ((c == 0) && (fsync(fileno(fout)) == -1))) {
1259 writeerr:
1260 			errflg = 1;
1261 			perror(local);
1262 		}
1263 		break;
1264 
1265 	case TYPE_A:
1266 		if ((restart_point > 0) && retrcmd) {
1267 			int c;
1268 			off_t i = 0;
1269 
1270 			if (fseek(fout, 0L, SEEK_SET) < 0) {
1271 				perror(local);
1272 				goto abort;
1273 			}
1274 			while (i++ < restart_point) {
1275 				if ((c = getc(fout)) == EOF) {
1276 					if (ferror(fout))
1277 						perror(local);
1278 					else
1279 						(void) fprintf(stderr,
1280 						"%s: Unexpected end of file\n",
1281 							local);
1282 					goto abort;
1283 				}
1284 				if (c == '\n')
1285 					i++;
1286 			}
1287 			if (fseeko(fout, 0L, SEEK_CUR) < 0) {
1288 				perror(local);
1289 				goto abort;
1290 			}
1291 		}
1292 		fdio_setbuf(buf, FTPBUFSIZ);
1293 		infd = fileno(din);
1294 		while ((c = fdio_getc(infd)) != EOF) {
1295 			while (c == '\r') {
1296 				while (hash && (bytes >= hashbytes)) {
1297 					(void) putchar('#');
1298 					(void) fflush(stdout);
1299 					hashbytes += HASHSIZ;
1300 				}
1301 				bytes++;
1302 
1303 				if ((c = fdio_getc(infd)) != '\n' || tcrflag) {
1304 					if (ferror(fout))
1305 						break;
1306 					if (putc('\r', fout) == EOF)
1307 						goto writer_ascii_err;
1308 				}
1309 #ifdef notdef
1310 				if (c == '\0') {
1311 					bytes++;
1312 					continue;
1313 				}
1314 #endif
1315 				if (c == EOF)
1316 					goto endread;
1317 			}
1318 			if (putc(c, fout) == EOF)
1319 				goto writer_ascii_err;
1320 			bytes++;
1321 		}
1322 endread:
1323 		if (hash && bytes > 0) {
1324 			if (bytes < hashbytes)
1325 				(void) putchar('#');
1326 			(void) putchar('\n');
1327 			(void) fflush(stdout);
1328 		}
1329 		if (fdio_error(infd)) {
1330 			errflg = 1;
1331 			perror("netin");
1332 		}
1333 		if ((fflush(fout) == EOF) || ferror(fout) ||
1334 			(fsync(fileno(fout)) == -1)) {
1335 writer_ascii_err:
1336 			errflg = 1;
1337 			perror(local);
1338 		}
1339 		break;
1340 	}
1341 	reset_timer();
1342 	if (closefunc != NULL)
1343 		(*closefunc)(fout);
1344 	(void) signal(SIGINT, oldintr);
1345 	if (oldintp)
1346 		(void) signal(SIGPIPE, oldintp);
1347 	(void) fclose(din); data = -1;
1348 	stop = gethrtime();
1349 	(void) getreply(0);
1350 	if (bytes > 0 && verbose && !errflg)
1351 		ptransfer("received", bytes, start, stop, local, remote);
1352 	if (!ctrl_in)
1353 		(void) printf("Lost connection\n");
1354 	if (oldtype) {
1355 		if (!debug)
1356 			verbose = 0;
1357 		switch (oldtype) {
1358 			case TYPE_I:
1359 				setbinary(0, NULL);
1360 				break;
1361 			case TYPE_E:
1362 				setebcdic(0, NULL);
1363 				break;
1364 			case TYPE_L:
1365 				settenex(0, NULL);
1366 				break;
1367 		}
1368 		verbose = oldverbose;
1369 	}
1370 	return;
1371 abort:
1372 
1373 /* abort using RFC959 recommended IP, SYNC sequence  */
1374 
1375 	stop = gethrtime();
1376 	if (oldintp)
1377 		(void) signal(SIGPIPE, oldintp);
1378 	(void) signal(SIGINT, SIG_IGN);
1379 	if (!cpend) {
1380 		code = -1;
1381 		(void) signal(SIGINT, oldintr);
1382 		return;
1383 	}
1384 
1385 	(void) fprintf(ctrl_out, "%c%c", IAC, IP);
1386 	(void) fflush(ctrl_out);
1387 	msg = (char)IAC;
1388 	/*
1389 	 * send IAC in urgent mode instead of DM because UNIX places oob
1390 	 * mark after urgent byte rather than before as now is protocol
1391 	 */
1392 	if (send(fileno(ctrl_out), &msg, 1, MSG_OOB) != 1) {
1393 		perror("abort");
1394 	}
1395 	(void) fprintf(ctrl_out, "%cABOR\r\n", DM);
1396 	(void) fflush(ctrl_out);
1397 	nfds = fileno(ctrl_in) + 1;
1398 	FD_ZERO(&mask);
1399 	FD_SET(fileno(ctrl_in), &mask);
1400 	if (din) {
1401 		FD_SET(fileno(din), &mask);
1402 		nfds = MAX(fileno(din) + 1, nfds);
1403 	}
1404 	if ((nfnd = empty(&mask, 10, nfds)) <= 0) {
1405 		if (nfnd < 0) {
1406 			perror("abort");
1407 		}
1408 		code = -1;
1409 		lostpeer(0);
1410 	}
1411 	if (din && FD_ISSET(fileno(din), &mask)) {
1412 		do {
1413 			reset_timer();
1414 		} while ((c = read(fileno(din), buf, FTPBUFSIZ)) > 0);
1415 	}
1416 	if ((c = getreply(0)) == ERROR && code == 552) {
1417 		/* needed for nic style abort */
1418 		if (data >= 0) {
1419 			(void) close(data);
1420 			data = -1;
1421 		}
1422 		(void) getreply(0);
1423 	}
1424 	if (oldtype) {
1425 		if (!debug)
1426 			verbose = 0;
1427 		switch (oldtype) {
1428 		case TYPE_I:
1429 			setbinary(0, NULL);
1430 			break;
1431 		case TYPE_E:
1432 			setebcdic(0, NULL);
1433 			break;
1434 		case TYPE_L:
1435 			settenex(0, NULL);
1436 			break;
1437 		}
1438 		verbose = oldverbose;
1439 	}
1440 	(void) getreply(0);
1441 	code = -1;
1442 	if (data >= 0) {
1443 		(void) close(data);
1444 		data = -1;
1445 	}
1446 	if (closefunc != NULL && fout != NULL)
1447 		(*closefunc)(fout);
1448 	if (din) {
1449 		(void) fclose(din);
1450 		data = -1;
1451 	}
1452 	if (bytes > 0 && verbose)
1453 		ptransfer("received", bytes, start, stop, local, remote);
1454 	if (!ctrl_in)
1455 		(void) printf("Lost connection\n");
1456 	(void) signal(SIGINT, oldintr);
1457 }
1458 
1459 /*
1460  * Need to start a listen on the data channel
1461  * before we send the command, otherwise the
1462  * server's connect may fail.
1463  */
1464 
1465 static int
1466 initconn(void)
1467 {
1468 	unsigned char *p, *a;
1469 	int result, tmpno = 0;
1470 	int on = 1;
1471 	socklen_t len;
1472 	int v4_addr;
1473 	char *c, *c2, delm;
1474 	in_port_t ports;
1475 
1476 	pasv_refused = B_FALSE;
1477 	if (passivemode) {
1478 		data = socket(AF_INET6, SOCK_STREAM, 0);
1479 		if (data < 0) {
1480 			perror("socket");
1481 			return (1);
1482 		}
1483 		if (timeout && setsockopt(data, IPPROTO_TCP,
1484 		    TCP_ABORT_THRESHOLD, (char *)&timeoutms,
1485 		    sizeof (timeoutms)) < 0 && debug)
1486 			perror("ftp: setsockopt (TCP_ABORT_THRESHOLD)");
1487 		if ((options & SO_DEBUG) &&
1488 		    setsockopt(data, SOL_SOCKET, SO_DEBUG, (char *)&on,
1489 			    sizeof (on)) < 0)
1490 			perror("setsockopt (ignored)");
1491 		/*
1492 		 * Use the system wide default send and receive buffer sizes
1493 		 * unless one has been specified.
1494 		 */
1495 		if (tcpwindowsize) {
1496 			if (setsockopt(data, SOL_SOCKET, SO_SNDBUF,
1497 			    (char *)&tcpwindowsize, sizeof (tcpwindowsize)) < 0)
1498 				perror("ftp: setsockopt (SO_SNDBUF - ignored)");
1499 			if (setsockopt(data, SOL_SOCKET, SO_RCVBUF,
1500 			    (char *)&tcpwindowsize, sizeof (tcpwindowsize)) < 0)
1501 				perror("ftp: setsockopt (SO_RCVBUF - ignored)");
1502 		}
1503 
1504 		data_addr = remctladdr;
1505 
1506 		if (ipv6rem == B_TRUE) {
1507 			if (command("EPSV") != COMPLETE) {
1508 				(void) fprintf(stderr,
1509 					"Passive mode refused. Try EPRT\n");
1510 				pasv_refused = B_TRUE;
1511 				goto noport;
1512 			}
1513 
1514 			/*
1515 			 * Get the data port from reply string from the
1516 			 * server.  The format of the reply string is:
1517 			 * 229 Entering Extended Passive Mode (|||port|)
1518 			 * where | is the delimiter being used.
1519 			 */
1520 			c = strchr(reply_string, '(');
1521 			c2 = strchr(reply_string, ')');
1522 			if (c == NULL || c2 == NULL) {
1523 				(void) fprintf(stderr, "Extended passive mode"
1524 				    "parsing failure.\n");
1525 				goto bad;
1526 			}
1527 			*(c2 - 1) = NULL;
1528 			/* Delimiter is the next char in the reply string */
1529 			delm = *(++c);
1530 			while (*c == delm) {
1531 				if (!*(c++)) {
1532 					(void) fprintf(stderr,
1533 					    "Extended passive mode"
1534 					    "parsing failure.\n");
1535 					goto bad;
1536 				}
1537 			}
1538 			/* assign the port for data connection */
1539 			ports = (in_port_t)atoi(c);
1540 			data_addr.sin6_port =  htons(ports);
1541 		} else {
1542 			int a1, a2, a3, a4, p1, p2;
1543 
1544 			if (command("PASV") != COMPLETE) {
1545 				(void) fprintf(stderr,
1546 					"Passive mode refused. Try PORT\n");
1547 				pasv_refused = B_TRUE;
1548 				goto noport;
1549 			}
1550 
1551 			/*
1552 			 * Get the data port from reply string from the
1553 			 * server.  The format of the reply string is:
1554 			 * 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)
1555 			 */
1556 			if (sscanf(pasv, "%d,%d,%d,%d,%d,%d",
1557 					&a1, &a2, &a3, &a4, &p1, &p2) != 6) {
1558 				(void) fprintf(stderr,
1559 					"Passive mode parsing failure.\n");
1560 				goto bad;
1561 			}
1562 			/*
1563 			 * Set the supplied address and port in an
1564 			 * IPv4-mapped IPv6 address.
1565 			 */
1566 			a = (unsigned char *)&data_addr.sin6_addr +
1567 				sizeof (struct in6_addr) -
1568 				sizeof (struct in_addr);
1569 #define	UC(b)	((b)&0xff)
1570 			a[0] = UC(a1);
1571 			a[1] = UC(a2);
1572 			a[2] = UC(a3);
1573 			a[3] = UC(a4);
1574 			p = (unsigned char *)&data_addr.sin6_port;
1575 			p[0] = UC(p1);
1576 			p[1] = UC(p2);
1577 		}
1578 
1579 		if (connect(data, (struct sockaddr *)&data_addr,
1580 		    sizeof (data_addr)) < 0) {
1581 			perror("connect");
1582 			goto bad;
1583 		}
1584 		return (0);
1585 	}
1586 
1587 noport:
1588 	data_addr = myctladdr;
1589 	if (sendport)
1590 		data_addr.sin6_port = 0;	/* let system pick one */
1591 
1592 	if (data != -1)
1593 		(void) close(data);
1594 	data = socket(AF_INET6, SOCK_STREAM, 0);
1595 	if (data < 0) {
1596 		perror("ftp: socket");
1597 		if (tmpno)
1598 			sendport = 1;
1599 		return (1);
1600 	}
1601 	if (!sendport)
1602 		if (setsockopt(data, SOL_SOCKET, SO_REUSEADDR,
1603 		    (char *)&on, sizeof (on)) < 0) {
1604 			perror("ftp: setsockopt (SO_REUSEADDR)");
1605 			goto bad;
1606 		}
1607 	if (bind(data,
1608 	    (struct sockaddr *)&data_addr, sizeof (data_addr)) < 0) {
1609 		perror("ftp: bind");
1610 		goto bad;
1611 	}
1612 	if (timeout && setsockopt(data, IPPROTO_TCP, TCP_ABORT_THRESHOLD,
1613 	    (char *)&timeoutms, sizeof (timeoutms)) < 0 && debug)
1614 		perror("ftp: setsockopt (TCP_ABORT_THRESHOLD)");
1615 	if (options & SO_DEBUG &&
1616 	    setsockopt(data, SOL_SOCKET, SO_DEBUG,
1617 	    (char *)&on, sizeof (on)) < 0)
1618 		perror("ftp: setsockopt (SO_DEBUG - ignored)");
1619 	/*
1620 	 * Use the system wide default send and receive buffer sizes unless
1621 	 * one has been specified.
1622 	 */
1623 	if (tcpwindowsize) {
1624 		if (setsockopt(data, SOL_SOCKET, SO_SNDBUF,
1625 		    (char *)&tcpwindowsize, sizeof (tcpwindowsize)) < 0)
1626 			perror("ftp: setsockopt (SO_SNDBUF - ignored)");
1627 		if (setsockopt(data, SOL_SOCKET, SO_RCVBUF,
1628 		    (char *)&tcpwindowsize, sizeof (tcpwindowsize)) < 0)
1629 			perror("ftp: setsockopt (SO_RCVBUF - ignored)");
1630 	}
1631 	len = sizeof (data_addr);
1632 	if (getsockname(data, (struct sockaddr *)&data_addr, &len) < 0) {
1633 		perror("ftp: getsockname");
1634 		goto bad;
1635 	}
1636 
1637 	v4_addr = IN6_IS_ADDR_V4MAPPED(&data_addr.sin6_addr);
1638 	if (listen(data, 1) < 0)
1639 		perror("ftp: listen");
1640 
1641 	if (sendport) {
1642 		a = (unsigned char *)&data_addr.sin6_addr;
1643 		p = (unsigned char *)&data_addr.sin6_port;
1644 		if (v4_addr) {
1645 			result =
1646 			    command("PORT %d,%d,%d,%d,%d,%d",
1647 			    UC(a[12]), UC(a[13]), UC(a[14]), UC(a[15]),
1648 			    UC(p[0]), UC(p[1]));
1649 		} else {
1650 			char hname[INET6_ADDRSTRLEN];
1651 
1652 			result = COMPLETE + 1;
1653 			/*
1654 			 * if on previous try to server, it was
1655 			 * determined that the server doesn't support
1656 			 * EPRT, don't bother trying again.  Just try
1657 			 * LPRT.
1658 			 */
1659 			if (eport_supported == B_TRUE) {
1660 				if (inet_ntop(AF_INET6, &data_addr.sin6_addr,
1661 				    hname, sizeof (hname)) != NULL) {
1662 					result = command("EPRT |%d|%s|%d|", 2,
1663 					    hname, htons(data_addr.sin6_port));
1664 					if (result != COMPLETE)
1665 						eport_supported = B_FALSE;
1666 				    }
1667 			}
1668 			/* Try LPRT */
1669 			if (result != COMPLETE) {
1670 				result = command(
1671 "LPRT %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
1672 6, 16,
1673 UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
1674 UC(a[4]), UC(a[5]), UC(a[6]), UC(a[7]),
1675 UC(a[8]), UC(a[9]), UC(a[10]), UC(a[11]),
1676 UC(a[12]), UC(a[13]), UC(a[14]), UC(a[15]),
1677 2, UC(p[0]), UC(p[1]));
1678 			}
1679 		}
1680 
1681 		if (result == ERROR && sendport == -1) {
1682 			sendport = 0;
1683 			tmpno = 1;
1684 			goto noport;
1685 		}
1686 		return (result != COMPLETE);
1687 	}
1688 	if (tmpno)
1689 		sendport = 1;
1690 	return (0);
1691 bad:
1692 	(void) close(data), data = -1;
1693 	if (tmpno)
1694 		sendport = 1;
1695 	return (1);
1696 }
1697 
1698 static FILE *
1699 dataconn(char *mode)
1700 {
1701 	struct sockaddr_in6 from;
1702 	int s;
1703 	socklen_t fromlen = sizeof (from);
1704 
1705 	reset_timer();
1706 	if (passivemode && !pasv_refused)
1707 		return (fdopen(data, mode));
1708 
1709 	s = accept(data, (struct sockaddr *)&from, &fromlen);
1710 	if (s < 0) {
1711 		perror("ftp: accept");
1712 		(void) close(data), data = -1;
1713 		return (NULL);
1714 	}
1715 	(void) close(data);
1716 	data = s;
1717 	return (fdopen(data, mode));
1718 }
1719 
1720 static void
1721 ptransfer(char *direction, off_t bytes, hrtime_t t0,
1722     hrtime_t t1, char *local, char *remote)
1723 {
1724 	hrtime_t td; /* nanoseconds in a 64 bit int */
1725 	double s, bs;
1726 
1727 	td = t1 - t0;
1728 	s = (double)td / 1000000000.0; /* seconds */
1729 	bs = (double)bytes / NONZERO(s);
1730 	if (local && *local != '-')
1731 		(void) printf("local: %s ", local);
1732 	if (remote)
1733 		(void) printf("remote: %s\n", remote);
1734 	(void) printf("%lld bytes %s in %.2g seconds (%.2f Kbytes/s)\n",
1735 		(longlong_t)bytes, direction, s, bs / 1024.0);
1736 }
1737 
1738 /*ARGSUSED*/
1739 static void
1740 psabort(int sig)
1741 {
1742 	abrtflag++;
1743 }
1744 
1745 void
1746 pswitch(int flag)
1747 {
1748 	void (*oldintr)();
1749 	static struct comvars {
1750 		int connect;
1751 		char name[MAXHOSTNAMELEN];
1752 		struct sockaddr_in6 mctl;
1753 		struct sockaddr_in6 hctl;
1754 		FILE *in;
1755 		FILE *out;
1756 		int tpe;
1757 		int cpnd;
1758 		int sunqe;
1759 		int runqe;
1760 		int mcse;
1761 		int ntflg;
1762 		char nti[17];
1763 		char nto[17];
1764 		int mapflg;
1765 		char mi[MAXPATHLEN];
1766 		char mo[MAXPATHLEN];
1767 		int authtype;
1768 		int clvl;
1769 		int dlvl;
1770 		} proxstruct, tmpstruct;
1771 	struct comvars *ip, *op;
1772 
1773 	abrtflag = 0;
1774 	oldintr = signal(SIGINT, psabort);
1775 	if (flag) {
1776 		if (proxy)
1777 			return;
1778 		ip = &tmpstruct;
1779 		op = &proxstruct;
1780 		proxy++;
1781 	} else {
1782 		if (!proxy)
1783 			return;
1784 		ip = &proxstruct;
1785 		op = &tmpstruct;
1786 		proxy = 0;
1787 	}
1788 	ip->connect = connected;
1789 	connected = op->connect;
1790 	if (hostname)
1791 		(void) strlcpy(ip->name, hostname, sizeof (ip->name));
1792 	else
1793 		ip->name[0] = 0;
1794 	hostname = op->name;
1795 	ip->hctl = remctladdr;
1796 	remctladdr = op->hctl;
1797 	ip->mctl = myctladdr;
1798 	myctladdr = op->mctl;
1799 	ip->in = ctrl_in;
1800 	ctrl_in = op->in;
1801 	ip->out = ctrl_out;
1802 	ctrl_out = op->out;
1803 	ip->tpe = type;
1804 	type = op->tpe;
1805 	if (!type)
1806 		type = 1;
1807 	ip->cpnd = cpend;
1808 	cpend = op->cpnd;
1809 	ip->sunqe = sunique;
1810 	sunique = op->sunqe;
1811 	ip->runqe = runique;
1812 	runique = op->runqe;
1813 	ip->mcse = mcase;
1814 	mcase = op->mcse;
1815 	ip->ntflg = ntflag;
1816 	ntflag = op->ntflg;
1817 	(void) strlcpy(ip->nti, ntin, sizeof (ip->nti));
1818 	(void) strlcpy(ntin, op->nti, sizeof (ntin));
1819 	(void) strlcpy(ip->nto, ntout, sizeof (ip->nto));
1820 	(void) strlcpy(ntout, op->nto, sizeof (ntout));
1821 	ip->mapflg = mapflag;
1822 	mapflag = op->mapflg;
1823 	(void) strlcpy(ip->mi, mapin, sizeof (ip->mi));
1824 	(void) strlcpy(mapin, op->mi, sizeof (mapin));
1825 	(void) strlcpy(ip->mo, mapout, sizeof (ip->mo));
1826 	(void) strlcpy(mapout, op->mo, sizeof (mapout));
1827 
1828 	ip->authtype = auth_type;
1829 	auth_type = op->authtype;
1830 	ip->clvl = clevel;
1831 	clevel = op->clvl;
1832 	ip->dlvl = dlevel;
1833 	dlevel = op->dlvl;
1834 	if (!clevel)
1835 		clevel = PROT_C;
1836 	if (!dlevel)
1837 		dlevel = PROT_C;
1838 
1839 	(void) signal(SIGINT, oldintr);
1840 	if (abrtflag) {
1841 		abrtflag = 0;
1842 		(*oldintr)();
1843 	}
1844 }
1845 
1846 /*ARGSUSED*/
1847 static void
1848 abortpt(int sig)
1849 {
1850 	(void) printf("\n");
1851 	(void) fflush(stdout);
1852 	ptabflg++;
1853 	mflag = 0;
1854 	abrtflag = 0;
1855 	longjmp(ptabort, 1);
1856 }
1857 
1858 static void
1859 proxtrans(char *cmd, char *local, char *remote)
1860 {
1861 	void (*oldintr)();
1862 	int tmptype, oldtype = 0, secndflag = 0, nfnd;
1863 	extern jmp_buf ptabort;
1864 	char *cmd2;
1865 	struct fd_set mask;
1866 	int ipv4_addr = IN6_IS_ADDR_V4MAPPED(&remctladdr.sin6_addr);
1867 
1868 	if (strcmp(cmd, "RETR"))
1869 		cmd2 = "RETR";
1870 	else
1871 		cmd2 = runique ? "STOU" : "STOR";
1872 	if (command(ipv4_addr ? "PASV" : "EPSV") != COMPLETE) {
1873 		(void) printf(
1874 		    "proxy server does not support third part transfers.\n");
1875 		return;
1876 	}
1877 	tmptype = type;
1878 	pswitch(0);
1879 	if (!connected) {
1880 		(void) printf("No primary connection\n");
1881 		pswitch(1);
1882 		code = -1;
1883 		return;
1884 	}
1885 	if (type != tmptype) {
1886 		oldtype = type;
1887 		switch (tmptype) {
1888 			case TYPE_A:
1889 				setascii(0, NULL);
1890 				break;
1891 			case TYPE_I:
1892 				setbinary(0, NULL);
1893 				break;
1894 			case TYPE_E:
1895 				setebcdic(0, NULL);
1896 				break;
1897 			case TYPE_L:
1898 				settenex(0, NULL);
1899 				break;
1900 		}
1901 	}
1902 	if (command(ipv4_addr ? "PORT %s" : "EPRT %s", pasv) != COMPLETE) {
1903 		switch (oldtype) {
1904 			case 0:
1905 				break;
1906 			case TYPE_A:
1907 				setascii(0, NULL);
1908 				break;
1909 			case TYPE_I:
1910 				setbinary(0, NULL);
1911 				break;
1912 			case TYPE_E:
1913 				setebcdic(0, NULL);
1914 				break;
1915 			case TYPE_L:
1916 				settenex(0, NULL);
1917 				break;
1918 		}
1919 		pswitch(1);
1920 		return;
1921 	}
1922 	if (setjmp(ptabort))
1923 		goto abort;
1924 	oldintr = signal(SIGINT, (void (*)())abortpt);
1925 	if (command("%s %s", cmd, remote) != PRELIM) {
1926 		(void) signal(SIGINT, oldintr);
1927 		switch (oldtype) {
1928 			case 0:
1929 				break;
1930 			case TYPE_A:
1931 				setascii(0, NULL);
1932 				break;
1933 			case TYPE_I:
1934 				setbinary(0, NULL);
1935 				break;
1936 			case TYPE_E:
1937 				setebcdic(0, NULL);
1938 				break;
1939 			case TYPE_L:
1940 				settenex(0, NULL);
1941 				break;
1942 		}
1943 		pswitch(1);
1944 		return;
1945 	}
1946 	(void) sleep(2);
1947 	pswitch(1);
1948 	secndflag++;
1949 	if (command("%s %s", cmd2, local) != PRELIM)
1950 		goto abort;
1951 	ptflag++;
1952 	(void) getreply(0);
1953 	pswitch(0);
1954 	(void) getreply(0);
1955 	(void) signal(SIGINT, oldintr);
1956 	switch (oldtype) {
1957 		case 0:
1958 			break;
1959 		case TYPE_A:
1960 			setascii(0, NULL);
1961 			break;
1962 		case TYPE_I:
1963 			setbinary(0, NULL);
1964 			break;
1965 		case TYPE_E:
1966 			setebcdic(0, NULL);
1967 			break;
1968 		case TYPE_L:
1969 			settenex(0, NULL);
1970 			break;
1971 	}
1972 	pswitch(1);
1973 	ptflag = 0;
1974 	(void) printf("local: %s remote: %s\n", local, remote);
1975 	return;
1976 abort:
1977 	(void) signal(SIGINT, SIG_IGN);
1978 	ptflag = 0;
1979 	if (strcmp(cmd, "RETR") && !proxy)
1980 		pswitch(1);
1981 	else if ((strcmp(cmd, "RETR") == 0) && proxy)
1982 		pswitch(0);
1983 	if (!cpend && !secndflag) {  /* only here if cmd = "STOR" (proxy=1) */
1984 		if (command("%s %s", cmd2, local) != PRELIM) {
1985 			pswitch(0);
1986 			switch (oldtype) {
1987 				case 0:
1988 					break;
1989 				case TYPE_A:
1990 					setascii(0, NULL);
1991 					break;
1992 				case TYPE_I:
1993 					setbinary(0, NULL);
1994 					break;
1995 				case TYPE_E:
1996 					setebcdic(0, NULL);
1997 					break;
1998 				case TYPE_L:
1999 					settenex(0, NULL);
2000 					break;
2001 			}
2002 			if (cpend) {
2003 				char msg[2];
2004 
2005 				(void) fprintf(ctrl_out, "%c%c", IAC, IP);
2006 				(void) fflush(ctrl_out);
2007 				*msg = (char)IAC;
2008 				*(msg+1) = (char)DM;
2009 				if (send(fileno(ctrl_out), msg, 2, MSG_OOB)
2010 				    != 2)
2011 					perror("abort");
2012 				(void) fprintf(ctrl_out, "ABOR\r\n");
2013 				(void) fflush(ctrl_out);
2014 				FD_ZERO(&mask);
2015 				FD_SET(fileno(ctrl_in), &mask);
2016 				if ((nfnd = empty(&mask, 10,
2017 				    fileno(ctrl_in) + 1)) <= 0) {
2018 					if (nfnd < 0) {
2019 						perror("abort");
2020 					}
2021 					if (ptabflg)
2022 						code = -1;
2023 					lostpeer(0);
2024 				}
2025 				(void) getreply(0);
2026 				(void) getreply(0);
2027 			}
2028 		}
2029 		pswitch(1);
2030 		if (ptabflg)
2031 			code = -1;
2032 		(void) signal(SIGINT, oldintr);
2033 		return;
2034 	}
2035 	if (cpend) {
2036 		char msg[2];
2037 
2038 		(void) fprintf(ctrl_out, "%c%c", IAC, IP);
2039 		(void) fflush(ctrl_out);
2040 		*msg = (char)IAC;
2041 		*(msg+1) = (char)DM;
2042 		if (send(fileno(ctrl_out), msg, 2, MSG_OOB) != 2)
2043 			perror("abort");
2044 		(void) fprintf(ctrl_out, "ABOR\r\n");
2045 		(void) fflush(ctrl_out);
2046 		FD_ZERO(&mask);
2047 		FD_SET(fileno(ctrl_in), &mask);
2048 		if ((nfnd = empty(&mask, 10, fileno(ctrl_in) + 1)) <= 0) {
2049 			if (nfnd < 0) {
2050 				perror("abort");
2051 			}
2052 			if (ptabflg)
2053 				code = -1;
2054 			lostpeer(0);
2055 		}
2056 		(void) getreply(0);
2057 		(void) getreply(0);
2058 	}
2059 	pswitch(!proxy);
2060 	if (!cpend && !secndflag) {  /* only if cmd = "RETR" (proxy=1) */
2061 		if (command("%s %s", cmd2, local) != PRELIM) {
2062 			pswitch(0);
2063 			switch (oldtype) {
2064 				case 0:
2065 					break;
2066 				case TYPE_A:
2067 					setascii(0, NULL);
2068 					break;
2069 				case TYPE_I:
2070 					setbinary(0, NULL);
2071 					break;
2072 				case TYPE_E:
2073 					setebcdic(0, NULL);
2074 					break;
2075 				case TYPE_L:
2076 					settenex(0, NULL);
2077 					break;
2078 			}
2079 			if (cpend) {
2080 				char msg[2];
2081 
2082 				(void) fprintf(ctrl_out, "%c%c", IAC, IP);
2083 				(void) fflush(ctrl_out);
2084 				*msg = (char)IAC;
2085 				*(msg+1) = (char)DM;
2086 				if (send(fileno(ctrl_out), msg, 2, MSG_OOB)
2087 				    != 2)
2088 					perror("abort");
2089 				(void) fprintf(ctrl_out, "ABOR\r\n");
2090 				(void) fflush(ctrl_out);
2091 				FD_ZERO(&mask);
2092 				FD_SET(fileno(ctrl_in), &mask);
2093 				if ((nfnd = empty(&mask, 10,
2094 				    fileno(ctrl_in) + 1)) <= 0) {
2095 					if (nfnd < 0) {
2096 						perror("abort");
2097 					}
2098 					if (ptabflg)
2099 						code = -1;
2100 					lostpeer(0);
2101 				}
2102 				(void) getreply(0);
2103 				(void) getreply(0);
2104 			}
2105 			pswitch(1);
2106 			if (ptabflg)
2107 				code = -1;
2108 			(void) signal(SIGINT, oldintr);
2109 			return;
2110 		}
2111 	}
2112 	if (cpend) {
2113 		char msg[2];
2114 
2115 		(void) fprintf(ctrl_out, "%c%c", IAC, IP);
2116 		(void) fflush(ctrl_out);
2117 		*msg = (char)IAC;
2118 		*(msg+1) = (char)DM;
2119 		if (send(fileno(ctrl_out), msg, 2, MSG_OOB) != 2)
2120 			perror("abort");
2121 		(void) fprintf(ctrl_out, "ABOR\r\n");
2122 		(void) fflush(ctrl_out);
2123 		FD_ZERO(&mask);
2124 		FD_SET(fileno(ctrl_in), &mask);
2125 		if ((nfnd = empty(&mask, 10, fileno(ctrl_in) + 1)) <= 0) {
2126 			if (nfnd < 0) {
2127 				perror("abort");
2128 			}
2129 			if (ptabflg)
2130 				code = -1;
2131 			lostpeer(0);
2132 		}
2133 		(void) getreply(0);
2134 		(void) getreply(0);
2135 	}
2136 	pswitch(!proxy);
2137 	if (cpend) {
2138 		FD_ZERO(&mask);
2139 		FD_SET(fileno(ctrl_in), &mask);
2140 		if ((nfnd = empty(&mask, 10, fileno(ctrl_in) + 1)) <= 0) {
2141 			if (nfnd < 0) {
2142 				perror("abort");
2143 			}
2144 			if (ptabflg)
2145 				code = -1;
2146 			lostpeer(0);
2147 		}
2148 		(void) getreply(0);
2149 		(void) getreply(0);
2150 	}
2151 	if (proxy)
2152 		pswitch(0);
2153 	switch (oldtype) {
2154 		case 0:
2155 			break;
2156 		case TYPE_A:
2157 			setascii(0, NULL);
2158 			break;
2159 		case TYPE_I:
2160 			setbinary(0, NULL);
2161 			break;
2162 		case TYPE_E:
2163 			setebcdic(0, NULL);
2164 			break;
2165 		case TYPE_L:
2166 			settenex(0, NULL);
2167 			break;
2168 	}
2169 	pswitch(1);
2170 	if (ptabflg)
2171 		code = -1;
2172 	(void) signal(SIGINT, oldintr);
2173 }
2174 
2175 /*ARGSUSED*/
2176 void
2177 reset(int argc, char *argv[])
2178 {
2179 	struct fd_set mask;
2180 	int nfnd = 1;
2181 
2182 	FD_ZERO(&mask);
2183 	while (nfnd > 0) {
2184 		FD_SET(fileno(ctrl_in), &mask);
2185 		if ((nfnd = empty(&mask, 0, fileno(ctrl_in) + 1)) < 0) {
2186 			perror("reset");
2187 			code = -1;
2188 			lostpeer(0);
2189 		} else if (nfnd > 0) {
2190 			(void) getreply(0);
2191 		}
2192 	}
2193 }
2194 
2195 static char *
2196 gunique(char *local)
2197 {
2198 	static char new[MAXPATHLEN];
2199 	char *cp = rindex(local, '/');
2200 	int d, count = 0;
2201 	char ext = '1';
2202 
2203 	if (cp)
2204 		*cp = '\0';
2205 	d = access(cp ? local : ".", 2);
2206 	if (cp)
2207 		*cp = '/';
2208 	if (d < 0) {
2209 		perror(local);
2210 		return ((char *)0);
2211 	}
2212 	if (strlcpy(new, local, sizeof (new)) >= sizeof (new))
2213 		(void) printf("gunique: too long: local %s, %d, new %d\n",
2214 		    local, strlen(local), sizeof (new));
2215 
2216 	cp = new + strlen(new);
2217 	*cp++ = '.';
2218 	while (!d) {
2219 		if (++count == 100) {
2220 			(void) printf(
2221 				"runique: can't find unique file name.\n");
2222 			return ((char *)0);
2223 		}
2224 		*cp++ = ext;
2225 		*cp = '\0';
2226 		if (ext == '9')
2227 			ext = '0';
2228 		else
2229 			ext++;
2230 		if ((d = access(new, 0)) < 0)
2231 			break;
2232 		if (ext != '0')
2233 			cp--;
2234 		else if (*(cp - 2) == '.')
2235 			*(cp - 1) = '1';
2236 		else {
2237 			*(cp - 2) = *(cp - 2) + 1;
2238 			cp--;
2239 		}
2240 	}
2241 	return (new);
2242 }
2243 
2244 /*
2245  * This is a wrap-around function for inet_ntop(). In case the af is AF_INET6
2246  * and the address pointed by src is a IPv4-mapped IPv6 address, it
2247  * returns printable IPv4 address, not IPv4-mapped IPv6 address. In other cases
2248  * it behaves just like inet_ntop().
2249  */
2250 const char *
2251 inet_ntop_native(int af, const void *src, char *dst, size_t size)
2252 {
2253 	struct in_addr src4;
2254 	const char *result;
2255 	struct sockaddr_in *sin;
2256 	struct sockaddr_in6 *sin6;
2257 
2258 	if (af == AF_INET6) {
2259 		sin6 = (struct sockaddr_in6 *)src;
2260 		if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
2261 			IN6_V4MAPPED_TO_INADDR(&sin6->sin6_addr, &src4);
2262 			result = inet_ntop(AF_INET, &src4, dst, size);
2263 		} else {
2264 			result = inet_ntop(AF_INET6, &sin6->sin6_addr,
2265 			    dst, size);
2266 		}
2267 	} else {
2268 		sin = (struct sockaddr_in *)src;
2269 		result = inet_ntop(af, &sin->sin_addr, dst, size);
2270 	}
2271 
2272 	return (result);
2273 }
2274 
2275 int
2276 secure_command(char *cmd)
2277 {
2278 	unsigned char *in = NULL, *out = NULL;
2279 	int length = 0;
2280 	size_t inlen;
2281 
2282 	if ((auth_type != AUTHTYPE_NONE) && clevel != PROT_C) {
2283 		gss_buffer_desc in_buf, out_buf;
2284 		OM_uint32 maj_stat, min_stat;
2285 
2286 		/* secure_command (based on level) */
2287 		if (auth_type == AUTHTYPE_GSSAPI) {
2288 			OM_uint32 expire_time;
2289 			int conf_state;
2290 			/* clevel = PROT_P; */
2291 			in_buf.value = cmd;
2292 			in_buf.length = strlen(cmd) + 1;
2293 
2294 			maj_stat = gss_context_time(&min_stat, gcontext,
2295 				&expire_time);
2296 			if (GSS_ERROR(maj_stat)) {
2297 				user_gss_error(maj_stat, min_stat,
2298 					"gss context has expired");
2299 				fatal("Your gss credentials have expired.  "
2300 					"Good-bye!");
2301 			}
2302 			maj_stat = gss_seal(&min_stat, gcontext,
2303 					    (clevel == PROT_P), /* private */
2304 					    GSS_C_QOP_DEFAULT,
2305 					    &in_buf, &conf_state,
2306 					    &out_buf);
2307 			if (maj_stat != GSS_S_COMPLETE) {
2308 				/* generally need to deal */
2309 				user_gss_error(maj_stat, min_stat,
2310 					(clevel == PROT_P) ?
2311 					"gss_seal ENC didn't complete":
2312 					"gss_seal MIC didn't complete");
2313 			} else if ((clevel == PROT_P) && !conf_state) {
2314 				(void) fprintf(stderr,
2315 					"GSSAPI didn't encrypt message");
2316 				out = out_buf.value;
2317 			} else {
2318 				if (debug)
2319 				(void) fprintf(stderr,
2320 					"sealed (%s) %d bytes\n",
2321 					clevel == PROT_P ? "ENC" : "MIC",
2322 					out_buf.length);
2323 
2324 				out = out_buf.value;
2325 			}
2326 		}
2327 		/* Other auth types go here ... */
2328 		inlen = ((4 * out_buf.length) / 3) + 4;
2329 		in = (uchar_t *)malloc(inlen);
2330 		if (in == NULL) {
2331 			gss_release_buffer(&min_stat, &out_buf);
2332 			fatal("Memory error allocating space for response.");
2333 		}
2334 		length = out_buf.length;
2335 		if (auth_error = radix_encode(out, in, inlen, &length, 0)) {
2336 			(void) fprintf(stderr,
2337 				"Couldn't base 64 encode command (%s)\n",
2338 				radix_error(auth_error));
2339 			free(in);
2340 			gss_release_buffer(&min_stat, &out_buf);
2341 			return (0);
2342 		}
2343 
2344 		(void) fprintf(ctrl_out, "%s %s",
2345 			clevel == PROT_P ? "ENC" : "MIC", in);
2346 
2347 		free(in);
2348 		gss_release_buffer(&min_stat, &out_buf);
2349 
2350 		if (debug)
2351 			(void) fprintf(stderr,
2352 			    "secure_command(%s)\nencoding %d bytes %s %s\n",
2353 			    cmd, length,
2354 			    (clevel == PROT_P) ? "ENC" : "MIC", in);
2355 	} else {
2356 		/*
2357 		 * auth_type = AUTHTYPE_NONE or
2358 		 * command channel is not protected
2359 		 */
2360 		fputs(cmd, ctrl_out);
2361 	}
2362 
2363 	(void) fprintf(ctrl_out, "\r\n");
2364 	(void) fflush(ctrl_out);
2365 	return (1);
2366 }
2367 
2368 unsigned int maxbuf;
2369 unsigned char *ucbuf;
2370 
2371 void
2372 setpbsz(unsigned int size)
2373 {
2374 	unsigned int actualbuf;
2375 	int oldverbose;
2376 
2377 	if (ucbuf)
2378 		(void) free(ucbuf);
2379 	actualbuf = size;
2380 	while ((ucbuf = (unsigned char *)malloc(actualbuf)) == NULL) {
2381 		if (actualbuf)
2382 			actualbuf >>= 2;
2383 		else {
2384 			perror("Error while trying to malloc PROT buffer:");
2385 			exit(1);
2386 		}
2387 	}
2388 	oldverbose = verbose;
2389 	verbose = 0;
2390 	reply_parse = "PBSZ=";
2391 	if (command("PBSZ %u", actualbuf) != COMPLETE)
2392 		fatal("Cannot set PROT buffer size");
2393 	if (reply_parse) {
2394 		if ((maxbuf = (unsigned int) atol(reply_parse)) > actualbuf)
2395 			maxbuf = actualbuf;
2396 	} else
2397 		maxbuf = actualbuf;
2398 	reply_parse = NULL;
2399 	verbose = oldverbose;
2400 }
2401 
2402 /*
2403  * Do the base 64 decoding of the raw input buffer, b64_buf.
2404  * Also do the verification and decryption, if required.
2405  * retval contains the current error code number
2406  *
2407  * returns:
2408  *	(RFC 2228:  error returns are 3 digit numbers of the form 5xy)
2409  *	5	if an error occurred
2410  */
2411 static int
2412 decode_reply(uchar_t *plain_buf,
2413 		int ilen,
2414 		uchar_t *b64_buf,
2415 		int retval,
2416 		boolean_t *again)
2417 {
2418 	int len;
2419 	int safe = 0;
2420 
2421 	*again = 0;
2422 
2423 	if (!b64_buf[0])	/* if there is no string, no problem */
2424 	    return (retval);
2425 
2426 	if ((auth_type == AUTHTYPE_NONE)) {
2427 	    (void) printf("Cannot decode reply:\n%d %s\n", code, b64_buf);
2428 	    return ('5');
2429 	}
2430 
2431 	switch (code) {
2432 
2433 	    case 631:	/* 'safe' */
2434 		safe = 1;
2435 		break;
2436 
2437 	    case 632:	/* 'private' */
2438 		break;
2439 
2440 	    case 633:	/* 'confidential' */
2441 		break;
2442 
2443 	    default:
2444 		(void) printf("Unknown reply: %d %s\n", code, b64_buf);
2445 		return ('5');
2446 	}
2447 
2448 	/* decode the base64 encoded message */
2449 	auth_error = radix_encode(b64_buf, plain_buf, ilen, &len, 1);
2450 
2451 	if (auth_error) {
2452 		(void) printf("Can't base 64 decode reply %d (%s)\n\"%s\"\n",
2453 			code, radix_error(auth_error), b64_buf);
2454 		return ('5');
2455 	}
2456 
2457 	if (auth_type == AUTHTYPE_GSSAPI) {
2458 		gss_buffer_desc xmit_buf, msg_buf;
2459 		OM_uint32 maj_stat, min_stat;
2460 		int conf_state = safe;
2461 		xmit_buf.value = plain_buf;
2462 		xmit_buf.length = len;
2463 
2464 		/* decrypt/verify the message */
2465 		maj_stat = gss_unseal(&min_stat, gcontext,
2466 			&xmit_buf, &msg_buf, &conf_state, NULL);
2467 		if (maj_stat != GSS_S_COMPLETE) {
2468 			user_gss_error(maj_stat, min_stat,
2469 				"failed unsealing reply");
2470 			return ('5');
2471 		}
2472 		if (msg_buf.length < ilen - 2 - 1) {
2473 			memcpy(plain_buf, msg_buf.value, msg_buf.length);
2474 			strcpy((char *)&plain_buf[msg_buf.length], "\r\n");
2475 			gss_release_buffer(&min_stat, &msg_buf);
2476 			*again = 1;
2477 		} else {
2478 			user_gss_error(maj_stat, min_stat,
2479 				"reply was too long");
2480 			return ('5');
2481 		}
2482 	} /* end if GSSAPI */
2483 
2484 	/* Other auth types go here... */
2485 
2486 	return (retval);
2487 }
2488