//

// HTTP routines for CUPS.

//

// Copyright © 2022-2025 by OpenPrinting.

// Copyright © 2007-2021 by Apple Inc.

// Copyright © 1997-2007 by Easy Software Products, all rights reserved.

//

// This file contains Kerberos support code, copyright 2006 by

// Jelmer Vernooij.

//

// Licensed under Apache License v2.0.  See the file "LICENSE" for more

// information.

//

#include "cups-private.h"

#include <fcntl.h>

#include <math.h>

#ifdef _WIN32

#  include <tchar.h>

#else

#  include <poll.h>

#  include <signal.h>

#  include <sys/time.h>

#  include <sys/resource.h>

#endif // _WIN32

#include <zlib.h>

//

// Local functions...

//

static void   http_add_field(http_t *http, http_field_t field, const char *value, bool append);

static void   http_content_coding_finish(http_t *http);

static void   http_content_coding_start(http_t *http, const char *value);

static http_t   *http_create(const char *host, int port, http_addrlist_t *addrlist, int family, http_encryption_t encryption, int blocking, _http_mode_t mode);

#ifdef DEBUG

static void   http_debug_hex(const char *prefix, const char *buffer, int bytes);

#endif // DEBUG

static ssize_t    http_read(http_t *http, char *buffer, size_t length, int timeout);

static ssize_t    http_read_buffered(http_t *http, char *buffer, size_t length);

static ssize_t    http_read_chunk(http_t *http, char *buffer, size_t length);

static bool   http_send(http_t *http, http_state_t request, const char *uri);

static ssize_t    http_write(http_t *http, const char *buffer, size_t length);

static ssize_t    http_write_chunk(http_t *http, const char *buffer, size_t length);

static off_t    http_set_length(http_t *http);

static void   http_set_timeout(int fd, double timeout);

static void   http_set_wait(http_t *http);

static bool   http_tls_upgrade(http_t *http);

//

// Local globals...

//

static const char * const http_fields[] =

      {

        "Accept-Language",

        "Accept-Ranges",

        "Authorization",

        "Connection",

        "Content-Encoding",

        "Content-Language",

        "Content-Length",

        "Content-Location",

        "Content-MD5",

        "Content-Range",

        "Content-Type",

        "Content-Version",

        "Date",

        "Host",

        "If-Modified-Since",

        "If-Unmodified-since",

        "Keep-Alive",

        "Last-Modified",

        "Link",

        "Location",

        "Range",

        "Referer",

        "Retry-After",

        "Transfer-Encoding",

        "Upgrade",

        "User-Agent",

        "WWW-Authenticate",

        "Accept-Encoding",

        "Allow",

        "Server",

        "Authentication-Info",

        "Access-Control-Allow-Credentials",

        "Access-Control-Allow-Headers",

        "Access-Control-Allow-Methods",

        "Access-Control-Allow-Origin",

        "Access-Control-Expose-Headers",

        "Access-Control-Max-Age",

        "Access-Control-Request-Headers",

        "Access-Control-Request-Method",

        "Optional-WWW-Authenticate",

        "Origin",

        "OSCORE",

        "Strict-Transport-Security",

        "Accept"

      };

//

// 'httpAcceptConnection()' - Accept a new HTTP client connection.

//

// This function accepts a new HTTP client connection from the specified

// listening socket "fd".  The "blocking" argument specifies whether the new

// HTTP connection is blocking.

//

// @since CUPS 1.7@

//

http_t *        // O - HTTP connection or `NULL`

httpAcceptConnection(int fd,    // I - Listen socket file descriptor

                     int blocking)  // I - 1 if the connection should be blocking, 0 otherwise

