[BACK]Return to log.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / cvs

Diff for /src/usr.bin/cvs/log.c between version 1.34 and 1.35

version 1.34, 2006/04/20 12:13:19 version 1.35, 2006/05/27 03:30:30
Line 1 
Line 1 
 /*      $OpenBSD$       */  /*      $OpenBSD$       */
 /*  /*
    * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
  * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>   * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
  * All rights reserved.   * All rights reserved.
  *   *
Line 31 
Line 32 
   
 extern char *__progname;  extern char *__progname;
   
   
 #ifdef unused  
 static char *cvs_log_levels[LP_MAX + 1] = {  
         "debug",  
         "info",  
         "notice",  
         "warning",  
         "error",  
         "alert",  
         "error",  
         "abort",  
         "trace",  
 };  
 #endif  
   
 static int cvs_slpriomap[LP_MAX + 1] = {  
         LOG_DEBUG,  
         LOG_INFO,  
         LOG_NOTICE,  
         LOG_WARNING,  
         LOG_ERR,  
         LOG_ALERT,  
         LOG_ERR,  
         LOG_ERR,  
         LOG_DEBUG,  
 };  
   
 #if !defined(RCSPROG)  
 static int send_m = 1;  static int send_m = 1;
 #endif  
 static u_int cvs_log_dest = LD_STD;  
 static u_int cvs_log_flags = 0;  
   
 static struct syslog_data cvs_sl = SYSLOG_DATA_INIT;  
   
 /* filter manipulation macros */  
 #define CVS_LOG_FLTRRST()       (cvs_log_filters = 0)  
 #define CVS_LOG_FLTRSET(l)      (cvs_log_filters |= (1 << l))  
 #define CVS_LOG_FLTRGET(l)      (cvs_log_filters & (1 << l))  
 #define CVS_LOG_FLTRCLR(l)      (cvs_log_filters &= ~(1 << l))  
   
 static u_int cvs_log_filters;  
   
   
 /*  /*
  * cvs_log_init()  
  *  
  * Initialize the logging facility of the server.  
  */  
 void  
 cvs_log_init(u_int dest, u_int flags)  
 {  
         int slopt;  
   
         cvs_log_dest = dest;  
         cvs_log_flags = flags;  
   
         /* by default, filter only LP_DEBUG and LP_INFO levels */  
         CVS_LOG_FLTRRST();  
         CVS_LOG_FLTRSET(LP_DEBUG);  
         CVS_LOG_FLTRSET(LP_INFO);  
   
         /* traces are enabled with the -t command-line option */  
         CVS_LOG_FLTRSET(LP_TRACE);  
   
         if (dest & LD_SYSLOG) {  
                 slopt = 0;  
   
                 if (dest & LD_CONS)  
                         slopt |= LOG_CONS;  
                 if (flags & LF_PID)  
                         slopt |= LOG_PID;  
   
                 openlog_r(__progname, slopt, LOG_DAEMON, &cvs_sl);  
         }  
 }  
   
   
 /*  
  * cvs_log_cleanup()  
  *  
  * Cleanup the logging facility.  
  */  
 void  
 cvs_log_cleanup(void)  
 {  
   
         closelog_r(&cvs_sl);  
 }  
   
   
 /*  
  * cvs_log_filter()  
  *  
  * Apply or remove filters on the logging facility.  The exact operation is  
  * specified by the <how> and <level> arguments.  The <how> arguments tells  
  * how the filters will be affected, and <level> gives the log levels that  
  * will be affected by the change.  
  * Returns 0 on success, or -1 on failure.  
  */  
   
 int  
 cvs_log_filter(u_int how, u_int level)  
 {  
         u_int i;  
   
         if (level > LP_MAX && level != LP_ALL) {  
                 cvs_log(LP_ERR, "invalid log level for filter");  
                 return (-1);  
         }  
   
         switch (how) {  
         case LP_FILTER_SET:  
                 if (level == LP_ALL)  
                         for (i = 0; i <= LP_MAX; i++)  
                                 CVS_LOG_FLTRSET(i);  
                 else  
                         CVS_LOG_FLTRSET(level);  
                 break;  
         case LP_FILTER_UNSET:  
                 if (level == LP_ALL)  
                         CVS_LOG_FLTRRST();  
                 else  
                         CVS_LOG_FLTRCLR(level);  
                 break;  
         default:  
                 return (-1);  
         }  
   
         return (0);  
 }  
   
   
 /*  
  * cvs_log()   * cvs_log()
  *   *
  * Log the format-string message   * Log the format-string message
Line 181 
Line 51 
         va_end(vap);          va_end(vap);
 }  }
   
   
 /*  /*
  * cvs_vlog()   * cvs_vlog()
  *   *
Line 194 
Line 63 
         int ecp;          int ecp;
         char prefix[64], buf[1024], ebuf[255];          char prefix[64], buf[1024], ebuf[255];
         FILE *out;          FILE *out;
 #if !defined(RCSPROG)  
         char *cmdname;          char *cmdname;
         struct cvs_cmd *cmdp;          struct cvs_cmd *cmdp;
 #endif  
   
         if (level > LP_MAX)          if (cvs_trace != 1 && level == LP_TRACE)
                 fatal("cvs_vlog failed");  
   
         /* apply any filters */  
         if (CVS_LOG_FLTRGET(level))  
                 return;                  return;
   
         if (level == LP_ERRNO)          if (level == LP_ERRNO)
