source/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  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include "includes.h"
  22 #include "printing.h"
  23
  24 #ifdef HAVE_CUPS
  25 #include <cups/cups.h>
  26 #include <cups/language.h>
  27
  28
  29 /*
  30  * 'cups_passwd_cb()' - The CUPS password callback...
  31  */
  32
  33 static const char *                             /* O - Password or NULL */
  34 cups_passwd_cb(const char *prompt)      /* I - Prompt */
  35 {
  36         /*
  37          * Always return NULL to indicate that no password is available...
  38          */
  39
  40         return (NULL);
  41 }
  42
  43 static const char *cups_server(void)
  44 {
  45         if ((lp_cups_server() != NULL) && (strlen(lp_cups_server()) > 0)) {
  46                 DEBUG(10, ("cups server explicitly set to %s\n",
  47                            lp_cups_server()));
  48                 return lp_cups_server();
  49         }
  50
  51         DEBUG(10, ("cups server left to default %s\n", cupsServer()));
  52         return cupsServer();
  53 }
  54
  55 BOOL cups_cache_reload(void)
  56 {
  57         http_t          *http = NULL;           /* HTTP connection to server */
  58         ipp_t           *request = NULL,        /* IPP Request */
  59                         *response = NULL;       /* IPP Response */
  60         ipp_attribute_t *attr;          /* Current attribute */
  61         cups_lang_t     *language = NULL;       /* Default language */
  62         char            *name,          /* printer-name attribute */
  63                         *info;          /* printer-info attribute */
  64         static const char *requested[] =/* Requested attributes */
  65                         {
  66                           "printer-name",
  67                           "printer-info"
  68                         };
  69         BOOL ret = False;
  70
  71         DEBUG(5, ("reloading cups printcap cache\n"));
  72
  73        /*
  74         * Make sure we don't ask for passwords...
  75         */
  76
  77         cupsSetPasswordCB(cups_passwd_cb);
  78
  79        /*
  80         * Try to connect to the server...
  81         */
  82
  83         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
  84                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
  85                          cups_server(), strerror(errno)));
  86                 goto out;
  87         }
  88
  89        /*
  90         * Build a CUPS_GET_PRINTERS request, which requires the following
  91         * attributes:
  92         *
  93         *    attributes-charset
  94         *    attributes-natural-language
  95         *    requested-attributes
  96         */
  97
  98         request = ippNew();
  99
 100         request->request.op.operation_id = CUPS_GET_PRINTERS;
 101         request->request.op.request_id   = 1;
 102
 103         language = cupsLangDefault();
 104
 105         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 106                      "attributes-charset", NULL, cupsLangEncoding(language));
 107
 108         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 109                      "attributes-natural-language", NULL, language->language);
 110
 111         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 112                       "requested-attributes",
 113                       (sizeof(requested) / sizeof(requested[0])),
 114                       NULL, requested);
 115
 116        /*
 117         * Do the request and get back a response...
 118         */
 119
 120         if ((response = cupsDoRequest(http, request, "/")) == NULL) {
 121                 DEBUG(0,("Unable to get printer list - %s\n",
 122                          ippErrorString(cupsLastError())));
 123                 goto out;
 124         }
 125
 126         for (attr = response->attrs; attr != NULL;) {
 127                /*
 128                 * Skip leading attributes until we hit a printer...
 129                 */
 130
 131                 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
 132                         attr = attr->next;
 133
 134                 if (attr == NULL)
 135                         break;
 136
 137                /*
 138                 * Pull the needed attributes from this printer...
 139                 */
 140
 141                 name       = NULL;
 142                 info       = NULL;
 143
 144                 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
 145                         if (strcmp(attr->name, "printer-name") == 0 &&
 146                             attr->value_tag == IPP_TAG_NAME)
 147                                 name = attr->values[0].string.text;
 148
 149                         if (strcmp(attr->name, "printer-info") == 0 &&
 150                             attr->value_tag == IPP_TAG_TEXT)
 151                                 info = attr->values[0].string.text;
 152
 153                         attr = attr->next;
 154                 }
 155
 156                /*
 157                 * See if we have everything needed...
 158                 */
 159
 160                 if (name == NULL)
 161                         break;
 162
 163                 if (!pcap_cache_add(name, info)) {
 164                         goto out;
 165                 }
 166         }
 167
 168         ippDelete(response);
 169         response = NULL;
 170
 171        /*
 172         * Build a CUPS_GET_CLASSES request, which requires the following
 173         * attributes:
 174         *
 175         *    attributes-charset
 176         *    attributes-natural-language
 177         *    requested-attributes
 178         */
 179
 180         request->request.op.operation_id = CUPS_GET_CLASSES;
 181         request->request.op.request_id   = 1;
 182
 183         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 184                      "attributes-charset", NULL, cupsLangEncoding(language));
 185
 186         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 187                      "attributes-natural-language", NULL, language->language);
 188
 189         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 190                       "requested-attributes",
 191                       (sizeof(requested) / sizeof(requested[0])),
 192                       NULL, requested);
 193
 194        /*
 195         * Do the request and get back a response...
 196         */
 197
 198         if ((response = cupsDoRequest(http, request, "/")) == NULL) {
 199                 DEBUG(0,("Unable to get printer list - %s\n",
 200                          ippErrorString(cupsLastError())));
 201                 goto out;
 202         }
 203
 204         for (attr = response->attrs; attr != NULL;) {
 205                /*
 206                 * Skip leading attributes until we hit a printer...
 207                 */
 208
 209                 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
 210                         attr = attr->next;
 211
 212                 if (attr == NULL)
 213                         break;
 214
 215                /*
 216                 * Pull the needed attributes from this printer...
 217                 */
 218
 219                 name       = NULL;
 220                 info       = NULL;
 221
 222                 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
 223                         if (strcmp(attr->name, "printer-name") == 0 &&
 224                             attr->value_tag == IPP_TAG_NAME)
 225                                 name = attr->values[0].string.text;
 226
 227                         if (strcmp(attr->name, "printer-info") == 0 &&
 228                             attr->value_tag == IPP_TAG_TEXT)
 229                                 info = attr->values[0].string.text;
 230
 231                         attr = attr->next;
 232                 }
 233
 234                /*
 235                 * See if we have everything needed...
 236                 */
 237
 238                 if (name == NULL)
 239                         break;
 240
 241                 if (!pcap_cache_add(name, info)) {
 242                         goto out;
 243                 }
 244         }
 245
 246         ret = True;
 247
 248  out:
 249
 250         if (request)
 251                 ippDelete(request);
 252
 253         if (response)
 254                 ippDelete(response);
 255
 256         if (language)
 257                 cupsLangFree(language);
 258
 259         if (http)
 260                 httpClose(http);
 261
 262         return ret;
 263 }
 264
 265
 266 /*
 267  * 'cups_job_delete()' - Delete a job.
 268  */
 269
 270 static int cups_job_delete(int snum, struct printjob *pjob)
 271 {
 272         int             ret = 1;                /* Return value */
 273         http_t          *http = NULL;           /* HTTP connection to server */
 274         ipp_t           *request = NULL,        /* IPP Request */
 275                         *response = NULL;       /* IPP Response */
 276         cups_lang_t     *language = NULL;       /* Default language */
 277         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
 278
 279
 280         DEBUG(5,("cups_job_delete(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
 281
 282        /*
 283         * Make sure we don't ask for passwords...
 284         */
 285
 286         cupsSetPasswordCB(cups_passwd_cb);
 287
 288        /*
 289         * Try to connect to the server...
 290         */
 291
 292         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
 293                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
 294                          cups_server(), strerror(errno)));
 295                 goto out;
 296         }
 297
 298        /*
 299         * Build an IPP_CANCEL_JOB request, which requires the following
 300         * attributes:
 301         *
 302         *    attributes-charset
 303         *    attributes-natural-language
 304         *    job-uri
 305         *    requesting-user-name
 306         */
 307
 308         request = ippNew();
 309
 310         request->request.op.operation_id = IPP_CANCEL_JOB;
 311         request->request.op.request_id   = 1;
 312
 313         language = cupsLangDefault();
 314
 315         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 316                      "attributes-charset", NULL, cupsLangEncoding(language));
 317
 318         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 319                      "attributes-natural-language", NULL, language->language);
 320
 321         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
 322
 323         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
 324
 325         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 326                      NULL, pjob->user);
 327
 328        /*
 329         * Do the request and get back a response...
 330         */
 331
 332         if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
 333                 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
 334                         DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
 335                                 ippErrorString(cupsLastError())));
 336                 } else {
 337                         ret = 0;
 338                 }
 339         } else {
 340                 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
 341                         ippErrorString(cupsLastError())));
 342         }
 343
 344  out:
 345
 346         if (request)
 347                 ippDelete(request);
 348
 349         if (response)
 350                 ippDelete(response);
 351
 352         if (language)
 353                 cupsLangFree(language);
 354
 355         if (http)
 356                 httpClose(http);
 357
 358         return ret;
 359 }
 360
 361
 362 /*
 363  * 'cups_job_pause()' - Pause a job.
 364  */
 365
 366 static int cups_job_pause(int snum, struct printjob *pjob)
 367 {
 368         int             ret = 1;                /* Return value */
 369         http_t          *http = NULL;           /* HTTP connection to server */
 370         ipp_t           *request = NULL,        /* IPP Request */
 371                         *response = NULL;       /* IPP Response */
 372         cups_lang_t     *language = NULL;       /* Default language */
 373         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
 374
 375
 376         DEBUG(5,("cups_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
 377
 378        /*
 379         * Make sure we don't ask for passwords...
 380         */
 381
 382         cupsSetPasswordCB(cups_passwd_cb);
 383
 384        /*
 385         * Try to connect to the server...
 386         */
 387
 388         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
 389                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
 390                          cups_server(), strerror(errno)));
 391                 goto out;
 392         }
 393
 394        /*
 395         * Build an IPP_HOLD_JOB request, which requires the following
 396         * attributes:
 397         *
 398         *    attributes-charset
 399         *    attributes-natural-language
 400         *    job-uri
 401         *    requesting-user-name
 402         */
 403
 404         request = ippNew();
 405
 406         request->request.op.operation_id = IPP_HOLD_JOB;
 407         request->request.op.request_id   = 1;
 408
 409         language = cupsLangDefault();
 410
 411         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 412                      "attributes-charset", NULL, cupsLangEncoding(language));
 413
 414         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 415                      "attributes-natural-language", NULL, language->language);
 416
 417         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
 418
 419         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
 420
 421         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 422                      NULL, pjob->user);
 423
 424        /*
 425         * Do the request and get back a response...
 426         */
 427
 428         if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
 429                 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
 430                         DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
 431                                 ippErrorString(cupsLastError())));
 432                 } else {
 433                         ret = 0;
 434                 }
 435         } else {
 436                 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
 437                         ippErrorString(cupsLastError())));
 438         }
 439
 440  out:
 441
 442         if (request)
 443                 ippDelete(request);
 444
 445         if (response)
 446                 ippDelete(response);
 447
 448         if (language)
 449                 cupsLangFree(language);
 450
 451         if (http)
 452                 httpClose(http);
 453
 454         return ret;
 455 }
 456
 457
 458 /*
 459  * 'cups_job_resume()' - Resume a paused job.
 460  */
 461
 462 static int cups_job_resume(int snum, struct printjob *pjob)
 463 {
 464         int             ret = 1;                /* Return value */
 465         http_t          *http = NULL;           /* HTTP connection to server */
 466         ipp_t           *request = NULL,        /* IPP Request */
 467                         *response = NULL;       /* IPP Response */
 468         cups_lang_t     *language = NULL;       /* Default language */
 469         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
 470
 471
 472         DEBUG(5,("cups_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
 473
 474        /*
 475         * Make sure we don't ask for passwords...
 476         */
 477
 478         cupsSetPasswordCB(cups_passwd_cb);
 479
 480        /*
 481         * Try to connect to the server...
 482         */
 483
 484         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
 485                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
 486                          cups_server(), strerror(errno)));
 487                 goto out;
 488         }
 489
 490        /*
 491         * Build an IPP_RELEASE_JOB request, which requires the following
 492         * attributes:
 493         *
 494         *    attributes-charset
 495         *    attributes-natural-language
 496         *    job-uri
 497         *    requesting-user-name
 498         */
 499
 500         request = ippNew();
 501
 502         request->request.op.operation_id = IPP_RELEASE_JOB;
 503         request->request.op.request_id   = 1;
 504
 505         language = cupsLangDefault();
 506
 507         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 508                      "attributes-charset", NULL, cupsLangEncoding(language));
 509
 510         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 511                      "attributes-natural-language", NULL, language->language);
 512
 513         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
 514
 515         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
 516
 517         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 518                      NULL, pjob->user);
 519
 520        /*
 521         * Do the request and get back a response...
 522         */
 523
 524         if ((response = cupsDoRequest(http, request, "/jobs")) != NULL) {
 525                 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
 526                         DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
 527                                 ippErrorString(cupsLastError())));
 528                 } else {
 529                         ret = 0;
 530                 }
 531         } else {
 532                 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
 533                         ippErrorString(cupsLastError())));
 534         }
 535
 536  out:
 537
 538         if (request)
 539                 ippDelete(request);
 540
 541         if (response)
 542                 ippDelete(response);
 543
 544         if (language)
 545                 cupsLangFree(language);
 546
 547         if (http)
 548                 httpClose(http);
 549
 550         return ret;
 551 }
 552
 553
 554 /*
 555  * 'cups_job_submit()' - Submit a job for printing.
 556  */
 557
 558 static int cups_job_submit(int snum, struct printjob *pjob)
 559 {
 560         int             ret = 1;                /* Return value */
 561         http_t          *http = NULL;           /* HTTP connection to server */
 562         ipp_t           *request = NULL,        /* IPP Request */
 563                         *response = NULL;       /* IPP Response */
 564         cups_lang_t     *language = NULL;       /* Default language */
 565         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
 566         char            *clientname = NULL;     /* hostname of client for job-originating-host attribute */
 567         pstring         new_jobname;
 568         int             num_options = 0;
 569         cups_option_t   *options = NULL;
 570
 571         DEBUG(5,("cups_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
 572
 573        /*
 574         * Make sure we don't ask for passwords...
 575         */
 576
 577         cupsSetPasswordCB(cups_passwd_cb);
 578
 579        /*
 580         * Try to connect to the server...
 581         */
 582
 583         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
 584                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
 585                          cups_server(), strerror(errno)));
 586                 goto out;
 587         }
 588
 589        /*
 590         * Build an IPP_PRINT_JOB request, which requires the following
 591         * attributes:
 592         *
 593         *    attributes-charset
 594         *    attributes-natural-language
 595         *    printer-uri
 596         *    requesting-user-name
 597         *    [document-data]
 598         */
 599
 600         request = ippNew();
 601
 602         request->request.op.operation_id = IPP_PRINT_JOB;
 603         request->request.op.request_id   = 1;
 604
 605         language = cupsLangDefault();
 606
 607         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 608                      "attributes-charset", NULL, cupsLangEncoding(language));
 609
 610         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 611                      "attributes-natural-language", NULL, language->language);
 612
 613         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
 614                  PRINTERNAME(snum));
 615
 616         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 617                      "printer-uri", NULL, uri);
 618
 619         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 620                      NULL, pjob->user);
 621
 622         clientname = client_name();
 623         if (strcmp(clientname, "UNKNOWN") == 0) {
 624                 clientname = client_addr();
 625         }
 626
 627         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 628                      "job-originating-host-name", NULL,
 629                       clientname);
 630
 631         pstr_sprintf(new_jobname,"%s%.8u %s", PRINT_SPOOL_PREFIX,
 632                 (unsigned int)pjob->smbjob, pjob->jobname);
 633
 634         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
 635                      new_jobname);
 636
 637         /*
 638          * add any options defined in smb.conf
 639          */
 640
 641         num_options = 0;
 642         options     = NULL;
 643         num_options = cupsParseOptions(lp_cups_options(snum), num_options, &options);
 644
 645         if ( num_options )
 646                 cupsEncodeOptions(request, num_options, options);
 647
 648        /*
 649         * Do the request and get back a response...
 650         */
 651
 652         slprintf(uri, sizeof(uri) - 1, "/printers/%s", PRINTERNAME(snum));
 653
 654         if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
 655                 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
 656                         DEBUG(0,("Unable to print file to %s - %s\n", PRINTERNAME(snum),
 657                                  ippErrorString(cupsLastError())));
 658                 } else {
 659                         ret = 0;
 660                 }
 661         } else {
 662                 DEBUG(0,("Unable to print file to `%s' - %s\n", PRINTERNAME(snum),
 663                          ippErrorString(cupsLastError())));
 664         }
 665
 666         if ( ret == 0 )
 667                 unlink(pjob->filename);
 668         /* else print_job_end will do it for us */
 669
 670  out:
 671
 672         if (request)
 673                 ippDelete(request);
 674
 675         if (response)
 676                 ippDelete(response);
 677
 678         if (language)
 679                 cupsLangFree(language);
 680
 681         if (http)
 682                 httpClose(http);
 683
 684         return ret;
 685         return (ret);
 686 }
 687
 688 /*
 689  * 'cups_queue_get()' - Get all the jobs in the print queue.
 690  */
 691
 692 static int cups_queue_get(const char *printer_name,
 693                enum printing_types printing_type,
 694                char *lpq_command,
 695                print_queue_struct **q,
 696                print_status_struct *status)
 697 {
 698         http_t          *http = NULL;           /* HTTP connection to server */
 699         ipp_t           *request = NULL,        /* IPP Request */
 700                         *response = NULL;       /* IPP Response */
 701         ipp_attribute_t *attr = NULL;           /* Current attribute */
 702         cups_lang_t     *language = NULL;       /* Default language */
 703         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
 704         int             qcount = 0,             /* Number of active queue entries */
 705                         qalloc = 0;             /* Number of queue entries allocated */
 706         print_queue_struct *queue = NULL,       /* Queue entries */
 707                         *temp;          /* Temporary pointer for queue */
 708         const char      *user_name,     /* job-originating-user-name attribute */
 709                         *job_name;      /* job-name attribute */
 710         int             job_id;         /* job-id attribute */
 711         int             job_k_octets;   /* job-k-octets attribute */
 712         time_t          job_time;       /* time-at-creation attribute */
 713         ipp_jstate_t    job_status;     /* job-status attribute */
 714         int             job_priority;   /* job-priority attribute */
 715         static const char *jattrs[] =   /* Requested job attributes */
 716                         {
 717                           "job-id",
 718                           "job-k-octets",
 719                           "job-name",
 720                           "job-originating-user-name",
 721                           "job-priority",
 722                           "job-state",
 723                           "time-at-creation",
 724                         };
 725         static const char *pattrs[] =   /* Requested printer attributes */
 726                         {
 727                           "printer-state",
 728                           "printer-state-message"
 729                         };
 730
 731         *q = NULL;
 732
 733         DEBUG(5,("cups_queue_get(%s, %p, %p)\n", printer_name, q, status));
 734
 735        /*
 736         * Make sure we don't ask for passwords...
 737         */
 738
 739         cupsSetPasswordCB(cups_passwd_cb);
 740
 741        /*
 742         * Try to connect to the server...
 743         */
 744
 745         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
 746                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
 747                          cups_server(), strerror(errno)));
 748                 goto out;
 749         }
 750
 751        /*
 752         * Generate the printer URI...
 753         */
 754
 755         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s", printer_name);
 756
 757        /*
 758         * Build an IPP_GET_JOBS request, which requires the following
 759         * attributes:
 760         *
 761         *    attributes-charset
 762         *    attributes-natural-language
 763         *    requested-attributes
 764         *    printer-uri
 765         */
 766
 767         request = ippNew();
 768
 769         request->request.op.operation_id = IPP_GET_JOBS;
 770         request->request.op.request_id   = 1;
 771
 772         language = cupsLangDefault();
 773
 774         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 775                      "attributes-charset", NULL, cupsLangEncoding(language));
 776
 777         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 778                      "attributes-natural-language", NULL, language->language);
 779
 780         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 781                       "requested-attributes",
 782                       (sizeof(jattrs) / sizeof(jattrs[0])),
 783                       NULL, jattrs);
 784
 785         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 786                      "printer-uri", NULL, uri);
 787
 788        /*
 789         * Do the request and get back a response...
 790         */
 791
 792         if ((response = cupsDoRequest(http, request, "/")) == NULL) {
 793                 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
 794                          ippErrorString(cupsLastError())));
 795                 goto out;
 796         }
 797
 798         if (response->request.status.status_code >= IPP_OK_CONFLICT) {
 799                 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
 800                          ippErrorString(response->request.status.status_code)));
 801                 goto out;
 802         }
 803
 804        /*
 805         * Process the jobs...
 806         */
 807
 808         qcount = 0;
 809         qalloc = 0;
 810         queue  = NULL;
 811
 812         for (attr = response->attrs; attr != NULL; attr = attr->next) {
 813                /*
 814                 * Skip leading attributes until we hit a job...
 815                 */
 816
 817                 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
 818                         attr = attr->next;
 819
 820                 if (attr == NULL)
 821                         break;
 822
 823                /*
 824                 * Allocate memory as needed...
 825                 */
 826                 if (qcount >= qalloc) {
 827                         qalloc += 16;
 828
 829                         temp = SMB_REALLOC_ARRAY(queue, print_queue_struct, qalloc);
 830
 831                         if (temp == NULL) {
 832                                 DEBUG(0,("cups_queue_get: Not enough memory!"));
 833                                 qcount = 0;
 834                                 SAFE_FREE(queue);
 835                                 goto out;
 836                         }
 837
 838                         queue = temp;
 839                 }
 840
 841                 temp = queue + qcount;
 842                 memset(temp, 0, sizeof(print_queue_struct));
 843
 844                /*
 845                 * Pull the needed attributes from this job...
 846                 */
 847
 848                 job_id       = 0;
 849                 job_priority = 50;
 850                 job_status   = IPP_JOB_PENDING;
 851                 job_time     = 0;
 852                 job_k_octets = 0;
 853                 user_name    = NULL;
 854                 job_name     = NULL;
 855
 856                 while (attr != NULL && attr->group_tag == IPP_TAG_JOB) {
 857                         if (attr->name == NULL) {
 858                                 attr = attr->next;
 859                                 break;
 860                         }
 861
 862                         if (strcmp(attr->name, "job-id") == 0 &&
 863                             attr->value_tag == IPP_TAG_INTEGER)
 864                                 job_id = attr->values[0].integer;
 865
 866                         if (strcmp(attr->name, "job-k-octets") == 0 &&
 867                             attr->value_tag == IPP_TAG_INTEGER)
 868                                 job_k_octets = attr->values[0].integer;
 869
 870                         if (strcmp(attr->name, "job-priority") == 0 &&
 871                             attr->value_tag == IPP_TAG_INTEGER)
 872                                 job_priority = attr->values[0].integer;
 873
 874                         if (strcmp(attr->name, "job-state") == 0 &&
 875                             attr->value_tag == IPP_TAG_ENUM)
 876                                 job_status = (ipp_jstate_t)(attr->values[0].integer);
 877
 878                         if (strcmp(attr->name, "time-at-creation") == 0 &&
 879                             attr->value_tag == IPP_TAG_INTEGER)
 880                                 job_time = attr->values[0].integer;
 881
 882                         if (strcmp(attr->name, "job-name") == 0 &&
 883                             attr->value_tag == IPP_TAG_NAME)
 884                                 job_name = attr->values[0].string.text;
 885
 886                         if (strcmp(attr->name, "job-originating-user-name") == 0 &&
 887                             attr->value_tag == IPP_TAG_NAME)
 888                                 user_name = attr->values[0].string.text;
 889
 890                         attr = attr->next;
 891                 }
 892
 893                /*
 894                 * See if we have everything needed...
 895                 */
 896
 897                 if (user_name == NULL || job_name == NULL || job_id == 0) {
 898                         if (attr == NULL)
 899                                 break;
 900                         else
 901                                 continue;
 902                 }
 903
 904                 temp->job      = job_id;
 905                 temp->size     = job_k_octets * 1024;
 906                 temp->status   = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
 907                                  job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
 908                                  job_status == IPP_JOB_HELD ? LPQ_PAUSED :
 909                                  LPQ_PRINTING;
 910                 temp->priority = job_priority;
 911                 temp->time     = job_time;
 912                 strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1);
 913                 strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1);
 914
 915                 qcount ++;
 916
 917                 if (attr == NULL)
 918                         break;
 919         }
 920
 921         ippDelete(response);
 922         response = NULL;
 923
 924        /*
 925         * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the
 926         * following attributes:
 927         *
 928         *    attributes-charset
 929         *    attributes-natural-language
 930         *    requested-attributes
 931         *    printer-uri
 932         */
 933
 934         request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
 935         request->request.op.request_id   = 1;
 936
 937         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
 938                      "attributes-charset", NULL, cupsLangEncoding(language));
 939
 940         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
 941                      "attributes-natural-language", NULL, language->language);
 942
 943         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 944                       "requested-attributes",
 945                       (sizeof(pattrs) / sizeof(pattrs[0])),
 946                       NULL, pattrs);
 947
 948         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 949                      "printer-uri", NULL, uri);
 950
 951        /*
 952         * Do the request and get back a response...
 953         */
 954
 955         if ((response = cupsDoRequest(http, request, "/")) == NULL) {
 956                 DEBUG(0,("Unable to get printer status for %s - %s\n", printer_name,
 957                          ippErrorString(cupsLastError())));
 958                 *q = queue;
 959                 goto out;
 960         }
 961
 962         if (response->request.status.status_code >= IPP_OK_CONFLICT) {
 963                 DEBUG(0,("Unable to get printer status for %s - %s\n", printer_name,
 964                          ippErrorString(response->request.status.status_code)));
 965                 *q = queue;
 966                 goto out;
 967         }
 968
 969        /*
 970         * Get the current printer status and convert it to the SAMBA values.
 971         */
 972
 973         if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL) {
 974                 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
 975                         status->status = LPSTAT_STOPPED;
 976                 else
 977                         status->status = LPSTAT_OK;
 978         }
 979
 980         if ((attr = ippFindAttribute(response, "printer-state-message",
 981                                      IPP_TAG_TEXT)) != NULL)
 982                 fstrcpy(status->message, attr->values[0].string.text);
 983
 984        /*
 985         * Return the job queue...
 986         */
 987
 988         *q = queue;
 989
 990  out:
 991
 992         if (request)
 993                 ippDelete(request);
 994
 995         if (response)
 996                 ippDelete(response);
 997
 998         if (language)
 999                 cupsLangFree(language);
