cups/request.c

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