1 /* $OpenBSD: syslog.c,v 1.28 2005/08/08 08:05:34 espie Exp $ */ 2 /* 3 * Copyright (c) 1983, 1988, 1993 4 * The Regents of the University of California. 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 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. Neither the name of the University nor the names of its contributors 15 * may be used to endorse or promote products derived from this software 16 * without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/types.h> 32 #include <sys/socket.h> 33 #include <sys/uio.h> 34 #include <syslog.h> 35 #include <sys/un.h> 36 #include <netdb.h> 37 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <paths.h> 41 #include <stdio.h> 42 #include <string.h> 43 #include <time.h> 44 #include <unistd.h> 45 #include <stdarg.h> 46 47 static struct syslog_data sdata = SYSLOG_DATA_INIT; 48 49 extern char *__progname; /* Program name, from crt0. */ 50 51 static void disconnectlog_r(struct syslog_data *); /* disconnect from syslogd */ 52 static void connectlog_r(struct syslog_data *); /* (re)connect to syslogd */ 53 54 /* 55 * syslog, vsyslog -- 56 * print message on log file; output is intended for syslogd(8). 57 */ 58 void 59 syslog(int pri, const char *fmt, ...) 60 { 61 va_list ap; 62 63 va_start(ap, fmt); 64 vsyslog(pri, fmt, ap); 65 va_end(ap); 66 } 67 68 void 69 vsyslog(int pri, const char *fmt, va_list ap) 70 { 71 vsyslog_r(pri, &sdata, fmt, ap); 72 } 73 74 void 75 openlog(const char *ident, int logstat, int logfac) 76 { 77 openlog_r(ident, logstat, logfac, &sdata); 78 } 79 80 void 81 closelog(void) 82 { 83 closelog_r(&sdata); 84 } 85 86 /* setlogmask -- set the log mask level */ 87 int 88 setlogmask(int pmask) 89 { 90 return setlogmask_r(pmask, &sdata); 91 } 92 93 /* Reentrant version of syslog, i.e. syslog_r() */ 94 95 void 96 syslog_r(int pri, struct syslog_data *data, const char *fmt, ...) 97 { 98 va_list ap; 99 100 va_start(ap, fmt); 101 vsyslog_r(pri, data, fmt, ap); 102 va_end(ap); 103 } 104 105 void 106 vsyslog_r(int pri, struct syslog_data *data, const char *fmt, va_list ap) 107 { 108 int cnt; 109 char ch, *p, *t; 110 time_t now; 111 int fd, saved_errno, error; 112 #define TBUF_LEN 2048 113 #define FMT_LEN 1024 114 char *stdp = NULL, tbuf[TBUF_LEN], fmt_cpy[FMT_LEN]; 115 int tbuf_left, fmt_left, prlen; 116 117 #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID 118 /* Check for invalid bits. */ 119 if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { 120 if (data == &sdata) { 121 syslog(INTERNALLOG, 122 "syslog: unknown facility/priority: %x", pri); 123 } else { 124 syslog_r(INTERNALLOG, data, 125 "syslog_r: unknown facility/priority: %x", pri); 126 } 127 pri &= LOG_PRIMASK|LOG_FACMASK; 128 } 129 130 /* Check priority against setlogmask values. */ 131 if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask)) 132 return; 133 134 saved_errno = errno; 135 136 /* Set default facility if none specified. */ 137 if ((pri & LOG_FACMASK) == 0) 138 pri |= data->log_fac; 139 140 /* If we have been called through syslog(), no need for reentrancy. */ 141 if (data == &sdata) 142 (void)time(&now); 143 144 p = tbuf; 145 tbuf_left = TBUF_LEN; 146 147 #define DEC() \ 148 do { \ 149 if (prlen < 0) \ 150 prlen = 0; \ 151 if (prlen >= tbuf_left) \ 152 prlen = tbuf_left - 1; \ 153 p += prlen; \ 154 tbuf_left -= prlen; \ 155 } while (0) 156 157 prlen = snprintf(p, tbuf_left, "<%d>", pri); 158 DEC(); 159 160 /* 161 * syslogd will expand time automagically for reentrant case, and 162 * for normal case, just do like before 163 */ 164 if (data == &sdata) { 165 prlen = strftime(p, tbuf_left, "%h %e %T ", localtime(&now)); 166 DEC(); 167 } 168 169 if (data->log_stat & LOG_PERROR) 170 stdp = p; 171 if (data->log_tag == NULL) 172 data->log_tag = __progname; 173 if (data->log_tag != NULL) { 174 prlen = snprintf(p, tbuf_left, "%s", data->log_tag); 175 DEC(); 176 } 177 if (data->log_stat & LOG_PID) { 178 prlen = snprintf(p, tbuf_left, "[%ld]", (long)getpid()); 179 DEC(); 180 } 181 if (data->log_tag != NULL) { 182 if (tbuf_left > 1) { 183 *p++ = ':'; 184 tbuf_left--; 185 } 186 if (tbuf_left > 1) { 187 *p++ = ' '; 188 tbuf_left--; 189 } 190 } 191 192 /* strerror() is not reentrant */ 193 194 for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt); ++fmt) { 195 if (ch == '%' && fmt[1] == 'm') { 196 ++fmt; 197 if (data == &sdata) { 198 prlen = snprintf(t, fmt_left, "%s", 199 strerror(saved_errno)); 200 } else { 201 prlen = snprintf(t, fmt_left, "Error %d", 202 saved_errno); 203 } 204 if (prlen < 0) 205 prlen = 0; 206 if (prlen >= fmt_left) 207 prlen = fmt_left - 1; 208 t += prlen; 209 fmt_left -= prlen; 210 } else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) { 211 *t++ = '%'; 212 *t++ = '%'; 213 fmt++; 214 fmt_left -= 2; 215 } else { 216 if (fmt_left > 1) { 217 *t++ = ch; 218 fmt_left--; 219 } 220 } 221 } 222 *t = '\0'; 223 224 prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap); 225 DEC(); 226 cnt = p - tbuf; 227 228 /* Output to stderr if requested. */ 229 if (data->log_stat & LOG_PERROR) { 230 struct iovec iov[2]; 231 232 iov[0].iov_base = stdp; 233 iov[0].iov_len = cnt - (stdp - tbuf); 234 iov[1].iov_base = "\n"; 235 iov[1].iov_len = 1; 236 (void)writev(STDERR_FILENO, iov, 2); 237 } 238 239 /* Get connected, output the message to the local logger. */ 240 if (!data->opened) 241 openlog_r(data->log_tag, data->log_stat, 0, data); 242 connectlog_r(data); 243 244 /* 245 * If the send() failed, there are two likely scenarios: 246 * 1) syslogd was restarted 247 * 2) /dev/log is out of socket buffer space 248 * We attempt to reconnect to /dev/log to take care of 249 * case #1 and keep send()ing data to cover case #2 250 * to give syslogd a chance to empty its socket buffer. 251 */ 252 if ((error = send(data->log_file, tbuf, cnt, 0)) < 0) { 253 if (errno != ENOBUFS) { 254 disconnectlog_r(data); 255 connectlog_r(data); 256 } 257 do { 258 usleep(1); 259 if ((error = send(data->log_file, tbuf, cnt, 0)) >= 0) 260 break; 261 } while (errno == ENOBUFS); 262 } 263 264 /* 265 * Output the message to the console; try not to block 266 * as a blocking console should not stop other processes. 267 * Make sure the error reported is the one from the syslogd failure. 268 */ 269 if (error == -1 && (data->log_stat & LOG_CONS) && 270 (fd = open(_PATH_CONSOLE, O_WRONLY|O_NONBLOCK, 0)) >= 0) { 271 struct iovec iov[2]; 272 273 p = strchr(tbuf, '>') + 1; 274 iov[0].iov_base = p; 275 iov[0].iov_len = cnt - (p - tbuf); 276 iov[1].iov_base = "\r\n"; 277 iov[1].iov_len = 2; 278 (void)writev(fd, iov, 2); 279 (void)close(fd); 280 } 281 282 if (data != &sdata) 283 closelog_r(data); 284 } 285 286 static void 287 disconnectlog_r(struct syslog_data *data) 288 { 289 /* 290 * If the user closed the FD and opened another in the same slot, 291 * that's their problem. They should close it before calling on 292 * system services. 293 */ 294 if (data->log_file != -1) { 295 close(data->log_file); 296 data->log_file = -1; 297 } 298 data->connected = 0; /* retry connect */ 299 } 300 301 static void 302 connectlog_r(struct syslog_data *data) 303 { 304 union { 305 struct sockaddr syslogAddr; 306 struct sockaddr_un syslogAddrUn; 307 } u; 308 309 #define SyslogAddr u.syslogAddrUn 310 311 if (data->log_file == -1) { 312 if ((data->log_file = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1) 313 return; 314 (void)fcntl(data->log_file, F_SETFD, 1); 315 } 316 if (data->log_file != -1 && !data->connected) { 317 memset(&SyslogAddr, '\0', sizeof(SyslogAddr)); 318 #if 0 319 /* BIONIC: no sun_len field to fill on Linux */ 320 SyslogAddr.sun_len = sizeof(SyslogAddr); 321 #endif 322 SyslogAddr.sun_family = AF_UNIX; 323 strlcpy(SyslogAddr.sun_path, _PATH_LOG, 324 sizeof(SyslogAddr.sun_path)); 325 if (connect(data->log_file, &u.syslogAddr, 326 sizeof(SyslogAddr)) == -1) { 327 (void)close(data->log_file); 328 data->log_file = -1; 329 } else 330 data->connected = 1; 331 } 332 } 333 334 void 335 openlog_r(const char *ident, int logstat, int logfac, struct syslog_data *data) 336 { 337 if (ident != NULL) 338 data->log_tag = ident; 339 data->log_stat = logstat; 340 if (logfac != 0 && (logfac &~ LOG_FACMASK) == 0) 341 data->log_fac = logfac; 342 343 if (data->log_stat & LOG_NDELAY) /* open immediately */ 344 connectlog_r(data); 345 346 data->opened = 1; /* ident and facility has been set */ 347 } 348 349 void 350 closelog_r(struct syslog_data *data) 351 { 352 (void)close(data->log_file); 353 data->log_file = -1; 354 data->connected = 0; 355 data->log_tag = NULL; 356 } 357 358 /* setlogmask -- set the log mask level */ 359 int 360 setlogmask_r(int pmask, struct syslog_data *data) 361 { 362 int omask; 363 364 omask = data->log_mask; 365 if (pmask != 0) 366 data->log_mask = pmask; 367 return (omask); 368 } 369
