?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build: get the SONAME right for installed libraries
[Samba/gebeck_regimport.git] / source3 / printing / print_iprint.c
blobf7a86dd453b3e2674f3f0d5e337b04869bc69986
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);
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(), PRINTERNAME(snum));
579
580 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
581
582 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob);
583
584 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
585 NULL, pjob->user);
586
587 /*
588 * Do the request and get back a response...
589 */
590
591 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", PRINTERNAME(snum));
592
593 if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
594 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
595 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
596 ippErrorString(cupsLastError())));
597 } else {
598 ret = 0;
599 }
600 } else {
601 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
602 ippErrorString(cupsLastError())));
603 }
604
605 out:
606 if (response)
607 ippDelete(response);
608
609 if (language)
610 cupsLangFree(language);
611
612 if (http)
613 httpClose(http);
614
615 return ret;
616 }
617
618
619 /*
620 * 'iprint_job_resume()' - Resume a paused job.
621 */
622
623 static int iprint_job_resume(int snum, struct printjob *pjob)
624 {
625 int ret = 1; /* Return value */
626 http_t *http = NULL; /* HTTP connection to server */
627 ipp_t *request = NULL, /* IPP Request */
628 *response = NULL; /* IPP Response */
629 cups_lang_t *language = NULL; /* Default language */
630 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
631 char httpPath[HTTP_MAX_URI]; /* path portion of the printer-uri */
632
633
634 DEBUG(5,("iprint_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
635
636 /*
637 * Make sure we don't ask for passwords...
638 */
639
640 cupsSetPasswordCB(iprint_passwd_cb);
641
642 /*
643 * Try to connect to the server...
644 */
645
646 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
647 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
648 iprint_server(), strerror(errno)));
649 goto out;
650 }
651
652 /*
653 * Build an IPP_RELEASE_JOB request, which requires the following
654 * attributes:
655 *
656 * attributes-charset
657 * attributes-natural-language
658 * printer-uri
659 * job-id
660 * requesting-user-name
661 */
662
663 request = ippNew();
664
665 request->request.op.operation_id = IPP_RELEASE_JOB;
666 request->request.op.request_id = 1;
667
668 language = cupsLangDefault();
669
670 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
671 "attributes-charset", NULL, "utf-8");
672
673 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
674 "attributes-natural-language", NULL, language->language);
675
676 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), PRINTERNAME(snum));
677
678 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
679
680 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", pjob->sysjob);
681
682 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
683 NULL, pjob->user);
684
685 /*
686 * Do the request and get back a response...
687 */
688
689 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", PRINTERNAME(snum));
690
691 if ((response = cupsDoRequest(http, request, httpPath)) != NULL) {
692 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
693 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
694 ippErrorString(cupsLastError())));
695 } else {
696 ret = 0;
697 }
698 } else {
699 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
700 ippErrorString(cupsLastError())));
701 }
702
703 out:
704 if (response)
705 ippDelete(response);
706
707 if (language)
708 cupsLangFree(language);
709
710 if (http)
711 httpClose(http);
712
713 return ret;
714 }
715
716
717 /*
718 * 'iprint_job_submit()' - Submit a job for printing.
719 */
720
721 static int iprint_job_submit(int snum, struct printjob *pjob)
722 {
723 int ret = 1; /* Return value */
724 http_t *http = NULL; /* HTTP connection to server */
725 ipp_t *request = NULL, /* IPP Request */
726 *response = NULL; /* IPP Response */
727 ipp_attribute_t *attr; /* Current attribute */
728 cups_lang_t *language = NULL; /* Default language */
729 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
730 const char *clientname = NULL; /* hostname of client for job-originating-host attribute */
731 char addr[INET6_ADDRSTRLEN];
732
733 DEBUG(5,("iprint_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
734
735 /*
736 * Make sure we don't ask for passwords...
737 */
738
739 cupsSetPasswordCB(iprint_passwd_cb);
740
741 /*
742 * Try to connect to the server...
743 */
744
745 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
746 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
747 iprint_server(), strerror(errno)));
748 goto out;
749 }
750
751 /*
752 * Build an IPP_PRINT_JOB request, which requires the following
753 * attributes:
754 *
755 * attributes-charset
756 * attributes-natural-language
757 * printer-uri
758 * requesting-user-name
759 * [document-data]
760 */
761
762 request = ippNew();
763
764 request->request.op.operation_id = IPP_PRINT_JOB;
765 request->request.op.request_id = 1;
766
767 language = cupsLangDefault();
768
769 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
770 "attributes-charset", NULL, "utf-8");
771
772 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
773 "attributes-natural-language", NULL, language->language);
774
775 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), PRINTERNAME(snum));
776
777 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
778 "printer-uri", NULL, uri);
779
780 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
781 NULL, pjob->user);
782
783 clientname = client_name(get_client_fd());
784 if (strcmp(clientname, "UNKNOWN") == 0) {
785 clientname = client_addr(get_client_fd(),addr,sizeof(addr));
786 }
787
788 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
789 "job-originating-host-name", NULL,
790 clientname);
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", 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", PRINTERNAME(snum),
804 ippErrorString(cupsLastError())));
805 } else {
806 ret = 0;
807 }
808 } else {
809 DEBUG(0,("Unable to print file to `%s' - %s\n", PRINTERNAME(snum),
810 ippErrorString(cupsLastError())));
811 }
812
813 if ( ret == 0 )
814 unlink(pjob->filename);
815 /* else print_job_end will do it for us */
816
817 if ( ret == 0 ) {
818
819 attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER);
820 if (attr != NULL && attr->group_tag == IPP_TAG_JOB)
821 {
822 pjob->sysjob = attr->values[0].integer;
823 }
824 }
825
826 out:
827 if (response)
828 ippDelete(response);
829
830 if (language)
831 cupsLangFree(language);
832
833 if (http)
834 httpClose(http);
835
836 return ret;
837 }
838
839 /*
840 * 'iprint_queue_get()' - Get all the jobs in the print queue.
841 */
842
843 static int iprint_queue_get(const char *sharename,
844 enum printing_types printing_type,
845 char *lpq_command,
846 print_queue_struct **q,
847 print_status_struct *status)
848 {
849 fstring printername;
850 http_t *http = NULL; /* HTTP connection to server */
851 ipp_t *request = NULL, /* IPP Request */
852 *response = NULL; /* IPP Response */
853 ipp_attribute_t *attr = NULL; /* Current attribute */
854 cups_lang_t *language = NULL; /* Default language */
855 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
856 char serviceUri[HTTP_MAX_URI]; /* service-uri attribute */
857 char httpPath[HTTP_MAX_URI]; /* path portion of the uri */
858 int jobUseUnixTime = 0; /* Whether job times should
859 * be assumed to be Unix time */
860 int qcount = 0, /* Number of active queue entries */
861 qalloc = 0; /* Number of queue entries allocated */
862 print_queue_struct *queue = NULL, /* Queue entries */
863 *temp; /* Temporary pointer for queue */
864 const char *user_name, /* job-originating-user-name attribute */
865 *job_name; /* job-name attribute */
866 int job_id; /* job-id attribute */
867 int job_k_octets; /* job-k-octets attribute */
868 time_t job_time; /* time-at-creation attribute */
869 time_t printer_current_time = 0; /* printer's current time */
870 time_t printer_up_time = 0; /* printer's uptime */
871 ipp_jstate_t job_status; /* job-status attribute */
872 int job_priority; /* job-priority attribute */
873 static const char *jattrs[] = /* Requested job attributes */
874 {
875 "job-id",
876 "job-k-octets",
877 "job-name",
878 "job-originating-user-name",
879 "job-priority",
880 "job-state",
881 "time-at-creation",
882 };
883 static const char *pattrs[] = /* Requested printer attributes */
884 {
885 "printer-state",
886 "printer-state-message",
887 "printer-current-time",
888 "printer-up-time"
889 };
890
891 *q = NULL;
892
893 /* HACK ALERT!!! The porblem with support the 'printer name'
894 option is that we key the tdb off the sharename. So we will
895 overload the lpq_command string to pass in the printername
896 (which is basically what we do for non-cups printers ... using
897 the lpq_command to get the queue listing). */
898
899 fstrcpy( printername, lpq_command );
900
901 DEBUG(5,("iprint_queue_get(%s, %p, %p)\n", printername, q, status));
902
903 /*
904 * Make sure we don't ask for passwords...
905 */
906
907 cupsSetPasswordCB(iprint_passwd_cb);
908
909 /*
910 * Try to connect to the server...
911 */
912
913 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
914 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
915 iprint_server(), strerror(errno)));
916 goto out;
917 }
918
919 /*
920 * Generate the printer URI and the service URI that goes with it...
921 */
922
923 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), printername);
924 slprintf(serviceUri, sizeof(serviceUri) - 1, "ipp://%s/ipp/", iprint_server());
925
926 /*
927 * For Linux iPrint servers from OES SP1 on, the iPrint server
928 * uses Unix time for job start times unless it detects the iPrint
929 * client in an http User-Agent header. (This was done to accomodate
930 * CUPS broken behavior. According to RFC 2911, section 4.3.14, job
931 * start times are supposed to be relative to how long the printer has
932 * been up.) Since libcups doesn't allow us to set that header before
933 * the request is sent, this ugly hack allows us to detect the server
934 * version and decide how to interpret the job time.
935 */
936 if (iprint_get_server_version(http, serviceUri) >=
937 NOVELL_SERVER_VERSION_OES_SP1)
938 jobUseUnixTime = 1;
939
940 request = ippNew();
941
942 request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
943 request->request.op.request_id = 2;
944
945 language = cupsLangDefault();
946
947 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
948 "attributes-charset", NULL, "utf-8");
949
950 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
951 "attributes-natural-language", NULL, language->language);
952
953 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
954 "printer-uri", NULL, uri);
955
956 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
957 "requested-attributes",
958 (sizeof(pattrs) / sizeof(pattrs[0])),
959 NULL, pattrs);
960
961 /*
962 * Do the request and get back a response...
963 */
964
965 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername);
966
967 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
968 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
969 ippErrorString(cupsLastError())));
970 *q = queue;
971 goto out;
972 }
973
974 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
975 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
976 ippErrorString(response->request.status.status_code)));
977 *q = queue;
978 goto out;
979 }
980
981 /*
982 * Get the current printer status and convert it to the SAMBA values.
983 */
984
985 if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) {
986 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
987 status->status = LPSTAT_STOPPED;
988 else
989 status->status = LPSTAT_OK;
990 }
991
992 if ((attr = ippFindAttribute(response, "printer-state-message",
993 IPP_TAG_TEXT)) != NULL)
994 fstrcpy(status->message, attr->values[0].string.text);
995
996 if ((attr = ippFindAttribute(response, "printer-current-time",
997 IPP_TAG_DATE)) != NULL)
998 printer_current_time = ippDateToTime(attr->values[0].date);
999
1000 if ((attr = ippFindAttribute(response, "printer-up-time",
1001 IPP_TAG_INTEGER)) != NULL)
1002 printer_up_time = attr->values[0].integer;
1003
1004 ippDelete(response);
1005 response = NULL;
1006
1007 /*
1008 * Build an IPP_GET_JOBS request, which requires the following
1009 * attributes:
1010 *
1011 * attributes-charset
1012 * attributes-natural-language
1013 * requested-attributes
1014 * printer-uri
1015 */
1016
1017 request = ippNew();
1018
1019 request->request.op.operation_id = IPP_GET_JOBS;
1020 request->request.op.request_id = 3;
1021
1022 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1023 "attributes-charset", NULL, "utf-8");
1024
1025 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1026 "attributes-natural-language", NULL, language->language);
1027
1028 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1029 "printer-uri", NULL, uri);
1030
1031 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1032 "requested-attributes",
1033 (sizeof(jattrs) / sizeof(jattrs[0])),
1034 NULL, jattrs);
1035
1036 /*
1037 * Do the request and get back a response...
1038 */
1039
1040 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername);
1041
1042 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
1043 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1044 ippErrorString(cupsLastError())));
1045 goto out;
1046 }
1047
1048 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1049 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1050 ippErrorString(response->request.status.status_code)));
1051 goto out;
1052 }
1053
1054 /*
1055 * Process the jobs...
1056 */
1057
1058 qcount = 0;
1059 qalloc = 0;
1060 queue = NULL;
1061
1062 for (attr = response->attrs; attr != NULL; attr = attr->next) {
1063 /*
1064 * Skip leading attributes until we hit a job...
1065 */
1066
1067 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
1068 attr = attr->next;
1069
1070 if (attr == NULL)
1071 break;
1072
1073 /*
1074 * Allocate memory as needed...
1075 */
1076 if (qcount >= qalloc) {
1077 qalloc += 16;
1078
1079 queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc);
1080
1081 if (queue == NULL) {
1082 DEBUG(0,("iprint_queue_get: Not enough memory!"));
1083 qcount = 0;
1084 goto out;
1085 }
1086 }
1087
1088 temp = queue + qcount;
1089 memset(temp, 0, sizeof(print_queue_struct));
1090
1091 /*
1092 * Pull the needed attributes from this job...
1093 */
1094
1095 job_id = 0;
1096 job_priority = 50;
1097 job_status = IPP_JOB_PENDING;
1098 job_time = 0;
1099 job_k_octets = 0;
1100 user_name = NULL;
1101 job_name = NULL;
1102
1103 while (attr != NULL && attr->group_tag == IPP_TAG_JOB) {
1104 if (attr->name == NULL) {
1105 attr = attr->next;
1106 break;
1107 }
1108
1109 if (strcmp(attr->name, "job-id") == 0 &&
1110 attr->value_tag == IPP_TAG_INTEGER)
1111 job_id = attr->values[0].integer;
1112
1113 if (strcmp(attr->name, "job-k-octets") == 0 &&
1114 attr->value_tag == IPP_TAG_INTEGER)
1115 job_k_octets = attr->values[0].integer;
1116
1117 if (strcmp(attr->name, "job-priority") == 0 &&
1118 attr->value_tag == IPP_TAG_INTEGER)
1119 job_priority = attr->values[0].integer;
1120
1121 if (strcmp(attr->name, "job-state") == 0 &&
1122 attr->value_tag == IPP_TAG_ENUM)
1123 job_status = (ipp_jstate_t)(attr->values[0].integer);
1124
1125 if (strcmp(attr->name, "time-at-creation") == 0 &&
1126 attr->value_tag == IPP_TAG_INTEGER)
1127 {
1128 /*
1129 * If jobs times are in Unix time, the accuracy of the job
1130 * start time depends upon the iPrint server's time being
1131 * set correctly. Otherwise, the accuracy depends upon
1132 * the Samba server's time being set correctly
1133 */
1134
1135 if (jobUseUnixTime)
1136 job_time = attr->values[0].integer;
1137 else
1138 job_time = time(NULL) - printer_up_time + attr->values[0].integer;
1139 }
1140
1141 if (strcmp(attr->name, "job-name") == 0 &&
1142 (attr->value_tag == IPP_TAG_NAMELANG ||
1143 attr->value_tag == IPP_TAG_NAME))
1144 job_name = attr->values[0].string.text;
1145
1146 if (strcmp(attr->name, "job-originating-user-name") == 0 &&
1147 (attr->value_tag == IPP_TAG_NAMELANG ||
1148 attr->value_tag == IPP_TAG_NAME))
1149 user_name = attr->values[0].string.text;
1150
1151 attr = attr->next;
1152 }
1153
1154 /*
1155 * See if we have everything needed...
1156 */
1157
1158 if (user_name == NULL || job_name == NULL || job_id == 0) {
1159 if (attr == NULL)
1160 break;
1161 else
1162 continue;
1163 }
1164
1165 temp->job = job_id;
1166 temp->size = job_k_octets * 1024;
1167 temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
1168 job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
1169 job_status == IPP_JOB_HELD ? LPQ_PAUSED :
1170 LPQ_PRINTING;
1171 temp->priority = job_priority;
1172 temp->time = job_time;
1173 strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1);
1174 strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1);
1175
1176 qcount ++;
1177
1178 if (attr == NULL)
1179 break;
1180 }
1181
1182 /*
1183 * Return the job queue...
1184 */
1185
1186 *q = queue;
1187
1188 out:
1189 if (response)
1190 ippDelete(response);
1191
1192 if (language)
1193 cupsLangFree(language);
1194
1195 if (http)
1196 httpClose(http);
1197
1198 return qcount;
1199 }
1200
1201
1202 /*
1203 * 'iprint_queue_pause()' - Pause a print queue.
1204 */
1205
1206 static int iprint_queue_pause(int snum)
1207 {
1208 return(-1); /* Not supported without credentials */
1209 }
1210
1211
1212 /*
1213 * 'iprint_queue_resume()' - Restart a print queue.
1214 */
1215
1216 static int iprint_queue_resume(int snum)
1217 {
1218 return(-1); /* Not supported without credentials */
1219 }
1220
1221 /*******************************************************************
1222 * iPrint printing interface definitions...
1223 ******************************************************************/
1224
1225 struct printif iprint_printif =
1226 {
1227 PRINT_IPRINT,
1228 iprint_queue_get,
1229 iprint_queue_pause,
1230 iprint_queue_resume,
1231 iprint_job_delete,
1232 iprint_job_pause,
1233 iprint_job_resume,
1234 iprint_job_submit,
1235 };
1236
1237 #else
1238 /* this keeps fussy compilers happy */
1239 void print_iprint_dummy(void);
1240 void print_iprint_dummy(void) {}
1241 #endif /* HAVE_IPRINT */
reg import