]> git.ipfire.org Git - thirdparty/cups.git/blame - scheduler/log.c
The debug strings table for mime type operations was out of sync with the
[thirdparty/cups.git] / scheduler / log.c
CommitLineData
ef416fc2 1/*
f2d18633 2 * "$Id$"
ef416fc2 3 *
996acce8 4 * Log file routines for the CUPS scheduler.
ef416fc2 5 *
0dc4a6bf 6 * Copyright 2007-2015 by Apple Inc.
996acce8 7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
ef416fc2 8 *
996acce8
MS
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/".
ef416fc2 14 */
15
16/*
17 * Include necessary headers...
18 */
19
20#include "cupsd.h"
21#include <stdarg.h>
0dc4a6bf
MS
22#ifdef HAVE_ASL_H
23# include <asl.h>
24#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
25# define SD_JOURNAL_SUPPRESS_LOCATION
26# include <systemd/sd-journal.h>
27#endif /* HAVE_ASL_H */
b423cd4c 28#include <syslog.h>
ef416fc2 29
30
0dc4a6bf
MS
31/*
32 * Constants for log keys from PWG 5110.3 (PWG Common Log Format)...
33 */
34
35#define PWG_DeviceUUID "DUU"
36#define PWG_Event "E"
37#define PWG_LogNaturalLanguage "NL"
38#define PWG_Status "S"
39#define PWG_ServiceURI "URI"
40#define PWG_UserHost "UH"
41#define PWG_UserName "UN"
42#define PWG_UserURI "UU"
43#define PWG_ServiceIsAcceptingJobs "IAJ"
44#define PWG_ServiceState "ST"
45#define PWG_ServiceStateReasons "SR"
46#define PWG_ServiceUUID "SUU"
47#define PWG_JobID "JID"
48#define PWG_JobUUID "JUU"
49#define PWG_JobImagesCompleted "JIM"
50#define PWG_JobImpressionsCompleted "JIC"
51#define PWG_JobDestinationURI "JD"
52#define PWG_JobState "JS"
53#define PWG_JobStateReasons "JR"
54#define PWG_JobAccountingID "JA"
55#define PWG_JobAcountingUserName "JAUN"
56#define PWG_JobAccountingUserURI "JAUU"
57
58
75bd9771
MS
59/*
60 * Local globals...
61 */
62
28a463e0
MS
63static _cups_mutex_t log_mutex = _CUPS_MUTEX_INITIALIZER;
64 /* Mutex for logging */
7e86f2f6 65static size_t log_linesize = 0; /* Size of line for output file */
75bd9771
MS
66static char *log_line = NULL; /* Line for output file */
67
0dc4a6bf
MS
68#ifdef HAVE_ASL_H
69static const int log_levels[] = /* ASL levels... */
70 {
71 ASL_LEVEL_EMERG,
72 ASL_LEVEL_EMERG,
73 ASL_LEVEL_ALERT,
74 ASL_LEVEL_CRIT,
75 ASL_LEVEL_ERR,
76 ASL_LEVEL_WARNING,
77 ASL_LEVEL_NOTICE,
78 ASL_LEVEL_INFO,
79 ASL_LEVEL_DEBUG,
80 ASL_LEVEL_DEBUG
81 };
82#elif defined(HAVE_VSYSLOG) || defined(HAVE_SYSTEMD_SD_JOURNAL_H)
83static const int log_levels[] = /* SYSLOG levels... */
cb7f98ee
MS
84 {
85 0,
86 LOG_EMERG,
87 LOG_ALERT,
88 LOG_CRIT,
89 LOG_ERR,
90 LOG_WARNING,
91 LOG_NOTICE,
92 LOG_INFO,
93 LOG_DEBUG,
94 LOG_DEBUG
95 };
0dc4a6bf 96#endif /* HAVE_ASL_H */
cb7f98ee 97
75bd9771 98
ef416fc2 99/*
100 * Local functions...
101 */
102
005dd1eb 103static int format_log_line(const char *message, va_list ap);
ef416fc2 104
105
22c9029b
MS
106/*
107 * 'cupsdCheckLogFile()' - Open/rotate a log file if it needs it.
108 */
109
110int /* O - 1 if log file open */
111cupsdCheckLogFile(cups_file_t **lf, /* IO - Log file */
112 const char *logname) /* I - Log filename */
113{
114 char backname[1024], /* Backup log filename */
115 filename[1024], /* Formatted log filename */
116 *ptr; /* Pointer into filename */
117 const char *logptr; /* Pointer into log filename */
118
119
120 /*
121 * See if we have a log file to check...
122 */
123
124 if (!lf || !logname || !logname[0])
125 return (1);
126
a1797929
MS
127 /*
128 * Handle logging to stderr...
129 */
130
131 if (!strcmp(logname, "stderr"))
132 {
133 *lf = LogStderr;
134 return (1);
135 }
136
22c9029b
MS
137 /*
138 * Format the filename as needed...
139 */
140
141 if (!*lf ||
142 (strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
143 MaxLogSize > 0))
144 {
145 /*
146 * Handle format strings...
147 */
148
149 filename[sizeof(filename) - 1] = '\0';
150
151 if (logname[0] != '/')
152 {
153 strlcpy(filename, ServerRoot, sizeof(filename));
154 strlcat(filename, "/", sizeof(filename));
155 }
156 else
157 filename[0] = '\0';
158
159 for (logptr = logname, ptr = filename + strlen(filename);
160 *logptr && ptr < (filename + sizeof(filename) - 1);
161 logptr ++)
162 if (*logptr == '%')
163 {
164 /*
165 * Format spec...
166 */
167
168 logptr ++;
169 if (*logptr == 's')
170 {
171 /*
172 * Insert the server name...
173 */
174
7e86f2f6 175 strlcpy(ptr, ServerName, sizeof(filename) - (size_t)(ptr - filename));
22c9029b
MS
176 ptr += strlen(ptr);
177 }
178 else
179 {
180 /*
181 * Otherwise just insert the character...
182 */
183
184 *ptr++ = *logptr;
185 }
186 }
187 else
188 *ptr++ = *logptr;
189
190 *ptr = '\0';
191 }
192
193 /*
194 * See if the log file is open...
195 */
196
197 if (!*lf)
198 {
199 /*
200 * Nope, open the log file...
201 */
202
203 if ((*lf = cupsFileOpen(filename, "a")) == NULL)
204 {
205 /*
206 * If the file is in CUPS_LOGDIR then try to create a missing directory...
207 */
208
209 if (!strncmp(filename, CUPS_LOGDIR, strlen(CUPS_LOGDIR)))
210 {
211 /*
212 * Try updating the permissions of the containing log directory, using
213 * the log file permissions as a basis...
214 */
215
7e86f2f6 216 mode_t log_dir_perm = (mode_t)(0300 | LogFilePerm);
22c9029b
MS
217 /* LogFilePerm + owner write/search */
218 if (log_dir_perm & 0040)
219 log_dir_perm |= 0010; /* Add group search */
220 if (log_dir_perm & 0004)
221 log_dir_perm |= 0001; /* Add other search */
222
7e86f2f6 223 cupsdCheckPermissions(CUPS_LOGDIR, NULL, log_dir_perm, RunUser, Group, 1, -1);
22c9029b
MS
224
225 *lf = cupsFileOpen(filename, "a");
226 }
227
228 if (*lf == NULL)
229 {
0dc4a6bf
MS
230#ifdef HAVE_ASL_H
231 asl_object_t m; /* Log message */
232
233 m = asl_new(ASL_TYPE_MSG);
234 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
235 asl_log(NULL, m, ASL_LEVEL_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
236 asl_release(m);
237
238#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
239 sd_journal_print(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
240
241#else
242 syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
243#endif /* HAVE_ASL_H */
22c9029b
MS
244
245 if (FatalErrors & CUPSD_FATAL_LOG)
246 cupsdEndProcess(getpid(), 0);
247
248 return (0);
249 }
250 }
251
252 if (strncmp(filename, "/dev/", 5))
253 {
254 /*
255 * Change ownership and permissions of non-device logs...
256 */
257
258 fchown(cupsFileNumber(*lf), RunUser, Group);
259 fchmod(cupsFileNumber(*lf), LogFilePerm);
260 }
261 }
262
263 /*
264 * Do we need to rotate the log?
265 */
266
267 if (strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
268 MaxLogSize > 0)
269 {
270 /*
271 * Rotate log file...
272 */
273
274 cupsFileClose(*lf);
275
5a9febac 276 strlcpy(backname, filename, sizeof(backname));
22c9029b
MS
277 strlcat(backname, ".O", sizeof(backname));
278
279 unlink(backname);
280 rename(filename, backname);
281
282 if ((*lf = cupsFileOpen(filename, "a")) == NULL)
283 {
0dc4a6bf
MS
284#ifdef HAVE_ASL_H
285 asl_object_t m; /* Log message */
286
287 m = asl_new(ASL_TYPE_MSG);
288 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
289 asl_log(NULL, m, ASL_LEVEL_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
290 asl_release(m);
291
292#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
293 sd_journal_print(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
294
295#else
296 syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
297#endif /* HAVE_ASL_H */
22c9029b
MS
298
299 if (FatalErrors & CUPSD_FATAL_LOG)
300 cupsdEndProcess(getpid(), 0);
301
302 return (0);
303 }
304
305 /*
306 * Change ownership and permissions of non-device logs...
307 */
308
309 fchown(cupsFileNumber(*lf), RunUser, Group);
310 fchmod(cupsFileNumber(*lf), LogFilePerm);
311 }
312
313 return (1);
314}
315
316
ef416fc2 317/*
318 * 'cupsdGetDateTime()' - Returns a pointer to a date/time string.
319 */
320
321char * /* O - Date/time string */
dfd5680b
MS
322cupsdGetDateTime(struct timeval *t, /* I - Time value or NULL for current */
323 cupsd_time_t format) /* I - Format to use */
ef416fc2 324{
dfd5680b
MS
325 struct timeval curtime; /* Current time value */
326 struct tm *date; /* Date/time value */
327 static struct timeval last_time = { 0, 0 };
328 /* Last time we formatted */
329 static char s[1024]; /* Date/time string */
ef416fc2 330 static const char * const months[12] =/* Months */
331 {
332 "Jan",
333 "Feb",
334 "Mar",
335 "Apr",
336 "May",
337 "Jun",
338 "Jul",
339 "Aug",
340 "Sep",
341 "Oct",
342 "Nov",
343 "Dec"
344 };
345
346
839a51c8
MS
347 /*
348 * Make sure we have a valid time...
349 */
350
351 if (!t)
dfd5680b
MS
352 {
353 gettimeofday(&curtime, NULL);
354 t = &curtime;
355 }
839a51c8 356
dfd5680b
MS
357 if (t->tv_sec != last_time.tv_sec ||
358 (LogTimeFormat == CUPSD_TIME_USECS && t->tv_usec != last_time.tv_usec))
ef416fc2 359 {
dfd5680b 360 last_time = *t;
ef416fc2 361
362 /*
363 * Get the date and time from the UNIX time value, and then format it
364 * into a string. Note that we *can't* use the strftime() function since
365 * it is localized and will seriously confuse automatic programs if the
366 * month names are in the wrong language!
367 *
368 * Also, we use the "timezone" variable that contains the current timezone
369 * offset from GMT in seconds so that we are reporting local time in the
370 * log files. If you want GMT, set the TZ environment variable accordingly
371 * before starting the scheduler.
372 *
373 * (*BSD and Darwin store the timezone offset in the tm structure)
374 */
375
dfd5680b 376 date = localtime(&(t->tv_sec));
ef416fc2 377
dfd5680b
MS
378 if (format == CUPSD_TIME_STANDARD)
379 snprintf(s, sizeof(s), "[%02d/%s/%04d:%02d:%02d:%02d %+03ld%02ld]",
380 date->tm_mday, months[date->tm_mon], 1900 + date->tm_year,
381 date->tm_hour, date->tm_min, date->tm_sec,
382#ifdef HAVE_TM_GMTOFF
383 date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
384#else
385 timezone / 3600, (timezone / 60) % 60);
386#endif /* HAVE_TM_GMTOFF */
387 else
388 snprintf(s, sizeof(s), "[%02d/%s/%04d:%02d:%02d:%02d.%06d %+03ld%02ld]",
389 date->tm_mday, months[date->tm_mon], 1900 + date->tm_year,
bf3816c7 390 date->tm_hour, date->tm_min, date->tm_sec, (int)t->tv_usec,
ef416fc2 391#ifdef HAVE_TM_GMTOFF
dfd5680b 392 date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
ef416fc2 393#else
dfd5680b 394 timezone / 3600, (timezone / 60) % 60);
ef416fc2 395#endif /* HAVE_TM_GMTOFF */
396 }
397
398 return (s);
399}
400
401
22c9029b
MS
402/*
403 * 'cupsdLogFCMessage()' - Log a file checking message.
404 */
405
406void
407cupsdLogFCMessage(
408 void *context, /* I - Printer (if any) */
409 _cups_fc_result_t result, /* I - Check result */
410 const char *message) /* I - Message to log */
411{
412 cupsd_printer_t *p = (cupsd_printer_t *)context;
413 /* Printer */
414 cupsd_loglevel_t level; /* Log level */
415
416
417 if (result == _CUPS_FILE_CHECK_OK)
418 level = CUPSD_LOG_DEBUG2;
419 else
420 level = CUPSD_LOG_ERROR;
421
422 if (p)
423 {
424 cupsdLogMessage(level, "%s: %s", p->name, message);
425
426 if (result == _CUPS_FILE_CHECK_MISSING ||
427 result == _CUPS_FILE_CHECK_WRONG_TYPE)
428 {
429 strlcpy(p->state_message, message, sizeof(p->state_message));
430
431 if (cupsdSetPrinterReasons(p, "+cups-missing-filter-warning"))
432 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, p, NULL, "%s", message);
433 }
88f9aafc
MS
434 else if (result == _CUPS_FILE_CHECK_PERMISSIONS ||
435 result == _CUPS_FILE_CHECK_RELATIVE_PATH)
22c9029b
MS
436 {
437 strlcpy(p->state_message, message, sizeof(p->state_message));
438
439 if (cupsdSetPrinterReasons(p, "+cups-insecure-filter-warning"))
440 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, p, NULL, "%s", message);
441 }
442 }
443 else
444 cupsdLogMessage(level, "%s", message);
445}
446
447
f7deaa1a 448#ifdef HAVE_GSSAPI
449/*
450 * 'cupsdLogGSSMessage()' - Log a GSSAPI error...
451 */
452
453int /* O - 1 on success, 0 on error */
454cupsdLogGSSMessage(
455 int level, /* I - Log level */
7e86f2f6
MS
456 OM_uint32 major_status, /* I - Major GSSAPI status */
457 OM_uint32 minor_status, /* I - Minor GSSAPI status */
f7deaa1a 458 const char *message, /* I - printf-style message string */
459 ...) /* I - Additional args as needed */
460{
461 OM_uint32 err_major_status, /* Major status code for display */
462 err_minor_status; /* Minor status code for display */
463 OM_uint32 msg_ctx; /* Message context */
464 gss_buffer_desc major_status_string = GSS_C_EMPTY_BUFFER,
465 /* Major status message */
466 minor_status_string = GSS_C_EMPTY_BUFFER;
467 /* Minor status message */
468 int ret; /* Return value */
dcb445bc 469 char buffer[8192]; /* Buffer for vsnprintf */
f7deaa1a 470
471
dcb445bc
MS
472 if (strchr(message, '%'))
473 {
474 /*
475 * Format the message string...
476 */
477
478 va_list ap; /* Pointer to arguments */
479
480 va_start(ap, message);
481 vsnprintf(buffer, sizeof(buffer), message, ap);
482 va_end(ap);
483
484 message = buffer;
485 }
486
f7deaa1a 487 msg_ctx = 0;
488 err_major_status = gss_display_status(&err_minor_status,
489 major_status,
490 GSS_C_GSS_CODE,
491 GSS_C_NO_OID,
492 &msg_ctx,
493 &major_status_string);
494
495 if (!GSS_ERROR(err_major_status))
1f0275e3
MS
496 gss_display_status(&err_minor_status, minor_status, GSS_C_MECH_CODE,
497 GSS_C_NULL_OID, &msg_ctx, &minor_status_string);
f7deaa1a 498
499 ret = cupsdLogMessage(level, "%s: %s, %s", message,
500 (char *)major_status_string.value,
501 (char *)minor_status_string.value);
502 gss_release_buffer(&err_minor_status, &major_status_string);
503 gss_release_buffer(&err_minor_status, &minor_status_string);
504
505 return (ret);
506}
507#endif /* HAVE_GSSAPI */
508
509
996acce8
MS
510/*
511 * 'cupsdLogClient()' - Log a client message.
512 */
513
514int /* O - 1 on success, 0 on error */
515cupsdLogClient(cupsd_client_t *con, /* I - Client connection */
516 int level, /* I - Log level */
517 const char *message, /* I - Printf-style message string */
518 ...) /* I - Additional arguments as needed */
519{
520 va_list ap, ap2; /* Argument pointers */
521 char clientmsg[1024];/* Format string for client message */
522 int status; /* Formatting status */
523
524
525 /*
526 * See if we want to log this message...
527 */
528
529 if (TestConfigFile || !ErrorLog)
530 return (1);
531
532 if (level > LogLevel)
533 return (1);
534
535 /*
536 * Format and write the log message...
537 */
538
539 if (con)
540 snprintf(clientmsg, sizeof(clientmsg), "[Client %d] %s", con->number,
541 message);
542 else
543 strlcpy(clientmsg, message, sizeof(clientmsg));
544
545 va_start(ap, message);
546
547 do
548 {
549 va_copy(ap2, ap);
550 status = format_log_line(clientmsg, ap2);
551 va_end(ap2);
552 }
553 while (status == 0);
554
555 va_end(ap);
556
557 if (status > 0)
558 return (cupsdWriteErrorLog(level, log_line));
559 else
560 return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
561 "Unable to allocate memory for log line."));
562}
563
564
ef416fc2 565/*
75bd9771 566 * 'cupsdLogJob()' - Log a job message.
ef416fc2 567 */
568
569int /* O - 1 on success, 0 on error */
75bd9771
MS
570cupsdLogJob(cupsd_job_t *job, /* I - Job */
571 int level, /* I - Log level */
572 const char *message, /* I - Printf-style message string */
573 ...) /* I - Additional arguments as needed */
ef416fc2 574{
dcb445bc 575 va_list ap, ap2; /* Argument pointers */
005dd1eb
MS
576 char jobmsg[1024]; /* Format string for job message */
577 int status; /* Formatting status */
ef416fc2 578
579
580 /*
581 * See if we want to log this message...
582 */
583
94da7e34
MS
584 if (TestConfigFile || !ErrorLog)
585 return (1);
586
178cb736
MS
587 if ((level > LogLevel ||
588 (level == CUPSD_LOG_INFO && LogLevel < CUPSD_LOG_DEBUG)) &&
589 LogDebugHistory <= 0)
2e4ff8af 590 return (1);
2e4ff8af 591
0dc4a6bf
MS
592#ifdef HAVE_ASL_H
593 if (!strcmp(ErrorLog, "syslog"))
594 {
595 asl_object_t m; /* Log message */
596 char job_id[32], /* job-id string */
597 completed[32]; /* job-impressions-completed string */
7c91f59a 598 cupsd_printer_t *printer = job ? (job->printer ? job->printer : (job->dest ? cupsdFindDest(job->dest) : NULL)) : NULL;
0dc4a6bf
MS
599 static const char * const job_states[] =
600 { /* job-state strings */
601 "Pending",
602 "PendingHeld",
603 "Processing",
604 "ProcessingStopped",
605 "Canceled",
606 "Aborted",
607 "Completed"
608 };
609
0dc4a6bf
MS
610 m = asl_new(ASL_TYPE_MSG);
611 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
7c91f59a
MS
612 if (printer)
613 asl_set(m, PWG_ServiceURI, printer->uri);
614 if (job)
0dc4a6bf 615 {
7c91f59a
MS
616 snprintf(job_id, sizeof(job_id), "%d", job->id);
617
618 asl_set(m, PWG_Event, "JobStateChanged");
619 asl_set(m, PWG_JobID, job_id);
69223177 620 asl_set(m, PWG_JobState, job->state_value < IPP_JSTATE_PENDING ? "" : job_states[job->state_value - IPP_JSTATE_PENDING]);
7c91f59a
MS
621
622 if (job->impressions)
623 {
624 snprintf(completed, sizeof(completed), "%d", ippGetInteger(job->impressions, 0));
625 asl_set(m, PWG_JobImpressionsCompleted, completed);
626 }
0dc4a6bf
MS
627 }
628
629 va_start(ap, message);
630 asl_vlog(NULL, m, log_levels[level], message, ap);
631 va_end(ap);
632
633 asl_release(m);
634 return (1);
635 }
636
637#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
638 if (!strcmp(ErrorLog, "syslog"))
639 {
f495e905 640 cupsd_printer_t *printer = job ? (job->printer ? job->printer : (job->dest ? cupsdFindDest(job->dest) : NULL)) : NULL;
0dc4a6bf
MS
641 static const char * const job_states[] =
642 { /* job-state strings */
643 "Pending",
644 "PendingHeld",
645 "Processing",
646 "ProcessingStopped",
647 "Canceled",
648 "Aborted",
649 "Completed"
650 };
651
652 va_start(ap, message);
653
654 do
655 {
656 va_copy(ap2, ap);
657 status = format_log_line(message, ap2);
658 va_end(ap2);
659 }
660 while (status == 0);
661
662 va_end(ap);
663
7c91f59a
MS
664 if (job)
665 sd_journal_send("MESSAGE=%s", log_line,
666 "PRIORITY=%i", log_levels[level],
667 PWG_Event"=JobStateChanged",
668 PWG_ServiceURI"=%s", printer ? printer->uri : "",
669 PWG_JobID"=%d", job->id,
69223177 670 PWG_JobState"=%s", job->state_value < IPP_JSTATE_PENDING ? "" : job_states[job->state_value - IPP_JSTATE_PENDING],
7c91f59a
MS
671 PWG_JobImpressionsCompleted"=%d", ippGetInteger(job->impressions, 0),
672 NULL);
673 else
674 sd_journal_send("MESSAGE=%s", log_line,
675 "PRIORITY=%i", log_levels[level],
676 NULL);
677
0dc4a6bf
MS
678 return (1);
679 }
0dc4a6bf
MS
680#endif /* HAVE_ASL_H */
681
ef416fc2 682 /*
75bd9771 683 * Format and write the log message...
ef416fc2 684 */
685
dcb445bc
MS
686 if (job)
687 snprintf(jobmsg, sizeof(jobmsg), "[Job %d] %s", job->id, message);
688 else
689 strlcpy(jobmsg, message, sizeof(jobmsg));
690
691 va_start(ap, message);
ef416fc2 692
005dd1eb
MS
693 do
694 {
dcb445bc
MS
695 va_copy(ap2, ap);
696 status = format_log_line(jobmsg, ap2);
697 va_end(ap2);
005dd1eb
MS
698 }
699 while (status == 0);
771bd8cb 700
dcb445bc
MS
701 va_end(ap);
702
005dd1eb 703 if (status > 0)
178cb736 704 {
dcb445bc
MS
705 if (job &&
706 (level > LogLevel ||
178cb736
MS
707 (level == CUPSD_LOG_INFO && LogLevel < CUPSD_LOG_DEBUG)) &&
708 LogDebugHistory > 0)
709 {
710 /*
711 * Add message to the job history...
712 */
713
714 cupsd_joblog_t *temp; /* Copy of log message */
ff2b08f9
MS
715 size_t log_len = strlen(log_line);
716 /* Length of log message */
178cb736 717
ff2b08f9 718 if ((temp = malloc(sizeof(cupsd_joblog_t) + log_len)) != NULL)
178cb736
MS
719 {
720 temp->time = time(NULL);
ff2b08f9 721 memcpy(temp->message, log_line, log_len + 1);
178cb736
MS
722 }
723
724 if (!job->history)
725 job->history = cupsArrayNew(NULL, NULL);
726
727 if (job->history && temp)
728 {
729 cupsArrayAdd(job->history, temp);
730
731 if (cupsArrayCount(job->history) > LogDebugHistory)
732 {
733 /*
734 * Remove excess messages...
735 */
736
737 temp = cupsArrayFirst(job->history);
738 cupsArrayRemove(job->history, temp);
739 free(temp);
740 }
741 }
742 else if (temp)
743 free(temp);
744
745 return (1);
746 }
747 else if (level <= LogLevel &&
748 (level != CUPSD_LOG_INFO || LogLevel >= CUPSD_LOG_DEBUG))
749 return (cupsdWriteErrorLog(level, log_line));
750 else
751 return (1);
752 }
75bd9771
MS
753 else
754 return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
996acce8 755 "Unable to allocate memory for log line."));
75bd9771 756}
ef416fc2 757
ef416fc2 758
75bd9771
MS
759/*
760 * 'cupsdLogMessage()' - Log a message to the error log file.
761 */
ef416fc2 762
75bd9771
MS
763int /* O - 1 on success, 0 on error */
764cupsdLogMessage(int level, /* I - Log level */
765 const char *message, /* I - printf-style message string */
766 ...) /* I - Additional args as needed */
767{
dcb445bc 768 va_list ap, ap2; /* Argument pointers */
005dd1eb 769 int status; /* Formatting status */
ef416fc2 770
ef416fc2 771
772 /*
75bd9771 773 * See if we want to log this message...
ef416fc2 774 */
775
85dda01c 776 if ((TestConfigFile || !ErrorLog) && level <= CUPSD_LOG_WARN)
ef416fc2 777 {
a4845881 778 va_start(ap, message);
0dc4a6bf
MS
779
780#ifdef HAVE_ASL_H
781 asl_object_t m; /* Log message */
782
783 m = asl_new(ASL_TYPE_MSG);
784 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
785 asl_vlog(NULL, m, log_levels[level], message, ap);
786 asl_release(m);
787
788#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
789 sd_journal_printv(log_levels[level], message, ap);
790
791#elif defined(HAVE_VSYSLOG)
792 vsyslog(LOG_LPR | log_levels[level], message, ap);
793
cb7f98ee 794#else
a4845881
MS
795 vfprintf(stderr, message, ap);
796 putc('\n', stderr);
cb7f98ee 797#endif /* HAVE_VSYSLOG */
0dc4a6bf 798
a4845881 799 va_end(ap);
ef416fc2 800
75bd9771 801 return (1);
ef416fc2 802 }
803
75bd9771
MS
804 if (level > LogLevel || !ErrorLog)
805 return (1);
ef416fc2 806
0dc4a6bf
MS
807#ifdef HAVE_ASL_H
808 if (!strcmp(ErrorLog, "syslog"))
809 {
810 asl_object_t m; /* Log message */
811
812 m = asl_new(ASL_TYPE_MSG);
813 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
814
815 va_start(ap, message);
816 asl_vlog(NULL, m, log_levels[level], message, ap);
817 va_end(ap);
818
819 asl_release(m);
820 return (1);
821 }
822
823#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
a990ad13
MS
824 if (!strcmp(ErrorLog, "syslog"))
825 {
67fe5048 826 va_start(ap, message);
a990ad13 827 sd_journal_printv(log_levels[level], message, ap);
67fe5048 828 va_end(ap);
a990ad13
MS
829 return (1);
830 }
0dc4a6bf
MS
831#endif /* HAVE_ASL_H */
832
ef416fc2 833 /*
75bd9771 834 * Format and write the log message...
ef416fc2 835 */
836
dcb445bc
MS
837 va_start(ap, message);
838
005dd1eb
MS
839 do
840 {
dcb445bc
MS
841 va_copy(ap2, ap);
842 status = format_log_line(message, ap2);
843 va_end(ap2);
005dd1eb
MS
844 }
845 while (status == 0);
ef416fc2 846
dcb445bc
MS
847 va_end(ap);
848
005dd1eb
MS
849 if (status > 0)
850 return (cupsdWriteErrorLog(level, log_line));
75bd9771
MS
851 else
852 return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
853 "Unable to allocate memory for log line!"));
ef416fc2 854}
855
856
857/*
858 * 'cupsdLogPage()' - Log a page to the page log file.
859 */
860
861int /* O - 1 on success, 0 on error */
862cupsdLogPage(cupsd_job_t *job, /* I - Job being printed */
863 const char *page) /* I - Page being printed */
864{
01ce6322
MS
865 int i; /* Looping var */
866 char buffer[2048], /* Buffer for page log */
867 *bufptr, /* Pointer into buffer */
868 name[256]; /* Attribute name */
869 const char *format, /* Pointer into PageLogFormat */
870 *nameend; /* End of attribute name */
871 ipp_attribute_t *attr; /* Current attribute */
771bd8cb
MS
872 char number[256]; /* Page number */
873 int copies; /* Number of copies */
ef416fc2 874
875
01ce6322
MS
876 /*
877 * Format the line going into the page log...
878 */
879
880 if (!PageLogFormat)
881 return (1);
882
5a9febac 883 strlcpy(number, "1", sizeof(number));
771bd8cb
MS
884 copies = 1;
885 sscanf(page, "%255s%d", number, &copies);
01ce6322
MS
886
887 for (format = PageLogFormat, bufptr = buffer; *format; format ++)
888 {
889 if (*format == '%')
890 {
891 format ++;
892
893 switch (*format)
894 {
895 case '%' : /* Literal % */
896 if (bufptr < (buffer + sizeof(buffer) - 1))
897 *bufptr++ = '%';
898 break;
899
900 case 'p' : /* Printer name */
5252fc7a 901 strlcpy(bufptr, job->dest, sizeof(buffer) - (size_t)(bufptr - buffer));
01ce6322
MS
902 bufptr += strlen(bufptr);
903 break;
904
905 case 'j' : /* Job ID */
7e86f2f6 906 snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", job->id);
01ce6322
MS
907 bufptr += strlen(bufptr);
908 break;
909
910 case 'u' : /* Username */
7e86f2f6 911 strlcpy(bufptr, job->username ? job->username : "-", sizeof(buffer) - (size_t)(bufptr - buffer));
01ce6322
MS
912 bufptr += strlen(bufptr);
913 break;
914
915 case 'T' : /* Date and time */
7e86f2f6 916 strlcpy(bufptr, cupsdGetDateTime(NULL, LogTimeFormat), sizeof(buffer) - (size_t)(bufptr - buffer));
01ce6322
MS
917 bufptr += strlen(bufptr);
918 break;
919
920 case 'P' : /* Page number */
7e86f2f6 921 strlcpy(bufptr, number, sizeof(buffer) - (size_t)(bufptr - buffer));
01ce6322
MS
922 bufptr += strlen(bufptr);
923 break;
924
925 case 'C' : /* Number of copies */
7e86f2f6 926 snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", copies);
01ce6322
MS
927 bufptr += strlen(bufptr);
928 break;
929
930 case '{' : /* {attribute} */
7e86f2f6 931 if ((nameend = strchr(format, '}')) != NULL && (size_t)(nameend - format - 2) < (sizeof(name) - 1))
01ce6322
MS
932 {
933 /*
934 * Pull the name from inside the brackets...
935 */
936
07623986 937 memcpy(name, format + 1, (size_t)(nameend - format - 1));
75bd9771
MS
938 name[nameend - format - 1] = '\0';
939
940 format = nameend;
01ce6322 941
bf1bc4c6
MS
942 attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO);
943 if (!attr && !strcmp(name, "job-billing"))
944 {
945 /*
946 * Handle alias "job-account-id" (which was standardized after
947 * "job-billing" was defined for CUPS...
948 */
949
950 attr = ippFindAttribute(job->attrs, "job-account-id", IPP_TAG_ZERO);
951 }
952 else if (!attr && !strcmp(name, "media"))
953 {
954 /*
955 * Handle alias "media-col" which uses dimensions instead of
956 * names...
957 */
958
959 attr = ippFindAttribute(job->attrs, "media-col/media-size", IPP_TAG_BEGIN_COLLECTION);
960 }
961
962 if (attr)
01ce6322
MS
963 {
964 /*
965 * Add the attribute value...
966 */
967
01ce6322
MS
968 for (i = 0;
969 i < attr->num_values &&
970 bufptr < (buffer + sizeof(buffer) - 1);
971 i ++)
972 {
973 if (i)
974 *bufptr++ = ',';
975
976 switch (attr->value_tag)
977 {
978 case IPP_TAG_INTEGER :
979 case IPP_TAG_ENUM :
7e86f2f6 980 snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", attr->values[i].integer);
01ce6322
MS
981 bufptr += strlen(bufptr);
982 break;
983
984 case IPP_TAG_BOOLEAN :
7e86f2f6 985 snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", attr->values[i].boolean);
01ce6322
MS
986 bufptr += strlen(bufptr);
987 break;
988
989 case IPP_TAG_TEXTLANG :
990 case IPP_TAG_NAMELANG :
991 case IPP_TAG_TEXT :
992 case IPP_TAG_NAME :
993 case IPP_TAG_KEYWORD :
994 case IPP_TAG_URI :
995 case IPP_TAG_URISCHEME :
996 case IPP_TAG_CHARSET :
997 case IPP_TAG_LANGUAGE :
998 case IPP_TAG_MIMETYPE :
7e86f2f6 999 strlcpy(bufptr, attr->values[i].string.text, sizeof(buffer) - (size_t)(bufptr - buffer));
01ce6322
MS
1000 bufptr += strlen(bufptr);
1001 break;
1002
bf1bc4c6
MS
1003 case IPP_TAG_BEGIN_COLLECTION :
1004 if (!strcmp(attr->name, "media-size"))
1005 {
1006 ipp_attribute_t *x_dimension = ippFindAttribute(ippGetCollection(attr, 0), "x-dimension", IPP_TAG_INTEGER);
1007 ipp_attribute_t *y_dimension = ippFindAttribute(ippGetCollection(attr, 0), "y-dimension", IPP_TAG_INTEGER);
1008 /* Media dimensions */
1009
1010 if (x_dimension && y_dimension)
1011 {
1012 pwg_media_t *pwg = pwgMediaForSize(ippGetInteger(x_dimension, 0), ippGetInteger(y_dimension, 0));
1013 /* PWG media name */
1014 strlcpy(bufptr, pwg->pwg, sizeof(buffer) - (size_t)(bufptr - buffer));
1015 break;
1016 }
1017 }
1018
01ce6322 1019 default :
7e86f2f6 1020 strlcpy(bufptr, "???", sizeof(buffer) - (size_t)(bufptr - buffer));
01ce6322
MS
1021 bufptr += strlen(bufptr);
1022 break;
1023 }
1024 }
1025 }
1026 else if (bufptr < (buffer + sizeof(buffer) - 1))
1027 *bufptr++ = '-';
1028 break;
1029 }
1030
1031 default :
1032 if (bufptr < (buffer + sizeof(buffer) - 2))
1033 {
1034 *bufptr++ = '%';
1035 *bufptr++ = *format;
1036 }
1037 break;
1038 }
1039 }
1040 else if (bufptr < (buffer + sizeof(buffer) - 1))
1041 *bufptr++ = *format;
1042 }
ef416fc2 1043
01ce6322 1044 *bufptr = '\0';
771bd8cb 1045
0dc4a6bf
MS
1046#ifdef HAVE_ASL_H
1047 if (!strcmp(ErrorLog, "syslog"))
1048 {
1049 asl_object_t m; /* Log message */
1050 char job_id[32], /* job-id string */
1051 completed[32]; /* job-impressions-completed string */
1052 static const char * const job_states[] =
1053 { /* job-state strings */
1054 "Pending",
1055 "PendingHeld",
1056 "Processing",
1057 "ProcessingStopped",
1058 "Canceled",
1059 "Aborted",
1060 "Completed"
1061 };
1062
1063 snprintf(job_id, sizeof(job_id), "%d", job->id);
1064
1065 m = asl_new(ASL_TYPE_MSG);
1066 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
1067 asl_set(m, PWG_Event, "JobStateChanged");
1068 asl_set(m, PWG_ServiceURI, job->printer->uri);
1069 asl_set(m, PWG_JobID, job_id);
1070 asl_set(m, PWG_JobState, job_states[job->state_value - IPP_JSTATE_PENDING]);
1071
1072 if (job->impressions)
1073 {
1074 snprintf(completed, sizeof(completed), "%d", ippGetInteger(job->impressions, 0));
1075 asl_set(m, PWG_JobImpressionsCompleted, completed);
1076 }
1077
1078 asl_log(NULL, m, ASL_LEVEL_INFO, "%s", buffer);
1079
1080 asl_release(m);
1081 return (1);
1082 }
1083
1084#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
1085 if (!strcmp(ErrorLog, "syslog"))
1086 {
0dc4a6bf
MS
1087 static const char * const job_states[] =
1088 { /* job-state strings */
1089 "Pending",
1090 "PendingHeld",
1091 "Processing",
1092 "ProcessingStopped",
1093 "Canceled",
1094 "Aborted",
1095 "Completed"
1096 };
1097
a990ad13
MS
1098 sd_journal_send("MESSAGE=%s", buffer,
1099 "PRIORITY=%i", LOG_INFO,
0dc4a6bf
MS
1100 PWG_Event"=JobStateChanged",
1101 PWG_ServiceURI"=%s", job->printer->uri,
1102 PWG_JobID"=%d", job->id,
1103 PWG_JobState"=%s", job_states[job->state_value - IPP_JSTATE_PENDING],
1104 PWG_JobImpressionsCompleted"=%d", ippGetInteger(job->impressions, 0),
1105 NULL);
1106 return (1);
1107 }
1108
1109#elif defined(HAVE_VSYSLOG)
ef416fc2 1110 /*
1111 * See if we are logging pages via syslog...
1112 */
1113
1114 if (!strcmp(PageLog, "syslog"))
1115 {
01ce6322 1116 syslog(LOG_INFO, "%s", buffer);
ef416fc2 1117
1118 return (1);
1119 }
0dc4a6bf 1120#endif /* HAVE_ASL_H */
ef416fc2 1121
1122 /*
1123 * Not using syslog; check the log file...
1124 */
1125
22c9029b 1126 if (!cupsdCheckLogFile(&PageFile, PageLog))
ef416fc2 1127 return (0);
1128
1129 /*
1130 * Print a page log entry of the form:
1131 *
ac884b6a 1132 * printer user job-id [DD/MON/YYYY:HH:MM:SS +TTTT] page num-copies \
ef416fc2 1133 * billing hostname
1134 */
1135
01ce6322 1136 cupsFilePrintf(PageFile, "%s\n", buffer);
ef416fc2 1137 cupsFileFlush(PageFile);
1138
1139 return (1);
1140}
1141
1142
1143/*
1144 * 'cupsdLogRequest()' - Log an HTTP request in Common Log Format.
1145 */
1146
1147int /* O - 1 on success, 0 on error */
1148cupsdLogRequest(cupsd_client_t *con, /* I - Request to log */
1149 http_status_t code) /* I - Response code */
1150{
839a51c8 1151 char temp[2048]; /* Temporary string for URI */
ef416fc2 1152 static const char * const states[] = /* HTTP client states... */
1153 {
1154 "WAITING",
1155 "OPTIONS",
1156 "GET",
1157 "GET",
1158 "HEAD",
1159 "POST",
1160 "POST",
1161 "POST",
1162 "PUT",
1163 "PUT",
1164 "DELETE",
1165 "TRACE",
1166 "CLOSE",
1167 "STATUS"
1168 };
1169
1170
1f0275e3
MS
1171 /*
1172 * Filter requests as needed...
1173 */
1174
c9dcc485
MS
1175 if (AccessLogLevel == CUPSD_ACCESSLOG_NONE)
1176 return (1);
1177 else if (AccessLogLevel < CUPSD_ACCESSLOG_ALL)
1f0275e3
MS
1178 {
1179 /*
ba55dc12 1180 * Eliminate simple GET, POST, and PUT requests...
1f0275e3
MS
1181 */
1182
1183 if ((con->operation == HTTP_GET &&
1184 strncmp(con->uri, "/admin/conf", 11) &&
1185 strncmp(con->uri, "/admin/log", 10)) ||
1186 (con->operation == HTTP_POST && !con->request &&
1187 strncmp(con->uri, "/admin", 6)) ||
ba55dc12
MS
1188 (con->operation != HTTP_GET && con->operation != HTTP_POST &&
1189 con->operation != HTTP_PUT))
1f0275e3
MS
1190 return (1);
1191
1192 if (con->request && con->response &&
e07d4801
MS
1193 (con->response->request.status.status_code < IPP_REDIRECTION_OTHER_SITE ||
1194 con->response->request.status.status_code == IPP_NOT_FOUND))
1f0275e3
MS
1195 {
1196 /*
1197 * Check successful requests...
1198 */
1199
1200 ipp_op_t op = con->request->request.op.operation_id;
1201 static cupsd_accesslog_t standard_ops[] =
1202 {
1203 CUPSD_ACCESSLOG_ALL, /* reserved */
1204 CUPSD_ACCESSLOG_ALL, /* reserved */
1205 CUPSD_ACCESSLOG_ACTIONS,/* Print-Job */
1206 CUPSD_ACCESSLOG_ACTIONS,/* Print-URI */
1207 CUPSD_ACCESSLOG_ACTIONS,/* Validate-Job */
1208 CUPSD_ACCESSLOG_ACTIONS,/* Create-Job */
1209 CUPSD_ACCESSLOG_ACTIONS,/* Send-Document */
1210 CUPSD_ACCESSLOG_ACTIONS,/* Send-URI */
1211 CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Job */
1212 CUPSD_ACCESSLOG_ALL, /* Get-Job-Attributes */
1213 CUPSD_ACCESSLOG_ALL, /* Get-Jobs */
1214 CUPSD_ACCESSLOG_ALL, /* Get-Printer-Attributes */
1215 CUPSD_ACCESSLOG_ACTIONS,/* Hold-Job */
1216 CUPSD_ACCESSLOG_ACTIONS,/* Release-Job */
1217 CUPSD_ACCESSLOG_ACTIONS,/* Restart-Job */
1218 CUPSD_ACCESSLOG_ALL, /* reserved */
1219 CUPSD_ACCESSLOG_CONFIG, /* Pause-Printer */
1220 CUPSD_ACCESSLOG_CONFIG, /* Resume-Printer */
1221 CUPSD_ACCESSLOG_CONFIG, /* Purge-Jobs */
1222 CUPSD_ACCESSLOG_CONFIG, /* Set-Printer-Attributes */
1223 CUPSD_ACCESSLOG_ACTIONS,/* Set-Job-Attributes */
1224 CUPSD_ACCESSLOG_CONFIG, /* Get-Printer-Supported-Values */
1225 CUPSD_ACCESSLOG_ACTIONS,/* Create-Printer-Subscription */
1226 CUPSD_ACCESSLOG_ACTIONS,/* Create-Job-Subscription */
1227 CUPSD_ACCESSLOG_ALL, /* Get-Subscription-Attributes */
1228 CUPSD_ACCESSLOG_ALL, /* Get-Subscriptions */
1229 CUPSD_ACCESSLOG_ACTIONS,/* Renew-Subscription */
1230 CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Subscription */
1231 CUPSD_ACCESSLOG_ALL, /* Get-Notifications */
1232 CUPSD_ACCESSLOG_ACTIONS,/* Send-Notifications */
1233 CUPSD_ACCESSLOG_ALL, /* reserved */
1234 CUPSD_ACCESSLOG_ALL, /* reserved */
1235 CUPSD_ACCESSLOG_ALL, /* reserved */
1236 CUPSD_ACCESSLOG_ALL, /* Get-Print-Support-Files */
1237 CUPSD_ACCESSLOG_CONFIG, /* Enable-Printer */
1238 CUPSD_ACCESSLOG_CONFIG, /* Disable-Printer */
1239 CUPSD_ACCESSLOG_CONFIG, /* Pause-Printer-After-Current-Job */
1240 CUPSD_ACCESSLOG_ACTIONS,/* Hold-New-Jobs */
1241 CUPSD_ACCESSLOG_ACTIONS,/* Release-Held-New-Jobs */
1242 CUPSD_ACCESSLOG_CONFIG, /* Deactivate-Printer */
1243 CUPSD_ACCESSLOG_CONFIG, /* Activate-Printer */
1244 CUPSD_ACCESSLOG_CONFIG, /* Restart-Printer */
1245 CUPSD_ACCESSLOG_CONFIG, /* Shutdown-Printer */
1246 CUPSD_ACCESSLOG_CONFIG, /* Startup-Printer */
1247 CUPSD_ACCESSLOG_ACTIONS,/* Reprocess-Job */
1248 CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Current-Job */
1249 CUPSD_ACCESSLOG_ACTIONS,/* Suspend-Current-Job */
1250 CUPSD_ACCESSLOG_ACTIONS,/* Resume-Job */
1251 CUPSD_ACCESSLOG_ACTIONS,/* Promote-Job */
1252 CUPSD_ACCESSLOG_ACTIONS /* Schedule-Job-After */
1253 };
1254 static cupsd_accesslog_t cups_ops[] =
1255 {
1256 CUPSD_ACCESSLOG_ALL, /* CUPS-Get-Default */
1257 CUPSD_ACCESSLOG_ALL, /* CUPS-Get-Printers */
1258 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Add-Modify-Printer */
1259 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Delete-Printer */
1260 CUPSD_ACCESSLOG_ALL, /* CUPS-Get-Classes */
1261 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Add-Modify-Class */
1262 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Delete-Class */
1263 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Accept-Jobs */
1264 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Reject-Jobs */
1265 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Set-Default */
1266 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Get-Devices */
1267 CUPSD_ACCESSLOG_CONFIG, /* CUPS-Get-PPDs */
1268 CUPSD_ACCESSLOG_ACTIONS,/* CUPS-Move-Job */
1269 CUPSD_ACCESSLOG_ACTIONS,/* CUPS-Authenticate-Job */
1270 CUPSD_ACCESSLOG_ALL /* CUPS-Get-PPD */
1271 };
771bd8cb 1272
1f0275e3
MS
1273
1274 if ((op <= IPP_SCHEDULE_JOB_AFTER && standard_ops[op] > AccessLogLevel) ||
1275 (op >= CUPS_GET_DEFAULT && op <= CUPS_GET_PPD &&
1276 cups_ops[op - CUPS_GET_DEFAULT] > AccessLogLevel))
1277 return (1);
1278 }
1279 }
1280
0dc4a6bf
MS
1281#ifdef HAVE_ASL_H
1282 if (!strcmp(ErrorLog, "syslog"))
1283 {
1284 asl_object_t m; /* Log message */
1285
1286 m = asl_new(ASL_TYPE_MSG);
1287 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
1288
1289 asl_log(NULL, m, ASL_LEVEL_INFO, "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
1290 con->http->hostname, con->username[0] != '\0' ? con->username : "-",
1291 states[con->operation], _httpEncodeURI(temp, con->uri, sizeof(temp)),
1292 con->http->version / 100, con->http->version % 100,
1293 code, CUPS_LLCAST con->bytes,
1294 con->request ?
1295 ippOpString(con->request->request.op.operation_id) : "-",
1296 con->response ?
1297 ippErrorString(con->response->request.status.status_code) : "-");
1298
1299 asl_release(m);
1300 return (1);
1301 }
1302
1303#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
a990ad13
MS
1304 if (!strcmp(ErrorLog, "syslog"))
1305 {
1306 sd_journal_print(LOG_INFO, "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s", con->http->hostname, con->username[0] != '\0' ? con->username : "-", states[con->operation], _httpEncodeURI(temp, con->uri, sizeof(temp)), con->http->version / 100, con->http->version % 100, code, CUPS_LLCAST con->bytes, con->request ? ippOpString(con->request->request.op.operation_id) : "-", con->response ? ippErrorString(con->response->request.status.status_code) : "-");
1307 return (1);
1308 }
0dc4a6bf
MS
1309
1310#elif defined(HAVE_VSYSLOG)
ef416fc2 1311 /*
1312 * See if we are logging accesses via syslog...
1313 */
1314
1315 if (!strcmp(AccessLog, "syslog"))
1316 {
2abf387c 1317 syslog(LOG_INFO,
1318 "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
996acce8 1319 con->http->hostname, con->username[0] != '\0' ? con->username : "-",
839a51c8 1320 states[con->operation], _httpEncodeURI(temp, con->uri, sizeof(temp)),
996acce8 1321 con->http->version / 100, con->http->version % 100,
2abf387c 1322 code, CUPS_LLCAST con->bytes,
1323 con->request ?
1324 ippOpString(con->request->request.op.operation_id) : "-",
1325 con->response ?
1326 ippErrorString(con->response->request.status.status_code) : "-");
ef416fc2 1327
1328 return (1);
1329 }
0dc4a6bf 1330#endif /* HAVE_ASL_H */
ef416fc2 1331
1332 /*
1333 * Not using syslog; check the log file...
1334 */
1335
22c9029b 1336 if (!cupsdCheckLogFile(&AccessFile, AccessLog))
ef416fc2 1337 return (0);
1338
1339 /*
1340 * Write a log of the request in "common log format"...
1341 */
1342
1343 cupsFilePrintf(AccessFile,
1344 "%s - %s %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
996acce8 1345 con->http->hostname,
c8fef167 1346 con->username[0] != '\0' ? con->username : "-",
dfd5680b
MS
1347 cupsdGetDateTime(&(con->start), LogTimeFormat),
1348 states[con->operation],
839a51c8 1349 _httpEncodeURI(temp, con->uri, sizeof(temp)),
996acce8 1350 con->http->version / 100, con->http->version % 100,
ef416fc2 1351 code, CUPS_LLCAST con->bytes,
1352 con->request ?
1353 ippOpString(con->request->request.op.operation_id) : "-",
1354 con->response ?
1355 ippErrorString(con->response->request.status.status_code) :
1356 "-");
1357
1358 cupsFileFlush(AccessFile);
1359
1360 return (1);
1361}
1362
1363
75bd9771
MS
1364/*
1365 * 'cupsdWriteErrorLog()' - Write a line to the ErrorLog.
1366 */
1367
1368int /* O - 1 on success, 0 on failure */
1369cupsdWriteErrorLog(int level, /* I - Log level */
1370 const char *message) /* I - Message string */
1371{
28a463e0 1372 int ret = 1; /* Return value */
75bd9771
MS
1373 static const char levels[] = /* Log levels... */
1374 {
1375 ' ',
1376 'X',
1377 'A',
1378 'C',
1379 'E',
1380 'W',
1381 'N',
1382 'I',
1383 'D',
1384 'd'
1385 };
75bd9771
MS
1386
1387
0dc4a6bf
MS
1388#ifdef HAVE_ASL_H
1389 if (!strcmp(ErrorLog, "syslog"))
1390 {
1391 asl_object_t m; /* Log message */
1392
1393 m = asl_new(ASL_TYPE_MSG);
1394 asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
1395 asl_log(NULL, m, ASL_LEVEL_INFO, "%s", message);
1396
1397 asl_release(m);
1398 return (1);
1399 }
1400
1401#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
a990ad13
MS
1402 if (!strcmp(ErrorLog, "syslog"))
1403 {
1404 sd_journal_print(log_levels[level], "%s", message);
1405 return (1);
1406 }
0dc4a6bf
MS
1407
1408#elif defined(HAVE_VSYSLOG)
75bd9771
MS
1409 /*
1410 * See if we are logging errors via syslog...
1411 */
1412
1413 if (!strcmp(ErrorLog, "syslog"))
1414 {
0dc4a6bf 1415 syslog(log_levels[level], "%s", message);
75bd9771
MS
1416 return (1);
1417 }
0dc4a6bf 1418#endif /* HAVE_ASL_H */
75bd9771
MS
1419
1420 /*
1421 * Not using syslog; check the log file...
1422 */
1423
28a463e0
MS
1424 _cupsMutexLock(&log_mutex);
1425
22c9029b 1426 if (!cupsdCheckLogFile(&ErrorFile, ErrorLog))
28a463e0
MS
1427 {
1428 ret = 0;
1429 }
1430 else
1431 {
1432 /*
1433 * Write the log message...
1434 */
75bd9771 1435
28a463e0
MS
1436 cupsFilePrintf(ErrorFile, "%c %s %s\n", levels[level],
1437 cupsdGetDateTime(NULL, LogTimeFormat), message);
1438 cupsFileFlush(ErrorFile);
1439 }
75bd9771 1440
28a463e0 1441 _cupsMutexUnlock(&log_mutex);
75bd9771 1442
28a463e0 1443 return (ret);
75bd9771
MS
1444}
1445
1446
ef416fc2 1447/*
75bd9771
MS
1448 * 'format_log_line()' - Format a line for a log file.
1449 *
1450 * This function resizes a global string buffer as needed. Each call returns
1451 * a pointer to this buffer, so the contents are only good until the next call
1452 * to format_log_line()...
1453 */
1454
005dd1eb 1455static int /* O - -1 for fatal, 0 for retry, 1 for success */
75bd9771
MS
1456format_log_line(const char *message, /* I - Printf-style format string */
1457 va_list ap) /* I - Argument list */
1458{
7e86f2f6 1459 ssize_t len; /* Length of formatted line */
75bd9771
MS
1460
1461
1462 /*
1463 * Allocate the line buffer as needed...
1464 */
1465
1466 if (!log_linesize)
1467 {
1468 log_linesize = 8192;
1469 log_line = malloc(log_linesize);
1470
1471 if (!log_line)
005dd1eb 1472 return (-1);
75bd9771
MS
1473 }
1474
1475 /*
1476 * Format the log message...
1477 */
1478
59189c00 1479 len = _cups_safe_vsnprintf(log_line, log_linesize, message, ap);
75bd9771
MS
1480
1481 /*
1482 * Resize the buffer as needed...
1483 */
1484
7e86f2f6 1485 if ((size_t)len >= log_linesize && log_linesize < 65536)
75bd9771
MS
1486 {
1487 char *temp; /* Temporary string pointer */
1488
75bd9771
MS
1489 len ++;
1490
1491 if (len < 8192)
1492 len = 8192;
1493 else if (len > 65536)
1494 len = 65536;
1495
7e86f2f6 1496 temp = realloc(log_line, (size_t)len);
75bd9771
MS
1497
1498 if (temp)
1499 {
1500 log_line = temp;
7e86f2f6 1501 log_linesize = (size_t)len;
75bd9771 1502
005dd1eb
MS
1503 return (0);
1504 }
75bd9771
MS
1505 }
1506
005dd1eb 1507 return (1);
75bd9771
MS
1508}
1509
1510
1511/*
f2d18633 1512 * End of "$Id$".
ef416fc2 1513 */