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