#pragma ident "%Z%%M% %I% %E% SMI"

#include "config.h"

#include <sys/types.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <sys/file.h>

#include <sys/wait.h>

#ifdef AIX

#include <sys/id.h>

#include <sys/priv.h>

#include <netinet/if_ether.h>

#include <net/if_dl.h>

#endif

#ifdef AUX

#include <compat.h>

#endif

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#define FTP_NAMES

#include <arpa/ftp.h>

#include <arpa/inet.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <signal.h>

#include <pwd.h>

#include <grp.h>

#include <setjmp.h>

#include <errno.h>

#include <string.h>

#ifdef INTERNAL_LS

#ifdef HAVE_GLOB_H

#include <glob.h>

#else

#include <wuftpd_glob.h>

#endif

#endif

#ifdef HAVE_GRP_H

#include <grp.h>

#endif

#include <sys/stat.h>

#define VA_LOCAL_DECL va_list ap;

#define VA_START(f) va_start(ap, f)

#define VA_END va_end(ap)

#include "proto.h"

#ifdef HAVE_UFS_QUOTA_H

#include <ufs/quota.h>

#endif

#ifdef HAVE_SYS_FS_UFS_QUOTA_H

#include <sys/fs/ufs_quota.h>

#endif

#ifdef HAVE_SYS_SYSLOG_H

#include <sys/syslog.h>

#endif

#if defined(HAVE_SYSLOG_H) || (!defined(AUTOCONF) && !defined(HAVE_SYS_SYSLOG_H))

#include <syslog.h>

#endif

#ifdef TIME_WITH_SYS_TIME

#include <time.h>

#include <sys/time.h>

#else

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#else

#include <time.h>

#endif

#endif

#ifdef HAVE_SYS_SENDFILE_H

#include <sys/sendfile.h>

#endif

#include "conversions.h"

#include "extensions.h"

#ifdef SHADOW_PASSWORD

#include <shadow.h>

#endif

#include "pathnames.h"

#ifdef M_UNIX

#include <arpa/nameser.h>

#include <resolv.h>

#endif

#if defined(HAVE_FCNTL_H)

#include <fcntl.h>

#endif

#ifdef HAVE_SYSINFO

#include <sys/systeminfo.h>

#endif

#ifdef KERBEROS

#include <sys/types.h>

#include <auth.h>

#include <krb.h>

#endif

#ifdef ULTRIX_AUTH

#include <auth.h>

#include <sys/svcinfo.h>

#endif

#ifndef HAVE_LSTAT

#define lstat stat

#endif

#ifdef AFS_AUTH

#include <afs/stds.h>

#include <afs/kautils.h>

#endif

#ifdef DCE_AUTH

#include <dce/rpc.h>

#include <dce/sec_login.h>

#include <dce/dce_error.h>

#endif

#ifdef HAVE_DIRENT_H

#include <dirent.h>

#else

#include <sys/dir.h>

#endif

#if defined(USE_LONGJMP)

#define wu_longjmp(x, y) longjmp((x), (y))

#define wu_setjmp(x) setjmp(x)

#ifndef JMP_BUF

#define JMP_BUF jmp_buf

#endif

#else

#define wu_longjmp(x, y) siglongjmp((x), (y))

#define wu_setjmp(x) sigsetjmp((x), 1)

#ifndef JMP_BUF

#define JMP_BUF sigjmp_buf

#endif

#endif

#ifndef MAXHOSTNAMELEN

#define MAXHOSTNAMELEN 64 /* may be too big */

#endif

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE !TRUE

#endif

#ifdef MAIL_ADMIN

#define MAILSERVERS 10

#define INCMAILS 10

int mailservers = 0;

char *mailserver[MAILSERVERS];

int incmails = 0;

char *incmail[INCMAILS];

char *mailfrom;

char *email(char *full_address);

FILE *SockOpen(char *host, int clientPort);

char *SockGets(FILE *sockfp, char *buf, int len);

int SockWrite(char *buf, int size, int nels, FILE *sockfp);

int SockPrintf(FILE *sockfp, char *format,...);

int SockPuts(FILE *sockfp, char *buf);

int Reply(FILE *sockfp);

int Send(FILE *sockfp, char *format,...);

#endif /* MAIL_ADMIN */

#if defined(_SCO_DS) && !defined(SIGURG)

#define SIGURG SIGUSR1

#endif

extern int errno;

extern char *ctime(const time_t *);

#ifndef NO_CRYPT_PROTO

extern char *crypt(const char *, const char *);

#endif

extern char version[];

extern char *home; /* pointer to home directory for glob */

extern char cbuf[];

extern off_t restart_point;

extern int yyerrorcalled;

struct SOCKSTORAGE ctrl_addr;

struct SOCKSTORAGE data_source;

struct SOCKSTORAGE data_dest;

struct SOCKSTORAGE his_addr;

struct SOCKSTORAGE pasv_addr;

struct SOCKSTORAGE vect_addr;

int route_vectored = 0;

int passive_port_min = 1024;

int passive_port_max = 65535;

int restricted_user = 0;

unsigned short data_port = 0;

#ifdef INET6

int ctrl_v4mapped = 0;

int epsv_all = 0;

int listen_v4 = 0; /* when set, listen on IPv4 socket in standalone mode */

#endif

#ifdef VIRTUAL

char virtual_root[MAXPATHLEN];

char virtual_banner[MAXPATHLEN];

char virtual_email[MAXPATHLEN];

char virtual_hostname[MAXHOSTNAMELEN];

char virtual_address[MAXHOSTNAMELEN];

extern int virtual_mode;

extern int virtual_ftpaccess;

#endif

#ifdef QUOTA

extern struct dqblk quota;

#endif

#if defined(USE_GSS)

#include "gssutil.h"

extern gss_info_t gss_info;

int allow_ccc = 0;

int ccc_ok = 0;

extern char *cur_auth_type;

#endif /* USE_GSS */

int data;

jmp_buf errcatch;

JMP_BUF urgcatch;

int logged_in = 0;

struct passwd *pw;

char chroot_path[MAXPATHLEN];

int debug = 0;

int disable_rfc931 = 0;

extern unsigned int timeout_idle;

extern unsigned int timeout_maxidle;

extern unsigned int timeout_data;

extern unsigned int timeout_accept;

extern unsigned int timeout_connect;

int logging = 0;

int log_commands = 0;

int log_security = 0;

int syslogmsg = 0;

static int wtmp_logging = 1;

#ifdef SECUREOSF

#define SecureWare /* Does this mean it works for all SecureWare? */

#endif

#ifdef HPUX_10_TRUSTED

#include <hpsecurity.h>

#endif

#if defined(SecureWare) || defined(HPUX_10_TRUSTED)

#include <prot.h>

#endif

int anonymous = 1;

int guest;

int type;

int form;

int stru; /* avoid C keyword */

int mode;

int usedefault = 1; /* for data transfers */

int pdata = -1; /* for passive mode */

int transflag;

int ftwflag;

off_t file_size;

off_t byte_count;

int TCPwindowsize = 0; /* 0 = use system default */

size_t sendbufsz; /* buffer size to use when sending data */

size_t recvbufsz; /* buffer size to use when receiving data */

#ifdef TRANSFER_COUNT

off_t data_count_total = 0; /* total number of data bytes */

off_t data_count_in = 0;

off_t data_count_out = 0;

off_t byte_count_total = 0; /* total number of general traffic */

off_t byte_count_in = 0;

off_t byte_count_out = 0;

int file_count_total = 0; /* total number of data files */

int file_count_in = 0;

int file_count_out = 0;

int xfer_count_total = 0; /* total number of transfers */

int xfer_count_in = 0;

int xfer_count_out = 0;

#ifdef TRANSFER_LIMIT

int file_limit_raw_in = 0;

int file_limit_raw_out = 0;

int file_limit_raw_total = 0;

int file_limit_data_in = 0;

int file_limit_data_out = 0;

int file_limit_data_total = 0;

off_t data_limit_raw_in = 0;

off_t data_limit_raw_out = 0;

