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

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

Ftp客户端

开发平台：

Unix_Linux

mod_core.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.  * Core FTPD module
  23.  * $Id: mod_core.c,v 1.16 1999/10/01 07:57:31 macgyver Exp $
  24.  *
  25.  * 11/5/98 Habeeb J. Dihu aka MacGyver (macgyver@tos.net): added
  26.  *  wu-ftpd style CDPath support.
  27.  */
  29. #include "conf.h"
  31. #include "privs.h"
  33. #include <ctype.h>
  35. #ifdef HAVE_REGEX_H
  36. #include <regex.h>
  37. #endif
  39. /* This is declared static to this module because it's not needed,
  40.  * except for the HELP command.
  41.  */
  43. static struct {
  44.   char *cmd;
  45.   char *syntax;
  46.   int implemented;
  47. } _help[] = {
  48.   { C_USER, "<sp> username", TRUE },
  49.   { C_PASS, "<sp> password", TRUE },
  50.   { C_ACCT, "is not implemented", FALSE },
  51.   { C_CWD,  "<sp> pathname", TRUE },
  52.   { C_XCWD, "<sp> pathname", TRUE },
  53.   { C_CDUP, "(up one directory)", TRUE },
  54.   { C_XCUP, "(up one directory)", TRUE },
  55.   { C_SMNT, "is not implemented", FALSE },
  56.   { C_QUIT, "(close control connection)", TRUE },
  57.   { C_REIN, "is not implemented", FALSE },
  58.   { C_PORT, "<sp> h1,h2,h3,h4,p1,p2", TRUE },
  59.   { C_PASV, "(returns address/port)", TRUE },
  60.   { C_TYPE, "<sp> type-code (A or I)", TRUE },
  61.   { C_STRU, "is not implemented", FALSE },
  62.   { C_MODE, "is not implemented (always S)", FALSE },
  63.   { C_RETR, "<sp> pathname", TRUE },
  64.   { C_STOR, "<sp> pathname", TRUE },
  65.   { C_STOU, "is not implemented", FALSE },
  66.   { C_APPE, "<sp> pathname", TRUE },
  67.   { C_ALLO, "is not implemented", FALSE },
  68.   { C_REST, "<sp> byte-count", TRUE },
  69.   { C_RNFR, "<sp> pathname", TRUE },
  70.   { C_RNTO, "<sp> pathname", TRUE },
  71.   { C_ABOR, "(abort current operation)", TRUE },
  72.   { C_DELE, "<sp> pathname", TRUE },
  73.   { C_MDTM, "<sp> pathname", TRUE },
  74.   { C_RMD,  "<sp> pathname", TRUE },
  75.   { C_XRMD, "<sp> pathname", TRUE },
  76.   { C_MKD,  "<sp> pathname", TRUE },
  77.   { C_XMKD, "<sp> pathname", TRUE },
  78.   { C_PWD,  "(returns current working directory)", TRUE },
  79.   { C_XPWD, "(returns current working directory)", TRUE },
  80.   { C_SIZE, "<sp> pathname", TRUE },
  81.   { C_LIST, "[<sp> pathname]", TRUE },
  82.   { C_NLST, "[<sp> (pathname)]", TRUE },
  83.   { C_SITE, "<sp> string", TRUE },
  84.   { C_SYST, "(returns system type)", TRUE },
  85.   { C_STAT, "[<sp> pathname]", TRUE },
  86.   { C_HELP, "[<sp> command]", TRUE },
  87.   { C_NOOP, "(no operation)", TRUE },
  88.   { NULL,   NULL,           FALSE }
  89. };
  91. extern module site_module;
  92. extern xaset_t *servers;
  94. /* from mod_site */
  95. extern modret_t *site_dispatch(cmd_rec*);
  97. MODRET set_servername(cmd_rec *cmd)
  98. {
  99.   server_rec *s = cmd->server;
  101.   CHECK_ARGS(cmd,1);
  102.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  104.   s->ServerName = pstrdup(s->pool,cmd->argv[1]);
  105.   return HANDLED(cmd);
  106. }
  108. MODRET set_servertype(cmd_rec *cmd)
  109. {
  110.   CHECK_ARGS(cmd,1);
  111.   CHECK_CONF(cmd,CONF_ROOT);
  113.   if(!strcasecmp(cmd->argv[1],"inetd"))
  114.     ServerType = SERVER_INETD;
  115.   else if(!strcasecmp(cmd->argv[1],"standalone"))
  116.     ServerType = SERVER_STANDALONE;
  117.   else
  118.     CONF_ERROR(cmd,"type must be either 'inetd' or 'standalone'.");
  119.   return HANDLED(cmd);
  120. }
  122. MODRET add_transferlog(cmd_rec *cmd)
  123. {
  124.   CHECK_ARGS(cmd,1);
  125.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  127.   add_config_param_str("TransferLog",1,(void*)cmd->argv[1]);
  129.   return HANDLED(cmd);
  130. }
  132. MODRET set_wtmplog(cmd_rec *cmd)
  133. {
  134.   int b;
  136.   CHECK_ARGS(cmd,1);
  137.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  139.   if(strcasecmp(cmd->argv[1],"NONE") == 0)
  140.     b = 0;
  141.   else
  142.     b = get_boolean(cmd,1);
  144.   if(b != -1)
  145.     add_config_param("WtmpLog",1,(void*)b);
  147.   return HANDLED(cmd);
  148. }
  150. MODRET add_bind(cmd_rec *cmd)
  151. {
  152.   CHECK_ARGS(cmd,1);
  153.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  155.   add_config_param_str("Bind",1,(void*)cmd->argv[1]);
  157.   return HANDLED(cmd);
  158. }
  160. MODRET set_serveradmin(cmd_rec *cmd)
  161. {
  162.   server_rec *s = cmd->server;
  164.   CHECK_ARGS(cmd,1);
  165.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  167.   s->ServerAdmin = pstrdup(s->pool,cmd->argv[1]);
  169.   return HANDLED(cmd);
  170. }
  172. MODRET set_usereversedns(cmd_rec *cmd)
  173. {
  174.   int b;
  176.   CHECK_ARGS(cmd,1);
  177.   CHECK_CONF(cmd,CONF_ROOT);
  179.   if((b = get_boolean(cmd,1)) == -1)
  180.     CONF_ERROR(cmd,"expected boolean argument.");
  182.   ServerUseReverseDNS = b;
  184.   return HANDLED(cmd);
  185. }
  187. MODRET set_scoreboardpath(cmd_rec *cmd)
  188. {
  189.   CHECK_ARGS(cmd,1);
  190.   CHECK_CONF(cmd,CONF_ROOT);
  192.   log_run_setpath(cmd->argv[1]);
  194.   return HANDLED(cmd);
  195. }
  197. MODRET set_serverport(cmd_rec *cmd)
  198. {
  199.   server_rec *s = cmd->server;
  200.   int port;
  202.   CHECK_ARGS(cmd,1);
  203.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  205.   port = atoi(cmd->argv[1]);
  206.   if(port < 0 || port > 65535)
  207.     CONF_ERROR(cmd,"value must be between 0 and 65535");
  209.   s->ServerPort = port;
  210.   return HANDLED(cmd);
  211. }
  213. MODRET set_deferwelcome(cmd_rec *cmd)
  214. {
  215.   int b;
  217.   CHECK_ARGS(cmd,1);
  218.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  220.   if((b = get_boolean(cmd,1)) == -1)
  221.     CONF_ERROR(cmd,"expected boolean argument.");
  223.   add_config_param("DeferWelcome",1,(void*)b);
  225.   return HANDLED(cmd);
  226. }
  228. MODRET set_serverident(cmd_rec *cmd)
  229. {
  230.   int b;
  231.   config_rec *c;
  232.   
  233.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  235.   if(cmd->argc < 2 || cmd->argc > 3)
  236.     CONF_ERROR(cmd,"invalid number of arguments");
  237.   
  238.   if((b = get_boolean(cmd,1)) == -1)
  239.     CONF_ERROR(cmd,"expected boolean argument.");
  241.   if(b && cmd->argc == 3) {
  242.     c = add_config_param("ServerIdent",2,(void*)!b,NULL);
  243.     c->argv[1] = pstrdup(permanent_pool,cmd->argv[2]);
  244.   } else
  245.     add_config_param("ServerIdent",1,(void*)!b);
  247.   return HANDLED(cmd);
  248. }
  250. MODRET set_defaultserver(cmd_rec *cmd)
  251. {
  252.   int b;
  253.   server_rec *s;
  255.   CHECK_ARGS(cmd,1);
  256.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  258.   if((b = get_boolean(cmd,1)) == -1)
  259.     CONF_ERROR(cmd,"expected boolean argument.");
  261.   if(!b)
  262.     return HANDLED(cmd);
  264.   /* DefaultServer is not allowed if already set somewhere */
  265.   for(s = (server_rec*)servers->xas_list; s; s=s->next)
  266.     if(find_config(s->conf,CONF_PARAM,"DefaultServer",FALSE)) {
  267.       CONF_ERROR(cmd,"DefaultServer has already been set.");
  268.     }
  270.   add_config_param("DefaultServer",1,(void*)b);
  271.   return HANDLED(cmd);
  272. }
  274. MODRET set_maxinstances(cmd_rec *cmd)
  275. {
  276.   int max;
  277.   char *endp;
  279.   CHECK_ARGS(cmd,1);
  280.   CHECK_CONF(cmd,CONF_ROOT);
  282.   if(!strcasecmp(cmd->argv[1],"none"))
  283.     max = 0;
  284.   else {
  285.     max = (int)strtol(cmd->argv[1],&endp,10);
  287.     if((endp && *endp) || max < 1)
  288.       CONF_ERROR(cmd,"argument must be 'none' or a number greater than 0.");
  289.   }
  291.   ServerMaxInstances = max;
  292.   return HANDLED(cmd);
  293. }
  295. MODRET _set_timeout(int *v, cmd_rec *cmd)
  296. {
  297.   int timeout;
  298.   char *endp;
  300.   CHECK_ARGS(cmd,1);
  301.   CHECK_CONF(cmd,CONF_ROOT);
  303.   timeout = (int)strtol(cmd->argv[1],&endp,10);
  305.   if((endp && *endp) || timeout < 0 || timeout > 65535)
  306.     CONF_ERROR(cmd,"timeout values must be between 0 and 65535");
  308.   *v = timeout;
  309.   return HANDLED(cmd);
  310. }
  312. MODRET set_maxclients(cmd_rec *cmd)
  313. {
  314.   int max;
  315.   char *endp;
  316.   config_rec *c;
  318.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  320.   if(cmd->argc < 2 || cmd->argc > 3)
  321.     CONF_ERROR(cmd,"invalid number of arguments");
  323.   if(!strcasecmp(cmd->argv[1],"none"))
  324.     max = -1;
  325.   else {
  326.     max = (int)strtol(cmd->argv[1],&endp,10);
  328.     if((endp && *endp) || max < 1) 
  329.       CONF_ERROR(cmd,"argument must be 'none' or a number greater than 0.");
  330.   }
  332.   if(cmd->argc == 3) {
  333.     c = add_config_param("MaxClients",2,(void*)max,NULL);
  334.     c->argv[1] = pstrdup(permanent_pool,cmd->argv[2]);   
  335.   } else
  336.     add_config_param("MaxClients",1,(void*)max);
  338.   return HANDLED(cmd);
  339. }
  341. MODRET set_maxhostclients(cmd_rec *cmd)
  342. {
  343.   int max;
  344.   char *endp;
  345.   config_rec *c;
  347.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  349.   if(cmd->argc < 2 || cmd->argc > 3)
  350.     CONF_ERROR(cmd,"invalid number of arguments");
  352.   if(!strcasecmp(cmd->argv[1],"none"))
  353.     max = -1;
  354.   else {
  355.     max = (int)strtol(cmd->argv[1],&endp,10);
  357.     if((endp && *endp) || max < 1)
  358.       CONF_ERROR(cmd,"argument must be 'none' or a number greater than 0.");
  359.   }
  361.   if(cmd->argc == 3) {
  362.     c = add_config_param("MaxClientsPerHost",2,(void*)max,NULL);
  363.     c->argv[1] = pstrdup(c->pool,cmd->argv[2]);   
  364.   } else
  365.     add_config_param("MaxClientsPerHost",1,(void*)max);
  367.   return HANDLED(cmd);
  368. }
  370. MODRET set_maxloginattempts(cmd_rec *cmd)
  371. {
  372.   int max;
  373.   char *endp;
  375.   CHECK_ARGS(cmd,1);
  376.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  378.   if(!strcasecmp(cmd->argv[1],"none"))
  379.     max = 0;
  380.   else {
  381.     max = (int)strtol(cmd->argv[1],&endp,10);
  383.     if((endp && *endp) || max < 1)
  384.       CONF_ERROR(cmd,"argument must be 'none' or a number greater than 0.");
  385.   }
  387.   add_config_param("MaxLoginAttempts",1,(void*)max);
  388.   return HANDLED(cmd);
  389. }
  391. MODRET set_useftpusers(cmd_rec *cmd)
  392. {
  393.   config_rec *c;
  395.   CHECK_ARGS(cmd,1);
  396.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  398.   c = add_config_param("UseFtpUsers",1,(void*)get_boolean(cmd,1));
  400.   c->flags |= CF_MERGEDOWN;
  401.   return HANDLED(cmd);
  402. }
  404. MODRET set_timeoutlogin(cmd_rec *cmd)
  405. {
  406.   return _set_timeout(&TimeoutLogin,cmd);
  407. }
  409. MODRET set_timeoutidle(cmd_rec *cmd)
  410. {
  411.   return _set_timeout(&TimeoutIdle,cmd);
  412. }
  414. MODRET set_timeoutnoxfer(cmd_rec *cmd)
  415. {
  416.   return _set_timeout(&TimeoutNoXfer,cmd);
  417. }
  419. MODRET set_timeoutstalled(cmd_rec *cmd)
  420. {
  421.   return _set_timeout(&TimeoutStalled,cmd);
  422. }
  424. MODRET set_socketbindtight(cmd_rec *cmd)
  425. {
  426.   CHECK_ARGS(cmd,1);
  427.   CHECK_CONF(cmd,CONF_ROOT);
  429.   SocketBindTight = get_boolean(cmd,1);
  430.   return HANDLED(cmd);  
  431. }
  433. MODRET set_multilinerfc2228(cmd_rec *cmd)
  434. {
  435.   CHECK_ARGS(cmd,1);
  436.   CHECK_CONF(cmd,CONF_ROOT);
  438.   MultilineRFC2228 = get_boolean(cmd,1);
  439.   return HANDLED(cmd);
  440. }
  442. MODRET set_identlookups(cmd_rec *cmd)
  443. {
  444.   CHECK_ARGS(cmd,1);
  445.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  447.   add_config_param("IdentLookups",1,get_boolean(cmd,1));
  448.   return HANDLED(cmd);
  449. }
  451. MODRET set_tcpbacklog(cmd_rec *cmd)
  452. {
  453.   int backlog;
  455.   CHECK_ARGS(cmd,1);
  456.   CHECK_CONF(cmd,CONF_ROOT);
  458.   backlog = atoi(cmd->argv[1]);
  460.   if(backlog < 1 || backlog > 255)
  461.     CONF_ERROR(cmd,"parameter must be a number between 1 and 255.");
  463.   tcpBackLog = backlog;
  464.   return HANDLED(cmd);
  465. }
  467. MODRET set_tcpreceivewindow(cmd_rec *cmd)
  468. {
  469.   int rwin;
  471.   CHECK_ARGS(cmd,1);
  472.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  474.   rwin = atoi(cmd->argv[1]);
  476.   if(rwin < 1024)
  477.     CONF_ERROR(cmd,"parameter must be number equal to or greater than 1024.");
  479.   cmd->server->tcp_rwin = rwin;
  480.   cmd->server->tcp_rwin_override = 1;
  481.   return HANDLED(cmd);
  482. }
  484. MODRET set_tcpsendwindow(cmd_rec *cmd)
  485. {
  486.   int swin;
  488.   CHECK_ARGS(cmd,1);
  489.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  491.   swin = atoi(cmd->argv[1]);
  493.   if(swin < 1024)
  494.     CONF_ERROR(cmd,"parameter must be number equal to or greater than 1024.");
  496.   cmd->server->tcp_swin = swin;
  497.   cmd->server->tcp_swin_override = 1;
  498.   return HANDLED(cmd);
  499. }
  501. MODRET set_tcpnodelay(cmd_rec *cmd)
  502. {
  503.   CHECK_ARGS(cmd,1);
  504.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  506.   add_config_param("tcpNoDelay",1,get_boolean(cmd,1));
  507.   return HANDLED(cmd);
  508. }
  510. MODRET set_user(cmd_rec *cmd)
  511. {
  512.   struct passwd *pw = NULL;
  514.   CHECK_ARGS(cmd,1);
  515.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  517.   /* 1.1.7, no longer force user/group lookup inside <Anonymous>
  518.    * it's now defered until authentication occurs.
  519.    */
  521.   if(!cmd->config || cmd->config->config_type != CONF_ANON) {
  522.     if((pw = auth_getpwnam(cmd->tmp_pool,cmd->argv[1])) == NULL) {
  523.       auth_endpwent(cmd->tmp_pool);
  524.       CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"Unknown user '",
  525.                              cmd->argv[1],"'.",NULL));
  526.     }
  527.   }
  529.   /* The extra cast is required to avoid compiler warning */
  531.   if(pw) {
  532.     add_config_param("User",1,(void*)((int)pw->pw_uid));
  533.     /* We don't need extra fds sitting around open */
  534.     auth_endpwent(cmd->tmp_pool);
  535.   }
  537.   add_config_param_str("UserName",1,(void*)cmd->argv[1]);
  538.   return HANDLED(cmd);
  539. }
  541. MODRET set_group(cmd_rec *cmd)
  542. {
  543.   struct group *grp = NULL;
  545.   CHECK_ARGS(cmd,1);
  546.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  548.   if(!cmd->config || cmd->config->config_type != CONF_ANON) {
  549.     if((grp = auth_getgrnam(cmd->tmp_pool,cmd->argv[1])) == NULL) {
  550.       auth_endgrent(cmd->tmp_pool);
  551.       CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"Unknown group '",
  552.                              cmd->argv[1],"'.",NULL));
  553.     }
  554.   }
  556.   /* The extra cast is needed to avoid compiler warning */
  558.   if(grp) {
  559.     add_config_param("Group",1,(void*)((int)grp->gr_gid));
  560.     auth_endgrent(cmd->tmp_pool);
  561.   }
  562.   add_config_param_str("GroupName",1,(void*)cmd->argv[1]);
  564.   return HANDLED(cmd);
  565. }
  567. MODRET add_userpassword(cmd_rec *cmd)
  568. {
  569.   CHECK_ARGS(cmd,2);
  570.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  572.   add_config_param_str("UserPassword",2,cmd->argv[1],cmd->argv[2]);
  573.   return HANDLED(cmd);
  574. }
  576. MODRET add_grouppassword(cmd_rec *cmd)
  577. {
  578.   CHECK_ARGS(cmd,2);
  579.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  581.   add_config_param_str("GroupPassword",2,cmd->argv[1],cmd->argv[2]);
  582.   return HANDLED(cmd);
  583. }
  585. MODRET set_accessgrantmsg(cmd_rec *cmd)
  586. {
  587.   CHECK_ARGS(cmd,1);
  588.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  590.   add_config_param_str("AccessGrantMsg",1,cmd->argv[1]);
  591.   return HANDLED(cmd);
  592. }
  594. MODRET set_umask(cmd_rec *cmd)
  595. {
  596.   config_rec *c;
  597.   char *endp;
  598.   int _umask;
  600.   CHECK_ARGS(cmd,1);
  601.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_DIR|CONF_ANON|CONF_GLOBAL);
  603.   _umask = strtol(cmd->argv[1],&endp,8);
  605.   if(endp && *endp)
  606.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"'",cmd->argv[1],"' is not "
  607.                            "a valid umask.",NULL));
  609.   c = add_config_param("Umask",1,(void*)_umask);
  610.   c->flags |= CF_MERGEDOWN;
  611.   return HANDLED(cmd);
  612. }
  614. MODRET set_requirevalidshell(cmd_rec *cmd)
  615. {
  616.   config_rec *c;
  618.   CHECK_ARGS(cmd,1);
  619.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  621.   c = add_config_param("RequireValidShell",1,get_boolean(cmd,1));
  622.   c->flags |= CF_MERGEDOWN;
  623.   return HANDLED(cmd);
  624. }
  626. MODRET set_syslogfacility(cmd_rec *cmd)
  627. {
  628.   int i;
  629.   struct {
  630.     char *name;
  631.     int facility;
  632.   } factable[] = {
  633.   { "AUTH", LOG_AUTHPRIV },
  634.   { "AUTHPRIV", LOG_AUTHPRIV },
  635. #ifdef HAVE_LOG_FTP
  636.   { "FTP", LOG_FTP },
  637. #endif
  638. #ifdef HAVE_LOG_CRON
  639.   { "CRON", LOG_CRON },
  640. #endif  
  641.   { "DAEMON", LOG_DAEMON },
  642.   { "KERN", LOG_KERN },
  643.   { "LOCAL0", LOG_LOCAL0 },
  644.   { "LOCAL1", LOG_LOCAL1 },
  645.   { "LOCAL2", LOG_LOCAL2 },
  646.   { "LOCAL3", LOG_LOCAL3 },
  647.   { "LOCAL4", LOG_LOCAL4 },
  648.   { "LOCAL5", LOG_LOCAL5 },
  649.   { "LOCAL6", LOG_LOCAL6 },
  650.   { "LOCAL7", LOG_LOCAL7 },
  651.   { "LPR", LOG_LPR },
  652.   { "MAIL", LOG_MAIL },
  653.   { "NEWS", LOG_NEWS },
  654.   { "USER", LOG_USER },
  655.   { "UUCP", LOG_UUCP },
  656.   { NULL, 0 } };
  658.   CHECK_ARGS(cmd,1);
  659.   CHECK_CONF(cmd,CONF_ROOT);
  661.   for(i = 0; factable[i].name; i++) {
  662.     if(!strcasecmp(cmd->argv[1],factable[i].name)) {
  663.       log_closesyslog();
  664.       log_setfacility(factable[i].facility);
  666.       block_signals();
  667.       PRIVS_ROOT
  668. switch(log_opensyslog(NULL)) {
  669. case -2:
  670.   PRIVS_RELINQUISH
  671.   unblock_signals();
  672.   CONF_ERROR(cmd, "you are attempting to log to a world writeable directory");
  673.   break;
  674.   
  675. case -1:
  676.   PRIVS_RELINQUISH
  677.   unblock_signals();
  678.   CONF_ERROR(cmd, "unable to open syslog");
  679.   break;
  680.   
  681. default:
  682.   break;
  683. }
  684.       PRIVS_RELINQUISH
  685.       unblock_signals();
  687.       return HANDLED(cmd);
  688.     }
  689.   }
  691.   CONF_ERROR(cmd, "argument must be a valid syslog facility");
  692. }
  694. MODRET set_showsymlinks(cmd_rec *cmd)
  695. {
  696.   config_rec *c;
  698.   CHECK_ARGS(cmd,1);
  699.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  701.   c = add_config_param("ShowSymlinks",1,get_boolean(cmd,1));
  702.   c->flags |= CF_MERGEDOWN;
  703.   return HANDLED(cmd);
  704. }
  706. MODRET set_regex(cmd_rec *cmd, char *param, char *type) {
  707. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  708.   regex_t *preg;
  709.   config_rec *c;
  710.   int ret;
  711.   
  712.   CHECK_ARGS(cmd, 1);
  713.   CHECK_CONF(cmd, CONF_ROOT | CONF_VIRTUAL | CONF_ANON | CONF_GLOBAL);
  714.   
  715.   log_debug(DEBUG4,"Compiling %s regex '%s'", type, cmd->argv[1]);
  716.   preg = calloc(1, sizeof(regex_t));
  717.   log_debug(DEBUG4,"Allocated %s regex at location %p", type, preg);
  718.   
  719.   if((ret = regcomp(preg, cmd->argv[1], REG_EXTENDED | REG_NOSUB)) != 0) {
  720.     char errmsg[200];
  722.     regerror(ret, preg, errmsg, 200);
  723.     regfree(preg);
  724.     
  725.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"'",cmd->argv[1],
  726.    "' failed regex compilation: ",errmsg,NULL));
  727.   }
  728.   
  729.   c = add_config_param(param, 1, preg);
  730.   c->flags |= CF_MERGEDOWN;
  731.   return HANDLED(cmd);
  733. #else /* no regular expression support at the moment */
  734.   CONF_ERROR(cmd, "The ", param, " directive cannot be used on this system, "
  735.      "as you do not have POSIX compliant regex support.");
  736. #endif
  737. }
  739. MODRET set_allowfilter(cmd_rec *cmd) {
  740.   return set_regex(cmd, "AllowFilter", "allow");
  741. }
  743. MODRET set_denyfilter(cmd_rec *cmd) {
  744.   return set_regex(cmd, "DenyFilter", "deny");
  745. }
  747. MODRET set_pathallowfilter(cmd_rec *cmd) {
  748.   return set_regex(cmd, "PathAllowFilter", "allow");
  749. }
  751. MODRET set_pathdenyfilter(cmd_rec *cmd) {
  752.   return set_regex(cmd, "PathDenyFilter", "deny");
  753. }
  755. MODRET set_allowforeignaddress(cmd_rec *cmd)
  756. {
  757.   int b;
  759.   CHECK_ARGS(cmd,1);
  760.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  762.   if((b = get_boolean(cmd,1)) == -1)
  763.     CONF_ERROR(cmd,"expected boolean argument.");
  765.   add_config_param("AllowForeignAddress",1,(void*)b);
  767.   return HANDLED(cmd);
  768. }
  770. MODRET set_commandbuffersize(cmd_rec *cmd)
  771. {
  772.   int size;
  774.   CHECK_ARGS(cmd, 1);
  775.   CHECK_CONF(cmd, CONF_ROOT | CONF_VIRTUAL | CONF_GLOBAL);
  776.   
  777.   size = atoi(cmd->argv[1]);
  778.   
  779.   add_config_param("CommandBufferSize", 1, (void*) size);
  781.   return HANDLED(cmd);
  782. }
  784. MODRET add_cdpath(cmd_rec *cmd)
  785. {
  786.   CHECK_ARGS(cmd,1);
  787.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  789.   add_config_param_str("CDPath",1,(void*)cmd->argv[1]);
  791.   return HANDLED(cmd);
  792. }
  794. MODRET add_directory(cmd_rec *cmd)
  795. {
  796.   config_rec *c;
  797.   char *dir,*rootdir = NULL;
  798.   int flags = 0;
  800.   CHECK_ARGS(cmd,1);
  801.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  803.   dir = cmd->argv[1];
  805.   if(*dir != '/' && *dir != '~' && 
  806.      (!cmd->config || cmd->config->config_type != CONF_ANON))
  807.     CONF_ERROR(cmd,"relative pathname not allowed in non-anonymous blocks.");
  809.   /* If in anonymous mode, and path is relative, just cat anon root
  810.    * and relative path
  811.    *
  812.    * NOTE [Flood,9/97]: This is no longer necessary, because we don't
  813.    * interpolate anonymous dirs at run-time.
  814.    *
  815.    */
  816.   if(cmd->config && cmd->config->config_type == CONF_ANON &&
  817.      *dir != '/' && *dir != '~') {
  818.     if(strcmp(dir,"*") != 0)
  819.       dir = pdircat(cmd->tmp_pool,"/",dir,NULL);
  820.     rootdir = cmd->config->name;
  821.   }
  822.   else {
  823.     /* if the directory begins with ~, two possibilities:
  824.      * ~username/... : resolve to absolute path for ~username
  825.      * ~/... : intended to be defered until authenciation, where
  826.      *         ~ will be replaced w/ user's home dir
  827.      */
  829.     if(*dir == '~' && (!*(dir+1) || *(dir+1) == '/'))
  830.       flags |= CF_DEFER;
  831.     else {
  832.       dir = dir_best_path(cmd->tmp_pool,dir);
  834.       if(!dir)
  835.         CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,cmd->argv[1],": ",
  836.                        strerror(errno),NULL));
  837.     }
  838.   }
  840.   c = start_sub_config(dir);
  841.   c->argc = 2;
  842.   c->argv = pcalloc(c->pool,3*sizeof(void*));
  843.   if(rootdir)
  844.     c->argv[1] = pstrdup(permanent_pool,rootdir);
  846.   c->config_type = CONF_DIR;
  847.   c->flags |= flags;
  848.   return HANDLED(cmd);
  849. }
  851. MODRET set_allowretrieverestart(cmd_rec *cmd)
  852. {
  853.   config_rec *c;
  854.   CHECK_ARGS(cmd,1);
  855.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_DIR|CONF_ANON|CONF_GLOBAL);
  857.   c = add_config_param("AllowRetrieveRestart",1,
  858.                        (void*)get_boolean(cmd,1));
  859.   c->flags |= CF_MERGEDOWN;
  860.   return HANDLED(cmd);
  861. }
  863. MODRET set_allowstorerestart(cmd_rec *cmd)
  864. {
  865.   config_rec *c;
  866.   CHECK_ARGS(cmd,1);
  867.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_DIR|CONF_ANON|CONF_GLOBAL);
  869.   c = add_config_param("AllowStoreRestart",1,
  870.                        (void*)get_boolean(cmd,1));
  871.   c->flags |= CF_MERGEDOWN;
  872.   return HANDLED(cmd);
  873. }
  875. MODRET add_hidenoaccess(cmd_rec *cmd)
  876. {
  877.   config_rec *c;
  878.   CHECK_ARGS(cmd,0);
  879.   CHECK_CONF(cmd,CONF_DIR|CONF_ANON);
  881.   c = add_config_param("HideNoAccess",1,(void*)1);
  882.   c->flags |= CF_MERGEDOWN;
  883.   return HANDLED(cmd);
  884. }
  886. MODRET add_anonymousgroup(cmd_rec *cmd)
  887. {
  888.   config_rec *c;
  889.   int argc;
  890.   char **argv;
  891.   array_header *acl;
  893.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  895.   if(cmd->argc < 2)
  896.     CONF_ERROR(cmd,"syntax: AnonymousGroup <group-expression>");
  898.   argv = cmd->argv;
  899.   argc = cmd->argc - 1;
  901.   acl = parse_group_expression(cmd->tmp_pool,&argc,argv);
  903.   c = add_config_param("AnonymousGroup",0);
  904.   c->argc = argc;
  905.   c->argv = pcalloc(c->pool,(argc+1) * sizeof(char*));
  906.   argv = (char**)c->argv;
  908.   if(argc && acl)
  909.     while(argc--) {
  910.       *argv++ = pstrdup(permanent_pool,*((char**)acl->elts));
  911.       acl->elts = ((char**)acl->elts) + 1;
  912.     }
  914.   *argv = NULL;
  915.   return HANDLED(cmd);
  916. }
  918. MODRET add_hideuser(cmd_rec *cmd)
  919. {
  920.   config_rec *c;
  921.   struct passwd *pw;
  922.   CHECK_ARGS(cmd,1);
  923.   CHECK_CONF(cmd,CONF_DIR|CONF_ANON);
  925.   pw = auth_getpwnam(cmd->tmp_pool,cmd->argv[1]);
  926.   if(!pw)
  927.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"'",cmd->argv[1],"' is not "
  928.                    "a valid user.",NULL));
  930.   c = add_config_param("HideUser",1,(void*)((int)pw->pw_uid));
  931.   c->flags |= CF_MERGEDOWN;
  932.   return HANDLED(cmd);
  933. }
  935. MODRET add_hidegroup(cmd_rec *cmd)
  936. {
  937.   config_rec *c;
  938.   struct group *gr;
  940.   CHECK_ARGS(cmd,1);
  941.   CHECK_CONF(cmd,CONF_DIR|CONF_ANON);
  943.   gr = auth_getgrnam(cmd->tmp_pool,cmd->argv[1]);
  944.   if(!gr)
  945.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"'",cmd->argv[1],"' is not "
  946.                    "a valid group.",NULL));
  948.   c = add_config_param("HideGroup",1,(void*)((int)gr->gr_gid));
  949.   c->flags |= CF_MERGEDOWN;
  950.   return HANDLED(cmd);
  951. }
  953. MODRET add_groupowner(cmd_rec *cmd)
  954. {
  955.   config_rec *c;
  957.   CHECK_ARGS(cmd,1);
  958.   CHECK_CONF(cmd,CONF_ANON|CONF_DIR|CONF_DYNDIR);
  960.   c = add_config_param_str("GroupOwner",1,cmd->argv[1]);
  961.   c->flags |= CF_MERGEDOWN;
  962.   return HANDLED(cmd);
  963. }
  965. MODRET set_allowoverwrite(cmd_rec *cmd)
  966. {
  967.   config_rec *c;
  969.   CHECK_ARGS(cmd,1);
  970.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_DIR|CONF_GLOBAL);
  972.   c = add_config_param("AllowOverwrite",1,(void*)get_boolean(cmd,1));
  973.   c->flags |= CF_MERGEDOWN;
  974.   return HANDLED(cmd);
  975. }
  977. MODRET set_hiddenstor(cmd_rec *cmd)
  978. {
  979.   config_rec *c;
  981.   CHECK_ARGS(cmd,1);
  982.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_DIR|CONF_GLOBAL);
  984.   c = add_config_param("HiddenStor",1,(void*)get_boolean(cmd,1));
  985.   c->flags |= CF_MERGEDOWN;
  986.   return HANDLED(cmd);
  987. }
  989. MODRET end_directory(cmd_rec *cmd)
  990. {
  991.   CHECK_ARGS(cmd,0);
  992.   CHECK_CONF(cmd,CONF_DIR);
  994.   end_sub_config();
  995.   return HANDLED(cmd);
  996. }
  998. MODRET add_anonymous(cmd_rec *cmd)
  999. {
  1000.   config_rec *c;
  1001.   char *dir;
  1003.   CHECK_ARGS(cmd,1);
  1004.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  1006.   dir = cmd->argv[1];
  1008.   if(*dir != '/' && *dir != '~')
  1009.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"(",dir,") absolute pathname "
  1010.                "required.",NULL));
  1012.   if(strchr(dir,'*'))
  1013.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"(",dir,") wildcards not allowed "
  1014.                "in pathname.",NULL));
  1016.   if(!strcmp(dir,"/"))
  1017.     CONF_ERROR(cmd,"'/' not permitted for anonymous root directory.");
  1019.   if(*(dir+strlen(dir)-1) != '/')
  1020.     dir = pstrcat(cmd->tmp_pool,dir,"/",NULL);
  1022.   if(!dir)
  1023.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,cmd->argv[1],": ",
  1024.                strerror(errno),NULL));
  1026.   c = start_sub_config(dir);
  1028.   c->config_type = CONF_ANON;
  1029.   return HANDLED(cmd);
  1030. }
  1032. MODRET set_anonrequirepassword(cmd_rec *cmd)
  1033. {
  1034.   CHECK_ARGS(cmd,1);
  1035.   CHECK_CONF(cmd,CONF_ANON);
  1037.   add_config_param("AnonRequirePassword",1,
  1038.                    (void*)get_boolean(cmd,1));
  1039.   return HANDLED(cmd);
  1040. }
  1042. MODRET end_anonymous(cmd_rec *cmd)
  1043. {
  1044.   CHECK_ARGS(cmd,0);
  1045.   CHECK_CONF(cmd,CONF_ANON);
  1047.   end_sub_config();
  1048.   return HANDLED(cmd);
  1049. }
  1051. MODRET add_global(cmd_rec *cmd)
  1052. {
  1053.   config_rec *c;
  1055.   CHECK_ARGS(cmd,0);
  1056.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL);
  1058.   c = start_sub_config("Global");
  1059.   c->config_type = CONF_GLOBAL;
  1061.   return HANDLED(cmd);
  1062. }
  1064. MODRET end_global(cmd_rec *cmd)
  1065. {
  1066.   CHECK_ARGS(cmd,0);
  1067.   CHECK_CONF(cmd,CONF_GLOBAL);
  1069.   end_sub_config();
  1070.   return HANDLED(cmd);
  1071. }
  1073. MODRET add_limit(cmd_rec *cmd)
  1074. {
  1075.   config_rec *c;
  1076.   int cargc;
  1077.   char **argv,**cargv;
  1079.   if(cmd->argc < 2)
  1080.     CONF_ERROR(cmd,"directive requires one or more FTP commands.");
  1081.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_DIR|CONF_ANON|CONF_DYNDIR|CONF_GLOBAL);
  1083.   c = start_sub_config("Limit");
  1084.   c->config_type = CONF_LIMIT;
  1085.   cargc = cmd->argc-1;
  1086.   cargv = cmd->argv+1;
  1088.   c->argc = cmd->argc-1;
  1089.   c->argv = pcalloc(c->pool,cmd->argc*sizeof(void*));
  1090.   argv = (char**)c->argv;
  1092.   while(cargc--)
  1093.     *argv++ = pstrdup(permanent_pool,*cargv++);
  1095.   *argv = NULL;
  1097.   return HANDLED(cmd);
  1098. }
  1100. MODRET add_order(cmd_rec *cmd)
  1101. {
  1102.   int order = -1,argc = cmd->argc;
  1103.   char *arg = "",**argv = cmd->argv+1;
  1105.   CHECK_CONF(cmd,CONF_LIMIT);
  1107.   while(--argc && *argv)
  1108.     arg = pstrcat(cmd->tmp_pool,arg,*argv++,NULL);
  1110.   if(!strcasecmp(arg,"allow,deny"))
  1111.     order = ORDER_ALLOWDENY;
  1112.   else if(!strcasecmp(arg,"deny,allow"))
  1113.     order = ORDER_DENYALLOW;
  1114.   else
  1115.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"'",arg,"': invalid argument",NULL));
  1117.   add_config_param("Order",1,(void*)order);
  1118.   return HANDLED(cmd);
  1119. }
  1121. MODRET _add_allow_deny_user(cmd_rec *cmd, char *name)
  1122. {
  1123.   config_rec *c;
  1124.   char **argv;
  1125.   int argc;
  1126.   array_header *acl = NULL;
  1128.   CHECK_CONF(cmd,CONF_LIMIT);
  1130.   if(cmd->argc < 2)
  1131.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"syntax: ",name,
  1132.                " <user-expression>",NULL));
  1134.   argv = cmd->argv;
  1135.   argc = cmd->argc-1;
  1137.   acl = parse_user_expression(cmd->tmp_pool,&argc,argv);
  1139.   c = add_config_param(name,0);
  1141.   c->argc = argc;
  1142.   c->argv = pcalloc(c->pool,(argc+1) * sizeof(char*));
  1143.   argv = (char**)c->argv;
  1144.   while(argc--) {
  1145.     *argv++ = pstrdup(permanent_pool,*((char**)acl->elts));
  1146.     acl->elts = ((char**)acl->elts) + 1;
  1147.   }
  1149.   *argv = NULL;
  1150.   return HANDLED(cmd);
  1151. }
  1153. MODRET _add_allow_deny_group(cmd_rec *cmd, char *name)
  1154. {
  1155.   config_rec *c;
  1156.   char **argv;
  1157.   int argc;
  1158.   array_header *acl = NULL;
  1160.   CHECK_CONF(cmd,CONF_LIMIT);
  1162.   if(cmd->argc < 2)
  1163.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"syntax: ",name,
  1164.                " <group-expression>",NULL));
  1166.   argv = cmd->argv;
  1167.   argc = cmd->argc-1;
  1169.   acl = parse_group_expression(cmd->tmp_pool,&argc,argv);
  1171.   c = add_config_param(name,0);
  1173.   c->argc = argc;
  1174.   c->argv = pcalloc(c->pool,(argc+1) * sizeof(char*));
  1175.   argv = (char**)c->argv;
  1176.   while(argc--) {
  1177.     *argv++ = pstrdup(permanent_pool,*((char**)acl->elts));
  1178.     acl->elts = ((char**)acl->elts) + 1;
  1179.   }
  1181.   *argv = NULL;
  1182.   return HANDLED(cmd);
  1183. }
  1185. MODRET add_allowgroup(cmd_rec *cmd)
  1186. {
  1187.   return _add_allow_deny_group(cmd,"AllowGroup");
  1188. }
  1190. MODRET add_denygroup(cmd_rec *cmd)
  1191. {
  1192.   return _add_allow_deny_group(cmd,"DenyGroup");
  1193. }
  1195. MODRET add_allowuser(cmd_rec *cmd)
  1196. {
  1197.   return _add_allow_deny_user(cmd,"AllowUser");
  1198. }
  1200. MODRET add_denyuser(cmd_rec *cmd)
  1201. {
  1202.   return _add_allow_deny_user(cmd,"DenyUser");
  1203. }
  1205. MODRET _add_allow_deny(cmd_rec *cmd, char *name)
  1206. {
  1207.   int argc;
  1208.   char *s,*ent,**argv;
  1209.   array_header *acl;
  1210.   config_rec *c;
  1212.   CHECK_CONF(cmd,CONF_LIMIT);
  1214.   /* Syntax: allow [from] [all|none]|host|network[,...] */
  1215.   acl = make_array(cmd->tmp_pool,cmd->argc,sizeof(char*));
  1216.   argc = cmd->argc-1; argv = cmd->argv;
  1218.   /* Skip optional "from" keyword */
  1219.   while(argc && *(argv+1)) {
  1220.     if(!strcasecmp("from",*(argv+1))) {
  1221.       argv++; argc--; continue;
  1222.     } else if(!strcasecmp("all",*(argv+1))) {
  1223.       *((char**)push_array(acl)) = "ALL";
  1224.       argc = 0;
  1225.     } else if(!strcasecmp("none",*(argv+1))) {
  1226.       *((char**)push_array(acl)) = "NONE";
  1227.       argc = 0;
  1228.     }
  1229.     break;
  1230.   }
  1232.   while(argc-- && *(++argv)) {
  1233.     s = pstrdup(cmd->tmp_pool,*argv);
  1235.     /* parse the string into coma-delimited entries */
  1236.     while((ent = get_token(&s,",")) != NULL)
  1237.       if(*ent) {
  1238.         if(!strcasecmp(ent,"all") || !strcasecmp(ent,"none")) {
  1239.           acl->nelts = 0; argc = 0; break;
  1240.         }
  1242.         *((char**)push_array(acl)) = ent;
  1243.       }
  1244.   }
  1246.   if(!acl->nelts)
  1247.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"syntax: ",name,
  1248.                    " [from] [all|none]|host|network[,...]",NULL));
  1250.   c = add_config_param(name,0);
  1252.   c->argc = acl->nelts;
  1253.   c->argv = pcalloc(c->pool,(c->argc+1) * sizeof(char*));
  1254.   argv = (char**)c->argv;
  1255.   while(acl->nelts--) {
  1256.     *argv++ = pstrdup(permanent_pool,*((char**)acl->elts));
  1257.     acl->elts = ((char**)acl->elts) + 1;
  1258.   }
  1260.   *argv = NULL;
  1261.   return HANDLED(cmd);
  1262. }
  1264. MODRET add_allow(cmd_rec *cmd)
  1265. {
  1266.   return _add_allow_deny(cmd,"Allow");
  1267. }
  1269. MODRET add_deny(cmd_rec *cmd)
  1270. {
  1271.   return _add_allow_deny(cmd,"Deny");
  1272. }
  1274. MODRET set_denyall(cmd_rec *cmd)
  1275. {
  1276.   CHECK_ARGS(cmd,0);
  1277.   CHECK_CONF(cmd,CONF_LIMIT|CONF_ANON);
  1279.   add_config_param("DenyAll",1,(void*)1);
  1280.   return HANDLED(cmd);
  1281. }
  1283. MODRET set_allowall(cmd_rec *cmd)
  1284. {
  1285.   CHECK_ARGS(cmd,0);
  1286.   CHECK_CONF(cmd,CONF_LIMIT|CONF_ANON);
  1288.   add_config_param("AllowAll",1,(void*)1);
  1289.   return HANDLED(cmd);
  1290. }
  1292. MODRET end_limit(cmd_rec *cmd)
  1293. {
  1294.   CHECK_ARGS(cmd,0);
  1295.   CHECK_CONF(cmd,CONF_LIMIT);
  1297.   end_sub_config();
  1298.   return HANDLED(cmd);
  1299. }
  1301. MODRET set_ignorehidden(cmd_rec *cmd)
  1302. {
  1303.   config_rec *c;
  1305.   CHECK_ARGS(cmd,1);
  1306.   CHECK_CONF(cmd,CONF_LIMIT);
  1308.   c = add_config_param("IgnoreHidden",1,(void*)get_boolean(cmd,1));
  1309.   return HANDLED(cmd);
  1310. }
  1312. MODRET add_useralias(cmd_rec *cmd)
  1313. {
  1314.   CHECK_ARGS(cmd,2);
  1315.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1317.   add_config_param_str("UserAlias",2,(void*)cmd->argv[1],(void*)cmd->argv[2]);
  1319.   return HANDLED(cmd);
  1320. }
  1322. MODRET set_displaylogin(cmd_rec *cmd)
  1323. {
  1324.   config_rec *c;
  1326.   CHECK_ARGS(cmd,1);
  1327.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1329.   c = add_config_param_str("DisplayLogin",1,(void*)cmd->argv[1]);
  1330.   c->flags |= CF_MERGEDOWN;
  1331.   return HANDLED(cmd);
  1332. }
  1334. MODRET set_displayconnect(cmd_rec *cmd)
  1335. {
  1336.   config_rec *c;
  1338.   CHECK_ARGS(cmd,1);
  1339.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  1341.   c = add_config_param_str("DisplayConnect",1,(void*)cmd->argv[1]);
  1342.   c->flags |= CF_MERGEDOWN;
  1343.   return HANDLED(cmd);
  1344. }
  1346. MODRET set_displayfirstchdir(cmd_rec *cmd)
  1347. {
  1348.   config_rec *c;
  1350.   CHECK_ARGS(cmd,1);
  1351.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_DIR|CONF_GLOBAL);
  1353.   c = add_config_param_str("DisplayFirstChdir",1,(void*)cmd->argv[1]);
  1354.   c->flags |= CF_MERGEDOWN;
  1355.   return HANDLED(cmd);
  1356. }
  1358. MODRET set_displayquit(cmd_rec *cmd)
  1359. {
  1360.   config_rec *c;
  1362.   CHECK_ARGS(cmd,1);
  1363.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1365.   c = add_config_param_str("DisplayQuit",1,(void*)cmd->argv[1]);
  1366.   c->flags |= CF_MERGEDOWN;
  1367.   return HANDLED(cmd);
  1368. }
  1370. MODRET set_displaygoaway(cmd_rec *cmd)
  1371. {
  1372.   config_rec *c;
  1374.   CHECK_ARGS(cmd,1);
  1375.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1377.   c = add_config_param_str("DisplayGoAway",1,(void*)cmd->argv[1]);
  1378.   c->flags |= CF_MERGEDOWN;
  1379.   return HANDLED(cmd);
  1380. }
  1382. MODRET set_authaliasonly(cmd_rec *cmd)
  1383. {
  1384.   int b;
  1386.   CHECK_ARGS(cmd,1);
  1387.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1389.   if((b = get_boolean(cmd,1)) == -1)
  1390.     CONF_ERROR(cmd,"expected boolean argument.");
  1392.   add_config_param("AuthAliasOnly",1,(void*)b);
  1394.   return HANDLED(cmd);
  1395. }
  1397. MODRET add_virtualhost(cmd_rec *cmd)
  1398. {
  1399.   server_rec *s;
  1401.   CHECK_ARGS(cmd,1);
  1402.   CHECK_CONF(cmd,CONF_ROOT);
  1404.   if(cmd->server != main_server)
  1405.     CONF_ERROR(cmd,"directive cannot be nested.");
  1407.   s = start_new_server(cmd->argv[1]);
  1408.   if(!s)
  1409.     CONF_ERROR(cmd,"unable to create virtual server configuration.");
  1411.   s->ServerPort = main_server->ServerPort;
  1412.   return HANDLED(cmd);
  1413. }
  1415. MODRET end_virtualhost(cmd_rec *cmd)
  1416. {
  1417.   CHECK_ARGS(cmd,0);
  1419.   if(cmd->server == main_server)
  1420.     CONF_ERROR(cmd,"must be matched with <VirtualServer> directive.");
  1422.   end_new_server();
  1423.   return HANDLED(cmd);
  1424. }
  1426. /* Display a file via a given response numeric.  File is displayed
  1427.  * in normal RFC959 multline mode, unless MultilineRFC2228 is set.
  1428.  * Returns: -1 on error
  1429.  *          0 if file display
  1430.  */
  1432. int core_display_file(const char *numeric, const char *fn)
  1433. {
  1434.   fsdir_t *fp;
  1435.   char buf[1024];
  1436.   int len, max, fd, classes_enabled;
  1437.   unsigned long fs_size = 0;
  1438.   pool *p;
  1439.   xaset_t *s;
  1440.   char *outs,*mg_time,mg_size[12],mg_max[12] = "unlimited", mg_class_limit[12];
  1441.   char mg_cur[12],mg_xfer_bytes[12],mg_cur_class[12], config_class_users[128];
  1442.   short first = 1;
  1444. #if defined(HAVE_SYS_STATVFS_H) || defined(HAVE_SYS_VFS_H)
  1445.   fs_size = get_fs_size((char*)fn);
  1446.   snprintf(mg_size, sizeof(mg_size), "%lu", fs_size);
  1447. #endif
  1449.   if((fp = fs_open_canon(fn,O_RDONLY,&fd)) == NULL)
  1450.     return -1;
  1452.   p = make_sub_pool(permanent_pool);
  1454.   s = (session.anon_config ? session.anon_config->subset : main_server->conf);
  1456.   mg_time = fmt_time(time(NULL));
  1457.   snprintf(mg_size, sizeof(mg_size), "%lu",fs_size);
  1458.   max = get_param_int(s,"MaxClients",FALSE);
  1459.   snprintf(mg_cur, sizeof(mg_cur), "%d",(int)get_param_int(main_server->conf,
  1460.           "CURRENT-CLIENTS",FALSE)+1);
  1462.   if((classes_enabled = get_param_int(CURRENT_CONF,"Classes",FALSE)) < 0)
  1463.     classes_enabled = 0;
  1464.   
  1465.   if (classes_enabled && session.class && session.class->name) {
  1466. snprintf(config_class_users,sizeof(config_class_users),"%s-%s","CURRENT-CLIENTS-CLASS",session.class->name);
  1467. snprintf(mg_cur_class,sizeof(mg_cur_class),"%d",(int)get_param_int(main_server->conf,config_class_users,FALSE)+1);
  1468. snprintf(mg_class_limit, sizeof(mg_class_limit), "%u",
  1469.  session.class->max_connections);
  1470.   } else
  1471. mg_cur_class[0] = 0;
  1473.   snprintf(mg_xfer_bytes, sizeof(mg_xfer_bytes), "%lu",
  1474.    session.total_bytes >> 10);
  1476.   if(max != -1)
  1477.     snprintf(mg_max, sizeof(mg_max), "%d",max);
  1479.   while(fs_gets(buf,sizeof(buf),fp,fd) != NULL) {
  1480.     buf[1023] = '';
  1482.     len = strlen(buf);
  1484.     while(len && (buf[len-1] == 'r' || buf[len-1] == 'n')) {
  1485.       buf[len-1] = '';
  1486.       len--;
  1487.     }
  1489.     outs = sreplace(p,buf,
  1490.              "%T",mg_time,
  1491.              "%F",mg_size,
  1492.      "%C",(session.cwd[0] ? session.cwd : "(none)"),
  1493.      "%R",(session.c && session.c->remote_name ?
  1494.    session.c->remote_name : "(unknown)"),
  1495.      "%L",main_server->ServerFQDN,
  1496.              "%u",session.ident_user,
  1497.      "%U",(char*)get_param_ptr(main_server->conf,"USER",FALSE),
  1498.      "%K",mg_xfer_bytes,
  1499.      "%M",mg_max,
  1500.              "%N",mg_cur,
  1501.      "%E",main_server->ServerAdmin,
  1502.      "%V",main_server->ServerName,
  1503.      "%x",(classes_enabled && session.class) ? session.class->name : "",
  1504.      "%y",mg_cur_class,
  1505.      "%z",mg_class_limit,
  1506.              NULL);
  1508.     if(first) {
  1509.       send_response_raw("%s-%s",numeric,outs);
  1510.       first=0;
  1511.     } else {
  1512.       if(MultilineRFC2228)
  1513.         send_response_raw("%s-%s",numeric,outs);
  1514.       else
  1515.         send_response_raw(" %s",outs);
  1516.       }
  1517.   }
  1519.   fs_close(fp,fd);
  1520.   return 0;
  1521. }
  1523. MODRET cmd_quit(cmd_rec *cmd)
  1524. {
  1525.   char *display = NULL;
  1526.   
  1527.   if(session.flags & SF_ANON)
  1528. display = (char*)get_param_ptr(session.anon_config->subset, "DisplayQuit", FALSE);
  1530.   if(!display)
  1531. display = (char*)get_param_ptr(cmd->server->conf, "DisplayQuit", FALSE);
  1533.   if(display) {
  1534. core_display_file(R_221, display);
  1535. /* hack or feature, core_display_file() always puts a hyphen
  1536.  * on the last line
  1537.  */
  1538. send_response(R_221, "");
  1539.   } else {
  1540.         send_response(R_221, "Goodbye.");
  1541.   }
  1542.   
  1543.   log_pri(LOG_NOTICE, "FTP session closed.");
  1544.   end_login(0);
  1545.   return HANDLED(cmd); /* Avoid compiler warning */
  1546. }
  1548. /* per RFC959, directory responses for MKD and PWD should be
  1549.  * "dir_name" (w/ quote).  For directories that CONTAIN quotes,
  1550.  * the add'l quotes must be duplicated.
  1551.  */
  1553. static char *quote_dir(cmd_rec *cmd, char *dir)
  1554. {
  1555.   return sreplace(cmd->tmp_pool,dir,""","""",NULL);
  1556. }
  1558. MODRET cmd_pwd(cmd_rec *cmd)
  1559. {
  1560.   if(cmd->argc != 1) {
  1561.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  1562.     return ERROR(cmd);
  1563.   }
  1565.   
  1566.   add_response(R_257,""%s" is current directory.",
  1567.                 quote_dir(cmd,session.vwd));
  1568.   return HANDLED(cmd);
  1569. }
  1571. MODRET cmd_pasv(cmd_rec *cmd)
  1572. {
  1573.   union {
  1574.     p_in_addr_t addr;
  1575.     unsigned char u[4];
  1576.   } addr;
  1578.   union {
  1579.     unsigned short port;
  1580.     unsigned char u[2];
  1581.   } port;
  1583.   if(cmd->argc != 1) {
  1584.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  1585.     return ERROR(cmd);
  1586.   }
  1588.   /* If we already have a passive listen data connection open,
  1589.    * kill it.
  1590.    */
  1592.   if(session.d) {
  1593.     inet_close(session.d->pool,session.d);
  1594.     session.d = NULL;
  1595.   }
  1597.   session.d = inet_create_connection(session.pool,NULL,-1,
  1598. session.c->local_ipaddr,INPORT_ANY,FALSE);
  1600.   if(!session.d)
  1601.      return ERROR_MSG(cmd,R_425,
  1602.                      "Unable to build data connection: Internal error.");
  1604.   inet_setblock(session.pool,session.d);
  1605.   inet_listen(session.pool,session.d,1);
  1607.   session.d->inf = io_open(session.pool,session.d->listen_fd,IO_READ);
  1609.   /* Now tell the client our address/port */
  1610.   session.data_port = session.d->local_port;
  1611.   session.flags |= SF_PASSIVE;
  1613.   addr.addr = *session.d->local_ipaddr;
  1614.   port.port = htons(session.data_port);
  1617.   log_debug(DEBUG1,"Entering Passive Mode (%u,%u,%u,%u,%u,%u)",
  1618. (int)addr.u[0],(int)addr.u[1],(int)addr.u[2],
  1619. (int)addr.u[3],(int)port.u[0],(int)port.u[1]);
  1621.   add_response(R_227, "Entering Passive Mode (%u,%u,%u,%u,%u,%u)",
  1622.                 (int)addr.u[0],(int)addr.u[1],(int)addr.u[2],
  1623.                 (int)addr.u[3],(int)port.u[0],(int)port.u[1]);
  1625.   return HANDLED(cmd);
  1626. }
  1628. MODRET cmd_port(cmd_rec *cmd)
  1629. {
  1630.   union {
  1631.     p_in_addr_t addr;
  1632.     unsigned char u[4];
  1633.   } addr;
  1635.   union {
  1636.     unsigned short port;
  1637.     unsigned char u[2];
  1638.   } port;
  1640.   char *a,*endp,*arg;
  1641.   int i,cnt = 0;
  1642.   int allow_foreign_addr = 0;
  1644.   if(cmd->argc != 2) {
  1645.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  1646.     return ERROR(cmd);
  1647.   }
  1649.   /* Format is h1,h2,h3,h4,p1,p2 (ASCII in network order) */
  1650.   a = pstrdup(cmd->tmp_pool,cmd->argv[1]);
  1652.   while(a && *a && cnt < 6) {
  1653.     arg = strsep(&a,",");
  1655.     if(!arg && a && *a) {
  1656.       arg = a;
  1657.       a = NULL;
  1658.     } else if(!arg)
  1659.       break;
  1661.     i = strtol(arg,&endp,10);
  1662.     if(*endp || i < 0 || i > 255)
  1663.       break;
  1665.     if(cnt < 4)
  1666.       addr.u[cnt++] = (unsigned char)i;
  1667.     else
  1668.       port.u[cnt++ - 4] = (unsigned char)i;
  1669.   }
  1671.   if(cnt != 6 || (a && *a))
  1672.     return ERROR_MSG(cmd,R_501,"Illegal PORT command.");
  1674.   /* Make sure that the address specified matches the address
  1675.    * that the control connection is coming from.
  1676.    */
  1678.   allow_foreign_addr = get_param_int(TOPLEVEL_CONF,"AllowForeignAddress",FALSE);
  1680.   if(allow_foreign_addr != 1) {
  1681.     if(addr.addr.s_addr != session.c->remote_ipaddr->s_addr ||
  1682.        !port.port) {
  1683.       log_pri(LOG_WARNING,"refused PORT %s from %s (address mismatch)",
  1684.        cmd->arg,session.c->remote_name);
  1685.       return ERROR_MSG(cmd,R_500,"Illegal PORT command.");
  1686.     }
  1687.   }
  1689.   /* Additionally, make sure that the port number used is a "high
  1690.    * numbered" port, to avoid bounce attacks
  1691.    */
  1693.   if(ntohs(port.port) < 1024) {
  1694.     log_pri(LOG_WARNING,"refused PORT %s from %s (bounce attack)",
  1695.                         cmd->arg,session.c->remote_name);
  1696.     return ERROR_MSG(cmd,R_500,"Illegal PORT command.");
  1697.   }
  1699.   memcpy(&session.data_addr, &addr.addr, sizeof(session.data_addr));
  1700.   session.data_port = ntohs(port.port);
  1701.   session.flags &= (SF_ALL^SF_PASSIVE);
  1703.   /* If we already have a data connection open, kill it.
  1704.    */
  1706.   if(session.d) {
  1707.     inet_close(session.d->pool,session.d);
  1708.     session.d = NULL;
  1709.   }
  1711.   add_response(R_200,"PORT command successful.");
  1712.   return HANDLED(cmd);
  1713. }
  1715. MODRET cmd_help(cmd_rec *cmd)
  1716. {
  1717.   int i,c = 0;
  1718.   char buf[9];
  1720.   if(cmd->argc == 1) {
  1721.     /* Print help for all commands */
  1722.     char *outa[8];
  1723.     char *outs = "";
  1725.     bzero(outa,sizeof(outa));
  1727.     add_response(R_214,
  1728.       "The following commands are recognized (* =>'s unimplemented).");
  1729.     for(i = 0; _help[i].cmd; i++) {
  1731.       if(_help[i].implemented)
  1732.         outa[c++] = _help[i].cmd;
  1733.       else
  1734.         outa[c++] = pstrcat(cmd->tmp_pool,_help[i].cmd,"*",NULL);
  1736.       /* 8 rows */
  1737.       if(((i+1) % 8 == 0) || !_help[i+1].cmd) {
  1738.         int j;
  1740.         for(j = 0; j < 8; j++) {
  1741.           if(outa[j]) {
  1742.             snprintf(buf, sizeof(buf), "%-8s",outa[j]);
  1743.             outs = pstrcat(cmd->tmp_pool,outs,buf,NULL);
  1744.           } else
  1745.             break;
  1746.         }
  1748.         if(*outs)
  1749.           add_response(R_214,"%s",outs);
  1750.         outs = "";
  1751.         c = 0;
  1752.         bzero(outa,sizeof(outa));
  1753.       }
  1754.     }
  1756.     add_response(R_214,"Direct comments to %s.",
  1757.                          (cmd->server->ServerAdmin ? cmd->server->ServerAdmin :
  1758.                           "ftp-admin"));
  1759.   } else {
  1760.     char *cp;
  1762.     for(cp = cmd->argv[1]; *cp; cp++)
  1763.       *cp = toupper(*cp);
  1765.     if(!strcmp(cmd->argv[1],"SITE"))
  1766.       return call_module(&site_module,site_dispatch,cmd);
  1768.     for(i = 0; _help[i].cmd; i++)
  1769.       if(!strcasecmp(cmd->argv[1],_help[i].cmd)) {
  1770.         add_response(R_214,"Syntax: %s %s",cmd->argv[1],_help[i].syntax);
  1771.         return HANDLED(cmd);
  1772.       }
  1774.     add_response_err(R_502,"Unknown command '%s'.",cmd->argv[1]);
  1775.     return ERROR(cmd);
  1776.   }
  1778.   return HANDLED(cmd);
  1779. }
  1781. MODRET cmd_syst(cmd_rec *cmd)
  1782. {
  1783.   add_response(R_215,"UNIX Type: L8");
  1784.   return HANDLED(cmd);
  1785. }
  1787. int core_chmod(cmd_rec *cmd, char *dir, mode_t mode) {
  1788.   if(!dir_check(cmd->tmp_pool, "SITE_CHMOD", "WRITE", dir, NULL))
  1789.     return -1;
  1791.   return fs_chmod(dir,mode);
  1792. }
  1794. MODRET _chdir(cmd_rec *cmd,char *ndir)
  1795. {
  1796.   char *display = NULL;
  1797.   char *dir,*odir,*cdir;
  1798.   config_rec *cdpath;
  1799.   int showsymlinks;
  1800.   
  1801.   odir = ndir;
  1802.   showsymlinks = get_param_int(TOPLEVEL_CONF,"ShowSymlinks",FALSE);
  1804.   if(showsymlinks == -1)
  1805.     showsymlinks = 1;
  1807.   if(showsymlinks) {
  1808.     dir = dir_realpath(cmd->tmp_pool,ndir);
  1810.     if(!dir || !dir_check_full(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL) ||
  1811.         fs_chdir(dir,0) == -1) {
  1812.       for(cdpath = find_config(main_server->conf,CONF_PARAM,"CDPath",TRUE);
  1813.   cdpath != NULL; cdpath =
  1814.     find_config_next(cdpath,cdpath->next,CONF_PARAM,"CDPath",TRUE)) {
  1815. cdir = (char *) malloc(strlen(cdpath->argv[0]) + strlen(ndir) + 2);
  1816. snprintf(cdir, strlen(cdpath->argv[0]) + strlen(ndir) + 2,
  1817.  "%s%s%s", (char *) cdpath->argv[0],
  1818.  ((char *) cdpath->argv[0])[strlen(cdpath->argv[0]) - 1] == '/' ? "" : "/",
  1819.  ndir);
  1820. dir = dir_realpath(cmd->tmp_pool,cdir);
  1821. free(cdir);
  1822. if(dir &&
  1823.    dir_check_full(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL) &&
  1824.    fs_chdir(dir,0) != -1) {
  1825.   break;
  1826. }
  1827.       }
  1828.       if(!cdpath) {
  1829. add_response_err(R_550,"%s: %s",odir,strerror(errno));
  1830. return ERROR(cmd);
  1831.       }
  1832.     }
  1833.   } else {
  1834.     /* virtualize the chdir */
  1835.     ndir = dir_virtual_chdir(cmd->tmp_pool,ndir);
  1836.     dir = dir_realpath(cmd->tmp_pool,ndir);
  1838.     if(!dir || !dir_check_full(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL) ||
  1839.         fs_chdir_canon(ndir,1) == -1) {
  1841.       for(cdpath = find_config(main_server->conf,CONF_PARAM,"CDPath",TRUE);
  1842.   cdpath != NULL; cdpath =
  1843.     find_config_next(cdpath,cdpath->next,CONF_PARAM,"CDPath",TRUE)) {
  1844. cdir = (char *) malloc(strlen(cdpath->argv[0]) + strlen(ndir) + 2);
  1845. snprintf(cdir, strlen(cdpath->argv[0]) + strlen(ndir) + 2,
  1846.  "%s%s%s", (char *) cdpath->argv[0],
  1847. ((char *)cdpath->argv[0])[strlen(cdpath->argv[0]) - 1] == '/' ? "" : "/",
  1848. ndir);
  1849. ndir = dir_virtual_chdir(cmd->tmp_pool,cdir);
  1850. dir = dir_realpath(cmd->tmp_pool,ndir);
  1851. free(cdir);
  1852. if(dir &&
  1853.    dir_check_full(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL) &&
  1854.    fs_chdir_canon(ndir,1) != -1) {
  1855.   break;
  1856. }
  1857.       }
  1858.       if(!cdpath) {
  1859. add_response_err(R_550,"%s: %s",odir,strerror(errno));
  1860. return ERROR(cmd);
  1861.       }
  1862.     }
  1863.   }
  1865.   sstrncpy(session.cwd,fs_getcwd(),sizeof(session.cwd));
  1866.   sstrncpy(session.vwd,fs_getvwd(),sizeof(session.vwd));
  1867.   log_run_cwd(session.cwd);
  1869.   if(session.dir_config)
  1870.     display = (char*)get_param_ptr(session.dir_config->subset,
  1871.                                    "DisplayFirstChdir",FALSE);
  1872.   if(!display && session.anon_config)
  1873.     display = (char*)get_param_ptr(session.anon_config->subset,
  1874.                                    "DisplayFirstChdir",FALSE);
  1875.   if(!display)
  1876.     display = (char*)get_param_ptr(cmd->server->conf,
  1877.                                    "DisplayFirstChdir",FALSE);
  1879.   if(display) {
  1880.     config_rec *c;
  1881.     time_t last;
  1882.     struct stat sbuf;
  1884.     c = find_config(cmd->server->conf,CONF_USERDATA,session.cwd,FALSE);
  1886.     if(!c) {
  1887.       time(&last);
  1888.       c = add_config_set(&cmd->server->conf,session.cwd);
  1889.       c->config_type = CONF_USERDATA;
  1890.       c->argc = 1;
  1891.       c->argv = pcalloc(c->pool,sizeof(void**) * 2);
  1892.       c->argv[0] = (void*)last;
  1893.       last = (time_t)0L;
  1894.     } else {
  1895.       last = (time_t)c->argv[0];
  1896.       c->argv[0] = (void*)time(NULL);
  1897.     }
  1899.     if(fs_stat(display,&sbuf) != -1 && !S_ISDIR(sbuf.st_mode) &&
  1900.        sbuf.st_mtime > last)
  1901.       core_display_file(R_250,display);
  1902.   }
  1904.   add_response(R_250,"CWD command successful.");
  1905.   return HANDLED(cmd);
  1906. }
  1908. MODRET cmd_rmd(cmd_rec *cmd)
  1909. {
  1910.   char *dir;
  1911. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  1912.   regex_t *preg;
  1913. #endif
  1915.   if(cmd->argc < 2) {
  1916.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  1917.     return ERROR(cmd);
  1918.   }
  1920. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  1921.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathAllowFilter",FALSE);
  1923.   if(preg && regexec(preg,cmd->arg,0,NULL,0) != 0) {
  1924.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  1925.     return ERROR(cmd);
  1926.   }
  1928.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathDenyFilter",FALSE);
  1929.   
  1930.   if(preg && regexec(preg,cmd->arg,0,NULL,0) == 0) {
  1931.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  1932.     return ERROR(cmd);
  1933.   }
  1934. #endif
  1936.   dir = dir_realpath(cmd->tmp_pool,cmd->arg);
  1938.   if(!dir || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL) ||
  1939.      rmdir(dir) == -1) {
  1940.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  1941.     return ERROR(cmd);
  1942.   } else
  1943.     add_response(R_250,"%s command successful.",cmd->argv[0]);
  1945.   return HANDLED(cmd);
  1946. }
  1948. MODRET cmd_mkd(cmd_rec *cmd)
  1949. {
  1950.   char *dir;
  1951. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  1952.   regex_t *preg;
  1953. #endif
  1955.   if(cmd->argc < 2) {
  1956.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  1957.     return ERROR(cmd);
  1958.   }
  1960.   if(strchr(cmd->arg,'*')) {
  1961.     add_response_err(R_550,"%s: Invalid directory name", cmd->argv[1]);
  1962.     return ERROR(cmd);
  1963.   }
  1965. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  1966.     preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathAllowFilter",FALSE);
  1968.     if(preg && regexec(preg,cmd->arg,0,NULL,0) != 0) {
  1969.       add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  1970.       return ERROR(cmd);
  1971.     }
  1973.     preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathDenyFilter",FALSE);
  1975.     if(preg && regexec(preg,cmd->arg,0,NULL,0) == 0) {
  1976.       add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  1977.       return ERROR(cmd);
  1978.     }
  1979. #endif
  1981.   dir = dir_canonical_path(cmd->tmp_pool,cmd->arg);
  1983.   if(!dir || !dir_check_canon(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL) ||
  1984.      mkdir(dir,0777) == -1) {
  1985.     add_response_err(R_550,"%s: %s",cmd->argv[1],strerror(errno));
  1986.     return ERROR(cmd);
  1987.   } else {
  1988.     if(session.fsgid) {
  1989.       struct stat sbuf;
  1991.       fs_stat(dir,&sbuf);
  1992.       if(chown(dir,(uid_t)-1,(gid_t)session.fsgid) == -1)
  1993.         log_pri(LOG_WARNING,"chown() failed: %s",strerror(errno));
  1994.       else
  1995.         chmod(dir,sbuf.st_mode);
  1996.     }
  1997.     add_response(R_257,""%s" - directory successfully created.",
  1998.                   quote_dir(cmd,dir));
  1999.   }
  2000.     
  2001.   return HANDLED(cmd);
  2002. }
  2004. MODRET cmd_cwd(cmd_rec *cmd)
  2005. {
  2006.   
  2007.   if(cmd->argc < 2) {
  2008.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2009.     return ERROR(cmd);
  2010.   }
  2012.   return _chdir(cmd,cmd->arg);
  2013. }
  2015. MODRET cmd_cdup(cmd_rec *cmd)
  2016. {
  2017.   if(cmd->argc != 1) {
  2018.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2019.     return ERROR(cmd);
  2020.   }
  2022.   return _chdir(cmd,"..");
  2023. }
  2025. /* Returns the modification time of a file.  This is not in RFC959,
  2026.  * but supposedly will be in the future.  Command/response:
  2027.  * - MDTM <sp> path-name <crlf>
  2028.  * - 213 <sp> YYYYMMDDHHMMSS <crlf>
  2029.  *
  2030.  * We return the time as GMT, not localtime.  WU-ftpd returns localtime,
  2031.  * which seems like a Bad Thing<tm> to me.  However, my reasoning might
  2032.  * not be correct.
  2033.  */
  2035. MODRET cmd_mdtm(cmd_rec *cmd)
  2036. {
  2037.   char *path;
  2038.   char buf[16];
  2039.   struct tm *tm;
  2040.   struct stat sbuf;
  2041.   
  2042.   if(cmd->argc < 2) {
  2043.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2044.     return ERROR(cmd);
  2045.   }
  2047.   path = dir_realpath(cmd->tmp_pool,cmd->arg);
  2049.   if(!path || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,path,NULL) ||
  2050.      fs_stat(path,&sbuf) == -1) {
  2051.     add_response_err(R_550,"%s: %s",cmd->argv[1],strerror(errno));
  2052.     return ERROR(cmd);
  2053.   } else {
  2054.     if(!S_ISREG(sbuf.st_mode)) {
  2055.       add_response_err(R_550,"%s: not a plain file.",cmd->argv[1]);
  2056.       return ERROR(cmd);
  2057.     } else {
  2058.       tm = gmtime(&sbuf.st_mtime);
  2059.       if(tm)
  2060.         snprintf(buf, sizeof(buf), "%04d%02d%02d%02d%02d%02d",
  2061.                 tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,
  2062.                 tm->tm_hour,tm->tm_min,tm->tm_sec);
  2063.       else
  2064.         snprintf(buf, sizeof(buf), "00000000000000");        
  2065.       add_response(R_213,"%s",buf);
  2066.     }
  2067.   }
  2069.   return HANDLED(cmd);
  2070. }
  2072. MODRET cmd_size(cmd_rec *cmd)
  2073. {
  2074.   char *path;
  2075.   struct stat sbuf;
  2076.   unsigned long st_size;
  2078.   if(cmd->argc < 2) {
  2079.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2080.     return ERROR(cmd);
  2081.   }
  2083.   path = dir_realpath(cmd->tmp_pool,cmd->arg);
  2085.   if(!path || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,path,NULL) ||
  2086.       fs_stat(path,&sbuf) == -1) {
  2087.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  2088.     return ERROR(cmd);
  2089.   } else {
  2090.     if(!S_ISREG(sbuf.st_mode)) {
  2091.       add_response_err(R_550,"%s: not a regular file.",cmd->arg);
  2092.       return ERROR(cmd);
  2093.     } else {
  2094.       st_size = sbuf.st_size;
  2095. #if 0
  2096.       /* This code disabled in 1.1.6pl2, it allowed a possible DoS when sizeing
  2097.        * large files in ascii mode.
  2098.        */
  2099.       if(session.flags & (SF_ASCII|SF_ASCII_OVERRIDE)) {
  2100.         int fd,cnt;
  2101. char buf[4096];
  2103.         if((fp = fs_open(path,O_RDONLY,&fd)) != NULL) {
  2104.           st_size = 0;
  2105.           while((cnt = fs_read(fp,fd,buf,sizeof(buf))) > 0) {
  2106.             st_size += cnt;
  2107.             while(cnt--)
  2108.               if(buf[cnt] == 'n') st_size++;
  2109.           }
  2110.           
  2111.           fs_close(fp,fd);
  2112.         }
  2113.       }
  2114. #endif
  2115.       add_response(R_213,"%lu",st_size);
  2116.     }
  2117.   }
  2119.   return HANDLED(cmd);
  2120. }
  2122. MODRET cmd_dele(cmd_rec *cmd)
  2123. {
  2124.   char *path;
  2125. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  2126.   regex_t *preg;
  2127. #endif
  2129.   if(cmd->argc < 2) {
  2130.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2131.     return ERROR(cmd);
  2132.   }
  2134. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  2135.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathAllowFilter",FALSE);
  2137.   if(preg && regexec(preg,cmd->arg,0,NULL,0) != 0) {
  2138.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  2139.     return ERROR(cmd);
  2140.   }
  2142.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathDenyFilter",FALSE);
  2144.   if(preg && regexec(preg,cmd->arg,0,NULL,0) == 0) {
  2145.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  2146.     return ERROR(cmd);
  2147.   }
  2148. #endif
  2150.   path = dir_realpath(cmd->tmp_pool,cmd->arg);
  2151.   if(!path || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,path,NULL) ||
  2152.      fs_unlink(path) == -1) {
  2153.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  2154.     return ERROR(cmd);
  2155.   }
  2156.   
  2157.   if(session.flags & SF_ANON) {
  2158.     log_xfer(0, session.c->remote_name, 0,
  2159.      path, (session.flags & SF_ASCII ? 'a' : 'b'),
  2160.      'd', 'a', session.anon_user);
  2161.   } else {
  2162.     log_xfer(0,session.c->remote_name, 0, path,
  2163.      (session.flags & SF_ASCII ? 'a' : 'b'),
  2164.      'd', 'r', session.user);
  2165.   }
  2166.   
  2167.   add_response(R_250,"%s command successful.",cmd->argv[0]);
  2168.   return HANDLED(cmd);
  2169. }
  2171. MODRET cmd_rnto(cmd_rec *cmd)
  2172. {
  2173.   char *path;
  2174. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  2175.   regex_t *preg;
  2176. #endif
  2178.   if(cmd->argc < 2) {
  2179.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2180.     return ERROR(cmd);
  2181.   }
  2183.   if(!session.xfer.path) {
  2184.     if(session.xfer.p) {
  2185.       destroy_pool(session.xfer.p);
  2186.       bzero(&session.xfer,sizeof(session.xfer));
  2187.     }
  2189.     add_response_err(R_503,"Bad sequence of commands.");
  2190.     return ERROR(cmd);
  2191.   }
  2193. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  2194.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathAllowFilter",FALSE);
  2196.   if(preg && regexec(preg,cmd->arg,0,NULL,0) != 0) {
  2197.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  2198.     return ERROR(cmd);
  2199.   }
  2201.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathDenyFilter",FALSE);
  2203.   if(preg && regexec(preg,cmd->arg,0,NULL,0) == 0) {
  2204.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  2205.     return ERROR(cmd);
  2206.   }
  2207. #endif
  2209.   path = dir_canonical_path(cmd->tmp_pool,cmd->arg);
  2211.   if(!path || !dir_check_canon(cmd->tmp_pool,cmd->argv[0],cmd->group,path,NULL) 
  2212.      || rename(session.xfer.path,path) == -1) {
  2213.     add_response_err(R_550,"rename: %s",strerror(errno));
  2214.     destroy_pool(session.xfer.p);
  2215.     bzero(&session.xfer,sizeof(session.xfer));
  2216.     return ERROR(cmd);
  2217.   }
  2219.   add_response(R_250,"rename successful.");
  2220.   destroy_pool(session.xfer.p);
  2221.   bzero(&session.xfer,sizeof(session.xfer));
  2222.   return HANDLED(cmd);
  2223. }
  2225. MODRET cmd_rnfr(cmd_rec *cmd)
  2226. {
  2227.   char *path;
  2228. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  2229.   regex_t *preg;
  2230. #endif
  2232.   if(cmd->argc < 2) {
  2233.     add_response_err(R_500,"'%s' is an unknown command.",get_full_cmd(cmd));
  2234.     return ERROR(cmd);
  2235.   }
  2237. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  2238.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathAllowFilter",FALSE);
  2240.   if(preg && regexec(preg,cmd->arg,0,NULL,0) != 0) {
  2241.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  2242.     return ERROR(cmd);
  2243.   }
  2245.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathDenyFilter",FALSE);
  2247.   if(preg && regexec(preg,cmd->arg,0,NULL,0) == 0) {
  2248.     add_response_err(R_550,"%s: Forbidden filename",cmd->arg);
  2249.     return ERROR(cmd);
  2250.   }
  2251. #endif
  2253.   path = dir_realpath(cmd->tmp_pool,cmd->arg);
  2255.   if(!path || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,path,NULL) ||
  2256.      !exists(path)) {
  2257.     add_response_err(R_550,"%s: %s",cmd->argv[1],strerror(errno));
  2258.     return ERROR(cmd);
  2259.   }
  2261.   /* We store the path in session.xfer.path */
  2262.   if(session.xfer.p) {
  2263.     destroy_pool(session.xfer.p);
  2264.     bzero(&session.xfer,sizeof(session.xfer));
  2265.   }
  2267.   session.xfer.p = make_sub_pool(session.pool);
  2268.   session.xfer.path = pstrdup(session.xfer.p,path);
  2269.   add_response(R_350,"File or directory exists, ready for destination name.");
  2271.   return HANDLED(cmd);
  2272. }
  2274. MODRET cmd_site(cmd_rec *cmd)
  2275. {
  2276.   char *cp;
  2278.   cmd->argc--;
  2279.   cmd->argv++;
  2281.   if(cmd->argc)
  2282.     for(cp = cmd->argv[0]; *cp; cp++)
  2283.       *cp = toupper(*cp);
  2285.   return call_module(&site_module,site_dispatch,cmd);
  2286. }
  2288. MODRET cmd_noop(cmd_rec *cmd)
  2289. {
  2290.   add_response(R_200,"NOOP command successful.");
  2291.   return HANDLED(cmd);
  2292. }
  2294. MODRET set_defaulttransfermode(cmd_rec *cmd)
  2295. {                                               
  2296.   config_rec *c;
  2298.   CHECK_ARGS(cmd,1);
  2299.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  2301.   if (strcasecmp(cmd->argv[1], "ascii") != 0 && strcasecmp(cmd->argv[1], "binary") != 0) {
  2302. CONF_ERROR(cmd, "parameter must be 'ascii' or 'binary'.");
  2303.   } else
  2304.    c = add_config_param_str("DefaultTransferMode", 1, cmd->argv[1]);
  2306.   c->flags |= CF_MERGEDOWN;
  2307.   return HANDLED(cmd);
  2308. }
  2310. MODRET set_classes(cmd_rec *cmd)
  2311. {
  2312.   int b;
  2313.   config_rec *c;
  2315.   CHECK_ARGS(cmd,1);
  2316.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  2318.   b = get_boolean(cmd,1);
  2319.   if (b == -1)
  2320.     CONF_ERROR(cmd, "requires a boolean value");
  2322.   c = add_config_param("Classes",1,(void*)b);
  2323.   c->flags |= CF_MERGEDOWN;
  2324.   return HANDLED(cmd);
  2325. }
  2327. static cdir_t *cdir_list = NULL;
  2328. static class_t *class_list = NULL;
  2330. static cdir_t *add_cdir(class_t *class, u_int_32 address, u_int_8 netmask)
  2331. {
  2332. cdir_t *n;
  2334. n = calloc(1, sizeof(cdir_t));
  2336. n->class = class;
  2337. while (netmask--) {
  2338. n->netmask >>= 1;
  2339. n->netmask |= 0x80000000;
  2340. }
  2341. n->address = address & n->netmask;
  2343. n->next = cdir_list;
  2344. cdir_list = n;                 
  2346. return n;
  2347. }
  2349. static cdir_t *find_cdir(u_int_32 address)
  2350. {
  2351. cdir_t *c, *f;
  2353. c = cdir_list;
  2354. f = NULL;
  2355. while (c) {
  2356. /* within cdir range ? && more specific netmask ? */
  2357. if (((address & c->netmask) == c->address) && (f == NULL || (f && (f->netmask < c->netmask))))
  2358. f = c;
  2360. c = c->next;
  2361. }
  2362. return f;
  2363. }
  2365. static class_t *add_class(char *name)
  2366. {
  2367. class_t *n;
  2369. n = calloc(1, sizeof(class_t));
  2371. n->name = strdup(name);
  2372. n->max_connections = 100;
  2374. n->next = class_list;
  2375. class_list = n;                 
  2377. return n;
  2378. }
  2380. static class_t *get_class(char *name)
  2381. {
  2382. class_t *c;
  2384. c = class_list;
  2385. while (c) {
  2386. if (name && strcmp(name, c->name) == 0)
  2387. return c;
  2389. c = c->next;
  2390. }
  2391. return NULL;
  2392. }
  2394. class_t *find_class(p_in_addr_t *addr, char *remote_name)
  2395. {
  2396. cdir_t *ip;
  2397. class_t *c, *f;
  2399. if ((ip = find_cdir(ntohl(addr->s_addr))) != NULL)
  2400. return ip->class;
  2402. c = class_list;
  2403. f = NULL;
  2404. while (c) {
  2405. if (c->preg && (regexec(c->preg, remote_name, 0, NULL, 0)) == 0) 
  2406. if (f == NULL || (f && f->max_connections < c->max_connections))
  2407. f = c;
  2408. c = c->next;
  2409. }
  2410. if (f)
  2411. return f;
  2412. else
  2413. return get_class("default");
  2414. }
  2416. MODRET set_class(cmd_rec *cmd)
  2417. {
  2418.   int bits, ret;
  2419.   class_t *n;
  2420.   regex_t *preg;
  2421.   p_in_addr_t *res;
  2422.   char *ptr, ipaddress[20], errmsg[80];
  2424.   CHECK_ARGS(cmd,3);
  2425.   CHECK_CONF(cmd,CONF_ROOT);
  2427.   /* setup "default" class if necesarry */
  2428.   if((n = get_class("default")) == NULL)
  2429.     n = add_class("default");
  2430.   
  2431.   /* find class, add if necessary */
  2432.   if((n = get_class(cmd->argv[1])) == NULL)
  2433.     n = add_class(cmd->argv[1]);
  2434.   
  2435.   /* what to do ? */
  2436.   if(strcasecmp(cmd->argv[2], "limit") == 0) {
  2437.     ret = atoi(cmd->argv[3]);
  2438.     if (ret < 0)
  2439.       ret = 100;
  2440.     n->max_connections = ret;
  2441.     log_debug(DEBUG4, "class '%s' maxconnections set to %d",
  2442.       n->name, n->max_connections);
  2443.   } else if (strcasecmp(cmd->argv[2], "regex") == 0) {
  2444.     preg = calloc(1, sizeof(regex_t));
  2445.     
  2446.     if((ret = regcomp(preg, cmd->argv[3],
  2447.       REG_EXTENDED|REG_NOSUB|REG_ICASE)) != 0) {
  2448.       regerror(ret, preg, errmsg, sizeof(errmsg));
  2449.       regfree(preg);
  2450.       
  2451.       n->preg = NULL;
  2452.       log_pri(LOG_ERR, "failed regexp '%s' compilation: ", cmd->argv[3]);
  2453.     } else {
  2454.       n->preg = preg;
  2455.     }
  2456.   } else if(strcasecmp(cmd->argv[2], "ip") == 0) {
  2457.     sstrncpy(ipaddress, cmd->argv[3], sizeof(ipaddress));
  2458.     if((ptr = strchr(ipaddress, '/')) == NULL) {
  2459.       log_pri(LOG_ERR, "class '%s' ipmask %s skipped.",
  2460.       cmd->argv[1], cmd->argv[3]);
  2461.       CONF_ERROR(cmd, "wrong syntax error.");
  2462.     } else {
  2463.       bits = atol(ptr + 1);
  2464.       
  2465.       if (bits < 0 || bits > 32) {
  2466. log_pri(LOG_ERR, "class '%s' ipmask %s skipped: wrong netmask",
  2467. cmd->argv[1], cmd->argv[3]);
  2468.       }
  2469.       
  2470.       *ptr = 0;
  2471.     }
  2472.     
  2473.     if((res = inet_getaddr(cmd->pool, ipaddress)) != NULL) {
  2474.       add_cdir(n, ntohl(res->s_addr), bits);
  2475.       log_debug(DEBUG4, "class '%s' ipmask %p/%d added.",
  2476. cmd->argv[1], res, bits);
  2477.     } else {
  2478.       log_pri(LOG_ERR, "Class '%s' ip could not parse '%s'",
  2479.       cmd->argv[1], cmd->argv[3]);
  2480.     }
  2481.   } else {
  2482.     CONF_ERROR(cmd, "unknown argument.");
  2483.   }
  2484.   
  2485.   return HANDLED(cmd);
  2486. }
  2488. /* Configuration directive table */
  2490. static conftable core_conftable[] = {
  2491.   { "ServerName", set_servername,  NULL },
  2492.   { "ServerIdent", set_serverident, NULL },
  2493.   { "ServerType", set_servertype, NULL },
  2494.   { "ServerAdmin", set_serveradmin, NULL },
  2495.   { "UseReverseDNS", set_usereversedns, NULL },
  2496.   { "ScoreboardPath", set_scoreboardpath, NULL },
  2497.   { "TransferLog", add_transferlog, NULL },
  2498.   { "WtmpLog", set_wtmplog, NULL },
  2499.   { "Bind", add_bind, NULL },
  2500.   { "Port", set_serverport,  NULL },
  2501.   { "SocketBindTight", set_socketbindtight, NULL },
  2502.   { "IdentLookups", set_identlookups, NULL },
  2503.   { "tcpBackLog", set_tcpbacklog, NULL },
  2504.   { "tcpReceiveWindow", set_tcpreceivewindow, NULL },
  2505.   { "tcpSendWindow", set_tcpsendwindow, NULL },
  2506.   { "tcpNoDelay", set_tcpnodelay, NULL },
  2507.   { "DeferWelcome", set_deferwelcome, NULL },
  2508.   { "DefaultServer", set_defaultserver, NULL },
  2509.   { "MultilineRFC2228", set_multilinerfc2228, NULL },
  2510.   { "User", set_user, NULL },
  2511.   { "Group", set_group,  NULL },
  2512.   { "UserPassword", add_userpassword, NULL },
  2513.   { "GroupPassword", add_grouppassword, NULL },
  2514.   { "Umask", set_umask, NULL },
  2515.   { "MaxLoginAttempts", set_maxloginattempts, NULL },
  2516.   { "MaxClients", set_maxclients, NULL },
  2517.   { "MaxClientsPerHost", set_maxhostclients, NULL },
  2518.   { "MaxInstances", set_maxinstances, NULL },
  2519.   { "RequireValidShell", set_requirevalidshell, NULL },
  2520.   { "ShowSymlinks", set_showsymlinks, NULL },
  2521.   { "SyslogFacility", set_syslogfacility, NULL },
  2522.   { "TimeoutLogin", set_timeoutlogin, NULL },
  2523.   { "TimeoutIdle", set_timeoutidle, NULL },
  2524.   { "TimeoutNoTransfer", set_timeoutnoxfer, NULL },
  2525.   { "TimeoutStalled", set_timeoutstalled, NULL },
  2526.   { "UseFtpUsers", set_useftpusers, NULL },
  2527.   { "AccessGrantMsg", set_accessgrantmsg, NULL },
  2528.   { "AnonymousGroup", add_anonymousgroup, NULL },
  2529.   { "<VirtualHost>", add_virtualhost, NULL },
  2530.   { "</VirtualHost>", end_virtualhost, NULL },
  2531.   { "<Directory>", add_directory, NULL },
  2532.   { "CDPath", add_cdpath, NULL },
  2533.   { "HideNoAccess", add_hidenoaccess, NULL },
  2534.   { "HideUser", add_hideuser, NULL },
  2535.   { "HideGroup", add_hidegroup, NULL },
  2536.   { "GroupOwner", add_groupowner, NULL },
  2537.   { "AllowOverwrite", set_allowoverwrite, NULL },
  2538.   { "HiddenStor", set_hiddenstor, NULL },
  2539.   { "DisplayFirstChdir", set_displayfirstchdir, NULL },
  2540.   { "AuthAliasOnly", set_authaliasonly, NULL },
  2541.   { "AllowRetrieveRestart", set_allowretrieverestart, NULL },
  2542.   { "AllowStoreRestart", set_allowstorerestart, NULL },
  2543.   { "</Directory>", end_directory, NULL },
  2544.   { "<Limit>", add_limit, NULL },
  2545.   { "IgnoreHidden", set_ignorehidden, NULL },
  2546.   { "Order", add_order, NULL },
  2547.   { "Allow", add_allow, NULL },
  2548.   { "Deny", add_deny, NULL },
  2549.   { "AllowGroup", add_allowgroup, NULL },
  2550.   { "DenyGroup", add_denygroup, NULL },
  2551.   { "AllowUser", add_allowuser, NULL },
  2552.   { "DenyUser", add_denyuser, NULL },
  2553.   { "AllowAll", set_allowall, NULL },
  2554.   { "DenyAll", set_denyall, NULL },
  2555.   { "</Limit>",  end_limit,  NULL },
  2556.   { "DisplayLogin", set_displaylogin, NULL },
  2557.   { "DisplayConnect", set_displayconnect, NULL },
  2558.   { "DisplayQuit", set_displayquit, NULL },
  2559.   { "DisplayGoAway", set_displaygoaway, NULL },
  2560.   { "<Anonymous>", add_anonymous, NULL },
  2561.   { "UserAlias", add_useralias,  NULL },
  2562.   { "AnonRequirePassword", set_anonrequirepassword, NULL },
  2563.   { "CommandBufferSize", set_commandbuffersize, NULL },
  2564.   { "AllowFilter", set_allowfilter, NULL },
  2565.   { "DenyFilter", set_denyfilter, NULL },
  2566.   { "PathAllowFilter", set_pathallowfilter, NULL },
  2567.   { "PathDenyFilter", set_pathdenyfilter, NULL },
  2568.   { "AllowForeignAddress", set_allowforeignaddress, NULL },
  2569.   { "</Anonymous>", end_anonymous, NULL },
  2570.   { "<Global>", add_global, NULL },
  2571.   { "</Global>", end_global, NULL },
  2572.   { "DefaultTransferMode", set_defaulttransfermode, NULL },
  2573.   { "Class", set_class, NULL },
  2574.   { "Classes", set_classes, NULL },
  2575.   { NULL, NULL, NULL }
  2576. };
  2578. cmdtable core_commands[] = {
  2579.   { CMD, C_HELP, G_NONE,  cmd_help, FALSE, FALSE, CL_INFO },
  2580.   { CMD, C_PORT, G_NONE,  cmd_port, TRUE, FALSE, CL_MISC },
  2581.   { CMD, C_PASV, G_NONE,  cmd_pasv, TRUE, FALSE, CL_MISC },
  2582.   { CMD, C_SYST, G_NONE,  cmd_syst, TRUE, FALSE, CL_INFO },
  2583.   { CMD, C_PWD,  G_NONE,  cmd_pwd, TRUE, FALSE, CL_INFO|CL_DIRS },
  2584.   { CMD, C_XPWD, G_NONE,  cmd_pwd, TRUE, FALSE, CL_INFO|CL_DIRS },
  2585.   { CMD, C_CWD,  G_DIRS,  cmd_cwd, TRUE, FALSE, CL_DIRS },
  2586.   { CMD, C_XCWD, G_DIRS,  cmd_cwd, TRUE, FALSE, CL_DIRS },
  2587.   { CMD, C_MKD,  G_WRITE, cmd_mkd, TRUE, FALSE, CL_DIRS|CL_WRITE },
  2588.   { CMD, C_XMKD, G_WRITE, cmd_mkd, TRUE, FALSE, CL_DIRS|CL_WRITE },
  2589.   { CMD, C_RMD,  G_WRITE, cmd_rmd, TRUE, FALSE, CL_DIRS|CL_WRITE },
  2590.   { CMD, C_XRMD, G_WRITE, cmd_rmd, TRUE, FALSE, CL_DIRS|CL_WRITE },
  2591.   { CMD, C_CDUP, G_DIRS,  cmd_cdup, TRUE, FALSE, CL_DIRS },
  2592.   { CMD, C_XCUP, G_DIRS,  cmd_cdup, TRUE, FALSE, CL_DIRS },
  2593.   { CMD, C_SITE, G_NONE,  cmd_site, TRUE, FALSE, CL_MISC },
  2594.   { CMD, C_DELE, G_WRITE, cmd_dele, TRUE, FALSE, CL_WRITE },
  2595.   { CMD, C_MDTM, G_DIRS,  cmd_mdtm, TRUE, FALSE, CL_INFO },
  2596.   { CMD, C_RNFR, G_DIRS,  cmd_rnfr, TRUE, FALSE, CL_MISC },
  2597.   { CMD, C_RNTO, G_WRITE, cmd_rnto, TRUE, FALSE, CL_MISC },
  2598.   { CMD, C_SIZE, G_READ,  cmd_size, TRUE, FALSE, CL_INFO },
  2599.   { CMD, C_QUIT, G_NONE,  cmd_quit, FALSE, TRUE,  CL_INFO },
  2600.   { CMD, C_NOOP, G_NONE,  cmd_noop, FALSE, TRUE,  CL_MISC },
  2601.   { 0, NULL }
  2602. };
  2604. /* Module interface */
  2606. module core_module = {
  2607.   NULL,NULL, /* always NULL */
  2608.   0x20, /* API Version 2.0 */
  2609.   "core",
  2610.   core_conftable,
  2611.   core_commands,
  2612.   NULL,
  2613.   NULL,NULL                    /* No initialization needed */
  2614. };