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