source3/printing/print_cups.c

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