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