开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
main.c
资源名称：proftpd-1.2.0pre8.tar.gz　[点击查看]
上传用户：pycemail
上传日期：2007-01-04
资源大小：329k
文件大小：53k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

main.c：源码内容
  1. /*
  2.  * ProFTPD - FTP server daemon
  3.  * Copyright (c) 1997, 1998 Public Flood Software
  4.  * Copyright (C) 1999, MacGyver aka Habeeb J. Dihu <macgyver@tos.net>
  5.  *  
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  19.  */
  21. /*
  22.  * House initialization and main program loop
  23.  * $Id: main.c,v 1.18 1999/10/01 07:57:32 macgyver Exp $
  24.  */
  26. /*
  27.  * History Log:
  28.  *
  29.  * 9/21/97 current: 0.99.0pl6, next: 0.99.0pl7
  30.  *   Removed the -o (--core) option, because some kernels won't
  31.  *   produce a core dump after the euid/egid have changed.  If
  32.  *   anyone knows a way around this, please let me know.
  33.  * 4/28/97 current: 0.99.0pl1, next: 0.99.0pl2
  34.  *   Added checking for <Limit LOGIN> in fork_server(), in order
  35.  *   to disconnect any connections which can never be authorized.
  36.  * 4/24/97 current: 0.99.0pl1, next: 0.99.0pl2
  37.  *   Removed include/proftpd_conf.h; unnecessary header file
  38.  */
  40. #include "conf.h"
  42. #include <signal.h>
  43. #include <sys/resource.h>
  45. #ifdef HAVE_GETOPT_H
  46. # include <getopt.h>
  47. #endif
  49. #ifdef HAVE_LIBUTIL_H
  50. # include <libutil.h>
  51. #endif /* HAVE_LIBUTIL_H */
  53. #if PF_ARGV_TYPE == PF_ARGV_PSTAT
  54. # ifdef HAVE_SYS_PSTAT_H
  55. #  include <sys/pstat.h>
  56. # else
  57. #  undef PF_ARGV_TYPE
  58. #  define PF_ARGV_TYPE PF_ARGV_WRITEABLE
  59. # endif /* HAVE_SYS_PSTAT_H */
  60. #endif /* PF_ARGV_PSTAT */
  62. #if PF_ARGV_TYPE == PF_ARGV_PSSTRINGS
  63. # ifndef HAVE_SYS_EXEC_H
  64. #  undef PF_ARGV_TYPE
  65. #  define PF_ARGV_TYPE PF_ARGV_WRITEABLE
  66. # else
  67. #  include <machine/vmparam.h>
  68. #  include <sys/exec.h>
  69. # endif /* HAVE_SYS_EXEC_H */
  70. #endif /* PF_ARGV_PSSTRINGS */
  72. #ifdef HAVE_REGEX_H
  73. #include <regex.h>
  74. #endif
  76. #ifdef HAVE_REGEXP_H
  77. # include <regexp.h>
  78. #endif /* HAVE_REGEXP_H */
  80. #include "privs.h"
  82. /* From mod_core.c
  83.  */
  84. extern int core_display_file(const char *numeric, const char *fn);
  86. struct rehash {
  87.   struct rehash *next;
  89.   void *data;
  90.   void (*rehash)(void*);
  91. };
  93. typedef struct _pidrec {
  94.   struct _pidrec *next,*prev;
  96.   pid_t pid;
  97.   int dead;
  98. } pidrec_t;
  100. typedef struct _binding {
  101.   struct _binding *next;
  103.   server_rec *server; /* server to handle request */
  104.   p_in_addr_t ipaddr; /* ip address "bound" to */
  105.   int        port;
  106.   conn_t     *listen; /* listen connection (if separate) */
  107.   char       isdefault; /* if default connection */
  108.   char       islocalhost; /* if handles localhost */
  109. } binding_t;
  111. void addl_bindings(server_rec*);
  113. extern xaset_t *servers;
  115. session_t session;
  116. int master = TRUE; /* Master daemon in standalone mode */
  117. int standalone = 0; /* If in standalone mode */
  118. pid_t mpid = 0; /* Master pid */
  119. int rehash = 0; /* Performing rehash? */
  120. struct rehash *rehash_list = NULL; /* Pre-rehash callbacks */
  121. binding_t *bind_list = NULL;
  122. pool *bind_pool = NULL;
  124. time_t shut = (time_t)0,deny = (time_t)0, disc = (time_t)0;
  125. char shutmsg[81] = "";
  127. xaset_t *children = NULL;
  128. static int child_count = 0,child_flag = 0;
  130. response_t *resp_list = NULL,*resp_err_list = NULL;
  131. static pool *resp_pool = NULL;
  132. static int (*main_check_auth)(cmd_rec*) = NULL;
  133. static char sbuf[1024];
  134. static char _ml_numeric[4];
  135. static char **Argv = NULL;
  136. static char *LastArgv = NULL;
  138. static int shutdownp = 0;
  139. static int abort_core = 0;
  140. static RETSIGTYPE sig_disconnect(int);
  141. static RETSIGTYPE sig_debug(int);
  143. char *config_filename = CONFIG_FILE_PATH;
  145. #if 0
  146. void test_fs()
  147. {
  148.   glob_t pglob;
  149.   char buf[1024];
  150.   char **cp;
  151.   int fd;
  152.   fsdir_t *f;
  153.   size_t l;
  155.   bzero(&pglob,sizeof(pglob));
  157.   chdir("/");
  158.   fs_setcwd("/");
  159.   if(fs_chdir("~flood/test",TRUE) == -1)
  160.     perror("fs_chdir [tmp]");
  162.   fs_chdir("test.tar/foo",1);
  164.   printf("cwd: %sn",fs_getcwd());
  165.   printf("vwd: %sn",fs_getvwd());
  167.   f = fs_open("TESTFILE",O_RDONLY,&fd);
  168.   if(!f) {
  169.     perror("fs_open");
  170.     exit(1);
  171.   }
  173.   fs_lseek(f,fd,-1024,SEEK_END);
  174.   while((l = fs_read(f,fd,buf,sizeof(buf)-1)) > 0) {
  175.     buf[l] = '';
  176.     printf("%s",buf);
  177.   }
  179.   fs_close(f,fd);
  180.   exit(0);
  182.   if(fs_glob("*",GLOB_PERIOD,0,&pglob) == -1)
  183.     perror("fs_glob");
  184.   else {
  185.     cp = pglob.gl_pathv;
  186.     while(pglob.gl_pathc--) {
  187.       printf("matched: %sn",*cp);
  188.       cp++;
  189.     }
  190.   }
  192.   exit(0);
  193. }
  194. #endif
  196. int add_binding(server_rec *server, p_in_addr_t *ipaddr, conn_t *listen,
  197.                 char isdefault, char islocalhost)
  198. {
  199.   binding_t *b;
  201.   for(b = bind_list; b; b=b->next)
  202.     if(b->ipaddr.s_addr == ipaddr->s_addr &&
  203.        b->port == server->ServerPort) {
  204.       /* binding already exists for this IP */
  205.       log_pri(LOG_NOTICE,"cannot bind %s:%d to server '%s', already bound to '%s'.",
  206.               inet_ntoa(*ipaddr),server->ServerPort,
  207.               server->ServerName,b->server->ServerName);
  208.       return -1;
  209.     }
  211.   if(!bind_pool)
  212.     bind_pool = make_sub_pool(permanent_pool);
  214.   b = palloc(bind_pool,sizeof(binding_t));
  215.   b->server = server;
  216.   b->port = server->ServerPort;
  217.   b->ipaddr = *ipaddr;
  218.   b->listen = listen;
  219.   b->isdefault = isdefault;
  220.   b->islocalhost = islocalhost;
  222.   b->next = bind_list;
  223.   bind_list = b;
  225.   return 0;
  226. }
  228. server_rec *find_binding(p_in_addr_t *ipaddr, int port)
  229. {
  230.   binding_t *b,*local_b = NULL,*default_b = NULL;
  232.   for(b = bind_list; b; b=b->next) {
  233.     if(b->ipaddr.s_addr == ipaddr->s_addr && (!b->port || b->port == port))
  234.       return b->server;
  236.     if(b->islocalhost)
  237.       local_b = b;
  238.     if(b->isdefault)
  239.       default_b = b;
  240.   }
  242.   /* Not found in binding list, so see if it's the loopback address */
  243.   if(local_b) {
  244.     p_in_addr_t loopback,loopmask,tmp;
  246. #ifdef HAVE_INET_ATON
  247.     inet_aton(LOOPBACK_NET,&loopback);
  248.     inet_aton(LOOPBACK_MASK,&loopmask);
  249. #else
  250.     loopback.s_addr = inet_addr(LOOPBACK_NET);
  251.     loopmask.s_addr = inet_addr(LOOPBACK_MASK);
  252. #endif
  253.     loopback.s_addr = ntohl(loopback.s_addr);
  254.     loopmask.s_addr = ntohl(loopmask.s_addr);
  255.     tmp.s_addr = ntohl(ipaddr->s_addr);
  257.     if((tmp.s_addr & loopmask.s_addr) == loopback.s_addr &&
  258.        (!local_b->port || port == local_b->port))
  259.       return local_b->server;
  260.   }
  262.   /* otherwise, use the default server, if set */
  263.   if(default_b)
  264.     return default_b->server;
  266.   return NULL;
  267. }
  269. conn_t *accept_binding(fd_set *rfd, int *lfd)
  270. {
  271.   binding_t *b;
  272.   int fd;
  274.   for(b = bind_list; b; b=b->next) {
  275.     if(b->listen && FD_ISSET(b->listen->listen_fd,rfd) &&
  276.        b->listen->mode == CM_LISTEN) {
  277.       if((fd = inet_accept_nowait(b->listen->pool,b->listen)) == -1) {
  278. /* Handle errors gracefully.  If we're here, then b->listen contains
  279.  * either error information, or we just got caught in a blocking
  280.  * condition. - MacGyver
  281.  */
  282. if(b->listen->mode == CM_ERROR) {
  283.   log_pri(LOG_ERR, "Error: unable to accept an incoming connection (%s)",
  284.   strerror(b->listen->xerrno));
  285.   b->listen->xerrno = 0;
  286.   b->listen->mode = CM_LISTEN;
  287.   return NULL;
  288. }
  289.       }
  290.       
  291.       *lfd = fd;
  292.       return b->listen;
  293.     }
  294.   }
  296.   return NULL;
  297. }
  299. int listen_binding(fd_set *rfd)
  300. {
  301.   int max_fd = 0;
  302.   binding_t *b;
  304.   FD_ZERO(rfd);
  305.   for(b = bind_list; b; b=b->next) {
  306.     if(b->listen) {
  307.       if(b->listen->mode == CM_NONE)
  308.         inet_listen(b->listen->pool,b->listen,tcpBackLog);
  310.       if(b->listen->mode == CM_ACCEPT)
  311.         inet_resetlisten(b->listen->pool,b->listen);
  312.       if(b->listen->mode == CM_LISTEN) {
  313.         FD_SET(b->listen->listen_fd,rfd);
  314. if (b->listen->listen_fd > max_fd)
  315. max_fd = b->listen->listen_fd;
  316.       }
  317.     }
  318.   }
  319.   return max_fd;
  320. }
  322. static void init_set_proc_title(int argc, char *argv[], char *envp[])
  323. {
  324. #ifdef HAVE___PROGNAME
  325.   extern char *__progname, *__progname_full;
  326. #endif /* HAVE___PROGNAME */
  327.   int i;
  328.   
  329.   Argv = argv;
  330.   
  331.   for(i = 0; i < argc; i++) {
  332.     if(!i || (LastArgv + 1 == argv[i]))
  333.       LastArgv = argv[i] + strlen(argv[i]);
  334.   }
  335.   
  336.   for(i = 0; envp[i] != NULL; i++) {
  337.     if((LastArgv + 1) == envp[i])
  338.       LastArgv = envp[i] + strlen(envp[i]);
  339.   }
  340.   
  341. #ifdef HAVE___PROGNAME
  342.   /* Set the __progname and __progname_full variables so glibc and company don't
  343.    * go nuts. - MacGyver
  344.    */
  345.   __progname = strdup("proftpd");
  346.   __progname_full = strdup(argv[0]);
  347. #endif /* HAVE___PROGNAME */
  348.   
  349. #if 0
  350.   /* Save argument/environment globals for use by set_proc_title */
  352.   Argv = argv;
  353.   while(*envp)
  354.     envp++;
  356.   LastArgv = envp[-1] + strlen(envp[-1]);
  357. #endif
  358. }    
  360. void set_proc_title(char *fmt,...)
  361. {
  362.   va_list msg;
  363.   static char statbuf[BUFSIZ];
  364.   
  365. #ifndef HAVE_SETPROCTITLE
  366. #if PF_ARGV_TYPE == PF_ARGV_PSTAT
  367.    union pstun pst;
  368. #endif /* PF_ARGV_PSTAT */
  369.   char *p;
  370.   int i,maxlen = (LastArgv - Argv[0]) - 2;
  371. #endif /* HAVE_SETPROCTITLE */
  373.   va_start(msg,fmt);
  375.   memset(statbuf, 0, sizeof(statbuf));
  376.   vsnprintf(statbuf, sizeof(statbuf), fmt, msg);
  378. #ifdef HAVE_SETPROCTITLE
  379.   setproctitle(statbuf);
  380. #endif /* HAVE_SETPROCTITLE */
  382.   va_end(msg);
  383.   
  384. #ifdef HAVE_SETPROCTITLE
  385.   return;
  386. #else
  387.   i = strlen(statbuf);
  389. #if PF_ARGV_TYPE == PF_ARGV_NEW
  390.   /* We can just replace argv[] arguments.  Nice and easy.
  391.    */
  392.   Argv[0] = statbuf;
  393.   Argv[1] = NULL;
  394. #endif /* PF_ARGV_NEW */
  396. #if PF_ARGV_TYPE == PF_ARGV_WRITEABLE
  397.   /* We can overwrite individual argv[] arguments.  Semi-nice.
  398.    */
  399.   snprintf(Argv[0], maxlen, "%s", statbuf);
  400.   p = &Argv[0][i];
  401.   
  402.   while(p < LastArgv)
  403.     *p++ = '';
  404.   Argv[1] = NULL;
  405. #endif /* PF_ARGV_WRITEABLE */
  407. #if PF_ARGV_TYPE == PF_ARGV_PSTAT
  408.   pst.pst_command = statbuf;
  409.   pstat(PSTAT_SETCMD, pst, i, 0, 0);
  410. #endif /* PF_ARGV_PSTAT */
  412. #if PF_ARGV_TYPE == PF_ARGV_PSSTRINGS
  413.   PS_STRINGS->ps_nargvstr = 1;
  414.   PS_STRINGS->ps_argvstr = statbuf;
  415. #endif /* PF_ARGV_PSSTRINGS */
  417. #endif /* HAVE_SETPROCTITLE */
  418. }
  419.   
  420. void main_set_idle()
  421. {
  422.   time_t now;
  424.   time(&now);
  426.   log_add_run(mpid, &now,session.user,
  427.       (session.class && session.class->name) ?
  428.       session.class->name : "",
  429.               main_server->ipaddr, (unsigned short) main_server->ServerPort,
  430.               0, 0, "proftpd: %s - %s: IDLE",
  431.       session.user,session.proc_prefix);
  432.   set_proc_title("proftpd: %s - %s: IDLE", session.user, session.proc_prefix);
  433. }
  435. static void send_response_list(response_t **head)
  436. {
  437.   int ml = 0;
  438.   char *last_numeric = NULL;
  439.   response_t *t;
  441.   for(t = *head; t; t=t->next) {
  442.     if(ml) {
  443.       /* look for end of multiline */
  444.       if(!t->next || (t->num && strcmp(t->num,last_numeric) != 0)) {
  445.         io_printf(session.c->outf,"%s %srn",last_numeric,t->msg);
  446.         ml = 0;
  447.       } else {
  448. if(MultilineRFC2228)
  449.   io_printf(session.c->outf,"%s-%srn",last_numeric,t->msg);
  450. else
  451.   io_printf(session.c->outf," %srn",t->msg);
  452.       }
  453.     } else {
  454.       /* look for start of multiline */
  455.       if(t->next && (!t->next->num || strcmp(t->num,t->next->num) == 0)) {
  456.         io_printf(session.c->outf,"%s-%srn",t->num,t->msg);
  457.         ml = 1;
  458.         last_numeric = t->num;
  459.       } else
  460.         io_printf(session.c->outf,"%s %srn",t->num,t->msg);
  461.     }
  462.   }
  464.   *head = NULL;
  465. }
  467. void add_response_err(const char *numeric, const char *fmt, ...)
  468. {
  469.   va_list msg;
  470.   response_t *t,**head;
  472.   va_start(msg,fmt);
  473.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  474.   va_end(msg);
  475.   
  476.   sbuf[sizeof(sbuf) - 1] = '';
  477.   
  478.   t = (response_t*) pcalloc(resp_pool, sizeof(response_t));
  479.   t->num = (numeric ? pstrdup(resp_pool, numeric) : NULL);
  480.   t->msg = pstrdup(resp_pool, sbuf);
  481.   
  482.   for(head = &resp_err_list; *head && (!numeric || !(*head)->num ||
  483.       strcmp((*head)->num,numeric) <= 0); head = &(*head)->next) ;
  485.   t->next = *head;
  486.   *head = t;
  487. }
  489. void add_response(const char *numeric, const char *fmt, ...)
  490. {
  491.   va_list msg;
  492.   response_t *t,**head;
  494.   va_start(msg,fmt);
  495.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  496.   va_end(msg);
  498.   sbuf[sizeof(sbuf) - 1] = '';
  499.   
  500.   t = (response_t*) pcalloc(resp_pool, sizeof(response_t));
  501.   t->num = (numeric ? pstrdup(resp_pool, numeric) : NULL);
  502.   t->msg = pstrdup(resp_pool, sbuf);
  503.   
  504.   for(head = &resp_list; *head && (!numeric || !(*head)->num ||
  505.       strcmp((*head)->num,numeric) <= 0); head = &(*head)->next) ;
  507.   t->next = *head;
  508.   *head = t;
  509. }
  511. void send_response_raw(const char *fmt, ...)
  512. {
  513.   va_list msg;
  515.   va_start(msg,fmt);
  516.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  517.   va_end(msg);
  519.   sbuf[sizeof(sbuf) - 1] = '';
  520.   io_printf(session.c->outf, "%srn", sbuf);
  521. }
  523. void send_response_async(const char *resp_numeric, const char *fmt, ...)
  524. {
  525.   char buf[1024];
  526.   va_list msg;
  527.   int maxlen;
  529.   sstrncpy(buf, resp_numeric, sizeof(buf));
  530.   sstrcat(buf, " ", sizeof(buf));
  531.   
  532.   maxlen = sizeof(buf) - strlen(buf) - 1;
  533.   
  534.   va_start(msg, fmt);
  535.   vsnprintf(buf + strlen(buf), maxlen, fmt, msg);
  536.   va_end(msg);
  537.   
  538.   buf[sizeof(buf) - 1] = '';
  539.   sstrcat(buf, "rn", sizeof(buf));
  541.   io_write_async(session.c->outf, buf, strlen(buf));
  542. }
  544. void send_response(const char *resp_numeric, const char *fmt, ...)
  545. {
  546.   va_list msg;
  548.   va_start(msg,fmt);
  549.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  550.   va_end(msg);
  551.   
  552.   sbuf[sizeof(sbuf) - 1] = '';
  553.   io_printf(session.c->outf,"%s %srn",resp_numeric, sbuf);
  554. }
  556. void send_response_ml_start(const char *resp_numeric, const char *fmt, ...)
  557. {
  558.   va_list msg;
  560.   va_start(msg,fmt);
  561.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  562.   va_end(msg);
  564.   sbuf[sizeof(sbuf) - 1] = '';
  565.   sstrncpy(_ml_numeric, resp_numeric, sizeof(_ml_numeric));
  566.   
  567.   io_printf(session.c->outf, "%s-%srn", _ml_numeric, sbuf);
  568. }
  570. void send_response_ml(const char *fmt, ...)
  571. {
  572.   va_list msg;
  574.   va_start(msg,fmt);
  575.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  576.   va_end(msg);
  578.   sbuf[sizeof(sbuf) - 1] = '';
  580.   io_printf(session.c->outf, " %srn", sbuf);
  581. }
  583. void send_response_ml_end(const char *fmt, ...)
  584. {
  585.   va_list msg;
  586.  
  587.   va_start(msg,fmt);
  588.   vsnprintf(sbuf, sizeof(sbuf), fmt, msg);
  589.   va_end(msg);
  591.   sbuf[sizeof(sbuf) - 1] = '';
  593.   io_printf(session.c->outf, "%s %srn", _ml_numeric, sbuf);
  594. }
  596. void set_auth_check(int (*ck)(cmd_rec*))
  597. {
  598.   main_check_auth = ck;
  599. }
  601. void end_login_noexit()
  602. {
  603.   /* Run all the exit handlers */
  604.   run_exit_handlers();
  606.   /* If session.user is set, we have a valid login */
  607.   if(session.user) {
  608. #if (defined(BSD) && (BSD >= 199103))
  609.     snprintf(sbuf, sizeof(sbuf), "ftp%ld",(long)getpid());
  610. #else
  611.     snprintf(sbuf, sizeof(sbuf), "ftpd%d",(int)getpid());
  612. #endif
  613.     sbuf[sizeof(sbuf) - 1] = '';
  614.     
  615.     if(session.wtmp_log)
  616.       log_wtmp(sbuf,"",
  617.         (session.c && session.c->remote_name ? session.c->remote_name : ""),
  618.         (session.c && session.c->remote_ipaddr ? session.c->remote_ipaddr : NULL));
  619.     log_add_run(mpid,NULL,NULL,NULL,NULL,0,0,0,NULL);
  620.     log_close_run();
  621.   }
  622. }
  624. /* Finish any cleaning up, mark utmp as closed and exit
  625.  * without flushing buffers
  626.  */
  628. void end_login(int exitcode)
  629. {
  630.   end_login_noexit();
  631.   _exit(exitcode);
  632. }
  634. void main_exit(void *pv, void *lv, void *ev, void *dummy)
  635. {
  636.   int pri = (int)pv;
  637.   char *log = (char*)lv;
  638.   int exitcode = (int)ev;
  640.   log_pri(pri,log);
  641.   if(standalone && master)
  642.     log_pri(LOG_NOTICE,"ProFTPD %s standalone mode SHUTDOWN",VERSION);
  643.   end_login(exitcode);
  644. }
  646. void shutdown_exit(void *d1, void *d2, void *d3, void *d4)
  647. {
  648.   char *msg;
  650.   if(check_shutmsg(&shut,&deny,&disc,shutmsg,sizeof(shutmsg)) == 1) {
  651.     char *user;
  652.     time_t now;
  654.     time(&now);
  655.     if(get_param_int(main_server->conf,"authenticated",FALSE) == 1)
  656.       user = get_param_ptr(main_server->conf,"USER",FALSE);
  657.     else
  658.       user = "NONE";
  660.     msg = sreplace(permanent_pool,shutmsg,
  661.                    "%s",pstrdup(permanent_pool,fmt_time(shut)),
  662.                    "%r",pstrdup(permanent_pool,fmt_time(deny)),
  663.                    "%d",pstrdup(permanent_pool,fmt_time(disc)),
  664.    "%C",(session.cwd[0] ? session.cwd : "(none)"),
  665.    "%L",main_server->ServerAddress,
  666.    "%R",(session.c && session.c->remote_name ?
  667.                          session.c->remote_name : "(unknown)"),
  668.    "%T",pstrdup(permanent_pool,fmt_time(now)),
  669.    "%U",user,
  670.    "%V",main_server->ServerName,
  671.                    NULL );
  673.     send_response_async(R_421,"FTP server shutting down - %s",msg);
  675.     main_exit((void*)LOG_NOTICE,msg,(void*)0,NULL);
  676.   }
  678.   signal(SIGUSR1,sig_disconnect);
  679. }
  681. static int _dispatch(cmd_rec *cmd, int cmd_type, int validate, char *match)
  682. {
  683.   char *argstr;
  684.   cmdtable *c;
  685.   modret_t *mr;
  686.   int success = 0;
  687.   int send_error = 0;
  688.   static int match_index_cache = -1;
  689.   static char *last_match = NULL;
  690.   int *index_cache;
  692.   send_error = (cmd_type == CMD || cmd_type == PRE_CMD);
  694.   if(!match) {
  695.     match = cmd->argv[0];
  696.     index_cache = &cmd->symtable_index;
  697.   } else {
  698.     if(last_match != match) {
  699.       match_index_cache = -1;
  700.       last_match = match;
  701.     }
  703.     index_cache = &match_index_cache;
  704.   }
  706.   c = mod_find_cmd_symbol(match,index_cache,NULL);
  707.   while(c && !success) {
  708.     if(c->cmd_type == cmd_type) {
  709.       if(c->group)
  710.         cmd->group = pstrdup(cmd->pool,c->group);
  712.       if(c->requires_auth && main_check_auth && !main_check_auth(cmd))
  713.         return -1;
  715. #if 0
  716.       if(!c->interrupt_xfer && (session.flags & SF_XFER)) {
  717.         if(send_error)
  718.           add_response_err(R_451,"Cannot accept command, transfer is in progress.");
  719.         success = -1;
  720.         break;
  721.       }
  722. #endif
  724.       cmd->tmp_pool = make_named_sub_pool(cmd->pool,"temp - dispatch pool");
  726.       argstr = make_arg_str(cmd->tmp_pool,cmd->argc,cmd->argv);
  728.       if(session.user && (session.flags & SF_XFER) == 0 &&
  729.          cmd_type == CMD) {
  730.         log_add_run(mpid, NULL, session.user,
  731.     (session.class && session.class->name) ?
  732.     session.class->name : "",
  733.     NULL, 0, 0, 0, "proftpd: %s - %s: %s",
  734.                     session.user,session.proc_prefix,
  735.                     make_arg_str(cmd->tmp_pool,cmd->argc,cmd->argv));
  736.         set_proc_title("proftpd: %s - %s: %s",
  737.                        session.user,session.proc_prefix,
  738.                        argstr);
  739.       }
  741.       /* Hack to hide passwords */
  743.       if(send_error) {
  744.         if(!strcasecmp(cmd->argv[0],"PASS"))
  745.           log_debug(DEBUG4,"received: PASS (hidden)");
  746.         else
  747.           log_debug(DEBUG4,"received: %s",argstr);
  748.       }
  750.       cmd->class |= c->class;
  752.       /* KLUDGE: disable umask() for not G_WRITE operations.  Config/
  753.        * Directory walking code will be completely redesigned in 1.3,
  754.        * this is only necessary for perfomance reasons in 1.1/1.2
  755.        */
  757.       if(!c->group || strcmp(c->group,G_WRITE) != 0)
  758.         kludge_disable_umask();
  759.       mr = call_module_cmd(c->m,c->handler,cmd);
  760.       kludge_enable_umask();
  762.       if(MODRET_ISHANDLED(mr))
  763.         success = 1;
  764.       else if(MODRET_ISERROR(mr)) {
  765.         if(cmd_type == POST_CMD || cmd_type == LOG_CMD || 
  766.                                    cmd_type == LOG_CMD_ERR) {
  767.           if(MODRET_ERRMSG(mr))
  768.             log_pri(LOG_NOTICE,"%s",MODRET_ERRMSG(mr));
  769.         } else if(send_error) {
  770.           if(MODRET_ERRNUM(mr) && MODRET_ERRMSG(mr))
  771.             add_response_err(MODRET_ERRNUM(mr),MODRET_ERRMSG(mr));
  772.           else if(MODRET_ERRMSG(mr))
  773.             send_response_raw(MODRET_ERRMSG(mr));
  774.         }
  776.         success = -1;
  777.       }
  779.       if(session.user && (session.flags & SF_XFER) == 0 && cmd_type == CMD)
  780.         main_set_idle();
  782.       destroy_pool(cmd->tmp_pool);
  783.     }
  785.     if(!success)
  786.       c = mod_find_cmd_symbol(match,index_cache,c);
  787.   }
  789.   if(!c && !success && validate) {
  790.     add_response_err("500", "%s not understood.", cmd->argv[0]);
  791.     success = -1;
  792.   }
  794.   return success;
  795. }
  797. static void dispatch_cmd(cmd_rec *cmd)
  798. {
  799.   char *cp;
  800.   int success = 0;
  802. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  803.   regex_t *preg;
  804.   int ret;
  805. #endif
  806.   
  807.   cmd->server = main_server;
  808.   resp_list = resp_err_list = NULL;
  809.   resp_pool = cmd->pool;
  810.   
  811. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  812.   /* Check for valid arguments.
  813.    */
  814.   preg = (regex_t*) get_param_ptr(TOPLEVEL_CONF, "AllowFilter", FALSE);
  815.   
  816.   if(preg && ((ret = regexec(preg, cmd->arg, 0, NULL, 0)) != 0)) {
  817.     char errmsg[200];
  818.     
  819.     regerror(ret, preg, errmsg, 200);
  820.     log_debug(DEBUG2, "'%s' didn't pass regex: %s", cmd->arg, errmsg);
  821.     add_response_err(R_550,"%s: Forbidden command argument", cmd->arg);
  822.     send_response_list(&resp_err_list);
  823.     return;
  824.   }
  825.   
  826.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"DenyFilter",FALSE);
  827.   
  828.   if(preg && ((ret = regexec(preg, cmd->arg, 0, NULL, 0)) == 0)) {
  829.     add_response_err(R_550,"%s: Forbidden command argument", cmd->arg);
  830.     send_response_list(&resp_err_list);
  831.     return;
  832.   }
  833. #endif
  834.   
  835.   for(cp = cmd->argv[0]; *cp; cp++)
  836.     *cp = toupper(*cp);
  838.   /* debug_print_dispatch(cmd); */
  840.   /* first dispatch PRE_CMD with wildcard */
  841.   success = _dispatch(cmd,PRE_CMD,FALSE,"*");
  843.   if(!success) /* run other pre_cmd */
  844.     success = _dispatch(cmd,PRE_CMD,FALSE,NULL);
  846.   if(success < 0) {
  847.     send_response_list(&resp_err_list);
  848.     return;
  849.   }
  851.   success = _dispatch(cmd,CMD,FALSE,"*");
  852.   if(!success)
  853.     success = _dispatch(cmd,CMD,TRUE,NULL);
  855.   if(success == 1) {
  856.     success = _dispatch(cmd,POST_CMD,FALSE,"*");
  857.     if(!success)
  858.       success = _dispatch(cmd,POST_CMD,FALSE,NULL);
  860.     _dispatch(cmd,LOG_CMD,FALSE,"*");
  861.     _dispatch(cmd,LOG_CMD,FALSE,NULL);
  863.     send_response_list(&resp_list);
  864.   } else if(success < 0) {
  865.     _dispatch(cmd,LOG_CMD_ERR,FALSE,"*");
  866.     _dispatch(cmd,LOG_CMD_ERR,FALSE,NULL);
  868.     send_response_list(&resp_err_list);
  869.   }
  870. }
  872. cmd_rec *make_cmd(pool *p, char *buf)
  873. {
  874.   char *cp = buf, *wrd;
  875.   cmd_rec *newcmd;
  876.   pool *newpool;
  877.   array_header *tarr;
  879.   newpool = make_sub_pool(p);
  880.   newcmd = (cmd_rec*)pcalloc(newpool,sizeof(cmd_rec));
  881.   newcmd->pool = newpool;
  882.   newcmd->symtable_index = -1;
  883.   
  884.   tarr = make_array(newpool,2,sizeof(char*));
  886.   if((wrd = get_word(&cp)) != NULL) {
  887.     *((char**)push_array(tarr)) = pstrdup(newpool,wrd);
  888.     newcmd->argc++;
  889.     newcmd->arg = pstrdup(newpool,cp);
  890.  
  891.     while((wrd = get_word(&cp)) != NULL) {
  892.       *((char**)push_array(tarr)) = pstrdup(newpool,wrd);
  893.       newcmd->argc++;
  894.     }
  895.   }
  897.   *((char**)push_array(tarr)) = NULL;
  899.   newcmd->argv = (char**)tarr->elts;
  901.   return newcmd;
  902. }
  904. static int _idle_timeout(CALLBACK_FRAME)
  905. {
  906.   /* we don't want to quit in the middle of a transfer */
  907.   if(session.flags & SF_XFER)
  908.     return 1; /* auto-restart the timer */
  910.   send_response_async(R_421,"Idle Timeout (%d seconds): closing control connection.", 
  911.                       TimeoutIdle);
  913.   main_exit((void*)LOG_NOTICE,
  914.   "FTP session idle timeout, disconnected.",
  915.   (void*)0,NULL);
  917.   remove_timer(TIMER_LOGIN,ANY_MODULE);
  918.   remove_timer(TIMER_NOXFER,ANY_MODULE);
  919.   return 0;
  920. }
  922. void cmd_loop(server_rec *server, conn_t *c)
  923. {
  924.   static int CmdBufSize = -1;
  925.   config_rec *id;
  926.   char buf[1024];
  927.   char *cp;
  928.   char *display;
  929.   int i;
  931.   /* Setup the main idle timer */
  932.   if(TimeoutIdle)
  933.     add_timer(TimeoutIdle,TIMER_IDLE,NULL,_idle_timeout);
  935.   display = (char*)get_param_ptr(server->conf,"DisplayConnect",FALSE);
  936.   if(display) {
  937.       core_display_file(R_220,display);
  938.   }
  940.   if((id = find_config(server->conf,CONF_PARAM,"ServerIdent",FALSE)) == NULL ||
  941.   !id->argv[0]) {
  942.     if(id && id->argc > 1)
  943.       send_response("220","%s",(char*)id->argv[1]);
  944.     else if(get_param_int(server->conf,"DeferWelcome",FALSE) == 1)
  945.       send_response("220", "ProFTPD " VERSION " Server ready.");
  946.     else
  947.       send_response("220", "ProFTPD " VERSION " Server (%s) [%s]",
  948.            server->ServerName,server->ServerAddress);
  949.   }
  950.   else
  951.   {
  952.     send_response("220", "%s FTP server ready.", server->ServerAddress);
  953.   }
  955.   /* make sure we can receive OOB data */
  956.   inet_setasync(session.pool,session.c);
  958.   while(1) {
  959.     if(io_telnet_gets(buf,sizeof(buf)-1,session.c->inf,session.c->outf) == NULL) {
  960.       if(session.c->inf->xerrno == EINTR)
  961. continue; /* Simple interrupted syscall */
  962.       
  963.       /* Otherwise, EOF */
  964.       log_pri(LOG_NOTICE,"FTP session closed.");
  965.       end_login(0);
  966.     }
  968.     /* Data received, reset idle timer */
  969.     if(TimeoutIdle)
  970.       reset_timer(TIMER_IDLE,NULL);
  972.     if(CmdBufSize == -1) {
  973.       if((CmdBufSize = get_param_int(main_server->conf,
  974.      "CommandBufferSize", FALSE)) <= 0) {
  975. CmdBufSize = 512;
  976.       } else if(CmdBufSize + 1 > sizeof(buf)) {
  977. log_pri(LOG_WARNING,
  978. "Invalid CommandBufferSize size given.  Resetting to 512.");
  979. CmdBufSize = 512;
  980.       }
  981.     }
  982.     
  983.     buf[CmdBufSize - 1] = '';
  984.     i = strlen(buf);
  986.     if(i && (buf[i-1] == 'n' || buf[i-1] == 'r')) {
  987.       buf[i-1] = ''; i--;
  988.       if(i && (buf[i-1] == 'n' || buf[i-1] =='r'))
  989.         buf[i-1] = '';
  990.     }
  992.     cp = buf;
  993.     if(*cp == 'r') cp++;
  995.     if(*cp) {
  996.       cmd_rec *cmd;
  998.       cmd = make_cmd(permanent_pool,cp);
  999.       if(cmd) {
  1000.         dispatch_cmd(cmd);
  1001.         destroy_pool(cmd->pool);
  1002.       }
  1003.     }
  1004.   }
  1005. }
  1007. static void _server_conn_cleanup(void *connp)
  1008. {
  1009.   *((conn_t**)connp) = NULL;
  1010. }
  1012. void register_rehash(void *data, void (*fp)(void*))
  1013. {
  1014.   struct rehash *r = (struct rehash*)pcalloc(permanent_pool,
  1015.    sizeof(struct rehash));
  1017.   r->data = data;
  1018.   r->rehash = fp;
  1019.   r->next = rehash_list;
  1020.   rehash_list = r;
  1021. }
  1023. void main_rehash(void *d1,void *d2,void *d3,void *d4)
  1024. {
  1025.   struct rehash *rh;
  1026.   server_rec *s,*snext,*old_main;
  1027.   xaset_t *old_servers;
  1028.   int isdefault;
  1030.   rehash++;
  1032.   old_servers = servers;
  1033.   old_main = main_server;
  1035.   if(master && mpid) {
  1036.     log_pri(LOG_NOTICE,"received SIGHUP -- master server rehashing configuration file.");
  1038.     for(rh = rehash_list; rh; rh=rh->next)
  1039.       rh->rehash(rh->data);
  1040.     
  1041.     init_config();
  1042.     init_conf_stacks();
  1044.     PRIVS_ROOT
  1045.     if(parse_config_file(config_filename) == -1) {
  1046.       PRIVS_RELINQUISH
  1047.       log_pri(LOG_ERR,"Fatal: unable to read configuration file '%s'.",
  1048.               config_filename);
  1049.       end_login(1);
  1050.     }
  1051.     PRIVS_RELINQUISH
  1052.     free_conf_stacks();
  1054.     fixup_servers();
  1056.     /* Free old configuration completely */
  1058.     for(s = (server_rec*)old_servers->xas_list; s; s=snext) {
  1059.       snext = s->next;
  1060.       destroy_pool(s->pool);
  1061.     }
  1063.     destroy_pool(old_servers->mempool);
  1065.     /* Destroy the old bind list */
  1066.     if(bind_pool) {
  1067.       destroy_pool(bind_pool);
  1068.       bind_pool = NULL;
  1069.     }
  1070.     bind_list = NULL;
  1072.     /* Recreate the listen connection */
  1074.     if(main_server->ServerPort)
  1075.       main_server->listen =
  1076.         inet_create_connection(main_server->pool,servers,-1,
  1077.                                (SocketBindTight ? main_server->ipaddr : NULL),
  1078.               main_server->ServerPort,FALSE);
  1079.     else
  1080.       main_server->listen = NULL;
  1082.     isdefault = get_param_int(main_server->conf,"DefaultServer",FALSE);
  1083.     if(isdefault != 1)
  1084.       isdefault = 0;
  1086.     if(main_server->ServerPort || isdefault) {
  1087.       add_binding(main_server,main_server->ipaddr,main_server->listen,
  1088.                   isdefault,1);
  1089.       addl_bindings(main_server);
  1090.     }
  1092.     for(s = main_server->next; s; s=s->next) {
  1093.       if(s->ServerPort != main_server->ServerPort || SocketBindTight ||
  1094.          !main_server->listen) {
  1096.         isdefault = get_param_int(s->conf,"DefaultServer",FALSE);
  1097.         if(isdefault != 1)
  1098.           isdefault = 0;
  1100.         if(s->ServerPort) {
  1101.           s->listen = inet_create_connection(
  1102.                         s->pool,servers,-1,
  1103.                         (SocketBindTight ? s->ipaddr : NULL),
  1104.                         s->ServerPort, FALSE);
  1105.           add_binding(s,s->ipaddr,s->listen,isdefault,0);
  1106.           addl_bindings(s);
  1107.         } else if(isdefault) {
  1108.           s->listen = NULL;
  1109.           add_binding(s,s->ipaddr,s->listen,isdefault,0);
  1110.           addl_bindings(s);
  1111.         } else
  1112.           s->listen = NULL;
  1113.       } else {
  1114.         isdefault = get_param_int(s->conf,"DefaultServer",FALSE);
  1115.         if(isdefault != 1)
  1116.           isdefault = 0;
  1118.         s->listen = main_server->listen;
  1119.         register_cleanup(s->listen->pool,&s->listen,
  1120.                          _server_conn_cleanup,
  1121.                          _server_conn_cleanup);
  1122.         add_binding(s,s->ipaddr,NULL,isdefault,0);
  1123.         addl_bindings(s);
  1124.       }
  1125.     }
  1126.   } else
  1127.     /* Child process -- cannot rehash, log error */
  1128.     log_pri(LOG_ERR,"received SIGHUP, cannot rehash child process");
  1129. }
  1131. void fork_server(int fd,conn_t *l,int nofork)
  1132. {
  1133.   server_rec *s,*serv = NULL;
  1134.   conn_t *conn;
  1135.   int i;
  1137. #ifndef DEBUG_NOFORK
  1138.   pid_t pid;
  1139.   sigset_t sigset;
  1140.   pool *p;
  1142.   if(!nofork) {
  1143.     pidrec_t *cpid;
  1145.     /* We block SIGCHLD to prevent a race condition if the child
  1146.      * dies before we can record it's pid.  Also block SIGTERM to
  1147.      * prevent sig_terminate() from examining the child list
  1148.      */
  1150.     sigemptyset(&sigset);
  1151.     sigaddset(&sigset,SIGTERM);
  1152.     sigaddset(&sigset,SIGCHLD);
  1153.     sigaddset(&sigset,SIGUSR1);
  1154.     sigaddset(&sigset,SIGUSR2);
  1156.     sigprocmask(SIG_BLOCK,&sigset,NULL);
  1158.     switch((pid = fork())) {
  1159.     case 0: /* child */
  1160.       master = FALSE; /* We aren't the master anymore */
  1161.       sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1162.       break;
  1163.     case -1:
  1164.       sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1165.       log_pri(LOG_ERR,"fork(): %s",strerror(errno));
  1166.       return;
  1167.     default: /* parent */
  1168.       /* The parent doesn't need the socket open */
  1169.       close(fd);
  1171.       if(!children) {
  1172.         p = make_sub_pool(permanent_pool);
  1173.         children = xaset_create(p,NULL);
  1174.       } else
  1175.         p = children->mempool;
  1177.       cpid = (pidrec_t*)pcalloc(p,sizeof(pidrec_t));
  1178.       cpid->pid = pid;
  1179.       xaset_insert(children,(xasetmember_t*)cpid);
  1180.       child_count++;
  1182.       /* Unblock the signals now as sig_child() will catch
  1183.        * an "immediate" death and remove the pid from the children list
  1184.        */
  1185.       sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1186.       return;
  1187.     }
  1188.   }
  1189. #ifdef HAVE_SETPGID
  1190.   setpgid(0,getpid());
  1191. #else
  1192. # ifdef SETPGRP_VOID
  1193.   setpgrp();
  1194. # else
  1195.    setpgrp(0,getpid());
  1196. # endif
  1197. #endif
  1199. #endif /* DEBUG_NOFORK */
  1202.   /* Child is running here */
  1203.   signal(SIGUSR1,sig_disconnect);
  1204.   signal(SIGUSR2,sig_debug);
  1205.   signal(SIGCHLD,SIG_DFL);
  1206.   signal(SIGHUP,SIG_IGN);
  1208.   /* From this point on, syslog stays open */
  1209.   /* We close it first so that the logger will pick up our
  1210.    * new pid.
  1211.    */
  1213.   block_signals();
  1214.   PRIVS_ROOT
  1216.   log_closesyslog();
  1217.   log_opensyslog(NULL);
  1219.   PRIVS_RELINQUISH
  1220.   unblock_signals();
  1222.   /* It's safe to call inet_openrw now (it might block),
  1223.    * because the parent is off answering new connections
  1224.    */
  1226.   conn = inet_openrw(permanent_pool,l,NULL,fd,
  1227.                      STDIN_FILENO,STDOUT_FILENO,TRUE);
  1229.   if(!conn) {
  1230.     log_pri(LOG_ERR,"Fatal: unable to open incoming connection: %s",
  1231.                    strerror(errno));
  1232.     exit(1);
  1233.   }
  1235.   inet_set_proto_options(permanent_pool,conn,1,1,0,0);
  1237.   serv = find_binding(conn->local_ipaddr,conn->local_port);
  1239.   /* If no server is configured to specifically handle the destination
  1240.    * address, search for the first server with DefaultServer set.
  1241.    */
  1243. #if 0
  1244.   if(!serv) {
  1245.     for(s = main_server; s; s=s->next)
  1246.       if(s->listen == l && 
  1247.          get_param_int(s->conf,"DefaultServer",FALSE) == 1) {
  1248.         serv = s;
  1249.         break;
  1250.       }
  1251.   }
  1252. #endif
  1254.   /* To conserve memory, free all other servers and associated
  1255.    * configurations
  1256.    */
  1257.   for(s = main_server; s; s=s->next)
  1258.     if(s != serv) {
  1259.       if(s->listen && s->listen != l) {
  1260. /* If our former listen socket was stdin or stdout (0 or 1),
  1261.          * inet_close() will attempt to close it, and in the process
  1262.          * close our read/write sockets for this connection.
  1263.          */
  1264.         if(s->listen->listen_fd == conn->rfd ||
  1265.            s->listen->listen_fd == conn->wfd)
  1266.           s->listen->listen_fd = -1;
  1267.         else
  1268.           inet_close(s->pool,s->listen);
  1269.       }
  1271.       if(s->listen) {
  1272.         if(s->listen->listen_fd == conn->rfd ||
  1273.            s->listen->listen_fd == conn->wfd)
  1274.              s->listen->listen_fd = -1;
  1275.       }
  1277.       xaset_remove(servers,(xasetmember_t*)s);
  1278.       destroy_pool(s->pool);
  1279.     }
  1281.   main_server = serv;
  1282.     
  1283.   session.pool = permanent_pool;
  1284.   session.c = conn;
  1285.   session.data_port = conn->remote_port - 1;
  1287.   /* Check and see if we are shutdown */
  1288.   if(shutdownp) {
  1289.     time_t now;
  1291.     time(&now);
  1292.     if(!deny || deny <= now) {
  1293.       char *reason =
  1294.           sreplace(permanent_pool,shutmsg,
  1295.                    "%s",pstrdup(permanent_pool,fmt_time(shut)),
  1296.                    "%r",pstrdup(permanent_pool,fmt_time(deny)),
  1297.                    "%d",pstrdup(permanent_pool,fmt_time(disc)),
  1298.    "%C",(session.cwd[0] ? session.cwd : "(none)"),
  1299.    "%L",main_server->ServerAddress,
  1300.    "%R",(session.c && session.c->remote_name ?
  1301.                          session.c->remote_name : "(unknown)"),
  1302.    "%T",pstrdup(permanent_pool,fmt_time(now)),
  1303.    "%U","NONE",
  1304.    "%V",main_server->ServerName,
  1305.                    NULL );
  1307.       log_auth(LOG_NOTICE,"connection refused (%s) from %s [%s]",
  1308.                reason,session.c->remote_name,
  1309.                inet_ntoa(*session.c->remote_ipaddr));
  1311.       printf("500 FTP server shut down (%s) -- please try again later.rn",
  1312.              reason); 
  1313.       fflush(stdout);
  1314.       exit(0);
  1315.     }
  1316.   }
  1318.   /* If no server is configured to handle the addr the user is
  1319.    * connected to, drop them.
  1320.    */
  1322.   if(!serv) {
  1323.     printf("500 Sorry, no server available to handle request on %s.rn",
  1324.            inet_getname(conn->pool,conn->local_ipaddr));
  1325.     fflush(stdout);
  1326.     exit(0);
  1327.   }
  1329.   if(serv->listen) {
  1330.     if(serv->listen->listen_fd == conn->rfd ||
  1331.         serv->listen->listen_fd == conn->wfd)
  1332.           serv->listen->listen_fd = -1;
  1334.     destroy_pool(serv->listen->pool);
  1335.     serv->listen = NULL;
  1336.   }
  1338.   /* Check config tree for <Limit LOGIN> directives */
  1339.   if(!login_check_limits(serv->conf,TRUE,FALSE,&i)) {
  1340.     log_pri(LOG_NOTICE,"Connection from %s [%s] denied.",
  1341.             session.c->remote_name,inet_ntoa(*session.c->remote_ipaddr));
  1342.     exit(0);
  1343.   }
  1345.   log_debug(DEBUG4,"connected - local  : %s:%d",
  1346.                     inet_ntoa(*session.c->local_ipaddr),
  1347.                     session.c->local_port);
  1348.   log_debug(DEBUG4,"connected - remote : %s:%d",
  1349.        inet_ntoa(*session.c->remote_ipaddr),
  1350.        session.c->remote_port);
  1352.   /* Use the ident protocol (RFC1413) to try to get remote ident_user
  1353.    */
  1355.   if(get_param_int(main_server->conf,"IdentLookups",FALSE) != 0)
  1356.     session.ident_user = get_ident(session.pool,conn);
  1357.   else
  1358.     session.ident_user = "UNKNOWN";
  1360.   /* Inform all the modules that we are now a child */
  1361.   init_child_modules();
  1363.   /* find class */
  1364.   session.class = (class_t *) find_class(conn->remote_ipaddr, conn->remote_name);
  1366.   /* xfer_set_data_port(conn->local_ipaddr,conn->local_port-1); */
  1367.   cmd_loop(serv,conn);
  1368. }
  1370. void disc_children()
  1371. {
  1372.   sigset_t sigset;
  1373.   pidrec_t *cp;
  1375.   if(disc && disc <= time(NULL) && children) {
  1376.     sigemptyset(&sigset);
  1377.     sigaddset(&sigset,SIGTERM);
  1378.     sigaddset(&sigset,SIGCHLD);
  1379.     sigaddset(&sigset,SIGUSR1);
  1380.     sigaddset(&sigset,SIGUSR2);
  1382.     sigprocmask(SIG_BLOCK,&sigset,NULL);
  1384.     PRIVS_ROOT
  1385.     for(cp = (pidrec_t*)children->xas_list; cp; cp=cp->next)
  1386.       kill(cp->pid,SIGUSR1);
  1387.     PRIVS_RELINQUISH
  1389.     sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1390.   }
  1391. }
  1393. void server_loop()
  1394. {
  1395.   fd_set rfd;
  1396.   conn_t *listen;
  1397.   int fd, max_fd;
  1398.   int i,err_count = 0;
  1399.   time_t last_error;
  1400.   struct timeval tv;
  1402.   set_proc_title("proftpd (accepting connections)");
  1404.   time(&last_error);
  1406.   while(1) {
  1407.     run_schedule();
  1409.     max_fd = listen_binding(&rfd);
  1411.     /* Check for ftp shutdown message file */
  1412.     switch(check_shutmsg(&shut,&deny,&disc,shutmsg,sizeof(shutmsg))) {
  1413.     case 1: if(!shutdownp) disc_children(); shutdownp = 1; break;
  1414.     case 0: shutdownp = 0; deny = disc = (time_t)0; break;
  1415.     }
  1417.     if(shutdownp) {
  1418.       tv.tv_usec = 0L;
  1419.       tv.tv_sec = 5L;
  1420.     } else {
  1421.       tv.tv_usec = 0L;
  1422.       tv.tv_sec = 30L;
  1423.     }
  1425.     i = select(max_fd + 1, &rfd, NULL, NULL,&tv);
  1427.     if(child_flag) {
  1428.       sigset_t sigset;
  1429.       pidrec_t *cp,*cpnext;
  1431.       sigemptyset(&sigset);
  1432.       sigaddset(&sigset,SIGCHLD);
  1433.       sigaddset(&sigset,SIGTERM);
  1434.       block_alarms();
  1435.       sigprocmask(SIG_BLOCK,&sigset,NULL);
  1437.       child_flag = 0;
  1438.       if(children) {
  1439.         for(cp = (pidrec_t*)children->xas_list; cp; cp=cpnext) {
  1440.           cpnext = cp->next;
  1441.           if(cp->dead)
  1442.             xaset_remove(children,(xasetmember_t*)cp);
  1443.         }
  1444.       }
  1445.       /* Don't need the pool anymore */
  1446.       if(!children->xas_list) {
  1447.         destroy_pool(children->mempool);
  1448.         children = NULL;
  1449.       }
  1451.       sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1452.       unblock_alarms();
  1453.     }
  1455.     if(i == -1) {
  1456.       time_t this_error;
  1458.       if(errno == EINTR)
  1459.         continue;
  1461.       time(&this_error);
  1462.       if((this_error - last_error) <= 5 && err_count++ > 10) {
  1463.         log_pri(LOG_ERR,"Fatal: select() failing repeatedly, shutting down.");
  1464.         exit(1);
  1465.       } else if((this_error - last_error) > 5) {
  1466.         last_error = this_error;
  1467.         err_count = 0;
  1468.       }
  1470.       log_pri(LOG_NOTICE,"select() failed in server_loop(): %s",
  1471.               strerror(errno));
  1472.     }
  1474.     if(i == 0)
  1475.       continue;
  1477.     /* fork off servers to handle each connection
  1478.      * our job is to get back to answering connections asap,
  1479.      * so leave the work of determining which server the connection
  1480.      * is for to our child.
  1481.      */
  1483.     listen = accept_binding(&rfd, &fd);
  1484.     if(listen) {
  1485.       if(ServerMaxInstances && child_count >= ServerMaxInstances) {
  1486.         log_pri(LOG_WARNING,"MaxInstances (%d) reached, new connection denied.",ServerMaxInstances);
  1487.         close(fd);
  1488.       } else
  1489.         fork_server(fd,listen,FALSE);
  1490.     }
  1491.   }
  1492. }
  1494. /* sig_rehash occurs in the master daemon when manually "kill -HUP"
  1495.  * in order to re-read configuration files, and is sent to all
  1496.  * children by the master.
  1497.  */
  1499. static RETSIGTYPE sig_rehash(int sig)
  1500. {
  1501.   schedule(main_rehash,0,NULL,NULL,NULL,NULL);
  1503.   signal(SIGHUP,sig_rehash);
  1504. }
  1506. /* sig_debug outputs some basic debugging info
  1507.  */
  1509. static RETSIGTYPE sig_debug(int sig)
  1510. {
  1511.   debug_walk_pools();
  1512. }
  1514. /* sig_disconnect is called in children when the parent daemon
  1515.  * detects that shutmsg has been created and ftp sessions should
  1516.  * be destroyed.  If a file transfer is underway, the process simply
  1517.  * dies, otherwise a function is scheduled to attempt to display
  1518.  * the shutdown reason.
  1519.  */
  1521. static RETSIGTYPE sig_disconnect(int sig)
  1522. {
  1523.   if((session.flags & SF_ANON) || (session.flags & SF_XFER))
  1524.     schedule(main_exit,0,(void*)LOG_NOTICE,
  1525.              "Parent process requested shutdown",
  1526.              (void*)0,NULL);
  1527.   else
  1528.     schedule(shutdown_exit,0,NULL,NULL,NULL,NULL);
  1530.   signal(SIGUSR1,SIG_IGN);
  1531. }
  1533. static RETSIGTYPE sig_child(int sig)
  1534. {
  1535.   sigset_t sigset;
  1536.   pid_t cpid;
  1537.   pidrec_t *cp,*cpnext;
  1539.   sigemptyset(&sigset);
  1540.   sigaddset(&sigset,SIGTERM);
  1542.   block_alarms();
  1543.   sigprocmask(SIG_BLOCK,&sigset,NULL);
  1545.   /* block SIGTERM in here, so we don't create screw with the
  1546.    * child list while modifying it.
  1547.    */
  1549.   while((cpid = waitpid(-1,NULL,WNOHANG)) > 0) {
  1550.     child_count--; child_flag = 1;
  1551.     if(children) {
  1552.       for(cp = (pidrec_t*)children->xas_list; cp; cp=cpnext) {
  1553.         cpnext = cp->next;
  1554.         if(cp->pid == cpid) {
  1555.           child_flag++;
  1556.           cp->dead = 1;
  1557.         }
  1558.       }
  1559.     }
  1560.   }
  1562.   sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1563.   unblock_alarms();
  1564.   signal(SIGCHLD,sig_child);
  1565. }
  1567. static RETSIGTYPE sig_abort(int sig)
  1568. {
  1569. #if 0
  1570.   if(abort_core)
  1571.     log_pri(LOG_NOTICE,"ProFTPD received SIGABRT signal, generating core file in %s",_prepare_core());
  1572.   else
  1573. #endif
  1574.     log_pri(LOG_NOTICE,"ProFTPD received SIGABRT signal, no core dump.");
  1575.   
  1576.   signal(SIGABRT,SIG_DFL);
  1577.   end_login_noexit();
  1578.   abort();
  1579. }  
  1581. static void _internal_abort()
  1582. {
  1583.   if(abort_core) {
  1584. #if 0
  1585.     log_pri(LOG_NOTICE,"core file dumped to %s",_prepare_core());
  1586. #endif
  1587.     signal(SIGABRT,SIG_DFL);
  1588.     end_login_noexit();
  1589.     abort();
  1590.   }
  1591. }
  1593. static RETSIGTYPE sig_terminate(int sig)
  1594. {
  1595.   pidrec_t *pid;
  1597.   if(sig == SIGTERM) {
  1598.     /* Don't log if we are a child that has been terminated */
  1599.     if(master) {
  1600.       /* Send a SIGKILL to all our children */
  1601.       if(children) {
  1602.         PRIVS_ROOT
  1603.         for(pid = (pidrec_t*)children->xas_list; pid; pid=pid->next)
  1604.           kill(pid->pid,SIGTERM);
  1605.         PRIVS_RELINQUISH
  1606.       }
  1608.       log_pri(LOG_NOTICE,"ProFTPD killed (signal %d)",sig);
  1609.     }
  1610.   } else
  1611.     log_pri(LOG_ERR,"ProFTPD terminating (signal %d)",sig);
  1613.   if(master && mpid == getpid()) {
  1614.     PRIVS_ROOT
  1615.     log_close_run();
  1616.     log_rm_run();
  1617.     PRIVS_RELINQUISH
  1618.     if(standalone)
  1619.       log_pri(LOG_NOTICE,"ProFTPD %s standalone mode SHUTDOWN",VERSION);
  1620.   }
  1622.   _internal_abort();  
  1623.   end_login(1);
  1624. }
  1626. static void install_signal_handlers()
  1627. {
  1628.   sigset_t sigset;
  1630.   /* Should the master server (only applicable in standalone mode)
  1631.    * kill off children if we receive a signal that causes termination?
  1632.    * hmmmm... Maybe this needs to be rethought, but I've done it in
  1633.    * such a way as to only kill off our children if we receive a SIGTERM,
  1634.    * meaning that the admin wants us dead (and prolly our kids too).
  1635.    */
  1637.   /* The sub-pool for the child list is created the first time we fork
  1638.    * off a child.  To conserve memory, the pool and list is destroyed
  1639.    * when our last child dies (to prevent the list from eating more and
  1640.    * more memory on long uptimes)
  1641.    */
  1643.   sigemptyset(&sigset);
  1644.   sigaddset(&sigset,SIGCHLD);
  1645.   sigaddset(&sigset,SIGINT);
  1646.   sigaddset(&sigset,SIGQUIT);
  1647.   sigaddset(&sigset,SIGILL);
  1648.   sigaddset(&sigset,SIGABRT);
  1649.   sigaddset(&sigset,SIGFPE);
  1650.   sigaddset(&sigset,SIGSEGV);
  1651.   sigaddset(&sigset,SIGALRM);
  1652.   sigaddset(&sigset,SIGTERM);
  1653. #ifdef SIGSTKFLT
  1654.   sigaddset(&sigset,SIGSTKFLT);
  1655. #endif
  1656.   sigaddset(&sigset,SIGIO);
  1657. #ifdef SIGBUS
  1658.   sigaddset(&sigset,SIGBUS);
  1659. #endif
  1660.   sigaddset(&sigset,SIGHUP);
  1661.   sigaddset(&sigset,SIGUSR2);
  1662.   
  1663.   signal(SIGCHLD,sig_child);
  1664.   signal(SIGHUP,sig_rehash);
  1665.   signal(SIGUSR2,sig_debug);
  1667. #ifndef DEBUG_NOSIG
  1668.   signal(SIGINT,sig_terminate);
  1669.   signal(SIGQUIT,sig_terminate);
  1670.   signal(SIGILL,sig_terminate);
  1671.   signal(SIGABRT,sig_abort);
  1672.   signal(SIGFPE,sig_terminate);
  1673.   signal(SIGSEGV,sig_terminate);
  1674.   signal(SIGTERM,sig_terminate);
  1675. #ifdef SIGSTKFLT
  1676.   signal(SIGSTKFLT,sig_terminate);
  1677. #endif /* SIGSTKFLT */
  1678.   signal(SIGIO,sig_terminate);
  1679. #ifdef SIGBUS
  1680.   signal(SIGBUS,sig_terminate);
  1681. #endif /* SIGBUS */
  1682. #endif /* DEBUG_NOSIG */
  1684.   signal(SIGIO,SIG_IGN);
  1685.   signal(SIGURG,SIG_IGN);
  1687.   /* In case our parent left signals blocked (as happens under some
  1688.    * poor inetd implementations)
  1689.    */
  1690.   sigprocmask(SIG_UNBLOCK,&sigset,NULL);
  1691. }
  1693. static void set_rlimits()
  1694. {
  1695.   struct rlimit rlim;
  1697.   if(getrlimit(RLIMIT_CORE,&rlim) == -1)
  1698.     log_pri(LOG_ERR,"getrlimit(): %s",strerror(errno));
  1699.   else {
  1700.     if(abort_core)
  1701.       rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY;
  1702.     else
  1703.       rlim.rlim_cur = rlim.rlim_max = 0;
  1705.     PRIVS_ROOT
  1706.     if(setrlimit(RLIMIT_CORE,&rlim) == -1) {
  1707.       PRIVS_RELINQUISH
  1708.       log_pri(LOG_ERR,"setrlimit(): %s",strerror(errno));
  1709.       return;
  1710.     }
  1711.     PRIVS_RELINQUISH
  1712.   }
  1713. }
  1715. void start_daemon()
  1716. {
  1717. #ifndef HAVE_SETSID
  1718.   int ttyfd;
  1719. #endif
  1721.   /* Fork off and have parent exit */
  1722.   switch(fork()) {
  1723.     case -1: perror("fork"); exit(1);
  1724.     case 0: break;
  1725.     default: exit(0);
  1726.   }
  1728. #ifdef HAVE_SETSID
  1729.   /* setsid() is the preferred way to disassociate from the 
  1730.    * controlling terminal
  1731.    */
  1732.   setsid();
  1733. #else
  1734.   /* Open /dev/tty to access our controlling tty (if any) */
  1735.   if( (ttyfd = open("/dev/tty",O_RDWR)) != -1)
  1736.   {
  1737.     if(ioctl(ttyfd,TIOCNOTTY,NULL) == -1) {
  1738.       perror("ioctl"); exit(1);
  1739.     }
  1741.     close(ttyfd);
  1742.   }
  1743. #endif /* HAVE_SETSID */
  1745.   /* Close the three big boys */
  1746.   close(fileno(stdin));
  1747.   close(fileno(stdout));
  1748.   close(fileno(stderr));
  1750.   /* Portable way to prevent re-acquiring a tty in the future */
  1752. #ifdef HAVE_SETPGID
  1753.   setpgid(0,getpid());
  1754. #else
  1755. # ifdef SETPGRP_VOID
  1756.   setpgrp();
  1757. # else
  1758.   setpgrp(0,getpid());
  1759. # endif
  1760. #endif
  1762.   fs_chdir("/",0);
  1763. }
  1765. void addl_bindings(server_rec *s)
  1766. {
  1767.   config_rec *c;
  1768.   conn_t *listen;
  1769.   p_in_addr_t *ipaddr;
  1771.   c = find_config(s->conf,CONF_PARAM,"Bind",FALSE);
  1772.   while(c) {
  1773.     listen = NULL;
  1775.     /* If SocketBindTight is set, we create an additional listen
  1776.      * connection for each binding.
  1777.      */
  1779.     ipaddr = inet_getaddr(s->pool,c->argv[0]);
  1780.     if(!ipaddr) {
  1781.       log_pri(LOG_NOTICE,"unable to determine IP address of `%s'.",
  1782.               c->argv[0]);
  1784.       continue;
  1785.     }
  1787.     if(SocketBindTight && s->ServerPort) {
  1788.       listen = inet_create_connection(s->pool,servers,-1,
  1789.                ipaddr,s->ServerPort,FALSE);
  1790.       add_binding(s,ipaddr,listen,0,0);
  1791.     } else
  1792.       add_binding(s,ipaddr,s->listen,0,0);
  1794.     c = find_config_next(c,c->next,CONF_PARAM,"Bind",FALSE);
  1795.   }
  1796. }
  1798. void inetd_main()
  1799. {
  1800.   server_rec *s;
  1801.   int isdefault;
  1803.   PRIVS_ROOT
  1804.   log_open_run(0,FALSE,TRUE);
  1805.   log_close_run();
  1806.   PRIVS_RELINQUISH
  1808.   main_server->listen = 
  1809.     inet_create_connection(main_server->pool,servers,STDIN_FILENO,
  1810.                            NULL,INPORT_ANY,FALSE);
  1812.   /* Fill in all the important connection info */
  1813.   if(inet_get_conn_info(main_server->listen,STDIN_FILENO) == -1) {
  1814.     log_pri(LOG_ERR,"Fatal: %s",strerror(errno));
  1815.     if(errno == ENOTSOCK)
  1816.       log_pri(LOG_ERR,"(Running from command line? "
  1817.                       "Use `ServerType standalone' in config file!)");
  1818.     exit(1);
  1819.   }
  1821.   isdefault = get_param_int(main_server->conf,"DefaultServer",FALSE);
  1822.   if(isdefault != 1)
  1823.     isdefault = 0;
  1825.   add_binding(main_server,main_server->ipaddr,main_server->listen,
  1826.                 isdefault,1);
  1827.   addl_bindings(main_server);
  1829.   /* Now attach the faked connection to all virtual servers */
  1830.   for(s = main_server->next; s; s=s->next) {
  1831.       /* Because this server is sharing the connection with the
  1832.        * main server, we need a cleanup handler to remove
  1833.        * the server's reference when the original connection's
  1834.        * pool is destroyed.
  1835.        */
  1836.       s->listen = main_server->listen;
  1837.       register_cleanup(s->listen->pool,&s->listen,
  1838.                        _server_conn_cleanup,
  1839.                        _server_conn_cleanup);
  1840.       
  1842.       isdefault = get_param_int(s->conf,"DefaultServer",FALSE);
  1843.       if(isdefault != 1)
  1844.         isdefault = 0;
  1846.       add_binding(s,s->ipaddr,s->listen,isdefault,0);
  1847.       addl_bindings(s);
  1848.   }
  1850.   /* Check our shutdown status */
  1851.   if(check_shutmsg(&shut,&deny,&disc,shutmsg,sizeof(shutmsg)) == 1)
  1852.     shutdownp = 1;
  1854.   /* Finally, call right into fork_server() to start servicing the
  1855.    * connection immediately
  1856.    */
  1857.   fork_server(STDIN_FILENO,main_server->listen,TRUE);
  1858. }
  1860. void standalone_main(int nodaemon)
  1861. {
  1862.   server_rec *s;
  1863.   int isdefault;
  1865.   standalone = 1;
  1866.   if(nodaemon) {
  1867.     log_stderr(TRUE);
  1868.     close(fileno(stdin));
  1869.     close(fileno(stdout));
  1870.   }
  1871.   else {
  1872.     log_stderr(FALSE);
  1873.     start_daemon();
  1874.   }
  1876.   mpid = getpid();
  1878.   PRIVS_ROOT
  1879.   log_open_run(mpid,TRUE,TRUE);
  1880.   log_close_run();
  1881.   PRIVS_RELINQUISH
  1883.   /* If a port is set to 0, the address/port is not bound at all */
  1885.   if(main_server->ServerPort)
  1886.     main_server->listen =
  1887.       inet_create_connection(main_server->pool,servers,-1,
  1888.                              (SocketBindTight ? main_server->ipaddr :  NULL),
  1889.                              main_server->ServerPort,FALSE);
  1890.   else
  1891.     main_server->listen = NULL;
  1893.   isdefault = get_param_int(main_server->conf,"DefaultServer",FALSE);
  1894.   if(isdefault != 1)
  1895.     isdefault = 0;
  1897.   if(main_server->ServerPort || isdefault) {
  1898.     add_binding(main_server,main_server->ipaddr,main_server->listen,
  1899.                 isdefault,1);
  1901.     addl_bindings(main_server);
  1902.   }
  1904.   for(s = main_server->next; s; s=s->next)
  1905.     if(s->ServerPort != main_server->ServerPort || SocketBindTight ||
  1906.        !main_server->listen) {
  1908.       isdefault = get_param_int(s->conf,"DefaultServer",FALSE);
  1909.       if(isdefault != 1)
  1910.         isdefault = 0;
  1912.       if(s->ServerPort) {
  1914.         s->listen = inet_create_connection(
  1915.                       s->pool,servers,-1,
  1916.          (SocketBindTight ? s->ipaddr : NULL),
  1917.                       s->ServerPort,FALSE);        
  1918.         add_binding(s,s->ipaddr,s->listen,isdefault,0);
  1919.         addl_bindings(s);
  1920.       } else if(isdefault) {
  1921.         s->listen = NULL;
  1922.         add_binding(s,s->ipaddr,s->listen,isdefault,0);
  1923.         addl_bindings(s);
  1924.       } else
  1925.         s->listen = NULL;
  1926.     } else {
  1927.       /* Because this server is sharing the connection with the
  1928.        * main server, we need a cleanup handler to remove
  1929.        * the server's reference when the original connection's
  1930.        * pool is destroyed.
  1931.        */
  1932.       isdefault = get_param_int(s->conf,"DefaultServer",FALSE);
  1933.       if(isdefault != 1)
  1934.         isdefault = 0;
  1935.        
  1936.       s->listen = main_server->listen;
  1937.       register_cleanup(s->listen->pool,&s->listen,
  1938.                        _server_conn_cleanup,
  1939.                        _server_conn_cleanup);
  1940.       add_binding(s,s->ipaddr,NULL,isdefault,0);
  1941.       addl_bindings(s);
  1942.     }
  1944.   log_pri(LOG_NOTICE,"ProFTPD %s standalone mode STARTUP",VERSION);
  1945.   server_loop();
  1946. }
  1948. extern char *optarg;
  1949. extern int optind,opterr,optopt;
  1951. struct option opts[] = {
  1952.   { "nodaemon", 0, NULL, 'n' },
  1953.   { "debug", 1, NULL, 'd' },
  1954.   { "config", 1, NULL, 'c' },
  1955.   { "persistent",1,NULL, 'p' },
  1956.   { "list",     0, NULL, 'l' },
  1957.   { "version",  0, NULL, 'v' },
  1958. /*
  1959.   { "core",     0, NULL, 'o' },
  1960. */
  1961.   { "help", 0, NULL, 'h' },
  1962.   { NULL, 0, NULL,  0  }
  1963. };
  1965. struct option_help {
  1966.   char *long_opt,*short_opt,*desc;
  1967. } opts_help[] = {
  1968.   { "--help","-h","display proftpd usage"},
  1969.   { "--nodaemon","-n","disable background daemon mode (all output goes to tty, instead of syslog)" },
  1970.   { "--debug","-d [level]","set debugging level (0-5, 5 == most debugging)" },
  1971.   { "--config","-c [config-file]","specify alternate configuration file" },
  1972.   { "--persistent","-p [0|1]","enable/disable default persistent passwd support" },
  1973.   { "--list","-l","list all compiled-in modules" },
  1974. /*
  1975.   { "--core","-o","enable core dump for profiling/debugging on serious errors"},
  1976. */
  1977.   { "--version","-v","print version number and exit" },
  1978.   { NULL,NULL,NULL }
  1979. };
  1982. void show_usage(int exit_code)
  1983. {
  1984.   struct option_help *h;
  1986.   printf("usage: proftpd [options]n");
  1987.   for(h = opts_help; h->long_opt; h++) {
  1988.     printf("  %s,%sn",h->long_opt,h->short_opt);
  1989.     printf("    %sn",h->desc);
  1990.   }
  1991.   exit(exit_code);
  1992. }
  1994. int main(int argc, char **argv, char **envp)
  1995. {
  1996.   int daemon_uid,daemon_gid,socketp;
  1997.   int _umask = 0,nodaemon = 0,c;
  1998.   struct sockaddr peer;
  2000. #ifdef DEBUG_MEMORY
  2001.   int logfd;
  2002.   extern int EF_PROTECT_BELOW;
  2003.   extern int EF_PROTECT_FREE;
  2004.   extern int EF_ALIGNMENT;
  2006.   EF_PROTECT_BELOW = 1;/* */
  2007.   EF_PROTECT_FREE = 1; /* */
  2008.   EF_ALIGNMENT = 0; /* */
  2010.   /* Redirect stderr to somewhere appropriate.
  2011.    * Ideally, this would be syslog, but alas...
  2012.    */
  2013.   if((logfd = open(RUN_DIR "/proftpd-memory.log",
  2014.    O_WRONLY | O_CREAT | O_APPEND, 0644))< 0) {
  2015. log_pri(LOG_ERR, "Error opening error logfile: %s", strerror(errno));
  2016. exit(1);
  2017.   }
  2019.   close(fileno(stderr));
  2020.   if(dup2(logfd, fileno(stderr)) == -1) {
  2021. log_pri(LOG_ERR, "Error converting standard error to a logfile: %s",
  2022. strerror(errno));
  2023. exit(1);
  2024.   }
  2025.   close(logfd);
  2026. #endif /* DEBUG_MEMORY */
  2028. #ifdef HAVE_SET_AUTH_PARAMETERS
  2029.   (void) set_auth_parameters(argc, argv);
  2030. #endif
  2032.   bzero(&session,sizeof(session));
  2034.   /* Initialize stuff for set_proc_title.
  2035.    */
  2036.   init_set_proc_title(argc, argv, envp);
  2038.   /* getpeername() fails if the fd isn't a socket */
  2039.   socketp = sizeof(peer);
  2040.   if(getpeername(fileno(stdin),&peer,&socketp) != -1) {
  2041.     log_stderr(FALSE);
  2042.     socketp = TRUE;
  2043.   } else
  2044.     socketp = FALSE;
  2046.   /* Open the syslog */
  2047.   log_opensyslog(NULL);
  2049.   /* Command line options supported:
  2050.    * -n,--nodaemon standalone server doesn't background itself,
  2051.    *                    all logging dumped to stderr
  2052.    *
  2053.    * -d n,--debug n set debug level
  2054.    *
  2055.    * -c, --config path  set the configuration path
  2056.    *
  2057.    * -v, --version      report version number
  2058.    */
  2060.   opterr = 0;
  2061.   while((c = getopt_long(argc,argv,"nd:c:p:lhv",opts,NULL)) != -1) {
  2062.     switch(c) {
  2063.     case 'n': 
  2064.       nodaemon++; break;
  2065.     case 'd': 
  2066.       if(!optarg) {
  2067.         log_pri(LOG_ERR,"Fatal: -d requires debugging level argument.");
  2068.         exit(1);
  2069.       }
  2070.       log_setdebuglevel(atoi(optarg));
  2071.       break;
  2072.     case 'c':
  2073.       if(!optarg) {
  2074.         log_pri(LOG_ERR,"Fatal: -c requires configuration path argument.");
  2075.         exit(1);
  2076.       }
  2077.       config_filename = strdup(optarg);
  2078.       break;
  2079.     case 'l':
  2080.       list_modules();
  2081.       exit(0);
  2082.     case 'p':
  2083.     {
  2084.       extern int persistent;
  2086.       if(!optarg || ((persistent = atoi(optarg)) != 1 && persistent != 0)) {
  2087.         log_pri(LOG_ERR,"Fatal: -p requires boolean (0|1) argument.");
  2088.         exit(1);
  2089.       }
  2091.       break;
  2092.     }
  2093.     /*
  2094.     case 'o':
  2095.       abort_core++;
  2096.       break;
  2097.     */
  2098.     case 'v':
  2099.       log_pri(LOG_NOTICE,"ProFTPD Version " VERSION);
  2100.       exit(0);
  2101.     case 'h':
  2102.       show_usage(0);
  2103.     case '?':
  2104.       log_pri(LOG_ERR,"Unknown option: %c",(char)optopt);
  2105.       show_usage(1);
  2106.     }
  2107.   }
  2108.  
  2109.   /* Initialize sub-systems */
  2110.   init_alloc();
  2111.   init_log();
  2112.   init_inet();
  2113.   init_io();
  2114.   init_fs();
  2115.   init_config();
  2116.   init_modules();
  2118.   init_conf_stacks();
  2119.   if(parse_config_file(config_filename) == -1) {
  2120.     log_pri(LOG_ERR,"Fatal: unable to read configuration file '%s'.",
  2121.             config_filename);
  2122.     exit(1);
  2123.   }
  2125.   free_conf_stacks();
  2127.   fixup_servers();
  2129.   /* After configuration is complete, make sure that passwd, group
  2130.    * aren't held open (unnecessary fds for master daemon)
  2131.    */
  2133.   endpwent();
  2134.   endgrent();
  2136.   /* Security */
  2137.   daemon_uid = get_param_int(main_server->conf,"User",FALSE);
  2138.   if(daemon_uid == -1)
  2139.     daemon_uid = 0;
  2140.   daemon_gid = get_param_int(main_server->conf,"Group",FALSE);
  2141.   if(daemon_gid == -1)
  2142.     daemon_gid = 0;
  2144.   if(daemon_uid)
  2145.     initgroups((const char*)get_param_ptr(main_server->conf,"UserName",
  2146.                   FALSE),daemon_gid);
  2147.   
  2148.    if((_umask = get_param_int(main_server->conf,"Umask",FALSE)) == -1)
  2149.     _umask = 0022;
  2151.   umask(_umask);
  2153.   /* Give up root and save our uid/gid for later use (if supported)
  2154.    * If we aren't currently root, PRIVS_SETUP will get rid of setuid
  2155.    * granted root and prevent further uid switching from being attempted.
  2156.    */
  2158.   PRIVS_SETUP(daemon_uid,daemon_gid)
  2160.   /* Install a signal handlers/abort handler */
  2161.   install_signal_handlers();
  2162.   set_rlimits();
  2164.   switch(ServerType) {
  2165.   case SERVER_STANDALONE: standalone_main(nodaemon);
  2166.   case SERVER_INETD:      inetd_main();
  2167.   }
  2169.   return 0;
  2170. }