1 /* 2 * Copyright (c) 1997-2006 Kungliga Tekniska H�gskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 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 * 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the Institute nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "krb5_locl.h" 35 36 RCSID("$Id: log.c 19088 2006-11-21 08:08:46Z lha $"); 37 38 struct facility { 39 int min; 40 int max; 41 krb5_log_log_func_t log_func; 42 krb5_log_close_func_t close_func; 43 void *data; 44 }; 45 46 static struct facility* 47 log_realloc(krb5_log_facility *f) 48 { 49 struct facility *fp; 50 fp = realloc(f->val, (f->len + 1) * sizeof(*f->val)); 51 if(fp == NULL) 52 return NULL; 53 f->len++; 54 f->val = fp; 55 fp += f->len - 1; 56 return fp; 57 } 58 59 struct s2i { 60 const char *s; 61 int val; 62 }; 63 64 #define L(X) { #X, LOG_ ## X } 65 66 static struct s2i syslogvals[] = { 67 L(EMERG), 68 L(ALERT), 69 L(CRIT), 70 L(ERR), 71 L(WARNING), 72 L(NOTICE), 73 L(INFO), 74 L(DEBUG), 75 76 L(AUTH), 77 #ifdef LOG_AUTHPRIV 78 L(AUTHPRIV), 79 #endif 80 #ifdef LOG_CRON 81 L(CRON), 82 #endif 83 L(DAEMON), 84 #ifdef LOG_FTP 85 L(FTP), 86 #endif 87 L(KERN), 88 L(LPR), 89 L(MAIL), 90 #ifdef LOG_NEWS 91 L(NEWS), 92 #endif 93 L(SYSLOG), 94 L(USER), 95 #ifdef LOG_UUCP 96 L(UUCP), 97 #endif 98 L(LOCAL0), 99 L(LOCAL1), 100 L(LOCAL2), 101 L(LOCAL3), 102 L(LOCAL4), 103 L(LOCAL5), 104 L(LOCAL6), 105 L(LOCAL7), 106 { NULL, -1 } 107 }; 108 109 static int 110 find_value(const char *s, struct s2i *table) 111 { 112 while(table->s && strcasecmp(table->s, s)) 113 table++; 114 return table->val; 115 } 116 117 krb5_error_code KRB5_LIB_FUNCTION 118 krb5_initlog(krb5_context context, 119 const char *program, 120 krb5_log_facility **fac) 121 { 122 krb5_log_facility *f = calloc(1, sizeof(*f)); 123 if(f == NULL) { 124 krb5_set_error_string (context, "malloc: out of memory"); 125 return ENOMEM; 126 } 127 f->program = strdup(program); 128 if(f->program == NULL){ 129 free(f); 130 krb5_set_error_string (context, "malloc: out of memory"); 131 return ENOMEM; 132 } 133 *fac = f; 134 return 0; 135 } 136 137 krb5_error_code KRB5_LIB_FUNCTION 138 krb5_addlog_func(krb5_context context, 139 krb5_log_facility *fac, 140 int min, 141 int max, 142 krb5_log_log_func_t log_func, 143 krb5_log_close_func_t close_func, 144 void *data) 145 { 146 struct facility *fp = log_realloc(fac); 147 if(fp == NULL) { 148 krb5_set_error_string (context, "malloc: out of memory"); 149 return ENOMEM; 150 } 151 fp->min = min; 152 fp->max = max; 153 fp->log_func = log_func; 154 fp->close_func = close_func; 155 fp->data = data; 156 return 0; 157 } 158 159 160 struct _heimdal_syslog_data{ 161 int priority; 162 }; 163 164 static void 165 log_syslog(const char *timestr, 166 const char *msg, 167 void *data) 168 169 { 170 struct _heimdal_syslog_data *s = data; 171 syslog(s->priority, "%s", msg); 172 } 173 174 static void 175 close_syslog(void *data) 176 { 177 free(data); 178 closelog(); 179 } 180 181 static krb5_error_code 182 open_syslog(krb5_context context, 183 krb5_log_facility *facility, int min, int max, 184 const char *sev, const char *fac) 185 { 186 struct _heimdal_syslog_data *sd = malloc(sizeof(*sd)); 187 int i; 188 189 if(sd == NULL) { 190 krb5_set_error_string (context, "malloc: out of memory"); 191 return ENOMEM; 192 } 193 i = find_value(sev, syslogvals); 194 if(i == -1) 195 i = LOG_ERR; 196 sd->priority = i; 197 i = find_value(fac, syslogvals); 198 if(i == -1) 199 i = LOG_AUTH; 200 sd->priority |= i; 201 roken_openlog(facility->program, LOG_PID | LOG_NDELAY, i); 202 return krb5_addlog_func(context, facility, min, max, 203 log_syslog, close_syslog, sd); 204 } 205 206 struct file_data{ 207 const char *filename; 208 const char *mode; 209 FILE *fd; 210 int keep_open; 211 }; 212 213 static void 214 log_file(const char *timestr, 215 const char *msg, 216 void *data) 217 { 218 struct file_data *f = data; 219 if(f->keep_open == 0) 220 f->fd = fopen(f->filename, f->mode); 221 if(f->fd == NULL) 222 return; 223 fprintf(f->fd, "%s %s\n", timestr, msg); 224 if(f->keep_open == 0) { 225 fclose(f->fd); 226 f->fd = NULL; 227 } 228 } 229 230 static void 231 close_file(void *data) 232 { 233 struct file_data *f = data; 234 if(f->keep_open && f->filename) 235 fclose(f->fd); 236 free(data); 237 } 238 239 static krb5_error_code 240 open_file(krb5_context context, krb5_log_facility *fac, int min, int max, 241 const char *filename, const char *mode, FILE *f, int keep_open) 242 { 243 struct file_data *fd = malloc(sizeof(*fd)); 244 if(fd == NULL) { 245 krb5_set_error_string (context, "malloc: out of memory"); 246 return ENOMEM; 247 } 248 fd->filename = filename; 249 fd->mode = mode; 250 fd->fd = f; 251 fd->keep_open = keep_open; 252 253 return krb5_addlog_func(context, fac, min, max, log_file, close_file, fd); 254 } 255 256 257 258 krb5_error_code KRB5_LIB_FUNCTION 259 krb5_addlog_dest(krb5_context context, krb5_log_facility *f, const char *orig) 260 { 261 krb5_error_code ret = 0; 262 int min = 0, max = -1, n; 263 char c; 264 const char *p = orig; 265 266 n = sscanf(p, "%d%c%d/", &min, &c, &max); 267 if(n == 2){ 268 if(c == '/') { 269 if(min < 0){ 270 max = -min; 271 min = 0; 272 }else{ 273 max = min; 274 } 275 } 276 } 277 if(n){ 278 p = strchr(p, '/'); 279 if(p == NULL) { 280 krb5_set_error_string (context, "failed to parse \"%s\"", orig); 281 return HEIM_ERR_LOG_PARSE; 282 } 283 p++; 284 } 285 if(strcmp(p, "STDERR") == 0){ 286 ret = open_file(context, f, min, max, NULL, NULL, stderr, 1); 287 }else if(strcmp(p, "CONSOLE") == 0){ 288 ret = open_file(context, f, min, max, "/dev/console", "w", NULL, 0); 289 }else if(strncmp(p, "FILE", 4) == 0 && (p[4] == ':' || p[4] == '=')){ 290 char *fn; 291 FILE *file = NULL; 292 int keep_open = 0; 293 fn = strdup(p + 5); 294 if(fn == NULL) { 295 krb5_set_error_string (context, "malloc: out of memory"); 296 return ENOMEM; 297 } 298 if(p[4] == '='){ 299 int i = open(fn, O_WRONLY | O_CREAT | 300 O_TRUNC | O_APPEND, 0666); 301 if(i < 0) { 302 ret = errno; 303 krb5_set_error_string (context, "open(%s): %s", fn, 304 strerror(ret)); 305 free(fn); 306 return ret; 307 } 308 file = fdopen(i, "a"); 309 if(file == NULL){ 310 ret = errno; 311 close(i); 312 krb5_set_error_string (context, "fdopen(%s): %s", fn, 313 strerror(ret)); 314 free(fn); 315 return ret; 316 } 317 keep_open = 1; 318 } 319 ret = open_file(context, f, min, max, fn, "a", file, keep_open); 320 }else if(strncmp(p, "DEVICE", 6) == 0 && (p[6] == ':' || p[6] == '=')){ 321 ret = open_file(context, f, min, max, strdup(p + 7), "w", NULL, 0); 322 }else if(strncmp(p, "SYSLOG", 6) == 0 && (p[6] == '\0' || p[6] == ':')){ 323 char severity[128] = ""; 324 char facility[128] = ""; 325 p += 6; 326 if(*p != '\0') 327 p++; 328 if(strsep_copy(&p, ":", severity, sizeof(severity)) != -1) 329 strsep_copy(&p, ":", facility, sizeof(facility)); 330 if(*severity == '\0') 331 strlcpy(severity, "ERR", sizeof(severity)); 332 if(*facility == '\0') 333 strlcpy(facility, "AUTH", sizeof(facility)); 334 ret = open_syslog(context, f, min, max, severity, facility); 335 }else{ 336 krb5_set_error_string (context, "unknown log type: %s", p); 337 ret = HEIM_ERR_LOG_PARSE; /* XXX */ 338 } 339 return ret; 340 } 341 342 343 krb5_error_code KRB5_LIB_FUNCTION 344 krb5_openlog(krb5_context context, 345 const char *program, 346 krb5_log_facility **fac) 347 { 348 krb5_error_code ret; 349 char **p, **q; 350 351 ret = krb5_initlog(context, program, fac); 352 if(ret) 353 return ret; 354 355 p = krb5_config_get_strings(context, NULL, "logging", program, NULL); 356 if(p == NULL) 357 p = krb5_config_get_strings(context, NULL, "logging", "default", NULL); 358 if(p){ 359 for(q = p; *q; q++) 360 ret = krb5_addlog_dest(context, *fac, *q); 361 krb5_config_free_strings(p); 362 }else 363 ret = krb5_addlog_dest(context, *fac, "SYSLOG"); 364 return 0; 365 } 366 367 krb5_error_code KRB5_LIB_FUNCTION 368 krb5_closelog(krb5_context context, 369 krb5_log_facility *fac) 370 { 371 int i; 372 for(i = 0; i < fac->len; i++) 373 (*fac->val[i].close_func)(fac->val[i].data); 374 free(fac->val); 375 free(fac->program); 376 fac->val = NULL; 377 fac->len = 0; 378 fac->program = NULL; 379 free(fac); 380 return 0; 381 } 382 383 #undef __attribute__ 384 #define __attribute__(X) 385 386 krb5_error_code KRB5_LIB_FUNCTION 387 krb5_vlog_msg(krb5_context context, 388 krb5_log_facility *fac, 389 char **reply, 390 int level, 391 const char *fmt, 392 va_list ap) 393 __attribute__((format (printf, 5, 0))) 394 { 395 396 char *msg = NULL; 397 const char *actual = NULL; 398 char buf[64]; 399 time_t t = 0; 400 int i; 401 402 for(i = 0; fac && i < fac->len; i++) 403 if(fac->val[i].min <= level && 404 (fac->val[i].max < 0 || fac->val[i].max >= level)) { 405 if(t == 0) { 406 t = time(NULL); 407 krb5_format_time(context, t, buf, sizeof(buf), TRUE); 408 } 409 if(actual == NULL) { 410 vasprintf(&msg, fmt, ap); 411 if(msg == NULL) 412 actual = fmt; 413 else 414 actual = msg; 415 } 416 (*fac->val[i].log_func)(buf, actual, fac->val[i].data); 417 } 418 if(reply == NULL) 419 free(msg); 420 else 421 *reply = msg; 422 return 0; 423 } 424 425 krb5_error_code KRB5_LIB_FUNCTION 426 krb5_vlog(krb5_context context, 427 krb5_log_facility *fac, 428 int level, 429 const char *fmt, 430 va_list ap) 431 __attribute__((format (printf, 4, 0))) 432 { 433 return krb5_vlog_msg(context, fac, NULL, level, fmt, ap); 434 } 435 436 krb5_error_code KRB5_LIB_FUNCTION 437 krb5_log_msg(krb5_context context, 438 krb5_log_facility *fac, 439 int level, 440 char **reply, 441 const char *fmt, 442 ...) 443 __attribute__((format (printf, 5, 6))) 444 { 445 va_list ap; 446 krb5_error_code ret; 447 448 va_start(ap, fmt); 449 ret = krb5_vlog_msg(context, fac, reply, level, fmt, ap); 450 va_end(ap); 451 return ret; 452 } 453 454 455 krb5_error_code KRB5_LIB_FUNCTION 456 krb5_log(krb5_context context, 457 krb5_log_facility *fac, 458 int level, 459 const char *fmt, 460 ...) 461 __attribute__((format (printf, 4, 5))) 462 { 463 va_list ap; 464 krb5_error_code ret; 465 466 va_start(ap, fmt); 467 ret = krb5_vlog(context, fac, level, fmt, ap); 468 va_end(ap); 469 return ret; 470 } 471 472