?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix bug #5080. Access to cups-printers via samba broken with cups 1.3.4, Unsupported...
[Samba.git] / source / printing / print_cups.c
blob0be65a58befc0a8544c0aeded960dce340a817c9
1 /*
2 * Support code for the Common UNIX Printing System ("CUPS")
3 *
4 * Copyright 1999-2003 by Michael R Sweet.
5 * Copyright 2008 Jeremy Allison.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 /*
22 * JRA. Converted to utf8 pull/push.
23 */
24
25 #include "includes.h"
26 #include "printing.h"
27
28 #ifdef HAVE_CUPS
29 #include <cups/cups.h>
30 #include <cups/language.h>
31
32 extern userdom_struct current_user_info;
33
34 /*
35 * 'cups_passwd_cb()' - The CUPS password callback...
36 */
37
38 static const char * /* O - Password or NULL */
39 cups_passwd_cb(const char *prompt) /* I - Prompt */
40 {
41 /*
42 * Always return NULL to indicate that no password is available...
43 */
44
45 return (NULL);
46 }
47
48 static http_t *cups_connect(TALLOC_CTX *frame)
49 {
50 http_t *http = NULL;
51 char *server = NULL, *p = NULL;
52 int port;
53
54 if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
55 if (push_utf8_talloc(frame, &server, lp_cups_server()) == (size_t)-1) {
56 return NULL;
57 }
58 } else {
59 server = talloc_strdup(frame,cupsServer());
60 }
61 if (!server) {
62 return NULL;
63 }
64
65 p = strchr(server, ':');
66 if (p) {
67 port = atoi(p+1);
68 *p = '\0';
69 } else {
70 port = ippPort();
71 }
72
73 DEBUG(10, ("connecting to cups server %s:%d\n",
74 server, port));
75
76 if ((http = httpConnect(server, port)) == NULL) {
77 DEBUG(0,("Unable to connect to CUPS server %s:%d - %s\n",
78 server, port, strerror(errno)));
79 return NULL;
80 }
81
82 return http;
83 }
84
85 bool cups_cache_reload(void)
86 {
87 TALLOC_CTX *frame = talloc_stackframe();
88 http_t *http = NULL; /* HTTP connection to server */
89 ipp_t *request = NULL, /* IPP Request */
90 *response = NULL; /* IPP Response */
91 ipp_attribute_t *attr; /* Current attribute */
92 cups_lang_t *language = NULL; /* Default language */
93 char *name, /* printer-name attribute */
94 *info; /* printer-info attribute */
95 static const char *requested[] =/* Requested attributes */
96 {
97 "printer-name",
98 "printer-info"
99 };
100 bool ret = False;
101
102 DEBUG(5, ("reloading cups printcap cache\n"));
103
104 /*
105 * Make sure we don't ask for passwords...
106 */
107
108 cupsSetPasswordCB(cups_passwd_cb);
109
110 /*
111 * Try to connect to the server...
112 */
113
114 if ((http = cups_connect(frame)) == NULL) {
115 goto out;
116 }
117
118 /*
119 * Build a CUPS_GET_PRINTERS request, which requires the following
120 * attributes:
121 *
122 * attributes-charset
123 * attributes-natural-language
124 * requested-attributes
125 */
126
127 request = ippNew();
128
129 request->request.op.operation_id = CUPS_GET_PRINTERS;
130 request->request.op.request_id = 1;
131
132 language = cupsLangDefault();
133
134 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
135 "attributes-charset", NULL, "utf-8");
136
137 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
138 "attributes-natural-language", NULL, language->language);
139
140 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
141 "requested-attributes",
142 (sizeof(requested) / sizeof(requested[0])),
143 NULL, requested);
144
145 /*
146 * Do the request and get back a response...
147 */
148
149 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
150 DEBUG(0,("Unable to get printer list - %s\n",
151 ippErrorString(cupsLastError())));
152 goto out;
153 }
154
155 for (attr = response->attrs; attr != NULL;) {
156 /*
157 * Skip leading attributes until we hit a printer...
158 */
159
160 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
161 attr = attr->next;
162
163 if (attr == NULL)
164 break;
165
166 /*
167 * Pull the needed attributes from this printer...
168 */
169
170 name = NULL;
171 info = NULL;
172
173 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
174 if (strcmp(attr->name, "printer-name") == 0 &&
175 attr->value_tag == IPP_TAG_NAME) {
176 pull_utf8_talloc(frame,
177 &name,
178 attr->values[0].string.text);
179 }
180
181 if (strcmp(attr->name, "printer-info") == 0 &&
182 attr->value_tag == IPP_TAG_TEXT) {
183 pull_utf8_talloc(frame,
184 &info,
185 attr->values[0].string.text);
186 }
187
188 attr = attr->next;
189 }
190
191 /*
192 * See if we have everything needed...
193 */
194
195 if (name == NULL)
196 break;
197
198 if (!pcap_cache_add(name, info)) {
199 goto out;
200 }
201 }
202
203 ippDelete(response);
204 response = NULL;
205
206 /*
207 * Build a CUPS_GET_CLASSES request, which requires the following
208 * attributes:
209 *
210 * attributes-charset
211 * attributes-natural-language
212 * requested-attributes
213 */
214
215 request = ippNew();
216
217 request->request.op.operation_id = CUPS_GET_CLASSES;
218 request->request.op.request_id = 1;
219
220 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
221 "attributes-charset", NULL, "utf-8");
222
223 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
224 "attributes-natural-language", NULL, language->language);
225
226 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
227 "requested-attributes",
228 (sizeof(requested) / sizeof(requested[0])),
229 NULL, requested);
230
231 /*
232 * Do the request and get back a response...
233 */
234
235 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
236 DEBUG(0,("Unable to get printer list - %s\n",
237 ippErrorString(cupsLastError())));
238 goto out;
239 }
240
241 for (attr = response->attrs; attr != NULL;) {
242 /*
243 * Skip leading attributes until we hit a printer...
244 */
245
246 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
247 attr = attr->next;
248
249 if (attr == NULL)
250 break;
251
252 /*
253 * Pull the needed attributes from this printer...
254 */
255
256 name = NULL;
257 info = NULL;
258
259 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
260 if (strcmp(attr->name, "printer-name") == 0 &&
261 attr->value_tag == IPP_TAG_NAME) {
262 pull_utf8_talloc(frame,
263 &name,
264 attr->values[0].string.text);
265 }
266
267 if (strcmp(attr->name, "printer-info") == 0 &&
268 attr->value_tag == IPP_TAG_TEXT) {
269 pull_utf8_talloc(frame,
270 &info,
271 attr->values[0].string.text);
272 }
273
274 attr = attr->next;
275 }
276
277 /*
278 * See if we have everything needed...
279 */
280
281 if (name == NULL)
282 break;
283
284 if (!pcap_cache_add(name, info)) {
285 goto out;
286 }
287 }
288
289 ret = True;
290
291 out:
292 if (response)
293 ippDelete(response);
294
295 if (language)
296 cupsLangFree(language);
297
298 if (http)
299 httpClose(http);
300
301 TALLOC_FREE(frame);
302 return ret;
303 }
304
305
306 /*
307 * 'cups_job_delete()' - Delete a job.
308 */
309
310 static int cups_job_delete(const char *sharename, const char *lprm_command, struct printjob *pjob)
311 {
312 TALLOC_CTX *frame = talloc_stackframe();
313 int ret = 1; /* Return value */
314 http_t *http = NULL; /* HTTP connection to server */
315 ipp_t *request = NULL, /* IPP Request */
316 *response = NULL; /* IPP Response */
317 cups_lang_t *language = NULL; /* Default language */
318 char *user = NULL;
319 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
320
321
322 DEBUG(5,("cups_job_delete(%s, %p (%d))\n", sharename, pjob, pjob->sysjob));
323
324 /*
325 * Make sure we don't ask for passwords...
326 */
327
328 cupsSetPasswordCB(cups_passwd_cb);
329
330 /*
331 * Try to connect to the server...
332 */
333
334 if ((http = cups_connect(frame)) == NULL) {
335 goto out;
336 }
337
338 /*
339 * Build an IPP_CANCEL_JOB request, which requires the following
340 * attributes:
341 *
342 * attributes-charset
343 * attributes-natural-language
344 * job-uri
345 * requesting-user-name
346 */
347
348 request = ippNew();
349
350 request->request.op.operation_id = IPP_CANCEL_JOB;
351 request->request.op.request_id = 1;
352
353 language = cupsLangDefault();
354
355 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
356 "attributes-charset", NULL, "utf-8");
357
358 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
359 "attributes-natural-language", NULL, language->language);
360
361 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
362
363 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
364
365 if (push_utf8_talloc(frame, &user, pjob->user) == (size_t)-1) {
366 goto out;
367 }
368
369 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
370 NULL, user);
371
372 /*
373 * Do the request and get back a response...
374 */
375
376 if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
377 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
378 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
379 ippErrorString(cupsLastError())));
380 } else {
381 ret = 0;
382 }
383 } else {
384 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
385 ippErrorString(cupsLastError())));
386 }
387
388 out:
389 if (response)
390 ippDelete(response);
391
392 if (language)
393 cupsLangFree(language);
394
395 if (http)
396 httpClose(http);
397
398 TALLOC_FREE(frame);
399 return ret;
400 }
401
402
403 /*
404 * 'cups_job_pause()' - Pause a job.
405 */
406
407 static int cups_job_pause(int snum, struct printjob *pjob)
408 {
409 TALLOC_CTX *frame = talloc_stackframe();
410 int ret = 1; /* Return value */
411 http_t *http = NULL; /* HTTP connection to server */
412 ipp_t *request = NULL, /* IPP Request */
413 *response = NULL; /* IPP Response */
414 cups_lang_t *language = NULL; /* Default language */
415 char *user = NULL;
416 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
417
418
419 DEBUG(5,("cups_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
420
421 /*
422 * Make sure we don't ask for passwords...
423 */
424
425 cupsSetPasswordCB(cups_passwd_cb);
426
427 /*
428 * Try to connect to the server...
429 */
430
431 if ((http = cups_connect(frame)) == NULL) {
432 goto out;
433 }
434
435 /*
436 * Build an IPP_HOLD_JOB request, which requires the following
437 * attributes:
438 *
439 * attributes-charset
440 * attributes-natural-language
441 * job-uri
442 * requesting-user-name
443 */
444
445 request = ippNew();
446
447 request->request.op.operation_id = IPP_HOLD_JOB;
448 request->request.op.request_id = 1;
449
450 language = cupsLangDefault();
451
452 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
453 "attributes-charset", NULL, "utf-8");
454
455 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
456 "attributes-natural-language", NULL, language->language);
457
458 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
459
460 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
461
462 if (push_utf8_talloc(frame, &user, pjob->user) == (size_t)-1) {
463 goto out;
464 }
465 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
466 NULL, user);
467
468 /*
469 * Do the request and get back a response...
470 */
471
472 if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
473 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
474 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
475 ippErrorString(cupsLastError())));
476 } else {
477 ret = 0;
478 }
479 } else {
480 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
481 ippErrorString(cupsLastError())));
482 }
483
484 out:
485 if (response)
486 ippDelete(response);
487
488 if (language)
489 cupsLangFree(language);
490
491 if (http)
492 httpClose(http);
493
494 TALLOC_FREE(frame);
495 return ret;
496 }
497
498
499 /*
500 * 'cups_job_resume()' - Resume a paused job.
501 */
502
503 static int cups_job_resume(int snum, struct printjob *pjob)
504 {
505 TALLOC_CTX *frame = talloc_stackframe();
506 int ret = 1; /* Return value */
507 http_t *http = NULL; /* HTTP connection to server */
508 ipp_t *request = NULL, /* IPP Request */
509 *response = NULL; /* IPP Response */
510 cups_lang_t *language = NULL; /* Default language */
511 char *user = NULL;
512 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
513
514
515 DEBUG(5,("cups_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
516
517 /*
518 * Make sure we don't ask for passwords...
519 */
520
521 cupsSetPasswordCB(cups_passwd_cb);
522
523 /*
524 * Try to connect to the server...
525 */
526
527 if ((http = cups_connect(frame)) == NULL) {
528 goto out;
529 }
530
531 /*
532 * Build an IPP_RELEASE_JOB request, which requires the following
533 * attributes:
534 *
535 * attributes-charset
536 * attributes-natural-language
537 * job-uri
538 * requesting-user-name
539 */
540
541 request = ippNew();
542
543 request->request.op.operation_id = IPP_RELEASE_JOB;
544 request->request.op.request_id = 1;
545
546 language = cupsLangDefault();
547
548 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
549 "attributes-charset", NULL, "utf-8");
550
551 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
552 "attributes-natural-language", NULL, language->language);
553
554 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
555
556 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
557
558 if (push_utf8_talloc(frame, &user, pjob->user) == (size_t)-1) {
559 goto out;
560 }
561 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
562 NULL, user);
563
564 /*
565 * Do the request and get back a response...
566 */
567
568 if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
569 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
570 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
571 ippErrorString(cupsLastError())));
572 } else {
573 ret = 0;
574 }
575 } else {
576 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
577 ippErrorString(cupsLastError())));
578 }
579
580 out:
581 if (response)
582 ippDelete(response);
583
584 if (language)
585 cupsLangFree(language);
586
587 if (http)
588 httpClose(http);
589
590 TALLOC_FREE(frame);
591 return ret;
592 }
593
594
595 /*
596 * 'cups_job_submit()' - Submit a job for printing.
597 */
598
599 static int cups_job_submit(int snum, struct printjob *pjob)
600 {
601 TALLOC_CTX *frame = talloc_stackframe();
602 int ret = 1; /* Return value */
603 http_t *http = NULL; /* HTTP connection to server */
604 ipp_t *request = NULL, /* IPP Request */
605 *response = NULL; /* IPP Response */
606 cups_lang_t *language = NULL; /* Default language */
607 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
608 const char *clientname = NULL; /* hostname of client for job-originating-host attribute */
609 char *new_jobname = NULL;
610 int num_options = 0;
611 cups_option_t *options = NULL;
612 char *printername = NULL;
613 char *user = NULL;
614 char *jobname = NULL;
615 char *cupsoptions = NULL;
616 char *filename = NULL;
617 char addr[INET6_ADDRSTRLEN];
618
619 DEBUG(5,("cups_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
620
621 /*
622 * Make sure we don't ask for passwords...
623 */
624
625 cupsSetPasswordCB(cups_passwd_cb);
626
627 /*
628 * Try to connect to the server...
629 */
630
631 if ((http = cups_connect(frame)) == NULL) {
632 goto out;
633 }
634
635 /*
636 * Build an IPP_PRINT_JOB request, which requires the following
637 * attributes:
638 *
639 * attributes-charset
640 * attributes-natural-language
641 * printer-uri
642 * requesting-user-name
643 * [document-data]
644 */
645
646 request = ippNew();
647
648 request->request.op.operation_id = IPP_PRINT_JOB;
649 request->request.op.request_id = 1;
650
651 language = cupsLangDefault();
652
653 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
654 "attributes-charset", NULL, "utf-8");
655
656 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
657 "attributes-natural-language", NULL, language->language);
658
659 if (push_utf8_talloc(frame, &printername, PRINTERNAME(snum)) == (size_t)-1) {
660 goto out;
661 }
662 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
663 printername);
664
665 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
666 "printer-uri", NULL, uri);
667
668 if (push_utf8_talloc(frame, &user, pjob->user) == (size_t)-1) {
669 goto out;
670 }
671 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
672 NULL, user);
673
674 clientname = client_name(get_client_fd());
675 if (strcmp(clientname, "UNKNOWN") == 0) {
676 clientname = client_addr(get_client_fd(),addr,sizeof(addr));
677 }
678
679 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
680 "job-originating-host-name", NULL,
681 clientname);
682
683 if (push_utf8_talloc(frame, &jobname, pjob->jobname) == (size_t)-1) {
684 goto out;
685 }
686 new_jobname = talloc_asprintf(frame,
687 "%s%.8u %s", PRINT_SPOOL_PREFIX,
688 (unsigned int)pjob->smbjob,
689 jobname);
690 if (new_jobname == NULL) {
691 goto out;
692 }
693
694 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
695 new_jobname);
696
697 /*
698 * add any options defined in smb.conf
699 */
700
701 if (push_utf8_talloc(frame, &cupsoptions, lp_cups_options(snum)) == (size_t)-1) {
702 goto out;
703 }
704 num_options = 0;
705 options = NULL;
706 num_options = cupsParseOptions(cupsoptions, num_options, &options);
707
708 if ( num_options )
709 cupsEncodeOptions(request, num_options, options);
710
711 /*
712 * Do the request and get back a response...
713 */
714
715 slprintf(uri, sizeof(uri) - 1, "/printers/%s", printername);
716
717 if (push_utf8_talloc(frame, &filename, pjob->filename) == (size_t)-1) {
718 goto out;
719 }
720 if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
721 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
722 DEBUG(0,("Unable to print file to %s - %s\n", PRINTERNAME(snum),
723 ippErrorString(cupsLastError())));
724 } else {
725 ret = 0;
726 }
727 } else {
728 DEBUG(0,("Unable to print file to `%s' - %s\n", PRINTERNAME(snum),
729 ippErrorString(cupsLastError())));
730 }
731
732 if ( ret == 0 )
733 unlink(pjob->filename);
734 /* else print_job_end will do it for us */
735
736 out:
737 if (response)
738 ippDelete(response);
739
740 if (language)
741 cupsLangFree(language);
742
743 if (http)
744 httpClose(http);
745
746 TALLOC_FREE(frame);
747
748 return ret;
749 }
750
751 /*
752 * 'cups_queue_get()' - Get all the jobs in the print queue.
753 */
754
755 static int cups_queue_get(const char *sharename,
756 enum printing_types printing_type,
757 char *lpq_command,
758 print_queue_struct **q,
759 print_status_struct *status)
760 {
761 TALLOC_CTX *frame = talloc_stackframe();
762 char *printername = NULL;
763 http_t *http = NULL; /* HTTP connection to server */
764 ipp_t *request = NULL, /* IPP Request */
765 *response = NULL; /* IPP Response */
766 ipp_attribute_t *attr = NULL; /* Current attribute */
767 cups_lang_t *language = NULL; /* Default language */
768 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
769 int qcount = 0, /* Number of active queue entries */
770 qalloc = 0; /* Number of queue entries allocated */
771 print_queue_struct *queue = NULL, /* Queue entries */
772 *temp; /* Temporary pointer for queue */
773 char *user_name = NULL, /* job-originating-user-name attribute */
774 *job_name = NULL; /* job-name attribute */
775 int job_id; /* job-id attribute */
776 int job_k_octets; /* job-k-octets attribute */
777 time_t job_time; /* time-at-creation attribute */
778 ipp_jstate_t job_status; /* job-status attribute */
779 int job_priority; /* job-priority attribute */
780 static const char *jattrs[] = /* Requested job attributes */
781 {
782 "job-id",
783 "job-k-octets",
784 "job-name",
785 "job-originating-user-name",
786 "job-priority",
787 "job-state",
788 "time-at-creation",
789 };
790 static const char *pattrs[] = /* Requested printer attributes */
791 {
792 "printer-state",
793 "printer-state-message"
794 };
795
796 *q = NULL;
797
798 /* HACK ALERT!!! The problem with support the 'printer name'
799 option is that we key the tdb off the sharename. So we will
800 overload the lpq_command string to pass in the printername
801 (which is basically what we do for non-cups printers ... using
802 the lpq_command to get the queue listing). */
803
804 if (push_utf8_talloc(frame, &printername, lpq_command) == (size_t)-1) {
805 goto out;
806 }
807 DEBUG(5,("cups_queue_get(%s, %p, %p)\n", lpq_command, q, status));
808
809 /*
810 * Make sure we don't ask for passwords...
811 */
812
813 cupsSetPasswordCB(cups_passwd_cb);
814
815 /*
816 * Try to connect to the server...
817 */
818
819 if ((http = cups_connect(frame)) == NULL) {
820 goto out;
821 }
822
823 /*
824 * Generate the printer URI...
825 */
826
827 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s", printername);
828
829 /*
830 * Build an IPP_GET_JOBS request, which requires the following
831 * attributes:
832 *
833 * attributes-charset
834 * attributes-natural-language
835 * requested-attributes
836 * printer-uri
837 */
838
839 request = ippNew();
840
841 request->request.op.operation_id = IPP_GET_JOBS;
842 request->request.op.request_id = 1;
843
844 language = cupsLangDefault();
845
846 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
847 "attributes-charset", NULL, "utf-8");
848
849 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
850 "attributes-natural-language", NULL, language->language);
851
852 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
853 "requested-attributes",
854 (sizeof(jattrs) / sizeof(jattrs[0])),
855 NULL, jattrs);
856
857 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
858 "printer-uri", NULL, uri);
859
860 /*
861 * Do the request and get back a response...
862 */
863
864 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
865 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
866 ippErrorString(cupsLastError())));
867 goto out;
868 }
869
870 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
871 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
872 ippErrorString(response->request.status.status_code)));
873 goto out;
874 }
875
876 /*
877 * Process the jobs...
878 */
879
880 qcount = 0;
881 qalloc = 0;
882 queue = NULL;
883
884 for (attr = response->attrs; attr != NULL; attr = attr->next) {
885 /*
886 * Skip leading attributes until we hit a job...
887 */
888
889 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
890 attr = attr->next;
891
892 if (attr == NULL)
893 break;
894
895 /*
896 * Allocate memory as needed...
897 */
898 if (qcount >= qalloc) {
899 qalloc += 16;
900
901 queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc);
902
903 if (queue == NULL) {
904 DEBUG(0,("cups_queue_get: Not enough memory!"));
905 qcount = 0;
906 goto out;
907 }
908 }
909
910 temp = queue + qcount;
911 memset(temp, 0, sizeof(print_queue_struct));
912
913 /*
914 * Pull the needed attributes from this job...
915 */
916
917 job_id = 0;
918 job_priority = 50;
919 job_status = IPP_JOB_PENDING;
920 job_time = 0;
921 job_k_octets = 0;
922 user_name = NULL;
923 job_name = NULL;
924
925 while (attr != NULL && attr->group_tag == IPP_TAG_JOB) {
926 if (attr->name == NULL) {
927 attr = attr->next;
928 break;
929 }
930
931 if (strcmp(attr->name, "job-id") == 0 &&
932 attr->value_tag == IPP_TAG_INTEGER)
933 job_id = attr->values[0].integer;
934
935 if (strcmp(attr->name, "job-k-octets") == 0 &&
936 attr->value_tag == IPP_TAG_INTEGER)
937 job_k_octets = attr->values[0].integer;
938
939 if (strcmp(attr->name, "job-priority") == 0 &&
940 attr->value_tag == IPP_TAG_INTEGER)
941 job_priority = attr->values[0].integer;
942
943 if (strcmp(attr->name, "job-state") == 0 &&
944 attr->value_tag == IPP_TAG_ENUM)
945 job_status = (ipp_jstate_t)(attr->values[0].integer);
946
947 if (strcmp(attr->name, "time-at-creation") == 0 &&
948 attr->value_tag == IPP_TAG_INTEGER)
949 job_time = attr->values[0].integer;
950
951 if (strcmp(attr->name, "job-name") == 0 &&
952 attr->value_tag == IPP_TAG_NAME) {
953 pull_utf8_talloc(frame,
954 &job_name,
955 attr->values[0].string.text);
956 }
957
958 if (strcmp(attr->name, "job-originating-user-name") == 0 &&
959 attr->value_tag == IPP_TAG_NAME) {
960 pull_utf8_talloc(frame,
961 &user_name,
962 attr->values[0].string.text);
963 }
964
965 attr = attr->next;
966 }
967
968 /*
969 * See if we have everything needed...
970 */
971
972 if (user_name == NULL || job_name == NULL || job_id == 0) {
973 if (attr == NULL)
974 break;
975 else
976 continue;
977 }
978
979 temp->job = job_id;
980 temp->size = job_k_octets * 1024;
981 temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
982 job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
983 job_status == IPP_JOB_HELD ? LPQ_PAUSED :
984 LPQ_PRINTING;
985 temp->priority = job_priority;
986 temp->time = job_time;
987 strlcpy(temp->fs_user, user_name, sizeof(temp->fs_user));
988 strlcpy(temp->fs_file, job_name, sizeof(temp->fs_file));
989
990 qcount ++;
991
992 if (attr == NULL)
993 break;
994 }
995
996 ippDelete(response);
997 response = NULL;
998
999 /*
1000 * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the
1001 * following attributes:
1002 *
1003 * attributes-charset
1004 * attributes-natural-language
1005 * requested-attributes
1006 * printer-uri
1007 */
1008
1009 request = ippNew();
1010
1011 request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
1012 request->request.op.request_id = 1;
1013
1014 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1015 "attributes-charset", NULL, "utf-8");
1016
1017 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1018 "attributes-natural-language", NULL, language->language);
1019
1020 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1021 "requested-attributes",
1022 (sizeof(pattrs) / sizeof(pattrs[0])),
1023 NULL, pattrs);
1024
1025 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1026 "printer-uri", NULL, uri);
1027
1028 /*
1029 * Do the request and get back a response...
1030 */
1031
1032 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
1033 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
1034 ippErrorString(cupsLastError())));
1035 *q = queue;
1036 goto out;
1037 }
1038
1039 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1040 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
1041 ippErrorString(response->request.status.status_code)));
1042 *q = queue;
1043 goto out;
1044 }
1045
1046 /*
1047 * Get the current printer status and convert it to the SAMBA values.
1048 */
1049
1050 if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) {
1051 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
1052 status->status = LPSTAT_STOPPED;
1053 else
1054 status->status = LPSTAT_OK;
1055 }
1056
1057 if ((attr = ippFindAttribute(response, "printer-state-message",
1058 IPP_TAG_TEXT)) != NULL) {
1059 char *msg = NULL;
1060 pull_utf8_talloc(frame, &msg, attr->values[0].string.text);
1061 fstrcpy(status->message, msg);
1062 }
1063
1064 /*
1065 * Return the job queue...
1066 */
1067
1068 *q = queue;
1069
1070 out:
1071 if (response)
1072 ippDelete(response);
1073
1074 if (language)
1075 cupsLangFree(language);
1076
1077 if (http)
1078 httpClose(http);
1079
1080 TALLOC_FREE(frame);
1081 return qcount;
1082 }
1083
1084
1085 /*
1086 * 'cups_queue_pause()' - Pause a print queue.
1087 */
1088
1089 static int cups_queue_pause(int snum)
1090 {
1091 TALLOC_CTX *frame = talloc_stackframe();
1092 int ret = 1; /* Return value */
1093 http_t *http = NULL; /* HTTP connection to server */
1094 ipp_t *request = NULL, /* IPP Request */
1095 *response = NULL; /* IPP Response */
1096 cups_lang_t *language = NULL; /* Default language */
1097 char *printername = NULL;
1098 char *username = NULL;
1099 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
1100
1101
1102 DEBUG(5,("cups_queue_pause(%d)\n", snum));
1103
1104 /*
1105 * Make sure we don't ask for passwords...
1106 */
1107
1108 cupsSetPasswordCB(cups_passwd_cb);
1109
1110 /*
1111 * Try to connect to the server...
1112 */
1113
1114 if ((http = cups_connect(frame)) == NULL) {
1115 goto out;
1116 }
1117
1118 /*
1119 * Build an IPP_PAUSE_PRINTER request, which requires the following
1120 * attributes:
1121 *
1122 * attributes-charset
1123 * attributes-natural-language
1124 * printer-uri
1125 * requesting-user-name
1126 */
1127
1128 request = ippNew();
1129
1130 request->request.op.operation_id = IPP_PAUSE_PRINTER;
1131 request->request.op.request_id = 1;
1132
1133 language = cupsLangDefault();
1134
1135 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1136 "attributes-charset", NULL, "utf-8");
1137
1138 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1139 "attributes-natural-language", NULL, language->language);
1140
1141 if (push_utf8_talloc(frame, &printername, PRINTERNAME(snum)) == (size_t)-1) {
1142 goto out;
1143 }
1144 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1145 printername);
1146
1147 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1148
1149 if (push_utf8_talloc(frame, &username, current_user_info.unix_name) == (size_t)-1) {
1150 goto out;
1151 }
1152 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1153 NULL, username);
1154
1155 /*
1156 * Do the request and get back a response...
1157 */
1158
1159 if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) {
1160 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1161 DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1162 ippErrorString(cupsLastError())));
1163 } else {
1164 ret = 0;
1165 }
1166 } else {
1167 DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1168 ippErrorString(cupsLastError())));
1169 }
1170
1171 out:
1172 if (response)
1173 ippDelete(response);
1174
1175 if (language)
1176 cupsLangFree(language);
1177
1178 if (http)
1179 httpClose(http);
1180
1181 TALLOC_FREE(frame);
1182 return ret;
1183 }
1184
1185
1186 /*
1187 * 'cups_queue_resume()' - Restart a print queue.
1188 */
1189
1190 static int cups_queue_resume(int snum)
1191 {
1192 TALLOC_CTX *frame = talloc_stackframe();
1193 int ret = 1; /* Return value */
1194 http_t *http = NULL; /* HTTP connection to server */
1195 ipp_t *request = NULL, /* IPP Request */
1196 *response = NULL; /* IPP Response */
1197 cups_lang_t *language = NULL; /* Default language */
1198 char *printername = NULL;
1199 char *username = NULL;
1200 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
1201
1202
1203 DEBUG(5,("cups_queue_resume(%d)\n", snum));
1204
1205 /*
1206 * Make sure we don't ask for passwords...
1207 */
1208
1209 cupsSetPasswordCB(cups_passwd_cb);
1210
1211 /*
1212 * Try to connect to the server...
1213 */
1214
1215 if ((http = cups_connect(frame)) == NULL) {
1216 goto out;
1217 }
1218
1219 /*
1220 * Build an IPP_RESUME_PRINTER request, which requires the following
1221 * attributes:
1222 *
1223 * attributes-charset
1224 * attributes-natural-language
1225 * printer-uri
1226 * requesting-user-name
1227 */
1228
1229 request = ippNew();
1230
1231 request->request.op.operation_id = IPP_RESUME_PRINTER;
1232 request->request.op.request_id = 1;
1233
1234 language = cupsLangDefault();
1235
1236 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1237 "attributes-charset", NULL, "utf-8");
1238
1239 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1240 "attributes-natural-language", NULL, language->language);
1241
1242 if (push_utf8_talloc(frame, &printername, PRINTERNAME(snum)) == (size_t)-1) {
1243 goto out;
1244 }
1245 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1246 printername);
1247
1248 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1249
1250 if (push_utf8_talloc(frame, &username, current_user_info.unix_name) == (size_t)-1) {
1251 goto out;
1252 }
1253 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1254 NULL, username);
1255
1256 /*
1257 * Do the request and get back a response...
1258 */
1259
1260 if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) {
1261 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1262 DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1263 ippErrorString(cupsLastError())));
1264 } else {
1265 ret = 0;
1266 }
1267 } else {
1268 DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1269 ippErrorString(cupsLastError())));
1270 }
1271
1272 out:
1273 if (response)
1274 ippDelete(response);
1275
1276 if (language)
1277 cupsLangFree(language);
1278
1279 if (http)
1280 httpClose(http);
1281
1282 TALLOC_FREE(frame);
1283 return ret;
1284 }
1285
1286 /*******************************************************************
1287 * CUPS printing interface definitions...
1288 ******************************************************************/
1289
1290 struct printif cups_printif =
1291 {
1292 PRINT_CUPS,
1293 cups_queue_get,
1294 cups_queue_pause,
1295 cups_queue_resume,
1296 cups_job_delete,
1297 cups_job_pause,
1298 cups_job_resume,
1299 cups_job_submit,
1300 };
1301
1302 bool cups_pull_comment_location(NT_PRINTER_INFO_LEVEL_2 *printer)
1303 {
1304 TALLOC_CTX *frame = talloc_stackframe();
1305 http_t *http = NULL; /* HTTP connection to server */
1306 ipp_t *request = NULL, /* IPP Request */
1307 *response = NULL; /* IPP Response */
1308 ipp_attribute_t *attr; /* Current attribute */
1309 cups_lang_t *language = NULL; /* Default language */
1310 char uri[HTTP_MAX_URI];
1311 char *server = NULL;
1312 char *sharename = NULL;
1313 char *name = NULL;
1314 static const char *requested[] =/* Requested attributes */
1315 {
1316 "printer-name",
1317 "printer-info",
1318 "printer-location"
1319 };
1320 bool ret = False;
1321
1322 DEBUG(5, ("pulling %s location\n", printer->sharename));
1323
1324 /*
1325 * Make sure we don't ask for passwords...
1326 */
1327
1328 cupsSetPasswordCB(cups_passwd_cb);
1329
1330 /*
1331 * Try to connect to the server...
1332 */
1333
1334 if ((http = cups_connect(frame)) == NULL) {
1335 goto out;
1336 }
1337
1338 request = ippNew();
1339
1340 request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
1341 request->request.op.request_id = 1;
1342
1343 language = cupsLangDefault();
1344
1345 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1346 "attributes-charset", NULL, "utf-8");
1347
1348 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1349 "attributes-natural-language", NULL, language->language);
1350
1351 if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
1352 if (push_utf8_talloc(frame, &server, lp_cups_server()) == (size_t)-1) {
1353 goto out;
1354 }
1355 } else {
1356 server = talloc_strdup(frame,cupsServer());
1357 }
1358 if (server) {
1359 goto out;
1360 }
1361 if (push_utf8_talloc(frame, &sharename, printer->sharename) == (size_t)-1) {
1362 goto out;
1363 }
1364 slprintf(uri, sizeof(uri) - 1, "ipp://%s/printers/%s",
1365 server, sharename);
1366
1367 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1368 "printer-uri", NULL, uri);
1369
1370 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1371 "requested-attributes",
1372 (sizeof(requested) / sizeof(requested[0])),
1373 NULL, requested);
1374
1375 /*
1376 * Do the request and get back a response...
1377 */
1378
1379 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
1380 DEBUG(0,("Unable to get printer attributes - %s\n",
1381 ippErrorString(cupsLastError())));
1382 goto out;
1383 }
1384
1385 for (attr = response->attrs; attr != NULL;) {
1386 /*
1387 * Skip leading attributes until we hit a printer...
1388 */
1389
1390 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
1391 attr = attr->next;
1392
1393 if (attr == NULL)
1394 break;
1395
1396 /*
1397 * Pull the needed attributes from this printer...
1398 */
1399
1400 while ( attr && (attr->group_tag == IPP_TAG_PRINTER) ) {
1401 if (strcmp(attr->name, "printer-name") == 0 &&
1402 attr->value_tag == IPP_TAG_NAME) {
1403 pull_utf8_talloc(frame,
1404 &name,
1405 attr->values[0].string.text);
1406 }
1407
1408 /* Grab the comment if we don't have one */
1409 if ( (strcmp(attr->name, "printer-info") == 0)
1410 && (attr->value_tag == IPP_TAG_TEXT)
1411 && !strlen(printer->comment) )
1412 {
1413 char *comment = NULL;
1414 pull_utf8_talloc(frame,
1415 &comment,
1416 attr->values[0].string.text);
1417 DEBUG(5,("cups_pull_comment_location: Using cups comment: %s\n",
1418 comment));
1419 strlcpy(printer->comment,
1420 comment,
1421 sizeof(printer->comment));
1422 }
1423
1424 /* Grab the location if we don't have one */
1425 if ( (strcmp(attr->name, "printer-location") == 0)
1426 && (attr->value_tag == IPP_TAG_TEXT)
1427 && !strlen(printer->location) )
1428 {
1429 char *location = NULL;
1430 pull_utf8_talloc(frame,
1431 &location,
1432 attr->values[0].string.text);
1433 DEBUG(5,("cups_pull_comment_location: Using cups location: %s\n",
1434 location));
1435 strlcpy(printer->location,
1436 location,
1437 sizeof(printer->location));
1438 }
1439
1440 attr = attr->next;
1441 }
1442
1443 /*
1444 * We have everything needed...
1445 */
1446
1447 if (name != NULL)
1448 break;
1449 }
1450
1451 ret = True;
1452
1453 out:
1454 if (response)
1455 ippDelete(response);
1456
1457 if (language)
1458 cupsLangFree(language);
1459
1460 if (http)
1461 httpClose(http);
1462
1463 TALLOC_FREE(frame);
1464 return ret;
1465 }
1466
1467 #else
1468 /* this keeps fussy compilers happy */
1469 void print_cups_dummy(void);
1470 void print_cups_dummy(void) {}
1471 #endif /* HAVE_CUPS */
Samba GIT mirror