]> git.ipfire.org Git - thirdparty/cups.git/blame - scheduler/job.c
projects / thirdparty / cups.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Save work on test suite to ensure we collect the exit status of all child
[thirdparty/cups.git] / scheduler / job.c
CommitLineData
ef416fc2 1/*
f2d18633 2 * "$Id$"
ef416fc2 3 *
462b6e74 4 * Job management routines for the CUPS scheduler.
ef416fc2 5 *
7e86f2f6 6 * Copyright 2007-2014 by Apple Inc.
462b6e74 7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
ef416fc2 8 *
462b6e74
MS		 9 * These coded instructions, statements, and computer programs are the
10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
12 * which should have been included with this file. If this file is
13 * file is missing or damaged, see the license at "http://www.cups.org/".
ef416fc2 14 */
15
16/*
17 * Include necessary headers...
18 */
19
20#include "cupsd.h"
21#include <grp.h>
22#include <cups/backend.h>
23#include <cups/dir.h>
88f9aafc
MS		 24#ifdef __APPLE__
25# include <IOKit/pwr_mgt/IOPMLib.h>
26# ifdef HAVE_IOKIT_PWR_MGT_IOPMLIBPRIVATE_H
27# include <IOKit/pwr_mgt/IOPMLibPrivate.h>
28# endif /* HAVE_IOKIT_PWR_MGT_IOPMLIBPRIVATE_H */
29#endif /* __APPLE__ */
ef416fc2 30
31
b9faaae1
MS		 32/*
33 * Design Notes for Job Management
34 * -------------------------------
35 *
36 * STATE CHANGES
37 *
38 * pending Do nothing/check jobs
39 * pending-held Send SIGTERM to filters and backend
40 * processing Do nothing/start job
41 * stopped Send SIGKILL to filters and backend
42 * canceled Send SIGTERM to filters and backend
43 * aborted Finalize
44 * completed Finalize
45 *
46 * Finalize clears the printer <-> job association, deletes the status
47 * buffer, closes all of the pipes, etc. and doesn't get run until all of
48 * the print processes are finished.
49 *
50 * UNLOADING OF JOBS (cupsdUnloadCompletedJobs)
51 *
52 * We unload the job attributes when they are not needed to reduce overall
53 * memory consumption. We don't unload jobs where job->state_value <
54 * IPP_JOB_STOPPED, job->printer != NULL, or job->access_time is recent.
55 *
56 * STARTING OF JOBS (start_job)
57 *
58 * When a job is started, a status buffer, several pipes, a security
59 * profile, and a backend process are created for the life of that job.
60 * These are shared for every file in a job. For remote print jobs, the
61 * IPP backend is provided with every file in the job and no filters are
62 * run.
63 *
64 * The job->printer member tracks which printer is printing a job, which
65 * can be different than the destination in job->dest for classes. The
66 * printer object also has a job pointer to track which job is being
67 * printed.
68 *
69 * PRINTING OF JOB FILES (cupsdContinueJob)
70 *
71 * Each file in a job is filtered by 0 or more programs. After getting the
72 * list of filters needed and the total cost, the job is either passed or
73 * put back to the processing state until the current FilterLevel comes down
74 * enough to allow printing.
75 *
76 * If we can print, we build a string for the print options and run each of
77 * the filters, piping the output from one into the next.
78 *
79 * JOB STATUS UPDATES (update_job)
80 *
81 * The update_job function gets called whenever there are pending messages
82 * on the status pipe. These generally are updates to the marker-*,
83 * printer-state-message, or printer-state-reasons attributes. On EOF,
84 * finalize_job is called to clean up.
85 *
86 * FINALIZING JOBS (finalize_job)
87 *
88 * When all filters and the backend are done, we set the job state to
89 * completed (no errors), aborted (filter errors or abort-job policy),
90 * pending-held (auth required or retry-job policy), or pending
91 * (retry-current-job or stop-printer policies) as appropriate.
92 *
93 * Then we close the pipes and free the status buffers and profiles.
94 *
95 * JOB FILE COMPLETION (process_children in main.c)
96 *
97 * For multiple-file jobs, process_children (in main.c) sees that all
98 * filters have exited and calls in to print the next file if there are
99 * more files in the job, otherwise it waits for the backend to exit and
100 * update_job to do the cleanup.
101 */
102
103
ef416fc2 104/*
105 * Local globals...
106 */
107
108static mime_filter_t gziptoany_filter =
109 {
110 NULL, /* Source type */
111 NULL, /* Destination type */
112 0, /* Cost */
113 "gziptoany" /* Filter program to run */
114 };
115
116
117/*
118 * Local functions...
119 */
120
121static int compare_active_jobs(void *first, void *second, void *data);
122static int compare_jobs(void *first, void *second, void *data);
178cb736 123static void dump_job_history(cupsd_job_t *job);
ef55b745 124static void finalize_job(cupsd_job_t *job, int set_job_state);
178cb736 125static void free_job_history(cupsd_job_t *job);
b9faaae1
MS		 126static char *get_options(cupsd_job_t *job, int banner_page, char *copies,
127 size_t copies_size, char *title,
128 size_t title_size);
c7017ecc 129static size_t ipp_length(ipp_t *ipp);
bd7854cb 130static void load_job_cache(const char *filename);
131static void load_next_job_id(const char *filename);
132static void load_request_root(void);
82cc1f9a
MS		 133static void remove_job_files(cupsd_job_t *job);
134static void remove_job_history(cupsd_job_t *job);
b9faaae1 135static void set_time(cupsd_job_t *job, const char *name);
e1d6a774 136static void start_job(cupsd_job_t *job, cupsd_printer_t *printer);
b9faaae1 137static void stop_job(cupsd_job_t *job, cupsd_jobaction_t action);
e1d6a774 138static void unload_job(cupsd_job_t *job);
f899b121 139static void update_job(cupsd_job_t *job);
4509bb49 140static void update_job_attrs(cupsd_job_t *job, int do_message);
ef416fc2 141
142
143/*
b9faaae1 144 * 'cupsdAddJob()' - Add a new job to the job queue.
ef416fc2 145 */
146
147cupsd_job_t * /* O - New job record */
148cupsdAddJob(int priority, /* I - Job priority */
149 const char *dest) /* I - Job destination */
150{
151 cupsd_job_t *job; /* New job record */
152
153
91c84a35
MS		 154 if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
155 return (NULL);
ef416fc2 156
89d46774 157 job->id = NextJobId ++;
158 job->priority = priority;
159 job->back_pipes[0] = -1;
160 job->back_pipes[1] = -1;
161 job->print_pipes[0] = -1;
162 job->print_pipes[1] = -1;
f7deaa1a 163 job->side_pipes[0] = -1;
164 job->side_pipes[1] = -1;
89d46774 165 job->status_pipes[0] = -1;
166 job->status_pipes[1] = -1;
ef416fc2 167
168 cupsdSetString(&job->dest, dest);
169
170 /*
171 * Add the new job to the "all jobs" and "active jobs" lists...
172 */
173
174 cupsArrayAdd(Jobs, job);
175 cupsArrayAdd(ActiveJobs, job);
176
177 return (job);
178}
179
180
181/*
b9faaae1 182 * 'cupsdCancelJobs()' - Cancel all jobs for the given destination/user.
ef416fc2 183 */
184
185void
186cupsdCancelJobs(const char *dest, /* I - Destination to cancel */
187 const char *username, /* I - Username or NULL */
188 int purge) /* I - Purge jobs? */
189{
190 cupsd_job_t *job; /* Current job */
191
192
193 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
194 job;
195 job = (cupsd_job_t *)cupsArrayNext(Jobs))
0a682745 196 {
b9faaae1 197 if ((!job->dest || !job->username) && !cupsdLoadJob(job))
0a682745
MS		 198 continue;
199
b9faaae1
MS		 200 if ((!dest || !strcmp(job->dest, dest)) &&
201 (!username || !strcmp(job->username, username)))
ef416fc2 202 {
203 /*
204 * Cancel all jobs matching this destination/user...
205 */
206
b9faaae1
MS		 207 if (purge)
208 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_PURGE,
209 "Job purged by user.");
41681883 210 else if (job->state_value < IPP_JOB_CANCELED)
b9faaae1
MS		 211 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_DEFAULT,
212 "Job canceled by user.");
ef416fc2 213 }
0a682745 214 }
ef416fc2 215
216 cupsdCheckJobs();
217}
218
219
220/*
221 * 'cupsdCheckJobs()' - Check the pending jobs and start any if the destination
222 * is available.
223 */
224
225void
226cupsdCheckJobs(void)
227{
228 cupsd_job_t *job; /* Current job in queue */
229 cupsd_printer_t *printer, /* Printer destination */
230 *pclass; /* Printer class destination */
ac884b6a 231 ipp_attribute_t *attr; /* Job attribute */
238c3832 232 time_t curtime; /* Current time */
ef416fc2 233
234
238c3832
MS		 235 curtime = time(NULL);
236
a29fd7dd
MS		 237 cupsdLogMessage(CUPSD_LOG_DEBUG2,
238 "cupsdCheckJobs: %d active jobs, sleeping=%d, reload=%d, "
239 "curtime=%ld", cupsArrayCount(ActiveJobs), Sleeping,
240 NeedReload, (long)curtime);
241
ef416fc2 242 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
243 job;
244 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
245 {
a29fd7dd
MS		 246 cupsdLogMessage(CUPSD_LOG_DEBUG2,
247 "cupsdCheckJobs: Job %d - dest=\"%s\", printer=%p, "
248 "state=%d, cancel_time=%ld, hold_until=%ld, kill_time=%ld, "
249 "pending_cost=%d, pending_timeout=%ld", job->id, job->dest,
250 job->printer, job->state_value, (long)job->cancel_time,
251 (long)job->hold_until, (long)job->kill_time,
252 job->pending_cost, (long)job->pending_timeout);
253
238c3832
MS		 254 /*
255 * Kill jobs if they are unresponsive...
256 */
257
258 if (job->kill_time && job->kill_time <= curtime)
259 {
581dae2d
MS		 260 if (!job->completed)
261 cupsdLogJob(job, CUPSD_LOG_ERROR, "Stopping unresponsive job.");
10d09e33 262
238c3832
MS		 263 stop_job(job, CUPSD_JOB_FORCE);
264 continue;
265 }
266
dcb445bc
MS		 267 /*
268 * Cancel stuck jobs...
269 */
270
271 if (job->cancel_time && job->cancel_time <= curtime)
272 {
3aec6cf0
MS		 273 int cancel_after; /* job-cancel-after value */
274
275 attr = ippFindAttribute(job->attrs, "job-cancel-after", IPP_TAG_INTEGER);
276 cancel_after = attr ? ippGetInteger(attr, 0) : MaxJobTime;
e3dfbe13 277
581dae2d 278 if (job->completed)
e3dfbe13 279 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_FORCE, "Marking stuck job as completed after %d seconds.", cancel_after);
581dae2d 280 else
e3dfbe13 281 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_DEFAULT, "Canceling stuck job after %d seconds.", cancel_after);
dcb445bc
MS		 282 continue;
283 }
284
ef416fc2 285 /*
286 * Start held jobs if they are ready...
287 */
288
bd7854cb 289 if (job->state_value == IPP_JOB_HELD &&
ef416fc2 290 job->hold_until &&
238c3832 291 job->hold_until < curtime)
bd7854cb 292 {
09a101d6 293 if (job->pending_timeout)
91c84a35 294 {
dfd5680b
MS		 295 /*
296 * This job is pending; check that we don't have an active Send-Document
297 * operation in progress on any of the client connections, then timeout
298 * the job so we can start printing...
299 */
300
301 cupsd_client_t *con; /* Current client connection */
302
dfd5680b
MS		 303 for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
304 con;
305 con = (cupsd_client_t *)cupsArrayNext(Clients))
306 if (con->request &&
307 con->request->request.op.operation_id == IPP_SEND_DOCUMENT)
308 break;
309
310 if (con)
311 continue;
312
91c84a35
MS		 313 if (cupsdTimeoutJob(job))
314 continue;
315 }
09a101d6 316
b9faaae1
MS		 317 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
318 "Job submission timed out.");
bd7854cb 319 }
ef416fc2 320
e07d4801
MS		 321 /*
322 * Continue jobs that are waiting on the FilterLimit...
323 */
324
325 if (job->pending_cost > 0 &&
326 ((FilterLevel + job->pending_cost) < FilterLimit || FilterLevel == 0))
327 cupsdContinueJob(job);
328
ef416fc2 329 /*
330 * Start pending jobs if the destination is available...
331 */
332
88f9aafc 333 if (job->state_value == IPP_JOB_PENDING && !NeedReload &&
581dae2d 334 !Sleeping && !DoingShutdown && !job->printer)
ef416fc2 335 {
336 printer = cupsdFindDest(job->dest);
337 pclass = NULL;
338
a2326b5b 339 while (printer && (printer->type & CUPS_PRINTER_CLASS))
ef416fc2 340 {
341 /*
342 * If the class is remote, just pass it to the remote server...
343 */
344
345 pclass = printer;
346
c0e1af83 347 if (pclass->state == IPP_PRINTER_STOPPED)
b86bc4cf 348 printer = NULL;
c0e1af83 349 else if (pclass->type & CUPS_PRINTER_REMOTE)
350 break;
351 else
352 printer = cupsdFindAvailablePrinter(printer->name);
ef416fc2 353 }
354
355 if (!printer && !pclass)
356 {
357 /*
358 * Whoa, the printer and/or class for this destination went away;
359 * cancel the job...
360 */
361
b9faaae1
MS		 362 cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_PURGE,
363 "Job aborted because the destination printer/class "
364 "has gone away.");
ef416fc2 365 }
61cf44e2 366 else if (printer && !printer->holding_new_jobs)
ef416fc2 367 {
368 /*
369 * See if the printer is available or remote and not printing a job;
370 * if so, start the job...
371 */
372
373 if (pclass)
374 {
375 /*
376 * Add/update a job-actual-printer-uri attribute for this job
377 * so that we know which printer actually printed the job...
378 */
379
ef416fc2 380 if ((attr = ippFindAttribute(job->attrs, "job-actual-printer-uri",
381 IPP_TAG_URI)) != NULL)
382 cupsdSetString(&attr->values[0].string.text, printer->uri);
383 else
384 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_URI,
385 "job-actual-printer-uri", NULL, printer->uri);
3dfe78b3
MS		 386
387 job->dirty = 1;
388 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
ef416fc2 389 }
390
a29fd7dd 391 if (!printer->job && printer->state == IPP_PRINTER_IDLE)
bc44d920 392 {
bc44d920 393 /*
394 * Start the job...
395 */
396
e1d6a774 397 start_job(job, printer);
bc44d920 398 }
ef416fc2 399 }
400 }
401 }
402}
403
404
405/*
406 * 'cupsdCleanJobs()' - Clean out old jobs.
407 */
408
409void
410cupsdCleanJobs(void)
411{
412 cupsd_job_t *job; /* Current job */
82cc1f9a
MS		 413 time_t curtime; /* Current time */
414
ef416fc2 415
82cc1f9a
MS		 416 cupsdLogMessage(CUPSD_LOG_DEBUG2,
417 "cupsdCleanJobs: MaxJobs=%d, JobHistory=%d, JobFiles=%d",
418 MaxJobs, JobHistory, JobFiles);
ef416fc2 419
82cc1f9a 420 if (MaxJobs <= 0 && JobHistory == INT_MAX && JobFiles == INT_MAX)
ef416fc2 421 return;
422
82cc1f9a
MS		 423 curtime = time(NULL);
424 JobHistoryUpdate = 0;
425
ef416fc2 426 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
82cc1f9a 427 job;
ef416fc2 428 job = (cupsd_job_t *)cupsArrayNext(Jobs))
82cc1f9a 429 {
b9faaae1 430 if (job->state_value >= IPP_JOB_CANCELED && !job->printer)
82cc1f9a
MS		 431 {
432 /*
433 * Expire old jobs (or job files)...
434 */
435
436 if ((MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs) ||
437 (job->history_time && job->history_time <= curtime))
438 {
439 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Removing from history.");
440 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
441 }
442 else if (job->file_time && job->file_time <= curtime)
443 {
444 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Removing document files.");
445 remove_job_files(job);
446
447 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
448 JobHistoryUpdate = job->history_time;
449 }
450 else
451 {
452 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
453 JobHistoryUpdate = job->history_time;
454
455 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
456 JobHistoryUpdate = job->file_time;
457 }
458 }
459 }
460
461 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCleanJobs: JobHistoryUpdate=%ld",
462 (long)JobHistoryUpdate);
ef416fc2 463}
464
465
3dfe78b3 466/*
b9faaae1 467 * 'cupsdContinueJob()' - Continue printing with the next file in a job.
3dfe78b3
MS		 468 */
469
470void
b9faaae1 471cupsdContinueJob(cupsd_job_t *job) /* I - Job */
3dfe78b3 472{
b9faaae1
MS		 473 int i; /* Looping var */
474 int slot; /* Pipe slot */
e07d4801 475 cups_array_t *filters = NULL,/* Filters for job */
b9faaae1
MS		 476 *prefilters; /* Filters with prefilters */
477 mime_filter_t *filter, /* Current filter */
478 *prefilter, /* Prefilter */
479 port_monitor; /* Port monitor filter */
480 char scheme[255]; /* Device URI scheme */
481 ipp_attribute_t *attr; /* Current attribute */
482 const char *ptr, /* Pointer into value */
483 *abort_message; /* Abort message */
f11a948a 484 ipp_jstate_t abort_state = IPP_JOB_STOPPED;
e07d4801 485 /* New job state on abort */
b9faaae1
MS		 486 struct stat backinfo; /* Backend file information */
487 int backroot; /* Run backend as root? */
488 int pid; /* Process ID of new filter process */
489 int banner_page; /* 1 if banner page, 0 otherwise */
e07d4801
MS		 490 int filterfds[2][2] = { { -1, -1 }, { -1, -1 } };
491 /* Pipes used between filters */
b9faaae1 492 int envc; /* Number of environment variables */
771bd8cb 493 struct stat fileinfo; /* Job file information */
59ac438c 494 int argc; /* Number of arguments */
e07d4801 495 char **argv = NULL, /* Filter command-line arguments */
b9faaae1
MS		 496 filename[1024], /* Job filename */
497 command[1024], /* Full path to command */
498 jobid[255], /* Job ID string */
499 title[IPP_MAX_NAME],
500 /* Job title string */
501 copies[255], /* # copies string */
502 *options, /* Options string */
eac3a0a0 503 *envp[MAX_ENV + 21],
b9faaae1
MS		 504 /* Environment variables */
505 charset[255], /* CHARSET env variable */
506 class_name[255],/* CLASS env variable */
507 classification[1024],
508 /* CLASSIFICATION env variable */
509 content_type[1024],
510 /* CONTENT_TYPE env variable */
511 device_uri[1024],
512 /* DEVICE_URI env variable */
6961465f 513 final_content_type[1024] = "",
b9faaae1
MS		 514 /* FINAL_CONTENT_TYPE env variable */
515 lang[255], /* LANG env variable */
516#ifdef __APPLE__
517 apple_language[255],
518 /* APPLE_LANGUAGE env variable */
519#endif /* __APPLE__ */
22c9029b
MS		 520 auth_info_required[255],
521 /* AUTH_INFO_REQUIRED env variable */
b9faaae1
MS		 522 ppd[1024], /* PPD env variable */
523 printer_info[255],
524 /* PRINTER_INFO env variable */
525 printer_location[255],
526 /* PRINTER_LOCATION env variable */
527 printer_name[255],
528 /* PRINTER env variable */
eac3a0a0
MS		 529 *printer_state_reasons = NULL,
530 /* PRINTER_STATE_REASONS env var */
b9faaae1
MS		 531 rip_max_cache[255];
532 /* RIP_MAX_CACHE env variable */
533
534
535 cupsdLogMessage(CUPSD_LOG_DEBUG2,
536 "cupsdContinueJob(job=%p(%d)): current_file=%d, num_files=%d",
537 job, job->id, job->current_file, job->num_files);
3dfe78b3 538
3dfe78b3 539 /*
b9faaae1
MS		 540 * Figure out what filters are required to convert from
541 * the source to the destination type...
3dfe78b3
MS		 542 */
543
b9faaae1 544 FilterLevel -= job->cost;
3dfe78b3 545
e07d4801
MS		 546 job->cost = 0;
547 job->pending_cost = 0;
548
549 memset(job->filters, 0, sizeof(job->filters));
550
b9faaae1 551 if (job->printer->raw)
3dfe78b3 552 {
b9faaae1
MS		 553 /*
554 * Remote jobs and raw queues go directly to the printer without
555 * filtering...
556 */
3dfe78b3 557
b9faaae1 558 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Sending job to queue tagged as raw...");
b9faaae1
MS		 559 }
560 else
561 {
562 /*
563 * Local jobs get filtered...
564 */
3dfe78b3 565
8e67b75b
MS		 566 mime_type_t *dst = job->printer->filetype;
567 /* Destination file type */
568
771bd8cb
MS		 569 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
570 job->id, job->current_file + 1);
571 if (stat(filename, &fileinfo))
572 fileinfo.st_size = 0;
573
8e67b75b
MS		 574 if (job->retry_as_raster)
575 {
576 /*
577 * Need to figure out whether the printer supports image/pwg-raster or
578 * image/urf, and use the corresponding type...
579 */
580
581 char type[MIME_MAX_TYPE]; /* MIME media type for printer */
582
583 snprintf(type, sizeof(type), "%s/image/urf", job->printer->name);
584 if ((dst = mimeType(MimeDatabase, "printer", type)) == NULL)
585 {
586 snprintf(type, sizeof(type), "%s/image/pwg-raster", job->printer->name);
587 dst = mimeType(MimeDatabase, "printer", type);
588 }
589
590 if (dst)
591 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Retrying job as \"%s\".", strchr(dst->type, '/') + 1);
592 else
593 cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to retry job using a supported raster format.");
594 }
595
596 filters = mimeFilter2(MimeDatabase, job->filetypes[job->current_file], (size_t)fileinfo.st_size, dst, &(job->cost));
ef416fc2 597
b9faaae1
MS		 598 if (!filters)
599 {
600 cupsdLogJob(job, CUPSD_LOG_ERROR,
12f89d24 601 "Unable to convert file %d to printable format.",
b9faaae1 602 job->current_file);
ef416fc2 603
e07d4801 604 abort_message = "Aborting job because it cannot be printed.";
f11a948a
MS		 605 abort_state = IPP_JOB_ABORTED;
606
12f89d24 607 ippSetString(job->attrs, &job->reasons, 0, "document-unprintable-error");
e07d4801 608 goto abort_job;
b9faaae1 609 }
ef416fc2 610
6961465f
MS		 611 /*
612 * Figure out the final content type...
613 */
614
615 cupsdLogJob(job, CUPSD_LOG_DEBUG, "%d filters for job:",
616 cupsArrayCount(filters));
617 for (filter = (mime_filter_t *)cupsArrayFirst(filters);
618 filter;
619 filter = (mime_filter_t *)cupsArrayNext(filters))
620 cupsdLogJob(job, CUPSD_LOG_DEBUG, "%s (%s/%s to %s/%s, cost %d)",
621 filter->filter,
622 filter->src ? filter->src->super : "???",
623 filter->src ? filter->src->type : "???",
624 filter->dst ? filter->dst->super : "???",
625 filter->dst ? filter->dst->type : "???",
626 filter->cost);
627
628 if (!job->printer->remote)
629 {
630 for (filter = (mime_filter_t *)cupsArrayLast(filters);
631 filter && filter->dst;
632 filter = (mime_filter_t *)cupsArrayPrev(filters))
633 if (strcmp(filter->dst->super, "printer") ||
634 strcmp(filter->dst->type, job->printer->name))
635 break;
636
637 if (filter && filter->dst)
638 {
639 if ((ptr = strchr(filter->dst->type, '/')) != NULL)
640 snprintf(final_content_type, sizeof(final_content_type),
641 "FINAL_CONTENT_TYPE=%s", ptr + 1);
642 else
643 snprintf(final_content_type, sizeof(final_content_type),
644 "FINAL_CONTENT_TYPE=%s/%s", filter->dst->super,
645 filter->dst->type);
646 }
54f63cdf
MS		 647 else
648 snprintf(final_content_type, sizeof(final_content_type),
649 "FINAL_CONTENT_TYPE=printer/%s", job->printer->name);
6961465f
MS		 650 }
651
ef416fc2 652 /*
b9faaae1 653 * Remove NULL ("-") filters...
ef416fc2 654 */
655
b9faaae1
MS		 656 for (filter = (mime_filter_t *)cupsArrayFirst(filters);
657 filter;
658 filter = (mime_filter_t *)cupsArrayNext(filters))
659 if (!strcmp(filter->filter, "-"))
660 cupsArrayRemove(filters, filter);
ef416fc2 661
b9faaae1
MS		 662 if (cupsArrayCount(filters) == 0)
663 {
664 cupsArrayDelete(filters);
665 filters = NULL;
666 }
ef416fc2 667
b9faaae1
MS		 668 /*
669 * If this printer has any pre-filters, insert the required pre-filter
670 * in the filters array...
671 */
ef416fc2 672
b9faaae1
MS		 673 if (job->printer->prefiltertype && filters)
674 {
675 prefilters = cupsArrayNew(NULL, NULL);
676
677 for (filter = (mime_filter_t *)cupsArrayFirst(filters);
678 filter;
679 filter = (mime_filter_t *)cupsArrayNext(filters))
680 {
681 if ((prefilter = mimeFilterLookup(MimeDatabase, filter->src,
682 job->printer->prefiltertype)))
683 {
684 cupsArrayAdd(prefilters, prefilter);
685 job->cost += prefilter->cost;
686 }
ef416fc2 687
b9faaae1
MS		 688 cupsArrayAdd(prefilters, filter);
689 }
e00b005a 690
b9faaae1
MS		 691 cupsArrayDelete(filters);
692 filters = prefilters;
693 }
694 }
bc44d920 695
c168a833 696 /*
b9faaae1
MS		 697 * Set a minimum cost of 100 for all jobs so that FilterLimit
698 * works with raw queues and other low-cost paths.
c168a833
MS		 699 */
700
b9faaae1
MS		 701 if (job->cost < 100)
702 job->cost = 100;
c168a833 703
745129be 704 /*
b9faaae1 705 * See if the filter cost is too high...
745129be
MS		 706 */
707
b9faaae1
MS		 708 if ((FilterLevel + job->cost) > FilterLimit && FilterLevel > 0 &&
709 FilterLimit > 0)
ef416fc2 710 {
711 /*
b9faaae1 712 * Don't print this job quite yet...
ef416fc2 713 */
714
b9faaae1 715 cupsArrayDelete(filters);
a74454a7 716
b9faaae1
MS		 717 cupsdLogJob(job, CUPSD_LOG_INFO,
718 "Holding because filter limit has been reached.");
719 cupsdLogJob(job, CUPSD_LOG_DEBUG2,
720 "cupsdContinueJob: file=%d, cost=%d, level=%d, limit=%d",
721 job->current_file, job->cost, FilterLevel,
722 FilterLimit);
e07d4801
MS		 723
724 job->pending_cost = job->cost;
725 job->cost = 0;
b9faaae1
MS		 726 return;
727 }
a74454a7 728
b9faaae1 729 FilterLevel += job->cost;
a74454a7 730
b9faaae1
MS		 731 /*
732 * Add decompression/raw filter as needed...
733 */
a74454a7 734
462b6e74
MS		 735 if (job->compressions[job->current_file] &&
736 (!job->printer->remote || job->num_files == 1))
b9faaae1 737 {
a74454a7 738 /*
b9faaae1 739 * Add gziptoany filter to the front of the list...
a74454a7 740 */
741
b9faaae1
MS		 742 if (!filters)
743 filters = cupsArrayNew(NULL, NULL);
ef416fc2 744
b9faaae1
MS		 745 if (!cupsArrayInsert(filters, &gziptoany_filter))
746 {
747 cupsdLogJob(job, CUPSD_LOG_DEBUG,
748 "Unable to add decompression filter - %s", strerror(errno));
ed486911 749
b9faaae1 750 cupsArrayDelete(filters);
ed486911 751
e07d4801 752 abort_message = "Stopping job because the scheduler ran out of memory.";
ed486911 753
e07d4801 754 goto abort_job;
b9faaae1
MS		 755 }
756 }
ef416fc2 757
b9faaae1
MS		 758 /*
759 * Add port monitor, if any...
760 */
ef416fc2 761
b9faaae1
MS		 762 if (job->printer->port_monitor)
763 {
764 /*
765 * Add port monitor to the end of the list...
766 */
ef416fc2 767
b9faaae1
MS		 768 if (!filters)
769 filters = cupsArrayNew(NULL, NULL);
ef416fc2 770
b9faaae1
MS		 771 port_monitor.src = NULL;
772 port_monitor.dst = NULL;
773 port_monitor.cost = 0;
ef416fc2 774
b9faaae1
MS		 775 snprintf(port_monitor.filter, sizeof(port_monitor.filter),
776 "%s/monitor/%s", ServerBin, job->printer->port_monitor);
ef416fc2 777
b9faaae1
MS		 778 if (!cupsArrayAdd(filters, &port_monitor))
779 {
780 cupsdLogJob(job, CUPSD_LOG_DEBUG,
781 "Unable to add port monitor - %s", strerror(errno));
ef416fc2 782
e07d4801 783 abort_message = "Stopping job because the scheduler ran out of memory.";
07725fee 784
e07d4801 785 goto abort_job;
b9faaae1
MS		 786 }
787 }
ef416fc2 788
b9faaae1
MS		 789 /*
790 * Make sure we don't go over the "MAX_FILTERS" limit...
791 */
ef416fc2 792
b9faaae1
MS		 793 if (cupsArrayCount(filters) > MAX_FILTERS)
794 {
795 cupsdLogJob(job, CUPSD_LOG_DEBUG,
12f89d24 796 "Too many filters (%d > %d), unable to print.",
b9faaae1 797 cupsArrayCount(filters), MAX_FILTERS);
ef416fc2 798
e07d4801 799 abort_message = "Aborting job because it needs too many filters to print.";
f11a948a
MS		 800 abort_state = IPP_JOB_ABORTED;
801
12f89d24
MS		 802 ippSetString(job->attrs, &job->reasons, 0, "document-unprintable-error");
803
e07d4801 804 goto abort_job;
b9faaae1 805 }
07725fee 806
b9faaae1
MS		 807 /*
808 * Determine if we are printing a banner page or not...
809 */
07725fee 810
b9faaae1
MS		 811 if (job->job_sheets == NULL)
812 {
813 cupsdLogJob(job, CUPSD_LOG_DEBUG, "No job-sheets attribute.");
814 if ((job->job_sheets =
815 ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_ZERO)) != NULL)
816 cupsdLogJob(job, CUPSD_LOG_DEBUG,
12f89d24 817 "... but someone added one without setting job_sheets.");
b9faaae1
MS		 818 }
819 else if (job->job_sheets->num_values == 1)
820 cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-sheets=%s",
821 job->job_sheets->values[0].string.text);
822 else
823 cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-sheets=%s,%s",
824 job->job_sheets->values[0].string.text,
825 job->job_sheets->values[1].string.text);
07725fee 826
a2326b5b 827 if (job->printer->type & CUPS_PRINTER_REMOTE)
b9faaae1
MS		 828 banner_page = 0;
829 else if (job->job_sheets == NULL)
830 banner_page = 0;
88f9aafc 831 else if (_cups_strcasecmp(job->job_sheets->values[0].string.text, "none") != 0 &&
b9faaae1
MS		 832 job->current_file == 0)
833 banner_page = 1;
834 else if (job->job_sheets->num_values > 1 &&
88f9aafc 835 _cups_strcasecmp(job->job_sheets->values[1].string.text, "none") != 0 &&
b9faaae1
MS		 836 job->current_file == (job->num_files - 1))
837 banner_page = 1;
838 else
839 banner_page = 0;
07725fee 840
b9faaae1
MS		 841 if ((options = get_options(job, banner_page, copies, sizeof(copies), title,
842 sizeof(title))) == NULL)
843 {
e07d4801 844 abort_message = "Stopping job because the scheduler ran out of memory.";
ef416fc2 845
e07d4801 846 goto abort_job;
b9faaae1 847 }
ef416fc2 848
b9faaae1
MS		 849 /*
850 * Build the command-line arguments for the filters. Each filter
851 * has 6 or 7 arguments:
852 *
853 * argv[0] = printer
854 * argv[1] = job ID
855 * argv[2] = username
856 * argv[3] = title
857 * argv[4] = # copies
858 * argv[5] = options
859 * argv[6] = filename (optional; normally stdin)
860 *
861 * This allows legacy printer drivers that use the old System V
862 * printing interface to be used by CUPS.
863 *
864 * For remote jobs, we send all of the files in the argument list.
865 */
07725fee 866
b9faaae1 867 if (job->printer->remote)
59ac438c 868 argc = 6 + job->num_files;
b9faaae1 869 else
59ac438c 870 argc = 7;
07725fee 871
7e86f2f6 872 if ((argv = calloc((size_t)argc + 1, sizeof(char *))) == NULL)
b9faaae1
MS		 873 {
874 cupsdLogMessage(CUPSD_LOG_DEBUG, "Unable to allocate argument array - %s",
875 strerror(errno));
07725fee 876
e07d4801
MS		 877 abort_message = "Stopping job because the scheduler ran out of memory.";
878
879 goto abort_job;
b9faaae1 880 }
ef416fc2 881
b9faaae1 882 sprintf(jobid, "%d", job->id);
ef416fc2 883
b9faaae1
MS		 884 argv[0] = job->printer->name;
885 argv[1] = jobid;
886 argv[2] = job->username;
887 argv[3] = title;
888 argv[4] = copies;
889 argv[5] = options;
ef416fc2 890
b9faaae1 891 if (job->printer->remote && job->num_files > 1)
ef416fc2 892 {
b9faaae1
MS		 893 for (i = 0; i < job->num_files; i ++)
894 {
895 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
896 job->id, i + 1);
897 argv[6 + i] = strdup(filename);
898 }
ef416fc2 899 }
900 else
901 {
b9faaae1
MS		 902 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
903 job->id, job->current_file + 1);
462b6e74 904 argv[6] = strdup(filename);
ef416fc2 905 }
ef416fc2 906
b9faaae1
MS		 907 for (i = 0; argv[i]; i ++)
908 cupsdLogJob(job, CUPSD_LOG_DEBUG, "argv[%d]=\"%s\"", i, argv[i]);
ef416fc2 909
b9faaae1
MS		 910 /*
911 * Create environment variable strings for the filters...
912 */
bd7854cb 913
b9faaae1
MS		 914 attr = ippFindAttribute(job->attrs, "attributes-natural-language",
915 IPP_TAG_LANGUAGE);
ef416fc2 916
b9faaae1 917#ifdef __APPLE__
5a9febac 918 strlcpy(apple_language, "APPLE_LANGUAGE=", sizeof(apple_language));
b9faaae1
MS		 919 _cupsAppleLanguage(attr->values[0].string.text,
920 apple_language + 15, sizeof(apple_language) - 15);
921#endif /* __APPLE__ */
ef416fc2 922
b9faaae1 923 switch (strlen(attr->values[0].string.text))
ef416fc2 924 {
b9faaae1
MS		 925 default :
926 /*
927 * This is an unknown or badly formatted language code; use
928 * the POSIX locale...
929 */
ef416fc2 930
5a9febac 931 strlcpy(lang, "LANG=C", sizeof(lang));
b9faaae1 932 break;
ef416fc2 933
b9faaae1
MS		 934 case 2 :
935 /*
936 * Just the language code (ll)...
937 */
ef416fc2 938
1340db2d 939 snprintf(lang, sizeof(lang), "LANG=%s.UTF-8",
b9faaae1
MS		 940 attr->values[0].string.text);
941 break;
ef416fc2 942
b9faaae1
MS		 943 case 5 :
944 /*
945 * Language and country code (ll-cc)...
946 */
ef416fc2 947
1340db2d 948 snprintf(lang, sizeof(lang), "LANG=%c%c_%c%c.UTF-8",
b9faaae1
MS		 949 attr->values[0].string.text[0],
950 attr->values[0].string.text[1],
951 toupper(attr->values[0].string.text[3] & 255),
952 toupper(attr->values[0].string.text[4] & 255));
953 break;
954 }
ef416fc2 955
b9faaae1
MS		 956 if ((attr = ippFindAttribute(job->attrs, "document-format",
957 IPP_TAG_MIMETYPE)) != NULL &&
958 (ptr = strstr(attr->values[0].string.text, "charset=")) != NULL)
959 snprintf(charset, sizeof(charset), "CHARSET=%s", ptr + 8);
960 else
961 strlcpy(charset, "CHARSET=utf-8", sizeof(charset));
ef416fc2 962
b9faaae1
MS		 963 snprintf(content_type, sizeof(content_type), "CONTENT_TYPE=%s/%s",
964 job->filetypes[job->current_file]->super,
965 job->filetypes[job->current_file]->type);
966 snprintf(device_uri, sizeof(device_uri), "DEVICE_URI=%s",
967 job->printer->device_uri);
968 snprintf(ppd, sizeof(ppd), "PPD=%s/ppd/%s.ppd", ServerRoot,
969 job->printer->name);
970 snprintf(printer_info, sizeof(printer_name), "PRINTER_INFO=%s",
971 job->printer->info ? job->printer->info : "");
972 snprintf(printer_location, sizeof(printer_name), "PRINTER_LOCATION=%s",
973 job->printer->location ? job->printer->location : "");
974 snprintf(printer_name, sizeof(printer_name), "PRINTER=%s", job->printer->name);
eac3a0a0
MS		 975 if (job->printer->num_reasons > 0)
976 {
977 char *psrptr; /* Pointer into PRINTER_STATE_REASONS */
978 size_t psrlen; /* Size of PRINTER_STATE_REASONS */
979
980 for (psrlen = 22, i = 0; i < job->printer->num_reasons; i ++)
981 psrlen += strlen(job->printer->reasons[i]) + 1;
982
983 if ((printer_state_reasons = malloc(psrlen)) != NULL)
984 {
985 /*
986 * All of these strcpy's are safe because we allocated the psr string...
987 */
988
5a9febac 989 strlcpy(printer_state_reasons, "PRINTER_STATE_REASONS=", psrlen);
eac3a0a0
MS		 990 for (psrptr = printer_state_reasons + 22, i = 0;
991 i < job->printer->num_reasons;
992 i ++)
993 {
994 if (i)
995 *psrptr++ = ',';
7e86f2f6 996 strlcpy(psrptr, job->printer->reasons[i], psrlen - (size_t)(psrptr - printer_state_reasons));
eac3a0a0
MS		 997 psrptr += strlen(psrptr);
998 }
999 }
1000 }
b9faaae1 1001 snprintf(rip_max_cache, sizeof(rip_max_cache), "RIP_MAX_CACHE=%s", RIPCache);
ef416fc2 1002
22c9029b
MS		 1003 if (job->printer->num_auth_info_required == 1)
1004 snprintf(auth_info_required, sizeof(auth_info_required),
1005 "AUTH_INFO_REQUIRED=%s",
1006 job->printer->auth_info_required[0]);
1007 else if (job->printer->num_auth_info_required == 2)
1008 snprintf(auth_info_required, sizeof(auth_info_required),
1009 "AUTH_INFO_REQUIRED=%s,%s",
1010 job->printer->auth_info_required[0],
1011 job->printer->auth_info_required[1]);
1012 else if (job->printer->num_auth_info_required == 3)
1013 snprintf(auth_info_required, sizeof(auth_info_required),
1014 "AUTH_INFO_REQUIRED=%s,%s,%s",
1015 job->printer->auth_info_required[0],
1016 job->printer->auth_info_required[1],
1017 job->printer->auth_info_required[2]);
1018 else if (job->printer->num_auth_info_required == 4)
1019 snprintf(auth_info_required, sizeof(auth_info_required),
1020 "AUTH_INFO_REQUIRED=%s,%s,%s,%s",
1021 job->printer->auth_info_required[0],
1022 job->printer->auth_info_required[1],
1023 job->printer->auth_info_required[2],
1024 job->printer->auth_info_required[3]);
1025 else
1026 strlcpy(auth_info_required, "AUTH_INFO_REQUIRED=none",
1027 sizeof(auth_info_required));
1028
b9faaae1 1029 envc = cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
ef416fc2 1030
b9faaae1
MS		 1031 envp[envc ++] = charset;
1032 envp[envc ++] = lang;
1033#ifdef __APPLE__
1034 envp[envc ++] = apple_language;
1035#endif /* __APPLE__ */
1036 envp[envc ++] = ppd;
1037 envp[envc ++] = rip_max_cache;
1038 envp[envc ++] = content_type;
1039 envp[envc ++] = device_uri;
1040 envp[envc ++] = printer_info;
1041 envp[envc ++] = printer_location;
1042 envp[envc ++] = printer_name;
eac3a0a0
MS		 1043 envp[envc ++] = printer_state_reasons ? printer_state_reasons :
1044 "PRINTER_STATE_REASONS=none";
b9faaae1
MS		 1045 envp[envc ++] = banner_page ? "CUPS_FILETYPE=job-sheet" :
1046 "CUPS_FILETYPE=document";
ef416fc2 1047
6961465f
MS		 1048 if (final_content_type[0])
1049 envp[envc ++] = final_content_type;
ef416fc2 1050
b9faaae1
MS		 1051 if (Classification && !banner_page)
1052 {
1053 if ((attr = ippFindAttribute(job->attrs, "job-sheets",
1054 IPP_TAG_NAME)) == NULL)
1055 snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
1056 Classification);
1057 else if (attr->num_values > 1 &&
1058 strcmp(attr->values[1].string.text, "none") != 0)
1059 snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
1060 attr->values[1].string.text);
1061 else
1062 snprintf(classification, sizeof(classification), "CLASSIFICATION=%s",
1063 attr->values[0].string.text);
ef416fc2 1064
b9faaae1
MS		 1065 envp[envc ++] = classification;
1066 }
ef416fc2 1067
a2326b5b 1068 if (job->dtype & CUPS_PRINTER_CLASS)
b9faaae1
MS		 1069 {
1070 snprintf(class_name, sizeof(class_name), "CLASS=%s", job->dest);
1071 envp[envc ++] = class_name;
1072 }
ef416fc2 1073
22c9029b 1074 envp[envc ++] = auth_info_required;
88f9aafc
MS		 1075
1076 for (i = 0;
1077 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
1078 i ++)
1079 if (job->auth_env[i])
1080 envp[envc ++] = job->auth_env[i];
1081 else
1082 break;
1083
07ed0e9a
MS		 1084 if (job->auth_uid)
1085 envp[envc ++] = job->auth_uid;
ef416fc2 1086
b9faaae1 1087 envp[envc] = NULL;
ef416fc2 1088
b9faaae1
MS		 1089 for (i = 0; i < envc; i ++)
1090 if (!strncmp(envp[i], "AUTH_", 5))
1091 cupsdLogJob(job, CUPSD_LOG_DEBUG, "envp[%d]=\"AUTH_%c****\"", i,
1092 envp[i][5]);
1093 else if (strncmp(envp[i], "DEVICE_URI=", 11))
1094 cupsdLogJob(job, CUPSD_LOG_DEBUG, "envp[%d]=\"%s\"", i, envp[i]);
1095 else
1096 cupsdLogJob(job, CUPSD_LOG_DEBUG, "envp[%d]=\"DEVICE_URI=%s\"", i,
1097 job->printer->sanitized_device_uri);
ef416fc2 1098
b9faaae1
MS		 1099 if (job->printer->remote)
1100 job->current_file = job->num_files;
1101 else
1102 job->current_file ++;
ef416fc2 1103
b9faaae1
MS		 1104 /*
1105 * Now create processes for all of the filters...
1106 */
ef416fc2 1107
b9faaae1
MS		 1108 for (i = 0, slot = 0, filter = (mime_filter_t *)cupsArrayFirst(filters);
1109 filter;
1110 i ++, filter = (mime_filter_t *)cupsArrayNext(filters))
1111 {
1112 if (filter->filter[0] != '/')
1113 snprintf(command, sizeof(command), "%s/filter/%s", ServerBin,
1114 filter->filter);
1115 else
1116 strlcpy(command, filter->filter, sizeof(command));
ef416fc2 1117
b9faaae1
MS		 1118 if (i < (cupsArrayCount(filters) - 1))
1119 {
1120 if (cupsdOpenPipe(filterfds[slot]))
1121 {
1122 abort_message = "Stopping job because the scheduler could not create "
1123 "the filter pipes.";
ef416fc2 1124
b9faaae1
MS		 1125 goto abort_job;
1126 }
1127 }
1128 else
1129 {
82f97232
MS		 1130 if (job->current_file == 1 ||
1131 (job->printer->pc && job->printer->pc->single_file))
b9faaae1
MS		 1132 {
1133 if (strncmp(job->printer->device_uri, "file:", 5) != 0)
1134 {
1135 if (cupsdOpenPipe(job->print_pipes))
1136 {
1137 abort_message = "Stopping job because the scheduler could not "
1138 "create the backend pipes.";
ef416fc2 1139
b9faaae1
MS		 1140 goto abort_job;
1141 }
1142 }
1143 else
1144 {
1145 job->print_pipes[0] = -1;
1146 if (!strcmp(job->printer->device_uri, "file:/dev/null") ||
1147 !strcmp(job->printer->device_uri, "file:///dev/null"))
1148 job->print_pipes[1] = -1;
1149 else
1150 {
1151 if (!strncmp(job->printer->device_uri, "file:/dev/", 10))
1152 job->print_pipes[1] = open(job->printer->device_uri + 5,
1153 O_WRONLY | O_EXCL);
1154 else if (!strncmp(job->printer->device_uri, "file:///dev/", 12))
1155 job->print_pipes[1] = open(job->printer->device_uri + 7,
1156 O_WRONLY | O_EXCL);
1157 else if (!strncmp(job->printer->device_uri, "file:///", 8))
1158 job->print_pipes[1] = open(job->printer->device_uri + 7,
1159 O_WRONLY | O_CREAT | O_TRUNC, 0600);
1160 else
1161 job->print_pipes[1] = open(job->printer->device_uri + 5,
1162 O_WRONLY | O_CREAT | O_TRUNC, 0600);
ef416fc2 1163
b9faaae1
MS		 1164 if (job->print_pipes[1] < 0)
1165 {
1166 abort_message = "Stopping job because the scheduler could not "
1167 "open the output file.";
bd7854cb 1168
b9faaae1
MS		 1169 goto abort_job;
1170 }
ef416fc2 1171
b9faaae1
MS		 1172 fcntl(job->print_pipes[1], F_SETFD,
1173 fcntl(job->print_pipes[1], F_GETFD) | FD_CLOEXEC);
1174 }
1175 }
1176 }
ef416fc2 1177
b9faaae1
MS		 1178 filterfds[slot][0] = job->print_pipes[0];
1179 filterfds[slot][1] = job->print_pipes[1];
1180 }
ef416fc2 1181
b9faaae1
MS		 1182 pid = cupsdStartProcess(command, argv, envp, filterfds[!slot][0],
1183 filterfds[slot][1], job->status_pipes[1],
1184 job->back_pipes[0], job->side_pipes[0], 0,
38e73f87 1185 job->profile, job, job->filters + i);
ef416fc2 1186
b9faaae1 1187 cupsdClosePipe(filterfds[!slot]);
ef416fc2 1188
b9faaae1
MS		 1189 if (pid == 0)
1190 {
1191 cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to start filter \"%s\" - %s.",
1192 filter->filter, strerror(errno));
3dfe78b3 1193
f11a948a 1194 abort_message = "Stopping job because the scheduler could not execute a "
b9faaae1 1195 "filter.";
ef416fc2 1196
b9faaae1
MS		 1197 goto abort_job;
1198 }
ef416fc2 1199
b9faaae1
MS		 1200 cupsdLogJob(job, CUPSD_LOG_INFO, "Started filter %s (PID %d)", command,
1201 pid);
bd7854cb 1202
59ac438c
MS		 1203 if (argv[6])
1204 {
1205 free(argv[6]);
1206 argv[6] = NULL;
1207 }
1208
1209 slot = !slot;
bd7854cb 1210 }
1211
b9faaae1
MS		 1212 cupsArrayDelete(filters);
1213 filters = NULL;
ef416fc2 1214
1215 /*
b9faaae1 1216 * Finally, pipe the final output into a backend process if needed...
ef416fc2 1217 */
1218
b9faaae1 1219 if (strncmp(job->printer->device_uri, "file:", 5) != 0)
bd7854cb 1220 {
82f97232
MS		 1221 if (job->current_file == 1 || job->printer->remote ||
1222 (job->printer->pc && job->printer->pc->single_file))
b9faaae1
MS		 1223 {
1224 sscanf(job->printer->device_uri, "%254[^:]", scheme);
1225 snprintf(command, sizeof(command), "%s/backend/%s", ServerBin, scheme);
ef416fc2 1226
b9faaae1
MS		 1227 /*
1228 * See if the backend needs to run as root...
1229 */
ef416fc2 1230
b9faaae1
MS		 1231 if (RunUser)
1232 backroot = 0;
1233 else if (stat(command, &backinfo))
1234 backroot = 0;
1235 else
0a393e6a 1236 backroot = !(backinfo.st_mode & (S_IWGRP | S_IRWXO));
ef416fc2 1237
b9faaae1 1238 argv[0] = job->printer->sanitized_device_uri;
ef416fc2 1239
b9faaae1
MS		 1240 filterfds[slot][0] = -1;
1241 filterfds[slot][1] = -1;
ef416fc2 1242
b9faaae1
MS		 1243 pid = cupsdStartProcess(command, argv, envp, filterfds[!slot][0],
1244 filterfds[slot][1], job->status_pipes[1],
1245 job->back_pipes[1], job->side_pipes[1],
8fe0183a 1246 backroot, job->bprofile, job, &(job->backend));
ef416fc2 1247
b9faaae1
MS		 1248 if (pid == 0)
1249 {
1250 abort_message = "Stopping job because the sheduler could not execute "
1251 "the backend.";
1252
1253 goto abort_job;
1254 }
1255 else
1256 {
1257 cupsdLogJob(job, CUPSD_LOG_INFO, "Started backend %s (PID %d)",
1258 command, pid);
1259 }
1260 }
ef416fc2 1261
82f97232
MS		 1262 if (job->current_file == job->num_files ||
1263 (job->printer->pc && job->printer->pc->single_file))
1264 cupsdClosePipe(job->print_pipes);
1265
b9faaae1
MS		 1266 if (job->current_file == job->num_files)
1267 {
b9faaae1
MS		 1268 cupsdClosePipe(job->back_pipes);
1269 cupsdClosePipe(job->side_pipes);
ef416fc2 1270
b9faaae1
MS		 1271 close(job->status_pipes[1]);
1272 job->status_pipes[1] = -1;
1273 }
1274 }
1275 else
bd7854cb 1276 {
b9faaae1
MS		 1277 filterfds[slot][0] = -1;
1278 filterfds[slot][1] = -1;
ef416fc2 1279
82f97232
MS		 1280 if (job->current_file == job->num_files ||
1281 (job->printer->pc && job->printer->pc->single_file))
b9faaae1
MS		 1282 cupsdClosePipe(job->print_pipes);
1283
82f97232
MS		 1284 if (job->current_file == job->num_files)
1285 {
b9faaae1
MS		 1286 close(job->status_pipes[1]);
1287 job->status_pipes[1] = -1;
1288 }
bd7854cb 1289 }
ef416fc2 1290
b9faaae1
MS		 1291 cupsdClosePipe(filterfds[slot]);
1292
59ac438c
MS		 1293 for (i = 6; i < argc; i ++)
1294 if (argv[i])
1295 free(argv[i]);
ef416fc2 1296
b9faaae1 1297 free(argv);
462b6e74 1298
eac3a0a0
MS		 1299 if (printer_state_reasons)
1300 free(printer_state_reasons);
ef416fc2 1301
b9faaae1
MS		 1302 cupsdAddSelect(job->status_buffer->fd, (cupsd_selfunc_t)update_job, NULL,
1303 job);
ef416fc2 1304
b9faaae1
MS		 1305 cupsdAddEvent(CUPSD_EVENT_JOB_STATE, job->printer, job, "Job #%d started.",
1306 job->id);
ef416fc2 1307
b9faaae1 1308 return;
ef416fc2 1309
ef416fc2 1310
bd7854cb 1311 /*
b9faaae1
MS		 1312 * If we get here, we need to abort the current job and close out all
1313 * files and pipes...
bd7854cb 1314 */
ef416fc2 1315
b9faaae1 1316 abort_job:
8b450588 1317
e07d4801
MS		 1318 FilterLevel -= job->cost;
1319 job->cost = 0;
1320
b9faaae1
MS		 1321 for (slot = 0; slot < 2; slot ++)
1322 cupsdClosePipe(filterfds[slot]);
1323
e07d4801
MS		 1324 cupsArrayDelete(filters);
1325
1326 if (argv)
1327 {
59ac438c
MS		 1328 for (i = 6; i < argc; i ++)
1329 if (argv[i])
1330 free(argv[i]);
e07d4801
MS		 1331 }
1332
eac3a0a0
MS		 1333 if (printer_state_reasons)
1334 free(printer_state_reasons);
1335
e07d4801
MS		 1336 cupsdClosePipe(job->print_pipes);
1337 cupsdClosePipe(job->back_pipes);
1338 cupsdClosePipe(job->side_pipes);
1339
1340 cupsdRemoveSelect(job->status_pipes[0]);
b9faaae1
MS		 1341 cupsdClosePipe(job->status_pipes);
1342 cupsdStatBufDelete(job->status_buffer);
1343 job->status_buffer = NULL;
1344
e07d4801
MS		 1345 /*
1346 * Update the printer and job state.
1347 */
b9faaae1 1348
e07d4801
MS		 1349 cupsdSetJobState(job, abort_state, CUPSD_JOB_DEFAULT, "%s", abort_message);
1350 cupsdSetPrinterState(job->printer, IPP_PRINTER_IDLE, 0);
1351 update_job_attrs(job, 0);
ef416fc2 1352
178cb736
MS		 1353 if (job->history)
1354 free_job_history(job);
1355
e07d4801 1356 cupsArrayRemove(PrintingJobs, job);
ef416fc2 1357
e07d4801
MS		 1358 /*
1359 * Clear the printer <-> job association...
1360 */
1361
1362 job->printer->job = NULL;
1363 job->printer = NULL;
b9faaae1 1364}
bd7854cb 1365
ef416fc2 1366
b9faaae1
MS		 1367/*
1368 * 'cupsdDeleteJob()' - Free all memory used by a job.
1369 */
ef416fc2 1370
b9faaae1
MS		 1371void
1372cupsdDeleteJob(cupsd_job_t *job, /* I - Job */
1373 cupsd_jobaction_t action)/* I - Action */
1374{
88f9aafc 1375 int i; /* Looping var */
22c9029b
MS		 1376
1377
b9faaae1 1378 if (job->printer)
ef55b745 1379 finalize_job(job, 1);
ef416fc2 1380
b9faaae1 1381 if (action == CUPSD_JOB_PURGE)
82cc1f9a 1382 remove_job_history(job);
ef416fc2 1383
b9faaae1
MS		 1384 cupsdClearString(&job->username);
1385 cupsdClearString(&job->dest);
88f9aafc
MS		 1386 for (i = 0;
1387 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
1388 i ++)
1389 cupsdClearString(job->auth_env + i);
07ed0e9a 1390 cupsdClearString(&job->auth_uid);
09a101d6 1391
82cc1f9a
MS		 1392 if (action == CUPSD_JOB_PURGE)
1393 remove_job_files(job);
1394 else if (job->num_files > 0)
b9faaae1
MS		 1395 {
1396 free(job->compressions);
1397 free(job->filetypes);
09a101d6 1398
82cc1f9a 1399 job->num_files = 0;
09a101d6 1400 }
ed6e7faf 1401
178cb736
MS		 1402 if (job->history)
1403 free_job_history(job);
1404
b9faaae1 1405 unload_job(job);
dfd5680b 1406
b9faaae1
MS		 1407 cupsArrayRemove(Jobs, job);
1408 cupsArrayRemove(ActiveJobs, job);
1409 cupsArrayRemove(PrintingJobs, job);
dfd5680b 1410
b9faaae1 1411 free(job);
ef416fc2 1412}
1413
1414
1415/*
b9faaae1 1416 * 'cupsdFreeAllJobs()' - Free all jobs from memory.
ef416fc2 1417 */
1418
1419void
b9faaae1 1420cupsdFreeAllJobs(void)
ef416fc2 1421{
b9faaae1 1422 cupsd_job_t *job; /* Current job */
ef416fc2 1423
ef416fc2 1424
b9faaae1 1425 if (!Jobs)
ef416fc2 1426 return;
1427
b9faaae1 1428 cupsdHoldSignals();
ef416fc2 1429
238c3832 1430 cupsdStopAllJobs(CUPSD_JOB_FORCE, 0);
b9faaae1 1431 cupsdSaveAllJobs();
e53920b9 1432
b9faaae1
MS		 1433 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
1434 job;
1435 job = (cupsd_job_t *)cupsArrayNext(Jobs))
1436 cupsdDeleteJob(job, CUPSD_JOB_DEFAULT);
ef416fc2 1437
b9faaae1
MS		 1438 cupsdReleaseSignals();
1439}
ef416fc2 1440
bd7854cb 1441
b9faaae1
MS		 1442/*
1443 * 'cupsdFindJob()' - Find the specified job.
1444 */
e53920b9 1445
b9faaae1
MS		 1446cupsd_job_t * /* O - Job data */
1447cupsdFindJob(int id) /* I - Job ID */
1448{
1449 cupsd_job_t key; /* Search key */
ef416fc2 1450
ef416fc2 1451
b9faaae1 1452 key.id = id;
e53920b9 1453
b9faaae1 1454 return ((cupsd_job_t *)cupsArrayFind(Jobs, &key));
ef416fc2 1455}
1456
1457
1458/*
b9faaae1
MS		 1459 * 'cupsdGetPrinterJobCount()' - Get the number of pending, processing,
1460 * or held jobs in a printer or class.
ef416fc2 1461 */
1462
b9faaae1
MS		 1463int /* O - Job count */
1464cupsdGetPrinterJobCount(
1465 const char *dest) /* I - Printer or class name */
ef416fc2 1466{
b9faaae1
MS		 1467 int count; /* Job count */
1468 cupsd_job_t *job; /* Current job */
005dd1eb 1469
005dd1eb 1470
b9faaae1
MS		 1471 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
1472 job;
1473 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
88f9aafc 1474 if (job->dest && !_cups_strcasecmp(job->dest, dest))
b9faaae1 1475 count ++;
ef416fc2 1476
b9faaae1 1477 return (count);
ef416fc2 1478}
1479
1480
1481/*
b9faaae1
MS		 1482 * 'cupsdGetUserJobCount()' - Get the number of pending, processing,
1483 * or held jobs for a user.
ef416fc2 1484 */
1485
b9faaae1
MS		 1486int /* O - Job count */
1487cupsdGetUserJobCount(
1488 const char *username) /* I - Username */
ef416fc2 1489{
b9faaae1
MS		 1490 int count; /* Job count */
1491 cupsd_job_t *job; /* Current job */
07725fee 1492
07725fee 1493
b9faaae1
MS		 1494 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
1495 job;
1496 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
88f9aafc 1497 if (!_cups_strcasecmp(job->username, username))
b9faaae1 1498 count ++;
07725fee 1499
b9faaae1 1500 return (count);
ef416fc2 1501}
1502
1503
1504/*
b9faaae1 1505 * 'cupsdLoadAllJobs()' - Load all jobs from disk.
ef416fc2 1506 */
1507
1508void
b9faaae1 1509cupsdLoadAllJobs(void)
bd7854cb 1510{
b9faaae1
MS		 1511 char filename[1024]; /* Full filename of job.cache file */
1512 struct stat fileinfo, /* Information on job.cache file */
1513 dirinfo; /* Information on RequestRoot dir */
bd7854cb 1514
bd7854cb 1515
bd7854cb 1516
1517 /*
b9faaae1 1518 * Create the job arrays as needed...
bd7854cb 1519 */
1520
b9faaae1
MS		 1521 if (!Jobs)
1522 Jobs = cupsArrayNew(compare_jobs, NULL);
1523
1524 if (!ActiveJobs)
1525 ActiveJobs = cupsArrayNew(compare_active_jobs, NULL);
1526
1527 if (!PrintingJobs)
1528 PrintingJobs = cupsArrayNew(compare_jobs, NULL);
bd7854cb 1529
1530 /*
b9faaae1 1531 * See whether the job.cache file is older than the RequestRoot directory...
bd7854cb 1532 */
1533
b9faaae1 1534 snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
bd7854cb 1535
b9faaae1
MS		 1536 if (stat(filename, &fileinfo))
1537 {
1538 fileinfo.st_mtime = 0;
1539
1540 if (errno != ENOENT)
1541 cupsdLogMessage(CUPSD_LOG_ERROR,
1542 "Unable to get file information for \"%s\" - %s",
1543 filename, strerror(errno));
1544 }
1545
1546 if (stat(RequestRoot, &dirinfo))
1547 {
1548 dirinfo.st_mtime = 0;
1549
1550 if (errno != ENOENT)
1551 cupsdLogMessage(CUPSD_LOG_ERROR,
1552 "Unable to get directory information for \"%s\" - %s",
1553 RequestRoot, strerror(errno));
1554 }
bd7854cb 1555
1556 /*
b9faaae1 1557 * Load the most recent source for job data...
bd7854cb 1558 */
1559
b9faaae1 1560 if (dirinfo.st_mtime > fileinfo.st_mtime)
bd7854cb 1561 {
b9faaae1
MS		 1562 load_request_root();
1563
1564 load_next_job_id(filename);
bd7854cb 1565 }
b9faaae1
MS		 1566 else
1567 load_job_cache(filename);
bd7854cb 1568
b9faaae1
MS		 1569 /*
1570 * Clean out old jobs as needed...
1571 */
1572
1573 if (MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs)
1574 cupsdCleanJobs();
bd7854cb 1575}
1576
1577
1578/*
b9faaae1 1579 * 'cupsdLoadJob()' - Load a single job.
bd7854cb 1580 */
1581
b9faaae1
MS		 1582int /* O - 1 on success, 0 on failure */
1583cupsdLoadJob(cupsd_job_t *job) /* I - Job */
ef416fc2 1584{
88f9aafc 1585 int i; /* Looping var */
b9faaae1
MS		 1586 char jobfile[1024]; /* Job filename */
1587 cups_file_t *fp; /* Job file */
1588 int fileid; /* Current file ID */
1589 ipp_attribute_t *attr; /* Job attribute */
1590 const char *dest; /* Destination name */
1591 cupsd_printer_t *destptr; /* Pointer to destination */
1592 mime_type_t **filetypes; /* New filetypes array */
1593 int *compressions; /* New compressions array */
ef416fc2 1594
1595
b9faaae1
MS		 1596 if (job->attrs)
1597 {
1598 if (job->state_value > IPP_JOB_STOPPED)
1599 job->access_time = time(NULL);
bd7854cb 1600
b9faaae1
MS		 1601 return (1);
1602 }
ef416fc2 1603
b9faaae1 1604 if ((job->attrs = ippNew()) == NULL)
ef416fc2 1605 {
12f89d24 1606 cupsdLogJob(job, CUPSD_LOG_ERROR, "Ran out of memory for job attributes.");
b9faaae1 1607 return (0);
ef416fc2 1608 }
1609
b9faaae1
MS		 1610 /*
1611 * Load job attributes...
1612 */
ef416fc2 1613
72f50170 1614 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Loading attributes...");
bd7854cb 1615
b9faaae1 1616 snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, job->id);
82cc1f9a
MS		 1617 if ((fp = cupsdOpenConfFile(jobfile)) == NULL)
1618 goto error;
ef416fc2 1619
b9faaae1
MS		 1620 if (ippReadIO(fp, (ipp_iocb_t)cupsFileRead, 1, NULL, job->attrs) != IPP_DATA)
1621 {
72f50170
MS		 1622 cupsdLogJob(job, CUPSD_LOG_ERROR,
1623 "Unable to read job control file \"%s\".", jobfile);
b9faaae1
MS		 1624 cupsFileClose(fp);
1625 goto error;
1626 }
ef416fc2 1627
b9faaae1 1628 cupsFileClose(fp);
ef416fc2 1629
b9faaae1
MS		 1630 /*
1631 * Copy attribute data to the job object...
1632 */
ef416fc2 1633
b9faaae1 1634 if (!ippFindAttribute(job->attrs, "time-at-creation", IPP_TAG_INTEGER))
ef416fc2 1635 {
72f50170
MS		 1636 cupsdLogJob(job, CUPSD_LOG_ERROR,
1637 "Missing or bad time-at-creation attribute in control file.");
b9faaae1 1638 goto error;
ef416fc2 1639 }
b9faaae1
MS		 1640
1641 if ((job->state = ippFindAttribute(job->attrs, "job-state",
1642 IPP_TAG_ENUM)) == NULL)
ef416fc2 1643 {
72f50170
MS		 1644 cupsdLogJob(job, CUPSD_LOG_ERROR,
1645 "Missing or bad job-state attribute in control file.");
b9faaae1
MS		 1646 goto error;
1647 }
ef416fc2 1648
82cc1f9a
MS		 1649 job->state_value = (ipp_jstate_t)job->state->values[0].integer;
1650 job->file_time = 0;
1651 job->history_time = 0;
1652
1653 if (job->state_value >= IPP_JOB_CANCELED &&
1654 (attr = ippFindAttribute(job->attrs, "time-at-completed",
1655 IPP_TAG_INTEGER)) != NULL)
1656 {
1657 if (JobHistory < INT_MAX)
1658 job->history_time = attr->values[0].integer + JobHistory;
1659 else
1660 job->history_time = INT_MAX;
1661
1662 if (job->history_time < time(NULL))
1663 goto error; /* Expired, remove from history */
1664
1665 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
1666 JobHistoryUpdate = job->history_time;
1667
1668 if (JobFiles < INT_MAX)
1669 job->file_time = attr->values[0].integer + JobFiles;
1670 else
1671 job->file_time = INT_MAX;
1672
1673 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
1674 JobHistoryUpdate = job->file_time;
1675
1676 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdLoadJob: JobHistoryUpdate=%ld",
1677 (long)JobHistoryUpdate);
1678 }
ef416fc2 1679
b9faaae1 1680 if (!job->dest)
ef416fc2 1681 {
b9faaae1
MS		 1682 if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
1683 IPP_TAG_URI)) == NULL)
1684 {
72f50170
MS		 1685 cupsdLogJob(job, CUPSD_LOG_ERROR,
1686 "No job-printer-uri attribute in control file.");
b9faaae1
MS		 1687 goto error;
1688 }
ef416fc2 1689
b9faaae1
MS		 1690 if ((dest = cupsdValidateDest(attr->values[0].string.text, &(job->dtype),
1691 &destptr)) == NULL)
1692 {
72f50170
MS		 1693 cupsdLogJob(job, CUPSD_LOG_ERROR,
1694 "Unable to queue job for destination \"%s\".",
1695 attr->values[0].string.text);
b9faaae1
MS		 1696 goto error;
1697 }
ef416fc2 1698
b9faaae1 1699 cupsdSetString(&job->dest, dest);
f7deaa1a 1700 }
b9faaae1 1701 else if ((destptr = cupsdFindDest(job->dest)) == NULL)
ef416fc2 1702 {
72f50170
MS		 1703 cupsdLogJob(job, CUPSD_LOG_ERROR,
1704 "Unable to queue job for destination \"%s\".",
1705 job->dest);
b9faaae1
MS		 1706 goto error;
1707 }
ef416fc2 1708
12f89d24
MS		 1709 if ((job->reasons = ippFindAttribute(job->attrs, "job-state-reasons",
1710 IPP_TAG_KEYWORD)) == NULL)
1711 {
1712 const char *reason; /* job-state-reason keyword */
1713
72f50170
MS		 1714 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1715 "Adding missing job-state-reasons attribute to control file.");
12f89d24
MS		 1716
1717 switch (job->state_value)
1718 {
82cc1f9a 1719 default :
12f89d24
MS		 1720 case IPP_JOB_PENDING :
1721 if (destptr->state == IPP_PRINTER_STOPPED)
1722 reason = "printer-stopped";
1723 else
1724 reason = "none";
1725 break;
1726
1727 case IPP_JOB_HELD :
1728 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
1729 IPP_TAG_ZERO)) != NULL &&
1730 (attr->value_tag == IPP_TAG_NAME ||
1731 attr->value_tag == IPP_TAG_NAMELANG ||
1732 attr->value_tag == IPP_TAG_KEYWORD) &&
1733 strcmp(attr->values[0].string.text, "no-hold"))
1734 reason = "job-hold-until-specified";
1735 else
1736 reason = "job-incoming";
1737 break;
1738
1739 case IPP_JOB_PROCESSING :
1740 reason = "job-printing";
1741 break;
1742
1743 case IPP_JOB_STOPPED :
1744 reason = "job-stopped";
1745 break;
1746
1747 case IPP_JOB_CANCELED :
1748 reason = "job-canceled-by-user";
1749 break;
1750
1751 case IPP_JOB_ABORTED :
1752 reason = "aborted-by-system";
1753 break;
1754
1755 case IPP_JOB_COMPLETED :
1756 reason = "job-completed-successfully";
1757 break;
1758 }
1759
1760 job->reasons = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
1761 "job-state-reasons", NULL, reason);
1762 }
1763 else if (job->state_value == IPP_JOB_PENDING)
1764 {
1765 if (destptr->state == IPP_PRINTER_STOPPED)
1766 ippSetString(job->attrs, &job->reasons, 0, "printer-stopped");
1767 else
1768 ippSetString(job->attrs, &job->reasons, 0, "none");
1769 }
1770
b9faaae1
MS		 1771 job->sheets = ippFindAttribute(job->attrs, "job-media-sheets-completed",
1772 IPP_TAG_INTEGER);
1773 job->job_sheets = ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_NAME);
ef416fc2 1774
b9faaae1
MS		 1775 if (!job->priority)
1776 {
1777 if ((attr = ippFindAttribute(job->attrs, "job-priority",
1778 IPP_TAG_INTEGER)) == NULL)
1779 {
72f50170
MS		 1780 cupsdLogJob(job, CUPSD_LOG_ERROR,
1781 "Missing or bad job-priority attribute in control file.");
b9faaae1
MS		 1782 goto error;
1783 }
1784
1785 job->priority = attr->values[0].integer;
f7deaa1a 1786 }
b9faaae1
MS		 1787
1788 if (!job->username)
ef416fc2 1789 {
b9faaae1
MS		 1790 if ((attr = ippFindAttribute(job->attrs, "job-originating-user-name",
1791 IPP_TAG_NAME)) == NULL)
1792 {
72f50170
MS		 1793 cupsdLogJob(job, CUPSD_LOG_ERROR,
1794 "Missing or bad job-originating-user-name "
1795 "attribute in control file.");
b9faaae1
MS		 1796 goto error;
1797 }
ef416fc2 1798
b9faaae1
MS		 1799 cupsdSetString(&job->username, attr->values[0].string.text);
1800 }
ef416fc2 1801
b9faaae1
MS		 1802 /*
1803 * Set the job hold-until time and state...
1804 */
1805
1806 if (job->state_value == IPP_JOB_HELD)
1807 {
1808 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
1809 IPP_TAG_KEYWORD)) == NULL)
1810 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
1811
1812 if (attr)
1813 cupsdSetJobHoldUntil(job, attr->values[0].string.text, CUPSD_JOB_DEFAULT);
ef416fc2 1814 else
b9faaae1
MS		 1815 {
1816 job->state->values[0].integer = IPP_JOB_PENDING;
1817 job->state_value = IPP_JOB_PENDING;
1818 }
f7deaa1a 1819 }
b9faaae1
MS		 1820 else if (job->state_value == IPP_JOB_PROCESSING)
1821 {
1822 job->state->values[0].integer = IPP_JOB_PENDING;
1823 job->state_value = IPP_JOB_PENDING;
1824 }
1825
1826 if (!job->num_files)
ef416fc2 1827 {
1828 /*
b9faaae1 1829 * Find all the d##### files...
ef416fc2 1830 */
1831
b9faaae1
MS		 1832 for (fileid = 1; fileid < 10000; fileid ++)
1833 {
1834 snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
1835 job->id, fileid);
ef416fc2 1836
b9faaae1
MS		 1837 if (access(jobfile, 0))
1838 break;
1839
72f50170
MS		 1840 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1841 "Auto-typing document file \"%s\"...", jobfile);
b9faaae1
MS		 1842
1843 if (fileid > job->num_files)
1844 {
1845 if (job->num_files == 0)
1846 {
7e86f2f6
MS		 1847 compressions = (int *)calloc((size_t)fileid, sizeof(int));
1848 filetypes = (mime_type_t **)calloc((size_t)fileid, sizeof(mime_type_t *));
b9faaae1
MS		 1849 }
1850 else
1851 {
7e86f2f6
MS		 1852 compressions = (int *)realloc(job->compressions, sizeof(int) * (size_t)fileid);
1853 filetypes = (mime_type_t **)realloc(job->filetypes, sizeof(mime_type_t *) * (size_t)fileid);
b9faaae1
MS		 1854 }
1855
cb7f98ee
MS		 1856 if (compressions)
1857 job->compressions = compressions;
1858
1859 if (filetypes)
1860 job->filetypes = filetypes;
1861
b9faaae1
MS		 1862 if (!compressions || !filetypes)
1863 {
72f50170
MS		 1864 cupsdLogJob(job, CUPSD_LOG_ERROR,
1865 "Ran out of memory for job file types.");
ef55b745
MS		 1866
1867 ippDelete(job->attrs);
1868 job->attrs = NULL;
1869
ef55b745
MS		 1870 if (job->compressions)
1871 {
1872 free(job->compressions);
1873 job->compressions = NULL;
1874 }
1875
1876 if (job->filetypes)
1877 {
1878 free(job->filetypes);
1879 job->filetypes = NULL;
1880 }
1881
1882 job->num_files = 0;
1883 return (0);
b9faaae1
MS		 1884 }
1885
cb7f98ee 1886 job->num_files = fileid;
b9faaae1
MS		 1887 }
1888
1889 job->filetypes[fileid - 1] = mimeFileType(MimeDatabase, jobfile, NULL,
1890 job->compressions + fileid - 1);
1891
1892 if (!job->filetypes[fileid - 1])
1893 job->filetypes[fileid - 1] = mimeType(MimeDatabase, "application",
1894 "vnd.cups-raw");
1895 }
ef416fc2 1896 }
b9faaae1
MS		 1897
1898 /*
1899 * Load authentication information as needed...
1900 */
1901
1902 if (job->state_value < IPP_JOB_STOPPED)
ef416fc2 1903 {
b9faaae1 1904 snprintf(jobfile, sizeof(jobfile), "%s/a%05d", RequestRoot, job->id);
ef416fc2 1905
88f9aafc
MS		 1906 for (i = 0;
1907 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
1908 i ++)
1909 cupsdClearString(job->auth_env + i);
07ed0e9a 1910 cupsdClearString(&job->auth_uid);
ef416fc2 1911
b9faaae1
MS		 1912 if ((fp = cupsFileOpen(jobfile, "r")) != NULL)
1913 {
dcb445bc
MS		 1914 int bytes, /* Size of auth data */
1915 linenum = 1; /* Current line number */
85dda01c 1916 char line[65536], /* Line from file */
dcb445bc 1917 *value, /* Value from line */
85dda01c 1918 data[65536]; /* Decoded data */
ef416fc2 1919
ef416fc2 1920
dcb445bc 1921 if (cupsFileGets(fp, line, sizeof(line)) &&
94436c5a 1922 !strcmp(line, "CUPSD-AUTH-V3"))
b9faaae1 1923 {
dcb445bc
MS		 1924 i = 0;
1925 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
1926 {
1927 /*
1928 * Decode value...
1929 */
1930
94436c5a
MS		 1931 if (strcmp(line, "negotiate") && strcmp(line, "uid"))
1932 {
1933 bytes = sizeof(data);
1934 httpDecode64_2(data, &bytes, value);
1935 }
b9faaae1 1936
dcb445bc
MS		 1937 /*
1938 * Assign environment variables...
1939 */
1940
1941 if (!strcmp(line, "uid"))
1942 {
1943 cupsdSetStringf(&job->auth_uid, "AUTH_UID=%s", value);
1944 continue;
1945 }
1946 else if (i >= (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0])))
1947 break;
1948
1949 if (!strcmp(line, "username"))
1950 cupsdSetStringf(job->auth_env + i, "AUTH_USERNAME=%s", data);
1951 else if (!strcmp(line, "domain"))
1952 cupsdSetStringf(job->auth_env + i, "AUTH_DOMAIN=%s", data);
1953 else if (!strcmp(line, "password"))
1954 cupsdSetStringf(job->auth_env + i, "AUTH_PASSWORD=%s", data);
1955 else if (!strcmp(line, "negotiate"))
94436c5a 1956 cupsdSetStringf(job->auth_env + i, "AUTH_NEGOTIATE=%s", value);
dcb445bc
MS		 1957 else
1958 continue;
1959
1960 i ++;
1961 }
1962 }
07ed0e9a 1963
b9faaae1
MS		 1964 cupsFileClose(fp);
1965 }
ef416fc2 1966 }
1967
b9faaae1
MS		 1968 job->access_time = time(NULL);
1969 return (1);
1970
1971 /*
1972 * If we get here then something bad happened...
1973 */
1974
1975 error:
1976
1977 ippDelete(job->attrs);
1978 job->attrs = NULL;
ef55b745 1979
82cc1f9a
MS		 1980 remove_job_history(job);
1981 remove_job_files(job);
b9faaae1
MS		 1982
1983 return (0);
ef416fc2 1984}
1985
1986
1987/*
b9faaae1 1988 * 'cupsdMoveJob()' - Move the specified job to a different destination.
ef416fc2 1989 */
1990
1991void
b9faaae1
MS		 1992cupsdMoveJob(cupsd_job_t *job, /* I - Job */
1993 cupsd_printer_t *p) /* I - Destination printer or class */
ef416fc2 1994{
b9faaae1
MS		 1995 ipp_attribute_t *attr; /* job-printer-uri attribute */
1996 const char *olddest; /* Old destination */
1997 cupsd_printer_t *oldp; /* Old pointer */
ef416fc2 1998
1999
2000 /*
b9faaae1 2001 * Don't move completed jobs...
ef416fc2 2002 */
2003
b9faaae1 2004 if (job->state_value > IPP_JOB_STOPPED)
ef416fc2 2005 return;
2006
2007 /*
b9faaae1 2008 * Get the old destination...
ef416fc2 2009 */
2010
b9faaae1 2011 olddest = job->dest;
ef416fc2 2012
b9faaae1
MS		 2013 if (job->printer)
2014 oldp = job->printer;
ef416fc2 2015 else
b9faaae1 2016 oldp = cupsdFindDest(olddest);
ef416fc2 2017
b9faaae1
MS		 2018 /*
2019 * Change the destination information...
2020 */
2021
eac3a0a0
MS		 2022 if (job->state_value > IPP_JOB_HELD)
2023 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2024 "Stopping job prior to move.");
b9faaae1
MS		 2025
2026 cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED, oldp, job,
2027 "Job #%d moved from %s to %s.", job->id, olddest,
2028 p->name);
2029
2030 cupsdSetString(&job->dest, p->name);
a2326b5b 2031 job->dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
b9faaae1
MS		 2032
2033 if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
2034 IPP_TAG_URI)) != NULL)
2035 cupsdSetString(&(attr->values[0].string.text), p->uri);
2036
2037 cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, p, job,
2038 "Job #%d moved from %s to %s.", job->id, olddest,
2039 p->name);
ef416fc2 2040
3dfe78b3
MS		 2041 job->dirty = 1;
2042 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
ef416fc2 2043}
2044
2045
2046/*
b9faaae1 2047 * 'cupsdReleaseJob()' - Release the specified job.
ef416fc2 2048 */
2049
2050void
b9faaae1 2051cupsdReleaseJob(cupsd_job_t *job) /* I - Job */
ef416fc2 2052{
b9faaae1
MS		 2053 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdReleaseJob(job=%p(%d))", job,
2054 job->id);
ef416fc2 2055
b9faaae1
MS		 2056 if (job->state_value == IPP_JOB_HELD)
2057 {
2058 /*
2059 * Add trailing banner as needed...
2060 */
ef416fc2 2061
b9faaae1
MS		 2062 if (job->pending_timeout)
2063 cupsdTimeoutJob(job);
ef416fc2 2064
b9faaae1
MS		 2065 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2066 "Job released by user.");
2067 }
e1d6a774 2068}
ef416fc2 2069
ef416fc2 2070
e1d6a774 2071/*
b9faaae1 2072 * 'cupsdRestartJob()' - Restart the specified job.
e1d6a774 2073 */
ef416fc2 2074
e1d6a774 2075void
b9faaae1 2076cupsdRestartJob(cupsd_job_t *job) /* I - Job */
e1d6a774 2077{
b9faaae1
MS		 2078 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdRestartJob(job=%p(%d))", job,
2079 job->id);
ef416fc2 2080
b9faaae1
MS		 2081 if (job->state_value == IPP_JOB_STOPPED || job->num_files)
2082 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2083 "Job restarted by user.");
2084}
ef416fc2 2085
ef416fc2 2086
b9faaae1
MS		 2087/*
2088 * 'cupsdSaveAllJobs()' - Save a summary of all jobs to disk.
2089 */
ef416fc2 2090
b9faaae1
MS		 2091void
2092cupsdSaveAllJobs(void)
2093{
2094 int i; /* Looping var */
321d8d57
MS		 2095 cups_file_t *fp; /* job.cache file */
2096 char filename[1024], /* job.cache filename */
2097 temp[1024]; /* Temporary string */
b9faaae1
MS		 2098 cupsd_job_t *job; /* Current job */
2099 time_t curtime; /* Current time */
2100 struct tm *curdate; /* Current date */
ef416fc2 2101
ef416fc2 2102
321d8d57
MS		 2103 snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
2104 if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm)) == NULL)
c168a833 2105 return;
ef416fc2 2106
321d8d57 2107 cupsdLogMessage(CUPSD_LOG_INFO, "Saving job.cache...");
bd7854cb 2108
b9faaae1
MS		 2109 /*
2110 * Write a small header to the file...
2111 */
bd7854cb 2112
b9faaae1
MS		 2113 curtime = time(NULL);
2114 curdate = localtime(&curtime);
2115 strftime(temp, sizeof(temp) - 1, "%Y-%m-%d %H:%M", curdate);
ef416fc2 2116
b9faaae1
MS		 2117 cupsFilePuts(fp, "# Job cache file for " CUPS_SVERSION "\n");
2118 cupsFilePrintf(fp, "# Written by cupsd on %s\n", temp);
2119 cupsFilePrintf(fp, "NextJobId %d\n", NextJobId);
f7deaa1a 2120
b9faaae1
MS		 2121 /*
2122 * Write each job known to the system...
2123 */
f7deaa1a 2124
b9faaae1
MS		 2125 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
2126 job;
2127 job = (cupsd_job_t *)cupsArrayNext(Jobs))
ef416fc2 2128 {
b9faaae1
MS		 2129 cupsFilePrintf(fp, "<Job %d>\n", job->id);
2130 cupsFilePrintf(fp, "State %d\n", job->state_value);
2131 cupsFilePrintf(fp, "Priority %d\n", job->priority);
8b116e60 2132 cupsFilePrintf(fp, "HoldUntil %d\n", (int)job->hold_until);
b9faaae1
MS		 2133 cupsFilePrintf(fp, "Username %s\n", job->username);
2134 cupsFilePrintf(fp, "Destination %s\n", job->dest);
2135 cupsFilePrintf(fp, "DestType %d\n", job->dtype);
2136 cupsFilePrintf(fp, "NumFiles %d\n", job->num_files);
2137 for (i = 0; i < job->num_files; i ++)
2138 cupsFilePrintf(fp, "File %d %s/%s %d\n", i + 1, job->filetypes[i]->super,
2139 job->filetypes[i]->type, job->compressions[i]);
2140 cupsFilePuts(fp, "</Job>\n");
ef416fc2 2141 }
b9faaae1 2142
321d8d57 2143 cupsdCloseCreatedConfFile(fp, filename);
e1d6a774 2144}
ef416fc2 2145
ef416fc2 2146
e1d6a774 2147/*
b9faaae1 2148 * 'cupsdSaveJob()' - Save a job to disk.
e1d6a774 2149 */
ef416fc2 2150
e1d6a774 2151void
b9faaae1 2152cupsdSaveJob(cupsd_job_t *job) /* I - Job */
e1d6a774 2153{
82cc1f9a 2154 char filename[1024]; /* Job control filename */
b9faaae1 2155 cups_file_t *fp; /* Job file */
3dfe78b3 2156
ef416fc2 2157
b9faaae1
MS		 2158 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSaveJob(job=%p(%d)): job->attrs=%p",
2159 job, job->id, job->attrs);
ef416fc2 2160
b9faaae1 2161 snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot, job->id);
ef416fc2 2162
82cc1f9a 2163 if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm & 0600)) == NULL)
b9faaae1 2164 return;
ef416fc2 2165
b9faaae1 2166 fchown(cupsFileNumber(fp), RunUser, Group);
ef416fc2 2167
b9faaae1 2168 job->attrs->state = IPP_IDLE;
ef416fc2 2169
b9faaae1
MS		 2170 if (ippWriteIO(fp, (ipp_iocb_t)cupsFileWrite, 1, NULL,
2171 job->attrs) != IPP_DATA)
321d8d57 2172 {
72f50170 2173 cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to write job control file.");
321d8d57 2174 cupsFileClose(fp);
321d8d57
MS		 2175 return;
2176 }
ef416fc2 2177
82cc1f9a 2178 if (!cupsdCloseCreatedConfFile(fp, filename))
cb7f98ee
MS		 2179 {
2180 /*
2181 * Remove backup file and mark this job as clean...
2182 */
2183
2184 strlcat(filename, ".O", sizeof(filename));
2185 unlink(filename);
2186
82cc1f9a 2187 job->dirty = 0;
cb7f98ee 2188 }
e1d6a774 2189}
ef416fc2 2190
ef416fc2 2191
e1d6a774 2192/*
b9faaae1 2193 * 'cupsdSetJobHoldUntil()' - Set the hold time for a job.
e1d6a774 2194 */
ef416fc2 2195
b9faaae1
MS		 2196void
2197cupsdSetJobHoldUntil(cupsd_job_t *job, /* I - Job */
2198 const char *when, /* I - When to resume */
2199 int update)/* I - Update job-hold-until attr? */
e1d6a774 2200{
b9faaae1
MS		 2201 time_t curtime; /* Current time */
2202 struct tm *curdate; /* Current date */
2203 int hour; /* Hold hour */
2204 int minute; /* Hold minute */
2205 int second = 0; /* Hold second */
ef416fc2 2206
ef416fc2 2207
b9faaae1
MS		 2208 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2209 "cupsdSetJobHoldUntil(job=%p(%d), when=\"%s\", update=%d)",
2210 job, job->id, when, update);
ef416fc2 2211
b9faaae1 2212 if (update)
ef416fc2 2213 {
e1d6a774 2214 /*
b9faaae1 2215 * Update the job-hold-until attribute...
e1d6a774 2216 */
ef416fc2 2217
b9faaae1 2218 ipp_attribute_t *attr; /* job-hold-until attribute */
ef416fc2 2219
b9faaae1
MS		 2220 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
2221 IPP_TAG_KEYWORD)) == NULL)
2222 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
ef416fc2 2223
b9faaae1
MS		 2224 if (attr)
2225 cupsdSetString(&(attr->values[0].string.text), when);
2226 else
2227 attr = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
2228 "job-hold-until", NULL, when);
ef416fc2 2229
b9faaae1
MS		 2230 if (attr)
2231 {
2232 if (isdigit(when[0] & 255))
2233 attr->value_tag = IPP_TAG_NAME;
2234 else
2235 attr->value_tag = IPP_TAG_KEYWORD;
2236
2237 job->dirty = 1;
2238 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2239 }
3e7fe0ca 2240
b9faaae1 2241 }
ef416fc2 2242
67dde2cc
MS		 2243 ippSetString(job->attrs, &job->reasons, 0, "job-hold-until-specified");
2244
b9faaae1
MS		 2245 /*
2246 * Update the hold time...
2247 */
2248
3e7fe0ca
MS		 2249 job->cancel_time = 0;
2250
b9faaae1
MS		 2251 if (!strcmp(when, "indefinite") || !strcmp(when, "auth-info-required"))
2252 {
e1d6a774 2253 /*
b9faaae1 2254 * Hold indefinitely...
e1d6a774 2255 */
ef416fc2 2256
b9faaae1 2257 job->hold_until = 0;
3e7fe0ca
MS		 2258
2259 if (MaxHoldTime > 0)
2260 job->cancel_time = time(NULL) + MaxHoldTime;
b9faaae1
MS		 2261 }
2262 else if (!strcmp(when, "day-time"))
2263 {
e1d6a774 2264 /*
b9faaae1 2265 * Hold to 6am the next morning unless local time is < 6pm.
e1d6a774 2266 */
ef416fc2 2267
b9faaae1
MS		 2268 curtime = time(NULL);
2269 curdate = localtime(&curtime);
ef416fc2 2270
b9faaae1
MS		 2271 if (curdate->tm_hour < 18)
2272 job->hold_until = curtime;
2273 else
2274 job->hold_until = curtime +
2275 ((29 - curdate->tm_hour) * 60 + 59 -
2276 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2277 }
2278 else if (!strcmp(when, "evening") || !strcmp(when, "night"))
2279 {
2280 /*
2281 * Hold to 6pm unless local time is > 6pm or < 6am.
2282 */
ef416fc2 2283
b9faaae1
MS		 2284 curtime = time(NULL);
2285 curdate = localtime(&curtime);
ef416fc2 2286
b9faaae1
MS		 2287 if (curdate->tm_hour < 6 || curdate->tm_hour >= 18)
2288 job->hold_until = curtime;
2289 else
2290 job->hold_until = curtime +
2291 ((17 - curdate->tm_hour) * 60 + 59 -
2292 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2293 }
2294 else if (!strcmp(when, "second-shift"))
2295 {
2296 /*
2297 * Hold to 4pm unless local time is > 4pm.
2298 */
ef416fc2 2299
b9faaae1
MS		 2300 curtime = time(NULL);
2301 curdate = localtime(&curtime);
ef416fc2 2302
b9faaae1
MS		 2303 if (curdate->tm_hour >= 16)
2304 job->hold_until = curtime;
2305 else
2306 job->hold_until = curtime +
2307 ((15 - curdate->tm_hour) * 60 + 59 -
2308 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2309 }
2310 else if (!strcmp(when, "third-shift"))
2311 {
2312 /*
2313 * Hold to 12am unless local time is < 8am.
2314 */
ef416fc2 2315
b9faaae1
MS		 2316 curtime = time(NULL);
2317 curdate = localtime(&curtime);
ef416fc2 2318
b9faaae1
MS		 2319 if (curdate->tm_hour < 8)
2320 job->hold_until = curtime;
2321 else
2322 job->hold_until = curtime +
2323 ((23 - curdate->tm_hour) * 60 + 59 -
2324 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2325 }
2326 else if (!strcmp(when, "weekend"))
2327 {
2328 /*
2329 * Hold to weekend unless we are in the weekend.
2330 */
ef416fc2 2331
b9faaae1
MS		 2332 curtime = time(NULL);
2333 curdate = localtime(&curtime);
ef416fc2 2334
b9faaae1
MS		 2335 if (curdate->tm_wday == 0 || curdate->tm_wday == 6)
2336 job->hold_until = curtime;
2337 else
2338 job->hold_until = curtime +
2339 (((5 - curdate->tm_wday) * 24 +
2340 (17 - curdate->tm_hour)) * 60 + 59 -
2341 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2342 }
2343 else if (sscanf(when, "%d:%d:%d", &hour, &minute, &second) >= 2)
2344 {
2345 /*
2346 * Hold to specified GMT time (HH:MM or HH:MM:SS)...
2347 */
bd7854cb 2348
b9faaae1
MS		 2349 curtime = time(NULL);
2350 curdate = gmtime(&curtime);
2351
2352 job->hold_until = curtime +
2353 ((hour - curdate->tm_hour) * 60 + minute -
2354 curdate->tm_min) * 60 + second - curdate->tm_sec;
2355
2356 /*
2357 * Hold until next day as needed...
2358 */
2359
2360 if (job->hold_until < curtime)
2361 job->hold_until += 24 * 60 * 60;
ef416fc2 2362 }
2363
b9faaae1
MS		 2364 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSetJobHoldUntil: hold_until=%d",
2365 (int)job->hold_until);
e1d6a774 2366}
ef416fc2 2367
ef416fc2 2368
e1d6a774 2369/*
b9faaae1
MS		 2370 * 'cupsdSetJobPriority()' - Set the priority of a job, moving it up/down in
2371 * the list as needed.
e1d6a774 2372 */
ef416fc2 2373
b9faaae1
MS		 2374void
2375cupsdSetJobPriority(
2376 cupsd_job_t *job, /* I - Job ID */
2377 int priority) /* I - New priority (0 to 100) */
e1d6a774 2378{
b9faaae1 2379 ipp_attribute_t *attr; /* Job attribute */
ef416fc2 2380
ef416fc2 2381
e1d6a774 2382 /*
b9faaae1 2383 * Don't change completed jobs...
e1d6a774 2384 */
bd7854cb 2385
b9faaae1 2386 if (job->state_value >= IPP_JOB_PROCESSING)
ef416fc2 2387 return;
ef416fc2 2388
e1d6a774 2389 /*
b9faaae1 2390 * Set the new priority and re-add the job into the active list...
e1d6a774 2391 */
ef416fc2 2392
b9faaae1 2393 cupsArrayRemove(ActiveJobs, job);
ef416fc2 2394
b9faaae1 2395 job->priority = priority;
ef416fc2 2396
b9faaae1
MS		 2397 if ((attr = ippFindAttribute(job->attrs, "job-priority",
2398 IPP_TAG_INTEGER)) != NULL)
2399 attr->values[0].integer = priority;
2400 else
2401 ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-priority",
2402 priority);
ef416fc2 2403
b9faaae1 2404 cupsArrayAdd(ActiveJobs, job);
bd7854cb 2405
b9faaae1
MS		 2406 job->dirty = 1;
2407 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2408}
bd7854cb 2409
ef416fc2 2410
b9faaae1
MS		 2411/*
2412 * 'cupsdSetJobState()' - Set the state of the specified print job.
2413 */
e1d6a774 2414
b9faaae1
MS		 2415void
2416cupsdSetJobState(
2417 cupsd_job_t *job, /* I - Job to cancel */
2418 ipp_jstate_t newstate, /* I - New job state */
2419 cupsd_jobaction_t action, /* I - Action to take */
2420 const char *message, /* I - Message to log */
2421 ...) /* I - Additional arguments as needed */
2422{
2423 int i; /* Looping var */
2424 ipp_jstate_t oldstate; /* Old state */
2425 char filename[1024]; /* Job filename */
2426 ipp_attribute_t *attr; /* Job attribute */
ef416fc2 2427
ef416fc2 2428
b9faaae1
MS		 2429 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2430 "cupsdSetJobState(job=%p(%d), state=%d, newstate=%d, "
2431 "action=%d, message=\"%s\")", job, job->id, job->state_value,
2432 newstate, action, message ? message : "(null)");
ef416fc2 2433
bd7854cb 2434
b9faaae1
MS		 2435 /*
2436 * Make sure we have the job attributes...
2437 */
e1d6a774 2438
b9faaae1
MS		 2439 if (!cupsdLoadJob(job))
2440 return;
bd7854cb 2441
f99f3698
MS		 2442 /*
2443 * Don't do anything if the state is unchanged and we aren't purging the
2444 * job...
2445 */
2446
2447 oldstate = job->state_value;
2448 if (newstate == oldstate && action != CUPSD_JOB_PURGE)
2449 return;
e1d6a774 2450
b9faaae1
MS		 2451 /*
2452 * Stop any processes that are working on the current job...
2453 */
e1d6a774 2454
b9faaae1 2455 if (oldstate == IPP_JOB_PROCESSING)
ef55b745 2456 stop_job(job, action);
b9faaae1
MS		 2457
2458 /*
2459 * Set the new job state...
2460 */
2461
0fa6c7fa
MS		 2462 job->state_value = newstate;
2463
2464 if (job->state)
2465 job->state->values[0].integer = newstate;
b9faaae1
MS		 2466
2467 switch (newstate)
2468 {
2469 case IPP_JOB_PENDING :
2470 /*
2471 * Update job-hold-until as needed...
2472 */
2473
2474 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
2475 IPP_TAG_KEYWORD)) == NULL)
2476 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
2477
2478 if (attr)
ef416fc2 2479 {
b9faaae1
MS		 2480 attr->value_tag = IPP_TAG_KEYWORD;
2481 cupsdSetString(&(attr->values[0].string.text), "no-hold");
e1d6a774 2482 }
ef416fc2 2483
b9faaae1
MS		 2484 default :
2485 break;
ef416fc2 2486
b9faaae1
MS		 2487 case IPP_JOB_ABORTED :
2488 case IPP_JOB_CANCELED :
2489 case IPP_JOB_COMPLETED :
2490 set_time(job, "time-at-completed");
12f89d24 2491 ippSetString(job->attrs, &job->reasons, 0, "processing-to-stop-point");
b9faaae1
MS		 2492 break;
2493 }
ef416fc2 2494
b9faaae1
MS		 2495 /*
2496 * Log message as needed...
2497 */
ef416fc2 2498
b9faaae1
MS		 2499 if (message)
2500 {
2501 char buffer[2048]; /* Message buffer */
2502 va_list ap; /* Pointer to additional arguments */
ef416fc2 2503
b9faaae1
MS		 2504 va_start(ap, message);
2505 vsnprintf(buffer, sizeof(buffer), message, ap);
2506 va_end(ap);
bd7854cb 2507
b9faaae1
MS		 2508 if (newstate > IPP_JOB_STOPPED)
2509 cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job, "%s", buffer);
2510 else
2511 cupsdAddEvent(CUPSD_EVENT_JOB_STATE, job->printer, job, "%s", buffer);
2512
2513 if (newstate == IPP_JOB_STOPPED || newstate == IPP_JOB_ABORTED)
2514 cupsdLogJob(job, CUPSD_LOG_ERROR, "%s", buffer);
2515 else
2516 cupsdLogJob(job, CUPSD_LOG_INFO, "%s", buffer);
2517 }
2518
2519 /*
2520 * Handle post-state-change actions...
2521 */
2522
2523 switch (newstate)
2524 {
2525 case IPP_JOB_PROCESSING :
e1d6a774 2526 /*
b9faaae1 2527 * Add the job to the "printing" list...
e1d6a774 2528 */
bd7854cb 2529
b9faaae1
MS		 2530 if (!cupsArrayFind(PrintingJobs, job))
2531 cupsArrayAdd(PrintingJobs, job);
ef416fc2 2532
b9faaae1
MS		 2533 /*
2534 * Set the processing time...
2535 */
ef416fc2 2536
b9faaae1
MS		 2537 set_time(job, "time-at-processing");
2538
2539 case IPP_JOB_PENDING :
2540 case IPP_JOB_HELD :
2541 case IPP_JOB_STOPPED :
e1d6a774 2542 /*
b9faaae1 2543 * Make sure the job is in the active list...
e1d6a774 2544 */
ef416fc2 2545
b9faaae1
MS		 2546 if (!cupsArrayFind(ActiveJobs, job))
2547 cupsArrayAdd(ActiveJobs, job);
ef416fc2 2548
b9faaae1
MS		 2549 /*
2550 * Save the job state to disk...
2551 */
ef416fc2 2552
b9faaae1
MS		 2553 job->dirty = 1;
2554 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2555 break;
ef416fc2 2556
b9faaae1
MS		 2557 case IPP_JOB_ABORTED :
2558 case IPP_JOB_CANCELED :
2559 case IPP_JOB_COMPLETED :
7a0cbd5e
MS		 2560 if (newstate == IPP_JOB_CANCELED)
2561 {
2562 /*
2563 * Remove the job from the active list if there are no processes still
2564 * running for it...
2565 */
ef416fc2 2566
7a0cbd5e
MS		 2567 for (i = 0; job->filters[i] < 0; i++);
2568
2569 if (!job->filters[i] && job->backend <= 0)
2570 cupsArrayRemove(ActiveJobs, job);
2571 }
2572 else
2573 {
2574 /*
2575 * Otherwise just remove the job from the active list immediately...
2576 */
2577
2578 cupsArrayRemove(ActiveJobs, job);
2579 }
ef416fc2 2580
b9faaae1 2581 /*
7a0cbd5e 2582 * Expire job subscriptions since the job is now "completed"...
b9faaae1 2583 */
ef416fc2 2584
7a0cbd5e 2585 cupsdExpireSubscriptions(NULL, job);
ef416fc2 2586
b9faaae1
MS		 2587#ifdef __APPLE__
2588 /*
2589 * If we are going to sleep and the PrintingJobs count is now 0, allow the
2590 * sleep to happen immediately...
2591 */
ef416fc2 2592
b9faaae1
MS		 2593 if (Sleeping && cupsArrayCount(PrintingJobs) == 0)
2594 cupsdAllowSleep();
2595#endif /* __APPLE__ */
ef416fc2 2596
b9faaae1
MS		 2597 /*
2598 * Remove any authentication data...
2599 */
bd7854cb 2600
b9faaae1
MS		 2601 snprintf(filename, sizeof(filename), "%s/a%05d", RequestRoot, job->id);
2602 if (cupsdRemoveFile(filename) && errno != ENOENT)
2603 cupsdLogMessage(CUPSD_LOG_ERROR,
2604 "Unable to remove authentication cache: %s",
2605 strerror(errno));
bd7854cb 2606
88f9aafc
MS		 2607 for (i = 0;
2608 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
2609 i ++)
2610 cupsdClearString(job->auth_env + i);
2611
07ed0e9a 2612 cupsdClearString(&job->auth_uid);
ef416fc2 2613
b9faaae1
MS		 2614 /*
2615 * Remove the print file for good if we aren't preserving jobs or
2616 * files...
2617 */
e1d6a774 2618
b9faaae1 2619 if (!JobHistory || !JobFiles || action == CUPSD_JOB_PURGE)
82cc1f9a 2620 remove_job_files(job);
ef416fc2 2621
b9faaae1
MS		 2622 if (JobHistory && action != CUPSD_JOB_PURGE)
2623 {
2624 /*
2625 * Save job state info...
2626 */
e1d6a774 2627
b9faaae1
MS		 2628 job->dirty = 1;
2629 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2630 }
ba55dc12
MS		 2631 else if (!job->printer)
2632 {
2633 /*
2634 * Delete the job immediately if not actively printing...
2635 */
2636
2637 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
2638 job = NULL;
2639 }
b9faaae1 2640 break;
e1d6a774 2641 }
2642
e07d4801
MS		 2643 /*
2644 * Finalize the job immediately if we forced things...
2645 */
2646
ba55dc12 2647 if (action >= CUPSD_JOB_FORCE && job && job->printer)
ef55b745 2648 finalize_job(job, 0);
e07d4801 2649
e1d6a774 2650 /*
b9faaae1 2651 * Update the server "busy" state...
e1d6a774 2652 */
ef416fc2 2653
b9faaae1
MS		 2654 cupsdSetBusyState();
2655}
e00b005a 2656
ef416fc2 2657
b9faaae1
MS		 2658/*
2659 * 'cupsdStopAllJobs()' - Stop all print jobs.
2660 */
ef416fc2 2661
b9faaae1
MS		 2662void
2663cupsdStopAllJobs(
238c3832
MS		 2664 cupsd_jobaction_t action, /* I - Action */
2665 int kill_delay) /* I - Number of seconds before we kill */
b9faaae1
MS		 2666{
2667 cupsd_job_t *job; /* Current job */
ef416fc2 2668
ef416fc2 2669
b9faaae1 2670 DEBUG_puts("cupsdStopAllJobs()");
ef416fc2 2671
b9faaae1
MS		 2672 for (job = (cupsd_job_t *)cupsArrayFirst(PrintingJobs);
2673 job;
2674 job = (cupsd_job_t *)cupsArrayNext(PrintingJobs))
238c3832 2675 {
581dae2d
MS		 2676 if (job->completed)
2677 {
2678 cupsdSetJobState(job, IPP_JOB_COMPLETED, CUPSD_JOB_FORCE, NULL);
2679 }
2680 else
2681 {
2682 if (kill_delay)
2683 job->kill_time = time(NULL) + kill_delay;
238c3832 2684
581dae2d
MS		 2685 cupsdSetJobState(job, IPP_JOB_PENDING, action, NULL);
2686 }
238c3832 2687 }
b9faaae1 2688}
bd7854cb 2689
bd7854cb 2690
b9faaae1
MS		 2691/*
2692 * 'cupsdUnloadCompletedJobs()' - Flush completed job history from memory.
2693 */
ef416fc2 2694
b9faaae1
MS		 2695void
2696cupsdUnloadCompletedJobs(void)
2697{
2698 cupsd_job_t *job; /* Current job */
2699 time_t expire; /* Expiration time */
ef416fc2 2700
b9faaae1
MS		 2701
2702 expire = time(NULL) - 60;
2703
2704 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
2705 job;
2706 job = (cupsd_job_t *)cupsArrayNext(Jobs))
2707 if (job->attrs && job->state_value >= IPP_JOB_STOPPED && !job->printer &&
2708 job->access_time < expire)
2709 {
2710 if (job->dirty)
2711 cupsdSaveJob(job);
2712
2713 unload_job(job);
2714 }
e1d6a774 2715}
ef416fc2 2716
ef416fc2 2717
82cc1f9a
MS		 2718/*
2719 * 'cupsdUpdateJobs()' - Update the history/file files for all jobs.
2720 */
2721
2722void
2723cupsdUpdateJobs(void)
2724{
2725 cupsd_job_t *job; /* Current job */
2726 time_t curtime; /* Current time */
2727 ipp_attribute_t *attr; /* time-at-completed attribute */
2728
2729
2730 curtime = time(NULL);
2731 JobHistoryUpdate = 0;
2732
2733 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
2734 job;
2735 job = (cupsd_job_t *)cupsArrayNext(Jobs))
2736 {
2737 if (job->state_value >= IPP_JOB_CANCELED &&
2738 (attr = ippFindAttribute(job->attrs, "time-at-completed",
2739 IPP_TAG_INTEGER)) != NULL)
2740 {
2741 /*
2742 * Update history/file expiration times...
2743 */
2744
2745 if (JobHistory < INT_MAX)
2746 job->history_time = attr->values[0].integer + JobHistory;
2747 else
2748 job->history_time = INT_MAX;
2749
2750 if (job->history_time < curtime)
2751 {
2752 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
2753 continue;
2754 }
2755
2756 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
2757 JobHistoryUpdate = job->history_time;
2758
2759 if (JobFiles < INT_MAX)
2760 job->file_time = attr->values[0].integer + JobFiles;
2761 else
2762 job->file_time = INT_MAX;
2763
2764 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
2765 JobHistoryUpdate = job->file_time;
2766 }
2767 }
2768
2769 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdUpdateAllJobs: JobHistoryUpdate=%ld",
2770 (long)JobHistoryUpdate);
2771}
2772
2773
e1d6a774 2774/*
b9faaae1 2775 * 'compare_active_jobs()' - Compare the job IDs and priorities of two jobs.
e1d6a774 2776 */
ef416fc2 2777
b9faaae1
MS		 2778static int /* O - Difference */
2779compare_active_jobs(void *first, /* I - First job */
2780 void *second, /* I - Second job */
2781 void *data) /* I - App data (not used) */
e1d6a774 2782{
b9faaae1 2783 int diff; /* Difference */
ef416fc2 2784
ef416fc2 2785
321d8d57
MS		 2786 (void)data;
2787
b9faaae1
MS		 2788 if ((diff = ((cupsd_job_t *)second)->priority -
2789 ((cupsd_job_t *)first)->priority) != 0)
2790 return (diff);
2791 else
2792 return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
e1d6a774 2793}
bd7854cb 2794
ef416fc2 2795
e1d6a774 2796/*
b9faaae1 2797 * 'compare_jobs()' - Compare the job IDs of two jobs.
e1d6a774 2798 */
ef416fc2 2799
b9faaae1
MS		 2800static int /* O - Difference */
2801compare_jobs(void *first, /* I - First job */
2802 void *second, /* I - Second job */
2803 void *data) /* I - App data (not used) */
e1d6a774 2804{
321d8d57
MS		 2805 (void)data;
2806
b9faaae1
MS		 2807 return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
2808}
ef416fc2 2809
ef416fc2 2810
178cb736
MS		 2811/*
2812 * 'dump_job_history()' - Dump any debug messages for a job.
2813 */
2814
2815static void
2816dump_job_history(cupsd_job_t *job) /* I - Job */
2817{
2818 int i, /* Looping var */
2819 oldsize; /* Current MaxLogSize */
2820 struct tm *date; /* Date/time value */
2821 cupsd_joblog_t *message; /* Current message */
2822 char temp[2048], /* Log message */
2823 *ptr, /* Pointer into log message */
2824 start[256], /* Start time */
2825 end[256]; /* End time */
2826 cupsd_printer_t *printer; /* Printer for job */
2827
2828
2829 /*
2830 * See if we have anything to dump...
2831 */
2832
2833 if (!job->history)
2834 return;
2835
2836 /*
2837 * Disable log rotation temporarily...
2838 */
2839
2840 oldsize = MaxLogSize;
2841 MaxLogSize = 0;
2842
2843 /*
2844 * Copy the debug messages to the log...
2845 */
2846
2847 message = (cupsd_joblog_t *)cupsArrayFirst(job->history);
2848 date = localtime(&(message->time));
2849 strftime(start, sizeof(start), "%X", date);
2850
2851 message = (cupsd_joblog_t *)cupsArrayLast(job->history);
2852 date = localtime(&(message->time));
2853 strftime(end, sizeof(end), "%X", date);
2854
2855 snprintf(temp, sizeof(temp),
2856 "[Job %d] The following messages were recorded from %s to %s",
2857 job->id, start, end);
2858 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2859
2860 for (message = (cupsd_joblog_t *)cupsArrayFirst(job->history);
2861 message;
2862 message = (cupsd_joblog_t *)cupsArrayNext(job->history))
2863 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, message->message);
2864
2865 snprintf(temp, sizeof(temp), "[Job %d] End of messages", job->id);
2866 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2867
2868 /*
2869 * Log the printer state values...
2870 */
2871
2872 if ((printer = job->printer) == NULL)
2873 printer = cupsdFindDest(job->dest);
2874
2875 if (printer)
2876 {
2877 snprintf(temp, sizeof(temp), "[Job %d] printer-state=%d(%s)", job->id,
2878 printer->state,
2879 printer->state == IPP_PRINTER_IDLE ? "idle" :
2880 printer->state == IPP_PRINTER_PROCESSING ? "processing" :
2881 "stopped");
2882 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2883
2884 snprintf(temp, sizeof(temp), "[Job %d] printer-state-message=\"%s\"",
2885 job->id, printer->state_message);
2886 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2887
2888 snprintf(temp, sizeof(temp), "[Job %d] printer-state-reasons=", job->id);
2889 ptr = temp + strlen(temp);
2890 if (printer->num_reasons == 0)
7e86f2f6 2891 strlcpy(ptr, "none", sizeof(temp) - (size_t)(ptr - temp));
178cb736
MS		 2892 else
2893 {
2894 for (i = 0;
2895 i < printer->num_reasons && ptr < (temp + sizeof(temp) - 2);
2896 i ++)
2897 {
2898 if (i)
2899 *ptr++ = ',';
2900
7e86f2f6 2901 strlcpy(ptr, printer->reasons[i], sizeof(temp) - (size_t)(ptr - temp));
178cb736
MS		 2902 ptr += strlen(ptr);
2903 }
2904 }
2905 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2906 }
2907
2908 /*
2909 * Restore log file rotation...
2910 */
2911
2912 MaxLogSize = oldsize;
2913
2914 /*
2915 * Free all messages...
2916 */
2917
2918 free_job_history(job);
2919}
2920
2921
2922/*
2923 * 'free_job_history()' - Free any log history.
2924 */
2925
2926static void
2927free_job_history(cupsd_job_t *job) /* I - Job */
2928{
2929 char *message; /* Current message */
2930
2931
2932 if (!job->history)
2933 return;
2934
2935 for (message = (char *)cupsArrayFirst(job->history);
2936 message;
2937 message = (char *)cupsArrayNext(job->history))
2938 free(message);
2939
2940 cupsArrayDelete(job->history);
2941 job->history = NULL;
2942}
2943
2944
b9faaae1
MS		 2945/*
2946 * 'finalize_job()' - Cleanup after job filter processes and support data.
2947 */
ef416fc2 2948
b9faaae1 2949static void
ef55b745
MS		 2950finalize_job(cupsd_job_t *job, /* I - Job */
2951 int set_job_state) /* I - 1 = set the job state */
b9faaae1
MS		 2952{
2953 ipp_pstate_t printer_state; /* New printer state value */
2954 ipp_jstate_t job_state; /* New job state value */
2955 const char *message; /* Message for job state */
2956 char buffer[1024]; /* Buffer for formatted messages */
e00b005a 2957
b9faaae1
MS		 2958
2959 cupsdLogMessage(CUPSD_LOG_DEBUG2, "finalize_job(job=%p(%d))", job, job->id);
ef416fc2 2960
e1d6a774 2961 /*
1e3e80bb
MS		 2962 * Clear the "connecting-to-device" and "cups-waiting-for-job-completed"
2963 * reasons, which are only valid when a printer is processing, along with any
2964 * remote printing job state...
e1d6a774 2965 */
ef416fc2 2966
07ed0e9a 2967 cupsdSetPrinterReasons(job->printer, "-connecting-to-device,"
1e3e80bb 2968 "cups-waiting-for-job-completed,"
07ed0e9a
MS		 2969 "cups-remote-pending,"
2970 "cups-remote-pending-held,"
2971 "cups-remote-processing,"
2972 "cups-remote-stopped,"
2973 "cups-remote-canceled,"
2974 "cups-remote-aborted,"
2975 "cups-remote-completed");
ef416fc2 2976
e1d6a774 2977 /*
b9faaae1
MS		 2978 * Similarly, clear the "offline-report" reason for non-USB devices since we
2979 * rarely have current information for network devices...
e1d6a774 2980 */
ef416fc2 2981
a469f8a5
MS		 2982 if (strncmp(job->printer->device_uri, "usb:", 4) &&
2983 strncmp(job->printer->device_uri, "ippusb:", 7))
b9faaae1 2984 cupsdSetPrinterReasons(job->printer, "-offline-report");
ef416fc2 2985
b9faaae1
MS		 2986 /*
2987 * Free the security profile...
2988 */
ef416fc2 2989
b9faaae1
MS		 2990 cupsdDestroyProfile(job->profile);
2991 job->profile = NULL;
8fe0183a
MS		 2992 cupsdDestroyProfile(job->bprofile);
2993 job->bprofile = NULL;
ef416fc2 2994
10d09e33 2995 /*
a469f8a5 2996 * Clear the unresponsive job watchdog timers...
10d09e33
MS		 2997 */
2998
a469f8a5
MS		 2999 job->cancel_time = 0;
3000 job->kill_time = 0;
10d09e33 3001
b9faaae1
MS		 3002 /*
3003 * Close pipes and status buffer...
3004 */
ef416fc2 3005
b9faaae1
MS		 3006 cupsdClosePipe(job->print_pipes);
3007 cupsdClosePipe(job->back_pipes);
3008 cupsdClosePipe(job->side_pipes);
ef416fc2 3009
e07d4801
MS		 3010 cupsdRemoveSelect(job->status_pipes[0]);
3011 cupsdClosePipe(job->status_pipes);
b9faaae1
MS		 3012 cupsdStatBufDelete(job->status_buffer);
3013 job->status_buffer = NULL;
ef416fc2 3014
e1d6a774 3015 /*
b9faaae1 3016 * Process the exit status...
e1d6a774 3017 */
ef416fc2 3018
1340db2d
MS		 3019 if (job->printer->state == IPP_PRINTER_PROCESSING)
3020 printer_state = IPP_PRINTER_IDLE;
3021 else
3022 printer_state = job->printer->state;
3023
3024 switch (job_state = job->state_value)
3025 {
3026 case IPP_JOB_PENDING :
3027 message = "Job paused.";
3028 break;
3029
3030 case IPP_JOB_HELD :
3031 message = "Job held.";
3032 break;
3033
3034 default :
3035 case IPP_JOB_PROCESSING :
3036 case IPP_JOB_COMPLETED :
f11a948a
MS		 3037 job_state = IPP_JOB_COMPLETED;
3038 message = "Job completed.";
12f89d24 3039
6961465f
MS		 3040 if (!job->status)
3041 ippSetString(job->attrs, &job->reasons, 0,
3042 "job-completed-successfully");
1340db2d
MS		 3043 break;
3044
3045 case IPP_JOB_STOPPED :
3046 message = "Job stopped.";
12f89d24
MS		 3047
3048 ippSetString(job->attrs, &job->reasons, 0, "job-stopped");
1340db2d
MS		 3049 break;
3050
3051 case IPP_JOB_CANCELED :
3052 message = "Job canceled.";
12f89d24
MS		 3053
3054 ippSetString(job->attrs, &job->reasons, 0, "job-canceled-by-user");
1340db2d
MS		 3055 break;
3056
3057 case IPP_JOB_ABORTED :
3058 message = "Job aborted.";
3059 break;
3060 }
ef416fc2 3061
b9faaae1 3062 if (job->status < 0)
e1d6a774 3063 {
3064 /*
b9faaae1 3065 * Backend had errors...
e1d6a774 3066 */
ef416fc2 3067
b9faaae1
MS		 3068 int exit_code; /* Exit code from backend */
3069
e1d6a774 3070 /*
b9faaae1
MS		 3071 * Convert the status to an exit code. Due to the way the W* macros are
3072 * implemented on MacOS X (bug?), we have to store the exit status in a
3073 * variable first and then convert...
e1d6a774 3074 */
ef416fc2 3075
b9faaae1
MS		 3076 exit_code = -job->status;
3077 if (WIFEXITED(exit_code))
3078 exit_code = WEXITSTATUS(exit_code);
3079 else
12f89d24
MS		 3080 {
3081 ippSetString(job->attrs, &job->reasons, 0, "cups-backend-crashed");
b9faaae1 3082 exit_code = job->status;
12f89d24 3083 }
ef416fc2 3084
b9faaae1
MS		 3085 cupsdLogJob(job, CUPSD_LOG_INFO, "Backend returned status %d (%s)",
3086 exit_code,
3087 exit_code == CUPS_BACKEND_FAILED ? "failed" :
3088 exit_code == CUPS_BACKEND_AUTH_REQUIRED ?
3089 "authentication required" :
3090 exit_code == CUPS_BACKEND_HOLD ? "hold job" :
3091 exit_code == CUPS_BACKEND_STOP ? "stop printer" :
3092 exit_code == CUPS_BACKEND_CANCEL ? "cancel job" :
a469f8a5
MS		 3093 exit_code == CUPS_BACKEND_RETRY ? "retry job later" :
3094 exit_code == CUPS_BACKEND_RETRY_CURRENT ? "retry job immediately" :
b9faaae1 3095 exit_code < 0 ? "crashed" : "unknown");
ef416fc2 3096
ef416fc2 3097 /*
b9faaae1 3098 * Do what needs to be done...
ef416fc2 3099 */
3100
b9faaae1 3101 switch (exit_code)
f7deaa1a 3102 {
b9faaae1
MS		 3103 default :
3104 case CUPS_BACKEND_FAILED :
3105 /*
3106 * Backend failure, use the error-policy to determine how to
3107 * act...
3108 */
f7deaa1a 3109
a2326b5b 3110 if (job->dtype & CUPS_PRINTER_CLASS)
b9faaae1
MS		 3111 {
3112 /*
3113 * Queued on a class - mark the job as pending and we'll retry on
3114 * another printer...
3115 */
f7deaa1a 3116
8b116e60
MS		 3117 if (job_state == IPP_JOB_COMPLETED)
3118 {
3119 job_state = IPP_JOB_PENDING;
3120 message = "Retrying job on another printer.";
12f89d24
MS		 3121
3122 ippSetString(job->attrs, &job->reasons, 0,
3123 "resources-are-not-ready");
8b116e60 3124 }
b9faaae1
MS		 3125 }
3126 else if (!strcmp(job->printer->error_policy, "retry-current-job"))
3127 {
3128 /*
3129 * The error policy is "retry-current-job" - mark the job as pending
3130 * and we'll retry on the same printer...
3131 */
f7deaa1a 3132
8b116e60
MS		 3133 if (job_state == IPP_JOB_COMPLETED)
3134 {
3135 job_state = IPP_JOB_PENDING;
3136 message = "Retrying job on same printer.";
12f89d24
MS		 3137
3138 ippSetString(job->attrs, &job->reasons, 0, "none");
8b116e60 3139 }
b9faaae1
MS		 3140 }
3141 else if ((job->printer->type & CUPS_PRINTER_FAX) ||
3142 !strcmp(job->printer->error_policy, "retry-job"))
3143 {
8b116e60 3144 if (job_state == IPP_JOB_COMPLETED)
b9faaae1
MS		 3145 {
3146 /*
8b116e60
MS		 3147 * The job was queued on a fax or the error policy is "retry-job" -
3148 * hold the job if the number of retries is less than the
3149 * JobRetryLimit, otherwise abort the job.
b9faaae1 3150 */
ef416fc2 3151
8b116e60
MS		 3152 job->tries ++;
3153
7cf5915e 3154 if (job->tries > JobRetryLimit && JobRetryLimit > 0)
8b116e60
MS		 3155 {
3156 /*
3157 * Too many tries...
3158 */
3159
3160 snprintf(buffer, sizeof(buffer),
3161 "Job aborted after %d unsuccessful attempts.",
3162 JobRetryLimit);
3163 job_state = IPP_JOB_ABORTED;
3164 message = buffer;
12f89d24
MS		 3165
3166 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
8b116e60
MS		 3167 }
3168 else
3169 {
3170 /*
3171 * Try again in N seconds...
3172 */
ef416fc2 3173
8b116e60
MS		 3174 snprintf(buffer, sizeof(buffer),
3175 "Job held for %d seconds since it could not be sent.",
3176 JobRetryInterval);
0268488e
MS		 3177
3178 job->hold_until = time(NULL) + JobRetryInterval;
3179 job_state = IPP_JOB_HELD;
3180 message = buffer;
12f89d24
MS		 3181
3182 ippSetString(job->attrs, &job->reasons, 0,
3183 "resources-are-not-ready");
8b116e60
MS		 3184 }
3185 }
b9faaae1 3186 }
8b116e60
MS		 3187 else if (!strcmp(job->printer->error_policy, "abort-job") &&
3188 job_state == IPP_JOB_COMPLETED)
b9faaae1
MS		 3189 {
3190 job_state = IPP_JOB_ABORTED;
3191 message = "Job aborted due to backend errors; please consult "
3192 "the error_log file for details.";
12f89d24
MS		 3193
3194 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
b9faaae1 3195 }
f11a948a 3196 else if (job->state_value == IPP_JOB_PROCESSING)
b9faaae1 3197 {
f11a948a 3198 job_state = IPP_JOB_PENDING;
b9faaae1 3199 printer_state = IPP_PRINTER_STOPPED;
b9faaae1 3200 message = "Printer stopped due to backend errors; please "
8b116e60 3201 "consult the error_log file for details.";
12f89d24
MS		 3202
3203 ippSetString(job->attrs, &job->reasons, 0, "none");
b9faaae1
MS		 3204 }
3205 break;
bd7854cb 3206
b9faaae1
MS		 3207 case CUPS_BACKEND_CANCEL :
3208 /*
f3c17241 3209 * Cancel the job...
b9faaae1 3210 */
bd7854cb 3211
8b116e60
MS		 3212 if (job_state == IPP_JOB_COMPLETED)
3213 {
f3c17241
MS		 3214 job_state = IPP_JOB_CANCELED;
3215 message = "Job canceled at printer.";
12f89d24 3216
f3c17241 3217 ippSetString(job->attrs, &job->reasons, 0, "canceled-at-device");
8b116e60 3218 }
b9faaae1 3219 break;
bd7854cb 3220
b9faaae1 3221 case CUPS_BACKEND_HOLD :
8b116e60
MS		 3222 if (job_state == IPP_JOB_COMPLETED)
3223 {
3224 /*
3225 * Hold the job...
3226 */
bd7854cb 3227
6961465f 3228 const char *reason = ippGetString(job->reasons, 0, NULL);
bd7854cb 3229
6961465f
MS		 3230 cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-state-reasons=\"%s\"",
3231 reason);
3232
3233 if (!reason || strncmp(reason, "account-", 8))
3234 {
3235 cupsdSetJobHoldUntil(job, "indefinite", 1);
3236
3237 ippSetString(job->attrs, &job->reasons, 0,
3238 "job-hold-until-specified");
3239 message = "Job held indefinitely due to backend errors; please "
8b116e60 3240 "consult the error_log file for details.";
6961465f
MS		 3241 }
3242 else if (!strcmp(reason, "account-info-needed"))
3243 {
3244 cupsdSetJobHoldUntil(job, "indefinite", 0);
3245
3246 message = "Job held indefinitely - account information is "
3247 "required.";
3248 }
3249 else if (!strcmp(reason, "account-closed"))
3250 {
3251 cupsdSetJobHoldUntil(job, "indefinite", 0);
3252
3253 message = "Job held indefinitely - account has been closed.";
3254 }
3255 else if (!strcmp(reason, "account-limit-reached"))
3256 {
3257 cupsdSetJobHoldUntil(job, "indefinite", 0);
3258
3259 message = "Job held indefinitely - account limit has been "
3260 "reached.";
3261 }
3262 else
3263 {
3264 cupsdSetJobHoldUntil(job, "indefinite", 0);
3265
3266 message = "Job held indefinitely - account authorization failed.";
3267 }
3268
3269 job_state = IPP_JOB_HELD;
8b116e60 3270 }
b9faaae1 3271 break;
2abf387c 3272
b9faaae1
MS		 3273 case CUPS_BACKEND_STOP :
3274 /*
3275 * Stop the printer...
3276 */
bd7854cb 3277
b9faaae1 3278 printer_state = IPP_PRINTER_STOPPED;
b9faaae1
MS		 3279 message = "Printer stopped due to backend errors; please "
3280 "consult the error_log file for details.";
8b116e60
MS		 3281
3282 if (job_state == IPP_JOB_COMPLETED)
12f89d24 3283 {
8b116e60 3284 job_state = IPP_JOB_PENDING;
12f89d24
MS		 3285
3286 ippSetString(job->attrs, &job->reasons, 0,
3287 "resources-are-not-ready");
3288 }
b9faaae1 3289 break;
bd7854cb 3290
b9faaae1
MS		 3291 case CUPS_BACKEND_AUTH_REQUIRED :
3292 /*
3293 * Hold the job for authentication...
3294 */
bd7854cb 3295
8b116e60
MS		 3296 if (job_state == IPP_JOB_COMPLETED)
3297 {
3298 cupsdSetJobHoldUntil(job, "auth-info-required", 1);
ef416fc2 3299
8b116e60
MS		 3300 job_state = IPP_JOB_HELD;
3301 message = "Job held for authentication.";
12f89d24 3302
a469f8a5
MS		 3303 if (strncmp(job->reasons->values[0].string.text, "account-", 8))
3304 ippSetString(job->attrs, &job->reasons, 0,
3305 "cups-held-for-authentication");
8b116e60 3306 }
b9faaae1 3307 break;
22c9029b
MS		 3308
3309 case CUPS_BACKEND_RETRY :
3310 if (job_state == IPP_JOB_COMPLETED)
3311 {
3312 /*
3313 * Hold the job if the number of retries is less than the
3314 * JobRetryLimit, otherwise abort the job.
3315 */
3316
3317 job->tries ++;
3318
3319 if (job->tries > JobRetryLimit && JobRetryLimit > 0)
3320 {
3321 /*
3322 * Too many tries...
3323 */
3324
3325 snprintf(buffer, sizeof(buffer),
3326 "Job aborted after %d unsuccessful attempts.",
3327 JobRetryLimit);
3328 job_state = IPP_JOB_ABORTED;
3329 message = buffer;
12f89d24
MS		 3330
3331 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
22c9029b
MS		 3332 }
3333 else
3334 {
3335 /*
3336 * Try again in N seconds...
3337 */
3338
3339 snprintf(buffer, sizeof(buffer),
3340 "Job held for %d seconds since it could not be sent.",
3341 JobRetryInterval);
3342
3343 job->hold_until = time(NULL) + JobRetryInterval;
3344 job_state = IPP_JOB_HELD;
3345 message = buffer;
12f89d24
MS		 3346
3347 ippSetString(job->attrs, &job->reasons, 0,
3348 "resources-are-not-ready");
22c9029b
MS		 3349 }
3350 }
3351 break;
3352
3353 case CUPS_BACKEND_RETRY_CURRENT :
3354 /*
3355 * Mark the job as pending and retry on the same printer...
3356 */
3357
3358 if (job_state == IPP_JOB_COMPLETED)
3359 {
3360 job_state = IPP_JOB_PENDING;
3361 message = "Retrying job on same printer.";
12f89d24
MS		 3362
3363 ippSetString(job->attrs, &job->reasons, 0, "none");
22c9029b
MS		 3364 }
3365 break;
e1d6a774 3366 }
3367 }
b9faaae1 3368 else if (job->status > 0)
ef416fc2 3369 {
3370 /*
b9faaae1 3371 * Filter had errors; stop job...
ef416fc2 3372 */
3373
8b116e60
MS		 3374 if (job_state == IPP_JOB_COMPLETED)
3375 {
3376 job_state = IPP_JOB_STOPPED;
3377 message = "Job stopped due to filter errors; please consult the "
3378 "error_log file for details.";
12f89d24
MS		 3379
3380 if (WIFSIGNALED(job->status))
3381 ippSetString(job->attrs, &job->reasons, 0, "cups-filter-crashed");
3382 else
3383 ippSetString(job->attrs, &job->reasons, 0, "job-completed-with-errors");
8b116e60 3384 }
e1d6a774 3385 }
e00b005a 3386
3dfe78b3 3387 /*
b9faaae1 3388 * Update the printer and job state.
3dfe78b3
MS		 3389 */
3390
321d8d57 3391 if (set_job_state && job_state != job->state_value)
ef55b745
MS		 3392 cupsdSetJobState(job, job_state, CUPSD_JOB_DEFAULT, "%s", message);
3393
b9faaae1
MS		 3394 cupsdSetPrinterState(job->printer, printer_state,
3395 printer_state == IPP_PRINTER_STOPPED);
3396 update_job_attrs(job, 0);
3dfe78b3 3397
178cb736
MS		 3398 if (job->history)
3399 {
a4845881
MS		 3400 if (job->status &&
3401 (job->state_value == IPP_JOB_ABORTED ||
3402 job->state_value == IPP_JOB_STOPPED))
178cb736
MS		 3403 dump_job_history(job);
3404 else
3405 free_job_history(job);
3406 }
3407
b9faaae1 3408 cupsArrayRemove(PrintingJobs, job);
3dfe78b3 3409
a29fd7dd
MS		 3410 /*
3411 * Apply any PPD updates...
3412 */
3413
3414 if (job->num_keywords)
3415 {
3416 if (cupsdUpdatePrinterPPD(job->printer, job->num_keywords, job->keywords))
3417 cupsdSetPrinterAttrs(job->printer);
3418
3419 cupsFreeOptions(job->num_keywords, job->keywords);
3420
3421 job->num_keywords = 0;
3422 job->keywords = NULL;
3423 }
3424
e1d6a774 3425 /*
b9faaae1 3426 * Clear the printer <-> job association...
e1d6a774 3427 */
ef416fc2 3428
b9faaae1
MS		 3429 job->printer->job = NULL;
3430 job->printer = NULL;
ef416fc2 3431
e1d6a774 3432 /*
b9faaae1 3433 * Try printing another job...
e1d6a774 3434 */
ef416fc2 3435
b9faaae1
MS		 3436 if (printer_state != IPP_PRINTER_STOPPED)
3437 cupsdCheckJobs();
3438}
ef416fc2 3439
ef416fc2 3440
b9faaae1
MS		 3441/*
3442 * 'get_options()' - Get a string containing the job options.
3443 */
3444
3445static char * /* O - Options string */
3446get_options(cupsd_job_t *job, /* I - Job */
3447 int banner_page, /* I - Printing a banner page? */
3448 char *copies, /* I - Copies buffer */
3449 size_t copies_size, /* I - Size of copies buffer */
3450 char *title, /* I - Title buffer */
3451 size_t title_size) /* I - Size of title buffer */
3452{
3453 int i; /* Looping var */
c7017ecc 3454 size_t newlength; /* New option buffer length */
b9faaae1
MS		 3455 char *optptr, /* Pointer to options */
3456 *valptr; /* Pointer in value string */
3457 ipp_attribute_t *attr; /* Current attribute */
f14324a7 3458 _ppd_cache_t *pc; /* PPD cache and mapping data */
c7017ecc
MS		 3459 int num_pwgppds; /* Number of PWG->PPD options */
3460 cups_option_t *pwgppds, /* PWG->PPD options */
3461 *pwgppd, /* Current PWG->PPD option */
3462 *preset; /* Current preset option */
f14324a7
MS		 3463 int print_color_mode,
3464 /* Output mode (if any) */
c7017ecc
MS		 3465 print_quality; /* Print quality (if any) */
3466 const char *ppd; /* PPD option choice */
3467 int exact; /* Did we get an exact match? */
b9faaae1 3468 static char *options = NULL;/* Full list of options */
c7017ecc 3469 static size_t optlength = 0; /* Length of option buffer */
b9faaae1 3470
ef416fc2 3471
e1d6a774 3472 /*
c7017ecc
MS		 3473 * Building the options string is harder than it needs to be, but for the
3474 * moment we need to pass strings for command-line args and not IPP attribute
3475 * pointers... :)
e1d6a774 3476 *
c7017ecc 3477 * First build an options array for any PWG->PPD mapped option/choice pairs.
e1d6a774 3478 */
ef416fc2 3479
f14324a7 3480 pc = job->printer->pc;
c7017ecc
MS		 3481 num_pwgppds = 0;
3482 pwgppds = NULL;
ef416fc2 3483
f14324a7 3484 if (pc &&
7cf5915e
MS		 3485 !ippFindAttribute(job->attrs,
3486 "com.apple.print.DocumentTicket.PMSpoolFormat",
3487 IPP_TAG_ZERO) &&
0268488e 3488 !ippFindAttribute(job->attrs, "APPrinterPreset", IPP_TAG_ZERO) &&
5a9febac 3489 (ippFindAttribute(job->attrs, "print-color-mode", IPP_TAG_ZERO) ||
7cf5915e 3490 ippFindAttribute(job->attrs, "print-quality", IPP_TAG_ZERO)))
c7017ecc 3491 {
7cf5915e 3492 /*
5a9febac 3493 * Map print-color-mode and print-quality to a preset...
7cf5915e
MS		 3494 */
3495
f14324a7 3496 if ((attr = ippFindAttribute(job->attrs, "print-color-mode",
5a9febac
MS		 3497 IPP_TAG_KEYWORD)) != NULL &&
3498 !strcmp(attr->values[0].string.text, "monochrome"))
f14324a7 3499 print_color_mode = _PWG_PRINT_COLOR_MODE_MONOCHROME;
c7017ecc 3500 else
f14324a7 3501 print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
c7017ecc
MS		 3502
3503 if ((attr = ippFindAttribute(job->attrs, "print-quality",
10d09e33 3504 IPP_TAG_ENUM)) != NULL &&
c7017ecc
MS		 3505 attr->values[0].integer >= IPP_QUALITY_DRAFT &&
3506 attr->values[0].integer <= IPP_QUALITY_HIGH)
3507 print_quality = attr->values[0].integer - IPP_QUALITY_DRAFT;
3508 else
030ae6a1 3509 print_quality = _PWG_PRINT_QUALITY_NORMAL;
c7017ecc 3510
f14324a7 3511 if (pc->num_presets[print_color_mode][print_quality] == 0)
c7017ecc
MS		 3512 {
3513 /*
3514 * Try to find a preset that works so that we maximize the chances of us
3515 * getting a good print using IPP attributes.
3516 */
3517
f14324a7 3518 if (pc->num_presets[print_color_mode][_PWG_PRINT_QUALITY_NORMAL] > 0)
c7017ecc 3519 print_quality = _PWG_PRINT_QUALITY_NORMAL;
f14324a7
MS		 3520 else if (pc->num_presets[_PWG_PRINT_COLOR_MODE_COLOR][print_quality] > 0)
3521 print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
c7017ecc
MS		 3522 else
3523 {
f14324a7
MS		 3524 print_quality = _PWG_PRINT_QUALITY_NORMAL;
3525 print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
c7017ecc
MS		 3526 }
3527 }
3528
f14324a7 3529 if (pc->num_presets[print_color_mode][print_quality] > 0)
c7017ecc
MS		 3530 {
3531 /*
3532 * Copy the preset options as long as the corresponding names are not
3533 * already defined in the IPP request...
3534 */
3535
f14324a7
MS		 3536 for (i = pc->num_presets[print_color_mode][print_quality],
3537 preset = pc->presets[print_color_mode][print_quality];
c7017ecc
MS		 3538 i > 0;
3539 i --, preset ++)
3540 {
3541 if (!ippFindAttribute(job->attrs, preset->name, IPP_TAG_ZERO))
3542 num_pwgppds = cupsAddOption(preset->name, preset->value, num_pwgppds,
3543 &pwgppds);
3544 }
3545 }
7cf5915e 3546 }
c7017ecc 3547
f14324a7 3548 if (pc)
7cf5915e 3549 {
4220952d
MS		 3550 if (!ippFindAttribute(job->attrs, "InputSlot", IPP_TAG_ZERO) &&
3551 !ippFindAttribute(job->attrs, "HPPaperSource", IPP_TAG_ZERO))
3552 {
f14324a7
MS		 3553 if ((ppd = _ppdCacheGetInputSlot(pc, job->attrs, NULL)) != NULL)
3554 num_pwgppds = cupsAddOption(pc->source_option, ppd, num_pwgppds,
4220952d 3555 &pwgppds);
4220952d 3556 }
4220952d 3557 if (!ippFindAttribute(job->attrs, "MediaType", IPP_TAG_ZERO) &&
f14324a7 3558 (ppd = _ppdCacheGetMediaType(pc, job->attrs, NULL)) != NULL)
4220952d 3559 num_pwgppds = cupsAddOption("MediaType", ppd, num_pwgppds, &pwgppds);
c7017ecc 3560
4220952d
MS		 3561 if (!ippFindAttribute(job->attrs, "PageRegion", IPP_TAG_ZERO) &&
3562 !ippFindAttribute(job->attrs, "PageSize", IPP_TAG_ZERO) &&
f14324a7 3563 (ppd = _ppdCacheGetPageSize(pc, job->attrs, NULL, &exact)) != NULL)
030ae6a1 3564 {
4220952d 3565 num_pwgppds = cupsAddOption("PageSize", ppd, num_pwgppds, &pwgppds);
c7017ecc 3566
030ae6a1
MS		 3567 if (!ippFindAttribute(job->attrs, "media", IPP_TAG_ZERO))
3568 num_pwgppds = cupsAddOption("media", ppd, num_pwgppds, &pwgppds);
3569 }
3570
4220952d
MS		 3571 if (!ippFindAttribute(job->attrs, "OutputBin", IPP_TAG_ZERO) &&
3572 (attr = ippFindAttribute(job->attrs, "output-bin",
3573 IPP_TAG_ZERO)) != NULL &&
3574 (attr->value_tag == IPP_TAG_KEYWORD ||
3575 attr->value_tag == IPP_TAG_NAME) &&
f14324a7 3576 (ppd = _ppdCacheGetOutputBin(pc, attr->values[0].string.text)) != NULL)
0268488e
MS		 3577 {
3578 /*
3579 * Map output-bin to OutputBin option...
3580 */
3581
4220952d 3582 num_pwgppds = cupsAddOption("OutputBin", ppd, num_pwgppds, &pwgppds);
0268488e
MS		 3583 }
3584
f14324a7
MS		 3585 if (pc->sides_option &&
3586 !ippFindAttribute(job->attrs, pc->sides_option, IPP_TAG_ZERO) &&
0268488e
MS		 3587 (attr = ippFindAttribute(job->attrs, "sides", IPP_TAG_KEYWORD)) != NULL)
3588 {
3589 /*
3590 * Map sides to duplex option...
3591 */
3592
3593 if (!strcmp(attr->values[0].string.text, "one-sided"))
f14324a7 3594 num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_1sided,
0268488e
MS		 3595 num_pwgppds, &pwgppds);
3596 else if (!strcmp(attr->values[0].string.text, "two-sided-long-edge"))
f14324a7 3597 num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_2sided_long,
0268488e
MS		 3598 num_pwgppds, &pwgppds);
3599 else if (!strcmp(attr->values[0].string.text, "two-sided-short-edge"))
f14324a7 3600 num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_2sided_short,
0268488e
MS		 3601 num_pwgppds, &pwgppds);
3602 }
dcb445bc
MS		 3603
3604 /*
3605 * Map finishings values...
3606 */
3607
3608 num_pwgppds = _ppdCacheGetFinishingOptions(pc, job->attrs,
3609 IPP_FINISHINGS_NONE, num_pwgppds,
3610 &pwgppds);
4220952d 3611 }
c7017ecc
MS		 3612
3613 /*
3614 * Figure out how much room we need...
3615 */
3616
3617 newlength = ipp_length(job->attrs);
3618
3619 for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
3620 newlength += 1 + strlen(pwgppd->name) + 1 + strlen(pwgppd->value);
3621
3622 /*
3623 * Then allocate/reallocate the option buffer as needed...
3624 */
3625
85dda01c
MS		 3626 if (newlength == 0) /* This can never happen, but Clang */
3627 newlength = 1; /* thinks it can... */
3628
c7017ecc 3629 if (newlength > optlength || !options)
e1d6a774 3630 {
b9faaae1 3631 if (!options)
c7017ecc 3632 optptr = malloc(newlength);
e1d6a774 3633 else
c7017ecc 3634 optptr = realloc(options, newlength);
ef416fc2 3635
b9faaae1 3636 if (!optptr)
e1d6a774 3637 {
75bd9771 3638 cupsdLogJob(job, CUPSD_LOG_CRIT,
12f89d24 3639 "Unable to allocate " CUPS_LLFMT " bytes for option buffer.",
c7017ecc 3640 CUPS_LLCAST newlength);
b9faaae1 3641 return (NULL);
e1d6a774 3642 }
ef416fc2 3643
e1d6a774 3644 options = optptr;
c7017ecc 3645 optlength = newlength;
e1d6a774 3646 }
ef416fc2 3647
e1d6a774 3648 /*
3649 * Now loop through the attributes and convert them to the textual
3650 * representation used by the filters...
3651 */
ef416fc2 3652
e1d6a774 3653 optptr = options;
3654 *optptr = '\0';
bd7854cb 3655
1340db2d
MS		 3656 snprintf(title, title_size, "%s-%d", job->printer->name, job->id);
3657 strlcpy(copies, "1", copies_size);
bd7854cb 3658
e1d6a774 3659 for (attr = job->attrs->attrs; attr != NULL; attr = attr->next)
bd7854cb 3660 {
e1d6a774 3661 if (!strcmp(attr->name, "copies") &&
3662 attr->value_tag == IPP_TAG_INTEGER)
3663 {
3664 /*
3665 * Don't use the # copies attribute if we are printing the job sheets...
3666 */
bd7854cb 3667
e1d6a774 3668 if (!banner_page)
1340db2d 3669 snprintf(copies, copies_size, "%d", attr->values[0].integer);
e1d6a774 3670 }
3671 else if (!strcmp(attr->name, "job-name") &&
3672 (attr->value_tag == IPP_TAG_NAME ||
3673 attr->value_tag == IPP_TAG_NAMELANG))
1340db2d 3674 strlcpy(title, attr->values[0].string.text, title_size);
e1d6a774 3675 else if (attr->group_tag == IPP_TAG_JOB)
3676 {
3677 /*
3678 * Filter out other unwanted attributes...
3679 */
bd7854cb 3680
c7017ecc
MS		 3681 if (attr->value_tag == IPP_TAG_NOVALUE ||
3682 attr->value_tag == IPP_TAG_MIMETYPE ||
e1d6a774 3683 attr->value_tag == IPP_TAG_NAMELANG ||
3684 attr->value_tag == IPP_TAG_TEXTLANG ||
db8b865d
MS		 3685 (attr->value_tag == IPP_TAG_URI && strcmp(attr->name, "job-uuid") &&
3686 strcmp(attr->name, "job-authorization-uri")) ||
e1d6a774 3687 attr->value_tag == IPP_TAG_URISCHEME ||
3688 attr->value_tag == IPP_TAG_BEGIN_COLLECTION) /* Not yet supported */
3689 continue;
bd7854cb 3690
5a9febac
MS		 3691 if (!strcmp(attr->name, "job-hold-until") ||
3692 !strcmp(attr->name, "job-id") ||
3693 !strcmp(attr->name, "job-k-octets") ||
3694 !strcmp(attr->name, "job-media-sheets") ||
3695 !strcmp(attr->name, "job-media-sheets-completed") ||
3696 !strcmp(attr->name, "job-state") ||
3697 !strcmp(attr->name, "job-state-reasons"))
e1d6a774 3698 continue;
bd7854cb 3699
e1d6a774 3700 if (!strncmp(attr->name, "job-", 4) &&
5a9febac
MS		 3701 strcmp(attr->name, "job-account-id") &&
3702 strcmp(attr->name, "job-accounting-user-id") &&
a469f8a5 3703 strcmp(attr->name, "job-authorization-uri") &&
e4572d57 3704 strcmp(attr->name, "job-billing") &&
5d6412a9 3705 strcmp(attr->name, "job-impressions") &&
c5571a1d 3706 strcmp(attr->name, "job-originating-host-name") &&
5a9febac 3707 strcmp(attr->name, "job-password") &&
a469f8a5 3708 strcmp(attr->name, "job-password-encryption") &&
e4572d57 3709 strcmp(attr->name, "job-uuid") &&
b9faaae1 3710 !(job->printer->type & CUPS_PRINTER_REMOTE))
e1d6a774 3711 continue;
ef416fc2 3712
5d6412a9
MS		 3713 if ((!strcmp(attr->name, "job-impressions") ||
3714 !strcmp(attr->name, "page-label") ||
e1d6a774 3715 !strcmp(attr->name, "page-border") ||
3716 !strncmp(attr->name, "number-up", 9) ||
b94498cf 3717 !strcmp(attr->name, "page-ranges") ||
e1d6a774 3718 !strcmp(attr->name, "page-set") ||
88f9aafc
MS		 3719 !_cups_strcasecmp(attr->name, "AP_FIRSTPAGE_InputSlot") ||
3720 !_cups_strcasecmp(attr->name, "AP_FIRSTPAGE_ManualFeed") ||
3721 !_cups_strcasecmp(attr->name, "com.apple.print.PrintSettings."
db1f069b 3722 "PMTotalSidesImaged..n.") ||
88f9aafc 3723 !_cups_strcasecmp(attr->name, "com.apple.print.PrintSettings."
db1f069b 3724 "PMTotalBeginPages..n.")) &&
e1d6a774 3725 banner_page)
3726 continue;
ef416fc2 3727
e1d6a774 3728 /*
3729 * Otherwise add them to the list...
3730 */
ef416fc2 3731
e1d6a774 3732 if (optptr > options)
7e86f2f6 3733 strlcat(optptr, " ", optlength - (size_t)(optptr - options));
ef416fc2 3734
e1d6a774 3735 if (attr->value_tag != IPP_TAG_BOOLEAN)
3736 {
7e86f2f6
MS		 3737 strlcat(optptr, attr->name, optlength - (size_t)(optptr - options));
3738 strlcat(optptr, "=", optlength - (size_t)(optptr - options));
e1d6a774 3739 }
ef416fc2 3740
e1d6a774 3741 for (i = 0; i < attr->num_values; i ++)
3742 {
3743 if (i)
7e86f2f6 3744 strlcat(optptr, ",", optlength - (size_t)(optptr - options));
ef416fc2 3745
e1d6a774 3746 optptr += strlen(optptr);
ef416fc2 3747
e1d6a774 3748 switch (attr->value_tag)
3749 {
3750 case IPP_TAG_INTEGER :
3751 case IPP_TAG_ENUM :
7e86f2f6 3752 snprintf(optptr, optlength - (size_t)(optptr - options),
e1d6a774 3753 "%d", attr->values[i].integer);
3754 break;
ef416fc2 3755
e1d6a774 3756 case IPP_TAG_BOOLEAN :
3757 if (!attr->values[i].boolean)
7e86f2f6 3758 strlcat(optptr, "no", optlength - (size_t)(optptr - options));
ef416fc2 3759
7e86f2f6 3760 strlcat(optptr, attr->name, optlength - (size_t)(optptr - options));
4220952d
MS		 3761 break;
3762
e1d6a774 3763 case IPP_TAG_RANGE :
3764 if (attr->values[i].range.lower == attr->values[i].range.upper)
7e86f2f6 3765 snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
e1d6a774 3766 "%d", attr->values[i].range.lower);
3767 else
7e86f2f6 3768 snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
e1d6a774 3769 "%d-%d", attr->values[i].range.lower,
3770 attr->values[i].range.upper);
3771 break;
ef416fc2 3772
e1d6a774 3773 case IPP_TAG_RESOLUTION :
7e86f2f6 3774 snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
e1d6a774 3775 "%dx%d%s", attr->values[i].resolution.xres,
3776 attr->values[i].resolution.yres,
3777 attr->values[i].resolution.units == IPP_RES_PER_INCH ?
3e7fe0ca 3778 "dpi" : "dpcm");
e1d6a774 3779 break;
ef416fc2 3780
e1d6a774 3781 case IPP_TAG_STRING :
3782 case IPP_TAG_TEXT :
3783 case IPP_TAG_NAME :
3784 case IPP_TAG_KEYWORD :
3785 case IPP_TAG_CHARSET :
3786 case IPP_TAG_LANGUAGE :
3787 case IPP_TAG_URI :
3788 for (valptr = attr->values[i].string.text; *valptr;)
3789 {
3790 if (strchr(" \t\n\\\'\"", *valptr))
3791 *optptr++ = '\\';
3792 *optptr++ = *valptr++;
3793 }
3794
3795 *optptr = '\0';
3796 break;
3797
3798 default :
3799 break; /* anti-compiler-warning-code */
3800 }
3801 }
3802
3803 optptr += strlen(optptr);
3804 }
3805 }
3806
c7017ecc
MS		 3807 /*
3808 * Finally loop through the PWG->PPD mapped options and add them...
3809 */
3810
3811 for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
3812 {
3813 *optptr++ = ' ';
7e86f2f6 3814 strlcpy(optptr, pwgppd->name, optlength - (size_t)(optptr - options));
c7017ecc
MS		 3815 optptr += strlen(optptr);
3816 *optptr++ = '=';
7e86f2f6 3817 strlcpy(optptr, pwgppd->value, optlength - (size_t)(optptr - options));
c7017ecc
MS		 3818 optptr += strlen(optptr);
3819 }
3820
3821 cupsFreeOptions(num_pwgppds, pwgppds);
3822
3823 /*
3824 * Return the options string...
3825 */
b9faaae1
MS		 3826
3827 return (options);
3828}
3829
3830
3831/*
3832 * 'ipp_length()' - Compute the size of the buffer needed to hold
3833 * the textual IPP attributes.
3834 */
3835
c7017ecc 3836static size_t /* O - Size of attribute buffer */
b9faaae1
MS		 3837ipp_length(ipp_t *ipp) /* I - IPP request */
3838{
c7017ecc 3839 size_t bytes; /* Number of bytes */
b9faaae1
MS		 3840 int i; /* Looping var */
3841 ipp_attribute_t *attr; /* Current attribute */
3842
3843
3844 /*
3845 * Loop through all attributes...
e1d6a774 3846 */
3847
b9faaae1 3848 bytes = 0;
e1d6a774 3849
b9faaae1 3850 for (attr = ipp->attrs; attr != NULL; attr = attr->next)
91c84a35 3851 {
b9faaae1
MS		 3852 /*
3853 * Skip attributes that won't be sent to filters...
3854 */
91c84a35 3855
c7017ecc
MS		 3856 if (attr->value_tag == IPP_TAG_NOVALUE ||
3857 attr->value_tag == IPP_TAG_MIMETYPE ||
b9faaae1
MS		 3858 attr->value_tag == IPP_TAG_NAMELANG ||
3859 attr->value_tag == IPP_TAG_TEXTLANG ||
3860 attr->value_tag == IPP_TAG_URI ||
3861 attr->value_tag == IPP_TAG_URISCHEME)
3862 continue;
91c84a35 3863
b9faaae1
MS		 3864 /*
3865 * Add space for a leading space and commas between each value.
3866 * For the first attribute, the leading space isn't used, so the
3867 * extra byte can be used as the nul terminator...
3868 */
e1d6a774 3869
b9faaae1 3870 bytes ++; /* " " separator */
7e86f2f6 3871 bytes += (size_t)attr->num_values; /* "," separators */
e1d6a774 3872
b9faaae1
MS		 3873 /*
3874 * Boolean attributes appear as "foo,nofoo,foo,nofoo", while
3875 * other attributes appear as "foo=value1,value2,...,valueN".
3876 */
3877
3878 if (attr->value_tag != IPP_TAG_BOOLEAN)
3879 bytes += strlen(attr->name);
3880 else
7e86f2f6 3881 bytes += (size_t)attr->num_values * strlen(attr->name);
b9faaae1
MS		 3882
3883 /*
3884 * Now add the size required for each value in the attribute...
3885 */
3886
3887 switch (attr->value_tag)
ef416fc2 3888 {
b9faaae1
MS		 3889 case IPP_TAG_INTEGER :
3890 case IPP_TAG_ENUM :
3891 /*
3892 * Minimum value of a signed integer is -2147483647, or 11 digits.
3893 */
3894
7e86f2f6 3895 bytes += (size_t)attr->num_values * 11;
b9faaae1
MS		 3896 break;
3897
3898 case IPP_TAG_BOOLEAN :
3899 /*
3900 * Add two bytes for each false ("no") value...
3901 */
3902
3903 for (i = 0; i < attr->num_values; i ++)
3904 if (!attr->values[i].boolean)
3905 bytes += 2;
3906 break;
3907
3908 case IPP_TAG_RANGE :
3909 /*
3910 * A range is two signed integers separated by a hyphen, or
3911 * 23 characters max.
3912 */
3913
7e86f2f6 3914 bytes += (size_t)attr->num_values * 23;
b9faaae1
MS		 3915 break;
3916
3917 case IPP_TAG_RESOLUTION :
3918 /*
3919 * A resolution is two signed integers separated by an "x" and
3920 * suffixed by the units, or 26 characters max.
3921 */
3922
7e86f2f6 3923 bytes += (size_t)attr->num_values * 26;
b9faaae1
MS		 3924 break;
3925
3926 case IPP_TAG_STRING :
3927 case IPP_TAG_TEXT :
3928 case IPP_TAG_NAME :
3929 case IPP_TAG_KEYWORD :
3930 case IPP_TAG_CHARSET :
3931 case IPP_TAG_LANGUAGE :
3932 case IPP_TAG_URI :
3933 /*
3934 * Strings can contain characters that need quoting. We need
3935 * at least 2 * len + 2 characters to cover the quotes and
3936 * any backslashes in the string.
3937 */
3938
3939 for (i = 0; i < attr->num_values; i ++)
3940 bytes += 2 * strlen(attr->values[i].string.text) + 2;
3941 break;
3942
3943 default :
3944 break; /* anti-compiler-warning-code */
e1d6a774 3945 }
3946 }
b9faaae1
MS		 3947
3948 return (bytes);
3949}
3950
3951
3952/*
3953 * 'load_job_cache()' - Load jobs from the job.cache file.
3954 */
3955
3956static void
3957load_job_cache(const char *filename) /* I - job.cache filename */
3958{
3959 cups_file_t *fp; /* job.cache file */
3960 char line[1024], /* Line buffer */
3961 *value; /* Value on line */
3962 int linenum; /* Line number in file */
3963 cupsd_job_t *job; /* Current job */
3964 int jobid; /* Job ID */
3965 char jobfile[1024]; /* Job filename */
3966
3967
3968 /*
3969 * Open the job.cache file...
3970 */
3971
321d8d57 3972 if ((fp = cupsdOpenConfFile(filename)) == NULL)
e1d6a774 3973 {
b9faaae1 3974 load_request_root();
b9faaae1
MS		 3975 return;
3976 }
ef416fc2 3977
e1d6a774 3978 /*
b9faaae1 3979 * Read entries from the job cache file and create jobs as needed.
e1d6a774 3980 */
ef416fc2 3981
b9faaae1
MS		 3982 cupsdLogMessage(CUPSD_LOG_INFO, "Loading job cache file \"%s\"...",
3983 filename);
ef416fc2 3984
b9faaae1
MS		 3985 linenum = 0;
3986 job = NULL;
3987
3988 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
3989 {
88f9aafc 3990 if (!_cups_strcasecmp(line, "NextJobId"))
b9faaae1
MS		 3991 {
3992 if (value)
3993 NextJobId = atoi(value);
3994 }
88f9aafc 3995 else if (!_cups_strcasecmp(line, "<Job"))
b9faaae1
MS		 3996 {
3997 if (job)
3998 {
12f89d24 3999 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing </Job> directive on line %d.",
b9faaae1
MS		 4000 linenum);
4001 continue;
4002 }
4003
4004 if (!value)
4005 {
12f89d24 4006 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing job ID on line %d.", linenum);
b9faaae1
MS		 4007 continue;
4008 }
4009
4010 jobid = atoi(value);
4011
4012 if (jobid < 1)
4013 {
12f89d24 4014 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad job ID %d on line %d.", jobid,
b9faaae1
MS		 4015 linenum);
4016 continue;
4017 }
4018
4019 snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, jobid);
4020 if (access(jobfile, 0))
4021 {
321d8d57
MS		 4022 snprintf(jobfile, sizeof(jobfile), "%s/c%05d.N", RequestRoot, jobid);
4023 if (access(jobfile, 0))
4024 {
12f89d24 4025 cupsdLogMessage(CUPSD_LOG_ERROR, "[Job %d] Files have gone away.",
321d8d57
MS		 4026 jobid);
4027 continue;
4028 }
b9faaae1
MS		 4029 }
4030
4031 job = calloc(1, sizeof(cupsd_job_t));
4032 if (!job)
4033 {
4034 cupsdLogMessage(CUPSD_LOG_EMERG,
12f89d24 4035 "[Job %d] Unable to allocate memory for job.", jobid);
b9faaae1
MS		 4036 break;
4037 }
4038
4039 job->id = jobid;
4040 job->back_pipes[0] = -1;
4041 job->back_pipes[1] = -1;
4042 job->print_pipes[0] = -1;
4043 job->print_pipes[1] = -1;
4044 job->side_pipes[0] = -1;
4045 job->side_pipes[1] = -1;
4046 job->status_pipes[0] = -1;
4047 job->status_pipes[1] = -1;
4048
72f50170 4049 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Loading from cache...");
b9faaae1
MS		 4050 }
4051 else if (!job)
4052 {
4053 cupsdLogMessage(CUPSD_LOG_ERROR,
12f89d24 4054 "Missing <Job #> directive on line %d.", linenum);
b9faaae1
MS		 4055 continue;
4056 }
88f9aafc 4057 else if (!_cups_strcasecmp(line, "</Job>"))
b9faaae1
MS		 4058 {
4059 cupsArrayAdd(Jobs, job);
4060
f701418f
MS		 4061 if (job->state_value <= IPP_JOB_STOPPED && cupsdLoadJob(job))
4062 cupsArrayAdd(ActiveJobs, job);
b9faaae1
MS		 4063
4064 job = NULL;
4065 }
4066 else if (!value)
4067 {
12f89d24 4068 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing value on line %d.", linenum);
b9faaae1
MS		 4069 continue;
4070 }
88f9aafc 4071 else if (!_cups_strcasecmp(line, "State"))
b9faaae1
MS		 4072 {
4073 job->state_value = (ipp_jstate_t)atoi(value);
4074
4075 if (job->state_value < IPP_JOB_PENDING)
4076 job->state_value = IPP_JOB_PENDING;
4077 else if (job->state_value > IPP_JOB_COMPLETED)
4078 job->state_value = IPP_JOB_COMPLETED;
4079 }
88f9aafc 4080 else if (!_cups_strcasecmp(line, "HoldUntil"))
8b116e60
MS		 4081 {
4082 job->hold_until = atoi(value);
4083 }
88f9aafc 4084 else if (!_cups_strcasecmp(line, "Priority"))
b9faaae1
MS		 4085 {
4086 job->priority = atoi(value);
4087 }
88f9aafc 4088 else if (!_cups_strcasecmp(line, "Username"))
b9faaae1
MS		 4089 {
4090 cupsdSetString(&job->username, value);
4091 }
88f9aafc 4092 else if (!_cups_strcasecmp(line, "Destination"))
b9faaae1
MS		 4093 {
4094 cupsdSetString(&job->dest, value);
4095 }
88f9aafc 4096 else if (!_cups_strcasecmp(line, "DestType"))
b9faaae1
MS		 4097 {
4098 job->dtype = (cups_ptype_t)atoi(value);
4099 }
88f9aafc 4100 else if (!_cups_strcasecmp(line, "NumFiles"))
b9faaae1
MS		 4101 {
4102 job->num_files = atoi(value);
4103
4104 if (job->num_files < 0)
4105 {
12f89d24 4106 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad NumFiles value %d on line %d.",
b9faaae1
MS		 4107 job->num_files, linenum);
4108 job->num_files = 0;
4109 continue;
4110 }
4111
4112 if (job->num_files > 0)
4113 {
4114 snprintf(jobfile, sizeof(jobfile), "%s/d%05d-001", RequestRoot,
4115 job->id);
4116 if (access(jobfile, 0))
4117 {
72f50170 4118 cupsdLogJob(job, CUPSD_LOG_INFO, "Data files have gone away.");
b9faaae1
MS		 4119 job->num_files = 0;
4120 continue;
4121 }
4122
7e86f2f6
MS		 4123 job->filetypes = calloc((size_t)job->num_files, sizeof(mime_type_t *));
4124 job->compressions = calloc((size_t)job->num_files, sizeof(int));
b9faaae1
MS		 4125
4126 if (!job->filetypes || !job->compressions)
4127 {
72f50170
MS		 4128 cupsdLogJob(job, CUPSD_LOG_EMERG,
4129 "Unable to allocate memory for %d files.",
4130 job->num_files);
b9faaae1
MS		 4131 break;
4132 }
4133 }
4134 }
88f9aafc 4135 else if (!_cups_strcasecmp(line, "File"))
b9faaae1
MS		 4136 {
4137 int number, /* File number */
4138 compression; /* Compression value */
4139 char super[MIME_MAX_SUPER], /* MIME super type */
4140 type[MIME_MAX_TYPE]; /* MIME type */
4141
4142
4143 if (sscanf(value, "%d%*[ \t]%15[^/]/%255s%d", &number, super, type,
4144 &compression) != 4)
4145 {
12f89d24 4146 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File on line %d.", linenum);
b9faaae1
MS		 4147 continue;
4148 }
4149
4150 if (number < 1 || number > job->num_files)
4151 {
12f89d24 4152 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File number %d on line %d.",
b9faaae1
MS		 4153 number, linenum);
4154 continue;
4155 }
0a682745 4156
b9faaae1 4157 number --;
ef416fc2 4158
b9faaae1
MS		 4159 job->compressions[number] = compression;
4160 job->filetypes[number] = mimeType(MimeDatabase, super, type);
ef416fc2 4161
b9faaae1
MS		 4162 if (!job->filetypes[number])
4163 {
e1d6a774 4164 /*
b9faaae1 4165 * If the original MIME type is unknown, auto-type it!
e1d6a774 4166 */
ef416fc2 4167
72f50170
MS		 4168 cupsdLogJob(job, CUPSD_LOG_ERROR,
4169 "Unknown MIME type %s/%s for file %d.",
4170 super, type, number + 1);
b9faaae1
MS		 4171
4172 snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
4173 job->id, number + 1);
4174 job->filetypes[number] = mimeFileType(MimeDatabase, jobfile, NULL,
4175 job->compressions + number);
ef416fc2 4176
e1d6a774 4177 /*
b9faaae1 4178 * If that didn't work, assume it is raw...
e1d6a774 4179 */
ef416fc2 4180
b9faaae1
MS		 4181 if (!job->filetypes[number])
4182 job->filetypes[number] = mimeType(MimeDatabase, "application",
4183 "vnd.cups-raw");
4184 }
4185 }
4186 else
12f89d24 4187 cupsdLogMessage(CUPSD_LOG_ERROR, "Unknown %s directive on line %d.",
b9faaae1 4188 line, linenum);
ef416fc2 4189 }
4190
cb7f98ee
MS		 4191 if (job)
4192 {
4193 cupsdLogMessage(CUPSD_LOG_ERROR,
4194 "Missing </Job> directive on line %d.", linenum);
4195 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
4196 }
4197
b9faaae1
MS		 4198 cupsFileClose(fp);
4199}
ef416fc2 4200
4201
b9faaae1
MS		 4202/*
4203 * 'load_next_job_id()' - Load the NextJobId value from the job.cache file.
4204 */
bd7854cb 4205
b9faaae1
MS		 4206static void
4207load_next_job_id(const char *filename) /* I - job.cache filename */
4208{
4209 cups_file_t *fp; /* job.cache file */
4210 char line[1024], /* Line buffer */
4211 *value; /* Value on line */
4212 int linenum; /* Line number in file */
4213 int next_job_id; /* NextJobId value from line */
db0bd74a 4214
db0bd74a 4215
b9faaae1
MS		 4216 /*
4217 * Read the NextJobId directive from the job.cache file and use
4218 * the value (if any).
4219 */
bd7854cb 4220
b9faaae1 4221 if ((fp = cupsFileOpen(filename, "r")) == NULL)
e1d6a774 4222 {
b9faaae1
MS		 4223 if (errno != ENOENT)
4224 cupsdLogMessage(CUPSD_LOG_ERROR,
4225 "Unable to open job cache file \"%s\": %s",
4226 filename, strerror(errno));
bd7854cb 4227
b9faaae1 4228 return;
e1d6a774 4229 }
bd7854cb 4230
b9faaae1
MS		 4231 cupsdLogMessage(CUPSD_LOG_INFO,
4232 "Loading NextJobId from job cache file \"%s\"...", filename);
4233
4234 linenum = 0;
4235
4236 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
bd7854cb 4237 {
88f9aafc 4238 if (!_cups_strcasecmp(line, "NextJobId"))
b9faaae1
MS		 4239 {
4240 if (value)
4241 {
4242 next_job_id = atoi(value);
4243
4244 if (next_job_id > NextJobId)
4245 NextJobId = next_job_id;
4246 }
4247 break;
4248 }
e1d6a774 4249 }
bd7854cb 4250
b9faaae1
MS		 4251 cupsFileClose(fp);
4252}
09a101d6 4253
f7deaa1a 4254
b9faaae1
MS		 4255/*
4256 * 'load_request_root()' - Load jobs from the RequestRoot directory.
4257 */
bd7854cb 4258
b9faaae1
MS		 4259static void
4260load_request_root(void)
4261{
4262 cups_dir_t *dir; /* Directory */
4263 cups_dentry_t *dent; /* Directory entry */
4264 cupsd_job_t *job; /* New job */
e1d6a774 4265
bd7854cb 4266
4267 /*
b9faaae1 4268 * Open the requests directory...
bd7854cb 4269 */
4270
b9faaae1 4271 cupsdLogMessage(CUPSD_LOG_DEBUG, "Scanning %s for jobs...", RequestRoot);
bd7854cb 4272
b9faaae1 4273 if ((dir = cupsDirOpen(RequestRoot)) == NULL)
bd7854cb 4274 {
b9faaae1
MS		 4275 cupsdLogMessage(CUPSD_LOG_ERROR,
4276 "Unable to open spool directory \"%s\": %s",
4277 RequestRoot, strerror(errno));
4278 return;
e1d6a774 4279 }
bd7854cb 4280
b9faaae1
MS		 4281 /*
4282 * Read all the c##### files...
4283 */
bd7854cb 4284
b9faaae1
MS		 4285 while ((dent = cupsDirRead(dir)) != NULL)
4286 if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c')
bd7854cb 4287 {
b9faaae1
MS		 4288 /*
4289 * Allocate memory for the job...
4290 */
bd7854cb 4291
b9faaae1 4292 if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
bd7854cb 4293 {
12f89d24 4294 cupsdLogMessage(CUPSD_LOG_ERROR, "Ran out of memory for jobs.");
b9faaae1
MS		 4295 cupsDirClose(dir);
4296 return;
4297 }
bd7854cb 4298
b9faaae1
MS		 4299 /*
4300 * Assign the job ID...
4301 */
bd7854cb 4302
b9faaae1
MS		 4303 job->id = atoi(dent->filename + 1);
4304 job->back_pipes[0] = -1;
4305 job->back_pipes[1] = -1;
4306 job->print_pipes[0] = -1;
4307 job->print_pipes[1] = -1;
4308 job->side_pipes[0] = -1;
4309 job->side_pipes[1] = -1;
4310 job->status_pipes[0] = -1;
4311 job->status_pipes[1] = -1;
bd7854cb 4312
b9faaae1
MS		 4313 if (job->id >= NextJobId)
4314 NextJobId = job->id + 1;
ed486911 4315
b9faaae1
MS		 4316 /*
4317 * Load the job...
4318 */
ed486911 4319
f701418f
MS		 4320 if (cupsdLoadJob(job))
4321 {
4322 /*
4323 * Insert the job into the array, sorting by job priority and ID...
4324 */
bd7854cb 4325
f701418f 4326 cupsArrayAdd(Jobs, job);
e1d6a774 4327
f701418f
MS		 4328 if (job->state_value <= IPP_JOB_STOPPED)
4329 cupsArrayAdd(ActiveJobs, job);
4330 else
4331 unload_job(job);
4332 }
0fa6c7fa
MS		 4333 else
4334 free(job);
bd7854cb 4335 }
bd7854cb 4336
b9faaae1
MS		 4337 cupsDirClose(dir);
4338}
bd7854cb 4339
4340
82cc1f9a
MS		 4341/*
4342 * 'remove_job_files()' - Remove the document files for a job.
4343 */
4344
4345static void
4346remove_job_files(cupsd_job_t *job) /* I - Job */
4347{
4348 int i; /* Looping var */
4349 char filename[1024]; /* Document filename */
4350
4351
4352 if (job->num_files <= 0)
4353 return;
4354
4355 for (i = 1; i <= job->num_files; i ++)
4356 {
4357 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
4358 job->id, i);
cb7f98ee 4359 cupsdUnlinkOrRemoveFile(filename);
82cc1f9a
MS		 4360 }
4361
4362 free(job->filetypes);
4363 free(job->compressions);
4364
4365 job->file_time = 0;
4366 job->num_files = 0;
4367 job->filetypes = NULL;
4368 job->compressions = NULL;
4369
4370 LastEvent |= CUPSD_EVENT_PRINTER_STATE_CHANGED;
4371}
4372
4373
4374/*
4375 * 'remove_job_history()' - Remove the control file for a job.
4376 */
4377
4378static void
4379remove_job_history(cupsd_job_t *job) /* I - Job */
4380{
4381 char filename[1024]; /* Control filename */
4382
4383
4384 /*
4385 * Remove the job info file...
4386 */
4387
4388 snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot,
4389 job->id);
cb7f98ee 4390 cupsdUnlinkOrRemoveFile(filename);
82cc1f9a
MS		 4391
4392 LastEvent |= CUPSD_EVENT_PRINTER_STATE_CHANGED;
4393}
4394
4395
b9faaae1
MS		 4396/*
4397 * 'set_time()' - Set one of the "time-at-xyz" attributes.
4398 */
bd7854cb 4399
b9faaae1
MS		 4400static void
4401set_time(cupsd_job_t *job, /* I - Job to update */
4402 const char *name) /* I - Name of attribute */
4403{
4404 ipp_attribute_t *attr; /* Time attribute */
82cc1f9a
MS		 4405 time_t curtime; /* Current time */
4406
bd7854cb 4407
82cc1f9a
MS		 4408 curtime = time(NULL);
4409
4410 cupsdLogJob(job, CUPSD_LOG_DEBUG, "%s=%ld", name, (long)curtime);
bd7854cb 4411
b9faaae1
MS		 4412 if ((attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO)) != NULL)
4413 {
4414 attr->value_tag = IPP_TAG_INTEGER;
82cc1f9a
MS		 4415 attr->values[0].integer = curtime;
4416 }
4417
4418 if (!strcmp(name, "time-at-completed"))
4419 {
0fa6c7fa 4420 if (JobHistory < INT_MAX && attr)
82cc1f9a
MS		 4421 job->history_time = attr->values[0].integer + JobHistory;
4422 else
4423 job->history_time = INT_MAX;
4424
4425 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
4426 JobHistoryUpdate = job->history_time;
4427
0fa6c7fa 4428 if (JobFiles < INT_MAX && attr)
82cc1f9a
MS		 4429 job->file_time = attr->values[0].integer + JobFiles;
4430 else
4431 job->file_time = INT_MAX;
4432
4433 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
4434 JobHistoryUpdate = job->file_time;
4435
4436 cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_time: JobHistoryUpdate=%ld",
4437 (long)JobHistoryUpdate);
b9faaae1
MS		 4438 }
4439}
bd7854cb 4440
e1d6a774 4441
b9faaae1
MS		 4442/*
4443 * 'start_job()' - Start a print job.
4444 */
e1d6a774 4445
b9faaae1
MS		 4446static void
4447start_job(cupsd_job_t *job, /* I - Job ID */
4448 cupsd_printer_t *printer) /* I - Printer to print job */
4449{
cb7f98ee 4450 const char *filename; /* Support filename */
982069db
MS		 4451 ipp_attribute_t *cancel_after = ippFindAttribute(job->attrs,
4452 "job-cancel-after",
4453 IPP_TAG_INTEGER);
4454 /* job-cancel-after attribute */
cb7f98ee
MS		 4455
4456
b9faaae1
MS		 4457 cupsdLogMessage(CUPSD_LOG_DEBUG2, "start_job(job=%p(%d), printer=%p(%s))",
4458 job, job->id, printer, printer->name);
bd7854cb 4459
b9faaae1
MS		 4460 /*
4461 * Make sure we have some files around before we try to print...
4462 */
bd7854cb 4463
b9faaae1
MS		 4464 if (job->num_files == 0)
4465 {
12f89d24 4466 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
b9faaae1
MS		 4467 cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_DEFAULT,
4468 "Aborting job because it has no files.");
4469 return;
4470 }
bd7854cb 4471
b9faaae1
MS		 4472 /*
4473 * Update the printer and job state to "processing"...
4474 */
bd7854cb 4475
b9faaae1
MS		 4476 if (!cupsdLoadJob(job))
4477 return;
89d46774 4478
3e7fe0ca
MS		 4479 if (!job->printer_message)
4480 job->printer_message = ippFindAttribute(job->attrs,
4481 "job-printer-state-message",
4482 IPP_TAG_TEXT);
88f9aafc
MS		 4483 if (job->printer_message)
4484 cupsdSetString(&(job->printer_message->values[0].string.text), "");
4485
12f89d24 4486 ippSetString(job->attrs, &job->reasons, 0, "job-printing");
b9faaae1
MS		 4487 cupsdSetJobState(job, IPP_JOB_PROCESSING, CUPSD_JOB_DEFAULT, NULL);
4488 cupsdSetPrinterState(printer, IPP_PRINTER_PROCESSING, 0);
07ed0e9a
MS		 4489 cupsdSetPrinterReasons(printer, "-cups-remote-pending,"
4490 "cups-remote-pending-held,"
4491 "cups-remote-processing,"
4492 "cups-remote-stopped,"
4493 "cups-remote-canceled,"
4494 "cups-remote-aborted,"
4495 "cups-remote-completed");
f7deaa1a 4496
1340db2d
MS		 4497 job->cost = 0;
4498 job->current_file = 0;
82cc1f9a
MS		 4499 job->file_time = 0;
4500 job->history_time = 0;
1340db2d
MS		 4501 job->progress = 0;
4502 job->printer = printer;
4503 printer->job = job;
f7deaa1a 4504
982069db
MS		 4505 if (cancel_after)
4506 job->cancel_time = time(NULL) + ippGetInteger(cancel_after, 0);
4507 else if (MaxJobTime > 0)
dcb445bc
MS		 4508 job->cancel_time = time(NULL) + MaxJobTime;
4509 else
4510 job->cancel_time = 0;
4511
cb7f98ee
MS		 4512 /*
4513 * Check for support files...
4514 */
4515
4516 cupsdSetPrinterReasons(job->printer, "-cups-missing-filter-warning,"
4517 "cups-insecure-filter-warning");
4518
4519 if (printer->pc)
4520 {
4521 for (filename = (const char *)cupsArrayFirst(printer->pc->support_files);
4522 filename;
4523 filename = (const char *)cupsArrayNext(printer->pc->support_files))
4524 {
4525 if (_cupsFileCheck(filename, _CUPS_FILE_CHECK_FILE, !RunUser,
4526 cupsdLogFCMessage, printer))
4527 break;
4528 }
4529 }
4530
b9faaae1
MS		 4531 /*
4532 * Setup the last exit status and security profiles...
4533 */
89d46774 4534
8fe0183a
MS		 4535 job->status = 0;
4536 job->profile = cupsdCreateProfile(job->id, 0);
4537 job->bprofile = cupsdCreateProfile(job->id, 1);
bd7854cb 4538
b9faaae1
MS		 4539 /*
4540 * Create the status pipes and buffer...
4541 */
bd7854cb 4542
b9faaae1
MS		 4543 if (cupsdOpenPipe(job->status_pipes))
4544 {
4545 cupsdLogJob(job, CUPSD_LOG_DEBUG,
4546 "Unable to create job status pipes - %s.", strerror(errno));
89d46774 4547
b9faaae1
MS		 4548 cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
4549 "Job stopped because the scheduler could not create the "
4550 "job status pipes.");
89d46774 4551
b9faaae1
MS		 4552 cupsdDestroyProfile(job->profile);
4553 job->profile = NULL;
8fe0183a
MS		 4554 cupsdDestroyProfile(job->bprofile);
4555 job->bprofile = NULL;
b9faaae1 4556 return;
e1d6a774 4557 }
bd7854cb 4558
b9faaae1
MS		 4559 job->status_buffer = cupsdStatBufNew(job->status_pipes[0], NULL);
4560 job->status_level = CUPSD_LOG_INFO;
4561
4562 /*
4563 * Create the backchannel pipes and make them non-blocking...
4564 */
bd7854cb 4565
b9faaae1 4566 if (cupsdOpenPipe(job->back_pipes))
e1d6a774 4567 {
b9faaae1
MS		 4568 cupsdLogJob(job, CUPSD_LOG_DEBUG,
4569 "Unable to create back-channel pipes - %s.", strerror(errno));
4570
4571 cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
4572 "Job stopped because the scheduler could not create the "
4573 "back-channel pipes.");
4574
4575 cupsdClosePipe(job->status_pipes);
4576 cupsdStatBufDelete(job->status_buffer);
4577 job->status_buffer = NULL;
4578
4579 cupsdDestroyProfile(job->profile);
4580 job->profile = NULL;
8fe0183a
MS		 4581 cupsdDestroyProfile(job->bprofile);
4582 job->bprofile = NULL;
b9faaae1 4583 return;
e1d6a774 4584 }
bd7854cb 4585
b9faaae1
MS		 4586 fcntl(job->back_pipes[0], F_SETFL,
4587 fcntl(job->back_pipes[0], F_GETFL) | O_NONBLOCK);
4588 fcntl(job->back_pipes[1], F_SETFL,
4589 fcntl(job->back_pipes[1], F_GETFL) | O_NONBLOCK);
ef416fc2 4590
b9faaae1
MS		 4591 /*
4592 * Create the side-channel pipes and make them non-blocking...
4593 */
ef416fc2 4594
b9faaae1
MS		 4595 if (socketpair(AF_LOCAL, SOCK_STREAM, 0, job->side_pipes))
4596 {
4597 cupsdLogJob(job, CUPSD_LOG_DEBUG,
4598 "Unable to create side-channel pipes - %s.", strerror(errno));
ef416fc2 4599
b9faaae1
MS		 4600 cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
4601 "Job stopped because the scheduler could not create the "
4602 "side-channel pipes.");
ef416fc2 4603
b9faaae1
MS		 4604 cupsdClosePipe(job->back_pipes);
4605
4606 cupsdClosePipe(job->status_pipes);
4607 cupsdStatBufDelete(job->status_buffer);
4608 job->status_buffer = NULL;
4609
4610 cupsdDestroyProfile(job->profile);
4611 job->profile = NULL;
8fe0183a
MS		 4612 cupsdDestroyProfile(job->bprofile);
4613 job->bprofile = NULL;
b9faaae1
MS		 4614 return;
4615 }
4616
4617 fcntl(job->side_pipes[0], F_SETFL,
4618 fcntl(job->side_pipes[0], F_GETFL) | O_NONBLOCK);
4619 fcntl(job->side_pipes[1], F_SETFL,
4620 fcntl(job->side_pipes[1], F_GETFL) | O_NONBLOCK);
ef416fc2 4621
7a0cbd5e
MS		 4622 fcntl(job->side_pipes[0], F_SETFD,
4623 fcntl(job->side_pipes[0], F_GETFD) | FD_CLOEXEC);
4624 fcntl(job->side_pipes[1], F_SETFD,
4625 fcntl(job->side_pipes[1], F_GETFD) | FD_CLOEXEC);
4626
ef416fc2 4627 /*
b9faaae1 4628 * Now start the first file in the job...
ef416fc2 4629 */
4630
b9faaae1
MS		 4631 cupsdContinueJob(job);
4632}
ef416fc2 4633
ef416fc2 4634
b9faaae1
MS		 4635/*
4636 * 'stop_job()' - Stop a print job.
4637 */
ef416fc2 4638
b9faaae1
MS		 4639static void
4640stop_job(cupsd_job_t *job, /* I - Job */
4641 cupsd_jobaction_t action) /* I - Action */
4642{
4643 int i; /* Looping var */
b94498cf 4644
ef416fc2 4645
b9faaae1
MS		 4646 cupsdLogMessage(CUPSD_LOG_DEBUG2, "stop_job(job=%p(%d), action=%d)", job,
4647 job->id, action);
ef416fc2 4648
b9faaae1
MS		 4649 FilterLevel -= job->cost;
4650 job->cost = 0;
ef416fc2 4651
238c3832
MS		 4652 if (action == CUPSD_JOB_DEFAULT && !job->kill_time)
4653 job->kill_time = time(NULL) + JobKillDelay;
ef55b745 4654 else if (action >= CUPSD_JOB_FORCE)
238c3832
MS		 4655 job->kill_time = 0;
4656
b9faaae1
MS		 4657 for (i = 0; job->filters[i]; i ++)
4658 if (job->filters[i] > 0)
ef55b745
MS		 4659 {
4660 cupsdEndProcess(job->filters[i], action >= CUPSD_JOB_FORCE);
4661
4662 if (action >= CUPSD_JOB_FORCE)
4663 job->filters[i] = -job->filters[i];
4664 }
b9faaae1
MS		 4665
4666 if (job->backend > 0)
ef55b745
MS		 4667 {
4668 cupsdEndProcess(job->backend, action >= CUPSD_JOB_FORCE);
4669
4670 if (action >= CUPSD_JOB_FORCE)
4671 job->backend = -job->backend;
4672 }
4673
4674 if (action >= CUPSD_JOB_FORCE)
4675 {
4676 /*
4677 * Clear job status...
4678 */
4679
4680 job->status = 0;
4681 }
e1d6a774 4682}
ef416fc2 4683
e1d6a774 4684
4685/*
4686 * 'unload_job()' - Unload a job from memory.
4687 */
4688
4689static void
4690unload_job(cupsd_job_t *job) /* I - Job */
4691{
4692 if (!job->attrs)
4693 return;
4694
72f50170 4695 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Unloading...");
e1d6a774 4696
4697 ippDelete(job->attrs);
4698
cc0d019f
MS		 4699 job->attrs = NULL;
4700 job->state = NULL;
12f89d24 4701 job->reasons = NULL;
cc0d019f
MS		 4702 job->sheets = NULL;
4703 job->job_sheets = NULL;
4704 job->printer_message = NULL;
4705 job->printer_reasons = NULL;
ef416fc2 4706}
4707
4708
4709/*
f899b121 4710 * 'update_job()' - Read a status update from a job's filters.
4711 */
4712
4713void
09a101d6 4714update_job(cupsd_job_t *job) /* I - Job to check */
f899b121 4715{
4716 int i; /* Looping var */
4717 int copies; /* Number of copies printed */
178cb736
MS		 4718 char message[CUPSD_SB_BUFFER_SIZE],
4719 /* Message text */
f899b121 4720 *ptr; /* Pointer update... */
4721 int loglevel, /* Log level for message */
4722 event = 0; /* Events? */
f0ab5bff
MS		 4723 static const char * const levels[] = /* Log levels */
4724 {
4725 "NONE",
4726 "EMERG",
4727 "ALERT",
4728 "CRIT",
4729 "ERROR",
4730 "WARN",
4731 "NOTICE",
4732 "INFO",
4733 "DEBUG",
4734 "DEBUG2"
4735 };
f899b121 4736
4737
f0ab5bff
MS		 4738 /*
4739 * Get the printer associated with this job; if the printer is stopped for
4740 * any reason then job->printer will be reset to NULL, so make sure we have
4741 * a valid pointer...
4742 */
4743
f899b121 4744 while ((ptr = cupsdStatBufUpdate(job->status_buffer, &loglevel,
4745 message, sizeof(message))) != NULL)
4746 {
4747 /*
4748 * Process page and printer state messages as needed...
4749 */
4750
4751 if (loglevel == CUPSD_LOG_PAGE)
4752 {
4753 /*
4754 * Page message; send the message to the page_log file and update the
4755 * job sheet count...
4756 */
4757
75bd9771 4758 cupsdLogJob(job, CUPSD_LOG_DEBUG, "PAGE: %s", message);
dd1abb6b 4759
91c84a35 4760 if (job->sheets)
f899b121 4761 {
88f9aafc 4762 if (!_cups_strncasecmp(message, "total ", 6))
f899b121 4763 {
4764 /*
4765 * Got a total count of pages from a backend or filter...
4766 */
4767
4768 copies = atoi(message + 6);
4769 copies -= job->sheets->values[0].integer; /* Just track the delta */
4770 }
4771 else if (!sscanf(message, "%*d%d", &copies))
4772 copies = 1;
4773
4774 job->sheets->values[0].integer += copies;
4775
b9faaae1 4776 if (job->printer->page_limit)
ba55dc12 4777 cupsdUpdateQuota(job->printer, job->username, copies, 0);
f899b121 4778 }
4779
4780 cupsdLogPage(job, message);
4781
91c84a35 4782 if (job->sheets)
b9faaae1 4783 cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
91c84a35 4784 "Printed %d page(s).", job->sheets->values[0].integer);
f899b121 4785 }
a469f8a5
MS		 4786 else if (loglevel == CUPSD_LOG_JOBSTATE)
4787 {
4788 /*
4789 * Support "keyword" to set job-state-reasons to the specified keyword.
4790 * This is sufficient for the current paid printing stuff.
4791 */
4792
4793 cupsdLogJob(job, CUPSD_LOG_DEBUG, "JOBSTATE: %s", message);
4794
8e67b75b
MS		 4795 if (!strcmp(message, "cups-retry-as-raster"))
4796 job->retry_as_raster = 1;
4797 else
4798 ippSetString(job->attrs, &job->reasons, 0, message);
a469f8a5 4799 }
f899b121 4800 else if (loglevel == CUPSD_LOG_STATE)
4801 {
75bd9771 4802 cupsdLogJob(job, CUPSD_LOG_DEBUG, "STATE: %s", message);
dd1abb6b 4803
09a101d6 4804 if (!strcmp(message, "paused"))
c24d2134 4805 {
b9faaae1 4806 cupsdStopPrinter(job->printer, 1);
c24d2134
MS		 4807 return;
4808 }
0fa6c7fa 4809 else if (message[0] && cupsdSetPrinterReasons(job->printer, message))
dcb445bc 4810 {
d9bca400 4811 event |= CUPSD_EVENT_PRINTER_STATE;
bc44d920 4812
982069db 4813 if (MaxJobTime > 0)
dcb445bc
MS		 4814 {
4815 /*
4816 * Reset cancel time after connecting to the device...
4817 */
4818
4819 for (i = 0; i < job->printer->num_reasons; i ++)
4820 if (!strcmp(job->printer->reasons[i], "connecting-to-device"))
4821 break;
4822
4823 if (i >= job->printer->num_reasons)
982069db 4824 {
581dae2d
MS		 4825 ipp_attribute_t *cancel_after = ippFindAttribute(job->attrs,
4826 "job-cancel-after",
4827 IPP_TAG_INTEGER);
4828 /* job-cancel-after attribute */
4829
982069db
MS		 4830 if (cancel_after)
4831 job->cancel_time = time(NULL) + ippGetInteger(cancel_after, 0);
4832 else
4833 job->cancel_time = time(NULL) + MaxJobTime;
4834 }
dcb445bc
MS		 4835 }
4836 }
4837
4509bb49 4838 update_job_attrs(job, 0);
f899b121 4839 }
4840 else if (loglevel == CUPSD_LOG_ATTR)
4841 {
4842 /*
4843 * Set attribute(s)...
4844 */
4845
4846 int num_attrs; /* Number of attributes */
4847 cups_option_t *attrs; /* Attributes */
4848 const char *attr; /* Attribute */
4849
75bd9771 4850 cupsdLogJob(job, CUPSD_LOG_DEBUG, "ATTR: %s", message);
dd1abb6b 4851
f899b121 4852 num_attrs = cupsParseOptions(message, 0, &attrs);
4853
5a9febac
MS		 4854 if ((attr = cupsGetOption("auth-info-default", num_attrs,
4855 attrs)) != NULL)
4856 {
4857 job->printer->num_options = cupsAddOption("auth-info", attr,
4858 job->printer->num_options,
4859 &(job->printer->options));
4860 cupsdSetPrinterAttrs(job->printer);
4861
4862 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
4863 }
4864
f899b121 4865 if ((attr = cupsGetOption("auth-info-required", num_attrs,
4866 attrs)) != NULL)
7ff4fea9 4867 {
b9faaae1
MS		 4868 cupsdSetAuthInfoRequired(job->printer, attr, NULL);
4869 cupsdSetPrinterAttrs(job->printer);
3dfe78b3 4870
a2326b5b 4871 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
7ff4fea9 4872 }
f899b121 4873
9a4f8274
MS		 4874 if ((attr = cupsGetOption("job-media-progress", num_attrs,
4875 attrs)) != NULL)
4876 {
4877 int progress = atoi(attr);
4878
4879
4880 if (progress >= 0 && progress <= 100)
4881 {
4882 job->progress = progress;
4883
4884 if (job->sheets)
b9faaae1 4885 cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
9a4f8274
MS		 4886 "Printing page %d, %d%%",
4887 job->sheets->values[0].integer, job->progress);
4888 }
4889 }
4890
323c5de1 4891 if ((attr = cupsGetOption("printer-alert", num_attrs, attrs)) != NULL)
4892 {
b9faaae1 4893 cupsdSetString(&job->printer->alert, attr);
d9bca400 4894 event |= CUPSD_EVENT_PRINTER_STATE;
323c5de1 4895 }
4896
4897 if ((attr = cupsGetOption("printer-alert-description", num_attrs,
4898 attrs)) != NULL)
4899 {
b9faaae1 4900 cupsdSetString(&job->printer->alert_description, attr);
d9bca400 4901 event |= CUPSD_EVENT_PRINTER_STATE;
323c5de1 4902 }
4903
5a738aea
MS		 4904 if ((attr = cupsGetOption("marker-colors", num_attrs, attrs)) != NULL)
4905 {
b9faaae1
MS		 4906 cupsdSetPrinterAttr(job->printer, "marker-colors", (char *)attr);
4907 job->printer->marker_time = time(NULL);
5a738aea 4908 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 4909 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 4910 }
4911
4912 if ((attr = cupsGetOption("marker-levels", num_attrs, attrs)) != NULL)
4913 {
b9faaae1
MS		 4914 cupsdSetPrinterAttr(job->printer, "marker-levels", (char *)attr);
4915 job->printer->marker_time = time(NULL);
5a738aea 4916 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 4917 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 4918 }
4919
ed6e7faf
MS		 4920 if ((attr = cupsGetOption("marker-low-levels", num_attrs, attrs)) != NULL)
4921 {
b9faaae1
MS		 4922 cupsdSetPrinterAttr(job->printer, "marker-low-levels", (char *)attr);
4923 job->printer->marker_time = time(NULL);
ed6e7faf
MS		 4924 event |= CUPSD_EVENT_PRINTER_STATE;
4925 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
4926 }
4927
4928 if ((attr = cupsGetOption("marker-high-levels", num_attrs, attrs)) != NULL)
4929 {
b9faaae1
MS		 4930 cupsdSetPrinterAttr(job->printer, "marker-high-levels", (char *)attr);
4931 job->printer->marker_time = time(NULL);
ed6e7faf
MS		 4932 event |= CUPSD_EVENT_PRINTER_STATE;
4933 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
4934 }
4935
75bd9771
MS		 4936 if ((attr = cupsGetOption("marker-message", num_attrs, attrs)) != NULL)
4937 {
b9faaae1
MS		 4938 cupsdSetPrinterAttr(job->printer, "marker-message", (char *)attr);
4939 job->printer->marker_time = time(NULL);
75bd9771 4940 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 4941 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
75bd9771
MS		 4942 }
4943
5a738aea
MS		 4944 if ((attr = cupsGetOption("marker-names", num_attrs, attrs)) != NULL)
4945 {
b9faaae1
MS		 4946 cupsdSetPrinterAttr(job->printer, "marker-names", (char *)attr);
4947 job->printer->marker_time = time(NULL);
5a738aea 4948 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 4949 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 4950 }
4951
4952 if ((attr = cupsGetOption("marker-types", num_attrs, attrs)) != NULL)
4953 {
b9faaae1
MS		 4954 cupsdSetPrinterAttr(job->printer, "marker-types", (char *)attr);
4955 job->printer->marker_time = time(NULL);
5a738aea 4956 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 4957 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 4958 }
4959
f899b121 4960 cupsFreeOptions(num_attrs, attrs);
4961 }
c9fc04c6
MS		 4962 else if (loglevel == CUPSD_LOG_PPD)
4963 {
4964 /*
4965 * Set attribute(s)...
4966 */
4967
75bd9771 4968 cupsdLogJob(job, CUPSD_LOG_DEBUG, "PPD: %s", message);
dd1abb6b 4969
a29fd7dd
MS		 4970 job->num_keywords = cupsParseOptions(message, job->num_keywords,
4971 &job->keywords);
c9fc04c6 4972 }
4d301e69 4973 else
f899b121 4974 {
4d301e69
MS		 4975 /*
4976 * Strip legacy message prefix...
4977 */
f899b121 4978
4d301e69 4979 if (!strncmp(message, "recoverable:", 12))
d2354e63 4980 {
4d301e69
MS		 4981 ptr = message + 12;
4982 while (isspace(*ptr & 255))
4983 ptr ++;
d2354e63 4984 }
4d301e69 4985 else if (!strncmp(message, "recovered:", 10))
acb056cb 4986 {
4d301e69
MS		 4987 ptr = message + 10;
4988 while (isspace(*ptr & 255))
4989 ptr ++;
acb056cb 4990 }
4d301e69
MS		 4991 else
4992 ptr = message;
4993
dcb445bc
MS		 4994 if (*ptr)
4995 cupsdLogJob(job, loglevel, "%s", ptr);
f899b121 4996
5180a04c
MS		 4997 if (loglevel < CUPSD_LOG_DEBUG &&
4998 strcmp(job->printer->state_message, ptr))
1f0275e3 4999 {
4d301e69 5000 strlcpy(job->printer->state_message, ptr,
b9faaae1 5001 sizeof(job->printer->state_message));
4509bb49 5002
8b116e60 5003 event |= CUPSD_EVENT_PRINTER_STATE | CUPSD_EVENT_JOB_PROGRESS;
4509bb49 5004
229681c1 5005 if (loglevel <= job->status_level && job->status_level > CUPSD_LOG_ERROR)
1f0275e3
MS		 5006 {
5007 /*
b9faaae1 5008 * Some messages show in the job-printer-state-message attribute...
1f0275e3 5009 */
09a101d6 5010
1f0275e3
MS		 5011 if (loglevel != CUPSD_LOG_NOTICE)
5012 job->status_level = loglevel;
01ce6322 5013
1f0275e3 5014 update_job_attrs(job, 1);
f0ab5bff
MS		 5015
5016 cupsdLogJob(job, CUPSD_LOG_DEBUG,
5017 "Set job-printer-state-message to \"%s\", "
5018 "current level=%s",
5019 job->printer_message->values[0].string.text,
5020 levels[job->status_level]);
1f0275e3 5021 }
75bd9771 5022 }
f899b121 5023 }
5024
5025 if (!strchr(job->status_buffer->buffer, '\n'))
5026 break;
5027 }
5028
f8b3a85b
MS		 5029 if (event & CUPSD_EVENT_JOB_PROGRESS)
5030 cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
5031 "%s", job->printer->state_message);
5180a04c 5032 if (event & CUPSD_EVENT_PRINTER_STATE)
b9faaae1
MS		 5033 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, job->printer, NULL,
5034 (job->printer->type & CUPS_PRINTER_CLASS) ?
f899b121 5035 "Class \"%s\" state changed." :
5036 "Printer \"%s\" state changed.",
b9faaae1 5037 job->printer->name);
f899b121 5038
8b116e60 5039
f899b121 5040 if (ptr == NULL && !job->status_buffer->bufused)
5041 {
5042 /*
5043 * See if all of the filters and the backend have returned their
5044 * exit statuses.
5045 */
5046
5047 for (i = 0; job->filters[i] < 0; i ++);
5048
5049 if (job->filters[i])
d7871c8c
MS		 5050 {
5051 /*
5052 * EOF but we haven't collected the exit status of all filters...
5053 */
5054
5055 cupsdCheckProcess();
f899b121 5056 return;
d7871c8c 5057 }
f899b121 5058
5059 if (job->current_file >= job->num_files && job->backend > 0)
d7871c8c
MS		 5060 {
5061 /*
5062 * EOF but we haven't collected the exit status of the backend...
5063 */
5064
5065 cupsdCheckProcess();
f899b121 5066 return;
d7871c8c 5067 }
f899b121 5068
5069 /*
5070 * Handle the end of job stuff...
5071 */
5072
ef55b745 5073 finalize_job(job, 1);
b9faaae1
MS		 5074
5075 /*
5076 * Check for new jobs...
5077 */
5078
5079 cupsdCheckJobs();
f899b121 5080 }
5081}
5082
5083
5084/*
bc44d920 5085 * 'update_job_attrs()' - Update the job-printer-* attributes.
5086 */
5087
5088void
4509bb49 5089update_job_attrs(cupsd_job_t *job, /* I - Job to update */
b9faaae1 5090 int do_message)/* I - 1 = copy job-printer-state message */
bc44d920 5091{
5092 int i; /* Looping var */
5093 int num_reasons; /* Actual number of reasons */
5094 const char * const *reasons; /* Reasons */
f0ab5bff 5095 static const char *none = "none"; /* "none" reason */
bc44d920 5096
5097
5098 /*
5099 * Get/create the job-printer-state-* attributes...
5100 */
5101
5102 if (!job->printer_message)
5103 {
5104 if ((job->printer_message = ippFindAttribute(job->attrs,
5105 "job-printer-state-message",
5106 IPP_TAG_TEXT)) == NULL)
5107 job->printer_message = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_TEXT,
5108 "job-printer-state-message",
5109 NULL, "");
5110 }
5111
5112 if (!job->printer_reasons)
5113 job->printer_reasons = ippFindAttribute(job->attrs,
5114 "job-printer-state-reasons",
5115 IPP_TAG_KEYWORD);
5116
bc44d920 5117 /*
b9faaae1 5118 * Copy or clear the printer-state-message value as needed...
bc44d920 5119 */
5120
b9faaae1
MS		 5121 if (job->state_value != IPP_JOB_PROCESSING &&
5122 job->status_level == CUPSD_LOG_INFO)
dcb445bc 5123 {
b9faaae1 5124 cupsdSetString(&(job->printer_message->values[0].string.text), "");
dcb445bc
MS		 5125
5126 job->dirty = 1;
5127 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
5128 }
b9faaae1 5129 else if (job->printer->state_message[0] && do_message)
dcb445bc 5130 {
bc44d920 5131 cupsdSetString(&(job->printer_message->values[0].string.text),
b9faaae1 5132 job->printer->state_message);
ef55b745 5133
dcb445bc
MS		 5134 job->dirty = 1;
5135 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
5136 }
5137
bc44d920 5138 /*
5139 * ... and the printer-state-reasons value...
5140 */
5141
b9faaae1 5142 if (job->printer->num_reasons == 0)
bc44d920 5143 {
5144 num_reasons = 1;
f0ab5bff 5145 reasons = &none;
bc44d920 5146 }
5147 else
5148 {
b9faaae1
MS		 5149 num_reasons = job->printer->num_reasons;
5150 reasons = (const char * const *)job->printer->reasons;
bc44d920 5151 }
5152
5153 if (!job->printer_reasons || job->printer_reasons->num_values != num_reasons)
5154 {
b9faaae1
MS		 5155 /*
5156 * Replace/create a job-printer-state-reasons attribute...
5157 */
5158
bc44d920 5159 ippDeleteAttribute(job->attrs, job->printer_reasons);
5160
5161 job->printer_reasons = ippAddStrings(job->attrs,
5162 IPP_TAG_JOB, IPP_TAG_KEYWORD,
5163 "job-printer-state-reasons",
5164 num_reasons, NULL, NULL);
5165 }
b9faaae1 5166 else
d2354e63 5167 {
b9faaae1
MS		 5168 /*
5169 * Don't bother clearing the reason strings if they are the same...
5170 */
5171
5172 for (i = 0; i < num_reasons; i ++)
5173 if (strcmp(job->printer_reasons->values[i].string.text, reasons[i]))
5174 break;
5175
5176 if (i >= num_reasons)
5177 return;
5178
5179 /*
5180 * Not the same, so free the current strings...
5181 */
5182
5183 for (i = 0; i < num_reasons; i ++)
d2354e63
MS		 5184 _cupsStrFree(job->printer_reasons->values[i].string.text);
5185 }
bc44d920 5186
b9faaae1
MS		 5187 /*
5188 * Copy the reasons...
5189 */
5190
bc44d920 5191 for (i = 0; i < num_reasons; i ++)
d2354e63 5192 job->printer_reasons->values[i].string.text = _cupsStrAlloc(reasons[i]);
dcb445bc
MS		 5193
5194 job->dirty = 1;
5195 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
bc44d920 5196}
5197
5198
5199/*
f2d18633 5200 * End of "$Id$".
ef416fc2 5201 */
Unnamed repository; edit this file 'description' to name the repository.