]> git.ipfire.org Git - thirdparty/cups.git/blob - scheduler/ipp.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Switch to using "all" and "media-col-database" because some vendors apparently
[thirdparty/cups.git] / scheduler / ipp.c
1 /*
2 * IPP routines for the CUPS scheduler.
3 *
4 * Copyright © 2007-2019 by Apple Inc.
5 * Copyright © 1997-2007 by Easy Software Products, all rights reserved.
6 *
7 * This file contains Kerberos support code, copyright 2006 by
8 * Jelmer Vernooij.
9 *
10 * Licensed under Apache License v2.0. See the file "LICENSE" for more
11 * information.
12 */
13
14 /*
15 * Include necessary headers...
16 */
17
18 #include "cupsd.h"
19 #include <cups/ppd-private.h>
20
21 #ifdef __APPLE__
22 /*# include <ApplicationServices/ApplicationServices.h>
23 extern CFUUIDRef ColorSyncCreateUUIDFromUInt32(unsigned id);
24 # include <CoreFoundation/CoreFoundation.h>*/
25 # ifdef HAVE_MEMBERSHIP_H
26 # include <membership.h>
27 # endif /* HAVE_MEMBERSHIP_H */
28 # ifdef HAVE_MEMBERSHIPPRIV_H
29 # include <membershipPriv.h>
30 # else
31 extern int mbr_user_name_to_uuid(const char* name, uuid_t uu);
32 extern int mbr_group_name_to_uuid(const char* name, uuid_t uu);
33 extern int mbr_check_membership_by_id(uuid_t user, gid_t group, int* ismember);
34 # endif /* HAVE_MEMBERSHIPPRIV_H */
35 #endif /* __APPLE__ */
36
37
38 /*
39 * Local functions...
40 */
41
42 static void accept_jobs(cupsd_client_t *con, ipp_attribute_t *uri);
43 static void add_class(cupsd_client_t *con, ipp_attribute_t *uri);
44 static int add_file(cupsd_client_t *con, cupsd_job_t *job,
45 mime_type_t *filetype, int compression);
46 static cupsd_job_t *add_job(cupsd_client_t *con, cupsd_printer_t *printer,
47 mime_type_t *filetype);
48 static void add_job_subscriptions(cupsd_client_t *con, cupsd_job_t *job);
49 static void add_job_uuid(cupsd_job_t *job);
50 static void add_printer(cupsd_client_t *con, ipp_attribute_t *uri);
51 static void add_printer_state_reasons(cupsd_client_t *con,
52 cupsd_printer_t *p);
53 static void add_queued_job_count(cupsd_client_t *con, cupsd_printer_t *p);
54 static void apply_printer_defaults(cupsd_printer_t *printer,
55 cupsd_job_t *job);
56 static void authenticate_job(cupsd_client_t *con, ipp_attribute_t *uri);
57 static void cancel_all_jobs(cupsd_client_t *con, ipp_attribute_t *uri);
58 static void cancel_job(cupsd_client_t *con, ipp_attribute_t *uri);
59 static void cancel_subscription(cupsd_client_t *con, int id);
60 static int check_rss_recipient(const char *recipient);
61 static int check_quotas(cupsd_client_t *con, cupsd_printer_t *p);
62 static void close_job(cupsd_client_t *con, ipp_attribute_t *uri);
63 static void copy_attrs(ipp_t *to, ipp_t *from, cups_array_t *ra,
64 ipp_tag_t group, int quickcopy,
65 cups_array_t *exclude);
66 static int copy_banner(cupsd_client_t *con, cupsd_job_t *job,
67 const char *name);
68 static int copy_file(const char *from, const char *to, mode_t mode);
69 static int copy_model(cupsd_client_t *con, const char *from,
70 const char *to);
71 static void copy_job_attrs(cupsd_client_t *con,
72 cupsd_job_t *job,
73 cups_array_t *ra, cups_array_t *exclude);
74 static void copy_printer_attrs(cupsd_client_t *con,
75 cupsd_printer_t *printer,
76 cups_array_t *ra);
77 static void copy_subscription_attrs(cupsd_client_t *con,
78 cupsd_subscription_t *sub,
79 cups_array_t *ra,
80 cups_array_t *exclude);
81 static void create_job(cupsd_client_t *con, ipp_attribute_t *uri);
82 static void create_local_printer(cupsd_client_t *con);
83 static cups_array_t *create_requested_array(ipp_t *request);
84 static void create_subscriptions(cupsd_client_t *con, ipp_attribute_t *uri);
85 static void delete_printer(cupsd_client_t *con, ipp_attribute_t *uri);
86 static void get_default(cupsd_client_t *con);
87 static void get_devices(cupsd_client_t *con);
88 static void get_document(cupsd_client_t *con, ipp_attribute_t *uri);
89 static void get_jobs(cupsd_client_t *con, ipp_attribute_t *uri);
90 static void get_job_attrs(cupsd_client_t *con, ipp_attribute_t *uri);
91 static void get_notifications(cupsd_client_t *con);
92 static void get_ppd(cupsd_client_t *con, ipp_attribute_t *uri);
93 static void get_ppds(cupsd_client_t *con);
94 static void get_printers(cupsd_client_t *con, int type);
95 static void get_printer_attrs(cupsd_client_t *con, ipp_attribute_t *uri);
96 static void get_printer_supported(cupsd_client_t *con, ipp_attribute_t *uri);
97 static void get_subscription_attrs(cupsd_client_t *con, int sub_id);
98 static void get_subscriptions(cupsd_client_t *con, ipp_attribute_t *uri);
99 static const char *get_username(cupsd_client_t *con);
100 static void hold_job(cupsd_client_t *con, ipp_attribute_t *uri);
101 static void hold_new_jobs(cupsd_client_t *con, ipp_attribute_t *uri);
102 static void move_job(cupsd_client_t *con, ipp_attribute_t *uri);
103 static int ppd_parse_line(const char *line, char *option, int olen,
104 char *choice, int clen);
105 static void print_job(cupsd_client_t *con, ipp_attribute_t *uri);
106 static void read_job_ticket(cupsd_client_t *con);
107 static void reject_jobs(cupsd_client_t *con, ipp_attribute_t *uri);
108 static void release_held_new_jobs(cupsd_client_t *con,
109 ipp_attribute_t *uri);
110 static void release_job(cupsd_client_t *con, ipp_attribute_t *uri);
111 static void renew_subscription(cupsd_client_t *con, int sub_id);
112 static void restart_job(cupsd_client_t *con, ipp_attribute_t *uri);
113 static void save_auth_info(cupsd_client_t *con, cupsd_job_t *job,
114 ipp_attribute_t *auth_info);
115 static void send_document(cupsd_client_t *con, ipp_attribute_t *uri);
116 static void send_http_error(cupsd_client_t *con, http_status_t status,
117 cupsd_printer_t *printer);
118 static void send_ipp_status(cupsd_client_t *con, ipp_status_t status, const char *message, ...) _CUPS_FORMAT(3, 4);
119 static void set_default(cupsd_client_t *con, ipp_attribute_t *uri);
120 static void set_job_attrs(cupsd_client_t *con, ipp_attribute_t *uri);
121 static void set_printer_attrs(cupsd_client_t *con, ipp_attribute_t *uri);
122 static int set_printer_defaults(cupsd_client_t *con, cupsd_printer_t *printer);
123 static void start_printer(cupsd_client_t *con, ipp_attribute_t *uri);
124 static void stop_printer(cupsd_client_t *con, ipp_attribute_t *uri);
125 static void url_encode_attr(ipp_attribute_t *attr, char *buffer, size_t bufsize);
126 static char *url_encode_string(const char *s, char *buffer, size_t bufsize);
127 static int user_allowed(cupsd_printer_t *p, const char *username);
128 static void validate_job(cupsd_client_t *con, ipp_attribute_t *uri);
129 static int validate_name(const char *name);
130 static int validate_user(cupsd_job_t *job, cupsd_client_t *con, const char *owner, char *username, size_t userlen);
131
132
133 /*
134 * 'cupsdProcessIPPRequest()' - Process an incoming IPP request.
135 */
136
137 int /* O - 1 on success, 0 on failure */
138 cupsdProcessIPPRequest(
139 cupsd_client_t *con) /* I - Client connection */
140 {
141 ipp_tag_t group; /* Current group tag */
142 ipp_attribute_t *attr; /* Current attribute */
143 ipp_attribute_t *charset; /* Character set attribute */
144 ipp_attribute_t *language; /* Language attribute */
145 ipp_attribute_t *uri = NULL; /* Printer or job URI attribute */
146 ipp_attribute_t *username; /* requesting-user-name attr */
147 int sub_id; /* Subscription ID */
148 int valid = 1; /* Valid request? */
149
150
151 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdProcessIPPRequest(%p[%d]): operation_id=%04x(%s)", con, con->number, con->request->request.op.operation_id, ippOpString(con->request->request.op.operation_id));
152
153 if (LogLevel >= CUPSD_LOG_DEBUG2)
154 {
155 for (group = IPP_TAG_ZERO, attr = ippFirstAttribute(con->request); attr; attr = ippNextAttribute(con->request))
156 {
157 const char *name; /* Attribute name */
158 char value[1024]; /* Attribute value */
159
160 if (group != ippGetGroupTag(attr))
161 {
162 group = ippGetGroupTag(attr);
163 if (group != IPP_TAG_ZERO)
164 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdProcessIPPRequest: %s", ippTagString(group));
165 }
166
167 if ((name = ippGetName(attr)) == NULL)
168 continue;
169
170 ippAttributeString(attr, value, sizeof(value));
171
172 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdProcessIPPRequest: %s %s%s '%s'", name, ippGetCount(attr) > 1 ? "1setOf " : "", ippTagString(ippGetValueTag(attr)), value);
173 }
174 }
175
176 /*
177 * First build an empty response message for this request...
178 */
179
180 con->response = ippNew();
181
182 con->response->request.status.version[0] = con->request->request.op.version[0];
183 con->response->request.status.version[1] = con->request->request.op.version[1];
184 con->response->request.status.request_id = con->request->request.op.request_id;
185
186 /*
187 * Then validate the request header and required attributes...
188 */
189
190 if (con->request->request.any.version[0] != 1 && con->request->request.any.version[0] != 2)
191 {
192 /*
193 * Return an error, since we only support IPP 1.x and 2.x.
194 */
195
196 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Bad request version number %d.%d.", IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED, con->http->hostname, con->request->request.any.version[0], con->request->request.any.version[1]);
197
198 send_ipp_status(con, IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED, _("Bad request version number %d.%d."), con->request->request.any.version[0], con->request->request.any.version[1]);
199 }
200 else if (con->request->request.any.request_id < 1)
201 {
202 /*
203 * Return an error, since request IDs must be between 1 and 2^31-1
204 */
205
206 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Bad request ID %d.", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname, con->request->request.any.request_id);
207
208 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Bad request ID %d."), con->request->request.any.request_id);
209 }
210 else if (!con->request->attrs)
211 {
212 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s No attributes in request.", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname);
213
214 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("No attributes in request."));
215 }
216 else
217 {
218 /*
219 * Make sure that the attributes are provided in the correct order and
220 * don't repeat groups...
221 */
222
223 for (attr = con->request->attrs, group = attr->group_tag;
224 attr;
225 attr = attr->next)
226 if (attr->group_tag < group && attr->group_tag != IPP_TAG_ZERO)
227 {
228 /*
229 * Out of order; return an error...
230 */
231
232 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Attribute groups are out of order", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname);
233
234 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Attribute groups are out of order (%x < %x)."), attr->group_tag, group);
235 break;
236 }
237 else
238 group = attr->group_tag;
239
240 if (!attr)
241 {
242 /*
243 * Then make sure that the first three attributes are:
244 *
245 * attributes-charset
246 * attributes-natural-language
247 * printer-uri/job-uri
248 */
249
250 attr = con->request->attrs;
251 if (attr && attr->name && !strcmp(attr->name, "attributes-charset") && (attr->value_tag & IPP_TAG_MASK) == IPP_TAG_CHARSET && attr->group_tag == IPP_TAG_OPERATION)
252 charset = attr;
253 else
254 charset = NULL;
255
256 if (attr)
257 attr = attr->next;
258
259 if (attr && attr->name && !strcmp(attr->name, "attributes-natural-language") && (attr->value_tag & IPP_TAG_MASK) == IPP_TAG_LANGUAGE && attr->group_tag == IPP_TAG_OPERATION)
260 {
261 language = attr;
262
263 /*
264 * Reset language for this request if different from Accept-Language.
265 */
266
267 if (!con->language ||
268 strcmp(attr->values[0].string.text, con->language->language))
269 {
270 cupsLangFree(con->language);
271 con->language = cupsLangGet(attr->values[0].string.text);
272 }
273 }
274 else
275 language = NULL;
276
277 if ((attr = ippFindAttribute(con->request, "printer-uri", IPP_TAG_URI)) != NULL && attr->group_tag == IPP_TAG_OPERATION)
278 uri = attr;
279 else if ((attr = ippFindAttribute(con->request, "job-uri", IPP_TAG_URI)) != NULL && attr->group_tag == IPP_TAG_OPERATION)
280 uri = attr;
281 else if (con->request->request.op.operation_id == CUPS_GET_PPD && (attr = ippFindAttribute(con->request, "ppd-name", IPP_TAG_NAME)) != NULL && attr->group_tag == IPP_TAG_OPERATION)
282 uri = attr;
283 else
284 uri = NULL;
285
286 if (charset)
287 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, charset->values[0].string.text);
288 else
289 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_CHARSET, "attributes-charset", NULL, "utf-8");
290
291 if (language)
292 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, language->values[0].string.text);
293 else
294 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "attributes-natural-language", NULL, DefaultLanguage);
295
296 if (charset && _cups_strcasecmp(charset->values[0].string.text, "us-ascii") && _cups_strcasecmp(charset->values[0].string.text, "utf-8"))
297 {
298 /*
299 * Bad character set...
300 */
301
302 cupsdLogMessage(CUPSD_LOG_ERROR, "Unsupported character set \"%s\"",
303 charset->values[0].string.text);
304 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Unsupported attributes-charset value \"%s\".", IPP_STATUS_ERROR_CHARSET, con->http->hostname, charset->values[0].string.text);
305 send_ipp_status(con, IPP_STATUS_ERROR_CHARSET, _("Unsupported character set \"%s\"."), charset->values[0].string.text);
306 }
307 else if (!charset || !language ||
308 (!uri &&
309 con->request->request.op.operation_id != CUPS_GET_DEFAULT &&
310 con->request->request.op.operation_id != CUPS_GET_PRINTERS &&
311 con->request->request.op.operation_id != CUPS_GET_CLASSES &&
312 con->request->request.op.operation_id != CUPS_GET_DEVICES &&
313 con->request->request.op.operation_id != CUPS_GET_PPDS))
314 {
315 /*
316 * Return an error, since attributes-charset,
317 * attributes-natural-language, and printer-uri/job-uri are required
318 * for all operations.
319 */
320
321 if (!charset)
322 {
323 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing attributes-charset attribute.");
324
325 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Missing attributes-charset attribute.", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname);
326 }
327
328 if (!language)
329 {
330 cupsdLogMessage(CUPSD_LOG_ERROR,
331 "Missing attributes-natural-language attribute.");
332
333 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Missing attributes-natural-language attribute.", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname);
334 }
335
336 if (!uri)
337 {
338 cupsdLogMessage(CUPSD_LOG_ERROR, "Missing printer-uri, job-uri, or ppd-name attribute.");
339
340 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Missing printer-uri, job-uri, or ppd-name attribute.", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname);
341 }
342
343 cupsdLogMessage(CUPSD_LOG_DEBUG, "Request attributes follow...");
344
345 for (attr = con->request->attrs; attr; attr = attr->next)
346 cupsdLogMessage(CUPSD_LOG_DEBUG,
347 "attr \"%s\": group_tag = %x, value_tag = %x",
348 attr->name ? attr->name : "(null)", attr->group_tag,
349 attr->value_tag);
350
351 cupsdLogMessage(CUPSD_LOG_DEBUG, "End of attributes...");
352
353 send_ipp_status(con, IPP_BAD_REQUEST,
354 _("Missing required attributes."));
355 }
356 else
357 {
358 /*
359 * OK, all the checks pass so far; validate "requesting-user-name"
360 * attribute value...
361 */
362
363 if ((username = ippFindAttribute(con->request, "requesting-user-name", IPP_TAG_ZERO)) != NULL)
364 {
365 /*
366 * Validate "requesting-user-name"...
367 */
368
369 if (username->group_tag != IPP_TAG_OPERATION && StrictConformance)
370 {
371 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s \"requesting-user-name\" attribute in wrong group.", IPP_STATUS_ERROR_BAD_REQUEST, con->http->hostname);
372 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("\"requesting-user-name\" attribute in wrong group."));
373 valid = 0;
374 }
375 else if (username->value_tag != IPP_TAG_NAME && username->value_tag != IPP_TAG_NAMELANG)
376 {
377 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s \"requesting-user-name\" attribute with wrong syntax.", IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, con->http->hostname);
378 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("\"requesting-user-name\" attribute with wrong syntax."));
379 if ((attr = ippCopyAttribute(con->response, username, 0)) != NULL)
380 attr->group_tag = IPP_TAG_UNSUPPORTED_GROUP;
381 valid = 0;
382 }
383 else if (!ippValidateAttribute(username))
384 {
385 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s \"requesting-user-name\" attribute with bad value.", IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, con->http->hostname);
386
387 if (StrictConformance)
388 {
389 /*
390 * Throw an error...
391 */
392
393 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("\"requesting-user-name\" attribute with wrong syntax."));
394 if ((attr = ippCopyAttribute(con->response, username, 0)) != NULL)
395 attr->group_tag = IPP_TAG_UNSUPPORTED_GROUP;
396 valid = 0;
397 }
398 else
399 {
400 /*
401 * Map bad "requesting-user-name" to 'anonymous'...
402 */
403
404 ippSetString(con->request, &username, 0, "anonymous");
405 }
406 }
407 else if (!strcmp(username->values[0].string.text, "root") && _cups_strcasecmp(con->http->hostname, "localhost") && strcmp(con->username, "root"))
408 {
409 /*
410 * Remote unauthenticated user masquerading as local root...
411 */
412
413 ippSetString(con->request, &username, 0, RemoteRoot);
414 }
415 }
416
417 if ((attr = ippFindAttribute(con->request, "notify-subscription-id", IPP_TAG_INTEGER)) != NULL)
418 sub_id = attr->values[0].integer;
419 else
420 sub_id = 0;
421
422 if (valid)
423 {
424 /*
425 * Try processing the operation...
426 */
427
428 if (uri)
429 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s %s", ippOpString(con->request->request.op.operation_id), uri->values[0].string.text);
430 else
431 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s", ippOpString(con->request->request.op.operation_id));
432
433 switch (con->request->request.op.operation_id)
434 {
435 case IPP_OP_PRINT_JOB :
436 print_job(con, uri);
437 break;
438
439 case IPP_OP_VALIDATE_JOB :
440 validate_job(con, uri);
441 break;
442
443 case IPP_OP_CREATE_JOB :
444 create_job(con, uri);
445 break;
446
447 case IPP_OP_SEND_DOCUMENT :
448 send_document(con, uri);
449 break;
450
451 case IPP_OP_CANCEL_JOB :
452 cancel_job(con, uri);
453 break;
454
455 case IPP_OP_GET_JOB_ATTRIBUTES :
456 get_job_attrs(con, uri);
457 break;
458
459 case IPP_OP_GET_JOBS :
460 get_jobs(con, uri);
461 break;
462
463 case IPP_OP_GET_PRINTER_ATTRIBUTES :
464 get_printer_attrs(con, uri);
465 break;
466
467 case IPP_OP_GET_PRINTER_SUPPORTED_VALUES :
468 get_printer_supported(con, uri);
469 break;
470
471 case IPP_OP_HOLD_JOB :
472 hold_job(con, uri);
473 break;
474
475 case IPP_OP_RELEASE_JOB :
476 release_job(con, uri);
477 break;
478
479 case IPP_OP_RESTART_JOB :
480 restart_job(con, uri);
481 break;
482
483 case IPP_OP_PAUSE_PRINTER :
484 stop_printer(con, uri);
485 break;
486
487 case IPP_OP_RESUME_PRINTER :
488 start_printer(con, uri);
489 break;
490
491 case IPP_OP_PURGE_JOBS :
492 case IPP_OP_CANCEL_JOBS :
493 case IPP_OP_CANCEL_MY_JOBS :
494 cancel_all_jobs(con, uri);
495 break;
496
497 case IPP_OP_SET_JOB_ATTRIBUTES :
498 set_job_attrs(con, uri);
499 break;
500
501 case IPP_OP_SET_PRINTER_ATTRIBUTES :
502 set_printer_attrs(con, uri);
503 break;
504
505 case IPP_OP_HOLD_NEW_JOBS :
506 hold_new_jobs(con, uri);
507 break;
508
509 case IPP_OP_RELEASE_HELD_NEW_JOBS :
510 release_held_new_jobs(con, uri);
511 break;
512
513 case IPP_OP_CLOSE_JOB :
514 close_job(con, uri);
515 break;
516
517 case IPP_OP_CUPS_GET_DEFAULT :
518 get_default(con);
519 break;
520
521 case IPP_OP_CUPS_GET_PRINTERS :
522 get_printers(con, 0);
523 break;
524
525 case IPP_OP_CUPS_GET_CLASSES :
526 get_printers(con, CUPS_PRINTER_CLASS);
527 break;
528
529 case IPP_OP_CUPS_ADD_MODIFY_PRINTER :
530 add_printer(con, uri);
531 break;
532
533 case IPP_OP_CUPS_DELETE_PRINTER :
534 delete_printer(con, uri);
535 break;
536
537 case IPP_OP_CUPS_ADD_MODIFY_CLASS :
538 add_class(con, uri);
539 break;
540
541 case IPP_OP_CUPS_DELETE_CLASS :
542 delete_printer(con, uri);
543 break;
544
545 case IPP_OP_CUPS_ACCEPT_JOBS :
546 case IPP_OP_ENABLE_PRINTER :
547 accept_jobs(con, uri);
548 break;
549
550 case IPP_OP_CUPS_REJECT_JOBS :
551 case IPP_OP_DISABLE_PRINTER :
552 reject_jobs(con, uri);
553 break;
554
555 case IPP_OP_CUPS_SET_DEFAULT :
556 set_default(con, uri);
557 break;
558
559 case IPP_OP_CUPS_GET_DEVICES :
560 get_devices(con);
561 break;
562
563 case IPP_OP_CUPS_GET_DOCUMENT :
564 get_document(con, uri);
565 break;
566
567 case IPP_OP_CUPS_GET_PPD :
568 get_ppd(con, uri);
569 break;
570
571 case IPP_OP_CUPS_GET_PPDS :
572 get_ppds(con);
573 break;
574
575 case IPP_OP_CUPS_MOVE_JOB :
576 move_job(con, uri);
577 break;
578
579 case IPP_OP_CUPS_AUTHENTICATE_JOB :
580 authenticate_job(con, uri);
581 break;
582
583 case IPP_OP_CREATE_PRINTER_SUBSCRIPTIONS :
584 case IPP_OP_CREATE_JOB_SUBSCRIPTIONS :
585 create_subscriptions(con, uri);
586 break;
587
588 case IPP_OP_GET_SUBSCRIPTION_ATTRIBUTES :
589 get_subscription_attrs(con, sub_id);
590 break;
591
592 case IPP_OP_GET_SUBSCRIPTIONS :
593 get_subscriptions(con, uri);
594 break;
595
596 case IPP_OP_RENEW_SUBSCRIPTION :
597 renew_subscription(con, sub_id);
598 break;
599
600 case IPP_OP_CANCEL_SUBSCRIPTION :
601 cancel_subscription(con, sub_id);
602 break;
603
604 case IPP_OP_GET_NOTIFICATIONS :
605 get_notifications(con);
606 break;
607
608 case IPP_OP_CUPS_CREATE_LOCAL_PRINTER :
609 create_local_printer(con);
610 break;
611
612 default :
613 cupsdAddEvent(CUPSD_EVENT_SERVER_AUDIT, NULL, NULL, "%04X %s Operation %04X (%s) not supported.", IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED, con->http->hostname, con->request->request.op.operation_id, ippOpString(con->request->request.op.operation_id));
614
615 send_ipp_status(con, IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED, _("%s not supported."), ippOpString(con->request->request.op.operation_id));
616 break;
617 }
618 }
619 }
620 }
621 }
622
623 if (con->response)
624 {
625 /*
626 * Sending data from the scheduler...
627 */
628
629 cupsdLogClient(con, con->response->request.status.status_code >= IPP_STATUS_ERROR_BAD_REQUEST && con->response->request.status.status_code != IPP_STATUS_ERROR_NOT_FOUND ? CUPSD_LOG_ERROR : CUPSD_LOG_DEBUG, "Returning IPP %s for %s (%s) from %s.", ippErrorString(con->response->request.status.status_code), ippOpString(con->request->request.op.operation_id), uri ? uri->values[0].string.text : "no URI", con->http->hostname);
630
631 httpClearFields(con->http);
632
633 #ifdef CUPSD_USE_CHUNKING
634 /*
635 * Because older versions of CUPS (1.1.17 and older) and some IPP
636 * clients do not implement chunking properly, we cannot use
637 * chunking by default. This may become the default in future
638 * CUPS releases, or we might add a configuration directive for
639 * it.
640 */
641
642 if (con->http->version == HTTP_1_1)
643 {
644 cupsdLogClient(con, CUPSD_LOG_DEBUG, "Transfer-Encoding: chunked");
645 cupsdSetLength(con->http, 0);
646 }
647 else
648 #endif /* CUPSD_USE_CHUNKING */
649 {
650 size_t length; /* Length of response */
651
652
653 length = ippLength(con->response);
654
655 if (con->file >= 0 && !con->pipe_pid)
656 {
657 struct stat fileinfo; /* File information */
658
659 if (!fstat(con->file, &fileinfo))
660 length += (size_t)fileinfo.st_size;
661 }
662
663 cupsdLogClient(con, CUPSD_LOG_DEBUG, "Content-Length: " CUPS_LLFMT, CUPS_LLCAST length);
664 httpSetLength(con->http, length);
665 }
666
667 if (cupsdSendHeader(con, HTTP_OK, "application/ipp", CUPSD_AUTH_NONE))
668 {
669 /*
670 * Tell the caller the response header was sent successfully...
671 */
672
673 cupsdAddSelect(httpGetFd(con->http), (cupsd_selfunc_t)cupsdReadClient, (cupsd_selfunc_t)cupsdWriteClient, con);
674
675 return (1);
676 }
677 else
678 {
679 /*
680 * Tell the caller the response header could not be sent...
681 */
682
683 return (0);
684 }
685 }
686 else
687 {
688 /*
689 * Sending data from a subprocess like cups-deviced; tell the caller
690 * everything is A-OK so far...
691 */
692
693 return (1);
694 }
695 }
696
697
698 /*
699 * 'cupsdTimeoutJob()' - Timeout a job waiting on job files.
700 */
701
702 int /* O - 0 on success, -1 on error */
703 cupsdTimeoutJob(cupsd_job_t *job) /* I - Job to timeout */
704 {
705 cupsd_printer_t *printer; /* Destination printer or class */
706 ipp_attribute_t *attr; /* job-sheets attribute */
707 int kbytes; /* Kilobytes in banner */
708
709
710 job->pending_timeout = 0;
711
712 /*
713 * See if we need to add the ending sheet...
714 */
715
716 if (!cupsdLoadJob(job))
717 return (-1);
718
719 printer = cupsdFindDest(job->dest);
720 attr = ippFindAttribute(job->attrs, "job-sheets", IPP_TAG_NAME);
721
722 if (printer && !(printer->type & CUPS_PRINTER_REMOTE) &&
723 attr && attr->num_values > 1)
724 {
725 /*
726 * Yes...
727 */
728
729 cupsdLogJob(job, CUPSD_LOG_INFO, "Adding end banner page \"%s\".",
730 attr->values[1].string.text);
731
732 if ((kbytes = copy_banner(NULL, job, attr->values[1].string.text)) < 0)
733 return (-1);
734
735 cupsdUpdateQuota(printer, job->username, 0, kbytes);
736 }
737
738 return (0);
739 }
740
741
742 /*
743 * 'accept_jobs()' - Accept print jobs to a printer.
744 */
745
746 static void
747 accept_jobs(cupsd_client_t *con, /* I - Client connection */
748 ipp_attribute_t *uri) /* I - Printer or class URI */
749 {
750 http_status_t status; /* Policy status */
751 cups_ptype_t dtype; /* Destination type (printer/class) */
752 cupsd_printer_t *printer; /* Printer data */
753
754
755 cupsdLogMessage(CUPSD_LOG_DEBUG2, "accept_jobs(%p[%d], %s)", con,
756 con->number, uri->values[0].string.text);
757
758 /*
759 * Is the destination valid?
760 */
761
762 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
763 {
764 /*
765 * Bad URI...
766 */
767
768 send_ipp_status(con, IPP_NOT_FOUND,
769 _("The printer or class does not exist."));
770 return;
771 }
772
773 /*
774 * Check policy...
775 */
776
777 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
778 {
779 send_http_error(con, status, printer);
780 return;
781 }
782
783 /*
784 * Accept jobs sent to the printer...
785 */
786
787 printer->accepting = 1;
788 printer->state_message[0] = '\0';
789
790 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, printer, NULL,
791 "Now accepting jobs.");
792
793 if (dtype & CUPS_PRINTER_CLASS)
794 {
795 cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
796
797 cupsdLogMessage(CUPSD_LOG_INFO, "Class \"%s\" now accepting jobs (\"%s\").",
798 printer->name, get_username(con));
799 }
800 else
801 {
802 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
803
804 cupsdLogMessage(CUPSD_LOG_INFO,
805 "Printer \"%s\" now accepting jobs (\"%s\").",
806 printer->name, get_username(con));
807 }
808
809 /*
810 * Everything was ok, so return OK status...
811 */
812
813 con->response->request.status.status_code = IPP_OK;
814 }
815
816
817 /*
818 * 'add_class()' - Add a class to the system.
819 */
820
821 static void
822 add_class(cupsd_client_t *con, /* I - Client connection */
823 ipp_attribute_t *uri) /* I - URI of class */
824 {
825 http_status_t status; /* Policy status */
826 int i; /* Looping var */
827 char scheme[HTTP_MAX_URI], /* Method portion of URI */
828 username[HTTP_MAX_URI], /* Username portion of URI */
829 host[HTTP_MAX_URI], /* Host portion of URI */
830 resource[HTTP_MAX_URI]; /* Resource portion of URI */
831 int port; /* Port portion of URI */
832 cupsd_printer_t *pclass, /* Class */
833 *member; /* Member printer/class */
834 cups_ptype_t dtype; /* Destination type */
835 ipp_attribute_t *attr; /* Printer attribute */
836 int modify; /* Non-zero if we just modified */
837 int need_restart_job; /* Need to restart job? */
838
839
840 cupsdLogMessage(CUPSD_LOG_DEBUG2, "add_class(%p[%d], %s)", con,
841 con->number, uri->values[0].string.text);
842
843 /*
844 * Do we have a valid URI?
845 */
846
847 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
848 sizeof(scheme), username, sizeof(username), host,
849 sizeof(host), &port, resource, sizeof(resource));
850
851
852 if (strncmp(resource, "/classes/", 9) || strlen(resource) == 9)
853 {
854 /*
855 * No, return an error...
856 */
857
858 send_ipp_status(con, IPP_BAD_REQUEST,
859 _("The printer-uri must be of the form "
860 "\"ipp://HOSTNAME/classes/CLASSNAME\"."));
861 return;
862 }
863
864 /*
865 * Do we have a valid printer name?
866 */
867
868 if (!validate_name(resource + 9))
869 {
870 /*
871 * No, return an error...
872 */
873
874 send_ipp_status(con, IPP_BAD_REQUEST,
875 _("The printer-uri \"%s\" contains invalid characters."),
876 uri->values[0].string.text);
877 return;
878 }
879
880 /*
881 * See if the class already exists; if not, create a new class...
882 */
883
884 if ((pclass = cupsdFindClass(resource + 9)) == NULL)
885 {
886 /*
887 * Class doesn't exist; see if we have a printer of the same name...
888 */
889
890 if ((pclass = cupsdFindPrinter(resource + 9)) != NULL)
891 {
892 /*
893 * Yes, return an error...
894 */
895
896 send_ipp_status(con, IPP_NOT_POSSIBLE,
897 _("A printer named \"%s\" already exists."),
898 resource + 9);
899 return;
900 }
901
902 /*
903 * No, check the default policy and then add the class...
904 */
905
906 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
907 {
908 send_http_error(con, status, NULL);
909 return;
910 }
911
912 pclass = cupsdAddClass(resource + 9);
913 modify = 0;
914
915 pclass->printer_id = NextPrinterId ++;
916 }
917 else if ((status = cupsdCheckPolicy(pclass->op_policy_ptr, con,
918 NULL)) != HTTP_OK)
919 {
920 send_http_error(con, status, pclass);
921 return;
922 }
923 else
924 modify = 1;
925
926 /*
927 * Look for attributes and copy them over as needed...
928 */
929
930 need_restart_job = 0;
931
932 if ((attr = ippFindAttribute(con->request, "printer-location", IPP_TAG_TEXT)) != NULL)
933 cupsdSetString(&pclass->location, attr->values[0].string.text);
934
935 if ((attr = ippFindAttribute(con->request, "printer-geo-location", IPP_TAG_URI)) != NULL && !strncmp(attr->values[0].string.text, "geo:", 4))
936 cupsdSetString(&pclass->geo_location, attr->values[0].string.text);
937
938 if ((attr = ippFindAttribute(con->request, "printer-organization", IPP_TAG_TEXT)) != NULL)
939 cupsdSetString(&pclass->organization, attr->values[0].string.text);
940
941 if ((attr = ippFindAttribute(con->request, "printer-organizational-unit", IPP_TAG_TEXT)) != NULL)
942 cupsdSetString(&pclass->organizational_unit, attr->values[0].string.text);
943
944 if ((attr = ippFindAttribute(con->request, "printer-info",
945 IPP_TAG_TEXT)) != NULL)
946 cupsdSetString(&pclass->info, attr->values[0].string.text);
947
948 if ((attr = ippFindAttribute(con->request, "printer-is-accepting-jobs",
949 IPP_TAG_BOOLEAN)) != NULL &&
950 attr->values[0].boolean != pclass->accepting)
951 {
952 cupsdLogMessage(CUPSD_LOG_INFO,
953 "Setting %s printer-is-accepting-jobs to %d (was %d.)",
954 pclass->name, attr->values[0].boolean, pclass->accepting);
955
956 pclass->accepting = attr->values[0].boolean;
957
958 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, pclass, NULL, "%s accepting jobs.",
959 pclass->accepting ? "Now" : "No longer");
960 }
961
962 if ((attr = ippFindAttribute(con->request, "printer-is-shared", IPP_TAG_BOOLEAN)) != NULL)
963 {
964 if (pclass->type & CUPS_PRINTER_REMOTE)
965 {
966 /*
967 * Cannot re-share remote printers.
968 */
969
970 send_ipp_status(con, IPP_BAD_REQUEST, _("Cannot change printer-is-shared for remote queues."));
971 if (!modify)
972 cupsdDeletePrinter(pclass, 0);
973
974 return;
975 }
976
977 if (pclass->shared && !ippGetBoolean(attr, 0))
978 cupsdDeregisterPrinter(pclass, 1);
979
980 cupsdLogMessage(CUPSD_LOG_INFO,
981 "Setting %s printer-is-shared to %d (was %d.)",
982 pclass->name, attr->values[0].boolean, pclass->shared);
983
984 pclass->shared = ippGetBoolean(attr, 0);
985 }
986
987 if ((attr = ippFindAttribute(con->request, "printer-state",
988 IPP_TAG_ENUM)) != NULL)
989 {
990 if (attr->values[0].integer != IPP_PRINTER_IDLE &&
991 attr->values[0].integer != IPP_PRINTER_STOPPED)
992 {
993 send_ipp_status(con, IPP_BAD_REQUEST,
994 _("Attempt to set %s printer-state to bad value %d."),
995 pclass->name, attr->values[0].integer);
996 if (!modify)
997 cupsdDeletePrinter(pclass, 0);
998
999 return;
1000 }
1001
1002 cupsdLogMessage(CUPSD_LOG_INFO, "Setting %s printer-state to %d (was %d.)",
1003 pclass->name, attr->values[0].integer, pclass->state);
1004
1005 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
1006 cupsdStopPrinter(pclass, 0);
1007 else
1008 {
1009 cupsdSetPrinterState(pclass, (ipp_pstate_t)(attr->values[0].integer), 0);
1010 need_restart_job = 1;
1011 }
1012 }
1013 if ((attr = ippFindAttribute(con->request, "printer-state-message",
1014 IPP_TAG_TEXT)) != NULL)
1015 {
1016 strlcpy(pclass->state_message, attr->values[0].string.text,
1017 sizeof(pclass->state_message));
1018
1019 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, pclass, NULL, "%s",
1020 pclass->state_message);
1021 }
1022 if ((attr = ippFindAttribute(con->request, "member-uris",
1023 IPP_TAG_URI)) != NULL)
1024 {
1025 /*
1026 * Clear the printer array as needed...
1027 */
1028
1029 need_restart_job = 1;
1030
1031 if (pclass->num_printers > 0)
1032 {
1033 free(pclass->printers);
1034 pclass->num_printers = 0;
1035 }
1036
1037 /*
1038 * Add each printer or class that is listed...
1039 */
1040
1041 for (i = 0; i < attr->num_values; i ++)
1042 {
1043 /*
1044 * Search for the printer or class URI...
1045 */
1046
1047 if (!cupsdValidateDest(attr->values[i].string.text, &dtype, &member))
1048 {
1049 /*
1050 * Bad URI...
1051 */
1052
1053 send_ipp_status(con, IPP_NOT_FOUND,
1054 _("The printer or class does not exist."));
1055 if (!modify)
1056 cupsdDeletePrinter(pclass, 0);
1057
1058 return;
1059 }
1060 else if (dtype & CUPS_PRINTER_CLASS)
1061 {
1062 send_ipp_status(con, IPP_BAD_REQUEST,
1063 _("Nested classes are not allowed."));
1064 if (!modify)
1065 cupsdDeletePrinter(pclass, 0);
1066
1067 return;
1068 }
1069
1070 /*
1071 * Add it to the class...
1072 */
1073
1074 cupsdAddPrinterToClass(pclass, member);
1075 }
1076 }
1077
1078 if (!set_printer_defaults(con, pclass))
1079 {
1080 if (!modify)
1081 cupsdDeletePrinter(pclass, 0);
1082
1083 return;
1084 }
1085
1086 if ((attr = ippFindAttribute(con->request, "auth-info-required",
1087 IPP_TAG_KEYWORD)) != NULL)
1088 cupsdSetAuthInfoRequired(pclass, NULL, attr);
1089
1090 pclass->config_time = time(NULL);
1091
1092 /*
1093 * Update the printer class attributes and return...
1094 */
1095
1096 cupsdSetPrinterAttrs(pclass);
1097 cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
1098
1099 if (need_restart_job && pclass->job)
1100 {
1101 /*
1102 * Reset the current job to a "pending" status...
1103 */
1104
1105 cupsdSetJobState(pclass->job, IPP_JOB_PENDING, CUPSD_JOB_FORCE,
1106 "Job restarted because the class was modified.");
1107 }
1108
1109 cupsdMarkDirty(CUPSD_DIRTY_PRINTCAP);
1110
1111 if (modify)
1112 {
1113 cupsdAddEvent(CUPSD_EVENT_PRINTER_MODIFIED,
1114 pclass, NULL, "Class \"%s\" modified by \"%s\".",
1115 pclass->name, get_username(con));
1116
1117 cupsdLogMessage(CUPSD_LOG_INFO, "Class \"%s\" modified by \"%s\".",
1118 pclass->name, get_username(con));
1119 }
1120 else
1121 {
1122 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED,
1123 pclass, NULL, "New class \"%s\" added by \"%s\".",
1124 pclass->name, get_username(con));
1125
1126 cupsdLogMessage(CUPSD_LOG_INFO, "New class \"%s\" added by \"%s\".",
1127 pclass->name, get_username(con));
1128 }
1129
1130 con->response->request.status.status_code = IPP_OK;
1131 }
1132
1133
1134 /*
1135 * 'add_file()' - Add a file to a job.
1136 */
1137
1138 static int /* O - 0 on success, -1 on error */
1139 add_file(cupsd_client_t *con, /* I - Connection to client */
1140 cupsd_job_t *job, /* I - Job to add to */
1141 mime_type_t *filetype, /* I - Type of file */
1142 int compression) /* I - Compression */
1143 {
1144 mime_type_t **filetypes; /* New filetypes array... */
1145 int *compressions; /* New compressions array... */
1146
1147
1148 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1149 "add_file(con=%p[%d], job=%d, filetype=%s/%s, "
1150 "compression=%d)", con, con ? con->number : -1, job->id,
1151 filetype->super, filetype->type, compression);
1152
1153 /*
1154 * Add the file to the job...
1155 */
1156
1157 if (job->num_files == 0)
1158 {
1159 compressions = (int *)malloc(sizeof(int));
1160 filetypes = (mime_type_t **)malloc(sizeof(mime_type_t *));
1161 }
1162 else
1163 {
1164 compressions = (int *)realloc(job->compressions,
1165 (size_t)(job->num_files + 1) * sizeof(int));
1166 filetypes = (mime_type_t **)realloc(job->filetypes,
1167 (size_t)(job->num_files + 1) *
1168 sizeof(mime_type_t *));
1169 }
1170
1171 if (compressions)
1172 job->compressions = compressions;
1173
1174 if (filetypes)
1175 job->filetypes = filetypes;
1176
1177 if (!compressions || !filetypes)
1178 {
1179 cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_PURGE,
1180 "Job aborted because the scheduler ran out of memory.");
1181
1182 if (con)
1183 send_ipp_status(con, IPP_INTERNAL_ERROR,
1184 _("Unable to allocate memory for file types."));
1185
1186 return (-1);
1187 }
1188
1189 job->compressions[job->num_files] = compression;
1190 job->filetypes[job->num_files] = filetype;
1191
1192 job->num_files ++;
1193
1194 job->dirty = 1;
1195 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
1196
1197 return (0);
1198 }
1199
1200
1201 /*
1202 * 'add_job()' - Add a job to a print queue.
1203 */
1204
1205 static cupsd_job_t * /* O - Job object */
1206 add_job(cupsd_client_t *con, /* I - Client connection */
1207 cupsd_printer_t *printer, /* I - Destination printer */
1208 mime_type_t *filetype) /* I - First print file type, if any */
1209 {
1210 http_status_t status; /* Policy status */
1211 ipp_attribute_t *attr, /* Current attribute */
1212 *auth_info; /* auth-info attribute */
1213 const char *mandatory; /* Current mandatory job attribute */
1214 const char *val; /* Default option value */
1215 int priority; /* Job priority */
1216 cupsd_job_t *job; /* Current job */
1217 char job_uri[HTTP_MAX_URI]; /* Job URI */
1218 int kbytes; /* Size of print file */
1219 int i; /* Looping var */
1220 int lowerpagerange; /* Page range bound */
1221 int exact; /* Did we have an exact match? */
1222 ipp_attribute_t *media_col, /* media-col attribute */
1223 *media_margin; /* media-*-margin attribute */
1224 ipp_t *unsup_col; /* media-col in unsupported response */
1225 static const char * const readonly[] =/* List of read-only attributes */
1226 {
1227 "date-time-at-completed",
1228 "date-time-at-creation",
1229 "date-time-at-processing",
1230 "job-detailed-status-messages",
1231 "job-document-access-errors",
1232 "job-id",
1233 "job-impressions-completed",
1234 "job-k-octets-completed",
1235 "job-media-sheets-completed",
1236 "job-pages-completed",
1237 "job-printer-up-time",
1238 "job-printer-uri",
1239 "job-state",
1240 "job-state-message",
1241 "job-state-reasons",
1242 "job-uri",
1243 "number-of-documents",
1244 "number-of-intervening-jobs",
1245 "output-device-assigned",
1246 "time-at-completed",
1247 "time-at-creation",
1248 "time-at-processing"
1249 };
1250
1251
1252 cupsdLogMessage(CUPSD_LOG_DEBUG2, "add_job(%p[%d], %p(%s), %p(%s/%s))",
1253 con, con->number, printer, printer->name,
1254 filetype, filetype ? filetype->super : "none",
1255 filetype ? filetype->type : "none");
1256
1257 /*
1258 * Check remote printing to non-shared printer...
1259 */
1260
1261 if (!printer->shared &&
1262 _cups_strcasecmp(con->http->hostname, "localhost") &&
1263 _cups_strcasecmp(con->http->hostname, ServerName))
1264 {
1265 send_ipp_status(con, IPP_NOT_AUTHORIZED,
1266 _("The printer or class is not shared."));
1267 return (NULL);
1268 }
1269
1270 /*
1271 * Check policy...
1272 */
1273
1274 auth_info = ippFindAttribute(con->request, "auth-info", IPP_TAG_TEXT);
1275
1276 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
1277 {
1278 send_http_error(con, status, printer);
1279 return (NULL);
1280 }
1281 else if (printer->num_auth_info_required == 1 &&
1282 !strcmp(printer->auth_info_required[0], "negotiate") &&
1283 !con->username[0])
1284 {
1285 send_http_error(con, HTTP_UNAUTHORIZED, printer);
1286 return (NULL);
1287 }
1288 #ifdef HAVE_SSL
1289 else if (auth_info && !con->http->tls &&
1290 !httpAddrLocalhost(con->http->hostaddr))
1291 {
1292 /*
1293 * Require encryption of auth-info over non-local connections...
1294 */
1295
1296 send_http_error(con, HTTP_UPGRADE_REQUIRED, printer);
1297 return (NULL);
1298 }
1299 #endif /* HAVE_SSL */
1300
1301 /*
1302 * See if the printer is accepting jobs...
1303 */
1304
1305 if (!printer->accepting)
1306 {
1307 send_ipp_status(con, IPP_NOT_ACCEPTING,
1308 _("Destination \"%s\" is not accepting jobs."),
1309 printer->name);
1310 return (NULL);
1311 }
1312
1313 /*
1314 * Validate job template attributes; for now just document-format,
1315 * copies, job-sheets, number-up, page-ranges, mandatory attributes, and
1316 * media...
1317 */
1318
1319 for (i = 0; i < (int)(sizeof(readonly) / sizeof(readonly[0])); i ++)
1320 {
1321 if ((attr = ippFindAttribute(con->request, readonly[i], IPP_TAG_ZERO)) != NULL)
1322 {
1323 ippDeleteAttribute(con->request, attr);
1324
1325 if (StrictConformance)
1326 {
1327 send_ipp_status(con, IPP_BAD_REQUEST, _("The '%s' Job Status attribute cannot be supplied in a job creation request."), readonly[i]);
1328 return (NULL);
1329 }
1330
1331 cupsdLogMessage(CUPSD_LOG_INFO, "Unexpected '%s' Job Status attribute in a job creation request.", readonly[i]);
1332 }
1333 }
1334
1335 if (printer->pc)
1336 {
1337 for (mandatory = (char *)cupsArrayFirst(printer->pc->mandatory);
1338 mandatory;
1339 mandatory = (char *)cupsArrayNext(printer->pc->mandatory))
1340 {
1341 if (!ippFindAttribute(con->request, mandatory, IPP_TAG_ZERO))
1342 {
1343 /*
1344 * Missing a required attribute...
1345 */
1346
1347 send_ipp_status(con, IPP_CONFLICT,
1348 _("The \"%s\" attribute is required for print jobs."),
1349 mandatory);
1350 return (NULL);
1351 }
1352 }
1353 }
1354
1355 if (filetype && printer->filetypes &&
1356 !cupsArrayFind(printer->filetypes, filetype))
1357 {
1358 char mimetype[MIME_MAX_SUPER + MIME_MAX_TYPE + 2];
1359 /* MIME media type string */
1360
1361
1362 snprintf(mimetype, sizeof(mimetype), "%s/%s", filetype->super,
1363 filetype->type);
1364
1365 send_ipp_status(con, IPP_DOCUMENT_FORMAT,
1366 _("Unsupported format \"%s\"."), mimetype);
1367
1368 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_MIMETYPE,
1369 "document-format", NULL, mimetype);
1370
1371 return (NULL);
1372 }
1373
1374 if ((attr = ippFindAttribute(con->request, "copies",
1375 IPP_TAG_INTEGER)) != NULL)
1376 {
1377 if (attr->values[0].integer < 1 || attr->values[0].integer > MaxCopies)
1378 {
1379 send_ipp_status(con, IPP_ATTRIBUTES, _("Bad copies value %d."),
1380 attr->values[0].integer);
1381 ippAddInteger(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_INTEGER,
1382 "copies", attr->values[0].integer);
1383 return (NULL);
1384 }
1385 }
1386
1387 if ((attr = ippFindAttribute(con->request, "job-sheets",
1388 IPP_TAG_ZERO)) != NULL)
1389 {
1390 if (attr->value_tag != IPP_TAG_KEYWORD &&
1391 attr->value_tag != IPP_TAG_NAME)
1392 {
1393 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-sheets value type."));
1394 return (NULL);
1395 }
1396
1397 if (attr->num_values > 2)
1398 {
1399 send_ipp_status(con, IPP_BAD_REQUEST,
1400 _("Too many job-sheets values (%d > 2)."),
1401 attr->num_values);
1402 return (NULL);
1403 }
1404
1405 for (i = 0; i < attr->num_values; i ++)
1406 if (strcmp(attr->values[i].string.text, "none") &&
1407 !cupsdFindBanner(attr->values[i].string.text))
1408 {
1409 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-sheets value \"%s\"."),
1410 attr->values[i].string.text);
1411 return (NULL);
1412 }
1413 }
1414
1415 if ((attr = ippFindAttribute(con->request, "number-up",
1416 IPP_TAG_INTEGER)) != NULL)
1417 {
1418 if (attr->values[0].integer != 1 &&
1419 attr->values[0].integer != 2 &&
1420 attr->values[0].integer != 4 &&
1421 attr->values[0].integer != 6 &&
1422 attr->values[0].integer != 9 &&
1423 attr->values[0].integer != 16)
1424 {
1425 send_ipp_status(con, IPP_ATTRIBUTES, _("Bad number-up value %d."),
1426 attr->values[0].integer);
1427 ippAddInteger(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_INTEGER,
1428 "number-up", attr->values[0].integer);
1429 return (NULL);
1430 }
1431 }
1432
1433 if ((attr = ippFindAttribute(con->request, "page-ranges",
1434 IPP_TAG_RANGE)) != NULL)
1435 {
1436 for (i = 0, lowerpagerange = 1; i < attr->num_values; i ++)
1437 {
1438 if (attr->values[i].range.lower < lowerpagerange ||
1439 attr->values[i].range.lower > attr->values[i].range.upper)
1440 {
1441 send_ipp_status(con, IPP_BAD_REQUEST,
1442 _("Bad page-ranges values %d-%d."),
1443 attr->values[i].range.lower,
1444 attr->values[i].range.upper);
1445 return (NULL);
1446 }
1447
1448 lowerpagerange = attr->values[i].range.upper + 1;
1449 }
1450 }
1451
1452 /*
1453 * Do media selection as needed...
1454 */
1455
1456 if (!ippFindAttribute(con->request, "PageRegion", IPP_TAG_ZERO) &&
1457 !ippFindAttribute(con->request, "PageSize", IPP_TAG_ZERO) &&
1458 _ppdCacheGetPageSize(printer->pc, con->request, NULL, &exact))
1459 {
1460 if (!exact &&
1461 (media_col = ippFindAttribute(con->request, "media-col",
1462 IPP_TAG_BEGIN_COLLECTION)) != NULL)
1463 {
1464 send_ipp_status(con, IPP_OK_SUBST, _("Unsupported margins."));
1465
1466 unsup_col = ippNew();
1467 if ((media_margin = ippFindAttribute(media_col->values[0].collection,
1468 "media-bottom-margin",
1469 IPP_TAG_INTEGER)) != NULL)
1470 ippAddInteger(unsup_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
1471 "media-bottom-margin", media_margin->values[0].integer);
1472
1473 if ((media_margin = ippFindAttribute(media_col->values[0].collection,
1474 "media-left-margin",
1475 IPP_TAG_INTEGER)) != NULL)
1476 ippAddInteger(unsup_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
1477 "media-left-margin", media_margin->values[0].integer);
1478
1479 if ((media_margin = ippFindAttribute(media_col->values[0].collection,
1480 "media-right-margin",
1481 IPP_TAG_INTEGER)) != NULL)
1482 ippAddInteger(unsup_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
1483 "media-right-margin", media_margin->values[0].integer);
1484
1485 if ((media_margin = ippFindAttribute(media_col->values[0].collection,
1486 "media-top-margin",
1487 IPP_TAG_INTEGER)) != NULL)
1488 ippAddInteger(unsup_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
1489 "media-top-margin", media_margin->values[0].integer);
1490
1491 ippAddCollection(con->response, IPP_TAG_UNSUPPORTED_GROUP, "media-col",
1492 unsup_col);
1493 ippDelete(unsup_col);
1494 }
1495 }
1496
1497 /*
1498 * Make sure we aren't over our limit...
1499 */
1500
1501 if (MaxJobs && cupsArrayCount(Jobs) >= MaxJobs)
1502 cupsdCleanJobs();
1503
1504 if (MaxJobs && cupsArrayCount(Jobs) >= MaxJobs)
1505 {
1506 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Too many active jobs."));
1507 return (NULL);
1508 }
1509
1510 if ((i = check_quotas(con, printer)) < 0)
1511 {
1512 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Quota limit reached."));
1513 return (NULL);
1514 }
1515 else if (i == 0)
1516 {
1517 send_ipp_status(con, IPP_NOT_AUTHORIZED, _("Not allowed to print."));
1518 return (NULL);
1519 }
1520
1521 /*
1522 * Create the job and set things up...
1523 */
1524
1525 if ((attr = ippFindAttribute(con->request, "job-priority",
1526 IPP_TAG_INTEGER)) != NULL)
1527 priority = attr->values[0].integer;
1528 else
1529 {
1530 if ((val = cupsGetOption("job-priority", printer->num_options,
1531 printer->options)) != NULL)
1532 priority = atoi(val);
1533 else
1534 priority = 50;
1535
1536 ippAddInteger(con->request, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-priority",
1537 priority);
1538 }
1539
1540 if ((attr = ippFindAttribute(con->request, "job-name", IPP_TAG_ZERO)) == NULL)
1541 ippAddString(con->request, IPP_TAG_JOB, IPP_TAG_NAME, "job-name", NULL, "Untitled");
1542 else if ((attr->value_tag != IPP_TAG_NAME &&
1543 attr->value_tag != IPP_TAG_NAMELANG) ||
1544 attr->num_values != 1)
1545 {
1546 send_ipp_status(con, IPP_ATTRIBUTES,
1547 _("Bad job-name value: Wrong type or count."));
1548 if ((attr = ippCopyAttribute(con->response, attr, 0)) != NULL)
1549 attr->group_tag = IPP_TAG_UNSUPPORTED_GROUP;
1550
1551 if (StrictConformance)
1552 return (NULL);
1553
1554 /* Don't use invalid attribute */
1555 ippDeleteAttribute(con->request, attr);
1556
1557 ippAddString(con->request, IPP_TAG_JOB, IPP_TAG_NAME, "job-name", NULL, "Untitled");
1558 }
1559 else if (!ippValidateAttribute(attr))
1560 {
1561 send_ipp_status(con, IPP_ATTRIBUTES, _("Bad job-name value: %s"),
1562 cupsLastErrorString());
1563
1564 if ((attr = ippCopyAttribute(con->response, attr, 0)) != NULL)
1565 attr->group_tag = IPP_TAG_UNSUPPORTED_GROUP;
1566
1567 if (StrictConformance)
1568 return (NULL);
1569
1570 /* Don't use invalid attribute */
1571 ippDeleteAttribute(con->request, attr);
1572
1573 ippAddString(con->request, IPP_TAG_JOB, IPP_TAG_NAME, "job-name", NULL, "Untitled");
1574 }
1575
1576 attr = ippFindAttribute(con->request, "requesting-user-name", IPP_TAG_NAME);
1577
1578 if ((job = cupsdAddJob(priority, printer->name)) == NULL)
1579 {
1580 send_ipp_status(con, IPP_INTERNAL_ERROR,
1581 _("Unable to add job for destination \"%s\"."),
1582 printer->name);
1583 return (NULL);
1584 }
1585
1586 job->dtype = printer->type & (CUPS_PRINTER_CLASS | CUPS_PRINTER_REMOTE);
1587 job->attrs = con->request;
1588 job->dirty = 1;
1589 con->request = ippNewRequest(job->attrs->request.op.operation_id);
1590
1591 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
1592
1593 add_job_uuid(job);
1594 apply_printer_defaults(printer, job);
1595
1596 if (con->username[0])
1597 {
1598 cupsdSetString(&job->username, con->username);
1599
1600 if (attr)
1601 ippSetString(job->attrs, &attr, 0, con->username);
1602 }
1603 else if (attr)
1604 {
1605 cupsdLogMessage(CUPSD_LOG_DEBUG,
1606 "add_job: requesting-user-name=\"%s\"",
1607 attr->values[0].string.text);
1608
1609 cupsdSetString(&job->username, attr->values[0].string.text);
1610 }
1611 else
1612 cupsdSetString(&job->username, "anonymous");
1613
1614 if (!attr)
1615 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_NAME,
1616 "job-originating-user-name", NULL, job->username);
1617 else
1618 {
1619 ippSetGroupTag(job->attrs, &attr, IPP_TAG_JOB);
1620 ippSetName(job->attrs, &attr, "job-originating-user-name");
1621 }
1622
1623 if (con->username[0] || auth_info)
1624 {
1625 save_auth_info(con, job, auth_info);
1626
1627 /*
1628 * Remove the auth-info attribute from the attribute data...
1629 */
1630
1631 if (auth_info)
1632 ippDeleteAttribute(job->attrs, auth_info);
1633 }
1634
1635 if ((attr = ippFindAttribute(con->request, "job-name", IPP_TAG_NAME)) != NULL)
1636 cupsdSetString(&(job->name), attr->values[0].string.text);
1637
1638 if ((attr = ippFindAttribute(job->attrs, "job-originating-host-name",
1639 IPP_TAG_ZERO)) != NULL)
1640 {
1641 /*
1642 * Request contains a job-originating-host-name attribute; validate it...
1643 */
1644
1645 if (attr->value_tag != IPP_TAG_NAME ||
1646 attr->num_values != 1 ||
1647 strcmp(con->http->hostname, "localhost"))
1648 {
1649 /*
1650 * Can't override the value if we aren't connected via localhost.
1651 * Also, we can only have 1 value and it must be a name value.
1652 */
1653
1654 ippDeleteAttribute(job->attrs, attr);
1655 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_NAME, "job-originating-host-name", NULL, con->http->hostname);
1656 }
1657 else
1658 ippSetGroupTag(job->attrs, &attr, IPP_TAG_JOB);
1659 }
1660 else
1661 {
1662 /*
1663 * No job-originating-host-name attribute, so use the hostname from
1664 * the connection...
1665 */
1666
1667 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_NAME,
1668 "job-originating-host-name", NULL, con->http->hostname);
1669 }
1670
1671 ippAddOutOfBand(job->attrs, IPP_TAG_JOB, IPP_TAG_NOVALUE, "date-time-at-completed");
1672 ippAddDate(job->attrs, IPP_TAG_JOB, "date-time-at-creation", ippTimeToDate(time(NULL)));
1673 ippAddOutOfBand(job->attrs, IPP_TAG_JOB, IPP_TAG_NOVALUE, "date-time-at-processing");
1674 ippAddOutOfBand(job->attrs, IPP_TAG_JOB, IPP_TAG_NOVALUE, "time-at-completed");
1675 ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "time-at-creation", time(NULL));
1676 ippAddOutOfBand(job->attrs, IPP_TAG_JOB, IPP_TAG_NOVALUE, "time-at-processing");
1677
1678 /*
1679 * Add remaining job attributes...
1680 */
1681
1682 ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-id", job->id);
1683 job->state = ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_ENUM,
1684 "job-state", IPP_JOB_STOPPED);
1685 job->state_value = (ipp_jstate_t)job->state->values[0].integer;
1686 job->reasons = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
1687 "job-state-reasons", NULL, "job-incoming");
1688 job->impressions = ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-impressions-completed", 0);
1689 job->sheets = ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER,
1690 "job-media-sheets-completed", 0);
1691 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_URI, "job-printer-uri", NULL,
1692 printer->uri);
1693
1694 if ((attr = ippFindAttribute(job->attrs, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
1695 attr->values[0].integer = 0;
1696 else
1697 ippAddInteger(job->attrs, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-k-octets", 0);
1698
1699 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
1700 IPP_TAG_KEYWORD)) == NULL)
1701 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
1702 if (!attr)
1703 {
1704 if ((val = cupsGetOption("job-hold-until", printer->num_options,
1705 printer->options)) == NULL)
1706 val = "no-hold";
1707
1708 attr = ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_KEYWORD,
1709 "job-hold-until", NULL, val);
1710 }
1711
1712 if (printer->holding_new_jobs)
1713 {
1714 /*
1715 * Hold all new jobs on this printer...
1716 */
1717
1718 if (attr && strcmp(attr->values[0].string.text, "no-hold"))
1719 cupsdSetJobHoldUntil(job, ippGetString(attr, 0, NULL), 0);
1720 else
1721 cupsdSetJobHoldUntil(job, "indefinite", 0);
1722
1723 job->state->values[0].integer = IPP_JOB_HELD;
1724 job->state_value = IPP_JOB_HELD;
1725
1726 ippSetString(job->attrs, &job->reasons, 0, "job-held-on-create");
1727 }
1728 else if (attr && strcmp(attr->values[0].string.text, "no-hold"))
1729 {
1730 /*
1731 * Hold job until specified time...
1732 */
1733
1734 cupsdSetJobHoldUntil(job, attr->values[0].string.text, 0);
1735
1736 job->state->values[0].integer = IPP_JOB_HELD;
1737 job->state_value = IPP_JOB_HELD;
1738
1739 ippSetString(job->attrs, &job->reasons, 0, "job-hold-until-specified");
1740 }
1741 else if (job->attrs->request.op.operation_id == IPP_CREATE_JOB)
1742 {
1743 job->hold_until = time(NULL) + MultipleOperationTimeout;
1744 job->state->values[0].integer = IPP_JOB_HELD;
1745 job->state_value = IPP_JOB_HELD;
1746 }
1747 else
1748 {
1749 job->state->values[0].integer = IPP_JOB_PENDING;
1750 job->state_value = IPP_JOB_PENDING;
1751
1752 ippSetString(job->attrs, &job->reasons, 0, "none");
1753 }
1754
1755 if (!(printer->type & CUPS_PRINTER_REMOTE) || Classification)
1756 {
1757 /*
1758 * Add job sheets options...
1759 */
1760
1761 if ((attr = ippFindAttribute(job->attrs, "job-sheets",
1762 IPP_TAG_ZERO)) == NULL)
1763 {
1764 cupsdLogMessage(CUPSD_LOG_DEBUG,
1765 "Adding default job-sheets values \"%s,%s\"...",
1766 printer->job_sheets[0], printer->job_sheets[1]);
1767
1768 attr = ippAddStrings(job->attrs, IPP_TAG_JOB, IPP_TAG_NAME, "job-sheets",
1769 2, NULL, NULL);
1770 ippSetString(job->attrs, &attr, 0, printer->job_sheets[0]);
1771 ippSetString(job->attrs, &attr, 1, printer->job_sheets[1]);
1772 }
1773
1774 job->job_sheets = attr;
1775
1776 /*
1777 * Enforce classification level if set...
1778 */
1779
1780 if (Classification)
1781 {
1782 cupsdLogMessage(CUPSD_LOG_INFO,
1783 "Classification=\"%s\", ClassifyOverride=%d",
1784 Classification ? Classification : "(null)",
1785 ClassifyOverride);
1786
1787 if (ClassifyOverride)
1788 {
1789 if (!strcmp(attr->values[0].string.text, "none") &&
1790 (attr->num_values == 1 ||
1791 !strcmp(attr->values[1].string.text, "none")))
1792 {
1793 /*
1794 * Force the leading banner to have the classification on it...
1795 */
1796
1797 ippSetString(job->attrs, &attr, 0, Classification);
1798
1799 cupsdLogJob(job, CUPSD_LOG_NOTICE, "CLASSIFICATION FORCED "
1800 "job-sheets=\"%s,none\", "
1801 "job-originating-user-name=\"%s\"",
1802 Classification, job->username);
1803 }
1804 else if (attr->num_values == 2 &&
1805 strcmp(attr->values[0].string.text,
1806 attr->values[1].string.text) &&
1807 strcmp(attr->values[0].string.text, "none") &&
1808 strcmp(attr->values[1].string.text, "none"))
1809 {
1810 /*
1811 * Can't put two different security markings on the same document!
1812 */
1813
1814 ippSetString(job->attrs, &attr, 1, attr->values[0].string.text);
1815
1816 cupsdLogJob(job, CUPSD_LOG_NOTICE, "CLASSIFICATION FORCED "
1817 "job-sheets=\"%s,%s\", "
1818 "job-originating-user-name=\"%s\"",
1819 attr->values[0].string.text,
1820 attr->values[1].string.text, job->username);
1821 }
1822 else if (strcmp(attr->values[0].string.text, Classification) &&
1823 strcmp(attr->values[0].string.text, "none") &&
1824 (attr->num_values == 1 ||
1825 (strcmp(attr->values[1].string.text, Classification) &&
1826 strcmp(attr->values[1].string.text, "none"))))
1827 {
1828 if (attr->num_values == 1)
1829 cupsdLogJob(job, CUPSD_LOG_NOTICE,
1830 "CLASSIFICATION OVERRIDDEN "
1831 "job-sheets=\"%s\", "
1832 "job-originating-user-name=\"%s\"",
1833 attr->values[0].string.text, job->username);
1834 else
1835 cupsdLogJob(job, CUPSD_LOG_NOTICE,
1836 "CLASSIFICATION OVERRIDDEN "
1837 "job-sheets=\"%s,%s\",fffff "
1838 "job-originating-user-name=\"%s\"",
1839 attr->values[0].string.text,
1840 attr->values[1].string.text, job->username);
1841 }
1842 }
1843 else if (strcmp(attr->values[0].string.text, Classification) &&
1844 (attr->num_values == 1 ||
1845 strcmp(attr->values[1].string.text, Classification)))
1846 {
1847 /*
1848 * Force the banner to have the classification on it...
1849 */
1850
1851 if (attr->num_values > 1 &&
1852 !strcmp(attr->values[0].string.text, attr->values[1].string.text))
1853 {
1854 ippSetString(job->attrs, &attr, 0, Classification);
1855 ippSetString(job->attrs, &attr, 1, Classification);
1856 }
1857 else
1858 {
1859 if (attr->num_values == 1 ||
1860 strcmp(attr->values[0].string.text, "none"))
1861 ippSetString(job->attrs, &attr, 0, Classification);
1862
1863 if (attr->num_values > 1 &&
1864 strcmp(attr->values[1].string.text, "none"))
1865 ippSetString(job->attrs, &attr, 1, Classification);
1866 }
1867
1868 if (attr->num_values > 1)
1869 cupsdLogJob(job, CUPSD_LOG_NOTICE,
1870 "CLASSIFICATION FORCED "
1871 "job-sheets=\"%s,%s\", "
1872 "job-originating-user-name=\"%s\"",
1873 attr->values[0].string.text,
1874 attr->values[1].string.text, job->username);
1875 else
1876 cupsdLogJob(job, CUPSD_LOG_NOTICE,
1877 "CLASSIFICATION FORCED "
1878 "job-sheets=\"%s\", "
1879 "job-originating-user-name=\"%s\"",
1880 Classification, job->username);
1881 }
1882 }
1883
1884 /*
1885 * See if we need to add the starting sheet...
1886 */
1887
1888 if (!(printer->type & CUPS_PRINTER_REMOTE))
1889 {
1890 cupsdLogJob(job, CUPSD_LOG_INFO, "Adding start banner page \"%s\".",
1891 attr->values[0].string.text);
1892
1893 if ((kbytes = copy_banner(con, job, attr->values[0].string.text)) < 0)
1894 {
1895 cupsdSetJobState(job, IPP_JOB_ABORTED, CUPSD_JOB_PURGE,
1896 "Aborting job because the start banner could not be "
1897 "copied.");
1898 return (NULL);
1899 }
1900
1901 cupsdUpdateQuota(printer, job->username, 0, kbytes);
1902 }
1903 }
1904 else if ((attr = ippFindAttribute(job->attrs, "job-sheets",
1905 IPP_TAG_ZERO)) != NULL)
1906 job->job_sheets = attr;
1907
1908 /*
1909 * Fill in the response info...
1910 */
1911
1912 httpAssembleURIf(HTTP_URI_CODING_ALL, job_uri, sizeof(job_uri), "ipp", NULL,
1913 con->clientname, con->clientport, "/jobs/%d", job->id);
1914 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_URI, "job-uri", NULL,
1915 job_uri);
1916
1917 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-id", job->id);
1918
1919 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_ENUM, "job-state",
1920 job->state_value);
1921 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_TEXT, "job-state-message", NULL, "");
1922 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-state-reasons",
1923 NULL, job->reasons->values[0].string.text);
1924
1925 con->response->request.status.status_code = IPP_OK;
1926
1927 /*
1928 * Add any job subscriptions...
1929 */
1930
1931 add_job_subscriptions(con, job);
1932
1933 /*
1934 * Set all but the first two attributes to the job attributes group...
1935 */
1936
1937 for (attr = job->attrs->attrs->next->next; attr; attr = attr->next)
1938 attr->group_tag = IPP_TAG_JOB;
1939
1940 /*
1941 * Fire the "job created" event...
1942 */
1943
1944 cupsdAddEvent(CUPSD_EVENT_JOB_CREATED, printer, job, "Job created.");
1945
1946 /*
1947 * Return the new job...
1948 */
1949
1950 return (job);
1951 }
1952
1953
1954 /*
1955 * 'add_job_subscriptions()' - Add any subscriptions for a job.
1956 */
1957
1958 static void
1959 add_job_subscriptions(
1960 cupsd_client_t *con, /* I - Client connection */
1961 cupsd_job_t *job) /* I - Newly created job */
1962 {
1963 int i; /* Looping var */
1964 ipp_attribute_t *prev, /* Previous attribute */
1965 *next, /* Next attribute */
1966 *attr; /* Current attribute */
1967 cupsd_subscription_t *sub; /* Subscription object */
1968 const char *recipient, /* notify-recipient-uri */
1969 *pullmethod; /* notify-pull-method */
1970 ipp_attribute_t *user_data; /* notify-user-data */
1971 int interval; /* notify-time-interval */
1972 unsigned mask; /* notify-events */
1973
1974
1975 /*
1976 * Find the first subscription group attribute; return if we have
1977 * none...
1978 */
1979
1980 for (attr = job->attrs->attrs; attr; attr = attr->next)
1981 if (attr->group_tag == IPP_TAG_SUBSCRIPTION)
1982 break;
1983
1984 if (!attr)
1985 return;
1986
1987 /*
1988 * Process the subscription attributes in the request...
1989 */
1990
1991 while (attr)
1992 {
1993 recipient = NULL;
1994 pullmethod = NULL;
1995 user_data = NULL;
1996 interval = 0;
1997 mask = CUPSD_EVENT_NONE;
1998
1999 while (attr && attr->group_tag != IPP_TAG_ZERO)
2000 {
2001 if (!strcmp(attr->name, "notify-recipient-uri") &&
2002 attr->value_tag == IPP_TAG_URI)
2003 {
2004 /*
2005 * Validate the recipient scheme against the ServerBin/notifier
2006 * directory...
2007 */
2008
2009 char notifier[1024], /* Notifier filename */
2010 scheme[HTTP_MAX_URI], /* Scheme portion of URI */
2011 userpass[HTTP_MAX_URI], /* Username portion of URI */
2012 host[HTTP_MAX_URI], /* Host portion of URI */
2013 resource[HTTP_MAX_URI]; /* Resource portion of URI */
2014 int port; /* Port portion of URI */
2015 struct stat info; /* File information */
2016
2017 recipient = attr->values[0].string.text;
2018
2019 if (httpSeparateURI(HTTP_URI_CODING_ALL, recipient,
2020 scheme, sizeof(scheme), userpass, sizeof(userpass),
2021 host, sizeof(host), &port,
2022 resource, sizeof(resource)) < HTTP_URI_OK)
2023 {
2024 send_ipp_status(con, IPP_NOT_POSSIBLE,
2025 _("Bad notify-recipient-uri \"%s\"."), recipient);
2026 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
2027 "notify-status-code", IPP_URI_SCHEME);
2028 return;
2029 }
2030
2031 snprintf(notifier, sizeof(notifier), "%s/notifier/%s", ServerBin, scheme);
2032 if (access(notifier, X_OK) || stat(notifier, &info) || !S_ISREG(info.st_mode))
2033 {
2034 send_ipp_status(con, IPP_NOT_POSSIBLE,
2035 _("notify-recipient-uri URI \"%s\" uses unknown "
2036 "scheme."), recipient);
2037 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
2038 "notify-status-code", IPP_URI_SCHEME);
2039 return;
2040 }
2041
2042 if (!strcmp(scheme, "rss") && !check_rss_recipient(recipient))
2043 {
2044 send_ipp_status(con, IPP_NOT_POSSIBLE,
2045 _("notify-recipient-uri URI \"%s\" is already used."),
2046 recipient);
2047 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
2048 "notify-status-code", IPP_ATTRIBUTES);
2049 return;
2050 }
2051 }
2052 else if (!strcmp(attr->name, "notify-pull-method") &&
2053 attr->value_tag == IPP_TAG_KEYWORD)
2054 {
2055 pullmethod = attr->values[0].string.text;
2056
2057 if (strcmp(pullmethod, "ippget"))
2058 {
2059 send_ipp_status(con, IPP_NOT_POSSIBLE,
2060 _("Bad notify-pull-method \"%s\"."), pullmethod);
2061 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
2062 "notify-status-code", IPP_ATTRIBUTES);
2063 return;
2064 }
2065 }
2066 else if (!strcmp(attr->name, "notify-charset") &&
2067 attr->value_tag == IPP_TAG_CHARSET &&
2068 strcmp(attr->values[0].string.text, "us-ascii") &&
2069 strcmp(attr->values[0].string.text, "utf-8"))
2070 {
2071 send_ipp_status(con, IPP_CHARSET,
2072 _("Character set \"%s\" not supported."),
2073 attr->values[0].string.text);
2074 return;
2075 }
2076 else if (!strcmp(attr->name, "notify-natural-language") &&
2077 (attr->value_tag != IPP_TAG_LANGUAGE ||
2078 strcmp(attr->values[0].string.text, DefaultLanguage)))
2079 {
2080 send_ipp_status(con, IPP_CHARSET,
2081 _("Language \"%s\" not supported."),
2082 attr->values[0].string.text);
2083 return;
2084 }
2085 else if (!strcmp(attr->name, "notify-user-data") &&
2086 attr->value_tag == IPP_TAG_STRING)
2087 {
2088 if (attr->num_values > 1 || attr->values[0].unknown.length > 63)
2089 {
2090 send_ipp_status(con, IPP_REQUEST_VALUE,
2091 _("The notify-user-data value is too large "
2092 "(%d > 63 octets)."),
2093 attr->values[0].unknown.length);
2094 return;
2095 }
2096
2097 user_data = attr;
2098 }
2099 else if (!strcmp(attr->name, "notify-events") &&
2100 attr->value_tag == IPP_TAG_KEYWORD)
2101 {
2102 for (i = 0; i < attr->num_values; i ++)
2103 mask |= cupsdEventValue(attr->values[i].string.text);
2104 }
2105 else if (!strcmp(attr->name, "notify-lease-duration"))
2106 {
2107 send_ipp_status(con, IPP_BAD_REQUEST,
2108 _("The notify-lease-duration attribute cannot be "
2109 "used with job subscriptions."));
2110 return;
2111 }
2112 else if (!strcmp(attr->name, "notify-time-interval") &&
2113 attr->value_tag == IPP_TAG_INTEGER)
2114 interval = attr->values[0].integer;
2115
2116 attr = attr->next;
2117 }
2118
2119 if (!recipient && !pullmethod)
2120 break;
2121
2122 if (mask == CUPSD_EVENT_NONE)
2123 mask = CUPSD_EVENT_JOB_COMPLETED;
2124
2125 if ((sub = cupsdAddSubscription(mask, cupsdFindDest(job->dest), job,
2126 recipient, 0)) != NULL)
2127 {
2128 sub->interval = interval;
2129
2130 cupsdSetString(&sub->owner, job->username);
2131
2132 if (user_data)
2133 {
2134 sub->user_data_len = user_data->values[0].unknown.length;
2135 memcpy(sub->user_data, user_data->values[0].unknown.data,
2136 (size_t)sub->user_data_len);
2137 }
2138
2139 ippAddSeparator(con->response);
2140 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
2141 "notify-subscription-id", sub->id);
2142
2143 cupsdLogMessage(CUPSD_LOG_DEBUG, "Added subscription %d for job %d",
2144 sub->id, job->id);
2145 }
2146
2147 if (attr)
2148 attr = attr->next;
2149 }
2150
2151 cupsdMarkDirty(CUPSD_DIRTY_SUBSCRIPTIONS);
2152
2153 /*
2154 * Remove all of the subscription attributes from the job request...
2155 *
2156 * TODO: Optimize this since subscription groups have to come at the
2157 * end of the request...
2158 */
2159
2160 for (attr = job->attrs->attrs, prev = NULL; attr; attr = next)
2161 {
2162 next = attr->next;
2163
2164 if (attr->group_tag == IPP_TAG_SUBSCRIPTION ||
2165 attr->group_tag == IPP_TAG_ZERO)
2166 {
2167 /*
2168 * Free and remove this attribute...
2169 */
2170
2171 ippDeleteAttribute(NULL, attr);
2172
2173 if (prev)
2174 prev->next = next;
2175 else
2176 job->attrs->attrs = next;
2177 }
2178 else
2179 prev = attr;
2180 }
2181
2182 job->attrs->last = prev;
2183 job->attrs->current = prev;
2184 }
2185
2186
2187 /*
2188 * 'add_job_uuid()' - Add job-uuid attribute to a job.
2189 *
2190 * See RFC 4122 for the definition of UUIDs and the format.
2191 */
2192
2193 static void
2194 add_job_uuid(cupsd_job_t *job) /* I - Job */
2195 {
2196 char uuid[64]; /* job-uuid string */
2197
2198
2199 /*
2200 * Add a job-uuid attribute if none exists...
2201 */
2202
2203 if (!ippFindAttribute(job->attrs, "job-uuid", IPP_TAG_URI))
2204 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_URI, "job-uuid", NULL,
2205 httpAssembleUUID(ServerName, RemotePort, job->dest, job->id,
2206 uuid, sizeof(uuid)));
2207 }
2208
2209
2210 /*
2211 * 'add_printer()' - Add a printer to the system.
2212 */
2213
2214 static void
2215 add_printer(cupsd_client_t *con, /* I - Client connection */
2216 ipp_attribute_t *uri) /* I - URI of printer */
2217 {
2218 http_status_t status; /* Policy status */
2219 int i; /* Looping var */
2220 char scheme[HTTP_MAX_URI], /* Method portion of URI */
2221 username[HTTP_MAX_URI], /* Username portion of URI */
2222 host[HTTP_MAX_URI], /* Host portion of URI */
2223 resource[HTTP_MAX_URI]; /* Resource portion of URI */
2224 int port; /* Port portion of URI */
2225 cupsd_printer_t *printer; /* Printer/class */
2226 ipp_attribute_t *attr; /* Printer attribute */
2227 cups_file_t *fp; /* Script/PPD file */
2228 char line[1024]; /* Line from file... */
2229 char srcfile[1024], /* Source Script/PPD file */
2230 dstfile[1024]; /* Destination Script/PPD file */
2231 int modify; /* Non-zero if we are modifying */
2232 int changed_driver, /* Changed the PPD? */
2233 need_restart_job, /* Need to restart job? */
2234 set_device_uri, /* Did we set the device URI? */
2235 set_port_monitor; /* Did we set the port monitor? */
2236
2237
2238 cupsdLogMessage(CUPSD_LOG_DEBUG2, "add_printer(%p[%d], %s)", con,
2239 con->number, uri->values[0].string.text);
2240
2241 /*
2242 * Do we have a valid URI?
2243 */
2244
2245 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
2246 sizeof(scheme), username, sizeof(username), host,
2247 sizeof(host), &port, resource, sizeof(resource));
2248
2249 if (strncmp(resource, "/printers/", 10) || strlen(resource) == 10)
2250 {
2251 /*
2252 * No, return an error...
2253 */
2254
2255 send_ipp_status(con, IPP_BAD_REQUEST,
2256 _("The printer-uri must be of the form "
2257 "\"ipp://HOSTNAME/printers/PRINTERNAME\"."));
2258 return;
2259 }
2260
2261 /*
2262 * Do we have a valid printer name?
2263 */
2264
2265 if (!validate_name(resource + 10))
2266 {
2267 /*
2268 * No, return an error...
2269 */
2270
2271 send_ipp_status(con, IPP_BAD_REQUEST,
2272 _("The printer-uri \"%s\" contains invalid characters."),
2273 uri->values[0].string.text);
2274 return;
2275 }
2276
2277 /*
2278 * See if the printer already exists; if not, create a new printer...
2279 */
2280
2281 if ((printer = cupsdFindPrinter(resource + 10)) == NULL)
2282 {
2283 /*
2284 * Printer doesn't exist; see if we have a class of the same name...
2285 */
2286
2287 if ((printer = cupsdFindClass(resource + 10)) != NULL)
2288 {
2289 /*
2290 * Yes, return an error...
2291 */
2292
2293 send_ipp_status(con, IPP_NOT_POSSIBLE,
2294 _("A class named \"%s\" already exists."),
2295 resource + 10);
2296 return;
2297 }
2298
2299 /*
2300 * No, check the default policy then add the printer...
2301 */
2302
2303 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
2304 {
2305 send_http_error(con, status, NULL);
2306 return;
2307 }
2308
2309 printer = cupsdAddPrinter(resource + 10);
2310 modify = 0;
2311
2312 printer->printer_id = NextPrinterId ++;
2313 }
2314 else if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con,
2315 NULL)) != HTTP_OK)
2316 {
2317 send_http_error(con, status, printer);
2318 return;
2319 }
2320 else
2321 modify = 1;
2322
2323 /*
2324 * Look for attributes and copy them over as needed...
2325 */
2326
2327 changed_driver = 0;
2328 need_restart_job = 0;
2329
2330 if ((attr = ippFindAttribute(con->request, "printer-is-temporary", IPP_TAG_BOOLEAN)) != NULL)
2331 printer->temporary = ippGetBoolean(attr, 0);
2332
2333 if ((attr = ippFindAttribute(con->request, "printer-location",
2334 IPP_TAG_TEXT)) != NULL)
2335 cupsdSetString(&printer->location, attr->values[0].string.text);
2336
2337 if ((attr = ippFindAttribute(con->request, "printer-geo-location", IPP_TAG_URI)) != NULL && !strncmp(attr->values[0].string.text, "geo:", 4))
2338 cupsdSetString(&printer->geo_location, attr->values[0].string.text);
2339
2340 if ((attr = ippFindAttribute(con->request, "printer-organization", IPP_TAG_TEXT)) != NULL)
2341 cupsdSetString(&printer->organization, attr->values[0].string.text);
2342
2343 if ((attr = ippFindAttribute(con->request, "printer-organizational-unit", IPP_TAG_TEXT)) != NULL)
2344 cupsdSetString(&printer->organizational_unit, attr->values[0].string.text);
2345
2346 if ((attr = ippFindAttribute(con->request, "printer-info",
2347 IPP_TAG_TEXT)) != NULL)
2348 cupsdSetString(&printer->info, attr->values[0].string.text);
2349
2350 set_device_uri = 0;
2351
2352 if ((attr = ippFindAttribute(con->request, "device-uri",
2353 IPP_TAG_URI)) != NULL)
2354 {
2355 /*
2356 * Do we have a valid device URI?
2357 */
2358
2359 http_uri_status_t uri_status; /* URI separation status */
2360 char old_device_uri[1024];
2361 /* Old device URI */
2362
2363 need_restart_job = 1;
2364
2365 uri_status = httpSeparateURI(HTTP_URI_CODING_ALL,
2366 attr->values[0].string.text,
2367 scheme, sizeof(scheme),
2368 username, sizeof(username),
2369 host, sizeof(host), &port,
2370 resource, sizeof(resource));
2371
2372 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s device-uri: %s", printer->name, httpURIStatusString(uri_status));
2373
2374 if (uri_status < HTTP_URI_OK)
2375 {
2376 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Bad device-uri \"%s\"."),
2377 attr->values[0].string.text);
2378 if (!modify)
2379 cupsdDeletePrinter(printer, 0);
2380
2381 return;
2382 }
2383
2384 if (!strcmp(scheme, "file"))
2385 {
2386 /*
2387 * See if the administrator has enabled file devices...
2388 */
2389
2390 if (!FileDevice && strcmp(resource, "/dev/null"))
2391 {
2392 /*
2393 * File devices are disabled and the URL is not file:/dev/null...
2394 */
2395
2396 send_ipp_status(con, IPP_NOT_POSSIBLE,
2397 _("File device URIs have been disabled. "
2398 "To enable, see the FileDevice directive in "
2399 "\"%s/cups-files.conf\"."),
2400 ServerRoot);
2401 if (!modify)
2402 cupsdDeletePrinter(printer, 0);
2403
2404 return;
2405 }
2406 }
2407 else
2408 {
2409 /*
2410 * See if the backend exists and is executable...
2411 */
2412
2413 snprintf(srcfile, sizeof(srcfile), "%s/backend/%s", ServerBin, scheme);
2414 if (access(srcfile, X_OK))
2415 {
2416 /*
2417 * Could not find device in list!
2418 */
2419
2420 send_ipp_status(con, IPP_NOT_POSSIBLE,
2421 _("Bad device-uri scheme \"%s\"."), scheme);
2422 if (!modify)
2423 cupsdDeletePrinter(printer, 0);
2424
2425 return;
2426 }
2427 }
2428
2429 if (printer->sanitized_device_uri)
2430 strlcpy(old_device_uri, printer->sanitized_device_uri,
2431 sizeof(old_device_uri));
2432 else
2433 old_device_uri[0] = '\0';
2434
2435 cupsdSetDeviceURI(printer, attr->values[0].string.text);
2436
2437 cupsdLogMessage(CUPSD_LOG_INFO,
2438 "Setting %s device-uri to \"%s\" (was \"%s\".)",
2439 printer->name, printer->sanitized_device_uri,
2440 old_device_uri);
2441
2442 set_device_uri = 1;
2443 }
2444
2445 set_port_monitor = 0;
2446
2447 if ((attr = ippFindAttribute(con->request, "port-monitor",
2448 IPP_TAG_NAME)) != NULL)
2449 {
2450 ipp_attribute_t *supported; /* port-monitor-supported attribute */
2451
2452
2453 need_restart_job = 1;
2454
2455 supported = ippFindAttribute(printer->ppd_attrs, "port-monitor-supported",
2456 IPP_TAG_NAME);
2457 if (supported)
2458 {
2459 for (i = 0; i < supported->num_values; i ++)
2460 if (!strcmp(supported->values[i].string.text,
2461 attr->values[0].string.text))
2462 break;
2463 }
2464
2465 if (!supported || i >= supported->num_values)
2466 {
2467 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Bad port-monitor \"%s\"."),
2468 attr->values[0].string.text);
2469 if (!modify)
2470 cupsdDeletePrinter(printer, 0);
2471
2472 return;
2473 }
2474
2475 cupsdLogMessage(CUPSD_LOG_INFO,
2476 "Setting %s port-monitor to \"%s\" (was \"%s\".)",
2477 printer->name, attr->values[0].string.text,
2478 printer->port_monitor ? printer->port_monitor : "none");
2479
2480 if (strcmp(attr->values[0].string.text, "none"))
2481 cupsdSetString(&printer->port_monitor, attr->values[0].string.text);
2482 else
2483 cupsdClearString(&printer->port_monitor);
2484
2485 set_port_monitor = 1;
2486 }
2487
2488 if ((attr = ippFindAttribute(con->request, "printer-is-accepting-jobs",
2489 IPP_TAG_BOOLEAN)) != NULL &&
2490 attr->values[0].boolean != printer->accepting)
2491 {
2492 cupsdLogMessage(CUPSD_LOG_INFO,
2493 "Setting %s printer-is-accepting-jobs to %d (was %d.)",
2494 printer->name, attr->values[0].boolean, printer->accepting);
2495
2496 printer->accepting = attr->values[0].boolean;
2497
2498 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, printer, NULL,
2499 "%s accepting jobs.",
2500 printer->accepting ? "Now" : "No longer");
2501 }
2502
2503 if ((attr = ippFindAttribute(con->request, "printer-is-shared", IPP_TAG_BOOLEAN)) != NULL)
2504 {
2505 if (ippGetBoolean(attr, 0) &&
2506 printer->num_auth_info_required == 1 &&
2507 !strcmp(printer->auth_info_required[0], "negotiate"))
2508 {
2509 send_ipp_status(con, IPP_BAD_REQUEST,
2510 _("Cannot share a remote Kerberized printer."));
2511 if (!modify)
2512 cupsdDeletePrinter(printer, 0);
2513
2514 return;
2515 }
2516
2517 if (printer->type & CUPS_PRINTER_REMOTE)
2518 {
2519 /*
2520 * Cannot re-share remote printers.
2521 */
2522
2523 send_ipp_status(con, IPP_BAD_REQUEST, _("Cannot change printer-is-shared for remote queues."));
2524 if (!modify)
2525 cupsdDeletePrinter(printer, 0);
2526
2527 return;
2528 }
2529
2530 if (printer->shared && !ippGetBoolean(attr, 0))
2531 cupsdDeregisterPrinter(printer, 1);
2532
2533 cupsdLogMessage(CUPSD_LOG_INFO,
2534 "Setting %s printer-is-shared to %d (was %d.)",
2535 printer->name, attr->values[0].boolean, printer->shared);
2536
2537 printer->shared = ippGetBoolean(attr, 0);
2538 if (printer->shared && printer->temporary)
2539 printer->temporary = 0;
2540 }
2541
2542 if ((attr = ippFindAttribute(con->request, "printer-state",
2543 IPP_TAG_ENUM)) != NULL)
2544 {
2545 if (attr->values[0].integer != IPP_PRINTER_IDLE &&
2546 attr->values[0].integer != IPP_PRINTER_STOPPED)
2547 {
2548 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad printer-state value %d."),
2549 attr->values[0].integer);
2550 if (!modify)
2551 cupsdDeletePrinter(printer, 0);
2552
2553 return;
2554 }
2555
2556 cupsdLogMessage(CUPSD_LOG_INFO, "Setting %s printer-state to %d (was %d.)",
2557 printer->name, attr->values[0].integer, printer->state);
2558
2559 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
2560 cupsdStopPrinter(printer, 0);
2561 else
2562 {
2563 need_restart_job = 1;
2564 cupsdSetPrinterState(printer, (ipp_pstate_t)(attr->values[0].integer), 0);
2565 }
2566 }
2567
2568 if ((attr = ippFindAttribute(con->request, "printer-state-message",
2569 IPP_TAG_TEXT)) != NULL)
2570 {
2571 strlcpy(printer->state_message, attr->values[0].string.text,
2572 sizeof(printer->state_message));
2573
2574 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, printer, NULL, "%s",
2575 printer->state_message);
2576 }
2577
2578 if ((attr = ippFindAttribute(con->request, "printer-state-reasons",
2579 IPP_TAG_KEYWORD)) != NULL)
2580 {
2581 if (attr->num_values >
2582 (int)(sizeof(printer->reasons) / sizeof(printer->reasons[0])))
2583 {
2584 send_ipp_status(con, IPP_NOT_POSSIBLE,
2585 _("Too many printer-state-reasons values (%d > %d)."),
2586 attr->num_values,
2587 (int)(sizeof(printer->reasons) /
2588 sizeof(printer->reasons[0])));
2589 if (!modify)
2590 cupsdDeletePrinter(printer, 0);
2591
2592 return;
2593 }
2594
2595 for (i = 0; i < printer->num_reasons; i ++)
2596 _cupsStrFree(printer->reasons[i]);
2597
2598 printer->num_reasons = 0;
2599 for (i = 0; i < attr->num_values; i ++)
2600 {
2601 if (!strcmp(attr->values[i].string.text, "none"))
2602 continue;
2603
2604 printer->reasons[printer->num_reasons] =
2605 _cupsStrRetain(attr->values[i].string.text);
2606 printer->num_reasons ++;
2607
2608 if (!strcmp(attr->values[i].string.text, "paused") &&
2609 printer->state != IPP_PRINTER_STOPPED)
2610 {
2611 cupsdLogMessage(CUPSD_LOG_INFO,
2612 "Setting %s printer-state to %d (was %d.)",
2613 printer->name, IPP_PRINTER_STOPPED, printer->state);
2614 cupsdStopPrinter(printer, 0);
2615 }
2616 }
2617
2618 if (PrintcapFormat == PRINTCAP_PLIST)
2619 cupsdMarkDirty(CUPSD_DIRTY_PRINTCAP);
2620
2621 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, printer, NULL,
2622 "Printer \"%s\" state changed.", printer->name);
2623 }
2624
2625 if (!set_printer_defaults(con, printer))
2626 {
2627 if (!modify)
2628 cupsdDeletePrinter(printer, 0);
2629
2630 return;
2631 }
2632
2633 if ((attr = ippFindAttribute(con->request, "auth-info-required",
2634 IPP_TAG_KEYWORD)) != NULL)
2635 cupsdSetAuthInfoRequired(printer, NULL, attr);
2636
2637 /*
2638 * See if we have all required attributes...
2639 */
2640
2641 if (!printer->device_uri)
2642 cupsdSetString(&printer->device_uri, "file:///dev/null");
2643
2644 /*
2645 * See if we have a PPD file attached to the request...
2646 */
2647
2648 if (con->filename)
2649 {
2650 need_restart_job = 1;
2651 changed_driver = 1;
2652
2653 strlcpy(srcfile, con->filename, sizeof(srcfile));
2654
2655 if ((fp = cupsFileOpen(srcfile, "rb")))
2656 {
2657 /*
2658 * Yes; get the first line from it...
2659 */
2660
2661 line[0] = '\0';
2662 cupsFileGets(fp, line, sizeof(line));
2663 cupsFileClose(fp);
2664
2665 /*
2666 * Then see what kind of file it is...
2667 */
2668
2669 if (strncmp(line, "*PPD-Adobe", 10))
2670 {
2671 send_ipp_status(con, IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED, _("Bad PPD file."));
2672 if (!modify)
2673 cupsdDeletePrinter(printer, 0);
2674
2675 return;
2676 }
2677
2678 snprintf(dstfile, sizeof(dstfile), "%s/ppd/%s.ppd", ServerRoot,
2679 printer->name);
2680
2681 /*
2682 * The new file is a PPD file, so move the file over to the ppd
2683 * directory...
2684 */
2685
2686 if (copy_file(srcfile, dstfile, ConfigFilePerm))
2687 {
2688 send_ipp_status(con, IPP_INTERNAL_ERROR, _("Unable to copy PPD file - %s"), strerror(errno));
2689 if (!modify)
2690 cupsdDeletePrinter(printer, 0);
2691
2692 return;
2693 }
2694
2695 cupsdLogMessage(CUPSD_LOG_DEBUG, "Copied PPD file successfully");
2696 }
2697 }
2698 else if ((attr = ippFindAttribute(con->request, "ppd-name", IPP_TAG_NAME)) != NULL)
2699 {
2700 const char *ppd_name = ippGetString(attr, 0, NULL);
2701 /* ppd-name value */
2702
2703 need_restart_job = 1;
2704 changed_driver = 1;
2705
2706 if (!strcmp(ppd_name, "raw"))
2707 {
2708 /*
2709 * Raw driver, remove any existing PPD file.
2710 */
2711
2712 snprintf(dstfile, sizeof(dstfile), "%s/ppd/%s.ppd", ServerRoot, printer->name);
2713 unlink(dstfile);
2714 }
2715 else if (strstr(ppd_name, "../"))
2716 {
2717 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Invalid ppd-name value."));
2718 if (!modify)
2719 cupsdDeletePrinter(printer, 0);
2720
2721 return;
2722 }
2723 else
2724 {
2725 /*
2726 * PPD model file...
2727 */
2728
2729 snprintf(dstfile, sizeof(dstfile), "%s/ppd/%s.ppd", ServerRoot, printer->name);
2730
2731 if (copy_model(con, ppd_name, dstfile))
2732 {
2733 send_ipp_status(con, IPP_INTERNAL_ERROR, _("Unable to copy PPD file."));
2734 if (!modify)
2735 cupsdDeletePrinter(printer, 0);
2736
2737 return;
2738 }
2739
2740 cupsdLogMessage(CUPSD_LOG_DEBUG, "Copied PPD file successfully");
2741 }
2742 }
2743
2744 if (changed_driver)
2745 {
2746 /*
2747 * If we changed the PPD, then remove the printer's cache file and clear the
2748 * printer-state-reasons...
2749 */
2750
2751 char cache_name[1024]; /* Cache filename for printer attrs */
2752
2753 snprintf(cache_name, sizeof(cache_name), "%s/%s.data", CacheDir, printer->name);
2754 unlink(cache_name);
2755
2756 cupsdSetPrinterReasons(printer, "none");
2757
2758 /*
2759 * (Re)register color profiles...
2760 */
2761
2762 cupsdRegisterColor(printer);
2763 }
2764
2765 /*
2766 * If we set the device URI but not the port monitor, check which port
2767 * monitor to use by default...
2768 */
2769
2770 if (set_device_uri && !set_port_monitor)
2771 {
2772 ppd_file_t *ppd; /* PPD file */
2773 ppd_attr_t *ppdattr; /* cupsPortMonitor attribute */
2774
2775
2776 httpSeparateURI(HTTP_URI_CODING_ALL, printer->device_uri, scheme,
2777 sizeof(scheme), username, sizeof(username), host,
2778 sizeof(host), &port, resource, sizeof(resource));
2779
2780 snprintf(srcfile, sizeof(srcfile), "%s/ppd/%s.ppd", ServerRoot,
2781 printer->name);
2782 if ((ppd = _ppdOpenFile(srcfile, _PPD_LOCALIZATION_NONE)) != NULL)
2783 {
2784 for (ppdattr = ppdFindAttr(ppd, "cupsPortMonitor", NULL);
2785 ppdattr;
2786 ppdattr = ppdFindNextAttr(ppd, "cupsPortMonitor", NULL))
2787 if (!strcmp(scheme, ppdattr->spec))
2788 {
2789 cupsdLogMessage(CUPSD_LOG_INFO,
2790 "Setting %s port-monitor to \"%s\" (was \"%s\".)",
2791 printer->name, ppdattr->value,
2792 printer->port_monitor ? printer->port_monitor
2793 : "none");
2794
2795 if (strcmp(ppdattr->value, "none"))
2796 cupsdSetString(&printer->port_monitor, ppdattr->value);
2797 else
2798 cupsdClearString(&printer->port_monitor);
2799
2800 break;
2801 }
2802
2803 ppdClose(ppd);
2804 }
2805 }
2806
2807 printer->config_time = time(NULL);
2808
2809 /*
2810 * Update the printer attributes and return...
2811 */
2812
2813 if (!printer->temporary)
2814 {
2815 if (!printer->printer_id)
2816 printer->printer_id = NextPrinterId ++;
2817
2818 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
2819 }
2820
2821 cupsdSetPrinterAttrs(printer);
2822
2823 if (need_restart_job && printer->job)
2824 {
2825 /*
2826 * Restart the current job...
2827 */
2828
2829 cupsdSetJobState(printer->job, IPP_JOB_PENDING, CUPSD_JOB_FORCE,
2830 "Job restarted because the printer was modified.");
2831 }
2832
2833 cupsdMarkDirty(CUPSD_DIRTY_PRINTCAP);
2834
2835 if (modify)
2836 {
2837 cupsdAddEvent(CUPSD_EVENT_PRINTER_MODIFIED,
2838 printer, NULL, "Printer \"%s\" modified by \"%s\".",
2839 printer->name, get_username(con));
2840
2841 cupsdLogMessage(CUPSD_LOG_INFO, "Printer \"%s\" modified by \"%s\".",
2842 printer->name, get_username(con));
2843 }
2844 else
2845 {
2846 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED,
2847 printer, NULL, "New printer \"%s\" added by \"%s\".",
2848 printer->name, get_username(con));
2849
2850 cupsdLogMessage(CUPSD_LOG_INFO, "New printer \"%s\" added by \"%s\".",
2851 printer->name, get_username(con));
2852 }
2853
2854 con->response->request.status.status_code = IPP_OK;
2855 }
2856
2857
2858 /*
2859 * 'add_printer_state_reasons()' - Add the "printer-state-reasons" attribute
2860 * based upon the printer state...
2861 */
2862
2863 static void
2864 add_printer_state_reasons(
2865 cupsd_client_t *con, /* I - Client connection */
2866 cupsd_printer_t *p) /* I - Printer info */
2867 {
2868 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2869 "add_printer_state_reasons(%p[%d], %p[%s])",
2870 con, con->number, p, p->name);
2871
2872 if (p->num_reasons == 0)
2873 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
2874 "printer-state-reasons", NULL, "none");
2875 else
2876 ippAddStrings(con->response, IPP_TAG_PRINTER, IPP_TAG_KEYWORD,
2877 "printer-state-reasons", p->num_reasons, NULL,
2878 (const char * const *)p->reasons);
2879 }
2880
2881
2882 /*
2883 * 'add_queued_job_count()' - Add the "queued-job-count" attribute for
2884 * the specified printer or class.
2885 */
2886
2887 static void
2888 add_queued_job_count(
2889 cupsd_client_t *con, /* I - Client connection */
2890 cupsd_printer_t *p) /* I - Printer or class */
2891 {
2892 int count; /* Number of jobs on destination */
2893
2894
2895 cupsdLogMessage(CUPSD_LOG_DEBUG2, "add_queued_job_count(%p[%d], %p[%s])",
2896 con, con->number, p, p->name);
2897
2898 count = cupsdGetPrinterJobCount(p->name);
2899
2900 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
2901 "queued-job-count", count);
2902 }
2903
2904
2905 /*
2906 * 'apply_printer_defaults()' - Apply printer default options to a job.
2907 */
2908
2909 static void
2910 apply_printer_defaults(
2911 cupsd_printer_t *printer, /* I - Printer */
2912 cupsd_job_t *job) /* I - Job */
2913 {
2914 int i, /* Looping var */
2915 num_options; /* Number of default options */
2916 cups_option_t *options, /* Default options */
2917 *option; /* Current option */
2918
2919
2920 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Applying default options...");
2921
2922 /*
2923 * Collect all of the default options and add the missing ones to the
2924 * job object...
2925 */
2926
2927 for (i = printer->num_options, num_options = 0, options = NULL,
2928 option = printer->options;
2929 i > 0;
2930 i --, option ++)
2931 if (!ippFindAttribute(job->attrs, option->name, IPP_TAG_ZERO))
2932 {
2933 if (!strcmp(option->name, "print-quality") && ippFindAttribute(job->attrs, "cupsPrintQuality", IPP_TAG_NAME))
2934 continue; /* Don't override cupsPrintQuality */
2935
2936 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Adding default %s=%s", option->name, option->value);
2937
2938 num_options = cupsAddOption(option->name, option->value, num_options, &options);
2939 }
2940
2941 /*
2942 * Encode these options as attributes in the job object...
2943 */
2944
2945 cupsEncodeOptions2(job->attrs, num_options, options, IPP_TAG_JOB);
2946 cupsFreeOptions(num_options, options);
2947 }
2948
2949
2950 /*
2951 * 'authenticate_job()' - Set job authentication info.
2952 */
2953
2954 static void
2955 authenticate_job(cupsd_client_t *con, /* I - Client connection */
2956 ipp_attribute_t *uri) /* I - Job URI */
2957 {
2958 ipp_attribute_t *attr, /* job-id attribute */
2959 *auth_info; /* auth-info attribute */
2960 int jobid; /* Job ID */
2961 cupsd_job_t *job; /* Current job */
2962 char scheme[HTTP_MAX_URI],
2963 /* Method portion of URI */
2964 username[HTTP_MAX_URI],
2965 /* Username portion of URI */
2966 host[HTTP_MAX_URI],
2967 /* Host portion of URI */
2968 resource[HTTP_MAX_URI];
2969 /* Resource portion of URI */
2970 int port; /* Port portion of URI */
2971
2972
2973 cupsdLogMessage(CUPSD_LOG_DEBUG2, "authenticate_job(%p[%d], %s)",
2974 con, con->number, uri->values[0].string.text);
2975
2976 /*
2977 * Start with "everything is OK" status...
2978 */
2979
2980 con->response->request.status.status_code = IPP_OK;
2981
2982 /*
2983 * See if we have a job URI or a printer URI...
2984 */
2985
2986 if (!strcmp(uri->name, "printer-uri"))
2987 {
2988 /*
2989 * Got a printer URI; see if we also have a job-id attribute...
2990 */
2991
2992 if ((attr = ippFindAttribute(con->request, "job-id",
2993 IPP_TAG_INTEGER)) == NULL)
2994 {
2995 send_ipp_status(con, IPP_BAD_REQUEST,
2996 _("Got a printer-uri attribute but no job-id."));
2997 return;
2998 }
2999
3000 jobid = attr->values[0].integer;
3001 }
3002 else
3003 {
3004 /*
3005 * Got a job URI; parse it to get the job ID...
3006 */
3007
3008 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
3009 sizeof(scheme), username, sizeof(username), host,
3010 sizeof(host), &port, resource, sizeof(resource));
3011
3012 if (strncmp(resource, "/jobs/", 6))
3013 {
3014 /*
3015 * Not a valid URI!
3016 */
3017
3018 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
3019 uri->values[0].string.text);
3020 return;
3021 }
3022
3023 jobid = atoi(resource + 6);
3024 }
3025
3026 /*
3027 * See if the job exists...
3028 */
3029
3030 if ((job = cupsdFindJob(jobid)) == NULL)
3031 {
3032 /*
3033 * Nope - return a "not found" error...
3034 */
3035
3036 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
3037 return;
3038 }
3039
3040 /*
3041 * See if the job has been completed...
3042 */
3043
3044 if (job->state_value != IPP_JOB_HELD)
3045 {
3046 /*
3047 * Return a "not-possible" error...
3048 */
3049
3050 send_ipp_status(con, IPP_NOT_POSSIBLE,
3051 _("Job #%d is not held for authentication."),
3052 jobid);
3053 return;
3054 }
3055
3056 /*
3057 * See if we have already authenticated...
3058 */
3059
3060 auth_info = ippFindAttribute(con->request, "auth-info", IPP_TAG_TEXT);
3061
3062 if (!con->username[0] && !auth_info)
3063 {
3064 cupsd_printer_t *printer; /* Job destination */
3065
3066 /*
3067 * No auth data. If we need to authenticate via Kerberos, send a
3068 * HTTP auth challenge, otherwise just return an IPP error...
3069 */
3070
3071 printer = cupsdFindDest(job->dest);
3072
3073 if (printer && printer->num_auth_info_required > 0 &&
3074 !strcmp(printer->auth_info_required[0], "negotiate"))
3075 send_http_error(con, HTTP_UNAUTHORIZED, printer);
3076 else
3077 send_ipp_status(con, IPP_NOT_AUTHORIZED,
3078 _("No authentication information provided."));
3079 return;
3080 }
3081
3082 /*
3083 * See if the job is owned by the requesting user...
3084 */
3085
3086 if (!validate_user(job, con, job->username, username, sizeof(username)))
3087 {
3088 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
3089 cupsdFindDest(job->dest));
3090 return;
3091 }
3092
3093 /*
3094 * Save the authentication information for this job...
3095 */
3096
3097 save_auth_info(con, job, auth_info);
3098
3099 /*
3100 * Reset the job-hold-until value to "no-hold"...
3101 */
3102
3103 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
3104 IPP_TAG_KEYWORD)) == NULL)
3105 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
3106
3107 if (attr)
3108 {
3109 ippSetValueTag(job->attrs, &attr, IPP_TAG_KEYWORD);
3110 ippSetString(job->attrs, &attr, 0, "no-hold");
3111 }
3112
3113 /*
3114 * Release the job and return...
3115 */
3116
3117 cupsdReleaseJob(job);
3118
3119 cupsdAddEvent(CUPSD_EVENT_JOB_STATE, NULL, job, "Job authenticated by user");
3120
3121 cupsdLogJob(job, CUPSD_LOG_INFO, "Authenticated by \"%s\".", con->username);
3122
3123 cupsdCheckJobs();
3124 }
3125
3126
3127 /*
3128 * 'cancel_all_jobs()' - Cancel all or selected print jobs.
3129 */
3130
3131 static void
3132 cancel_all_jobs(cupsd_client_t *con, /* I - Client connection */
3133 ipp_attribute_t *uri) /* I - Job or Printer URI */
3134 {
3135 int i; /* Looping var */
3136 http_status_t status; /* Policy status */
3137 cups_ptype_t dtype; /* Destination type */
3138 char scheme[HTTP_MAX_URI], /* Scheme portion of URI */
3139 userpass[HTTP_MAX_URI], /* Username portion of URI */
3140 hostname[HTTP_MAX_URI], /* Host portion of URI */
3141 resource[HTTP_MAX_URI]; /* Resource portion of URI */
3142 int port; /* Port portion of URI */
3143 ipp_attribute_t *attr; /* Attribute in request */
3144 const char *username = NULL; /* Username */
3145 cupsd_jobaction_t purge = CUPSD_JOB_DEFAULT;
3146 /* Purge? */
3147 cupsd_printer_t *printer; /* Printer */
3148 ipp_attribute_t *job_ids; /* job-ids attribute */
3149 cupsd_job_t *job; /* Job */
3150
3151
3152 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cancel_all_jobs(%p[%d], %s)", con,
3153 con->number, uri->values[0].string.text);
3154
3155 /*
3156 * Get the jobs to cancel/purge...
3157 */
3158
3159 switch (con->request->request.op.operation_id)
3160 {
3161 case IPP_PURGE_JOBS :
3162 /*
3163 * Get the username (if any) for the jobs we want to cancel (only if
3164 * "my-jobs" is specified...
3165 */
3166
3167 if ((attr = ippFindAttribute(con->request, "my-jobs",
3168 IPP_TAG_BOOLEAN)) != NULL &&
3169 attr->values[0].boolean)
3170 {
3171 if ((attr = ippFindAttribute(con->request, "requesting-user-name",
3172 IPP_TAG_NAME)) != NULL)
3173 username = attr->values[0].string.text;
3174 else
3175 {
3176 send_ipp_status(con, IPP_BAD_REQUEST,
3177 _("Missing requesting-user-name attribute."));
3178 return;
3179 }
3180 }
3181
3182 /*
3183 * Look for the "purge-jobs" attribute...
3184 */
3185
3186 if ((attr = ippFindAttribute(con->request, "purge-jobs",
3187 IPP_TAG_BOOLEAN)) != NULL)
3188 purge = attr->values[0].boolean ? CUPSD_JOB_PURGE : CUPSD_JOB_DEFAULT;
3189 else
3190 purge = CUPSD_JOB_PURGE;
3191 break;
3192
3193 case IPP_CANCEL_MY_JOBS :
3194 if (con->username[0])
3195 username = con->username;
3196 else if ((attr = ippFindAttribute(con->request, "requesting-user-name",
3197 IPP_TAG_NAME)) != NULL)
3198 username = attr->values[0].string.text;
3199 else
3200 {
3201 send_ipp_status(con, IPP_BAD_REQUEST,
3202 _("Missing requesting-user-name attribute."));
3203 return;
3204 }
3205
3206 default :
3207 break;
3208 }
3209
3210 job_ids = ippFindAttribute(con->request, "job-ids", IPP_TAG_INTEGER);
3211
3212 /*
3213 * See if we have a printer URI...
3214 */
3215
3216 if (strcmp(uri->name, "printer-uri"))
3217 {
3218 send_ipp_status(con, IPP_BAD_REQUEST,
3219 _("The printer-uri attribute is required."));
3220 return;
3221 }
3222
3223 /*
3224 * And if the destination is valid...
3225 */
3226
3227 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
3228 {
3229 /*
3230 * Bad URI?
3231 */
3232
3233 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text,
3234 scheme, sizeof(scheme), userpass, sizeof(userpass),
3235 hostname, sizeof(hostname), &port,
3236 resource, sizeof(resource));
3237
3238 if ((!strncmp(resource, "/printers/", 10) && resource[10]) ||
3239 (!strncmp(resource, "/classes/", 9) && resource[9]))
3240 {
3241 send_ipp_status(con, IPP_NOT_FOUND,
3242 _("The printer or class does not exist."));
3243 return;
3244 }
3245
3246 /*
3247 * Check policy...
3248 */
3249
3250 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
3251 {
3252 send_http_error(con, status, NULL);
3253 return;
3254 }
3255
3256 if (job_ids)
3257 {
3258 for (i = 0; i < job_ids->num_values; i ++)
3259 {
3260 if ((job = cupsdFindJob(job_ids->values[i].integer)) == NULL)
3261 break;
3262
3263 if (con->request->request.op.operation_id == IPP_CANCEL_MY_JOBS &&
3264 _cups_strcasecmp(job->username, username))
3265 break;
3266 }
3267
3268 if (i < job_ids->num_values)
3269 {
3270 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
3271 job_ids->values[i].integer);
3272 return;
3273 }
3274
3275 for (i = 0; i < job_ids->num_values; i ++)
3276 {
3277 job = cupsdFindJob(job_ids->values[i].integer);
3278
3279 cupsdSetJobState(job, IPP_JOB_CANCELED, purge,
3280 purge == CUPSD_JOB_PURGE ? "Job purged by user." :
3281 "Job canceled by user.");
3282 }
3283
3284 cupsdLogMessage(CUPSD_LOG_INFO, "Selected jobs were %s by \"%s\".",
3285 purge == CUPSD_JOB_PURGE ? "purged" : "canceled",
3286 get_username(con));
3287 }
3288 else
3289 {
3290 /*
3291 * Cancel all jobs on all printers...
3292 */
3293
3294 cupsdCancelJobs(NULL, username, purge);
3295
3296 cupsdLogMessage(CUPSD_LOG_INFO, "All jobs were %s by \"%s\".",
3297 purge == CUPSD_JOB_PURGE ? "purged" : "canceled",
3298 get_username(con));
3299 }
3300 }
3301 else
3302 {
3303 /*
3304 * Check policy...
3305 */
3306
3307 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con,
3308 NULL)) != HTTP_OK)
3309 {
3310 send_http_error(con, status, printer);
3311 return;
3312 }
3313
3314 if (job_ids)
3315 {
3316 for (i = 0; i < job_ids->num_values; i ++)
3317 {
3318 if ((job = cupsdFindJob(job_ids->values[i].integer)) == NULL ||
3319 _cups_strcasecmp(job->dest, printer->name))
3320 break;
3321
3322 if (con->request->request.op.operation_id == IPP_CANCEL_MY_JOBS &&
3323 _cups_strcasecmp(job->username, username))
3324 break;
3325 }
3326
3327 if (i < job_ids->num_values)
3328 {
3329 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
3330 job_ids->values[i].integer);
3331 return;
3332 }
3333
3334 for (i = 0; i < job_ids->num_values; i ++)
3335 {
3336 job = cupsdFindJob(job_ids->values[i].integer);
3337
3338 cupsdSetJobState(job, IPP_JOB_CANCELED, purge,
3339 purge == CUPSD_JOB_PURGE ? "Job purged by user." :
3340 "Job canceled by user.");
3341 }
3342
3343 cupsdLogMessage(CUPSD_LOG_INFO, "Selected jobs were %s by \"%s\".",
3344 purge == CUPSD_JOB_PURGE ? "purged" : "canceled",
3345 get_username(con));
3346 }
3347 else
3348 {
3349 /*
3350 * Cancel all of the jobs on the named printer...
3351 */
3352
3353 cupsdCancelJobs(printer->name, username, purge);
3354
3355 cupsdLogMessage(CUPSD_LOG_INFO, "All jobs on \"%s\" were %s by \"%s\".",
3356 printer->name,
3357 purge == CUPSD_JOB_PURGE ? "purged" : "canceled",
3358 get_username(con));
3359 }
3360 }
3361
3362 con->response->request.status.status_code = IPP_OK;
3363
3364 cupsdCheckJobs();
3365 }
3366
3367
3368 /*
3369 * 'cancel_job()' - Cancel a print job.
3370 */
3371
3372 static void
3373 cancel_job(cupsd_client_t *con, /* I - Client connection */
3374 ipp_attribute_t *uri) /* I - Job or Printer URI */
3375 {
3376 ipp_attribute_t *attr; /* Current attribute */
3377 int jobid; /* Job ID */
3378 char scheme[HTTP_MAX_URI], /* Scheme portion of URI */
3379 username[HTTP_MAX_URI], /* Username portion of URI */
3380 host[HTTP_MAX_URI], /* Host portion of URI */
3381 resource[HTTP_MAX_URI]; /* Resource portion of URI */
3382 int port; /* Port portion of URI */
3383 cupsd_job_t *job; /* Job information */
3384 cups_ptype_t dtype; /* Destination type (printer/class) */
3385 cupsd_printer_t *printer; /* Printer data */
3386 cupsd_jobaction_t purge; /* Purge the job? */
3387
3388
3389 cupsdLogMessage(CUPSD_LOG_DEBUG2, "cancel_job(%p[%d], %s)", con,
3390 con->number, uri->values[0].string.text);
3391
3392 /*
3393 * See if we have a job URI or a printer URI...
3394 */
3395
3396 if (!strcmp(uri->name, "printer-uri"))
3397 {
3398 /*
3399 * Got a printer URI; see if we also have a job-id attribute...
3400 */
3401
3402 if ((attr = ippFindAttribute(con->request, "job-id",
3403 IPP_TAG_INTEGER)) == NULL)
3404 {
3405 send_ipp_status(con, IPP_BAD_REQUEST,
3406 _("Got a printer-uri attribute but no job-id."));
3407 return;
3408 }
3409
3410 if ((jobid = attr->values[0].integer) == 0)
3411 {
3412 /*
3413 * Find the current job on the specified printer...
3414 */
3415
3416 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
3417 {
3418 /*
3419 * Bad URI...
3420 */
3421
3422 send_ipp_status(con, IPP_NOT_FOUND,
3423 _("The printer or class does not exist."));
3424 return;
3425 }
3426
3427 /*
3428 * See if there are any pending jobs...
3429 */
3430
3431 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
3432 job;
3433 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
3434 if (job->state_value <= IPP_JOB_PROCESSING &&
3435 !_cups_strcasecmp(job->dest, printer->name))
3436 break;
3437
3438 if (job)
3439 jobid = job->id;
3440 else
3441 {
3442 /*
3443 * No, try stopped jobs...
3444 */
3445
3446 for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
3447 job;
3448 job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
3449 if (job->state_value == IPP_JOB_STOPPED &&
3450 !_cups_strcasecmp(job->dest, printer->name))
3451 break;
3452
3453 if (job)
3454 jobid = job->id;
3455 else
3456 {
3457 send_ipp_status(con, IPP_NOT_POSSIBLE, _("No active jobs on %s."),
3458 printer->name);
3459 return;
3460 }
3461 }
3462 }
3463 }
3464 else
3465 {
3466 /*
3467 * Got a job URI; parse it to get the job ID...
3468 */
3469
3470 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
3471 sizeof(scheme), username, sizeof(username), host,
3472 sizeof(host), &port, resource, sizeof(resource));
3473
3474 if (strncmp(resource, "/jobs/", 6))
3475 {
3476 /*
3477 * Not a valid URI!
3478 */
3479
3480 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
3481 uri->values[0].string.text);
3482 return;
3483 }
3484
3485 jobid = atoi(resource + 6);
3486 }
3487
3488 /*
3489 * Look for the "purge-job" attribute...
3490 */
3491
3492 if ((attr = ippFindAttribute(con->request, "purge-job",
3493 IPP_TAG_BOOLEAN)) != NULL)
3494 purge = attr->values[0].boolean ? CUPSD_JOB_PURGE : CUPSD_JOB_DEFAULT;
3495 else
3496 purge = CUPSD_JOB_DEFAULT;
3497
3498 /*
3499 * See if the job exists...
3500 */
3501
3502 if ((job = cupsdFindJob(jobid)) == NULL)
3503 {
3504 /*
3505 * Nope - return a "not found" error...
3506 */
3507
3508 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
3509 return;
3510 }
3511
3512 /*
3513 * See if the job is owned by the requesting user...
3514 */
3515
3516 if (!validate_user(job, con, job->username, username, sizeof(username)))
3517 {
3518 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
3519 cupsdFindDest(job->dest));
3520 return;
3521 }
3522
3523 /*
3524 * See if the job is already completed, canceled, or aborted; if so,
3525 * we can't cancel...
3526 */
3527
3528 if (job->state_value >= IPP_JOB_CANCELED && purge != CUPSD_JOB_PURGE)
3529 {
3530 switch (job->state_value)
3531 {
3532 case IPP_JOB_CANCELED :
3533 send_ipp_status(con, IPP_NOT_POSSIBLE,
3534 _("Job #%d is already canceled - can\'t cancel."),
3535 jobid);
3536 break;
3537
3538 case IPP_JOB_ABORTED :
3539 send_ipp_status(con, IPP_NOT_POSSIBLE,
3540 _("Job #%d is already aborted - can\'t cancel."),
3541 jobid);
3542 break;
3543
3544 default :
3545 send_ipp_status(con, IPP_NOT_POSSIBLE,
3546 _("Job #%d is already completed - can\'t cancel."),
3547 jobid);
3548 break;
3549 }
3550
3551 return;
3552 }
3553
3554 /*
3555 * Cancel the job and return...
3556 */
3557
3558 cupsdSetJobState(job, IPP_JOB_CANCELED, purge,
3559 purge == CUPSD_JOB_PURGE ? "Job purged by \"%s\"" :
3560 "Job canceled by \"%s\"",
3561 username);
3562 cupsdCheckJobs();
3563
3564 if (purge == CUPSD_JOB_PURGE)
3565 cupsdLogMessage(CUPSD_LOG_INFO, "[Job %d] Purged by \"%s\".", jobid,
3566 username);
3567 else
3568 cupsdLogMessage(CUPSD_LOG_INFO, "[Job %d] Canceled by \"%s\".", jobid,
3569 username);
3570
3571 con->response->request.status.status_code = IPP_OK;
3572 }
3573
3574
3575 /*
3576 * 'cancel_subscription()' - Cancel a subscription.
3577 */
3578
3579 static void
3580 cancel_subscription(
3581 cupsd_client_t *con, /* I - Client connection */
3582 int sub_id) /* I - Subscription ID */
3583 {
3584 http_status_t status; /* Policy status */
3585 cupsd_subscription_t *sub; /* Subscription */
3586
3587
3588 cupsdLogMessage(CUPSD_LOG_DEBUG2,
3589 "cancel_subscription(con=%p[%d], sub_id=%d)",
3590 con, con->number, sub_id);
3591
3592 /*
3593 * Is the subscription ID valid?
3594 */
3595
3596 if ((sub = cupsdFindSubscription(sub_id)) == NULL)
3597 {
3598 /*
3599 * Bad subscription ID...
3600 */
3601
3602 send_ipp_status(con, IPP_NOT_FOUND,
3603 _("Subscription #%d does not exist."), sub_id);
3604 return;
3605 }
3606
3607 /*
3608 * Check policy...
3609 */
3610
3611 if ((status = cupsdCheckPolicy(sub->dest ? sub->dest->op_policy_ptr :
3612 DefaultPolicyPtr,
3613 con, sub->owner)) != HTTP_OK)
3614 {
3615 send_http_error(con, status, sub->dest);
3616 return;
3617 }
3618
3619 /*
3620 * Cancel the subscription...
3621 */
3622
3623 cupsdDeleteSubscription(sub, 1);
3624
3625 con->response->request.status.status_code = IPP_OK;
3626 }
3627
3628
3629 /*
3630 * 'check_rss_recipient()' - Check that we do not have a duplicate RSS feed URI.
3631 */
3632
3633 static int /* O - 1 if OK, 0 if not */
3634 check_rss_recipient(
3635 const char *recipient) /* I - Recipient URI */
3636 {
3637 cupsd_subscription_t *sub; /* Current subscription */
3638
3639
3640 for (sub = (cupsd_subscription_t *)cupsArrayFirst(Subscriptions);
3641 sub;
3642 sub = (cupsd_subscription_t *)cupsArrayNext(Subscriptions))
3643 if (sub->recipient)
3644 {
3645 /*
3646 * Compare the URIs up to the first ?...
3647 */
3648
3649 const char *r1, *r2;
3650
3651 for (r1 = recipient, r2 = sub->recipient;
3652 *r1 == *r2 && *r1 && *r1 != '?' && *r2 && *r2 != '?';
3653 r1 ++, r2 ++);
3654
3655 if (*r1 == *r2)
3656 return (0);
3657 }
3658
3659 return (1);
3660 }
3661
3662
3663 /*
3664 * 'check_quotas()' - Check quotas for a printer and user.
3665 */
3666
3667 static int /* O - 1 if OK, 0 if forbidden,
3668 -1 if limit reached */
3669 check_quotas(cupsd_client_t *con, /* I - Client connection */
3670 cupsd_printer_t *p) /* I - Printer or class */
3671 {
3672 char username[33], /* Username */
3673 *name; /* Current user name */
3674 cupsd_quota_t *q; /* Quota data */
3675 #ifdef HAVE_MBR_UID_TO_UUID
3676 /*
3677 * Use Apple membership APIs which require that all names represent
3678 * valid user account or group records accessible by the server.
3679 */
3680
3681 uuid_t usr_uuid; /* UUID for job requesting user */
3682 uuid_t usr2_uuid; /* UUID for ACL user name entry */
3683 uuid_t grp_uuid; /* UUID for ACL group name entry */
3684 int mbr_err; /* Error from membership function */
3685 int is_member; /* Is this user a member? */
3686 #else
3687 /*
3688 * Use standard POSIX APIs for checking users and groups...
3689 */
3690
3691 struct passwd *pw; /* User password data */
3692 #endif /* HAVE_MBR_UID_TO_UUID */
3693
3694
3695 cupsdLogMessage(CUPSD_LOG_DEBUG2, "check_quotas(%p[%d], %p[%s])",
3696 con, con->number, p, p->name);
3697
3698 /*
3699 * Figure out who is printing...
3700 */
3701
3702 strlcpy(username, get_username(con), sizeof(username));
3703
3704 if ((name = strchr(username, '@')) != NULL)
3705 *name = '\0'; /* Strip @REALM */
3706
3707 /*
3708 * Check global active job limits for printers and users...
3709 */
3710
3711 if (MaxJobsPerPrinter)
3712 {
3713 /*
3714 * Check if there are too many pending jobs on this printer...
3715 */
3716
3717 if (cupsdGetPrinterJobCount(p->name) >= MaxJobsPerPrinter)
3718 {
3719 cupsdLogMessage(CUPSD_LOG_INFO, "Too many jobs for printer \"%s\"...",
3720 p->name);
3721 return (-1);
3722 }
3723 }
3724
3725 if (MaxJobsPerUser)
3726 {
3727 /*
3728 * Check if there are too many pending jobs for this user...
3729 */
3730
3731 if (cupsdGetUserJobCount(username) >= MaxJobsPerUser)
3732 {
3733 cupsdLogMessage(CUPSD_LOG_INFO, "Too many jobs for user \"%s\"...",
3734 username);
3735 return (-1);
3736 }
3737 }
3738
3739 /*
3740 * Check against users...
3741 */
3742
3743 if (cupsArrayCount(p->users) == 0 && p->k_limit == 0 && p->page_limit == 0)
3744 return (1);
3745
3746 if (cupsArrayCount(p->users))
3747 {
3748 #ifdef HAVE_MBR_UID_TO_UUID
3749 /*
3750 * Get UUID for job requesting user...
3751 */
3752
3753 if (mbr_user_name_to_uuid((char *)username, usr_uuid))
3754 {
3755 /*
3756 * Unknown user...
3757 */
3758
3759 cupsdLogMessage(CUPSD_LOG_DEBUG,
3760 "check_quotas: UUID lookup failed for user \"%s\"",
3761 username);
3762 cupsdLogMessage(CUPSD_LOG_INFO,
3763 "Denying user \"%s\" access to printer \"%s\" "
3764 "(unknown user)...",
3765 username, p->name);
3766 return (0);
3767 }
3768 #else
3769 /*
3770 * Get UID and GID of requesting user...
3771 */
3772
3773 pw = getpwnam(username);
3774 endpwent();
3775 #endif /* HAVE_MBR_UID_TO_UUID */
3776
3777 for (name = (char *)cupsArrayFirst(p->users);
3778 name;
3779 name = (char *)cupsArrayNext(p->users))
3780 if (name[0] == '@')
3781 {
3782 /*
3783 * Check group membership...
3784 */
3785
3786 #ifdef HAVE_MBR_UID_TO_UUID
3787 if (name[1] == '#')
3788 {
3789 if (uuid_parse(name + 2, grp_uuid))
3790 uuid_clear(grp_uuid);
3791 }
3792 else if ((mbr_err = mbr_group_name_to_uuid(name + 1, grp_uuid)) != 0)
3793 {
3794 /*
3795 * Invalid ACL entries are ignored for matching; just record a
3796 * warning in the log...
3797 */
3798
3799 cupsdLogMessage(CUPSD_LOG_DEBUG,
3800 "check_quotas: UUID lookup failed for ACL entry "
3801 "\"%s\" (err=%d)", name, mbr_err);
3802 cupsdLogMessage(CUPSD_LOG_WARN,
3803 "Access control entry \"%s\" not a valid group name; "
3804 "entry ignored", name);
3805 }
3806
3807 if ((mbr_err = mbr_check_membership(usr_uuid, grp_uuid,
3808 &is_member)) != 0)
3809 {
3810 /*
3811 * At this point, there should be no errors, but check anyways...
3812 */
3813
3814 cupsdLogMessage(CUPSD_LOG_DEBUG,
3815 "check_quotas: group \"%s\" membership check "
3816 "failed (err=%d)", name + 1, mbr_err);
3817 is_member = 0;
3818 }
3819
3820 /*
3821 * Stop if we found a match...
3822 */
3823
3824 if (is_member)
3825 break;
3826
3827 #else
3828 if (cupsdCheckGroup(username, pw, name + 1))
3829 break;
3830 #endif /* HAVE_MBR_UID_TO_UUID */
3831 }
3832 #ifdef HAVE_MBR_UID_TO_UUID
3833 else
3834 {
3835 if (name[0] == '#')
3836 {
3837 if (uuid_parse(name + 1, usr2_uuid))
3838 uuid_clear(usr2_uuid);
3839 }
3840 else if ((mbr_err = mbr_user_name_to_uuid(name, usr2_uuid)) != 0)
3841 {
3842 /*
3843 * Invalid ACL entries are ignored for matching; just record a
3844 * warning in the log...
3845 */
3846
3847 cupsdLogMessage(CUPSD_LOG_DEBUG,
3848 "check_quotas: UUID lookup failed for ACL entry "
3849 "\"%s\" (err=%d)", name, mbr_err);
3850 cupsdLogMessage(CUPSD_LOG_WARN,
3851 "Access control entry \"%s\" not a valid user name; "
3852 "entry ignored", name);
3853 }
3854
3855 if (!uuid_compare(usr_uuid, usr2_uuid))
3856 break;
3857 }
3858 #else
3859 else if (!_cups_strcasecmp(username, name))
3860 break;
3861 #endif /* HAVE_MBR_UID_TO_UUID */
3862
3863 if ((name != NULL) == p->deny_users)
3864 {
3865 cupsdLogMessage(CUPSD_LOG_INFO,
3866 "Denying user \"%s\" access to printer \"%s\"...",
3867 username, p->name);
3868 return (0);
3869 }
3870 }
3871
3872 /*
3873 * Check quotas...
3874 */
3875
3876 if (p->k_limit || p->page_limit)
3877 {
3878 if ((q = cupsdUpdateQuota(p, username, 0, 0)) == NULL)
3879 {
3880 cupsdLogMessage(CUPSD_LOG_ERROR,
3881 "Unable to allocate quota data for user \"%s\"",
3882 username);
3883 return (-1);
3884 }
3885
3886 if ((q->k_count >= p->k_limit && p->k_limit) ||
3887 (q->page_count >= p->page_limit && p->page_limit))
3888 {
3889 cupsdLogMessage(CUPSD_LOG_INFO, "User \"%s\" is over the quota limit...",
3890 username);
3891 return (-1);
3892 }
3893 }
3894
3895 /*
3896 * If we have gotten this far, we're done!
3897 */
3898
3899 return (1);
3900 }
3901
3902
3903 /*
3904 * 'close_job()' - Close a multi-file job.
3905 */
3906
3907 static void
3908 close_job(cupsd_client_t *con, /* I - Client connection */
3909 ipp_attribute_t *uri) /* I - Printer URI */
3910 {
3911 cupsd_job_t *job; /* Job */
3912 ipp_attribute_t *attr; /* Attribute */
3913 char job_uri[HTTP_MAX_URI],
3914 /* Job URI */
3915 username[256]; /* User name */
3916
3917
3918 cupsdLogMessage(CUPSD_LOG_DEBUG2, "close_job(%p[%d], %s)", con,
3919 con->number, uri->values[0].string.text);
3920
3921 /*
3922 * See if we have a job URI or a printer URI...
3923 */
3924
3925 if (strcmp(uri->name, "printer-uri"))
3926 {
3927 /*
3928 * job-uri is not supported by Close-Job!
3929 */
3930
3931 send_ipp_status(con, IPP_BAD_REQUEST,
3932 _("Close-Job doesn't support the job-uri attribute."));
3933 return;
3934 }
3935
3936 /*
3937 * Got a printer URI; see if we also have a job-id attribute...
3938 */
3939
3940 if ((attr = ippFindAttribute(con->request, "job-id",
3941 IPP_TAG_INTEGER)) == NULL)
3942 {
3943 send_ipp_status(con, IPP_BAD_REQUEST,
3944 _("Got a printer-uri attribute but no job-id."));
3945 return;
3946 }
3947
3948 if ((job = cupsdFindJob(attr->values[0].integer)) == NULL)
3949 {
3950 /*
3951 * Nope - return a "not found" error...
3952 */
3953
3954 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
3955 attr->values[0].integer);
3956 return;
3957 }
3958
3959 /*
3960 * See if the job is owned by the requesting user...
3961 */
3962
3963 if (!validate_user(job, con, job->username, username, sizeof(username)))
3964 {
3965 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
3966 cupsdFindDest(job->dest));
3967 return;
3968 }
3969
3970 /*
3971 * Add any ending sheet...
3972 */
3973
3974 if (cupsdTimeoutJob(job))
3975 return;
3976
3977 if (job->state_value == IPP_JOB_STOPPED)
3978 {
3979 job->state->values[0].integer = IPP_JOB_PENDING;
3980 job->state_value = IPP_JOB_PENDING;
3981 }
3982 else if (job->state_value == IPP_JOB_HELD)
3983 {
3984 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
3985 IPP_TAG_KEYWORD)) == NULL)
3986 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
3987
3988 if (!attr || !strcmp(attr->values[0].string.text, "no-hold"))
3989 {
3990 job->state->values[0].integer = IPP_JOB_PENDING;
3991 job->state_value = IPP_JOB_PENDING;
3992 }
3993 }
3994
3995 job->dirty = 1;
3996 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
3997
3998 /*
3999 * Fill in the response info...
4000 */
4001
4002 httpAssembleURIf(HTTP_URI_CODING_ALL, job_uri, sizeof(job_uri), "ipp", NULL,
4003 con->clientname, con->clientport, "/jobs/%d", job->id);
4004 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_URI, "job-uri", NULL,
4005 job_uri);
4006
4007 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-id", job->id);
4008
4009 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_ENUM, "job-state",
4010 job->state_value);
4011
4012 con->response->request.status.status_code = IPP_OK;
4013
4014 /*
4015 * Start the job if necessary...
4016 */
4017
4018 cupsdCheckJobs();
4019 }
4020
4021
4022 /*
4023 * 'copy_attrs()' - Copy attributes from one request to another.
4024 */
4025
4026 static void
4027 copy_attrs(ipp_t *to, /* I - Destination request */
4028 ipp_t *from, /* I - Source request */
4029 cups_array_t *ra, /* I - Requested attributes */
4030 ipp_tag_t group, /* I - Group to copy */
4031 int quickcopy, /* I - Do a quick copy? */
4032 cups_array_t *exclude) /* I - Attributes to exclude? */
4033 {
4034 ipp_attribute_t *fromattr; /* Source attribute */
4035
4036
4037 cupsdLogMessage(CUPSD_LOG_DEBUG2,
4038 "copy_attrs(to=%p, from=%p, ra=%p, group=%x, quickcopy=%d)",
4039 to, from, ra, group, quickcopy);
4040
4041 if (!to || !from)
4042 return;
4043
4044 for (fromattr = from->attrs; fromattr; fromattr = fromattr->next)
4045 {
4046 /*
4047 * Filter attributes as needed...
4048 */
4049
4050 if ((group != IPP_TAG_ZERO && fromattr->group_tag != group &&
4051 fromattr->group_tag != IPP_TAG_ZERO) || !fromattr->name)
4052 continue;
4053
4054 if (!strcmp(fromattr->name, "document-password") ||
4055 !strcmp(fromattr->name, "job-authorization-uri") ||
4056 !strcmp(fromattr->name, "job-password") ||
4057 !strcmp(fromattr->name, "job-password-encryption") ||
4058 !strcmp(fromattr->name, "job-printer-uri"))
4059 continue;
4060
4061 if (exclude &&
4062 (cupsArrayFind(exclude, fromattr->name) ||
4063 cupsArrayFind(exclude, "all")))
4064 {
4065 /*
4066 * We need to exclude this attribute for security reasons; we require the
4067 * job-id attribute regardless of the security settings for IPP
4068 * conformance.
4069 *
4070 * The job-printer-uri attribute is handled by copy_job_attrs().
4071 *
4072 * Subscription attribute security is handled by copy_subscription_attrs().
4073 */
4074
4075 if (strcmp(fromattr->name, "job-id"))
4076 continue;
4077 }
4078
4079 if (!ra || cupsArrayFind(ra, fromattr->name))
4080 {
4081 /*
4082 * Don't send collection attributes by default to IPP/1.x clients
4083 * since many do not support collections. Also don't send
4084 * media-col-database unless specifically requested by the client.
4085 */
4086
4087 if (fromattr->value_tag == IPP_TAG_BEGIN_COLLECTION &&
4088 !ra &&
4089 (to->request.status.version[0] == 1 ||
4090 !strcmp(fromattr->name, "media-col-database")))
4091 continue;
4092
4093 ippCopyAttribute(to, fromattr, quickcopy);
4094 }
4095 }
4096 }
4097
4098
4099 /*
4100 * 'copy_banner()' - Copy a banner file to the requests directory for the
4101 * specified job.
4102 */
4103
4104 static int /* O - Size of banner file in kbytes */
4105 copy_banner(cupsd_client_t *con, /* I - Client connection */
4106 cupsd_job_t *job, /* I - Job information */
4107 const char *name) /* I - Name of banner */
4108 {
4109 int i; /* Looping var */
4110 int kbytes; /* Size of banner file in kbytes */
4111 char filename[1024]; /* Job filename */
4112 cupsd_banner_t *banner; /* Pointer to banner */
4113 cups_file_t *in; /* Input file */
4114 cups_file_t *out; /* Output file */
4115 int ch; /* Character from file */
4116 char attrname[255], /* Name of attribute */
4117 *s; /* Pointer into name */
4118 ipp_attribute_t *attr; /* Attribute */
4119
4120
4121 cupsdLogMessage(CUPSD_LOG_DEBUG2,
4122 "copy_banner(con=%p[%d], job=%p[%d], name=\"%s\")",
4123 con, con ? con->number : -1, job, job->id,
4124 name ? name : "(null)");
4125
4126 /*
4127 * Find the banner; return if not found or "none"...
4128 */
4129
4130 if (!name || !strcmp(name, "none") ||
4131 (banner = cupsdFindBanner(name)) == NULL)
4132 return (0);
4133
4134 /*
4135 * Open the banner and job files...
4136 */
4137
4138 if (add_file(con, job, banner->filetype, 0))
4139 return (-1);
4140
4141 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot, job->id,
4142 job->num_files);
4143 if ((out = cupsFileOpen(filename, "w")) == NULL)
4144 {
4145 cupsdLogMessage(CUPSD_LOG_ERROR,
4146 "Unable to create banner job file %s - %s",
4147 filename, strerror(errno));
4148 job->num_files --;
4149 return (0);
4150 }
4151
4152 fchmod(cupsFileNumber(out), 0640);
4153 fchown(cupsFileNumber(out), RunUser, Group);
4154
4155 /*
4156 * Try the localized banner file under the subdirectory...
4157 */
4158
4159 strlcpy(attrname, job->attrs->attrs->next->values[0].string.text,
4160 sizeof(attrname));
4161 if (strlen(attrname) > 2 && attrname[2] == '-')
4162 {
4163 /*
4164 * Convert ll-cc to ll_CC...
4165 */
4166
4167 attrname[2] = '_';
4168 attrname[3] = (char)toupper(attrname[3] & 255);
4169 attrname[4] = (char)toupper(attrname[4] & 255);
4170 }
4171
4172 snprintf(filename, sizeof(filename), "%s/banners/%s/%s", DataDir,
4173 attrname, name);
4174
4175 if (access(filename, 0) && strlen(attrname) > 2)
4176 {
4177 /*
4178 * Wasn't able to find "ll_CC" locale file; try the non-national
4179 * localization banner directory.
4180 */
4181
4182 attrname[2] = '\0';
4183
4184 snprintf(filename, sizeof(filename), "%s/banners/%s/%s", DataDir,
4185 attrname, name);
4186 }
4187
4188 if (access(filename, 0))
4189 {
4190 /*
4191 * Use the non-localized banner file.
4192 */
4193
4194 snprintf(filename, sizeof(filename), "%s/banners/%s", DataDir, name);
4195 }
4196
4197 if ((in = cupsFileOpen(filename, "r")) == NULL)
4198 {
4199 cupsFileClose(out);
4200 unlink(filename);
4201 cupsdLogMessage(CUPSD_LOG_ERROR,
4202 "Unable to open banner template file %s - %s",
4203 filename, strerror(errno));
4204 job->num_files --;
4205 return (0);
4206 }
4207
4208 /*
4209 * Parse the file to the end...
4210 */
4211
4212 while ((ch = cupsFileGetChar(in)) != EOF)
4213 if (ch == '{')
4214 {
4215 /*
4216 * Get an attribute name...
4217 */
4218
4219 for (s = attrname; (ch = cupsFileGetChar(in)) != EOF;)
4220 if (!isalpha(ch & 255) && ch != '-' && ch != '?')
4221 break;
4222 else if (s < (attrname + sizeof(attrname) - 1))
4223 *s++ = (char)ch;
4224 else
4225 break;
4226
4227 *s = '\0';
4228
4229 if (ch != '}')
4230 {
4231 /*
4232 * Ignore { followed by stuff that is not an attribute name...
4233 */
4234
4235 cupsFilePrintf(out, "{%s%c", attrname, ch);
4236 continue;
4237 }
4238
4239 /*
4240 * See if it is defined...
4241 */
4242
4243 if (attrname[0] == '?')
4244 s = attrname + 1;
4245 else
4246 s = attrname;
4247
4248 if (!strcmp(s, "printer-name"))
4249 {
4250 cupsFilePuts(out, job->dest);
4251 continue;
4252 }
4253 else if ((attr = ippFindAttribute(job->attrs, s, IPP_TAG_ZERO)) == NULL)
4254 {
4255 /*
4256 * See if we have a leading question mark...
4257 */
4258
4259 if (attrname[0] != '?')
4260 {
4261 /*
4262 * Nope, write to file as-is; probably a PostScript procedure...
4263 */
4264
4265 cupsFilePrintf(out, "{%s}", attrname);
4266 }
4267
4268 continue;
4269 }
4270
4271 /*
4272 * Output value(s)...
4273 */
4274
4275 for (i = 0; i < attr->num_values; i ++)
4276 {
4277 if (i)
4278 cupsFilePutChar(out, ',');
4279
4280 switch (attr->value_tag)
4281 {
4282 case IPP_TAG_INTEGER :
4283 case IPP_TAG_ENUM :
4284 if (!strncmp(s, "time-at-", 8))
4285 {
4286 struct timeval tv; /* Time value */
4287
4288 tv.tv_sec = attr->values[i].integer;
4289 tv.tv_usec = 0;
4290
4291 cupsFilePuts(out, cupsdGetDateTime(&tv, CUPSD_TIME_STANDARD));
4292 }
4293 else
4294 cupsFilePrintf(out, "%d", attr->values[i].integer);
4295 break;
4296
4297 case IPP_TAG_BOOLEAN :
4298 cupsFilePrintf(out, "%d", attr->values[i].boolean);
4299 break;
4300
4301 case IPP_TAG_NOVALUE :
4302 cupsFilePuts(out, "novalue");
4303 break;
4304
4305 case IPP_TAG_RANGE :
4306 cupsFilePrintf(out, "%d-%d", attr->values[i].range.lower,
4307 attr->values[i].range.upper);
4308 break;
4309
4310 case IPP_TAG_RESOLUTION :
4311 cupsFilePrintf(out, "%dx%d%s", attr->values[i].resolution.xres,
4312 attr->values[i].resolution.yres,
4313 attr->values[i].resolution.units == IPP_RES_PER_INCH ?
4314 "dpi" : "dpcm");
4315 break;
4316
4317 case IPP_TAG_URI :
4318 case IPP_TAG_STRING :
4319 case IPP_TAG_TEXT :
4320 case IPP_TAG_NAME :
4321 case IPP_TAG_KEYWORD :
4322 case IPP_TAG_CHARSET :
4323 case IPP_TAG_LANGUAGE :
4324 if (!_cups_strcasecmp(banner->filetype->type, "postscript"))
4325 {
4326 /*
4327 * Need to quote strings for PS banners...
4328 */
4329
4330 const char *p;
4331
4332 for (p = attr->values[i].string.text; *p; p ++)
4333 {
4334 if (*p == '(' || *p == ')' || *p == '\\')
4335 {
4336 cupsFilePutChar(out, '\\');
4337 cupsFilePutChar(out, *p);
4338 }
4339 else if (*p < 32 || *p > 126)
4340 cupsFilePrintf(out, "\\%03o", *p & 255);
4341 else
4342 cupsFilePutChar(out, *p);
4343 }
4344 }
4345 else
4346 cupsFilePuts(out, attr->values[i].string.text);
4347 break;
4348
4349 default :
4350 break; /* anti-compiler-warning-code */
4351 }
4352 }
4353 }
4354 else if (ch == '\\') /* Quoted char */
4355 {
4356 ch = cupsFileGetChar(in);
4357
4358 if (ch != '{') /* Only do special handling for \{ */
4359 cupsFilePutChar(out, '\\');
4360
4361 cupsFilePutChar(out, ch);
4362 }
4363 else
4364 cupsFilePutChar(out, ch);
4365
4366 cupsFileClose(in);
4367
4368 kbytes = (cupsFileTell(out) + 1023) / 1024;
4369
4370 job->koctets += kbytes;
4371
4372 if ((attr = ippFindAttribute(job->attrs, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
4373 attr->values[0].integer += kbytes;
4374
4375 cupsFileClose(out);
4376
4377 return (kbytes);
4378 }
4379
4380
4381 /*
4382 * 'copy_file()' - Copy a PPD file...
4383 */
4384
4385 static int /* O - 0 = success, -1 = error */
4386 copy_file(const char *from, /* I - Source file */
4387 const char *to, /* I - Destination file */
4388 mode_t mode) /* I - Permissions */
4389 {
4390 cups_file_t *src, /* Source file */
4391 *dst; /* Destination file */
4392 int bytes; /* Bytes to read/write */
4393 char buffer[2048]; /* Copy buffer */
4394
4395
4396 cupsdLogMessage(CUPSD_LOG_DEBUG2, "copy_file(\"%s\", \"%s\")", from, to);
4397
4398 /*
4399 * Open the source and destination file for a copy...
4400 */
4401
4402 if ((src = cupsFileOpen(from, "rb")) == NULL)
4403 return (-1);
4404
4405 if ((dst = cupsdCreateConfFile(to, mode)) == NULL)
4406 {
4407 cupsFileClose(src);
4408 return (-1);
4409 }
4410
4411 /*
4412 * Copy the source file to the destination...
4413 */
4414
4415 while ((bytes = cupsFileRead(src, buffer, sizeof(buffer))) > 0)
4416 if (cupsFileWrite(dst, buffer, (size_t)bytes) < bytes)
4417 {
4418 cupsFileClose(src);
4419 cupsFileClose(dst);
4420 return (-1);
4421 }
4422
4423 /*
4424 * Close both files and return...
4425 */
4426
4427 cupsFileClose(src);
4428
4429 return (cupsdCloseCreatedConfFile(dst, to));
4430 }
4431
4432
4433 /*
4434 * 'copy_model()' - Copy a PPD model file, substituting default values
4435 * as needed...
4436 */
4437
4438 static int /* O - 0 = success, -1 = error */
4439 copy_model(cupsd_client_t *con, /* I - Client connection */
4440 const char *from, /* I - Source file */
4441 const char *to) /* I - Destination file */
4442 {
4443 fd_set input; /* select() input set */
4444 struct timeval timeout; /* select() timeout */
4445 int maxfd; /* Max file descriptor for select() */
4446 char tempfile[1024]; /* Temporary PPD file */
4447 int tempfd; /* Temporary PPD file descriptor */
4448 int temppid; /* Process ID of cups-driverd */
4449 int temppipe[2]; /* Temporary pipes */
4450 char *argv[4], /* Command-line arguments */
4451 *envp[MAX_ENV]; /* Environment */
4452 cups_file_t *src, /* Source file */
4453 *dst; /* Destination file */
4454 ppd_file_t *ppd; /* PPD file */
4455 int bytes, /* Bytes from pipe */
4456 total; /* Total bytes from pipe */
4457 char buffer[2048]; /* Copy buffer */
4458 int i; /* Looping var */
4459 char option[PPD_MAX_NAME], /* Option name */
4460 choice[PPD_MAX_NAME]; /* Choice name */
4461 ppd_size_t *size; /* Default size */
4462 int num_defaults; /* Number of default options */
4463 cups_option_t *defaults; /* Default options */
4464 char cups_protocol[PPD_MAX_LINE];
4465 /* cupsProtocol attribute */
4466
4467
4468 cupsdLogMessage(CUPSD_LOG_DEBUG2, "copy_model(con=%p, from=\"%s\", to=\"%s\")", con, from, to);
4469
4470 /*
4471 * Run cups-driverd to get the PPD file...
4472 */
4473
4474 argv[0] = "cups-driverd";
4475 argv[1] = "cat";
4476 argv[2] = (char *)from;
4477 argv[3] = NULL;
4478
4479 cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
4480
4481 snprintf(buffer, sizeof(buffer), "%s/daemon/cups-driverd", ServerBin);
4482 snprintf(tempfile, sizeof(tempfile), "%s/%d.ppd", TempDir, con->number);
4483 tempfd = open(tempfile, O_WRONLY | O_CREAT | O_TRUNC, 0600);
4484 if (tempfd < 0 || cupsdOpenPipe(temppipe))
4485 return (-1);
4486
4487 cupsdLogMessage(CUPSD_LOG_DEBUG,
4488 "copy_model: Running \"cups-driverd cat %s\"...", from);
4489
4490 if (!cupsdStartProcess(buffer, argv, envp, -1, temppipe[1], CGIPipes[1],
4491 -1, -1, 0, DefaultProfile, NULL, &temppid))
4492 {
4493 close(tempfd);
4494 unlink(tempfile);
4495
4496 return (-1);
4497 }
4498
4499 close(temppipe[1]);
4500
4501 /*
4502 * Wait up to 30 seconds for the PPD file to be copied...
4503 */
4504
4505 total = 0;
4506
4507 if (temppipe[0] > CGIPipes[0])
4508 maxfd = temppipe[0] + 1;
4509 else
4510 maxfd = CGIPipes[0] + 1;
4511
4512 for (;;)
4513 {
4514 /*
4515 * See if we have data ready...
4516 */
4517
4518 FD_ZERO(&input);
4519 FD_SET(temppipe[0], &input);
4520 FD_SET(CGIPipes[0], &input);
4521
4522 timeout.tv_sec = 30;
4523 timeout.tv_usec = 0;
4524
4525 if ((i = select(maxfd, &input, NULL, NULL, &timeout)) < 0)
4526 {
4527 if (errno == EINTR)
4528 continue;
4529 else
4530 break;
4531 }
4532 else if (i == 0)
4533 {
4534 /*
4535 * We have timed out...
4536 */
4537
4538 break;
4539 }
4540
4541 if (FD_ISSET(temppipe[0], &input))
4542 {
4543 /*
4544 * Read the PPD file from the pipe, and write it to the PPD file.
4545 */
4546
4547 if ((bytes = read(temppipe[0], buffer, sizeof(buffer))) > 0)
4548 {
4549 if (write(tempfd, buffer, (size_t)bytes) < bytes)
4550 break;
4551
4552 total += bytes;
4553 }
4554 else
4555 break;
4556 }
4557
4558 if (FD_ISSET(CGIPipes[0], &input))
4559 cupsdUpdateCGI();
4560 }
4561
4562 close(temppipe[0]);
4563 close(tempfd);
4564
4565 if (!total)
4566 {
4567 /*
4568 * No data from cups-deviced...
4569 */
4570
4571 cupsdLogMessage(CUPSD_LOG_ERROR, "copy_model: empty PPD file");
4572 unlink(tempfile);
4573 return (-1);
4574 }
4575
4576 /*
4577 * Open the source file for a copy...
4578 */
4579
4580 if ((src = cupsFileOpen(tempfile, "rb")) == NULL)
4581 {
4582 unlink(tempfile);
4583 return (-1);
4584 }
4585
4586 /*
4587 * Read the source file and see what page sizes are supported...
4588 */
4589
4590 if ((ppd = _ppdOpen(src, _PPD_LOCALIZATION_NONE)) == NULL)
4591 {
4592 cupsFileClose(src);
4593 unlink(tempfile);
4594 return (-1);
4595 }
4596
4597 /*
4598 * Open the destination (if possible) and set the default options...
4599 */
4600
4601 num_defaults = 0;
4602 defaults = NULL;
4603 cups_protocol[0] = '\0';
4604
4605 if ((dst = cupsFileOpen(to, "rb")) != NULL)
4606 {
4607 /*
4608 * Read all of the default lines from the old PPD...
4609 */
4610
4611 while (cupsFileGets(dst, buffer, sizeof(buffer)))
4612 if (!strncmp(buffer, "*Default", 8))
4613 {
4614 /*
4615 * Add the default option...
4616 */
4617
4618 if (!ppd_parse_line(buffer, option, sizeof(option),
4619 choice, sizeof(choice)))
4620 {
4621 ppd_option_t *ppdo; /* PPD option */
4622
4623
4624 /*
4625 * Only add the default if the default hasn't already been
4626 * set and the choice exists in the new PPD...
4627 */
4628
4629 if (!cupsGetOption(option, num_defaults, defaults) &&
4630 (ppdo = ppdFindOption(ppd, option)) != NULL &&
4631 ppdFindChoice(ppdo, choice))
4632 num_defaults = cupsAddOption(option, choice, num_defaults,
4633 &defaults);
4634 }
4635 }
4636 else if (!strncmp(buffer, "*cupsProtocol:", 14))
4637 strlcpy(cups_protocol, buffer, sizeof(cups_protocol));
4638
4639 cupsFileClose(dst);
4640 }
4641 else if ((size = ppdPageSize(ppd, DefaultPaperSize)) != NULL)
4642 {
4643 /*
4644 * Add the default media sizes...
4645 */
4646
4647 num_defaults = cupsAddOption("PageSize", size->name,
4648 num_defaults, &defaults);
4649 num_defaults = cupsAddOption("PageRegion", size->name,
4650 num_defaults, &defaults);
4651 num_defaults = cupsAddOption("PaperDimension", size->name,
4652 num_defaults, &defaults);
4653 num_defaults = cupsAddOption("ImageableArea", size->name,
4654 num_defaults, &defaults);
4655 }
4656
4657 ppdClose(ppd);
4658
4659 /*
4660 * Open the destination file for a copy...
4661 */
4662
4663 if ((dst = cupsdCreateConfFile(to, ConfigFilePerm)) == NULL)
4664 {
4665 cupsFreeOptions(num_defaults, defaults);
4666 cupsFileClose(src);
4667 unlink(tempfile);
4668 return (-1);
4669 }
4670
4671 /*
4672 * Copy the source file to the destination...
4673 */
4674
4675 cupsFileRewind(src);
4676
4677 while (cupsFileGets(src, buffer, sizeof(buffer)))
4678 {
4679 if (!strncmp(buffer, "*Default", 8))
4680 {
4681 /*
4682 * Check for an previous default option choice...
4683 */
4684
4685 if (!ppd_parse_line(buffer, option, sizeof(option),
4686 choice, sizeof(choice)))
4687 {
4688 const char *val; /* Default option value */
4689
4690
4691 if ((val = cupsGetOption(option, num_defaults, defaults)) != NULL)
4692 {
4693 /*
4694 * Substitute the previous choice...
4695 */
4696
4697 snprintf(buffer, sizeof(buffer), "*Default%s: %s", option, val);
4698 }
4699 }
4700 }
4701
4702 cupsFilePrintf(dst, "%s\n", buffer);
4703 }
4704
4705 if (cups_protocol[0])
4706 cupsFilePrintf(dst, "%s\n", cups_protocol);
4707
4708 cupsFreeOptions(num_defaults, defaults);
4709
4710 /*
4711 * Close both files and return...
4712 */
4713
4714 cupsFileClose(src);
4715
4716 unlink(tempfile);
4717
4718 return (cupsdCloseCreatedConfFile(dst, to));
4719 }
4720
4721
4722 /*
4723 * 'copy_job_attrs()' - Copy job attributes.
4724 */
4725
4726 static void
4727 copy_job_attrs(cupsd_client_t *con, /* I - Client connection */
4728 cupsd_job_t *job, /* I - Job */
4729 cups_array_t *ra, /* I - Requested attributes array */
4730 cups_array_t *exclude) /* I - Private attributes array */
4731 {
4732 char job_uri[HTTP_MAX_URI]; /* Job URI */
4733
4734
4735 /*
4736 * Send the requested attributes for each job...
4737 */
4738
4739 if (!cupsArrayFind(exclude, "all"))
4740 {
4741 if ((!exclude || !cupsArrayFind(exclude, "number-of-documents")) &&
4742 (!ra || cupsArrayFind(ra, "number-of-documents")))
4743 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER,
4744 "number-of-documents", job->num_files);
4745
4746 if ((!exclude || !cupsArrayFind(exclude, "job-media-progress")) &&
4747 (!ra || cupsArrayFind(ra, "job-media-progress")))
4748 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER,
4749 "job-media-progress", job->progress);
4750
4751 if ((!exclude || !cupsArrayFind(exclude, "job-more-info")) &&
4752 (!ra || cupsArrayFind(ra, "job-more-info")))
4753 {
4754 httpAssembleURIf(HTTP_URI_CODING_ALL, job_uri, sizeof(job_uri), "http",
4755 NULL, con->clientname, con->clientport, "/jobs/%d",
4756 job->id);
4757 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_URI,
4758 "job-more-info", NULL, job_uri);
4759 }
4760
4761 if (job->state_value > IPP_JOB_PROCESSING &&
4762 (!exclude || !cupsArrayFind(exclude, "job-preserved")) &&
4763 (!ra || cupsArrayFind(ra, "job-preserved")))
4764 ippAddBoolean(con->response, IPP_TAG_JOB, "job-preserved",
4765 job->num_files > 0);
4766
4767 if ((!exclude || !cupsArrayFind(exclude, "job-printer-up-time")) &&
4768 (!ra || cupsArrayFind(ra, "job-printer-up-time")))
4769 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER,
4770 "job-printer-up-time", time(NULL));
4771 }
4772
4773 if (!ra || cupsArrayFind(ra, "job-printer-uri"))
4774 {
4775 httpAssembleURIf(HTTP_URI_CODING_ALL, job_uri, sizeof(job_uri), "ipp", NULL,
4776 con->clientname, con->clientport,
4777 (job->dtype & CUPS_PRINTER_CLASS) ? "/classes/%s" :
4778 "/printers/%s",
4779 job->dest);
4780 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_URI,
4781 "job-printer-uri", NULL, job_uri);
4782 }
4783
4784 if (!ra || cupsArrayFind(ra, "job-uri"))
4785 {
4786 httpAssembleURIf(HTTP_URI_CODING_ALL, job_uri, sizeof(job_uri), "ipp", NULL,
4787 con->clientname, con->clientport, "/jobs/%d",
4788 job->id);
4789 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_URI,
4790 "job-uri", NULL, job_uri);
4791 }
4792
4793 if (job->attrs)
4794 {
4795 copy_attrs(con->response, job->attrs, ra, IPP_TAG_JOB, 0, exclude);
4796 }
4797 else
4798 {
4799 /*
4800 * Generate attributes from the job structure...
4801 */
4802
4803 if (job->completed_time && (!ra || cupsArrayFind(ra, "date-time-at-completed")))
4804 ippAddDate(con->response, IPP_TAG_JOB, "date-time-at-completed", ippTimeToDate(job->completed_time));
4805
4806 if (job->creation_time && (!ra || cupsArrayFind(ra, "date-time-at-creation")))
4807 ippAddDate(con->response, IPP_TAG_JOB, "date-time-at-creation", ippTimeToDate(job->creation_time));
4808
4809 if (!ra || cupsArrayFind(ra, "job-id"))
4810 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-id", job->id);
4811
4812 if (!ra || cupsArrayFind(ra, "job-k-octets"))
4813 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-k-octets", job->koctets);
4814
4815 if (job->name && (!ra || cupsArrayFind(ra, "job-name")))
4816 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_NAME, "job-name", NULL, job->name);
4817
4818 if (job->username && (!ra || cupsArrayFind(ra, "job-originating-user-name")))
4819 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_NAME, "job-originating-user-name", NULL, job->username);
4820
4821 if (!ra || cupsArrayFind(ra, "job-state"))
4822 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_ENUM, "job-state", (int)job->state_value);
4823
4824 if (!ra || cupsArrayFind(ra, "job-state-reasons"))
4825 {
4826 switch (job->state_value)
4827 {
4828 default : /* Should never get here for processing, pending, held, or stopped jobs since they don't get unloaded... */
4829 break;
4830 case IPP_JSTATE_ABORTED :
4831 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-state-reasons", NULL, "job-aborted-by-system");
4832 break;
4833 case IPP_JSTATE_CANCELED :
4834 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-state-reasons", NULL, "job-canceled-by-user");
4835 break;
4836 case IPP_JSTATE_COMPLETED :
4837 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-state-reasons", NULL, "job-completed-successfully");
4838 break;
4839 }
4840 }
4841
4842 if (job->completed_time && (!ra || cupsArrayFind(ra, "time-at-completed")))
4843 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "time-at-completed", (int)job->completed_time);
4844
4845 if (job->creation_time && (!ra || cupsArrayFind(ra, "time-at-creation")))
4846 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "time-at-creation", (int)job->creation_time);
4847 }
4848 }
4849
4850
4851 /*
4852 * 'copy_printer_attrs()' - Copy printer attributes.
4853 */
4854
4855 static void
4856 copy_printer_attrs(
4857 cupsd_client_t *con, /* I - Client connection */
4858 cupsd_printer_t *printer, /* I - Printer */
4859 cups_array_t *ra) /* I - Requested attributes array */
4860 {
4861 char uri[HTTP_MAX_URI]; /* URI value */
4862 time_t curtime; /* Current time */
4863 int i; /* Looping var */
4864 int is_encrypted = httpIsEncrypted(con->http);
4865 /* Is the connection encrypted? */
4866
4867
4868 /*
4869 * Copy the printer attributes to the response using requested-attributes
4870 * and document-format attributes that may be provided by the client.
4871 */
4872
4873 _cupsRWLockRead(&printer->lock);
4874
4875 curtime = time(NULL);
4876
4877 if (!ra || cupsArrayFind(ra, "marker-change-time"))
4878 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "marker-change-time", printer->marker_time);
4879
4880 if (printer->num_printers > 0 && (!ra || cupsArrayFind(ra, "member-uris")))
4881 {
4882 ipp_attribute_t *member_uris; /* member-uris attribute */
4883 cupsd_printer_t *p2; /* Printer in class */
4884 ipp_attribute_t *p2_uri; /* printer-uri-supported for class printer */
4885
4886
4887 if ((member_uris = ippAddStrings(con->response, IPP_TAG_PRINTER, IPP_TAG_URI, "member-uris", printer->num_printers, NULL, NULL)) != NULL)
4888 {
4889 for (i = 0; i < printer->num_printers; i ++)
4890 {
4891 p2 = printer->printers[i];
4892
4893 if ((p2_uri = ippFindAttribute(p2->attrs, "printer-uri-supported", IPP_TAG_URI)) != NULL)
4894 {
4895 member_uris->values[i].string.text = _cupsStrRetain(p2_uri->values[0].string.text);
4896 }
4897 else
4898 {
4899 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), is_encrypted ? "ipps" : "ipp", NULL, con->clientname, con->clientport, (p2->type & CUPS_PRINTER_CLASS) ? "/classes/%s" : "/printers/%s", p2->name);
4900 member_uris->values[i].string.text = _cupsStrAlloc(uri);
4901 }
4902 }
4903 }
4904 }
4905
4906 if (printer->alert && (!ra || cupsArrayFind(ra, "printer-alert")))
4907 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_STRING, "printer-alert", NULL, printer->alert);
4908
4909 if (printer->alert_description && (!ra || cupsArrayFind(ra, "printer-alert-description")))
4910 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-alert-description", NULL, printer->alert_description);
4911
4912 if (!ra || cupsArrayFind(ra, "printer-config-change-date-time"))
4913 ippAddDate(con->response, IPP_TAG_PRINTER, "printer-config-change-date-time", ippTimeToDate(printer->config_time));
4914
4915 if (!ra || cupsArrayFind(ra, "printer-config-change-time"))
4916 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "printer-config-change-time", printer->config_time);
4917
4918 if (!ra || cupsArrayFind(ra, "printer-current-time"))
4919 ippAddDate(con->response, IPP_TAG_PRINTER, "printer-current-time", ippTimeToDate(curtime));
4920
4921 #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI)
4922 if (!ra || cupsArrayFind(ra, "printer-dns-sd-name"))
4923 {
4924 if (printer->reg_name)
4925 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_NAME, "printer-dns-sd-name", NULL, printer->reg_name);
4926 else
4927 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_NOVALUE, "printer-dns-sd-name", 0);
4928 }
4929 #endif /* HAVE_DNSSD || HAVE_AVAHI */
4930
4931 if (!ra || cupsArrayFind(ra, "printer-error-policy"))
4932 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_NAME, "printer-error-policy", NULL, printer->error_policy);
4933
4934 if (!ra || cupsArrayFind(ra, "printer-error-policy-supported"))
4935 {
4936 static const char * const errors[] =/* printer-error-policy-supported values */
4937 {
4938 "abort-job",
4939 "retry-current-job",
4940 "retry-job",
4941 "stop-printer"
4942 };
4943
4944 if (printer->type & CUPS_PRINTER_CLASS)
4945 ippAddString(con->response, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_NAME), "printer-error-policy-supported", NULL, "retry-current-job");
4946 else
4947 ippAddStrings(con->response, IPP_TAG_PRINTER, IPP_CONST_TAG(IPP_TAG_NAME), "printer-error-policy-supported", sizeof(errors) / sizeof(errors[0]), NULL, errors);
4948 }
4949
4950 if (!ra || cupsArrayFind(ra, "printer-icons"))
4951 {
4952 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), is_encrypted ? "https" : "http", NULL, con->clientname, con->clientport, "/icons/%s.png", printer->name);
4953 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-icons", NULL, uri);
4954 cupsdLogMessage(CUPSD_LOG_DEBUG2, "printer-icons=\"%s\"", uri);
4955 }
4956
4957 if (!ra || cupsArrayFind(ra, "printer-is-accepting-jobs"))
4958 ippAddBoolean(con->response, IPP_TAG_PRINTER, "printer-is-accepting-jobs", (char)printer->accepting);
4959
4960 if (!ra || cupsArrayFind(ra, "printer-is-shared"))
4961 ippAddBoolean(con->response, IPP_TAG_PRINTER, "printer-is-shared", (char)printer->shared);
4962
4963 if (!ra || cupsArrayFind(ra, "printer-is-temporary"))
4964 ippAddBoolean(con->response, IPP_TAG_PRINTER, "printer-is-temporary", (char)printer->temporary);
4965
4966 if (!ra || cupsArrayFind(ra, "printer-more-info"))
4967 {
4968 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), is_encrypted ? "https" : "http", NULL, con->clientname, con->clientport, (printer->type & CUPS_PRINTER_CLASS) ? "/classes/%s" : "/printers/%s", printer->name);
4969 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-more-info", NULL, uri);
4970 }
4971
4972 if (!ra || cupsArrayFind(ra, "printer-op-policy"))
4973 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_NAME, "printer-op-policy", NULL, printer->op_policy);
4974
4975 if (!ra || cupsArrayFind(ra, "printer-state"))
4976 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state", printer->state);
4977
4978 if (!ra || cupsArrayFind(ra, "printer-state-change-date-time"))
4979 ippAddDate(con->response, IPP_TAG_PRINTER, "printer-state-change-date-time", ippTimeToDate(printer->state_time));
4980
4981 if (!ra || cupsArrayFind(ra, "printer-state-change-time"))
4982 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "printer-state-change-time", printer->state_time);
4983
4984 if (!ra || cupsArrayFind(ra, "printer-state-message"))
4985 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-state-message", NULL, printer->state_message);
4986
4987 if (!ra || cupsArrayFind(ra, "printer-state-reasons"))
4988 add_printer_state_reasons(con, printer);
4989
4990 if (!ra || cupsArrayFind(ra, "printer-strings-uri"))
4991 {
4992 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), is_encrypted ? "https" : "http", NULL, con->clientname, con->clientport, "/strings/%s.strings", printer->name);
4993 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-strings-uri", NULL, uri);
4994 cupsdLogMessage(CUPSD_LOG_DEBUG2, "printer-strings-uri=\"%s\"", uri);
4995 }
4996
4997 if (!ra || cupsArrayFind(ra, "printer-type"))
4998 {
4999 cups_ptype_t type; /* printer-type value */
5000
5001 /*
5002 * Add the CUPS-specific printer-type attribute...
5003 */
5004
5005 type = printer->type;
5006
5007 if (printer == DefaultPrinter)
5008 type |= CUPS_PRINTER_DEFAULT;
5009
5010 if (!printer->accepting)
5011 type |= CUPS_PRINTER_REJECTING;
5012
5013 if (!printer->shared)
5014 type |= CUPS_PRINTER_NOT_SHARED;
5015
5016 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-type", (int)type);
5017 }
5018
5019 if (!ra || cupsArrayFind(ra, "printer-up-time"))
5020 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "printer-up-time", curtime);
5021
5022 if (!ra || cupsArrayFind(ra, "printer-uri-supported"))
5023 {
5024 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), is_encrypted ? "ipps" : "ipp", NULL, con->clientname, con->clientport, (printer->type & CUPS_PRINTER_CLASS) ? "/classes/%s" : "/printers/%s", printer->name);
5025 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-uri-supported", NULL, uri);
5026 cupsdLogMessage(CUPSD_LOG_DEBUG2, "printer-uri-supported=\"%s\"", uri);
5027 }
5028
5029 if (!ra || cupsArrayFind(ra, "queued-job-count"))
5030 add_queued_job_count(con, printer);
5031
5032 copy_attrs(con->response, printer->attrs, ra, IPP_TAG_ZERO, 0, NULL);
5033 if (printer->ppd_attrs)
5034 copy_attrs(con->response, printer->ppd_attrs, ra, IPP_TAG_ZERO, 0, NULL);
5035 copy_attrs(con->response, CommonData, ra, IPP_TAG_ZERO, IPP_TAG_COPY, NULL);
5036
5037 _cupsRWUnlock(&printer->lock);
5038 }
5039
5040
5041 /*
5042 * 'copy_subscription_attrs()' - Copy subscription attributes.
5043 */
5044
5045 static void
5046 copy_subscription_attrs(
5047 cupsd_client_t *con, /* I - Client connection */
5048 cupsd_subscription_t *sub, /* I - Subscription */
5049 cups_array_t *ra, /* I - Requested attributes array */
5050 cups_array_t *exclude) /* I - Private attributes array */
5051 {
5052 ipp_attribute_t *attr; /* Current attribute */
5053 char printer_uri[HTTP_MAX_URI];
5054 /* Printer URI */
5055 int count; /* Number of events */
5056 unsigned mask; /* Current event mask */
5057 const char *name; /* Current event name */
5058
5059
5060 cupsdLogMessage(CUPSD_LOG_DEBUG2,
5061 "copy_subscription_attrs(con=%p, sub=%p, ra=%p, exclude=%p)",
5062 con, sub, ra, exclude);
5063
5064 /*
5065 * Copy the subscription attributes to the response using the
5066 * requested-attributes attribute that may be provided by the client.
5067 */
5068
5069 if (!exclude || !cupsArrayFind(exclude, "all"))
5070 {
5071 if ((!exclude || !cupsArrayFind(exclude, "notify-events")) &&
5072 (!ra || cupsArrayFind(ra, "notify-events")))
5073 {
5074 cupsdLogMessage(CUPSD_LOG_DEBUG2, "copy_subscription_attrs: notify-events");
5075
5076 if ((name = cupsdEventName((cupsd_eventmask_t)sub->mask)) != NULL)
5077 {
5078 /*
5079 * Simple event list...
5080 */
5081
5082 ippAddString(con->response, IPP_TAG_SUBSCRIPTION, IPP_CONST_TAG(IPP_TAG_KEYWORD), "notify-events", NULL, name);
5083 }
5084 else
5085 {
5086 /*
5087 * Complex event list...
5088 */
5089
5090 for (mask = 1, count = 0; mask < CUPSD_EVENT_ALL; mask <<= 1)
5091 if (sub->mask & mask)
5092 count ++;
5093
5094 attr = ippAddStrings(con->response, IPP_TAG_SUBSCRIPTION, IPP_CONST_TAG(IPP_TAG_KEYWORD), "notify-events", count, NULL, NULL);
5095
5096 for (mask = 1, count = 0; mask < CUPSD_EVENT_ALL; mask <<= 1)
5097 if (sub->mask & mask)
5098 {
5099 attr->values[count].string.text = (char *)cupsdEventName((cupsd_eventmask_t)mask);
5100
5101 count ++;
5102 }
5103 }
5104 }
5105
5106 if ((!exclude || !cupsArrayFind(exclude, "notify-lease-duration")) &&
5107 (!sub->job && (!ra || cupsArrayFind(ra, "notify-lease-duration"))))
5108 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
5109 "notify-lease-duration", sub->lease);
5110
5111 if ((!exclude || !cupsArrayFind(exclude, "notify-recipient-uri")) &&
5112 (sub->recipient && (!ra || cupsArrayFind(ra, "notify-recipient-uri"))))
5113 ippAddString(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
5114 "notify-recipient-uri", NULL, sub->recipient);
5115 else if ((!exclude || !cupsArrayFind(exclude, "notify-pull-method")) &&
5116 (!ra || cupsArrayFind(ra, "notify-pull-method")))
5117 ippAddString(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
5118 "notify-pull-method", NULL, "ippget");
5119
5120 if ((!exclude || !cupsArrayFind(exclude, "notify-subscriber-user-name")) &&
5121 (!ra || cupsArrayFind(ra, "notify-subscriber-user-name")))
5122 ippAddString(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_NAME,
5123 "notify-subscriber-user-name", NULL, sub->owner);
5124
5125 if ((!exclude || !cupsArrayFind(exclude, "notify-time-interval")) &&
5126 (!ra || cupsArrayFind(ra, "notify-time-interval")))
5127 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
5128 "notify-time-interval", sub->interval);
5129
5130 if (sub->user_data_len > 0 &&
5131 (!exclude || !cupsArrayFind(exclude, "notify-user-data")) &&
5132 (!ra || cupsArrayFind(ra, "notify-user-data")))
5133 ippAddOctetString(con->response, IPP_TAG_SUBSCRIPTION, "notify-user-data",
5134 sub->user_data, sub->user_data_len);
5135 }
5136
5137 if (sub->job && (!ra || cupsArrayFind(ra, "notify-job-id")))
5138 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
5139 "notify-job-id", sub->job->id);
5140
5141 if (sub->dest && (!ra || cupsArrayFind(ra, "notify-printer-uri")))
5142 {
5143 httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri),
5144 "ipp", NULL, con->clientname, con->clientport,
5145 "/printers/%s", sub->dest->name);
5146 ippAddString(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
5147 "notify-printer-uri", NULL, printer_uri);
5148 }
5149
5150 if (!ra || cupsArrayFind(ra, "notify-subscription-id"))
5151 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
5152 "notify-subscription-id", sub->id);
5153 }
5154
5155
5156 /*
5157 * 'create_job()' - Print a file to a printer or class.
5158 */
5159
5160 static void
5161 create_job(cupsd_client_t *con, /* I - Client connection */
5162 ipp_attribute_t *uri) /* I - Printer URI */
5163 {
5164 int i; /* Looping var */
5165 cupsd_printer_t *printer; /* Printer */
5166 cupsd_job_t *job; /* New job */
5167 static const char * const forbidden_attrs[] =
5168 { /* List of forbidden attributes */
5169 "compression",
5170 "document-format",
5171 "document-name",
5172 "document-natural-language"
5173 };
5174
5175
5176 cupsdLogMessage(CUPSD_LOG_DEBUG2, "create_job(%p[%d], %s)", con,
5177 con->number, uri->values[0].string.text);
5178
5179 /*
5180 * Is the destination valid?
5181 */
5182
5183 if (!cupsdValidateDest(uri->values[0].string.text, NULL, &printer))
5184 {
5185 /*
5186 * Bad URI...
5187 */
5188
5189 send_ipp_status(con, IPP_NOT_FOUND,
5190 _("The printer or class does not exist."));
5191 return;
5192 }
5193
5194 /*
5195 * Check for invalid Create-Job attributes and log a warning or error depending
5196 * on whether cupsd is running in "strict conformance" mode...
5197 */
5198
5199 for (i = 0;
5200 i < (int)(sizeof(forbidden_attrs) / sizeof(forbidden_attrs[0]));
5201 i ++)
5202 if (ippFindAttribute(con->request, forbidden_attrs[i], IPP_TAG_ZERO))
5203 {
5204 if (StrictConformance)
5205 {
5206 send_ipp_status(con, IPP_BAD_REQUEST,
5207 _("The '%s' operation attribute cannot be supplied in a "
5208 "Create-Job request."), forbidden_attrs[i]);
5209 return;
5210 }
5211
5212 cupsdLogMessage(CUPSD_LOG_WARN,
5213 "Unexpected '%s' operation attribute in a Create-Job "
5214 "request.", forbidden_attrs[i]);
5215 }
5216
5217 /*
5218 * Create the job object...
5219 */
5220
5221 if ((job = add_job(con, printer, NULL)) == NULL)
5222 return;
5223
5224 job->pending_timeout = 1;
5225
5226 /*
5227 * Save and log the job...
5228 */
5229
5230 cupsdLogJob(job, CUPSD_LOG_INFO, "Queued on \"%s\" by \"%s\".",
5231 job->dest, job->username);
5232 }
5233
5234
5235 /*
5236 * 'create_local_bg_thread()' - Background thread for creating a local print queue.
5237 */
5238
5239 static void * /* O - Exit status */
5240 create_local_bg_thread(
5241 cupsd_printer_t *printer) /* I - Printer */
5242 {
5243 cups_file_t *from, /* Source file */
5244 *to; /* Destination file */
5245 char fromppd[1024], /* Source PPD */
5246 toppd[1024], /* Destination PPD */
5247 scheme[32], /* URI scheme */
5248 userpass[256], /* User:pass */
5249 host[256], /* Hostname */
5250 resource[1024], /* Resource path */
5251 line[1024]; /* Line from PPD */
5252 int port; /* Port number */
5253 http_encryption_t encryption; /* Type of encryption to use */
5254 http_t *http; /* Connection to printer */
5255 ipp_t *request, /* Request to printer */
5256 *response; /* Response from printer */
5257 ipp_attribute_t *attr; /* Attribute in response */
5258 ipp_status_t status; /* Status code */
5259 static const char * const pattrs[] = /* Printer attributes we need */
5260 {
5261 "all",
5262 "media-col-database"
5263 };
5264
5265
5266 /*
5267 * Try connecting to the printer...
5268 */
5269
5270 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s: Generating PPD file from \"%s\"...", printer->name, printer->device_uri);
5271
5272 if (httpSeparateURI(HTTP_URI_CODING_ALL, printer->device_uri, scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_STATUS_OK)
5273 {
5274 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: Bad device URI \"%s\".", printer->name, printer->device_uri);
5275 return (NULL);
5276 }
5277
5278 if (!strcmp(scheme, "ipps") || port == 443)
5279 encryption = HTTP_ENCRYPTION_ALWAYS;
5280 else
5281 encryption = HTTP_ENCRYPTION_IF_REQUESTED;
5282
5283 if ((http = httpConnect2(host, port, NULL, AF_UNSPEC, encryption, 1, 30000, NULL)) == NULL)
5284 {
5285 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: Unable to connect to %s:%d: %s", printer->name, host, port, cupsLastErrorString());
5286 return (NULL);
5287 }
5288
5289 /*
5290 * Query the printer for its capabilities...
5291 */
5292
5293 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s: Connected to %s:%d, sending Get-Printer-Attributes request...", printer->name, host, port);
5294
5295 request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
5296 ippSetVersion(request, 2, 0);
5297 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, printer->device_uri);
5298 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
5299
5300 response = cupsDoRequest(http, request, resource);
5301 status = cupsLastError();
5302
5303 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s: Get-Printer-Attributes returned %s (%s)", printer->name, ippErrorString(cupsLastError()), cupsLastErrorString());
5304
5305 if (status == IPP_STATUS_ERROR_BAD_REQUEST || status == IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED)
5306 {
5307 /*
5308 * Try request using IPP/1.1, in case we are talking to an old CUPS server or
5309 * printer...
5310 */
5311
5312 ippDelete(response);
5313
5314 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s: Re-sending Get-Printer-Attributes request using IPP/1.1...", printer->name);
5315
5316 request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
5317 ippSetVersion(request, 1, 1);
5318 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, printer->device_uri);
5319 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", NULL, "all");
5320
5321 response = cupsDoRequest(http, request, resource);
5322
5323 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s: IPP/1.1 Get-Printer-Attributes returned %s (%s)", printer->name, ippErrorString(cupsLastError()), cupsLastErrorString());
5324 }
5325
5326 // TODO: Grab printer icon file...
5327 httpClose(http);
5328
5329 /*
5330 * Write the PPD for the queue...
5331 */
5332
5333 if (_ppdCreateFromIPP(fromppd, sizeof(fromppd), response))
5334 {
5335 _cupsRWLockWrite(&printer->lock);
5336
5337 if ((!printer->info || !*(printer->info)) && (attr = ippFindAttribute(response, "printer-info", IPP_TAG_TEXT)) != NULL)
5338 cupsdSetString(&printer->info, ippGetString(attr, 0, NULL));
5339
5340 if ((!printer->location || !*(printer->location)) && (attr = ippFindAttribute(response, "printer-location", IPP_TAG_TEXT)) != NULL)
5341 cupsdSetString(&printer->location, ippGetString(attr, 0, NULL));
5342
5343 if ((!printer->geo_location || !*(printer->geo_location)) && (attr = ippFindAttribute(response, "printer-geo-location", IPP_TAG_URI)) != NULL)
5344 cupsdSetString(&printer->geo_location, ippGetString(attr, 0, NULL));
5345
5346 _cupsRWUnlock(&printer->lock);
5347
5348 if ((from = cupsFileOpen(fromppd, "r")) == NULL)
5349 {
5350 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: Unable to read generated PPD: %s", printer->name, strerror(errno));
5351 return (NULL);
5352 }
5353
5354 snprintf(toppd, sizeof(toppd), "%s/ppd/%s.ppd", ServerRoot, printer->name);
5355 if ((to = cupsdCreateConfFile(toppd, ConfigFilePerm)) == NULL)
5356 {
5357 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: Unable to create PPD for printer: %s", printer->name, strerror(errno));
5358 cupsFileClose(from);
5359 return (NULL);
5360 }
5361
5362 while (cupsFileGets(from, line, sizeof(line)))
5363 cupsFilePrintf(to, "%s\n", line);
5364
5365 cupsFileClose(from);
5366 if (!cupsdCloseCreatedConfFile(to, toppd))
5367 {
5368 printer->config_time = time(NULL);
5369 printer->state = IPP_PSTATE_IDLE;
5370 printer->accepting = 1;
5371
5372 cupsdSetPrinterAttrs(printer);
5373
5374 cupsdAddEvent(CUPSD_EVENT_PRINTER_CONFIG, printer, NULL, "Printer \"%s\" is now available.", printer->name);
5375 cupsdLogMessage(CUPSD_LOG_INFO, "Printer \"%s\" is now available.", printer->name);
5376 }
5377 }
5378 else
5379 cupsdLogMessage(CUPSD_LOG_ERROR, "%s: PPD creation failed: %s", printer->name, cupsLastErrorString());
5380
5381 return (NULL);
5382 }
5383
5384
5385 /*
5386 * 'create_local_printer()' - Create a local (temporary) print queue.
5387 */
5388
5389 static void
5390 create_local_printer(
5391 cupsd_client_t *con) /* I - Client connection */
5392 {
5393 ipp_attribute_t *device_uri, /* device-uri attribute */
5394 *printer_geo_location, /* printer-geo-location attribute */
5395 *printer_info, /* printer-info attribute */
5396 *printer_location, /* printer-location attribute */
5397 *printer_name; /* printer-name attribute */
5398 cupsd_printer_t *printer; /* New printer */
5399 http_status_t status; /* Policy status */
5400 char name[128], /* Sanitized printer name */
5401 *nameptr, /* Pointer into name */
5402 uri[1024]; /* printer-uri-supported value */
5403 const char *ptr; /* Pointer into attribute value */
5404
5405
5406 /*
5407 * Require local access to create a local printer...
5408 */
5409
5410 if (!httpAddrLocalhost(httpGetAddress(con->http)))
5411 {
5412 send_ipp_status(con, IPP_STATUS_ERROR_FORBIDDEN, _("Only local users can create a local printer."));
5413 return;
5414 }
5415
5416 /*
5417 * Check any other policy limits...
5418 */
5419
5420 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
5421 {
5422 send_http_error(con, status, NULL);
5423 return;
5424 }
5425
5426 /*
5427 * Grab needed attributes...
5428 */
5429
5430 if ((printer_name = ippFindAttribute(con->request, "printer-name", IPP_TAG_ZERO)) == NULL || ippGetGroupTag(printer_name) != IPP_TAG_PRINTER || ippGetValueTag(printer_name) != IPP_TAG_NAME)
5431 {
5432 if (!printer_name)
5433 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Missing required attribute \"%s\"."), "printer-name");
5434 else if (ippGetGroupTag(printer_name) != IPP_TAG_PRINTER)
5435 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Attribute \"%s\" is in the wrong group."), "printer-name");
5436 else
5437 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Attribute \"%s\" is the wrong value type."), "printer-name");
5438
5439 return;
5440 }
5441
5442 for (nameptr = name, ptr = ippGetString(printer_name, 0, NULL); *ptr && nameptr < (name + sizeof(name) - 1); ptr ++)
5443 {
5444 /*
5445 * Sanitize the printer name...
5446 */
5447
5448 if (_cups_isalnum(*ptr))
5449 *nameptr++ = *ptr;
5450 else if (nameptr == name || nameptr[-1] != '_')
5451 *nameptr++ = '_';
5452 }
5453
5454 *nameptr = '\0';
5455
5456 if ((device_uri = ippFindAttribute(con->request, "device-uri", IPP_TAG_ZERO)) == NULL || ippGetGroupTag(device_uri) != IPP_TAG_PRINTER || ippGetValueTag(device_uri) != IPP_TAG_URI)
5457 {
5458 if (!device_uri)
5459 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Missing required attribute \"%s\"."), "device-uri");
5460 else if (ippGetGroupTag(device_uri) != IPP_TAG_PRINTER)
5461 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Attribute \"%s\" is in the wrong group."), "device-uri");
5462 else
5463 send_ipp_status(con, IPP_STATUS_ERROR_BAD_REQUEST, _("Attribute \"%s\" is the wrong value type."), "device-uri");
5464
5465 return;
5466 }
5467
5468 printer_geo_location = ippFindAttribute(con->request, "printer-geo-location", IPP_TAG_URI);
5469 printer_info = ippFindAttribute(con->request, "printer-info", IPP_TAG_TEXT);
5470 printer_location = ippFindAttribute(con->request, "printer-location", IPP_TAG_TEXT);
5471
5472 /*
5473 * See if the printer already exists...
5474 */
5475
5476 if ((printer = cupsdFindDest(name)) != NULL)
5477 {
5478 send_ipp_status(con, IPP_STATUS_ERROR_NOT_POSSIBLE, _("Printer \"%s\" already exists."), name);
5479 goto add_printer_attributes;
5480 }
5481
5482 /*
5483 * Create the printer...
5484 */
5485
5486 if ((printer = cupsdAddPrinter(name)) == NULL)
5487 {
5488 send_ipp_status(con, IPP_STATUS_ERROR_INTERNAL, _("Unable to create printer."));
5489 return;
5490 }
5491
5492 printer->shared = 0;
5493 printer->temporary = 1;
5494
5495 cupsdSetDeviceURI(printer, ippGetString(device_uri, 0, NULL));
5496
5497 if (printer_geo_location)
5498 cupsdSetString(&printer->geo_location, ippGetString(printer_geo_location, 0, NULL));
5499 if (printer_info)
5500 cupsdSetString(&printer->info, ippGetString(printer_info, 0, NULL));
5501 if (printer_location)
5502 cupsdSetString(&printer->location, ippGetString(printer_location, 0, NULL));
5503
5504 cupsdSetPrinterAttrs(printer);
5505
5506 /*
5507 * Run a background thread to create the PPD...
5508 */
5509
5510 _cupsThreadCreate((_cups_thread_func_t)create_local_bg_thread, printer);
5511
5512 /*
5513 * Return printer attributes...
5514 */
5515
5516 send_ipp_status(con, IPP_STATUS_OK, _("Local printer created."));
5517
5518 add_printer_attributes:
5519
5520 ippAddBoolean(con->response, IPP_TAG_PRINTER, "printer-is-accepting-jobs", (char)printer->accepting);
5521 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state", printer->state);
5522 add_printer_state_reasons(con, printer);
5523
5524 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), httpIsEncrypted(con->http) ? "ipps" : "ipp", NULL, con->clientname, con->clientport, "/printers/%s", printer->name);
5525 ippAddString(con->response, IPP_TAG_PRINTER, IPP_TAG_URI, "printer-uri-supported", NULL, uri);
5526 }
5527
5528
5529 /*
5530 * 'create_requested_array()' - Create an array for the requested-attributes.
5531 */
5532
5533 static cups_array_t * /* O - Array of attributes or NULL */
5534 create_requested_array(ipp_t *request) /* I - IPP request */
5535 {
5536 cups_array_t *ra; /* Requested attributes array */
5537
5538
5539 /*
5540 * Create the array for standard attributes...
5541 */
5542
5543 ra = ippCreateRequestedArray(request);
5544
5545 /*
5546 * Add CUPS defaults as needed...
5547 */
5548
5549 if (cupsArrayFind(ra, "printer-defaults"))
5550 {
5551 /*
5552 * Include user-set defaults...
5553 */
5554
5555 char *name; /* Option name */
5556
5557 cupsArrayRemove(ra, "printer-defaults");
5558
5559 for (name = (char *)cupsArrayFirst(CommonDefaults);
5560 name;
5561 name = (char *)cupsArrayNext(CommonDefaults))
5562 if (!cupsArrayFind(ra, name))
5563 cupsArrayAdd(ra, name);
5564 }
5565
5566 return (ra);
5567 }
5568
5569
5570 /*
5571 * 'create_subscriptions()' - Create one or more notification subscriptions.
5572 */
5573
5574 static void
5575 create_subscriptions(
5576 cupsd_client_t *con, /* I - Client connection */
5577 ipp_attribute_t *uri) /* I - Printer URI */
5578 {
5579 http_status_t status; /* Policy status */
5580 int i; /* Looping var */
5581 ipp_attribute_t *attr; /* Current attribute */
5582 cups_ptype_t dtype; /* Destination type (printer/class) */
5583 char scheme[HTTP_MAX_URI],
5584 /* Scheme portion of URI */
5585 userpass[HTTP_MAX_URI],
5586 /* Username portion of URI */
5587 host[HTTP_MAX_URI],
5588 /* Host portion of URI */
5589 resource[HTTP_MAX_URI];
5590 /* Resource portion of URI */
5591 int port; /* Port portion of URI */
5592 cupsd_printer_t *printer; /* Printer/class */
5593 cupsd_job_t *job; /* Job */
5594 int jobid; /* Job ID */
5595 cupsd_subscription_t *sub; /* Subscription object */
5596 const char *username, /* requesting-user-name or
5597 authenticated username */
5598 *recipient, /* notify-recipient-uri */
5599 *pullmethod; /* notify-pull-method */
5600 ipp_attribute_t *user_data; /* notify-user-data */
5601 int interval, /* notify-time-interval */
5602 lease; /* notify-lease-duration */
5603 unsigned mask; /* notify-events */
5604 ipp_attribute_t *notify_events,/* notify-events(-default) */
5605 *notify_lease; /* notify-lease-duration(-default) */
5606
5607
5608 #ifdef DEBUG
5609 for (attr = con->request->attrs; attr; attr = attr->next)
5610 {
5611 if (attr->group_tag != IPP_TAG_ZERO)
5612 cupsdLogMessage(CUPSD_LOG_DEBUG2, "g%04x v%04x %s", attr->group_tag,
5613 attr->value_tag, attr->name);
5614 else
5615 cupsdLogMessage(CUPSD_LOG_DEBUG2, "----SEP----");
5616 }
5617 #endif /* DEBUG */
5618
5619 /*
5620 * Is the destination valid?
5621 */
5622
5623 cupsdLogMessage(CUPSD_LOG_DEBUG, "create_subscriptions(con=%p(%d), uri=\"%s\")", con, con->number, uri->values[0].string.text);
5624
5625 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
5626 sizeof(scheme), userpass, sizeof(userpass), host,
5627 sizeof(host), &port, resource, sizeof(resource));
5628
5629 if (!strcmp(resource, "/"))
5630 {
5631 dtype = (cups_ptype_t)0;
5632 printer = NULL;
5633 }
5634 else if (!strncmp(resource, "/printers", 9) && strlen(resource) <= 10)
5635 {
5636 dtype = (cups_ptype_t)0;
5637 printer = NULL;
5638 }
5639 else if (!strncmp(resource, "/classes", 8) && strlen(resource) <= 9)
5640 {
5641 dtype = CUPS_PRINTER_CLASS;
5642 printer = NULL;
5643 }
5644 else if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
5645 {
5646 /*
5647 * Bad URI...
5648 */
5649
5650 send_ipp_status(con, IPP_NOT_FOUND,
5651 _("The printer or class does not exist."));
5652 return;
5653 }
5654
5655 /*
5656 * Check policy...
5657 */
5658
5659 if (printer)
5660 {
5661 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con,
5662 NULL)) != HTTP_OK)
5663 {
5664 send_http_error(con, status, printer);
5665 return;
5666 }
5667 }
5668 else if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
5669 {
5670 send_http_error(con, status, NULL);
5671 return;
5672 }
5673
5674 /*
5675 * Get the user that is requesting the subscription...
5676 */
5677
5678 username = get_username(con);
5679
5680 /*
5681 * Find the first subscription group attribute; return if we have
5682 * none...
5683 */
5684
5685 for (attr = con->request->attrs; attr; attr = attr->next)
5686 if (attr->group_tag == IPP_TAG_SUBSCRIPTION)
5687 break;
5688
5689 if (!attr)
5690 {
5691 send_ipp_status(con, IPP_BAD_REQUEST,
5692 _("No subscription attributes in request."));
5693 return;
5694 }
5695
5696 /*
5697 * Process the subscription attributes in the request...
5698 */
5699
5700 con->response->request.status.status_code = IPP_BAD_REQUEST;
5701
5702 while (attr)
5703 {
5704 recipient = NULL;
5705 pullmethod = NULL;
5706 user_data = NULL;
5707 interval = 0;
5708 lease = DefaultLeaseDuration;
5709 jobid = 0;
5710 mask = CUPSD_EVENT_NONE;
5711
5712 if (printer)
5713 {
5714 notify_events = ippFindAttribute(printer->attrs, "notify-events-default",
5715 IPP_TAG_KEYWORD);
5716 notify_lease = ippFindAttribute(printer->attrs,
5717 "notify-lease-duration-default",
5718 IPP_TAG_INTEGER);
5719
5720 if (notify_lease)
5721 lease = notify_lease->values[0].integer;
5722 }
5723 else
5724 {
5725 notify_events = NULL;
5726 notify_lease = NULL;
5727 }
5728
5729 while (attr && attr->group_tag != IPP_TAG_ZERO)
5730 {
5731 if (!strcmp(attr->name, "notify-recipient-uri") &&
5732 attr->value_tag == IPP_TAG_URI)
5733 {
5734 /*
5735 * Validate the recipient scheme against the ServerBin/notifier
5736 * directory...
5737 */
5738
5739 char notifier[1024]; /* Notifier filename */
5740
5741
5742 recipient = attr->values[0].string.text;
5743
5744 if (httpSeparateURI(HTTP_URI_CODING_ALL, recipient,
5745 scheme, sizeof(scheme), userpass, sizeof(userpass),
5746 host, sizeof(host), &port,
5747 resource, sizeof(resource)) < HTTP_URI_OK)
5748 {
5749 send_ipp_status(con, IPP_NOT_POSSIBLE,
5750 _("Bad notify-recipient-uri \"%s\"."), recipient);
5751 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
5752 "notify-status-code", IPP_URI_SCHEME);
5753 return;
5754 }
5755
5756 snprintf(notifier, sizeof(notifier), "%s/notifier/%s", ServerBin,
5757 scheme);
5758 if (access(notifier, X_OK) || !strcmp(scheme, ".") || !strcmp(scheme, ".."))
5759 {
5760 send_ipp_status(con, IPP_NOT_POSSIBLE,
5761 _("notify-recipient-uri URI \"%s\" uses unknown "
5762 "scheme."), recipient);
5763 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
5764 "notify-status-code", IPP_URI_SCHEME);
5765 return;
5766 }
5767
5768 if (!strcmp(scheme, "rss") && !check_rss_recipient(recipient))
5769 {
5770 send_ipp_status(con, IPP_NOT_POSSIBLE,
5771 _("notify-recipient-uri URI \"%s\" is already used."),
5772 recipient);
5773 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
5774 "notify-status-code", IPP_ATTRIBUTES);
5775 return;
5776 }
5777 }
5778 else if (!strcmp(attr->name, "notify-pull-method") &&
5779 attr->value_tag == IPP_TAG_KEYWORD)
5780 {
5781 pullmethod = attr->values[0].string.text;
5782
5783 if (strcmp(pullmethod, "ippget"))
5784 {
5785 send_ipp_status(con, IPP_NOT_POSSIBLE,
5786 _("Bad notify-pull-method \"%s\"."), pullmethod);
5787 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM,
5788 "notify-status-code", IPP_ATTRIBUTES);
5789 return;
5790 }
5791 }
5792 else if (!strcmp(attr->name, "notify-charset") &&
5793 attr->value_tag == IPP_TAG_CHARSET &&
5794 strcmp(attr->values[0].string.text, "us-ascii") &&
5795 strcmp(attr->values[0].string.text, "utf-8"))
5796 {
5797 send_ipp_status(con, IPP_CHARSET,
5798 _("Character set \"%s\" not supported."),
5799 attr->values[0].string.text);
5800 return;
5801 }
5802 else if (!strcmp(attr->name, "notify-natural-language") &&
5803 (attr->value_tag != IPP_TAG_LANGUAGE ||
5804 strcmp(attr->values[0].string.text, DefaultLanguage)))
5805 {
5806 send_ipp_status(con, IPP_CHARSET,
5807 _("Language \"%s\" not supported."),
5808 attr->values[0].string.text);
5809 return;
5810 }
5811 else if (!strcmp(attr->name, "notify-user-data") &&
5812 attr->value_tag == IPP_TAG_STRING)
5813 {
5814 if (attr->num_values > 1 || attr->values[0].unknown.length > 63)
5815 {
5816 send_ipp_status(con, IPP_REQUEST_VALUE,
5817 _("The notify-user-data value is too large "
5818 "(%d > 63 octets)."),
5819 attr->values[0].unknown.length);
5820 return;
5821 }
5822
5823 user_data = attr;
5824 }
5825 else if (!strcmp(attr->name, "notify-events") &&
5826 attr->value_tag == IPP_TAG_KEYWORD)
5827 notify_events = attr;
5828 else if (!strcmp(attr->name, "notify-lease-duration") &&
5829 attr->value_tag == IPP_TAG_INTEGER)
5830 lease = attr->values[0].integer;
5831 else if (!strcmp(attr->name, "notify-time-interval") &&
5832 attr->value_tag == IPP_TAG_INTEGER)
5833 interval = attr->values[0].integer;
5834 else if (!strcmp(attr->name, "notify-job-id") &&
5835 attr->value_tag == IPP_TAG_INTEGER)
5836 jobid = attr->values[0].integer;
5837
5838 attr = attr->next;
5839 }
5840
5841 if (notify_events)
5842 {
5843 for (i = 0; i < notify_events->num_values; i ++)
5844 mask |= cupsdEventValue(notify_events->values[i].string.text);
5845 }
5846
5847 if (recipient)
5848 {
5849 cupsdLogMessage(CUPSD_LOG_DEBUG, "recipient=\"%s\"", recipient);
5850
5851
5852 if (!strncmp(recipient, "mailto:", 7) && user_data)
5853 {
5854 char temp[64]; /* Temporary string */
5855
5856 memcpy(temp, user_data->values[0].unknown.data, (size_t)user_data->values[0].unknown.length);
5857 temp[user_data->values[0].unknown.length] = '\0';
5858
5859 if (httpSeparateURI(HTTP_URI_CODING_ALL, temp, scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_OK)
5860 {
5861 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Bad notify-user-data \"%s\"."), temp);
5862 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_ENUM, "notify-status-code", IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES);
5863 return;
5864 }
5865 }
5866 }
5867
5868 if (pullmethod)
5869 cupsdLogMessage(CUPSD_LOG_DEBUG, "pullmethod=\"%s\"", pullmethod);
5870 cupsdLogMessage(CUPSD_LOG_DEBUG, "notify-lease-duration=%d", lease);
5871 cupsdLogMessage(CUPSD_LOG_DEBUG, "notify-time-interval=%d", interval);
5872
5873 if (!recipient && !pullmethod)
5874 break;
5875
5876 if (mask == CUPSD_EVENT_NONE)
5877 {
5878 if (jobid)
5879 mask = CUPSD_EVENT_JOB_COMPLETED;
5880 else if (printer)
5881 mask = CUPSD_EVENT_PRINTER_STATE_CHANGED;
5882 else
5883 {
5884 send_ipp_status(con, IPP_BAD_REQUEST,
5885 _("notify-events not specified."));
5886 return;
5887 }
5888 }
5889
5890 if (MaxLeaseDuration && (lease == 0 || lease > MaxLeaseDuration))
5891 {
5892 cupsdLogMessage(CUPSD_LOG_INFO,
5893 "create_subscriptions: Limiting notify-lease-duration to "
5894 "%d seconds.",
5895 MaxLeaseDuration);
5896 lease = MaxLeaseDuration;
5897 }
5898
5899 if (jobid)
5900 {
5901 if ((job = cupsdFindJob(jobid)) == NULL)
5902 {
5903 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
5904 jobid);
5905 return;
5906 }
5907 }
5908 else
5909 job = NULL;
5910
5911 if ((sub = cupsdAddSubscription(mask, printer, job, recipient, 0)) == NULL)
5912 {
5913 send_ipp_status(con, IPP_TOO_MANY_SUBSCRIPTIONS,
5914 _("There are too many subscriptions."));
5915 return;
5916 }
5917
5918 if (job)
5919 cupsdLogMessage(CUPSD_LOG_DEBUG, "Added subscription #%d for job %d.",
5920 sub->id, job->id);
5921 else if (printer)
5922 cupsdLogMessage(CUPSD_LOG_DEBUG,
5923 "Added subscription #%d for printer \"%s\".",
5924 sub->id, printer->name);
5925 else
5926 cupsdLogMessage(CUPSD_LOG_DEBUG, "Added subscription #%d for server.",
5927 sub->id);
5928
5929 sub->interval = interval;
5930 sub->lease = lease;
5931 sub->expire = lease ? time(NULL) + lease : 0;
5932
5933 cupsdSetString(&sub->owner, username);
5934
5935 if (user_data)
5936 {
5937 sub->user_data_len = user_data->values[0].unknown.length;
5938 memcpy(sub->user_data, user_data->values[0].unknown.data,
5939 (size_t)sub->user_data_len);
5940 }
5941
5942 ippAddSeparator(con->response);
5943 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
5944 "notify-subscription-id", sub->id);
5945
5946 con->response->request.status.status_code = IPP_OK;
5947
5948 if (attr)
5949 attr = attr->next;
5950 }
5951
5952 cupsdMarkDirty(CUPSD_DIRTY_SUBSCRIPTIONS);
5953 }
5954
5955
5956 /*
5957 * 'delete_printer()' - Remove a printer or class from the system.
5958 */
5959
5960 static void
5961 delete_printer(cupsd_client_t *con, /* I - Client connection */
5962 ipp_attribute_t *uri) /* I - URI of printer or class */
5963 {
5964 http_status_t status; /* Policy status */
5965 cups_ptype_t dtype; /* Destination type (printer/class) */
5966 cupsd_printer_t *printer; /* Printer/class */
5967 char filename[1024]; /* Script/PPD filename */
5968 int temporary; /* Temporary queue? */
5969
5970
5971 cupsdLogMessage(CUPSD_LOG_DEBUG2, "delete_printer(%p[%d], %s)", con,
5972 con->number, uri->values[0].string.text);
5973
5974 /*
5975 * Do we have a valid URI?
5976 */
5977
5978 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
5979 {
5980 /*
5981 * Bad URI...
5982 */
5983
5984 send_ipp_status(con, IPP_NOT_FOUND,
5985 _("The printer or class does not exist."));
5986 return;
5987 }
5988
5989 /*
5990 * Check policy...
5991 */
5992
5993 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
5994 {
5995 send_http_error(con, status, NULL);
5996 return;
5997 }
5998
5999 /*
6000 * Remove old jobs...
6001 */
6002
6003 cupsdCancelJobs(printer->name, NULL, 1);
6004
6005 /*
6006 * Remove old subscriptions and send a "deleted printer" event...
6007 */
6008
6009 cupsdAddEvent(CUPSD_EVENT_PRINTER_DELETED, printer, NULL,
6010 "%s \"%s\" deleted by \"%s\".",
6011 (dtype & CUPS_PRINTER_CLASS) ? "Class" : "Printer",
6012 printer->name, get_username(con));
6013
6014 cupsdExpireSubscriptions(printer, NULL);
6015
6016 /*
6017 * Remove any old PPD or script files...
6018 */
6019
6020 snprintf(filename, sizeof(filename), "%s/ppd/%s.ppd", ServerRoot,
6021 printer->name);
6022 unlink(filename);
6023 snprintf(filename, sizeof(filename), "%s/ppd/%s.ppd.O", ServerRoot,
6024 printer->name);
6025 unlink(filename);
6026
6027 snprintf(filename, sizeof(filename), "%s/%s.png", CacheDir, printer->name);
6028 unlink(filename);
6029
6030 snprintf(filename, sizeof(filename), "%s/%s.data", CacheDir, printer->name);
6031 unlink(filename);
6032
6033 /*
6034 * Unregister color profiles...
6035 */
6036
6037 cupsdUnregisterColor(printer);
6038
6039 temporary = printer->temporary;
6040
6041 if (dtype & CUPS_PRINTER_CLASS)
6042 {
6043 cupsdLogMessage(CUPSD_LOG_INFO, "Class \"%s\" deleted by \"%s\".",
6044 printer->name, get_username(con));
6045
6046 cupsdDeletePrinter(printer, 0);
6047 if (!temporary)
6048 cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
6049 }
6050 else
6051 {
6052 cupsdLogMessage(CUPSD_LOG_INFO, "Printer \"%s\" deleted by \"%s\".",
6053 printer->name, get_username(con));
6054
6055 if (cupsdDeletePrinter(printer, 0) && !temporary)
6056 cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
6057
6058 if (!temporary)
6059 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
6060 }
6061
6062 if (!temporary)
6063 cupsdMarkDirty(CUPSD_DIRTY_PRINTCAP);
6064
6065 /*
6066 * Return with no errors...
6067 */
6068
6069 con->response->request.status.status_code = IPP_OK;
6070 }
6071
6072
6073 /*
6074 * 'get_default()' - Get the default destination.
6075 */
6076
6077 static void
6078 get_default(cupsd_client_t *con) /* I - Client connection */
6079 {
6080 http_status_t status; /* Policy status */
6081 cups_array_t *ra; /* Requested attributes array */
6082
6083
6084 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_default(%p[%d])", con, con->number);
6085
6086 /*
6087 * Check policy...
6088 */
6089
6090 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
6091 {
6092 send_http_error(con, status, NULL);
6093 return;
6094 }
6095
6096 if (DefaultPrinter)
6097 {
6098 ra = create_requested_array(con->request);
6099
6100 copy_printer_attrs(con, DefaultPrinter, ra);
6101
6102 cupsArrayDelete(ra);
6103
6104 con->response->request.status.status_code = IPP_OK;
6105 }
6106 else
6107 send_ipp_status(con, IPP_NOT_FOUND, _("No default printer."));
6108 }
6109
6110
6111 /*
6112 * 'get_devices()' - Get the list of available devices on the local system.
6113 */
6114
6115 static void
6116 get_devices(cupsd_client_t *con) /* I - Client connection */
6117 {
6118 http_status_t status; /* Policy status */
6119 ipp_attribute_t *limit, /* limit attribute */
6120 *timeout, /* timeout attribute */
6121 *requested, /* requested-attributes attribute */
6122 *exclude, /* exclude-schemes attribute */
6123 *include; /* include-schemes attribute */
6124 char command[1024], /* cups-deviced command */
6125 options[2048], /* Options to pass to command */
6126 requested_str[256],
6127 /* String for requested attributes */
6128 exclude_str[512],
6129 /* String for excluded schemes */
6130 include_str[512];
6131 /* String for included schemes */
6132
6133
6134 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_devices(%p[%d])", con, con->number);
6135
6136 /*
6137 * Check policy...
6138 */
6139
6140 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
6141 {
6142 send_http_error(con, status, NULL);
6143 return;
6144 }
6145
6146 /*
6147 * Run cups-deviced command with the given options...
6148 */
6149
6150 limit = ippFindAttribute(con->request, "limit", IPP_TAG_INTEGER);
6151 timeout = ippFindAttribute(con->request, "timeout", IPP_TAG_INTEGER);
6152 requested = ippFindAttribute(con->request, "requested-attributes",
6153 IPP_TAG_KEYWORD);
6154 exclude = ippFindAttribute(con->request, "exclude-schemes", IPP_TAG_NAME);
6155 include = ippFindAttribute(con->request, "include-schemes", IPP_TAG_NAME);
6156
6157 if (requested)
6158 url_encode_attr(requested, requested_str, sizeof(requested_str));
6159 else
6160 strlcpy(requested_str, "requested-attributes=all", sizeof(requested_str));
6161
6162 if (exclude)
6163 url_encode_attr(exclude, exclude_str, sizeof(exclude_str));
6164 else
6165 exclude_str[0] = '\0';
6166
6167 if (include)
6168 url_encode_attr(include, include_str, sizeof(include_str));
6169 else
6170 include_str[0] = '\0';
6171
6172 snprintf(command, sizeof(command), "%s/daemon/cups-deviced", ServerBin);
6173 snprintf(options, sizeof(options),
6174 "%d+%d+%d+%d+%s%s%s%s%s",
6175 con->request->request.op.request_id,
6176 limit ? limit->values[0].integer : 0,
6177 timeout ? timeout->values[0].integer : 15,
6178 (int)User,
6179 requested_str,
6180 exclude_str[0] ? "%20" : "", exclude_str,
6181 include_str[0] ? "%20" : "", include_str);
6182
6183 if (cupsdSendCommand(con, command, options, 1))
6184 {
6185 /*
6186 * Command started successfully, don't send an IPP response here...
6187 */
6188
6189 ippDelete(con->response);
6190 con->response = NULL;
6191 }
6192 else
6193 {
6194 /*
6195 * Command failed, return "internal error" so the user knows something
6196 * went wrong...
6197 */
6198
6199 send_ipp_status(con, IPP_INTERNAL_ERROR,
6200 _("cups-deviced failed to execute."));
6201 }
6202 }
6203
6204
6205 /*
6206 * 'get_document()' - Get a copy of a job file.
6207 */
6208
6209 static void
6210 get_document(cupsd_client_t *con, /* I - Client connection */
6211 ipp_attribute_t *uri) /* I - Job URI */
6212 {
6213 http_status_t status; /* Policy status */
6214 ipp_attribute_t *attr; /* Current attribute */
6215 int jobid; /* Job ID */
6216 int docnum; /* Document number */
6217 cupsd_job_t *job; /* Current job */
6218 char scheme[HTTP_MAX_URI], /* Method portion of URI */
6219 username[HTTP_MAX_URI], /* Username portion of URI */
6220 host[HTTP_MAX_URI], /* Host portion of URI */
6221 resource[HTTP_MAX_URI]; /* Resource portion of URI */
6222 int port; /* Port portion of URI */
6223 char filename[1024], /* Filename for document */
6224 format[1024]; /* Format for document */
6225
6226
6227 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_document(%p[%d], %s)", con,
6228 con->number, uri->values[0].string.text);
6229
6230 /*
6231 * See if we have a job URI or a printer URI...
6232 */
6233
6234 if (!strcmp(uri->name, "printer-uri"))
6235 {
6236 /*
6237 * Got a printer URI; see if we also have a job-id attribute...
6238 */
6239
6240 if ((attr = ippFindAttribute(con->request, "job-id",
6241 IPP_TAG_INTEGER)) == NULL)
6242 {
6243 send_ipp_status(con, IPP_BAD_REQUEST,
6244 _("Got a printer-uri attribute but no job-id."));
6245 return;
6246 }
6247
6248 jobid = attr->values[0].integer;
6249 }
6250 else
6251 {
6252 /*
6253 * Got a job URI; parse it to get the job ID...
6254 */
6255
6256 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
6257 sizeof(scheme), username, sizeof(username), host,
6258 sizeof(host), &port, resource, sizeof(resource));
6259
6260 if (strncmp(resource, "/jobs/", 6))
6261 {
6262 /*
6263 * Not a valid URI!
6264 */
6265
6266 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
6267 uri->values[0].string.text);
6268 return;
6269 }
6270
6271 jobid = atoi(resource + 6);
6272 }
6273
6274 /*
6275 * See if the job exists...
6276 */
6277
6278 if ((job = cupsdFindJob(jobid)) == NULL)
6279 {
6280 /*
6281 * Nope - return a "not found" error...
6282 */
6283
6284 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
6285 return;
6286 }
6287
6288 /*
6289 * Check policy...
6290 */
6291
6292 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con,
6293 job->username)) != HTTP_OK)
6294 {
6295 send_http_error(con, status, NULL);
6296 return;
6297 }
6298
6299 /*
6300 * Get the document number...
6301 */
6302
6303 if ((attr = ippFindAttribute(con->request, "document-number",
6304 IPP_TAG_INTEGER)) == NULL)
6305 {
6306 send_ipp_status(con, IPP_BAD_REQUEST,
6307 _("Missing document-number attribute."));
6308 return;
6309 }
6310
6311 if ((docnum = attr->values[0].integer) < 1 || docnum > job->num_files ||
6312 attr->num_values > 1)
6313 {
6314 send_ipp_status(con, IPP_NOT_FOUND,
6315 _("Document #%d does not exist in job #%d."), docnum,
6316 jobid);
6317 return;
6318 }
6319
6320 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot, jobid,
6321 docnum);
6322 if ((con->file = open(filename, O_RDONLY)) == -1)
6323 {
6324 cupsdLogMessage(CUPSD_LOG_ERROR,
6325 "Unable to open document %d in job %d - %s", docnum, jobid,
6326 strerror(errno));
6327 send_ipp_status(con, IPP_NOT_FOUND,
6328 _("Unable to open document #%d in job #%d."), docnum,
6329 jobid);
6330 return;
6331 }
6332
6333 fcntl(con->file, F_SETFD, fcntl(con->file, F_GETFD) | FD_CLOEXEC);
6334
6335 cupsdLoadJob(job);
6336
6337 snprintf(format, sizeof(format), "%s/%s", job->filetypes[docnum - 1]->super,
6338 job->filetypes[docnum - 1]->type);
6339
6340 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
6341 NULL, format);
6342 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "document-number",
6343 docnum);
6344 if ((attr = ippFindAttribute(job->attrs, "document-name",
6345 IPP_TAG_NAME)) != NULL)
6346 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_NAME, "document-name",
6347 NULL, attr->values[0].string.text);
6348 }
6349
6350
6351 /*
6352 * 'get_job_attrs()' - Get job attributes.
6353 */
6354
6355 static void
6356 get_job_attrs(cupsd_client_t *con, /* I - Client connection */
6357 ipp_attribute_t *uri) /* I - Job URI */
6358 {
6359 http_status_t status; /* Policy status */
6360 ipp_attribute_t *attr; /* Current attribute */
6361 int jobid; /* Job ID */
6362 cupsd_job_t *job; /* Current job */
6363 cupsd_printer_t *printer; /* Current printer */
6364 cupsd_policy_t *policy; /* Current security policy */
6365 char scheme[HTTP_MAX_URI], /* Scheme portion of URI */
6366 username[HTTP_MAX_URI], /* Username portion of URI */
6367 host[HTTP_MAX_URI], /* Host portion of URI */
6368 resource[HTTP_MAX_URI]; /* Resource portion of URI */
6369 int port; /* Port portion of URI */
6370 cups_array_t *ra, /* Requested attributes array */
6371 *exclude; /* Private attributes array */
6372
6373
6374 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_job_attrs(%p[%d], %s)", con,
6375 con->number, uri->values[0].string.text);
6376
6377 /*
6378 * See if we have a job URI or a printer URI...
6379 */
6380
6381 if (!strcmp(uri->name, "printer-uri"))
6382 {
6383 /*
6384 * Got a printer URI; see if we also have a job-id attribute...
6385 */
6386
6387 if ((attr = ippFindAttribute(con->request, "job-id",
6388 IPP_TAG_INTEGER)) == NULL)
6389 {
6390 send_ipp_status(con, IPP_BAD_REQUEST,
6391 _("Got a printer-uri attribute but no job-id."));
6392 return;
6393 }
6394
6395 jobid = attr->values[0].integer;
6396 }
6397 else
6398 {
6399 /*
6400 * Got a job URI; parse it to get the job ID...
6401 */
6402
6403 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
6404 sizeof(scheme), username, sizeof(username), host,
6405 sizeof(host), &port, resource, sizeof(resource));
6406
6407 if (strncmp(resource, "/jobs/", 6))
6408 {
6409 /*
6410 * Not a valid URI!
6411 */
6412
6413 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
6414 uri->values[0].string.text);
6415 return;
6416 }
6417
6418 jobid = atoi(resource + 6);
6419 }
6420
6421 /*
6422 * See if the job exists...
6423 */
6424
6425 if ((job = cupsdFindJob(jobid)) == NULL)
6426 {
6427 /*
6428 * Nope - return a "not found" error...
6429 */
6430
6431 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
6432 return;
6433 }
6434
6435 /*
6436 * Check policy...
6437 */
6438
6439 if ((printer = job->printer) == NULL)
6440 printer = cupsdFindDest(job->dest);
6441
6442 if (printer)
6443 policy = printer->op_policy_ptr;
6444 else
6445 policy = DefaultPolicyPtr;
6446
6447 if ((status = cupsdCheckPolicy(policy, con, job->username)) != HTTP_OK)
6448 {
6449 send_http_error(con, status, NULL);
6450 return;
6451 }
6452
6453 exclude = cupsdGetPrivateAttrs(policy, con, printer, job->username);
6454
6455 /*
6456 * Copy attributes...
6457 */
6458
6459 cupsdLoadJob(job);
6460
6461 ra = create_requested_array(con->request);
6462 copy_job_attrs(con, job, ra, exclude);
6463 cupsArrayDelete(ra);
6464
6465 con->response->request.status.status_code = IPP_OK;
6466 }
6467
6468
6469 /*
6470 * 'get_jobs()' - Get a list of jobs for the specified printer.
6471 */
6472
6473 static void
6474 get_jobs(cupsd_client_t *con, /* I - Client connection */
6475 ipp_attribute_t *uri) /* I - Printer URI */
6476 {
6477 http_status_t status; /* Policy status */
6478 ipp_attribute_t *attr; /* Current attribute */
6479 const char *dest; /* Destination */
6480 cups_ptype_t dtype; /* Destination type (printer/class) */
6481 cups_ptype_t dmask; /* Destination type mask */
6482 char scheme[HTTP_MAX_URI], /* Scheme portion of URI */
6483 username[HTTP_MAX_URI], /* Username portion of URI */
6484 host[HTTP_MAX_URI], /* Host portion of URI */
6485 resource[HTTP_MAX_URI]; /* Resource portion of URI */
6486 int port; /* Port portion of URI */
6487 int job_comparison; /* Job comparison */
6488 ipp_jstate_t job_state; /* job-state value */
6489 int first_job_id = 1, /* First job ID */
6490 first_index = 1, /* First index */
6491 limit = 0, /* Maximum number of jobs to return */
6492 count, /* Number of jobs that match */
6493 need_load_job = 0; /* Do we need to load the job? */
6494 const char *job_attr; /* Job attribute requested */
6495 ipp_attribute_t *job_ids; /* job-ids attribute */
6496 cupsd_job_t *job; /* Current job pointer */
6497 cupsd_printer_t *printer; /* Printer */
6498 cups_array_t *list; /* Which job list... */
6499 int delete_list = 0; /* Delete the list afterwards? */
6500 cups_array_t *ra, /* Requested attributes array */
6501 *exclude; /* Private attributes array */
6502 cupsd_policy_t *policy; /* Current policy */
6503
6504
6505 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_jobs(%p[%d], %s)", con, con->number,
6506 uri->values[0].string.text);
6507
6508 /*
6509 * Is the destination valid?
6510 */
6511
6512 if (strcmp(uri->name, "printer-uri"))
6513 {
6514 send_ipp_status(con, IPP_BAD_REQUEST, _("No printer-uri in request."));
6515 return;
6516 }
6517
6518 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
6519 sizeof(scheme), username, sizeof(username), host,
6520 sizeof(host), &port, resource, sizeof(resource));
6521
6522 if (!strcmp(resource, "/") || !strcmp(resource, "/jobs"))
6523 {
6524 dest = NULL;
6525 dtype = (cups_ptype_t)0;
6526 dmask = (cups_ptype_t)0;
6527 printer = NULL;
6528 }
6529 else if (!strncmp(resource, "/printers", 9) && strlen(resource) <= 10)
6530 {
6531 dest = NULL;
6532 dtype = (cups_ptype_t)0;
6533 dmask = CUPS_PRINTER_CLASS;
6534 printer = NULL;
6535 }
6536 else if (!strncmp(resource, "/classes", 8) && strlen(resource) <= 9)
6537 {
6538 dest = NULL;
6539 dtype = CUPS_PRINTER_CLASS;
6540 dmask = CUPS_PRINTER_CLASS;
6541 printer = NULL;
6542 }
6543 else if ((dest = cupsdValidateDest(uri->values[0].string.text, &dtype,
6544 &printer)) == NULL)
6545 {
6546 /*
6547 * Bad URI...
6548 */
6549
6550 send_ipp_status(con, IPP_NOT_FOUND,
6551 _("The printer or class does not exist."));
6552 return;
6553 }
6554 else
6555 {
6556 dtype &= CUPS_PRINTER_CLASS;
6557 dmask = CUPS_PRINTER_CLASS;
6558 }
6559
6560 /*
6561 * Check policy...
6562 */
6563
6564 if (printer)
6565 policy = printer->op_policy_ptr;
6566 else
6567 policy = DefaultPolicyPtr;
6568
6569 if ((status = cupsdCheckPolicy(policy, con, NULL)) != HTTP_OK)
6570 {
6571 send_http_error(con, status, NULL);
6572 return;
6573 }
6574
6575 job_ids = ippFindAttribute(con->request, "job-ids", IPP_TAG_INTEGER);
6576
6577 /*
6578 * See if the "which-jobs" attribute have been specified...
6579 */
6580
6581 if ((attr = ippFindAttribute(con->request, "which-jobs",
6582 IPP_TAG_KEYWORD)) != NULL && job_ids)
6583 {
6584 send_ipp_status(con, IPP_CONFLICT,
6585 _("The %s attribute cannot be provided with job-ids."),
6586 "which-jobs");
6587 return;
6588 }
6589 else if (!attr || !strcmp(attr->values[0].string.text, "not-completed"))
6590 {
6591 job_comparison = -1;
6592 job_state = IPP_JOB_STOPPED;
6593 list = ActiveJobs;
6594 }
6595 else if (!strcmp(attr->values[0].string.text, "completed"))
6596 {
6597 job_comparison = 1;
6598 job_state = IPP_JOB_CANCELED;
6599 list = cupsdGetCompletedJobs(printer);
6600 delete_list = 1;
6601 }
6602 else if (!strcmp(attr->values[0].string.text, "aborted"))
6603 {
6604 job_comparison = 0;
6605 job_state = IPP_JOB_ABORTED;
6606 list = cupsdGetCompletedJobs(printer);
6607 delete_list = 1;
6608 }
6609 else if (!strcmp(attr->values[0].string.text, "all"))
6610 {
6611 job_comparison = 1;
6612 job_state = IPP_JOB_PENDING;
6613 list = Jobs;
6614 }
6615 else if (!strcmp(attr->values[0].string.text, "canceled"))
6616 {
6617 job_comparison = 0;
6618 job_state = IPP_JOB_CANCELED;
6619 list = cupsdGetCompletedJobs(printer);
6620 delete_list = 1;
6621 }
6622 else if (!strcmp(attr->values[0].string.text, "pending"))
6623 {
6624 job_comparison = 0;
6625 job_state = IPP_JOB_PENDING;
6626 list = ActiveJobs;
6627 }
6628 else if (!strcmp(attr->values[0].string.text, "pending-held"))
6629 {
6630 job_comparison = 0;
6631 job_state = IPP_JOB_HELD;
6632 list = ActiveJobs;
6633 }
6634 else if (!strcmp(attr->values[0].string.text, "processing"))
6635 {
6636 job_comparison = 0;
6637 job_state = IPP_JOB_PROCESSING;
6638 list = PrintingJobs;
6639 }
6640 else if (!strcmp(attr->values[0].string.text, "processing-stopped"))
6641 {
6642 job_comparison = 0;
6643 job_state = IPP_JOB_STOPPED;
6644 list = ActiveJobs;
6645 }
6646 else
6647 {
6648 send_ipp_status(con, IPP_ATTRIBUTES,
6649 _("The which-jobs value \"%s\" is not supported."),
6650 attr->values[0].string.text);
6651 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_KEYWORD,
6652 "which-jobs", NULL, attr->values[0].string.text);
6653 return;
6654 }
6655
6656 /*
6657 * See if they want to limit the number of jobs reported...
6658 */
6659
6660 if ((attr = ippFindAttribute(con->request, "limit", IPP_TAG_INTEGER)) != NULL)
6661 {
6662 if (job_ids)
6663 {
6664 send_ipp_status(con, IPP_CONFLICT,
6665 _("The %s attribute cannot be provided with job-ids."),
6666 "limit");
6667 return;
6668 }
6669
6670 limit = attr->values[0].integer;
6671 }
6672
6673 if ((attr = ippFindAttribute(con->request, "first-index", IPP_TAG_INTEGER)) != NULL)
6674 {
6675 if (job_ids)
6676 {
6677 send_ipp_status(con, IPP_CONFLICT,
6678 _("The %s attribute cannot be provided with job-ids."),
6679 "first-index");
6680 return;
6681 }
6682
6683 first_index = attr->values[0].integer;
6684 }
6685 else if ((attr = ippFindAttribute(con->request, "first-job-id", IPP_TAG_INTEGER)) != NULL)
6686 {
6687 if (job_ids)
6688 {
6689 send_ipp_status(con, IPP_CONFLICT,
6690 _("The %s attribute cannot be provided with job-ids."),
6691 "first-job-id");
6692 return;
6693 }
6694
6695 first_job_id = attr->values[0].integer;
6696 }
6697
6698 /*
6699 * See if we only want to see jobs for a specific user...
6700 */
6701
6702 if ((attr = ippFindAttribute(con->request, "my-jobs", IPP_TAG_BOOLEAN)) != NULL && job_ids)
6703 {
6704 send_ipp_status(con, IPP_CONFLICT,
6705 _("The %s attribute cannot be provided with job-ids."),
6706 "my-jobs");
6707 return;
6708 }
6709 else if (attr && attr->values[0].boolean)
6710 strlcpy(username, get_username(con), sizeof(username));
6711 else
6712 username[0] = '\0';
6713
6714 ra = create_requested_array(con->request);
6715 for (job_attr = (char *)cupsArrayFirst(ra); job_attr; job_attr = (char *)cupsArrayNext(ra))
6716 if (strcmp(job_attr, "job-id") &&
6717 strcmp(job_attr, "job-k-octets") &&
6718 strcmp(job_attr, "job-media-progress") &&
6719 strcmp(job_attr, "job-more-info") &&
6720 strcmp(job_attr, "job-name") &&
6721 strcmp(job_attr, "job-originating-user-name") &&
6722 strcmp(job_attr, "job-preserved") &&
6723 strcmp(job_attr, "job-printer-up-time") &&
6724 strcmp(job_attr, "job-printer-uri") &&
6725 strcmp(job_attr, "job-state") &&
6726 strcmp(job_attr, "job-state-reasons") &&
6727 strcmp(job_attr, "job-uri") &&
6728 strcmp(job_attr, "time-at-completed") &&
6729 strcmp(job_attr, "time-at-creation") &&
6730 strcmp(job_attr, "number-of-documents"))
6731 {
6732 need_load_job = 1;
6733 break;
6734 }
6735
6736 if (need_load_job && (limit == 0 || limit > 500) && (list == Jobs || delete_list))
6737 {
6738 /*
6739 * Limit expensive Get-Jobs for job history to 500 jobs...
6740 */
6741
6742 ippAddInteger(con->response, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "limit", 500);
6743
6744 if (limit)
6745 ippAddInteger(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_INTEGER, "limit", limit);
6746
6747 limit = 500;
6748
6749 cupsdLogClient(con, CUPSD_LOG_INFO, "Limiting Get-Jobs response to %d jobs.", limit);
6750 }
6751
6752 /*
6753 * OK, build a list of jobs for this printer...
6754 */
6755
6756 if (job_ids)
6757 {
6758 int i; /* Looping var */
6759
6760 for (i = 0; i < job_ids->num_values; i ++)
6761 {
6762 if (!cupsdFindJob(job_ids->values[i].integer))
6763 break;
6764 }
6765
6766 if (i < job_ids->num_values)
6767 {
6768 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
6769 job_ids->values[i].integer);
6770 return;
6771 }
6772
6773 for (i = 0; i < job_ids->num_values; i ++)
6774 {
6775 job = cupsdFindJob(job_ids->values[i].integer);
6776
6777 if (need_load_job && !job->attrs)
6778 {
6779 cupsdLoadJob(job);
6780
6781 if (!job->attrs)
6782 {
6783 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_jobs: No attributes for job %d", job->id);
6784 continue;
6785 }
6786 }
6787
6788 if (i > 0)
6789 ippAddSeparator(con->response);
6790
6791 exclude = cupsdGetPrivateAttrs(job->printer ?
6792 job->printer->op_policy_ptr :
6793 policy, con, job->printer,
6794 job->username);
6795
6796 copy_job_attrs(con, job, ra, exclude);
6797 }
6798 }
6799 else
6800 {
6801 if (first_index > 1)
6802 job = (cupsd_job_t *)cupsArrayIndex(list, first_index - 1);
6803 else
6804 job = (cupsd_job_t *)cupsArrayFirst(list);
6805
6806 for (count = 0; (limit <= 0 || count < limit) && job; job = (cupsd_job_t *)cupsArrayNext(list))
6807 {
6808 /*
6809 * Filter out jobs that don't match...
6810 */
6811
6812 cupsdLogMessage(CUPSD_LOG_DEBUG2,
6813 "get_jobs: job->id=%d, dest=\"%s\", username=\"%s\", "
6814 "state_value=%d, attrs=%p", job->id, job->dest,
6815 job->username, job->state_value, job->attrs);
6816
6817 if (!job->dest || !job->username)
6818 cupsdLoadJob(job);
6819
6820 if (!job->dest || !job->username)
6821 continue;
6822
6823 if ((dest && strcmp(job->dest, dest)) &&
6824 (!job->printer || !dest || strcmp(job->printer->name, dest)))
6825 continue;
6826 if ((job->dtype & dmask) != dtype &&
6827 (!job->printer || (job->printer->type & dmask) != dtype))
6828 continue;
6829
6830 if ((job_comparison < 0 && job->state_value > job_state) ||
6831 (job_comparison == 0 && job->state_value != job_state) ||
6832 (job_comparison > 0 && job->state_value < job_state))
6833 continue;
6834
6835 if (job->id < first_job_id)
6836 continue;
6837
6838 if (need_load_job && !job->attrs)
6839 {
6840 cupsdLoadJob(job);
6841
6842 if (!job->attrs)
6843 {
6844 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_jobs: No attributes for job %d", job->id);
6845 continue;
6846 }
6847 }
6848
6849 if (username[0] && _cups_strcasecmp(username, job->username))
6850 continue;
6851
6852 if (count > 0)
6853 ippAddSeparator(con->response);
6854
6855 count ++;
6856
6857 exclude = cupsdGetPrivateAttrs(job->printer ?
6858 job->printer->op_policy_ptr :
6859 policy, con, job->printer,
6860 job->username);
6861
6862 copy_job_attrs(con, job, ra, exclude);
6863 }
6864
6865 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_jobs: count=%d", count);
6866 }
6867
6868 cupsArrayDelete(ra);
6869
6870 if (delete_list)
6871 cupsArrayDelete(list);
6872
6873 con->response->request.status.status_code = IPP_OK;
6874 }
6875
6876
6877 /*
6878 * 'get_notifications()' - Get events for a subscription.
6879 */
6880
6881 static void
6882 get_notifications(cupsd_client_t *con) /* I - Client connection */
6883 {
6884 int i, j; /* Looping vars */
6885 http_status_t status; /* Policy status */
6886 cupsd_subscription_t *sub; /* Subscription */
6887 ipp_attribute_t *ids, /* notify-subscription-ids */
6888 *sequences; /* notify-sequence-numbers */
6889 int min_seq; /* Minimum sequence number */
6890 int interval; /* Poll interval */
6891
6892
6893 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_notifications(con=%p[%d])",
6894 con, con->number);
6895
6896 /*
6897 * Get subscription attributes...
6898 */
6899
6900 ids = ippFindAttribute(con->request, "notify-subscription-ids",
6901 IPP_TAG_INTEGER);
6902 sequences = ippFindAttribute(con->request, "notify-sequence-numbers",
6903 IPP_TAG_INTEGER);
6904
6905 if (!ids)
6906 {
6907 send_ipp_status(con, IPP_BAD_REQUEST,
6908 _("Missing notify-subscription-ids attribute."));
6909 return;
6910 }
6911
6912 /*
6913 * Are the subscription IDs valid?
6914 */
6915
6916 for (i = 0, interval = 60; i < ids->num_values; i ++)
6917 {
6918 if ((sub = cupsdFindSubscription(ids->values[i].integer)) == NULL)
6919 {
6920 /*
6921 * Bad subscription ID...
6922 */
6923
6924 send_ipp_status(con, IPP_NOT_FOUND, _("Subscription #%d does not exist."),
6925 ids->values[i].integer);
6926 return;
6927 }
6928
6929 /*
6930 * Check policy...
6931 */
6932
6933 if ((status = cupsdCheckPolicy(sub->dest ? sub->dest->op_policy_ptr :
6934 DefaultPolicyPtr,
6935 con, sub->owner)) != HTTP_OK)
6936 {
6937 send_http_error(con, status, sub->dest);
6938 return;
6939 }
6940
6941 /*
6942 * Check the subscription type and update the interval accordingly.
6943 */
6944
6945 if (sub->job && sub->job->state_value == IPP_JOB_PROCESSING &&
6946 interval > 10)
6947 interval = 10;
6948 else if (sub->job && sub->job->state_value >= IPP_JOB_STOPPED)
6949 interval = 0;
6950 else if (sub->dest && sub->dest->state == IPP_PRINTER_PROCESSING &&
6951 interval > 30)
6952 interval = 30;
6953 }
6954
6955 /*
6956 * Tell the client to poll again in N seconds...
6957 */
6958
6959 if (interval > 0)
6960 ippAddInteger(con->response, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
6961 "notify-get-interval", interval);
6962
6963 ippAddInteger(con->response, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
6964 "printer-up-time", time(NULL));
6965
6966 /*
6967 * Copy the subscription event attributes to the response.
6968 */
6969
6970 con->response->request.status.status_code =
6971 interval ? IPP_OK : IPP_OK_EVENTS_COMPLETE;
6972
6973 for (i = 0; i < ids->num_values; i ++)
6974 {
6975 /*
6976 * Get the subscription and sequence number...
6977 */
6978
6979 sub = cupsdFindSubscription(ids->values[i].integer);
6980
6981 if (sequences && i < sequences->num_values)
6982 min_seq = sequences->values[i].integer;
6983 else
6984 min_seq = 1;
6985
6986 /*
6987 * If we don't have any new events, nothing to do here...
6988 */
6989
6990 if (min_seq > (sub->first_event_id + cupsArrayCount(sub->events)))
6991 continue;
6992
6993 /*
6994 * Otherwise copy all of the new events...
6995 */
6996
6997 if (sub->first_event_id > min_seq)
6998 j = 0;
6999 else
7000 j = min_seq - sub->first_event_id;
7001
7002 for (; j < cupsArrayCount(sub->events); j ++)
7003 {
7004 ippAddSeparator(con->response);
7005
7006 copy_attrs(con->response,
7007 ((cupsd_event_t *)cupsArrayIndex(sub->events, j))->attrs, NULL,
7008 IPP_TAG_EVENT_NOTIFICATION, 0, NULL);
7009 }
7010 }
7011 }
7012
7013
7014 /*
7015 * 'get_ppd()' - Get a named PPD from the local system.
7016 */
7017
7018 static void
7019 get_ppd(cupsd_client_t *con, /* I - Client connection */
7020 ipp_attribute_t *uri) /* I - Printer URI or PPD name */
7021 {
7022 http_status_t status; /* Policy status */
7023 cupsd_printer_t *dest; /* Destination */
7024 cups_ptype_t dtype; /* Destination type */
7025
7026
7027 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_ppd(%p[%d], %p[%s=%s])", con,
7028 con->number, uri, uri->name, uri->values[0].string.text);
7029
7030 if (!strcmp(ippGetName(uri), "ppd-name"))
7031 {
7032 /*
7033 * Return a PPD file from cups-driverd...
7034 */
7035
7036 const char *ppd_name = ippGetString(uri, 0, NULL);
7037 /* ppd-name value */
7038 char command[1024], /* cups-driverd command */
7039 options[1024], /* Options to pass to command */
7040 oppd_name[1024]; /* Escaped ppd-name */
7041
7042 /*
7043 * Check policy...
7044 */
7045
7046 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
7047 {
7048 send_http_error(con, status, NULL);
7049 return;
7050 }
7051
7052 /*
7053 * Check ppd-name value...
7054 */
7055
7056 if (strstr(ppd_name, "../"))
7057 {
7058 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Invalid ppd-name value."));
7059 return;
7060 }
7061
7062 /*
7063 * Run cups-driverd command with the given options...
7064 */
7065
7066 snprintf(command, sizeof(command), "%s/daemon/cups-driverd", ServerBin);
7067 url_encode_string(ppd_name, oppd_name, sizeof(oppd_name));
7068 snprintf(options, sizeof(options), "get+%d+%s", ippGetRequestId(con->request), oppd_name);
7069
7070 if (cupsdSendCommand(con, command, options, 0))
7071 {
7072 /*
7073 * Command started successfully, don't send an IPP response here...
7074 */
7075
7076 ippDelete(con->response);
7077 con->response = NULL;
7078 }
7079 else
7080 {
7081 /*
7082 * Command failed, return "internal error" so the user knows something
7083 * went wrong...
7084 */
7085
7086 send_ipp_status(con, IPP_INTERNAL_ERROR, _("cups-driverd failed to execute."));
7087 }
7088 }
7089 else if (!strcmp(ippGetName(uri), "printer-uri") && cupsdValidateDest(ippGetString(uri, 0, NULL), &dtype, &dest))
7090 {
7091 int i; /* Looping var */
7092 char filename[1024]; /* PPD filename */
7093
7094 /*
7095 * Check policy...
7096 */
7097
7098 if ((status = cupsdCheckPolicy(dest->op_policy_ptr, con, NULL)) != HTTP_OK)
7099 {
7100 send_http_error(con, status, dest);
7101 return;
7102 }
7103
7104 /*
7105 * See if we need the PPD for a class or remote printer...
7106 */
7107
7108 snprintf(filename, sizeof(filename), "%s/ppd/%s.ppd", ServerRoot, dest->name);
7109
7110 if ((dtype & CUPS_PRINTER_REMOTE) && access(filename, 0))
7111 {
7112 send_ipp_status(con, IPP_STATUS_CUPS_SEE_OTHER, _("See remote printer."));
7113 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, dest->uri);
7114 return;
7115 }
7116 else if (dtype & CUPS_PRINTER_CLASS)
7117 {
7118 for (i = 0; i < dest->num_printers; i ++)
7119 if (!(dest->printers[i]->type & CUPS_PRINTER_CLASS))
7120 {
7121 snprintf(filename, sizeof(filename), "%s/ppd/%s.ppd", ServerRoot, dest->printers[i]->name);
7122
7123 if (!access(filename, 0))
7124 break;
7125 }
7126
7127 if (i < dest->num_printers)
7128 dest = dest->printers[i];
7129 else
7130 {
7131 send_ipp_status(con, IPP_STATUS_CUPS_SEE_OTHER, _("See remote printer."));
7132 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, dest->printers[0]->uri);
7133 return;
7134 }
7135 }
7136
7137 /*
7138 * Found the printer with the PPD file, now see if there is one...
7139 */
7140
7141 if ((con->file = open(filename, O_RDONLY)) < 0)
7142 {
7143 send_ipp_status(con, IPP_STATUS_ERROR_NOT_FOUND, _("The PPD file \"%s\" could not be opened: %s"), ippGetString(uri, 0, NULL), strerror(errno));
7144 return;
7145 }
7146
7147 fcntl(con->file, F_SETFD, fcntl(con->file, F_GETFD) | FD_CLOEXEC);
7148
7149 con->pipe_pid = 0;
7150
7151 ippSetStatusCode(con->response, IPP_STATUS_OK);
7152 }
7153 else
7154 send_ipp_status(con, IPP_STATUS_ERROR_NOT_FOUND, _("The PPD file \"%s\" could not be found."), ippGetString(uri, 0, NULL));
7155 }
7156
7157
7158 /*
7159 * 'get_ppds()' - Get the list of PPD files on the local system.
7160 */
7161
7162 static void
7163 get_ppds(cupsd_client_t *con) /* I - Client connection */
7164 {
7165 http_status_t status; /* Policy status */
7166 ipp_attribute_t *limit, /* Limit attribute */
7167 *device, /* ppd-device-id attribute */
7168 *language, /* ppd-natural-language attribute */
7169 *make, /* ppd-make attribute */
7170 *model, /* ppd-make-and-model attribute */
7171 *model_number, /* ppd-model-number attribute */
7172 *product, /* ppd-product attribute */
7173 *psversion, /* ppd-psverion attribute */
7174 *type, /* ppd-type attribute */
7175 *requested, /* requested-attributes attribute */
7176 *exclude, /* exclude-schemes attribute */
7177 *include; /* include-schemes attribute */
7178 char command[1024], /* cups-driverd command */
7179 options[4096], /* Options to pass to command */
7180 device_str[256],/* Escaped ppd-device-id string */
7181 language_str[256],
7182 /* Escaped ppd-natural-language */
7183 make_str[256], /* Escaped ppd-make string */
7184 model_str[256], /* Escaped ppd-make-and-model string */
7185 model_number_str[256],
7186 /* ppd-model-number string */
7187 product_str[256],
7188 /* Escaped ppd-product string */
7189 psversion_str[256],
7190 /* Escaped ppd-psversion string */
7191 type_str[256], /* Escaped ppd-type string */
7192 requested_str[256],
7193 /* String for requested attributes */
7194 exclude_str[512],
7195 /* String for excluded schemes */
7196 include_str[512];
7197 /* String for included schemes */
7198
7199
7200 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_ppds(%p[%d])", con, con->number);
7201
7202 /*
7203 * Check policy...
7204 */
7205
7206 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
7207 {
7208 send_http_error(con, status, NULL);
7209 return;
7210 }
7211
7212 /*
7213 * Run cups-driverd command with the given options...
7214 */
7215
7216 limit = ippFindAttribute(con->request, "limit", IPP_TAG_INTEGER);
7217 device = ippFindAttribute(con->request, "ppd-device-id", IPP_TAG_TEXT);
7218 language = ippFindAttribute(con->request, "ppd-natural-language",
7219 IPP_TAG_LANGUAGE);
7220 make = ippFindAttribute(con->request, "ppd-make", IPP_TAG_TEXT);
7221 model = ippFindAttribute(con->request, "ppd-make-and-model",
7222 IPP_TAG_TEXT);
7223 model_number = ippFindAttribute(con->request, "ppd-model-number",
7224 IPP_TAG_INTEGER);
7225 product = ippFindAttribute(con->request, "ppd-product", IPP_TAG_TEXT);
7226 psversion = ippFindAttribute(con->request, "ppd-psversion", IPP_TAG_TEXT);
7227 type = ippFindAttribute(con->request, "ppd-type", IPP_TAG_KEYWORD);
7228 requested = ippFindAttribute(con->request, "requested-attributes",
7229 IPP_TAG_KEYWORD);
7230 exclude = ippFindAttribute(con->request, "exclude-schemes",
7231 IPP_TAG_NAME);
7232 include = ippFindAttribute(con->request, "include-schemes",
7233 IPP_TAG_NAME);
7234
7235 if (requested)
7236 url_encode_attr(requested, requested_str, sizeof(requested_str));
7237 else
7238 strlcpy(requested_str, "requested-attributes=all", sizeof(requested_str));
7239
7240 if (device)
7241 url_encode_attr(device, device_str, sizeof(device_str));
7242 else
7243 device_str[0] = '\0';
7244
7245 if (language)
7246 url_encode_attr(language, language_str, sizeof(language_str));
7247 else
7248 language_str[0] = '\0';
7249
7250 if (make)
7251 url_encode_attr(make, make_str, sizeof(make_str));
7252 else
7253 make_str[0] = '\0';
7254
7255 if (model)
7256 url_encode_attr(model, model_str, sizeof(model_str));
7257 else
7258 model_str[0] = '\0';
7259
7260 if (model_number)
7261 snprintf(model_number_str, sizeof(model_number_str), "ppd-model-number=%d",
7262 model_number->values[0].integer);
7263 else
7264 model_number_str[0] = '\0';
7265
7266 if (product)
7267 url_encode_attr(product, product_str, sizeof(product_str));
7268 else
7269 product_str[0] = '\0';
7270
7271 if (psversion)
7272 url_encode_attr(psversion, psversion_str, sizeof(psversion_str));
7273 else
7274 psversion_str[0] = '\0';
7275
7276 if (type)
7277 url_encode_attr(type, type_str, sizeof(type_str));
7278 else
7279 type_str[0] = '\0';
7280
7281 if (exclude)
7282 url_encode_attr(exclude, exclude_str, sizeof(exclude_str));
7283 else
7284 exclude_str[0] = '\0';
7285
7286 if (include)
7287 url_encode_attr(include, include_str, sizeof(include_str));
7288 else
7289 include_str[0] = '\0';
7290
7291 snprintf(command, sizeof(command), "%s/daemon/cups-driverd", ServerBin);
7292 snprintf(options, sizeof(options),
7293 "list+%d+%d+%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
7294 con->request->request.op.request_id,
7295 limit ? limit->values[0].integer : 0,
7296 requested_str,
7297 device ? "%20" : "", device_str,
7298 language ? "%20" : "", language_str,
7299 make ? "%20" : "", make_str,
7300 model ? "%20" : "", model_str,
7301 model_number ? "%20" : "", model_number_str,
7302 product ? "%20" : "", product_str,
7303 psversion ? "%20" : "", psversion_str,
7304 type ? "%20" : "", type_str,
7305 exclude_str[0] ? "%20" : "", exclude_str,
7306 include_str[0] ? "%20" : "", include_str);
7307
7308 if (cupsdSendCommand(con, command, options, 0))
7309 {
7310 /*
7311 * Command started successfully, don't send an IPP response here...
7312 */
7313
7314 ippDelete(con->response);
7315 con->response = NULL;
7316 }
7317 else
7318 {
7319 /*
7320 * Command failed, return "internal error" so the user knows something
7321 * went wrong...
7322 */
7323
7324 send_ipp_status(con, IPP_INTERNAL_ERROR,
7325 _("cups-driverd failed to execute."));
7326 }
7327 }
7328
7329
7330 /*
7331 * 'get_printer_attrs()' - Get printer attributes.
7332 */
7333
7334 static void
7335 get_printer_attrs(cupsd_client_t *con, /* I - Client connection */
7336 ipp_attribute_t *uri) /* I - Printer URI */
7337 {
7338 http_status_t status; /* Policy status */
7339 cups_ptype_t dtype; /* Destination type (printer/class) */
7340 cupsd_printer_t *printer; /* Printer/class */
7341 cups_array_t *ra; /* Requested attributes array */
7342
7343
7344 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_printer_attrs(%p[%d], %s)", con,
7345 con->number, uri->values[0].string.text);
7346
7347 /*
7348 * Is the destination valid?
7349 */
7350
7351 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
7352 {
7353 /*
7354 * Bad URI...
7355 */
7356
7357 send_ipp_status(con, IPP_NOT_FOUND,
7358 _("The printer or class does not exist."));
7359 return;
7360 }
7361
7362 /*
7363 * Check policy...
7364 */
7365
7366 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
7367 {
7368 send_http_error(con, status, printer);
7369 return;
7370 }
7371
7372 /*
7373 * Send the attributes...
7374 */
7375
7376 ra = create_requested_array(con->request);
7377
7378 copy_printer_attrs(con, printer, ra);
7379
7380 cupsArrayDelete(ra);
7381
7382 con->response->request.status.status_code = IPP_OK;
7383 }
7384
7385
7386 /*
7387 * 'get_printer_supported()' - Get printer supported values.
7388 */
7389
7390 static void
7391 get_printer_supported(
7392 cupsd_client_t *con, /* I - Client connection */
7393 ipp_attribute_t *uri) /* I - Printer URI */
7394 {
7395 http_status_t status; /* Policy status */
7396 cups_ptype_t dtype; /* Destination type (printer/class) */
7397 cupsd_printer_t *printer; /* Printer/class */
7398
7399
7400 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_printer_supported(%p[%d], %s)", con,
7401 con->number, uri->values[0].string.text);
7402
7403 /*
7404 * Is the destination valid?
7405 */
7406
7407 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
7408 {
7409 /*
7410 * Bad URI...
7411 */
7412
7413 send_ipp_status(con, IPP_NOT_FOUND,
7414 _("The printer or class does not exist."));
7415 return;
7416 }
7417
7418 /*
7419 * Check policy...
7420 */
7421
7422 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
7423 {
7424 send_http_error(con, status, printer);
7425 return;
7426 }
7427
7428 /*
7429 * Return a list of attributes that can be set via Set-Printer-Attributes.
7430 */
7431
7432 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ADMINDEFINE,
7433 "printer-geo-location", 0);
7434 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ADMINDEFINE,
7435 "printer-info", 0);
7436 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ADMINDEFINE,
7437 "printer-location", 0);
7438 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ADMINDEFINE,
7439 "printer-organization", 0);
7440 ippAddInteger(con->response, IPP_TAG_PRINTER, IPP_TAG_ADMINDEFINE,
7441 "printer-organizational-unit", 0);
7442
7443 con->response->request.status.status_code = IPP_OK;
7444 }
7445
7446
7447 /*
7448 * 'get_printers()' - Get a list of printers or classes.
7449 */
7450
7451 static void
7452 get_printers(cupsd_client_t *con, /* I - Client connection */
7453 int type) /* I - 0 or CUPS_PRINTER_CLASS */
7454 {
7455 http_status_t status; /* Policy status */
7456 ipp_attribute_t *attr; /* Current attribute */
7457 int limit; /* Max number of printers to return */
7458 int count; /* Number of printers that match */
7459 int printer_id; /* Printer we are interested in */
7460 cupsd_printer_t *printer; /* Current printer pointer */
7461 cups_ptype_t printer_type, /* printer-type attribute */
7462 printer_mask; /* printer-type-mask attribute */
7463 char *location; /* Location string */
7464 const char *username; /* Current user */
7465 char *first_printer_name; /* first-printer-name attribute */
7466 cups_array_t *ra; /* Requested attributes array */
7467 int local; /* Local connection? */
7468
7469
7470 cupsdLogMessage(CUPSD_LOG_DEBUG2, "get_printers(%p[%d], %x)", con,
7471 con->number, type);
7472
7473 /*
7474 * Check policy...
7475 */
7476
7477 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
7478 {
7479 send_http_error(con, status, NULL);
7480 return;
7481 }
7482
7483 /*
7484 * Check for printers...
7485 */
7486
7487 if (!Printers || !cupsArrayCount(Printers))
7488 {
7489 send_ipp_status(con, IPP_NOT_FOUND, _("No destinations added."));
7490 return;
7491 }
7492
7493 /*
7494 * See if they want to limit the number of printers reported...
7495 */
7496
7497 if ((attr = ippFindAttribute(con->request, "limit",
7498 IPP_TAG_INTEGER)) != NULL)
7499 limit = attr->values[0].integer;
7500 else
7501 limit = 10000000;
7502
7503 if ((attr = ippFindAttribute(con->request, "first-printer-name",
7504 IPP_TAG_NAME)) != NULL)
7505 first_printer_name = attr->values[0].string.text;
7506 else
7507 first_printer_name = NULL;
7508
7509 /*
7510 * Support filtering...
7511 */
7512
7513 if ((attr = ippFindAttribute(con->request, "printer-id", IPP_TAG_INTEGER)) != NULL)
7514 {
7515 if ((printer_id = ippGetInteger(attr, 0)) <= 0)
7516 {
7517 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Bad \"printer-id\" value %d."), printer_id);
7518 return;
7519 }
7520 }
7521 else
7522 printer_id = 0;
7523
7524 if ((attr = ippFindAttribute(con->request, "printer-type",
7525 IPP_TAG_ENUM)) != NULL)
7526 printer_type = (cups_ptype_t)attr->values[0].integer;
7527 else
7528 printer_type = (cups_ptype_t)0;
7529
7530 if ((attr = ippFindAttribute(con->request, "printer-type-mask",
7531 IPP_TAG_ENUM)) != NULL)
7532 printer_mask = (cups_ptype_t)attr->values[0].integer;
7533 else
7534 printer_mask = (cups_ptype_t)0;
7535
7536 local = httpAddrLocalhost(&(con->clientaddr));
7537
7538 if ((attr = ippFindAttribute(con->request, "printer-location",
7539 IPP_TAG_TEXT)) != NULL)
7540 location = attr->values[0].string.text;
7541 else
7542 location = NULL;
7543
7544 if (con->username[0])
7545 username = con->username;
7546 else if ((attr = ippFindAttribute(con->request, "requesting-user-name",
7547 IPP_TAG_NAME)) != NULL)
7548 username = attr->values[0].string.text;
7549 else
7550 username = NULL;
7551
7552 ra = create_requested_array(con->request);
7553
7554 /*
7555 * OK, build a list of printers for this printer...
7556 */
7557
7558 if (first_printer_name)
7559 {
7560 if ((printer = cupsdFindDest(first_printer_name)) == NULL)
7561 printer = (cupsd_printer_t *)cupsArrayFirst(Printers);
7562 }
7563 else
7564 printer = (cupsd_printer_t *)cupsArrayFirst(Printers);
7565
7566 for (count = 0;
7567 count < limit && printer;
7568 printer = (cupsd_printer_t *)cupsArrayNext(Printers))
7569 {
7570 if (!local && !printer->shared)
7571 continue;
7572
7573 if (printer_id && printer->printer_id != printer_id)
7574 continue;
7575
7576 if ((!type || (printer->type & CUPS_PRINTER_CLASS) == type) &&
7577 (printer->type & printer_mask) == printer_type &&
7578 (!location ||
7579 (printer->location && !_cups_strcasecmp(printer->location, location))))
7580 {
7581 /*
7582 * If a username is specified, see if it is allowed or denied
7583 * access...
7584 */
7585
7586 if (cupsArrayCount(printer->users) && username &&
7587 !user_allowed(printer, username))
7588 continue;
7589
7590 /*
7591 * Add the group separator as needed...
7592 */
7593
7594 if (count > 0)
7595 ippAddSeparator(con->response);
7596
7597 count ++;
7598
7599 /*
7600 * Send the attributes...
7601 */
7602
7603 copy_printer_attrs(con, printer, ra);
7604 }
7605 }
7606
7607 cupsArrayDelete(ra);
7608
7609 con->response->request.status.status_code = IPP_OK;
7610 }
7611
7612
7613 /*
7614 * 'get_subscription_attrs()' - Get subscription attributes.
7615 */
7616
7617 static void
7618 get_subscription_attrs(
7619 cupsd_client_t *con, /* I - Client connection */
7620 int sub_id) /* I - Subscription ID */
7621 {
7622 http_status_t status; /* Policy status */
7623 cupsd_subscription_t *sub; /* Subscription */
7624 cupsd_policy_t *policy; /* Current security policy */
7625 cups_array_t *ra, /* Requested attributes array */
7626 *exclude; /* Private attributes array */
7627
7628
7629 cupsdLogMessage(CUPSD_LOG_DEBUG2,
7630 "get_subscription_attrs(con=%p[%d], sub_id=%d)",
7631 con, con->number, sub_id);
7632
7633 /*
7634 * Expire subscriptions as needed...
7635 */
7636
7637 cupsdExpireSubscriptions(NULL, NULL);
7638
7639 /*
7640 * Is the subscription ID valid?
7641 */
7642
7643 if ((sub = cupsdFindSubscription(sub_id)) == NULL)
7644 {
7645 /*
7646 * Bad subscription ID...
7647 */
7648
7649 send_ipp_status(con, IPP_NOT_FOUND, _("Subscription #%d does not exist."),
7650 sub_id);
7651 return;
7652 }
7653
7654 /*
7655 * Check policy...
7656 */
7657
7658 if (sub->dest)
7659 policy = sub->dest->op_policy_ptr;
7660 else
7661 policy = DefaultPolicyPtr;
7662
7663 if ((status = cupsdCheckPolicy(policy, con, sub->owner)) != HTTP_OK)
7664 {
7665 send_http_error(con, status, sub->dest);
7666 return;
7667 }
7668
7669 exclude = cupsdGetPrivateAttrs(policy, con, sub->dest, sub->owner);
7670
7671 /*
7672 * Copy the subscription attributes to the response using the
7673 * requested-attributes attribute that may be provided by the client.
7674 */
7675
7676 ra = create_requested_array(con->request);
7677
7678 copy_subscription_attrs(con, sub, ra, exclude);
7679
7680 cupsArrayDelete(ra);
7681
7682 con->response->request.status.status_code = IPP_OK;
7683 }
7684
7685
7686 /*
7687 * 'get_subscriptions()' - Get subscriptions.
7688 */
7689
7690 static void
7691 get_subscriptions(cupsd_client_t *con, /* I - Client connection */
7692 ipp_attribute_t *uri) /* I - Printer/job URI */
7693 {
7694 http_status_t status; /* Policy status */
7695 int count; /* Number of subscriptions */
7696 int limit; /* Limit */
7697 cupsd_subscription_t *sub; /* Subscription */
7698 cups_array_t *ra; /* Requested attributes array */
7699 ipp_attribute_t *attr; /* Attribute */
7700 cups_ptype_t dtype; /* Destination type (printer/class) */
7701 char scheme[HTTP_MAX_URI],
7702 /* Scheme portion of URI */
7703 username[HTTP_MAX_URI],
7704 /* Username portion of URI */
7705 host[HTTP_MAX_URI],
7706 /* Host portion of URI */
7707 resource[HTTP_MAX_URI];
7708 /* Resource portion of URI */
7709 int port; /* Port portion of URI */
7710 cupsd_job_t *job; /* Job pointer */
7711 cupsd_printer_t *printer; /* Printer */
7712 cupsd_policy_t *policy; /* Policy */
7713 cups_array_t *exclude; /* Private attributes array */
7714
7715
7716 cupsdLogMessage(CUPSD_LOG_DEBUG2,
7717 "get_subscriptions(con=%p[%d], uri=%s)",
7718 con, con->number, uri->values[0].string.text);
7719
7720 /*
7721 * Is the destination valid?
7722 */
7723
7724 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
7725 sizeof(scheme), username, sizeof(username), host,
7726 sizeof(host), &port, resource, sizeof(resource));
7727
7728 if (!strcmp(resource, "/") ||
7729 (!strncmp(resource, "/jobs", 5) && strlen(resource) <= 6) ||
7730 (!strncmp(resource, "/printers", 9) && strlen(resource) <= 10) ||
7731 (!strncmp(resource, "/classes", 8) && strlen(resource) <= 9))
7732 {
7733 printer = NULL;
7734 job = NULL;
7735 }
7736 else if (!strncmp(resource, "/jobs/", 6) && resource[6])
7737 {
7738 printer = NULL;
7739 job = cupsdFindJob(atoi(resource + 6));
7740
7741 if (!job)
7742 {
7743 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
7744 atoi(resource + 6));
7745 return;
7746 }
7747 }
7748 else if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
7749 {
7750 /*
7751 * Bad URI...
7752 */
7753
7754 send_ipp_status(con, IPP_NOT_FOUND,
7755 _("The printer or class does not exist."));
7756 return;
7757 }
7758 else if ((attr = ippFindAttribute(con->request, "notify-job-id",
7759 IPP_TAG_INTEGER)) != NULL)
7760 {
7761 job = cupsdFindJob(attr->values[0].integer);
7762
7763 if (!job)
7764 {
7765 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."),
7766 attr->values[0].integer);
7767 return;
7768 }
7769 }
7770 else
7771 job = NULL;
7772
7773 /*
7774 * Check policy...
7775 */
7776
7777 if (printer)
7778 policy = printer->op_policy_ptr;
7779 else
7780 policy = DefaultPolicyPtr;
7781
7782 if ((status = cupsdCheckPolicy(policy, con, NULL)) != HTTP_OK)
7783 {
7784 send_http_error(con, status, printer);
7785 return;
7786 }
7787
7788 /*
7789 * Expire subscriptions as needed...
7790 */
7791
7792 cupsdExpireSubscriptions(NULL, NULL);
7793
7794 /*
7795 * Copy the subscription attributes to the response using the
7796 * requested-attributes attribute that may be provided by the client.
7797 */
7798
7799 ra = create_requested_array(con->request);
7800
7801 if ((attr = ippFindAttribute(con->request, "limit",
7802 IPP_TAG_INTEGER)) != NULL)
7803 limit = attr->values[0].integer;
7804 else
7805 limit = 0;
7806
7807 /*
7808 * See if we only want to see subscriptions for a specific user...
7809 */
7810
7811 if ((attr = ippFindAttribute(con->request, "my-subscriptions",
7812 IPP_TAG_BOOLEAN)) != NULL &&
7813 attr->values[0].boolean)
7814 strlcpy(username, get_username(con), sizeof(username));
7815 else
7816 username[0] = '\0';
7817
7818 for (sub = (cupsd_subscription_t *)cupsArrayFirst(Subscriptions), count = 0;
7819 sub;
7820 sub = (cupsd_subscription_t *)cupsArrayNext(Subscriptions))
7821 if ((!printer || sub->dest == printer) && (!job || sub->job == job) &&
7822 (!username[0] || !_cups_strcasecmp(username, sub->owner)))
7823 {
7824 ippAddSeparator(con->response);
7825
7826 exclude = cupsdGetPrivateAttrs(sub->dest ? sub->dest->op_policy_ptr :
7827 policy, con, sub->dest,
7828 sub->owner);
7829
7830 copy_subscription_attrs(con, sub, ra, exclude);
7831
7832 count ++;
7833 if (limit && count >= limit)
7834 break;
7835 }
7836
7837 cupsArrayDelete(ra);
7838
7839 if (count)
7840 con->response->request.status.status_code = IPP_OK;
7841 else
7842 send_ipp_status(con, IPP_NOT_FOUND, _("No subscriptions found."));
7843 }
7844
7845
7846 /*
7847 * 'get_username()' - Get the username associated with a request.
7848 */
7849
7850 static const char * /* O - Username */
7851 get_username(cupsd_client_t *con) /* I - Connection */
7852 {
7853 ipp_attribute_t *attr; /* Attribute */
7854
7855
7856 if (con->username[0])
7857 return (con->username);
7858 else if ((attr = ippFindAttribute(con->request, "requesting-user-name",
7859 IPP_TAG_NAME)) != NULL)
7860 return (attr->values[0].string.text);
7861 else
7862 return ("anonymous");
7863 }
7864
7865
7866 /*
7867 * 'hold_job()' - Hold a print job.
7868 */
7869
7870 static void
7871 hold_job(cupsd_client_t *con, /* I - Client connection */
7872 ipp_attribute_t *uri) /* I - Job or Printer URI */
7873 {
7874 ipp_attribute_t *attr; /* Current job-hold-until */
7875 const char *when; /* New value */
7876 int jobid; /* Job ID */
7877 char scheme[HTTP_MAX_URI], /* Method portion of URI */
7878 username[HTTP_MAX_URI], /* Username portion of URI */
7879 host[HTTP_MAX_URI], /* Host portion of URI */
7880 resource[HTTP_MAX_URI]; /* Resource portion of URI */
7881 int port; /* Port portion of URI */
7882 cupsd_job_t *job; /* Job information */
7883
7884
7885 cupsdLogMessage(CUPSD_LOG_DEBUG2, "hold_job(%p[%d], %s)", con, con->number,
7886 uri->values[0].string.text);
7887
7888 /*
7889 * See if we have a job URI or a printer URI...
7890 */
7891
7892 if (!strcmp(uri->name, "printer-uri"))
7893 {
7894 /*
7895 * Got a printer URI; see if we also have a job-id attribute...
7896 */
7897
7898 if ((attr = ippFindAttribute(con->request, "job-id",
7899 IPP_TAG_INTEGER)) == NULL)
7900 {
7901 send_ipp_status(con, IPP_BAD_REQUEST,
7902 _("Got a printer-uri attribute but no job-id."));
7903 return;
7904 }
7905
7906 jobid = attr->values[0].integer;
7907 }
7908 else
7909 {
7910 /*
7911 * Got a job URI; parse it to get the job ID...
7912 */
7913
7914 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
7915 sizeof(scheme), username, sizeof(username), host,
7916 sizeof(host), &port, resource, sizeof(resource));
7917
7918 if (strncmp(resource, "/jobs/", 6))
7919 {
7920 /*
7921 * Not a valid URI!
7922 */
7923
7924 send_ipp_status(con, IPP_BAD_REQUEST,
7925 _("Bad job-uri \"%s\"."),
7926 uri->values[0].string.text);
7927 return;
7928 }
7929
7930 jobid = atoi(resource + 6);
7931 }
7932
7933 /*
7934 * See if the job exists...
7935 */
7936
7937 if ((job = cupsdFindJob(jobid)) == NULL)
7938 {
7939 /*
7940 * Nope - return a "not found" error...
7941 */
7942
7943 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
7944 return;
7945 }
7946
7947 /*
7948 * See if the job is owned by the requesting user...
7949 */
7950
7951 if (!validate_user(job, con, job->username, username, sizeof(username)))
7952 {
7953 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
7954 cupsdFindDest(job->dest));
7955 return;
7956 }
7957
7958 /*
7959 * See if the job is in a state that allows holding...
7960 */
7961
7962 if (job->state_value > IPP_JOB_STOPPED)
7963 {
7964 /*
7965 * Return a "not-possible" error...
7966 */
7967
7968 send_ipp_status(con, IPP_NOT_POSSIBLE,
7969 _("Job #%d is finished and cannot be altered."),
7970 job->id);
7971 return;
7972 }
7973
7974 /*
7975 * Hold the job and return...
7976 */
7977
7978 if ((attr = ippFindAttribute(con->request, "job-hold-until", IPP_TAG_ZERO)) != NULL)
7979 {
7980 if ((ippGetValueTag(attr) != IPP_TAG_KEYWORD && ippGetValueTag(attr) != IPP_TAG_NAME && ippGetValueTag(attr) != IPP_TAG_NAMELANG) || ippGetCount(attr) != 1 || !ippValidateAttribute(attr))
7981 {
7982 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Unsupported 'job-hold-until' value."));
7983 ippCopyAttribute(con->response, attr, 0);
7984 return;
7985 }
7986
7987 when = ippGetString(attr, 0, NULL);
7988
7989 cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED, cupsdFindDest(job->dest), job,
7990 "Job job-hold-until value changed by user.");
7991 }
7992 else
7993 when = "indefinite";
7994
7995 cupsdSetJobHoldUntil(job, when, 1);
7996 cupsdSetJobState(job, IPP_JOB_HELD, CUPSD_JOB_DEFAULT, "Job held by \"%s\".",
7997 username);
7998
7999 con->response->request.status.status_code = IPP_OK;
8000 }
8001
8002
8003 /*
8004 * 'hold_new_jobs()' - Hold pending/new jobs on a printer or class.
8005 */
8006
8007 static void
8008 hold_new_jobs(cupsd_client_t *con, /* I - Connection */
8009 ipp_attribute_t *uri) /* I - Printer URI */
8010 {
8011 http_status_t status; /* Policy status */
8012 cups_ptype_t dtype; /* Destination type (printer/class) */
8013 cupsd_printer_t *printer; /* Printer data */
8014
8015
8016 cupsdLogMessage(CUPSD_LOG_DEBUG2, "hold_new_jobs(%p[%d], %s)", con,
8017 con->number, uri->values[0].string.text);
8018
8019 /*
8020 * Is the destination valid?
8021 */
8022
8023 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
8024 {
8025 /*
8026 * Bad URI...
8027 */
8028
8029 send_ipp_status(con, IPP_NOT_FOUND,
8030 _("The printer or class does not exist."));
8031 return;
8032 }
8033
8034 /*
8035 * Check policy...
8036 */
8037
8038 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
8039 {
8040 send_http_error(con, status, printer);
8041 return;
8042 }
8043
8044 /*
8045 * Hold pending/new jobs sent to the printer...
8046 */
8047
8048 printer->holding_new_jobs = 1;
8049
8050 cupsdSetPrinterReasons(printer, "+hold-new-jobs");
8051
8052 if (dtype & CUPS_PRINTER_CLASS)
8053 cupsdLogMessage(CUPSD_LOG_INFO,
8054 "Class \"%s\" now holding pending/new jobs (\"%s\").",
8055 printer->name, get_username(con));
8056 else
8057 cupsdLogMessage(CUPSD_LOG_INFO,
8058 "Printer \"%s\" now holding pending/new jobs (\"%s\").",
8059 printer->name, get_username(con));
8060
8061 /*
8062 * Everything was ok, so return OK status...
8063 */
8064
8065 con->response->request.status.status_code = IPP_OK;
8066 }
8067
8068
8069 /*
8070 * 'move_job()' - Move a job to a new destination.
8071 */
8072
8073 static void
8074 move_job(cupsd_client_t *con, /* I - Client connection */
8075 ipp_attribute_t *uri) /* I - Job URI */
8076 {
8077 http_status_t status; /* Policy status */
8078 ipp_attribute_t *attr; /* Current attribute */
8079 int jobid; /* Job ID */
8080 cupsd_job_t *job; /* Current job */
8081 const char *src; /* Source printer/class */
8082 cups_ptype_t stype, /* Source type (printer or class) */
8083 dtype; /* Destination type (printer/class) */
8084 char scheme[HTTP_MAX_URI], /* Scheme portion of URI */
8085 username[HTTP_MAX_URI], /* Username portion of URI */
8086 host[HTTP_MAX_URI], /* Host portion of URI */
8087 resource[HTTP_MAX_URI]; /* Resource portion of URI */
8088 int port; /* Port portion of URI */
8089 cupsd_printer_t *sprinter, /* Source printer */
8090 *dprinter; /* Destination printer */
8091
8092
8093 cupsdLogMessage(CUPSD_LOG_DEBUG2, "move_job(%p[%d], %s)", con, con->number,
8094 uri->values[0].string.text);
8095
8096 /*
8097 * Get the new printer or class...
8098 */
8099
8100 if ((attr = ippFindAttribute(con->request, "job-printer-uri",
8101 IPP_TAG_URI)) == NULL)
8102 {
8103 /*
8104 * Need job-printer-uri...
8105 */
8106
8107 send_ipp_status(con, IPP_BAD_REQUEST,
8108 _("job-printer-uri attribute missing."));
8109 return;
8110 }
8111
8112 if (!cupsdValidateDest(attr->values[0].string.text, &dtype, &dprinter))
8113 {
8114 /*
8115 * Bad URI...
8116 */
8117
8118 send_ipp_status(con, IPP_NOT_FOUND,
8119 _("The printer or class does not exist."));
8120 return;
8121 }
8122
8123 /*
8124 * See if we have a job URI or a printer URI...
8125 */
8126
8127 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
8128 sizeof(scheme), username, sizeof(username), host,
8129 sizeof(host), &port, resource, sizeof(resource));
8130
8131 if (!strcmp(uri->name, "printer-uri"))
8132 {
8133 /*
8134 * Got a printer URI; see if we also have a job-id attribute...
8135 */
8136
8137 if ((attr = ippFindAttribute(con->request, "job-id",
8138 IPP_TAG_INTEGER)) == NULL)
8139 {
8140 /*
8141 * Move all jobs...
8142 */
8143
8144 if ((src = cupsdValidateDest(uri->values[0].string.text, &stype,
8145 &sprinter)) == NULL)
8146 {
8147 /*
8148 * Bad URI...
8149 */
8150
8151 send_ipp_status(con, IPP_NOT_FOUND,
8152 _("The printer or class does not exist."));
8153 return;
8154 }
8155
8156 job = NULL;
8157 }
8158 else
8159 {
8160 /*
8161 * Otherwise, just move a single job...
8162 */
8163
8164 if ((job = cupsdFindJob(attr->values[0].integer)) == NULL)
8165 {
8166 /*
8167 * Nope - return a "not found" error...
8168 */
8169
8170 send_ipp_status(con, IPP_NOT_FOUND,
8171 _("Job #%d does not exist."), attr->values[0].integer);
8172 return;
8173 }
8174 else
8175 {
8176 /*
8177 * Job found, initialize source pointers...
8178 */
8179
8180 src = NULL;
8181 sprinter = NULL;
8182 }
8183 }
8184 }
8185 else
8186 {
8187 /*
8188 * Got a job URI; parse it to get the job ID...
8189 */
8190
8191 if (strncmp(resource, "/jobs/", 6))
8192 {
8193 /*
8194 * Not a valid URI!
8195 */
8196
8197 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
8198 uri->values[0].string.text);
8199 return;
8200 }
8201
8202 /*
8203 * See if the job exists...
8204 */
8205
8206 jobid = atoi(resource + 6);
8207
8208 if ((job = cupsdFindJob(jobid)) == NULL)
8209 {
8210 /*
8211 * Nope - return a "not found" error...
8212 */
8213
8214 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
8215 return;
8216 }
8217 else
8218 {
8219 /*
8220 * Job found, initialize source pointers...
8221 */
8222
8223 src = NULL;
8224 sprinter = NULL;
8225 }
8226 }
8227
8228 /*
8229 * Check the policy of the destination printer...
8230 */
8231
8232 if ((status = cupsdCheckPolicy(dprinter->op_policy_ptr, con,
8233 job ? job->username : NULL)) != HTTP_OK)
8234 {
8235 send_http_error(con, status, dprinter);
8236 return;
8237 }
8238
8239 /*
8240 * Now move the job or jobs...
8241 */
8242
8243 if (job)
8244 {
8245 /*
8246 * See if the job has been completed...
8247 */
8248
8249 if (job->state_value > IPP_JOB_STOPPED)
8250 {
8251 /*
8252 * Return a "not-possible" error...
8253 */
8254
8255 send_ipp_status(con, IPP_NOT_POSSIBLE,
8256 _("Job #%d is finished and cannot be altered."),
8257 job->id);
8258 return;
8259 }
8260
8261 /*
8262 * See if the job is owned by the requesting user...
8263 */
8264
8265 if (!validate_user(job, con, job->username, username, sizeof(username)))
8266 {
8267 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
8268 cupsdFindDest(job->dest));
8269 return;
8270 }
8271
8272 /*
8273 * Move the job to a different printer or class...
8274 */
8275
8276 cupsdMoveJob(job, dprinter);
8277 }
8278 else
8279 {
8280 /*
8281 * Got the source printer, now look through the jobs...
8282 */
8283
8284 for (job = (cupsd_job_t *)cupsArrayFirst(Jobs);
8285 job;
8286 job = (cupsd_job_t *)cupsArrayNext(Jobs))
8287 {
8288 /*
8289 * See if the job is pointing at the source printer or has not been
8290 * completed...
8291 */
8292
8293 if (_cups_strcasecmp(job->dest, src) ||
8294 job->state_value > IPP_JOB_STOPPED)
8295 continue;
8296
8297 /*
8298 * See if the job can be moved by the requesting user...
8299 */
8300
8301 if (!validate_user(job, con, job->username, username, sizeof(username)))
8302 continue;
8303
8304 /*
8305 * Move the job to a different printer or class...
8306 */
8307
8308 cupsdMoveJob(job, dprinter);
8309 }
8310 }
8311
8312 /*
8313 * Start jobs if possible...
8314 */
8315
8316 cupsdCheckJobs();
8317
8318 /*
8319 * Return with "everything is OK" status...
8320 */
8321
8322 con->response->request.status.status_code = IPP_OK;
8323 }
8324
8325
8326 /*
8327 * 'ppd_parse_line()' - Parse a PPD default line.
8328 */
8329
8330 static int /* O - 0 on success, -1 on failure */
8331 ppd_parse_line(const char *line, /* I - Line */
8332 char *option, /* O - Option name */
8333 int olen, /* I - Size of option name */
8334 char *choice, /* O - Choice name */
8335 int clen) /* I - Size of choice name */
8336 {
8337 /*
8338 * Verify this is a default option line...
8339 */
8340
8341 if (strncmp(line, "*Default", 8))
8342 return (-1);
8343
8344 /*
8345 * Read the option name...
8346 */
8347
8348 for (line += 8, olen --;
8349 *line > ' ' && *line < 0x7f && *line != ':' && *line != '/';
8350 line ++)
8351 if (olen > 0)
8352 {
8353 *option++ = *line;
8354 olen --;
8355 }
8356
8357 *option = '\0';
8358
8359 /*
8360 * Skip everything else up to the colon (:)...
8361 */
8362
8363 while (*line && *line != ':')
8364 line ++;
8365
8366 if (!*line)
8367 return (-1);
8368
8369 line ++;
8370
8371 /*
8372 * Now grab the option choice, skipping leading whitespace...
8373 */
8374
8375 while (isspace(*line & 255))
8376 line ++;
8377
8378 for (clen --;
8379 *line > ' ' && *line < 0x7f && *line != ':' && *line != '/';
8380 line ++)
8381 if (clen > 0)
8382 {
8383 *choice++ = *line;
8384 clen --;
8385 }
8386
8387 *choice = '\0';
8388
8389 /*
8390 * Return with no errors...
8391 */
8392
8393 return (0);
8394 }
8395
8396
8397 /*
8398 * 'print_job()' - Print a file to a printer or class.
8399 */
8400
8401 static void
8402 print_job(cupsd_client_t *con, /* I - Client connection */
8403 ipp_attribute_t *uri) /* I - Printer URI */
8404 {
8405 ipp_attribute_t *attr; /* Current attribute */
8406 ipp_attribute_t *doc_name; /* document-name attribute */
8407 ipp_attribute_t *format; /* Document-format attribute */
8408 const char *default_format; /* document-format-default value */
8409 cupsd_job_t *job; /* New job */
8410 char filename[1024]; /* Job filename */
8411 mime_type_t *filetype; /* Type of file */
8412 char super[MIME_MAX_SUPER], /* Supertype of file */
8413 type[MIME_MAX_TYPE], /* Subtype of file */
8414 mimetype[MIME_MAX_SUPER + MIME_MAX_TYPE + 2];
8415 /* Textual name of mime type */
8416 cupsd_printer_t *printer; /* Printer data */
8417 struct stat fileinfo; /* File information */
8418 int kbytes; /* Size of file */
8419 int compression; /* Document compression */
8420
8421
8422 cupsdLogMessage(CUPSD_LOG_DEBUG2, "print_job(%p[%d], %s)", con, con->number,
8423 uri->values[0].string.text);
8424
8425 /*
8426 * Validate print file attributes, for now just document-format and
8427 * compression (CUPS only supports "none" and "gzip")...
8428 */
8429
8430 compression = CUPS_FILE_NONE;
8431
8432 if ((attr = ippFindAttribute(con->request, "compression",
8433 IPP_TAG_KEYWORD)) != NULL)
8434 {
8435 if (strcmp(attr->values[0].string.text, "none")
8436 #ifdef HAVE_LIBZ
8437 && strcmp(attr->values[0].string.text, "gzip")
8438 #endif /* HAVE_LIBZ */
8439 )
8440 {
8441 send_ipp_status(con, IPP_ATTRIBUTES,
8442 _("Unsupported compression \"%s\"."),
8443 attr->values[0].string.text);
8444 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_KEYWORD,
8445 "compression", NULL, attr->values[0].string.text);
8446 return;
8447 }
8448
8449 #ifdef HAVE_LIBZ
8450 if (!strcmp(attr->values[0].string.text, "gzip"))
8451 compression = CUPS_FILE_GZIP;
8452 #endif /* HAVE_LIBZ */
8453 }
8454
8455 /*
8456 * Do we have a file to print?
8457 */
8458
8459 if (!con->filename)
8460 {
8461 send_ipp_status(con, IPP_BAD_REQUEST, _("No file in print request."));
8462 return;
8463 }
8464
8465 /*
8466 * Is the destination valid?
8467 */
8468
8469 if (!cupsdValidateDest(uri->values[0].string.text, NULL, &printer))
8470 {
8471 /*
8472 * Bad URI...
8473 */
8474
8475 send_ipp_status(con, IPP_NOT_FOUND,
8476 _("The printer or class does not exist."));
8477 return;
8478 }
8479
8480 /*
8481 * Is it a format we support?
8482 */
8483
8484 doc_name = ippFindAttribute(con->request, "document-name", IPP_TAG_NAME);
8485 if (doc_name)
8486 ippSetName(con->request, &doc_name, "document-name-supplied");
8487
8488 if ((format = ippFindAttribute(con->request, "document-format",
8489 IPP_TAG_MIMETYPE)) != NULL)
8490 {
8491 /*
8492 * Grab format from client...
8493 */
8494
8495 if (sscanf(format->values[0].string.text, "%15[^/]/%255[^;]", super,
8496 type) != 2)
8497 {
8498 send_ipp_status(con, IPP_BAD_REQUEST,
8499 _("Bad document-format \"%s\"."),
8500 format->values[0].string.text);
8501 return;
8502 }
8503
8504 ippAddString(con->request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format-supplied", NULL, ippGetString(format, 0, NULL));
8505 }
8506 else if ((default_format = cupsGetOption("document-format",
8507 printer->num_options,
8508 printer->options)) != NULL)
8509 {
8510 /*
8511 * Use default document format...
8512 */
8513
8514 if (sscanf(default_format, "%15[^/]/%255[^;]", super, type) != 2)
8515 {
8516 send_ipp_status(con, IPP_BAD_REQUEST,
8517 _("Bad document-format \"%s\"."),
8518 default_format);
8519 return;
8520 }
8521 }
8522 else
8523 {
8524 /*
8525 * Auto-type it!
8526 */
8527
8528 strlcpy(super, "application", sizeof(super));
8529 strlcpy(type, "octet-stream", sizeof(type));
8530 }
8531
8532 if (!strcmp(super, "application") && !strcmp(type, "octet-stream"))
8533 {
8534 /*
8535 * Auto-type the file...
8536 */
8537
8538 cupsdLogMessage(CUPSD_LOG_DEBUG, "[Job ???] Auto-typing file...");
8539
8540
8541 filetype = mimeFileType(MimeDatabase, con->filename,
8542 doc_name ? doc_name->values[0].string.text : NULL,
8543 &compression);
8544
8545 if (!filetype)
8546 filetype = mimeType(MimeDatabase, super, type);
8547
8548 cupsdLogMessage(CUPSD_LOG_INFO, "[Job ???] Request file type is %s/%s.",
8549 filetype->super, filetype->type);
8550
8551 snprintf(mimetype, sizeof(mimetype), "%s/%s", filetype->super, filetype->type);
8552 ippAddString(con->request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format-detected", NULL, mimetype);
8553 }
8554 else
8555 filetype = mimeType(MimeDatabase, super, type);
8556
8557 if (filetype &&
8558 (!format ||
8559 (!strcmp(super, "application") && !strcmp(type, "octet-stream"))))
8560 {
8561 /*
8562 * Replace the document-format attribute value with the auto-typed or
8563 * default one.
8564 */
8565
8566 snprintf(mimetype, sizeof(mimetype), "%s/%s", filetype->super,
8567 filetype->type);
8568
8569 if (format)
8570 ippSetString(con->request, &format, 0, mimetype);
8571 else
8572 ippAddString(con->request, IPP_TAG_JOB, IPP_TAG_MIMETYPE,
8573 "document-format", NULL, mimetype);
8574 }
8575 else if (!filetype)
8576 {
8577 send_ipp_status(con, IPP_DOCUMENT_FORMAT,
8578 _("Unsupported document-format \"%s\"."),
8579 format ? format->values[0].string.text :
8580 "application/octet-stream");
8581 cupsdLogMessage(CUPSD_LOG_INFO,
8582 "Hint: Do you have the raw file printing rules enabled?");
8583
8584 if (format)
8585 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_MIMETYPE,
8586 "document-format", NULL, format->values[0].string.text);
8587
8588 return;
8589 }
8590
8591 /*
8592 * Read any embedded job ticket info from PS files...
8593 */
8594
8595 if (!_cups_strcasecmp(filetype->super, "application") &&
8596 (!_cups_strcasecmp(filetype->type, "postscript") ||
8597 !_cups_strcasecmp(filetype->type, "pdf")))
8598 read_job_ticket(con);
8599
8600 /*
8601 * Create the job object...
8602 */
8603
8604 if ((job = add_job(con, printer, filetype)) == NULL)
8605 return;
8606
8607 /*
8608 * Update quota data...
8609 */
8610
8611 if (stat(con->filename, &fileinfo))
8612 kbytes = 0;
8613 else
8614 kbytes = (fileinfo.st_size + 1023) / 1024;
8615
8616 cupsdUpdateQuota(printer, job->username, 0, kbytes);
8617
8618 job->koctets += kbytes;
8619
8620 if ((attr = ippFindAttribute(job->attrs, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
8621 attr->values[0].integer += kbytes;
8622
8623 /*
8624 * Add the job file...
8625 */
8626
8627 if (add_file(con, job, filetype, compression))
8628 return;
8629
8630 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot, job->id, job->num_files);
8631 if (rename(con->filename, filename))
8632 {
8633 cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to rename job document file \"%s\": %s", filename, strerror(errno));
8634
8635 send_ipp_status(con, IPP_INTERNAL_ERROR, _("Unable to rename job document file."));
8636 return;
8637 }
8638
8639 cupsdClearString(&con->filename);
8640
8641 /*
8642 * See if we need to add the ending sheet...
8643 */
8644
8645 if (cupsdTimeoutJob(job))
8646 return;
8647
8648 /*
8649 * Log and save the job...
8650 */
8651
8652 cupsdLogJob(job, CUPSD_LOG_INFO,
8653 "File of type %s/%s queued by \"%s\".",
8654 filetype->super, filetype->type, job->username);
8655 cupsdLogJob(job, CUPSD_LOG_DEBUG, "hold_until=%d", (int)job->hold_until);
8656 cupsdLogJob(job, CUPSD_LOG_INFO, "Queued on \"%s\" by \"%s\".",
8657 job->dest, job->username);
8658
8659 /*
8660 * Start the job if possible...
8661 */
8662
8663 cupsdCheckJobs();
8664 }
8665
8666
8667 /*
8668 * 'read_job_ticket()' - Read a job ticket embedded in a print file.
8669 *
8670 * This function only gets called when printing a single PDF or PostScript
8671 * file using the Print-Job operation. It doesn't work for Create-Job +
8672 * Send-File, since the job attributes need to be set at job creation
8673 * time for banners to work. The embedded job ticket stuff is here
8674 * primarily to allow the Windows printer driver for CUPS to pass in JCL
8675 * options and IPP attributes which otherwise would be lost.
8676 *
8677 * The format of a job ticket is simple:
8678 *
8679 * %cupsJobTicket: attr1=value1 attr2=value2 ... attrN=valueN
8680 *
8681 * %cupsJobTicket: attr1=value1
8682 * %cupsJobTicket: attr2=value2
8683 * ...
8684 * %cupsJobTicket: attrN=valueN
8685 *
8686 * Job ticket lines must appear immediately after the first line that
8687 * specifies PostScript (%!PS-Adobe-3.0) or PDF (%PDF) format, and CUPS
8688 * stops looking for job ticket info when it finds a line that does not begin
8689 * with "%cupsJobTicket:".
8690 *
8691 * The maximum length of a job ticket line, including the prefix, is
8692 * 255 characters to conform with the Adobe DSC.
8693 *
8694 * Read-only attributes are rejected with a notice to the error log in
8695 * case a malicious user tries anything. Since the job ticket is read
8696 * prior to attribute validation in print_job(), job ticket attributes
8697 * will go through the same validation as IPP attributes...
8698 */
8699
8700 static void
8701 read_job_ticket(cupsd_client_t *con) /* I - Client connection */
8702 {
8703 cups_file_t *fp; /* File to read from */
8704 char line[256]; /* Line data */
8705 int num_options; /* Number of options */
8706 cups_option_t *options; /* Options */
8707 ipp_t *ticket; /* New attributes */
8708 ipp_attribute_t *attr, /* Current attribute */
8709 *attr2, /* Job attribute */
8710 *prev2; /* Previous job attribute */
8711
8712
8713 /*
8714 * First open the print file...
8715 */
8716
8717 if ((fp = cupsFileOpen(con->filename, "rb")) == NULL)
8718 {
8719 cupsdLogMessage(CUPSD_LOG_ERROR,
8720 "Unable to open print file for job ticket - %s",
8721 strerror(errno));
8722 return;
8723 }
8724
8725 /*
8726 * Skip the first line...
8727 */
8728
8729 if (cupsFileGets(fp, line, sizeof(line)) == NULL)
8730 {
8731 cupsdLogMessage(CUPSD_LOG_ERROR,
8732 "Unable to read from print file for job ticket - %s",
8733 strerror(errno));
8734 cupsFileClose(fp);
8735 return;
8736 }
8737
8738 if (strncmp(line, "%!PS-Adobe-", 11) && strncmp(line, "%PDF-", 5))
8739 {
8740 /*
8741 * Not a DSC-compliant file, so no job ticket info will be available...
8742 */
8743
8744 cupsFileClose(fp);
8745 return;
8746 }
8747
8748 /*
8749 * Read job ticket info from the file...
8750 */
8751
8752 num_options = 0;
8753 options = NULL;
8754
8755 while (cupsFileGets(fp, line, sizeof(line)))
8756 {
8757 /*
8758 * Stop at the first non-ticket line...
8759 */
8760
8761 if (strncmp(line, "%cupsJobTicket:", 15))
8762 break;
8763
8764 /*
8765 * Add the options to the option array...
8766 */
8767
8768 num_options = cupsParseOptions(line + 15, num_options, &options);
8769 }
8770
8771 /*
8772 * Done with the file; see if we have any options...
8773 */
8774
8775 cupsFileClose(fp);
8776
8777 if (num_options == 0)
8778 return;
8779
8780 /*
8781 * OK, convert the options to an attribute list, and apply them to
8782 * the request...
8783 */
8784
8785 ticket = ippNew();
8786 cupsEncodeOptions(ticket, num_options, options);
8787
8788 /*
8789 * See what the user wants to change.
8790 */
8791
8792 for (attr = ticket->attrs; attr; attr = attr->next)
8793 {
8794 if (attr->group_tag != IPP_TAG_JOB || !attr->name)
8795 continue;
8796
8797 if (!strncmp(attr->name, "date-time-at-", 13) ||
8798 !strcmp(attr->name, "job-impressions-completed") ||
8799 !strcmp(attr->name, "job-media-sheets-completed") ||
8800 !strncmp(attr->name, "job-k-octets", 12) ||
8801 !strcmp(attr->name, "job-id") ||
8802 !strcmp(attr->name, "job-originating-host-name") ||
8803 !strcmp(attr->name, "job-originating-user-name") ||
8804 !strcmp(attr->name, "job-pages-completed") ||
8805 !strcmp(attr->name, "job-printer-uri") ||
8806 !strncmp(attr->name, "job-state", 9) ||
8807 !strcmp(attr->name, "job-uri") ||
8808 !strncmp(attr->name, "time-at-", 8))
8809 continue; /* Read-only attrs */
8810
8811 if ((attr2 = ippFindAttribute(con->request, attr->name,
8812 IPP_TAG_ZERO)) != NULL)
8813 {
8814 /*
8815 * Some other value; first free the old value...
8816 */
8817
8818 if (con->request->attrs == attr2)
8819 {
8820 con->request->attrs = attr2->next;
8821 prev2 = NULL;
8822 }
8823 else
8824 {
8825 for (prev2 = con->request->attrs; prev2; prev2 = prev2->next)
8826 if (prev2->next == attr2)
8827 {
8828 prev2->next = attr2->next;
8829 break;
8830 }
8831 }
8832
8833 if (con->request->last == attr2)
8834 con->request->last = prev2;
8835
8836 ippDeleteAttribute(NULL, attr2);
8837 }
8838
8839 /*
8840 * Add new option by copying it...
8841 */
8842
8843 ippCopyAttribute(con->request, attr, 0);
8844 }
8845
8846 /*
8847 * Then free the attribute list and option array...
8848 */
8849
8850 ippDelete(ticket);
8851 cupsFreeOptions(num_options, options);
8852 }
8853
8854
8855 /*
8856 * 'reject_jobs()' - Reject print jobs to a printer.
8857 */
8858
8859 static void
8860 reject_jobs(cupsd_client_t *con, /* I - Client connection */
8861 ipp_attribute_t *uri) /* I - Printer or class URI */
8862 {
8863 http_status_t status; /* Policy status */
8864 cups_ptype_t dtype; /* Destination type (printer/class) */
8865 cupsd_printer_t *printer; /* Printer data */
8866 ipp_attribute_t *attr; /* printer-state-message text */
8867
8868
8869 cupsdLogMessage(CUPSD_LOG_DEBUG2, "reject_jobs(%p[%d], %s)", con,
8870 con->number, uri->values[0].string.text);
8871
8872 /*
8873 * Is the destination valid?
8874 */
8875
8876 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
8877 {
8878 /*
8879 * Bad URI...
8880 */
8881
8882 send_ipp_status(con, IPP_NOT_FOUND,
8883 _("The printer or class does not exist."));
8884 return;
8885 }
8886
8887 /*
8888 * Check policy...
8889 */
8890
8891 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
8892 {
8893 send_http_error(con, status, printer);
8894 return;
8895 }
8896
8897 /*
8898 * Reject jobs sent to the printer...
8899 */
8900
8901 printer->accepting = 0;
8902
8903 if ((attr = ippFindAttribute(con->request, "printer-state-message",
8904 IPP_TAG_TEXT)) == NULL)
8905 strlcpy(printer->state_message, "Rejecting Jobs",
8906 sizeof(printer->state_message));
8907 else
8908 strlcpy(printer->state_message, attr->values[0].string.text,
8909 sizeof(printer->state_message));
8910
8911 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, printer, NULL,
8912 "No longer accepting jobs.");
8913
8914 if (dtype & CUPS_PRINTER_CLASS)
8915 {
8916 cupsdMarkDirty(CUPSD_DIRTY_CLASSES);
8917
8918 cupsdLogMessage(CUPSD_LOG_INFO, "Class \"%s\" rejecting jobs (\"%s\").",
8919 printer->name, get_username(con));
8920 }
8921 else
8922 {
8923 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
8924
8925 cupsdLogMessage(CUPSD_LOG_INFO, "Printer \"%s\" rejecting jobs (\"%s\").",
8926 printer->name, get_username(con));
8927 }
8928
8929 /*
8930 * Everything was ok, so return OK status...
8931 */
8932
8933 con->response->request.status.status_code = IPP_OK;
8934 }
8935
8936
8937 /*
8938 * 'release_held_new_jobs()' - Release pending/new jobs on a printer or class.
8939 */
8940
8941 static void
8942 release_held_new_jobs(
8943 cupsd_client_t *con, /* I - Connection */
8944 ipp_attribute_t *uri) /* I - Printer URI */
8945 {
8946 http_status_t status; /* Policy status */
8947 cups_ptype_t dtype; /* Destination type (printer/class) */
8948 cupsd_printer_t *printer; /* Printer data */
8949
8950
8951 cupsdLogMessage(CUPSD_LOG_DEBUG2, "release_held_new_jobs(%p[%d], %s)", con,
8952 con->number, uri->values[0].string.text);
8953
8954 /*
8955 * Is the destination valid?
8956 */
8957
8958 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
8959 {
8960 /*
8961 * Bad URI...
8962 */
8963
8964 send_ipp_status(con, IPP_NOT_FOUND,
8965 _("The printer or class does not exist."));
8966 return;
8967 }
8968
8969 /*
8970 * Check policy...
8971 */
8972
8973 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
8974 {
8975 send_http_error(con, status, printer);
8976 return;
8977 }
8978
8979 /*
8980 * Hold pending/new jobs sent to the printer...
8981 */
8982
8983 printer->holding_new_jobs = 0;
8984
8985 cupsdSetPrinterReasons(printer, "-hold-new-jobs");
8986
8987 if (dtype & CUPS_PRINTER_CLASS)
8988 cupsdLogMessage(CUPSD_LOG_INFO,
8989 "Class \"%s\" now printing pending/new jobs (\"%s\").",
8990 printer->name, get_username(con));
8991 else
8992 cupsdLogMessage(CUPSD_LOG_INFO,
8993 "Printer \"%s\" now printing pending/new jobs (\"%s\").",
8994 printer->name, get_username(con));
8995
8996 cupsdCheckJobs();
8997
8998 /*
8999 * Everything was ok, so return OK status...
9000 */
9001
9002 con->response->request.status.status_code = IPP_OK;
9003 }
9004
9005
9006 /*
9007 * 'release_job()' - Release a held print job.
9008 */
9009
9010 static void
9011 release_job(cupsd_client_t *con, /* I - Client connection */
9012 ipp_attribute_t *uri) /* I - Job or Printer URI */
9013 {
9014 ipp_attribute_t *attr; /* Current attribute */
9015 int jobid; /* Job ID */
9016 char scheme[HTTP_MAX_URI], /* Method portion of URI */
9017 username[HTTP_MAX_URI], /* Username portion of URI */
9018 host[HTTP_MAX_URI], /* Host portion of URI */
9019 resource[HTTP_MAX_URI]; /* Resource portion of URI */
9020 int port; /* Port portion of URI */
9021 cupsd_job_t *job; /* Job information */
9022
9023
9024 cupsdLogMessage(CUPSD_LOG_DEBUG2, "release_job(%p[%d], %s)", con,
9025 con->number, uri->values[0].string.text);
9026
9027 /*
9028 * See if we have a job URI or a printer URI...
9029 */
9030
9031 if (!strcmp(uri->name, "printer-uri"))
9032 {
9033 /*
9034 * Got a printer URI; see if we also have a job-id attribute...
9035 */
9036
9037 if ((attr = ippFindAttribute(con->request, "job-id",
9038 IPP_TAG_INTEGER)) == NULL)
9039 {
9040 send_ipp_status(con, IPP_BAD_REQUEST,
9041 _("Got a printer-uri attribute but no job-id."));
9042 return;
9043 }
9044
9045 jobid = attr->values[0].integer;
9046 }
9047 else
9048 {
9049 /*
9050 * Got a job URI; parse it to get the job ID...
9051 */
9052
9053 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
9054 sizeof(scheme), username, sizeof(username), host,
9055 sizeof(host), &port, resource, sizeof(resource));
9056
9057 if (strncmp(resource, "/jobs/", 6))
9058 {
9059 /*
9060 * Not a valid URI!
9061 */
9062
9063 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
9064 uri->values[0].string.text);
9065 return;
9066 }
9067
9068 jobid = atoi(resource + 6);
9069 }
9070
9071 /*
9072 * See if the job exists...
9073 */
9074
9075 if ((job = cupsdFindJob(jobid)) == NULL)
9076 {
9077 /*
9078 * Nope - return a "not found" error...
9079 */
9080
9081 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
9082 return;
9083 }
9084
9085 /*
9086 * See if job is "held"...
9087 */
9088
9089 if (job->state_value != IPP_JOB_HELD)
9090 {
9091 /*
9092 * Nope - return a "not possible" error...
9093 */
9094
9095 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Job #%d is not held."), jobid);
9096 return;
9097 }
9098
9099 /*
9100 * See if the job is owned by the requesting user...
9101 */
9102
9103 if (!validate_user(job, con, job->username, username, sizeof(username)))
9104 {
9105 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
9106 cupsdFindDest(job->dest));
9107 return;
9108 }
9109
9110 /*
9111 * Reset the job-hold-until value to "no-hold"...
9112 */
9113
9114 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
9115 IPP_TAG_KEYWORD)) == NULL)
9116 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
9117
9118 if (attr)
9119 {
9120 ippSetValueTag(job->attrs, &attr, IPP_TAG_KEYWORD);
9121 ippSetString(job->attrs, &attr, 0, "no-hold");
9122
9123 cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED, cupsdFindDest(job->dest), job,
9124 "Job job-hold-until value changed by user.");
9125 ippSetString(job->attrs, &job->reasons, 0, "none");
9126 }
9127
9128 /*
9129 * Release the job and return...
9130 */
9131
9132 cupsdReleaseJob(job);
9133
9134 cupsdAddEvent(CUPSD_EVENT_JOB_STATE, cupsdFindDest(job->dest), job,
9135 "Job released by user.");
9136
9137 cupsdLogJob(job, CUPSD_LOG_INFO, "Released by \"%s\".", username);
9138
9139 con->response->request.status.status_code = IPP_OK;
9140
9141 cupsdCheckJobs();
9142 }
9143
9144
9145 /*
9146 * 'renew_subscription()' - Renew an existing subscription...
9147 */
9148
9149 static void
9150 renew_subscription(
9151 cupsd_client_t *con, /* I - Client connection */
9152 int sub_id) /* I - Subscription ID */
9153 {
9154 http_status_t status; /* Policy status */
9155 cupsd_subscription_t *sub; /* Subscription */
9156 ipp_attribute_t *lease; /* notify-lease-duration */
9157
9158
9159 cupsdLogMessage(CUPSD_LOG_DEBUG2,
9160 "renew_subscription(con=%p[%d], sub_id=%d)",
9161 con, con->number, sub_id);
9162
9163 /*
9164 * Is the subscription ID valid?
9165 */
9166
9167 if ((sub = cupsdFindSubscription(sub_id)) == NULL)
9168 {
9169 /*
9170 * Bad subscription ID...
9171 */
9172
9173 send_ipp_status(con, IPP_NOT_FOUND, _("Subscription #%d does not exist."),
9174 sub_id);
9175 return;
9176 }
9177
9178 if (sub->job)
9179 {
9180 /*
9181 * Job subscriptions cannot be renewed...
9182 */
9183
9184 send_ipp_status(con, IPP_NOT_POSSIBLE,
9185 _("Job subscriptions cannot be renewed."));
9186 return;
9187 }
9188
9189 /*
9190 * Check policy...
9191 */
9192
9193 if ((status = cupsdCheckPolicy(sub->dest ? sub->dest->op_policy_ptr :
9194 DefaultPolicyPtr,
9195 con, sub->owner)) != HTTP_OK)
9196 {
9197 send_http_error(con, status, sub->dest);
9198 return;
9199 }
9200
9201 /*
9202 * Renew the subscription...
9203 */
9204
9205 lease = ippFindAttribute(con->request, "notify-lease-duration",
9206 IPP_TAG_INTEGER);
9207
9208 sub->lease = lease ? lease->values[0].integer : DefaultLeaseDuration;
9209
9210 if (MaxLeaseDuration && (sub->lease == 0 || sub->lease > MaxLeaseDuration))
9211 {
9212 cupsdLogMessage(CUPSD_LOG_INFO,
9213 "renew_subscription: Limiting notify-lease-duration to "
9214 "%d seconds.",
9215 MaxLeaseDuration);
9216 sub->lease = MaxLeaseDuration;
9217 }
9218
9219 sub->expire = sub->lease ? time(NULL) + sub->lease : 0;
9220
9221 cupsdMarkDirty(CUPSD_DIRTY_SUBSCRIPTIONS);
9222
9223 con->response->request.status.status_code = IPP_OK;
9224
9225 ippAddInteger(con->response, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
9226 "notify-lease-duration", sub->lease);
9227 }
9228
9229
9230 /*
9231 * 'restart_job()' - Restart an old print job.
9232 */
9233
9234 static void
9235 restart_job(cupsd_client_t *con, /* I - Client connection */
9236 ipp_attribute_t *uri) /* I - Job or Printer URI */
9237 {
9238 ipp_attribute_t *attr; /* Current attribute */
9239 int jobid; /* Job ID */
9240 cupsd_job_t *job; /* Job information */
9241 char scheme[HTTP_MAX_URI], /* Method portion of URI */
9242 username[HTTP_MAX_URI], /* Username portion of URI */
9243 host[HTTP_MAX_URI], /* Host portion of URI */
9244 resource[HTTP_MAX_URI]; /* Resource portion of URI */
9245 int port; /* Port portion of URI */
9246
9247
9248 cupsdLogMessage(CUPSD_LOG_DEBUG2, "restart_job(%p[%d], %s)", con,
9249 con->number, uri->values[0].string.text);
9250
9251 /*
9252 * See if we have a job URI or a printer URI...
9253 */
9254
9255 if (!strcmp(uri->name, "printer-uri"))
9256 {
9257 /*
9258 * Got a printer URI; see if we also have a job-id attribute...
9259 */
9260
9261 if ((attr = ippFindAttribute(con->request, "job-id",
9262 IPP_TAG_INTEGER)) == NULL)
9263 {
9264 send_ipp_status(con, IPP_BAD_REQUEST,
9265 _("Got a printer-uri attribute but no job-id."));
9266 return;
9267 }
9268
9269 jobid = attr->values[0].integer;
9270 }
9271 else
9272 {
9273 /*
9274 * Got a job URI; parse it to get the job ID...
9275 */
9276
9277 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
9278 sizeof(scheme), username, sizeof(username), host,
9279 sizeof(host), &port, resource, sizeof(resource));
9280
9281 if (strncmp(resource, "/jobs/", 6))
9282 {
9283 /*
9284 * Not a valid URI!
9285 */
9286
9287 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
9288 uri->values[0].string.text);
9289 return;
9290 }
9291
9292 jobid = atoi(resource + 6);
9293 }
9294
9295 /*
9296 * See if the job exists...
9297 */
9298
9299 if ((job = cupsdFindJob(jobid)) == NULL)
9300 {
9301 /*
9302 * Nope - return a "not found" error...
9303 */
9304
9305 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
9306 return;
9307 }
9308
9309 /*
9310 * See if job is in any of the "completed" states...
9311 */
9312
9313 if (job->state_value <= IPP_JOB_PROCESSING)
9314 {
9315 /*
9316 * Nope - return a "not possible" error...
9317 */
9318
9319 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Job #%d is not complete."),
9320 jobid);
9321 return;
9322 }
9323
9324 /*
9325 * See if we have retained the job files...
9326 */
9327
9328 cupsdLoadJob(job);
9329
9330 if (!job->attrs || job->num_files == 0)
9331 {
9332 /*
9333 * Nope - return a "not possible" error...
9334 */
9335
9336 send_ipp_status(con, IPP_NOT_POSSIBLE,
9337 _("Job #%d cannot be restarted - no files."), jobid);
9338 return;
9339 }
9340
9341 /*
9342 * See if the job is owned by the requesting user...
9343 */
9344
9345 if (!validate_user(job, con, job->username, username, sizeof(username)))
9346 {
9347 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
9348 cupsdFindDest(job->dest));
9349 return;
9350 }
9351
9352 /*
9353 * See if the job-hold-until attribute is specified...
9354 */
9355
9356 if ((attr = ippFindAttribute(con->request, "job-hold-until",
9357 IPP_TAG_KEYWORD)) == NULL)
9358 attr = ippFindAttribute(con->request, "job-hold-until", IPP_TAG_NAME);
9359
9360 if (attr && strcmp(attr->values[0].string.text, "no-hold"))
9361 {
9362 /*
9363 * Return the job to a held state...
9364 */
9365
9366 cupsdLogJob(job, CUPSD_LOG_DEBUG,
9367 "Restarted by \"%s\" with job-hold-until=%s.",
9368 username, attr->values[0].string.text);
9369 cupsdSetJobHoldUntil(job, attr->values[0].string.text, 0);
9370
9371 cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED | CUPSD_EVENT_JOB_STATE,
9372 NULL, job, "Job restarted by user with job-hold-until=%s",
9373 attr->values[0].string.text);
9374 }
9375 else
9376 {
9377 /*
9378 * Restart the job...
9379 */
9380
9381 cupsdRestartJob(job);
9382 cupsdCheckJobs();
9383 }
9384
9385 cupsdLogJob(job, CUPSD_LOG_INFO, "Restarted by \"%s\".", username);
9386
9387 con->response->request.status.status_code = IPP_OK;
9388 }
9389
9390
9391 /*
9392 * 'save_auth_info()' - Save authentication information for a job.
9393 */
9394
9395 static void
9396 save_auth_info(
9397 cupsd_client_t *con, /* I - Client connection */
9398 cupsd_job_t *job, /* I - Job */
9399 ipp_attribute_t *auth_info) /* I - auth-info attribute, if any */
9400 {
9401 int i; /* Looping var */
9402 char filename[1024]; /* Job authentication filename */
9403 cups_file_t *fp; /* Job authentication file */
9404 char line[65536]; /* Line for file */
9405 cupsd_printer_t *dest; /* Destination printer/class */
9406
9407
9408 /*
9409 * This function saves the in-memory authentication information for
9410 * a job so that it can be used to authenticate with a remote host.
9411 * The information is stored in a file that is readable only by the
9412 * root user. The fields are Base-64 encoded, each on a separate line,
9413 * followed by random number (up to 1024) of newlines to limit the
9414 * amount of information that is exposed.
9415 *
9416 * Because of the potential for exposing of authentication information,
9417 * this functionality is only enabled when running cupsd as root.
9418 *
9419 * This caching only works for the Basic and BasicDigest authentication
9420 * types. Digest authentication cannot be cached this way, and in
9421 * the future Kerberos authentication may make all of this obsolete.
9422 *
9423 * Authentication information is saved whenever an authenticated
9424 * Print-Job, Create-Job, or CUPS-Authenticate-Job operation is
9425 * performed.
9426 *
9427 * This information is deleted after a job is completed or canceled,
9428 * so reprints may require subsequent re-authentication.
9429 */
9430
9431 if (RunUser)
9432 return;
9433
9434 if ((dest = cupsdFindDest(job->dest)) == NULL)
9435 return;
9436
9437 /*
9438 * Create the authentication file and change permissions...
9439 */
9440
9441 snprintf(filename, sizeof(filename), "%s/a%05d", RequestRoot, job->id);
9442 if ((fp = cupsFileOpen(filename, "w")) == NULL)
9443 {
9444 cupsdLogMessage(CUPSD_LOG_ERROR,
9445 "Unable to save authentication info to \"%s\" - %s",
9446 filename, strerror(errno));
9447 return;
9448 }
9449
9450 fchown(cupsFileNumber(fp), 0, 0);
9451 fchmod(cupsFileNumber(fp), 0400);
9452
9453 cupsFilePuts(fp, "CUPSD-AUTH-V3\n");
9454
9455 for (i = 0;
9456 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
9457 i ++)
9458 cupsdClearString(job->auth_env + i);
9459
9460 if (auth_info && auth_info->num_values == dest->num_auth_info_required)
9461 {
9462 /*
9463 * Write 1 to 3 auth values...
9464 */
9465
9466 for (i = 0;
9467 i < auth_info->num_values &&
9468 i < (int)(sizeof(job->auth_env) / sizeof(job->auth_env[0]));
9469 i ++)
9470 {
9471 if (strcmp(dest->auth_info_required[i], "negotiate"))
9472 {
9473 httpEncode64_2(line, sizeof(line), auth_info->values[i].string.text, (int)strlen(auth_info->values[i].string.text));
9474 cupsFilePutConf(fp, dest->auth_info_required[i], line);
9475 }
9476 else
9477 cupsFilePutConf(fp, dest->auth_info_required[i],
9478 auth_info->values[i].string.text);
9479
9480 if (!strcmp(dest->auth_info_required[i], "username"))
9481 cupsdSetStringf(job->auth_env + i, "AUTH_USERNAME=%s",
9482 auth_info->values[i].string.text);
9483 else if (!strcmp(dest->auth_info_required[i], "domain"))
9484 cupsdSetStringf(job->auth_env + i, "AUTH_DOMAIN=%s",
9485 auth_info->values[i].string.text);
9486 else if (!strcmp(dest->auth_info_required[i], "password"))
9487 cupsdSetStringf(job->auth_env + i, "AUTH_PASSWORD=%s",
9488 auth_info->values[i].string.text);
9489 else if (!strcmp(dest->auth_info_required[i], "negotiate"))
9490 cupsdSetStringf(job->auth_env + i, "AUTH_NEGOTIATE=%s",
9491 auth_info->values[i].string.text);
9492 else
9493 i --;
9494 }
9495 }
9496 else if (auth_info && auth_info->num_values == 2 &&
9497 dest->num_auth_info_required == 1 &&
9498 !strcmp(dest->auth_info_required[0], "negotiate"))
9499 {
9500 /*
9501 * Allow fallback to username+password for Kerberized queues...
9502 */
9503
9504 httpEncode64_2(line, sizeof(line), auth_info->values[0].string.text, (int)strlen(auth_info->values[0].string.text));
9505 cupsFilePutConf(fp, "username", line);
9506
9507 cupsdSetStringf(job->auth_env + 0, "AUTH_USERNAME=%s",
9508 auth_info->values[0].string.text);
9509
9510 httpEncode64_2(line, sizeof(line), auth_info->values[1].string.text, (int)strlen(auth_info->values[1].string.text));
9511 cupsFilePutConf(fp, "password", line);
9512
9513 cupsdSetStringf(job->auth_env + 1, "AUTH_PASSWORD=%s",
9514 auth_info->values[1].string.text);
9515 }
9516 else if (con->username[0])
9517 {
9518 /*
9519 * Write the authenticated username...
9520 */
9521
9522 httpEncode64_2(line, sizeof(line), con->username, (int)strlen(con->username));
9523 cupsFilePutConf(fp, "username", line);
9524
9525 cupsdSetStringf(job->auth_env + 0, "AUTH_USERNAME=%s", con->username);
9526
9527 /*
9528 * Write the authenticated password...
9529 */
9530
9531 httpEncode64_2(line, sizeof(line), con->password, (int)strlen(con->password));
9532 cupsFilePutConf(fp, "password", line);
9533
9534 cupsdSetStringf(job->auth_env + 1, "AUTH_PASSWORD=%s", con->password);
9535 }
9536
9537 #ifdef HAVE_GSSAPI
9538 if (con->gss_uid > 0)
9539 {
9540 cupsFilePrintf(fp, "uid %d\n", (int)con->gss_uid);
9541 cupsdSetStringf(&job->auth_uid, "AUTH_UID=%d", (int)con->gss_uid);
9542 }
9543 #endif /* HAVE_GSSAPI */
9544
9545 /*
9546 * Write a random number of newlines to the end of the file...
9547 */
9548
9549 for (i = (CUPS_RAND() % 1024); i >= 0; i --)
9550 cupsFilePutChar(fp, '\n');
9551
9552 /*
9553 * Close the file and return...
9554 */
9555
9556 cupsFileClose(fp);
9557 }
9558
9559
9560 /*
9561 * 'send_document()' - Send a file to a printer or class.
9562 */
9563
9564 static void
9565 send_document(cupsd_client_t *con, /* I - Client connection */
9566 ipp_attribute_t *uri) /* I - Printer URI */
9567 {
9568 ipp_attribute_t *attr; /* Current attribute */
9569 ipp_attribute_t *format; /* Request's document-format attribute */
9570 ipp_attribute_t *jformat; /* Job's document-format attribute */
9571 const char *default_format;/* document-format-default value */
9572 int jobid; /* Job ID number */
9573 cupsd_job_t *job; /* Current job */
9574 char job_uri[HTTP_MAX_URI],
9575 /* Job URI */
9576 scheme[HTTP_MAX_URI],
9577 /* Method portion of URI */
9578 username[HTTP_MAX_URI],
9579 /* Username portion of URI */
9580 host[HTTP_MAX_URI],
9581 /* Host portion of URI */
9582 resource[HTTP_MAX_URI];
9583 /* Resource portion of URI */
9584 int port; /* Port portion of URI */
9585 mime_type_t *filetype; /* Type of file */
9586 char super[MIME_MAX_SUPER],
9587 /* Supertype of file */
9588 type[MIME_MAX_TYPE],
9589 /* Subtype of file */
9590 mimetype[MIME_MAX_SUPER + MIME_MAX_TYPE + 2];
9591 /* Textual name of mime type */
9592 char filename[1024]; /* Job filename */
9593 cupsd_printer_t *printer; /* Current printer */
9594 struct stat fileinfo; /* File information */
9595 int kbytes; /* Size of file */
9596 int compression; /* Type of compression */
9597 int start_job; /* Start the job? */
9598
9599
9600 cupsdLogMessage(CUPSD_LOG_DEBUG2, "send_document(%p[%d], %s)", con,
9601 con->number, uri->values[0].string.text);
9602
9603 /*
9604 * See if we have a job URI or a printer URI...
9605 */
9606
9607 if (!strcmp(uri->name, "printer-uri"))
9608 {
9609 /*
9610 * Got a printer URI; see if we also have a job-id attribute...
9611 */
9612
9613 if ((attr = ippFindAttribute(con->request, "job-id",
9614 IPP_TAG_INTEGER)) == NULL)
9615 {
9616 send_ipp_status(con, IPP_BAD_REQUEST,
9617 _("Got a printer-uri attribute but no job-id."));
9618 return;
9619 }
9620
9621 jobid = attr->values[0].integer;
9622 }
9623 else
9624 {
9625 /*
9626 * Got a job URI; parse it to get the job ID...
9627 */
9628
9629 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
9630 sizeof(scheme), username, sizeof(username), host,
9631 sizeof(host), &port, resource, sizeof(resource));
9632
9633 if (strncmp(resource, "/jobs/", 6))
9634 {
9635 /*
9636 * Not a valid URI!
9637 */
9638
9639 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
9640 uri->values[0].string.text);
9641 return;
9642 }
9643
9644 jobid = atoi(resource + 6);
9645 }
9646
9647 /*
9648 * See if the job exists...
9649 */
9650
9651 if ((job = cupsdFindJob(jobid)) == NULL)
9652 {
9653 /*
9654 * Nope - return a "not found" error...
9655 */
9656
9657 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
9658 return;
9659 }
9660
9661 printer = cupsdFindDest(job->dest);
9662
9663 /*
9664 * See if the job is owned by the requesting user...
9665 */
9666
9667 if (!validate_user(job, con, job->username, username, sizeof(username)))
9668 {
9669 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
9670 cupsdFindDest(job->dest));
9671 return;
9672 }
9673
9674 /*
9675 * OK, see if the client is sending the document compressed - CUPS
9676 * only supports "none" and "gzip".
9677 */
9678
9679 compression = CUPS_FILE_NONE;
9680
9681 if ((attr = ippFindAttribute(con->request, "compression",
9682 IPP_TAG_KEYWORD)) != NULL)
9683 {
9684 if (strcmp(attr->values[0].string.text, "none")
9685 #ifdef HAVE_LIBZ
9686 && strcmp(attr->values[0].string.text, "gzip")
9687 #endif /* HAVE_LIBZ */
9688 )
9689 {
9690 send_ipp_status(con, IPP_ATTRIBUTES, _("Unsupported compression \"%s\"."),
9691 attr->values[0].string.text);
9692 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_KEYWORD,
9693 "compression", NULL, attr->values[0].string.text);
9694 return;
9695 }
9696
9697 #ifdef HAVE_LIBZ
9698 if (!strcmp(attr->values[0].string.text, "gzip"))
9699 compression = CUPS_FILE_GZIP;
9700 #endif /* HAVE_LIBZ */
9701 }
9702
9703 /*
9704 * Do we have a file to print?
9705 */
9706
9707 if ((attr = ippFindAttribute(con->request, "last-document",
9708 IPP_TAG_BOOLEAN)) == NULL)
9709 {
9710 send_ipp_status(con, IPP_BAD_REQUEST,
9711 _("Missing last-document attribute in request."));
9712 return;
9713 }
9714
9715 if (!con->filename)
9716 {
9717 /*
9718 * Check for an empty request with "last-document" set to true, which is
9719 * used to close an "open" job by RFC 2911, section 3.3.2.
9720 */
9721
9722 if (job->num_files > 0 && attr->values[0].boolean)
9723 goto last_document;
9724
9725 send_ipp_status(con, IPP_BAD_REQUEST, _("No file in print request."));
9726 return;
9727 }
9728
9729 /*
9730 * Is it a format we support?
9731 */
9732
9733 cupsdLoadJob(job);
9734
9735 if ((format = ippFindAttribute(con->request, "document-format",
9736 IPP_TAG_MIMETYPE)) != NULL)
9737 {
9738 /*
9739 * Grab format from client...
9740 */
9741
9742 if (sscanf(format->values[0].string.text, "%15[^/]/%255[^;]",
9743 super, type) != 2)
9744 {
9745 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad document-format \"%s\"."),
9746 format->values[0].string.text);
9747 return;
9748 }
9749
9750 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format-supplied", NULL, ippGetString(format, 0, NULL));
9751 }
9752 else if ((default_format = cupsGetOption("document-format",
9753 printer->num_options,
9754 printer->options)) != NULL)
9755 {
9756 /*
9757 * Use default document format...
9758 */
9759
9760 if (sscanf(default_format, "%15[^/]/%255[^;]", super, type) != 2)
9761 {
9762 send_ipp_status(con, IPP_BAD_REQUEST,
9763 _("Bad document-format-default \"%s\"."), default_format);
9764 return;
9765 }
9766 }
9767 else
9768 {
9769 /*
9770 * No document format attribute? Auto-type it!
9771 */
9772
9773 strlcpy(super, "application", sizeof(super));
9774 strlcpy(type, "octet-stream", sizeof(type));
9775 }
9776
9777 if (!strcmp(super, "application") && !strcmp(type, "octet-stream"))
9778 {
9779 /*
9780 * Auto-type the file...
9781 */
9782
9783 ipp_attribute_t *doc_name; /* document-name attribute */
9784
9785
9786 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Auto-typing file...");
9787
9788 doc_name = ippFindAttribute(con->request, "document-name", IPP_TAG_NAME);
9789 filetype = mimeFileType(MimeDatabase, con->filename,
9790 doc_name ? doc_name->values[0].string.text : NULL,
9791 &compression);
9792
9793 if (!filetype)
9794 filetype = mimeType(MimeDatabase, super, type);
9795
9796 if (filetype)
9797 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Request file type is %s/%s.",
9798 filetype->super, filetype->type);
9799
9800 snprintf(mimetype, sizeof(mimetype), "%s/%s", filetype->super, filetype->type);
9801 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format-detected", NULL, mimetype);
9802 }
9803 else
9804 filetype = mimeType(MimeDatabase, super, type);
9805
9806 if (filetype)
9807 {
9808 /*
9809 * Replace the document-format attribute value with the auto-typed or
9810 * default one.
9811 */
9812
9813 snprintf(mimetype, sizeof(mimetype), "%s/%s", filetype->super,
9814 filetype->type);
9815
9816 if ((jformat = ippFindAttribute(job->attrs, "document-format",
9817 IPP_TAG_MIMETYPE)) != NULL)
9818 ippSetString(job->attrs, &jformat, 0, mimetype);
9819 else
9820 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_MIMETYPE,
9821 "document-format", NULL, mimetype);
9822 }
9823 else if (!filetype)
9824 {
9825 send_ipp_status(con, IPP_DOCUMENT_FORMAT,
9826 _("Unsupported document-format \"%s/%s\"."), super, type);
9827 cupsdLogMessage(CUPSD_LOG_INFO,
9828 "Hint: Do you have the raw file printing rules enabled?");
9829
9830 if (format)
9831 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_MIMETYPE,
9832 "document-format", NULL, format->values[0].string.text);
9833
9834 return;
9835 }
9836
9837 if (printer->filetypes && !cupsArrayFind(printer->filetypes, filetype))
9838 {
9839 snprintf(mimetype, sizeof(mimetype), "%s/%s", filetype->super,
9840 filetype->type);
9841
9842 send_ipp_status(con, IPP_DOCUMENT_FORMAT,
9843 _("Unsupported document-format \"%s\"."), mimetype);
9844
9845 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_MIMETYPE,
9846 "document-format", NULL, mimetype);
9847
9848 return;
9849 }
9850
9851 /*
9852 * Add the file to the job...
9853 */
9854
9855 if (add_file(con, job, filetype, compression))
9856 return;
9857
9858 if ((attr = ippFindAttribute(con->request, "document-name", IPP_TAG_NAME)) != NULL)
9859 ippAddString(job->attrs, IPP_TAG_JOB, IPP_TAG_NAME, "document-name-supplied", NULL, ippGetString(attr, 0, NULL));
9860
9861 if (stat(con->filename, &fileinfo))
9862 kbytes = 0;
9863 else
9864 kbytes = (fileinfo.st_size + 1023) / 1024;
9865
9866 cupsdUpdateQuota(printer, job->username, 0, kbytes);
9867
9868 job->koctets += kbytes;
9869
9870 if ((attr = ippFindAttribute(job->attrs, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
9871 attr->values[0].integer += kbytes;
9872
9873 snprintf(filename, sizeof(filename), "%s/d%05d-%03d", RequestRoot, job->id, job->num_files);
9874 if (rename(con->filename, filename))
9875 {
9876 cupsdLogJob(job, CUPSD_LOG_ERROR, "Unable to rename job document file \"%s\": %s", filename, strerror(errno));
9877
9878 send_ipp_status(con, IPP_INTERNAL_ERROR, _("Unable to rename job document file."));
9879 return;
9880 }
9881
9882 cupsdClearString(&con->filename);
9883
9884 cupsdLogJob(job, CUPSD_LOG_INFO, "File of type %s/%s queued by \"%s\".",
9885 filetype->super, filetype->type, job->username);
9886
9887 /*
9888 * Start the job if this is the last document...
9889 */
9890
9891 last_document:
9892
9893 if ((attr = ippFindAttribute(con->request, "last-document",
9894 IPP_TAG_BOOLEAN)) != NULL &&
9895 attr->values[0].boolean)
9896 {
9897 /*
9898 * See if we need to add the ending sheet...
9899 */
9900
9901 if (cupsdTimeoutJob(job))
9902 return;
9903
9904 if (job->state_value == IPP_JOB_STOPPED)
9905 {
9906 job->state->values[0].integer = IPP_JOB_PENDING;
9907 job->state_value = IPP_JOB_PENDING;
9908
9909 ippSetString(job->attrs, &job->reasons, 0, "none");
9910 }
9911 else if (job->state_value == IPP_JOB_HELD)
9912 {
9913 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
9914 IPP_TAG_KEYWORD)) == NULL)
9915 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
9916
9917 if (!attr || !strcmp(attr->values[0].string.text, "no-hold"))
9918 {
9919 job->state->values[0].integer = IPP_JOB_PENDING;
9920 job->state_value = IPP_JOB_PENDING;
9921
9922 ippSetString(job->attrs, &job->reasons, 0, "none");
9923 }
9924 else
9925 ippSetString(job->attrs, &job->reasons, 0, "job-hold-until-specified");
9926 }
9927
9928 job->dirty = 1;
9929 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
9930
9931 start_job = 1;
9932 }
9933 else
9934 {
9935 if ((attr = ippFindAttribute(job->attrs, "job-hold-until",
9936 IPP_TAG_KEYWORD)) == NULL)
9937 attr = ippFindAttribute(job->attrs, "job-hold-until", IPP_TAG_NAME);
9938
9939 if (!attr || !strcmp(attr->values[0].string.text, "no-hold"))
9940 {
9941 job->state->values[0].integer = IPP_JOB_HELD;
9942 job->state_value = IPP_JOB_HELD;
9943 job->hold_until = time(NULL) + MultipleOperationTimeout;
9944
9945 ippSetString(job->attrs, &job->reasons, 0, "job-incoming");
9946
9947 job->dirty = 1;
9948 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
9949 }
9950
9951 start_job = 0;
9952 }
9953
9954 /*
9955 * Fill in the response info...
9956 */
9957
9958 httpAssembleURIf(HTTP_URI_CODING_ALL, job_uri, sizeof(job_uri), "ipp", NULL,
9959 con->clientname, con->clientport, "/jobs/%d", jobid);
9960 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_URI, "job-uri", NULL,
9961 job_uri);
9962
9963 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-id", jobid);
9964
9965 ippAddInteger(con->response, IPP_TAG_JOB, IPP_TAG_ENUM, "job-state",
9966 job->state_value);
9967 ippAddString(con->response, IPP_TAG_JOB, IPP_TAG_KEYWORD, "job-state-reasons",
9968 NULL, job->reasons->values[0].string.text);
9969
9970 con->response->request.status.status_code = IPP_OK;
9971
9972 /*
9973 * Start the job if necessary...
9974 */
9975
9976 if (start_job)
9977 cupsdCheckJobs();
9978 }
9979
9980
9981 /*
9982 * 'send_http_error()' - Send a HTTP error back to the IPP client.
9983 */
9984
9985 static void
9986 send_http_error(
9987 cupsd_client_t *con, /* I - Client connection */
9988 http_status_t status, /* I - HTTP status code */
9989 cupsd_printer_t *printer) /* I - Printer, if any */
9990 {
9991 ipp_attribute_t *uri; /* Request URI, if any */
9992
9993
9994 if ((uri = ippFindAttribute(con->request, "printer-uri",
9995 IPP_TAG_URI)) == NULL)
9996 uri = ippFindAttribute(con->request, "job-uri", IPP_TAG_URI);
9997
9998 cupsdLogMessage(status == HTTP_FORBIDDEN ? CUPSD_LOG_ERROR : CUPSD_LOG_DEBUG,
9999 "[Client %d] Returning HTTP %s for %s (%s) from %s",
10000 con->number, httpStatus(status),
10001 con->request ?
10002 ippOpString(con->request->request.op.operation_id) :
10003 "no operation-id",
10004 uri ? uri->values[0].string.text : "no URI",
10005 con->http->hostname);
10006
10007 if (printer)
10008 {
10009 int auth_type; /* Type of authentication required */
10010
10011
10012 auth_type = CUPSD_AUTH_NONE;
10013
10014 if (status == HTTP_UNAUTHORIZED &&
10015 printer->num_auth_info_required > 0 &&
10016 !strcmp(printer->auth_info_required[0], "negotiate") &&
10017 con->request &&
10018 (con->request->request.op.operation_id == IPP_PRINT_JOB ||
10019 con->request->request.op.operation_id == IPP_CREATE_JOB ||
10020 con->request->request.op.operation_id == CUPS_AUTHENTICATE_JOB))
10021 {
10022 /*
10023 * Creating and authenticating jobs requires Kerberos...
10024 */
10025
10026 auth_type = CUPSD_AUTH_NEGOTIATE;
10027 }
10028 else
10029 {
10030 /*
10031 * Use policy/location-defined authentication requirements...
10032 */
10033
10034 char resource[HTTP_MAX_URI]; /* Resource portion of URI */
10035 cupsd_location_t *auth; /* Pointer to authentication element */
10036
10037
10038 if (printer->type & CUPS_PRINTER_CLASS)
10039 snprintf(resource, sizeof(resource), "/classes/%s", printer->name);
10040 else
10041 snprintf(resource, sizeof(resource), "/printers/%s", printer->name);
10042
10043 if ((auth = cupsdFindBest(resource, HTTP_POST)) == NULL ||
10044 auth->type == CUPSD_AUTH_NONE)
10045 auth = cupsdFindPolicyOp(printer->op_policy_ptr,
10046 con->request ?
10047 con->request->request.op.operation_id :
10048 IPP_PRINT_JOB);
10049
10050 if (auth)
10051 {
10052 if (auth->type == CUPSD_AUTH_DEFAULT)
10053 auth_type = cupsdDefaultAuthType();
10054 else
10055 auth_type = auth->type;
10056 }
10057 }
10058
10059 cupsdSendError(con, status, auth_type);
10060 }
10061 else
10062 cupsdSendError(con, status, CUPSD_AUTH_NONE);
10063
10064 ippDelete(con->response);
10065 con->response = NULL;
10066
10067 return;
10068 }
10069
10070
10071 /*
10072 * 'send_ipp_status()' - Send a status back to the IPP client.
10073 */
10074
10075 static void
10076 send_ipp_status(cupsd_client_t *con, /* I - Client connection */
10077 ipp_status_t status, /* I - IPP status code */
10078 const char *message,/* I - Status message */
10079 ...) /* I - Additional args as needed */
10080 {
10081 va_list ap; /* Pointer to additional args */
10082 char formatted[1024]; /* Formatted errror message */
10083
10084
10085 va_start(ap, message);
10086 vsnprintf(formatted, sizeof(formatted),
10087 _cupsLangString(con->language, message), ap);
10088 va_end(ap);
10089
10090 cupsdLogMessage(CUPSD_LOG_DEBUG, "%s %s: %s",
10091 ippOpString(con->request->request.op.operation_id),
10092 ippErrorString(status), formatted);
10093
10094 con->response->request.status.status_code = status;
10095
10096 if (ippFindAttribute(con->response, "attributes-charset",
10097 IPP_TAG_ZERO) == NULL)
10098 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
10099 "attributes-charset", NULL, "utf-8");
10100
10101 if (ippFindAttribute(con->response, "attributes-natural-language",
10102 IPP_TAG_ZERO) == NULL)
10103 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
10104 "attributes-natural-language", NULL, DefaultLanguage);
10105
10106 ippAddString(con->response, IPP_TAG_OPERATION, IPP_TAG_TEXT,
10107 "status-message", NULL, formatted);
10108 }
10109
10110
10111 /*
10112 * 'set_default()' - Set the default destination...
10113 */
10114
10115 static void
10116 set_default(cupsd_client_t *con, /* I - Client connection */
10117 ipp_attribute_t *uri) /* I - Printer URI */
10118 {
10119 http_status_t status; /* Policy status */
10120 cups_ptype_t dtype; /* Destination type (printer/class) */
10121 cupsd_printer_t *printer, /* Printer */
10122 *oldprinter; /* Old default printer */
10123
10124
10125 cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_default(%p[%d], %s)", con,
10126 con->number, uri->values[0].string.text);
10127
10128 /*
10129 * Is the destination valid?
10130 */
10131
10132 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
10133 {
10134 /*
10135 * Bad URI...
10136 */
10137
10138 send_ipp_status(con, IPP_NOT_FOUND,
10139 _("The printer or class does not exist."));
10140 return;
10141 }
10142
10143 /*
10144 * Check policy...
10145 */
10146
10147 if ((status = cupsdCheckPolicy(DefaultPolicyPtr, con, NULL)) != HTTP_OK)
10148 {
10149 send_http_error(con, status, NULL);
10150 return;
10151 }
10152
10153 /*
10154 * Set it as the default...
10155 */
10156
10157 oldprinter = DefaultPrinter;
10158 DefaultPrinter = printer;
10159
10160 if (oldprinter)
10161 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, oldprinter, NULL,
10162 "%s is no longer the default printer.", oldprinter->name);
10163
10164 cupsdAddEvent(CUPSD_EVENT_PRINTER_STATE, printer, NULL,
10165 "%s is now the default printer.", printer->name);
10166
10167 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS | CUPSD_DIRTY_CLASSES |
10168 CUPSD_DIRTY_PRINTCAP);
10169
10170 cupsdLogMessage(CUPSD_LOG_INFO,
10171 "Default destination set to \"%s\" by \"%s\".",
10172 printer->name, get_username(con));
10173
10174 /*
10175 * Everything was ok, so return OK status...
10176 */
10177
10178 con->response->request.status.status_code = IPP_OK;
10179 }
10180
10181
10182 /*
10183 * 'set_job_attrs()' - Set job attributes.
10184 */
10185
10186 static void
10187 set_job_attrs(cupsd_client_t *con, /* I - Client connection */
10188 ipp_attribute_t *uri) /* I - Job URI */
10189 {
10190 ipp_attribute_t *attr, /* Current attribute */
10191 *attr2; /* Job attribute */
10192 int jobid; /* Job ID */
10193 cupsd_job_t *job; /* Current job */
10194 char scheme[HTTP_MAX_URI],
10195 /* Method portion of URI */
10196 username[HTTP_MAX_URI],
10197 /* Username portion of URI */
10198 host[HTTP_MAX_URI],
10199 /* Host portion of URI */
10200 resource[HTTP_MAX_URI];
10201 /* Resource portion of URI */
10202 int port; /* Port portion of URI */
10203 int event; /* Events? */
10204 int check_jobs; /* Check jobs? */
10205
10206
10207 cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_job_attrs(%p[%d], %s)", con,
10208 con->number, uri->values[0].string.text);
10209
10210 /*
10211 * Start with "everything is OK" status...
10212 */
10213
10214 con->response->request.status.status_code = IPP_OK;
10215
10216 /*
10217 * See if we have a job URI or a printer URI...
10218 */
10219
10220 if (!strcmp(uri->name, "printer-uri"))
10221 {
10222 /*
10223 * Got a printer URI; see if we also have a job-id attribute...
10224 */
10225
10226 if ((attr = ippFindAttribute(con->request, "job-id",
10227 IPP_TAG_INTEGER)) == NULL)
10228 {
10229 send_ipp_status(con, IPP_BAD_REQUEST,
10230 _("Got a printer-uri attribute but no job-id."));
10231 return;
10232 }
10233
10234 jobid = attr->values[0].integer;
10235 }
10236 else
10237 {
10238 /*
10239 * Got a job URI; parse it to get the job ID...
10240 */
10241
10242 httpSeparateURI(HTTP_URI_CODING_ALL, uri->values[0].string.text, scheme,
10243 sizeof(scheme), username, sizeof(username), host,
10244 sizeof(host), &port, resource, sizeof(resource));
10245
10246 if (strncmp(resource, "/jobs/", 6))
10247 {
10248 /*
10249 * Not a valid URI!
10250 */
10251
10252 send_ipp_status(con, IPP_BAD_REQUEST, _("Bad job-uri \"%s\"."),
10253 uri->values[0].string.text);
10254 return;
10255 }
10256
10257 jobid = atoi(resource + 6);
10258 }
10259
10260 /*
10261 * See if the job exists...
10262 */
10263
10264 if ((job = cupsdFindJob(jobid)) == NULL)
10265 {
10266 /*
10267 * Nope - return a "not found" error...
10268 */
10269
10270 send_ipp_status(con, IPP_NOT_FOUND, _("Job #%d does not exist."), jobid);
10271 return;
10272 }
10273
10274 /*
10275 * See if the job has been completed...
10276 */
10277
10278 if (job->state_value > IPP_JOB_STOPPED)
10279 {
10280 /*
10281 * Return a "not-possible" error...
10282 */
10283
10284 send_ipp_status(con, IPP_NOT_POSSIBLE,
10285 _("Job #%d is finished and cannot be altered."), jobid);
10286 return;
10287 }
10288
10289 /*
10290 * See if the job is owned by the requesting user...
10291 */
10292
10293 if (!validate_user(job, con, job->username, username, sizeof(username)))
10294 {
10295 send_http_error(con, con->username[0] ? HTTP_FORBIDDEN : HTTP_UNAUTHORIZED,
10296 cupsdFindDest(job->dest));
10297 return;
10298 }
10299
10300 /*
10301 * See what the user wants to change.
10302 */
10303
10304 cupsdLoadJob(job);
10305
10306 check_jobs = 0;
10307 event = 0;
10308
10309 for (attr = con->request->attrs; attr; attr = attr->next)
10310 {
10311 if (attr->group_tag != IPP_TAG_JOB || !attr->name)
10312 continue;
10313
10314 if (!strcmp(attr->name, "attributes-charset") ||
10315 !strcmp(attr->name, "attributes-natural-language") ||
10316 !strncmp(attr->name, "date-time-at-", 13) ||
10317 !strncmp(attr->name, "document-compression", 20) ||
10318 !strncmp(attr->name, "document-format", 15) ||
10319 !strcmp(attr->name, "job-detailed-status-messages") ||
10320 !strcmp(attr->name, "job-document-access-errors") ||
10321 !strcmp(attr->name, "job-id") ||
10322 !strcmp(attr->name, "job-impressions-completed") ||
10323 !strcmp(attr->name, "job-k-octets-completed") ||
10324 !strcmp(attr->name, "job-media-sheets-completed") ||
10325 !strcmp(attr->name, "job-originating-host-name") ||
10326 !strcmp(attr->name, "job-originating-user-name") ||
10327 !strcmp(attr->name, "job-pages-completed") ||
10328 !strcmp(attr->name, "job-printer-up-time") ||
10329 !strcmp(attr->name, "job-printer-uri") ||
10330 !strcmp(attr->name, "job-sheets") ||
10331 !strcmp(attr->name, "job-state-message") ||
10332 !strcmp(attr->name, "job-state-reasons") ||
10333 !strcmp(attr->name, "job-uri") ||
10334 !strcmp(attr->name, "number-of-documents") ||
10335 !strcmp(attr->name, "number-of-intervening-jobs") ||
10336 !strcmp(attr->name, "output-device-assigned") ||
10337 !strncmp(attr->name, "time-at-", 8))
10338 {
10339 /*
10340 * Read-only attrs!
10341 */
10342
10343 send_ipp_status(con, IPP_ATTRIBUTES_NOT_SETTABLE,
10344 _("%s cannot be changed."), attr->name);
10345
10346 attr2 = ippCopyAttribute(con->response, attr, 0);
10347 ippSetGroupTag(con->response, &attr2, IPP_TAG_UNSUPPORTED_GROUP);
10348 continue;
10349 }
10350
10351 if (!ippValidateAttribute(attr))
10352 {
10353 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Bad '%s' value."), attr->name);
10354 ippCopyAttribute(con->response, attr, 0);
10355 return;
10356 }
10357
10358 if (!strcmp(attr->name, "job-hold-until"))
10359 {
10360 const char *when = ippGetString(attr, 0, NULL);
10361 /* job-hold-until value */
10362
10363 if ((ippGetValueTag(attr) != IPP_TAG_KEYWORD && ippGetValueTag(attr) != IPP_TAG_NAME && ippGetValueTag(attr) != IPP_TAG_NAMELANG) || ippGetCount(attr) != 1)
10364 {
10365 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Unsupported 'job-hold-until' value."));
10366 ippCopyAttribute(con->response, attr, 0);
10367 return;
10368 }
10369
10370 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Setting job-hold-until to %s", when);
10371 cupsdSetJobHoldUntil(job, when, 0);
10372
10373 if (!strcmp(when, "no-hold"))
10374 {
10375 cupsdReleaseJob(job);
10376 check_jobs = 1;
10377 }
10378 else
10379 cupsdSetJobState(job, IPP_JOB_HELD, CUPSD_JOB_DEFAULT, "Job held by \"%s\".", username);
10380
10381 event |= CUPSD_EVENT_JOB_CONFIG_CHANGED | CUPSD_EVENT_JOB_STATE;
10382 }
10383 else if (!strcmp(attr->name, "job-priority"))
10384 {
10385 /*
10386 * Change the job priority...
10387 */
10388
10389 if (attr->value_tag != IPP_TAG_INTEGER)
10390 {
10391 send_ipp_status(con, IPP_REQUEST_VALUE, _("Bad job-priority value."));
10392
10393 attr2 = ippCopyAttribute(con->response, attr, 0);
10394 ippSetGroupTag(con->response, &attr2, IPP_TAG_UNSUPPORTED_GROUP);
10395 }
10396 else if (job->state_value >= IPP_JOB_PROCESSING)
10397 {
10398 send_ipp_status(con, IPP_NOT_POSSIBLE,
10399 _("Job is completed and cannot be changed."));
10400 return;
10401 }
10402 else if (con->response->request.status.status_code == IPP_OK)
10403 {
10404 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Setting job-priority to %d",
10405 attr->values[0].integer);
10406 cupsdSetJobPriority(job, attr->values[0].integer);
10407
10408 check_jobs = 1;
10409 event |= CUPSD_EVENT_JOB_CONFIG_CHANGED |
10410 CUPSD_EVENT_PRINTER_QUEUE_ORDER_CHANGED;
10411 }
10412 }
10413 else if (!strcmp(attr->name, "job-state"))
10414 {
10415 /*
10416 * Change the job state...
10417 */
10418
10419 if (attr->value_tag != IPP_TAG_ENUM)
10420 {
10421 send_ipp_status(con, IPP_REQUEST_VALUE, _("Bad job-state value."));
10422
10423 attr2 = ippCopyAttribute(con->response, attr, 0);
10424 ippSetGroupTag(con->response, &attr2, IPP_TAG_UNSUPPORTED_GROUP);
10425 }
10426 else
10427 {
10428 switch (attr->values[0].integer)
10429 {
10430 case IPP_JOB_PENDING :
10431 case IPP_JOB_HELD :
10432 if (job->state_value > IPP_JOB_HELD)
10433 {
10434 send_ipp_status(con, IPP_NOT_POSSIBLE,
10435 _("Job state cannot be changed."));
10436 return;
10437 }
10438 else if (con->response->request.status.status_code == IPP_OK)
10439 {
10440 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Setting job-state to %d",
10441 attr->values[0].integer);
10442 cupsdSetJobState(job, (ipp_jstate_t)attr->values[0].integer, CUPSD_JOB_DEFAULT, "Job state changed by \"%s\"", username);
10443 check_jobs = 1;
10444 }
10445 break;
10446
10447 case IPP_JOB_PROCESSING :
10448 case IPP_JOB_STOPPED :
10449 if (job->state_value != attr->values[0].integer)
10450 {
10451 send_ipp_status(con, IPP_NOT_POSSIBLE,
10452 _("Job state cannot be changed."));
10453 return;
10454 }
10455 break;
10456
10457 case IPP_JOB_CANCELED :
10458 case IPP_JOB_ABORTED :
10459 case IPP_JOB_COMPLETED :
10460 if (job->state_value > IPP_JOB_PROCESSING)
10461 {
10462 send_ipp_status(con, IPP_NOT_POSSIBLE,
10463 _("Job state cannot be changed."));
10464 return;
10465 }
10466 else if (con->response->request.status.status_code == IPP_OK)
10467 {
10468 cupsdLogJob(job, CUPSD_LOG_DEBUG, "Setting job-state to %d",
10469 attr->values[0].integer);
10470 cupsdSetJobState(job, (ipp_jstate_t)attr->values[0].integer,
10471 CUPSD_JOB_DEFAULT,
10472 "Job state changed by \"%s\"", username);
10473 check_jobs = 1;
10474 }
10475 break;
10476 }
10477 }
10478 }
10479 else if (con->response->request.status.status_code != IPP_OK)
10480 continue;
10481 else if ((attr2 = ippFindAttribute(job->attrs, attr->name,
10482 IPP_TAG_ZERO)) != NULL)
10483 {
10484 /*
10485 * Some other value; first free the old value...
10486 */
10487
10488 if (job->attrs->prev)
10489 job->attrs->prev->next = attr2->next;
10490 else
10491 job->attrs->attrs = attr2->next;
10492
10493 if (job->attrs->last == attr2)
10494 job->attrs->last = job->attrs->prev;
10495
10496 ippDeleteAttribute(NULL, attr2);
10497
10498 /*
10499 * Then copy the attribute...
10500 */
10501
10502 ippCopyAttribute(job->attrs, attr, 0);
10503 }
10504 else if (attr->value_tag == IPP_TAG_DELETEATTR)
10505 {
10506 /*
10507 * Delete the attribute...
10508 */
10509
10510 if ((attr2 = ippFindAttribute(job->attrs, attr->name,
10511 IPP_TAG_ZERO)) != NULL)
10512 {
10513 if (job->attrs->prev)
10514 job->attrs->prev->next = attr2->next;
10515 else
10516 job->attrs->attrs = attr2->next;
10517
10518 if (attr2 == job->attrs->last)
10519 job->attrs->last = job->attrs->prev;
10520
10521 ippDeleteAttribute(NULL, attr2);
10522
10523 event |= CUPSD_EVENT_JOB_CONFIG_CHANGED;
10524 }
10525 }
10526 else
10527 {
10528 /*
10529 * Add new option by copying it...
10530 */
10531
10532 ippCopyAttribute(job->attrs, attr, 0);
10533
10534 event |= CUPSD_EVENT_JOB_CONFIG_CHANGED;
10535 }
10536 }
10537
10538 /*
10539 * Save the job...
10540 */
10541
10542 job->dirty = 1;
10543 cupsdMarkDirty(CUPSD_DIRTY_JOBS);
10544
10545 /*
10546 * Send events as needed...
10547 */
10548
10549 if (event & CUPSD_EVENT_PRINTER_QUEUE_ORDER_CHANGED)
10550 cupsdAddEvent(CUPSD_EVENT_PRINTER_QUEUE_ORDER_CHANGED,
10551 cupsdFindDest(job->dest), job,
10552 "Job priority changed by user.");
10553
10554 if (event & CUPSD_EVENT_JOB_STATE)
10555 cupsdAddEvent(CUPSD_EVENT_JOB_STATE, cupsdFindDest(job->dest), job,
10556 job->state_value == IPP_JOB_HELD ?
10557 "Job held by user." : "Job restarted by user.");
10558
10559 if (event & CUPSD_EVENT_JOB_CONFIG_CHANGED)
10560 cupsdAddEvent(CUPSD_EVENT_JOB_CONFIG_CHANGED, cupsdFindDest(job->dest), job,
10561 "Job options changed by user.");
10562
10563 /*
10564 * Start jobs if possible...
10565 */
10566
10567 if (check_jobs)
10568 cupsdCheckJobs();
10569 }
10570
10571
10572 /*
10573 * 'set_printer_attrs()' - Set printer attributes.
10574 */
10575
10576 static void
10577 set_printer_attrs(cupsd_client_t *con, /* I - Client connection */
10578 ipp_attribute_t *uri) /* I - Printer */
10579 {
10580 http_status_t status; /* Policy status */
10581 cups_ptype_t dtype; /* Destination type (printer/class) */
10582 cupsd_printer_t *printer; /* Printer/class */
10583 ipp_attribute_t *attr; /* Printer attribute */
10584 int changed = 0; /* Was anything changed? */
10585
10586
10587 cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_printer_attrs(%p[%d], %s)", con,
10588 con->number, uri->values[0].string.text);
10589
10590 /*
10591 * Is the destination valid?
10592 */
10593
10594 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
10595 {
10596 /*
10597 * Bad URI...
10598 */
10599
10600 send_ipp_status(con, IPP_NOT_FOUND,
10601 _("The printer or class does not exist."));
10602 return;
10603 }
10604
10605 /*
10606 * Check policy...
10607 */
10608
10609 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
10610 {
10611 send_http_error(con, status, printer);
10612 return;
10613 }
10614
10615 /*
10616 * Return a list of attributes that can be set via Set-Printer-Attributes.
10617 */
10618
10619 if ((attr = ippFindAttribute(con->request, "printer-location",
10620 IPP_TAG_TEXT)) != NULL)
10621 {
10622 cupsdSetString(&printer->location, attr->values[0].string.text);
10623 changed = 1;
10624 }
10625
10626 if ((attr = ippFindAttribute(con->request, "printer-geo-location", IPP_TAG_URI)) != NULL && !strncmp(attr->values[0].string.text, "geo:", 4))
10627 {
10628 cupsdSetString(&printer->geo_location, attr->values[0].string.text);
10629 changed = 1;
10630 }
10631
10632 if ((attr = ippFindAttribute(con->request, "printer-organization", IPP_TAG_TEXT)) != NULL)
10633 {
10634 cupsdSetString(&printer->organization, attr->values[0].string.text);
10635 changed = 1;
10636 }
10637
10638 if ((attr = ippFindAttribute(con->request, "printer-organizational-unit", IPP_TAG_TEXT)) != NULL)
10639 {
10640 cupsdSetString(&printer->organizational_unit, attr->values[0].string.text);
10641 changed = 1;
10642 }
10643
10644 if ((attr = ippFindAttribute(con->request, "printer-info",
10645 IPP_TAG_TEXT)) != NULL)
10646 {
10647 cupsdSetString(&printer->info, attr->values[0].string.text);
10648 changed = 1;
10649 }
10650
10651 /*
10652 * Update the printer attributes and return...
10653 */
10654
10655 if (changed)
10656 {
10657 printer->config_time = time(NULL);
10658
10659 cupsdSetPrinterAttrs(printer);
10660 cupsdMarkDirty(CUPSD_DIRTY_PRINTERS);
10661
10662 cupsdAddEvent(CUPSD_EVENT_PRINTER_CONFIG, printer, NULL,
10663 "Printer \"%s\" description or location changed by \"%s\".",
10664 printer->name, get_username(con));
10665
10666 cupsdLogMessage(CUPSD_LOG_INFO,
10667 "Printer \"%s\" description or location changed by \"%s\".",
10668 printer->name, get_username(con));
10669 }
10670
10671 con->response->request.status.status_code = IPP_OK;
10672 }
10673
10674
10675 /*
10676 * 'set_printer_defaults()' - Set printer default options from a request.
10677 */
10678
10679 static int /* O - 1 on success, 0 on failure */
10680 set_printer_defaults(
10681 cupsd_client_t *con, /* I - Client connection */
10682 cupsd_printer_t *printer) /* I - Printer */
10683 {
10684 int i; /* Looping var */
10685 ipp_attribute_t *attr; /* Current attribute */
10686 size_t namelen; /* Length of attribute name */
10687 char name[256], /* New attribute name */
10688 value[256]; /* String version of integer attrs */
10689
10690
10691 for (attr = con->request->attrs; attr; attr = attr->next)
10692 {
10693 /*
10694 * Skip non-printer attributes...
10695 */
10696
10697 if (attr->group_tag != IPP_TAG_PRINTER || !attr->name)
10698 continue;
10699
10700 cupsdLogMessage(CUPSD_LOG_DEBUG2, "set_printer_defaults: %s", attr->name);
10701
10702 if (!strcmp(attr->name, "job-sheets-default"))
10703 {
10704 /*
10705 * Only allow keywords and names...
10706 */
10707
10708 if (attr->value_tag != IPP_TAG_NAME && attr->value_tag != IPP_TAG_KEYWORD)
10709 continue;
10710
10711 /*
10712 * Only allow job-sheets-default to be set when running without a
10713 * system high classification level...
10714 */
10715
10716 if (Classification)
10717 continue;
10718
10719 cupsdSetString(&printer->job_sheets[0], attr->values[0].string.text);
10720
10721 if (attr->num_values > 1)
10722 cupsdSetString(&printer->job_sheets[1], attr->values[1].string.text);
10723 else
10724 cupsdSetString(&printer->job_sheets[1], "none");
10725 }
10726 else if (!strcmp(attr->name, "requesting-user-name-allowed"))
10727 {
10728 cupsdFreeStrings(&(printer->users));
10729
10730 printer->deny_users = 0;
10731
10732 if (attr->value_tag == IPP_TAG_NAME &&
10733 (attr->num_values > 1 ||
10734 strcmp(attr->values[0].string.text, "all")))
10735 {
10736 for (i = 0; i < attr->num_values; i ++)
10737 cupsdAddString(&(printer->users), attr->values[i].string.text);
10738 }
10739 }
10740 else if (!strcmp(attr->name, "requesting-user-name-denied"))
10741 {
10742 cupsdFreeStrings(&(printer->users));
10743
10744 printer->deny_users = 1;
10745
10746 if (attr->value_tag == IPP_TAG_NAME &&
10747 (attr->num_values > 1 ||
10748 strcmp(attr->values[0].string.text, "none")))
10749 {
10750 for (i = 0; i < attr->num_values; i ++)
10751 cupsdAddString(&(printer->users), attr->values[i].string.text);
10752 }
10753 }
10754 else if (!strcmp(attr->name, "job-quota-period"))
10755 {
10756 if (attr->value_tag != IPP_TAG_INTEGER)
10757 continue;
10758
10759 cupsdLogMessage(CUPSD_LOG_DEBUG, "Setting job-quota-period to %d...",
10760 attr->values[0].integer);
10761 cupsdFreeQuotas(printer);
10762
10763 printer->quota_period = attr->values[0].integer;
10764 }
10765 else if (!strcmp(attr->name, "job-k-limit"))
10766 {
10767 if (attr->value_tag != IPP_TAG_INTEGER)
10768 continue;
10769
10770 cupsdLogMessage(CUPSD_LOG_DEBUG, "Setting job-k-limit to %d...",
10771 attr->values[0].integer);
10772 cupsdFreeQuotas(printer);
10773
10774 printer->k_limit = attr->values[0].integer;
10775 }
10776 else if (!strcmp(attr->name, "job-page-limit"))
10777 {
10778 if (attr->value_tag != IPP_TAG_INTEGER)
10779 continue;
10780
10781 cupsdLogMessage(CUPSD_LOG_DEBUG, "Setting job-page-limit to %d...",
10782 attr->values[0].integer);
10783 cupsdFreeQuotas(printer);
10784
10785 printer->page_limit = attr->values[0].integer;
10786 }
10787 else if (!strcmp(attr->name, "printer-op-policy"))
10788 {
10789 cupsd_policy_t *p; /* Policy */
10790
10791
10792 if (attr->value_tag != IPP_TAG_NAME)
10793 continue;
10794
10795 if ((p = cupsdFindPolicy(attr->values[0].string.text)) != NULL)
10796 {
10797 cupsdLogMessage(CUPSD_LOG_DEBUG,
10798 "Setting printer-op-policy to \"%s\"...",
10799 attr->values[0].string.text);
10800 cupsdSetString(&printer->op_policy, attr->values[0].string.text);
10801 printer->op_policy_ptr = p;
10802 }
10803 else
10804 {
10805 send_ipp_status(con, IPP_NOT_POSSIBLE,
10806 _("Unknown printer-op-policy \"%s\"."),
10807 attr->values[0].string.text);
10808 return (0);
10809 }
10810 }
10811 else if (!strcmp(attr->name, "printer-error-policy"))
10812 {
10813 if (attr->value_tag != IPP_TAG_NAME && attr->value_tag != IPP_TAG_KEYWORD)
10814 continue;
10815
10816 if (strcmp(attr->values[0].string.text, "retry-current-job") &&
10817 ((printer->type & CUPS_PRINTER_CLASS) ||
10818 (strcmp(attr->values[0].string.text, "abort-job") &&
10819 strcmp(attr->values[0].string.text, "retry-job") &&
10820 strcmp(attr->values[0].string.text, "stop-printer"))))
10821 {
10822 send_ipp_status(con, IPP_NOT_POSSIBLE,
10823 _("Unknown printer-error-policy \"%s\"."),
10824 attr->values[0].string.text);
10825 return (0);
10826 }
10827
10828 cupsdLogMessage(CUPSD_LOG_DEBUG,
10829 "Setting printer-error-policy to \"%s\"...",
10830 attr->values[0].string.text);
10831 cupsdSetString(&printer->error_policy, attr->values[0].string.text);
10832 }
10833
10834 /*
10835 * Skip any other non-default attributes...
10836 */
10837
10838 namelen = strlen(attr->name);
10839 if (namelen < 9 || strcmp(attr->name + namelen - 8, "-default") ||
10840 namelen > (sizeof(name) - 1) || attr->num_values != 1)
10841 continue;
10842
10843 /*
10844 * OK, anything else must be a user-defined default...
10845 */
10846
10847 strlcpy(name, attr->name, sizeof(name));
10848 name[namelen - 8] = '\0'; /* Strip "-default" */
10849
10850 switch (attr->value_tag)
10851 {
10852 case IPP_TAG_DELETEATTR :
10853 printer->num_options = cupsRemoveOption(name,
10854 printer->num_options,
10855 &(printer->options));
10856 cupsdLogMessage(CUPSD_LOG_DEBUG,
10857 "Deleting %s", attr->name);
10858 break;
10859
10860 case IPP_TAG_NAME :
10861 case IPP_TAG_TEXT :
10862 case IPP_TAG_KEYWORD :
10863 case IPP_TAG_URI :
10864 printer->num_options = cupsAddOption(name,
10865 attr->values[0].string.text,
10866 printer->num_options,
10867 &(printer->options));
10868 cupsdLogMessage(CUPSD_LOG_DEBUG,
10869 "Setting %s to \"%s\"...", attr->name,
10870 attr->values[0].string.text);
10871 break;
10872
10873 case IPP_TAG_BOOLEAN :
10874 printer->num_options = cupsAddOption(name,
10875 attr->values[0].boolean ?
10876 "true" : "false",
10877 printer->num_options,
10878 &(printer->options));
10879 cupsdLogMessage(CUPSD_LOG_DEBUG,
10880 "Setting %s to %s...", attr->name,
10881 attr->values[0].boolean ? "true" : "false");
10882 break;
10883
10884 case IPP_TAG_INTEGER :
10885 case IPP_TAG_ENUM :
10886 sprintf(value, "%d", attr->values[0].integer);
10887 printer->num_options = cupsAddOption(name, value,
10888 printer->num_options,
10889 &(printer->options));
10890 cupsdLogMessage(CUPSD_LOG_DEBUG,
10891 "Setting %s to %s...", attr->name, value);
10892 break;
10893
10894 case IPP_TAG_RANGE :
10895 sprintf(value, "%d-%d", attr->values[0].range.lower,
10896 attr->values[0].range.upper);
10897 printer->num_options = cupsAddOption(name, value,
10898 printer->num_options,
10899 &(printer->options));
10900 cupsdLogMessage(CUPSD_LOG_DEBUG,
10901 "Setting %s to %s...", attr->name, value);
10902 break;
10903
10904 case IPP_TAG_RESOLUTION :
10905 sprintf(value, "%dx%d%s", attr->values[0].resolution.xres,
10906 attr->values[0].resolution.yres,
10907 attr->values[0].resolution.units == IPP_RES_PER_INCH ?
10908 "dpi" : "dpcm");
10909 printer->num_options = cupsAddOption(name, value,
10910 printer->num_options,
10911 &(printer->options));
10912 cupsdLogMessage(CUPSD_LOG_DEBUG,
10913 "Setting %s to %s...", attr->name, value);
10914 break;
10915
10916 default :
10917 /* Do nothing for other values */
10918 break;
10919 }
10920 }
10921
10922 return (1);
10923 }
10924
10925
10926 /*
10927 * 'start_printer()' - Start a printer.
10928 */
10929
10930 static void
10931 start_printer(cupsd_client_t *con, /* I - Client connection */
10932 ipp_attribute_t *uri) /* I - Printer URI */
10933 {
10934 int i; /* Temporary variable */
10935 http_status_t status; /* Policy status */
10936 cups_ptype_t dtype; /* Destination type (printer/class) */
10937 cupsd_printer_t *printer; /* Printer data */
10938
10939
10940 cupsdLogMessage(CUPSD_LOG_DEBUG2, "start_printer(%p[%d], %s)", con,
10941 con->number, uri->values[0].string.text);
10942
10943 /*
10944 * Is the destination valid?
10945 */
10946
10947 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
10948 {
10949 /*
10950 * Bad URI...
10951 */
10952
10953 send_ipp_status(con, IPP_NOT_FOUND,
10954 _("The printer or class does not exist."));
10955 return;
10956 }
10957
10958 /*
10959 * Check policy...
10960 */
10961
10962 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
10963 {
10964 send_http_error(con, status, printer);
10965 return;
10966 }
10967
10968 /*
10969 * Start the printer...
10970 */
10971
10972 printer->state_message[0] = '\0';
10973
10974 cupsdStartPrinter(printer, 1);
10975
10976 if (dtype & CUPS_PRINTER_CLASS)
10977 cupsdLogMessage(CUPSD_LOG_INFO, "Class \"%s\" started by \"%s\".",
10978 printer->name, get_username(con));
10979 else
10980 cupsdLogMessage(CUPSD_LOG_INFO, "Printer \"%s\" started by \"%s\".",
10981 printer->name, get_username(con));
10982
10983 cupsdCheckJobs();
10984
10985 /*
10986 * Check quotas...
10987 */
10988
10989 if ((i = check_quotas(con, printer)) < 0)
10990 {
10991 send_ipp_status(con, IPP_NOT_POSSIBLE, _("Quota limit reached."));
10992 return;
10993 }
10994 else if (i == 0)
10995 {
10996 send_ipp_status(con, IPP_NOT_AUTHORIZED, _("Not allowed to print."));
10997 return;
10998 }
10999
11000 /*
11001 * Everything was ok, so return OK status...
11002 */
11003
11004 con->response->request.status.status_code = IPP_OK;
11005 }
11006
11007
11008 /*
11009 * 'stop_printer()' - Stop a printer.
11010 */
11011
11012 static void
11013 stop_printer(cupsd_client_t *con, /* I - Client connection */
11014 ipp_attribute_t *uri) /* I - Printer URI */
11015 {
11016 http_status_t status; /* Policy status */
11017 cups_ptype_t dtype; /* Destination type (printer/class) */
11018 cupsd_printer_t *printer; /* Printer data */
11019 ipp_attribute_t *attr; /* printer-state-message attribute */
11020
11021
11022 cupsdLogMessage(CUPSD_LOG_DEBUG2, "stop_printer(%p[%d], %s)", con,
11023 con->number, uri->values[0].string.text);
11024
11025 /*
11026 * Is the destination valid?
11027 */
11028
11029 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
11030 {
11031 /*
11032 * Bad URI...
11033 */
11034
11035 send_ipp_status(con, IPP_NOT_FOUND,
11036 _("The printer or class does not exist."));
11037 return;
11038 }
11039
11040 /*
11041 * Check policy...
11042 */
11043
11044 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
11045 {
11046 send_http_error(con, status, printer);
11047 return;
11048 }
11049
11050 /*
11051 * Stop the printer...
11052 */
11053
11054 if ((attr = ippFindAttribute(con->request, "printer-state-message",
11055 IPP_TAG_TEXT)) == NULL)
11056 strlcpy(printer->state_message, "Paused", sizeof(printer->state_message));
11057 else
11058 {
11059 strlcpy(printer->state_message, attr->values[0].string.text,
11060 sizeof(printer->state_message));
11061 }
11062
11063 cupsdStopPrinter(printer, 1);
11064
11065 if (dtype & CUPS_PRINTER_CLASS)
11066 cupsdLogMessage(CUPSD_LOG_INFO, "Class \"%s\" stopped by \"%s\".",
11067 printer->name, get_username(con));
11068 else
11069 cupsdLogMessage(CUPSD_LOG_INFO, "Printer \"%s\" stopped by \"%s\".",
11070 printer->name, get_username(con));
11071
11072 /*
11073 * Everything was ok, so return OK status...
11074 */
11075
11076 con->response->request.status.status_code = IPP_OK;
11077 }
11078
11079
11080 /*
11081 * 'url_encode_attr()' - URL-encode a string attribute.
11082 */
11083
11084 static void
11085 url_encode_attr(ipp_attribute_t *attr, /* I - Attribute */
11086 char *buffer,/* I - String buffer */
11087 size_t bufsize)/* I - Size of buffer */
11088 {
11089 int i; /* Looping var */
11090 char *bufptr, /* Pointer into buffer */
11091 *bufend; /* End of buffer */
11092
11093
11094 strlcpy(buffer, attr->name, bufsize);
11095 bufptr = buffer + strlen(buffer);
11096 bufend = buffer + bufsize - 1;
11097
11098 for (i = 0; i < attr->num_values; i ++)
11099 {
11100 if (bufptr >= bufend)
11101 break;
11102
11103 if (i)
11104 *bufptr++ = ',';
11105 else
11106 *bufptr++ = '=';
11107
11108 if (bufptr >= bufend)
11109 break;
11110
11111 *bufptr++ = '\'';
11112
11113 bufptr = url_encode_string(attr->values[i].string.text, bufptr, (size_t)(bufend - bufptr + 1));
11114
11115 if (bufptr >= bufend)
11116 break;
11117
11118 *bufptr++ = '\'';
11119 }
11120
11121 *bufptr = '\0';
11122 }
11123
11124
11125 /*
11126 * 'url_encode_string()' - URL-encode a string.
11127 */
11128
11129 static char * /* O - End of string */
11130 url_encode_string(const char *s, /* I - String */
11131 char *buffer, /* I - String buffer */
11132 size_t bufsize) /* I - Size of buffer */
11133 {
11134 char *bufptr, /* Pointer into buffer */
11135 *bufend; /* End of buffer */
11136 static const char *hex = "0123456789ABCDEF";
11137 /* Hex digits */
11138
11139
11140 bufptr = buffer;
11141 bufend = buffer + bufsize - 1;
11142
11143 while (*s && bufptr < bufend)
11144 {
11145 if (*s == ' ' || *s == '%' || *s == '+')
11146 {
11147 if (bufptr >= (bufend - 2))
11148 break;
11149
11150 *bufptr++ = '%';
11151 *bufptr++ = hex[(*s >> 4) & 15];
11152 *bufptr++ = hex[*s & 15];
11153
11154 s ++;
11155 }
11156 else if (*s == '\'' || *s == '\\')
11157 {
11158 if (bufptr >= (bufend - 1))
11159 break;
11160
11161 *bufptr++ = '\\';
11162 *bufptr++ = *s++;
11163 }
11164 else
11165 *bufptr++ = *s++;
11166 }
11167
11168 *bufptr = '\0';
11169
11170 return (bufptr);
11171 }
11172
11173
11174 /*
11175 * 'user_allowed()' - See if a user is allowed to print to a queue.
11176 */
11177
11178 static int /* O - 0 if not allowed, 1 if allowed */
11179 user_allowed(cupsd_printer_t *p, /* I - Printer or class */
11180 const char *username) /* I - Username */
11181 {
11182 struct passwd *pw; /* User password data */
11183 char baseuser[256], /* Base username */
11184 *baseptr, /* Pointer to "@" in base username */
11185 *name; /* Current user name */
11186
11187
11188 if (cupsArrayCount(p->users) == 0)
11189 return (1);
11190
11191 if (!strcmp(username, "root"))
11192 return (1);
11193
11194 if (strchr(username, '@'))
11195 {
11196 /*
11197 * Strip @REALM for username check...
11198 */
11199
11200 strlcpy(baseuser, username, sizeof(baseuser));
11201
11202 if ((baseptr = strchr(baseuser, '@')) != NULL)
11203 *baseptr = '\0';
11204
11205 username = baseuser;
11206 }
11207
11208 pw = getpwnam(username);
11209 endpwent();
11210
11211 for (name = (char *)cupsArrayFirst(p->users);
11212 name;
11213 name = (char *)cupsArrayNext(p->users))
11214 {
11215 if (name[0] == '@')
11216 {
11217 /*
11218 * Check group membership...
11219 */
11220
11221 if (cupsdCheckGroup(username, pw, name + 1))
11222 break;
11223 }
11224 else if (name[0] == '#')
11225 {
11226 /*
11227 * Check UUID...
11228 */
11229
11230 if (cupsdCheckGroup(username, pw, name))
11231 break;
11232 }
11233 else if (!_cups_strcasecmp(username, name))
11234 break;
11235 }
11236
11237 return ((name != NULL) != p->deny_users);
11238 }
11239
11240
11241 /*
11242 * 'validate_job()' - Validate printer options and destination.
11243 */
11244
11245 static void
11246 validate_job(cupsd_client_t *con, /* I - Client connection */
11247 ipp_attribute_t *uri) /* I - Printer URI */
11248 {
11249 http_status_t status; /* Policy status */
11250 ipp_attribute_t *attr; /* Current attribute */
11251 #ifdef HAVE_SSL
11252 ipp_attribute_t *auth_info; /* auth-info attribute */
11253 #endif /* HAVE_SSL */
11254 ipp_attribute_t *format, /* Document-format attribute */
11255 *name; /* Job-name attribute */
11256 cups_ptype_t dtype; /* Destination type (printer/class) */
11257 char super[MIME_MAX_SUPER],
11258 /* Supertype of file */
11259 type[MIME_MAX_TYPE];
11260 /* Subtype of file */
11261 cupsd_printer_t *printer; /* Printer */
11262
11263
11264 cupsdLogMessage(CUPSD_LOG_DEBUG2, "validate_job(%p[%d], %s)", con,
11265 con->number, uri->values[0].string.text);
11266
11267 /*
11268 * OK, see if the client is sending the document compressed - CUPS
11269 * doesn't support compression yet...
11270 */
11271
11272 if ((attr = ippFindAttribute(con->request, "compression",
11273 IPP_TAG_KEYWORD)) != NULL)
11274 {
11275 if (strcmp(attr->values[0].string.text, "none")
11276 #ifdef HAVE_LIBZ
11277 && strcmp(attr->values[0].string.text, "gzip")
11278 #endif /* HAVE_LIBZ */
11279 )
11280 {
11281 send_ipp_status(con, IPP_ATTRIBUTES,
11282 _("Unsupported 'compression' value \"%s\"."),
11283 attr->values[0].string.text);
11284 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_KEYWORD,
11285 "compression", NULL, attr->values[0].string.text);
11286 return;
11287 }
11288 }
11289
11290 /*
11291 * Is it a format we support?
11292 */
11293
11294 if ((format = ippFindAttribute(con->request, "document-format",
11295 IPP_TAG_MIMETYPE)) != NULL)
11296 {
11297 if (sscanf(format->values[0].string.text, "%15[^/]/%255[^;]",
11298 super, type) != 2)
11299 {
11300 send_ipp_status(con, IPP_BAD_REQUEST,
11301 _("Bad 'document-format' value \"%s\"."),
11302 format->values[0].string.text);
11303 return;
11304 }
11305
11306 if ((strcmp(super, "application") || strcmp(type, "octet-stream")) &&
11307 !mimeType(MimeDatabase, super, type))
11308 {
11309 cupsdLogMessage(CUPSD_LOG_INFO,
11310 "Hint: Do you have the raw file printing rules enabled?");
11311 send_ipp_status(con, IPP_DOCUMENT_FORMAT,
11312 _("Unsupported 'document-format' value \"%s\"."),
11313 format->values[0].string.text);
11314 ippAddString(con->response, IPP_TAG_UNSUPPORTED_GROUP, IPP_TAG_MIMETYPE,
11315 "document-format", NULL, format->values[0].string.text);
11316 return;
11317 }
11318 }
11319
11320 /*
11321 * Is the job-hold-until value valid?
11322 */
11323
11324 if ((attr = ippFindAttribute(con->request, "job-hold-until", IPP_TAG_ZERO)) != NULL && ((ippGetValueTag(attr) != IPP_TAG_KEYWORD && ippGetValueTag(attr) != IPP_TAG_NAME && ippGetValueTag(attr) != IPP_TAG_NAMELANG) || ippGetCount(attr) != 1 || !ippValidateAttribute(attr)))
11325 {
11326 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Unsupported 'job-hold-until' value."));
11327 ippCopyAttribute(con->response, attr, 0);
11328 return;
11329 }
11330
11331 /*
11332 * Is the job-name valid?
11333 */
11334
11335 if ((name = ippFindAttribute(con->request, "job-name", IPP_TAG_ZERO)) != NULL)
11336 {
11337 if ((name->value_tag != IPP_TAG_NAME && name->value_tag != IPP_TAG_NAMELANG) ||
11338 name->num_values != 1 || !ippValidateAttribute(name))
11339 {
11340 if (StrictConformance)
11341 {
11342 send_ipp_status(con, IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES, _("Unsupported 'job-name' value."));
11343 ippCopyAttribute(con->response, name, 0);
11344 return;
11345 }
11346 else
11347 {
11348 cupsdLogMessage(CUPSD_LOG_WARN, "Unsupported 'job-name' value, deleting from request.");
11349 ippDeleteAttribute(con->request, name);
11350 }
11351 }
11352 }
11353
11354 /*
11355 * Is the destination valid?
11356 */
11357
11358 if (!cupsdValidateDest(uri->values[0].string.text, &dtype, &printer))
11359 {
11360 /*
11361 * Bad URI...
11362 */
11363
11364 send_ipp_status(con, IPP_NOT_FOUND,
11365 _("The printer or class does not exist."));
11366 return;
11367 }
11368
11369 /*
11370 * Check policy...
11371 */
11372
11373 #ifdef HAVE_SSL
11374 auth_info = ippFindAttribute(con->request, "auth-info", IPP_TAG_TEXT);
11375 #endif /* HAVE_SSL */
11376
11377 if ((status = cupsdCheckPolicy(printer->op_policy_ptr, con, NULL)) != HTTP_OK)
11378 {
11379 send_http_error(con, status, printer);
11380 return;
11381 }
11382 else if (printer->num_auth_info_required == 1 &&
11383 !strcmp(printer->auth_info_required[0], "negotiate") &&
11384 !con->username[0])
11385 {
11386 send_http_error(con, HTTP_UNAUTHORIZED, printer);
11387 return;
11388 }
11389 #ifdef HAVE_SSL
11390 else if (auth_info && !con->http->tls &&
11391 !httpAddrLocalhost(con->http->hostaddr))
11392 {
11393 /*
11394 * Require encryption of auth-info over non-local connections...
11395 */
11396
11397 send_http_error(con, HTTP_UPGRADE_REQUIRED, printer);
11398 return;
11399 }
11400 #endif /* HAVE_SSL */
11401
11402 /*
11403 * Everything was ok, so return OK status...
11404 */
11405
11406 con->response->request.status.status_code = IPP_OK;
11407 }
11408
11409
11410 /*
11411 * 'validate_name()' - Make sure the printer name only contains valid chars.
11412 */
11413
11414 static int /* O - 0 if name is no good, 1 if good */
11415 validate_name(const char *name) /* I - Name to check */
11416 {
11417 const char *ptr; /* Pointer into name */
11418
11419
11420 /*
11421 * Scan the whole name...
11422 */
11423
11424 for (ptr = name; *ptr; ptr ++)
11425 if ((*ptr > 0 && *ptr <= ' ') || *ptr == 127 || *ptr == '/' || *ptr == '#')
11426 return (0);
11427
11428 /*
11429 * All the characters are good; validate the length, too...
11430 */
11431
11432 return ((ptr - name) < 128);
11433 }
11434
11435
11436 /*
11437 * 'validate_user()' - Validate the user for the request.
11438 */
11439
11440 static int /* O - 1 if permitted, 0 otherwise */
11441 validate_user(cupsd_job_t *job, /* I - Job */
11442 cupsd_client_t *con, /* I - Client connection */
11443 const char *owner, /* I - Owner of job/resource */
11444 char *username, /* O - Authenticated username */
11445 size_t userlen) /* I - Length of username */
11446 {
11447 cupsd_printer_t *printer; /* Printer for job */
11448
11449
11450 cupsdLogMessage(CUPSD_LOG_DEBUG2, "validate_user(job=%d, con=%d, owner=\"%s\", username=%p, userlen=" CUPS_LLFMT ")", job->id, con ? con->number : 0, owner ? owner : "(null)", username, CUPS_LLCAST userlen);
11451
11452 /*
11453 * Validate input...
11454 */
11455
11456 if (!con || !owner || !username || userlen <= 0)
11457 return (0);
11458
11459 /*
11460 * Get the best authenticated username that is available.
11461 */
11462
11463 strlcpy(username, get_username(con), userlen);
11464
11465 /*
11466 * Check the username against the owner...
11467 */
11468
11469 printer = cupsdFindDest(job->dest);
11470
11471 return (cupsdCheckPolicy(printer ? printer->op_policy_ptr : DefaultPolicyPtr,
11472 con, owner) == HTTP_OK);
11473 }
Unnamed repository; edit this file 'description' to name the repository.