?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: change blocking.c to use fsp_fnum_dbg() for fsp->fnum logging.
[Samba/gebeck_regimport.git] / source3 / printing / print_iprint.c
blob1ff705a383c0e243a8ebed990166ea6b9d0d9491
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 {
727 int ret = 1; /* Return value */
728 http_t *http = NULL; /* HTTP connection to server */
729 ipp_t *request = NULL, /* IPP Request */
730 *response = NULL; /* IPP Response */
731 ipp_attribute_t *attr; /* Current attribute */
732 cups_lang_t *language = NULL; /* Default language */
733 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
734
735 DEBUG(5,("iprint_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
736
737 /*
738 * Make sure we don't ask for passwords...
739 */
740
741 cupsSetPasswordCB(iprint_passwd_cb);
742
743 /*
744 * Try to connect to the server...
745 */
746
747 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
748 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
749 iprint_server(), strerror(errno)));
750 goto out;
751 }
752
753 /*
754 * Build an IPP_PRINT_JOB request, which requires the following
755 * attributes:
756 *
757 * attributes-charset
758 * attributes-natural-language
759 * printer-uri
760 * requesting-user-name
761 * [document-data]
762 */
763
764 request = ippNew();
765
766 request->request.op.operation_id = IPP_PRINT_JOB;
767 request->request.op.request_id = 1;
768
769 language = cupsLangDefault();
770
771 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
772 "attributes-charset", NULL, "utf-8");
773
774 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
775 "attributes-natural-language", NULL, language->language);
776
777 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(),
778 lp_printername(snum));
779
780 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
781 "printer-uri", NULL, uri);
782
783 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
784 NULL, pjob->user);
785
786 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
787 "job-originating-host-name", NULL,
788 pjob->clientmachine);
789
790 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
791 pjob->jobname);
792
793 /*
794 * Do the request and get back a response...
795 */
796
797 slprintf(uri, sizeof(uri) - 1, "/ipp/%s", lp_printername(snum));
798
799 if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
800 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
801 DEBUG(0,("Unable to print file to %s - %s\n",
802 lp_printername(snum),
803 ippErrorString(cupsLastError())));
804 } else {
805 ret = 0;
806 }
807 } else {
808 DEBUG(0,("Unable to print file to `%s' - %s\n",
809 lp_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_up_time = 0; /* printer's uptime */
870 ipp_jstate_t job_status; /* job-status attribute */
871 int job_priority; /* job-priority attribute */
872 static const char *jattrs[] = /* Requested job attributes */
873 {
874 "job-id",
875 "job-k-octets",
876 "job-name",
877 "job-originating-user-name",
878 "job-priority",
879 "job-state",
880 "time-at-creation",
881 };
882 static const char *pattrs[] = /* Requested printer attributes */
883 {
884 "printer-state",
885 "printer-state-message",
886 "printer-current-time",
887 "printer-up-time"
888 };
889
890 *q = NULL;
891
892 /* HACK ALERT!!! The porblem with support the 'printer name'
893 option is that we key the tdb off the sharename. So we will
894 overload the lpq_command string to pass in the printername
895 (which is basically what we do for non-cups printers ... using
896 the lpq_command to get the queue listing). */
897
898 fstrcpy( printername, lpq_command );
899
900 DEBUG(5,("iprint_queue_get(%s, %p, %p)\n", printername, q, status));
901
902 /*
903 * Make sure we don't ask for passwords...
904 */
905
906 cupsSetPasswordCB(iprint_passwd_cb);
907
908 /*
909 * Try to connect to the server...
910 */
911
912 if ((http = httpConnect(iprint_server(), ippPort())) == NULL) {
913 DEBUG(0,("Unable to connect to iPrint server %s - %s\n",
914 iprint_server(), strerror(errno)));
915 goto out;
916 }
917
918 /*
919 * Generate the printer URI and the service URI that goes with it...
920 */
921
922 slprintf(uri, sizeof(uri) - 1, "ipp://%s/ipp/%s", iprint_server(), printername);
923 slprintf(serviceUri, sizeof(serviceUri) - 1, "ipp://%s/ipp/", iprint_server());
924
925 /*
926 * For Linux iPrint servers from OES SP1 on, the iPrint server
927 * uses Unix time for job start times unless it detects the iPrint
928 * client in an http User-Agent header. (This was done to accomodate
929 * CUPS broken behavior. According to RFC 2911, section 4.3.14, job
930 * start times are supposed to be relative to how long the printer has
931 * been up.) Since libcups doesn't allow us to set that header before
932 * the request is sent, this ugly hack allows us to detect the server
933 * version and decide how to interpret the job time.
934 */
935 if (iprint_get_server_version(http, serviceUri) >=
936 NOVELL_SERVER_VERSION_OES_SP1)
937 jobUseUnixTime = 1;
938
939 request = ippNew();
940
941 request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
942 request->request.op.request_id = 2;
943
944 language = cupsLangDefault();
945
946 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
947 "attributes-charset", NULL, "utf-8");
948
949 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
950 "attributes-natural-language", NULL, language->language);
951
952 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
953 "printer-uri", NULL, uri);
954
955 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
956 "requested-attributes",
957 (sizeof(pattrs) / sizeof(pattrs[0])),
958 NULL, pattrs);
959
960 /*
961 * Do the request and get back a response...
962 */
963
964 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername);
965
966 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
967 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
968 ippErrorString(cupsLastError())));
969 *q = queue;
970 goto out;
971 }
972
973 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
974 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
975 ippErrorString(response->request.status.status_code)));
976 *q = queue;
977 goto out;
978 }
979
980 /*
981 * Get the current printer status and convert it to the SAMBA values.
982 */
983
984 if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) {
985 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
986 status->status = LPSTAT_STOPPED;
987 else
988 status->status = LPSTAT_OK;
989 }
990
991 if ((attr = ippFindAttribute(response, "printer-state-message",
992 IPP_TAG_TEXT)) != NULL)
993 fstrcpy(status->message, attr->values[0].string.text);
994
995 if ((attr = ippFindAttribute(response, "printer-up-time",
996 IPP_TAG_INTEGER)) != NULL)
997 printer_up_time = attr->values[0].integer;
998
999 ippDelete(response);
1000 response = NULL;
1001
1002 /*
1003 * Build an IPP_GET_JOBS request, which requires the following
1004 * attributes:
1005 *
1006 * attributes-charset
1007 * attributes-natural-language
1008 * requested-attributes
1009 * printer-uri
1010 */
1011
1012 request = ippNew();
1013
1014 request->request.op.operation_id = IPP_GET_JOBS;
1015 request->request.op.request_id = 3;
1016
1017 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1018 "attributes-charset", NULL, "utf-8");
1019
1020 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1021 "attributes-natural-language", NULL, language->language);
1022
1023 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1024 "printer-uri", NULL, uri);
1025
1026 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1027 "requested-attributes",
1028 (sizeof(jattrs) / sizeof(jattrs[0])),
1029 NULL, jattrs);
1030
1031 /*
1032 * Do the request and get back a response...
1033 */
1034
1035 slprintf(httpPath, sizeof(httpPath) - 1, "/ipp/%s", printername);
1036
1037 if ((response = cupsDoRequest(http, request, httpPath)) == NULL) {
1038 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1039 ippErrorString(cupsLastError())));
1040 goto out;
1041 }
1042
1043 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1044 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1045 ippErrorString(response->request.status.status_code)));
1046 goto out;
1047 }
1048
1049 /*
1050 * Process the jobs...
1051 */
1052
1053 qcount = 0;
1054 qalloc = 0;
1055 queue = NULL;
1056
1057 for (attr = response->attrs; attr != NULL; attr = attr->next) {
1058 /*
1059 * Skip leading attributes until we hit a job...
1060 */
1061
1062 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
1063 attr = attr->next;
1064
1065 if (attr == NULL)
1066 break;
1067
1068 /*
1069 * Allocate memory as needed...
1070 */
1071 if (qcount >= qalloc) {
1072 qalloc += 16;
1073
1074 queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc);
1075
1076 if (queue == NULL) {
1077 DEBUG(0,("iprint_queue_get: Not enough memory!"));
1078 qcount = 0;
1079 goto out;
1080 }
1081 }
1082
1083 temp = queue + qcount;
1084 memset(temp, 0, sizeof(print_queue_struct));
1085
1086 /*
1087 * Pull the needed attributes from this job...
1088 */
1089
1090 job_id = 0;
1091 job_priority = 50;
1092 job_status = IPP_JOB_PENDING;
1093 job_time = 0;
1094 job_k_octets = 0;
1095 user_name = NULL;
1096 job_name = NULL;
1097
1098 while (attr != NULL && attr->group_tag == IPP_TAG_JOB) {
1099 if (attr->name == NULL) {
1100 attr = attr->next;
1101 break;
1102 }
1103
1104 if (strcmp(attr->name, "job-id") == 0 &&
1105 attr->value_tag == IPP_TAG_INTEGER)
1106 job_id = attr->values[0].integer;
1107
1108 if (strcmp(attr->name, "job-k-octets") == 0 &&
1109 attr->value_tag == IPP_TAG_INTEGER)
1110 job_k_octets = attr->values[0].integer;
1111
1112 if (strcmp(attr->name, "job-priority") == 0 &&
1113 attr->value_tag == IPP_TAG_INTEGER)
1114 job_priority = attr->values[0].integer;
1115
1116 if (strcmp(attr->name, "job-state") == 0 &&
1117 attr->value_tag == IPP_TAG_ENUM)
1118 job_status = (ipp_jstate_t)(attr->values[0].integer);
1119
1120 if (strcmp(attr->name, "time-at-creation") == 0 &&
1121 attr->value_tag == IPP_TAG_INTEGER)
1122 {
1123 /*
1124 * If jobs times are in Unix time, the accuracy of the job
1125 * start time depends upon the iPrint server's time being
1126 * set correctly. Otherwise, the accuracy depends upon
1127 * the Samba server's time being set correctly
1128 */
1129
1130 if (jobUseUnixTime)
1131 job_time = attr->values[0].integer;
1132 else
1133 job_time = time(NULL) - printer_up_time + attr->values[0].integer;
1134 }
1135
1136 if (strcmp(attr->name, "job-name") == 0 &&
1137 (attr->value_tag == IPP_TAG_NAMELANG ||
1138 attr->value_tag == IPP_TAG_NAME))
1139 job_name = attr->values[0].string.text;
1140
1141 if (strcmp(attr->name, "job-originating-user-name") == 0 &&
1142 (attr->value_tag == IPP_TAG_NAMELANG ||
1143 attr->value_tag == IPP_TAG_NAME))
1144 user_name = attr->values[0].string.text;
1145
1146 attr = attr->next;
1147 }
1148
1149 /*
1150 * See if we have everything needed...
1151 */
1152
1153 if (user_name == NULL || job_name == NULL || job_id == 0) {
1154 if (attr == NULL)
1155 break;
1156 else
1157 continue;
1158 }
1159
1160 temp->job = job_id;
1161 temp->size = job_k_octets * 1024;
1162 temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
1163 job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
1164 job_status == IPP_JOB_HELD ? LPQ_PAUSED :
1165 LPQ_PRINTING;
1166 temp->priority = job_priority;
1167 temp->time = job_time;
1168 strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1);
1169 strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1);
1170
1171 qcount ++;
1172
1173 if (attr == NULL)
1174 break;
1175 }
1176
1177 /*
1178 * Return the job queue...
1179 */
1180
1181 *q = queue;
1182
1183 out:
1184 if (response)
1185 ippDelete(response);
1186
1187 if (language)
1188 cupsLangFree(language);
1189
1190 if (http)
1191 httpClose(http);
1192
1193 return qcount;
1194 }
1195
1196
1197 /*
1198 * 'iprint_queue_pause()' - Pause a print queue.
1199 */
1200
1201 static int iprint_queue_pause(int snum)
1202 {
1203 return(-1); /* Not supported without credentials */
1204 }
1205
1206
1207 /*
1208 * 'iprint_queue_resume()' - Restart a print queue.
1209 */
1210
1211 static int iprint_queue_resume(int snum)
1212 {
1213 return(-1); /* Not supported without credentials */
1214 }
1215
1216 /*******************************************************************
1217 * iPrint printing interface definitions...
1218 ******************************************************************/
1219
1220 struct printif iprint_printif =
1221 {
1222 PRINT_IPRINT,
1223 iprint_queue_get,
1224 iprint_queue_pause,
1225 iprint_queue_resume,
1226 iprint_job_delete,
1227 iprint_job_pause,
1228 iprint_job_resume,
1229 iprint_job_submit,
1230 };
1231
1232 #else
1233 /* this keeps fussy compilers happy */
1234 void print_iprint_dummy(void);
1235 void print_iprint_dummy(void) {}
1236 #endif /* HAVE_IPRINT */
reg import