]> 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.7b1-r10947.
[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 *
0fa6c7fa 6 * Copyright 2007-2013 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 117 /* Password for device URI */
7cf5915e
MS		 118static const char * const pattrs[] = /* Printer attributes we want */
119{
a469f8a5
MS		 120#ifdef HAVE_LIBZ
121 "compression-supported",
122#endif /* HAVE_LIBZ */
7cf5915e
MS		 123 "copies-supported",
124 "cups-version",
125 "document-format-supported",
126 "marker-colors",
127 "marker-high-levels",
128 "marker-levels",
129 "marker-low-levels",
130 "marker-message",
131 "marker-names",
132 "marker-types",
133 "media-col-supported",
84315f46 134 "multiple-document-handling-supported",
c8fef167 135 "operations-supported",
7cf5915e
MS		 136 "printer-alert",
137 "printer-alert-description",
138 "printer-is-accepting-jobs",
139 "printer-state",
140 "printer-state-message",
a4845881 141 "printer-state-reasons"
7cf5915e 142};
07ed0e9a
MS		 143static const char * const remote_job_states[] =
144{ /* Remote job state keywords */
88f9aafc
MS		 145 "+cups-remote-pending",
146 "+cups-remote-pending-held",
147 "+cups-remote-processing",
148 "+cups-remote-stopped",
149 "+cups-remote-canceled",
150 "+cups-remote-aborted",
151 "+cups-remote-completed"
07ed0e9a 152};
321d8d57 153static _cups_mutex_t report_mutex = _CUPS_MUTEX_INITIALIZER;
eac3a0a0 154 /* Mutex to control access */
321d8d57
MS		 155static int num_attr_cache = 0;
156 /* Number of cached attributes */
157static cups_option_t *attr_cache = NULL;
158 /* Cached attributes */
159static cups_array_t *state_reasons; /* Array of printe-state-reasons keywords */
eac3a0a0
MS		 160static char tmpfilename[1024] = "";
161 /* Temporary spool file name */
ef416fc2 162
163
164/*
165 * Local functions...
166 */
167
7cf5915e
MS		 168static void cancel_job(http_t *http, const char *uri, int id,
169 const char *resource, const char *user,
170 int version);
171static ipp_pstate_t check_printer_state(http_t *http, const char *uri,
172 const char *resource,
321d8d57 173 const char *user, int version);
7cf5915e 174static void *monitor_printer(_cups_monitor_t *monitor);
0268488e
MS		 175static ipp_t *new_request(ipp_op_t op, int version, const char *uri,
176 const char *user, const char *title,
177 int num_options, cups_option_t *options,
178 const char *compression, int copies,
f14324a7 179 const char *format, _ppd_cache_t *pc,
a469f8a5 180 ppd_file_t *ppd,
84315f46 181 ipp_attribute_t *media_col_sup,
a469f8a5
MS		 182 ipp_attribute_t *doc_handling_sup,
183 int print_color_mode);
5a9febac
MS		 184static const char *password_cb(const char *prompt, http_t *http,
185 const char *method, const char *resource,
6961465f 186 int *user_data);
5a9febac 187static const char *quote_string(const char *s, char *q, size_t qsize);
7cf5915e 188static void report_attr(ipp_attribute_t *attr);
321d8d57 189static void report_printer_state(ipp_t *ipp);
eac3a0a0 190#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
37e7e6e0 191static int run_as_user(char *argv[], uid_t uid,
eac3a0a0
MS		 192 const char *device_uri, int fd);
193#endif /* HAVE_GSSAPI && HAVE_XPC */
7cf5915e 194static void sigterm_handler(int sig);
f228370c 195static int timeout_cb(http_t *http, void *user_data);
eac3a0a0 196static void update_reasons(ipp_attribute_t *attr, const char *s);
ef416fc2 197
198
199/*
200 * 'main()' - Send a file to the printer or server.
201 *
202 * Usage:
203 *
204 * printer-uri job-id user title copies options [file]
205 */
206
207int /* O - Exit status */
bd7854cb 208main(int argc, /* I - Number of command-line args */
ef416fc2 209 char *argv[]) /* I - Command-line arguments */
210{
211 int i; /* Looping var */
b94498cf 212 int send_options; /* Send job options? */
ef416fc2 213 int num_options; /* Number of printer options */
214 cups_option_t *options; /* Printer options */
1f0275e3 215 const char *device_uri; /* Device URI */
acb056cb 216 char scheme[255], /* Scheme in URI */
ef416fc2 217 hostname[1024], /* Hostname */
ef416fc2 218 resource[1024], /* Resource info (printer name) */
26d47ec6 219 addrname[256], /* Address name */
ef416fc2 220 *optptr, /* Pointer to URI options */
db1f069b
MS		 221 *name, /* Name of option */
222 *value, /* Value of option */
223 sep; /* Separator character */
6961465f 224 int password_tries = 0; /* Password tries */
c8fef167 225 http_addrlist_t *addrlist; /* Address of printer */
5a9febac 226 int snmp_enabled = 1; /* Is SNMP enabled? */
7a14d768
MS		 227 int snmp_fd, /* SNMP socket */
228 start_count, /* Page count via SNMP at start */
426c6a59
MS		 229 page_count, /* Page count via SNMP */
230 have_supplies; /* Printer supports supply levels? */
bd7854cb 231 int num_files; /* Number of files to print */
82f97232
MS		 232 char **files, /* Files to print */
233 *compatfile = NULL; /* Compatibility filename */
234 off_t compatsize = 0; /* Size of compatibility file */
ef416fc2 235 int port; /* Port number (not used) */
c8fef167 236 char portname[255]; /* Port name */
ef416fc2 237 char uri[HTTP_MAX_URI]; /* Updated URI without user/pass */
dcb445bc 238 char print_job_name[1024]; /* Update job-name for Print-Job */
cc754834 239 http_status_t http_status; /* Status of HTTP request */
ef416fc2 240 ipp_status_t ipp_status; /* Status of IPP request */
241 http_t *http; /* HTTP connection */
242 ipp_t *request, /* IPP request */
243 *response, /* IPP response */
244 *supported; /* get-printer-attributes response */
c0e1af83 245 time_t start_time; /* Time of first connect */
c0e1af83 246 int contimeout; /* Connection timeout */
f14324a7
MS		 247 int delay, /* Delay for retries */
248 prev_delay; /* Previous delay */
0268488e
MS		 249 const char *compression; /* Compression mode */
250 int waitjob, /* Wait for job complete? */
a469f8a5 251 waitjob_tries = 0, /* Number of times we've waited */
ef416fc2 252 waitprinter; /* Wait for printer ready? */
7cf5915e 253 _cups_monitor_t monitor; /* Monitoring data */
ef416fc2 254 ipp_attribute_t *job_id_attr; /* job-id attribute */
255 int job_id; /* job-id value */
bd7854cb 256 ipp_attribute_t *job_sheets; /* job-media-sheets-completed */
257 ipp_attribute_t *job_state; /* job-state */
a469f8a5
MS		 258#ifdef HAVE_LIBZ
259 ipp_attribute_t *compression_sup; /* compression-supported */
260#endif /* HAVE_LIBZ */
bd7854cb 261 ipp_attribute_t *copies_sup; /* copies-supported */
cc754834 262 ipp_attribute_t *cups_version; /* cups-version */
bd7854cb 263 ipp_attribute_t *format_sup; /* document-format-supported */
c5b24bfa 264 ipp_attribute_t *job_auth; /* job-authorization-uri */
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
6961465f 637 cupsSetPasswordCB2((cups_password_cb2_t)password_cb, &password_tries);
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
db8b865d
MS		 694 http = httpConnect2(hostname, port, addrlist, AF_UNSPEC, cupsEncryption(), 1,
695 0, NULL);
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 {
0fa6c7fa 1069 if (ippContainsString(compression_sup, "gzip"))
a469f8a5 1070 compression = "gzip";
0fa6c7fa
MS		 1071 else if (ippContainsString(compression_sup, "deflate"))
1072 compression = "deflate";
a469f8a5
MS		 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
0fa6c7fa
MS		 1357 * Send-Document. This is another dreaded compatibility hack, but
1358 * unfortunately there are enough broken printers out there that we need
1359 * this for now...
5a9febac
MS		 1360 */
1361
1362 if (version == 10)
1363 create_job = send_document = 0;
1364
7cf5915e
MS		 1365 /*
1366 * Start monitoring the printer in the background...
1367 */
1368
1369 monitor.uri = uri;
1370 monitor.hostname = hostname;
1371 monitor.user = argv[2];
1372 monitor.resource = resource;
1373 monitor.port = port;
1374 monitor.version = version;
1375 monitor.job_id = 0;
a29fd7dd 1376 monitor.get_job_attrs = get_job_attrs;
7cf5915e
MS		 1377 monitor.encryption = cupsEncryption();
1378 monitor.job_state = IPP_JOB_PENDING;
1379 monitor.printer_state = IPP_PRINTER_IDLE;
1380
dcb445bc
MS		 1381 if (create_job)
1382 {
1383 monitor.job_name = argv[3];
1384 }
1385 else
1386 {
1387 snprintf(print_job_name, sizeof(print_job_name), "%s - %s", argv[1],
1388 argv[3]);
1389 monitor.job_name = print_job_name;
1390 }
1391
7cf5915e
MS		 1392 _cupsThreadCreate((_cups_thread_func_t)monitor_printer, &monitor);
1393
ef416fc2 1394 /*
0268488e 1395 * Validate access to the printer...
ef416fc2 1396 */
1397
22c9029b 1398 while (!job_canceled && validate_job)
ef416fc2 1399 {
dcb445bc
MS		 1400 request = new_request(IPP_VALIDATE_JOB, version, uri, argv[2],
1401 monitor.job_name, num_options, options, compression,
a469f8a5
MS		 1402 copies_sup ? copies : 1, document_format, pc, ppd,
1403 media_col_sup, doc_handling_sup, print_color_mode);
b423cd4c 1404
c5b24bfa 1405 response = cupsDoRequest(http, request, resource);
ef416fc2 1406
0268488e 1407 ipp_status = cupsLastError();
ef416fc2 1408
22c9029b
MS		 1409 fprintf(stderr, "DEBUG: Validate-Job: %s (%s)\n",
1410 ippErrorString(ipp_status), cupsLastErrorString());
cc754834 1411
c5b24bfa
MS		 1412 if ((job_auth = ippFindAttribute(response, "job-authorization-uri",
1413 IPP_TAG_URI)) != NULL)
1414 num_options = cupsAddOption("job-authorization-uri",
1415 ippGetString(job_auth, 0, NULL), num_options,
1416 &options);
1417
1418 ippDelete(response);
1419
22c9029b
MS		 1420 if (job_canceled)
1421 break;
ef416fc2 1422
a469f8a5
MS		 1423 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1424 ipp_status == IPP_STATUS_ERROR_BUSY)
22c9029b 1425 {
f3c17241 1426 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
22c9029b
MS		 1427 sleep(10);
1428 }
a469f8a5
MS		 1429 else if (ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED ||
1430 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1431 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1432 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1433 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
a29fd7dd 1434 goto cleanup;
a469f8a5
MS		 1435 else if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1436 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
22c9029b 1437 {
12f89d24
MS		 1438 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1439 /* WWW-Authenticate field value */
cc754834 1440
12f89d24 1441 if (!strncmp(www_auth, "Negotiate", 9))
22c9029b 1442 auth_info_required = "negotiate";
12f89d24
MS		 1443 else if (www_auth[0])
1444 auth_info_required = "username,password";
ef416fc2 1445
22c9029b 1446 goto cleanup;
0268488e 1447 }
a469f8a5 1448 else if (ipp_status == IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED)
22c9029b 1449 {
eac3a0a0
MS		 1450 /*
1451 * This is all too common...
1452 */
1453
1454 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1455 "cups-ipp-missing-validate-job");
22c9029b
MS		 1456 break;
1457 }
a29fd7dd
MS		 1458 else if (ipp_status < IPP_REDIRECTION_OTHER_SITE ||
1459 ipp_status == IPP_BAD_REQUEST)
0268488e
MS		 1460 break;
1461 }
cc754834 1462
0268488e
MS		 1463 /*
1464 * Then issue the print-job request...
1465 */
cc754834 1466
0268488e 1467 job_id = 0;
7cf5915e 1468
0268488e
MS		 1469 while (!job_canceled && copies_remaining > 0)
1470 {
1471 /*
1472 * Check for side-channel requests...
1473 */
cc754834 1474
0268488e 1475 backendCheckSideChannel(snmp_fd, http->hostaddr);
7cf5915e 1476
0268488e
MS		 1477 /*
1478 * Build the IPP job creation request...
1479 */
d09495fa 1480
0268488e
MS		 1481 if (job_canceled)
1482 break;
ef416fc2 1483
dcb445bc
MS		 1484 request = new_request((num_files > 1 || create_job) ? IPP_CREATE_JOB :
1485 IPP_PRINT_JOB,
1486 version, uri, argv[2], monitor.job_name, num_options,
1487 options, compression, copies_sup ? copies : 1,
a469f8a5
MS		 1488 document_format, pc, ppd, media_col_sup,
1489 doc_handling_sup, print_color_mode);
ef416fc2 1490
ef416fc2 1491 /*
1492 * Do the request...
1493 */
1494
dcb445bc 1495 if (num_files > 1 || create_job)
bd7854cb 1496 response = cupsDoRequest(http, request, resource);
ef416fc2 1497 else
cc754834 1498 {
82f97232
MS		 1499 size_t length = 0; /* Length of request */
1500
1501 if (compatsize > 0)
1502 {
1503 fputs("DEBUG: Sending file using HTTP/1.0 Content-Length...\n", stderr);
1504 length = ippLength(request) + (size_t)compatsize;
1505 }
1506 else
1507 fputs("DEBUG: Sending file using HTTP/1.1 chunking...\n", stderr);
1508
1509 http_status = cupsSendRequest(http, request, resource, length);
cc754834
MS		 1510 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1511 {
c41769ff
MS		 1512 if (compression && strcmp(compression, "none"))
1513 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1514
cc754834 1515 if (num_files == 1)
dcb445bc
MS		 1516 {
1517 if ((fd = open(files[0], O_RDONLY)) < 0)
1518 {
1519 _cupsLangPrintError("ERROR", _("Unable to open print file"));
1520 return (CUPS_BACKEND_FAILED);
1521 }
1522 }
cc754834 1523 else
eac3a0a0
MS		 1524 {
1525 fd = 0;
1526 http_status = cupsWriteRequestData(http, buffer, bytes);
1527 }
cc754834 1528
83e08001
MS		 1529 while (http_status == HTTP_CONTINUE &&
1530 (!job_canceled || compatsize > 0))
cc754834 1531 {
eac3a0a0
MS		 1532 /*
1533 * Check for side-channel requests and more print data...
1534 */
cc754834 1535
eac3a0a0
MS		 1536 FD_ZERO(&input);
1537 FD_SET(fd, &input);
1538 FD_SET(snmp_fd, &input);
cc754834 1539
eac3a0a0
MS		 1540 while (select(fd > snmp_fd ? fd + 1 : snmp_fd + 1, &input, NULL, NULL,
1541 NULL) <= 0 && !job_canceled);
1542
1543 if (FD_ISSET(snmp_fd, &input))
cc754834 1544 backendCheckSideChannel(snmp_fd, http->hostaddr);
eac3a0a0
MS		 1545
1546 if (FD_ISSET(fd, &input))
1547 {
1548 if ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
1549 {
1550 fprintf(stderr, "DEBUG: Read %d bytes...\n", (int)bytes);
1551
c41769ff
MS		 1552 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1553 != HTTP_CONTINUE)
eac3a0a0
MS		 1554 break;
1555 }
1556 else if (bytes == 0 || (errno != EINTR && errno != EAGAIN))
1557 break;
cc754834
MS		 1558 }
1559 }
1560
c41769ff
MS		 1561 if (http_status == HTTP_ERROR)
1562 fprintf(stderr, "DEBUG: Error writing document data for "
1563 "Print-Job: %s\n", strerror(httpError(http)));
1564
cc754834
MS		 1565 if (num_files == 1)
1566 close(fd);
1567 }
1568
1569 response = cupsGetResponse(http, resource);
1570 ippDelete(request);
1571 }
bd7854cb 1572
1573 ipp_status = cupsLastError();
ef416fc2 1574
22c9029b 1575 fprintf(stderr, "DEBUG: %s: %s (%s)\n",
dcb445bc 1576 (num_files > 1 || create_job) ? "Create-Job" : "Print-Job",
22c9029b
MS		 1577 ippErrorString(ipp_status), cupsLastErrorString());
1578
ef416fc2 1579 if (ipp_status > IPP_OK_CONFLICT)
1580 {
1581 job_id = 0;
1582
cc754834 1583 if (job_canceled)
bd7854cb 1584 break;
1585
a469f8a5
MS		 1586 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1587 ipp_status == IPP_STATUS_ERROR_NOT_POSSIBLE ||
1588 ipp_status == IPP_STATUS_ERROR_BUSY)
ef416fc2 1589 {
f3c17241 1590 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
ef416fc2 1591 sleep(10);
22c9029b
MS		 1592
1593 if (num_files == 0)
1594 {
1595 /*
1596 * We can't re-submit when we have no files to print, so exit
1597 * immediately with the right status code...
1598 */
1599
1600 goto cleanup;
1601 }
ef416fc2 1602 }
a469f8a5
MS		 1603 else if (ipp_status == IPP_STATUS_ERROR_JOB_CANCELED ||
1604 ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED ||
6961465f 1605 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
a469f8a5
MS		 1606 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1607 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1608 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1609 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
771bd8cb 1610 goto cleanup;
ef416fc2 1611 else
68b10830
MS		 1612 {
1613 /*
1614 * Update auth-info-required as needed...
1615 */
1616
0837b7e8 1617 _cupsLangPrintFilter(stderr, "ERROR",
a469f8a5 1618 _("Print job was not accepted."));
68b10830 1619
a469f8a5
MS		 1620 if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1621 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
68b10830 1622 {
12f89d24
MS		 1623 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1624 /* WWW-Authenticate field value */
3e7fe0ca 1625
12f89d24
MS		 1626 if (!strncmp(www_auth, "Negotiate", 9))
1627 auth_info_required = "negotiate";
1628 else if (www_auth[0])
1629 auth_info_required = "username,password";
1630 }
1631 else if (ipp_status == IPP_REQUEST_VALUE)
1632 {
1633 /*
1634 * Print file is too large, abort this job...
18ecb428
MS		 1635 */
1636
12f89d24 1637 goto cleanup;
68b10830 1638 }
22c9029b
MS		 1639 else
1640 sleep(10);
1641
1642 if (num_files == 0)
1643 {
1644 /*
1645 * We can't re-submit when we have no files to print, so exit
1646 * immediately with the right status code...
1647 */
1648
1649 goto cleanup;
1650 }
68b10830 1651 }
ef416fc2 1652 }
1653 else if ((job_id_attr = ippFindAttribute(response, "job-id",
1654 IPP_TAG_INTEGER)) == NULL)
1655 {
a469f8a5 1656 fputs("DEBUG: Print job accepted - job ID unknown.\n", stderr);
eac3a0a0
MS		 1657 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1658 "cups-ipp-missing-job-id");
ef416fc2 1659 job_id = 0;
1660 }
1661 else
1662 {
3e7fe0ca 1663 password_tries = 0;
7cf5915e 1664 monitor.job_id = job_id = job_id_attr->values[0].integer;
a469f8a5 1665 fprintf(stderr, "DEBUG: Print job accepted - job ID %d.\n", job_id);
ef416fc2 1666 }
1667
bd7854cb 1668 ippDelete(response);
1669
cc754834 1670 if (job_canceled)
bd7854cb 1671 break;
1672
dcb445bc 1673 if (job_id && (num_files > 1 || create_job))
bd7854cb 1674 {
dcb445bc 1675 for (i = 0; num_files == 0 || i < num_files; i ++)
bd7854cb 1676 {
7a14d768
MS		 1677 /*
1678 * Check for side-channel requests...
1679 */
1680
1681 backendCheckSideChannel(snmp_fd, http->hostaddr);
1682
1683 /*
1684 * Send the next file in the job...
1685 */
1686
bd7854cb 1687 request = ippNewRequest(IPP_SEND_DOCUMENT);
c168a833
MS		 1688 request->request.op.version[0] = version / 10;
1689 request->request.op.version[1] = version % 10;
bd7854cb 1690
1691 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1692 NULL, uri);
1693
1694 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1695 job_id);
1696
1697 if (argv[2][0])
1698 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1699 "requesting-user-name", NULL, argv[2]);
1700
dcb445bc 1701 if ((i + 1) >= num_files)
bd7854cb 1702 ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
1703
82cc1f9a
MS		 1704 if (document_format)
1705 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1706 "document-format", NULL, document_format);
bd7854cb 1707
5a9febac
MS		 1708 if (compression)
1709 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1710 "compression", NULL, compression);
1711
cc754834
MS		 1712 fprintf(stderr, "DEBUG: Sending file %d using chunking...\n", i + 1);
1713 http_status = cupsSendRequest(http, request, resource, 0);
dcb445bc
MS		 1714 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1715 {
a469f8a5
MS		 1716 if (compression && strcmp(compression, "none"))
1717 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1718
dcb445bc
MS		 1719 if (num_files == 0)
1720 {
1721 fd = 0;
1722 http_status = cupsWriteRequestData(http, buffer, bytes);
1723 }
1724 else
1725 {
1726 if ((fd = open(files[i], O_RDONLY)) < 0)
1727 {
1728 _cupsLangPrintError("ERROR", _("Unable to open print file"));
1729 return (CUPS_BACKEND_FAILED);
1730 }
1731 }
1732 }
1733 else
1734 fd = -1;
1735
1736 if (fd >= 0)
cc754834 1737 {
82cc1f9a 1738 while (!job_canceled && http_status == HTTP_CONTINUE &&
83e08001 1739 (bytes = read(fd, buffer, sizeof(buffer))) > 0)
cc754834 1740 {
82cc1f9a
MS		 1741 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1742 != HTTP_CONTINUE)
cc754834
MS		 1743 break;
1744 else
1745 {
1746 /*
1747 * Check for side-channel requests...
1748 */
1749
1750 backendCheckSideChannel(snmp_fd, http->hostaddr);
1751 }
1752 }
1753
dcb445bc
MS		 1754 if (fd > 0)
1755 close(fd);
cc754834 1756 }
97c9a8d7 1757
c41769ff
MS		 1758 if (http_status == HTTP_ERROR)
1759 fprintf(stderr, "DEBUG: Error writing document data for "
1760 "Send-Document: %s\n", strerror(httpError(http)));
1761
cc754834
MS		 1762 ippDelete(cupsGetResponse(http, resource));
1763 ippDelete(request);
bd7854cb 1764
22c9029b
MS		 1765 fprintf(stderr, "DEBUG: Send-Document: %s (%s)\n",
1766 ippErrorString(cupsLastError()), cupsLastErrorString());
1767
bd7854cb 1768 if (cupsLastError() > IPP_OK_CONFLICT)
1769 {
1770 ipp_status = cupsLastError();
1771
0837b7e8 1772 _cupsLangPrintFilter(stderr, "ERROR",
22c9029b 1773 _("Unable to add document to print job."));
bd7854cb 1774 break;
1775 }
3e7fe0ca
MS		 1776 else
1777 {
1778 password_tries = 0;
1779
1780 if (num_files == 0 || fd < 0)
1781 break;
1782 }
bd7854cb 1783 }
1784 }
ef416fc2 1785
1786 if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
1787 {
1788 fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
d09495fa 1789 copies_remaining --;
ef416fc2 1790 }
1791 else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
a2326b5b 1792 ipp_status == IPP_NOT_POSSIBLE ||
ef416fc2 1793 ipp_status == IPP_PRINTER_BUSY)
a469f8a5
MS		 1794 {
1795 if (argc == 6)
1796 {
1797 /*
1798 * Need to reprocess the entire job; if we have a job ID, cancel the
1799 * job first...
1800 */
1801
1802 if (job_id > 0)
1803 cancel_job(http, uri, job_id, resource, argv[2], version);
1804
1805 goto cleanup;
1806 }
1f6f3dbc 1807 continue;
a469f8a5 1808 }
5a9febac
MS		 1809 else if (ipp_status == IPP_REQUEST_VALUE ||
1810 ipp_status == IPP_ERROR_JOB_CANCELED ||
1811 ipp_status == IPP_NOT_AUTHORIZED ||
a469f8a5
MS		 1812 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1813 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1814 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1815 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED ||
5a9febac
MS		 1816 ipp_status == IPP_INTERNAL_ERROR)
1817 {
1818 /*
1819 * Print file is too large, job was canceled, we need new
1820 * authentication data, or we had some sort of error...
1821 */
1822
1823 goto cleanup;
1824 }
0fa6c7fa
MS		 1825 else if (ipp_status == IPP_STATUS_ERROR_CUPS_UPGRADE_REQUIRED)
1826 {
1827 /*
1828 * Server is configured incorrectly; the policy for Create-Job and
1829 * Send-Document has to be the same (auth or no auth, encryption or
1830 * no encryption). Force the queue to stop since printing will never
1831 * work.
1832 */
1833
1834 fputs("DEBUG: The server or printer is configured incorrectly.\n",
1835 stderr);
1836 fputs("DEBUG: The policy for Create-Job and Send-Document must have the "
1837 "same authentication and encryption requirements.\n", stderr);
1838
1839 ipp_status = IPP_STATUS_ERROR_INTERNAL;
1840
1841 if (job_id > 0)
1842 cancel_job(http, uri, job_id, resource, argv[2], version);
1843
1844 goto cleanup;
1845 }
5a9febac 1846 else if (ipp_status == IPP_NOT_FOUND)
12f89d24
MS		 1847 {
1848 /*
5a9febac
MS		 1849 * Printer does not actually implement support for Create-Job/
1850 * Send-Document, so log the conformance issue and stop the printer.
12f89d24
MS		 1851 */
1852
5a9febac
MS		 1853 fputs("DEBUG: This printer claims to support Create-Job and "
1854 "Send-Document, but those operations failed.\n", stderr);
1855 fputs("DEBUG: Add '?version=1.0' to the device URI to use legacy "
1856 "compatibility mode.\n", stderr);
1857 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1858 "cups-ipp-missing-send-document");
1859
1860 ipp_status = IPP_INTERNAL_ERROR; /* Force queue to stop */
1861
12f89d24
MS		 1862 goto cleanup;
1863 }
ef416fc2 1864 else
d09495fa 1865 copies_remaining --;
ef416fc2 1866
1867 /*
1868 * Wait for the job to complete...
1869 */
1870
a29fd7dd 1871 if (!job_id || !waitjob || !get_job_attrs)
ef416fc2 1872 continue;
1873
0837b7e8 1874 _cupsLangPrintFilter(stderr, "INFO", _("Waiting for job to complete."));
ef416fc2 1875
f14324a7 1876 for (delay = _cupsNextDelay(0, &prev_delay); !job_canceled;)
ef416fc2 1877 {
7a14d768
MS		 1878 /*
1879 * Check for side-channel requests...
1880 */
1881
1882 backendCheckSideChannel(snmp_fd, http->hostaddr);
1883
0fa6c7fa
MS		 1884 /*
1885 * Check printer state...
1886 */
1887
1888 check_printer_state(http, uri, resource, argv[2], version);
1889
6961465f
MS		 1890 if (cupsLastError() <= IPP_OK_CONFLICT)
1891 password_tries = 0;
1892
ef416fc2 1893 /*
1894 * Build an IPP_GET_JOB_ATTRIBUTES request...
1895 */
1896
fa73b229 1897 request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
c168a833
MS		 1898 request->request.op.version[0] = version / 10;
1899 request->request.op.version[1] = version % 10;
ef416fc2 1900
1901 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1902 NULL, uri);
1903
1904 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1905 job_id);
1906
1907 if (argv[2][0])
1908 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1909 "requesting-user-name", NULL, argv[2]);
1910
1911 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1912 "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
1913 NULL, jattrs);
1914
1915 /*
1916 * Do the request...
1917 */
1918
f14324a7 1919 httpReconnect(http);
bd7854cb 1920 response = cupsDoRequest(http, request, resource);
1921 ipp_status = cupsLastError();
ef416fc2 1922
a29fd7dd 1923 if (ipp_status == IPP_NOT_FOUND || ipp_status == IPP_NOT_POSSIBLE)
ef416fc2 1924 {
1925 /*
1926 * Job has gone away and/or the server has no job history...
1927 */
1928
eac3a0a0
MS		 1929 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1930 "cups-ipp-missing-job-history");
ef416fc2 1931 ippDelete(response);
1932
1933 ipp_status = IPP_OK;
1934 break;
1935 }
1936
22c9029b
MS		 1937 fprintf(stderr, "DEBUG: Get-Job-Attributes: %s (%s)\n",
1938 ippErrorString(ipp_status), cupsLastErrorString());
1939
3e7fe0ca
MS		 1940 if (ipp_status <= IPP_OK_CONFLICT)
1941 password_tries = 0;
1942 else
ef416fc2 1943 {
1944 if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
1945 ipp_status != IPP_PRINTER_BUSY)
1946 {
bd7854cb 1947 ippDelete(response);
12f89d24 1948 ipp_status = IPP_OK;
ef416fc2 1949 break;
1950 }
a469f8a5
MS		 1951 else if (ipp_status == IPP_INTERNAL_ERROR)
1952 {
1953 waitjob_tries ++;
1954
1955 if (waitjob_tries > 4)
1956 {
1957 ippDelete(response);
1958 ipp_status = IPP_OK;
1959 break;
1960 }
1961 }
ef416fc2 1962 }
1963
bd7854cb 1964 if (response)
ef416fc2 1965 {
1966 if ((job_state = ippFindAttribute(response, "job-state",
1967 IPP_TAG_ENUM)) != NULL)
1968 {
07ed0e9a
MS		 1969 /*
1970 * Reflect the remote job state in the local queue...
1971 */
1972
eac3a0a0
MS		 1973 if (cups_version &&
1974 job_state->values[0].integer >= IPP_JOB_PENDING &&
07ed0e9a 1975 job_state->values[0].integer <= IPP_JOB_COMPLETED)
eac3a0a0
MS		 1976 update_reasons(NULL,
1977 remote_job_states[job_state->values[0].integer -
1978 IPP_JOB_PENDING]);
1979
1980 if ((job_sheets = ippFindAttribute(response,
1981 "job-media-sheets-completed",
1982 IPP_TAG_INTEGER)) == NULL)
1983 job_sheets = ippFindAttribute(response,
1984 "job-impressions-completed",
1985 IPP_TAG_INTEGER);
1986
1987 if (job_sheets)
1988 fprintf(stderr, "PAGE: total %d\n",
1989 job_sheets->values[0].integer);
07ed0e9a 1990
ef416fc2 1991 /*
1992 * Stop polling if the job is finished or pending-held...
1993 */
1994
b94498cf 1995 if (job_state->values[0].integer > IPP_JOB_STOPPED)
ef416fc2 1996 {
ef416fc2 1997 ippDelete(response);
1998 break;
1999 }
2000 }
a2326b5b
MS		 2001 else if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
2002 ipp_status != IPP_NOT_POSSIBLE &&
2003 ipp_status != IPP_PRINTER_BUSY)
7a0cbd5e
MS		 2004 {
2005 /*
2006 * If the printer does not return a job-state attribute, it does not
2007 * conform to the IPP specification - break out immediately and fail
2008 * the job...
2009 */
2010
eac3a0a0
MS		 2011 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
2012 "cups-ipp-missing-job-state");
7a0cbd5e
MS		 2013 ipp_status = IPP_INTERNAL_ERROR;
2014 break;
2015 }
ef416fc2 2016 }
2017
bd7854cb 2018 ippDelete(response);
ef416fc2 2019
2020 /*
f14324a7 2021 * Wait before polling again...
ef416fc2 2022 */
2023
2e4ff8af
MS		 2024 sleep(delay);
2025
f14324a7 2026 delay = _cupsNextDelay(delay, &prev_delay);
ef416fc2 2027 }
2028 }
2029
2030 /*
bd7854cb 2031 * Cancel the job as needed...
ef416fc2 2032 */
2033
f3c17241 2034 if (job_canceled > 0 && job_id > 0)
bd7854cb 2035 cancel_job(http, uri, job_id, resource, argv[2], version);
2036
2037 /*
2038 * Check the printer state and report it if necessary...
2039 */
ef416fc2 2040
321d8d57 2041 check_printer_state(http, uri, resource, argv[2], version);
ef416fc2 2042
6961465f
MS		 2043 if (cupsLastError() <= IPP_OK_CONFLICT)
2044 password_tries = 0;
2045
7a14d768
MS		 2046 /*
2047 * Collect the final page count as needed...
2048 */
2049
c8fef167 2050 if (have_supplies &&
cb7f98ee
MS		 2051 !backendSNMPSupplies(snmp_fd, &(http->addrlist->addr), &page_count,
2052 NULL) &&
7a14d768
MS		 2053 page_count > start_count)
2054 fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
2055
18ecb428
MS		 2056#ifdef HAVE_GSSAPI
2057 /*
2058 * See if we used Kerberos at all...
2059 */
2060
2061 if (http->gssctx)
2062 auth_info_required = "negotiate";
2063#endif /* HAVE_GSSAPI */
2064
ef416fc2 2065 /*
2066 * Free memory...
2067 */
2068
0268488e
MS		 2069 cleanup:
2070
2071 cupsFreeOptions(num_options, options);
f14324a7 2072 _ppdCacheDestroy(pc);
a469f8a5 2073 ppdClose(ppd);
0268488e 2074
ef416fc2 2075 httpClose(http);
2076
bd7854cb 2077 ippDelete(supported);
ef416fc2 2078
2079 /*
2080 * Remove the temporary file(s) if necessary...
2081 */
2082
82f97232
MS		 2083 if (tmpfilename[0])
2084 unlink(tmpfilename);
2085
ef416fc2 2086 /*
2087 * Return the queue status...
2088 */
2089
f14324a7 2090 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
82f97232 2091 ipp_status == IPP_AUTHENTICATION_CANCELED ||
f14324a7
MS		 2092 ipp_status <= IPP_OK_CONFLICT)
2093 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
18ecb428 2094
a469f8a5
MS		 2095 if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED)
2096 fputs("JOBSTATE: account-info-needed\n", stderr);
2097 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED)
2098 fputs("JOBSTATE: account-closed\n", stderr);
2099 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED)
2100 fputs("JOBSTATE: account-limit-reached\n", stderr);
2101 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
2102 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2103
82f97232 2104 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
6961465f 2105 ipp_status == IPP_AUTHENTICATION_CANCELED)
7ff4fea9 2106 return (CUPS_BACKEND_AUTH_REQUIRED);
6961465f
MS		 2107 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
2108 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
2109 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
2110 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
2111 return (CUPS_BACKEND_HOLD);
7a0cbd5e
MS		 2112 else if (ipp_status == IPP_INTERNAL_ERROR)
2113 return (CUPS_BACKEND_STOP);
a29fd7dd 2114 else if (ipp_status == IPP_CONFLICT)
7ff4fea9 2115 return (CUPS_BACKEND_FAILED);
a29fd7dd 2116 else if (ipp_status == IPP_REQUEST_VALUE ||
6961465f 2117 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
a29fd7dd 2118 ipp_status == IPP_DOCUMENT_FORMAT || job_canceled < 0)
12f89d24 2119 {
f3c17241
MS		 2120 if (ipp_status == IPP_REQUEST_VALUE)
2121 _cupsLangPrintFilter(stderr, "ERROR", _("Print job too large."));
a29fd7dd
MS		 2122 else if (ipp_status == IPP_DOCUMENT_FORMAT)
2123 _cupsLangPrintFilter(stderr, "ERROR",
2124 _("Printer cannot print supplied content."));
6961465f
MS		 2125 else if (ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES)
2126 _cupsLangPrintFilter(stderr, "ERROR",
2127 _("Printer cannot print with supplied options."));
f3c17241
MS		 2128 else
2129 _cupsLangPrintFilter(stderr, "ERROR", _("Print job canceled at printer."));
2130
12f89d24
MS		 2131 return (CUPS_BACKEND_CANCEL);
2132 }
771bd8cb 2133 else if (ipp_status > IPP_OK_CONFLICT && ipp_status != IPP_ERROR_JOB_CANCELED)
22c9029b 2134 return (CUPS_BACKEND_RETRY_CURRENT);
7ff4fea9
MS		 2135 else
2136 return (CUPS_BACKEND_OK);
ef416fc2 2137}
2138
2139
bd7854cb 2140/*
2141 * 'cancel_job()' - Cancel a print job.
2142 */
2143
2144static void
2145cancel_job(http_t *http, /* I - HTTP connection */
2146 const char *uri, /* I - printer-uri */
2147 int id, /* I - job-id */
2148 const char *resource, /* I - Resource path */
2149 const char *user, /* I - requesting-user-name */
2150 int version) /* I - IPP version */
2151{
2152 ipp_t *request; /* Cancel-Job request */
2153
2154
0837b7e8 2155 _cupsLangPrintFilter(stderr, "INFO", _("Canceling print job."));
bd7854cb 2156
2157 request = ippNewRequest(IPP_CANCEL_JOB);
c168a833
MS		 2158 request->request.op.version[0] = version / 10;
2159 request->request.op.version[1] = version % 10;
bd7854cb 2160
2161 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2162 NULL, uri);
2163 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", id);
2164
2165 if (user && user[0])
2166 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2167 "requesting-user-name", NULL, user);
2168
2169 /*
2170 * Do the request...
2171 */
2172
2173 ippDelete(cupsDoRequest(http, request, resource));
2174
2175 if (cupsLastError() > IPP_OK_CONFLICT)
22c9029b 2176 _cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
bd7854cb 2177}
2178
2179
ef416fc2 2180/*
7cf5915e 2181 * 'check_printer_state()' - Check the printer state.
ef416fc2 2182 */
2183
7cf5915e 2184static ipp_pstate_t /* O - Current printer-state */
fa73b229 2185check_printer_state(
2186 http_t *http, /* I - HTTP connection */
2187 const char *uri, /* I - Printer URI */
2188 const char *resource, /* I - Resource path */
2189 const char *user, /* I - Username, if any */
321d8d57
MS		 2190 int version) /* I - IPP version */
2191 {
7cf5915e
MS		 2192 ipp_t *request, /* IPP request */
2193 *response; /* IPP response */
2194 ipp_attribute_t *attr; /* Attribute in response */
2195 ipp_pstate_t printer_state = IPP_PRINTER_STOPPED;
2196 /* Current printer-state */
ef416fc2 2197
2198
2199 /*
7cf5915e 2200 * Send a Get-Printer-Attributes request and log the results...
ef416fc2 2201 */
2202
fa73b229 2203 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
c168a833
MS		 2204 request->request.op.version[0] = version / 10;
2205 request->request.op.version[1] = version % 10;
ef416fc2 2206
2207 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
7cf5915e 2208 NULL, uri);
ef416fc2 2209
2210 if (user && user[0])
2211 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
7cf5915e 2212 "requesting-user-name", NULL, user);
ef416fc2 2213
323c5de1 2214 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
7cf5915e
MS		 2215 "requested-attributes",
2216 (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
ef416fc2 2217
2218 if ((response = cupsDoRequest(http, request, resource)) != NULL)
2219 {
321d8d57 2220 report_printer_state(response);
7cf5915e
MS		 2221
2222 if ((attr = ippFindAttribute(response, "printer-state",
2223 IPP_TAG_ENUM)) != NULL)
2224 printer_state = (ipp_pstate_t)attr->values[0].integer;
2225
ef416fc2 2226 ippDelete(response);
2227 }
7cf5915e 2228
22c9029b
MS		 2229 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
2230 ippErrorString(cupsLastError()), cupsLastErrorString());
2231
7cf5915e
MS		 2232 /*
2233 * Return the printer-state value...
2234 */
2235
2236 return (printer_state);
ef416fc2 2237}
2238
2239
7cf5915e 2240/*
eac3a0a0 2241 * 'monitor_printer()' - Monitor the printer state.
7cf5915e
MS		 2242 */
2243
2244static void * /* O - Thread exit code */
2245monitor_printer(
2246 _cups_monitor_t *monitor) /* I - Monitoring data */
2247{
2248 http_t *http; /* Connection to printer */
2249 ipp_t *request, /* IPP request */
2250 *response; /* IPP response */
2251 ipp_attribute_t *attr; /* Attribute in response */
2252 int delay, /* Current delay */
f14324a7 2253 prev_delay; /* Previous delay */
dcb445bc
MS		 2254 ipp_op_t job_op; /* Operation to use */
2255 int job_id; /* Job ID */
2256 const char *job_name; /* Job name */
2257 ipp_jstate_t job_state; /* Job state */
2258 const char *job_user; /* Job originating user name */
6961465f 2259 int password_tries = 0; /* Password tries */
7cf5915e
MS		 2260
2261
2262 /*
2263 * Make a copy of the printer connection...
2264 */
2265
db8b865d
MS		 2266 http = httpConnect2(monitor->hostname, monitor->port, NULL, AF_UNSPEC,
2267 monitor->encryption, 1, 0, NULL);
f228370c 2268 httpSetTimeout(http, 30.0, timeout_cb, NULL);
3e7fe0ca
MS		 2269 if (username[0])
2270 cupsSetUser(username);
6961465f
MS		 2271
2272 cupsSetPasswordCB2((cups_password_cb2_t)password_cb, &password_tries);
7cf5915e
MS		 2273
2274 /*
2275 * Loop until the job is canceled, aborted, or completed.
2276 */
2277
f14324a7 2278 delay = _cupsNextDelay(0, &prev_delay);
7cf5915e 2279
a469f8a5
MS		 2280 monitor->job_reasons = 0;
2281
7cf5915e
MS		 2282 while (monitor->job_state < IPP_JOB_CANCELED && !job_canceled)
2283 {
2284 /*
2285 * Reconnect to the printer...
2286 */
2287
2288 if (!httpReconnect(http))
2289 {
2290 /*
2291 * Connected, so check on the printer state...
2292 */
2293
2294 monitor->printer_state = check_printer_state(http, monitor->uri,
2295 monitor->resource,
2296 monitor->user,
321d8d57 2297 monitor->version);
6961465f
MS		 2298 if (cupsLastError() <= IPP_OK_CONFLICT)
2299 password_tries = 0;
7cf5915e 2300
dcb445bc
MS		 2301 /*
2302 * Check the status of the job itself...
2303 */
7cf5915e 2304
a29fd7dd
MS		 2305 job_op = (monitor->job_id > 0 && monitor->get_job_attrs) ?
2306 IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS;
dcb445bc
MS		 2307 request = ippNewRequest(job_op);
2308 request->request.op.version[0] = monitor->version / 10;
2309 request->request.op.version[1] = monitor->version % 10;
7cf5915e 2310
dcb445bc
MS		 2311 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2312 NULL, monitor->uri);
2313 if (job_op == IPP_GET_JOB_ATTRIBUTES)
7cf5915e 2314 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
dcb445bc 2315 monitor->job_id);
7cf5915e 2316
dcb445bc
MS		 2317 if (monitor->user && monitor->user[0])
2318 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2319 "requesting-user-name", NULL, monitor->user);
7cf5915e 2320
dcb445bc
MS		 2321 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2322 "requested-attributes",
2323 (int)(sizeof(jattrs) / sizeof(jattrs[0])), NULL, jattrs);
7cf5915e 2324
dcb445bc
MS		 2325 /*
2326 * Do the request...
2327 */
7cf5915e 2328
dcb445bc 2329 response = cupsDoRequest(http, request, monitor->resource);
7cf5915e 2330
f3c17241 2331 fprintf(stderr, "DEBUG: (monitor) %s: %s (%s)\n", ippOpString(job_op),
dcb445bc 2332 ippErrorString(cupsLastError()), cupsLastErrorString());
22c9029b 2333
3e7fe0ca
MS		 2334 if (cupsLastError() <= IPP_OK_CONFLICT)
2335 password_tries = 0;
2336
dcb445bc
MS		 2337 if (job_op == IPP_GET_JOB_ATTRIBUTES)
2338 {
7cf5915e
MS		 2339 if ((attr = ippFindAttribute(response, "job-state",
2340 IPP_TAG_ENUM)) != NULL)
2341 monitor->job_state = (ipp_jstate_t)attr->values[0].integer;
2342 else
2343 monitor->job_state = IPP_JOB_COMPLETED;
dcb445bc 2344 }
12f89d24 2345 else if (response)
dcb445bc
MS		 2346 {
2347 for (attr = response->attrs; attr; attr = attr->next)
2348 {
2349 job_id = 0;
2350 job_name = NULL;
2351 job_state = IPP_JOB_PENDING;
2352 job_user = NULL;
2353
2354 while (attr && attr->group_tag != IPP_TAG_JOB)
2355 attr = attr->next;
7cf5915e 2356
dcb445bc
MS		 2357 if (!attr)
2358 break;
2359
2360 while (attr && attr->group_tag == IPP_TAG_JOB)
2361 {
2362 if (!strcmp(attr->name, "job-id") &&
2363 attr->value_tag == IPP_TAG_INTEGER)
2364 job_id = attr->values[0].integer;
2365 else if (!strcmp(attr->name, "job-name") &&
2366 (attr->value_tag == IPP_TAG_NAME ||
2367 attr->value_tag == IPP_TAG_NAMELANG))
2368 job_name = attr->values[0].string.text;
2369 else if (!strcmp(attr->name, "job-state") &&
2370 attr->value_tag == IPP_TAG_ENUM)
2371 job_state = attr->values[0].integer;
2372 else if (!strcmp(attr->name, "job-originating-user-name") &&
2373 (attr->value_tag == IPP_TAG_NAME ||
2374 attr->value_tag == IPP_TAG_NAMELANG))
2375 job_user = attr->values[0].string.text;
2376
2377 attr = attr->next;
2378 }
2379
2380 if (job_id > 0 && job_name && !strcmp(job_name, monitor->job_name) &&
2381 job_user && monitor->user && !strcmp(job_user, monitor->user))
2382 {
2383 monitor->job_id = job_id;
2384 monitor->job_state = job_state;
2385 break;
2386 }
2387
2388 if (!attr)
2389 break;
2390 }
7cf5915e
MS		 2391 }
2392
a469f8a5
MS		 2393 if ((attr = ippFindAttribute(response, "job-state-reasons",
2394 IPP_TAG_KEYWORD)) != NULL)
2395 {
2396 int i, new_reasons = 0; /* Looping var, new reasons */
2397
2398 for (i = 0; i < attr->num_values; i ++)
2399 {
2400 if (!strcmp(attr->values[i].string.text,
2401 "account-authorization-failed"))
2402 new_reasons |= _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED;
2403 else if (!strcmp(attr->values[i].string.text, "account-closed"))
2404 new_reasons |= _CUPS_JSR_ACCOUNT_CLOSED;
2405 else if (!strcmp(attr->values[i].string.text, "account-info-needed"))
2406 new_reasons |= _CUPS_JSR_ACCOUNT_INFO_NEEDED;
2407 else if (!strcmp(attr->values[i].string.text,
2408 "account-limit-reached"))
2409 new_reasons |= _CUPS_JSR_ACCOUNT_LIMIT_REACHED;
2410 else if (!strcmp(attr->values[i].string.text, "job-password-wait"))
2411 new_reasons |= _CUPS_JSR_JOB_PASSWORD_WAIT;
2412 else if (!strcmp(attr->values[i].string.text, "job-release-wait"))
2413 new_reasons |= _CUPS_JSR_JOB_RELEASE_WAIT;
2414 }
2415
2416 if (new_reasons != monitor->job_reasons)
2417 {
2418 if (new_reasons & _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED)
2419 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2420 else if (new_reasons & _CUPS_JSR_ACCOUNT_CLOSED)
2421 fputs("JOBSTATE: account-closed\n", stderr);
2422 else if (new_reasons & _CUPS_JSR_ACCOUNT_INFO_NEEDED)
2423 fputs("JOBSTATE: account-info-needed\n", stderr);
2424 else if (new_reasons & _CUPS_JSR_ACCOUNT_LIMIT_REACHED)
2425 fputs("JOBSTATE: account-limit-reached\n", stderr);
2426 else if (new_reasons & _CUPS_JSR_JOB_PASSWORD_WAIT)
2427 fputs("JOBSTATE: job-password-wait\n", stderr);
2428 else if (new_reasons & _CUPS_JSR_JOB_RELEASE_WAIT)
2429 fputs("JOBSTATE: job-release-wait\n", stderr);
2430 else
2431 fputs("JOBSTATE: job-printing\n", stderr);
2432
2433 monitor->job_reasons = new_reasons;
2434 }
2435 }
2436
dcb445bc
MS		 2437 ippDelete(response);
2438
f3c17241
MS		 2439 fprintf(stderr, "DEBUG: (monitor) job-state=%s\n",
2440 ippEnumString("job-state", monitor->job_state));
2441
2442 if (!job_canceled &&
2443 (monitor->job_state == IPP_JOB_CANCELED ||
2444 monitor->job_state == IPP_JOB_ABORTED))
2445 job_canceled = -1;
2446
7cf5915e
MS		 2447 /*
2448 * Disconnect from the printer - we'll reconnect on the next poll...
2449 */
2450
2451 _httpDisconnect(http);
2452 }
2453
2454 /*
f14324a7 2455 * Sleep for N seconds...
7cf5915e
MS		 2456 */
2457
2458 sleep(delay);
2459
f14324a7 2460 delay = _cupsNextDelay(delay, &prev_delay);
7cf5915e
MS		 2461 }
2462
dcb445bc
MS		 2463 /*
2464 * Cancel the job if necessary...
2465 */
2466
f3c17241 2467 if (job_canceled > 0 && monitor->job_id > 0)
dcb445bc
MS		 2468 if (!httpReconnect(http))
2469 cancel_job(http, monitor->uri, monitor->job_id, monitor->resource,
2470 monitor->user, monitor->version);
2471
7cf5915e
MS		 2472 /*
2473 * Cleanup and return...
2474 */
2475
2476 httpClose(http);
2477
2478 return (NULL);
2479}
2480
2481
0268488e
MS		 2482/*
2483 * 'new_request()' - Create a new print creation or validation request.
2484 */
2485
2486static ipp_t * /* O - Request data */
2487new_request(
2488 ipp_op_t op, /* I - IPP operation code */
2489 int version, /* I - IPP version number */
2490 const char *uri, /* I - printer-uri value */
2491 const char *user, /* I - requesting-user-name value */
2492 const char *title, /* I - job-name value */
2493 int num_options, /* I - Number of options to send */
2494 cups_option_t *options, /* I - Options to send */
2495 const char *compression, /* I - compression value or NULL */
c8fef167 2496 int copies, /* I - copies value or 0 */
dcb445bc 2497 const char *format, /* I - document-format value or NULL */
f14324a7 2498 _ppd_cache_t *pc, /* I - PPD cache and mapping data */
a469f8a5 2499 ppd_file_t *ppd, /* I - PPD file data */
84315f46 2500 ipp_attribute_t *media_col_sup, /* I - media-col-supported values */
a469f8a5
MS		 2501 ipp_attribute_t *doc_handling_sup, /* I - multiple-document-handling-supported values */
2502 int print_color_mode) /* I - Printer supports print-color-mode */
0268488e
MS		 2503{
2504 int i; /* Looping var */
2505 ipp_t *request; /* Request data */
2506 const char *keyword; /* PWG keyword */
2507 _pwg_size_t *size; /* PWG media size */
2508 ipp_t *media_col, /* media-col value */
2509 *media_size; /* media-size value */
2510 const char *media_source, /* media-source value */
84315f46 2511 *media_type, /* media-type value */
5a9febac
MS		 2512 *collate_str, /* multiple-document-handling value */
2513 *mandatory; /* Mandatory attributes */
a469f8a5
MS		 2514 ipp_tag_t group; /* Current group */
2515 ipp_attribute_t *attr; /* Current attribute */
2516 const char *color_attr_name; /* Supported color attribute */
2517 char buffer[1024]; /* Value buffer */
0268488e
MS		 2518
2519
2520 /*
2521 * Create the IPP request...
2522 */
2523
2524 request = ippNewRequest(op);
2525 request->request.op.version[0] = version / 10;
2526 request->request.op.version[1] = version % 10;
2527
2528 fprintf(stderr, "DEBUG: %s IPP/%d.%d\n",
2529 ippOpString(request->request.op.operation_id),
2530 request->request.op.version[0],
2531 request->request.op.version[1]);
2532
2533 /*
2534 * Add standard attributes...
2535 */
2536
2537 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2538 NULL, uri);
2539 fprintf(stderr, "DEBUG: printer-uri=\"%s\"\n", uri);
2540
2541 if (user && *user)
2542 {
2543 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2544 "requesting-user-name", NULL, user);
2545 fprintf(stderr, "DEBUG: requesting-user-name=\"%s\"\n", user);
2546 }
2547
2548 if (title && *title)
2549 {
2550 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
2551 title);
2552 fprintf(stderr, "DEBUG: job-name=\"%s\"\n", title);
2553 }
2554
a29fd7dd 2555 if (format && op != IPP_CREATE_JOB)
0268488e
MS		 2556 {
2557 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
2558 "document-format", NULL, format);
2559 fprintf(stderr, "DEBUG: document-format=\"%s\"\n", format);
2560 }
2561
2562#ifdef HAVE_LIBZ
a469f8a5 2563 if (compression && op != IPP_OP_CREATE_JOB && op != IPP_OP_VALIDATE_JOB)
0268488e
MS		 2564 {
2565 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2566 "compression", NULL, compression);
2567 fprintf(stderr, "DEBUG: compression=\"%s\"\n", compression);
2568 }
2569#endif /* HAVE_LIBZ */
2570
2571 /*
2572 * Handle options on the command-line...
2573 */
2574
2575 if (num_options > 0)
2576 {
f14324a7 2577 if (pc)
0268488e 2578 {
dcb445bc
MS		 2579 int num_finishings = 0, /* Number of finishing values */
2580 finishings[10]; /* Finishing enum values */
a469f8a5 2581 ppd_choice_t *choice; /* Marked choice */
dcb445bc 2582
0268488e
MS		 2583 /*
2584 * Send standard IPP attributes...
2585 */
2586
a469f8a5
MS		 2587 fputs("DEBUG: Adding standard IPP operation/job attributes.\n", stderr);
2588
5a9febac
MS		 2589 if (pc->password &&
2590 (keyword = cupsGetOption("job-password", num_options,
2591 options)) != NULL)
2592 {
2593 ippAddOctetString(request, IPP_TAG_OPERATION, "job-password",
2594 keyword, strlen(keyword));
a469f8a5
MS		 2595
2596 if ((keyword = cupsGetOption("job-password-encryption", num_options,
2597 options)) == NULL)
2598 keyword = "none";
2599
5a9febac 2600 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
a469f8a5 2601 "job-password-encryption", NULL, keyword);
5a9febac
MS		 2602 }
2603
2604 if (pc->account_id &&
2605 (keyword = cupsGetOption("job-account-id", num_options,
2606 options)) != NULL)
2607 ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "job-account-id",
2608 NULL, keyword);
2609
6961465f 2610 if (pc->accounting_user_id &&
5a9febac
MS		 2611 (keyword = cupsGetOption("job-accounting-user-id", num_options,
2612 options)) != NULL)
2613 ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME,
2614 "job-accounting-user-id", NULL, keyword);
2615
2616 for (mandatory = (char *)cupsArrayFirst(pc->mandatory);
2617 mandatory;
2618 mandatory = (char *)cupsArrayNext(pc->mandatory))
2619 {
2620 if (strcmp(mandatory, "copies") &&
2621 strcmp(mandatory, "destination-uris") &&
2622 strcmp(mandatory, "finishings") &&
2623 strcmp(mandatory, "job-account-id") &&
2624 strcmp(mandatory, "job-accounting-user-id") &&
2625 strcmp(mandatory, "job-password") &&
a469f8a5 2626 strcmp(mandatory, "job-password-encryption") &&
5a9febac
MS		 2627 strcmp(mandatory, "media") &&
2628 strncmp(mandatory, "media-col", 9) &&
2629 strcmp(mandatory, "multiple-document-handling") &&
2630 strcmp(mandatory, "output-bin") &&
2631 strcmp(mandatory, "print-color-mode") &&
2632 strcmp(mandatory, "print-quality") &&
2633 strcmp(mandatory, "sides") &&
2634 (keyword = cupsGetOption(mandatory, num_options, options)) != NULL)
2635 {
2636 _ipp_option_t *opt = _ippFindOption(mandatory);
2637 /* Option type */
2638 ipp_tag_t value_tag = opt ? opt->value_tag : IPP_TAG_NAME;
2639 /* Value type */
2640
2641 switch (value_tag)
2642 {
2643 case IPP_TAG_INTEGER :
2644 case IPP_TAG_ENUM :
2645 ippAddInteger(request, IPP_TAG_JOB, value_tag, mandatory,
2646 atoi(keyword));
2647 break;
2648 case IPP_TAG_BOOLEAN :
2649 ippAddBoolean(request, IPP_TAG_JOB, mandatory,
2650 !_cups_strcasecmp(keyword, "true"));
2651 break;
2652 case IPP_TAG_RANGE :
2653 {
2654 int lower, upper; /* Range */
2655
2656 if (sscanf(keyword, "%d-%d", &lower, &upper) != 2)
2657 lower = upper = atoi(keyword);
2658
2659 ippAddRange(request, IPP_TAG_JOB, mandatory, lower, upper);
2660 }
2661 break;
2662 case IPP_TAG_STRING :
2663 ippAddOctetString(request, IPP_TAG_JOB, mandatory, keyword,
2664 strlen(keyword));
2665 break;
2666 default :
2667 ippAddString(request, IPP_TAG_JOB, value_tag, mandatory,
2668 NULL, keyword);
2669 break;
2670 }
2671 }
2672 }
2673
0268488e
MS		 2674 if ((keyword = cupsGetOption("PageSize", num_options, options)) == NULL)
2675 keyword = cupsGetOption("media", num_options, options);
2676
f14324a7 2677 if ((size = _ppdCacheGetSize(pc, keyword)) != NULL)
0268488e
MS		 2678 {
2679 /*
2680 * Add a media-col value...
2681 */
2682
2683 media_size = ippNew();
2684 ippAddInteger(media_size, IPP_TAG_ZERO, IPP_TAG_INTEGER,
2685 "x-dimension", size->width);
2686 ippAddInteger(media_size, IPP_TAG_ZERO, IPP_TAG_INTEGER,
2687 "y-dimension", size->length);
2688
2689 media_col = ippNew();
2690 ippAddCollection(media_col, IPP_TAG_ZERO, "media-size", media_size);
2691
f14324a7
MS		 2692 media_source = _ppdCacheGetSource(pc, cupsGetOption("InputSlot",
2693 num_options,
2694 options));
2695 media_type = _ppdCacheGetType(pc, cupsGetOption("MediaType",
2696 num_options,
2697 options));
0268488e
MS		 2698
2699 for (i = 0; i < media_col_sup->num_values; i ++)
2700 {
2701 if (!strcmp(media_col_sup->values[i].string.text,
2702 "media-left-margin"))
2703 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
2704 "media-left-margin", size->left);
2705 else if (!strcmp(media_col_sup->values[i].string.text,
2706 "media-bottom-margin"))
2707 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
85dda01c 2708 "media-bottom-margin", size->bottom);
0268488e
MS		 2709 else if (!strcmp(media_col_sup->values[i].string.text,
2710 "media-right-margin"))
2711 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
85dda01c 2712 "media-right-margin", size->right);
0268488e
MS		 2713 else if (!strcmp(media_col_sup->values[i].string.text,
2714 "media-top-margin"))
2715 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
85dda01c 2716 "media-top-margin", size->top);
0268488e
MS		 2717 else if (!strcmp(media_col_sup->values[i].string.text,
2718 "media-source") && media_source)
2719 ippAddString(media_col, IPP_TAG_ZERO, IPP_TAG_KEYWORD,
2720 "media-source", NULL, media_source);
2721 else if (!strcmp(media_col_sup->values[i].string.text,
2722 "media-type") && media_type)
2723 ippAddString(media_col, IPP_TAG_ZERO, IPP_TAG_KEYWORD,
2724 "media-type", NULL, media_type);
2725 }
2726
2727 ippAddCollection(request, IPP_TAG_JOB, "media-col", media_col);
2728 }
2729
2730 if ((keyword = cupsGetOption("output-bin", num_options,
2731 options)) == NULL)
a469f8a5
MS		 2732 {
2733 if ((choice = ppdFindMarkedChoice(ppd, "OutputBin")) != NULL)
2734 keyword = _ppdCacheGetBin(pc, choice->choice);
2735 }
0268488e
MS		 2736
2737 if (keyword)
2738 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "output-bin",
2739 NULL, keyword);
2740
a469f8a5
MS		 2741 color_attr_name = print_color_mode ? "print-color-mode" : "output-mode";
2742
5a9febac 2743 if ((keyword = cupsGetOption("print-color-mode", num_options,
0268488e 2744 options)) != NULL)
a469f8a5 2745 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, color_attr_name,
0268488e 2746 NULL, keyword);
a469f8a5 2747 else if ((choice = ppdFindMarkedChoice(ppd, "ColorModel")) != NULL)
0268488e 2748 {
a469f8a5 2749 if (!_cups_strcasecmp(choice->choice, "Gray"))
5a9febac 2750 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
a469f8a5 2751 color_attr_name, NULL, "monochrome");
0268488e 2752 else
5a9febac 2753 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
a469f8a5 2754 color_attr_name, NULL, "color");
0268488e
MS		 2755 }
2756
2757 if ((keyword = cupsGetOption("print-quality", num_options,
2758 options)) != NULL)
2759 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2760 atoi(keyword));
a469f8a5 2761 else if ((choice = ppdFindMarkedChoice(ppd, "cupsPrintQuality")) != NULL)
0268488e 2762 {
a469f8a5 2763 if (!_cups_strcasecmp(choice->choice, "draft"))
0268488e
MS		 2764 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2765 IPP_QUALITY_DRAFT);
a469f8a5 2766 else if (!_cups_strcasecmp(choice->choice, "normal"))
0268488e
MS		 2767 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2768 IPP_QUALITY_NORMAL);
a469f8a5 2769 else if (!_cups_strcasecmp(choice->choice, "high"))
0268488e
MS		 2770 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2771 IPP_QUALITY_HIGH);
2772 }
2773
2774 if ((keyword = cupsGetOption("sides", num_options, options)) != NULL)
2775 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2776 NULL, keyword);
f14324a7 2777 else if (pc->sides_option &&
a469f8a5 2778 (choice = ppdFindMarkedChoice(ppd, pc->sides_option)) != NULL)
0268488e 2779 {
a469f8a5 2780 if (!_cups_strcasecmp(choice->choice, pc->sides_1sided))
0268488e
MS		 2781 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2782 NULL, "one-sided");
a469f8a5 2783 else if (!_cups_strcasecmp(choice->choice, pc->sides_2sided_long))
0268488e
MS		 2784 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2785 NULL, "two-sided-long-edge");
a469f8a5 2786 if (!_cups_strcasecmp(choice->choice, pc->sides_2sided_short))
0268488e
MS		 2787 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2788 NULL, "two-sided-short-edge");
2789 }
84315f46 2790
82cc1f9a
MS		 2791 if ((keyword = cupsGetOption("multiple-document-handling",
2792 num_options, options)) != NULL)
2793 {
2794 if (strstr(keyword, "uncollated"))
2795 keyword = "false";
2796 else
2797 keyword = "true";
2798 }
2799 else if ((keyword = cupsGetOption("collate", num_options,
2800 options)) == NULL)
2801 keyword = "true";
2802
2803 if (format)
2804 {
2805 if (!_cups_strcasecmp(format, "image/gif") ||
2806 !_cups_strcasecmp(format, "image/jp2") ||
2807 !_cups_strcasecmp(format, "image/jpeg") ||
2808 !_cups_strcasecmp(format, "image/png") ||
2809 !_cups_strcasecmp(format, "image/tiff") ||
2810 !_cups_strncasecmp(format, "image/x-", 8))
2811 {
2812 /*
2813 * Collation makes no sense for single page image formats...
2814 */
2815
2816 keyword = "false";
2817 }
2818 else if (!_cups_strncasecmp(format, "image/", 6) ||
2819 !_cups_strcasecmp(format, "application/vnd.cups-raster"))
2820 {
2821 /*
2822 * Multi-page image formats will have copies applied by the upstream
2823 * filters...
2824 */
2825
2826 copies = 1;
2827 }
2828 }
2829
2830 if (doc_handling_sup)
84315f46 2831 {
88f9aafc 2832 if (!_cups_strcasecmp(keyword, "true"))
84315f46
MS		 2833 collate_str = "separate-documents-collated-copies";
2834 else
2835 collate_str = "separate-documents-uncollated-copies";
eac3a0a0 2836
84315f46
MS		 2837 for (i = 0; i < doc_handling_sup->num_values; i ++)
2838 if (!strcmp(doc_handling_sup->values[i].string.text, collate_str))
2839 {
2840 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
2841 "multiple-document-handling", NULL, collate_str);
2842 break;
2843 }
3e7fe0ca
MS		 2844
2845 if (i >= doc_handling_sup->num_values)
2846 copies = 1;
84315f46 2847 }
dcb445bc
MS		 2848
2849 /*
2850 * Map finishing options...
2851 */
2852
2853 num_finishings = _ppdCacheGetFinishingValues(pc, num_options, options,
2854 (int)(sizeof(finishings) /
2855 sizeof(finishings[0])),
2856 finishings);
2857 if (num_finishings > 0)
2858 ippAddIntegers(request, IPP_TAG_JOB, IPP_TAG_ENUM, "finishings",
2859 num_finishings, finishings);
2860
2861 /*
2862 * Map FaxOut options...
2863 */
2864
2865 if ((keyword = cupsGetOption("phone", num_options, options)) != NULL)
2866 {
2867 ipp_t *destination; /* destination collection */
2868 char tel_uri[1024]; /* tel: URI */
2869
2870 destination = ippNew();
2871
2872 httpAssembleURI(HTTP_URI_CODING_ALL, tel_uri, sizeof(tel_uri), "tel",
2873 NULL, NULL, 0, keyword);
2874 ippAddString(destination, IPP_TAG_JOB, IPP_TAG_URI, "destination-uri",
2875 NULL, tel_uri);
2876
2877 if ((keyword = cupsGetOption("faxPrefix", num_options,
2878 options)) != NULL && *keyword)
2879 ippAddString(destination, IPP_TAG_JOB, IPP_TAG_TEXT,
2880 "pre-dial-string", NULL, keyword);
2881
2882 ippAddCollection(request, IPP_TAG_JOB, "destination-uris", destination);
2883 ippDelete(destination);
2884 }
0268488e
MS		 2885 }
2886 else
2887 {
2888 /*
2889 * When talking to another CUPS server, send all options...
2890 */
2891
a469f8a5
MS		 2892 fputs("DEBUG: Adding all operation/job attributes.\n", stderr);
2893 cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
a29fd7dd 2894 cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
0268488e
MS		 2895 }
2896
82cc1f9a 2897 if (copies > 1 && (!pc || copies <= pc->max_copies))
0268488e
MS		 2898 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", copies);
2899 }
2900
a469f8a5
MS		 2901 fprintf(stderr, "DEBUG: IPP/%d.%d %s #%d\n", version / 10, version % 10,
2902 ippOpString(ippGetOperation(request)), ippGetRequestId(request));
2903 for (group = IPP_TAG_ZERO, attr = ippFirstAttribute(request);
2904 attr;
2905 attr = ippNextAttribute(request))
2906 {
2907 const char *name = ippGetName(attr);
2908
2909 if (!name)
2910 {
2911 group = IPP_TAG_ZERO;
2912 continue;
2913 }
2914
2915 if (group != ippGetGroupTag(attr))
2916 {
2917 group = ippGetGroupTag(attr);
2918 fprintf(stderr, "DEBUG: ---- %s ----\n", ippTagString(group));
2919 }
2920
2921 ippAttributeString(attr, buffer, sizeof(buffer));
2922 fprintf(stderr, "DEBUG: %s %s%s %s\n", name,
2923 ippGetCount(attr) > 1 ? "1setOf " : "",
2924 ippTagString(ippGetValueTag(attr)), buffer);
2925 }
2926
2927 fprintf(stderr, "DEBUG: ---- %s ----\n", ippTagString(IPP_TAG_END));
2928
0268488e
MS		 2929 return (request);
2930}
2931
2932
ef416fc2 2933/*
2934 * 'password_cb()' - Disable the password prompt for cupsDoFileRequest().
2935 */
2936
bd7854cb 2937static const char * /* O - Password */
5a9febac
MS		 2938password_cb(const char *prompt, /* I - Prompt (not used) */
2939 http_t *http, /* I - Connection */
2940 const char *method, /* I - Request method (not used) */
2941 const char *resource, /* I - Resource path (not used) */
6961465f 2942 int *password_tries) /* I - Password tries */
ef416fc2 2943{
5a9febac
MS		 2944 char def_username[HTTP_MAX_VALUE]; /* Default username */
2945
2946
6961465f
MS		 2947 fprintf(stderr, "DEBUG: password_cb(prompt=\"%s\", http=%p, method=\"%s\", "
2948 "resource=\"%s\", password_tries=%p(%d)), password=%p\n",
2949 prompt, http, method, resource, password_tries, *password_tries,
2950 password);
3e7fe0ca 2951
ef416fc2 2952 (void)prompt;
5a9febac
MS		 2953 (void)method;
2954 (void)resource;
ef416fc2 2955
18ecb428
MS		 2956 /*
2957 * Remember that we need to authenticate...
2958 */
2959
2960 auth_info_required = "username,password";
2961
5a9febac
MS		 2962 if (httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "username",
2963 def_username))
2964 {
2965 char quoted[HTTP_MAX_VALUE * 2 + 4];
2966 /* Quoted string */
2967
2968 fprintf(stderr, "ATTR: auth-info-default=%s,\n",
2969 quote_string(def_username, quoted, sizeof(quoted)));
2970 }
2971
6961465f 2972 if (password && *password && *password_tries < 3)
76cd9e37 2973 {
6961465f 2974 (*password_tries) ++;
76cd9e37 2975
ef416fc2 2976 return (password);
76cd9e37 2977 }
ef416fc2 2978 else
2979 {
2980 /*
18ecb428 2981 * Give up after 3 tries or if we don't have a password to begin with...
ef416fc2 2982 */
2983
18ecb428 2984 return (NULL);
ef416fc2 2985 }
2986}
2987
2988
5a9febac
MS		 2989/*
2990 * 'quote_string()' - Quote a string value.
2991 */
2992
2993static const char * /* O - Quoted string */
2994quote_string(const char *s, /* I - String */
2995 char *q, /* I - Quoted string buffer */
2996 size_t qsize) /* I - Size of quoted string buffer */
2997{
2998 char *qptr, /* Pointer into string buffer */
2999 *qend; /* End of string buffer */
3000
3001
3002 qptr = q;
3003 qend = q + qsize - 5;
3004
3005 if (qend < q)
3006 {
3007 *q = '\0';
3008 return (q);
3009 }
3010
3011 *qptr++ = '\'';
3012 *qptr++ = '\"';
3013
3014 while (*s && qptr < qend)
3015 {
3016 if (*s == '\\' || *s == '\"' || *s == '\'')
3017 {
3018 if (q < (qend - 3))
3019 {
3020 *qptr++ = '\\';
3021 *qptr++ = '\\';
3022 *qptr++ = '\\';
3023 }
3024 else
3025 break;
3026 }
3027
3028 *qptr++ = *s++;
3029 }
3030
3031 *qptr++ = '\"';
3032 *qptr++ = '\'';
3033 *qptr = '\0';
3034
3035 return (q);
3036}
3037
3038
1f0275e3
MS		 3039/*
3040 * 'report_attr()' - Report an IPP attribute value.
3041 */
3042
3043static void
3044report_attr(ipp_attribute_t *attr) /* I - Attribute */
3045{
eac3a0a0
MS		 3046 int i; /* Looping var */
3047 char value[1024], /* Value string */
5a9febac 3048 *valptr; /* Pointer into value string */
eac3a0a0 3049 const char *cached; /* Cached attribute */
1f0275e3
MS		 3050
3051
3052 /*
3053 * Convert the attribute values into quoted strings...
3054 */
3055
3056 for (i = 0, valptr = value;
3057 i < attr->num_values && valptr < (value + sizeof(value) - 10);
3058 i ++)
3059 {
3060 if (i > 0)
3061 *valptr++ = ',';
3062
3063 switch (attr->value_tag)
3064 {
3065 case IPP_TAG_INTEGER :
3066 case IPP_TAG_ENUM :
3067 snprintf(valptr, sizeof(value) - (valptr - value), "%d",
3068 attr->values[i].integer);
3069 valptr += strlen(valptr);
3070 break;
3071
3072 case IPP_TAG_TEXT :
3073 case IPP_TAG_NAME :
3074 case IPP_TAG_KEYWORD :
5a9febac
MS		 3075 quote_string(attr->values[i].string.text, valptr,
3076 value + sizeof(value) - valptr);
3077 valptr += strlen(valptr);
1f0275e3
MS		 3078 break;
3079
3080 default :
3081 /*
3082 * Unsupported value type...
3083 */
3084
3085 return;
3086 }
3087 }
3088
3089 *valptr = '\0';
3090
321d8d57
MS		 3091 _cupsMutexLock(&report_mutex);
3092
eac3a0a0
MS		 3093 if ((cached = cupsGetOption(attr->name, num_attr_cache,
3094 attr_cache)) == NULL || strcmp(cached, value))
3095 {
3096 /*
3097 * Tell the scheduler about the new values...
3098 */
1f0275e3 3099
eac3a0a0
MS		 3100 num_attr_cache = cupsAddOption(attr->name, value, num_attr_cache,
3101 &attr_cache);
3102 fprintf(stderr, "ATTR: %s=%s\n", attr->name, value);
3103 }
321d8d57
MS		 3104
3105 _cupsMutexUnlock(&report_mutex);
1f0275e3
MS		 3106}
3107
3108
ef416fc2 3109/*
3110 * 'report_printer_state()' - Report the printer state.
3111 */
3112
321d8d57
MS		 3113static void
3114report_printer_state(ipp_t *ipp) /* I - IPP response */
ef416fc2 3115{
7cf5915e
MS		 3116 ipp_attribute_t *pa, /* printer-alert */
3117 *pam, /* printer-alert-message */
3118 *psm, /* printer-state-message */
1f0275e3
MS		 3119 *reasons, /* printer-state-reasons */
3120 *marker; /* marker-* attributes */
7cf5915e
MS		 3121 char value[1024], /* State/message string */
3122 *valptr; /* Pointer into string */
c8fef167
MS		 3123 static int ipp_supplies = -1;
3124 /* Report supply levels? */
ef416fc2 3125
3126
7cf5915e
MS		 3127 /*
3128 * Report alerts and messages...
3129 */
3130
3131 if ((pa = ippFindAttribute(ipp, "printer-alert", IPP_TAG_TEXT)) != NULL)
3132 report_attr(pa);
3133
3134 if ((pam = ippFindAttribute(ipp, "printer-alert-message",
3135 IPP_TAG_TEXT)) != NULL)
3136 report_attr(pam);
3137
323c5de1 3138 if ((psm = ippFindAttribute(ipp, "printer-state-message",
3139 IPP_TAG_TEXT)) != NULL)
7cf5915e
MS		 3140 {
3141 char *ptr; /* Pointer into message */
3142
3143
3144 strlcpy(value, "INFO: ", sizeof(value));
3145 for (ptr = psm->values[0].string.text, valptr = value + 6;
3146 *ptr && valptr < (value + sizeof(value) - 6);
3147 ptr ++)
3148 {
3149 if (*ptr < ' ' && *ptr > 0 && *ptr != '\t')
3150 {
3151 /*
3152 * Substitute "<XX>" for the control character; sprintf is safe because
3153 * we always leave 6 chars free at the end...
3154 */
3155
3156 sprintf(valptr, "<%02X>", *ptr);
3157 valptr += 4;
3158 }
3159 else
3160 *valptr++ = *ptr;
3161 }
3162
3163 *valptr++ = '\n';
e60ec91f 3164 *valptr = '\0';
7cf5915e
MS		 3165
3166 fputs(value, stderr);
3167 }
3168
3169 /*
3170 * Now report printer-state-reasons, filtering out some of the reasons we never
3171 * want to set...
3172 */
323c5de1 3173
ef416fc2 3174 if ((reasons = ippFindAttribute(ipp, "printer-state-reasons",
3175 IPP_TAG_KEYWORD)) == NULL)
321d8d57 3176 return;
ef416fc2 3177
eac3a0a0 3178 update_reasons(reasons, NULL);
ef416fc2 3179
1f0275e3
MS		 3180 /*
3181 * Relay the current marker-* attribute values...
3182 */
3183
c8fef167
MS		 3184 if (ipp_supplies < 0)
3185 {
3186 ppd_file_t *ppd; /* PPD file */
3187 ppd_attr_t *ppdattr; /* Attribute in PPD file */
3188
3189 if ((ppd = ppdOpenFile(getenv("PPD"))) != NULL &&
3190 (ppdattr = ppdFindAttr(ppd, "cupsIPPSupplies", NULL)) != NULL &&
88f9aafc 3191 ppdattr->value && _cups_strcasecmp(ppdattr->value, "true"))
c8fef167
MS		 3192 ipp_supplies = 0;
3193 else
3194 ipp_supplies = 1;
3195
3196 ppdClose(ppd);
3197 }
3198
3199 if (ipp_supplies > 0)
3200 {
3201 if ((marker = ippFindAttribute(ipp, "marker-colors", IPP_TAG_NAME)) != NULL)
3202 report_attr(marker);
3203 if ((marker = ippFindAttribute(ipp, "marker-high-levels",
3204 IPP_TAG_INTEGER)) != NULL)
3205 report_attr(marker);
3206 if ((marker = ippFindAttribute(ipp, "marker-levels",
3207 IPP_TAG_INTEGER)) != NULL)
3208 report_attr(marker);
3209 if ((marker = ippFindAttribute(ipp, "marker-low-levels",
3210 IPP_TAG_INTEGER)) != NULL)
3211 report_attr(marker);
3212 if ((marker = ippFindAttribute(ipp, "marker-message",
3213 IPP_TAG_TEXT)) != NULL)
3214 report_attr(marker);
3215 if ((marker = ippFindAttribute(ipp, "marker-names", IPP_TAG_NAME)) != NULL)
3216 report_attr(marker);
3217 if ((marker = ippFindAttribute(ipp, "marker-types",
3218 IPP_TAG_KEYWORD)) != NULL)
3219 report_attr(marker);
3220 }
ef416fc2 3221}
3222
3223
eac3a0a0
MS		 3224#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
3225/*
3226 * 'run_as_user()' - Run the IPP backend as the printing user.
3227 *
3228 * This function uses an XPC-based user agent to run the backend as the printing
3229 * user. We need to do this in order to have access to the user's Kerberos
3230 * credentials.
3231 */
3232
3233static int /* O - Exit status */
37e7e6e0 3234run_as_user(char *argv[], /* I - Command-line arguments */
eac3a0a0
MS		 3235 uid_t uid, /* I - User ID */
3236 const char *device_uri, /* I - Device URI */
3237 int fd) /* I - File to print */
3238{
88f9aafc 3239 const char *auth_negotiate;/* AUTH_NEGOTIATE env var */
eac3a0a0
MS		 3240 xpc_connection_t conn; /* Connection to XPC service */
3241 xpc_object_t request; /* Request message dictionary */
3242 __block xpc_object_t response; /* Response message dictionary */
3243 dispatch_semaphore_t sem; /* Semaphore for waiting for response */
3244 int status = CUPS_BACKEND_FAILED;
3245 /* Status of request */
3246
3247
3248 fprintf(stderr, "DEBUG: Running IPP backend as UID %d.\n", (int)uid);
3249
3250 /*
3251 * Connect to the user agent for the specified UID...
3252 */
3253
3254 conn = xpc_connection_create_mach_service(kPMPrintUIToolAgent,
3255 dispatch_get_global_queue(0, 0), 0);
3256 if (!conn)
3257 {
3258 _cupsLangPrintFilter(stderr, "ERROR",
3259 _("Unable to start backend process."));
3260 fputs("DEBUG: Unable to create connection to agent.\n", stderr);
3261 goto cleanup;
3262 }
3263
3264 xpc_connection_set_event_handler(conn,
3265 ^(xpc_object_t event)
3266 {
3267 xpc_type_t messageType = xpc_get_type(event);
3268
3269 if (messageType == XPC_TYPE_ERROR)
3270 {
3271 if (event == XPC_ERROR_CONNECTION_INTERRUPTED)
3272 fprintf(stderr, "DEBUG: Interrupted connection to service %s.\n",
3273 xpc_connection_get_name(conn));
3274 else if (event == XPC_ERROR_CONNECTION_INVALID)
3275 fprintf(stderr, "DEBUG: Connection invalid for service %s.\n",
3276 xpc_connection_get_name(conn));
3277 else
3278 fprintf(stderr, "DEBUG: Unxpected error for service %s: %s\n",
3279 xpc_connection_get_name(conn),
3280 xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION));
3281 }
3282 });
3283 xpc_connection_set_target_uid(conn, uid);
3284 xpc_connection_resume(conn);
3285
3286 /*
3287 * Try starting the backend...
3288 */
3289
3290 request = xpc_dictionary_create(NULL, NULL, 0);
3291 xpc_dictionary_set_int64(request, "command", kPMStartJob);
3292 xpc_dictionary_set_string(request, "device-uri", device_uri);
3293 xpc_dictionary_set_string(request, "job-id", argv[1]);
3294 xpc_dictionary_set_string(request, "user", argv[2]);
3295 xpc_dictionary_set_string(request, "title", argv[3]);
3296 xpc_dictionary_set_string(request, "copies", argv[4]);
3297 xpc_dictionary_set_string(request, "options", argv[5]);
3298 xpc_dictionary_set_string(request, "auth-info-required",
3299 getenv("AUTH_INFO_REQUIRED"));
88f9aafc
MS		 3300 if ((auth_negotiate = getenv("AUTH_NEGOTIATE")) != NULL)
3301 xpc_dictionary_set_string(request, "auth-negotiate", auth_negotiate);
eac3a0a0
MS		 3302 xpc_dictionary_set_fd(request, "stdin", fd);
3303 xpc_dictionary_set_fd(request, "stderr", 2);
3304 xpc_dictionary_set_fd(request, "side-channel", CUPS_SC_FD);
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 child_pid = xpc_dictionary_get_int64(response, "child-pid");
3328
3329 xpc_release(response);
3330
3331 if (child_pid)
3332 fprintf(stderr, "DEBUG: Child PID=%d.\n", child_pid);
3333 else
3334 {
3335 _cupsLangPrintFilter(stderr, "ERROR",
3336 _("Unable to start backend process."));
3337 fputs("DEBUG: No child PID.\n", stderr);
3338 goto cleanup;
3339 }
3340 }
3341 else
3342 {
3343 _cupsLangPrintFilter(stderr, "ERROR",
3344 _("Unable to start backend process."));
3345 fputs("DEBUG: No reply from agent.\n", stderr);
3346 goto cleanup;
3347 }
3348
3349 /*
3350 * Then wait for the backend to finish...
3351 */
3352
3353 request = xpc_dictionary_create(NULL, NULL, 0);
3354 xpc_dictionary_set_int64(request, "command", kPMWaitForJob);
3355 xpc_dictionary_set_fd(request, "stderr", 2);
3356
3357 sem = dispatch_semaphore_create(0);
3358 response = NULL;
3359
3360 xpc_connection_send_message_with_reply(conn, request,
3361 dispatch_get_global_queue(0,0),
3362 ^(xpc_object_t reply)
3363 {
3364 /* Save the response and wake up */
3365 if (xpc_get_type(reply)
3366 == XPC_TYPE_DICTIONARY)
3367 response = xpc_retain(reply);
3368
3369 dispatch_semaphore_signal(sem);
3370 });
3371
3372 dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
3373 xpc_release(request);
3374 dispatch_release(sem);
3375
3376 if (response)
3377 {
3378 status = xpc_dictionary_get_int64(response, "status");
3379
3380 if (status == SIGTERM || status == SIGKILL || status == SIGPIPE)
3381 {
3382 fprintf(stderr, "DEBUG: Child terminated on signal %d.\n", status);
3383 status = CUPS_BACKEND_FAILED;
3384 }
3385 else if (WIFSIGNALED(status))
3386 {
3387 fprintf(stderr, "DEBUG: Child crashed on signal %d.\n", status);
3388 status = CUPS_BACKEND_STOP;
3389 }
3390 else if (WIFEXITED(status))
3391 {
3392 status = WEXITSTATUS(status);
3393 fprintf(stderr, "DEBUG: Child exited with status %d.\n", status);
3394 }
3395
3396 xpc_release(response);
3397 }
3398 else
3399 _cupsLangPrintFilter(stderr, "ERROR",
3400 _("Unable to get backend exit status."));
3401
3402 cleanup:
3403
3404 if (conn)
3405 {
3406 xpc_connection_suspend(conn);
3407 xpc_connection_cancel(conn);
3408 xpc_release(conn);
3409 }
3410
3411 return (status);
3412}
3413#endif /* HAVE_GSSAPI && HAVE_XPC */
3414
3415
ef416fc2 3416/*
3417 * 'sigterm_handler()' - Handle 'terminate' signals that stop the backend.
3418 */
3419
3420static void
3421sigterm_handler(int sig) /* I - Signal */
3422{
3423 (void)sig; /* remove compiler warnings... */
3424
f3c17241
MS		 3425 write(2, "DEBUG: Got SIGTERM.\n", 20);
3426
eac3a0a0
MS		 3427#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
3428 if (child_pid)
3429 {
3430 kill(child_pid, sig);
3431 child_pid = 0;
3432 }
3433#endif /* HAVE_GSSAPI && HAVE_XPC */
3434
cc754834 3435 if (!job_canceled)
bd7854cb 3436 {
3437 /*
eac3a0a0 3438 * Flag that the job should be canceled...
bd7854cb 3439 */
3440
f3c17241
MS		 3441 write(2, "DEBUG: job_canceled = 1.\n", 25);
3442
cc754834 3443 job_canceled = 1;
bd7854cb 3444 return;
3445 }
3446
82f97232
MS		 3447 /*
3448 * The scheduler already tried to cancel us once, now just terminate
eac3a0a0 3449 * after removing our temp file!
82f97232
MS		 3450 */
3451
3452 if (tmpfilename[0])
3453 unlink(tmpfilename);
3454
ef416fc2 3455 exit(1);
3456}
3457
3458
f228370c
MS		 3459/*
3460 * 'timeout_cb()' - Handle HTTP timeouts.
3461 */
3462
3463static int /* O - 1 to continue, 0 to cancel */
3464timeout_cb(http_t *http, /* I - Connection to server (unused) */
3465 void *user_data) /* I - User data (unused) */
3466{
3467 (void)http;
3468 (void)user_data;
3469
3470 return (!job_canceled);
3471}
3472
3473
ef416fc2 3474/*
eac3a0a0
MS		 3475 * 'update_reasons()' - Update the printer-state-reasons values.
3476 */
3477
3478static void
3479update_reasons(ipp_attribute_t *attr, /* I - printer-state-reasons or NULL */
3480 const char *s) /* I - STATE: string or NULL */
3481{
3482 char op; /* Add (+), remove (-), replace (\0) */
3483 cups_array_t *new_reasons; /* New reasons array */
3484 char *reason, /* Current reason */
3485 add[2048], /* Reasons added string */
3486 *addptr, /* Pointer into add string */
3487 rem[2048], /* Reasons removed string */
3488 *remptr; /* Pointer into remove string */
3489 const char *addprefix, /* Current add string prefix */
3490 *remprefix; /* Current remove string prefix */
3491
3492
3493 fprintf(stderr, "DEBUG: update_reasons(attr=%d(%s%s), s=\"%s\")\n",
3494 attr ? attr->num_values : 0, attr ? attr->values[0].string.text : "",
3495 attr && attr->num_values > 1 ? ",..." : "", s ? s : "(null)");
3496
3497 /*
3498 * Create an array of new reason keyword strings...
3499 */
3500
3501 if (attr)
3502 {
3503 int i; /* Looping var */
3504
3505 new_reasons = cupsArrayNew((cups_array_func_t)strcmp, NULL);
3506 op = '\0';
3507
3508 for (i = 0; i < attr->num_values; i ++)
3509 {
3510 reason = attr->values[i].string.text;
3511
3512 if (strcmp(reason, "none") &&
3513 strcmp(reason, "none-report") &&
3514 strcmp(reason, "paused") &&
a4845881 3515 strncmp(reason, "spool-area-full", 15) &&
eac3a0a0
MS		 3516 strcmp(reason, "com.apple.print.recoverable-warning") &&
3517 strncmp(reason, "cups-", 5))
3518 cupsArrayAdd(new_reasons, reason);
3519 }
3520 }
3521 else if (s)
3522 {
3523 if (*s == '+' || *s == '-')
3524 op = *s++;
3525 else
3526 op = '\0';
3527
5a9febac 3528 new_reasons = _cupsArrayNewStrings(s, ',');
eac3a0a0
MS		 3529 }
3530 else
3531 return;
3532
3533 /*
3534 * Compute the changes...
3535 */
3536
3537 add[0] = '\0';
3538 addprefix = "STATE: +";
3539 addptr = add;
3540 rem[0] = '\0';
3541 remprefix = "STATE: -";
3542 remptr = rem;
3543
3544 fprintf(stderr, "DEBUG2: op='%c', new_reasons=%d, state_reasons=%d\n",
3545 op ? op : ' ', cupsArrayCount(new_reasons),
3546 cupsArrayCount(state_reasons));
3547
321d8d57 3548 _cupsMutexLock(&report_mutex);
eac3a0a0
MS		 3549
3550 if (op == '+')
3551 {
3552 /*
3553 * Add reasons...
3554 */
3555
3556 for (reason = (char *)cupsArrayFirst(new_reasons);
3557 reason;
3558 reason = (char *)cupsArrayNext(new_reasons))
3559 {
3560 if (!cupsArrayFind(state_reasons, reason))
3561 {
3562 if (!strncmp(reason, "cups-remote-", 12))
3563 {
3564 /*
3565 * If we are setting cups-remote-xxx, remove all other cups-remote-xxx
3566 * keywords...
3567 */
3568
3569 char *temp; /* Current reason in state_reasons */
3570
3571 cupsArraySave(state_reasons);
3572
3573 for (temp = (char *)cupsArrayFirst(state_reasons);
3574 temp;
3575 temp = (char *)cupsArrayNext(state_reasons))
3576 if (!strncmp(temp, "cups-remote-", 12))
3577 {
3578 snprintf(remptr, sizeof(rem) - (remptr - rem), "%s%s", remprefix,
3579 temp);
3580 remptr += strlen(remptr);
3581 remprefix = ",";
3582
3583 cupsArrayRemove(state_reasons, temp);
3584 break;
3585 }
3586
3587 cupsArrayRestore(state_reasons);
3588 }
3589
3590 cupsArrayAdd(state_reasons, reason);
3591
3592 snprintf(addptr, sizeof(add) - (addptr - add), "%s%s", addprefix,
3593 reason);
3594 addptr += strlen(addptr);
3595 addprefix = ",";
3596 }
3597 }
3598 }
3599 else if (op == '-')
3600 {
3601 /*
3602 * Remove reasons...
3603 */
3604
3605 for (reason = (char *)cupsArrayFirst(new_reasons);
3606 reason;
3607 reason = (char *)cupsArrayNext(new_reasons))
3608 {
3609 if (cupsArrayFind(state_reasons, reason))
3610 {
3611 snprintf(remptr, sizeof(rem) - (remptr - rem), "%s%s", remprefix,
3612 reason);
3613 remptr += strlen(remptr);
3614 remprefix = ",";
3615
3616 cupsArrayRemove(state_reasons, reason);
3617 }
3618 }
3619 }
3620 else
3621 {
3622 /*
3623 * Replace reasons...
3624 */
3625
3626 for (reason = (char *)cupsArrayFirst(state_reasons);
3627 reason;
3628 reason = (char *)cupsArrayNext(state_reasons))
3629 {
3630 if (strncmp(reason, "cups-", 5) && !cupsArrayFind(new_reasons, reason))
3631 {
3632 snprintf(remptr, sizeof(rem) - (remptr - rem), "%s%s", remprefix,
3633 reason);
3634 remptr += strlen(remptr);
3635 remprefix = ",";
3636
3637 cupsArrayRemove(state_reasons, reason);
3638 }
3639 }
3640
3641 for (reason = (char *)cupsArrayFirst(new_reasons);
3642 reason;
3643 reason = (char *)cupsArrayNext(new_reasons))
3644 {
3645 if (!cupsArrayFind(state_reasons, reason))
3646 {
3647 cupsArrayAdd(state_reasons, reason);
3648
3649 snprintf(addptr, sizeof(add) - (addptr - add), "%s%s", addprefix,
3650 reason);
3651 addptr += strlen(addptr);
3652 addprefix = ",";
3653 }
3654 }
3655 }
3656
321d8d57 3657 _cupsMutexUnlock(&report_mutex);
eac3a0a0
MS		 3658
3659 /*
3660 * Report changes and return...
3661 */
3662
3663 if (add[0] && rem[0])
3664 fprintf(stderr, "%s\n%s\n", add, rem);
3665 else if (add[0])
3666 fprintf(stderr, "%s\n", add);
3667 else if (rem[0])
3668 fprintf(stderr, "%s\n", rem);
3669}
3670
3671/*
3672 * End of "$Id: ipp.c 9759 2011-05-11 03:24:33Z mike $".
ef416fc2 3673 */
Unnamed repository; edit this file 'description' to name the repository.