]> 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
Changelog.
[thirdparty/cups.git] / backend / ipp.c
CommitLineData
c8f9565c 1/*
c9d3f842 2 * "$Id$"
c8f9565c 3 *
6875feac 4 * IPP backend for CUPS.
c8f9565c 5 *
4febe238 6 * Copyright 2007-2013 by Apple Inc.
bb3ff448 7 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
c8f9565c 8 *
9 * These coded instructions, statements, and computer programs are the
4e8d321f 10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
c8f9565c 12 * "LICENSE" which should have been included with this file. If this
4e8d321f 13 * file is missing or damaged, see the license at "http://www.cups.org/".
c8f9565c 14 *
dab1a4d8 15 * This file is subject to the Apple OS-Developed Software exception.
16 *
c8f9565c 17 * Contents:
18 *
9ef7dccf 19 * main() - Send a file to the printer or server.
20 * cancel_job() - Cancel a print job.
b9738d7c 21 * check_printer_state() - Check the printer state.
9ef7dccf 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.
d1c2727f 29 * report_printer_state() - Report the printer state.
9ef7dccf 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.
c8f9565c 34 */
35
36/*
37 * Include necessary headers.
38 */
39
eab5b04e 40#include "backend-private.h"
7b1ef0fc 41#include <cups/array-private.h>
c8f9565c 42#include <sys/types.h>
43#include <sys/stat.h>
1c85e5c0 44#include <sys/wait.h>
959a6a28 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
9b1db43b 50# ifdef HAVE_XPC_PRIVATE_H
51# include <xpc/private.h>
52# else
959a6a28 53extern void xpc_connection_set_target_uid(xpc_connection_t connection,
54 uid_t uid);
9b1db43b 55# endif /* HAVE_XPC_PRIVATE_H */
959a6a28 56#endif /* HAVE_GSSAPI && HAVE_XPC */
c8f9565c 57
b9738d7c 58
4ab5ee04 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
b9738d7c 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 */
a2a8bd6a 83 job_id, /* Job ID for submitted job */
4ab5ee04 84 job_reasons, /* Job state reasons bits */
a2a8bd6a 85 get_job_attrs; /* Support Get-Job-Attributes? */
5ed93a63 86 const char *job_name; /* Job name for submitted job */
b9738d7c 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
8f4595eb 93/*
94 * Globals...
95 */
96
7b1ef0fc 97static const char *auth_info_required;
4233257e 98 /* New auth-info-required value */
959a6a28 99#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
7b1ef0fc 100static int child_pid = 0; /* Child process ID */
959a6a28 101#endif /* HAVE_GSSAPI && HAVE_XPC */
b9738d7c 102static const char * const jattrs[] = /* Job attributes we want */
103{
36f9d0f8 104 "job-id",
f8c0cc95 105 "job-impressions-completed",
b9738d7c 106 "job-media-sheets-completed",
5ed93a63 107 "job-name",
108 "job-originating-user-name",
b9738d7c 109 "job-state",
110 "job-state-reasons"
111};
7b1ef0fc 112static int job_canceled = 0;
113 /* Job cancelled? */
f92e446a 114static char username[256] = "",
115 /* Username for device URI */
116 *password = NULL;
7b1ef0fc 117 /* Password for device URI */
b9738d7c 118static const char * const pattrs[] = /* Printer attributes we want */
119{
3c16b2a3 120#ifdef HAVE_LIBZ
121 "compression-supported",
122#endif /* HAVE_LIBZ */
b9738d7c 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",
adbcb02a 134 "multiple-document-handling-supported",
e2fe9bbd 135 "operations-supported",
b9738d7c 136 "printer-alert",
137 "printer-alert-description",
138 "printer-is-accepting-jobs",
139 "printer-state",
140 "printer-state-message",
2a46c0fe 141 "printer-state-reasons"
b9738d7c 142};
6c1b8723 143static const char * const remote_job_states[] =
144{ /* Remote job state keywords */
dbc9263b 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"
6c1b8723 152};
6ef97027 153static _cups_mutex_t report_mutex = _CUPS_MUTEX_INITIALIZER;
7b1ef0fc 154 /* Mutex to control access */
6ef97027 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 */
7b1ef0fc 160static char tmpfilename[1024] = "";
161 /* Temporary spool file name */
8f4595eb 162
163
b5cb0608 164/*
165 * Local functions...
166 */
167
b9738d7c 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,
4a241564 173 const char *user, int version);
b9738d7c 174static void *monitor_printer(_cups_monitor_t *monitor);
2ec940b5 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,
8211508e 179 const char *format, _ppd_cache_t *pc,
2d3aac27 180 ppd_file_t *ppd,
adbcb02a 181 ipp_attribute_t *media_col_sup,
0d77fe26 182 ipp_attribute_t *doc_handling_sup,
183 int print_color_mode);
9ef7dccf 184static const char *password_cb(const char *prompt, http_t *http,
185 const char *method, const char *resource,
478d9bb3 186 int *user_data);
9ef7dccf 187static const char *quote_string(const char *s, char *q, size_t qsize);
b9738d7c 188static void report_attr(ipp_attribute_t *attr);
4a241564 189static void report_printer_state(ipp_t *ipp);
959a6a28 190#if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
d8f880d0 191static int run_as_user(char *argv[], uid_t uid,
959a6a28 192 const char *device_uri, int fd);
193#endif /* HAVE_GSSAPI && HAVE_XPC */
b9738d7c 194static void sigterm_handler(int sig);
1179bc03 195static int timeout_cb(http_t *http, void *user_data);
7b1ef0fc 196static void update_reasons(ipp_attribute_t *attr, const char *s);
a684a3b0 197
b5cb0608 198
c8f9565c 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
74ef1ffb 207int /* O - Exit status */
072c4872 208main(int argc, /* I - Number of command-line args */
74ef1ffb 209 char *argv[]) /* I - Command-line arguments */
c8f9565c 210{
74ef1ffb 211 int i; /* Looping var */
cad2b75f 212 int send_options; /* Send job options? */
74ef1ffb 213 int num_options; /* Number of printer options */
214 cups_option_t *options; /* Printer options */
cda2b561 215 const char *device_uri; /* Device URI */
9fa9ba8f 216 char scheme[255], /* Scheme in URI */
74ef1ffb 217 hostname[1024], /* Hostname */
74ef1ffb 218 resource[1024], /* Resource info (printer name) */
a0c0bbe7 219 addrname[256], /* Address name */
74ef1ffb 220 *optptr, /* Pointer to URI options */
abd1f85f 221 *name, /* Name of option */
222 *value, /* Value of option */
223 sep; /* Separator character */
478d9bb3 224 int password_tries = 0; /* Password tries */
cce0044f 225 http_addrlist_t *addrlist; /* Address of printer */
bd08ee89 226 int snmp_enabled = 1; /* Is SNMP enabled? */
eab5b04e 227 int snmp_fd, /* SNMP socket */
228 start_count, /* Page count via SNMP at start */
6bffe4a6 229 page_count, /* Page count via SNMP */
230 have_supplies; /* Printer supports supply levels? */
072c4872 231 int num_files; /* Number of files to print */
940afb4b 232 char **files, /* Files to print */
233 *compatfile = NULL; /* Compatibility filename */
234 off_t compatsize = 0; /* Size of compatibility file */
74ef1ffb 235 int port; /* Port number (not used) */
cce0044f 236 char portname[255]; /* Port name */
74ef1ffb 237 char uri[HTTP_MAX_URI]; /* Updated URI without user/pass */
5ed93a63 238 char print_job_name[1024]; /* Update job-name for Print-Job */
6875feac 239 http_status_t http_status; /* Status of HTTP request */
74ef1ffb 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 */
ff0295f0 245 time_t start_time; /* Time of first connect */
ff0295f0 246 int contimeout; /* Connection timeout */
fc596e79 247 int delay, /* Delay for retries */
248 prev_delay; /* Previous delay */
2ec940b5 249 const char *compression; /* Compression mode */
250 int waitjob, /* Wait for job complete? */
24b2889c 251 waitjob_tries = 0, /* Number of times we've waited */
74ef1ffb 252 waitprinter; /* Wait for printer ready? */
b9738d7c 253 _cups_monitor_t monitor; /* Monitoring data */
74ef1ffb 254 ipp_attribute_t *job_id_attr; /* job-id attribute */
255 int job_id; /* job-id value */
072c4872 256 ipp_attribute_t *job_sheets; /* job-media-sheets-completed */
257 ipp_attribute_t *job_state; /* job-state */
3c16b2a3 258#ifdef HAVE_LIBZ
259 ipp_attribute_t *compression_sup; /* compression-supported */
260#endif /* HAVE_LIBZ */
072c4872 261 ipp_attribute_t *copies_sup; /* copies-supported */
6875feac 262 ipp_attribute_t *cups_version; /* cups-version */
072c4872 263 ipp_attribute_t *format_sup; /* document-format-supported */
971b2b61 264 ipp_attribute_t *job_auth; /* job-authorization-uri */
6875feac 265 ipp_attribute_t *media_col_sup; /* media-col-supported */
2ec940b5 266 ipp_attribute_t *operations_sup; /* operations-supported */
adbcb02a 267 ipp_attribute_t *doc_handling_sup; /* multiple-document-handling-supported */
74ef1ffb 268 ipp_attribute_t *printer_state; /* printer-state attribute */
072c4872 269 ipp_attribute_t *printer_accepting; /* printer-is-accepting-jobs */
5ed93a63 270 int create_job = 0, /* Does printer support Create-Job? */
a2a8bd6a 271 get_job_attrs = 0, /* Does printer support Get-Job-Attributes? */
537ee478 272 send_document = 0, /* Does printer support Send-Document? */
0d77fe26 273 validate_job = 0, /* Does printer support Validate-Job? */
274 print_color_mode = 0; /* Does printer support print-color-mode? */
37de726f 275 int copies, /* Number of copies for job */
276 copies_remaining; /* Number of copies remaining */
b43a3371 277 const char *content_type, /* CONTENT_TYPE environment variable */
2ec940b5 278 *final_content_type, /* FINAL_CONTENT_TYPE environment var */
279 *document_format; /* document-format value */
6875feac 280 int fd; /* File descriptor */
0663fa1c 281 off_t bytes = 0; /* Bytes copied */
6875feac 282 char buffer[16384]; /* Copy buffer */
4ff40357 283#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
74ef1ffb 284 struct sigaction action; /* Actions for POSIX signals */
4ff40357 285#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
74ef1ffb 286 int version; /* IPP version */
2d3aac27 287 ppd_file_t *ppd = NULL; /* PPD file */
288 _ppd_cache_t *pc = NULL; /* PPD cache and mapping data */
0663fa1c 289 fd_set input; /* Input set for select() */
c8f9565c 290
4b23f3b3 291
292 /*
293 * Make sure status messages are not buffered...
294 */
295
2922de55 296 setbuf(stderr, NULL);
c8f9565c 297
98904cd6 298 /*
8f4595eb 299 * Ignore SIGPIPE and catch SIGTERM signals...
98904cd6 300 */
301
302#ifdef HAVE_SIGSET
303 sigset(SIGPIPE, SIG_IGN);
8f4595eb 304 sigset(SIGTERM, sigterm_handler);
98904cd6 305#elif defined(HAVE_SIGACTION)
306 memset(&action, 0, sizeof(action));
307 action.sa_handler = SIG_IGN;
308 sigaction(SIGPIPE, &action, NULL);
8f4595eb 309
310 sigemptyset(&action.sa_mask);
311 sigaddset(&action.sa_mask, SIGTERM);
312 action.sa_handler = sigterm_handler;
313 sigaction(SIGTERM, &action, NULL);
98904cd6 314#else
315 signal(SIGPIPE, SIG_IGN);
8f4595eb 316 signal(SIGTERM, sigterm_handler);
98904cd6 317#endif /* HAVE_SIGSET */
318
4b23f3b3 319 /*
320 * Check command-line...
321 */
322
68edc300 323 if (argc == 1)
324 {
183914a3 325 char *s;
326
d4c438d4 327 if ((s = strrchr(argv[0], '/')) != NULL)
328 s ++;
329 else
330 s = argv[0];
331
3037604c 332 printf("network %s \"Unknown\" \"%s (%s)\"\n",
333 s, _cupsLangString(cupsLangDefault(),
334 _("Internet Printing Protocol")), s);
6248387b 335 return (CUPS_BACKEND_OK);
68edc300 336 }
072c4872 337 else if (argc < 6)
c8f9565c 338 {
472af6f3 339 _cupsLangPrintf(stderr,
4c4eea89 340 _("Usage: %s job-id user title copies options [file]"),
472af6f3 341 argv[0]);
6248387b 342 return (CUPS_BACKEND_STOP);
c8f9565c 343 }
344
959a6a28 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
7b1ef0fc 358 if ((auth_info_required = getenv("AUTH_INFO_REQUIRED")) == NULL)
359 auth_info_required = "none";
360
480e077e 361 state_reasons = _cupsArrayNewStrings(getenv("PRINTER_STATE_REASONS"), ',');
7b1ef0fc 362
959a6a28 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)
d8f880d0 378 return (run_as_user(argv, uid, device_uri, 0));
959a6a28 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 {
d8f880d0 387 status = run_as_user(argv, uid, device_uri, fd);
959a6a28 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
a684a3b0 408 /*
072c4872 409 * Get the (final) content type...
a684a3b0 410 */
411
b43a3371 412 if ((content_type = getenv("CONTENT_TYPE")) == NULL)
413 content_type = "application/octet-stream";
a684a3b0 414
b43a3371 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 }
12d8a513 422
7abb7137 423 /*
424 * Extract the hostname and printer name from the URI...
425 */
426
9fa9ba8f 427 httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
428 username, sizeof(username), hostname, sizeof(hostname), &port,
429 resource, sizeof(resource));
7abb7137 430
6df6deaf 431 if (!port)
432 port = IPP_PORT; /* Default to port 631 */
433
2ce1efdc 434 if (!strcmp(scheme, "https") || !strcmp(scheme, "ipps"))
7abb7137 435 cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
692bbbae 436 else
437 cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
7abb7137 438
897922a9 439 /*
440 * See if there are any options...
441 */
442
2ec940b5 443 compression = NULL;
6875feac 444 version = 20;
897922a9 445 waitjob = 1;
446 waitprinter = 1;
ff0295f0 447 contimeout = 7 * 24 * 60 * 60;
897922a9 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
abd1f85f 468 name = optptr;
897922a9 469
abd1f85f 470 while (*optptr && *optptr != '=' && *optptr != '+' && *optptr != '&')
471 optptr ++;
472
473 if ((sep = *optptr) != '\0')
474 *optptr++ = '\0';
475
476 if (sep == '=')
897922a9 477 {
478 /*
479 * Get the value...
480 */
481
abd1f85f 482 value = optptr;
897922a9 483
abd1f85f 484 while (*optptr && *optptr != '+' && *optptr != '&')
897922a9 485 optptr ++;
abd1f85f 486
487 if (*optptr)
488 *optptr++ = '\0';
897922a9 489 }
490 else
abd1f85f 491 value = (char *)"";
897922a9 492
493 /*
494 * Process the option...
495 */
496
c6fab96f 497 if (!_cups_strcasecmp(name, "waitjob"))
897922a9 498 {
499 /*
500 * Wait for job completion?
501 */
502
c6fab96f 503 waitjob = !_cups_strcasecmp(value, "on") ||
504 !_cups_strcasecmp(value, "yes") ||
505 !_cups_strcasecmp(value, "true");
897922a9 506 }
c6fab96f 507 else if (!_cups_strcasecmp(name, "waitprinter"))
897922a9 508 {
509 /*
510 * Wait for printer idle?
511 */
512
c6fab96f 513 waitprinter = !_cups_strcasecmp(value, "on") ||
514 !_cups_strcasecmp(value, "yes") ||
515 !_cups_strcasecmp(value, "true");
897922a9 516 }
c6fab96f 517 else if (!_cups_strcasecmp(name, "encryption"))
897922a9 518 {
519 /*
520 * Enable/disable encryption?
521 */
522
c6fab96f 523 if (!_cups_strcasecmp(value, "always"))
897922a9 524 cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
c6fab96f 525 else if (!_cups_strcasecmp(value, "required"))
897922a9 526 cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
c6fab96f 527 else if (!_cups_strcasecmp(value, "never"))
897922a9 528 cupsSetEncryption(HTTP_ENCRYPT_NEVER);
c6fab96f 529 else if (!_cups_strcasecmp(value, "ifrequested"))
897922a9 530 cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
531 else
532 {
4c4eea89 533 _cupsLangPrintFilter(stderr, "ERROR",
534 _("Unknown encryption option value: \"%s\"."),
535 value);
897922a9 536 }
537 }
bd08ee89 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 }
c6fab96f 548 else if (!_cups_strcasecmp(name, "version"))
a708af2a 549 {
550 if (!strcmp(value, "1.0"))
22d59a30 551 version = 10;
a708af2a 552 else if (!strcmp(value, "1.1"))
22d59a30 553 version = 11;
554 else if (!strcmp(value, "2.0"))
555 version = 20;
556 else if (!strcmp(value, "2.1"))
557 version = 21;
4c4eea89 558 else if (!strcmp(value, "2.2"))
559 version = 22;
a708af2a 560 else
561 {
4c4eea89 562 _cupsLangPrintFilter(stderr, "ERROR",
563 _("Unknown version option value: \"%s\"."),
564 value);
a708af2a 565 }
566 }
1230a8a0 567#ifdef HAVE_LIBZ
c6fab96f 568 else if (!_cups_strcasecmp(name, "compression"))
1230a8a0 569 {
c6fab96f 570 if (!_cups_strcasecmp(value, "true") || !_cups_strcasecmp(value, "yes") ||
571 !_cups_strcasecmp(value, "on") || !_cups_strcasecmp(value, "gzip"))
2ec940b5 572 compression = "gzip";
3c16b2a3 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";
1230a8a0 580 }
581#endif /* HAVE_LIBZ */
c6fab96f 582 else if (!_cups_strcasecmp(name, "contimeout"))
ff0295f0 583 {
584 /*
585 * Set the connection timeout...
586 */
587
588 if (atoi(value) > 0)
589 contimeout = atoi(value);
590 }
897922a9 591 else
592 {
593 /*
594 * Unknown option...
595 */
596
4c4eea89 597 _cupsLangPrintFilter(stderr, "ERROR",
598 _("Unknown option \"%s\" with value \"%s\"."),
599 name, value);
897922a9 600 }
601 }
602 }
603
1230a8a0 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 {
6875feac 612 num_files = 0;
7b73f614 613 files = NULL;
c6fab96f 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);
6875feac 617
618 fputs("DEBUG: Sending stdin for job...\n", stderr);
1230a8a0 619 }
620 else
621 {
622 /*
623 * Point to the files on the command-line...
624 */
625
b43a3371 626 num_files = argc - 6;
627 files = argv + 6;
628 send_options = 1;
cad2b75f 629
6875feac 630 fprintf(stderr, "DEBUG: %d files to send in job...\n", num_files);
631 }
1230a8a0 632
c8f9565c 633 /*
b5cb0608 634 * Set the authentication info, if any...
c8f9565c 635 */
636
478d9bb3 637 cupsSetPasswordCB2((cups_password_cb2_t)password_cb, &password_tries);
b5cb0608 638
639 if (username[0])
640 {
48e211f3 641 /*
9ef7dccf 642 * Use authentication information in the device URI...
48e211f3 643 */
644
b5cb0608 645 if ((password = strchr(username, ':')) != NULL)
646 *password++ = '\0';
647
648 cupsSetUser(username);
649 }
cbedee47 650 else
48e211f3 651 {
652 /*
fa1fc704 653 * Try loading authentication information from the environment.
48e211f3 654 */
655
abd1f85f 656 const char *ptr = getenv("AUTH_USERNAME");
657
658 if (ptr)
f92e446a 659 {
660 strlcpy(username, ptr, sizeof(username));
fa1fc704 661 cupsSetUser(ptr);
f92e446a 662 }
48e211f3 663
fa1fc704 664 password = getenv("AUTH_PASSWORD");
48e211f3 665 }
c8f9565c 666
667 /*
cce0044f 668 * Try finding the remote server...
c8f9565c 669 */
670
f831f3d8 671 start_time = time(NULL);
ff0295f0 672
cce0044f 673 sprintf(portname, "%d", port);
674
7b1ef0fc 675 update_reasons(NULL, "+connecting-to-device");
cce0044f 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 {
7b1ef0fc 686 update_reasons(NULL, "-connecting-to-device");
cce0044f 687 return (CUPS_BACKEND_STOP);
688 }
449acb70 689
690 if (job_canceled)
691 return (CUPS_BACKEND_OK);
cce0044f 692 }
693
8a5c43f4 694 http = httpConnect2(hostname, port, addrlist, AF_UNSPEC, cupsEncryption(), 1,
695 0, NULL);
1179bc03 696 httpSetTimeout(http, 30.0, timeout_cb, NULL);
cce0044f 697
698 /*
699 * See if the printer supports SNMP...
700 */
701
bd08ee89 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)
cce0044f 708 have_supplies = !backendSNMPSupplies(snmp_fd, &(addrlist->addr),
709 &start_count, NULL);
cce0044f 710 else
711 have_supplies = start_count = 0;
712
713 /*
714 * Wait for data from the filter...
715 */
716
717 if (num_files == 0)
0663fa1c 718 {
ad6d7ec9 719 if (!backendWaitLoop(snmp_fd, &(addrlist->addr), 0, backendNetworkSideCB))
cce0044f 720 return (CUPS_BACKEND_OK);
0663fa1c 721 else if ((bytes = read(0, buffer, sizeof(buffer))) <= 0)
722 return (CUPS_BACKEND_OK);
723 }
cce0044f 724
725 /*
726 * Try connecting to the remote server...
727 */
728
fc596e79 729 delay = _cupsNextDelay(0, &prev_delay);
22a980cc 730
97fcaf92 731 do
c8f9565c 732 {
9fa9ba8f 733 fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
4c4eea89 734 _cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
c8f9565c 735
cce0044f 736 if (httpReconnect(http))
d21a7597 737 {
03a8680a 738 int error = errno; /* Connection error */
739
cce0044f 740 if (http->status == HTTP_PKI_ERROR)
7b1ef0fc 741 update_reasons(NULL, "+cups-certificate-error");
cce0044f 742
6875feac 743 if (job_canceled)
bb3ff448 744 break;
745
997cf8b0 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
4c4eea89 755 _cupsLangPrintFilter(stderr, "INFO",
756 _("Unable to contact printer, queuing on next "
757 "printer in class."));
997cf8b0 758
997cf8b0 759 /*
760 * Sleep 5 seconds to keep the job from requeuing too rapidly...
761 */
762
763 sleep(5);
764
7b1ef0fc 765 update_reasons(NULL, "-connecting-to-device");
cce0044f 766
6248387b 767 return (CUPS_BACKEND_FAILED);
997cf8b0 768 }
769
03a8680a 770 fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(errno));
771
4c2096b8 772 if (errno == ECONNREFUSED || errno == EHOSTDOWN ||
773 errno == EHOSTUNREACH)
97fcaf92 774 {
ff0295f0 775 if (contimeout && (time(NULL) - start_time) > contimeout)
776 {
4c4eea89 777 _cupsLangPrintFilter(stderr, "ERROR",
778 _("The printer is not responding."));
7b1ef0fc 779 update_reasons(NULL, "-connecting-to-device");
ff0295f0 780 return (CUPS_BACKEND_FAILED);
781 }
782
03a8680a 783 switch (error)
784 {
785 case EHOSTDOWN :
4c4eea89 786 _cupsLangPrintFilter(stderr, "WARNING",
7cfa02ab 787 _("The printer may not exist or "
788 "is unavailable at this time."));
03a8680a 789 break;
790
791 case EHOSTUNREACH :
4c4eea89 792 _cupsLangPrintFilter(stderr, "WARNING",
7cfa02ab 793 _("The printer is unreachable at this "
794 "time."));
03a8680a 795 break;
796
797 case ECONNREFUSED :
798 default :
4c4eea89 799 _cupsLangPrintFilter(stderr, "WARNING",
d326343a 800 _("The printer is in use."));
03a8680a 801 break;
802 }
ff0295f0 803
804 sleep(delay);
805
fc596e79 806 delay = _cupsNextDelay(delay, &prev_delay);
97fcaf92 807 }
808 else
809 {
4c4eea89 810 _cupsLangPrintFilter(stderr, "ERROR",
7cfa02ab 811 _("The printer is not responding."));
2cc18dd2 812 sleep(30);
97fcaf92 813 }
bb3ff448 814
6875feac 815 if (job_canceled)
bb3ff448 816 break;
d21a7597 817 }
cce0044f 818 else
7b1ef0fc 819 update_reasons(NULL, "-cups-certificate-error");
c8f9565c 820 }
cce0044f 821 while (http->fd < 0);
c8f9565c 822
449acb70 823 if (job_canceled)
824 return (CUPS_BACKEND_OK);
825 else if (!http)
bb3ff448 826 return (CUPS_BACKEND_FAILED);
bb3ff448 827
7b1ef0fc 828 update_reasons(NULL, "-connecting-to-device");
4c4eea89 829 _cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
a4e23897 830
f0aa54a1 831 fprintf(stderr, "DEBUG: Connected to %s:%d...\n",
832 httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
2d3aac27 833 httpAddrPort(http->hostaddr));
a0c0bbe7 834
c8f9565c 835 /*
836 * Build a URI for the printer and fill the standard IPP attributes for
8ce7c000 837 * an IPP_PRINT_FILE request. We can't use the URI in argv[0] because it
838 * might contain username:password information...
c8f9565c 839 */
840
11fdb546 841 httpAssembleURI(HTTP_URI_CODING_ALL, uri, sizeof(uri), scheme, NULL, hostname,
842 port, resource);
c8f9565c 843
844 /*
97fcaf92 845 * First validate the destination and see if the device supports multiple
6875feac 846 * copies...
c8f9565c 847 */
848
3c16b2a3 849#ifdef HAVE_LIBZ
850 compression_sup = NULL;
851#endif /* HAVE_LIBZ */
adbcb02a 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;
c8f9565c 859
97fcaf92 860 do
c8f9565c 861 {
56f7a531 862 /*
863 * Check for side-channel requests...
864 */
865
866 backendCheckSideChannel(snmp_fd, http->hostaddr);
867
c8f9565c 868 /*
97fcaf92 869 * Build the IPP request...
c8f9565c 870 */
871
e12df069 872 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
22d59a30 873 request->request.op.version[0] = version / 10;
874 request->request.op.version[1] = version % 10;
c8f9565c 875
97fcaf92 876 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
877 NULL, uri);
c8f9565c 878
8f4595eb 879 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
880 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
881 NULL, pattrs);
882
97fcaf92 883 /*
884 * Do the request...
885 */
c8f9565c 886
2054e655 887 fputs("DEBUG: Getting supported attributes...\n", stderr);
a4e23897 888
acd7eb22 889 if (http->version < HTTP_1_1)
6875feac 890 {
8962df79 891 fprintf(stderr, "DEBUG: Printer responded with HTTP version %d.%d.\n",
892 http->version / 100, http->version % 100);
7b1ef0fc 893 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
894 "cups-ipp-wrong-http-version");
6875feac 895 }
acd7eb22 896
b9738d7c 897 supported = cupsDoRequest(http, request, resource);
898 ipp_status = cupsLastError();
b5cb0608 899
5fb23099 900 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
901 ippErrorString(ipp_status), cupsLastErrorString());
902
f92e446a 903 if (ipp_status <= IPP_OK_CONFLICT)
904 password_tries = 0;
905 else
c8f9565c 906 {
b9738d7c 907 fprintf(stderr, "DEBUG: Get-Printer-Attributes returned %s.\n",
908 ippErrorString(ipp_status));
909
b5cb0608 910 if (ipp_status == IPP_PRINTER_BUSY ||
911 ipp_status == IPP_SERVICE_UNAVAILABLE)
c8f9565c 912 {
ff0295f0 913 if (contimeout && (time(NULL) - start_time) > contimeout)
914 {
4c4eea89 915 _cupsLangPrintFilter(stderr, "ERROR",
916 _("The printer is not responding."));
ff0295f0 917 return (CUPS_BACKEND_FAILED);
918 }
919
d326343a 920 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
ff0295f0 921
4a241564 922 report_printer_state(supported);
ff0295f0 923
924 sleep(delay);
925
fc596e79 926 delay = _cupsNextDelay(delay, &prev_delay);
97fcaf92 927 }
b5cb0608 928 else if ((ipp_status == IPP_BAD_REQUEST ||
22d59a30 929 ipp_status == IPP_VERSION_NOT_SUPPORTED) && version > 10)
c8f9565c 930 {
b5cb0608 931 /*
6875feac 932 * Switch to IPP/1.1 or IPP/1.0...
b5cb0608 933 */
97fcaf92 934
6875feac 935 if (version >= 20)
936 {
8d6e4061 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);
6875feac 941 version = 11;
942 }
943 else
944 {
8d6e4061 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);
6875feac 949 version = 10;
950 }
951
a4e23897 952 httpReconnect(http);
c8f9565c 953 }
67474245 954 else if (ipp_status == IPP_NOT_FOUND)
955 {
4c4eea89 956 _cupsLangPrintFilter(stderr, "ERROR",
8d6e4061 957 _("The printer configuration is incorrect or the "
958 "printer no longer exists."));
67474245 959
5fb23099 960 ippDelete(supported);
67474245 961
6248387b 962 return (CUPS_BACKEND_STOP);
67474245 963 }
f92e446a 964 else if (ipp_status == IPP_FORBIDDEN ||
3e9c9081 965 ipp_status == IPP_AUTHENTICATION_CANCELED)
fc7e68cf 966 {
6836e69b 967 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
968 /* WWW-Authenticate field value */
969
970 if (!strncmp(www_auth, "Negotiate", 9))
fc7e68cf 971 auth_info_required = "negotiate";
6836e69b 972 else if (www_auth[0])
973 auth_info_required = "username,password";
fc7e68cf 974
975 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
976 return (CUPS_BACKEND_AUTH_REQUIRED);
977 }
f92e446a 978 else if (ipp_status != IPP_NOT_AUTHORIZED)
67474245 979 {
4c4eea89 980 _cupsLangPrintFilter(stderr, "ERROR",
5fb23099 981 _("Unable to get printer status."));
67474245 982 sleep(10);
84a03f93 983
984 httpReconnect(http);
67474245 985 }
d1c2727f 986
7cfa02ab 987 ippDelete(supported);
5fb23099 988 supported = NULL;
d1c2727f 989 continue;
97fcaf92 990 }
6875feac 991
f8c0cc95 992 if (!getenv("CLASS"))
7cfa02ab 993 {
f8c0cc95 994 /*
995 * Check printer-is-accepting-jobs = false and printer-state-reasons for the
996 * "spool-area-full" keyword...
997 */
998
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;
9e88f2d2 1006 else if (!printer_accepting)
7b1ef0fc 1007 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1008 "cups-ipp-missing-printer-is-accepting-jobs");
c6fab96f 1009
9e88f2d2 1010 if ((printer_state = ippFindAttribute(supported,
1011 "printer-state-reasons",
7f650b54 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)
f8c0cc95 1018 {
1019 for (i = 0; i < printer_state->num_values; i ++)
7f650b54 1020 {
9e88f2d2 1021 if (!strcmp(printer_state->values[0].string.text,
1022 "spool-area-full") ||
f8c0cc95 1023 !strncmp(printer_state->values[0].string.text, "spool-area-full-",
1024 16))
1025 {
1026 busy = 1;
1027 break;
1028 }
7f650b54 1029 }
f8c0cc95 1030 }
7cfa02ab 1031
f8c0cc95 1032 if (busy)
7cfa02ab 1033 {
d326343a 1034 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
7cfa02ab 1035
4a241564 1036 report_printer_state(supported);
7cfa02ab 1037
1038 sleep(delay);
1039
f8c0cc95 1040 delay = _cupsNextDelay(delay, &prev_delay);
7cfa02ab 1041
1042 ippDelete(supported);
5fb23099 1043 supported = NULL;
7cfa02ab 1044 continue;
1045 }
1046 }
7cfa02ab 1047
6875feac 1048 /*
1049 * Check for supported attributes...
1050 */
1051
3c16b2a3 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 {
5af0c5ab 1069 if (ippContainsString(compression_sup, "gzip"))
e3d00397 1070 compression = "gzip";
5af0c5ab 1071 else if (ippContainsString(compression_sup, "deflate"))
1072 compression = "deflate";
3c16b2a3 1073
1074 if (compression)
1075 fprintf(stderr, "DEBUG: Automatically using \"%s\" compression.\n",
1076 compression);
1077 }
1078 }
1079#endif /* HAVE_LIBZ */
1080
6875feac 1081 if ((copies_sup = ippFindAttribute(supported, "copies-supported",
1082 IPP_TAG_RANGE)) != NULL)
97fcaf92 1083 {
b5cb0608 1084 /*
1085 * Has the "copies-supported" attribute - does it have an upper
1086 * bound > 1?
1087 */
97fcaf92 1088
6875feac 1089 fprintf(stderr, "DEBUG: copies-supported=%d-%d\n",
1090 copies_sup->values[0].range.lower,
1091 copies_sup->values[0].range.upper);
1092
b5cb0608 1093 if (copies_sup->values[0].range.upper <= 1)
1094 copies_sup = NULL; /* No */
1095 }
97fcaf92 1096
6875feac 1097 cups_version = ippFindAttribute(supported, "cups-version", IPP_TAG_TEXT);
b5cb0608 1098
6875feac 1099 if ((format_sup = ippFindAttribute(supported, "document-format-supported",
1100 IPP_TAG_MIMETYPE)) != NULL)
b5cb0608 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);
c8f9565c 1107 }
d1c2727f 1108
6875feac 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
0d77fe26 1119 print_color_mode = ippFindAttribute(supported,
1120 "print-color-mode-supported",
1121 IPP_TAG_KEYWORD) != NULL;
1122
2ec940b5 1123 if ((operations_sup = ippFindAttribute(supported, "operations-supported",
1124 IPP_TAG_ENUM)) != NULL)
1125 {
7f650b54 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
9e88f2d2 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)
7b1ef0fc 1137 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1138 "cups-ipp-missing-print-job");
9e88f2d2 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)
7b1ef0fc 1145 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1146 "cups-ipp-missing-cancel-job");
9e88f2d2 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)
7b1ef0fc 1153 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1154 "cups-ipp-missing-get-job-attributes");
9e88f2d2 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)
7b1ef0fc 1161 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1162 "cups-ipp-missing-get-printer-attributes");
9e88f2d2 1163
2ec940b5 1164 for (i = 0; i < operations_sup->num_values; i ++)
5ed93a63 1165 {
2ec940b5 1166 if (operations_sup->values[i].integer == IPP_VALIDATE_JOB)
2ec940b5 1167 validate_job = 1;
5ed93a63 1168 else if (operations_sup->values[i].integer == IPP_CREATE_JOB)
5ed93a63 1169 create_job = 1;
537ee478 1170 else if (operations_sup->values[i].integer == IPP_SEND_DOCUMENT)
1171 send_document = 1;
a2a8bd6a 1172 else if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
1173 get_job_attrs = 1;
537ee478 1174 }
1175
2cca44e9 1176 if (create_job && !send_document)
537ee478 1177 {
1178 fputs("DEBUG: Printer supports Create-Job but not Send-Document.\n",
1179 stderr);
1180 create_job = 0;
b10d3fc1 1181
1182 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1183 "cups-ipp-missing-send-document");
5ed93a63 1184 }
2ec940b5 1185
1186 if (!validate_job)
7b1ef0fc 1187 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1188 "cups-ipp-missing-validate-job");
2ec940b5 1189 }
1190 else
7b1ef0fc 1191 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1192 "cups-ipp-missing-operations-supported");
2ec940b5 1193
adbcb02a 1194 doc_handling_sup = ippFindAttribute(supported,
1195 "multiple-document-handling-supported",
1196 IPP_TAG_KEYWORD);
1197
4a241564 1198 report_printer_state(supported);
c8f9565c 1199 }
449acb70 1200 while (!job_canceled && ipp_status > IPP_OK_CONFLICT);
1201
1202 if (job_canceled)
1203 return (CUPS_BACKEND_OK);
c8f9565c 1204
997cf8b0 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 ||
072c4872 1218 (printer_state->values[0].integer > IPP_PRINTER_PROCESSING &&
1219 waitprinter) ||
997cf8b0 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
4c4eea89 1230 _cupsLangPrintFilter(stderr, "INFO",
1231 _("Unable to contact printer, queuing on next "
1232 "printer in class."));
997cf8b0 1233
1234 ippDelete(supported);
1235 httpClose(http);
1236
997cf8b0 1237 /*
1238 * Sleep 5 seconds to keep the job from requeuing too rapidly...
1239 */
1240
1241 sleep(5);
1242
6248387b 1243 return (CUPS_BACKEND_FAILED);
997cf8b0 1244 }
1245 }
1246
c8f9565c 1247 /*
97fcaf92 1248 * See if the printer supports multiple copies...
c8f9565c 1249 */
1250
37de726f 1251 copies = atoi(argv[4]);
1252
d1c2727f 1253 if (copies_sup || argc < 7)
37de726f 1254 copies_remaining = 1;
0c5b0932 1255 else
37de726f 1256 copies_remaining = copies;
0c5b0932 1257
2ec940b5 1258 /*
1259 * Prepare remaining printing options...
1260 */
1261
1262 options = NULL;
2ec940b5 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"));
8211508e 1275 pc = _ppdCacheCreateWithPPD(ppd);
2ec940b5 1276
2d3aac27 1277 ppdMarkDefaults(ppd);
1278 cupsMarkOptions(ppd, num_options, options);
2ec940b5 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 ++)
03f5686f 1289 if (!_cups_strcasecmp(final_content_type,
1290 format_sup->values[i].string.text))
2ec940b5 1291 {
1292 document_format = final_content_type;
1293 break;
1294 }
cce0044f 1295
c182b536 1296 if (!document_format)
cce0044f 1297 {
1298 for (i = 0; i < format_sup->num_values; i ++)
c6fab96f 1299 if (!_cups_strcasecmp("application/octet-stream",
03f5686f 1300 format_sup->values[i].string.text))
cce0044f 1301 {
1302 document_format = "application/octet-stream";
1303 break;
1304 }
1305 }
2ec940b5 1306 }
1307
03f5686f 1308 fprintf(stderr, "DEBUG: final_content_type=\"%s\", document_format=\"%s\"\n",
1309 final_content_type, document_format ? document_format : "(null)");
1310
940afb4b 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
3bf3931c 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;
940afb4b 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
a2387f4f 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
38025f7e 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...
a2387f4f 1360 */
1361
1362 if (version == 10)
1363 create_job = send_document = 0;
1364
b9738d7c 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;
a2a8bd6a 1376 monitor.get_job_attrs = get_job_attrs;
b9738d7c 1377 monitor.encryption = cupsEncryption();
1378 monitor.job_state = IPP_JOB_PENDING;
1379 monitor.printer_state = IPP_PRINTER_IDLE;
1380
5ed93a63 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
b8a55545 1392 _cupsThreadCreate((_cups_thread_func_t)monitor_printer, &monitor);
b9738d7c 1393
c8f9565c 1394 /*
2ec940b5 1395 * Validate access to the printer...
c8f9565c 1396 */
1397
5fb23099 1398 while (!job_canceled && validate_job)
c8f9565c 1399 {
5ed93a63 1400 request = new_request(IPP_VALIDATE_JOB, version, uri, argv[2],
1401 monitor.job_name, num_options, options, compression,
2d3aac27 1402 copies_sup ? copies : 1, document_format, pc, ppd,
0d77fe26 1403 media_col_sup, doc_handling_sup, print_color_mode);
97fcaf92 1404
971b2b61 1405 response = cupsDoRequest(http, request, resource);
8ce7c000 1406
2ec940b5 1407 ipp_status = cupsLastError();
97fcaf92 1408
5fb23099 1409 fprintf(stderr, "DEBUG: Validate-Job: %s (%s)\n",
1410 ippErrorString(ipp_status), cupsLastErrorString());
6875feac 1411
971b2b61 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
5fb23099 1420 if (job_canceled)
1421 break;
e7186d00 1422
e35b1e23 1423 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1424 ipp_status == IPP_STATUS_ERROR_BUSY)
5fb23099 1425 {
d326343a 1426 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
5fb23099 1427 sleep(10);
1428 }
e35b1e23 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)
d78cda84 1434 goto cleanup;
e35b1e23 1435 else if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1436 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
5fb23099 1437 {
6836e69b 1438 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1439 /* WWW-Authenticate field value */
b8f3410f 1440
6836e69b 1441 if (!strncmp(www_auth, "Negotiate", 9))
5fb23099 1442 auth_info_required = "negotiate";
6836e69b 1443 else if (www_auth[0])
1444 auth_info_required = "username,password";
753453e4 1445
5fb23099 1446 goto cleanup;
2ec940b5 1447 }
e35b1e23 1448 else if (ipp_status == IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED)
5fb23099 1449 {
0663fa1c 1450 /*
1451 * This is all too common...
1452 */
1453
7b1ef0fc 1454 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1455 "cups-ipp-missing-validate-job");
5fb23099 1456 break;
1457 }
193a6973 1458 else if (ipp_status < IPP_REDIRECTION_OTHER_SITE ||
1459 ipp_status == IPP_BAD_REQUEST)
2ec940b5 1460 break;
1461 }
37de726f 1462
2ec940b5 1463 /*
1464 * Then issue the print-job request...
1465 */
6875feac 1466
2ec940b5 1467 job_id = 0;
6875feac 1468
2ec940b5 1469 while (!job_canceled && copies_remaining > 0)
1470 {
1471 /*
1472 * Check for side-channel requests...
1473 */
b9738d7c 1474
2ec940b5 1475 backendCheckSideChannel(snmp_fd, http->hostaddr);
b9738d7c 1476
2ec940b5 1477 /*
1478 * Build the IPP job creation request...
1479 */
6875feac 1480
2ec940b5 1481 if (job_canceled)
1482 break;
753453e4 1483
5ed93a63 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,
2d3aac27 1488 document_format, pc, ppd, media_col_sup,
0d77fe26 1489 doc_handling_sup, print_color_mode);
c8f9565c 1490
cb555bcf 1491 /*
b5cb0608 1492 * Do the request...
cb555bcf 1493 */
1494
5ed93a63 1495 if (num_files > 1 || create_job)
072c4872 1496 response = cupsDoRequest(http, request, resource);
b5cb0608 1497 else
6875feac 1498 {
940afb4b 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);
6875feac 1510 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1511 {
8e21e3ad 1512 if (compression && strcmp(compression, "none"))
1513 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1514
6875feac 1515 if (num_files == 1)
4ed00dc2 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 }
6875feac 1523 else
6875feac 1524 {
7b64ad64 1525 fd = 0;
1526 http_status = cupsWriteRequestData(http, buffer, bytes);
1527 }
6875feac 1528
06efaeda 1529 while (http_status == HTTP_CONTINUE &&
1530 (!job_canceled || compatsize > 0))
7b64ad64 1531 {
0663fa1c 1532 /*
1533 * Check for side-channel requests and more print data...
1534 */
1535
1536 FD_ZERO(&input);
1537 FD_SET(fd, &input);
1538 FD_SET(snmp_fd, &input);
1539
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))
6875feac 1544 backendCheckSideChannel(snmp_fd, http->hostaddr);
0663fa1c 1545
1546 if (FD_ISSET(fd, &input))
7b64ad64 1547 {
1548 if ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
1549 {
1550 fprintf(stderr, "DEBUG: Read %d bytes...\n", (int)bytes);
1551
8e21e3ad 1552 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1553 != HTTP_CONTINUE)
7b64ad64 1554 break;
1555 }
1556 else if (bytes == 0 || (errno != EINTR && errno != EAGAIN))
1557 break;
1558 }
6875feac 1559 }
1560
8e21e3ad 1561 if (http_status == HTTP_ERROR)
1562 fprintf(stderr, "DEBUG: Error writing document data for "
1563 "Print-Job: %s\n", strerror(httpError(http)));
1564
6875feac 1565 if (num_files == 1)
1566 close(fd);
1567 }
1568
1569 response = cupsGetResponse(http, resource);
1570 ippDelete(request);
1571 }
072c4872 1572
1573 ipp_status = cupsLastError();
b5cb0608 1574
5fb23099 1575 fprintf(stderr, "DEBUG: %s: %s (%s)\n",
5ed93a63 1576 (num_files > 1 || create_job) ? "Create-Job" : "Print-Job",
5fb23099 1577 ippErrorString(ipp_status), cupsLastErrorString());
1578
b5cb0608 1579 if (ipp_status > IPP_OK_CONFLICT)
1580 {
753453e4 1581 job_id = 0;
1582
6875feac 1583 if (job_canceled)
072c4872 1584 break;
1585
e35b1e23 1586 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1587 ipp_status == IPP_STATUS_ERROR_NOT_POSSIBLE ||
1588 ipp_status == IPP_STATUS_ERROR_BUSY)
b5cb0608 1589 {
d326343a 1590 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
b5cb0608 1591 sleep(10);
7cfa02ab 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 }
b5cb0608 1602 }
e35b1e23 1603 else if (ipp_status == IPP_STATUS_ERROR_JOB_CANCELED ||
1604 ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED ||
72429331 1605 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
e35b1e23 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)
72bdcfc1 1610 goto cleanup;
b5cb0608 1611 else
ebac5c9b 1612 {
1613 /*
1614 * Update auth-info-required as needed...
1615 */
1616
4c4eea89 1617 _cupsLangPrintFilter(stderr, "ERROR",
8d6e4061 1618 _("Print job was not accepted."));
ebac5c9b 1619
e35b1e23 1620 if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1621 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
ebac5c9b 1622 {
6836e69b 1623 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1624 /* WWW-Authenticate field value */
3e9c9081 1625
6836e69b 1626 if (!strncmp(www_auth, "Negotiate", 9))
4233257e 1627 auth_info_required = "negotiate";
6836e69b 1628 else if (www_auth[0])
1629 auth_info_required = "username,password";
ebac5c9b 1630 }
893cc878 1631 else if (ipp_status == IPP_REQUEST_VALUE)
1632 {
1633 /*
1634 * Print file is too large, abort this job...
1635 */
1636
1637 goto cleanup;
1638 }
5fb23099 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 }
ebac5c9b 1651 }
b5cb0608 1652 }
1653 else if ((job_id_attr = ippFindAttribute(response, "job-id",
1654 IPP_TAG_INTEGER)) == NULL)
97fcaf92 1655 {
8d6e4061 1656 fputs("DEBUG: Print job accepted - job ID unknown.\n", stderr);
7b1ef0fc 1657 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1658 "cups-ipp-missing-job-id");
b5cb0608 1659 job_id = 0;
1660 }
1661 else
1662 {
f92e446a 1663 password_tries = 0;
b9738d7c 1664 monitor.job_id = job_id = job_id_attr->values[0].integer;
8d6e4061 1665 fprintf(stderr, "DEBUG: Print job accepted - job ID %d.\n", job_id);
97fcaf92 1666 }
cb555bcf 1667
072c4872 1668 ippDelete(response);
1669
6875feac 1670 if (job_canceled)
072c4872 1671 break;
1672
5ed93a63 1673 if (job_id && (num_files > 1 || create_job))
072c4872 1674 {
5ed93a63 1675 for (i = 0; num_files == 0 || i < num_files; i ++)
072c4872 1676 {
56f7a531 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
072c4872 1687 request = ippNewRequest(IPP_SEND_DOCUMENT);
22d59a30 1688 request->request.op.version[0] = version / 10;
1689 request->request.op.version[1] = version % 10;
072c4872 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
5ed93a63 1701 if ((i + 1) >= num_files)
072c4872 1702 ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
1703
2524a5ef 1704 if (document_format)
1705 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1706 "document-format", NULL, document_format);
072c4872 1707
675dc7f3 1708 if (compression)
1709 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1710 "compression", NULL, compression);
1711
6875feac 1712 fprintf(stderr, "DEBUG: Sending file %d using chunking...\n", i + 1);
1713 http_status = cupsSendRequest(http, request, resource, 0);
5ed93a63 1714 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1715 {
3c16b2a3 1716 if (compression && strcmp(compression, "none"))
1717 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1718
5ed93a63 1719 if (num_files == 0)
1720 {
1721 fd = 0;
1722 http_status = cupsWriteRequestData(http, buffer, bytes);
1723 }
1724 else
4ed00dc2 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 }
5ed93a63 1732 }
1733 else
1734 fd = -1;
1735
1736 if (fd >= 0)
6875feac 1737 {
75d1b92c 1738 while (!job_canceled && http_status == HTTP_CONTINUE &&
06efaeda 1739 (bytes = read(fd, buffer, sizeof(buffer))) > 0)
6875feac 1740 {
75d1b92c 1741 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1742 != HTTP_CONTINUE)
6875feac 1743 break;
1744 else
1745 {
1746 /*
1747 * Check for side-channel requests...
1748 */
1749
1750 backendCheckSideChannel(snmp_fd, http->hostaddr);
1751 }
1752 }
1753
5ed93a63 1754 if (fd > 0)
1755 close(fd);
6875feac 1756 }
acd7eb22 1757
8e21e3ad 1758 if (http_status == HTTP_ERROR)
1759 fprintf(stderr, "DEBUG: Error writing document data for "
1760 "Send-Document: %s\n", strerror(httpError(http)));
1761
6875feac 1762 ippDelete(cupsGetResponse(http, resource));
1763 ippDelete(request);
072c4872 1764
5fb23099 1765 fprintf(stderr, "DEBUG: Send-Document: %s (%s)\n",
1766 ippErrorString(cupsLastError()), cupsLastErrorString());
1767
072c4872 1768 if (cupsLastError() > IPP_OK_CONFLICT)
1769 {
1770 ipp_status = cupsLastError();
1771
4c4eea89 1772 _cupsLangPrintFilter(stderr, "ERROR",
5fb23099 1773 _("Unable to add document to print job."));
072c4872 1774 break;
1775 }
f92e446a 1776 else
1777 {
1778 password_tries = 0;
1779
1780 if (num_files == 0 || fd < 0)
1781 break;
1782 }
072c4872 1783 }
1784 }
b5cb0608 1785
753453e4 1786 if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
b5cb0608 1787 {
1788 fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
37de726f 1789 copies_remaining --;
b5cb0608 1790 }
ab827512 1791 else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
084c8c5c 1792 ipp_status == IPP_NOT_POSSIBLE ||
ab827512 1793 ipp_status == IPP_PRINTER_BUSY)
b514d580 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 }
a04d2365 1807 continue;
b514d580 1808 }
a2387f4f 1809 else if (ipp_status == IPP_REQUEST_VALUE ||
1810 ipp_status == IPP_ERROR_JOB_CANCELED ||
08861878 1811 ipp_status == IPP_NOT_AUTHORIZED ||
e35b1e23 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 ||
08861878 1816 ipp_status == IPP_INTERNAL_ERROR)
893cc878 1817 {
1818 /*
08861878 1819 * Print file is too large, job was canceled, we need new
1820 * authentication data, or we had some sort of error...
893cc878 1821 */
1822
1823 goto cleanup;
1824 }
38025f7e 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 }
a2387f4f 1846 else if (ipp_status == IPP_NOT_FOUND)
1847 {
1848 /*
1849 * Printer does not actually implement support for Create-Job/
1850 * Send-Document, so log the conformance issue and stop the printer.
1851 */
1852
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
1862 goto cleanup;
1863 }
ab827512 1864 else
37de726f 1865 copies_remaining --;
8ce7c000 1866
c8f9565c 1867 /*
b5cb0608 1868 * Wait for the job to complete...
c8f9565c 1869 */
1870
a2a8bd6a 1871 if (!job_id || !waitjob || !get_job_attrs)
b5cb0608 1872 continue;
1873
4c4eea89 1874 _cupsLangPrintFilter(stderr, "INFO", _("Waiting for job to complete."));
b5cb0608 1875
fc596e79 1876 for (delay = _cupsNextDelay(0, &prev_delay); !job_canceled;)
c8f9565c 1877 {
56f7a531 1878 /*
1879 * Check for side-channel requests...
1880 */
1881
1882 backendCheckSideChannel(snmp_fd, http->hostaddr);
1883
1868f11c 1884 /*
1885 * Check printer state...
1886 */
1887
1888 check_printer_state(http, uri, resource, argv[2], version);
1889
478d9bb3 1890 if (cupsLastError() <= IPP_OK_CONFLICT)
1891 password_tries = 0;
1892
97fcaf92 1893 /*
b5cb0608 1894 * Build an IPP_GET_JOB_ATTRIBUTES request...
97fcaf92 1895 */
1896
e12df069 1897 request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
22d59a30 1898 request->request.op.version[0] = version / 10;
1899 request->request.op.version[1] = version % 10;
97fcaf92 1900
b5cb0608 1901 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1902 NULL, uri);
3f9cb6c6 1903
b5cb0608 1904 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1905 job_id);
c8f9565c 1906
ee8b7dd3 1907 if (argv[2][0])
897922a9 1908 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1909 "requesting-user-name", NULL, argv[2]);
ee8b7dd3 1910
8f4595eb 1911 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1912 "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
1913 NULL, jattrs);
97fcaf92 1914
1915 /*
b5cb0608 1916 * Do the request...
97fcaf92 1917 */
1918
fc596e79 1919 httpReconnect(http);
072c4872 1920 response = cupsDoRequest(http, request, resource);
1921 ipp_status = cupsLastError();
97fcaf92 1922
35d763f5 1923 if (ipp_status == IPP_NOT_FOUND || ipp_status == IPP_NOT_POSSIBLE)
97fcaf92 1924 {
b5cb0608 1925 /*
d1c2727f 1926 * Job has gone away and/or the server has no job history...
b5cb0608 1927 */
97fcaf92 1928
7b1ef0fc 1929 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1930 "cups-ipp-missing-job-history");
b5cb0608 1931 ippDelete(response);
d1c2727f 1932
1933 ipp_status = IPP_OK;
b5cb0608 1934 break;
97fcaf92 1935 }
1936
5fb23099 1937 fprintf(stderr, "DEBUG: Get-Job-Attributes: %s (%s)\n",
1938 ippErrorString(ipp_status), cupsLastErrorString());
1939
f92e446a 1940 if (ipp_status <= IPP_OK_CONFLICT)
1941 password_tries = 0;
1942 else
6a536282 1943 {
b5cb0608 1944 if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
24b2889c 1945 ipp_status != IPP_PRINTER_BUSY)
97fcaf92 1946 {
072c4872 1947 ippDelete(response);
75bdfcbb 1948 ipp_status = IPP_OK;
b5cb0608 1949 break;
97fcaf92 1950 }
24b2889c 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 }
6a536282 1962 }
8f4595eb 1963
072c4872 1964 if (response)
97fcaf92 1965 {
8f4595eb 1966 if ((job_state = ippFindAttribute(response, "job-state",
1967 IPP_TAG_ENUM)) != NULL)
97fcaf92 1968 {
6c1b8723 1969 /*
1970 * Reflect the remote job state in the local queue...
1971 */
1972
7b1ef0fc 1973 if (cups_version &&
1974 job_state->values[0].integer >= IPP_JOB_PENDING &&
1975 job_state->values[0].integer <= IPP_JOB_COMPLETED)
1976 update_reasons(NULL,
1977 remote_job_states[job_state->values[0].integer -
1978 IPP_JOB_PENDING]);
f8c0cc95 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);
6c1b8723 1990
8f4595eb 1991 /*
1992 * Stop polling if the job is finished or pending-held...
1993 */
1994
7951315f 1995 if (job_state->values[0].integer > IPP_JOB_STOPPED)
8f4595eb 1996 {
1997 ippDelete(response);
1998 break;
1999 }
97fcaf92 2000 }
084c8c5c 2001 else if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
2002 ipp_status != IPP_NOT_POSSIBLE &&
2003 ipp_status != IPP_PRINTER_BUSY)
f3fdb6b2 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
7b1ef0fc 2011 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
2012 "cups-ipp-missing-job-state");
f3fdb6b2 2013 ipp_status = IPP_INTERNAL_ERROR;
2014 break;
2015 }
97fcaf92 2016 }
2017
072c4872 2018 ippDelete(response);
d1c2727f 2019
b5cb0608 2020 /*
fc596e79 2021 * Wait before polling again...
d1c2727f 2022 */
97fcaf92 2023
2ce8588b 2024 sleep(delay);
2025
fc596e79 2026 delay = _cupsNextDelay(delay, &prev_delay);
97fcaf92 2027 }
c8f9565c 2028 }
2029
6bb5a528 2030 /*
072c4872 2031 * Cancel the job as needed...
6bb5a528 2032 */
2033
c21b4ddc 2034 if (job_canceled > 0 && job_id > 0)
072c4872 2035 cancel_job(http, uri, job_id, resource, argv[2], version);
2036
2037 /*
2038 * Check the printer state and report it if necessary...
2039 */
6bb5a528 2040
4a241564 2041 check_printer_state(http, uri, resource, argv[2], version);
6bb5a528 2042
478d9bb3 2043 if (cupsLastError() <= IPP_OK_CONFLICT)
2044 password_tries = 0;
2045
eab5b04e 2046 /*
2047 * Collect the final page count as needed...
2048 */
2049
aa141f0d 2050 if (have_supplies &&
35ef82b5 2051 !backendSNMPSupplies(snmp_fd, &(http->addrlist->addr), &page_count,
2052 NULL) &&
eab5b04e 2053 page_count > start_count)
2054 fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
2055
4233257e 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
c8f9565c 2065 /*
2066 * Free memory...
2067 */
2068
2ec940b5 2069 cleanup:
2070
2071 cupsFreeOptions(num_options, options);
8211508e 2072 _ppdCacheDestroy(pc);
2d3aac27 2073 ppdClose(ppd);
2ec940b5 2074
c8f9565c 2075 httpClose(http);
c8f9565c 2076
072c4872 2077 ippDelete(supported);
2922de55 2078
c8f9565c 2079 /*
b8f3410f 2080 * Remove the temporary file(s) if necessary...
c8f9565c 2081 */
2082
940afb4b 2083 if (tmpfilename[0])
2084 unlink(tmpfilename);
2085
c8f9565c 2086 /*
2087 * Return the queue status...
2088 */
2089
c55dc24c 2090 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
d0eaf635 2091 ipp_status == IPP_AUTHENTICATION_CANCELED ||
c55dc24c 2092 ipp_status <= IPP_OK_CONFLICT)
2093 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
4233257e 2094
e35b1e23 2095 if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED)
4ab5ee04 2096 fputs("JOBSTATE: account-info-needed\n", stderr);
e35b1e23 2097 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED)
4ab5ee04 2098 fputs("JOBSTATE: account-closed\n", stderr);
e35b1e23 2099 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED)
4ab5ee04 2100 fputs("JOBSTATE: account-limit-reached\n", stderr);
e35b1e23 2101 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
4ab5ee04 2102 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2103
d0eaf635 2104 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
72429331 2105 ipp_status == IPP_AUTHENTICATION_CANCELED)
3fe655a3 2106 return (CUPS_BACKEND_AUTH_REQUIRED);
72429331 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);
f3fdb6b2 2112 else if (ipp_status == IPP_INTERNAL_ERROR)
2113 return (CUPS_BACKEND_STOP);
d78cda84 2114 else if (ipp_status == IPP_CONFLICT)
623108b2 2115 return (CUPS_BACKEND_FAILED);
d78cda84 2116 else if (ipp_status == IPP_REQUEST_VALUE ||
72429331 2117 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
d78cda84 2118 ipp_status == IPP_DOCUMENT_FORMAT || job_canceled < 0)
893cc878 2119 {
c21b4ddc 2120 if (ipp_status == IPP_REQUEST_VALUE)
2121 _cupsLangPrintFilter(stderr, "ERROR", _("Print job too large."));
d78cda84 2122 else if (ipp_status == IPP_DOCUMENT_FORMAT)
2123 _cupsLangPrintFilter(stderr, "ERROR",
2124 _("Printer cannot print supplied content."));
72429331 2125 else if (ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES)
2126 _cupsLangPrintFilter(stderr, "ERROR",
2127 _("Printer cannot print with supplied options."));
c21b4ddc 2128 else
2129 _cupsLangPrintFilter(stderr, "ERROR", _("Print job canceled at printer."));
2130
893cc878 2131 return (CUPS_BACKEND_CANCEL);
2132 }
e0d12789 2133 else if (ipp_status > IPP_OK_CONFLICT && ipp_status != IPP_ERROR_JOB_CANCELED)
5fb23099 2134 return (CUPS_BACKEND_RETRY_CURRENT);
3fe655a3 2135 else
2136 return (CUPS_BACKEND_OK);
b5cb0608 2137}
2138
2139
072c4872 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
4c4eea89 2155 _cupsLangPrintFilter(stderr, "INFO", _("Canceling print job."));
072c4872 2156
2157 request = ippNewRequest(IPP_CANCEL_JOB);
22d59a30 2158 request->request.op.version[0] = version / 10;
2159 request->request.op.version[1] = version % 10;
072c4872 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)
5fb23099 2176 _cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
072c4872 2177}
2178
2179
6bb5a528 2180/*
b9738d7c 2181 * 'check_printer_state()' - Check the printer state.
6bb5a528 2182 */
2183
b9738d7c 2184static ipp_pstate_t /* O - Current printer-state */
e12df069 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 */
4a241564 2190 int version) /* I - IPP version */
2191 {
b9738d7c 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 */
6bb5a528 2197
2198
2199 /*
b9738d7c 2200 * Send a Get-Printer-Attributes request and log the results...
6bb5a528 2201 */
2202
e12df069 2203 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
22d59a30 2204 request->request.op.version[0] = version / 10;
2205 request->request.op.version[1] = version % 10;
6bb5a528 2206
2207 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
b9738d7c 2208 NULL, uri);
6bb5a528 2209
2210 if (user && user[0])
2211 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
b9738d7c 2212 "requesting-user-name", NULL, user);
6bb5a528 2213
a6ccc6e8 2214 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
b9738d7c 2215 "requested-attributes",
2216 (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
6bb5a528 2217
2218 if ((response = cupsDoRequest(http, request, resource)) != NULL)
2219 {
4a241564 2220 report_printer_state(response);
b9738d7c 2221
2222 if ((attr = ippFindAttribute(response, "printer-state",
2223 IPP_TAG_ENUM)) != NULL)
2224 printer_state = (ipp_pstate_t)attr->values[0].integer;
2225
6bb5a528 2226 ippDelete(response);
2227 }
b9738d7c 2228
5fb23099 2229 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
2230 ippErrorString(cupsLastError()), cupsLastErrorString());
2231
b9738d7c 2232 /*
2233 * Return the printer-state value...
2234 */
2235
2236 return (printer_state);
6bb5a528 2237}
2238
2239
b9738d7c 2240/*
959a6a28 2241 * 'monitor_printer()' - Monitor the printer state.
b9738d7c 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 */
8211508e 2253 prev_delay; /* Previous delay */
5ed93a63 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 */
478d9bb3 2259 int password_tries = 0; /* Password tries */
b9738d7c 2260
2261
2262 /*
2263 * Make a copy of the printer connection...
2264 */
2265
8a5c43f4 2266 http = httpConnect2(monitor->hostname, monitor->port, NULL, AF_UNSPEC,
2267 monitor->encryption, 1, 0, NULL);
1179bc03 2268 httpSetTimeout(http, 30.0, timeout_cb, NULL);
f92e446a 2269 if (username[0])
2270 cupsSetUser(username);
478d9bb3 2271
2272 cupsSetPasswordCB2((cups_password_cb2_t)password_cb, &password_tries);
b9738d7c 2273
2274 /*
2275 * Loop until the job is canceled, aborted, or completed.
2276 */
2277
fc596e79 2278 delay = _cupsNextDelay(0, &prev_delay);
b9738d7c 2279
4ab5ee04 2280 monitor->job_reasons = 0;
2281
b9738d7c 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,
4a241564 2297 monitor->version);
478d9bb3 2298 if (cupsLastError() <= IPP_OK_CONFLICT)
2299 password_tries = 0;
b9738d7c 2300
5ed93a63 2301 /*
2302 * Check the status of the job itself...
2303 */
b9738d7c 2304
a2a8bd6a 2305 job_op = (monitor->job_id > 0 && monitor->get_job_attrs) ?
2306 IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS;
5ed93a63 2307 request = ippNewRequest(job_op);
2308 request->request.op.version[0] = monitor->version / 10;
2309 request->request.op.version[1] = monitor->version % 10;
b9738d7c 2310
5ed93a63 2311 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2312 NULL, monitor->uri);
2313 if (job_op == IPP_GET_JOB_ATTRIBUTES)
b9738d7c 2314 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
5ed93a63 2315 monitor->job_id);
b9738d7c 2316
5ed93a63 2317 if (monitor->user && monitor->user[0])
2318 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2319 "requesting-user-name", NULL, monitor->user);
b9738d7c 2320
5ed93a63 2321 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2322 "requested-attributes",
2323 (int)(sizeof(jattrs) / sizeof(jattrs[0])), NULL, jattrs);
b9738d7c 2324
5ed93a63 2325 /*
2326 * Do the request...
2327 */
b9738d7c 2328
5ed93a63 2329 response = cupsDoRequest(http, request, monitor->resource);
b9738d7c 2330
c21b4ddc 2331 fprintf(stderr, "DEBUG: (monitor) %s: %s (%s)\n", ippOpString(job_op),
5ed93a63 2332 ippErrorString(cupsLastError()), cupsLastErrorString());
5fb23099 2333
f92e446a 2334 if (cupsLastError() <= IPP_OK_CONFLICT)
2335 password_tries = 0;
2336
5ed93a63 2337 if (job_op == IPP_GET_JOB_ATTRIBUTES)
2338 {
b9738d7c 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;
5ed93a63 2344 }
ceb8f840 2345 else if (response)
5ed93a63 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;
b9738d7c 2356
5ed93a63 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 }
b9738d7c 2391 }
2392
4ab5ee04 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
5ed93a63 2437 ippDelete(response);
2438
c21b4ddc 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
b9738d7c 2447 /*
2448 * Disconnect from the printer - we'll reconnect on the next poll...
2449 */
2450
2451 _httpDisconnect(http);
2452 }
2453
2454 /*
fc596e79 2455 * Sleep for N seconds...
b9738d7c 2456 */
2457
2458 sleep(delay);
2459
fc596e79 2460 delay = _cupsNextDelay(delay, &prev_delay);
b9738d7c 2461 }
2462
5ed93a63 2463 /*
2464 * Cancel the job if necessary...
2465 */
2466
c21b4ddc 2467 if (job_canceled > 0 && monitor->job_id > 0)
5ed93a63 2468 if (!httpReconnect(http))
2469 cancel_job(http, monitor->uri, monitor->job_id, monitor->resource,
2470 monitor->user, monitor->version);
2471
b9738d7c 2472 /*
2473 * Cleanup and return...
2474 */
2475
2476 httpClose(http);
2477
2478 return (NULL);
2479}
2480
2481
2ec940b5 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 */
aa141f0d 2496 int copies, /* I - copies value or 0 */
03ab99b4 2497 const char *format, /* I - document-format value or NULL */
8211508e 2498 _ppd_cache_t *pc, /* I - PPD cache and mapping data */
2d3aac27 2499 ppd_file_t *ppd, /* I - PPD file data */
adbcb02a 2500 ipp_attribute_t *media_col_sup, /* I - media-col-supported values */
0d77fe26 2501 ipp_attribute_t *doc_handling_sup, /* I - multiple-document-handling-supported values */
2502 int print_color_mode) /* I - Printer supports print-color-mode */
2ec940b5 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 */
adbcb02a 2511 *media_type, /* media-type value */
480e077e 2512 *collate_str, /* multiple-document-handling value */
2513 *mandatory; /* Mandatory attributes */
94cbf73e 2514 ipp_tag_t group; /* Current group */
2515 ipp_attribute_t *attr; /* Current attribute */
0d77fe26 2516 const char *color_attr_name; /* Supported color attribute */
94cbf73e 2517 char buffer[1024]; /* Value buffer */
2ec940b5 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
a2f8c7bd 2555 if (format && op != IPP_CREATE_JOB)
2ec940b5 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
3c16b2a3 2563 if (compression && op != IPP_OP_CREATE_JOB && op != IPP_OP_VALIDATE_JOB)
2ec940b5 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 {
8211508e 2577 if (pc)
2ec940b5 2578 {
10a541ae 2579 int num_finishings = 0, /* Number of finishing values */
2580 finishings[10]; /* Finishing enum values */
2d3aac27 2581 ppd_choice_t *choice; /* Marked choice */
10a541ae 2582
2ec940b5 2583 /*
2584 * Send standard IPP attributes...
2585 */
2586
94cbf73e 2587 fputs("DEBUG: Adding standard IPP operation/job attributes.\n", stderr);
2588
480e077e 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));
94cbf73e 2595
2596 if ((keyword = cupsGetOption("job-password-encryption", num_options,
2597 options)) == NULL)
2598 keyword = "none";
2599
480e077e 2600 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
94cbf73e 2601 "job-password-encryption", NULL, keyword);
480e077e 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
72429331 2610 if (pc->accounting_user_id &&
480e077e 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") &&
94cbf73e 2626 strcmp(mandatory, "job-password-encryption") &&
480e077e 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
2ec940b5 2674 if ((keyword = cupsGetOption("PageSize", num_options, options)) == NULL)
2675 keyword = cupsGetOption("media", num_options, options);
2676
8211508e 2677 if ((size = _ppdCacheGetSize(pc, keyword)) != NULL)
2ec940b5 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
8211508e 2692 media_source = _ppdCacheGetSource(pc, cupsGetOption("InputSlot",
2693 num_options,
2694 options));
2695 media_type = _ppdCacheGetType(pc, cupsGetOption("MediaType",
2696 num_options,
2697 options));
2ec940b5 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,
59075862 2708 "media-bottom-margin", size->bottom);
2ec940b5 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,
59075862 2712 "media-right-margin", size->right);
2ec940b5 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,
59075862 2716 "media-top-margin", size->top);
2ec940b5 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)
2d3aac27 2732 {
2733 if ((choice = ppdFindMarkedChoice(ppd, "OutputBin")) != NULL)
2734 keyword = _ppdCacheGetBin(pc, choice->choice);
2735 }
2ec940b5 2736
2737 if (keyword)
2738 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "output-bin",
2739 NULL, keyword);
2740
0d77fe26 2741 color_attr_name = print_color_mode ? "print-color-mode" : "output-mode";
2742
480e077e 2743 if ((keyword = cupsGetOption("print-color-mode", num_options,
35420b6f 2744 options)) != NULL)
0d77fe26 2745 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, color_attr_name,
2ec940b5 2746 NULL, keyword);
2d3aac27 2747 else if ((choice = ppdFindMarkedChoice(ppd, "ColorModel")) != NULL)
2ec940b5 2748 {
2d3aac27 2749 if (!_cups_strcasecmp(choice->choice, "Gray"))
480e077e 2750 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
0d77fe26 2751 color_attr_name, NULL, "monochrome");
2ec940b5 2752 else
480e077e 2753 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD,
0d77fe26 2754 color_attr_name, NULL, "color");
2ec940b5 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));
2d3aac27 2761 else if ((choice = ppdFindMarkedChoice(ppd, "cupsPrintQuality")) != NULL)
2ec940b5 2762 {
2d3aac27 2763 if (!_cups_strcasecmp(choice->choice, "draft"))
2ec940b5 2764 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2765 IPP_QUALITY_DRAFT);
2d3aac27 2766 else if (!_cups_strcasecmp(choice->choice, "normal"))
2ec940b5 2767 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_ENUM, "print-quality",
2768 IPP_QUALITY_NORMAL);
2d3aac27 2769 else if (!_cups_strcasecmp(choice->choice, "high"))
2ec940b5 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);
8211508e 2777 else if (pc->sides_option &&
2d3aac27 2778 (choice = ppdFindMarkedChoice(ppd, pc->sides_option)) != NULL)
2ec940b5 2779 {
2d3aac27 2780 if (!_cups_strcasecmp(choice->choice, pc->sides_1sided))
2ec940b5 2781 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2782 NULL, "one-sided");
2d3aac27 2783 else if (!_cups_strcasecmp(choice->choice, pc->sides_2sided_long))
2ec940b5 2784 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2785 NULL, "two-sided-long-edge");
2d3aac27 2786 if (!_cups_strcasecmp(choice->choice, pc->sides_2sided_short))
2ec940b5 2787 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
2788 NULL, "two-sided-short-edge");
2789 }
adbcb02a 2790
0516141a 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 */
75d1b92c 2825
0516141a 2826 copies = 1;
2827 }
2828 }
2829
2830 if (doc_handling_sup)
adbcb02a 2831 {
c6fab96f 2832 if (!_cups_strcasecmp(keyword, "true"))
adbcb02a 2833 collate_str = "separate-documents-collated-copies";
2834 else
2835 collate_str = "separate-documents-uncollated-copies";
7b64ad64 2836
adbcb02a 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 }
5b95452e 2844
2845 if (i >= doc_handling_sup->num_values)
2846 copies = 1;
adbcb02a 2847 }
32f5cbae 2848
10a541ae 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);
5a9015da 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 }
2ec940b5 2885 }
2886 else
2887 {
2888 /*
2889 * When talking to another CUPS server, send all options...
2890 */
2891
94cbf73e 2892 fputs("DEBUG: Adding all operation/job attributes.\n", stderr);
2893 cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
648baa44 2894 cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
2ec940b5 2895 }
2896
75d1b92c 2897 if (copies > 1 && (!pc || copies <= pc->max_copies))
2ec940b5 2898 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", copies);
2899 }
2900
94cbf73e 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
2ec940b5 2929 return (request);
2930}
2931
2932
b5cb0608 2933/*
2934 * 'password_cb()' - Disable the password prompt for cupsDoFileRequest().
2935 */
2936
072c4872 2937static const char * /* O - Password */
9ef7dccf 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) */
478d9bb3 2942 int *password_tries) /* I - Password tries */
b5cb0608 2943{
9ef7dccf 2944 char def_username[HTTP_MAX_VALUE]; /* Default username */
2945
2946
478d9bb3 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);
f92e446a 2951
b5cb0608 2952 (void)prompt;
9ef7dccf 2953 (void)method;
2954 (void)resource;
b5cb0608 2955
4233257e 2956 /*
2957 * Remember that we need to authenticate...
2958 */
2959
2960 auth_info_required = "username,password";
2961
9ef7dccf 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
478d9bb3 2972 if (password && *password && *password_tries < 3)
9c85dfbf 2973 {
478d9bb3 2974 (*password_tries) ++;
9c85dfbf 2975
6248387b 2976 return (password);
9c85dfbf 2977 }
6248387b 2978 else
2979 {
2980 /*
4233257e 2981 * Give up after 3 tries or if we don't have a password to begin with...
6248387b 2982 */
2983
4233257e 2984 return (NULL);
6248387b 2985 }
c8f9565c 2986}
2987
2988
9ef7dccf 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
7c7997c3 3039/*
3040 * 'report_attr()' - Report an IPP attribute value.
3041 */
3042
3043static void
3044report_attr(ipp_attribute_t *attr) /* I - Attribute */
3045{
7b1ef0fc 3046 int i; /* Looping var */
3047 char value[1024], /* Value string */
9ef7dccf 3048 *valptr; /* Pointer into value string */
7b1ef0fc 3049 const char *cached; /* Cached attribute */
7c7997c3 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 :
9ef7dccf 3075 quote_string(attr->values[i].string.text, valptr,
3076 value + sizeof(value) - valptr);
3077 valptr += strlen(valptr);
7c7997c3 3078 break;
3079
3080 default :
3081 /*
3082 * Unsupported value type...
3083 */
3084
3085 return;
3086 }
3087 }
3088
3089 *valptr = '\0';
3090
6ef97027 3091 _cupsMutexLock(&report_mutex);
3092
7b1ef0fc 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 */
7c7997c3 3099
7b1ef0fc 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 }
6ef97027 3104
3105 _cupsMutexUnlock(&report_mutex);
7c7997c3 3106}
3107
3108
c8f9565c 3109/*
d1c2727f 3110 * 'report_printer_state()' - Report the printer state.
3111 */
3112
90d0da15 3113static void
4a241564 3114report_printer_state(ipp_t *ipp) /* I - IPP response */
d1c2727f 3115{
b9738d7c 3116 ipp_attribute_t *pa, /* printer-alert */
3117 *pam, /* printer-alert-message */
3118 *psm, /* printer-state-message */
7c7997c3 3119 *reasons, /* printer-state-reasons */
3120 *marker; /* marker-* attributes */
b9738d7c 3121 char value[1024], /* State/message string */
3122 *valptr; /* Pointer into string */
aa141f0d 3123 static int ipp_supplies = -1;
3124 /* Report supply levels? */
d1c2727f 3125
3126
b9738d7c 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
a6ccc6e8 3138 if ((psm = ippFindAttribute(ipp, "printer-state-message",
3139 IPP_TAG_TEXT)) != NULL)
b9738d7c 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';
57487c71 3164 *valptr = '\0';
b9738d7c 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 */
a6ccc6e8 3173
d1c2727f 3174 if ((reasons = ippFindAttribute(ipp, "printer-state-reasons",
3175 IPP_TAG_KEYWORD)) == NULL)
90d0da15 3176 return;
d1c2727f 3177
7b1ef0fc 3178 update_reasons(reasons, NULL);
8f4595eb 3179
7c7997c3 3180 /*
3181 * Relay the current marker-* attribute values...
3182 */
3183
aa141f0d 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 &&
c6fab96f 3191 ppdattr->value && _cups_strcasecmp(ppdattr->value, "true"))
aa141f0d 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 }
d1c2727f 3221}
3222
3223
959a6a28 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 */
d8f880d0 3234run_as_user(char *argv[], /* I - Command-line arguments */
959a6a28 3235 uid_t uid, /* I - User ID */
3236 const char *device_uri, /* I - Device URI */
3237 int fd) /* I - File to print */
3238{
3d5f60d1 3239 const char *auth_negotiate;/* AUTH_NEGOTIATE env var */
959a6a28 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"));
3d5f60d1 3300 if ((auth_negotiate = getenv("AUTH_NEGOTIATE")) != NULL)
3301 xpc_dictionary_set_string(request, "auth-negotiate", auth_negotiate);
959a6a28 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
d1c2727f 3416/*
8f4595eb 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
c21b4ddc 3425 write(2, "DEBUG: Got SIGTERM.\n", 20);
3426
959a6a28 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
6875feac 3435 if (!job_canceled)
072c4872 3436 {
3437 /*
959a6a28 3438 * Flag that the job should be canceled...
072c4872 3439 */
3440
c21b4ddc 3441 write(2, "DEBUG: job_canceled = 1.\n", 25);
3442
6875feac 3443 job_canceled = 1;
072c4872 3444 return;
3445 }
3446
940afb4b 3447 /*
3448 * The scheduler already tried to cancel us once, now just terminate
7b1ef0fc 3449 * after removing our temp file!
940afb4b 3450 */
3451
3452 if (tmpfilename[0])
3453 unlink(tmpfilename);
3454
8f4595eb 3455 exit(1);
3456}
3457
3458
1179bc03 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
7b1ef0fc 3474/*
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") &&
77dd74a0 3515 strncmp(reason, "spool-area-full", 15) &&
7b1ef0fc 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
480e077e 3528 new_reasons = _cupsArrayNewStrings(s, ',');
7b1ef0fc 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
6ef97027 3548 _cupsMutexLock(&report_mutex);
7b1ef0fc 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
6ef97027 3657 _cupsMutexUnlock(&report_mutex);
7b1ef0fc 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
8f4595eb 3671/*
c9d3f842 3672 * End of "$Id$".
c8f9565c 3673 */
Unnamed repository; edit this file 'description' to name the repository.