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