Home | History | Annotate | Line # | Download | only in ftpd
ftpd.c revision 1.205
      1  1.205  christos /*	$NetBSD: ftpd.c,v 1.205 2019/10/15 18:29:32 christos Exp $	*/
      2   1.67    itojun 
      3   1.67    itojun /*
      4  1.192     lukem  * Copyright (c) 1997-2009 The NetBSD Foundation, Inc.
      5   1.67    itojun  * All rights reserved.
      6   1.73     lukem  *
      7   1.73     lukem  * This code is derived from software contributed to The NetBSD Foundation
      8   1.73     lukem  * by Luke Mewburn.
      9   1.73     lukem  *
     10   1.67    itojun  * Redistribution and use in source and binary forms, with or without
     11   1.67    itojun  * modification, are permitted provided that the following conditions
     12   1.67    itojun  * are met:
     13   1.67    itojun  * 1. Redistributions of source code must retain the above copyright
     14   1.67    itojun  *    notice, this list of conditions and the following disclaimer.
     15   1.67    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.67    itojun  *    notice, this list of conditions and the following disclaimer in the
     17   1.67    itojun  *    documentation and/or other materials provided with the distribution.
     18   1.73     lukem  *
     19   1.73     lukem  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20   1.73     lukem  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21   1.73     lukem  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22   1.73     lukem  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23   1.73     lukem  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24   1.73     lukem  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25   1.73     lukem  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26   1.73     lukem  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27   1.73     lukem  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28   1.73     lukem  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29   1.73     lukem  * POSSIBILITY OF SUCH DAMAGE.
     30   1.67    itojun  */
     31   1.13       cgd 
     32    1.1       cgd /*
     33    1.8   deraadt  * Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994
     34    1.8   deraadt  *	The Regents of the University of California.  All rights reserved.
     35    1.1       cgd  *
     36    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     37    1.1       cgd  * modification, are permitted provided that the following conditions
     38    1.1       cgd  * are met:
     39    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     40    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     41    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     42    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     43    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     44  1.156       agc  * 3. Neither the name of the University nor the names of its contributors
     45    1.1       cgd  *    may be used to endorse or promote products derived from this software
     46    1.1       cgd  *    without specific prior written permission.
     47    1.1       cgd  *
     48    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     49    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     52    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58    1.1       cgd  * SUCH DAMAGE.
     59    1.1       cgd  */
     60    1.1       cgd 
     61   1.62     lukem /*
     62   1.73     lukem  * Copyright (C) 1997 and 1998 WIDE Project.
     63   1.62     lukem  * All rights reserved.
     64   1.73     lukem  *
     65   1.62     lukem  * Redistribution and use in source and binary forms, with or without
     66   1.62     lukem  * modification, are permitted provided that the following conditions
     67   1.62     lukem  * are met:
     68   1.62     lukem  * 1. Redistributions of source code must retain the above copyright
     69   1.62     lukem  *    notice, this list of conditions and the following disclaimer.
     70   1.62     lukem  * 2. Redistributions in binary form must reproduce the above copyright
     71   1.62     lukem  *    notice, this list of conditions and the following disclaimer in the
     72   1.62     lukem  *    documentation and/or other materials provided with the distribution.
     73   1.73     lukem  * 3. Neither the name of the project nor the names of its contributors
     74   1.73     lukem  *    may be used to endorse or promote products derived from this software
     75   1.73     lukem  *    without specific prior written permission.
     76   1.73     lukem  *
     77   1.73     lukem  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     78   1.73     lukem  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     79   1.73     lukem  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     80   1.73     lukem  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     81   1.73     lukem  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     82   1.73     lukem  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     83   1.73     lukem  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     84   1.73     lukem  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     85   1.73     lukem  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     86   1.73     lukem  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     87   1.73     lukem  * SUCH DAMAGE.
     88   1.62     lukem  */
     89   1.62     lukem 
     90   1.25  christos #include <sys/cdefs.h>
     91    1.1       cgd #ifndef lint
     92  1.186     lukem __COPYRIGHT("@(#) Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994\
     93  1.186     lukem  The Regents of the University of California.  All rights reserved.");
     94    1.1       cgd #endif /* not lint */
     95    1.1       cgd 
     96    1.1       cgd #ifndef lint
     97   1.13       cgd #if 0
     98   1.17       cjs static char sccsid[] = "@(#)ftpd.c	8.5 (Berkeley) 4/28/95";
     99   1.13       cgd #else
    100  1.205  christos __RCSID("$NetBSD: ftpd.c,v 1.205 2019/10/15 18:29:32 christos Exp $");
    101   1.13       cgd #endif
    102    1.1       cgd #endif /* not lint */
    103    1.1       cgd 
    104    1.1       cgd /*
    105    1.1       cgd  * FTP server.
    106    1.1       cgd  */
    107    1.1       cgd #include <sys/param.h>
    108    1.1       cgd #include <sys/stat.h>
    109    1.1       cgd #include <sys/ioctl.h>
    110    1.1       cgd #include <sys/socket.h>
    111    1.1       cgd #include <sys/wait.h>
    112  1.139     enami #include <sys/mman.h>
    113  1.139     enami #include <sys/resource.h>
    114    1.1       cgd 
    115    1.1       cgd #include <netinet/in.h>
    116    1.1       cgd #include <netinet/in_systm.h>
    117    1.1       cgd #include <netinet/ip.h>
    118    1.1       cgd 
    119    1.1       cgd #define	FTP_NAMES
    120    1.1       cgd #include <arpa/ftp.h>
    121    1.1       cgd #include <arpa/inet.h>
    122    1.1       cgd #include <arpa/telnet.h>
    123    1.1       cgd 
    124    1.8   deraadt #include <ctype.h>
    125    1.1       cgd #include <dirent.h>
    126    1.8   deraadt #include <err.h>
    127    1.8   deraadt #include <errno.h>
    128    1.1       cgd #include <fcntl.h>
    129   1.21       cjs #include <fnmatch.h>
    130    1.8   deraadt #include <glob.h>
    131   1.81     lukem #include <grp.h>
    132    1.8   deraadt #include <limits.h>
    133    1.8   deraadt #include <netdb.h>
    134    1.1       cgd #include <pwd.h>
    135  1.167     peter #include <poll.h>
    136    1.8   deraadt #include <signal.h>
    137   1.93     lukem #include <stdarg.h>
    138    1.1       cgd #include <stdio.h>
    139    1.1       cgd #include <stdlib.h>
    140    1.1       cgd #include <string.h>
    141    1.8   deraadt #include <syslog.h>
    142    1.8   deraadt #include <time.h>
    143  1.118     lukem #include <tzfile.h>
    144    1.8   deraadt #include <unistd.h>
    145   1.73     lukem #include <util.h>
    146  1.141  christos #ifdef SUPPORT_UTMP
    147   1.78     lukem #include <utmp.h>
    148  1.141  christos #endif
    149  1.141  christos #ifdef SUPPORT_UTMPX
    150  1.141  christos #include <utmpx.h>
    151  1.141  christos #endif
    152   1.25  christos #ifdef SKEY
    153   1.25  christos #include <skey.h>
    154   1.25  christos #endif
    155   1.38   mycroft #ifdef KERBEROS5
    156   1.86     aidan #include <com_err.h>
    157   1.69  christos #include <krb5/krb5.h>
    158   1.38   mycroft #endif
    159    1.8   deraadt 
    160  1.164  christos #ifdef	LOGIN_CAP
    161  1.164  christos #include <login_cap.h>
    162  1.164  christos #endif
    163  1.164  christos 
    164  1.164  christos #ifdef USE_PAM
    165  1.164  christos #include <security/pam_appl.h>
    166  1.164  christos #endif
    167  1.164  christos 
    168  1.201  christos #include "pfilter.h"
    169  1.201  christos 
    170   1.84     lukem #define	GLOBAL
    171   1.24     lukem #include "extern.h"
    172    1.1       cgd #include "pathnames.h"
    173   1.78     lukem #include "version.h"
    174    1.1       cgd 
    175  1.178  christos static sig_atomic_t	transflag;
    176  1.178  christos static sig_atomic_t	urgflag;
    177  1.158     lukem 
    178    1.1       cgd int	data;
    179  1.167     peter int	Dflag;
    180  1.204  riastrad int	fflag;
    181   1.51   msaitoh int	sflag;
    182    1.1       cgd int	stru;			/* avoid C keyword */
    183    1.1       cgd int	mode;
    184  1.111     lukem int	dataport;		/* use specific data port */
    185  1.111     lukem int	dopidfile;		/* maintain pid file */
    186  1.101     lukem int	doutmp;			/* update utmp file */
    187  1.102     lukem int	dowtmp;			/* update wtmp file */
    188  1.154     lukem int	doxferlog;		/* syslog/write wu-ftpd style xferlog entries */
    189  1.154     lukem int	xferlogfd;		/* fd to write wu-ftpd xferlog entries to */
    190  1.180  christos int	getnameopts;		/* flags for use with getname() */
    191  1.101     lukem int	dropprivs;		/* if privileges should or have been dropped */
    192  1.101     lukem int	mapped;			/* IPv4 connection on AF_INET6 socket */
    193    1.1       cgd off_t	file_size;
    194    1.1       cgd off_t	byte_count;
    195   1.13       cgd static char ttyline[20];
    196  1.164  christos 
    197  1.164  christos #ifdef USE_PAM
    198  1.183     lukem static int	auth_pam(void);
    199  1.164  christos pam_handle_t	*pamh = NULL;
    200  1.164  christos #endif
    201  1.164  christos 
    202  1.141  christos #ifdef SUPPORT_UTMP
    203   1.78     lukem static struct utmp utmp;	/* for utmp */
    204  1.141  christos #endif
    205  1.141  christos #ifdef SUPPORT_UTMPX
    206  1.141  christos static struct utmpx utmpx;	/* for utmpx */
    207  1.141  christos #endif
    208   1.57     lukem 
    209  1.111     lukem static const char *anondir = NULL;
    210  1.117     lukem static const char *confdir = _DEFAULT_CONFDIR;
    211   1.24     lukem 
    212  1.157     lukem static char	*curname;		/* current USER name */
    213  1.157     lukem static size_t	curname_len;		/* length of curname (include NUL) */
    214  1.157     lukem 
    215   1.38   mycroft #if defined(KERBEROS) || defined(KERBEROS5)
    216   1.91     fredb int	has_ccache = 0;
    217   1.13       cgd int	notickets = 1;
    218   1.13       cgd char	*krbtkfile_env = NULL;
    219   1.91     fredb char	*tty = ttyline;
    220   1.92  explorer int	login_krb5_forwardable_tgt = 0;
    221   1.73     lukem #endif
    222    1.4       cgd 
    223   1.67    itojun int epsvall = 0;
    224   1.67    itojun 
    225    1.1       cgd /*
    226    1.1       cgd  * Timeout intervals for retrying connections
    227    1.1       cgd  * to hosts that don't accept PORT cmds.  This
    228    1.1       cgd  * is a kludge, but given the problems with TCP...
    229    1.1       cgd  */
    230    1.1       cgd #define	SWAITMAX	90	/* wait at most 90 seconds */
    231    1.1       cgd #define	SWAITINT	5	/* interval between retries */
    232    1.1       cgd 
    233    1.1       cgd int	swaitmax = SWAITMAX;
    234    1.1       cgd int	swaitint = SWAITINT;
    235    1.1       cgd 
    236  1.139     enami enum send_status {
    237  1.139     enami 	SS_SUCCESS,
    238  1.158     lukem 	SS_ABORTED,			/* transfer aborted */
    239  1.139     enami 	SS_NO_TRANSFER,			/* no transfer made yet */
    240  1.139     enami 	SS_FILE_ERROR,			/* file read error */
    241  1.139     enami 	SS_DATA_ERROR			/* data send error */
    242  1.139     enami };
    243  1.139     enami 
    244   1.88     lukem static int	 bind_pasv_addr(void);
    245   1.88     lukem static int	 checkuser(const char *, const char *, int, int, char **);
    246   1.88     lukem static int	 checkaccess(const char *);
    247  1.116     lukem static int	 checkpassword(const struct passwd *, const char *);
    248  1.183     lukem static void	 do_pass(int, int, const char *);
    249   1.88     lukem static void	 end_login(void);
    250   1.88     lukem static FILE	*getdatasock(const char *);
    251   1.88     lukem static char	*gunique(const char *);
    252  1.160  christos static void	 login_utmp(const char *, const char *, const char *,
    253  1.160  christos 		     struct sockinet *);
    254  1.118     lukem static void	 logremotehost(struct sockinet *);
    255  1.195     joerg __dead static void	 lostconn(int);
    256  1.195     joerg __dead static void	 toolong(int);
    257  1.195     joerg __dead static void	 sigquit(int);
    258  1.158     lukem static void	 sigurg(int);
    259  1.158     lukem static int	 handleoobcmd(void);
    260   1.88     lukem static int	 receive_data(FILE *, FILE *);
    261  1.139     enami static int	 send_data(FILE *, FILE *, const struct stat *, int);
    262   1.88     lukem static struct passwd *sgetpwnam(const char *);
    263  1.139     enami static int	 write_data(int, char *, size_t, off_t *, struct timeval *,
    264  1.139     enami 		     int);
    265  1.139     enami static enum send_status
    266  1.139     enami 		 send_data_with_read(int, int, const struct stat *, int);
    267  1.139     enami static enum send_status
    268  1.139     enami 		 send_data_with_mmap(int, int, const struct stat *, int);
    269  1.139     enami static void	 logrusage(const struct rusage *, const struct rusage *);
    270  1.141  christos static void	 logout_utmp(void);
    271    1.8   deraadt 
    272   1.88     lukem int	main(int, char *[]);
    273   1.26    mellon 
    274   1.92  explorer #if defined(KERBEROS)
    275   1.88     lukem int	klogin(struct passwd *, char *, char *, char *);
    276   1.88     lukem void	kdestroy(void);
    277   1.26    mellon #endif
    278   1.92  explorer #if defined(KERBEROS5)
    279   1.92  explorer int	k5login(struct passwd *, char *, char *, char *);
    280   1.92  explorer void	k5destroy(void);
    281   1.92  explorer #endif
    282   1.63     lukem 
    283    1.8   deraadt int
    284   1.88     lukem main(int argc, char *argv[])
    285    1.1       cgd {
    286  1.176       mrg 	int		ch, on = 1, tos, keepalive;
    287  1.176       mrg 	socklen_t	addrlen;
    288   1.73     lukem #ifdef KERBEROS5
    289   1.76     lukem 	krb5_error_code	kerror;
    290   1.38   mycroft #endif
    291  1.111     lukem 	char		*p;
    292  1.154     lukem 	const char	*xferlogname = NULL;
    293  1.146    itojun 	long		l;
    294  1.158     lukem 	struct sigaction sa;
    295  1.167     peter 	sa_family_t	af = AF_UNSPEC;
    296    1.1       cgd 
    297   1.87     lukem 	connections = 1;
    298  1.171  christos 	ftpd_debug = 0;
    299   1.35     lukem 	logging = 0;
    300   1.87     lukem 	pdata = -1;
    301  1.167     peter 	Dflag = 0;
    302  1.204  riastrad 	fflag = 0;
    303   1.51   msaitoh 	sflag = 0;
    304  1.111     lukem 	dataport = 0;
    305  1.111     lukem 	dopidfile = 1;		/* default: DO use a pid file to count users */
    306  1.118     lukem 	doutmp = 0;		/* default: Do NOT log to utmp */
    307  1.102     lukem 	dowtmp = 1;		/* default: DO log to wtmp */
    308  1.118     lukem 	doxferlog = 0;		/* default: Do NOT syslog xferlog */
    309  1.154     lukem 	xferlogfd = -1;		/* default: Do NOT write xferlog file */
    310  1.180  christos 	getnameopts = 0;	/* default: xlate addrs to name */
    311  1.101     lukem 	dropprivs = 0;
    312  1.101     lukem 	mapped = 0;
    313   1.87     lukem 	usedefault = 1;
    314  1.111     lukem 	emailaddr = NULL;
    315   1.80     lukem 	hostname[0] = '\0';
    316  1.100     lukem 	homedir[0] = '\0';
    317   1.95     lukem 	gidcount = 0;
    318  1.123     aidan 	is_oob = 0;
    319  1.111     lukem 	version = FTPD_VERSION;
    320  1.111     lukem 
    321  1.111     lukem 	/*
    322  1.111     lukem 	 * LOG_NDELAY sets up the logging connection immediately,
    323  1.111     lukem 	 * necessary for anonymous ftp's that chroot and can't do it later.
    324  1.111     lukem 	 */
    325  1.111     lukem 	openlog("ftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
    326    1.1       cgd 
    327  1.167     peter 	while ((ch = getopt(argc, argv,
    328  1.204  riastrad 	    "46a:c:C:Dde:fh:HlL:nP:qQrst:T:uUvV:wWX")) != -1) {
    329    1.8   deraadt 		switch (ch) {
    330  1.167     peter 		case '4':
    331  1.167     peter 			af = AF_INET;
    332  1.167     peter 			break;
    333  1.167     peter 
    334  1.167     peter 		case '6':
    335  1.167     peter 			af = AF_INET6;
    336  1.167     peter 			break;
    337  1.167     peter 
    338   1.22       cjs 		case 'a':
    339   1.22       cjs 			anondir = optarg;
    340   1.22       cjs 			break;
    341   1.22       cjs 
    342   1.34     lukem 		case 'c':
    343  1.111     lukem 			confdir = optarg;
    344   1.34     lukem 			break;
    345   1.73     lukem 
    346   1.35     lukem 		case 'C':
    347  1.188     lukem 			if ((p = strchr(optarg, '@')) != NULL) {
    348  1.188     lukem 				*p++ = '\0';
    349  1.188     lukem 				strlcpy(remotehost, p, MAXHOSTNAMELEN + 1);
    350  1.188     lukem 				if (inet_pton(AF_INET, p,
    351  1.188     lukem 				    &his_addr.su_addr) == 1) {
    352  1.188     lukem 					his_addr.su_family = AF_INET;
    353  1.188     lukem 					his_addr.su_len =
    354  1.188     lukem 					    sizeof(his_addr.si_su.su_sin);
    355  1.188     lukem #ifdef INET6
    356  1.188     lukem 				} else if (inet_pton(AF_INET6, p,
    357  1.188     lukem 				    &his_addr.su_6addr) == 1) {
    358  1.188     lukem 					his_addr.su_family = AF_INET6;
    359  1.188     lukem 					his_addr.su_len =
    360  1.188     lukem 					    sizeof(his_addr.si_su.su_sin6);
    361  1.188     lukem #endif
    362  1.188     lukem 				} else
    363  1.188     lukem 					his_addr.su_family = AF_UNSPEC;
    364  1.188     lukem 			}
    365   1.81     lukem 			pw = sgetpwnam(optarg);
    366   1.73     lukem 			exit(checkaccess(optarg) ? 0 : 1);
    367   1.35     lukem 			/* NOTREACHED */
    368   1.34     lukem 
    369  1.167     peter 		case 'D':
    370  1.167     peter 			Dflag = 1;
    371  1.167     peter 			break;
    372  1.167     peter 
    373    1.1       cgd 		case 'd':
    374   1.22       cjs 		case 'v':		/* deprecated */
    375  1.171  christos 			ftpd_debug = 1;
    376    1.1       cgd 			break;
    377    1.1       cgd 
    378  1.111     lukem 		case 'e':
    379  1.111     lukem 			emailaddr = optarg;
    380  1.111     lukem 			break;
    381  1.111     lukem 
    382  1.204  riastrad 		case 'f':
    383  1.204  riastrad 			fflag = 1;
    384  1.204  riastrad 			break;
    385  1.204  riastrad 
    386   1.80     lukem 		case 'h':
    387   1.80     lukem 			strlcpy(hostname, optarg, sizeof(hostname));
    388   1.99     lukem 			break;
    389   1.99     lukem 
    390   1.99     lukem 		case 'H':
    391   1.99     lukem 			if (gethostname(hostname, sizeof(hostname)) == -1)
    392   1.99     lukem 				hostname[0] = '\0';
    393   1.99     lukem 			hostname[sizeof(hostname) - 1] = '\0';
    394   1.80     lukem 			break;
    395   1.80     lukem 
    396    1.1       cgd 		case 'l':
    397    1.8   deraadt 			logging++;	/* > 1 == extra logging */
    398    1.1       cgd 			break;
    399    1.1       cgd 
    400  1.154     lukem 		case 'L':
    401  1.154     lukem 			xferlogname = optarg;
    402  1.154     lukem 			break;
    403  1.154     lukem 
    404  1.180  christos 		case 'n':
    405  1.180  christos 			getnameopts = NI_NUMERICHOST;
    406  1.180  christos 			break;
    407  1.180  christos 
    408  1.111     lukem 		case 'P':
    409  1.146    itojun 			errno = 0;
    410  1.146    itojun 			p = NULL;
    411  1.146    itojun 			l = strtol(optarg, &p, 10);
    412  1.146    itojun 			if (errno || *optarg == '\0' || *p != '\0' ||
    413  1.146    itojun 			    l < IPPORT_RESERVED ||
    414  1.146    itojun 			    l > IPPORT_ANONMAX) {
    415  1.111     lukem 				syslog(LOG_WARNING, "Invalid dataport %s",
    416  1.111     lukem 				    optarg);
    417  1.111     lukem 				dataport = 0;
    418  1.111     lukem 			}
    419  1.146    itojun 			dataport = (int)l;
    420  1.111     lukem 			break;
    421  1.111     lukem 
    422  1.111     lukem 		case 'q':
    423  1.111     lukem 			dopidfile = 1;
    424  1.111     lukem 			break;
    425  1.111     lukem 
    426  1.111     lukem 		case 'Q':
    427  1.111     lukem 			dopidfile = 0;
    428  1.111     lukem 			break;
    429  1.111     lukem 
    430  1.101     lukem 		case 'r':
    431  1.101     lukem 			dropprivs = 1;
    432  1.101     lukem 			break;
    433  1.101     lukem 
    434   1.51   msaitoh 		case 's':
    435   1.51   msaitoh 			sflag = 1;
    436   1.51   msaitoh 			break;
    437   1.51   msaitoh 
    438    1.1       cgd 		case 't':
    439    1.1       cgd 		case 'T':
    440  1.119     lukem 			syslog(LOG_WARNING,
    441  1.111     lukem 			    "-%c has been deprecated in favour of ftpd.conf",
    442  1.111     lukem 			    ch);
    443  1.111     lukem 			break;
    444  1.111     lukem 
    445    1.1       cgd 		case 'u':
    446  1.111     lukem 			doutmp = 1;
    447    1.8   deraadt 			break;
    448    1.1       cgd 
    449   1.78     lukem 		case 'U':
    450  1.111     lukem 			doutmp = 0;
    451   1.78     lukem 			break;
    452   1.78     lukem 
    453  1.101     lukem 		case 'V':
    454  1.101     lukem 			if (EMPTYSTR(optarg) || strcmp(optarg, "-") == 0)
    455  1.101     lukem 				version = NULL;
    456  1.101     lukem 			else
    457  1.171  christos 				version = ftpd_strdup(optarg);
    458  1.101     lukem 			break;
    459  1.101     lukem 
    460  1.111     lukem 		case 'w':
    461  1.111     lukem 			dowtmp = 1;
    462  1.111     lukem 			break;
    463  1.111     lukem 
    464  1.102     lukem 		case 'W':
    465  1.102     lukem 			dowtmp = 0;
    466  1.102     lukem 			break;
    467  1.102     lukem 
    468  1.118     lukem 		case 'X':
    469  1.154     lukem 			doxferlog |= 1;
    470  1.118     lukem 			break;
    471  1.118     lukem 
    472    1.1       cgd 		default:
    473   1.35     lukem 			if (optopt == 'a' || optopt == 'C')
    474   1.35     lukem 				exit(1);
    475  1.119     lukem 			syslog(LOG_WARNING, "unknown flag -%c ignored", optopt);
    476    1.1       cgd 			break;
    477    1.1       cgd 		}
    478    1.1       cgd 	}
    479  1.111     lukem 	if (EMPTYSTR(confdir))
    480  1.111     lukem 		confdir = _DEFAULT_CONFDIR;
    481   1.35     lukem 
    482  1.201  christos 	pfilter_open();
    483  1.201  christos 
    484  1.166  christos 	if (dowtmp) {
    485  1.166  christos #ifdef SUPPORT_UTMPX
    486  1.166  christos 		ftpd_initwtmpx();
    487  1.166  christos #endif
    488  1.166  christos #ifdef SUPPORT_UTMP
    489  1.166  christos 		ftpd_initwtmp();
    490  1.166  christos #endif
    491  1.166  christos 	}
    492  1.157     lukem 	errno = 0;
    493  1.157     lukem 	l = sysconf(_SC_LOGIN_NAME_MAX);
    494  1.157     lukem 	if (l == -1 && errno != 0) {
    495  1.157     lukem 		syslog(LOG_ERR, "sysconf _SC_LOGIN_NAME_MAX: %m");
    496  1.157     lukem 		exit(1);
    497  1.157     lukem 	} else if (l <= 0) {
    498  1.157     lukem 		syslog(LOG_WARNING, "using conservative LOGIN_NAME_MAX value");
    499  1.157     lukem 		curname_len = _POSIX_LOGIN_NAME_MAX;
    500  1.157     lukem 	} else
    501  1.157     lukem 		curname_len = (size_t)l;
    502  1.157     lukem 	curname = malloc(curname_len);
    503  1.157     lukem 	if (curname == NULL) {
    504  1.157     lukem 		syslog(LOG_ERR, "malloc: %m");
    505  1.157     lukem 		exit(1);
    506  1.157     lukem 	}
    507  1.157     lukem 	curname[0] = '\0';
    508  1.157     lukem 
    509  1.167     peter 	if (Dflag) {
    510  1.167     peter 		int error, fd, i, n, *socks;
    511  1.167     peter 		struct pollfd *fds;
    512  1.167     peter 		struct addrinfo hints, *res, *res0;
    513  1.167     peter 
    514  1.204  riastrad 		if (!fflag && daemon(1, 0) == -1) {
    515  1.167     peter 			syslog(LOG_ERR, "failed to daemonize: %m");
    516  1.167     peter 			exit(1);
    517  1.167     peter 		}
    518  1.167     peter 		(void)memset(&sa, 0, sizeof(sa));
    519  1.167     peter 		sa.sa_handler = SIG_IGN;
    520  1.167     peter 		sa.sa_flags = SA_NOCLDWAIT;
    521  1.167     peter 		sigemptyset(&sa.sa_mask);
    522  1.167     peter 		(void)sigaction(SIGCHLD, &sa, NULL);
    523  1.167     peter 
    524  1.167     peter 		(void)memset(&hints, 0, sizeof(hints));
    525  1.167     peter 		hints.ai_flags = AI_PASSIVE;
    526  1.167     peter 		hints.ai_family = af;
    527  1.167     peter 		hints.ai_socktype = SOCK_STREAM;
    528  1.167     peter 		error = getaddrinfo(NULL, "ftp", &hints, &res0);
    529  1.167     peter 		if (error) {
    530  1.167     peter 			syslog(LOG_ERR, "getaddrinfo: %s", gai_strerror(error));
    531  1.167     peter 			exit(1);
    532  1.167     peter 		}
    533  1.167     peter 
    534  1.167     peter 		for (n = 0, res = res0; res != NULL; res = res->ai_next)
    535  1.167     peter 			n++;
    536  1.167     peter 		if (n == 0) {
    537  1.167     peter 			syslog(LOG_ERR, "no addresses available");
    538  1.167     peter 			exit(1);
    539  1.167     peter 		}
    540  1.167     peter 		socks = malloc(n * sizeof(int));
    541  1.167     peter 		fds = malloc(n * sizeof(struct pollfd));
    542  1.167     peter 		if (socks == NULL || fds == NULL) {
    543  1.167     peter 			syslog(LOG_ERR, "malloc: %m");
    544  1.167     peter 			exit(1);
    545  1.167     peter 		}
    546  1.167     peter 
    547  1.167     peter 		for (n = 0, res = res0; res != NULL; res = res->ai_next) {
    548  1.167     peter 			socks[n] = socket(res->ai_family, res->ai_socktype,
    549  1.167     peter 			    res->ai_protocol);
    550  1.167     peter 			if (socks[n] == -1)
    551  1.167     peter 				continue;
    552  1.167     peter 			(void)setsockopt(socks[n], SOL_SOCKET, SO_REUSEADDR,
    553  1.167     peter 			    &on, sizeof(on));
    554  1.167     peter 			if (bind(socks[n], res->ai_addr, res->ai_addrlen)
    555  1.167     peter 			    == -1) {
    556  1.167     peter 				(void)close(socks[n]);
    557  1.167     peter 				continue;
    558  1.167     peter 			}
    559  1.167     peter 			if (listen(socks[n], 12) == -1) {
    560  1.167     peter 				(void)close(socks[n]);
    561  1.167     peter 				continue;
    562  1.167     peter 			}
    563  1.167     peter 
    564  1.167     peter 			fds[n].fd = socks[n];
    565  1.167     peter 			fds[n].events = POLLIN;
    566  1.167     peter 			n++;
    567  1.167     peter 		}
    568  1.167     peter 		if (n == 0) {
    569  1.167     peter 			syslog(LOG_ERR, "%m");
    570  1.167     peter 			exit(1);
    571  1.167     peter 		}
    572  1.167     peter 		freeaddrinfo(res0);
    573  1.167     peter 
    574  1.167     peter 		if (pidfile(NULL) == -1)
    575  1.167     peter 			syslog(LOG_ERR, "failed to write a pid file: %m");
    576  1.167     peter 
    577  1.167     peter 		for (;;) {
    578  1.167     peter 			if (poll(fds, n, INFTIM) == -1) {
    579  1.167     peter 				if (errno == EINTR)
    580  1.167     peter 					continue;
    581  1.167     peter 				syslog(LOG_ERR, "poll: %m");
    582  1.167     peter 				exit(1);
    583  1.167     peter 			}
    584  1.167     peter 			for (i = 0; i < n; i++) {
    585  1.167     peter 				if (fds[i].revents & POLLIN) {
    586  1.167     peter 					fd = accept(fds[i].fd, NULL, NULL);
    587  1.167     peter 					if (fd == -1) {
    588  1.167     peter 						syslog(LOG_ERR, "accept: %m");
    589  1.167     peter 						continue;
    590  1.167     peter 					}
    591  1.167     peter 					switch (fork()) {
    592  1.167     peter 					case -1:
    593  1.167     peter 						syslog(LOG_ERR, "fork: %m");
    594  1.167     peter 						break;
    595  1.167     peter 					case 0:
    596  1.167     peter 						goto child;
    597  1.167     peter 						/* NOTREACHED */
    598  1.167     peter 					}
    599  1.167     peter 					(void)close(fd);
    600  1.167     peter 				}
    601  1.167     peter 			}
    602  1.167     peter 		}
    603  1.167     peter  child:
    604  1.167     peter 		(void)dup2(fd, STDIN_FILENO);
    605  1.167     peter 		(void)dup2(fd, STDOUT_FILENO);
    606  1.167     peter 		(void)dup2(fd, STDERR_FILENO);
    607  1.167     peter 		for (i = 0; i < n; i++)
    608  1.167     peter 			(void)close(socks[i]);
    609  1.167     peter 	}
    610  1.167     peter 
    611  1.118     lukem 	memset((char *)&his_addr, 0, sizeof(his_addr));
    612  1.109     lukem 	addrlen = sizeof(his_addr.si_su);
    613  1.109     lukem 	if (getpeername(0, (struct sockaddr *)&his_addr.si_su, &addrlen) < 0) {
    614  1.196     lukem 		syslog((errno == ENOTCONN) ? LOG_NOTICE : LOG_ERR,
    615  1.196     lukem 		    "getpeername (%s): %m",argv[0]);
    616   1.35     lukem 		exit(1);
    617   1.35     lukem 	}
    618  1.109     lukem 	his_addr.su_len = addrlen;
    619  1.118     lukem 	memset((char *)&ctrl_addr, 0, sizeof(ctrl_addr));
    620  1.109     lukem 	addrlen = sizeof(ctrl_addr.si_su);
    621   1.68    itojun 	if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) {
    622   1.68    itojun 		syslog(LOG_ERR, "getsockname (%s): %m",argv[0]);
    623   1.68    itojun 		exit(1);
    624   1.68    itojun 	}
    625  1.109     lukem 	ctrl_addr.su_len = addrlen;
    626  1.104  christos #ifdef INET6
    627   1.67    itojun 	if (his_addr.su_family == AF_INET6
    628  1.109     lukem 	 && IN6_IS_ADDR_V4MAPPED(&his_addr.su_6addr)) {
    629   1.68    itojun #if 1
    630   1.68    itojun 		/*
    631   1.68    itojun 		 * IPv4 control connection arrived to AF_INET6 socket.
    632   1.68    itojun 		 * I hate to do this, but this is the easiest solution.
    633   1.90    itojun 		 *
    634   1.90    itojun 		 * The assumption is untrue on SIIT environment.
    635   1.68    itojun 		 */
    636  1.109     lukem 		struct sockinet tmp_addr;
    637   1.74    itojun 		const int off = sizeof(struct in6_addr) - sizeof(struct in_addr);
    638   1.68    itojun 
    639   1.68    itojun 		tmp_addr = his_addr;
    640   1.68    itojun 		memset(&his_addr, 0, sizeof(his_addr));
    641  1.109     lukem 		his_addr.su_family = AF_INET;
    642  1.109     lukem 		his_addr.su_len = sizeof(his_addr.si_su.su_sin);
    643  1.109     lukem 		memcpy(&his_addr.su_addr, &tmp_addr.su_6addr.s6_addr[off],
    644  1.109     lukem 		    sizeof(his_addr.su_addr));
    645  1.109     lukem 		his_addr.su_port = tmp_addr.su_port;
    646   1.68    itojun 
    647   1.68    itojun 		tmp_addr = ctrl_addr;
    648   1.68    itojun 		memset(&ctrl_addr, 0, sizeof(ctrl_addr));
    649  1.109     lukem 		ctrl_addr.su_family = AF_INET;
    650  1.109     lukem 		ctrl_addr.su_len = sizeof(ctrl_addr.si_su.su_sin);
    651  1.109     lukem 		memcpy(&ctrl_addr.su_addr, &tmp_addr.su_6addr.s6_addr[off],
    652  1.109     lukem 		    sizeof(ctrl_addr.su_addr));
    653  1.109     lukem 		ctrl_addr.su_port = tmp_addr.su_port;
    654   1.68    itojun #else
    655   1.67    itojun 		while (fgets(line, sizeof(line), fd) != NULL) {
    656   1.67    itojun 			if ((cp = strchr(line, '\n')) != NULL)
    657   1.67    itojun 				*cp = '\0';
    658   1.95     lukem 			reply(-530, "%s", line);
    659   1.67    itojun 		}
    660   1.67    itojun 		(void) fflush(stdout);
    661   1.67    itojun 		(void) fclose(fd);
    662   1.67    itojun 		reply(530,
    663  1.101     lukem 		    "Connection from IPv4 mapped address is not supported.");
    664   1.67    itojun 		exit(0);
    665   1.68    itojun #endif
    666   1.75    itojun 
    667   1.75    itojun 		mapped = 1;
    668   1.75    itojun 	} else
    669  1.109     lukem #endif /* INET6 */
    670   1.75    itojun 		mapped = 0;
    671   1.35     lukem #ifdef IP_TOS
    672   1.75    itojun 	if (!mapped && his_addr.su_family == AF_INET) {
    673   1.67    itojun 		tos = IPTOS_LOWDELAY;
    674   1.67    itojun 		if (setsockopt(0, IPPROTO_IP, IP_TOS, (char *)&tos,
    675   1.67    itojun 			       sizeof(int)) < 0)
    676   1.67    itojun 			syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
    677   1.67    itojun 	}
    678   1.35     lukem #endif
    679   1.80     lukem 	/* if the hostname hasn't been given, attempt to determine it */
    680   1.80     lukem 	if (hostname[0] == '\0') {
    681  1.109     lukem 		if (getnameinfo((struct sockaddr *)&ctrl_addr.si_su,
    682  1.180  christos 		    ctrl_addr.su_len, hostname, sizeof(hostname), NULL, 0,
    683  1.180  christos 			getnameopts) != 0)
    684   1.80     lukem 			(void)gethostname(hostname, sizeof(hostname));
    685   1.80     lukem 		hostname[sizeof(hostname) - 1] = '\0';
    686   1.80     lukem 	}
    687   1.79     lukem 
    688   1.35     lukem 	/* set this here so klogin can use it... */
    689   1.35     lukem 	(void)snprintf(ttyline, sizeof(ttyline), "ftp%d", getpid());
    690   1.35     lukem 
    691    1.1       cgd 	(void) freopen(_PATH_DEVNULL, "w", stderr);
    692  1.158     lukem 
    693  1.158     lukem 	memset(&sa, 0, sizeof(sa));
    694  1.158     lukem 	sa.sa_handler = SIG_DFL;
    695  1.158     lukem 	sa.sa_flags = SA_RESTART;
    696  1.158     lukem 	sigemptyset(&sa.sa_mask);
    697  1.158     lukem 	(void) sigaction(SIGCHLD, &sa, NULL);
    698  1.158     lukem 
    699  1.158     lukem 	sa.sa_handler = sigquit;
    700  1.158     lukem 	sa.sa_flags = SA_RESTART;
    701  1.158     lukem 	sigfillset(&sa.sa_mask);	/* block all sigs in these handlers */
    702  1.158     lukem 	(void) sigaction(SIGHUP, &sa, NULL);
    703  1.158     lukem 	(void) sigaction(SIGINT, &sa, NULL);
    704  1.158     lukem 	(void) sigaction(SIGQUIT, &sa, NULL);
    705  1.158     lukem 	(void) sigaction(SIGTERM, &sa, NULL);
    706  1.158     lukem 	sa.sa_handler = lostconn;
    707  1.158     lukem 	(void) sigaction(SIGPIPE, &sa, NULL);
    708  1.158     lukem 	sa.sa_handler = toolong;
    709  1.158     lukem 	(void) sigaction(SIGALRM, &sa, NULL);
    710  1.158     lukem 	sa.sa_handler = sigurg;
    711  1.158     lukem 	(void) sigaction(SIGURG, &sa, NULL);
    712    1.1       cgd 
    713    1.1       cgd 	/* Try to handle urgent data inline */
    714    1.1       cgd #ifdef SO_OOBINLINE
    715    1.1       cgd 	if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof(on)) < 0)
    716  1.119     lukem 		syslog(LOG_WARNING, "setsockopt: %m");
    717    1.1       cgd #endif
    718   1.66    briggs 	/* Set keepalives on the socket to detect dropped connections.  */
    719   1.66    briggs #ifdef SO_KEEPALIVE
    720   1.66    briggs 	keepalive = 1;
    721   1.66    briggs 	if (setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive,
    722   1.66    briggs 	    sizeof(int)) < 0)
    723   1.66    briggs 		syslog(LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m");
    724   1.66    briggs #endif
    725    1.1       cgd 
    726    1.1       cgd #ifdef	F_SETOWN
    727    1.1       cgd 	if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1)
    728  1.119     lukem 		syslog(LOG_WARNING, "fcntl F_SETOWN: %m");
    729    1.1       cgd #endif
    730  1.118     lukem 	logremotehost(&his_addr);
    731    1.1       cgd 	/*
    732    1.1       cgd 	 * Set up default state
    733    1.1       cgd 	 */
    734    1.1       cgd 	data = -1;
    735    1.1       cgd 	type = TYPE_A;
    736    1.1       cgd 	form = FORM_N;
    737    1.1       cgd 	stru = STRU_F;
    738    1.1       cgd 	mode = MODE_S;
    739    1.1       cgd 	tmpline[0] = '\0';
    740   1.57     lukem 	hasyyerrored = 0;
    741    1.8   deraadt 
    742   1.38   mycroft #ifdef KERBEROS5
    743   1.38   mycroft 	kerror = krb5_init_context(&kcontext);
    744   1.38   mycroft 	if (kerror) {
    745  1.119     lukem 		syslog(LOG_ERR, "%s when initializing Kerberos context",
    746   1.38   mycroft 		    error_message(kerror));
    747   1.38   mycroft 		exit(0);
    748   1.38   mycroft 	}
    749   1.45  christos #endif /* KERBEROS5 */
    750   1.38   mycroft 
    751   1.82     lukem 	init_curclass();
    752   1.82     lukem 	curclass.timeout = 300;		/* 5 minutes, as per login(1) */
    753   1.82     lukem 	curclass.type = CLASS_REAL;
    754   1.82     lukem 
    755    1.8   deraadt 	/* If logins are disabled, print out the message. */
    756  1.100     lukem 	if (display_file(_PATH_NOLOGIN, 530)) {
    757    1.8   deraadt 		reply(530, "System not available.");
    758    1.8   deraadt 		exit(0);
    759    1.8   deraadt 	}
    760  1.163  christos 	(void)display_file(conffilename(_NAME_FTPWELCOME), 220);
    761    1.8   deraadt 		/* reply(220,) must follow */
    762  1.101     lukem 	if (EMPTYSTR(version))
    763  1.101     lukem 		reply(220, "%s FTP server ready.", hostname);
    764  1.101     lukem 	else
    765  1.101     lukem 		reply(220, "%s FTP server (%s) ready.", hostname, version);
    766   1.73     lukem 
    767  1.154     lukem 	if (xferlogname != NULL) {
    768  1.154     lukem 		xferlogfd = open(xferlogname, O_WRONLY | O_APPEND | O_CREAT,
    769  1.154     lukem 		    0660);
    770  1.154     lukem 		if (xferlogfd == -1)
    771  1.154     lukem 			syslog(LOG_WARNING, "open xferlog `%s': %m",
    772  1.154     lukem 			    xferlogname);
    773  1.154     lukem 		else
    774  1.154     lukem 			doxferlog |= 2;
    775  1.154     lukem 	}
    776  1.154     lukem 
    777  1.123     aidan 	ftp_loop();
    778    1.1       cgd 	/* NOTREACHED */
    779    1.1       cgd }
    780    1.1       cgd 
    781    1.8   deraadt static void
    782  1.178  christos lostconn(int signo __unused)
    783    1.1       cgd {
    784    1.8   deraadt 
    785  1.171  christos 	if (ftpd_debug)
    786    1.1       cgd 		syslog(LOG_DEBUG, "lost connection");
    787   1.35     lukem 	dologout(1);
    788    1.1       cgd }
    789    1.1       cgd 
    790  1.158     lukem static void
    791  1.178  christos toolong(int signo __unused)
    792  1.158     lukem {
    793  1.158     lukem 
    794  1.158     lukem 		/* XXXSIGRACE */
    795  1.158     lukem 	reply(421,
    796  1.158     lukem 	    "Timeout (" LLF " seconds): closing control connection.",
    797  1.158     lukem 	    (LLT)curclass.timeout);
    798  1.158     lukem 	if (logging)
    799  1.158     lukem 		syslog(LOG_INFO, "User %s timed out after " LLF " seconds",
    800  1.158     lukem 		    (pw ? pw->pw_name : "unknown"), (LLT)curclass.timeout);
    801  1.158     lukem 	dologout(1);
    802  1.158     lukem }
    803  1.158     lukem 
    804  1.158     lukem static void
    805  1.158     lukem sigquit(int signo)
    806  1.158     lukem {
    807  1.158     lukem 
    808  1.171  christos 	if (ftpd_debug)
    809  1.158     lukem 		syslog(LOG_DEBUG, "got signal %d", signo);
    810  1.158     lukem 	dologout(1);
    811  1.158     lukem }
    812  1.158     lukem 
    813  1.158     lukem static void
    814  1.178  christos sigurg(int signo __unused)
    815  1.158     lukem {
    816  1.158     lukem 
    817  1.158     lukem 	urgflag = 1;
    818  1.158     lukem }
    819  1.158     lukem 
    820  1.158     lukem 
    821    1.1       cgd /*
    822    1.1       cgd  * Save the result of a getpwnam.  Used for USER command, since
    823    1.1       cgd  * the data returned must not be clobbered by any other command
    824    1.1       cgd  * (e.g., globbing).
    825    1.1       cgd  */
    826    1.8   deraadt static struct passwd *
    827   1.88     lukem sgetpwnam(const char *name)
    828    1.1       cgd {
    829    1.1       cgd 	static struct passwd save;
    830    1.8   deraadt 	struct passwd *p;
    831    1.1       cgd 
    832    1.1       cgd 	if ((p = getpwnam(name)) == NULL)
    833    1.1       cgd 		return (p);
    834    1.1       cgd 	if (save.pw_name) {
    835   1.54   mycroft 		free((char *)save.pw_name);
    836   1.78     lukem 		memset(save.pw_passwd, 0, strlen(save.pw_passwd));
    837   1.54   mycroft 		free((char *)save.pw_passwd);
    838   1.54   mycroft 		free((char *)save.pw_gecos);
    839   1.54   mycroft 		free((char *)save.pw_dir);
    840   1.54   mycroft 		free((char *)save.pw_shell);
    841    1.1       cgd 	}
    842    1.1       cgd 	save = *p;
    843  1.171  christos 	save.pw_name = ftpd_strdup(p->pw_name);
    844  1.171  christos 	save.pw_passwd = ftpd_strdup(p->pw_passwd);
    845  1.171  christos 	save.pw_gecos = ftpd_strdup(p->pw_gecos);
    846  1.171  christos 	save.pw_dir = ftpd_strdup(p->pw_dir);
    847  1.171  christos 	save.pw_shell = ftpd_strdup(p->pw_shell);
    848    1.1       cgd 	return (&save);
    849    1.1       cgd }
    850    1.1       cgd 
    851   1.93     lukem static int	login_attempts;	/* number of failed login attempts */
    852  1.133     lukem static int	askpasswd;	/* had USER command, ask for PASSwd */
    853  1.133     lukem static int	permitted;	/* USER permitted */
    854    1.1       cgd 
    855    1.1       cgd /*
    856    1.1       cgd  * USER command.
    857    1.1       cgd  * Sets global passwd pointer pw if named account exists and is acceptable;
    858    1.1       cgd  * sets askpasswd if a PASS command is expected.  If logged in previously,
    859    1.1       cgd  * need to reset state.  If name is "ftp" or "anonymous", the name is not in
    860  1.163  christos  * _NAME_FTPUSERS, and ftp account exists, set guest and pw, then just return.
    861    1.1       cgd  * If account doesn't exist, ask for passwd anyway.  Otherwise, check user
    862    1.1       cgd  * requesting login privileges.  Disallow anyone who does not have a standard
    863    1.1       cgd  * shell as returned by getusershell().  Disallow anyone mentioned in the file
    864  1.163  christos  * _NAME_FTPUSERS to allow people such as root and uucp to be avoided.
    865    1.1       cgd  */
    866    1.8   deraadt void
    867   1.88     lukem user(const char *name)
    868    1.1       cgd {
    869  1.133     lukem 	char	*class;
    870  1.164  christos #ifdef	LOGIN_CAP
    871  1.164  christos 	login_cap_t *lc = NULL;
    872  1.164  christos #endif
    873  1.183     lukem #ifdef USE_PAM
    874  1.183     lukem 	int e;
    875  1.183     lukem #endif
    876  1.133     lukem 
    877  1.133     lukem 	class = NULL;
    878    1.1       cgd 	if (logged_in) {
    879   1.73     lukem 		switch (curclass.type) {
    880   1.73     lukem 		case CLASS_GUEST:
    881    1.1       cgd 			reply(530, "Can't change user from guest login.");
    882    1.1       cgd 			return;
    883   1.73     lukem 		case CLASS_CHROOT:
    884    1.5       cgd 			reply(530, "Can't change user from chroot user.");
    885    1.5       cgd 			return;
    886   1.73     lukem 		case CLASS_REAL:
    887  1.101     lukem 			if (dropprivs) {
    888  1.101     lukem 				reply(530, "Can't change user.");
    889  1.101     lukem 				return;
    890  1.101     lukem 			}
    891   1.73     lukem 			end_login();
    892   1.73     lukem 			break;
    893   1.73     lukem 		default:
    894   1.73     lukem 			abort();
    895    1.1       cgd 		}
    896    1.1       cgd 	}
    897    1.1       cgd 
    898   1.92  explorer #if defined(KERBEROS)
    899   1.38   mycroft 	kdestroy();
    900   1.38   mycroft #endif
    901   1.92  explorer #if defined(KERBEROS5)
    902   1.92  explorer 	k5destroy();
    903   1.92  explorer #endif
    904   1.38   mycroft 
    905   1.73     lukem 	curclass.type = CLASS_REAL;
    906  1.133     lukem 	askpasswd = 0;
    907  1.133     lukem 	permitted = 0;
    908  1.133     lukem 
    909    1.1       cgd 	if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) {
    910   1.81     lukem 			/* need `pw' setup for checkaccess() and checkuser () */
    911   1.81     lukem 		if ((pw = sgetpwnam("ftp")) == NULL)
    912   1.81     lukem 			reply(530, "User %s unknown.", name);
    913   1.82     lukem 		else if (! checkaccess("ftp") || ! checkaccess("anonymous"))
    914    1.1       cgd 			reply(530, "User %s access denied.", name);
    915   1.81     lukem 		else {
    916   1.73     lukem 			curclass.type = CLASS_GUEST;
    917    1.1       cgd 			askpasswd = 1;
    918    1.8   deraadt 			reply(331,
    919    1.8   deraadt 			    "Guest login ok, type your name as password.");
    920   1.81     lukem 		}
    921  1.133     lukem 		if (!askpasswd) {
    922  1.133     lukem 			if (logging)
    923  1.133     lukem 				syslog(LOG_NOTICE,
    924  1.133     lukem 				    "ANONYMOUS FTP LOGIN REFUSED FROM %s",
    925  1.191  christos 				    remoteloghost);
    926  1.133     lukem 			end_login();
    927  1.133     lukem 			goto cleanup_user;
    928  1.133     lukem 		}
    929  1.133     lukem 		name = "ftp";
    930  1.133     lukem 	} else
    931  1.133     lukem 		pw = sgetpwnam(name);
    932   1.34     lukem 
    933  1.157     lukem 	strlcpy(curname, name, curname_len);
    934   1.36   mycroft 
    935  1.133     lukem 			/* check user in /etc/ftpusers, and setup class */
    936  1.163  christos 	permitted = checkuser(_NAME_FTPUSERS, curname, 1, 0, &class);
    937  1.133     lukem 
    938  1.133     lukem 			/* check user in /etc/ftpchroot */
    939  1.177     lukem #ifdef	LOGIN_CAP
    940  1.164  christos 	lc = login_getpwclass(pw);
    941  1.177     lukem #endif
    942  1.164  christos 	if (checkuser(_NAME_FTPCHROOT, curname, 0, 0, NULL)
    943  1.164  christos #ifdef	LOGIN_CAP	/* Allow login.conf configuration as well */
    944  1.164  christos 	    || login_getcapbool(lc, "ftp-chroot", 0)
    945  1.164  christos #endif
    946  1.164  christos 	) {
    947  1.133     lukem 		if (curclass.type == CLASS_GUEST) {
    948  1.133     lukem 			syslog(LOG_NOTICE,
    949  1.133     lukem 	    "Can't change guest user to chroot class; remove entry in %s",
    950  1.163  christos 			    _NAME_FTPCHROOT);
    951  1.133     lukem 			exit(1);
    952  1.133     lukem 		}
    953  1.133     lukem 		curclass.type = CLASS_CHROOT;
    954  1.133     lukem 	}
    955  1.183     lukem 
    956  1.133     lukem 			/* determine default class */
    957  1.133     lukem 	if (class == NULL) {
    958  1.133     lukem 		switch (curclass.type) {
    959  1.133     lukem 		case CLASS_GUEST:
    960  1.171  christos 			class = ftpd_strdup("guest");
    961  1.133     lukem 			break;
    962  1.133     lukem 		case CLASS_CHROOT:
    963  1.171  christos 			class = ftpd_strdup("chroot");
    964  1.133     lukem 			break;
    965  1.133     lukem 		case CLASS_REAL:
    966  1.171  christos 			class = ftpd_strdup("real");
    967  1.133     lukem 			break;
    968  1.133     lukem 		default:
    969  1.133     lukem 			syslog(LOG_ERR, "unknown curclass.type %d; aborting",
    970  1.133     lukem 			    curclass.type);
    971  1.133     lukem 			abort();
    972  1.133     lukem 		}
    973  1.133     lukem 	}
    974  1.133     lukem 			/* parse ftpd.conf, setting up various parameters */
    975  1.133     lukem 	parse_conf(class);
    976  1.133     lukem 			/* if not guest user, check for valid shell */
    977  1.133     lukem 	if (pw == NULL)
    978  1.133     lukem 		permitted = 0;
    979  1.133     lukem 	else {
    980  1.133     lukem 		const char	*cp, *shell;
    981  1.133     lukem 
    982  1.133     lukem 		if ((shell = pw->pw_shell) == NULL || *shell == 0)
    983  1.133     lukem 			shell = _PATH_BSHELL;
    984  1.133     lukem 		while ((cp = getusershell()) != NULL)
    985  1.133     lukem 			if (strcmp(cp, shell) == 0)
    986  1.133     lukem 				break;
    987  1.133     lukem 		endusershell();
    988  1.133     lukem 		if (cp == NULL && curclass.type != CLASS_GUEST)
    989  1.133     lukem 			permitted = 0;
    990  1.133     lukem 	}
    991  1.133     lukem 
    992  1.133     lukem 			/* deny quickly (after USER not PASS) if requested */
    993  1.133     lukem 	if (CURCLASS_FLAGS_ISSET(denyquick) && !permitted) {
    994  1.133     lukem 		reply(530, "User %s may not use FTP.", curname);
    995  1.133     lukem 		if (logging)
    996  1.133     lukem 			syslog(LOG_NOTICE, "FTP LOGIN REFUSED FROM %s, %s",
    997  1.191  christos 			    remoteloghost, curname);
    998  1.133     lukem 		end_login();
    999  1.133     lukem 		goto cleanup_user;
   1000  1.133     lukem 	}
   1001  1.133     lukem 
   1002  1.133     lukem 			/* if haven't asked yet (i.e, not anon), ask now */
   1003  1.133     lukem 	if (!askpasswd) {
   1004  1.133     lukem 		askpasswd = 1;
   1005  1.183     lukem #ifdef USE_PAM
   1006  1.183     lukem 		e = auth_pam();		/* this does reply(331, ...) */
   1007  1.183     lukem 		do_pass(1, e, "");
   1008  1.183     lukem 		goto cleanup_user;
   1009  1.183     lukem #else /* !USE_PAM */
   1010    1.7   deraadt #ifdef SKEY
   1011  1.133     lukem 		if (skey_haskey(curname) == 0) {
   1012  1.133     lukem 			const char *myskey;
   1013    1.7   deraadt 
   1014  1.133     lukem 			myskey = skey_keyinfo(curname);
   1015  1.134     lukem 			reply(331, "Password [ %s ] required for %s.",
   1016  1.133     lukem 			    myskey ? myskey : "error getting challenge",
   1017  1.133     lukem 			    curname);
   1018  1.133     lukem 		} else
   1019    1.7   deraadt #endif
   1020  1.133     lukem 			reply(331, "Password required for %s.", curname);
   1021  1.183     lukem #endif /* !USE_PAM */
   1022  1.133     lukem 	}
   1023    1.7   deraadt 
   1024  1.133     lukem  cleanup_user:
   1025  1.164  christos #ifdef LOGIN_CAP
   1026  1.164  christos 	login_close(lc);
   1027  1.164  christos #endif
   1028    1.1       cgd 	/*
   1029    1.1       cgd 	 * Delay before reading passwd after first failed
   1030    1.1       cgd 	 * attempt to slow down passwd-guessing programs.
   1031    1.1       cgd 	 */
   1032    1.1       cgd 	if (login_attempts)
   1033    1.1       cgd 		sleep((unsigned) login_attempts);
   1034  1.133     lukem 
   1035  1.133     lukem 	if (class)
   1036  1.133     lukem 		free(class);
   1037    1.1       cgd }
   1038    1.1       cgd 
   1039    1.1       cgd /*
   1040   1.58     lukem  * Determine whether something is to happen (allow access, chroot)
   1041   1.58     lukem  * for a user. Each line is a shell-style glob followed by
   1042   1.58     lukem  * `yes' or `no'.
   1043   1.58     lukem  *
   1044  1.126       wiz  * For backward compatibility, `allow' and `deny' are synonymns
   1045   1.58     lukem  * for `yes' and `no', respectively.
   1046   1.19       cjs  *
   1047   1.21       cjs  * Each glob is matched against the username in turn, and the first
   1048   1.58     lukem  * match found is used. If no match is found, the result is the
   1049   1.58     lukem  * argument `def'. If a match is found but without and explicit
   1050   1.58     lukem  * `yes'/`no', the result is the opposite of def.
   1051   1.58     lukem  *
   1052   1.58     lukem  * If the file doesn't exist at all, the result is the argument
   1053   1.58     lukem  * `nofile'
   1054   1.21       cjs  *
   1055   1.21       cjs  * Any line starting with `#' is considered a comment and ignored.
   1056   1.19       cjs  *
   1057   1.73     lukem  * Returns 0 if the user is denied, or 1 if they are allowed.
   1058   1.81     lukem  *
   1059   1.81     lukem  * NOTE: needs struct passwd *pw setup before use.
   1060   1.19       cjs  */
   1061  1.118     lukem static int
   1062   1.88     lukem checkuser(const char *fname, const char *name, int def, int nofile,
   1063   1.88     lukem 	    char **retclass)
   1064   1.58     lukem {
   1065   1.58     lukem 	FILE	*fd;
   1066   1.58     lukem 	int	 retval;
   1067  1.132     lukem 	char	*word, *perm, *class, *buf, *p;
   1068   1.76     lukem 	size_t	 len, line;
   1069   1.58     lukem 
   1070   1.58     lukem 	retval = def;
   1071   1.73     lukem 	if (retclass != NULL)
   1072   1.73     lukem 		*retclass = NULL;
   1073   1.58     lukem 	if ((fd = fopen(conffilename(fname), "r")) == NULL)
   1074   1.58     lukem 		return nofile;
   1075   1.19       cjs 
   1076   1.76     lukem 	line = 0;
   1077   1.73     lukem 	for (;
   1078   1.76     lukem 	    (buf = fparseln(fd, &len, &line, NULL, FPARSELN_UNESCCOMM |
   1079  1.147     lukem 			    FPARSELN_UNESCCONT | FPARSELN_UNESCESC)) != NULL;
   1080   1.73     lukem 	    free(buf), buf = NULL) {
   1081  1.132     lukem 		word = perm = class = NULL;
   1082   1.73     lukem 		p = buf;
   1083   1.73     lukem 		if (len < 1)
   1084   1.73     lukem 			continue;
   1085   1.73     lukem 		if (p[len - 1] == '\n')
   1086   1.73     lukem 			p[--len] = '\0';
   1087   1.73     lukem 		if (EMPTYSTR(p))
   1088   1.19       cjs 			continue;
   1089   1.73     lukem 
   1090  1.132     lukem 		NEXTWORD(p, word);
   1091   1.73     lukem 		NEXTWORD(p, perm);
   1092   1.73     lukem 		NEXTWORD(p, class);
   1093  1.132     lukem 		if (EMPTYSTR(word))
   1094   1.70      tron 			continue;
   1095   1.76     lukem 		if (!EMPTYSTR(class)) {
   1096   1.76     lukem 			if (strcasecmp(class, "all") == 0 ||
   1097   1.76     lukem 			    strcasecmp(class, "none") == 0) {
   1098   1.76     lukem 				syslog(LOG_WARNING,
   1099   1.76     lukem 		"%s line %d: illegal user-defined class `%s' - skipping entry",
   1100   1.76     lukem 					    fname, (int)line, class);
   1101   1.76     lukem 				continue;
   1102   1.76     lukem 			}
   1103   1.76     lukem 		}
   1104   1.73     lukem 
   1105   1.73     lukem 					/* have a host specifier */
   1106  1.132     lukem 		if ((p = strchr(word, '@')) != NULL) {
   1107  1.188     lukem 			unsigned char	net[16], mask[16], *addr;
   1108  1.188     lukem 			int		addrlen, bits, bytes, a;
   1109   1.73     lukem 
   1110   1.73     lukem 			*p++ = '\0';
   1111   1.73     lukem 					/* check against network or CIDR */
   1112  1.188     lukem 			memset(net, 0x00, sizeof(net));
   1113  1.188     lukem 			if ((bits = inet_net_pton(his_addr.su_family, p, net,
   1114  1.188     lukem 			    sizeof(net))) != -1) {
   1115  1.188     lukem #ifdef INET6
   1116  1.188     lukem 				if (his_addr.su_family == AF_INET) {
   1117  1.188     lukem #endif
   1118  1.188     lukem 					addrlen = 4;
   1119  1.188     lukem 					addr = (unsigned char *)&his_addr.su_addr;
   1120  1.188     lukem #ifdef INET6
   1121  1.188     lukem 				} else {
   1122  1.188     lukem 					addrlen = 16;
   1123  1.188     lukem 					addr = (unsigned char *)&his_addr.su_6addr;
   1124  1.188     lukem 				}
   1125  1.188     lukem #endif
   1126  1.188     lukem 				bytes = bits / 8;
   1127  1.188     lukem 				bits = bits % 8;
   1128  1.188     lukem 				if (bytes > 0)
   1129  1.188     lukem 					memset(mask, 0xFF, bytes);
   1130  1.188     lukem 				if (bytes < addrlen)
   1131  1.188     lukem 					mask[bytes] = 0xFF << (8 - bits);
   1132  1.188     lukem 				if (bytes + 1 < addrlen)
   1133  1.188     lukem 					memset(mask + bytes + 1, 0x00,
   1134  1.188     lukem 					    addrlen - bytes - 1);
   1135  1.188     lukem 				for (a = 0; a < addrlen; a++)
   1136  1.188     lukem 					if ((addr[a] & mask[a]) != net[a])
   1137  1.188     lukem 						break;
   1138  1.188     lukem 				if (a < addrlen)
   1139   1.73     lukem 					continue;
   1140   1.73     lukem 
   1141   1.73     lukem 					/* check against hostname glob */
   1142  1.132     lukem 			} else if (fnmatch(p, remotehost, FNM_CASEFOLD) != 0)
   1143   1.73     lukem 				continue;
   1144   1.19       cjs 		}
   1145   1.73     lukem 
   1146   1.81     lukem 					/* have a group specifier */
   1147  1.132     lukem 		if ((p = strchr(word, ':')) != NULL) {
   1148   1.81     lukem 			gid_t	*groups, *ng;
   1149   1.81     lukem 			int	 gsize, i, found;
   1150   1.81     lukem 
   1151  1.133     lukem 			if (pw == NULL)
   1152  1.133     lukem 				continue;	/* no match for unknown user */
   1153   1.81     lukem 			*p++ = '\0';
   1154   1.81     lukem 			groups = NULL;
   1155   1.81     lukem 			gsize = 16;
   1156   1.81     lukem 			do {
   1157   1.81     lukem 				ng = realloc(groups, gsize * sizeof(gid_t));
   1158   1.81     lukem 				if (ng == NULL)
   1159   1.81     lukem 					fatal(
   1160   1.81     lukem 					    "Local resource failure: realloc");
   1161   1.81     lukem 				groups = ng;
   1162   1.81     lukem 			} while (getgrouplist(pw->pw_name, pw->pw_gid,
   1163   1.81     lukem 						groups, &gsize) == -1);
   1164   1.81     lukem 			found = 0;
   1165   1.81     lukem 			for (i = 0; i < gsize; i++) {
   1166   1.81     lukem 				struct group *g;
   1167   1.81     lukem 
   1168   1.81     lukem 				if ((g = getgrgid(groups[i])) == NULL)
   1169   1.81     lukem 					continue;
   1170   1.81     lukem 				if (fnmatch(p, g->gr_name, 0) == 0) {
   1171   1.81     lukem 					found = 1;
   1172   1.81     lukem 					break;
   1173   1.81     lukem 				}
   1174   1.81     lukem 			}
   1175   1.81     lukem 			free(groups);
   1176   1.81     lukem 			if (!found)
   1177   1.81     lukem 				continue;
   1178   1.81     lukem 		}
   1179   1.81     lukem 
   1180   1.73     lukem 					/* check against username glob */
   1181  1.132     lukem 		if (fnmatch(word, name, 0) != 0)
   1182   1.73     lukem 			continue;
   1183   1.73     lukem 
   1184   1.73     lukem 		if (perm != NULL &&
   1185   1.73     lukem 		    ((strcasecmp(perm, "allow") == 0) ||
   1186   1.73     lukem 		     (strcasecmp(perm, "yes") == 0)))
   1187   1.73     lukem 			retval = 1;
   1188   1.73     lukem 		else if (perm != NULL &&
   1189   1.73     lukem 		    ((strcasecmp(perm, "deny") == 0) ||
   1190   1.73     lukem 		     (strcasecmp(perm, "no") == 0)))
   1191   1.73     lukem 			retval = 0;
   1192   1.73     lukem 		else
   1193   1.73     lukem 			retval = !def;
   1194   1.73     lukem 		if (!EMPTYSTR(class) && retclass != NULL)
   1195  1.171  christos 			*retclass = ftpd_strdup(class);
   1196   1.73     lukem 		free(buf);
   1197   1.73     lukem 		break;
   1198   1.19       cjs 	}
   1199   1.19       cjs 	(void) fclose(fd);
   1200   1.21       cjs 	return (retval);
   1201   1.19       cjs }
   1202   1.58     lukem 
   1203   1.58     lukem /*
   1204   1.58     lukem  * Check if user is allowed by /etc/ftpusers
   1205   1.73     lukem  * returns 1 for yes, 0 for no
   1206   1.81     lukem  *
   1207   1.81     lukem  * NOTE: needs struct passwd *pw setup (for checkuser())
   1208   1.58     lukem  */
   1209  1.118     lukem static int
   1210   1.88     lukem checkaccess(const char *name)
   1211   1.58     lukem {
   1212   1.58     lukem 
   1213  1.163  christos 	return (checkuser(_NAME_FTPUSERS, name, 1, 0, NULL));
   1214   1.58     lukem }
   1215   1.19       cjs 
   1216  1.140  christos static void
   1217  1.160  christos login_utmp(const char *line, const char *name, const char *host,
   1218  1.160  christos     struct sockinet *haddr)
   1219  1.140  christos {
   1220  1.140  christos #if defined(SUPPORT_UTMPX) || defined(SUPPORT_UTMP)
   1221  1.140  christos 	struct timeval tv;
   1222  1.140  christos 	(void)gettimeofday(&tv, NULL);
   1223  1.140  christos #endif
   1224  1.140  christos #ifdef SUPPORT_UTMPX
   1225  1.140  christos 	if (doutmp) {
   1226  1.140  christos 		(void)memset(&utmpx, 0, sizeof(utmpx));
   1227  1.140  christos 		utmpx.ut_tv = tv;
   1228  1.140  christos 		utmpx.ut_pid = getpid();
   1229  1.140  christos 		utmpx.ut_id[0] = 'f';
   1230  1.140  christos 		utmpx.ut_id[1] = 't';
   1231  1.140  christos 		utmpx.ut_id[2] = 'p';
   1232  1.140  christos 		utmpx.ut_id[3] = '*';
   1233  1.140  christos 		utmpx.ut_type = USER_PROCESS;
   1234  1.144    itojun 		(void)strncpy(utmpx.ut_name, name, sizeof(utmpx.ut_name));
   1235  1.144    itojun 		(void)strncpy(utmpx.ut_line, line, sizeof(utmpx.ut_line));
   1236  1.144    itojun 		(void)strncpy(utmpx.ut_host, host, sizeof(utmpx.ut_host));
   1237  1.160  christos 		(void)memcpy(&utmpx.ut_ss, &haddr->si_su, haddr->su_len);
   1238  1.155     tacha 		ftpd_loginx(&utmpx);
   1239  1.140  christos 	}
   1240  1.140  christos 	if (dowtmp)
   1241  1.160  christos 		ftpd_logwtmpx(line, name, host, haddr, 0, USER_PROCESS);
   1242  1.140  christos #endif
   1243  1.140  christos #ifdef SUPPORT_UTMP
   1244  1.140  christos 	if (doutmp) {
   1245  1.140  christos 		(void)memset(&utmp, 0, sizeof(utmp));
   1246  1.140  christos 		(void)time(&utmp.ut_time);
   1247  1.144    itojun 		(void)strncpy(utmp.ut_name, name, sizeof(utmp.ut_name));
   1248  1.144    itojun 		(void)strncpy(utmp.ut_line, line, sizeof(utmp.ut_line));
   1249  1.144    itojun 		(void)strncpy(utmp.ut_host, host, sizeof(utmp.ut_host));
   1250  1.152     lukem 		ftpd_login(&utmp);
   1251  1.140  christos 	}
   1252  1.140  christos 	if (dowtmp)
   1253  1.152     lukem 		ftpd_logwtmp(line, name, host);
   1254  1.140  christos #endif
   1255  1.140  christos }
   1256  1.140  christos 
   1257  1.140  christos static void
   1258  1.140  christos logout_utmp(void)
   1259  1.140  christos {
   1260  1.140  christos #ifdef SUPPORT_UTMPX
   1261  1.166  christos 	int okwtmpx = dowtmp;
   1262  1.140  christos #endif
   1263  1.140  christos #ifdef SUPPORT_UTMP
   1264  1.166  christos 	int okwtmp = dowtmp;
   1265  1.140  christos #endif
   1266  1.166  christos 	if (logged_in) {
   1267  1.140  christos #ifdef SUPPORT_UTMPX
   1268  1.166  christos 		if (doutmp)
   1269  1.166  christos 			okwtmpx &= ftpd_logoutx(ttyline, 0, DEAD_PROCESS);
   1270  1.166  christos 		if (okwtmpx)
   1271  1.166  christos 			ftpd_logwtmpx(ttyline, "", "", NULL, 0, DEAD_PROCESS);
   1272  1.140  christos #endif
   1273  1.140  christos #ifdef SUPPORT_UTMP
   1274  1.166  christos 		if (doutmp)
   1275  1.166  christos 			okwtmp &= ftpd_logout(ttyline);
   1276  1.166  christos 		if (okwtmp)
   1277  1.152     lukem 			ftpd_logwtmp(ttyline, "", "");
   1278  1.140  christos #endif
   1279  1.140  christos 	}
   1280  1.140  christos }
   1281  1.140  christos 
   1282   1.19       cjs /*
   1283  1.118     lukem  * Terminate login as previous user (if any), resetting state;
   1284    1.1       cgd  * used when USER command is given or login fails.
   1285    1.1       cgd  */
   1286    1.8   deraadt static void
   1287   1.88     lukem end_login(void)
   1288    1.1       cgd {
   1289  1.164  christos #ifdef USE_PAM
   1290  1.164  christos 	int e;
   1291  1.164  christos #endif
   1292  1.140  christos 	logout_utmp();
   1293  1.118     lukem 	show_chdir_messages(-1);		/* flush chdir cache */
   1294  1.118     lukem 	if (pw != NULL && pw->pw_passwd != NULL)
   1295  1.118     lukem 		memset(pw->pw_passwd, 0, strlen(pw->pw_passwd));
   1296    1.1       cgd 	pw = NULL;
   1297    1.1       cgd 	logged_in = 0;
   1298  1.133     lukem 	askpasswd = 0;
   1299  1.133     lukem 	permitted = 0;
   1300   1.85     lukem 	quietmessages = 0;
   1301   1.95     lukem 	gidcount = 0;
   1302   1.73     lukem 	curclass.type = CLASS_REAL;
   1303  1.118     lukem 	(void) seteuid((uid_t)0);
   1304  1.164  christos #ifdef	LOGIN_CAP
   1305  1.164  christos 	setusercontext(NULL, getpwuid(0), 0,
   1306  1.164  christos 		       LOGIN_SETPRIORITY|LOGIN_SETRESOURCES|LOGIN_SETUMASK);
   1307  1.164  christos #endif
   1308  1.164  christos #ifdef USE_PAM
   1309  1.164  christos 	if (pamh) {
   1310  1.164  christos 		if ((e = pam_setcred(pamh, PAM_DELETE_CRED)) != PAM_SUCCESS)
   1311  1.164  christos 			syslog(LOG_ERR, "pam_setcred: %s",
   1312  1.164  christos 			    pam_strerror(pamh, e));
   1313  1.164  christos 		if ((e = pam_close_session(pamh,0)) != PAM_SUCCESS)
   1314  1.164  christos 			syslog(LOG_ERR, "pam_close_session: %s",
   1315  1.164  christos 			    pam_strerror(pamh, e));
   1316  1.164  christos 		if ((e = pam_end(pamh, e)) != PAM_SUCCESS)
   1317  1.164  christos 			syslog(LOG_ERR, "pam_end: %s", pam_strerror(pamh, e));
   1318  1.164  christos 		pamh = NULL;
   1319  1.164  christos 	}
   1320  1.164  christos #endif
   1321    1.1       cgd }
   1322    1.1       cgd 
   1323    1.8   deraadt void
   1324   1.88     lukem pass(const char *passwd)
   1325    1.1       cgd {
   1326  1.183     lukem 	do_pass(0, 0, passwd);
   1327  1.183     lukem }
   1328  1.183     lukem 
   1329  1.183     lukem /*
   1330  1.183     lukem  * Perform the passwd confirmation and login.
   1331  1.183     lukem  *
   1332  1.183     lukem  * If pass_checked is zero, confirm passwd is correct, & ignore pass_rval.
   1333  1.183     lukem  * This is the traditional PASS implementation.
   1334  1.183     lukem  *
   1335  1.183     lukem  * If pass_checked is non-zero, use pass_rval and ignore passwd.
   1336  1.183     lukem  * This is used by auth_pam() which has already parsed PASS.
   1337  1.183     lukem  * This only applies to curclass.type != CLASS_GUEST.
   1338  1.183     lukem  */
   1339  1.183     lukem static void
   1340  1.183     lukem do_pass(int pass_checked, int pass_rval, const char *passwd)
   1341  1.183     lukem {
   1342   1.78     lukem 	int		 rval;
   1343  1.133     lukem 	char		 root[MAXPATHLEN];
   1344  1.164  christos #ifdef	LOGIN_CAP
   1345  1.164  christos 	login_cap_t *lc = NULL;
   1346  1.164  christos #endif
   1347  1.164  christos #ifdef USE_PAM
   1348  1.164  christos 	int e;
   1349  1.164  christos #endif
   1350  1.183     lukem 
   1351  1.183     lukem 	rval = 1;
   1352  1.183     lukem 
   1353    1.1       cgd 	if (logged_in || askpasswd == 0) {
   1354    1.1       cgd 		reply(503, "Login with USER first.");
   1355    1.1       cgd 		return;
   1356    1.1       cgd 	}
   1357    1.1       cgd 	askpasswd = 0;
   1358   1.73     lukem 	if (curclass.type != CLASS_GUEST) {
   1359  1.101     lukem 			/* "ftp" is the only account allowed with no password */
   1360    1.8   deraadt 		if (pw == NULL) {
   1361    1.8   deraadt 			rval = 1;	/* failure below */
   1362    1.8   deraadt 			goto skip;
   1363    1.8   deraadt 		}
   1364  1.183     lukem 		if (pass_checked) {	/* password validated in user() */
   1365  1.183     lukem 			rval = pass_rval;
   1366  1.164  christos 			goto skip;
   1367  1.164  christos 		}
   1368  1.183     lukem #ifdef USE_PAM
   1369  1.183     lukem 		syslog(LOG_ERR, "do_pass: USE_PAM shouldn't get here");
   1370  1.183     lukem 		rval = 1;
   1371  1.164  christos 		goto skip;
   1372  1.164  christos #endif
   1373   1.92  explorer #if defined(KERBEROS)
   1374   1.64   thorpej 		if (klogin(pw, "", hostname, (char *)passwd) == 0) {
   1375   1.92  explorer 			rval = 0;
   1376   1.92  explorer 			goto skip;
   1377   1.92  explorer 		}
   1378   1.92  explorer #endif
   1379   1.92  explorer #if defined(KERBEROS5)
   1380   1.92  explorer 		if (k5login(pw, "", hostname, (char *)passwd) == 0) {
   1381   1.37   mycroft 			rval = 0;
   1382   1.37   mycroft 			goto skip;
   1383   1.37   mycroft 		}
   1384   1.37   mycroft #endif
   1385   1.36   mycroft #ifdef SKEY
   1386   1.62     lukem 		if (skey_haskey(pw->pw_name) == 0) {
   1387   1.62     lukem 			char *p;
   1388   1.62     lukem 			int r;
   1389   1.62     lukem 
   1390  1.171  christos 			p = ftpd_strdup(passwd);
   1391   1.62     lukem 			r = skey_passcheck(pw->pw_name, p);
   1392   1.62     lukem 			free(p);
   1393   1.62     lukem 			if (r != -1) {
   1394   1.62     lukem 				rval = 0;
   1395   1.62     lukem 				goto skip;
   1396   1.62     lukem 			}
   1397   1.36   mycroft 		}
   1398    1.4       cgd #endif
   1399  1.116     lukem 		if (!sflag)
   1400  1.116     lukem 			rval = checkpassword(pw, passwd);
   1401  1.116     lukem 		else
   1402  1.116     lukem 			rval = 1;
   1403    1.4       cgd 
   1404   1.89     lukem  skip:
   1405  1.101     lukem 
   1406  1.101     lukem 			/*
   1407  1.101     lukem 			 * If rval > 0, the user failed the authentication check
   1408  1.101     lukem 			 * above.  If rval == 0, either Kerberos or local
   1409  1.101     lukem 			 * authentication succeeded.
   1410  1.101     lukem 			 */
   1411    1.4       cgd 		if (rval) {
   1412   1.98  sommerfe 			reply(530, "%s", rval == 2 ? "Password expired." :
   1413   1.45  christos 			    "Login incorrect.");
   1414  1.201  christos 			pfilter_notify(1, rval == 2 ? "exppass" : "badpass");
   1415   1.23     lukem 			if (logging) {
   1416    1.8   deraadt 				syslog(LOG_NOTICE,
   1417  1.191  christos 				    "FTP LOGIN FAILED FROM %s", remoteloghost);
   1418   1.23     lukem 				syslog(LOG_AUTHPRIV | LOG_NOTICE,
   1419    1.8   deraadt 				    "FTP LOGIN FAILED FROM %s, %s",
   1420  1.191  christos 				    remoteloghost, curname);
   1421   1.23     lukem 			}
   1422    1.1       cgd 			pw = NULL;
   1423    1.1       cgd 			if (login_attempts++ >= 5) {
   1424    1.1       cgd 				syslog(LOG_NOTICE,
   1425    1.1       cgd 				    "repeated login failures from %s",
   1426  1.191  christos 				    remoteloghost);
   1427    1.1       cgd 				exit(0);
   1428    1.1       cgd 			}
   1429    1.1       cgd 			return;
   1430    1.1       cgd 		}
   1431    1.1       cgd 	}
   1432   1.19       cjs 
   1433  1.133     lukem 			/* password ok; check if anything else prevents login */
   1434  1.133     lukem 	if (! permitted) {
   1435   1.19       cjs 		reply(530, "User %s may not use FTP.", pw->pw_name);
   1436   1.19       cjs 		if (logging)
   1437   1.62     lukem 			syslog(LOG_NOTICE, "FTP LOGIN REFUSED FROM %s, %s",
   1438  1.191  christos 			    remoteloghost, pw->pw_name);
   1439   1.82     lukem 		goto bad;
   1440   1.19       cjs 	}
   1441   1.19       cjs 
   1442    1.1       cgd 	login_attempts = 0;		/* this time successful */
   1443    1.8   deraadt 	if (setegid((gid_t)pw->pw_gid) < 0) {
   1444    1.8   deraadt 		reply(550, "Can't set gid.");
   1445   1.82     lukem 		goto bad;
   1446    1.8   deraadt 	}
   1447  1.164  christos #ifdef	LOGIN_CAP
   1448  1.164  christos 	if ((lc = login_getpwclass(pw)) != NULL) {
   1449  1.164  christos #ifdef notyet
   1450  1.164  christos 		char	remote_ip[NI_MAXHOST];
   1451  1.164  christos 
   1452  1.164  christos 		if (getnameinfo((struct sockaddr *)&his_addr, his_addr.su_len,
   1453  1.164  christos 			remote_ip, sizeof(remote_ip) - 1, NULL, 0,
   1454  1.164  christos 			NI_NUMERICHOST))
   1455  1.164  christos 				*remote_ip = 0;
   1456  1.164  christos 		remote_ip[sizeof(remote_ip) - 1] = 0;
   1457  1.164  christos 		if (!auth_hostok(lc, remotehost, remote_ip)) {
   1458  1.201  christos 			pfilter_notify(1, "bannedhost");
   1459  1.164  christos 			syslog(LOG_INFO|LOG_AUTH,
   1460  1.164  christos 			    "FTP LOGIN FAILED (HOST) as %s: permission denied.",
   1461  1.164  christos 			    pw->pw_name);
   1462  1.164  christos 			reply(530, "Permission denied.");
   1463  1.164  christos 			pw = NULL;
   1464  1.164  christos 			return;
   1465  1.164  christos 		}
   1466  1.164  christos 		if (!auth_timeok(lc, time(NULL))) {
   1467  1.164  christos 			reply(530, "Login not available right now.");
   1468  1.164  christos 			pw = NULL;
   1469  1.164  christos 			return;
   1470  1.164  christos 		}
   1471  1.164  christos #endif
   1472  1.164  christos 	}
   1473  1.164  christos 	setsid();
   1474  1.164  christos 	setusercontext(lc, pw, 0,
   1475  1.164  christos 		LOGIN_SETLOGIN|LOGIN_SETGROUP|LOGIN_SETPRIORITY|
   1476  1.164  christos 		LOGIN_SETRESOURCES|LOGIN_SETUMASK);
   1477  1.164  christos #else
   1478    1.1       cgd 	(void) initgroups(pw->pw_name, pw->pw_gid);
   1479  1.101     lukem 			/* cache groups for cmds.c::matchgroup() */
   1480  1.164  christos #endif
   1481  1.164  christos #ifdef USE_PAM
   1482  1.164  christos 	if (pamh) {
   1483  1.164  christos 		if ((e = pam_open_session(pamh, 0)) != PAM_SUCCESS) {
   1484  1.164  christos 			syslog(LOG_ERR, "pam_open_session: %s",
   1485  1.164  christos 			    pam_strerror(pamh, e));
   1486  1.164  christos 		} else if ((e = pam_setcred(pamh, PAM_ESTABLISH_CRED))
   1487  1.164  christos 		    != PAM_SUCCESS) {
   1488  1.164  christos 			syslog(LOG_ERR, "pam_setcred: %s",
   1489  1.164  christos 			    pam_strerror(pamh, e));
   1490  1.164  christos 		}
   1491  1.164  christos 	}
   1492  1.164  christos #endif
   1493  1.151       dsl 	gidcount = getgroups(0, NULL);
   1494  1.151       dsl 	if (gidlist)
   1495  1.151       dsl 		free(gidlist);
   1496  1.151       dsl 	gidlist = malloc(gidcount * sizeof *gidlist);
   1497  1.151       dsl 	gidcount = getgroups(gidcount, gidlist);
   1498    1.1       cgd 
   1499  1.140  christos 	/* open utmp/wtmp before chroot */
   1500  1.160  christos 	login_utmp(ttyline, pw->pw_name, remotehost, &his_addr);
   1501   1.78     lukem 
   1502    1.1       cgd 	logged_in = 1;
   1503    1.1       cgd 
   1504  1.111     lukem 	connections = 1;
   1505  1.111     lukem 	if (dopidfile)
   1506  1.111     lukem 		count_users();
   1507   1.82     lukem 	if (curclass.limit != -1 && connections > curclass.limit) {
   1508   1.82     lukem 		if (! EMPTYSTR(curclass.limitfile))
   1509  1.100     lukem 			(void)display_file(conffilename(curclass.limitfile),
   1510  1.100     lukem 			    530);
   1511   1.82     lukem 		reply(530,
   1512  1.147     lukem 		    "User %s access denied, connection limit of " LLF
   1513  1.147     lukem 		    " reached.",
   1514  1.147     lukem 		    pw->pw_name, (LLT)curclass.limit);
   1515   1.82     lukem 		syslog(LOG_NOTICE,
   1516  1.147     lukem 		    "Maximum connection limit of " LLF
   1517  1.147     lukem 		    " for class %s reached, login refused for %s",
   1518  1.147     lukem 		    (LLT)curclass.limit, curclass.classname, pw->pw_name);
   1519   1.82     lukem 		goto bad;
   1520   1.82     lukem 	}
   1521   1.24     lukem 
   1522  1.100     lukem 	homedir[0] = '/';
   1523   1.73     lukem 	switch (curclass.type) {
   1524   1.73     lukem 	case CLASS_GUEST:
   1525  1.101     lukem 			/*
   1526  1.101     lukem 			 * We MUST do a chdir() after the chroot. Otherwise
   1527  1.101     lukem 			 * the old current directory will be accessible as "."
   1528  1.101     lukem 			 * outside the new root!
   1529  1.101     lukem 			 */
   1530  1.100     lukem 		format_path(root,
   1531  1.100     lukem 		    curclass.chroot ? curclass.chroot :
   1532  1.100     lukem 		    anondir ? anondir :
   1533  1.100     lukem 		    pw->pw_dir);
   1534  1.100     lukem 		format_path(homedir,
   1535  1.100     lukem 		    curclass.homedir ? curclass.homedir :
   1536  1.100     lukem 		    "/");
   1537  1.100     lukem 		if (EMPTYSTR(homedir))
   1538  1.100     lukem 			homedir[0] = '/';
   1539  1.100     lukem 		if (EMPTYSTR(root) || chroot(root) < 0) {
   1540  1.100     lukem 			syslog(LOG_NOTICE,
   1541  1.100     lukem 			    "GUEST user %s: can't chroot to %s: %m",
   1542  1.100     lukem 			    pw->pw_name, root);
   1543  1.100     lukem 			goto bad_guest;
   1544  1.100     lukem 		}
   1545  1.100     lukem 		if (chdir(homedir) < 0) {
   1546  1.100     lukem 			syslog(LOG_NOTICE,
   1547  1.100     lukem 			    "GUEST user %s: can't chdir to %s: %m",
   1548  1.100     lukem 			    pw->pw_name, homedir);
   1549  1.100     lukem  bad_guest:
   1550    1.1       cgd 			reply(550, "Can't set guest privileges.");
   1551    1.5       cgd 			goto bad;
   1552    1.5       cgd 		}
   1553   1.73     lukem 		break;
   1554   1.73     lukem 	case CLASS_CHROOT:
   1555  1.100     lukem 		format_path(root,
   1556  1.100     lukem 		    curclass.chroot ? curclass.chroot :
   1557  1.100     lukem 		    pw->pw_dir);
   1558  1.100     lukem 		format_path(homedir,
   1559  1.100     lukem 		    curclass.homedir ? curclass.homedir :
   1560  1.100     lukem 		    "/");
   1561  1.100     lukem 		if (EMPTYSTR(homedir))
   1562  1.100     lukem 			homedir[0] = '/';
   1563  1.100     lukem 		if (EMPTYSTR(root) || chroot(root) < 0) {
   1564  1.100     lukem 			syslog(LOG_NOTICE,
   1565  1.100     lukem 			    "CHROOT user %s: can't chroot to %s: %m",
   1566  1.100     lukem 			    pw->pw_name, root);
   1567  1.100     lukem 			goto bad_chroot;
   1568  1.100     lukem 		}
   1569  1.100     lukem 		if (chdir(homedir) < 0) {
   1570  1.100     lukem 			syslog(LOG_NOTICE,
   1571  1.100     lukem 			    "CHROOT user %s: can't chdir to %s: %m",
   1572  1.100     lukem 			    pw->pw_name, homedir);
   1573  1.100     lukem  bad_chroot:
   1574    1.5       cgd 			reply(550, "Can't change root.");
   1575    1.1       cgd 			goto bad;
   1576    1.1       cgd 		}
   1577   1.73     lukem 		break;
   1578   1.73     lukem 	case CLASS_REAL:
   1579  1.172       wiz 			/* only chroot REAL if explicitly requested */
   1580  1.118     lukem 		if (! EMPTYSTR(curclass.chroot)) {
   1581  1.118     lukem 			format_path(root, curclass.chroot);
   1582  1.118     lukem 			if (EMPTYSTR(root) || chroot(root) < 0) {
   1583  1.118     lukem 				syslog(LOG_NOTICE,
   1584  1.118     lukem 				    "REAL user %s: can't chroot to %s: %m",
   1585  1.118     lukem 				    pw->pw_name, root);
   1586  1.118     lukem 				goto bad_chroot;
   1587  1.118     lukem 			}
   1588  1.118     lukem 		}
   1589  1.100     lukem 		format_path(homedir,
   1590  1.100     lukem 		    curclass.homedir ? curclass.homedir :
   1591  1.100     lukem 		    pw->pw_dir);
   1592  1.100     lukem 		if (EMPTYSTR(homedir) || chdir(homedir) < 0) {
   1593   1.73     lukem 			if (chdir("/") < 0) {
   1594  1.100     lukem 				syslog(LOG_NOTICE,
   1595  1.100     lukem 				    "REAL user %s: can't chdir to %s: %m",
   1596  1.100     lukem 				    pw->pw_name,
   1597  1.100     lukem 				    !EMPTYSTR(homedir) ?  homedir : "/");
   1598   1.73     lukem 				reply(530,
   1599   1.73     lukem 				    "User %s: can't change directory to %s.",
   1600  1.100     lukem 				    pw->pw_name,
   1601  1.100     lukem 				    !EMPTYSTR(homedir) ? homedir : "/");
   1602   1.73     lukem 				goto bad;
   1603  1.100     lukem 			} else {
   1604   1.95     lukem 				reply(-230,
   1605   1.73     lukem 				    "No directory! Logging in with home=/");
   1606  1.100     lukem 				homedir[0] = '/';
   1607  1.100     lukem 			}
   1608  1.100     lukem 		}
   1609   1.73     lukem 		break;
   1610   1.73     lukem 	}
   1611  1.164  christos #ifndef LOGIN_CAP
   1612  1.151       dsl 	setsid();
   1613  1.105  jdolecek 	setlogin(pw->pw_name);
   1614  1.164  christos #endif
   1615  1.101     lukem 	if (dropprivs ||
   1616  1.101     lukem 	    (curclass.type != CLASS_REAL &&
   1617  1.101     lukem 	    ntohs(ctrl_addr.su_port) > IPPORT_RESERVED + 1)) {
   1618  1.101     lukem 		dropprivs++;
   1619  1.101     lukem 		if (setgid((gid_t)pw->pw_gid) < 0) {
   1620  1.101     lukem 			reply(550, "Can't set gid.");
   1621  1.101     lukem 			goto bad;
   1622  1.101     lukem 		}
   1623  1.101     lukem 		if (setuid((uid_t)pw->pw_uid) < 0) {
   1624  1.101     lukem 			reply(550, "Can't set uid.");
   1625  1.101     lukem 			goto bad;
   1626  1.101     lukem 		}
   1627  1.101     lukem 	} else {
   1628  1.101     lukem 		if (seteuid((uid_t)pw->pw_uid) < 0) {
   1629  1.101     lukem 			reply(550, "Can't set uid.");
   1630  1.101     lukem 			goto bad;
   1631  1.101     lukem 		}
   1632    1.1       cgd 	}
   1633  1.100     lukem 	setenv("HOME", homedir, 1);
   1634   1.44     lukem 
   1635   1.85     lukem 	if (curclass.type == CLASS_GUEST && passwd[0] == '-')
   1636   1.85     lukem 		quietmessages = 1;
   1637   1.85     lukem 
   1638  1.101     lukem 			/*
   1639  1.101     lukem 			 * Display a login message, if it exists.
   1640  1.101     lukem 			 * N.B. reply(230,) must follow the message.
   1641  1.101     lukem 			 */
   1642  1.131     lukem 	if (! EMPTYSTR(curclass.motd))
   1643  1.131     lukem 		(void)display_file(conffilename(curclass.motd), 230);
   1644   1.24     lukem 	show_chdir_messages(230);
   1645   1.73     lukem 	if (curclass.type == CLASS_GUEST) {
   1646  1.118     lukem 		char *p;
   1647  1.118     lukem 
   1648    1.1       cgd 		reply(230, "Guest login ok, access restrictions apply.");
   1649  1.181     lukem #if defined(HAVE_SETPROCTITLE)
   1650    1.8   deraadt 		snprintf(proctitle, sizeof(proctitle),
   1651  1.129     lukem 		    "%s: anonymous/%s", remotehost, passwd);
   1652   1.97    itojun 		setproctitle("%s", proctitle);
   1653  1.181     lukem #endif /* defined(HAVE_SETPROCTITLE) */
   1654    1.1       cgd 		if (logging)
   1655   1.81     lukem 			syslog(LOG_INFO,
   1656   1.81     lukem 			"ANONYMOUS FTP LOGIN FROM %s, %s (class: %s, type: %s)",
   1657  1.191  christos 			    remoteloghost, passwd,
   1658   1.81     lukem 			    curclass.classname, CURCLASSTYPE);
   1659  1.118     lukem 			/* store guest password reply into pw_passwd */
   1660  1.171  christos 		REASSIGN(pw->pw_passwd, ftpd_strdup(passwd));
   1661  1.118     lukem 		for (p = pw->pw_passwd; *p; p++)
   1662  1.159       dsl 			if (!isgraph((unsigned char)*p))
   1663  1.118     lukem 				*p = '_';
   1664    1.1       cgd 	} else {
   1665    1.1       cgd 		reply(230, "User %s logged in.", pw->pw_name);
   1666  1.181     lukem #if defined(HAVE_SETPROCTITLE)
   1667    1.8   deraadt 		snprintf(proctitle, sizeof(proctitle),
   1668    1.8   deraadt 		    "%s: %s", remotehost, pw->pw_name);
   1669   1.97    itojun 		setproctitle("%s", proctitle);
   1670  1.181     lukem #endif /* defined(HAVE_SETPROCTITLE) */
   1671    1.1       cgd 		if (logging)
   1672   1.81     lukem 			syslog(LOG_INFO,
   1673   1.81     lukem 			    "FTP LOGIN FROM %s as %s (class: %s, type: %s)",
   1674  1.191  christos 			    remoteloghost, pw->pw_name,
   1675   1.81     lukem 			    curclass.classname, CURCLASSTYPE);
   1676    1.1       cgd 	}
   1677   1.24     lukem 	(void) umask(curclass.umask);
   1678  1.164  christos #ifdef	LOGIN_CAP
   1679  1.164  christos 	login_close(lc);
   1680  1.164  christos #endif
   1681  1.133     lukem 	return;
   1682  1.111     lukem 
   1683   1.73     lukem  bad:
   1684  1.164  christos #ifdef	LOGIN_CAP
   1685  1.164  christos 	login_close(lc);
   1686  1.164  christos #endif
   1687  1.101     lukem 			/* Forget all about it... */
   1688    1.1       cgd 	end_login();
   1689    1.1       cgd }
   1690    1.1       cgd 
   1691    1.8   deraadt void
   1692  1.193     lukem retrieve(const char *argv[], const char *name)
   1693    1.1       cgd {
   1694   1.95     lukem 	FILE *fin, *dout;
   1695    1.1       cgd 	struct stat st;
   1696   1.88     lukem 	int (*closefunc)(FILE *) = NULL;
   1697  1.148   thorpej 	int dolog, sendrv, closerv, stderrfd, isconversion, isdata, isls;
   1698   1.62     lukem 	struct timeval start, finish, td, *tdp;
   1699  1.139     enami 	struct rusage rusage_before, rusage_after;
   1700   1.62     lukem 	const char *dispname;
   1701  1.193     lukem 	const char *error;
   1702    1.1       cgd 
   1703   1.49     lukem 	sendrv = closerv = stderrfd = -1;
   1704  1.148   thorpej 	isconversion = isdata = isls = dolog = 0;
   1705   1.62     lukem 	tdp = NULL;
   1706   1.62     lukem 	dispname = name;
   1707   1.95     lukem 	fin = dout = NULL;
   1708  1.138     lukem 	error = NULL;
   1709  1.118     lukem 	if (argv == NULL) {		/* if not running a command ... */
   1710  1.148   thorpej 		dolog = 1;
   1711   1.62     lukem 		isdata = 1;
   1712   1.62     lukem 		fin = fopen(name, "r");
   1713   1.62     lukem 		closefunc = fclose;
   1714  1.118     lukem 		if (fin == NULL)	/* doesn't exist?; try a conversion */
   1715   1.71     lukem 			argv = do_conversion(name);
   1716   1.71     lukem 		if (argv != NULL) {
   1717   1.49     lukem 			isconversion++;
   1718  1.118     lukem 			syslog(LOG_DEBUG, "get command: '%s' on '%s'",
   1719   1.71     lukem 			    argv[0], name);
   1720   1.49     lukem 		}
   1721   1.24     lukem 	}
   1722   1.71     lukem 	if (argv != NULL) {
   1723   1.82     lukem 		char temp[MAXPATHLEN];
   1724    1.1       cgd 
   1725   1.71     lukem 		if (strcmp(argv[0], INTERNAL_LS) == 0) {
   1726   1.63     lukem 			isls = 1;
   1727   1.63     lukem 			stderrfd = -1;
   1728   1.63     lukem 		} else {
   1729   1.63     lukem 			(void)snprintf(temp, sizeof(temp), "%s", TMPFILE);
   1730   1.63     lukem 			stderrfd = mkstemp(temp);
   1731   1.63     lukem 			if (stderrfd != -1)
   1732   1.63     lukem 				(void)unlink(temp);
   1733   1.63     lukem 		}
   1734   1.71     lukem 		dispname = argv[0];
   1735   1.71     lukem 		fin = ftpd_popen(argv, "r", stderrfd);
   1736   1.62     lukem 		closefunc = ftpd_pclose;
   1737    1.1       cgd 		st.st_size = -1;
   1738    1.1       cgd 		st.st_blksize = BUFSIZ;
   1739    1.1       cgd 	}
   1740    1.1       cgd 	if (fin == NULL) {
   1741    1.8   deraadt 		if (errno != 0) {
   1742   1.62     lukem 			perror_reply(550, dispname);
   1743  1.148   thorpej 			if (dolog)
   1744  1.118     lukem 				logxfer("get", -1, name, NULL, NULL,
   1745   1.62     lukem 				    strerror(errno));
   1746    1.8   deraadt 		}
   1747   1.71     lukem 		goto cleanupretrieve;
   1748    1.1       cgd 	}
   1749    1.8   deraadt 	byte_count = -1;
   1750   1.71     lukem 	if (argv == NULL
   1751   1.49     lukem 	    && (fstat(fileno(fin), &st) < 0 || !S_ISREG(st.st_mode))) {
   1752  1.138     lukem 		error = "Not a plain file";
   1753  1.138     lukem 		reply(550, "%s: %s.", dispname, error);
   1754    1.1       cgd 		goto done;
   1755    1.1       cgd 	}
   1756    1.1       cgd 	if (restart_point) {
   1757    1.1       cgd 		if (type == TYPE_A) {
   1758   1.49     lukem 			off_t i;
   1759    1.8   deraadt 			int c;
   1760    1.1       cgd 
   1761   1.49     lukem 			for (i = 0; i < restart_point; i++) {
   1762    1.1       cgd 				if ((c=getc(fin)) == EOF) {
   1763  1.138     lukem 					error = strerror(errno);
   1764   1.62     lukem 					perror_reply(550, dispname);
   1765    1.1       cgd 					goto done;
   1766    1.1       cgd 				}
   1767    1.1       cgd 				if (c == '\n')
   1768    1.1       cgd 					i++;
   1769    1.8   deraadt 			}
   1770   1.31    kleink 		} else if (lseek(fileno(fin), restart_point, SEEK_SET) < 0) {
   1771  1.138     lukem 			error = strerror(errno);
   1772   1.62     lukem 			perror_reply(550, dispname);
   1773    1.1       cgd 			goto done;
   1774    1.1       cgd 		}
   1775    1.1       cgd 	}
   1776   1.62     lukem 	dout = dataconn(dispname, st.st_size, "w");
   1777    1.1       cgd 	if (dout == NULL)
   1778    1.1       cgd 		goto done;
   1779   1.62     lukem 
   1780  1.139     enami 	(void)getrusage(RUSAGE_SELF, &rusage_before);
   1781   1.62     lukem 	(void)gettimeofday(&start, NULL);
   1782  1.139     enami 	sendrv = send_data(fin, dout, &st, isdata);
   1783   1.62     lukem 	(void)gettimeofday(&finish, NULL);
   1784  1.139     enami 	(void)getrusage(RUSAGE_SELF, &rusage_after);
   1785  1.137     lukem 	closedataconn(dout);		/* close now to affect timing stats */
   1786   1.62     lukem 	timersub(&finish, &start, &td);
   1787   1.62     lukem 	tdp = &td;
   1788   1.89     lukem  done:
   1789  1.148   thorpej 	if (dolog) {
   1790  1.138     lukem 		logxfer("get", byte_count, name, NULL, tdp, error);
   1791  1.139     enami 		if (tdp != NULL)
   1792  1.139     enami 			logrusage(&rusage_before, &rusage_after);
   1793  1.139     enami 	}
   1794   1.49     lukem 	closerv = (*closefunc)(fin);
   1795   1.49     lukem 	if (sendrv == 0) {
   1796  1.132     lukem 		FILE *errf;
   1797   1.49     lukem 		struct stat sb;
   1798   1.49     lukem 
   1799   1.71     lukem 		if (!isls && argv != NULL && closerv != 0) {
   1800   1.95     lukem 			reply(-226,
   1801   1.49     lukem 			    "Command returned an exit status of %d",
   1802   1.49     lukem 			    closerv);
   1803   1.49     lukem 			if (isconversion)
   1804  1.119     lukem 				syslog(LOG_WARNING,
   1805   1.71     lukem 				    "retrieve command: '%s' returned %d",
   1806   1.71     lukem 				    argv[0], closerv);
   1807   1.49     lukem 		}
   1808   1.71     lukem 		if (!isls && argv != NULL && stderrfd != -1 &&
   1809   1.49     lukem 		    (fstat(stderrfd, &sb) == 0) && sb.st_size > 0 &&
   1810  1.132     lukem 		    ((errf = fdopen(stderrfd, "r")) != NULL)) {
   1811   1.49     lukem 			char *cp, line[LINE_MAX];
   1812   1.49     lukem 
   1813   1.95     lukem 			reply(-226, "Command error messages:");
   1814  1.132     lukem 			rewind(errf);
   1815  1.132     lukem 			while (fgets(line, sizeof(line), errf) != NULL) {
   1816   1.49     lukem 				if ((cp = strchr(line, '\n')) != NULL)
   1817   1.49     lukem 					*cp = '\0';
   1818   1.95     lukem 				reply(0, "  %s", line);
   1819   1.49     lukem 			}
   1820   1.49     lukem 			(void) fflush(stdout);
   1821  1.132     lukem 			(void) fclose(errf);
   1822   1.49     lukem 				/* a reply(226,) must follow */
   1823   1.49     lukem 		}
   1824   1.49     lukem 		reply(226, "Transfer complete.");
   1825   1.49     lukem 	}
   1826   1.71     lukem  cleanupretrieve:
   1827   1.49     lukem 	if (stderrfd != -1)
   1828   1.49     lukem 		(void)close(stderrfd);
   1829   1.71     lukem 	if (isconversion)
   1830   1.71     lukem 		free(argv);
   1831    1.1       cgd }
   1832    1.1       cgd 
   1833    1.8   deraadt void
   1834  1.132     lukem store(const char *name, const char *fmode, int unique)
   1835    1.1       cgd {
   1836    1.1       cgd 	FILE *fout, *din;
   1837    1.1       cgd 	struct stat st;
   1838   1.88     lukem 	int (*closefunc)(FILE *);
   1839   1.62     lukem 	struct timeval start, finish, td, *tdp;
   1840  1.193     lukem 	const char *desc, *error;
   1841    1.1       cgd 
   1842   1.95     lukem 	din = NULL;
   1843  1.132     lukem 	desc = (*fmode == 'w') ? "put" : "append";
   1844  1.138     lukem 	error = NULL;
   1845    1.1       cgd 	if (unique && stat(name, &st) == 0 &&
   1846    1.8   deraadt 	    (name = gunique(name)) == NULL) {
   1847  1.118     lukem 		logxfer(desc, -1, name, NULL, NULL,
   1848  1.118     lukem 		    "cannot create unique file");
   1849   1.89     lukem 		goto cleanupstore;
   1850    1.8   deraadt 	}
   1851    1.1       cgd 
   1852    1.1       cgd 	if (restart_point)
   1853  1.132     lukem 		fmode = "r+";
   1854  1.132     lukem 	fout = fopen(name, fmode);
   1855    1.1       cgd 	closefunc = fclose;
   1856   1.62     lukem 	tdp = NULL;
   1857    1.1       cgd 	if (fout == NULL) {
   1858    1.1       cgd 		perror_reply(553, name);
   1859  1.118     lukem 		logxfer(desc, -1, name, NULL, NULL, strerror(errno));
   1860   1.89     lukem 		goto cleanupstore;
   1861    1.1       cgd 	}
   1862    1.8   deraadt 	byte_count = -1;
   1863    1.1       cgd 	if (restart_point) {
   1864    1.1       cgd 		if (type == TYPE_A) {
   1865   1.49     lukem 			off_t i;
   1866    1.8   deraadt 			int c;
   1867    1.1       cgd 
   1868   1.49     lukem 			for (i = 0; i < restart_point; i++) {
   1869    1.1       cgd 				if ((c=getc(fout)) == EOF) {
   1870  1.138     lukem 					error = strerror(errno);
   1871    1.1       cgd 					perror_reply(550, name);
   1872    1.1       cgd 					goto done;
   1873    1.1       cgd 				}
   1874    1.1       cgd 				if (c == '\n')
   1875    1.1       cgd 					i++;
   1876    1.8   deraadt 			}
   1877    1.1       cgd 			/*
   1878    1.1       cgd 			 * We must do this seek to "current" position
   1879    1.1       cgd 			 * because we are changing from reading to
   1880    1.1       cgd 			 * writing.
   1881    1.1       cgd 			 */
   1882   1.20     lukem 			if (fseek(fout, 0L, SEEK_CUR) < 0) {
   1883  1.138     lukem 				error = strerror(errno);
   1884    1.1       cgd 				perror_reply(550, name);
   1885    1.1       cgd 				goto done;
   1886    1.1       cgd 			}
   1887   1.31    kleink 		} else if (lseek(fileno(fout), restart_point, SEEK_SET) < 0) {
   1888  1.138     lukem 			error = strerror(errno);
   1889    1.1       cgd 			perror_reply(550, name);
   1890    1.1       cgd 			goto done;
   1891    1.1       cgd 		}
   1892    1.1       cgd 	}
   1893    1.1       cgd 	din = dataconn(name, (off_t)-1, "r");
   1894    1.1       cgd 	if (din == NULL)
   1895    1.1       cgd 		goto done;
   1896   1.62     lukem 	(void)gettimeofday(&start, NULL);
   1897    1.1       cgd 	if (receive_data(din, fout) == 0) {
   1898    1.1       cgd 		if (unique)
   1899    1.1       cgd 			reply(226, "Transfer complete (unique file name:%s).",
   1900    1.1       cgd 			    name);
   1901    1.1       cgd 		else
   1902    1.1       cgd 			reply(226, "Transfer complete.");
   1903    1.1       cgd 	}
   1904   1.62     lukem 	(void)gettimeofday(&finish, NULL);
   1905  1.137     lukem 	closedataconn(din);		/* close now to affect timing stats */
   1906   1.62     lukem 	timersub(&finish, &start, &td);
   1907   1.62     lukem 	tdp = &td;
   1908   1.89     lukem  done:
   1909  1.138     lukem 	logxfer(desc, byte_count, name, NULL, tdp, error);
   1910    1.1       cgd 	(*closefunc)(fout);
   1911   1.89     lukem  cleanupstore:
   1912  1.137     lukem 	;
   1913    1.1       cgd }
   1914    1.1       cgd 
   1915    1.8   deraadt static FILE *
   1916  1.132     lukem getdatasock(const char *fmode)
   1917    1.1       cgd {
   1918  1.101     lukem 	int		on, s, t, tries;
   1919  1.101     lukem 	in_port_t	port;
   1920    1.1       cgd 
   1921  1.101     lukem 	on = 1;
   1922    1.1       cgd 	if (data >= 0)
   1923  1.132     lukem 		return (fdopen(data, fmode));
   1924  1.101     lukem 	if (! dropprivs)
   1925  1.101     lukem 		(void) seteuid((uid_t)0);
   1926   1.67    itojun 	s = socket(ctrl_addr.su_family, SOCK_STREAM, 0);
   1927    1.1       cgd 	if (s < 0)
   1928    1.1       cgd 		goto bad;
   1929    1.1       cgd 	if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
   1930    1.8   deraadt 	    (char *) &on, sizeof(on)) < 0)
   1931    1.1       cgd 		goto bad;
   1932   1.66    briggs 	if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
   1933   1.66    briggs 	    (char *) &on, sizeof(on)) < 0)
   1934   1.66    briggs 		goto bad;
   1935  1.101     lukem 			/* anchor socket to avoid multi-homing problems */
   1936   1.67    itojun 	data_source = ctrl_addr;
   1937  1.101     lukem 			/*
   1938  1.101     lukem 			 * By default source port for PORT connctions is
   1939  1.101     lukem 			 * ctrlport-1 (see RFC959 section 5.2).
   1940  1.101     lukem 			 * However, if privs have been dropped and that
   1941  1.101     lukem 			 * would be < IPPORT_RESERVED, use a random port
   1942  1.101     lukem 			 * instead.
   1943  1.101     lukem 			 */
   1944  1.111     lukem 	if (dataport)
   1945  1.111     lukem 		port = dataport;
   1946  1.111     lukem 	else
   1947  1.111     lukem 		port = ntohs(ctrl_addr.su_port) - 1;
   1948  1.101     lukem 	if (dropprivs && port < IPPORT_RESERVED)
   1949  1.101     lukem 		port = 0;		/* use random port */
   1950  1.101     lukem 	data_source.su_port = htons(port);
   1951  1.101     lukem 
   1952    1.1       cgd 	for (tries = 1; ; tries++) {
   1953  1.109     lukem 		if (bind(s, (struct sockaddr *)&data_source.si_su,
   1954   1.67    itojun 		    data_source.su_len) >= 0)
   1955    1.1       cgd 			break;
   1956    1.1       cgd 		if (errno != EADDRINUSE || tries > 10)
   1957    1.1       cgd 			goto bad;
   1958    1.1       cgd 		sleep(tries);
   1959    1.1       cgd 	}
   1960  1.101     lukem 	if (! dropprivs)
   1961  1.101     lukem 		(void) seteuid((uid_t)pw->pw_uid);
   1962    1.1       cgd #ifdef IP_TOS
   1963   1.75    itojun 	if (!mapped && ctrl_addr.su_family == AF_INET) {
   1964   1.67    itojun 		on = IPTOS_THROUGHPUT;
   1965   1.67    itojun 		if (setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&on,
   1966   1.67    itojun 			       sizeof(int)) < 0)
   1967   1.67    itojun 			syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
   1968   1.67    itojun 	}
   1969    1.1       cgd #endif
   1970  1.132     lukem 	return (fdopen(s, fmode));
   1971   1.89     lukem  bad:
   1972  1.101     lukem 		/* Return the real value of errno (close may change it) */
   1973    1.8   deraadt 	t = errno;
   1974  1.101     lukem 	if (! dropprivs)
   1975  1.101     lukem 		(void) seteuid((uid_t)pw->pw_uid);
   1976  1.203       shm 	if (s >= 0)
   1977  1.203       shm 		(void) close(s);
   1978    1.8   deraadt 	errno = t;
   1979    1.1       cgd 	return (NULL);
   1980    1.1       cgd }
   1981    1.1       cgd 
   1982   1.93     lukem FILE *
   1983  1.132     lukem dataconn(const char *name, off_t size, const char *fmode)
   1984    1.1       cgd {
   1985    1.1       cgd 	char sizebuf[32];
   1986    1.1       cgd 	FILE *file;
   1987  1.150     lukem 	int retry, tos, keepalive, conerrno;
   1988    1.1       cgd 
   1989    1.1       cgd 	file_size = size;
   1990    1.1       cgd 	byte_count = 0;
   1991    1.1       cgd 	if (size != (off_t) -1)
   1992  1.109     lukem 		(void)snprintf(sizebuf, sizeof(sizebuf), " (" LLF " byte%s)",
   1993  1.109     lukem 		    (LLT)size, PLURAL(size));
   1994    1.1       cgd 	else
   1995   1.29       mrg 		sizebuf[0] = '\0';
   1996    1.1       cgd 	if (pdata >= 0) {
   1997  1.109     lukem 		struct sockinet from;
   1998  1.176       mrg 		int s;
   1999  1.176       mrg 		socklen_t fromlen = sizeof(from.su_len);
   2000    1.1       cgd 
   2001   1.42     lukem 		(void) alarm(curclass.timeout);
   2002  1.109     lukem 		s = accept(pdata, (struct sockaddr *)&from.si_su, &fromlen);
   2003   1.42     lukem 		(void) alarm(0);
   2004    1.1       cgd 		if (s < 0) {
   2005    1.1       cgd 			reply(425, "Can't open data connection.");
   2006    1.1       cgd 			(void) close(pdata);
   2007    1.1       cgd 			pdata = -1;
   2008    1.8   deraadt 			return (NULL);
   2009    1.1       cgd 		}
   2010    1.1       cgd 		(void) close(pdata);
   2011    1.1       cgd 		pdata = s;
   2012   1.67    itojun 		switch (from.su_family) {
   2013   1.67    itojun 		case AF_INET:
   2014    1.1       cgd #ifdef IP_TOS
   2015   1.75    itojun 			if (!mapped) {
   2016   1.75    itojun 				tos = IPTOS_THROUGHPUT;
   2017   1.75    itojun 				(void) setsockopt(s, IPPROTO_IP, IP_TOS,
   2018   1.75    itojun 				    (char *)&tos, sizeof(int));
   2019   1.75    itojun 			}
   2020   1.67    itojun 			break;
   2021   1.66    briggs #endif
   2022   1.67    itojun 		}
   2023   1.66    briggs 		/* Set keepalives on the socket to detect dropped conns. */
   2024   1.66    briggs #ifdef SO_KEEPALIVE
   2025   1.66    briggs 		keepalive = 1;
   2026   1.66    briggs 		(void) setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
   2027   1.66    briggs 		    (char *)&keepalive, sizeof(int));
   2028    1.1       cgd #endif
   2029    1.8   deraadt 		reply(150, "Opening %s mode data connection for '%s'%s.",
   2030    1.1       cgd 		     type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
   2031  1.132     lukem 		return (fdopen(pdata, fmode));
   2032    1.1       cgd 	}
   2033    1.1       cgd 	if (data >= 0) {
   2034    1.8   deraadt 		reply(125, "Using existing data connection for '%s'%s.",
   2035    1.1       cgd 		    name, sizebuf);
   2036    1.1       cgd 		usedefault = 1;
   2037  1.132     lukem 		return (fdopen(data, fmode));
   2038    1.1       cgd 	}
   2039    1.1       cgd 	if (usedefault)
   2040    1.1       cgd 		data_dest = his_addr;
   2041    1.1       cgd 	usedefault = 1;
   2042  1.150     lukem 	retry = conerrno = 0;
   2043  1.150     lukem 	do {
   2044  1.150     lukem 		file = getdatasock(fmode);
   2045  1.150     lukem 		if (file == NULL) {
   2046  1.150     lukem 			char hbuf[NI_MAXHOST];
   2047  1.150     lukem 			char pbuf[NI_MAXSERV];
   2048  1.150     lukem 
   2049  1.150     lukem 			if (getnameinfo((struct sockaddr *)&data_source.si_su,
   2050  1.150     lukem 			    data_source.su_len, hbuf, sizeof(hbuf), pbuf,
   2051  1.150     lukem 			    sizeof(pbuf), NI_NUMERICHOST | NI_NUMERICSERV))
   2052  1.150     lukem 				strlcpy(hbuf, "?", sizeof(hbuf));
   2053  1.150     lukem 			reply(425, "Can't create data socket (%s,%s): %s.",
   2054  1.150     lukem 			      hbuf, pbuf, strerror(errno));
   2055  1.150     lukem 			return (NULL);
   2056  1.150     lukem 		}
   2057  1.150     lukem 		data = fileno(file);
   2058  1.150     lukem 		conerrno = 0;
   2059  1.150     lukem 		if (connect(data, (struct sockaddr *)&data_dest.si_su,
   2060  1.150     lukem 		    data_dest.su_len) == 0)
   2061  1.150     lukem 			break;
   2062  1.150     lukem 		conerrno = errno;
   2063  1.150     lukem 		(void) fclose(file);
   2064  1.174     peter 		file = NULL;
   2065  1.150     lukem 		data = -1;
   2066  1.150     lukem 		if (conerrno == EADDRINUSE) {
   2067    1.1       cgd 			sleep((unsigned) swaitint);
   2068    1.1       cgd 			retry += swaitint;
   2069  1.150     lukem 		} else {
   2070  1.150     lukem 			break;
   2071    1.1       cgd 		}
   2072  1.150     lukem 	} while (retry <= swaitmax);
   2073  1.150     lukem 	if (conerrno != 0) {
   2074    1.1       cgd 		perror_reply(425, "Can't build data connection");
   2075    1.1       cgd 		return (NULL);
   2076    1.1       cgd 	}
   2077    1.8   deraadt 	reply(150, "Opening %s mode data connection for '%s'%s.",
   2078    1.1       cgd 	     type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
   2079    1.1       cgd 	return (file);
   2080    1.1       cgd }
   2081    1.1       cgd 
   2082   1.95     lukem void
   2083   1.95     lukem closedataconn(FILE *fd)
   2084   1.95     lukem {
   2085   1.95     lukem 
   2086  1.136     lukem 	if (fd == NULL)
   2087  1.136     lukem 		return;
   2088  1.136     lukem 	(void)fclose(fd);
   2089   1.95     lukem 	data = -1;
   2090   1.95     lukem 	if (pdata >= 0)
   2091   1.95     lukem 		(void)close(pdata);
   2092   1.95     lukem 	pdata = -1;
   2093   1.95     lukem }
   2094   1.95     lukem 
   2095  1.139     enami int
   2096  1.139     enami write_data(int fd, char *buf, size_t size, off_t *bufrem,
   2097  1.139     enami     struct timeval *then, int isdata)
   2098  1.139     enami {
   2099  1.139     enami 	struct timeval now, td;
   2100  1.139     enami 	ssize_t c;
   2101  1.139     enami 
   2102  1.139     enami 	while (size > 0) {
   2103  1.139     enami 		c = size;
   2104  1.139     enami 		if (curclass.writesize) {
   2105  1.139     enami 			if (curclass.writesize < c)
   2106  1.139     enami 				c = curclass.writesize;
   2107  1.139     enami 		}
   2108  1.139     enami 		if (curclass.rateget) {
   2109  1.139     enami 			if (*bufrem < c)
   2110  1.139     enami 				c = *bufrem;
   2111  1.139     enami 		}
   2112  1.139     enami 		(void) alarm(curclass.timeout);
   2113  1.139     enami 		c = write(fd, buf, c);
   2114  1.139     enami 		if (c <= 0)
   2115  1.139     enami 			return (1);
   2116  1.139     enami 		buf += c;
   2117  1.139     enami 		size -= c;
   2118  1.139     enami 		byte_count += c;
   2119  1.139     enami 		if (isdata) {
   2120  1.139     enami 			total_data_out += c;
   2121  1.139     enami 			total_data += c;
   2122  1.139     enami 		}
   2123  1.139     enami 		total_bytes_out += c;
   2124  1.139     enami 		total_bytes += c;
   2125  1.139     enami 		if (curclass.rateget) {
   2126  1.139     enami 			*bufrem -= c;
   2127  1.139     enami 			if (*bufrem == 0) {
   2128  1.139     enami 				(void)gettimeofday(&now, NULL);
   2129  1.139     enami 				timersub(&now, then, &td);
   2130  1.139     enami 				if (td.tv_sec == 0) {
   2131  1.139     enami 					usleep(1000000 - td.tv_usec);
   2132  1.139     enami 					(void)gettimeofday(then, NULL);
   2133  1.139     enami 				} else
   2134  1.139     enami 					*then = now;
   2135  1.139     enami 				*bufrem = curclass.rateget;
   2136  1.139     enami 			}
   2137  1.139     enami 		}
   2138  1.139     enami 	}
   2139  1.139     enami 	return (0);
   2140  1.139     enami }
   2141  1.139     enami 
   2142  1.139     enami static enum send_status
   2143  1.139     enami send_data_with_read(int filefd, int netfd, const struct stat *st, int isdata)
   2144  1.139     enami {
   2145  1.139     enami 	struct timeval then;
   2146  1.139     enami 	off_t bufrem;
   2147  1.193     lukem 	ssize_t readsize;
   2148  1.139     enami 	char *buf;
   2149  1.139     enami 	int c, error;
   2150  1.139     enami 
   2151  1.193     lukem 	if (curclass.readsize > 0)
   2152  1.139     enami 		readsize = curclass.readsize;
   2153  1.139     enami 	else
   2154  1.193     lukem 		readsize = st->st_blksize;
   2155  1.139     enami 	if ((buf = malloc(readsize)) == NULL) {
   2156  1.139     enami 		perror_reply(451, "Local resource failure: malloc");
   2157  1.139     enami 		return (SS_NO_TRANSFER);
   2158  1.139     enami 	}
   2159  1.139     enami 
   2160  1.139     enami 	if (curclass.rateget) {
   2161  1.139     enami 		bufrem = curclass.rateget;
   2162  1.139     enami 		(void)gettimeofday(&then, NULL);
   2163  1.193     lukem 	} else
   2164  1.193     lukem 		bufrem = readsize;
   2165  1.200  christos 	for (;;) {
   2166  1.139     enami 		(void) alarm(curclass.timeout);
   2167  1.139     enami 		c = read(filefd, buf, readsize);
   2168  1.139     enami 		if (c == 0)
   2169  1.139     enami 			error = SS_SUCCESS;
   2170  1.139     enami 		else if (c < 0)
   2171  1.139     enami 			error = SS_FILE_ERROR;
   2172  1.139     enami 		else if (write_data(netfd, buf, c, &bufrem, &then, isdata))
   2173  1.139     enami 			error = SS_DATA_ERROR;
   2174  1.158     lukem 		else if (urgflag && handleoobcmd())
   2175  1.158     lukem 			error = SS_ABORTED;
   2176  1.139     enami 		else
   2177  1.139     enami 			continue;
   2178  1.139     enami 
   2179  1.139     enami 		free(buf);
   2180  1.139     enami 		return (error);
   2181  1.139     enami 	}
   2182  1.139     enami }
   2183  1.139     enami 
   2184  1.139     enami static enum send_status
   2185  1.139     enami send_data_with_mmap(int filefd, int netfd, const struct stat *st, int isdata)
   2186  1.139     enami {
   2187  1.139     enami 	struct timeval then;
   2188  1.139     enami 	off_t bufrem, filesize, off, origoff;
   2189  1.193     lukem 	ssize_t mapsize, winsize;
   2190  1.139     enami 	int error, sendbufsize, sendlowat;
   2191  1.139     enami 	void *win;
   2192  1.139     enami 
   2193  1.193     lukem 	bufrem = 0;
   2194  1.139     enami 	if (curclass.sendbufsize) {
   2195  1.139     enami 		sendbufsize = curclass.sendbufsize;
   2196  1.139     enami 		if (setsockopt(netfd, SOL_SOCKET, SO_SNDBUF,
   2197  1.139     enami 		    &sendbufsize, sizeof(int)) == -1)
   2198  1.139     enami 			syslog(LOG_WARNING, "setsockopt(SO_SNDBUF, %d): %m",
   2199  1.139     enami 			    sendbufsize);
   2200  1.139     enami 	}
   2201  1.139     enami 
   2202  1.139     enami 	if (curclass.sendlowat) {
   2203  1.139     enami 		sendlowat = curclass.sendlowat;
   2204  1.139     enami 		if (setsockopt(netfd, SOL_SOCKET, SO_SNDLOWAT,
   2205  1.139     enami 		    &sendlowat, sizeof(int)) == -1)
   2206  1.139     enami 			syslog(LOG_WARNING, "setsockopt(SO_SNDLOWAT, %d): %m",
   2207  1.139     enami 			    sendlowat);
   2208  1.139     enami 	}
   2209  1.139     enami 
   2210  1.139     enami 	winsize = curclass.mmapsize;
   2211  1.139     enami 	filesize = st->st_size;
   2212  1.171  christos 	if (ftpd_debug)
   2213  1.193     lukem 		syslog(LOG_INFO, "mmapsize = " LLF ", writesize = " LLF,
   2214  1.193     lukem 		    (LLT)winsize, (LLT)curclass.writesize);
   2215  1.193     lukem 	if (winsize <= 0)
   2216  1.139     enami 		goto try_read;
   2217  1.139     enami 
   2218  1.139     enami 	off = lseek(filefd, (off_t)0, SEEK_CUR);
   2219  1.139     enami 	if (off == -1)
   2220  1.139     enami 		goto try_read;
   2221  1.139     enami 
   2222  1.139     enami 	origoff = off;
   2223  1.139     enami 	if (curclass.rateget) {
   2224  1.139     enami 		bufrem = curclass.rateget;
   2225  1.139     enami 		(void)gettimeofday(&then, NULL);
   2226  1.193     lukem 	} else
   2227  1.193     lukem 		bufrem = winsize;
   2228  1.139     enami 	while (1) {
   2229  1.139     enami 		mapsize = MIN(filesize - off, winsize);
   2230  1.139     enami 		if (mapsize == 0)
   2231  1.139     enami 			break;
   2232  1.139     enami 		win = mmap(NULL, mapsize, PROT_READ,
   2233  1.139     enami 		    MAP_FILE|MAP_SHARED, filefd, off);
   2234  1.139     enami 		if (win == MAP_FAILED) {
   2235  1.139     enami 			if (off == origoff)
   2236  1.139     enami 				goto try_read;
   2237  1.139     enami 			return (SS_FILE_ERROR);
   2238  1.139     enami 		}
   2239  1.139     enami 		(void) madvise(win, mapsize, MADV_SEQUENTIAL);
   2240  1.139     enami 		error = write_data(netfd, win, mapsize, &bufrem, &then,
   2241  1.139     enami 		    isdata);
   2242  1.139     enami 		(void) madvise(win, mapsize, MADV_DONTNEED);
   2243  1.139     enami 		munmap(win, mapsize);
   2244  1.158     lukem 		if (urgflag && handleoobcmd())
   2245  1.158     lukem 			return (SS_ABORTED);
   2246  1.139     enami 		if (error)
   2247  1.139     enami 			return (SS_DATA_ERROR);
   2248  1.139     enami 		off += mapsize;
   2249  1.139     enami 	}
   2250  1.139     enami 	return (SS_SUCCESS);
   2251  1.139     enami 
   2252  1.139     enami  try_read:
   2253  1.139     enami 	return (send_data_with_read(filefd, netfd, st, isdata));
   2254  1.139     enami }
   2255  1.139     enami 
   2256    1.1       cgd /*
   2257  1.183     lukem  * Transfer the contents of "instr" to "outstr" peer using the appropriate
   2258  1.139     enami  * encapsulation of the data subject to Mode, Structure, and Type.
   2259    1.1       cgd  *
   2260    1.1       cgd  * NB: Form isn't handled.
   2261    1.1       cgd  */
   2262   1.49     lukem static int
   2263  1.139     enami send_data(FILE *instr, FILE *outstr, const struct stat *st, int isdata)
   2264    1.1       cgd {
   2265   1.73     lukem 	int	 c, filefd, netfd, rval;
   2266    1.1       cgd 
   2267  1.158     lukem 	urgflag = 0;
   2268   1.62     lukem 	transflag = 1;
   2269   1.62     lukem 	rval = -1;
   2270   1.24     lukem 
   2271    1.1       cgd 	switch (type) {
   2272    1.1       cgd 
   2273    1.1       cgd 	case TYPE_A:
   2274  1.109     lukem  /* XXXLUKEM: rate limit ascii send (get) */
   2275   1.62     lukem 		(void) alarm(curclass.timeout);
   2276    1.1       cgd 		while ((c = getc(instr)) != EOF) {
   2277  1.158     lukem 			if (urgflag && handleoobcmd())
   2278  1.158     lukem 				goto cleanup_send_data;
   2279    1.1       cgd 			byte_count++;
   2280   1.63     lukem 			if (c == '\n') {
   2281   1.63     lukem 				if (ferror(outstr))
   2282   1.63     lukem 					goto data_err;
   2283   1.63     lukem 				(void) putc('\r', outstr);
   2284   1.63     lukem 				if (isdata) {
   2285   1.63     lukem 					total_data_out++;
   2286   1.63     lukem 					total_data++;
   2287   1.63     lukem 				}
   2288   1.63     lukem 				total_bytes_out++;
   2289   1.63     lukem 				total_bytes++;
   2290   1.63     lukem 			}
   2291   1.63     lukem 			(void) putc(c, outstr);
   2292   1.62     lukem 			if (isdata) {
   2293   1.62     lukem 				total_data_out++;
   2294   1.62     lukem 				total_data++;
   2295   1.62     lukem 			}
   2296   1.62     lukem 			total_bytes_out++;
   2297   1.62     lukem 			total_bytes++;
   2298   1.62     lukem 			if ((byte_count % 4096) == 0)
   2299   1.62     lukem 				(void) alarm(curclass.timeout);
   2300    1.1       cgd 		}
   2301   1.62     lukem 		(void) alarm(0);
   2302    1.1       cgd 		fflush(outstr);
   2303    1.1       cgd 		if (ferror(instr))
   2304    1.1       cgd 			goto file_err;
   2305    1.1       cgd 		if (ferror(outstr))
   2306    1.1       cgd 			goto data_err;
   2307   1.62     lukem 		rval = 0;
   2308   1.62     lukem 		goto cleanup_send_data;
   2309    1.1       cgd 
   2310    1.1       cgd 	case TYPE_I:
   2311    1.1       cgd 	case TYPE_L:
   2312   1.63     lukem 		filefd = fileno(instr);
   2313    1.1       cgd 		netfd = fileno(outstr);
   2314  1.139     enami 		switch (send_data_with_mmap(filefd, netfd, st, isdata)) {
   2315  1.139     enami 
   2316  1.139     enami 		case SS_SUCCESS:
   2317  1.139     enami 			break;
   2318  1.139     enami 
   2319  1.158     lukem 		case SS_ABORTED:
   2320  1.139     enami 		case SS_NO_TRANSFER:
   2321  1.139     enami 			goto cleanup_send_data;
   2322  1.139     enami 
   2323  1.139     enami 		case SS_FILE_ERROR:
   2324  1.139     enami 			goto file_err;
   2325   1.73     lukem 
   2326  1.139     enami 		case SS_DATA_ERROR:
   2327  1.139     enami 			goto data_err;
   2328    1.1       cgd 		}
   2329   1.62     lukem 		rval = 0;
   2330   1.62     lukem 		goto cleanup_send_data;
   2331   1.62     lukem 
   2332    1.1       cgd 	default:
   2333    1.1       cgd 		reply(550, "Unimplemented TYPE %d in send_data", type);
   2334   1.62     lukem 		goto cleanup_send_data;
   2335    1.1       cgd 	}
   2336    1.1       cgd 
   2337   1.89     lukem  data_err:
   2338   1.62     lukem 	(void) alarm(0);
   2339    1.1       cgd 	perror_reply(426, "Data connection");
   2340   1.62     lukem 	goto cleanup_send_data;
   2341    1.1       cgd 
   2342   1.89     lukem  file_err:
   2343   1.62     lukem 	(void) alarm(0);
   2344   1.62     lukem 	perror_reply(551, "Error on input file");
   2345  1.158     lukem 	goto cleanup_send_data;
   2346   1.73     lukem 
   2347   1.89     lukem  cleanup_send_data:
   2348   1.62     lukem 	(void) alarm(0);
   2349    1.1       cgd 	transflag = 0;
   2350  1.158     lukem 	urgflag = 0;
   2351   1.62     lukem 	if (isdata) {
   2352   1.62     lukem 		total_files_out++;
   2353   1.62     lukem 		total_files++;
   2354   1.62     lukem 	}
   2355   1.62     lukem 	total_xfers_out++;
   2356   1.62     lukem 	total_xfers++;
   2357   1.62     lukem 	return (rval);
   2358    1.1       cgd }
   2359    1.1       cgd 
   2360    1.1       cgd /*
   2361    1.8   deraadt  * Transfer data from peer to "outstr" using the appropriate encapulation of
   2362    1.8   deraadt  * the data subject to Mode, Structure, and Type.
   2363    1.1       cgd  *
   2364    1.1       cgd  * N.B.: Form isn't handled.
   2365    1.1       cgd  */
   2366    1.8   deraadt static int
   2367   1.88     lukem receive_data(FILE *instr, FILE *outstr)
   2368    1.1       cgd {
   2369  1.178  christos 	int	c, netfd, filefd, rval;
   2370  1.178  christos 	int	volatile bare_lfs;
   2371  1.111     lukem 	off_t	byteswritten;
   2372  1.168  ginsbach 	char	*buf;
   2373  1.193     lukem 	ssize_t	readsize;
   2374  1.158     lukem 	struct sigaction sa, sa_saved;
   2375  1.168  ginsbach 	struct stat st;
   2376    1.1       cgd 
   2377  1.158     lukem 	memset(&sa, 0, sizeof(sa));
   2378  1.158     lukem 	sigfillset(&sa.sa_mask);
   2379  1.158     lukem 	sa.sa_flags = SA_RESTART;
   2380  1.158     lukem 	sa.sa_handler = lostconn;
   2381  1.158     lukem 	(void) sigaction(SIGALRM, &sa, &sa_saved);
   2382  1.158     lukem 
   2383   1.24     lukem 	bare_lfs = 0;
   2384  1.158     lukem 	urgflag = 0;
   2385   1.62     lukem 	transflag = 1;
   2386   1.62     lukem 	rval = -1;
   2387  1.111     lukem 	byteswritten = 0;
   2388  1.168  ginsbach 	buf = NULL;
   2389   1.24     lukem 
   2390  1.111     lukem #define FILESIZECHECK(x) \
   2391  1.111     lukem 			do { \
   2392  1.111     lukem 				if (curclass.maxfilesize != -1 && \
   2393  1.111     lukem 				    (x) > curclass.maxfilesize) { \
   2394  1.111     lukem 					errno = EFBIG; \
   2395  1.111     lukem 					goto file_err; \
   2396  1.111     lukem 				} \
   2397  1.111     lukem 			} while (0)
   2398  1.111     lukem 
   2399    1.1       cgd 	switch (type) {
   2400    1.1       cgd 
   2401    1.1       cgd 	case TYPE_I:
   2402    1.1       cgd 	case TYPE_L:
   2403   1.62     lukem 		netfd = fileno(instr);
   2404   1.62     lukem 		filefd = fileno(outstr);
   2405   1.62     lukem 		(void) alarm(curclass.timeout);
   2406  1.168  ginsbach 		if (curclass.readsize)
   2407  1.168  ginsbach 			readsize = curclass.readsize;
   2408  1.200  christos 		else if (fstat(filefd, &st) != -1)
   2409  1.193     lukem 			readsize = (ssize_t)st.st_blksize;
   2410  1.168  ginsbach 		else
   2411  1.168  ginsbach 			readsize = BUFSIZ;
   2412  1.168  ginsbach 		if ((buf = malloc(readsize)) == NULL) {
   2413  1.168  ginsbach 			perror_reply(451, "Local resource failure: malloc");
   2414  1.168  ginsbach 			goto cleanup_recv_data;
   2415  1.168  ginsbach 		}
   2416   1.73     lukem 		if (curclass.rateput) {
   2417   1.73     lukem 			while (1) {
   2418   1.73     lukem 				int d;
   2419   1.73     lukem 				struct timeval then, now, td;
   2420   1.73     lukem 				off_t bufrem;
   2421   1.73     lukem 
   2422   1.73     lukem 				(void)gettimeofday(&then, NULL);
   2423   1.73     lukem 				errno = c = d = 0;
   2424   1.73     lukem 				for (bufrem = curclass.rateput; bufrem > 0; ) {
   2425   1.73     lukem 					if ((c = read(netfd, buf,
   2426  1.168  ginsbach 					    MIN(readsize, bufrem))) <= 0)
   2427   1.73     lukem 						goto recvdone;
   2428  1.158     lukem 					if (urgflag && handleoobcmd())
   2429  1.158     lukem 						goto cleanup_recv_data;
   2430  1.111     lukem 					FILESIZECHECK(byte_count + c);
   2431   1.73     lukem 					if ((d = write(filefd, buf, c)) != c)
   2432  1.111     lukem 						goto file_err;
   2433   1.73     lukem 					(void) alarm(curclass.timeout);
   2434   1.73     lukem 					bufrem -= c;
   2435   1.73     lukem 					byte_count += c;
   2436   1.73     lukem 					total_data_in += c;
   2437   1.73     lukem 					total_data += c;
   2438   1.73     lukem 					total_bytes_in += c;
   2439   1.73     lukem 					total_bytes += c;
   2440   1.73     lukem 				}
   2441   1.73     lukem 				(void)gettimeofday(&now, NULL);
   2442   1.73     lukem 				timersub(&now, &then, &td);
   2443   1.96     lukem 				if (td.tv_sec == 0)
   2444   1.96     lukem 					usleep(1000000 - td.tv_usec);
   2445   1.73     lukem 			}
   2446   1.73     lukem 		} else {
   2447  1.168  ginsbach 			while ((c = read(netfd, buf, readsize)) > 0) {
   2448  1.158     lukem 				if (urgflag && handleoobcmd())
   2449  1.158     lukem 					goto cleanup_recv_data;
   2450  1.111     lukem 				FILESIZECHECK(byte_count + c);
   2451   1.73     lukem 				if (write(filefd, buf, c) != c)
   2452   1.73     lukem 					goto file_err;
   2453   1.73     lukem 				(void) alarm(curclass.timeout);
   2454   1.73     lukem 				byte_count += c;
   2455   1.73     lukem 				total_data_in += c;
   2456   1.73     lukem 				total_data += c;
   2457   1.73     lukem 				total_bytes_in += c;
   2458   1.73     lukem 				total_bytes += c;
   2459   1.73     lukem 			}
   2460    1.1       cgd 		}
   2461   1.73     lukem  recvdone:
   2462   1.73     lukem 		if (c < 0)
   2463    1.1       cgd 			goto data_err;
   2464   1.62     lukem 		rval = 0;
   2465   1.62     lukem 		goto cleanup_recv_data;
   2466    1.1       cgd 
   2467    1.1       cgd 	case TYPE_E:
   2468    1.1       cgd 		reply(553, "TYPE E not implemented.");
   2469   1.62     lukem 		goto cleanup_recv_data;
   2470    1.1       cgd 
   2471    1.1       cgd 	case TYPE_A:
   2472   1.62     lukem 		(void) alarm(curclass.timeout);
   2473  1.109     lukem  /* XXXLUKEM: rate limit ascii receive (put) */
   2474    1.1       cgd 		while ((c = getc(instr)) != EOF) {
   2475  1.158     lukem 			if (urgflag && handleoobcmd())
   2476  1.158     lukem 				goto cleanup_recv_data;
   2477    1.1       cgd 			byte_count++;
   2478   1.62     lukem 			total_data_in++;
   2479   1.62     lukem 			total_data++;
   2480   1.62     lukem 			total_bytes_in++;
   2481   1.62     lukem 			total_bytes++;
   2482   1.62     lukem 			if ((byte_count % 4096) == 0)
   2483   1.62     lukem 				(void) alarm(curclass.timeout);
   2484    1.1       cgd 			if (c == '\n')
   2485    1.1       cgd 				bare_lfs++;
   2486    1.1       cgd 			while (c == '\r') {
   2487    1.1       cgd 				if (ferror(outstr))
   2488    1.1       cgd 					goto data_err;
   2489    1.1       cgd 				if ((c = getc(instr)) != '\n') {
   2490   1.62     lukem 					byte_count++;
   2491   1.62     lukem 					total_data_in++;
   2492   1.62     lukem 					total_data++;
   2493   1.62     lukem 					total_bytes_in++;
   2494   1.62     lukem 					total_bytes++;
   2495   1.62     lukem 					if ((byte_count % 4096) == 0)
   2496   1.62     lukem 						(void) alarm(curclass.timeout);
   2497  1.111     lukem 					byteswritten++;
   2498  1.111     lukem 					FILESIZECHECK(byteswritten);
   2499    1.1       cgd 					(void) putc ('\r', outstr);
   2500    1.1       cgd 					if (c == '\0' || c == EOF)
   2501    1.1       cgd 						goto contin2;
   2502    1.1       cgd 				}
   2503    1.1       cgd 			}
   2504  1.111     lukem 			byteswritten++;
   2505  1.111     lukem 			FILESIZECHECK(byteswritten);
   2506    1.1       cgd 			(void) putc(c, outstr);
   2507  1.111     lukem  contin2:	;
   2508    1.1       cgd 		}
   2509   1.62     lukem 		(void) alarm(0);
   2510    1.1       cgd 		fflush(outstr);
   2511    1.1       cgd 		if (ferror(instr))
   2512    1.1       cgd 			goto data_err;
   2513    1.1       cgd 		if (ferror(outstr))
   2514    1.1       cgd 			goto file_err;
   2515    1.1       cgd 		if (bare_lfs) {
   2516   1.95     lukem 			reply(-226,
   2517   1.62     lukem 			    "WARNING! %d bare linefeeds received in ASCII mode",
   2518    1.8   deraadt 			    bare_lfs);
   2519   1.95     lukem 			reply(0, "File may not have transferred correctly.");
   2520    1.1       cgd 		}
   2521   1.62     lukem 		rval = 0;
   2522   1.62     lukem 		goto cleanup_recv_data;
   2523   1.62     lukem 
   2524    1.1       cgd 	default:
   2525    1.1       cgd 		reply(550, "Unimplemented TYPE %d in receive_data", type);
   2526   1.62     lukem 		goto cleanup_recv_data;
   2527    1.1       cgd 	}
   2528  1.120       cgd #undef FILESIZECHECK
   2529    1.1       cgd 
   2530   1.89     lukem  data_err:
   2531   1.62     lukem 	(void) alarm(0);
   2532    1.1       cgd 	perror_reply(426, "Data Connection");
   2533   1.62     lukem 	goto cleanup_recv_data;
   2534    1.1       cgd 
   2535   1.89     lukem  file_err:
   2536   1.62     lukem 	(void) alarm(0);
   2537   1.62     lukem 	perror_reply(452, "Error writing file");
   2538   1.62     lukem 	goto cleanup_recv_data;
   2539   1.62     lukem 
   2540   1.89     lukem  cleanup_recv_data:
   2541   1.62     lukem 	(void) alarm(0);
   2542  1.158     lukem 	(void) sigaction(SIGALRM, &sa_saved, NULL);
   2543  1.168  ginsbach 	if (buf)
   2544  1.168  ginsbach 		free(buf);
   2545    1.1       cgd 	transflag = 0;
   2546  1.158     lukem 	urgflag = 0;
   2547   1.62     lukem 	total_files_in++;
   2548   1.62     lukem 	total_files++;
   2549   1.62     lukem 	total_xfers_in++;
   2550   1.62     lukem 	total_xfers++;
   2551   1.62     lukem 	return (rval);
   2552    1.1       cgd }
   2553    1.1       cgd 
   2554    1.8   deraadt void
   2555   1.88     lukem statcmd(void)
   2556    1.1       cgd {
   2557  1.109     lukem 	struct sockinet *su = NULL;
   2558  1.112    itojun 	static char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
   2559  1.185     lukem 	unsigned char *a, *p;
   2560   1.89     lukem 	int ispassive, af;
   2561   1.93     lukem 	off_t otbi, otbo, otb;
   2562    1.1       cgd 
   2563  1.197    plunky 	a = p = NULL;
   2564   1.67    itojun 
   2565   1.95     lukem 	reply(-211, "%s FTP server status:", hostname);
   2566  1.101     lukem 	reply(0, "Version: %s", EMPTYSTR(version) ? "<suppressed>" : version);
   2567  1.112    itojun 	hbuf[0] = '\0';
   2568  1.109     lukem 	if (!getnameinfo((struct sockaddr *)&his_addr.si_su, his_addr.su_len,
   2569  1.112    itojun 			hbuf, sizeof(hbuf), NULL, 0, NI_NUMERICHOST)
   2570  1.112    itojun 	    && strcmp(remotehost, hbuf) != 0)
   2571  1.112    itojun 		reply(0, "Connected to %s (%s)", remotehost, hbuf);
   2572  1.104  christos 	else
   2573   1.95     lukem 		reply(0, "Connected to %s", remotehost);
   2574  1.104  christos 
   2575    1.1       cgd 	if (logged_in) {
   2576   1.73     lukem 		if (curclass.type == CLASS_GUEST)
   2577   1.95     lukem 			reply(0, "Logged in anonymously");
   2578    1.1       cgd 		else
   2579   1.95     lukem 			reply(0, "Logged in as %s%s", pw->pw_name,
   2580   1.73     lukem 			    curclass.type == CLASS_CHROOT ? " (chroot)" : "");
   2581    1.1       cgd 	} else if (askpasswd)
   2582   1.95     lukem 		reply(0, "Waiting for password");
   2583    1.1       cgd 	else
   2584   1.95     lukem 		reply(0, "Waiting for user name");
   2585   1.95     lukem 	cprintf(stdout, "    TYPE: %s", typenames[type]);
   2586   1.93     lukem 	if (type == TYPE_A || type == TYPE_E)
   2587   1.95     lukem 		cprintf(stdout, ", FORM: %s", formnames[form]);
   2588   1.62     lukem 	if (type == TYPE_L) {
   2589    1.1       cgd #if NBBY == 8
   2590   1.95     lukem 		cprintf(stdout, " %d", NBBY);
   2591    1.1       cgd #else
   2592   1.62     lukem 			/* XXX: `bytesize' needs to be defined in this case */
   2593   1.95     lukem 		cprintf(stdout, " %d", bytesize);
   2594    1.1       cgd #endif
   2595   1.62     lukem 	}
   2596   1.95     lukem 	cprintf(stdout, "; STRUcture: %s; transfer MODE: %s\r\n",
   2597    1.1       cgd 	    strunames[stru], modenames[mode]);
   2598   1.67    itojun 	ispassive = 0;
   2599   1.67    itojun 	if (data != -1) {
   2600  1.147     lukem 		reply(0, "Data connection open");
   2601   1.67    itojun 		su = NULL;
   2602   1.67    itojun 	} else if (pdata != -1) {
   2603   1.95     lukem 		reply(0, "in Passive mode");
   2604  1.118     lukem 		if (curclass.advertise.su_len != 0)
   2605  1.118     lukem 			su = &curclass.advertise;
   2606  1.118     lukem 		else
   2607  1.118     lukem 			su = &pasv_addr;
   2608   1.67    itojun 		ispassive = 1;
   2609    1.1       cgd 		goto printaddr;
   2610    1.1       cgd 	} else if (usedefault == 0) {
   2611  1.173     peter 		su = (struct sockinet *)&data_dest;
   2612  1.173     peter 
   2613   1.67    itojun 		if (epsvall) {
   2614   1.95     lukem 			reply(0, "EPSV only mode (EPSV ALL)");
   2615   1.67    itojun 			goto epsvonly;
   2616   1.67    itojun 		}
   2617   1.89     lukem  printaddr:
   2618   1.93     lukem 							/* PASV/PORT */
   2619   1.67    itojun 		if (su->su_family == AF_INET) {
   2620  1.185     lukem 			a = (unsigned char *) &su->su_addr;
   2621  1.185     lukem 			p = (unsigned char *) &su->su_port;
   2622    1.1       cgd #define UC(b) (((int) b) & 0xff)
   2623   1.95     lukem 			reply(0, "%s (%d,%d,%d,%d,%d,%d)",
   2624   1.93     lukem 				ispassive ? "PASV" : "PORT" ,
   2625   1.67    itojun 				UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
   2626   1.67    itojun 				UC(p[0]), UC(p[1]));
   2627   1.67    itojun 		}
   2628   1.67    itojun 
   2629   1.93     lukem 							/* LPSV/LPRT */
   2630   1.67    itojun 	    {
   2631  1.132     lukem 		int alen, i;
   2632   1.67    itojun 
   2633   1.67    itojun 		alen = 0;
   2634   1.67    itojun 		switch (su->su_family) {
   2635   1.67    itojun 		case AF_INET:
   2636  1.185     lukem 			a = (unsigned char *) &su->su_addr;
   2637  1.185     lukem 			p = (unsigned char *) &su->su_port;
   2638  1.109     lukem 			alen = sizeof(su->su_addr);
   2639   1.67    itojun 			af = 4;
   2640   1.67    itojun 			break;
   2641  1.104  christos #ifdef INET6
   2642   1.67    itojun 		case AF_INET6:
   2643  1.185     lukem 			a = (unsigned char *) &su->su_6addr;
   2644  1.185     lukem 			p = (unsigned char *) &su->su_port;
   2645  1.109     lukem 			alen = sizeof(su->su_6addr);
   2646   1.67    itojun 			af = 6;
   2647   1.67    itojun 			break;
   2648  1.104  christos #endif
   2649   1.67    itojun 		default:
   2650   1.67    itojun 			af = 0;
   2651   1.67    itojun 			break;
   2652   1.67    itojun 		}
   2653   1.67    itojun 		if (af) {
   2654   1.95     lukem 			cprintf(stdout, "    %s (%d,%d",
   2655   1.93     lukem 			    ispassive ? "LPSV" : "LPRT", af, alen);
   2656   1.67    itojun 			for (i = 0; i < alen; i++)
   2657   1.95     lukem 				cprintf(stdout, ",%d", UC(a[i]));
   2658  1.112    itojun 			cprintf(stdout, ",%d,%d,%d)\r\n",
   2659  1.112    itojun 			    2, UC(p[0]), UC(p[1]));
   2660    1.1       cgd #undef UC
   2661   1.67    itojun 		}
   2662   1.67    itojun 	    }
   2663   1.67    itojun 
   2664   1.67    itojun 		/* EPRT/EPSV */
   2665   1.89     lukem  epsvonly:
   2666  1.109     lukem 		af = af2epsvproto(su->su_family);
   2667  1.112    itojun 		hbuf[0] = '\0';
   2668  1.109     lukem 		if (af > 0) {
   2669  1.112    itojun 			struct sockinet tmp;
   2670  1.112    itojun 
   2671  1.112    itojun 			tmp = *su;
   2672  1.113     lukem #ifdef INET6
   2673  1.112    itojun 			if (tmp.su_family == AF_INET6)
   2674  1.112    itojun 				tmp.su_scope_id = 0;
   2675  1.113     lukem #endif
   2676  1.112    itojun 			if (getnameinfo((struct sockaddr *)&tmp.si_su,
   2677  1.112    itojun 			    tmp.su_len, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf),
   2678  1.112    itojun 			    NI_NUMERICHOST | NI_NUMERICSERV) == 0)
   2679  1.112    itojun 				reply(0, "%s (|%d|%s|%s|)",
   2680   1.93     lukem 				    ispassive ? "EPSV" : "EPRT",
   2681  1.112    itojun 				    af, hbuf, sbuf);
   2682   1.67    itojun 		}
   2683    1.1       cgd 	} else
   2684   1.95     lukem 		reply(0, "No data connection");
   2685   1.62     lukem 
   2686   1.62     lukem 	if (logged_in) {
   2687  1.109     lukem 		reply(0,
   2688  1.109     lukem 		    "Data sent:        " LLF " byte%s in " LLF " file%s",
   2689  1.109     lukem 		    (LLT)total_data_out, PLURAL(total_data_out),
   2690  1.109     lukem 		    (LLT)total_files_out, PLURAL(total_files_out));
   2691  1.109     lukem 		reply(0,
   2692  1.109     lukem 		    "Data received:    " LLF " byte%s in " LLF " file%s",
   2693  1.109     lukem 		    (LLT)total_data_in, PLURAL(total_data_in),
   2694  1.109     lukem 		    (LLT)total_files_in, PLURAL(total_files_in));
   2695  1.109     lukem 		reply(0,
   2696  1.109     lukem 		    "Total data:       " LLF " byte%s in " LLF " file%s",
   2697  1.109     lukem 		    (LLT)total_data, PLURAL(total_data),
   2698  1.109     lukem 		    (LLT)total_files, PLURAL(total_files));
   2699   1.62     lukem 	}
   2700   1.62     lukem 	otbi = total_bytes_in;
   2701   1.62     lukem 	otbo = total_bytes_out;
   2702   1.62     lukem 	otb = total_bytes;
   2703  1.109     lukem 	reply(0, "Traffic sent:     " LLF " byte%s in " LLF " transfer%s",
   2704  1.109     lukem 	    (LLT)otbo, PLURAL(otbo),
   2705  1.109     lukem 	    (LLT)total_xfers_out, PLURAL(total_xfers_out));
   2706  1.109     lukem 	reply(0, "Traffic received: " LLF " byte%s in " LLF " transfer%s",
   2707  1.109     lukem 	    (LLT)otbi, PLURAL(otbi),
   2708  1.109     lukem 	    (LLT)total_xfers_in, PLURAL(total_xfers_in));
   2709  1.109     lukem 	reply(0, "Total traffic:    " LLF " byte%s in " LLF " transfer%s",
   2710  1.109     lukem 	    (LLT)otb, PLURAL(otb),
   2711  1.109     lukem 	    (LLT)total_xfers, PLURAL(total_xfers));
   2712   1.24     lukem 
   2713  1.133     lukem 	if (logged_in && !CURCLASS_FLAGS_ISSET(private)) {
   2714   1.24     lukem 		struct ftpconv *cp;
   2715   1.24     lukem 
   2716   1.98  sommerfe 		reply(0, "%s", "");
   2717   1.95     lukem 		reply(0, "Class: %s, type: %s",
   2718   1.81     lukem 		    curclass.classname, CURCLASSTYPE);
   2719   1.95     lukem 		reply(0, "Check PORT/LPRT commands: %sabled",
   2720  1.111     lukem 		    CURCLASS_FLAGS_ISSET(checkportcmd) ? "en" : "dis");
   2721  1.100     lukem 		if (! EMPTYSTR(curclass.display))
   2722   1.95     lukem 			reply(0, "Display file: %s", curclass.display);
   2723  1.100     lukem 		if (! EMPTYSTR(curclass.notify))
   2724   1.95     lukem 			reply(0, "Notify fileglob: %s", curclass.notify);
   2725  1.147     lukem 		reply(0, "Idle timeout: " LLF ", maximum timeout: " LLF,
   2726  1.147     lukem 		    (LLT)curclass.timeout, (LLT)curclass.maxtimeout);
   2727   1.95     lukem 		reply(0, "Current connections: %d", connections);
   2728   1.82     lukem 		if (curclass.limit == -1)
   2729   1.95     lukem 			reply(0, "Maximum connections: unlimited");
   2730   1.82     lukem 		else
   2731  1.147     lukem 			reply(0, "Maximum connections: " LLF,
   2732  1.147     lukem 			    (LLT)curclass.limit);
   2733   1.82     lukem 		if (curclass.limitfile)
   2734  1.111     lukem 			reply(0, "Connection limit exceeded message file: %s",
   2735  1.131     lukem 			    conffilename(curclass.limitfile));
   2736  1.100     lukem 		if (! EMPTYSTR(curclass.chroot))
   2737  1.100     lukem 			reply(0, "Chroot format: %s", curclass.chroot);
   2738  1.135     lukem 		reply(0, "Deny bad ftpusers(5) quickly: %sabled",
   2739  1.133     lukem 		    CURCLASS_FLAGS_ISSET(denyquick) ? "en" : "dis");
   2740  1.100     lukem 		if (! EMPTYSTR(curclass.homedir))
   2741  1.100     lukem 			reply(0, "Homedir format: %s", curclass.homedir);
   2742  1.111     lukem 		if (curclass.maxfilesize == -1)
   2743  1.111     lukem 			reply(0, "Maximum file size: unlimited");
   2744  1.111     lukem 		else
   2745  1.111     lukem 			reply(0, "Maximum file size: " LLF,
   2746  1.111     lukem 			    (LLT)curclass.maxfilesize);
   2747  1.100     lukem 		if (! EMPTYSTR(curclass.motd))
   2748  1.131     lukem 			reply(0, "MotD file: %s", conffilename(curclass.motd));
   2749   1.95     lukem 		reply(0,
   2750   1.73     lukem 	    "Modify commands (CHMOD, DELE, MKD, RMD, RNFR, UMASK): %sabled",
   2751  1.111     lukem 		    CURCLASS_FLAGS_ISSET(modify) ? "en" : "dis");
   2752   1.95     lukem 		reply(0, "Upload commands (APPE, STOR, STOU): %sabled",
   2753  1.111     lukem 		    CURCLASS_FLAGS_ISSET(upload) ? "en" : "dis");
   2754  1.111     lukem 		reply(0, "Sanitize file names: %sabled",
   2755  1.111     lukem 		    CURCLASS_FLAGS_ISSET(sanenames) ? "en" : "dis");
   2756  1.111     lukem 		reply(0, "PASV/LPSV/EPSV connections: %sabled",
   2757  1.111     lukem 		    CURCLASS_FLAGS_ISSET(passive) ? "en" : "dis");
   2758  1.118     lukem 		if (curclass.advertise.su_len != 0) {
   2759  1.118     lukem 			char buf[50];	/* big enough for IPv6 address */
   2760  1.118     lukem 			const char *bp;
   2761  1.118     lukem 
   2762  1.118     lukem 			bp = inet_ntop(curclass.advertise.su_family,
   2763  1.118     lukem 			    (void *)&curclass.advertise.su_addr,
   2764  1.118     lukem 			    buf, sizeof(buf));
   2765  1.118     lukem 			if (bp != NULL)
   2766  1.128     lukem 				reply(0, "PASV advertise address: %s", bp);
   2767  1.118     lukem 		}
   2768   1.85     lukem 		if (curclass.portmin && curclass.portmax)
   2769  1.147     lukem 			reply(0, "PASV port range: " LLF " - " LLF,
   2770  1.147     lukem 			    (LLT)curclass.portmin, (LLT)curclass.portmax);
   2771   1.73     lukem 		if (curclass.rateget)
   2772  1.111     lukem 			reply(0, "Rate get limit: " LLF " bytes/sec",
   2773  1.111     lukem 			    (LLT)curclass.rateget);
   2774   1.73     lukem 		else
   2775   1.95     lukem 			reply(0, "Rate get limit: disabled");
   2776   1.73     lukem 		if (curclass.rateput)
   2777  1.111     lukem 			reply(0, "Rate put limit: " LLF " bytes/sec",
   2778  1.111     lukem 			    (LLT)curclass.rateput);
   2779   1.73     lukem 		else
   2780   1.95     lukem 			reply(0, "Rate put limit: disabled");
   2781  1.147     lukem 		if (curclass.mmapsize)
   2782  1.147     lukem 			reply(0, "Mmap size: " LLF, (LLT)curclass.mmapsize);
   2783  1.147     lukem 		else
   2784  1.147     lukem 			reply(0, "Mmap size: disabled");
   2785  1.147     lukem 		if (curclass.readsize)
   2786  1.147     lukem 			reply(0, "Read size: " LLF, (LLT)curclass.readsize);
   2787  1.147     lukem 		else
   2788  1.147     lukem 			reply(0, "Read size: default");
   2789  1.147     lukem 		if (curclass.writesize)
   2790  1.147     lukem 			reply(0, "Write size: " LLF, (LLT)curclass.writesize);
   2791  1.147     lukem 		else
   2792  1.147     lukem 			reply(0, "Write size: default");
   2793  1.168  ginsbach 		if (curclass.recvbufsize)
   2794  1.168  ginsbach 			reply(0, "Receive buffer size: " LLF,
   2795  1.168  ginsbach 			    (LLT)curclass.recvbufsize);
   2796  1.168  ginsbach 		else
   2797  1.168  ginsbach 			reply(0, "Receive buffer size: default");
   2798  1.147     lukem 		if (curclass.sendbufsize)
   2799  1.147     lukem 			reply(0, "Send buffer size: " LLF,
   2800  1.147     lukem 			    (LLT)curclass.sendbufsize);
   2801  1.147     lukem 		else
   2802  1.147     lukem 			reply(0, "Send buffer size: default");
   2803  1.147     lukem 		if (curclass.sendlowat)
   2804  1.147     lukem 			reply(0, "Send low water mark: " LLF,
   2805  1.147     lukem 			    (LLT)curclass.sendlowat);
   2806  1.147     lukem 		else
   2807  1.147     lukem 			reply(0, "Send low water mark: default");
   2808   1.95     lukem 		reply(0, "Umask: %.04o", curclass.umask);
   2809   1.24     lukem 		for (cp = curclass.conversions; cp != NULL; cp=cp->next) {
   2810   1.24     lukem 			if (cp->suffix == NULL || cp->types == NULL ||
   2811   1.24     lukem 			    cp->command == NULL)
   2812   1.24     lukem 				continue;
   2813   1.95     lukem 			reply(0, "Conversion: %s [%s] disable: %s, command: %s",
   2814   1.24     lukem 			    cp->suffix, cp->types, cp->disable, cp->command);
   2815   1.24     lukem 		}
   2816   1.24     lukem 	}
   2817   1.24     lukem 
   2818    1.1       cgd 	reply(211, "End of status");
   2819    1.1       cgd }
   2820    1.1       cgd 
   2821    1.8   deraadt void
   2822   1.88     lukem fatal(const char *s)
   2823    1.1       cgd {
   2824    1.8   deraadt 
   2825    1.1       cgd 	reply(451, "Error in server: %s\n", s);
   2826    1.1       cgd 	reply(221, "Closing connection due to server error.");
   2827    1.1       cgd 	dologout(0);
   2828    1.1       cgd 	/* NOTREACHED */
   2829    1.1       cgd }
   2830    1.1       cgd 
   2831   1.93     lukem /*
   2832   1.93     lukem  * reply() --
   2833   1.95     lukem  *	depending on the value of n, display fmt with a trailing CRLF and
   2834   1.95     lukem  *	prefix of:
   2835   1.95     lukem  *	n < -1		prefix the message with abs(n) + "-"	(initial line)
   2836   1.95     lukem  *	n == 0		prefix the message with 4 spaces	(middle lines)
   2837   1.95     lukem  *	n >  0		prefix the message with n + " "		(final line)
   2838   1.93     lukem  */
   2839    1.8   deraadt void
   2840    1.8   deraadt reply(int n, const char *fmt, ...)
   2841    1.1       cgd {
   2842  1.158     lukem 	char	msg[MAXPATHLEN * 2 + 100];
   2843  1.158     lukem 	size_t	b;
   2844  1.158     lukem 	va_list	ap;
   2845   1.88     lukem 
   2846   1.95     lukem 	if (n == 0)
   2847  1.158     lukem 		b = snprintf(msg, sizeof(msg), "    ");
   2848   1.95     lukem 	else if (n < 0)
   2849  1.158     lukem 		b = snprintf(msg, sizeof(msg), "%d-", -n);
   2850   1.95     lukem 	else
   2851  1.158     lukem 		b = snprintf(msg, sizeof(msg), "%d ", n);
   2852  1.158     lukem 	va_start(ap, fmt);
   2853  1.158     lukem 	vsnprintf(msg + b, sizeof(msg) - b, fmt, ap);
   2854  1.130       wiz 	va_end(ap);
   2855  1.158     lukem 	cprintf(stdout, "%s\r\n", msg);
   2856    1.1       cgd 	(void)fflush(stdout);
   2857  1.171  christos 	if (ftpd_debug)
   2858  1.158     lukem 		syslog(LOG_DEBUG, "<--- %s", msg);
   2859    1.1       cgd }
   2860    1.1       cgd 
   2861    1.8   deraadt static void
   2862  1.118     lukem logremotehost(struct sockinet *who)
   2863    1.1       cgd {
   2864  1.109     lukem 
   2865  1.191  christos #if defined(HAVE_SOCKADDR_SNPRINTF)
   2866  1.205  christos 	char abuf[MAXHOSTNAMELEN];
   2867  1.191  christos #endif
   2868  1.191  christos 
   2869  1.191  christos 	struct sockaddr *sa = (struct sockaddr *)&who->si_su;
   2870  1.191  christos 	if (getnameinfo(sa, who->su_len, remotehost, sizeof(remotehost), NULL,
   2871  1.191  christos 	    0, getnameopts))
   2872  1.112    itojun 		strlcpy(remotehost, "?", sizeof(remotehost));
   2873  1.191  christos #if defined(HAVE_SOCKADDR_SNPRINTF)
   2874  1.191  christos 	sockaddr_snprintf(abuf, sizeof(abuf), "%a", sa);
   2875  1.191  christos 	snprintf(remoteloghost, sizeof(remoteloghost), "%s(%s)", remotehost,
   2876  1.191  christos 	    abuf);
   2877  1.191  christos #else
   2878  1.191  christos 	strlcpy(remoteloghost, remotehost, sizeof(remoteloghost));
   2879  1.191  christos #endif
   2880  1.191  christos 
   2881  1.181     lukem #if defined(HAVE_SETPROCTITLE)
   2882    1.8   deraadt 	snprintf(proctitle, sizeof(proctitle), "%s: connected", remotehost);
   2883   1.97    itojun 	setproctitle("%s", proctitle);
   2884  1.181     lukem #endif /* defined(HAVE_SETPROCTITLE) */
   2885    1.8   deraadt 	if (logging)
   2886   1.79     lukem 		syslog(LOG_INFO, "connection from %s to %s",
   2887  1.191  christos 		    remoteloghost, hostname);
   2888    1.1       cgd }
   2889    1.1       cgd 
   2890    1.1       cgd /*
   2891  1.118     lukem  * Record logout in wtmp file and exit with supplied status.
   2892  1.158     lukem  * NOTE: because this is called from signal handlers it cannot
   2893  1.158     lukem  *       use stdio (or call other functions that use stdio).
   2894    1.1       cgd  */
   2895    1.8   deraadt void
   2896   1.88     lukem dologout(int status)
   2897    1.1       cgd {
   2898   1.16       mrg 	/*
   2899   1.16       mrg 	* Prevent reception of SIGURG from resulting in a resumption
   2900   1.16       mrg 	* back to the main program loop.
   2901   1.16       mrg 	*/
   2902   1.16       mrg 	transflag = 0;
   2903  1.141  christos 	logout_utmp();
   2904    1.1       cgd 	if (logged_in) {
   2905   1.36   mycroft #ifdef KERBEROS
   2906    1.4       cgd 		if (!notickets && krbtkfile_env)
   2907    1.4       cgd 			unlink(krbtkfile_env);
   2908    1.4       cgd #endif
   2909    1.1       cgd 	}
   2910    1.1       cgd 	/* beware of flushing buffers after a SIGPIPE */
   2911  1.154     lukem 	if (xferlogfd != -1)
   2912  1.154     lukem 		close(xferlogfd);
   2913    1.1       cgd 	_exit(status);
   2914    1.1       cgd }
   2915    1.1       cgd 
   2916  1.124     lukem void
   2917  1.124     lukem abor(void)
   2918  1.123     aidan {
   2919  1.124     lukem 
   2920  1.158     lukem 	if (!transflag)
   2921  1.158     lukem 		return;
   2922  1.123     aidan 	tmpline[0] = '\0';
   2923  1.123     aidan 	is_oob = 0;
   2924  1.123     aidan 	reply(426, "Transfer aborted. Data connection closed.");
   2925  1.123     aidan 	reply(226, "Abort successful");
   2926  1.158     lukem 	transflag = 0;		/* flag that the transfer has aborted */
   2927  1.123     aidan }
   2928  1.123     aidan 
   2929  1.124     lukem void
   2930  1.124     lukem statxfer(void)
   2931  1.123     aidan {
   2932  1.124     lukem 
   2933  1.158     lukem 	if (!transflag)
   2934  1.158     lukem 		return;
   2935  1.123     aidan 	tmpline[0] = '\0';
   2936  1.123     aidan 	is_oob = 0;
   2937  1.123     aidan 	if (file_size != (off_t) -1)
   2938  1.123     aidan 		reply(213,
   2939  1.123     aidan 		    "Status: " LLF " of " LLF " byte%s transferred",
   2940  1.123     aidan 		    (LLT)byte_count, (LLT)file_size,
   2941  1.123     aidan 		    PLURAL(byte_count));
   2942  1.123     aidan 	else
   2943  1.123     aidan 		reply(213, "Status: " LLF " byte%s transferred",
   2944  1.123     aidan 		    (LLT)byte_count, PLURAL(byte_count));
   2945  1.123     aidan }
   2946  1.123     aidan 
   2947  1.158     lukem /*
   2948  1.158     lukem  * Call when urgflag != 0 to handle Out Of Band commands.
   2949  1.158     lukem  * Returns non zero if the OOB command aborted the transfer
   2950  1.158     lukem  * by setting transflag to 0. (c.f., "ABOR").
   2951  1.158     lukem  */
   2952  1.158     lukem static int
   2953  1.198  dholland handleoobcmd(void)
   2954    1.1       cgd {
   2955    1.1       cgd 	char *cp;
   2956  1.187     lukem 	int ret;
   2957    1.1       cgd 
   2958  1.158     lukem 	if (!urgflag)
   2959  1.158     lukem 		return (0);
   2960  1.158     lukem 	urgflag = 0;
   2961    1.1       cgd 	/* only process if transfer occurring */
   2962    1.1       cgd 	if (!transflag)
   2963  1.158     lukem 		return (0);
   2964    1.1       cgd 	cp = tmpline;
   2965  1.194       roy 	ret = get_line(cp, sizeof(tmpline)-1, stdin);
   2966  1.187     lukem 	if (ret == -1) {
   2967    1.1       cgd 		reply(221, "You could at least say goodbye.");
   2968    1.1       cgd 		dologout(0);
   2969  1.187     lukem 	} else if (ret == -2) {
   2970  1.187     lukem 		/* Ignore truncated command */
   2971  1.187     lukem 		/* XXX: abort xfer with "500 command too long", & return 1 ? */
   2972  1.187     lukem 		return 0;
   2973    1.1       cgd 	}
   2974  1.158     lukem 		/*
   2975  1.158     lukem 		 * Manually parse OOB commands, because we can't
   2976  1.158     lukem 		 * recursively call the yacc parser...
   2977  1.158     lukem 		 */
   2978  1.158     lukem 	if (strcasecmp(cp, "ABOR\r\n") == 0) {
   2979  1.158     lukem 		abor();
   2980  1.158     lukem 	} else if (strcasecmp(cp, "STAT\r\n") == 0) {
   2981  1.158     lukem 		statxfer();
   2982  1.158     lukem 	} else {
   2983  1.158     lukem 		/* XXX: error with "500 unknown command" ? */
   2984  1.158     lukem 	}
   2985  1.158     lukem 	return (transflag == 0);
   2986    1.1       cgd }
   2987    1.1       cgd 
   2988   1.84     lukem static int
   2989   1.88     lukem bind_pasv_addr(void)
   2990   1.84     lukem {
   2991   1.84     lukem 	static int passiveport;
   2992   1.84     lukem 	int port, len;
   2993   1.84     lukem 
   2994   1.84     lukem 	len = pasv_addr.su_len;
   2995   1.84     lukem 	if (curclass.portmin == 0 && curclass.portmax == 0) {
   2996   1.84     lukem 		pasv_addr.su_port = 0;
   2997  1.109     lukem 		return (bind(pdata, (struct sockaddr *)&pasv_addr.si_su, len));
   2998   1.84     lukem 	}
   2999   1.84     lukem 
   3000   1.84     lukem 	if (passiveport == 0) {
   3001   1.84     lukem 		srand(getpid());
   3002   1.84     lukem 		passiveport = rand() % (curclass.portmax - curclass.portmin)
   3003   1.84     lukem 		    + curclass.portmin;
   3004   1.84     lukem 	}
   3005   1.84     lukem 
   3006   1.84     lukem 	port = passiveport;
   3007   1.84     lukem 	while (1) {
   3008   1.84     lukem 		port++;
   3009   1.84     lukem 		if (port > curclass.portmax)
   3010   1.84     lukem 			port = curclass.portmin;
   3011   1.84     lukem 		else if (port == passiveport) {
   3012   1.84     lukem 			errno = EAGAIN;
   3013   1.84     lukem 			return (-1);
   3014   1.84     lukem 		}
   3015   1.84     lukem 		pasv_addr.su_port = htons(port);
   3016  1.109     lukem 		if (bind(pdata, (struct sockaddr *)&pasv_addr.si_su, len) == 0)
   3017   1.84     lukem 			break;
   3018   1.84     lukem 		if (errno != EADDRINUSE)
   3019   1.84     lukem 			return (-1);
   3020   1.84     lukem 	}
   3021   1.84     lukem 	passiveport = port;
   3022   1.84     lukem 	return (0);
   3023   1.84     lukem }
   3024   1.84     lukem 
   3025    1.1       cgd /*
   3026    1.1       cgd  * Note: a response of 425 is not mentioned as a possible response to
   3027    1.8   deraadt  *	the PASV command in RFC959. However, it has been blessed as
   3028    1.8   deraadt  *	a legitimate response by Jon Postel in a telephone conversation
   3029    1.1       cgd  *	with Rick Adams on 25 Jan 89.
   3030    1.1       cgd  */
   3031    1.8   deraadt void
   3032   1.88     lukem passive(void)
   3033    1.1       cgd {
   3034  1.193     lukem 	socklen_t len;
   3035  1.193     lukem 	int recvbufsize;
   3036    1.8   deraadt 	char *p, *a;
   3037    1.1       cgd 
   3038   1.72    itojun 	if (pdata >= 0)
   3039   1.72    itojun 		close(pdata);
   3040    1.1       cgd 	pdata = socket(AF_INET, SOCK_STREAM, 0);
   3041   1.23     lukem 	if (pdata < 0 || !logged_in) {
   3042    1.1       cgd 		perror_reply(425, "Can't open passive connection");
   3043    1.1       cgd 		return;
   3044    1.1       cgd 	}
   3045    1.1       cgd 	pasv_addr = ctrl_addr;
   3046   1.84     lukem 
   3047   1.84     lukem 	if (bind_pasv_addr() < 0)
   3048   1.84     lukem 		goto pasv_error;
   3049   1.67    itojun 	len = pasv_addr.su_len;
   3050  1.109     lukem 	if (getsockname(pdata, (struct sockaddr *) &pasv_addr.si_su, &len) < 0)
   3051    1.1       cgd 		goto pasv_error;
   3052  1.109     lukem 	pasv_addr.su_len = len;
   3053  1.168  ginsbach 	if (curclass.recvbufsize) {
   3054  1.168  ginsbach 		recvbufsize = curclass.recvbufsize;
   3055  1.168  ginsbach 		if (setsockopt(pdata, SOL_SOCKET, SO_RCVBUF, &recvbufsize,
   3056  1.168  ginsbach 			       sizeof(int)) == -1)
   3057  1.168  ginsbach 			syslog(LOG_WARNING, "setsockopt(SO_RCVBUF, %d): %m",
   3058  1.168  ginsbach 			       recvbufsize);
   3059  1.168  ginsbach 	}
   3060    1.1       cgd 	if (listen(pdata, 1) < 0)
   3061    1.1       cgd 		goto pasv_error;
   3062  1.118     lukem 	if (curclass.advertise.su_len != 0)
   3063  1.118     lukem 		a = (char *) &curclass.advertise.su_addr;
   3064  1.118     lukem 	else
   3065  1.118     lukem 		a = (char *) &pasv_addr.su_addr;
   3066   1.67    itojun 	p = (char *) &pasv_addr.su_port;
   3067    1.1       cgd 
   3068    1.1       cgd #define UC(b) (((int) b) & 0xff)
   3069    1.1       cgd 
   3070    1.1       cgd 	reply(227, "Entering Passive Mode (%d,%d,%d,%d,%d,%d)", UC(a[0]),
   3071    1.1       cgd 		UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
   3072    1.1       cgd 	return;
   3073    1.1       cgd 
   3074   1.89     lukem  pasv_error:
   3075   1.67    itojun 	(void) close(pdata);
   3076   1.67    itojun 	pdata = -1;
   3077   1.67    itojun 	perror_reply(425, "Can't open passive connection");
   3078   1.67    itojun 	return;
   3079   1.67    itojun }
   3080   1.67    itojun 
   3081   1.67    itojun /*
   3082  1.106    itojun  * convert protocol identifier to/from AF
   3083  1.106    itojun  */
   3084  1.106    itojun int
   3085  1.106    itojun lpsvproto2af(int proto)
   3086  1.106    itojun {
   3087  1.106    itojun 
   3088  1.106    itojun 	switch (proto) {
   3089  1.109     lukem 	case 4:
   3090  1.109     lukem 		return AF_INET;
   3091  1.106    itojun #ifdef INET6
   3092  1.109     lukem 	case 6:
   3093  1.109     lukem 		return AF_INET6;
   3094  1.106    itojun #endif
   3095  1.109     lukem 	default:
   3096  1.109     lukem 		return -1;
   3097  1.106    itojun 	}
   3098  1.106    itojun }
   3099  1.106    itojun 
   3100  1.106    itojun int
   3101  1.106    itojun af2lpsvproto(int af)
   3102  1.106    itojun {
   3103  1.106    itojun 
   3104  1.106    itojun 	switch (af) {
   3105  1.109     lukem 	case AF_INET:
   3106  1.109     lukem 		return 4;
   3107  1.106    itojun #ifdef INET6
   3108  1.109     lukem 	case AF_INET6:
   3109  1.109     lukem 		return 6;
   3110  1.106    itojun #endif
   3111  1.109     lukem 	default:
   3112  1.109     lukem 		return -1;
   3113  1.106    itojun 	}
   3114  1.106    itojun }
   3115  1.106    itojun 
   3116  1.106    itojun int
   3117  1.106    itojun epsvproto2af(int proto)
   3118  1.106    itojun {
   3119  1.106    itojun 
   3120  1.106    itojun 	switch (proto) {
   3121  1.109     lukem 	case 1:
   3122  1.109     lukem 		return AF_INET;
   3123  1.106    itojun #ifdef INET6
   3124  1.109     lukem 	case 2:
   3125  1.109     lukem 		return AF_INET6;
   3126  1.106    itojun #endif
   3127  1.109     lukem 	default:
   3128  1.109     lukem 		return -1;
   3129  1.106    itojun 	}
   3130  1.106    itojun }
   3131  1.106    itojun 
   3132  1.106    itojun int
   3133  1.106    itojun af2epsvproto(int af)
   3134  1.106    itojun {
   3135  1.106    itojun 
   3136  1.106    itojun 	switch (af) {
   3137  1.109     lukem 	case AF_INET:
   3138  1.109     lukem 		return 1;
   3139  1.106    itojun #ifdef INET6
   3140  1.109     lukem 	case AF_INET6:
   3141  1.109     lukem 		return 2;
   3142  1.106    itojun #endif
   3143  1.109     lukem 	default:
   3144  1.109     lukem 		return -1;
   3145  1.106    itojun 	}
   3146  1.106    itojun }
   3147  1.106    itojun 
   3148  1.106    itojun /*
   3149   1.67    itojun  * 228 Entering Long Passive Mode (af, hal, h1, h2, h3,..., pal, p1, p2...)
   3150   1.67    itojun  * 229 Entering Extended Passive Mode (|||port|)
   3151   1.67    itojun  */
   3152   1.67    itojun void
   3153  1.193     lukem long_passive(const char *cmd, int pf)
   3154   1.67    itojun {
   3155  1.176       mrg 	socklen_t len;
   3156   1.84     lukem 	char *p, *a;
   3157   1.67    itojun 
   3158   1.67    itojun 	if (!logged_in) {
   3159   1.67    itojun 		syslog(LOG_NOTICE, "long passive but not logged in");
   3160   1.67    itojun 		reply(503, "Login with USER first.");
   3161   1.67    itojun 		return;
   3162   1.67    itojun 	}
   3163   1.67    itojun 
   3164  1.106    itojun 	if (pf != PF_UNSPEC && ctrl_addr.su_family != pf) {
   3165  1.106    itojun 		/*
   3166  1.111     lukem 		 * XXX: only EPRT/EPSV ready clients will understand this
   3167  1.106    itojun 		 */
   3168  1.106    itojun 		if (strcmp(cmd, "EPSV") != 0)
   3169  1.106    itojun 			reply(501, "Network protocol mismatch"); /*XXX*/
   3170  1.106    itojun 		else
   3171  1.106    itojun 			epsv_protounsupp("Network protocol mismatch");
   3172   1.67    itojun 
   3173  1.106    itojun 		return;
   3174   1.67    itojun 	}
   3175   1.73     lukem 
   3176   1.72    itojun 	if (pdata >= 0)
   3177   1.72    itojun 		close(pdata);
   3178   1.67    itojun 	pdata = socket(ctrl_addr.su_family, SOCK_STREAM, 0);
   3179   1.67    itojun 	if (pdata < 0) {
   3180   1.67    itojun 		perror_reply(425, "Can't open passive connection");
   3181   1.67    itojun 		return;
   3182   1.67    itojun 	}
   3183   1.67    itojun 	pasv_addr = ctrl_addr;
   3184   1.84     lukem 	if (bind_pasv_addr() < 0)
   3185   1.67    itojun 		goto pasv_error;
   3186   1.67    itojun 	len = pasv_addr.su_len;
   3187  1.109     lukem 	if (getsockname(pdata, (struct sockaddr *) &pasv_addr.si_su, &len) < 0)
   3188   1.67    itojun 		goto pasv_error;
   3189  1.109     lukem 	pasv_addr.su_len = len;
   3190   1.67    itojun 	if (listen(pdata, 1) < 0)
   3191   1.67    itojun 		goto pasv_error;
   3192   1.67    itojun 	p = (char *) &pasv_addr.su_port;
   3193   1.67    itojun 
   3194   1.67    itojun #define UC(b) (((int) b) & 0xff)
   3195   1.67    itojun 
   3196   1.67    itojun 	if (strcmp(cmd, "LPSV") == 0) {
   3197  1.118     lukem 		struct sockinet *advert;
   3198  1.118     lukem 
   3199  1.118     lukem 		if (curclass.advertise.su_len != 0)
   3200  1.118     lukem 			advert = &curclass.advertise;
   3201  1.118     lukem 		else
   3202  1.118     lukem 			advert = &pasv_addr;
   3203  1.118     lukem 		switch (advert->su_family) {
   3204   1.67    itojun 		case AF_INET:
   3205  1.118     lukem 			a = (char *) &advert->su_addr;
   3206  1.109     lukem 			reply(228,
   3207  1.109     lukem     "Entering Long Passive Mode (%d,%d,%d,%d,%d,%d,%d,%d,%d)",
   3208   1.67    itojun 				4, 4, UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
   3209   1.67    itojun 				2, UC(p[0]), UC(p[1]));
   3210   1.67    itojun 			return;
   3211  1.104  christos #ifdef INET6
   3212   1.67    itojun 		case AF_INET6:
   3213  1.118     lukem 			a = (char *) &advert->su_6addr;
   3214  1.109     lukem 			reply(228,
   3215  1.109     lukem     "Entering Long Passive Mode (%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
   3216   1.67    itojun 				6, 16,
   3217   1.67    itojun 				UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
   3218   1.67    itojun 				UC(a[4]), UC(a[5]), UC(a[6]), UC(a[7]),
   3219   1.67    itojun 				UC(a[8]), UC(a[9]), UC(a[10]), UC(a[11]),
   3220   1.67    itojun 				UC(a[12]), UC(a[13]), UC(a[14]), UC(a[15]),
   3221   1.67    itojun 				2, UC(p[0]), UC(p[1]));
   3222   1.67    itojun 			return;
   3223  1.104  christos #endif
   3224   1.67    itojun 		}
   3225   1.67    itojun #undef UC
   3226   1.67    itojun 	} else if (strcmp(cmd, "EPSV") == 0) {
   3227   1.67    itojun 		switch (pasv_addr.su_family) {
   3228   1.67    itojun 		case AF_INET:
   3229  1.109     lukem #ifdef INET6
   3230   1.67    itojun 		case AF_INET6:
   3231  1.109     lukem #endif
   3232   1.67    itojun 			reply(229, "Entering Extended Passive Mode (|||%d|)",
   3233  1.109     lukem 			    ntohs(pasv_addr.su_port));
   3234   1.67    itojun 			return;
   3235   1.67    itojun 		}
   3236   1.67    itojun 	} else {
   3237   1.67    itojun 		/* more proper error code? */
   3238   1.67    itojun 	}
   3239   1.67    itojun 
   3240   1.89     lukem  pasv_error:
   3241    1.1       cgd 	(void) close(pdata);
   3242    1.1       cgd 	pdata = -1;
   3243    1.1       cgd 	perror_reply(425, "Can't open passive connection");
   3244    1.1       cgd 	return;
   3245  1.106    itojun }
   3246  1.106    itojun 
   3247  1.106    itojun int
   3248  1.106    itojun extended_port(const char *arg)
   3249  1.106    itojun {
   3250  1.106    itojun 	char *tmp = NULL;
   3251  1.106    itojun 	char *result[3];
   3252  1.106    itojun 	char *p, *q;
   3253  1.106    itojun 	char delim;
   3254  1.106    itojun 	struct addrinfo hints;
   3255  1.106    itojun 	struct addrinfo *res = NULL;
   3256  1.106    itojun 	int i;
   3257  1.106    itojun 	unsigned long proto;
   3258  1.106    itojun 
   3259  1.171  christos 	tmp = ftpd_strdup(arg);
   3260  1.106    itojun 	p = tmp;
   3261  1.106    itojun 	delim = p[0];
   3262  1.106    itojun 	p++;
   3263  1.106    itojun 	memset(result, 0, sizeof(result));
   3264  1.106    itojun 	for (i = 0; i < 3; i++) {
   3265  1.106    itojun 		q = strchr(p, delim);
   3266  1.106    itojun 		if (!q || *q != delim)
   3267  1.106    itojun 			goto parsefail;
   3268  1.106    itojun 		*q++ = '\0';
   3269  1.106    itojun 		result[i] = p;
   3270  1.106    itojun 		p = q;
   3271  1.106    itojun 	}
   3272  1.106    itojun 
   3273  1.111     lukem 			/* some more sanity checks */
   3274  1.146    itojun 	errno = 0;
   3275  1.106    itojun 	p = NULL;
   3276  1.106    itojun 	(void)strtoul(result[2], &p, 10);
   3277  1.146    itojun 	if (errno || !*result[2] || *p)
   3278  1.108    itojun 		goto parsefail;
   3279  1.146    itojun 	errno = 0;
   3280  1.106    itojun 	p = NULL;
   3281  1.106    itojun 	proto = strtoul(result[0], &p, 10);
   3282  1.146    itojun 	if (errno || !*result[0] || *p)
   3283  1.106    itojun 		goto protounsupp;
   3284  1.106    itojun 
   3285  1.106    itojun 	memset(&hints, 0, sizeof(hints));
   3286  1.106    itojun 	hints.ai_family = epsvproto2af((int)proto);
   3287  1.106    itojun 	if (hints.ai_family < 0)
   3288  1.106    itojun 		goto protounsupp;
   3289  1.106    itojun 	hints.ai_socktype = SOCK_STREAM;
   3290  1.106    itojun 	hints.ai_flags = AI_NUMERICHOST;
   3291  1.106    itojun 	if (getaddrinfo(result[1], result[2], &hints, &res))
   3292  1.106    itojun 		goto parsefail;
   3293  1.106    itojun 	if (res->ai_next)
   3294  1.106    itojun 		goto parsefail;
   3295  1.106    itojun 	if (sizeof(data_dest) < res->ai_addrlen)
   3296  1.106    itojun 		goto parsefail;
   3297  1.118     lukem 	memcpy(&data_dest.si_su, res->ai_addr, res->ai_addrlen);
   3298  1.118     lukem 	data_dest.su_len = res->ai_addrlen;
   3299  1.113     lukem #ifdef INET6
   3300  1.106    itojun 	if (his_addr.su_family == AF_INET6 &&
   3301  1.106    itojun 	    data_dest.su_family == AF_INET6) {
   3302  1.111     lukem 			/* XXX: more sanity checks! */
   3303  1.109     lukem 		data_dest.su_scope_id = his_addr.su_scope_id;
   3304  1.106    itojun 	}
   3305  1.113     lukem #endif
   3306  1.106    itojun 
   3307  1.106    itojun 	if (tmp != NULL)
   3308  1.106    itojun 		free(tmp);
   3309  1.106    itojun 	if (res)
   3310  1.106    itojun 		freeaddrinfo(res);
   3311  1.106    itojun 	return 0;
   3312  1.106    itojun 
   3313  1.109     lukem  parsefail:
   3314  1.106    itojun 	reply(500, "Invalid argument, rejected.");
   3315  1.106    itojun 	usedefault = 1;
   3316  1.107    itojun 	if (tmp != NULL)
   3317  1.107    itojun 		free(tmp);
   3318  1.107    itojun 	if (res)
   3319  1.107    itojun 		freeaddrinfo(res);
   3320  1.106    itojun 	return -1;
   3321  1.106    itojun 
   3322  1.109     lukem  protounsupp:
   3323  1.106    itojun 	epsv_protounsupp("Protocol not supported");
   3324  1.106    itojun 	usedefault = 1;
   3325  1.107    itojun 	if (tmp != NULL)
   3326  1.107    itojun 		free(tmp);
   3327  1.106    itojun 	return -1;
   3328  1.106    itojun }
   3329  1.106    itojun 
   3330  1.106    itojun /*
   3331  1.106    itojun  * 522 Protocol not supported (proto,...)
   3332  1.106    itojun  * as we assume address family for control and data connections are the same,
   3333  1.106    itojun  * we do not return the list of address families we support - instead, we
   3334  1.106    itojun  * return the address family of the control connection.
   3335  1.106    itojun  */
   3336  1.106    itojun void
   3337  1.106    itojun epsv_protounsupp(const char *message)
   3338  1.106    itojun {
   3339  1.106    itojun 	int proto;
   3340  1.106    itojun 
   3341  1.106    itojun 	proto = af2epsvproto(ctrl_addr.su_family);
   3342  1.106    itojun 	if (proto < 0)
   3343  1.111     lukem 		reply(501, "%s", message);	/* XXX */
   3344  1.106    itojun 	else
   3345  1.106    itojun 		reply(522, "%s, use (%d)", message, proto);
   3346    1.1       cgd }
   3347    1.1       cgd 
   3348    1.1       cgd /*
   3349    1.1       cgd  * Generate unique name for file with basename "local".
   3350    1.1       cgd  * The file named "local" is already known to exist.
   3351    1.1       cgd  * Generates failure reply on error.
   3352   1.29       mrg  *
   3353  1.109     lukem  * XXX:	this function should under go changes similar to
   3354  1.109     lukem  *	the mktemp(3)/mkstemp(3) changes.
   3355    1.1       cgd  */
   3356    1.8   deraadt static char *
   3357   1.88     lukem gunique(const char *local)
   3358    1.1       cgd {
   3359   1.82     lukem 	static char new[MAXPATHLEN];
   3360    1.1       cgd 	struct stat st;
   3361    1.8   deraadt 	char *cp;
   3362   1.73     lukem 	int count;
   3363    1.1       cgd 
   3364    1.8   deraadt 	cp = strrchr(local, '/');
   3365    1.1       cgd 	if (cp)
   3366    1.1       cgd 		*cp = '\0';
   3367    1.1       cgd 	if (stat(cp ? local : ".", &st) < 0) {
   3368    1.1       cgd 		perror_reply(553, cp ? local : ".");
   3369   1.57     lukem 		return (NULL);
   3370    1.1       cgd 	}
   3371    1.1       cgd 	if (cp)
   3372    1.1       cgd 		*cp = '/';
   3373    1.1       cgd 	for (count = 1; count < 100; count++) {
   3374   1.73     lukem 		(void)snprintf(new, sizeof(new) - 1, "%s.%d", local, count);
   3375    1.1       cgd 		if (stat(new, &st) < 0)
   3376    1.8   deraadt 			return (new);
   3377    1.1       cgd 	}
   3378    1.1       cgd 	reply(452, "Unique file name cannot be created.");
   3379    1.8   deraadt 	return (NULL);
   3380    1.1       cgd }
   3381    1.1       cgd 
   3382    1.1       cgd /*
   3383    1.1       cgd  * Format and send reply containing system error number.
   3384    1.1       cgd  */
   3385    1.8   deraadt void
   3386   1.88     lukem perror_reply(int code, const char *string)
   3387    1.1       cgd {
   3388   1.62     lukem 	int save_errno;
   3389    1.8   deraadt 
   3390   1.62     lukem 	save_errno = errno;
   3391    1.1       cgd 	reply(code, "%s: %s.", string, strerror(errno));
   3392   1.62     lukem 	errno = save_errno;
   3393    1.1       cgd }
   3394    1.1       cgd 
   3395    1.1       cgd static char *onefile[] = {
   3396  1.193     lukem 	NULL,
   3397    1.1       cgd 	0
   3398    1.1       cgd };
   3399    1.1       cgd 
   3400    1.8   deraadt void
   3401   1.88     lukem send_file_list(const char *whichf)
   3402    1.1       cgd {
   3403    1.1       cgd 	struct stat st;
   3404  1.178  christos 	DIR *dirp;
   3405    1.1       cgd 	struct dirent *dir;
   3406  1.178  christos 	FILE *volatile dout;
   3407  1.178  christos 	char **volatile dirlist;
   3408  1.178  christos 	char *dirname, *p;
   3409  1.178  christos 	char *notglob;
   3410  1.178  christos 	int volatile simple;
   3411  1.178  christos 	int volatile freeglob;
   3412    1.8   deraadt 	glob_t gl;
   3413   1.62     lukem 
   3414  1.178  christos 	dirp = NULL;
   3415  1.178  christos 	dout = NULL;
   3416  1.178  christos 	notglob = NULL;
   3417  1.178  christos 	simple = 0;
   3418  1.178  christos 	freeglob = 0;
   3419  1.158     lukem 	urgflag = 0;
   3420    1.1       cgd 
   3421   1.62     lukem 	p = NULL;
   3422    1.8   deraadt 	if (strpbrk(whichf, "~{[*?") != NULL) {
   3423  1.122  christos 		int flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_TILDE|GLOB_LIMIT;
   3424    1.1       cgd 
   3425    1.8   deraadt 		memset(&gl, 0, sizeof(gl));
   3426    1.8   deraadt 		freeglob = 1;
   3427    1.8   deraadt 		if (glob(whichf, flags, 0, &gl)) {
   3428  1.170     lukem 			reply(450, "Not found");
   3429  1.158     lukem 			goto cleanup_send_file_list;
   3430    1.8   deraadt 		} else if (gl.gl_pathc == 0) {
   3431    1.1       cgd 			errno = ENOENT;
   3432  1.170     lukem 			perror_reply(450, whichf);
   3433  1.158     lukem 			goto cleanup_send_file_list;
   3434    1.1       cgd 		}
   3435    1.8   deraadt 		dirlist = gl.gl_pathv;
   3436    1.1       cgd 	} else {
   3437  1.171  christos 		notglob = ftpd_strdup(whichf);
   3438  1.132     lukem 		onefile[0] = notglob;
   3439    1.1       cgd 		dirlist = onefile;
   3440    1.1       cgd 		simple = 1;
   3441    1.1       cgd 	}
   3442   1.62     lukem 					/* XXX: } for vi sm */
   3443    1.1       cgd 
   3444   1.20     lukem 	while ((dirname = *dirlist++) != NULL) {
   3445   1.33     lukem 		int trailingslash = 0;
   3446   1.33     lukem 
   3447    1.1       cgd 		if (stat(dirname, &st) < 0) {
   3448    1.1       cgd 			/*
   3449    1.1       cgd 			 * If user typed "ls -l", etc, and the client
   3450    1.1       cgd 			 * used NLST, do what the user meant.
   3451    1.1       cgd 			 */
   3452   1.71     lukem 			/* XXX: nuke this support? */
   3453    1.1       cgd 			if (dirname[0] == '-' && *dirlist == NULL &&
   3454    1.1       cgd 			    transflag == 0) {
   3455  1.193     lukem 				const char *argv[] = { INTERNAL_LS, "", NULL };
   3456   1.71     lukem 
   3457   1.71     lukem 				argv[1] = dirname;
   3458   1.71     lukem 				retrieve(argv, dirname);
   3459  1.158     lukem 				goto cleanup_send_file_list;
   3460    1.1       cgd 			}
   3461  1.170     lukem 			perror_reply(450, whichf);
   3462   1.95     lukem 			goto cleanup_send_file_list;
   3463    1.1       cgd 		}
   3464    1.1       cgd 
   3465    1.8   deraadt 		if (S_ISREG(st.st_mode)) {
   3466  1.118     lukem 			/*
   3467  1.118     lukem 			 * XXXRFC:
   3468  1.118     lukem 			 *	should we follow RFC959 and not work
   3469  1.118     lukem 			 *	for non directories?
   3470  1.118     lukem 			 */
   3471    1.1       cgd 			if (dout == NULL) {
   3472    1.1       cgd 				dout = dataconn("file list", (off_t)-1, "w");
   3473    1.1       cgd 				if (dout == NULL)
   3474  1.158     lukem 					goto cleanup_send_file_list;
   3475  1.158     lukem 				transflag = 1;
   3476    1.1       cgd 			}
   3477  1.118     lukem 			cprintf(dout, "%s%s\n", dirname,
   3478   1.62     lukem 			    type == TYPE_A ? "\r" : "");
   3479    1.1       cgd 			continue;
   3480    1.8   deraadt 		} else if (!S_ISDIR(st.st_mode))
   3481    1.1       cgd 			continue;
   3482    1.1       cgd 
   3483   1.33     lukem 		if (dirname[strlen(dirname) - 1] == '/')
   3484   1.33     lukem 			trailingslash++;
   3485   1.33     lukem 
   3486    1.1       cgd 		if ((dirp = opendir(dirname)) == NULL)
   3487    1.1       cgd 			continue;
   3488    1.1       cgd 
   3489    1.1       cgd 		while ((dir = readdir(dirp)) != NULL) {
   3490   1.82     lukem 			char nbuf[MAXPATHLEN];
   3491    1.1       cgd 
   3492  1.202       shm 			if (urgflag && handleoobcmd()) {
   3493  1.202       shm 				(void) closedir(dirp);
   3494  1.158     lukem 				goto cleanup_send_file_list;
   3495  1.202       shm 			}
   3496  1.158     lukem 
   3497   1.93     lukem 			if (ISDOTDIR(dir->d_name) || ISDOTDOTDIR(dir->d_name))
   3498    1.1       cgd 				continue;
   3499    1.1       cgd 
   3500   1.33     lukem 			(void)snprintf(nbuf, sizeof(nbuf), "%s%s%s", dirname,
   3501   1.33     lukem 			    trailingslash ? "" : "/", dir->d_name);
   3502    1.1       cgd 
   3503    1.1       cgd 			/*
   3504   1.30     lukem 			 * We have to do a stat to ensure it's
   3505    1.1       cgd 			 * not a directory or special file.
   3506    1.1       cgd 			 */
   3507  1.118     lukem 			/*
   3508  1.118     lukem 			 * XXXRFC:
   3509  1.118     lukem 			 *	should we follow RFC959 and filter out
   3510  1.118     lukem 			 *	non files ?   lukem - NO!, or not until
   3511  1.118     lukem 			 *	our ftp client uses MLS{T,D} for completion.
   3512  1.118     lukem 			 */
   3513    1.1       cgd 			if (simple || (stat(nbuf, &st) == 0 &&
   3514    1.8   deraadt 			    S_ISREG(st.st_mode))) {
   3515    1.1       cgd 				if (dout == NULL) {
   3516    1.1       cgd 					dout = dataconn("file list", (off_t)-1,
   3517    1.1       cgd 						"w");
   3518  1.202       shm 					if (dout == NULL) {
   3519  1.202       shm 						(void) closedir(dirp);
   3520  1.158     lukem 						goto cleanup_send_file_list;
   3521  1.202       shm 					}
   3522  1.158     lukem 					transflag = 1;
   3523    1.1       cgd 				}
   3524   1.62     lukem 				p = nbuf;
   3525    1.1       cgd 				if (nbuf[0] == '.' && nbuf[1] == '/')
   3526   1.62     lukem 					p = &nbuf[2];
   3527  1.118     lukem 				cprintf(dout, "%s%s\n", p,
   3528   1.62     lukem 				    type == TYPE_A ? "\r" : "");
   3529    1.1       cgd 			}
   3530    1.1       cgd 		}
   3531    1.1       cgd 		(void) closedir(dirp);
   3532    1.1       cgd 	}
   3533    1.1       cgd 
   3534    1.1       cgd 	if (dout == NULL)
   3535  1.170     lukem 		reply(450, "No files found.");
   3536    1.1       cgd 	else if (ferror(dout) != 0)
   3537  1.170     lukem 		perror_reply(451, "Data connection");
   3538    1.1       cgd 	else
   3539    1.1       cgd 		reply(226, "Transfer complete.");
   3540    1.1       cgd 
   3541   1.95     lukem  cleanup_send_file_list:
   3542  1.158     lukem 	closedataconn(dout);
   3543    1.1       cgd 	transflag = 0;
   3544  1.158     lukem 	urgflag = 0;
   3545   1.62     lukem 	total_xfers++;
   3546   1.62     lukem 	total_xfers_out++;
   3547  1.132     lukem 	if (notglob)
   3548  1.132     lukem 		free(notglob);
   3549   1.62     lukem 	if (freeglob)
   3550    1.8   deraadt 		globfree(&gl);
   3551   1.34     lukem }
   3552   1.34     lukem 
   3553   1.34     lukem char *
   3554   1.88     lukem conffilename(const char *s)
   3555   1.34     lukem {
   3556   1.82     lukem 	static char filename[MAXPATHLEN];
   3557   1.34     lukem 
   3558   1.73     lukem 	if (*s == '/')
   3559   1.73     lukem 		strlcpy(filename, s, sizeof(filename));
   3560   1.73     lukem 	else
   3561   1.73     lukem 		(void)snprintf(filename, sizeof(filename), "%s/%s", confdir ,s);
   3562   1.73     lukem 	return (filename);
   3563   1.62     lukem }
   3564   1.62     lukem 
   3565   1.62     lukem /*
   3566  1.118     lukem  * logxfer --
   3567  1.118     lukem  *	if logging > 1, then based on the arguments, syslog a message:
   3568   1.62     lukem  *	 if bytes != -1		"<command> <file1> = <bytes> bytes"
   3569   1.62     lukem  *	 else if file2 != NULL	"<command> <file1> <file2>"
   3570   1.62     lukem  *	 else			"<command> <file1>"
   3571   1.62     lukem  *	if elapsed != NULL, append "in xxx.yyy seconds"
   3572   1.62     lukem  *	if error != NULL, append ": " + error
   3573  1.118     lukem  *
   3574  1.147     lukem  *	if doxferlog != 0, bytes != -1, and command is "get", "put",
   3575  1.154     lukem  *	or "append", syslog and/or write a wu-ftpd style xferlog entry
   3576   1.62     lukem  */
   3577   1.62     lukem void
   3578  1.118     lukem logxfer(const char *command, off_t bytes, const char *file1, const char *file2,
   3579  1.139     enami     const struct timeval *elapsed, const char *error)
   3580   1.62     lukem {
   3581  1.169     lukem 	char		 buf[MAXPATHLEN * 2 + 100];
   3582  1.169     lukem 	char		 realfile1[MAXPATHLEN], realfile2[MAXPATHLEN];
   3583  1.118     lukem 	const char	*r1, *r2;
   3584  1.118     lukem 	char		 direction;
   3585  1.118     lukem 	size_t		 len;
   3586  1.118     lukem 	time_t		 now;
   3587   1.62     lukem 
   3588  1.118     lukem 	if (logging <=1 && !doxferlog)
   3589   1.62     lukem 		return;
   3590   1.62     lukem 
   3591  1.118     lukem 	r1 = r2 = NULL;
   3592  1.169     lukem 	if ((r1 = realpath(file1, realfile1)) == NULL)
   3593  1.118     lukem 		r1 = file1;
   3594  1.118     lukem 	if (file2 != NULL)
   3595  1.169     lukem 		if ((r2 = realpath(file2, realfile2)) == NULL)
   3596  1.118     lukem 			r2 = file2;
   3597   1.62     lukem 
   3598  1.118     lukem 		/*
   3599  1.118     lukem 		 * syslog command
   3600  1.118     lukem 		 */
   3601  1.118     lukem 	if (logging > 1) {
   3602  1.118     lukem 		len = snprintf(buf, sizeof(buf), "%s %s", command, r1);
   3603  1.118     lukem 		if (bytes != (off_t)-1)
   3604  1.118     lukem 			len += snprintf(buf + len, sizeof(buf) - len,
   3605  1.118     lukem 			    " = " LLF " byte%s", (LLT) bytes, PLURAL(bytes));
   3606  1.118     lukem 		else if (r2 != NULL)
   3607  1.118     lukem 			len += snprintf(buf + len, sizeof(buf) - len,
   3608  1.118     lukem 			    " %s", r2);
   3609  1.118     lukem 		if (elapsed != NULL)
   3610  1.118     lukem 			len += snprintf(buf + len, sizeof(buf) - len,
   3611  1.192     lukem 			    " in " LLF ".%.03ld seconds",
   3612  1.192     lukem 			    (LLT)elapsed->tv_sec,
   3613  1.190  christos 			    (long)(elapsed->tv_usec / 1000));
   3614  1.118     lukem 		if (error != NULL)
   3615  1.118     lukem 			len += snprintf(buf + len, sizeof(buf) - len,
   3616  1.118     lukem 			    ": %s", error);
   3617  1.118     lukem 		syslog(LOG_INFO, "%s", buf);
   3618   1.62     lukem 	}
   3619   1.62     lukem 
   3620  1.118     lukem 		/*
   3621  1.118     lukem 		 * syslog wu-ftpd style log entry, prefixed with "xferlog: "
   3622  1.118     lukem 		 */
   3623  1.138     lukem 	if (!doxferlog || bytes == -1)
   3624  1.118     lukem 		return;
   3625  1.118     lukem 
   3626  1.118     lukem 	if (strcmp(command, "get") == 0)
   3627  1.118     lukem 		direction = 'o';
   3628  1.118     lukem 	else if (strcmp(command, "put") == 0 || strcmp(command, "append") == 0)
   3629  1.118     lukem 		direction = 'i';
   3630  1.118     lukem 	else
   3631  1.118     lukem 		return;
   3632   1.62     lukem 
   3633  1.118     lukem 	time(&now);
   3634  1.154     lukem 	len = snprintf(buf, sizeof(buf),
   3635  1.192     lukem 	    "%.24s " LLF " %s " LLF " %s %c %s %c %c %s FTP 0 * %c\n",
   3636  1.118     lukem 
   3637  1.118     lukem /*
   3638  1.154     lukem  * XXX: wu-ftpd puts ' (send)' or ' (recv)' in the syslog message, and removes
   3639  1.118     lukem  *	the full date.  This may be problematic for accurate log parsing,
   3640  1.118     lukem  *	given that syslog messages don't contain the full date.
   3641  1.118     lukem  */
   3642  1.118     lukem 	    ctime(&now),
   3643  1.192     lukem 	    (LLT)
   3644  1.190  christos 	    (elapsed == NULL ? 0 : elapsed->tv_sec + (elapsed->tv_usec > 0)),
   3645  1.118     lukem 	    remotehost,
   3646  1.138     lukem 	    (LLT) bytes,
   3647  1.118     lukem 	    r1,
   3648  1.118     lukem 	    type == TYPE_A ? 'a' : 'b',
   3649  1.118     lukem 	    "_",		/* XXX: take conversions into account? */
   3650  1.118     lukem 	    direction,
   3651  1.118     lukem 
   3652  1.118     lukem 	    curclass.type == CLASS_GUEST ?  'a' :
   3653  1.118     lukem 	    curclass.type == CLASS_CHROOT ? 'g' :
   3654  1.118     lukem 	    curclass.type == CLASS_REAL ?   'r' : '?',
   3655  1.118     lukem 
   3656  1.118     lukem 	    curclass.type == CLASS_GUEST ? pw->pw_passwd : pw->pw_name,
   3657  1.118     lukem 	    error != NULL ? 'i' : 'c'
   3658  1.118     lukem 	    );
   3659  1.154     lukem 
   3660  1.154     lukem 	if ((doxferlog & 2) && xferlogfd != -1)
   3661  1.154     lukem 		write(xferlogfd, buf, len);
   3662  1.154     lukem 	if ((doxferlog & 1)) {
   3663  1.154     lukem 		buf[len-1] = '\n';	/* strip \n from syslog message */
   3664  1.154     lukem 		syslog(LOG_INFO, "xferlog: %s", buf);
   3665  1.154     lukem 	}
   3666  1.139     enami }
   3667  1.139     enami 
   3668  1.139     enami /*
   3669  1.139     enami  * Log the resource usage.
   3670  1.139     enami  *
   3671  1.139     enami  * XXX: more resource usage to logging?
   3672  1.139     enami  */
   3673  1.139     enami void
   3674  1.139     enami logrusage(const struct rusage *rusage_before,
   3675  1.139     enami     const struct rusage *rusage_after)
   3676  1.139     enami {
   3677  1.139     enami 	struct timeval usrtime, systime;
   3678  1.139     enami 
   3679  1.139     enami 	if (logging <= 1)
   3680  1.139     enami 		return;
   3681  1.139     enami 
   3682  1.139     enami 	timersub(&rusage_after->ru_utime, &rusage_before->ru_utime, &usrtime);
   3683  1.139     enami 	timersub(&rusage_after->ru_stime, &rusage_before->ru_stime, &systime);
   3684  1.192     lukem 	syslog(LOG_INFO, LLF ".%.03ldu " LLF ".%.03lds %ld+%ldio %ldpf+%ldw",
   3685  1.192     lukem 	    (LLT)usrtime.tv_sec, (long)(usrtime.tv_usec / 1000),
   3686  1.192     lukem 	    (LLT)systime.tv_sec, (long)(systime.tv_usec / 1000),
   3687  1.139     enami 	    rusage_after->ru_inblock - rusage_before->ru_inblock,
   3688  1.139     enami 	    rusage_after->ru_oublock - rusage_before->ru_oublock,
   3689  1.139     enami 	    rusage_after->ru_majflt - rusage_before->ru_majflt,
   3690  1.139     enami 	    rusage_after->ru_nswap - rusage_before->ru_nswap);
   3691  1.115     lukem }
   3692  1.115     lukem 
   3693  1.115     lukem /*
   3694  1.116     lukem  * Determine if `password' is valid for user given in `pw'.
   3695  1.116     lukem  * Returns 2 if password expired, 1 if otherwise failed, 0 if ok
   3696  1.115     lukem  */
   3697  1.115     lukem int
   3698  1.132     lukem checkpassword(const struct passwd *pwent, const char *password)
   3699  1.115     lukem {
   3700  1.189     lukem 	const char *orig;
   3701  1.189     lukem 	char	*new;
   3702  1.161  ginsbach 	time_t	 change, expire, now;
   3703  1.116     lukem 
   3704  1.161  ginsbach 	change = expire = 0;
   3705  1.132     lukem 	if (pwent == NULL)
   3706  1.116     lukem 		return 1;
   3707  1.116     lukem 
   3708  1.161  ginsbach 	time(&now);
   3709  1.132     lukem 	orig = pwent->pw_passwd;	/* save existing password */
   3710  1.132     lukem 	expire = pwent->pw_expire;
   3711  1.189     lukem 	change = pwent->pw_change;
   3712  1.189     lukem 	if (change == _PASSWORD_CHGNOW)
   3713  1.189     lukem 		change = now;
   3714  1.116     lukem 
   3715  1.116     lukem 	if (orig[0] == '\0')		/* don't allow empty passwords */
   3716  1.116     lukem 		return 1;
   3717  1.116     lukem 
   3718  1.116     lukem 	new = crypt(password, orig);	/* encrypt given password */
   3719  1.116     lukem 	if (strcmp(new, orig) != 0)	/* compare */
   3720  1.116     lukem 		return 1;
   3721  1.116     lukem 
   3722  1.162  ginsbach 	if ((expire && now >= expire) || (change && now >= change))
   3723  1.116     lukem 		return 2;		/* check if expired */
   3724  1.115     lukem 
   3725  1.116     lukem 	return 0;			/* OK! */
   3726   1.62     lukem }
   3727   1.62     lukem 
   3728   1.62     lukem char *
   3729  1.171  christos ftpd_strdup(const char *s)
   3730   1.62     lukem {
   3731   1.62     lukem 	char *new = strdup(s);
   3732   1.62     lukem 
   3733   1.62     lukem 	if (new == NULL)
   3734   1.62     lukem 		fatal("Local resource failure: malloc");
   3735   1.62     lukem 		/* NOTREACHED */
   3736   1.62     lukem 	return (new);
   3737   1.95     lukem }
   3738   1.95     lukem 
   3739   1.95     lukem /*
   3740   1.95     lukem  * As per fprintf(), but increment total_bytes and total_bytes_out,
   3741   1.95     lukem  * by the appropriate amount.
   3742   1.95     lukem  */
   3743   1.95     lukem void
   3744   1.95     lukem cprintf(FILE *fd, const char *fmt, ...)
   3745   1.95     lukem {
   3746   1.95     lukem 	off_t b;
   3747   1.95     lukem 	va_list ap;
   3748   1.95     lukem 
   3749   1.95     lukem 	va_start(ap, fmt);
   3750   1.95     lukem 	b = vfprintf(fd, fmt, ap);
   3751  1.130       wiz 	va_end(ap);
   3752   1.95     lukem 	total_bytes += b;
   3753   1.95     lukem 	total_bytes_out += b;
   3754    1.1       cgd }
   3755  1.164  christos 
   3756  1.164  christos #ifdef USE_PAM
   3757  1.164  christos /*
   3758  1.164  christos  * the following code is stolen from imap-uw PAM authentication module and
   3759  1.164  christos  * login.c
   3760  1.164  christos  */
   3761  1.182     lukem typedef struct {
   3762  1.183     lukem 	const char *uname;	/* user name */
   3763  1.183     lukem 	int	    triedonce;	/* if non-zero, tried before */
   3764  1.182     lukem } ftpd_cred_t;
   3765  1.164  christos 
   3766  1.164  christos static int
   3767  1.164  christos auth_conv(int num_msg, const struct pam_message **msg,
   3768  1.164  christos     struct pam_response **resp, void *appdata)
   3769  1.164  christos {
   3770  1.187     lukem 	int i, ret;
   3771  1.183     lukem 	size_t n;
   3772  1.182     lukem 	ftpd_cred_t *cred = (ftpd_cred_t *) appdata;
   3773  1.164  christos 	struct pam_response *myreply;
   3774  1.183     lukem 	char pbuf[FTP_BUFLEN];
   3775  1.164  christos 
   3776  1.183     lukem 	if (num_msg <= 0 || num_msg > PAM_MAX_NUM_MSG)
   3777  1.183     lukem 		return (PAM_CONV_ERR);
   3778  1.164  christos 	myreply = calloc(num_msg, sizeof *myreply);
   3779  1.164  christos 	if (myreply == NULL)
   3780  1.164  christos 		return PAM_BUF_ERR;
   3781  1.164  christos 
   3782  1.164  christos 	for (i = 0; i < num_msg; i++) {
   3783  1.183     lukem 		myreply[i].resp_retcode = 0;
   3784  1.183     lukem 		myreply[i].resp = NULL;
   3785  1.164  christos 		switch (msg[i]->msg_style) {
   3786  1.183     lukem 		case PAM_PROMPT_ECHO_ON:	/* user */
   3787  1.183     lukem 			myreply[i].resp = ftpd_strdup(cred->uname);
   3788  1.164  christos 			/* PAM frees resp. */
   3789  1.164  christos 			break;
   3790  1.183     lukem 		case PAM_PROMPT_ECHO_OFF:	/* authtok (password) */
   3791  1.183     lukem 				/*
   3792  1.183     lukem 				 * Only send a single 331 reply and
   3793  1.183     lukem 				 * then expect a PASS.
   3794  1.183     lukem 				 */
   3795  1.183     lukem 			if (cred->triedonce) {
   3796  1.183     lukem 				syslog(LOG_ERR,
   3797  1.183     lukem 			"auth_conv: already performed PAM_PROMPT_ECHO_OFF");
   3798  1.183     lukem 				goto fail;
   3799  1.183     lukem 			}
   3800  1.183     lukem 			cred->triedonce++;
   3801  1.183     lukem 			if (msg[i]->msg[0] == '\0') {
   3802  1.183     lukem 				(void)strlcpy(pbuf, "password", sizeof(pbuf));
   3803  1.183     lukem 			} else {
   3804  1.185     lukem 					/* Uncapitalize msg */
   3805  1.183     lukem 				(void)strlcpy(pbuf, msg[i]->msg, sizeof(pbuf));
   3806  1.183     lukem 				if (isupper((unsigned char)pbuf[0]))
   3807  1.183     lukem 					pbuf[0] = tolower(
   3808  1.183     lukem 					    (unsigned char)pbuf[0]);
   3809  1.185     lukem 					/* Remove trailing ':' and whitespace */
   3810  1.185     lukem 				n = strlen(pbuf);
   3811  1.185     lukem 				while (n-- > 0) {
   3812  1.185     lukem 					if (isspace((unsigned char)pbuf[n]) ||
   3813  1.185     lukem 					    pbuf[n] == ':')
   3814  1.185     lukem 						pbuf[n] = '\0';
   3815  1.185     lukem 					else
   3816  1.185     lukem 						break;
   3817  1.185     lukem 				}
   3818  1.183     lukem 			}
   3819  1.183     lukem 				/* Send reply, wait for a response. */
   3820  1.183     lukem 			reply(331, "User %s accepted, provide %s.",
   3821  1.183     lukem 			    cred->uname, pbuf);
   3822  1.183     lukem 			(void) alarm(curclass.timeout);
   3823  1.194       roy 			ret = get_line(pbuf, sizeof(pbuf)-1, stdin);
   3824  1.187     lukem 			(void) alarm(0);
   3825  1.187     lukem 			if (ret == -1) {
   3826  1.183     lukem 				reply(221, "You could at least say goodbye.");
   3827  1.183     lukem 				dologout(0);
   3828  1.187     lukem 			} else if (ret == -2) {
   3829  1.187     lukem 			    /* XXX: should we do this reply(-530, ..) ? */
   3830  1.187     lukem 				reply(-530, "Command too long.");
   3831  1.187     lukem 				goto fail;
   3832  1.183     lukem 			}
   3833  1.183     lukem 				/* Ensure it is PASS */
   3834  1.183     lukem 			if (strncasecmp(pbuf, "PASS ", 5) != 0) {
   3835  1.187     lukem 				syslog(LOG_ERR,
   3836  1.187     lukem 				    "auth_conv: unexpected reply '%.4s'", pbuf);
   3837  1.187     lukem 				/* XXX: should we do this reply(-530, ..) ? */
   3838  1.187     lukem 				reply(-530, "Unexpected reply '%.4s'.", pbuf);
   3839  1.187     lukem 				goto fail;
   3840  1.183     lukem 			}
   3841  1.183     lukem 				/* Strip CRLF from "PASS" reply */
   3842  1.183     lukem 			n = strlen(pbuf);
   3843  1.183     lukem 			while (--n >= 5 &&
   3844  1.183     lukem 			    (pbuf[n] == '\r' || pbuf[n] == '\n'))
   3845  1.183     lukem 			    pbuf[n] = '\0';
   3846  1.183     lukem 				/* Copy password into reply */
   3847  1.183     lukem 			myreply[i].resp = ftpd_strdup(pbuf+5);
   3848  1.183     lukem 				/* PAM frees resp. */
   3849  1.164  christos 			break;
   3850  1.164  christos 		case PAM_TEXT_INFO:
   3851  1.164  christos 		case PAM_ERROR_MSG:
   3852  1.164  christos 			break;
   3853  1.164  christos 		default:			/* unknown message style */
   3854  1.183     lukem 			goto fail;
   3855  1.164  christos 		}
   3856  1.164  christos 	}
   3857  1.164  christos 
   3858  1.164  christos 	*resp = myreply;
   3859  1.164  christos 	return PAM_SUCCESS;
   3860  1.183     lukem 
   3861  1.183     lukem  fail:
   3862  1.183     lukem 	free(myreply);
   3863  1.183     lukem 	*resp = NULL;
   3864  1.183     lukem 	return PAM_CONV_ERR;
   3865  1.164  christos }
   3866  1.164  christos 
   3867  1.164  christos /*
   3868  1.164  christos  * Attempt to authenticate the user using PAM.  Returns 0 if the user is
   3869  1.164  christos  * authenticated, or 1 if not authenticated.  If some sort of PAM system
   3870  1.164  christos  * error occurs (e.g., the "/etc/pam.conf" file is missing) then this
   3871  1.164  christos  * function returns -1.  This can be used as an indication that we should
   3872  1.164  christos  * fall back to a different authentication mechanism.
   3873  1.183     lukem  * pw maybe be updated to a new user if PAM_USER changes from curname.
   3874  1.164  christos  */
   3875  1.164  christos static int
   3876  1.183     lukem auth_pam(void)
   3877  1.164  christos {
   3878  1.164  christos 	const char *tmpl_user;
   3879  1.164  christos 	const void *item;
   3880  1.164  christos 	int rval;
   3881  1.164  christos 	int e;
   3882  1.183     lukem 	ftpd_cred_t auth_cred = { curname, 0 };
   3883  1.164  christos 	struct pam_conv conv = { &auth_conv, &auth_cred };
   3884  1.164  christos 
   3885  1.183     lukem 	e = pam_start("ftpd", curname, &conv, &pamh);
   3886  1.164  christos 	if (e != PAM_SUCCESS) {
   3887  1.164  christos 		/*
   3888  1.164  christos 		 * In OpenPAM, it's OK to pass NULL to pam_strerror()
   3889  1.164  christos 		 * if context creation has failed in the first place.
   3890  1.164  christos 		 */
   3891  1.164  christos 		syslog(LOG_ERR, "pam_start: %s", pam_strerror(NULL, e));
   3892  1.164  christos 		return -1;
   3893  1.164  christos 	}
   3894  1.164  christos 
   3895  1.164  christos 	e = pam_set_item(pamh, PAM_RHOST, remotehost);
   3896  1.164  christos 	if (e != PAM_SUCCESS) {
   3897  1.164  christos 		syslog(LOG_ERR, "pam_set_item(PAM_RHOST): %s",
   3898  1.164  christos 			pam_strerror(pamh, e));
   3899  1.164  christos 		if ((e = pam_end(pamh, e)) != PAM_SUCCESS) {
   3900  1.164  christos 			syslog(LOG_ERR, "pam_end: %s", pam_strerror(pamh, e));
   3901  1.164  christos 		}
   3902  1.164  christos 		pamh = NULL;
   3903  1.164  christos 		return -1;
   3904  1.164  christos 	}
   3905  1.164  christos 
   3906  1.179  christos 	e = pam_set_item(pamh, PAM_SOCKADDR, &his_addr);
   3907  1.179  christos 	if (e != PAM_SUCCESS) {
   3908  1.179  christos 		syslog(LOG_ERR, "pam_set_item(PAM_SOCKADDR): %s",
   3909  1.179  christos 			pam_strerror(pamh, e));
   3910  1.179  christos 		if ((e = pam_end(pamh, e)) != PAM_SUCCESS) {
   3911  1.179  christos 			syslog(LOG_ERR, "pam_end: %s", pam_strerror(pamh, e));
   3912  1.179  christos 		}
   3913  1.179  christos 		pamh = NULL;
   3914  1.179  christos 		return -1;
   3915  1.179  christos 	}
   3916  1.179  christos 
   3917  1.164  christos 	e = pam_authenticate(pamh, 0);
   3918  1.185     lukem 	if (ftpd_debug)
   3919  1.185     lukem 		syslog(LOG_DEBUG, "pam_authenticate: user '%s' returned %d",
   3920  1.185     lukem 		    curname, e);
   3921  1.164  christos 	switch (e) {
   3922  1.164  christos 	case PAM_SUCCESS:
   3923  1.164  christos 		/*
   3924  1.164  christos 		 * With PAM we support the concept of a "template"
   3925  1.164  christos 		 * user.  The user enters a login name which is
   3926  1.164  christos 		 * authenticated by PAM, usually via a remote service
   3927  1.164  christos 		 * such as RADIUS or TACACS+.  If authentication
   3928  1.164  christos 		 * succeeds, a different but related "template" name
   3929  1.164  christos 		 * is used for setting the credentials, shell, and
   3930  1.164  christos 		 * home directory.  The name the user enters need only
   3931  1.164  christos 		 * exist on the remote authentication server, but the
   3932  1.164  christos 		 * template name must be present in the local password
   3933  1.164  christos 		 * database.
   3934  1.164  christos 		 *
   3935  1.164  christos 		 * This is supported by two various mechanisms in the
   3936  1.164  christos 		 * individual modules.  However, from the application's
   3937  1.164  christos 		 * point of view, the template user is always passed
   3938  1.164  christos 		 * back as a changed value of the PAM_USER item.
   3939  1.164  christos 		 */
   3940  1.164  christos 		if ((e = pam_get_item(pamh, PAM_USER, &item)) ==
   3941  1.164  christos 		    PAM_SUCCESS) {
   3942  1.164  christos 			tmpl_user = (const char *) item;
   3943  1.183     lukem 			if (pw == NULL
   3944  1.183     lukem 			    || strcmp(pw->pw_name, tmpl_user) != 0) {
   3945  1.183     lukem 				pw = sgetpwnam(tmpl_user);
   3946  1.183     lukem 				if (ftpd_debug)
   3947  1.183     lukem 					syslog(LOG_DEBUG,
   3948  1.185     lukem 					    "auth_pam: PAM changed "
   3949  1.185     lukem 					    "user from '%s' to '%s'",
   3950  1.183     lukem 					    curname, pw->pw_name);
   3951  1.183     lukem 				(void)strlcpy(curname, pw->pw_name,
   3952  1.183     lukem 				    curname_len);
   3953  1.183     lukem 			}
   3954  1.164  christos 		} else
   3955  1.164  christos 			syslog(LOG_ERR, "Couldn't get PAM_USER: %s",
   3956  1.164  christos 			    pam_strerror(pamh, e));
   3957  1.164  christos 		rval = 0;
   3958  1.164  christos 		break;
   3959  1.164  christos 
   3960  1.164  christos 	case PAM_AUTH_ERR:
   3961  1.164  christos 	case PAM_USER_UNKNOWN:
   3962  1.164  christos 	case PAM_MAXTRIES:
   3963  1.164  christos 		rval = 1;
   3964  1.164  christos 		break;
   3965  1.164  christos 
   3966  1.164  christos 	default:
   3967  1.164  christos 		syslog(LOG_ERR, "pam_authenticate: %s", pam_strerror(pamh, e));
   3968  1.164  christos 		rval = -1;
   3969  1.164  christos 		break;
   3970  1.164  christos 	}
   3971  1.164  christos 
   3972  1.164  christos 	if (rval == 0) {
   3973  1.164  christos 		e = pam_acct_mgmt(pamh, 0);
   3974  1.164  christos 		if (e != PAM_SUCCESS) {
   3975  1.164  christos 			syslog(LOG_ERR, "pam_acct_mgmt: %s",
   3976  1.164  christos 						pam_strerror(pamh, e));
   3977  1.164  christos 			rval = 1;
   3978  1.164  christos 		}
   3979  1.164  christos 	}
   3980  1.164  christos 
   3981  1.164  christos 	if (rval != 0) {
   3982  1.164  christos 		if ((e = pam_end(pamh, e)) != PAM_SUCCESS) {
   3983  1.164  christos 			syslog(LOG_ERR, "pam_end: %s", pam_strerror(pamh, e));
   3984  1.164  christos 		}
   3985  1.164  christos 		pamh = NULL;
   3986  1.164  christos 	}
   3987  1.164  christos 	return rval;
   3988  1.164  christos }
   3989  1.164  christos 
   3990  1.164  christos #endif /* USE_PAM */
   3991