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

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

Ftp客户端

开发平台：

Unix_Linux

dirtree.c：源码内容
  1. /*
  2.  * ProFTPD - FTP server daemon
  3.  * Copyright (c) 1997, 1998 Public Flood Software
  4.  *  
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  18.  */
  20. /* Read configuration file(s), and manage server/configuration
  21.  * structures.
  22.  * $Id: dirtree.c,v 1.10 1999/10/01 03:32:17 macgyver Exp $
  23.  */
  25. /* History:
  26.  * 5/1/97 0.99.0pl2
  27.  *  Used to be named "config.c", renamed to dirtree.c (directive
  28.  *  tree) so as not to conflict with GNU autoconf's top-level config.h.
  29.  */
  31. #include "conf.h"
  33. #include <sys/stat.h>
  34. #include <stdarg.h>
  36. #ifdef HAVE_ARPA_INET_H
  37. # include <arpa/inet.h>
  38. #endif
  40. xaset_t *servers = NULL;
  41. server_rec *main_server = NULL;
  42. int tcpBackLog = TUNABLE_DEFAULT_BACKLOG;
  43. int SocketBindTight = FALSE;
  44. char ServerType = SERVER_STANDALONE;
  45. int ServerMaxInstances = 0;
  46. int ServerUseReverseDNS = TRUE;
  47. int TimeoutLogin = TUNABLE_TIMEOUTLOGIN;
  48. int TimeoutIdle = TUNABLE_TIMEOUTIDLE;
  49. int TimeoutNoXfer = TUNABLE_TIMEOUTNOXFER;
  50. int TimeoutStalled = TUNABLE_TIMEOUTSTALLED;
  51. char MultilineRFC2228 = 0;
  53. /* Used by find_config_* */
  54. xaset_t *find_config_top = NULL;
  56. static void _mergedown(xaset_t*,int);
  58. /* Used by get_param_int_next & get_param_ptr_next as "placeholders" */
  59. static config_rec *_last_param_int = NULL;
  60. static config_rec *_last_param_ptr = NULL;
  61. static int _kludge_disable_umask = 0;
  63. /* Used only while reading configuration files */
  65. struct {
  66.   pool *tpool;
  67.   array_header *sstack,*cstack;
  68.   server_rec **curserver;
  69.   config_rec **curconfig;
  70. } conf;
  72. void kludge_disable_umask()
  73. {
  74.   _kludge_disable_umask = 1;
  75. }
  77. void kludge_enable_umask()
  78. {
  79.   _kludge_disable_umask = 0;
  80. }
  82. char *get_word(char **cp)
  83. {
  84.   char *ret,*dst;
  85.   char quote_mode = 0;
  87.   if(!cp || !*cp || !**cp)
  88.     return NULL;
  90.   while(**cp && isspace((UCHAR)**cp)) (*cp)++;
  92.   if(!**cp)
  93.     return NULL;
  95.   ret = dst = *cp;
  96.   
  97.   if(**cp == '"') {
  98.     quote_mode++;
  99.     (*cp)++;
  100.   }
  102.   while(**cp && (quote_mode ? (**cp != '"') : !isspace((UCHAR)**cp))) {
  103.     if(**cp == '\' && quote_mode) {
  104.       /* escaped char */
  105.       if(*((*cp)+1))
  106.         *dst = *(++(*cp));
  107.     }
  109.     *dst++ = **cp;
  110.     ++(*cp);
  111.   }
  113.   if(**cp) (*cp)++;
  114.   *dst = '';
  116.   return ret;
  117. }
  119. cmd_rec *get_config_cmd(pool *ppool, FILE *fp)
  120. {
  121.   char buf[256],*cp,*wrd;
  122.   cmd_rec *newcmd;
  123.   pool *newpool;
  124.   array_header *tarr;
  125.   int i;
  127.   while(fgets(buf,sizeof(buf)-1,fp)) {
  128.     i = strlen(buf);
  129.     if(i && buf[i-1] == 'n')
  130.       buf[i-1] = '';
  132.     for(cp = buf; *cp && isspace((UCHAR)*cp); cp++) ;
  134.     if(*cp == '#' || !*cp) /* Comment or blank line */
  135.       continue;
  137.     /* Build a new pool for the command structure and array */
  138.     newpool = make_sub_pool(ppool);
  139.     newcmd = (cmd_rec*)pcalloc(newpool,sizeof(cmd_rec));
  140.     newcmd->pool = newpool;
  141.     tarr = make_array(newpool,4,sizeof(char**));
  143.     /* Add each word to the array */
  144.     while((wrd = get_word(&cp)) != NULL) {
  145.       char *tmp = pstrdup(newpool, wrd);
  146.       
  147.       *((char**)push_array(tarr)) = tmp; /* pstrdup(newpool,wrd); */
  148.       newcmd->argc++;
  149.     }
  151.     *((char**)push_array(tarr)) = NULL;
  152.     
  153.     /* The array header's job is done, we can forget about it and
  154.      * it will get purged when the command's pool is cleared
  155.      */
  157.     newcmd->argv = (char**)tarr->elts;
  159.     /* Perform a fixup on configuration directives so that:
  160.      * -argv[0]--  -argv[1]-- ----argv[2]-----
  161.      * <Option     /etc/adir  /etc/anotherdir>
  162.      *   .. becomes ..
  163.      * -argv[0]--  -argv[1]-  ----argv[2]----
  164.      * <Option>    /etc/adir  /etc/anotherdir
  165.      */
  167.     if(newcmd->argc && *(newcmd->argv[0]) == '<') {
  168.       char *cp = newcmd->argv[newcmd->argc-1];
  170.       if(*(cp + strlen(cp)-1) == '>' && newcmd->argc > 1) {
  171.         if(!strcmp(cp,">")) {
  172.           newcmd->argv[newcmd->argc-1] = NULL;
  173.           newcmd->argc--;
  174.         } else
  175.           *(cp + strlen(cp)-1) = '';
  177.         cp = newcmd->argv[0];
  178.         if(*(cp + strlen(cp)-1) != '>')
  179.           newcmd->argv[0] = pstrcat(newcmd->pool,cp,">",NULL);
  180.       }
  181.     }
  183.         
  184.     return newcmd;
  185.   }
  187.   return NULL;
  188. }
  190. void init_dyn_stacks(pool *p,config_rec *top)
  191. {
  192.   conf.sstack = make_array(p,1,sizeof(server_rec*));
  193.   conf.curserver = (server_rec**)push_array(conf.sstack);
  194.   *conf.curserver = main_server;
  195.   conf.cstack = make_array(p,3,sizeof(config_rec*));
  196.   conf.curconfig = (config_rec**)push_array(conf.cstack);
  197.   *conf.curconfig = NULL;
  198.   conf.curconfig = (config_rec**)push_array(conf.cstack);
  199.   *conf.curconfig = top;
  200. }
  202. void init_conf_stacks()
  203. {
  204.   pool *pool = make_sub_pool(permanent_pool);
  206.   conf.tpool = pool;
  207.   conf.sstack = make_array(pool,1,sizeof(server_rec*));
  208.   conf.curserver = (server_rec**)push_array(conf.sstack);
  209.   *conf.curserver = main_server;
  210.   conf.cstack = make_array(pool,10,sizeof(config_rec*));
  211.   conf.curconfig = (config_rec**)push_array(conf.cstack);
  212.   *conf.curconfig = NULL;
  213. }
  215. void free_dyn_stacks()
  216. {
  217.   bzero(&conf,sizeof(conf));
  218. }
  220. void free_conf_stacks()
  221. {
  222.   destroy_pool(conf.tpool);
  223.   bzero(&conf,sizeof(conf));
  224. }
  226. /* Used by modules to start/end configuration sections */
  228. server_rec *start_new_server(const char *addr)
  229. {
  230.   server_rec *s;
  231.   pool *p;
  233.   p = make_sub_pool(permanent_pool);
  235.   s = (server_rec*)pcalloc(p,sizeof(server_rec));
  236.   s->pool = p;
  237.   
  238.   /* Have to make sure it ends up on the end of the chain,
  239.    * otherwise main_server becomes useless.
  240.    */
  242.   xaset_insert_end(servers,(xasetmember_t*)s);
  243.   s->set = servers;
  244.   if(addr)
  245.     s->ServerAddress = pstrdup(s->pool,addr);
  246.   s->ServerPort = -1;
  248.   conf.curserver = (server_rec**)push_array(conf.sstack);
  249.   *conf.curserver = s;
  250.   return s;
  251. }
  253. server_rec *end_new_server()
  254. {
  255.   if(!*conf.curserver)
  256.     return NULL;
  258.   if(conf.curserver == (server_rec**)conf.sstack->elts)
  259.     return NULL; /* Disallow underflows */
  261.   
  262.   conf.curserver--;
  263.   conf.sstack->nelts--;
  266.   return *conf.curserver;
  267. }
  269. /* Starts a sub-configuration */
  270.   
  271. config_rec *start_sub_config(const char *name)
  272. {
  273.   config_rec *c,*parent = *conf.curconfig;
  274.   pool *p;
  275.   xaset_t **set;
  277.   if(parent) {
  278.     p = make_sub_pool(parent->pool);
  279.     set = &parent->subset;
  280.   } else {
  281.     p = make_sub_pool((*conf.curserver)->pool);
  282.     set = &(*conf.curserver)->conf;
  283.   }
  285.   c = (config_rec*)pcalloc(p,sizeof(config_rec));
  287.   if(!*set)
  288.     *set = xaset_create(p,NULL);
  290.   xaset_insert(*set,(xasetmember_t*)c);
  291.   
  292.   c->pool = p;
  293.   c->set = *set;
  294.   c->parent = parent;
  295.   if(name)
  296.     c->name = pstrdup(p,name);
  298.   if(parent && (parent->config_type == CONF_DYNDIR))
  299.     c->flags |= CF_DYNAMIC;
  301.   /* Now insert another level onto the stack */
  302.   if(!*conf.curconfig)
  303.     *conf.curconfig = c;
  304.   else {
  305.     conf.curconfig = (config_rec**)push_array(conf.cstack);
  306.     *conf.curconfig = c;
  307.   }
  309.   return c;
  310. }
  312. /* Pop one level off the stack */
  313. config_rec *end_sub_config()
  314. {
  315.   if(conf.curconfig == (config_rec**)conf.cstack->elts) {
  316.     if(*conf.curconfig)
  317.       *conf.curconfig = NULL;
  318.     return NULL;
  319.   }
  321.   conf.curconfig--;
  322.   conf.cstack->nelts--;
  324.   return *conf.curconfig;
  325. }
  327. /* Adds a config_rec to the specified set */
  328. config_rec *add_config_set(xaset_t **set,const char *name)
  329. {
  330.   pool *p;
  331.   config_rec *c,*parent = NULL;
  333.   if(!*set) {
  334.     p = make_sub_pool(permanent_pool);
  335.     *set = xaset_create(p,NULL);
  336.   } else {
  337.     if((*set)->xas_list)
  338.       parent = ((config_rec*)((*set)->xas_list))->parent;
  339.     p = (*set)->mempool;
  340.   }
  342.   c = (config_rec*)pcalloc(p,sizeof(config_rec));
  343.   
  344.   c->pool = p;
  345.   c->set = *set;
  346.   c->parent = parent;
  347.   if(name)
  348.     c->name = pstrdup(p,name);
  349.   xaset_insert_end(*set,(xasetmember_t*)c);
  350.   return c;
  351. }
  353. /* Adds a config_rec on the current "level" */
  354. config_rec *add_config(const char *name)
  355. {
  356.   server_rec *s = *conf.curserver;
  357.   config_rec *parent,*c = *conf.curconfig;
  358.   pool *p;
  359.   xaset_t **set;
  361.   if(c) {
  362.     parent = c;
  363.     p = c->pool;
  364.     set = &c->subset;
  365.   } else {
  366.     parent = NULL;
  367.     
  368.     if(!s->conf || !s->conf->xas_list)
  369.       p = make_sub_pool(s->pool);
  370.     else
  371.       p = ((config_rec*)s->conf->xas_list)->pool;
  372.     set = &s->conf;
  373.   }
  375.   if(!*set)
  376.     *set = xaset_create(p,NULL);
  378.   c = add_config_set(set,name);
  379.   c->parent = parent;
  381.   return c;
  382. }
  384. array_header *parse_group_expression(pool *p, int *argc, char **argv)
  385. {
  386.   array_header *acl = NULL;
  387.   int cnt = *argc;
  388.   char *s,*ent;
  390.   if(cnt) {
  391.     acl = make_array(p,cnt,(sizeof(char*)));
  392.     while(cnt-- && *(++argv)) {
  393.       s = pstrdup(p,*argv);
  394.       while((ent = get_token(&s,",")) != NULL)
  395.         if(*ent)
  396.           *((char**)push_array(acl)) = ent;
  397.     }
  399.     *argc = acl->nelts;
  400.   } else
  401.     *argc = 0;
  403.   return acl;
  404. }
  406. array_header *parse_user_expression(pool *p, int *argc, char **argv)
  407. {
  408.   return parse_group_expression(p,argc,argv);
  409. }
  411. /* boolean "group-expression" matching, returns 1 if the expression
  412.  * matches
  413.  */
  415. int group_expression(char **expr)
  416. {
  417.   int cnt,found;
  418.   char *grp;
  420.   for(; *expr; expr++) {
  421.     grp = *expr;
  422.     found = FALSE;
  424.     if(*grp == '!') {
  425.       found = !found;
  426.       grp++;
  427.     }
  429.     for(cnt = session.groups->nelts-1; cnt >= 0; cnt--)
  430.       if(strcmp(*(((char**)session.groups->elts)+cnt),grp) == 0) {
  431.         found = !found; break;
  432.       }
  434.     if(!found) {
  435.       expr = NULL;
  436.       break;
  437.     } 
  438.   }
  440.   if(expr)
  441.     return TRUE;
  443.   return FALSE;
  444. }
  445.   
  446. /* boolean "user-expression" matching, returns 1 if the expression
  447.  * matches
  448.  */
  450. int user_expression(char **expr)
  451. {
  452.   int found;
  453.   char *user;
  455.   for(; *expr; expr++) {
  456.     user = *expr;
  457.     found = FALSE;
  459.     if(*user == '!') {
  460.       found = !found;
  461.       user++;
  462.     }
  464.     if(strcmp(session.user,user) == 0)
  465.       found = !found;
  467.     if(!found) {
  468.       expr = NULL;
  469.       break;
  470.     }
  471.   }
  473.   if(expr)
  474.     return TRUE;
  476.   return FALSE;
  477. }
  479. /* Per-directory configuration */
  481. static int _strmatch(register char *s1, register char *s2)
  482. {
  483.   register int len = 0;
  485.   while(*s1 && *s2 && *s1++ == *s2++)
  486.     len++;
  488.   return len;
  489. }
  491. static config_rec *_recur_match_path(pool *p,xaset_t *s, char *path)
  492. {
  493.   config_rec *c,*res;
  494.   char *tmp;
  496.   if(!s)
  497.     return NULL;
  499.   for(c = (config_rec*)s->xas_list; c; c=c->next)
  500.     if(c->config_type == CONF_DIR) {
  501.       tmp = c->name;
  503.       if(c->argv[1]) {
  504.         if(*(char*)(c->argv[1]) == '~')
  505.           c->argv[1] = dir_canonical_path(c->pool,(char*)c->argv[1]);
  506.         tmp = pdircat(p,(char*)c->argv[1],tmp,NULL);
  507.       }
  509.       if(!strcmp(tmp,path))
  510.         return c; /* Exact match */
  512.       if(!strstr(tmp,"/*")) {
  513.         if(*tmp && *(tmp+(strlen(tmp)-1)) == '/') {
  514.           *(tmp+(strlen(tmp)-1)) = '';
  515.           if(!strcmp(tmp,path))
  516.             return c;
  517.         }
  518.         tmp = pstrcat(p,tmp,"/*",NULL);
  519.       }
  521.       /* Temporary measure until we figure what's going on with
  522.        * gnu fnmatch
  523.        */
  525. #if 0
  526.       if(fnmatch(tmp,path,FNM_PATHNAME) == 0) {
  527. #else
  528.       if(fnmatch(tmp,path,0) == 0) {
  529. #endif
  530.         if(c->subset) {
  531.           res = _recur_match_path(p,c->subset,path);
  532.           if(res)
  533.             return res;
  534.         }
  535.         return c;
  536.       }
  537.     }
  539.   return NULL;
  540. }
  542. config_rec *dir_match_path(pool *p, char *path)
  543. {
  544.   char *tmp;
  545.   config_rec *res = NULL;
  547.   tmp = pstrdup(p,path);
  548.   if(*(tmp+strlen(tmp)-1) == '*')
  549.     *(tmp+strlen(tmp)-1) = '';
  550.   if(*(tmp+strlen(tmp)-1) == '/')
  551.     *(tmp+strlen(tmp)-1) = '';
  553.   if(session.anon_config) {
  554.     res = _recur_match_path(p,session.anon_config->subset,tmp);
  555.     if(!res) {
  557.       if(session.anon_root && !strncmp(session.anon_root,tmp,
  558.                                        strlen(session.anon_root)))
  559.         return NULL;
  560.     }
  561.   }
  563.   if(!res)
  564.     res = _recur_match_path(p,main_server->conf,tmp);
  566. /*
  567.   if(!res)
  568.     res = ((session.anon_config) ? session.anon_config : (config_rec*)main_server->conf->xas_list);
  569. */
  571.   return res;
  572. }
  574. int dir_get_param(pool *pp,char *path,char *param)
  575. {
  576.   char *fullpath,*tmp;
  577.   pool *p;
  578.   config_rec *c;
  580.   p = make_sub_pool(pp);
  582.   if(*path != '/')
  583.     fullpath = pstrcat(p,session.cwd,"/",path,NULL);
  584.   else
  585.     fullpath = path;
  587.   if((tmp = dir_realpath(p,fullpath)) != NULL)
  588.     fullpath = tmp;
  590.   if(session.anon_root)
  591.     fullpath = pdircat(p,session.anon_root,fullpath,NULL);
  593.   c = dir_match_path(p,fullpath);
  595.   destroy_pool(p);
  597.   if(c)
  598.     return get_param_int(c->subset,param,FALSE);
  599.   return -1;
  600. }
  602. static int _dir_check_op(pool *p,xaset_t *c,int op,
  603.                          int uid,int gid,int mode)
  604. {
  605.   int i,res = 1,pcheck = 0;
  606.   int *gidp = NULL,u,g;
  608.   if(!c)
  609.     return 1; /* Default is to allow */
  610.   if(uid == session.uid)
  611.     pcheck |= (mode & S_IRWXU);
  612.   else if(session.gid == gid)
  613. isgroup:
  614.     pcheck |= (mode & S_IRWXG);
  615.   else {
  616.     for(i = session.gids->nelts, gidp = (int*)session.gids->elts; i;
  617.         i--, gidp++)
  618.           if(*gidp == gid)
  619.             goto isgroup;
  620.     pcheck |= (mode & S_IRWXO);
  621.   }
  623.   switch(op) {
  624.   case OP_HIDE:
  625.     u = get_param_int(c,"HideUser",FALSE);
  627.     while(u != -1 && (u != uid || u == session.uid))
  628.       u = get_param_int_next("HideUser",FALSE);
  630.     if(u == uid) {
  631.       res = 0;
  632.       break;
  633.     }
  635.     g = get_param_int(c,"HideGroup",FALSE);
  637.     while(g != -1 && (g != gid || g == session.gid))
  638.       g = get_param_int_next("HideGroup",FALSE);
  640.     if(g == gid) {
  641.       res = 0;
  642.       break;
  643.     }
  645.     if(get_param_int(c,"HideNoAccess",FALSE) == 1) {
  646.       if(S_ISDIR(mode))
  647.         res = pcheck &= (S_IXUSR|S_IXGRP|S_IXOTH);
  648.       else
  649.         res = pcheck &= (S_IRUSR|S_IRGRP|S_IROTH);
  650.     }
  651.     break;
  652.   case OP_COMMAND:
  653.     if(get_param_int(c,"AllowAll",FALSE) == 1)
  654.       /* nop */;  
  655.     else if(get_param_int(c,"DenyAll",FALSE) == 1)
  656.       res = 0;
  657.     break;
  658.   }
  660.   return res;
  661. }
  663. int dir_check_op_mode(pool *p,char *path,int op,
  664.                        int uid,int gid,int mode)
  665. {
  666.   char *fullpath;
  667.   xaset_t *c;
  668.   config_rec *sc;
  669.   int res;
  671.   if(*path != '/')
  672.     fullpath = pdircat(p,session.cwd,path,NULL);
  673.   else
  674.     fullpath = path;
  676.   if(session.anon_root)
  677.     fullpath = pdircat(p,session.anon_root,fullpath,NULL);
  678.   
  679.   c = CURRENT_CONF;
  680.   sc = _recur_match_path(p,c,fullpath);
  682.   if(sc)
  683.     res = _dir_check_op(p,sc->subset,op,uid,gid,mode);
  684.   else
  685.     res = _dir_check_op(p,c,op,uid,gid,mode);
  687.   return res;  
  688. }
  690. int dir_check_op(pool *pp,char *path,int op)
  691. {
  692.   struct stat sbuf;
  694.   if(fs_stat(path,&sbuf) == -1)
  695.     return 1;
  697.   return dir_check_op_mode(pp,path,op,sbuf.st_uid,sbuf.st_gid,sbuf.st_mode);
  698. }
  700. static int _check_user_access(xaset_t *conf, char *name)
  701. {
  702.   int ret = 0;
  703.   config_rec *c = find_config(conf,CONF_PARAM,name,FALSE);
  705.   while(c) {
  706.     ret = user_expression((char**)c->argv);
  708.     if(ret)
  709.       break;
  711.     c = find_config_next(c,c->next,CONF_PARAM,name,FALSE);
  712.   }
  714.   return ret;
  715. }
  717. static int _check_group_access(xaset_t *conf, char *name)
  718. {
  719.   int ret = 0;
  720.   config_rec *c = find_config(conf,CONF_PARAM,name,FALSE);
  722.   while(c) {
  723.     ret = group_expression((char**)c->argv);
  725.     if(ret)
  726.       break;
  728.     c = find_config_next(c,c->next,CONF_PARAM,name,FALSE);
  729.   }
  731.   return ret;
  732. }
  734. /* returns 1 if explicit match
  735.  * returns -1 if explicit mismatch (i.e. "NONE")
  736.  * returns 0 if no match
  737.  */
  739. int match_ip(p_in_addr_t *addr, char *name, const char *match)
  740. {
  741.   char buf[1024];
  742.   char *mask,*cp;
  743.   int cidr_mode = 0, cidr_bits;
  744.   p_in_addr_t cidr_addr;
  745.   u_int_32 cidr_mask = 0;
  747.   if(!strcasecmp(match,"ALL"))
  748.     return 1;
  750.   if(!strcasecmp(match,"NONE"))
  751.     return -1;
  753.   memset(buf,0,sizeof(buf));
  754.   mask = buf;
  756.   if(*match == '.') {
  757.     *mask++ = '*';
  758.     *mask = '';
  759.     sstrcat(buf, match, sizeof(buf));
  760.   } else if(*(match + strlen(match) - 1) == '.') {
  761.     sstrcat(buf, match, sizeof(buf));
  762.     sstrcat(buf, "*", sizeof(buf));
  763.   } else if((cp = strchr(match,'/')) != NULL) { /* check for CIDR notation */
  764.     /* first portion of CIDR should be dotted quad, second portion
  765.      * is netmask
  766.      */
  767.     sstrncpy(buf, match, (cp-match)+1 <= sizeof(buf) ?
  768.                          (cp-match)+1 :  sizeof(buf));    
  769.     cidr_bits = atoi(cp+1);
  770.     
  771.     if(cidr_bits > 0 && cidr_bits < 33) {
  772.       int shift = 32 - cidr_bits;
  773.       
  774.       cidr_mode = 1;
  775.       while(cidr_bits--)
  776. cidr_mask = (cidr_mask << 1) | 1;
  777.       cidr_mask = cidr_mask << shift;
  778. #ifdef HAVE_INET_ATON
  779.       if(inet_aton(mask,&cidr_addr) == 0)
  780. return 0;
  781. #else
  782.       cidr_addr.s_addr = inet_addr(mask);
  783. #endif
  784.       cidr_addr.s_addr &= htonl(cidr_mask);
  785.     } else {
  786.       return 0;
  787.     }
  788.   } else {
  789.     sstrcat(buf, match, sizeof(buf));
  790.   }
  791.   
  792.   if(cidr_mode) {
  793.     if((addr->s_addr & htonl(cidr_mask)) == cidr_addr.s_addr)
  794.       return 1;
  795.   } else {
  796.     if(fnmatch(buf, name, FNM_NOESCAPE) == 0 ||
  797.        fnmatch(buf, inet_ntoa(*addr), FNM_NOESCAPE) == 0)
  798.       return 1;
  799.   }
  800.   
  801.   return 0;
  802. }
  804. static int _check_ip_access(xaset_t *conf, char *name)
  805. {
  806.   char **argv;
  807.   int argc; 
  809.   config_rec *c = find_config(conf,CONF_PARAM,name,FALSE);
  811.   while(c) {
  812.     for(argc = c->argc, argv = (char**)c->argv; argc; argc--, argv++) {
  813.       switch(match_ip(session.c->remote_ipaddr,session.c->remote_name,*argv)) {
  814.       case 1: return TRUE;
  815.       case -1: return FALSE;
  816.       default: break; /* avoid compiler warning */
  817.       }
  818.     }
  820.     c = find_config_next(c,c->next,CONF_PARAM,name,FALSE);
  821.   }
  823.   return FALSE;
  824. }
  826. /* 1 if allowed, 0 otherwise */
  828. static int _check_limit_allow(config_rec *c)
  829. {
  830.   /* if session.groups is null, this means no authentication
  831.    * attempt has been made, so we simply check for the
  832.    * very existance of an AllowGroup, and assume (for now) it's
  833.    * allowed.  This works because later calls to _check_limit_allow
  834.    * WILL have filled in the group members and we can truely check
  835.    * group membership at that time.  Same goes for AllowUser.
  836.    */
  838.   if(!session.user) {
  839.     if(find_config(c->subset,CONF_PARAM,"AllowUser", FALSE))
  840.       return 1;
  841.   } else if(_check_user_access(c->subset,"AllowUser"))
  842.     return 1;
  844.   if(!session.groups) {
  845.     if(find_config(c->subset,CONF_PARAM,"AllowGroup",FALSE))
  846.       return 1;
  847.   } else if(_check_group_access(c->subset,"AllowGroup"))
  848.     return 1;
  849.   if(_check_ip_access(c->subset,"Allow"))
  850.     return 1;
  851.   if(get_param_int(c->subset,"AllowAll",FALSE) == 1)
  852.     return 1;
  854.   return 0;
  855. }
  857. static int _check_limit_deny(config_rec *c)
  858. {
  859.   if(get_param_int(c->subset,"DenyAll",FALSE) == 1)
  860.     return 1;
  861.   if(session.user && _check_user_access(c->subset,"DenyUser"))
  862.     return 1;
  863.   if(session.groups && _check_group_access(c->subset,"DenyGroup"))
  864.     return 1;
  865.   if(_check_ip_access(c->subset,"Deny"))
  866.     return 1;
  867.   return 0;
  868. }
  870. /* _check_limit returns 1 if allowed, 0 if implicitly allowed,
  871.  * and -1 if implicitly denied and -2 if explicitly denied.
  872.  */
  873.    
  874. static int _check_limit(config_rec *c)
  875. {
  876.   int order;
  878.   if((order = get_param_int(c->subset,"Order",FALSE)) == -1)
  879.     order = ORDER_ALLOWDENY;
  881.   if(order == ORDER_DENYALLOW) {
  882.     /* check deny first */
  883.     if(_check_limit_deny(c))
  884.       return -2; /* explicit deny */
  885.     if(_check_limit_allow(c))
  886.       return 1; /* explicit allow */
  888.     return -1;     /* implicit deny */
  889.   }
  891.   /* check allow first */
  892.   if(_check_limit_allow(c))
  893.     return 1; /* explicit allow */
  894.   if(_check_limit_deny(c))
  895.     return -2; /* explicit deny */
  897.   return 0; /* implicit allow */
  898. }
  900. /* Note: if and == 1, the logic is short circuited so that the first
  901.  * failure results in a FALSE return from the entire function, if and
  902.  * == 0, an ORing operation is assumed and the function will return
  903.  * TRUE if any <limit LOGIN> allows access.
  904.  */
  906. int login_check_limits(xaset_t *conf, int recurse, 
  907.                        int and, int *found)
  908. {
  909.   int res = and;
  910.   int rfound;
  911.   config_rec *c;
  912.   int argc;
  913.   char **argv;
  915.   *found = 0;
  917.   if(!conf || !conf->xas_list)
  918.     return TRUE; /* default is to allow */
  920.   /* First check top level */
  921.   for(c = (config_rec*)conf->xas_list; c; c=c->next)
  922.     if(c->config_type == CONF_LIMIT) {
  923.       for(argc = c->argc, argv = (char**)c->argv; argc; argc--, argv++)
  924.         if(!strcasecmp("LOGIN",*argv))
  925.           break;
  927.       if(argc) {
  928.         if(and) {
  929.           switch(_check_limit(c)) {
  930.           case 1: res = (res && TRUE); (*found)++; break;
  931.   case -1:
  932.           case -2: res = (res && FALSE); (*found)++; break;
  933.           }
  934.           if(!res)
  935.             break;
  936.         } else
  937.           switch(_check_limit(c)) {
  938.           case 1: res = TRUE;
  939.   case -1:
  940.           case -2: (*found)++; break;
  941.           }
  942.       }
  943.     }
  945.   if( ((res && and) || (!res && !and && *found)) && recurse ) {
  946.     for(c = (config_rec*)conf->xas_list; c; c=c->next)
  947.       if(c->config_type == CONF_ANON && c->subset && c->subset->xas_list) {
  948.        if(and) {
  949.          res = (res && login_check_limits(c->subset,recurse,
  950.                                           and,&rfound));
  951.          (*found) += rfound;
  952.          if(!res)
  953.            break;
  954.        } else {
  955.          int rres;
  957.          rres = login_check_limits(c->subset,
  958.                                   recurse,and,&rfound);
  959.          if(rfound)
  960.            res = (res || rres);
  961.          (*found) += rfound;
  962.          if(res)
  963.            break;
  964.        }
  965.      }
  966.   }
  968.   if(!*found && !and)
  969.     return TRUE; /* Default is to allow */
  970.   return res;
  971. }
  973. int dir_check_limits(config_rec *c, char *cmd, int hidden)
  974. {
  975.   /* Check limit directives */
  976.   int res = 1;
  977.   config_rec *lc;
  978.   int i;
  980.   errno = 0;
  982.   while(c && (res == 1)) {
  983.     if(c->subset)
  984.       for(lc = (config_rec*)c->subset->xas_list; lc && (res == 1); lc=lc->next)
  985.         if(lc->config_type == CONF_LIMIT) {
  986.           for(i = 0; i < lc->argc; i++)
  987.             if(!strcmp(cmd,(char*)(lc->argv[i])))
  988.               break;
  990. /*
  991.           log_debug(DEBUG5,"cmd=%s i=%d lc->argc=%d lc->argv[0]=%sn",
  992.                     cmd, i, lc->argc, (char*)(lc->argv[i]));
  993. */
  995.           if(i == lc->argc)
  996.             continue;
  997.           /* Found a limit directive associated with the current
  998.            * command
  999.            */
  1000.           if(hidden && get_param_int(lc->subset,"IgnoreHidden",FALSE) == 1)
  1001.             { res = 0; errno = ENOENT; break; }
  1002.           switch(_check_limit(lc)) {
  1003.           case 1: res++; break;
  1004.           case -1:
  1005.           case -2: res = 0; break;
  1006.           default: continue;
  1007.           }
  1009.           break;
  1010.         }
  1013.     c = c->parent;
  1014.   }
  1016.   if(!res && !errno)
  1017.     errno = EACCES;
  1019.   return res;
  1020. }
  1022. void build_dyn_config(pool *p,char *_path, struct stat *_sbuf, int recurse)
  1023. {
  1024.   char *fullpath,*path,*dynpath,*cp;
  1025.   struct stat sbuf;
  1026.   config_rec *d;
  1027.   FILE *fp;
  1028.   cmd_rec *cmd;
  1029.   xaset_t **set = NULL;
  1030.   int isfile,removed = 0;
  1032.   /* Switch through each directory, from "deepest" up looking for
  1033.    * new or updated .ftpaccess files
  1034.    */
  1036.   if(!_path)
  1037.     return;
  1039.   path = pstrdup(p,_path);
  1041.   memcpy(&sbuf,_sbuf,sizeof(sbuf));
  1043.   if(S_ISDIR(sbuf.st_mode))
  1044.     dynpath = pdircat(p,path,"/.ftpaccess",NULL);
  1045.   else
  1046.     dynpath = NULL;
  1048.   while(path) {
  1049.     if(session.anon_root) {
  1050.       fullpath = pdircat(p,session.anon_root,path,NULL);
  1052.       if(strcmp(fullpath,"/") && *(fullpath + strlen(fullpath) - 1) == '/')
  1053.         *(fullpath + strlen(fullpath) - 1) = '';
  1054.     } else
  1055.       fullpath = path;
  1057.     if(dynpath)
  1058.       isfile = fs_stat(dynpath,&sbuf);
  1059.     else
  1060.       isfile = -1;
  1062.     d = dir_match_path(p,fullpath);
  1064.     if(!d && isfile != -1) {
  1065.       set = (session.anon_config ? &session.anon_config->subset :
  1066.              &main_server->conf);
  1067.       d = add_config_set(set,fullpath);
  1068.       d->config_type = CONF_DIR;
  1069.       d->argc = 1;
  1070.       d->argv = pcalloc(d->pool,2*sizeof(void*));
  1071.     } else if(d) {
  1072.       config_rec *newd,*dnext;
  1074.       if(isfile != -1 && strcmp(d->name,fullpath) != 0) {
  1075.         set = &d->subset;
  1076.         newd = add_config_set(set,fullpath);
  1077.         newd->config_type = CONF_DIR;
  1078.         newd->argc = 1;
  1079.         newd->argv = pcalloc(newd->pool,2*sizeof(void*));
  1080. newd->parent = d;
  1081.         d = newd;
  1082.       } else if(d->subset && d->subset->xas_list &&
  1083.                 strcmp(d->name,fullpath) == 0 && 
  1084.                 (isfile == -1 || sbuf.st_mtime > (time_t)d->argv[0])) {
  1085.         set = (d->parent ? &d->parent->subset :
  1086.                &main_server->conf);
  1088.         /* remove all old dynamic entries */
  1089.         for(newd = (config_rec*)d->subset->xas_list; newd; newd=dnext) {
  1090.           dnext = newd->next;
  1092.           if(newd->flags & CF_DYNAMIC) {
  1093.             xaset_remove(d->subset,(xasetmember_t*)newd);
  1094.             removed++;
  1095.           }
  1096.         }
  1098.         if(!d->subset->xas_list) {
  1099.           destroy_pool(d->subset->mempool);
  1100.           d->subset = NULL;
  1101.           d->argv[0] = NULL;
  1103.   /* If the file has been removed and no entries exist in this
  1104.            * dynamic entry, remove it completely
  1105.            */
  1107.           if(isfile == -1)
  1108.             xaset_remove(*set,(xasetmember_t*)d);
  1109.         }
  1110.       }
  1111.     }
  1113.     if(isfile != -1 && d && sbuf.st_mtime > (time_t)d->argv[0]) {
  1114.       /* File has been modified or not loaded yet */
  1115.       d->argv[0] = (void*)sbuf.st_mtime;
  1117.       fp = fopen(dynpath,"r");
  1118.       if(fp) {
  1119.         removed = 0;
  1121.         init_dyn_stacks(p,d);
  1122.         d->config_type = CONF_DYNDIR;
  1124.         while((cmd = get_config_cmd(p,fp)) != NULL) {
  1125.           if(cmd->argc) {
  1126.             conftable *c;
  1127.             char found = 0;
  1128.             modret_t *mr;
  1130.             cmd->server = *conf.curserver;
  1131.             cmd->config = *conf.curconfig;
  1132.               
  1133.             for(c = m_conftable; c->directive; c++)
  1134.               if(!strcasecmp(c->directive,cmd->argv[0])) {
  1135.                 ++found;
  1136.                 if((mr = call_module(c->m,c->handler,cmd)) != NULL) 
  1137.                 {
  1138.                   if(MODRET_ERRMSG(mr))
  1139.                   log_pri(LOG_WARNING,"warning: %s",MODRET_ERRMSG(mr));
  1140.                 }
  1142. if(MODRET_ISDECLINED(mr))
  1143. found--;
  1145. destroy_pool(cmd->tmp_pool);
  1146.               }
  1148.             if(!found)
  1149.               log_pri(LOG_WARNING,"warning: unknown configuration directive '%s'.",
  1150.                       cmd->argv[0]);
  1152.           }
  1153.  
  1154.           destroy_pool(cmd->pool);
  1155.         }
  1157. log_debug(DEBUG5,"dynamic configuration added/updated for %s.",
  1158.                          fullpath);
  1160.         d->config_type = CONF_DIR;
  1161.         free_dyn_stacks();
  1163.         _mergedown(*set,TRUE);
  1164.         fclose(fp);
  1165.       }
  1166.     }
  1168.     if(isfile == -1 && removed && d && set) {
  1169.       log_debug(DEBUG5,"dynamic configuration removed for %s.",
  1170.                        fullpath);
  1171.       _mergedown(*set,FALSE);
  1172.     }
  1174.     if(!recurse)
  1175.       break;
  1177.     cp = rindex(path,'/');
  1178.     if(cp && strcmp(path,"/") != 0)
  1179.       *cp = '';
  1180.     else
  1181.       path = NULL;
  1182.     if(path) {
  1183.       if(*(path+strlen(path)-1) == '*')
  1184.         *(path+strlen(path)-1) = '';
  1185.       dynpath = pdircat(p,path,"/.ftpaccess",NULL);
  1186.     }
  1187.   }
  1188. }
  1190. /* dir_check_full() fully recurses the path passed
  1191.  * returns 1 if operation is allowed on current path,
  1192.  * or 0 if not.
  1193.  */
  1195. int dir_check_full(pool *pp, char *cmd, char *group, char *path, int *hidden)
  1196. {
  1197.   char *fullpath,*grpowner;
  1198.   config_rec *c;
  1199.   struct stat sbuf;
  1200.   pool *p;
  1201.   int res = 1,hid,_umask = 0,isfile;
  1203.   if(!hidden)
  1204.     hidden = &hid;
  1206.   *hidden = 0;
  1207.   p = make_sub_pool(pp);
  1209.   /* flood -- this is no longer needed, as all paths passed to 
  1210.    * dir_check should have gone through either dir_canonical or
  1211.    * dir_real first (depending on if they are supposed to pre-exist
  1213.   fullpath = dir_realpath(p,path);
  1215.   if(!fullpath)
  1216.     fullpath = pdircat(p,session.cwd,path,NULL);
  1217.   else 
  1218.     path = fullpath;
  1219.   */
  1221.   fullpath = path;
  1223.   if(session.anon_root)
  1224.     fullpath = pdircat(p,session.anon_root,fullpath,NULL);
  1226.   log_debug(DEBUG5,"in dir_check(): path = '%s', fullpath = '%s'.",
  1227.             path,fullpath);
  1229.   /* Check and build all appropriate dynamic configuration entries */
  1230.   if((isfile = fs_stat(path,&sbuf)) == -1)
  1231.     bzero(&sbuf,sizeof(sbuf));
  1233.   build_dyn_config(p,path,&sbuf,1);
  1235.   session.dir_config = c = dir_match_path(p,fullpath);
  1237.   if(!c && session.anon_config)
  1238.     c = session.anon_config;
  1240.   if(_kludge_disable_umask || 
  1241.       (_umask = get_param_int(CURRENT_CONF,"Umask",FALSE)) == -1)
  1242.     _umask = 0;
  1244.   if((grpowner = get_param_ptr(CURRENT_CONF,"GroupOwner",FALSE)) != NULL) {
  1245.     /* attempt chgrp on all new files */
  1246.     struct group *gr;
  1248.     if((gr = auth_getgrnam(p,grpowner)) != NULL)
  1249.       session.fsgid = gr->gr_gid;
  1250.   }
  1252.   if(isfile != -1) {
  1253.     *hidden = !_dir_check_op(p,CURRENT_CONF,OP_HIDE,sbuf.st_uid,sbuf.st_gid,sbuf.st_mode);
  1254.     res = _dir_check_op(p,CURRENT_CONF,OP_COMMAND,sbuf.st_uid,sbuf.st_gid,sbuf.st_mode);
  1255.   }
  1257.   if(res) {
  1258.     res = dir_check_limits(c,cmd,*hidden);
  1260.     /* If specifically allowed, res will be > 1 and we don't want to
  1261.      * check the command group limit
  1262.      */
  1264.     if(res == 1 && group)
  1265.       res = dir_check_limits(c,group,*hidden);
  1267.     /* if still == 1, no explicit allow so check lowest priority "ALL" group */
  1268.     if(res == 1)
  1269.       res = dir_check_limits(c,"ALL",*hidden);
  1270.   }
  1272.   if(res && _umask)
  1273.     umask(_umask);
  1275.   destroy_pool(p);
  1276.   return res;
  1277. }
  1279. /* dir_check() checks the current dir configuration against the path,
  1280.  * if it matches (partially), a search is done only in the subconfig,
  1281.  * otherwise handed off to dir_check_full
  1282.  */
  1284. int dir_check(pool *pp, char *cmd, char *group, char *path, int *hidden)
  1285. {
  1286.   char *fullpath,*grpowner;
  1287.   config_rec *c;
  1288.   struct stat sbuf;
  1289.   pool *p;
  1290.   int res = 1,hid,_umask = 0,isfile;
  1292.   p = make_sub_pool(pp);
  1294.   fullpath = path;
  1296.   if(session.anon_root)
  1297.     fullpath = pdircat(p,session.anon_root,fullpath,NULL);
  1299.   c = (session.dir_config ? session.dir_config :
  1300.         (session.anon_config ? session.anon_config : NULL));
  1302.   if(!c || strncmp(c->name,fullpath,strlen(c->name)) != 0) {
  1303.     destroy_pool(p);
  1304.     return dir_check_full(pp,cmd,group,path,hidden);
  1305.   }
  1307.   if(!hidden)
  1308.     hidden = &hid;
  1310.   *hidden = 0;
  1312.   /* Check and build all appropriate dynamic configuration entries */
  1313.   if((isfile = fs_stat(path,&sbuf)) == -1)
  1314.     bzero(&sbuf,sizeof(sbuf));
  1316.   build_dyn_config(p,path,&sbuf,0);
  1318.   session.dir_config = c = dir_match_path(p,fullpath);
  1320.   if(!c && session.anon_config)
  1321.     c = session.anon_config;
  1323.   if(_kludge_disable_umask ||
  1324.        (_umask = get_param_int(CURRENT_CONF,"Umask",FALSE)) == -1)
  1325.     _umask = 0;
  1327.   if((grpowner = get_param_ptr(CURRENT_CONF,"GroupOwner",FALSE)) != NULL) {
  1328.     /* attempt chgrp on all new files */
  1329.     struct group *gr;
  1331.     if((gr = auth_getgrnam(p,grpowner)) != NULL)
  1332.       session.fsgid = gr->gr_gid;
  1333.   }
  1335.   if(isfile != -1) {
  1336.     *hidden = !_dir_check_op(p,CURRENT_CONF,OP_HIDE,sbuf.st_uid,sbuf.st_gid,sbuf.st_mode);
  1337.     res = _dir_check_op(p,CURRENT_CONF,OP_COMMAND,sbuf.st_uid,sbuf.st_gid,sbuf.st_mode);
  1338.   }
  1340.   if(res) {
  1341.     res = dir_check_limits(c,cmd,*hidden);
  1343.     /* If specifically allowed, res will be > 1 and we don't want to
  1344.      * check the command group limit
  1345.      */
  1347.     if(res == 1 && group)
  1348.       res = dir_check_limits(c,group,*hidden);
  1350.     /* if still == 1, no explicit allow so check lowest priority "ALL" group */
  1351.     if(res == 1)
  1352.       res = dir_check_limits(c,"ALL",*hidden);
  1353.   }
  1355.   if(res && _umask)
  1356.     umask(_umask);
  1358.   destroy_pool(p);
  1359.   return res;
  1360. }
  1362. /* dir_check_canon() canonocalizes as much of the path as possible
  1363.  * (which may not be all of it, as the target may not yet exist
  1364.  * then we hand off to dir_check()
  1365.  */
  1367. int dir_check_canon(pool *pp, char *cmd, char *group, char *path, int *hidden)
  1368. {
  1369.   return dir_check(pp,cmd,group,dir_best_path(pp,path),hidden);
  1370. }
  1372. /*
  1373.  * Move all the members (i.e. a "branch") of one config set to
  1374.  * a different parent.
  1375.  */
  1377. static void _reparent_all(config_rec *newparent,xaset_t *set)
  1378. {
  1379.   config_rec *c,*cnext;
  1381.   if(!newparent->subset)
  1382.     newparent->subset = xaset_create(newparent->pool,NULL);
  1384.   for(c = (config_rec*)set->xas_list; c; c = cnext) {
  1385.     cnext = c->next;
  1386.     xaset_remove(set,(xasetmember_t*)c);
  1387.     xaset_insert(newparent->subset,(xasetmember_t*)c);
  1388.     c->set = newparent->subset;
  1389.     c->parent = newparent;
  1390.   }
  1391. }
  1393. /* Recursively find the most appropriate place to move a CONF_DIR
  1394.  * directive to.
  1395.  */
  1397. static config_rec *_find_best_dir(xaset_t *set,char *path,int *matchlen)
  1398. {
  1399.   config_rec *c,*res = NULL,*rres;
  1400.   int len,imatchlen,tmatchlen;
  1402.   *matchlen = 0;
  1404.   if(!set || !set->xas_list)
  1405.     return NULL;
  1407.   for(c = (config_rec*)set->xas_list; c; c=c->next) {
  1408.     if(c->config_type == CONF_DIR) {
  1409.       if(!strcmp(c->name,path))
  1410.         continue; /* Don't examine the current */
  1411.       len = strlen(c->name);
  1412.       while(len > 0 && (*(c->name+len-1) == '*' ||
  1413.                         *(c->name+len-1) == '/'))
  1414.         len--;
  1416.       if(!strncmp(c->name,path,len) &&
  1417.          len < strlen(path)) {
  1418.            rres = _find_best_dir(c->subset,path,&imatchlen);
  1419.            tmatchlen = _strmatch(path,c->name);
  1420.            if(!rres && tmatchlen > *matchlen) {
  1421.              res = c;
  1422.              *matchlen = tmatchlen;
  1423.            } else if(imatchlen > *matchlen) {
  1424.              res = rres;
  1425.              *matchlen = imatchlen;
  1426.            }     
  1427.          }
  1428.     }
  1429.   }
  1431.   return res;
  1432. }
  1434. /* Reorder all the CONF_DIR configuration sections, so that they are
  1435.  * in directory tree order
  1436.  */
  1438. static void _reorder_dirs(xaset_t *set, int mask)
  1439. {
  1440.   config_rec *c,*cnext,*newparent;
  1441.   int tmp,defer = 0;
  1443.   if(!set || !set->xas_list)
  1444.     return;
  1446.   if(!(mask & CF_DEFER))
  1447.     defer = 1;
  1449.   for(c = (config_rec*)set->xas_list; c; c=cnext) {
  1450.     cnext = c->next;
  1452.     if(c->config_type == CONF_DIR) {
  1453.       if(mask && !(c->flags & mask))
  1454.         continue;
  1456.       if(defer && (c->flags & CF_DEFER))
  1457.         continue;
  1459.       /* If <Directory *> is used inside <Anonymous>, move all
  1460.        * the directives from '*' into the higher level
  1461.        */
  1462.       if(!strcmp(c->name,"*") && c->parent &&
  1463.          c->parent->config_type == CONF_ANON) {
  1464.         if(c->subset)
  1465.           _reparent_all(c->parent,c->subset);
  1466.         xaset_remove(c->parent->subset,(xasetmember_t*)c);
  1467.       } else {
  1468.         newparent = _find_best_dir(set,c->name,&tmp);
  1469.         if(newparent) {
  1470.           if(!newparent->subset)
  1471.             newparent->subset = xaset_create(newparent->pool,NULL);
  1473.           xaset_remove(c->set,(xasetmember_t*)c);
  1474.           xaset_insert(newparent->subset,(xasetmember_t*)c);
  1475.           c->set = newparent->subset;
  1476.           c->parent = newparent;
  1477.         }
  1478.       }
  1479.     }
  1480.   }
  1482.   /* Top level is now sorted, now we recursively sort all the sublevels
  1483.    */
  1484.   for(c = (config_rec*)set->xas_list; c; c=c->next)
  1485.     if(c->config_type == CONF_DIR || c->config_type == CONF_ANON)
  1486.       _reorder_dirs(c->subset,mask);
  1487. }
  1489. void debug_dump_config(xaset_t *s,char *indent)
  1490. {
  1491.   config_rec *c;
  1493.   if(!indent)
  1494.     indent = "";
  1496.   for(c = (config_rec*)s->xas_list; c; c=c->next) {
  1497.     log_debug(DEBUG5,"%s%s",indent,c->name);
  1498.     if(c->subset)
  1499.       debug_dump_config(c->subset,pstrcat(permanent_pool,indent," ",NULL));
  1500.   }
  1501. }
  1503. static void _mergedown(xaset_t *s,int dynamic)
  1504. {
  1505.   config_rec *c,*dest,*newconf;
  1506.   int argc;
  1507.   void **argv,**sargv;
  1508.   
  1509.   if(!s || !s->xas_list)
  1510.     return;
  1512.   for(c = (config_rec*)s->xas_list; c; c=c->next)
  1513.     if(c->flags & CF_MERGEDOWN)
  1514.       for(dest = (config_rec*)s->xas_list; dest; dest=dest->next)
  1515.         if(dest->config_type == CONF_ANON ||
  1516.            dest->config_type == CONF_DIR) {
  1517.           /* If an option of the same name/type is found in the
  1518.            * next level down, it overrides, so we don't merge.
  1519.            */
  1520.           if(find_config(dest->subset,c->config_type,
  1521.                          c->name,FALSE))
  1522.             continue;
  1524.           if(!dest->subset)
  1525.             dest->subset = xaset_create(dest->pool,NULL);
  1527.           newconf = add_config_set(&dest->subset,c->name);
  1528.           newconf->config_type = c->config_type;
  1529.           newconf->flags = c->flags | (dynamic ? CF_DYNAMIC : 0);
  1530.           newconf->argc = c->argc;
  1531.           newconf->argv = palloc(newconf->pool,(c->argc+1)*sizeof(void*));
  1532.           argv = newconf->argv; sargv = c->argv;
  1533.           argc = newconf->argc;
  1534.           while(argc--)
  1535.             *argv++ = *sargv++;
  1536.           *argv++ = NULL;
  1537.         }
  1538.           
  1539.   /* Top level merged, recursively merge lower levels */
  1540.   for(c = (config_rec*)s->xas_list; c; c=c->next)
  1541.     if(c->subset && (c->config_type == CONF_ANON ||
  1542.                      c->config_type == CONF_DIR))
  1543.       _mergedown(c->subset,dynamic);
  1544. }
  1546. /* iterate through <Directory> blocks inside of anonymous and
  1547.  * resolve each one.
  1548.  */
  1550. void resolve_anonymous_dirs(xaset_t *clist)
  1551. {
  1552.   config_rec *c;
  1553.   char *realdir;
  1555.   if(!clist)
  1556.     return;
  1558.   for(c = (config_rec*)clist->xas_list; c; c=c->next) {
  1559.     if(c->config_type == CONF_DIR) {
  1560.       if(c->argv[1]) {
  1561.         realdir = dir_best_path(c->pool,c->argv[1]);
  1562.         if(realdir)
  1563.           c->argv[1] = realdir;
  1564.         else {
  1565.           realdir = dir_canonical_path(c->pool,c->argv[1]);
  1566.           if(realdir)
  1567.             c->argv[1] = realdir;
  1568.         }
  1569.       }
  1571.       if(c->subset)
  1572.         resolve_anonymous_dirs(c->subset);
  1573.     }
  1574.   }
  1575. }
  1577. /* iterate through directory configuration items and resolve
  1578.  * ~ references
  1579.  */
  1581. void resolve_defered_dirs(server_rec *s)
  1582. {
  1583.   config_rec *c;
  1584.   char *realdir;
  1586.   if(!s || !s->conf)
  1587.     return;
  1589.   for(c = (config_rec*)s->conf->xas_list; c; c=c->next) {
  1590.     if(c->config_type == CONF_DIR && (c->flags & CF_DEFER)) {
  1591.       realdir = dir_best_path(c->pool,c->name);
  1592.       if(realdir)
  1593.         c->name = realdir;
  1594.       else {
  1595.         realdir = dir_canonical_path(c->pool,c->name);
  1596.         if(realdir)
  1597.           c->name = realdir;
  1598.       }
  1599.     }
  1600.   }
  1601. }
  1603. static
  1604. void _copy_recur(xaset_t **set, pool *p, config_rec *c, config_rec *new_parent)
  1605. {
  1606.   config_rec *newconf;
  1607.   int argc;
  1608.   void **argv,**sargv;
  1610.   if(!*set)
  1611.     *set = xaset_create(p,NULL);
  1613.   newconf = add_config_set(set,c->name);
  1614.   newconf->config_type = c->config_type;
  1615.   newconf->flags = c->flags;
  1616.   newconf->parent = new_parent;
  1617.   newconf->argc = c->argc;
  1618.   if(c->argc) {
  1619.     newconf->argv = palloc(newconf->pool,(c->argc+1)*sizeof(void*));
  1620.     argv = newconf->argv; sargv = c->argv;
  1621.     argc = newconf->argc;
  1623.     while(argc--)
  1624.       *argv++ = *sargv++;
  1625.     if(argv)
  1626.     *argv++ = NULL;
  1627.   }
  1629.   if(c->subset && c->subset->xas_list)
  1630.     _copy_recur(&newconf->subset,p,
  1631.                 (config_rec*)c->subset->xas_list,newconf);
  1632. }
  1634. static 
  1635. void _copy_global_to_all(xaset_t *set)
  1636. {
  1637.   server_rec *s;
  1638.   config_rec *c;
  1640.   if(!set || !set->xas_list)
  1641.     return;
  1643.   for(c = (config_rec*)set->xas_list; c; c=c->next)
  1644.     for(s = (server_rec*)servers->xas_list; s; s=s->next)
  1645.       _copy_recur(&s->conf,s->pool,c,NULL);
  1646. }
  1648. void fixup_globals()
  1649. {
  1650.   server_rec *s,*smain;
  1651.   config_rec *c,*cnext;
  1653.   smain = (server_rec*)servers->xas_list;
  1654.   for(s = smain; s; s=s->next) {
  1655.     /* loop through each top level directive looking for a CONF_GLOBAL
  1656.      * context
  1657.      */
  1658.     if(!s->conf || !s->conf->xas_list)
  1659.       continue;
  1661.     for(c = (config_rec*)s->conf->xas_list; c; c=cnext) {
  1662.       cnext = c->next;
  1663.       if(c->config_type == CONF_GLOBAL) {
  1664.         /* copy the contents of the block to all other servers
  1665.          * (including this one), then pull the block "out of play".
  1666.          */
  1667.         if(c->subset && c->subset->xas_list)
  1668.           _copy_global_to_all(c->subset);
  1669.         xaset_remove(s->conf,(xasetmember_t*)c);
  1670.         if(!s->conf->xas_list) {
  1671.           destroy_pool(s->conf->mempool);
  1672.           s->conf = NULL;
  1673.         }
  1674.       }
  1675.     }
  1676.   }
  1677. }
  1679. void fixup_dirs(server_rec *s, int mask)
  1680. {
  1681.   if(!s || !s->conf)
  1682.     return;
  1684.   _reorder_dirs(s->conf,mask);
  1686.   /* Merge mergeable configuration items down
  1687.    */
  1689.   _mergedown(s->conf,FALSE);
  1691. /*
  1692.   for(c = (config_rec*)s->conf->xas_list; c; c=c->next)
  1693.     if(c->config_type == CONF_ANON)
  1694.       _reorder_dirs(c->subset);
  1695. */
  1696.   log_debug(DEBUG5,"");
  1697.   log_debug(DEBUG5,"Config for %s:",s->ServerName);
  1698.   debug_dump_config(s->conf,NULL);
  1699. }
  1701. config_rec *find_config_next(config_rec *prev, config_rec *c, int type,
  1702.                              const char *name, int recurse)
  1703. {
  1704.   config_rec *top = c;
  1706.   /* We do two searches (if recursing) so that we find the "deepest"
  1707.    * level first.
  1708.    */
  1710.   if(!c && !prev)
  1711.     return NULL;
  1713.   if(!prev)
  1714.     prev = top;
  1716.   if(recurse) {
  1717.     do {
  1718.       config_rec *res = NULL;
  1720.       for(c = top; c; c=c->next) {
  1721.         if(c->subset && c->subset->xas_list)
  1722.           res = find_config_next(NULL,(config_rec*)c->subset->xas_list,
  1723.                                  type,name,recurse+1);
  1724.           if(res)
  1725.             return res;
  1726.         }
  1728.       /* If deep recursion yielded no match try the current subset */
  1729.       for(c = top; c; c=c->next)
  1730.         if((type == -1 || type == c->config_type) &&
  1731.             (!name || !strcmp(name,c->name)))
  1732.           return c;
  1733.               
  1734.       /* Restart the search at the previous level if required */
  1735.       if(prev->parent && recurse == 1 &&
  1736.          prev->parent->next &&
  1737.          prev->parent->set != find_config_top) {
  1738.         prev = top = prev->parent->next; c = top;
  1739.         continue;
  1740.       }
  1742.       break;
  1743.     } while(1);
  1744.   } else {
  1745.     for(c = top; c; c=c->next)
  1746.       if((type == -1 || type == c->config_type) &&
  1747.          (!name || !strcmp(name,c->name)))
  1748.         return c;
  1749.   }
  1751.   return NULL;
  1752. }
  1753.     
  1754. void find_config_set_top(config_rec *c)
  1755. {
  1756.   if(c && c->parent)
  1757.     find_config_top = c->parent->set;
  1758.   else
  1759.     find_config_top = NULL;
  1760. }
  1763. config_rec *find_config(xaset_t *set, int type, const char *name, int recurse)
  1764. {
  1765.   if(!set || !set->xas_list)
  1766.     return NULL;
  1768.   find_config_set_top((config_rec*)set->xas_list);
  1770.   return find_config_next(NULL,(config_rec*)set->xas_list,type,name,recurse);
  1771. }
  1773. /* These next two functions return the first argument in a
  1774.  * CONF_PARAM configuration entry.  If more than one or all
  1775.  * parameters are needed, the caller will need to use find_config,
  1776.  * and iterate through the argv themselves.
  1777.  * _int returns -1 if the config name is not found, _ptr returns
  1778.  * NULL.
  1779.  */
  1781. long get_param_int(xaset_t *set,const char *name,int recurse)
  1782. {
  1783.   config_rec *c;
  1785.   if(!set) {
  1786.     _last_param_int = NULL;
  1787.     return -1;
  1788.   }
  1790.   c = find_config(set,CONF_PARAM,name,recurse);
  1792.   if(c && c->argc) {
  1793.     _last_param_int = c;
  1794.     return (long)c->argv[0];
  1795.   }
  1797.   _last_param_int = NULL;
  1798.   return -1;  /* Parameters aren't allowed to contain neg. integers anyway */
  1799. }
  1801. long get_param_int_next(const char *name,int recurse)
  1802. {
  1803.   config_rec *c;
  1805.   if(!_last_param_int || !_last_param_int->next) {
  1806.     _last_param_int = NULL;
  1807.     return -1;
  1808.   }
  1810.   c = find_config_next(_last_param_int,_last_param_int->next,
  1811.                        CONF_PARAM,name,recurse);
  1813.   if(c && c->argc) {
  1814.     _last_param_int = c;
  1815.     return (long)c->argv[0];
  1816.   }
  1818.   _last_param_int = NULL;
  1819.   return -1;
  1820. }
  1822. void *get_param_ptr(xaset_t *set,const char *name,int recurse)
  1823. {
  1824.   config_rec *c;
  1826.   if(!set) {
  1827.     _last_param_ptr = NULL;
  1828.     return NULL;
  1829.   }
  1831.   c = find_config(set,CONF_PARAM,name,recurse);
  1833.   if(c && c->argc) {
  1834.     _last_param_ptr = c;
  1835.     return c->argv[0];
  1836.   }
  1838.   _last_param_ptr = NULL;
  1839.   return NULL;
  1840. }
  1842. void *get_param_ptr_next(const char *name,int recurse)
  1843. {
  1844.   config_rec *c;
  1846.   if(!_last_param_ptr || !_last_param_ptr->next) {
  1847.     _last_param_ptr = NULL;
  1848.     return NULL;
  1849.   }
  1851.   c = find_config_next(_last_param_ptr,_last_param_ptr->next,
  1852.                        CONF_PARAM,name,recurse);
  1854.   if(c && c->argv) {
  1855.     _last_param_ptr = c;
  1856.     return c->argv[0];
  1857.   }
  1859.   _last_param_ptr = NULL;
  1860.   return NULL;
  1861. }
  1863. int remove_config(xaset_t *set, const char *name,int recurse)
  1864. {
  1865.   server_rec *s = (conf.curserver ? *conf.curserver : main_server);
  1866.   config_rec *c;
  1867.   int found = 0;
  1868.   xaset_t *fset;
  1870.   while((c = find_config(set,-1,name,recurse)) != NULL) {
  1871.     found++;
  1873.     fset = c->set;
  1874.     xaset_remove(fset,(xasetmember_t*)c);
  1876.     if(!fset->xas_list) {
  1877.       if(c->parent && c->parent->subset == fset) {
  1878.         c->parent->subset = NULL;
  1879.         destroy_pool(fset->mempool);
  1880.       } else if(s->conf == fset) {
  1881.         s->conf = NULL;
  1882.         destroy_pool(fset->mempool);
  1883.       }
  1884.     }
  1885.   }
  1887.   return found;
  1888. }
  1889.         
  1890. config_rec *add_config_param_set(xaset_t **set,const char *name,int num,...)
  1891. {
  1892.   config_rec *c = add_config_set(set,name);
  1893.   void **argv;
  1894.   va_list ap;
  1896.   if(c) {
  1897.     c->config_type = CONF_PARAM;
  1898.     c->argc = num;
  1899.     c->argv = pcalloc(c->pool,(num+1)*sizeof(void*));
  1901.     argv = c->argv;
  1902.     va_start(ap,num);
  1904.     while(num-- > 0)
  1905.       *argv++ = va_arg(ap,void*);
  1908.     va_end(ap);
  1909.   }
  1911.   return c;
  1912. }
  1914. config_rec *add_config_param_str(const char *name, int num, ...)
  1915. {
  1916.   config_rec *c = add_config(name);
  1917.   char *arg;
  1918.   void **argv;
  1919.   va_list ap;
  1921.   if(c) {
  1922.     c->config_type = CONF_PARAM;
  1923.     c->argc = num;
  1924.     c->argv = pcalloc(c->pool,(num+1) * sizeof(char*));
  1926.     argv = c->argv;
  1927.     va_start(ap,num);
  1929.     while(num-- > 0) {
  1930.       arg = va_arg(ap,char*);
  1931.       if(arg)
  1932.         *argv++ = pstrdup(permanent_pool,arg);
  1933.       else
  1934.         *argv++ = NULL;
  1935.     }
  1937.     va_end(ap);
  1938.   }
  1940.   return c;
  1941. }
  1943. config_rec *add_config_param(const char *name,int num,...)
  1944. {
  1945.   config_rec *c = add_config(name);
  1946.   void **argv;
  1947.   va_list ap;
  1949.   if(c) {
  1950.     c->config_type = CONF_PARAM;
  1951.     c->argc = num;
  1952.     c->argv = pcalloc(c->pool,(num+1) * sizeof(void*));
  1953.     
  1954.     argv = c->argv;
  1955.     va_start(ap,num);
  1957.     while(num-- > 0)
  1958.       *argv++ = va_arg(ap,void*);
  1960.     va_end(ap);
  1961.   }
  1963.   return c;
  1964. }
  1966. int parse_config_file(const char *fname)
  1967. {
  1968.   FILE *fp;
  1969.   cmd_rec *cmd;
  1970.   pool *tmp_pool = make_sub_pool(permanent_pool);
  1971.   modret_t *mr;
  1972.  
  1973.   fp = pfopen(tmp_pool,fname,"r");
  1975.   if(!fp) { destroy_pool(tmp_pool); return -1; }
  1976.   
  1977.   while((cmd = get_config_cmd(tmp_pool,fp)) != NULL) {
  1978.     if(cmd->argc) {
  1979.       conftable *c;
  1980.       char found = 0;
  1982.       cmd->server = *conf.curserver;
  1983.       cmd->config = *conf.curconfig;
  1985.       for(c = m_conftable; c->directive; c++)
  1986.         if(!strcasecmp(c->directive,cmd->argv[0])) {
  1987.           ++found;
  1988.           if((mr = call_module(c->m,c->handler,cmd)) != NULL) {
  1989.             if(MODRET_ISERROR(mr)) {
  1990.             log_pri(LOG_ERR,"Fatal: %s",MODRET_ERRMSG(mr));
  1991.             exit(1);
  1992.     }
  1993.           }
  1995.   if(MODRET_ISDECLINED(mr))
  1996.     found--;
  1998.           destroy_pool(cmd->tmp_pool);
  1999.         }
  2001.        if(!found) {
  2002.          log_pri(LOG_ERR,"Fatal: unknown configuration directive '%s'.",
  2003.                  cmd->argv[0]);
  2004.          exit(1);
  2005.        }
  2006.     }
  2008.     destroy_pool(cmd->pool);
  2009.   }
  2011.   pfclose(tmp_pool,fp);
  2012.   destroy_pool(tmp_pool);
  2013.   return 0;
  2014. }
  2016. /* Go through each server configuration and complain if important
  2017.  * information is missing (post reading configuration files).
  2018.  * otherwise fill in defaults where applicable
  2019.  */
  2021. void fixup_servers()
  2022. {
  2023.   server_rec *s;
  2025.   fixup_globals();
  2027.   s = (server_rec*)servers->xas_list;
  2028.   if(s && !s->ServerName)
  2029.     s->ServerName = pstrdup(s->pool,"ProFTPD");
  2031.   for(; s; s=s->next) {
  2032.     if(s->ServerPort == -1)
  2033.       s->ServerPort = inet_getservport(s->pool,"ftp","tcp");
  2034.     if(!s->ServerAddress)
  2035.       s->ServerFQDN = s->ServerAddress = inet_gethostname(s->pool);
  2036.     else
  2037.       s->ServerFQDN = inet_fqdn(s->pool,s->ServerAddress);
  2039.     if(!s->ServerFQDN)
  2040.       s->ServerFQDN = s->ServerAddress;
  2042.     if(!s->ServerAdmin)
  2043.       s->ServerAdmin = pstrcat(s->pool,"root@",s->ServerFQDN,NULL);
  2044.     if(!s->ServerName) {
  2045.       server_rec *m = (server_rec*)servers->xas_list;
  2046.       s->ServerName = pstrdup(s->pool,m->ServerName);
  2047.     }
  2049.     if(!s->tcp_rwin)
  2050.       s->tcp_rwin = TUNABLE_DEFAULT_RWIN;
  2051.     if(!s->tcp_swin)
  2052.       s->tcp_swin = TUNABLE_DEFAULT_SWIN;
  2054.     s->ipaddr = inet_getaddr(s->pool,s->ServerAddress);
  2056.     if(!s->ipaddr) {
  2057.       log_pri(LOG_ERR,"Fatal: unable to determine IP address of `%s'.",
  2058.                       s->ServerAddress);
  2059.       exit(1);
  2060.     }
  2061.     if(get_param_int(s->conf,"DefaultServer",FALSE) == 1)
  2062.       s->ipaddr->s_addr = 0;
  2064.     fixup_dirs(s,0);
  2065.   }
  2067.   clear_inet_pool();
  2068. }
  2070. void init_config()
  2071. {
  2072.   pool *pool = make_sub_pool(permanent_pool);
  2074.   servers = xaset_create(pool,NULL);
  2076.   pool = make_sub_pool(permanent_pool);
  2077.   main_server = (server_rec*)pcalloc(pool,sizeof(server_rec));
  2078.   xaset_insert(servers,(xasetmember_t*)main_server);
  2080.   main_server->pool = pool;
  2081.   main_server->set = servers;
  2082. }
  2084. /* These functions are used by modules to help parse configuration.
  2085.  */
  2087. int check_conf(cmd_rec *cmd, int allowed)
  2088. {
  2089.   int x;
  2091.   x = (cmd->config && cmd->config->config_type != CONF_PARAM ?
  2092.        cmd->config->config_type : CONF_ROOT);
  2094.   return (x & allowed);
  2095. }
  2097. char *get_section_name(cmd_rec *cmd)
  2098. {
  2099.   if(!cmd->config || cmd->config->config_type == CONF_PARAM)
  2100.     return "top level";
  2102.   switch(cmd->config->config_type) {
  2103.   case CONF_DIR: return "<Directory>";
  2104.   case CONF_ANON: return "<Anonymous>";
  2105.   case CONF_LIMIT: return "<Limit>";
  2106.   case CONF_GLOBAL: return "<Global>";
  2107.   };
  2109.   return "(null)";
  2110. }
  2112. int get_boolean(cmd_rec *cmd, int av)
  2113. {
  2114.   char *cp = cmd->argv[av];
  2116.   /* Boolean string can be "on","off","yes","no",
  2117.    * "true","false","1" or "0"
  2118.    */
  2120.   if(!strcasecmp(cp,"on"))
  2121.     return 1;
  2122.   if(!strcasecmp(cp,"off"))
  2123.     return 0;
  2124.   if(!strcasecmp(cp,"yes"))
  2125.     return 1;
  2126.   if(!strcasecmp(cp,"no"))
  2127.     return 0;
  2128.   if(!strcasecmp(cp,"true"))
  2129.     return 1;
  2130.   if(!strcasecmp(cp,"false"))
  2131.     return 0;
  2132.   if(!strcasecmp(cp,"1"))
  2133.     return 1;
  2134.   if(!strcasecmp(cp,"0"))
  2135.     return 0;
  2137.   return -1;
  2138. }
  2140. char *get_full_cmd(cmd_rec *cmd)
  2141. {
  2142.   pool *p = cmd->tmp_pool;
  2143.   char *res = "";
  2144.   int i;
  2146.   if(cmd->arg)
  2147.     res = pstrcat(p,cmd->argv[0]," ",cmd->arg,NULL);
  2148.   else {
  2149.     for(i = 0; i < cmd->argc; i++)
  2150.       res = pstrcat(p,res,cmd->argv[i]," ",NULL);
  2152.     while(res[strlen(res)-1] == ' ' && *res)
  2153.       res[strlen(res)-1] = '';
  2154.   }
  2156.   return res;
  2157. }