1000
1001         if (http)
1002                 httpClose(http);
1003
1004         return qcount;
1005 }
1006
1007
1008 /*
1009  * 'cups_queue_pause()' - Pause a print queue.
1010  */
1011
1012 static int cups_queue_pause(int snum)
1013 {
1014         extern userdom_struct current_user_info;
1015         int             ret = 1;                /* Return value */
1016         http_t          *http = NULL;           /* HTTP connection to server */
1017         ipp_t           *request = NULL,        /* IPP Request */
1018                         *response = NULL;       /* IPP Response */
1019         cups_lang_t     *language = NULL;       /* Default language */
1020         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
1021
1022
1023         DEBUG(5,("cups_queue_pause(%d)\n", snum));
1024
1025         /*
1026          * Make sure we don't ask for passwords...
1027          */
1028
1029         cupsSetPasswordCB(cups_passwd_cb);
1030
1031         /*
1032          * Try to connect to the server...
1033          */
1034
1035         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
1036                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
1037                          cups_server(), strerror(errno)));
1038                 goto out;
1039         }
1040
1041         /*
1042          * Build an IPP_PAUSE_PRINTER request, which requires the following
1043          * attributes:
1044          *
1045          *    attributes-charset
1046          *    attributes-natural-language
1047          *    printer-uri
1048          *    requesting-user-name
1049          */
1050
1051         request = ippNew();
1052
1053         request->request.op.operation_id = IPP_PAUSE_PRINTER;
1054         request->request.op.request_id   = 1;
1055
1056         language = cupsLangDefault();
1057
1058         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1059                      "attributes-charset", NULL, cupsLangEncoding(language));
1060
1061         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1062                      "attributes-natural-language", NULL, language->language);
1063
1064         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1065                  PRINTERNAME(snum));
1066
1067         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1068
1069         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1070                      NULL, current_user_info.unix_name);
1071
1072        /*
1073         * Do the request and get back a response...
1074         */
1075
1076         if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) {
1077                 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1078                         DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1079                                 ippErrorString(cupsLastError())));
1080                 } else {
1081                         ret = 0;
1082                 }
1083         } else {
1084                 DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1085                         ippErrorString(cupsLastError())));
1086         }
1087
1088  out:
1089
1090         if (request)
1091                 ippDelete(request);
1092
1093         if (response)
1094                 ippDelete(response);
1095
1096         if (language)
1097                 cupsLangFree(language);
1098
1099         if (http)
1100                 httpClose(http);
1101
1102         return ret;
1103 }
1104
1105
1106 /*
1107  * 'cups_queue_resume()' - Restart a print queue.
1108  */
1109
1110 static int cups_queue_resume(int snum)
1111 {
1112         extern userdom_struct current_user_info;
1113         int             ret = 1;                /* Return value */
1114         http_t          *http = NULL;           /* HTTP connection to server */
1115         ipp_t           *request = NULL,        /* IPP Request */
1116                         *response = NULL;       /* IPP Response */
1117         cups_lang_t     *language = NULL;       /* Default language */
1118         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
1119
1120
1121         DEBUG(5,("cups_queue_resume(%d)\n", snum));
1122
1123        /*
1124         * Make sure we don't ask for passwords...
1125         */
1126
1127         cupsSetPasswordCB(cups_passwd_cb);
1128
1129        /*
1130         * Try to connect to the server...
1131         */
1132
1133         if ((http = httpConnect(cups_server(), ippPort())) == NULL) {
1134                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n",
1135                          cups_server(), strerror(errno)));
1136                 goto out;
1137         }
1138
1139        /*
1140         * Build an IPP_RESUME_PRINTER request, which requires the following
1141         * attributes:
1142         *
1143         *    attributes-charset
1144         *    attributes-natural-language
1145         *    printer-uri
1146         *    requesting-user-name
1147         */
1148
1149         request = ippNew();
1150
1151         request->request.op.operation_id = IPP_RESUME_PRINTER;
1152         request->request.op.request_id   = 1;
1153
1154         language = cupsLangDefault();
1155
1156         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1157                      "attributes-charset", NULL, cupsLangEncoding(language));
1158
1159         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1160                      "attributes-natural-language", NULL, language->language);
1161
1162         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1163                  PRINTERNAME(snum));
1164
1165         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1166
1167         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1168                      NULL, current_user_info.unix_name);
1169
1170        /*
1171         * Do the request and get back a response...
1172         */
1173
1174         if ((response = cupsDoRequest(http, request, "/admin/")) != NULL) {
1175                 if (response->request.status.status_code >= IPP_OK_CONFLICT) {
1176                         DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1177                                 ippErrorString(cupsLastError())));
1178                 } else {
1179                         ret = 0;
1180                 }
1181         } else {
1182                 DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1183                         ippErrorString(cupsLastError())));
1184         }
1185
1186  out:
1187
1188         if (request)
1189                 ippDelete(request);
1190
1191         if (response)
1192                 ippDelete(response);
1193
1194         if (language)
1195                 cupsLangFree(language);
1196
1197         if (http)
1198                 httpClose(http);
1199
1200         return ret;
1201 }
1202
1203 /*******************************************************************
1204  * CUPS printing interface definitions...
1205  ******************************************************************/
1206
1207 struct printif  cups_printif =
1208 {
1209         PRINT_CUPS,
1210         cups_queue_get,
1211         cups_queue_pause,
1212         cups_queue_resume,
1213         cups_job_delete,
1214         cups_job_pause,
1215         cups_job_resume,
1216         cups_job_submit,
1217 };
1218
1219 #else
1220  /* this keeps fussy compilers happy */
1221  void print_cups_dummy(void) {}
1222 #endif /* HAVE_CUPS */