scheduler/log.c

   1 /*
   2  * "$Id$"
   3  *
   4  * Log file routines for the CUPS scheduler.
   5  *
   6  * Copyright 2007-2015 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
  16 /*
  17  * Include necessary headers...
  18  */
  19
  20 #include "cupsd.h"
  21 #include <stdarg.h>
  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 */
  28 #include <syslog.h>
  29
  30
  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
  59 /*
  60  * Local globals...
  61  */
  62
  63 static _cups_mutex_t log_mutex = _CUPS_MUTEX_INITIALIZER;
  64                                         /* Mutex for logging */
  65 static size_t   log_linesize = 0;       /* Size of line for output file */
  66 static char     *log_line = NULL;       /* Line for output file */
  67
  68 #ifdef HAVE_ASL_H
  69 static 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)
  83 static const int log_levels[] =         /* SYSLOG levels... */
  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                 };
  96 #endif /* HAVE_ASL_H */
  97
  98
  99 /*
 100  * Local functions...
 101  */
 102
 103 static int      format_log_line(const char *message, va_list ap);
 104
 105
 106 /*
 107  * 'cupsdCheckLogFile()' - Open/rotate a log file if it needs it.
 108  */
 109
 110 int                                     /* O  - 1 if log file open */
 111 cupsdCheckLogFile(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
 127  /*
 128   * Handle logging to stderr...
 129   */
 130
 131   if (!strcmp(logname, "stderr"))
 132   {
 133     *lf = LogStderr;
 134     return (1);
 135   }
 136
 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
 175           strlcpy(ptr, ServerName, sizeof(filename) - (size_t)(ptr - filename));
 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
 216         mode_t log_dir_perm = (mode_t)(0300 | LogFilePerm);
 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
 223         cupsdCheckPermissions(CUPS_LOGDIR, NULL, log_dir_perm, RunUser, Group, 1, -1);
 224
 225         *lf = cupsFileOpen(filename, "a");
 226       }
 227
 228       if (*lf == NULL)
 229       {
 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 */
 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
 276     strlcpy(backname, filename, sizeof(backname));
 277     strlcat(backname, ".O", sizeof(backname));
 278
 279     unlink(backname);
 280     rename(filename, backname);
 281
 282     if ((*lf = cupsFileOpen(filename, "a")) == NULL)
 283     {
 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 */
 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
 317 /*
 318  * 'cupsdGetDateTime()' - Returns a pointer to a date/time string.
 319  */
 320
 321 char *                                  /* O - Date/time string */
 322 cupsdGetDateTime(struct timeval *t,     /* I - Time value or NULL for current */
 323                  cupsd_time_t   format) /* I - Format to use */
 324 {
 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 */
 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
 347  /*
 348   * Make sure we have a valid time...
 349   */
 350
 351   if (!t)
 352   {
 353     gettimeofday(&curtime, NULL);
 354     t = &curtime;
 355   }
 356
 357   if (t->tv_sec != last_time.tv_sec ||
 358       (LogTimeFormat == CUPSD_TIME_USECS && t->tv_usec != last_time.tv_usec))
 359   {
 360     last_time = *t;
 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
 376     date = localtime(&(t->tv_sec));
 377
 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,
 390                date->tm_hour, date->tm_min, date->tm_sec, (int)t->tv_usec,
 391 #ifdef HAVE_TM_GMTOFF
 392                date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
 393 #else
 394                timezone / 3600, (timezone / 60) % 60);
 395 #endif /* HAVE_TM_GMTOFF */
 396   }
 397
 398   return (s);
 399 }
 400
 401
 402 /*
 403  * 'cupsdLogFCMessage()' - Log a file checking message.
 404  */
 405
 406 void
 407 cupsdLogFCMessage(
 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     }
 434     else if (result == _CUPS_FILE_CHECK_PERMISSIONS ||
 435              result == _CUPS_FILE_CHECK_RELATIVE_PATH)
 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
 448 #ifdef HAVE_GSSAPI
 449 /*
 450  * 'cupsdLogGSSMessage()' - Log a GSSAPI error...
 451  */
 452
 453 int                                     /* O - 1 on success, 0 on error */
 454 cupsdLogGSSMessage(
 455     int        level,                   /* I - Log level */
 456     OM_uint32  major_status,            /* I - Major GSSAPI status */
 457     OM_uint32  minor_status,            /* I - Minor GSSAPI status */
 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 */
 469   char          buffer[8192];           /* Buffer for vsnprintf */
 470
 471
 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
 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))
 496     gss_display_status(&err_minor_status, minor_status, GSS_C_MECH_CODE,
 497                        GSS_C_NULL_OID, &msg_ctx, &minor_status_string);
 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
 510 /*
 511  * 'cupsdLogClient()' - Log a client message.
 512  */
 513
 514 int                                     /* O - 1 on success, 0 on error */
 515 cupsdLogClient(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
 565 /*
 566  * 'cupsdLogJob()' - Log a job message.
 567  */
 568
 569 int                                     /* O - 1 on success, 0 on error */
 570 cupsdLogJob(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 */
 574 {
 575   va_list               ap, ap2;        /* Argument pointers */
 576   char                  jobmsg[1024];   /* Format string for job message */
 577   int                   status;         /* Formatting status */
 578
 579
 580  /*
 581   * See if we want to log this message...
 582   */
 583
 584   if (TestConfigFile || !ErrorLog)
 585     return (1);
 586
 587   if ((level > LogLevel ||
 588        (level == CUPSD_LOG_INFO && LogLevel < CUPSD_LOG_DEBUG)) &&
 589       LogDebugHistory <= 0)
 590     return (1);
 591
 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 */
 598     cupsd_printer_t *printer = job->printer ? job->printer : cupsdFindDest(job->dest);
 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
 610     snprintf(job_id, sizeof(job_id), "%d", job->id);
 611
 612     m = asl_new(ASL_TYPE_MSG);
 613     asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
 614     asl_set(m, PWG_Event, "JobStateChanged");
 615     asl_set(m, PWG_ServiceURI, printer->uri);
 616     asl_set(m, PWG_JobID, job_id);
 617     asl_set(m, PWG_JobState, job_states[job->state_value - IPP_JSTATE_PENDING]);
 618
 619     if (job->impressions)
 620     {
 621       snprintf(completed, sizeof(completed), "%d", ippGetInteger(job->impressions, 0));
 622       asl_set(m, PWG_JobImpressionsCompleted, completed);
 623     }
 624
 625     va_start(ap, message);
 626     asl_vlog(NULL, m, log_levels[level], message, ap);
 627     va_end(ap);
 628
 629     asl_release(m);
 630     return (1);
 631   }
 632
 633 #elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
 634   if (!strcmp(ErrorLog, "syslog"))
 635   {
 636     cupsd_printer_t *printer = job->printer ? job->printer : cupsdFindDest(job->dest);
 637     static const char * const job_states[] =
 638     {                                   /* job-state strings */
 639       "Pending",
 640       "PendingHeld",
 641       "Processing",
 642       "ProcessingStopped",
 643       "Canceled",
 644       "Aborted",
 645       "Completed"
 646     };
 647
 648     va_start(ap, message);
 649
 650     do
 651     {
 652       va_copy(ap2, ap);
 653       status = format_log_line(message, ap2);
 654       va_end(ap2);
 655     }
 656     while (status == 0);
 657
 658     va_end(ap);
 659
 660     sd_journal_send("MESSAGE=%s", log_line,
 661                     "PRIORITY=%i", log_levels[level],
 662                     PWG_Event"=JobStateChanged",
 663                     PWG_ServiceURI"=%s", printer->uri,
 664                     PWG_JobID"=%d", job->id,
 665                     PWG_JobState"=%s", job_states[job->state_value - IPP_JSTATE_PENDING],
 666                     PWG_JobImpressionsCompleted"=%d", ippGetInteger(job->impressions, 0),
 667                     NULL);
 668     return (1);
 669   }
 670
 671 #endif /* HAVE_ASL_H */
 672
 673  /*
 674   * Format and write the log message...
 675   */
 676
 677   if (job)
 678     snprintf(jobmsg, sizeof(jobmsg), "[Job %d] %s", job->id, message);
 679   else
 680     strlcpy(jobmsg, message, sizeof(jobmsg));
 681
 682   va_start(ap, message);
 683
 684   do
 685   {
 686     va_copy(ap2, ap);
 687     status = format_log_line(jobmsg, ap2);
 688     va_end(ap2);
 689   }
 690   while (status == 0);
 691
 692   va_end(ap);
 693
 694   if (status > 0)
 695   {
 696     if (job &&
 697         (level > LogLevel ||
 698          (level == CUPSD_LOG_INFO && LogLevel < CUPSD_LOG_DEBUG)) &&
 699         LogDebugHistory > 0)
 700     {
 701      /*
 702       * Add message to the job history...
 703       */
 704
 705       cupsd_joblog_t *temp;             /* Copy of log message */
 706       size_t         log_len = strlen(log_line);
 707                                         /* Length of log message */
 708
 709       if ((temp = malloc(sizeof(cupsd_joblog_t) + log_len)) != NULL)
 710       {
 711         temp->time = time(NULL);
 712         memcpy(temp->message, log_line, log_len + 1);
 713       }
 714
 715       if (!job->history)
 716         job->history = cupsArrayNew(NULL, NULL);
 717
 718       if (job->history && temp)
 719       {
 720         cupsArrayAdd(job->history, temp);
 721
 722         if (cupsArrayCount(job->history) > LogDebugHistory)
 723         {
 724          /*
 725           * Remove excess messages...
 726           */
 727
 728           temp = cupsArrayFirst(job->history);
 729           cupsArrayRemove(job->history, temp);
 730           free(temp);
 731         }
 732       }
 733       else if (temp)
 734         free(temp);
 735
 736       return (1);
 737     }
 738     else if (level <= LogLevel &&
 739              (level != CUPSD_LOG_INFO || LogLevel >= CUPSD_LOG_DEBUG))
 740       return (cupsdWriteErrorLog(level, log_line));
 741     else
 742       return (1);
 743   }
 744   else
 745     return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
 746                                "Unable to allocate memory for log line."));
 747 }
 748
 749
 750 /*
 751  * 'cupsdLogMessage()' - Log a message to the error log file.
 752  */
 753
 754 int                                     /* O - 1 on success, 0 on error */
 755 cupsdLogMessage(int        level,       /* I - Log level */
 756                 const char *message,    /* I - printf-style message string */
 757                 ...)                    /* I - Additional args as needed */
 758 {
 759   va_list               ap, ap2;        /* Argument pointers */
 760   int                   status;         /* Formatting status */
 761
 762
 763  /*
 764   * See if we want to log this message...
 765   */
 766
 767   if ((TestConfigFile || !ErrorLog) && level <= CUPSD_LOG_WARN)
 768   {
 769     va_start(ap, message);
 770
 771 #ifdef HAVE_ASL_H
 772     asl_object_t        m;              /* Log message */
 773
 774     m = asl_new(ASL_TYPE_MSG);
 775     asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
 776     asl_vlog(NULL, m, log_levels[level], message, ap);
 777     asl_release(m);
 778
 779 #elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
 780     sd_journal_printv(log_levels[level], message, ap);
 781
 782 #elif defined(HAVE_VSYSLOG)
 783     vsyslog(LOG_LPR | log_levels[level], message, ap);
 784
 785 #else
 786     vfprintf(stderr, message, ap);
 787     putc('\n', stderr);
 788 #endif /* HAVE_VSYSLOG */
 789
 790     va_end(ap);
 791
 792     return (1);
 793   }
 794
 795   if (level > LogLevel || !ErrorLog)
 796     return (1);
 797
 798 #ifdef HAVE_ASL_H
 799   if (!strcmp(ErrorLog, "syslog"))
 800   {
 801     asl_object_t        m;              /* Log message */
 802
 803     m = asl_new(ASL_TYPE_MSG);
 804     asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
 805
 806     va_start(ap, message);
 807     asl_vlog(NULL, m, log_levels[level], message, ap);
 808     va_end(ap);
 809
 810     asl_release(m);
 811     return (1);
 812   }
 813
 814 #elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
 815   if (!strcmp(ErrorLog, "syslog"))
 816   {
 817     va_start(ap, message);
 818     sd_journal_printv(log_levels[level], message, ap);
 819     va_end(ap);
 820     return (1);
 821   }
 822 #endif /* HAVE_ASL_H */
 823
 824  /*
 825   * Format and write the log message...
 826   */
 827
 828   va_start(ap, message);
 829
 830   do
 831   {
 832     va_copy(ap2, ap);
 833     status = format_log_line(message, ap2);
 834     va_end(ap2);
 835   }
 836   while (status == 0);
 837
 838   va_end(ap);
 839
 840   if (status > 0)
 841     return (cupsdWriteErrorLog(level, log_line));
 842   else
 843     return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
 844                                "Unable to allocate memory for log line!"));
 845 }
 846
 847
 848 /*
 849  * 'cupsdLogPage()' - Log a page to the page log file.
 850  */
 851
 852 int                                     /* O - 1 on success, 0 on error */
 853 cupsdLogPage(cupsd_job_t *job,          /* I - Job being printed */
 854              const char  *page)         /* I - Page being printed */
 855 {
 856   int                   i;              /* Looping var */
 857   char                  buffer[2048],   /* Buffer for page log */
 858                         *bufptr,        /* Pointer into buffer */
 859                         name[256];      /* Attribute name */
 860   const char            *format,        /* Pointer into PageLogFormat */
 861                         *nameend;       /* End of attribute name */
 862   ipp_attribute_t       *attr;          /* Current attribute */
 863   char                  number[256];    /* Page number */
 864   int                   copies;         /* Number of copies */
 865
 866
 867  /*
 868   * Format the line going into the page log...
 869   */
 870
 871   if (!PageLogFormat)
 872     return (1);
 873
 874   strlcpy(number, "1", sizeof(number));
 875   copies = 1;
 876   sscanf(page, "%255s%d", number, &copies);
 877
 878   for (format = PageLogFormat, bufptr = buffer; *format; format ++)
 879   {
 880     if (*format == '%')
 881     {
 882       format ++;
 883
 884       switch (*format)
 885       {
 886         case '%' :                      /* Literal % */
 887             if (bufptr < (buffer + sizeof(buffer) - 1))
 888               *bufptr++ = '%';
 889             break;
 890
 891         case 'p' :                      /* Printer name */
 892             strlcpy(bufptr, job->dest, sizeof(buffer) - (size_t)(bufptr - buffer));
 893             bufptr += strlen(bufptr);
 894             break;
 895
 896         case 'j' :                      /* Job ID */
 897             snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", job->id);
 898             bufptr += strlen(bufptr);
 899             break;
 900
 901         case 'u' :                      /* Username */
 902             strlcpy(bufptr, job->username ? job->username : "-", sizeof(buffer) - (size_t)(bufptr - buffer));
 903             bufptr += strlen(bufptr);
 904             break;
 905
 906         case 'T' :                      /* Date and time */
 907             strlcpy(bufptr, cupsdGetDateTime(NULL, LogTimeFormat), sizeof(buffer) - (size_t)(bufptr - buffer));
 908             bufptr += strlen(bufptr);
 909             break;
 910
 911         case 'P' :                      /* Page number */
 912             strlcpy(bufptr, number, sizeof(buffer) - (size_t)(bufptr - buffer));
 913             bufptr += strlen(bufptr);
 914             break;
 915
 916         case 'C' :                      /* Number of copies */
 917             snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", copies);
 918             bufptr += strlen(bufptr);
 919             break;
 920
 921         case '{' :                      /* {attribute} */
 922             if ((nameend = strchr(format, '}')) != NULL && (size_t)(nameend - format - 2) < (sizeof(name) - 1))
 923             {
 924              /*
 925               * Pull the name from inside the brackets...
 926               */
 927
 928               memcpy(name, format + 1, (size_t)(nameend - format - 1));
 929               name[nameend - format - 1] = '\0';
 930
 931               format = nameend;
 932
 933               attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO);
 934               if (!attr && !strcmp(name, "job-billing"))
 935               {
 936                /*
 937                 * Handle alias "job-account-id" (which was standardized after
 938                 * "job-billing" was defined for CUPS...
 939                 */
 940
 941                 attr = ippFindAttribute(job->attrs, "job-account-id", IPP_TAG_ZERO);
 942               }
 943               else if (!attr && !strcmp(name, "media"))
 944               {
 945                /*
 946                 * Handle alias "media-col" which uses dimensions instead of
 947                 * names...
 948                 */
 949
 950                 attr = ippFindAttribute(job->attrs, "media-col/media-size", IPP_TAG_BEGIN_COLLECTION);
 951               }
 952
 953               if (attr)
 954               {
 955                /*
 956                 * Add the attribute value...
 957                 */
 958
 959                 for (i = 0;
 960                      i < attr->num_values &&
 961                          bufptr < (buffer + sizeof(buffer) - 1);
 962                      i ++)
 963                 {
 964                   if (i)
 965                     *bufptr++ = ',';
 966
 967                   switch (attr->value_tag)
 968                   {
 969                     case IPP_TAG_INTEGER :
 970                     case IPP_TAG_ENUM :
 971                         snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", attr->values[i].integer);
 972                         bufptr += strlen(bufptr);
 973                         break;
 974
 975                     case IPP_TAG_BOOLEAN :
 976                         snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", attr->values[i].boolean);
 977                         bufptr += strlen(bufptr);
 978                         break;
 979
 980                     case IPP_TAG_TEXTLANG :
 981                     case IPP_TAG_NAMELANG :
 982                     case IPP_TAG_TEXT :
 983                     case IPP_TAG_NAME :
 984                     case IPP_TAG_KEYWORD :
 985                     case IPP_TAG_URI :
 986                     case IPP_TAG_URISCHEME :
 987                     case IPP_TAG_CHARSET :
 988                     case IPP_TAG_LANGUAGE :
 989                     case IPP_TAG_MIMETYPE :
 990                         strlcpy(bufptr, attr->values[i].string.text, sizeof(buffer) - (size_t)(bufptr - buffer));
 991                         bufptr += strlen(bufptr);
 992                         break;
 993
 994                     case IPP_TAG_BEGIN_COLLECTION :
 995                         if (!strcmp(attr->name, "media-size"))
 996                         {
 997                           ipp_attribute_t *x_dimension = ippFindAttribute(ippGetCollection(attr, 0), "x-dimension", IPP_TAG_INTEGER);
 998                           ipp_attribute_t *y_dimension = ippFindAttribute(ippGetCollection(attr, 0), "y-dimension", IPP_TAG_INTEGER);
 999                                         /* Media dimensions */
1000
1001                           if (x_dimension && y_dimension)
1002                           {
1003                             pwg_media_t *pwg = pwgMediaForSize(ippGetInteger(x_dimension, 0), ippGetInteger(y_dimension, 0));
1004                                         /* PWG media name */
1005                             strlcpy(bufptr, pwg->pwg, sizeof(buffer) - (size_t)(bufptr - buffer));
1006                             break;
1007                           }
1008                         }
1009
1010                     default :
1011                         strlcpy(bufptr, "???", sizeof(buffer) - (size_t)(bufptr - buffer));
1012                         bufptr += strlen(bufptr);
1013                         break;
1014                   }
1015                 }
1016               }
1017               else if (bufptr < (buffer + sizeof(buffer) - 1))
1018                 *bufptr++ = '-';
1019               break;
1020             }
1021
1022         default :
1023             if (bufptr < (buffer + sizeof(buffer) - 2))
1024             {
1025               *bufptr++ = '%';
1026               *bufptr++ = *format;
1027             }
1028             break;
1029       }
1030     }
1031     else if (bufptr < (buffer + sizeof(buffer) - 1))
1032       *bufptr++ = *format;
1033   }
1034
1035   *bufptr = '\0';
1036
1037 #ifdef HAVE_ASL_H
1038   if (!strcmp(ErrorLog, "syslog"))
1039   {
1040     asl_object_t        m;              /* Log message */
1041     char                job_id[32],     /* job-id string */
1042                         completed[32];  /* job-impressions-completed string */
1043     static const char * const job_states[] =
1044     {                                   /* job-state strings */
1045       "Pending",
1046       "PendingHeld",
1047       "Processing",
1048       "ProcessingStopped",
1049       "Canceled",
1050       "Aborted",
1051       "Completed"
1052     };
1053
1054     snprintf(job_id, sizeof(job_id), "%d", job->id);
1055
1056     m = asl_new(ASL_TYPE_MSG);
1057     asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
1058     asl_set(m, PWG_Event, "JobStateChanged");
1059     asl_set(m, PWG_ServiceURI, job->printer->uri);
1060     asl_set(m, PWG_JobID, job_id);
1061     asl_set(m, PWG_JobState, job_states[job->state_value - IPP_JSTATE_PENDING]);
1062
1063     if (job->impressions)
1064     {
1065       snprintf(completed, sizeof(completed), "%d", ippGetInteger(job->impressions, 0));
1066       asl_set(m, PWG_JobImpressionsCompleted, completed);
1067     }
1068
1069     asl_log(NULL, m, ASL_LEVEL_INFO, "%s", buffer);
1070
1071     asl_release(m);
1072     return (1);
1073   }
1074
1075 #elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
1076   if (!strcmp(ErrorLog, "syslog"))
1077   {
1078     static const char * const job_states[] =
1079     {                                   /* job-state strings */
1080       "Pending",
1081       "PendingHeld",
1082       "Processing",
1083       "ProcessingStopped",
1084       "Canceled",
1085       "Aborted",
1086       "Completed"
1087     };
1088
1089     sd_journal_send("MESSAGE=%s", buffer,
1090                     "PRIORITY=%i", LOG_INFO,
1091                     PWG_Event"=JobStateChanged",
1092                     PWG_ServiceURI"=%s", job->printer->uri,
1093                     PWG_JobID"=%d", job->id,
1094                     PWG_JobState"=%s", job_states[job->state_value - IPP_JSTATE_PENDING],
1095                     PWG_JobImpressionsCompleted"=%d", ippGetInteger(job->impressions, 0),
1096                     NULL);
1097     return (1);
1098   }
1099
1100 #elif defined(HAVE_VSYSLOG)
1101  /*
1102   * See if we are logging pages via syslog...
1103   */
1104
1105   if (!strcmp(PageLog, "syslog"))
1106   {
1107     syslog(LOG_INFO, "%s", buffer);
1108
1109     return (1);
1110   }
1111 #endif /* HAVE_ASL_H */
1112
1113  /*
1114   * Not using syslog; check the log file...
1115   */
1116
1117   if (!cupsdCheckLogFile(&PageFile, PageLog))
1118     return (0);
1119
1120  /*
1121   * Print a page log entry of the form:
1122   *
1123   *    printer user job-id [DD/MON/YYYY:HH:MM:SS +TTTT] page num-copies \
1124   *        billing hostname
1125   */
1126
1127   cupsFilePrintf(PageFile, "%s\n", buffer);
1128   cupsFileFlush(PageFile);
1129
1130   return (1);
1131 }
1132
1133
1134 /*
1135  * 'cupsdLogRequest()' - Log an HTTP request in Common Log Format.
1136  */
1137
1138 int                                     /* O - 1 on success, 0 on error */
1139 cupsdLogRequest(cupsd_client_t *con,    /* I - Request to log */
1140                 http_status_t  code)    /* I - Response code */
1141 {
1142   char  temp[2048];                     /* Temporary string for URI */
1143   static const char * const states[] =  /* HTTP client states... */
1144                 {
1145                   "WAITING",
1146                   "OPTIONS",
1147                   "GET",
1148                   "GET",
1149                   "HEAD",
1150                   "POST",
1151                   "POST",
1152                   "POST",
1153                   "PUT",
1154                   "PUT",
1155                   "DELETE",
1156                   "TRACE",
1157                   "CLOSE",
1158                   "STATUS"
1159                 };
1160
1161
1162  /*
1163   * Filter requests as needed...
1164   */
1165
1166   if (AccessLogLevel == CUPSD_ACCESSLOG_NONE)
1167     return (1);
1168   else if (AccessLogLevel < CUPSD_ACCESSLOG_ALL)
1169   {
1170    /*
1171     * Eliminate simple GET, POST, and PUT requests...
1172     */
1173
1174     if ((con->operation == HTTP_GET &&
1175          strncmp(con->uri, "/admin/conf", 11) &&
1176          strncmp(con->uri, "/admin/log", 10)) ||
1177         (con->operation == HTTP_POST && !con->request &&
1178          strncmp(con->uri, "/admin", 6)) ||
1179         (con->operation != HTTP_GET && con->operation != HTTP_POST &&
1180          con->operation != HTTP_PUT))
1181       return (1);
1182
1183     if (con->request && con->response &&
1184         (con->response->request.status.status_code < IPP_REDIRECTION_OTHER_SITE ||
1185          con->response->request.status.status_code == IPP_NOT_FOUND))
1186     {
1187      /*
1188       * Check successful requests...
1189       */
1190
1191       ipp_op_t op = con->request->request.op.operation_id;
1192       static cupsd_accesslog_t standard_ops[] =
1193       {
1194         CUPSD_ACCESSLOG_ALL,    /* reserved */
1195         CUPSD_ACCESSLOG_ALL,    /* reserved */
1196         CUPSD_ACCESSLOG_ACTIONS,/* Print-Job */
1197         CUPSD_ACCESSLOG_ACTIONS,/* Print-URI */
1198         CUPSD_ACCESSLOG_ACTIONS,/* Validate-Job */
1199         CUPSD_ACCESSLOG_ACTIONS,/* Create-Job */
1200         CUPSD_ACCESSLOG_ACTIONS,/* Send-Document */
1201         CUPSD_ACCESSLOG_ACTIONS,/* Send-URI */
1202         CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Job */
1203         CUPSD_ACCESSLOG_ALL,    /* Get-Job-Attributes */
1204         CUPSD_ACCESSLOG_ALL,    /* Get-Jobs */
1205         CUPSD_ACCESSLOG_ALL,    /* Get-Printer-Attributes */
1206         CUPSD_ACCESSLOG_ACTIONS,/* Hold-Job */
1207         CUPSD_ACCESSLOG_ACTIONS,/* Release-Job */
1208         CUPSD_ACCESSLOG_ACTIONS,/* Restart-Job */
1209         CUPSD_ACCESSLOG_ALL,    /* reserved */
1210         CUPSD_ACCESSLOG_CONFIG, /* Pause-Printer */
1211         CUPSD_ACCESSLOG_CONFIG, /* Resume-Printer */
1212         CUPSD_ACCESSLOG_CONFIG, /* Purge-Jobs */
1213         CUPSD_ACCESSLOG_CONFIG, /* Set-Printer-Attributes */
1214         CUPSD_ACCESSLOG_ACTIONS,/* Set-Job-Attributes */
1215         CUPSD_ACCESSLOG_CONFIG, /* Get-Printer-Supported-Values */
1216         CUPSD_ACCESSLOG_ACTIONS,/* Create-Printer-Subscription */
1217         CUPSD_ACCESSLOG_ACTIONS,/* Create-Job-Subscription */
1218         CUPSD_ACCESSLOG_ALL,    /* Get-Subscription-Attributes */
1219         CUPSD_ACCESSLOG_ALL,    /* Get-Subscriptions */
1220         CUPSD_ACCESSLOG_ACTIONS,/* Renew-Subscription */
1221         CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Subscription */
1222         CUPSD_ACCESSLOG_ALL,    /* Get-Notifications */
1223         CUPSD_ACCESSLOG_ACTIONS,/* Send-Notifications */
1224         CUPSD_ACCESSLOG_ALL,    /* reserved */
1225         CUPSD_ACCESSLOG_ALL,    /* reserved */
1226         CUPSD_ACCESSLOG_ALL,    /* reserved */
1227         CUPSD_ACCESSLOG_ALL,    /* Get-Print-Support-Files */
1228         CUPSD_ACCESSLOG_CONFIG, /* Enable-Printer */
1229         CUPSD_ACCESSLOG_CONFIG, /* Disable-Printer */
1230         CUPSD_ACCESSLOG_CONFIG, /* Pause-Printer-After-Current-Job */
1231         CUPSD_ACCESSLOG_ACTIONS,/* Hold-New-Jobs */
1232         CUPSD_ACCESSLOG_ACTIONS,/* Release-Held-New-Jobs */
1233         CUPSD_ACCESSLOG_CONFIG, /* Deactivate-Printer */
1234         CUPSD_ACCESSLOG_CONFIG, /* Activate-Printer */
1235         CUPSD_ACCESSLOG_CONFIG, /* Restart-Printer */
1236         CUPSD_ACCESSLOG_CONFIG, /* Shutdown-Printer */
1237         CUPSD_ACCESSLOG_CONFIG, /* Startup-Printer */
1238         CUPSD_ACCESSLOG_ACTIONS,/* Reprocess-Job */
1239         CUPSD_ACCESSLOG_ACTIONS,/* Cancel-Current-Job */
1240         CUPSD_ACCESSLOG_ACTIONS,/* Suspend-Current-Job */
1241         CUPSD_ACCESSLOG_ACTIONS,/* Resume-Job */
1242         CUPSD_ACCESSLOG_ACTIONS,/* Promote-Job */
1243         CUPSD_ACCESSLOG_ACTIONS /* Schedule-Job-After */
1244       };
1245       static cupsd_accesslog_t cups_ops[] =
1246       {
1247         CUPSD_ACCESSLOG_ALL,    /* CUPS-Get-Default */
1248         CUPSD_ACCESSLOG_ALL,    /* CUPS-Get-Printers */
1249         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Add-Modify-Printer */
1250         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Delete-Printer */
1251         CUPSD_ACCESSLOG_ALL,    /* CUPS-Get-Classes */
1252         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Add-Modify-Class */
1253         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Delete-Class */
1254         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Accept-Jobs */
1255         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Reject-Jobs */
1256         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Set-Default */
1257         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Get-Devices */
1258         CUPSD_ACCESSLOG_CONFIG, /* CUPS-Get-PPDs */
1259         CUPSD_ACCESSLOG_ACTIONS,/* CUPS-Move-Job */
1260         CUPSD_ACCESSLOG_ACTIONS,/* CUPS-Authenticate-Job */
1261         CUPSD_ACCESSLOG_ALL     /* CUPS-Get-PPD */
1262       };
1263
1264
1265       if ((op <= IPP_SCHEDULE_JOB_AFTER && standard_ops[op] > AccessLogLevel) ||
1266           (op >= CUPS_GET_DEFAULT && op <= CUPS_GET_PPD &&
1267            cups_ops[op - CUPS_GET_DEFAULT] > AccessLogLevel))
1268         return (1);
1269     }
1270   }
1271
1272 #ifdef HAVE_ASL_H
1273   if (!strcmp(ErrorLog, "syslog"))
1274   {
1275     asl_object_t        m;              /* Log message */
1276
1277     m = asl_new(ASL_TYPE_MSG);
1278     asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
1279
1280     asl_log(NULL, m, ASL_LEVEL_INFO, "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
1281            con->http->hostname, con->username[0] != '\0' ? con->username : "-",
1282            states[con->operation], _httpEncodeURI(temp, con->uri, sizeof(temp)),
1283            con->http->version / 100, con->http->version % 100,
1284            code, CUPS_LLCAST con->bytes,
1285            con->request ?
1286                ippOpString(con->request->request.op.operation_id) : "-",
1287            con->response ?
1288                ippErrorString(con->response->request.status.status_code) : "-");
1289
1290     asl_release(m);
1291     return (1);
1292   }
1293
1294 #elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
1295   if (!strcmp(ErrorLog, "syslog"))
1296   {
1297     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) : "-");
1298     return (1);
1299   }
1300
1301 #elif defined(HAVE_VSYSLOG)
1302  /*
1303   * See if we are logging accesses via syslog...
1304   */
1305
1306   if (!strcmp(AccessLog, "syslog"))
1307   {
1308     syslog(LOG_INFO,
1309            "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
1310            con->http->hostname, con->username[0] != '\0' ? con->username : "-",
1311            states[con->operation], _httpEncodeURI(temp, con->uri, sizeof(temp)),
1312            con->http->version / 100, con->http->version % 100,
1313            code, CUPS_LLCAST con->bytes,
1314            con->request ?
1315                ippOpString(con->request->request.op.operation_id) : "-",
1316            con->response ?
1317                ippErrorString(con->response->request.status.status_code) : "-");
1318
1319     return (1);
1320   }
1321 #endif /* HAVE_ASL_H */
1322
1323  /*
1324   * Not using syslog; check the log file...
1325   */
1326
1327   if (!cupsdCheckLogFile(&AccessFile, AccessLog))
1328     return (0);
1329
1330  /*
1331   * Write a log of the request in "common log format"...
1332   */
1333
1334   cupsFilePrintf(AccessFile,
1335                  "%s - %s %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
1336                  con->http->hostname,
1337                  con->username[0] != '\0' ? con->username : "-",
1338                  cupsdGetDateTime(&(con->start), LogTimeFormat),
1339                  states[con->operation],
1340                  _httpEncodeURI(temp, con->uri, sizeof(temp)),
1341                  con->http->version / 100, con->http->version % 100,
1342                  code, CUPS_LLCAST con->bytes,
1343                  con->request ?
1344                      ippOpString(con->request->request.op.operation_id) : "-",
1345                  con->response ?
1346                      ippErrorString(con->response->request.status.status_code) :
1347                      "-");
1348
1349   cupsFileFlush(AccessFile);
1350
1351   return (1);
1352 }
1353
1354
1355 /*
1356  * 'cupsdWriteErrorLog()' - Write a line to the ErrorLog.
1357  */
1358
1359 int                                     /* O - 1 on success, 0 on failure */
1360 cupsdWriteErrorLog(int        level,    /* I - Log level */
1361                    const char *message) /* I - Message string */
1362 {
1363   int           ret = 1;                /* Return value */
1364   static const char     levels[] =      /* Log levels... */
1365                 {
1366                   ' ',
1367                   'X',
1368                   'A',
1369                   'C',
1370                   'E',
1371                   'W',
1372                   'N',
1373                   'I',
1374                   'D',
1375                   'd'
1376                 };
1377
1378
1379 #ifdef HAVE_ASL_H
1380   if (!strcmp(ErrorLog, "syslog"))
1381   {
1382     asl_object_t        m;              /* Log message */
1383
1384     m = asl_new(ASL_TYPE_MSG);
1385     asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
1386     asl_log(NULL, m, ASL_LEVEL_INFO, "%s", message);
1387
1388     asl_release(m);
1389     return (1);
1390   }
1391
1392 #elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
1393   if (!strcmp(ErrorLog, "syslog"))
1394   {
1395     sd_journal_print(log_levels[level], "%s", message);
1396     return (1);
1397   }
1398
1399 #elif defined(HAVE_VSYSLOG)
1400  /*
1401   * See if we are logging errors via syslog...
1402   */
1403
1404   if (!strcmp(ErrorLog, "syslog"))
1405   {
1406     syslog(log_levels[level], "%s", message);
1407     return (1);
1408   }
1409 #endif /* HAVE_ASL_H */
1410
1411  /*
1412   * Not using syslog; check the log file...
1413   */
1414
1415   _cupsMutexLock(&log_mutex);
1416
1417   if (!cupsdCheckLogFile(&ErrorFile, ErrorLog))
1418   {
1419     ret = 0;
1420   }
1421   else
1422   {
1423    /*
1424     * Write the log message...
1425     */
1426
1427     cupsFilePrintf(ErrorFile, "%c %s %s\n", levels[level],
1428                    cupsdGetDateTime(NULL, LogTimeFormat), message);
1429     cupsFileFlush(ErrorFile);
1430   }
1431
1432   _cupsMutexUnlock(&log_mutex);
1433
1434   return (ret);
1435 }
1436
1437
1438 /*
1439  * 'format_log_line()' - Format a line for a log file.
1440  *
1441  * This function resizes a global string buffer as needed.  Each call returns
1442  * a pointer to this buffer, so the contents are only good until the next call
1443  * to format_log_line()...
1444  */
1445
1446 static int                              /* O - -1 for fatal, 0 for retry, 1 for success */
1447 format_log_line(const char *message,    /* I - Printf-style format string */
1448                 va_list    ap)          /* I - Argument list */
1449 {
1450   ssize_t       len;                    /* Length of formatted line */
1451
1452
1453  /*
1454   * Allocate the line buffer as needed...
1455   */
1456
1457   if (!log_linesize)
1458   {
1459     log_linesize = 8192;
1460     log_line     = malloc(log_linesize);
1461
1462     if (!log_line)
1463       return (-1);
1464   }
1465
1466  /*
1467   * Format the log message...
1468   */
1469
1470   len = vsnprintf(log_line, log_linesize, message, ap);
1471
1472  /*
1473   * Resize the buffer as needed...
1474   */
1475
1476   if ((size_t)len >= log_linesize && log_linesize < 65536)
1477   {
1478     char        *temp;                  /* Temporary string pointer */
1479
1480
1481     len ++;
1482
1483     if (len < 8192)
1484       len = 8192;
1485     else if (len > 65536)
1486       len = 65536;
1487
1488     temp = realloc(log_line, (size_t)len);
1489
1490     if (temp)
1491     {
1492       log_line     = temp;
1493       log_linesize = (size_t)len;
1494
1495       return (0);
1496     }
1497   }
1498
1499   return (1);
1500 }
1501
1502
1503 /*
1504  * End of "$Id$".
1505  */