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