off_t data_limit_raw_total = 0;

off_t data_limit_data_in = 0;

off_t data_limit_data_out = 0;

off_t data_limit_data_total = 0;

#ifdef RATIO /* 1998/08/04 K.Wakui */

#define TRUNC_KB(n) ((n)/1024+(((n)%1024)?1:0))

off_t total_free_dl = 0;

int upload_download_rate = 0;

int freefile;

int is_downloadfree( char * );

#endif /* RATIO */

#endif

#endif

int retrieve_is_data = 1; /* !0=data, 0=general traffic -- for 'ls' */

char LastFileTransferred[MAXPATHLEN] = "";

static char *RootDirectory = NULL;

#if !defined(CMASK) || CMASK == 0

#undef CMASK

#define CMASK 022

#endif

mode_t defumask = CMASK; /* default umask value */

#ifdef ALTERNATE_CD

char defhome[] = "/";

#endif

char tmpline[7];

char hostname[MAXHOSTNAMELEN];

char remotehost[MAXHOSTNAMELEN];

char remoteaddr[MAXHOSTNAMELEN];

char *remoteident = "[nowhere yet]";

int rhlookup = TRUE; /* when TRUE lookup the remote hosts name */

#define MAXUSERNAMELEN 256

char the_user[MAXUSERNAMELEN];

int use_accessfile = 0;

char guestpw[MAXHOSTNAMELEN];

char privatepw[MAXHOSTNAMELEN];

int nameserved = 0;

extern char authuser[];

extern int authenticated;

extern int keepalive;

int xferlog = 0;

int log_outbound_xfers = 0;

int log_incoming_xfers = 0;

char logfile[MAXPATHLEN];

int dolreplies = 1;

char *autospout = NULL;

int autospout_free = 0;

int mangleopts = 0;

int lgi_failure_threshold = 5;

#define SWAITMAX 90 /* wait at most 90 seconds */

#define SWAITINT 5 /* interval between retries */

int swaitmax = SWAITMAX;

int swaitint = SWAITINT;

SIGNAL_TYPE lostconn(int sig);

SIGNAL_TYPE randomsig(int sig);

SIGNAL_TYPE myoob(int sig);

FILE *getdatasock(char *mode);

FILE *dataconn(char *name, off_t size, char *mode);

void setproctitle(const char *fmt,...);

void initsetproctitle(int, char **, char **);

void reply(int, char *fmt,...);

void lreply(int, char *fmt,...);

#ifndef HAVE_VSNPRINTF

extern int vsnprintf(char *, size_t, const char *, va_list);

#endif

#ifndef HAVE_SNPRINTF

extern int snprintf(char *, size_t, const char *,...);

#endif

#ifdef NEED_SIGFIX

extern sigset_t block_sigmask; /* defined in sigfix.c */

#endif

char proctitle[BUFSIZ]; /* initial part of title */

#if defined(SKEY) && defined(OPIE)

#error YOU SHOULD NOT HAVE BOTH SKEY AND OPIE DEFINED!!!!!

#endif

#ifdef SKEY

#include <skey.h>

int pwok = 0;

#endif

#ifdef OPIE

#include <opie.h>

int pwok = 0;

int af_pwok = 0;

struct opie opiestate;

#endif

#ifdef KERBEROS

void init_krb();

void end_krb();

char krb_ticket_name[100];

#endif /* KERBEROS */

#ifdef ULTRIX_AUTH

int ultrix_check_pass(char *passwd, char *xpasswd);

#endif

#ifdef USE_PAM

#if defined(ULTRIX_AUTH) || defined(SECUREOSF) || defined(KERBEROS) || defined(SKEY) || defined (OPIE) || defined (BSD_AUTH)

#error No other auth methods are allowed with PAM.

#endif

#include <security/pam_appl.h>

static int pam_check_pass(char *user, char *passwd);

pam_handle_t *pamh;

#endif

#ifndef INTERNAL_LS

char ls_long[BUFSIZ * 2];

char ls_short[BUFSIZ * 2];

char ls_plain[BUFSIZ * 2];

#endif

#define FTPD_OPTS ":4aAdiIlLoP:qQr:t:T:u:vVwWxX"

#if defined(DAEMON)

# define DAEMON_OPTS "p:sS"

#else /* !(defined(DAEMON)) */

# define DAEMON_OPTS

#endif /* !(defined(DAEMON)) */

#if defined(USE_GSS)

# define GSS_OPTS "CK"

#else /* !(defined(USE_GSS)) */

# define GSS_OPTS

#endif /* !(defined(USE_GSS)) */

#ifndef L_FORMAT /* Autoconf detects this... */

#if (defined(BSD) && (BSD >= 199103)) && !defined(LONGOFF_T)

#define L_FORMAT "qd"

#else

#ifdef _AIX42

#define L_FORMAT "lld"

#else

#ifdef SOLARIS_2

#define L_FORMAT "ld"

#else

#define L_FORMAT "d"

#endif

#endif

#endif

#endif

#ifdef DAEMON

int be_daemon = 0; /* Run standalone? */

int daemon_port = 0;

static void do_daemon(void);

#endif

int Bypass_PID_Files = 0;

#ifdef OTHER_PASSWD

#include "getpwnam.h"

char _path_passwd[MAXPATHLEN];

#ifdef SHADOW_PASSWORD

char _path_shadow[MAXPATHLEN];

#endif

#endif

#if defined(USE_PAM) && defined(OTHER_PASSWD)

int use_pam = 1;

#else

int use_pam = 0;

#endif

void print_copyright(void);

char *mapping_getcwd(char *path, size_t size);

void dolog(struct SOCKSTORAGE *);

#ifdef THROUGHPUT

extern void throughput_calc(char *, int *, double *);

extern void throughput_adjust(char *);

#endif

time_t login_time;

time_t limit_time = 0;

int regexmatch(char *name, char *rgexp);

int pasv_allowed(char *remoteaddr);

int port_allowed(char *remoteaddr);

#if sparc && !__svr4__

int fclose(FILE *);

#endif

static SIGNAL_TYPE alarm_signal(int sig)

{

}

static FILE *draconian_FILE = NULL;

static SIGNAL_TYPE draconian_alarm_signal(int sig)

{

if (draconian_FILE != NULL) {

fclose(draconian_FILE);

draconian_FILE = NULL;

}

(void) signal(SIGALRM, draconian_alarm_signal);

}

static void socket_flush_wait(FILE *file)

{

static int flushwait = TRUE;

static int first_time = TRUE;

char c;

int set;

int fd = fileno(file);

int serrno = errno;

struct aclmember *entry;

if (first_time) {

entry = NULL;

/* flush-wait yes|no [typelist] */

while (getaclentry("flush-wait", &entry)) {

if (!ARG0)

continue;

if (strcasecmp(ARG0, "yes") == 0)

set = TRUE;

else if (strcasecmp(ARG0, "no") == 0)

set = FALSE;

else

continue;

if (!ARG1)

flushwait = set;

else if (type_match(ARG1)) {

flushwait = set;

break;

}

}

first_time = FALSE;

}

if (flushwait) {

if (draconian_FILE != NULL)

shutdown(fd, 1);

if (draconian_FILE != NULL)

read(fd, &c, 1);

}

errno = serrno;

}

static int IPClassOfService(const char *type)

{

int ipcos = -1, value;

char *endp;

struct aclmember *entry = NULL;

/* ipcos control|data <value> [<typelist>] */

while (getaclentry("ipcos", &entry)) {

if (ARG0 && ARG1) {

if (strcasecmp(type, ARG0) == 0) {

if (!ARG2) {

errno = 0;

value = (int) strtol(ARG1, &endp, 0);

if ((errno == 0) && (value >= 0) && (*endp == '\0'))

ipcos = value;

}

else if (type_match(ARG2)) {

errno = 0;

value = (int) strtol(ARG1, &endp, 0);

if ((errno == 0) && (value >= 0) && (*endp == '\0')) {

ipcos = value;

break;

}

}

}

}

}

return ipcos;

}

