home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / inetutils-1.2-src.tgz / tar.out / fsf / inetutils / ftpd / ftpd.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  38KB  |  1,747 lines
  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. #ifndef lint
  35. static char copyright[] =
  36. "@(#) Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994\n\
  37.     The Regents of the University of California.  All rights reserved.\n";
  38. #endif /* not lint */
  39.  
  40. #ifndef lint
  41. static char sccsid[] = "@(#)ftpd.c    8.5 (Berkeley) 4/28/95";
  42. #endif /* not lint */
  43.  
  44. /*
  45.  * FTP server.
  46.  */
  47.  
  48. #ifdef HAVE_CONFIG_H
  49. #include <config.h>
  50. #endif
  51.  
  52. #include <sys/param.h>
  53. #include <sys/stat.h>
  54. #include <sys/ioctl.h>
  55. #include <sys/socket.h>
  56. #include <sys/wait.h>
  57.  
  58. #include <netinet/in.h>
  59. #ifdef HAVE_NETINET_IN_SYSTM_H
  60. #include <netinet/in_systm.h>
  61. #endif
  62. #ifdef HAVE_NETINET_IP_H
  63. #include <netinet/ip.h>
  64. #endif
  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 <errno.h>
  74. #include <fcntl.h>
  75. #include <glob.h>
  76. #include <limits.h>
  77. #include <netdb.h>
  78. #include <pwd.h>
  79. #include <setjmp.h>
  80. #include <signal.h>
  81. #include <stdio.h>
  82. #include <stdlib.h>
  83. #include <string.h>
  84. #include <syslog.h>
  85. #include <time.h>
  86. #include <unistd.h>
  87. #include <crypt.h>
  88.  
  89. #include "extern.h"
  90.  
  91. #if __STDC__
  92. #include <stdarg.h>
  93. #else
  94. #include <varargs.h>
  95. #endif
  96.  
  97. #ifndef LOG_FTP
  98. #define LOG_FTP LOG_DAEMON    /* Use generic facility.  */
  99. #endif
  100.  
  101. extern char *inetutils_version;
  102.  
  103. extern    off_t restart_point;
  104. extern    char cbuf[];
  105.  
  106. struct    sockaddr_in ctrl_addr;
  107. struct    sockaddr_in data_source;
  108. struct    sockaddr_in data_dest;
  109. struct    sockaddr_in his_addr;
  110. struct    sockaddr_in pasv_addr;
  111.  
  112. int    data;
  113. jmp_buf    errcatch, urgcatch;
  114. int    logged_in;
  115. struct    passwd *pw;
  116. int    debug;
  117. int    timeout = 900;    /* timeout after 15 minutes of inactivity */
  118. int    maxtimeout = 7200;/* don't allow idle time to be set beyond 2 hours */
  119. int    logging;
  120. int    guest;
  121. int    type;
  122. int    form;
  123. int    stru;            /* avoid C keyword */
  124. int    mode;
  125. int    usedefault = 1;        /* for data transfers */
  126. int    pdata = -1;        /* for passive mode */
  127. sig_atomic_t transflag;
  128. off_t    file_size;
  129. off_t    byte_count;
  130. #if !defined(CMASK) || CMASK == 0
  131. #undef CMASK
  132. #define CMASK 027
  133. #endif
  134. int    defumask = CMASK;        /* default umask value */
  135. char    tmpline[7];
  136. char    *hostname = 0;
  137. char    *remotehost = 0;
  138.  
  139. #define NUM_SIMUL_OFF_TO_STRS 4
  140.  
  141. /* Returns a string with the decimal representation of the off_t OFF, taking
  142.    into account that off_t might be longer than a long.  The return value is
  143.    a pointer to a static buffer, but a return value will only be reused every
  144.    NUM_SIMUL_OFF_TO_STRS calls, to allow multiple off_t's to be conveniently
  145.    printed with a single printf statement.  */
  146. static char *
  147. off_to_str (off)
  148.      off_t off;
  149. {
  150.   static char bufs[NUM_SIMUL_OFF_TO_STRS][80];
  151.   static char (*next_buf)[80] = bufs;
  152.  
  153.   if (next_buf > &bufs[NUM_SIMUL_OFF_TO_STRS])
  154.     next_buf = bufs;
  155.  
  156.   if (sizeof (off) > sizeof (long))
  157.     sprintf (*next_buf, "%qd", off);
  158.   else if (sizeof (off) == sizeof (long))
  159.     sprintf (*next_buf, "%ld", off);
  160.   else
  161.     sprintf (*next_buf, "%d", off);
  162.  
  163.   return *next_buf++;
  164. }
  165.  
  166. /*
  167.  * Timeout intervals for retrying connections
  168.  * to hosts that don't accept PORT cmds.  This
  169.  * is a kludge, but given the problems with TCP...
  170.  */
  171. #define    SWAITMAX    90    /* wait at most 90 seconds */
  172. #define    SWAITINT    5    /* interval between retries */
  173.  
  174. int    swaitmax = SWAITMAX;
  175. int    swaitint = SWAITINT;
  176.  
  177. #ifdef SETPROCTITLE
  178. char    **Argv = NULL;        /* pointer to argument vector */
  179. char    *LastArgv = NULL;    /* end of argv */
  180. char    proctitle[LINE_MAX];    /* initial part of title */
  181. #endif /* SETPROCTITLE */
  182.  
  183. #define LOGCMD(cmd, file) \
  184.     if (logging > 1) \
  185.         syslog(LOG_INFO,"%s %s%s", cmd, \
  186.         *(file) == '/' ? "" : curdir(), file);
  187. #define LOGCMD2(cmd, file1, file2) \
  188.      if (logging > 1) \
  189.         syslog(LOG_INFO,"%s %s%s %s%s", cmd, \
  190.         *(file1) == '/' ? "" : curdir(), file1, \
  191.         *(file2) == '/' ? "" : curdir(), file2);
  192. #define LOGBYTES(cmd, file, cnt) \
  193.     if (logging > 1) { \
  194.         if (cnt == (off_t)-1) \
  195.             syslog(LOG_INFO,"%s %s%s", cmd, \
  196.             *(file) == '/' ? "" : curdir(), file); \
  197.         else \
  198.             syslog(LOG_INFO, "%s %s%s = %s bytes", \
  199.             cmd, (*(file) == '/') ? "" : curdir(), file, \
  200.                off_to_str (cnt)); \
  201.     }
  202.  
  203. static void     ack __P((char *));
  204. static void     myoob __P((int));
  205. static int     checkuser __P((char *));
  206. static FILE    *dataconn __P((char *, off_t, char *));
  207. static void     dolog __P((struct sockaddr_in *));
  208. static char    *curdir __P((void));
  209. static void     end_login __P((void));
  210. static FILE    *getdatasock __P((char *));
  211. static char    *gunique __P((char *));
  212. static void     lostconn __P((int));
  213. static int     receive_data __P((FILE *, FILE *));
  214. static void     send_data __P((FILE *, FILE *, off_t));
  215. static struct passwd *
  216.          sgetpwnam __P((char *));
  217. static char    *sgetsave __P((char *));
  218.  
  219. static char *
  220. curdir()
  221. {
  222.         static char *path = 0;
  223.     if (path)
  224.             free (path);
  225.     path = getcwd (0, 0);
  226.     if (! path)
  227.         return ("");
  228.     if (path[1] != '\0') {    /* special case for root dir. */
  229.             char *new = realloc (path, strlen (path) + 2); /* '/' + '\0' */
  230.         if (! new)
  231.                 return "";
  232.         strcat(new, "/");
  233.         path = new;
  234.     }
  235.     /* For guest account, skip / since it's chrooted */
  236.     return (guest ? path+1 : path);
  237. }
  238.  
  239. int
  240. main(argc, argv, envp)
  241.     int argc;
  242.     char *argv[];
  243.     char **envp;
  244. {
  245.         extern char *localhost ();
  246.     int addrlen, ch, on = 1, tos;
  247.     char *cp, line[LINE_MAX];
  248.     FILE *fd;
  249.  
  250.     /*
  251.      * LOG_NDELAY sets up the logging connection immediately,
  252.      * necessary for anonymous ftp's that chroot and can't do it later.
  253.      */
  254.     openlog("ftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
  255.     addrlen = sizeof(his_addr);
  256.     if (getpeername(0, (struct sockaddr *)&his_addr, &addrlen) < 0) {
  257.         syslog(LOG_ERR, "getpeername (%s): %m",argv[0]);
  258.         exit(1);
  259.     }
  260.     addrlen = sizeof(ctrl_addr);
  261.     if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) {
  262.         syslog(LOG_ERR, "getsockname (%s): %m",argv[0]);
  263.         exit(1);
  264.     }
  265. #if defined (IP_TOS) && defined (IPTOS_LOWDELAY) && defined (IPPROTO_IP)
  266.     tos = IPTOS_LOWDELAY;
  267.     if (setsockopt(0, IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(int)) < 0)
  268.         syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
  269. #endif
  270.     data_source.sin_port = htons(ntohs(ctrl_addr.sin_port) - 1);
  271.     debug = 0;
  272. #ifdef SETPROCTITLE
  273.     /*
  274.      *  Save start and extent of argv for setproctitle.
  275.      */
  276.     Argv = argv;
  277.     while (*envp)
  278.         envp++;
  279.     LastArgv = envp[-1] + strlen(envp[-1]);
  280. #endif /* SETPROCTITLE */
  281.  
  282.     while ((ch = getopt(argc, argv, "dlt:T:u:v")) != EOF) {
  283.         switch (ch) {
  284.         case 'd':
  285.             debug = 1;
  286.             break;
  287.  
  288.         case 'l':
  289.             logging++;    /* > 1 == extra logging */
  290.             break;
  291.  
  292.         case 't':
  293.             timeout = atoi(optarg);
  294.             if (maxtimeout < timeout)
  295.                 maxtimeout = timeout;
  296.             break;
  297.  
  298.         case 'T':
  299.             maxtimeout = atoi(optarg);
  300.             if (timeout > maxtimeout)
  301.                 timeout = maxtimeout;
  302.             break;
  303.  
  304.         case 'u':
  305.             {
  306.             long val = 0;
  307.  
  308.             val = strtol(optarg, &optarg, 8);
  309.             if (*optarg != '\0' || val < 0)
  310.                 fprintf (stderr,
  311.                      "%s: bad value for -u", argv[0]);
  312.             else
  313.                 defumask = val;
  314.             break;
  315.             }
  316.  
  317.         case 'v':
  318.             debug = 1;
  319.             break;
  320.  
  321.         default:
  322.             fprintf (stderr,
  323.                  "%s: unknown flag -%c ignored", argv[0]);
  324.             break;
  325.         }
  326.     }
  327.     (void) freopen(PATH_DEVNULL, "w", stderr);
  328.     (void) signal(SIGPIPE, lostconn);
  329.     (void) signal(SIGCHLD, SIG_IGN);
  330.     if ((int)signal(SIGURG, myoob) < 0)
  331.         syslog(LOG_ERR, "signal: %m");
  332.  
  333.     /* Try to handle urgent data inline */
  334. #ifdef SO_OOBINLINE
  335.     if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof(on)) < 0)
  336.         syslog(LOG_ERR, "setsockopt: %m");
  337. #endif
  338.  
  339. #ifdef    F_SETOWN
  340.     if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1)
  341.         syslog(LOG_ERR, "fcntl F_SETOWN: %m");
  342. #endif
  343.     dolog(&his_addr);
  344.     /*
  345.      * Set up default state
  346.      */
  347.     data = -1;
  348.     type = TYPE_A;
  349.     form = FORM_N;
  350.     stru = STRU_F;
  351.     mode = MODE_S;
  352.     tmpline[0] = '\0';
  353.  
  354.     /* If logins are disabled, print out the message. */
  355.     if ((fd = fopen(PATH_NOLOGIN,"r")) != NULL) {
  356.         while (fgets(line, sizeof(line), fd) != NULL) {
  357.             if ((cp = strchr(line, '\n')) != NULL)
  358.                 *cp = '\0';
  359.             lreply(530, "%s", line);
  360.         }
  361.         (void) fflush(stdout);
  362.         (void) fclose(fd);
  363.         reply(530, "System not available.");
  364.         exit(0);
  365.     }
  366.     if ((fd = fopen(PATH_FTPWELCOME, "r")) != NULL) {
  367.         while (fgets(line, sizeof(line), fd) != NULL) {
  368.             if ((cp = strchr(line, '\n')) != NULL)
  369.                 *cp = '\0';
  370.             lreply(220, "%s", line);
  371.         }
  372.         (void) fflush(stdout);
  373.         (void) fclose(fd);
  374.         /* reply(220,) must follow */
  375.     }
  376.             
  377.     hostname = localhost ();
  378.     if (! hostname)
  379.         perror_reply (550, "Local resource failure: malloc");
  380.  
  381.     reply(220, "%s FTP server (%s) ready.", hostname, inetutils_version);
  382.     (void) setjmp(errcatch);
  383.     for (;;)
  384.         (void) yyparse();
  385.     /* NOTREACHED */
  386. }
  387.  
  388. static void
  389. lostconn(signo)
  390.     int signo;
  391. {
  392.  
  393.     if (debug)
  394.         syslog(LOG_DEBUG, "lost connection");
  395.     dologout(-1);
  396. }
  397.  
  398. static char ttyline[20];
  399.  
  400. /*
  401.  * Helper function for sgetpwnam().
  402.  */
  403. static char *
  404. sgetsave(s)
  405.     char *s;
  406. {
  407.     char *new = malloc((unsigned) strlen(s) + 1);
  408.  
  409.     if (new == NULL) {
  410.         perror_reply(421, "Local resource failure: malloc");
  411.         dologout(1);
  412.         /* NOTREACHED */
  413.     }
  414.     (void) strcpy(new, s);
  415.     return (new);
  416. }
  417.  
  418. /*
  419.  * Save the result of a getpwnam.  Used for USER command, since
  420.  * the data returned must not be clobbered by any other command
  421.  * (e.g., globbing).
  422.  */
  423. static struct passwd *
  424. sgetpwnam(name)
  425.     char *name;
  426. {
  427.     static struct passwd save;
  428.     struct passwd *p;
  429.  
  430.     if ((p = getpwnam(name)) == NULL)
  431.         return (p);
  432.     if (save.pw_name) {
  433.         free(save.pw_name);
  434.         free(save.pw_passwd);
  435.         free(save.pw_gecos);
  436.         free(save.pw_dir);
  437.         free(save.pw_shell);
  438.     }
  439.     save = *p;
  440.     save.pw_name = sgetsave(p->pw_name);
  441.     save.pw_passwd = sgetsave(p->pw_passwd);
  442.     save.pw_gecos = sgetsave(p->pw_gecos);
  443.     save.pw_dir = sgetsave(p->pw_dir);
  444.     save.pw_shell = sgetsave(p->pw_shell);
  445.     return (&save);
  446. }
  447.  
  448. static int login_attempts;    /* number of failed login attempts */
  449. static int askpasswd;        /* had user command, ask for passwd */
  450. static char curname[10];    /* current USER name */
  451.  
  452. static void
  453. complete_login (passwd)
  454.      char *passwd;
  455. {
  456.     char *salt, *xpasswd;
  457.     FILE *fd;
  458.  
  459.     if (!guest && (!pw || *pw->pw_passwd)) {
  460.         salt = pw ? pw->pw_passwd : "xx";
  461.         xpasswd = CRYPT (passwd, salt);
  462.         if (!pw || strcmp(xpasswd, pw->pw_passwd)) {
  463.             reply(530, "Login incorrect.");
  464.             if (logging)
  465.                 syslog(LOG_NOTICE,
  466.                     "FTP LOGIN FAILED FROM %s, %s",
  467.                     remotehost, curname);
  468.             pw = NULL;
  469.             if (login_attempts++ >= 5) {
  470.                 syslog(LOG_NOTICE,
  471.                     "repeated login failures from %s",
  472.                     remotehost);
  473.                 exit(0);
  474.             }
  475.             return;
  476.         }
  477.     }
  478.     login_attempts = 0;        /* this time successful */
  479.     if (setegid((gid_t)pw->pw_gid) < 0) {
  480.         reply(550, "Can't set gid.");
  481.         return;
  482.     }
  483.     (void) initgroups(pw->pw_name, pw->pw_gid);
  484.  
  485.     /* open wtmp before chroot */
  486.     (void)sprintf(ttyline, "ftp%d", getpid());
  487.     logwtmp_keep_open (ttyline, pw->pw_name, remotehost);
  488.     logged_in = 1;
  489.  
  490.     if (guest) {
  491.         /*
  492.          * We MUST do a chdir() after the chroot. Otherwise
  493.          * the old current directory will be accessible as "."
  494.          * outside the new root!
  495.          */
  496.         if (chroot(pw->pw_dir) < 0 || chdir("/") < 0) {
  497.             reply(550, "Can't set guest privileges.");
  498.             goto bad;
  499.         }
  500.     } else if (chdir(pw->pw_dir) < 0) {
  501.         if (chdir("/") < 0) {
  502.             reply(530, "User %s: can't change directory to %s.",
  503.                 pw->pw_name, pw->pw_dir);
  504.             goto bad;
  505.         } else
  506.             lreply(230, "No directory! Logging in with home=/");
  507.     }
  508.     if (seteuid((uid_t)pw->pw_uid) < 0) {
  509.         reply(550, "Can't set uid.");
  510.         goto bad;
  511.     }
  512.     /*
  513.      * Display a login message, if it exists.
  514.      * N.B. reply(230,) must follow the message.
  515.      */
  516.     if ((fd = fopen(PATH_FTPLOGINMESG, "r")) != NULL) {
  517.         char *cp, line[LINE_MAX];
  518.  
  519.         while (fgets(line, sizeof(line), fd) != NULL) {
  520.             if ((cp = strchr(line, '\n')) != NULL)
  521.                 *cp = '\0';
  522.             lreply(230, "%s", line);
  523.         }
  524.         (void) fflush(stdout);
  525.         (void) fclose(fd);
  526.     }
  527.     if (guest) {
  528.         reply(230, "Guest login ok, access restrictions apply.");
  529. #ifdef SETPROCTITLE
  530.         snprintf(proctitle, sizeof(proctitle),
  531.             "%s: anonymous/%.*s", remotehost,
  532.             sizeof(proctitle) - sizeof(remotehost) -
  533.             sizeof(": anonymous/"), passwd);
  534.         setproctitle(proctitle);
  535. #endif /* SETPROCTITLE */
  536.         if (logging)
  537.             syslog(LOG_INFO, "ANONYMOUS FTP LOGIN FROM %s, %s",
  538.                 remotehost, passwd);
  539.     } else {
  540.         reply(230, "User %s logged in.", pw->pw_name);
  541. #ifdef SETPROCTITLE
  542.         snprintf(proctitle, sizeof(proctitle),
  543.             "%s: %s", remotehost, pw->pw_name);
  544.         setproctitle(proctitle);
  545. #endif /* SETPROCTITLE */
  546.         if (logging)
  547.             syslog(LOG_INFO, "FTP LOGIN FROM %s as %s",
  548.                 remotehost, pw->pw_name);
  549.     }
  550.     (void) umask(defumask);
  551.     return;
  552. bad:
  553.     /* Forget all about it... */
  554.     end_login();
  555. }
  556.  
  557. /*
  558.  * USER command.
  559.  * Sets global passwd pointer pw if named account exists and is acceptable;
  560.  * sets askpasswd if a PASS command is expected.  If logged in previously,
  561.  * need to reset state.  If name is "ftp" or "anonymous", the name is not in
  562.  * PATH_FTPUSERS, and ftp account exists, set guest and pw, then just return.
  563.  * If account doesn't exist, ask for passwd anyway.  Otherwise, check user
  564.  * requesting login privileges.  Disallow anyone who does not have a standard
  565.  * shell as returned by getusershell().  Disallow anyone mentioned in the file
  566.  * PATH_FTPUSERS to allow people such as root and uucp to be avoided.
  567.  */
  568. void
  569. user(name)
  570.     char *name;
  571. {
  572.     char *cp, *shell;
  573.  
  574.     if (logged_in) {
  575.         if (guest) {
  576.             reply(530, "Can't change user from guest login.");
  577.             return;
  578.         }
  579.         end_login();
  580.     }
  581.  
  582.     guest = 0;
  583.     if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) {
  584.         if (checkuser("ftp") || checkuser("anonymous"))
  585.             reply(530, "User %s access denied.", name);
  586.         else if ((pw = sgetpwnam("ftp")) != NULL) {
  587.             guest = 1;
  588.             askpasswd = 1;
  589.             reply(331,
  590.                 "Guest login ok, type your name as password.");
  591.         } else
  592.             reply(530, "User %s unknown.", name);
  593.         if (!askpasswd && logging)
  594.             syslog(LOG_NOTICE,
  595.                 "ANONYMOUS FTP LOGIN REFUSED FROM %s", remotehost);
  596.         return;
  597.     }
  598.     if (pw = sgetpwnam(name)) {
  599.         if ((shell = pw->pw_shell) == NULL || *shell == 0)
  600.             shell = PATH_BSHELL;
  601.         while ((cp = getusershell()) != NULL)
  602.             if (strcmp(cp, shell) == 0)
  603.                 break;
  604.         endusershell();
  605.  
  606.         if (cp == NULL || checkuser(name)) {
  607.             reply(530, "User %s access denied.", name);
  608.             if (logging)
  609.                 syslog(LOG_NOTICE,
  610.                     "FTP LOGIN REFUSED FROM %s, %s",
  611.                     remotehost, name);
  612.             pw = (struct passwd *) NULL;
  613.             return;
  614.         }
  615.     }
  616.     if (logging)
  617.         strncpy(curname, name, sizeof(curname)-1);
  618.  
  619.     if (!pw || *pw->pw_passwd) {
  620.         reply(331, "Password required for %s.", name);
  621.         askpasswd = 1;
  622.     } else
  623.             complete_login (0);
  624.  
  625.     /*
  626.      * Delay before reading passwd after first failed
  627.      * attempt to slow down passwd-guessing programs.
  628.      */
  629.     if (login_attempts)
  630.         sleep((unsigned) login_attempts);
  631. }
  632.  
  633. /*
  634.  * Check if a user is in the file PATH_FTPUSERS
  635.  */
  636. static int
  637. checkuser(name)
  638.     char *name;
  639. {
  640.     FILE *fd;
  641.     int found = 0;
  642.     char *p, line[BUFSIZ];
  643.  
  644.     if ((fd = fopen(PATH_FTPUSERS, "r")) != NULL) {
  645.         while (fgets(line, sizeof(line), fd) != NULL)
  646.             if ((p = strchr(line, '\n')) != NULL) {
  647.                 *p = '\0';
  648.                 if (line[0] == '#')
  649.                     continue;
  650.                 if (strcmp(line, name) == 0) {
  651.                     found = 1;
  652.                     break;
  653.                 }
  654.             }
  655.         (void) fclose(fd);
  656.     }
  657.     return (found);
  658. }
  659.  
  660. /*
  661.  * Terminate login as previous user, if any, resetting state;
  662.  * used when USER command is given or login fails.
  663.  */
  664. static void
  665. end_login()
  666. {
  667.  
  668.     (void) seteuid((uid_t)0);
  669.     if (logged_in)
  670.         logwtmp_keep_open (ttyline, "", "");
  671.     pw = NULL;
  672.     logged_in = 0;
  673.     guest = 0;
  674. }
  675.  
  676. void
  677. pass(passwd)
  678.     char *passwd;
  679. {
  680.     if (logged_in || askpasswd == 0) {
  681.         reply(503, "Login with USER first.");
  682.         return;
  683.     }
  684.     askpasswd = 0;
  685.  
  686.     complete_login (passwd);
  687. }
  688.  
  689. void
  690. retrieve(cmd, name)
  691.     char *cmd, *name;
  692. {
  693.     FILE *fin, *dout;
  694.     struct stat st;
  695.     int (*closefunc) __P((FILE *));
  696.  
  697.     if (cmd == 0) {
  698.         fin = fopen(name, "r"), closefunc = fclose;
  699.         st.st_size = 0;
  700.     } else {
  701.         char line[BUFSIZ];
  702.  
  703.         (void) sprintf(line, cmd, name), name = line;
  704.         fin = ftpd_popen(line, "r"), closefunc = ftpd_pclose;
  705.         st.st_size = -1;
  706.         st.st_blksize = BUFSIZ;
  707.     }
  708.     if (fin == NULL) {
  709.         if (errno != 0) {
  710.             perror_reply(550, name);
  711.             if (cmd == 0) {
  712.                 LOGCMD("get", name);
  713.             }
  714.         }
  715.         return;
  716.     }
  717.     byte_count = -1;
  718.     if (cmd == 0 && (fstat(fileno(fin), &st) < 0 || !S_ISREG(st.st_mode))) {
  719.         reply(550, "%s: not a plain file.", name);
  720.         goto done;
  721.     }
  722.     if (restart_point) {
  723.         if (type == TYPE_A) {
  724.             off_t i, n;
  725.             int c;
  726.  
  727.             n = restart_point;
  728.             i = 0;
  729.             while (i++ < n) {
  730.                 if ((c=getc(fin)) == EOF) {
  731.                     perror_reply(550, name);
  732.                     goto done;
  733.                 }
  734.                 if (c == '\n')
  735.                     i++;
  736.             }
  737.         } else if (lseek(fileno(fin), restart_point, SEEK_SET) < 0) {
  738.             perror_reply(550, name);
  739.             goto done;
  740.         }
  741.     }
  742.     dout = dataconn(name, st.st_size, "w");
  743.     if (dout == NULL)
  744.         goto done;
  745.     send_data(fin, dout, st.st_blksize);
  746.     (void) fclose(dout);
  747.     data = -1;
  748.     pdata = -1;
  749. done:
  750.     if (cmd == 0)
  751.         LOGBYTES("get", name, byte_count);
  752.     (*closefunc)(fin);
  753. }
  754.  
  755. void
  756. store(name, mode, unique)
  757.     char *name, *mode;
  758.     int unique;
  759. {
  760.     FILE *fout, *din;
  761.     struct stat st;
  762.     int (*closefunc) __P((FILE *));
  763.  
  764.     if (unique && stat(name, &st) == 0 &&
  765.         (name = gunique(name)) == NULL) {
  766.         LOGCMD(*mode == 'w' ? "put" : "append", name);
  767.         return;
  768.     }
  769.  
  770.     if (restart_point)
  771.         mode = "r+";
  772.     fout = fopen(name, mode);
  773.     closefunc = fclose;
  774.     if (fout == NULL) {
  775.         perror_reply(553, name);
  776.         LOGCMD(*mode == 'w' ? "put" : "append", name);
  777.         return;
  778.     }
  779.     byte_count = -1;
  780.     if (restart_point) {
  781.         if (type == TYPE_A) {
  782.             off_t i, n;
  783.             int c;
  784.  
  785.             n = restart_point;
  786.             i = 0;
  787.             while (i++ < n) {
  788.                 if ((c=getc(fout)) == EOF) {
  789.                     perror_reply(550, name);
  790.                     goto done;
  791.                 }
  792.                 if (c == '\n')
  793.                     i++;
  794.             }
  795.             /*
  796.              * We must do this seek to "current" position
  797.              * because we are changing from reading to
  798.              * writing.
  799.              */
  800.             if (fseek(fout, 0L, SEEK_CUR) < 0) {
  801.                 perror_reply(550, name);
  802.                 goto done;
  803.             }
  804.         } else if (lseek(fileno(fout), restart_point, SEEK_SET) < 0) {
  805.             perror_reply(550, name);
  806.             goto done;
  807.         }
  808.     }
  809.     din = dataconn(name, (off_t)-1, "r");
  810.     if (din == NULL)
  811.         goto done;
  812.     if (receive_data(din, fout) == 0) {
  813.         if (unique)
  814.             reply(226, "Transfer complete (unique file name:%s).",
  815.                 name);
  816.         else
  817.             reply(226, "Transfer complete.");
  818.     }
  819.     (void) fclose(din);
  820.     data = -1;
  821.     pdata = -1;
  822. done:
  823.     LOGBYTES(*mode == 'w' ? "put" : "append", name, byte_count);
  824.     (*closefunc)(fout);
  825. }
  826.  
  827. static FILE *
  828. getdatasock(mode)
  829.     char *mode;
  830. {
  831.     int on = 1, s, t, tries;
  832.  
  833.     if (data >= 0)
  834.         return (fdopen(data, mode));
  835.     (void) seteuid((uid_t)0);
  836.     s = socket(AF_INET, SOCK_STREAM, 0);
  837.     if (s < 0)
  838.         goto bad;
  839.     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  840.         (char *) &on, sizeof(on)) < 0)
  841.         goto bad;
  842.     /* anchor socket to avoid multi-homing problems */
  843.     data_source.sin_family = AF_INET;
  844.     data_source.sin_addr = ctrl_addr.sin_addr;
  845.     for (tries = 1; ; tries++) {
  846.         if (bind(s, (struct sockaddr *)&data_source,
  847.             sizeof(data_source)) >= 0)
  848.             break;
  849.         if (errno != EADDRINUSE || tries > 10)
  850.             goto bad;
  851.         sleep(tries);
  852.     }
  853.     (void) seteuid((uid_t)pw->pw_uid);
  854. #if defined (IP_TOS) && defined (IPTOS_THROUGHPUT) && defined (IPPROTO_IP)
  855.     on = IPTOS_THROUGHPUT;
  856.     if (setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&on, sizeof(int)) < 0)
  857.         syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
  858. #endif
  859.     return (fdopen(s, mode));
  860. bad:
  861.     /* Return the real value of errno (close may change it) */
  862.     t = errno;
  863.     (void) seteuid((uid_t)pw->pw_uid);
  864.     (void) close(s);
  865.     errno = t;
  866.     return (NULL);
  867. }
  868.  
  869. static FILE *
  870. dataconn(name, size, mode)
  871.     char *name;
  872.     off_t size;
  873.     char *mode;
  874. {
  875.     char sizebuf[32];
  876.     FILE *file;
  877.     int retry = 0, tos;
  878.  
  879.     file_size = size;
  880.     byte_count = 0;
  881.     if (size != (off_t) -1)
  882.         (void) sprintf(sizebuf, " (%s bytes)", off_to_str (size));
  883.     else
  884.         (void) strcpy(sizebuf, "");
  885.     if (pdata >= 0) {
  886.         struct sockaddr_in from;
  887.         int s, fromlen = sizeof(from);
  888.  
  889.         s = accept(pdata, (struct sockaddr *)&from, &fromlen);
  890.         if (s < 0) {
  891.             reply(425, "Can't open data connection.");
  892.             (void) close(pdata);
  893.             pdata = -1;
  894.             return (NULL);
  895.         }
  896.         (void) close(pdata);
  897.         pdata = s;
  898. #if defined (IP_TOS) && defined (IPTOS_LOWDELAY) && defined (IPPROTO_IP)
  899.         tos = IPTOS_LOWDELAY;
  900.         (void) setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&tos,
  901.             sizeof(int));
  902. #endif
  903.         reply(150, "Opening %s mode data connection for '%s'%s.",
  904.              type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
  905.         return (fdopen(pdata, mode));
  906.     }
  907.     if (data >= 0) {
  908.         reply(125, "Using existing data connection for '%s'%s.",
  909.             name, sizebuf);
  910.         usedefault = 1;
  911.         return (fdopen(data, mode));
  912.     }
  913.     if (usedefault)
  914.         data_dest = his_addr;
  915.     usedefault = 1;
  916.     file = getdatasock(mode);
  917.     if (file == NULL) {
  918.         reply(425, "Can't create data socket (%s,%d): %s.",
  919.             inet_ntoa(data_source.sin_addr),
  920.             ntohs(data_source.sin_port), strerror(errno));
  921.         return (NULL);
  922.     }
  923.     data = fileno(file);
  924.     while (connect(data, (struct sockaddr *)&data_dest,
  925.         sizeof(data_dest)) < 0) {
  926.         if (errno == EADDRINUSE && retry < swaitmax) {
  927.             sleep((unsigned) swaitint);
  928.             retry += swaitint;
  929.             continue;
  930.         }
  931.         perror_reply(425, "Can't build data connection");
  932.         (void) fclose(file);
  933.         data = -1;
  934.         return (NULL);
  935.     }
  936.     reply(150, "Opening %s mode data connection for '%s'%s.",
  937.          type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
  938.     return (file);
  939. }
  940.  
  941. /*
  942.  * Tranfer the contents of "instr" to "outstr" peer using the appropriate
  943.  * encapsulation of the data subject * to Mode, Structure, and Type.
  944.  *
  945.  * NB: Form isn't handled.
  946.  */
  947. static void
  948. send_data(instr, outstr, blksize)
  949.     FILE *instr, *outstr;
  950.     off_t blksize;
  951. {
  952.     int c, cnt, filefd, netfd;
  953.     char *buf;
  954.  
  955.     transflag++;
  956.     if (setjmp(urgcatch)) {
  957.         transflag = 0;
  958.         return;
  959.     }
  960.     switch (type) {
  961.  
  962.     case TYPE_A:
  963.         while ((c = getc(instr)) != EOF) {
  964.             byte_count++;
  965.             if (c == '\n') {
  966.                 if (ferror(outstr))
  967.                     goto data_err;
  968.                 (void) putc('\r', outstr);
  969.             }
  970.             (void) putc(c, outstr);
  971.         }
  972.         fflush(outstr);
  973.         transflag = 0;
  974.         if (ferror(instr))
  975.             goto file_err;
  976.         if (ferror(outstr))
  977.             goto data_err;
  978.         reply(226, "Transfer complete.");
  979.         return;
  980.  
  981.     case TYPE_I:
  982.     case TYPE_L:
  983.         if ((buf = malloc((u_int)blksize)) == NULL) {
  984.             transflag = 0;
  985.             perror_reply(451, "Local resource failure: malloc");
  986.             return;
  987.         }
  988.         netfd = fileno(outstr);
  989.         filefd = fileno(instr);
  990.         while ((cnt = read(filefd, buf, (u_int)blksize)) > 0 &&
  991.             write(netfd, buf, cnt) == cnt)
  992.             byte_count += cnt;
  993.         transflag = 0;
  994.         (void)free(buf);
  995.         if (cnt != 0) {
  996.             if (cnt < 0)
  997.                 goto file_err;
  998.             goto data_err;
  999.         }
  1000.         reply(226, "Transfer complete.");
  1001.         return;
  1002.     default:
  1003.         transflag = 0;
  1004.         reply(550, "Unimplemented TYPE %d in send_data", type);
  1005.         return;
  1006.     }
  1007.  
  1008. data_err:
  1009.     transflag = 0;
  1010.     perror_reply(426, "Data connection");
  1011.     return;
  1012.  
  1013. file_err:
  1014.     transflag = 0;
  1015.     perror_reply(551, "Error on input file");
  1016. }
  1017.  
  1018. /*
  1019.  * Transfer data from peer to "outstr" using the appropriate encapulation of
  1020.  * the data subject to Mode, Structure, and Type.
  1021.  *
  1022.  * N.B.: Form isn't handled.
  1023.  */
  1024. static int
  1025. receive_data(instr, outstr)
  1026.     FILE *instr, *outstr;
  1027. {
  1028.     int c;
  1029.     int cnt, bare_lfs = 0;
  1030.     char buf[BUFSIZ];
  1031.  
  1032.     transflag++;
  1033.     if (setjmp(urgcatch)) {
  1034.         transflag = 0;
  1035.         return (-1);
  1036.     }
  1037.     switch (type) {
  1038.  
  1039.     case TYPE_I:
  1040.     case TYPE_L:
  1041.         while ((cnt = read(fileno(instr), buf, sizeof(buf))) > 0) {
  1042.             if (write(fileno(outstr), buf, cnt) != cnt)
  1043.                 goto file_err;
  1044.             byte_count += cnt;
  1045.         }
  1046.         if (cnt < 0)
  1047.             goto data_err;
  1048.         transflag = 0;
  1049.         return (0);
  1050.  
  1051.     case TYPE_E:
  1052.         reply(553, "TYPE E not implemented.");
  1053.         transflag = 0;
  1054.         return (-1);
  1055.  
  1056.     case TYPE_A:
  1057.         while ((c = getc(instr)) != EOF) {
  1058.             byte_count++;
  1059.             if (c == '\n')
  1060.                 bare_lfs++;
  1061.             while (c == '\r') {
  1062.                 if (ferror(outstr))
  1063.                     goto data_err;
  1064.                 if ((c = getc(instr)) != '\n') {
  1065.                     (void) putc ('\r', outstr);
  1066.                     if (c == '\0' || c == EOF)
  1067.                         goto contin2;
  1068.                 }
  1069.             }
  1070.             (void) putc(c, outstr);
  1071.     contin2:    ;
  1072.         }
  1073.         fflush(outstr);
  1074.         if (ferror(instr))
  1075.             goto data_err;
  1076.         if (ferror(outstr))
  1077.             goto file_err;
  1078.         transflag = 0;
  1079.         if (bare_lfs) {
  1080.             lreply(226,
  1081.         "WARNING! %d bare linefeeds received in ASCII mode",
  1082.                 bare_lfs);
  1083.         (void)printf("   File may not have transferred correctly.\r\n");
  1084.         }
  1085.         return (0);
  1086.     default:
  1087.         reply(550, "Unimplemented TYPE %d in receive_data", type);
  1088.         transflag = 0;
  1089.         return (-1);
  1090.     }
  1091.  
  1092. data_err:
  1093.     transflag = 0;
  1094.     perror_reply(426, "Data Connection");
  1095.     return (-1);
  1096.  
  1097. file_err:
  1098.     transflag = 0;
  1099.     perror_reply(452, "Error writing file");
  1100.     return (-1);
  1101. }
  1102.  
  1103. void
  1104. statfilecmd(filename)
  1105.     char *filename;
  1106. {
  1107.     FILE *fin;
  1108.     int c;
  1109.     char line[LINE_MAX];
  1110.  
  1111.     (void)snprintf(line, sizeof(line), "/bin/ls -lgA %s", filename);
  1112.     fin = ftpd_popen(line, "r");
  1113.     lreply(211, "status of %s:", filename);
  1114.     while ((c = getc(fin)) != EOF) {
  1115.         if (c == '\n') {
  1116.             if (ferror(stdout)){
  1117.                 perror_reply(421, "control connection");
  1118.                 (void) ftpd_pclose(fin);
  1119.                 dologout(1);
  1120.                 /* NOTREACHED */
  1121.             }
  1122.             if (ferror(fin)) {
  1123.                 perror_reply(551, filename);
  1124.                 (void) ftpd_pclose(fin);
  1125.                 return;
  1126.             }
  1127.             (void) putc('\r', stdout);
  1128.         }
  1129.         (void) putc(c, stdout);
  1130.     }
  1131.     (void) ftpd_pclose(fin);
  1132.     reply(211, "End of Status");
  1133. }
  1134.  
  1135. void
  1136. statcmd()
  1137. {
  1138.     struct sockaddr_in *sin;
  1139.     u_char *a, *p;
  1140.  
  1141.     lreply(211, "%s FTP server status:", hostname);
  1142.     printf("     %s\r\n", inetutils_version);
  1143.     printf("     Connected to %s", remotehost);
  1144.     if (!isdigit(remotehost[0]))
  1145.         printf(" (%s)", inet_ntoa(his_addr.sin_addr));
  1146.     printf("\r\n");
  1147.     if (logged_in) {
  1148.         if (guest)
  1149.             printf("     Logged in anonymously\r\n");
  1150.         else
  1151.             printf("     Logged in as %s\r\n", pw->pw_name);
  1152.     } else if (askpasswd)
  1153.         printf("     Waiting for password\r\n");
  1154.     else
  1155.         printf("     Waiting for user name\r\n");
  1156.     printf("     TYPE: %s", typenames[type]);
  1157.     if (type == TYPE_A || type == TYPE_E)
  1158.         printf(", FORM: %s", formnames[form]);
  1159.     if (type == TYPE_L)
  1160. #ifdef CHAR_BIT
  1161.         printf(" %d", CHAR_BIT);
  1162. #else
  1163. #if NBBY == 8
  1164.         printf(" %d", NBBY);
  1165. #else
  1166.         printf(" %d", bytesize);    /* need definition! */
  1167. #endif
  1168. #endif
  1169.     printf("; STRUcture: %s; transfer MODE: %s\r\n",
  1170.         strunames[stru], modenames[mode]);
  1171.     if (data != -1)
  1172.         printf("     Data connection open\r\n");
  1173.     else if (pdata != -1) {
  1174.         printf("     in Passive mode");
  1175.         sin = &pasv_addr;
  1176.         goto printaddr;
  1177.     } else if (usedefault == 0) {
  1178.         printf("     PORT");
  1179.         sin = &data_dest;
  1180. printaddr:
  1181.         a = (u_char *) &sin->sin_addr;
  1182.         p = (u_char *) &sin->sin_port;
  1183. #define UC(b) (((int) b) & 0xff)
  1184.         printf(" (%d,%d,%d,%d,%d,%d)\r\n", UC(a[0]),
  1185.             UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
  1186. #undef UC
  1187.     } else
  1188.         printf("     No data connection\r\n");
  1189.     reply(211, "End of status");
  1190. }
  1191.  
  1192. void
  1193. fatal(s)
  1194.     char *s;
  1195. {
  1196.  
  1197.     reply(451, "Error in server: %s\n", s);
  1198.     reply(221, "Closing connection due to server error.");
  1199.     dologout(0);
  1200.     /* NOTREACHED */
  1201. }
  1202.  
  1203. void
  1204. #if __STDC__
  1205. reply(int n, const char *fmt, ...)
  1206. #else
  1207. reply(n, fmt, va_alist)
  1208.     int n;
  1209.     char *fmt;
  1210.         va_dcl
  1211. #endif
  1212. {
  1213.     va_list ap;
  1214. #if __STDC__
  1215.     va_start(ap, fmt);
  1216. #else
  1217.     va_start(ap);
  1218. #endif
  1219.     (void)printf("%d ", n);
  1220.     (void)vprintf(fmt, ap);
  1221.     (void)printf("\r\n");
  1222.     (void)fflush(stdout);
  1223.     if (debug) {
  1224.         syslog(LOG_DEBUG, "<--- %d ", n);
  1225.         vsyslog(LOG_DEBUG, fmt, ap);
  1226.     }
  1227. }
  1228.  
  1229. void
  1230. #if __STDC__
  1231. lreply(int n, const char *fmt, ...)
  1232. #else
  1233. lreply(n, fmt, va_alist)
  1234.     int n;
  1235.     char *fmt;
  1236.         va_dcl
  1237. #endif
  1238. {
  1239.     va_list ap;
  1240. #if __STDC__
  1241.     va_start(ap, fmt);
  1242. #else
  1243.     va_start(ap);
  1244. #endif
  1245.     (void)printf("%d- ", n);
  1246.     (void)vprintf(fmt, ap);
  1247.     (void)printf("\r\n");
  1248.     (void)fflush(stdout);
  1249.     if (debug) {
  1250.         syslog(LOG_DEBUG, "<--- %d- ", n);
  1251.         vsyslog(LOG_DEBUG, fmt, ap);
  1252.     }
  1253. }
  1254.  
  1255. static void
  1256. ack(s)
  1257.     char *s;
  1258. {
  1259.  
  1260.     reply(250, "%s command successful.", s);
  1261. }
  1262.  
  1263. void
  1264. nack(s)
  1265.     char *s;
  1266. {
  1267.  
  1268.     reply(502, "%s command not implemented.", s);
  1269. }
  1270.  
  1271. /* ARGSUSED */
  1272. void
  1273. yyerror(s)
  1274.     char *s;
  1275. {
  1276.     char *cp;
  1277.  
  1278.     if (cp = strchr(cbuf,'\n'))
  1279.         *cp = '\0';
  1280.     reply(500, "'%s': command not understood.", cbuf);
  1281. }
  1282.  
  1283. void
  1284. delete(name)
  1285.     char *name;
  1286. {
  1287.     struct stat st;
  1288.  
  1289.     LOGCMD("delete", name);
  1290.     if (stat(name, &st) < 0) {
  1291.         perror_reply(550, name);
  1292.         return;
  1293.     }
  1294.     if ((st.st_mode&S_IFMT) == S_IFDIR) {
  1295.         if (rmdir(name) < 0) {
  1296.             perror_reply(550, name);
  1297.             return;
  1298.         }
  1299.         goto done;
  1300.     }
  1301.     if (unlink(name) < 0) {
  1302.         perror_reply(550, name);
  1303.         return;
  1304.     }
  1305. done:
  1306.     ack("DELE");
  1307. }
  1308.  
  1309. void
  1310. cwd(path)
  1311.     char *path;
  1312. {
  1313.  
  1314.     if (chdir(path) < 0)
  1315.         perror_reply(550, path);
  1316.     else
  1317.         ack("CWD");
  1318. }
  1319.  
  1320. void
  1321. makedir(name)
  1322.     char *name;
  1323. {
  1324.  
  1325.     LOGCMD("mkdir", name);
  1326.     if (mkdir(name, 0777) < 0)
  1327.         perror_reply(550, name);
  1328.     else
  1329.         reply(257, "MKD command successful.");
  1330. }
  1331.  
  1332. void
  1333. removedir(name)
  1334.     char *name;
  1335. {
  1336.  
  1337.     LOGCMD("rmdir", name);
  1338.     if (rmdir(name) < 0)
  1339.         perror_reply(550, name);
  1340.     else
  1341.         ack("RMD");
  1342. }
  1343.  
  1344. void
  1345. pwd()
  1346. {
  1347.     char *path = getcwd (0, 0);
  1348.     if (path) {
  1349.         reply(257, "\"%s\" is current directory.", path);
  1350.         free (path);
  1351.     } else
  1352.         reply(550, "%s.", strerror (errno));
  1353. }
  1354.  
  1355. char *
  1356. renamefrom(name)
  1357.     char *name;
  1358. {
  1359.     struct stat st;
  1360.  
  1361.     if (stat(name, &st) < 0) {
  1362.         perror_reply(550, name);
  1363.         return ((char *)0);
  1364.     }
  1365.     reply(350, "File exists, ready for destination name");
  1366.     return (name);
  1367. }
  1368.  
  1369. void
  1370. renamecmd(from, to)
  1371.     char *from, *to;
  1372. {
  1373.  
  1374.     LOGCMD2("rename", from, to);
  1375.     if (rename(from, to) < 0)
  1376.         perror_reply(550, "rename");
  1377.     else
  1378.         ack("RNTO");
  1379. }
  1380.  
  1381. static void
  1382. dolog(sin)
  1383.     struct sockaddr_in *sin;
  1384. {
  1385.     char *name;
  1386.     struct hostent *hp = gethostbyaddr((char *)&sin->sin_addr,
  1387.         sizeof(struct in_addr), AF_INET);
  1388.  
  1389.     if (hp)
  1390.         name = hp->h_name;
  1391.     else
  1392.         name = inet_ntoa(sin->sin_addr);
  1393.  
  1394.     if (remotehost)
  1395.         free (remotehost);
  1396.     remotehost = malloc (strlen (name));
  1397.     strcpy (remotehost, name);
  1398.  
  1399. #ifdef SETPROCTITLE
  1400.     snprintf(proctitle, sizeof(proctitle), "%s: connected", remotehost);
  1401.     setproctitle(proctitle);
  1402. #endif /* SETPROCTITLE */
  1403.  
  1404.     if (logging)
  1405.         syslog(LOG_INFO, "connection from %s", remotehost);
  1406. }
  1407.  
  1408. /*
  1409.  * Record logout in wtmp file
  1410.  * and exit with supplied status.
  1411.  */
  1412. void
  1413. dologout(status)
  1414.     int status;
  1415. {
  1416.  
  1417.     if (logged_in) {
  1418.         (void) seteuid((uid_t)0);
  1419.         logwtmp_keep_open (ttyline, "", "");
  1420.     }
  1421.     /* beware of flushing buffers after a SIGPIPE */
  1422.     _exit(status);
  1423. }
  1424.  
  1425. static void
  1426. myoob(signo)
  1427.     int signo;
  1428. {
  1429.     char *cp;
  1430.  
  1431.     /* only process if transfer occurring */
  1432.     if (!transflag)
  1433.         return;
  1434.     cp = tmpline;
  1435.     if (telnet_fgets(cp, 7, stdin) == NULL) {
  1436.         reply(221, "You could at least say goodbye.");
  1437.         dologout(0);
  1438.     }
  1439.     upper(cp);
  1440.     if (strcmp(cp, "ABOR\r\n") == 0) {
  1441.         tmpline[0] = '\0';
  1442.         reply(426, "Transfer aborted. Data connection closed.");
  1443.         reply(226, "Abort successful");
  1444.         longjmp(urgcatch, 1);
  1445.     }
  1446.     if (strcmp(cp, "STAT\r\n") == 0) {
  1447.         if (file_size != (off_t) -1)
  1448.             reply(213, "Status: %s of %s bytes transferred",
  1449.                 off_to_str (byte_count), off_to_str (file_size));
  1450.         else
  1451.             reply(213, "Status: %s bytes transferred",
  1452.                   off_to_str (byte_count));
  1453.     }
  1454. }
  1455.  
  1456. /*
  1457.  * Note: a response of 425 is not mentioned as a possible response to
  1458.  *    the PASV command in RFC959. However, it has been blessed as
  1459.  *    a legitimate response by Jon Postel in a telephone conversation
  1460.  *    with Rick Adams on 25 Jan 89.
  1461.  */
  1462. void
  1463. passive()
  1464. {
  1465.     int len;
  1466.     char *p, *a;
  1467.  
  1468.     pdata = socket(AF_INET, SOCK_STREAM, 0);
  1469.     if (pdata < 0) {
  1470.         perror_reply(425, "Can't open passive connection");
  1471.         return;
  1472.     }
  1473.     pasv_addr = ctrl_addr;
  1474.     pasv_addr.sin_port = 0;
  1475.     (void) seteuid((uid_t)0);
  1476.     if (bind(pdata, (struct sockaddr *)&pasv_addr, sizeof(pasv_addr)) < 0) {
  1477.         (void) seteuid((uid_t)pw->pw_uid);
  1478.         goto pasv_error;
  1479.     }
  1480.     (void) seteuid((uid_t)pw->pw_uid);
  1481.     len = sizeof(pasv_addr);
  1482.     if (getsockname(pdata, (struct sockaddr *) &pasv_addr, &len) < 0)
  1483.         goto pasv_error;
  1484.     if (listen(pdata, 1) < 0)
  1485.         goto pasv_error;
  1486.     a = (char *) &pasv_addr.sin_addr;
  1487.     p = (char *) &pasv_addr.sin_port;
  1488.  
  1489. #define UC(b) (((int) b) & 0xff)
  1490.  
  1491.     reply(227, "Entering Passive Mode (%d,%d,%d,%d,%d,%d)", UC(a[0]),
  1492.         UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
  1493.     return;
  1494.  
  1495. pasv_error:
  1496.     (void) close(pdata);
  1497.     pdata = -1;
  1498.     perror_reply(425, "Can't open passive connection");
  1499.     return;
  1500. }
  1501.  
  1502. /*
  1503.  * Generate unique name for file with basename "local".
  1504.  * The file named "local" is already known to exist.
  1505.  * Generates failure reply on error.
  1506.  */
  1507. static char *
  1508. gunique(local)
  1509.     char *local;
  1510. {
  1511.     static char *new = 0;
  1512.     struct stat st;
  1513.     int count;
  1514.     char *cp;
  1515.  
  1516.     cp = strrchr(local, '/');
  1517.     if (cp)
  1518.         *cp = '\0';
  1519.     if (stat(cp ? local : ".", &st) < 0) {
  1520.         perror_reply(553, cp ? local : ".");
  1521.         return ((char *) 0);
  1522.     }
  1523.     if (cp)
  1524.         *cp = '/';
  1525.  
  1526.     if (new)
  1527.         free (new);
  1528.  
  1529.     new = malloc (strlen (local) + 5); /* '.' + DIG + DIG + '\0' */
  1530.     if (new) {
  1531.         strcpy(new, local);
  1532.         cp = new + strlen(new);
  1533.         *cp++ = '.';
  1534.         for (count = 1; count < 100; count++) {
  1535.             (void)sprintf(cp, "%d", count);
  1536.             if (stat(new, &st) < 0)
  1537.                 return (new);
  1538.         }
  1539.     }
  1540.  
  1541.     reply(452, "Unique file name cannot be created.");
  1542.     return (NULL);
  1543. }
  1544.  
  1545. /*
  1546.  * Format and send reply containing system error number.
  1547.  */
  1548. void
  1549. perror_reply(code, string)
  1550.     int code;
  1551.     char *string;
  1552. {
  1553.  
  1554.     reply(code, "%s: %s.", string, strerror(errno));
  1555. }
  1556.  
  1557. static char *onefile[] = {
  1558.     "",
  1559.     0
  1560. };
  1561.  
  1562. void
  1563. send_file_list(whichf)
  1564.     char *whichf;
  1565. {
  1566.     struct stat st;
  1567.     DIR *dirp = NULL;
  1568.     struct dirent *dir;
  1569.     FILE *dout = NULL;
  1570.     char **dirlist, *dirname;
  1571.     int simple = 0;
  1572.     int freeglob = 0;
  1573.     glob_t gl;
  1574.  
  1575.     if (strpbrk(whichf, "~{[*?") != NULL) {
  1576.         int flags = GLOB_NOCHECK;
  1577.  
  1578. #ifdef GLOB_BRACE
  1579.         flags |= GLOB_BRACE;
  1580. #endif
  1581. #ifdef GLOB_QUOTE
  1582.         flags |= GLOB_QUOTE;
  1583. #endif
  1584. #ifdef GLOB_TILDE
  1585.         flags |= GLOB_TILDE;
  1586. #endif
  1587.  
  1588.         memset(&gl, 0, sizeof(gl));
  1589.         freeglob = 1;
  1590.         if (glob(whichf, flags, 0, &gl)) {
  1591.             reply(550, "not found");
  1592.             goto out;
  1593.         } else if (gl.gl_pathc == 0) {
  1594.             errno = ENOENT;
  1595.             perror_reply(550, whichf);
  1596.             goto out;
  1597.         }
  1598.         dirlist = gl.gl_pathv;
  1599.     } else {
  1600.         onefile[0] = whichf;
  1601.         dirlist = onefile;
  1602.         simple = 1;
  1603.     }
  1604.  
  1605.     if (setjmp(urgcatch)) {
  1606.         transflag = 0;
  1607.         goto out;
  1608.     }
  1609.     while (dirname = *dirlist++) {
  1610.         if (stat(dirname, &st) < 0) {
  1611.             /*
  1612.              * If user typed "ls -l", etc, and the client
  1613.              * used NLST, do what the user meant.
  1614.              */
  1615.             if (dirname[0] == '-' && *dirlist == NULL &&
  1616.                 transflag == 0) {
  1617.                 retrieve("/bin/ls %s", dirname);
  1618.                 goto out;
  1619.             }
  1620.             perror_reply(550, whichf);
  1621.             if (dout != NULL) {
  1622.                 (void) fclose(dout);
  1623.                 transflag = 0;
  1624.                 data = -1;
  1625.                 pdata = -1;
  1626.             }
  1627.             goto out;
  1628.         }
  1629.  
  1630.         if (S_ISREG(st.st_mode)) {
  1631.             if (dout == NULL) {
  1632.                 dout = dataconn("file list", (off_t)-1, "w");
  1633.                 if (dout == NULL)
  1634.                     goto out;
  1635.                 transflag++;
  1636.             }
  1637.             fprintf(dout, "%s%s\n", dirname,
  1638.                 type == TYPE_A ? "\r" : "");
  1639.             byte_count += strlen(dirname) + 1;
  1640.             continue;
  1641.         } else if (!S_ISDIR(st.st_mode))
  1642.             continue;
  1643.  
  1644.         if ((dirp = opendir(dirname)) == NULL)
  1645.             continue;
  1646.  
  1647.         while ((dir = readdir(dirp)) != NULL) {
  1648.             char *nbuf;
  1649.  
  1650.             if (dir->d_name[0] == '.' && dir->d_name[1] == '\0')
  1651.                 continue;
  1652.             if (dir->d_name[0] == '.' && dir->d_name[1] == '.' &&
  1653.                 dir->d_name[2] == '\0')
  1654.                 continue;
  1655.  
  1656.             nbuf = alloca (strlen (dirname) + 1 + strlen (dir->d_name) + 1);
  1657.             sprintf(nbuf, "%s/%s", dirname, dir->d_name);
  1658.  
  1659.             /*
  1660.              * We have to do a stat to insure it's
  1661.              * not a directory or special file.
  1662.              */
  1663.             if (simple || (stat(nbuf, &st) == 0 &&
  1664.                 S_ISREG(st.st_mode))) {
  1665.                 if (dout == NULL) {
  1666.                     dout = dataconn("file list", (off_t)-1,
  1667.                         "w");
  1668.                     if (dout == NULL)
  1669.                         goto out;
  1670.                     transflag++;
  1671.                 }
  1672.                 if (nbuf[0] == '.' && nbuf[1] == '/')
  1673.                     fprintf(dout, "%s%s\n", &nbuf[2],
  1674.                         type == TYPE_A ? "\r" : "");
  1675.                 else
  1676.                     fprintf(dout, "%s%s\n", nbuf,
  1677.                         type == TYPE_A ? "\r" : "");
  1678.                 byte_count += strlen(nbuf) + 1;
  1679.             }
  1680.         }
  1681.         (void) closedir(dirp);
  1682.     }
  1683.  
  1684.     if (dout == NULL)
  1685.         reply(550, "No files found.");
  1686.     else if (ferror(dout) != 0)
  1687.         perror_reply(550, "Data connection");
  1688.     else
  1689.         reply(226, "Transfer complete.");
  1690.  
  1691.     transflag = 0;
  1692.     if (dout != NULL)
  1693.         (void) fclose(dout);
  1694.     data = -1;
  1695.     pdata = -1;
  1696. out:
  1697.     if (freeglob) {
  1698.         freeglob = 0;
  1699.         globfree(&gl);
  1700.     }
  1701. }
  1702.  
  1703. #ifdef SETPROCTITLE
  1704. /*
  1705.  * Clobber argv so ps will show what we're doing.  (Stolen from sendmail.)
  1706.  * Warning, since this is usually started from inetd.conf, it often doesn't
  1707.  * have much of an environment or arglist to overwrite.
  1708.  */
  1709. void
  1710. #if __STDC__
  1711. setproctitle(const char *fmt, ...)
  1712. #else
  1713. setproctitle(fmt, va_alist)
  1714.     char *fmt;
  1715.         va_dcl
  1716. #endif
  1717. {
  1718.     int i;
  1719.     va_list ap;
  1720.     char *p, *bp, ch;
  1721.     char buf[LINE_MAX];
  1722.  
  1723. #if __STDC__
  1724.     va_start(ap, fmt);
  1725. #else
  1726.     va_start(ap);
  1727. #endif
  1728.     (void)vsnprintf(buf, sizeof(buf), fmt, ap);
  1729.  
  1730.     /* make ps print our process name */
  1731.     p = Argv[0];
  1732.     *p++ = '-';
  1733.  
  1734.     i = strlen(buf);
  1735.     if (i > LastArgv - p - 2) {
  1736.         i = LastArgv - p - 2;
  1737.         buf[i] = '\0';
  1738.     }
  1739.     bp = buf;
  1740.     while (ch = *bp++)
  1741.         if (ch != '\n' && ch != '\r')
  1742.             *p++ = ch;
  1743.     while (p < LastArgv)
  1744.         *p++ = ' ';
  1745. }
  1746. #endif /* SETPROCTITLE */
  1747.