{

  http_t    *http;    // HTTP connection

  http_addrlist_t addrlist; // Dummy address list

  socklen_t   addrlen;  // Length of address

  int     val;    // Socket option value

  // Range check input...

  if (fd < 0)

    return (NULL);

  // Create the client connection...

  memset(&addrlist, 0, sizeof(addrlist));

  if ((http = http_create(NULL, 0, &addrlist, AF_UNSPEC, HTTP_ENCRYPTION_IF_REQUESTED, blocking, _HTTP_MODE_SERVER)) == NULL)

    return (NULL);

  // Accept the client and get the remote address...

  addrlen = sizeof(http_addr_t);

  if ((http->fd = accept(fd, (struct sockaddr *)&(http->addrlist->addr), &addrlen)) < 0)

  {

    _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0);

    httpClose(http);

    return (NULL);

  }

  http->hostaddr = &(http->addrlist->addr);

  if (httpAddrIsLocalhost(http->hostaddr))

    cupsCopyString(http->hostname, "localhost", sizeof(http->hostname));

  else

    httpAddrGetString(http->hostaddr, http->hostname, sizeof(http->hostname));

#ifdef SO_NOSIGPIPE

  // Disable SIGPIPE for this socket.

  val = 1;

  setsockopt(http->fd, SOL_SOCKET, SO_NOSIGPIPE, CUPS_SOCAST &val, sizeof(val));

#endif // SO_NOSIGPIPE

  // Using TCP_NODELAY improves responsiveness, especially on systems with a

  // slow loopback interface.  Since we write large buffers when sending print

  // files and requests, there shouldn't be any performance penalty for this...

  val = 1;

  setsockopt(http->fd, IPPROTO_TCP, TCP_NODELAY, CUPS_SOCAST &val, sizeof(val));

#ifdef FD_CLOEXEC

  // Close this socket when starting another process...

  fcntl(http->fd, F_SETFD, FD_CLOEXEC);

#endif // FD_CLOEXEC

  return (http);

}

//

// 'httpAddCredential()' - Allocates and adds a single credential to an array.

//

// @deprecated@ @exclude all@

//

int         // O - 0 on success, -1 on error

httpAddCredential(

    cups_array_t *credentials,    // I - Credentials array

    const void   *data,     // I - PEM-encoded X.509 data

    size_t       datalen)   // I - Length of data

{

  (void)credentials;

  (void)data;

  (void)datalen;

  return (-1);

}

//

// 'httpBlocking()' - Set blocking/non-blocking behavior on a connection.

//

// @deprecated@

//

void

httpBlocking(http_t *http,    // I - HTTP connection

             int    b)      // I - 1 = blocking, 0 = non-blocking

{

  httpSetBlocking(http, b != 0);

}

//

// 'httpCheck()' - Check to see if there is a pending response from the server.

//

// @deprecated@

//

int         // O - 0 = no data, 1 = data available

httpCheck(http_t *http)     // I - HTTP connection

{

  return (httpWait(http, 0));

}

//

// 'httpClearCookie()' - Clear the cookie value(s).

//

// @since CUPS 1.1.19@

//

void

httpClearCookie(http_t *http)   // I - HTTP connection

{

  if (!http)

    return;

  free(http->cookie);

  http->cookie = NULL;

}

//

// 'httpClearFields()' - Clear HTTP request/response fields.

//

void

httpClearFields(http_t *http)   // I - HTTP connection

{

  http_field_t  field;      // Current field

  DEBUG_printf("httpClearFields(http=%p)", (void *)http);

  if (http)

  {

    memset(http->_fields, 0, sizeof(http->_fields));

    for (field = HTTP_FIELD_ACCEPT_LANGUAGE; field < HTTP_FIELD_ACCEPT_ENCODING; field ++)

    {

      if (!http->fields[field])

        continue;

      if (http->fields[field] != http->_fields[field])

        free(http->fields[field]);

      http->fields[field] = NULL;

    }

    for (; field < HTTP_FIELD_MAX; field ++)

    {

      if (!http->fields[field])

        continue;

      free(http->fields[field]);

      http->fields[field] = NULL;

    }

    if (http->mode == _HTTP_MODE_CLIENT)

    {

      if (http->hostname[0] == '/')

  httpSetField(http, HTTP_FIELD_HOST, "localhost");

      else

  httpSetField(http, HTTP_FIELD_HOST, http->hostname);

    }

    http->expect = (http_status_t)0;

  }

}

//

// 'httpClose()' - Close a HTTP connection.

//

void

