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