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

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

Ftp客户端

开发平台：

Unix_Linux

log.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. /*
  21.  * ProFTPD logging support
  22.  * $Id: log.c,v 1.12 1999/10/01 07:57:32 macgyver Exp $
  23.  */
  25. /* History Log:
  26.  *
  27.  * 4/24/97 0.99.0pl1
  28.  *   Added log_debug() and log_setdebuglevel() in order to facilitate
  29.  *   altering the amount of debugging info printed or syslogged.
  30.  *   Also added a command line argument (-d,--debug) to alter the
  31.  *   debug level at runtime.  See main.c.
  32.  */
  34. /* AIX requires this to be the first thing in the file. */
  35. #if defined(_AIX) && !defined(__GNUC__)
  36. #pragma alloca
  37. #endif
  39. #include "conf.h"
  41. #include <signal.h>
  43. static int syslog_open = FALSE;
  44. static int syslog_discard = FALSE;
  45. static int logstderr = TRUE;
  46. static int debug_level = DEBUG0; /* Default is no debug logging */
  47. static int facility = LOG_DAEMON;
  48. static int set_facility = -1;
  49. static char *syslog_fn = NULL;
  50. static char *syslog_hostname;
  51. static int syslog_fd = -1;
  52. static int runfd = -1;
  53. static char scoreboard_path[MAX_PATH_LEN] = RUN_DIR;
  54. static char *runfn = NULL;
  55. static char *runcwd = NULL;
  56. static char *address = NULL;
  57. static size_t runsize = 0;
  58. static int xferfd = -1;
  60. char *fmt_time(time_t t)
  61. {
  62.   static char buf[30];
  63.   static char *mons[] =
  64.   { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
  65.   static char *days[] =
  66.   { "Sun","Mon","Tue","Wed","Thu","Fri","Sat" };
  67.   struct tm *tr;
  69.   if((tr = localtime(&t)) != NULL) {
  70.     snprintf(buf,sizeof(buf),"%s %s %2d %02d:%02d:%02d %d",
  71.             days[tr->tm_wday],
  72.             mons[tr->tm_mon],
  73.             tr->tm_mday,
  74.             tr->tm_hour,
  75.             tr->tm_min,
  76.             tr->tm_sec,
  77.             tr->tm_year + 1900);
  78.   } else
  79.     buf[0] = '';
  80.   
  81.   return buf;
  82. }
  84. void log_close_xfer()
  85. {
  86.   if(xferfd != -1)
  87.     close(xferfd);
  88.   xferfd = -1;
  89. }
  91. int log_open_xfer(const char *fn)
  92. {
  93.   if(!fn) {
  94.     if(xferfd != -1)
  95.       log_close_xfer();
  96.     return 0;
  97.   }
  99.   if(xferfd == -1)
  100.     xferfd = open(fn,O_WRONLY|O_APPEND|O_CREAT,0644);
  102.   return xferfd;
  103. }
  105. int log_xfer(int xfertime,char *remhost,unsigned long fsize,
  106.              char *fname,char xfertype,char direction,
  107.              char access,char *user)
  108. {
  109.   char buf[1024], fbuf[1024];
  110.   int i;
  112.   if(xferfd == -1)
  113.     return 0;
  115.   for(i = 0; (i + 1 < sizeof(fbuf)) && fname[i] != ''; i++) {
  116.     fbuf[i] = (isspace(fname[i]) || iscntrl(fname[i])) ? '_' : fname[i];
  117.   }
  118.   
  119.   fbuf[i] = '';
  120.   
  121.   snprintf(buf,sizeof(buf),"%s %d %s %lu %s %c _ %c %c %s ftp 0 *n",
  122.    fmt_time(time(NULL)),xfertime,remhost,fsize,
  123.    fbuf,xfertype,direction,access,user);
  125.   return(write(xferfd,buf,strlen(buf)));
  126. }
  128. void log_rm_run()
  129. {
  130.   if(runfd > -1)
  131.     close(runfd);
  132.   if(runfn)
  133.     unlink(runfn);
  135.   runfd = -1;
  136. }
  138. int log_close_run()
  139. {
  140.   if(runfd == -1)
  141.     return 0;
  143.   close(runfd);
  144.   runfd = -1;
  145.   return 0;
  146. }
  148. const char *log_run_getpath(void)
  149. {
  150.   return scoreboard_path;
  151. }
  153. void log_run_setpath(const char *path)
  154. {
  155.   sstrncpy(scoreboard_path,path,sizeof(scoreboard_path));
  156.   if(scoreboard_path[strlen(scoreboard_path)-1] == '/')
  157.     scoreboard_path[strlen(scoreboard_path)-1] = '';
  158. }
  160. int log_run_checkpath(void)
  161. {
  162.   struct stat sbuf;
  164.   if(stat(scoreboard_path,&sbuf) < 0)
  165.     return -1;
  167.   if(!S_ISDIR(sbuf.st_mode)) {
  168.     errno = ENOTDIR;
  169.     return -1;
  170.   }
  172.   return 0;
  173. }
  175. int log_open_run(pid_t mpid, int trunc, int allow_update)
  176. {
  177.   char fname[MAXPATHLEN];
  178.   logrun_header_t hdr;
  179.   int i;
  181.   if(runfd > -1)
  182.     return 0;
  184.   if(!mpid)
  185.     snprintf(fname, sizeof(fname), "%s/proftpd-inetd",scoreboard_path);
  186.   else
  187.     snprintf(fname, sizeof(fname), "%s/proftpd-%d",scoreboard_path,(int)mpid);
  189.   runfn = pstrdup(permanent_pool,fname);
  190.   if((runfd = open(runfn,O_RDWR|O_CREAT|(trunc ? O_TRUNC : 0),
  191.                    0644)) == -1)
  192.     return -1;
  194.   /* Attempt to read header */
  195.   i = read(runfd, &hdr, sizeof(hdr));
  197.   if(i <= 0) {
  198.     char buf[sizeof(logrun_t)];
  199.     runsize = sizeof(logrun_t);
  200.     
  201.     hdr.r_magic = LOGRUN_MAGIC;
  202.     hdr.r_version = INTERNAL_VERSION;
  203.     hdr.r_size = sizeof(logrun_t);
  204.     bzero(buf,sizeof(logrun_t));
  205.     bcopy(&hdr,buf,sizeof(hdr));
  206.     write(runfd,buf,runsize);
  207.     fsync(runfd);
  209.     return runfd;
  210.   }
  212.   if(i < sizeof(hdr)) {
  213.     /* File is corrupt, etc, silently rm it */
  214.     if(allow_update) {
  215.       log_rm_run();
  216.       return log_open_run(mpid,trunc,allow_update);
  217.     }
  218.     return -1;
  219.   }
  221.   if(hdr.r_magic != LOGRUN_MAGIC) {
  222.     /* Old version or corrupt */
  223.     log_pri(LOG_NOTICE,"run-time scoreboard file '%s' is corrupted or old version.",fname);
  224.     if(allow_update) {
  225.       log_rm_run();
  226.       return log_open_run(mpid,trunc,allow_update);
  227.     }
  228.     return -1;
  229.   }
  231.   if(hdr.r_version < INTERNAL_VERSION) {
  232.     log_pri(LOG_NOTICE,"run-time scoreboard file '%s' is old version.",fname);
  233.     if(allow_update) {
  234.       log_rm_run();
  235.       return log_open_run(mpid,trunc,allow_update);
  236.     }
  237.     return -1;
  238.   }
  240.   if(hdr.r_version > INTERNAL_VERSION) {
  241.     log_pri(LOG_NOTICE,"run-time scoreboard file '%s' appears to be from a newer version of proftpd (%s).",
  242.             fname,VERSION);
  243.     log_close_run();
  244.     return -1;
  245.   }
  247.   runsize = (size_t)hdr.r_size;
  248.   return runfd;
  249. }
  251. static int _pid_exists(pid_t pid)
  252. {
  253. #ifdef LINUX
  254.   char procfn[20];
  255.   struct stat sbuf;
  256. #endif
  257.   int res;
  259.   res = kill(pid,SIGCONT);
  260. #ifdef LINUX
  261.   snprintf(procfn, sizeof(procfn), "/proc/%d",pid);    
  262.   if( (res == -1 && errno == EPERM) || !res ||
  263.     stat(procfn,&sbuf) != -1)
  264. #else
  265.   if( (res == -1 && errno == EPERM) || !res )
  266. #endif
  267.     return 1;
  268.   return 0;
  269. }
  271. static size_t _read_hdr(int fd)
  272. {
  273.   logrun_header_t hdr;
  275.   if(read(fd,&hdr,sizeof(hdr)) != sizeof(hdr))
  276.     return 0;
  278.   if(hdr.r_magic != LOGRUN_MAGIC)
  279.     /* Old version or corrupt */
  280.     return 0;
  282.   if(hdr.r_version != INTERNAL_VERSION)
  283.     return 0;
  285.   lseek(fd, hdr.r_size, SEEK_SET);
  286.   return (size_t)hdr.r_size;
  287. }
  289. static int _read_run(int fd, size_t size, logrun_t *ent)
  290. {
  291.   unsigned char *buf;
  292.   logrun_t *tmp;
  294.   buf = (unsigned char*)alloca(size);
  296.   while(read(fd,buf,size) == size) {
  297.     tmp = (logrun_t*)buf;
  299.     if(tmp->pid) {
  300.       /* Try to determine if the process still exists */
  302.       bcopy(tmp,ent,sizeof(logrun_t));
  303.       return _pid_exists(ent->pid);
  304.     }
  305.   }
  307.   return -1;
  308. }
  310. logrun_t *log_read_run(pid_t *mpid)
  311. {
  312.   static DIR *dir = NULL;
  313.   static struct dirent *dent = NULL;
  314.   static int fd = -1;
  315.   static logrun_t ent;
  316.   static size_t size = 0;
  317.   char *cp, buf[MAXPATHLEN];
  319.   errno = 0;
  320.   if(!dir) {
  321.     dir = opendir(scoreboard_path);
  322.     if(!dir)
  323.       return NULL;
  324.   }
  326.   while(fd != -1) {
  327.     switch(_read_run(fd,size,&ent)) {
  328.     case 1:
  329.       errno = 0;
  330.       return &ent;
  331.     case -1:
  332.       close(fd); fd = -1; break;
  333.     }
  334.   }
  336.   while((dent = readdir(dir)) != NULL)
  337.     if(strncmp(dent->d_name,"proftpd",7) == 0) {
  338.       cp = rindex(dent->d_name,'-');
  339.       if(cp) {
  340.         cp++;
  341.         if(mpid)
  342.           *mpid = (pid_t)atoi(cp);
  343.         snprintf(buf, sizeof(buf), "%s/%s",scoreboard_path,dent->d_name);
  344.         fd = open(buf,O_RDONLY,0644);
  346.         if(fd != -1) {
  347.           size = _read_hdr(fd);
  348.           if(!size) {
  349.             close(fd);
  350.             fd = -1;
  351.           }
  353.           while(fd != -1) {
  354.             switch(_read_run(fd,size,&ent)) {
  355.             case 1: errno = 0; return &ent;
  356.             case -1: close(fd); fd = -1; errno = 0;
  357.             }
  358.           }
  359.         } else
  360.           return NULL;
  361.       }
  362.     }
  364.   closedir(dir);
  365.   dir = NULL;
  367.   return NULL;
  368. }
  370. void log_run_address(const char *remote_name, const p_in_addr_t *remote_ipaddr)
  371. {
  372.   char buf[1024];
  374.   snprintf(buf,sizeof(buf),"%s [%s]",remote_name,inet_ntoa(*remote_ipaddr));
  375.   buf[1023] = '';
  376.   address = pstrdup(permanent_pool,buf);
  377. }
  379. void log_run_cwd(const char *cwd)
  380. {
  381.   if(!runcwd)
  382.     runcwd = pcalloc(permanent_pool,MAX_PATH_LEN);
  383.   
  384.   sstrncpy(runcwd,cwd,MAX_PATH_LEN);
  385. }
  387. /* log_add_run() logs the current process and connection information to
  388.  * the scoreboard_path/proftpd-[master_daemon_pid] file.  If an existing record
  389.  * for the current pid is found, it is overwritten.  Passing user ==
  390.  * NULL clears the entry.
  391.  */
  393. int log_add_run(pid_t mpid, time_t *idle_since, char *user,char *class,
  394.                 p_in_addr_t *server_ip, unsigned short server_port, 
  395.                 unsigned long tx_size, unsigned long tx_done, char *op, ...)
  396. {
  397.   logrun_t ent,fent;
  398.   int res = 0,c,first = -1;
  399.   va_list msg;
  400.   char buf[1500] = "";
  402. #ifndef HAVE_FLOCK
  403.   struct flock arg;
  404. #endif
  406.   c = runsize;
  408.   if(op) {
  409.     va_start(msg,op);
  410.     vsnprintf(buf,sizeof(buf),op,msg);
  411.     va_end(msg);
  412.     buf[sizeof(buf)-1] = '';
  413.   }
  415.   if(runfd == -1)
  416.     log_open_run(mpid,FALSE,FALSE);
  418.   if(runfd == -1)
  419.     return -1;
  421.   bzero(&ent,sizeof(ent));
  422.   ent.pid = getpid();
  423.   ent.uid = geteuid();
  424.   ent.gid = getegid();
  426. #ifdef HAVE_FLOCK
  427.   flock(runfd,LOCK_EX);
  428. #else
  429.   arg.l_type = F_WRLCK; arg.l_whence = arg.l_start = arg.l_len = 0;
  430.   fcntl(runfd, F_SETLKW, &arg);
  431. #endif
  433.   if(lseek(runfd,runsize,SEEK_SET) != -1) {
  434.     while(read(runfd,(char*)&fent,sizeof(fent)) == sizeof(fent) &&
  435.           fent.pid != ent.pid) {
  436.       if((!fent.pid || !_pid_exists(fent.pid)) && first == -1)
  437.         first = c;
  438.       c += sizeof(fent);
  439.     }
  441.     if(fent.pid == ent.pid) {
  442.       bcopy(&fent,&ent,sizeof(ent));
  443.       first = -1;
  444.       lseek(runfd,c,SEEK_SET);
  445.     } else
  446.       lseek(runfd,runsize,SEEK_END);
  447.   }
  449.   if(idle_since)
  450.     ent.idle_since = *idle_since;
  451.   else
  452.     ent.idle_since = 0;
  454.   if(user) {
  455.     bzero(ent.user,sizeof(ent.user));
  456.     sstrncpy(ent.user,user,sizeof(ent.user));
  457.   }
  458.   if(class) {
  459.     bzero(ent.class,sizeof(ent.class));
  460.     sstrncpy(ent.class,class,sizeof(ent.class));
  461.   }
  462.   if(buf[0]) {
  463.     bzero(ent.op,sizeof(ent.op));
  464.     sstrncpy(ent.op,buf,sizeof(ent.op));
  465.   }
  467.   if(server_ip)
  468.     bcopy(server_ip,&ent.server_ip,sizeof(ent.server_ip));
  469.   if(server_port)
  470.     ent.server_port = server_port;
  472.   if(tx_size) {
  473.     ent.transfer_size = tx_size;
  474.     ent.transfer_complete = tx_done;
  475.   } else {
  476.     ent.transfer_size = 0;
  477.     ent.transfer_complete = 0;
  478.   }
  480.   if(runcwd) {
  481.     sstrncpy(ent.cwd,runcwd,sizeof(ent.cwd));
  482.     ent.cwd[sizeof(ent.cwd)-1] = '';
  483.   } else
  484.     bzero(ent.cwd,sizeof(ent.cwd));
  486.   if(address) {
  487.     sstrncpy(ent.address,address,sizeof(ent.address));
  488.     ent.address[sizeof(ent.address)-1] = '';
  489.   } else
  490.     bzero(ent.address,sizeof(ent.address));
  492.   if(!user) {
  493.     if(fent.pid == ent.pid) {
  494.       bzero(&ent,sizeof(ent));
  495.       res = write(runfd,(char*)&ent,sizeof(ent));
  496.     }
  497.   } else {
  498.     if(first != -1)
  499.       lseek(runfd,first,SEEK_SET);
  500.     res = write(runfd,(char*)&ent,sizeof(ent));
  501.   }
  503.   /* 11/16/97 - fsync() causes the kernel to flush related file buffers to
  504.    * disk, not necessary here.
  505.    */
  507.   /* fsync(runfd); */
  509. #ifdef HAVE_FLOCK
  510.   flock(runfd,LOCK_UN);
  511. #else
  512.   arg.l_type = F_UNLCK; arg.l_whence = arg.l_start = arg.l_len = 0;
  513.   fcntl(runfd, F_SETLKW, &arg);
  514. #endif
  516.   return res;
  517. }
  519. /* This next function logs an entry to wtmp, it MUST be called as
  520.  * root BEFORE a chroot occurs.
  521.  * Note: This has some portability ifdefs in it.  They *should* work,
  522.  * but I haven't been able to test them.
  523.  */
  525. int log_wtmp(char *line, char *name, char *host, p_in_addr_t *ip)
  526. {
  527.   struct stat buf;
  528.   struct utmp ut;
  529.   int res = 0;
  530.   static int fd = -1;
  532. #if defined(SVR4) || defined(__SVR4)
  533. #if !(defined(LINUX) || defined(__hpux) || defined (_AIX))
  534.   /* This "auxilliary" utmp doesn't exist under linux. */
  535.   struct utmpx utx;
  536.   static int fdx = -1;
  538.   if(fdx < 0 && (fdx = open(WTMPX_FILE, O_WRONLY | O_APPEND, 0)) < 0) {
  539.     log_pri(LOG_WARNING,"wtmpx %s: %s",WTMPX_FILE,strerror(errno));
  540.     return -1;
  541.   }
  543.   if(fstat(fdx,&buf) == 0) {
  544.     memset(&utx,0,sizeof(utx));
  545.     sstrncpy(utx.ut_user,name,sizeof(utx.ut_user));
  546.     sstrncpy(utx.ut_id,"ftp",sizeof(utx.ut_user));
  547.     sstrncpy(utx.ut_line,line,sizeof(utx.ut_line));
  548.     sstrncpy(utx.ut_host,host,sizeof(utx.ut_host));
  549.     utx.ut_syslen = strlen(utx.ut_host)+1;
  550.     utx.ut_pid = getpid();
  551.     time(&utx.ut_tv.tv_sec);
  552.     if(*name)
  553.       utx.ut_type = USER_PROCESS;
  554.     else
  555.       utx.ut_type = DEAD_PROCESS;
  556.     utx.ut_exit.e_termination = 0;
  557.     utx.ut_exit.e_exit = 0;
  558.     if(write(fdx,(char*)&utx,sizeof(utx)) != sizeof(utx))
  559.       ftruncate(fdx, buf.st_size);
  560.   } else {
  561.     log_debug(DEBUG0,"%s fstat(): %s",WTMPX_FILE,strerror(errno));
  562.     res = -1;
  563.   }
  565. #endif
  566. #endif /* SVR4 */
  568.   if(fd < 0 && (fd = open(WTMP_FILE,O_WRONLY|O_APPEND,0)) < 0) {
  569.     log_pri(LOG_WARNING,"wtmp %s: %s",WTMP_FILE,strerror(errno));
  570.     return -1;
  571.   }
  572.  
  573.   if(fstat(fd,&buf) == 0) {
  574.     memset(&ut,0,sizeof(ut));
  575. #ifdef HAVE_UTMAXTYPE
  576. #ifdef LINUX
  577.     if(ip)
  578.       memcpy(&ut.ut_addr,ip,sizeof(ut.ut_addr));
  579. #else
  580.     sstrncpy(ut.ut_id,"ftp",sizeof(ut.ut_id));
  581.     ut.ut_exit.e_termination = 0;
  582.     ut.ut_exit.e_exit = 0;
  583. #endif
  584.     sstrncpy(ut.ut_line,line,sizeof(ut.ut_line));
  585.     if(name && *name)
  586.       sstrncpy(ut.ut_user,name,sizeof(ut.ut_user));
  587.     ut.ut_pid = getpid();
  588.     if(name && *name)
  589.       ut.ut_type = USER_PROCESS;
  590.     else
  591.       ut.ut_type = DEAD_PROCESS;
  592. #else  /* !HAVE_UTMAXTYPE */
  593.     sstrncpy(ut.ut_line,line,sizeof(ut.ut_line));
  594.     if(name && *name)
  595.       sstrncpy(ut.ut_name,name,sizeof(ut.ut_name));
  596. #endif /* HAVE_UTMAXTYPE */
  598. #ifdef HAVE_UT_UT_HOST
  599.     if(host && *host)
  600.       sstrncpy(ut.ut_host,host,sizeof(ut.ut_host));
  601. #endif /* HAVE_UT_UT_HOST */
  603.     time(&ut.ut_time);
  604.     if(write(fd,(char*)&ut,sizeof(ut)) != sizeof(ut))
  605.       ftruncate(fd,buf.st_size);
  606.   } else {
  607.     log_debug(DEBUG0,"%s fstat(): %s",WTMP_FILE,strerror(errno));
  608.     res = -1;
  609.   }
  611.   return res;
  612. }
  614. int log_opensyslog(const char *fn)
  615. {
  616.   char *ptr;
  617.   struct stat statbuf;
  618.   
  619.   if(set_facility != -1)
  620.     facility = set_facility;
  622.   if(fn)
  623.     syslog_fn = pstrdup(permanent_pool,fn);
  625.   if(!syslog_fn) {
  626.     openlog("proftpd",LOG_NDELAY|LOG_PID,facility);
  627.     syslog_open = TRUE;
  628.     syslog_fd = -1;
  629.   } else {
  630.     if((ptr = rindex(syslog_fn, '/')) == NULL) {
  631.       log_debug(DEBUG0, "%s rindex failed", syslog_fn);
  632.       syslog_fn = NULL;
  633.       return -1;
  634.     }
  635.     
  636.     *ptr = '';
  638.     if(stat(syslog_fn, &statbuf) == -1) {
  639.       log_debug(DEBUG0, "%s stat: %s", syslog_fn, strerror(errno));
  640.       syslog_fn = NULL;
  641.       return -1;
  642.     }
  644.     if(!S_ISDIR(statbuf.st_mode)) {
  645.       log_debug(DEBUG0, "%s is not a directory", syslog_fn);
  646.       syslog_fn = NULL;
  647.       return -1;
  648.     }
  649.     
  650.     if(statbuf.st_mode & S_IWOTH) {
  651.       log_debug(DEBUG0, "%s is a world writeable directory", syslog_fn);
  652.       syslog_fn = NULL;
  653.       return -2;
  654.     }
  655.     
  656.     *ptr = '/';
  657.     syslog_fd = open(syslog_fn,O_CREAT|O_APPEND|O_WRONLY,0640);
  658.     if(syslog_fd == -1) {
  659.       syslog_fn = NULL;
  660.       return -1;
  661.     }
  663.     syslog_open = TRUE;
  664.   }
  666.   return 0;
  667. }
  669. void log_closesyslog()
  670. {
  671.   if(syslog_fd != -1)
  672.     close(syslog_fd);
  673.   else
  674.     closelog();
  676.   syslog_fd = -1;
  677.   syslog_open = FALSE;
  678. }
  680. void log_setfacility(int f)
  681. {
  682.   set_facility = f;
  683. }
  685. void log_discard()
  686. {
  687.   syslog_discard = TRUE;
  688. }
  690. void log(int priority, int f, char *s)
  691. {
  692.   if(logstderr) {
  693.     fprintf(stderr,"%sn",s);
  694.     return;
  695.   }
  697.   if(syslog_discard)
  698.     return;
  700.   if(syslog_fd != -1) {
  701.     char buf[1024];
  702.     time_t tt = time(NULL);
  703.     struct tm *t;
  705.     t = localtime(&tt);
  706.     strftime(buf,sizeof(buf),"%b %d %H:%M:%S ",t);
  707.     buf[sizeof(buf) - 1] = '';
  708.     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
  709.              "%s proftpd[%u]: %s",syslog_hostname,
  710.              (unsigned int)getpid(),s);
  712.     buf[sizeof(buf)-1] = '';
  713.     write(syslog_fd,buf,strlen(buf));
  714.     write(syslog_fd,"n",1);
  715.     return;
  716.   }
  718.   if(set_facility != -1)
  719.     f = set_facility;
  721.   if(f != facility || !syslog_open)
  722.     openlog("proftpd", LOG_NDELAY | LOG_PID, f);
  724.   syslog(priority, "%sn", s);
  726.   if(!syslog_open)
  727.     closelog();
  728.   else if(f != facility)
  729.     openlog("proftpd", LOG_NDELAY | LOG_PID, facility);
  730. }
  732. void log_pri(int priority,char *fmt,...)
  733. {
  734.   char buf[1024];
  735.   va_list msg;
  737.   va_start(msg,fmt);
  738.   vsnprintf(buf, sizeof(buf), fmt, msg);
  739.   va_end(msg);
  741.   buf[1023] = '';
  743.   log(priority,facility,buf);
  744. }
  746. /* Like log_pri(), but sends the log entry in the LOG_AUTHPRIV
  747.  * facility (presumable it doesn't need to be seen by everyone
  748.  */
  750. void log_auth(int priority, char *fmt, ...)
  751. {
  752.   char buf[1024];
  753.   va_list msg;
  755.   va_start(msg,fmt);
  756.   vsnprintf(buf, sizeof(buf), fmt, msg);
  757.   va_end(msg);
  759.   buf[1023] = '';
  761.   log(priority, LOG_AUTHPRIV, buf);
  762. }
  764. /* Disable logging to stderr, should be done right before forking
  765.  * or disassociation from controlling tty.  After disabling stderr
  766.  * logging, all messages go to syslog.
  767.  */
  769. void log_stderr(int bool)
  770. {
  771.   logstderr = bool;
  772. }
  774. /* Set the debug logging level, see log.h for constants.  Higher
  775.  * numbers mean print more, DEBUG0 (0) == print no debugging log
  776.  * (default)
  777.  */
  779. int log_setdebuglevel(int level)
  780. {
  781.   int old_level = debug_level;
  782.   debug_level = level;
  783.   return old_level;
  784. }
  786. void log_debug(int level,char *str,...)
  787. {
  788.   char buf[1024];
  789.   va_list msg;
  791.   if(debug_level < level)
  792.     return;
  794.   va_start(msg,str);
  795.   vsnprintf(buf, sizeof(buf), str, msg);
  796.   va_end(msg);
  798.   buf[1023] = '';
  800.   log(LOG_DEBUG, facility, buf);
  801. }
  803. void init_log()
  804. {
  805.   char buf[256];
  807.   if(gethostname(buf, sizeof(buf)) == -1)
  808.     sstrncpy(buf, "localhost", sizeof(buf));
  809.   
  810.   syslog_hostname = inet_validate(pstrdup(permanent_pool, buf));
  811. }