#include "http-private.h"
#include "globals.h"
#include "debug.h"
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#ifndef WIN32
# include <signal.h>
# include <sys/time.h>
# include <sys/resource.h>
#endif
#ifdef HAVE_POLL
# include <sys/poll.h>
#endif
#ifndef FNONBLK
# define FNONBLK O_NONBLOCK
#endif
#ifdef DEBUG
static void http_debug_hex(const char *prefix, const char *buffer,
int bytes);
#endif
static http_field_t http_field(const char *name);
static int http_send(http_t *http, http_state_t request,
const char *uri);
static int http_write(http_t *http, const char *buffer,
int length);
static int http_write_chunk(http_t *http, const char *buffer,
int length);
#ifdef HAVE_SSL
static int http_read_ssl(http_t *http, char *buf, int len);
static int http_setup_ssl(http_t *http);
static void http_shutdown_ssl(http_t *http);
static int http_upgrade(http_t *http);
static int http_write_ssl(http_t *http, const char *buf, int len);
# ifdef HAVE_GNUTLS
# ifdef HAVE_PTHREAD_H
GCRY_THREAD_OPTION_PTHREAD_IMPL;
# endif
# elif defined(HAVE_LIBSSL) && defined(HAVE_PTHREAD_H)
static pthread_mutex_t *http_locks;
static void http_locking_cb(int mode, int type, const char *file,
int line);
static unsigned long http_threadid_cb(void);
# endif
#endif
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"
};
#ifdef DEBUG
static const char * const http_states[] =
{
"HTTP_WAITING",
"HTTP_OPTIONS",
"HTTP_GET",
"HTTP_GET_SEND",
"HTTP_HEAD",
"HTTP_POST",
"HTTP_POST_RECV",
"HTTP_POST_SEND",
"HTTP_PUT",
"HTTP_PUT_RECV",
"HTTP_DELETE",
"HTTP_TRACE",
"HTTP_CLOSE",
"HTTP_STATUS"
};
#endif
#if defined(HAVE_SSL) && defined(HAVE_LIBSSL)
static int http_bio_write(BIO *h, const char *buf, int num);
static int http_bio_read(BIO *h, char *buf, int size);
static int http_bio_puts(BIO *h, const char *str);
static long http_bio_ctrl(BIO *h, int cmd, long arg1, void *arg2);
static int http_bio_new(BIO *h);
static int http_bio_free(BIO *data);
static BIO_METHOD http_bio_methods =
{
BIO_TYPE_SOCKET,
"http",
http_bio_write,
http_bio_read,
http_bio_puts,
NULL,
http_bio_ctrl,
http_bio_new,
http_bio_free,
NULL,
};
BIO_METHOD *
_httpBIOMethods(void)
{
return (&http_bio_methods);
}
#endif
void
httpBlocking(http_t *http,
int b)
{
if (http)
http->blocking = b;
}
int
httpCheck(http_t *http)
{
return (httpWait(http, 0));
}
void
httpClearCookie(http_t *http)
{
if (!http)
return;
if (http->cookie)
{
free(http->cookie);
http->cookie = NULL;
}
}
void
httpClearFields(http_t *http)
{
if (http)
{
memset(http->fields, 0, sizeof(http->fields));
if (http->hostname[0] == '/')
httpSetField(http, HTTP_FIELD_HOST, "localhost");
else
httpSetField(http, HTTP_FIELD_HOST, http->hostname);
if (http->field_authorization)
{
free(http->field_authorization);
http->field_authorization = NULL;
}
http->expect = (http_status_t)0;
}
}
void
httpClose(http_t *http)
{
#ifdef HAVE_GSSAPI
OM_uint32 minor_status;
#endif
DEBUG_printf(("httpClose(http=%p)", http));
if (!http)
return;
httpAddrFreeList(http->addrlist);
if (http->cookie)
free(http->cookie);
#ifdef HAVE_SSL
if (http->tls)
http_shutdown_ssl(http);
#endif
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif
#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
#ifdef HAVE_AUTHORIZATION_H
if (http->auth_ref)
AuthorizationFree(http->auth_ref, kAuthorizationFlagDefaults);
#endif
httpClearFields(http);
if (http->authstring && http->authstring != http->_authstring)
free(http->authstring);
free(http);
}
http_t *
httpConnect(const char *host,
int port)
{
return (httpConnectEncrypt(host, port, HTTP_ENCRYPT_IF_REQUESTED));
}
http_t *
httpConnectEncrypt(
const char *host,
int port,
http_encryption_t encryption)
{
http_t *http;
DEBUG_printf(("httpConnectEncrypt(host=\"%s\", port=%d, encryption=%d)",
host, port, encryption));
if ((http = _httpCreate(host, port, encryption)) == NULL)
return (NULL);
if (!httpReconnect(http))
return (http);
httpAddrFreeList(http->addrlist);
free(http);
return (NULL);
}
http_t *
_httpCreate(
const char *host,
int port,
http_encryption_t encryption)
{
http_t *http;
http_addrlist_t *addrlist;
char service[255];
DEBUG_printf(("4_httpCreate(host=\"%s\", port=%d, encryption=%d)",
host, port, encryption));
if (!host)
return (NULL);
httpInitialize();
sprintf(service, "%d", port);
if ((addrlist = httpAddrGetList(host, AF_UNSPEC, service)) == NULL)
return (NULL);
if ((http = calloc(sizeof(http_t), 1)) == NULL)
{
httpAddrFreeList(addrlist);
return (NULL);
}
http->activity = time(NULL);
http->addrlist = addrlist;
http->blocking = 1;
http->fd = -1;
#ifdef HAVE_GSSAPI
http->gssctx = GSS_C_NO_CONTEXT;
http->gssname = GSS_C_NO_NAME;
#endif
http->version = HTTP_1_1;
strlcpy(http->hostname, host, sizeof(http->hostname));
if (port == 443)
http->encryption = HTTP_ENCRYPT_ALWAYS;
else
http->encryption = encryption;
return (http);
}
int
httpDelete(http_t *http,
const char *uri)
{
return (http_send(http, HTTP_DELETE, uri));
}
int
httpEncryption(http_t *http,
http_encryption_t e)
{
DEBUG_printf(("httpEncryption(http=%p, e=%d)", http, e));
#ifdef HAVE_SSL
if (!http)
return (0);
http->encryption = e;
if ((http->encryption == HTTP_ENCRYPT_ALWAYS && !http->tls) ||
(http->encryption == HTTP_ENCRYPT_NEVER && http->tls))
return (httpReconnect(http));
else if (http->encryption == HTTP_ENCRYPT_REQUIRED && !http->tls)
return (http_upgrade(http));
else
return (0);
#else
if (e == HTTP_ENCRYPT_ALWAYS || e == HTTP_ENCRYPT_REQUIRED)
return (-1);
else
return (0);
#endif
}
int
httpError(http_t *http)
{
if (http)
return (http->error);
else
return (EINVAL);
}
void
httpFlush(http_t *http)
{
char buffer[8192];
int blocking;
http_state_t oldstate;
DEBUG_printf(("httpFlush(http=%p), state=%s", http,
http_states[http->state]));
blocking = http->blocking;
http->blocking = 0;
oldstate = http->state;
while (httpRead2(http, buffer, sizeof(buffer)) > 0);
http->blocking = blocking;
if (http->state == oldstate && http->state != HTTP_WAITING && http->fd >= 0)
{
http->state = HTTP_WAITING;
#ifdef HAVE_SSL
if (http->tls)
http_shutdown_ssl(http);
#endif
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif
http->fd = -1;
}
}
int
httpFlushWrite(http_t *http)
{
int bytes;
DEBUG_printf(("httpFlushWrite(http=%p)", http));
if (!http || !http->wused)
return (0);
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
bytes = http_write_chunk(http, http->wbuffer, http->wused);
else
bytes = http_write(http, http->wbuffer, http->wused);
http->wused = 0;
return (bytes);
}
int
httpGet(http_t *http,
const char *uri)
{
return (http_send(http, HTTP_GET, uri));
}
char *
httpGetAuthString(http_t *http)
{
if (http)
return (http->authstring);
else
return (NULL);
}
int
httpGetBlocking(http_t *http)
{
return (http ? http->blocking : 0);
}
const char *
httpGetCookie(http_t *http)
{
return (http ? http->cookie : NULL);
}
int
httpGetFd(http_t *http)
{
return (http ? http->fd : -1);
}
const char *
httpGetField(http_t *http,
http_field_t field)
{
if (!http || field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
return (NULL);
else if (field == HTTP_FIELD_AUTHORIZATION &&
http->field_authorization)
{
return (http->field_authorization);
}
else
return (http->fields[field]);
}
int
httpGetLength(http_t *http)
{
if (http)
{
httpGetLength2(http);
return (http->_data_remaining);
}
else
return (-1);
}
off_t
httpGetLength2(http_t *http)
{
DEBUG_printf(("2httpGetLength2(http=%p), state=%s", http,
http_states[http->state]));
if (!http)
return (-1);
if (!strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked"))
{
DEBUG_puts("4httpGetLength2: chunked request!");
http->data_encoding = HTTP_ENCODE_CHUNKED;
http->data_remaining = 0;
}
else
{
http->data_encoding = HTTP_ENCODE_LENGTH;
if (!http->fields[HTTP_FIELD_CONTENT_LENGTH][0])
{
if (http->status >= HTTP_MULTIPLE_CHOICES)
http->data_remaining = 0;
else
http->data_remaining = 2147483647;
}
else
http->data_remaining = strtoll(http->fields[HTTP_FIELD_CONTENT_LENGTH],
NULL, 10);
DEBUG_printf(("4httpGetLength2: content_length=" CUPS_LLFMT,
CUPS_LLCAST http->data_remaining));
}
if (http->data_remaining <= INT_MAX)
http->_data_remaining = (int)http->data_remaining;
else
http->_data_remaining = INT_MAX;
return (http->data_remaining);
}
http_status_t
httpGetStatus(http_t *http)
{
return (http ? http->status : HTTP_ERROR);
}
char *
httpGetSubField(http_t *http,
http_field_t field,
const char *name,
char *value)
{
return (httpGetSubField2(http, field, name, value, HTTP_MAX_VALUE));
}
char *
httpGetSubField2(http_t *http,
http_field_t field,
const char *name,
char *value,
int valuelen)
{
const char *fptr;
char temp[HTTP_MAX_VALUE],
*ptr,
*end;
DEBUG_printf(("2httpGetSubField2(http=%p, field=%d, name=\"%s\", value=%p, "
"valuelen=%d)", http, field, name, value, valuelen));
if (!http || !name || !value || valuelen < 2 ||
field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
return (NULL);
end = value + valuelen - 1;
for (fptr = http->fields[field]; *fptr;)
{
while (_cups_isspace(*fptr))
fptr ++;
if (*fptr == ',')
{
fptr ++;
continue;
}
for (ptr = temp;
*fptr && *fptr != '=' && !_cups_isspace(*fptr) &&
ptr < (temp + sizeof(temp) - 1);
*ptr++ = *fptr++);
*ptr = '\0';
DEBUG_printf(("4httpGetSubField2: name=\"%s\"", temp));
while (_cups_isspace(*fptr))
fptr ++;
if (!*fptr)
break;
if (*fptr != '=')
continue;
fptr ++;
while (_cups_isspace(*fptr))
fptr ++;
if (*fptr == '\"')
{
for (ptr = value, fptr ++;
*fptr && *fptr != '\"' && ptr < end;
*ptr++ = *fptr++);
*ptr = '\0';
while (*fptr && *fptr != '\"')
fptr ++;
if (*fptr)
fptr ++;
}
else
{
for (ptr = value;
*fptr && !_cups_isspace(*fptr) && *fptr != ',' && ptr < end;
*ptr++ = *fptr++);
*ptr = '\0';
while (*fptr && !_cups_isspace(*fptr) && *fptr != ',')
fptr ++;
}
DEBUG_printf(("4httpGetSubField2: value=\"%s\"", value));
if (!strcmp(name, temp))
{
DEBUG_printf(("3httpGetSubField2: Returning \"%s\"", value));
return (value);
}
}
value[0] = '\0';
DEBUG_puts("3httpGetSubField2: Returning NULL");
return (NULL);
}
char *
httpGets(char *line,
int length,
http_t *http)
{
char *lineptr,
*lineend,
*bufptr,
*bufend;
int bytes,
eol;
DEBUG_printf(("2httpGets(line=%p, length=%d, http=%p)", line, length, http));
if (http == NULL || line == NULL)
return (NULL);
http->error = 0;
lineptr = line;
lineend = line + length - 1;
eol = 0;
while (lineptr < lineend)
{
#ifdef WIN32
WSASetLastError(0);
#else
errno = 0;
#endif
while (http->used == 0)
{
if (!http->blocking && !_httpWait(http, 10000, 1))
{
DEBUG_puts("3httpGets: Timed out!");
#ifdef WIN32
http->error = WSAETIMEDOUT;
#else
http->error = ETIMEDOUT;
#endif
return (NULL);
}
#ifdef HAVE_SSL
if (http->tls)
bytes = http_read_ssl(http, http->buffer + http->used,
HTTP_MAX_BUFFER - http->used);
else
#endif
bytes = recv(http->fd, http->buffer + http->used,
HTTP_MAX_BUFFER - http->used, 0);
DEBUG_printf(("4httpGets: read %d bytes...", bytes));
if (bytes < 0)
{
#ifdef WIN32
if (WSAGetLastError() != http->error)
{
http->error = WSAGetLastError();
continue;
}
DEBUG_printf(("3httpGets: recv() error %d!", WSAGetLastError()));
#else
DEBUG_printf(("3httpGets: recv() error %d!", errno));
if (errno == EINTR || errno == EAGAIN)
continue;
else if (errno != http->error)
{
http->error = errno;
continue;
}
#endif
return (NULL);
}
else if (bytes == 0)
{
http->error = EPIPE;
return (NULL);
}
http->used += bytes;
}
for (bufptr = http->buffer, bufend = http->buffer + http->used;
lineptr < lineend && bufptr < bufend;)
{
if (*bufptr == 0x0a)
{
eol = 1;
bufptr ++;
break;
}
else if (*bufptr == 0x0d)
bufptr ++;
else
*lineptr++ = *bufptr++;
}
http->used -= (int)(bufptr - http->buffer);
if (http->used > 0)
memmove(http->buffer, bufptr, http->used);
if (eol)
{
http->activity = time(NULL);
*lineptr = '\0';
DEBUG_printf(("3httpGets: Returning \"%s\"", line));
return (line);
}
}
DEBUG_puts("3httpGets: No new line available!");
return (NULL);
}
int
httpHead(http_t *http,
const char *uri)
{
DEBUG_printf(("httpHead(http=%p, uri=\"%s\")", http, uri));
return (http_send(http, HTTP_HEAD, uri));
}
void
httpInitialize(void)
{
static int initialized = 0;
#ifdef WIN32
WSADATA winsockdata;
#endif
#ifdef HAVE_LIBSSL
int i;
unsigned char data[1024];
#endif
if (initialized)
return;
#ifdef WIN32
WSAStartup(MAKEWORD(2,2), &winsockdata);
#elif !defined(SO_NOSIGPIPE)
# ifdef HAVE_SIGSET
sigset(SIGPIPE, SIG_IGN);
# elif defined(HAVE_SIGACTION)
struct sigaction action;
memset(&action, 0, sizeof(action));
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
# else
signal(SIGPIPE, SIG_IGN);
# endif
#endif
#ifdef HAVE_GNUTLS
# ifdef HAVE_PTHREAD_H
gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
# endif
gnutls_global_init();
#elif defined(HAVE_LIBSSL)
SSL_load_error_strings();
SSL_library_init();
# ifdef HAVE_PTHREAD_H
http_locks = calloc(CRYPTO_num_locks(), sizeof(pthread_mutex_t));
for (i = 0; i < CRYPTO_num_locks(); i ++)
pthread_mutex_init(http_locks + i, NULL);
CRYPTO_set_id_callback(http_threadid_cb);
CRYPTO_set_locking_callback(http_locking_cb);
# endif
CUPS_SRAND(time(NULL));
for (i = 0; i < sizeof(data); i ++)
data[i] = CUPS_RAND();
RAND_seed(data, sizeof(data));
#endif
initialized = 1;
}
int
httpOptions(http_t *http,
const char *uri)
{
return (http_send(http, HTTP_OPTIONS, uri));
}
int
httpPost(http_t *http,
const char *uri)
{
return (http_send(http, HTTP_POST, uri));
}
int
httpPrintf(http_t *http,
const char *format,
...)
{
int bytes;
char buf[16384];
va_list ap;
DEBUG_printf(("2httpPrintf(http=%p, format=\"%s\", ...)", http, format));
va_start(ap, format);
bytes = vsnprintf(buf, sizeof(buf), format, ap);
va_end(ap);
DEBUG_printf(("3httpPrintf: %s", buf));
if (http->data_encoding == HTTP_ENCODE_FIELDS)
return (httpWrite2(http, buf, bytes));
else
{
if (http->wused)
{
DEBUG_puts("4httpPrintf: flushing existing data...");
if (httpFlushWrite(http) < 0)
return (-1);
}
return (http_write(http, buf, bytes));
}
}
int
httpPut(http_t *http,
const char *uri)
{
DEBUG_printf(("httpPut(http=%p, uri=\"%s\")", http, uri));
return (http_send(http, HTTP_PUT, uri));
}
int
httpRead(http_t *http,
char *buffer,
int length)
{
return ((int)httpRead2(http, buffer, length));
}
ssize_t
httpRead2(http_t *http,
char *buffer,
size_t length)
{
ssize_t bytes;
char len[32];
DEBUG_printf(("httpRead2(http=%p, buffer=%p, length=" CUPS_LLFMT ")",
http, buffer, CUPS_LLCAST length));
if (http == NULL || buffer == NULL)
return (-1);
http->activity = time(NULL);
http->error = 0;
if (length <= 0)
return (0);
if (http->data_encoding == HTTP_ENCODE_CHUNKED &&
http->data_remaining <= 0)
{
DEBUG_puts("2httpRead2: Getting chunk length...");
if (httpGets(len, sizeof(len), http) == NULL)
{
DEBUG_puts("1httpRead2: Could not get length!");
return (0);
}
http->data_remaining = strtoll(len, NULL, 16);
if (http->data_remaining < 0)
{
DEBUG_puts("1httpRead2: Negative chunk length!");
return (0);
}
}
DEBUG_printf(("2httpRead2: data_remaining=" CUPS_LLFMT,
CUPS_LLCAST http->data_remaining));
if (http->data_remaining <= 0)
{
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
httpGets(len, sizeof(len), http);
if (http->state == HTTP_POST_RECV)
http->state ++;
else
http->state = HTTP_WAITING;
http->data_encoding = HTTP_ENCODE_LENGTH;
return (0);
}
else if (length > (size_t)http->data_remaining)
length = (size_t)http->data_remaining;
if (http->used == 0 && length <= 256)
{
if (!http->blocking && !httpWait(http, 10000))
return (0);
if (http->data_remaining > sizeof(http->buffer))
bytes = sizeof(http->buffer);
else
bytes = http->data_remaining;
#ifdef HAVE_SSL
if (http->tls)
bytes = http_read_ssl(http, http->buffer, bytes);
else
#endif
{
DEBUG_printf(("2httpRead2: reading %d bytes from socket into buffer...",
(int)bytes));
bytes = recv(http->fd, http->buffer, bytes, 0);
DEBUG_printf(("2httpRead2: read %d bytes from socket into buffer...",
(int)bytes));
}
if (bytes > 0)
http->used = bytes;
else if (bytes < 0)
{
#ifdef WIN32
http->error = WSAGetLastError();
return (-1);
#else
if (errno != EINTR && errno != EAGAIN)
{
http->error = errno;
return (-1);
}
#endif
}
else
{
http->error = EPIPE;
return (0);
}
}
if (http->used > 0)
{
if (length > (size_t)http->used)
length = (size_t)http->used;
bytes = (ssize_t)length;
DEBUG_printf(("2httpRead2: grabbing %d bytes from input buffer...",
(int)bytes));
memcpy(buffer, http->buffer, length);
http->used -= (int)length;
if (http->used > 0)
memmove(http->buffer, http->buffer + length, http->used);
}
#ifdef HAVE_SSL
else if (http->tls)
{
if (!http->blocking && !httpWait(http, 10000))
return (0);
bytes = (ssize_t)http_read_ssl(http, buffer, (int)length);
}
#endif
else
{
if (!http->blocking && !httpWait(http, 10000))
return (0);
DEBUG_printf(("2httpRead2: reading " CUPS_LLFMT " bytes from socket...",
CUPS_LLCAST length));
#ifdef WIN32
bytes = (ssize_t)recv(http->fd, buffer, (int)length, 0);
#else
while ((bytes = recv(http->fd, buffer, length, 0)) < 0)
if (errno != EINTR && errno != EAGAIN)
break;
#endif
DEBUG_printf(("2httpRead2: read " CUPS_LLFMT " bytes from socket...",
CUPS_LLCAST bytes));
}
if (bytes > 0)
{
http->data_remaining -= bytes;
if (http->data_remaining <= INT_MAX)
http->_data_remaining = (int)http->data_remaining;
else
http->_data_remaining = INT_MAX;
}
else if (bytes < 0)
{
#ifdef WIN32
http->error = WSAGetLastError();
#else
if (errno == EINTR || errno == EAGAIN)
bytes = 0;
else
http->error = errno;
#endif
}
else
{
http->error = EPIPE;
return (0);
}
if (http->data_remaining == 0)
{
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
httpGets(len, sizeof(len), http);
if (http->data_encoding != HTTP_ENCODE_CHUNKED)
{
if (http->state == HTTP_POST_RECV)
http->state ++;
else
http->state = HTTP_WAITING;
}
}
#ifdef DEBUG
http_debug_hex("httpRead2", buffer, (int)bytes);
#endif
return (bytes);
}
#if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
OSStatus
_httpReadCDSA(
SSLConnectionRef connection,
void *data,
size_t *dataLength)
{
OSStatus result;
ssize_t bytes;
http_t *http;
http = (http_t *)connection;
if (!http->blocking)
{
if (!_httpWait(http, 10000, 0))
{
http->error = ETIMEDOUT;
return (-1);
}
}
do
{
bytes = recv(http->fd, data, *dataLength, 0);
}
while (bytes == -1 && (errno == EINTR || errno == EAGAIN));
if (bytes == *dataLength)
{
result = 0;
}
else if (bytes > 0)
{
*dataLength = bytes;
result = errSSLWouldBlock;
}
else
{
*dataLength = 0;
if (bytes == 0)
result = errSSLClosedGraceful;
else if (errno == EAGAIN)
result = errSSLWouldBlock;
else
result = errSSLClosedAbort;
}
return (result);
}
#endif
#if defined(HAVE_SSL) && defined(HAVE_GNUTLS)
ssize_t
_httpReadGNUTLS(
gnutls_transport_ptr ptr,
void *data,
size_t length)
{
http_t *http;
http = (http_t *)ptr;
if (!http->blocking)
{
if (!_httpWait(http, 10000, 0))
{
http->error = ETIMEDOUT;
return (-1);
}
}
return (recv(http->fd, data, length, 0));
}
#endif
int
httpReconnect(http_t *http)
{
http_addrlist_t *addr;
#ifdef DEBUG
http_addrlist_t *current;
char temp[256];
#endif
DEBUG_printf(("httpReconnect(http=%p)", http));
if (!http)
return (-1);
#ifdef HAVE_SSL
if (http->tls)
{
DEBUG_puts("2httpReconnect: Shutting down SSL/TLS...");
http_shutdown_ssl(http);
}
#endif
if (http->fd >= 0)
{
DEBUG_printf(("2httpReconnect: Closing socket %d...", http->fd));
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif
http->fd = -1;
}
#ifdef DEBUG
for (current = http->addrlist; current; current = current->next)
DEBUG_printf(("2httpReconnect: Address %s:%d",
httpAddrString(&(current->addr), temp, sizeof(temp)),
_httpAddrPort(&(current->addr))));
#endif
if ((addr = httpAddrConnect(http->addrlist, &(http->fd))) == NULL)
{
#ifdef WIN32
http->error = WSAGetLastError();
#else
http->error = errno;
#endif
http->status = HTTP_ERROR;
DEBUG_printf(("1httpReconnect: httpAddrConnect failed: %s",
strerror(http->error)));
return (-1);
}
DEBUG_printf(("2httpReconnect: New socket=%d", http->fd));
http->hostaddr = &(addr->addr);
http->error = 0;
http->status = HTTP_CONTINUE;
#ifdef HAVE_SSL
if (http->encryption == HTTP_ENCRYPT_ALWAYS)
{
if (http_setup_ssl(http) != 0)
{
# ifdef WIN32
closesocket(http->fd);
# else
close(http->fd);
# endif
return (-1);
}
}
else if (http->encryption == HTTP_ENCRYPT_REQUIRED)
return (http_upgrade(http));
#endif
DEBUG_printf(("1httpReconnect: Connected to %s:%d...",
httpAddrString(http->hostaddr, temp, sizeof(temp)),
_httpAddrPort(http->hostaddr)));
return (0);
}
void
httpSetAuthString(http_t *http,
const char *scheme,
const char *data)
{
if (!http)
return;
if (http->authstring && http->authstring != http->_authstring)
free(http->authstring);
http->authstring = http->_authstring;
if (scheme)
{
int len = (int)strlen(scheme) + (data ? (int)strlen(data) + 1 : 0) + 1;
char *temp;
if (len > (int)sizeof(http->_authstring))
{
if ((temp = malloc(len)) == NULL)
len = sizeof(http->_authstring);
else
http->authstring = temp;
}
if (data)
snprintf(http->authstring, len, "%s %s", scheme, data);
else
strlcpy(http->authstring, scheme, len);
}
else
{
http->_authstring[0] = '\0';
}
}
void
httpSetCookie(http_t *http,
const char *cookie)
{
if (!http)
return;
if (http->cookie)
free(http->cookie);
if (cookie)
http->cookie = strdup(cookie);
else
http->cookie = NULL;
}
void
httpSetExpect(http_t *http,
http_status_t expect)
{
if (http)
http->expect = expect;
}
void
httpSetField(http_t *http,
http_field_t field,
const char *value)
{
if (http == NULL ||
field < HTTP_FIELD_ACCEPT_LANGUAGE ||
field > HTTP_FIELD_WWW_AUTHENTICATE ||
value == NULL)
return;
strlcpy(http->fields[field], value, HTTP_MAX_VALUE);
if (field == HTTP_FIELD_AUTHORIZATION)
{
if (http->field_authorization)
free(http->field_authorization);
http->field_authorization = strdup(value);
}
else if (field == HTTP_FIELD_HOST)
{
char *ptr = strchr(value, ':');
if (value[0] != '[' && ptr && strchr(ptr + 1, ':'))
{
snprintf(http->fields[HTTP_FIELD_HOST],
sizeof(http->fields[HTTP_FIELD_HOST]), "[%s]", value);
}
else
{
ptr = http->fields[HTTP_FIELD_HOST];
if (*ptr)
{
ptr += strlen(ptr) - 1;
if (*ptr == '.')
*ptr = '\0';
}
}
}
}
void
httpSetLength(http_t *http,
size_t length)
{
if (!http)
return;
if (!length)
{
strcpy(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked");
http->fields[HTTP_FIELD_CONTENT_LENGTH][0] = '\0';
}
else
{
http->fields[HTTP_FIELD_TRANSFER_ENCODING][0] = '\0';
snprintf(http->fields[HTTP_FIELD_CONTENT_LENGTH], HTTP_MAX_VALUE,
CUPS_LLFMT, CUPS_LLCAST length);
}
}
int
httpTrace(http_t *http,
const char *uri)
{
return (http_send(http, HTTP_TRACE, uri));
}
http_status_t
httpUpdate(http_t *http)
{
char line[32768],
*value;
http_field_t field;
int major, minor,
status;
DEBUG_printf(("httpUpdate(http=%p), state=%s", http,
http_states[http->state]));
if (http->wused)
{
DEBUG_puts("2httpUpdate: flushing buffer...");
if (httpFlushWrite(http) < 0)
return (HTTP_ERROR);
}
if (http->state == HTTP_WAITING)
return (HTTP_CONTINUE);
while (httpGets(line, sizeof(line), http) != NULL)
{
DEBUG_printf(("2httpUpdate: Got \"%s\"", line));
if (line[0] == '\0')
{
if (http->status == HTTP_CONTINUE)
return (http->status);
if (http->status < HTTP_BAD_REQUEST)
http->digest_tries = 0;
#ifdef HAVE_SSL
if (http->status == HTTP_SWITCHING_PROTOCOLS && !http->tls)
{
if (http_setup_ssl(http) != 0)
{
# ifdef WIN32
closesocket(http->fd);
# else
close(http->fd);
# endif
return (HTTP_ERROR);
}
return (HTTP_CONTINUE);
}
#endif
httpGetLength2(http);
switch (http->state)
{
case HTTP_GET :
case HTTP_POST :
case HTTP_POST_RECV :
case HTTP_PUT :
http->state ++;
case HTTP_POST_SEND :
case HTTP_HEAD :
break;
default :
http->state = HTTP_WAITING;
break;
}
return (http->status);
}
else if (!strncmp(line, "HTTP/", 5))
{
if (sscanf(line, "HTTP/%d.%d%d", &major, &minor, &status) != 3)
return (HTTP_ERROR);
http->version = (http_version_t)(major * 100 + minor);
http->status = (http_status_t)status;
}
else if ((value = strchr(line, ':')) != NULL)
{
*value++ = '\0';
while (_cups_isspace(*value))
value ++;
if (!strcasecmp(line, "expect"))
{
http->expect = (http_status_t)atoi(value);
}
else if (!strcasecmp(line, "cookie"))
{
httpSetCookie(http, value);
}
else if ((field = http_field(line)) == HTTP_FIELD_UNKNOWN)
{
DEBUG_printf(("1httpUpdate: unknown field %s seen!", line));
continue;
}
else
httpSetField(http, field, value);
}
else
{
DEBUG_printf(("1httpUpdate: Bad response line \"%s\"!", line));
http->status = HTTP_ERROR;
return (HTTP_ERROR);
}
}
if (http->error == EPIPE && http->status > HTTP_CONTINUE)
{
DEBUG_printf(("1httpUpdate: Returning status %d...", http->status));
return (http->status);
}
if (http->error)
{
DEBUG_printf(("1httpUpdate: socket error %d - %s", http->error,
strerror(http->error)));
http->status = HTTP_ERROR;
return (HTTP_ERROR);
}
return (HTTP_CONTINUE);
}
int
_httpWait(http_t *http,
int msec,
int usessl)
{
#ifdef HAVE_POLL
struct pollfd pfd;
#else
fd_set input_set;
struct timeval timeout;
#endif
int nfds;
DEBUG_printf(("4_httpWait(http=%p, msec=%d, usessl=%d)", http, msec, usessl));
if (http->fd < 0)
return (0);
#ifdef HAVE_SSL
if (http->tls && usessl)
{
# ifdef HAVE_LIBSSL
if (SSL_pending((SSL *)(http->tls)))
return (1);
# elif defined(HAVE_GNUTLS)
if (gnutls_record_check_pending(((http_tls_t *)(http->tls))->session))
return (1);
# elif defined(HAVE_CDSASSL)
size_t bytes;
if (!SSLGetBufferedReadSize(((http_tls_t *)(http->tls))->session, &bytes) &&
bytes > 0)
return (1);
# endif
}
#endif
#ifdef HAVE_POLL
pfd.fd = http->fd;
pfd.events = POLLIN;
while ((nfds = poll(&pfd, 1, msec)) < 0 &&
(errno == EINTR || errno == EAGAIN));
#else
do
{
FD_ZERO(&input_set);
FD_SET(http->fd, &input_set);
DEBUG_printf(("6_httpWait: msec=%d, http->fd=%d", msec, http->fd));
if (msec >= 0)
{
timeout.tv_sec = msec / 1000;
timeout.tv_usec = (msec % 1000) * 1000;
nfds = select(http->fd + 1, &input_set, NULL, NULL, &timeout);
}
else
nfds = select(http->fd + 1, &input_set, NULL, NULL, NULL);
DEBUG_printf(("6_httpWait: select() returned %d...", nfds));
}
# ifdef WIN32
while (nfds < 0 && WSAGetLastError() == WSAEINTR);
# else
while (nfds < 0 && (errno == EINTR || errno == EAGAIN));
# endif
#endif
DEBUG_printf(("5_httpWait: returning with nfds=%d...", nfds));
return (nfds > 0);
}
int
httpWait(http_t *http,
int msec)
{
if (http == NULL)
return (0);
if (http->used)
return (1);
if (http->wused)
{
if (httpFlushWrite(http) < 0)
return (0);
}
return (_httpWait(http, msec, 1));
}
int
httpWrite(http_t *http,
const char *buffer,
int length)
{
return ((int)httpWrite2(http, buffer, length));
}
ssize_t
httpWrite2(http_t *http,
const char *buffer,
size_t length)
{
ssize_t bytes;
DEBUG_printf(("httpWrite2(http=%p, buffer=%p, length=" CUPS_LLFMT ")", http,
buffer, CUPS_LLCAST length));
if (http == NULL || buffer == NULL)
return (-1);
http->activity = time(NULL);
if (length > 0)
{
if (http->wused && (length + http->wused) > sizeof(http->wbuffer))
{
DEBUG_printf(("2httpWrite2: Flushing buffer (wused=%d, length="
CUPS_LLFMT ")", http->wused, CUPS_LLCAST length));
httpFlushWrite(http);
}
if ((length + http->wused) <= sizeof(http->wbuffer) &&
length < sizeof(http->wbuffer))
{
DEBUG_printf(("2httpWrite2: Copying " CUPS_LLFMT " bytes to wbuffer...",
CUPS_LLCAST length));
memcpy(http->wbuffer + http->wused, buffer, length);
http->wused += (int)length;
bytes = (ssize_t)length;
}
else
{
DEBUG_printf(("2httpWrite2: Writing " CUPS_LLFMT " bytes to socket...",
CUPS_LLCAST length));
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
bytes = (ssize_t)http_write_chunk(http, buffer, (int)length);
else
bytes = (ssize_t)http_write(http, buffer, (int)length);
DEBUG_printf(("2httpWrite2: Wrote " CUPS_LLFMT " bytes...",
CUPS_LLCAST bytes));
}
if (http->data_encoding == HTTP_ENCODE_LENGTH)
http->data_remaining -= bytes;
}
else
bytes = 0;
if ((http->data_encoding == HTTP_ENCODE_CHUNKED && length == 0) ||
(http->data_encoding == HTTP_ENCODE_LENGTH && http->data_remaining == 0))
{
DEBUG_puts("2httpWrite: changing states...");
if (http->wused)
httpFlushWrite(http);
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
{
http_write(http, "0\r\n\r\n", 5);
http->data_encoding = HTTP_ENCODE_LENGTH;
http->data_remaining = 0;
}
if (http->state == HTTP_POST_RECV)
http->state ++;
else if (http->state == HTTP_PUT_RECV)
http->state = HTTP_STATUS;
else
http->state = HTTP_WAITING;
}
return (bytes);
}
#if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
OSStatus
_httpWriteCDSA(
SSLConnectionRef connection,
const void *data,
size_t *dataLength)
{
OSStatus result;
ssize_t bytes;
http_t *http;
http = (http_t *)connection;
do
{
bytes = write(http->fd, data, *dataLength);
}
while (bytes == -1 && (errno == EINTR || errno == EAGAIN));
if (bytes == *dataLength)
{
result = 0;
}
else if (bytes >= 0)
{
*dataLength = bytes;
result = errSSLWouldBlock;
}
else
{
*dataLength = 0;
if (errno == EAGAIN)
result = errSSLWouldBlock;
else
result = errSSLClosedAbort;
}
return (result);
}
#endif
#if defined(HAVE_SSL) && defined(HAVE_GNUTLS)
ssize_t
_httpWriteGNUTLS(
gnutls_transport_ptr ptr,
const void *data,
size_t length)
{
return (send(((http_t *)ptr)->fd, data, length, 0));
}
#endif
#if defined(HAVE_SSL) && defined(HAVE_LIBSSL)
static long
http_bio_ctrl(BIO *h,
int cmd,
long arg1,
void *arg2)
{
switch (cmd)
{
default :
return (0);
case BIO_CTRL_RESET :
h->ptr = NULL;
return (0);
case BIO_C_SET_FILE_PTR :
h->ptr = arg2;
h->init = 1;
return (1);
case BIO_C_GET_FILE_PTR :
if (arg2)
{
*((void **)arg2) = h->ptr;
return (1);
}
else
return (0);
case BIO_CTRL_DUP :
case BIO_CTRL_FLUSH :
return (1);
}
}
static int
http_bio_free(BIO *h)
{
if (!h)
return (0);
if (h->shutdown)
{
h->init = 0;
h->flags = 0;
}
return (1);
}
static int
http_bio_new(BIO *h)
{
if (!h)
return (0);
h->init = 0;
h->num = 0;
h->ptr = NULL;
h->flags = 0;
return (1);
}
static int
http_bio_puts(BIO *h,
const char *str)
{
#ifdef WIN32
return (send(((http_t *)h->ptr)->fd, str, (int)strlen(str), 0));
#else
return (send(((http_t *)h->ptr)->fd, str, strlen(str), 0));
#endif
}
static int
http_bio_read(BIO *h,
char *buf,
int size)
{
http_t *http;
http = (http_t *)h->ptr;
if (!http->blocking)
{
if (!_httpWait(http, 10000, 0))
{
#ifdef WIN32
http->error = WSAETIMEDOUT;
#else
http->error = ETIMEDOUT;
#endif
return (-1);
}
}
return (recv(http->fd, buf, size, 0));
}
static int
http_bio_write(BIO *h,
const char *buf,
int num)
{
return (send(((http_t *)h->ptr)->fd, buf, num, 0));
}
#endif
#ifdef DEBUG
static void
http_debug_hex(const char *prefix,
const char *buffer,
int bytes)
{
int i, j,
ch;
char line[255],
*start,
*ptr;
if (_cups_debug_fd < 0 || _cups_debug_level < 6)
return;
DEBUG_printf(("6%s: %d bytes:\n", prefix, bytes));
snprintf(line, sizeof(line), "6%s: ", prefix);
start = line + strlen(line);
for (i = 0; i < bytes; i += 16)
{
for (j = 0, ptr = start; j < 16 && (i + j) < bytes; j ++, ptr += 2)
sprintf(ptr, "%02X", buffer[i + j] & 255);
while (j < 16)
{
strcpy(ptr, " ");
ptr += 2;
j ++;
}
strcpy(ptr, " ");
ptr += 2;
for (j = 0; j < 16 && (i + j) < bytes; j ++)
{
ch = buffer[i + j] & 255;
if (ch < ' ' || ch >= 127)
ch = '.';
*ptr++ = ch;
}
*ptr = '\0';
DEBUG_puts(line);
}
}
#endif
static http_field_t
http_field(const char *name)
{
int i;
for (i = 0; i < HTTP_FIELD_MAX; i ++)
if (strcasecmp(name, http_fields[i]) == 0)
return ((http_field_t)i);
return (HTTP_FIELD_UNKNOWN);
}
#ifdef HAVE_SSL
static int
http_read_ssl(http_t *http,
char *buf,
int len)
{
# if defined(HAVE_LIBSSL)
return (SSL_read((SSL *)(http->tls), buf, len));
# elif defined(HAVE_GNUTLS)
ssize_t result;
result = gnutls_record_recv(((http_tls_t *)(http->tls))->session, buf, len);
if (result < 0 && !errno)
{
switch (result)
{
case GNUTLS_E_INTERRUPTED :
errno = EINTR;
break;
case GNUTLS_E_AGAIN :
errno = EAGAIN;
break;
default :
errno = EPIPE;
break;
}
result = -1;
}
return ((int)result);
# elif defined(HAVE_CDSASSL)
int result;
OSStatus error;
size_t processed;
error = SSLRead(((http_tls_t *)http->tls)->session, buf, len, &processed);
switch (error)
{
case 0 :
result = (int)processed;
break;
case errSSLClosedGraceful :
result = 0;
break;
case errSSLWouldBlock :
if (processed)
result = (int)processed;
else
{
result = -1;
errno = EINTR;
}
break;
default :
errno = EPIPE;
result = -1;
break;
}
return (result);
# endif
}
#endif
#if defined(HAVE_LIBSSL) && defined(HAVE_PTHREAD_H)
static void
http_locking_cb(int mode,
int type,
const char *file,
int line)
{
if (mode & CRYPTO_LOCK)
pthread_mutex_lock(http_locks + type);
else
pthread_mutex_unlock(http_locks + type);
}
#endif
static int
http_send(http_t *http,
http_state_t request,
const char *uri)
{
int i;
char buf[1024];
static const char * const codes[] =
{
NULL,
"OPTIONS",
"GET",
NULL,
"HEAD",
"POST",
NULL,
NULL,
"PUT",
NULL,
"DELETE",
"TRACE",
"CLOSE"
};
DEBUG_printf(("7http_send(http=%p, request=HTTP_%s, uri=\"%s\")",
http, codes[request], uri));
if (http == NULL || uri == NULL)
return (-1);
if (!http->fields[HTTP_FIELD_USER_AGENT][0])
httpSetField(http, HTTP_FIELD_USER_AGENT, CUPS_MINIMAL);
_httpEncodeURI(buf, uri, sizeof(buf));
if (http->status == HTTP_ERROR || http->status >= HTTP_BAD_REQUEST)
if (httpReconnect(http))
return (-1);
if (http->wused)
{
if (httpFlushWrite(http) < 0)
if (httpReconnect(http))
return (-1);
}
http->state = request;
http->data_encoding = HTTP_ENCODE_FIELDS;
if (request == HTTP_POST || request == HTTP_PUT)
http->state ++;
http->status = HTTP_CONTINUE;
#ifdef HAVE_SSL
if (http->encryption == HTTP_ENCRYPT_REQUIRED && !http->tls)
{
httpSetField(http, HTTP_FIELD_CONNECTION, "Upgrade");
httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.0,SSL/2.0,SSL/3.0");
}
#endif
if (httpPrintf(http, "%s %s HTTP/1.1\r\n", codes[request], buf) < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
for (i = 0; i < HTTP_FIELD_MAX; i ++)
if (http->fields[i][0] != '\0')
{
DEBUG_printf(("9http_send: %s: %s", http_fields[i],
httpGetField(http, i)));
if (httpPrintf(http, "%s: %s\r\n", http_fields[i],
httpGetField(http, i)) < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
}
if (http->cookie)
if (httpPrintf(http, "Cookie: $Version=0; %s\r\n", http->cookie) < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
if (http->expect == HTTP_CONTINUE &&
(http->state == HTTP_POST_RECV || http->state == HTTP_PUT_RECV))
if (httpPrintf(http, "Expect: 100-continue\r\n") < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
if (httpPrintf(http, "\r\n") < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
if (httpFlushWrite(http) < 0)
return (-1);
httpGetLength2(http);
httpClearFields(http);
if (http->field_authorization && http->authstring &&
(!strncmp(http->authstring, "Negotiate", 9) ||
!strncmp(http->authstring, "AuthRef", 7)))
{
http->_authstring[0] = '\0';
if (http->authstring != http->_authstring)
free(http->authstring);
http->authstring = http->_authstring;
}
return (0);
}
#ifdef HAVE_SSL
static int
http_setup_ssl(http_t *http)
{
# ifdef HAVE_LIBSSL
SSL_CTX *context;
SSL *conn;
BIO *bio;
# elif defined(HAVE_GNUTLS)
http_tls_t *conn;
gnutls_certificate_client_credentials *credentials;
# elif defined(HAVE_CDSASSL)
OSStatus error;
http_tls_t *conn;
# endif
DEBUG_printf(("7http_setup_ssl(http=%p)", http));
# ifdef HAVE_LIBSSL
context = SSL_CTX_new(SSLv23_client_method());
SSL_CTX_set_options(context, SSL_OP_NO_SSLv2);
bio = BIO_new(_httpBIOMethods());
BIO_ctrl(bio, BIO_C_SET_FILE_PTR, 0, (char *)http);
conn = SSL_new(context);
SSL_set_bio(conn, bio, bio);
if (SSL_connect(conn) != 1)
{
# ifdef DEBUG
unsigned long error;
while ((error = ERR_get_error()) != 0)
DEBUG_printf(("8http_setup_ssl: %s", ERR_error_string(error, NULL)));
# endif
SSL_CTX_free(context);
SSL_free(conn);
# ifdef WIN32
http->error = WSAGetLastError();
# else
http->error = errno;
# endif
http->status = HTTP_ERROR;
return (HTTP_ERROR);
}
# elif defined(HAVE_GNUTLS)
if ((conn = (http_tls_t *)malloc(sizeof(http_tls_t))) == NULL)
{
http->error = errno;
http->status = HTTP_ERROR;
return (-1);
}
credentials = (gnutls_certificate_client_credentials *)
malloc(sizeof(gnutls_certificate_client_credentials));
if (credentials == NULL)
{
free(conn);
http->error = errno;
http->status = HTTP_ERROR;
return (-1);
}
gnutls_certificate_allocate_credentials(credentials);
gnutls_init(&(conn->session), GNUTLS_CLIENT);
gnutls_set_default_priority(conn->session);
gnutls_credentials_set(conn->session, GNUTLS_CRD_CERTIFICATE, *credentials);
gnutls_transport_set_ptr(conn->session, (gnutls_transport_ptr)http);
gnutls_transport_set_pull_function(conn->session, _httpReadGNUTLS);
gnutls_transport_set_push_function(conn->session, _httpWriteGNUTLS);
if ((gnutls_handshake(conn->session)) != GNUTLS_E_SUCCESS)
{
http->error = errno;
http->status = HTTP_ERROR;
gnutls_deinit(conn->session);
gnutls_certificate_free_credentials(*credentials);
free(credentials);
free(conn);
return (-1);
}
conn->credentials = credentials;
# elif defined(HAVE_CDSASSL)
conn = (http_tls_t *)calloc(1, sizeof(http_tls_t));
if (conn == NULL)
return (-1);
if ((error = SSLNewContext(false, &conn->session)))
{
http->error = error;
http->status = HTTP_ERROR;
free(conn);
return (-1);
}
error = SSLSetConnection(conn->session, http);
if (!error)
error = SSLSetIOFuncs(conn->session, _httpReadCDSA, _httpWriteCDSA);
if (!error)
error = SSLSetAllowsExpiredCerts(conn->session, true);
if (!error)
error = SSLSetAllowsAnyRoot(conn->session, true);
if (!error)
error = SSLSetProtocolVersionEnabled(conn->session, kSSLProtocol2, false);
if (!error)
{
while ((error = SSLHandshake(conn->session)) == errSSLWouldBlock)
usleep(1000);
}
if (error)
{
http->error = error;
http->status = HTTP_ERROR;
SSLDisposeContext(conn->session);
free(conn);
return (-1);
}
# endif
http->tls = conn;
return (0);
}
#endif
#ifdef HAVE_SSL
static void
http_shutdown_ssl(http_t *http)
{
# ifdef HAVE_LIBSSL
SSL_CTX *context;
SSL *conn;
conn = (SSL *)(http->tls);
context = SSL_get_SSL_CTX(conn);
SSL_shutdown(conn);
SSL_CTX_free(context);
SSL_free(conn);
# elif defined(HAVE_GNUTLS)
http_tls_t *conn;
gnutls_certificate_client_credentials *credentials;
conn = (http_tls_t *)(http->tls);
credentials = (gnutls_certificate_client_credentials *)(conn->credentials);
gnutls_bye(conn->session, GNUTLS_SHUT_RDWR);
gnutls_deinit(conn->session);
gnutls_certificate_free_credentials(*credentials);
free(credentials);
free(conn);
# elif defined(HAVE_CDSASSL)
http_tls_t *conn;
conn = (http_tls_t *)(http->tls);
while (SSLClose(conn->session) == errSSLWouldBlock)
usleep(1000);
SSLDisposeContext(conn->session);
if (conn->certsArray)
CFRelease(conn->certsArray);
free(conn);
# endif
http->tls = NULL;
}
#endif
#if defined(HAVE_LIBSSL) && defined(HAVE_PTHREAD_H)
static unsigned long
http_threadid_cb(void)
{
return ((unsigned long)pthread_self());
}
#endif
#ifdef HAVE_SSL
static int
http_upgrade(http_t *http)
{
int ret;
http_t myhttp;
DEBUG_printf(("7http_upgrade(%p)", http));
httpFlush(http);
memcpy(&myhttp, http, sizeof(myhttp));
http->field_authorization = NULL;
httpClearFields(http);
httpSetField(http, HTTP_FIELD_CONNECTION, "upgrade");
httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.0, SSL/2.0, SSL/3.0");
if ((ret = httpOptions(http, "*")) == 0)
{
while (httpUpdate(http) == HTTP_CONTINUE);
}
memcpy(http->fields, myhttp.fields, sizeof(http->fields));
http->data_encoding = myhttp.data_encoding;
http->data_remaining = myhttp.data_remaining;
http->_data_remaining = myhttp._data_remaining;
http->expect = myhttp.expect;
http->field_authorization = myhttp.field_authorization;
http->digest_tries = myhttp.digest_tries;
if (!http->tls)
{
DEBUG_puts("8http_upgrade: Server does not support HTTP upgrade!");
# ifdef WIN32
closesocket(http->fd);
# else
close(http->fd);
# endif
http->fd = -1;
return (-1);
}
else
return (ret);
}
#endif
static int
http_write(http_t *http,
const char *buffer,
int length)
{
int tbytes,
bytes;
http->error = 0;
tbytes = 0;
while (length > 0)
{
#ifdef HAVE_SSL
if (http->tls)
bytes = http_write_ssl(http, buffer, length);
else
#endif
bytes = send(http->fd, buffer, length, 0);
if (bytes < 0)
{
#ifdef WIN32
if (WSAGetLastError() != http->error)
{
http->error = WSAGetLastError();
continue;
}
#else
if (errno == EINTR || errno == EAGAIN)
continue;
else if (errno != http->error && errno != ECONNRESET)
{
http->error = errno;
continue;
}
#endif
DEBUG_puts("8http_write: error writing data...");
return (-1);
}
buffer += bytes;
tbytes += bytes;
length -= bytes;
}
#ifdef DEBUG
http_debug_hex("http_write", buffer - tbytes, tbytes);
#endif
return (tbytes);
}
static int
http_write_chunk(http_t *http,
const char *buffer,
int length)
{
char header[255];
int bytes;
DEBUG_printf(("7http_write_chunk(http=%p, buffer=%p, length=%d)",
http, buffer, length));
sprintf(header, "%x\r\n", length);
if (http_write(http, header, (int)strlen(header)) < 0)
{
DEBUG_puts("8http_write_chunk: http_write of length failed!");
return (-1);
}
if ((bytes = http_write(http, buffer, length)) < 0)
{
DEBUG_puts("8http_write_chunk: http_write of buffer failed!");
return (-1);
}
if (http_write(http, "\r\n", 2) < 0)
{
DEBUG_puts("8http_write_chunk: http_write of CR LF failed!");
return (-1);
}
return (bytes);
}
#ifdef HAVE_SSL
static int
http_write_ssl(http_t *http,
const char *buf,
int len)
{
# if defined(HAVE_LIBSSL)
return (SSL_write((SSL *)(http->tls), buf, len));
# elif defined(HAVE_GNUTLS)
ssize_t result;
result = gnutls_record_send(((http_tls_t *)(http->tls))->session, buf, len);
if (result < 0 && !errno)
{
switch (result)
{
case GNUTLS_E_INTERRUPTED :
errno = EINTR;
break;
case GNUTLS_E_AGAIN :
errno = EAGAIN;
break;
default :
errno = EPIPE;
break;
}
result = -1;
}
return ((int)result);
# elif defined(HAVE_CDSASSL)
int result;
OSStatus error;
size_t processed;
error = SSLWrite(((http_tls_t *)http->tls)->session, buf, len, &processed);
switch (error)
{
case 0 :
result = (int)processed;
break;
case errSSLClosedGraceful :
result = 0;
break;
case errSSLWouldBlock :
if (processed)
result = (int)processed;
else
{
result = -1;
errno = EINTR;
}
break;
default :
errno = EPIPE;
result = -1;
break;
}
return (result);
# endif
}
#endif