#include "cupsd.h"
#include <stdarg.h>
#ifdef HAVE_ASL_H
# include <asl.h>
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
# define SD_JOURNAL_SUPPRESS_LOCATION
# include <systemd/sd-journal.h>
#endif
#include <syslog.h>
#define PWG_DeviceUUID "DUU"
#define PWG_Event "E"
#define PWG_LogNaturalLanguage "NL"
#define PWG_Status "S"
#define PWG_ServiceURI "URI"
#define PWG_UserHost "UH"
#define PWG_UserName "UN"
#define PWG_UserURI "UU"
#define PWG_ServiceIsAcceptingJobs "IAJ"
#define PWG_ServiceState "ST"
#define PWG_ServiceStateReasons "SR"
#define PWG_ServiceUUID "SUU"
#define PWG_JobID "JID"
#define PWG_JobUUID "JUU"
#define PWG_JobImagesCompleted "JIM"
#define PWG_JobImpressionsCompleted "JIC"
#define PWG_JobDestinationURI "JD"
#define PWG_JobState "JS"
#define PWG_JobStateReasons "JR"
#define PWG_JobAccountingID "JA"
#define PWG_JobAcountingUserName "JAUN"
#define PWG_JobAccountingUserURI "JAUU"
static _cups_mutex_t log_mutex = _CUPS_MUTEX_INITIALIZER;
static size_t log_linesize = 0;
static char *log_line = NULL;
#ifdef HAVE_ASL_H
static const int log_levels[] =
{
ASL_LEVEL_EMERG,
ASL_LEVEL_EMERG,
ASL_LEVEL_ALERT,
ASL_LEVEL_CRIT,
ASL_LEVEL_ERR,
ASL_LEVEL_WARNING,
ASL_LEVEL_NOTICE,
ASL_LEVEL_INFO,
ASL_LEVEL_DEBUG,
ASL_LEVEL_DEBUG
};
#elif defined(HAVE_VSYSLOG) || defined(HAVE_SYSTEMD_SD_JOURNAL_H)
static const int log_levels[] =
{
0,
LOG_EMERG,
LOG_ALERT,
LOG_CRIT,
LOG_ERR,
LOG_WARNING,
LOG_NOTICE,
LOG_INFO,
LOG_DEBUG,
LOG_DEBUG
};
#endif
static int format_log_line(const char *message, va_list ap);
int
cupsdCheckLogFile(cups_file_t **lf,
const char *logname)
{
char backname[1024],
filename[1024],
*ptr;
const char *logptr;
if (!lf || !logname || !logname[0])
return (1);
if (!strcmp(logname, "stderr"))
{
*lf = LogStderr;
return (1);
}
if (!*lf ||
(strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
MaxLogSize > 0))
{
filename[sizeof(filename) - 1] = '\0';
if (logname[0] != '/')
{
strlcpy(filename, ServerRoot, sizeof(filename));
strlcat(filename, "/", sizeof(filename));
}
else
filename[0] = '\0';
for (logptr = logname, ptr = filename + strlen(filename);
*logptr && ptr < (filename + sizeof(filename) - 1);
logptr ++)
if (*logptr == '%')
{
logptr ++;
if (*logptr == 's')
{
strlcpy(ptr, ServerName, sizeof(filename) - (size_t)(ptr - filename));
ptr += strlen(ptr);
}
else
{
*ptr++ = *logptr;
}
}
else
*ptr++ = *logptr;
*ptr = '\0';
}
if (!*lf)
{
if ((*lf = cupsFileOpen(filename, "a")) == NULL)
{
if (!strncmp(filename, CUPS_LOGDIR, strlen(CUPS_LOGDIR)))
{
mode_t log_dir_perm = (mode_t)(0300 | LogFilePerm);
if (log_dir_perm & 0040)
log_dir_perm |= 0010;
if (log_dir_perm & 0004)
log_dir_perm |= 0001;
cupsdCheckPermissions(CUPS_LOGDIR, NULL, log_dir_perm, RunUser, Group, 1, -1);
*lf = cupsFileOpen(filename, "a");
}
if (*lf == NULL)
{
#ifdef HAVE_ASL_H
asl_object_t m;
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_log(NULL, m, ASL_LEVEL_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
asl_release(m);
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
sd_journal_print(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#else
syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#endif
if (FatalErrors & CUPSD_FATAL_LOG)
cupsdEndProcess(getpid(), 0);
return (0);
}
}
if (strncmp(filename, "/dev/", 5))
{
fchown(cupsFileNumber(*lf), RunUser, Group);
fchmod(cupsFileNumber(*lf), LogFilePerm);
}
}
if (strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
MaxLogSize > 0)
{
cupsFileClose(*lf);
strlcpy(backname, filename, sizeof(backname));
strlcat(backname, ".O", sizeof(backname));
unlink(backname);
rename(filename, backname);
if ((*lf = cupsFileOpen(filename, "a")) == NULL)
{
#ifdef HAVE_ASL_H
asl_object_t m;
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_log(NULL, m, ASL_LEVEL_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
asl_release(m);
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
sd_journal_print(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#else
syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#endif
if (FatalErrors & CUPSD_FATAL_LOG)
cupsdEndProcess(getpid(), 0);
return (0);
}
fchown(cupsFileNumber(*lf), RunUser, Group);
fchmod(cupsFileNumber(*lf), LogFilePerm);
}
return (1);
}
char *
cupsdGetDateTime(struct timeval *t,
cupsd_time_t format)
{
struct timeval curtime;
struct tm *date;
static struct timeval last_time = { 0, 0 };
static char s[1024];
static const char * const months[12] =
{
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
};
if (!t)
{
gettimeofday(&curtime, NULL);
t = &curtime;
}
if (t->tv_sec != last_time.tv_sec ||
(LogTimeFormat == CUPSD_TIME_USECS && t->tv_usec != last_time.tv_usec))
{
last_time = *t;
date = localtime(&(t->tv_sec));
if (format == CUPSD_TIME_STANDARD)
snprintf(s, sizeof(s), "[%02d/%s/%04d:%02d:%02d:%02d %+03ld%02ld]",
date->tm_mday, months[date->tm_mon], 1900 + date->tm_year,
date->tm_hour, date->tm_min, date->tm_sec,
#ifdef HAVE_TM_GMTOFF
date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
#else
timezone / 3600, (timezone / 60) % 60);
#endif
else
snprintf(s, sizeof(s), "[%02d/%s/%04d:%02d:%02d:%02d.%06d %+03ld%02ld]",
date->tm_mday, months[date->tm_mon], 1900 + date->tm_year,
date->tm_hour, date->tm_min, date->tm_sec, (int)t->tv_usec,
#ifdef HAVE_TM_GMTOFF
date->tm_gmtoff / 3600, (date->tm_gmtoff / 60) % 60);
#else
timezone / 3600, (timezone / 60) % 60);
#endif
}
return (s);
}
void
cupsdLogFCMessage(
void *context,
_cups_fc_result_t result,
const char *message)
{
cupsd_printer_t *p = (cupsd_printer_t *)context;
cupsd_loglevel_t level;
if (result == _CUPS_FILE_CHECK_OK)
level = CUPSD_LOG_DEBUG2;
else
level = CUPSD_LOG_ERROR;
if (p)
{
cupsdLogMessage(level, "%s: %s", p->name, message);
if (result == _CUPS_FILE_CHECK_MISSING ||
result == _CUPS_FILE_CHECK_WRONG_TYPE)
{
strlcpy(p->state_message, message, sizeof(p->state_message));
if (cupsdSetPrinterReasons(p, "+cups-missing-filter-warning"))
cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, p, NULL, "%s", message);
}
else if (result == _CUPS_FILE_CHECK_PERMISSIONS ||
result == _CUPS_FILE_CHECK_RELATIVE_PATH)
{
strlcpy(p->state_message, message, sizeof(p->state_message));
if (cupsdSetPrinterReasons(p, "+cups-insecure-filter-warning"))
cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, p, NULL, "%s", message);
}
}
else
cupsdLogMessage(level, "%s", message);
}
#ifdef HAVE_GSSAPI
int
cupsdLogGSSMessage(
int level,
OM_uint32 major_status,
OM_uint32 minor_status,
const char *message,
...)
{
OM_uint32 err_major_status,
err_minor_status;
OM_uint32 msg_ctx;
gss_buffer_desc major_status_string = GSS_C_EMPTY_BUFFER,
minor_status_string = GSS_C_EMPTY_BUFFER;
int ret;
char buffer[8192];
if (strchr(message, '%'))
{
va_list ap;
va_start(ap, message);
vsnprintf(buffer, sizeof(buffer), message, ap);
va_end(ap);
message = buffer;
}
msg_ctx = 0;
err_major_status = gss_display_status(&err_minor_status,
major_status,
GSS_C_GSS_CODE,
GSS_C_NO_OID,
&msg_ctx,
&major_status_string);
if (!GSS_ERROR(err_major_status))
gss_display_status(&err_minor_status, minor_status, GSS_C_MECH_CODE,
GSS_C_NULL_OID, &msg_ctx, &minor_status_string);
ret = cupsdLogMessage(level, "%s: %s, %s", message,
(char *)major_status_string.value,
(char *)minor_status_string.value);
gss_release_buffer(&err_minor_status, &major_status_string);
gss_release_buffer(&err_minor_status, &minor_status_string);
return (ret);
}
#endif
int
cupsdLogClient(cupsd_client_t *con,
int level,
const char *message,
...)
{
va_list ap, ap2;
char clientmsg[1024];
int status;
if (TestConfigFile || !ErrorLog)
return (1);
if (level > LogLevel)
return (1);
if (con)
snprintf(clientmsg, sizeof(clientmsg), "[Client %d] %s", con->number,
message);
else
strlcpy(clientmsg, message, sizeof(clientmsg));
va_start(ap, message);
do
{
va_copy(ap2, ap);
status = format_log_line(clientmsg, ap2);
va_end(ap2);
}
while (status == 0);
va_end(ap);
if (status > 0)
return (cupsdWriteErrorLog(level, log_line));
else
return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
"Unable to allocate memory for log line."));
}
int
cupsdLogJob(cupsd_job_t *job,
int level,
const char *message,
...)
{
va_list ap, ap2;
char jobmsg[1024];
int status;
if (TestConfigFile || !ErrorLog)
return (1);
if (level > LogLevel && LogDebugHistory <= 0)
return (1);
#ifdef HAVE_ASL_H
if (!strcmp(ErrorLog, "syslog"))
{
asl_object_t m;
char job_id[32],
completed[32];
cupsd_printer_t *printer = job ? (job->printer ? job->printer : (job->dest ? cupsdFindDest(job->dest) : NULL)) : NULL;
static const char * const job_states[] =
{
"Pending",
"PendingHeld",
"Processing",
"ProcessingStopped",
"Canceled",
"Aborted",
"Completed"
};
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
if (printer)
asl_set(m, PWG_ServiceURI, printer->uri);
if (job)
{
snprintf(job_id, sizeof(job_id), "%d", job->id);
asl_set(m, PWG_Event, "JobStateChanged");
asl_set(m, PWG_JobID, job_id);
asl_set(m, PWG_JobState, job->state_value < IPP_JSTATE_PENDING ? "" : job_states[job->state_value - IPP_JSTATE_PENDING]);
if (job->impressions)
{
snprintf(completed, sizeof(completed), "%d", ippGetInteger(job->impressions, 0));
asl_set(m, PWG_JobImpressionsCompleted, completed);
}
}
va_start(ap, message);
asl_vlog(NULL, m, log_levels[level], message, ap);
va_end(ap);
asl_release(m);
return (1);
}
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
if (!strcmp(ErrorLog, "syslog"))
{
cupsd_printer_t *printer = job ? (job->printer ? job->printer : (job->dest ? cupsdFindDest(job->dest) : NULL)) : NULL;
static const char * const job_states[] =
{
"Pending",
"PendingHeld",
"Processing",
"ProcessingStopped",
"Canceled",
"Aborted",
"Completed"
};
va_start(ap, message);
do
{
va_copy(ap2, ap);
status = format_log_line(message, ap2);
va_end(ap2);
}
while (status == 0);
va_end(ap);
if (job)
sd_journal_send("MESSAGE=%s", log_line,
"PRIORITY=%i", log_levels[level],
PWG_Event"=JobStateChanged",
PWG_ServiceURI"=%s", printer ? printer->uri : "",
PWG_JobID"=%d", job->id,
PWG_JobState"=%s", job->state_value < IPP_JSTATE_PENDING ? "" : job_states[job->state_value - IPP_JSTATE_PENDING],
PWG_JobImpressionsCompleted"=%d", ippGetInteger(job->impressions, 0),
NULL);
else
sd_journal_send("MESSAGE=%s", log_line,
"PRIORITY=%i", log_levels[level],
NULL);
return (1);
}
#endif
if (job)
snprintf(jobmsg, sizeof(jobmsg), "[Job %d] %s", job->id, message);
else
strlcpy(jobmsg, message, sizeof(jobmsg));
va_start(ap, message);
do
{
va_copy(ap2, ap);
status = format_log_line(jobmsg, ap2);
va_end(ap2);
}
while (status == 0);
va_end(ap);
if (status > 0)
{
if (job && level > LogLevel && LogDebugHistory > 0)
{
cupsd_joblog_t *temp;
size_t log_len = strlen(log_line);
if ((temp = malloc(sizeof(cupsd_joblog_t) + log_len)) != NULL)
{
temp->time = time(NULL);
memcpy(temp->message, log_line, log_len + 1);
}
if (!job->history)
job->history = cupsArrayNew(NULL, NULL);
if (job->history && temp)
{
cupsArrayAdd(job->history, temp);
if (cupsArrayCount(job->history) > LogDebugHistory)
{
temp = cupsArrayFirst(job->history);
cupsArrayRemove(job->history, temp);
free(temp);
}
}
else if (temp)
free(temp);
return (1);
}
else if (level <= LogLevel)
return (cupsdWriteErrorLog(level, log_line));
else
return (1);
}
else
return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
"Unable to allocate memory for log line."));
}
int
cupsdLogMessage(int level,
const char *message,
...)
{
va_list ap, ap2;
int status;
if ((TestConfigFile || !ErrorLog) && level <= CUPSD_LOG_WARN)
{
va_start(ap, message);
#ifdef HAVE_ASL_H
asl_object_t m;
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_vlog(NULL, m, log_levels[level], message, ap);
asl_release(m);
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
sd_journal_printv(log_levels[level], message, ap);
#elif defined(HAVE_VSYSLOG)
vsyslog(LOG_LPR | log_levels[level], message, ap);
#else
vfprintf(stderr, message, ap);
putc('\n', stderr);
#endif
va_end(ap);
return (1);
}
if (level > LogLevel || !ErrorLog)
return (1);
#ifdef HAVE_ASL_H
if (!strcmp(ErrorLog, "syslog"))
{
asl_object_t m;
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
va_start(ap, message);
asl_vlog(NULL, m, log_levels[level], message, ap);
va_end(ap);
asl_release(m);
return (1);
}
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
if (!strcmp(ErrorLog, "syslog"))
{
va_start(ap, message);
sd_journal_printv(log_levels[level], message, ap);
va_end(ap);
return (1);
}
#endif
va_start(ap, message);
do
{
va_copy(ap2, ap);
status = format_log_line(message, ap2);
va_end(ap2);
}
while (status == 0);
va_end(ap);
if (status > 0)
return (cupsdWriteErrorLog(level, log_line));
else
return (cupsdWriteErrorLog(CUPSD_LOG_ERROR,
"Unable to allocate memory for log line!"));
}
int
cupsdLogPage(cupsd_job_t *job,
const char *page)
{
int i;
char buffer[2048],
*bufptr,
name[256];
const char *format,
*nameend;
ipp_attribute_t *attr;
char number[256];
int copies;
if (!PageLogFormat)
return (1);
strlcpy(number, "1", sizeof(number));
copies = 1;
sscanf(page, "%255s%d", number, &copies);
for (format = PageLogFormat, bufptr = buffer; *format; format ++)
{
if (*format == '%')
{
format ++;
switch (*format)
{
case '%' :
if (bufptr < (buffer + sizeof(buffer) - 1))
*bufptr++ = '%';
break;
case 'p' :
strlcpy(bufptr, job->dest, sizeof(buffer) - (size_t)(bufptr - buffer));
bufptr += strlen(bufptr);
break;
case 'j' :
snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", job->id);
bufptr += strlen(bufptr);
break;
case 'u' :
strlcpy(bufptr, job->username ? job->username : "-", sizeof(buffer) - (size_t)(bufptr - buffer));
bufptr += strlen(bufptr);
break;
case 'T' :
strlcpy(bufptr, cupsdGetDateTime(NULL, LogTimeFormat), sizeof(buffer) - (size_t)(bufptr - buffer));
bufptr += strlen(bufptr);
break;
case 'P' :
strlcpy(bufptr, number, sizeof(buffer) - (size_t)(bufptr - buffer));
bufptr += strlen(bufptr);
break;
case 'C' :
snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", copies);
bufptr += strlen(bufptr);
break;
case '{' :
if ((nameend = strchr(format, '}')) != NULL && (size_t)(nameend - format - 2) < (sizeof(name) - 1))
{
memcpy(name, format + 1, (size_t)(nameend - format - 1));
name[nameend - format - 1] = '\0';
format = nameend;
attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO);
if (!attr && !strcmp(name, "job-billing"))
{
attr = ippFindAttribute(job->attrs, "job-account-id", IPP_TAG_ZERO);
}
else if (!attr && !strcmp(name, "media"))
{
attr = ippFindAttribute(job->attrs, "media-col/media-size", IPP_TAG_BEGIN_COLLECTION);
}
if (attr)
{
for (i = 0;
i < attr->num_values &&
bufptr < (buffer + sizeof(buffer) - 1);
i ++)
{
if (i)
*bufptr++ = ',';
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", attr->values[i].integer);
bufptr += strlen(bufptr);
break;
case IPP_TAG_BOOLEAN :
snprintf(bufptr, sizeof(buffer) - (size_t)(bufptr - buffer), "%d", attr->values[i].boolean);
bufptr += strlen(bufptr);
break;
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_URI :
case IPP_TAG_URISCHEME :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_MIMETYPE :
strlcpy(bufptr, attr->values[i].string.text, sizeof(buffer) - (size_t)(bufptr - buffer));
bufptr += strlen(bufptr);
break;
case IPP_TAG_BEGIN_COLLECTION :
if (!strcmp(attr->name, "media-size"))
{
ipp_attribute_t *x_dimension = ippFindAttribute(ippGetCollection(attr, 0), "x-dimension", IPP_TAG_INTEGER);
ipp_attribute_t *y_dimension = ippFindAttribute(ippGetCollection(attr, 0), "y-dimension", IPP_TAG_INTEGER);
if (x_dimension && y_dimension)
{
pwg_media_t *pwg = pwgMediaForSize(ippGetInteger(x_dimension, 0), ippGetInteger(y_dimension, 0));
strlcpy(bufptr, pwg->pwg, sizeof(buffer) - (size_t)(bufptr - buffer));
break;
}
}
default :
strlcpy(bufptr, "???", sizeof(buffer) - (size_t)(bufptr - buffer));
bufptr += strlen(bufptr);
break;
}
}
}
else if (bufptr < (buffer + sizeof(buffer) - 1))
*bufptr++ = '-';
break;
}
default :
if (bufptr < (buffer + sizeof(buffer) - 2))
{
*bufptr++ = '%';
*bufptr++ = *format;
}
break;
}
}
else if (bufptr < (buffer + sizeof(buffer) - 1))
*bufptr++ = *format;
}
*bufptr = '\0';
#ifdef HAVE_ASL_H
if (!strcmp(ErrorLog, "syslog"))
{
asl_object_t m;
char job_id[32],
completed[32];
static const char * const job_states[] =
{
"Pending",
"PendingHeld",
"Processing",
"ProcessingStopped",
"Canceled",
"Aborted",
"Completed"
};
snprintf(job_id, sizeof(job_id), "%d", job->id);
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_set(m, PWG_Event, "JobStateChanged");
asl_set(m, PWG_ServiceURI, job->printer->uri);
asl_set(m, PWG_JobID, job_id);
asl_set(m, PWG_JobState, job_states[job->state_value - IPP_JSTATE_PENDING]);
if (job->impressions)
{
snprintf(completed, sizeof(completed), "%d", ippGetInteger(job->impressions, 0));
asl_set(m, PWG_JobImpressionsCompleted, completed);
}
asl_log(NULL, m, ASL_LEVEL_INFO, "%s", buffer);
asl_release(m);
return (1);
}
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
if (!strcmp(ErrorLog, "syslog"))
{
static const char * const job_states[] =
{
"Pending",
"PendingHeld",
"Processing",
"ProcessingStopped",
"Canceled",
"Aborted",
"Completed"
};
sd_journal_send("MESSAGE=%s", buffer,
"PRIORITY=%i", LOG_INFO,
PWG_Event"=JobStateChanged",
PWG_ServiceURI"=%s", job->printer->uri,
PWG_JobID"=%d", job->id,
PWG_JobState"=%s", job_states[job->state_value - IPP_JSTATE_PENDING],
PWG_JobImpressionsCompleted"=%d", ippGetInteger(job->impressions, 0),
NULL);
return (1);
}
#elif defined(HAVE_VSYSLOG)
if (!strcmp(PageLog, "syslog"))
{
syslog(LOG_INFO, "%s", buffer);
return (1);
}
#endif
if (!cupsdCheckLogFile(&PageFile, PageLog))
return (0);
cupsFilePrintf(PageFile, "%s\n", buffer);
cupsFileFlush(PageFile);
return (1);
}
int
cupsdLogRequest(cupsd_client_t *con,
http_status_t code)
{
char temp[2048];
static const char * const states[] =
{
"WAITING",
"OPTIONS",
"GET",
"GET",
"HEAD",
"POST",
"POST",
"POST",
"PUT",
"PUT",
"DELETE",
"TRACE",
"CLOSE",
"STATUS"
};
if (AccessLogLevel == CUPSD_ACCESSLOG_NONE)
return (1);
else if (AccessLogLevel < CUPSD_ACCESSLOG_ALL)
{
if ((con->operation == HTTP_GET &&
strncmp(con->uri, "/admin/conf", 11) &&
strncmp(con->uri, "/admin/log", 10)) ||
(con->operation == HTTP_POST && !con->request &&
strncmp(con->uri, "/admin", 6)) ||
(con->operation != HTTP_GET && con->operation != HTTP_POST &&
con->operation != HTTP_PUT))
return (1);
if (con->request && con->response &&
(con->response->request.status.status_code < IPP_REDIRECTION_OTHER_SITE ||
con->response->request.status.status_code == IPP_NOT_FOUND))
{
ipp_op_t op = con->request->request.op.operation_id;
static cupsd_accesslog_t standard_ops[] =
{
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS
};
static cupsd_accesslog_t cups_ops[] =
{
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_ALL,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_CONFIG,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ACTIONS,
CUPSD_ACCESSLOG_ALL
};
if ((op <= IPP_SCHEDULE_JOB_AFTER && standard_ops[op] > AccessLogLevel) ||
(op >= CUPS_GET_DEFAULT && op <= CUPS_GET_PPD &&
cups_ops[op - CUPS_GET_DEFAULT] > AccessLogLevel))
return (1);
}
}
#ifdef HAVE_ASL_H
if (!strcmp(ErrorLog, "syslog"))
{
asl_object_t m;
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_log(NULL, m, ASL_LEVEL_INFO, "REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
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) : "-");
asl_release(m);
return (1);
}
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
if (!strcmp(ErrorLog, "syslog"))
{
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) : "-");
return (1);
}
#elif defined(HAVE_VSYSLOG)
if (!strcmp(AccessLog, "syslog"))
{
syslog(LOG_INFO,
"REQUEST %s - %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
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) : "-");
return (1);
}
#endif
if (!cupsdCheckLogFile(&AccessFile, AccessLog))
return (0);
cupsFilePrintf(AccessFile,
"%s - %s %s \"%s %s HTTP/%d.%d\" %d " CUPS_LLFMT " %s %s\n",
con->http->hostname,
con->username[0] != '\0' ? con->username : "-",
cupsdGetDateTime(&(con->start), LogTimeFormat),
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) :
"-");
cupsFileFlush(AccessFile);
return (1);
}
int
cupsdWriteErrorLog(int level,
const char *message)
{
int ret = 1;
static const char levels[] =
{
' ',
'X',
'A',
'C',
'E',
'W',
'N',
'I',
'D',
'd'
};
#ifdef HAVE_ASL_H
if (!strcmp(ErrorLog, "syslog"))
{
asl_object_t m;
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_log(NULL, m, ASL_LEVEL_INFO, "%s", message);
asl_release(m);
return (1);
}
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
if (!strcmp(ErrorLog, "syslog"))
{
sd_journal_print(log_levels[level], "%s", message);
return (1);
}
#elif defined(HAVE_VSYSLOG)
if (!strcmp(ErrorLog, "syslog"))
{
syslog(log_levels[level], "%s", message);
return (1);
}
#endif
_cupsMutexLock(&log_mutex);
if (!cupsdCheckLogFile(&ErrorFile, ErrorLog))
{
ret = 0;
}
else
{
cupsFilePrintf(ErrorFile, "%c %s %s\n", levels[level],
cupsdGetDateTime(NULL, LogTimeFormat), message);
cupsFileFlush(ErrorFile);
}
_cupsMutexUnlock(&log_mutex);
return (ret);
}
static int
format_log_line(const char *message,
va_list ap)
{
ssize_t len;
if (!log_linesize)
{
log_linesize = 8192;
log_line = malloc(log_linesize);
if (!log_line)
return (-1);
}
len = _cups_safe_vsnprintf(log_line, log_linesize, message, ap);
if ((size_t)len >= log_linesize && log_linesize < 65536)
{
char *temp;
len ++;
if (len < 8192)
len = 8192;
else if (len > 65536)
len = 65536;
temp = realloc(log_line, (size_t)len);
if (temp)
{
log_line = temp;
log_linesize = (size_t)len;
return (0);
}
}
return (1);
}