*
* HTTP routines for the Common UNIX Printing System (CUPS).
*
- * Copyright 1997-2005 by Easy Software Products, all rights reserved.
+ * Copyright 1997-2006 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
* property of Easy Software Products and are protected by Federal
*
* Contents:
*
+ * httpBlocking() - Set blocking/non-blocking behavior on a connection.
* httpCheck() - Check to see if there is a pending response from
* the server.
* httpClearCookie() - Clear the cookie value(s).
+ * httpClearFields() - Clear HTTP request fields.
* httpClose() - Close an HTTP connection...
* httpConnect() - Connect to a HTTP server.
* httpConnectEncrypt() - Connect to a HTTP server using encryption.
- * httpDecode64() - Base64-decode a string.
- * httpDecode64_2() - Base64-decode a string.
* httpDelete() - Send a DELETE request to the server.
- * httpEncode64() - Base64-encode a string.
- * httpEncode64_2() - Base64-encode a string.
* httpEncryption() - Set the required encryption on the link.
+ * httpError() - Get the last error on a connection.
* httpFlush() - Flush data from a HTTP connection.
* httpFlushWrite() - Flush data in write buffer.
* httpGet() - Send a GET request to the server.
- * httpGetDateString() - Get a formatted date/time string from a time value.
- * httpGetDateString2() - Get a formatted date/time string from a time value.
- * httpGetDateTime() - Get a time value from a formatted date/time string.
+ * httpGetBlocking() - Get the blocking/non-block state of a connection.
+ * httpGetCookie() - Get any cookie data from the response.
+ * httpGetFd() - Get the file descriptor associated with a
+ * connection.
+ * httpGetField() - Get a field value from a request/response.
* httpGetLength() - Get the amount of data remaining from the
* content-length or transfer-encoding fields.
* httpGetLength2() - Get the amount of data remaining from the
* content-length or transfer-encoding fields.
+ * httpGetStatus() - Get the status of the last HTTP request.
* httpGetSubField() - Get a sub-field value.
* httpGets() - Get a line of text from a HTTP connection.
* httpHead() - Send a HEAD request to the server.
* httpPrintf() - Print a formatted string to a HTTP connection.
* httpPut() - Send a PUT request to the server.
* httpRead() - Read data from a HTTP connection.
+ * httpRead2() - Read data from a HTTP connection.
+ * _httpReadCDSA() - Read function for CDSA decryption code.
* httpReconnect() - Reconnect to a HTTP server...
* httpSetCookie() - Set the cookie value(s)...
+ * httpSetExpect() - Set the Expect: header in a request.
* httpSetField() - Set the value of an HTTP header.
* httpSetLength() - Set the content-length and transfer-encoding.
* httpTrace() - Send an TRACE request to the server.
* httpUpdate() - Update the current HTTP state for incoming data.
* httpWait() - Wait for data available on a connection.
* httpWrite() - Write data to a HTTP connection.
+ * httpWrite2() - Write data to a HTTP connection.
+ * _httpWriteCDSA() - Write function for CDSA encryption code.
* http_field() - Return the field index for a field name.
* http_read_ssl() - Read from a SSL/TLS connection.
* http_send() - Send a request with all fields and the trailing
* http_wait() - Wait for data available on a connection.
* http_write() - Write data to a connection.
* http_write_ssl() - Write to a SSL/TLS connection.
- * http_read_cdsa() - Read function for CDSA decryption code.
- * http_write_cdsa() - Write function for CDSA encryption code.
*/
/*
static int http_write_chunk(http_t *http, const char *buffer,
int length);
#ifdef HAVE_SSL
-# ifdef HAVE_CDSASSL
-static OSStatus http_read_cdsa(SSLConnectionRef connection, void *data, size_t *dataLength);
-# endif /* HAVE_CDSASSL */
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);
-# ifdef HAVE_CDSASSL
-static OSStatus http_write_cdsa(SSLConnectionRef connection, const void *data, size_t *dataLength);
-# endif /* HAVE_CDSASSL */
static int http_write_ssl(http_t *http, const char *buf, int len);
#endif /* HAVE_SSL */
"User-Agent",
"WWW-Authenticate"
};
-static const char * const http_days[7] =
- {
- "Sun",
- "Mon",
- "Tue",
- "Wed",
- "Thu",
- "Fri",
- "Sat"
- };
-static const char * const http_months[12] =
- {
- "Jan",
- "Feb",
- "Mar",
- "Apr",
- "May",
- "Jun",
- "Jul",
- "Aug",
- "Sep",
- "Oct",
- "Nov",
- "Dec"
- };
+
+
+/*
+ * 'httpBlocking()' - Set blocking/non-blocking behavior on a connection.
+ */
+
+void
+httpBlocking(http_t *http, /* I - HTTP connection */
+ int b) /* I - 1 = blocking, 0 = non-blocking */
+{
+ if (http)
+ http->blocking = b;
+}
/*
* 'httpCheck()' - Check to see if there is a pending response from the server.
*/
-int /* O - 0 = no data, 1 = data available */
-httpCheck(http_t *http) /* I - HTTP connection */
+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 - Connection */
+httpClearCookie(http_t *http) /* I - HTTP connection */
{
if (!http)
return;
}
+/*
+ * 'httpClearFields()' - Clear HTTP request fields.
+ */
+
+void
+httpClearFields(http_t *http) /* I - HTTP connection */
+{
+ if (http)
+ {
+ memset(http->fields, 0, sizeof(http->fields));
+ httpSetField(http, HTTP_FIELD_HOST, http->hostname);
+
+ http->expect = (http_status_t)0;
+ }
+}
+
+
/*
* 'httpClose()' - Close an HTTP connection...
*/
void
-httpClose(http_t *http) /* I - Connection to close */
+httpClose(http_t *http) /* I - HTTP connection */
{
DEBUG_printf(("httpClose(http=%p)\n", http));
if (!http)
return;
+ httpAddrFreeList(http->addrlist);
+
if (http->input_set)
free(http->input_set);
int port, /* I - Port number */
http_encryption_t encryption) /* I - Type of encryption to use */
{
- int i; /* Looping var */
http_t *http; /* New HTTP connection */
- struct hostent *hostaddr; /* Host address data */
+ http_addrlist_t *addrlist; /* Host address data */
+ char service[255]; /* Service name */
DEBUG_printf(("httpConnectEncrypt(host=\"%s\", port=%d, encryption=%d)\n",
* Lookup the host...
*/
- if ((hostaddr = httpGetHostByName(host)) == NULL)
- {
- /*
- * This hack to make users that don't have a localhost entry in
- * their hosts file or DNS happy...
- */
-
- if (strcasecmp(host, "localhost") != 0)
- return (NULL);
- else if ((hostaddr = httpGetHostByName("127.0.0.1")) == NULL)
- return (NULL);
- }
-
- /*
- * Verify that it is an IPv4, IPv6, or domain address...
- */
+ sprintf(service, "%d", port);
- if ((hostaddr->h_addrtype != AF_INET || hostaddr->h_length != 4)
-#ifdef AF_INET6
- && (hostaddr->h_addrtype != AF_INET6 || hostaddr->h_length != 16)
-#endif /* AF_INET6 */
-#ifdef AF_LOCAL
- && (hostaddr->h_addrtype != AF_LOCAL)
-#endif /* AF_LOCAL */
- )
+ if ((addrlist = httpAddrGetList(host, AF_UNSPEC, service)) == NULL)
return (NULL);
/*
strlcpy(http->hostname, host, sizeof(http->hostname));
- for (i = 0; hostaddr->h_addr_list[i]; i ++)
- {
- /*
- * Load the address...
- */
-
- httpAddrLoad(hostaddr, port, i, &(http->hostaddr));
-
- /*
- * Connect to the remote system...
- */
-
- if (!httpReconnect(http))
- return (http);
- }
-
- /*
- * Could not connect to any known address - bail out!
- */
-
- free(http);
- return (NULL);
-}
-
-
-/*
- * 'httpDecode64()' - Base64-decode a string.
- */
-
-char * /* O - Decoded string */
-httpDecode64(char *out, /* I - String to write to */
- const char *in) /* I - String to read from */
-{
- int outlen; /* Output buffer length */
-
-
/*
- * Use the old maximum buffer size for binary compatibility...
+ * Connect to the remote system...
*/
- outlen = 512;
-
- return (httpDecode64_2(out, &outlen, in));
-}
-
-
-/*
- * 'httpDecode64_2()' - Base64-decode a string.
- */
-
-char * /* O - Decoded string */
-httpDecode64_2(char *out, /* I - String to write to */
- int *outlen, /* IO - Size of output string */
- const char *in) /* I - String to read from */
-{
- int pos, /* Bit position */
- base64; /* Value of this character */
- char *outptr, /* Output pointer */
- *outend; /* End of output buffer */
+ http->addrlist = addrlist;
+ if (!httpReconnect(http))
+ return (http);
/*
- * Range check input...
- */
-
- if (!out || !outlen || *outlen < 1 || !in || !*in)
- return (NULL);
-
- /*
- * Convert from base-64 to bytes...
+ * Could not connect to any known address - bail out!
*/
- for (outptr = out, outend = out + *outlen - 1, pos = 0; *in != '\0'; in ++)
- {
- /*
- * Decode this character into a number from 0 to 63...
- */
-
- if (*in >= 'A' && *in <= 'Z')
- base64 = *in - 'A';
- else if (*in >= 'a' && *in <= 'z')
- base64 = *in - 'a' + 26;
- else if (*in >= '0' && *in <= '9')
- base64 = *in - '0' + 52;
- else if (*in == '+')
- base64 = 62;
- else if (*in == '/')
- base64 = 63;
- else if (*in == '=')
- break;
- else
- continue;
+ httpAddrFreeList(addrlist);
- /*
- * Store the result in the appropriate chars...
- */
-
- switch (pos)
- {
- case 0 :
- if (outptr < outend)
- *outptr = base64 << 2;
- pos ++;
- break;
- case 1 :
- if (outptr < outend)
- *outptr++ |= (base64 >> 4) & 3;
- if (outptr < outend)
- *outptr = (base64 << 4) & 255;
- pos ++;
- break;
- case 2 :
- if (outptr < outend)
- *outptr++ |= (base64 >> 2) & 15;
- if (outptr < outend)
- *outptr = (base64 << 6) & 255;
- pos ++;
- break;
- case 3 :
- if (outptr < outend)
- *outptr++ |= base64;
- pos = 0;
- break;
- }
- }
-
- *outptr = '\0';
-
- /*
- * Return the decoded string and size...
- */
-
- *outlen = (int)(outptr - out);
+ free(http);
- return (out);
+ return (NULL);
}
*/
int /* O - Status of call (0 = success) */
-httpDelete(http_t *http, /* I - HTTP data */
+httpDelete(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI to delete */
{
return (http_send(http, HTTP_DELETE, uri));
}
-/*
- * 'httpEncode64()' - Base64-encode a string.
- */
-
-char * /* O - Encoded string */
-httpEncode64(char *out, /* I - String to write to */
- const char *in) /* I - String to read from */
-{
- return (httpEncode64_2(out, 512, in, strlen(in)));
-}
-
-
-/*
- * 'httpEncode64_2()' - Base64-encode a string.
- */
-
-char * /* O - Encoded string */
-httpEncode64_2(char *out, /* I - String to write to */
- int outlen, /* I - Size of output string */
- const char *in, /* I - String to read from */
- int inlen) /* I - Size of input string */
-{
- char *outptr, /* Output pointer */
- *outend; /* End of output buffer */
- static const char base64[] = /* Base64 characters... */
- {
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz"
- "0123456789"
- "+/"
- };
-
-
- /*
- * Range check input...
- */
-
- if (!out || outlen < 1 || !in || inlen < 1)
- return (NULL);
-
- /*
- * Convert bytes to base-64...
- */
-
- for (outptr = out, outend = out + outlen - 1; inlen > 0; in ++, inlen --)
- {
- /*
- * Encode the up to 3 characters as 4 Base64 numbers...
- */
-
- if (outptr < outend)
- *outptr ++ = base64[(in[0] & 255) >> 2];
- if (outptr < outend)
- *outptr ++ = base64[(((in[0] & 255) << 4) | ((in[1] & 255) >> 4)) & 63];
-
- in ++;
- inlen --;
- if (inlen <= 0)
- {
- if (outptr < outend)
- *outptr ++ = '=';
- if (outptr < outend)
- *outptr ++ = '=';
- break;
- }
-
- if (outptr < outend)
- *outptr ++ = base64[(((in[0] & 255) << 2) | ((in[1] & 255) >> 6)) & 63];
-
- in ++;
- inlen --;
- if (inlen <= 0)
- {
- if (outptr < outend)
- *outptr ++ = '=';
- break;
- }
-
- if (outptr < outend)
- *outptr ++ = base64[in[0] & 63];
- }
-
- *outptr = '\0';
-
- /*
- * Return the encoded string...
- */
-
- return (out);
-}
-
-
/*
* 'httpEncryption()' - Set the required encryption on the link.
*/
int /* O - -1 on error, 0 on success */
-httpEncryption(http_t *http, /* I - HTTP data */
+httpEncryption(http_t *http, /* I - HTTP connection */
http_encryption_t e) /* I - New encryption preference */
{
DEBUG_printf(("httpEncryption(http=%p, e=%d)\n", http, e));
}
+/*
+ * 'httpError()' - Get the last error on a connection.
+ */
+
+int /* O - Error code (errno) value */
+httpError(http_t *http) /* I - HTTP connection */
+{
+ if (http)
+ return (http->error);
+ else
+ return (EINVAL);
+}
+
+
/*
* 'httpFlush()' - Flush data from a HTTP connection.
*/
void
-httpFlush(http_t *http) /* I - HTTP data */
+httpFlush(http_t *http) /* I - HTTP connection */
{
char buffer[8192]; /* Junk buffer */
+ int blocking; /* To block or not to block */
DEBUG_printf(("httpFlush(http=%p), state=%d\n", http, http->state));
- while (httpRead(http, buffer, sizeof(buffer)) > 0);
+ /*
+ * Temporarily set non-blocking mode so we don't get stuck in httpRead()...
+ */
+
+ blocking = http->blocking;
+ http->blocking = 0;
+
+ /*
+ * Read any data we can...
+ */
+
+ 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 != HTTP_WAITING && http->fd >= 0)
+ {
+ /*
+ * Didn't get the data back, so close the current connection.
+ */
+
+ http->state = HTTP_WAITING;
+
+#ifdef HAVE_SSL
+ if (http->tls)
+ http_shutdown_ssl(http);
+#endif /* HAVE_SSL */
+
+#ifdef WIN32
+ closesocket(http->fd);
+#else
+ close(http->fd);
+#endif /* WIN32 */
+
+ http->fd = -1;
+ }
}
/*
* 'httpFlushWrite()' - Flush data in write buffer.
+ *
+ * @since CUPS 1.2@
*/
int /* O - Bytes written or -1 on error */
-httpFlushWrite(http_t *http) /* I - HTTP data */
+httpFlushWrite(http_t *http) /* I - HTTP connection */
{
int bytes; /* Bytes written */
*/
int /* O - Status of call (0 = success) */
-httpGet(http_t *http, /* I - HTTP data */
+httpGet(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI to get */
{
return (http_send(http, HTTP_GET, uri));
/*
- * 'httpGetDateString()' - Get a formatted date/time string from a time value.
+ * 'httpGetBlocking()' - Get the blocking/non-block state of a connection.
*
- * @deprecated
+ * @since CUPS 1.2@
*/
-const char * /* O - Date/time string */
-httpGetDateString(time_t t) /* I - UNIX time */
+int /* O - 1 if blocking, 0 if non-blocking */
+httpGetBlocking(http_t *http) /* I - HTTP connection */
{
- _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
-
-
- return (httpGetDateString2(t, cg->http_date, sizeof(cg->http_date)));
+ return (http ? http->blocking : 0);
}
/*
- * 'httpGetDateString2()' - Get a formatted date/time string from a time value.
+ * 'httpGetCookie()' - Get any cookie data from the response.
*/
-const char * /* O - Date/time string */
-httpGetDateString2(time_t t, /* I - UNIX time */
- char *s, /* I - String buffer */
- int slen) /* I - Size of string buffer */
+const char * /* O - Cookie data or NULL */
+httpGetCookie(http_t *http) /* I - HTTP connecion */
{
- struct tm *tdate; /* UNIX date/time data */
+ return (http ? http->cookie : NULL);
+}
- tdate = gmtime(&t);
- snprintf(s, slen, "%s, %02d %s %d %02d:%02d:%02d GMT",
- http_days[tdate->tm_wday], tdate->tm_mday,
- http_months[tdate->tm_mon], tdate->tm_year + 1900,
- tdate->tm_hour, tdate->tm_min, tdate->tm_sec);
+/*
+ * 'httpGetFd()' - Get the file descriptor associated with a connection.
+ *
+ * @since CUPS 1.2@
+ */
- return (s);
+int /* O - File descriptor or -1 if none */
+httpGetFd(http_t *http) /* I - HTTP connection */
+{
+ return (http ? http->fd : -1);
}
/*
- * 'httpGetDateTime()' - Get a time value from a formatted date/time string.
+ * 'httpGetField()' - Get a field value from a request/response.
*/
-time_t /* O - UNIX time */
-httpGetDateTime(const char *s) /* I - Date/time string */
+const char * /* O - Field value */
+httpGetField(http_t *http, /* I - HTTP connection */
+ http_field_t field) /* I - Field to get */
{
- int i; /* Looping var */
- char mon[16]; /* Abbreviated month name */
- int day, year; /* Day of month and year */
- int hour, min, sec; /* Time */
- int days; /* Number of days since 1970 */
- static const int normal_days[] = /* Days to a month, normal years */
- { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
- static const int leap_days[] = /* Days to a month, leap years */
- { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };
+ if (!http || field <= HTTP_FIELD_UNKNOWN || field >= HTTP_FIELD_MAX)
+ return (NULL);
+ else
+ return (http->fields[field]);
+}
- DEBUG_printf(("httpGetDateTime(s=\"%s\")\n", s));
+/*
+ * 'httpGetLength()' - Get the amount of data remaining from the
+ * content-length or transfer-encoding fields.
+ *
+ * This function is deprecated and will not return lengths larger than
+ * 2^31 - 1; use httpGetLength2() instead.
+ *
+ * @deprecated@
+ */
+int /* O - Content length */
+httpGetLength(http_t *http) /* I - HTTP connection */
+{
/*
- * Extract the date and time from the formatted string...
+ * Get the read content length and return the 32-bit value.
*/
- if (sscanf(s, "%*s%d%15s%d%d:%d:%d", &day, mon, &year, &hour, &min, &sec) < 6)
- return (0);
+ if (http)
+ {
+ httpGetLength2(http);
- DEBUG_printf((" day=%d, mon=\"%s\", year=%d, hour=%d, min=%d, sec=%d\n",
- day, mon, year, hour, min, sec));
+ return (http->_data_remaining);
+ }
+ else
+ return (-1);
+}
- /*
- * Convert the month name to a number from 0 to 11.
- */
- for (i = 0; i < 12; i ++)
- if (!strcasecmp(mon, http_months[i]))
- break;
+/*
+ * 'httpGetLength2()' - Get the amount of data remaining from the
+ * content-length or transfer-encoding fields.
+ *
+ * This function returns the complete content length, even for
+ * content larger than 2^31 - 1.
+ *
+ * @since CUPS 1.2@
+ */
- if (i >= 12)
- return (0);
+off_t /* O - Content length */
+httpGetLength2(http_t *http) /* I - HTTP connection */
+{
+ DEBUG_printf(("httpGetLength2(http=%p), state=%d\n", http, http->state));
- DEBUG_printf((" i=%d\n", i));
+ if (!http)
+ return (-1);
- /*
- * Now convert the date and time to a UNIX time value in seconds since
- * 1970. We can't use mktime() since the timezone may not be UTC but
- * the date/time string *is* UTC.
- */
+ if (!strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked"))
+ {
+ DEBUG_puts("httpGetLength2: chunked request!");
+
+ http->data_encoding = HTTP_ENCODE_CHUNKED;
+ http->data_remaining = 0;
+ }
+ else
+ {
+ http->data_encoding = HTTP_ENCODE_LENGTH;
+
+ /*
+ * The following is a hack for HTTP servers that don't send a
+ * content-length or transfer-encoding field...
+ *
+ * If there is no content-length then the connection must close
+ * after the transfer is complete...
+ */
+
+ if (http->fields[HTTP_FIELD_CONTENT_LENGTH][0] == '\0')
+ http->data_remaining = 2147483647;
+ else
+ http->data_remaining = strtoll(http->fields[HTTP_FIELD_CONTENT_LENGTH],
+ NULL, 10);
+
+ DEBUG_printf(("httpGetLength2: content_length=" CUPS_LLFMT "\n",
+ CUPS_LLCAST http->data_remaining));
+ }
- if ((year & 3) == 0 && ((year % 100) != 0 || (year % 400) == 0))
- days = leap_days[i] + day - 1;
+ if (http->data_remaining <= INT_MAX)
+ http->_data_remaining = (int)http->data_remaining;
else
- days = normal_days[i] + day - 1;
+ http->_data_remaining = INT_MAX;
- DEBUG_printf((" days=%d\n", days));
+ return (http->data_remaining);
+}
- days += (year - 1970) * 365 + /* 365 days per year (normally) */
- ((year - 1) / 4 - 492) - /* + leap days */
- ((year - 1) / 100 - 19) + /* - 100 year days */
- ((year - 1) / 400 - 4); /* + 400 year days */
- DEBUG_printf((" days=%d\n", days));
+/*
+ * 'httpGetStatus()' - Get the status of the last HTTP request.
+ *
+ * @since CUPS 1.2@
+ */
- return (days * 86400 + hour * 3600 + min * 60 + sec);
+http_status_t /* O - HTTP status */
+httpGetStatus(http_t *http) /* I - HTTP connection */
+{
+ return (http ? http->status : HTTP_ERROR);
}
/*
* 'httpGetSubField()' - Get a sub-field value.
+ *
+ * @deprecated@
*/
char * /* O - Value or NULL */
-httpGetSubField(http_t *http, /* I - HTTP data */
+httpGetSubField(http_t *http, /* I - HTTP connection */
http_field_t field, /* I - Field index */
const char *name, /* I - Name of sub-field */
char *value) /* O - Value string */
+{
+ return (httpGetSubField2(http, field, name, value, HTTP_MAX_VALUE));
+}
+
+
+/*
+ * 'httpGetSubField2()' - Get a sub-field value.
+ *
+ * @since CUPS 1.2@
+ */
+
+char * /* O - Value or NULL */
+httpGetSubField2(http_t *http, /* I - HTTP connection */
+ http_field_t field, /* I - Field index */
+ const char *name, /* I - Name of sub-field */
+ char *value, /* O - Value string */
+ int valuelen) /* I - Size of value buffer */
{
const char *fptr; /* Pointer into field */
char temp[HTTP_MAX_VALUE], /* Temporary buffer for name */
- *ptr; /* Pointer into string buffer */
+ *ptr, /* Pointer into string buffer */
+ *end; /* End of value buffer */
+ DEBUG_printf(("httpGetSubField2(http=%p, field=%d, name=\"%s\", value=%p, valuelen=%d)\n",
+ http, field, name, value, valuelen));
- DEBUG_printf(("httpGetSubField(http=%p, field=%d, name=\"%s\", value=%p)\n",
- http, field, name, value));
-
- if (http == NULL ||
- field < HTTP_FIELD_ACCEPT_LANGUAGE ||
- field > HTTP_FIELD_WWW_AUTHENTICATE ||
- name == NULL || value == NULL)
+ 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;)
{
/*
*/
for (ptr = temp;
- *fptr && *fptr != '=' && !isspace(*fptr & 255) && ptr < (temp + sizeof(temp) - 1);
+ *fptr && *fptr != '=' && !isspace(*fptr & 255) &&
+ ptr < (temp + sizeof(temp) - 1);
*ptr++ = *fptr++);
*ptr = '\0';
*/
for (ptr = value, fptr ++;
- *fptr && *fptr != '\"' && ptr < (value + HTTP_MAX_VALUE - 1);
+ *fptr && *fptr != '\"' && ptr < end;
*ptr++ = *fptr++);
*ptr = '\0';
*/
for (ptr = value;
- *fptr && !isspace(*fptr & 255) && *fptr != ',' && ptr < (value + HTTP_MAX_VALUE - 1);
+ *fptr && !isspace(*fptr & 255) && *fptr != ',' && ptr < end;
*ptr++ = *fptr++);
*ptr = '\0';
* See if this is the one...
*/
- if (strcmp(name, temp) == 0)
+ if (!strcmp(name, temp))
return (value);
}
}
-/*
- * 'httpGetLength()' - Get the amount of data remaining from the
- * content-length or transfer-encoding fields.
- *
- * This function is deprecated and will not return lengths larger than
- * 2^31 - 1; use httpGetLength2() instead.
- */
-
-int /* O - Content length */
-httpGetLength(http_t *http) /* I - HTTP data */
-{
- /*
- * Get the read content length and return the 32-bit value.
- */
-
- httpGetLength2(http);
-
- return (http->_data_remaining);
-}
-
-
-/*
- * 'httpGetLength2()' - Get the amount of data remaining from the
- * content-length or transfer-encoding fields.
- *
- * This function returns the complete content length, even for
- * content larger than 2^31 - 1.
- */
-
-off_t /* O - Content length */
-httpGetLength2(http_t *http) /* I - HTTP data */
-{
- DEBUG_printf(("httpGetLength2(http=%p), state=%d\n", http, http->state));
-
- if (!strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked"))
- {
- DEBUG_puts("httpGetLength2: chunked request!");
-
- http->data_encoding = HTTP_ENCODE_CHUNKED;
- http->data_remaining = 0;
- }
- else
- {
- http->data_encoding = HTTP_ENCODE_LENGTH;
-
- /*
- * The following is a hack for HTTP servers that don't send a
- * content-length or transfer-encoding field...
- *
- * If there is no content-length then the connection must close
- * after the transfer is complete...
- */
-
- if (http->fields[HTTP_FIELD_CONTENT_LENGTH][0] == '\0')
- http->data_remaining = 2147483647;
- else
- http->data_remaining = strtoll(http->fields[HTTP_FIELD_CONTENT_LENGTH],
- NULL, 10);
-
- DEBUG_printf(("httpGetLength2: content_length=" CUPS_LLFORMAT "\n",
- 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);
-}
-
-
/*
* 'httpGets()' - Get a line of text from a HTTP connection.
*/
char * /* O - Line or NULL */
httpGets(char *line, /* I - Line to read into */
int length, /* I - Max length of buffer */
- http_t *http) /* I - HTTP data */
+ http_t *http) /* I - HTTP connection */
{
char *lineptr, /* Pointer into line */
+ *lineend, /* End of line */
*bufptr, /* Pointer into input buffer */
*bufend; /* Pointer to end of buffer */
- int bytes; /* Number of bytes read */
+ int bytes, /* Number of bytes read */
+ eol; /* End-of-line? */
DEBUG_printf(("httpGets(line=%p, length=%d, http=%p)\n", line, length, http));
return (NULL);
/*
- * Pre-scan the buffer and see if there is a newline in there...
+ * Read a line from the buffer...
*/
+
+ lineptr = line;
+ lineend = line + length - 1;
+ eol = 0;
+
+ while (lineptr < lineend)
+ {
+ /*
+ * Pre-load the buffer as needed...
+ */
#ifdef WIN32
- WSASetLastError(0);
+ WSASetLastError(0);
#else
- errno = 0;
+ errno = 0;
#endif /* WIN32 */
- do
- {
- bufptr = http->buffer;
- bufend = http->buffer + http->used;
-
- while (bufptr < bufend)
- if (*bufptr == 0x0a)
- break;
- else
- bufptr ++;
-
- if (bufptr >= bufend && http->used < HTTP_MAX_BUFFER)
+ while (http->used == 0)
{
/*
* No newline; see if there is more data to be read...
#ifdef HAVE_SSL
if (http->tls)
- bytes = http_read_ssl(http, bufend, HTTP_MAX_BUFFER - http->used);
+ bytes = http_read_ssl(http, http->buffer + http->used,
+ HTTP_MAX_BUFFER - http->used);
else
#endif /* HAVE_SSL */
- bytes = recv(http->fd, bufend, HTTP_MAX_BUFFER - http->used, 0);
+ bytes = recv(http->fd, http->buffer + http->used,
+ HTTP_MAX_BUFFER - http->used, 0);
DEBUG_printf(("httpGets: read %d bytes...\n", bytes));
}
/*
- * Yup, update the amount used and the end pointer...
+ * Yup, update the amount used...
*/
http->used += bytes;
- bufend += bytes;
- bufptr = bufend;
}
- }
- while (bufptr >= bufend && http->used < HTTP_MAX_BUFFER);
-
- http->activity = time(NULL);
-
- /*
- * Read a line from the buffer...
- */
-
- lineptr = line;
- bufptr = http->buffer;
- bytes = 0;
- length --;
- while (bufptr < bufend && bytes < length)
- {
- bytes ++;
+ /*
+ * Now copy as much of the current line as possible...
+ */
- if (*bufptr == 0x0a)
+ for (bufptr = http->buffer, bufend = http->buffer + http->used;
+ lineptr < lineend && bufptr < bufend;)
{
- bufptr ++;
- break;
+ if (*bufptr == 0x0a)
+ {
+ eol = 1;
+ bufptr ++;
+ break;
+ }
+ else if (*bufptr == 0x0d)
+ bufptr ++;
+ else
+ *lineptr++ = *bufptr++;
}
- else if (*bufptr == 0x0d)
- bufptr ++;
- else
- *lineptr++ = *bufptr++;
- }
- if (bytes > 0)
- {
- *lineptr = '\0';
-
- http->used -= bytes;
+ http->used -= bufptr - http->buffer;
if (http->used > 0)
memmove(http->buffer, bufptr, http->used);
- DEBUG_printf(("httpGets: Returning \"%s\"\n", line));
- return (line);
+ if (eol)
+ {
+ /*
+ * End of line...
+ */
+
+ http->activity = time(NULL);
+
+ *lineptr = '\0';
+
+ DEBUG_printf(("httpGets: Returning \"%s\"\n", line));
+
+ return (line);
+ }
}
DEBUG_puts("httpGets: No new line available!");
*/
int /* O - Status of call (0 = success) */
-httpHead(http_t *http, /* I - HTTP data */
+httpHead(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI for head */
{
return (http_send(http, HTTP_HEAD, uri));
if (!initialized)
WSAStartup(MAKEWORD(1,1), &winsockdata);
-#elif defined(HAVE_SIGSET)
- sigset(SIGPIPE, SIG_IGN);
-#elif defined(HAVE_SIGACTION)
- struct sigaction action; /* POSIX sigaction data */
-
-
+#elif !defined(SO_NOSIGPIPE)
/*
* Ignore SIGPIPE signals...
*/
+# ifdef HAVE_SIGSET
+ sigset(SIGPIPE, SIG_IGN);
+# elif defined(HAVE_SIGACTION)
+ struct sigaction action; /* POSIX sigaction data */
+
+
memset(&action, 0, sizeof(action));
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
-#else
+# else
signal(SIGPIPE, SIG_IGN);
+# endif /* !SO_NOSIGPIPE */
#endif /* WIN32 */
#ifdef HAVE_GNUTLS
*/
int /* O - Status of call (0 = success) */
-httpOptions(http_t *http, /* I - HTTP data */
+httpOptions(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI for options */
{
return (http_send(http, HTTP_OPTIONS, uri));
*/
int /* O - Status of call (0 = success) */
-httpPost(http_t *http, /* I - HTTP data */
+httpPost(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI for post */
{
return (http_send(http, HTTP_POST, uri));
/*
* 'httpPrintf()' - Print a formatted string to a HTTP connection.
+ *
+ * @private@
*/
int /* O - Number of bytes written */
-httpPrintf(http_t *http, /* I - HTTP data */
+httpPrintf(http_t *http, /* I - HTTP connection */
const char *format, /* I - printf-style format string */
...) /* I - Additional args as needed */
{
*/
int /* O - Status of call (0 = success) */
-httpPut(http_t *http, /* I - HTTP data */
+httpPut(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI to put */
{
return (http_send(http, HTTP_PUT, uri));
/*
* 'httpRead()' - Read data from a HTTP connection.
+ *
+ * This function is deprecated. Use the httpRead2() function which can
+ * read more than 2GB of data.
+ *
+ * @deprecated@
*/
int /* O - Number of bytes read */
-httpRead(http_t *http, /* I - HTTP data */
+httpRead(http_t *http, /* I - HTTP connection */
char *buffer, /* I - Buffer for data */
int length) /* I - Maximum number of bytes */
{
- int bytes; /* Bytes read */
+ return ((int)httpRead2(http, buffer, length));
+}
+
+
+/*
+ * 'httpRead2()' - Read data from a HTTP connection.
+ *
+ * @since CUPS 1.2@
+ */
+
+ssize_t /* O - Number of bytes read */
+httpRead2(http_t *http, /* I - HTTP connection */
+ char *buffer, /* I - Buffer for data */
+ size_t length) /* I - Maximum number of bytes */
+{
+ ssize_t bytes; /* Bytes read */
char len[32]; /* Length string */
if (http->data_encoding == HTTP_ENCODE_CHUNKED &&
http->data_remaining <= 0)
{
- DEBUG_puts("httpRead: Getting chunk length...");
+ DEBUG_puts("httpRead2: Getting chunk length...");
if (httpGets(len, sizeof(len), http) == NULL)
{
- DEBUG_puts("httpRead: Could not get length!");
+ DEBUG_puts("httpRead2: Could not get length!");
return (0);
}
http->data_remaining = strtoll(len, NULL, 16);
if (http->data_remaining < 0)
{
- DEBUG_puts("httpRead: Negative chunk length!");
+ DEBUG_puts("httpRead2: Negative chunk length!");
return (0);
}
}
- DEBUG_printf(("httpRead: data_remaining=%d\n", http->data_remaining));
+ DEBUG_printf(("httpRead2: data_remaining=" CUPS_LLFMT "\n",
+ CUPS_LLCAST http->data_remaining));
if (http->data_remaining <= 0)
{
else
#endif /* HAVE_SSL */
{
- DEBUG_printf(("httpRead: reading %d bytes from socket into buffer...\n",
+ DEBUG_printf(("httpRead2: reading %d bytes from socket into buffer...\n",
bytes));
bytes = recv(http->fd, http->buffer, bytes, 0);
- DEBUG_printf(("httpRead: read %d bytes from socket into buffer...\n",
+ DEBUG_printf(("httpRead2: read %d bytes from socket into buffer...\n",
bytes));
}
bytes = length;
- DEBUG_printf(("httpRead: grabbing %d bytes from input buffer...\n", bytes));
+ DEBUG_printf(("httpRead2: grabbing %d bytes from input buffer...\n", bytes));
memcpy(buffer, http->buffer, length);
http->used -= length;
if (!http->blocking && !httpWait(http, 1000))
return (0);
- DEBUG_printf(("httpRead: reading %d bytes from socket...\n", length));
+ DEBUG_printf(("httpRead2: reading %d bytes from socket...\n", length));
while ((bytes = recv(http->fd, buffer, length, 0)) < 0)
if (errno != EINTR)
break;
- DEBUG_printf(("httpRead: read %d bytes from socket...\n", bytes));
+ DEBUG_printf(("httpRead2: read %d bytes from socket...\n", bytes));
}
if (bytes > 0)
#ifdef DEBUG
{
int i, j, ch;
- printf("httpRead: Read %d bytes:\n", bytes);
+ printf("httpRead2: Read %d bytes:\n", bytes);
for (i = 0; i < bytes; i += 16)
{
printf(" ");
{
ch = buffer[i + j] & 255;
- if (ch < ' ' || ch == 127)
+ if (ch < ' ' || ch >= 127)
ch = '.';
putchar(ch);
}
+#if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
+/*
+ * '_httpReadCDSA()' - Read function for CDSA decryption code.
+ */
+
+OSStatus /* O - -1 on error, 0 on success */
+_httpReadCDSA(
+ SSLConnectionRef connection, /* I - SSL/TLS connection */
+ void *data, /* I - Data buffer */
+ size_t *dataLength) /* IO - Number of bytes */
+{
+ OSStatus result; /* Return value */
+ ssize_t bytes; /* Number of bytes read */
+
+ do
+ bytes = recv((int)connection, data, *dataLength, 0);
+ while (bytes == -1 && errno == EINTR);
+
+ if (bytes == *dataLength)
+ result = 0;
+ else if (bytes > 0)
+ {
+ *dataLength = bytes;
+ result = errSSLWouldBlock;
+ }
+ else
+ {
+ *dataLength = 0;
+
+ if (bytes == 0)
+ result = errSSLClosedAbort;
+ else if (errno == EAGAIN)
+ result = errSSLWouldBlock;
+ else if (errno == EPIPE)
+ result = errSSLClosedAbort;
+ else
+ result = errSSLInternal;
+ }
+
+ return result;
+}
+#endif /* HAVE_SSL && HAVE_CDSASSL */
+
+
/*
- * 'httpReconnect()' - Reconnect to a HTTP server...
+ * 'httpReconnect()' - Reconnect to a HTTP server.
*/
int /* O - 0 on success, non-zero on failure */
-httpReconnect(http_t *http) /* I - HTTP data */
+httpReconnect(http_t *http) /* I - HTTP connection */
{
- int val; /* Socket option value */
- int status; /* Connect status */
+ http_addrlist_t *addr; /* Connected address */
DEBUG_printf(("httpReconnect(http=%p)\n", http));
*/
if (http->fd >= 0)
+ {
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif /* WIN32 */
- /*
- * Create the socket and set options to allow reuse.
- */
-
- if ((http->fd = socket(http->hostaddr.addr.sa_family, SOCK_STREAM, 0)) < 0)
- {
-#ifdef WIN32
- http->error = WSAGetLastError();
-#else
- http->error = errno;
-#endif /* WIN32 */
- http->status = HTTP_ERROR;
- return (-1);
+ http->fd = -1;
}
-#ifdef FD_CLOEXEC
- fcntl(http->fd, F_SETFD, FD_CLOEXEC); /* Close this socket when starting *
- * other processes... */
-#endif /* FD_CLOEXEC */
-
- val = 1;
- setsockopt(http->fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
-
-#ifdef SO_REUSEPORT
- val = 1;
- setsockopt(http->fd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val));
-#endif /* SO_REUSEPORT */
-
- /*
- * 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;
-#ifdef WIN32
- setsockopt(http->fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
-#else
- setsockopt(http->fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
-#endif /* WIN32 */
-
/*
* Connect to the server...
*/
-#ifdef AF_INET6
- if (http->hostaddr.addr.sa_family == AF_INET6)
- status = connect(http->fd, (struct sockaddr *)&(http->hostaddr),
- sizeof(http->hostaddr.ipv6));
- else
-#endif /* AF_INET6 */
-#ifdef AF_LOCAL
- if (http->hostaddr.addr.sa_family == AF_LOCAL)
- status = connect(http->fd, (struct sockaddr *)&(http->hostaddr),
- SUN_LEN(&(http->hostaddr.un)));
- else
-#endif /* AF_LOCAL */
- status = connect(http->fd, (struct sockaddr *)&(http->hostaddr),
- sizeof(http->hostaddr.ipv4));
-
- if (status < 0)
+ if ((addr = httpAddrConnect(http->addrlist, &(http->fd))) == NULL)
{
+ /*
+ * Unable to connect...
+ */
+
#ifdef WIN32
http->error = WSAGetLastError();
#else
#endif /* WIN32 */
http->status = HTTP_ERROR;
-#ifdef WIN32
- closesocket(http->fd);
-#else
- close(http->fd);
-#endif
-
- http->fd = -1;
-
return (-1);
}
- http->error = 0;
- http->status = HTTP_CONTINUE;
+ http->hostaddr = &(addr->addr);
+ http->error = 0;
+ http->status = HTTP_CONTINUE;
#ifdef HAVE_SSL
if (http->encryption == HTTP_ENCRYPT_ALWAYS)
/*
* 'httpSetCookie()' - Set the cookie value(s)...
+ *
+ * @since CUPS 1.1.19@
*/
void
}
+/*
+ * 'httpSetExpect()' - Set the Expect: header in a request.
+ *
+ * Currently only HTTP_CONTINUE is supported for the "expect" argument.
+ *
+ * @since CUPS 1.2@
+ */
+
+void
+httpSetExpect(http_t *http, /* I - HTTP connection */
+ http_status_t expect) /* I - HTTP status to expect (HTTP_CONTINUE) */
+{
+ if (http)
+ http->expect = expect;
+}
+
+
/*
* 'httpSetField()' - Set the value of an HTTP header.
*/
void
-httpSetField(http_t *http, /* I - HTTP data */
+httpSetField(http_t *http, /* I - HTTP connection */
http_field_t field, /* I - Field index */
const char *value) /* I - Value */
{
/*
* 'httpSetLength()' - Set the content-length and content-encoding.
+ *
+ * @since CUPS 1.2@
*/
void
-httpSetLength(http_t *http, /* I - HTTP data */
- off_t length) /* I - Length (0 for chunked) */
+httpSetLength(http_t *http, /* I - HTTP connection */
+ size_t length) /* I - Length (0 for chunked) */
{
- if (!http || length < 0)
+ if (!http)
return;
if (!length)
*/
int /* O - Status of call (0 = success) */
-httpTrace(http_t *http, /* I - HTTP data */
+httpTrace(http_t *http, /* I - HTTP connection */
const char *uri) /* I - URI for trace */
{
return (http_send(http, HTTP_TRACE, uri));
*/
http_status_t /* O - HTTP status */
-httpUpdate(http_t *http) /* I - HTTP data */
+httpUpdate(http_t *http) /* I - HTTP connection */
{
- char line[16384], /* Line from connection... */
+ char line[32768], /* Line from connection... */
*value; /* Pointer to value on line */
http_field_t field; /* Field index */
int major, minor, /* HTTP version numbers */
/*
* 'httpWait()' - Wait for data available on a connection.
+ *
+ * @since CUPS 1.1.19@
*/
int /* O - 1 if data is available, 0 otherwise */
-httpWait(http_t *http, /* I - HTTP data */
+httpWait(http_t *http, /* I - HTTP connection */
int msec) /* I - Milliseconds to wait */
{
/*
/*
* 'httpWrite()' - Write data to a HTTP connection.
+ *
+ * This function is deprecated. Use the httpWrite2() function which can
+ * write more than 2GB of data.
+ *
+ * @deprecated@
*/
int /* O - Number of bytes written */
-httpWrite(http_t *http, /* I - HTTP data */
+httpWrite(http_t *http, /* I - HTTP connection */
const char *buffer, /* I - Buffer for data */
int length) /* I - Number of bytes to write */
{
- int bytes; /* Bytes written */
+ return ((int)httpWrite2(http, buffer, length));
+}
+
+
+/*
+ * 'httpWrite2()' - Write data to a HTTP connection.
+ *
+ * @since CUPS 1.2@
+ */
+
+ssize_t /* O - Number of bytes written */
+httpWrite2(http_t *http, /* I - HTTP connection */
+ const char *buffer, /* I - Buffer for data */
+ size_t length) /* I - Number of bytes to write */
+{
+ ssize_t bytes; /* Bytes written */
DEBUG_printf(("httpWrite(http=%p, buffer=%p, length=%d)\n", http,
if (http->data_encoding == HTTP_ENCODE_LENGTH)
http->data_remaining -= bytes;
}
+ else
+ bytes = 0;
/*
* Handle end-of-request processing...
}
+#if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
/*
- * 'http_field()' - Return the field index for a field name.
+ * '_httpWriteCDSA()' - Write function for CDSA encryption code.
*/
-static http_field_t /* O - Field index */
-http_field(const char *name) /* I - String name */
+OSStatus /* O - -1 on error, 0 on success */
+_httpWriteCDSA(
+ SSLConnectionRef connection, /* I - SSL/TLS connection */
+ const void *data, /* I - Data buffer */
+ size_t *dataLength) /* IO - Number of bytes */
{
- int i; /* Looping var */
+ OSStatus result; /* Return value */
+ ssize_t bytes; /* Number of bytes read */
+ do
+ bytes = write((int)connection, data, *dataLength);
+ while (bytes == -1 && errno == EINTR);
- for (i = 0; i < HTTP_FIELD_MAX; i ++)
- if (strcasecmp(name, http_fields[i]) == 0)
- return ((http_field_t)i);
+ if (bytes == *dataLength)
+ result = 0;
+ else if (bytes >= 0)
+ {
+ *dataLength = bytes;
+ result = errSSLWouldBlock;
+ }
+ else
+ {
+ *dataLength = 0;
+
+ if (errno == EAGAIN)
+ result = errSSLWouldBlock;
+ else if (errno == EPIPE)
+ result = errSSLClosedAbort;
+ else
+ result = errSSLInternal;
+ }
- return (HTTP_FIELD_UNKNOWN);
+ return result;
}
+#endif /* HAVE_SSL && HAVE_CDSASSL */
-#if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
/*
- * 'http_read_cdsa()' - Read function for CDSA decryption code.
+ * 'http_field()' - Return the field index for a field name.
*/
-static OSStatus /* O - -1 on error, 0 on success */
-http_read_cdsa(
- SSLConnectionRef connection, /* I - SSL/TLS connection */
- void *data, /* I - Data buffer */
- size_t *dataLength) /* IO - Number of bytes */
+static http_field_t /* O - Field index */
+http_field(const char *name) /* I - String name */
{
- ssize_t bytes; /* Number of bytes read */
+ int i; /* Looping var */
- bytes = recv((int)connection, data, *dataLength, 0);
- if (bytes >= 0)
- {
- *dataLength = bytes;
- return (0);
- }
- else
- return (-1);
+ for (i = 0; i < HTTP_FIELD_MAX; i ++)
+ if (strcasecmp(name, http_fields[i]) == 0)
+ return ((http_field_t)i);
+
+ return (HTTP_FIELD_UNKNOWN);
}
-#endif /* HAVE_SSL && HAVE_CDSASSL */
#ifdef HAVE_SSL
*/
static int /* O - Bytes read */
-http_read_ssl(http_t *http, /* I - HTTP data */
+http_read_ssl(http_t *http, /* I - HTTP connection */
char *buf, /* I - Buffer to store data */
int len) /* I - Length of buffer */
{
return (gnutls_record_recv(((http_tls_t *)(http->tls))->session, buf, len));
# elif defined(HAVE_CDSASSL)
+ int result; /* Return value */
OSStatus error; /* Error info */
size_t processed; /* Number of bytes processed */
error = SSLRead((SSLContextRef)http->tls, buf, len, &processed);
- if (error == 0)
- return (processed);
- else
+ switch (error)
{
- http->error = error;
-
- return (-1);
+ 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 /* HAVE_LIBSSL */
}
#endif /* HAVE_SSL */
*/
static int /* O - 0 on success, non-zero on error */
-http_send(http_t *http, /* I - HTTP data */
+http_send(http_t *http, /* I - HTTP connection */
http_state_t request, /* I - Request code */
const char *uri) /* I - URI */
{
if (http == NULL || uri == NULL)
return (-1);
+ /*
+ * Set the User-Agent field if it isn't already...
+ */
+
+ if (!http->fields[HTTP_FIELD_USER_AGENT][0])
+ httpSetField(http, HTTP_FIELD_USER_AGENT, CUPS_MINIMAL);
+
/*
* Encode the URI as needed...
*/
*/
if (http->status == HTTP_ERROR || http->status >= HTTP_BAD_REQUEST)
- httpReconnect(http);
+ if (httpReconnect(http))
+ return (-1);
/*
* Send the request header...
}
}
+ 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;
*/
static int /* O - Status of connection */
-http_setup_ssl(http_t *http) /* I - HTTP data */
+http_setup_ssl(http_t *http) /* I - HTTP connection */
{
# ifdef HAVE_LIBSSL
SSL_CTX *context; /* Context for encryption */
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, http->fd);
+ gnutls_transport_set_ptr(conn->session, (gnutls_transport_ptr)http->fd);
if ((gnutls_handshake(conn->session)) != GNUTLS_E_SUCCESS)
{
error = SSLNewContext(false, &conn);
if (!error)
- error = SSLSetIOFuncs(conn, http_read_cdsa, http_write_cdsa);
+ error = SSLSetIOFuncs(conn, _httpReadCDSA, _httpWriteCDSA);
if (!error)
error = SSLSetConnection(conn, (SSLConnectionRef)http->fd);
error = SSLSetAllowsAnyRoot(conn, true);
if (!error)
- error = SSLHandshake(conn);
+ {
+ while ((error = SSLHandshake(conn)) == errSSLWouldBlock)
+ usleep(1000);
+ }
if (error != 0)
{
*/
static void
-http_shutdown_ssl(http_t *http) /* I - HTTP data */
+http_shutdown_ssl(http_t *http) /* I - HTTP connection */
{
# ifdef HAVE_LIBSSL
SSL_CTX *context; /* Context for encryption */
free(conn);
# elif defined(HAVE_CDSASSL)
- SSLClose((SSLContextRef)http->tls);
+ while (SSLClose((SSLContextRef)http->tls) == errSSLWouldBlock)
+ usleep(1000);
+
SSLDisposeContext((SSLContextRef)http->tls);
# endif /* HAVE_LIBSSL */
*/
static int /* O - Status of connection */
-http_upgrade(http_t *http) /* I - HTTP data */
+http_upgrade(http_t *http) /* I - HTTP connection */
{
int ret; /* Return value */
http_t myhttp; /* Local copy of HTTP data */
*/
static int /* O - 1 if data is available, 0 otherwise */
-http_wait(http_t *http, /* I - HTTP data */
+http_wait(http_t *http, /* I - HTTP connection */
int msec) /* I - Milliseconds to wait */
{
#ifndef WIN32
struct rlimit limit; /* Runtime limit */
+ int set_size; /* Size of select set */
#endif /* !WIN32 */
struct timeval timeout; /* Timeout */
int nfds; /* Result from select() */
- int set_size; /* Size of select set */
DEBUG_printf(("http_wait(http=%p, msec=%d)\n", http, msec));
+ if (http->fd < 0)
+ return (0);
+
/*
* Check the SSL/TLS buffers for data first...
*/
*/
static int /* O - Number of bytes written */
-http_write(http_t *http, /* I - HTTP data */
+http_write(http_t *http, /* I - HTTP connection */
const char *buffer, /* I - Buffer for data */
int length) /* I - Number of bytes to write */
{
}
-#if defined(HAVE_SSL) && defined(HAVE_CDSASSL)
-/*
- * 'http_write_cdsa()' - Write function for CDSA encryption code.
- */
-
-static OSStatus /* O - -1 on error, 0 on success */
-http_write_cdsa(
- SSLConnectionRef connection, /* I - SSL/TLS connection */
- const void *data, /* I - Data buffer */
- size_t *dataLength) /* IO - Number of bytes */
-{
- ssize_t bytes; /* Number of write written */
-
-
- bytes = write((int)connection, data, *dataLength);
- if (bytes >= 0)
- {
- *dataLength = bytes;
- return (0);
- }
- else
- return (-1);
-}
-#endif /* HAVE_SSL && HAVE_CDSASSL */
-
-
/*
* 'http_write_chunk()' - Write a chunked buffer.
*/
static int /* O - Number bytes written */
-http_write_chunk(http_t *http, /* I - HTTP data */
+http_write_chunk(http_t *http, /* I - HTTP connection */
const char *buffer, /* I - Buffer to write */
int length) /* I - Length of buffer */
{
*/
static int /* O - Bytes written */
-http_write_ssl(http_t *http, /* I - HTTP data */
+http_write_ssl(http_t *http, /* I - HTTP connection */
const char *buf, /* I - Buffer holding data */
int len) /* I - Length of buffer */
{
# elif defined(HAVE_GNUTLS)
return (gnutls_record_send(((http_tls_t *)(http->tls))->session, buf, len));
# elif defined(HAVE_CDSASSL)
+ int result; /* Return value */
OSStatus error; /* Error info */
size_t processed; /* Number of bytes processed */
error = SSLWrite((SSLContextRef)http->tls, buf, len, &processed);
- if (error == 0)
- return (processed);
- else
+ switch (error)
{
- http->error = error;
- return (-1);
+ 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 /* HAVE_LIBSSL */
}
#endif /* HAVE_SSL */
projects / thirdparty / cups.git / blobdiff