|
|
/*
|
|
|
* Job management routines for the CUPS scheduler.
|
|
|
*
|
|
|
* Copyright © 2007-2019 by Apple Inc.
|
|
|
* Copyright © 1997-2007 by Easy Software Products, all rights reserved.
|
|
|
*
|
|
|
* Licensed under Apache License v2.0. See the file "LICENSE" for more
|
|
|
* information.
|
|
|
*/
|
|
|
|
|
|
/*
|
|
|
* Include necessary headers...
|
|
|
*/
|
|
|
|
|
|
#include "cupsd.h"
|
|
|
#include <grp.h>
|
|
|
#include <cups/backend.h>
|
|
|
#include <cups/dir.h>
|
|
|
#ifdef __APPLE__
|
|
|
# include <IOKit/pwr_mgt/IOPMLib.h>
|
|
|
# ifdef HAVE_IOKIT_PWR_MGT_IOPMLIBPRIVATE_H
|
|
|
# include <IOKit/pwr_mgt/IOPMLibPrivate.h>
|
|
|
# endif /* HAVE_IOKIT_PWR_MGT_IOPMLIBPRIVATE_H */
|
|
|
#endif /* __APPLE__ */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Design Notes for Job Management
|
|
|
* -------------------------------
|
|
|
*
|
|
|
* STATE CHANGES
|
|
|
*
|
|
|
* pending Do nothing/check jobs
|
|
|
* pending-held Send SIGTERM to filters and backend
|
|
|
* processing Do nothing/start job
|
|
|
* stopped Send SIGKILL to filters and backend
|
|
|
* canceled Send SIGTERM to filters and backend
|
|
|
* aborted Finalize
|
|
|
* completed Finalize
|
|
|
*
|
|
|
* Finalize clears the printer <-> job association, deletes the status
|
|
|
* buffer, closes all of the pipes, etc. and doesn't get run until all of
|
|
|
* the print processes are finished.
|
|
|
*
|
|
|
* UNLOADING OF JOBS (cupsdUnloadCompletedJobs)
|
|
|
*
|
|
|
* We unload the job attributes when they are not needed to reduce overall
|
|
|
* memory consumption. We don't unload jobs where job->state_value <
|
|
|
* IPP_JOB_STOPPED, job->printer != NULL, or job->access_time is recent.
|
|
|
*
|
|
|
* STARTING OF JOBS (start_job)
|
|
|
*
|
|
|
* When a job is started, a status buffer, several pipes, a security
|
|
|
* profile, and a backend process are created for the life of that job.
|
|
|
* These are shared for every file in a job. For remote print jobs, the
|
|
|
* IPP backend is provided with every file in the job and no filters are
|
|
|
* run.
|
|
|
*
|
|
|
* The job->printer member tracks which printer is printing a job, which
|
|
|
* can be different than the destination in job->dest for classes. The
|
|
|
* printer object also has a job pointer to track which job is being
|
|
|
* printed.
|
|
|
*
|
|
|
* PRINTING OF JOB FILES (cupsdContinueJob)
|
|
|
*
|
|
|
* Each file in a job is filtered by 0 or more programs. After getting the
|
|
|
* list of filters needed and the total cost, the job is either passed or
|
|
|
* put back to the processing state until the current FilterLevel comes down
|
|
|
* enough to allow printing.
|
|
|
*
|
|
|
* If we can print, we build a string for the print options and run each of
|
|
|
* the filters, piping the output from one into the next.
|
|
|
*
|
|
|
* JOB STATUS UPDATES (update_job)
|
|
|
*
|
|
|
* The update_job function gets called whenever there are pending messages
|
|
|
* on the status pipe. These generally are updates to the marker-*,
|
|
|
* printer-state-message, or printer-state-reasons attributes. On EOF,
|
|
|
* finalize_job is called to clean up.
|
|
|
*
|
|
|
* FINALIZING JOBS (finalize_job)
|
|
|
*
|
|
|
* When all filters and the backend are done, we set the job state to
|
|
|
* completed (no errors), aborted (filter errors or abort-job policy),
|
|
|
* pending-held (auth required or retry-job policy), or pending
|
|
|
* (retry-current-job or stop-printer policies) as appropriate.
|
|
|
*
|
|
|
* Then we close the pipes and free the status buffers and profiles.
|
|
|
*
|
|
|
* JOB FILE COMPLETION (process_children in main.c)
|
|
|
*
|
|
|
* For multiple-file jobs, process_children (in main.c) sees that all
|
|
|
* filters have exited and calls in to print the next file if there are
|
|
|
* more files in the job, otherwise it waits for the backend to exit and
|
|
|
* update_job to do the cleanup.
|
|
|
*/
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Local globals...
|
|
|
*/
|
|
|
|
|
|
static mime_filter_t gziptoany_filter =
|
|
|
{
|
|
|
NULL, /* Source type */
|
|
|
NULL, /* Destination type */
|
|
|
0, /* Cost */
|
|
|
"gziptoany" /* Filter program to run */
|
|
|
};
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Local functions...
|
|
|
*/
|
|
|
|
|
|
static int compare_active_jobs(void *first, void *second, void *data);
|
|
|
static int compare_completed_jobs(void *first, void *second, void *data);
|
|
|
static int compare_jobs(void *first, void *second, void *data);
|
|
|
static void dump_job_history(cupsd_job_t *job);
|
|
|
static void finalize_job(cupsd_job_t *job, int set_job_state);
|
|
|
static void free_job_history(cupsd_job_t *job);
|
|
|
static char *get_options(cupsd_job_t *job, int banner_page, char *copies,
|
|
|
size_t copies_size, char *title,
|
|
|
size_t title_size);
|
|
|
static size_t 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 remove_job_files(cupsd_job_t *job);
|
|
|
static void remove_job_history(cupsd_job_t *job);
|
|
|
static void set_time(cupsd_job_t *job, const char *name);
|
|
|
static void start_job(cupsd_job_t *job, cupsd_printer_t *printer);
|
|
|
static void stop_job(cupsd_job_t *job, cupsd_jobaction_t action);
|
|
|
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, int do_message);
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdAddJob()' - Add a new job to the job queue.
|
|
|
*/
|
|
|
|
|
|
cupsd_job_t * /* O - New job record */
|
|
|
cupsdAddJob(int priority, /* I - Job priority */
|
|
|
const char *dest) /* I - Job destination */
|
|
|
{
|
|
|
cupsd_job_t *job; /* New job record */
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
/*
|
|
|
* Add the new job to the "all jobs" and "active jobs" lists...
|
|
|
*/
|
|
|
|
|
|
cupsArrayAdd(Jobs, job);
|
|
|
cupsArrayAdd(ActiveJobs, job);
|
|
|
|
|
|
return (job);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdCancelJobs()' - Cancel all jobs for the given destination/user.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdCancelJobs(const char *dest, /* I - Destination to cancel */
|
|
|
const char *username, /* I - Username or NULL */
|
|
|
int purge) /* I - Purge jobs? */
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(Jobs))
|
|
|
{
|
|
|
if ((!job->dest || !job->username) && !cupsdLoadJob(job))
|
|
|
continue;
|
|
|
|
|
|
if ((!dest || !strcmp(job->dest, dest)) &&
|
|
|
(!username || !strcmp(job->username, username)))
|
|
|
{
|
|
|
/*
|
|
|
* Cancel all jobs matching this destination/user...
|
|
|
*/
|
|
|
|
|
|
if (purge)
|
|
|
cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_PURGE,
|
|
|
"Job purged by user.");
|
|
|
else if (job->state_value < IPP_JOB_CANCELED)
|
|
|
cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_DEFAULT,
|
|
|
"Job canceled by user.");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdCheckJobs()' - Check the pending jobs and start any if the destination
|
|
|
* is available.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdCheckJobs(void)
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job in queue */
|
|
|
cupsd_printer_t *printer, /* Printer destination */
|
|
|
*pclass; /* Printer class destination */
|
|
|
ipp_attribute_t *attr; /* Job attribute */
|
|
|
time_t curtime; /* Current time */
|
|
|
const char *reasons; /* job-state-reasons value */
|
|
|
|
|
|
|
|
|
curtime = time(NULL);
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCheckJobs: %d active jobs, sleeping=%d, ac-power=%d, reload=%d, curtime=%ld", cupsArrayCount(ActiveJobs), Sleeping, ACPower, NeedReload, (long)curtime);
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdCheckJobs: Job %d - dest=\"%s\", printer=%p, "
|
|
|
"state=%d, cancel_time=%ld, hold_until=%ld, kill_time=%ld, "
|
|
|
"pending_cost=%d, pending_timeout=%ld", job->id, job->dest,
|
|
|
job->printer, job->state_value, (long)job->cancel_time,
|
|
|
(long)job->hold_until, (long)job->kill_time,
|
|
|
job->pending_cost, (long)job->pending_timeout);
|
|
|
|
|
|
/*
|
|
|
* Kill jobs if they are unresponsive...
|
|
|
*/
|
|
|
|
|
|
if (job->kill_time && job->kill_time <= curtime)
|
|
|
{
|
|
|
if (!job->completed)
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "Stopping unresponsive job.");
|
|
|
|
|
|
stop_job(job, CUPSD_JOB_FORCE);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Cancel stuck jobs...
|
|
|
*/
|
|
|
|
|
|
if (job->cancel_time && job->cancel_time <= curtime)
|
|
|
{
|
|
|
int cancel_after; /* job-cancel-after value */
|
|
|
|
|
|
attr = ippFindAttribute(job->attrs, "job-cancel-after", IPP_TAG_INTEGER);
|
|
|
cancel_after = attr ? ippGetInteger(attr, 0) : MaxJobTime;
|
|
|
|
|
|
if (job->completed)
|
|
|
cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_FORCE, "Marking stuck job as completed after %d seconds.", cancel_after);
|
|
|
else
|
|
|
cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_DEFAULT, "Canceling stuck job after %d seconds.", cancel_after);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Start held jobs if they are ready...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value == IPP_JOB_HELD &&
|
|
|
job->hold_until &&
|
|
|
job->hold_until < curtime)
|
|
|
{
|
|
|
if (job->pending_timeout)
|
|
|
{
|
|
|
/*
|
|
|
* This job is pending; check that we don't have an active Send-Document
|
|
|
* operation in progress on any of the client connections, then timeout
|
|
|
* the job so we can start printing...
|
|
|
*/
|
|
|
|
|
|
cupsd_client_t *con; /* Current client connection */
|
|
|
|
|
|
for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
|
|
|
con;
|
|
|
con = (cupsd_client_t *)cupsArrayNext(Clients))
|
|
|
if (con->request &&
|
|
|
con->request->request.op.operation_id == IPP_SEND_DOCUMENT)
|
|
|
break;
|
|
|
|
|
|
if (con)
|
|
|
continue;
|
|
|
|
|
|
if (cupsdTimeoutJob(job))
|
|
|
continue;
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT, "Job submission timed out.");
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "Job submission timed out.");
|
|
|
}
|
|
|
else
|
|
|
cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT, "Job hold expired.");
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Continue jobs that are waiting on the FilterLimit...
|
|
|
*/
|
|
|
|
|
|
if (job->pending_cost > 0 &&
|
|
|
((FilterLevel + job->pending_cost) < FilterLimit || FilterLevel == 0))
|
|
|
cupsdContinueJob(job);
|
|
|
|
|
|
/*
|
|
|
* Skip jobs that where held-on-create
|
|
|
*/
|
|
|
|
|
|
reasons = ippGetString(job->reasons, 0, NULL);
|
|
|
if (reasons && !strcmp(reasons, "job-held-on-create"))
|
|
|
{
|
|
|
/*
|
|
|
* Check whether the printer is still holding new jobs...
|
|
|
*/
|
|
|
|
|
|
printer = cupsdFindDest(job->dest);
|
|
|
|
|
|
if (printer->holding_new_jobs)
|
|
|
continue;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "none");
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Start pending jobs if the destination is available...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value == IPP_JOB_PENDING && !NeedReload &&
|
|
|
(!Sleeping || ACPower) && !DoingShutdown && !job->printer)
|
|
|
{
|
|
|
printer = cupsdFindDest(job->dest);
|
|
|
pclass = NULL;
|
|
|
|
|
|
while (printer && (printer->type & CUPS_PRINTER_CLASS))
|
|
|
{
|
|
|
/*
|
|
|
* If the class is remote, just pass it to the remote server...
|
|
|
*/
|
|
|
|
|
|
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)
|
|
|
{
|
|
|
/*
|
|
|
* Whoa, the printer and/or class for this destination went away;
|
|
|
* cancel the job...
|
|
|
*/
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_PURGE,
|
|
|
"Job aborted because the destination printer/class "
|
|
|
"has gone away.");
|
|
|
}
|
|
|
else if (printer)
|
|
|
{
|
|
|
/*
|
|
|
* See if the printer is available or remote and not printing a job;
|
|
|
* if so, start the job...
|
|
|
*/
|
|
|
|
|
|
if (pclass)
|
|
|
{
|
|
|
/*
|
|
|
* Add/update a job-printer-uri-actual attribute for this job
|
|
|
* so that we know which printer actually printed the job...
|
|
|
*/
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-printer-uri-actual", IPP_TAG_URI)) != NULL)
|
|
|
ippSetString(job->attrs, &attr, 0, printer->uri);
|
|
|
else
|
|
|
ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_URI, "job-printer-uri-actual", NULL, printer->uri);
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
|
|
|
if (!printer->job && printer->state == IPP_PRINTER_IDLE)
|
|
|
{
|
|
|
/*
|
|
|
* Start the job...
|
|
|
*/
|
|
|
|
|
|
cupsArraySave(ActiveJobs);
|
|
|
start_job(job, printer);
|
|
|
cupsArrayRestore(ActiveJobs);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdCleanJobs()' - Clean out old jobs.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdCleanJobs(void)
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
time_t curtime; /* Current time */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdCleanJobs: MaxJobs=%d, JobHistory=%d, JobFiles=%d",
|
|
|
MaxJobs, JobHistory, JobFiles);
|
|
|
|
|
|
if (MaxJobs <= 0 && JobHistory == INT_MAX && JobFiles == INT_MAX)
|
|
|
return;
|
|
|
|
|
|
curtime = time(NULL);
|
|
|
JobHistoryUpdate = 0;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCleanJobs: curtime=%d", (int)curtime);
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(Jobs))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCleanJobs: Job %d, state=%d, printer=%p, history_time=%d, file_time=%d", job->id, (int)job->state_value, (void *)job->printer, (int)job->history_time, (int)job->file_time);
|
|
|
|
|
|
if ((job->history_time && job->history_time < JobHistoryUpdate) || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->history_time;
|
|
|
|
|
|
if ((job->file_time && job->file_time < JobHistoryUpdate) || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->file_time;
|
|
|
|
|
|
if (job->state_value >= IPP_JOB_CANCELED && !job->printer)
|
|
|
{
|
|
|
/*
|
|
|
* Expire old jobs (or job files)...
|
|
|
*/
|
|
|
|
|
|
if ((MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs) ||
|
|
|
(job->history_time && job->history_time <= curtime))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Removing from history.");
|
|
|
cupsdDeleteJob(job, CUPSD_JOB_PURGE);
|
|
|
}
|
|
|
else if (job->file_time && job->file_time <= curtime && job->num_files > 0)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Removing document files.");
|
|
|
remove_job_files(job);
|
|
|
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCleanJobs: JobHistoryUpdate=%ld",
|
|
|
(long)JobHistoryUpdate);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdContinueJob()' - Continue printing with the next file in a job.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdContinueJob(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
int slot; /* Pipe slot */
|
|
|
cups_array_t *filters = NULL,/* Filters for job */
|
|
|
*prefilters; /* Filters with prefilters */
|
|
|
mime_filter_t *filter, /* Current filter */
|
|
|
*prefilter, /* Prefilter */
|
|
|
port_monitor; /* Port monitor filter */
|
|
|
char scheme[255]; /* Device URI scheme */
|
|
|
ipp_attribute_t *attr; /* Current attribute */
|
|
|
const char *ptr, /* Pointer into value */
|
|
|
*abort_message; /* Abort message */
|
|
|
ipp_jstate_t abort_state = IPP_JOB_STOPPED;
|
|
|
/* New job state on abort */
|
|
|
struct stat backinfo; /* Backend file information */
|
|
|
int backroot; /* Run backend as root? */
|
|
|
int pid; /* Process ID of new filter process */
|
|
|
int banner_page; /* 1 if banner page, 0 otherwise */
|
|
|
int filterfds[2][2] = { { -1, -1 }, { -1, -1 } };
|
|
|
/* Pipes used between filters */
|
|
|
int envc; /* Number of environment variables */
|
|
|
struct stat fileinfo; /* Job file information */
|
|
|
int argc = 0; /* Number of arguments */
|
|
|
char **argv = NULL, /* Filter command-line arguments */
|
|
|
filename[1024], /* Job filename */
|
|
|
command[1024], /* Full path to command */
|
|
|
jobid[255], /* Job ID string */
|
|
|
title[IPP_MAX_NAME],
|
|
|
/* Job title string */
|
|
|
copies[255], /* # copies string */
|
|
|
*options, /* Options string */
|
|
|
*envp[MAX_ENV + 21],
|
|
|
/* Environment variables */
|
|
|
charset[255], /* CHARSET env variable */
|
|
|
class_name[255],/* CLASS env variable */
|
|
|
classification[1024],
|
|
|
/* CLASSIFICATION env variable */
|
|
|
content_type[1024],
|
|
|
/* CONTENT_TYPE env variable */
|
|
|
device_uri[1024],
|
|
|
/* DEVICE_URI env variable */
|
|
|
final_content_type[1024] = "",
|
|
|
/* FINAL_CONTENT_TYPE env variable */
|
|
|
lang[255], /* LANG env variable */
|
|
|
#ifdef __APPLE__
|
|
|
apple_language[255],
|
|
|
/* APPLE_LANGUAGE env variable */
|
|
|
#endif /* __APPLE__ */
|
|
|
auth_info_required[255],
|
|
|
/* AUTH_INFO_REQUIRED env variable */
|
|
|
ppd[1024], /* PPD env variable */
|
|
|
printer_info[255],
|
|
|
/* PRINTER_INFO env variable */
|
|
|
printer_location[255],
|
|
|
/* PRINTER_LOCATION env variable */
|
|
|
printer_name[255],
|
|
|
/* PRINTER env variable */
|
|
|
*printer_state_reasons = NULL,
|
|
|
/* PRINTER_STATE_REASONS env var */
|
|
|
rip_max_cache[255];
|
|
|
/* RIP_MAX_CACHE env variable */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdContinueJob(job=%p(%d)): current_file=%d, num_files=%d",
|
|
|
job, job->id, job->current_file, job->num_files);
|
|
|
|
|
|
/*
|
|
|
* Figure out what filters are required to convert from
|
|
|
* the source to the destination type...
|
|
|
*/
|
|
|
|
|
|
FilterLevel -= job->cost;
|
|
|
|
|
|
job->cost = 0;
|
|
|
job->pending_cost = 0;
|
|
|
|
|
|
memset(job->filters, 0, sizeof(job->filters));
|
|
|
|
|
|
if (job->printer->raw)
|
|
|
{
|
|
|
/*
|
|
|
* Remote jobs and raw queues go directly to the printer without
|
|
|
* filtering...
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Sending job to queue tagged as raw...");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Local jobs get filtered...
|
|
|
*/
|
|
|
|
|
|
mime_type_t *dst = job->printer->filetype;
|
|
|
/* Destination file type */
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
|
|
|
job->id, job->current_file + 1);
|
|
|
if (stat(filename, &fileinfo))
|
|
|
fileinfo.st_size = 0;
|
|
|
|
|
|
if (job->retry_as_raster)
|
|
|
{
|
|
|
/*
|
|
|
* Need to figure out whether the printer supports image/pwg-raster or
|
|
|
* image/urf, and use the corresponding type...
|
|
|
*/
|
|
|
|
|
|
char type[MIME_MAX_TYPE]; /* MIME media type for printer */
|
|
|
|
|
|
snprintf(type, sizeof(type), "%s/image/urf", job->printer->name);
|
|
|
if ((dst = mimeType(MimeDatabase, "printer", type)) == NULL)
|
|
|
{
|
|
|
snprintf(type, sizeof(type), "%s/image/pwg-raster", job->printer->name);
|
|
|
dst = mimeType(MimeDatabase, "printer", type);
|
|
|
}
|
|
|
|
|
|
if (dst)
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Retrying job as \"%s\".", strchr(dst->type, '/') + 1);
|
|
|
else
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to retry job using a supported raster format.");
|
|
|
}
|
|
|
|
|
|
filters = mimeFilter2(MimeDatabase, job->filetypes[job->current_file], (size_t)fileinfo.st_size, dst, &(job->cost));
|
|
|
|
|
|
if (!filters)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Unable to convert file %d to printable format.",
|
|
|
job->current_file);
|
|
|
|
|
|
abort_message = "Aborting job because it cannot be printed.";
|
|
|
abort_state = IPP_JOB_ABORTED;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "document-unprintable-error");
|
|
|
goto abort_job;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Figure out the final content type...
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "%d filters for job:",
|
|
|
cupsArrayCount(filters));
|
|
|
for (filter = (mime_filter_t *)cupsArrayFirst(filters);
|
|
|
filter;
|
|
|
filter = (mime_filter_t *)cupsArrayNext(filters))
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "%s (%s/%s to %s/%s, cost %d)",
|
|
|
filter->filter,
|
|
|
filter->src ? filter->src->super : "???",
|
|
|
filter->src ? filter->src->type : "???",
|
|
|
filter->dst ? filter->dst->super : "???",
|
|
|
filter->dst ? filter->dst->type : "???",
|
|
|
filter->cost);
|
|
|
|
|
|
if (!job->printer->remote)
|
|
|
{
|
|
|
for (filter = (mime_filter_t *)cupsArrayLast(filters);
|
|
|
filter && filter->dst;
|
|
|
filter = (mime_filter_t *)cupsArrayPrev(filters))
|
|
|
if (strcmp(filter->dst->super, "printer") ||
|
|
|
strcmp(filter->dst->type, job->printer->name))
|
|
|
break;
|
|
|
|
|
|
if (filter && filter->dst)
|
|
|
{
|
|
|
if ((ptr = strchr(filter->dst->type, '/')) != NULL)
|
|
|
snprintf(final_content_type, sizeof(final_content_type),
|
|
|
"FINAL_CONTENT_TYPE=%s", ptr + 1);
|
|
|
else
|
|
|
snprintf(final_content_type, sizeof(final_content_type),
|
|
|
"FINAL_CONTENT_TYPE=%s/%s", filter->dst->super,
|
|
|
filter->dst->type);
|
|
|
}
|
|
|
else
|
|
|
snprintf(final_content_type, sizeof(final_content_type),
|
|
|
"FINAL_CONTENT_TYPE=printer/%s", job->printer->name);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Remove NULL ("-") filters...
|
|
|
*/
|
|
|
|
|
|
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 this printer has any pre-filters, insert the required pre-filter
|
|
|
* in the filters array...
|
|
|
*/
|
|
|
|
|
|
if (job->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,
|
|
|
job->printer->prefiltertype)))
|
|
|
{
|
|
|
cupsArrayAdd(prefilters, prefilter);
|
|
|
job->cost += prefilter->cost;
|
|
|
}
|
|
|
|
|
|
cupsArrayAdd(prefilters, filter);
|
|
|
}
|
|
|
|
|
|
cupsArrayDelete(filters);
|
|
|
filters = prefilters;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Set a minimum cost of 100 for all jobs so that FilterLimit
|
|
|
* works with raw queues and other low-cost paths.
|
|
|
*/
|
|
|
|
|
|
if (job->cost < 100)
|
|
|
job->cost = 100;
|
|
|
|
|
|
/*
|
|
|
* See if the filter cost is too high...
|
|
|
*/
|
|
|
|
|
|
if ((FilterLevel + job->cost) > FilterLimit && FilterLevel > 0 &&
|
|
|
FilterLimit > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Don't print this job quite yet...
|
|
|
*/
|
|
|
|
|
|
cupsArrayDelete(filters);
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO,
|
|
|
"Holding because filter limit has been reached.");
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2,
|
|
|
"cupsdContinueJob: file=%d, cost=%d, level=%d, limit=%d",
|
|
|
job->current_file, job->cost, FilterLevel,
|
|
|
FilterLimit);
|
|
|
|
|
|
job->pending_cost = job->cost;
|
|
|
job->cost = 0;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
FilterLevel += job->cost;
|
|
|
|
|
|
/*
|
|
|
* Add decompression/raw filter as needed...
|
|
|
*/
|
|
|
|
|
|
if ((job->compressions[job->current_file] && (!job->printer->remote || job->num_files == 1)) ||
|
|
|
(!job->printer->remote && job->printer->raw && job->num_files > 1))
|
|
|
{
|
|
|
/*
|
|
|
* Add gziptoany filter to the front of the list...
|
|
|
*/
|
|
|
|
|
|
if (!filters)
|
|
|
filters = cupsArrayNew(NULL, NULL);
|
|
|
|
|
|
if (!cupsArrayInsert(filters, &gziptoany_filter))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Unable to add decompression filter - %s", strerror(errno));
|
|
|
|
|
|
cupsArrayDelete(filters);
|
|
|
|
|
|
abort_message = "Stopping job because the scheduler ran out of memory.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Add port monitor, if any...
|
|
|
*/
|
|
|
|
|
|
if (job->printer->port_monitor)
|
|
|
{
|
|
|
/*
|
|
|
* Add port monitor to the end of the list...
|
|
|
*/
|
|
|
|
|
|
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, job->printer->port_monitor);
|
|
|
|
|
|
if (!cupsArrayAdd(filters, &port_monitor))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Unable to add port monitor - %s", strerror(errno));
|
|
|
|
|
|
abort_message = "Stopping job because the scheduler ran out of memory.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Make sure we don't go over the "MAX_FILTERS" limit...
|
|
|
*/
|
|
|
|
|
|
if (cupsArrayCount(filters) > MAX_FILTERS)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Too many filters (%d > %d), unable to print.",
|
|
|
cupsArrayCount(filters), MAX_FILTERS);
|
|
|
|
|
|
abort_message = "Aborting job because it needs too many filters to print.";
|
|
|
abort_state = IPP_JOB_ABORTED;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "document-unprintable-error");
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Determine if we are printing a banner page or not...
|
|
|
*/
|
|
|
|
|
|
if (job->job_sheets == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "No job-sheets attribute.");
|
|
|
if ((job->job_sheets =
|
|
|
ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_ZERO)) != NULL)
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"... but someone added one without setting job_sheets.");
|
|
|
}
|
|
|
else if (job->job_sheets->num_values == 1)
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-sheets=%s",
|
|
|
job->job_sheets->values[0].string.text);
|
|
|
else
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-sheets=%s,%s",
|
|
|
job->job_sheets->values[0].string.text,
|
|
|
job->job_sheets->values[1].string.text);
|
|
|
|
|
|
if (job->printer->type & CUPS_PRINTER_REMOTE)
|
|
|
banner_page = 0;
|
|
|
else if (job->job_sheets == NULL)
|
|
|
banner_page = 0;
|
|
|
else if (_cups_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 &&
|
|
|
_cups_strcasecmp(job->job_sheets->values[1].string.text, "none") != 0 &&
|
|
|
job->current_file == (job->num_files - 1))
|
|
|
banner_page = 1;
|
|
|
else
|
|
|
banner_page = 0;
|
|
|
|
|
|
if ((options = get_options(job, banner_page, copies, sizeof(copies), title,
|
|
|
sizeof(title))) == NULL)
|
|
|
{
|
|
|
abort_message = "Stopping job because the scheduler ran out of memory.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Build the command-line arguments for the filters. Each filter
|
|
|
* has 6 or 7 arguments:
|
|
|
*
|
|
|
* argv[0] = printer
|
|
|
* argv[1] = job ID
|
|
|
* argv[2] = username
|
|
|
* argv[3] = title
|
|
|
* argv[4] = # copies
|
|
|
* argv[5] = options
|
|
|
* argv[6] = filename (optional; normally stdin)
|
|
|
*
|
|
|
* This allows legacy printer drivers that use the old System V
|
|
|
* printing interface to be used by CUPS.
|
|
|
*
|
|
|
* For remote jobs, we send all of the files in the argument list.
|
|
|
*/
|
|
|
|
|
|
if (job->printer->remote)
|
|
|
argc = 6 + job->num_files;
|
|
|
else
|
|
|
argc = 7;
|
|
|
|
|
|
if ((argv = calloc((size_t)argc + 1, sizeof(char *))) == NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG, "Unable to allocate argument array - %s",
|
|
|
strerror(errno));
|
|
|
|
|
|
abort_message = "Stopping job because the scheduler ran out of memory.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
|
|
|
sprintf(jobid, "%d", job->id);
|
|
|
|
|
|
argv[0] = job->printer->name;
|
|
|
argv[1] = jobid;
|
|
|
argv[2] = job->username;
|
|
|
argv[3] = title;
|
|
|
argv[4] = copies;
|
|
|
argv[5] = options;
|
|
|
|
|
|
if (job->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] = strdup(filename);
|
|
|
}
|
|
|
|
|
|
for (i = 0; argv[i]; i ++)
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "argv[%d]=\"%s\"", i, argv[i]);
|
|
|
|
|
|
/*
|
|
|
* Create environment variable strings for the filters...
|
|
|
*/
|
|
|
|
|
|
attr = ippFindAttribute(job->attrs, "attributes-natural-language",
|
|
|
IPP_TAG_LANGUAGE);
|
|
|
|
|
|
#ifdef __APPLE__
|
|
|
strlcpy(apple_language, "APPLE_LANGUAGE=", sizeof(apple_language));
|
|
|
_cupsAppleLanguage(attr->values[0].string.text,
|
|
|
apple_language + 15, sizeof(apple_language) - 15);
|
|
|
#endif /* __APPLE__ */
|
|
|
|
|
|
switch (strlen(attr->values[0].string.text))
|
|
|
{
|
|
|
default :
|
|
|
/*
|
|
|
* This is an unknown or badly formatted language code; use
|
|
|
* the POSIX locale...
|
|
|
*/
|
|
|
|
|
|
strlcpy(lang, "LANG=C", sizeof(lang));
|
|
|
break;
|
|
|
|
|
|
case 2 :
|
|
|
/*
|
|
|
* Just the language code (ll)...
|
|
|
*/
|
|
|
|
|
|
snprintf(lang, sizeof(lang), "LANG=%s.UTF-8",
|
|
|
attr->values[0].string.text);
|
|
|
break;
|
|
|
|
|
|
case 5 :
|
|
|
/*
|
|
|
* Language and country code (ll-cc)...
|
|
|
*/
|
|
|
|
|
|
snprintf(lang, sizeof(lang), "LANG=%c%c_%c%c.UTF-8",
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "document-format",
|
|
|
IPP_TAG_MIMETYPE)) != NULL &&
|
|
|
(ptr = strstr(attr->values[0].string.text, "charset=")) != NULL)
|
|
|
snprintf(charset, sizeof(charset), "CHARSET=%s", ptr + 8);
|
|
|
else
|
|
|
strlcpy(charset, "CHARSET=utf-8", sizeof(charset));
|
|
|
|
|
|
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",
|
|
|
job->printer->device_uri);
|
|
|
snprintf(ppd, sizeof(ppd), "PPD=%s/ppd/%s.ppd", ServerRoot,
|
|
|
job->printer->name);
|
|
|
snprintf(printer_info, sizeof(printer_name), "PRINTER_INFO=%s",
|
|
|
job->printer->info ? job->printer->info : "");
|
|
|
snprintf(printer_location, sizeof(printer_name), "PRINTER_LOCATION=%s",
|
|
|
job->printer->location ? job->printer->location : "");
|
|
|
snprintf(printer_name, sizeof(printer_name), "PRINTER=%s", job->printer->name);
|
|
|
if (job->printer->num_reasons > 0)
|
|
|
{
|
|
|
char *psrptr; /* Pointer into PRINTER_STATE_REASONS */
|
|
|
size_t psrlen; /* Size of PRINTER_STATE_REASONS */
|
|
|
|
|
|
for (psrlen = 22, i = 0; i < job->printer->num_reasons; i ++)
|
|
|
psrlen += strlen(job->printer->reasons[i]) + 1;
|
|
|
|
|
|
if ((printer_state_reasons = malloc(psrlen)) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* All of these strcpy's are safe because we allocated the psr string...
|
|
|
*/
|
|
|
|
|
|
strlcpy(printer_state_reasons, "PRINTER_STATE_REASONS=", psrlen);
|
|
|
for (psrptr = printer_state_reasons + 22, i = 0;
|
|
|
i < job->printer->num_reasons;
|
|
|
i ++)
|
|
|
{
|
|
|
if (i)
|
|
|
*psrptr++ = ',';
|
|
|
strlcpy(psrptr, job->printer->reasons[i], psrlen - (size_t)(psrptr - printer_state_reasons));
|
|
|
psrptr += strlen(psrptr);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
snprintf(rip_max_cache, sizeof(rip_max_cache), "RIP_MAX_CACHE=%s", RIPCache);
|
|
|
|
|
|
if (job->printer->num_auth_info_required == 1)
|
|
|
snprintf(auth_info_required, sizeof(auth_info_required),
|
|
|
"AUTH_INFO_REQUIRED=%s",
|
|
|
job->printer->auth_info_required[0]);
|
|
|
else if (job->printer->num_auth_info_required == 2)
|
|
|
snprintf(auth_info_required, sizeof(auth_info_required),
|
|
|
"AUTH_INFO_REQUIRED=%s,%s",
|
|
|
job->printer->auth_info_required[0],
|
|
|
job->printer->auth_info_required[1]);
|
|
|
else if (job->printer->num_auth_info_required == 3)
|
|
|
snprintf(auth_info_required, sizeof(auth_info_required),
|
|
|
"AUTH_INFO_REQUIRED=%s,%s,%s",
|
|
|
job->printer->auth_info_required[0],
|
|
|
job->printer->auth_info_required[1],
|
|
|
job->printer->auth_info_required[2]);
|
|
|
else if (job->printer->num_auth_info_required == 4)
|
|
|
snprintf(auth_info_required, sizeof(auth_info_required),
|
|
|
"AUTH_INFO_REQUIRED=%s,%s,%s,%s",
|
|
|
job->printer->auth_info_required[0],
|
|
|
job->printer->auth_info_required[1],
|
|
|
job->printer->auth_info_required[2],
|
|
|
job->printer->auth_info_required[3]);
|
|
|
else
|
|
|
strlcpy(auth_info_required, "AUTH_INFO_REQUIRED=none",
|
|
|
sizeof(auth_info_required));
|
|
|
|
|
|
envc = cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
|
|
|
|
|
|
envp[envc ++] = charset;
|
|
|
envp[envc ++] = lang;
|
|
|
#ifdef __APPLE__
|
|
|
envp[envc ++] = apple_language;
|
|
|
#endif /* __APPLE__ */
|
|
|
envp[envc ++] = ppd;
|
|
|
envp[envc ++] = rip_max_cache;
|
|
|
envp[envc ++] = content_type;
|
|
|
envp[envc ++] = device_uri;
|
|
|
envp[envc ++] = printer_info;
|
|
|
envp[envc ++] = printer_location;
|
|
|
envp[envc ++] = printer_name;
|
|
|
envp[envc ++] = printer_state_reasons ? printer_state_reasons :
|
|
|
"PRINTER_STATE_REASONS=none";
|
|
|
envp[envc ++] = banner_page ? "CUPS_FILETYPE=job-sheet" :
|
|
|
"CUPS_FILETYPE=document";
|
|
|
|
|
|
if (final_content_type[0])
|
|
|
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)
|
|
|
{
|
|
|
snprintf(class_name, sizeof(class_name), "CLASS=%s", job->dest);
|
|
|
envp[envc ++] = class_name;
|
|
|
}
|
|
|
|
|
|
envp[envc ++] = auth_info_required;
|
|
|
|
|
|
for (i = 0;
|
|
|
i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
|
|
|
i ++)
|
|
|
if (job->auth_env[i])
|
|
|
envp[envc ++] = job->auth_env[i];
|
|
|
else
|
|
|
break;
|
|
|
|
|
|
if (job->auth_uid)
|
|
|
envp[envc ++] = job->auth_uid;
|
|
|
|
|
|
envp[envc] = NULL;
|
|
|
|
|
|
for (i = 0; i < envc; i ++)
|
|
|
if (!strncmp(envp[i], "AUTH_", 5))
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "envp[%d]=\"AUTH_%c****\"", i,
|
|
|
envp[i][5]);
|
|
|
else if (strncmp(envp[i], "DEVICE_URI=", 11))
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "envp[%d]=\"%s\"", i, envp[i]);
|
|
|
else
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "envp[%d]=\"DEVICE_URI=%s\"", i,
|
|
|
job->printer->sanitized_device_uri);
|
|
|
|
|
|
if (job->printer->remote)
|
|
|
job->current_file = job->num_files;
|
|
|
else
|
|
|
job->current_file ++;
|
|
|
|
|
|
/*
|
|
|
* Now create processes for all of the 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]))
|
|
|
{
|
|
|
abort_message = "Stopping job because the scheduler could not create "
|
|
|
"the filter pipes.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (job->current_file == 1 ||
|
|
|
(job->printer->pc && job->printer->pc->single_file))
|
|
|
{
|
|
|
if (strncmp(job->printer->device_uri, "file:", 5) != 0)
|
|
|
{
|
|
|
if (cupsdOpenPipe(job->print_pipes))
|
|
|
{
|
|
|
abort_message = "Stopping job because the scheduler could not "
|
|
|
"create the backend pipes.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
job->print_pipes[0] = -1;
|
|
|
if (!strcmp(job->printer->device_uri, "file:/dev/null") ||
|
|
|
!strcmp(job->printer->device_uri, "file:///dev/null"))
|
|
|
job->print_pipes[1] = -1;
|
|
|
else
|
|
|
{
|
|
|
if (!strncmp(job->printer->device_uri, "file:/dev/", 10))
|
|
|
job->print_pipes[1] = open(job->printer->device_uri + 5,
|
|
|
O_WRONLY | O_EXCL);
|
|
|
else if (!strncmp(job->printer->device_uri, "file:///dev/", 12))
|
|
|
job->print_pipes[1] = open(job->printer->device_uri + 7,
|
|
|
O_WRONLY | O_EXCL);
|
|
|
else if (!strncmp(job->printer->device_uri, "file:///", 8))
|
|
|
job->print_pipes[1] = open(job->printer->device_uri + 7,
|
|
|
O_WRONLY | O_CREAT | O_TRUNC, 0600);
|
|
|
else
|
|
|
job->print_pipes[1] = open(job->printer->device_uri + 5,
|
|
|
O_WRONLY | O_CREAT | O_TRUNC, 0600);
|
|
|
|
|
|
if (job->print_pipes[1] < 0)
|
|
|
{
|
|
|
abort_message = "Stopping job because the scheduler 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);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
filterfds[slot][0] = job->print_pipes[0];
|
|
|
filterfds[slot][1] = job->print_pipes[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->profile, job, job->filters + i);
|
|
|
|
|
|
cupsdClosePipe(filterfds[!slot]);
|
|
|
|
|
|
if (pid == 0)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to start filter \"%s\" - %s.",
|
|
|
filter->filter, strerror(errno));
|
|
|
|
|
|
abort_message = "Stopping job because the scheduler could not execute a "
|
|
|
"filter.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO, "Started filter %s (PID %d)", command,
|
|
|
pid);
|
|
|
|
|
|
if (argv[6])
|
|
|
{
|
|
|
free(argv[6]);
|
|
|
argv[6] = NULL;
|
|
|
}
|
|
|
|
|
|
slot = !slot;
|
|
|
}
|
|
|
|
|
|
cupsArrayDelete(filters);
|
|
|
filters = NULL;
|
|
|
|
|
|
/*
|
|
|
* Finally, pipe the final output into a backend process if needed...
|
|
|
*/
|
|
|
|
|
|
if (strncmp(job->printer->device_uri, "file:", 5) != 0)
|
|
|
{
|
|
|
if (job->current_file == 1 || job->printer->remote ||
|
|
|
(job->printer->pc && job->printer->pc->single_file))
|
|
|
{
|
|
|
sscanf(job->printer->device_uri, "%254[^:]", scheme);
|
|
|
snprintf(command, sizeof(command), "%s/backend/%s", ServerBin, scheme);
|
|
|
|
|
|
/*
|
|
|
* See if the backend needs to run as root...
|
|
|
*/
|
|
|
|
|
|
if (RunUser)
|
|
|
backroot = 0;
|
|
|
else if (stat(command, &backinfo))
|
|
|
backroot = 0;
|
|
|
else
|
|
|
backroot = !(backinfo.st_mode & (S_IWGRP | S_IRWXO));
|
|
|
|
|
|
argv[0] = job->printer->sanitized_device_uri;
|
|
|
|
|
|
filterfds[slot][0] = -1;
|
|
|
filterfds[slot][1] = -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->bprofile, job, &(job->backend));
|
|
|
|
|
|
if (pid == 0)
|
|
|
{
|
|
|
abort_message = "Stopping job because the sheduler could not execute "
|
|
|
"the backend.";
|
|
|
|
|
|
goto abort_job;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO, "Started backend %s (PID %d)",
|
|
|
command, pid);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (job->current_file == job->num_files ||
|
|
|
(job->printer->pc && job->printer->pc->single_file))
|
|
|
cupsdClosePipe(job->print_pipes);
|
|
|
|
|
|
if (job->current_file == job->num_files)
|
|
|
{
|
|
|
cupsdClosePipe(job->back_pipes);
|
|
|
cupsdClosePipe(job->side_pipes);
|
|
|
|
|
|
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 ||
|
|
|
(job->printer->pc && job->printer->pc->single_file))
|
|
|
cupsdClosePipe(job->print_pipes);
|
|
|
|
|
|
if (job->current_file == job->num_files)
|
|
|
{
|
|
|
close(job->status_pipes[1]);
|
|
|
job->status_pipes[1] = -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsdClosePipe(filterfds[slot]);
|
|
|
|
|
|
for (i = 6; i < argc; i ++)
|
|
|
free(argv[i]);
|
|
|
free(argv);
|
|
|
|
|
|
if (printer_state_reasons)
|
|
|
free(printer_state_reasons);
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
/*
|
|
|
* If we get here, we need to abort the current job and close out all
|
|
|
* files and pipes...
|
|
|
*/
|
|
|
|
|
|
abort_job:
|
|
|
|
|
|
FilterLevel -= job->cost;
|
|
|
job->cost = 0;
|
|
|
|
|
|
for (slot = 0; slot < 2; slot ++)
|
|
|
cupsdClosePipe(filterfds[slot]);
|
|
|
|
|
|
cupsArrayDelete(filters);
|
|
|
|
|
|
if (argv)
|
|
|
{
|
|
|
for (i = 6; i < argc; i ++)
|
|
|
free(argv[i]);
|
|
|
|
|
|
free(argv);
|
|
|
}
|
|
|
|
|
|
if (printer_state_reasons)
|
|
|
free(printer_state_reasons);
|
|
|
|
|
|
cupsdClosePipe(job->print_pipes);
|
|
|
cupsdClosePipe(job->back_pipes);
|
|
|
cupsdClosePipe(job->side_pipes);
|
|
|
|
|
|
cupsdRemoveSelect(job->status_pipes[0]);
|
|
|
cupsdClosePipe(job->status_pipes);
|
|
|
cupsdStatBufDelete(job->status_buffer);
|
|
|
job->status_buffer = NULL;
|
|
|
|
|
|
/*
|
|
|
* Update the printer and job state.
|
|
|
*/
|
|
|
|
|
|
cupsdSetJobState(job, abort_state, CUPSD_JOB_DEFAULT, "%s", abort_message);
|
|
|
cupsdSetPrinterState(job->printer, IPP_PRINTER_IDLE, 0);
|
|
|
update_job_attrs(job, 0);
|
|
|
|
|
|
if (job->history)
|
|
|
free_job_history(job);
|
|
|
|
|
|
cupsArrayRemove(PrintingJobs, job);
|
|
|
|
|
|
/*
|
|
|
* Clear the printer <-> job association...
|
|
|
*/
|
|
|
|
|
|
job->printer->job = NULL;
|
|
|
job->printer = NULL;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdDeleteJob()' - Free all memory used by a job.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdDeleteJob(cupsd_job_t *job, /* I - Job */
|
|
|
cupsd_jobaction_t action)/* I - Action */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
|
|
|
|
|
|
if (job->printer)
|
|
|
finalize_job(job, 1);
|
|
|
|
|
|
if (action == CUPSD_JOB_PURGE)
|
|
|
remove_job_history(job);
|
|
|
|
|
|
cupsdClearString(&job->username);
|
|
|
cupsdClearString(&job->dest);
|
|
|
for (i = 0;
|
|
|
i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
|
|
|
i ++)
|
|
|
cupsdClearString(job->auth_env + i);
|
|
|
cupsdClearString(&job->auth_uid);
|
|
|
|
|
|
if (action == CUPSD_JOB_PURGE)
|
|
|
remove_job_files(job);
|
|
|
else if (job->num_files > 0)
|
|
|
{
|
|
|
free(job->compressions);
|
|
|
free(job->filetypes);
|
|
|
|
|
|
job->num_files = 0;
|
|
|
}
|
|
|
|
|
|
if (job->history)
|
|
|
free_job_history(job);
|
|
|
|
|
|
unload_job(job);
|
|
|
|
|
|
cupsArrayRemove(Jobs, job);
|
|
|
cupsArrayRemove(ActiveJobs, job);
|
|
|
cupsArrayRemove(PrintingJobs, job);
|
|
|
|
|
|
free(job);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdFreeAllJobs()' - Free all jobs from memory.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdFreeAllJobs(void)
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
|
|
|
|
|
|
if (!Jobs)
|
|
|
return;
|
|
|
|
|
|
cupsdHoldSignals();
|
|
|
|
|
|
cupsdStopAllJobs(CUPSD_JOB_FORCE, 0);
|
|
|
cupsdSaveAllJobs();
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(Jobs))
|
|
|
cupsdDeleteJob(job, CUPSD_JOB_DEFAULT);
|
|
|
|
|
|
cupsdReleaseSignals();
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdFindJob()' - Find the specified job.
|
|
|
*/
|
|
|
|
|
|
cupsd_job_t * /* O - Job data */
|
|
|
cupsdFindJob(int id) /* I - Job ID */
|
|
|
{
|
|
|
cupsd_job_t key; /* Search key */
|
|
|
|
|
|
|
|
|
key.id = id;
|
|
|
|
|
|
return ((cupsd_job_t *)cupsArrayFind(Jobs, &key));
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdGetCompletedJobs()'- Generate a completed jobs list.
|
|
|
*/
|
|
|
|
|
|
cups_array_t * /* O - Array of jobs */
|
|
|
cupsdGetCompletedJobs(
|
|
|
cupsd_printer_t *p) /* I - Printer */
|
|
|
{
|
|
|
cups_array_t *list; /* Array of jobs */
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
|
|
|
|
|
|
list = cupsArrayNew(compare_completed_jobs, NULL);
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(Jobs))
|
|
|
if ((!p || !_cups_strcasecmp(p->name, job->dest)) && job->state_value >= IPP_JOB_STOPPED && job->completed_time)
|
|
|
cupsArrayAdd(list, job);
|
|
|
|
|
|
return (list);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdGetPrinterJobCount()' - Get the number of pending, processing,
|
|
|
* or held jobs in a printer or class.
|
|
|
*/
|
|
|
|
|
|
int /* O - Job count */
|
|
|
cupsdGetPrinterJobCount(
|
|
|
const char *dest) /* I - Printer or class name */
|
|
|
{
|
|
|
int count; /* Job count */
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
|
|
|
if (job->dest && !_cups_strcasecmp(job->dest, dest))
|
|
|
count ++;
|
|
|
|
|
|
return (count);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdGetUserJobCount()' - Get the number of pending, processing,
|
|
|
* or held jobs for a user.
|
|
|
*/
|
|
|
|
|
|
int /* O - Job count */
|
|
|
cupsdGetUserJobCount(
|
|
|
const char *username) /* I - Username */
|
|
|
{
|
|
|
int count; /* Job count */
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
|
|
|
if (!_cups_strcasecmp(job->username, username))
|
|
|
count ++;
|
|
|
|
|
|
return (count);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdLoadAllJobs()' - Load all jobs from disk.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdLoadAllJobs(void)
|
|
|
{
|
|
|
char filename[1024]; /* Full filename of job.cache file */
|
|
|
struct stat fileinfo; /* Information on job.cache file */
|
|
|
cups_dir_t *dir; /* RequestRoot dir */
|
|
|
cups_dentry_t *dent; /* Entry in RequestRoot */
|
|
|
int load_cache = 1; /* Load the job.cache file? */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Create the job arrays as needed...
|
|
|
*/
|
|
|
|
|
|
if (!Jobs)
|
|
|
Jobs = cupsArrayNew(compare_jobs, NULL);
|
|
|
|
|
|
if (!ActiveJobs)
|
|
|
ActiveJobs = cupsArrayNew(compare_active_jobs, NULL);
|
|
|
|
|
|
if (!PrintingJobs)
|
|
|
PrintingJobs = cupsArrayNew(compare_jobs, NULL);
|
|
|
|
|
|
/*
|
|
|
* See whether the job.cache file is older than the RequestRoot directory...
|
|
|
*/
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
|
|
|
|
|
|
if (stat(filename, &fileinfo))
|
|
|
{
|
|
|
/*
|
|
|
* No job.cache file...
|
|
|
*/
|
|
|
|
|
|
load_cache = 0;
|
|
|
|
|
|
if (errno != ENOENT)
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Unable to get file information for \"%s\" - %s",
|
|
|
filename, strerror(errno));
|
|
|
}
|
|
|
else if ((dir = cupsDirOpen(RequestRoot)) == NULL)
|
|
|
{
|
|
|
/*
|
|
|
* No spool directory...
|
|
|
*/
|
|
|
|
|
|
load_cache = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
while ((dent = cupsDirRead(dir)) != NULL)
|
|
|
{
|
|
|
if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c' && dent->fileinfo.st_mtime > fileinfo.st_mtime)
|
|
|
{
|
|
|
/*
|
|
|
* Job history file is newer than job.cache file...
|
|
|
*/
|
|
|
|
|
|
load_cache = 0;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsDirClose(dir);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Load the most recent source for job data...
|
|
|
*/
|
|
|
|
|
|
if (load_cache)
|
|
|
{
|
|
|
/*
|
|
|
* Load the job.cache file...
|
|
|
*/
|
|
|
|
|
|
load_job_cache(filename);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Load the job history files...
|
|
|
*/
|
|
|
|
|
|
load_request_root();
|
|
|
|
|
|
load_next_job_id(filename);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Clean out old jobs as needed...
|
|
|
*/
|
|
|
|
|
|
if (MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs)
|
|
|
cupsdCleanJobs();
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdLoadJob()' - Load a single job.
|
|
|
*/
|
|
|
|
|
|
int /* O - 1 on success, 0 on failure */
|
|
|
cupsdLoadJob(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
char jobfile[1024]; /* Job filename */
|
|
|
cups_file_t *fp; /* Job file */
|
|
|
int fileid; /* Current file ID */
|
|
|
ipp_attribute_t *attr; /* Job attribute */
|
|
|
const char *dest; /* Destination name */
|
|
|
cupsd_printer_t *destptr; /* Pointer to destination */
|
|
|
mime_type_t **filetypes; /* New filetypes array */
|
|
|
int *compressions; /* New compressions array */
|
|
|
|
|
|
|
|
|
if (job->attrs)
|
|
|
{
|
|
|
if (job->state_value > IPP_JOB_STOPPED)
|
|
|
job->access_time = time(NULL);
|
|
|
|
|
|
return (1);
|
|
|
}
|
|
|
|
|
|
if ((job->attrs = ippNew()) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "Ran out of memory for job attributes.");
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Load job attributes...
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Loading attributes...");
|
|
|
|
|
|
snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, job->id);
|
|
|
if ((fp = cupsdOpenConfFile(jobfile)) == NULL)
|
|
|
goto error;
|
|
|
|
|
|
if (ippReadIO(fp, (ipp_iocb_t)cupsFileRead, 1, NULL, job->attrs) != IPP_DATA)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Unable to read job control file \"%s\".", jobfile);
|
|
|
cupsFileClose(fp);
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
|
|
|
/*
|
|
|
* Copy attribute data to the job object...
|
|
|
*/
|
|
|
|
|
|
if (!ippFindAttribute(job->attrs, "time-at-creation", IPP_TAG_INTEGER))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Missing or bad time-at-creation attribute in control file.");
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
if ((job->state = ippFindAttribute(job->attrs, "job-state",
|
|
|
IPP_TAG_ENUM)) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Missing or bad job-state attribute in control file.");
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
job->state_value = (ipp_jstate_t)job->state->values[0].integer;
|
|
|
job->file_time = 0;
|
|
|
job->history_time = 0;
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "time-at-creation", IPP_TAG_INTEGER)) != NULL)
|
|
|
job->creation_time = attr->values[0].integer;
|
|
|
|
|
|
if (job->state_value >= IPP_JOB_CANCELED && (attr = ippFindAttribute(job->attrs, "time-at-completed", IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
job->completed_time = attr->values[0].integer;
|
|
|
|
|
|
if (JobHistory < INT_MAX)
|
|
|
job->history_time = job->completed_time + JobHistory;
|
|
|
else
|
|
|
job->history_time = INT_MAX;
|
|
|
|
|
|
if (job->history_time < time(NULL))
|
|
|
goto error; /* Expired, remove from history */
|
|
|
|
|
|
if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->history_time;
|
|
|
|
|
|
if (JobFiles < INT_MAX)
|
|
|
job->file_time = job->completed_time + JobFiles;
|
|
|
else
|
|
|
job->file_time = INT_MAX;
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "cupsdLoadJob: job->file_time=%ld, time-at-completed=%ld, JobFiles=%d", (long)job->file_time, (long)attr->values[0].integer, JobFiles);
|
|
|
|
|
|
if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->file_time;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdLoadJob: JobHistoryUpdate=%ld",
|
|
|
(long)JobHistoryUpdate);
|
|
|
}
|
|
|
|
|
|
if (!job->dest)
|
|
|
{
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
|
|
|
IPP_TAG_URI)) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"No job-printer-uri attribute in control file.");
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
if ((dest = cupsdValidateDest(attr->values[0].string.text, &(job->dtype),
|
|
|
&destptr)) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Unable to queue job for destination \"%s\".",
|
|
|
attr->values[0].string.text);
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
cupsdSetString(&job->dest, dest);
|
|
|
}
|
|
|
else if ((destptr = cupsdFindDest(job->dest)) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Unable to queue job for destination \"%s\".",
|
|
|
job->dest);
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
if ((job->reasons = ippFindAttribute(job->attrs, "job-state-reasons",
|
|
|
IPP_TAG_KEYWORD)) == NULL)
|
|
|
{
|
|
|
const char *reason; /* job-state-reason keyword */
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Adding missing job-state-reasons attribute to control file.");
|
|
|
|
|
|
switch (job->state_value)
|
|
|
{
|
|
|
default :
|
|
|
case IPP_JOB_PENDING :
|
|
|
if (destptr->state == IPP_PRINTER_STOPPED)
|
|
|
reason = "printer-stopped";
|
|
|
else
|
|
|
reason = "none";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_HELD :
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
|
|
|
IPP_TAG_ZERO)) != NULL &&
|
|
|
(attr->value_tag == IPP_TAG_NAME ||
|
|
|
attr->value_tag == IPP_TAG_NAMELANG ||
|
|
|
attr->value_tag == IPP_TAG_KEYWORD) &&
|
|
|
strcmp(attr->values[0].string.text, "no-hold"))
|
|
|
reason = "job-hold-until-specified";
|
|
|
else
|
|
|
reason = "job-incoming";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_PROCESSING :
|
|
|
reason = "job-printing";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_STOPPED :
|
|
|
reason = "job-stopped";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_CANCELED :
|
|
|
reason = "job-canceled-by-user";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_ABORTED :
|
|
|
reason = "aborted-by-system";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_COMPLETED :
|
|
|
reason = "job-completed-successfully";
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
job->reasons = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
|
|
|
"job-state-reasons", NULL, reason);
|
|
|
}
|
|
|
else if (job->state_value == IPP_JOB_PENDING)
|
|
|
{
|
|
|
if (destptr->state == IPP_PRINTER_STOPPED)
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "printer-stopped");
|
|
|
else
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "none");
|
|
|
}
|
|
|
|
|
|
job->impressions = ippFindAttribute(job->attrs, "job-impressions-completed", IPP_TAG_INTEGER);
|
|
|
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->impressions)
|
|
|
job->impressions = ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-impressions-completed", 0);
|
|
|
if (!job->sheets)
|
|
|
job->sheets = ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-media-sheets-completed", 0);
|
|
|
|
|
|
if (!job->priority)
|
|
|
{
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-priority",
|
|
|
IPP_TAG_INTEGER)) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Missing or bad job-priority attribute in control file.");
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
job->priority = attr->values[0].integer;
|
|
|
}
|
|
|
|
|
|
if (!job->username)
|
|
|
{
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-originating-user-name",
|
|
|
IPP_TAG_NAME)) == NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Missing or bad job-originating-user-name "
|
|
|
"attribute in control file.");
|
|
|
goto error;
|
|
|
}
|
|
|
|
|
|
cupsdSetString(&job->username, attr->values[0].string.text);
|
|
|
}
|
|
|
|
|
|
if (!job->name)
|
|
|
{
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-name", IPP_TAG_NAME)) != NULL)
|
|
|
cupsdSetString(&job->name, attr->values[0].string.text);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Set the job hold-until time and state...
|
|
|
*/
|
|
|
|
|
|
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, CUPSD_JOB_DEFAULT);
|
|
|
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 ((attr = ippFindAttribute(job->attrs, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
|
|
|
job->koctets = attr->values[0].integer;
|
|
|
|
|
|
if (!job->num_files)
|
|
|
{
|
|
|
/*
|
|
|
* Find all the d##### files...
|
|
|
*/
|
|
|
|
|
|
for (fileid = 1; fileid < 10000; fileid ++)
|
|
|
{
|
|
|
snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
|
|
|
job->id, fileid);
|
|
|
|
|
|
if (access(jobfile, 0))
|
|
|
break;
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Auto-typing document file \"%s\"...", jobfile);
|
|
|
|
|
|
if (fileid > job->num_files)
|
|
|
{
|
|
|
if (job->num_files == 0)
|
|
|
{
|
|
|
compressions = (int *)calloc((size_t)fileid, sizeof(int));
|
|
|
filetypes = (mime_type_t **)calloc((size_t)fileid, sizeof(mime_type_t *));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
compressions = (int *)realloc(job->compressions, sizeof(int) * (size_t)fileid);
|
|
|
filetypes = (mime_type_t **)realloc(job->filetypes, sizeof(mime_type_t *) * (size_t)fileid);
|
|
|
}
|
|
|
|
|
|
if (compressions)
|
|
|
job->compressions = compressions;
|
|
|
|
|
|
if (filetypes)
|
|
|
job->filetypes = filetypes;
|
|
|
|
|
|
if (!compressions || !filetypes)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Ran out of memory for job file types.");
|
|
|
|
|
|
ippDelete(job->attrs);
|
|
|
job->attrs = NULL;
|
|
|
|
|
|
if (job->compressions)
|
|
|
{
|
|
|
free(job->compressions);
|
|
|
job->compressions = NULL;
|
|
|
}
|
|
|
|
|
|
if (job->filetypes)
|
|
|
{
|
|
|
free(job->filetypes);
|
|
|
job->filetypes = NULL;
|
|
|
}
|
|
|
|
|
|
job->num_files = 0;
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
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");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Load authentication information as needed...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value < IPP_JOB_STOPPED)
|
|
|
{
|
|
|
snprintf(jobfile, sizeof(jobfile), "%s/a%05d", RequestRoot, job->id);
|
|
|
|
|
|
for (i = 0;
|
|
|
i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
|
|
|
i ++)
|
|
|
cupsdClearString(job->auth_env + i);
|
|
|
cupsdClearString(&job->auth_uid);
|
|
|
|
|
|
if ((fp = cupsFileOpen(jobfile, "r")) != NULL)
|
|
|
{
|
|
|
int bytes, /* Size of auth data */
|
|
|
linenum = 1; /* Current line number */
|
|
|
char line[65536], /* Line from file */
|
|
|
*value, /* Value from line */
|
|
|
data[65536]; /* Decoded data */
|
|
|
|
|
|
|
|
|
if (cupsFileGets(fp, line, sizeof(line)) &&
|
|
|
!strcmp(line, "CUPSD-AUTH-V3"))
|
|
|
{
|
|
|
i = 0;
|
|
|
while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
|
|
|
{
|
|
|
/*
|
|
|
* Decode value...
|
|
|
*/
|
|
|
|
|
|
if (strcmp(line, "negotiate") && strcmp(line, "uid"))
|
|
|
{
|
|
|
bytes = sizeof(data);
|
|
|
httpDecode64_2(data, &bytes, value);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Assign environment variables...
|
|
|
*/
|
|
|
|
|
|
if (!strcmp(line, "uid"))
|
|
|
{
|
|
|
cupsdSetStringf(&job->auth_uid, "AUTH_UID=%s", value);
|
|
|
continue;
|
|
|
}
|
|
|
else if (i >= (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0])))
|
|
|
break;
|
|
|
|
|
|
if (!strcmp(line, "username"))
|
|
|
cupsdSetStringf(job->auth_env + i, "AUTH_USERNAME=%s", data);
|
|
|
else if (!strcmp(line, "domain"))
|
|
|
cupsdSetStringf(job->auth_env + i, "AUTH_DOMAIN=%s", data);
|
|
|
else if (!strcmp(line, "password"))
|
|
|
cupsdSetStringf(job->auth_env + i, "AUTH_PASSWORD=%s", data);
|
|
|
else if (!strcmp(line, "negotiate"))
|
|
|
cupsdSetStringf(job->auth_env + i, "AUTH_NEGOTIATE=%s", value);
|
|
|
else
|
|
|
continue;
|
|
|
|
|
|
i ++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
job->access_time = time(NULL);
|
|
|
return (1);
|
|
|
|
|
|
/*
|
|
|
* If we get here then something bad happened...
|
|
|
*/
|
|
|
|
|
|
error:
|
|
|
|
|
|
ippDelete(job->attrs);
|
|
|
job->attrs = NULL;
|
|
|
|
|
|
remove_job_history(job);
|
|
|
remove_job_files(job);
|
|
|
|
|
|
return (0);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdMoveJob()' - Move the specified job to a different destination.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdMoveJob(cupsd_job_t *job, /* I - Job */
|
|
|
cupsd_printer_t *p) /* I - Destination printer or class */
|
|
|
{
|
|
|
ipp_attribute_t *attr; /* job-printer-uri attribute */
|
|
|
const char *olddest; /* Old destination */
|
|
|
cupsd_printer_t *oldp; /* Old pointer */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Don't move completed jobs...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value > IPP_JOB_STOPPED)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Get the old destination...
|
|
|
*/
|
|
|
|
|
|
olddest = job->dest;
|
|
|
|
|
|
if (job->printer)
|
|
|
oldp = job->printer;
|
|
|
else
|
|
|
oldp = cupsdFindDest(olddest);
|
|
|
|
|
|
/*
|
|
|
* Change the destination information...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value > IPP_JOB_HELD)
|
|
|
cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
|
|
|
"Stopping job prior to move.");
|
|
|
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED, 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);
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
|
|
|
IPP_TAG_URI)) != NULL)
|
|
|
ippSetString(job->attrs, &attr, 0, p->uri);
|
|
|
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, p, job,
|
|
|
"Job #%d moved from %s to %s.", job->id, olddest,
|
|
|
p->name);
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdReleaseJob()' - Release the specified job.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdReleaseJob(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdReleaseJob(job=%p(%d))", job,
|
|
|
job->id);
|
|
|
|
|
|
if (job->state_value == IPP_JOB_HELD)
|
|
|
{
|
|
|
/*
|
|
|
* Add trailing banner as needed...
|
|
|
*/
|
|
|
|
|
|
if (job->pending_timeout)
|
|
|
cupsdTimeoutJob(job);
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
|
|
|
"Job released by user.");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdRestartJob()' - Restart the specified job.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdRestartJob(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdRestartJob(job=%p(%d))", job,
|
|
|
job->id);
|
|
|
|
|
|
if (job->state_value == IPP_JOB_STOPPED || job->num_files)
|
|
|
cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
|
|
|
"Job restarted by user.");
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSaveAllJobs()' - Save a summary of all jobs to disk.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSaveAllJobs(void)
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
cups_file_t *fp; /* job.cache file */
|
|
|
char filename[1024], /* job.cache filename */
|
|
|
temp[1024]; /* Temporary string */
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
time_t curtime; /* Current time */
|
|
|
struct tm curdate; /* Current date */
|
|
|
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
|
|
|
if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm)) == NULL)
|
|
|
return;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_INFO, "Saving job.cache...");
|
|
|
|
|
|
/*
|
|
|
* Write a small header to the file...
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
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);
|
|
|
|
|
|
/*
|
|
|
* Write each job known to the system...
|
|
|
*/
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(Jobs))
|
|
|
{
|
|
|
if (job->printer && job->printer->temporary)
|
|
|
{
|
|
|
/*
|
|
|
* Don't save jobs on temporary printers...
|
|
|
*/
|
|
|
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
cupsFilePrintf(fp, "<Job %d>\n", job->id);
|
|
|
cupsFilePrintf(fp, "State %d\n", job->state_value);
|
|
|
cupsFilePrintf(fp, "Created %ld\n", (long)job->creation_time);
|
|
|
if (job->completed_time)
|
|
|
cupsFilePrintf(fp, "Completed %ld\n", (long)job->completed_time);
|
|
|
cupsFilePrintf(fp, "Priority %d\n", job->priority);
|
|
|
if (job->hold_until)
|
|
|
cupsFilePrintf(fp, "HoldUntil %ld\n", (long)job->hold_until);
|
|
|
cupsFilePrintf(fp, "Username %s\n", job->username);
|
|
|
if (job->name)
|
|
|
cupsFilePutConf(fp, "Name", job->name);
|
|
|
cupsFilePrintf(fp, "Destination %s\n", job->dest);
|
|
|
cupsFilePrintf(fp, "DestType %d\n", job->dtype);
|
|
|
cupsFilePrintf(fp, "KOctets %d\n", job->koctets);
|
|
|
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");
|
|
|
}
|
|
|
|
|
|
cupsdCloseCreatedConfFile(fp, filename);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSaveJob()' - Save a job to disk.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSaveJob(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
char filename[1024]; /* Job control filename */
|
|
|
cups_file_t *fp; /* Job file */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSaveJob(job=%p(%d)): job->attrs=%p",
|
|
|
job, job->id, job->attrs);
|
|
|
|
|
|
if (job->printer && job->printer->temporary)
|
|
|
{
|
|
|
/*
|
|
|
* Don't save jobs on temporary printers...
|
|
|
*/
|
|
|
|
|
|
job->dirty = 0;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot, job->id);
|
|
|
|
|
|
if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm & 0600)) == NULL)
|
|
|
return;
|
|
|
|
|
|
fchown(cupsFileNumber(fp), RunUser, Group);
|
|
|
|
|
|
job->attrs->state = IPP_IDLE;
|
|
|
|
|
|
if (ippWriteIO(fp, (ipp_iocb_t)cupsFileWrite, 1, NULL,
|
|
|
job->attrs) != IPP_DATA)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to write job control file.");
|
|
|
cupsFileClose(fp);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (!cupsdCloseCreatedConfFile(fp, filename))
|
|
|
{
|
|
|
/*
|
|
|
* Remove backup file and mark this job as clean...
|
|
|
*/
|
|
|
|
|
|
strlcat(filename, ".O", sizeof(filename));
|
|
|
unlink(filename);
|
|
|
|
|
|
job->dirty = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetJobHoldUntil()' - Set the hold time for a job.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetJobHoldUntil(cupsd_job_t *job, /* I - Job */
|
|
|
const char *when, /* I - When to resume */
|
|
|
int update)/* I - Update job-hold-until attr? */
|
|
|
{
|
|
|
time_t curtime; /* Current time */
|
|
|
struct tm curdate; /* Current date */
|
|
|
int hour; /* Hold hour */
|
|
|
int minute; /* Hold minute */
|
|
|
int second = 0; /* Hold second */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdSetJobHoldUntil(job=%p(%d), when=\"%s\", update=%d)",
|
|
|
job, job->id, when, update);
|
|
|
|
|
|
if (update)
|
|
|
{
|
|
|
/*
|
|
|
* Update the job-hold-until attribute...
|
|
|
*/
|
|
|
|
|
|
ipp_attribute_t *attr; /* job-hold-until attribute */
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
|
|
|
IPP_TAG_KEYWORD)) == NULL)
|
|
|
attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
|
|
|
|
|
|
if (attr)
|
|
|
ippSetString(job->attrs, &attr, 0, when);
|
|
|
else
|
|
|
attr = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
|
|
|
"job-hold-until", NULL, when);
|
|
|
|
|
|
if (attr)
|
|
|
{
|
|
|
if (isdigit(when[0] & 255))
|
|
|
attr->value_tag = IPP_TAG_NAME;
|
|
|
else
|
|
|
attr->value_tag = IPP_TAG_KEYWORD;
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if (strcmp(when, "no-hold"))
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "job-hold-until-specified");
|
|
|
else
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "none");
|
|
|
|
|
|
/*
|
|
|
* Update the hold time...
|
|
|
*/
|
|
|
|
|
|
job->cancel_time = 0;
|
|
|
|
|
|
if (!strcmp(when, "indefinite") || !strcmp(when, "auth-info-required"))
|
|
|
{
|
|
|
/*
|
|
|
* Hold indefinitely...
|
|
|
*/
|
|
|
|
|
|
job->hold_until = 0;
|
|
|
|
|
|
if (MaxHoldTime > 0)
|
|
|
job->cancel_time = time(NULL) + MaxHoldTime;
|
|
|
}
|
|
|
else if (!strcmp(when, "day-time"))
|
|
|
{
|
|
|
/*
|
|
|
* Hold to 6am the next morning unless local time is < 6pm.
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
|
|
|
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"))
|
|
|
{
|
|
|
/*
|
|
|
* Hold to 6pm unless local time is > 6pm or < 6am.
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
|
|
|
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"))
|
|
|
{
|
|
|
/*
|
|
|
* Hold to 4pm unless local time is > 4pm.
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
|
|
|
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"))
|
|
|
{
|
|
|
/*
|
|
|
* Hold to 12am unless local time is < 8am.
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
|
|
|
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"))
|
|
|
{
|
|
|
/*
|
|
|
* Hold to weekend unless we are in the weekend.
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
localtime_r(&curtime, &curdate);
|
|
|
|
|
|
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)
|
|
|
{
|
|
|
/*
|
|
|
* Hold to specified GMT time (HH:MM or HH:MM:SS)...
|
|
|
*/
|
|
|
|
|
|
time(&curtime);
|
|
|
gmtime_r(&curtime, &curdate);
|
|
|
|
|
|
job->hold_until = curtime +
|
|
|
((hour - curdate.tm_hour) * 60 + minute -
|
|
|
curdate.tm_min) * 60 + second - curdate.tm_sec;
|
|
|
|
|
|
/*
|
|
|
* Hold until next day as needed...
|
|
|
*/
|
|
|
|
|
|
if (job->hold_until < curtime)
|
|
|
job->hold_until += 24 * 60 * 60;
|
|
|
}
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSetJobHoldUntil: hold_until=%d",
|
|
|
(int)job->hold_until);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetJobPriority()' - Set the priority of a job, moving it up/down in
|
|
|
* the list as needed.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetJobPriority(
|
|
|
cupsd_job_t *job, /* I - Job ID */
|
|
|
int priority) /* I - New priority (0 to 100) */
|
|
|
{
|
|
|
ipp_attribute_t *attr; /* Job attribute */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Don't change completed jobs...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value >= IPP_JOB_PROCESSING)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Set the new priority and re-add the job into the active list...
|
|
|
*/
|
|
|
|
|
|
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);
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdSetJobState()' - Set the state of the specified print job.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdSetJobState(
|
|
|
cupsd_job_t *job, /* I - Job to cancel */
|
|
|
ipp_jstate_t newstate, /* I - New job state */
|
|
|
cupsd_jobaction_t action, /* I - Action to take */
|
|
|
const char *message, /* I - Message to log */
|
|
|
...) /* I - Additional arguments as needed */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
ipp_jstate_t oldstate; /* Old state */
|
|
|
char filename[1024]; /* Job filename */
|
|
|
ipp_attribute_t *attr; /* Job attribute */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2,
|
|
|
"cupsdSetJobState(job=%p(%d), state=%d, newstate=%d, "
|
|
|
"action=%d, message=\"%s\")", job, job->id, job->state_value,
|
|
|
newstate, action, message ? message : "(null)");
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Make sure we have the job attributes...
|
|
|
*/
|
|
|
|
|
|
if (!cupsdLoadJob(job))
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Don't do anything if the state is unchanged and we aren't purging the
|
|
|
* job...
|
|
|
*/
|
|
|
|
|
|
oldstate = job->state_value;
|
|
|
if (newstate == oldstate && action != CUPSD_JOB_PURGE)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Stop any processes that are working on the current job...
|
|
|
*/
|
|
|
|
|
|
if (oldstate == IPP_JOB_PROCESSING)
|
|
|
stop_job(job, action);
|
|
|
|
|
|
/*
|
|
|
* Set the new job state...
|
|
|
*/
|
|
|
|
|
|
job->state_value = newstate;
|
|
|
|
|
|
if (job->state)
|
|
|
job->state->values[0].integer = (int)newstate;
|
|
|
|
|
|
switch (newstate)
|
|
|
{
|
|
|
case IPP_JOB_PENDING :
|
|
|
/*
|
|
|
* Update job-hold-until as needed...
|
|
|
*/
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
|
|
|
IPP_TAG_KEYWORD)) == NULL)
|
|
|
attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
|
|
|
|
|
|
if (attr)
|
|
|
{
|
|
|
ippSetValueTag(job->attrs, &attr, IPP_TAG_KEYWORD);
|
|
|
ippSetString(job->attrs, &attr, 0, "no-hold");
|
|
|
}
|
|
|
|
|
|
default :
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_ABORTED :
|
|
|
case IPP_JOB_CANCELED :
|
|
|
case IPP_JOB_COMPLETED :
|
|
|
set_time(job, "time-at-completed");
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "processing-to-stop-point");
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Log message as needed...
|
|
|
*/
|
|
|
|
|
|
if (message)
|
|
|
{
|
|
|
char buffer[2048]; /* Message buffer */
|
|
|
va_list ap; /* Pointer to additional arguments */
|
|
|
|
|
|
va_start(ap, message);
|
|
|
vsnprintf(buffer, sizeof(buffer), message, ap);
|
|
|
va_end(ap);
|
|
|
|
|
|
if (newstate > IPP_JOB_STOPPED)
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job, "%s", buffer);
|
|
|
else
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_STATE, job->printer, job, "%s", buffer);
|
|
|
|
|
|
if (newstate == IPP_JOB_STOPPED || newstate == IPP_JOB_ABORTED || newstate == IPP_JOB_HELD)
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR, "%s", buffer);
|
|
|
else
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO, "%s", buffer);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Handle post-state-change actions...
|
|
|
*/
|
|
|
|
|
|
switch (newstate)
|
|
|
{
|
|
|
case IPP_JOB_PROCESSING :
|
|
|
/*
|
|
|
* Add the job to the "printing" list...
|
|
|
*/
|
|
|
|
|
|
if (!cupsArrayFind(PrintingJobs, job))
|
|
|
cupsArrayAdd(PrintingJobs, job);
|
|
|
|
|
|
/*
|
|
|
* Set the processing time...
|
|
|
*/
|
|
|
|
|
|
set_time(job, "time-at-processing");
|
|
|
|
|
|
case IPP_JOB_PENDING :
|
|
|
case IPP_JOB_HELD :
|
|
|
case IPP_JOB_STOPPED :
|
|
|
/*
|
|
|
* Make sure the job is in the active list...
|
|
|
*/
|
|
|
|
|
|
if (!cupsArrayFind(ActiveJobs, job))
|
|
|
cupsArrayAdd(ActiveJobs, job);
|
|
|
|
|
|
/*
|
|
|
* Save the job state to disk...
|
|
|
*/
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_ABORTED :
|
|
|
case IPP_JOB_CANCELED :
|
|
|
case IPP_JOB_COMPLETED :
|
|
|
if (newstate == IPP_JOB_CANCELED)
|
|
|
{
|
|
|
/*
|
|
|
* Remove the job from the active list if there are no processes still
|
|
|
* running for it...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; job->filters[i] < 0; i++);
|
|
|
|
|
|
if (!job->filters[i] && job->backend <= 0)
|
|
|
cupsArrayRemove(ActiveJobs, job);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Otherwise just remove the job from the active list immediately...
|
|
|
*/
|
|
|
|
|
|
cupsArrayRemove(ActiveJobs, job);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Expire job subscriptions since the job is now "completed"...
|
|
|
*/
|
|
|
|
|
|
cupsdExpireSubscriptions(NULL, job);
|
|
|
|
|
|
#ifdef __APPLE__
|
|
|
/*
|
|
|
* If we are going to sleep and the PrintingJobs count is now 0, allow the
|
|
|
* sleep to happen immediately...
|
|
|
*/
|
|
|
|
|
|
if (Sleeping && cupsArrayCount(PrintingJobs) == 0)
|
|
|
cupsdAllowSleep();
|
|
|
#endif /* __APPLE__ */
|
|
|
|
|
|
/*
|
|
|
* Remove any authentication data...
|
|
|
*/
|
|
|
|
|
|
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));
|
|
|
|
|
|
for (i = 0;
|
|
|
i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
|
|
|
i ++)
|
|
|
cupsdClearString(job->auth_env + i);
|
|
|
|
|
|
cupsdClearString(&job->auth_uid);
|
|
|
|
|
|
/*
|
|
|
* Remove the print file for good if we aren't preserving jobs or
|
|
|
* files...
|
|
|
*/
|
|
|
|
|
|
if (!JobHistory || !JobFiles || action == CUPSD_JOB_PURGE)
|
|
|
remove_job_files(job);
|
|
|
|
|
|
if (JobHistory && action != CUPSD_JOB_PURGE)
|
|
|
{
|
|
|
/*
|
|
|
* Save job state info...
|
|
|
*/
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
else if (!job->printer)
|
|
|
{
|
|
|
/*
|
|
|
* Delete the job immediately if not actively printing...
|
|
|
*/
|
|
|
|
|
|
cupsdDeleteJob(job, CUPSD_JOB_PURGE);
|
|
|
job = NULL;
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Finalize the job immediately if we forced things...
|
|
|
*/
|
|
|
|
|
|
if (action >= CUPSD_JOB_FORCE && job && job->printer)
|
|
|
finalize_job(job, 0);
|
|
|
|
|
|
/*
|
|
|
* Update the server "busy" state...
|
|
|
*/
|
|
|
|
|
|
cupsdSetBusyState(0);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdStopAllJobs()' - Stop all print jobs.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdStopAllJobs(
|
|
|
cupsd_jobaction_t action, /* I - Action */
|
|
|
int kill_delay) /* I - Number of seconds before we kill */
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(PrintingJobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(PrintingJobs))
|
|
|
{
|
|
|
if (job->completed)
|
|
|
{
|
|
|
cupsdSetJobState(job, IPP_JOB_COMPLETED, CUPSD_JOB_FORCE, NULL);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (kill_delay)
|
|
|
job->kill_time = time(NULL) + kill_delay;
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_PENDING, action, NULL);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdUnloadCompletedJobs()' - Flush completed job history from memory.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdUnloadCompletedJobs(void)
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
time_t expire; /* Expiration time */
|
|
|
|
|
|
|
|
|
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->printer &&
|
|
|
job->access_time < expire)
|
|
|
{
|
|
|
if (job->dirty)
|
|
|
cupsdSaveJob(job);
|
|
|
|
|
|
if (!job->dirty)
|
|
|
unload_job(job);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'cupsdUpdateJobs()' - Update the history/file files for all jobs.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
cupsdUpdateJobs(void)
|
|
|
{
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
time_t curtime; /* Current time */
|
|
|
ipp_attribute_t *attr; /* time-at-completed attribute */
|
|
|
|
|
|
|
|
|
curtime = time(NULL);
|
|
|
JobHistoryUpdate = 0;
|
|
|
|
|
|
for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
|
|
|
job;
|
|
|
job = (cupsd_job_t *)cupsArrayNext(Jobs))
|
|
|
{
|
|
|
if (job->state_value >= IPP_JOB_CANCELED &&
|
|
|
(attr = ippFindAttribute(job->attrs, "time-at-completed",
|
|
|
IPP_TAG_INTEGER)) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Update history/file expiration times...
|
|
|
*/
|
|
|
|
|
|
job->completed_time = attr->values[0].integer;
|
|
|
|
|
|
if (JobHistory < INT_MAX)
|
|
|
job->history_time = job->completed_time + JobHistory;
|
|
|
else
|
|
|
job->history_time = INT_MAX;
|
|
|
|
|
|
if (job->history_time < curtime)
|
|
|
{
|
|
|
cupsdDeleteJob(job, CUPSD_JOB_PURGE);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->history_time;
|
|
|
|
|
|
if (JobFiles < INT_MAX)
|
|
|
job->file_time = job->completed_time + JobFiles;
|
|
|
else
|
|
|
job->file_time = INT_MAX;
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "cupsdUpdateJobs: job->file_time=%ld, time-at-completed=%ld, JobFiles=%d", (long)job->file_time, (long)attr->values[0].integer, JobFiles);
|
|
|
|
|
|
if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->file_time;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdUpdateJobs: JobHistoryUpdate=%ld",
|
|
|
(long)JobHistoryUpdate);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'compare_active_jobs()' - Compare the job IDs and priorities of two jobs.
|
|
|
*/
|
|
|
|
|
|
static int /* O - Difference */
|
|
|
compare_active_jobs(void *first, /* I - First job */
|
|
|
void *second, /* I - Second job */
|
|
|
void *data) /* I - App data (not used) */
|
|
|
{
|
|
|
int diff; /* Difference */
|
|
|
|
|
|
|
|
|
(void)data;
|
|
|
|
|
|
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);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'compare_completed_jobs()' - Compare the job IDs and completion times of two jobs.
|
|
|
*/
|
|
|
|
|
|
static int /* O - Difference */
|
|
|
compare_completed_jobs(void *first, /* I - First job */
|
|
|
void *second, /* I - Second job */
|
|
|
void *data) /* I - App data (not used) */
|
|
|
{
|
|
|
int diff; /* Difference */
|
|
|
|
|
|
|
|
|
(void)data;
|
|
|
|
|
|
if ((diff = ((cupsd_job_t *)second)->completed_time -
|
|
|
((cupsd_job_t *)first)->completed_time) != 0)
|
|
|
return (diff);
|
|
|
else
|
|
|
return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'compare_jobs()' - Compare the job IDs of two jobs.
|
|
|
*/
|
|
|
|
|
|
static int /* O - Difference */
|
|
|
compare_jobs(void *first, /* I - First job */
|
|
|
void *second, /* I - Second job */
|
|
|
void *data) /* I - App data (not used) */
|
|
|
{
|
|
|
(void)data;
|
|
|
|
|
|
return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'dump_job_history()' - Dump any debug messages for a job.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
dump_job_history(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
int i, /* Looping var */
|
|
|
oldsize; /* Current MaxLogSize */
|
|
|
struct tm date; /* Date/time value */
|
|
|
cupsd_joblog_t *message; /* Current message */
|
|
|
char temp[2048], /* Log message */
|
|
|
*ptr, /* Pointer into log message */
|
|
|
start[256], /* Start time */
|
|
|
end[256]; /* End time */
|
|
|
cupsd_printer_t *printer; /* Printer for job */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* See if we have anything to dump...
|
|
|
*/
|
|
|
|
|
|
if (!job->history)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Disable log rotation temporarily...
|
|
|
*/
|
|
|
|
|
|
oldsize = MaxLogSize;
|
|
|
MaxLogSize = 0;
|
|
|
|
|
|
/*
|
|
|
* Copy the debug messages to the log...
|
|
|
*/
|
|
|
|
|
|
message = (cupsd_joblog_t *)cupsArrayFirst(job->history);
|
|
|
localtime_r(&(message->time), &date);
|
|
|
strftime(start, sizeof(start), "%X", &date);
|
|
|
|
|
|
message = (cupsd_joblog_t *)cupsArrayLast(job->history);
|
|
|
localtime_r(&(message->time), &date);
|
|
|
strftime(end, sizeof(end), "%X", &date);
|
|
|
|
|
|
snprintf(temp, sizeof(temp),
|
|
|
"[Job %d] The following messages were recorded from %s to %s",
|
|
|
job->id, start, end);
|
|
|
cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
|
|
|
|
|
|
for (message = (cupsd_joblog_t *)cupsArrayFirst(job->history);
|
|
|
message;
|
|
|
message = (cupsd_joblog_t *)cupsArrayNext(job->history))
|
|
|
cupsdWriteErrorLog(CUPSD_LOG_DEBUG, message->message);
|
|
|
|
|
|
snprintf(temp, sizeof(temp), "[Job %d] End of messages", job->id);
|
|
|
cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
|
|
|
|
|
|
/*
|
|
|
* Log the printer state values...
|
|
|
*/
|
|
|
|
|
|
if ((printer = job->printer) == NULL)
|
|
|
printer = cupsdFindDest(job->dest);
|
|
|
|
|
|
if (printer)
|
|
|
{
|
|
|
snprintf(temp, sizeof(temp), "[Job %d] printer-state=%d(%s)", job->id,
|
|
|
printer->state,
|
|
|
printer->state == IPP_PRINTER_IDLE ? "idle" :
|
|
|
printer->state == IPP_PRINTER_PROCESSING ? "processing" :
|
|
|
"stopped");
|
|
|
cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
|
|
|
|
|
|
snprintf(temp, sizeof(temp), "[Job %d] printer-state-message=\"%s\"",
|
|
|
job->id, printer->state_message);
|
|
|
cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
|
|
|
|
|
|
snprintf(temp, sizeof(temp), "[Job %d] printer-state-reasons=", job->id);
|
|
|
ptr = temp + strlen(temp);
|
|
|
if (printer->num_reasons == 0)
|
|
|
strlcpy(ptr, "none", sizeof(temp) - (size_t)(ptr - temp));
|
|
|
else
|
|
|
{
|
|
|
for (i = 0;
|
|
|
i < printer->num_reasons && ptr < (temp + sizeof(temp) - 2);
|
|
|
i ++)
|
|
|
{
|
|
|
if (i)
|
|
|
*ptr++ = ',';
|
|
|
|
|
|
strlcpy(ptr, printer->reasons[i], sizeof(temp) - (size_t)(ptr - temp));
|
|
|
ptr += strlen(ptr);
|
|
|
}
|
|
|
}
|
|
|
cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Restore log file rotation...
|
|
|
*/
|
|
|
|
|
|
MaxLogSize = oldsize;
|
|
|
|
|
|
/*
|
|
|
* Free all messages...
|
|
|
*/
|
|
|
|
|
|
free_job_history(job);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'free_job_history()' - Free any log history.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
free_job_history(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
char *message; /* Current message */
|
|
|
|
|
|
|
|
|
if (!job->history)
|
|
|
return;
|
|
|
|
|
|
for (message = (char *)cupsArrayFirst(job->history);
|
|
|
message;
|
|
|
message = (char *)cupsArrayNext(job->history))
|
|
|
free(message);
|
|
|
|
|
|
cupsArrayDelete(job->history);
|
|
|
job->history = NULL;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'finalize_job()' - Cleanup after job filter processes and support data.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
finalize_job(cupsd_job_t *job, /* I - Job */
|
|
|
int set_job_state) /* I - 1 = set the job state */
|
|
|
{
|
|
|
ipp_pstate_t printer_state; /* New printer state value */
|
|
|
ipp_jstate_t job_state; /* New job state value */
|
|
|
const char *message; /* Message for job state */
|
|
|
char buffer[1024]; /* Buffer for formatted messages */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "finalize_job(job=%p(%d))", job, job->id);
|
|
|
|
|
|
/*
|
|
|
* Clear the "connecting-to-device" and "cups-waiting-for-job-completed"
|
|
|
* reasons, which are only valid when a printer is processing, along with any
|
|
|
* remote printing job state...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterReasons(job->printer, "-connecting-to-device,"
|
|
|
"cups-waiting-for-job-completed,"
|
|
|
"cups-remote-pending,"
|
|
|
"cups-remote-pending-held,"
|
|
|
"cups-remote-processing,"
|
|
|
"cups-remote-stopped,"
|
|
|
"cups-remote-canceled,"
|
|
|
"cups-remote-aborted,"
|
|
|
"cups-remote-completed");
|
|
|
|
|
|
/*
|
|
|
* Similarly, clear the "offline-report" reason for non-USB devices since we
|
|
|
* rarely have current information for network devices...
|
|
|
*/
|
|
|
|
|
|
if (strncmp(job->printer->device_uri, "usb:", 4) &&
|
|
|
strncmp(job->printer->device_uri, "ippusb:", 7))
|
|
|
cupsdSetPrinterReasons(job->printer, "-offline-report");
|
|
|
|
|
|
/*
|
|
|
* Free the security profile...
|
|
|
*/
|
|
|
|
|
|
cupsdDestroyProfile(job->profile);
|
|
|
job->profile = NULL;
|
|
|
cupsdDestroyProfile(job->bprofile);
|
|
|
job->bprofile = NULL;
|
|
|
|
|
|
/*
|
|
|
* Clear the unresponsive job watchdog timers...
|
|
|
*/
|
|
|
|
|
|
job->cancel_time = 0;
|
|
|
job->kill_time = 0;
|
|
|
|
|
|
/*
|
|
|
* Close pipes and status buffer...
|
|
|
*/
|
|
|
|
|
|
cupsdClosePipe(job->print_pipes);
|
|
|
cupsdClosePipe(job->back_pipes);
|
|
|
cupsdClosePipe(job->side_pipes);
|
|
|
|
|
|
cupsdRemoveSelect(job->status_pipes[0]);
|
|
|
cupsdClosePipe(job->status_pipes);
|
|
|
cupsdStatBufDelete(job->status_buffer);
|
|
|
job->status_buffer = NULL;
|
|
|
|
|
|
/*
|
|
|
* Log the final impression (page) count...
|
|
|
*/
|
|
|
|
|
|
snprintf(buffer, sizeof(buffer), "total %d", ippGetInteger(job->impressions, 0));
|
|
|
cupsdLogPage(job, buffer);
|
|
|
|
|
|
/*
|
|
|
* Process the exit status...
|
|
|
*/
|
|
|
|
|
|
if (job->printer->state == IPP_PRINTER_PROCESSING)
|
|
|
printer_state = IPP_PRINTER_IDLE;
|
|
|
else
|
|
|
printer_state = job->printer->state;
|
|
|
|
|
|
switch (job_state = job->state_value)
|
|
|
{
|
|
|
case IPP_JOB_PENDING :
|
|
|
message = "Job paused.";
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_HELD :
|
|
|
message = "Job held.";
|
|
|
break;
|
|
|
|
|
|
default :
|
|
|
case IPP_JOB_PROCESSING :
|
|
|
case IPP_JOB_COMPLETED :
|
|
|
job_state = IPP_JOB_COMPLETED;
|
|
|
message = "Job completed.";
|
|
|
|
|
|
if (!job->status)
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
"job-completed-successfully");
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_STOPPED :
|
|
|
message = "Job stopped.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "job-stopped");
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_CANCELED :
|
|
|
message = "Job canceled.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "job-canceled-by-user");
|
|
|
break;
|
|
|
|
|
|
case IPP_JOB_ABORTED :
|
|
|
message = "Job aborted.";
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if (job->status < 0)
|
|
|
{
|
|
|
/*
|
|
|
* Backend had errors...
|
|
|
*/
|
|
|
|
|
|
int exit_code; /* Exit code from backend */
|
|
|
|
|
|
/*
|
|
|
* Convert the status to an exit code. Due to the way the W* macros are
|
|
|
* implemented on macOS (bug?), we have to store the exit status in a
|
|
|
* variable first and then convert...
|
|
|
*/
|
|
|
|
|
|
exit_code = -job->status;
|
|
|
if (WIFEXITED(exit_code))
|
|
|
exit_code = WEXITSTATUS(exit_code);
|
|
|
else
|
|
|
{
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "cups-backend-crashed");
|
|
|
exit_code = job->status;
|
|
|
}
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO, "Backend returned status %d (%s)",
|
|
|
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 == CUPS_BACKEND_RETRY ? "retry job later" :
|
|
|
exit_code == CUPS_BACKEND_RETRY_CURRENT ? "retry job immediately" :
|
|
|
exit_code < 0 ? "crashed" : "unknown");
|
|
|
|
|
|
/*
|
|
|
* Do what needs to be done...
|
|
|
*/
|
|
|
|
|
|
switch (exit_code)
|
|
|
{
|
|
|
default :
|
|
|
case CUPS_BACKEND_FAILED :
|
|
|
/*
|
|
|
* Backend failure, use the error-policy to determine how to
|
|
|
* act...
|
|
|
*/
|
|
|
|
|
|
if (job->dtype & CUPS_PRINTER_CLASS)
|
|
|
{
|
|
|
/*
|
|
|
* Queued on a class - mark the job as pending and we'll retry on
|
|
|
* another printer...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_PENDING;
|
|
|
message = "Retrying job on another printer.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
"resources-are-not-ready");
|
|
|
}
|
|
|
}
|
|
|
else if (!strcmp(job->printer->error_policy, "retry-current-job"))
|
|
|
{
|
|
|
/*
|
|
|
* The error policy is "retry-current-job" - mark the job as pending
|
|
|
* and we'll retry on the same printer...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_PENDING;
|
|
|
message = "Retrying job on same printer.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "none");
|
|
|
}
|
|
|
}
|
|
|
else if ((job->printer->type & CUPS_PRINTER_FAX) ||
|
|
|
!strcmp(job->printer->error_policy, "retry-job"))
|
|
|
{
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
/*
|
|
|
* The job was queued on a fax or the error policy is "retry-job" -
|
|
|
* hold the job if the number of retries is less than the
|
|
|
* JobRetryLimit, otherwise abort the job.
|
|
|
*/
|
|
|
|
|
|
job->tries ++;
|
|
|
|
|
|
if (job->tries > JobRetryLimit && JobRetryLimit > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Too many tries...
|
|
|
*/
|
|
|
|
|
|
snprintf(buffer, sizeof(buffer),
|
|
|
"Job aborted after %d unsuccessful attempts.",
|
|
|
JobRetryLimit);
|
|
|
job_state = IPP_JOB_ABORTED;
|
|
|
message = buffer;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Try again in N seconds...
|
|
|
*/
|
|
|
|
|
|
snprintf(buffer, sizeof(buffer),
|
|
|
"Job held for %d seconds since it could not be sent.",
|
|
|
JobRetryInterval);
|
|
|
|
|
|
job->hold_until = time(NULL) + JobRetryInterval;
|
|
|
job_state = IPP_JOB_HELD;
|
|
|
message = buffer;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
"resources-are-not-ready");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (!strcmp(job->printer->error_policy, "abort-job") &&
|
|
|
job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_ABORTED;
|
|
|
|
|
|
if (ErrorLog)
|
|
|
{
|
|
|
snprintf(buffer, sizeof(buffer), "Job aborted due to backend errors; please consult the %s file for details.", ErrorLog);
|
|
|
message = buffer;
|
|
|
}
|
|
|
else
|
|
|
message = "Job aborted due to backend errors.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
|
|
|
}
|
|
|
else if (job->state_value == IPP_JOB_PROCESSING)
|
|
|
{
|
|
|
job_state = IPP_JOB_PENDING;
|
|
|
printer_state = IPP_PRINTER_STOPPED;
|
|
|
|
|
|
if (ErrorLog)
|
|
|
{
|
|
|
snprintf(buffer, sizeof(buffer), "Printer stopped due to backend errors; please consult the %s file for details.", ErrorLog);
|
|
|
message = buffer;
|
|
|
}
|
|
|
else
|
|
|
message = "Printer stopped due to backend errors.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "none");
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case CUPS_BACKEND_CANCEL :
|
|
|
/*
|
|
|
* Cancel the job...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_CANCELED;
|
|
|
message = "Job canceled at printer.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "canceled-at-device");
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case CUPS_BACKEND_HOLD :
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
/*
|
|
|
* Hold the job...
|
|
|
*/
|
|
|
|
|
|
const char *reason = ippGetString(job->reasons, 0, NULL);
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-state-reasons=\"%s\"",
|
|
|
reason);
|
|
|
|
|
|
if (!reason || strncmp(reason, "account-", 8))
|
|
|
{
|
|
|
cupsdSetJobHoldUntil(job, "indefinite", 1);
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
"job-hold-until-specified");
|
|
|
|
|
|
if (ErrorLog)
|
|
|
{
|
|
|
snprintf(buffer, sizeof(buffer), "Job held indefinitely due to backend errors; please consult the %s file for details.", ErrorLog);
|
|
|
message = buffer;
|
|
|
}
|
|
|
else
|
|
|
message = "Job held indefinitely due to backend errors.";
|
|
|
}
|
|
|
else if (!strcmp(reason, "account-info-needed"))
|
|
|
{
|
|
|
cupsdSetJobHoldUntil(job, "indefinite", 0);
|
|
|
|
|
|
message = "Job held indefinitely - account information is required.";
|
|
|
}
|
|
|
else if (!strcmp(reason, "account-closed"))
|
|
|
{
|
|
|
cupsdSetJobHoldUntil(job, "indefinite", 0);
|
|
|
|
|
|
message = "Job held indefinitely - account has been closed.";
|
|
|
}
|
|
|
else if (!strcmp(reason, "account-limit-reached"))
|
|
|
{
|
|
|
cupsdSetJobHoldUntil(job, "indefinite", 0);
|
|
|
|
|
|
message = "Job held indefinitely - account limit has been reached.";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cupsdSetJobHoldUntil(job, "indefinite", 0);
|
|
|
|
|
|
message = "Job held indefinitely - account authorization failed.";
|
|
|
}
|
|
|
|
|
|
job_state = IPP_JOB_HELD;
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case CUPS_BACKEND_STOP :
|
|
|
/*
|
|
|
* Stop the printer...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JSTATE_CANCELED || job_state == IPP_JSTATE_ABORTED)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO, "Ignored STOP from backend since the job is %s.", job_state == IPP_JSTATE_CANCELED ? "canceled" : "aborted");
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
printer_state = IPP_PRINTER_STOPPED;
|
|
|
|
|
|
if (ErrorLog)
|
|
|
{
|
|
|
snprintf(buffer, sizeof(buffer), "Printer stopped due to backend errors; please consult the %s file for details.", ErrorLog);
|
|
|
message = buffer;
|
|
|
}
|
|
|
else
|
|
|
message = "Printer stopped due to backend errors.";
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_PENDING;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "resources-are-not-ready");
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case CUPS_BACKEND_AUTH_REQUIRED :
|
|
|
/*
|
|
|
* Hold the job for authentication...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
cupsdSetJobHoldUntil(job, "auth-info-required", 1);
|
|
|
|
|
|
job_state = IPP_JOB_HELD;
|
|
|
message = "Job held for authentication.";
|
|
|
|
|
|
if (strncmp(job->reasons->values[0].string.text, "account-", 8))
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
"cups-held-for-authentication");
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case CUPS_BACKEND_RETRY :
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
/*
|
|
|
* Hold the job if the number of retries is less than the
|
|
|
* JobRetryLimit, otherwise abort the job.
|
|
|
*/
|
|
|
|
|
|
job->tries ++;
|
|
|
|
|
|
if (job->tries > JobRetryLimit && JobRetryLimit > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Too many tries...
|
|
|
*/
|
|
|
|
|
|
snprintf(buffer, sizeof(buffer),
|
|
|
"Job aborted after %d unsuccessful attempts.",
|
|
|
JobRetryLimit);
|
|
|
job_state = IPP_JOB_ABORTED;
|
|
|
message = buffer;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Try again in N seconds...
|
|
|
*/
|
|
|
|
|
|
snprintf(buffer, sizeof(buffer),
|
|
|
"Job held for %d seconds since it could not be sent.",
|
|
|
JobRetryInterval);
|
|
|
|
|
|
job->hold_until = time(NULL) + JobRetryInterval;
|
|
|
job_state = IPP_JOB_HELD;
|
|
|
message = buffer;
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0,
|
|
|
"resources-are-not-ready");
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
case CUPS_BACKEND_RETRY_CURRENT :
|
|
|
/*
|
|
|
* Mark the job as pending and retry on the same printer...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_PENDING;
|
|
|
message = "Retrying job on same printer.";
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "none");
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
else if (job->status > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Filter had errors; stop job...
|
|
|
*/
|
|
|
|
|
|
if (job_state == IPP_JOB_COMPLETED)
|
|
|
{
|
|
|
job_state = IPP_JOB_STOPPED;
|
|
|
|
|
|
if (ErrorLog)
|
|
|
{
|
|
|
snprintf(buffer, sizeof(buffer), "Job stopped due to filter errors; please consult the %s file for details.", ErrorLog);
|
|
|
message = buffer;
|
|
|
}
|
|
|
else
|
|
|
message = "Job stopped due to filter errors.";
|
|
|
|
|
|
if (WIFSIGNALED(job->status))
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "cups-filter-crashed");
|
|
|
else
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "job-completed-with-errors");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Update the printer and job state.
|
|
|
*/
|
|
|
|
|
|
if (set_job_state && job_state != job->state_value)
|
|
|
cupsdSetJobState(job, job_state, CUPSD_JOB_DEFAULT, "%s", message);
|
|
|
|
|
|
cupsdSetPrinterState(job->printer, printer_state,
|
|
|
printer_state == IPP_PRINTER_STOPPED);
|
|
|
update_job_attrs(job, 0);
|
|
|
|
|
|
if (job->history)
|
|
|
{
|
|
|
if (job->status &&
|
|
|
(job->state_value == IPP_JOB_ABORTED ||
|
|
|
job->state_value == IPP_JOB_STOPPED))
|
|
|
dump_job_history(job);
|
|
|
else
|
|
|
free_job_history(job);
|
|
|
}
|
|
|
|
|
|
cupsArrayRemove(PrintingJobs, job);
|
|
|
|
|
|
/*
|
|
|
* Clear informational messages...
|
|
|
*/
|
|
|
|
|
|
if (job->status_level > CUPSD_LOG_ERROR)
|
|
|
job->printer->state_message[0] = '\0';
|
|
|
|
|
|
/*
|
|
|
* Apply any PPD updates...
|
|
|
*/
|
|
|
|
|
|
if (job->num_keywords)
|
|
|
{
|
|
|
if (cupsdUpdatePrinterPPD(job->printer, job->num_keywords, job->keywords))
|
|
|
cupsdSetPrinterAttrs(job->printer);
|
|
|
|
|
|
cupsFreeOptions(job->num_keywords, job->keywords);
|
|
|
|
|
|
job->num_keywords = 0;
|
|
|
job->keywords = NULL;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Clear the printer <-> job association...
|
|
|
*/
|
|
|
|
|
|
job->printer->job = NULL;
|
|
|
job->printer = NULL;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'get_options()' - Get a string containing the job options.
|
|
|
*/
|
|
|
|
|
|
static char * /* O - Options string */
|
|
|
get_options(cupsd_job_t *job, /* I - Job */
|
|
|
int banner_page, /* I - Printing a banner page? */
|
|
|
char *copies, /* I - Copies buffer */
|
|
|
size_t copies_size, /* I - Size of copies buffer */
|
|
|
char *title, /* I - Title buffer */
|
|
|
size_t title_size) /* I - Size of title buffer */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
size_t newlength; /* New option buffer length */
|
|
|
char *optptr, /* Pointer to options */
|
|
|
*valptr; /* Pointer in value string */
|
|
|
ipp_attribute_t *attr; /* Current attribute */
|
|
|
_ppd_cache_t *pc; /* PPD cache and mapping data */
|
|
|
int num_pwgppds; /* Number of PWG->PPD options */
|
|
|
cups_option_t *pwgppds, /* PWG->PPD options */
|
|
|
*pwgppd, /* Current PWG->PPD option */
|
|
|
*preset; /* Current preset option */
|
|
|
int print_color_mode,
|
|
|
/* Output mode (if any) */
|
|
|
print_quality; /* Print quality (if any) */
|
|
|
const char *ppd; /* PPD option choice */
|
|
|
int exact; /* Did we get an exact match? */
|
|
|
static char *options = NULL;/* Full list of options */
|
|
|
static size_t optlength = 0; /* Length of option buffer */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Building the options string is harder than it needs to be, but for the
|
|
|
* moment we need to pass strings for command-line args and not IPP attribute
|
|
|
* pointers... :)
|
|
|
*
|
|
|
* First build an options array for any PWG->PPD mapped option/choice pairs.
|
|
|
*/
|
|
|
|
|
|
pc = job->printer->pc;
|
|
|
num_pwgppds = 0;
|
|
|
pwgppds = NULL;
|
|
|
|
|
|
if (pc &&
|
|
|
!ippFindAttribute(job->attrs, "com.apple.print.DocumentTicket.PMSpoolFormat", IPP_TAG_ZERO) &&
|
|
|
!ippFindAttribute(job->attrs, "APPrinterPreset", IPP_TAG_ZERO) &&
|
|
|
(ippFindAttribute(job->attrs, "print-color-mode", IPP_TAG_ZERO) || ippFindAttribute(job->attrs, "print-quality", IPP_TAG_ZERO) || ippFindAttribute(job->attrs, "cupsPrintQuality", IPP_TAG_ZERO)))
|
|
|
{
|
|
|
/*
|
|
|
* Map print-color-mode and print-quality to a preset...
|
|
|
*/
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "print-color-mode",
|
|
|
IPP_TAG_KEYWORD)) != NULL &&
|
|
|
!strcmp(attr->values[0].string.text, "monochrome"))
|
|
|
print_color_mode = _PWG_PRINT_COLOR_MODE_MONOCHROME;
|
|
|
else
|
|
|
print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "print-quality", IPP_TAG_ENUM)) != NULL)
|
|
|
{
|
|
|
ipp_quality_t pq = (ipp_quality_t)ippGetInteger(attr, 0);
|
|
|
|
|
|
if (pq >= IPP_QUALITY_DRAFT && pq <= IPP_QUALITY_HIGH)
|
|
|
print_quality = attr->values[0].integer - IPP_QUALITY_DRAFT;
|
|
|
else
|
|
|
print_quality = _PWG_PRINT_QUALITY_NORMAL;
|
|
|
}
|
|
|
else if ((attr = ippFindAttribute(job->attrs, "cupsPrintQuality", IPP_TAG_NAME)) != NULL)
|
|
|
{
|
|
|
const char *pq = ippGetString(attr, 0, NULL);
|
|
|
|
|
|
if (!_cups_strcasecmp(pq, "draft"))
|
|
|
print_quality = _PWG_PRINT_QUALITY_DRAFT;
|
|
|
else if (!_cups_strcasecmp(pq, "high"))
|
|
|
print_quality = _PWG_PRINT_QUALITY_HIGH;
|
|
|
else
|
|
|
print_quality = _PWG_PRINT_QUALITY_NORMAL;
|
|
|
|
|
|
if (!ippFindAttribute(job->attrs, "print-quality", IPP_TAG_ENUM))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping cupsPrintQuality=%s to print-quality=%d", pq, print_quality + IPP_QUALITY_DRAFT);
|
|
|
num_pwgppds = cupsAddIntegerOption("print-quality", print_quality + IPP_QUALITY_DRAFT, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
print_quality = _PWG_PRINT_QUALITY_NORMAL;
|
|
|
}
|
|
|
|
|
|
if (pc->num_presets[print_color_mode][print_quality] == 0)
|
|
|
{
|
|
|
/*
|
|
|
* Try to find a preset that works so that we maximize the chances of us
|
|
|
* getting a good print using IPP attributes.
|
|
|
*/
|
|
|
|
|
|
if (pc->num_presets[print_color_mode][_PWG_PRINT_QUALITY_NORMAL] > 0)
|
|
|
print_quality = _PWG_PRINT_QUALITY_NORMAL;
|
|
|
else if (pc->num_presets[_PWG_PRINT_COLOR_MODE_COLOR][print_quality] > 0)
|
|
|
print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
|
|
|
else
|
|
|
{
|
|
|
print_quality = _PWG_PRINT_QUALITY_NORMAL;
|
|
|
print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (pc->num_presets[print_color_mode][print_quality] > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Copy the preset options as long as the corresponding names are not
|
|
|
* already defined in the IPP request...
|
|
|
*/
|
|
|
|
|
|
for (i = pc->num_presets[print_color_mode][print_quality],
|
|
|
preset = pc->presets[print_color_mode][print_quality];
|
|
|
i > 0;
|
|
|
i --, preset ++)
|
|
|
{
|
|
|
if (!ippFindAttribute(job->attrs, preset->name, IPP_TAG_ZERO))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Adding preset option %s=%s", preset->name, preset->value);
|
|
|
|
|
|
num_pwgppds = cupsAddOption(preset->name, preset->value, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (pc)
|
|
|
{
|
|
|
if ((attr = ippFindAttribute(job->attrs, "print-quality", IPP_TAG_ENUM)) != NULL)
|
|
|
{
|
|
|
int pq = ippGetInteger(attr, 0);
|
|
|
static const char * const pqs[] = { "Draft", "Normal", "High" };
|
|
|
|
|
|
if (pq >= IPP_QUALITY_DRAFT && pq <= IPP_QUALITY_HIGH)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping print-quality=%d to cupsPrintQuality=%s", pq, pqs[pq - IPP_QUALITY_DRAFT]);
|
|
|
|
|
|
num_pwgppds = cupsAddOption("cupsPrintQuality", pqs[pq - IPP_QUALITY_DRAFT], num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!ippFindAttribute(job->attrs, "InputSlot", IPP_TAG_ZERO) &&
|
|
|
!ippFindAttribute(job->attrs, "HPPaperSource", IPP_TAG_ZERO))
|
|
|
{
|
|
|
if ((ppd = _ppdCacheGetInputSlot(pc, job->attrs, NULL)) != NULL)
|
|
|
num_pwgppds = cupsAddOption(pc->source_option, ppd, num_pwgppds,
|
|
|
&pwgppds);
|
|
|
}
|
|
|
if (!ippFindAttribute(job->attrs, "MediaType", IPP_TAG_ZERO) &&
|
|
|
(ppd = _ppdCacheGetMediaType(pc, job->attrs, NULL)) != NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping media to MediaType=%s", ppd);
|
|
|
|
|
|
num_pwgppds = cupsAddOption("MediaType", ppd, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
|
|
|
if (!ippFindAttribute(job->attrs, "PageRegion", IPP_TAG_ZERO) &&
|
|
|
!ippFindAttribute(job->attrs, "PageSize", IPP_TAG_ZERO) &&
|
|
|
(ppd = _ppdCacheGetPageSize(pc, job->attrs, NULL, &exact)) != NULL)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping media to Pagesize=%s", ppd);
|
|
|
|
|
|
num_pwgppds = cupsAddOption("PageSize", ppd, num_pwgppds, &pwgppds);
|
|
|
|
|
|
if (!ippFindAttribute(job->attrs, "media", IPP_TAG_ZERO))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Adding media=%s", ppd);
|
|
|
|
|
|
num_pwgppds = cupsAddOption("media", ppd, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!ippFindAttribute(job->attrs, "OutputBin", IPP_TAG_ZERO) &&
|
|
|
(attr = ippFindAttribute(job->attrs, "output-bin",
|
|
|
IPP_TAG_ZERO)) != NULL &&
|
|
|
(attr->value_tag == IPP_TAG_KEYWORD ||
|
|
|
attr->value_tag == IPP_TAG_NAME) &&
|
|
|
(ppd = _ppdCacheGetOutputBin(pc, attr->values[0].string.text)) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Map output-bin to OutputBin option...
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping output-bin to OutputBin=%s", ppd);
|
|
|
|
|
|
num_pwgppds = cupsAddOption("OutputBin", ppd, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
|
|
|
if (pc->sides_option &&
|
|
|
!ippFindAttribute(job->attrs, pc->sides_option, IPP_TAG_ZERO) &&
|
|
|
(attr = ippFindAttribute(job->attrs, "sides", IPP_TAG_KEYWORD)) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Map sides to duplex option...
|
|
|
*/
|
|
|
|
|
|
if (!strcmp(attr->values[0].string.text, "one-sided"))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping sizes to Duplex=%s", pc->sides_1sided);
|
|
|
|
|
|
num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_1sided, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
else if (!strcmp(attr->values[0].string.text, "two-sided-long-edge"))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping sizes to Duplex=%s", pc->sides_2sided_long);
|
|
|
|
|
|
num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_2sided_long, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
else if (!strcmp(attr->values[0].string.text, "two-sided-short-edge"))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "Mapping sizes to Duplex=%s", pc->sides_2sided_short);
|
|
|
|
|
|
num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_2sided_short, num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Map finishings values...
|
|
|
*/
|
|
|
|
|
|
num_pwgppds = _ppdCacheGetFinishingOptions(pc, job->attrs, IPP_FINISHINGS_NONE, num_pwgppds, &pwgppds);
|
|
|
|
|
|
for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG2, "After mapping finishings %s=%s", pwgppd->name, pwgppd->value);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Map page-delivery values...
|
|
|
*/
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, "page-delivery", IPP_TAG_KEYWORD)) != NULL && !ippFindAttribute(job->attrs, "outputorder", IPP_TAG_ZERO))
|
|
|
{
|
|
|
const char *page_delivery = ippGetString(attr, 0, NULL);
|
|
|
|
|
|
if (!strncmp(page_delivery, "same-order", 10))
|
|
|
num_pwgppds = cupsAddOption("OutputOrder", "Normal", num_pwgppds, &pwgppds);
|
|
|
else if (!strncmp(page_delivery, "reverse-order", 13))
|
|
|
num_pwgppds = cupsAddOption("OutputOrder", "Reverse", num_pwgppds, &pwgppds);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Figure out how much room we need...
|
|
|
*/
|
|
|
|
|
|
newlength = ipp_length(job->attrs);
|
|
|
|
|
|
for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
|
|
|
newlength += 1 + strlen(pwgppd->name) + 1 + strlen(pwgppd->value);
|
|
|
|
|
|
/*
|
|
|
* Then allocate/reallocate the option buffer as needed...
|
|
|
*/
|
|
|
|
|
|
if (newlength == 0) /* This can never happen, but Clang */
|
|
|
newlength = 1; /* thinks it can... */
|
|
|
|
|
|
if (newlength > optlength || !options)
|
|
|
{
|
|
|
if (!options)
|
|
|
optptr = malloc(newlength);
|
|
|
else
|
|
|
optptr = realloc(options, newlength);
|
|
|
|
|
|
if (!optptr)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_CRIT,
|
|
|
"Unable to allocate " CUPS_LLFMT " bytes for option buffer.",
|
|
|
CUPS_LLCAST newlength);
|
|
|
return (NULL);
|
|
|
}
|
|
|
|
|
|
options = optptr;
|
|
|
optlength = newlength;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Now loop through the attributes and convert them to the textual
|
|
|
* representation used by the filters...
|
|
|
*/
|
|
|
|
|
|
optptr = options;
|
|
|
*optptr = '\0';
|
|
|
|
|
|
snprintf(title, title_size, "%s-%d", job->printer->name, job->id);
|
|
|
strlcpy(copies, "1", copies_size);
|
|
|
|
|
|
for (attr = job->attrs->attrs; attr != NULL; attr = attr->next)
|
|
|
{
|
|
|
if (!strcmp(attr->name, "copies") &&
|
|
|
attr->value_tag == IPP_TAG_INTEGER)
|
|
|
{
|
|
|
/*
|
|
|
* Don't use the # copies attribute if we are printing the job sheets...
|
|
|
*/
|
|
|
|
|
|
if (!banner_page)
|
|
|
snprintf(copies, copies_size, "%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, title_size);
|
|
|
else if (attr->group_tag == IPP_TAG_JOB)
|
|
|
{
|
|
|
/*
|
|
|
* Filter out other unwanted attributes...
|
|
|
*/
|
|
|
|
|
|
if (attr->value_tag == IPP_TAG_NOVALUE ||
|
|
|
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") &&
|
|
|
strcmp(attr->name, "job-authorization-uri")) ||
|
|
|
attr->value_tag == IPP_TAG_URISCHEME ||
|
|
|
attr->value_tag == IPP_TAG_BEGIN_COLLECTION) /* Not yet supported */
|
|
|
continue;
|
|
|
|
|
|
if (!strcmp(attr->name, "job-hold-until") ||
|
|
|
!strcmp(attr->name, "job-id") ||
|
|
|
!strcmp(attr->name, "job-k-octets") ||
|
|
|
!strcmp(attr->name, "job-media-sheets") ||
|
|
|
!strcmp(attr->name, "job-media-sheets-completed") ||
|
|
|
!strcmp(attr->name, "job-state") ||
|
|
|
!strcmp(attr->name, "job-state-reasons"))
|
|
|
continue;
|
|
|
|
|
|
if (!strncmp(attr->name, "job-", 4) &&
|
|
|
strcmp(attr->name, "job-account-id") &&
|
|
|
strcmp(attr->name, "job-accounting-user-id") &&
|
|
|
strcmp(attr->name, "job-authorization-uri") &&
|
|
|
strcmp(attr->name, "job-billing") &&
|
|
|
strcmp(attr->name, "job-impressions") &&
|
|
|
strcmp(attr->name, "job-originating-host-name") &&
|
|
|
strcmp(attr->name, "job-password") &&
|
|
|
strcmp(attr->name, "job-password-encryption") &&
|
|
|
strcmp(attr->name, "job-uuid") &&
|
|
|
!(job->printer->type & CUPS_PRINTER_REMOTE))
|
|
|
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") ||
|
|
|
!_cups_strcasecmp(attr->name, "AP_FIRSTPAGE_InputSlot") ||
|
|
|
!_cups_strcasecmp(attr->name, "AP_FIRSTPAGE_ManualFeed") ||
|
|
|
!_cups_strcasecmp(attr->name, "com.apple.print.PrintSettings."
|
|
|
"PMTotalSidesImaged..n.") ||
|
|
|
!_cups_strcasecmp(attr->name, "com.apple.print.PrintSettings."
|
|
|
"PMTotalBeginPages..n.")) &&
|
|
|
banner_page)
|
|
|
continue;
|
|
|
|
|
|
/*
|
|
|
* Otherwise add them to the list...
|
|
|
*/
|
|
|
|
|
|
if (optptr > options)
|
|
|
strlcat(optptr, " ", optlength - (size_t)(optptr - options));
|
|
|
|
|
|
if (attr->value_tag != IPP_TAG_BOOLEAN)
|
|
|
{
|
|
|
strlcat(optptr, attr->name, optlength - (size_t)(optptr - options));
|
|
|
strlcat(optptr, "=", optlength - (size_t)(optptr - options));
|
|
|
}
|
|
|
|
|
|
for (i = 0; i < attr->num_values; i ++)
|
|
|
{
|
|
|
if (i)
|
|
|
strlcat(optptr, ",", optlength - (size_t)(optptr - options));
|
|
|
|
|
|
optptr += strlen(optptr);
|
|
|
|
|
|
switch (attr->value_tag)
|
|
|
{
|
|
|
case IPP_TAG_INTEGER :
|
|
|
case IPP_TAG_ENUM :
|
|
|
snprintf(optptr, optlength - (size_t)(optptr - options),
|
|
|
"%d", attr->values[i].integer);
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_BOOLEAN :
|
|
|
if (!attr->values[i].boolean)
|
|
|
strlcat(optptr, "no", optlength - (size_t)(optptr - options));
|
|
|
|
|
|
strlcat(optptr, attr->name, optlength - (size_t)(optptr - options));
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_RANGE :
|
|
|
if (attr->values[i].range.lower == attr->values[i].range.upper)
|
|
|
snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
|
|
|
"%d", attr->values[i].range.lower);
|
|
|
else
|
|
|
snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
|
|
|
"%d-%d", attr->values[i].range.lower,
|
|
|
attr->values[i].range.upper);
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_RESOLUTION :
|
|
|
snprintf(optptr, optlength - (size_t)(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" : "dpcm");
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_STRING :
|
|
|
{
|
|
|
int length = attr->values[i].unknown.length;
|
|
|
|
|
|
for (valptr = attr->values[i].unknown.data; length > 0; length --)
|
|
|
{
|
|
|
if ((*valptr & 255) < 0x20 || *valptr == 0x7f)
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if (length > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Encode this string as hex characters...
|
|
|
*/
|
|
|
|
|
|
*optptr++ = '<';
|
|
|
|
|
|
for (valptr = attr->values[i].unknown.data, length = attr->values[i].unknown.length; length > 0; length --)
|
|
|
{
|
|
|
snprintf(optptr, optlength - (size_t)(optptr - options) - 1, "%02X", *valptr & 255);
|
|
|
optptr += 2;
|
|
|
}
|
|
|
|
|
|
*optptr++ = '>';
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
for (valptr = attr->values[i].unknown.data, length = attr->values[i].unknown.length; length > 0; length --)
|
|
|
{
|
|
|
if (strchr(" \t\n\\\'\"", *valptr))
|
|
|
*optptr++ = '\\';
|
|
|
*optptr++ = *valptr++;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
*optptr = '\0';
|
|
|
break;
|
|
|
|
|
|
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; /* anti-compiler-warning-code */
|
|
|
}
|
|
|
}
|
|
|
|
|
|
optptr += strlen(optptr);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Finally loop through the PWG->PPD mapped options and add them...
|
|
|
*/
|
|
|
|
|
|
for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
|
|
|
{
|
|
|
*optptr++ = ' ';
|
|
|
strlcpy(optptr, pwgppd->name, optlength - (size_t)(optptr - options));
|
|
|
optptr += strlen(optptr);
|
|
|
*optptr++ = '=';
|
|
|
strlcpy(optptr, pwgppd->value, optlength - (size_t)(optptr - options));
|
|
|
optptr += strlen(optptr);
|
|
|
}
|
|
|
|
|
|
cupsFreeOptions(num_pwgppds, pwgppds);
|
|
|
|
|
|
/*
|
|
|
* Return the options string...
|
|
|
*/
|
|
|
|
|
|
return (options);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'ipp_length()' - Compute the size of the buffer needed to hold
|
|
|
* the textual IPP attributes.
|
|
|
*/
|
|
|
|
|
|
static size_t /* O - Size of attribute buffer */
|
|
|
ipp_length(ipp_t *ipp) /* I - IPP request */
|
|
|
{
|
|
|
size_t bytes; /* Number of bytes */
|
|
|
int i; /* Looping var */
|
|
|
ipp_attribute_t *attr; /* Current attribute */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Loop through all attributes...
|
|
|
*/
|
|
|
|
|
|
bytes = 0;
|
|
|
|
|
|
for (attr = ipp->attrs; attr != NULL; attr = attr->next)
|
|
|
{
|
|
|
/*
|
|
|
* Skip attributes that won't be sent to filters...
|
|
|
*/
|
|
|
|
|
|
if (attr->value_tag == IPP_TAG_NOVALUE ||
|
|
|
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;
|
|
|
|
|
|
/*
|
|
|
* Add space for a leading space and commas between each value.
|
|
|
* For the first attribute, the leading space isn't used, so the
|
|
|
* extra byte can be used as the nul terminator...
|
|
|
*/
|
|
|
|
|
|
bytes ++; /* " " separator */
|
|
|
bytes += (size_t)attr->num_values; /* "," separators */
|
|
|
|
|
|
/*
|
|
|
* Boolean attributes appear as "foo,nofoo,foo,nofoo", while
|
|
|
* other attributes appear as "foo=value1,value2,...,valueN".
|
|
|
*/
|
|
|
|
|
|
if (attr->value_tag != IPP_TAG_BOOLEAN)
|
|
|
bytes += strlen(attr->name);
|
|
|
else
|
|
|
bytes += (size_t)attr->num_values * strlen(attr->name);
|
|
|
|
|
|
/*
|
|
|
* Now add the size required for each value in the attribute...
|
|
|
*/
|
|
|
|
|
|
switch (attr->value_tag)
|
|
|
{
|
|
|
case IPP_TAG_INTEGER :
|
|
|
case IPP_TAG_ENUM :
|
|
|
/*
|
|
|
* Minimum value of a signed integer is -2147483647, or 11 digits.
|
|
|
*/
|
|
|
|
|
|
bytes += (size_t)attr->num_values * 11;
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_BOOLEAN :
|
|
|
/*
|
|
|
* Add two bytes for each false ("no") value...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < attr->num_values; i ++)
|
|
|
if (!attr->values[i].boolean)
|
|
|
bytes += 2;
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_RANGE :
|
|
|
/*
|
|
|
* A range is two signed integers separated by a hyphen, or
|
|
|
* 23 characters max.
|
|
|
*/
|
|
|
|
|
|
bytes += (size_t)attr->num_values * 23;
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_RESOLUTION :
|
|
|
/*
|
|
|
* A resolution is two signed integers separated by an "x" and
|
|
|
* suffixed by the units, or 26 characters max.
|
|
|
*/
|
|
|
|
|
|
bytes += (size_t)attr->num_values * 26;
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_STRING :
|
|
|
/*
|
|
|
* Octet strings can contain characters that need quoting. We need
|
|
|
* at least 2 * len + 2 characters to cover the quotes and any
|
|
|
* backslashes in the string.
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < attr->num_values; i ++)
|
|
|
bytes += 2 * (size_t)attr->values[i].unknown.length + 2;
|
|
|
break;
|
|
|
|
|
|
case IPP_TAG_TEXT :
|
|
|
case IPP_TAG_NAME :
|
|
|
case IPP_TAG_KEYWORD :
|
|
|
case IPP_TAG_CHARSET :
|
|
|
case IPP_TAG_LANGUAGE :
|
|
|
case IPP_TAG_URI :
|
|
|
/*
|
|
|
* Strings can contain characters that need quoting. We need
|
|
|
* at least 2 * len + 2 characters to cover the quotes and
|
|
|
* any backslashes in the string.
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < attr->num_values; i ++)
|
|
|
bytes += 2 * strlen(attr->values[i].string.text) + 2;
|
|
|
break;
|
|
|
|
|
|
default :
|
|
|
break; /* anti-compiler-warning-code */
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return (bytes);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'load_job_cache()' - Load jobs from the job.cache file.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
load_job_cache(const char *filename) /* I - job.cache filename */
|
|
|
{
|
|
|
cups_file_t *fp; /* job.cache file */
|
|
|
char line[1024], /* Line buffer */
|
|
|
*value; /* Value on line */
|
|
|
int linenum; /* Line number in file */
|
|
|
cupsd_job_t *job; /* Current job */
|
|
|
int jobid; /* Job ID */
|
|
|
char jobfile[1024]; /* Job filename */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Open the job.cache file...
|
|
|
*/
|
|
|
|
|
|
if ((fp = cupsdOpenConfFile(filename)) == NULL)
|
|
|
{
|
|
|
load_request_root();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Read entries from the job cache file and create jobs as needed.
|
|
|
*/
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_INFO, "Loading job cache file \"%s\"...",
|
|
|
filename);
|
|
|
|
|
|
linenum = 0;
|
|
|
job = NULL;
|
|
|
|
|
|
while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
|
|
|
{
|
|
|
if (!_cups_strcasecmp(line, "NextJobId"))
|
|
|
{
|
|
|
if (value)
|
|
|
NextJobId = atoi(value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "<Job"))
|
|
|
{
|
|
|
if (job)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Missing </Job> directive on line %d of %s.", linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (!value)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Missing job ID on line %d of %s.", linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
jobid = atoi(value);
|
|
|
|
|
|
if (jobid < 1)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad job ID %d on line %d of %s.", jobid, linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, jobid);
|
|
|
if (access(jobfile, 0))
|
|
|
{
|
|
|
snprintf(jobfile, sizeof(jobfile), "%s/c%05d.N", RequestRoot, jobid);
|
|
|
if (access(jobfile, 0))
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "[Job %d] Files have gone away.",
|
|
|
jobid);
|
|
|
|
|
|
/*
|
|
|
* job.cache file is out-of-date compared to spool directory; load
|
|
|
* that instead...
|
|
|
*/
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
load_request_root();
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Loading from cache...");
|
|
|
}
|
|
|
else if (!job)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Missing <Job #> directive on line %d of %s.", linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "</Job>"))
|
|
|
{
|
|
|
cupsArrayAdd(Jobs, job);
|
|
|
|
|
|
if (job->state_value <= IPP_JOB_STOPPED && cupsdLoadJob(job))
|
|
|
cupsArrayAdd(ActiveJobs, job);
|
|
|
else if (job->state_value > IPP_JOB_STOPPED)
|
|
|
{
|
|
|
if (!job->completed_time || !job->creation_time || !job->name || !job->koctets)
|
|
|
{
|
|
|
cupsdLoadJob(job);
|
|
|
unload_job(job);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
job = NULL;
|
|
|
}
|
|
|
else if (!value)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Missing value on line %d of %s.", linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
else if (!_cups_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 (!_cups_strcasecmp(line, "Name"))
|
|
|
{
|
|
|
cupsdSetString(&(job->name), value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Created"))
|
|
|
{
|
|
|
job->creation_time = strtol(value, NULL, 10);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Completed"))
|
|
|
{
|
|
|
job->completed_time = strtol(value, NULL, 10);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "HoldUntil"))
|
|
|
{
|
|
|
job->hold_until = strtol(value, NULL, 10);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Priority"))
|
|
|
{
|
|
|
job->priority = atoi(value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Username"))
|
|
|
{
|
|
|
cupsdSetString(&job->username, value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "Destination"))
|
|
|
{
|
|
|
cupsdSetString(&job->dest, value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "DestType"))
|
|
|
{
|
|
|
job->dtype = (cups_ptype_t)atoi(value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "KOctets"))
|
|
|
{
|
|
|
job->koctets = atoi(value);
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "NumFiles"))
|
|
|
{
|
|
|
job->num_files = atoi(value);
|
|
|
|
|
|
if (job->num_files < 0)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad NumFiles value %d on line %d of %s.", job->num_files, linenum, filename);
|
|
|
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))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_INFO, "Data files have gone away.");
|
|
|
job->num_files = 0;
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
job->filetypes = calloc((size_t)job->num_files, sizeof(mime_type_t *));
|
|
|
job->compressions = calloc((size_t)job->num_files, sizeof(int));
|
|
|
|
|
|
if (!job->filetypes || !job->compressions)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_EMERG,
|
|
|
"Unable to allocate memory for %d files.",
|
|
|
job->num_files);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (!_cups_strcasecmp(line, "File"))
|
|
|
{
|
|
|
int number, /* File number */
|
|
|
compression; /* Compression value */
|
|
|
char super[MIME_MAX_SUPER], /* MIME super type */
|
|
|
type[MIME_MAX_TYPE]; /* MIME type */
|
|
|
|
|
|
|
|
|
if (sscanf(value, "%d%*[ \t]%15[^/]/%255s%d", &number, super, type,
|
|
|
&compression) != 4)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File on line %d of %s.", linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (number < 1 || number > job->num_files)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File number %d on line %d of %s.", number, linenum, filename);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
number --;
|
|
|
|
|
|
job->compressions[number] = compression;
|
|
|
job->filetypes[number] = mimeType(MimeDatabase, super, type);
|
|
|
|
|
|
if (!job->filetypes[number])
|
|
|
{
|
|
|
/*
|
|
|
* If the original MIME type is unknown, auto-type it!
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_ERROR,
|
|
|
"Unknown MIME type %s/%s for file %d.",
|
|
|
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 that didn't work, assume it is raw...
|
|
|
*/
|
|
|
|
|
|
if (!job->filetypes[number])
|
|
|
job->filetypes[number] = mimeType(MimeDatabase, "application",
|
|
|
"vnd.cups-raw");
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Unknown %s directive on line %d of %s.", line, linenum, filename);
|
|
|
}
|
|
|
|
|
|
if (job)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR,
|
|
|
"Missing </Job> directive on line %d of %s.", linenum, filename);
|
|
|
cupsdDeleteJob(job, CUPSD_JOB_PURGE);
|
|
|
}
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'load_next_job_id()' - Load the NextJobId value from the job.cache file.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
load_next_job_id(const char *filename) /* I - job.cache filename */
|
|
|
{
|
|
|
cups_file_t *fp; /* job.cache file */
|
|
|
char line[1024], /* Line buffer */
|
|
|
*value; /* Value on line */
|
|
|
int linenum; /* Line number in file */
|
|
|
int next_job_id; /* NextJobId value from line */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Read the NextJobId directive from the job.cache file and use
|
|
|
* the value (if any).
|
|
|
*/
|
|
|
|
|
|
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 (!_cups_strcasecmp(line, "NextJobId"))
|
|
|
{
|
|
|
if (value)
|
|
|
{
|
|
|
next_job_id = atoi(value);
|
|
|
|
|
|
if (next_job_id > NextJobId)
|
|
|
NextJobId = next_job_id;
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
cupsFileClose(fp);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'load_request_root()' - Load jobs from the RequestRoot directory.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
load_request_root(void)
|
|
|
{
|
|
|
cups_dir_t *dir; /* Directory */
|
|
|
cups_dentry_t *dent; /* Directory entry */
|
|
|
cupsd_job_t *job; /* New job */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Open the requests directory...
|
|
|
*/
|
|
|
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Read all the c##### files...
|
|
|
*/
|
|
|
|
|
|
while ((dent = cupsDirRead(dir)) != NULL)
|
|
|
if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c')
|
|
|
{
|
|
|
/*
|
|
|
* Allocate memory for the job...
|
|
|
*/
|
|
|
|
|
|
if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
|
|
|
{
|
|
|
cupsdLogMessage(CUPSD_LOG_ERROR, "Ran out of memory for jobs.");
|
|
|
cupsDirClose(dir);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Assign the job ID...
|
|
|
*/
|
|
|
|
|
|
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;
|
|
|
|
|
|
/*
|
|
|
* Load the job...
|
|
|
*/
|
|
|
|
|
|
if (cupsdLoadJob(job))
|
|
|
{
|
|
|
/*
|
|
|
* Insert the job into the array, sorting by job priority and ID...
|
|
|
*/
|
|
|
|
|
|
cupsArrayAdd(Jobs, job);
|
|
|
|
|
|
if (job->state_value <= IPP_JOB_STOPPED)
|
|
|
cupsArrayAdd(ActiveJobs, job);
|
|
|
else
|
|
|
unload_job(job);
|
|
|
}
|
|
|
else
|
|
|
free(job);
|
|
|
}
|
|
|
|
|
|
cupsDirClose(dir);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'remove_job_files()' - Remove the document files for a job.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
remove_job_files(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
char filename[1024]; /* Document filename */
|
|
|
|
|
|
|
|
|
if (job->num_files <= 0)
|
|
|
return;
|
|
|
|
|
|
for (i = 1; i <= job->num_files; i ++)
|
|
|
{
|
|
|
snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
|
|
|
job->id, i);
|
|
|
cupsdUnlinkOrRemoveFile(filename);
|
|
|
}
|
|
|
|
|
|
free(job->filetypes);
|
|
|
free(job->compressions);
|
|
|
|
|
|
job->file_time = 0;
|
|
|
job->num_files = 0;
|
|
|
job->filetypes = NULL;
|
|
|
job->compressions = NULL;
|
|
|
|
|
|
LastEvent |= CUPSD_EVENT_PRINTER_STATE_CHANGED;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'remove_job_history()' - Remove the control file for a job.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
remove_job_history(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
char filename[1024]; /* Control filename */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Remove the job info file...
|
|
|
*/
|
|
|
|
|
|
snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot,
|
|
|
job->id);
|
|
|
cupsdUnlinkOrRemoveFile(filename);
|
|
|
|
|
|
LastEvent |= CUPSD_EVENT_PRINTER_STATE_CHANGED;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'set_time()' - Set one of the "time-at-xyz" attributes.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
set_time(cupsd_job_t *job, /* I - Job to update */
|
|
|
const char *name) /* I - Name of attribute */
|
|
|
{
|
|
|
char date_name[128]; /* date-time-at-xxx */
|
|
|
ipp_attribute_t *attr; /* Time attribute */
|
|
|
time_t curtime; /* Current time */
|
|
|
|
|
|
|
|
|
curtime = time(NULL);
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "%s=%ld", name, (long)curtime);
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO)) != NULL)
|
|
|
{
|
|
|
attr->value_tag = IPP_TAG_INTEGER;
|
|
|
attr->values[0].integer = curtime;
|
|
|
}
|
|
|
|
|
|
snprintf(date_name, sizeof(date_name), "date-%s", name);
|
|
|
|
|
|
if ((attr = ippFindAttribute(job->attrs, date_name, IPP_TAG_ZERO)) != NULL)
|
|
|
{
|
|
|
attr->value_tag = IPP_TAG_DATE;
|
|
|
ippSetDate(job->attrs, &attr, 0, ippTimeToDate(curtime));
|
|
|
}
|
|
|
|
|
|
if (!strcmp(name, "time-at-completed"))
|
|
|
{
|
|
|
job->completed_time = curtime;
|
|
|
|
|
|
if (JobHistory < INT_MAX && attr)
|
|
|
job->history_time = job->completed_time + JobHistory;
|
|
|
else
|
|
|
job->history_time = INT_MAX;
|
|
|
|
|
|
if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->history_time;
|
|
|
|
|
|
if (JobFiles < INT_MAX && attr)
|
|
|
job->file_time = job->completed_time + JobFiles;
|
|
|
else
|
|
|
job->file_time = INT_MAX;
|
|
|
|
|
|
if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
|
|
|
JobHistoryUpdate = job->file_time;
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_time: JobHistoryUpdate=%ld",
|
|
|
(long)JobHistoryUpdate);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'start_job()' - Start a print job.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
start_job(cupsd_job_t *job, /* I - Job ID */
|
|
|
cupsd_printer_t *printer) /* I - Printer to print job */
|
|
|
{
|
|
|
const char *filename; /* Support filename */
|
|
|
ipp_attribute_t *cancel_after = ippFindAttribute(job->attrs,
|
|
|
"job-cancel-after",
|
|
|
IPP_TAG_INTEGER);
|
|
|
/* job-cancel-after attribute */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "start_job(job=%p(%d), printer=%p(%s))",
|
|
|
job, job->id, printer, printer->name);
|
|
|
|
|
|
/*
|
|
|
* Make sure we have some files around before we try to print...
|
|
|
*/
|
|
|
|
|
|
if (job->num_files == 0)
|
|
|
{
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
|
|
|
cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_DEFAULT,
|
|
|
"Aborting job because it has no files.");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Update the printer and job state to "processing"...
|
|
|
*/
|
|
|
|
|
|
if (!cupsdLoadJob(job))
|
|
|
return;
|
|
|
|
|
|
if (!job->printer_message)
|
|
|
job->printer_message = ippFindAttribute(job->attrs,
|
|
|
"job-printer-state-message",
|
|
|
IPP_TAG_TEXT);
|
|
|
if (job->printer_message)
|
|
|
ippSetString(job->attrs, &job->printer_message, 0, "");
|
|
|
|
|
|
ippSetString(job->attrs, &job->reasons, 0, "job-printing");
|
|
|
cupsdSetJobState(job, IPP_JOB_PROCESSING, CUPSD_JOB_DEFAULT, NULL);
|
|
|
cupsdSetPrinterState(printer, IPP_PRINTER_PROCESSING, 0);
|
|
|
cupsdSetPrinterReasons(printer, "-cups-remote-pending,"
|
|
|
"cups-remote-pending-held,"
|
|
|
"cups-remote-processing,"
|
|
|
"cups-remote-stopped,"
|
|
|
"cups-remote-canceled,"
|
|
|
"cups-remote-aborted,"
|
|
|
"cups-remote-completed");
|
|
|
|
|
|
job->cost = 0;
|
|
|
job->current_file = 0;
|
|
|
job->file_time = 0;
|
|
|
job->history_time = 0;
|
|
|
job->progress = 0;
|
|
|
job->printer = printer;
|
|
|
printer->job = job;
|
|
|
|
|
|
if (cancel_after)
|
|
|
job->cancel_time = time(NULL) + ippGetInteger(cancel_after, 0);
|
|
|
else if (MaxJobTime > 0)
|
|
|
job->cancel_time = time(NULL) + MaxJobTime;
|
|
|
else
|
|
|
job->cancel_time = 0;
|
|
|
|
|
|
/*
|
|
|
* Check for support files...
|
|
|
*/
|
|
|
|
|
|
cupsdSetPrinterReasons(job->printer, "-cups-missing-filter-warning,"
|
|
|
"cups-insecure-filter-warning");
|
|
|
|
|
|
if (printer->pc)
|
|
|
{
|
|
|
for (filename = (const char *)cupsArrayFirst(printer->pc->support_files);
|
|
|
filename;
|
|
|
filename = (const char *)cupsArrayNext(printer->pc->support_files))
|
|
|
{
|
|
|
if (_cupsFileCheck(filename, _CUPS_FILE_CHECK_FILE, !RunUser,
|
|
|
cupsdLogFCMessage, printer))
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Setup the last exit status and security profiles...
|
|
|
*/
|
|
|
|
|
|
job->status = 0;
|
|
|
job->profile = cupsdCreateProfile(job->id, 0);
|
|
|
job->bprofile = cupsdCreateProfile(job->id, 1);
|
|
|
|
|
|
#ifdef HAVE_SANDBOX_H
|
|
|
if ((!job->profile || !job->bprofile) && UseSandboxing && Sandboxing != CUPSD_SANDBOXING_OFF)
|
|
|
{
|
|
|
/*
|
|
|
* Failure to create the sandbox profile means something really bad has
|
|
|
* happened and we need to shutdown immediately.
|
|
|
*/
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
#endif /* HAVE_SANDBOX_H */
|
|
|
|
|
|
/*
|
|
|
* Create the status pipes and buffer...
|
|
|
*/
|
|
|
|
|
|
if (cupsdOpenPipe(job->status_pipes))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Unable to create job status pipes - %s.", strerror(errno));
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
|
|
|
"Job stopped because the scheduler could not create the "
|
|
|
"job status pipes.");
|
|
|
|
|
|
cupsdDestroyProfile(job->profile);
|
|
|
job->profile = NULL;
|
|
|
cupsdDestroyProfile(job->bprofile);
|
|
|
job->bprofile = NULL;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
job->status_buffer = cupsdStatBufNew(job->status_pipes[0], NULL);
|
|
|
job->status_level = CUPSD_LOG_INFO;
|
|
|
|
|
|
/*
|
|
|
* Create the backchannel pipes and make them non-blocking...
|
|
|
*/
|
|
|
|
|
|
if (cupsdOpenPipe(job->back_pipes))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Unable to create back-channel pipes - %s.", strerror(errno));
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
|
|
|
"Job stopped because the scheduler could not create the "
|
|
|
"back-channel pipes.");
|
|
|
|
|
|
cupsdClosePipe(job->status_pipes);
|
|
|
cupsdStatBufDelete(job->status_buffer);
|
|
|
job->status_buffer = NULL;
|
|
|
|
|
|
cupsdDestroyProfile(job->profile);
|
|
|
job->profile = NULL;
|
|
|
cupsdDestroyProfile(job->bprofile);
|
|
|
job->bprofile = NULL;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
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);
|
|
|
|
|
|
/*
|
|
|
* Create the side-channel pipes and make them non-blocking...
|
|
|
*/
|
|
|
|
|
|
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, job->side_pipes))
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Unable to create side-channel pipes - %s.", strerror(errno));
|
|
|
|
|
|
cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
|
|
|
"Job stopped because the scheduler could not create the "
|
|
|
"side-channel pipes.");
|
|
|
|
|
|
cupsdClosePipe(job->back_pipes);
|
|
|
|
|
|
cupsdClosePipe(job->status_pipes);
|
|
|
cupsdStatBufDelete(job->status_buffer);
|
|
|
job->status_buffer = NULL;
|
|
|
|
|
|
cupsdDestroyProfile(job->profile);
|
|
|
job->profile = NULL;
|
|
|
cupsdDestroyProfile(job->bprofile);
|
|
|
job->bprofile = NULL;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
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);
|
|
|
|
|
|
fcntl(job->side_pipes[0], F_SETFD,
|
|
|
fcntl(job->side_pipes[0], F_GETFD) | FD_CLOEXEC);
|
|
|
fcntl(job->side_pipes[1], F_SETFD,
|
|
|
fcntl(job->side_pipes[1], F_GETFD) | FD_CLOEXEC);
|
|
|
|
|
|
/*
|
|
|
* Now start the first file in the job...
|
|
|
*/
|
|
|
|
|
|
cupsdContinueJob(job);
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'stop_job()' - Stop a print job.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
stop_job(cupsd_job_t *job, /* I - Job */
|
|
|
cupsd_jobaction_t action) /* I - Action */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
|
|
|
|
|
|
cupsdLogMessage(CUPSD_LOG_DEBUG2, "stop_job(job=%p(%d), action=%d)", job,
|
|
|
job->id, action);
|
|
|
|
|
|
FilterLevel -= job->cost;
|
|
|
job->cost = 0;
|
|
|
|
|
|
if (action == CUPSD_JOB_DEFAULT && !job->kill_time && job->backend > 0)
|
|
|
job->kill_time = time(NULL) + JobKillDelay;
|
|
|
else if (action >= CUPSD_JOB_FORCE)
|
|
|
job->kill_time = 0;
|
|
|
|
|
|
for (i = 0; job->filters[i]; i ++)
|
|
|
if (job->filters[i] > 0)
|
|
|
{
|
|
|
cupsdEndProcess(job->filters[i], action >= CUPSD_JOB_FORCE);
|
|
|
|
|
|
if (action >= CUPSD_JOB_FORCE)
|
|
|
job->filters[i] = -job->filters[i];
|
|
|
}
|
|
|
|
|
|
if (job->backend > 0)
|
|
|
{
|
|
|
cupsdEndProcess(job->backend, action >= CUPSD_JOB_FORCE);
|
|
|
|
|
|
if (action >= CUPSD_JOB_FORCE)
|
|
|
job->backend = -job->backend;
|
|
|
}
|
|
|
|
|
|
if (action >= CUPSD_JOB_FORCE)
|
|
|
{
|
|
|
/*
|
|
|
* Clear job status...
|
|
|
*/
|
|
|
|
|
|
job->status = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'unload_job()' - Unload a job from memory.
|
|
|
*/
|
|
|
|
|
|
static void
|
|
|
unload_job(cupsd_job_t *job) /* I - Job */
|
|
|
{
|
|
|
if (!job->attrs)
|
|
|
return;
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "Unloading...");
|
|
|
|
|
|
ippDelete(job->attrs);
|
|
|
|
|
|
job->attrs = NULL;
|
|
|
job->state = NULL;
|
|
|
job->reasons = NULL;
|
|
|
job->impressions = NULL;
|
|
|
job->sheets = NULL;
|
|
|
job->job_sheets = NULL;
|
|
|
job->printer_message = NULL;
|
|
|
job->printer_reasons = NULL;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'update_job()' - Read a status update from a job's filters.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
update_job(cupsd_job_t *job) /* I - Job to check */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
char message[CUPSD_SB_BUFFER_SIZE],
|
|
|
/* Message text */
|
|
|
*ptr; /* Pointer update... */
|
|
|
int loglevel, /* Log level for message */
|
|
|
event = 0; /* Events? */
|
|
|
cupsd_printer_t *printer = job->printer;
|
|
|
/* Printer */
|
|
|
static const char * const levels[] = /* Log levels */
|
|
|
{
|
|
|
"NONE",
|
|
|
"EMERG",
|
|
|
"ALERT",
|
|
|
"CRIT",
|
|
|
"ERROR",
|
|
|
"WARN",
|
|
|
"NOTICE",
|
|
|
"INFO",
|
|
|
"DEBUG",
|
|
|
"DEBUG2"
|
|
|
};
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Get the printer associated with this job; if the printer is stopped for
|
|
|
* any reason then job->printer will be reset to NULL, so make sure we have
|
|
|
* a valid pointer...
|
|
|
*/
|
|
|
|
|
|
while ((ptr = cupsdStatBufUpdate(job->status_buffer, &loglevel,
|
|
|
message, sizeof(message))) != NULL)
|
|
|
{
|
|
|
/*
|
|
|
* Process page and printer state messages as needed...
|
|
|
*/
|
|
|
|
|
|
if (loglevel == CUPSD_LOG_PAGE)
|
|
|
{
|
|
|
int impressions = ippGetInteger(job->impressions, 0);
|
|
|
/* Number of impressions printed */
|
|
|
int delta; /* Number of impressions added */
|
|
|
|
|
|
/*
|
|
|
* Page message; send the message to the page_log file and update the
|
|
|
* job sheet count...
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "PAGE: %s", message);
|
|
|
|
|
|
if (!_cups_strncasecmp(message, "total ", 6))
|
|
|
{
|
|
|
/*
|
|
|
* Got a total count of pages from a backend or filter...
|
|
|
*/
|
|
|
|
|
|
int total = atoi(message + 6); /* Total impressions */
|
|
|
|
|
|
if (total > impressions)
|
|
|
{
|
|
|
delta = total - impressions;
|
|
|
impressions = total;
|
|
|
}
|
|
|
else
|
|
|
delta = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Add the number of copies to the impression count...
|
|
|
*/
|
|
|
|
|
|
int copies; /* Number of copies */
|
|
|
|
|
|
if (!sscanf(message, "%*d%d", &copies) || copies <= 0)
|
|
|
copies = 1;
|
|
|
|
|
|
delta = copies;
|
|
|
impressions += copies;
|
|
|
}
|
|
|
|
|
|
if (job->impressions)
|
|
|
ippSetInteger(job->attrs, &job->impressions, 0, impressions);
|
|
|
|
|
|
if (job->sheets)
|
|
|
{
|
|
|
const char *sides = ippGetString(ippFindAttribute(job->attrs, "sides", IPP_TAG_KEYWORD), 0, NULL);
|
|
|
|
|
|
if (sides && strcmp(sides, "one-sided"))
|
|
|
ippSetInteger(job->attrs, &job->sheets, 0, impressions / 2);
|
|
|
else
|
|
|
ippSetInteger(job->attrs, &job->sheets, 0, impressions);
|
|
|
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job, "Printed %d page(s).", ippGetInteger(job->sheets, 0));
|
|
|
}
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
|
|
|
if (job->printer->page_limit)
|
|
|
cupsdUpdateQuota(job->printer, job->username, delta, 0);
|
|
|
}
|
|
|
else if (loglevel == CUPSD_LOG_JOBSTATE)
|
|
|
{
|
|
|
/*
|
|
|
* Support "keyword" to set job-state-reasons to the specified keyword.
|
|
|
* This is sufficient for the current paid printing stuff.
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "JOBSTATE: %s", message);
|
|
|
|
|
|
if (!strcmp(message, "cups-retry-as-raster"))
|
|
|
job->retry_as_raster = 1;
|
|
|
else
|
|
|
ippSetString(job->attrs, &job->reasons, 0, message);
|
|
|
}
|
|
|
else if (loglevel == CUPSD_LOG_STATE)
|
|
|
{
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "STATE: %s", message);
|
|
|
|
|
|
if (!strcmp(message, "paused"))
|
|
|
{
|
|
|
cupsdStopPrinter(job->printer, 1);
|
|
|
return;
|
|
|
}
|
|
|
else if (message[0] && cupsdSetPrinterReasons(job->printer, message))
|
|
|
{
|
|
|
event |= CUPSD_EVENT_PRINTER_STATE;
|
|
|
|
|
|
if (MaxJobTime > 0)
|
|
|
{
|
|
|
/*
|
|
|
* Reset cancel time after connecting to the device...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < job->printer->num_reasons; i ++)
|
|
|
if (!strcmp(job->printer->reasons[i], "connecting-to-device"))
|
|
|
break;
|
|
|
|
|
|
if (i >= job->printer->num_reasons)
|
|
|
{
|
|
|
ipp_attribute_t *cancel_after = ippFindAttribute(job->attrs,
|
|
|
"job-cancel-after",
|
|
|
IPP_TAG_INTEGER);
|
|
|
/* job-cancel-after attribute */
|
|
|
|
|
|
if (cancel_after)
|
|
|
job->cancel_time = time(NULL) + ippGetInteger(cancel_after, 0);
|
|
|
else if (MaxJobTime > 0)
|
|
|
job->cancel_time = time(NULL) + MaxJobTime;
|
|
|
else
|
|
|
job->cancel_time = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
update_job_attrs(job, 0);
|
|
|
}
|
|
|
else if (loglevel == CUPSD_LOG_ATTR)
|
|
|
{
|
|
|
/*
|
|
|
* Set attribute(s)...
|
|
|
*/
|
|
|
|
|
|
int num_attrs; /* Number of attributes */
|
|
|
cups_option_t *attrs; /* Attributes */
|
|
|
const char *attr; /* Attribute */
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "ATTR: %s", message);
|
|
|
|
|
|
num_attrs = cupsParseOptions(message, 0, &attrs);
|
|
|
|
|
|
if ((attr = cupsGetOption("auth-info-default", num_attrs,
|
|
|
attrs)) != NULL)
|
|
|
{
|
|
|
job->printer->num_options = cupsAddOption("auth-info", attr,
|
|
|
job->printer->num_options,
|
|
|
&(job->printer->options));
|
|
|
cupsdSetPrinterAttrs(job->printer);
|
|
|
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
if ((attr = cupsGetOption("auth-info-required", num_attrs,
|
|
|
attrs)) != NULL)
|
|
|
{
|
|
|
cupsdSetAuthInfoRequired(job->printer, attr, NULL);
|
|
|
cupsdSetPrinterAttrs(job->printer);
|
|
|
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
if ((attr = cupsGetOption("job-media-progress", num_attrs,
|
|
|
attrs)) != NULL)
|
|
|
{
|
|
|
int progress = atoi(attr);
|
|
|
|
|
|
|
|
|
if (progress >= 0 && progress <= 100)
|
|
|
{
|
|
|
job->progress = progress;
|
|
|
|
|
|
if (job->sheets)
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
|
|
|
"Printing page %d, %d%%",
|
|
|
job->sheets->values[0].integer, job->progress);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
if ((attr = cupsGetOption("marker-low-levels", num_attrs, attrs)) != NULL)
|
|
|
{
|
|
|
cupsdSetPrinterAttr(job->printer, "marker-low-levels", (char *)attr);
|
|
|
job->printer->marker_time = time(NULL);
|
|
|
event |= CUPSD_EVENT_PRINTER_STATE;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
if ((attr = cupsGetOption("marker-high-levels", num_attrs, attrs)) != NULL)
|
|
|
{
|
|
|
cupsdSetPrinterAttr(job->printer, "marker-high-levels", (char *)attr);
|
|
|
job->printer->marker_time = time(NULL);
|
|
|
event |= CUPSD_EVENT_PRINTER_STATE;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
|
|
|
}
|
|
|
|
|
|
cupsFreeOptions(num_attrs, attrs);
|
|
|
}
|
|
|
else if (loglevel == CUPSD_LOG_PPD)
|
|
|
{
|
|
|
/*
|
|
|
* Set attribute(s)...
|
|
|
*/
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG, "PPD: %s", message);
|
|
|
|
|
|
job->num_keywords = cupsParseOptions(message, job->num_keywords,
|
|
|
&job->keywords);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Strip legacy message prefix...
|
|
|
*/
|
|
|
|
|
|
if (!strncmp(message, "recoverable:", 12))
|
|
|
{
|
|
|
ptr = message + 12;
|
|
|
while (isspace(*ptr & 255))
|
|
|
ptr ++;
|
|
|
}
|
|
|
else if (!strncmp(message, "recovered:", 10))
|
|
|
{
|
|
|
ptr = message + 10;
|
|
|
while (isspace(*ptr & 255))
|
|
|
ptr ++;
|
|
|
}
|
|
|
else
|
|
|
ptr = message;
|
|
|
|
|
|
if (*ptr)
|
|
|
cupsdLogJob(job, loglevel == CUPSD_LOG_INFO ? CUPSD_LOG_DEBUG : loglevel, "%s", ptr);
|
|
|
|
|
|
if (loglevel < CUPSD_LOG_DEBUG &&
|
|
|
strcmp(job->printer->state_message, ptr))
|
|
|
{
|
|
|
strlcpy(job->printer->state_message, ptr,
|
|
|
sizeof(job->printer->state_message));
|
|
|
|
|
|
event |= CUPSD_EVENT_PRINTER_STATE | CUPSD_EVENT_JOB_PROGRESS;
|
|
|
|
|
|
if (loglevel <= job->status_level && job->status_level > CUPSD_LOG_ERROR)
|
|
|
{
|
|
|
/*
|
|
|
* Some messages show in the job-printer-state-message attribute...
|
|
|
*/
|
|
|
|
|
|
if (loglevel != CUPSD_LOG_NOTICE)
|
|
|
job->status_level = loglevel;
|
|
|
|
|
|
update_job_attrs(job, 1);
|
|
|
|
|
|
cupsdLogJob(job, CUPSD_LOG_DEBUG,
|
|
|
"Set job-printer-state-message to \"%s\", "
|
|
|
"current level=%s",
|
|
|
job->printer_message->values[0].string.text,
|
|
|
levels[job->status_level]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!strchr(job->status_buffer->buffer, '\n'))
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if (event & CUPSD_EVENT_JOB_PROGRESS)
|
|
|
cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
|
|
|
"%s", job->printer->state_message);
|
|
|
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)
|
|
|
{
|
|
|
/*
|
|
|
* See if all of the filters and the backend have returned their
|
|
|
* exit statuses.
|
|
|
*/
|
|
|
|
|
|
for (i = 0; job->filters[i] < 0; i ++);
|
|
|
|
|
|
if (job->filters[i])
|
|
|
{
|
|
|
/*
|
|
|
* EOF but we haven't collected the exit status of all filters...
|
|
|
*/
|
|
|
|
|
|
cupsdCheckProcess();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (job->current_file >= job->num_files && job->backend > 0)
|
|
|
{
|
|
|
/*
|
|
|
* EOF but we haven't collected the exit status of the backend...
|
|
|
*/
|
|
|
|
|
|
cupsdCheckProcess();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Handle the end of job stuff...
|
|
|
*/
|
|
|
|
|
|
finalize_job(job, 1);
|
|
|
|
|
|
/*
|
|
|
* Try printing another job...
|
|
|
*/
|
|
|
|
|
|
if (printer->state != IPP_PRINTER_STOPPED)
|
|
|
cupsdCheckJobs();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/*
|
|
|
* 'update_job_attrs()' - Update the job-printer-* attributes.
|
|
|
*/
|
|
|
|
|
|
void
|
|
|
update_job_attrs(cupsd_job_t *job, /* I - Job to update */
|
|
|
int do_message)/* I - 1 = copy job-printer-state message */
|
|
|
{
|
|
|
int i; /* Looping var */
|
|
|
int num_reasons; /* Actual number of reasons */
|
|
|
const char * const *reasons; /* Reasons */
|
|
|
static const char *none = "none"; /* "none" reason */
|
|
|
|
|
|
|
|
|
/*
|
|
|
* Get/create the job-printer-state-* attributes...
|
|
|
*/
|
|
|
|
|
|
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);
|
|
|
|
|
|
/*
|
|
|
* Copy or clear the printer-state-message value as needed...
|
|
|
*/
|
|
|
|
|
|
if (job->state_value != IPP_JOB_PROCESSING &&
|
|
|
job->status_level == CUPSD_LOG_INFO)
|
|
|
{
|
|
|
ippSetString(job->attrs, &job->printer_message, 0, "");
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
else if (job->printer->state_message[0] && do_message)
|
|
|
{
|
|
|
ippSetString(job->attrs, &job->printer_message, 0, job->printer->state_message);
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* ... and the printer-state-reasons value...
|
|
|
*/
|
|
|
|
|
|
if (job->printer->num_reasons == 0)
|
|
|
{
|
|
|
num_reasons = 1;
|
|
|
reasons = &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)
|
|
|
{
|
|
|
/*
|
|
|
* Replace/create a job-printer-state-reasons attribute...
|
|
|
*/
|
|
|
|
|
|
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);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*
|
|
|
* Don't bother clearing the reason strings if they are the same...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < num_reasons; i ++)
|
|
|
if (strcmp(job->printer_reasons->values[i].string.text, reasons[i]))
|
|
|
break;
|
|
|
|
|
|
if (i >= num_reasons)
|
|
|
return;
|
|
|
|
|
|
/*
|
|
|
* Not the same, so free the current strings...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < num_reasons; i ++)
|
|
|
_cupsStrFree(job->printer_reasons->values[i].string.text);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Copy the reasons...
|
|
|
*/
|
|
|
|
|
|
for (i = 0; i < num_reasons; i ++)
|
|
|
job->printer_reasons->values[i].string.text = _cupsStrAlloc(reasons[i]);
|
|
|
|
|
|
job->dirty = 1;
|
|
|
cupsdMarkDirty(CUPSD_DIRTY_JOBS);
|
|
|
}
|
