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