int main(int argc, char **argv, char **envp)

{

#if defined(UNIXWARE) || defined(AIX)

size_t addrlen;

#else

int addrlen;

#endif

int on = 1;

int cos;

int c;

#ifndef INTERNAL_LS

int which;

#endif

extern int optopt;

extern char *optarg;

char *hp;

struct aclmember *entry;

#ifdef VIRTUAL

#if defined(UNIXWARE) || defined(AIX)

size_t virtual_len;

#else

int virtual_len;

#endif

struct SOCKSTORAGE virtual_addr;

#endif

struct servent *serv;

#ifdef AUX

setcompat(COMPAT_POSIX | COMPAT_BSDSETUGID);

#endif

closelog();

#ifdef FACILITY

openlog("ftpd", LOG_PID | LOG_NDELAY, FACILITY);

#else

openlog("ftpd", LOG_PID);

#endif

#ifdef SecureWare

setluid(1); /* make sure there is a valid luid */

set_auth_parameters(argc, argv);

setreuid(0, 0);

#endif

#if defined(M_UNIX) && !defined(_M_UNIX)

res_init(); /* bug in old (1.1.1) resolver */

_res.retrans = 20; /* because of fake syslog in 3.2.2 */

setlogmask(LOG_UPTO(LOG_INFO));

#endif

while ((c = getopt(argc, argv, FTPD_OPTS DAEMON_OPTS GSS_OPTS)) != -1) {

switch (c) {

case '4':

#ifdef INET6

listen_v4 = 1;

#endif

break;

case 'a':

use_accessfile = 1;

break;

case 'A':

use_accessfile = 0;

break;

case 'v':

debug = 1;

break;

case 'd':

debug = 1;

break;

#if defined(USE_GSS)

case 'C':

gss_info.want_creds = 1;

break;

case 'K':

gss_info.must_gss_auth = 1;

break;

#endif /* USE_GSS */

case 'l':

logging = 1;

break;

case 'L':

log_commands = 3;

break;

case 'i':

log_incoming_xfers = 3;

break;

case 'I':

disable_rfc931 = 1;

break;

case 'o':

log_outbound_xfers = 3;

break;

case 'q':

Bypass_PID_Files = 0;

break;

case 'Q':

Bypass_PID_Files = 1;

break;

case 'r':

if ((optarg != NULL) && (optarg[0] != '\0')) {

RootDirectory = malloc(strlen(optarg) + 1);

if (RootDirectory != NULL)

strcpy(RootDirectory, optarg);

}

break;

case 'P':

data_port = htons(atoi(optarg));

break;

#ifdef DAEMON

case 'p':

daemon_port = atoi(optarg);

break;

case 's':

be_daemon = 1;

break;

case 'S':

be_daemon = 2;

break;

#endif /* DAEMON */

case 't':

timeout_idle = atoi(optarg);

if (timeout_maxidle < timeout_idle)

timeout_maxidle = timeout_idle;

break;

case 'T':

timeout_maxidle = atoi(optarg);

if (timeout_idle > timeout_maxidle)

timeout_idle = timeout_maxidle;

break;

case 'u':

{

unsigned int val = 0;

while (*optarg && *optarg >= '0' && *optarg <= '7')

val = val * 8 + *optarg++ - '0';

if (*optarg || val > 0777)

syslog(LOG_ERR, "bad value for -u");

else

defumask = val;

break;

}

case 'V':

print_copyright();

exit(0);

/* NOTREACHED */

case 'w':

wtmp_logging = 1;

break;

case 'W':

wtmp_logging = 0;

break;

case 'x':

syslogmsg = 2;

break;

case 'X':

syslogmsg = 1;

break;

case ':':

syslog(LOG_ERR, "option -%c requires an argument", optopt);

break;

default:

syslog(LOG_ERR, "unknown option -%c ignored", optopt);

break;

}

}

initsetproctitle(argc, argv, envp);

(void) freopen(_PATH_DEVNULL, "w", stderr);

/* Checking for random signals ... */

#ifdef NEED_SIGFIX

sigemptyset(&block_sigmask);

#endif

#ifndef SIG_DEBUG

#ifdef SIGHUP

(void) signal(SIGHUP, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGHUP);

#endif

#endif

#ifdef SIGINT

(void) signal(SIGINT, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGINT);

#endif

#endif

#ifdef SIGQUIT

(void) signal(SIGQUIT, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGQUIT);

#endif

#endif

#ifdef SIGILL

(void) signal(SIGILL, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGILL);

#endif

#endif

#ifdef SIGTRAP

(void) signal(SIGTRAP, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGTRAP);

#endif

#endif

#ifdef SIGIOT

(void) signal(SIGIOT, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGIOT);

#endif

#endif

#ifdef SIGEMT

(void) signal(SIGEMT, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGEMT);

#endif

#endif

#ifdef SIGFPE

(void) signal(SIGFPE, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGFPE);

#endif

#endif

#ifdef SIGKILL

(void) signal(SIGKILL, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGKILL);

#endif

#endif

#ifdef SIGBUS

(void) signal(SIGBUS, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGBUS);

#endif

#endif

#ifdef SIGSEGV

(void) signal(SIGSEGV, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGSEGV);

#endif

#endif

#ifdef SIGSYS

(void) signal(SIGSYS, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGSYS);

#endif

#endif

#ifdef SIGALRM

(void) signal(SIGALRM, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGALRM);

#endif

#endif

#ifdef SIGSTOP

(void) signal(SIGSTOP, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGSTOP);

#endif

#endif

#ifdef SIGTSTP

(void) signal(SIGTSTP, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGTSTP);

#endif

#endif

#ifdef SIGTTIN

(void) signal(SIGTTIN, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGTTIN);

#endif

#endif

#ifdef SIGTTOU

(void) signal(SIGTTOU, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGTTOU);

#endif

#endif

#ifdef SIGIO

(void) signal(SIGIO, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGIO);

#endif

#endif

#ifdef SIGXCPU

(void) signal(SIGXCPU, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGXCPU);

#endif

#endif

#ifdef SIGXFSZ

(void) signal(SIGXFSZ, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGXFSZ);

#endif

#endif

#ifdef SIGWINCH

(void) signal(SIGWINCH, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGWINCH);

#endif

#endif

#ifdef SIGVTALRM

(void) signal(SIGVTALRM, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGVTALRM);

#endif

#endif

#ifdef SIGPROF

(void) signal(SIGPROF, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGPROF);

#endif

#endif

#ifdef SIGUSR1

(void) signal(SIGUSR1, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGUSR1);

#endif

#endif

#ifdef SIGUSR2

(void) signal(SIGUSR2, randomsig);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGUSR2);

#endif

#endif

#ifdef SIGPIPE

(void) signal(SIGPIPE, lostconn);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGPIPE);

#endif

#endif

#ifdef SIGCHLD

(void) signal(SIGCHLD, SIG_IGN);

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGCHLD);

#endif

#endif

#ifdef SIGURG

if (signal(SIGURG, myoob) == SIG_ERR)

syslog(LOG_ERR, "signal: %m");

#ifdef NEED_SIGFIX

sigaddset(&block_sigmask, SIGURG);

#endif

#endif

#endif /* SIG_DEBUG */

#ifdef VIRTUAL

virtual_root[0] = '\0';

virtual_banner[0] = '\0';

#endif

setup_paths();

#ifdef OTHER_PASSWD

strcpy(_path_passwd, "/etc/passwd");

#ifdef SHADOW_PASSWORD

strcpy(_path_shadow, "/etc/shadow");

#endif

#endif

access_init();

#ifdef DAEMON

if (be_daemon != 0)

do_daemon();

else {

#endif

addrlen = sizeof(his_addr);

if (getpeername(0, (struct sockaddr *) &his_addr, &addrlen) < 0) {

syslog(LOG_ERR, "getpeername: %m");

#ifndef DEBUG

exit(1);

#endif

}

#ifdef DAEMON

}

#endif

addrlen = sizeof(ctrl_addr);