httpClose(http_t *http)     // I - HTTP connection

{

  http_field_t  field;      // Current field

#ifdef HAVE_GSSAPI

  OM_uint32 minor_status;   // Minor status code

#endif // HAVE_GSSAPI

  DEBUG_printf("httpClose(http=%p)", (void *)http);

  //

  // Range check input...

  //

  if (!http)

    return;

  //

  // Close any open connection...

  //

  _httpDisconnect(http);

  //

  // Free memory used...

  //

  httpAddrFreeList(http->addrlist);

  free(http->cookie);

#ifdef HAVE_GSSAPI

  if (http->gssctx != GSS_C_NO_CONTEXT)

    gss_delete_sec_context(&minor_status, &http->gssctx, GSS_C_NO_BUFFER);

  if (http->gssname != GSS_C_NO_NAME)

    gss_release_name(&minor_status, &http->gssname);

#endif // HAVE_GSSAPI

#ifdef HAVE_AUTHORIZATION_H

  if (http->auth_ref)

    AuthorizationFree(http->auth_ref, kAuthorizationFlagDefaults);

#endif // HAVE_AUTHORIZATION_H

  for (field = HTTP_FIELD_ACCEPT_LANGUAGE; field < HTTP_FIELD_MAX; field ++)

  {

    free(http->default_fields[field]);

    if (field >= HTTP_FIELD_ACCEPT_ENCODING || http->fields[field] != http->_fields[field])

      free(http->fields[field]);

  }

  if (http->authstring && http->authstring != http->_authstring)

    free(http->authstring);

  _httpFreeCredentials(http->tls_credentials);

  free(http);

}

//

// 'httpCompareCredentials()' - Compare two sets of X.509 credentials.

//

// @deprecated@ @exclude all@

//

int         // O - 1 if they match, 0 if they do not

httpCompareCredentials(

    cups_array_t *cred1,    // I - First set of X.509 credentials

    cups_array_t *cred2)    // I - Second set of X.509 credentials

{

  (void)cred1;

  (void)cred2;

  return (0);

}

//

// 'httpConnect()' - Connect to a HTTP server.

//

// This function is deprecated - use @link httpConnect2@ instead.

//

// @deprecated@ @exclude all@

//

http_t *        // O - New HTTP connection

httpConnect(const char *host,   // I - Host to connect to

            int        port)    // I - Port number

{

  return (httpConnect2(host, port, NULL, AF_UNSPEC, HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL));

}

//

// 'httpConnect2()' - Connect to a HTTP server.

//

// This function creates a connection to a HTTP server.  The "host" and "port"

// arguments specify a hostname or IP address and port number to use while the

// "addrlist" argument specifies a list of addresses to use or `NULL` to do a

// fresh lookup.  The "family" argument specifies the address family to use -

// `AF_UNSPEC` to try both IPv4 and IPv6, `AF_INET` for IPv4, or `AF_INET6` for

// IPv6.

//

// The "encryption" argument specifies whether to encrypt the connection and the

// "blocking" argument specifies whether to use blocking behavior when reading

// or writing data.

//

// The "msec" argument specifies how long to try to connect to the server or `0`

// to just create an unconnected `http_t` object.  The "cancel" argument

// specifies an integer variable that can be set to a non-zero value to cancel

// the connection process.

//

// @since CUPS 1.7@

//

http_t *        // O - New HTTP connection

httpConnect2(

    const char        *host,    // I - Host to connect to

    int               port,   // I - Port number

    http_addrlist_t   *addrlist,  // I - List of addresses or `NULL` to lookup

    int               family,   // I - Address family to use or `AF_UNSPEC` for any

    http_encryption_t encryption, // I - Type of encryption to use

    int               blocking,   // I - 1 for blocking connection, 0 for non-blocking

    int               msec,   // I - Connection timeout in milliseconds, 0 means don't connect

    int               *cancel)    // I - Pointer to "cancel" variable

