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

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

Ftp客户端

开发平台：

Unix_Linux

mod_log.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.  * Flexible logging module for proftpd
  23.  * $Id: mod_log.c,v 1.8 1999/10/01 07:57:31 macgyver Exp $
  24.  */
  26. #include "conf.h"
  28. #include "privs.h"
  30. extern response_t *resp_list,*resp_err_list;
  32. #define LOGBUF_SIZE 1025
  34. typedef struct logformat_struc logformat_t;
  35. typedef struct logfile_struc  logfile_t;
  37. struct logformat_struc {
  38.   logformat_t *next,*prev;
  40.   char *lf_nickname;
  41.   unsigned char *lf_format;
  42. };
  44. struct logfile_struc {
  45.   logfile_t *next,*prev;
  47.   int lf_fd;
  48.   int lf_classes;
  49.   char *lf_filename;
  50.   logformat_t *lf_format;
  51.   config_rec *lf_conf; /* pointer to the "owning" configuration */
  52. };
  53.   
  54. #define META_START 0xff
  55. #define META_ARG_END 0xfe
  56. #define META_ARG 1
  57. #define META_BYTES_SENT 2
  58. #define META_FILENAME 3
  59. #define META_ENV_VAR 4
  60. #define META_REMOTE_HOST 5
  61. #define META_REMOTE_IP 6
  62. #define META_IDENT_USER 7
  63. #define META_SERVER_PORT 8
  64. #define META_PID 9
  65. #define META_TIME 10
  66. #define META_SECONDS 11
  67. #define META_COMMAND 12
  68. #define META_SERVERNAME 13
  69. #define META_USER 14
  70. #define META_RESPONSE_CODE 15
  71. #define META_CLASS 16
  73. static pool *log_pool;
  74. static logformat_t *formats = NULL;
  75. static xaset_t *format_set = NULL;
  76. static logfile_t *logs = NULL;
  77. static xaset_t *log_set = NULL;
  79. /* format string args:
  80.    %c - class
  81.    %b - bytes sent for request
  82.    %f - filename
  83.    %{FOOBAR}e - contents of environment variable FOOBAR
  84.    %h - remote host
  85.    %a - remote IP-address
  86.    %l - remote logname (from identd)
  87.    %p - Port of server serving request
  88.    %P - Process ID of child serving request
  89.    %r - Full request (command)
  90.    %t - Time
  91.    %{format}t - formatted time (strftime(3) format)
  92.    %T - Time taken to serve request, in seconds
  93.    %s - Reponse code (status)
  94.    %u - Local user
  95.    %v - Servername of server serving request
  96. */
  98. static
  99. void add_meta(unsigned char **s, unsigned char meta, int args, ...)
  100. {
  101.   int arglen;
  102.   char *arg;
  104.   **s = META_START;
  105.   (*s) = (*s) + 1;
  106.   **s = meta;
  107.   (*s) = (*s) + 1;
  109.   if(args) {
  110.     va_list ap;
  111.     va_start(ap,args);
  113.     while(args--) {
  114.       arglen = va_arg(ap,int);
  115.       arg = va_arg(ap,char*);
  117.       bcopy(arg,*s,arglen);
  118.       (*s) = (*s) + arglen;
  119.       **s = META_ARG_END;
  120.       (*s) = (*s) + 1;
  121.     }
  123.     va_end(ap);
  124.   }
  125. }
  127. static
  128. char *preparse_arg(char **s)
  129. {
  130.   char *ret = (*s) + 1;
  132.   (*s) = (*s) + 1;
  133.   while(**s && **s != '}')
  134.     (*s) = (*s) + 1;
  136.   **s = 0;
  137.   (*s) = (*s) + 1;
  138.   return ret;
  139. }
  141. static
  142. void logformat(char *nickname, char *fmts)
  143. {
  144.   char *tmp,*arg;
  145.   unsigned char format[1024],*outs;
  146.   logformat_t *lf;
  148.   outs = format;
  149.   for(tmp = fmts; *tmp; ) {
  150.     if(*tmp == '%') {
  151.       arg = NULL;
  152.       tmp++;
  153.       for(;;) {
  154.         switch(*tmp) {
  155.         case '{':
  156.           arg = preparse_arg(&tmp);
  157.           continue;
  158.         case 'b':
  159.           add_meta(&outs,META_BYTES_SENT,0);
  160.           break;
  161.         case 'c':
  162.           add_meta(&outs,META_CLASS,0);
  163.           break;
  164.         case 'f':
  165.           add_meta(&outs,META_FILENAME,0);
  166.           break;
  167.         case 'e':
  168.           if(arg) {
  169.             add_meta(&outs,META_ENV_VAR,0);
  170.             add_meta(&outs,META_ARG,1,(int)strlen(arg),arg);
  171.           }
  172.           break;
  173.         case 'h':
  174.           add_meta(&outs,META_REMOTE_HOST,0);
  175.           break;
  176.         case 'a':
  177.           add_meta(&outs,META_REMOTE_IP,0);
  178.           break;
  179.         case 'l':
  180.           add_meta(&outs,META_IDENT_USER,0);
  181.           break;
  182.         case 'p': 
  183.           add_meta(&outs,META_SERVER_PORT,0);
  184.           break;
  185.         case 'P':
  186.           add_meta(&outs,META_PID,0);
  187.           break;
  188.         case 't':
  189.           add_meta(&outs,META_TIME,0);
  190.           if(arg)
  191.             add_meta(&outs,META_ARG,1,(int)strlen(arg),arg);
  192.           break;
  193.         case 'T':
  194.           add_meta(&outs,META_SECONDS,0);
  195.           break;
  196.         case 'u':
  197.           add_meta(&outs,META_USER,0);
  198.           break;
  199.         case 'r':
  200.           add_meta(&outs,META_COMMAND,0);
  201.           break;
  202.         case 'v':
  203.           add_meta(&outs,META_SERVERNAME,0);
  204.           break;
  205.         case 's':
  206.           add_meta(&outs,META_RESPONSE_CODE,0);
  207.           break;
  208.         case '%':
  209.           *outs++ = '%';
  210.           break;
  211.         }
  212. tmp++;
  213. break;
  214.       }
  215.     } else
  216.       *outs++ = *tmp++;
  217.   }
  219.   *outs++ = 0;
  221.   lf = (logformat_t*)pcalloc(log_pool,sizeof(logformat_t));
  222.   lf->lf_nickname = pstrdup(log_pool,nickname);
  223.   lf->lf_format = palloc(log_pool,outs - format);
  224.   bcopy(format,lf->lf_format,outs-format);
  226.   if(!format_set)
  227.     format_set = xaset_create(log_pool,NULL);
  229.   xaset_insert_end(format_set,(xasetmember_t*)lf);
  230.   formats = (logformat_t*)format_set->xas_list;
  231. }
  233. /* Syntax: LogFormat nickname "format string"
  234.  */
  236. MODRET add_logformat(cmd_rec *cmd)
  237. {
  238.   CHECK_ARGS(cmd,2);
  239.   CHECK_CONF(cmd,CONF_ROOT);
  241.   logformat(cmd->argv[1],cmd->argv[2]);
  242.   return HANDLED(cmd);
  243. }
  245. static int _parse_classes(char *s)
  246. {
  247.   int classes = 0;
  248.   char *nextp = NULL;
  250.   do {
  252.     if((nextp = strchr(s,',')))
  253.       *nextp++ = '';
  255.     if(!nextp) {
  256.       if((nextp = strchr(s,'|')))
  257.         *nextp++ = '';
  258.     }
  260.     if(!strcasecmp(s,"NONE"))
  261.       { classes = CL_NONE; break; }
  262.     if(!strcasecmp(s,"ALL"))
  263.       { classes = CL_ALL; break; }
  264.     else if(!strcasecmp(s,"AUTH"))
  265.       classes |= CL_AUTH;
  266.     else if(!strcasecmp(s,"INFO"))
  267.       classes |= CL_INFO;
  268.     else if(!strcasecmp(s,"DIRS"))
  269.       classes |= CL_DIRS;
  270.     else if(!strcasecmp(s,"READ"))
  271.       classes |= CL_READ;
  272.     else if(!strcasecmp(s,"WRITE"))
  273.       classes |= CL_WRITE;
  274.     else if(!strcasecmp(s,"MISC"))
  275.       classes |= CL_MISC;
  276.   } while((s = nextp));
  278.   return classes;
  279. }
  281. /* Syntax: ExtendedLog <log-filename> [<cmd-classes> [<format-nickname>]]
  282.  */
  284. MODRET add_extendedlog(cmd_rec *cmd)
  285. {
  286.   config_rec *c;
  287.   int argc;
  288.   char **argv;
  290.   CHECK_CONF(cmd,CONF_ROOT|CONF_VIRTUAL|CONF_ANON|CONF_GLOBAL);
  292.   argc = cmd->argc;
  293.   argv = cmd->argv;
  295.   if(argc < 2)
  296.     CONF_ERROR(cmd,"Syntax: ExtendedLog <log-filename> [<command-classes> [<format-nickname>]]");
  298.   c = add_config_param("ExtendedLog",3,NULL,NULL,NULL);
  300.   if(cmd->argv[1][0] != '/')
  301.     c->argv[0] = dir_canonical_path(log_pool,cmd->argv[1]);
  302.   else
  303.     c->argv[0] = pstrdup(log_pool,cmd->argv[1]);
  305.   if(argc > 2)
  306.     c->argv[1] = pstrdup(log_pool,cmd->argv[2]);
  307.   if(argc > 3)
  308.     c->argv[2] = pstrdup(log_pool,cmd->argv[3]);
  310.   c->argc = argc-1;
  311.   return HANDLED(cmd);
  312. }
  314. /* Syntax: SystemLog <filename> */
  316. MODRET set_systemlog(cmd_rec *cmd)
  317. {
  318.   char *syslogfn;
  319.   int ret;
  320.   
  321.   CHECK_ARGS(cmd,1);
  322.   CHECK_CONF(cmd,CONF_ROOT);
  324.   log_closesyslog();
  326.   syslogfn = cmd->argv[1];
  328.   if(strcasecmp(syslogfn,"NONE") == 0) {
  329.     log_discard();
  330.     return HANDLED(cmd);
  331.   }
  333.   if(*syslogfn != '/') 
  334.     syslogfn = dir_canonical_path(cmd->tmp_pool,syslogfn);
  336.   block_signals();
  337.   PRIVS_ROOT
  339.     if((ret = log_opensyslog(syslogfn)) < 0) {
  340.       int xerrno = errno;
  341.       
  342.       PRIVS_RELINQUISH
  343.       unblock_signals();
  344.       
  345.       if(ret == -2) {
  346. CONF_ERROR(cmd, "you are attempting to log to a world writeable directory");
  347.       } else {
  348. CONF_ERROR(cmd,pstrcat(cmd->tmp_pool,"unable to redirect logging to '",
  349.        syslogfn,"': ",strerror(xerrno),NULL));
  350.       }
  351.     }
  352.   
  353.   PRIVS_RELINQUISH
  354.   unblock_signals();
  356.   return HANDLED(cmd);
  357. }
  359. #ifdef HAVE_GMTOFF
  360. static
  361. struct tm *_get_gmtoff(int *tz)
  362. {
  363.   time_t tt = time(NULL);
  364.   struct tm *t;
  366.   t = localtime(&tt);
  367.   *tz = (int)(t->tm_gmtoff / 60)
  368.   return t;
  369. }
  370. #else
  371. static
  372. struct tm *_get_gmtoff(int *tz)
  373. {
  374.   time_t tt = time(NULL);
  375.   struct tm gmt;
  376.   struct tm *t;
  377.   int days,hours,minutes;
  379.   gmt = *gmtime(&tt);
  380.   t = localtime(&tt);
  382.   days = t->tm_yday - gmt.tm_yday;
  383.   hours = ((days < -1 ? 24 : 1 < days ? -24 : days * 24)
  384.           + t->tm_hour - gmt.tm_hour);
  385.   minutes = hours * 60 + t->tm_min - gmt.tm_min;
  386.   *tz = minutes;
  387.   return t;
  388. }
  389. #endif /* HAVE_GMTOFF */
  391. static
  392. char *get_next_meta(pool *p, cmd_rec *cmd, unsigned char **f)
  393. {
  394.   unsigned char *m;
  395.   char arg[256],*argp = NULL;
  397.   m = (*f) + 1;
  398.   switch(*m) {
  399.   case META_ARG:
  400.     m++; argp = arg;
  401.     while(*m != META_ARG_END)
  402.       *argp++ = (char)*m++;
  404.     *argp = 0; argp = arg;
  405.     m++;
  406.     break;
  408.   case META_BYTES_SENT:
  409.     argp = arg;
  410.     if(session.xfer.p)
  411.       snprintf(argp, sizeof(arg), "%lu",session.xfer.total_bytes);
  412.     else
  413.       sstrncpy(argp, "-", sizeof(arg));
  415.     m++;
  416.     break;
  418.   case META_CLASS:
  419.     argp = arg;
  420.     if(get_param_int(TOPLEVEL_CONF, "Classes", FALSE) > 0)
  421.       sstrncpy(argp, session.class->name, sizeof(arg));
  422.     else
  423.       sstrncpy(argp, "-", sizeof(arg));
  424.     m++;
  425.     break;
  427.   case META_FILENAME:
  428.     argp = arg;
  429.     if(session.xfer.p && session.xfer.path) {
  430.       char *fullpath;
  431.       fullpath = dir_abs_path(p,session.xfer.path,TRUE);
  432.       sstrncpy(argp, fullpath, sizeof(arg));
  433.     } else {
  434.       sstrncpy(argp, "-", sizeof(arg));
  435.     }
  437.     m++;
  438.     break;
  440.   case META_ENV_VAR:
  441.     argp = arg;
  442.     m++;
  444.     if(*m == META_START && *(m+1) == META_ARG) {
  445.       char *env;
  447.       env = getenv(get_next_meta(p,cmd,&m));
  448.       sstrncpy(argp, env, sizeof(arg));
  449.     }
  451.     break;
  453.   case META_REMOTE_HOST:
  454.     argp = arg;
  455.     sstrncpy(argp, session.c->remote_name, sizeof(arg));
  456.     m++;
  457.     break;
  459.   case META_REMOTE_IP:
  460.     argp = arg;
  461.     sstrncpy(argp, inet_ntoa(*session.c->remote_ipaddr), sizeof(arg));
  462.     m++;
  463.     break;
  465.   case META_IDENT_USER:
  466.     argp = arg;
  467.     sstrncpy(argp, session.ident_user, sizeof(arg));
  468.     m++;
  469.     break;
  471.   case META_SERVER_PORT:
  472.     argp = arg;
  473.     snprintf(argp, sizeof(arg), "%d", cmd->server->ServerPort);
  474.     m++;
  475.     break;
  477.   case META_PID:
  478.     argp = arg;
  479.     snprintf(argp, sizeof(arg), "%u",(unsigned int)getpid());
  480.     m++;
  481.     break;
  483.   case META_TIME:
  484.     {
  485.       char *time_fmt = "[%d/%b/%Y:%H:%M:%S ";
  486.       struct tm t;
  487.       int internal_fmt = 1;
  488.       int timz;
  489.       char sign;
  491.       argp = arg; m++;
  493.       if(*m == META_START && *(m+1) == META_ARG) {
  494.         time_fmt = get_next_meta(p,cmd,&m);
  495.         internal_fmt = 0;
  496.       }
  497.       t = *_get_gmtoff(&timz);
  498.       sign = (timz < 0 ? '-' : '+');
  499.       if(timz < 0)
  500.         timz = -timz;
  502.       strftime(argp,80,time_fmt,&t);
  503.       if(internal_fmt)
  504.         snprintf(argp + strlen(argp), sizeof(arg) - strlen(argp),
  505.                 "%c%.2d%.2d]", sign, timz/60, timz%60);
  507.     }
  508.     break;
  510.   case META_SECONDS:
  511.     argp = arg;
  512.     if(session.xfer.p) {
  513.       struct timeval end_time;
  515.       gettimeofday(&end_time,NULL);
  516.       end_time.tv_sec -= session.xfer.start_time.tv_sec;
  517.       if(end_time.tv_usec >= session.xfer.start_time.tv_usec)
  518.         end_time.tv_usec -= session.xfer.start_time.tv_usec;
  519.       else {
  520.         end_time.tv_usec = 1000000L - (session.xfer.start_time.tv_usec -
  521.                            end_time.tv_usec);
  522.         end_time.tv_sec--;
  523.       }
  525.       snprintf(argp, sizeof(arg), "%lu",(unsigned long)end_time.tv_sec);
  526.     } else {
  527.       sstrncpy(argp,"-",sizeof(arg));
  528.     }
  530.     m++;
  531.     break;
  533.   case META_COMMAND:
  534.     argp = arg;
  536.     if(!strcasecmp(cmd->argv[0],"PASS") && session.hide_password)
  537.       sstrncpy(argp, "PASS (hidden)", sizeof(arg));
  538.     else
  539.       sstrncpy(argp, get_full_cmd(cmd), sizeof(arg));
  540.     m++;
  541.     break;
  543.   case META_SERVERNAME:
  544.     argp = arg;
  546.     sstrncpy(argp,cmd->server->ServerName,sizeof(arg));
  547.     m++;
  548.     break;
  550.   case META_USER:
  551.     argp = arg;
  553.     if(!session.user) {
  554.       char *u;
  556.       u = get_param_ptr(cmd->server->conf,"UserName",FALSE);
  557.       if(!u)
  558.         u = "root";
  559.     
  560.       sstrncpy(argp, u, sizeof(arg));
  561.     } else {
  562.       sstrncpy(argp, session.user, sizeof(arg));
  563.     }
  565.     m++;
  566.     break;
  568.   case META_RESPONSE_CODE:
  569.     {
  570.       response_t *r;
  572.       argp = arg;
  573.       r = (resp_list ? resp_list : resp_err_list);
  575.       for(; r && !r->num; r=r->next) ;
  576.       if(r && r->num)
  577.         sstrncpy(argp,r->num,sizeof(arg));
  578.       else
  579.         sstrncpy(argp,"-",sizeof(arg));
  580.     }
  582.     m++;
  583.     break;
  584.   }
  586.   *f = m;
  587.   if(argp)
  588.     return pstrdup(p, argp);
  589.   else
  590.     return NULL;
  591. }
  593. static
  594. void do_log(cmd_rec *cmd, logfile_t *lf)
  595. {
  596.   unsigned char *f;
  597.   size_t size = LOGBUF_SIZE-2;
  598.   char logbuf[LOGBUF_SIZE];
  599.   logformat_t *fmt;
  600.   char *s,*bp;
  602.   fmt = lf->lf_format;
  603.   f = fmt->lf_format;
  604.   bp = logbuf;
  606.   while(*f && size) {
  607.     if(*f == META_START) {
  608.       s = get_next_meta(cmd->tmp_pool,cmd,&f);
  609.       if(s) {
  610.         size_t tmp;
  612.         tmp = strlen(s);
  613.         if(tmp > size)
  614.           tmp = size;
  616.         bcopy(s,bp,tmp);
  617.         size -= tmp;
  618.         bp += tmp;
  619.       }
  620.     } else {
  621.       *bp++ = (char)*f++;
  622.       size--;
  623.     }
  624.   }
  626.   *bp++ = 'n';
  627.   *bp = '';
  629.   write(lf->lf_fd,logbuf,strlen(logbuf));
  630. }
  632. MODRET log_command(cmd_rec *cmd)
  633. {
  634.   logfile_t *lf;
  635.   /* If not in anon mode, only handle logs for main servers */
  637.   for(lf = logs; lf; lf=lf->next)
  638.     if(lf->lf_fd != -1 && (cmd->class & lf->lf_classes)) {
  639.       if(!session.anon_config && lf->lf_conf && lf->lf_conf->config_type == CONF_ANON)
  640.         continue;
  641.       do_log(cmd,lf);
  642.     }
  644.   return DECLINED(cmd);
  645. }
  647. /* log_rehash is called whenever the master server rehashes it's
  648.  * config (in response to SIGHUP).
  649.  */
  651. static
  652. void log_rehash(void *d)
  653. {
  654.   destroy_pool(log_pool);
  656.   formats = NULL;
  657.   format_set = NULL;
  658.   logs = NULL;
  659.   log_set = NULL;
  661.   log_pool = make_sub_pool(permanent_pool);
  662.   logformat("","%h %l %u %t "%r" %s %b");
  663. }
  664.   
  665. static 
  666. int log_init()
  667. {
  668.   log_pool = make_sub_pool(permanent_pool);
  669.   /* add the "default" extendedlog format */
  670.   logformat("","%h %l %u %t "%r" %s %b");
  671.   register_rehash(NULL,log_rehash);
  672.   return 0;
  673. }
  675. static
  676. void get_extendedlogs()
  677. {
  678.   config_rec *c;
  679.   char *logfname;
  680.   int logclasses = CL_ALL;
  681.   logformat_t *logfmt;
  682.   char *logfmt_s = NULL;
  683.   logfile_t *logf;
  685.   c = find_config(main_server->conf,CONF_PARAM,"ExtendedLog",TRUE);
  687.   while(c) {
  688.     logfname = c->argv[0];
  690.     if(c->argc > 1) {
  691.       logclasses = _parse_classes(c->argv[1]);
  692.       if(c->argc > 2)
  693.         logfmt_s = c->argv[2];
  694.     }
  696.     if(logfmt_s) {
  697.       /* search for the format-nickname */
  698.       for(logfmt = formats; logfmt; logfmt=logfmt->next)
  699.         if(!strcmp(logfmt->lf_nickname,logfmt_s))
  700.           break;
  702.       if(!logfmt) {
  703.         log_pri(LOG_NOTICE,"format-nickname '%s' is not defined.",
  704.                            logfmt_s);
  705.         goto loop_extendedlogs;
  706.       }
  707.     } else
  708.       logfmt = formats;
  710.     logf = (logfile_t*)pcalloc(permanent_pool,sizeof(logfile_t));
  711.     logf->lf_fd = -1;
  712.     logf->lf_classes = logclasses;
  713.     logf->lf_filename = pstrdup(permanent_pool,logfname);
  714.     logf->lf_format = logfmt;
  715.     logf->lf_conf = c->parent;
  716.     if(!log_set)
  717.       log_set = xaset_create(permanent_pool,NULL);
  719.     xaset_insert(log_set,(xasetmember_t*)logf);
  720.     logs = (logfile_t*)log_set->xas_list;
  722. loop_extendedlogs:
  723.     c = find_config_next(c,c->next,CONF_PARAM,"ExtendedLog",TRUE);
  724.   }
  725. }
  727. MODRET log_auth_complete(cmd_rec *cmd)
  728. {
  729.   logfile_t *lf;
  731.   /* authentication is complete, if we aren't in anon-mode, close
  732.    * all extendedlogs opened inside <Anonymous> blocks.
  733.    */
  734.   if(!session.anon_config) {
  735.     for(lf = logs; lf; lf=lf->next)
  736.       if(lf->lf_fd != -1 && lf->lf_conf && lf->lf_conf->config_type == CONF_ANON) {
  737.         close(lf->lf_fd);
  738.         lf->lf_fd = -1;
  739.       }
  740.   } else {
  741.     /* close all logs which were opened inside a _different_ anonymous
  742.      * context.
  743.      */
  744.     for(lf = logs; lf; lf=lf->next)
  745.       if(lf->lf_fd != -1 && lf->lf_conf && lf->lf_conf != session.anon_config) {
  746.         close(lf->lf_fd);
  747.         lf->lf_fd = -1;
  748.       }
  750.     /* if any extendedlogs set inside our context match an outer log,
  751.      * close the outer (this allows overriding inside <Anonymous>).
  752.      */
  753.     for(lf = logs; lf; lf=lf->next)
  754.       if(lf->lf_conf && lf->lf_conf == session.anon_config) {
  755.         /* this should "override" any lower-level extendedlog with the
  756.          * same filename.
  757.          */
  758.         logfile_t *lf2;
  760.         for(lf2 = logs; lf2; lf2=lf2->next) {
  761.           if(lf2->lf_fd != -1 && !lf2->lf_conf &&
  762.              !strcmp(lf2->lf_filename,lf->lf_filename)) {
  763.             close(lf2->lf_fd);
  764.             lf2->lf_fd = -1;
  765.           }
  766.         }
  767.        
  768.         /* go ahead and close the log if it's CL_NONE */
  770.         if(lf->lf_fd != -1 && lf->lf_classes == CL_NONE) {
  771.           close(lf->lf_fd);
  772.           lf->lf_fd = -1;
  773.         }
  774.       }
  775.   }
  776.   return DECLINED(cmd);
  777. }
  779. static
  780. int log_child_init()
  781. {
  782.   /* open all log files */
  783.   logfile_t *lf;
  784.   int xerrno;
  786.   get_extendedlogs();
  788.   for(lf = logs; lf; lf=lf->next)
  789.     if(lf->lf_fd == -1) {
  790.       block_signals();
  791.       PRIVS_ROOT
  793.       lf->lf_fd = 
  794.          open(lf->lf_filename,O_CREAT|O_APPEND|O_WRONLY,0644);
  795.       xerrno = errno;
  797.       PRIVS_RELINQUISH
  798.       unblock_signals();
  800.       if(lf->lf_fd == -1)
  801.         log_pri(LOG_NOTICE,"unable to open ExtendedLog '%s': %s",
  802.                 lf->lf_filename,strerror(errno));
  803.     }
  805.   return 0;
  806. }
  809. static conftable log_config[] = {
  810.   { "LogFormat", add_logformat, NULL },
  811.   { "ExtendedLog", add_extendedlog, NULL },
  812.   { "SystemLog", set_systemlog, NULL },
  813.   { NULL, NULL, NULL }
  814. };
  816. cmdtable log_commands[] = {
  817.   { LOG_CMD, "*", G_NONE, log_command, FALSE, FALSE },
  818.   { LOG_CMD_ERR,"*", G_NONE, log_command, FALSE, FALSE },
  819.   { POST_CMD, "PASS", G_NONE, log_auth_complete,FALSE,FALSE },
  820.   { 0, NULL }
  821. };
  823. module log_module = {
  824.   NULL,NULL, /* Always NULL */
  825.   0x20, /* API version */
  826.   "log", /* Module name */
  827.   log_config,
  828.   log_commands,
  829.   NULL,
  830.   log_init,log_child_init
  831. };