]> git.ipfire.org Git - thirdparty/cups.git/blame - backend/ipp.c
projects / thirdparty / cups.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge changes from CUPS 1.7svn-r10755.
[thirdparty/cups.git] / backend / ipp.c
CommitLineData
ef416fc2 1/*
eac3a0a0 2 * "$Id: ipp.c 9759 2011-05-11 03:24:33Z mike $"
ef416fc2 3 *
cc754834 4 * IPP backend for CUPS.
ef416fc2 5 *
dcb445bc 6 * Copyright 2007-2012 by Apple Inc.
7594b224 7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
ef416fc2 8 *
9 * These coded instructions, statements, and computer programs are the
bc44d920 10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
ef416fc2 12 * "LICENSE" which should have been included with this file. If this
bc44d920 13 * file is missing or damaged, see the license at "http://www.cups.org/".
ef416fc2 14 *
15 * This file is subject to the Apple OS-Developed Software exception.
16 *
17 * Contents:
18 *
5a9febac
MS		 19 * main() - Send a file to the printer or server.
20 * cancel_job() - Cancel a print job.
7cf5915e 21 * check_printer_state() - Check the printer state.
5a9febac
MS		 22 * monitor_printer() - Monitor the printer state.
23 * new_request() - Create a new print creation or validation
24 * request.
25 * password_cb() - Disable the password prompt for
26 * cupsDoFileRequest().
27 * quote_string() - Quote a string value.
28 * report_attr() - Report an IPP attribute value.
ef416fc2 29 * report_printer_state() - Report the printer state.
5a9febac
MS		 30 * run_as_user() - Run the IPP backend as the printing user.
31 * sigterm_handler() - Handle 'terminate' signals that stop the backend.
32 * timeout_cb() - Handle HTTP timeouts.
33 * update_reasons() - Update the printer-state-reasons values.
ef416fc2 34 */
35
36/*
37 * Include necessary headers.
38 */
39
7a14d768 40#include "backend-private.h"
eac3a0a0 41#include <cups/array-private.h>
ef416fc2 42#include <sys/types.h>
43#include <sys/stat.h>
ef416fc2 44#include <sys/wait.h>
eac3a0a0
MS		 45#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
46# include <xpc/xpc.h>
47# define kPMPrintUIToolAgent "com.apple.printuitool.agent"
48# define kPMStartJob 100
49# define kPMWaitForJob 101
82cc1f9a
MS		 50# ifdef HAVE_XPC_PRIVATE_H
51# include <xpc/private.h>
52# else
eac3a0a0
MS		 53extern void xpc_connection_set_target_uid(xpc_connection_t connection,
54 uid_t uid);
82cc1f9a 55# endif /* HAVE_XPC_PRIVATE_H */
eac3a0a0 56#endif /* HAVE_GSSAPI && HAVE_XPC */
ef416fc2 57
7cf5915e 58
a469f8a5
MS		 59/*
60 * Bits for job-state-reasons we care about...
61 */
62
63#define _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED 0x01
64#define _CUPS_JSR_ACCOUNT_CLOSED 0x02
65#define _CUPS_JSR_ACCOUNT_INFO_NEEDED 0x04
66#define _CUPS_JSR_ACCOUNT_LIMIT_REACHED 0x08
67#define _CUPS_JSR_JOB_PASSWORD_WAIT 0x10
68#define _CUPS_JSR_JOB_RELEASE_WAIT 0x20
69
70
7cf5915e
MS		 71/*
72 * Types...
73 */
74
75typedef struct _cups_monitor_s /**** Monitoring data ****/
76{
77 const char *uri, /* Printer URI */
78 *hostname, /* Hostname */
79 *user, /* Username */
80 *resource; /* Resource path */
81 int port, /* Port number */
82 version, /* IPP version */
a29fd7dd 83 job_id, /* Job ID for submitted job */
a469f8a5 84 job_reasons, /* Job state reasons bits */
a29fd7dd 85 get_job_attrs; /* Support Get-Job-Attributes? */
dcb445bc 86 const char *job_name; /* Job name for submitted job */
7cf5915e
MS		 87 http_encryption_t encryption; /* Use encryption? */
88 ipp_jstate_t job_state; /* Current job state */
89 ipp_pstate_t printer_state; /* Current printer state */
90} _cups_monitor_t;
91
92
ef416fc2 93/*
94 * Globals...
95 */
96
eac3a0a0 97static const char *auth_info_required;
18ecb428 98 /* New auth-info-required value */
eac3a0a0
MS		 99#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
100static int child_pid = 0; /* Child process ID */
101#endif /* HAVE_GSSAPI && HAVE_XPC */
7cf5915e
MS		 102static const char * const jattrs[] = /* Job attributes we want */
103{
3dd9c340 104 "job-id",
eac3a0a0 105 "job-impressions-completed",
7cf5915e 106 "job-media-sheets-completed",
dcb445bc
MS		 107 "job-name",
108 "job-originating-user-name",
7cf5915e
MS		 109 "job-state",
110 "job-state-reasons"
111};
eac3a0a0
MS		 112static int job_canceled = 0;
113 /* Job cancelled? */
3e7fe0ca
MS		 114static char username[256] = "",
115 /* Username for device URI */
116 *password = NULL;
eac3a0a0
MS		 117 /* Password for device URI */
118static int password_tries = 0;
119 /* Password tries */
7cf5915e
MS		 120static const char * const pattrs[] = /* Printer attributes we want */
121{
a469f8a5
MS		 122#ifdef HAVE_LIBZ
123 "compression-supported",
124#endif /* HAVE_LIBZ */
7cf5915e
MS		 125 "copies-supported",
126 "cups-version",
127 "document-format-supported",
128 "marker-colors",
129 "marker-high-levels",
130 "marker-levels",
131 "marker-low-levels",
132 "marker-message",
133 "marker-names",
134 "marker-types",
135 "media-col-supported",
84315f46 136 "multiple-document-handling-supported",
c8fef167 137 "operations-supported",
7cf5915e
MS		 138 "printer-alert",
139 "printer-alert-description",
140 "printer-is-accepting-jobs",
141 "printer-state",
142 "printer-state-message",
a4845881 143 "printer-state-reasons"
7cf5915e 144};
07ed0e9a
MS		 145static const char * const remote_job_states[] =
146{ /* Remote job state keywords */
88f9aafc
MS		 147 "+cups-remote-pending",
148 "+cups-remote-pending-held",
149 "+cups-remote-processing",
150 "+cups-remote-stopped",
151 "+cups-remote-canceled",
152 "+cups-remote-aborted",
153 "+cups-remote-completed"
07ed0e9a 154};
321d8d57 155static _cups_mutex_t report_mutex = _CUPS_MUTEX_INITIALIZER;
eac3a0a0 156 /* Mutex to control access */
321d8d57
MS		 157static int num_attr_cache = 0;
158 /* Number of cached attributes */
159static cups_option_t *attr_cache = NULL;
160 /* Cached attributes */
161static cups_array_t *state_reasons; /* Array of printe-state-reasons keywords */
eac3a0a0
MS		 162static char tmpfilename[1024] = "";
163 /* Temporary spool file name */
ef416fc2 164
165
166/*
167 * Local functions...
168 */
169
7cf5915e
MS		 170static void cancel_job(http_t *http, const char *uri, int id,
171 const char *resource, const char *user,
172 int version);
173static ipp_pstate_t check_printer_state(http_t *http, const char *uri,
174 const char *resource,
321d8d57 175 const char *user, int version);
7cf5915e 176static void *monitor_printer(_cups_monitor_t *monitor);
0268488e
MS		 177static ipp_t *new_request(ipp_op_t op, int version, const char *uri,
178 const char *user, const char *title,
179 int num_options, cups_option_t *options,
180 const char *compression, int copies,
f14324a7 181 const char *format, _ppd_cache_t *pc,
a469f8a5 182 ppd_file_t *ppd,
84315f46 183 ipp_attribute_t *media_col_sup,
a469f8a5
MS		 184 ipp_attribute_t *doc_handling_sup,
185 int print_color_mode);
5a9febac
MS		 186static const char *password_cb(const char *prompt, http_t *http,
187 const char *method, const char *resource,
188 void *user_data);
189static const char *quote_string(const char *s, char *q, size_t qsize);
7cf5915e 190static void report_attr(ipp_attribute_t *attr);
321d8d57 191static void report_printer_state(ipp_t *ipp);
eac3a0a0 192#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
37e7e6e0 193static int run_as_user(char *argv[], uid_t uid,
eac3a0a0
MS		 194 const char *device_uri, int fd);
195#endif /* HAVE_GSSAPI && HAVE_XPC */
7cf5915e 196static void sigterm_handler(int sig);
f228370c 197static int timeout_cb(http_t *http, void *user_data);
eac3a0a0 198static void update_reasons(ipp_attribute_t *attr, const char *s);
ef416fc2 199
200
201/*
202 * 'main()' - Send a file to the printer or server.
203 *
204 * Usage:
205 *
206 * printer-uri job-id user title copies options [file]
207 */
208
209int /* O - Exit status */
bd7854cb 210main(int argc, /* I - Number of command-line args */
ef416fc2 211 char *argv[]) /* I - Command-line arguments */
212{
213 int i; /* Looping var */
b94498cf 214 int send_options; /* Send job options? */
ef416fc2 215 int num_options; /* Number of printer options */
216 cups_option_t *options; /* Printer options */
1f0275e3 217 const char *device_uri; /* Device URI */
acb056cb 218 char scheme[255], /* Scheme in URI */
ef416fc2 219 hostname[1024], /* Hostname */
ef416fc2 220 resource[1024], /* Resource info (printer name) */
26d47ec6 221 addrname[256], /* Address name */
ef416fc2 222 *optptr, /* Pointer to URI options */
db1f069b
MS		 223 *name, /* Name of option */
224 *value, /* Value of option */
225 sep; /* Separator character */
c8fef167 226 http_addrlist_t *addrlist; /* Address of printer */
5a9febac 227 int snmp_enabled = 1; /* Is SNMP enabled? */
7a14d768
MS		 228 int snmp_fd, /* SNMP socket */
229 start_count, /* Page count via SNMP at start */
426c6a59
MS		 230 page_count, /* Page count via SNMP */
231 have_supplies; /* Printer supports supply levels? */
bd7854cb 232 int num_files; /* Number of files to print */
82f97232
MS		 233 char **files, /* Files to print */
234 *compatfile = NULL; /* Compatibility filename */
235 off_t compatsize = 0; /* Size of compatibility file */
ef416fc2 236 int port; /* Port number (not used) */
c8fef167 237 char portname[255]; /* Port name */
ef416fc2 238 char uri[HTTP_MAX_URI]; /* Updated URI without user/pass */
dcb445bc 239 char print_job_name[1024]; /* Update job-name for Print-Job */
cc754834 240 http_status_t http_status; /* Status of HTTP request */
ef416fc2 241 ipp_status_t ipp_status; /* Status of IPP request */
242 http_t *http; /* HTTP connection */
243 ipp_t *request, /* IPP request */
244 *response, /* IPP response */
245 *supported; /* get-printer-attributes response */
c0e1af83 246 time_t start_time; /* Time of first connect */
c0e1af83 247 int contimeout; /* Connection timeout */
f14324a7
MS		 248 int delay, /* Delay for retries */
249 prev_delay; /* Previous delay */
0268488e
MS		 250 const char *compression; /* Compression mode */
251 int waitjob, /* Wait for job complete? */
a469f8a5 252 waitjob_tries = 0, /* Number of times we've waited */
ef416fc2 253 waitprinter; /* Wait for printer ready? */
7cf5915e 254 _cups_monitor_t monitor; /* Monitoring data */
ef416fc2 255 ipp_attribute_t *job_id_attr; /* job-id attribute */
256 int job_id; /* job-id value */
bd7854cb 257 ipp_attribute_t *job_sheets; /* job-media-sheets-completed */
258 ipp_attribute_t *job_state; /* job-state */
a469f8a5
MS		 259#ifdef HAVE_LIBZ
260 ipp_attribute_t *compression_sup; /* compression-supported */
261#endif /* HAVE_LIBZ */
bd7854cb 262 ipp_attribute_t *copies_sup; /* copies-supported */
cc754834 263 ipp_attribute_t *cups_version; /* cups-version */
bd7854cb 264 ipp_attribute_t *format_sup; /* document-format-supported */
cc754834 265 ipp_attribute_t *media_col_sup; /* media-col-supported */
0268488e 266 ipp_attribute_t *operations_sup; /* operations-supported */
84315f46 267 ipp_attribute_t *doc_handling_sup; /* multiple-document-handling-supported */
ef416fc2 268 ipp_attribute_t *printer_state; /* printer-state attribute */
bd7854cb 269 ipp_attribute_t *printer_accepting; /* printer-is-accepting-jobs */
dcb445bc 270 int create_job = 0, /* Does printer support Create-Job? */
a29fd7dd 271 get_job_attrs = 0, /* Does printer support Get-Job-Attributes? */
dcb445bc 272 send_document = 0, /* Does printer support Send-Document? */
a469f8a5
MS		 273 validate_job = 0, /* Does printer support Validate-Job? */
274 print_color_mode = 0; /* Does printer support print-color-mode? */
d09495fa 275 int copies, /* Number of copies for job */
276 copies_remaining; /* Number of copies remaining */
c277e2f8 277 const char *content_type, /* CONTENT_TYPE environment variable */
0268488e
MS		 278 *final_content_type, /* FINAL_CONTENT_TYPE environment var */
279 *document_format; /* document-format value */
cc754834 280 int fd; /* File descriptor */
eac3a0a0 281 off_t bytes = 0; /* Bytes copied */
cc754834 282 char buffer[16384]; /* Copy buffer */
ef416fc2 283#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
284 struct sigaction action; /* Actions for POSIX signals */
285#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
286 int version; /* IPP version */
a469f8a5
MS		 287 ppd_file_t *ppd = NULL; /* PPD file */
288 _ppd_cache_t *pc = NULL; /* PPD cache and mapping data */
eac3a0a0 289 fd_set input; /* Input set for select() */
ef416fc2 290
291
292 /*
293 * Make sure status messages are not buffered...
294 */
295
296 setbuf(stderr, NULL);
297
298 /*
299 * Ignore SIGPIPE and catch SIGTERM signals...
300 */
301
302#ifdef HAVE_SIGSET
303 sigset(SIGPIPE, SIG_IGN);
304 sigset(SIGTERM, sigterm_handler);
305#elif defined(HAVE_SIGACTION)
306 memset(&action, 0, sizeof(action));
307 action.sa_handler = SIG_IGN;
308 sigaction(SIGPIPE, &action, NULL);
309
310 sigemptyset(&action.sa_mask);
311 sigaddset(&action.sa_mask, SIGTERM);
312 action.sa_handler = sigterm_handler;
313 sigaction(SIGTERM, &action, NULL);
314#else
315 signal(SIGPIPE, SIG_IGN);
316 signal(SIGTERM, sigterm_handler);
317#endif /* HAVE_SIGSET */
318
319 /*
320 * Check command-line...
321 */
322
323 if (argc == 1)
324 {
325 char *s;
326
327 if ((s = strrchr(argv[0], '/')) != NULL)
328 s ++;
329 else
330 s = argv[0];
331
8b450588
MS		 332 printf("network %s \"Unknown\" \"%s (%s)\"\n",
333 s, _cupsLangString(cupsLangDefault(),
334 _("Internet Printing Protocol")), s);
ef416fc2 335 return (CUPS_BACKEND_OK);
336 }
bd7854cb 337 else if (argc < 6)
ef416fc2 338 {
db1f069b 339 _cupsLangPrintf(stderr,
0837b7e8 340 _("Usage: %s job-id user title copies options [file]"),
db1f069b 341 argv[0]);
ef416fc2 342 return (CUPS_BACKEND_STOP);
343 }
344
eac3a0a0
MS		 345 /*
346 * Get the device URI...
347 */
348
349 while ((device_uri = cupsBackendDeviceURI(argv)) == NULL)
350 {
351 _cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));
352 sleep(10);
353
354 if (getenv("CLASS") != NULL)
355 return (CUPS_BACKEND_FAILED);
356 }
357
358 if ((auth_info_required = getenv("AUTH_INFO_REQUIRED")) == NULL)
359 auth_info_required = "none";
360
5a9febac 361 state_reasons = _cupsArrayNewStrings(getenv("PRINTER_STATE_REASONS"), ',');
eac3a0a0
MS		 362
363#ifdef HAVE_GSSAPI
364 /*
365 * For Kerberos, become the printing user (if we can) to get the credentials
366 * that way.
367 */
368
369 if (!getuid() && (value = getenv("AUTH_UID")) != NULL)
370 {
371 uid_t uid = (uid_t)atoi(value);
372 /* User ID */
373
374# ifdef HAVE_XPC
375 if (uid > 0)
376 {
377 if (argc == 6)
37e7e6e0 378 return (run_as_user(argv, uid, device_uri, 0));
eac3a0a0
MS		 379 else
380 {
381 int status = 0; /* Exit status */
382
383 for (i = 6; i < argc && !status && !job_canceled; i ++)
384 {
385 if ((fd = open(argv[i], O_RDONLY)) >= 0)
386 {
37e7e6e0 387 status = run_as_user(argv, uid, device_uri, fd);
eac3a0a0
MS		 388 close(fd);
389 }
390 else
391 {
392 _cupsLangPrintError("ERROR", _("Unable to open print file"));
393 status = CUPS_BACKEND_FAILED;
394 }
395 }
396
397 return (status);
398 }
399 }
400
401# else /* No XPC, just try to run as the user ID */
402 if (uid > 0)
403 seteuid(uid);
404# endif /* HAVE_XPC */
405 }
406#endif /* HAVE_GSSAPI */
407
ef416fc2 408 /*
bd7854cb 409 * Get the (final) content type...
ef416fc2 410 */
411
c277e2f8
MS		 412 if ((content_type = getenv("CONTENT_TYPE")) == NULL)
413 content_type = "application/octet-stream";
ef416fc2 414
c277e2f8
MS		 415 if ((final_content_type = getenv("FINAL_CONTENT_TYPE")) == NULL)
416 {
417 final_content_type = content_type;
418
419 if (!strncmp(final_content_type, "printer/", 8))
420 final_content_type = "application/vnd.cups-raw";
421 }
d09495fa 422
ef416fc2 423 /*
424 * Extract the hostname and printer name from the URI...
425 */
426
acb056cb
MS		 427 httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
428 username, sizeof(username), hostname, sizeof(hostname), &port,
429 resource, sizeof(resource));
ef416fc2 430
a41f09e2
MS		 431 if (!port)
432 port = IPP_PORT; /* Default to port 631 */
433
acb056cb 434 if (!strcmp(scheme, "https"))
ef416fc2 435 cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
8ca02f3c 436 else
437 cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
ef416fc2 438
ef416fc2 439 /*
440 * See if there are any options...
441 */
442
0268488e 443 compression = NULL;
cc754834 444 version = 20;
ef416fc2 445 waitjob = 1;
446 waitprinter = 1;
c0e1af83 447 contimeout = 7 * 24 * 60 * 60;
ef416fc2 448
449 if ((optptr = strchr(resource, '?')) != NULL)
450 {
451 /*
452 * Yup, terminate the device name string and move to the first
453 * character of the optptr...
454 */
455
456 *optptr++ = '\0';
457
458 /*
459 * Then parse the optptr...
460 */
461
462 while (*optptr)
463 {
464 /*
465 * Get the name...
466 */
467
db1f069b 468 name = optptr;
ef416fc2 469
db1f069b
MS		 470 while (*optptr && *optptr != '=' && *optptr != '+' && *optptr != '&')
471 optptr ++;
472
473 if ((sep = *optptr) != '\0')
474 *optptr++ = '\0';
475
476 if (sep == '=')
ef416fc2 477 {
478 /*
479 * Get the value...
480 */
481
db1f069b 482 value = optptr;
ef416fc2 483
db1f069b 484 while (*optptr && *optptr != '+' && *optptr != '&')
ef416fc2 485 optptr ++;
db1f069b
MS		 486
487 if (*optptr)
488 *optptr++ = '\0';
ef416fc2 489 }
490 else
db1f069b 491 value = (char *)"";
ef416fc2 492
493 /*
494 * Process the option...
495 */
496
88f9aafc 497 if (!_cups_strcasecmp(name, "waitjob"))
ef416fc2 498 {
499 /*
500 * Wait for job completion?
501 */
502
88f9aafc
MS		 503 waitjob = !_cups_strcasecmp(value, "on") ||
504 !_cups_strcasecmp(value, "yes") ||
505 !_cups_strcasecmp(value, "true");
ef416fc2 506 }
88f9aafc 507 else if (!_cups_strcasecmp(name, "waitprinter"))
ef416fc2 508 {
509 /*
510 * Wait for printer idle?
511 */
512
88f9aafc
MS		 513 waitprinter = !_cups_strcasecmp(value, "on") ||
514 !_cups_strcasecmp(value, "yes") ||
515 !_cups_strcasecmp(value, "true");
ef416fc2 516 }
88f9aafc 517 else if (!_cups_strcasecmp(name, "encryption"))
ef416fc2 518 {
519 /*
520 * Enable/disable encryption?
521 */
522
88f9aafc 523 if (!_cups_strcasecmp(value, "always"))
ef416fc2 524 cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
88f9aafc 525 else if (!_cups_strcasecmp(value, "required"))
ef416fc2 526 cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
88f9aafc 527 else if (!_cups_strcasecmp(value, "never"))
ef416fc2 528 cupsSetEncryption(HTTP_ENCRYPT_NEVER);
88f9aafc 529 else if (!_cups_strcasecmp(value, "ifrequested"))
ef416fc2 530 cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
531 else
532 {
0837b7e8
MS		 533 _cupsLangPrintFilter(stderr, "ERROR",
534 _("Unknown encryption option value: \"%s\"."),
535 value);
ef416fc2 536 }
537 }
5a9febac
MS		 538 else if (!_cups_strcasecmp(name, "snmp"))
539 {
540 /*
541 * Enable/disable SNMP stuff...
542 */
543
544 snmp_enabled = !value[0] || !_cups_strcasecmp(value, "on") ||
545 _cups_strcasecmp(value, "yes") ||
546 _cups_strcasecmp(value, "true");
547 }
88f9aafc 548 else if (!_cups_strcasecmp(name, "version"))
ef416fc2 549 {
550 if (!strcmp(value, "1.0"))
c168a833 551 version = 10;
ef416fc2 552 else if (!strcmp(value, "1.1"))
c168a833
MS		 553 version = 11;
554 else if (!strcmp(value, "2.0"))
555 version = 20;
556 else if (!strcmp(value, "2.1"))
557 version = 21;
0837b7e8
MS		 558 else if (!strcmp(value, "2.2"))
559 version = 22;
ef416fc2 560 else
561 {
0837b7e8
MS		 562 _cupsLangPrintFilter(stderr, "ERROR",
563 _("Unknown version option value: \"%s\"."),
564 value);
ef416fc2 565 }
566 }
b423cd4c 567#ifdef HAVE_LIBZ
88f9aafc 568 else if (!_cups_strcasecmp(name, "compression"))
b423cd4c 569 {
88f9aafc
MS		 570 if (!_cups_strcasecmp(value, "true") || !_cups_strcasecmp(value, "yes") ||
571 !_cups_strcasecmp(value, "on") || !_cups_strcasecmp(value, "gzip"))
0268488e 572 compression = "gzip";
a469f8a5
MS		 573 else if (!_cups_strcasecmp(value, "deflate"))
574 compression = "deflate";
575 else if (!_cups_strcasecmp(value, "false") ||
576 !_cups_strcasecmp(value, "no") ||
577 !_cups_strcasecmp(value, "off") ||
578 !_cups_strcasecmp(value, "none"))
579 compression = "none";
b423cd4c 580 }
581#endif /* HAVE_LIBZ */
88f9aafc 582 else if (!_cups_strcasecmp(name, "contimeout"))
c0e1af83 583 {
584 /*
585 * Set the connection timeout...
586 */
587
588 if (atoi(value) > 0)
589 contimeout = atoi(value);
590 }
ef416fc2 591 else
592 {
593 /*
594 * Unknown option...
595 */
596
0837b7e8
MS		 597 _cupsLangPrintFilter(stderr, "ERROR",
598 _("Unknown option \"%s\" with value \"%s\"."),
599 name, value);
ef416fc2 600 }
601 }
602 }
603
b423cd4c 604 /*
605 * If we have 7 arguments, print the file named on the command-line.
606 * Otherwise, copy stdin to a temporary file and print the temporary
607 * file.
608 */
609
610 if (argc == 6)
611 {
cc754834 612 num_files = 0;
f228370c 613 files = NULL;
88f9aafc
MS		 614 send_options = !_cups_strcasecmp(final_content_type, "application/pdf") ||
615 !_cups_strcasecmp(final_content_type, "application/vnd.cups-pdf") ||
616 !_cups_strncasecmp(final_content_type, "image/", 6);
cc754834
MS		 617
618 fputs("DEBUG: Sending stdin for job...\n", stderr);
b423cd4c 619 }
620 else
621 {
622 /*
623 * Point to the files on the command-line...
624 */
625
c277e2f8
MS		 626 num_files = argc - 6;
627 files = argv + 6;
628 send_options = 1;
b94498cf 629
cc754834
MS		 630 fprintf(stderr, "DEBUG: %d files to send in job...\n", num_files);
631 }
b423cd4c 632
ef416fc2 633 /*
634 * Set the authentication info, if any...
635 */
636
5a9febac 637 cupsSetPasswordCB2(password_cb, NULL);
ef416fc2 638
639 if (username[0])
640 {
641 /*
5a9febac 642 * Use authentication information in the device URI...
ef416fc2 643 */
644
645 if ((password = strchr(username, ':')) != NULL)
646 *password++ = '\0';
647
648 cupsSetUser(username);
649 }
82f97232 650 else
ef416fc2 651 {
652 /*
09a101d6 653 * Try loading authentication information from the environment.
ef416fc2 654 */
655
db1f069b
MS		 656 const char *ptr = getenv("AUTH_USERNAME");
657
658 if (ptr)
3e7fe0ca
MS		 659 {
660 strlcpy(username, ptr, sizeof(username));
09a101d6 661 cupsSetUser(ptr);
3e7fe0ca 662 }
ef416fc2 663
09a101d6 664 password = getenv("AUTH_PASSWORD");
ef416fc2 665 }
666
667 /*
c8fef167 668 * Try finding the remote server...
ef416fc2 669 */
670
4d301e69 671 start_time = time(NULL);
c0e1af83 672
c8fef167
MS		 673 sprintf(portname, "%d", port);
674
eac3a0a0 675 update_reasons(NULL, "+connecting-to-device");
c8fef167
MS		 676 fprintf(stderr, "DEBUG: Looking up \"%s\"...\n", hostname);
677
678 while ((addrlist = httpAddrGetList(hostname, AF_UNSPEC, portname)) == NULL)
679 {
680 _cupsLangPrintFilter(stderr, "INFO",
681 _("Unable to locate printer \"%s\"."), hostname);
682 sleep(10);
683
684 if (getenv("CLASS") != NULL)
685 {
eac3a0a0 686 update_reasons(NULL, "-connecting-to-device");
c8fef167
MS		 687 return (CUPS_BACKEND_STOP);
688 }
f3c17241
MS		 689
690 if (job_canceled)
691 return (CUPS_BACKEND_OK);
c8fef167
MS		 692 }
693
a469f8a5
MS		 694 http = _httpCreate(hostname, port, addrlist, AF_UNSPEC, cupsEncryption(), 1,
695 _HTTP_MODE_CLIENT);
f228370c 696 httpSetTimeout(http, 30.0, timeout_cb, NULL);
c8fef167
MS		 697
698 /*
699 * See if the printer supports SNMP...
700 */
701
5a9febac
MS		 702 if (snmp_enabled)
703 snmp_fd = _cupsSNMPOpen(addrlist->addr.addr.sa_family);
704 else
705 snmp_fd = -1;
706
707 if (snmp_fd >= 0)
c8fef167
MS		 708 have_supplies = !backendSNMPSupplies(snmp_fd, &(addrlist->addr),
709 &start_count, NULL);
c8fef167
MS		 710 else
711 have_supplies = start_count = 0;
712
713 /*
714 * Wait for data from the filter...
715 */
716
717 if (num_files == 0)
eac3a0a0 718 {
f14324a7 719 if (!backendWaitLoop(snmp_fd, &(addrlist->addr), 0, backendNetworkSideCB))
c8fef167 720 return (CUPS_BACKEND_OK);
eac3a0a0
MS		 721 else if ((bytes = read(0, buffer, sizeof(buffer))) <= 0)
722 return (CUPS_BACKEND_OK);
723 }
c8fef167
MS		 724
725 /*
726 * Try connecting to the remote server...
727 */
728
f14324a7 729 delay = _cupsNextDelay(0, &prev_delay);
757d2cad 730
ef416fc2 731 do
732 {
acb056cb 733 fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
0837b7e8 734 _cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
ef416fc2 735
c8fef167 736 if (httpReconnect(http))
ef416fc2 737 {
c7017ecc
MS		 738 int error = errno; /* Connection error */
739
c8fef167 740 if (http->status == HTTP_PKI_ERROR)
eac3a0a0 741 update_reasons(NULL, "+cups-certificate-error");
c8fef167 742
cc754834 743 if (job_canceled)
7594b224 744 break;
745
ef416fc2 746 if (getenv("CLASS") != NULL)
747 {
748 /*
749 * If the CLASS environment variable is set, the job was submitted
750 * to a class and not to a specific queue. In this case, we want
751 * to abort immediately so that the job can be requeued on the next
752 * available printer in the class.
753 */
754
0837b7e8
MS		 755 _cupsLangPrintFilter(stderr, "INFO",
756 _("Unable to contact printer, queuing on next "
757 "printer in class."));
ef416fc2 758
ef416fc2 759 /*
760 * Sleep 5 seconds to keep the job from requeuing too rapidly...
761 */
762
763 sleep(5);
764
eac3a0a0 765 update_reasons(NULL, "-connecting-to-device");
c8fef167 766
ef416fc2 767 return (CUPS_BACKEND_FAILED);
768 }
769
c7017ecc
MS		 770 fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(errno));
771
ef416fc2 772 if (errno == ECONNREFUSED || errno == EHOSTDOWN ||
773 errno == EHOSTUNREACH)
774 {
c0e1af83 775 if (contimeout && (time(NULL) - start_time) > contimeout)
776 {
0837b7e8
MS		 777 _cupsLangPrintFilter(stderr, "ERROR",
778 _("The printer is not responding."));
eac3a0a0 779 update_reasons(NULL, "-connecting-to-device");
c0e1af83 780 return (CUPS_BACKEND_FAILED);
781 }
782
c7017ecc
MS		 783 switch (error)
784 {
785 case EHOSTDOWN :
0837b7e8 786 _cupsLangPrintFilter(stderr, "WARNING",
22c9029b
MS		 787 _("The printer may not exist or "
788 "is unavailable at this time."));
c7017ecc
MS		 789 break;
790
791 case EHOSTUNREACH :
0837b7e8 792 _cupsLangPrintFilter(stderr, "WARNING",
22c9029b
MS		 793 _("The printer is unreachable at this "
794 "time."));
c7017ecc
MS		 795 break;
796
797 case ECONNREFUSED :
798 default :
0837b7e8 799 _cupsLangPrintFilter(stderr, "WARNING",
f3c17241 800 _("The printer is in use."));
c7017ecc
MS		 801 break;
802 }
c0e1af83 803
804 sleep(delay);
805
f14324a7 806 delay = _cupsNextDelay(delay, &prev_delay);
ef416fc2 807 }
ef416fc2 808 else
809 {
0837b7e8 810 _cupsLangPrintFilter(stderr, "ERROR",
22c9029b 811 _("The printer is not responding."));
ef416fc2 812 sleep(30);
813 }
7594b224 814
cc754834 815 if (job_canceled)
7594b224 816 break;
ef416fc2 817 }
c8fef167 818 else
eac3a0a0 819 update_reasons(NULL, "-cups-certificate-error");
ef416fc2 820 }
c8fef167 821 while (http->fd < 0);
ef416fc2 822
f3c17241
MS		 823 if (job_canceled)
824 return (CUPS_BACKEND_OK);
825 else if (!http)
7594b224 826 return (CUPS_BACKEND_FAILED);
7594b224 827
eac3a0a0 828 update_reasons(NULL, "-connecting-to-device");
0837b7e8 829 _cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
ef416fc2 830
22c9029b
MS		 831 fprintf(stderr, "DEBUG: Connected to %s:%d...\n",
832 httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
a469f8a5 833 httpAddrPort(http->hostaddr));
26d47ec6 834
ef416fc2 835 /*
836 * Build a URI for the printer and fill the standard IPP attributes for
837 * an IPP_PRINT_FILE request. We can't use the URI in argv[0] because it
838 * might contain username:password information...
839 */
840
acb056cb
MS		 841 httpAssembleURI(HTTP_URI_CODING_ALL, uri, sizeof(uri), scheme, NULL, hostname,
842 port, resource);
ef416fc2 843
844 /*
845 * First validate the destination and see if the device supports multiple
cc754834 846 * copies...
ef416fc2 847 */
848
a469f8a5
MS		 849#ifdef HAVE_LIBZ
850 compression_sup = NULL;
851#endif /* HAVE_LIBZ */
84315f46
MS		 852 copies_sup = NULL;
853 cups_version = NULL;
854 format_sup = NULL;
855 media_col_sup = NULL;
856 supported = NULL;
857 operations_sup = NULL;
858 doc_handling_sup = NULL;
ef416fc2 859
860 do
861 {
7a14d768
MS		 862 /*
863 * Check for side-channel requests...
864 */
865
866 backendCheckSideChannel(snmp_fd, http->hostaddr);
867
ef416fc2 868 /*
869 * Build the IPP request...
870 */
871
fa73b229 872 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
c168a833
MS		 873 request->request.op.version[0] = version / 10;
874 request->request.op.version[1] = version % 10;
ef416fc2 875
876 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
877 NULL, uri);
878
879 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
880 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
881 NULL, pattrs);
882
883 /*
884 * Do the request...
885 */
886
887 fputs("DEBUG: Getting supported attributes...\n", stderr);
888
97c9a8d7 889 if (http->version < HTTP_1_1)
cc754834 890 {
c7017ecc
MS		 891 fprintf(stderr, "DEBUG: Printer responded with HTTP version %d.%d.\n",
892 http->version / 100, http->version % 100);
eac3a0a0
MS		 893 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
894 "cups-ipp-wrong-http-version");
cc754834 895 }
97c9a8d7 896
7cf5915e
MS		 897 supported = cupsDoRequest(http, request, resource);
898 ipp_status = cupsLastError();
ef416fc2 899
22c9029b
MS		 900 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
901 ippErrorString(ipp_status), cupsLastErrorString());
902
3e7fe0ca
MS		 903 if (ipp_status <= IPP_OK_CONFLICT)
904 password_tries = 0;
905 else
ef416fc2 906 {
7cf5915e
MS		 907 fprintf(stderr, "DEBUG: Get-Printer-Attributes returned %s.\n",
908 ippErrorString(ipp_status));
909
ef416fc2 910 if (ipp_status == IPP_PRINTER_BUSY ||
911 ipp_status == IPP_SERVICE_UNAVAILABLE)
912 {
c0e1af83 913 if (contimeout && (time(NULL) - start_time) > contimeout)
914 {
0837b7e8
MS		 915 _cupsLangPrintFilter(stderr, "ERROR",
916 _("The printer is not responding."));
c0e1af83 917 return (CUPS_BACKEND_FAILED);
918 }
919
f3c17241 920 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
c0e1af83 921
321d8d57 922 report_printer_state(supported);
c0e1af83 923
924 sleep(delay);
925
f14324a7 926 delay = _cupsNextDelay(delay, &prev_delay);
ef416fc2 927 }
928 else if ((ipp_status == IPP_BAD_REQUEST ||
c168a833 929 ipp_status == IPP_VERSION_NOT_SUPPORTED) && version > 10)
ef416fc2 930 {
931 /*
cc754834 932 * Switch to IPP/1.1 or IPP/1.0...
ef416fc2 933 */
934
cc754834
MS		 935 if (version >= 20)
936 {
a469f8a5
MS		 937 _cupsLangPrintFilter(stderr, "INFO", _("Preparing to print."));
938 fprintf(stderr,
939 "DEBUG: The printer does not support IPP/%d.%d, trying "
940 "IPP/1.1.\n", version / 10, version % 10);
cc754834
MS		 941 version = 11;
942 }
943 else
944 {
a469f8a5
MS		 945 _cupsLangPrintFilter(stderr, "INFO", _("Preparing to print."));
946 fprintf(stderr,
947 "DEBUG: The printer does not support IPP/%d.%d, trying "
948 "IPP/1.0.\n", version / 10, version % 10);
cc754834
MS		 949 version = 10;
950 }
951
ef416fc2 952 httpReconnect(http);
953 }
954 else if (ipp_status == IPP_NOT_FOUND)
955 {
0837b7e8 956 _cupsLangPrintFilter(stderr, "ERROR",
a469f8a5
MS		 957 _("The printer configuration is incorrect or the "
958 "printer no longer exists."));
ef416fc2 959
22c9029b 960 ippDelete(supported);
ef416fc2 961
962 return (CUPS_BACKEND_STOP);
963 }
3e7fe0ca
MS		 964 else if (ipp_status == IPP_FORBIDDEN ||
965 ipp_status == IPP_AUTHENTICATION_CANCELED)
41681883 966 {
12f89d24
MS		 967 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
968 /* WWW-Authenticate field value */
969
970 if (!strncmp(www_auth, "Negotiate", 9))
41681883 971 auth_info_required = "negotiate";
12f89d24
MS		 972 else if (www_auth[0])
973 auth_info_required = "username,password";
41681883
MS		 974
975 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
976 return (CUPS_BACKEND_AUTH_REQUIRED);
977 }
3e7fe0ca 978 else if (ipp_status != IPP_NOT_AUTHORIZED)
ef416fc2 979 {
0837b7e8 980 _cupsLangPrintFilter(stderr, "ERROR",
22c9029b 981 _("Unable to get printer status."));
ef416fc2 982 sleep(10);
5a9febac
MS		 983
984 httpReconnect(http);
ef416fc2 985 }
986
22c9029b
MS		 987 ippDelete(supported);
988 supported = NULL;
ef416fc2 989 continue;
990 }
cc754834 991
eac3a0a0 992 if (!getenv("CLASS"))
22c9029b 993 {
eac3a0a0
MS		 994 /*
995 * Check printer-is-accepting-jobs = false and printer-state-reasons for the
996 * "spool-area-full" keyword...
997 */
22c9029b 998
eac3a0a0
MS		 999 int busy = 0;
1000
1001 if ((printer_accepting = ippFindAttribute(supported,
1002 "printer-is-accepting-jobs",
1003 IPP_TAG_BOOLEAN)) != NULL &&
1004 !printer_accepting->values[0].boolean)
1005 busy = 1;
1006 else if (!printer_accepting)
1007 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1008 "cups-ipp-missing-printer-is-accepting-jobs");
88f9aafc 1009
eac3a0a0
MS		 1010 if ((printer_state = ippFindAttribute(supported,
1011 "printer-state-reasons",
a469f8a5
MS		 1012 IPP_TAG_KEYWORD)) == NULL)
1013 {
1014 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1015 "cups-ipp-missing-printer-state-reasons");
1016 }
1017 else if (!busy)
eac3a0a0
MS		 1018 {
1019 for (i = 0; i < printer_state->num_values; i ++)
a469f8a5 1020 {
eac3a0a0
MS		 1021 if (!strcmp(printer_state->values[0].string.text,
1022 "spool-area-full") ||
1023 !strncmp(printer_state->values[0].string.text, "spool-area-full-",
1024 16))
1025 {
1026 busy = 1;
1027 break;
1028 }
a469f8a5 1029 }
eac3a0a0 1030 }
eac3a0a0
MS		 1031
1032 if (busy)
22c9029b 1033 {
f3c17241 1034 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
22c9029b 1035
321d8d57 1036 report_printer_state(supported);
22c9029b
MS		 1037
1038 sleep(delay);
1039
eac3a0a0 1040 delay = _cupsNextDelay(delay, &prev_delay);
22c9029b
MS		 1041
1042 ippDelete(supported);
1043 supported = NULL;
1044 continue;
1045 }
1046 }
22c9029b 1047
cc754834
MS		 1048 /*
1049 * Check for supported attributes...
1050 */
1051
a469f8a5
MS		 1052#ifdef HAVE_LIBZ
1053 if ((compression_sup = ippFindAttribute(supported, "compression-supported",
1054 IPP_TAG_KEYWORD)) != NULL)
1055 {
1056 /*
1057 * Check whether the requested compression is supported and/or default to
1058 * compression if supported...
1059 */
1060
1061 if (compression && !ippContainsString(compression_sup, compression))
1062 {
1063 fprintf(stderr, "DEBUG: Printer does not support the requested "
1064 "compression value \"%s\".\n", compression);
1065 compression = NULL;
1066 }
1067 else if (!compression)
1068 {
1069 if (ippContainsString(compression_sup, "deflate"))
1070 compression = "deflate";
1071 else if (ippContainsString(compression_sup, "gzip"))
1072 compression = "gzip";
1073
1074 if (compression)
1075 fprintf(stderr, "DEBUG: Automatically using \"%s\" compression.\n",
1076 compression);
1077 }
1078 }
1079#endif /* HAVE_LIBZ */
1080
cc754834
MS		 1081 if ((copies_sup = ippFindAttribute(supported, "copies-supported",
1082 IPP_TAG_RANGE)) != NULL)
ef416fc2 1083 {
1084 /*
1085 * Has the "copies-supported" attribute - does it have an upper
1086 * bound > 1?
1087 */
1088
cc754834
MS		 1089 fprintf(stderr, "DEBUG: copies-supported=%d-%d\n",
1090 copies_sup->values[0].range.lower,
1091 copies_sup->values[0].range.upper);
1092
ef416fc2 1093 if (copies_sup->values[0].range.upper <= 1)
1094 copies_sup = NULL; /* No */
1095 }
1096
cc754834 1097 cups_version = ippFindAttribute(supported, "cups-version", IPP_TAG_TEXT);
ef416fc2 1098
cc754834
MS		 1099 if ((format_sup = ippFindAttribute(supported, "document-format-supported",
1100 IPP_TAG_MIMETYPE)) != NULL)
ef416fc2 1101 {
1102 fprintf(stderr, "DEBUG: document-format-supported (%d values)\n",
1103 format_sup->num_values);
1104 for (i = 0; i < format_sup->num_values; i ++)
1105 fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
1106 format_sup->values[i].string.text);
1107 }
1108
cc754834
MS		 1109 if ((media_col_sup = ippFindAttribute(supported, "media-col-supported",
1110 IPP_TAG_KEYWORD)) != NULL)
1111 {
1112 fprintf(stderr, "DEBUG: media-col-supported (%d values)\n",
1113 media_col_sup->num_values);
1114 for (i = 0; i < media_col_sup->num_values; i ++)
1115 fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
1116 media_col_sup->values[i].string.text);
1117 }
1118
a469f8a5
MS		 1119 print_color_mode = ippFindAttribute(supported,
1120 "print-color-mode-supported",
1121 IPP_TAG_KEYWORD) != NULL;
1122
0268488e
MS		 1123 if ((operations_sup = ippFindAttribute(supported, "operations-supported",
1124 IPP_TAG_ENUM)) != NULL)
1125 {
a469f8a5
MS		 1126 fprintf(stderr, "DEBUG: operations-supported (%d values)\n",
1127 operations_sup->num_values);
1128 for (i = 0; i < operations_sup->num_values; i ++)
1129 fprintf(stderr, "DEBUG: [%d] = %s\n", i,
1130 ippOpString(operations_sup->values[i].integer));
1131
eac3a0a0
MS		 1132 for (i = 0; i < operations_sup->num_values; i ++)
1133 if (operations_sup->values[i].integer == IPP_PRINT_JOB)
1134 break;
1135
1136 if (i >= operations_sup->num_values)
1137 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1138 "cups-ipp-missing-print-job");
1139
1140 for (i = 0; i < operations_sup->num_values; i ++)
1141 if (operations_sup->values[i].integer == IPP_CANCEL_JOB)
1142 break;
1143
1144 if (i >= operations_sup->num_values)
1145 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1146 "cups-ipp-missing-cancel-job");
1147
1148 for (i = 0; i < operations_sup->num_values; i ++)
1149 if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
1150 break;
1151
1152 if (i >= operations_sup->num_values)
1153 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1154 "cups-ipp-missing-get-job-attributes");
1155
1156 for (i = 0; i < operations_sup->num_values; i ++)
1157 if (operations_sup->values[i].integer == IPP_GET_PRINTER_ATTRIBUTES)
1158 break;
1159
1160 if (i >= operations_sup->num_values)
1161 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1162 "cups-ipp-missing-get-printer-attributes");
1163
0268488e 1164 for (i = 0; i < operations_sup->num_values; i ++)
dcb445bc 1165 {
0268488e 1166 if (operations_sup->values[i].integer == IPP_VALIDATE_JOB)
0268488e 1167 validate_job = 1;
dcb445bc
MS		 1168 else if (operations_sup->values[i].integer == IPP_CREATE_JOB)
1169 create_job = 1;
1170 else if (operations_sup->values[i].integer == IPP_SEND_DOCUMENT)
1171 send_document = 1;
a29fd7dd
MS		 1172 else if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
1173 get_job_attrs = 1;
dcb445bc
MS		 1174 }
1175
37e7e6e0 1176 if (create_job && !send_document)
dcb445bc
MS		 1177 {
1178 fputs("DEBUG: Printer supports Create-Job but not Send-Document.\n",
1179 stderr);
1180 create_job = 0;
a29fd7dd
MS		 1181
1182 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1183 "cups-ipp-missing-send-document");
dcb445bc 1184 }
0268488e
MS		 1185
1186 if (!validate_job)
eac3a0a0
MS		 1187 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1188 "cups-ipp-missing-validate-job");
0268488e
MS		 1189 }
1190 else
eac3a0a0
MS		 1191 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1192 "cups-ipp-missing-operations-supported");
0268488e 1193
84315f46
MS		 1194 doc_handling_sup = ippFindAttribute(supported,
1195 "multiple-document-handling-supported",
1196 IPP_TAG_KEYWORD);
1197
321d8d57 1198 report_printer_state(supported);
ef416fc2 1199 }
f3c17241
MS		 1200 while (!job_canceled && ipp_status > IPP_OK_CONFLICT);
1201
1202 if (job_canceled)
1203 return (CUPS_BACKEND_OK);
ef416fc2 1204
1205 /*
1206 * See if the printer is accepting jobs and is not stopped; if either
1207 * condition is true and we are printing to a class, requeue the job...
1208 */
1209
1210 if (getenv("CLASS") != NULL)
1211 {
1212 printer_state = ippFindAttribute(supported, "printer-state",
1213 IPP_TAG_ENUM);
1214 printer_accepting = ippFindAttribute(supported, "printer-is-accepting-jobs",
1215 IPP_TAG_BOOLEAN);
1216
1217 if (printer_state == NULL ||
bd7854cb 1218 (printer_state->values[0].integer > IPP_PRINTER_PROCESSING &&
1219 waitprinter) ||
ef416fc2 1220 printer_accepting == NULL ||
1221 !printer_accepting->values[0].boolean)
1222 {
1223 /*
1224 * If the CLASS environment variable is set, the job was submitted
1225 * to a class and not to a specific queue. In this case, we want
1226 * to abort immediately so that the job can be requeued on the next
1227 * available printer in the class.
1228 */
1229
0837b7e8
MS		 1230 _cupsLangPrintFilter(stderr, "INFO",
1231 _("Unable to contact printer, queuing on next "
1232 "printer in class."));
ef416fc2 1233
1234 ippDelete(supported);
1235 httpClose(http);
1236
ef416fc2 1237 /*
1238 * Sleep 5 seconds to keep the job from requeuing too rapidly...
1239 */
1240
1241 sleep(5);
1242
1243 return (CUPS_BACKEND_FAILED);
1244 }
1245 }
1246
1247 /*
1248 * See if the printer supports multiple copies...
1249 */
1250
d09495fa 1251 copies = atoi(argv[4]);
1252
ef416fc2 1253 if (copies_sup || argc < 7)
d09495fa 1254 copies_remaining = 1;
ef416fc2 1255 else
d09495fa 1256 copies_remaining = copies;
ef416fc2 1257
0268488e
MS		 1258 /*
1259 * Prepare remaining printing options...
1260 */
1261
1262 options = NULL;
0268488e
MS		 1263
1264 if (send_options)
1265 {
1266 num_options = cupsParseOptions(argv[5], 0, &options);
1267
1268 if (!cups_version && media_col_sup)
1269 {
1270 /*
1271 * Load the PPD file and generate PWG attribute mapping information...
1272 */
1273
1274 ppd = ppdOpenFile(getenv("PPD"));
f14324a7 1275 pc = _ppdCacheCreateWithPPD(ppd);
0268488e 1276
a469f8a5
MS		 1277 ppdMarkDefaults(ppd);
1278 cupsMarkOptions(ppd, num_options, options);
0268488e
MS		 1279 }
1280 }
1281 else
1282 num_options = 0;
1283
1284 document_format = NULL;
1285
1286 if (format_sup != NULL)
1287 {
1288 for (i = 0; i < format_sup->num_values; i ++)
82cc1f9a
MS		 1289 if (!_cups_strcasecmp(final_content_type,
1290 format_sup->values[i].string.text))
0268488e
MS		 1291 {
1292 document_format = final_content_type;
1293 break;
1294 }
c8fef167 1295
3e7fe0ca 1296 if (!document_format)
c8fef167
MS		 1297 {
1298 for (i = 0; i < format_sup->num_values; i ++)
88f9aafc 1299 if (!_cups_strcasecmp("application/octet-stream",
82cc1f9a 1300 format_sup->values[i].string.text))
c8fef167
MS		 1301 {
1302 document_format = "application/octet-stream";
1303 break;
1304 }
1305 }
0268488e
MS		 1306 }
1307
82cc1f9a
MS		 1308 fprintf(stderr, "DEBUG: final_content_type=\"%s\", document_format=\"%s\"\n",
1309 final_content_type, document_format ? document_format : "(null)");
1310
82f97232
MS		 1311 /*
1312 * If the printer does not support HTTP/1.1 (which IPP requires), copy stdin
1313 * to a temporary file so that we can do a HTTP/1.0 submission...
1314 *
1315 * (I hate compatibility hacks!)
1316 */
1317
1318 if (http->version < HTTP_1_1 && num_files == 0)
1319 {
1320 if ((fd = cupsTempFd(tmpfilename, sizeof(tmpfilename))) < 0)
1321 {
1322 perror("DEBUG: Unable to create temporary file");
1323 return (CUPS_BACKEND_FAILED);
1324 }
1325
1326 _cupsLangPrintFilter(stderr, "INFO", _("Copying print data."));
1327
12f89d24
MS		 1328 if ((compatsize = write(fd, buffer, bytes)) < 0)
1329 {
1330 perror("DEBUG: Unable to write temporary file");
1331 return (CUPS_BACKEND_FAILED);
1332 }
1333
1334 if ((bytes = backendRunLoop(-1, fd, snmp_fd, &(addrlist->addr), 0, 0,
1335 backendNetworkSideCB)) < 0)
1336 return (CUPS_BACKEND_FAILED);
1337
1338 compatsize += bytes;
82f97232
MS		 1339
1340 close(fd);
1341
1342 compatfile = tmpfilename;
1343 files = &compatfile;
1344 num_files = 1;
1345 }
1346 else if (http->version < HTTP_1_1 && num_files == 1)
1347 {
1348 struct stat fileinfo; /* File information */
1349
1350 if (!stat(files[0], &fileinfo))
1351 compatsize = fileinfo.st_size;
1352 }
1353
5a9febac
MS		 1354 /*
1355 * If the printer only claims to support IPP/1.0, or if the user specifically
1356 * included version=1.0 in the URI, then do not try to use Create-Job or
1357 * Send-Document. This is another dreaded compatibility hack, but unfortunately
1358 * there are enough broken printers out there that we need this for now...
1359 */
1360
1361 if (version == 10)
1362 create_job = send_document = 0;
1363
7cf5915e
MS		 1364 /*
1365 * Start monitoring the printer in the background...
1366 */
1367
1368 monitor.uri = uri;
1369 monitor.hostname = hostname;
1370 monitor.user = argv[2];
1371 monitor.resource = resource;
1372 monitor.port = port;
1373 monitor.version = version;
1374 monitor.job_id = 0;
a29fd7dd 1375 monitor.get_job_attrs = get_job_attrs;
7cf5915e
MS		 1376 monitor.encryption = cupsEncryption();
1377 monitor.job_state = IPP_JOB_PENDING;
1378 monitor.printer_state = IPP_PRINTER_IDLE;
1379
dcb445bc
MS		 1380 if (create_job)
1381 {
1382 monitor.job_name = argv[3];
1383 }
1384 else
1385 {
1386 snprintf(print_job_name, sizeof(print_job_name), "%s - %s", argv[1],
1387 argv[3]);
1388 monitor.job_name = print_job_name;
1389 }
1390
7cf5915e
MS		 1391 _cupsThreadCreate((_cups_thread_func_t)monitor_printer, &monitor);
1392
ef416fc2 1393 /*
0268488e 1394 * Validate access to the printer...
ef416fc2 1395 */
1396
22c9029b 1397 while (!job_canceled && validate_job)
ef416fc2 1398 {
dcb445bc
MS		 1399 request = new_request(IPP_VALIDATE_JOB, version, uri, argv[2],
1400 monitor.job_name, num_options, options, compression,
a469f8a5
MS		 1401 copies_sup ? copies : 1, document_format, pc, ppd,
1402 media_col_sup, doc_handling_sup, print_color_mode);
b423cd4c 1403
0268488e 1404 ippDelete(cupsDoRequest(http, request, resource));
ef416fc2 1405
0268488e 1406 ipp_status = cupsLastError();
ef416fc2 1407
22c9029b
MS		 1408 fprintf(stderr, "DEBUG: Validate-Job: %s (%s)\n",
1409 ippErrorString(ipp_status), cupsLastErrorString());
cc754834 1410
22c9029b
MS		 1411 if (job_canceled)
1412 break;
ef416fc2 1413
a469f8a5
MS		 1414 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1415 ipp_status == IPP_STATUS_ERROR_BUSY)
22c9029b 1416 {
f3c17241 1417 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
22c9029b
MS		 1418 sleep(10);
1419 }
a469f8a5
MS		 1420 else if (ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED ||
1421 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1422 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1423 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1424 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
a29fd7dd 1425 goto cleanup;
a469f8a5
MS		 1426 else if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1427 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
22c9029b 1428 {
12f89d24
MS		 1429 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1430 /* WWW-Authenticate field value */
cc754834 1431
12f89d24 1432 if (!strncmp(www_auth, "Negotiate", 9))
22c9029b 1433 auth_info_required = "negotiate";
12f89d24
MS		 1434 else if (www_auth[0])
1435 auth_info_required = "username,password";
ef416fc2 1436
22c9029b 1437 goto cleanup;
0268488e 1438 }
a469f8a5 1439 else if (ipp_status == IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED)
22c9029b 1440 {
eac3a0a0
MS		 1441 /*
1442 * This is all too common...
1443 */
1444
1445 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1446 "cups-ipp-missing-validate-job");
22c9029b
MS		 1447 break;
1448 }
a29fd7dd
MS		 1449 else if (ipp_status < IPP_REDIRECTION_OTHER_SITE ||
1450 ipp_status == IPP_BAD_REQUEST)
0268488e
MS		 1451 break;
1452 }
cc754834 1453
0268488e
MS		 1454 /*
1455 * Then issue the print-job request...
1456 */
cc754834 1457
0268488e 1458 job_id = 0;
7cf5915e 1459
0268488e
MS		 1460 while (!job_canceled && copies_remaining > 0)
1461 {
1462 /*
1463 * Check for side-channel requests...
1464 */
cc754834 1465
0268488e 1466 backendCheckSideChannel(snmp_fd, http->hostaddr);
7cf5915e 1467
0268488e
MS		 1468 /*
1469 * Build the IPP job creation request...
1470 */
d09495fa 1471
0268488e
MS		 1472 if (job_canceled)
1473 break;
ef416fc2 1474
dcb445bc
MS		 1475 request = new_request((num_files > 1 || create_job) ? IPP_CREATE_JOB :
1476 IPP_PRINT_JOB,
1477 version, uri, argv[2], monitor.job_name, num_options,
1478 options, compression, copies_sup ? copies : 1,
a469f8a5
MS		 1479 document_format, pc, ppd, media_col_sup,
1480 doc_handling_sup, print_color_mode);
ef416fc2 1481
ef416fc2 1482 /*
1483 * Do the request...
1484 */
1485
dcb445bc 1486 if (num_files > 1 || create_job)
bd7854cb 1487 response = cupsDoRequest(http, request, resource);
ef416fc2 1488 else
cc754834 1489 {
82f97232
MS		 1490 size_t length = 0; /* Length of request */
1491
1492 if (compatsize > 0)
1493 {
1494 fputs("DEBUG: Sending file using HTTP/1.0 Content-Length...\n", stderr);
1495 length = ippLength(request) + (size_t)compatsize;
1496 }
1497 else
1498 fputs("DEBUG: Sending file using HTTP/1.1 chunking...\n", stderr);
1499
1500 http_status = cupsSendRequest(http, request, resource, length);
cc754834
MS		 1501 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1502 {
c41769ff
MS		 1503 if (compression && strcmp(compression, "none"))
1504 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1505
cc754834 1506 if (num_files == 1)
dcb445bc
MS		 1507 {
1508 if ((fd = open(files[0], O_RDONLY)) < 0)
1509 {
1510 _cupsLangPrintError("ERROR", _("Unable to open print file"));
1511 return (CUPS_BACKEND_FAILED);
1512 }
1513 }
cc754834 1514 else
eac3a0a0
MS		 1515 {
1516 fd = 0;
1517 http_status = cupsWriteRequestData(http, buffer, bytes);
1518 }
cc754834 1519
83e08001
MS		 1520 while (http_status == HTTP_CONTINUE &&
1521 (!job_canceled || compatsize > 0))
cc754834 1522 {
eac3a0a0
MS		 1523 /*
1524 * Check for side-channel requests and more print data...
1525 */
cc754834 1526
eac3a0a0
MS		 1527 FD_ZERO(&input);
1528 FD_SET(fd, &input);
1529 FD_SET(snmp_fd, &input);
cc754834 1530
eac3a0a0
MS		 1531 while (select(fd > snmp_fd ? fd + 1 : snmp_fd + 1, &input, NULL, NULL,
1532 NULL) <= 0 && !job_canceled);
1533
1534 if (FD_ISSET(snmp_fd, &input))
cc754834 1535 backendCheckSideChannel(snmp_fd, http->hostaddr);
eac3a0a0
MS		 1536
1537 if (FD_ISSET(fd, &input))
1538 {
1539 if ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
1540 {
1541 fprintf(stderr, "DEBUG: Read %d bytes...\n", (int)bytes);
1542
c41769ff
MS		 1543 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1544 != HTTP_CONTINUE)
eac3a0a0
MS		 1545 break;
1546 }
1547 else if (bytes == 0 || (errno != EINTR && errno != EAGAIN))
1548 break;
cc754834
MS		 1549 }
1550 }
1551
c41769ff
MS		 1552 if (http_status == HTTP_ERROR)
1553 fprintf(stderr, "DEBUG: Error writing document data for "
1554 "Print-Job: %s\n", strerror(httpError(http)));
1555
cc754834
MS		 1556 if (num_files == 1)
1557 close(fd);
1558 }
1559
1560 response = cupsGetResponse(http, resource);
1561 ippDelete(request);
1562 }
bd7854cb 1563
1564 ipp_status = cupsLastError();
ef416fc2 1565
22c9029b 1566 fprintf(stderr, "DEBUG: %s: %s (%s)\n",
dcb445bc 1567 (num_files > 1 || create_job) ? "Create-Job" : "Print-Job",
22c9029b
MS		 1568 ippErrorString(ipp_status), cupsLastErrorString());
1569
ef416fc2 1570 if (ipp_status > IPP_OK_CONFLICT)
1571 {
1572 job_id = 0;
1573
cc754834 1574 if (job_canceled)
bd7854cb 1575 break;
1576
a469f8a5
MS		 1577 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1578 ipp_status == IPP_STATUS_ERROR_NOT_POSSIBLE ||
1579 ipp_status == IPP_STATUS_ERROR_BUSY)
ef416fc2 1580 {
f3c17241 1581 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
ef416fc2 1582 sleep(10);
22c9029b
MS		 1583
1584 if (num_files == 0)
1585 {
1586 /*
1587 * We can't re-submit when we have no files to print, so exit
1588 * immediately with the right status code...
1589 */
1590
1591 goto cleanup;
1592 }
ef416fc2 1593 }
a469f8a5
MS		 1594 else if (ipp_status == IPP_STATUS_ERROR_JOB_CANCELED ||
1595 ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED ||
1596 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1597 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1598 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1599 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
771bd8cb 1600 goto cleanup;
ef416fc2 1601 else
68b10830
MS		 1602 {
1603 /*
1604 * Update auth-info-required as needed...
1605 */
1606
0837b7e8 1607 _cupsLangPrintFilter(stderr, "ERROR",
a469f8a5 1608 _("Print job was not accepted."));
68b10830 1609
a469f8a5
MS		 1610 if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1611 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
68b10830 1612 {
12f89d24
MS		 1613 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1614 /* WWW-Authenticate field value */
3e7fe0ca 1615
12f89d24
MS		 1616 if (!strncmp(www_auth, "Negotiate", 9))
1617 auth_info_required = "negotiate";
1618 else if (www_auth[0])
1619 auth_info_required = "username,password";
1620 }
1621 else if (ipp_status == IPP_REQUEST_VALUE)
1622 {
1623 /*
1624 * Print file is too large, abort this job...
18ecb428
MS		 1625 */
1626
12f89d24 1627 goto cleanup;
68b10830 1628 }
22c9029b
MS		 1629 else
1630 sleep(10);
1631
1632 if (num_files == 0)
1633 {
1634 /*
1635 * We can't re-submit when we have no files to print, so exit
1636 * immediately with the right status code...
1637 */
1638
1639 goto cleanup;
1640 }
68b10830 1641 }
ef416fc2 1642 }
1643 else if ((job_id_attr = ippFindAttribute(response, "job-id",
1644 IPP_TAG_INTEGER)) == NULL)
1645 {
a469f8a5 1646 fputs("DEBUG: Print job accepted - job ID unknown.\n", stderr);
eac3a0a0
MS		 1647 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1648 "cups-ipp-missing-job-id");
ef416fc2 1649 job_id = 0;
1650 }
1651 else
1652 {
3e7fe0ca 1653 password_tries = 0;
7cf5915e 1654 monitor.job_id = job_id = job_id_attr->values[0].integer;
a469f8a5 1655 fprintf(stderr, "DEBUG: Print job accepted - job ID %d.\n", job_id);
ef416fc2 1656 }
1657
bd7854cb 1658 ippDelete(response);
1659
cc754834 1660 if (job_canceled)
bd7854cb 1661 break;
1662
dcb445bc 1663 if (job_id && (num_files > 1 || create_job))
bd7854cb 1664 {
dcb445bc 1665 for (i = 0; num_files == 0 || i < num_files; i ++)
bd7854cb 1666 {
7a14d768
MS		 1667 /*
1668 * Check for side-channel requests...
1669 */
1670
1671 backendCheckSideChannel(snmp_fd, http->hostaddr);
1672
1673 /*
1674 * Send the next file in the job...
1675 */
1676
bd7854cb 1677 request = ippNewRequest(IPP_SEND_DOCUMENT);
c168a833
MS		 1678 request->request.op.version[0] = version / 10;
1679 request->request.op.version[1] = version % 10;
bd7854cb 1680
1681 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1682 NULL, uri);
1683
1684 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1685 job_id);
1686
1687 if (argv[2][0])
1688 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1689 "requesting-user-name", NULL, argv[2]);
1690
dcb445bc 1691 if ((i + 1) >= num_files)
bd7854cb 1692 ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
1693
82cc1f9a
MS		 1694 if (document_format)
1695 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1696 "document-format", NULL, document_format);
bd7854cb 1697
5a9febac
MS		 1698 if (compression)
1699 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1700 "compression", NULL, compression);
1701
cc754834
MS		 1702 fprintf(stderr, "DEBUG: Sending file %d using chunking...\n", i + 1);
1703 http_status = cupsSendRequest(http, request, resource, 0);
dcb445bc
MS		 1704 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1705 {
a469f8a5
MS		 1706 if (compression && strcmp(compression, "none"))
1707 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1708
dcb445bc
MS		 1709 if (num_files == 0)
1710 {
1711 fd = 0;
1712 http_status = cupsWriteRequestData(http, buffer, bytes);
1713 }
1714 else
1715 {
1716 if ((fd = open(files[i], O_RDONLY)) < 0)
1717 {
1718 _cupsLangPrintError("ERROR", _("Unable to open print file"));
1719 return (CUPS_BACKEND_FAILED);
1720 }
1721 }
1722 }
1723 else
1724 fd = -1;
1725
1726 if (fd >= 0)
cc754834 1727 {
82cc1f9a 1728 while (!job_canceled && http_status == HTTP_CONTINUE &&
83e08001 1729 (bytes = read(fd, buffer, sizeof(buffer))) > 0)
cc754834 1730 {
82cc1f9a
MS		 1731 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1732 != HTTP_CONTINUE)
cc754834
MS		 1733 break;
1734 else
1735 {
1736 /*
1737 * Check for side-channel requests...
1738 */
1739
1740 backendCheckSideChannel(snmp_fd, http->hostaddr);
1741 }
1742 }
1743
dcb445bc
MS		 1744 if (fd > 0)
1745 close(fd);
cc754834 1746 }
97c9a8d7 1747
c41769ff
MS		 1748 if (http_status == HTTP_ERROR)
1749 fprintf(stderr, "DEBUG: Error writing document data for "
1750 "Send-Document: %s\n", strerror(httpError(http)));
1751
cc754834
MS		 1752 ippDelete(cupsGetResponse(http, resource));
1753 ippDelete(request);
bd7854cb 1754
22c9029b
MS		 1755 fprintf(stderr, "DEBUG: Send-Document: %s (%s)\n",
1756 ippErrorString(cupsLastError()), cupsLastErrorString());
1757
bd7854cb 1758 if (cupsLastError() > IPP_OK_CONFLICT)
1759 {
1760 ipp_status = cupsLastError();
1761
0837b7e8 1762 _cupsLangPrintFilter(stderr, "ERROR",
22c9029b 1763 _("Unable to add document to print job."));
bd7854cb 1764 break;
1765 }
3e7fe0ca
MS		 1766 else
1767 {
1768 password_tries = 0;
1769
1770 if (num_files == 0 || fd < 0)
1771 break;
1772 }
bd7854cb 1773 }
1774 }
ef416fc2 1775
1776 if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
1777 {
1778 fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
d09495fa 1779 copies_remaining --;
ef416fc2 1780 }
1781 else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
a2326b5b 1782 ipp_status == IPP_NOT_POSSIBLE ||
ef416fc2 1783 ipp_status == IPP_PRINTER_BUSY)
a469f8a5
MS		 1784 {
1785 if (argc == 6)
1786 {
1787 /*
1788 * Need to reprocess the entire job; if we have a job ID, cancel the
1789 * job first...
1790 */
1791
1792 if (job_id > 0)
1793 cancel_job(http, uri, job_id, resource, argv[2], version);
1794
1795 goto cleanup;
1796 }
1f6f3dbc 1797 continue;
a469f8a5 1798 }
5a9febac
MS		 1799 else if (ipp_status == IPP_REQUEST_VALUE ||
1800 ipp_status == IPP_ERROR_JOB_CANCELED ||
1801 ipp_status == IPP_NOT_AUTHORIZED ||
a469f8a5
MS		 1802 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1803 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1804 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1805 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED ||
5a9febac
MS		 1806 ipp_status == IPP_INTERNAL_ERROR)
1807 {
1808 /*
1809 * Print file is too large, job was canceled, we need new
1810 * authentication data, or we had some sort of error...
1811 */
1812
1813 goto cleanup;
1814 }
1815 else if (ipp_status == IPP_NOT_FOUND)
12f89d24
MS		 1816 {
1817 /*
5a9febac
MS		 1818 * Printer does not actually implement support for Create-Job/
1819 * Send-Document, so log the conformance issue and stop the printer.
12f89d24
MS		 1820 */
1821
5a9febac
MS		 1822 fputs("DEBUG: This printer claims to support Create-Job and "
1823 "Send-Document, but those operations failed.\n", stderr);
1824 fputs("DEBUG: Add '?version=1.0' to the device URI to use legacy "
1825 "compatibility mode.\n", stderr);
1826 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1827 "cups-ipp-missing-send-document");
1828
1829 ipp_status = IPP_INTERNAL_ERROR; /* Force queue to stop */
1830
12f89d24
MS		 1831 goto cleanup;
1832 }
ef416fc2 1833 else
d09495fa 1834 copies_remaining --;
ef416fc2 1835
1836 /*
1837 * Wait for the job to complete...
1838 */
1839
a29fd7dd 1840 if (!job_id || !waitjob || !get_job_attrs)
ef416fc2 1841 continue;
1842
0837b7e8 1843 _cupsLangPrintFilter(stderr, "INFO", _("Waiting for job to complete."));
ef416fc2 1844
f14324a7 1845 for (delay = _cupsNextDelay(0, &prev_delay); !job_canceled;)
ef416fc2 1846 {
7a14d768
MS		 1847 /*
1848 * Check for side-channel requests...
1849 */
1850
1851 backendCheckSideChannel(snmp_fd, http->hostaddr);
1852
ef416fc2 1853 /*
1854 * Build an IPP_GET_JOB_ATTRIBUTES request...
1855 */
1856
fa73b229 1857 request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
c168a833
MS		 1858 request->request.op.version[0] = version / 10;
1859 request->request.op.version[1] = version % 10;
ef416fc2 1860
1861 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1862 NULL, uri);
1863
1864 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1865 job_id);
1866
1867 if (argv[2][0])
1868 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1869 "requesting-user-name", NULL, argv[2]);
1870
1871 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1872 "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
1873 NULL, jattrs);
1874
1875 /*
1876 * Do the request...
1877 */
1878
f14324a7 1879 httpReconnect(http);
bd7854cb 1880 response = cupsDoRequest(http, request, resource);
1881 ipp_status = cupsLastError();
ef416fc2 1882
a29fd7dd 1883 if (ipp_status == IPP_NOT_FOUND || ipp_status == IPP_NOT_POSSIBLE)
ef416fc2 1884 {
1885 /*
1886 * Job has gone away and/or the server has no job history...
1887 */
1888
eac3a0a0
MS		 1889 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1890 "cups-ipp-missing-job-history");
ef416fc2 1891 ippDelete(response);
1892
1893 ipp_status = IPP_OK;
1894 break;
1895 }
1896
22c9029b
MS		 1897 fprintf(stderr, "DEBUG: Get-Job-Attributes: %s (%s)\n",
1898 ippErrorString(ipp_status), cupsLastErrorString());
1899
3e7fe0ca
MS		 1900 if (ipp_status <= IPP_OK_CONFLICT)
1901 password_tries = 0;
1902 else
ef416fc2 1903 {
1904 if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
1905 ipp_status != IPP_PRINTER_BUSY)
1906 {
bd7854cb 1907 ippDelete(response);
12f89d24 1908 ipp_status = IPP_OK;
ef416fc2 1909 break;
1910 }
a469f8a5
MS		 1911 else if (ipp_status == IPP_INTERNAL_ERROR)
1912 {
1913 waitjob_tries ++;
1914
1915 if (waitjob_tries > 4)
1916 {
1917 ippDelete(response);
1918 ipp_status = IPP_OK;
1919 break;
1920 }
1921 }
ef416fc2 1922 }
1923
bd7854cb 1924 if (response)
ef416fc2 1925 {
1926 if ((job_state = ippFindAttribute(response, "job-state",
1927 IPP_TAG_ENUM)) != NULL)
1928 {
07ed0e9a
MS		 1929 /*
1930 * Reflect the remote job state in the local queue...
1931 */
1932
eac3a0a0
MS		 1933 if (cups_version &&
1934 job_state->values[0].integer >= IPP_JOB_PENDING &&
07ed0e9a 1935 job_state->values[0].integer <= IPP_JOB_COMPLETED)
eac3a0a0
MS		 1936 update_reasons(NULL,
1937 remote_job_states[job_state->values[0].integer -
1938 IPP_JOB_PENDING]);
1939
1940 if ((job_sheets = ippFindAttribute(response,
1941 "job-media-sheets-completed",
1942 IPP_TAG_INTEGER)) == NULL)
1943 job_sheets = ippFindAttribute(response,
1944 "job-impressions-completed",
1945 IPP_TAG_INTEGER);
1946
1947 if (job_sheets)
1948 fprintf(stderr, "PAGE: total %d\n",
1949 job_sheets->values[0].integer);
07ed0e9a 1950
ef416fc2 1951 /*
1952 * Stop polling if the job is finished or pending-held...
1953 */
1954
b94498cf 1955 if (job_state->values[0].integer > IPP_JOB_STOPPED)
ef416fc2 1956 {
ef416fc2 1957 ippDelete(response);
1958 break;
1959 }
1960 }
a2326b5b
MS		 1961 else if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
1962 ipp_status != IPP_NOT_POSSIBLE &&
1963 ipp_status != IPP_PRINTER_BUSY)
7a0cbd5e
MS		 1964 {
1965 /*
1966 * If the printer does not return a job-state attribute, it does not
1967 * conform to the IPP specification - break out immediately and fail
1968 * the job...
1969 */
1970
eac3a0a0
MS		 1971 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1972 "cups-ipp-missing-job-state");
7a0cbd5e
MS		 1973 ipp_status = IPP_INTERNAL_ERROR;
1974 break;
1975 }
ef416fc2 1976 }
1977
bd7854cb 1978 ippDelete(response);
ef416fc2 1979
1980 /*
f14324a7 1981 * Wait before polling again...
ef416fc2 1982 */
1983
2e4ff8af
MS		 1984 sleep(delay);
1985
f14324a7 1986 delay = _cupsNextDelay(delay, &prev_delay);
ef416fc2 1987 }
1988 }
1989
1990 /*
bd7854cb 1991 * Cancel the job as needed...
ef416fc2 1992 */
1993
f3c17241 1994 if (job_canceled > 0 && job_id > 0)
bd7854cb 1995 cancel_job(http, uri, job_id, resource, argv[2], version);
1996
1997 /*
1998 * Check the printer state and report it if necessary...
1999 */
ef416fc2 2000
321d8d57 2001 check_printer_state(http, uri, resource, argv[2], version);
ef416fc2 2002
7a14d768
MS		 2003 /*
2004 * Collect the final page count as needed...
2005 */
2006
c8fef167 2007 if (have_supplies &&
7a14d768
MS		 2008 !backendSNMPSupplies(snmp_fd, http->hostaddr, &page_count, NULL) &&
2009 page_count > start_count)
2010 fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
2011
18ecb428
MS		 2012#ifdef HAVE_GSSAPI
2013 /*
2014 * See if we used Kerberos at all...
2015 */
2016
2017 if (http->gssctx)
2018 auth_info_required = "negotiate";
2019#endif /* HAVE_GSSAPI */
2020
ef416fc2 2021 /*
2022 * Free memory...
2023 */
2024
0268488e
MS		 2025 cleanup:
2026
2027 cupsFreeOptions(num_options, options);
f14324a7 2028 _ppdCacheDestroy(pc);
a469f8a5 2029 ppdClose(ppd);
0268488e 2030
ef416fc2 2031 httpClose(http);
2032
bd7854cb 2033 ippDelete(supported);
ef416fc2 2034
2035 /*
2036 * Remove the temporary file(s) if necessary...
2037 */
2038
82f97232
MS		 2039 if (tmpfilename[0])
2040 unlink(tmpfilename);
2041
ef416fc2 2042 /*
2043 * Return the queue status...
2044 */
2045
f14324a7 2046 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
82f97232 2047 ipp_status == IPP_AUTHENTICATION_CANCELED ||
f14324a7
MS		 2048 ipp_status <= IPP_OK_CONFLICT)
2049 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
18ecb428 2050
a469f8a5
MS		 2051 if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED)
2052 fputs("JOBSTATE: account-info-needed\n", stderr);
2053 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED)
2054 fputs("JOBSTATE: account-closed\n", stderr);
2055 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED)
2056 fputs("JOBSTATE: account-limit-reached\n", stderr);
2057 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
2058 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2059
82f97232 2060 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
a469f8a5
MS		 2061 ipp_status == IPP_AUTHENTICATION_CANCELED ||
2062 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
2063 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
2064 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
2065 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
7ff4fea9 2066 return (CUPS_BACKEND_AUTH_REQUIRED);
7a0cbd5e
MS		 2067 else if (ipp_status == IPP_INTERNAL_ERROR)
2068 return (CUPS_BACKEND_STOP);
a29fd7dd 2069 else if (ipp_status == IPP_CONFLICT)
7ff4fea9 2070 return (CUPS_BACKEND_FAILED);
a29fd7dd
MS		 2071 else if (ipp_status == IPP_REQUEST_VALUE ||
2072 ipp_status == IPP_DOCUMENT_FORMAT || job_canceled < 0)
12f89d24 2073 {
f3c17241
MS		 2074 if (ipp_status == IPP_REQUEST_VALUE)
2075 _cupsLangPrintFilter(stderr, "ERROR", _("Print job too large."));
a29fd7dd
MS		 2076 else if (ipp_status == IPP_DOCUMENT_FORMAT)
2077 _cupsLangPrintFilter(stderr, "ERROR",
2078 _("Printer cannot print supplied content."));
f3c17241
MS		 2079 else
2080 _cupsLangPrintFilter(stderr, "ERROR", _("Print job canceled at printer."));
2081
12f89d24
MS		 2082 return (CUPS_BACKEND_CANCEL);
2083 }
771bd8cb 2084 else if (ipp_status > IPP_OK_CONFLICT && ipp_status != IPP_ERROR_JOB_CANCELED)
22c9029b 2085 return (CUPS_BACKEND_RETRY_CURRENT);
7ff4fea9
MS		 2086 else
2087 return (CUPS_BACKEND_OK);
ef416fc2 2088}
2089
2090
bd7854cb 2091/*
2092 * 'cancel_job()' - Cancel a print job.
2093 */
2094
2095static void
2096cancel_job(http_t *http, /* I - HTTP connection */
2097 const char *uri, /* I - printer-uri */
2098 int id, /* I - job-id */
2099 const char *resource, /* I - Resource path */
2100 const char *user, /* I - requesting-user-name */
2101 int version) /* I - IPP version */
2102{
2103 ipp_t *request; /* Cancel-Job request */
2104
2105
0837b7e8 2106 _cupsLangPrintFilter(stderr, "INFO", _("Canceling print job."));
bd7854cb 2107
2108 request = ippNewRequest(IPP_CANCEL_JOB);
c168a833
MS		 2109 request->request.op.version[0] = version / 10;
2110 request->request.op.version[1] = version % 10;
bd7854cb 2111
2112 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2113 NULL, uri);
2114 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", id);
2115
2116 if (user && user[0])
2117 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2118 "requesting-user-name", NULL, user);
2119
2120 /*
2121 * Do the request...
2122 */
2123
2124 ippDelete(cupsDoRequest(http, request, resource));
2125
2126 if (cupsLastError() > IPP_OK_CONFLICT)
22c9029b 2127 _cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
bd7854cb 2128}
2129
2130
ef416fc2 2131/*
7cf5915e 2132 * 'check_printer_state()' - Check the printer state.
ef416fc2 2133 */
2134
7cf5915e 2135static ipp_pstate_t /* O - Current printer-state */
fa73b229 2136check_printer_state(
2137 http_t *http, /* I - HTTP connection */
2138 const char *uri, /* I - Printer URI */
2139 const char *resource, /* I - Resource path */
2140 const char *user, /* I - Username, if any */
321d8d57
MS		 2141 int version) /* I - IPP version */
2142 {
7cf5915e
MS		 2143 ipp_t *request, /* IPP request */
2144 *response; /* IPP response */
2145 ipp_attribute_t *attr; /* Attribute in response */
2146 ipp_pstate_t printer_state = IPP_PRINTER_STOPPED;
2147 /* Current printer-state */
ef416fc2 2148
2149
2150 /*
7cf5915e 2151 * Send a Get-Printer-Attributes request and log the results...
ef416fc2 2152 */
2153
fa73b229 2154 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
c168a833
MS		 2155 request->request.op.version[0] = version / 10;
2156 request->request.op.version[1] = version % 10;
ef416fc2 2157
2158 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
7cf5915e 2159 NULL, uri);
ef416fc2 2160
2161 if (user && user[0])
2162 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
7cf5915e 2163 "requesting-user-name", NULL, user);
ef416fc2 2164
323c5de1 2165 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
7cf5915e
MS		 2166 "requested-attributes",
2167 (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
ef416fc2 2168
2169 if ((response = cupsDoRequest(http, request, resource)) != NULL)
2170 {
321d8d57 2171 report_printer_state(response);
7cf5915e
MS		 2172
2173 if ((attr = ippFindAttribute(response, "printer-state",
2174 IPP_TAG_ENUM)) != NULL)
2175 printer_state = (ipp_pstate_t)attr->values[0].integer;
2176
ef416fc2 2177 ippDelete(response);
2178 }
7cf5915e 2179
22c9029b
MS		 2180 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
2181 ippErrorString(cupsLastError()), cupsLastErrorString());
2182
3e7fe0ca
MS		 2183 if (cupsLastError() <= IPP_OK_CONFLICT)
2184 password_tries = 0;
2185
7cf5915e
MS		 2186 /*
2187 * Return the printer-state value...
2188 */
2189
2190 return (printer_state);
ef416fc2 2191}
2192
2193
7cf5915e 2194/*
eac3a0a0 2195 * 'monitor_printer()' - Monitor the printer state.
7cf5915e
MS		 2196 */
2197
2198static void * /* O - Thread exit code */
2199monitor_printer(
2200 _cups_monitor_t *monitor) /* I - Monitoring data */
2201{
2202 http_t *http; /* Connection to printer */
2203 ipp_t *request, /* IPP request */
2204 *response; /* IPP response */
2205 ipp_attribute_t *attr; /* Attribute in response */
2206 int delay, /* Current delay */
f14324a7 2207 prev_delay; /* Previous delay */
dcb445bc
MS		 2208 ipp_op_t job_op; /* Operation to use */
2209 int job_id; /* Job ID */
2210 const char *job_name; /* Job name */
2211 ipp_jstate_t job_state; /* Job state */
2212 const char *job_user; /* Job originating user name */
7cf5915e
MS		 2213
2214
2215 /*
2216 * Make a copy of the printer connection...
2217 */
2218
a469f8a5
MS		 2219 http = _httpCreate(monitor->hostname, monitor->port, NULL, AF_UNSPEC,
2220 monitor->encryption, 1, _HTTP_MODE_CLIENT);
f228370c 2221 httpSetTimeout(http, 30.0, timeout_cb, NULL);
3e7fe0ca
MS		 2222 if (username[0])
2223 cupsSetUser(username);
5a9febac 2224 cupsSetPasswordCB2(password_cb, NULL);
7cf5915e
MS		 2225
2226 /*
2227 * Loop until the job is canceled, aborted, or completed.
2228 */
2229
f14324a7 2230 delay = _cupsNextDelay(0, &prev_delay);
7cf5915e 2231
a469f8a5
MS		 2232 monitor->job_reasons = 0;
2233
7cf5915e
MS		 2234 while (monitor->job_state < IPP_JOB_CANCELED && !job_canceled)
2235 {
2236 /*
2237 * Reconnect to the printer...
2238 */
2239
2240 if (!httpReconnect(http))
2241 {
2242 /*
2243 * Connected, so check on the printer state...
2244 */
2245
2246 monitor->printer_state = check_printer_state(http, monitor->uri,
2247 monitor->resource,
2248 monitor->user,
321d8d57 2249 monitor->version);
7cf5915e 2250
dcb445bc
MS		 2251 /*
2252 * Check the status of the job itself...
2253 */
7cf5915e 2254
a29fd7dd
MS		 2255 job_op = (monitor->job_id > 0 && monitor->get_job_attrs) ?
2256 IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS;
dcb445bc
MS		 2257 request = ippNewRequest(job_op);
2258 request->request.op.version[0] = monitor->version / 10;
2259 request->request.op.version[1] = monitor->version % 10;
7cf5915e 2260
dcb445bc
MS		 2261 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2262 NULL, monitor->uri);
2263 if (job_op == IPP_GET_JOB_ATTRIBUTES)
7cf5915e 2264 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
dcb445bc 2265 monitor->job_id);
7cf5915e 2266
dcb445bc
MS		 2267 if (monitor->user && monitor->user[0])
2268 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2269 "requesting-user-name", NULL, monitor->user);
7cf5915e 2270
dcb445bc
MS		 2271 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2272 "requested-attributes",
2273 (int)(sizeof(jattrs) / sizeof(jattrs[0])), NULL, jattrs);
7cf5915e 2274
dcb445bc
MS		 2275 /*
2276 * Do the request...
2277 */
7cf5915e 2278
dcb445bc 2279 response = cupsDoRequest(http, request, monitor->resource);
7cf5915e 2280
f3c17241 2281 fprintf(stderr, "DEBUG: (monitor) %s: %s (%s)\n", ippOpString(job_op),
dcb445bc 2282 ippErrorString(cupsLastError()), cupsLastErrorString());
22c9029b 2283
3e7fe0ca
MS		 2284 if (cupsLastError() <= IPP_OK_CONFLICT)
2285 password_tries = 0;
2286
dcb445bc
MS		 2287 if (job_op == IPP_GET_JOB_ATTRIBUTES)
2288 {
7cf5915e
MS		 2289 if ((attr = ippFindAttribute(response, "job-state",
2290 IPP_TAG_ENUM)) != NULL)
2291 monitor->job_state = (ipp_jstate_t)attr->values[0].integer;
2292 else
2293 monitor->job_state = IPP_JOB_COMPLETED;
dcb445bc 2294 }
12f89d24 2295 else if (response)
dcb445bc
MS		 2296 {
2297 for (attr = response->attrs; attr; attr = attr->next)
2298 {
2299 job_id = 0;
2300 job_name = NULL;
2301 job_state = IPP_JOB_PENDING;
2302 job_user = NULL;
2303
2304 while (attr && attr->group_tag != IPP_TAG_JOB)
2305 attr = attr->next;
7cf5915e 2306
dcb445bc
MS		 2307 if (!attr)
2308 break;
2309
2310 while (attr && attr->group_tag == IPP_TAG_JOB)
2311 {
2312 if (!strcmp(attr->name, "job-id") &&
2313 attr->value_tag == IPP_TAG_INTEGER)
2314 job_id = attr->values[0].integer;
2315 else if (!strcmp(attr->name, "job-name") &&
2316 (attr->value_tag == IPP_TAG_NAME ||
2317 attr->value_tag == IPP_TAG_NAMELANG))
2318 job_name = attr->values[0].string.text;
2319 else if (!strcmp(attr->name, "job-state") &&
2320 attr->value_tag == IPP_TAG_ENUM)
2321 job_state = attr->values[0].integer;
2322 else if (!strcmp(attr->name, "job-originating-user-name") &&
2323 (attr->value_tag == IPP_TAG_NAME ||
2324 attr->value_tag == IPP_TAG_NAMELANG))
2325 job_user = attr->values[0].string.text;
2326
2327 attr = attr->next;
2328 }
2329
2330 if (job_id > 0 && job_name && !strcmp(job_name, monitor->job_name) &&
2331 job_user && monitor->user && !strcmp(job_user, monitor->user))
2332 {
2333 monitor->job_id = job_id;
2334 monitor->job_state = job_state;
2335 break;
2336 }
2337
2338 if (!attr)
2339 break;
2340 }
7cf5915e
MS		 2341 }
2342
a469f8a5
MS		 2343 if ((attr = ippFindAttribute(response, "job-state-reasons",
2344 IPP_TAG_KEYWORD)) != NULL)
2345 {
2346 int i, new_reasons = 0; /* Looping var, new reasons */
2347
2348 for (i = 0; i < attr->num_values; i ++)
2349 {
2350 if (!strcmp(attr->values[i].string.text,
2351 "account-authorization-failed"))
2352 new_reasons |= _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED;
2353 else if (!strcmp(attr->values[i].string.text, "account-closed"))
2354 new_reasons |= _CUPS_JSR_ACCOUNT_CLOSED;
2355 else if (!strcmp(attr->values[i].string.text, "account-info-needed"))
2356 new_reasons |= _CUPS_JSR_ACCOUNT_INFO_NEEDED;
2357 else if (!strcmp(attr->values[i].string.text,
2358 "account-limit-reached"))
2359 new_reasons |= _CUPS_JSR_ACCOUNT_LIMIT_REACHED;
2360 else if (!strcmp(attr->values[i].string.text, "job-password-wait"))
2361 new_reasons |= _CUPS_JSR_JOB_PASSWORD_WAIT;
2362 else if (!strcmp(attr->values[i].string.text, "job-release-wait"))
2363 new_reasons |= _CUPS_JSR_JOB_RELEASE_WAIT;
2364 }
2365
2366 if (new_reasons != monitor->job_reasons)
2367 {
2368 if (new_reasons & _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED)
2369 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2370 else if (new_reasons & _CUPS_JSR_ACCOUNT_CLOSED)
2371 fputs("JOBSTATE: account-closed\n", stderr);
2372 else if (new_reasons & _CUPS_JSR_ACCOUNT_INFO_NEEDED)
2373 fputs("JOBSTATE: account-info-needed\n", stderr);
2374 else if (new_reasons & _CUPS_JSR_ACCOUNT_LIMIT_REACHED)
2375 fputs("JOBSTATE: account-limit-reached\n", stderr);
2376 else if (new_reasons & _CUPS_JSR_JOB_PASSWORD_WAIT)
2377 fputs("JOBSTATE: job-password-wait\n", stderr);
2378 else if (new_reasons & _CUPS_JSR_JOB_RELEASE_WAIT)
2379 fputs("JOBSTATE: job-release-wait\n", stderr);
2380 else
2381 fputs("JOBSTATE: job-printing\n", stderr);
2382
2383 monitor->job_reasons = new_reasons;
2384 }
2385 }
2386
dcb445bc
MS		 2387 ippDelete(response);
2388
f3c17241
MS		 2389 fprintf(stderr, "DEBUG: (monitor) job-state=%s\n",
2390 ippEnumString("job-state", monitor->job_state));
2391
2392 if (!job_canceled &&
2393 (monitor->job_state == IPP_JOB_CANCELED ||
2394 monitor->job_state == IPP_JOB_ABORTED))
2395 job_canceled = -1;
2396
7cf5915e
MS		 2397 /*
2398 * Disconnect from the printer - we'll reconnect on the next poll...
2399 */
2400
2401 _httpDisconnect(http);
2402 }
2403
2404 /*
f14324a7 2405 * Sleep for N seconds...
7cf5915e
MS		 2406 */
2407
2408 sleep(delay);
2409
f14324a7 2410 delay = _cupsNextDelay(delay, &prev_delay);
7cf5915e
MS		 2411 }
2412
dcb445bc
MS		 2413 /*
2414 * Cancel the job if necessary...
2415 */
2416
f3c17241 2417 if (job_canceled > 0 && monitor->job_id > 0)
dcb445bc
MS		 2418 if (!httpReconnect(http))
2419 cancel_job(http, monitor->uri, monitor->job_id, monitor->resource,
2420 monitor->user, monitor->version);
2421
7cf5915e
MS		 2422 /*
2423 * Cleanup and return...
2424 */
2425
2426 httpClose(http);
2427
2428 return (NULL);
2429}
2430
2431
0268488e
MS		 2432/*
2433 * 'new_request()' - Create a new print creation or validation request.
2434 */
2435
2436static ipp_t * /* O - Request data */
2437new_request(
2438 ipp_op_t op, /* I - IPP operation code */
2439 int version, /* I - IPP version number */
2440 const char *uri, /* I - printer-uri value */
2441 const char *user, /* I - requesting-user-name value */
2442 const char *title, /* I - job-name value */
2443 int num_options, /* I - Number of options to send */
2444 cups_option_t *options, /* I - Options to send */
2445 const char *compression, /* I - compression value or NULL */
c8fef167 2446 int copies, /* I - copies value or 0 */
dcb445bc 2447 const char *format, /* I - document-format value or NULL */
f14324a7 2448 _ppd_cache_t *pc, /* I - PPD cache and mapping data */
a469f8a5 2449 ppd_file_t *ppd, /* I - PPD file data */
84315f46 2450 ipp_attribute_t *media_col_sup, /* I - media-col-supported values */
a469f8a5
MS		 2451 ipp_attribute_t *doc_handling_sup, /* I - multiple-document-handling-supported values */
2452 int print_color_mode) /* I - Printer supports print-color-mode */
0268488e
MS		 2453{
2454 int i; /* Looping var */
2455 ipp_t *request; /* Request data */
2456 const char *keyword; /* PWG keyword */
2457 _pwg_size_t *size; /* PWG media size */
2458 ipp_t *media_col, /* media-col value */
2459 *media_size; /* media-size value */
2460 const char *media_source, /* media-source value */
84315f46 2461 *media_type, /* media-type value */
5a9febac
MS		 2462 *collate_str, /* multiple-document-handling value */
2463 *mandatory; /* Mandatory attributes */
a469f8a5
MS		 2464 ipp_tag_t group; /* Current group */
2465 ipp_attribute_t *attr; /* Current attribute */
2466 const char *color_attr_name; /* Supported color attribute */
2467 char buffer[1024]; /* Value buffer */
0268488e
MS		 2468
2469
2470 /*
2471 * Create the IPP request...
2472 */
2473
2474 request = ippNewRequest(op);
2475 request->request.op.version[0] = version / 10;
2476 request->request.op.version[1] = version % 10;
2477
2478 fprintf(stderr, "DEBUG: %s IPP/%d.%d\n",
2479 ippOpString(request->request.op.operation_id),
2480 request->request.op.version[0],
2481 request->request.op.version[1]);
2482
2483 /*
2484 * Add standard attributes...
2485 */
2486
2487 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2488 NULL, uri);
2489 fprintf(stderr, "DEBUG: printer-uri=\"%s\"\n", uri);
2490
2491 if (user && *user)
2492 {
2493 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2494 "requesting-user-name", NULL, user);
2495 fprintf(stderr, "DEBUG: requesting-user-name=\"%s\"\n", user);
2496 }
2497
2498 if (title && *title)
2499 {
2500 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
2501 title);
2502 fprintf(stderr, "DEBUG: job-name=\"%s\"\n", title);
2503 }
2504
a29fd7dd 2505 if (format && op != IPP_CREATE_JOB)
0268488e
MS		 2506 {
2507 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
2508 "document-format", NULL, format);
2509 fprintf(stderr, "DEBUG: document-format=\"%s\"\n", format);
2510 }
2511
2512#ifdef HAVE_LIBZ
a469f8a5 2513 if (compression && op != IPP_OP_CREATE_JOB && op != IPP_OP_VALIDATE_JOB)
0268488e
MS		 2514 {
2515 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2516 "compression", NULL, compression);
2517 fprintf(stderr, "DEBUG: compression=\"%s\"\n", compression);
2518 }
2519#endif /* HAVE_LIBZ */
2520
2521 /*
2522 * Handle options on the command-line...
2523 */
2524
2525 if (num_options > 0)
2526 {
f14324a7 2527 if (pc)
0268488e 2528 {
dcb445bc
MS		 2529 int num_finishings = 0, /* Number of finishing values */
2530 finishings[10]; /* Finishing enum values */
a469f8a5 2531 ppd_choice_t *choice; /* Marked choice */
dcb445bc 2532
0268488e
MS		 2533 /*
2534 * Send standard IPP attributes...
2535 */
2536
a469f8a5
MS		 2537 fputs("DEBUG: Adding standard IPP operation/job attributes.\n", stderr);
2538
5a9febac
MS		 2539 if (pc->password &&
2540 (keyword = cupsGetOption("job-password", num_options,
2541 options)) != NULL)
2542 {
2543 ippAddOctetString(request, IPP_TAG_OPERATION, "job-password",
2544 keyword, strlen(keyword));
a469f8a5
MS		 2545
2546 if ((keyword = cupsGetOption("job-password-encryption", num_options,
2547 options)) == NULL)
2548 keyword = "none";
2549
5a9febac 2550 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
a469f8a5 2551 "job-password-encryption", NULL, keyword);
5a9febac
MS		 2552 }
2553
2554 if (pc->account_id &&
2555 (keyword = cupsGetOption("job-account-id", num_options,
2556 options)) != NULL)
2557 ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "job-account-id",
2558 NULL, keyword);
2559
2560 if (pc->account_id &&
2561 (keyword = cupsGetOption("job-accounting-user-id", num_options,
2562 options)) != NULL)
2563 ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME,
2564 "job-accounting-user-id", NULL, keyword);
2565
2566 for (mandatory = (char *)cupsArrayFirst(pc->mandatory);
2567 mandatory;
2568 mandatory = (char *)cupsArrayNext(pc->mandatory))
2569 {
2570 if (strcmp(mandatory, "copies") &&
2571 strcmp(mandatory, "destination-uris") &&
2572 strcmp(mandatory, "finishings") &&
2573 strcmp(mandatory, "job-account-id") &&
2574 strcmp(mandatory, "job-accounting-user-id") &&
2575 strcmp(mandatory, "job-password") &&
a469f8a5 2576 strcmp(mandatory, "job-password-encryption") &&
5a9febac
MS		 2577 strcmp(mandatory, "media") &&
2578 strncmp(mandatory, "media-col", 9) &&
2579 strcmp(mandatory, "multiple-document-handling") &&
2580 strcmp(mandatory, "output-bin") &&
2581 strcmp(mandatory, "print-color-mode") &&
2582 strcmp(mandatory, "print-quality") &&
2583 strcmp(mandatory, "sides") &&
2584 (keyword = cupsGetOption(mandatory, num_options, options)) != NULL)
2585 {
2586 _ipp_option_t *opt = _ippFindOption(mandatory);
2587 /* Option type */
2588 ipp_tag_t value_tag = opt ? opt->value_tag : IPP_TAG_NAME;
2589 /* Value type */
2590
2591 switch (value_tag)
2592 {
2593 case IPP_TAG_INTEGER :
2594 case IPP_TAG_ENUM :
2595 ippAddInteger(request, IPP_TAG_JOB, value_tag, mandatory,
2596 atoi(keyword));
2597 break;
2598 case IPP_TAG_BOOLEAN :
2599 ippAddBoolean(request, IPP_TAG_JOB, mandatory,
2600 !_cups_strcasecmp(keyword, "true"));
2601 break;
2602 case IPP_TAG_RANGE :
2603 {
2604 int lower, upper; /* Range */
2605
2606 if (sscanf(keyword, "%d-%d", &lower, &upper) != 2)
2607 lower = upper = atoi(keyword);
2608
2609 ippAddRange(request, IPP_TAG_JOB, mandatory, lower, upper);
2610 }
2611 break;
2612 case IPP_TAG_STRING :
2613 ippAddOctetString(request, IPP_TAG_JOB, mandatory, keyword,
2614 strlen(keyword));
2615 break;
2616 default :
2617 ippAddString(request, IPP_TAG_JOB, value_tag, mandatory,
2618 NULL, keyword);
2619 break;
2620 }
2621 }
2622 }
2623
0268488e
MS		 2624 if ((keyword = cupsGetOption("PageSize", num_options, options)) == NULL)
2625 keyword = cupsGetOption("media", num_options, options);
2626
f14324a7 2627 if ((size = _ppdCacheGetSize(pc, keyword)) != NULL)
0268488e
MS		 2628 {
2629 /*
2630 * Add a media-col value...
2631 */
2632
2633 media_size = ippNew();
2634 ippAddInteger(media_size, IPP_TAG_ZERO, IPP_TAG_INTEGER,
2635 "x-dimension", size->width);
2636 ippAddInteger(media_size, IPP_TAG_ZERO, IPP_TAG_INTEGER,
2637 "y-dimension", size->length);
2638
2639 media_col = ippNew();
2640 ippAddCollection(media_col, IPP_TAG_ZERO, "media-size", media_size);
2641
f14324a7
MS		 2642 media_source = _ppdCacheGetSource(pc, cupsGetOption("InputSlot",
2643 num_options,
2644 options));
2645 media_type = _ppdCacheGetType(pc, cupsGetOption("MediaType",
2646 num_options,
2647 options));
0268488e
MS		 2648
2649 for (i = 0; i < media_col_sup->num_values; i ++)
2650 {
2651 if (!strcmp(media_col_sup->values[i].string.text,
2652 "media-left-margin"))
2653 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
2654 "media-left-margin", size->left);
2655 else if (!strcmp(media_col_sup->values[i].string.text,
2656 "media-bottom-margin"))
2657 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
85dda01c 2658 "media-bottom-margin", size->bottom);
0268488e
MS		 2659 else if (!strcmp(media_col_sup->values[i].string.text,
2660 "media-right-margin"))
2661 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
85dda01c 2662 "media-right-margin", size->right);
0268488e
MS		 2663 else if (!strcmp(media_col_sup->values[i].string.text,
2664 "media-top-margin"))
2665 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
85dda01c 2666 "media-top-margin", size->top);
0268488e
MS		 2667 else if (!strcmp(media_col_sup->values[i].string.text,
2668 "media-source") && media_source)
2669 ippAddString(media_col, IPP_TAG_ZERO, IPP_TAG_KEYWORD,
2670 "media-source", NULL, media_source);
2671 else if (!strcmp(media_col_sup->values[i].string.text,
2672 "media-type") && media_type)
2673 ippAddString(media_col, IPP_TAG_ZERO, IPP_TAG_KEYWORD,
2674 "media-type", NULL, media_type);
2675 }
2676
2677 ippAddCollection(request, IPP_TAG_JOB, "media-col", media_col);
2678 }
2679
2680 if ((keyword = cupsGetOption("output-bin", num_options,
2681 options)) == NULL)
a469f8a5
MS		 2682 {
2683 if ((choice = ppdFindMarkedChoice(ppd, "OutputBin")) != NULL)
2684 keyword = _ppdCacheGetBin(pc, choice->choice);
2685 }
0268488e
MS		 2686
2687 if (keyword)
2688 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "output-bin",
2689 NULL, keyword);
2690
a469f8a5
MS		 2691 color_attr_name = print_color_mode ? "print-color-mode" : "output-mode";
2692
5a9febac 2693 if ((keyword = cupsGetOption("print-color-mode", num_options,
0268488e 2694 options)) != NULL)
a469f8a5 2695 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, color_attr_name,
0268488e 2696 NULL, keyword);
a469f8a5 2697 else if ((choice = ppdFindMarkedChoice(ppd, "ColorModel")) != NULL)
0268488e 2698 {
a469f8a5 2699 if (!_cups_strcasecmp(choice->choice, "Gray"))
5a9febac 2700 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
a469f8a5 2701 color_attr_name, NULL, "monochrome");
0268488e 2702 else
5a9febac 2703 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
a469f8a5 2704 color_attr_name, NULL, "color");
0268488e
MS		 2705 }
2706
2707 if ((keyword = cupsGetOption("print-quality", num_options,
2708 options)) != NULL)
2709 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2710 atoi(keyword));
a469f8a5 2711 else if ((choice = ppdFindMarkedChoice(ppd, "cupsPrintQuality")) != NULL)
0268488e 2712 {
a469f8a5 2713 if (!_cups_strcasecmp(choice->choice, "draft"))
0268488e
MS		 2714 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2715 IPP_QUALITY_DRAFT);
a469f8a5 2716 else if (!_cups_strcasecmp(choice->choice, "normal"))
0268488e
MS		 2717 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2718 IPP_QUALITY_NORMAL);
a469f8a5 2719 else if (!_cups_strcasecmp(choice->choice, "high"))
0268488e
MS		 2720 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2721 IPP_QUALITY_HIGH);
2722 }
2723
2724 if ((keyword = cupsGetOption("sides", num_options, options)) != NULL)
2725 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2726 NULL, keyword);
f14324a7 2727 else if (pc->sides_option &&
a469f8a5 2728 (choice = ppdFindMarkedChoice(ppd, pc->sides_option)) != NULL)
0268488e 2729 {
a469f8a5 2730 if (!_cups_strcasecmp(choice->choice, pc->sides_1sided))
0268488e
MS		 2731 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2732 NULL, "one-sided");
a469f8a5 2733 else if (!_cups_strcasecmp(choice->choice, pc->sides_2sided_long))
0268488e
MS		 2734 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2735 NULL, "two-sided-long-edge");
a469f8a5 2736 if (!_cups_strcasecmp(choice->choice, pc->sides_2sided_short))
0268488e
MS		 2737 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2738 NULL, "two-sided-short-edge");
2739 }
84315f46 2740
82cc1f9a
MS		 2741 if ((keyword = cupsGetOption("multiple-document-handling",
2742 num_options, options)) != NULL)
2743 {
2744 if (strstr(keyword, "uncollated"))
2745 keyword = "false";
2746 else
2747 keyword = "true";
2748 }
2749 else if ((keyword = cupsGetOption("collate", num_options,
2750 options)) == NULL)
2751 keyword = "true";
2752
2753 if (format)
2754 {
2755 if (!_cups_strcasecmp(format, "image/gif") ||
2756 !_cups_strcasecmp(format, "image/jp2") ||
2757 !_cups_strcasecmp(format, "image/jpeg") ||
2758 !_cups_strcasecmp(format, "image/png") ||
2759 !_cups_strcasecmp(format, "image/tiff") ||
2760 !_cups_strncasecmp(format, "image/x-", 8))
2761 {
2762 /*
2763 * Collation makes no sense for single page image formats...
2764 */
2765
2766 keyword = "false";
2767 }
2768 else if (!_cups_strncasecmp(format, "image/", 6) ||
2769 !_cups_strcasecmp(format, "application/vnd.cups-raster"))
2770 {
2771 /*
2772 * Multi-page image formats will have copies applied by the upstream
2773 * filters...
2774 */
2775
2776 copies = 1;
2777 }
2778 }
2779
2780 if (doc_handling_sup)
84315f46 2781 {
88f9aafc 2782 if (!_cups_strcasecmp(keyword, "true"))
84315f46
MS		 2783 collate_str = "separate-documents-collated-copies";
2784 else
2785 collate_str = "separate-documents-uncollated-copies";
eac3a0a0 2786
84315f46
MS		 2787 for (i = 0; i < doc_handling_sup->num_values; i ++)
2788 if (!strcmp(doc_handling_sup->values[i].string.text, collate_str))
2789 {
2790 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
2791 "multiple-document-handling", NULL, collate_str);
2792 break;
2793 }
3e7fe0ca
MS		 2794
2795 if (i >= doc_handling_sup->num_values)
2796 copies = 1;
84315f46 2797 }
dcb445bc
MS		 2798
2799 /*
2800 * Map finishing options...
2801 */
2802
2803 num_finishings = _ppdCacheGetFinishingValues(pc, num_options, options,
2804 (int)(sizeof(finishings) /
2805 sizeof(finishings[0])),
2806 finishings);
2807 if (num_finishings > 0)
2808 ippAddIntegers(request, IPP_TAG_JOB, IPP_TAG_ENUM, "finishings",
2809 num_finishings, finishings);
2810
2811 /*
2812 * Map FaxOut options...
2813 */
2814
2815 if ((keyword = cupsGetOption("phone", num_options, options)) != NULL)
2816 {
2817 ipp_t *destination; /* destination collection */
2818 char tel_uri[1024]; /* tel: URI */
2819
2820 destination = ippNew();
2821
2822 httpAssembleURI(HTTP_URI_CODING_ALL, tel_uri, sizeof(tel_uri), "tel",
2823 NULL, NULL, 0, keyword);
2824 ippAddString(destination, IPP_TAG_JOB, IPP_TAG_URI, "destination-uri",
2825 NULL, tel_uri);
2826
2827 if ((keyword = cupsGetOption("faxPrefix", num_options,
2828 options)) != NULL && *keyword)
2829 ippAddString(destination, IPP_TAG_JOB, IPP_TAG_TEXT,
2830 "pre-dial-string", NULL, keyword);
2831
2832 ippAddCollection(request, IPP_TAG_JOB, "destination-uris", destination);
2833 ippDelete(destination);
2834 }
0268488e
MS		 2835 }
2836 else
2837 {
2838 /*
2839 * When talking to another CUPS server, send all options...
2840 */
2841
a469f8a5
MS		 2842 fputs("DEBUG: Adding all operation/job attributes.\n", stderr);
2843 cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
a29fd7dd 2844 cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
0268488e
MS		 2845 }
2846
82cc1f9a 2847 if (copies > 1 && (!pc || copies <= pc->max_copies))
0268488e
MS		 2848 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", copies);
2849 }
2850
a469f8a5
MS		 2851 fprintf(stderr, "DEBUG: IPP/%d.%d %s #%d\n", version / 10, version % 10,
2852 ippOpString(ippGetOperation(request)), ippGetRequestId(request));
2853 for (group = IPP_TAG_ZERO, attr = ippFirstAttribute(request);
2854 attr;
2855 attr = ippNextAttribute(request))
2856 {
2857 const char *name = ippGetName(attr);
2858
2859 if (!name)
2860 {
2861 group = IPP_TAG_ZERO;
2862 continue;
2863 }
2864
2865 if (group != ippGetGroupTag(attr))
2866 {
2867 group = ippGetGroupTag(attr);
2868 fprintf(stderr, "DEBUG: ---- %s ----\n", ippTagString(group));
2869 }
2870
2871 ippAttributeString(attr, buffer, sizeof(buffer));
2872 fprintf(stderr, "DEBUG: %s %s%s %s\n", name,
2873 ippGetCount(attr) > 1 ? "1setOf " : "",
2874 ippTagString(ippGetValueTag(attr)), buffer);
2875 }
2876
2877 fprintf(stderr, "DEBUG: ---- %s ----\n", ippTagString(IPP_TAG_END));
2878
0268488e
MS		 2879 return (request);
2880}
2881
2882
ef416fc2 2883/*
2884 * 'password_cb()' - Disable the password prompt for cupsDoFileRequest().
2885 */
2886
bd7854cb 2887static const char * /* O - Password */
5a9febac
MS		 2888password_cb(const char *prompt, /* I - Prompt (not used) */
2889 http_t *http, /* I - Connection */
2890 const char *method, /* I - Request method (not used) */
2891 const char *resource, /* I - Resource path (not used) */
2892 void *user_data) /* I - User data (not used) */
ef416fc2 2893{
5a9febac
MS		 2894 char def_username[HTTP_MAX_VALUE]; /* Default username */
2895
2896
3e7fe0ca
MS		 2897 fprintf(stderr, "DEBUG: password_cb(prompt=\"%s\"), password=%p, "
2898 "password_tries=%d\n", prompt, password, password_tries);
2899
ef416fc2 2900 (void)prompt;
5a9febac
MS		 2901 (void)method;
2902 (void)resource;
2903 (void)user_data;
ef416fc2 2904
18ecb428
MS		 2905 /*
2906 * Remember that we need to authenticate...
2907 */
2908
2909 auth_info_required = "username,password";
2910
5a9febac
MS		 2911 if (httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "username",
2912 def_username))
2913 {
2914 char quoted[HTTP_MAX_VALUE * 2 + 4];
2915 /* Quoted string */
2916
2917 fprintf(stderr, "ATTR: auth-info-default=%s,\n",
2918 quote_string(def_username, quoted, sizeof(quoted)));
2919 }
2920
3dfe78b3 2921 if (password && *password && password_tries < 3)
76cd9e37
MS		 2922 {
2923 password_tries ++;
2924
ef416fc2 2925 return (password);
76cd9e37 2926 }
ef416fc2 2927 else
2928 {
2929 /*
18ecb428 2930 * Give up after 3 tries or if we don't have a password to begin with...
ef416fc2 2931 */
2932
18ecb428 2933 return (NULL);
ef416fc2 2934 }
2935}
2936
2937
5a9febac
MS		 2938/*
2939 * 'quote_string()' - Quote a string value.
2940 */
2941
2942static const char * /* O - Quoted string */
2943quote_string(const char *s, /* I - String */
2944 char *q, /* I - Quoted string buffer */
2945 size_t qsize) /* I - Size of quoted string buffer */
2946{
2947 char *qptr, /* Pointer into string buffer */
2948 *qend; /* End of string buffer */
2949
2950
2951 qptr = q;
2952 qend = q + qsize - 5;
2953
2954 if (qend < q)
2955 {
2956 *q = '\0';
2957 return (q);
2958 }
2959
2960 *qptr++ = '\'';
2961 *qptr++ = '\"';
2962
2963 while (*s && qptr < qend)
2964 {
2965 if (*s == '\\' || *s == '\"' || *s == '\'')
2966 {
2967 if (q < (qend - 3))
2968 {
2969 *qptr++ = '\\';
2970 *qptr++ = '\\';
2971 *qptr++ = '\\';
2972 }
2973 else
2974 break;
2975 }
2976
2977 *qptr++ = *s++;
2978 }
2979
2980 *qptr++ = '\"';
2981 *qptr++ = '\'';
2982 *qptr = '\0';
2983
2984 return (q);
2985}
2986
2987
1f0275e3
MS		 2988/*
2989 * 'report_attr()' - Report an IPP attribute value.
2990 */
2991
2992static void
2993report_attr(ipp_attribute_t *attr) /* I - Attribute */
2994{
eac3a0a0
MS		 2995 int i; /* Looping var */
2996 char value[1024], /* Value string */
5a9febac 2997 *valptr; /* Pointer into value string */
eac3a0a0 2998 const char *cached; /* Cached attribute */
1f0275e3
MS		 2999
3000
3001 /*
3002 * Convert the attribute values into quoted strings...
3003 */
3004
3005 for (i = 0, valptr = value;
3006 i < attr->num_values && valptr < (value + sizeof(value) - 10);
3007 i ++)
3008 {
3009 if (i > 0)
3010 *valptr++ = ',';
3011
3012 switch (attr->value_tag)
3013 {
3014 case IPP_TAG_INTEGER :
3015 case IPP_TAG_ENUM :
3016 snprintf(valptr, sizeof(value) - (valptr - value), "%d",
3017 attr->values[i].integer);
3018 valptr += strlen(valptr);
3019 break;
3020
3021 case IPP_TAG_TEXT :
3022 case IPP_TAG_NAME :
3023 case IPP_TAG_KEYWORD :
5a9febac
MS		 3024 quote_string(attr->values[i].string.text, valptr,
3025 value + sizeof(value) - valptr);
3026 valptr += strlen(valptr);
1f0275e3
MS		 3027 break;
3028
3029 default :
3030 /*
3031 * Unsupported value type...
3032 */
3033
3034 return;
3035 }
3036 }
3037
3038 *valptr = '\0';
3039
321d8d57
MS		 3040 _cupsMutexLock(&report_mutex);
3041
eac3a0a0
MS		 3042 if ((cached = cupsGetOption(attr->name, num_attr_cache,
3043 attr_cache)) == NULL || strcmp(cached, value))
3044 {
3045 /*
3046 * Tell the scheduler about the new values...
3047 */
1f0275e3 3048
eac3a0a0
MS		 3049 num_attr_cache = cupsAddOption(attr->name, value, num_attr_cache,
3050 &attr_cache);
3051 fprintf(stderr, "ATTR: %s=%s\n", attr->name, value);
3052 }
321d8d57
MS		 3053
3054 _cupsMutexUnlock(&report_mutex);
1f0275e3
MS		 3055}
3056
3057
ef416fc2 3058/*
3059 * 'report_printer_state()' - Report the printer state.
3060 */
3061
321d8d57
MS		 3062static void
3063report_printer_state(ipp_t *ipp) /* I - IPP response */
ef416fc2 3064{
7cf5915e
MS		 3065 ipp_attribute_t *pa, /* printer-alert */
3066 *pam, /* printer-alert-message */
3067 *psm, /* printer-state-message */
1f0275e3
MS		 3068 *reasons, /* printer-state-reasons */
3069 *marker; /* marker-* attributes */
7cf5915e
MS		 3070 char value[1024], /* State/message string */
3071 *valptr; /* Pointer into string */
c8fef167
MS		 3072 static int ipp_supplies = -1;
3073 /* Report supply levels? */
ef416fc2 3074
3075
7cf5915e
MS		 3076 /*
3077 * Report alerts and messages...
3078 */
3079
3080 if ((pa = ippFindAttribute(ipp, "printer-alert", IPP_TAG_TEXT)) != NULL)
3081 report_attr(pa);
3082
3083 if ((pam = ippFindAttribute(ipp, "printer-alert-message",
3084 IPP_TAG_TEXT)) != NULL)
3085 report_attr(pam);
3086
323c5de1 3087 if ((psm = ippFindAttribute(ipp, "printer-state-message",
3088 IPP_TAG_TEXT)) != NULL)
7cf5915e
MS		 3089 {
3090 char *ptr; /* Pointer into message */
3091
3092
3093 strlcpy(value, "INFO: ", sizeof(value));
3094 for (ptr = psm->values[0].string.text, valptr = value + 6;
3095 *ptr && valptr < (value + sizeof(value) - 6);
3096 ptr ++)
3097 {
3098 if (*ptr < ' ' && *ptr > 0 && *ptr != '\t')
3099 {
3100 /*
3101 * Substitute "<XX>" for the control character; sprintf is safe because
3102 * we always leave 6 chars free at the end...
3103 */
3104
3105 sprintf(valptr, "<%02X>", *ptr);
3106 valptr += 4;
3107 }
3108 else
3109 *valptr++ = *ptr;
3110 }
3111
3112 *valptr++ = '\n';
e60ec91f 3113 *valptr = '\0';
7cf5915e
MS		 3114
3115 fputs(value, stderr);
3116 }
3117
3118 /*
3119 * Now report printer-state-reasons, filtering out some of the reasons we never
3120 * want to set...
3121 */
323c5de1 3122
ef416fc2 3123 if ((reasons = ippFindAttribute(ipp, "printer-state-reasons",
3124 IPP_TAG_KEYWORD)) == NULL)
321d8d57 3125 return;
ef416fc2 3126
eac3a0a0 3127 update_reasons(reasons, NULL);
ef416fc2 3128
1f0275e3
MS		 3129 /*
3130 * Relay the current marker-* attribute values...
3131 */
3132
c8fef167
MS		 3133 if (ipp_supplies < 0)
3134 {
3135 ppd_file_t *ppd; /* PPD file */
3136 ppd_attr_t *ppdattr; /* Attribute in PPD file */
3137
3138 if ((ppd = ppdOpenFile(getenv("PPD"))) != NULL &&
3139 (ppdattr = ppdFindAttr(ppd, "cupsIPPSupplies", NULL)) != NULL &&
88f9aafc 3140 ppdattr->value && _cups_strcasecmp(ppdattr->value, "true"))
c8fef167
MS		 3141 ipp_supplies = 0;
3142 else
3143 ipp_supplies = 1;
3144
3145 ppdClose(ppd);
3146 }
3147
3148 if (ipp_supplies > 0)
3149 {
3150 if ((marker = ippFindAttribute(ipp, "marker-colors", IPP_TAG_NAME)) != NULL)
3151 report_attr(marker);
3152 if ((marker = ippFindAttribute(ipp, "marker-high-levels",
3153 IPP_TAG_INTEGER)) != NULL)
3154 report_attr(marker);
3155 if ((marker = ippFindAttribute(ipp, "marker-levels",
3156 IPP_TAG_INTEGER)) != NULL)
3157 report_attr(marker);
3158 if ((marker = ippFindAttribute(ipp, "marker-low-levels",
3159 IPP_TAG_INTEGER)) != NULL)
3160 report_attr(marker);
3161 if ((marker = ippFindAttribute(ipp, "marker-message",
3162 IPP_TAG_TEXT)) != NULL)
3163 report_attr(marker);
3164 if ((marker = ippFindAttribute(ipp, "marker-names", IPP_TAG_NAME)) != NULL)
3165 report_attr(marker);
3166 if ((marker = ippFindAttribute(ipp, "marker-types",
3167 IPP_TAG_KEYWORD)) != NULL)
3168 report_attr(marker);
3169 }
ef416fc2 3170}
3171
3172
eac3a0a0
MS		 3173#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
3174/*
3175 * 'run_as_user()' - Run the IPP backend as the printing user.
3176 *
3177 * This function uses an XPC-based user agent to run the backend as the printing
3178 * user. We need to do this in order to have access to the user's Kerberos
3179 * credentials.
3180 */
3181
3182static int /* O - Exit status */
37e7e6e0 3183run_as_user(char *argv[], /* I - Command-line arguments */
eac3a0a0
MS		 3184 uid_t uid, /* I - User ID */
3185 const char *device_uri, /* I - Device URI */
3186 int fd) /* I - File to print */
3187{
88f9aafc 3188 const char *auth_negotiate;/* AUTH_NEGOTIATE env var */
eac3a0a0
MS		 3189 xpc_connection_t conn; /* Connection to XPC service */
3190 xpc_object_t request; /* Request message dictionary */
3191 __block xpc_object_t response; /* Response message dictionary */
3192 dispatch_semaphore_t sem; /* Semaphore for waiting for response */
3193 int status = CUPS_BACKEND_FAILED;
3194 /* Status of request */
3195
3196
3197 fprintf(stderr, "DEBUG: Running IPP backend as UID %d.\n", (int)uid);
3198
3199 /*
3200 * Connect to the user agent for the specified UID...
3201 */
3202
3203 conn = xpc_connection_create_mach_service(kPMPrintUIToolAgent,
3204 dispatch_get_global_queue(0, 0), 0);
3205 if (!conn)
3206 {
3207 _cupsLangPrintFilter(stderr, "ERROR",
3208 _("Unable to start backend process."));
3209 fputs("DEBUG: Unable to create connection to agent.\n", stderr);
3210 goto cleanup;
3211 }
3212
3213 xpc_connection_set_event_handler(conn,
3214 ^(xpc_object_t event)
3215 {
3216 xpc_type_t messageType = xpc_get_type(event);
3217
3218 if (messageType == XPC_TYPE_ERROR)
3219 {
3220 if (event == XPC_ERROR_CONNECTION_INTERRUPTED)
3221 fprintf(stderr, "DEBUG: Interrupted connection to service %s.\n",
3222 xpc_connection_get_name(conn));
3223 else if (event == XPC_ERROR_CONNECTION_INVALID)
3224 fprintf(stderr, "DEBUG: Connection invalid for service %s.\n",
3225 xpc_connection_get_name(conn));
3226 else
3227 fprintf(stderr, "DEBUG: Unxpected error for service %s: %s\n",
3228 xpc_connection_get_name(conn),
3229 xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION));
3230 }
3231 });
3232 xpc_connection_set_target_uid(conn, uid);
3233 xpc_connection_resume(conn);
3234
3235 /*
3236 * Try starting the backend...
3237 */
3238
3239 request = xpc_dictionary_create(NULL, NULL, 0);
3240 xpc_dictionary_set_int64(request, "command", kPMStartJob);
3241 xpc_dictionary_set_string(request, "device-uri", device_uri);
3242 xpc_dictionary_set_string(request, "job-id", argv[1]);
3243 xpc_dictionary_set_string(request, "user", argv[2]);
3244 xpc_dictionary_set_string(request, "title", argv[3]);
3245 xpc_dictionary_set_string(request, "copies", argv[4]);
3246 xpc_dictionary_set_string(request, "options", argv[5]);
3247 xpc_dictionary_set_string(request, "auth-info-required",
3248 getenv("AUTH_INFO_REQUIRED"));
88f9aafc
MS		 3249 if ((auth_negotiate = getenv("AUTH_NEGOTIATE")) != NULL)
3250 xpc_dictionary_set_string(request, "auth-negotiate", auth_negotiate);
eac3a0a0
MS		 3251 xpc_dictionary_set_fd(request, "stdin", fd);
3252 xpc_dictionary_set_fd(request, "stderr", 2);
3253 xpc_dictionary_set_fd(request, "side-channel", CUPS_SC_FD);
3254
3255 sem = dispatch_semaphore_create(0);
3256 response = NULL;
3257
3258 xpc_connection_send_message_with_reply(conn, request,
3259 dispatch_get_global_queue(0,0),
3260 ^(xpc_object_t reply)
3261 {
3262 /* Save the response and wake up */
3263 if (xpc_get_type(reply)
3264 == XPC_TYPE_DICTIONARY)
3265 response = xpc_retain(reply);
3266
3267 dispatch_semaphore_signal(sem);
3268 });
3269
3270 dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
3271 xpc_release(request);
3272 dispatch_release(sem);
3273
3274 if (response)
3275 {
3276 child_pid = xpc_dictionary_get_int64(response, "child-pid");
3277
3278 xpc_release(response);
3279
3280 if (child_pid)
3281 fprintf(stderr, "DEBUG: Child PID=%d.\n", child_pid);
3282 else
3283 {
3284 _cupsLangPrintFilter(stderr, "ERROR",
3285 _("Unable to start backend process."));
3286 fputs("DEBUG: No child PID.\n", stderr);
3287 goto cleanup;
3288 }
3289 }
3290 else
3291 {
3292 _cupsLangPrintFilter(stderr, "ERROR",
3293 _("Unable to start backend process."));
3294 fputs("DEBUG: No reply from agent.\n", stderr);
3295 goto cleanup;
3296 }
3297
3298 /*
3299 * Then wait for the backend to finish...
3300 */
3301
3302 request = xpc_dictionary_create(NULL, NULL, 0);
3303 xpc_dictionary_set_int64(request, "command", kPMWaitForJob);
3304 xpc_dictionary_set_fd(request, "stderr", 2);
3305
3306 sem = dispatch_semaphore_create(0);
3307 response = NULL;
3308
3309 xpc_connection_send_message_with_reply(conn, request,
3310 dispatch_get_global_queue(0,0),
3311 ^(xpc_object_t reply)
3312 {
3313 /* Save the response and wake up */
3314 if (xpc_get_type(reply)
3315 == XPC_TYPE_DICTIONARY)
3316 response = xpc_retain(reply);
3317
3318 dispatch_semaphore_signal(sem);
3319 });
3320
3321 dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
3322 xpc_release(request);
3323 dispatch_release(sem);
3324
3325 if (response)
3326 {
3327 status = xpc_dictionary_get_int64(response, "status");
3328
3329 if (status == SIGTERM || status == SIGKILL || status == SIGPIPE)
3330 {
3331 fprintf(stderr, "DEBUG: Child terminated on signal %d.\n", status);
3332 status = CUPS_BACKEND_FAILED;
3333 }
3334 else if (WIFSIGNALED(status))
3335 {
3336 fprintf(stderr, "DEBUG: Child crashed on signal %d.\n", status);
3337 status = CUPS_BACKEND_STOP;
3338 }
3339 else if (WIFEXITED(status))
3340 {
3341 status = WEXITSTATUS(status);
3342 fprintf(stderr, "DEBUG: Child exited with status %d.\n", status);
3343 }
3344
3345 xpc_release(response);
3346 }
3347 else
3348 _cupsLangPrintFilter(stderr, "ERROR",
3349 _("Unable to get backend exit status."));
3350
3351 cleanup:
3352
3353 if (conn)
3354 {
3355 xpc_connection_suspend(conn);
3356 xpc_connection_cancel(conn);
3357 xpc_release(conn);
3358 }
3359
3360 return (status);
3361}
3362#endif /* HAVE_GSSAPI && HAVE_XPC */
3363
3364
ef416fc2 3365/*
3366 * 'sigterm_handler()' - Handle 'terminate' signals that stop the backend.
3367 */
3368
3369static void
3370sigterm_handler(int sig) /* I - Signal */
3371{
3372 (void)sig; /* remove compiler warnings... */
3373
f3c17241
MS		 3374 write(2, "DEBUG: Got SIGTERM.\n", 20);
3375
eac3a0a0
MS		 3376#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
3377 if (child_pid)
3378 {
3379 kill(child_pid, sig);
3380 child_pid = 0;
3381 }
3382#endif /* HAVE_GSSAPI && HAVE_XPC */
3383
cc754834 3384 if (!job_canceled)
bd7854cb 3385 {
3386 /*
eac3a0a0 3387 * Flag that the job should be canceled...
bd7854cb 3388 */
3389
f3c17241
MS		 3390 write(2, "DEBUG: job_canceled = 1.\n", 25);
3391
cc754834 3392 job_canceled = 1;
bd7854cb 3393 return;
3394 }
3395
82f97232
MS		 3396 /*
3397 * The scheduler already tried to cancel us once, now just terminate
eac3a0a0 3398 * after removing our temp file!
82f97232
MS		 3399 */
3400
3401 if (tmpfilename[0])
3402 unlink(tmpfilename);
3403
ef416fc2 3404 exit(1);
3405}
3406
3407
f228370c
MS		 3408/*
3409 * 'timeout_cb()' - Handle HTTP timeouts.
3410 */
3411
3412static int /* O - 1 to continue, 0 to cancel */
3413timeout_cb(http_t *http, /* I - Connection to server (unused) */
3414 void *user_data) /* I - User data (unused) */
3415{
3416 (void)http;
3417 (void)user_data;
3418
3419 return (!job_canceled);
3420}
3421
3422
ef416fc2 3423/*
eac3a0a0
MS		 3424 * 'update_reasons()' - Update the printer-state-reasons values.
3425 */
3426
3427static void
3428update_reasons(ipp_attribute_t *attr, /* I - printer-state-reasons or NULL */
3429 const char *s) /* I - STATE: string or NULL */
3430{
3431 char op; /* Add (+), remove (-), replace (\0) */
3432 cups_array_t *new_reasons; /* New reasons array */
3433 char *reason, /* Current reason */
3434 add[2048], /* Reasons added string */
3435 *addptr, /* Pointer into add string */
3436 rem[2048], /* Reasons removed string */
3437 *remptr; /* Pointer into remove string */
3438 const char *addprefix, /* Current add string prefix */
3439 *remprefix; /* Current remove string prefix */
3440
3441
3442 fprintf(stderr, "DEBUG: update_reasons(attr=%d(%s%s), s=\"%s\")\n",
3443 attr ? attr->num_values : 0, attr ? attr->values[0].string.text : "",
3444 attr && attr->num_values > 1 ? ",..." : "", s ? s : "(null)");
3445
3446 /*
3447 * Create an array of new reason keyword strings...
3448 */
3449
3450 if (attr)
3451 {
3452 int i; /* Looping var */
3453
3454 new_reasons = cupsArrayNew((cups_array_func_t)strcmp, NULL);
3455 op = '\0';
3456
3457 for (i = 0; i < attr->num_values; i ++)
3458 {
3459 reason = attr->values[i].string.text;
3460
3461 if (strcmp(reason, "none") &&
3462 strcmp(reason, "none-report") &&
3463 strcmp(reason, "paused") &&
a4845881 3464 strncmp(reason, "spool-area-full", 15) &&
eac3a0a0
MS		 3465 strcmp(reason, "com.apple.print.recoverable-warning") &&
3466 strncmp(reason, "cups-", 5))
3467 cupsArrayAdd(new_reasons, reason);
3468 }
3469 }
3470 else if (s)
3471 {
3472 if (*s == '+' || *s == '-')
3473 op = *s++;
3474 else
3475 op = '\0';
3476
5a9febac 3477 new_reasons = _cupsArrayNewStrings(s, ',');
eac3a0a0
MS		 3478 }
3479 else
3480 return;
3481
3482 /*
3483 * Compute the changes...
3484 */
3485
3486 add[0] = '\0';
3487 addprefix = "STATE: +";
3488 addptr = add;
3489 rem[0] = '\0';
3490 remprefix = "STATE: -";
3491 remptr = rem;
3492
3493 fprintf(stderr, "DEBUG2: op='%c', new_reasons=%d, state_reasons=%d\n",
3494 op ? op : ' ', cupsArrayCount(new_reasons),
3495 cupsArrayCount(state_reasons));
3496
321d8d57 3497 _cupsMutexLock(&report_mutex);
eac3a0a0
MS		 3498
3499 if (op == '+')
3500 {
3501 /*
3502 * Add reasons...
3503 */
3504
3505 for (reason = (char *)cupsArrayFirst(new_reasons);
3506 reason;
3507 reason = (char *)cupsArrayNext(new_reasons))
3508 {
3509 if (!cupsArrayFind(state_reasons, reason))
3510 {
3511 if (!strncmp(reason, "cups-remote-", 12))
3512 {
3513 /*
3514 * If we are setting cups-remote-xxx, remove all other cups-remote-xxx
3515 * keywords...
3516 */
3517
3518 char *temp; /* Current reason in state_reasons */
3519
3520 cupsArraySave(state_reasons);
3521
3522 for (temp = (char *)cupsArrayFirst(state_reasons);
3523 temp;
3524 temp = (char *)cupsArrayNext(state_reasons))
3525 if (!strncmp(temp, "cups-remote-", 12))
3526 {
3527 snprintf(remptr, sizeof(rem) - (remptr - rem), "%s%s", remprefix,
3528 temp);
3529 remptr += strlen(remptr);
3530 remprefix = ",";
3531
3532 cupsArrayRemove(state_reasons, temp);
3533 break;
3534 }
3535
3536 cupsArrayRestore(state_reasons);
3537 }
3538
3539 cupsArrayAdd(state_reasons, reason);
3540
3541 snprintf(addptr, sizeof(add) - (addptr - add), "%s%s", addprefix,
3542 reason);
3543 addptr += strlen(addptr);
3544 addprefix = ",";
3545 }
3546 }
3547 }
3548 else if (op == '-')
3549 {
3550 /*
3551 * Remove reasons...
3552 */
3553
3554 for (reason = (char *)cupsArrayFirst(new_reasons);
3555 reason;
3556 reason = (char *)cupsArrayNext(new_reasons))
3557 {
3558 if (cupsArrayFind(state_reasons, reason))
3559 {
3560 snprintf(remptr, sizeof(rem) - (remptr - rem), "%s%s", remprefix,
3561 reason);
3562 remptr += strlen(remptr);
3563 remprefix = ",";
3564
3565 cupsArrayRemove(state_reasons, reason);
3566 }
3567 }
3568 }
3569 else
3570 {
3571 /*
3572 * Replace reasons...
3573 */
3574
3575 for (reason = (char *)cupsArrayFirst(state_reasons);
3576 reason;
3577 reason = (char *)cupsArrayNext(state_reasons))
3578 {
3579 if (strncmp(reason, "cups-", 5) && !cupsArrayFind(new_reasons, reason))
3580 {
3581 snprintf(remptr, sizeof(rem) - (remptr - rem), "%s%s", remprefix,
3582 reason);
3583 remptr += strlen(remptr);
3584 remprefix = ",";
3585
3586 cupsArrayRemove(state_reasons, reason);
3587 }
3588 }
3589
3590 for (reason = (char *)cupsArrayFirst(new_reasons);
3591 reason;
3592 reason = (char *)cupsArrayNext(new_reasons))
3593 {
3594 if (!cupsArrayFind(state_reasons, reason))
3595 {
3596 cupsArrayAdd(state_reasons, reason);
3597
3598 snprintf(addptr, sizeof(add) - (addptr - add), "%s%s", addprefix,
3599 reason);
3600 addptr += strlen(addptr);
3601 addprefix = ",";
3602 }
3603 }
3604 }
3605
321d8d57 3606 _cupsMutexUnlock(&report_mutex);
eac3a0a0
MS		 3607
3608 /*
3609 * Report changes and return...
3610 */
3611
3612 if (add[0] && rem[0])
3613 fprintf(stderr, "%s\n%s\n", add, rem);
3614 else if (add[0])
3615 fprintf(stderr, "%s\n", add);
3616 else if (rem[0])
3617 fprintf(stderr, "%s\n", rem);
3618}
3619
3620/*
3621 * End of "$Id: ipp.c 9759 2011-05-11 03:24:33Z mike $".
ef416fc2 3622 */
Unnamed repository; edit this file 'description' to name the repository.