Back to index

courier  0.68.2
lcclog.c
Go to the documentation of this file.
00001 /*
00002 ** Copyright 1998 - 2001 Double Precision, Inc.
00003 ** See COPYING for distribution information.
00004 */
00005 
00006 #if    HAVE_CONFIG_H
00007 #include      "courier_lib_config.h"
00008 #endif
00009 
00010 #include      "courier.h"
00011 #include      <sys/types.h>
00012 #include      <string.h>
00013 #include      <stdlib.h>
00014 #include      <stdio.h>
00015 #include      <errno.h>
00016 #include      <grp.h>
00017 #if    HAVE_UNISTD_H
00018 #include      "unistd.h"
00019 #endif
00020 #include      "maxlongsize.h"
00021 #include      <sys/types.h>
00022 #include      <sys/uio.h>
00023 #if    HAVE_SYSLOG_H
00024 #include      <syslog.h>
00025 #endif
00026 
00027 
00028 static int log_opened=0;
00029 static char logbuf[1024];
00030 static const char *logmodule;
00031 
00032 static void clog_msg_send_stderr();
00033 #if    HAVE_SYSLOG_H
00034 static void clog_msg_send_syslog();
00035 #endif
00036 
00037 static void (*clog_msg_send_func)();
00038 
00039 void clog_open_syslog(const char *module)
00040 {
00041 #if    HAVE_SYSLOG_H
00042 
00043        logmodule=module;
00044        clog_msg_send_func=clog_msg_send_syslog;
00045        openlog(module, 0
00046 #ifdef  LOG_NDELAY
00047                      | LOG_NDELAY
00048 #else
00049                      | LOG_NOWAIT
00050 #endif
00051                      , LOG_MAIL);
00052 
00053 #else
00054        clog_open_stderr(module);
00055 #endif
00056        log_opened=1;
00057 }
00058 
00059 void clog_open_stderr(const char *module)
00060 {
00061 #ifdef HAVE_SETVBUF_IOLBF
00062        setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
00063 #endif
00064 
00065        log_opened=1;
00066        logmodule=module;
00067        clog_msg_send_func=clog_msg_send_stderr;
00068 }
00069 
00070 void clog_msg_start_info()
00071 {
00072        if (!log_opened)     return;
00073        strcpy(logbuf, "INFO: ");
00074 }
00075 
00076 void clog_msg_start_err()
00077 {
00078        if (!log_opened)
00079               clog_open_stderr("init");
00080        strcpy(logbuf, "ERR: ");
00081 }
00082 
00083 void clog_msg_send()
00084 {
00085        if (!log_opened)     return;
00086 
00087        (*clog_msg_send_func)();
00088 }
00089 
00090 static void clog_msg_send_stderr()
00091 {
00092 struct iovec  iov[4];
00093 int    niov=0;
00094 
00095        if (logmodule)
00096        {
00097               iov[niov].iov_base=(caddr_t)logmodule;
00098               iov[niov++].iov_len=strlen(logmodule);
00099               iov[niov].iov_base=(caddr_t)": ";
00100               iov[niov++].iov_len=2;
00101        }
00102 
00103        iov[niov].iov_base=(caddr_t)logbuf;
00104        iov[niov++].iov_len=strlen(logbuf);
00105        iov[niov].iov_base=(caddr_t)"\n";
00106        iov[niov++].iov_len=1;
00107        writev(2, iov, niov);
00108 }
00109 
00110 #if    HAVE_SYSLOG_H
00111 static void clog_msg_send_syslog()
00112 {
00113 const char *p=logbuf;
00114 int    loglevel=LOG_INFO;
00115 
00116        if (*p == 'E')       loglevel=LOG_ERR;
00117        while (*p && *p != ':')
00118               p++;
00119        if (*p)       p++;
00120        while (*p == ' ')    ++p;
00121 
00122        syslog(loglevel, "%s", p);
00123 }
00124 #endif
00125 
00126 void clog_msg_str(const char *p)
00127 {
00128 int    n, l;
00129 int    c;
00130 int    trunc=0;
00131 
00132        if (!p || !log_opened)      return;
00133        n=strlen(p);
00134        l=strlen(logbuf);
00135        if (n > 128)
00136        {
00137               n=128;
00138               trunc=1;
00139        }
00140 
00141        if (n+l >= sizeof(logbuf)-1)
00142               n=sizeof(logbuf)-1-l;
00143 
00144        while (n)
00145        {
00146               c= *p++;
00147               if ( c == '\r')      continue;
00148               if ( c == '\n' && *p == 0)  break;
00149 
00150               if ( c == '\n')      c='/';
00151               else if (c < ' ' || c >= 0x7E)     c='.';
00152               logbuf[l++]=c;
00153               --n;
00154        }
00155        logbuf[l]=0;
00156        if (trunc)    clog_msg_str("...");
00157 }
00158 
00159 void clog_msg_ulong(unsigned long n)
00160 {
00161 char   buf[MAXLONGSIZE+2];
00162 
00163        if (!log_opened)     return;
00164        sprintf(buf, "%lu", n);
00165        clog_msg_str(buf);
00166 }
00167 
00168 void clog_msg_uint(unsigned n)
00169 {
00170        clog_msg_ulong(n);
00171 }
00172 
00173 
00174 void clog_msg_int(int n)
00175 {
00176        if (n < 0)
00177        {
00178               n= -n;
00179               clog_msg_str("-");
00180        }
00181        clog_msg_uint(n);
00182 }
00183 
00184 void clog_msg_prerrno()
00185 {
00186        clog_msg_start_err();
00187 #if    HAVE_STRERROR
00188        clog_msg_str(strerror(errno));
00189 #else
00190        {
00191        char   buf[MAXLONGSIZE+40];
00192 
00193               sprintf(buf, "System error, errno=%d", (int)errno);
00194               clog_msg_str(buf);
00195        }
00196 #endif
00197        clog_msg_send();
00198 }
00199 
00200 void clog_msg_errno()
00201 {
00202        clog_msg_prerrno();
00203        exit(1);
00204 }