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