if (getsockname(0, (struct sockaddr *) &ctrl_addr, &addrlen) < 0) {

syslog(LOG_ERR, "getsockname: %m");

#ifndef DEBUG

exit(1);

#endif

}

/* Sanity check */

if ((SOCK_FAMILY(ctrl_addr) != AF_INET)

#ifdef INET6

&& (SOCK_FAMILY(ctrl_addr) != AF_INET6)

#endif

) {

syslog(LOG_ERR, "control connection address family (%d) not supported.",

SOCK_FAMILY(ctrl_addr));

#ifndef DEBUG

exit(1);

#endif

}

#ifdef SOLARIS_BSM_AUDIT

/* Set audit characteristics */

if (audit_settid(0)) {

syslog(LOG_ERR, "audit failure");

exit(1);

}

#endif

#ifdef INET6

/* IP_TOS is an IPv4 socket option */

if (SOCK_FAMILY(ctrl_addr) == AF_INET)

#endif

if ((cos = IPClassOfService("control")) >= 0) {

if (setsockopt(0, IPPROTO_IP, IP_TOS, (char *) &cos, sizeof(int)) < 0)

syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");

}

#ifdef TCP_NODELAY

/*

if (setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &on, sizeof (on)) < 0)

syslog(LOG_WARNING, "control setsockopt TCP_NODELAY: %m");

#endif

if (keepalive)

if (setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, (char *) &on, sizeof(on)) < 0)

syslog(LOG_ERR, "setsockopt SO_KEEPALIVE %m");

/* Try to handle urgent data inline */

#ifdef SO_OOBINLINE

if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, (char *) &on, sizeof(int)) < 0)

syslog(LOG_ERR, "setsockopt (SO_OOBINLINE): %m");

#endif

#ifdef F_SETOWN

if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1)

syslog(LOG_ERR, "fcntl F_SETOWN: %m");

#elif defined(SIOCSPGRP)

{

int pid;

pid = getpid();

if (ioctl(fileno(stdin), SIOCSPGRP, &pid) == -1)

syslog(LOG_ERR, "ioctl SIOCSPGRP: %m");

}

#endif

#ifdef INET6

if ((SOCK_FAMILY(ctrl_addr) == AF_INET6) &&

IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&(ctrl_addr))->sin6_addr))

ctrl_v4mapped = 1;

#endif

if (data_port == 0) {

serv = getservbyname("ftp-data", "tcp");

if (serv != NULL)

data_port = serv->s_port;

else

data_port = htons(ntohs(SOCK_PORT(ctrl_addr)) - 1);

}

if (RootDirectory != NULL) {

if ((chroot(RootDirectory) < 0)

|| (chdir("/") < 0)) {

syslog(LOG_ERR, "Cannot chroot to initial directory, aborting.");

exit(1);

}

}

load_timeouts();

/* set resolver options */

set_res_options();

dolog(&his_addr);

/* Set up default state */

data = -1;

type = TYPE_A;

form = FORM_N;

stru = STRU_F;

mode = MODE_S;

tmpline[0] = '\0';

yyerrorcalled = 0;

entry = (struct aclmember *) NULL;

if ((getaclentry("hostname", &entry)) && ARG0) {

(void) strncpy(hostname, ARG0, sizeof(hostname));

hostname[sizeof(hostname) - 1] = '\0';

}

else {

#ifdef HAVE_SYSINFO

sysinfo(SI_HOSTNAME, hostname, sizeof(hostname));

#else

(void) gethostname(hostname, sizeof(hostname));

#endif

hp = wu_gethostbyname(hostname);

if (hp) {

(void) strncpy(hostname, hp, sizeof(hostname));

hostname[sizeof(hostname) - 1] = '\0';

}

}

route_vectored = routevector();

conv_init();

#ifdef MAIL_ADMIN

incmails = 0;

mailfrom = NULL;

#endif /* MAIL_ADMIN */

#ifdef VIRTUAL

/*

if (virtual_mode) {

/* Get the root of the virtual server directory */

entry = (struct aclmember *) NULL;

if (getaclentry("root", &entry)) {

if (ARG0)

strcpy(virtual_root, ARG0);

}

/* Get the logfile to use */

entry = (struct aclmember *) NULL;

if (getaclentry("logfile", &entry)) {

if (ARG0)

strcpy(logfile, ARG0);

}

}

else {

virtual_hostname[0] = '\0';

virtual_address[0] = '\0';

virtual_len = sizeof(virtual_addr);

if (getsockname(0, (struct sockaddr *) &virtual_addr, &virtual_len) == 0) {

strcpy(virtual_address, inet_stop(&virtual_addr));

wu_gethostbyaddr(&virtual_addr, virtual_hostname, sizeof(virtual_hostname));

entry = (struct aclmember *) NULL;

while (getaclentry("virtual", &entry)) {

if (!ARG0 || !ARG1 || !ARG2)

continue;

if (hostmatch(ARG0, virtual_address, virtual_hostname)) {

if (!strcasecmp(ARG1, "root")) {

if (debug)

syslog(LOG_DEBUG, "VirtualFTP Connect to: %s [%s]",

virtual_hostname, virtual_address);

virtual_mode = 1;

strncpy(virtual_root, ARG2, sizeof(virtual_root));

virtual_root[sizeof(virtual_root) - 1] = '\0';

/* reset hostname to this virtual name */

(void) strcpy(hostname, virtual_hostname);

virtual_email[0] = '\0';

}

if (!strcasecmp(ARG1, "banner")) {

strncpy(virtual_banner, ARG2, sizeof(virtual_banner));

virtual_banner[sizeof(virtual_banner) - 1] = '\0';

}

if (!strcasecmp(ARG1, "logfile")) {

strncpy(logfile, ARG2, sizeof(logfile));

logfile[sizeof(logfile) - 1] = '\0';

}

if (!strcasecmp(ARG1, "hostname")) {

strncpy(hostname, ARG2, sizeof(hostname));

hostname[sizeof(hostname) - 1] = '\0';

}

if (!strcasecmp(ARG1, "email")) {

strncpy(virtual_email, ARG2, sizeof(virtual_email));

virtual_email[sizeof(virtual_email) - 1] = '\0';

}

#ifdef OTHER_PASSWD

if (!strcasecmp(ARG1, "passwd")) {

strncpy(_path_passwd, ARG2, sizeof(_path_passwd));

_path_passwd[sizeof(_path_passwd) - 1] = '\0';

#ifdef USE_PAM

use_pam = 0;

#endif

}

#ifdef SHADOW_PASSWORD

if (!strcasecmp(ARG1, "shadow")) {

strncpy(_path_shadow, ARG2, sizeof(_path_shadow));

_path_shadow[sizeof(_path_shadow) - 1] = '\0';

#ifdef USE_PAM

use_pam = 0;

#endif

}

#endif

#endif

#ifdef MAIL_ADMIN

if (mailfrom == NULL)

if (!strcasecmp(ARG1, "mailfrom")) {

mailfrom = strdup(ARG2);

}

if (!strcasecmp(ARG1, "incmail")) {

if (incmails < INCMAILS)

incmail[incmails++] = strdup(ARG2);

}

#endif

}

}

if (!virtual_mode) {

entry = (struct aclmember *) NULL;

while (getaclentry("defaultserver", &entry)) {

if (!ARG0 || !ARG1)

continue;

#ifdef MAIL_ADMIN

if (mailfrom == NULL)

if (!strcasecmp(ARG0, "mailfrom")) {

mailfrom = strdup(ARG1);

}

if (!strcasecmp(ARG0, "incmail")) {

if (incmails < INCMAILS)

incmail[incmails++] = strdup(ARG1);

}

#endif

}

}

}

}

#ifdef VIRTUAL_DEBUG

lreply(220, "_path_ftpaccess == %s", _path_ftpaccess);

lreply(220, "_path_ftpusers == %s", _path_ftpusers);

lreply(220, "_path_ftphosts == %s", _path_ftphosts);

lreply(220, "_path_private == %s", _path_private);

lreply(220, "_path_cvt == %s", _path_cvt);

