Initial import from FreeBSD RELENG_4:
[dragonfly.git] / libexec / ftpd / ftpd.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#if 0
35#ifndef lint
36static char copyright[] =
37"@(#) Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994\n\
38 The Regents of the University of California. All rights reserved.\n";
39#endif /* not lint */
40#endif
41
42#ifndef lint
43#if 0
44static char sccsid[] = "@(#)ftpd.c 8.4 (Berkeley) 4/16/94";
45#endif
46static const char rcsid[] =
47 "$FreeBSD: src/libexec/ftpd/ftpd.c,v 1.62.2.48 2003/02/14 12:42:42 yar Exp $";
48#endif /* not lint */
49
50/*
51 * FTP server.
52 */
53#include <sys/param.h>
54#include <sys/ioctl.h>
55#include <sys/mman.h>
56#include <sys/socket.h>
57#include <sys/stat.h>
58#include <sys/time.h>
59#include <sys/wait.h>
60
61#include <netinet/in.h>
62#include <netinet/in_systm.h>
63#include <netinet/ip.h>
64#include <netinet/tcp.h>
65
66#define FTP_NAMES
67#include <arpa/ftp.h>
68#include <arpa/inet.h>
69#include <arpa/telnet.h>
70
71#include <ctype.h>
72#include <dirent.h>
73#include <err.h>
74#include <errno.h>
75#include <fcntl.h>
76#include <glob.h>
77#include <limits.h>
78#include <netdb.h>
79#include <pwd.h>
80#include <grp.h>
81#include <signal.h>
82#include <stdio.h>
83#include <stdlib.h>
84#include <string.h>
85#include <syslog.h>
86#include <time.h>
87#include <unistd.h>
88#include <libutil.h>
89#ifdef LOGIN_CAP
90#include <login_cap.h>
91#endif
92
93#ifdef SKEY
94#include <skey.h>
95#endif
96
97#if !defined(NOPAM)
98#include <security/pam_appl.h>
99#endif
100
101#include "pathnames.h"
102#include "extern.h"
103
104#if __STDC__
105#include <stdarg.h>
106#else
107#include <varargs.h>
108#endif
109
110static char version[] = "Version 6.00LS";
111#undef main
112
113extern off_t restart_point;
114extern char cbuf[];
115
116union sockunion server_addr;
117union sockunion ctrl_addr;
118union sockunion data_source;
119union sockunion data_dest;
120union sockunion his_addr;
121union sockunion pasv_addr;
122
123int daemon_mode;
124int data;
125int dataport;
126int hostinfo = 1; /* print host-specific info in messages */
127int logged_in;
128struct passwd *pw;
129char *homedir;
130int ftpdebug;
131int timeout = 900; /* timeout after 15 minutes of inactivity */
132int maxtimeout = 7200;/* don't allow idle time to be set beyond 2 hours */
133int logging;
134int restricted_data_ports = 1;
135int paranoid = 1; /* be extra careful about security */
136int anon_only = 0; /* Only anonymous ftp allowed */
137int guest;
138int dochroot;
139int dowtmp = 1;
140int stats;
141int statfd = -1;
142int type;
143int form;
144int stru; /* avoid C keyword */
145int mode;
146int usedefault = 1; /* for data transfers */
147int pdata = -1; /* for passive mode */
148int readonly=0; /* Server is in readonly mode. */
149int noepsv=0; /* EPSV command is disabled. */
150int noretr=0; /* RETR command is disabled. */
151int noguestretr=0; /* RETR command is disabled for anon users. */
152int noguestmkd=0; /* MKD command is disabled for anon users. */
153int noguestmod=1; /* anon users may not modify existing files. */
154
155static volatile sig_atomic_t recvurg;
156sig_atomic_t transflag;
157off_t file_size;
158off_t byte_count;
159#if !defined(CMASK) || CMASK == 0
160#undef CMASK
161#define CMASK 027
162#endif
163int defumask = CMASK; /* default umask value */
164char tmpline[7];
165char *hostname;
166int epsvall = 0;
167
168#ifdef VIRTUAL_HOSTING
169char *ftpuser;
170
171static struct ftphost {
172 struct ftphost *next;
173 struct addrinfo *hostinfo;
174 char *hostname;
175 char *anonuser;
176 char *statfile;
177 char *welcome;
178 char *loginmsg;
179} *thishost, *firsthost;
180
181#endif
182char remotehost[MAXHOSTNAMELEN];
183char *ident = NULL;
184
185static char ttyline[20];
186char *tty = ttyline; /* for klogin */
187
188#if !defined(NOPAM)
189static int auth_pam __P((struct passwd**, const char*));
190#endif
191
192char *pid_file = NULL;
193
194/*
195 * Limit number of pathnames that glob can return.
196 * A limit of 0 indicates the number of pathnames is unlimited.
197 */
198#define MAXGLOBARGS 16384
199#
200
201/*
202 * Timeout intervals for retrying connections
203 * to hosts that don't accept PORT cmds. This
204 * is a kludge, but given the problems with TCP...
205 */
206#define SWAITMAX 90 /* wait at most 90 seconds */
207#define SWAITINT 5 /* interval between retries */
208
209int swaitmax = SWAITMAX;
210int swaitint = SWAITINT;
211
212#ifdef SETPROCTITLE
213#ifdef OLD_SETPROCTITLE
214char **Argv = NULL; /* pointer to argument vector */
215char *LastArgv = NULL; /* end of argv */
216#endif /* OLD_SETPROCTITLE */
217char proctitle[LINE_MAX]; /* initial part of title */
218#endif /* SETPROCTITLE */
219
220#ifdef SKEY
221int pwok = 0;
222#endif
223
224#define LOGCMD(cmd, file) \
225 if (logging > 1) \
226 syslog(LOG_INFO,"%s %s%s", cmd, \
227 *(file) == '/' ? "" : curdir(), file);
228#define LOGCMD2(cmd, file1, file2) \
229 if (logging > 1) \
230 syslog(LOG_INFO,"%s %s%s %s%s", cmd, \
231 *(file1) == '/' ? "" : curdir(), file1, \
232 *(file2) == '/' ? "" : curdir(), file2);
233#define LOGBYTES(cmd, file, cnt) \
234 if (logging > 1) { \
235 if (cnt == (off_t)-1) \
236 syslog(LOG_INFO,"%s %s%s", cmd, \
237 *(file) == '/' ? "" : curdir(), file); \
238 else \
239 syslog(LOG_INFO, "%s %s%s = %qd bytes", \
240 cmd, (*(file) == '/') ? "" : curdir(), file, cnt); \
241 }
242
243#ifdef VIRTUAL_HOSTING
244static void inithosts __P((void));
245static void selecthost __P((union sockunion *));
246#endif
247static void ack __P((char *));
248static void sigurg __P((int));
249static void myoob __P((void));
250static int checkuser __P((char *, char *, int, char **));
251static FILE *dataconn __P((char *, off_t, char *));
252static void dolog __P((struct sockaddr *));
253static char *curdir __P((void));
254static void end_login __P((void));
255static FILE *getdatasock __P((char *));
256static int guniquefd __P((char *, char **));
257static void lostconn __P((int));
258static void sigquit __P((int));
259static int receive_data __P((FILE *, FILE *));
260static int send_data __P((FILE *, FILE *, off_t, off_t, int));
261static struct passwd *
262 sgetpwnam __P((char *));
263static char *sgetsave __P((char *));
264static void reapchild __P((int));
265static void logxfer __P((char *, off_t, time_t));
266static char *doublequote __P((char *));
267
268static char *
269curdir()
270{
271 static char path[MAXPATHLEN+1+1]; /* path + '/' + '\0' */
272
273 if (getcwd(path, sizeof(path)-2) == NULL)
274 return ("");
275 if (path[1] != '\0') /* special case for root dir. */
276 strcat(path, "/");
277 /* For guest account, skip / since it's chrooted */
278 return (guest ? path+1 : path);
279}
280
281int
282main(argc, argv, envp)
283 int argc;
284 char *argv[];
285 char **envp;
286{
287 int addrlen, ch, on = 1, tos;
288 char *cp, line[LINE_MAX];
289 FILE *fd;
290 int error;
291 char *bindname = NULL;
292 const char *bindport = "ftp";
293 int family = AF_UNSPEC;
294 int enable_v4 = 0;
295 struct sigaction sa;
296
297 tzset(); /* in case no timezone database in ~ftp */
298 sigemptyset(&sa.sa_mask);
299 sa.sa_flags = SA_RESTART;
300
301#ifdef OLD_SETPROCTITLE
302 /*
303 * Save start and extent of argv for setproctitle.
304 */
305 Argv = argv;
306 while (*envp)
307 envp++;
308 LastArgv = envp[-1] + strlen(envp[-1]);
309#endif /* OLD_SETPROCTITLE */
310
311
312 while ((ch = getopt(argc, argv,
313 "46a:AdDEhlmMoOp:P:rRSt:T:u:UvW")) != -1) {
314 switch (ch) {
315 case '4':
316 enable_v4 = 1;
317 if (family == AF_UNSPEC)
318 family = AF_INET;
319 break;
320
321 case '6':
322 family = AF_INET6;
323 break;
324
325 case 'a':
326 bindname = optarg;
327 break;
328
329 case 'A':
330 anon_only = 1;
331 break;
332
333 case 'd':
334 ftpdebug++;
335 break;
336
337 case 'D':
338 daemon_mode++;
339 break;
340
341 case 'E':
342 noepsv = 1;
343 break;
344
345 case 'h':
346 hostinfo = 0;
347 break;
348
349 case 'l':
350 logging++; /* > 1 == extra logging */
351 break;
352
353 case 'm':
354 noguestmod = 0;
355 break;
356
357 case 'M':
358 noguestmkd = 1;
359 break;
360
361 case 'o':
362 noretr = 1;
363 break;
364
365 case 'O':
366 noguestretr = 1;
367 break;
368
369 case 'p':
370 pid_file = optarg;
371 break;
372
373 case 'P':
374 bindport = optarg;
375 break;
376
377 case 'r':
378 readonly = 1;
379 break;
380
381 case 'R':
382 paranoid = 0;
383 break;
384
385 case 'S':
386 stats++;
387 break;
388
389 case 't':
390 timeout = atoi(optarg);
391 if (maxtimeout < timeout)
392 maxtimeout = timeout;
393 break;
394
395 case 'T':
396 maxtimeout = atoi(optarg);
397 if (timeout > maxtimeout)
398 timeout = maxtimeout;
399 break;
400
401 case 'u':
402 {
403 long val = 0;
404
405 val = strtol(optarg, &optarg, 8);
406 if (*optarg != '\0' || val < 0)
407 warnx("bad value for -u");
408 else
409 defumask = val;
410 break;
411 }
412 case 'U':
413 restricted_data_ports = 0;
414 break;
415
416 case 'v':
417 ftpdebug++;
418 break;
419
420 case 'W':
421 dowtmp = 0;
422 break;
423
424 default:
425 warnx("unknown flag -%c ignored", optopt);
426 break;
427 }
428 }
429
430#ifdef VIRTUAL_HOSTING
431 inithosts();
432#endif
433 (void) freopen(_PATH_DEVNULL, "w", stderr);
434
435 /*
436 * LOG_NDELAY sets up the logging connection immediately,
437 * necessary for anonymous ftp's that chroot and can't do it later.
438 */
439 openlog("ftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
440
441 if (daemon_mode) {
442 int ctl_sock, fd;
443 struct addrinfo hints, *res;
444
445 /*
446 * Detach from parent.
447 */
448 if (daemon(1, 1) < 0) {
449 syslog(LOG_ERR, "failed to become a daemon");
450 exit(1);
451 }
452 sa.sa_handler = reapchild;
453 (void)sigaction(SIGCHLD, &sa, NULL);
454 /* init bind_sa */
455 memset(&hints, 0, sizeof(hints));
456
457 hints.ai_family = family == AF_UNSPEC ? AF_INET : family;
458 hints.ai_socktype = SOCK_STREAM;
459 hints.ai_protocol = 0;
460 hints.ai_flags = AI_PASSIVE;
461 error = getaddrinfo(bindname, bindport, &hints, &res);
462 if (error) {
463 if (family == AF_UNSPEC) {
464 hints.ai_family = AF_UNSPEC;
465 error = getaddrinfo(bindname, bindport, &hints,
466 &res);
467 }
468 }
469 if (error) {
470 syslog(LOG_ERR, "%s", gai_strerror(error));
471 if (error == EAI_SYSTEM)
472 syslog(LOG_ERR, "%s", strerror(errno));
473 exit(1);
474 }
475 if (res->ai_addr == NULL) {
476 syslog(LOG_ERR, "-a %s: getaddrinfo failed", hostname);
477 exit(1);
478 } else
479 family = res->ai_addr->sa_family;
480 /*
481 * Open a socket, bind it to the FTP port, and start
482 * listening.
483 */
484 ctl_sock = socket(family, SOCK_STREAM, 0);
485 if (ctl_sock < 0) {
486 syslog(LOG_ERR, "control socket: %m");
487 exit(1);
488 }
489 if (setsockopt(ctl_sock, SOL_SOCKET, SO_REUSEADDR,
490 &on, sizeof(on)) < 0)
491 syslog(LOG_WARNING,
492 "control setsockopt (SO_REUSEADDR): %m");
493 if (family == AF_INET6 && enable_v4 == 0) {
494 if (setsockopt(ctl_sock, IPPROTO_IPV6, IPV6_V6ONLY,
495 &on, sizeof (on)) < 0)
496 syslog(LOG_WARNING,
497 "control setsockopt (IPV6_V6ONLY): %m");
498 }
499 memcpy(&server_addr, res->ai_addr, res->ai_addr->sa_len);
500 if (bind(ctl_sock, (struct sockaddr *)&server_addr,
501 server_addr.su_len) < 0) {
502 syslog(LOG_ERR, "control bind: %m");
503 exit(1);
504 }
505 if (listen(ctl_sock, 32) < 0) {
506 syslog(LOG_ERR, "control listen: %m");
507 exit(1);
508 }
509 /*
510 * Atomically write process ID
511 */
512 if (pid_file)
513 {
514 int fd;
515 char buf[20];
516
517 fd = open(pid_file, O_CREAT | O_WRONLY | O_TRUNC
518 | O_NONBLOCK | O_EXLOCK, 0644);
519 if (fd < 0) {
520 if (errno == EAGAIN)
521 errx(1, "%s: file locked", pid_file);
522 else
523 err(1, "%s", pid_file);
524 }
525 snprintf(buf, sizeof(buf),
526 "%lu\n", (unsigned long) getpid());
527 if (write(fd, buf, strlen(buf)) < 0)
528 err(1, "%s: write", pid_file);
529 /* Leave the pid file open and locked */
530 }
531 /*
532 * Loop forever accepting connection requests and forking off
533 * children to handle them.
534 */
535 while (1) {
536 addrlen = server_addr.su_len;
537 fd = accept(ctl_sock, (struct sockaddr *)&his_addr, &addrlen);
538 if (fork() == 0) {
539 /* child */
540 (void) dup2(fd, 0);
541 (void) dup2(fd, 1);
542 close(ctl_sock);
543 break;
544 }
545 close(fd);
546 }
547 } else {
548 addrlen = sizeof(his_addr);
549 if (getpeername(0, (struct sockaddr *)&his_addr, &addrlen) < 0) {
550 syslog(LOG_ERR, "getpeername (%s): %m",argv[0]);
551 exit(1);
552 }
553 }
554
555 sa.sa_handler = SIG_DFL;
556 (void)sigaction(SIGCHLD, &sa, NULL);
557
558 sa.sa_handler = sigurg;
559 sa.sa_flags = 0; /* don't restart syscalls for SIGURG */
560 (void)sigaction(SIGURG, &sa, NULL);
561
562 sigfillset(&sa.sa_mask); /* block all signals in handler */
563 sa.sa_flags = SA_RESTART;
564 sa.sa_handler = sigquit;
565 (void)sigaction(SIGHUP, &sa, NULL);
566 (void)sigaction(SIGINT, &sa, NULL);
567 (void)sigaction(SIGQUIT, &sa, NULL);
568 (void)sigaction(SIGTERM, &sa, NULL);
569
570 sa.sa_handler = lostconn;
571 (void)sigaction(SIGPIPE, &sa, NULL);
572
573 addrlen = sizeof(ctrl_addr);
574 if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) {
575 syslog(LOG_ERR, "getsockname (%s): %m",argv[0]);
576 exit(1);
577 }
578 dataport = ntohs(ctrl_addr.su_port) - 1; /* as per RFC 959 */
579#ifdef VIRTUAL_HOSTING
580 /* select our identity from virtual host table */
581 selecthost(&ctrl_addr);
582#endif
583#ifdef IP_TOS
584 if (ctrl_addr.su_family == AF_INET)
585 {
586 tos = IPTOS_LOWDELAY;
587 if (setsockopt(0, IPPROTO_IP, IP_TOS, &tos, sizeof(int)) < 0)
588 syslog(LOG_WARNING, "control setsockopt (IP_TOS): %m");
589 }
590#endif
591 /*
592 * Disable Nagle on the control channel so that we don't have to wait
593 * for peer's ACK before issuing our next reply.
594 */
595 if (setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) < 0)
596 syslog(LOG_WARNING, "control setsockopt (TCP_NODELAY): %m");
597
598 data_source.su_port = htons(ntohs(ctrl_addr.su_port) - 1);
599
600 /* set this here so klogin can use it... */
601 (void)snprintf(ttyline, sizeof(ttyline), "ftp%d", getpid());
602
603 /* Try to handle urgent data inline */
604#ifdef SO_OOBINLINE
605 if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)) < 0)
606 syslog(LOG_WARNING, "control setsockopt (SO_OOBINLINE): %m");
607#endif
608
609#ifdef F_SETOWN
610 if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1)
611 syslog(LOG_ERR, "fcntl F_SETOWN: %m");
612#endif
613 dolog((struct sockaddr *)&his_addr);
614 /*
615 * Set up default state
616 */
617 data = -1;
618 type = TYPE_A;
619 form = FORM_N;
620 stru = STRU_F;
621 mode = MODE_S;
622 tmpline[0] = '\0';
623
624 /* If logins are disabled, print out the message. */
625 if ((fd = fopen(_PATH_NOLOGIN,"r")) != NULL) {
626 while (fgets(line, sizeof(line), fd) != NULL) {
627 if ((cp = strchr(line, '\n')) != NULL)
628 *cp = '\0';
629 lreply(530, "%s", line);
630 }
631 (void) fflush(stdout);
632 (void) fclose(fd);
633 reply(530, "System not available.");
634 exit(0);
635 }
636#ifdef VIRTUAL_HOSTING
637 if ((fd = fopen(thishost->welcome, "r")) != NULL) {
638#else
639 if ((fd = fopen(_PATH_FTPWELCOME, "r")) != NULL) {
640#endif
641 while (fgets(line, sizeof(line), fd) != NULL) {
642 if ((cp = strchr(line, '\n')) != NULL)
643 *cp = '\0';
644 lreply(220, "%s", line);
645 }
646 (void) fflush(stdout);
647 (void) fclose(fd);
648 /* reply(220,) must follow */
649 }
650#ifndef VIRTUAL_HOSTING
651 if ((hostname = malloc(MAXHOSTNAMELEN)) == NULL)
652 fatalerror("Ran out of memory.");
653 (void) gethostname(hostname, MAXHOSTNAMELEN - 1);
654 hostname[MAXHOSTNAMELEN - 1] = '\0';
655#endif
656 if (hostinfo)
657 reply(220, "%s FTP server (%s) ready.", hostname, version);
658 else
659 reply(220, "FTP server ready.");
660 for (;;)
661 (void) yyparse();
662 /* NOTREACHED */
663}
664
665static void
666lostconn(signo)
667 int signo;
668{
669
670 if (ftpdebug)
671 syslog(LOG_DEBUG, "lost connection");
672 dologout(1);
673}
674
675static void
676sigquit(signo)
677 int signo;
678{
679
680 syslog(LOG_ERR, "got signal %d", signo);
681 dologout(1);
682}
683
684#ifdef VIRTUAL_HOSTING
685/*
686 * read in virtual host tables (if they exist)
687 */
688
689static void
690inithosts()
691{
692 int insert;
693 size_t len;
694 FILE *fp;
695 char *cp, *mp, *line;
696 char *hostname;
697 char *vhost, *anonuser, *statfile, *welcome, *loginmsg;
698 struct ftphost *hrp, *lhrp;
699 struct addrinfo hints, *res, *ai;
700
701 /*
702 * Fill in the default host information
703 */
704 if ((hostname = malloc(MAXHOSTNAMELEN)) == NULL)
705 fatalerror("Ran out of memory.");
706 if (gethostname(hostname, MAXHOSTNAMELEN) < 0)
707 hostname[0] = '\0';
708 hostname[MAXHOSTNAMELEN - 1] = '\0';
709 if ((hrp = malloc(sizeof(struct ftphost))) == NULL)
710 fatalerror("Ran out of memory.");
711 hrp->hostname = hostname;
712 hrp->hostinfo = NULL;
713
714 memset(&hints, 0, sizeof(hints));
715 hints.ai_flags = AI_CANONNAME;
716 hints.ai_family = AF_UNSPEC;
717 if (getaddrinfo(hrp->hostname, NULL, &hints, &res) == 0)
718 hrp->hostinfo = res;
719 hrp->statfile = _PATH_FTPDSTATFILE;
720 hrp->welcome = _PATH_FTPWELCOME;
721 hrp->loginmsg = _PATH_FTPLOGINMESG;
722 hrp->anonuser = "ftp";
723 hrp->next = NULL;
724 thishost = firsthost = lhrp = hrp;
725 if ((fp = fopen(_PATH_FTPHOSTS, "r")) != NULL) {
726 int addrsize, gothost;
727 void *addr;
728 struct hostent *hp;
729
730 while ((line = fgetln(fp, &len)) != NULL) {
731 int i, hp_error;
732
733 /* skip comments */
734 if (line[0] == '#')
735 continue;
736 if (line[len - 1] == '\n') {
737 line[len - 1] = '\0';
738 mp = NULL;
739 } else {
740 if ((mp = malloc(len + 1)) == NULL)
741 fatalerror("Ran out of memory.");
742 memcpy(mp, line, len);
743 mp[len] = '\0';
744 line = mp;
745 }
746 cp = strtok(line, " \t");
747 /* skip empty lines */
748 if (cp == NULL)
749 goto nextline;
750 vhost = cp;
751
752 /* set defaults */
753 anonuser = "ftp";
754 statfile = _PATH_FTPDSTATFILE;
755 welcome = _PATH_FTPWELCOME;
756 loginmsg = _PATH_FTPLOGINMESG;
757
758 /*
759 * Preparse the line so we can use its info
760 * for all the addresses associated with
761 * the virtual host name.
762 * Field 0, the virtual host name, is special:
763 * it's already parsed off and will be strdup'ed
764 * later, after we know its canonical form.
765 */
766 for (i = 1; i < 5 && (cp = strtok(NULL, " \t")); i++)
767 if (*cp != '-' && (cp = strdup(cp)))
768 switch (i) {
769 case 1: /* anon user permissions */
770 anonuser = cp;
771 break;
772 case 2: /* statistics file */
773 statfile = cp;
774 break;
775 case 3: /* welcome message */
776 welcome = cp;
777 break;
778 case 4: /* login message */
779 loginmsg = cp;
780 break;
781 default: /* programming error */
782 abort();
783 /* NOTREACHED */
784 }
785
786 hints.ai_flags = 0;
787 hints.ai_family = AF_UNSPEC;
788 hints.ai_flags = AI_PASSIVE;
789 if (getaddrinfo(vhost, NULL, &hints, &res) != 0)
790 goto nextline;
791 for (ai = res; ai != NULL && ai->ai_addr != NULL;
792 ai = ai->ai_next) {
793
794 gothost = 0;
795 for (hrp = firsthost; hrp != NULL; hrp = hrp->next) {
796 struct addrinfo *hi;
797
798 for (hi = hrp->hostinfo; hi != NULL;
799 hi = hi->ai_next)
800 if (hi->ai_addrlen == ai->ai_addrlen &&
801 memcmp(hi->ai_addr,
802 ai->ai_addr,
803 ai->ai_addr->sa_len) == 0) {
804 gothost++;
805 break;
806 }
807 if (gothost)
808 break;
809 }
810 if (hrp == NULL) {
811 if ((hrp = malloc(sizeof(struct ftphost))) == NULL)
812 goto nextline;
813 hrp->hostname = NULL;
814 insert = 1;
815 } else {
816 if (hrp->hostinfo && hrp->hostinfo != res)
817 freeaddrinfo(hrp->hostinfo);
818 insert = 0; /* host already in the chain */
819 }
820 hrp->hostinfo = res;
821
822 /*
823 * determine hostname to use.
824 * force defined name if there is a valid alias
825 * otherwise fallback to primary hostname
826 */
827 /* XXX: getaddrinfo() can't do alias check */
828 switch(hrp->hostinfo->ai_family) {
829 case AF_INET:
830 addr = &((struct sockaddr_in *)hrp->hostinfo->ai_addr)->sin_addr;
831 addrsize = sizeof(struct in_addr);
832 break;
833 case AF_INET6:
834 addr = &((struct sockaddr_in6 *)hrp->hostinfo->ai_addr)->sin6_addr;
835 addrsize = sizeof(struct in6_addr);
836 break;
837 default:
838 /* should not reach here */
839 freeaddrinfo(hrp->hostinfo);
840 if (insert)
841 free(hrp); /*not in chain, can free*/
842 else
843 hrp->hostinfo = NULL; /*mark as blank*/
844 goto nextline;
845 /* NOTREACHED */
846 }
847 if ((hp = getipnodebyaddr(addr, addrsize,
848 hrp->hostinfo->ai_family,
849 &hp_error)) != NULL) {
850 if (strcmp(vhost, hp->h_name) != 0) {
851 if (hp->h_aliases == NULL)
852 vhost = hp->h_name;
853 else {
854 i = 0;
855 while (hp->h_aliases[i] &&
856 strcmp(vhost, hp->h_aliases[i]) != 0)
857 ++i;
858 if (hp->h_aliases[i] == NULL)
859 vhost = hp->h_name;
860 }
861 }
862 }
863 if (hrp->hostname &&
864 strcmp(hrp->hostname, vhost) != 0) {
865 free(hrp->hostname);
866 hrp->hostname = NULL;
867 }
868 if (hrp->hostname == NULL &&
869 (hrp->hostname = strdup(vhost)) == NULL) {
870 freeaddrinfo(hrp->hostinfo);
871 hrp->hostinfo = NULL; /* mark as blank */
872 if (hp)
873 freehostent(hp);
874 goto nextline;
875 }
876 hrp->anonuser = anonuser;
877 hrp->statfile = statfile;
878 hrp->welcome = welcome;
879 hrp->loginmsg = loginmsg;
880 if (insert) {
881 hrp->next = NULL;
882 lhrp->next = hrp;
883 lhrp = hrp;
884 }
885 if (hp)
886 freehostent(hp);
887 }
888nextline:
889 if (mp)
890 free(mp);
891 }
892 (void) fclose(fp);
893 }
894}
895
896static void
897selecthost(su)
898 union sockunion *su;
899{
900 struct ftphost *hrp;
901 u_int16_t port;
902#ifdef INET6
903 struct in6_addr *mapped_in6 = NULL;
904#endif
905 struct addrinfo *hi;
906
907#ifdef INET6
908 /*
909 * XXX IPv4 mapped IPv6 addr consideraton,
910 * specified in rfc2373.
911 */
912 if (su->su_family == AF_INET6 &&
913 IN6_IS_ADDR_V4MAPPED(&su->su_sin6.sin6_addr))
914 mapped_in6 = &su->su_sin6.sin6_addr;
915#endif
916
917 hrp = thishost = firsthost; /* default */
918 port = su->su_port;
919 su->su_port = 0;
920 while (hrp != NULL) {
921 for (hi = hrp->hostinfo; hi != NULL; hi = hi->ai_next) {
922 if (memcmp(su, hi->ai_addr, hi->ai_addrlen) == 0) {
923 thishost = hrp;
924 break;
925 }
926#ifdef INET6
927 /* XXX IPv4 mapped IPv6 addr consideraton */
928 if (hi->ai_addr->sa_family == AF_INET && mapped_in6 != NULL &&
929 (memcmp(&mapped_in6->s6_addr[12],
930 &((struct sockaddr_in *)hi->ai_addr)->sin_addr,
931 sizeof(struct in_addr)) == 0)) {
932 thishost = hrp;
933 break;
934 }
935#endif
936 }
937 hrp = hrp->next;
938 }
939 su->su_port = port;
940 /* setup static variables as appropriate */
941 hostname = thishost->hostname;
942 ftpuser = thishost->anonuser;
943}
944#endif
945
946/*
947 * Helper function for sgetpwnam().
948 */
949static char *
950sgetsave(s)
951 char *s;
952{
953 char *new = malloc((unsigned) strlen(s) + 1);
954
955 if (new == NULL) {
956 perror_reply(421, "Local resource failure: malloc");
957 dologout(1);
958 /* NOTREACHED */
959 }
960 (void) strcpy(new, s);
961 return (new);
962}
963
964/*
965 * Save the result of a getpwnam. Used for USER command, since
966 * the data returned must not be clobbered by any other command
967 * (e.g., globbing).
968 */
969static struct passwd *
970sgetpwnam(name)
971 char *name;
972{
973 static struct passwd save;
974 struct passwd *p;
975
976 if ((p = getpwnam(name)) == NULL)
977 return (p);
978 if (save.pw_name) {
979 free(save.pw_name);
980 free(save.pw_passwd);
981 free(save.pw_gecos);
982 free(save.pw_dir);
983 free(save.pw_shell);
984 }
985 save = *p;
986 save.pw_name = sgetsave(p->pw_name);
987 save.pw_passwd = sgetsave(p->pw_passwd);
988 save.pw_gecos = sgetsave(p->pw_gecos);
989 save.pw_dir = sgetsave(p->pw_dir);
990 save.pw_shell = sgetsave(p->pw_shell);
991 return (&save);
992}
993
994static int login_attempts; /* number of failed login attempts */
995static int askpasswd; /* had user command, ask for passwd */
996static char curname[MAXLOGNAME]; /* current USER name */
997
998/*
999 * USER command.
1000 * Sets global passwd pointer pw if named account exists and is acceptable;
1001 * sets askpasswd if a PASS command is expected. If logged in previously,
1002 * need to reset state. If name is "ftp" or "anonymous", the name is not in
1003 * _PATH_FTPUSERS, and ftp account exists, set guest and pw, then just return.
1004 * If account doesn't exist, ask for passwd anyway. Otherwise, check user
1005 * requesting login privileges. Disallow anyone who does not have a standard
1006 * shell as returned by getusershell(). Disallow anyone mentioned in the file
1007 * _PATH_FTPUSERS to allow people such as root and uucp to be avoided.
1008 */
1009void
1010user(name)
1011 char *name;
1012{
1013 char *cp, *shell;
1014
1015 if (logged_in) {
1016 if (guest) {
1017 reply(530, "Can't change user from guest login.");
1018 return;
1019 } else if (dochroot) {
1020 reply(530, "Can't change user from chroot user.");
1021 return;
1022 }
1023 end_login();
1024 }
1025
1026 guest = 0;
1027 if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) {
1028 if (checkuser(_PATH_FTPUSERS, "ftp", 0, NULL) ||
1029 checkuser(_PATH_FTPUSERS, "anonymous", 0, NULL))
1030 reply(530, "User %s access denied.", name);
1031#ifdef VIRTUAL_HOSTING
1032 else if ((pw = sgetpwnam(thishost->anonuser)) != NULL) {
1033#else
1034 else if ((pw = sgetpwnam("ftp")) != NULL) {
1035#endif
1036 guest = 1;
1037 askpasswd = 1;
1038 reply(331,
1039 "Guest login ok, send your email address as password.");
1040 } else
1041 reply(530, "User %s unknown.", name);
1042 if (!askpasswd && logging)
1043 syslog(LOG_NOTICE,
1044 "ANONYMOUS FTP LOGIN REFUSED FROM %s", remotehost);
1045 return;
1046 }
1047 if (anon_only != 0) {
1048 reply(530, "Sorry, only anonymous ftp allowed.");
1049 return;
1050 }
1051
1052 if ((pw = sgetpwnam(name))) {
1053 if ((shell = pw->pw_shell) == NULL || *shell == 0)
1054 shell = _PATH_BSHELL;
1055 while ((cp = getusershell()) != NULL)
1056 if (strcmp(cp, shell) == 0)
1057 break;
1058 endusershell();
1059
1060 if (cp == NULL || checkuser(_PATH_FTPUSERS, name, 1, NULL)) {
1061 reply(530, "User %s access denied.", name);
1062 if (logging)
1063 syslog(LOG_NOTICE,
1064 "FTP LOGIN REFUSED FROM %s, %s",
1065 remotehost, name);
1066 pw = (struct passwd *) NULL;
1067 return;
1068 }
1069 }
1070 if (logging)
1071 strncpy(curname, name, sizeof(curname)-1);
1072#ifdef SKEY
1073 pwok = skeyaccess(name, NULL, remotehost, remotehost);
1074 reply(331, "%s", skey_challenge(name, pw, pwok));
1075#else
1076 reply(331, "Password required for %s.", name);
1077#endif
1078 askpasswd = 1;
1079 /*
1080 * Delay before reading passwd after first failed
1081 * attempt to slow down passwd-guessing programs.
1082 */
1083 if (login_attempts)
1084 sleep((unsigned) login_attempts);
1085}
1086
1087/*
1088 * Check if a user is in the file "fname",
1089 * return a pointer to a malloc'd string with the rest
1090 * of the matching line in "residue" if not NULL.
1091 */
1092static int
1093checkuser(fname, name, pwset, residue)
1094 char *fname;
1095 char *name;
1096 int pwset;
1097 char **residue;
1098{
1099 FILE *fd;
1100 int found = 0;
1101 size_t len;
1102 char *line, *mp, *p;
1103
1104 if ((fd = fopen(fname, "r")) != NULL) {
1105 while (!found && (line = fgetln(fd, &len)) != NULL) {
1106 /* skip comments */
1107 if (line[0] == '#')
1108 continue;
1109 if (line[len - 1] == '\n') {
1110 line[len - 1] = '\0';
1111 mp = NULL;
1112 } else {
1113 if ((mp = malloc(len + 1)) == NULL)
1114 fatalerror("Ran out of memory.");
1115 memcpy(mp, line, len);
1116 mp[len] = '\0';
1117 line = mp;
1118 }
1119 /* avoid possible leading and trailing whitespace */
1120 p = strtok(line, " \t");
1121 /* skip empty lines */
1122 if (p == NULL)
1123 goto nextline;
1124 /*
1125 * if first chr is '@', check group membership
1126 */
1127 if (p[0] == '@') {
1128 int i = 0;
1129 struct group *grp;
1130
1131 if (p[1] == '\0') /* single @ matches anyone */
1132 found = 1;
1133 else {
1134 if ((grp = getgrnam(p+1)) == NULL)
1135 goto nextline;
1136 /*
1137 * Check user's default group
1138 */
1139 if (pwset && grp->gr_gid == pw->pw_gid)
1140 found = 1;
1141 /*
1142 * Check supplementary groups
1143 */
1144 while (!found && grp->gr_mem[i])
1145 found = strcmp(name,
1146 grp->gr_mem[i++])
1147 == 0;
1148 }
1149 }
1150 /*
1151 * Otherwise, just check for username match
1152 */
1153 else
1154 found = strcmp(p, name) == 0;
1155 /*
1156 * Save the rest of line to "residue" if matched
1157 */
1158 if (found && residue) {
1159 if ((p = strtok(NULL, "")) != NULL)
1160 p += strspn(p, " \t");
1161 if (p && *p) {
1162 if ((*residue = strdup(p)) == NULL)
1163 fatalerror("Ran out of memory.");
1164 } else
1165 *residue = NULL;
1166 }
1167nextline:
1168 if (mp)
1169 free(mp);
1170 }
1171 (void) fclose(fd);
1172 }
1173 return (found);
1174}
1175
1176/*
1177 * Terminate login as previous user, if any, resetting state;
1178 * used when USER command is given or login fails.
1179 */
1180static void
1181end_login()
1182{
1183
1184 (void) seteuid((uid_t)0);
1185 if (logged_in && dowtmp)
1186 ftpd_logwtmp(ttyline, "", NULL);
1187 pw = NULL;
1188#ifdef LOGIN_CAP
1189 setusercontext(NULL, getpwuid(0), (uid_t)0,
1190 LOGIN_SETPRIORITY|LOGIN_SETRESOURCES|LOGIN_SETUMASK);
1191#endif
1192 logged_in = 0;
1193 guest = 0;
1194 dochroot = 0;
1195}
1196
1197#if !defined(NOPAM)
1198
1199/*
1200 * the following code is stolen from imap-uw PAM authentication module and
1201 * login.c
1202 */
1203#define COPY_STRING(s) (s ? strdup(s) : NULL)
1204
1205struct cred_t {
1206 const char *uname; /* user name */
1207 const char *pass; /* password */
1208};
1209typedef struct cred_t cred_t;
1210
1211static int
1212auth_conv(int num_msg, const struct pam_message **msg,
1213 struct pam_response **resp, void *appdata)
1214{
1215 int i;
1216 cred_t *cred = (cred_t *) appdata;
1217 struct pam_response *reply =
1218 malloc(sizeof(struct pam_response) * num_msg);
1219
1220 for (i = 0; i < num_msg; i++) {
1221 switch (msg[i]->msg_style) {
1222 case PAM_PROMPT_ECHO_ON: /* assume want user name */
1223 reply[i].resp_retcode = PAM_SUCCESS;
1224 reply[i].resp = COPY_STRING(cred->uname);
1225 /* PAM frees resp. */
1226 break;
1227 case PAM_PROMPT_ECHO_OFF: /* assume want password */
1228 reply[i].resp_retcode = PAM_SUCCESS;
1229 reply[i].resp = COPY_STRING(cred->pass);
1230 /* PAM frees resp. */
1231 break;
1232 case PAM_TEXT_INFO:
1233 case PAM_ERROR_MSG:
1234 reply[i].resp_retcode = PAM_SUCCESS;
1235 reply[i].resp = NULL;
1236 break;
1237 default: /* unknown message style */
1238 free(reply);
1239 return PAM_CONV_ERR;
1240 }
1241 }
1242
1243 *resp = reply;
1244 return PAM_SUCCESS;
1245}
1246
1247/*
1248 * Attempt to authenticate the user using PAM. Returns 0 if the user is
1249 * authenticated, or 1 if not authenticated. If some sort of PAM system
1250 * error occurs (e.g., the "/etc/pam.conf" file is missing) then this
1251 * function returns -1. This can be used as an indication that we should
1252 * fall back to a different authentication mechanism.
1253 */
1254static int
1255auth_pam(struct passwd **ppw, const char *pass)
1256{
1257 pam_handle_t *pamh = NULL;
1258 const char *tmpl_user;
1259 const void *item;
1260 int rval;
1261 int e;
1262 cred_t auth_cred = { (*ppw)->pw_name, pass };
1263 struct pam_conv conv = { &auth_conv, &auth_cred };
1264
1265 e = pam_start("ftpd", (*ppw)->pw_name, &conv, &pamh);
1266 if (e != PAM_SUCCESS) {
1267 syslog(LOG_ERR, "pam_start: %s", pam_strerror(pamh, e));
1268 return -1;
1269 }
1270
1271 e = pam_set_item(pamh, PAM_RHOST, remotehost);
1272 if (e != PAM_SUCCESS) {
1273 syslog(LOG_ERR, "pam_set_item(PAM_RHOST): %s",
1274 pam_strerror(pamh, e));
1275 return -1;
1276 }
1277
1278 e = pam_authenticate(pamh, 0);
1279 switch (e) {
1280 case PAM_SUCCESS:
1281 /*
1282 * With PAM we support the concept of a "template"
1283 * user. The user enters a login name which is
1284 * authenticated by PAM, usually via a remote service
1285 * such as RADIUS or TACACS+. If authentication
1286 * succeeds, a different but related "template" name
1287 * is used for setting the credentials, shell, and
1288 * home directory. The name the user enters need only
1289 * exist on the remote authentication server, but the
1290 * template name must be present in the local password
1291 * database.
1292 *
1293 * This is supported by two various mechanisms in the
1294 * individual modules. However, from the application's
1295 * point of view, the template user is always passed
1296 * back as a changed value of the PAM_USER item.
1297 */
1298 if ((e = pam_get_item(pamh, PAM_USER, &item)) ==
1299 PAM_SUCCESS) {
1300 tmpl_user = (const char *) item;
1301 if (strcmp((*ppw)->pw_name, tmpl_user) != 0)
1302 *ppw = getpwnam(tmpl_user);
1303 } else
1304 syslog(LOG_ERR, "Couldn't get PAM_USER: %s",
1305 pam_strerror(pamh, e));
1306 rval = 0;
1307 break;
1308
1309 case PAM_AUTH_ERR:
1310 case PAM_USER_UNKNOWN:
1311 case PAM_MAXTRIES:
1312 rval = 1;
1313 break;
1314
1315 default:
1316 syslog(LOG_ERR, "auth_pam: %s", pam_strerror(pamh, e));
1317 rval = -1;
1318 break;
1319 }
1320
1321 if ((e = pam_end(pamh, e)) != PAM_SUCCESS) {
1322 syslog(LOG_ERR, "pam_end: %s", pam_strerror(pamh, e));
1323 rval = -1;
1324 }
1325 return rval;
1326}
1327
1328#endif /* !defined(NOPAM) */
1329
1330void
1331pass(passwd)
1332 char *passwd;
1333{
1334 int rval;
1335 FILE *fd;
1336#ifdef LOGIN_CAP
1337 login_cap_t *lc = NULL;
1338#endif
1339 char *chrootdir;
1340 char *residue = NULL;
1341
1342 if (logged_in || askpasswd == 0) {
1343 reply(503, "Login with USER first.");
1344 return;
1345 }
1346 askpasswd = 0;
1347 if (!guest) { /* "ftp" is only account allowed no password */
1348 if (pw == NULL) {
1349 rval = 1; /* failure below */
1350 goto skip;
1351 }
1352#if !defined(NOPAM)
1353 rval = auth_pam(&pw, passwd);
1354 if (rval >= 0)
1355 goto skip;
1356#endif
1357#ifdef SKEY
1358 if (pwok)
1359 rval = strcmp(pw->pw_passwd,
1360 crypt(passwd, pw->pw_passwd));
1361 if (rval)
1362 rval = strcmp(pw->pw_passwd,
1363 skey_crypt(passwd, pw->pw_passwd, pw, pwok));
1364#else
1365 rval = strcmp(pw->pw_passwd, crypt(passwd, pw->pw_passwd));
1366#endif
1367 /* The strcmp does not catch null passwords! */
1368 if (*pw->pw_passwd == '\0' ||
1369 (pw->pw_expire && time(NULL) >= pw->pw_expire))
1370 rval = 1; /* failure */
1371skip:
1372 /*
1373 * If rval == 1, the user failed the authentication check
1374 * above. If rval == 0, either PAM or local authentication
1375 * succeeded.
1376 */
1377 if (rval) {
1378 reply(530, "Login incorrect.");
1379 if (logging) {
1380 syslog(LOG_NOTICE,
1381 "FTP LOGIN FAILED FROM %s",
1382 remotehost);
1383 syslog(LOG_AUTHPRIV | LOG_NOTICE,
1384 "FTP LOGIN FAILED FROM %s, %s",
1385 remotehost, curname);
1386 }
1387 pw = NULL;
1388 if (login_attempts++ >= 5) {
1389 syslog(LOG_NOTICE,
1390 "repeated login failures from %s",
1391 remotehost);
1392 exit(0);
1393 }
1394 return;
1395 }
1396 }
1397#ifdef SKEY
1398 pwok = 0;
1399#endif
1400 login_attempts = 0; /* this time successful */
1401 if (setegid((gid_t)pw->pw_gid) < 0) {
1402 reply(550, "Can't set gid.");
1403 return;
1404 }
1405 /* May be overridden by login.conf */
1406 (void) umask(defumask);
1407#ifdef LOGIN_CAP
1408 if ((lc = login_getpwclass(pw)) != NULL) {
1409 char remote_ip[MAXHOSTNAMELEN];
1410
1411 getnameinfo((struct sockaddr *)&his_addr, his_addr.su_len,
1412 remote_ip, sizeof(remote_ip) - 1, NULL, 0,
1413 NI_NUMERICHOST);
1414 remote_ip[sizeof(remote_ip) - 1] = 0;
1415 if (!auth_hostok(lc, remotehost, remote_ip)) {
1416 syslog(LOG_INFO|LOG_AUTH,
1417 "FTP LOGIN FAILED (HOST) as %s: permission denied.",
1418 pw->pw_name);
1419 reply(530, "Permission denied.\n");
1420 pw = NULL;
1421 return;
1422 }
1423 if (!auth_timeok(lc, time(NULL))) {
1424 reply(530, "Login not available right now.\n");
1425 pw = NULL;
1426 return;
1427 }
1428 }
1429 setusercontext(lc, pw, (uid_t)0,
1430 LOGIN_SETLOGIN|LOGIN_SETGROUP|LOGIN_SETPRIORITY|
1431 LOGIN_SETRESOURCES|LOGIN_SETUMASK);
1432#else
1433 setlogin(pw->pw_name);
1434 (void) initgroups(pw->pw_name, pw->pw_gid);
1435#endif
1436
1437 /* open wtmp before chroot */
1438 if (dowtmp)
1439 ftpd_logwtmp(ttyline, pw->pw_name,
1440 (struct sockaddr *)&his_addr);
1441 logged_in = 1;
1442
1443 if (guest && stats && statfd < 0)
1444#ifdef VIRTUAL_HOSTING
1445 if ((statfd = open(thishost->statfile, O_WRONLY|O_APPEND)) < 0)
1446#else
1447 if ((statfd = open(_PATH_FTPDSTATFILE, O_WRONLY|O_APPEND)) < 0)
1448#endif
1449 stats = 0;
1450
1451 dochroot =
1452 checkuser(_PATH_FTPCHROOT, pw->pw_name, 1, &residue)
1453#ifdef LOGIN_CAP /* Allow login.conf configuration as well */
1454 || login_getcapbool(lc, "ftp-chroot", 0)
1455#endif
1456 ;
1457 chrootdir = NULL;
1458 /*
1459 * For a chrooted local user,
1460 * a) see whether ftpchroot(5) specifies a chroot directory,
1461 * b) extract the directory pathname from the line,
1462 * c) expand it to the absolute pathname if necessary.
1463 */
1464 if (dochroot && residue &&
1465 (chrootdir = strtok(residue, " \t")) != NULL &&
1466 chrootdir[0] != '/') {
1467 asprintf(&chrootdir, "%s/%s", pw->pw_dir, chrootdir);
1468 if (chrootdir == NULL)
1469 fatalerror("Ran out of memory.");
1470 }
1471 if (guest || dochroot) {
1472 /*
1473 * If no chroot directory set yet, use the login directory.
1474 * Copy it so it can be modified while pw->pw_dir stays intact.
1475 */
1476 if (chrootdir == NULL &&
1477 (chrootdir = strdup(pw->pw_dir)) == NULL)
1478 fatalerror("Ran out of memory.");
1479 /*
1480 * Check for the "/chroot/./home" syntax,
1481 * separate the chroot and home directory pathnames.
1482 */
1483 if ((homedir = strstr(chrootdir, "/./")) != NULL) {
1484 *(homedir++) = '\0'; /* wipe '/' */
1485 homedir++; /* skip '.' */
1486 /* so chrootdir can be freed later */
1487 if ((homedir = strdup(homedir)) == NULL)
1488 fatalerror("Ran out of memory.");
1489 } else {
1490 /*
1491 * We MUST do a chdir() after the chroot. Otherwise
1492 * the old current directory will be accessible as "."
1493 * outside the new root!
1494 */
1495 homedir = "/";
1496 }
1497 /*
1498 * Finally, do chroot()
1499 */
1500 if (chroot(chrootdir) < 0) {
1501 reply(550, "Can't change root.");
1502 goto bad;
1503 }
1504 } else /* real user w/o chroot */
1505 homedir = pw->pw_dir;
1506 /*
1507 * Set euid *before* doing chdir() so
1508 * a) the user won't be carried to a directory that he couldn't reach
1509 * on his own due to no permission to upper path components,
1510 * b) NFS mounted homedirs w/restrictive permissions will be accessible
1511 * (uid 0 has no root power over NFS if not mapped explicitly.)
1512 */
1513 if (seteuid((uid_t)pw->pw_uid) < 0) {
1514 reply(550, "Can't set uid.");
1515 goto bad;
1516 }
1517 if (chdir(homedir) < 0) {
1518 if (guest || dochroot) {
1519 reply(550, "Can't change to base directory.");
1520 goto bad;
1521 } else {
1522 if (chdir("/") < 0) {
1523 reply(550, "Root is inaccessible.");
1524 goto bad;
1525 }
1526 lreply(230, "No directory! Logging in with home=/");
1527 }
1528 }
1529
1530 /*
1531 * Display a login message, if it exists.
1532 * N.B. reply(230,) must follow the message.
1533 */
1534#ifdef VIRTUAL_HOSTING
1535 if ((fd = fopen(thishost->loginmsg, "r")) != NULL) {
1536#else
1537 if ((fd = fopen(_PATH_FTPLOGINMESG, "r")) != NULL) {
1538#endif
1539 char *cp, line[LINE_MAX];
1540
1541 while (fgets(line, sizeof(line), fd) != NULL) {
1542 if ((cp = strchr(line, '\n')) != NULL)
1543 *cp = '\0';
1544 lreply(230, "%s", line);
1545 }
1546 (void) fflush(stdout);
1547 (void) fclose(fd);
1548 }
1549 if (guest) {
1550 if (ident != NULL)
1551 free(ident);
1552 ident = strdup(passwd);
1553 if (ident == NULL)
1554 fatalerror("Ran out of memory.");
1555
1556 reply(230, "Guest login ok, access restrictions apply.");
1557#ifdef SETPROCTITLE
1558#ifdef VIRTUAL_HOSTING
1559 if (thishost != firsthost)
1560 snprintf(proctitle, sizeof(proctitle),
1561 "%s: anonymous(%s)/%s", remotehost, hostname,
1562 passwd);
1563 else
1564#endif
1565 snprintf(proctitle, sizeof(proctitle),
1566 "%s: anonymous/%s", remotehost, passwd);
1567 setproctitle("%s", proctitle);
1568#endif /* SETPROCTITLE */
1569 if (logging)
1570 syslog(LOG_INFO, "ANONYMOUS FTP LOGIN FROM %s, %s",
1571 remotehost, passwd);
1572 } else {
1573 if (dochroot)
1574 reply(230, "User %s logged in, "
1575 "access restrictions apply.", pw->pw_name);
1576 else
1577 reply(230, "User %s logged in.", pw->pw_name);
1578
1579#ifdef SETPROCTITLE
1580 snprintf(proctitle, sizeof(proctitle),
1581 "%s: user/%s", remotehost, pw->pw_name);
1582 setproctitle("%s", proctitle);
1583#endif /* SETPROCTITLE */
1584 if (logging)
1585 syslog(LOG_INFO, "FTP LOGIN FROM %s as %s",
1586 remotehost, pw->pw_name);
1587 }
1588#ifdef LOGIN_CAP
1589 login_close(lc);
1590#endif
1591 if (chrootdir)
1592 free(chrootdir);
1593 if (residue)
1594 free(residue);
1595 return;
1596bad:
1597 /* Forget all about it... */
1598#ifdef LOGIN_CAP
1599 login_close(lc);
1600#endif
1601 if (chrootdir)
1602 free(chrootdir);
1603 if (residue)
1604 free(residue);
1605 end_login();
1606}
1607
1608void
1609retrieve(cmd, name)
1610 char *cmd, *name;
1611{
1612 FILE *fin, *dout;
1613 struct stat st;
1614 int (*closefunc) __P((FILE *));
1615 time_t start;
1616
1617 if (cmd == 0) {
1618 fin = fopen(name, "r"), closefunc = fclose;
1619 st.st_size = 0;
1620 } else {
1621 char line[BUFSIZ];
1622
1623 (void) snprintf(line, sizeof(line), cmd, name), name = line;
1624 fin = ftpd_popen(line, "r"), closefunc = ftpd_pclose;
1625 st.st_size = -1;
1626 st.st_blksize = BUFSIZ;
1627 }
1628 if (fin == NULL) {
1629 if (errno != 0) {
1630 perror_reply(550, name);
1631 if (cmd == 0) {
1632 LOGCMD("get", name);
1633 }
1634 }
1635 return;
1636 }
1637 byte_count = -1;
1638 if (cmd == 0) {
1639 if (fstat(fileno(fin), &st) < 0) {
1640 perror_reply(550, name);
1641 goto done;
1642 }
1643 if (!S_ISREG(st.st_mode)) {
1644 if (guest) {
1645 reply(550, "%s: not a plain file.", name);
1646 goto done;
1647 }
1648 st.st_size = -1;
1649 /* st.st_blksize is set for all descriptor types */
1650 }
1651 }
1652 if (restart_point) {
1653 if (type == TYPE_A) {
1654 off_t i, n;
1655 int c;
1656
1657 n = restart_point;
1658 i = 0;
1659 while (i++ < n) {
1660 if ((c=getc(fin)) == EOF) {
1661 perror_reply(550, name);
1662 goto done;
1663 }
1664 if (c == '\n')
1665 i++;
1666 }
1667 } else if (lseek(fileno(fin), restart_point, L_SET) < 0) {
1668 perror_reply(550, name);
1669 goto done;
1670 }
1671 }
1672 dout = dataconn(name, st.st_size, "w");
1673 if (dout == NULL)
1674 goto done;
1675 time(&start);
1676 send_data(fin, dout, st.st_blksize, st.st_size,
1677 restart_point == 0 && cmd == 0 && S_ISREG(st.st_mode));
1678 if (cmd == 0 && guest && stats)
1679 logxfer(name, st.st_size, start);
1680 (void) fclose(dout);
1681 data = -1;
1682 pdata = -1;
1683done:
1684 if (cmd == 0)
1685 LOGBYTES("get", name, byte_count);
1686 (*closefunc)(fin);
1687}
1688
1689void
1690store(name, mode, unique)
1691 char *name, *mode;
1692 int unique;
1693{
1694 int fd;
1695 FILE *fout, *din;
1696 int (*closefunc) __P((FILE *));
1697
1698 if (*mode == 'a') { /* APPE */
1699 if (unique) {
1700 /* Programming error */
1701 syslog(LOG_ERR, "Internal: unique flag to APPE");
1702 unique = 0;
1703 }
1704 if (guest && noguestmod) {
1705 reply(550, "Appending to existing file denied");
1706 goto err;
1707 }
1708 restart_point = 0; /* not affected by preceding REST */
1709 }
1710 if (unique) /* STOU overrides REST */
1711 restart_point = 0;
1712 if (guest && noguestmod) {
1713 if (restart_point) { /* guest STOR w/REST */
1714 reply(550, "Modifying existing file denied");
1715 goto err;
1716 } else /* treat guest STOR as STOU */
1717 unique = 1;
1718 }
1719
1720 if (restart_point)
1721 mode = "r+"; /* so ASCII manual seek can work */
1722 if (unique) {
1723 if ((fd = guniquefd(name, &name)) < 0)
1724 goto err;
1725 fout = fdopen(fd, mode);
1726 } else
1727 fout = fopen(name, mode);
1728 closefunc = fclose;
1729 if (fout == NULL) {
1730 perror_reply(553, name);
1731 goto err;
1732 }
1733 byte_count = -1;
1734 if (restart_point) {
1735 if (type == TYPE_A) {
1736 off_t i, n;
1737 int c;
1738
1739 n = restart_point;
1740 i = 0;
1741 while (i++ < n) {
1742 if ((c=getc(fout)) == EOF) {
1743 perror_reply(550, name);
1744 goto done;
1745 }
1746 if (c == '\n')
1747 i++;
1748 }
1749 /*
1750 * We must do this seek to "current" position
1751 * because we are changing from reading to
1752 * writing.
1753 */
1754 if (fseeko(fout, (off_t)0, SEEK_CUR) < 0) {
1755 perror_reply(550, name);
1756 goto done;
1757 }
1758 } else if (lseek(fileno(fout), restart_point, L_SET) < 0) {
1759 perror_reply(550, name);
1760 goto done;
1761 }
1762 }
1763 din = dataconn(name, (off_t)-1, "r");
1764 if (din == NULL)
1765 goto done;
1766 if (receive_data(din, fout) == 0) {
1767 if (unique)
1768 reply(226, "Transfer complete (unique file name:%s).",
1769 name);
1770 else
1771 reply(226, "Transfer complete.");
1772 }
1773 (void) fclose(din);
1774 data = -1;
1775 pdata = -1;
1776done:
1777 LOGBYTES(*mode == 'a' ? "append" : "put", name, byte_count);
1778 (*closefunc)(fout);
1779 return;
1780err:
1781 LOGCMD(*mode == 'a' ? "append" : "put" , name);
1782 return;
1783}
1784
1785static FILE *
1786getdatasock(mode)
1787 char *mode;
1788{
1789 int on = 1, s, t, tries;
1790
1791 if (data >= 0)
1792 return (fdopen(data, mode));
1793 (void) seteuid((uid_t)0);
1794
1795 s = socket(data_dest.su_family, SOCK_STREAM, 0);
1796 if (s < 0)
1797 goto bad;
1798 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
1799 syslog(LOG_WARNING, "data setsockopt (SO_REUSEADDR): %m");
1800 /* anchor socket to avoid multi-homing problems */
1801 data_source = ctrl_addr;
1802 data_source.su_port = htons(dataport);
1803 for (tries = 1; ; tries++) {
1804 if (bind(s, (struct sockaddr *)&data_source,
1805 data_source.su_len) >= 0)
1806 break;
1807 if (errno != EADDRINUSE || tries > 10)
1808 goto bad;
1809 sleep(tries);
1810 }
1811 (void) seteuid((uid_t)pw->pw_uid);
1812#ifdef IP_TOS
1813 if (data_source.su_family == AF_INET)
1814 {
1815 on = IPTOS_THROUGHPUT;
1816 if (setsockopt(s, IPPROTO_IP, IP_TOS, &on, sizeof(int)) < 0)
1817 syslog(LOG_WARNING, "data setsockopt (IP_TOS): %m");
1818 }
1819#endif
1820#ifdef TCP_NOPUSH
1821 /*
1822 * Turn off push flag to keep sender TCP from sending short packets
1823 * at the boundaries of each write(). Should probably do a SO_SNDBUF
1824 * to set the send buffer size as well, but that may not be desirable
1825 * in heavy-load situations.
1826 */
1827 on = 1;
1828 if (setsockopt(s, IPPROTO_TCP, TCP_NOPUSH, &on, sizeof on) < 0)
1829 syslog(LOG_WARNING, "data setsockopt (TCP_NOPUSH): %m");
1830#endif
1831#ifdef SO_SNDBUF
1832 on = 65536;
1833 if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &on, sizeof on) < 0)
1834 syslog(LOG_WARNING, "data setsockopt (SO_SNDBUF): %m");
1835#endif
1836
1837 return (fdopen(s, mode));
1838bad:
1839 /* Return the real value of errno (close may change it) */
1840 t = errno;
1841 (void) seteuid((uid_t)pw->pw_uid);
1842 (void) close(s);
1843 errno = t;
1844 return (NULL);
1845}
1846
1847static FILE *
1848dataconn(name, size, mode)
1849 char *name;
1850 off_t size;
1851 char *mode;
1852{
1853 char sizebuf[32];
1854 FILE *file;
1855 int retry = 0, tos, conerrno;
1856
1857 file_size = size;
1858 byte_count = 0;
1859 if (size != (off_t) -1)
1860 (void) snprintf(sizebuf, sizeof(sizebuf), " (%qd bytes)", size);
1861 else
1862 *sizebuf = '\0';
1863 if (pdata >= 0) {
1864 union sockunion from;
1865 int flags;
1866 int s, fromlen = ctrl_addr.su_len;
1867 struct timeval timeout;
1868 fd_set set;
1869
1870 FD_ZERO(&set);
1871 FD_SET(pdata, &set);
1872
1873 timeout.tv_usec = 0;
1874 timeout.tv_sec = 120;
1875
1876 /*
1877 * Granted a socket is in the blocking I/O mode,
1878 * accept() will block after a successful select()
1879 * if the selected connection dies in between.
1880 * Therefore set the non-blocking I/O flag here.
1881 */
1882 if ((flags = fcntl(pdata, F_GETFL, 0)) == -1 ||
1883 fcntl(pdata, F_SETFL, flags | O_NONBLOCK) == -1)
1884 goto pdata_err;
1885 if (select(pdata+1, &set, (fd_set *) 0, (fd_set *) 0, &timeout) <= 0 ||
1886 (s = accept(pdata, (struct sockaddr *) &from, &fromlen)) < 0)
1887 goto pdata_err;
1888 (void) close(pdata);
1889 pdata = s;
1890 /*
1891 * Unset the inherited non-blocking I/O flag
1892 * on the child socket so stdio can work on it.
1893 */
1894 if ((flags = fcntl(pdata, F_GETFL, 0)) == -1 ||
1895 fcntl(pdata, F_SETFL, flags & ~O_NONBLOCK) == -1)
1896 goto pdata_err;
1897#ifdef IP_TOS
1898 if (from.su_family == AF_INET)
1899 {
1900 tos = IPTOS_THROUGHPUT;
1901 if (setsockopt(s, IPPROTO_IP, IP_TOS, &tos, sizeof(int)) < 0)
1902 syslog(LOG_WARNING, "pdata setsockopt (IP_TOS): %m");
1903 }
1904#endif
1905 reply(150, "Opening %s mode data connection for '%s'%s.",
1906 type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
1907 return (fdopen(pdata, mode));
1908pdata_err:
1909 reply(425, "Can't open data connection.");
1910 (void) close(pdata);
1911 pdata = -1;
1912 return (NULL);
1913 }
1914 if (data >= 0) {
1915 reply(125, "Using existing data connection for '%s'%s.",
1916 name, sizebuf);
1917 usedefault = 1;
1918 return (fdopen(data, mode));
1919 }
1920 if (usedefault)
1921 data_dest = his_addr;
1922 usedefault = 1;
1923 do {
1924 file = getdatasock(mode);
1925 if (file == NULL) {
1926 char hostbuf[BUFSIZ], portbuf[BUFSIZ];
1927 getnameinfo((struct sockaddr *)&data_source,
1928 data_source.su_len, hostbuf, sizeof(hostbuf) - 1,
1929 portbuf, sizeof(portbuf),
1930 NI_NUMERICHOST|NI_NUMERICSERV);
1931 reply(425, "Can't create data socket (%s,%s): %s.",
1932 hostbuf, portbuf, strerror(errno));
1933 return (NULL);
1934 }
1935 data = fileno(file);
1936 conerrno = 0;
1937 if (connect(data, (struct sockaddr *)&data_dest,
1938 data_dest.su_len) == 0)
1939 break;
1940 conerrno = errno;
1941 (void) fclose(file);
1942 data = -1;
1943 if (conerrno == EADDRINUSE) {
1944 sleep((unsigned) swaitint);
1945 retry += swaitint;
1946 } else {
1947 break;
1948 }
1949 } while (retry <= swaitmax);
1950 if (conerrno != 0) {
1951 perror_reply(425, "Can't build data connection");
1952 return (NULL);
1953 }
1954 reply(150, "Opening %s mode data connection for '%s'%s.",
1955 type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
1956 return (file);
1957}
1958
1959/*
1960 * Tranfer the contents of "instr" to "outstr" peer using the appropriate
1961 * encapsulation of the data subject to Mode, Structure, and Type.
1962 *
1963 * NB: Form isn't handled.
1964 */
1965static int
1966send_data(instr, outstr, blksize, filesize, isreg)
1967 FILE *instr, *outstr;
1968 off_t blksize;
1969 off_t filesize;
1970 int isreg;
1971{
1972 int c, filefd, netfd;
1973 char *buf;
1974 off_t cnt;
1975
1976 transflag++;
1977 switch (type) {
1978
1979 case TYPE_A:
1980 while ((c = getc(instr)) != EOF) {
1981 if (recvurg)
1982 goto got_oob;
1983 byte_count++;
1984 if (c == '\n') {
1985 if (ferror(outstr))
1986 goto data_err;
1987 (void) putc('\r', outstr);
1988 }
1989 (void) putc(c, outstr);
1990 }
1991 if (recvurg)
1992 goto got_oob;
1993 fflush(outstr);
1994 transflag = 0;
1995 if (ferror(instr))
1996 goto file_err;
1997 if (ferror(outstr))
1998 goto data_err;
1999 reply(226, "Transfer complete.");
2000 return (0);
2001
2002 case TYPE_I:
2003 case TYPE_L:
2004 /*
2005 * isreg is only set if we are not doing restart and we
2006 * are sending a regular file
2007 */
2008 netfd = fileno(outstr);
2009 filefd = fileno(instr);
2010
2011 if (isreg) {
2012
2013 off_t offset;
2014 int err;
2015
2016 err = cnt = offset = 0;
2017
2018 while (err != -1 && filesize > 0) {
2019 err = sendfile(filefd, netfd, offset, 0,
2020 (struct sf_hdtr *) NULL, &cnt, 0);
2021 /*
2022 * Calculate byte_count before OOB processing.
2023 * It can be used in myoob() later.
2024 */
2025 byte_count += cnt;
2026 if (recvurg)
2027 goto got_oob;
2028 offset += cnt;
2029 filesize -= cnt;
2030
2031 if (err == -1) {
2032 if (!cnt)
2033 goto oldway;
2034
2035 goto data_err;
2036 }
2037 }
2038
2039 transflag = 0;
2040 reply(226, "Transfer complete.");
2041 return (0);
2042 }
2043
2044oldway:
2045 if ((buf = malloc((u_int)blksize)) == NULL) {
2046 transflag = 0;
2047 perror_reply(451, "Local resource failure: malloc");
2048 return (-1);
2049 }
2050
2051 while ((cnt = read(filefd, buf, (u_int)blksize)) > 0 &&
2052 write(netfd, buf, cnt) == cnt)
2053 byte_count += cnt;
2054 transflag = 0;
2055 (void)free(buf);
2056 if (cnt != 0) {
2057 if (cnt < 0)
2058 goto file_err;
2059 goto data_err;
2060 }
2061 reply(226, "Transfer complete.");
2062 return (0);
2063 default:
2064 transflag = 0;
2065 reply(550, "Unimplemented TYPE %d in send_data", type);
2066 return (-1);
2067 }
2068
2069data_err:
2070 transflag = 0;
2071 perror_reply(426, "Data connection");
2072 return (-1);
2073
2074file_err:
2075 transflag = 0;
2076 perror_reply(551, "Error on input file");
2077 return (-1);
2078
2079got_oob:
2080 myoob();
2081 recvurg = 0;
2082 transflag = 0;
2083 return (-1);
2084}
2085
2086/*
2087 * Transfer data from peer to "outstr" using the appropriate encapulation of
2088 * the data subject to Mode, Structure, and Type.
2089 *
2090 * N.B.: Form isn't handled.
2091 */
2092static int
2093receive_data(instr, outstr)
2094 FILE *instr, *outstr;
2095{
2096 int c;
2097 int cnt, bare_lfs;
2098 char buf[BUFSIZ];
2099
2100 transflag++;
2101 bare_lfs = 0;
2102
2103 switch (type) {
2104
2105 case TYPE_I:
2106 case TYPE_L:
2107 while ((cnt = read(fileno(instr), buf, sizeof(buf))) > 0) {
2108 if (recvurg)
2109 goto got_oob;
2110 if (write(fileno(outstr), buf, cnt) != cnt)
2111 goto file_err;
2112 byte_count += cnt;
2113 }
2114 if (recvurg)
2115 goto got_oob;
2116 if (cnt < 0)
2117 goto data_err;
2118 transflag = 0;
2119 return (0);
2120
2121 case TYPE_E:
2122 reply(553, "TYPE E not implemented.");
2123 transflag = 0;
2124 return (-1);
2125
2126 case TYPE_A:
2127 while ((c = getc(instr)) != EOF) {
2128 if (recvurg)
2129 goto got_oob;
2130 byte_count++;
2131 if (c == '\n')
2132 bare_lfs++;
2133 while (c == '\r') {
2134 if (ferror(outstr))
2135 goto data_err;
2136 if ((c = getc(instr)) != '\n') {
2137 (void) putc ('\r', outstr);
2138 if (c == '\0' || c == EOF)
2139 goto contin2;
2140 }
2141 }
2142 (void) putc(c, outstr);
2143 contin2: ;
2144 }
2145 if (recvurg)
2146 goto got_oob;
2147 fflush(outstr);
2148 if (ferror(instr))
2149 goto data_err;
2150 if (ferror(outstr))
2151 goto file_err;
2152 transflag = 0;
2153 if (bare_lfs) {
2154 lreply(226,
2155 "WARNING! %d bare linefeeds received in ASCII mode",
2156 bare_lfs);
2157 (void)printf(" File may not have transferred correctly.\r\n");
2158 }
2159 return (0);
2160 default:
2161 reply(550, "Unimplemented TYPE %d in receive_data", type);
2162 transflag = 0;
2163 return (-1);
2164 }
2165
2166data_err:
2167 transflag = 0;
2168 perror_reply(426, "Data Connection");
2169 return (-1);
2170
2171file_err:
2172 transflag = 0;
2173 perror_reply(452, "Error writing file");
2174 return (-1);
2175
2176got_oob:
2177 myoob();
2178 recvurg = 0;
2179 transflag = 0;
2180 return (-1);
2181}
2182
2183void
2184statfilecmd(filename)
2185 char *filename;
2186{
2187 FILE *fin;
2188 int atstart;
2189 int c;
2190 char line[LINE_MAX];
2191
2192 (void)snprintf(line, sizeof(line), _PATH_LS " -lgA %s", filename);
2193 fin = ftpd_popen(line, "r");
2194 lreply(211, "status of %s:", filename);
2195 atstart = 1;
2196 while ((c = getc(fin)) != EOF) {
2197 if (c == '\n') {
2198 if (ferror(stdout)){
2199 perror_reply(421, "control connection");
2200 (void) ftpd_pclose(fin);
2201 dologout(1);
2202 /* NOTREACHED */
2203 }
2204 if (ferror(fin)) {
2205 perror_reply(551, filename);
2206 (void) ftpd_pclose(fin);
2207 return;
2208 }
2209 (void) putc('\r', stdout);
2210 }
2211 /*
2212 * RFC 959 says neutral text should be prepended before
2213 * a leading 3-digit number followed by whitespace, but
2214 * many ftp clients can be confused by any leading digits,
2215 * as a matter of fact.
2216 */
2217 if (atstart && isdigit(c))
2218 (void) putc(' ', stdout);
2219 (void) putc(c, stdout);
2220 atstart = (c == '\n');
2221 }
2222 (void) ftpd_pclose(fin);
2223 reply(211, "End of Status");
2224}
2225
2226void
2227statcmd()
2228{
2229 union sockunion *su;
2230 u_char *a, *p;
2231 char hname[NI_MAXHOST];
2232 int ispassive;
2233
2234 if (hostinfo) {
2235 lreply(211, "%s FTP server status:", hostname);
2236 printf(" %s\r\n", version);
2237 } else
2238 lreply(211, "FTP server status:");
2239 printf(" Connected to %s", remotehost);
2240 if (!getnameinfo((struct sockaddr *)&his_addr, his_addr.su_len,
2241 hname, sizeof(hname) - 1, NULL, 0, NI_NUMERICHOST)) {
2242 if (strcmp(hname, remotehost) != 0)
2243 printf(" (%s)", hname);
2244 }
2245 printf("\r\n");
2246 if (logged_in) {
2247 if (guest)
2248 printf(" Logged in anonymously\r\n");
2249 else
2250 printf(" Logged in as %s\r\n", pw->pw_name);
2251 } else if (askpasswd)
2252 printf(" Waiting for password\r\n");
2253 else
2254 printf(" Waiting for user name\r\n");
2255 printf(" TYPE: %s", typenames[type]);
2256 if (type == TYPE_A || type == TYPE_E)
2257 printf(", FORM: %s", formnames[form]);
2258 if (type == TYPE_L)
2259#if NBBY == 8
2260 printf(" %d", NBBY);
2261#else
2262 printf(" %d", bytesize); /* need definition! */
2263#endif
2264 printf("; STRUcture: %s; transfer MODE: %s\r\n",
2265 strunames[stru], modenames[mode]);
2266 if (data != -1)
2267 printf(" Data connection open\r\n");
2268 else if (pdata != -1) {
2269 ispassive = 1;
2270 su = &pasv_addr;
2271 goto printaddr;
2272 } else if (usedefault == 0) {
2273 ispassive = 0;
2274 su = &data_dest;
2275printaddr:
2276#define UC(b) (((int) b) & 0xff)
2277 if (epsvall) {
2278 printf(" EPSV only mode (EPSV ALL)\r\n");
2279 goto epsvonly;
2280 }
2281
2282 /* PORT/PASV */
2283 if (su->su_family == AF_INET) {
2284 a = (u_char *) &su->su_sin.sin_addr;
2285 p = (u_char *) &su->su_sin.sin_port;
2286 printf(" %s (%d,%d,%d,%d,%d,%d)\r\n",
2287 ispassive ? "PASV" : "PORT",
2288 UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
2289 UC(p[0]), UC(p[1]));
2290 }
2291
2292 /* LPRT/LPSV */
2293 {
2294 int alen, af, i;
2295
2296 switch (su->su_family) {
2297 case AF_INET:
2298 a = (u_char *) &su->su_sin.sin_addr;
2299 p = (u_char *) &su->su_sin.sin_port;
2300 alen = sizeof(su->su_sin.sin_addr);
2301 af = 4;
2302 break;
2303 case AF_INET6:
2304 a = (u_char *) &su->su_sin6.sin6_addr;
2305 p = (u_char *) &su->su_sin6.sin6_port;
2306 alen = sizeof(su->su_sin6.sin6_addr);
2307 af = 6;
2308 break;
2309 default:
2310 af = 0;
2311 break;
2312 }
2313 if (af) {
2314 printf(" %s (%d,%d,", ispassive ? "LPSV" : "LPRT",
2315 af, alen);
2316 for (i = 0; i < alen; i++)
2317 printf("%d,", UC(a[i]));
2318 printf("%d,%d,%d)\r\n", 2, UC(p[0]), UC(p[1]));
2319 }
2320 }
2321
2322epsvonly:;
2323 /* EPRT/EPSV */
2324 {
2325 int af;
2326
2327 switch (su->su_family) {
2328 case AF_INET:
2329 af = 1;
2330 break;
2331 case AF_INET6:
2332 af = 2;
2333 break;
2334 default:
2335 af = 0;
2336 break;
2337 }
2338 if (af) {
2339 union sockunion tmp;
2340
2341 tmp = *su;
2342 if (tmp.su_family == AF_INET6)
2343 tmp.su_sin6.sin6_scope_id = 0;
2344 if (!getnameinfo((struct sockaddr *)&tmp, tmp.su_len,
2345 hname, sizeof(hname) - 1, NULL, 0,
2346 NI_NUMERICHOST)) {
2347 printf(" %s |%d|%s|%d|\r\n",
2348 ispassive ? "EPSV" : "EPRT",
2349 af, hname, htons(tmp.su_port));
2350 }
2351 }
2352 }
2353#undef UC
2354 } else
2355 printf(" No data connection\r\n");
2356 reply(211, "End of status");
2357}
2358
2359void
2360fatalerror(s)
2361 char *s;
2362{
2363
2364 reply(451, "Error in server: %s\n", s);
2365 reply(221, "Closing connection due to server error.");
2366 dologout(0);
2367 /* NOTREACHED */
2368}
2369
2370void
2371#if __STDC__
2372reply(int n, const char *fmt, ...)
2373#else
2374reply(n, fmt, va_alist)
2375 int n;
2376 char *fmt;
2377 va_dcl
2378#endif
2379{
2380 va_list ap;
2381#if __STDC__
2382 va_start(ap, fmt);
2383#else
2384 va_start(ap);
2385#endif
2386 (void)printf("%d ", n);
2387 (void)vprintf(fmt, ap);
2388 (void)printf("\r\n");
2389 (void)fflush(stdout);
2390 if (ftpdebug) {
2391 syslog(LOG_DEBUG, "<--- %d ", n);
2392 vsyslog(LOG_DEBUG, fmt, ap);
2393 }
2394}
2395
2396void
2397#if __STDC__
2398lreply(int n, const char *fmt, ...)
2399#else
2400lreply(n, fmt, va_alist)
2401 int n;
2402 char *fmt;
2403 va_dcl
2404#endif
2405{
2406 va_list ap;
2407#if __STDC__
2408 va_start(ap, fmt);
2409#else
2410 va_start(ap);
2411#endif
2412 (void)printf("%d- ", n);
2413 (void)vprintf(fmt, ap);
2414 (void)printf("\r\n");
2415 (void)fflush(stdout);
2416 if (ftpdebug) {
2417 syslog(LOG_DEBUG, "<--- %d- ", n);
2418 vsyslog(LOG_DEBUG, fmt, ap);
2419 }
2420}
2421
2422static void
2423ack(s)
2424 char *s;
2425{
2426
2427 reply(250, "%s command successful.", s);
2428}
2429
2430void
2431nack(s)
2432 char *s;
2433{
2434
2435 reply(502, "%s command not implemented.", s);
2436}
2437
2438/* ARGSUSED */
2439void
2440yyerror(s)
2441 char *s;
2442{
2443 char *cp;
2444
2445 if ((cp = strchr(cbuf,'\n')))
2446 *cp = '\0';
2447 reply(500, "'%s': command not understood.", cbuf);
2448}
2449
2450void
2451delete(name)
2452 char *name;
2453{
2454 struct stat st;
2455
2456 LOGCMD("delete", name);
2457 if (lstat(name, &st) < 0) {
2458 perror_reply(550, name);
2459 return;
2460 }
2461 if ((st.st_mode&S_IFMT) == S_IFDIR) {
2462 if (rmdir(name) < 0) {
2463 perror_reply(550, name);
2464 return;
2465 }
2466 goto done;
2467 }
2468 if (unlink(name) < 0) {
2469 perror_reply(550, name);
2470 return;
2471 }
2472done:
2473 ack("DELE");
2474}
2475
2476void
2477cwd(path)
2478 char *path;
2479{
2480
2481 if (chdir(path) < 0)
2482 perror_reply(550, path);
2483 else
2484 ack("CWD");
2485}
2486
2487void
2488makedir(name)
2489 char *name;
2490{
2491 char *s;
2492
2493 LOGCMD("mkdir", name);
2494 if (guest && noguestmkd)
2495 reply(550, "%s: permission denied", name);
2496 else if (mkdir(name, 0777) < 0)
2497 perror_reply(550, name);
2498 else {
2499 if ((s = doublequote(name)) == NULL)
2500 fatalerror("Ran out of memory.");
2501 reply(257, "\"%s\" directory created.", s);
2502 free(s);
2503 }
2504}
2505
2506void
2507removedir(name)
2508 char *name;
2509{
2510
2511 LOGCMD("rmdir", name);
2512 if (rmdir(name) < 0)
2513 perror_reply(550, name);
2514 else
2515 ack("RMD");
2516}
2517
2518void
2519pwd()
2520{
2521 char *s, path[MAXPATHLEN + 1];
2522
2523 if (getwd(path) == (char *)NULL)
2524 reply(550, "%s.", path);
2525 else {
2526 if ((s = doublequote(path)) == NULL)
2527 fatalerror("Ran out of memory.");
2528 reply(257, "\"%s\" is current directory.", s);
2529 free(s);
2530 }
2531}
2532
2533char *
2534renamefrom(name)
2535 char *name;
2536{
2537 struct stat st;
2538
2539 if (lstat(name, &st) < 0) {
2540 perror_reply(550, name);
2541 return ((char *)0);
2542 }
2543 reply(350, "File exists, ready for destination name");
2544 return (name);
2545}
2546
2547void
2548renamecmd(from, to)
2549 char *from, *to;
2550{
2551 struct stat st;
2552
2553 LOGCMD2("rename", from, to);
2554
2555 if (guest && (stat(to, &st) == 0)) {
2556 reply(550, "%s: permission denied", to);
2557 return;
2558 }
2559
2560 if (rename(from, to) < 0)
2561 perror_reply(550, "rename");
2562 else
2563 ack("RNTO");
2564}
2565
2566static void
2567dolog(who)
2568 struct sockaddr *who;
2569{
2570 int error;
2571
2572 realhostname_sa(remotehost, sizeof(remotehost) - 1, who, who->sa_len);
2573
2574#ifdef SETPROCTITLE
2575#ifdef VIRTUAL_HOSTING
2576 if (thishost != firsthost)
2577 snprintf(proctitle, sizeof(proctitle), "%s: connected (to %s)",
2578 remotehost, hostname);
2579 else
2580#endif
2581 snprintf(proctitle, sizeof(proctitle), "%s: connected",
2582 remotehost);
2583 setproctitle("%s", proctitle);
2584#endif /* SETPROCTITLE */
2585
2586 if (logging) {
2587#ifdef VIRTUAL_HOSTING
2588 if (thishost != firsthost)
2589 syslog(LOG_INFO, "connection from %s (to %s)",
2590 remotehost, hostname);
2591 else
2592#endif
2593 {
2594 char who_name[MAXHOSTNAMELEN];
2595
2596 error = getnameinfo(who, who->sa_len,
2597 who_name, sizeof(who_name) - 1,
2598 NULL, 0, NI_NUMERICHOST);
2599 syslog(LOG_INFO, "connection from %s (%s)", remotehost,
2600 error == 0 ? who_name : "");
2601 }
2602 }
2603}
2604
2605/*
2606 * Record logout in wtmp file
2607 * and exit with supplied status.
2608 */
2609void
2610dologout(status)
2611 int status;
2612{
2613 /*
2614 * Prevent reception of SIGURG from resulting in a resumption
2615 * back to the main program loop.
2616 */
2617 transflag = 0;
2618
2619 if (logged_in && dowtmp) {
2620 (void) seteuid((uid_t)0);
2621 ftpd_logwtmp(ttyline, "", NULL);
2622 }
2623 /* beware of flushing buffers after a SIGPIPE */
2624 _exit(status);
2625}
2626
2627static void
2628sigurg(signo)
2629 int signo;
2630{
2631
2632 recvurg = 1;
2633}
2634
2635static void
2636myoob()
2637{
2638 char *cp;
2639
2640 /* only process if transfer occurring */
2641 if (!transflag)
2642 return;
2643 cp = tmpline;
2644 if (getline(cp, 7, stdin) == NULL) {
2645 reply(221, "You could at least say goodbye.");
2646 dologout(0);
2647 }
2648 upper(cp);
2649 if (strcmp(cp, "ABOR\r\n") == 0) {
2650 tmpline[0] = '\0';
2651 reply(426, "Transfer aborted. Data connection closed.");
2652 reply(226, "Abort successful");
2653 }
2654 if (strcmp(cp, "STAT\r\n") == 0) {
2655 tmpline[0] = '\0';
2656 if (file_size != (off_t) -1)
2657 reply(213, "Status: %qd of %qd bytes transferred",
2658 byte_count, file_size);
2659 else
2660 reply(213, "Status: %qd bytes transferred", byte_count);
2661 }
2662}
2663
2664/*
2665 * Note: a response of 425 is not mentioned as a possible response to
2666 * the PASV command in RFC959. However, it has been blessed as
2667 * a legitimate response by Jon Postel in a telephone conversation
2668 * with Rick Adams on 25 Jan 89.
2669 */
2670void
2671passive()
2672{
2673 int len, on;
2674 char *p, *a;
2675
2676 if (pdata >= 0) /* close old port if one set */
2677 close(pdata);
2678
2679 pdata = socket(ctrl_addr.su_family, SOCK_STREAM, 0);
2680 if (pdata < 0) {
2681 perror_reply(425, "Can't open passive connection");
2682 return;
2683 }
2684 on = 1;
2685 if (setsockopt(pdata, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
2686 syslog(LOG_WARNING, "pdata setsockopt (SO_REUSEADDR): %m");
2687
2688 (void) seteuid((uid_t)0);
2689
2690#ifdef IP_PORTRANGE
2691 if (ctrl_addr.su_family == AF_INET) {
2692 on = restricted_data_ports ? IP_PORTRANGE_HIGH
2693 : IP_PORTRANGE_DEFAULT;
2694
2695 if (setsockopt(pdata, IPPROTO_IP, IP_PORTRANGE,
2696 &on, sizeof(on)) < 0)
2697 goto pasv_error;
2698 }
2699#endif
2700#ifdef IPV6_PORTRANGE
2701 if (ctrl_addr.su_family == AF_INET6) {
2702 on = restricted_data_ports ? IPV6_PORTRANGE_HIGH
2703 : IPV6_PORTRANGE_DEFAULT;
2704
2705 if (setsockopt(pdata, IPPROTO_IPV6, IPV6_PORTRANGE,
2706 &on, sizeof(on)) < 0)
2707 goto pasv_error;
2708 }
2709#endif
2710
2711 pasv_addr = ctrl_addr;
2712 pasv_addr.su_port = 0;
2713 if (bind(pdata, (struct sockaddr *)&pasv_addr, pasv_addr.su_len) < 0)
2714 goto pasv_error;
2715
2716 (void) seteuid((uid_t)pw->pw_uid);
2717
2718 len = sizeof(pasv_addr);
2719 if (getsockname(pdata, (struct sockaddr *) &pasv_addr, &len) < 0)
2720 goto pasv_error;
2721 if (listen(pdata, 1) < 0)
2722 goto pasv_error;
2723 if (pasv_addr.su_family == AF_INET)
2724 a = (char *) &pasv_addr.su_sin.sin_addr;
2725 else if (pasv_addr.su_family == AF_INET6 &&
2726 IN6_IS_ADDR_V4MAPPED(&pasv_addr.su_sin6.sin6_addr))
2727 a = (char *) &pasv_addr.su_sin6.sin6_addr.s6_addr[12];
2728 else
2729 goto pasv_error;
2730
2731 p = (char *) &pasv_addr.su_port;
2732
2733#define UC(b) (((int) b) & 0xff)
2734
2735 reply(227, "Entering Passive Mode (%d,%d,%d,%d,%d,%d)", UC(a[0]),
2736 UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
2737 return;
2738
2739pasv_error:
2740 (void) seteuid((uid_t)pw->pw_uid);
2741 (void) close(pdata);
2742 pdata = -1;
2743 perror_reply(425, "Can't open passive connection");
2744 return;
2745}
2746
2747/*
2748 * Long Passive defined in RFC 1639.
2749 * 228 Entering Long Passive Mode
2750 * (af, hal, h1, h2, h3,..., pal, p1, p2...)
2751 */
2752
2753void
2754long_passive(cmd, pf)
2755 char *cmd;
2756 int pf;
2757{
2758 int len, on;
2759 char *p, *a;
2760
2761 if (pdata >= 0) /* close old port if one set */
2762 close(pdata);
2763
2764 if (pf != PF_UNSPEC) {
2765 if (ctrl_addr.su_family != pf) {
2766 switch (ctrl_addr.su_family) {
2767 case AF_INET:
2768 pf = 1;
2769 break;
2770 case AF_INET6:
2771 pf = 2;
2772 break;
2773 default:
2774 pf = 0;
2775 break;
2776 }
2777 /*
2778 * XXX
2779 * only EPRT/EPSV ready clients will understand this
2780 */
2781 if (strcmp(cmd, "EPSV") == 0 && pf) {
2782 reply(522, "Network protocol mismatch, "
2783 "use (%d)", pf);
2784 } else
2785 reply(501, "Network protocol mismatch"); /*XXX*/
2786
2787 return;
2788 }
2789 }
2790
2791 pdata = socket(ctrl_addr.su_family, SOCK_STREAM, 0);
2792 if (pdata < 0) {
2793 perror_reply(425, "Can't open passive connection");
2794 return;
2795 }
2796 on = 1;
2797 if (setsockopt(pdata, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
2798 syslog(LOG_WARNING, "pdata setsockopt (SO_REUSEADDR): %m");
2799
2800 (void) seteuid((uid_t)0);
2801
2802 pasv_addr = ctrl_addr;
2803 pasv_addr.su_port = 0;
2804 len = pasv_addr.su_len;
2805
2806#ifdef IP_PORTRANGE
2807 if (ctrl_addr.su_family == AF_INET) {
2808 on = restricted_data_ports ? IP_PORTRANGE_HIGH
2809 : IP_PORTRANGE_DEFAULT;
2810
2811 if (setsockopt(pdata, IPPROTO_IP, IP_PORTRANGE,
2812 &on, sizeof(on)) < 0)
2813 goto pasv_error;
2814 }
2815#endif
2816#ifdef IPV6_PORTRANGE
2817 if (ctrl_addr.su_family == AF_INET6) {
2818 on = restricted_data_ports ? IPV6_PORTRANGE_HIGH
2819 : IPV6_PORTRANGE_DEFAULT;
2820
2821 if (setsockopt(pdata, IPPROTO_IPV6, IPV6_PORTRANGE,
2822 &on, sizeof(on)) < 0)
2823 goto pasv_error;
2824 }
2825#endif
2826
2827 if (bind(pdata, (struct sockaddr *)&pasv_addr, len) < 0)
2828 goto pasv_error;
2829
2830 (void) seteuid((uid_t)pw->pw_uid);
2831
2832 if (getsockname(pdata, (struct sockaddr *) &pasv_addr, &len) < 0)
2833 goto pasv_error;
2834 if (listen(pdata, 1) < 0)
2835 goto pasv_error;
2836
2837#define UC(b) (((int) b) & 0xff)
2838
2839 if (strcmp(cmd, "LPSV") == 0) {
2840 p = (char *)&pasv_addr.su_port;
2841 switch (pasv_addr.su_family) {
2842 case AF_INET:
2843 a = (char *) &pasv_addr.su_sin.sin_addr;
2844 v4_reply:
2845 reply(228,
2846"Entering Long Passive Mode (%d,%d,%d,%d,%d,%d,%d,%d,%d)",
2847 4, 4, UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
2848 2, UC(p[0]), UC(p[1]));
2849 return;
2850 case AF_INET6:
2851 if (IN6_IS_ADDR_V4MAPPED(&pasv_addr.su_sin6.sin6_addr)) {
2852 a = (char *) &pasv_addr.su_sin6.sin6_addr.s6_addr[12];
2853 goto v4_reply;
2854 }
2855 a = (char *) &pasv_addr.su_sin6.sin6_addr;
2856 reply(228,
2857"Entering Long Passive Mode "
2858"(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
2859 6, 16, UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]),
2860 UC(a[4]), UC(a[5]), UC(a[6]), UC(a[7]),
2861 UC(a[8]), UC(a[9]), UC(a[10]), UC(a[11]),
2862 UC(a[12]), UC(a[13]), UC(a[14]), UC(a[15]),
2863 2, UC(p[0]), UC(p[1]));
2864 return;
2865 }
2866 } else if (strcmp(cmd, "EPSV") == 0) {
2867 switch (pasv_addr.su_family) {
2868 case AF_INET:
2869 case AF_INET6:
2870 reply(229, "Entering Extended Passive Mode (|||%d|)",
2871 ntohs(pasv_addr.su_port));
2872 return;
2873 }
2874 } else {
2875 /* more proper error code? */
2876 }
2877
2878pasv_error:
2879 (void) seteuid((uid_t)pw->pw_uid);
2880 (void) close(pdata);
2881 pdata = -1;
2882 perror_reply(425, "Can't open passive connection");
2883 return;
2884}
2885
2886/*
2887 * Generate unique name for file with basename "local"
2888 * and open the file in order to avoid possible races.
2889 * Try "local" first, then "local.1", "local.2" etc, up to "local.99".
2890 * Return descriptor to the file, set "name" to its name.
2891 *
2892 * Generates failure reply on error.
2893 */
2894static int
2895guniquefd(local, name)
2896 char *local;
2897 char **name;
2898{
2899 static char new[MAXPATHLEN];
2900 struct stat st;
2901 char *cp;
2902 int count;
2903 int fd;
2904
2905 cp = strrchr(local, '/');
2906 if (cp)
2907 *cp = '\0';
2908 if (stat(cp ? local : ".", &st) < 0) {
2909 perror_reply(553, cp ? local : ".");
2910 return (-1);
2911 }
2912 if (cp) {
2913 /*
2914 * Let not overwrite dirname with counter suffix.
2915 * -4 is for /nn\0
2916 * In this extreme case dot won't be put in front of suffix.
2917 */
2918 if (strlen(local) > sizeof(new) - 4) {
2919 reply(553, "Pathname too long");
2920 return (-1);
2921 }
2922 *cp = '/';
2923 }
2924 /* -4 is for the .nn<null> we put on the end below */
2925 (void) snprintf(new, sizeof(new) - 4, "%s", local);
2926 cp = new + strlen(new);
2927 /*
2928 * Don't generate dotfile unless requested explicitly.
2929 * This covers the case when basename gets truncated off
2930 * by buffer size.
2931 */
2932 if (cp > new && cp[-1] != '/')
2933 *cp++ = '.';
2934 for (count = 0; count < 100; count++) {
2935 /* At count 0 try unmodified name */
2936 if (count)
2937 (void)sprintf(cp, "%d", count);
2938 if ((fd = open(count ? new : local,
2939 O_RDWR | O_CREAT | O_EXCL, 0666)) >= 0) {
2940 *name = count ? new : local;
2941 return (fd);
2942 }
2943 if (errno != EEXIST) {
2944 perror_reply(553, count ? new : local);
2945 return (-1);
2946 }
2947 }
2948 reply(452, "Unique file name cannot be created.");
2949 return (-1);
2950}
2951
2952/*
2953 * Format and send reply containing system error number.
2954 */
2955void
2956perror_reply(code, string)
2957 int code;
2958 char *string;
2959{
2960
2961 reply(code, "%s: %s.", string, strerror(errno));
2962}
2963
2964static char *onefile[] = {
2965 "",
2966 0
2967};
2968
2969void
2970send_file_list(whichf)
2971 char *whichf;
2972{
2973 struct stat st;
2974 DIR *dirp = NULL;
2975 struct dirent *dir;
2976 FILE *dout = NULL;
2977 char **dirlist, *dirname;
2978 int simple = 0;
2979 int freeglob = 0;
2980 glob_t gl;
2981
2982 if (strpbrk(whichf, "~{[*?") != NULL) {
2983 int flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_QUOTE|GLOB_TILDE;
2984
2985 memset(&gl, 0, sizeof(gl));
2986 gl.gl_matchc = MAXGLOBARGS;
2987 flags |= GLOB_LIMIT;
2988 freeglob = 1;
2989 if (glob(whichf, flags, 0, &gl)) {
2990 reply(550, "not found");
2991 goto out;
2992 } else if (gl.gl_pathc == 0) {
2993 errno = ENOENT;
2994 perror_reply(550, whichf);
2995 goto out;
2996 }
2997 dirlist = gl.gl_pathv;
2998 } else {
2999 onefile[0] = whichf;
3000 dirlist = onefile;
3001 simple = 1;
3002 }
3003
3004 while ((dirname = *dirlist++)) {
3005 if (stat(dirname, &st) < 0) {
3006 /*
3007 * If user typed "ls -l", etc, and the client
3008 * used NLST, do what the user meant.
3009 */
3010 if (dirname[0] == '-' && *dirlist == NULL &&
3011 transflag == 0) {
3012 retrieve(_PATH_LS " %s", dirname);
3013 goto out;
3014 }
3015 perror_reply(550, whichf);
3016 if (dout != NULL) {
3017 (void) fclose(dout);
3018 transflag = 0;
3019 data = -1;
3020 pdata = -1;
3021 }
3022 goto out;
3023 }
3024
3025 if (S_ISREG(st.st_mode)) {
3026 if (dout == NULL) {
3027 dout = dataconn("file list", (off_t)-1, "w");
3028 if (dout == NULL)
3029 goto out;
3030 transflag++;
3031 }
3032 fprintf(dout, "%s%s\n", dirname,
3033 type == TYPE_A ? "\r" : "");
3034 byte_count += strlen(dirname) + 1;
3035 continue;
3036 } else if (!S_ISDIR(st.st_mode))
3037 continue;
3038
3039 if ((dirp = opendir(dirname)) == NULL)
3040 continue;
3041
3042 while ((dir = readdir(dirp)) != NULL) {
3043 char nbuf[MAXPATHLEN];
3044
3045 if (recvurg) {
3046 myoob();
3047 recvurg = 0;
3048 transflag = 0;
3049 goto out;
3050 }
3051
3052 if (dir->d_name[0] == '.' && dir->d_namlen == 1)
3053 continue;
3054 if (dir->d_name[0] == '.' && dir->d_name[1] == '.' &&
3055 dir->d_namlen == 2)
3056 continue;
3057
3058 snprintf(nbuf, sizeof(nbuf),
3059 "%s/%s", dirname, dir->d_name);
3060
3061 /*
3062 * We have to do a stat to insure it's
3063 * not a directory or special file.
3064 */
3065 if (simple || (stat(nbuf, &st) == 0 &&
3066 S_ISREG(st.st_mode))) {
3067 if (dout == NULL) {
3068 dout = dataconn("file list", (off_t)-1,
3069 "w");
3070 if (dout == NULL)
3071 goto out;
3072 transflag++;
3073 }
3074 if (nbuf[0] == '.' && nbuf[1] == '/')
3075 fprintf(dout, "%s%s\n", &nbuf[2],
3076 type == TYPE_A ? "\r" : "");
3077 else
3078 fprintf(dout, "%s%s\n", nbuf,
3079 type == TYPE_A ? "\r" : "");
3080 byte_count += strlen(nbuf) + 1;
3081 }
3082 }
3083 (void) closedir(dirp);
3084 }
3085
3086 if (dout == NULL)
3087 reply(550, "No files found.");
3088 else if (ferror(dout) != 0)
3089 perror_reply(550, "Data connection");
3090 else
3091 reply(226, "Transfer complete.");
3092
3093 transflag = 0;
3094 if (dout != NULL)
3095 (void) fclose(dout);
3096 data = -1;
3097 pdata = -1;
3098out:
3099 if (freeglob) {
3100 freeglob = 0;
3101 globfree(&gl);
3102 }
3103}
3104
3105void
3106reapchild(signo)
3107 int signo;
3108{
3109 while (wait3(NULL, WNOHANG, NULL) > 0);
3110}
3111
3112#ifdef OLD_SETPROCTITLE
3113/*
3114 * Clobber argv so ps will show what we're doing. (Stolen from sendmail.)
3115 * Warning, since this is usually started from inetd.conf, it often doesn't
3116 * have much of an environment or arglist to overwrite.
3117 */
3118void
3119#if __STDC__
3120setproctitle(const char *fmt, ...)
3121#else
3122setproctitle(fmt, va_alist)
3123 char *fmt;
3124 va_dcl
3125#endif
3126{
3127 int i;
3128 va_list ap;
3129 char *p, *bp, ch;
3130 char buf[LINE_MAX];
3131
3132#if __STDC__
3133 va_start(ap, fmt);
3134#else
3135 va_start(ap);
3136#endif
3137 (void)vsnprintf(buf, sizeof(buf), fmt, ap);
3138
3139 /* make ps print our process name */
3140 p = Argv[0];
3141 *p++ = '-';
3142
3143 i = strlen(buf);
3144 if (i > LastArgv - p - 2) {
3145 i = LastArgv - p - 2;
3146 buf[i] = '\0';
3147 }
3148 bp = buf;
3149 while (ch = *bp++)
3150 if (ch != '\n' && ch != '\r')
3151 *p++ = ch;
3152 while (p < LastArgv)
3153 *p++ = ' ';
3154}
3155#endif /* OLD_SETPROCTITLE */
3156
3157static void
3158logxfer(name, size, start)
3159 char *name;
3160 off_t size;
3161 time_t start;
3162{
3163 char buf[1024];
3164 char path[MAXPATHLEN + 1];
3165 time_t now;
3166
3167 if (statfd >= 0 && getwd(path) != NULL) {
3168 time(&now);
3169 snprintf(buf, sizeof(buf), "%.20s!%s!%s!%s/%s!%qd!%ld\n",
3170 ctime(&now)+4, ident, remotehost,
3171 path, name, (long long)size,
3172 (long)(now - start + (now == start)));
3173 write(statfd, buf, strlen(buf));
3174 }
3175}
3176
3177static char *
3178doublequote(s)
3179 char *s;
3180{
3181 int n;
3182 char *p, *s2;
3183
3184 for (p = s, n = 0; *p; p++)
3185 if (*p == '"')
3186 n++;
3187
3188 if ((s2 = malloc(p - s + n + 1)) == NULL)
3189 return (NULL);
3190
3191 for (p = s2; *s; s++, p++) {
3192 if ((*p = *s) == '"')
3193 *(++p) = '"';
3194 }
3195 *p = '\0';
3196
3197 return (s2);
3198}