{

  http_t  *http;      // New HTTP connection

  DEBUG_printf("httpConnect2(host=\"%s\", port=%d, addrlist=%p, family=%d, encryption=%d, blocking=%d, msec=%d, cancel=%p)", host, port, (void *)addrlist, family, encryption, blocking, msec, (void *)cancel);

  // Create the HTTP structure...

  if ((http = http_create(host, port, addrlist, family, encryption, blocking, _HTTP_MODE_CLIENT)) == NULL)

    return (NULL);

  // Optionally connect to the remote system...

  if (msec == 0 || httpConnectAgain(http, msec, cancel))

    return (http);

  // Could not connect to any known address - bail out!

  httpClose(http);

  return (NULL);

}

//

// 'httpConnectAgain()' - Reconnect to a HTTP server with timeout and optional cancel variable.

//

bool          // O - `true` on success, `false` on failure

httpConnectAgain(http_t *http,    // I - HTTP connection

           int    msec,   // I - Timeout in milliseconds

           int    *cancel)  // I - Pointer to "cancel" variable

{

  http_addrlist_t *addr;    // Connected address

  char      *orig_creds;  // Original peer credentials

#ifdef DEBUG

  http_addrlist_t *current; // Current address

  char      temp[256];  // Temporary address string

#endif // DEBUG

  DEBUG_printf("httpConnectAgain(http=%p, msec=%d, cancel=%p)", (void *)http, msec, (void *)cancel);

  if (!http)

  {

    _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);

    return (false);

  }

  orig_creds = httpCopyPeerCredentials(http);

  if (http->tls)

  {

    DEBUG_puts("1httpConnectAgain: Shutting down TLS...");

    _httpTLSStop(http);

  }

  // Close any previously open socket...

  if (http->fd >= 0)

  {

    DEBUG_printf("1httpConnectAgain: Closing socket %d...", http->fd);

    httpAddrClose(NULL, http->fd);

    http->fd = -1;

  }

  // Reset all state (except fields, which may be reused)...

  http->state           = HTTP_STATE_WAITING;

  http->version         = HTTP_VERSION_1_1;

  http->keep_alive      = HTTP_KEEPALIVE_OFF;

  memset(&http->_hostaddr, 0, sizeof(http->_hostaddr));

  http->data_encoding   = HTTP_ENCODING_FIELDS;

  http->_data_remaining = 0;

  http->used            = 0;

  http->data_remaining  = 0;

  http->hostaddr        = NULL;

  http->wused           = 0;

  // Connect to the server...

#ifdef DEBUG

  for (current = http->addrlist; current; current = current->next)

    DEBUG_printf("1httpConnectAgain: Address %s:%d", httpAddrString(&(current->addr), temp, sizeof(temp)), httpAddrPort(&(current->addr)));

#endif // DEBUG

  if ((addr = httpAddrConnect2(http->addrlist, &(http->fd), msec, cancel)) == NULL)

  {

    // Unable to connect...

#ifdef _WIN32

    http->error  = WSAGetLastError();

#else

    http->error  = errno;

#endif // _WIN32

    http->status = HTTP_STATUS_ERROR;

    DEBUG_printf("1httpConnectAgain: httpAddrConnect failed: %s", strerror(http->error));

    free(orig_creds);

    return (false);

  }

  DEBUG_printf("1httpConnectAgain: New socket=%d", http->fd);

  if (http->timeout_value > 0)

    http_set_timeout(http->fd, http->timeout_value);

  http->hostaddr = &(addr->addr);

  http->error    = 0;

  if (http->encryption == HTTP_ENCRYPTION_ALWAYS)

  {

    // Always do encryption via TLS.

    if (!_httpTLSStart(http))

    {

      httpAddrClose(NULL, http->fd);

      http->fd = -1;

      free(orig_creds);

      return (false);

    }

  }

  else if (http->encryption == HTTP_ENCRYPTION_REQUIRED && !http->tls_upgrade)

  {

    if (!http_tls_upgrade(http))

    {

      free(orig_creds);

      return (false);

    }

  }

  DEBUG_printf("1httpConnectAgain: Connected to %s:%d...", httpAddrGetString(http->hostaddr, temp, sizeof(temp)), httpAddrGetPort(http->hostaddr));

  if (orig_creds)

  {

    char *new_creds = httpCopyPeerCredentials(http);

          // New peer credentials

    if (!new_creds || (strcmp(orig_creds, new_creds) && cupsGetCredentialsTrust(/*path*/NULL, http->hostname, new_creds, /*require_ca*/true) != HTTP_TRUST_OK))

    {

      // New and old credentials don't match and the new cert doesn't validate...

      _httpDisconnect(http);

      free(orig_creds);

      free(new_creds);

      return (false);

    }

    free(new_creds);

  }

  free(orig_creds);

  return (true);

}