if (virtual_mode) {

if (virtual_ftpaccess)

lreply(220, "VIRTUAL Mode: Using %s specific %s access file",

hostname, _path_ftpaccess);

else

lreply(220, "VIRTUAL Mode: Using Master access file %s",

_path_ftpaccess);

lreply(220, "virtual_root == %s", virtual_root);

if (!virtual_ftpaccess)

lreply(220, "virtual_banner == %s", virtual_banner);

}

lreply(220, "logfile == %s", logfile);

#endif

#endif

if (is_shutdown(1, 1) != 0) {

syslog(LOG_INFO, "connection refused (server shut down) from %s",

remoteident);

reply(500, "%s FTP server shut down -- please try again later.",

hostname);

exit(0);

}

#ifdef OPIE

af_pwok = opieaccessfile(remotehost);

#endif

/* check permitted access based on name and address lookup of remote host */

if (!check_rhost_reverse()) {

exit(0);

}

if (!check_rhost_matches()) {

exit(0);

}

show_banner(220);

#ifndef INTERNAL_LS

entry = (struct aclmember *) NULL;

if (getaclentry("lslong", &entry) && ARG0 && (int) strlen(ARG0) > 0) {

strcpy(ls_long, ARG0);

for (which = 1; (which < MAXARGS) && ARG[which]; which++) {

strcat(ls_long, " ");

strcat(ls_long, ARG[which]);

}

}

else {

#if defined(SVR4) || defined(ISC)

#if defined(AIX) || defined(SOLARIS_2)

strcpy(ls_long, "/bin/ls -lA");

#else

strcpy(ls_long, "/bin/ls -la");

#endif

#else

strcpy(ls_long, "/bin/ls -lgA");

#endif

}

strcat(ls_long, " %s");

entry = (struct aclmember *) NULL;

if (getaclentry("lsshort", &entry) && ARG0 && (int) strlen(ARG0) > 0) {

strcpy(ls_short, ARG0);

for (which = 1; (which < MAXARGS) && ARG[which]; which++) {

strcat(ls_short, " ");

strcat(ls_short, ARG[which]);

}

}

else {

#if defined(SVR4) || defined(ISC)

#if defined(AIX) || defined(SOLARIS_2)

strcpy(ls_short, "/bin/ls -lA");

#else

strcpy(ls_short, "/bin/ls -la");

#endif

#else

strcpy(ls_short, "/bin/ls -lgA");

#endif

}

strcat(ls_short, " %s");

entry = (struct aclmember *) NULL;

if (getaclentry("lsplain", &entry) && ARG0 && (int) strlen(ARG0) > 0) {

strcpy(ls_plain, ARG0);

for (which = 1; (which < MAXARGS) && ARG[which]; which++) {

strcat(ls_plain, " ");

strcat(ls_plain, ARG[which]);

}

}

else

strcpy(ls_plain, "/bin/ls");

strcat(ls_plain, " %s");

#endif /* ! INTERNAL_LS */

#ifdef MAIL_ADMIN

mailservers = 0;

entry = (struct aclmember *) NULL;

while (getaclentry("mailserver", &entry) && ARG0 && mailservers < MAILSERVERS)

mailserver[mailservers++] = strdup(ARG0);

if (mailservers == 0)

mailserver[mailservers++] = strdup("localhost");

if (incmails == 0) {

entry = (struct aclmember *) NULL;

while (getaclentry("incmail", &entry) && ARG0 && incmails < INCMAILS)

incmail[incmails++] = strdup(ARG0);

}

if (mailfrom == NULL) {

entry = (struct aclmember *) NULL;

if (getaclentry("mailfrom", &entry) && ARG0)

mailfrom = strdup(ARG0);

else

mailfrom = strdup("wu-ftpd");

}

#endif /* MAIL_ADMIN */

{

#define OUTPUT_LEN (BUFSIZ * 2)

int version_option = 0;

char output_text[OUTPUT_LEN + 1];

int which;

entry = NULL;

if (getaclentry("greeting", &entry) && ARG0) {

if (!strcasecmp(ARG0, "full"))

version_option = 0;

else if (!strcasecmp(ARG0, "text") && ARG1)

version_option = 3;

else if (!strcasecmp(ARG0, "terse"))

version_option = 2;

else if (!strcasecmp(ARG0, "brief"))

version_option = 1;

}

switch (version_option) {

default:

reply(220, "%s FTP server (%s) ready.", hostname, version);

break;

case 1:

reply(220, "%s FTP server ready.", hostname);

break;

case 2:

reply(220, "FTP server ready.");

break;

case 3:

output_text[0] = '\0';

for (which = 1; (which < MAXARGS) && ARG[which]; which++) {

if (which > 1)

(void) strlcat(output_text, " ", sizeof(output_text));

(void) strlcat(output_text, ARG[which], sizeof(output_text));

}

reply(220, "%s", output_text);

break;

}

}

(void) setjmp(errcatch);

for (;;)

(void) yyparse();

/* NOTREACHED */

}

SIGNAL_TYPE randomsig(int sig)

{

#ifdef HAVE_SIGLIST

syslog(LOG_ERR, "exiting on signal %d: %s", sig, sys_siglist[sig]);

#else

syslog(LOG_ERR, "exiting on signal %d", sig);

#endif

chdir("/");

signal(SIGIOT, SIG_DFL);

signal(SIGILL, SIG_DFL);

exit(1);

/* dologout(-1); *//* NOTREACHED */

}

SIGNAL_TYPE lostconn(int sig)

{

#ifdef VERBOSE_ERROR_LOGING

syslog(LOG_INFO, "lost connection to %s", remoteident);

#else

if (debug)

syslog(LOG_DEBUG, "lost connection to %s", remoteident);

#endif

dologout(-1);

}

static char ttyline[20];

#ifdef MAPPING_CHDIR

char mapped_path[MAXPATHLEN] = "/";

#if !defined(HAVE_GETCWD)

char *mapping_getwd(char *path)

{

strcpy(path, mapped_path);

return path;

}

#endif /* !defined(HAVE_GETCWD) */

char *mapping_getcwd(char *path, size_t size)

{

(void) strlcpy(path, mapped_path, size);

return path;

}

char pathspace[MAXPATHLEN];

char old_mapped_path[MAXPATHLEN];

void do_elem(char *dir)

{

/* . */

if (dir[0] == '.' && dir[1] == '\0') {

/* ignore it */

return;

}

/* .. */

if (dir[0] == '.' && dir[1] == '.' && dir[2] == '\0') {

char *last;

/* lop the last directory off the path */

if ((last = strrchr(mapped_path, '/'))) {

/* If start of pathname leave the / */

if (last == mapped_path)

last++;

*last = '\0';

}

return;

}

/* append the dir part with a leading / unless at root */

if (!(mapped_path[0] == '/' && mapped_path[1] == '\0'))

(void) strlcat(mapped_path, "/", sizeof(mapped_path));

(void) strlcat(mapped_path, dir, sizeof(mapped_path));

}

int mapping_chdir(char *orig_path)

{

int ret;

char *sl, *path;

(void) strlcpy(old_mapped_path, mapped_path, sizeof(old_mapped_path));

(void) strlcpy(pathspace, orig_path, sizeof(pathspace));

path = pathspace;

/* / at start of path, set the start of the mapped_path to / */

if (path[0] == '/') {

mapped_path[0] = '/';

mapped_path[1] = '\0';

path++;

}

while ((sl = strchr(path, '/'))) {

char *dir;

dir = path;

*sl = '\0';

path = sl + 1;

if (*dir)

do_elem(dir);

if (*path == '\0')

break;

}

if (*path)

do_elem(path);

if ((ret = chdir(mapped_path)) < 0) {

(void) strlcpy(mapped_path, old_mapped_path, sizeof(mapped_path));

}

return ret;

}

#define chdir(d) mapping_chdir(d)

#define getwd(d) mapping_getwd(d)

#define getcwd(d,u) mapping_getcwd((d),(u))

#endif /* MAPPING_CHDIR */

char *sgetsave(char *s)

