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