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