//

// 'httpConnectEncrypt()' - Connect to a HTTP server using encryption.

//

// This function is now deprecated. Please use the @link httpConnect2@ function

// instead.

//

// @deprecated@ @exclude all@

//

http_t *        // O - New HTTP connection

httpConnectEncrypt(

    const char        *host,    // I - Host to connect to

    int               port,   // I - Port number

    http_encryption_t encryption) // I - Type of encryption to use

{

  DEBUG_printf("httpConnectEncrypt(host=\"%s\", port=%d, encryption=%d)", host, port, encryption);

  return (httpConnect2(host, port, NULL, AF_UNSPEC, encryption, 1, 30000, NULL));

}

//

// 'httpConnectURI()' - Connect to a HTTP service using a URI.

//

// This function creates a connection to a HTTP server.  The "uri" argument

// specifies a "http", "https", "ipp", or "ipps" URI for the service.

//

// The resource path for the service is returned in the buffer pointed to by

// the "resource" argument of size "rsize".

//

// The "msec" argument specifies how long to try to connect to the server or `0`

// to just create an unconnected `http_t` object.  The "cancel" argument

// specifies an integer variable that can be set to a non-zero value to cancel

// the connection process.

//

// The "require_ca" argument specifies whether to verify that the service

// connection is using a CA-signed X.509 certificate.

//

// @since CUPS 2.5@

//

http_t *        // O - New HTTP connection

httpConnectURI(const char *uri,   // I - Service to connect to

               char       *host,  // I - Host name buffer (`NULL` for don't care)

               size_t     hsize,  // I - Size of host name buffer

               int        *port,  // O - Port number (`NULL` for don't care)

               char       *resource,  // I - Resource path buffer (`NULL` for don't care)

               size_t     rsize,  // I - Size of resource path buffer

               bool       blocking, // I - `true` for blocking connection, `false` for non-blocking

               int        msec,   // I - Connection timeout in milliseconds, `0` means don't connect

               int        *cancel,  // I - Pointer to "cancel" variable or `NULL` for none

               bool       require_ca) // I - `true` to require a CA-signed X.509 certificate

{

  http_t  *http;      // New HTTP connection

  char    scheme[32],   // URI scheme

    userpass[32],   // URI username:password

    lhost[256],   // URI host (local copy)

    lresource[256];   // URI resource (local copy)

  int   lport;      // URI port (local copy)

  http_encryption_t encryption;   // Type of encryption to use

  http_uri_status_t uri_status;   // URI separation status

  DEBUG_printf("httpConnectURI(uri=\"%s\", host=%p, hsize=%u, port=%p, resource=%p, rsize=%u, blocking=%d, msec=%d, cancel=%p, require_ca=%s)", uri, (void *)host, (unsigned)hsize, (void *)port, (void *)resource, (unsigned)rsize, blocking, msec, (void *)cancel, require_ca ? "true" : "false");

  // Range check input...

  if (!uri)

  {

    if (host)

      *host = '\0';

    if (port)

      *port = 0;

    if (resource)

      *resource = '\0';

    return (NULL);

  }

  if (!host)

  {

    host  = lhost;

    hsize = sizeof(lhost);

  }

  if (!port)

    port = &lport;

  if (!resource)

  {

    resource = lresource;

    rsize    = sizeof(lresource);

  }

  // Get the URI components...

  if ((uri_status = httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme), userpass, sizeof(userpass), host, hsize, port, resource, rsize)) < HTTP_URI_STATUS_OK)

  {

    _cupsSetError(IPP_STATUS_ERROR_INTERNAL, httpURIStatusString(uri_status), 0);

    return (NULL);

  }

  DEBUG_printf("1httpConnectURI: scheme=\"%s\", host=\"%s\", port=%d, resource=\"%s\"", scheme, host, *port, resource);

  if (!strcmp(scheme, "https") || !strcmp(scheme, "ipps") || *port == 443)

    encryption = HTTP_ENCRYPTION_ALWAYS;

  else

    encryption = HTTP_ENCRYPTION_IF_REQUESTED;

  http = httpConnect2(host, *port, /*addrlist*/NULL, AF_UNSPEC, encryption, blocking, msec, cancel);

  if (httpIsEncrypted(http))

  {

    // Validate trust with service...

    char  *creds;     // Peer credentials...

    http_trust_t trust;     // Trust in credentials...

    creds = httpCopyPeerCredentials(http);

    trust = cupsGetCredentialsTrust(/*path*/NULL, host, creds, require_ca);

    if (trust == HTTP_TRUST_OK)

    {

      // Pin the trusted credentials (for TOFU)...

      cupsSaveCredentials(/*path*/NULL, host, creds, /*key*/NULL);

    }

    else if (trust != HTTP_TRUST_RENEWED)

    {

      // Don't allow the connection...

      httpClose(http);

      http = NULL;

    }

    free(creds);

  }

  return (http);

}