Line 212 
Line 75 
                 ecp = 0;                  ecp = 0;
   
         /* always use the command name in error messages, not aliases */          /* always use the command name in error messages, not aliases */
 #if !defined(RCSPROG)  
         if (cvs_command == NULL)          if (cvs_command == NULL)
                 cmdname = " ";                  cmdname = " ";
         else {          else {
Line 233 
Line 95 
                         snprintf(prefix, sizeof(prefix), "%s %s", __progname,                          snprintf(prefix, sizeof(prefix), "%s %s", __progname,
                             cmdname);                              cmdname);
         } else /* just use the standard strlcpy */          } else /* just use the standard strlcpy */
 #endif  
                 strlcpy(prefix, __progname, sizeof(prefix));                  strlcpy(prefix, __progname, sizeof(prefix));
   
         if ((cvs_log_flags & LF_PID) && level != LP_TRACE) {  
                 snprintf(buf, sizeof(buf), "[%d]", (int)getpid());  
                 strlcat(prefix, buf, sizeof(prefix));  
         }  
   
         vsnprintf(buf, sizeof(buf), fmt, vap);          vsnprintf(buf, sizeof(buf), fmt, vap);
         if (level == LP_ERRNO) {          if (level == LP_ERRNO) {
                 snprintf(ebuf, sizeof(ebuf), ": %s", strerror(errno));                  snprintf(ebuf, sizeof(ebuf), ": %s", strerror(errno));
                 strlcat(buf, ebuf, sizeof(buf));                  strlcat(buf, ebuf, sizeof(buf));
         }          }
   
         if (cvs_log_dest & LD_STD) {          if (level == LP_NOTICE)
                 if (level < LP_NOTICE)                  out = stdout;
                         out = stdout;          else
                 else                  out = stderr;
                         out = stderr;  
   
 #if !defined(RCSPROG)          if (cvs_cmdop == CVS_OP_SERVER) {
                 if (cvs_cmdop == CVS_OP_SERVER) {                  if (out == stdout)
                         if (out == stdout)                          putc('M', out);
                                 putc('M', out);                  else {
                         else {                          out = stdout;
                                 out = stdout;                          putc('E', out);
                                 putc('E', out);  
                         }  
                         putc(' ', out);  
                 }                  }
 #endif  
   
                 fputs(prefix, out);                  putc(' ', out);
                 if (level != LP_TRACE)  
                         fputs(": ", out);  
                 fputs(buf, out);  
                 fputc('\n', out);  
         }          }
   
         if (cvs_log_dest & LD_SYSLOG)          fputs(prefix, out);
                 syslog_r(cvs_slpriomap[level], &cvs_sl, "%s", buf);          if (level != LP_TRACE)
                   fputs(": ", out);
           fputs(buf, out);
           fputc('\n', out);
   
         /* preserve it just in case we changed it? */          /* preserve it just in case we changed it? */
         if (level == LP_ERRNO)          if (level == LP_ERRNO)
                 errno = ecp;                  errno = ecp;
 }  }
   
   
 /*  /*
  * cvs_printf()   * cvs_printf()
  *   *
Line 291 
Line 140 
 cvs_printf(const char *fmt, ...)  cvs_printf(const char *fmt, ...)
 {  {
         int ret;          int ret;
 #if !defined(RCSPROG)  
         char *nstr, *dp, *sp;          char *nstr, *dp, *sp;
 #endif  
         va_list vap;          va_list vap;
   
         va_start(vap, fmt);          va_start(vap, fmt);
   
 #if !defined(RCSPROG)  
         if (cvs_cmdop == CVS_OP_SERVER) {          if (cvs_cmdop == CVS_OP_SERVER) {
                 ret = vasprintf(&nstr, fmt, vap);                  ret = vasprintf(&nstr, fmt, vap);
                 if (ret == -1)                  if (ret == -1)
Line 326 
Line 172 
                 }                  }
                 xfree(nstr);                  xfree(nstr);
         } else          } else
 #endif  
                 ret = vprintf(fmt, vap);                  ret = vprintf(fmt, vap);
   
         va_end(vap);          va_end(vap);
Legend:
Removed from v.1.34  
changed lines
  Added in v.1.35