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