//

// 'httpDelete()' - Send a DELETE request to the server.

//

// @deprecated@ @exclude all@

//

int         // O - Status of call (0 = success)

httpDelete(http_t     *http,    // I - HTTP connection

           const char *uri)   // I - URI to delete

{

  return (http_send(http, HTTP_STATE_DELETE, uri) ? 0 : -1);

}

//

// '_httpDisconnect()' - Disconnect a HTTP connection.

//

void

_httpDisconnect(http_t *http)   // I - HTTP connection

{

  if (http->tls)

    _httpTLSStop(http);

  httpAddrClose(NULL, http->fd);

  http->fd = -1;

}

//

// 'httpEncryption()' - Set the required encryption on the link.

//

// @deprecated@ @exclude all@

//

int         // O - -1 on error, 0 on success

httpEncryption(http_t            *http, // I - HTTP connection

               http_encryption_t e) // I - New encryption preference

{

  return (httpSetEncryption(http, e) ? 0 : -1);

}

//

// 'httpError()' - Get the last error on a connection.

//

// @deprecated@ @exclude all@

//

int         // O - Error code (errno) value

httpError(http_t *http)     // I - HTTP connection

{

  return (httpGetError(http));

}

//

// 'httpFieldValue()' - Return the HTTP field enumeration value for a field name.

//

http_field_t        // O - Field index

httpFieldValue(const char *name)  // I - String name

{

  int i;        // Looping var

  for (i = 0; i < HTTP_FIELD_MAX; i ++)

  {

    if (!_cups_strcasecmp(name, http_fields[i]))

      return ((http_field_t)i);

  }

  return (HTTP_FIELD_UNKNOWN);

}

//

// 'httpFlush()' - Flush data read from a HTTP connection.

//

void

httpFlush(http_t *http)     // I - HTTP connection

{

  char    buffer[8192];   // Junk buffer

  int   blocking;   // To block or not to block

  http_state_t  oldstate;   // Old state

  DEBUG_printf("httpFlush(http=%p), state=%s", (void *)http, httpStateString(http->state));

  // Nothing to do if we are in the "waiting" state...

  if (http->state == HTTP_STATE_WAITING)

    return;

  // Temporarily set non-blocking mode so we don't get stuck in httpRead()...

  blocking = http->blocking;

  http->blocking = 0;

  // Read any data we can...

  oldstate = http->state;

  while (httpRead2(http, buffer, sizeof(buffer)) > 0);

  // Restore blocking and reset the connection if we didn't get all of

  // the remaining data...

  http->blocking = blocking;

  if (http->state == oldstate && http->state != HTTP_STATE_WAITING &&

      http->fd >= 0)

  {

    // Didn't get the data back, so close the current connection.

    if (http->coding)

      http_content_coding_finish(http);

    DEBUG_puts("1httpFlush: Setting state to HTTP_STATE_WAITING and closing.");

    http->state = HTTP_STATE_WAITING;

    if (http->tls)

      _httpTLSStop(http);

    httpAddrClose(NULL, http->fd);

    http->fd = -1;

  }

}