{

char *new;

new = (char *) malloc(strlen(s) + 1);

if (new == NULL) {

perror_reply(421, "Local resource failure: malloc");

dologout(1);

/* NOTREACHED */

}

(void) strcpy(new, s);

return (new);

}

struct passwd *sgetpwnam(char *name)

{

static struct passwd save;

register struct passwd *p;

#ifdef M_UNIX

struct passwd *ret = (struct passwd *) NULL;

#endif

char *sgetsave(char *s);

#ifdef KERBEROS

register struct authorization *q;

#endif /* KERBEROS */

#if defined(SecureWare) || defined(HPUX_10_TRUSTED)

struct pr_passwd *pr;

#endif

#ifdef KERBEROS

init_krb();

q = getauthuid(p->pw_uid);

end_krb();

#endif /* KERBEROS */

#ifdef M_UNIX

#if defined(SecureWare) || defined(HPUX_10_TRUSTED)

if ((pr = getprpwnam(name)) == NULL)

goto DONE;

#endif /* SecureWare || HPUX_10_TRUSTED */

#ifdef OTHER_PASSWD

if ((p = bero_getpwnam(name, _path_passwd)) == NULL)

#else

if ((p = getpwnam(name)) == NULL)

#endif

goto DONE;

#else /* M_UNIX */

#if defined(SecureWare) || defined(HPUX_10_TRUSTED)

if ((pr = getprpwnam(name)) == NULL)

return ((struct passwd *) pr);

#endif /* SecureWare || HPUX_10_TRUSTED */

#ifdef OTHER_PASSWD

if ((p = bero_getpwnam(name, _path_passwd)) == NULL)

#else

if ((p = getpwnam(name)) == NULL)

#endif

return (p);

#endif /* M_UNIX */

if (save.pw_name)

free(save.pw_name);

if (save.pw_gecos)

free(save.pw_gecos);

if (save.pw_dir)

free(save.pw_dir);

if (save.pw_shell)

free(save.pw_shell);

if (save.pw_passwd)

free(save.pw_passwd);

save = *p;

save.pw_name = sgetsave(p->pw_name);

#ifdef KERBEROS

save.pw_passwd = sgetsave(q->a_password);

#elif defined(SecureWare) || defined(HPUX_10_TRUSTED)

if (pr->uflg.fg_encrypt && pr->ufld.fd_encrypt && *pr->ufld.fd_encrypt)

save.pw_passwd = sgetsave(pr->ufld.fd_encrypt);

else

save.pw_passwd = sgetsave("");

#else

save.pw_passwd = sgetsave(p->pw_passwd);

#endif

#ifdef SHADOW_PASSWORD

if (p && (p->pw_passwd==NULL || strlen(p->pw_passwd)<8)) {

struct spwd *spw;

#ifdef OTHER_PASSWD

if ((spw = bero_getspnam(p->pw_name, _path_shadow)) != NULL) {

#else

setspent();

if ((spw = getspnam(p->pw_name)) != NULL) {

#endif

int expired = 0;

/*XXX Does this work on all Shadow Password Implementations? */

/* it is supposed to work on Solaris 2.x */

time_t now;

long today;

now = time((time_t *) 0);

today = now / (60 * 60 * 24);

if ((spw->sp_expire > 0) && (spw->sp_expire < today))

expired++;

if ((spw->sp_max > 0) && (spw->sp_lstchg > 0) &&

(spw->sp_lstchg + spw->sp_max < today))

expired++;

free(save.pw_passwd);

save.pw_passwd = sgetsave(expired ? "" : spw->sp_pwdp);

}

#if !defined(LINUX) && !defined(UNIXWARE)

else {

free(save.pw_passwd);

save.pw_passwd = sgetsave("");

}

#endif

#ifndef OTHER_PASSWD

endspent();

#endif

}

#endif

save.pw_gecos = sgetsave(p->pw_gecos);

save.pw_dir = sgetsave(p->pw_dir);

save.pw_shell = sgetsave(p->pw_shell);

#ifdef M_UNIX

ret = &save;

DONE:

endpwent();

#endif

#if defined(SecureWare) || defined(HPUX_10_TRUSTED)

endprpwent();

#endif

#ifdef M_UNIX

return (ret);

#else

return (&save);

#endif

}

#if defined(SKEY) && !defined(__NetBSD__)

char *skey_challenge(char *name, struct passwd *pwd, int pwok)

{

static char buf[128];

char sbuf[40];

struct skey skey;

/* Display s/key challenge where appropriate. */

if (pwd == NULL || skeychallenge(&skey, pwd->pw_name, sbuf))

sprintf(buf, "Password required for %s.", name);

else

sprintf(buf, "%s %s for %s.", sbuf,

pwok ? "allowed" : "required", name);

return (buf);

}

#endif

int login_attempts; /* number of failed login attempts */

int askpasswd; /* had user command, ask for passwd */

#ifndef HELP_CRACKERS

int DenyLoginAfterPassword;

char DelayedMessageFile[MAXPATHLEN];

extern void pr_mesg(int msgcode, char *msgfile);

#endif

#if defined(VIRTUAL) && defined(CLOSED_VIRTUAL_SERVER)

static int defaultserver_allow(const char *username)

{

struct aclmember *entry = NULL;

int which;

while (getaclentry("defaultserver", &entry))

if (ARG0 && !strcasecmp(ARG0, "allow"))

for (which = 1; (which < MAXARGS) && ARG[which]; which++)

if (!strcasecmp(username, ARG[which]) || !strcmp("*", ARG[which]))

return (1);

return (0);

}

static int defaultserver_deny(const char *username)

{

struct aclmember *entry = NULL;

int which;

while (getaclentry("defaultserver", &entry))

if (ARG0 && !strcasecmp(ARG0, "deny"))

for (which = 1; (which < MAXARGS) && ARG[which]; which++)

if (!strcasecmp(username, ARG[which]) || !strcmp("*", ARG[which]))

return (1);

return (0);

}

static int defaultserver_private(void)

{

struct aclmember *entry = NULL;

while (getaclentry("defaultserver", &entry))

if (ARG0 && !strcasecmp(ARG0, "private"))

return (1);

return (0);

}

#endif

void user(char *name)

{

char *cp;

char *shell;

#ifdef BSD_AUTH

char *auth;

#endif

#if defined(USE_GSS)

int gss_need_passwd = 1;

#endif

if (logged_in) {

#ifdef VERBOSE_ERROR_LOGING

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (already logged in as %s) FROM %s, %s",

pw->pw_name, remoteident, name);

#endif

reply(530, "Already logged in.");

return;

}

#ifndef HELP_CRACKERS

askpasswd = 1;

DenyLoginAfterPassword = 0;

DelayedMessageFile[0] = '\0';

#endif

#ifdef BSD_AUTH

if ((auth = strchr(name, ':')))

*auth++ = 0;

#endif

#ifdef HOST_ACCESS /* 19-Mar-93 BM */

if (!rhost_ok(name, remotehost, remoteaddr)) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (name in %s) FROM %s, %s",

_path_ftphosts, remoteident, name);

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (name in %s) FROM %s, %s",

_path_ftphosts, remoteident, name);

return;

#endif

}

#endif

strncpy(the_user, name, MAXUSERNAMELEN - 1);

anonymous = 0;

guest = 0;

if (!strcasecmp(name, "ftp") || !strcasecmp(name, "anonymous")) {

struct aclmember *entry = NULL;

int machineok = 1;

char guestservername[MAXHOSTNAMELEN];

guestservername[0] = '\0';

#ifdef NO_ANONYMOUS_ACCESS

reply(530, "Anonymous FTP access denied.");

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (anonymous ftp not supported) FROM %s, %s",

remoteident, name);

return;

#else

#if defined(VIRTUAL) && defined(CLOSED_VIRTUAL_SERVER)

if (!virtual_mode && defaultserver_private()) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (anonymous ftp denied on default server) FROM %s, %s",

remoteident, name);

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (anonymous ftp denied on default server) FROM %s, %s",

remoteident, name);

