cups/http.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   HTTP routines for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 1997-2006 by Easy Software Products, all rights reserved.
   7  *
   8  *   These coded instructions, statements, and computer programs are the
   9  *   property of Easy Software Products and are protected by Federal
  10  *   copyright law.  Distribution and use rights are outlined in the file
  11  *   "LICENSE.txt" which should have been included with this file.  If this
  12  *   file is missing or damaged please contact Easy Software Products
  13  *   at:
  14  *
  15  *       Attn: CUPS Licensing Information
  16  *       Easy Software Products
  17  *       44141 Airport View Drive, Suite 204
  18  *       Hollywood, Maryland 20636 USA
  19  *
  20  *       Voice: (301) 373-9600
  21  *       EMail: cups-info@cups.org
  22  *         WWW: http://www.cups.org
  23  *
  24  *   This file is subject to the Apple OS-Developed Software exception.
  25  *
  26  * Contents:
  27  *
  28  *   httpBlocking()       - Set blocking/non-blocking behavior on a connection.
  29  *   httpCheck()          - Check to see if there is a pending response from
  30  *                          the server.
  31  *   httpClearCookie()    - Clear the cookie value(s).
  32  *   httpClearFields()    - Clear HTTP request fields.
  33  *   httpClose()          - Close an HTTP connection...
  34  *   httpConnect()        - Connect to a HTTP server.
  35  *   httpConnectEncrypt() - Connect to a HTTP server using encryption.
  36  *   httpDelete()         - Send a DELETE request to the server.
  37  *   httpEncryption()     - Set the required encryption on the link.
  38  *   httpError()          - Get the last error on a connection.
  39  *   httpFlush()          - Flush data from a HTTP connection.
  40  *   httpFlushWrite()     - Flush data in write buffer.
  41  *   httpGet()            - Send a GET request to the server.
  42  *   httpGetBlocking()    - Get the blocking/non-block state of a connection.
  43  *   httpGetCookie()      - Get any cookie data from the response.
  44  *   httpGetFd()          - Get the file descriptor associated with a
  45  *                          connection.
  46  *   httpGetField()       - Get a field value from a request/response.
  47  *   httpGetLength()      - Get the amount of data remaining from the
  48  *                          content-length or transfer-encoding fields.
  49  *   httpGetLength2()     - Get the amount of data remaining from the
  50  *                          content-length or transfer-encoding fields.
  51  *   httpGetStatus()      - Get the status of the last HTTP request.
  52  *   httpGetSubField()    - Get a sub-field value.
  53  *   httpGets()           - Get a line of text from a HTTP connection.
  54  *   httpHead()           - Send a HEAD request to the server.
  55  *   httpInitialize()     - Initialize the HTTP interface library and set the
  56  *                          default HTTP proxy (if any).
  57  *   httpOptions()        - Send an OPTIONS request to the server.
  58  *   httpPost()           - Send a POST request to the server.
  59  *   httpPrintf()         - Print a formatted string to a HTTP connection.
  60  *   httpPut()            - Send a PUT request to the server.
  61  *   httpRead()           - Read data from a HTTP connection.
  62  *   httpRead2()          - Read data from a HTTP connection.
  63  *   _httpReadCDSA()      - Read function for CDSA decryption code.
  64  *   httpReconnect()      - Reconnect to a HTTP server...
  65  *   httpSetCookie()      - Set the cookie value(s)...
  66  *   httpSetExpect()      - Set the Expect: header in a request.
  67  *   httpSetField()       - Set the value of an HTTP header.
  68  *   httpSetLength()      - Set the content-length and transfer-encoding.
  69  *   httpTrace()          - Send an TRACE request to the server.
  70  *   httpUpdate()         - Update the current HTTP state for incoming data.
  71  *   httpWait()           - Wait for data available on a connection.
  72  *   httpWrite()          - Write data to a HTTP connection.
  73  *   httpWrite2()         - Write data to a HTTP connection.
  74  *   _httpWriteCDSA()     - Write function for CDSA encryption code.
  75  *   http_field()         - Return the field index for a field name.
  76  *   http_read_ssl()      - Read from a SSL/TLS connection.
  77  *   http_send()          - Send a request with all fields and the trailing
  78  *                          blank line.
  79  *   http_setup_ssl()     - Set up SSL/TLS on a connection.
  80  *   http_shutdown_ssl()  - Shut down SSL/TLS on a connection.
  81  *   http_upgrade()       - Force upgrade to TLS encryption.
  82  *   http_wait()          - Wait for data available on a connection.
  83  *   http_write()         - Write data to a connection.
  84  *   http_write_ssl()     - Write to a SSL/TLS connection.
  85  */
  86
  87 /*
  88  * Include necessary headers...
  89  */
  90
  91 #include "http-private.h"
  92 #include "globals.h"
  93 #include "debug.h"
  94 #include <stdlib.h>
  95 #include <fcntl.h>
  96 #include <errno.h>
  97 #ifndef WIN32
  98 #  include <signal.h>
  99 #  include <sys/time.h>
 100 #  include <sys/resource.h>
 101 #endif /* !WIN32 */
 102
 103
 104 /*
 105  * Some operating systems have done away with the Fxxxx constants for
 106  * the fcntl() call; this works around that "feature"...
 107  */
 108
 109 #ifndef FNONBLK
 110 #  define FNONBLK O_NONBLOCK
 111 #endif /* !FNONBLK */
 112
 113
 114 /*
 115  * Local functions...
 116  */
 117
 118 static http_field_t     http_field(const char *name);
 119 static int              http_send(http_t *http, http_state_t request,
 120                                   const char *uri);
 121 static int              http_wait(http_t *http, int msec);
 122 static int              http_write(http_t *http, const char *buffer,
 123                                    int length);
 124 static int              http_write_chunk(http_t *http, const char *buffer,
 125                                          int length);
 126 #ifdef HAVE_SSL
 127 static int              http_read_ssl(http_t *http, char *buf, int len);
 128 static int              http_setup_ssl(http_t *http);
 129 static void             http_shutdown_ssl(http_t *http);
 130 static int              http_upgrade(http_t *http);
 131 static int              http_write_ssl(http_t *http, const char *buf, int len);
 132 #endif /* HAVE_SSL */
 133
 134
 135 /*
 136  * Local globals...
 137  */
 138
 139 static const char * const http_fields[] =
 140                         {
 141                           "Accept-Language",
 142                           "Accept-Ranges",
 143                           "Authorization",
 144                           "Connection",
 145                           "Content-Encoding",
 146                           "Content-Language",
 147                           "Content-Length",
 148                           "Content-Location",
 149                           "Content-MD5",
 150                           "Content-Range",
 151                           "Content-Type",
 152                           "Content-Version",
 153                           "Date",
 154                           "Host",
 155                           "If-Modified-Since",
 156                           "If-Unmodified-since",
 157                           "Keep-Alive",
 158                           "Last-Modified",
 159                           "Link",
 160                           "Location",
 161                           "Range",
 162                           "Referer",
 163                           "Retry-After",
 164                           "Transfer-Encoding",
 165                           "Upgrade",
 166                           "User-Agent",
 167                           "WWW-Authenticate"
 168                         };
 169
 170
 171 /*
 172  * 'httpBlocking()' - Set blocking/non-blocking behavior on a connection.
 173  */
 174
 175 void
 176 httpBlocking(http_t *http,              /* I - HTTP connection */
 177              int    b)                  /* I - 1 = blocking, 0 = non-blocking */
 178 {
 179   if (http)
 180     http->blocking = b;
 181 }
 182
 183
 184 /*
 185  * 'httpCheck()' - Check to see if there is a pending response from the server.
 186  */
 187
 188 int                                     /* O - 0 = no data, 1 = data available */
 189 httpCheck(http_t *http)                 /* I - HTTP connection */
 190 {
 191   return (httpWait(http, 0));
 192 }
 193
 194
 195 /*
 196  * 'httpClearCookie()' - Clear the cookie value(s).
 197  *
 198  * @since CUPS 1.1.19@
 199  */
 200
 201 void
 202 httpClearCookie(http_t *http)           /* I - HTTP connection */
 203 {
 204   if (!http)
 205     return;
 206
 207   if (http->cookie)
 208   {
 209     free(http->cookie);
 210     http->cookie = NULL;
 211   }
 212 }
 213
 214
 215 /*
 216  * 'httpClearFields()' - Clear HTTP request fields.
 217  */
 218
 219 void
 220 httpClearFields(http_t *http)           /* I - HTTP connection */
 221 {
 222   if (http)
 223   {
 224     memset(http->fields, 0, sizeof(http->fields));
 225     httpSetField(http, HTTP_FIELD_HOST, http->hostname);
 226
 227     http->expect = (http_status_t)0;
 228   }
 229 }
 230
 231
 232 /*
 233  * 'httpClose()' - Close an HTTP connection...
 234  */
 235
 236 void
 237 httpClose(http_t *http)                 /* I - HTTP connection */
 238 {
 239   DEBUG_printf(("httpClose(http=%p)\n", http));
 240
 241   if (!http)
 242     return;
 243
 244   httpAddrFreeList(http->addrlist);
 245
 246   if (http->input_set)
 247     free(http->input_set);
 248
 249   if (http->cookie)
 250     free(http->cookie);
 251
 252 #ifdef HAVE_SSL
 253   if (http->tls)
 254     http_shutdown_ssl(http);
 255 #endif /* HAVE_SSL */
 256
 257 #ifdef WIN32
 258   closesocket(http->fd);
 259 #else
 260   close(http->fd);
 261 #endif /* WIN32 */
 262
 263   free(http);
 264 }
 265
 266
 267 /*
 268  * 'httpConnect()' - Connect to a HTTP server.
 269  */
 270
 271 http_t *                                /* O - New HTTP connection */
 272 httpConnect(const char *host,           /* I - Host to connect to */
 273             int        port)            /* I - Port number */
 274 {
 275   http_encryption_t     encryption;     /* Type of encryption to use */
 276
 277
 278  /*
 279   * Set the default encryption status...
 280   */
 281
 282   if (port == 443)
 283     encryption = HTTP_ENCRYPT_ALWAYS;
 284   else
 285     encryption = HTTP_ENCRYPT_IF_REQUESTED;
 286
 287   return (httpConnectEncrypt(host, port, encryption));
 288 }
 289
 290
 291 /*
 292  * 'httpConnectEncrypt()' - Connect to a HTTP server using encryption.
 293  */
 294
 295 http_t *                                /* O - New HTTP connection */
 296 httpConnectEncrypt(
 297     const char        *host,            /* I - Host to connect to */
 298     int               port,             /* I - Port number */
 299     http_encryption_t encryption)       /* I - Type of encryption to use */
 300 {
 301   http_t                *http;          /* New HTTP connection */
 302   http_addrlist_t       *addrlist;      /* Host address data */
 303   char                  service[255];   /* Service name */
 304
 305
 306   DEBUG_printf(("httpConnectEncrypt(host=\"%s\", port=%d, encryption=%d)\n",
 307                 host ? host : "(null)", port, encryption));
 308
 309   if (!host)
 310     return (NULL);
 311
 312   httpInitialize();
 313
 314  /*
 315   * Lookup the host...
 316   */
 317
 318   sprintf(service, "%d", port);
 319
 320   if ((addrlist = httpAddrGetList(host, AF_UNSPEC, service)) == NULL)
 321     return (NULL);
 322
 323  /*
 324   * Allocate memory for the structure...
 325   */
 326
 327   http = calloc(sizeof(http_t), 1);
 328   if (http == NULL)
 329     return (NULL);
 330
 331   http->version  = HTTP_1_1;
 332   http->blocking = 1;
 333   http->activity = time(NULL);
 334   http->fd       = -1;
 335
 336  /*
 337   * Set the encryption status...
 338   */
 339
 340   if (port == 443)                      /* Always use encryption for https */
 341     http->encryption = HTTP_ENCRYPT_ALWAYS;
 342   else
 343     http->encryption = encryption;
 344
 345  /*
 346   * Loop through the addresses we have until one of them connects...
 347   */
 348
 349   strlcpy(http->hostname, host, sizeof(http->hostname));
 350
 351  /*
 352   * Connect to the remote system...
 353   */
 354
 355   http->addrlist = addrlist;
 356
 357   if (!httpReconnect(http))
 358     return (http);
 359
 360  /*
 361   * Could not connect to any known address - bail out!
 362   */
 363
 364   httpAddrFreeList(addrlist);
 365
 366   free(http);
 367
 368   return (NULL);
 369 }
 370
 371
 372 /*
 373  * 'httpDelete()' - Send a DELETE request to the server.
 374  */
 375
 376 int                                     /* O - Status of call (0 = success) */
 377 httpDelete(http_t     *http,            /* I - HTTP connection */
 378            const char *uri)             /* I - URI to delete */
 379 {
 380   return (http_send(http, HTTP_DELETE, uri));
 381 }
 382
 383
 384 /*
 385  * 'httpEncryption()' - Set the required encryption on the link.
 386  */
 387
 388 int                                     /* O - -1 on error, 0 on success */
 389 httpEncryption(http_t            *http, /* I - HTTP connection */
 390                http_encryption_t e)     /* I - New encryption preference */
 391 {
 392   DEBUG_printf(("httpEncryption(http=%p, e=%d)\n", http, e));
 393
 394 #ifdef HAVE_SSL
 395   if (!http)
 396     return (0);
 397
 398   http->encryption = e;
 399
 400   if ((http->encryption == HTTP_ENCRYPT_ALWAYS && !http->tls) ||
 401       (http->encryption == HTTP_ENCRYPT_NEVER && http->tls))
 402     return (httpReconnect(http));
 403   else if (http->encryption == HTTP_ENCRYPT_REQUIRED && !http->tls)
 404     return (http_upgrade(http));
 405   else
 406     return (0);
 407 #else
 408   if (e == HTTP_ENCRYPT_ALWAYS || e == HTTP_ENCRYPT_REQUIRED)
 409     return (-1);
 410   else
 411     return (0);
 412 #endif /* HAVE_SSL */
 413 }
 414
 415
 416 /*
 417  * 'httpError()' - Get the last error on a connection.
 418  */
 419
 420 int                                     /* O - Error code (errno) value */
 421 httpError(http_t *http)                 /* I - HTTP connection */
 422 {
 423   if (http)
 424     return (http->error);
 425   else
 426     return (EINVAL);
 427 }
 428
 429
 430 /*
 431  * 'httpFlush()' - Flush data from a HTTP connection.
 432  */
 433
 434 void
 435 httpFlush(http_t *http)                 /* I - HTTP connection */
 436 {
 437   char  buffer[8192];                   /* Junk buffer */
 438   int   blocking;                       /* To block or not to block */
 439
 440
 441   DEBUG_printf(("httpFlush(http=%p), state=%d\n", http, http->state));
 442
 443  /*
 444   * Temporarily set non-blocking mode so we don't get stuck in httpRead()...
 445   */
 446
 447   blocking = http->blocking;
 448   http->blocking = 0;
 449
 450  /*
 451   * Read any data we can...
 452   */
 453
 454   while (httpRead2(http, buffer, sizeof(buffer)) > 0);
 455
 456  /*
 457   * Restore blocking and reset the connection if we didn't get all of
 458   * the remaining data...
 459   */
 460
 461   http->blocking = blocking;
 462
 463   if (http->state != HTTP_WAITING && http->fd >= 0)
 464   {
 465    /*
 466     * Didn't get the data back, so close the current connection.
 467     */
 468
 469     http->state = HTTP_WAITING;
 470
 471 #ifdef HAVE_SSL
 472     if (http->tls)
 473       http_shutdown_ssl(http);
 474 #endif /* HAVE_SSL */
 475
 476 #ifdef WIN32
 477     closesocket(http->fd);
 478 #else
 479     close(http->fd);
 480 #endif /* WIN32 */
 481
 482     http->fd = -1;
 483   }
 484 }
 485
 486
 487 /*
 488  * 'httpFlushWrite()' - Flush data in write buffer.
 489  *
 490  * @since CUPS 1.2@
 491  */
 492
 493 int                                     /* O - Bytes written or -1 on error */
 494 httpFlushWrite(http_t *http)            /* I - HTTP connection */
 495 {
 496   int   bytes;                          /* Bytes written */
 497
 498
 499   DEBUG_printf(("httpFlushWrite(http=%p)\n", http));
 500
 501   if (!http || !http->wused)
 502     return (0);
 503
 504   if (http->data_encoding == HTTP_ENCODE_CHUNKED)
 505     bytes = http_write_chunk(http, http->wbuffer, http->wused);
 506   else
 507     bytes = http_write(http, http->wbuffer, http->wused);
 508
 509   http->wused = 0;
 510
 511   return (bytes);
 512 }
 513
 514
 515 /*
 516  * 'httpGet()' - Send a GET request to the server.
 517  */
 518
 519 int                                     /* O - Status of call (0 = success) */
 520 httpGet(http_t     *http,               /* I - HTTP connection */
 521         const char *uri)                /* I - URI to get */
 522 {
 523   return (http_send(http, HTTP_GET, uri));
 524 }
 525
 526
 527 /*
 528  * 'httpGetBlocking()' - Get the blocking/non-block state of a connection.
 529  *
 530  * @since CUPS 1.2@
 531  */
 532
 533 int                                     /* O - 1 if blocking, 0 if non-blocking */
 534 httpGetBlocking(http_t *http)           /* I - HTTP connection */
 535 {
 536   return (http ? http->blocking : 0);
 537 }
 538
 539
 540 /*
 541  * 'httpGetCookie()' - Get any cookie data from the response.
 542  */
 543
 544 const char *                            /* O - Cookie data or NULL */
 545 httpGetCookie(http_t *http)             /* I - HTTP connecion */
 546 {
 547   return (http ? http->cookie : NULL);
 548 }
 549
 550
 551 /*
 552  * 'httpGetFd()' - Get the file descriptor associated with a connection.
 553  *
 554  * @since CUPS 1.2@
 555  */
 556
 557 int                                     /* O - File descriptor or -1 if none */
 558 httpGetFd(http_t *http)                 /* I - HTTP connection */
 559 {
 560   return (http ? http->fd : -1);
 561 }
 562
 563
 564 /*
 565  * 'httpGetField()' - Get a field value from a request/response.
 566  */
 567
 568 const char *                            /* O - Field value */
 569 httpGetField(http_t       *http,        /* I - HTTP connection */
 570              http_field_t field)        /* I - Field to get */
 571 {
 572   if (!http || field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
 573     return (NULL);
 574   else
 575     return (http->fields[field]);
 576 }
 577
 578
 579 /*
 580  * 'httpGetLength()' - Get the amount of data remaining from the
 581  *                     content-length or transfer-encoding fields.
 582  *
 583  * This function is deprecated and will not return lengths larger than
 584  * 2^31 - 1; use httpGetLength2() instead.
 585  *
 586  * @deprecated@
 587  */
 588
 589 int                                     /* O - Content length */
 590 httpGetLength(http_t *http)             /* I - HTTP connection */
 591 {
 592  /*
 593   * Get the read content length and return the 32-bit value.
 594   */
 595
 596   if (http)
 597   {
 598     httpGetLength2(http);
 599
 600     return (http->_data_remaining);
 601   }
 602   else
 603     return (-1);
 604 }
 605
 606
 607 /*
 608  * 'httpGetLength2()' - Get the amount of data remaining from the
 609  *                      content-length or transfer-encoding fields.
 610  *
 611  * This function returns the complete content length, even for
 612  * content larger than 2^31 - 1.
 613  *
 614  * @since CUPS 1.2@
 615  */
 616
 617 off_t                                   /* O - Content length */
 618 httpGetLength2(http_t *http)            /* I - HTTP connection */
 619 {
 620   DEBUG_printf(("httpGetLength2(http=%p), state=%d\n", http, http->state));
 621
 622   if (!http)
 623     return (-1);
 624
 625   if (!strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked"))
 626   {
 627     DEBUG_puts("httpGetLength2: chunked request!");
 628
 629     http->data_encoding  = HTTP_ENCODE_CHUNKED;
 630     http->data_remaining = 0;
 631   }
 632   else
 633   {
 634     http->data_encoding = HTTP_ENCODE_LENGTH;
 635
 636    /*
 637     * The following is a hack for HTTP servers that don't send a
 638     * content-length or transfer-encoding field...
 639     *
 640     * If there is no content-length then the connection must close
 641     * after the transfer is complete...
 642     */
 643
 644     if (http->fields[HTTP_FIELD_CONTENT_LENGTH][0] == '\0')
 645       http->data_remaining = 2147483647;
 646     else
 647       http->data_remaining = strtoll(http->fields[HTTP_FIELD_CONTENT_LENGTH],
 648                                      NULL, 10);
 649
 650     DEBUG_printf(("httpGetLength2: content_length=" CUPS_LLFMT "\n",
 651                   CUPS_LLCAST http->data_remaining));
 652   }
 653
 654   if (http->data_remaining <= INT_MAX)
 655     http->_data_remaining = (int)http->data_remaining;
 656   else
 657     http->_data_remaining = INT_MAX;
 658
 659   return (http->data_remaining);
 660 }
 661
 662
 663 /*
 664  * 'httpGetStatus()' - Get the status of the last HTTP request.
 665  *
 666  * @since CUPS 1.2@
 667  */
 668
 669 http_status_t                           /* O - HTTP status */
 670 httpGetStatus(http_t *http)             /* I - HTTP connection */
 671 {
 672   return (http ? http->status : HTTP_ERROR);
 673 }
 674
 675
 676 /*
 677  * 'httpGetSubField()' - Get a sub-field value.
 678  *
 679  * @deprecated@
 680  */
 681
 682 char *                                  /* O - Value or NULL */
 683 httpGetSubField(http_t       *http,     /* I - HTTP connection */
 684                 http_field_t field,     /* I - Field index */
 685                 const char   *name,     /* I - Name of sub-field */
 686                 char         *value)    /* O - Value string */
 687 {
 688   return (httpGetSubField2(http, field, name, value, HTTP_MAX_VALUE));
 689 }
 690
 691
 692 /*
 693  * 'httpGetSubField2()' - Get a sub-field value.
 694  *
 695  * @since CUPS 1.2@
 696  */
 697
 698 char *                                  /* O - Value or NULL */
 699 httpGetSubField2(http_t       *http,    /* I - HTTP connection */
 700                  http_field_t field,    /* I - Field index */
 701                  const char   *name,    /* I - Name of sub-field */
 702                  char         *value,   /* O - Value string */
 703                  int          valuelen) /* I - Size of value buffer */
 704 {
 705   const char    *fptr;                  /* Pointer into field */
 706   char          temp[HTTP_MAX_VALUE],   /* Temporary buffer for name */
 707                 *ptr,                   /* Pointer into string buffer */
 708                 *end;                   /* End of value buffer */
 709
 710   DEBUG_printf(("httpGetSubField2(http=%p, field=%d, name=\"%s\", value=%p, valuelen=%d)\n",
 711                 http, field, name, value, valuelen));
 712
 713   if (!http || !name || !value || valuelen < 2 ||
 714       field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
 715     return (NULL);
 716
 717   end = value + valuelen - 1;
 718
 719   for (fptr = http->fields[field]; *fptr;)
 720   {
 721    /*
 722     * Skip leading whitespace...
 723     */
 724
 725     while (isspace(*fptr & 255))
 726       fptr ++;
 727
 728     if (*fptr == ',')
 729     {
 730       fptr ++;
 731       continue;
 732     }
 733
 734    /*
 735     * Get the sub-field name...
 736     */
 737
 738     for (ptr = temp;
 739          *fptr && *fptr != '=' && !isspace(*fptr & 255) &&
 740              ptr < (temp + sizeof(temp) - 1);
 741          *ptr++ = *fptr++);
 742
 743     *ptr = '\0';
 744
 745     DEBUG_printf(("httpGetSubField: name=\"%s\"\n", temp));
 746
 747    /*
 748     * Skip trailing chars up to the '='...
 749     */
 750
 751     while (isspace(*fptr & 255))
 752       fptr ++;
 753
 754     if (!*fptr)
 755       break;
 756
 757     if (*fptr != '=')
 758       continue;
 759
 760    /*
 761     * Skip = and leading whitespace...
 762     */
 763
 764     fptr ++;
 765
 766     while (isspace(*fptr & 255))
 767       fptr ++;
 768
 769     if (*fptr == '\"')
 770     {
 771      /*
 772       * Read quoted string...
 773       */
 774
 775       for (ptr = value, fptr ++;
 776            *fptr && *fptr != '\"' && ptr < end;
 777            *ptr++ = *fptr++);
 778
 779       *ptr = '\0';
 780
 781       while (*fptr && *fptr != '\"')
 782         fptr ++;
 783
 784       if (*fptr)
 785         fptr ++;
 786     }
 787     else
 788     {
 789      /*
 790       * Read unquoted string...
 791       */
 792
 793       for (ptr = value;
 794            *fptr && !isspace(*fptr & 255) && *fptr != ',' && ptr < end;
 795            *ptr++ = *fptr++);
 796
 797       *ptr = '\0';
 798
 799       while (*fptr && !isspace(*fptr & 255) && *fptr != ',')
 800         fptr ++;
 801     }
 802
 803     DEBUG_printf(("httpGetSubField: value=\"%s\"\n", value));
 804
 805    /*
 806     * See if this is the one...
 807     */
 808
 809     if (!strcmp(name, temp))
 810       return (value);
 811   }
 812
 813   value[0] = '\0';
 814
 815   return (NULL);
 816 }
 817
 818
 819 /*
 820  * 'httpGets()' - Get a line of text from a HTTP connection.
 821  */
 822
 823 char *                                  /* O - Line or NULL */
 824 httpGets(char   *line,                  /* I - Line to read into */
 825          int    length,                 /* I - Max length of buffer */
 826          http_t *http)                  /* I - HTTP connection */
 827 {
 828   char  *lineptr,                       /* Pointer into line */
 829         *lineend,                       /* End of line */
 830         *bufptr,                        /* Pointer into input buffer */
 831         *bufend;                        /* Pointer to end of buffer */
 832   int   bytes,                          /* Number of bytes read */
 833         eol;                            /* End-of-line? */
 834
 835
 836   DEBUG_printf(("httpGets(line=%p, length=%d, http=%p)\n", line, length, http));
 837
 838   if (http == NULL || line == NULL)
 839     return (NULL);
 840
 841  /*
 842   * Read a line from the buffer...
 843   */
 844
 845   lineptr = line;
 846   lineend = line + length - 1;
 847   eol     = 0;
 848
 849   while (lineptr < lineend)
 850   {
 851    /*
 852     * Pre-load the buffer as needed...
 853     */
 854
 855 #ifdef WIN32
 856     WSASetLastError(0);
 857 #else
 858     errno = 0;
 859 #endif /* WIN32 */
 860
 861     while (http->used == 0)
 862     {
 863      /*
 864       * No newline; see if there is more data to be read...
 865       */
 866
 867       if (!http->blocking && !http_wait(http, 1000))
 868         return (NULL);
 869
 870 #ifdef HAVE_SSL
 871       if (http->tls)
 872         bytes = http_read_ssl(http, http->buffer + http->used,
 873                               HTTP_MAX_BUFFER - http->used);
 874       else
 875 #endif /* HAVE_SSL */
 876         bytes = recv(http->fd, http->buffer + http->used,
 877                      HTTP_MAX_BUFFER - http->used, 0);
 878
 879       DEBUG_printf(("httpGets: read %d bytes...\n", bytes));
 880
 881       if (bytes < 0)
 882       {
 883        /*
 884         * Nope, can't get a line this time...
 885         */
 886
 887 #ifdef WIN32
 888         if (WSAGetLastError() != http->error)
 889         {
 890           http->error = WSAGetLastError();
 891           continue;
 892         }
 893
 894         DEBUG_printf(("httpGets: recv() error %d!\n", WSAGetLastError()));
 895 #else
 896         DEBUG_printf(("httpGets: recv() error %d!\n", errno));
 897
 898         if (errno == EINTR)
 899           continue;
 900         else if (errno != http->error)
 901         {
 902           http->error = errno;
 903           continue;
 904         }
 905 #endif /* WIN32 */
 906
 907         return (NULL);
 908       }
 909       else if (bytes == 0)
 910       {
 911         http->error = EPIPE;
 912
 913         return (NULL);
 914       }
 915
 916      /*
 917       * Yup, update the amount used...
 918       */
 919
 920       http->used += bytes;
 921     }
 922
 923    /*
 924     * Now copy as much of the current line as possible...
 925     */
 926
 927     for (bufptr = http->buffer, bufend = http->buffer + http->used;
 928          lineptr < lineend && bufptr < bufend;)
 929     {
 930       if (*bufptr == 0x0a)
 931       {
 932         eol = 1;
 933         bufptr ++;
 934         break;
 935       }
 936       else if (*bufptr == 0x0d)
 937         bufptr ++;
 938       else
 939         *lineptr++ = *bufptr++;
 940     }
 941
 942     http->used -= bufptr - http->buffer;
 943     if (http->used > 0)
 944       memmove(http->buffer, bufptr, http->used);
 945
 946     if (eol)
 947     {
 948      /*
 949       * End of line...
 950       */
 951
 952       http->activity = time(NULL);
 953
 954       *lineptr = '\0';
 955
 956       DEBUG_printf(("httpGets: Returning \"%s\"\n", line));
 957
 958       return (line);
 959     }
 960   }
 961
 962   DEBUG_puts("httpGets: No new line available!");
 963
 964   return (NULL);
 965 }
 966
 967
 968 /*
 969  * 'httpHead()' - Send a HEAD request to the server.
 970  */
 971
 972 int                                     /* O - Status of call (0 = success) */
 973 httpHead(http_t     *http,              /* I - HTTP connection */
 974          const char *uri)               /* I - URI for head */
 975 {
 976   return (http_send(http, HTTP_HEAD, uri));
 977 }
 978
 979
 980 /*
 981  * 'httpInitialize()' - Initialize the HTTP interface library and set the
 982  *                      default HTTP proxy (if any).
 983  */
 984
 985 void
 986 httpInitialize(void)
 987 {
 988 #ifdef HAVE_LIBSSL
 989 #  ifndef WIN32
 990   struct timeval        curtime;        /* Current time in microseconds */
 991 #  endif /* !WIN32 */
 992   int                   i;              /* Looping var */
 993   unsigned char         data[1024];     /* Seed data */
 994 #endif /* HAVE_LIBSSL */
 995
 996 #ifdef WIN32
 997   WSADATA       winsockdata;            /* WinSock data */
 998   static int    initialized = 0;        /* Has WinSock been initialized? */
 999
1000
1001   if (!initialized)
1002     WSAStartup(MAKEWORD(1,1), &winsockdata);
1003 #elif !defined(SO_NOSIGPIPE)
1004  /*
1005   * Ignore SIGPIPE signals...
1006   */
1007
1008 #  ifdef HAVE_SIGSET
1009   sigset(SIGPIPE, SIG_IGN);
1010 #  elif defined(HAVE_SIGACTION)
1011   struct sigaction      action;         /* POSIX sigaction data */
1012
1013
1014   memset(&action, 0, sizeof(action));
1015   action.sa_handler = SIG_IGN;
1016   sigaction(SIGPIPE, &action, NULL);
1017 #  else
1018   signal(SIGPIPE, SIG_IGN);
1019 #  endif /* !SO_NOSIGPIPE */
1020 #endif /* WIN32 */
1021
1022 #ifdef HAVE_GNUTLS
1023   gnutls_global_init();
1024 #endif /* HAVE_GNUTLS */
1025
1026 #ifdef HAVE_LIBSSL
1027   SSL_load_error_strings();
1028   SSL_library_init();
1029
1030  /*
1031   * Using the current time is a dubious random seed, but on some systems
1032   * it is the best we can do (on others, this seed isn't even used...)
1033   */
1034
1035 #ifdef WIN32
1036 #else
1037   gettimeofday(&curtime, NULL);
1038   srand(curtime.tv_sec + curtime.tv_usec);
1039 #endif /* WIN32 */
1040
1041   for (i = 0; i < sizeof(data); i ++)
1042     data[i] = rand(); /* Yes, this is a poor source of random data... */
1043
1044   RAND_seed(&data, sizeof(data));
1045 #endif /* HAVE_LIBSSL */
1046 }
1047
1048
1049 /*
1050  * 'httpOptions()' - Send an OPTIONS request to the server.
1051  */
1052
1053 int                                     /* O - Status of call (0 = success) */
1054 httpOptions(http_t     *http,           /* I - HTTP connection */
1055             const char *uri)            /* I - URI for options */
1056 {
1057   return (http_send(http, HTTP_OPTIONS, uri));
1058 }
1059
1060
1061 /*
1062  * 'httpPost()' - Send a POST request to the server.
1063  */
1064
1065 int                                     /* O - Status of call (0 = success) */
1066 httpPost(http_t     *http,              /* I - HTTP connection */
1067          const char *uri)               /* I - URI for post */
1068 {
1069   return (http_send(http, HTTP_POST, uri));
1070 }
1071
1072
1073 /*
1074  * 'httpPrintf()' - Print a formatted string to a HTTP connection.
1075  *
1076  * @private@
1077  */
1078
1079 int                                     /* O - Number of bytes written */
1080 httpPrintf(http_t     *http,            /* I - HTTP connection */
1081            const char *format,          /* I - printf-style format string */
1082            ...)                         /* I - Additional args as needed */
1083 {
1084   int           bytes;                  /* Number of bytes to write */
1085   char          buf[16384];             /* Buffer for formatted string */
1086   va_list       ap;                     /* Variable argument pointer */
1087
1088
1089   DEBUG_printf(("httpPrintf(http=%p, format=\"%s\", ...)\n", http, format));
1090
1091   va_start(ap, format);
1092   bytes = vsnprintf(buf, sizeof(buf), format, ap);
1093   va_end(ap);
1094
1095   DEBUG_printf(("httpPrintf: %s", buf));
1096
1097   if (http->wused)
1098   {
1099     DEBUG_puts("    flushing existing data...");
1100
1101     if (httpFlushWrite(http) < 0)
1102       return (-1);
1103   }
1104
1105   return (http_write(http, buf, bytes));
1106 }
1107
1108
1109 /*
1110  * 'httpPut()' - Send a PUT request to the server.
1111  */
1112
1113 int                                     /* O - Status of call (0 = success) */
1114 httpPut(http_t     *http,               /* I - HTTP connection */
1115         const char *uri)                /* I - URI to put */
1116 {
1117   return (http_send(http, HTTP_PUT, uri));
1118 }
1119
1120
1121 /*
1122  * 'httpRead()' - Read data from a HTTP connection.
1123  *
1124  * This function is deprecated. Use the httpRead2() function which can
1125  * read more than 2GB of data.
1126  *
1127  * @deprecated@
1128  */
1129
1130 int                                     /* O - Number of bytes read */
1131 httpRead(http_t *http,                  /* I - HTTP connection */
1132          char   *buffer,                /* I - Buffer for data */
1133          int    length)                 /* I - Maximum number of bytes */
1134 {
1135   return ((int)httpRead2(http, buffer, length));
1136 }
1137
1138
1139 /*
1140  * 'httpRead2()' - Read data from a HTTP connection.
1141  *
1142  * @since CUPS 1.2@
1143  */
1144
1145 ssize_t                                 /* O - Number of bytes read */
1146 httpRead2(http_t *http,                 /* I - HTTP connection */
1147           char   *buffer,               /* I - Buffer for data */
1148           size_t length)                /* I - Maximum number of bytes */
1149 {
1150   ssize_t       bytes;                  /* Bytes read */
1151   char          len[32];                /* Length string */
1152
1153
1154   DEBUG_printf(("httpRead(http=%p, buffer=%p, length=%d)\n",
1155                 http, buffer, length));
1156
1157   if (http == NULL || buffer == NULL)
1158     return (-1);
1159
1160   http->activity = time(NULL);
1161
1162   if (length <= 0)
1163     return (0);
1164
1165   if (http->data_encoding == HTTP_ENCODE_CHUNKED &&
1166       http->data_remaining <= 0)
1167   {
1168     DEBUG_puts("httpRead2: Getting chunk length...");
1169
1170     if (httpGets(len, sizeof(len), http) == NULL)
1171     {
1172       DEBUG_puts("httpRead2: Could not get length!");
1173       return (0);
1174     }
1175
1176     http->data_remaining = strtoll(len, NULL, 16);
1177     if (http->data_remaining < 0)
1178     {
1179       DEBUG_puts("httpRead2: Negative chunk length!");
1180       return (0);
1181     }
1182   }
1183
1184   DEBUG_printf(("httpRead2: data_remaining=" CUPS_LLFMT "\n",
1185                 CUPS_LLCAST http->data_remaining));
1186
1187   if (http->data_remaining <= 0)
1188   {
1189    /*
1190     * A zero-length chunk ends a transfer; unless we are reading POST
1191     * data, go idle...
1192     */
1193
1194     if (http->data_encoding == HTTP_ENCODE_CHUNKED)
1195       httpGets(len, sizeof(len), http);
1196
1197     if (http->state == HTTP_POST_RECV)
1198       http->state ++;
1199     else
1200       http->state = HTTP_WAITING;
1201
1202    /*
1203     * Prevent future reads for this request...
1204     */
1205
1206     http->data_encoding = HTTP_ENCODE_LENGTH;
1207
1208     return (0);
1209   }
1210   else if (length > http->data_remaining)
1211     length = http->data_remaining;
1212
1213   if (http->used == 0 && length <= 256)
1214   {
1215    /*
1216     * Buffer small reads for better performance...
1217     */
1218
1219     if (!http->blocking && !httpWait(http, 1000))
1220       return (0);
1221
1222     if (http->data_remaining > sizeof(http->buffer))
1223       bytes = sizeof(http->buffer);
1224     else
1225       bytes = http->data_remaining;
1226
1227 #ifdef HAVE_SSL
1228     if (http->tls)
1229       bytes = http_read_ssl(http, http->buffer, bytes);
1230     else
1231 #endif /* HAVE_SSL */
1232     {
1233       DEBUG_printf(("httpRead2: reading %d bytes from socket into buffer...\n",
1234                     bytes));
1235
1236       bytes = recv(http->fd, http->buffer, bytes, 0);
1237
1238       DEBUG_printf(("httpRead2: read %d bytes from socket into buffer...\n",
1239                     bytes));
1240     }
1241
1242     if (bytes > 0)
1243       http->used = bytes;
1244     else if (bytes < 0)
1245     {
1246 #ifdef WIN32
1247       http->error = WSAGetLastError();
1248       return (-1);
1249 #else
1250       if (errno != EINTR)
1251       {
1252         http->error = errno;
1253         return (-1);
1254       }
1255 #endif /* WIN32 */
1256     }
1257     else
1258     {
1259       http->error = EPIPE;
1260       return (0);
1261     }
1262   }
1263
1264   if (http->used > 0)
1265   {
1266     if (length > http->used)
1267       length = http->used;
1268
1269     bytes = length;
1270
1271     DEBUG_printf(("httpRead2: grabbing %d bytes from input buffer...\n", bytes));
1272
1273     memcpy(buffer, http->buffer, length);
1274     http->used -= length;
1275
1276     if (http->used > 0)
1277       memmove(http->buffer, http->buffer + length, http->used);
1278   }
1279 #ifdef HAVE_SSL
1280   else if (http->tls)
1281   {
1282     if (!http->blocking && !httpWait(http, 1000))
1283       return (0);
1284
1285     bytes = http_read_ssl(http, buffer, length);
1286   }
1287 #endif /* HAVE_SSL */
1288   else
1289   {
1290     if (!http->blocking && !httpWait(http, 1000))
1291       return (0);
1292
1293     DEBUG_printf(("httpRead2: reading %d bytes from socket...\n", length));
1294
1295     while ((bytes = recv(http->fd, buffer, length, 0)) < 0)
1296       if (errno != EINTR)
1297         break;
1298
1299     DEBUG_printf(("httpRead2: read %d bytes from socket...\n", bytes));
1300   }
1301
1302   if (bytes > 0)
1303   {
1304     http->data_remaining -= bytes;
1305
1306     if (http->data_remaining <= INT_MAX)
1307       http->_data_remaining = (int)http->data_remaining;
1308     else
1309       http->_data_remaining = INT_MAX;
1310   }
1311   else if (bytes < 0)
1312   {
1313 #ifdef WIN32
1314     http->error = WSAGetLastError();
1315 #else
1316     if (errno == EINTR)
1317       bytes = 0;
1318     else
1319       http->error = errno;
1320 #endif /* WIN32 */
1321   }
1322   else
1323   {
1324     http->error = EPIPE;
1325     return (0);
1326   }
1327
1328   if (http->data_remaining == 0)
1329   {
1330     if (http->data_encoding == HTTP_ENCODE_CHUNKED)
1331       httpGets(len, sizeof(len), http);
1332
1333     if (http->data_encoding != HTTP_ENCODE_CHUNKED)
1334     {
1335       if (http->state == HTTP_POST_RECV)
1336         http->state ++;
1337       else
1338         http->state = HTTP_WAITING;
1339     }
1340   }
1341
1342 #ifdef DEBUG
1343   {
1344     int i, j, ch;
1345     printf("httpRead2: Read %d bytes:\n", bytes);
1346     for (i = 0; i < bytes; i += 16)
1347     {
1348       printf("   ");
1349
1350       for (j = 0; j < 16 && (i + j) < bytes; j ++)
1351         printf(" %02X", buffer[i + j] & 255);
1352
1353       while (j < 16)
1354       {
1355         printf("   ");
1356         j ++;
1357       }
1358
1359       printf("    ");
1360       for (j = 0; j < 16 && (i + j) < bytes; j ++)
1361       {
1362         ch = buffer[i + j] & 255;
1363
1364         if (ch < ' ' || ch >= 127)
1365           ch = '.';
1366
1367         putchar(ch);
1368       }
1369       putchar('\n');
1370     }
1371   }
1372 #endif /* DEBUG */
1373
1374   return (bytes);
1375 }
1376
1377
1378 #if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
1379 /*
1380  * '_httpReadCDSA()' - Read function for CDSA decryption code.
1381  */
1382
1383 OSStatus                                /* O  - -1 on error, 0 on success */
1384 _httpReadCDSA(
1385     SSLConnectionRef connection,        /* I  - SSL/TLS connection */
1386     void             *data,             /* I  - Data buffer */
1387     size_t           *dataLength)       /* IO - Number of bytes */
1388 {
1389   OSStatus      result;                 /* Return value */
1390   ssize_t       bytes;                  /* Number of bytes read */
1391
1392
1393   for (;;)
1394   {
1395     bytes = recv((int)connection, data, *dataLength, 0);
1396
1397     if (bytes > 0)
1398     {
1399       result      = (bytes == *dataLength);
1400       *dataLength = bytes;
1401
1402       return (result);
1403     }
1404
1405     if (bytes == 0)
1406       return (errSSLClosedAbort);
1407
1408     if (errno == EAGAIN)
1409       return (errSSLWouldBlock);
1410
1411     if (errno == EPIPE)
1412       return (errSSLClosedAbort);
1413
1414     if (errno != EINTR)
1415       return (errSSLInternal);
1416   }
1417 }
1418 #endif /* HAVE_SSL && HAVE_CDSASSL */
1419
1420
1421 /*
1422  * 'httpReconnect()' - Reconnect to a HTTP server.
1423  */
1424
1425 int                                     /* O - 0 on success, non-zero on failure */
1426 httpReconnect(http_t *http)             /* I - HTTP connection */
1427 {
1428   http_addrlist_t       *addr;          /* Connected address */
1429
1430
1431   DEBUG_printf(("httpReconnect(http=%p)\n", http));
1432
1433   if (!http)
1434     return (-1);
1435
1436 #ifdef HAVE_SSL
1437   if (http->tls)
1438     http_shutdown_ssl(http);
1439 #endif /* HAVE_SSL */
1440
1441  /*
1442   * Close any previously open socket...
1443   */
1444
1445   if (http->fd >= 0)
1446   {
1447 #ifdef WIN32
1448     closesocket(http->fd);
1449 #else
1450     close(http->fd);
1451 #endif /* WIN32 */
1452
1453     http->fd = -1;
1454   }
1455
1456  /*
1457   * Connect to the server...
1458   */
1459
1460   if ((addr = httpAddrConnect(http->addrlist, &(http->fd))) == NULL)
1461   {
1462    /*
1463     * Unable to connect...
1464     */
1465
1466 #ifdef WIN32
1467     http->error  = WSAGetLastError();
1468 #else
1469     http->error  = errno;
1470 #endif /* WIN32 */
1471     http->status = HTTP_ERROR;
1472
1473     return (-1);
1474   }
1475
1476   http->hostaddr = &(addr->addr);
1477   http->error    = 0;
1478   http->status   = HTTP_CONTINUE;
1479
1480 #ifdef HAVE_SSL
1481   if (http->encryption == HTTP_ENCRYPT_ALWAYS)
1482   {
1483    /*
1484     * Always do encryption via SSL.
1485     */
1486
1487     if (http_setup_ssl(http) != 0)
1488     {
1489 #ifdef WIN32
1490       closesocket(http->fd);
1491 #else
1492       close(http->fd);
1493 #endif /* WIN32 */
1494
1495       return (-1);
1496     }
1497   }
1498   else if (http->encryption == HTTP_ENCRYPT_REQUIRED)
1499     return (http_upgrade(http));
1500 #endif /* HAVE_SSL */
1501
1502   return (0);
1503 }
1504
1505
1506 /*
1507  * 'httpSetCookie()' - Set the cookie value(s)...
1508  *
1509  * @since CUPS 1.1.19@
1510  */
1511
1512 void
1513 httpSetCookie(http_t     *http,         /* I - Connection */
1514               const char *cookie)       /* I - Cookie string */
1515 {
1516   if (!http)
1517     return;
1518
1519   if (http->cookie)
1520     free(http->cookie);
1521
1522   if (cookie)
1523     http->cookie = strdup(cookie);
1524   else
1525     http->cookie = NULL;
1526 }
1527
1528
1529 /*
1530  * 'httpSetExpect()' - Set the Expect: header in a request.
1531  *
1532  * Currently only HTTP_CONTINUE is supported for the "expect" argument.
1533  *
1534  * @since CUPS 1.2@
1535  */
1536
1537 void
1538 httpSetExpect(http_t        *http,      /* I - HTTP connection */
1539               http_status_t expect)     /* I - HTTP status to expect (HTTP_CONTINUE) */
1540 {
1541   if (http)
1542     http->expect = expect;
1543 }
1544
1545
1546 /*
1547  * 'httpSetField()' - Set the value of an HTTP header.
1548  */
1549
1550 void
1551 httpSetField(http_t       *http,        /* I - HTTP connection */
1552              http_field_t field,        /* I - Field index */
1553              const char   *value)       /* I - Value */
1554 {
1555   if (http == NULL ||
1556       field < HTTP_FIELD_ACCEPT_LANGUAGE ||
1557       field > HTTP_FIELD_WWW_AUTHENTICATE ||
1558       value == NULL)
1559     return;
1560
1561   strlcpy(http->fields[field], value, HTTP_MAX_VALUE);
1562 }
1563
1564
1565 /*
1566  * 'httpSetLength()' - Set the content-length and content-encoding.
1567  *
1568  * @since CUPS 1.2@
1569  */
1570
1571 void
1572 httpSetLength(http_t *http,             /* I - HTTP connection */
1573               size_t length)            /* I - Length (0 for chunked) */
1574 {
1575   if (!http)
1576     return;
1577
1578   if (!length)
1579   {
1580     strcpy(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked");
1581     http->fields[HTTP_FIELD_CONTENT_LENGTH][0] = '\0';
1582   }
1583   else
1584   {
1585     http->fields[HTTP_FIELD_TRANSFER_ENCODING][0] = '\0';
1586     snprintf(http->fields[HTTP_FIELD_CONTENT_LENGTH], HTTP_MAX_VALUE,
1587              CUPS_LLFMT, CUPS_LLCAST length);
1588   }
1589 }
1590
1591
1592 /*
1593  * 'httpTrace()' - Send an TRACE request to the server.
1594  */
1595
1596 int                                     /* O - Status of call (0 = success) */
1597 httpTrace(http_t     *http,             /* I - HTTP connection */
1598           const char *uri)              /* I - URI for trace */
1599 {
1600   return (http_send(http, HTTP_TRACE, uri));
1601 }
1602
1603
1604 /*
1605  * 'httpUpdate()' - Update the current HTTP state for incoming data.
1606  */
1607
1608 http_status_t                           /* O - HTTP status */
1609 httpUpdate(http_t *http)                /* I - HTTP connection */
1610 {
1611   char          line[32768],            /* Line from connection... */
1612                 *value;                 /* Pointer to value on line */
1613   http_field_t  field;                  /* Field index */
1614   int           major, minor,           /* HTTP version numbers */
1615                 status;                 /* Request status */
1616
1617
1618   DEBUG_printf(("httpUpdate(http=%p), state=%d\n", http, http->state));
1619
1620  /*
1621   * Flush pending data, if any...
1622   */
1623
1624   if (http->wused)
1625   {
1626     DEBUG_puts("    flushing buffer...");
1627
1628     if (httpFlushWrite(http) < 0)
1629       return (HTTP_ERROR);
1630   }
1631
1632  /*
1633   * If we haven't issued any commands, then there is nothing to "update"...
1634   */
1635
1636   if (http->state == HTTP_WAITING)
1637     return (HTTP_CONTINUE);
1638
1639  /*
1640   * Grab all of the lines we can from the connection...
1641   */
1642
1643   while (httpGets(line, sizeof(line), http) != NULL)
1644   {
1645     DEBUG_printf(("httpUpdate: Got \"%s\"\n", line));
1646
1647     if (line[0] == '\0')
1648     {
1649      /*
1650       * Blank line means the start of the data section (if any).  Return
1651       * the result code, too...
1652       *
1653       * If we get status 100 (HTTP_CONTINUE), then we *don't* change states.
1654       * Instead, we just return HTTP_CONTINUE to the caller and keep on
1655       * tryin'...
1656       */
1657
1658       if (http->status == HTTP_CONTINUE)
1659         return (http->status);
1660
1661       if (http->status < HTTP_BAD_REQUEST)
1662         http->digest_tries = 0;
1663
1664 #ifdef HAVE_SSL
1665       if (http->status == HTTP_SWITCHING_PROTOCOLS && !http->tls)
1666       {
1667         if (http_setup_ssl(http) != 0)
1668         {
1669 #  ifdef WIN32
1670           closesocket(http->fd);
1671 #  else
1672           close(http->fd);
1673 #  endif /* WIN32 */
1674
1675           return (HTTP_ERROR);
1676         }
1677
1678         return (HTTP_CONTINUE);
1679       }
1680 #endif /* HAVE_SSL */
1681
1682       httpGetLength2(http);
1683
1684       switch (http->state)
1685       {
1686         case HTTP_GET :
1687         case HTTP_POST :
1688         case HTTP_POST_RECV :
1689         case HTTP_PUT :
1690             http->state ++;
1691         case HTTP_POST_SEND :
1692             break;
1693
1694         default :
1695             http->state = HTTP_WAITING;
1696             break;
1697       }
1698
1699       return (http->status);
1700     }
1701     else if (strncmp(line, "HTTP/", 5) == 0)
1702     {
1703      /*
1704       * Got the beginning of a response...
1705       */
1706
1707       if (sscanf(line, "HTTP/%d.%d%d", &major, &minor, &status) != 3)
1708         return (HTTP_ERROR);
1709
1710       http->version = (http_version_t)(major * 100 + minor);
1711       http->status  = (http_status_t)status;
1712     }
1713     else if ((value = strchr(line, ':')) != NULL)
1714     {
1715      /*
1716       * Got a value...
1717       */
1718
1719       *value++ = '\0';
1720       while (isspace(*value & 255))
1721         value ++;
1722
1723      /*
1724       * Be tolerants of servers that send unknown attribute fields...
1725       */
1726
1727       if (!strcasecmp(line, "expect"))
1728       {
1729        /*
1730         * "Expect: 100-continue" or similar...
1731         */
1732
1733         http->expect = (http_status_t)atoi(value);
1734       }
1735       else if (!strcasecmp(line, "cookie"))
1736       {
1737        /*
1738         * "Cookie: name=value[; name=value ...]" - replaces previous cookies...
1739         */
1740
1741         httpSetCookie(http, value);
1742       }
1743       else if ((field = http_field(line)) == HTTP_FIELD_UNKNOWN)
1744       {
1745         DEBUG_printf(("httpUpdate: unknown field %s seen!\n", line));
1746         continue;
1747       }
1748       else
1749         httpSetField(http, field, value);
1750     }
1751     else
1752     {
1753       http->status = HTTP_ERROR;
1754       return (HTTP_ERROR);
1755     }
1756   }
1757
1758  /*
1759   * See if there was an error...
1760   */
1761
1762   if (http->error == EPIPE && http->status > HTTP_CONTINUE)
1763     return (http->status);
1764
1765   if (http->error)
1766   {
1767     DEBUG_printf(("httpUpdate: socket error %d - %s\n", http->error,
1768                   strerror(http->error)));
1769     http->status = HTTP_ERROR;
1770     return (HTTP_ERROR);
1771   }
1772
1773  /*
1774   * If we haven't already returned, then there is nothing new...
1775   */
1776
1777   return (HTTP_CONTINUE);
1778 }
1779
1780
1781 /*
1782  * 'httpWait()' - Wait for data available on a connection.
1783  *
1784  * @since CUPS 1.1.19@
1785  */
1786
1787 int                                     /* O - 1 if data is available, 0 otherwise */
1788 httpWait(http_t *http,                  /* I - HTTP connection */
1789          int    msec)                   /* I - Milliseconds to wait */
1790 {
1791  /*
1792   * First see if there is data in the buffer...
1793   */
1794
1795   if (http == NULL)
1796     return (0);
1797
1798   if (http->used)
1799     return (1);
1800
1801  /*
1802   * If not, check the SSL/TLS buffers and do a select() on the connection...
1803   */
1804
1805   return (http_wait(http, msec));
1806 }
1807
1808
1809 /*
1810  * 'httpWrite()' - Write data to a HTTP connection.
1811  *
1812  * This function is deprecated. Use the httpWrite2() function which can
1813  * write more than 2GB of data.
1814  *
1815  * @deprecated@
1816  */
1817
1818 int                                     /* O - Number of bytes written */
1819 httpWrite(http_t     *http,             /* I - HTTP connection */
1820           const char *buffer,           /* I - Buffer for data */
1821           int        length)            /* I - Number of bytes to write */
1822 {
1823   return ((int)httpWrite2(http, buffer, length));
1824 }
1825
1826
1827 /*
1828  * 'httpWrite2()' - Write data to a HTTP connection.
1829  *
1830  * @since CUPS 1.2@
1831  */
1832
1833 ssize_t                                 /* O - Number of bytes written */
1834 httpWrite2(http_t     *http,            /* I - HTTP connection */
1835            const char *buffer,          /* I - Buffer for data */
1836            size_t     length)           /* I - Number of bytes to write */
1837 {
1838   ssize_t       bytes;                  /* Bytes written */
1839
1840
1841   DEBUG_printf(("httpWrite(http=%p, buffer=%p, length=%d)\n", http,
1842                 buffer, length));
1843
1844  /*
1845   * Range check input...
1846   */
1847
1848   if (http == NULL || buffer == NULL)
1849     return (-1);
1850
1851  /*
1852   * Mark activity on the connection...
1853   */
1854
1855   http->activity = time(NULL);
1856
1857  /*
1858   * Buffer small writes for better performance...
1859   */
1860
1861   if (length > 0)
1862   {
1863     if (http->wused && (length + http->wused) > sizeof(http->wbuffer))
1864     {
1865       DEBUG_printf(("    flushing buffer (wused=%d, length=%d)\n",
1866                     http->wused, length));
1867
1868       httpFlushWrite(http);
1869     }
1870
1871     if ((length + http->wused) <= sizeof(http->wbuffer))
1872     {
1873      /*
1874       * Write to buffer...
1875       */
1876
1877       DEBUG_printf(("    copying %d bytes to wbuffer...\n", length));
1878
1879       memcpy(http->wbuffer + http->wused, buffer, length);
1880       http->wused += length;
1881       bytes = length;
1882     }
1883     else
1884     {
1885      /*
1886       * Otherwise write the data directly...
1887       */
1888
1889       DEBUG_printf(("    writing %d bytes to socket...\n", length));
1890
1891       if (http->data_encoding == HTTP_ENCODE_CHUNKED)
1892         bytes = http_write_chunk(http, buffer, length);
1893       else
1894         bytes = http_write(http, buffer, length);
1895
1896       DEBUG_printf(("    wrote %d bytes...\n", bytes));
1897     }
1898
1899     if (http->data_encoding == HTTP_ENCODE_LENGTH)
1900       http->data_remaining -= bytes;
1901   }
1902   else
1903     bytes = 0;
1904
1905  /*
1906   * Handle end-of-request processing...
1907   */
1908
1909   if ((http->data_encoding == HTTP_ENCODE_CHUNKED && length == 0) ||
1910       (http->data_encoding == HTTP_ENCODE_LENGTH && http->data_remaining == 0))
1911   {
1912    /*
1913     * Finished with the transfer; unless we are sending POST or PUT
1914     * data, go idle...
1915     */
1916
1917     DEBUG_puts("httpWrite: changing states...");
1918
1919     if (http->wused)
1920       httpFlushWrite(http);
1921
1922     if (http->data_encoding == HTTP_ENCODE_CHUNKED)
1923     {
1924      /*
1925       * Send a 0-length chunk at the end of the request...
1926       */
1927
1928       http_write(http, "0\r\n\r\n", 5);
1929
1930      /*
1931       * Reset the data state...
1932       */
1933
1934       http->data_encoding  = HTTP_ENCODE_LENGTH;
1935       http->data_remaining = 0;
1936     }
1937
1938     if (http->state == HTTP_POST_RECV)
1939       http->state ++;
1940     else if (http->state == HTTP_PUT_RECV)
1941       http->state = HTTP_STATUS;
1942     else
1943       http->state = HTTP_WAITING;
1944   }
1945
1946   return (bytes);
1947 }
1948
1949
1950 #if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
1951 /*
1952  * '_httpWriteCDSA()' - Write function for CDSA encryption code.
1953  */
1954
1955 OSStatus                                /* O  - -1 on error, 0 on success */
1956 _httpWriteCDSA(
1957     SSLConnectionRef connection,        /* I  - SSL/TLS connection */
1958     const void       *data,             /* I  - Data buffer */
1959     size_t           *dataLength)       /* IO - Number of bytes */
1960 {
1961   OSStatus      result;                 /* Return value */
1962   ssize_t       bytes;                  /* Number of bytes read */
1963
1964
1965   for (;;)
1966   {
1967     bytes = write((int)connection, data, *dataLength);
1968
1969     if (bytes >= 0)
1970     {
1971       result      = (bytes == *dataLength) ? 0 : errSSLWouldBlock;
1972       *dataLength = bytes;
1973
1974       return (result);
1975     }
1976
1977     if (errno == EAGAIN)
1978       return (errSSLWouldBlock);
1979
1980     if (errno == EPIPE)
1981       return (errSSLClosedAbort);
1982
1983     if (errno != EINTR)
1984       return (errSSLInternal);
1985   }
1986 }
1987 #endif /* HAVE_SSL && HAVE_CDSASSL */
1988
1989
1990 /*
1991  * 'http_field()' - Return the field index for a field name.
1992  */
1993
1994 static http_field_t             /* O - Field index */
1995 http_field(const char *name)    /* I - String name */
1996 {
1997   int   i;                      /* Looping var */
1998
1999
2000   for (i = 0; i < HTTP_FIELD_MAX; i ++)
2001     if (strcasecmp(name, http_fields[i]) == 0)
2002       return ((http_field_t)i);
2003
2004   return (HTTP_FIELD_UNKNOWN);
2005 }
2006
2007
2008 #ifdef HAVE_SSL
2009 /*
2010  * 'http_read_ssl()' - Read from a SSL/TLS connection.
2011  */
2012
2013 static int                              /* O - Bytes read */
2014 http_read_ssl(http_t *http,             /* I - HTTP connection */
2015               char   *buf,              /* I - Buffer to store data */
2016               int    len)               /* I - Length of buffer */
2017 {
2018 #  if defined(HAVE_LIBSSL)
2019   return (SSL_read((SSL *)(http->tls), buf, len));
2020
2021 #  elif defined(HAVE_GNUTLS)
2022   return (gnutls_record_recv(((http_tls_t *)(http->tls))->session, buf, len));
2023
2024 #  elif defined(HAVE_CDSASSL)
2025   int           result;                 /* Return value */
2026   OSStatus      error;                  /* Error info */
2027   size_t        processed;              /* Number of bytes processed */
2028
2029
2030   error = SSLRead((SSLContextRef)http->tls, buf, len, &processed);
2031
2032   switch (error)
2033   {
2034     case 0 :
2035         result = (int)processed;
2036         break;
2037     case errSSLClosedGraceful :
2038         result = 0;
2039         break;
2040     case errSSLWouldBlock :
2041         errno = EAGAIN;
2042         result = -1;
2043         break;
2044     default :
2045         errno = EPIPE;
2046         result = -1;
2047         break;
2048   }
2049
2050   return (result);
2051 #  endif /* HAVE_LIBSSL */
2052 }
2053 #endif /* HAVE_SSL */
2054
2055
2056 /*
2057  * 'http_send()' - Send a request with all fields and the trailing blank line.
2058  */
2059
2060 static int                      /* O - 0 on success, non-zero on error */
2061 http_send(http_t       *http,   /* I - HTTP connection */
2062           http_state_t request, /* I - Request code */
2063           const char   *uri)    /* I - URI */
2064 {
2065   int           i;              /* Looping var */
2066   char          *ptr,           /* Pointer in buffer */
2067                 buf[1024];      /* Encoded URI buffer */
2068   static const char * const codes[] =
2069                 {               /* Request code strings */
2070                   NULL,
2071                   "OPTIONS",
2072                   "GET",
2073                   NULL,
2074                   "HEAD",
2075                   "POST",
2076                   NULL,
2077                   NULL,
2078                   "PUT",
2079                   NULL,
2080                   "DELETE",
2081                   "TRACE",
2082                   "CLOSE"
2083                 };
2084   static const char hex[] = "0123456789ABCDEF";
2085                                 /* Hex digits */
2086
2087
2088   DEBUG_printf(("http_send(http=%p, request=HTTP_%s, uri=\"%s\")\n",
2089                 http, codes[request], uri));
2090
2091   if (http == NULL || uri == NULL)
2092     return (-1);
2093
2094  /*
2095   * Set the User-Agent field if it isn't already...
2096   */
2097
2098   if (!http->fields[HTTP_FIELD_USER_AGENT][0])
2099     httpSetField(http, HTTP_FIELD_USER_AGENT, CUPS_MINIMAL);
2100
2101  /*
2102   * Encode the URI as needed...
2103   */
2104
2105   for (ptr = buf; *uri != '\0' && ptr < (buf + sizeof(buf) - 1); uri ++)
2106     if (*uri <= ' ' || *uri >= 127)
2107     {
2108       if (ptr < (buf + sizeof(buf) - 1))
2109         *ptr ++ = '%';
2110       if (ptr < (buf + sizeof(buf) - 1))
2111         *ptr ++ = hex[(*uri >> 4) & 15];
2112       if (ptr < (buf + sizeof(buf) - 1))
2113         *ptr ++ = hex[*uri & 15];
2114     }
2115     else
2116       *ptr ++ = *uri;
2117
2118   *ptr = '\0';
2119
2120  /*
2121   * See if we had an error the last time around; if so, reconnect...
2122   */
2123
2124   if (http->status == HTTP_ERROR || http->status >= HTTP_BAD_REQUEST)
2125     if (httpReconnect(http))
2126       return (-1);
2127
2128  /*
2129   * Send the request header...
2130   */
2131
2132   http->state = request;
2133   if (request == HTTP_POST || request == HTTP_PUT)
2134     http->state ++;
2135
2136   http->status = HTTP_CONTINUE;
2137
2138 #ifdef HAVE_SSL
2139   if (http->encryption == HTTP_ENCRYPT_REQUIRED && !http->tls)
2140   {
2141     httpSetField(http, HTTP_FIELD_CONNECTION, "Upgrade");
2142     httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.0,SSL/2.0,SSL/3.0");
2143   }
2144 #endif /* HAVE_SSL */
2145
2146   if (httpPrintf(http, "%s %s HTTP/1.1\r\n", codes[request], buf) < 1)
2147   {
2148     http->status = HTTP_ERROR;
2149     return (-1);
2150   }
2151
2152   for (i = 0; i < HTTP_FIELD_MAX; i ++)
2153     if (http->fields[i][0] != '\0')
2154     {
2155       DEBUG_printf(("%s: %s\n", http_fields[i], http->fields[i]));
2156
2157       if (httpPrintf(http, "%s: %s\r\n", http_fields[i], http->fields[i]) < 1)
2158       {
2159         http->status = HTTP_ERROR;
2160         return (-1);
2161       }
2162     }
2163
2164   if (http->cookie)
2165     if (httpPrintf(http, "Cookie: $Version=0; %s\r\n", http->cookie) < 1)
2166     {
2167       http->status = HTTP_ERROR;
2168       return (-1);
2169     }
2170
2171   if (http->expect == HTTP_CONTINUE &&
2172       (http->state == HTTP_POST_RECV || http->state == HTTP_PUT_RECV))
2173     if (httpPrintf(http, "Expect: 100-continue\r\n") < 1)
2174     {
2175       http->status = HTTP_ERROR;
2176       return (-1);
2177     }
2178
2179   if (httpPrintf(http, "\r\n") < 1)
2180   {
2181     http->status = HTTP_ERROR;
2182     return (-1);
2183   }
2184
2185   httpGetLength2(http);
2186   httpClearFields(http);
2187
2188   return (0);
2189 }
2190
2191
2192 #ifdef HAVE_SSL
2193 /*
2194  * 'http_setup_ssl()' - Set up SSL/TLS support on a connection.
2195  */
2196
2197 static int                              /* O - Status of connection */
2198 http_setup_ssl(http_t *http)            /* I - HTTP connection */
2199 {
2200 #  ifdef HAVE_LIBSSL
2201   SSL_CTX       *context;       /* Context for encryption */
2202   SSL           *conn;          /* Connection for encryption */
2203 #  elif defined(HAVE_GNUTLS)
2204   http_tls_t    *conn;          /* TLS session object */
2205   gnutls_certificate_client_credentials *credentials;
2206                                 /* TLS credentials */
2207 #  elif defined(HAVE_CDSASSL)
2208   SSLContextRef conn;           /* Context for encryption */
2209   OSStatus      error;          /* Error info */
2210 #  endif /* HAVE_LIBSSL */
2211
2212
2213   DEBUG_printf(("http_setup_ssl(http=%p)\n", http));
2214
2215 #  ifdef HAVE_LIBSSL
2216   context = SSL_CTX_new(SSLv23_client_method());
2217
2218   SSL_CTX_set_options(context, SSL_OP_NO_SSLv2); /* Only use SSLv3 or TLS */
2219
2220   conn = SSL_new(context);
2221
2222   SSL_set_fd(conn, http->fd);
2223   if (SSL_connect(conn) != 1)
2224   {
2225 #    ifdef DEBUG
2226     unsigned long       error;  /* Error code */
2227
2228     while ((error = ERR_get_error()) != 0)
2229       printf("http_setup_ssl: %s\n", ERR_error_string(error, NULL));
2230 #    endif /* DEBUG */
2231
2232     SSL_CTX_free(context);
2233     SSL_free(conn);
2234
2235 #    ifdef WIN32
2236     http->error  = WSAGetLastError();
2237 #    else
2238     http->error  = errno;
2239 #    endif /* WIN32 */
2240     http->status = HTTP_ERROR;
2241
2242     return (HTTP_ERROR);
2243   }
2244
2245 #  elif defined(HAVE_GNUTLS)
2246   conn = (http_tls_t *)malloc(sizeof(http_tls_t));
2247
2248   if (conn == NULL)
2249   {
2250     http->error  = errno;
2251     http->status = HTTP_ERROR;
2252
2253     return (-1);
2254   }
2255
2256   credentials = (gnutls_certificate_client_credentials *)
2257                     malloc(sizeof(gnutls_certificate_client_credentials));
2258   if (credentials == NULL)
2259   {
2260     free(conn);
2261
2262     http->error = errno;
2263     http->status = HTTP_ERROR;
2264
2265     return (-1);
2266   }
2267
2268   gnutls_certificate_allocate_credentials(credentials);
2269
2270   gnutls_init(&(conn->session), GNUTLS_CLIENT);
2271   gnutls_set_default_priority(conn->session);
2272   gnutls_credentials_set(conn->session, GNUTLS_CRD_CERTIFICATE, *credentials);
2273   gnutls_transport_set_ptr(conn->session, http->fd);
2274
2275   if ((gnutls_handshake(conn->session)) != GNUTLS_E_SUCCESS)
2276   {
2277     http->error  = errno;
2278     http->status = HTTP_ERROR;
2279
2280     return (-1);
2281   }
2282
2283   conn->credentials = credentials;
2284
2285 #  elif defined(HAVE_CDSASSL)
2286   error = SSLNewContext(false, &conn);
2287
2288   if (!error)
2289     error = SSLSetIOFuncs(conn, _httpReadCDSA, _httpWriteCDSA);
2290
2291   if (!error)
2292     error = SSLSetConnection(conn, (SSLConnectionRef)http->fd);
2293
2294   if (!error)
2295     error = SSLSetAllowsExpiredCerts(conn, true);
2296
2297   if (!error)
2298     error = SSLSetAllowsAnyRoot(conn, true);
2299
2300   if (!error)
2301     error = SSLHandshake(conn);
2302
2303   if (error != 0)
2304   {
2305     http->error  = error;
2306     http->status = HTTP_ERROR;
2307
2308     SSLDisposeContext(conn);
2309
2310     close(http->fd);
2311
2312     return (-1);
2313   }
2314 #  endif /* HAVE_CDSASSL */
2315
2316   http->tls = conn;
2317   return (0);
2318 }
2319 #endif /* HAVE_SSL */
2320
2321
2322 #ifdef HAVE_SSL
2323 /*
2324  * 'http_shutdown_ssl()' - Shut down SSL/TLS on a connection.
2325  */
2326
2327 static void
2328 http_shutdown_ssl(http_t *http) /* I - HTTP connection */
2329 {
2330 #  ifdef HAVE_LIBSSL
2331   SSL_CTX       *context;       /* Context for encryption */
2332   SSL           *conn;          /* Connection for encryption */
2333
2334
2335   conn    = (SSL *)(http->tls);
2336   context = SSL_get_SSL_CTX(conn);
2337
2338   SSL_shutdown(conn);
2339   SSL_CTX_free(context);
2340   SSL_free(conn);
2341
2342 #  elif defined(HAVE_GNUTLS)
2343   http_tls_t      *conn;        /* Encryption session */
2344   gnutls_certificate_client_credentials *credentials;
2345                                 /* TLS credentials */
2346
2347
2348   conn = (http_tls_t *)(http->tls);
2349   credentials = (gnutls_certificate_client_credentials *)(conn->credentials);
2350
2351   gnutls_bye(conn->session, GNUTLS_SHUT_RDWR);
2352   gnutls_deinit(conn->session);
2353   gnutls_certificate_free_credentials(*credentials);
2354   free(credentials);
2355   free(conn);
2356
2357 #  elif defined(HAVE_CDSASSL)
2358   SSLClose((SSLContextRef)http->tls);
2359   SSLDisposeContext((SSLContextRef)http->tls);
2360 #  endif /* HAVE_LIBSSL */
2361
2362   http->tls = NULL;
2363 }
2364 #endif /* HAVE_SSL */
2365
2366
2367 #ifdef HAVE_SSL
2368 /*
2369  * 'http_upgrade()' - Force upgrade to TLS encryption.
2370  */
2371
2372 static int                      /* O - Status of connection */
2373 http_upgrade(http_t *http)      /* I - HTTP connection */
2374 {
2375   int           ret;            /* Return value */
2376   http_t        myhttp;         /* Local copy of HTTP data */
2377
2378
2379   DEBUG_printf(("http_upgrade(%p)\n", http));
2380
2381  /*
2382   * Copy the HTTP data to a local variable so we can do the OPTIONS
2383   * request without interfering with the existing request data...
2384   */
2385
2386   memcpy(&myhttp, http, sizeof(myhttp));
2387
2388  /*
2389   * Send an OPTIONS request to the server, requiring SSL or TLS
2390   * encryption on the link...
2391   */
2392
2393   httpClearFields(&myhttp);
2394   httpSetField(&myhttp, HTTP_FIELD_CONNECTION, "upgrade");
2395   httpSetField(&myhttp, HTTP_FIELD_UPGRADE, "TLS/1.0, SSL/2.0, SSL/3.0");
2396
2397   if ((ret = httpOptions(&myhttp, "*")) == 0)
2398   {
2399    /*
2400     * Wait for the secure connection...
2401     */
2402
2403     while (httpUpdate(&myhttp) == HTTP_CONTINUE);
2404   }
2405
2406   httpFlush(&myhttp);
2407
2408  /*
2409   * Copy the HTTP data back over, if any...
2410   */
2411
2412   http->fd         = myhttp.fd;
2413   http->error      = myhttp.error;
2414   http->activity   = myhttp.activity;
2415   http->status     = myhttp.status;
2416   http->version    = myhttp.version;
2417   http->keep_alive = myhttp.keep_alive;
2418   http->used       = myhttp.used;
2419
2420   if (http->used)
2421     memcpy(http->buffer, myhttp.buffer, http->used);
2422
2423   http->auth_type   = myhttp.auth_type;
2424   http->nonce_count = myhttp.nonce_count;
2425
2426   memcpy(http->nonce, myhttp.nonce, sizeof(http->nonce));
2427
2428   http->tls        = myhttp.tls;
2429   http->encryption = myhttp.encryption;
2430
2431  /*
2432   * See if we actually went secure...
2433   */
2434
2435   if (!http->tls)
2436   {
2437    /*
2438     * Server does not support HTTP upgrade...
2439     */
2440
2441     DEBUG_puts("Server does not support HTTP upgrade!");
2442
2443 #  ifdef WIN32
2444     closesocket(http->fd);
2445 #  else
2446     close(http->fd);
2447 #  endif
2448
2449     http->fd = -1;
2450
2451     return (-1);
2452   }
2453   else
2454     return (ret);
2455 }
2456 #endif /* HAVE_SSL */
2457
2458
2459 /*
2460  * 'http_wait()' - Wait for data available on a connection.
2461  */
2462
2463 static int                              /* O - 1 if data is available, 0 otherwise */
2464 http_wait(http_t *http,                 /* I - HTTP connection */
2465           int    msec)                  /* I - Milliseconds to wait */
2466 {
2467 #ifndef WIN32
2468   struct rlimit         limit;          /* Runtime limit */
2469   int                   set_size;       /* Size of select set */
2470 #endif /* !WIN32 */
2471   struct timeval        timeout;        /* Timeout */
2472   int                   nfds;           /* Result from select() */
2473
2474
2475   DEBUG_printf(("http_wait(http=%p, msec=%d)\n", http, msec));
2476
2477   if (http->fd < 0)
2478     return (0);
2479
2480  /*
2481   * Check the SSL/TLS buffers for data first...
2482   */
2483
2484 #ifdef HAVE_SSL
2485   if (http->tls)
2486   {
2487 #  ifdef HAVE_LIBSSL
2488     if (SSL_pending((SSL *)(http->tls)))
2489       return (1);
2490 #  elif defined(HAVE_GNUTLS)
2491     if (gnutls_record_check_pending(((http_tls_t *)(http->tls))->session))
2492       return (1);
2493 #  elif defined(HAVE_CDSASSL)
2494     size_t bytes;                       /* Bytes that are available */
2495
2496     if (!SSLGetBufferedReadSize((SSLContextRef)http->tls, &bytes) && bytes > 0)
2497       return (1);
2498 #  endif /* HAVE_LIBSSL */
2499   }
2500 #endif /* HAVE_SSL */
2501
2502  /*
2503   * Then try doing a select() to poll the socket...
2504   */
2505
2506   if (!http->input_set)
2507   {
2508 #ifdef WIN32
2509    /*
2510     * Windows has a fixed-size select() structure, different (surprise,
2511     * surprise!) from all UNIX implementations.  Just allocate this
2512     * fixed structure...
2513     */
2514
2515     http->input_set = calloc(1, sizeof(fd_set));
2516 #else
2517    /*
2518     * Allocate the select() input set based upon the max number of file
2519     * descriptors available for this process...
2520     */
2521
2522     getrlimit(RLIMIT_NOFILE, &limit);
2523
2524     set_size = (limit.rlim_cur + 31) / 8 + 4;
2525     if (set_size < sizeof(fd_set))
2526       set_size = sizeof(fd_set);
2527
2528     http->input_set = calloc(1, set_size);
2529 #endif /* WIN32 */
2530
2531     if (!http->input_set)
2532       return (0);
2533   }
2534
2535   do
2536   {
2537     FD_SET(http->fd, http->input_set);
2538
2539     if (msec >= 0)
2540     {
2541       timeout.tv_sec  = msec / 1000;
2542       timeout.tv_usec = (msec % 1000) * 1000;
2543
2544       nfds = select(http->fd + 1, http->input_set, NULL, NULL, &timeout);
2545     }
2546     else
2547       nfds = select(http->fd + 1, http->input_set, NULL, NULL, NULL);
2548   }
2549 #ifdef WIN32
2550   while (nfds < 0 && WSAGetLastError() == WSAEINTR);
2551 #else
2552   while (nfds < 0 && errno == EINTR);
2553 #endif /* WIN32 */
2554
2555   FD_CLR(http->fd, http->input_set);
2556
2557   return (nfds > 0);
2558 }
2559
2560
2561 /*
2562  * 'http_write()' - Write a buffer to a HTTP connection.
2563  */
2564
2565 static int                              /* O - Number of bytes written */
2566 http_write(http_t     *http,            /* I - HTTP connection */
2567           const char *buffer,           /* I - Buffer for data */
2568           int        length)            /* I - Number of bytes to write */
2569 {
2570   int   tbytes,                         /* Total bytes sent */
2571         bytes;                          /* Bytes sent */
2572
2573
2574   tbytes = 0;
2575
2576   while (length > 0)
2577   {
2578 #ifdef HAVE_SSL
2579     if (http->tls)
2580       bytes = http_write_ssl(http, buffer, length);
2581     else
2582 #endif /* HAVE_SSL */
2583     bytes = send(http->fd, buffer, length, 0);
2584
2585     if (bytes < 0)
2586     {
2587 #ifdef WIN32
2588       if (WSAGetLastError() != http->error)
2589       {
2590         http->error = WSAGetLastError();
2591         continue;
2592       }
2593 #else
2594       if (errno == EINTR)
2595         continue;
2596       else if (errno != http->error && errno != ECONNRESET)
2597       {
2598         http->error = errno;
2599         continue;
2600       }
2601 #endif /* WIN32 */
2602
2603       DEBUG_puts("http_write: error writing data...\n");
2604
2605       return (-1);
2606     }
2607
2608     buffer += bytes;
2609     tbytes += bytes;
2610     length -= bytes;
2611   }
2612
2613 #ifdef DEBUG
2614   {
2615     int i, j, ch;
2616     printf("http_write: wrote %d bytes: \n", tbytes);
2617     for (i = 0, buffer -= tbytes; i < tbytes; i += 16)
2618     {
2619       printf("   ");
2620
2621       for (j = 0; j < 16 && (i + j) < tbytes; j ++)
2622         printf(" %02X", buffer[i + j] & 255);
2623
2624       while (j < 16)
2625       {
2626         printf("   ");
2627         j ++;
2628       }
2629
2630       printf("    ");
2631       for (j = 0; j < 16 && (i + j) < tbytes; j ++)
2632       {
2633         ch = buffer[i + j] & 255;
2634
2635         if (ch < ' ' || ch == 127)
2636           ch = '.';
2637
2638         putchar(ch);
2639       }
2640       putchar('\n');
2641     }
2642   }
2643 #endif /* DEBUG */
2644
2645   return (tbytes);
2646 }
2647
2648
2649 /*
2650  * 'http_write_chunk()' - Write a chunked buffer.
2651  */
2652
2653 static int                              /* O - Number bytes written */
2654 http_write_chunk(http_t     *http,      /* I - HTTP connection */
2655                  const char *buffer,    /* I - Buffer to write */
2656                  int        length)     /* I - Length of buffer */
2657 {
2658   char  header[255];                    /* Chunk header */
2659   int   bytes;                          /* Bytes written */
2660
2661   DEBUG_printf(("http_write_chunk(http=%p, buffer=%p, length=%d)\n",
2662                 http, buffer, length));
2663
2664  /*
2665   * Write the chunk header, data, and trailer.
2666   */
2667
2668   sprintf(header, "%x\r\n", length);
2669   if (http_write(http, header, strlen(header)) < 0)
2670   {
2671     DEBUG_puts("    http_write of length failed!");
2672     return (-1);
2673   }
2674
2675   if ((bytes = http_write(http, buffer, length)) < 0)
2676   {
2677     DEBUG_puts("    http_write of buffer failed!");
2678     return (-1);
2679   }
2680
2681   if (http_write(http, "\r\n", 2) < 0)
2682   {
2683     DEBUG_puts("    http_write of CR LF failed!");
2684     return (-1);
2685   }
2686
2687   return (bytes);
2688 }
2689
2690
2691 #ifdef HAVE_SSL
2692 /*
2693  * 'http_write_ssl()' - Write to a SSL/TLS connection.
2694  */
2695
2696 static int                              /* O - Bytes written */
2697 http_write_ssl(http_t     *http,        /* I - HTTP connection */
2698                const char *buf,         /* I - Buffer holding data */
2699                int        len)          /* I - Length of buffer */
2700 {
2701 #  if defined(HAVE_LIBSSL)
2702   return (SSL_write((SSL *)(http->tls), buf, len));
2703
2704 #  elif defined(HAVE_GNUTLS)
2705   return (gnutls_record_send(((http_tls_t *)(http->tls))->session, buf, len));
2706 #  elif defined(HAVE_CDSASSL)
2707   int           result;                 /* Return value */
2708   OSStatus      error;                  /* Error info */
2709   size_t        processed;              /* Number of bytes processed */
2710
2711
2712   error = SSLWrite((SSLContextRef)http->tls, buf, len, &processed);
2713
2714   switch (error)
2715   {
2716     case 0 :
2717         result = (int)processed;
2718         break;
2719     case errSSLClosedGraceful :
2720         result = 0;
2721         break;
2722     case errSSLWouldBlock :
2723         errno = EAGAIN;
2724         result = -1;
2725         break;
2726     default :
2727         errno = EPIPE;
2728         result = -1;
2729         break;
2730   }
2731
2732   return (result);
2733 #  endif /* HAVE_LIBSSL */
2734 }
2735 #endif /* HAVE_SSL */
2736
2737
2738 /*
2739  * End of "$Id$".
2740  */