Annotation of embedaddon/ntp/ports/winnt/libntp/syslog.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Copyright (C) 2001  Internet Software Consortium.
                      3:  *
                      4:  * Permission to use, copy, modify, and distribute this software for any
                      5:  * purpose with or without fee is hereby granted, provided that the above
                      6:  * copyright notice and this permission notice appear in all copies.
                      7:  *
                      8:  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
                      9:  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
                     10:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
                     11:  * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
                     12:  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
                     13:  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
                     14:  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
                     15:  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     16:  */
                     17: 
                     18: /* From BIND 9 lib/isc/win32/: syslog.c,v 1.6 2002/08/03 01:34:14 mayer */
                     19: 
                     20: #include <config.h>
                     21: 
                     22: #include <stdio.h>
                     23: #include <windows.h>
                     24: #include <string.h>
                     25: #include <stdlib.h>
                     26: #include <syslog.h>
                     27: 
                     28: #include <isc/strerror.h>
                     29: 
                     30: #include "messages.h"
                     31: 
                     32: static HANDLE hAppLog = NULL;
                     33: static FILE *log_stream;
                     34: static int debug_level = 0;
                     35: static char progname[51] = "NTP";
                     36: static int logmask = 0;
                     37: 
                     38: static struct dsn_c_pvt_sfnt {
                     39:        int val;
                     40:        const char *strval;
                     41: } facilities[] = {
                     42:        { LOG_KERN,             "kern" },
                     43:        { LOG_USER,             "user" },
                     44:        { LOG_MAIL,             "mail" },
                     45:        { LOG_DAEMON,           "daemon" },
                     46:        { LOG_AUTH,             "auth" },
                     47:        { LOG_SYSLOG,           "syslog" },
                     48:        { LOG_LPR,              "lpr" },
                     49: #ifdef LOG_NEWS
                     50:        { LOG_NEWS,             "news" },
                     51: #endif
                     52: #ifdef LOG_UUCP
                     53:        { LOG_UUCP,             "uucp" },
                     54: #endif
                     55: #ifdef LOG_CRON
                     56:        { LOG_CRON,             "cron" },
                     57: #endif
                     58: #ifdef LOG_AUTHPRIV
                     59:        { LOG_AUTHPRIV,         "authpriv" },
                     60: #endif
                     61: #ifdef LOG_FTP
                     62:        { LOG_FTP,              "ftp" },
                     63: #endif
                     64:        { LOG_LOCAL0,           "local0"},
                     65:        { LOG_LOCAL1,           "local1"},
                     66:        { LOG_LOCAL2,           "local2"},
                     67:        { LOG_LOCAL3,           "local3"},
                     68:        { LOG_LOCAL4,           "local4"},
                     69:        { LOG_LOCAL5,           "local5"},
                     70:        { LOG_LOCAL6,           "local6"},
                     71:        { LOG_LOCAL7,           "local7"},
                     72:        { 0,                    NULL }
                     73: };
                     74: 
                     75: #if 0
                     76: BOOL
                     77: isc_syslog_facilityfromstring(const char *str, int *facilityp) {
                     78:        int i;
                     79: 
                     80:        REQUIRE(str != NULL);
                     81:        REQUIRE(facilityp != NULL);
                     82: 
                     83:        for (i = 0 ; facilities[i].strval != NULL ; i++) {
                     84:                if (strcasecmp(facilities[i].strval, str) == 0) {
                     85:                        *facilityp = facilities[i].val;
                     86:                        return (TRUE);
                     87:                }
                     88:        }
                     89:        return (FALSE);
                     90: }
                     91: #endif
                     92: /*
                     93:  * Log to the NT Event Log
                     94:  */
                     95: void
                     96: syslog(int level, const char *fmt, ...) {
                     97:        va_list ap;
                     98:        char buf[1024];
                     99:        char *str[1];
                    100: 
                    101:        str[0] = buf;
                    102: 
                    103:        va_start(ap, fmt);
                    104:        vsprintf(buf, fmt, ap);
                    105:        va_end(ap);
                    106: 
                    107:        /* Make sure that the channel is open to write the event */
                    108:        if (hAppLog == NULL) {
                    109:                openlog(progname, LOG_PID);
                    110:        }
                    111:        switch (level) {
                    112:                case LOG_INFO:
                    113:                case LOG_NOTICE:
                    114:                case LOG_DEBUG:
                    115:                        ReportEvent(hAppLog, EVENTLOG_INFORMATION_TYPE, 0,
                    116:                                    NTP_INFO, NULL, 1, 0, str, NULL);
                    117:                        break;
                    118:                case LOG_WARNING:
                    119:                        ReportEvent(hAppLog, EVENTLOG_WARNING_TYPE, 0,
                    120:                                    NTP_WARNING, NULL, 1, 0, str, NULL);
                    121:                        break;
                    122:                default:
                    123:                        ReportEvent(hAppLog, EVENTLOG_ERROR_TYPE, 0,
                    124:                                    NTP_ERROR, NULL, 1, 0, str, NULL);
                    125:                        break;
                    126:                }
                    127: }
                    128: 
                    129: /*
                    130:  * Initialize event logging
                    131:  */
                    132: void
                    133: openlog(const char *name, int flags, ...) {
                    134:        /* Get a handle to the Application event log */
                    135:        hAppLog = RegisterEventSource(NULL, progname);
                    136:        strncpy(progname, name, sizeof(progname));
                    137:        progname[sizeof(progname) - 1] = 0;
                    138: }
                    139: 
                    140: /*
                    141:  * Close the Handle to the application Event Log
                    142:  * We don't care whether or not we succeeded so ignore return values
                    143:  * In fact if we failed then we would have nowhere to put the message
                    144:  */
                    145: void
                    146: closelog() {
                    147:        DeregisterEventSource(hAppLog);
                    148: }
                    149: 
                    150: /*
                    151:  * Keep event logging synced with the current debug level
                    152:  */
                    153: void
                    154: ModifyLogLevel(int level) {
                    155:        debug_level = level;    
                    156: }
                    157: /*
                    158:  * Set the log priority mask to the given value.
                    159:  * Return the previous priority mask
                    160:  * Note that this setting is ignored in Win32
                    161:  */
                    162: int
                    163: setlogmask(int maskpri) {
                    164:        int temp = logmask;
                    165:        logmask = maskpri;
                    166:        return (temp);
                    167: }
                    168: 
                    169: /*
                    170:  * Initialize logging for the port section of libbind.
                    171:  * Piggyback onto stream given.
                    172:  */
                    173: void
                    174: InitNTLogging(FILE *stream, int debug) {
                    175:        log_stream = stream;
                    176:        ModifyLogLevel(debug);
                    177: }
                    178: /*
                    179:  * This function is for reporting errors to the application
                    180:  * event log in case the regular syslog is not available
                    181:  * mainly during startup. It should not be used under normal
                    182:  * circumstances.
                    183:  */
                    184: void
                    185: NTReportError(const char *name, const char *str) {
                    186:        HANDLE hNTAppLog = NULL;
                    187:        const char *buf[1];
                    188: 
                    189:        buf[0] = str;
                    190: 
                    191:        hNTAppLog = RegisterEventSource(NULL, name);
                    192: 
                    193:        ReportEvent(hNTAppLog, EVENTLOG_ERROR_TYPE, 0,
                    194:                    NTP_ERROR, NULL, 1, 0, buf, NULL);
                    195: 
                    196:        DeregisterEventSource(hNTAppLog);
                    197: }
                    198: 
                    199: 
                    200: /*
                    201:  * ntp_strerror() - provide strerror()-compatible wrapper for libisc's
                    202:  *                 isc__strerror(), which knows about Windows as well as
                    203:  *                 C runtime error messages.
                    204:  */
                    205: 
                    206: char *
                    207: ntp_strerror(
                    208:        int code
                    209:        )
                    210: {
                    211:        static char msgbuf[128];
                    212: 
                    213:        isc__strerror(code, msgbuf, sizeof(msgbuf));
                    214: 
                    215:        return msgbuf;
                    216: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>