return;

#endif

}

#endif

if (checkuser("ftp") || checkuser("anonymous")) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (ftp in %s) FROM %s, %s",

_path_ftpusers, remoteident, name);

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (ftp in %s) FROM %s, %s",

_path_ftpusers, remoteident, name);

return;

#endif

/*

}

else if (getaclentry("guestserver", &entry)) {

char *tmphost;

/*

machineok = 0;

if (hostname[0]

&& ((tmphost = wu_gethostbyname(hostname)))) {

/*

char dns_localhost[MAXHOSTNAMELEN];

int machinecount;

strncpy(dns_localhost, tmphost, sizeof(dns_localhost));

dns_localhost[sizeof(dns_localhost) - 1] = '\0';

for (machinecount = 0;

(machinecount < MAXARGS) && entry->arg[machinecount];

machinecount++) {

if ((tmphost = wu_gethostbyname(entry->arg[machinecount]))) {

/*

if (!machinecount) {

strncpy(guestservername, entry->arg[machinecount],

sizeof(guestservername));

guestservername[sizeof(guestservername) - 1] = '\0';

}

if (!strcasecmp(tmphost, dns_localhost)) {

machineok++;

break;

}

}

}

}

}

if (!machineok) {

if (guestservername[0])

reply(530,

"Guest login not allowed on this machine, connect to %s instead.",

guestservername);

else

reply(530,

"Guest login not allowed on this machine.");

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (localhost not in guestservers) FROM %s, %s",

remoteident, name);

/* End of the big patch -- Nap */

dologout(0);

}

else if ((pw = sgetpwnam("ftp")) != NULL) {

anonymous = 1; /* for the access_ok call */

if (access_ok(530) < 1) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (access denied) FROM %s, %s",

remoteident, name);

reply(331, "Guest login ok, send your complete e-mail address as password.");

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (access denied) FROM %s, %s",

remoteident, name);

dologout(0);

#endif

}

else {

askpasswd = 1;

if (use_accessfile)

acl_setfunctions();

reply(331, "Guest login ok, send your complete e-mail address as password.");

}

}

else {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

reply(331, "Guest login ok, send your complete e-mail address as password.");

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (ftp not in /etc/passwd) FROM %s, %s",

remoteident, name);

#else

reply(530, "User %s unknown.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (ftp not in /etc/passwd) FROM %s, %s",

remoteident, name);

#endif

#ifdef SOLARIS_BSM_AUDIT

audit_ftpd_no_anon();

#endif

}

return;

#endif

}

#ifdef ANON_ONLY

else { /* "ftp" or "anon" -- MARK your conditionals, okay?! */

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (not anonymous) FROM %s, %s",

remoteident, name);

reply(331, "Password required for %s.", name);

#else

reply(530, "User %s unknown.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (not anonymous) FROM %s, %s",

remoteident, name);

#endif

return;

}

#endif /* ANON_ONLY */

#if defined(VIRTUAL) && defined(CLOSED_VIRTUAL_SERVER)

if (!virtual_mode && defaultserver_deny(name) && !defaultserver_allow(name)) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (ftp denied on default server) FROM %s, %s",

remoteident, name);

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (ftp denied on default server) FROM %s, %s",

remoteident, name);

return;

#endif

}

#endif

#if defined(USE_GSS)

if (gss_info.must_gss_auth &&

(!IS_GSSAUTH(cur_auth_type) ||

!(gss_info.authstate & GSS_ADAT_DONE))) {

reply(530, "Must perform authentication before identifying USER.");

return;

}

#endif /* USE_GSS */

if ((pw = sgetpwnam(name)) != NULL) {

if ((denieduid(pw->pw_uid) && !alloweduid(pw->pw_uid))

|| (deniedgid(pw->pw_gid) && !allowedgid(pw->pw_gid))) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (username in denied-uid) FROM %s, %s",

remoteident, name);

reply(331, "Password required for %s.", name);

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE,

"FTP LOGIN REFUSED (username in denied-uid) FROM %s, %s",

remoteident, name);

#endif

return;

}

#if defined(USE_GSS)

if (IS_GSSAUTH(cur_auth_type) &&

(gss_info.authstate & GSS_ADAT_DONE)) {

char buf[BUFSIZ];

if (gss_user(pw))

gss_info.authstate |= GSS_USER_DONE;

if (gss_info.must_gss_auth &&

!GSSUSERAUTH_OK(gss_info)) {

reply(530, "User %s access denied", name);

if (logging)

syslog(LOG_NOTICE, "FTP GSSAPI LOGIN REFUSED FROM %s, %s",

remoteident, name);

pw = NULL;

return;

}

/*

gss_need_passwd = !GSSUSERAUTH_OK(gss_info) ||

(GSSUSERAUTH_OK(gss_info) &&

(gss_info.want_creds && !gss_info.have_creds));

if (gss_need_passwd) {

snprintf(buf, sizeof(buf),

"GSSAPI user %s is authorized as %s password required",

gss_info.display_name, name);

reply(331, "%s", buf);

askpasswd = 1;

syslog(LOG_DEBUG, "%s", buf);

return;

}

}

#endif /* defined(USE_GSS) */

#if !defined(USE_PAM) || (defined(USE_PAM) && defined(OTHER_PASSWD)) || defined(SOLARIS_2) /* PAM should be doing these checks, not ftpd */

#if defined(USE_PAM) && !defined(SOLARIS_2)

if(!use_pam) {

#endif

if ((shell = pw->pw_shell) == NULL || *shell == 0)

shell = _PATH_BSHELL;

while ((cp = getusershell()) != NULL)

if (strcmp(cp, shell) == 0)

break;

endusershell();

if (cp == NULL || checkuser(name)) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

if (cp == NULL)

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (shell not in /etc/shells) FROM %s, %s", remoteident, name);

else

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (username in %s) FROM %s, %s", _path_ftpusers, remoteident, name);

reply(331, "Password required for %s.", name);

#else

reply(530, "User %s access denied.", name);

if (cp == NULL)

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (shell not in /etc/shells) FROM %s, %s", remoteident, name);

else

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (username in %s) FROM %s, %s", _path_ftpusers, remoteident, name);

#endif /* HELP_CRACKERS */

pw = (struct passwd *) NULL;

return;

}

#if defined(USE_PAM) && !defined(SOLARIS_2)

} /* if(!use_pam) */

#endif

#endif /* !USE_PAM || (USE_PAM && OTHER_PASSWD) || SOLARIS_2 */

/* if user is a member of any of the guestgroups, cause a chroot() */

/* after they log in successfully */

if (use_accessfile) { /* see above. _H */

guest = acl_guestgroup(pw);

if (guest && acl_realgroup(pw))

guest = 0;

}

}

if (access_ok(530) < 1) {

#ifndef HELP_CRACKERS

DenyLoginAfterPassword = 1;

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (access denied) FROM %s, %s",

remoteident, name);

reply(331, "Password required for %s.", name);

#else

reply(530, "User %s access denied.", name);

syslog(LOG_NOTICE, "FTP LOGIN REFUSED (access denied) FROM %s, %s",

remoteident, name);

#endif

return;

}

else if (use_accessfile) /* see above. _H */

acl_setfunctions();

#ifdef BSD_AUTH

if ((cp = start_auth(auth, name, pw)) != NULL) {

char *s;

for (;;) {

s = strsep(&cp, "\n");

if (cp == NULL || *cp == '\0')

break;

lreply(331, "%s", s);

}

reply(331, "%s", s);

}

