]> git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/log.c
projects / thirdparty / cups.git / blob
? search:


de7b5458f00ad3a3b1647e4ca966d777a285be8a
[thirdparty/cups.git] / scheduler / log.c
1 /*
2 * "$Id: log.c 7918 2008-09-08 22:03:01Z mike $"
3 *
4 * Log file routines for the CUPS scheduler.
5 *
6 * Copyright 2007-2011 by Apple Inc.
7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
8 *
9 * These coded instructions, statements, and computer programs are the
10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
12 * which should have been included with this file. If this file is
13 * file is missing or damaged, see the license at "http://www.cups.org/".
14 *
15 * Contents:
16 *
17 * cupsdCheckLogFile() - Open/rotate a log file if it needs it.
18 * cupsdGetDateTime() - Returns a pointer to a date/time string.
19 * cupsdLogGSSMessage() - Log a GSSAPI error...
20 * cupsdLogJob() - Log a job message.
21 * cupsdLogMessage() - Log a message to the error log file.
22 * cupsdLogPage() - Log a page to the page log file.
23 * cupsdLogRequest() - Log an HTTP request in Common Log Format.
24 * cupsdWriteErrorLog() - Write a line to the ErrorLog.
25 * format_log_line() - Format a line for a log file.
26 */
27
28 /*
29 * Include necessary headers...
30 */
31
32 #include "cupsd.h"
33 #include <stdarg.h>
34 #include <syslog.h>
35
36
37 /*
38 * Local globals...
39 */
40
41 static int log_linesize = 0; /* Size of line for output file */
42 static char *log_line = NULL; /* Line for output file */
43
44
45 /*
46 * Local functions...
47 */
48
49 static int format_log_line(const char *message, va_list ap);
50
51
52 /*
53 * 'cupsdCheckLogFile()' - Open/rotate a log file if it needs it.
54 */
55
56 int /* O - 1 if log file open */
57 cupsdCheckLogFile(cups_file_t **lf, /* IO - Log file */
58 const char *logname) /* I - Log filename */
59 {
60 char backname[1024], /* Backup log filename */
61 filename[1024], /* Formatted log filename */
62 *ptr; /* Pointer into filename */
63 const char *logptr; /* Pointer into log filename */
64
65
66 /*
67 * See if we have a log file to check...
68 */
69
70 if (!lf || !logname || !logname[0])
71 return (1);
72
73 /*
74 * Format the filename as needed...
75 */
76
77 if (!*lf ||
78 (strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
79 MaxLogSize > 0))
80 {
81 /*
82 * Handle format strings...
83 */
84
85 filename[sizeof(filename) - 1] = '\0';
86
87 if (logname[0] != '/')
88 {
89 strlcpy(filename, ServerRoot, sizeof(filename));
90 strlcat(filename, "/", sizeof(filename));
91 }
92 else
93 filename[0] = '\0';
94
95 for (logptr = logname, ptr = filename + strlen(filename);
96 *logptr && ptr < (filename + sizeof(filename) - 1);
97 logptr ++)
98 if (*logptr == '%')
99 {
100 /*
101 * Format spec...
102 */
103
104 logptr ++;
105 if (*logptr == 's')
106 {
107 /*
108 * Insert the server name...
109 */
110
111 strlcpy(ptr, ServerName, sizeof(filename) - (ptr - filename));
112 ptr += strlen(ptr);
113 }
114 else
115 {
116 /*
117 * Otherwise just insert the character...
118 */
119
120 *ptr++ = *logptr;
121 }
122 }
123 else
124 *ptr++ = *logptr;
125
126 *ptr = '\0';
127 }
128
129 /*
130 * See if the log file is open...
131 */
132
133 if (!*lf)
134 {
135 /*
136 * Nope, open the log file...
137 */
138
139 if ((*lf = cupsFileOpen(filename, "a")) == NULL)
140 {
141 /*
142 * If the file is in CUPS_LOGDIR then try to create a missing directory...
143 */
144
145 if (!strncmp(filename, CUPS_LOGDIR, strlen(CUPS_LOGDIR)))
146 {
147 /*
148 * Try updating the permissions of the containing log directory, using
149 * the log file permissions as a basis...
150 */
151
152 int log_dir_perm = 0300 | LogFilePerm;
153 /* LogFilePerm + owner write/search */
154 if (log_dir_perm & 0040)
155 log_dir_perm |= 0010; /* Add group search */
156 if (log_dir_perm & 0004)
157 log_dir_perm |= 0001; /* Add other search */
158
159 cupsdCheckPermissions(CUPS_LOGDIR, NULL, log_dir_perm, RunUser, Group,
160 1, -1);
161
162 *lf = cupsFileOpen(filename, "a");
163 }
164
165 if (*lf == NULL)
166 {
167 syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename,
168 strerror(errno));
169
170 if (FatalErrors & CUPSD_FATAL_LOG)
171 cupsdEndProcess(getpid(), 0);
172
173 return (0);
174 }
175 }
176
177 if (strncmp(filename, "/dev/", 5))
178 {
179 /*
180 * Change ownership and permissions of non-device logs...
181 */
182
183 fchown(cupsFileNumber(*lf), RunUser, Group);
184 fchmod(cupsFileNumber(*lf), LogFilePerm);
185 }
186 }
187
188 /*
189 * Do we need to rotate the log?
190 */
191
192 if (strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
193 MaxLogSize > 0)
194 {
195 /*
196 * Rotate log file...
197 */
198
199 cupsFileClose(*lf);
200
201 strcpy(backname, filename);
202 strlcat(backname, ".O", sizeof(backname));
203
204 unlink(backname);
205 rename(filename, backname);
206
207 if ((*lf = cupsFileOpen(filename, "a")) == NULL)
208 {
209 syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename,
210 strerror(errno));
211
212 if (FatalErrors & CUPSD_FATAL_LOG)
213 cupsdEndProcess(getpid(), 0);
214
215 return (0);
216 }
217
218 /*
219 * Change ownership and permissions of non-device logs...
220 */
221
222 fchown(cupsFileNumber(*lf), RunUser, Group);
223 fchmod(cupsFileNumber(*lf), LogFilePerm);
224 }
225
226 return (1);
227 }
228
229
230 /*
231 * 'cupsdGetDateTime()' - Returns a pointer to a date/time string.
232 */
233
234 char * /* O - Date/time string */
235 cupsdGetDateTime(struct timeval *t, /* I - Time value or NULL for current */
236 cupsd_time_t format) /* I - Format to use */
237 {
238 struct timeval curtime; /* Current time value */
239 struct tm *date; /* Date/time value */
240 static struct timeval last_time = { 0, 0 };
241 /* Last time we formatted */
242 static char s[1024]; /* Date/time string */
243 static const char * const months[12] =/* Months */
244 {
245 "Jan",
246 "Feb",
247 "Mar",
248 "Apr",
249 "May",
250 "Jun",
251 "Jul",
252 "Aug",
253 "Sep",
254 "Oct",
255 "Nov",
256 "Dec"
257 };
258
259
260 /*
261 * Make sure we have a valid time...
262 */
263
264 if (!t)
265 {
266 gettimeofday(&curtime, NULL);
267 t = &curtime;
268 }
269
270 if (t->tv_sec != last_time.tv_sec ||
271 (LogTimeFormat == CUPSD_TIME_USECS && t->tv_usec != last_time.tv_usec))
272 {
273 last_time = *t;
274
275 /*
276 * Get the date and time from the UNIX time value, and then format it
277 * into a string. Note that we *can't* use the strftime() function since
278 * it is localized and will seriously confuse automatic programs if the
279 * month names are in the wrong language!
280 *
281 * Also, we use the "timezone" variable that contains the current timezone
282 * offset from GMT in seconds so that we are reporting local time in the
283 * log files. If you want GMT, set the TZ environment variable accordingly
284 * before starting the scheduler.
285 *
286 * (*BSD and Darwin store the timezone offset in the tm structure)
287 */
288
289 date = localtime(&(t->tv_sec));
290
291 if (format == CUPSD_TIME_STANDARD)
292 snprintf(s, sizeof(s), "[%02d/%s/%04d:%02d:%02d:%02d %+03ld%02ld]",
293 date->tm_mday, months[date->tm_mon], 1900 + date->tm_year,
294 date->tm_hour, date->tm_min, date->tm_sec,
295 #ifdef HAVE_TM_GMTOFF
296 date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
297 #else
298 timezone / 3600, (timezone / 60) % 60);
299 #endif /* HAVE_TM_GMTOFF */
300 else
301 snprintf(s, sizeof(s), "[%02d/%s/%04d:%02d:%02d:%02d.%06d %+03ld%02ld]",
302 date->tm_mday, months[date->tm_mon], 1900 + date->tm_year,
303 date->tm_hour, date->tm_min, date->tm_sec, (int)t->tv_usec,
304 #ifdef HAVE_TM_GMTOFF
305 date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
306 #else
307 timezone / 3600, (timezone / 60) % 60);
308 #endif /* HAVE_TM_GMTOFF */
309 }
310
311 return (s);
312 }
313
314
315 /*
316 * 'cupsdLogFCMessage()' - Log a file checking message.
317 */
318
319 void
320 cupsdLogFCMessage(
321 void *context, /* I - Printer (if any) */
322 _cups_fc_result_t result, /* I - Check result */
323 const char *message) /* I - Message to log */
324 {
325 cupsd_printer_t *p = (cupsd_printer_t *)context;
326 /* Printer */
327 cupsd_loglevel_t level; /* Log level */
328
329
330 if (result == _CUPS_FILE_CHECK_OK)
331 level = CUPSD_LOG_DEBUG2;
332 else
333 level = CUPSD_LOG_ERROR;
334
335 if (p)
336 {
337 cupsdLogMessage(level, "%s: %s", p->name, message);
338
339 if (result == _CUPS_FILE_CHECK_MISSING ||
340 result == _CUPS_FILE_CHECK_WRONG_TYPE)
341 {
342 strlcpy(p->state_message, message, sizeof(p->state_message));
343
344 if (cupsdSetPrinterReasons(p, "+cups-missing-filter-warning"))
345 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, p, NULL, "%s", message);
346 }
347 else if (result == _CUPS_FILE_CHECK_PERMISSIONS ||
348 result == _CUPS_FILE_CHECK_RELATIVE_PATH)
349 {
350 strlcpy(p->state_message, message, sizeof(p->state_message));
351
352 if (cupsdSetPrinterReasons(p, "+cups-insecure-filter-warning"))
353 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, p, NULL, "%s", message);
354 }
355 }
356 else
357 cupsdLogMessage(level, "%s", message);
358 }
359
360
361 #ifdef HAVE_GSSAPI
362 /*
363 * 'cupsdLogGSSMessage()' - Log a GSSAPI error...
364 */
365
366 int /* O - 1 on success, 0 on error */
367 cupsdLogGSSMessage(
368 int level, /* I - Log level */
369 int major_status, /* I - Major GSSAPI status */
370 int minor_status, /* I - Minor GSSAPI status */
371 const char *message, /* I - printf-style message string */
372 ...) /* I - Additional args as needed */
373 {
374 OM_uint32 err_major_status, /* Major status code for display */
375 err_minor_status; /* Minor status code for display */
376 OM_uint32 msg_ctx; /* Message context */
377 gss_buffer_desc major_status_string = GSS_C_EMPTY_BUFFER,
378 /* Major status message */
379 minor_status_string = GSS_C_EMPTY_BUFFER;
380 /* Minor status message */
381 int ret; /* Return value */
382
383
384 msg_ctx = 0;
385 err_major_status = gss_display_status(&err_minor_status,
386 major_status,
387 GSS_C_GSS_CODE,
388 GSS_C_NO_OID,
389 &msg_ctx,
390 &major_status_string);
391
392 if (!GSS_ERROR(err_major_status))
393 gss_display_status(&err_minor_status, minor_status, GSS_C_MECH_CODE,
394 GSS_C_NULL_OID, &msg_ctx, &minor_status_string);
395
396 ret = cupsdLogMessage(level, "%s: %s, %s", message,
397 (char *)major_status_string.value,
398 (char *)minor_status_string.value);
399 gss_release_buffer(&err_minor_status, &major_status_string);
400 gss_release_buffer(&err_minor_status, &minor_status_string);
401
402 return (ret);
403 }
404 #endif /* HAVE_GSSAPI */
405
406
407 /*
408 * 'cupsdLogJob()' - Log a job message.
409 */
410
411 int /* O - 1 on success, 0 on error */
412 cupsdLogJob(cupsd_job_t *job, /* I - Job */
413 int level, /* I - Log level */
414 const char *message, /* I - Printf-style message string */
415 ...) /* I - Additional arguments as needed */
416 {
417 va_list ap; /* Argument pointer */
418 char jobmsg[1024]; /* Format string for job message */
419 int status; /* Formatting status */
420
421
422 /*
423 * See if we want to log this message...
424 */
425
426 if (TestConfigFile || !ErrorLog)
427 return (1);
428
429 if ((level > LogLevel ||
430 (level == CUPSD_LOG_INFO && LogLevel < CUPSD_LOG_DEBUG)) &&
431 LogDebugHistory <= 0)
432 return (1);
433
434 /*
435 * Format and write the log message...
436 */
437
438 snprintf(jobmsg, sizeof(jobmsg), "[Job %d] %s", job->id, message);
439
440 do
441 {
442 va_start(ap, message);
443 status = format_log_line(jobmsg, ap);
444 va_end(ap);
445 }
446 while (status == 0);
447
448 if (status > 0)
449 {
450 if ((level > LogLevel ||
451 (level == CUPSD_LOG_INFO && LogLevel < CUPSD_LOG_DEBUG)) &&
452 LogDebugHistory > 0)
453 {
454 /*
455 * Add message to the job history...
456 */
457
458 cupsd_joblog_t *temp; /* Copy of log message */
459
460
461 if ((temp = malloc(sizeof(cupsd_joblog_t) + strlen(log_line))) != NULL)
462 {
463 temp->time = time(NULL);
464 strcpy(temp->message, log_line);
465 }
466
467 if (!job->history)
468 job->history = cupsArrayNew(NULL, NULL);
469
470 if (job->history && temp)
471 {
472 cupsArrayAdd(job->history, temp);
473
474 if (cupsArrayCount(job->history) > LogDebugHistory)
475 {
476 /*
477 * Remove excess messages...
478 */
479
480 temp = cupsArrayFirst(job->history);
481 cupsArrayRemove(job->history, temp);
482 free(temp);
483 }
484 }
485 else if (temp)
486 free(temp);
487
488 return (1);
489 }
490 else if (level <= LogLevel &&
491 (level != CUPSD_LOG_INFO || LogLevel >= CUPSD_LOG_DEBUG))
492 return (cupsdWriteErrorLog(level, log_line));
493 else
494 return (1);
495 }
496 else
497 return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
498 "Unable to allocate memory for log line!"));
499 }
500
501
502 /*
503 * 'cupsdLogMessage()' - Log a message to the error log file.
504 */
505
506 int /* O - 1 on success, 0 on error */
507 cupsdLogMessage(int level, /* I - Log level */
508 const char *message, /* I - printf-style message string */
509 ...) /* I - Additional args as needed */
510 {
511 va_list ap; /* Argument pointer */
512 int status; /* Formatting status */
513
514
515 /*
516 * See if we want to log this message...
517 */
518
519 if (TestConfigFile)
520 {
521 if (level <= CUPSD_LOG_WARN)
522 {
523 va_start(ap, message);
524 vfprintf(stderr, message, ap);
525 putc('\n', stderr);
526 va_end(ap);
527 }
528
529 return (1);
530 }
531
532 if (level > LogLevel || !ErrorLog)
533 return (1);
534
535 /*
536 * Format and write the log message...
537 */
538
539 do
540 {
541 va_start(ap, message);
542 status = format_log_line(message, ap);
543 va_end(ap);
544 }
545 while (status == 0);
546
547 if (status > 0)
548 return (cupsdWriteErrorLog(level, log_line));
549 else
550 return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
551 "Unable to allocate memory for log line!"));
552 }
553
554
555 /*
556 * 'cupsdLogPage()' - Log a page to the page log file.
557 */
558
559 int /* O - 1 on success, 0 on error */
560 cupsdLogPage(cupsd_job_t *job, /* I - Job being printed */
561 const char *page) /* I - Page being printed */
562 {
563 int i; /* Looping var */
564 char buffer[2048], /* Buffer for page log */
565 *bufptr, /* Pointer into buffer */
566 name[256]; /* Attribute name */
567 const char *format, /* Pointer into PageLogFormat */
568 *nameend; /* End of attribute name */
569 ipp_attribute_t *attr; /* Current attribute */
570 char number[256]; /* Page number */
571 int copies; /* Number of copies */
572
573
574 /*
575 * Format the line going into the page log...
576 */
577
578 if (!PageLogFormat)
579 return (1);
580
581 strcpy(number, "1");
582 copies = 1;
583 sscanf(page, "%255s%d", number, &copies);
584
585 for (format = PageLogFormat, bufptr = buffer; *format; format ++)
586 {
587 if (*format == '%')
588 {
589 format ++;
590
591 switch (*format)
592 {
593 case '%' : /* Literal % */
594 if (bufptr < (buffer + sizeof(buffer) - 1))
595 *bufptr++ = '%';
596 break;
597
598 case 'p' : /* Printer name */
599 strlcpy(bufptr, job->printer->name,
600 sizeof(buffer) - (bufptr - buffer));
601 bufptr += strlen(bufptr);
602 break;
603
604 case 'j' : /* Job ID */
605 snprintf(bufptr, sizeof(buffer) - (bufptr - buffer), "%d", job->id);
606 bufptr += strlen(bufptr);
607 break;
608
609 case 'u' : /* Username */
610 strlcpy(bufptr, job->username ? job->username : "-",
611 sizeof(buffer) - (bufptr - buffer));
612 bufptr += strlen(bufptr);
613 break;
614
615 case 'T' : /* Date and time */
616 strlcpy(bufptr, cupsdGetDateTime(NULL, LogTimeFormat),
617 sizeof(buffer) - (bufptr - buffer));
618 bufptr += strlen(bufptr);
619 break;
620
621 case 'P' : /* Page number */
622 strlcpy(bufptr, number, sizeof(buffer) - (bufptr - buffer));
623 bufptr += strlen(bufptr);
624 break;
625
626 case 'C' : /* Number of copies */
627 snprintf(bufptr, sizeof(buffer) - (bufptr - buffer), "%d", copies);
628 bufptr += strlen(bufptr);
629 break;
630
631 case '{' : /* {attribute} */
632 if ((nameend = strchr(format, '}')) != NULL &&
633 (nameend - format - 2) < (sizeof(name) - 1))
634 {
635 /*
636 * Pull the name from inside the brackets...
637 */
638
639 memcpy(name, format + 1, nameend - format - 1);
640 name[nameend - format - 1] = '\0';
641
642 format = nameend;
643
644 if ((attr = ippFindAttribute(job->attrs, name,
645 IPP_TAG_ZERO)) != NULL)
646 {
647 /*
648 * Add the attribute value...
649 */
650
651 for (i = 0;
652 i < attr->num_values &&
653 bufptr < (buffer + sizeof(buffer) - 1);
654 i ++)
655 {
656 if (i)
657 *bufptr++ = ',';
658
659 switch (attr->value_tag)
660 {
661 case IPP_TAG_INTEGER :
662 case IPP_TAG_ENUM :
663 snprintf(bufptr, sizeof(buffer) - (bufptr - buffer),
664 "%d", attr->values[i].integer);
665 bufptr += strlen(bufptr);
666 break;
667
668 case IPP_TAG_BOOLEAN :
669 snprintf(bufptr, sizeof(buffer) - (bufptr - buffer),
670 "%d", attr->values[i].boolean);
671 bufptr += strlen(bufptr);
672 break;
673
674 case IPP_TAG_TEXTLANG :
675 case IPP_TAG_NAMELANG :
676 case IPP_TAG_TEXT :
677 case IPP_TAG_NAME :
678 case IPP_TAG_KEYWORD :
679 case IPP_TAG_URI :
680 case IPP_TAG_URISCHEME :
681 case IPP_TAG_CHARSET :
682 case IPP_TAG_LANGUAGE :
683 case IPP_TAG_MIMETYPE :
684 strlcpy(bufptr, attr->values[i].string.text,
685 sizeof(buffer) - (bufptr - buffer));
686 bufptr += strlen(bufptr);
687 break;
688
689 default :
690 strlcpy(bufptr, "???",
691 sizeof(buffer) - (bufptr - buffer));
692 bufptr += strlen(bufptr);
693 break;
694 }
695 }
696 }
697 else if (bufptr < (buffer + sizeof(buffer) - 1))
698 *bufptr++ = '-';
699 break;
700 }
701
702 default :
703 if (bufptr < (buffer + sizeof(buffer) - 2))
704 {
705 *bufptr++ = '%';
706 *bufptr++ = *format;
707 }
708 break;
709 }
710 }
711 else if (bufptr < (buffer + sizeof(buffer) - 1))
712 *bufptr++ = *format;
713 }
714
715 *bufptr = '\0';
716
717 #ifdef HAVE_VSYSLOG
718 /*
719 * See if we are logging pages via syslog...
720 */
721
722 if (!strcmp(PageLog, "syslog"))
723 {
724 syslog(LOG_INFO, "%s", buffer);
725
726 return (1);
727 }
728 #endif /* HAVE_VSYSLOG */
729
730 /*
731 * Not using syslog; check the log file...
732 */
733
734 if (!cupsdCheckLogFile(&PageFile, PageLog))
735 return (0);
736
737 /*
738 * Print a page log entry of the form:
739 *
740 * printer user job-id [DD/MON/YYYY:HH:MM:SS +TTTT] page num-copies \
741 * billing hostname
742 */
743
744 cupsFilePrintf(PageFile, "%s\n", buffer);
745 cupsFileFlush(PageFile);
746
747 return (1);
748 }
749
750
751 /*
752 * 'cupsdLogRequest()' - Log an HTTP request in Common Log Format.
753 */
754
755 int /* O - 1 on success, 0 on error */
756 cupsdLogRequest(cupsd_client_t *con, /* I - Request to log */
757 http_status_t code) /* I - Response code */
758 {
759 char temp[2048]; /* Temporary string for URI */
760 static const char * const states[] = /* HTTP client states... */
761 {
762 "WAITING",
763 "OPTIONS",
764 "GET",
765 "GET",
766 "HEAD",
767 "POST",
768 "POST",
769 "POST",
770 "PUT",
771 "PUT",
772 "DELETE",
773 "TRACE",
774 "CLOSE",
775 "STATUS"
776 };
777
778
779 /*
780 * Filter requests as needed...
781 */
782
783 if (AccessLogLevel < CUPSD_ACCESSLOG_ALL)
784 {
785 /*
786 * Eliminate simple GET, POST, and PUT requests...
787 */
788
789 if ((con->operation == HTTP_GET &&
790 strncmp(con->uri, "/admin/conf", 11) &&
791 strncmp(con->uri, "/admin/log", 10)) ||
792 (con->operation == HTTP_POST && !con->request &&
793 strncmp(con->uri, "/admin", 6)) ||
794 (con->operation != HTTP_GET && con->operation != HTTP_POST &&
795 con->operation != HTTP_PUT))
796 return (1);
797
798 if (con->request && con->response &&
799 (con->response->request.status.status_code < IPP_REDIRECTION_OTHER_SITE ||
800 con->response->request.status.status_code == IPP_NOT_FOUND))
801 {
802 /*
803 * Check successful requests...
804 */
805
806 ipp_op_t op = con->request->request.op.operation_id;
807 static cupsd_accesslog_t standard_ops[] =
808 {
809 CUPSD_ACCESSLOG_ALL, /* reserved */
810 CUPSD_ACCESSLOG_ALL, /* reserved */
811 CUPSD_ACCESSLOG_ACTIONS,/* Print-Job */
812 CUPSD_ACCESSLOG_ACTIONS,/* Print-URI */
813 CUPSD_ACCESSLOG_ACTIONS,/* Validate-Job */
814 CUPSD_ACCESSLOG_ACTIONS,/* Create-Job */
815 CUPSD_ACCESSLOG_ACTIONS,/* Send-Document */
816 CUPSD_ACCESSLOG_ACTIONS,/* Send-URI */
817 CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Job */
818 CUPSD_ACCESSLOG_ALL, /* Get-Job-Attributes */
819 CUPSD_ACCESSLOG_ALL, /* Get-Jobs */
820 CUPSD_ACCESSLOG_ALL, /* Get-Printer-Attributes */
821 CUPSD_ACCESSLOG_ACTIONS,/* Hold-Job */
822 CUPSD_ACCESSLOG_ACTIONS,/* Release-Job */
823 CUPSD_ACCESSLOG_ACTIONS,/* Restart-Job */
824 CUPSD_ACCESSLOG_ALL, /* reserved */
825 CUPSD_ACCESSLOG_CONFIG, /* Pause-Printer */
826 CUPSD_ACCESSLOG_CONFIG, /* Resume-Printer */
827 CUPSD_ACCESSLOG_CONFIG, /* Purge-Jobs */
828 CUPSD_ACCESSLOG_CONFIG, /* Set-Printer-Attributes */
829 CUPSD_ACCESSLOG_ACTIONS,/* Set-Job-Attributes */
830 CUPSD_ACCESSLOG_CONFIG, /* Get-Printer-Supported-Values */
831 CUPSD_ACCESSLOG_ACTIONS,/* Create-Printer-Subscription */
832 CUPSD_ACCESSLOG_ACTIONS,/* Create-Job-Subscription */
833 CUPSD_ACCESSLOG_ALL, /* Get-Subscription-Attributes */
834 CUPSD_ACCESSLOG_ALL, /* Get-Subscriptions */
835 CUPSD_ACCESSLOG_ACTIONS,/* Renew-Subscription */
836 CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Subscription */
837 CUPSD_ACCESSLOG_ALL, /* Get-Notifications */
838 CUPSD_ACCESSLOG_ACTIONS,/* Send-Notifications */
839 CUPSD_ACCESSLOG_ALL, /* reserved */
840 CUPSD_ACCESSLOG_ALL, /* reserved */
841 CUPSD_ACCESSLOG_ALL, /* reserved */
842 CUPSD_ACCESSLOG_ALL, /* Get-Print-Support-Files */
843 CUPSD_ACCESSLOG_CONFIG, /* Enable-Printer */
844 CUPSD_ACCESSLOG_CONFIG, /* Disable-Printer */
845 CUPSD_ACCESSLOG_CONFIG, /* Pause-Printer-After-Current-Job */
846 CUPSD_ACCESSLOG_ACTIONS,/* Hold-New-Jobs */
847 CUPSD_ACCESSLOG_ACTIONS,/* Release-Held-New-Jobs */
848 CUPSD_ACCESSLOG_CONFIG, /* Deactivate-Printer */
849 CUPSD_ACCESSLOG_CONFIG, /* Activate-Printer */
850 CUPSD_ACCESSLOG_CONFIG, /* Restart-Printer */
851 CUPSD_ACCESSLOG_CONFIG, /* Shutdown-Printer */
852 CUPSD_ACCESSLOG_CONFIG, /* Startup-Printer */
853 CUPSD_ACCESSLOG_ACTIONS,/* Reprocess-Job */
854 CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Current-Job */
855 CUPSD_ACCESSLOG_ACTIONS,/* Suspend-Current-Job */
856 CUPSD_ACCESSLOG_ACTIONS,/* Resume-Job */
857 CUPSD_ACCESSLOG_ACTIONS,/* Promote-Job */
858 CUPSD_ACCESSLOG_ACTIONS /* Schedule-Job-After */
859 };
860 static cupsd_accesslog_t cups_ops[] =
861 {
862 CUPSD_ACCESSLOG_ALL, /* CUPS-Get-Default */
863 CUPSD_ACCESSLOG_ALL, /* CUPS-Get-Printers */
864 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Add-Modify-Printer */
865 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Delete-Printer */
866 CUPSD_ACCESSLOG_ALL, /* CUPS-Get-Classes */
867 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Add-Modify-Class */
868 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Delete-Class */
869 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Accept-Jobs */
870 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Reject-Jobs */
871 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Set-Default */
872 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Get-Devices */
873 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Get-PPDs */
874 CUPSD_ACCESSLOG_ACTIONS,/* CUPS-Move-Job */
875 CUPSD_ACCESSLOG_ACTIONS,/* CUPS-Authenticate-Job */
876 CUPSD_ACCESSLOG_ALL /* CUPS-Get-PPD */
877 };
878
879
880 if ((op <= IPP_SCHEDULE_JOB_AFTER && standard_ops[op] > AccessLogLevel) ||
881 (op >= CUPS_GET_DEFAULT && op <= CUPS_GET_PPD &&
882 cups_ops[op - CUPS_GET_DEFAULT] > AccessLogLevel))
883 return (1);
884 }
885 }
886
887 #ifdef HAVE_VSYSLOG
888 /*
889 * See if we are logging accesses via syslog...
890 */
891
892 if (!strcmp(AccessLog, "syslog"))
893 {
894 syslog(LOG_INFO,
895 "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
896 con->http.hostname, con->username[0] != '\0' ? con->username : "-",
897 states[con->operation], _httpEncodeURI(temp, con->uri, sizeof(temp)),
898 con->http.version / 100, con->http.version % 100,
899 code, CUPS_LLCAST con->bytes,
900 con->request ?
901 ippOpString(con->request->request.op.operation_id) : "-",
902 con->response ?
903 ippErrorString(con->response->request.status.status_code) : "-");
904
905 return (1);
906 }
907 #endif /* HAVE_VSYSLOG */
908
909 /*
910 * Not using syslog; check the log file...
911 */
912
913 if (!cupsdCheckLogFile(&AccessFile, AccessLog))
914 return (0);
915
916 /*
917 * Write a log of the request in "common log format"...
918 */
919
920 cupsFilePrintf(AccessFile,
921 "%s - %s %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
922 con->http.hostname,
923 con->username[0] != '\0' ? con->username : "-",
924 cupsdGetDateTime(&(con->start), LogTimeFormat),
925 states[con->operation],
926 _httpEncodeURI(temp, con->uri, sizeof(temp)),
927 con->http.version / 100, con->http.version % 100,
928 code, CUPS_LLCAST con->bytes,
929 con->request ?
930 ippOpString(con->request->request.op.operation_id) : "-",
931 con->response ?
932 ippErrorString(con->response->request.status.status_code) :
933 "-");
934
935 cupsFileFlush(AccessFile);
936
937 return (1);
938 }
939
940
941 /*
942 * 'cupsdWriteErrorLog()' - Write a line to the ErrorLog.
943 */
944
945 int /* O - 1 on success, 0 on failure */
946 cupsdWriteErrorLog(int level, /* I - Log level */
947 const char *message) /* I - Message string */
948 {
949 static const char levels[] = /* Log levels... */
950 {
951 ' ',
952 'X',
953 'A',
954 'C',
955 'E',
956 'W',
957 'N',
958 'I',
959 'D',
960 'd'
961 };
962 #ifdef HAVE_VSYSLOG
963 static const int syslevels[] = /* SYSLOG levels... */
964 {
965 0,
966 LOG_EMERG,
967 LOG_ALERT,
968 LOG_CRIT,
969 LOG_ERR,
970 LOG_WARNING,
971 LOG_NOTICE,
972 LOG_INFO,
973 LOG_DEBUG,
974 LOG_DEBUG
975 };
976 #endif /* HAVE_VSYSLOG */
977
978
979 #ifdef HAVE_VSYSLOG
980 /*
981 * See if we are logging errors via syslog...
982 */
983
984 if (!strcmp(ErrorLog, "syslog"))
985 {
986 syslog(syslevels[level], "%s", message);
987 return (1);
988 }
989 #endif /* HAVE_VSYSLOG */
990
991 /*
992 * Not using syslog; check the log file...
993 */
994
995 if (!cupsdCheckLogFile(&ErrorFile, ErrorLog))
996 return (0);
997
998 /*
999 * Write the log message...
1000 */
1001
1002 cupsFilePrintf(ErrorFile, "%c %s %s\n", levels[level],
1003 cupsdGetDateTime(NULL, LogTimeFormat), message);
1004 cupsFileFlush(ErrorFile);
1005
1006 return (1);
1007 }
1008
1009
1010 /*
1011 * 'format_log_line()' - Format a line for a log file.
1012 *
1013 * This function resizes a global string buffer as needed. Each call returns
1014 * a pointer to this buffer, so the contents are only good until the next call
1015 * to format_log_line()...
1016 */
1017
1018 static int /* O - -1 for fatal, 0 for retry, 1 for success */
1019 format_log_line(const char *message, /* I - Printf-style format string */
1020 va_list ap) /* I - Argument list */
1021 {
1022 int len; /* Length of formatted line */
1023
1024
1025 /*
1026 * Allocate the line buffer as needed...
1027 */
1028
1029 if (!log_linesize)
1030 {
1031 log_linesize = 8192;
1032 log_line = malloc(log_linesize);
1033
1034 if (!log_line)
1035 return (-1);
1036 }
1037
1038 /*
1039 * Format the log message...
1040 */
1041
1042 len = vsnprintf(log_line, log_linesize, message, ap);
1043
1044 /*
1045 * Resize the buffer as needed...
1046 */
1047
1048 if (len >= log_linesize && log_linesize < 65536)
1049 {
1050 char *temp; /* Temporary string pointer */
1051
1052
1053 len ++;
1054
1055 if (len < 8192)
1056 len = 8192;
1057 else if (len > 65536)
1058 len = 65536;
1059
1060 temp = realloc(log_line, len);
1061
1062 if (temp)
1063 {
1064 log_line = temp;
1065 log_linesize = len;
1066
1067 return (0);
1068 }
1069 }
1070
1071 return (1);
1072 }
1073
1074
1075 /*
1076 * End of "$Id: log.c 7918 2008-09-08 22:03:01Z mike $".
1077 */
Unnamed repository; edit this file 'description' to name the repository.