]> 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
Fix some issues in ipptool for skipped tests (<rdar://problem/24137160>)
[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 *
4c97c06f 6 * Copyright 2007-2015 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);
eec1fbc3 122static int compare_completed_jobs(void *first, void *second, void *data);
ef416fc2 123static int compare_jobs(void *first, void *second, void *data);
178cb736 124static void dump_job_history(cupsd_job_t *job);
ef55b745 125static void finalize_job(cupsd_job_t *job, int set_job_state);
178cb736 126static void free_job_history(cupsd_job_t *job);
b9faaae1
MS		 127static char *get_options(cupsd_job_t *job, int banner_page, char *copies,
128 size_t copies_size, char *title,
129 size_t title_size);
c7017ecc 130static size_t ipp_length(ipp_t *ipp);
bd7854cb 131static void load_job_cache(const char *filename);
132static void load_next_job_id(const char *filename);
133static void load_request_root(void);
82cc1f9a
MS		 134static void remove_job_files(cupsd_job_t *job);
135static void remove_job_history(cupsd_job_t *job);
b9faaae1 136static void set_time(cupsd_job_t *job, const char *name);
e1d6a774 137static void start_job(cupsd_job_t *job, cupsd_printer_t *printer);
b9faaae1 138static void stop_job(cupsd_job_t *job, cupsd_jobaction_t action);
e1d6a774 139static void unload_job(cupsd_job_t *job);
f899b121 140static void update_job(cupsd_job_t *job);
4509bb49 141static void update_job_attrs(cupsd_job_t *job, int do_message);
ef416fc2 142
143
144/*
b9faaae1 145 * 'cupsdAddJob()' - Add a new job to the job queue.
ef416fc2 146 */
147
148cupsd_job_t * /* O - New job record */
149cupsdAddJob(int priority, /* I - Job priority */
150 const char *dest) /* I - Job destination */
151{
152 cupsd_job_t *job; /* New job record */
153
154
91c84a35
MS		 155 if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
156 return (NULL);
ef416fc2 157
89d46774 158 job->id = NextJobId ++;
159 job->priority = priority;
160 job->back_pipes[0] = -1;
161 job->back_pipes[1] = -1;
162 job->print_pipes[0] = -1;
163 job->print_pipes[1] = -1;
f7deaa1a 164 job->side_pipes[0] = -1;
165 job->side_pipes[1] = -1;
89d46774 166 job->status_pipes[0] = -1;
167 job->status_pipes[1] = -1;
ef416fc2 168
169 cupsdSetString(&job->dest, dest);
170
171 /*
172 * Add the new job to the "all jobs" and "active jobs" lists...
173 */
174
175 cupsArrayAdd(Jobs, job);
176 cupsArrayAdd(ActiveJobs, job);
177
178 return (job);
179}
180
181
182/*
b9faaae1 183 * 'cupsdCancelJobs()' - Cancel all jobs for the given destination/user.
ef416fc2 184 */
185
186void
187cupsdCancelJobs(const char *dest, /* I - Destination to cancel */
188 const char *username, /* I - Username or NULL */
189 int purge) /* I - Purge jobs? */
190{
191 cupsd_job_t *job; /* Current job */
192
193
194 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
195 job;
196 job = (cupsd_job_t *)cupsArrayNext(Jobs))
0a682745 197 {
b9faaae1 198 if ((!job->dest || !job->username) && !cupsdLoadJob(job))
0a682745
MS		 199 continue;
200
b9faaae1
MS		 201 if ((!dest || !strcmp(job->dest, dest)) &&
202 (!username || !strcmp(job->username, username)))
ef416fc2 203 {
204 /*
205 * Cancel all jobs matching this destination/user...
206 */
207
b9faaae1
MS		 208 if (purge)
209 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_PURGE,
210 "Job purged by user.");
41681883 211 else if (job->state_value < IPP_JOB_CANCELED)
b9faaae1
MS		 212 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_DEFAULT,
213 "Job canceled by user.");
ef416fc2 214 }
0a682745 215 }
ef416fc2 216}
217
218
219/*
220 * 'cupsdCheckJobs()' - Check the pending jobs and start any if the destination
221 * is available.
222 */
223
224void
225cupsdCheckJobs(void)
226{
227 cupsd_job_t *job; /* Current job in queue */
228 cupsd_printer_t *printer, /* Printer destination */
229 *pclass; /* Printer class destination */
ac884b6a 230 ipp_attribute_t *attr; /* Job attribute */
238c3832 231 time_t curtime; /* Current time */
ef416fc2 232
233
238c3832
MS		 234 curtime = time(NULL);
235
1deb86fd 236 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdCheckJobs: %d active jobs, sleeping=%d, ac-power=%d, reload=%d, curtime=%ld", cupsArrayCount(ActiveJobs), Sleeping, ACPower, NeedReload, (long)curtime);
a29fd7dd 237
ef416fc2 238 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
239 job;
240 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
241 {
a29fd7dd
MS		 242 cupsdLogMessage(CUPSD_LOG_DEBUG2,
243 "cupsdCheckJobs: Job %d - dest=\"%s\", printer=%p, "
244 "state=%d, cancel_time=%ld, hold_until=%ld, kill_time=%ld, "
245 "pending_cost=%d, pending_timeout=%ld", job->id, job->dest,
246 job->printer, job->state_value, (long)job->cancel_time,
247 (long)job->hold_until, (long)job->kill_time,
248 job->pending_cost, (long)job->pending_timeout);
249
238c3832
MS		 250 /*
251 * Kill jobs if they are unresponsive...
252 */
253
254 if (job->kill_time && job->kill_time <= curtime)
255 {
581dae2d
MS		 256 if (!job->completed)
257 cupsdLogJob(job, CUPSD_LOG_ERROR, "Stopping unresponsive job.");
10d09e33 258
238c3832
MS		 259 stop_job(job, CUPSD_JOB_FORCE);
260 continue;
261 }
262
dcb445bc
MS		 263 /*
264 * Cancel stuck jobs...
265 */
266
267 if (job->cancel_time && job->cancel_time <= curtime)
268 {
3aec6cf0
MS		 269 int cancel_after; /* job-cancel-after value */
270
271 attr = ippFindAttribute(job->attrs, "job-cancel-after", IPP_TAG_INTEGER);
272 cancel_after = attr ? ippGetInteger(attr, 0) : MaxJobTime;
e3dfbe13 273
581dae2d 274 if (job->completed)
e3dfbe13 275 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_FORCE, "Marking stuck job as completed after %d seconds.", cancel_after);
581dae2d 276 else
e3dfbe13 277 cupsdSetJobState(job, IPP_JOB_CANCELED, CUPSD_JOB_DEFAULT, "Canceling stuck job after %d seconds.", cancel_after);
dcb445bc
MS		 278 continue;
279 }
280
ef416fc2 281 /*
282 * Start held jobs if they are ready...
283 */
284
bd7854cb 285 if (job->state_value == IPP_JOB_HELD &&
ef416fc2 286 job->hold_until &&
238c3832 287 job->hold_until < curtime)
bd7854cb 288 {
09a101d6 289 if (job->pending_timeout)
91c84a35 290 {
dfd5680b
MS		 291 /*
292 * This job is pending; check that we don't have an active Send-Document
293 * operation in progress on any of the client connections, then timeout
294 * the job so we can start printing...
295 */
296
297 cupsd_client_t *con; /* Current client connection */
298
dfd5680b
MS		 299 for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
300 con;
301 con = (cupsd_client_t *)cupsArrayNext(Clients))
302 if (con->request &&
303 con->request->request.op.operation_id == IPP_SEND_DOCUMENT)
304 break;
305
306 if (con)
307 continue;
308
91c84a35
MS		 309 if (cupsdTimeoutJob(job))
310 continue;
311 }
09a101d6 312
b9faaae1
MS		 313 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
314 "Job submission timed out.");
bd7854cb 315 }
ef416fc2 316
e07d4801
MS		 317 /*
318 * Continue jobs that are waiting on the FilterLimit...
319 */
320
321 if (job->pending_cost > 0 &&
322 ((FilterLevel + job->pending_cost) < FilterLimit || FilterLevel == 0))
323 cupsdContinueJob(job);
324
ef416fc2 325 /*
326 * Start pending jobs if the destination is available...
327 */
328
88f9aafc 329 if (job->state_value == IPP_JOB_PENDING && !NeedReload &&
1deb86fd 330 (!Sleeping || ACPower) && !DoingShutdown && !job->printer)
ef416fc2 331 {
332 printer = cupsdFindDest(job->dest);
333 pclass = NULL;
334
a2326b5b 335 while (printer && (printer->type & CUPS_PRINTER_CLASS))
ef416fc2 336 {
337 /*
338 * If the class is remote, just pass it to the remote server...
339 */
340
341 pclass = printer;
342
c0e1af83 343 if (pclass->state == IPP_PRINTER_STOPPED)
b86bc4cf 344 printer = NULL;
c0e1af83 345 else if (pclass->type & CUPS_PRINTER_REMOTE)
346 break;
347 else
348 printer = cupsdFindAvailablePrinter(printer->name);
ef416fc2 349 }
350
351 if (!printer && !pclass)
352 {
353 /*
354 * Whoa, the printer and/or class for this destination went away;
355 * cancel the job...
356 */
357
b9faaae1
MS		 358 cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_PURGE,
359 "Job aborted because the destination printer/class "
360 "has gone away.");
ef416fc2 361 }
61cf44e2 362 else if (printer && !printer->holding_new_jobs)
ef416fc2 363 {
364 /*
365 * See if the printer is available or remote and not printing a job;
366 * if so, start the job...
367 */
368
369 if (pclass)
370 {
371 /*
372 * Add/update a job-actual-printer-uri attribute for this job
373 * so that we know which printer actually printed the job...
374 */
375
ef416fc2 376 if ((attr = ippFindAttribute(job->attrs, "job-actual-printer-uri",
377 IPP_TAG_URI)) != NULL)
5e6c3df7 378 ippSetString(job->attrs, &attr, 0, printer->uri);
ef416fc2 379 else
380 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_URI,
381 "job-actual-printer-uri", NULL, printer->uri);
3dfe78b3
MS		 382
383 job->dirty = 1;
384 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
ef416fc2 385 }
386
a29fd7dd 387 if (!printer->job && printer->state == IPP_PRINTER_IDLE)
bc44d920 388 {
bc44d920 389 /*
390 * Start the job...
391 */
392
93d3b4fe 393 cupsArraySave(ActiveJobs);
e1d6a774 394 start_job(job, printer);
93d3b4fe 395 cupsArrayRestore(ActiveJobs);
bc44d920 396 }
ef416fc2 397 }
398 }
399 }
400}
401
402
403/*
404 * 'cupsdCleanJobs()' - Clean out old jobs.
405 */
406
407void
408cupsdCleanJobs(void)
409{
410 cupsd_job_t *job; /* Current job */
82cc1f9a
MS		 411 time_t curtime; /* Current time */
412
ef416fc2 413
82cc1f9a
MS		 414 cupsdLogMessage(CUPSD_LOG_DEBUG2,
415 "cupsdCleanJobs: MaxJobs=%d, JobHistory=%d, JobFiles=%d",
416 MaxJobs, JobHistory, JobFiles);
ef416fc2 417
82cc1f9a 418 if (MaxJobs <= 0 && JobHistory == INT_MAX && JobFiles == INT_MAX)
ef416fc2 419 return;
420
82cc1f9a
MS		 421 curtime = time(NULL);
422 JobHistoryUpdate = 0;
423
ef416fc2 424 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
82cc1f9a 425 job;
ef416fc2 426 job = (cupsd_job_t *)cupsArrayNext(Jobs))
82cc1f9a 427 {
b9faaae1 428 if (job->state_value >= IPP_JOB_CANCELED && !job->printer)
82cc1f9a
MS		 429 {
430 /*
431 * Expire old jobs (or job files)...
432 */
433
434 if ((MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs) ||
435 (job->history_time && job->history_time <= curtime))
436 {
437 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Removing from history.");
438 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
439 }
440 else if (job->file_time && job->file_time <= curtime)
441 {
442 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Removing document files.");
443 remove_job_files(job);
444
0b2b24c5
MS		 445 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
446
82cc1f9a
MS		 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 */
12f1eda9 494 int argc = 0; /* 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
eec1fbc3
MS		 1458/*
1459 * 'cupsdGetCompletedJobs()'- Generate a completed jobs list.
1460 */
1461
1462cups_array_t * /* O - Array of jobs */
1463cupsdGetCompletedJobs(
1464 cupsd_printer_t *p) /* I - Printer */
1465{
1466 cups_array_t *list; /* Array of jobs */
1467 cupsd_job_t *job; /* Current job */
1468
1469
1470 list = cupsArrayNew(compare_completed_jobs, NULL);
1471
1472 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
1473 job;
1474 job = (cupsd_job_t *)cupsArrayNext(Jobs))
1475 if ((!p || !_cups_strcasecmp(p->name, job->dest)) && job->state_value >= IPP_JOB_STOPPED && job->completed_time)
1476 cupsArrayAdd(list, job);
1477
1478 return (list);
1479}
1480
1481
ef416fc2 1482/*
b9faaae1
MS		 1483 * 'cupsdGetPrinterJobCount()' - Get the number of pending, processing,
1484 * or held jobs in a printer or class.
ef416fc2 1485 */
1486
b9faaae1
MS		 1487int /* O - Job count */
1488cupsdGetPrinterJobCount(
1489 const char *dest) /* I - Printer or class name */
ef416fc2 1490{
b9faaae1
MS		 1491 int count; /* Job count */
1492 cupsd_job_t *job; /* Current job */
005dd1eb 1493
005dd1eb 1494
b9faaae1
MS		 1495 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
1496 job;
1497 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
88f9aafc 1498 if (job->dest && !_cups_strcasecmp(job->dest, dest))
b9faaae1 1499 count ++;
ef416fc2 1500
b9faaae1 1501 return (count);
ef416fc2 1502}
1503
1504
1505/*
b9faaae1
MS		 1506 * 'cupsdGetUserJobCount()' - Get the number of pending, processing,
1507 * or held jobs for a user.
ef416fc2 1508 */
1509
b9faaae1
MS		 1510int /* O - Job count */
1511cupsdGetUserJobCount(
1512 const char *username) /* I - Username */
ef416fc2 1513{
b9faaae1
MS		 1514 int count; /* Job count */
1515 cupsd_job_t *job; /* Current job */
07725fee 1516
07725fee 1517
b9faaae1
MS		 1518 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs), count = 0;
1519 job;
1520 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
88f9aafc 1521 if (!_cups_strcasecmp(job->username, username))
b9faaae1 1522 count ++;
07725fee 1523
b9faaae1 1524 return (count);
ef416fc2 1525}
1526
1527
1528/*
b9faaae1 1529 * 'cupsdLoadAllJobs()' - Load all jobs from disk.
ef416fc2 1530 */
1531
1532void
b9faaae1 1533cupsdLoadAllJobs(void)
bd7854cb 1534{
b9faaae1 1535 char filename[1024]; /* Full filename of job.cache file */
222753d9
MS		 1536 struct stat fileinfo; /* Information on job.cache file */
1537 cups_dir_t *dir; /* RequestRoot dir */
1538 cups_dentry_t *dent; /* Entry in RequestRoot */
1539 int load_cache = 1; /* Load the job.cache file? */
bd7854cb 1540
bd7854cb 1541
1542 /*
b9faaae1 1543 * Create the job arrays as needed...
bd7854cb 1544 */
1545
b9faaae1
MS		 1546 if (!Jobs)
1547 Jobs = cupsArrayNew(compare_jobs, NULL);
1548
1549 if (!ActiveJobs)
1550 ActiveJobs = cupsArrayNew(compare_active_jobs, NULL);
1551
1552 if (!PrintingJobs)
1553 PrintingJobs = cupsArrayNew(compare_jobs, NULL);
bd7854cb 1554
1555 /*
b9faaae1 1556 * See whether the job.cache file is older than the RequestRoot directory...
bd7854cb 1557 */
1558
b9faaae1 1559 snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
bd7854cb 1560
b9faaae1
MS		 1561 if (stat(filename, &fileinfo))
1562 {
222753d9
MS		 1563 /*
1564 * No job.cache file...
1565 */
1566
1567 load_cache = 0;
b9faaae1
MS		 1568
1569 if (errno != ENOENT)
1570 cupsdLogMessage(CUPSD_LOG_ERROR,
1571 "Unable to get file information for \"%s\" - %s",
1572 filename, strerror(errno));
1573 }
222753d9
MS		 1574 else if ((dir = cupsDirOpen(RequestRoot)) == NULL)
1575 {
1576 /*
1577 * No spool directory...
1578 */
b9faaae1 1579
222753d9
MS		 1580 load_cache = 0;
1581 }
1582 else
b9faaae1 1583 {
222753d9
MS		 1584 while ((dent = cupsDirRead(dir)) != NULL)
1585 {
1586 if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c' && dent->fileinfo.st_mtime > fileinfo.st_mtime)
1587 {
1588 /*
1589 * Job history file is newer than job.cache file...
1590 */
b9faaae1 1591
222753d9
MS		 1592 load_cache = 0;
1593 break;
1594 }
1595 }
4c97c06f
MS		 1596
1597 cupsDirClose(dir);
b9faaae1 1598 }
bd7854cb 1599
1600 /*
b9faaae1 1601 * Load the most recent source for job data...
bd7854cb 1602 */
1603
222753d9 1604 if (load_cache)
bd7854cb 1605 {
222753d9
MS		 1606 /*
1607 * Load the job.cache file...
1608 */
1609
1610 load_job_cache(filename);
1611 }
1612 else
1613 {
1614 /*
1615 * Load the job history files...
1616 */
1617
b9faaae1
MS		 1618 load_request_root();
1619
1620 load_next_job_id(filename);
bd7854cb 1621 }
1622
b9faaae1
MS		 1623 /*
1624 * Clean out old jobs as needed...
1625 */
1626
1627 if (MaxJobs > 0 && cupsArrayCount(Jobs) >= MaxJobs)
1628 cupsdCleanJobs();
bd7854cb 1629}
1630
1631
1632/*
b9faaae1 1633 * 'cupsdLoadJob()' - Load a single job.
bd7854cb 1634 */
1635
b9faaae1
MS		 1636int /* O - 1 on success, 0 on failure */
1637cupsdLoadJob(cupsd_job_t *job) /* I - Job */
ef416fc2 1638{
88f9aafc 1639 int i; /* Looping var */
b9faaae1
MS		 1640 char jobfile[1024]; /* Job filename */
1641 cups_file_t *fp; /* Job file */
1642 int fileid; /* Current file ID */
1643 ipp_attribute_t *attr; /* Job attribute */
1644 const char *dest; /* Destination name */
1645 cupsd_printer_t *destptr; /* Pointer to destination */
1646 mime_type_t **filetypes; /* New filetypes array */
1647 int *compressions; /* New compressions array */
ef416fc2 1648
1649
b9faaae1
MS		 1650 if (job->attrs)
1651 {
1652 if (job->state_value > IPP_JOB_STOPPED)
1653 job->access_time = time(NULL);
bd7854cb 1654
b9faaae1
MS		 1655 return (1);
1656 }
ef416fc2 1657
b9faaae1 1658 if ((job->attrs = ippNew()) == NULL)
ef416fc2 1659 {
12f89d24 1660 cupsdLogJob(job, CUPSD_LOG_ERROR, "Ran out of memory for job attributes.");
b9faaae1 1661 return (0);
ef416fc2 1662 }
1663
b9faaae1
MS		 1664 /*
1665 * Load job attributes...
1666 */
ef416fc2 1667
72f50170 1668 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Loading attributes...");
bd7854cb 1669
b9faaae1 1670 snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, job->id);
82cc1f9a
MS		 1671 if ((fp = cupsdOpenConfFile(jobfile)) == NULL)
1672 goto error;
ef416fc2 1673
b9faaae1
MS		 1674 if (ippReadIO(fp, (ipp_iocb_t)cupsFileRead, 1, NULL, job->attrs) != IPP_DATA)
1675 {
72f50170
MS		 1676 cupsdLogJob(job, CUPSD_LOG_ERROR,
1677 "Unable to read job control file \"%s\".", jobfile);
b9faaae1
MS		 1678 cupsFileClose(fp);
1679 goto error;
1680 }
ef416fc2 1681
b9faaae1 1682 cupsFileClose(fp);
ef416fc2 1683
b9faaae1
MS		 1684 /*
1685 * Copy attribute data to the job object...
1686 */
ef416fc2 1687
b9faaae1 1688 if (!ippFindAttribute(job->attrs, "time-at-creation", IPP_TAG_INTEGER))
ef416fc2 1689 {
72f50170
MS		 1690 cupsdLogJob(job, CUPSD_LOG_ERROR,
1691 "Missing or bad time-at-creation attribute in control file.");
b9faaae1 1692 goto error;
ef416fc2 1693 }
b9faaae1
MS		 1694
1695 if ((job->state = ippFindAttribute(job->attrs, "job-state",
1696 IPP_TAG_ENUM)) == NULL)
ef416fc2 1697 {
72f50170
MS		 1698 cupsdLogJob(job, CUPSD_LOG_ERROR,
1699 "Missing or bad job-state attribute in control file.");
b9faaae1
MS		 1700 goto error;
1701 }
ef416fc2 1702
82cc1f9a
MS		 1703 job->state_value = (ipp_jstate_t)job->state->values[0].integer;
1704 job->file_time = 0;
1705 job->history_time = 0;
1706
f16ea703
MS		 1707 if ((attr = ippFindAttribute(job->attrs, "time-at-creation", IPP_TAG_INTEGER)) != NULL)
1708 job->creation_time = attr->values[0].integer;
1709
1710 if (job->state_value >= IPP_JOB_CANCELED && (attr = ippFindAttribute(job->attrs, "time-at-completed", IPP_TAG_INTEGER)) != NULL)
82cc1f9a 1711 {
eec1fbc3
MS		 1712 job->completed_time = attr->values[0].integer;
1713
82cc1f9a
MS		 1714 if (JobHistory < INT_MAX)
1715 job->history_time = attr->values[0].integer + JobHistory;
1716 else
1717 job->history_time = INT_MAX;
1718
1719 if (job->history_time < time(NULL))
1720 goto error; /* Expired, remove from history */
1721
1722 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
1723 JobHistoryUpdate = job->history_time;
1724
1725 if (JobFiles < INT_MAX)
1726 job->file_time = attr->values[0].integer + JobFiles;
1727 else
1728 job->file_time = INT_MAX;
1729
1730 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
1731 JobHistoryUpdate = job->file_time;
1732
1733 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdLoadJob: JobHistoryUpdate=%ld",
1734 (long)JobHistoryUpdate);
1735 }
ef416fc2 1736
b9faaae1 1737 if (!job->dest)
ef416fc2 1738 {
b9faaae1
MS		 1739 if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
1740 IPP_TAG_URI)) == NULL)
1741 {
72f50170
MS		 1742 cupsdLogJob(job, CUPSD_LOG_ERROR,
1743 "No job-printer-uri attribute in control file.");
b9faaae1
MS		 1744 goto error;
1745 }
ef416fc2 1746
b9faaae1
MS		 1747 if ((dest = cupsdValidateDest(attr->values[0].string.text, &(job->dtype),
1748 &destptr)) == NULL)
1749 {
72f50170
MS		 1750 cupsdLogJob(job, CUPSD_LOG_ERROR,
1751 "Unable to queue job for destination \"%s\".",
1752 attr->values[0].string.text);
b9faaae1
MS		 1753 goto error;
1754 }
ef416fc2 1755
b9faaae1 1756 cupsdSetString(&job->dest, dest);
f7deaa1a 1757 }
b9faaae1 1758 else if ((destptr = cupsdFindDest(job->dest)) == NULL)
ef416fc2 1759 {
72f50170
MS		 1760 cupsdLogJob(job, CUPSD_LOG_ERROR,
1761 "Unable to queue job for destination \"%s\".",
1762 job->dest);
b9faaae1
MS		 1763 goto error;
1764 }
ef416fc2 1765
12f89d24
MS		 1766 if ((job->reasons = ippFindAttribute(job->attrs, "job-state-reasons",
1767 IPP_TAG_KEYWORD)) == NULL)
1768 {
1769 const char *reason; /* job-state-reason keyword */
1770
72f50170
MS		 1771 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1772 "Adding missing job-state-reasons attribute to control file.");
12f89d24
MS		 1773
1774 switch (job->state_value)
1775 {
82cc1f9a 1776 default :
12f89d24
MS		 1777 case IPP_JOB_PENDING :
1778 if (destptr->state == IPP_PRINTER_STOPPED)
1779 reason = "printer-stopped";
1780 else
1781 reason = "none";
1782 break;
1783
1784 case IPP_JOB_HELD :
1785 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
1786 IPP_TAG_ZERO)) != NULL &&
1787 (attr->value_tag == IPP_TAG_NAME ||
1788 attr->value_tag == IPP_TAG_NAMELANG ||
1789 attr->value_tag == IPP_TAG_KEYWORD) &&
1790 strcmp(attr->values[0].string.text, "no-hold"))
1791 reason = "job-hold-until-specified";
1792 else
1793 reason = "job-incoming";
1794 break;
1795
1796 case IPP_JOB_PROCESSING :
1797 reason = "job-printing";
1798 break;
1799
1800 case IPP_JOB_STOPPED :
1801 reason = "job-stopped";
1802 break;
1803
1804 case IPP_JOB_CANCELED :
1805 reason = "job-canceled-by-user";
1806 break;
1807
1808 case IPP_JOB_ABORTED :
1809 reason = "aborted-by-system";
1810 break;
1811
1812 case IPP_JOB_COMPLETED :
1813 reason = "job-completed-successfully";
1814 break;
1815 }
1816
1817 job->reasons = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
1818 "job-state-reasons", NULL, reason);
1819 }
1820 else if (job->state_value == IPP_JOB_PENDING)
1821 {
1822 if (destptr->state == IPP_PRINTER_STOPPED)
1823 ippSetString(job->attrs, &job->reasons, 0, "printer-stopped");
1824 else
1825 ippSetString(job->attrs, &job->reasons, 0, "none");
1826 }
1827
9514a192
MS		 1828 job->impressions = ippFindAttribute(job->attrs, "job-impressions-completed", IPP_TAG_INTEGER);
1829 job->sheets = ippFindAttribute(job->attrs, "job-media-sheets-completed", IPP_TAG_INTEGER);
1830 job->job_sheets = ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_NAME);
1831
1832 if (!job->impressions)
1833 job->impressions = ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-impressions-completed", 0);
ef416fc2 1834
b9faaae1
MS		 1835 if (!job->priority)
1836 {
1837 if ((attr = ippFindAttribute(job->attrs, "job-priority",
1838 IPP_TAG_INTEGER)) == NULL)
1839 {
72f50170
MS		 1840 cupsdLogJob(job, CUPSD_LOG_ERROR,
1841 "Missing or bad job-priority attribute in control file.");
b9faaae1
MS		 1842 goto error;
1843 }
1844
1845 job->priority = attr->values[0].integer;
f7deaa1a 1846 }
b9faaae1
MS		 1847
1848 if (!job->username)
ef416fc2 1849 {
b9faaae1
MS		 1850 if ((attr = ippFindAttribute(job->attrs, "job-originating-user-name",
1851 IPP_TAG_NAME)) == NULL)
1852 {
72f50170
MS		 1853 cupsdLogJob(job, CUPSD_LOG_ERROR,
1854 "Missing or bad job-originating-user-name "
1855 "attribute in control file.");
b9faaae1
MS		 1856 goto error;
1857 }
ef416fc2 1858
b9faaae1
MS		 1859 cupsdSetString(&job->username, attr->values[0].string.text);
1860 }
ef416fc2 1861
f16ea703
MS		 1862 if (!job->name)
1863 {
1864 if ((attr = ippFindAttribute(job->attrs, "job-name", IPP_TAG_NAME)) != NULL)
1865 cupsdSetString(&job->name, attr->values[0].string.text);
1866 }
1867
b9faaae1
MS		 1868 /*
1869 * Set the job hold-until time and state...
1870 */
1871
1872 if (job->state_value == IPP_JOB_HELD)
1873 {
1874 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
1875 IPP_TAG_KEYWORD)) == NULL)
1876 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
1877
1878 if (attr)
1879 cupsdSetJobHoldUntil(job, attr->values[0].string.text, CUPSD_JOB_DEFAULT);
ef416fc2 1880 else
b9faaae1
MS		 1881 {
1882 job->state->values[0].integer = IPP_JOB_PENDING;
1883 job->state_value = IPP_JOB_PENDING;
1884 }
f7deaa1a 1885 }
b9faaae1
MS		 1886 else if (job->state_value == IPP_JOB_PROCESSING)
1887 {
1888 job->state->values[0].integer = IPP_JOB_PENDING;
1889 job->state_value = IPP_JOB_PENDING;
1890 }
1891
f16ea703
MS		 1892 if ((attr = ippFindAttribute(job->attrs, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
1893 job->koctets = attr->values[0].integer;
1894
b9faaae1 1895 if (!job->num_files)
ef416fc2 1896 {
1897 /*
b9faaae1 1898 * Find all the d##### files...
ef416fc2 1899 */
1900
b9faaae1
MS		 1901 for (fileid = 1; fileid < 10000; fileid ++)
1902 {
1903 snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
1904 job->id, fileid);
ef416fc2 1905
b9faaae1
MS		 1906 if (access(jobfile, 0))
1907 break;
1908
72f50170
MS		 1909 cupsdLogJob(job, CUPSD_LOG_DEBUG,
1910 "Auto-typing document file \"%s\"...", jobfile);
b9faaae1
MS		 1911
1912 if (fileid > job->num_files)
1913 {
1914 if (job->num_files == 0)
1915 {
7e86f2f6
MS		 1916 compressions = (int *)calloc((size_t)fileid, sizeof(int));
1917 filetypes = (mime_type_t **)calloc((size_t)fileid, sizeof(mime_type_t *));
b9faaae1
MS		 1918 }
1919 else
1920 {
7e86f2f6
MS		 1921 compressions = (int *)realloc(job->compressions, sizeof(int) * (size_t)fileid);
1922 filetypes = (mime_type_t **)realloc(job->filetypes, sizeof(mime_type_t *) * (size_t)fileid);
b9faaae1
MS		 1923 }
1924
cb7f98ee
MS		 1925 if (compressions)
1926 job->compressions = compressions;
1927
1928 if (filetypes)
1929 job->filetypes = filetypes;
1930
b9faaae1
MS		 1931 if (!compressions || !filetypes)
1932 {
72f50170
MS		 1933 cupsdLogJob(job, CUPSD_LOG_ERROR,
1934 "Ran out of memory for job file types.");
ef55b745
MS		 1935
1936 ippDelete(job->attrs);
1937 job->attrs = NULL;
1938
ef55b745
MS		 1939 if (job->compressions)
1940 {
1941 free(job->compressions);
1942 job->compressions = NULL;
1943 }
1944
1945 if (job->filetypes)
1946 {
1947 free(job->filetypes);
1948 job->filetypes = NULL;
1949 }
1950
1951 job->num_files = 0;
1952 return (0);
b9faaae1
MS		 1953 }
1954
cb7f98ee 1955 job->num_files = fileid;
b9faaae1
MS		 1956 }
1957
1958 job->filetypes[fileid - 1] = mimeFileType(MimeDatabase, jobfile, NULL,
1959 job->compressions + fileid - 1);
1960
1961 if (!job->filetypes[fileid - 1])
1962 job->filetypes[fileid - 1] = mimeType(MimeDatabase, "application",
1963 "vnd.cups-raw");
1964 }
ef416fc2 1965 }
b9faaae1
MS		 1966
1967 /*
1968 * Load authentication information as needed...
1969 */
1970
1971 if (job->state_value < IPP_JOB_STOPPED)
ef416fc2 1972 {
b9faaae1 1973 snprintf(jobfile, sizeof(jobfile), "%s/a%05d", RequestRoot, job->id);
ef416fc2 1974
88f9aafc
MS		 1975 for (i = 0;
1976 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
1977 i ++)
1978 cupsdClearString(job->auth_env + i);
07ed0e9a 1979 cupsdClearString(&job->auth_uid);
ef416fc2 1980
b9faaae1
MS		 1981 if ((fp = cupsFileOpen(jobfile, "r")) != NULL)
1982 {
dcb445bc
MS		 1983 int bytes, /* Size of auth data */
1984 linenum = 1; /* Current line number */
85dda01c 1985 char line[65536], /* Line from file */
dcb445bc 1986 *value, /* Value from line */
85dda01c 1987 data[65536]; /* Decoded data */
ef416fc2 1988
ef416fc2 1989
dcb445bc 1990 if (cupsFileGets(fp, line, sizeof(line)) &&
94436c5a 1991 !strcmp(line, "CUPSD-AUTH-V3"))
b9faaae1 1992 {
dcb445bc
MS		 1993 i = 0;
1994 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
1995 {
1996 /*
1997 * Decode value...
1998 */
1999
94436c5a
MS		 2000 if (strcmp(line, "negotiate") && strcmp(line, "uid"))
2001 {
2002 bytes = sizeof(data);
2003 httpDecode64_2(data, &bytes, value);
2004 }
b9faaae1 2005
dcb445bc
MS		 2006 /*
2007 * Assign environment variables...
2008 */
2009
2010 if (!strcmp(line, "uid"))
2011 {
2012 cupsdSetStringf(&job->auth_uid, "AUTH_UID=%s", value);
2013 continue;
2014 }
2015 else if (i >= (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0])))
2016 break;
2017
2018 if (!strcmp(line, "username"))
2019 cupsdSetStringf(job->auth_env + i, "AUTH_USERNAME=%s", data);
2020 else if (!strcmp(line, "domain"))
2021 cupsdSetStringf(job->auth_env + i, "AUTH_DOMAIN=%s", data);
2022 else if (!strcmp(line, "password"))
2023 cupsdSetStringf(job->auth_env + i, "AUTH_PASSWORD=%s", data);
2024 else if (!strcmp(line, "negotiate"))
94436c5a 2025 cupsdSetStringf(job->auth_env + i, "AUTH_NEGOTIATE=%s", value);
dcb445bc
MS		 2026 else
2027 continue;
2028
2029 i ++;
2030 }
2031 }
07ed0e9a 2032
b9faaae1
MS		 2033 cupsFileClose(fp);
2034 }
ef416fc2 2035 }
2036
b9faaae1
MS		 2037 job->access_time = time(NULL);
2038 return (1);
2039
2040 /*
2041 * If we get here then something bad happened...
2042 */
2043
2044 error:
2045
2046 ippDelete(job->attrs);
2047 job->attrs = NULL;
ef55b745 2048
82cc1f9a
MS		 2049 remove_job_history(job);
2050 remove_job_files(job);
b9faaae1
MS		 2051
2052 return (0);
ef416fc2 2053}
2054
2055
2056/*
b9faaae1 2057 * 'cupsdMoveJob()' - Move the specified job to a different destination.
ef416fc2 2058 */
2059
2060void
b9faaae1
MS		 2061cupsdMoveJob(cupsd_job_t *job, /* I - Job */
2062 cupsd_printer_t *p) /* I - Destination printer or class */
ef416fc2 2063{
b9faaae1
MS		 2064 ipp_attribute_t *attr; /* job-printer-uri attribute */
2065 const char *olddest; /* Old destination */
2066 cupsd_printer_t *oldp; /* Old pointer */
ef416fc2 2067
2068
2069 /*
b9faaae1 2070 * Don't move completed jobs...
ef416fc2 2071 */
2072
b9faaae1 2073 if (job->state_value > IPP_JOB_STOPPED)
ef416fc2 2074 return;
2075
2076 /*
b9faaae1 2077 * Get the old destination...
ef416fc2 2078 */
2079
b9faaae1 2080 olddest = job->dest;
ef416fc2 2081
b9faaae1
MS		 2082 if (job->printer)
2083 oldp = job->printer;
ef416fc2 2084 else
b9faaae1 2085 oldp = cupsdFindDest(olddest);
ef416fc2 2086
b9faaae1
MS		 2087 /*
2088 * Change the destination information...
2089 */
2090
eac3a0a0
MS		 2091 if (job->state_value > IPP_JOB_HELD)
2092 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2093 "Stopping job prior to move.");
b9faaae1
MS		 2094
2095 cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED, oldp, job,
2096 "Job #%d moved from %s to %s.", job->id, olddest,
2097 p->name);
2098
2099 cupsdSetString(&job->dest, p->name);
a2326b5b 2100 job->dtype = p->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
b9faaae1
MS		 2101
2102 if ((attr = ippFindAttribute(job->attrs, "job-printer-uri",
2103 IPP_TAG_URI)) != NULL)
5e6c3df7 2104 ippSetString(job->attrs, &attr, 0, p->uri);
b9faaae1
MS		 2105
2106 cupsdAddEvent(CUPSD_EVENT_JOB_STOPPED, p, job,
2107 "Job #%d moved from %s to %s.", job->id, olddest,
2108 p->name);
ef416fc2 2109
3dfe78b3
MS		 2110 job->dirty = 1;
2111 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
ef416fc2 2112}
2113
2114
2115/*
b9faaae1 2116 * 'cupsdReleaseJob()' - Release the specified job.
ef416fc2 2117 */
2118
2119void
b9faaae1 2120cupsdReleaseJob(cupsd_job_t *job) /* I - Job */
ef416fc2 2121{
b9faaae1
MS		 2122 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdReleaseJob(job=%p(%d))", job,
2123 job->id);
ef416fc2 2124
b9faaae1
MS		 2125 if (job->state_value == IPP_JOB_HELD)
2126 {
2127 /*
2128 * Add trailing banner as needed...
2129 */
ef416fc2 2130
b9faaae1
MS		 2131 if (job->pending_timeout)
2132 cupsdTimeoutJob(job);
ef416fc2 2133
b9faaae1
MS		 2134 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2135 "Job released by user.");
2136 }
e1d6a774 2137}
ef416fc2 2138
ef416fc2 2139
e1d6a774 2140/*
b9faaae1 2141 * 'cupsdRestartJob()' - Restart the specified job.
e1d6a774 2142 */
ef416fc2 2143
e1d6a774 2144void
b9faaae1 2145cupsdRestartJob(cupsd_job_t *job) /* I - Job */
e1d6a774 2146{
b9faaae1
MS		 2147 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdRestartJob(job=%p(%d))", job,
2148 job->id);
ef416fc2 2149
b9faaae1
MS		 2150 if (job->state_value == IPP_JOB_STOPPED || job->num_files)
2151 cupsdSetJobState(job, IPP_JOB_PENDING, CUPSD_JOB_DEFAULT,
2152 "Job restarted by user.");
2153}
ef416fc2 2154
ef416fc2 2155
b9faaae1
MS		 2156/*
2157 * 'cupsdSaveAllJobs()' - Save a summary of all jobs to disk.
2158 */
ef416fc2 2159
b9faaae1
MS		 2160void
2161cupsdSaveAllJobs(void)
2162{
2163 int i; /* Looping var */
321d8d57
MS		 2164 cups_file_t *fp; /* job.cache file */
2165 char filename[1024], /* job.cache filename */
2166 temp[1024]; /* Temporary string */
b9faaae1
MS		 2167 cupsd_job_t *job; /* Current job */
2168 time_t curtime; /* Current time */
2169 struct tm *curdate; /* Current date */
ef416fc2 2170
ef416fc2 2171
321d8d57
MS		 2172 snprintf(filename, sizeof(filename), "%s/job.cache", CacheDir);
2173 if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm)) == NULL)
c168a833 2174 return;
ef416fc2 2175
321d8d57 2176 cupsdLogMessage(CUPSD_LOG_INFO, "Saving job.cache...");
bd7854cb 2177
b9faaae1
MS		 2178 /*
2179 * Write a small header to the file...
2180 */
bd7854cb 2181
b9faaae1
MS		 2182 curtime = time(NULL);
2183 curdate = localtime(&curtime);
2184 strftime(temp, sizeof(temp) - 1, "%Y-%m-%d %H:%M", curdate);
ef416fc2 2185
b9faaae1
MS		 2186 cupsFilePuts(fp, "# Job cache file for " CUPS_SVERSION "\n");
2187 cupsFilePrintf(fp, "# Written by cupsd on %s\n", temp);
2188 cupsFilePrintf(fp, "NextJobId %d\n", NextJobId);
f7deaa1a 2189
b9faaae1
MS		 2190 /*
2191 * Write each job known to the system...
2192 */
f7deaa1a 2193
b9faaae1
MS		 2194 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
2195 job;
2196 job = (cupsd_job_t *)cupsArrayNext(Jobs))
ef416fc2 2197 {
b9faaae1
MS		 2198 cupsFilePrintf(fp, "<Job %d>\n", job->id);
2199 cupsFilePrintf(fp, "State %d\n", job->state_value);
f16ea703 2200 cupsFilePrintf(fp, "Created %ld\n", (long)job->creation_time);
eec1fbc3
MS		 2201 if (job->completed_time)
2202 cupsFilePrintf(fp, "Completed %ld\n", (long)job->completed_time);
b9faaae1 2203 cupsFilePrintf(fp, "Priority %d\n", job->priority);
eec1fbc3
MS		 2204 if (job->hold_until)
2205 cupsFilePrintf(fp, "HoldUntil %ld\n", (long)job->hold_until);
b9faaae1 2206 cupsFilePrintf(fp, "Username %s\n", job->username);
f16ea703
MS		 2207 if (job->name)
2208 cupsFilePutConf(fp, "Name", job->name);
b9faaae1
MS		 2209 cupsFilePrintf(fp, "Destination %s\n", job->dest);
2210 cupsFilePrintf(fp, "DestType %d\n", job->dtype);
f16ea703 2211 cupsFilePrintf(fp, "KOctets %d\n", job->koctets);
b9faaae1
MS		 2212 cupsFilePrintf(fp, "NumFiles %d\n", job->num_files);
2213 for (i = 0; i < job->num_files; i ++)
2214 cupsFilePrintf(fp, "File %d %s/%s %d\n", i + 1, job->filetypes[i]->super,
2215 job->filetypes[i]->type, job->compressions[i]);
2216 cupsFilePuts(fp, "</Job>\n");
ef416fc2 2217 }
b9faaae1 2218
321d8d57 2219 cupsdCloseCreatedConfFile(fp, filename);
e1d6a774 2220}
ef416fc2 2221
ef416fc2 2222
e1d6a774 2223/*
b9faaae1 2224 * 'cupsdSaveJob()' - Save a job to disk.
e1d6a774 2225 */
ef416fc2 2226
e1d6a774 2227void
b9faaae1 2228cupsdSaveJob(cupsd_job_t *job) /* I - Job */
e1d6a774 2229{
82cc1f9a 2230 char filename[1024]; /* Job control filename */
b9faaae1 2231 cups_file_t *fp; /* Job file */
3dfe78b3 2232
ef416fc2 2233
b9faaae1
MS		 2234 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSaveJob(job=%p(%d)): job->attrs=%p",
2235 job, job->id, job->attrs);
ef416fc2 2236
b9faaae1 2237 snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot, job->id);
ef416fc2 2238
82cc1f9a 2239 if ((fp = cupsdCreateConfFile(filename, ConfigFilePerm & 0600)) == NULL)
b9faaae1 2240 return;
ef416fc2 2241
b9faaae1 2242 fchown(cupsFileNumber(fp), RunUser, Group);
ef416fc2 2243
b9faaae1 2244 job->attrs->state = IPP_IDLE;
ef416fc2 2245
b9faaae1
MS		 2246 if (ippWriteIO(fp, (ipp_iocb_t)cupsFileWrite, 1, NULL,
2247 job->attrs) != IPP_DATA)
321d8d57 2248 {
72f50170 2249 cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to write job control file.");
321d8d57 2250 cupsFileClose(fp);
321d8d57
MS		 2251 return;
2252 }
ef416fc2 2253
82cc1f9a 2254 if (!cupsdCloseCreatedConfFile(fp, filename))
cb7f98ee
MS		 2255 {
2256 /*
2257 * Remove backup file and mark this job as clean...
2258 */
2259
2260 strlcat(filename, ".O", sizeof(filename));
2261 unlink(filename);
2262
82cc1f9a 2263 job->dirty = 0;
cb7f98ee 2264 }
e1d6a774 2265}
ef416fc2 2266
ef416fc2 2267
e1d6a774 2268/*
b9faaae1 2269 * 'cupsdSetJobHoldUntil()' - Set the hold time for a job.
e1d6a774 2270 */
ef416fc2 2271
b9faaae1
MS		 2272void
2273cupsdSetJobHoldUntil(cupsd_job_t *job, /* I - Job */
2274 const char *when, /* I - When to resume */
2275 int update)/* I - Update job-hold-until attr? */
e1d6a774 2276{
b9faaae1
MS		 2277 time_t curtime; /* Current time */
2278 struct tm *curdate; /* Current date */
2279 int hour; /* Hold hour */
2280 int minute; /* Hold minute */
2281 int second = 0; /* Hold second */
ef416fc2 2282
ef416fc2 2283
b9faaae1
MS		 2284 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2285 "cupsdSetJobHoldUntil(job=%p(%d), when=\"%s\", update=%d)",
2286 job, job->id, when, update);
ef416fc2 2287
b9faaae1 2288 if (update)
ef416fc2 2289 {
e1d6a774 2290 /*
b9faaae1 2291 * Update the job-hold-until attribute...
e1d6a774 2292 */
ef416fc2 2293
b9faaae1 2294 ipp_attribute_t *attr; /* job-hold-until attribute */
ef416fc2 2295
b9faaae1
MS		 2296 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
2297 IPP_TAG_KEYWORD)) == NULL)
2298 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
ef416fc2 2299
b9faaae1 2300 if (attr)
5e6c3df7 2301 ippSetString(job->attrs, &attr, 0, when);
b9faaae1
MS		 2302 else
2303 attr = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
2304 "job-hold-until", NULL, when);
ef416fc2 2305
b9faaae1
MS		 2306 if (attr)
2307 {
2308 if (isdigit(when[0] & 255))
2309 attr->value_tag = IPP_TAG_NAME;
2310 else
2311 attr->value_tag = IPP_TAG_KEYWORD;
2312
2313 job->dirty = 1;
2314 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2315 }
3e7fe0ca 2316
b9faaae1 2317 }
ef416fc2 2318
67dde2cc
MS		 2319 ippSetString(job->attrs, &job->reasons, 0, "job-hold-until-specified");
2320
b9faaae1
MS		 2321 /*
2322 * Update the hold time...
2323 */
2324
3e7fe0ca
MS		 2325 job->cancel_time = 0;
2326
b9faaae1
MS		 2327 if (!strcmp(when, "indefinite") || !strcmp(when, "auth-info-required"))
2328 {
e1d6a774 2329 /*
b9faaae1 2330 * Hold indefinitely...
e1d6a774 2331 */
ef416fc2 2332
b9faaae1 2333 job->hold_until = 0;
3e7fe0ca
MS		 2334
2335 if (MaxHoldTime > 0)
2336 job->cancel_time = time(NULL) + MaxHoldTime;
b9faaae1
MS		 2337 }
2338 else if (!strcmp(when, "day-time"))
2339 {
e1d6a774 2340 /*
b9faaae1 2341 * Hold to 6am the next morning unless local time is < 6pm.
e1d6a774 2342 */
ef416fc2 2343
b9faaae1
MS		 2344 curtime = time(NULL);
2345 curdate = localtime(&curtime);
ef416fc2 2346
b9faaae1
MS		 2347 if (curdate->tm_hour < 18)
2348 job->hold_until = curtime;
2349 else
2350 job->hold_until = curtime +
2351 ((29 - curdate->tm_hour) * 60 + 59 -
2352 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2353 }
2354 else if (!strcmp(when, "evening") || !strcmp(when, "night"))
2355 {
2356 /*
2357 * Hold to 6pm unless local time is > 6pm or < 6am.
2358 */
ef416fc2 2359
b9faaae1
MS		 2360 curtime = time(NULL);
2361 curdate = localtime(&curtime);
ef416fc2 2362
b9faaae1
MS		 2363 if (curdate->tm_hour < 6 || curdate->tm_hour >= 18)
2364 job->hold_until = curtime;
2365 else
2366 job->hold_until = curtime +
2367 ((17 - curdate->tm_hour) * 60 + 59 -
2368 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2369 }
2370 else if (!strcmp(when, "second-shift"))
2371 {
2372 /*
2373 * Hold to 4pm unless local time is > 4pm.
2374 */
ef416fc2 2375
b9faaae1
MS		 2376 curtime = time(NULL);
2377 curdate = localtime(&curtime);
ef416fc2 2378
b9faaae1
MS		 2379 if (curdate->tm_hour >= 16)
2380 job->hold_until = curtime;
2381 else
2382 job->hold_until = curtime +
2383 ((15 - curdate->tm_hour) * 60 + 59 -
2384 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2385 }
2386 else if (!strcmp(when, "third-shift"))
2387 {
2388 /*
2389 * Hold to 12am unless local time is < 8am.
2390 */
ef416fc2 2391
b9faaae1
MS		 2392 curtime = time(NULL);
2393 curdate = localtime(&curtime);
ef416fc2 2394
b9faaae1
MS		 2395 if (curdate->tm_hour < 8)
2396 job->hold_until = curtime;
2397 else
2398 job->hold_until = curtime +
2399 ((23 - curdate->tm_hour) * 60 + 59 -
2400 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2401 }
2402 else if (!strcmp(when, "weekend"))
2403 {
2404 /*
2405 * Hold to weekend unless we are in the weekend.
2406 */
ef416fc2 2407
b9faaae1
MS		 2408 curtime = time(NULL);
2409 curdate = localtime(&curtime);
ef416fc2 2410
b9faaae1
MS		 2411 if (curdate->tm_wday == 0 || curdate->tm_wday == 6)
2412 job->hold_until = curtime;
2413 else
2414 job->hold_until = curtime +
2415 (((5 - curdate->tm_wday) * 24 +
2416 (17 - curdate->tm_hour)) * 60 + 59 -
2417 curdate->tm_min) * 60 + 60 - curdate->tm_sec;
2418 }
2419 else if (sscanf(when, "%d:%d:%d", &hour, &minute, &second) >= 2)
2420 {
2421 /*
2422 * Hold to specified GMT time (HH:MM or HH:MM:SS)...
2423 */
bd7854cb 2424
b9faaae1
MS		 2425 curtime = time(NULL);
2426 curdate = gmtime(&curtime);
2427
2428 job->hold_until = curtime +
2429 ((hour - curdate->tm_hour) * 60 + minute -
2430 curdate->tm_min) * 60 + second - curdate->tm_sec;
2431
2432 /*
2433 * Hold until next day as needed...
2434 */
2435
2436 if (job->hold_until < curtime)
2437 job->hold_until += 24 * 60 * 60;
ef416fc2 2438 }
2439
b9faaae1
MS		 2440 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSetJobHoldUntil: hold_until=%d",
2441 (int)job->hold_until);
e1d6a774 2442}
ef416fc2 2443
ef416fc2 2444
e1d6a774 2445/*
b9faaae1
MS		 2446 * 'cupsdSetJobPriority()' - Set the priority of a job, moving it up/down in
2447 * the list as needed.
e1d6a774 2448 */
ef416fc2 2449
b9faaae1
MS		 2450void
2451cupsdSetJobPriority(
2452 cupsd_job_t *job, /* I - Job ID */
2453 int priority) /* I - New priority (0 to 100) */
e1d6a774 2454{
b9faaae1 2455 ipp_attribute_t *attr; /* Job attribute */
ef416fc2 2456
ef416fc2 2457
e1d6a774 2458 /*
b9faaae1 2459 * Don't change completed jobs...
e1d6a774 2460 */
bd7854cb 2461
b9faaae1 2462 if (job->state_value >= IPP_JOB_PROCESSING)
ef416fc2 2463 return;
ef416fc2 2464
e1d6a774 2465 /*
b9faaae1 2466 * Set the new priority and re-add the job into the active list...
e1d6a774 2467 */
ef416fc2 2468
b9faaae1 2469 cupsArrayRemove(ActiveJobs, job);
ef416fc2 2470
b9faaae1 2471 job->priority = priority;
ef416fc2 2472
b9faaae1
MS		 2473 if ((attr = ippFindAttribute(job->attrs, "job-priority",
2474 IPP_TAG_INTEGER)) != NULL)
2475 attr->values[0].integer = priority;
2476 else
2477 ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-priority",
2478 priority);
ef416fc2 2479
b9faaae1 2480 cupsArrayAdd(ActiveJobs, job);
bd7854cb 2481
b9faaae1
MS		 2482 job->dirty = 1;
2483 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2484}
bd7854cb 2485
ef416fc2 2486
b9faaae1
MS		 2487/*
2488 * 'cupsdSetJobState()' - Set the state of the specified print job.
2489 */
e1d6a774 2490
b9faaae1
MS		 2491void
2492cupsdSetJobState(
2493 cupsd_job_t *job, /* I - Job to cancel */
2494 ipp_jstate_t newstate, /* I - New job state */
2495 cupsd_jobaction_t action, /* I - Action to take */
2496 const char *message, /* I - Message to log */
2497 ...) /* I - Additional arguments as needed */
2498{
2499 int i; /* Looping var */
2500 ipp_jstate_t oldstate; /* Old state */
2501 char filename[1024]; /* Job filename */
2502 ipp_attribute_t *attr; /* Job attribute */
ef416fc2 2503
ef416fc2 2504
b9faaae1
MS		 2505 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2506 "cupsdSetJobState(job=%p(%d), state=%d, newstate=%d, "
2507 "action=%d, message=\"%s\")", job, job->id, job->state_value,
2508 newstate, action, message ? message : "(null)");
ef416fc2 2509
bd7854cb 2510
b9faaae1
MS		 2511 /*
2512 * Make sure we have the job attributes...
2513 */
e1d6a774 2514
b9faaae1
MS		 2515 if (!cupsdLoadJob(job))
2516 return;
bd7854cb 2517
f99f3698
MS		 2518 /*
2519 * Don't do anything if the state is unchanged and we aren't purging the
2520 * job...
2521 */
2522
2523 oldstate = job->state_value;
2524 if (newstate == oldstate && action != CUPSD_JOB_PURGE)
2525 return;
e1d6a774 2526
b9faaae1
MS		 2527 /*
2528 * Stop any processes that are working on the current job...
2529 */
e1d6a774 2530
b9faaae1 2531 if (oldstate == IPP_JOB_PROCESSING)
ef55b745 2532 stop_job(job, action);
b9faaae1
MS		 2533
2534 /*
2535 * Set the new job state...
2536 */
2537
0fa6c7fa
MS		 2538 job->state_value = newstate;
2539
2540 if (job->state)
2541 job->state->values[0].integer = newstate;
b9faaae1
MS		 2542
2543 switch (newstate)
2544 {
2545 case IPP_JOB_PENDING :
2546 /*
2547 * Update job-hold-until as needed...
2548 */
2549
2550 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
2551 IPP_TAG_KEYWORD)) == NULL)
2552 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
2553
2554 if (attr)
ef416fc2 2555 {
5e6c3df7
MS		 2556 ippSetValueTag(job->attrs, &attr, IPP_TAG_KEYWORD);
2557 ippSetString(job->attrs, &attr, 0, "no-hold");
e1d6a774 2558 }
ef416fc2 2559
b9faaae1
MS		 2560 default :
2561 break;
ef416fc2 2562
b9faaae1
MS		 2563 case IPP_JOB_ABORTED :
2564 case IPP_JOB_CANCELED :
2565 case IPP_JOB_COMPLETED :
2566 set_time(job, "time-at-completed");
12f89d24 2567 ippSetString(job->attrs, &job->reasons, 0, "processing-to-stop-point");
b9faaae1
MS		 2568 break;
2569 }
ef416fc2 2570
b9faaae1
MS		 2571 /*
2572 * Log message as needed...
2573 */
ef416fc2 2574
b9faaae1
MS		 2575 if (message)
2576 {
2577 char buffer[2048]; /* Message buffer */
2578 va_list ap; /* Pointer to additional arguments */
ef416fc2 2579
b9faaae1
MS		 2580 va_start(ap, message);
2581 vsnprintf(buffer, sizeof(buffer), message, ap);
2582 va_end(ap);
bd7854cb 2583
b9faaae1
MS		 2584 if (newstate > IPP_JOB_STOPPED)
2585 cupsdAddEvent(CUPSD_EVENT_JOB_COMPLETED, job->printer, job, "%s", buffer);
2586 else
2587 cupsdAddEvent(CUPSD_EVENT_JOB_STATE, job->printer, job, "%s", buffer);
2588
2589 if (newstate == IPP_JOB_STOPPED || newstate == IPP_JOB_ABORTED)
2590 cupsdLogJob(job, CUPSD_LOG_ERROR, "%s", buffer);
2591 else
2592 cupsdLogJob(job, CUPSD_LOG_INFO, "%s", buffer);
2593 }
2594
2595 /*
2596 * Handle post-state-change actions...
2597 */
2598
2599 switch (newstate)
2600 {
2601 case IPP_JOB_PROCESSING :
e1d6a774 2602 /*
b9faaae1 2603 * Add the job to the "printing" list...
e1d6a774 2604 */
bd7854cb 2605
b9faaae1
MS		 2606 if (!cupsArrayFind(PrintingJobs, job))
2607 cupsArrayAdd(PrintingJobs, job);
ef416fc2 2608
b9faaae1
MS		 2609 /*
2610 * Set the processing time...
2611 */
ef416fc2 2612
b9faaae1
MS		 2613 set_time(job, "time-at-processing");
2614
2615 case IPP_JOB_PENDING :
2616 case IPP_JOB_HELD :
2617 case IPP_JOB_STOPPED :
e1d6a774 2618 /*
b9faaae1 2619 * Make sure the job is in the active list...
e1d6a774 2620 */
ef416fc2 2621
b9faaae1
MS		 2622 if (!cupsArrayFind(ActiveJobs, job))
2623 cupsArrayAdd(ActiveJobs, job);
ef416fc2 2624
b9faaae1
MS		 2625 /*
2626 * Save the job state to disk...
2627 */
ef416fc2 2628
b9faaae1
MS		 2629 job->dirty = 1;
2630 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2631 break;
ef416fc2 2632
b9faaae1
MS		 2633 case IPP_JOB_ABORTED :
2634 case IPP_JOB_CANCELED :
2635 case IPP_JOB_COMPLETED :
7a0cbd5e
MS		 2636 if (newstate == IPP_JOB_CANCELED)
2637 {
2638 /*
2639 * Remove the job from the active list if there are no processes still
2640 * running for it...
2641 */
ef416fc2 2642
7a0cbd5e
MS		 2643 for (i = 0; job->filters[i] < 0; i++);
2644
2645 if (!job->filters[i] && job->backend <= 0)
2646 cupsArrayRemove(ActiveJobs, job);
2647 }
2648 else
2649 {
2650 /*
2651 * Otherwise just remove the job from the active list immediately...
2652 */
2653
2654 cupsArrayRemove(ActiveJobs, job);
2655 }
ef416fc2 2656
b9faaae1 2657 /*
7a0cbd5e 2658 * Expire job subscriptions since the job is now "completed"...
b9faaae1 2659 */
ef416fc2 2660
7a0cbd5e 2661 cupsdExpireSubscriptions(NULL, job);
ef416fc2 2662
b9faaae1
MS		 2663#ifdef __APPLE__
2664 /*
2665 * If we are going to sleep and the PrintingJobs count is now 0, allow the
2666 * sleep to happen immediately...
2667 */
ef416fc2 2668
b9faaae1
MS		 2669 if (Sleeping && cupsArrayCount(PrintingJobs) == 0)
2670 cupsdAllowSleep();
2671#endif /* __APPLE__ */
ef416fc2 2672
b9faaae1
MS		 2673 /*
2674 * Remove any authentication data...
2675 */
bd7854cb 2676
b9faaae1
MS		 2677 snprintf(filename, sizeof(filename), "%s/a%05d", RequestRoot, job->id);
2678 if (cupsdRemoveFile(filename) && errno != ENOENT)
2679 cupsdLogMessage(CUPSD_LOG_ERROR,
2680 "Unable to remove authentication cache: %s",
2681 strerror(errno));
bd7854cb 2682
88f9aafc
MS		 2683 for (i = 0;
2684 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
2685 i ++)
2686 cupsdClearString(job->auth_env + i);
2687
07ed0e9a 2688 cupsdClearString(&job->auth_uid);
ef416fc2 2689
b9faaae1
MS		 2690 /*
2691 * Remove the print file for good if we aren't preserving jobs or
2692 * files...
2693 */
e1d6a774 2694
b9faaae1 2695 if (!JobHistory || !JobFiles || action == CUPSD_JOB_PURGE)
82cc1f9a 2696 remove_job_files(job);
ef416fc2 2697
b9faaae1
MS		 2698 if (JobHistory && action != CUPSD_JOB_PURGE)
2699 {
2700 /*
2701 * Save job state info...
2702 */
e1d6a774 2703
b9faaae1
MS		 2704 job->dirty = 1;
2705 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
2706 }
ba55dc12
MS		 2707 else if (!job->printer)
2708 {
2709 /*
2710 * Delete the job immediately if not actively printing...
2711 */
2712
2713 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
2714 job = NULL;
2715 }
b9faaae1 2716 break;
e1d6a774 2717 }
2718
e07d4801
MS		 2719 /*
2720 * Finalize the job immediately if we forced things...
2721 */
2722
ba55dc12 2723 if (action >= CUPSD_JOB_FORCE && job && job->printer)
ef55b745 2724 finalize_job(job, 0);
e07d4801 2725
e1d6a774 2726 /*
b9faaae1 2727 * Update the server "busy" state...
e1d6a774 2728 */
ef416fc2 2729
b9faaae1
MS		 2730 cupsdSetBusyState();
2731}
e00b005a 2732
ef416fc2 2733
b9faaae1
MS		 2734/*
2735 * 'cupsdStopAllJobs()' - Stop all print jobs.
2736 */
ef416fc2 2737
b9faaae1
MS		 2738void
2739cupsdStopAllJobs(
238c3832
MS		 2740 cupsd_jobaction_t action, /* I - Action */
2741 int kill_delay) /* I - Number of seconds before we kill */
b9faaae1
MS		 2742{
2743 cupsd_job_t *job; /* Current job */
ef416fc2 2744
ef416fc2 2745
b9faaae1 2746 DEBUG_puts("cupsdStopAllJobs()");
ef416fc2 2747
b9faaae1
MS		 2748 for (job = (cupsd_job_t *)cupsArrayFirst(PrintingJobs);
2749 job;
2750 job = (cupsd_job_t *)cupsArrayNext(PrintingJobs))
238c3832 2751 {
581dae2d
MS		 2752 if (job->completed)
2753 {
2754 cupsdSetJobState(job, IPP_JOB_COMPLETED, CUPSD_JOB_FORCE, NULL);
2755 }
2756 else
2757 {
2758 if (kill_delay)
2759 job->kill_time = time(NULL) + kill_delay;
238c3832 2760
581dae2d
MS		 2761 cupsdSetJobState(job, IPP_JOB_PENDING, action, NULL);
2762 }
238c3832 2763 }
b9faaae1 2764}
bd7854cb 2765
bd7854cb 2766
b9faaae1
MS		 2767/*
2768 * 'cupsdUnloadCompletedJobs()' - Flush completed job history from memory.
2769 */
ef416fc2 2770
b9faaae1
MS		 2771void
2772cupsdUnloadCompletedJobs(void)
2773{
2774 cupsd_job_t *job; /* Current job */
2775 time_t expire; /* Expiration time */
ef416fc2 2776
b9faaae1
MS		 2777
2778 expire = time(NULL) - 60;
2779
2780 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
2781 job;
2782 job = (cupsd_job_t *)cupsArrayNext(Jobs))
2783 if (job->attrs && job->state_value >= IPP_JOB_STOPPED && !job->printer &&
2784 job->access_time < expire)
2785 {
2786 if (job->dirty)
2787 cupsdSaveJob(job);
2788
2789 unload_job(job);
2790 }
e1d6a774 2791}
ef416fc2 2792
ef416fc2 2793
82cc1f9a
MS		 2794/*
2795 * 'cupsdUpdateJobs()' - Update the history/file files for all jobs.
2796 */
2797
2798void
2799cupsdUpdateJobs(void)
2800{
2801 cupsd_job_t *job; /* Current job */
2802 time_t curtime; /* Current time */
2803 ipp_attribute_t *attr; /* time-at-completed attribute */
2804
2805
2806 curtime = time(NULL);
2807 JobHistoryUpdate = 0;
2808
2809 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
2810 job;
2811 job = (cupsd_job_t *)cupsArrayNext(Jobs))
2812 {
2813 if (job->state_value >= IPP_JOB_CANCELED &&
2814 (attr = ippFindAttribute(job->attrs, "time-at-completed",
2815 IPP_TAG_INTEGER)) != NULL)
2816 {
2817 /*
2818 * Update history/file expiration times...
2819 */
2820
2821 if (JobHistory < INT_MAX)
2822 job->history_time = attr->values[0].integer + JobHistory;
2823 else
2824 job->history_time = INT_MAX;
2825
2826 if (job->history_time < curtime)
2827 {
2828 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
2829 continue;
2830 }
2831
2832 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
2833 JobHistoryUpdate = job->history_time;
2834
2835 if (JobFiles < INT_MAX)
2836 job->file_time = attr->values[0].integer + JobFiles;
2837 else
2838 job->file_time = INT_MAX;
2839
2840 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
2841 JobHistoryUpdate = job->file_time;
2842 }
2843 }
2844
2845 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdUpdateAllJobs: JobHistoryUpdate=%ld",
2846 (long)JobHistoryUpdate);
2847}
2848
2849
e1d6a774 2850/*
b9faaae1 2851 * 'compare_active_jobs()' - Compare the job IDs and priorities of two jobs.
e1d6a774 2852 */
ef416fc2 2853
b9faaae1
MS		 2854static int /* O - Difference */
2855compare_active_jobs(void *first, /* I - First job */
2856 void *second, /* I - Second job */
2857 void *data) /* I - App data (not used) */
e1d6a774 2858{
b9faaae1 2859 int diff; /* Difference */
ef416fc2 2860
ef416fc2 2861
321d8d57
MS		 2862 (void)data;
2863
b9faaae1
MS		 2864 if ((diff = ((cupsd_job_t *)second)->priority -
2865 ((cupsd_job_t *)first)->priority) != 0)
2866 return (diff);
2867 else
2868 return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
e1d6a774 2869}
bd7854cb 2870
ef416fc2 2871
eec1fbc3
MS		 2872/*
2873 * 'compare_completed_jobs()' - Compare the job IDs and completion times of two jobs.
2874 */
2875
2876static int /* O - Difference */
2877compare_completed_jobs(void *first, /* I - First job */
2878 void *second, /* I - Second job */
2879 void *data) /* I - App data (not used) */
2880{
2881 int diff; /* Difference */
2882
2883
2884 (void)data;
2885
2886 if ((diff = ((cupsd_job_t *)second)->completed_time -
2887 ((cupsd_job_t *)first)->completed_time) != 0)
2888 return (diff);
2889 else
2890 return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
2891}
2892
2893
e1d6a774 2894/*
b9faaae1 2895 * 'compare_jobs()' - Compare the job IDs of two jobs.
e1d6a774 2896 */
ef416fc2 2897
b9faaae1
MS		 2898static int /* O - Difference */
2899compare_jobs(void *first, /* I - First job */
2900 void *second, /* I - Second job */
2901 void *data) /* I - App data (not used) */
e1d6a774 2902{
321d8d57
MS		 2903 (void)data;
2904
b9faaae1
MS		 2905 return (((cupsd_job_t *)first)->id - ((cupsd_job_t *)second)->id);
2906}
ef416fc2 2907
ef416fc2 2908
178cb736
MS		 2909/*
2910 * 'dump_job_history()' - Dump any debug messages for a job.
2911 */
2912
2913static void
2914dump_job_history(cupsd_job_t *job) /* I - Job */
2915{
2916 int i, /* Looping var */
2917 oldsize; /* Current MaxLogSize */
2918 struct tm *date; /* Date/time value */
2919 cupsd_joblog_t *message; /* Current message */
2920 char temp[2048], /* Log message */
2921 *ptr, /* Pointer into log message */
2922 start[256], /* Start time */
2923 end[256]; /* End time */
2924 cupsd_printer_t *printer; /* Printer for job */
2925
2926
2927 /*
2928 * See if we have anything to dump...
2929 */
2930
2931 if (!job->history)
2932 return;
2933
2934 /*
2935 * Disable log rotation temporarily...
2936 */
2937
2938 oldsize = MaxLogSize;
2939 MaxLogSize = 0;
2940
2941 /*
2942 * Copy the debug messages to the log...
2943 */
2944
2945 message = (cupsd_joblog_t *)cupsArrayFirst(job->history);
2946 date = localtime(&(message->time));
2947 strftime(start, sizeof(start), "%X", date);
2948
2949 message = (cupsd_joblog_t *)cupsArrayLast(job->history);
2950 date = localtime(&(message->time));
2951 strftime(end, sizeof(end), "%X", date);
2952
2953 snprintf(temp, sizeof(temp),
2954 "[Job %d] The following messages were recorded from %s to %s",
2955 job->id, start, end);
2956 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2957
2958 for (message = (cupsd_joblog_t *)cupsArrayFirst(job->history);
2959 message;
2960 message = (cupsd_joblog_t *)cupsArrayNext(job->history))
2961 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, message->message);
2962
2963 snprintf(temp, sizeof(temp), "[Job %d] End of messages", job->id);
2964 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2965
2966 /*
2967 * Log the printer state values...
2968 */
2969
2970 if ((printer = job->printer) == NULL)
2971 printer = cupsdFindDest(job->dest);
2972
2973 if (printer)
2974 {
2975 snprintf(temp, sizeof(temp), "[Job %d] printer-state=%d(%s)", job->id,
2976 printer->state,
2977 printer->state == IPP_PRINTER_IDLE ? "idle" :
2978 printer->state == IPP_PRINTER_PROCESSING ? "processing" :
2979 "stopped");
2980 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2981
2982 snprintf(temp, sizeof(temp), "[Job %d] printer-state-message=\"%s\"",
2983 job->id, printer->state_message);
2984 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
2985
2986 snprintf(temp, sizeof(temp), "[Job %d] printer-state-reasons=", job->id);
2987 ptr = temp + strlen(temp);
2988 if (printer->num_reasons == 0)
7e86f2f6 2989 strlcpy(ptr, "none", sizeof(temp) - (size_t)(ptr - temp));
178cb736
MS		 2990 else
2991 {
2992 for (i = 0;
2993 i < printer->num_reasons && ptr < (temp + sizeof(temp) - 2);
2994 i ++)
2995 {
2996 if (i)
2997 *ptr++ = ',';
2998
7e86f2f6 2999 strlcpy(ptr, printer->reasons[i], sizeof(temp) - (size_t)(ptr - temp));
178cb736
MS		 3000 ptr += strlen(ptr);
3001 }
3002 }
3003 cupsdWriteErrorLog(CUPSD_LOG_DEBUG, temp);
3004 }
3005
3006 /*
3007 * Restore log file rotation...
3008 */
3009
3010 MaxLogSize = oldsize;
3011
3012 /*
3013 * Free all messages...
3014 */
3015
3016 free_job_history(job);
3017}
3018
3019
3020/*
3021 * 'free_job_history()' - Free any log history.
3022 */
3023
3024static void
3025free_job_history(cupsd_job_t *job) /* I - Job */
3026{
3027 char *message; /* Current message */
3028
3029
3030 if (!job->history)
3031 return;
3032
3033 for (message = (char *)cupsArrayFirst(job->history);
3034 message;
3035 message = (char *)cupsArrayNext(job->history))
3036 free(message);
3037
3038 cupsArrayDelete(job->history);
3039 job->history = NULL;
3040}
3041
3042
b9faaae1
MS		 3043/*
3044 * 'finalize_job()' - Cleanup after job filter processes and support data.
3045 */
ef416fc2 3046
b9faaae1 3047static void
ef55b745
MS		 3048finalize_job(cupsd_job_t *job, /* I - Job */
3049 int set_job_state) /* I - 1 = set the job state */
b9faaae1
MS		 3050{
3051 ipp_pstate_t printer_state; /* New printer state value */
3052 ipp_jstate_t job_state; /* New job state value */
3053 const char *message; /* Message for job state */
3054 char buffer[1024]; /* Buffer for formatted messages */
e00b005a 3055
b9faaae1
MS		 3056
3057 cupsdLogMessage(CUPSD_LOG_DEBUG2, "finalize_job(job=%p(%d))", job, job->id);
ef416fc2 3058
e1d6a774 3059 /*
1e3e80bb
MS		 3060 * Clear the "connecting-to-device" and "cups-waiting-for-job-completed"
3061 * reasons, which are only valid when a printer is processing, along with any
3062 * remote printing job state...
e1d6a774 3063 */
ef416fc2 3064
07ed0e9a 3065 cupsdSetPrinterReasons(job->printer, "-connecting-to-device,"
1e3e80bb 3066 "cups-waiting-for-job-completed,"
07ed0e9a
MS		 3067 "cups-remote-pending,"
3068 "cups-remote-pending-held,"
3069 "cups-remote-processing,"
3070 "cups-remote-stopped,"
3071 "cups-remote-canceled,"
3072 "cups-remote-aborted,"
3073 "cups-remote-completed");
ef416fc2 3074
e1d6a774 3075 /*
b9faaae1
MS		 3076 * Similarly, clear the "offline-report" reason for non-USB devices since we
3077 * rarely have current information for network devices...
e1d6a774 3078 */
ef416fc2 3079
a469f8a5
MS		 3080 if (strncmp(job->printer->device_uri, "usb:", 4) &&
3081 strncmp(job->printer->device_uri, "ippusb:", 7))
b9faaae1 3082 cupsdSetPrinterReasons(job->printer, "-offline-report");
ef416fc2 3083
b9faaae1
MS		 3084 /*
3085 * Free the security profile...
3086 */
ef416fc2 3087
b9faaae1
MS		 3088 cupsdDestroyProfile(job->profile);
3089 job->profile = NULL;
8fe0183a
MS		 3090 cupsdDestroyProfile(job->bprofile);
3091 job->bprofile = NULL;
ef416fc2 3092
10d09e33 3093 /*
a469f8a5 3094 * Clear the unresponsive job watchdog timers...
10d09e33
MS		 3095 */
3096
a469f8a5
MS		 3097 job->cancel_time = 0;
3098 job->kill_time = 0;
10d09e33 3099
b9faaae1
MS		 3100 /*
3101 * Close pipes and status buffer...
3102 */
ef416fc2 3103
b9faaae1
MS		 3104 cupsdClosePipe(job->print_pipes);
3105 cupsdClosePipe(job->back_pipes);
3106 cupsdClosePipe(job->side_pipes);
ef416fc2 3107
e07d4801
MS		 3108 cupsdRemoveSelect(job->status_pipes[0]);
3109 cupsdClosePipe(job->status_pipes);
b9faaae1
MS		 3110 cupsdStatBufDelete(job->status_buffer);
3111 job->status_buffer = NULL;
ef416fc2 3112
e1d6a774 3113 /*
b9faaae1 3114 * Process the exit status...
e1d6a774 3115 */
ef416fc2 3116
1340db2d
MS		 3117 if (job->printer->state == IPP_PRINTER_PROCESSING)
3118 printer_state = IPP_PRINTER_IDLE;
3119 else
3120 printer_state = job->printer->state;
3121
3122 switch (job_state = job->state_value)
3123 {
3124 case IPP_JOB_PENDING :
3125 message = "Job paused.";
3126 break;
3127
3128 case IPP_JOB_HELD :
3129 message = "Job held.";
3130 break;
3131
3132 default :
3133 case IPP_JOB_PROCESSING :
3134 case IPP_JOB_COMPLETED :
f11a948a
MS		 3135 job_state = IPP_JOB_COMPLETED;
3136 message = "Job completed.";
12f89d24 3137
6961465f
MS		 3138 if (!job->status)
3139 ippSetString(job->attrs, &job->reasons, 0,
3140 "job-completed-successfully");
1340db2d
MS		 3141 break;
3142
3143 case IPP_JOB_STOPPED :
3144 message = "Job stopped.";
12f89d24
MS		 3145
3146 ippSetString(job->attrs, &job->reasons, 0, "job-stopped");
1340db2d
MS		 3147 break;
3148
3149 case IPP_JOB_CANCELED :
3150 message = "Job canceled.";
12f89d24
MS		 3151
3152 ippSetString(job->attrs, &job->reasons, 0, "job-canceled-by-user");
1340db2d
MS		 3153 break;
3154
3155 case IPP_JOB_ABORTED :
3156 message = "Job aborted.";
3157 break;
3158 }
ef416fc2 3159
b9faaae1 3160 if (job->status < 0)
e1d6a774 3161 {
3162 /*
b9faaae1 3163 * Backend had errors...
e1d6a774 3164 */
ef416fc2 3165
b9faaae1
MS		 3166 int exit_code; /* Exit code from backend */
3167
e1d6a774 3168 /*
b9faaae1
MS		 3169 * Convert the status to an exit code. Due to the way the W* macros are
3170 * implemented on MacOS X (bug?), we have to store the exit status in a
3171 * variable first and then convert...
e1d6a774 3172 */
ef416fc2 3173
b9faaae1
MS		 3174 exit_code = -job->status;
3175 if (WIFEXITED(exit_code))
3176 exit_code = WEXITSTATUS(exit_code);
3177 else
12f89d24
MS		 3178 {
3179 ippSetString(job->attrs, &job->reasons, 0, "cups-backend-crashed");
b9faaae1 3180 exit_code = job->status;
12f89d24 3181 }
ef416fc2 3182
b9faaae1
MS		 3183 cupsdLogJob(job, CUPSD_LOG_INFO, "Backend returned status %d (%s)",
3184 exit_code,
3185 exit_code == CUPS_BACKEND_FAILED ? "failed" :
3186 exit_code == CUPS_BACKEND_AUTH_REQUIRED ?
3187 "authentication required" :
3188 exit_code == CUPS_BACKEND_HOLD ? "hold job" :
3189 exit_code == CUPS_BACKEND_STOP ? "stop printer" :
3190 exit_code == CUPS_BACKEND_CANCEL ? "cancel job" :
a469f8a5
MS		 3191 exit_code == CUPS_BACKEND_RETRY ? "retry job later" :
3192 exit_code == CUPS_BACKEND_RETRY_CURRENT ? "retry job immediately" :
b9faaae1 3193 exit_code < 0 ? "crashed" : "unknown");
ef416fc2 3194
ef416fc2 3195 /*
b9faaae1 3196 * Do what needs to be done...
ef416fc2 3197 */
3198
b9faaae1 3199 switch (exit_code)
f7deaa1a 3200 {
b9faaae1
MS		 3201 default :
3202 case CUPS_BACKEND_FAILED :
3203 /*
3204 * Backend failure, use the error-policy to determine how to
3205 * act...
3206 */
f7deaa1a 3207
a2326b5b 3208 if (job->dtype & CUPS_PRINTER_CLASS)
b9faaae1
MS		 3209 {
3210 /*
3211 * Queued on a class - mark the job as pending and we'll retry on
3212 * another printer...
3213 */
f7deaa1a 3214
8b116e60
MS		 3215 if (job_state == IPP_JOB_COMPLETED)
3216 {
3217 job_state = IPP_JOB_PENDING;
3218 message = "Retrying job on another printer.";
12f89d24
MS		 3219
3220 ippSetString(job->attrs, &job->reasons, 0,
3221 "resources-are-not-ready");
8b116e60 3222 }
b9faaae1
MS		 3223 }
3224 else if (!strcmp(job->printer->error_policy, "retry-current-job"))
3225 {
3226 /*
3227 * The error policy is "retry-current-job" - mark the job as pending
3228 * and we'll retry on the same printer...
3229 */
f7deaa1a 3230
8b116e60
MS		 3231 if (job_state == IPP_JOB_COMPLETED)
3232 {
3233 job_state = IPP_JOB_PENDING;
3234 message = "Retrying job on same printer.";
12f89d24
MS		 3235
3236 ippSetString(job->attrs, &job->reasons, 0, "none");
8b116e60 3237 }
b9faaae1
MS		 3238 }
3239 else if ((job->printer->type & CUPS_PRINTER_FAX) ||
3240 !strcmp(job->printer->error_policy, "retry-job"))
3241 {
8b116e60 3242 if (job_state == IPP_JOB_COMPLETED)
b9faaae1
MS		 3243 {
3244 /*
8b116e60
MS		 3245 * The job was queued on a fax or the error policy is "retry-job" -
3246 * hold the job if the number of retries is less than the
3247 * JobRetryLimit, otherwise abort the job.
b9faaae1 3248 */
ef416fc2 3249
8b116e60
MS		 3250 job->tries ++;
3251
7cf5915e 3252 if (job->tries > JobRetryLimit && JobRetryLimit > 0)
8b116e60
MS		 3253 {
3254 /*
3255 * Too many tries...
3256 */
3257
3258 snprintf(buffer, sizeof(buffer),
3259 "Job aborted after %d unsuccessful attempts.",
3260 JobRetryLimit);
3261 job_state = IPP_JOB_ABORTED;
3262 message = buffer;
12f89d24
MS		 3263
3264 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
8b116e60
MS		 3265 }
3266 else
3267 {
3268 /*
3269 * Try again in N seconds...
3270 */
ef416fc2 3271
8b116e60
MS		 3272 snprintf(buffer, sizeof(buffer),
3273 "Job held for %d seconds since it could not be sent.",
3274 JobRetryInterval);
0268488e
MS		 3275
3276 job->hold_until = time(NULL) + JobRetryInterval;
3277 job_state = IPP_JOB_HELD;
3278 message = buffer;
12f89d24
MS		 3279
3280 ippSetString(job->attrs, &job->reasons, 0,
3281 "resources-are-not-ready");
8b116e60
MS		 3282 }
3283 }
b9faaae1 3284 }
8b116e60
MS		 3285 else if (!strcmp(job->printer->error_policy, "abort-job") &&
3286 job_state == IPP_JOB_COMPLETED)
b9faaae1
MS		 3287 {
3288 job_state = IPP_JOB_ABORTED;
3289 message = "Job aborted due to backend errors; please consult "
3290 "the error_log file for details.";
12f89d24
MS		 3291
3292 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
b9faaae1 3293 }
f11a948a 3294 else if (job->state_value == IPP_JOB_PROCESSING)
b9faaae1 3295 {
f11a948a 3296 job_state = IPP_JOB_PENDING;
b9faaae1 3297 printer_state = IPP_PRINTER_STOPPED;
b9faaae1 3298 message = "Printer stopped due to backend errors; please "
8b116e60 3299 "consult the error_log file for details.";
12f89d24
MS		 3300
3301 ippSetString(job->attrs, &job->reasons, 0, "none");
b9faaae1
MS		 3302 }
3303 break;
bd7854cb 3304
b9faaae1
MS		 3305 case CUPS_BACKEND_CANCEL :
3306 /*
f3c17241 3307 * Cancel the job...
b9faaae1 3308 */
bd7854cb 3309
8b116e60
MS		 3310 if (job_state == IPP_JOB_COMPLETED)
3311 {
f3c17241
MS		 3312 job_state = IPP_JOB_CANCELED;
3313 message = "Job canceled at printer.";
12f89d24 3314
f3c17241 3315 ippSetString(job->attrs, &job->reasons, 0, "canceled-at-device");
8b116e60 3316 }
b9faaae1 3317 break;
bd7854cb 3318
b9faaae1 3319 case CUPS_BACKEND_HOLD :
8b116e60
MS		 3320 if (job_state == IPP_JOB_COMPLETED)
3321 {
3322 /*
3323 * Hold the job...
3324 */
bd7854cb 3325
6961465f 3326 const char *reason = ippGetString(job->reasons, 0, NULL);
bd7854cb 3327
6961465f
MS		 3328 cupsdLogJob(job, CUPSD_LOG_DEBUG, "job-state-reasons=\"%s\"",
3329 reason);
3330
3331 if (!reason || strncmp(reason, "account-", 8))
3332 {
3333 cupsdSetJobHoldUntil(job, "indefinite", 1);
3334
3335 ippSetString(job->attrs, &job->reasons, 0,
3336 "job-hold-until-specified");
3337 message = "Job held indefinitely due to backend errors; please "
8b116e60 3338 "consult the error_log file for details.";
6961465f
MS		 3339 }
3340 else if (!strcmp(reason, "account-info-needed"))
3341 {
3342 cupsdSetJobHoldUntil(job, "indefinite", 0);
3343
3344 message = "Job held indefinitely - account information is "
3345 "required.";
3346 }
3347 else if (!strcmp(reason, "account-closed"))
3348 {
3349 cupsdSetJobHoldUntil(job, "indefinite", 0);
3350
3351 message = "Job held indefinitely - account has been closed.";
3352 }
3353 else if (!strcmp(reason, "account-limit-reached"))
3354 {
3355 cupsdSetJobHoldUntil(job, "indefinite", 0);
3356
3357 message = "Job held indefinitely - account limit has been "
3358 "reached.";
3359 }
3360 else
3361 {
3362 cupsdSetJobHoldUntil(job, "indefinite", 0);
3363
3364 message = "Job held indefinitely - account authorization failed.";
3365 }
3366
3367 job_state = IPP_JOB_HELD;
8b116e60 3368 }
b9faaae1 3369 break;
2abf387c 3370
b9faaae1
MS		 3371 case CUPS_BACKEND_STOP :
3372 /*
3373 * Stop the printer...
3374 */
bd7854cb 3375
b9faaae1 3376 printer_state = IPP_PRINTER_STOPPED;
b9faaae1
MS		 3377 message = "Printer stopped due to backend errors; please "
3378 "consult the error_log file for details.";
8b116e60
MS		 3379
3380 if (job_state == IPP_JOB_COMPLETED)
12f89d24 3381 {
8b116e60 3382 job_state = IPP_JOB_PENDING;
12f89d24
MS		 3383
3384 ippSetString(job->attrs, &job->reasons, 0,
3385 "resources-are-not-ready");
3386 }
b9faaae1 3387 break;
bd7854cb 3388
b9faaae1
MS		 3389 case CUPS_BACKEND_AUTH_REQUIRED :
3390 /*
3391 * Hold the job for authentication...
3392 */
bd7854cb 3393
8b116e60
MS		 3394 if (job_state == IPP_JOB_COMPLETED)
3395 {
3396 cupsdSetJobHoldUntil(job, "auth-info-required", 1);
ef416fc2 3397
8b116e60
MS		 3398 job_state = IPP_JOB_HELD;
3399 message = "Job held for authentication.";
12f89d24 3400
a469f8a5
MS		 3401 if (strncmp(job->reasons->values[0].string.text, "account-", 8))
3402 ippSetString(job->attrs, &job->reasons, 0,
3403 "cups-held-for-authentication");
8b116e60 3404 }
b9faaae1 3405 break;
22c9029b
MS		 3406
3407 case CUPS_BACKEND_RETRY :
3408 if (job_state == IPP_JOB_COMPLETED)
3409 {
3410 /*
3411 * Hold the job if the number of retries is less than the
3412 * JobRetryLimit, otherwise abort the job.
3413 */
3414
3415 job->tries ++;
3416
3417 if (job->tries > JobRetryLimit && JobRetryLimit > 0)
3418 {
3419 /*
3420 * Too many tries...
3421 */
3422
3423 snprintf(buffer, sizeof(buffer),
3424 "Job aborted after %d unsuccessful attempts.",
3425 JobRetryLimit);
3426 job_state = IPP_JOB_ABORTED;
3427 message = buffer;
12f89d24
MS		 3428
3429 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
22c9029b
MS		 3430 }
3431 else
3432 {
3433 /*
3434 * Try again in N seconds...
3435 */
3436
3437 snprintf(buffer, sizeof(buffer),
3438 "Job held for %d seconds since it could not be sent.",
3439 JobRetryInterval);
3440
3441 job->hold_until = time(NULL) + JobRetryInterval;
3442 job_state = IPP_JOB_HELD;
3443 message = buffer;
12f89d24
MS		 3444
3445 ippSetString(job->attrs, &job->reasons, 0,
3446 "resources-are-not-ready");
22c9029b
MS		 3447 }
3448 }
3449 break;
3450
3451 case CUPS_BACKEND_RETRY_CURRENT :
3452 /*
3453 * Mark the job as pending and retry on the same printer...
3454 */
3455
3456 if (job_state == IPP_JOB_COMPLETED)
3457 {
3458 job_state = IPP_JOB_PENDING;
3459 message = "Retrying job on same printer.";
12f89d24
MS		 3460
3461 ippSetString(job->attrs, &job->reasons, 0, "none");
22c9029b
MS		 3462 }
3463 break;
e1d6a774 3464 }
3465 }
b9faaae1 3466 else if (job->status > 0)
ef416fc2 3467 {
3468 /*
b9faaae1 3469 * Filter had errors; stop job...
ef416fc2 3470 */
3471
8b116e60
MS		 3472 if (job_state == IPP_JOB_COMPLETED)
3473 {
3474 job_state = IPP_JOB_STOPPED;
3475 message = "Job stopped due to filter errors; please consult the "
3476 "error_log file for details.";
12f89d24
MS		 3477
3478 if (WIFSIGNALED(job->status))
3479 ippSetString(job->attrs, &job->reasons, 0, "cups-filter-crashed");
3480 else
3481 ippSetString(job->attrs, &job->reasons, 0, "job-completed-with-errors");
8b116e60 3482 }
e1d6a774 3483 }
e00b005a 3484
3dfe78b3 3485 /*
b9faaae1 3486 * Update the printer and job state.
3dfe78b3
MS		 3487 */
3488
321d8d57 3489 if (set_job_state && job_state != job->state_value)
ef55b745
MS		 3490 cupsdSetJobState(job, job_state, CUPSD_JOB_DEFAULT, "%s", message);
3491
b9faaae1
MS		 3492 cupsdSetPrinterState(job->printer, printer_state,
3493 printer_state == IPP_PRINTER_STOPPED);
3494 update_job_attrs(job, 0);
3dfe78b3 3495
178cb736
MS		 3496 if (job->history)
3497 {
a4845881
MS		 3498 if (job->status &&
3499 (job->state_value == IPP_JOB_ABORTED ||
3500 job->state_value == IPP_JOB_STOPPED))
178cb736
MS		 3501 dump_job_history(job);
3502 else
3503 free_job_history(job);
3504 }
3505
b9faaae1 3506 cupsArrayRemove(PrintingJobs, job);
3dfe78b3 3507
a29fd7dd
MS		 3508 /*
3509 * Apply any PPD updates...
3510 */
3511
3512 if (job->num_keywords)
3513 {
3514 if (cupsdUpdatePrinterPPD(job->printer, job->num_keywords, job->keywords))
3515 cupsdSetPrinterAttrs(job->printer);
3516
3517 cupsFreeOptions(job->num_keywords, job->keywords);
3518
3519 job->num_keywords = 0;
3520 job->keywords = NULL;
3521 }
3522
e1d6a774 3523 /*
b9faaae1 3524 * Clear the printer <-> job association...
e1d6a774 3525 */
ef416fc2 3526
b9faaae1
MS		 3527 job->printer->job = NULL;
3528 job->printer = NULL;
b9faaae1 3529}
ef416fc2 3530
ef416fc2 3531
b9faaae1
MS		 3532/*
3533 * 'get_options()' - Get a string containing the job options.
3534 */
3535
3536static char * /* O - Options string */
3537get_options(cupsd_job_t *job, /* I - Job */
3538 int banner_page, /* I - Printing a banner page? */
3539 char *copies, /* I - Copies buffer */
3540 size_t copies_size, /* I - Size of copies buffer */
3541 char *title, /* I - Title buffer */
3542 size_t title_size) /* I - Size of title buffer */
3543{
3544 int i; /* Looping var */
c7017ecc 3545 size_t newlength; /* New option buffer length */
b9faaae1
MS		 3546 char *optptr, /* Pointer to options */
3547 *valptr; /* Pointer in value string */
3548 ipp_attribute_t *attr; /* Current attribute */
f14324a7 3549 _ppd_cache_t *pc; /* PPD cache and mapping data */
c7017ecc
MS		 3550 int num_pwgppds; /* Number of PWG->PPD options */
3551 cups_option_t *pwgppds, /* PWG->PPD options */
3552 *pwgppd, /* Current PWG->PPD option */
3553 *preset; /* Current preset option */
f14324a7
MS		 3554 int print_color_mode,
3555 /* Output mode (if any) */
c7017ecc
MS		 3556 print_quality; /* Print quality (if any) */
3557 const char *ppd; /* PPD option choice */
3558 int exact; /* Did we get an exact match? */
b9faaae1 3559 static char *options = NULL;/* Full list of options */
c7017ecc 3560 static size_t optlength = 0; /* Length of option buffer */
b9faaae1 3561
ef416fc2 3562
e1d6a774 3563 /*
c7017ecc
MS		 3564 * Building the options string is harder than it needs to be, but for the
3565 * moment we need to pass strings for command-line args and not IPP attribute
3566 * pointers... :)
e1d6a774 3567 *
c7017ecc 3568 * First build an options array for any PWG->PPD mapped option/choice pairs.
e1d6a774 3569 */
ef416fc2 3570
f14324a7 3571 pc = job->printer->pc;
c7017ecc
MS		 3572 num_pwgppds = 0;
3573 pwgppds = NULL;
ef416fc2 3574
f14324a7 3575 if (pc &&
7cf5915e
MS		 3576 !ippFindAttribute(job->attrs,
3577 "com.apple.print.DocumentTicket.PMSpoolFormat",
3578 IPP_TAG_ZERO) &&
0268488e 3579 !ippFindAttribute(job->attrs, "APPrinterPreset", IPP_TAG_ZERO) &&
5a9febac 3580 (ippFindAttribute(job->attrs, "print-color-mode", IPP_TAG_ZERO) ||
7cf5915e 3581 ippFindAttribute(job->attrs, "print-quality", IPP_TAG_ZERO)))
c7017ecc 3582 {
7cf5915e 3583 /*
5a9febac 3584 * Map print-color-mode and print-quality to a preset...
7cf5915e
MS		 3585 */
3586
f14324a7 3587 if ((attr = ippFindAttribute(job->attrs, "print-color-mode",
5a9febac
MS		 3588 IPP_TAG_KEYWORD)) != NULL &&
3589 !strcmp(attr->values[0].string.text, "monochrome"))
f14324a7 3590 print_color_mode = _PWG_PRINT_COLOR_MODE_MONOCHROME;
c7017ecc 3591 else
f14324a7 3592 print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
c7017ecc
MS		 3593
3594 if ((attr = ippFindAttribute(job->attrs, "print-quality",
10d09e33 3595 IPP_TAG_ENUM)) != NULL &&
c7017ecc
MS		 3596 attr->values[0].integer >= IPP_QUALITY_DRAFT &&
3597 attr->values[0].integer <= IPP_QUALITY_HIGH)
3598 print_quality = attr->values[0].integer - IPP_QUALITY_DRAFT;
3599 else
030ae6a1 3600 print_quality = _PWG_PRINT_QUALITY_NORMAL;
c7017ecc 3601
f14324a7 3602 if (pc->num_presets[print_color_mode][print_quality] == 0)
c7017ecc
MS		 3603 {
3604 /*
3605 * Try to find a preset that works so that we maximize the chances of us
3606 * getting a good print using IPP attributes.
3607 */
3608
f14324a7 3609 if (pc->num_presets[print_color_mode][_PWG_PRINT_QUALITY_NORMAL] > 0)
c7017ecc 3610 print_quality = _PWG_PRINT_QUALITY_NORMAL;
f14324a7
MS		 3611 else if (pc->num_presets[_PWG_PRINT_COLOR_MODE_COLOR][print_quality] > 0)
3612 print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
c7017ecc
MS		 3613 else
3614 {
f14324a7
MS		 3615 print_quality = _PWG_PRINT_QUALITY_NORMAL;
3616 print_color_mode = _PWG_PRINT_COLOR_MODE_COLOR;
c7017ecc
MS		 3617 }
3618 }
3619
f14324a7 3620 if (pc->num_presets[print_color_mode][print_quality] > 0)
c7017ecc
MS		 3621 {
3622 /*
3623 * Copy the preset options as long as the corresponding names are not
3624 * already defined in the IPP request...
3625 */
3626
f14324a7
MS		 3627 for (i = pc->num_presets[print_color_mode][print_quality],
3628 preset = pc->presets[print_color_mode][print_quality];
c7017ecc
MS		 3629 i > 0;
3630 i --, preset ++)
3631 {
3632 if (!ippFindAttribute(job->attrs, preset->name, IPP_TAG_ZERO))
3633 num_pwgppds = cupsAddOption(preset->name, preset->value, num_pwgppds,
3634 &pwgppds);
3635 }
3636 }
7cf5915e 3637 }
c7017ecc 3638
f14324a7 3639 if (pc)
7cf5915e 3640 {
4220952d
MS		 3641 if (!ippFindAttribute(job->attrs, "InputSlot", IPP_TAG_ZERO) &&
3642 !ippFindAttribute(job->attrs, "HPPaperSource", IPP_TAG_ZERO))
3643 {
f14324a7
MS		 3644 if ((ppd = _ppdCacheGetInputSlot(pc, job->attrs, NULL)) != NULL)
3645 num_pwgppds = cupsAddOption(pc->source_option, ppd, num_pwgppds,
4220952d 3646 &pwgppds);
4220952d 3647 }
4220952d 3648 if (!ippFindAttribute(job->attrs, "MediaType", IPP_TAG_ZERO) &&
f14324a7 3649 (ppd = _ppdCacheGetMediaType(pc, job->attrs, NULL)) != NULL)
4220952d 3650 num_pwgppds = cupsAddOption("MediaType", ppd, num_pwgppds, &pwgppds);
c7017ecc 3651
4220952d
MS		 3652 if (!ippFindAttribute(job->attrs, "PageRegion", IPP_TAG_ZERO) &&
3653 !ippFindAttribute(job->attrs, "PageSize", IPP_TAG_ZERO) &&
f14324a7 3654 (ppd = _ppdCacheGetPageSize(pc, job->attrs, NULL, &exact)) != NULL)
030ae6a1 3655 {
4220952d 3656 num_pwgppds = cupsAddOption("PageSize", ppd, num_pwgppds, &pwgppds);
c7017ecc 3657
030ae6a1
MS		 3658 if (!ippFindAttribute(job->attrs, "media", IPP_TAG_ZERO))
3659 num_pwgppds = cupsAddOption("media", ppd, num_pwgppds, &pwgppds);
3660 }
3661
4220952d
MS		 3662 if (!ippFindAttribute(job->attrs, "OutputBin", IPP_TAG_ZERO) &&
3663 (attr = ippFindAttribute(job->attrs, "output-bin",
3664 IPP_TAG_ZERO)) != NULL &&
3665 (attr->value_tag == IPP_TAG_KEYWORD ||
3666 attr->value_tag == IPP_TAG_NAME) &&
f14324a7 3667 (ppd = _ppdCacheGetOutputBin(pc, attr->values[0].string.text)) != NULL)
0268488e
MS		 3668 {
3669 /*
3670 * Map output-bin to OutputBin option...
3671 */
3672
4220952d 3673 num_pwgppds = cupsAddOption("OutputBin", ppd, num_pwgppds, &pwgppds);
0268488e
MS		 3674 }
3675
f14324a7
MS		 3676 if (pc->sides_option &&
3677 !ippFindAttribute(job->attrs, pc->sides_option, IPP_TAG_ZERO) &&
0268488e
MS		 3678 (attr = ippFindAttribute(job->attrs, "sides", IPP_TAG_KEYWORD)) != NULL)
3679 {
3680 /*
3681 * Map sides to duplex option...
3682 */
3683
3684 if (!strcmp(attr->values[0].string.text, "one-sided"))
f14324a7 3685 num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_1sided,
0268488e
MS		 3686 num_pwgppds, &pwgppds);
3687 else if (!strcmp(attr->values[0].string.text, "two-sided-long-edge"))
f14324a7 3688 num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_2sided_long,
0268488e
MS		 3689 num_pwgppds, &pwgppds);
3690 else if (!strcmp(attr->values[0].string.text, "two-sided-short-edge"))
f14324a7 3691 num_pwgppds = cupsAddOption(pc->sides_option, pc->sides_2sided_short,
0268488e
MS		 3692 num_pwgppds, &pwgppds);
3693 }
dcb445bc
MS		 3694
3695 /*
3696 * Map finishings values...
3697 */
3698
3699 num_pwgppds = _ppdCacheGetFinishingOptions(pc, job->attrs,
3700 IPP_FINISHINGS_NONE, num_pwgppds,
3701 &pwgppds);
4220952d 3702 }
c7017ecc
MS		 3703
3704 /*
3705 * Figure out how much room we need...
3706 */
3707
3708 newlength = ipp_length(job->attrs);
3709
3710 for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
3711 newlength += 1 + strlen(pwgppd->name) + 1 + strlen(pwgppd->value);
3712
3713 /*
3714 * Then allocate/reallocate the option buffer as needed...
3715 */
3716
85dda01c
MS		 3717 if (newlength == 0) /* This can never happen, but Clang */
3718 newlength = 1; /* thinks it can... */
3719
c7017ecc 3720 if (newlength > optlength || !options)
e1d6a774 3721 {
b9faaae1 3722 if (!options)
c7017ecc 3723 optptr = malloc(newlength);
e1d6a774 3724 else
c7017ecc 3725 optptr = realloc(options, newlength);
ef416fc2 3726
b9faaae1 3727 if (!optptr)
e1d6a774 3728 {
75bd9771 3729 cupsdLogJob(job, CUPSD_LOG_CRIT,
12f89d24 3730 "Unable to allocate " CUPS_LLFMT " bytes for option buffer.",
c7017ecc 3731 CUPS_LLCAST newlength);
b9faaae1 3732 return (NULL);
e1d6a774 3733 }
ef416fc2 3734
e1d6a774 3735 options = optptr;
c7017ecc 3736 optlength = newlength;
e1d6a774 3737 }
ef416fc2 3738
e1d6a774 3739 /*
3740 * Now loop through the attributes and convert them to the textual
3741 * representation used by the filters...
3742 */
ef416fc2 3743
e1d6a774 3744 optptr = options;
3745 *optptr = '\0';
bd7854cb 3746
1340db2d
MS		 3747 snprintf(title, title_size, "%s-%d", job->printer->name, job->id);
3748 strlcpy(copies, "1", copies_size);
bd7854cb 3749
e1d6a774 3750 for (attr = job->attrs->attrs; attr != NULL; attr = attr->next)
bd7854cb 3751 {
e1d6a774 3752 if (!strcmp(attr->name, "copies") &&
3753 attr->value_tag == IPP_TAG_INTEGER)
3754 {
3755 /*
3756 * Don't use the # copies attribute if we are printing the job sheets...
3757 */
bd7854cb 3758
e1d6a774 3759 if (!banner_page)
1340db2d 3760 snprintf(copies, copies_size, "%d", attr->values[0].integer);
e1d6a774 3761 }
3762 else if (!strcmp(attr->name, "job-name") &&
3763 (attr->value_tag == IPP_TAG_NAME ||
3764 attr->value_tag == IPP_TAG_NAMELANG))
1340db2d 3765 strlcpy(title, attr->values[0].string.text, title_size);
e1d6a774 3766 else if (attr->group_tag == IPP_TAG_JOB)
3767 {
3768 /*
3769 * Filter out other unwanted attributes...
3770 */
bd7854cb 3771
c7017ecc
MS		 3772 if (attr->value_tag == IPP_TAG_NOVALUE ||
3773 attr->value_tag == IPP_TAG_MIMETYPE ||
e1d6a774 3774 attr->value_tag == IPP_TAG_NAMELANG ||
3775 attr->value_tag == IPP_TAG_TEXTLANG ||
db8b865d
MS		 3776 (attr->value_tag == IPP_TAG_URI && strcmp(attr->name, "job-uuid") &&
3777 strcmp(attr->name, "job-authorization-uri")) ||
e1d6a774 3778 attr->value_tag == IPP_TAG_URISCHEME ||
3779 attr->value_tag == IPP_TAG_BEGIN_COLLECTION) /* Not yet supported */
3780 continue;
bd7854cb 3781
5a9febac
MS		 3782 if (!strcmp(attr->name, "job-hold-until") ||
3783 !strcmp(attr->name, "job-id") ||
3784 !strcmp(attr->name, "job-k-octets") ||
3785 !strcmp(attr->name, "job-media-sheets") ||
3786 !strcmp(attr->name, "job-media-sheets-completed") ||
3787 !strcmp(attr->name, "job-state") ||
3788 !strcmp(attr->name, "job-state-reasons"))
e1d6a774 3789 continue;
bd7854cb 3790
e1d6a774 3791 if (!strncmp(attr->name, "job-", 4) &&
5a9febac
MS		 3792 strcmp(attr->name, "job-account-id") &&
3793 strcmp(attr->name, "job-accounting-user-id") &&
a469f8a5 3794 strcmp(attr->name, "job-authorization-uri") &&
e4572d57 3795 strcmp(attr->name, "job-billing") &&
5d6412a9 3796 strcmp(attr->name, "job-impressions") &&
c5571a1d 3797 strcmp(attr->name, "job-originating-host-name") &&
5a9febac 3798 strcmp(attr->name, "job-password") &&
a469f8a5 3799 strcmp(attr->name, "job-password-encryption") &&
e4572d57 3800 strcmp(attr->name, "job-uuid") &&
b9faaae1 3801 !(job->printer->type & CUPS_PRINTER_REMOTE))
e1d6a774 3802 continue;
ef416fc2 3803
5d6412a9
MS		 3804 if ((!strcmp(attr->name, "job-impressions") ||
3805 !strcmp(attr->name, "page-label") ||
e1d6a774 3806 !strcmp(attr->name, "page-border") ||
3807 !strncmp(attr->name, "number-up", 9) ||
b94498cf 3808 !strcmp(attr->name, "page-ranges") ||
e1d6a774 3809 !strcmp(attr->name, "page-set") ||
88f9aafc
MS		 3810 !_cups_strcasecmp(attr->name, "AP_FIRSTPAGE_InputSlot") ||
3811 !_cups_strcasecmp(attr->name, "AP_FIRSTPAGE_ManualFeed") ||
3812 !_cups_strcasecmp(attr->name, "com.apple.print.PrintSettings."
db1f069b 3813 "PMTotalSidesImaged..n.") ||
88f9aafc 3814 !_cups_strcasecmp(attr->name, "com.apple.print.PrintSettings."
db1f069b 3815 "PMTotalBeginPages..n.")) &&
e1d6a774 3816 banner_page)
3817 continue;
ef416fc2 3818
e1d6a774 3819 /*
3820 * Otherwise add them to the list...
3821 */
ef416fc2 3822
e1d6a774 3823 if (optptr > options)
7e86f2f6 3824 strlcat(optptr, " ", optlength - (size_t)(optptr - options));
ef416fc2 3825
e1d6a774 3826 if (attr->value_tag != IPP_TAG_BOOLEAN)
3827 {
7e86f2f6
MS		 3828 strlcat(optptr, attr->name, optlength - (size_t)(optptr - options));
3829 strlcat(optptr, "=", optlength - (size_t)(optptr - options));
e1d6a774 3830 }
ef416fc2 3831
e1d6a774 3832 for (i = 0; i < attr->num_values; i ++)
3833 {
3834 if (i)
7e86f2f6 3835 strlcat(optptr, ",", optlength - (size_t)(optptr - options));
ef416fc2 3836
e1d6a774 3837 optptr += strlen(optptr);
ef416fc2 3838
e1d6a774 3839 switch (attr->value_tag)
3840 {
3841 case IPP_TAG_INTEGER :
3842 case IPP_TAG_ENUM :
7e86f2f6 3843 snprintf(optptr, optlength - (size_t)(optptr - options),
e1d6a774 3844 "%d", attr->values[i].integer);
3845 break;
ef416fc2 3846
e1d6a774 3847 case IPP_TAG_BOOLEAN :
3848 if (!attr->values[i].boolean)
7e86f2f6 3849 strlcat(optptr, "no", optlength - (size_t)(optptr - options));
ef416fc2 3850
7e86f2f6 3851 strlcat(optptr, attr->name, optlength - (size_t)(optptr - options));
4220952d
MS		 3852 break;
3853
e1d6a774 3854 case IPP_TAG_RANGE :
3855 if (attr->values[i].range.lower == attr->values[i].range.upper)
7e86f2f6 3856 snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
e1d6a774 3857 "%d", attr->values[i].range.lower);
3858 else
7e86f2f6 3859 snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
e1d6a774 3860 "%d-%d", attr->values[i].range.lower,
3861 attr->values[i].range.upper);
3862 break;
ef416fc2 3863
e1d6a774 3864 case IPP_TAG_RESOLUTION :
7e86f2f6 3865 snprintf(optptr, optlength - (size_t)(optptr - options) - 1,
e1d6a774 3866 "%dx%d%s", attr->values[i].resolution.xres,
3867 attr->values[i].resolution.yres,
3868 attr->values[i].resolution.units == IPP_RES_PER_INCH ?
3e7fe0ca 3869 "dpi" : "dpcm");
e1d6a774 3870 break;
ef416fc2 3871
e1d6a774 3872 case IPP_TAG_STRING :
3873 case IPP_TAG_TEXT :
3874 case IPP_TAG_NAME :
3875 case IPP_TAG_KEYWORD :
3876 case IPP_TAG_CHARSET :
3877 case IPP_TAG_LANGUAGE :
3878 case IPP_TAG_URI :
3879 for (valptr = attr->values[i].string.text; *valptr;)
3880 {
3881 if (strchr(" \t\n\\\'\"", *valptr))
3882 *optptr++ = '\\';
3883 *optptr++ = *valptr++;
3884 }
3885
3886 *optptr = '\0';
3887 break;
3888
3889 default :
3890 break; /* anti-compiler-warning-code */
3891 }
3892 }
3893
3894 optptr += strlen(optptr);
3895 }
3896 }
3897
c7017ecc
MS		 3898 /*
3899 * Finally loop through the PWG->PPD mapped options and add them...
3900 */
3901
3902 for (i = num_pwgppds, pwgppd = pwgppds; i > 0; i --, pwgppd ++)
3903 {
3904 *optptr++ = ' ';
7e86f2f6 3905 strlcpy(optptr, pwgppd->name, optlength - (size_t)(optptr - options));
c7017ecc
MS		 3906 optptr += strlen(optptr);
3907 *optptr++ = '=';
7e86f2f6 3908 strlcpy(optptr, pwgppd->value, optlength - (size_t)(optptr - options));
c7017ecc
MS		 3909 optptr += strlen(optptr);
3910 }
3911
3912 cupsFreeOptions(num_pwgppds, pwgppds);
3913
3914 /*
3915 * Return the options string...
3916 */
b9faaae1
MS		 3917
3918 return (options);
3919}
3920
3921
3922/*
3923 * 'ipp_length()' - Compute the size of the buffer needed to hold
3924 * the textual IPP attributes.
3925 */
3926
c7017ecc 3927static size_t /* O - Size of attribute buffer */
b9faaae1
MS		 3928ipp_length(ipp_t *ipp) /* I - IPP request */
3929{
c7017ecc 3930 size_t bytes; /* Number of bytes */
b9faaae1
MS		 3931 int i; /* Looping var */
3932 ipp_attribute_t *attr; /* Current attribute */
3933
3934
3935 /*
3936 * Loop through all attributes...
e1d6a774 3937 */
3938
b9faaae1 3939 bytes = 0;
e1d6a774 3940
b9faaae1 3941 for (attr = ipp->attrs; attr != NULL; attr = attr->next)
91c84a35 3942 {
b9faaae1
MS		 3943 /*
3944 * Skip attributes that won't be sent to filters...
3945 */
91c84a35 3946
c7017ecc
MS		 3947 if (attr->value_tag == IPP_TAG_NOVALUE ||
3948 attr->value_tag == IPP_TAG_MIMETYPE ||
b9faaae1
MS		 3949 attr->value_tag == IPP_TAG_NAMELANG ||
3950 attr->value_tag == IPP_TAG_TEXTLANG ||
3951 attr->value_tag == IPP_TAG_URI ||
3952 attr->value_tag == IPP_TAG_URISCHEME)
3953 continue;
91c84a35 3954
b9faaae1
MS		 3955 /*
3956 * Add space for a leading space and commas between each value.
3957 * For the first attribute, the leading space isn't used, so the
3958 * extra byte can be used as the nul terminator...
3959 */
e1d6a774 3960
b9faaae1 3961 bytes ++; /* " " separator */
7e86f2f6 3962 bytes += (size_t)attr->num_values; /* "," separators */
e1d6a774 3963
b9faaae1
MS		 3964 /*
3965 * Boolean attributes appear as "foo,nofoo,foo,nofoo", while
3966 * other attributes appear as "foo=value1,value2,...,valueN".
3967 */
3968
3969 if (attr->value_tag != IPP_TAG_BOOLEAN)
3970 bytes += strlen(attr->name);
3971 else
7e86f2f6 3972 bytes += (size_t)attr->num_values * strlen(attr->name);
b9faaae1
MS		 3973
3974 /*
3975 * Now add the size required for each value in the attribute...
3976 */
3977
3978 switch (attr->value_tag)
ef416fc2 3979 {
b9faaae1
MS		 3980 case IPP_TAG_INTEGER :
3981 case IPP_TAG_ENUM :
3982 /*
3983 * Minimum value of a signed integer is -2147483647, or 11 digits.
3984 */
3985
7e86f2f6 3986 bytes += (size_t)attr->num_values * 11;
b9faaae1
MS		 3987 break;
3988
3989 case IPP_TAG_BOOLEAN :
3990 /*
3991 * Add two bytes for each false ("no") value...
3992 */
3993
3994 for (i = 0; i < attr->num_values; i ++)
3995 if (!attr->values[i].boolean)
3996 bytes += 2;
3997 break;
3998
3999 case IPP_TAG_RANGE :
4000 /*
4001 * A range is two signed integers separated by a hyphen, or
4002 * 23 characters max.
4003 */
4004
7e86f2f6 4005 bytes += (size_t)attr->num_values * 23;
b9faaae1
MS		 4006 break;
4007
4008 case IPP_TAG_RESOLUTION :
4009 /*
4010 * A resolution is two signed integers separated by an "x" and
4011 * suffixed by the units, or 26 characters max.
4012 */
4013
7e86f2f6 4014 bytes += (size_t)attr->num_values * 26;
b9faaae1
MS		 4015 break;
4016
4017 case IPP_TAG_STRING :
4018 case IPP_TAG_TEXT :
4019 case IPP_TAG_NAME :
4020 case IPP_TAG_KEYWORD :
4021 case IPP_TAG_CHARSET :
4022 case IPP_TAG_LANGUAGE :
4023 case IPP_TAG_URI :
4024 /*
4025 * Strings can contain characters that need quoting. We need
4026 * at least 2 * len + 2 characters to cover the quotes and
4027 * any backslashes in the string.
4028 */
4029
4030 for (i = 0; i < attr->num_values; i ++)
4031 bytes += 2 * strlen(attr->values[i].string.text) + 2;
4032 break;
4033
4034 default :
4035 break; /* anti-compiler-warning-code */
e1d6a774 4036 }
4037 }
b9faaae1
MS		 4038
4039 return (bytes);
4040}
4041
4042
4043/*
4044 * 'load_job_cache()' - Load jobs from the job.cache file.
4045 */
4046
4047static void
4048load_job_cache(const char *filename) /* I - job.cache filename */
4049{
4050 cups_file_t *fp; /* job.cache file */
4051 char line[1024], /* Line buffer */
4052 *value; /* Value on line */
4053 int linenum; /* Line number in file */
4054 cupsd_job_t *job; /* Current job */
4055 int jobid; /* Job ID */
4056 char jobfile[1024]; /* Job filename */
4057
4058
4059 /*
4060 * Open the job.cache file...
4061 */
4062
321d8d57 4063 if ((fp = cupsdOpenConfFile(filename)) == NULL)
e1d6a774 4064 {
b9faaae1 4065 load_request_root();
b9faaae1
MS		 4066 return;
4067 }
ef416fc2 4068
e1d6a774 4069 /*
b9faaae1 4070 * Read entries from the job cache file and create jobs as needed.
e1d6a774 4071 */
ef416fc2 4072
b9faaae1
MS		 4073 cupsdLogMessage(CUPSD_LOG_INFO, "Loading job cache file \"%s\"...",
4074 filename);
ef416fc2 4075
b9faaae1
MS		 4076 linenum = 0;
4077 job = NULL;
4078
4079 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
4080 {
88f9aafc 4081 if (!_cups_strcasecmp(line, "NextJobId"))
b9faaae1
MS		 4082 {
4083 if (value)
4084 NextJobId = atoi(value);
4085 }
88f9aafc 4086 else if (!_cups_strcasecmp(line, "<Job"))
b9faaae1
MS		 4087 {
4088 if (job)
4089 {
c07e5e20 4090 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing </Job> directive on line %d of %s.", linenum, filename);
b9faaae1
MS		 4091 continue;
4092 }
4093
4094 if (!value)
4095 {
c07e5e20 4096 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing job ID on line %d of %s.", linenum, filename);
b9faaae1
MS		 4097 continue;
4098 }
4099
4100 jobid = atoi(value);
4101
4102 if (jobid < 1)
4103 {
c07e5e20 4104 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad job ID %d on line %d of %s.", jobid, linenum, filename);
b9faaae1
MS		 4105 continue;
4106 }
4107
4108 snprintf(jobfile, sizeof(jobfile), "%s/c%05d", RequestRoot, jobid);
4109 if (access(jobfile, 0))
4110 {
321d8d57
MS		 4111 snprintf(jobfile, sizeof(jobfile), "%s/c%05d.N", RequestRoot, jobid);
4112 if (access(jobfile, 0))
4113 {
12f89d24 4114 cupsdLogMessage(CUPSD_LOG_ERROR, "[Job %d] Files have gone away.",
321d8d57
MS		 4115 jobid);
4116 continue;
4117 }
b9faaae1
MS		 4118 }
4119
4120 job = calloc(1, sizeof(cupsd_job_t));
4121 if (!job)
4122 {
4123 cupsdLogMessage(CUPSD_LOG_EMERG,
12f89d24 4124 "[Job %d] Unable to allocate memory for job.", jobid);
b9faaae1
MS		 4125 break;
4126 }
4127
4128 job->id = jobid;
4129 job->back_pipes[0] = -1;
4130 job->back_pipes[1] = -1;
4131 job->print_pipes[0] = -1;
4132 job->print_pipes[1] = -1;
4133 job->side_pipes[0] = -1;
4134 job->side_pipes[1] = -1;
4135 job->status_pipes[0] = -1;
4136 job->status_pipes[1] = -1;
4137
72f50170 4138 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Loading from cache...");
b9faaae1
MS		 4139 }
4140 else if (!job)
4141 {
4142 cupsdLogMessage(CUPSD_LOG_ERROR,
c07e5e20 4143 "Missing <Job #> directive on line %d of %s.", linenum, filename);
b9faaae1
MS		 4144 continue;
4145 }
88f9aafc 4146 else if (!_cups_strcasecmp(line, "</Job>"))
b9faaae1
MS		 4147 {
4148 cupsArrayAdd(Jobs, job);
4149
f701418f
MS		 4150 if (job->state_value <= IPP_JOB_STOPPED && cupsdLoadJob(job))
4151 cupsArrayAdd(ActiveJobs, job);
eec1fbc3
MS		 4152 else if (job->state_value > IPP_JOB_STOPPED)
4153 {
f16ea703 4154 if (!job->completed_time || !job->creation_time || !job->name || !job->koctets)
eec1fbc3
MS		 4155 {
4156 cupsdLoadJob(job);
4157 unload_job(job);
4158 }
4159 }
b9faaae1
MS		 4160
4161 job = NULL;
4162 }
4163 else if (!value)
4164 {
c07e5e20 4165 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing value on line %d of %s.", linenum, filename);
b9faaae1
MS		 4166 continue;
4167 }
88f9aafc 4168 else if (!_cups_strcasecmp(line, "State"))
b9faaae1
MS		 4169 {
4170 job->state_value = (ipp_jstate_t)atoi(value);
4171
4172 if (job->state_value < IPP_JOB_PENDING)
4173 job->state_value = IPP_JOB_PENDING;
4174 else if (job->state_value > IPP_JOB_COMPLETED)
4175 job->state_value = IPP_JOB_COMPLETED;
4176 }
f16ea703
MS		 4177 else if (!_cups_strcasecmp(line, "Name"))
4178 {
4179 cupsdSetString(&(job->name), value);
4180 }
4181 else if (!_cups_strcasecmp(line, "Created"))
4182 {
4183 job->creation_time = strtol(value, NULL, 10);
4184 }
eec1fbc3
MS		 4185 else if (!_cups_strcasecmp(line, "Completed"))
4186 {
4187 job->completed_time = strtol(value, NULL, 10);
4188 }
88f9aafc 4189 else if (!_cups_strcasecmp(line, "HoldUntil"))
8b116e60 4190 {
eec1fbc3 4191 job->hold_until = strtol(value, NULL, 10);
8b116e60 4192 }
88f9aafc 4193 else if (!_cups_strcasecmp(line, "Priority"))
b9faaae1
MS		 4194 {
4195 job->priority = atoi(value);
4196 }
88f9aafc 4197 else if (!_cups_strcasecmp(line, "Username"))
b9faaae1
MS		 4198 {
4199 cupsdSetString(&job->username, value);
4200 }
88f9aafc 4201 else if (!_cups_strcasecmp(line, "Destination"))
b9faaae1
MS		 4202 {
4203 cupsdSetString(&job->dest, value);
4204 }
88f9aafc 4205 else if (!_cups_strcasecmp(line, "DestType"))
b9faaae1
MS		 4206 {
4207 job->dtype = (cups_ptype_t)atoi(value);
4208 }
f16ea703
MS		 4209 else if (!_cups_strcasecmp(line, "KOctets"))
4210 {
4211 job->koctets = atoi(value);
4212 }
88f9aafc 4213 else if (!_cups_strcasecmp(line, "NumFiles"))
b9faaae1
MS		 4214 {
4215 job->num_files = atoi(value);
4216
4217 if (job->num_files < 0)
4218 {
c07e5e20 4219 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad NumFiles value %d on line %d of %s.", job->num_files, linenum, filename);
b9faaae1
MS		 4220 job->num_files = 0;
4221 continue;
4222 }
4223
4224 if (job->num_files > 0)
4225 {
4226 snprintf(jobfile, sizeof(jobfile), "%s/d%05d-001", RequestRoot,
4227 job->id);
4228 if (access(jobfile, 0))
4229 {
72f50170 4230 cupsdLogJob(job, CUPSD_LOG_INFO, "Data files have gone away.");
b9faaae1
MS		 4231 job->num_files = 0;
4232 continue;
4233 }
4234
7e86f2f6
MS		 4235 job->filetypes = calloc((size_t)job->num_files, sizeof(mime_type_t *));
4236 job->compressions = calloc((size_t)job->num_files, sizeof(int));
b9faaae1
MS		 4237
4238 if (!job->filetypes || !job->compressions)
4239 {
72f50170
MS		 4240 cupsdLogJob(job, CUPSD_LOG_EMERG,
4241 "Unable to allocate memory for %d files.",
4242 job->num_files);
b9faaae1
MS		 4243 break;
4244 }
4245 }
4246 }
88f9aafc 4247 else if (!_cups_strcasecmp(line, "File"))
b9faaae1
MS		 4248 {
4249 int number, /* File number */
4250 compression; /* Compression value */
4251 char super[MIME_MAX_SUPER], /* MIME super type */
4252 type[MIME_MAX_TYPE]; /* MIME type */
4253
4254
4255 if (sscanf(value, "%d%*[ \t]%15[^/]/%255s%d", &number, super, type,
4256 &compression) != 4)
4257 {
c07e5e20 4258 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File on line %d of %s.", linenum, filename);
b9faaae1
MS		 4259 continue;
4260 }
4261
4262 if (number < 1 || number > job->num_files)
4263 {
c07e5e20 4264 cupsdLogMessage(CUPSD_LOG_ERROR, "Bad File number %d on line %d of %s.", number, linenum, filename);
b9faaae1
MS		 4265 continue;
4266 }
0a682745 4267
b9faaae1 4268 number --;
ef416fc2 4269
b9faaae1
MS		 4270 job->compressions[number] = compression;
4271 job->filetypes[number] = mimeType(MimeDatabase, super, type);
ef416fc2 4272
b9faaae1
MS		 4273 if (!job->filetypes[number])
4274 {
e1d6a774 4275 /*
b9faaae1 4276 * If the original MIME type is unknown, auto-type it!
e1d6a774 4277 */
ef416fc2 4278
72f50170
MS		 4279 cupsdLogJob(job, CUPSD_LOG_ERROR,
4280 "Unknown MIME type %s/%s for file %d.",
4281 super, type, number + 1);
b9faaae1
MS		 4282
4283 snprintf(jobfile, sizeof(jobfile), "%s/d%05d-%03d", RequestRoot,
4284 job->id, number + 1);
4285 job->filetypes[number] = mimeFileType(MimeDatabase, jobfile, NULL,
4286 job->compressions + number);
ef416fc2 4287
e1d6a774 4288 /*
b9faaae1 4289 * If that didn't work, assume it is raw...
e1d6a774 4290 */
ef416fc2 4291
b9faaae1
MS		 4292 if (!job->filetypes[number])
4293 job->filetypes[number] = mimeType(MimeDatabase, "application",
4294 "vnd.cups-raw");
4295 }
4296 }
4297 else
c07e5e20 4298 cupsdLogMessage(CUPSD_LOG_ERROR, "Unknown %s directive on line %d of %s.", line, linenum, filename);
ef416fc2 4299 }
4300
cb7f98ee
MS		 4301 if (job)
4302 {
4303 cupsdLogMessage(CUPSD_LOG_ERROR,
c07e5e20 4304 "Missing </Job> directive on line %d of %s.", linenum, filename);
cb7f98ee
MS		 4305 cupsdDeleteJob(job, CUPSD_JOB_PURGE);
4306 }
4307
b9faaae1
MS		 4308 cupsFileClose(fp);
4309}
ef416fc2 4310
4311
b9faaae1
MS		 4312/*
4313 * 'load_next_job_id()' - Load the NextJobId value from the job.cache file.
4314 */
bd7854cb 4315
b9faaae1
MS		 4316static void
4317load_next_job_id(const char *filename) /* I - job.cache filename */
4318{
4319 cups_file_t *fp; /* job.cache file */
4320 char line[1024], /* Line buffer */
4321 *value; /* Value on line */
4322 int linenum; /* Line number in file */
4323 int next_job_id; /* NextJobId value from line */
db0bd74a 4324
db0bd74a 4325
b9faaae1
MS		 4326 /*
4327 * Read the NextJobId directive from the job.cache file and use
4328 * the value (if any).
4329 */
bd7854cb 4330
b9faaae1 4331 if ((fp = cupsFileOpen(filename, "r")) == NULL)
e1d6a774 4332 {
b9faaae1
MS		 4333 if (errno != ENOENT)
4334 cupsdLogMessage(CUPSD_LOG_ERROR,
4335 "Unable to open job cache file \"%s\": %s",
4336 filename, strerror(errno));
bd7854cb 4337
b9faaae1 4338 return;
e1d6a774 4339 }
bd7854cb 4340
b9faaae1
MS		 4341 cupsdLogMessage(CUPSD_LOG_INFO,
4342 "Loading NextJobId from job cache file \"%s\"...", filename);
4343
4344 linenum = 0;
4345
4346 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
bd7854cb 4347 {
88f9aafc 4348 if (!_cups_strcasecmp(line, "NextJobId"))
b9faaae1
MS		 4349 {
4350 if (value)
4351 {
4352 next_job_id = atoi(value);
4353
4354 if (next_job_id > NextJobId)
4355 NextJobId = next_job_id;
4356 }
4357 break;
4358 }
e1d6a774 4359 }
bd7854cb 4360
b9faaae1
MS		 4361 cupsFileClose(fp);
4362}
09a101d6 4363
f7deaa1a 4364
b9faaae1
MS		 4365/*
4366 * 'load_request_root()' - Load jobs from the RequestRoot directory.
4367 */
bd7854cb 4368
b9faaae1
MS		 4369static void
4370load_request_root(void)
4371{
4372 cups_dir_t *dir; /* Directory */
4373 cups_dentry_t *dent; /* Directory entry */
4374 cupsd_job_t *job; /* New job */
e1d6a774 4375
bd7854cb 4376
4377 /*
b9faaae1 4378 * Open the requests directory...
bd7854cb 4379 */
4380
b9faaae1 4381 cupsdLogMessage(CUPSD_LOG_DEBUG, "Scanning %s for jobs...", RequestRoot);
bd7854cb 4382
b9faaae1 4383 if ((dir = cupsDirOpen(RequestRoot)) == NULL)
bd7854cb 4384 {
b9faaae1
MS		 4385 cupsdLogMessage(CUPSD_LOG_ERROR,
4386 "Unable to open spool directory \"%s\": %s",
4387 RequestRoot, strerror(errno));
4388 return;
e1d6a774 4389 }
bd7854cb 4390
b9faaae1
MS		 4391 /*
4392 * Read all the c##### files...
4393 */
bd7854cb 4394
b9faaae1
MS		 4395 while ((dent = cupsDirRead(dir)) != NULL)
4396 if (strlen(dent->filename) >= 6 && dent->filename[0] == 'c')
bd7854cb 4397 {
b9faaae1
MS		 4398 /*
4399 * Allocate memory for the job...
4400 */
bd7854cb 4401
b9faaae1 4402 if ((job = calloc(sizeof(cupsd_job_t), 1)) == NULL)
bd7854cb 4403 {
12f89d24 4404 cupsdLogMessage(CUPSD_LOG_ERROR, "Ran out of memory for jobs.");
b9faaae1
MS		 4405 cupsDirClose(dir);
4406 return;
4407 }
bd7854cb 4408
b9faaae1
MS		 4409 /*
4410 * Assign the job ID...
4411 */
bd7854cb 4412
b9faaae1
MS		 4413 job->id = atoi(dent->filename + 1);
4414 job->back_pipes[0] = -1;
4415 job->back_pipes[1] = -1;
4416 job->print_pipes[0] = -1;
4417 job->print_pipes[1] = -1;
4418 job->side_pipes[0] = -1;
4419 job->side_pipes[1] = -1;
4420 job->status_pipes[0] = -1;
4421 job->status_pipes[1] = -1;
bd7854cb 4422
b9faaae1
MS		 4423 if (job->id >= NextJobId)
4424 NextJobId = job->id + 1;
ed486911 4425
b9faaae1
MS		 4426 /*
4427 * Load the job...
4428 */
ed486911 4429
f701418f
MS		 4430 if (cupsdLoadJob(job))
4431 {
4432 /*
4433 * Insert the job into the array, sorting by job priority and ID...
4434 */
bd7854cb 4435
f701418f 4436 cupsArrayAdd(Jobs, job);
e1d6a774 4437
f701418f
MS		 4438 if (job->state_value <= IPP_JOB_STOPPED)
4439 cupsArrayAdd(ActiveJobs, job);
4440 else
4441 unload_job(job);
4442 }
0fa6c7fa
MS		 4443 else
4444 free(job);
bd7854cb 4445 }
bd7854cb 4446
b9faaae1
MS		 4447 cupsDirClose(dir);
4448}
bd7854cb 4449
4450
82cc1f9a
MS		 4451/*
4452 * 'remove_job_files()' - Remove the document files for a job.
4453 */
4454
4455static void
4456remove_job_files(cupsd_job_t *job) /* I - Job */
4457{
4458 int i; /* Looping var */
4459 char filename[1024]; /* Document filename */
4460
4461
4462 if (job->num_files <= 0)
4463 return;
4464
4465 for (i = 1; i <= job->num_files; i ++)
4466 {
4467 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot,
4468 job->id, i);
cb7f98ee 4469 cupsdUnlinkOrRemoveFile(filename);
82cc1f9a
MS		 4470 }
4471
4472 free(job->filetypes);
4473 free(job->compressions);
4474
4475 job->file_time = 0;
4476 job->num_files = 0;
4477 job->filetypes = NULL;
4478 job->compressions = NULL;
4479
4480 LastEvent |= CUPSD_EVENT_PRINTER_STATE_CHANGED;
4481}
4482
4483
4484/*
4485 * 'remove_job_history()' - Remove the control file for a job.
4486 */
4487
4488static void
4489remove_job_history(cupsd_job_t *job) /* I - Job */
4490{
4491 char filename[1024]; /* Control filename */
4492
4493
4494 /*
4495 * Remove the job info file...
4496 */
4497
4498 snprintf(filename, sizeof(filename), "%s/c%05d", RequestRoot,
4499 job->id);
cb7f98ee 4500 cupsdUnlinkOrRemoveFile(filename);
82cc1f9a
MS		 4501
4502 LastEvent |= CUPSD_EVENT_PRINTER_STATE_CHANGED;
4503}
4504
4505
b9faaae1
MS		 4506/*
4507 * 'set_time()' - Set one of the "time-at-xyz" attributes.
4508 */
bd7854cb 4509
b9faaae1
MS		 4510static void
4511set_time(cupsd_job_t *job, /* I - Job to update */
4512 const char *name) /* I - Name of attribute */
4513{
9b4bd602 4514 char date_name[128]; /* date-time-at-xxx */
b9faaae1 4515 ipp_attribute_t *attr; /* Time attribute */
82cc1f9a
MS		 4516 time_t curtime; /* Current time */
4517
bd7854cb 4518
82cc1f9a
MS		 4519 curtime = time(NULL);
4520
4521 cupsdLogJob(job, CUPSD_LOG_DEBUG, "%s=%ld", name, (long)curtime);
bd7854cb 4522
b9faaae1
MS		 4523 if ((attr = ippFindAttribute(job->attrs, name, IPP_TAG_ZERO)) != NULL)
4524 {
4525 attr->value_tag = IPP_TAG_INTEGER;
82cc1f9a
MS		 4526 attr->values[0].integer = curtime;
4527 }
4528
9b4bd602
MS		 4529 snprintf(date_name, sizeof(date_name), "date-%s", name);
4530
4531 if ((attr = ippFindAttribute(job->attrs, date_name, IPP_TAG_ZERO)) != NULL)
4532 {
4533 attr->value_tag = IPP_TAG_DATE;
4534 ippSetDate(job->attrs, &attr, 0, ippTimeToDate(curtime));
4535 }
4536
82cc1f9a
MS		 4537 if (!strcmp(name, "time-at-completed"))
4538 {
eec1fbc3
MS		 4539 job->completed_time = curtime;
4540
0fa6c7fa 4541 if (JobHistory < INT_MAX && attr)
82cc1f9a
MS		 4542 job->history_time = attr->values[0].integer + JobHistory;
4543 else
4544 job->history_time = INT_MAX;
4545
4546 if (job->history_time < JobHistoryUpdate || !JobHistoryUpdate)
4547 JobHistoryUpdate = job->history_time;
4548
0fa6c7fa 4549 if (JobFiles < INT_MAX && attr)
82cc1f9a
MS		 4550 job->file_time = attr->values[0].integer + JobFiles;
4551 else
4552 job->file_time = INT_MAX;
4553
4554 if (job->file_time < JobHistoryUpdate || !JobHistoryUpdate)
4555 JobHistoryUpdate = job->file_time;
4556
4557 cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_time: JobHistoryUpdate=%ld",
4558 (long)JobHistoryUpdate);
b9faaae1
MS		 4559 }
4560}
bd7854cb 4561
e1d6a774 4562
b9faaae1
MS		 4563/*
4564 * 'start_job()' - Start a print job.
4565 */
e1d6a774 4566
b9faaae1
MS		 4567static void
4568start_job(cupsd_job_t *job, /* I - Job ID */
4569 cupsd_printer_t *printer) /* I - Printer to print job */
4570{
cb7f98ee 4571 const char *filename; /* Support filename */
982069db
MS		 4572 ipp_attribute_t *cancel_after = ippFindAttribute(job->attrs,
4573 "job-cancel-after",
4574 IPP_TAG_INTEGER);
4575 /* job-cancel-after attribute */
cb7f98ee
MS		 4576
4577
b9faaae1
MS		 4578 cupsdLogMessage(CUPSD_LOG_DEBUG2, "start_job(job=%p(%d), printer=%p(%s))",
4579 job, job->id, printer, printer->name);
bd7854cb 4580
b9faaae1
MS		 4581 /*
4582 * Make sure we have some files around before we try to print...
4583 */
bd7854cb 4584
b9faaae1
MS		 4585 if (job->num_files == 0)
4586 {
12f89d24 4587 ippSetString(job->attrs, &job->reasons, 0, "aborted-by-system");
b9faaae1
MS		 4588 cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_DEFAULT,
4589 "Aborting job because it has no files.");
4590 return;
4591 }
bd7854cb 4592
b9faaae1
MS		 4593 /*
4594 * Update the printer and job state to "processing"...
4595 */
bd7854cb 4596
b9faaae1
MS		 4597 if (!cupsdLoadJob(job))
4598 return;
89d46774 4599
3e7fe0ca
MS		 4600 if (!job->printer_message)
4601 job->printer_message = ippFindAttribute(job->attrs,
4602 "job-printer-state-message",
4603 IPP_TAG_TEXT);
88f9aafc 4604 if (job->printer_message)
5e6c3df7 4605 ippSetString(job->attrs, &job->printer_message, 0, "");
88f9aafc 4606
12f89d24 4607 ippSetString(job->attrs, &job->reasons, 0, "job-printing");
b9faaae1
MS		 4608 cupsdSetJobState(job, IPP_JOB_PROCESSING, CUPSD_JOB_DEFAULT, NULL);
4609 cupsdSetPrinterState(printer, IPP_PRINTER_PROCESSING, 0);
07ed0e9a
MS		 4610 cupsdSetPrinterReasons(printer, "-cups-remote-pending,"
4611 "cups-remote-pending-held,"
4612 "cups-remote-processing,"
4613 "cups-remote-stopped,"
4614 "cups-remote-canceled,"
4615 "cups-remote-aborted,"
4616 "cups-remote-completed");
f7deaa1a 4617
1340db2d
MS		 4618 job->cost = 0;
4619 job->current_file = 0;
82cc1f9a
MS		 4620 job->file_time = 0;
4621 job->history_time = 0;
1340db2d
MS		 4622 job->progress = 0;
4623 job->printer = printer;
4624 printer->job = job;
f7deaa1a 4625
982069db
MS		 4626 if (cancel_after)
4627 job->cancel_time = time(NULL) + ippGetInteger(cancel_after, 0);
4628 else if (MaxJobTime > 0)
dcb445bc
MS		 4629 job->cancel_time = time(NULL) + MaxJobTime;
4630 else
4631 job->cancel_time = 0;
4632
cb7f98ee
MS		 4633 /*
4634 * Check for support files...
4635 */
4636
4637 cupsdSetPrinterReasons(job->printer, "-cups-missing-filter-warning,"
4638 "cups-insecure-filter-warning");
4639
4640 if (printer->pc)
4641 {
4642 for (filename = (const char *)cupsArrayFirst(printer->pc->support_files);
4643 filename;
4644 filename = (const char *)cupsArrayNext(printer->pc->support_files))
4645 {
4646 if (_cupsFileCheck(filename, _CUPS_FILE_CHECK_FILE, !RunUser,
4647 cupsdLogFCMessage, printer))
4648 break;
4649 }
4650 }
4651
b9faaae1
MS		 4652 /*
4653 * Setup the last exit status and security profiles...
4654 */
89d46774 4655
8fe0183a
MS		 4656 job->status = 0;
4657 job->profile = cupsdCreateProfile(job->id, 0);
4658 job->bprofile = cupsdCreateProfile(job->id, 1);
bd7854cb 4659
b9faaae1
MS		 4660 /*
4661 * Create the status pipes and buffer...
4662 */
bd7854cb 4663
b9faaae1
MS		 4664 if (cupsdOpenPipe(job->status_pipes))
4665 {
4666 cupsdLogJob(job, CUPSD_LOG_DEBUG,
4667 "Unable to create job status pipes - %s.", strerror(errno));
89d46774 4668
b9faaae1
MS		 4669 cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
4670 "Job stopped because the scheduler could not create the "
4671 "job status pipes.");
89d46774 4672
b9faaae1
MS		 4673 cupsdDestroyProfile(job->profile);
4674 job->profile = NULL;
8fe0183a
MS		 4675 cupsdDestroyProfile(job->bprofile);
4676 job->bprofile = NULL;
b9faaae1 4677 return;
e1d6a774 4678 }
bd7854cb 4679
b9faaae1
MS		 4680 job->status_buffer = cupsdStatBufNew(job->status_pipes[0], NULL);
4681 job->status_level = CUPSD_LOG_INFO;
4682
4683 /*
4684 * Create the backchannel pipes and make them non-blocking...
4685 */
bd7854cb 4686
b9faaae1 4687 if (cupsdOpenPipe(job->back_pipes))
e1d6a774 4688 {
b9faaae1
MS		 4689 cupsdLogJob(job, CUPSD_LOG_DEBUG,
4690 "Unable to create back-channel pipes - %s.", strerror(errno));
4691
4692 cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
4693 "Job stopped because the scheduler could not create the "
4694 "back-channel pipes.");
4695
4696 cupsdClosePipe(job->status_pipes);
4697 cupsdStatBufDelete(job->status_buffer);
4698 job->status_buffer = NULL;
4699
4700 cupsdDestroyProfile(job->profile);
4701 job->profile = NULL;
8fe0183a
MS		 4702 cupsdDestroyProfile(job->bprofile);
4703 job->bprofile = NULL;
b9faaae1 4704 return;
e1d6a774 4705 }
bd7854cb 4706
b9faaae1
MS		 4707 fcntl(job->back_pipes[0], F_SETFL,
4708 fcntl(job->back_pipes[0], F_GETFL) | O_NONBLOCK);
4709 fcntl(job->back_pipes[1], F_SETFL,
4710 fcntl(job->back_pipes[1], F_GETFL) | O_NONBLOCK);
ef416fc2 4711
b9faaae1
MS		 4712 /*
4713 * Create the side-channel pipes and make them non-blocking...
4714 */
ef416fc2 4715
b9faaae1
MS		 4716 if (socketpair(AF_LOCAL, SOCK_STREAM, 0, job->side_pipes))
4717 {
4718 cupsdLogJob(job, CUPSD_LOG_DEBUG,
4719 "Unable to create side-channel pipes - %s.", strerror(errno));
ef416fc2 4720
b9faaae1
MS		 4721 cupsdSetJobState(job, IPP_JOB_STOPPED, CUPSD_JOB_DEFAULT,
4722 "Job stopped because the scheduler could not create the "
4723 "side-channel pipes.");
ef416fc2 4724
b9faaae1
MS		 4725 cupsdClosePipe(job->back_pipes);
4726
4727 cupsdClosePipe(job->status_pipes);
4728 cupsdStatBufDelete(job->status_buffer);
4729 job->status_buffer = NULL;
4730
4731 cupsdDestroyProfile(job->profile);
4732 job->profile = NULL;
8fe0183a
MS		 4733 cupsdDestroyProfile(job->bprofile);
4734 job->bprofile = NULL;
b9faaae1
MS		 4735 return;
4736 }
4737
4738 fcntl(job->side_pipes[0], F_SETFL,
4739 fcntl(job->side_pipes[0], F_GETFL) | O_NONBLOCK);
4740 fcntl(job->side_pipes[1], F_SETFL,
4741 fcntl(job->side_pipes[1], F_GETFL) | O_NONBLOCK);
ef416fc2 4742
7a0cbd5e
MS		 4743 fcntl(job->side_pipes[0], F_SETFD,
4744 fcntl(job->side_pipes[0], F_GETFD) | FD_CLOEXEC);
4745 fcntl(job->side_pipes[1], F_SETFD,
4746 fcntl(job->side_pipes[1], F_GETFD) | FD_CLOEXEC);
4747
ef416fc2 4748 /*
b9faaae1 4749 * Now start the first file in the job...
ef416fc2 4750 */
4751
b9faaae1
MS		 4752 cupsdContinueJob(job);
4753}
ef416fc2 4754
ef416fc2 4755
b9faaae1
MS		 4756/*
4757 * 'stop_job()' - Stop a print job.
4758 */
ef416fc2 4759
b9faaae1
MS		 4760static void
4761stop_job(cupsd_job_t *job, /* I - Job */
4762 cupsd_jobaction_t action) /* I - Action */
4763{
4764 int i; /* Looping var */
b94498cf 4765
ef416fc2 4766
b9faaae1
MS		 4767 cupsdLogMessage(CUPSD_LOG_DEBUG2, "stop_job(job=%p(%d), action=%d)", job,
4768 job->id, action);
ef416fc2 4769
b9faaae1
MS		 4770 FilterLevel -= job->cost;
4771 job->cost = 0;
ef416fc2 4772
765bf3be 4773 if (action == CUPSD_JOB_DEFAULT && !job->kill_time && job->backend > 0)
238c3832 4774 job->kill_time = time(NULL) + JobKillDelay;
ef55b745 4775 else if (action >= CUPSD_JOB_FORCE)
238c3832
MS		 4776 job->kill_time = 0;
4777
b9faaae1
MS		 4778 for (i = 0; job->filters[i]; i ++)
4779 if (job->filters[i] > 0)
ef55b745
MS		 4780 {
4781 cupsdEndProcess(job->filters[i], action >= CUPSD_JOB_FORCE);
4782
4783 if (action >= CUPSD_JOB_FORCE)
4784 job->filters[i] = -job->filters[i];
4785 }
b9faaae1
MS		 4786
4787 if (job->backend > 0)
ef55b745
MS		 4788 {
4789 cupsdEndProcess(job->backend, action >= CUPSD_JOB_FORCE);
4790
4791 if (action >= CUPSD_JOB_FORCE)
4792 job->backend = -job->backend;
4793 }
4794
4795 if (action >= CUPSD_JOB_FORCE)
4796 {
4797 /*
4798 * Clear job status...
4799 */
4800
4801 job->status = 0;
4802 }
e1d6a774 4803}
ef416fc2 4804
e1d6a774 4805
4806/*
4807 * 'unload_job()' - Unload a job from memory.
4808 */
4809
4810static void
4811unload_job(cupsd_job_t *job) /* I - Job */
4812{
4813 if (!job->attrs)
4814 return;
4815
72f50170 4816 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Unloading...");
e1d6a774 4817
4818 ippDelete(job->attrs);
4819
cc0d019f
MS		 4820 job->attrs = NULL;
4821 job->state = NULL;
12f89d24 4822 job->reasons = NULL;
9514a192 4823 job->impressions = NULL;
cc0d019f
MS		 4824 job->sheets = NULL;
4825 job->job_sheets = NULL;
4826 job->printer_message = NULL;
4827 job->printer_reasons = NULL;
ef416fc2 4828}
4829
4830
4831/*
f899b121 4832 * 'update_job()' - Read a status update from a job's filters.
4833 */
4834
4835void
09a101d6 4836update_job(cupsd_job_t *job) /* I - Job to check */
f899b121 4837{
4838 int i; /* Looping var */
4839 int copies; /* Number of copies printed */
178cb736
MS		 4840 char message[CUPSD_SB_BUFFER_SIZE],
4841 /* Message text */
f899b121 4842 *ptr; /* Pointer update... */
4843 int loglevel, /* Log level for message */
4844 event = 0; /* Events? */
8ef06c79
MS		 4845 cupsd_printer_t *printer = job->printer;
4846 /* Printer */
f0ab5bff
MS		 4847 static const char * const levels[] = /* Log levels */
4848 {
4849 "NONE",
4850 "EMERG",
4851 "ALERT",
4852 "CRIT",
4853 "ERROR",
4854 "WARN",
4855 "NOTICE",
4856 "INFO",
4857 "DEBUG",
4858 "DEBUG2"
4859 };
f899b121 4860
4861
f0ab5bff
MS		 4862 /*
4863 * Get the printer associated with this job; if the printer is stopped for
4864 * any reason then job->printer will be reset to NULL, so make sure we have
4865 * a valid pointer...
4866 */
4867
f899b121 4868 while ((ptr = cupsdStatBufUpdate(job->status_buffer, &loglevel,
4869 message, sizeof(message))) != NULL)
4870 {
4871 /*
4872 * Process page and printer state messages as needed...
4873 */
4874
4875 if (loglevel == CUPSD_LOG_PAGE)
4876 {
4877 /*
4878 * Page message; send the message to the page_log file and update the
4879 * job sheet count...
4880 */
4881
75bd9771 4882 cupsdLogJob(job, CUPSD_LOG_DEBUG, "PAGE: %s", message);
dd1abb6b 4883
9514a192
MS		 4884 if (job->impressions)
4885 {
4886 if (!_cups_strncasecmp(message, "total ", 6))
4887 {
4888 /*
4889 * Got a total count of pages from a backend or filter...
4890 */
4891
4892 copies = atoi(message + 6);
4893 copies -= ippGetInteger(job->impressions, 0); /* Just track the delta */
4894 }
4895 else if (!sscanf(message, "%*d%d", &copies))
4896 copies = 1;
4897
4898 ippSetInteger(job->attrs, &job->impressions, 0, ippGetInteger(job->impressions, 0) + copies);
4899 job->dirty = 1;
4900 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
4901 }
4902
91c84a35 4903 if (job->sheets)
f899b121 4904 {
88f9aafc 4905 if (!_cups_strncasecmp(message, "total ", 6))
f899b121 4906 {
4907 /*
4908 * Got a total count of pages from a backend or filter...
4909 */
4910
4911 copies = atoi(message + 6);
9514a192 4912 copies -= ippGetInteger(job->sheets, 0); /* Just track the delta */
f899b121 4913 }
4914 else if (!sscanf(message, "%*d%d", &copies))
4915 copies = 1;
4916
9514a192
MS		 4917 ippSetInteger(job->attrs, &job->sheets, 0, ippGetInteger(job->sheets, 0) + copies);
4918 job->dirty = 1;
4919 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
f899b121 4920
b9faaae1 4921 if (job->printer->page_limit)
ba55dc12 4922 cupsdUpdateQuota(job->printer, job->username, copies, 0);
f899b121 4923 }
4924
4925 cupsdLogPage(job, message);
4926
91c84a35 4927 if (job->sheets)
9514a192 4928 cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job, "Printed %d page(s).", ippGetInteger(job->sheets, 0));
f899b121 4929 }
a469f8a5
MS		 4930 else if (loglevel == CUPSD_LOG_JOBSTATE)
4931 {
4932 /*
4933 * Support "keyword" to set job-state-reasons to the specified keyword.
4934 * This is sufficient for the current paid printing stuff.
4935 */
4936
4937 cupsdLogJob(job, CUPSD_LOG_DEBUG, "JOBSTATE: %s", message);
4938
8e67b75b
MS		 4939 if (!strcmp(message, "cups-retry-as-raster"))
4940 job->retry_as_raster = 1;
4941 else
4942 ippSetString(job->attrs, &job->reasons, 0, message);
a469f8a5 4943 }
f899b121 4944 else if (loglevel == CUPSD_LOG_STATE)
4945 {
75bd9771 4946 cupsdLogJob(job, CUPSD_LOG_DEBUG, "STATE: %s", message);
dd1abb6b 4947
09a101d6 4948 if (!strcmp(message, "paused"))
c24d2134 4949 {
b9faaae1 4950 cupsdStopPrinter(job->printer, 1);
c24d2134
MS		 4951 return;
4952 }
0fa6c7fa 4953 else if (message[0] && cupsdSetPrinterReasons(job->printer, message))
dcb445bc 4954 {
d9bca400 4955 event |= CUPSD_EVENT_PRINTER_STATE;
bc44d920 4956
982069db 4957 if (MaxJobTime > 0)
dcb445bc
MS		 4958 {
4959 /*
4960 * Reset cancel time after connecting to the device...
4961 */
4962
4963 for (i = 0; i < job->printer->num_reasons; i ++)
4964 if (!strcmp(job->printer->reasons[i], "connecting-to-device"))
4965 break;
4966
4967 if (i >= job->printer->num_reasons)
982069db 4968 {
581dae2d
MS		 4969 ipp_attribute_t *cancel_after = ippFindAttribute(job->attrs,
4970 "job-cancel-after",
4971 IPP_TAG_INTEGER);
4972 /* job-cancel-after attribute */
4973
982069db
MS		 4974 if (cancel_after)
4975 job->cancel_time = time(NULL) + ippGetInteger(cancel_after, 0);
4976 else
4977 job->cancel_time = time(NULL) + MaxJobTime;
4978 }
dcb445bc
MS		 4979 }
4980 }
4981
4509bb49 4982 update_job_attrs(job, 0);
f899b121 4983 }
4984 else if (loglevel == CUPSD_LOG_ATTR)
4985 {
4986 /*
4987 * Set attribute(s)...
4988 */
4989
4990 int num_attrs; /* Number of attributes */
4991 cups_option_t *attrs; /* Attributes */
4992 const char *attr; /* Attribute */
4993
75bd9771 4994 cupsdLogJob(job, CUPSD_LOG_DEBUG, "ATTR: %s", message);
dd1abb6b 4995
f899b121 4996 num_attrs = cupsParseOptions(message, 0, &attrs);
4997
5a9febac
MS		 4998 if ((attr = cupsGetOption("auth-info-default", num_attrs,
4999 attrs)) != NULL)
5000 {
5001 job->printer->num_options = cupsAddOption("auth-info", attr,
5002 job->printer->num_options,
5003 &(job->printer->options));
5004 cupsdSetPrinterAttrs(job->printer);
5005
5006 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5007 }
5008
f899b121 5009 if ((attr = cupsGetOption("auth-info-required", num_attrs,
5010 attrs)) != NULL)
7ff4fea9 5011 {
b9faaae1
MS		 5012 cupsdSetAuthInfoRequired(job->printer, attr, NULL);
5013 cupsdSetPrinterAttrs(job->printer);
3dfe78b3 5014
a2326b5b 5015 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
7ff4fea9 5016 }
f899b121 5017
9a4f8274
MS		 5018 if ((attr = cupsGetOption("job-media-progress", num_attrs,
5019 attrs)) != NULL)
5020 {
5021 int progress = atoi(attr);
5022
5023
5024 if (progress >= 0 && progress <= 100)
5025 {
5026 job->progress = progress;
5027
5028 if (job->sheets)
b9faaae1 5029 cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
9a4f8274
MS		 5030 "Printing page %d, %d%%",
5031 job->sheets->values[0].integer, job->progress);
5032 }
5033 }
5034
323c5de1 5035 if ((attr = cupsGetOption("printer-alert", num_attrs, attrs)) != NULL)
5036 {
b9faaae1 5037 cupsdSetString(&job->printer->alert, attr);
d9bca400 5038 event |= CUPSD_EVENT_PRINTER_STATE;
323c5de1 5039 }
5040
5041 if ((attr = cupsGetOption("printer-alert-description", num_attrs,
5042 attrs)) != NULL)
5043 {
b9faaae1 5044 cupsdSetString(&job->printer->alert_description, attr);
d9bca400 5045 event |= CUPSD_EVENT_PRINTER_STATE;
323c5de1 5046 }
5047
5a738aea
MS		 5048 if ((attr = cupsGetOption("marker-colors", num_attrs, attrs)) != NULL)
5049 {
b9faaae1
MS		 5050 cupsdSetPrinterAttr(job->printer, "marker-colors", (char *)attr);
5051 job->printer->marker_time = time(NULL);
5a738aea 5052 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 5053 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 5054 }
5055
5056 if ((attr = cupsGetOption("marker-levels", num_attrs, attrs)) != NULL)
5057 {
b9faaae1
MS		 5058 cupsdSetPrinterAttr(job->printer, "marker-levels", (char *)attr);
5059 job->printer->marker_time = time(NULL);
5a738aea 5060 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 5061 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 5062 }
5063
ed6e7faf
MS		 5064 if ((attr = cupsGetOption("marker-low-levels", num_attrs, attrs)) != NULL)
5065 {
b9faaae1
MS		 5066 cupsdSetPrinterAttr(job->printer, "marker-low-levels", (char *)attr);
5067 job->printer->marker_time = time(NULL);
ed6e7faf
MS		 5068 event |= CUPSD_EVENT_PRINTER_STATE;
5069 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5070 }
5071
5072 if ((attr = cupsGetOption("marker-high-levels", num_attrs, attrs)) != NULL)
5073 {
b9faaae1
MS		 5074 cupsdSetPrinterAttr(job->printer, "marker-high-levels", (char *)attr);
5075 job->printer->marker_time = time(NULL);
ed6e7faf
MS		 5076 event |= CUPSD_EVENT_PRINTER_STATE;
5077 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5078 }
5079
75bd9771
MS		 5080 if ((attr = cupsGetOption("marker-message", num_attrs, attrs)) != NULL)
5081 {
b9faaae1
MS		 5082 cupsdSetPrinterAttr(job->printer, "marker-message", (char *)attr);
5083 job->printer->marker_time = time(NULL);
75bd9771 5084 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 5085 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
75bd9771
MS		 5086 }
5087
5a738aea
MS		 5088 if ((attr = cupsGetOption("marker-names", num_attrs, attrs)) != NULL)
5089 {
b9faaae1
MS		 5090 cupsdSetPrinterAttr(job->printer, "marker-names", (char *)attr);
5091 job->printer->marker_time = time(NULL);
5a738aea 5092 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 5093 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 5094 }
5095
5096 if ((attr = cupsGetOption("marker-types", num_attrs, attrs)) != NULL)
5097 {
b9faaae1
MS		 5098 cupsdSetPrinterAttr(job->printer, "marker-types", (char *)attr);
5099 job->printer->marker_time = time(NULL);
5a738aea 5100 event |= CUPSD_EVENT_PRINTER_STATE;
52f6f666 5101 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
5a738aea
MS		 5102 }
5103
f899b121 5104 cupsFreeOptions(num_attrs, attrs);
5105 }
c9fc04c6
MS		 5106 else if (loglevel == CUPSD_LOG_PPD)
5107 {
5108 /*
5109 * Set attribute(s)...
5110 */
5111
75bd9771 5112 cupsdLogJob(job, CUPSD_LOG_DEBUG, "PPD: %s", message);
dd1abb6b 5113
a29fd7dd
MS		 5114 job->num_keywords = cupsParseOptions(message, job->num_keywords,
5115 &job->keywords);
c9fc04c6 5116 }
4d301e69 5117 else
f899b121 5118 {
4d301e69
MS		 5119 /*
5120 * Strip legacy message prefix...
5121 */
f899b121 5122
4d301e69 5123 if (!strncmp(message, "recoverable:", 12))
d2354e63 5124 {
4d301e69
MS		 5125 ptr = message + 12;
5126 while (isspace(*ptr & 255))
5127 ptr ++;
d2354e63 5128 }
4d301e69 5129 else if (!strncmp(message, "recovered:", 10))
acb056cb 5130 {
4d301e69
MS		 5131 ptr = message + 10;
5132 while (isspace(*ptr & 255))
5133 ptr ++;
acb056cb 5134 }
4d301e69
MS		 5135 else
5136 ptr = message;
5137
dcb445bc
MS		 5138 if (*ptr)
5139 cupsdLogJob(job, loglevel, "%s", ptr);
f899b121 5140
5180a04c
MS		 5141 if (loglevel < CUPSD_LOG_DEBUG &&
5142 strcmp(job->printer->state_message, ptr))
1f0275e3 5143 {
4d301e69 5144 strlcpy(job->printer->state_message, ptr,
b9faaae1 5145 sizeof(job->printer->state_message));
4509bb49 5146
8b116e60 5147 event |= CUPSD_EVENT_PRINTER_STATE | CUPSD_EVENT_JOB_PROGRESS;
4509bb49 5148
229681c1 5149 if (loglevel <= job->status_level && job->status_level > CUPSD_LOG_ERROR)
1f0275e3
MS		 5150 {
5151 /*
b9faaae1 5152 * Some messages show in the job-printer-state-message attribute...
1f0275e3 5153 */
09a101d6 5154
1f0275e3
MS		 5155 if (loglevel != CUPSD_LOG_NOTICE)
5156 job->status_level = loglevel;
01ce6322 5157
1f0275e3 5158 update_job_attrs(job, 1);
f0ab5bff
MS		 5159
5160 cupsdLogJob(job, CUPSD_LOG_DEBUG,
5161 "Set job-printer-state-message to \"%s\", "
5162 "current level=%s",
5163 job->printer_message->values[0].string.text,
5164 levels[job->status_level]);
1f0275e3 5165 }
75bd9771 5166 }
f899b121 5167 }
5168
5169 if (!strchr(job->status_buffer->buffer, '\n'))
5170 break;
5171 }
5172
f8b3a85b
MS		 5173 if (event & CUPSD_EVENT_JOB_PROGRESS)
5174 cupsdAddEvent(CUPSD_EVENT_JOB_PROGRESS, job->printer, job,
5175 "%s", job->printer->state_message);
5180a04c 5176 if (event & CUPSD_EVENT_PRINTER_STATE)
b9faaae1
MS		 5177 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, job->printer, NULL,
5178 (job->printer->type & CUPS_PRINTER_CLASS) ?
f899b121 5179 "Class \"%s\" state changed." :
5180 "Printer \"%s\" state changed.",
b9faaae1 5181 job->printer->name);
f899b121 5182
8b116e60 5183
f899b121 5184 if (ptr == NULL && !job->status_buffer->bufused)
5185 {
5186 /*
5187 * See if all of the filters and the backend have returned their
5188 * exit statuses.
5189 */
5190
5191 for (i = 0; job->filters[i] < 0; i ++);
5192
5193 if (job->filters[i])
d7871c8c
MS		 5194 {
5195 /*
5196 * EOF but we haven't collected the exit status of all filters...
5197 */
5198
5199 cupsdCheckProcess();
f899b121 5200 return;
d7871c8c 5201 }
f899b121 5202
5203 if (job->current_file >= job->num_files && job->backend > 0)
d7871c8c
MS		 5204 {
5205 /*
5206 * EOF but we haven't collected the exit status of the backend...
5207 */
5208
5209 cupsdCheckProcess();
f899b121 5210 return;
d7871c8c 5211 }
f899b121 5212
5213 /*
5214 * Handle the end of job stuff...
5215 */
5216
ef55b745 5217 finalize_job(job, 1);
b9faaae1
MS		 5218
5219 /*
8ef06c79 5220 * Try printing another job...
b9faaae1
MS		 5221 */
5222
8ef06c79
MS		 5223 if (printer->state != IPP_PRINTER_STOPPED)
5224 cupsdCheckJobs();
f899b121 5225 }
5226}
5227
5228
5229/*
bc44d920 5230 * 'update_job_attrs()' - Update the job-printer-* attributes.
5231 */
5232
5233void
4509bb49 5234update_job_attrs(cupsd_job_t *job, /* I - Job to update */
b9faaae1 5235 int do_message)/* I - 1 = copy job-printer-state message */
bc44d920 5236{
5237 int i; /* Looping var */
5238 int num_reasons; /* Actual number of reasons */
5239 const char * const *reasons; /* Reasons */
f0ab5bff 5240 static const char *none = "none"; /* "none" reason */
bc44d920 5241
5242
5243 /*
5244 * Get/create the job-printer-state-* attributes...
5245 */
5246
5247 if (!job->printer_message)
5248 {
5249 if ((job->printer_message = ippFindAttribute(job->attrs,
5250 "job-printer-state-message",
5251 IPP_TAG_TEXT)) == NULL)
5252 job->printer_message = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_TEXT,
5253 "job-printer-state-message",
5254 NULL, "");
5255 }
5256
5257 if (!job->printer_reasons)
5258 job->printer_reasons = ippFindAttribute(job->attrs,
5259 "job-printer-state-reasons",
5260 IPP_TAG_KEYWORD);
5261
bc44d920 5262 /*
b9faaae1 5263 * Copy or clear the printer-state-message value as needed...
bc44d920 5264 */
5265
b9faaae1
MS		 5266 if (job->state_value != IPP_JOB_PROCESSING &&
5267 job->status_level == CUPSD_LOG_INFO)
dcb445bc 5268 {
5e6c3df7 5269 ippSetString(job->attrs, &job->printer_message, 0, "");
dcb445bc
MS		 5270
5271 job->dirty = 1;
5272 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
5273 }
b9faaae1 5274 else if (job->printer->state_message[0] && do_message)
dcb445bc 5275 {
5e6c3df7 5276 ippSetString(job->attrs, &job->printer_message, 0, job->printer->state_message);
ef55b745 5277
dcb445bc
MS		 5278 job->dirty = 1;
5279 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
5280 }
5281
bc44d920 5282 /*
5283 * ... and the printer-state-reasons value...
5284 */
5285
b9faaae1 5286 if (job->printer->num_reasons == 0)
bc44d920 5287 {
5288 num_reasons = 1;
f0ab5bff 5289 reasons = &none;
bc44d920 5290 }
5291 else
5292 {
b9faaae1
MS		 5293 num_reasons = job->printer->num_reasons;
5294 reasons = (const char * const *)job->printer->reasons;
bc44d920 5295 }
5296
5297 if (!job->printer_reasons || job->printer_reasons->num_values != num_reasons)
5298 {
b9faaae1
MS		 5299 /*
5300 * Replace/create a job-printer-state-reasons attribute...
5301 */
5302
bc44d920 5303 ippDeleteAttribute(job->attrs, job->printer_reasons);
5304
5305 job->printer_reasons = ippAddStrings(job->attrs,
5306 IPP_TAG_JOB, IPP_TAG_KEYWORD,
5307 "job-printer-state-reasons",
5308 num_reasons, NULL, NULL);
5309 }
b9faaae1 5310 else
d2354e63 5311 {
b9faaae1
MS		 5312 /*
5313 * Don't bother clearing the reason strings if they are the same...
5314 */
5315
5316 for (i = 0; i < num_reasons; i ++)
5317 if (strcmp(job->printer_reasons->values[i].string.text, reasons[i]))
5318 break;
5319
5320 if (i >= num_reasons)
5321 return;
5322
5323 /*
5324 * Not the same, so free the current strings...
5325 */
5326
5327 for (i = 0; i < num_reasons; i ++)
d2354e63
MS		 5328 _cupsStrFree(job->printer_reasons->values[i].string.text);
5329 }
bc44d920 5330
b9faaae1
MS		 5331 /*
5332 * Copy the reasons...
5333 */
5334
bc44d920 5335 for (i = 0; i < num_reasons; i ++)
d2354e63 5336 job->printer_reasons->values[i].string.text = _cupsStrAlloc(reasons[i]);
dcb445bc
MS		 5337
5338 job->dirty = 1;
5339 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
bc44d920 5340}
5341
5342
5343/*
f2d18633 5344 * End of "$Id$".
ef416fc2 5345 */
Unnamed repository; edit this file 'description' to name the repository.