else {

#endif /* BSD_AUTH */

#ifdef SKEY

#ifndef __NetBSD__

#ifdef SKEY_NAME

/* this is the old way, but freebsd uses it */

pwok = skeyaccess(name, NULL, remotehost, remoteaddr);

#else

/* this is the new way */

pwok = skeyaccess(pw, NULL, remotehost, remoteaddr);

#endif /* SKEY_NAME */

reply(331, "%s", skey_challenge(name, pw, pwok));

#else

if (skey_haskey(name) == 0) {

char *myskey;

myskey = skey_keyinfo(name);

reply(331, "Password [%s] required for %s.",

myskey ? myskey : "error getting challenge", name);

}

else

reply(331, "Password required for %s.", name);

#endif /* __NetBSD__ */

#else

#ifdef OPIE

{

char prompt[OPIE_CHALLENGE_MAX + 1];

opiechallenge(&opiestate, name, prompt);

if (askpasswd == -1) {

syslog(LOG_WARNING, "Invalid FTP user name %s attempted from %s", name, remotehost);

pwok = 0;

}

else

pwok = af_pwok && opiealways(pw->pw_dir);

reply(331, "Response to %s %s for %s.",

prompt, pwok ? "requested" : "required", name);

}

#else /* !SKEY */

#if defined(USE_GSS)

if (GSSUSERAUTH_OK(gss_info) && !gss_need_passwd) {

/*

askpasswd = 0;

logged_in = 1;

pass("");

return;

}

#endif /* defined(USE_GSS) */

reply(331, "Password required for %s.", name);

#endif /* OPIE */

#endif /* SKEY */

#ifdef BSD_AUTH

}

#endif /* BSD_AUTH */

askpasswd = 1;

/* Delay before reading passwd after first failed attempt to slow down

if (login_attempts) {

enable_signaling(); /* we can allow signals once again: kinch */

sleep((unsigned) login_attempts);

}

return;

}

int checkuser(char *name)

{

register FILE *fd;

register char *p;

char line[BUFSIZ];

#ifdef SOLARIS_ETC_FTPUSERS

static int etc_ftpusers = 0;

if (etc_ftpusers) {

strcpy(_path_ftpusers, _PATH_FTPUSERS);

etc_ftpusers = 0;

}

retry:

#endif

if ((fd = fopen(_path_ftpusers, "r")) != NULL) {

while (fgets(line, sizeof(line), fd) != NULL)

if ((p = strchr(line, '\n')) != NULL) {

*p = '\0';

if (line[0] == '#')

continue;

if (strcasecmp(line, name) == 0) {

(void) fclose(fd);

#ifdef SOLARIS_BSM_AUDIT

audit_ftpd_excluded(name);

#endif

#ifdef SOLARIS_ETC_FTPUSERS

if (etc_ftpusers)

syslog(LOG_NOTICE, "%s is deprecated, use %s instead", _path_ftpusers, _PATH_FTPUSERS);

#endif

return (1);

}

}

(void) fclose(fd);

}

#ifdef SOLARIS_ETC_FTPUSERS

if (!etc_ftpusers && (strcmp(_path_ftpusers, _PATH_FTPUSERS) == 0)) {

strcpy(_path_ftpusers, "/etc/ftpusers");

etc_ftpusers = 1;

goto retry;

}

#endif

return (0);

}

int uid_match(char *keyword, uid_t uid)

{

struct aclmember *entry = NULL;

int which;

char *ptr;

struct passwd *pw;

/*

while (getaclentry(keyword, &entry)) {

for (which = 0; (which < MAXARGS) && ARG[which]; which++) {

if (!strcmp(ARG[which], "*"))

return (1);

if (ARG[which][0] == '%') {

if ((ptr = strchr(ARG[which] + 1, '-')) == NULL) {

if ((ptr = strchr(ARG[which] + 1, '+')) == NULL) {

if (uid == strtoul(ARG[which] + 1, NULL, 0))

return (1);

}

else {

*ptr++ = '\0';

if ((ARG[which][1] == '\0')

|| (uid >= strtoul(ARG[which] + 1, NULL, 0))) {

*--ptr = '+';

return (1);

}

*--ptr = '+';

}

}

else {

*ptr++ = '\0';

if (((ARG[which][1] == '\0')

|| (uid >= strtoul(ARG[which] + 1, NULL, 0)))

&& ((*ptr == '\0')

|| (uid <= strtoul(ptr, NULL, 0)))) {

*--ptr = '-';

return (1);

}

*--ptr = '-';

}

}

else {

#ifdef OTHER_PASSWD

pw = bero_getpwnam(ARG[which], _path_passwd);

#else

pw = getpwnam(ARG[which]);

#endif

if (pw && (uid == pw->pw_uid))

return (1);

}

}

}

return (0);

}

int gid_match(char *keyword, gid_t gid, char *username)

{

struct aclmember *entry = NULL;

int which;

char *ptr;

struct group *grp;

char **member;

/*

while (getaclentry(keyword, &entry)) {

for (which = 0; (which < MAXARGS) && ARG[which]; which++) {

if (!strcmp(ARG[which], "*"))

return (1);

if (ARG[which][0] == '%') {

if ((ptr = strchr(ARG[which] + 1, '-')) == NULL) {

if ((ptr = strchr(ARG[which] + 1, '+')) == NULL) {

if (gid == strtoul(ARG[which] + 1, NULL, 0))

return (1);

}

else {

*ptr++ = '\0';

if ((ARG[which][1] == '\0')

|| (gid >= strtoul(ARG[which] + 1, NULL, 0))) {

*--ptr = '+';

return (1);

}

*--ptr = '+';

}

}

else {

*ptr++ = '\0';

if (((ARG[which][1] == '\0')

|| (gid >= strtoul(ARG[which] + 1, NULL, 0)))

&& ((*ptr == '\0')

|| (gid <= strtoul(ptr, NULL, 0)))) {

*--ptr = '-';

return (1);

}

*--ptr = '-';

}

}

else {

if ((grp = getgrnam(ARG[which]))) {

if (gid == grp->gr_gid)

return (1);

if (username) {

for (member = grp->gr_mem; *member; member++)

if (!strcasecmp(*member, username))

return (1);

}

}

}

}

}

return (0);

}

int denieduid(uid_t uid)

{

return uid_match("deny-uid", uid);

}

int alloweduid(uid_t uid)

{

return uid_match("allow-uid", uid);

}

int deniedgid(gid_t gid)

{

return gid_match("deny-gid", gid, NULL);

}

int allowedgid(gid_t gid)

{

return gid_match("allow-gid", gid, NULL);

}

void end_login(void)

{

delay_signaling(); /* we can't allow any signals while euid==0: kinch */

(void) seteuid((uid_t) 0);

if (logged_in) {

if (wtmp_logging)

wu_logwtmp(ttyline, pw->pw_name, remotehost, 0);

#ifdef USE_PAM

if (!anonymous && pamh) {

(void) pam_close_session(pamh, 0);

(void) pam_end(pamh, PAM_SUCCESS);

pamh = (pam_handle_t *)0;

}

#endif

}

pw = NULL;

#ifdef AFS_AUTH

ktc_ForgetAllTokens();

#endif

logged_in = 0;

anonymous = 0;

guest = 0;

}

int validate_eaddr(char *eaddr)

{

int i, host, state;

for (i = host = state = 0; eaddr[i] != '\0'; i++) {

switch (eaddr[i]) {

case '.':

if (!host)

return 0;

if (state == 2)

state = 3;

host = 0;

break;

case '@':

if (!host || state > 1 || !strncasecmp("ftp", eaddr + i - host, host))

return 0;

state = 2;

host = 0;

break;

case '!':

case '%':

if (!host || state > 1)

return 0;

state = 1;

host = 0;

break;

case '-':

break;

default:

host++;

}

}

if (((state == 3) && host > 1) || ((state == 1) && host > 1))

return 1;

else

return 0;

}

#if defined(VIRTUAL) && defined(CLOSED_VIRTUAL_SERVER)

static int AllowVirtualUser(const char *username)

{

struct aclmember *entry = NULL;

int which;

while (getaclentry("virtual", &entry))

if (ARG0 && hostmatch(ARG0, virtual_address, virtual_hostname)

&& ARG1 && !strcasecmp(ARG1, "allow"))

for (which = 2; (which < MAXARGS) && ARG[which]; which++)

if (!strcasecmp(username, ARG[which]) || !strcmp("*", ARG[which]))

return (1);

return (0);

}

static int DenyVirtualUser(const char *username)

{

struct aclmember *entry = NULL;