Annotation of src/usr.bin/cvs/log.c, Revision 1.22
1.22 ! xsa 1: /* $OpenBSD: log.c,v 1.21 2005/07/07 14:27:57 joris Exp $ */
1.1 jfb 2: /*
1.2 jfb 3: * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
1.1 jfb 4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: *
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. The name of the author may not be used to endorse or promote products
13: * derived from this software without specific prior written permission.
14: *
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
16: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
17: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
18: * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
24: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27: #include <sys/types.h>
28:
29: #include <errno.h>
30: #include <stdio.h>
1.16 xsa 31: #include <stdlib.h>
1.1 jfb 32: #include <string.h>
1.16 xsa 33: #include <syslog.h>
1.1 jfb 34: #include <unistd.h>
35:
1.16 xsa 36: #include "cvs.h"
1.1 jfb 37: #include "log.h"
38:
39: extern char *__progname;
40:
1.3 jfb 41:
1.2 jfb 42: #ifdef unused
1.13 jfb 43: static char *cvs_log_levels[LP_MAX + 1] = {
1.1 jfb 44: "debug",
45: "info",
46: "notice",
47: "warning",
48: "error",
49: "alert",
1.4 jfb 50: "error",
51: "abort",
1.13 jfb 52: "trace",
1.1 jfb 53: };
1.2 jfb 54: #endif
1.1 jfb 55:
1.13 jfb 56: static int cvs_slpriomap[LP_MAX + 1] = {
1.1 jfb 57: LOG_DEBUG,
58: LOG_INFO,
59: LOG_NOTICE,
60: LOG_WARNING,
61: LOG_ERR,
62: LOG_ALERT,
63: LOG_ERR,
1.4 jfb 64: LOG_ERR,
1.13 jfb 65: LOG_DEBUG,
1.1 jfb 66: };
67:
1.19 joris 68: static int send_m = 1;
1.1 jfb 69: static u_int cvs_log_dest = LD_STD;
70: static u_int cvs_log_flags = 0;
71:
1.10 jfb 72: static struct syslog_data cvs_sl = SYSLOG_DATA_INIT;
1.1 jfb 73:
1.9 jfb 74: /* filter manipulation macros */
1.22 ! xsa 75: #define CVS_LOG_FLTRRST() (cvs_log_filters = 0)
! 76: #define CVS_LOG_FLTRSET(l) (cvs_log_filters |= (1 << l))
! 77: #define CVS_LOG_FLTRGET(l) (cvs_log_filters & (1 << l))
! 78: #define CVS_LOG_FLTRCLR(l) (cvs_log_filters &= ~(1 << l))
1.1 jfb 79:
1.9 jfb 80: static u_int cvs_log_filters;
1.1 jfb 81:
82:
83: /*
84: * cvs_log_init()
85: *
86: * Initialize the logging facility of the server.
87: * Returns 0 on success, or -1 on failure.
88: */
89: int
90: cvs_log_init(u_int dest, u_int flags)
91: {
92: int slopt;
93:
94: cvs_log_dest = dest;
95: cvs_log_flags = flags;
96:
97: /* by default, filter only LP_DEBUG and LP_INFO levels */
1.9 jfb 98: CVS_LOG_FLTRRST();
99: CVS_LOG_FLTRSET(LP_DEBUG);
100: CVS_LOG_FLTRSET(LP_INFO);
1.1 jfb 101:
1.8 jfb 102: /* traces are enabled with the -t command-line option */
1.9 jfb 103: CVS_LOG_FLTRSET(LP_TRACE);
1.8 jfb 104:
1.1 jfb 105: if (dest & LD_SYSLOG) {
106: slopt = 0;
107:
108: if (dest & LD_CONS)
109: slopt |= LOG_CONS;
110: if (flags & LF_PID)
111: slopt |= LOG_PID;
112:
113: openlog_r(__progname, slopt, LOG_DAEMON, &cvs_sl);
114: }
115:
116: return (0);
117: }
118:
119:
120: /*
121: * cvs_log_cleanup()
122: *
123: * Cleanup the logging facility.
124: */
125: void
126: cvs_log_cleanup(void)
127: {
1.7 tedu 128:
1.1 jfb 129: closelog_r(&cvs_sl);
130: }
131:
132:
133: /*
134: * cvs_log_filter()
135: *
136: * Apply or remove filters on the logging facility. The exact operation is
137: * specified by the <how> and <level> arguments. The <how> arguments tells
138: * how the filters will be affected, and <level> gives the log levels that
139: * will be affected by the change.
140: * Returns 0 on success, or -1 on failure.
141: */
142:
143: int
144: cvs_log_filter(u_int how, u_int level)
145: {
146: u_int i;
147:
148: if ((level > LP_MAX) && (level != LP_ALL)) {
149: cvs_log(LP_ERR, "invalid log level for filter");
150: return (-1);
151: }
152:
153: switch (how) {
154: case LP_FILTER_SET:
155: if (level == LP_ALL)
1.9 jfb 156: for (i = 0; i <= LP_MAX; i++)
157: CVS_LOG_FLTRSET(i);
1.1 jfb 158: else
1.9 jfb 159: CVS_LOG_FLTRSET(level);
1.1 jfb 160: break;
161: case LP_FILTER_UNSET:
162: if (level == LP_ALL)
1.9 jfb 163: CVS_LOG_FLTRRST();
1.1 jfb 164: else
1.9 jfb 165: CVS_LOG_FLTRCLR(level);
1.1 jfb 166: break;
167: default:
168: return (-1);
169: }
170:
171: return (0);
172: }
173:
174:
175: /*
176: * cvs_log()
177: *
178: * Log the format-string message
179: * The <fmt> argument should not have a terminating newline, as this is taken
180: * care of by the logging facility.
181: */
182: int
183: cvs_log(u_int level, const char *fmt, ...)
184: {
185: int ret;
186: va_list vap;
187:
188: va_start(vap, fmt);
189: ret = cvs_vlog(level, fmt, vap);
190: va_end(vap);
191:
192: return (ret);
193: }
194:
195:
196: /*
197: * cvs_vlog()
198: *
199: * The <fmt> argument should not have a terminating newline, as this is taken
200: * care of by the logging facility.
201: */
202: int
203: cvs_vlog(u_int level, const char *fmt, va_list vap)
204: {
205: int ecp;
206: char prefix[64], buf[1024], ebuf[32];
207: FILE *out;
1.20 joris 208: struct cvs_cmd *cmdp;
1.1 jfb 209:
1.13 jfb 210: if (level > LP_MAX)
1.4 jfb 211: return (-1);
1.1 jfb 212:
213: /* apply any filters */
1.9 jfb 214: if (CVS_LOG_FLTRGET(level))
1.1 jfb 215: return (0);
216:
217: if (level == LP_ERRNO)
218: ecp = errno;
1.4 jfb 219: else
220: ecp = 0;
1.1 jfb 221:
1.17 xsa 222: /* always use the command name in error messages, not aliases */
223: cmdp = cvs_findcmd(cvs_command);
224:
1.3 jfb 225: /* The cvs program appends the command name to the program name */
1.8 jfb 226: if (level == LP_TRACE) {
227: strlcpy(prefix, " -> ", sizeof(prefix));
228: if (cvs_cmdop == CVS_OP_SERVER)
229: prefix[0] = 'S';
230: } else if (cvs_command != NULL) {
1.4 jfb 231: if (level == LP_ABORT)
232: snprintf(prefix, sizeof(prefix), "%s [%s aborted]",
1.17 xsa 233: __progname, cmdp->cmd_name);
1.4 jfb 234: else
235: snprintf(prefix, sizeof(prefix), "%s %s", __progname,
1.17 xsa 236: cmdp->cmd_name);
1.6 deraadt 237: } else /* just use the standard strlcpy */
1.3 jfb 238: strlcpy(prefix, __progname, sizeof(prefix));
239:
1.8 jfb 240: if ((cvs_log_flags & LF_PID) && (level != LP_TRACE)) {
1.1 jfb 241: snprintf(buf, sizeof(buf), "[%d]", (int)getpid());
242: strlcat(prefix, buf, sizeof(prefix));
243: }
244:
245: vsnprintf(buf, sizeof(buf), fmt, vap);
246: if (level == LP_ERRNO) {
247: snprintf(ebuf, sizeof(ebuf), ": %s", strerror(errno));
248: strlcat(buf, ebuf, sizeof(buf));
249: }
250:
251: if (cvs_log_dest & LD_STD) {
252: if (level <= LP_NOTICE)
253: out = stdout;
254: else
255: out = stderr;
1.3 jfb 256:
257: if (cvs_cmdop == CVS_OP_SERVER) {
258: if (out == stdout)
259: putc('M', out);
1.11 jfb 260: else {
261: out = stdout;
1.3 jfb 262: putc('E', out);
1.11 jfb 263: }
1.3 jfb 264: putc(' ', out);
265: }
1.1 jfb 266:
1.8 jfb 267: fputs(prefix, out);
268: if (level != LP_TRACE)
269: fputs(": ", out);
270: fputs(buf, out);
271: fputc('\n', out);
1.1 jfb 272: }
273:
274: if (cvs_log_dest & LD_SYSLOG)
275: syslog_r(cvs_slpriomap[level], &cvs_sl, "%s", buf);
276:
277: /* preserve it just in case we changed it? */
278: if (level == LP_ERRNO)
279: errno = ecp;
280:
281: return (0);
1.2 jfb 282: }
283:
284:
285: /*
286: * cvs_printf()
287: *
1.14 jfb 288: * Wrapper function around printf() that prepends a 'M' command when
1.2 jfb 289: * the program is acting as server.
290: */
291: int
292: cvs_printf(const char *fmt, ...)
293: {
294: int ret;
1.14 jfb 295: char *nstr, *dp, *sp;
1.2 jfb 296: va_list vap;
297:
298: va_start(vap, fmt);
1.14 jfb 299:
300: if (cvs_cmdop == CVS_OP_SERVER) {
301: ret = vasprintf(&nstr, fmt, vap);
302: if (ret != -1) {
303: for (dp = nstr; *dp != '\0';) {
304: sp = strchr(dp, '\n');
305: if (sp == NULL)
306: for (sp = dp; *sp != '\0'; sp++)
307: ;
308:
1.21 joris 309: if (send_m) {
1.18 joris 310: send_m = 0;
311: putc('M', stdout);
312: putc(' ', stdout);
313: }
314:
1.14 jfb 315: fwrite(dp, sizeof(char), (size_t)(sp - dp),
316: stdout);
317:
318: if (*sp != '\n')
319: break;
320:
321: putc('\n', stdout);
1.18 joris 322: send_m = 1;
1.14 jfb 323: dp = sp + 1;
324: }
325: free(nstr);
326: }
327: } else
328: ret = vprintf(fmt, vap);
329:
1.2 jfb 330: va_end(vap);
331: return (ret);
1.1 jfb 332: }
1.19 joris 333: void
334: cvs_putchar(int c)
335: {
336: if (cvs_cmdop == CVS_OP_SERVER && send_m) {
337: send_m = 0;
338: putc('M', stdout);
339: putc(' ', stdout);
340: }
341:
342: putc(c, stdout);
343:
344: if (cvs_cmdop == CVS_OP_SERVER && c == '\n')
345: send_m = 1;
346: }
![[BACK]](/icons/back.gif){kind=icon}
Return to log.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / cvs