//

// 'httpFlushWrite()' - Flush data written to a HTTP connection.

//

// @since CUPS 1.2@

//

int         // O - Bytes written or -1 on error

httpFlushWrite(http_t *http)    // I - HTTP connection

{

  ssize_t bytes;      // Bytes written

  DEBUG_printf("httpFlushWrite(http=%p) data_encoding=%d", (void *)http, http ? http->data_encoding : 100);

  if (!http || !http->wused)

  {

    DEBUG_puts(http ? "1httpFlushWrite: Write buffer is empty." : "1httpFlushWrite: No connection.");

    return (0);

  }

  if (http->data_encoding == HTTP_ENCODING_CHUNKED)

    bytes = http_write_chunk(http, http->wbuffer, (size_t)http->wused);

  else

    bytes = http_write(http, http->wbuffer, (size_t)http->wused);

  http->wused = 0;

  DEBUG_printf("1httpFlushWrite: Returning %d, errno=%d.", (int)bytes, errno);

  return ((int)bytes);

}

//

// 'httpFreeCredentials()' - Free an array of credentials.

//

// @deprecated@ @exclude all@

//

void

httpFreeCredentials(

    cups_array_t *credentials)    // I - Array of credentials

{

  (void)credentials;

}

//

// 'httpGet()' - Send a GET request to the server.

//

// @deprecated@ @exclude all@

//

int         // O - Status of call (0 = success)

httpGet(http_t     *http,   // I - HTTP connection

        const char *uri)    // I - URI to get

{

  return (http_send(http, HTTP_STATE_GET, uri) ? 0 : -1);

}

//

// 'httpGetActivity()' - Get the most recent activity for a connection.

//

// The return value is the time in seconds of the last read or write.

//

// @since CUPS 2.0/OS 10.10@

//

time_t          // O - Time of last read or write

httpGetActivity(http_t *http)   // I - HTTP connection

{

  return (http ? http->activity : 0);

}

//

// 'httpGetAuthString()' - Get the current authorization string.

//

// The authorization string is set by @link cupsDoAuthentication@ and

// @link httpSetAuthString@.  Use @link httpGetAuthString@ to retrieve the

// string to use with @link httpSetField@ for the

// `HTTP_FIELD_AUTHORIZATION` value.

//

// @since CUPS 1.3@

//

char *          // O - Authorization string

httpGetAuthString(http_t *http)   // I - HTTP connection

{

  if (http)

    return (http->authstring);

  else

    return (NULL);

}

//

// 'httpGetBlocking()' - Get the blocking/non-blocking state of a connection.

//

// @since CUPS 1.2@

//

int         // O - 1 if blocking, 0 if non-blocking

httpGetBlocking(http_t *http)   // I - HTTP connection

{

  return (http ? http->blocking : 0);

}

//

// 'httpGetContentEncoding()' - Get a common content encoding, if any, between

//                              the client and server.

//

// This function uses the value of the Accepts-Encoding HTTP header and must be

// called after receiving a response from the server or a request from the

// client.  The value returned can be use in subsequent requests (for clients)

// or in the response (for servers) in order to compress the content stream.

//

// @since CUPS 1.7@

//

const char *        // O - Content-Coding value or `NULL` for the identity coding.

httpGetContentEncoding(http_t *http)  // I - HTTP connection

{

  if (http && http->fields[HTTP_FIELD_ACCEPT_ENCODING])

  {

    int   i;      // Looping var

    char  temp[HTTP_MAX_VALUE], // Copy of Accepts-Encoding value

    *start,     // Start of coding value

    *end;     // End of coding value

    double  qvalue;     // "qvalue" for coding

    struct lconv *loc = localeconv(); // Locale data

    static const char * const codings[] =

    {         // Supported content codings

      "deflate",