?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow data flow to be debugged and only log on error. All seems ok now.
[Samba.git] / source / printing / print_cups.c
blob6086bb858b0169d87e8ab8e860e5199572d97100
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 static SIG_ATOMIC_T gotalarm;
33
34 /***************************************************************
35 Signal function to tell us we timed out.
36 ****************************************************************/
37
38 static void gotalarm_sig(void)
39 {
40 gotalarm = 1;
41 }
42
43 extern userdom_struct current_user_info;
44
45 /*
46 * 'cups_passwd_cb()' - The CUPS password callback...
47 */
48
49 static const char * /* O - Password or NULL */
50 cups_passwd_cb(const char *prompt) /* I - Prompt */
51 {
52 /*
53 * Always return NULL to indicate that no password is available...
54 */
55
56 return (NULL);
57 }
58
59 static http_t *cups_connect(TALLOC_CTX *frame)
60 {
61 http_t *http = NULL;
62 char *server = NULL, *p = NULL;
63 int port;
64 int timeout = lp_cups_connection_timeout();
65 size_t size;
66
67 if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
68 if (!push_utf8_talloc(frame, &server, lp_cups_server(), &size)) {
69 return NULL;
70 }
71 } else {
72 server = talloc_strdup(frame,cupsServer());
73 }
74 if (!server) {
75 return NULL;
76 }
77
78 p = strchr(server, ':');
79 if (p) {
80 port = atoi(p+1);
81 *p = '\0';
82 } else {
83 port = ippPort();
84 }
85
86 DEBUG(10, ("connecting to cups server %s:%d\n",
87 server, port));
88
89 gotalarm = 0;
90
91 if (timeout) {
92 CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
93 alarm(timeout);
94 }
95
96 http = httpConnect(server, port);
97
98 CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
99 alarm(0);
100
101 if (http == NULL) {
102 DEBUG(0,("Unable to connect to CUPS server %s:%d - %s\n",
103 server, port, strerror(errno)));
104 }
105
106 return http;
107 }
108
109 static void send_pcap_info(const char *name, const char *info, void *pd)
110 {
111 int fd = *(int *)pd;
112 size_t namelen = name ? strlen(name)+1 : 0;
113 size_t infolen = info ? strlen(info)+1 : 0;
114
115 DEBUG(11,("send_pcap_info: writing namelen %u\n", (unsigned int)namelen));
116 if (sys_write(fd, &namelen, sizeof(namelen)) != sizeof(namelen)) {
117 DEBUG(10,("send_pcap_info: namelen write failed %s\n",
118 strerror(errno)));
119 return;
120 }
121 DEBUG(11,("send_pcap_info: writing infolen %u\n", (unsigned int)infolen));
122 if (sys_write(fd, &infolen, sizeof(infolen)) != sizeof(infolen)) {
123 DEBUG(10,("send_pcap_info: infolen write failed %s\n",
124 strerror(errno)));
125 return;
126 }
127 if (namelen) {
128 DEBUG(11,("send_pcap_info: writing name %s\n", name));
129 if (sys_write(fd, name, namelen) != namelen) {
130 DEBUG(10,("send_pcap_info: name write failed %s\n",
131 strerror(errno)));
132 return;
133 }
134 }
135 if (infolen) {
136 DEBUG(11,("send_pcap_info: writing info %s\n", info));
137 if (sys_write(fd, info, infolen) != infolen) {
138 DEBUG(10,("send_pcap_info: info write failed %s\n",
139 strerror(errno)));
140 return;
141 }
142 }
143 }
144
145 static bool cups_cache_reload_async(int fd)
146 {
147 TALLOC_CTX *frame = talloc_stackframe();
148 struct pcap_cache *tmp_pcap_cache = NULL;
149 http_t *http = NULL; /* HTTP connection to server */
150 ipp_t *request = NULL, /* IPP Request */
151 *response = NULL; /* IPP Response */
152 ipp_attribute_t *attr; /* Current attribute */
153 cups_lang_t *language = NULL; /* Default language */
154 char *name, /* printer-name attribute */
155 *info; /* printer-info attribute */
156 static const char *requested[] =/* Requested attributes */
157 {
158 "printer-name",
159 "printer-info"
160 };
161 bool ret = False;
162 size_t size;
163
164 DEBUG(5, ("reloading cups printcap cache\n"));
165
166 /*
167 * Make sure we don't ask for passwords...
168 */
169
170 cupsSetPasswordCB(cups_passwd_cb);
171
172 /*
173 * Try to connect to the server...
174 */
175
176 if ((http = cups_connect(frame)) == NULL) {
177 goto out;
178 }
179
180 /*
181 * Build a CUPS_GET_PRINTERS request, which requires the following
182 * attributes:
183 *
184 * attributes-charset
185 * attributes-natural-language
186 * requested-attributes
187 */
188
189 request = ippNew();
190
191 request->request.op.operation_id = CUPS_GET_PRINTERS;
192 request->request.op.request_id = 1;
193
194 language = cupsLangDefault();
195
196 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
197 "attributes-charset", NULL, "utf-8");
198
199 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
200 "attributes-natural-language", NULL, language->language);
201
202 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
203 "requested-attributes",
204 (sizeof(requested) / sizeof(requested[0])),
205 NULL, requested);
206
207 /*
208 * Do the request and get back a response...
209 */
210
211 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
212 DEBUG(0,("Unable to get printer list - %s\n",
213 ippErrorString(cupsLastError())));
214 goto out;
215 }
216
217 for (attr = response->attrs; attr != NULL;) {
218 /*
219 * Skip leading attributes until we hit a printer...
220 */
221
222 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
223 attr = attr->next;
224
225 if (attr == NULL)
226 break;
227
228 /*
229 * Pull the needed attributes from this printer...
230 */
231
232 name = NULL;
233 info = NULL;
234
235 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
236 if (strcmp(attr->name, "printer-name") == 0 &&
237 attr->value_tag == IPP_TAG_NAME) {
238 if (!pull_utf8_talloc(frame,
239 &name,
240 attr->values[0].string.text,
241 &size)) {
242 goto out;
243 }
244 }
245
246 if (strcmp(attr->name, "printer-info") == 0 &&
247 attr->value_tag == IPP_TAG_TEXT) {
248 if (!pull_utf8_talloc(frame,
249 &info,
250 attr->values[0].string.text,
251 &size)) {
252 goto out;
253 }
254 }
255
256 attr = attr->next;
257 }
258
259 /*
260 * See if we have everything needed...
261 */
262
263 if (name == NULL)
264 break;
265
266 if (!pcap_cache_add_specific(&tmp_pcap_cache, name, info)) {
267 goto out;
268 }
269 }
270
271 ippDelete(response);
272 response = NULL;
273
274 /*
275 * Build a CUPS_GET_CLASSES request, which requires the following
276 * attributes:
277 *
278 * attributes-charset
279 * attributes-natural-language
280 * requested-attributes
281 */
282
283 request = ippNew();
284
285 request->request.op.operation_id = CUPS_GET_CLASSES;
286 request->request.op.request_id = 1;
287
288 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
289 "attributes-charset", NULL, "utf-8");
290
291 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
292 "attributes-natural-language", NULL, language->language);
293
294 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
295 "requested-attributes",
296 (sizeof(requested) / sizeof(requested[0])),
297 NULL, requested);
298
299 /*
300 * Do the request and get back a response...
301 */
302
303 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
304 DEBUG(0,("Unable to get printer list - %s\n",
305 ippErrorString(cupsLastError())));
306 goto out;
307 }
308
309 for (attr = response->attrs; attr != NULL;) {
310 /*
311 * Skip leading attributes until we hit a printer...
312 */
313
314 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
315 attr = attr->next;
316
317 if (attr == NULL)
318 break;
319
320 /*
321 * Pull the needed attributes from this printer...
322 */
323
324 name = NULL;
325 info = NULL;
326
327 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
328 if (strcmp(attr->name, "printer-name") == 0 &&
329 attr->value_tag == IPP_TAG_NAME) {
330 if (!pull_utf8_talloc(frame,
331 &name,
332 attr->values[0].string.text,
333 &size)) {
334 goto out;
335 }
336 }
337
338 if (strcmp(attr->name, "printer-info") == 0 &&
339 attr->value_tag == IPP_TAG_TEXT) {
340 if (!pull_utf8_talloc(frame,
341 &info,
342 attr->values[0].string.text,
343 &size)) {
344 goto out;
345 }
346 }
347
348 attr = attr->next;
349 }
350
351 /*
352 * See if we have everything needed...
353 */
354
355 if (name == NULL)
356 break;
357
358 if (!pcap_cache_add_specific(&tmp_pcap_cache, name, info)) {
359 goto out;
360 }
361 }
362
363 ret = True;
364
365 out:
366 if (response)
367 ippDelete(response);
368
369 if (language)
370 cupsLangFree(language);
371
372 if (http)
373 httpClose(http);
374
375 /* Send all the entries up the pipe. */
376 if (tmp_pcap_cache) {
377 pcap_printer_fn_specific(tmp_pcap_cache,
378 send_pcap_info,
379 (void *)&fd);
380
381 pcap_cache_destroy_specific(&tmp_pcap_cache);
382 }
383 TALLOC_FREE(frame);
384 return ret;
385 }
386
387 static struct pcap_cache *local_pcap_copy;
388 struct fd_event *cache_fd_event;
389
390 static bool cups_pcap_load_async(int *pfd)
391 {
392 int fds[2];
393 pid_t pid;
394
395 *pfd = -1;
396
397 if (cache_fd_event) {
398 DEBUG(3,("cups_pcap_load_async: already waiting for "
399 "a refresh event\n" ));
400 return false;
401 }
402
403 DEBUG(5,("cups_pcap_load_async: asynchronously loading cups printers\n"));
404
405 if (pipe(fds) == -1) {
406 return false;
407 }
408
409 pid = sys_fork();
410 if (pid == (pid_t)-1) {
411 DEBUG(10,("cups_pcap_load_async: fork failed %s\n",
412 strerror(errno) ));
413 close(fds[0]);
414 close(fds[1]);
415 return false;
416 }
417
418 if (pid) {
419 DEBUG(10,("cups_pcap_load_async: child pid = %u\n",
420 (unsigned int)pid ));
421 /* Parent. */
422 close(fds[1]);
423 *pfd = fds[0];
424 return true;
425 }
426
427 /* Child. */
428 close(fds[0]);
429 cups_cache_reload_async(fds[1]);
430 close(fds[1]);
431 _exit(0);
432 }
433
434 static void cups_async_callback(struct event_context *event_ctx,
435 struct fd_event *event,
436 uint16 flags,
437 void *p)
438 {
439 TALLOC_CTX *frame = talloc_stackframe();
440 int fd = *(int *)p;
441 struct pcap_cache *tmp_pcap_cache = NULL;
442
443 DEBUG(5,("cups_async_callback: callback received for printer data. "
444 "fd = %d\n", fd));
445
446 while (1) {
447 char *name = NULL, *info = NULL;
448 size_t namelen = 0, infolen = 0;
449 ssize_t ret = -1;
450
451 ret = sys_read(fd, &namelen, sizeof(namelen));
452 if (ret == 0) {
453 /* EOF */
454 break;
455 }
456 if (ret != sizeof(namelen)) {
457 DEBUG(10,("cups_async_callback: namelen read failed %d %s\n",
458 errno, strerror(errno)));
459 break;
460 }
461
462 DEBUG(11,("cups_async_callback: read namelen %u\n",
463 (unsigned int)namelen));
464
465 ret = sys_read(fd, &infolen, sizeof(infolen));
466 if (ret == 0) {
467 /* EOF */
468 break;
469 }
470 if (ret != sizeof(infolen)) {
471 DEBUG(10,("cups_async_callback: infolen read failed %s\n",
472 strerror(errno)));
473 break;
474 }
475
476 DEBUG(11,("cups_async_callback: read infolen %u\n",
477 (unsigned int)infolen));
478
479 if (namelen) {
480 name = TALLOC_ARRAY(frame, char, namelen);
481 if (!name) {
482 break;
483 }
484 ret = sys_read(fd, name, namelen);
485 if (ret == 0) {
486 /* EOF */
487 break;
488 }
489 if (ret != namelen) {
490 DEBUG(10,("cups_async_callback: name read failed %s\n",
491 strerror(errno)));
492 break;
493 }
494 DEBUG(11,("cups_async_callback: read name %s\n",
495 name));
496 } else {
497 name = NULL;
498 }
499 if (infolen) {
500 info = TALLOC_ARRAY(frame, char, infolen);
501 if (!info) {
502 break;
503 }
504 ret = sys_read(fd, info, infolen);
505 if (ret == 0) {
506 /* EOF */
507 break;
508 }
509 if (ret != infolen) {
510 DEBUG(10,("cups_async_callback: info read failed %s\n",
511 strerror(errno)));
512 break;
513 }
514 DEBUG(11,("cups_async_callback: read info %s\n",
515 info));
516 } else {
517 info = NULL;
518 }
519
520 /* Add to our local pcap cache. */
521 pcap_cache_add_specific(&tmp_pcap_cache, name, info);
522 TALLOC_FREE(name);
523 TALLOC_FREE(info);
524 }
525
526 TALLOC_FREE(frame);
527 if (tmp_pcap_cache) {
528 /* We got a namelist, replace our local cache. */
529 pcap_cache_destroy_specific(&local_pcap_copy);
530 local_pcap_copy = tmp_pcap_cache;
531
532 /* And the systemwide pcap cache. */
533 pcap_cache_replace(local_pcap_copy);
534 } else {
535 DEBUG(2,("cups_async_callback: failed to read a new "
536 "printer list\n"));
537 }
538 close(fd);
539 TALLOC_FREE(p);
540 TALLOC_FREE(cache_fd_event);
541 }
542
543 bool cups_cache_reload(void)
544 {
545 int *p_pipe_fd = TALLOC_P(NULL, int);
546
547 if (!p_pipe_fd) {
548 return false;
549 }
550
551 /* Set up an async refresh. */
552 if (!cups_pcap_load_async(p_pipe_fd)) {
553 return false;
554 }
555 if (!local_pcap_copy) {
556 /* We have no local cache, wait directly for
557 * async refresh to complete.
558 */
559 DEBUG(10,("cups_cache_reload: sync read on fd %d\n",
560 *p_pipe_fd ));
561
562 cups_async_callback(smbd_event_context(),
563 NULL,
564 EVENT_FD_READ,
565 (void *)p_pipe_fd);
566 if (!local_pcap_copy) {
567 return false;
568 }
569 } else {
570 /* Replace the system cache with our
571 * local copy. */
572 pcap_cache_replace(local_pcap_copy);
573
574 DEBUG(10,("cups_cache_reload: async read on fd %d\n",
575 *p_pipe_fd ));
576
577 /* Trigger an event when the pipe can be read. */
578 cache_fd_event = event_add_fd(smbd_event_context(),
579 NULL, *p_pipe_fd,
580 EVENT_FD_READ,
581 cups_async_callback,
582 (void *)p_pipe_fd);
583 if (!cache_fd_event) {
584 close(*p_pipe_fd);
585 TALLOC_FREE(p_pipe_fd);
586 return false;
587 }
588 }
589 return true;
590 }
591
592 /*
593 * 'cups_job_delete()' - Delete a job.
594 */
595
596 static int cups_job_delete(const char *sharename, const char *lprm_command, struct printjob *pjob)
597 {
598 TALLOC_CTX *frame = talloc_stackframe();
599 int ret = 1; /* Return value */
600 http_t *http = NULL; /* HTTP connection to server */
601 ipp_t *request = NULL, /* IPP Request */
602 *response = NULL; /* IPP Response */
603 cups_lang_t *language = NULL; /* Default language */
604 char *user = NULL;
605 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
606 size_t size;
607
608 DEBUG(5,("cups_job_delete(%s, %p (%d))\n", sharename, pjob, pjob->sysjob));
609
610 /*
611 * Make sure we don't ask for passwords...
612 */
613
614 cupsSetPasswordCB(cups_passwd_cb);
615
616 /*
617 * Try to connect to the server...
618 */
619
620 if ((http = cups_connect(frame)) == NULL) {
621 goto out;
622 }
623
624 /*
625 * Build an IPP_CANCEL_JOB request, which requires the following
626 * attributes:
627 *
628 * attributes-charset
629 * attributes-natural-language
630 * job-uri
631 * requesting-user-name
632 */
633
634 request = ippNew();
635
636 request->request.op.operation_id = IPP_CANCEL_JOB;
637 request->request.op.request_id = 1;
638
639 language = cupsLangDefault();
640
641 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
642 "attributes-charset", NULL, "utf-8");
643
644 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
645 "attributes-natural-language", NULL, language->language);
646
647 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
648
649 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
650
651 if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
652 goto out;
653 }
654
655 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
656 NULL, user);
657
658 /*
659 * Do the request and get back a response...
660 */
661
662 if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
663 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
664 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
665 ippErrorString(cupsLastError())));
666 } else {
667 ret = 0;
668 }
669 } else {
670 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
671 ippErrorString(cupsLastError())));
672 }
673
674 out:
675 if (response)
676 ippDelete(response);
677
678 if (language)
679 cupsLangFree(language);
680
681 if (http)
682 httpClose(http);
683
684 TALLOC_FREE(frame);
685 return ret;
686 }
687
688
689 /*
690 * 'cups_job_pause()' - Pause a job.
691 */
692
693 static int cups_job_pause(int snum, struct printjob *pjob)
694 {
695 TALLOC_CTX *frame = talloc_stackframe();
696 int ret = 1; /* Return value */
697 http_t *http = NULL; /* HTTP connection to server */
698 ipp_t *request = NULL, /* IPP Request */
699 *response = NULL; /* IPP Response */
700 cups_lang_t *language = NULL; /* Default language */
701 char *user = NULL;
702 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
703 size_t size;
704
705 DEBUG(5,("cups_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
706
707 /*
708 * Make sure we don't ask for passwords...
709 */
710
711 cupsSetPasswordCB(cups_passwd_cb);
712
713 /*
714 * Try to connect to the server...
715 */
716
717 if ((http = cups_connect(frame)) == NULL) {
718 goto out;
719 }
720
721 /*
722 * Build an IPP_HOLD_JOB request, which requires the following
723 * attributes:
724 *
725 * attributes-charset
726 * attributes-natural-language
727 * job-uri
728 * requesting-user-name
729 */
730
731 request = ippNew();
732
733 request->request.op.operation_id = IPP_HOLD_JOB;
734 request->request.op.request_id = 1;
735
736 language = cupsLangDefault();
737
738 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
739 "attributes-charset", NULL, "utf-8");
740
741 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
742 "attributes-natural-language", NULL, language->language);
743
744 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
745
746 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
747
748 if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
749 goto out;
750 }
751 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
752 NULL, user);
753
754 /*
755 * Do the request and get back a response...
756 */
757
758 if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
759 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
760 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
761 ippErrorString(cupsLastError())));
762 } else {
763 ret = 0;
764 }
765 } else {
766 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
767 ippErrorString(cupsLastError())));
768 }
769
770 out:
771 if (response)
772 ippDelete(response);
773
774 if (language)
775 cupsLangFree(language);
776
777 if (http)
778 httpClose(http);
779
780 TALLOC_FREE(frame);
781 return ret;
782 }
783
784
785 /*
786 * 'cups_job_resume()' - Resume a paused job.
787 */
788
789 static int cups_job_resume(int snum, struct printjob *pjob)
790 {
791 TALLOC_CTX *frame = talloc_stackframe();
792 int ret = 1; /* Return value */
793 http_t *http = NULL; /* HTTP connection to server */
794 ipp_t *request = NULL, /* IPP Request */
795 *response = NULL; /* IPP Response */
796 cups_lang_t *language = NULL; /* Default language */
797 char *user = NULL;
798 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
799 size_t size;
800
801 DEBUG(5,("cups_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
802
803 /*
804 * Make sure we don't ask for passwords...
805 */
806
807 cupsSetPasswordCB(cups_passwd_cb);
808
809 /*
810 * Try to connect to the server...
811 */
812
813 if ((http = cups_connect(frame)) == NULL) {
814 goto out;
815 }
816
817 /*
818 * Build an IPP_RELEASE_JOB request, which requires the following
819 * attributes:
820 *
821 * attributes-charset
822 * attributes-natural-language
823 * job-uri
824 * requesting-user-name
825 */
826
827 request = ippNew();
828
829 request->request.op.operation_id = IPP_RELEASE_JOB;
830 request->request.op.request_id = 1;
831
832 language = cupsLangDefault();
833
834 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
835 "attributes-charset", NULL, "utf-8");
836
837 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
838 "attributes-natural-language", NULL, language->language);
839
840 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
841
842 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
843
844 if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
845 goto out;
846 }
847 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
848 NULL, user);
849
850 /*
851 * Do the request and get back a response...
852 */
853
854 if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
855 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
856 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
857 ippErrorString(cupsLastError())));
858 } else {
859 ret = 0;
860 }
861 } else {
862 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
863 ippErrorString(cupsLastError())));
864 }
865
866 out:
867 if (response)
868 ippDelete(response);
869
870 if (language)
871 cupsLangFree(language);
872
873 if (http)
874 httpClose(http);
875
876 TALLOC_FREE(frame);
877 return ret;
878 }
879
880
881 /*
882 * 'cups_job_submit()' - Submit a job for printing.
883 */
884
885 static int cups_job_submit(int snum, struct printjob *pjob)
886 {
887 TALLOC_CTX *frame = talloc_stackframe();
888 int ret = 1; /* Return value */
889 http_t *http = NULL; /* HTTP connection to server */
890 ipp_t *request = NULL, /* IPP Request */
891 *response = NULL; /* IPP Response */
892 cups_lang_t *language = NULL; /* Default language */
893 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
894 const char *clientname = NULL; /* hostname of client for job-originating-host attribute */
895 char *new_jobname = NULL;
896 int num_options = 0;
897 cups_option_t *options = NULL;
898 char *printername = NULL;
899 char *user = NULL;
900 char *jobname = NULL;
901 char *cupsoptions = NULL;
902 char *filename = NULL;
903 size_t size;
904 char addr[INET6_ADDRSTRLEN];
905
906 DEBUG(5,("cups_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
907
908 /*
909 * Make sure we don't ask for passwords...
910 */
911
912 cupsSetPasswordCB(cups_passwd_cb);
913
914 /*
915 * Try to connect to the server...
916 */
917
918 if ((http = cups_connect(frame)) == NULL) {
919 goto out;
920 }
921
922 /*
923 * Build an IPP_PRINT_JOB request, which requires the following
924 * attributes:
925 *
926 * attributes-charset
927 * attributes-natural-language
928 * printer-uri
929 * requesting-user-name
930 * [document-data]
931 */
932
933 request = ippNew();
934
935 request->request.op.operation_id = IPP_PRINT_JOB;
936 request->request.op.request_id = 1;
937
938 language = cupsLangDefault();
939
940 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
941 "attributes-charset", NULL, "utf-8");
942
943 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
944 "attributes-natural-language", NULL, language->language);
945
946 if (!push_utf8_talloc(frame, &printername, PRINTERNAME(snum), &size)) {
947 goto out;
948 }
949 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
950 printername);
951
952 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
953 "printer-uri", NULL, uri);
954
955 if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
956 goto out;
957 }
958 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
959 NULL, user);
960
961 clientname = client_name(get_client_fd());
962 if (strcmp(clientname, "UNKNOWN") == 0) {
963 clientname = client_addr(get_client_fd(),addr,sizeof(addr));
964 }
965
966 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
967 "job-originating-host-name", NULL,
968 clientname);
969
970 if (!push_utf8_talloc(frame, &jobname, pjob->jobname, &size)) {
971 goto out;
972 }
973 new_jobname = talloc_asprintf(frame,
974 "%s%.8u %s", PRINT_SPOOL_PREFIX,
975 (unsigned int)pjob->smbjob,
976 jobname);
977 if (new_jobname == NULL) {
978 goto out;
979 }
980
981 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
982 new_jobname);
983
984 /*
985 * add any options defined in smb.conf
986 */
987
988 if (!push_utf8_talloc(frame, &cupsoptions, lp_cups_options(snum), &size)) {
989 goto out;
990 }
991 num_options = 0;
992 options = NULL;
993 num_options = cupsParseOptions(cupsoptions, num_options, &options);
994
995 if ( num_options )
996 cupsEncodeOptions(request, num_options, options);
997
998 /*
999 * Do the request and get back a response...
1000 */
1001
1002 slprintf(uri, sizeof(uri) - 1, "/printers/%s", printername);
1003
1004 if (!push_utf8_talloc(frame, &filename, pjob->filename, &size)) {
1005 goto out;
1006 }
1007 if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
1008 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1009 DEBUG(0,("Unable to print file to %s - %s\n", PRINTERNAME(snum),
1010 ippErrorString(cupsLastError())));
1011 } else {
1012 ret = 0;
1013 }
1014 } else {
1015 DEBUG(0,("Unable to print file to `%s' - %s\n", PRINTERNAME(snum),
1016 ippErrorString(cupsLastError())));
1017 }
1018
1019 if ( ret == 0 )
1020 unlink(pjob->filename);
1021 /* else print_job_end will do it for us */
1022
1023 out:
1024 if (response)
1025 ippDelete(response);
1026
1027 if (language)
1028 cupsLangFree(language);
1029
1030 if (http)
1031 httpClose(http);
1032
1033 TALLOC_FREE(frame);
1034
1035 return ret;
1036 }
1037
1038 /*
1039 * 'cups_queue_get()' - Get all the jobs in the print queue.
1040 */
1041
1042 static int cups_queue_get(const char *sharename,
1043 enum printing_types printing_type,
1044 char *lpq_command,
1045 print_queue_struct **q,
1046 print_status_struct *status)
1047 {
1048 TALLOC_CTX *frame = talloc_stackframe();
1049 char *printername = NULL;
1050 http_t *http = NULL; /* HTTP connection to server */
1051 ipp_t *request = NULL, /* IPP Request */
1052 *response = NULL; /* IPP Response */
1053 ipp_attribute_t *attr = NULL; /* Current attribute */
1054 cups_lang_t *language = NULL; /* Default language */
1055 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
1056 int qcount = 0, /* Number of active queue entries */
1057 qalloc = 0; /* Number of queue entries allocated */
1058 print_queue_struct *queue = NULL, /* Queue entries */
1059 *temp; /* Temporary pointer for queue */
1060 char *user_name = NULL, /* job-originating-user-name attribute */
1061 *job_name = NULL; /* job-name attribute */
1062 int job_id; /* job-id attribute */
1063 int job_k_octets; /* job-k-octets attribute */
1064 time_t job_time; /* time-at-creation attribute */
1065 ipp_jstate_t job_status; /* job-status attribute */
1066 int job_priority; /* job-priority attribute */
1067 size_t size;
1068 static const char *jattrs[] = /* Requested job attributes */
1069 {
1070 "job-id",
1071 "job-k-octets",
1072 "job-name",
1073 "job-originating-user-name",
1074 "job-priority",
1075 "job-state",
1076 "time-at-creation",
1077 };
1078 static const char *pattrs[] = /* Requested printer attributes */
1079 {
1080 "printer-state",
1081 "printer-state-message"
1082 };
1083
1084 *q = NULL;
1085
1086 /* HACK ALERT!!! The problem with support the 'printer name'
1087 option is that we key the tdb off the sharename. So we will
1088 overload the lpq_command string to pass in the printername
1089 (which is basically what we do for non-cups printers ... using
1090 the lpq_command to get the queue listing). */
1091
1092 if (!push_utf8_talloc(frame, &printername, lpq_command, &size)) {
1093 goto out;
1094 }
1095 DEBUG(5,("cups_queue_get(%s, %p, %p)\n", lpq_command, q, status));
1096
1097 /*
1098 * Make sure we don't ask for passwords...
1099 */
1100
1101 cupsSetPasswordCB(cups_passwd_cb);
1102
1103 /*
1104 * Try to connect to the server...
1105 */
1106
1107 if ((http = cups_connect(frame)) == NULL) {
1108 goto out;
1109 }
1110
1111 /*
1112 * Generate the printer URI...
1113 */
1114
1115 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s", printername);
1116
1117 /*
1118 * Build an IPP_GET_JOBS request, which requires the following
1119 * attributes:
1120 *
1121 * attributes-charset
1122 * attributes-natural-language
1123 * requested-attributes
1124 * printer-uri
1125 */
1126
1127 request = ippNew();
1128
1129 request->request.op.operation_id = IPP_GET_JOBS;
1130 request->request.op.request_id = 1;
1131
1132 language = cupsLangDefault();
1133
1134 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1135 "attributes-charset", NULL, "utf-8");
1136
1137 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1138 "attributes-natural-language", NULL, language->language);
1139
1140 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1141 "requested-attributes",
1142 (sizeof(jattrs) / sizeof(jattrs[0])),
1143 NULL, jattrs);
1144
1145 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1146 "printer-uri", NULL, uri);
1147
1148 /*
1149 * Do the request and get back a response...
1150 */
1151
1152 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
1153 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1154 ippErrorString(cupsLastError())));
1155 goto out;
1156 }
1157
1158 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1159 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
1160 ippErrorString(response->request.status.status_code)));
1161 goto out;
1162 }
1163
1164 /*
1165 * Process the jobs...
1166 */
1167
1168 qcount = 0;
1169 qalloc = 0;
1170 queue = NULL;
1171
1172 for (attr = response->attrs; attr != NULL; attr = attr->next) {
1173 /*
1174 * Skip leading attributes until we hit a job...
1175 */
1176
1177 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
1178 attr = attr->next;
1179
1180 if (attr == NULL)
1181 break;
1182
1183 /*
1184 * Allocate memory as needed...
1185 */
1186 if (qcount >= qalloc) {
1187 qalloc += 16;
1188
1189 queue = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc);
1190
1191 if (queue == NULL) {
1192 DEBUG(0,("cups_queue_get: Not enough memory!"));
1193 qcount = 0;
1194 goto out;
1195 }
1196 }
1197
1198 temp = queue + qcount;
1199 memset(temp, 0, sizeof(print_queue_struct));
1200
1201 /*
1202 * Pull the needed attributes from this job...
1203 */
1204
1205 job_id = 0;
1206 job_priority = 50;
1207 job_status = IPP_JOB_PENDING;
1208 job_time = 0;
1209 job_k_octets = 0;
1210 user_name = NULL;
1211 job_name = NULL;
1212
1213 while (attr != NULL && attr->group_tag == IPP_TAG_JOB) {
1214 if (attr->name == NULL) {
1215 attr = attr->next;
1216 break;
1217 }
1218
1219 if (strcmp(attr->name, "job-id") == 0 &&
1220 attr->value_tag == IPP_TAG_INTEGER)
1221 job_id = attr->values[0].integer;
1222
1223 if (strcmp(attr->name, "job-k-octets") == 0 &&
1224 attr->value_tag == IPP_TAG_INTEGER)
1225 job_k_octets = attr->values[0].integer;
1226
1227 if (strcmp(attr->name, "job-priority") == 0 &&
1228 attr->value_tag == IPP_TAG_INTEGER)
1229 job_priority = attr->values[0].integer;
1230
1231 if (strcmp(attr->name, "job-state") == 0 &&
1232 attr->value_tag == IPP_TAG_ENUM)
1233 job_status = (ipp_jstate_t)(attr->values[0].integer);
1234
1235 if (strcmp(attr->name, "time-at-creation") == 0 &&
1236 attr->value_tag == IPP_TAG_INTEGER)
1237 job_time = attr->values[0].integer;
1238
1239 if (strcmp(attr->name, "job-name") == 0 &&
1240 attr->value_tag == IPP_TAG_NAME) {
1241 if (!pull_utf8_talloc(frame,
1242 &job_name,
1243 attr->values[0].string.text,
1244 &size)) {
1245 goto out;
1246 }
1247 }
1248
1249 if (strcmp(attr->name, "job-originating-user-name") == 0 &&
1250 attr->value_tag == IPP_TAG_NAME) {
1251 if (!pull_utf8_talloc(frame,
1252 &user_name,
1253 attr->values[0].string.text,
1254 &size)) {
1255 goto out;
1256 }
1257 }
1258
1259 attr = attr->next;
1260 }
1261
1262 /*
1263 * See if we have everything needed...
1264 */
1265
1266 if (user_name == NULL || job_name == NULL || job_id == 0) {
1267 if (attr == NULL)
1268 break;
1269 else
1270 continue;
1271 }
1272
1273 temp->job = job_id;
1274 temp->size = job_k_octets * 1024;
1275 temp->status = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
1276 job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
1277 job_status == IPP_JOB_HELD ? LPQ_PAUSED :
1278 LPQ_PRINTING;
1279 temp->priority = job_priority;
1280 temp->time = job_time;
1281 strlcpy(temp->fs_user, user_name, sizeof(temp->fs_user));
1282 strlcpy(temp->fs_file, job_name, sizeof(temp->fs_file));
1283
1284 qcount ++;
1285
1286 if (attr == NULL)
1287 break;
1288 }
1289
1290 ippDelete(response);
1291 response = NULL;
1292
1293 /*
1294 * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the
1295 * following attributes:
1296 *
1297 * attributes-charset
1298 * attributes-natural-language
1299 * requested-attributes
1300 * printer-uri
1301 */
1302
1303 request = ippNew();
1304
1305 request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
1306 request->request.op.request_id = 1;
1307
1308 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1309 "attributes-charset", NULL, "utf-8");
1310
1311 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1312 "attributes-natural-language", NULL, language->language);
1313
1314 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1315 "requested-attributes",
1316 (sizeof(pattrs) / sizeof(pattrs[0])),
1317 NULL, pattrs);
1318
1319 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1320 "printer-uri", NULL, uri);
1321
1322 /*
1323 * Do the request and get back a response...
1324 */
1325
1326 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
1327 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
1328 ippErrorString(cupsLastError())));
1329 *q = queue;
1330 goto out;
1331 }
1332
1333 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1334 DEBUG(0,("Unable to get printer status for %s - %s\n", printername,
1335 ippErrorString(response->request.status.status_code)));
1336 *q = queue;
1337 goto out;
1338 }
1339
1340 /*
1341 * Get the current printer status and convert it to the SAMBA values.
1342 */
1343
1344 if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) {
1345 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
1346 status->status = LPSTAT_STOPPED;
1347 else
1348 status->status = LPSTAT_OK;
1349 }
1350
1351 if ((attr = ippFindAttribute(response, "printer-state-message",
1352 IPP_TAG_TEXT)) != NULL) {
1353 char *msg = NULL;
1354 if (!pull_utf8_talloc(frame, &msg,
1355 attr->values[0].string.text,
1356 &size)) {
1357 goto out;
1358 }
1359 fstrcpy(status->message, msg);
1360 }
1361
1362 /*
1363 * Return the job queue...
1364 */
1365
1366 *q = queue;
1367
1368 out:
1369 if (response)
1370 ippDelete(response);
1371
1372 if (language)
1373 cupsLangFree(language);
1374
1375 if (http)
1376 httpClose(http);
1377
1378 TALLOC_FREE(frame);
1379 return qcount;
1380 }
1381
1382
1383 /*
1384 * 'cups_queue_pause()' - Pause a print queue.
1385 */
1386
1387 static int cups_queue_pause(int snum)
1388 {
1389 TALLOC_CTX *frame = talloc_stackframe();
1390 int ret = 1; /* Return value */
1391 http_t *http = NULL; /* HTTP connection to server */
1392 ipp_t *request = NULL, /* IPP Request */
1393 *response = NULL; /* IPP Response */
1394 cups_lang_t *language = NULL; /* Default language */
1395 char *printername = NULL;
1396 char *username = NULL;
1397 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
1398 size_t size;
1399
1400 DEBUG(5,("cups_queue_pause(%d)\n", snum));
1401
1402 /*
1403 * Make sure we don't ask for passwords...
1404 */
1405
1406 cupsSetPasswordCB(cups_passwd_cb);
1407
1408 /*
1409 * Try to connect to the server...
1410 */
1411
1412 if ((http = cups_connect(frame)) == NULL) {
1413 goto out;
1414 }
1415
1416 /*
1417 * Build an IPP_PAUSE_PRINTER request, which requires the following
1418 * attributes:
1419 *
1420 * attributes-charset
1421 * attributes-natural-language
1422 * printer-uri
1423 * requesting-user-name
1424 */
1425
1426 request = ippNew();
1427
1428 request->request.op.operation_id = IPP_PAUSE_PRINTER;
1429 request->request.op.request_id = 1;
1430
1431 language = cupsLangDefault();
1432
1433 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1434 "attributes-charset", NULL, "utf-8");
1435
1436 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1437 "attributes-natural-language", NULL, language->language);
1438
1439 if (!push_utf8_talloc(frame, &printername, PRINTERNAME(snum), &size)) {
1440 goto out;
1441 }
1442 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1443 printername);
1444
1445 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1446
1447 if (!push_utf8_talloc(frame, &username, current_user_info.unix_name, &size)) {
1448 goto out;
1449 }
1450 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1451 NULL, username);
1452
1453 /*
1454 * Do the request and get back a response...
1455 */
1456
1457 if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) {
1458 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1459 DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1460 ippErrorString(cupsLastError())));
1461 } else {
1462 ret = 0;
1463 }
1464 } else {
1465 DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1466 ippErrorString(cupsLastError())));
1467 }
1468
1469 out:
1470 if (response)
1471 ippDelete(response);
1472
1473 if (language)
1474 cupsLangFree(language);
1475
1476 if (http)
1477 httpClose(http);
1478
1479 TALLOC_FREE(frame);
1480 return ret;
1481 }
1482
1483
1484 /*
1485 * 'cups_queue_resume()' - Restart a print queue.
1486 */
1487
1488 static int cups_queue_resume(int snum)
1489 {
1490 TALLOC_CTX *frame = talloc_stackframe();
1491 int ret = 1; /* Return value */
1492 http_t *http = NULL; /* HTTP connection to server */
1493 ipp_t *request = NULL, /* IPP Request */
1494 *response = NULL; /* IPP Response */
1495 cups_lang_t *language = NULL; /* Default language */
1496 char *printername = NULL;
1497 char *username = NULL;
1498 char uri[HTTP_MAX_URI]; /* printer-uri attribute */
1499 size_t size;
1500
1501 DEBUG(5,("cups_queue_resume(%d)\n", snum));
1502
1503 /*
1504 * Make sure we don't ask for passwords...
1505 */
1506
1507 cupsSetPasswordCB(cups_passwd_cb);
1508
1509 /*
1510 * Try to connect to the server...
1511 */
1512
1513 if ((http = cups_connect(frame)) == NULL) {
1514 goto out;
1515 }
1516
1517 /*
1518 * Build an IPP_RESUME_PRINTER request, which requires the following
1519 * attributes:
1520 *
1521 * attributes-charset
1522 * attributes-natural-language
1523 * printer-uri
1524 * requesting-user-name
1525 */
1526
1527 request = ippNew();
1528
1529 request->request.op.operation_id = IPP_RESUME_PRINTER;
1530 request->request.op.request_id = 1;
1531
1532 language = cupsLangDefault();
1533
1534 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1535 "attributes-charset", NULL, "utf-8");
1536
1537 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1538 "attributes-natural-language", NULL, language->language);
1539
1540 if (!push_utf8_talloc(frame, &printername, PRINTERNAME(snum), &size)) {
1541 goto out;
1542 }
1543 slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1544 printername);
1545
1546 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1547
1548 if (!push_utf8_talloc(frame, &username, current_user_info.unix_name, &size)) {
1549 goto out;
1550 }
1551 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1552 NULL, username);
1553
1554 /*
1555 * Do the request and get back a response...
1556 */
1557
1558 if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) {
1559 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1560 DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1561 ippErrorString(cupsLastError())));
1562 } else {
1563 ret = 0;
1564 }
1565 } else {
1566 DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1567 ippErrorString(cupsLastError())));
1568 }
1569
1570 out:
1571 if (response)
1572 ippDelete(response);
1573
1574 if (language)
1575 cupsLangFree(language);
1576
1577 if (http)
1578 httpClose(http);
1579
1580 TALLOC_FREE(frame);
1581 return ret;
1582 }
1583
1584 /*******************************************************************
1585 * CUPS printing interface definitions...
1586 ******************************************************************/
1587
1588 struct printif cups_printif =
1589 {
1590 PRINT_CUPS,
1591 cups_queue_get,
1592 cups_queue_pause,
1593 cups_queue_resume,
1594 cups_job_delete,
1595 cups_job_pause,
1596 cups_job_resume,
1597 cups_job_submit,
1598 };
1599
1600 bool cups_pull_comment_location(NT_PRINTER_INFO_LEVEL_2 *printer)
1601 {
1602 TALLOC_CTX *frame = talloc_stackframe();
1603 http_t *http = NULL; /* HTTP connection to server */
1604 ipp_t *request = NULL, /* IPP Request */
1605 *response = NULL; /* IPP Response */
1606 ipp_attribute_t *attr; /* Current attribute */
1607 cups_lang_t *language = NULL; /* Default language */
1608 char uri[HTTP_MAX_URI];
1609 char *server = NULL;
1610 char *sharename = NULL;
1611 char *name = NULL;
1612 static const char *requested[] =/* Requested attributes */
1613 {
1614 "printer-name",
1615 "printer-info",
1616 "printer-location"
1617 };
1618 bool ret = False;
1619 size_t size;
1620
1621 DEBUG(5, ("pulling %s location\n", printer->sharename));
1622
1623 /*
1624 * Make sure we don't ask for passwords...
1625 */
1626
1627 cupsSetPasswordCB(cups_passwd_cb);
1628
1629 /*
1630 * Try to connect to the server...
1631 */
1632
1633 if ((http = cups_connect(frame)) == NULL) {
1634 goto out;
1635 }
1636
1637 request = ippNew();
1638
1639 request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
1640 request->request.op.request_id = 1;
1641
1642 language = cupsLangDefault();
1643
1644 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1645 "attributes-charset", NULL, "utf-8");
1646
1647 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1648 "attributes-natural-language", NULL, language->language);
1649
1650 if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
1651 if (!push_utf8_talloc(frame, &server, lp_cups_server(), &size)) {
1652 goto out;
1653 }
1654 } else {
1655 server = talloc_strdup(frame,cupsServer());
1656 }
1657 if (server) {
1658 goto out;
1659 }
1660 if (!push_utf8_talloc(frame, &sharename, printer->sharename, &size)) {
1661 goto out;
1662 }
1663 slprintf(uri, sizeof(uri) - 1, "ipp://%s/printers/%s",
1664 server, sharename);
1665
1666 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1667 "printer-uri", NULL, uri);
1668
1669 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1670 "requested-attributes",
1671 (sizeof(requested) / sizeof(requested[0])),
1672 NULL, requested);
1673
1674 /*
1675 * Do the request and get back a response...
1676 */
1677
1678 if ((response = cupsDoRequest(http, request, "/")) == NULL) {
1679 DEBUG(0,("Unable to get printer attributes - %s\n",
1680 ippErrorString(cupsLastError())));
1681 goto out;
1682 }
1683
1684 for (attr = response->attrs; attr != NULL;) {
1685 /*
1686 * Skip leading attributes until we hit a printer...
1687 */
1688
1689 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
1690 attr = attr->next;
1691
1692 if (attr == NULL)
1693 break;
1694
1695 /*
1696 * Pull the needed attributes from this printer...
1697 */
1698
1699 while ( attr && (attr->group_tag == IPP_TAG_PRINTER) ) {
1700 if (strcmp(attr->name, "printer-name") == 0 &&
1701 attr->value_tag == IPP_TAG_NAME) {
1702 if (!pull_utf8_talloc(frame,
1703 &name,
1704 attr->values[0].string.text,
1705 &size)) {
1706 goto out;
1707 }
1708 }
1709
1710 /* Grab the comment if we don't have one */
1711 if ( (strcmp(attr->name, "printer-info") == 0)
1712 && (attr->value_tag == IPP_TAG_TEXT)
1713 && !strlen(printer->comment) )
1714 {
1715 char *comment = NULL;
1716 if (!pull_utf8_talloc(frame,
1717 &comment,
1718 attr->values[0].string.text,
1719 &size)) {
1720 goto out;
1721 }
1722 DEBUG(5,("cups_pull_comment_location: Using cups comment: %s\n",
1723 comment));
1724 strlcpy(printer->comment,
1725 comment,
1726 sizeof(printer->comment));
1727 }
1728
1729 /* Grab the location if we don't have one */
1730 if ( (strcmp(attr->name, "printer-location") == 0)
1731 && (attr->value_tag == IPP_TAG_TEXT)
1732 && !strlen(printer->location) )
1733 {
1734 char *location = NULL;
1735 if (!pull_utf8_talloc(frame,
1736 &location,
1737 attr->values[0].string.text,
1738 &size)) {
1739 goto out;
1740 }
1741 DEBUG(5,("cups_pull_comment_location: Using cups location: %s\n",
1742 location));
1743 strlcpy(printer->location,
1744 location,
1745 sizeof(printer->location));
1746 }
1747
1748 attr = attr->next;
1749 }
1750
1751 /*
1752 * We have everything needed...
1753 */
1754
1755 if (name != NULL)
1756 break;
1757 }
1758
1759 ret = True;
1760
1761 out:
1762 if (response)
1763 ippDelete(response);
1764
1765 if (language)
1766 cupsLangFree(language);
1767
1768 if (http)
1769 httpClose(http);
1770
1771 TALLOC_FREE(frame);
1772 return ret;
1773 }
1774
1775 #else
1776 /* this keeps fussy compilers happy */
1777 void print_cups_dummy(void);
1778 void print_cups_dummy(void) {}
1779 #endif /* HAVE_CUPS */
Samba GIT mirror