cups/request.c

   1 /*
   2  * "$Id: request.c 7946 2008-09-16 23:27:54Z mike $"
   3  *
   4  *   IPP utilities for CUPS.
   5  *
   6  *   Copyright 2007-2010 by Apple Inc.
   7  *   Copyright 1997-2007 by Easy Software Products.
   8  *
   9  *   These coded instructions, statements, and computer programs are the
  10  *   property of Apple Inc. and are protected by Federal copyright
  11  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  *   which should have been included with this file.  If this file is
  13  *   file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  *   This file is subject to the Apple OS-Developed Software exception.
  16  *
  17  * Contents:
  18  *
  19  *   cupsDoFileRequest()    - Do an IPP request with a file.
  20  *   cupsDoIORequest()      - Do an IPP request with file descriptors.
  21  *   cupsDoRequest()        - Do an IPP request.
  22  *   cupsGetResponse()      - Get a response to an IPP request.
  23  *   cupsLastError()        - Return the last IPP status code.
  24  *   cupsLastErrorString()  - Return the last IPP status-message.
  25  *   cupsReadResponseData() - Read additional data after the IPP response.
  26  *   cupsSendRequest()      - Send an IPP request.
  27  *   cupsWriteRequestData() - Write additional data after an IPP request.
  28  *   _cupsConnect()         - Get the default server connection...
  29  *   _cupsSetError()        - Set the last IPP status code and status-message.
  30  *   _cupsSetHTTPError()    - Set the last error using the HTTP status.
  31  */
  32
  33 /*
  34  * Include necessary headers...
  35  */
  36
  37 #include "cups-private.h"
  38 #include <fcntl.h>
  39 #include <sys/stat.h>
  40 #if defined(WIN32) || defined(__EMX__)
  41 #  include <io.h>
  42 #else
  43 #  include <unistd.h>
  44 #endif /* WIN32 || __EMX__ */
  45 #ifndef O_BINARY
  46 #  define O_BINARY 0
  47 #endif /* O_BINARY */
  48
  49
  50 /*
  51  * 'cupsDoFileRequest()' - Do an IPP request with a file.
  52  *
  53  * This function sends the IPP request to the specified server, retrying
  54  * and authenticating as necessary.  The request is freed with @link ippDelete@
  55  * after receiving a valid IPP response.
  56  */
  57
  58 ipp_t *                                 /* O - Response data */
  59 cupsDoFileRequest(http_t     *http,     /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
  60                   ipp_t      *request,  /* I - IPP request */
  61                   const char *resource, /* I - HTTP resource for POST */
  62                   const char *filename) /* I - File to send or @code NULL@ for none */
  63 {
  64   ipp_t         *response;              /* IPP response data */
  65   int           infile;                 /* Input file */
  66
  67
  68   DEBUG_printf(("cupsDoFileRequest(http=%p, request=%p(%s), resource=\"%s\", "
  69                 "filename=\"%s\")", http, request,
  70                 request ? ippOpString(request->request.op.operation_id) : "?",
  71                 resource, filename));
  72
  73   if (filename)
  74   {
  75     if ((infile = open(filename, O_RDONLY | O_BINARY)) < 0)
  76     {
  77      /*
  78       * Can't get file information!
  79       */
  80
  81       _cupsSetError(errno == ENOENT ? IPP_NOT_FOUND : IPP_NOT_AUTHORIZED,
  82                     NULL, 0);
  83
  84       ippDelete(request);
  85
  86       return (NULL);
  87     }
  88   }
  89   else
  90     infile = -1;
  91
  92   response = cupsDoIORequest(http, request, resource, infile, -1);
  93
  94   if (infile >= 0)
  95     close(infile);
  96
  97   return (response);
  98 }
  99
 100
 101 /*
 102  * 'cupsDoIORequest()' - Do an IPP request with file descriptors.
 103  *
 104  * This function sends the IPP request to the specified server, retrying
 105  * and authenticating as necessary.  The request is freed with ippDelete()
 106  * after receiving a valid IPP response.
 107  *
 108  * If "infile" is a valid file descriptor, cupsDoIORequest() copies
 109  * all of the data from the file after the IPP request message.
 110  *
 111  * If "outfile" is a valid file descriptor, cupsDoIORequest() copies
 112  * all of the data after the IPP response message to the file.
 113  *
 114  * @since CUPS 1.3/Mac OS X 10.5@
 115  */
 116
 117 ipp_t *                                 /* O - Response data */
 118 cupsDoIORequest(http_t     *http,       /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 119                 ipp_t      *request,    /* I - IPP request */
 120                 const char *resource,   /* I - HTTP resource for POST */
 121                 int        infile,      /* I - File to read from or -1 for none */
 122                 int        outfile)     /* I - File to write to or -1 for none */
 123 {
 124   ipp_t         *response = NULL;       /* IPP response data */
 125   size_t        length = 0;             /* Content-Length value */
 126   http_status_t status;                 /* Status of HTTP request */
 127   struct stat   fileinfo;               /* File information */
 128   int           bytes;                  /* Number of bytes read/written */
 129   char          buffer[32768];          /* Output buffer */
 130
 131
 132   DEBUG_printf(("cupsDoIORequest(http=%p, request=%p(%s), resource=\"%s\", "
 133                 "infile=%d, outfile=%d)", http, request,
 134                 request ? ippOpString(request->request.op.operation_id) : "?",
 135                 resource, infile, outfile));
 136
 137  /*
 138   * Range check input...
 139   */
 140
 141   if (!request || !resource)
 142   {
 143     ippDelete(request);
 144
 145     _cupsSetError(IPP_INTERNAL_ERROR, strerror(EINVAL), 0);
 146
 147     return (NULL);
 148   }
 149
 150  /*
 151   * Get the default connection as needed...
 152   */
 153
 154   if (!http)
 155     if ((http = _cupsConnect()) == NULL)
 156       return (NULL);
 157
 158  /*
 159   * See if we have a file to send...
 160   */
 161
 162   if (infile >= 0)
 163   {
 164     if (fstat(infile, &fileinfo))
 165     {
 166      /*
 167       * Can't get file information!
 168       */
 169
 170       _cupsSetError(errno == EBADF ? IPP_NOT_FOUND : IPP_NOT_AUTHORIZED,
 171                     NULL, 0);
 172
 173       ippDelete(request);
 174
 175       return (NULL);
 176     }
 177
 178 #ifdef WIN32
 179     if (fileinfo.st_mode & _S_IFDIR)
 180 #else
 181     if (S_ISDIR(fileinfo.st_mode))
 182 #endif /* WIN32 */
 183     {
 184      /*
 185       * Can't send a directory...
 186       */
 187
 188       ippDelete(request);
 189
 190       _cupsSetError(IPP_NOT_POSSIBLE, strerror(EISDIR), 0);
 191
 192       return (NULL);
 193     }
 194
 195 #ifndef WIN32
 196     if (!S_ISREG(fileinfo.st_mode))
 197       length = 0;                       /* Chunk when piping */
 198     else
 199 #endif /* !WIN32 */
 200     length = ippLength(request) + fileinfo.st_size;
 201   }
 202   else
 203     length = ippLength(request);
 204
 205   DEBUG_printf(("2cupsDoIORequest: Request length=%ld, total length=%ld",
 206                 (long)ippLength(request), (long)length));
 207
 208  /*
 209   * Clear any "Local" authentication data since it is probably stale...
 210   */
 211
 212   if (http->authstring && !strncmp(http->authstring, "Local ", 6))
 213     httpSetAuthString(http, NULL, NULL);
 214
 215  /*
 216   * Loop until we can send the request without authorization problems.
 217   */
 218
 219   while (response == NULL)
 220   {
 221     DEBUG_puts("2cupsDoIORequest: setup...");
 222
 223    /*
 224     * Send the request...
 225     */
 226
 227     status = cupsSendRequest(http, request, resource, length);
 228
 229     DEBUG_printf(("2cupsDoIORequest: status=%d", status));
 230
 231     if (status == HTTP_CONTINUE && request->state == IPP_DATA && infile >= 0)
 232     {
 233       DEBUG_puts("2cupsDoIORequest: file write...");
 234
 235      /*
 236       * Send the file with the request...
 237       */
 238
 239 #ifndef WIN32
 240       if (S_ISREG(fileinfo.st_mode))
 241 #endif /* WIN32 */
 242       lseek(infile, 0, SEEK_SET);
 243
 244       while ((bytes = (int)read(infile, buffer, sizeof(buffer))) > 0)
 245       {
 246         if (httpCheck(http))
 247         {
 248           if ((status = httpUpdate(http)) != HTTP_CONTINUE)
 249             break;
 250         }
 251
 252         if (httpWrite2(http, buffer, bytes) < bytes)
 253           break;
 254       }
 255     }
 256
 257    /*
 258     * Get the server's response...
 259     */
 260
 261     if (status == HTTP_CONTINUE || status == HTTP_OK)
 262     {
 263       response = cupsGetResponse(http, resource);
 264       status   = http->status;
 265     }
 266     else
 267       httpFlush(http);
 268
 269     DEBUG_printf(("2cupsDoIORequest: status=%d", status));
 270
 271     if (status == HTTP_ERROR ||
 272         (status >= HTTP_BAD_REQUEST && status != HTTP_UNAUTHORIZED &&
 273          status != HTTP_UPGRADE_REQUIRED))
 274     {
 275       _cupsSetHTTPError(status);
 276       break;
 277     }
 278
 279     if (response)
 280     {
 281       if (outfile >= 0)
 282       {
 283        /*
 284         * Write trailing data to file...
 285         */
 286
 287         while ((bytes = (int)httpRead2(http, buffer, sizeof(buffer))) > 0)
 288           if (write(outfile, buffer, bytes) < bytes)
 289             break;
 290       }
 291       else
 292       {
 293        /*
 294         * Flush any remaining data...
 295         */
 296
 297         httpFlush(http);
 298       }
 299     }
 300   }
 301
 302  /*
 303   * Delete the original request and return the response...
 304   */
 305
 306   ippDelete(request);
 307
 308   return (response);
 309 }
 310
 311
 312 /*
 313  * 'cupsDoRequest()' - Do an IPP request.
 314  *
 315  * This function sends the IPP request to the specified server, retrying
 316  * and authenticating as necessary.  The request is freed with ippDelete()
 317  * after receiving a valid IPP response.
 318  */
 319
 320 ipp_t *                                 /* O - Response data */
 321 cupsDoRequest(http_t     *http,         /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 322               ipp_t      *request,      /* I - IPP request */
 323               const char *resource)     /* I - HTTP resource for POST */
 324 {
 325   DEBUG_printf(("cupsDoRequest(http=%p, request=%p(%s), resource=\"%s\")",
 326                 http, request,
 327                 request ? ippOpString(request->request.op.operation_id) : "?",
 328                 resource));
 329
 330   return (cupsDoIORequest(http, request, resource, -1, -1));
 331 }
 332
 333
 334 /*
 335  * 'cupsGetResponse()' - Get a response to an IPP request.
 336  *
 337  * Use this function to get the response for an IPP request sent using
 338  * cupsSendDocument() or cupsSendRequest(). For requests that return
 339  * additional data, use httpRead() after getting a successful response.
 340  *
 341  * @since CUPS 1.4/Mac OS X 10.6@
 342  */
 343
 344 ipp_t *                                 /* O - Response or @code NULL@ on HTTP error */
 345 cupsGetResponse(http_t     *http,       /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 346                 const char *resource)   /* I - HTTP resource for POST */
 347 {
 348   http_status_t status;                 /* HTTP status */
 349   ipp_state_t   state;                  /* IPP read state */
 350   ipp_t         *response = NULL;       /* IPP response */
 351
 352
 353   DEBUG_printf(("cupsGetResponse(http=%p, resource=\"%s\")", http, resource));
 354
 355  /*
 356   * Connect to the default server as needed...
 357   */
 358
 359   if (!http)
 360     http = _cupsConnect();
 361
 362   if (!http || (http->state != HTTP_POST_RECV && http->state != HTTP_POST_SEND))
 363     return (NULL);
 364
 365  /*
 366   * Check for an unfinished chunked request...
 367   */
 368
 369   if (http->data_encoding == HTTP_ENCODE_CHUNKED)
 370   {
 371    /*
 372     * Send a 0-length chunk to finish off the request...
 373     */
 374
 375     DEBUG_puts("2cupsGetResponse: Finishing chunked POST...");
 376
 377     if (httpWrite2(http, "", 0) < 0)
 378       return (NULL);
 379   }
 380
 381  /*
 382   * Wait for a response from the server...
 383   */
 384
 385   DEBUG_printf(("2cupsGetResponse: Update loop, http->status=%d...",
 386                 http->status));
 387
 388   status = http->status;
 389   while (status == HTTP_CONTINUE)
 390     status = httpUpdate(http);
 391
 392   DEBUG_printf(("2cupsGetResponse: status=%d", status));
 393
 394   if (status == HTTP_OK)
 395   {
 396    /*
 397     * Get the IPP response...
 398     */
 399
 400     response = ippNew();
 401
 402     while ((state = ippRead(http, response)) != IPP_DATA)
 403       if (state == IPP_ERROR)
 404         break;
 405
 406     if (state == IPP_ERROR)
 407     {
 408      /*
 409       * Delete the response...
 410       */
 411
 412       DEBUG_puts("1cupsGetResponse: IPP read error!");
 413
 414       ippDelete(response);
 415       response = NULL;
 416
 417       _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 418     }
 419   }
 420   else if (status != HTTP_ERROR)
 421   {
 422    /*
 423     * Flush any error message...
 424     */
 425
 426     httpFlush(http);
 427
 428    /*
 429     * Then handle encryption and authentication...
 430     */
 431
 432     if (status == HTTP_UNAUTHORIZED)
 433     {
 434      /*
 435       * See if we can do authentication...
 436       */
 437
 438       DEBUG_puts("2cupsGetResponse: Need authorization...");
 439
 440       if (!cupsDoAuthentication(http, "POST", resource))
 441         httpReconnect(http);
 442       else
 443         status = HTTP_AUTHORIZATION_CANCELED;
 444     }
 445
 446 #ifdef HAVE_SSL
 447     else if (status == HTTP_UPGRADE_REQUIRED)
 448     {
 449      /*
 450       * Force a reconnect with encryption...
 451       */
 452
 453       DEBUG_puts("2cupsGetResponse: Need encryption...");
 454
 455       if (!httpReconnect(http))
 456         httpEncryption(http, HTTP_ENCRYPT_REQUIRED);
 457     }
 458 #endif /* HAVE_SSL */
 459   }
 460
 461   if (response)
 462   {
 463     ipp_attribute_t     *attr;          /* status-message attribute */
 464
 465
 466     attr = ippFindAttribute(response, "status-message", IPP_TAG_TEXT);
 467
 468     DEBUG_printf(("1cupsGetResponse: status-code=%s, status-message=\"%s\"",
 469                   ippErrorString(response->request.status.status_code),
 470                   attr ? attr->values[0].string.text : ""));
 471
 472     _cupsSetError(response->request.status.status_code,
 473                   attr ? attr->values[0].string.text :
 474                       ippErrorString(response->request.status.status_code), 0);
 475   }
 476   else if (status != HTTP_OK)
 477     _cupsSetHTTPError(status);
 478
 479   return (response);
 480 }
 481
 482
 483 /*
 484  * 'cupsLastError()' - Return the last IPP status code.
 485  */
 486
 487 ipp_status_t                            /* O - IPP status code from last request */
 488 cupsLastError(void)
 489 {
 490   return (_cupsGlobals()->last_error);
 491 }
 492
 493
 494 /*
 495  * 'cupsLastErrorString()' - Return the last IPP status-message.
 496  *
 497  * @since CUPS 1.2/Mac OS X 10.5@
 498  */
 499
 500 const char *                            /* O - status-message text from last request */
 501 cupsLastErrorString(void)
 502 {
 503   return (_cupsGlobals()->last_status_message);
 504 }
 505
 506
 507 /*
 508  * 'cupsReadResponseData()' - Read additional data after the IPP response.
 509  *
 510  * This function is used after cupsGetResponse() to read the PPD or document
 511  * files for CUPS_GET_PPD and CUPS_GET_DOCUMENT requests, respectively.
 512  *
 513  * @since CUPS 1.4/Mac OS X 10.6@
 514  */
 515
 516 ssize_t                                 /* O - Bytes read, 0 on EOF, -1 on error */
 517 cupsReadResponseData(
 518     http_t *http,                       /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 519     char   *buffer,                     /* I - Buffer to use */
 520     size_t length)                      /* I - Number of bytes to read */
 521 {
 522  /*
 523   * Get the default connection as needed...
 524   */
 525
 526   DEBUG_printf(("cupsReadResponseData(http=%p, buffer=%p, "
 527                 "length=" CUPS_LLFMT ")", http, buffer, CUPS_LLCAST length));
 528
 529   if (!http)
 530   {
 531     _cups_globals_t *cg = _cupsGlobals();
 532                                         /* Pointer to library globals */
 533
 534     if ((http = cg->http) == NULL)
 535     {
 536       _cupsSetError(IPP_INTERNAL_ERROR, _("No active connection"), 1);
 537       return (-1);
 538     }
 539   }
 540
 541  /*
 542   * Then read from the HTTP connection...
 543   */
 544
 545   return (httpRead2(http, buffer, length));
 546 }
 547
 548
 549 /*
 550  * 'cupsSendRequest()' - Send an IPP request.
 551  *
 552  * Use httpWrite() to write any additional data (document, PPD file, etc.)
 553  * for the request, cupsGetResponse() to get the IPP response, and httpRead()
 554  * to read any additional data following the response. Only one request can be
 555  * sent/queued at a time.
 556  *
 557  * Unlike cupsDoFileRequest(), cupsDoIORequest(), and cupsDoRequest(), the
 558  * request is not freed.
 559  *
 560  * @since CUPS 1.4/Mac OS X 10.6@
 561  */
 562
 563 http_status_t                           /* O - Initial HTTP status */
 564 cupsSendRequest(http_t     *http,       /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 565                 ipp_t      *request,    /* I - IPP request */
 566                 const char *resource,   /* I - Resource path */
 567                 size_t     length)      /* I - Length of data to follow or @code CUPS_LENGTH_VARIABLE@ */
 568 {
 569   http_status_t status;                 /* Status of HTTP request */
 570   int           got_status;             /* Did we get the status? */
 571   ipp_state_t   state;                  /* State of IPP processing */
 572   http_status_t expect;                 /* Expect: header to use */
 573
 574
 575   DEBUG_printf(("cupsSendRequest(http=%p, request=%p(%s), resource=\"%s\", "
 576                 "length=" CUPS_LLFMT ")", http, request,
 577                 request ? ippOpString(request->request.op.operation_id) : "?",
 578                 resource, CUPS_LLCAST length));
 579
 580  /*
 581   * Range check input...
 582   */
 583
 584   if (!request || !resource)
 585   {
 586     _cupsSetError(IPP_INTERNAL_ERROR, strerror(EINVAL), 0);
 587
 588     return (HTTP_ERROR);
 589   }
 590
 591  /*
 592   * Get the default connection as needed...
 593   */
 594
 595   if (!http)
 596     if ((http = _cupsConnect()) == NULL)
 597       return (HTTP_SERVICE_UNAVAILABLE);
 598
 599 #ifdef HAVE_SSL
 600  /*
 601   * See if we have an auth-info attribute and are communicating over
 602   * a non-local link.  If so, encrypt the link so that we can pass
 603   * the authentication information securely...
 604   */
 605
 606   if (ippFindAttribute(request, "auth-info", IPP_TAG_TEXT) &&
 607       !httpAddrLocalhost(http->hostaddr) && !http->tls &&
 608       httpEncryption(http, HTTP_ENCRYPT_REQUIRED))
 609   {
 610     _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 611     return (HTTP_SERVICE_UNAVAILABLE);
 612   }
 613 #endif /* HAVE_SSL */
 614
 615  /*
 616   * Reconnect if the last response had a "Connection: close"...
 617   */
 618
 619   if (!strcasecmp(http->fields[HTTP_FIELD_CONNECTION], "close"))
 620     if (httpReconnect(http))
 621     {
 622       _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 623       return (HTTP_SERVICE_UNAVAILABLE);
 624     }
 625
 626  /*
 627   * Loop until we can send the request without authorization problems.
 628   */
 629
 630   expect = HTTP_CONTINUE;
 631
 632   for (;;)
 633   {
 634     DEBUG_puts("2cupsSendRequest: Setup...");
 635
 636    /*
 637     * Setup the HTTP variables needed...
 638     */
 639
 640     httpClearFields(http);
 641     httpSetExpect(http, expect);
 642     httpSetField(http, HTTP_FIELD_CONTENT_TYPE, "application/ipp");
 643     httpSetLength(http, length);
 644
 645 #ifdef HAVE_GSSAPI
 646     if (http->authstring && !strncmp(http->authstring, "Negotiate", 9))
 647     {
 648      /*
 649       * Do not use cached Kerberos credentials since they will look like a
 650       * "replay" attack...
 651       */
 652
 653       cupsDoAuthentication(http, "POST", resource);
 654     }
 655     else
 656 #endif /* HAVE_GSSAPI */
 657     httpSetField(http, HTTP_FIELD_AUTHORIZATION, http->authstring);
 658
 659     DEBUG_printf(("2cupsSendRequest: authstring=\"%s\"", http->authstring));
 660
 661    /*
 662     * Try the request...
 663     */
 664
 665     DEBUG_puts("2cupsSendRequest: Sending HTTP POST...");
 666
 667     if (httpPost(http, resource))
 668     {
 669       if (httpReconnect(http))
 670       {
 671         _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 672         return (HTTP_SERVICE_UNAVAILABLE);
 673       }
 674       else
 675         continue;
 676     }
 677
 678    /*
 679     * Send the IPP data...
 680     */
 681
 682     DEBUG_puts("2cupsSendRequest: Writing IPP request...");
 683
 684     request->state = IPP_IDLE;
 685     status         = HTTP_CONTINUE;
 686     got_status     = 0;
 687
 688     while ((state = ippWrite(http, request)) != IPP_DATA)
 689       if (state == IPP_ERROR)
 690         break;
 691       else if (httpCheck(http))
 692       {
 693         got_status = 1;
 694
 695         if ((status = httpUpdate(http)) != HTTP_CONTINUE)
 696           break;
 697       }
 698
 699    /*
 700     * Wait up to 1 second to get the 100-continue response as needed...
 701     */
 702
 703     if (!got_status && expect == HTTP_CONTINUE)
 704     {
 705       DEBUG_puts("2cupsSendRequest: Waiting for 100-continue...");
 706
 707       if (httpWait(http, 1000))
 708         status = httpUpdate(http);
 709     }
 710     else if (httpCheck(http))
 711       status = httpUpdate(http);
 712
 713     DEBUG_printf(("2cupsSendRequest: status=%d", status));
 714
 715    /*
 716     * Process the current HTTP status...
 717     */
 718
 719     if (status >= HTTP_BAD_REQUEST)
 720       httpFlush(http);
 721
 722     switch (status)
 723     {
 724       case HTTP_ERROR :
 725       case HTTP_CONTINUE :
 726       case HTTP_OK :
 727           return (status);
 728
 729       case HTTP_UNAUTHORIZED :
 730           if (cupsDoAuthentication(http, "POST", resource))
 731             return (HTTP_AUTHORIZATION_CANCELED);
 732
 733           if (httpReconnect(http))
 734           {
 735             _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 736             return (HTTP_SERVICE_UNAVAILABLE);
 737           }
 738           break;
 739
 740 #ifdef HAVE_SSL
 741       case HTTP_UPGRADE_REQUIRED :
 742          /*
 743           * Flush any error message, reconnect, and then upgrade with
 744           * encryption...
 745           */
 746
 747           if (httpReconnect(http))
 748           {
 749             _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 750             return (HTTP_SERVICE_UNAVAILABLE);
 751           }
 752
 753           if (httpEncryption(http, HTTP_ENCRYPT_REQUIRED))
 754           {
 755             _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 756             return (HTTP_SERVICE_UNAVAILABLE);
 757           }
 758           break;
 759 #endif /* HAVE_SSL */
 760
 761       case HTTP_EXPECTATION_FAILED :
 762          /*
 763           * Don't try using the Expect: header the next time around...
 764           */
 765
 766           expect = (http_status_t)0;
 767
 768           if (httpReconnect(http))
 769           {
 770             _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 771             return (HTTP_SERVICE_UNAVAILABLE);
 772           }
 773           break;
 774
 775       default :
 776          /*
 777           * Some other error...
 778           */
 779
 780           return (status);
 781     }
 782   }
 783 }
 784
 785
 786 /*
 787  * 'cupsWriteRequestData()' - Write additional data after an IPP request.
 788  *
 789  * This function is used after @link cupsSendRequest@ to provide a PPD and
 790  * after @link cupsStartDocument@ to provide a document file.
 791  *
 792  * @since CUPS 1.4/Mac OS X 10.6@
 793  */
 794
 795 http_status_t                           /* O - @code HTTP_CONTINUE@ if OK or HTTP status on error */
 796 cupsWriteRequestData(
 797     http_t     *http,                   /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 798     const char *buffer,                 /* I - Bytes to write */
 799     size_t     length)                  /* I - Number of bytes to write */
 800 {
 801   int   wused;                          /* Previous bytes in buffer */
 802
 803
 804  /*
 805   * Get the default connection as needed...
 806   */
 807
 808   DEBUG_printf(("cupsWriteRequestData(http=%p, buffer=%p, "
 809                 "length=" CUPS_LLFMT ")", http, buffer, CUPS_LLCAST length));
 810
 811   if (!http)
 812   {
 813     _cups_globals_t *cg = _cupsGlobals();
 814                                         /* Pointer to library globals */
 815
 816     if ((http = cg->http) == NULL)
 817     {
 818       _cupsSetError(IPP_INTERNAL_ERROR, _("No active connection"), 1);
 819       DEBUG_puts("1cupsWriteRequestData: Returning HTTP_ERROR.");
 820       return (HTTP_ERROR);
 821     }
 822   }
 823
 824  /*
 825   * Then write to the HTTP connection...
 826   */
 827
 828   wused = http->wused;
 829
 830   if (httpWrite2(http, buffer, length) < 0)
 831   {
 832     DEBUG_puts("1cupsWriteRequestData: Returning HTTP_ERROR.");
 833     _cupsSetError(IPP_INTERNAL_ERROR, strerror(http->error), 0);
 834     return (HTTP_ERROR);
 835   }
 836
 837  /*
 838   * Finally, check if we have any pending data from the server...
 839   */
 840
 841   if (length >= HTTP_MAX_BUFFER ||
 842       http->wused < wused ||
 843       (wused > 0 && http->wused == length))
 844   {
 845    /*
 846     * We've written something to the server, so check for response data...
 847     */
 848
 849     if (_httpWait(http, 0, 1))
 850     {
 851       http_status_t     status;         /* Status from httpUpdate */
 852
 853       if ((status = httpUpdate(http)) >= HTTP_BAD_REQUEST)
 854       {
 855         _cupsSetHTTPError(status);
 856         httpFlush(http);
 857       }
 858
 859       DEBUG_printf(("1cupsWriteRequestData: Returning %d.\n", status));
 860       return (status);
 861     }
 862   }
 863
 864   DEBUG_puts("1cupsWriteRequestData: Returning HTTP_CONTINUE.");
 865   return (HTTP_CONTINUE);
 866 }
 867
 868
 869 /*
 870  * '_cupsConnect()' - Get the default server connection...
 871  */
 872
 873 http_t *                                /* O - HTTP connection */
 874 _cupsConnect(void)
 875 {
 876   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 877
 878
 879  /*
 880   * See if we are connected to the same server...
 881   */
 882
 883   if (cg->http)
 884   {
 885    /*
 886     * Compare the connection hostname, port, and encryption settings to
 887     * the cached defaults; these were initialized the first time we
 888     * connected...
 889     */
 890
 891     if (strcmp(cg->http->hostname, cg->server) ||
 892         cg->ipp_port != _httpAddrPort(cg->http->hostaddr) ||
 893         (cg->http->encryption != cg->encryption &&
 894          cg->http->encryption == HTTP_ENCRYPT_NEVER))
 895     {
 896      /*
 897       * Need to close the current connection because something has changed...
 898       */
 899
 900       httpClose(cg->http);
 901       cg->http = NULL;
 902     }
 903   }
 904
 905  /*
 906   * (Re)connect as needed...
 907   */
 908
 909   if (!cg->http)
 910   {
 911     if ((cg->http = httpConnectEncrypt(cupsServer(), ippPort(),
 912                                        cupsEncryption())) == NULL)
 913     {
 914       if (errno)
 915         _cupsSetError(IPP_SERVICE_UNAVAILABLE, NULL, 0);
 916       else
 917         _cupsSetError(IPP_SERVICE_UNAVAILABLE,
 918                       _("Unable to connect to host."), 1);
 919     }
 920   }
 921
 922  /*
 923   * Return the cached connection...
 924   */
 925
 926   return (cg->http);
 927 }
 928
 929
 930 /*
 931  * '_cupsSetError()' - Set the last IPP status code and status-message.
 932  */
 933
 934 void
 935 _cupsSetError(ipp_status_t status,      /* I - IPP status code */
 936               const char   *message,    /* I - status-message value */
 937               int          localize)    /* I - Localize the message? */
 938 {
 939   _cups_globals_t       *cg;            /* Global data */
 940
 941
 942   if (!message && errno)
 943   {
 944     message  = strerror(errno);
 945     localize = 0;
 946   }
 947
 948   cg             = _cupsGlobals();
 949   cg->last_error = status;
 950
 951   if (cg->last_status_message)
 952   {
 953     _cupsStrFree(cg->last_status_message);
 954
 955     cg->last_status_message = NULL;
 956   }
 957
 958   if (message)
 959   {
 960     if (localize)
 961     {
 962      /*
 963       * Get the message catalog...
 964       */
 965
 966       if (!cg->lang_default)
 967         cg->lang_default = cupsLangDefault();
 968
 969       cg->last_status_message = _cupsStrAlloc(_cupsLangString(cg->lang_default,
 970                                                               message));
 971     }
 972     else
 973       cg->last_status_message = _cupsStrAlloc(message);
 974   }
 975
 976   DEBUG_printf(("4_cupsSetError: last_error=%s, last_status_message=\"%s\"",
 977                 ippErrorString(cg->last_error), cg->last_status_message));
 978 }
 979
 980
 981 /*
 982  * '_cupsSetHTTPError()' - Set the last error using the HTTP status.
 983  */
 984
 985 void
 986 _cupsSetHTTPError(http_status_t status) /* I - HTTP status code */
 987 {
 988   switch (status)
 989   {
 990     case HTTP_NOT_FOUND :
 991         _cupsSetError(IPP_NOT_FOUND, httpStatus(status), 0);
 992         break;
 993
 994     case HTTP_UNAUTHORIZED :
 995         _cupsSetError(IPP_NOT_AUTHENTICATED, httpStatus(status), 0);
 996         break;
 997
 998     case HTTP_AUTHORIZATION_CANCELED :
 999         _cupsSetError(IPP_AUTHENTICATION_CANCELED, httpStatus(status), 0);
1000         break;
1001
1002     case HTTP_FORBIDDEN :
1003         _cupsSetError(IPP_FORBIDDEN, httpStatus(status), 0);
1004         break;
1005
1006     case HTTP_BAD_REQUEST :
1007         _cupsSetError(IPP_BAD_REQUEST, httpStatus(status), 0);
1008         break;
1009
1010     case HTTP_REQUEST_TOO_LARGE :
1011         _cupsSetError(IPP_REQUEST_VALUE, httpStatus(status), 0);
1012         break;
1013
1014     case HTTP_NOT_IMPLEMENTED :
1015         _cupsSetError(IPP_OPERATION_NOT_SUPPORTED, httpStatus(status), 0);
1016         break;
1017
1018     case HTTP_NOT_SUPPORTED :
1019         _cupsSetError(IPP_VERSION_NOT_SUPPORTED, httpStatus(status), 0);
1020         break;
1021
1022     case HTTP_UPGRADE_REQUIRED :
1023         _cupsSetError(IPP_UPGRADE_REQUIRED, httpStatus(status), 0);
1024         break;
1025
1026     case HTTP_PKI_ERROR :
1027         _cupsSetError(IPP_PKI_ERROR, httpStatus(status), 0);
1028         break;
1029
1030     case HTTP_ERROR :
1031         _cupsSetError(IPP_INTERNAL_ERROR, httpStatus(status), 0);
1032         break;
1033
1034     default :
1035         DEBUG_printf(("4_cupsSetHTTPError: HTTP error %d mapped to "
1036                       "IPP_SERVICE_UNAVAILABLE!", status));
1037         _cupsSetError(IPP_SERVICE_UNAVAILABLE, httpStatus(status), 0);
1038         break;
1039   }
1040 }
1041
1042
1043 /*
1044  * End of "$Id: request.c 7946 2008-09-16 23:27:54Z mike $".
1045  */