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