?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nfs4acls: Introduce a helper variable
[Samba.git] / source3 / printing / print_iprint.c
blob1c9e5a25922780993bf10a0f1fc5c112e7df4c3f
1 /*
2 * Support code for Novell iPrint using the Common UNIX Printing
3 * System ("CUPS") libraries
4 *
5 * Copyright 1999-2003 by Michael R Sweet.
6 * Portions Copyright 2005 by Joel J. Smith.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "printing.h"
24 #include "printing/pcap.h"
25
26 #ifdef HAVE_IPRINT
27 #include <cups/cups.h>
28 #include <cups/language.h>
29
30 #define OPERATION_NOVELL_LIST_PRINTERS 0x401A
31 #define OPERATION_NOVELL_MGMT 0x401C
32 #define NOVELL_SERVER_SYSNAME "sysname="
33 #define NOVELL_SERVER_SYSNAME_NETWARE "NetWare IA32"
34 #define NOVELL_SERVER_VERSION_STRING "iprintserverversion="
35 #define NOVELL_SERVER_VERSION_OES_SP1 33554432
36
37 #if (CUPS_VERSION_MAJOR > 1) || (CUPS_VERSION_MINOR > 5)
38 #define HAVE_CUPS_1_6 1
39 #endif
40
41 #ifndef HAVE_CUPS_1_6
42 #define ippGetCount(attr) attr->num_values
43 #define ippGetGroupTag(attr) attr->group_tag
44 #define ippGetName(attr) attr->name
45 #define ippGetValueTag(attr) attr->value_tag
46 #define ippGetStatusCode(ipp) ipp->request.status.status_code
47 #define ippGetBoolean(attr, element) attr->values[element].boolean
48 #define ippGetInteger(attr, element) attr->values[element].integer
49 #define ippGetString(attr, element, language) attr->values[element].string.text
50
51 static ipp_attribute_t *
52 ippFirstAttribute(ipp_t *ipp)
53 {
54 if (!ipp)
55 return (NULL);
56 return (ipp->current = ipp->attrs);
57 }
58
59 static ipp_attribute_t *
60 ippNextAttribute(ipp_t *ipp)
61 {
62 if (!ipp || !ipp->current)
63 return (NULL);
64 return (ipp->current = ipp->current->next);
65 }
66
67 static int ippSetOperation(ipp_t *ipp, ipp_op_t op)
68 {
69 ipp->request.op.operation_id = op;
70 return (1);
71 }
72
73 static int ippSetRequestId(ipp_t *ipp, int request_id)
74 {
75 ipp->request.any.request_id = request_id;
76 return (1);
77 }
78 #endif
79
80 /*
81 * 'iprint_passwd_cb()' - The iPrint password callback...
82 */
83
84 static const char * /* O - Password or NULL */
85 iprint_passwd_cb(const char *prompt) /* I - Prompt */
86 {
87 /*
88 * Always return NULL to indicate that no password is available...
89 */
90
91 return (NULL);
92 }
93
94 static const char *iprint_server(void)
95 {
96 const char *server = lp_iprint_server(talloc_tos());
97
98 if ((server != NULL) && (strlen(server) > 0)) {
99 DEBUG(10, ("iprint server explicitly set to %s\n",
100 server));
101 return server;
102 }
103
104 DEBUG(10, ("iprint server left to default %s\n", cupsServer()));
105 return cupsServer();
106 }
107
108 /*
109 * Pass in an already connected http_t*
110 * Returns the server version if one can be found, multiplied by
111 * -1 for all NetWare versions. Returns 0 if a server version
112 * cannot be determined
113 */
114
115 static int iprint_get_server_version(http_t *http, char* serviceUri)
116 {
117 ipp_t *request = NULL, /* IPP Request */
118 *response = NULL; /* IPP Response */
119 ipp_attribute_t *attr; /* Current attribute */
120 cups_lang_t *language = NULL; /* Default language */
121 char *ver; /* server version pointer */
122 char *vertmp; /* server version tmp pointer */
123 int serverVersion = 0; /* server version */
124 char *os; /* server os */
125 int osFlag = 0; /* 0 for NetWare, 1 for anything else */
126 char *temp; /* pointer for string manipulation */
127
128 /*
129 * Build an OPERATION_NOVELL_MGMT("get-server-version") request,
130 * which requires the following attributes:
131 *
132 * attributes-charset
133 * attributes-natural-language
134 * operation-name
135 * service-uri
136 */
137
138 request = ippNew();
139
140 ippSetOperation(request, (ipp_op_t)OPERATION_NOVELL_MGMT);
141 ippSetRequestId(request, 1);
142
143 language = cupsLangDefault();
144
145 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
146 "attributes-charset", NULL, "utf-8");
147
148 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
149 "attributes-natural-language", NULL, language->language);
150
151 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
152 "service-uri", NULL, serviceUri);
153
154 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
155 "operation-name", NULL, "get-server-version");
156
157 /*
158 * Do the request and get back a response...
159 */
160
161 if (((response = cupsDoRequest(http, request, "/ipp/")) == NULL) ||
162 (ippGetStatusCode(response) >= IPP_OK_CONFLICT))
163 goto out;
164
165 if (((attr = ippFindAttribute(response, "server-version",
166 IPP_TAG_STRING)) != NULL)) {
167 if ((ver = strstr(ippGetString(attr, 0, NULL),
168 NOVELL_SERVER_VERSION_STRING)) != NULL) {
169 ver += strlen(NOVELL_SERVER_VERSION_STRING);
170 /*
171 * Strangely, libcups stores a IPP_TAG_STRING (octet
172 * string) as a null-terminated string with no length
173 * even though it could be binary data with nulls in
174 * it. Luckily, in this case the value is not binary.
175 */
176 serverVersion = strtol(ver, &vertmp, 10);
177
178 /* Check for not found, overflow or negative version */
179 if ((ver == vertmp) || (serverVersion < 0))
180 serverVersion = 0;
181 }
182
183 if ((os = strstr(ippGetString(attr, 0, NULL),
184 NOVELL_SERVER_SYSNAME)) != NULL) {
185 os += strlen(NOVELL_SERVER_SYSNAME);
186 if ((temp = strchr(os,'<')) != NULL)
187 *temp = '\0';
188 if (strcmp(os,NOVELL_SERVER_SYSNAME_NETWARE))
189 osFlag = 1; /* 1 for non-NetWare systems */
190 }
191 }
192
193 out:
194 if (response)
195 ippDelete(response);
196
197 if (language)
198 cupsLangFree(language);
199
200 if (osFlag == 0)
201 serverVersion *= -1;
202
203 return serverVersion;
204 }
205
206
207 static int iprint_cache_add_printer(http_t *http,
208 int reqId,
209 const char *url,
210 struct pcap_cache **pcache)
211 {
212 ipp_t *request = NULL, /* IPP Request */
213 *response = NULL; /* IPP Response */
214 ipp_attribute_t *attr; /* Current attribute */
215 cups_lang_t *language = NULL; /* Default language */
216 const char *name, /* printer-name attribute */
217 *info; /* printer-info attribute */
218 char smb_enabled, /* smb-enabled attribute */
219 secure; /* security-enabled attrib. */
220
221 const char *httpPath; /* path portion of the printer-uri */
222
223 static const char *pattrs[] = /* Requested printer attributes */
224 {
225 "printer-name",
226 "security-enabled",
227 "printer-info",
228 "smb-enabled"
229 };
230
231 request = ippNew();
232
233 ippSetOperation(request, IPP_GET_PRINTER_ATTRIBUTES);
234 ippSetRequestId(request, reqId);
235
236 language = cupsLangDefault();
237
238 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
239 "attributes-charset", NULL, "utf-8");
240
241 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
242 "attributes-natural-language", NULL, language->language);
243
244 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, url);
245
246 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
247 "requested-attributes",
248 (sizeof(pattrs) / sizeof(pattrs[0])),
249 NULL, pattrs);
250
251 /*
252 * Do the request and get back a response...
253 */
254
255 if ((httpPath = strstr(url,"://")) == NULL ||
256 (httpPath = strchr(httpPath+3,'/')) == NULL)
257 {
258 ippDelete(request);
259 request = NULL;
260 goto out;
261 }
262
263 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
264 ipp_status_t lastErr = cupsLastError();
265
266 /*
267 * Ignore printers that cannot be queried without credentials
268 */
269 if (lastErr == IPP_FORBIDDEN ||
270 lastErr == IPP_NOT_AUTHENTICATED ||
271 lastErr == IPP_NOT_AUTHORIZED)
272 goto out;
273
274 DEBUG(0,("Unable to get printer list - %s\n",
275 ippErrorString(lastErr)));
276 goto out;
277 }
278
279 for (attr = ippFirstAttribute(response); attr != NULL;) {
280 /*
281 * Skip leading attributes until we hit a printer...
282 */
283
284 while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER)
285 attr = ippNextAttribute(response);
286
287 if (attr == NULL)
288 break;
289
290 /*
291 * Pull the needed attributes from this printer...
292 */
293
294 name = NULL;
295 info = NULL;
296 smb_enabled= 1;
297 secure = 0;
298
299 while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER) {
300 if (strcmp(ippGetName(attr), "printer-name") == 0 &&
301 ippGetValueTag(attr) == IPP_TAG_NAME)
302 name = ippGetString(attr, 0, NULL);
303
304 if (strcmp(ippGetName(attr), "printer-info") == 0 &&
305 (ippGetValueTag(attr) == IPP_TAG_TEXT ||
306 ippGetValueTag(attr) == IPP_TAG_TEXTLANG))
307 info = ippGetString(attr, 0, NULL);
308
309 /*
310 * If the smb-enabled attribute is present and the
311 * value is set to 0, don't show the printer.
312 * If the attribute is not present, assume that the
313 * printer should show up
314 */
315 if (!strcmp(ippGetName(attr), "smb-enabled") &&
316 ((ippGetValueTag(attr) == IPP_TAG_INTEGER &&
317 !ippGetInteger(attr, 0)) ||
318 (ippGetValueTag(attr) == IPP_TAG_BOOLEAN &&
319 !ippGetBoolean(attr, 0))))
320 smb_enabled = 0;
321
322 /*
323 * If the security-enabled attribute is present and the
324 * value is set to 1, don't show the printer.
325 * If the attribute is not present, assume that the
326 * printer should show up
327 */
328 if (!strcmp(ippGetName(attr), "security-enabled") &&
329 ((ippGetValueTag(attr) == IPP_TAG_INTEGER &&
330 ippGetInteger(attr, 0)) ||
331 (ippGetValueTag(attr) == IPP_TAG_BOOLEAN &&
332 ippGetBoolean(attr, 0))))
333 secure = 1;
334
335 attr = ippNextAttribute(response);
336 }
337
338 /*
339 * See if we have everything needed...
340 * Make sure the printer is not a secure printer
341 * and make sure smb printing hasn't been explicitly
342 * disabled for the printer
343 */
344
345 if (name != NULL && !secure && smb_enabled)
346 pcap_cache_add_specific(pcache, name, info, NULL);
347 }
348
349 out:
350 if (response)
351 ippDelete(response);
352 return(0);
353 }
354
355 bool iprint_cache_reload(struct pcap_cache **_pcache)
356 {
357 http_t *http = NULL; /* HTTP connection to server */
358 ipp_t *request = NULL, /* IPP Request */
359 *response = NULL; /* IPP Response */
360 ipp_attribute_t *attr; /* Current attribute */
361 cups_lang_t *language = NULL; /* Default language */
362 int i;
363 bool ret = false;
364 struct pcap_cache *pcache = NULL;
365
366 DEBUG(5, ("reloading iprint printcap cache\n"));
367
368 /*
369 * Make sure we don't ask for passwords...
370 */
371
372 cupsSetPasswordCB(iprint_passwd_cb);
373
374 /*
375 * Try to connect to the server...
376 */
377
378 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
379 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
380 iprint_server(), strerror(errno)));
381 goto out;
382 }
383
384 /*
385 * Build a OPERATION_NOVELL_LIST_PRINTERS request, which requires the following attributes:
386 *
387 * attributes-charset
388 * attributes-natural-language
389 */
390
391 request = ippNew();
392
393 ippSetOperation(request, (ipp_op_t)OPERATION_NOVELL_LIST_PRINTERS);
394 ippSetRequestId(request, 1);
395
396 language = cupsLangDefault();
397
398 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
399 "attributes-charset", NULL, "utf-8");
400
401 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
402 "attributes-natural-language", NULL, language->language);
403
404 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
405 "ipp-server", NULL, "ippSrvr");
406
407 /*
408 * Do the request and get back a response...
409 */
410
411 if ((response = cupsDoRequest(http, request, "/ipp")) == NULL) {
412 DEBUG(0,("Unable to get printer list - %s\n",
413 ippErrorString(cupsLastError())));
414 goto out;
415 }
416
417 for (attr = ippFirstAttribute(response); attr != NULL;) {
418 /*
419 * Skip leading attributes until we hit a printer...
420 */
421
422 while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER)
423 attr = ippNextAttribute(response);
424
425 if (attr == NULL)
426 break;
427
428 /*
429 * Pull the needed attributes from this printer...
430 */
431
432 while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER)
433 {
434 if (strcmp(ippGetName(attr), "printer-name") == 0 &&
435 (ippGetValueTag(attr) == IPP_TAG_URI ||
436 ippGetValueTag(attr) == IPP_TAG_NAME ||
437 ippGetValueTag(attr) == IPP_TAG_TEXT ||
438 ippGetValueTag(attr) == IPP_TAG_NAMELANG ||
439 ippGetValueTag(attr) == IPP_TAG_TEXTLANG))
440 {
441 for (i = 0; i<ippGetCount(attr); i++)
442 {
443 const char *url = ippGetString(attr, i, NULL);
444 if (!url || !strlen(url))
445 continue;
446 iprint_cache_add_printer(http, i+2, url,
447 &pcache);
448 }
449 }
450 attr = ippNextAttribute(response);
451 }
452 }
453
454 ret = true;
455 *_pcache = pcache;
456
457 out:
458 if (response)
459 ippDelete(response);
460
461 if (language)
462 cupsLangFree(language);
463
464 if (http)
465 httpClose(http);
466
467 return ret;
468 }
469
470
471 /*
472 * 'iprint_job_delete()' - Delete a job.
473 */
474
475 static int iprint_job_delete(const char *sharename, const char *lprm_command, struct printjob *pjob)
476 {
477 int ret = 1; /* Return value */
478 http_t *http = NULL; /* HTTP connection to server */
479 ipp_t *request = NULL, /* IPP Request */
480 *response = NULL; /* IPP Response */
481 cups_lang_t *language = NULL; /* Default language */
482 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
483 char httpPath[HTTP_MAX_URI]; /* path portion of the printer-uri */
484
485
486 DEBUG(5,("iprint_job_delete(%s, %p (%d))\n", sharename, pjob, pjob->sysjob));
487
488 /*
489 * Make sure we don't ask for passwords...
490 */
491
492 cupsSetPasswordCB(iprint_passwd_cb);
493
494 /*
495 * Try to connect to the server...
496 */
497
498 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
499 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
500 iprint_server(), strerror(errno)));
501 goto out;
502 }
503
504 /*
505 * Build an IPP_CANCEL_JOB request, which uses the following
506 * attributes:
507 *
508 * attributes-charset
509 * attributes-natural-language
510 * printer-uri
511 * job-id
512 * requesting-user-name
513 */
514
515 request = ippNew();
516
517 ippSetOperation(request, IPP_CANCEL_JOB);
518 ippSetRequestId(request, 1);
519
520 language = cupsLangDefault();
521
522 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
523 "attributes-charset", NULL, "utf-8");
524
525 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
526 "attributes-natural-language", NULL, language->language);
527
528 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), sharename);
529
530 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
531
532 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob);
533
534 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
535 NULL, pjob->user);
536
537 /*
538 * Do the request and get back a response...
539 */
540
541 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", sharename);
542
543 if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
544 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
545 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
546 ippErrorString(cupsLastError())));
547 } else {
548 ret = 0;
549 }
550 } else {
551 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
552 ippErrorString(cupsLastError())));
553 }
554
555 out:
556 if (response)
557 ippDelete(response);
558
559 if (language)
560 cupsLangFree(language);
561
562 if (http)
563 httpClose(http);
564
565 return ret;
566 }
567
568
569 /*
570 * 'iprint_job_pause()' - Pause a job.
571 */
572
573 static int iprint_job_pause(int snum, struct printjob *pjob)
574 {
575 int ret = 1; /* Return value */
576 http_t *http = NULL; /* HTTP connection to server */
577 ipp_t *request = NULL, /* IPP Request */
578 *response = NULL; /* IPP Response */
579 cups_lang_t *language = NULL; /* Default language */
580 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
581 char httpPath[HTTP_MAX_URI]; /* path portion of the printer-uri */
582
583
584 DEBUG(5,("iprint_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
585
586 /*
587 * Make sure we don't ask for passwords...
588 */
589
590 cupsSetPasswordCB(iprint_passwd_cb);
591
592 /*
593 * Try to connect to the server...
594 */
595
596 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
597 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
598 iprint_server(), strerror(errno)));
599 goto out;
600 }
601
602 /*
603 * Build an IPP_HOLD_JOB request, which requires the following
604 * attributes:
605 *
606 * attributes-charset
607 * attributes-natural-language
608 * printer-uri
609 * job-id
610 * requesting-user-name
611 */
612
613 request = ippNew();
614
615 ippSetOperation(request, IPP_HOLD_JOB);
616 ippSetRequestId(request, 1);
617
618 language = cupsLangDefault();
619
620 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
621 "attributes-charset", NULL, "utf-8");
622
623 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
624 "attributes-natural-language", NULL, language->language);
625
626 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
627 lp_printername(talloc_tos(), snum));
628
629 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
630
631 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob);
632
633 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
634 NULL, pjob->user);
635
636 /*
637 * Do the request and get back a response...
638 */
639
640 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s",
641 lp_printername(talloc_tos(), snum));
642
643 if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
644 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
645 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
646 ippErrorString(cupsLastError())));
647 } else {
648 ret = 0;
649 }
650 } else {
651 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
652 ippErrorString(cupsLastError())));
653 }
654
655 out:
656 if (response)
657 ippDelete(response);
658
659 if (language)
660 cupsLangFree(language);
661
662 if (http)
663 httpClose(http);
664
665 return ret;
666 }
667
668
669 /*
670 * 'iprint_job_resume()' - Resume a paused job.
671 */
672
673 static int iprint_job_resume(int snum, struct printjob *pjob)
674 {
675 int ret = 1; /* Return value */
676 http_t *http = NULL; /* HTTP connection to server */
677 ipp_t *request = NULL, /* IPP Request */
678 *response = NULL; /* IPP Response */
679 cups_lang_t *language = NULL; /* Default language */
680 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
681 char httpPath[HTTP_MAX_URI]; /* path portion of the printer-uri */
682
683
684 DEBUG(5,("iprint_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
685
686 /*
687 * Make sure we don't ask for passwords...
688 */
689
690 cupsSetPasswordCB(iprint_passwd_cb);
691
692 /*
693 * Try to connect to the server...
694 */
695
696 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
697 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
698 iprint_server(), strerror(errno)));
699 goto out;
700 }
701
702 /*
703 * Build an IPP_RELEASE_JOB request, which requires the following
704 * attributes:
705 *
706 * attributes-charset
707 * attributes-natural-language
708 * printer-uri
709 * job-id
710 * requesting-user-name
711 */
712
713 request = ippNew();
714
715 ippSetOperation(request, IPP_RELEASE_JOB);
716 ippSetRequestId(request, 1);
717
718 language = cupsLangDefault();
719
720 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
721 "attributes-charset", NULL, "utf-8");
722
723 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
724 "attributes-natural-language", NULL, language->language);
725
726 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
727 lp_printername(talloc_tos(), snum));
728
729 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
730
731 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob);
732
733 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
734 NULL, pjob->user);
735
736 /*
737 * Do the request and get back a response...
738 */
739
740 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s",
741 lp_printername(talloc_tos(), snum));
742
743 if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
744 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
745 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
746 ippErrorString(cupsLastError())));
747 } else {
748 ret = 0;
749 }
750 } else {
751 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
752 ippErrorString(cupsLastError())));
753 }
754
755 out:
756 if (response)
757 ippDelete(response);
758
759 if (language)
760 cupsLangFree(language);
761
762 if (http)
763 httpClose(http);
764
765 return ret;
766 }
767
768
769 /*
770 * 'iprint_job_submit()' - Submit a job for printing.
771 */
772
773 static int iprint_job_submit(int snum, struct printjob *pjob,
774 enum printing_types printing_type,
775 char *lpq_cmd)
776 {
777 int ret = 1; /* Return value */
778 http_t *http = NULL; /* HTTP connection to server */
779 ipp_t *request = NULL, /* IPP Request */
780 *response = NULL; /* IPP Response */
781 ipp_attribute_t *attr; /* Current attribute */
782 cups_lang_t *language = NULL; /* Default language */
783 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
784
785 DEBUG(5,("iprint_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
786
787 /*
788 * Make sure we don't ask for passwords...
789 */
790
791 cupsSetPasswordCB(iprint_passwd_cb);
792
793 /*
794 * Try to connect to the server...
795 */
796
797 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
798 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
799 iprint_server(), strerror(errno)));
800 goto out;
801 }
802
803 /*
804 * Build an IPP_PRINT_JOB request, which requires the following
805 * attributes:
806 *
807 * attributes-charset
808 * attributes-natural-language
809 * printer-uri
810 * requesting-user-name
811 * [document-data]
812 */
813
814 request = ippNew();
815
816 ippSetOperation(request, IPP_PRINT_JOB);
817 ippSetRequestId(request, 1);
818
819 language = cupsLangDefault();
820
821 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
822 "attributes-charset", NULL, "utf-8");
823
824 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
825 "attributes-natural-language", NULL, language->language);
826
827 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
828 lp_printername(talloc_tos(), snum));
829
830 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
831 "printer-uri", NULL, uri);
832
833 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
834 NULL, pjob->user);
835
836 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
837 "job-originating-host-name", NULL,
838 pjob->clientmachine);
839
840 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
841 pjob->jobname);
842
843 /*
844 * Do the request and get back a response...
845 */
846
847 slprintf(uri, sizeof(uri) - 1, "/ipp/%s", lp_printername(talloc_tos(), snum));
848
849 if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
850 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
851 DEBUG(0,("Unable to print file to %s - %s\n",
852 lp_printername(talloc_tos(), snum),
853 ippErrorString(cupsLastError())));
854 } else {
855 ret = 0;
856 }
857 } else {
858 DEBUG(0,("Unable to print file to `%s' - %s\n",
859 lp_printername(talloc_tos(), snum),
860 ippErrorString(cupsLastError())));
861 }
862
863 if ( ret == 0 )
864 unlink(pjob->filename);
865 /* else print_job_end will do it for us */
866
867 if ( ret == 0 ) {
868
869 attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER);
870 if (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_JOB)
871 {
872 pjob->sysjob = ippGetInteger(attr, 0);
873 }
874 }
875
876 out:
877 if (response)
878 ippDelete(response);
879
880 if (language)
881 cupsLangFree(language);
882
883 if (http)
884 httpClose(http);
885
886 return ret;
887 }
888
889 /*
890 * 'iprint_queue_get()' - Get all the jobs in the print queue.
891 */
892
893 static int iprint_queue_get(const char *sharename,
894 enum printing_types printing_type,
895 char *lpq_command,
896 print_queue_struct **q,
897 print_status_struct *status)
898 {
899 fstring printername;
900 http_t *http = NULL; /* HTTP connection to server */
901 ipp_t *request = NULL, /* IPP Request */
902 *response = NULL; /* IPP Response */
903 ipp_attribute_t *attr = NULL; /* Current attribute */
904 cups_lang_t *language = NULL; /* Default language */
905 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
906 char serviceUri[HTTP_MAX_URI]; /* service-uri attribute */
907 char httpPath[HTTP_MAX_URI]; /* path portion of the uri */
908 int jobUseUnixTime = 0; /* Whether job times should
909 * be assumed to be Unix time */
910 int qcount = 0, /* Number of active queue entries */
911 qalloc = 0; /* Number of queue entries allocated */
912 print_queue_struct *queue = NULL, /* Queue entries */
913 *temp; /* Temporary pointer for queue */
914 const char *user_name, /* job-originating-user-name attribute */
915 *job_name; /* job-name attribute */
916 int job_id; /* job-id attribute */
917 int job_k_octets; /* job-k-octets attribute */
918 time_t job_time; /* time-at-creation attribute */
919 time_t printer_up_time = 0; /* printer's uptime */
920 ipp_jstate_t job_status; /* job-status attribute */
921 int job_priority; /* job-priority attribute */
922 static const char *jattrs[] = /* Requested job attributes */
923 {
924 "job-id",
925 "job-k-octets",
926 "job-name",
927 "job-originating-user-name",
928 "job-priority",
929 "job-state",
930 "time-at-creation",
931 };
932 static const char *pattrs[] = /* Requested printer attributes */
933 {
934 "printer-state",
935 "printer-state-message",
936 "printer-current-time",
937 "printer-up-time"
938 };
939
940 *q = NULL;
941
942 /* HACK ALERT!!! The porblem with support the 'printer name'
943 option is that we key the tdb off the sharename. So we will
944 overload the lpq_command string to pass in the printername
945 (which is basically what we do for non-cups printers ... using
946 the lpq_command to get the queue listing). */
947
948 fstrcpy( printername, lpq_command );
949
950 DEBUG(5,("iprint_queue_get(%s, %p, %p)\n", printername, q, status));
951
952 /*
953 * Make sure we don't ask for passwords...
954 */
955
956 cupsSetPasswordCB(iprint_passwd_cb);
957
958 /*
959 * Try to connect to the server...
960 */
961
962 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
963 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
964 iprint_server(), strerror(errno)));
965 goto out;
966 }
967
968 /*
969 * Generate the printer URI and the service URI that goes with it...
970 */
971
972 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), printername);
973 slprintf(serviceUri, sizeof(serviceUri) - 1, "ipp://%s/ipp/", iprint_server());
974
975 /*
976 * For Linux iPrint servers from OES SP1 on, the iPrint server
977 * uses Unix time for job start times unless it detects the iPrint
978 * client in an http User-Agent header. (This was done to accomodate
979 * CUPS broken behavior. According to RFC 2911, section 4.3.14, job
980 * start times are supposed to be relative to how long the printer has
981 * been up.) Since libcups doesn't allow us to set that header before
982 * the request is sent, this ugly hack allows us to detect the server
983 * version and decide how to interpret the job time.
984 */
985 if (iprint_get_server_version(http, serviceUri) >=
986 NOVELL_SERVER_VERSION_OES_SP1)
987 jobUseUnixTime = 1;
988
989 request = ippNew();
990
991 ippSetOperation(request, IPP_GET_PRINTER_ATTRIBUTES);
992 ippSetRequestId(request, 2);
993
994 language = cupsLangDefault();
995
996 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
997 "attributes-charset", NULL, "utf-8");
998
999 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1000 "attributes-natural-language", NULL, language->language);
1001
1002 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1003 "printer-uri", NULL, uri);
1004
1005 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1006 "requested-attributes",
1007 (sizeof(pattrs) / sizeof(pattrs[0])),
1008 NULL, pattrs);
1009
1010 /*
1011 * Do the request and get back a response...
1012 */
1013
1014 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername);
1015
1016 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
1017 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
1018 ippErrorString(cupsLastError())));
1019 *q = queue;
1020 goto out;
1021 }
1022
1023 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
1024 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
1025 ippErrorString(ippGetStatusCode(response))));
1026 *q = queue;
1027 goto out;
1028 }
1029
1030 /*
1031 * Get the current printer status and convert it to the SAMBA values.
1032 */
1033
1034 if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) {
1035 if (ippGetInteger(attr, 0) == IPP_PRINTER_STOPPED)
1036 status->status = LPSTAT_STOPPED;
1037 else
1038 status->status = LPSTAT_OK;
1039 }
1040
1041 if ((attr = ippFindAttribute(response, "printer-state-message",
1042 IPP_TAG_TEXT)) != NULL)
1043 fstrcpy(status->message, ippGetString(attr, 0, NULL));
1044
1045 if ((attr = ippFindAttribute(response, "printer-up-time",
1046 IPP_TAG_INTEGER)) != NULL)
1047 printer_up_time = ippGetInteger(attr, 0);
1048
1049 ippDelete(response);
1050 response = NULL;
1051
1052 /*
1053 * Build an IPP_GET_JOBS request, which requires the following
1054 * attributes:
1055 *
1056 * attributes-charset
1057 * attributes-natural-language
1058 * requested-attributes
1059 * printer-uri
1060 */
1061
1062 request = ippNew();
1063
1064 ippSetOperation(request, IPP_GET_JOBS);
1065 ippSetRequestId(request, 3);
1066
1067 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1068 "attributes-charset", NULL, "utf-8");
1069
1070 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1071 "attributes-natural-language", NULL, language->language);
1072
1073 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1074 "printer-uri", NULL, uri);
1075
1076 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1077 "requested-attributes",
1078 (sizeof(jattrs) / sizeof(jattrs[0])),
1079 NULL, jattrs);
1080
1081 /*
1082 * Do the request and get back a response...
1083 */
1084
1085 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername);
1086
1087 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
1088 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1089 ippErrorString(cupsLastError())));
1090 goto out;
1091 }
1092
1093 if (ippGetStatusCode(response) >= IPP_OK_CONFLICT) {
1094 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1095 ippErrorString(ippGetStatusCode(response))));
1096 goto out;
1097 }
1098
1099 /*
1100 * Process the jobs...
1101 */
1102
1103 qcount = 0;
1104 qalloc = 0;
1105 queue = NULL;
1106
1107 for (attr = ippFirstAttribute(response); attr != NULL; attr = ippNextAttribute(response)) {
1108 /*
1109 * Skip leading attributes until we hit a job...
1110 */
1111
1112 while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_JOB)
1113 attr = ippNextAttribute(response);
1114
1115 if (attr == NULL)
1116 break;
1117
1118 /*
1119 * Allocate memory as needed...
1120 */
1121 if (qcount >= qalloc) {
1122 qalloc += 16;
1123
1124 queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc);
1125
1126 if (queue == NULL) {
1127 DEBUG(0,("iprint_queue_get: Not enough memory!"));
1128 qcount = 0;
1129 goto out;
1130 }
1131 }
1132
1133 temp = queue + qcount;
1134 memset(temp, 0, sizeof(print_queue_struct));
1135
1136 /*
1137 * Pull the needed attributes from this job...
1138 */
1139
1140 job_id = 0;
1141 job_priority = 50;
1142 job_status = IPP_JOB_PENDING;
1143 job_time = 0;
1144 job_k_octets = 0;
1145 user_name = NULL;
1146 job_name = NULL;
1147
1148 while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_JOB) {
1149 if (ippGetName(attr) == NULL) {
1150 attr = ippNextAttribute(response);
1151 break;
1152 }
1153
1154 if (strcmp(ippGetName(attr), "job-id") == 0 &&
1155 ippGetValueTag(attr) == IPP_TAG_INTEGER)
1156 job_id = ippGetInteger(attr, 0);
1157
1158 if (strcmp(ippGetName(attr), "job-k-octets") == 0 &&
1159 ippGetValueTag(attr) == IPP_TAG_INTEGER)
1160 job_k_octets = ippGetInteger(attr, 0);
1161
1162 if (strcmp(ippGetName(attr), "job-priority") == 0 &&
1163 ippGetValueTag(attr) == IPP_TAG_INTEGER)
1164 job_priority = ippGetInteger(attr, 0);
1165
1166 if (strcmp(ippGetName(attr), "job-state") == 0 &&
1167 ippGetValueTag(attr) == IPP_TAG_ENUM)
1168 job_status = (ipp_jstate_t)ippGetInteger(attr, 0);
1169
1170 if (strcmp(ippGetName(attr), "time-at-creation") == 0 &&
1171 ippGetValueTag(attr) == IPP_TAG_INTEGER)
1172 {
1173 /*
1174 * If jobs times are in Unix time, the accuracy of the job
1175 * start time depends upon the iPrint server's time being
1176 * set correctly. Otherwise, the accuracy depends upon
1177 * the Samba server's time being set correctly
1178 */
1179
1180 if (jobUseUnixTime)
1181 job_time = ippGetInteger(attr, 0);
1182 else
1183 job_time = time(NULL) - printer_up_time + ippGetInteger(attr, 0);
1184 }
1185
1186 if (strcmp(ippGetName(attr), "job-name") == 0 &&
1187 (ippGetValueTag(attr) == IPP_TAG_NAMELANG ||
1188 ippGetValueTag(attr) == IPP_TAG_NAME))
1189 job_name = ippGetString(attr, 0, NULL);
1190
1191 if (strcmp(ippGetName(attr), "job-originating-user-name") == 0 &&
1192 (ippGetValueTag(attr) == IPP_TAG_NAMELANG ||
1193 ippGetValueTag(attr) == IPP_TAG_NAME))
1194 user_name = ippGetString(attr, 0, NULL);
1195
1196 attr = ippNextAttribute(response);
1197 }
1198
1199 /*
1200 * See if we have everything needed...
1201 */
1202
1203 if (user_name == NULL || job_name == NULL || job_id == 0) {
1204 if (attr == NULL)
1205 break;
1206 else
1207 continue;
1208 }
1209
1210 temp->sysjob = job_id;
1211 temp->size = job_k_octets * 1024;
1212 temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
1213 job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
1214 job_status == IPP_JOB_HELD ? LPQ_PAUSED :
1215 LPQ_PRINTING;
1216 temp->priority = job_priority;
1217 temp->time = job_time;
1218 strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1);
1219 strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1);
1220
1221 qcount ++;
1222
1223 if (attr == NULL)
1224 break;
1225 }
1226
1227 /*
1228 * Return the job queue...
1229 */
1230
1231 *q = queue;
1232
1233 out:
1234 if (response)
1235 ippDelete(response);
1236
1237 if (language)
1238 cupsLangFree(language);
1239
1240 if (http)
1241 httpClose(http);
1242
1243 return qcount;
1244 }
1245
1246
1247 /*
1248 * 'iprint_queue_pause()' - Pause a print queue.
1249 */
1250
1251 static int iprint_queue_pause(int snum)
1252 {
1253 return(-1); /* Not supported without credentials */
1254 }
1255
1256
1257 /*
1258 * 'iprint_queue_resume()' - Restart a print queue.
1259 */
1260
1261 static int iprint_queue_resume(int snum)
1262 {
1263 return(-1); /* Not supported without credentials */
1264 }
1265
1266 /*******************************************************************
1267 * iPrint printing interface definitions...
1268 ******************************************************************/
1269
1270 struct printif iprint_printif =
1271 {
1272 PRINT_IPRINT,
1273 iprint_queue_get,
1274 iprint_queue_pause,
1275 iprint_queue_resume,
1276 iprint_job_delete,
1277 iprint_job_pause,
1278 iprint_job_resume,
1279 iprint_job_submit,
1280 };
1281
1282 #else
1283 /* this keeps fussy compilers happy */
1284 void print_iprint_dummy(void);
1285 void print_iprint_dummy(void) {}
1286 #endif /* HAVE_IPRINT */
Samba GIT mirror