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

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

Ftp客户端

开发平台：

Unix_Linux

mod_auth.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.  * Authentication module for ProFTPD
  23.  * $Id: mod_auth.c,v 1.12 1999/10/01 07:57:31 macgyver Exp $
  24.  */
  26. #include "conf.h"
  28. #include "privs.h"
  30. /* From the core module */
  31. extern int core_display_file(const char *,const char *);
  32. extern pid_t mpid;
  34. module auth_module;
  36. static int logged_in = 0;
  37. static int auth_tries = 0;
  39. /* check_auth is hooked into the main server's auth_hook function,
  40.  * so that we can deny all commands until authentication is complete.
  41.  */
  43. int check_auth(cmd_rec *cmd)
  44. {
  45.   if(get_param_int(cmd->server->conf,"authenticated",FALSE) != 1) {
  46.     send_response(R_530,"Please login with USER and PASS.");
  47.     return FALSE;
  48.   }
  50.   return TRUE;
  51. }
  53. int _auth_shutdown(CALLBACK_FRAME)
  54. {
  55.   log_pri(LOG_ERR,"scheduled main_exit() never ran [from auth:_login_timeout], terminating.");
  56.   end_login(1);
  57.   return 0; /* Avoid compiler warning */
  58. }
  60. /* As for 1.2.0, timer callbacks are now non-reentrant, so it's
  61.  * safe to call main_exit()
  62.  */
  64. int _login_timeout(CALLBACK_FRAME)
  65. {
  66.   /* Is this the proper behavior when timing out? */
  67.   send_response_async(R_421,"Login Timeout (%d seconds): closing control connection.",
  68.                       TimeoutLogin);
  69.   main_exit((void*)LOG_NOTICE,"FTP login timed out, disconnected.",
  70.   (void*)0,NULL);
  72. /*
  73.   schedule(main_exit,0,(void*)LOG_NOTICE,"FTP login timed out, disconnected.",
  74.            (void*)0,NULL);
  75.   remove_timer(TIMER_IDLE,ANY_MODULE);
  76.   remove_timer(TIMER_NOXFER,ANY_MODULE);
  77.   add_timer(10,-1,&auth_module,_auth_shutdown);
  78. */
  80. /* should never be reached */
  81.   return 0; /* Don't restart the timer */
  82. }
  84. int auth_init_child()
  85. {
  86.   /* Start the login timer */
  87.   if(TimeoutLogin)
  88.     add_timer(TimeoutLogin,TIMER_LOGIN,&auth_module,_login_timeout);
  89.   return 0;
  90. }
  92. int auth_init()
  93. {
  94.   /* By default, enable auth checking */
  95.   set_auth_check(check_auth);
  96.   return 0;
  97. }
  99. static int _do_auth(pool *p, xaset_t *conf, char *u, char *pw)
  100. {
  101.   char *cpw = NULL;
  102.   config_rec *c;
  104.   if(conf) {
  105.     c = find_config(conf,CONF_PARAM,"UserPassword",FALSE);
  107.     while(c) {
  108.       if(!strcmp(c->argv[0],u)) {
  109.         cpw = (char*)c->argv[1];
  110.         break;
  111.       }
  113.       c = find_config_next(c,c->next,CONF_PARAM,"UserPassword",FALSE);
  114.     }
  115.   }
  118.   if(cpw) {
  119.     if(!auth_getpwnam(p,u))
  120.       return AUTH_NOPWD;
  121.     return auth_check(p,cpw,u,pw);
  122.   }
  124.   return auth_authenticate(p,u,pw);
  125. }
  127. /* Handle group based authentication, only checked if pw
  128.  * based fails
  129.  */
  131. static config_rec *_auth_group(pool *p, char *user, char **group,
  132.                                char **ournamep, char **anonnamep, char *pass)
  133. {
  134.   config_rec *c;
  135.   char *ourname = NULL,*anonname = NULL;
  136.   char **grmem;
  137.   struct group *grp;
  139.   ourname = (char*)get_param_ptr(main_server->conf,"UserName",FALSE);
  140.   if(ournamep && ourname)
  141.     *ournamep = ourname;
  143.   c = find_config(main_server->conf,CONF_PARAM,"GroupPassword",TRUE);
  145.   if(c) do {
  146.     grp = auth_getgrnam(p,c->argv[0]);
  148.     if(!grp)
  149.       continue;
  151.     for(grmem = grp->gr_mem; *grmem; grmem++)
  152.       if(!strcmp(*grmem,user)) {
  153.         if(auth_check(p,c->argv[1],user,pass) == 0)
  154.           break;
  155.       }
  157.     if(*grmem) {
  158.       if(group)
  159.         *group = c->argv[0];
  161.       if(c->parent)
  162.         c = c->parent;
  164.       if(c->config_type == CONF_ANON)
  165.         anonname = (char*)get_param_ptr(c->subset,"UserName",FALSE);
  166.       if(anonnamep)
  167.         *anonnamep = anonname;
  168.       if(anonnamep && !anonname && ourname)
  169.         *anonnamep = ourname;
  170.       
  171.       break;
  172.     }
  173.   } while((c = find_config_next(c,c->next,CONF_PARAM,"GroupPassword",TRUE)) != NULL);
  175.   return c;
  176. }
  178. static void build_group_arrays(pool *p, struct passwd *xpw, char *name,
  179.                             array_header **gids, array_header **groups)
  180. {
  181.   struct group *gr;
  182.   struct passwd *pw = xpw;
  183.   array_header *xgids,*xgroups;
  184.   char **gr_mem;
  186.   xgids = make_array(p,2,sizeof(int));
  187.   xgroups = make_array(p,2,sizeof(char*));
  189.   if(!pw && !name)
  190.     return;
  192.   if(!pw) {
  193.     pw = auth_getpwnam(p,name);
  195.     if(!pw)
  196.       return;
  197.   }
  199.   if((gr = auth_getgrgid(p,pw->pw_gid)) != NULL)
  200.     *((char**)push_array(xgroups)) =
  201.                          pstrdup(p,gr->gr_name);
  203.   auth_setgrent(p);
  205.   while((gr = auth_getgrent(p)) != NULL && gr->gr_mem)
  206.     for(gr_mem = gr->gr_mem; *gr_mem; gr_mem++) {
  207.       if(!strcmp(*gr_mem,pw->pw_name)) {
  208.         *((int*)push_array(xgids)) = (int)gr->gr_gid;
  209.         if(pw->pw_gid != gr->gr_gid)
  210.           *((char**)push_array(xgroups)) =
  211.                          pstrdup(p,gr->gr_name);
  212.         break;
  213.       }
  214.     }
  216.   *gids = xgids;
  217.   *groups = xgroups;
  218. }
  220. static int _init_groups(pool *p, gid_t addl_group)
  221. {
  222.   gid_t *gid_arr;
  223.   int i,*session_gids;
  224.   size_t ngids = session.gids->nelts;
  226.   session_gids = session.gids->elts;
  227.   gid_arr = palloc(p,sizeof(gid_t) * (ngids+1));
  229.   for(i = 0; i < ngids; i++)
  230.     gid_arr[i] = (gid_t)session_gids[i];
  231.   
  232.   gid_arr[i] = addl_group;
  234.   return setgroups(ngids+1,gid_arr);
  235. }
  237. static config_rec *_auth_anonymous_group(pool *p, char *user)
  238. {
  239.   config_rec *c;
  240.   int ret = 0;
  242.   build_group_arrays(p,NULL,user,&session.gids,&session.groups);
  243.   c = find_config(main_server->conf,CONF_PARAM,"AnonymousGroup",FALSE);
  245.   if(c) do {
  246.     ret = group_expression((char**)c->argv);
  247.   } while(!ret && (c = find_config_next(c,c->next,CONF_PARAM,"AnonymousGroup",FALSE)) != NULL);
  248.  
  249.   return ret ? c : NULL;
  250. }
  252. static config_rec *_auth_resolve_user(pool *p,char **user,
  253.                                       char **ournamep,
  254.                                       char **anonnamep)
  255. {
  256.   config_rec *c,*topc;
  257.   char *ourname,*anonname = NULL;
  258.   int is_alias = 0, force_anon = 0;
  260.   /* Precendence rules:
  261.    *   1. Search for UserAlias directive.
  262.    *   2. Search for Anonymous directive.
  263.    *   3. Normal user login
  264.    */
  266.   ourname = (char*)get_param_ptr(main_server->conf,"UserName",FALSE);
  268.   if(ournamep && ourname)
  269.     *ournamep = ourname; 
  271.   c = find_config(main_server->conf,CONF_PARAM,"UserAlias",TRUE);
  272.   if(c) do {
  273.     if(!strcmp(c->argv[0], "*") || !strcmp(c->argv[0],*user)) {
  274.       is_alias = 1;
  275.       break;
  276.     }  
  277.   } while((c = find_config_next(c,c->next,CONF_PARAM,"UserAlias",TRUE)) != NULL);
  279.   /* if AuthAliasOnly is set, ignore this one and continue */
  280.   topc = c;
  282.   while(c && c->parent &&
  283.              find_config(c->parent->set,CONF_PARAM,"AuthAliasOnly",FALSE)) {
  284.     is_alias = 0;
  285.     find_config_set_top(topc);
  286.     c = find_config_next(c,c->next,CONF_PARAM,"UserAlias",TRUE);
  287.     if(c && (!strcmp(c->argv[0],"*") || !strcmp(c->argv[0],*user)))
  288.       is_alias = 1;
  289.   }
  291.   if(c) {
  292.     *user = c->argv[1];
  294.     /* If the alias is applied inside an <Anonymous> context, we have found
  295.      * our anon block
  296.      */
  298.     if(c->parent && c->parent->config_type == CONF_ANON)
  299.       c = c->parent;
  300.     else
  301.       c = NULL;
  302.   }
  304.   /* Next, search for an anonymous entry */
  306.   if(!c)
  307.     c = find_config(main_server->conf,CONF_ANON,NULL,FALSE);
  308.   else
  309.     find_config_set_top(c);
  311.   if(c) do {
  312.     anonname = (char*)get_param_ptr(c->subset,"UserName",FALSE);
  313.     if(!anonname)
  314.       anonname = ourname;
  316.     if(anonname && !strcmp(anonname,*user)) {
  317.        if(anonnamep)
  318.          *anonnamep = anonname;
  319.        break;
  320.     }
  321.   } while((c = find_config_next(c,c->next,CONF_ANON,NULL,FALSE)) != NULL);
  323.   if(!c) {
  324.     c = _auth_anonymous_group(p,*user);
  326.     if(c)
  327.       force_anon = 1;
  328.   }
  330.   if(!is_alias && !force_anon) {
  331.     if(find_config((c ? c->subset :
  332.                    main_server->conf),CONF_PARAM,"AuthAliasOnly",FALSE)) {
  333.       
  334.       if(c && c->config_type == CONF_ANON)
  335.         c = NULL;
  336.       else
  337.         *user = NULL;
  339.       if(*user && find_config(main_server->conf,CONF_PARAM,"AuthAliasOnly",FALSE))
  340.         *user = NULL;
  342.       if((!user || !c) && anonnamep)
  343.         *anonnamep = NULL;
  344.     }
  345.   }
  347.   return c;
  348. }
  350. static int _auth_check_ftpusers(xaset_t *s, const char *user)
  351. {
  352.   int res = 1;
  353.   FILE *fp;
  354.   char *u,buf[256];
  356.   if(get_param_int(s,"UseFtpUsers",FALSE) != 0) {
  357.     PRIVS_ROOT
  358.     fp = fopen(FTPUSERS_PATH,"r");
  359.     PRIVS_RELINQUISH
  361.     if(!fp)
  362.       return res;
  364.     while(fgets(buf,sizeof(buf)-1,fp)) {
  365.       buf[sizeof(buf)-1] = ''; CHOP(buf);
  367.       u = buf; while(isspace((UCHAR)*u) && *u) u++;
  369.       if(!*u || *u == '#')
  370.         continue;
  372.       if(!strcmp(u,user)) {
  373.         res = 0;
  374.         break;
  375.       }
  376.     }
  378.     fclose(fp);
  379.   }
  381.   return res;
  382. }
  384. static int _auth_check_shell(xaset_t *s, const char *shell)
  385. {
  386.   int res = 1;
  387.   FILE *shellf;
  388.   char buf[256];
  390.   if(get_param_int(s,"RequireValidShell",FALSE) != 0 &&
  391.      (shellf = fopen(VALID_SHELL_PATH,"r")) != NULL) {
  392.     res = 0;
  393.     while(fgets(buf,sizeof(buf)-1,shellf)) {
  394.       buf[sizeof(buf)-1] = ''; CHOP(buf);
  396.       if(!strcmp(shell,buf)) {
  397.         res = 1;
  398.         break;
  399.       }
  400.     }
  402.     fclose(shellf);
  403.   }
  405.   return res;
  406. }
  408. /* Determine any applicable chdirs
  409.  */
  411. static char *_get_default_chdir(pool *p, xaset_t *conf)
  412. {
  413.   config_rec *c;
  414.   char *dir = NULL;
  415.   int ret;
  417.   c = find_config(conf,CONF_PARAM,"DefaultChdir",FALSE);
  419.   while(c) {
  420.     /* Check the groups acl */
  421.     if(c->argc < 2) {
  422.       dir = c->argv[0];
  423.       break;
  424.     }
  426.     ret = group_expression(((char**)c->argv)+1);
  428.     if(ret) {
  429.       dir = c->argv[0];
  430.       break;
  431.     }
  433.     c = find_config_next(c,c->next,CONF_PARAM,"DefaultChdir",FALSE);
  434.   }
  436.   /* if the directory is relative, concatenate w/ session.cwd
  437.    */
  439.   if(dir && *dir != '/' && *dir != '~')
  440.     dir = pdircat(p,session.cwd,dir,NULL);
  442.   return dir;
  443. }
  445. /* Determine if the user (non-anon) needs a default root dir
  446.  * other than /
  447.  */
  449. static char *_get_default_root(pool *p)
  450. {
  451.   config_rec *c;
  452.   char *dir = NULL;
  453.   int ret;
  455.   c = find_config(main_server->conf,CONF_PARAM,"DefaultRoot",FALSE);
  457.   while(c) {
  458.     /* Check the groups acl */
  459.     if(c->argc < 2) {
  460.       dir = c->argv[0];
  461.       break;
  462.     }
  464.     ret = group_expression(((char**)c->argv)+1);
  466.     if(ret) {
  467.       dir = c->argv[0];
  468.       break;
  469.     }
  471.     c = find_config_next(c,c->next,CONF_PARAM,"DefaultRoot",FALSE);
  472.   }
  474.   if(dir) {
  475.     if(!strcmp(dir,"/"))
  476.       dir = NULL;
  477.     else {
  478.       char *realdir;
  480.       realdir = dir_realpath(p,dir);
  482.       if(realdir)
  483.         dir = realdir;
  484.     }
  485.   }
  487.   return dir;
  488. }
  490. static struct passwd *passwd_dup(pool *p, struct passwd *pw)
  491. {
  492.   struct passwd *npw;
  493.       
  494.   npw = pcalloc(p,sizeof(struct passwd));
  495.    
  496.   npw->pw_name = pstrdup(p,pw->pw_name);
  497.   npw->pw_passwd = pstrdup(p,pw->pw_passwd);
  498.   npw->pw_uid = pw->pw_uid;
  499.   npw->pw_gid = pw->pw_gid;
  500.   npw->pw_gecos = pstrdup(p,pw->pw_gecos);
  501.   npw->pw_dir = pstrdup(p,pw->pw_dir);
  502.   npw->pw_shell = pstrdup(p,pw->pw_shell);
  503.       
  504.   return npw;
  505. }
  507. /* Next function (the biggie) handles all authentication, setting
  508.  * up chroot() jail, etc.
  509.  */
  511. static int _setup_environment(pool *p, char *user, char *pass)
  512. {
  513.   struct passwd *pw;
  514.   struct stat sbuf;
  515.   config_rec *c;
  516.   char *origuser,*ourname,*anonname = NULL,*anongroup = NULL,*ugroup = NULL;
  517.   char ttyname[20], *defaulttransfermode;
  518.   char *defroot = NULL,*defchdir = NULL,*xferlog = NULL;
  519.   int aclp,i,force_anon = 0,wtmp_log = -1,showsymlinks;
  521.   /********************* Authenticate the user here *********************/
  523.   session.hide_password = TRUE;
  525.   origuser = user;
  526.   c = _auth_resolve_user(p,&user,&ourname,&anonname);
  528.   if(!user) {
  529.     log_pri(LOG_NOTICE,"failed login from %s, '%s' is not a UserAlias.",inet_ascii(p,session.c->remote_ipaddr),origuser);
  530.     goto auth_failure;
  531.   }
  533.   /* If c != NULL from this point on, we have an anonymous login */
  534.   aclp = login_check_limits(main_server->conf,FALSE,TRUE,&i);
  536.   if((pw = auth_getpwnam(p,user)) == NULL) {
  537.     log_pri(LOG_NOTICE,"failed login from %s, can't find user '%s'",inet_ascii(p,session.c->remote_ipaddr),user);
  538.     goto auth_failure;
  539.   }
  541.   /* security: other functions perform pw lookups, thus we need to make
  542.    * a local copy of the user just looked up
  543.    */
  545.   pw = passwd_dup(p,pw);
  547.   if(pw->pw_uid == 0) {
  548.     /* If RootLogin is set to true, we allow this... even though we
  549.      * still log a warning. :)
  550.      */
  552.     if(get_param_int((c ? c->subset : main_server->conf),"RootLogin",FALSE) != 1) {
  553.       log_auth(LOG_CRIT,"SECURITY VIOLATION: root login attempted from %s [%s] to %s:%i",
  554.        session.c->remote_name,
  555.        inet_ascii(p,session.c->remote_ipaddr),
  556.        inet_ascii(p,session.c->local_ipaddr),
  557.        session.c->local_port);
  558.       return 0;
  559.     } else
  560.       log_auth(LOG_WARNING,"root login from %s [%s] to %s:%i",
  561.        session.c->remote_name,
  562.        inet_ascii(p,session.c->remote_ipaddr),
  563.        inet_ascii(p,session.c->local_ipaddr),
  564.        session.c->local_port);
  565.   }
  567.   session.user = pstrdup(p,pw->pw_name);
  568.   session.group = pstrdup(p,auth_gid_name(p,pw->pw_gid));
  570.   /* set force_anon (for AnonymousGroup) and build a custom
  571.    * anonymous config for this session.
  572.    */
  573.   if(c && c->config_type != CONF_ANON) {
  574.     force_anon = 1;
  576.     defroot = _get_default_root(session.pool);
  577.     if(!defroot)
  578.       defroot = pstrdup(session.pool,pw->pw_dir);
  580.     c = (config_rec*)pcalloc(session.pool,sizeof(config_rec));
  581.     c->config_type = CONF_ANON;
  582.     c->name = defroot;
  584.     anonname = pw->pw_name;
  586.     /* hackery, we trick everything else by pointing the subset
  587.      * at the main server's configuration.  tricky, eh?
  588.      */
  589.      c->subset = main_server->conf;
  590.   }
  592.   if(c) {
  593.     if(!force_anon) {
  594.         anongroup = (char*)get_param_ptr(c->subset,"GroupName",FALSE);
  595.       if(!anongroup)
  596.         anongroup = (char*)get_param_ptr(main_server->conf,"GroupName",FALSE);
  597.     }
  599.     if(!login_check_limits(c->subset,FALSE,TRUE,&i) || (!aclp && !i) ){
  600.       log_auth(LOG_NOTICE,"ANON %s: LIMIT access denies login from %s [%s] to %s:%i",
  601.                           origuser,
  602.                           session.c->remote_name,
  603.                           inet_ascii(p,session.c->remote_ipaddr),
  604.   inet_ascii(p,session.c->local_ipaddr),
  605.   session.c->local_port);
  606.       goto auth_failure;
  607.     }
  608.   }
  610.   if(!c && !aclp) {
  611.     log_auth(LOG_NOTICE,"USER %s: LIMIT access denies login from %s [%s] to %s:%i",
  612.              origuser,session.c->remote_name,
  613.              inet_ascii(p,session.c->remote_ipaddr),
  614.      inet_ascii(p,session.c->local_ipaddr),
  615.      session.c->local_port);
  616.     goto auth_failure;
  617.   }
  619.   if(!c || get_param_int(c->subset,"AnonRequirePassword",FALSE) == 1) {
  620.     int authcode;
  622.     if(c)
  623.       authcode = _do_auth(p,c->subset,user,pass);
  624.     else
  625.       authcode = _do_auth(p,main_server->conf,user,pass);
  627.     if(authcode) {
  628.       /* Normal authentication has failed, see if group authentication
  629.        * passes
  630.        */
  632.       if((c = _auth_group(p,user,&anongroup,&ourname,&anonname,pass)) != NULL) {
  633.         if(c->config_type != CONF_ANON) {
  634.           c = NULL;
  635.           ugroup = anongroup; anongroup = NULL;
  636.         }
  638.         authcode = 0;
  639.       }
  640.     }
  641.       
  642.     bzero(pass,strlen(pass));
  644.     switch(authcode) {
  645.     case AUTH_NOPWD:
  646.       log_auth(LOG_NOTICE,"USER %s: no such user found from %s [%s] to %s:%i",
  647.                user,session.c->remote_name,
  648.        inet_ascii(p,session.c->remote_ipaddr),
  649.        inet_ascii(p,session.c->local_ipaddr),
  650.        session.c->local_port);
  651.       break;
  652.     case AUTH_BADPWD:
  653.       log_auth(LOG_NOTICE,"USER %s: incorrect password from %s [%s] to %s:%i",
  654.                origuser,session.c->remote_name,
  655.        inet_ascii(p,session.c->remote_ipaddr),
  656.        inet_ascii(p,session.c->local_ipaddr),
  657.        session.c->local_port);
  658.       break;
  659.     case AUTH_AGEPWD:
  660.       log_auth(LOG_NOTICE,"USER %s: password expired from %s [%s] to %s:%i",
  661.        user,session.c->remote_name,
  662.        inet_ascii(p,session.c->remote_ipaddr),
  663.        inet_ascii(p,session.c->local_ipaddr),
  664.        session.c->local_port);
  665.       break;
  666.     case AUTH_DISABLEDPWD:
  667.       log_auth(LOG_NOTICE,"USER %s: account disabled from %s [%s] to %s:%i",
  668.        user,session.c->remote_name,
  669.        inet_ascii(p,session.c->remote_ipaddr),
  670.        inet_ascii(p,session.c->local_ipaddr),
  671.        session.c->local_port);
  672.       break;
  673.     };
  675.     if(authcode != 0)
  676.       goto auth_failure;
  677.   } else if(c)
  678.     session.hide_password = FALSE;
  680. /* Flood - 7/10/97, not sure what setutent() was used for, but it
  681.  * certainly looks unnecessary now.
  682.  */
  684.  /* setutent(); */
  686.   auth_setgrent(p);
  688.   if(!_auth_check_shell((c ? c->subset : main_server->conf),pw->pw_shell)) {
  689.     log_auth(LOG_NOTICE,"failed login '%s' from %s [%s] to %s:%i (invalid shell)",
  690.                user,session.c->remote_name,
  691.        inet_ascii(p,session.c->remote_ipaddr),
  692.        inet_ascii(p,session.c->local_ipaddr),
  693.        session.c->local_port);
  694.     goto auth_failure;
  695.   }
  697.   if(!_auth_check_ftpusers((c ? c->subset : main_server->conf),pw->pw_name)) {
  698.     log_auth(LOG_NOTICE,"failed login '%s' from %s [%s] to %s:%i (user in %s)",
  699.              pw->pw_name,session.c->remote_name,
  700.              inet_ascii(p,session.c->remote_ipaddr),
  701.      inet_ascii(p,session.c->local_ipaddr),
  702.      session.c->local_port,
  703.              FTPUSERS_PATH);
  704.     goto auth_failure;
  705.   }
  707.   if(c) {
  708.     struct group *grp;
  709.     int add_userdir;
  710.     char *u;
  711.     
  712.     u = (char *) get_param_int(main_server->conf,C_USER,FALSE);               
  713.                                                                               
  714.     add_userdir = get_param_int((c ? c->subset : main_server->conf),
  715. "UserDirRoot",FALSE);
  717.     if(add_userdir > 0 && strcmp(u, user)) {
  718.       session.anon_root = dir_realpath(session.pool, pdircat(session.pool,
  719.      c->name, u, NULL));
  720.     } else {
  721.       session.anon_root = dir_realpath(session.pool,c->name);
  722.     }
  723.     
  724.     session.anon_user = pstrdup(session.pool,pass);
  726.     if(!session.anon_root) {
  727.       log_pri(LOG_ERR,"%s: Directory %s is not accessible.",
  728.               session.user,c->name);
  729.       add_response_err(R_530,"Unable to set anonymous privileges.");
  730.       goto auth_failure;
  731.     }
  732.   
  733.     sstrncpy(session.cwd, "/", sizeof(session.cwd));
  734.     xferlog = get_param_ptr(c->subset,"TransferLog",FALSE);
  736.     if(anongroup) {
  737.       grp = auth_getgrnam(p,anongroup);
  738.       if(grp) {
  739.         pw->pw_gid = grp->gr_gid;
  740.         session.group = pstrdup(p,grp->gr_name);
  741.       }
  742.     }
  743.   } else {
  744.     struct group *grp;
  746.     if(ugroup) {
  747.       grp = auth_getgrnam(p,ugroup);
  748.       if(grp) {
  749.         pw->pw_gid = grp->gr_gid;
  750.         session.group = pstrdup(p,grp->gr_name);
  751.       }
  752.     }
  754.     sstrncpy(session.cwd, pw->pw_dir, MAX_PATH_LEN);
  755.   }
  757.   /* Get default chdir (if any) */
  758.   defchdir = _get_default_chdir(p,(c ? c->subset : main_server->conf));
  759.   
  760.   if(defchdir)
  761.     sstrncpy(session.cwd, defchdir, MAX_PATH_LEN);
  763.   build_group_arrays(session.pool,pw,NULL,
  764.                      &session.gids,&session.groups);
  767.   /* check limits again to make sure deny/allow directives still permit
  768.    * access.
  769.    */
  771.   if(!login_check_limits((c ? c->subset : main_server->conf),FALSE,TRUE,&i))
  772.   {
  773.     log_auth(LOG_NOTICE,"%s: LIMIT access denies login (DenyGroup) from %s [%s] to %s:%i",
  774.              origuser,session.c->remote_name,
  775.              inet_ascii(p,session.c->remote_ipaddr),
  776.      inet_ascii(p,session.c->local_ipaddr),
  777.      session.c->local_port);
  778.     goto auth_failure;
  779.   }
  780.   
  781.   /* perform a dir fixup */
  782.   resolve_defered_dirs(main_server);
  783.   fixup_dirs(main_server,CF_DEFER);
  784.   /* If running under an anonymous context, resolve all <Directory>
  785.    * blocks inside it
  786.    */
  787.   if(c && c->subset)
  788.     resolve_anonymous_dirs(c->subset);
  790.   if(c)
  791.     log_auth(LOG_NOTICE,"ANONYMOUS FTP login as '%s' from %s [%s] to %s:%i",
  792.       origuser,session.c->remote_name,
  793.       inet_ascii(p,session.c->remote_ipaddr),
  794.       inet_ascii(p,session.c->local_ipaddr),
  795.       session.c->local_port);
  796.   else
  797.     log_auth(LOG_NOTICE,"FTP login as '%s' from %s [%s] to %s:%i",
  798.       origuser,session.c->remote_name,
  799.       inet_ascii(p,session.c->remote_ipaddr),
  800.       inet_ascii(p,session.c->local_ipaddr),
  801.       session.c->local_port);
  803.   /* Write the login to wtmp.  This must be done here because we won't
  804.    * have access after we give up root.  This can result in falsified
  805.    * wtmp entries if an error kicks the user out before we get
  806.    * through with the login process.  Oh well.
  807.    */
  809. #if (defined(BSD) && (BSD >= 199103))
  810.   snprintf(ttyname, sizeof(ttyname), "ftp%ld",(long)getpid());
  811. #else
  812.   snprintf(ttyname, sizeof(ttyname), "ftpd%d",(int)getpid());
  813. #endif
  815.   /* Perform wtmp logging only if not turned off in <Anonymous>
  816.    * or the current server
  817.    */
  819.   if(c)
  820.     wtmp_log = get_param_int(c->subset,"WtmpLog",FALSE);
  822.   if(wtmp_log == -1)
  823.     wtmp_log = get_param_int(main_server->conf,"WtmpLog",FALSE);
  825.   PRIVS_ROOT
  827.   if(wtmp_log != 0) {
  828.     log_wtmp(ttyname,session.user,session.c->remote_name,
  829.              session.c->remote_ipaddr);
  830.     session.wtmp_log = TRUE;
  831.   }
  833.   /* Open the /var/run log for later writing */
  834.   log_open_run(mpid,FALSE,TRUE);
  835.   /* Open /var/log/ files */
  836.   if(!xferlog) {
  837.     if(c)
  838.       xferlog = get_param_ptr(c->subset,"TransferLog",FALSE);
  839.     if(!xferlog)
  840.       xferlog = get_param_ptr(main_server->conf,"TransferLog",FALSE);
  841.     if(!xferlog)
  842.       xferlog = XFERLOG_PATH;
  843.   }
  845.   if(strcasecmp(xferlog,"NONE") == 0)
  846.     log_open_xfer(NULL);
  847.   else
  848.     log_open_xfer(xferlog);
  850.   _init_groups(p,pw->pw_gid);
  852.   PRIVS_RELINQUISH
  854.   /* Now check to see if the user has an applicable DefaultRoot */
  855.   if(!c && (defroot = _get_default_root(session.pool))) {
  857.     /* Make sure pass/group is open */
  858.     auth_setpwent(p);
  859.     auth_setgrent(p);
  861.     /* On some unices the following is necessary to ensure the files
  862.      * are open.  (BSDI 3.1)
  863.      */
  864.     auth_getpwent(p);
  865.     auth_getgrent(p);
  867.     PRIVS_ROOT
  869.     if(chroot(defroot) == -1) {
  871.       PRIVS_RELINQUISH
  873.       add_response_err(R_530,"Unable to set default root directory.");
  874.       log_pri(LOG_ERR,"%s chroot("%s"): %s",session.user,
  875.               defroot,strerror(errno));
  876.       end_login(1);
  877.     }
  879.     PRIVS_RELINQUISH
  881.     session.anon_root = defroot;
  883.     /* Re-calc the new cwd based on this root dir.  If not applicable
  884.      * place the user in / (of defroot)
  885.      */
  887.     if(strncmp(session.cwd,defroot,strlen(defroot)) == 0) {
  888.       char *newcwd = &session.cwd[strlen(defroot)];
  890.       if(*newcwd == '/')
  891.         newcwd++;
  892.       session.cwd[0] = '/';
  894.       sstrncpy(&session.cwd[1], newcwd, sizeof(session.cwd));
  895.     } else
  896.       sstrncpy(session.cwd, "/", sizeof(session.cwd));
  897.   }
  899.   if(c) {
  900.     /* Make sure pass/group is open */
  901.     auth_setpwent(p);
  902.     auth_setgrent(p);
  904.     /* On some unices the following is necessary to ensure the files
  905.      * are open.  (BSDI 3.1)
  906.      */
  907.     auth_getpwent(p);
  908.     auth_getgrent(p);
  909.   }
  911.   PRIVS_ROOT
  913.   if(c && chroot(session.anon_root) == -1) { 
  914.     if(session.uid)
  915.       _init_groups(p,session.gid);
  917.     PRIVS_RELINQUISH
  919.     add_response_err(R_530,"Unable to set anonymous privileges.");
  920.     log_pri(LOG_ERR,"%s chroot(): %s",session.user,strerror(errno));
  921.     
  922.     end_login(1);
  923.   }
  925.   /* new in 1.1.x, I gave in and we don't give up root permanently..
  926.    * sigh.
  927.    */
  929. #ifndef __hpux
  930.   block_signals();
  932.   PRIVS_ROOT
  934.   setuid(0);
  935.   setgid(0);
  937.   PRIVS_SETUP(pw->pw_uid,pw->pw_gid)
  939.   unblock_signals();
  940. #else
  941.   session.uid = session.ouid = pw->pw_uid;
  942.   session.gid = pw->pw_gid;
  943.   PRIVS_RELINQUISH
  944. #endif
  946. #ifdef HAVE_GETEUID
  947.   if(getegid() != pw->pw_gid ||
  948.      geteuid() != pw->pw_uid) {
  950.     PRIVS_RELINQUISH
  952.     add_response_err(R_530,"Unable to set user privileges.");
  953.     log_pri(LOG_ERR,"%s setregid() or setreuid(): %s",
  954.             session.user,strerror(errno));
  956.     end_login(1);
  957.   }
  958. #endif
  960.   /*
  961.    *  session.uid = pw->pw_uid;
  962.    */
  964.   /* Overwrite original uid, so PRIVS_ macros no longer 
  965.    * try to do anything 
  966.    */
  968.   /*
  969.    * session.ouid = pw->pw_uid;
  970.    * session.gid = pw->pw_gid;
  971.    */
  973.   /* chdir to the proper directory, do this even if anonymous
  974.    * to make sure we aren't outside our chrooted space.
  975.    */
  977.   showsymlinks = get_param_int((c ? c->subset : main_server->conf),
  978.                                "ShowSymlinks",FALSE);
  980.   if(showsymlinks == -1)
  981.     showsymlinks = 1;
  983.   if(fs_chdir_canon(session.cwd,!showsymlinks) == -1) {
  984.     add_response_err(R_530,"Unable to chdir.");
  985.     log_pri(LOG_ERR,"%s chdir("%s"): %s",session.user,
  986.             session.cwd,strerror(errno));
  987.     end_login(1);
  988.   }
  990.   sstrncpy(session.cwd, fs_getcwd(), sizeof(session.cwd));
  991.   sstrncpy(session.vwd, fs_getvwd(), sizeof(session.vwd));
  994.   /* check dynamic configuration */
  995.   if(fs_stat("/",&sbuf) != -1)
  996.     build_dyn_config(p,"/",&sbuf,1);
  998.   if(c) {
  999.     if(!session.hide_password)
  1000.       session.proc_prefix =
  1001.       pstrcat(permanent_pool,session.c->remote_name,
  1002.               ": anonymous/",pass,NULL);
  1003.     else
  1004.       session.proc_prefix =
  1005.       pstrcat(permanent_pool,session.c->remote_name,
  1006.               ": anonymous",NULL);
  1008.     session.anon_config = c;
  1009.     session.flags = SF_ANON;
  1010.   } else {
  1011.     session.proc_prefix = pstrdup(permanent_pool,session.c->remote_name);
  1012.             
  1013.     session.flags = 0;
  1014.   }
  1016.   /* Make sure passwd file is closed after login to avoid leaking information */
  1017.   auth_endpwent(p);
  1019.   /* Default transfer mode is ASCII */
  1020.   defaulttransfermode = (char*)get_param_ptr(CURRENT_CONF, "DefaultTransferMode", FALSE);
  1021.   if (defaulttransfermode && strcasecmp(defaulttransfermode, "binary") == 0)
  1022. session.flags &= (SF_ALL^SF_ASCII);
  1023.   else
  1024. session.flags |= SF_ASCII;
  1026.   /* Authentication complete, user logged in, now kill the login
  1027.    * timer.
  1028.    */
  1030.   log_run_address(session.c->remote_name,session.c->remote_ipaddr);
  1031.   log_run_cwd(session.cwd);
  1032.   main_set_idle();
  1034.   remove_timer(TIMER_LOGIN,&auth_module);
  1036.   session.user = pstrdup(permanent_pool,session.user);
  1037.   session.group = pstrdup(permanent_pool,session.group);
  1038.   return 1;
  1040. auth_failure:
  1041.   session.user = session.group = NULL;
  1042.   session.gids = session.groups = NULL;
  1043.   session.wtmp_log = 0;
  1044.   return 0;
  1045. }
  1046.   
  1047. MODRET cmd_user(cmd_rec *cmd)
  1048. {
  1049.   int nopass = 0, cur = 0,hcur = 0, ccur = 0;
  1050.   logrun_t *l;
  1051.   config_rec *c,*maxc;
  1052.   char *user,*origuser, config_class_users[128];
  1053.   int failnopwprompt = 0, aclp,i, classes_enabled;
  1055.   if(logged_in)
  1056.     return ERROR_MSG(cmd,R_503,"You are already logged in!");
  1057.   if(cmd->argc != 2)
  1058.     return ERROR_MSG(cmd,R_500,"'USER': command requires a parameter.");
  1060.   user = cmd->argv[1];
  1062.   remove_config(cmd->server->conf,C_USER,FALSE);
  1063.   add_config_param_set(&cmd->server->conf,C_USER,1,
  1064.                        pstrdup(cmd->server->pool,user));
  1066.   origuser = user;
  1067.   c = _auth_resolve_user(cmd->tmp_pool,&user,NULL,NULL);
  1069.   switch(get_param_int((c && c->config_type == CONF_ANON ? c->subset :
  1070.                      main_server->conf),"LoginPasswordPrompt",FALSE))
  1071.   {
  1072.     case 0: failnopwprompt = 1; break;
  1073.     default: failnopwprompt = 0; break;
  1074.   }
  1076.   if(failnopwprompt) {
  1077.     if(!user) {
  1078.       log_pri(LOG_NOTICE,"failed login from %s, '%s' is not a UserAlias.",inet_ascii(cmd->tmp_pool,session.c->remote_ipaddr),origuser);
  1079.       send_response(R_530,"Login incorrect.");
  1080.       end_login(0);
  1081.     }
  1083.     aclp = login_check_limits(main_server->conf,FALSE,TRUE,&i);
  1085.     if(c && c->config_type != CONF_ANON) {
  1086.       c = (config_rec*)pcalloc(session.pool,sizeof(config_rec));
  1087.       c->config_type = CONF_ANON;
  1088.       c->name = ""; /* don't really need this yet */
  1089.       c->subset = main_server->conf;
  1090.     }
  1092.     if(c) {
  1093.       if(!login_check_limits(c->subset,FALSE,TRUE,&i) || (!aclp && !i) ) {
  1094.               log_auth(LOG_NOTICE,"ANON %s: LIMIT access denies login from %s [%s] to %s:%i",
  1095.                           origuser,
  1096.                           session.c->remote_name,
  1097.                           inet_ascii(cmd->tmp_pool,session.c->remote_ipaddr),
  1098.   inet_ascii(cmd->tmp_pool,session.c->local_ipaddr),
  1099.   session.c->local_port);
  1100.               send_response(R_530,"Login incorrect.");
  1101.               end_login(0);
  1102.       }
  1103.     }
  1105.     if(!c && !aclp) {
  1106.       log_auth(LOG_NOTICE,"USER %s: LIMIT access denies login from %s [%s] to %s:%i",
  1107.                origuser,session.c->remote_name,
  1108.                inet_ascii(cmd->tmp_pool,session.c->remote_ipaddr),
  1109.        inet_ascii(cmd->tmp_pool,session.c->local_ipaddr),
  1110.        session.c->local_port);
  1111.       send_response(R_530,"Login incorrect.");
  1112.       end_login(0);
  1113.     }
  1114.   }
  1115.   
  1116.   if((classes_enabled = get_param_int(main_server->conf,"Classes",FALSE)) < 0)
  1117.     classes_enabled = 0;
  1118.   
  1119.   if(classes_enabled)
  1120.     session.class = (class_t *) find_class(session.c->remote_ipaddr,
  1121.    session.c->remote_name);
  1122.   
  1123.   /* Determine how many users are currently connected */
  1125.   if(user) {
  1126.     PRIVS_ROOT
  1127.     while((l = log_read_run(NULL)) != NULL)
  1128.       /* Make sure it matches our current server */
  1129.       if(l->server_ip.s_addr == main_server->ipaddr->s_addr &&
  1130.          l->server_port == main_server->ServerPort) {
  1131.         if((c && c->config_type == CONF_ANON && !strcmp(l->user,user)) || !c) {
  1132.           char *s, *d, ip[32];
  1134.           cur++;
  1135.           s = strchr (l->address, '[');
  1136.           d = ip;
  1137.           if (s != NULL) s++;
  1138.           while (*s && *s != ']') *d++ = *s++;
  1139.           *d = '';
  1141.           if(!strcmp(ip, inet_ntoa(*session.c->remote_ipaddr)))
  1142.             hcur++;
  1143.         }
  1145.         if(classes_enabled && strcmp(l->class, session.class->name) == 0)
  1146.          ccur++;
  1147.       }
  1148.     PRIVS_RELINQUISH
  1149.   }
  1151.   remove_config(cmd->server->conf,"CURRENT-CLIENTS",FALSE);
  1152.   add_config_param_set(&cmd->server->conf,"CURRENT-CLIENTS",1,(void*)cur);
  1154.   if (classes_enabled) {
  1155.     remove_config(cmd->server->conf,"CURRENT-CLASS",FALSE);
  1156.     add_config_param_set(&cmd->server->conf,"CURRENT-CLASS",1,session.class->name);
  1158.     snprintf(config_class_users, sizeof(config_class_users), "%s-%s", "CURRENT-CLIENTS-CLASS", session.class->name);
  1159.     remove_config(cmd->server->conf,config_class_users,FALSE);
  1160.     add_config_param_set(&cmd->server->conf,config_class_users,1,ccur);
  1162.     /* too many users in this class ? */
  1163.     if (ccur == session.class->max_connections) {
  1164. char *display = NULL;
  1166. if(session.flags & SF_ANON)
  1167.   display = (char*) get_param_ptr(session.anon_config->subset,
  1168.   "DisplayGoAway",FALSE);
  1169.            
  1170. if(!display)
  1171.   display = (char*) get_param_ptr(cmd->server->conf,
  1172.   "DisplayGoAway",FALSE);
  1174. if (display)
  1175.   core_display_file(R_530, display);
  1176. else
  1177.   send_response(R_530,
  1178. "Too many users in your class, please try again later.");
  1180. log_auth(LOG_NOTICE,"connection refused (max clients for class %s)",session.class->name);
  1181. end_login(0);
  1182.     }
  1183.   }
  1184.   
  1185.   /* Try to determine what MaxClients applies to the user
  1186.    * (if any) and count through the runtime file to see
  1187.    * if this would exceed the max.
  1188.    */
  1191.   if(c && user && get_param_int(c->subset,"AnonRequirePassword",FALSE) != 1)
  1192.       nopass++;
  1195.   maxc = find_config((c ? c->subset : cmd->server->conf),
  1196.                   CONF_PARAM,"MaxClientsPerHost",FALSE);
  1198.   if(maxc) {
  1199.     int max = (int)maxc->argv[0];
  1200.     char *maxstr = "Sorry, maximum number clients (%m) from your host already connected.";
  1201.     char maxn[10];
  1203.     snprintf(maxn, sizeof(maxn), "%d",max);
  1204.     if(maxc->argc > 1)
  1205.       maxstr = maxc->argv[1];
  1206.     
  1207.     if(hcur >= max) {
  1208.       send_response(R_530,"%s",
  1209.                     sreplace(cmd->tmp_pool,maxstr,"%m",maxn,NULL));
  1211.       log_auth(LOG_NOTICE,"connection refused (max clients per host %d)",
  1212.                max);
  1213.       end_login(0);
  1214.     }
  1216.   }
  1219.   maxc = find_config((c ? c->subset : cmd->server->conf),
  1220.                   CONF_PARAM,"MaxClients",FALSE);
  1222.   if(maxc) {
  1223.     int max = (int)maxc->argv[0];
  1224.     char *maxstr = "Sorry, maximum number of allowed clients (%m) already connected.";
  1225.     char maxn[10];
  1227.     snprintf(maxn, sizeof(maxn), "%d",max);
  1228.     if(maxc->argc > 1)
  1229.       maxstr = maxc->argv[1];
  1230.     
  1231.     if(cur >= max) {
  1232.       send_response(R_530,"%s",
  1233.                     sreplace(cmd->tmp_pool,maxstr,"%m",maxn,NULL));
  1235.       log_auth(LOG_NOTICE,"connection refused (max clients %d)",
  1236.                max);
  1237.       end_login(0);
  1238.     }
  1240.   }
  1242.   /* Make sure the passwd file is open in case we chroot right away,
  1243.    * so we can still access it.
  1244.    */
  1246.   auth_setpwent(cmd->tmp_pool);
  1247.   auth_setgrent(cmd->tmp_pool);
  1248.   if(nopass)
  1249.     add_response(R_331,"Anonymous login ok, send your complete e-mail address as password.");
  1250.   else
  1251.     add_response(R_331,"Password required for %s.",cmd->argv[1]);
  1253.   session.gids = NULL;
  1254.   session.groups = NULL;
  1255.   session.user = NULL;
  1256.   session.group = NULL;
  1258.   return HANDLED(cmd);
  1259. }
  1261. MODRET cmd_pass(cmd_rec *cmd)
  1262. {
  1263.   char *display = NULL;
  1264.   char *user,*grantmsg;
  1265.   int res = 0;
  1267. #if 0
  1268.   if(cmd->argc < 2)
  1269.     return ERROR_MSG(cmd,R_500,"'PASS': command requires a parameter.");
  1270. #endif
  1272.   if(logged_in)
  1273.     return ERROR_MSG(cmd,R_503,"You are already logged in!");
  1275.   user = (char*)get_param_ptr(cmd->server->conf,C_USER,FALSE);
  1277.   if(!user)
  1278.     return ERROR_MSG(cmd,R_503,"Login with USER first.");
  1279.   
  1280.   if((res = _setup_environment(cmd->tmp_pool,user,cmd->arg)) == 1) {
  1281.     add_config_param_set(&cmd->server->conf,"authenticated",1,(void*)1);
  1282.     set_auth_check(NULL);
  1284.     if(session.flags & SF_ANON)
  1285.       display = (char*)get_param_ptr(session.anon_config->subset,
  1286.                                      "DisplayLogin",FALSE);
  1287.     if(!display)
  1288.       display = (char*)get_param_ptr(cmd->server->conf,
  1289.                                      "DisplayLogin",FALSE);
  1291.     if(display)
  1292.       core_display_file(R_230,display);
  1294.     if((grantmsg = 
  1295.         (char*)get_param_ptr((session.anon_config ? session.anon_config->subset :
  1296.                               cmd->server->conf),"AccessGrantMsg",FALSE)) != NULL) {
  1297.       grantmsg = sreplace(cmd->tmp_pool,grantmsg,"%u",user,NULL);
  1299.       add_response(R_230,"%s",grantmsg,NULL);
  1300.     } else {
  1301.       if(session.flags & SF_ANON)
  1302.         add_response(R_230,"Anonymous access granted, restrictions apply.");
  1303.       else
  1304.         add_response(R_230,"User %s logged in.",user);
  1305.     }
  1307.     logged_in = 1;
  1308.     return HANDLED(cmd);
  1309.   }
  1311.   remove_config(cmd->server->conf,C_USER,FALSE);
  1313.   if(res == 0) {
  1314.     int max;
  1316.     max = get_param_int(main_server->conf,"MaxLoginAttempts",FALSE);
  1317.     if(max == -1)
  1318.       max = 3;
  1320.     if(++auth_tries >= max) {
  1321.       send_response(R_530,"Login incorrect");
  1322.       log_auth(LOG_NOTICE,"Maximum login attempts exceeded from %s [%s] to %s:%i",
  1323.                session.c->remote_name,
  1324.                inet_ascii(cmd->tmp_pool,session.c->remote_ipaddr),
  1325.        inet_ascii(cmd->tmp_pool,session.c->local_ipaddr),
  1326.        session.c->local_port);
  1327.       end_login(0);
  1328.     }
  1330.     return ERROR_MSG(cmd,R_530,"Login incorrect.");
  1331.   }
  1333.   return HANDLED(cmd);
  1334. }
  1336. MODRET set_rootlogin(cmd_rec *cmd)
  1337. {
  1338.   CHECK_ARGS(cmd,1);
  1339.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1341.   add_config_param("RootLogin",1,(void*)get_boolean(cmd,1));
  1342.   return HANDLED(cmd);
  1343. }
  1345. MODRET set_loginpasswordprompt(cmd_rec *cmd)
  1346. {
  1347.   config_rec *c;
  1349.   CHECK_ARGS(cmd,1);
  1350.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1352.   c = add_config_param("LoginPasswordPrompt",1,(void*)get_boolean(cmd,1));
  1353.   c->flags |= CF_MERGEDOWN;
  1355.   return HANDLED(cmd);
  1356. }
  1358. MODRET add_defaultroot(cmd_rec *cmd)
  1359. {
  1360.   config_rec *c;
  1361.   char *dir,**argv;
  1362.   int argc;
  1363.   array_header *acl = NULL;
  1365.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_GLOBAL);
  1367.   if(cmd->argc < 2)
  1368.     CONF_ERROR(cmd,"syntax: DefaultRoot <directory> [<group-expression>]");
  1370.   argv = cmd->argv;
  1371.   argc = cmd->argc-2;
  1373.   dir = *++argv;
  1375.   /* dir must be / or ~
  1376.    */
  1378.   if(*dir != '/' && *dir != '~')
  1379.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"(",dir,") absolute pathname "
  1380.               "required.",NULL));
  1382.   if(strchr(dir,'*'))
  1383.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"(",dir,") wildcards not allowed "
  1384.                "in pathname.",NULL));
  1386.   if(*(dir+strlen(dir)-1) != '/')
  1387.     dir = pstrcat(cmd->tmp_pool,dir,"/",NULL);
  1389.   acl = parse_group_expression(cmd->tmp_pool,&argc,argv);
  1391.   c = add_config_param("DefaultRoot",0);
  1393.   c->argc = argc+1;
  1394.   c->argv = pcalloc(c->pool,(argc+2) * sizeof(char*));
  1395.   argv = (char**)c->argv;
  1396.   *argv++ = pstrdup(permanent_pool,dir);
  1398.   if(argc && acl)
  1399.     while(argc--) {
  1400.       *argv++ = pstrdup(permanent_pool,*((char**)acl->elts));
  1401.       acl->elts = ((char**)acl->elts) + 1;
  1402.     }
  1404.   *argv = NULL;
  1405.   return HANDLED(cmd);
  1406. }
  1408. MODRET add_defaultchdir(cmd_rec *cmd)
  1409. {
  1410.   config_rec *c;
  1411.   char *dir,**argv;
  1412.   int argc;
  1413.   array_header *acl = NULL;
  1415.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  1417.   if(cmd->argc < 2)
  1418.     CONF_ERROR(cmd,"syntax: DefaultChdir <directory> [<group-expression>]");
  1420.   argv = cmd->argv;
  1421.   argc = cmd->argc-2;
  1423.   dir = *++argv;
  1425.   if(strchr(dir,'*'))
  1426.     CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"(",dir,") wildcards not allowed "
  1427.                "in pathname.",NULL));
  1429.   if(*(dir+strlen(dir)-1) != '/')
  1430.     dir = pstrcat(cmd->tmp_pool,dir,"/",NULL);
  1432.   acl = parse_group_expression(cmd->tmp_pool,&argc,argv);
  1434.   c = add_config_param("DefaultChdir",0);
  1436.   c->argc = argc+1;
  1437.   c->argv = pcalloc(c->pool,(argc+2) * sizeof(char*));
  1438.   argv = (char**)c->argv;
  1439.   *argv++ = pstrdup(permanent_pool,dir);
  1441.   if(argc && acl)
  1442.     while(argc--) {
  1443.       *argv++ = pstrdup(permanent_pool,*((char**)acl->elts));
  1444.       acl->elts = ((char**)acl->elts) + 1;
  1445.     }
  1447.   *argv = NULL;
  1448.   return HANDLED(cmd);
  1449. }
  1451. MODRET add_userdirroot (cmd_rec *cmd)
  1452. {
  1453.   CHECK_ARGS(cmd,1);
  1454.   CHECK_CONF (cmd, CONF_ANON);
  1456.   add_config_param("UserDirRoot",1,(void*)get_boolean(cmd,1));
  1457.   return HANDLED(cmd);
  1458. }
  1460. static conftable auth_config[] = {
  1461.   { "RootLogin", set_rootlogin, NULL },
  1462.   { "LoginPasswordPrompt", set_loginpasswordprompt, NULL },
  1463.   { "DefaultRoot", add_defaultroot, NULL },
  1464.   { "DefaultChdir", add_defaultchdir, NULL },
  1465.   { "UserDirRoot", add_userdirroot, NULL },
  1466.   { NULL, NULL, NULL }
  1467. };
  1469. cmdtable auth_commands[] = {
  1470.   { CMD, C_USER, G_NONE, cmd_user, FALSE, FALSE, CL_AUTH },
  1471.   { CMD, C_PASS, G_NONE, cmd_pass, FALSE,  FALSE, CL_AUTH },
  1472.   { 0, NULL }
  1473. };
  1475. /* Module interface */
  1477. module auth_module = {
  1478.   NULL,NULL, /* Always NULL */
  1479.   0x20, /* API Version 2.0 */
  1480.   "auth",
  1481.   auth_config,
  1482.   auth_commands,
  1483.   NULL,
  1484.   auth_init,auth_init_child
  1485. };