#include "cupsd.h"
#include <grp.h>
#include <cups/backend.h>
#include <cups/dir.h>
static mime_filter_t gziptoany_filter =
{
NULL,
NULL,
0,
"gziptoany"
};
static int compare_active_jobs(void *first, void *second, void *data);
static int compare_jobs(void *first, void *second, void *data);
static int ipp_length(ipp_t *ipp);
static void load_job_cache(const char *filename);
static void load_next_job_id(const char *filename);
static void load_request_root(void);
static void set_time(cupsd_job_t *job, const char *name);
static void set_hold_until(cupsd_job_t *job, time_t holdtime);
static void start_job(cupsd_job_t *job, cupsd_printer_t *printer);
static void unload_job(cupsd_job_t *job);
static void update_job(cupsd_job_t *job);
static void update_job_attrs(cupsd_job_t *job);
cupsd_job_t *
cupsdAddJob(int priority,
const char *dest)
{
cupsd_job_t *job;
if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
return (NULL);
job->id = NextJobId ++;
job->priority = priority;
job->back_pipes[0] = -1;
job->back_pipes[1] = -1;
job->print_pipes[0] = -1;
job->print_pipes[1] = -1;
job->side_pipes[0] = -1;
job->side_pipes[1] = -1;
job->status_pipes[0] = -1;
job->status_pipes[1] = -1;
cupsdSetString(&job->dest, dest);
cupsArrayAdd(Jobs, job);
cupsArrayAdd(ActiveJobs, job);
return (job);
}
void
cupsdCancelJob(cupsd_job_t *job,
int purge,
ipp_jstate_t newstate)
{
int i;
char filename[1024];
cupsd_printer_t *printer;
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCancelJob: id = %d", job->id);
printer = job->printer;
if (job->state_value == IPP_JOB_PROCESSING)
cupsdStopJob(job, 0);
cupsdLoadJob(job);
if (job->attrs)
job->state->values[0].integer = newstate;
job->state_value = newstate;
set_time(job, "time-at-completed");
switch (newstate)
{
default :
break;
case IPP_JOB_CANCELED :
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, printer, job,
purge ? "Job purged." : "Job canceled.");
break;
case IPP_JOB_ABORTED :
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, printer, job,
"Job aborted; please consult the error_log file "
"for details.");
break;
case IPP_JOB_COMPLETED :
printer->state_message[0] = '\0';
cupsdSetPrinterState(printer, IPP_PRINTER_IDLE, 0);
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, printer, job,
"Job completed.");
break;
}
cupsdExpireSubscriptions(NULL, job);
cupsArrayRemove(ActiveJobs, job);
snprintf(filename, sizeof(filename), "%s/a%05d", RequestRoot, job->id);
if (cupsdRemoveFile(filename) && errno != ENOENT)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to remove authentication cache: %s",
strerror(errno));
cupsdClearString(&job->auth_username);
cupsdClearString(&job->auth_domain);
cupsdClearString(&job->auth_password);
#ifdef HAVE_GSSAPI
if (job->ccache)
{
krb5_cc_destroy(KerberosContext, job->ccache);
job->ccache = NULL;
}
cupsdClearString(&job->ccname);
#endif
job->current_file = 0;
if (!JobHistory || !JobFiles || purge)
{
for (i = 1; i <= job->num_files; i ++)
{
snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
job->id, i);
unlink(filename);
}
if (job->num_files > 0)
{
free(job->filetypes);
free(job->compressions);
job->num_files = 0;
job->filetypes = NULL;
job->compressions = NULL;
}
}
if (JobHistory && !purge)
{
cupsdSaveJob(job);
}
else
{
snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot,
job->id);
unlink(filename);
cupsArrayRemove(Jobs, job);
cupsdDeleteJob(job);
}
}
void
cupsdCancelJobs(const char *dest,
const char *username,
int purge)
{
cupsd_job_t *job;
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
job;
job = (cupsd_job_t *)cupsArrayNext(Jobs))
{
if (!job->dest || !job->username)
cupsdLoadJob(job);
if (!job->dest || !job->username)
continue;
if ((dest == NULL || !strcmp(job->dest, dest)) &&
(username == NULL || !strcmp(job->username, username)))
{
cupsdCancelJob(job, purge, IPP_JOB_CANCELED);
}
}
cupsdCheckJobs();
}
void
cupsdCheckJobs(void)
{
cupsd_job_t *job;
cupsd_printer_t *printer,
*pclass;
ipp_attribute_t *attr;
DEBUG_puts("cupsdCheckJobs()");
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"cupsdCheckJobs: %d active jobs, sleeping=%d, reload=%d",
cupsArrayCount(ActiveJobs), Sleeping, NeedReload);
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"cupsdCheckJobs: Job %d: state_value=%d, loaded=%s",
job->id, job->state_value, job->attrs ? "yes" : "no");
if (job->state_value == IPP_JOB_HELD &&
job->hold_until &&
job->hold_until < time(NULL))
{
if (job->pending_timeout)
{
if (cupsdTimeoutJob(job))
continue;
}
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
IPP_TAG_KEYWORD)) == NULL)
attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
if (attr)
{
attr->value_tag = IPP_TAG_KEYWORD;
cupsdSetString(&(attr->values[0].string.text), "no-hold");
cupsdSaveJob(job);
}
}
if (job->state_value == IPP_JOB_PENDING && !NeedReload && !Sleeping)
{
printer = cupsdFindDest(job->dest);
pclass = NULL;
while (printer &&
(printer->type & (CUPS_PRINTER_IMPLICIT | CUPS_PRINTER_CLASS)))
{
pclass = printer;
if (pclass->state == IPP_PRINTER_STOPPED)
printer = NULL;
else if (pclass->type & CUPS_PRINTER_REMOTE)
break;
else
printer = cupsdFindAvailablePrinter(printer->name);
}
if (!printer && !pclass)
{
cupsdLogMessage(CUPSD_LOG_WARN,
"[Job %d] Printer/class %s has gone away; canceling job!",
job->id, job->dest);
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the destination printer/class has "
"gone away.");
cupsdCancelJob(job, 1, IPP_JOB_ABORTED);
}
else if (printer)
{
if (pclass)
{
if ((attr = ippFindAttribute(job->attrs, "job-actual-printer-uri",
IPP_TAG_URI)) != NULL)
cupsdSetString(&attr->values[0].string.text, printer->uri);
else
ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_URI,
"job-actual-printer-uri", NULL, printer->uri);
}
if ((!(printer->type & CUPS_PRINTER_DISCOVERED) &&
printer->state == IPP_PRINTER_IDLE) ||
((printer->type & CUPS_PRINTER_DISCOVERED) &&
!printer->job))
{
printer->state_message[0] = '\0';
cupsdSetPrinterReasons(printer, "none");
start_job(job, printer);
}
}
}
}
}
void
cupsdCleanJobs(void)
{
cupsd_job_t *job;
if (MaxJobs <= 0)
return;
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
job && cupsArrayCount(Jobs) >= MaxJobs;
job = (cupsd_job_t *)cupsArrayNext(Jobs))
if (job->state_value >= IPP_JOB_CANCELED)
cupsdCancelJob(job, 1, IPP_JOB_CANCELED);
}
void
cupsdDeleteJob(cupsd_job_t *job)
{
cupsdClearString(&job->username);
cupsdClearString(&job->dest);
cupsdClearString(&job->auth_username);
cupsdClearString(&job->auth_domain);
cupsdClearString(&job->auth_password);
#ifdef HAVE_GSSAPI
if (job->ccache)
{
krb5_cc_destroy(KerberosContext, job->ccache);
job->ccache = NULL;
}
cupsdClearString(&job->ccname);
#endif
if (job->num_files > 0)
{
free(job->compressions);
free(job->filetypes);
}
ippDelete(job->attrs);
free(job);
}
void
cupsdFinishJob(cupsd_job_t *job)
{
cupsd_printer_t *printer;
ipp_attribute_t *attr;
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] File %d is complete.",
job->id, job->current_file - 1);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] cupsdFinishJob: job->status is %d",
job->id, job->status);
if (job->status_buffer &&
(job->status < 0 || job->current_file >= job->num_files))
{
cupsdRemoveSelect(job->status_buffer->fd);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] cupsdFinishJob: Closing status pipes [ %d %d ]...",
job->id, job->status_pipes[0], job->status_pipes[1]);
cupsdClosePipe(job->status_pipes);
cupsdStatBufDelete(job->status_buffer);
job->status_buffer = NULL;
}
printer = job->printer;
update_job_attrs(job);
if (job->status < 0)
{
int exit_code;
exit_code = -job->status;
if (WIFEXITED(exit_code))
exit_code = WEXITSTATUS(exit_code);
else
exit_code = job->status;
cupsdLogMessage(CUPSD_LOG_INFO, "[Job %d] Backend returned status %d (%s)",
job->id, exit_code,
exit_code == CUPS_BACKEND_FAILED ? "failed" :
exit_code == CUPS_BACKEND_AUTH_REQUIRED ?
"authentication required" :
exit_code == CUPS_BACKEND_HOLD ? "hold job" :
exit_code == CUPS_BACKEND_STOP ? "stop printer" :
exit_code == CUPS_BACKEND_CANCEL ? "cancel job" :
exit_code < 0 ? "crashed" : "unknown");
switch (exit_code)
{
default :
case CUPS_BACKEND_FAILED :
cupsdStopJob(job, 0);
if (job->dtype & (CUPS_PRINTER_CLASS | CUPS_PRINTER_IMPLICIT))
{
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
}
cupsdSaveJob(job);
if (job->dtype & (CUPS_PRINTER_CLASS | CUPS_PRINTER_IMPLICIT))
cupsdCheckJobs();
else if ((printer->type & CUPS_PRINTER_FAX) ||
!strcmp(printer->error_policy, "retry-job"))
{
job->tries ++;
if (job->tries >= JobRetryLimit)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Canceling job since it could not be "
"sent after %d tries.",
job->id, JobRetryLimit);
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
}
else
{
set_hold_until(job, time(NULL) + JobRetryInterval);
cupsdAddEvent(CUPSD_EVENT_JOB_STATE, job->printer, job,
"Job held due to fax errors; please consult "
"the error_log file for details.");
cupsdSetPrinterState(printer, IPP_PRINTER_IDLE, 0);
}
}
else if (!strcmp(printer->error_policy, "abort-job"))
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
else
{
cupsdSetPrinterState(printer, IPP_PRINTER_STOPPED, 1);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, printer, job,
"Job stopped due to backend errors; please consult "
"the error_log file for details.");
}
break;
case CUPS_BACKEND_CANCEL :
cupsdCancelJob(job, 0, IPP_JOB_CANCELED);
break;
case CUPS_BACKEND_HOLD :
cupsdStopJob(job, 0);
cupsdSetJobHoldUntil(job, "indefinite");
job->state->values[0].integer = IPP_JOB_HELD;
job->state_value = IPP_JOB_HELD;
cupsdSaveJob(job);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, printer, job,
"Job held due to backend errors; please consult "
"the error_log file for details.");
break;
case CUPS_BACKEND_STOP :
cupsdStopJob(job, 0);
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
cupsdSaveJob(job);
cupsdSetPrinterState(printer, IPP_PRINTER_STOPPED, 1);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, printer, job,
"Job stopped due to backend errors; please consult "
"the error_log file for details.");
break;
case CUPS_BACKEND_AUTH_REQUIRED :
cupsdStopJob(job, 0);
cupsdSetJobHoldUntil(job, "auth-info-required");
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
IPP_TAG_KEYWORD)) == NULL)
attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
if (attr)
{
attr->value_tag = IPP_TAG_KEYWORD;
cupsdSetString(&(attr->values[0].string.text),
"auth-info-required");
}
job->state->values[0].integer = IPP_JOB_HELD;
job->state_value = IPP_JOB_HELD;
cupsdSaveJob(job);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, printer, job,
"Authentication is required for job %d.", job->id);
break;
}
cupsdCheckJobs();
}
else if (job->status > 0)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Job stopped due to filter errors.", job->id);
cupsdStopJob(job, 1);
cupsdSaveJob(job);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, printer, job,
"Job stopped due to filter errors; please consult the "
"error_log file for details.");
cupsdCheckJobs();
}
else
{
if (job->current_file < job->num_files)
{
FilterLevel -= job->cost;
start_job(job, printer);
}
else
{
cupsdLogMessage(CUPSD_LOG_INFO, "[Job %d] Completed successfully.",
job->id);
cupsdCancelJob(job, 0, IPP_JOB_COMPLETED);
cupsdCheckJobs();
}
}
}
void
cupsdFreeAllJobs(void)
{
cupsd_job_t *job;
if (!Jobs)
return;
cupsdHoldSignals();
cupsdStopAllJobs(1);
cupsdSaveAllJobs();
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
job;
job = (cupsd_job_t *)cupsArrayNext(Jobs))
{
cupsArrayRemove(Jobs, job);
cupsArrayRemove(ActiveJobs, job);
cupsdDeleteJob(job);
}
cupsdReleaseSignals();
}
cupsd_job_t *
cupsdFindJob(int id)
{
cupsd_job_t key;
key.id = id;
return ((cupsd_job_t *)cupsArrayFind(Jobs, &key));
}
int
cupsdGetPrinterJobCount(
const char *dest)
{
int count;
cupsd_job_t *job;
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
if (job->dest && !strcasecmp(job->dest, dest))
count ++;
return (count);
}
int
cupsdGetUserJobCount(
const char *username)
{
int count;
cupsd_job_t *job;
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
if (!strcasecmp(job->username, username))
count ++;
return (count);
}
void
cupsdHoldJob(cupsd_job_t *job)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdHoldJob: id = %d", job->id);
if (job->state_value == IPP_JOB_PROCESSING)
cupsdStopJob(job, 0);
else
cupsdLoadJob(job);
DEBUG_puts("cupsdHoldJob: setting state to held...");
job->state->values[0].integer = IPP_JOB_HELD;
job->state_value = IPP_JOB_HELD;
job->current_file = 0;
cupsdSaveJob(job);
}
void
cupsdLoadAllJobs(void)
{
char filename[1024];
struct stat fileinfo,
dirinfo;
if (!Jobs)
Jobs = cupsArrayNew(compare_jobs, NULL);
if (!ActiveJobs)
ActiveJobs = cupsArrayNew(compare_active_jobs, NULL);
snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
if (stat(filename, &fileinfo))
{
fileinfo.st_mtime = 0;
if (errno != ENOENT)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to get file information for \"%s\" - %s",
filename, strerror(errno));
}
if (stat(RequestRoot, &dirinfo))
{
dirinfo.st_mtime = 0;
if (errno != ENOENT)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to get directory information for \"%s\" - %s",
RequestRoot, strerror(errno));
}
if (dirinfo.st_mtime > fileinfo.st_mtime)
{
load_request_root();
load_next_job_id(filename);
}
else
load_job_cache(filename);
if (MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs)
cupsdCleanJobs();
}
int
cupsdLoadJob(cupsd_job_t *job)
{
char jobfile[1024];
cups_file_t *fp;
int fileid;
ipp_attribute_t *attr;
const char *dest;
cupsd_printer_t *destptr;
mime_type_t **filetypes;
int *compressions;
if (job->attrs)
{
if (job->state_value > IPP_JOB_STOPPED)
job->access_time = time(NULL);
return (1);
}
if ((job->attrs = ippNew()) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Ran out of memory for job attributes!", job->id);
return (0);
}
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] Loading attributes...", job->id);
snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, job->id);
if ((fp = cupsFileOpen(jobfile, "r")) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to open job control file \"%s\" - %s!",
job->id, jobfile, strerror(errno));
goto error;
}
if (ippReadIO(fp, (ipp_iocb_t)cupsFileRead, 1, NULL, job->attrs) != IPP_DATA)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to read job control file \"%s\"!",
job->id, jobfile);
cupsFileClose(fp);
goto error;
}
cupsFileClose(fp);
if (!ippFindAttribute(job->attrs, "time-at-creation", IPP_TAG_INTEGER))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Missing or bad time-at-creation attribute in "
"control file!", job->id);
goto error;
}
if ((job->state = ippFindAttribute(job->attrs, "job-state",
IPP_TAG_ENUM)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Missing or bad job-state attribute in "
"control file!",
job->id);
goto error;
}
job->state_value = (ipp_jstate_t)job->state->values[0].integer;
if (!job->dest)
{
if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
IPP_TAG_URI)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] No job-printer-uri attribute in control file!",
job->id);
goto error;
}
if ((dest = cupsdValidateDest(attr->values[0].string.text, &(job->dtype),
&destptr)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to queue job for destination \"%s\"!",
job->id, attr->values[0].string.text);
goto error;
}
cupsdSetString(&job->dest, dest);
}
else if ((destptr = cupsdFindDest(job->dest)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to queue job for destination \"%s\"!",
job->id, job->dest);
goto error;
}
job->sheets = ippFindAttribute(job->attrs, "job-media-sheets-completed",
IPP_TAG_INTEGER);
job->job_sheets = ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_NAME);
if (!job->priority)
{
if ((attr = ippFindAttribute(job->attrs, "job-priority",
IPP_TAG_INTEGER)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Missing or bad job-priority attribute in "
"control file!", job->id);
goto error;
}
job->priority = attr->values[0].integer;
}
if (!job->username)
{
if ((attr = ippFindAttribute(job->attrs, "job-originating-user-name",
IPP_TAG_NAME)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Missing or bad job-originating-user-name "
"attribute in control file!", job->id);
goto error;
}
cupsdSetString(&job->username, attr->values[0].string.text);
}
if (job->state_value == IPP_JOB_HELD)
{
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
IPP_TAG_KEYWORD)) == NULL)
attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
if (attr)
cupsdSetJobHoldUntil(job, attr->values[0].string.text);
else
{
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
}
}
else if (job->state_value == IPP_JOB_PROCESSING)
{
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
}
if (!job->num_files)
{
for (fileid = 1; fileid < 10000; fileid ++)
{
snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
job->id, fileid);
if (access(jobfile, 0))
break;
cupsdLogMessage(CUPSD_LOG_DEBUG,
"[Job %d] Auto-typing document file \"%s\"...",
job->id, jobfile);
if (fileid > job->num_files)
{
if (job->num_files == 0)
{
compressions = (int *)calloc(fileid, sizeof(int));
filetypes = (mime_type_t **)calloc(fileid, sizeof(mime_type_t *));
}
else
{
compressions = (int *)realloc(job->compressions,
sizeof(int) * fileid);
filetypes = (mime_type_t **)realloc(job->filetypes,
sizeof(mime_type_t *) *
fileid);
}
if (!compressions || !filetypes)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Ran out of memory for job file types!",
job->id);
return (1);
}
job->compressions = compressions;
job->filetypes = filetypes;
job->num_files = fileid;
}
job->filetypes[fileid - 1] = mimeFileType(MimeDatabase, jobfile, NULL,
job->compressions + fileid - 1);
if (!job->filetypes[fileid - 1])
job->filetypes[fileid - 1] = mimeType(MimeDatabase, "application",
"vnd.cups-raw");
}
}
if (job->state_value < IPP_JOB_STOPPED)
{
snprintf(jobfile, sizeof(jobfile), "%s/a%05d", RequestRoot, job->id);
cupsdClearString(&job->auth_username);
cupsdClearString(&job->auth_domain);
cupsdClearString(&job->auth_password);
if ((fp = cupsFileOpen(jobfile, "r")) != NULL)
{
int i,
bytes;
char line[255],
data[255];
for (i = 0;
i < destptr->num_auth_info_required &&
cupsFileGets(fp, line, sizeof(line));
i ++)
{
bytes = sizeof(data);
httpDecode64_2(data, &bytes, line);
if (!strcmp(destptr->auth_info_required[i], "username"))
cupsdSetStringf(&job->auth_username, "AUTH_USERNAME=%s", data);
else if (!strcmp(destptr->auth_info_required[i], "domain"))
cupsdSetStringf(&job->auth_domain, "AUTH_DOMAIN=%s", data);
else if (!strcmp(destptr->auth_info_required[i], "password"))
cupsdSetStringf(&job->auth_password, "AUTH_PASSWORD=%s", data);
}
cupsFileClose(fp);
}
}
job->access_time = time(NULL);
return (1);
error:
ippDelete(job->attrs);
job->attrs = NULL;
unlink(jobfile);
return (0);
}
void
cupsdMoveJob(cupsd_job_t *job,
cupsd_printer_t *p)
{
ipp_attribute_t *attr;
const char *olddest;
cupsd_printer_t *oldp;
if (job->state_value > IPP_JOB_STOPPED)
return;
olddest = job->dest;
if (job->printer)
oldp = job->printer;
else
oldp = cupsdFindDest(olddest);
if (job->state_value == IPP_JOB_PROCESSING)
cupsdStopJob(job, 0);
else
cupsdLoadJob(job);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, oldp, job,
"Job #%d moved from %s to %s.", job->id, olddest,
p->name);
cupsdSetString(&job->dest, p->name);
job->dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE |
CUPS_PRINTER_IMPLICIT);
if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
IPP_TAG_URI)) != NULL)
cupsdSetString(&(attr->values[0].string.text), p->uri);
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, p, job,
"Job #%d moved from %s to %s.", job->id, olddest,
p->name);
cupsdSaveJob(job);
}
void
cupsdReleaseJob(cupsd_job_t *job)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdReleaseJob: id = %d", job->id);
if (job->state_value == IPP_JOB_HELD)
{
if (job->pending_timeout)
cupsdTimeoutJob(job);
DEBUG_puts("cupsdReleaseJob: setting state to pending...");
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
cupsdSaveJob(job);
}
}
void
cupsdRestartJob(cupsd_job_t *job)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdRestartJob: id = %d", job->id);
if (job->state_value == IPP_JOB_STOPPED || job->num_files)
{
ipp_jstate_t old_state;
cupsdLoadJob(job);
old_state = job->state_value;
job->tries = 0;
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
cupsdSaveJob(job);
if (old_state > IPP_JOB_STOPPED)
cupsArrayAdd(ActiveJobs, job);
}
}
void
cupsdSaveAllJobs(void)
{
int i;
cups_file_t *fp;
char temp[1024];
cupsd_job_t *job;
time_t curtime;
struct tm *curdate;
snprintf(temp, sizeof(temp), "%s/job.cache", CacheDir);
if ((fp = cupsFileOpen(temp, "w")) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to create job cache file \"%s\" - %s",
temp, strerror(errno));
return;
}
cupsdLogMessage(CUPSD_LOG_INFO, "Saving job cache file \"%s\"...", temp);
fchown(cupsFileNumber(fp), getuid(), Group);
fchmod(cupsFileNumber(fp), ConfigFilePerm);
curtime = time(NULL);
curdate = localtime(&curtime);
strftime(temp, sizeof(temp) - 1, "%Y-%m-%d %H:%M", curdate);
cupsFilePuts(fp, "# Job cache file for " CUPS_SVERSION "\n");
cupsFilePrintf(fp, "# Written by cupsd on %s\n", temp);
cupsFilePrintf(fp, "NextJobId %d\n", NextJobId);
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
job;
job = (cupsd_job_t *)cupsArrayNext(Jobs))
{
cupsFilePrintf(fp, "<Job %d>\n", job->id);
cupsFilePrintf(fp, "State %d\n", job->state_value);
cupsFilePrintf(fp, "Priority %d\n", job->priority);
cupsFilePrintf(fp, "Username %s\n", job->username);
cupsFilePrintf(fp, "Destination %s\n", job->dest);
cupsFilePrintf(fp, "DestType %d\n", job->dtype);
cupsFilePrintf(fp, "NumFiles %d\n", job->num_files);
for (i = 0; i < job->num_files; i ++)
cupsFilePrintf(fp, "File %d %s/%s %d\n", i + 1, job->filetypes[i]->super,
job->filetypes[i]->type, job->compressions[i]);
cupsFilePuts(fp, "</Job>\n");
}
cupsFileClose(fp);
}
void
cupsdSaveJob(cupsd_job_t *job)
{
char filename[1024];
cups_file_t *fp;
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSaveJob(job=%p(%d)): job->attrs=%p",
job, job->id, job->attrs);
snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot, job->id);
if ((fp = cupsFileOpen(filename, "w")) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to create job control file \"%s\" - %s.",
job->id, filename, strerror(errno));
return;
}
fchmod(cupsFileNumber(fp), 0600);
fchown(cupsFileNumber(fp), RunUser, Group);
job->attrs->state = IPP_IDLE;
if (ippWriteIO(fp, (ipp_iocb_t)cupsFileWrite, 1, NULL,
job->attrs) != IPP_DATA)
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to write job control file!", job->id);
cupsFileClose(fp);
}
void
cupsdSetJobHoldUntil(cupsd_job_t *job,
const char *when)
{
time_t curtime;
struct tm *curdate;
int hour;
int minute;
int second;
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSetJobHoldUntil(%d, \"%s\")",
job->id, when);
second = 0;
if (!strcmp(when, "indefinite") || !strcmp(when, "auth-info-required"))
{
job->hold_until = 0;
}
else if (!strcmp(when, "day-time"))
{
curtime = time(NULL);
curdate = localtime(&curtime);
if (curdate->tm_hour < 18)
job->hold_until = curtime;
else
job->hold_until = curtime +
((29 - curdate->tm_hour) * 60 + 59 -
curdate->tm_min) * 60 + 60 - curdate->tm_sec;
}
else if (!strcmp(when, "evening") || !strcmp(when, "night"))
{
curtime = time(NULL);
curdate = localtime(&curtime);
if (curdate->tm_hour < 6 || curdate->tm_hour >= 18)
job->hold_until = curtime;
else
job->hold_until = curtime +
((17 - curdate->tm_hour) * 60 + 59 -
curdate->tm_min) * 60 + 60 - curdate->tm_sec;
}
else if (!strcmp(when, "second-shift"))
{
curtime = time(NULL);
curdate = localtime(&curtime);
if (curdate->tm_hour >= 16)
job->hold_until = curtime;
else
job->hold_until = curtime +
((15 - curdate->tm_hour) * 60 + 59 -
curdate->tm_min) * 60 + 60 - curdate->tm_sec;
}
else if (!strcmp(when, "third-shift"))
{
curtime = time(NULL);
curdate = localtime(&curtime);
if (curdate->tm_hour < 8)
job->hold_until = curtime;
else
job->hold_until = curtime +
((23 - curdate->tm_hour) * 60 + 59 -
curdate->tm_min) * 60 + 60 - curdate->tm_sec;
}
else if (!strcmp(when, "weekend"))
{
curtime = time(NULL);
curdate = localtime(&curtime);
if (curdate->tm_wday == 0 || curdate->tm_wday == 6)
job->hold_until = curtime;
else
job->hold_until = curtime +
(((5 - curdate->tm_wday) * 24 +
(17 - curdate->tm_hour)) * 60 + 59 -
curdate->tm_min) * 60 + 60 - curdate->tm_sec;
}
else if (sscanf(when, "%d:%d:%d", &hour, &minute, &second) >= 2)
{
curtime = time(NULL);
curdate = gmtime(&curtime);
job->hold_until = curtime +
((hour - curdate->tm_hour) * 60 + minute -
curdate->tm_min) * 60 + second - curdate->tm_sec;
if (job->hold_until < curtime)
job->hold_until += 24 * 60 * 60;
}
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSetJobHoldUntil: hold_until = %d",
(int)job->hold_until);
}
void
cupsdSetJobPriority(
cupsd_job_t *job,
int priority)
{
ipp_attribute_t *attr;
if (job->state_value >= IPP_JOB_PROCESSING)
return;
cupsArrayRemove(ActiveJobs, job);
job->priority = priority;
if ((attr = ippFindAttribute(job->attrs, "job-priority",
IPP_TAG_INTEGER)) != NULL)
attr->values[0].integer = priority;
else
ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-priority",
priority);
cupsArrayAdd(ActiveJobs, job);
cupsdSaveJob(job);
}
void
cupsdStopAllJobs(int force)
{
cupsd_job_t *job;
DEBUG_puts("cupsdStopAllJobs()");
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
if (job->state_value == IPP_JOB_PROCESSING)
{
cupsdStopJob(job, force);
job->state->values[0].integer = IPP_JOB_PENDING;
job->state_value = IPP_JOB_PENDING;
}
}
void
cupsdStopJob(cupsd_job_t *job,
int force)
{
int i;
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] cupsdStopJob: force = %d", job->id, force);
if (job->state_value != IPP_JOB_PROCESSING)
return;
FilterLevel -= job->cost;
if (job->printer->state == IPP_PRINTER_PROCESSING)
cupsdSetPrinterState(job->printer, IPP_PRINTER_IDLE, 0);
job->state->values[0].integer = IPP_JOB_STOPPED;
job->state_value = IPP_JOB_STOPPED;
job->printer->job = NULL;
job->printer = NULL;
job->current_file --;
for (i = 0; job->filters[i]; i ++)
if (job->filters[i] > 0)
{
cupsdEndProcess(job->filters[i], force);
job->filters[i] = 0;
}
if (job->backend > 0)
{
cupsdEndProcess(job->backend, force);
job->backend = 0;
}
cupsdLogMessage(CUPSD_LOG_DEBUG2, "[Job %d] Closing print pipes [ %d %d ]...",
job->id, job->print_pipes[0], job->print_pipes[1]);
cupsdClosePipe(job->print_pipes);
cupsdLogMessage(CUPSD_LOG_DEBUG2, "[Job %d] Closing back pipes [ %d %d ]...",
job->id, job->back_pipes[0], job->back_pipes[1]);
cupsdClosePipe(job->back_pipes);
cupsdLogMessage(CUPSD_LOG_DEBUG2, "[Job %d] Closing side pipes [ %d %d ]...",
job->id, job->side_pipes[0], job->side_pipes[1]);
cupsdClosePipe(job->side_pipes);
if (job->status_buffer)
{
cupsdRemoveSelect(job->status_buffer->fd);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] Closing status pipes [ %d %d ]...", job->id,
job->status_pipes[0], job->status_pipes[1]);
cupsdClosePipe(job->status_pipes);
cupsdStatBufDelete(job->status_buffer);
job->status_buffer = NULL;
}
}
void
cupsdUnloadCompletedJobs(void)
{
cupsd_job_t *job;
time_t expire;
expire = time(NULL) - 60;
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
job;
job = (cupsd_job_t *)cupsArrayNext(Jobs))
if (job->attrs && job->state_value >= IPP_JOB_STOPPED &&
job->access_time < expire)
unload_job(job);
}
static int
compare_active_jobs(void *first,
void *second,
void *data)
{
int diff;
if ((diff = ((cupsd_job_t *)second)->priority -
((cupsd_job_t *)first)->priority) != 0)
return (diff);
else
return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
}
static int
compare_jobs(void *first,
void *second,
void *data)
{
return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
}
static int
ipp_length(ipp_t *ipp)
{
int bytes;
int i;
ipp_attribute_t *attr;
bytes = 0;
for (attr = ipp->attrs; attr != NULL; attr = attr->next)
{
if (attr->value_tag == IPP_TAG_MIMETYPE ||
attr->value_tag == IPP_TAG_NAMELANG ||
attr->value_tag == IPP_TAG_TEXTLANG ||
attr->value_tag == IPP_TAG_URI ||
attr->value_tag == IPP_TAG_URISCHEME)
continue;
if (strncmp(attr->name, "time-", 5) == 0)
continue;
bytes ++;
bytes += attr->num_values;
if (attr->value_tag != IPP_TAG_BOOLEAN)
bytes += strlen(attr->name);
else
bytes += attr->num_values * strlen(attr->name);
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
bytes += attr->num_values * 11;
break;
case IPP_TAG_BOOLEAN :
for (i = 0; i < attr->num_values; i ++)
if (!attr->values[i].boolean)
bytes += 2;
break;
case IPP_TAG_RANGE :
bytes += attr->num_values * 23;
break;
case IPP_TAG_RESOLUTION :
bytes += attr->num_values * 26;
break;
case IPP_TAG_STRING :
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_URI :
for (i = 0; i < attr->num_values; i ++)
bytes += 2 * strlen(attr->values[i].string.text) + 2;
break;
default :
break;
}
}
return (bytes);
}
static void
load_job_cache(const char *filename)
{
cups_file_t *fp;
char line[1024],
*value;
int linenum;
cupsd_job_t *job;
int jobid;
char jobfile[1024];
if ((fp = cupsFileOpen(filename, "r")) == NULL)
{
if (errno != ENOENT)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to open job cache file \"%s\": %s",
filename, strerror(errno));
load_request_root();
return;
}
cupsdLogMessage(CUPSD_LOG_INFO, "Loading job cache file \"%s\"...",
filename);
linenum = 0;
job = NULL;
while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
{
if (!strcasecmp(line, "NextJobId"))
{
if (value)
NextJobId = atoi(value);
}
else if (!strcasecmp(line, "<Job"))
{
if (job)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Missing </Job> directive on line %d!",
linenum);
continue;
}
if (!value)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Missing job ID on line %d!", linenum);
continue;
}
jobid = atoi(value);
if (jobid < 1)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad job ID %d on line %d!", jobid,
linenum);
continue;
}
snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, jobid);
if (access(jobfile, 0))
{
cupsdLogMessage(CUPSD_LOG_ERROR, "[Job %d] Files have gone away!",
jobid);
continue;
}
job = calloc(1, sizeof(cupsd_job_t));
if (!job)
{
cupsdLogMessage(CUPSD_LOG_EMERG,
"[Job %d] Unable to allocate memory for job!", jobid);
break;
}
job->id = jobid;
job->back_pipes[0] = -1;
job->back_pipes[1] = -1;
job->print_pipes[0] = -1;
job->print_pipes[1] = -1;
job->side_pipes[0] = -1;
job->side_pipes[1] = -1;
job->status_pipes[0] = -1;
job->status_pipes[1] = -1;
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] Loading from cache...", job->id);
}
else if (!job)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Missing <Job #> directive on line %d!", linenum);
continue;
}
else if (!strcasecmp(line, "</Job>"))
{
cupsArrayAdd(Jobs, job);
if (job->state_value <= IPP_JOB_STOPPED)
{
cupsArrayAdd(ActiveJobs, job);
cupsdLoadJob(job);
}
job = NULL;
}
else if (!value)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Missing value on line %d!", linenum);
continue;
}
else if (!strcasecmp(line, "State"))
{
job->state_value = (ipp_jstate_t)atoi(value);
if (job->state_value < IPP_JOB_PENDING)
job->state_value = IPP_JOB_PENDING;
else if (job->state_value > IPP_JOB_COMPLETED)
job->state_value = IPP_JOB_COMPLETED;
}
else if (!strcasecmp(line, "Priority"))
{
job->priority = atoi(value);
}
else if (!strcasecmp(line, "Username"))
{
cupsdSetString(&job->username, value);
}
else if (!strcasecmp(line, "Destination"))
{
cupsdSetString(&job->dest, value);
}
else if (!strcasecmp(line, "DestType"))
{
job->dtype = (cups_ptype_t)atoi(value);
}
else if (!strcasecmp(line, "NumFiles"))
{
job->num_files = atoi(value);
if (job->num_files < 0)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad NumFiles value %d on line %d!",
job->num_files, linenum);
job->num_files = 0;
continue;
}
if (job->num_files > 0)
{
snprintf(jobfile, sizeof(jobfile), "%s/d%05d-001", RequestRoot,
job->id);
if (access(jobfile, 0))
{
cupsdLogMessage(CUPSD_LOG_INFO,
"[Job %d] Data files have gone away!", job->id);
job->num_files = 0;
continue;
}
job->filetypes = calloc(job->num_files, sizeof(mime_type_t *));
job->compressions = calloc(job->num_files, sizeof(int));
if (!job->filetypes || !job->compressions)
{
cupsdLogMessage(CUPSD_LOG_EMERG,
"[Job %d] Unable to allocate memory for %d files!",
job->id, job->num_files);
break;
}
}
}
else if (!strcasecmp(line, "File"))
{
int number,
compression;
char super[MIME_MAX_SUPER],
type[MIME_MAX_TYPE];
if (sscanf(value, "%d%*[ \t]%15[^/]/%255s%d", &number, super, type,
&compression) != 4)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File on line %d!", linenum);
continue;
}
if (number < 1 || number > job->num_files)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File number %d on line %d!",
number, linenum);
continue;
}
number --;
job->compressions[number] = compression;
job->filetypes[number] = mimeType(MimeDatabase, super, type);
if (!job->filetypes[number])
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unknown MIME type %s/%s for file %d!",
job->id, super, type, number + 1);
snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
job->id, number + 1);
job->filetypes[number] = mimeFileType(MimeDatabase, jobfile, NULL,
job->compressions + number);
if (!job->filetypes[number])
job->filetypes[number] = mimeType(MimeDatabase, "application",
"vnd.cups-raw");
}
}
else
cupsdLogMessage(CUPSD_LOG_ERROR, "Unknown %s directive on line %d!",
line, linenum);
}
cupsFileClose(fp);
}
static void
load_next_job_id(const char *filename)
{
cups_file_t *fp;
char line[1024],
*value;
int linenum;
int next_job_id;
if ((fp = cupsFileOpen(filename, "r")) == NULL)
{
if (errno != ENOENT)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to open job cache file \"%s\": %s",
filename, strerror(errno));
return;
}
cupsdLogMessage(CUPSD_LOG_INFO,
"Loading NextJobId from job cache file \"%s\"...", filename);
linenum = 0;
while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
{
if (!strcasecmp(line, "NextJobId"))
{
if (value)
{
next_job_id = atoi(value);
if (next_job_id > NextJobId)
NextJobId = next_job_id;
}
break;
}
}
cupsFileClose(fp);
}
static void
load_request_root(void)
{
cups_dir_t *dir;
cups_dentry_t *dent;
cupsd_job_t *job;
cupsdLogMessage(CUPSD_LOG_DEBUG, "Scanning %s for jobs...", RequestRoot);
if ((dir = cupsDirOpen(RequestRoot)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to open spool directory \"%s\": %s",
RequestRoot, strerror(errno));
return;
}
while ((dent = cupsDirRead(dir)) != NULL)
if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c')
{
if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Ran out of memory for jobs!");
cupsDirClose(dir);
return;
}
job->id = atoi(dent->filename + 1);
job->back_pipes[0] = -1;
job->back_pipes[1] = -1;
job->print_pipes[0] = -1;
job->print_pipes[1] = -1;
job->side_pipes[0] = -1;
job->side_pipes[1] = -1;
job->status_pipes[0] = -1;
job->status_pipes[1] = -1;
if (job->id >= NextJobId)
NextJobId = job->id + 1;
cupsdLoadJob(job);
cupsArrayAdd(Jobs, job);
if (job->state_value <= IPP_JOB_STOPPED)
cupsArrayAdd(ActiveJobs, job);
else
unload_job(job);
}
cupsDirClose(dir);
}
static void
set_time(cupsd_job_t *job,
const char *name)
{
ipp_attribute_t *attr;
if ((attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO)) != NULL)
{
attr->value_tag = IPP_TAG_INTEGER;
attr->values[0].integer = time(NULL);
}
}
static void
set_hold_until(cupsd_job_t *job,
time_t holdtime)
{
ipp_attribute_t *attr;
struct tm *holddate;
char holdstr[64];
cupsdLogMessage(CUPSD_LOG_DEBUG, "set_hold_until: hold_until = %d",
(int)holdtime);
job->state->values[0].integer = IPP_JOB_HELD;
job->state_value = IPP_JOB_HELD;
job->hold_until = holdtime;
holddate = gmtime(&holdtime);
snprintf(holdstr, sizeof(holdstr), "%d:%d:%d", holddate->tm_hour,
holddate->tm_min, holddate->tm_sec);
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
IPP_TAG_KEYWORD)) == NULL)
attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
if (attr == NULL)
ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-hold-until",
NULL, holdstr);
else
cupsdSetString(&attr->values[0].string.text, holdstr);
cupsdSaveJob(job);
}
static void
start_job(cupsd_job_t *job,
cupsd_printer_t *printer)
{
int i;
int slot;
cups_array_t *filters,
*prefilters;
mime_filter_t *filter,
*prefilter,
port_monitor;
char method[255],
*optptr,
*valptr;
ipp_attribute_t *attr;
struct stat backinfo;
int backroot;
int pid;
int banner_page;
int filterfds[2][2];
int envc;
char **argv,
sani_uri[1024],
filename[1024],
command[1024],
jobid[255],
title[IPP_MAX_NAME],
copies[255],
*envp[MAX_ENV + 16],
charset[255],
class_name[255],
classification[1024],
content_type[1024],
device_uri[1024],
final_content_type[1024],
lang[255],
#ifdef __APPLE__
apple_language[255],
#endif
ppd[1024],
printer_name[255],
rip_max_cache[255];
static char *options = NULL;
static int optlength = 0;
cupsdLogMessage(CUPSD_LOG_DEBUG2, "[Job %d] start_job: file = %d/%d",
job->id, job->current_file, job->num_files);
if (job->num_files == 0)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "[Job %d] No files, canceling job!",
job->id);
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
return;
}
filters = NULL;
job->cost = 0;
if (printer->raw)
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"[Job %d] Sending job to queue tagged as raw...", job->id);
filters = NULL;
}
else
{
filters = mimeFilter(MimeDatabase, job->filetypes[job->current_file],
printer->filetype, &(job->cost));
if (!filters)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to convert file %d to printable format!",
job->current_file, job->id);
cupsdLogMessage(CUPSD_LOG_INFO,
"Hint: Do you have Ghostscript installed?");
if (LogLevel < CUPSD_LOG_DEBUG)
cupsdLogMessage(CUPSD_LOG_INFO,
"Hint: Try setting the LogLevel to \"debug\".");
job->current_file ++;
if (job->current_file == job->num_files)
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
return;
}
for (filter = (mime_filter_t *)cupsArrayFirst(filters);
filter;
filter = (mime_filter_t *)cupsArrayNext(filters))
if (!strcmp(filter->filter, "-"))
cupsArrayRemove(filters, filter);
if (cupsArrayCount(filters) == 0)
{
cupsArrayDelete(filters);
filters = NULL;
}
if (printer->prefiltertype && filters)
{
prefilters = cupsArrayNew(NULL, NULL);
for (filter = (mime_filter_t *)cupsArrayFirst(filters);
filter;
filter = (mime_filter_t *)cupsArrayNext(filters))
{
if ((prefilter = mimeFilterLookup(MimeDatabase, filter->src,
printer->prefiltertype)))
{
cupsArrayAdd(prefilters, prefilter);
job->cost += prefilter->cost;
}
cupsArrayAdd(prefilters, filter);
}
cupsArrayDelete(filters);
filters = prefilters;
}
}
if (job->cost < 100)
job->cost = 100;
if ((FilterLevel + job->cost) > FilterLimit && FilterLevel > 0 &&
FilterLimit > 0)
{
cupsArrayDelete(filters);
cupsdLogMessage(CUPSD_LOG_INFO,
"[Job %d] Holding because filter limit has been reached.",
job->id);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: file=%d, cost=%d, level=%d, limit=%d",
job->id, job->current_file, job->cost, FilterLevel,
FilterLimit);
return;
}
FilterLevel += job->cost;
if ((!printer->raw && job->compressions[job->current_file]) ||
(!filters && !printer->remote &&
(job->num_files > 1 || !strncmp(printer->device_uri, "file:", 5))))
{
if (!filters)
filters = cupsArrayNew(NULL, NULL);
if (!cupsArrayInsert(filters, &gziptoany_filter))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to add decompression filter - %s",
job->id, strerror(errno));
cupsArrayDelete(filters);
job->current_file ++;
if (job->current_file == job->num_files)
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
return;
}
}
if (printer->port_monitor)
{
if (!filters)
filters = cupsArrayNew(NULL, NULL);
port_monitor.src = NULL;
port_monitor.dst = NULL;
port_monitor.cost = 0;
snprintf(port_monitor.filter, sizeof(port_monitor.filter),
"%s/monitor/%s", ServerBin, printer->port_monitor);
if (!cupsArrayAdd(filters, &port_monitor))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to add port monitor - %s",
job->id, strerror(errno));
cupsArrayDelete(filters);
job->current_file ++;
if (job->current_file == job->num_files)
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
return;
}
}
if (cupsArrayCount(filters) > MAX_FILTERS)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Too many filters (%d > %d), unable to print!",
job->id, cupsArrayCount(filters), MAX_FILTERS);
cupsArrayDelete(filters);
cupsdCancelJob(job, 0, IPP_JOB_STOPPED);
return;
}
job->state->values[0].integer = IPP_JOB_PROCESSING;
job->state_value = IPP_JOB_PROCESSING;
job->status = 0;
job->printer = printer;
printer->job = job;
cupsdSetPrinterState(printer, IPP_PRINTER_PROCESSING, 0);
if (job->current_file == 0)
{
set_time(job, "time-at-processing");
cupsdOpenPipe(job->back_pipes);
fcntl(job->back_pipes[0], F_SETFL,
fcntl(job->back_pipes[0], F_GETFL) | O_NONBLOCK);
fcntl(job->back_pipes[1], F_SETFL,
fcntl(job->back_pipes[1], F_GETFL) | O_NONBLOCK);
socketpair(AF_LOCAL, SOCK_STREAM, 0, job->side_pipes);
fcntl(job->side_pipes[0], F_SETFL,
fcntl(job->side_pipes[0], F_GETFL) | O_NONBLOCK);
fcntl(job->side_pipes[1], F_SETFL,
fcntl(job->side_pipes[1], F_GETFL) | O_NONBLOCK);
}
if (job->job_sheets == NULL)
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] No job-sheets attribute.",
job->id);
if ((job->job_sheets =
ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_ZERO)) != NULL)
cupsdLogMessage(CUPSD_LOG_DEBUG,
"[Job %d] ... but someone added one without setting "
"job_sheets!", job->id);
}
else if (job->job_sheets->num_values == 1)
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] job-sheets=%s", job->id,
job->job_sheets->values[0].string.text);
else
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] job-sheets=%s,%s", job->id,
job->job_sheets->values[0].string.text,
job->job_sheets->values[1].string.text);
if (printer->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_IMPLICIT))
banner_page = 0;
else if (job->job_sheets == NULL)
banner_page = 0;
else if (strcasecmp(job->job_sheets->values[0].string.text, "none") != 0 &&
job->current_file == 0)
banner_page = 1;
else if (job->job_sheets->num_values > 1 &&
strcasecmp(job->job_sheets->values[1].string.text, "none") != 0 &&
job->current_file == (job->num_files - 1))
banner_page = 1;
else
banner_page = 0;
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] banner_page = %d", job->id,
banner_page);
i = ipp_length(job->attrs);
if (i > optlength || !options)
{
if (optlength == 0)
optptr = malloc(i);
else
optptr = realloc(options, i);
if (optptr == NULL)
{
cupsdLogMessage(CUPSD_LOG_CRIT,
"[Job %d] Unable to allocate %d bytes for option buffer!",
job->id, i);
cupsArrayDelete(filters);
FilterLevel -= job->cost;
cupsdCancelJob(job, 0, IPP_JOB_ABORTED);
return;
}
options = optptr;
optlength = i;
}
optptr = options;
*optptr = '\0';
snprintf(title, sizeof(title), "%s-%d", printer->name, job->id);
strcpy(copies, "1");
for (attr = job->attrs->attrs; attr != NULL; attr = attr->next)
{
if (!strcmp(attr->name, "copies") &&
attr->value_tag == IPP_TAG_INTEGER)
{
if (!banner_page)
sprintf(copies, "%d", attr->values[0].integer);
}
else if (!strcmp(attr->name, "job-name") &&
(attr->value_tag == IPP_TAG_NAME ||
attr->value_tag == IPP_TAG_NAMELANG))
strlcpy(title, attr->values[0].string.text, sizeof(title));
else if (attr->group_tag == IPP_TAG_JOB)
{
if (attr->value_tag == IPP_TAG_MIMETYPE ||
attr->value_tag == IPP_TAG_NAMELANG ||
attr->value_tag == IPP_TAG_TEXTLANG ||
(attr->value_tag == IPP_TAG_URI && strcmp(attr->name, "job-uuid")) ||
attr->value_tag == IPP_TAG_URISCHEME ||
attr->value_tag == IPP_TAG_BEGIN_COLLECTION)
continue;
if (!strncmp(attr->name, "time-", 5))
continue;
if (!strncmp(attr->name, "job-", 4) && strcmp(attr->name, "job-uuid") &&
strcmp(attr->name, "job-impressions") &&
strcmp(attr->name, "job-originating-host-name") &&
!(printer->type & CUPS_PRINTER_REMOTE))
continue;
if (!strncmp(attr->name, "job-", 4) &&
strcmp(attr->name, "job-uuid") &&
strcmp(attr->name, "job-billing") &&
strcmp(attr->name, "job-impressions") &&
strcmp(attr->name, "job-sheets") &&
strcmp(attr->name, "job-hold-until") &&
strcmp(attr->name, "job-priority"))
continue;
if ((!strcmp(attr->name, "job-impressions") ||
!strcmp(attr->name, "page-label") ||
!strcmp(attr->name, "page-border") ||
!strncmp(attr->name, "number-up", 9) ||
!strcmp(attr->name, "page-ranges") ||
!strcmp(attr->name, "page-set") ||
!strcasecmp(attr->name, "AP_FIRSTPAGE_InputSlot") ||
!strcasecmp(attr->name, "AP_FIRSTPAGE_ManualFeed") ||
!strcasecmp(attr->name, "com.apple.print.PrintSettings."
"PMTotalSidesImaged..n.") ||
!strcasecmp(attr->name, "com.apple.print.PrintSettings."
"PMTotalBeginPages..n.")) &&
banner_page)
continue;
if (optptr > options)
strlcat(optptr, " ", optlength - (optptr - options));
if (attr->value_tag != IPP_TAG_BOOLEAN)
{
strlcat(optptr, attr->name, optlength - (optptr - options));
strlcat(optptr, "=", optlength - (optptr - options));
}
for (i = 0; i < attr->num_values; i ++)
{
if (i)
strlcat(optptr, ",", optlength - (optptr - options));
optptr += strlen(optptr);
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
snprintf(optptr, optlength - (optptr - options),
"%d", attr->values[i].integer);
break;
case IPP_TAG_BOOLEAN :
if (!attr->values[i].boolean)
strlcat(optptr, "no", optlength - (optptr - options));
case IPP_TAG_NOVALUE :
strlcat(optptr, attr->name,
optlength - (optptr - options));
break;
case IPP_TAG_RANGE :
if (attr->values[i].range.lower == attr->values[i].range.upper)
snprintf(optptr, optlength - (optptr - options) - 1,
"%d", attr->values[i].range.lower);
else
snprintf(optptr, optlength - (optptr - options) - 1,
"%d-%d", attr->values[i].range.lower,
attr->values[i].range.upper);
break;
case IPP_TAG_RESOLUTION :
snprintf(optptr, optlength - (optptr - options) - 1,
"%dx%d%s", attr->values[i].resolution.xres,
attr->values[i].resolution.yres,
attr->values[i].resolution.units == IPP_RES_PER_INCH ?
"dpi" : "dpc");
break;
case IPP_TAG_STRING :
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_URI :
for (valptr = attr->values[i].string.text; *valptr;)
{
if (strchr(" \t\n\\\'\"", *valptr))
*optptr++ = '\\';
*optptr++ = *valptr++;
}
*optptr = '\0';
break;
default :
break;
}
}
optptr += strlen(optptr);
}
}
if (printer->remote && job->num_files > 1)
argv = calloc(7 + job->num_files, sizeof(char *));
else
argv = calloc(8, sizeof(char *));
if (!argv)
{
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to allocate argument array!");
cupsArrayDelete(filters);
FilterLevel -= job->cost;
cupsdStopPrinter(printer, 0);
return;
}
sprintf(jobid, "%d", job->id);
argv[0] = printer->name;
argv[1] = jobid;
argv[2] = job->username;
argv[3] = title;
argv[4] = copies;
argv[5] = options;
if (printer->remote && job->num_files > 1)
{
for (i = 0; i < job->num_files; i ++)
{
snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
job->id, i + 1);
argv[6 + i] = strdup(filename);
}
}
else
{
snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
job->id, job->current_file + 1);
argv[6] = filename;
}
for (i = 0; argv[i]; i ++)
cupsdLogMessage(CUPSD_LOG_DEBUG,
"[Job %d] argv[%d]=\"%s\"", job->id, i, argv[i]);
attr = ippFindAttribute(job->attrs, "attributes-natural-language",
IPP_TAG_LANGUAGE);
#ifdef __APPLE__
strcpy(apple_language, "APPLE_LANGUAGE=");
_cupsAppleLanguage(attr->values[0].string.text,
apple_language + 15, sizeof(apple_language) - 15);
#endif
switch (strlen(attr->values[0].string.text))
{
default :
strcpy(lang, "LANG=C");
break;
case 2 :
snprintf(lang, sizeof(lang), "LANG=%s.UTF8",
attr->values[0].string.text);
break;
case 5 :
snprintf(lang, sizeof(lang), "LANG=%c%c_%c%c.UTF8",
attr->values[0].string.text[0],
attr->values[0].string.text[1],
toupper(attr->values[0].string.text[3] & 255),
toupper(attr->values[0].string.text[4] & 255));
break;
}
attr = ippFindAttribute(job->attrs, "document-format",
IPP_TAG_MIMETYPE);
if (attr != NULL &&
(optptr = strstr(attr->values[0].string.text, "charset=")) != NULL)
snprintf(charset, sizeof(charset), "CHARSET=%s", optptr + 8);
else
{
attr = ippFindAttribute(job->attrs, "attributes-charset",
IPP_TAG_CHARSET);
snprintf(charset, sizeof(charset), "CHARSET=%s",
attr->values[0].string.text);
}
snprintf(content_type, sizeof(content_type), "CONTENT_TYPE=%s/%s",
job->filetypes[job->current_file]->super,
job->filetypes[job->current_file]->type);
snprintf(device_uri, sizeof(device_uri), "DEVICE_URI=%s",
printer->device_uri);
cupsdSanitizeURI(printer->device_uri, sani_uri, sizeof(sani_uri));
snprintf(ppd, sizeof(ppd), "PPD=%s/ppd/%s.ppd", ServerRoot, printer->name);
snprintf(printer_name, sizeof(printer_name), "PRINTER=%s", printer->name);
snprintf(rip_max_cache, sizeof(rip_max_cache), "RIP_MAX_CACHE=%s", RIPCache);
envc = cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
envp[envc ++] = charset;
envp[envc ++] = lang;
#ifdef __APPLE__
envp[envc ++] = apple_language;
#endif
envp[envc ++] = ppd;
envp[envc ++] = rip_max_cache;
envp[envc ++] = content_type;
envp[envc ++] = device_uri;
envp[envc ++] = printer_name;
if (!printer->remote && !printer->raw)
{
filter = (mime_filter_t *)cupsArrayLast(filters);
if (printer->port_monitor)
filter = (mime_filter_t *)cupsArrayPrev(filters);
if (filter && filter->dst)
{
snprintf(final_content_type, sizeof(final_content_type),
"FINAL_CONTENT_TYPE=%s/%s",
filter->dst->super, filter->dst->type);
envp[envc ++] = final_content_type;
}
}
if (Classification && !banner_page)
{
if ((attr = ippFindAttribute(job->attrs, "job-sheets",
IPP_TAG_NAME)) == NULL)
snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
Classification);
else if (attr->num_values > 1 &&
strcmp(attr->values[1].string.text, "none") != 0)
snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
attr->values[1].string.text);
else
snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
attr->values[0].string.text);
envp[envc ++] = classification;
}
if (job->dtype & (CUPS_PRINTER_CLASS | CUPS_PRINTER_IMPLICIT))
{
snprintf(class_name, sizeof(class_name), "CLASS=%s", job->dest);
envp[envc ++] = class_name;
}
if (job->auth_username)
envp[envc ++] = job->auth_username;
if (job->auth_domain)
envp[envc ++] = job->auth_domain;
if (job->auth_password)
envp[envc ++] = job->auth_password;
#ifdef HAVE_GSSAPI
if (job->ccname)
envp[envc ++] = job->ccname;
#endif
envp[envc] = NULL;
for (i = 0; i < envc; i ++)
if (!strncmp(envp[i], "AUTH_", 5))
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] envp[%d]=\"AUTH_%c****\"",
job->id, i, envp[i][5]);
else if (strncmp(envp[i], "DEVICE_URI=", 11))
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] envp[%d]=\"%s\"",
job->id, i, envp[i]);
else
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] envp[%d]=\"DEVICE_URI=%s\"",
job->id, i, sani_uri);
if (printer->remote)
job->current_file = job->num_files;
else
job->current_file ++;
filterfds[0][0] = -1;
filterfds[0][1] = -1;
filterfds[1][0] = -1;
filterfds[1][1] = -1;
if (!job->status_buffer)
{
if (cupsdOpenPipe(job->status_pipes))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to create job status pipes - %s.",
job->id, strerror(errno));
snprintf(printer->state_message, sizeof(printer->state_message),
"Unable to create status pipes - %s.", strerror(errno));
cupsdAddPrinterHistory(printer);
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the server could not create the job "
"status pipes.");
goto abort_job;
}
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: status_pipes = [ %d %d ]",
job->id, job->status_pipes[0], job->status_pipes[1]);
job->status_buffer = cupsdStatBufNew(job->status_pipes[0], "[Job %d]",
job->id);
job->status_level = CUPSD_LOG_INFO;
}
job->status = 0;
memset(job->filters, 0, sizeof(job->filters));
for (i = 0, slot = 0, filter = (mime_filter_t *)cupsArrayFirst(filters);
filter;
i ++, filter = (mime_filter_t *)cupsArrayNext(filters))
{
if (filter->filter[0] != '/')
snprintf(command, sizeof(command), "%s/filter/%s", ServerBin,
filter->filter);
else
strlcpy(command, filter->filter, sizeof(command));
if (i < (cupsArrayCount(filters) - 1))
{
if (cupsdOpenPipe(filterfds[slot]))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to create job filter pipes - %s.",
job->id, strerror(errno));
snprintf(printer->state_message, sizeof(printer->state_message),
"Unable to create filter pipes - %s.", strerror(errno));
cupsdAddPrinterHistory(printer);
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the server could not create the "
"filter pipes.");
goto abort_job;
}
}
else
{
if (job->current_file == 1)
{
if (strncmp(printer->device_uri, "file:", 5) != 0)
{
if (cupsdOpenPipe(job->print_pipes))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to create job backend pipes - %s.",
job->id, strerror(errno));
snprintf(printer->state_message, sizeof(printer->state_message),
"Unable to create backend pipes - %s.", strerror(errno));
cupsdAddPrinterHistory(printer);
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the server could not create "
"the backend pipes.");
goto abort_job;
}
}
else
{
job->print_pipes[0] = -1;
if (!strcmp(printer->device_uri, "file:/dev/null") ||
!strcmp(printer->device_uri, "file:///dev/null"))
job->print_pipes[1] = -1;
else
{
if (!strncmp(printer->device_uri, "file:/dev/", 10))
job->print_pipes[1] = open(printer->device_uri + 5,
O_WRONLY | O_EXCL);
else if (!strncmp(printer->device_uri, "file:///dev/", 12))
job->print_pipes[1] = open(printer->device_uri + 7,
O_WRONLY | O_EXCL);
else if (!strncmp(printer->device_uri, "file:///", 8))
job->print_pipes[1] = open(printer->device_uri + 7,
O_WRONLY | O_CREAT | O_TRUNC, 0600);
else
job->print_pipes[1] = open(printer->device_uri + 5,
O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (job->print_pipes[1] < 0)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to open output file \"%s\" - %s.",
job->id, printer->device_uri, strerror(errno));
snprintf(printer->state_message, sizeof(printer->state_message),
"Unable to open output file \"%s\" - %s.",
printer->device_uri, strerror(errno));
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the server could not open the "
"output file.");
goto abort_job;
}
fcntl(job->print_pipes[1], F_SETFD,
fcntl(job->print_pipes[1], F_GETFD) | FD_CLOEXEC);
}
}
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: print_pipes = [ %d %d ]",
job->id, job->print_pipes[0], job->print_pipes[1]);
}
filterfds[slot][0] = job->print_pipes[0];
filterfds[slot][1] = job->print_pipes[1];
}
cupsdLogMessage(CUPSD_LOG_DEBUG2, "[Job %d] start_job: filter=\"%s\"",
job->id, command);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: filterfds[%d]=[ %d %d ]",
job->id, slot, filterfds[slot][0], filterfds[slot][1]);
pid = cupsdStartProcess(command, argv, envp, filterfds[!slot][0],
filterfds[slot][1], job->status_pipes[1],
job->back_pipes[0], job->side_pipes[0], 0,
job->filters + i);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing filter pipes for slot %d "
"[ %d %d ]...",
job->id, !slot, filterfds[!slot][0], filterfds[!slot][1]);
cupsdClosePipe(filterfds[!slot]);
if (pid == 0)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to start filter \"%s\" - %s.",
job->id, filter->filter, strerror(errno));
snprintf(printer->state_message, sizeof(printer->state_message),
"Unable to start filter \"%s\" - %s.",
filter->filter, strerror(errno));
cupsdAddPrinterHistory(printer);
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the server could not execute a "
"filter.");
goto abort_job;
}
cupsdLogMessage(CUPSD_LOG_INFO, "[Job %d] Started filter %s (PID %d)",
job->id, command, pid);
argv[6] = NULL;
slot = !slot;
}
cupsArrayDelete(filters);
filters = NULL;
if (strncmp(printer->device_uri, "file:", 5) != 0)
{
if (job->current_file == 1 || printer->remote)
{
sscanf(printer->device_uri, "%254[^:]", method);
snprintf(command, sizeof(command), "%s/backend/%s", ServerBin, method);
if (RunUser)
backroot = 0;
else if (stat(command, &backinfo))
backroot = 0;
else
backroot = !(backinfo.st_mode & (S_IRWXG | S_IRWXO));
argv[0] = sani_uri;
filterfds[slot][0] = -1;
filterfds[slot][1] = -1;
cupsdLogMessage(CUPSD_LOG_DEBUG2, "[Job %d] start_job: backend=\"%s\"",
job->id, command);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: filterfds[%d] = [ %d %d ]", job->id,
slot, filterfds[slot][0], filterfds[slot][1]);
pid = cupsdStartProcess(command, argv, envp, filterfds[!slot][0],
filterfds[slot][1], job->status_pipes[1],
job->back_pipes[1], job->side_pipes[1],
backroot, &(job->backend));
if (pid == 0)
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"[Job %d] Unable to start backend \"%s\" - %s.",
job->id, method, strerror(errno));
snprintf(printer->state_message, sizeof(printer->state_message),
"Unable to start backend \"%s\" - %s.", method,
strerror(errno));
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job,
"Job canceled because the server could not execute "
"the backend.");
goto abort_job;
}
else
{
cupsdLogMessage(CUPSD_LOG_INFO, "[Job %d] Started backend %s (PID %d)",
job->id, command, pid);
}
}
if (job->current_file == job->num_files)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing print pipes [ %d %d ]...",
job->id, job->print_pipes[0], job->print_pipes[1]);
cupsdClosePipe(job->print_pipes);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing back pipes [ %d %d ]...",
job->id, job->back_pipes[0], job->back_pipes[1]);
cupsdClosePipe(job->back_pipes);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing side pipes [ %d %d ]...",
job->id, job->side_pipes[0], job->side_pipes[1]);
cupsdClosePipe(job->side_pipes);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing status output pipe %d...",
job->id, job->status_pipes[1]);
close(job->status_pipes[1]);
job->status_pipes[1] = -1;
}
}
else
{
filterfds[slot][0] = -1;
filterfds[slot][1] = -1;
if (job->current_file == job->num_files)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing print pipes [ %d %d ]...",
job->id, job->print_pipes[0], job->print_pipes[1]);
cupsdClosePipe(job->print_pipes);
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing status output pipe %d...",
job->id, job->status_pipes[1]);
close(job->status_pipes[1]);
job->status_pipes[1] = -1;
}
}
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing filter pipes for slot %d "
"[ %d %d ]...",
job->id, slot, filterfds[slot][0], filterfds[slot][1]);
cupsdClosePipe(filterfds[slot]);
if (printer->remote && job->num_files > 1)
{
for (i = 0; i < job->num_files; i ++)
free(argv[i + 6]);
}
free(argv);
cupsdAddSelect(job->status_buffer->fd, (cupsd_selfunc_t)update_job, NULL,
job);
cupsdAddEvent(CUPSD_EVENT_JOB_STATE, job->printer, job, "Job #%d started.",
job->id);
return;
abort_job:
for (slot = 0; slot < 2; slot ++)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing filter pipes for slot %d "
"[ %d %d ]...",
job->id, slot, filterfds[slot][0], filterfds[slot][1]);
cupsdClosePipe(filterfds[slot]);
}
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"[Job %d] start_job: Closing status pipes [ %d %d ]...",
job->id, job->status_pipes[0], job->status_pipes[1]);
cupsdClosePipe(job->status_pipes);
cupsdStatBufDelete(job->status_buffer);
job->status_buffer = NULL;
cupsArrayDelete(filters);
if (printer->remote && job->num_files > 1)
{
for (i = 0; i < job->num_files; i ++)
free(argv[i + 6]);
}
free(argv);
cupsdStopJob(job, 0);
}
static void
unload_job(cupsd_job_t *job)
{
if (!job->attrs)
return;
cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job %d] Unloading...", job->id);
ippDelete(job->attrs);
job->attrs = NULL;
job->state = NULL;
job->sheets = NULL;
job->job_sheets = NULL;
job->printer_message = NULL;
job->printer_reasons = NULL;
}
void
update_job(cupsd_job_t *job)
{
int i;
int copies;
char message[1024],
*ptr;
int loglevel,
event = 0;
while ((ptr = cupsdStatBufUpdate(job->status_buffer, &loglevel,
message, sizeof(message))) != NULL)
{
if (loglevel == CUPSD_LOG_PAGE)
{
if (job->sheets)
{
if (!strncasecmp(message, "total ", 6))
{
copies = atoi(message + 6);
copies -= job->sheets->values[0].integer;
}
else if (!sscanf(message, "%*d%d", &copies))
copies = 1;
job->sheets->values[0].integer += copies;
if (job->printer->page_limit)
{
cupsd_quota_t *q = cupsdUpdateQuota(job->printer, job->username,
copies, 0);
#ifdef __APPLE__
if (AppleQuotas && q->page_count == -3)
{
cupsdLogMessage(CUPSD_LOG_INFO,
"[Job %d] Canceled because pages exceed user %s "
"quota limit on printer %s (%s).",
job->id, job->username, job->printer->name,
job->printer->info);
cupsdCancelJob(job, 1, IPP_JOB_CANCELED);
return;
}
#else
(void)q;
#endif
}
}
cupsdLogPage(job, message);
if (job->sheets)
cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
"Printed %d page(s).", job->sheets->values[0].integer);
}
else if (loglevel == CUPSD_LOG_STATE)
{
if (!strcmp(message, "paused"))
{
cupsdStopPrinter(job->printer, 1);
return;
}
else
{
cupsdSetPrinterReasons(job->printer, message);
cupsdAddPrinterHistory(job->printer);
event |= CUPSD_EVENT_PRINTER_STATE;
}
update_job_attrs(job);
}
else if (loglevel == CUPSD_LOG_ATTR)
{
int num_attrs;
cups_option_t *attrs;
const char *attr;
num_attrs = cupsParseOptions(message, 0, &attrs);
if ((attr = cupsGetOption("auth-info-required", num_attrs,
attrs)) != NULL)
{
cupsdSetAuthInfoRequired(job->printer, attr, NULL);
cupsdSetPrinterAttrs(job->printer);
cupsdSaveAllPrinters();
}
if ((attr = cupsGetOption("printer-alert", num_attrs, attrs)) != NULL)
{
cupsdSetString(&job->printer->alert, attr);
event |= CUPSD_EVENT_PRINTER_STATE;
}
if ((attr = cupsGetOption("printer-alert-description", num_attrs,
attrs)) != NULL)
{
cupsdSetString(&job->printer->alert_description, attr);
event |= CUPSD_EVENT_PRINTER_STATE;
}
if ((attr = cupsGetOption("marker-colors", num_attrs, attrs)) != NULL)
{
cupsdSetPrinterAttr(job->printer, "marker-colors", (char *)attr);
job->printer->marker_time = time(NULL);
event |= CUPSD_EVENT_PRINTER_STATE;
}
if ((attr = cupsGetOption("marker-levels", num_attrs, attrs)) != NULL)
{
cupsdSetPrinterAttr(job->printer, "marker-levels", (char *)attr);
job->printer->marker_time = time(NULL);
event |= CUPSD_EVENT_PRINTER_STATE;
}
if ((attr = cupsGetOption("marker-message", num_attrs, attrs)) != NULL)
{
cupsdSetPrinterAttr(job->printer, "marker-message", (char *)attr);
job->printer->marker_time = time(NULL);
event |= CUPSD_EVENT_PRINTER_STATE;
}
if ((attr = cupsGetOption("marker-names", num_attrs, attrs)) != NULL)
{
cupsdSetPrinterAttr(job->printer, "marker-names", (char *)attr);
job->printer->marker_time = time(NULL);
event |= CUPSD_EVENT_PRINTER_STATE;
}
if ((attr = cupsGetOption("marker-types", num_attrs, attrs)) != NULL)
{
cupsdSetPrinterAttr(job->printer, "marker-types", (char *)attr);
job->printer->marker_time = time(NULL);
event |= CUPSD_EVENT_PRINTER_STATE;
}
cupsFreeOptions(num_attrs, attrs);
}
#ifdef __APPLE__
else if (!strncmp(message, "recoverable:", 12))
{
ptr = message + 12;
while (isspace(*ptr & 255))
ptr ++;
if (*ptr)
{
cupsdSetPrinterReasons(job->printer,
"+com.apple.print.recoverable-warning");
cupsdSetString(&job->printer->recoverable, ptr);
cupsdAddPrinterHistory(job->printer);
event |= CUPSD_EVENT_PRINTER_STATE;
}
}
else if (!strncmp(message, "recovered:", 10))
{
cupsdSetPrinterReasons(job->printer,
"-com.apple.print.recoverable-warning");
ptr = message + 10;
while (isspace(*ptr & 255))
ptr ++;
cupsdSetString(&job->printer->recoverable, ptr);
cupsdAddPrinterHistory(job->printer);
event |= CUPSD_EVENT_PRINTER_STATE;
}
#endif
else if (loglevel <= job->status_level)
{
if (loglevel != CUPSD_LOG_NOTICE)
job->status_level = loglevel;
strlcpy(job->printer->state_message, message,
sizeof(job->printer->state_message));
cupsdAddPrinterHistory(job->printer);
event |= CUPSD_EVENT_PRINTER_STATE;
update_job_attrs(job);
}
if (!strchr(job->status_buffer->buffer, '\n'))
break;
}
if (event & CUPSD_EVENT_PRINTER_STATE)
cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, job->printer, NULL,
(job->printer->type & CUPS_PRINTER_CLASS) ?
"Class \"%s\" state changed." :
"Printer \"%s\" state changed.",
job->printer->name);
if (ptr == NULL && !job->status_buffer->bufused)
{
for (i = 0; job->filters[i] < 0; i ++);
if (job->filters[i])
return;
if (job->current_file >= job->num_files && job->backend > 0)
return;
cupsdFinishJob(job);
}
}
void
update_job_attrs(cupsd_job_t *job)
{
int i;
int num_reasons;
const char * const *reasons;
static const char *none = "none",
*paused = "paused";
if (!job->printer_message)
{
if ((job->printer_message = ippFindAttribute(job->attrs,
"job-printer-state-message",
IPP_TAG_TEXT)) == NULL)
job->printer_message = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_TEXT,
"job-printer-state-message",
NULL, "");
}
if (!job->printer_reasons)
job->printer_reasons = ippFindAttribute(job->attrs,
"job-printer-state-reasons",
IPP_TAG_KEYWORD);
if (!job->printer)
return;
if (job->printer->state_message[0])
cupsdSetString(&(job->printer_message->values[0].string.text),
job->printer->state_message);
if (job->printer->num_reasons == 0)
{
num_reasons = 1;
reasons = job->printer->state == IPP_PRINTER_STOPPED ? &paused : &none;
}
else
{
num_reasons = job->printer->num_reasons;
reasons = (const char * const *)job->printer->reasons;
}
if (!job->printer_reasons || job->printer_reasons->num_values != num_reasons)
{
ippDeleteAttribute(job->attrs, job->printer_reasons);
job->printer_reasons = ippAddStrings(job->attrs,
IPP_TAG_JOB, IPP_TAG_KEYWORD,
"job-printer-state-reasons",
num_reasons, NULL, NULL);
}
for (i = 0; i < num_reasons; i ++)
cupsdSetString(&(job->printer_reasons->values[i].string.text), reasons[i]);
}