--- /dev/null
+dnl config.m4 for pecl/http
+dnl $Id$
+
+PHP_ARG_ENABLE([http], [whether to enable extended HTTP support],
+[ --enable-http Enable extended HTTP support])
+PHP_ARG_WITH([curl], [for CURL support],
+[ --with-curl[=DIR] Include CURL support])
+
+if test "$PHP_HTTP" != "no"; then
+
+dnl -----
+dnl CTYPE
+dnl -----
+ if test -r /usr/include/ctype.h -o -r /usr/local/include/ctype.h ; then
+ AC_DEFINE([HAVE_CTYPE], [1], [Have ctype support])
+ fi
+
+dnl ----
+dnl CURL
+dnl ----
+ if test "$PHP_CURL" != "no"; then
+ if test -r $PHP_CURL/include/curl/easy.h; then
+ CURL_DIR=$PHP_CURL
+ else
+ AC_MSG_CHECKING(for CURL in default path)
+ for i in /usr/local /usr; do
+ if test -r $i/include/curl/easy.h; then
+ CURL_DIR=$i
+ AC_MSG_RESULT(found in $i)
+ break
+ fi
+ done
+ fi
+
+ if test -z "$CURL_DIR"; then
+ AC_MSG_RESULT(not found)
+ AC_MSG_ERROR(Please reinstall the libcurl distribution -
+ easy.h should be in <curl-dir>/include/curl/)
+ fi
+
+ CURL_CONFIG="curl-config"
+
+ if ${CURL_DIR}/bin/curl-config --libs print > /dev/null 2>&1; then
+ CURL_CONFIG=${CURL_DIR}/bin/curl-config
+ else
+ if ${CURL_DIR}/curl-config --libs print > /dev/null 2>&1; then
+ CURL_CONFIG=${CURL_DIR}/curl-config
+ fi
+ fi
+
+ PHP_ADD_INCLUDE($CURL_DIR/include)
+ PHP_EVAL_LIBLINE($CURL_LIBS, CURL_SHARED_LIBADD)
+ PHP_ADD_LIBRARY_WITH_PATH(curl, $CURL_DIR/lib, HTTP_SHARED_LIBADD)
+
+ PHP_CHECK_LIBRARY(curl,curl_easy_init,
+ [
+ AC_DEFINE(HAVE_CURL,1,[Have CURL easy support])
+ ],[
+ AC_MSG_ERROR(There is something wrong with libcurl. Please check config.log for more information.)
+ ],[
+ $CURL_LIBS -L$CURL_DIR/lib
+ ])
+
+ PHP_CHECK_LIBRARY(curl,curl_version_info,
+ [
+ AC_DEFINE(HAVE_CURL_VERSION_INFO,1,[ ])
+ ],[],[
+ $CURL_LIBS -L$CURL_DIR/lib
+ ])
+ fi
+
+dnl ----
+dnl DONE
+dnl ----
+ PHP_NEW_EXTENSION([http], [http.c http_api.c], [$ext_shared])
+ PHP_SUBST([HTTP_SHARED_LIBADD])
+ AC_DEFINE([HAVE_HTTP], [1], [Have extended HTTP support])
+fi
--- /dev/null
+// config.w32 for pecl/http
+// $Id$
+
+ARG_ENABLE("http", "whether to enable extended HTTP support", "no");
+
+if (PHP_HTTP != "no") {
+ EXTENSION("http", "http.c http_api.c")
+ AC_DEFINE("HAVE_HTTP", 1, "Have extended HTTP support")
+ if (CHECK_LIB("libcurl.lib", "http", PHP_HTTP) &&
+ CHECK_HEADER_ADD_INCLUDE("curl/easy.h", "CFLAGS_HTTP") &&
+ CHECK_LIB("ssleay32.lib", "http", PHP_HTTP) &&
+ CHECK_LIB("libeay32.lib", "http", PHP_HTTP) &&
+ CHECK_LIB("zlib.lib", "http", PHP_HTTP) &&
+ CHECK_LIB("winmm.lib", "http", PHP_HTTP)) {
+ AC_DEFINE('HAVE_CURL', 1, 'Have CURL library');
+ } else {
+ WARNING("curl convenience functions not enabled; libraries and headers not found");
+ }
+}
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PECL :: http |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.0 of the PHP license, that |
+ | is bundled with this package in the file LICENSE, and is available |
+ | through the world-wide-web at http://www.php.net/license/3_0.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "ext/standard/info.h"
+#include "ext/standard/datetime.h"
+#include "ext/session/php_session.h"
+#include "ext/standard/php_string.h"
+#include "ext/standard/php_smart_str.h"
+
+#include "php_http.h"
+#include "php_http_api.h"
+
+#if defined(HAVE_CURL) && HAVE_CURL
+#include <curl/curl.h>
+#endif
+
+ZEND_DECLARE_MODULE_GLOBALS(http)
+
+#ifdef COMPILE_DL_HTTP
+ZEND_GET_MODULE(http)
+#endif
+
+/* {{{ http_functions[] */
+function_entry http_functions[] = {
+ PHP_FE(http_date, NULL)
+ PHP_FE(http_absolute_uri, NULL)
+ PHP_FE(http_negotiate_language, NULL)
+ PHP_FE(http_negotiate_charset, NULL)
+ PHP_FE(http_redirect, NULL)
+ PHP_FE(http_send_status, NULL)
+ PHP_FE(http_send_last_modified, NULL)
+ PHP_FE(http_match_modified, NULL)
+ PHP_FE(http_match_etag, NULL)
+ PHP_FE(http_cache_last_modified, NULL)
+ PHP_FE(http_cache_etag, NULL)
+ PHP_FE(http_accept_ranges, NULL)
+ PHP_FE(http_content_type, NULL)
+ PHP_FE(http_content_disposition, NULL)
+ PHP_FE(http_send_data, NULL)
+ PHP_FE(http_send_file, NULL)
+ PHP_FE(http_send_stream, NULL)
+ PHP_FE(http_chunked_decode, NULL)
+ PHP_FE(http_split_response, NULL)
+#if defined(HAVE_CURL) && HAVE_CURL
+ PHP_FE(http_get, NULL)
+ PHP_FE(http_head, NULL)
+ PHP_FE(http_post_data, NULL)
+ PHP_FE(http_post_array, NULL)
+#endif
+ PHP_FE(http_auth_basic, NULL)
+ PHP_FE(http_auth_basic_cb, NULL)
+ {NULL, NULL, NULL}
+};
+/* }}} */
+
+/* {{{ http_module_entry */
+zend_module_entry http_module_entry = {
+#if ZEND_MODULE_API_NO >= 20010901
+ STANDARD_MODULE_HEADER,
+#endif
+ "http",
+ http_functions,
+ PHP_MINIT(http),
+ NULL,
+ NULL,
+ PHP_RSHUTDOWN(http),
+ PHP_MINFO(http),
+#if ZEND_MODULE_API_NO >= 20010901
+ PHP_EXT_HTTP_VERSION,
+#endif
+ STANDARD_MODULE_PROPERTIES
+};
+/* }}} */
+
+#define RETURN_SUCCESS(v) RETURN_BOOL(SUCCESS == (v))
+
+/* {{{ proto string http_date([int timestamp])
+ *
+ * This function returns a valid HTTP date regarding RFC 822/1123
+ * looking like: "Wed, 22 Dec 2004 11:34:47 GMT"
+ *
+ */
+PHP_FUNCTION(http_date)
+{
+ long t = -1;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (t == -1) {
+ t = (long) time(NULL);
+ }
+
+ RETURN_STRING(http_date(t), 0);
+}
+/* }}} */
+
+/* {{{ proto string http_absolute_uri(string url[, string proto])
+ *
+ * This function returns an absolute URI constructed from url.
+ * If the url is already abolute but a different proto was supplied,
+ * only the proto part of the URI will be updated. If url has no
+ * path specified, the path of the current REQUEST_URI will be taken.
+ * The host will be taken either from the Host HTTP header of the client
+ * the SERVER_NAME or just localhost if prior are not available.
+ *
+ * Some examples:
+ * <pre>
+ * url = "page.php" => http://www.example.com/current/path/page.php
+ * url = "/page.php" => http://www.example.com/page.php
+ * url = "/page.php", proto = "https" => https://www.example.com/page.php
+ * </pre>
+ *
+ */
+PHP_FUNCTION(http_absolute_uri)
+{
+ char *url = NULL, *proto = NULL;
+ int url_len = 0, proto_len = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &url, &url_len, &proto, &proto_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ RETURN_STRING(http_absolute_uri(url, proto), 0);
+}
+/* }}} */
+
+/* {{{ proto string http_negotiate_language(array supported[, string default = 'en-US'])
+ *
+ * This function negotiates the clients preferred language based on its
+ * Accept-Language HTTP header. It returns the negotiated language or
+ * the default language if none match.
+ *
+ * The qualifier is recognized and languages without qualifier are rated highest.
+ *
+ * The supported parameter is expected to be an array having
+ * the supported languages as array values.
+ *
+ * Example:
+ * <pre>
+ * <?php
+ * $langs = array(
+ * 'en-US',// default
+ * 'fr',
+ * 'fr-FR',
+ * 'de',
+ * 'de-DE',
+ * 'de-AT',
+ * 'de-CH',
+ * );
+ * include './langs/'. http_negotiate_language($langs) .'.php';
+ * ?>
+ * </pre>
+ *
+ */
+PHP_FUNCTION(http_negotiate_language)
+{
+ zval *supported;
+ char *def = NULL;
+ int def_len = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|s", &supported, &def, &def_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (!def) {
+ def = "en-US";
+ }
+
+ RETURN_STRING(http_negotiate_language(supported, def), 0);
+}
+/* }}} */
+
+/* {{{ proto string http_negotiate_charset(array supported[, string default = 'iso-8859-1'])
+ *
+ * This function negotiates the clients preferred charset based on its
+ * Accept-Charset HTTP header. It returns the negotiated charset or
+ * the default charset if none match.
+ *
+ * The qualifier is recognized and charset without qualifier are rated highest.
+ *
+ * The supported parameter is expected to be an array having
+ * the supported charsets as array values.
+ *
+ * Example:
+ * <pre>
+ * <?php
+ * $charsets = array(
+ * 'iso-8859-1', // default
+ * 'iso-8859-2',
+ * 'iso-8859-15',
+ * 'utf-8'
+ * );
+ * $pref = http_negotiate_charset($charsets);
+ * if (!strcmp($pref, 'iso-8859-1')) {
+ * iconv_set_encoding('internal_encoding', 'iso-8859-1');
+ * iconv_set_encoding('output_encoding', $pref);
+ * ob_start('ob_iconv_handler');
+ * }
+ * ?>
+ * </pre>
+ */
+PHP_FUNCTION(http_negotiate_charset)
+{
+ zval *supported;
+ char *def = NULL;
+ int def_len = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|s", &supported, &def, &def_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (!def) {
+ def = "iso-8859-1";
+ }
+
+ RETURN_STRING(http_negotiate_charset(supported, def), 0);
+}
+/* }}} */
+
+/* {{{ proto bool http_send_status(int status)
+ *
+ * Send HTTP status code.
+ * This function sends the desired HTTP status code along with its corresponding
+ * status message, e.g. calling http_send_status(304) will issue a
+ * "Status: 304 Not Modified" with CGI-SAPIs and "HTTP/1.1 304 Not Modified"
+ * when PHP is run as web server module.
+ *
+ */
+PHP_FUNCTION(http_send_status)
+{
+ int status = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status) != SUCCESS) {
+ RETURN_FALSE;
+ }
+ if (status < 100 || status > 510) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid HTTP status code (100-510): %d", status);
+ RETURN_FALSE;
+ }
+
+ RETURN_SUCCESS(http_send_status(status));
+}
+/* }}} */
+
+/* {{{ proto bool http_send_last_modified([int timestamp])
+ *
+ * This converts the given timestamp to a valid HTTP date and
+ * sends it as "Last-Modified" HTTP header. If timestamp is
+ * omitted, current time is taken.
+ *
+ */
+PHP_FUNCTION(http_send_last_modified)
+{
+ long t = -1;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (t == -1) {
+ t = (long) time(NULL);
+ }
+
+ RETURN_SUCCESS(http_send_last_modified(t));
+}
+/* }}} */
+
+/* {{{ proto bool http_match_modified([int timestamp])
+ *
+ * Matches the given timestamp against the clients "If-Modified-Since" and
+ * "If-Unmodified-Since" HTTP headers.
+ *
+ */
+PHP_FUNCTION(http_match_modified)
+{
+ long t = -1;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ // current time if not supplied (senseless though)
+ if (t == -1) {
+ t = (long) time(NULL);
+ }
+
+ RETURN_BOOL(http_modified_match("HTTP_IF_MODIFIED_SINCE", t) || http_modified_match("HTTP_IF_UNMODIFIED_SINCE", t));
+}
+/* }}} */
+
+/* {{{ proto bool http_match_etag(string etag)
+ *
+ * This matches the given ETag against the clients
+ * "If-Match" and "If-None-Match" HTTP headers.
+ *
+ */
+PHP_FUNCTION(http_match_etag)
+{
+ int etag_len;
+ char *etag;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &etag, &etag_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ RETURN_BOOL(http_etag_match("HTTP_IF_NONE_MATCH", etag) || http_etag_match("HTTP_IF_MATCH", etag));
+}
+/* }}} */
+
+/* {{{ proto bool http_cache_last_modified([int timestamp_or_expires]])
+ *
+ * If timestamp_or_exires is greater than 0, it is handled as timestamp
+ * and will be sent as date of last modification. If it is 0 or omitted,
+ * the current time will be sent as Last-Modified date. If it's negative,
+ * it is handled as expiration tim in seconds, which means that if the
+ * requested last modification date is not between the calculated timespan,
+ * the Last-Modified header is updated and the actual body will be sent.
+ *
+ */
+PHP_FUNCTION(http_cache_last_modified)
+{
+ long last_modified = 0, send_modified = 0, t;
+ zval *zlm;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &last_modified) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ t = (long) time(NULL);
+
+ /* 0 or omitted */
+ if (!last_modified) {
+ /* does the client have? */
+ if (zlm = http_get_server_var("HTTP_IF_MODIFIED_SINCE")) {
+ last_modified = send_modified = http_parse_date(Z_STRVAL_P(zlm));
+ /* use current time */
+ } else {
+ last_modified = send_modified = t;
+ }
+ /* negative value is supposed to be expiration time */
+ } else if (last_modified < 0) {
+ last_modified += t;
+ send_modified = t;
+ /* send supplied time explicitly */
+ } else {
+ send_modified = last_modified;
+ }
+
+ http_send_header("Cache-Control: private, must-revalidate, max-age=0");
+
+ if (http_modified_match("HTTP_IF_MODIFIED_SINCE", last_modified)) {
+ if (SUCCESS == http_send_status(304)) {
+ zend_bailout();
+ } else {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not send 304 Not Modified");
+ RETURN_FALSE;
+ }
+ }
+ RETURN_SUCCESS(http_send_last_modified(send_modified));
+}
+/* }}} */
+
+/* {{{ proto bool http_cache_etag([string etag])
+ *
+ * This function attempts to cache the HTTP body based on an ETag,
+ * either supplied or generated through calculation of the MD5
+ * checksum of the output (uses output buffering).
+ *
+ * If clients "If-None-Match" header matches the supplied/calculated
+ * ETag, the body is considered cached on the clients side and
+ * a "304 Not Modified" status code is issued.
+ *
+ */
+PHP_FUNCTION(http_cache_etag)
+{
+ char *etag;
+ int etag_len = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &etag, &etag_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ /* send remaining data to nirvana */
+ http_send_header("Connection: close");
+ http_send_header("Cache-Control: private, must-revalidate, max-age=0");
+
+ /* if no etag is given and we didn't already
+ * start ob_etaghandler -- start it
+ */
+ if (!HTTP_G(etag_started) && !etag_len) {
+ php_ob_set_internal_handler(_http_ob_etaghandler, (uint) 4096, "etag output handler", 0 TSRMLS_CC);
+ HTTP_G(etag_started) = 1;
+ RETURN_BOOL(php_start_ob_buffer_named("etag output handler", (uint) 4096, 0 TSRMLS_CC));
+ }
+
+ if (http_etag_match("HTTP_IF_NONE_MATCH", etag)) {
+ if (SUCCESS == http_send_status(304)) {
+ zend_bailout();
+ } else {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not send 304 Not Modified");
+ RETURN_FALSE;
+ }
+ }
+
+ RETURN_SUCCESS(http_send_etag(etag, etag_len));
+}
+/* }}} */
+
+/* {{{ proto void http_redirect([string url[, array params[, bool session,[ bool permanent]]]])
+ *
+ * Redirect to a given url.
+ * The supplied url will be expanded with http_absolute_uri(), the params array will
+ * be treated with http_build_query() and the session identification will be appended
+ * if session is true.
+ *
+ * Depending on permanent the redirection will be issued with a permanent
+ * ("301 Moved Permanently") or a temporary ("302 Found") redirection
+ * status code.
+ *
+ */
+PHP_FUNCTION(http_redirect)
+{
+ int url_len;
+ zend_bool session = 0, permanent = 0;
+ zval *params = NULL;
+ smart_str qstr = {0};
+ char *url, *URI, LOC[HTTP_URI_MAXLEN + 9];
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sa!bb", &url, &url_len, ¶ms, &session, &permanent) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ /* append session info */
+ if (session && (PS(session_status) == php_session_active)) {
+ if (!params) {
+ MAKE_STD_ZVAL(params);
+ array_init(params);
+ }
+ if (add_assoc_string(params, PS(session_name), PS(id), 1) != SUCCESS) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not append session information");
+ }
+ }
+
+ /* treat params array with http_build_query() */
+ if (params) {
+ if (php_url_encode_hash_ex(Z_ARRVAL_P(params), &qstr, NULL,0,NULL,0,NULL,0,NULL TSRMLS_CC) != SUCCESS) {
+ if (qstr.c) {
+ efree(qstr.c);
+ }
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not encode query parameters");
+ RETURN_FALSE;
+ }
+ smart_str_0(&qstr);
+ }
+
+ URI = http_absolute_uri(url, NULL);
+ if (qstr.c) {
+ snprintf(LOC, HTTP_URI_MAXLEN + strlen("Location: "), "Location: %s?%s", URI, qstr.c);
+ efree(qstr.c);
+ } else {
+ snprintf(LOC, HTTP_URI_MAXLEN + strlen("Location: "), "Location: %s", URI);
+ }
+ efree(URI);
+
+ RETVAL_BOOL((SUCCESS == http_send_header(LOC)) && (SUCCESS == http_send_status((permanent ? 301 : 302))));
+}
+/* }}} */
+
+/* {{{ proto bool http_send_data(string data)
+ *
+ * Sends raw data with support for (multiple) range requests.
+ *
+ */
+PHP_FUNCTION(http_send_data)
+{
+ zval *zdata;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zdata) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ convert_to_string_ex(&zdata);
+
+ RETURN_SUCCESS(http_send_data(zdata));
+}
+/* }}} */
+
+/* {{{ proto bool http_send_file(string file)
+ *
+ * Sends a file with support for (multiple) range requests.
+ *
+ */
+PHP_FUNCTION(http_send_file)
+{
+ zval *zfile;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zfile) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ convert_to_string_ex(&zfile);
+
+ RETURN_SUCCESS(http_send_file(zfile));
+}
+/* }}} */
+
+/* {{{ proto bool http_send_stream(resource stream)
+ *
+ * Sends an already opened stream with support for (multiple) range requests.
+ *
+ */
+PHP_FUNCTION(http_send_stream)
+{
+ zval *zstream;
+ php_stream *file;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ php_stream_from_zval(file, &zstream);
+
+ RETURN_SUCCESS(http_send_stream(file));
+}
+/* }}} */
+
+/* {{{ proto bool http_accept_ranges(void)
+ *
+ * Issues a "Accept-Ranges: bytes" header.
+ *
+ * Example:
+ * <pre>
+ * <?php
+ * http_content_type('application/x-zip');
+ * http_content_disposition('latest.zip');
+ * http_accept_ranges();
+ * http_cache_etag();
+ * http_send_file('../some/download.zip');
+ * ?>
+ * </pre>
+ *
+ */
+PHP_FUNCTION(http_accept_ranges)
+{
+ if (ZEND_NUM_ARGS()) {
+ WRONG_PARAM_COUNT;
+ }
+ RETURN_SUCCESS(http_send_header("Accept-Ranges: bytes"));
+}
+/* }}} */
+
+/* {{{ proto bool http_content_type([string content_type = 'application/x-octetstream'])
+ *
+ * Sets the content type.
+ *
+ */
+PHP_FUNCTION(http_content_type)
+{
+ char *ct, *content_type;
+ int ct_len = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &ct, &ct_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (!ct_len) {
+ RETURN_SUCCESS(http_send_header("Content-Type: application/x-octetstream"));
+ }
+
+ /* remember for multiple ranges */
+ if (HTTP_G(ctype)) {
+ efree(HTTP_G(ctype));
+ }
+ HTTP_G(ctype) = estrndup(ct, ct_len);
+
+ content_type = (char *) emalloc(strlen("Content-Type: ") + ct_len + 1);
+ sprintf(content_type, "Content-Type: %s", ct);
+
+ RETVAL_BOOL(SUCCESS == http_send_header(content_type));
+ efree(content_type);
+}
+/* }}} */
+
+/* {{{ proto bool http_content_disposition(string filename[, bool inline = false])
+ *
+ * Set the Content Disposition. The Content-Disposition header is very useful
+ * if the data actually sent came from a file or something similar, that should
+ * be "saved" by the client/user (i.e. by browsers "Save as..." popup window).
+ *
+ */
+PHP_FUNCTION(http_content_disposition)
+{
+ char *filename, *header;
+ int f_len;
+ zend_bool send_inline = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &f_len, &send_inline) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (send_inline) {
+ header = (char *) emalloc(strlen("Content-Disposition: inline; filename=\"\"") + f_len + 1);
+ sprintf(header, "Content-Disposition: inline; filename=\"%s\"", filename);
+ } else {
+ header = (char *) emalloc(strlen("Content-Disposition: attachment; filename=\"\"") + f_len + 1);
+ sprintf(header, "Content-Disposition: attachment; filename=\"%s\"", filename);
+ }
+
+ RETVAL_BOOL(SUCCESS == http_send_header(header));
+ efree(header);
+}
+/* }}} */
+
+/* {{{ proto string http_chunked_decode(string encoded)
+ *
+ * This function decodes a string that was HTTP-chunked encoded.
+ * Returns false on failure.
+ */
+PHP_FUNCTION(http_chunked_decode)
+{
+ char *encoded = NULL, *decoded = NULL;
+ int encoded_len = 0, decoded_len = 0;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &encoded, &encoded_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (SUCCESS == http_chunked_decode(encoded, encoded_len, &decoded, &decoded_len)) {
+ RETURN_STRINGL(decoded, decoded_len, 0);
+ } else {
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto array http_split_response(string http_response)
+ *
+ * This function splits an HTTP response into an array with headers and the
+ * content body. The returned array may look simliar to the following example:
+ *
+ * <pre>
+ * array(
+ * 0 => array(
+ * 'Status' => '200 Ok',
+ * 'Content-Type' => 'text/plain',
+ * 'Content-Language' => 'en-US'
+ * ),
+ * 1 => "Hello World!"
+ * );
+ * </pre>
+ */
+PHP_FUNCTION(http_split_response)
+{
+ zval *zresponse, *zbody, *zheaders;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zresponse) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ convert_to_string_ex(&zresponse);
+
+ MAKE_STD_ZVAL(zbody);
+ MAKE_STD_ZVAL(zheaders);
+ array_init(zheaders);
+
+ http_split_response(zresponse, zheaders, zbody);
+
+ array_init(return_value);
+ add_index_zval(return_value, 0, zheaders);
+ add_index_zval(return_value, 1, zbody);
+}
+/* }}} */
+
+/* {{{ HAVE_CURL */
+#if defined(HAVE_CURL) && HAVE_CURL
+
+/* {{{ proto string http_get(string url[, array options])
+ *
+ * Performs an HTTP GET request on the supplied url.
+ *
+ * The second parameter is expected to be an associative
+ * array where the following keys will be recognized:
+ * <pre>
+ * - redirect: int, whether and how many redirects to follow
+ * - unrestrictedauth: bool, whether to continue sending credentials on
+ * redirects to a different host
+ * - proxyhost: string, proxy host in "host[:port]" format
+ * - proxyport: int, use another proxy port as specified in proxyhost
+ * - proxyauth: string, proxy credentials in "user:pass" format
+ * - proxyauthtype: int, HTTP_AUTH_BASIC and/or HTTP_AUTH_NTLM
+ * - httpauth: string, http credentials in "user:pass" format
+ * - httpauthtype: int, HTTP_AUTH_BASIC, DIGEST and/or NTLM
+ * - compress: bool, whether to allow gzip/deflate content encoding
+ * - port: int, use another port as specified in the url
+ * - referer: string, the referer to sends
+ * - useragent: string, the user agent to send
+ * - headers: array, list of custom headers in "header: value" format
+ * - cookies: array, list of cookies in "name=value" format
+ * - cookiestore: string, path to a file where cookies are/will be stored
+ * </pre>
+ */
+PHP_FUNCTION(http_get)
+{
+ char *URL, *data = NULL;
+ size_t data_len = 0;
+ int URL_len;
+ zval *options = NULL;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &URL, &URL_len, &options) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (SUCCESS == http_get(URL, options ? Z_ARRVAL_P(options) : NULL, &data, &data_len)) {
+ RETURN_STRINGL(data, data_len, 0);
+ } else {
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto string http_head(string url[, array options])
+ *
+ * Performs an HTTP HEAD request on the suppied url.
+ * Returns the HTTP response as string.
+ * See http_get() for a full list of available options.
+ */
+PHP_FUNCTION(http_head)
+{
+ char *URL, *data = NULL;
+ size_t data_len = 0;
+ int URL_len;
+ zval *options = NULL;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &URL, &URL_len, &options) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (SUCCESS == http_head(URL, options ? Z_ARRVAL_P(options) : NULL, &data, &data_len)) {
+ RETURN_STRINGL(data, data_len, 0);
+ } else {
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto string http_post_data(string url, string data[, array options])
+ *
+ * Performs an HTTP POST request, posting data.
+ * Returns the HTTP response as string.
+ * See http_get() for a full list of available options.
+ */
+PHP_FUNCTION(http_post_data)
+{
+ char *URL, *postdata, *data = NULL;
+ size_t data_len = 0;
+ int postdata_len, URL_len;
+ zval *options = NULL;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a", &URL, &URL_len, &postdata, &postdata_len, &options) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (SUCCESS == http_post_data(URL, postdata, (size_t) postdata_len, options ? Z_ARRVAL_P(options) : NULL, &data, &data_len)) {
+ RETURN_STRINGL(data, data_len, 0);
+ } else {
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto string http_post_data(string url, array data[, array options])
+ *
+ * Performs an HTTP POST request, posting www-form-urlencoded array data.
+ * Returns the HTTP response as string.
+ * See http_get() for a full list of available options.
+ */
+PHP_FUNCTION(http_post_array)
+{
+ char *URL, *data = NULL;
+ size_t data_len = 0;
+ int URL_len;
+ zval *options = NULL, *postdata;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a", &URL, &URL_len, &postdata, &options) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (SUCCESS == http_post_array(URL, Z_ARRVAL_P(postdata), options ? Z_ARRVAL_P(options) : NULL, &data, &data_len)) {
+ RETURN_STRINGL(data, data_len, 0);
+ } else {
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+#endif
+/* }}} HAVE_CURL */
+
+
+/* {{{ proto bool http_auth_basic(string user, string pass[, string realm = "Restricted"])
+ *
+ * Example:
+ * <pre>
+ * <?php
+ * if (!http_auth_basic('mike', 's3c|r3t')) {
+ * die('<h1>Authorization failed!</h1>');
+ * }
+ * ?>
+ * </pre>
+ */
+PHP_FUNCTION(http_auth_basic)
+{
+ char *realm = NULL, *user, *pass, *suser, *spass;
+ int r_len, u_len, p_len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &user, &u_len, &pass, &p_len, &realm, &r_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (!realm) {
+ realm = "Restricted";
+ }
+
+ if (SUCCESS != http_auth_credentials(&suser, &spass)) {
+ http_auth_header("Basic", realm);
+ RETURN_FALSE;
+ }
+
+ if (strcasecmp(suser, user)) {
+ http_auth_header("Basic", realm);
+ RETURN_FALSE;
+ }
+
+ if (strcmp(spass, pass)) {
+ http_auth_header("Basic", realm);
+ RETURN_FALSE;
+ }
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool http_auth_basic_cb(mixed callback[, string realm = "Restricted"])
+ *
+ * Example:
+ * <pre>
+ * <?php
+ * function auth_cb($user, $pass)
+ * {
+ * global $db;
+ * $query = 'SELECT pass FROM users WHERE user='. $db->quoteSmart($user);
+ * if (strlen($realpass = $db->getOne($query)) {
+ * return $pass === $realpass;
+ * }
+ * return false;
+ * }
+ *
+ * if (!http_auth_basic_cb('auth_cb')) {
+ * die('<h1>Authorization failed</h1>');
+ * }
+ * ?>
+ * </pre>
+ */
+PHP_FUNCTION(http_auth_basic_cb)
+{
+ zval *cb;
+ char *realm = NULL, *user, *pass;
+ int r_len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &cb, &realm, &r_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (!realm) {
+ realm = "Restricted";
+ }
+
+ if (SUCCESS != http_auth_credentials(&user, &pass)) {
+ http_auth_header("Basic", realm);
+ RETURN_FALSE;
+ }
+ {
+ zval *zparams[2] = {NULL, NULL}, retval;
+ int result = 0;
+
+ MAKE_STD_ZVAL(zparams[0]);
+ MAKE_STD_ZVAL(zparams[1]);
+ ZVAL_STRING(zparams[0], user, 0);
+ ZVAL_STRING(zparams[1], pass, 0);
+
+ if (SUCCESS == call_user_function(EG(function_table), NULL, cb,
+ &retval, 2, zparams TSRMLS_CC)) {
+ result = Z_LVAL(retval);
+ }
+
+ efree(user);
+ efree(pass);
+ efree(zparams[0]);
+ efree(zparams[1]);
+
+ if (!result) {
+ http_auth_header("Basic", realm);
+ }
+
+ RETURN_BOOL(result);
+ }
+}
+/* }}}*/
+
+
+/* {{{ php_http_init_globals(zend_http_globals *) */
+static void php_http_init_globals(zend_http_globals *http_globals)
+{
+ http_globals->etag_started = 0;
+ http_globals->ctype = NULL;
+#if defined(HAVE_CURL) && HAVE_CURL
+ http_globals->curlbuf.body.data = NULL;
+ http_globals->curlbuf.body.used = 0;
+ http_globals->curlbuf.body.free = 0;
+ http_globals->curlbuf.hdrs.data = NULL;
+ http_globals->curlbuf.hdrs.used = 0;
+ http_globals->curlbuf.hdrs.free = 0;
+#endif
+}
+/* }}} */
+
+/* {{{ PHP_MINIT_FUNCTION */
+PHP_MINIT_FUNCTION(http)
+{
+ ZEND_INIT_MODULE_GLOBALS(http, php_http_init_globals, NULL);
+#if defined(HAVE_CURL) && HAVE_CURL
+ REGISTER_LONG_CONSTANT("HTTP_AUTH_BASIC", CURLAUTH_BASIC, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("HTTP_AUTH_DIGEST", CURLAUTH_DIGEST, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("HTTP_AUTH_NTLM", CURLAUTH_NTLM, CONST_CS | CONST_PERSISTENT);
+#endif
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_RSHUTDOWN_FUNCTION */
+PHP_RSHUTDOWN_FUNCTION(http)
+{
+ if (HTTP_G(ctype)) {
+ efree(HTTP_G(ctype));
+ }
+#if defined(HAVE_CURL) && HAVE_CURL
+ if (HTTP_G(curlbuf).body.data) {
+ efree(HTTP_G(curlbuf).body.data);
+ }
+ if (HTTP_G(curlbuf).hdrs.data) {
+ efree(HTTP_G(curlbuf).hdrs.data);
+ }
+#endif
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MINFO_FUNCTION */
+PHP_MINFO_FUNCTION(http)
+{
+ php_info_print_table_start();
+ php_info_print_table_header(2, "Extended HTTP support", "enabled");
+ php_info_print_table_row(2, "Version:", PHP_EXT_HTTP_VERSION);
+ php_info_print_table_row(2, "cURL convenience functions:",
+#if defined(HAVE_CURL) && HAVE_CURL
+ "enabled"
+#else
+ "disabled"
+#endif
+ );
+ php_info_print_table_end();
+}
+/* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PECL :: http |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.0 of the PHP license, that |
+ | is bundled with this package in the file LICENSE, and is available |
+ | through the world-wide-web at http://www.php.net/license/3_0.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_version.h"
+#include "php_streams.h"
+#include "ext/standard/md5.h"
+#include "ext/standard/url.h"
+#include "ext/standard/base64.h"
+#include "ext/standard/php_string.h"
+#include "ext/standard/php_lcg.h"
+
+#include "SAPI.h"
+
+#if (PHP_MAJOR_VERSION >= 5)
+#include "ext/standard/php_http.h"
+#else
+#include "php_http_build_query.h"
+#include "http_build_query.c"
+#endif
+
+#include "php_http.h"
+#include "php_http_api.h"
+
+#include <ctype.h>
+
+#if defined(HAVE_CURL) && HAVE_CURL
+#include <curl/curl.h>
+#include <curl/easy.h>
+#endif
+
+ZEND_DECLARE_MODULE_GLOBALS(http)
+
+/* {{{ day/month names */
+static const char *days[] = {
+ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+static const char *wkdays[] = {
+ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
+};
+static const char *weekdays[] = {
+ "Monday", "Tuesday", "Wednesday",
+ "Thursday", "Friday", "Saturday", "Sunday"
+};
+static const char *months[] = {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Okt", "Nov", "Dec"
+};
+enum assume_next {
+ DATE_MDAY,
+ DATE_YEAR,
+ DATE_TIME
+};
+static const struct time_zone {
+ const char *name;
+ const int offset;
+} time_zones[] = {
+ {"GMT", 0}, /* Greenwich Mean */
+ {"UTC", 0}, /* Universal (Coordinated) */
+ {"WET", 0}, /* Western European */
+ {"BST", 0}, /* British Summer */
+ {"WAT", 60}, /* West Africa */
+ {"AST", 240}, /* Atlantic Standard */
+ {"ADT", 240}, /* Atlantic Daylight */
+ {"EST", 300}, /* Eastern Standard */
+ {"EDT", 300}, /* Eastern Daylight */
+ {"CST", 360}, /* Central Standard */
+ {"CDT", 360}, /* Central Daylight */
+ {"MST", 420}, /* Mountain Standard */
+ {"MDT", 420}, /* Mountain Daylight */
+ {"PST", 480}, /* Pacific Standard */
+ {"PDT", 480}, /* Pacific Daylight */
+ {"YST", 540}, /* Yukon Standard */
+ {"YDT", 540}, /* Yukon Daylight */
+ {"HST", 600}, /* Hawaii Standard */
+ {"HDT", 600}, /* Hawaii Daylight */
+ {"CAT", 600}, /* Central Alaska */
+ {"AHST", 600}, /* Alaska-Hawaii Standard */
+ {"NT", 660}, /* Nome */
+ {"IDLW", 720}, /* International Date Line West */
+ {"CET", -60}, /* Central European */
+ {"MET", -60}, /* Middle European */
+ {"MEWT", -60}, /* Middle European Winter */
+ {"MEST", -120}, /* Middle European Summer */
+ {"CEST", -120}, /* Central European Summer */
+ {"MESZ", -60}, /* Middle European Summer */
+ {"FWT", -60}, /* French Winter */
+ {"FST", -60}, /* French Summer */
+ {"EET", -120}, /* Eastern Europe, USSR Zone 1 */
+ {"WAST", -420}, /* West Australian Standard */
+ {"WADT", -420}, /* West Australian Daylight */
+ {"CCT", -480}, /* China Coast, USSR Zone 7 */
+ {"JST", -540}, /* Japan Standard, USSR Zone 8 */
+ {"EAST", -600}, /* Eastern Australian Standard */
+ {"EADT", -600}, /* Eastern Australian Daylight */
+ {"GST", -600}, /* Guam Standard, USSR Zone 9 */
+ {"NZT", -720}, /* New Zealand */
+ {"NZST", -720}, /* New Zealand Standard */
+ {"NZDT", -720}, /* New Zealand Daylight */
+ {"IDLE", -720}, /* International Date Line East */
+};
+/* }}} */
+
+/* {{{ internals */
+
+static int http_sort_q(const void *a, const void *b TSRMLS_DC);
+#define http_etag(e, p, l, m) _http_etag((e), (p), (l), (m) TSRMLS_CC)
+static inline char *_http_etag(char **new_etag, const void *data_ptr, const size_t data_len, const http_send_mode data_mode TSRMLS_DC);
+#define http_is_range_request() _http_is_range_request(TSRMLS_C)
+static inline int _http_is_range_request(TSRMLS_D);
+#define http_send_chunk(d, b, e, m) _http_send_chunk((d), (b), (e), (m) TSRMLS_CC)
+static STATUS _http_send_chunk(const void *data, const size_t begin, const size_t end, const http_send_mode mode TSRMLS_DC);
+
+static int check_day(char *day, size_t len);
+static int check_month(char *month);
+static int check_tzone(char *tzone);
+
+/* {{{ HAVE_CURL */
+#if defined(HAVE_CURL) && HAVE_CURL
+#define http_curl_initbuf(m) _http_curl_initbuf((m) TSRMLS_CC)
+static inline void _http_curl_initbuf(http_curlbuf_member member TSRMLS_DC);
+#define http_curl_freebuf(m) _http_curl_freebuf((m) TSRMLS_CC)
+static inline void _http_curl_freebuf(http_curlbuf_member member TSRMLS_DC);
+#define http_curl_sizebuf(m, l) _http_curl_sizebuf((m), (l) TSRMLS_CC)
+static inline void _http_curl_sizebuf(http_curlbuf_member member, size_t len TSRMLS_DC);
+#define http_curl_movebuf(m, d, l) _http_curl_movebuf((m), (d), (l) TSRMLS_CC)
+static inline void _http_curl_movebuf(http_curlbuf_member member, char **data, size_t *data_len TSRMLS_DC);
+#define http_curl_copybuf(m, d, l) _http_curl_copybuf((m), (d), (l) TSRMLS_CC)
+static inline void _http_curl_copybuf(http_curlbuf_member member, char **data, size_t *data_len TSRMLS_DC);
+#define http_curl_setopts(c, u, o) _http_curl_setopts((c), (u), (o) TSRMLS_CC)
+static inline void _http_curl_setopts(CURL *ch, const char *url, HashTable *options TSRMLS_DC);
+
+#define http_curl_getopt(o, k) _http_curl_getopt((o), (k) TSRMLS_CC, 0)
+#define http_curl_getopt1(o, k, t1) _http_curl_getopt((o), (k) TSRMLS_CC, 1, (t1))
+#define http_curl_getopt2(o, k, t1, t2) _http_curl_getopt((o), (k) TSRMLS_CC, 2, (t1), (t2))
+static inline zval *_http_curl_getopt(HashTable *options, char *key TSRMLS_DC, int checks, ...);
+
+static size_t http_curl_body_callback(char *, size_t, size_t, void *);
+static size_t http_curl_hdrs_callback(char *, size_t, size_t, void *);
+#endif
+/* }}} HAVE_CURL */
+
+/* {{{ static int http_sort_q(const void *, const void *) */
+static int http_sort_q(const void *a, const void *b TSRMLS_DC)
+{
+ Bucket *f, *s;
+ zval result, *first, *second;
+
+ f = *((Bucket **) a);
+ s = *((Bucket **) b);
+
+ first = *((zval **) f->pData);
+ second= *((zval **) s->pData);
+
+ if (numeric_compare_function(&result, first, second TSRMLS_CC) != SUCCESS) {
+ return 0;
+ }
+ return (Z_LVAL(result) > 0 ? -1 : (Z_LVAL(result) < 0 ? 1 : 0));
+}
+/* }}} */
+
+/* {{{ static inline char *http_etag(char **, void *, size_t, http_send_mode) */
+static inline char *_http_etag(char **new_etag, const void *data_ptr,
+ const size_t data_len, const http_send_mode data_mode TSRMLS_DC)
+{
+ char ssb_buf[127], digest[16];
+ PHP_MD5_CTX ctx;
+
+ PHP_MD5Init(&ctx);
+
+ switch (data_mode)
+ {
+ case SEND_DATA:
+ PHP_MD5Update(&ctx, data_ptr, data_len);
+ break;
+
+ case SEND_RSRC:
+ snprintf(ssb_buf, 127, "%l=%l=%l",
+ HTTP_G(ssb).sb.st_mtime,
+ HTTP_G(ssb).sb.st_ino,
+ HTTP_G(ssb).sb.st_size
+ );
+ PHP_MD5Update(&ctx, ssb_buf, strlen(ssb_buf));
+ break;
+
+ default:
+ return NULL;
+ break;
+ }
+
+ PHP_MD5Final(digest, &ctx);
+ make_digest(*new_etag, digest);
+
+ return *new_etag;
+}
+/* }}} */
+
+/* {{{ static inline int http_is_range_request(void) */
+static inline int _http_is_range_request(TSRMLS_D)
+{
+ return zend_hash_exists(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]),
+ "HTTP_RANGE", strlen("HTTP_RANGE") + 1);
+}
+/* }}} */
+
+/* {{{ static STATUS http_send_chunk(const void *, size_t, size_t,
+ http_send_mode) */
+static STATUS _http_send_chunk(const void *data, const size_t begin,
+ const size_t end, const http_send_mode mode TSRMLS_DC)
+{
+ char *buf;
+ size_t read = 0;
+ long len = end - begin;
+ php_stream *s;
+
+ switch (mode)
+ {
+ case SEND_RSRC:
+ s = (php_stream *) data;
+ if (php_stream_seek(s, begin, SEEK_SET)) {
+ return FAILURE;
+ }
+ buf = (char *) ecalloc(1, HTTP_BUF_SIZE);
+ /* read into buf and write out */
+ while ((len -= HTTP_BUF_SIZE) >= 0) {
+ if (!(read = php_stream_read(s, buf, HTTP_BUF_SIZE))) {
+ efree(buf);
+ return FAILURE;
+ }
+ if (read - php_body_write(buf, read TSRMLS_CC)) {
+ efree(buf);
+ return FAILURE;
+ }
+ }
+
+ /* read & write left over */
+ if (len) {
+ if (read = php_stream_read(s, buf, HTTP_BUF_SIZE + len)) {
+ if (read - php_body_write(buf, read TSRMLS_CC)) {
+ efree(buf);
+ return FAILURE;
+ }
+ } else {
+ efree(buf);
+ return FAILURE;
+ }
+ }
+ efree(buf);
+ return SUCCESS;
+ break;
+
+ case SEND_DATA:
+ return len == php_body_write(
+ Z_STRVAL_P((zval *) data) + begin, len TSRMLS_CC)
+ ? SUCCESS : FAILURE;
+ break;
+
+ default:
+ return FAILURE;
+ break;
+ }
+}
+/* }}} */
+
+/* {{{ HAVE_CURL */
+#if defined(HAVE_CURL) && HAVE_CURL
+
+/* {{{ static inline void http_curl_initbuf(http_curlbuf_member) */
+static inline void _http_curl_initbuf(http_curlbuf_member member TSRMLS_DC)
+{
+ http_curl_freebuf(member);
+
+ if (member & CURLBUF_HDRS) {
+ HTTP_G(curlbuf).hdrs.data = emalloc(HTTP_CURLBUF_HDRSSIZE);
+ HTTP_G(curlbuf).hdrs.free = HTTP_CURLBUF_HDRSSIZE;
+ }
+ if (member & CURLBUF_BODY) {
+ HTTP_G(curlbuf).body.data = emalloc(HTTP_CURLBUF_BODYSIZE);
+ HTTP_G(curlbuf).body.free = HTTP_CURLBUF_BODYSIZE;
+ }
+}
+/* }}} */
+
+/* {{{ static inline void http_curl_freebuf(http_curlbuf_member) */
+static inline void _http_curl_freebuf(http_curlbuf_member member TSRMLS_DC)
+{
+ if (member & CURLBUF_HDRS) {
+ if (HTTP_G(curlbuf).hdrs.data) {
+ efree(HTTP_G(curlbuf).hdrs.data);
+ HTTP_G(curlbuf).hdrs.data = NULL;
+ }
+ HTTP_G(curlbuf).hdrs.used = 0;
+ HTTP_G(curlbuf).hdrs.free = 0;
+ }
+ if (member & CURLBUF_BODY) {
+ if (HTTP_G(curlbuf).body.data) {
+ efree(HTTP_G(curlbuf).body.data);
+ HTTP_G(curlbuf).body.data = NULL;
+ }
+ HTTP_G(curlbuf).body.used = 0;
+ HTTP_G(curlbuf).body.free = 0;
+ }
+}
+/* }}} */
+
+/* {{{ static inline void http_curl_copybuf(http_curlbuf_member, char **,
+ size_t *) */
+static inline void _http_curl_copybuf(http_curlbuf_member member, char **data,
+ size_t *data_len TSRMLS_DC)
+{
+ *data = NULL;
+ *data_len = 0;
+
+ if ((member & CURLBUF_HDRS) && HTTP_G(curlbuf).hdrs.used) {
+ if ((member & CURLBUF_BODY) && HTTP_G(curlbuf).body.used) {
+ *data = emalloc(HTTP_G(curlbuf).hdrs.used + HTTP_G(curlbuf).body.used + 1);
+ } else {
+ *data = emalloc(HTTP_G(curlbuf).hdrs.used + 1);
+ }
+ memcpy(*data, HTTP_G(curlbuf).hdrs.data, HTTP_G(curlbuf).hdrs.used);
+ *data_len = HTTP_G(curlbuf).hdrs.used;
+ }
+
+ if ((member & CURLBUF_BODY) && HTTP_G(curlbuf).body.used) {
+ if (*data) {
+ memcpy((*data) + HTTP_G(curlbuf).hdrs.used,
+ HTTP_G(curlbuf).body.data, HTTP_G(curlbuf).body.used);
+ *data_len = HTTP_G(curlbuf).hdrs.used + HTTP_G(curlbuf).body.used;
+ } else {
+ emalloc(HTTP_G(curlbuf).body.used + 1);
+ memcpy(*data, HTTP_G(curlbuf).body.data, HTTP_G(curlbuf).body.used);
+ *data_len = HTTP_G(curlbuf).body.used;
+ }
+ }
+ if (*data) {
+ (*data)[*data_len] = 0;
+ } else {
+ *data = "";
+ }
+}
+/* }}} */
+
+/* {{{ static inline void http_curl_movebuf(http_curlbuf_member, char **,
+ size_t *) */
+static inline void _http_curl_movebuf(http_curlbuf_member member, char **data,
+ size_t *data_len TSRMLS_DC)
+{
+ http_curl_copybuf(member, data, data_len);
+ http_curl_freebuf(member);
+}
+/* }}} */
+
+/* {{{ static size_t http_curl_body_callback(char *, size_t, size_t, void *) */
+static size_t http_curl_body_callback(char *buf, size_t len, size_t n, void *s)
+{
+ TSRMLS_FETCH();
+
+ if ((len *= n) > HTTP_G(curlbuf).body.free) {
+ size_t bsize = HTTP_CURLBUF_BODYSIZE;
+ while (bsize < len) {
+ bsize *= 2;
+ }
+ HTTP_G(curlbuf).body.data = erealloc(HTTP_G(curlbuf).body.data,
+ HTTP_G(curlbuf).body.used + bsize);
+ HTTP_G(curlbuf).body.free += bsize;
+ }
+
+ memcpy(HTTP_G(curlbuf).body.data + HTTP_G(curlbuf).body.used, buf, len);
+ HTTP_G(curlbuf).body.free -= len;
+ HTTP_G(curlbuf).body.used += len;
+
+ return len;
+}
+/* }}} */
+
+/* {{{ static size_t http_curl_hdrs_callback(char*, size_t, size_t, void *) */
+static size_t http_curl_hdrs_callback(char *buf, size_t len, size_t n, void *s)
+{
+ TSRMLS_FETCH();
+
+ /* discard previous headers */
+ if ((HTTP_G(curlbuf).hdrs.used) && (!strncmp(buf, "HTTP/1.", strlen("HTTP/1.")))) {
+ http_curl_initbuf(CURLBUF_HDRS);
+ }
+
+ if ((len *= n) > HTTP_G(curlbuf).hdrs.free) {
+ size_t bsize = HTTP_CURLBUF_HDRSSIZE;
+ while (bsize < len) {
+ bsize *= 2;
+ }
+ HTTP_G(curlbuf).hdrs.data = erealloc(HTTP_G(curlbuf).hdrs.data,
+ HTTP_G(curlbuf).hdrs.used + bsize);
+ HTTP_G(curlbuf).hdrs.free += bsize;
+ }
+
+ memcpy(HTTP_G(curlbuf).hdrs.data + HTTP_G(curlbuf).hdrs.used, buf, len);
+ HTTP_G(curlbuf).hdrs.free -= len;
+ HTTP_G(curlbuf).hdrs.used += len;
+
+ return len;
+}
+/* }}} */
+
+/* {{{ static inline zval *http_curl_getopt(HashTable *, char *, int, ...) */
+static inline zval *_http_curl_getopt(HashTable *options, char *key TSRMLS_DC, int checks, ...)
+{
+ zval **zoption;
+ va_list types;
+ int i;
+
+ if (SUCCESS != zend_hash_find(options, key, strlen(key) + 1, (void **) &zoption)) {
+ return NULL;
+ }
+ if (checks < 1) {
+ return *zoption;
+ }
+
+ va_start(types, checks);
+ for (i = 0; i < checks; ++i) {
+ if ((va_arg(types, int)) == (Z_TYPE_PP(zoption))) {
+ va_end(types);
+ return *zoption;
+ }
+ }
+ va_end(types);
+ return NULL;
+}
+/* }}} */
+
+/* {{{ static inline void http_curl_setopts(CURL *, char *, HashTable *) */
+static inline void _http_curl_setopts(CURL *ch, const char *url, HashTable *options TSRMLS_DC)
+{
+ zval *zoption;
+
+ /* standard options */
+ curl_easy_setopt(ch, CURLOPT_URL, url);
+ curl_easy_setopt(ch, CURLOPT_HEADER, 0);
+ curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 1);
+ curl_easy_setopt(ch, CURLOPT_AUTOREFERER, 1);
+ curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, http_curl_body_callback);
+ curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, http_curl_hdrs_callback);
+#if defined(ZTS)
+ curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1);
+#endif
+#if defined(PHP_DEBUG)
+ curl_easy_setopt(ch, CURLOPT_VERBOSE, 1);
+#endif
+
+ if ((!options) || (1 > zend_hash_num_elements(options))) {
+ return;
+ }
+
+ /* redirects */
+ if (zoption = http_curl_getopt1(options, "redirect", IS_LONG)) {
+ curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, Z_LVAL_P(zoption) ? 1 : 0);
+ curl_easy_setopt(ch, CURLOPT_MAXREDIRS, Z_LVAL_P(zoption));
+ if (zoption = http_curl_getopt2(options, "unrestrictedauth", IS_LONG, IS_BOOL)) {
+ curl_easy_setopt(ch, CURLOPT_UNRESTRICTED_AUTH, Z_LVAL_P(zoption));
+ }
+ } else {
+ curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, 0);
+ }
+
+ /* proxy */
+ if (zoption = http_curl_getopt1(options, "proxyhost", IS_STRING)) {
+ curl_easy_setopt(ch, CURLOPT_PROXY, Z_STRVAL_P(zoption));
+ /* port */
+ if (zoption = http_curl_getopt1(options, "proxyport", IS_LONG)) {
+ curl_easy_setopt(ch, CURLOPT_PROXYPORT, Z_LVAL_P(zoption));
+ }
+ /* user:pass */
+ if (zoption = http_curl_getopt1(options, "proxyauth", IS_STRING)) {
+ curl_easy_setopt(ch, CURLOPT_PROXYUSERPWD, Z_STRVAL_P(zoption));
+ }
+ /* auth method */
+ if (zoption = http_curl_getopt1(options, "proxyauthtype", IS_LONG)) {
+ curl_easy_setopt(ch, CURLOPT_PROXYAUTH, Z_LVAL_P(zoption));
+ }
+ }
+
+ /* auth */
+ if (zoption = http_curl_getopt1(options, "httpauth", IS_STRING)) {
+ curl_easy_setopt(ch, CURLOPT_USERPWD, Z_STRVAL_P(zoption));
+ }
+ if (zoption = http_curl_getopt1(options, "httpauthtype", IS_LONG)) {
+ curl_easy_setopt(ch, CURLOPT_HTTPAUTH, Z_LVAL_P(zoption));
+ }
+
+ /* compress */
+ if (zoption = http_curl_getopt2(options, "compress", IS_LONG, IS_BOOL)) {
+ /* empty string enables deflate and gzip */
+ curl_easy_setopt(ch, CURLOPT_ENCODING, "");
+ }
+
+ /* another port */
+ if (zoption = http_curl_getopt1(options, "port", IS_LONG)) {
+ curl_easy_setopt(ch, CURLOPT_PORT, Z_LVAL_P(zoption));
+ }
+
+ /* referer */
+ if (zoption = http_curl_getopt1(options, "referer", IS_STRING)) {
+ curl_easy_setopt(ch, CURLOPT_REFERER, Z_STRVAL_P(zoption));
+ }
+
+ /* useragent */
+ if (zoption = http_curl_getopt1(options, "useragent", IS_STRING)) {
+ curl_easy_setopt(ch, CURLOPT_USERAGENT, Z_STRVAL_P(zoption));
+ }
+
+ /* cookies */
+ if (zoption = http_curl_getopt1(options, "cookies", IS_ARRAY)) {
+ zval cookies, glue;
+ ZVAL_STRINGL(&glue, "; ", 2, 0);
+ php_implode(&glue, zoption, &cookies);
+ if (Z_STRVAL(cookies)) {
+ curl_easy_setopt(ch, CURLOPT_COOKIE, Z_STRVAL(cookies));
+ }
+ }
+
+ /* cookiestore */
+ if (zoption = http_curl_getopt1(options, "cookiestore", IS_STRING)) {
+ curl_easy_setopt(ch, CURLOPT_COOKIEFILE, Z_STRVAL_P(zoption));
+ curl_easy_setopt(ch, CURLOPT_COOKIEJAR, Z_STRVAL_P(zoption));
+ }
+
+ /* additional headers */
+ if (zoption = http_curl_getopt1(options, "headers", IS_ARRAY)) {
+ zval **header;
+ struct curl_slist *headers = NULL;
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(zoption));
+ while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void **) &header)) {
+ headers = curl_slist_append(headers, Z_STRVAL_PP(header));
+ zend_hash_move_forward(Z_ARRVAL_P(zoption));
+ }
+ if (headers) {
+ curl_easy_setopt(ch, CURLOPT_HTTPHEADER, headers);
+ }
+ }
+}
+/* }}} */
+
+#endif
+/* }}} HAVE_CURL */
+
+static int check_day(char *day, size_t len)
+{
+ int i;
+ const char * const *check = (len > 3) ? &weekdays[0] : &wkdays[0];
+ for (i = 0; i < 7; i++) {
+ if (!strcmp(day, check[0])) {
+ return i;
+ }
+ check++;
+ }
+ return -1;
+}
+
+static int check_month(char *month)
+{
+ int i;
+ const char * const *check = &months[0];
+ for (i = 0; i < 12; i++) {
+ if (!strcmp(month, check[0])) {
+ return i;
+ }
+ check++;
+ }
+ return -1;
+}
+
+/* return the time zone offset between GMT and the input one, in number
+ of seconds or -1 if the timezone wasn't found/legal */
+
+static int check_tzone(char *tzone)
+{
+ int i;
+ const struct time_zone *check = time_zones;
+ for (i = 0; i < sizeof(time_zones) / sizeof(time_zones[0]); i++) {
+ if (!strcmp(tzone, check->name)) {
+ return check->offset * 60;
+ }
+ check++;
+ }
+ return -1;
+}
+
+/* }}} internals */
+
+/* {{{ public API */
+
+/* {{{ char *http_date(time_t) */
+PHP_HTTP_API char *_http_date(time_t t TSRMLS_DC)
+{
+ struct tm *gmtime, tmbuf;
+ char *date = ecalloc(1, 30);
+
+ gmtime = php_gmtime_r(&t, &tmbuf);
+ snprintf(date, 30,
+ "%s, %02d %s %04d %02d:%02d:%02d GMT",
+ days[gmtime->tm_wday], gmtime->tm_mday,
+ months[gmtime->tm_mon], gmtime->tm_year + 1900,
+ gmtime->tm_hour, gmtime->tm_min, gmtime->tm_sec
+ );
+ return date;
+}
+/* }}} */
+
+/* time_t http_parse_date(char *)
+ Originally by libcurl, Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al. */
+PHP_HTTP_API time_t http_parse_date(const char *date)
+{
+ time_t t = 0;
+ int tz_offset = -1, year = -1, month = -1, monthday = -1, weekday = -1,
+ hours = -1, minutes = -1, seconds = -1;
+ struct tm tm;
+ enum assume_next dignext = DATE_MDAY;
+ const char *indate = date;
+
+ int found = 0, part = 0; /* max 6 parts */
+
+ while (*date && (part < 6)) {
+ int found = 0;
+
+ while (*date && !isalnum(*date)) {
+ date++;
+ }
+
+ if (isalpha(*date)) {
+ /* a name coming up */
+ char buf[32] = "";
+ size_t len;
+ sscanf(date, "%31[A-Za-z]", buf);
+ len = strlen(buf);
+
+ if (weekday == -1) {
+ weekday = check_day(buf, len);
+ if (weekday != -1) {
+ found = 1;
+ }
+ }
+
+ if (!found && (month == -1)) {
+ month = check_month(buf);
+ if (month != -1) {
+ found = 1;
+ }
+ }
+
+ if (!found && (tz_offset == -1)) {
+ /* this just must be a time zone string */
+ tz_offset = check_tzone(buf);
+ if (tz_offset != -1) {
+ found = 1;
+ }
+ }
+
+ if (!found) {
+ return -1; /* bad string */
+ }
+ date += len;
+ }
+ else if (isdigit(*date)) {
+ /* a digit */
+ int val;
+ char *end;
+ if((seconds == -1) && (3 == sscanf(date, "%02d:%02d:%02d", &hours, &minutes, &seconds))) {
+ /* time stamp! */
+ date += 8;
+ found = 1;
+ }
+ else {
+ val = (int) strtol(date, &end, 10);
+
+ if ((tz_offset == -1) && ((end - date) == 4) && (val < 1300) && (indate < date) && ((date[-1] == '+' || date[-1] == '-'))) {
+ /* four digits and a value less than 1300 and it is preceeded with
+ a plus or minus. This is a time zone indication. */
+ found = 1;
+ tz_offset = (val / 100 * 60 + val % 100) * 60;
+
+ /* the + and - prefix indicates the local time compared to GMT,
+ this we need ther reversed math to get what we want */
+ tz_offset = date[-1] == '+' ? -tz_offset : tz_offset;
+ }
+
+ if (((end - date) == 8) && (year == -1) && (month == -1) && (monthday == -1)) {
+ /* 8 digits, no year, month or day yet. This is YYYYMMDD */
+ found = 1;
+ year = val / 10000;
+ month = (val % 10000) / 100 - 1; /* month is 0 - 11 */
+ monthday = val % 100;
+ }
+
+ if (!found && (dignext == DATE_MDAY) && (monthday == -1)) {
+ if ((val > 0) && (val < 32)) {
+ monthday = val;
+ found = 1;
+ }
+ dignext = DATE_YEAR;
+ }
+
+ if (!found && (dignext == DATE_YEAR) && (year == -1)) {
+ year = val;
+ found = 1;
+ if (year < 1900) {
+ year += year > 70 ? 1900 : 2000;
+ }
+ if(monthday == -1) {
+ dignext = DATE_MDAY;
+ }
+ }
+
+ if (!found) {
+ return -1;
+ }
+
+ date = end;
+ }
+ }
+
+ part++;
+ }
+
+ if (-1 == seconds) {
+ seconds = minutes = hours = 0; /* no time, make it zero */
+ }
+
+ if ((-1 == monthday) || (-1 == month) || (-1 == year)) {
+ /* lacks vital info, fail */
+ return -1;
+ }
+
+ if (sizeof(time_t) < 5) {
+ /* 32 bit time_t can only hold dates to the beginning of 2038 */
+ if (year > 2037) {
+ return 0x7fffffff;
+ }
+ }
+
+ tm.tm_sec = seconds;
+ tm.tm_min = minutes;
+ tm.tm_hour = hours;
+ tm.tm_mday = monthday;
+ tm.tm_mon = month;
+ tm.tm_year = year - 1900;
+ tm.tm_wday = 0;
+ tm.tm_yday = 0;
+ tm.tm_isdst = 0;
+
+ t = mktime(&tm);
+
+ /* time zone adjust */
+ {
+ struct tm *gmt, keeptime2;
+ long delta;
+ time_t t2;
+
+ if(!(gmt = php_gmtime_r(&t, &keeptime2))) {
+ return -1; /* illegal date/time */
+ }
+
+ t2 = mktime(gmt);
+
+ /* Add the time zone diff (between the given timezone and GMT) and the
+ diff between the local time zone and GMT. */
+ delta = (tz_offset != -1 ? tz_offset : 0) + (t - t2);
+
+ if((delta > 0) && (t + delta < t)) {
+ return -1; /* time_t overflow */
+ }
+
+ t += delta;
+ }
+
+ return t;
+}
+/* }}} */
+
+/* {{{ inline STATUS http_send_status(int) */
+PHP_HTTP_API inline STATUS _http_send_status(const int status TSRMLS_DC)
+{
+ int s = status;
+ return sapi_header_op(SAPI_HEADER_SET_STATUS, (void *) s TSRMLS_CC);
+}
+/* }}} */
+
+/* {{{ inline STATUS http_send_header(char *) */
+PHP_HTTP_API inline STATUS _http_send_header(const char *header TSRMLS_DC)
+{
+ return http_send_status_header(0, header);
+}
+/* }}} */
+
+/* {{{ inline STATUS http_send_status_header(int, char *) */
+PHP_HTTP_API inline STATUS _http_send_status_header(const int status, const char *header TSRMLS_DC)
+{
+ sapi_header_line h = {(char *) header, strlen(header), status};
+ return sapi_header_op(SAPI_HEADER_REPLACE, &h TSRMLS_CC);
+}
+/* }}} */
+
+/* {{{ inline zval *http_get_server_var(char *) */
+PHP_HTTP_API inline zval *_http_get_server_var(const char *key TSRMLS_DC)
+{
+ zval **var;
+ if (SUCCESS == zend_hash_find(
+ Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]),
+ (char *) key, strlen(key) + 1, (void **) &var)) {
+ return *var;
+ }
+ return NULL;
+}
+/* }}} */
+
+/* {{{ void http_ob_etaghandler(char *, uint, char **, uint *, int) */
+PHP_HTTP_API void _http_ob_etaghandler(char *output, uint output_len,
+ char **handled_output, uint *handled_output_len, int mode TSRMLS_DC)
+{
+ char etag[33] = { 0 };
+ unsigned char digest[16];
+
+ if (mode & PHP_OUTPUT_HANDLER_START) {
+ PHP_MD5Init(&HTTP_G(etag_md5));
+ }
+
+ PHP_MD5Update(&HTTP_G(etag_md5), output, output_len);
+
+ if (mode & PHP_OUTPUT_HANDLER_END) {
+ PHP_MD5Final(digest, &HTTP_G(etag_md5));
+ make_digest(etag, digest);
+
+ if (http_etag_match("HTTP_IF_NONE_MATCH", etag)) {
+ http_send_status(304);
+ } else {
+ http_send_etag(etag, 32);
+ }
+ }
+
+ *handled_output_len = output_len;
+ *handled_output = estrndup(output, output_len);
+}
+/* }}} */
+
+/* {{{ int http_modified_match(char *, int) */
+PHP_HTTP_API int _http_modified_match(const char *entry, const time_t t TSRMLS_DC)
+{
+ int retval;
+ zval *zmodified;
+ char *modified, *chr_ptr;
+
+ HTTP_GSC(zmodified, entry, 0);
+
+ modified = estrndup(Z_STRVAL_P(zmodified), Z_STRLEN_P(zmodified));
+ if (chr_ptr = strrchr(modified, ';')) {
+ chr_ptr = 0;
+ }
+ retval = (t <= http_parse_date(modified));
+ efree(modified);
+ return retval;
+}
+/* }}} */
+
+/* {{{ int http_etag_match(char *, char *) */
+PHP_HTTP_API int _http_etag_match(const char *entry, const char *etag TSRMLS_DC)
+{
+ zval *zetag;
+ char *quoted_etag;
+ STATUS result;
+
+ HTTP_GSC(zetag, entry, 0);
+
+ if (NULL != strchr(Z_STRVAL_P(zetag), '*')) {
+ return 1;
+ }
+
+ quoted_etag = (char *) emalloc(strlen(etag) + 3);
+ sprintf(quoted_etag, "\"%s\"", etag);
+
+ if (!strchr(Z_STRVAL_P(zetag), ',')) {
+ result = !strcmp(Z_STRVAL_P(zetag), quoted_etag);
+ } else {
+ result = (NULL != strstr(Z_STRVAL_P(zetag), quoted_etag));
+ }
+
+ efree(quoted_etag);
+ return result;
+}
+/* }}} */
+
+/* {{{ STATUS http_send_last_modified(int) */
+PHP_HTTP_API STATUS _http_send_last_modified(const int t TSRMLS_DC)
+{
+ char modified[96] = "Last-Modified: ", *date;
+ date = http_date(t);
+ strcat(modified, date);
+ efree(date);
+ return http_send_header(modified);
+}
+/* }}} */
+
+/* {{{ static STATUS http_send_etag(char *, int) */
+PHP_HTTP_API STATUS _http_send_etag(const char *etag,
+ const int etag_len TSRMLS_DC)
+{
+ STATUS ret;
+ int header_len;
+ char *etag_header;
+
+ header_len = strlen("ETag: \"\"") + etag_len + 1;
+ etag_header = (char *) emalloc(header_len);
+ snprintf(etag_header, header_len, "ETag: \"%s\"", etag);
+ ret = http_send_header(etag_header);
+ efree(etag_header);
+ return ret;
+}
+/* }}} */
+
+/* {{{ char *http_absolute_uri(char *, char *) */
+PHP_HTTP_API char *_http_absolute_uri(const char *url,
+ const char *proto TSRMLS_DC)
+{
+ char URI[HTTP_URI_MAXLEN + 1], *PTR, *proto_ptr, *host, *path;
+ zval *zhost;
+
+ if (!url || !strlen(url)) {
+ if (!SG(request_info).request_uri) {
+ return NULL;
+ }
+ url = SG(request_info).request_uri;
+ }
+ /* Mess around with already absolute URIs */
+ else if (proto_ptr = strstr(url, "://")) {
+ if (!proto || !strncmp(url, proto, strlen(proto))) {
+ return estrdup(url);
+ } else {
+ snprintf(URI, HTTP_URI_MAXLEN, "%s%s", proto, proto_ptr + 3);
+ return estrdup(URI);
+ }
+ }
+
+ /* protocol defaults to http */
+ if (!proto || !strlen(proto)) {
+ proto = "http";
+ }
+
+ /* get host name */
+ if ( (zhost = http_get_server_var("HTTP_HOST")) ||
+ (zhost = http_get_server_var("SERVER_NAME"))) {
+ host = Z_STRVAL_P(zhost);
+ } else {
+ host = "localhost";
+ }
+
+
+ /* glue together */
+ if (url[0] == '/') {
+ snprintf(URI, HTTP_URI_MAXLEN, "%s://%s%s", proto, host, url);
+ } else if (SG(request_info).request_uri) {
+ path = estrdup(SG(request_info).request_uri);
+ php_dirname(path, strlen(path));
+ snprintf(URI, HTTP_URI_MAXLEN, "%s://%s%s/%s", proto, host, path, url);
+ efree(path);
+ } else {
+ snprintf(URI, HTTP_URI_MAXLEN, "%s://%s/%s", proto, host, url);
+ }
+
+ /* strip everything after a new line */
+ PTR = URI;
+ while (*PTR != 0) {
+ if (*PTR == '\n' || *PTR == '\r') {
+ *PTR = 0;
+ break;
+ }
+ PTR++;
+ }
+
+ return estrdup(URI);
+}
+/* }}} */
+
+/* {{{ char *http_negotiate_q(char *, zval *, char *, hash_entry_type) */
+PHP_HTTP_API char *_http_negotiate_q(const char *entry, const zval *supported,
+ const char *def TSRMLS_DC)
+{
+ zval *zaccept, *zarray, *zdelim, **zentry, *zentries, **zsupp;
+ char *q_ptr, *result;
+ int i, c;
+ double qual;
+
+ HTTP_GSC(zaccept, entry, estrdup(def));
+
+ MAKE_STD_ZVAL(zarray);
+ array_init(zarray);
+
+ MAKE_STD_ZVAL(zdelim);
+ ZVAL_STRING(zdelim, ",", 0);
+ php_explode(zdelim, zaccept, zarray, -1);
+ efree(zdelim);
+
+ MAKE_STD_ZVAL(zentries);
+ array_init(zentries);
+
+ c = zend_hash_num_elements(Z_ARRVAL_P(zarray));
+ for (i = 0; i < c; i++, zend_hash_move_forward(Z_ARRVAL_P(zarray))) {
+
+ if (SUCCESS != zend_hash_get_current_data(
+ Z_ARRVAL_P(zarray), (void **) &zentry)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ "Cannot parse %s header: %s", entry, Z_STRVAL_P(zaccept));
+ break;
+ }
+
+ /* check for qualifier */
+ if (NULL != (q_ptr = strrchr(Z_STRVAL_PP(zentry), ';'))) {
+ qual = strtod(q_ptr + 3, NULL);
+ } else {
+ qual = 1000.0 - 1;
+ }
+
+ /* walk through the supported array */
+ for ( zend_hash_internal_pointer_reset(Z_ARRVAL_P(supported));
+ SUCCESS == zend_hash_get_current_data(
+ Z_ARRVAL_P(supported), (void **) &zsupp);
+ zend_hash_move_forward(Z_ARRVAL_P(supported))) {
+ if (!strcasecmp(Z_STRVAL_PP(zsupp), Z_STRVAL_PP(zentry))) {
+ add_assoc_double(zentries, Z_STRVAL_PP(zsupp), qual);
+ break;
+ }
+ }
+ }
+
+ zval_dtor(zarray);
+ efree(zarray);
+
+ zend_hash_internal_pointer_reset(Z_ARRVAL_P(zentries));
+
+ if ( (SUCCESS != zend_hash_sort(Z_ARRVAL_P(zentries), zend_qsort,
+ http_sort_q, 0 TSRMLS_CC)) ||
+ (HASH_KEY_NON_EXISTANT == zend_hash_get_current_key(
+ Z_ARRVAL_P(zentries), &result, 0, 1))) {
+ result = estrdup(def);
+ }
+
+ zval_dtor(zentries);
+ efree(zentries);
+
+ return result;
+}
+/* }}} */
+
+/* {{{ http_range_status http_get_request_ranges(zval *zranges, size_t) */
+PHP_HTTP_API http_range_status _http_get_request_ranges(zval *zranges,
+ const size_t length TSRMLS_DC)
+{
+ zval *zrange, *zentry, **zentries;
+ char *range, c;
+ long begin = -1, end = -1, *ptr;
+
+ HTTP_GSC(zrange, "HTTP_RANGE", RANGE_NO);
+ range = Z_STRVAL_P(zrange);
+
+ if (strncmp(range, "bytes=", strlen("bytes="))) {
+ php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Range header misses bytes=");
+ return RANGE_ERR;
+ }
+
+ ptr = &begin;
+ range += strlen("bytes=");
+
+ do {
+ switch (c = *(range++))
+ {
+ case '0':
+ *ptr *= 10;
+ break;
+
+ case '1': case '2': case '3':
+ case '4': case '5': case '6':
+ case '7': case '8': case '9':
+ /*
+ * If the value of the pointer is already set (non-negative)
+ * then multiply its value by ten and add the current value,
+ * else initialise the pointers value with the current value
+ * --
+ * This let us recognize empty fields when validating the
+ * ranges, i.e. a "-10" for begin and "12345" for the end
+ * was the following range request: "Range: bytes=0-12345";
+ * While a "-1" for begin and "12345" for the end would
+ * have been: "Range: bytes=-12345".
+ */
+ if (*ptr > 0) {
+ *ptr *= 10;
+ *ptr += c - '0';
+ } else {
+ *ptr = c - '0';
+ }
+ break;
+
+ case '-':
+ ptr = &end;
+ break;
+
+ case 0:
+ case ',':
+
+ if (length) {
+ /* validate ranges */
+ switch (begin)
+ {
+ /* "0-12345" */
+ case -10:
+ if ((length - end) < 1) {
+ return RANGE_ERR;
+ }
+ begin = 0;
+ break;
+
+ /* "-12345" */
+ case -1:
+ if ((length - end) < 1) {
+ return RANGE_ERR;
+ }
+ begin = length - end;
+ end = length;
+ break;
+
+ /* "12345-(xxx)" */
+ default:
+ switch (end)
+ {
+ /* "12345-" */
+ case -1:
+ if ((length - begin) < 1) {
+ return RANGE_ERR;
+ }
+ end = length - 1;
+ break;
+
+ /* "12345-67890" */
+ default:
+ if ( ((length - begin) < 1) ||
+ ((length - end) < 1) ||
+ ((begin - end) >= 0)) {
+ return RANGE_ERR;
+ }
+ break;
+ }
+ break;
+ }
+ }
+
+ zentry = (zval *) zentries++;
+ MAKE_STD_ZVAL(zentry);
+ array_init(zentry);
+ add_index_long(zentry, 0, begin);
+ add_index_long(zentry, 1, end);
+ add_next_index_zval(zranges, zentry);
+
+ begin = -1;
+ end = -1;
+ ptr = &begin;
+ break;
+
+ default:
+ return RANGE_ERR;
+ break;
+ }
+ } while (c != 0);
+
+ return RANGE_OK;
+}
+/* }}} */
+
+/* {{{ STATUS http_send_ranges(zval *, void *, size_t, http_send_mode) */
+PHP_HTTP_API STATUS _http_send_ranges(zval *zranges, const void *data, const size_t size, const http_send_mode mode TSRMLS_DC)
+{
+ zval **zrange;
+ long b, e, **begin, **end;
+ char range_header[255], multi_header[68] = "Content-Type: multipart/byteranges; boundary=", bound[23], preface[1024];
+ int i, c;
+
+ /* Send HTTP 206 Partial Content */
+ http_send_status(206);
+
+ /* single range */
+ if ((c = zend_hash_num_elements(Z_ARRVAL_P(zranges))) == 1) {
+ zend_hash_index_find(Z_ARRVAL_P(zranges), 0, (void **) &zrange);
+ zend_hash_index_find(Z_ARRVAL_PP(zrange), 0, (void **) &begin);
+ zend_hash_index_find(Z_ARRVAL_PP(zrange), 1, (void **) &end);
+
+ /* so zranges can be freed */
+ b = **begin;
+ e = **end;
+
+ /* free zranges */
+ zval_dtor(zranges);
+ efree(zranges);
+
+ /* send content range header */
+ snprintf(range_header, 255, "Content-Range: bytes %d-%d/%d", b, e, size);
+ http_send_header(range_header);
+
+ /* send requested chunk */
+ return http_send_chunk(data, b, e + 1, mode);
+ }
+
+ /* multi range */
+
+ snprintf(bound, 23, "--%d%0.9f", time(NULL), php_combined_lcg(TSRMLS_C));
+ strncat(multi_header, bound + 2, 21);
+ http_send_header(multi_header);
+
+ /* send each requested chunk */
+ for ( i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(zranges));
+ i < c;
+ i++, zend_hash_move_forward(Z_ARRVAL_P(zranges))) {
+ if ( HASH_KEY_NON_EXISTANT == zend_hash_get_current_data(
+ Z_ARRVAL_P(zranges), (void **) &zrange) ||
+ SUCCESS != zend_hash_index_find(
+ Z_ARRVAL_PP(zrange), 0, (void **) &begin) ||
+ SUCCESS != zend_hash_index_find(
+ Z_ARRVAL_PP(zrange), 1, (void **) &end)) {
+ break;
+ }
+
+ snprintf(preface, 1024,
+ "\r\n%s\r\nContent-Type: %s\r\nContent-Range: bytes %d-%d/%d\r\n\r\n", bound,
+ HTTP_G(ctype) ? HTTP_G(ctype) : "application/x-octetstream",
+ **begin, **end, size);
+ php_body_write(preface, strlen(preface) TSRMLS_CC);
+ http_send_chunk(data, **begin, **end + 1, mode);
+
+ }
+
+ /* free zranges */
+ zval_dtor(zranges);
+ efree(zranges);
+
+ /* write boundary once more */
+ php_body_write("\n", 1 TSRMLS_CC);
+ php_body_write(bound, strlen(bound) TSRMLS_CC);
+
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ STATUS http_send(void *, sizezo_t, http_send_mode) */
+PHP_HTTP_API STATUS _http_send(const void *data_ptr, const size_t data_size,
+ const http_send_mode data_mode TSRMLS_DC)
+{
+ zval *zranges = NULL;
+
+ if (!data_ptr) {
+ return FAILURE;
+ }
+
+ /* never ever use the output to compute the ETag if http_send() is used */
+ if (HTTP_G(etag_started)) {
+ char *new_etag = (char *) emalloc(33);
+
+ php_end_ob_buffer(0, 0 TSRMLS_CC);
+ if (NULL == http_etag(&new_etag, data_ptr, data_size, data_mode)) {
+ efree(new_etag);
+ return FAILURE;
+ }
+
+ /* send 304 Not Modified if etag matches */
+ if (http_etag_match("HTTP_IF_NONE_MATCH", new_etag)) {
+ efree(new_etag);
+ return http_send_status(304);
+ }
+
+ http_send_etag(new_etag, 32);
+ efree(new_etag);
+ }
+
+ if (http_is_range_request()) {
+
+ MAKE_STD_ZVAL(zranges);
+ array_init(zranges);
+
+ switch (http_get_request_ranges(zranges, data_size))
+ {
+ case RANGE_NO:
+ zval_dtor(zranges);
+ efree(zranges);
+ /* go ahead and send all */
+ break;
+
+ case RANGE_OK:
+ return http_send_ranges(zranges, data_ptr, data_size, data_mode);
+ break;
+
+ case RANGE_ERR:
+ zval_dtor(zranges);
+ efree(zranges);
+ http_send_status(416);
+ return FAILURE;
+ break;
+
+ default:
+ return FAILURE;
+ break;
+ }
+ }
+ /* send all */
+ return http_send_chunk(data_ptr, 0, data_size, data_mode);
+}
+/* }}} */
+
+/* {{{ STATUS http_send_data(zval *) */
+PHP_HTTP_API STATUS _http_send_data(const zval *zdata TSRMLS_DC)
+{
+ if (!Z_STRLEN_P(zdata)) {
+ return SUCCESS;
+ }
+ if (!Z_STRVAL_P(zdata)) {
+ return FAILURE;
+ }
+
+ return http_send((void *) zdata, Z_STRLEN_P(zdata), SEND_DATA);
+}
+/* }}} */
+
+/* {{{ STATUS http_send_stream(php_stream *) */
+PHP_HTTP_API STATUS _http_send_stream(const php_stream *file TSRMLS_DC)
+{
+ if (php_stream_stat((php_stream *) file, &HTTP_G(ssb))) {
+ return FAILURE;
+ }
+
+ return http_send((void *) file, HTTP_G(ssb).sb.st_size, SEND_RSRC);
+}
+/* }}} */
+
+/* {{{ STATUS http_send_file(zval *) */
+PHP_HTTP_API STATUS _http_send_file(const zval *zfile TSRMLS_DC)
+{
+ php_stream *file;
+ STATUS ret;
+
+ if (!Z_STRLEN_P(zfile)) {
+ return FAILURE;
+ }
+
+ if (!(file = php_stream_open_wrapper(Z_STRVAL_P(zfile), "rb",
+ REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL))) {
+ return FAILURE;
+ }
+
+ ret = http_send_stream(file);
+ php_stream_close(file);
+ return ret;
+}
+/* }}} */
+
+/* {{{ proto STATUS http_chunked_decode(char *, size_t, char **, size_t *) */
+PHP_HTTP_API STATUS _http_chunked_decode(const char *encoded,
+ const size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC)
+{
+ const char *e_ptr;
+ char *d_ptr;
+
+ *decoded_len = 0;
+ *decoded = (char *) ecalloc(1, encoded_len);
+ d_ptr = *decoded;
+ e_ptr = encoded;
+
+ while (((e_ptr - encoded) - encoded_len) > 0) {
+ char hex_len[9] = {0};
+ size_t chunk_len = 0;
+ int i = 0;
+
+ /* read in chunk size */
+ while (isxdigit(*e_ptr)) {
+ if (i == 9) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ "Chunk size is too long: 0x%s...", hex_len);
+ efree(*decoded);
+ return FAILURE;
+ }
+ hex_len[i++] = *e_ptr++;
+ }
+
+ /* hex to long */
+ if (strcmp(hex_len, "0")) {
+ char *error = NULL;
+ chunk_len = strtol(hex_len, &error, 16);
+ if (error == hex_len) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ "Invalid chunk size string: '%s'", hex_len);
+ efree(*decoded);
+ return FAILURE;
+ }
+ } else {
+ break;
+ }
+
+ /* new line */
+ if (*e_ptr++ != '\r' || *e_ptr++ != '\n') {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING,
+ "Invalid character (expected 0x0A, 0x0D; got: %x)",
+ *(e_ptr - 1));
+ efree(*decoded);
+ return FAILURE;
+ }
+
+ memcpy(d_ptr, e_ptr, chunk_len);
+ d_ptr += chunk_len;
+ e_ptr += chunk_len + 2;
+ *decoded_len += chunk_len;
+ }
+
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto void http_split_response(zval *, zval *, zval *) */
+PHP_HTTP_API void _http_split_response(const zval *zresponse, zval *zheaders,
+ zval *zbody TSRMLS_DC)
+{
+ char *header, *response, *body = NULL;
+ long response_len = Z_STRLEN_P(zresponse);
+ header = response = Z_STRVAL_P(zresponse);
+
+ while ((response - Z_STRVAL_P(zresponse) + 3) < response_len) {
+ if ( (*response++ == '\r') &&
+ (*response++ == '\n') &&
+ (*response++ == '\r') &&
+ (*response++ == '\n')) {
+ body = response;
+ break;
+ }
+ }
+
+ if (body && (response_len - (body - header))) {
+ ZVAL_STRINGL(zbody, body, response_len - (body - header) - 1, 1);
+ } else {
+ Z_TYPE_P(zbody) = IS_NULL;
+ }
+
+ /* check for HTTP status - FIXXME: strchr() */
+ if (!strncmp(header, "HTTP/1.", 7)) {
+ char *end = strchr(header, '\r');
+ add_assoc_stringl(zheaders, "Status",
+ header + strlen("HTTP/1.x "),
+ end - (header + strlen("HTTP/1.x ")), 1);
+ header = end + 2;
+ }
+ /* split headers */
+ {
+ char *colon = NULL, *line = header;
+
+ while ( (line - Z_STRVAL_P(zresponse) + 3) <
+ (body - Z_STRVAL_P(zresponse))) {
+ switch (*line++)
+ {
+ case '\r':
+ if (colon && (*line == '\n')) {
+ char *key = estrndup(header, colon - header);
+ add_assoc_stringl(zheaders, key,
+ colon + 2, line - colon - 3, 1);
+ efree(key);
+
+ colon = NULL;
+ header += line - header + 1;
+ }
+ break;
+
+ case ':':
+ if (!colon) {
+ colon = line - 1;
+ }
+ break;
+ }
+ }
+ }
+}
+/* }}} */
+
+/* {{{ HAVE_CURL */
+#if defined(HAVE_CURL) && HAVE_CURL
+
+/* {{{ STATUS http_get(char *, HashTable *, char **, size_t *) */
+PHP_HTTP_API STATUS _http_get(const char *URL, HashTable *options,
+ char **data, size_t *data_len TSRMLS_DC)
+{
+ CURL *ch = curl_easy_init();
+
+ if (!ch) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not initialize curl");
+ return FAILURE;
+ }
+
+ http_curl_initbuf(CURLBUF_EVRY);
+ http_curl_setopts(ch, URL, options);
+
+ if (CURLE_OK != curl_easy_perform(ch)) {
+ curl_easy_cleanup(ch);
+ http_curl_freebuf(CURLBUF_EVRY);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not perform request");
+ return FAILURE;
+ }
+ curl_easy_cleanup(ch);
+
+ http_curl_movebuf(CURLBUF_EVRY, data, data_len);
+
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ STATUS http_head(char *, HashTable *, char **data, size_t *) */
+PHP_HTTP_API STATUS _http_head(const char *URL, HashTable *options,
+ char **data, size_t *data_len TSRMLS_DC)
+{
+ CURL *ch = curl_easy_init();
+
+ if (!ch) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not initialize curl");
+ return FAILURE;
+ }
+
+ http_curl_initbuf(CURLBUF_HDRS);
+ http_curl_setopts(ch, URL, options);
+ curl_easy_setopt(ch, CURLOPT_NOBODY, 1);
+
+ if (CURLE_OK != curl_easy_perform(ch)) {
+ curl_easy_cleanup(ch);
+ http_curl_freebuf(CURLBUF_HDRS);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not perform request");
+ return FAILURE;
+ }
+ curl_easy_cleanup(ch);
+
+ http_curl_movebuf(CURLBUF_HDRS, data, data_len);
+
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ STATUS http_post_data(char *, char *, size_t, HashTable *, char **, size_t *) */
+PHP_HTTP_API STATUS _http_post_data(const char *URL, char *postdata,
+ size_t postdata_len, HashTable *options, char **data,
+ size_t *data_len TSRMLS_DC)
+{
+ CURL *ch = curl_easy_init();
+
+ if (!ch) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not initialize curl");
+ return FAILURE;
+ }
+
+ http_curl_initbuf(CURLBUF_EVRY);
+ http_curl_setopts(ch, URL, options);
+ curl_easy_setopt(ch, CURLOPT_POST, 1);
+ curl_easy_setopt(ch, CURLOPT_POSTFIELDS, postdata);
+ curl_easy_setopt(ch, CURLOPT_POSTFIELDSIZE, postdata_len);
+
+ if (CURLE_OK != curl_easy_perform(ch)) {
+ curl_easy_cleanup(ch);
+ http_curl_freebuf(CURLBUF_EVRY);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not perform request");
+ return FAILURE;
+ }
+ curl_easy_cleanup(ch);
+
+ http_curl_movebuf(CURLBUF_EVRY, data, data_len);
+
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ STATUS http_post_array(char *, HashTable *, HashTable *, char **, size_t *) */
+PHP_HTTP_API STATUS _http_post_array(const char *URL, HashTable *postarray,
+ HashTable *options, char **data, size_t *data_len TSRMLS_DC)
+{
+ smart_str qstr = {0};
+ STATUS status;
+
+ if (php_url_encode_hash_ex(postarray, &qstr, NULL,0,NULL,0,NULL,0,NULL TSRMLS_CC) != SUCCESS) {
+ if (qstr.c) {
+ efree(qstr.c);
+ }
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not encode post data");
+ return FAILURE;
+ }
+ smart_str_0(&qstr);
+
+ status = http_post_data(URL, qstr.c, qstr.len, options, data, data_len);
+ if (qstr.c) {
+ efree(qstr.c);
+ }
+ return status;
+}
+/* }}} */
+
+#endif
+/* }}} HAVE_CURL */
+
+/* {{{ void http_auth_header(char *, char*) */
+PHP_HTTP_API void _http_auth_header(const char *type, const char *realm TSRMLS_DC)
+{
+ char realm_header[1024];
+ snprintf(realm_header, 1024, "WWW-Authenticate: %s realm=\"%s\"", type, realm);
+ http_send_status_header(401, realm_header);
+}
+/* }}} */
+
+/* {{{ STATUS http_auth_credentials(char **, char **) */
+PHP_HTTP_API STATUS _http_auth_credentials(char **user, char **pass TSRMLS_DC)
+{
+ if (strncmp(sapi_module.name, "isapi", 5)) {
+ zval *zuser, *zpass;
+
+ HTTP_GSC(zuser, "PHP_AUTH_USER", FAILURE);
+ HTTP_GSC(zpass, "PHP_AUTH_PW", FAILURE);
+
+ *user = estrndup(Z_STRVAL_P(zuser), Z_STRLEN_P(zuser));
+ *pass = estrndup(Z_STRVAL_P(zpass), Z_STRLEN_P(zpass));
+
+ return SUCCESS;
+ } else {
+ zval *zauth = NULL;
+ HTTP_GSC(zauth, "HTTP_AUTHORIZATION", FAILURE);
+ {
+ char *decoded, *colon;
+ int decoded_len;
+ decoded = php_base64_decode(Z_STRVAL_P(zauth), Z_STRLEN_P(zauth),
+ &decoded_len);
+
+ if (colon = strchr(decoded + 6, ':')) {
+ *user = estrndup(decoded + 6, colon - decoded - 6);
+ *pass = estrndup(colon + 1, decoded + decoded_len - colon - 6 - 1);
+
+ return SUCCESS;
+ } else {
+ return FAILURE;
+ }
+ }
+ }
+}
+/* }}} */
+
+/* }}} public API */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP Version 5 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997-2004 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.0 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available through the world-wide-web at the following url: |
+ | http://www.php.net/license/3_0.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: Sara Golemon <pollita@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#include "php_http.h"
+#include "php_ini.h"
+#include "ext/standard/url.h"
+
+#define URL_DEFAULT_ARG_SEP "&"
+
+/* {{{ php_url_encode_hash */
+PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
+ const char *num_prefix, int num_prefix_len,
+ const char *key_prefix, int key_prefix_len,
+ const char *key_suffix, int key_suffix_len,
+ zval *type TSRMLS_DC)
+{
+ char *arg_sep = NULL, *key = NULL, *ekey, *newprefix, *p;
+ int arg_sep_len, key_len, ekey_len, key_type, newprefix_len;
+ ulong idx;
+ zval **zdata = NULL, *copyzval;
+
+ if (!ht) {
+ return FAILURE;
+ }
+
+ if (ht->nApplyCount > 0) {
+ /* Prevent recursion */
+ return SUCCESS;
+ }
+
+ arg_sep = INI_STR("arg_separator.output");
+ if (!arg_sep || !strlen(arg_sep)) {
+ arg_sep = URL_DEFAULT_ARG_SEP;
+ }
+ arg_sep_len = strlen(arg_sep);
+
+ for (zend_hash_internal_pointer_reset(ht);
+ (key_type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL)) != HASH_KEY_NON_EXISTANT;
+ zend_hash_move_forward(ht)
+ ) {
+ if (key_type == HASH_KEY_IS_STRING && key_len && key[key_len-1] == '\0') {
+ /* We don't want that trailing NULL */
+ key_len -= 1;
+ }
+
+ /* handling for private & protected object properties */
+ if (key && *key == '\0' && type != NULL) {
+ char *tmp;
+
+ zend_object *zobj = zend_objects_get_address(type TSRMLS_CC);
+ if (zend_check_property_access(zobj, key TSRMLS_CC) != SUCCESS) {
+ /* private or protected property access outside of the class */
+ continue;
+ }
+ zend_unmangle_property_name(key, &tmp, &key);
+ key_len = strlen(key);
+ }
+
+ if (zend_hash_get_current_data_ex(ht, (void **)&zdata, NULL) == FAILURE || !zdata || !(*zdata)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error traversing form data array.");
+ return FAILURE;
+ }
+ if (Z_TYPE_PP(zdata) == IS_ARRAY || Z_TYPE_PP(zdata) == IS_OBJECT) {
+ if (key_type == HASH_KEY_IS_STRING) {
+ ekey = php_url_encode(key, key_len, &ekey_len);
+ newprefix_len = key_suffix_len + ekey_len + key_prefix_len + 1;
+ newprefix = emalloc(newprefix_len + 1);
+ p = newprefix;
+
+ if (key_prefix) {
+ memcpy(p, key_prefix, key_prefix_len);
+ p += key_prefix_len;
+ }
+
+ memcpy(p, ekey, ekey_len);
+ p += ekey_len;
+ efree(ekey);
+
+ if (key_suffix) {
+ memcpy(p, key_suffix, key_suffix_len);
+ p += key_suffix_len;
+ }
+
+ *(p++) = '[';
+ *p = '\0';
+ } else {
+ /* Is an integer key */
+ ekey_len = spprintf(&ekey, 12, "%ld", idx);
+ newprefix_len = key_prefix_len + num_prefix_len + ekey_len + key_suffix_len + 1;
+ newprefix = emalloc(newprefix_len + 1);
+ p = newprefix;
+
+ if (key_prefix) {
+ memcpy(p, key_prefix, key_prefix_len);
+ p += key_prefix_len;
+ }
+
+ memcpy(p, num_prefix, num_prefix_len);
+ p += num_prefix_len;
+
+ memcpy(p, ekey, ekey_len);
+ p += ekey_len;
+ efree(ekey);
+
+ if (key_suffix) {
+ memcpy(p, key_suffix, key_suffix_len);
+ p += key_suffix_len;
+ }
+ *(p++) = '[';
+ *p = '\0';
+ }
+ ht->nApplyCount++;
+ php_url_encode_hash_ex(HASH_OF(*zdata), formstr, NULL, 0, newprefix, newprefix_len, "]", 1,
+(Z_TYPE_PP(zdata) == IS_OBJECT ? *zdata : NULL) TSRMLS_CC);
+ ht->nApplyCount--;
+ efree(newprefix);
+ } else if (Z_TYPE_PP(zdata) == IS_NULL || Z_TYPE_PP(zdata) == IS_RESOURCE) {
+ /* Skip these types */
+ continue;
+ } else {
+ if (formstr->len) {
+ smart_str_appendl(formstr, arg_sep, arg_sep_len);
+ }
+ /* Simple key=value */
+ smart_str_appendl(formstr, key_prefix, key_prefix_len);
+ if (key_type == HASH_KEY_IS_STRING) {
+ ekey = php_url_encode(key, key_len, &ekey_len);
+ smart_str_appendl(formstr, ekey, ekey_len);
+ efree(ekey);
+ } else {
+ /* Numeric key */
+ if (num_prefix) {
+ smart_str_appendl(formstr, num_prefix, num_prefix_len);
+ }
+ ekey_len = spprintf(&ekey, 12, "%ld", idx);
+ smart_str_appendl(formstr, ekey, ekey_len);
+ efree(ekey);
+ }
+ smart_str_appendl(formstr, key_suffix, key_suffix_len);
+ smart_str_appendl(formstr, "=", 1);
+ switch (Z_TYPE_PP(zdata)) {
+ case IS_STRING:
+ ekey = php_url_encode(Z_STRVAL_PP(zdata), Z_STRLEN_PP(zdata), &ekey_len);
+ break;
+ case IS_LONG:
+ case IS_BOOL:
+ ekey_len = spprintf(&ekey, 12, "%ld", Z_LVAL_PP(zdata));
+ break;
+ case IS_DOUBLE:
+ ekey_len = spprintf(&ekey, 48, "%.*G", (int) EG(precision), Z_DVAL_PP(zdata));
+ break;
+ default:
+ /* fall back on convert to string */
+ MAKE_STD_ZVAL(copyzval);
+ *copyzval = **zdata;
+ zval_copy_ctor(copyzval);
+ convert_to_string_ex(©zval);
+ ekey = php_url_encode(Z_STRVAL_P(copyzval), Z_STRLEN_P(copyzval), &ekey_len);
+ zval_ptr_dtor(©zval);
+ }
+ smart_str_appendl(formstr, ekey, ekey_len);
+ efree(ekey);
+ }
+ }
+
+ return SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto string http_build_query(mixed formdata [, string prefix])
+ Generates a form-encoded query string from an associative array or object. */
+PHP_FUNCTION(http_build_query)
+{
+ zval *formdata;
+ char *prefix = NULL;
+ int prefix_len = 0;
+ smart_str formstr = {0};
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &formdata, &prefix, &prefix_len) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (Z_TYPE_P(formdata) != IS_ARRAY && Z_TYPE_P(formdata) != IS_OBJECT) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parameter 1 expected to be Array or Object. Incorrect value given.");
+ RETURN_FALSE;
+ }
+
+ if (php_url_encode_hash_ex(HASH_OF(formdata), &formstr, prefix, prefix_len, NULL, 0, NULL, 0, (Z_TYPE_P(formdata) == IS_OBJECT ? formdata : NULL) TSRMLS_CC) == FAILURE) {
+ if (formstr.c) {
+ efree(formstr.c);
+ }
+ RETURN_FALSE;
+ }
+
+ if (!formstr.c) {
+ RETURN_NULL();
+ }
+
+ smart_str_0(&formstr);
+
+ RETURN_STRINGL(formstr.c, formstr.len, 0);
+}
+/* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
+
--- /dev/null
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE package SYSTEM "http://pear.php.net/dtd/package-1.0">
+<package>
+ <name>pecl_http</name>
+ <summary>Extended HTTP support</summary>
+ <description>
+<![CDATA[
+Currently implemented features:
+===============================
+
+* Building absolute URIs
+* RCF compliant HTTP redirects
+* Caching by "Last-Modified" and/or ETag (with 'on the fly' option)
+* Sending data/files/streams with (multiple) ranges support
+* Negotiating user preferred language/charset
+* Convenient request functions to HEAD/GET/POST if libcurl is available
+]]>
+ </description>
+ <license>PHP License 3.0</license>
+
+ <maintainers>
+ <maintainer>
+ <user>mike</user>
+ <name>Michael Wallner</name>
+ <email>mike@php.net</email>
+ <role>lead</role>
+ </maintainer>
+ </maintainers>
+
+ <release>
+ <version>0.3.0</version>
+ <date>2005-02-xx</date>
+ <state>alpha</state>
+ <notes><![CDATA[
+ * ctype is now mandatory
+ * replaced calls to php_parse_date() to http_parse_date() (original by libcurls Curl_parsedate())
+]]>
+ </notes>
+ </release>
+
+ <filelist>
+ <dir name="/">
+ <file role="doc">EXPERIMENTAL</file>
+ <file role="doc">docs/functions.html</file>
+ <file role="src" platform="windows">config.w32</file>
+ <file role="src">config.m4</file>
+ <file role="src">http.c</file>
+ <file role="src">php_http.h</file>
+ <file role="src">http_api.c</file>
+ <file role="src">php_http_api.h</file>
+ <file role="src">http_build_query.c</file>
+ <file role="src">php_http_build_query.h</file>
+ </dir>
+ </filelist>
+</package>
+
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PECL :: http |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.0 of the PHP license, that |
+ | is bundled with this package in the file LICENSE, and is available |
+ | through the world-wide-web at http://www.php.net/license/3_0.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef PHP_EXT_HTTP_H
+#define PHP_EXT_HTTP_H
+
+#define PHP_EXT_HTTP_VERSION "0.3.0"
+
+/* make compile on Win32 */
+#include "php_streams.h"
+#include "ext/standard/md5.h"
+
+extern zend_module_entry http_module_entry;
+#define phpext_http_ptr &http_module_entry
+
+#ifdef ZTS
+#include "TSRM.h"
+#define HTTP_G(v) TSRMG(http_globals_id, zend_http_globals *, v)
+#else
+#define HTTP_G(v) (http_globals.v)
+#endif
+
+PHP_FUNCTION(http_date);
+PHP_FUNCTION(http_absolute_uri);
+PHP_FUNCTION(http_negotiate_language);
+PHP_FUNCTION(http_negotiate_charset);
+PHP_FUNCTION(http_redirect);
+PHP_FUNCTION(http_send_status);
+PHP_FUNCTION(http_send_last_modified);
+PHP_FUNCTION(http_match_modified);
+PHP_FUNCTION(http_match_etag);
+PHP_FUNCTION(http_cache_last_modified);
+PHP_FUNCTION(http_cache_etag);
+PHP_FUNCTION(http_accept_ranges);
+PHP_FUNCTION(http_content_type);
+PHP_FUNCTION(http_content_disposition);
+PHP_FUNCTION(http_send_data);
+PHP_FUNCTION(http_send_file);
+PHP_FUNCTION(http_send_stream);
+PHP_FUNCTION(http_chunked_decode);
+PHP_FUNCTION(http_split_response);
+#if defined(HAVE_CURL) && HAVE_CURL
+PHP_FUNCTION(http_get);
+PHP_FUNCTION(http_head);
+PHP_FUNCTION(http_post_data);
+PHP_FUNCTION(http_post_array);
+#endif
+PHP_FUNCTION(http_auth_basic);
+PHP_FUNCTION(http_auth_basic_cb);
+
+PHP_MINIT_FUNCTION(http);
+PHP_RSHUTDOWN_FUNCTION(http);
+PHP_MINFO_FUNCTION(http);
+
+ZEND_BEGIN_MODULE_GLOBALS(http)
+ zend_bool etag_started;
+ PHP_MD5_CTX etag_md5;
+ php_stream_statbuf ssb;
+ char *ctype;
+#if defined(HAVE_CURL) && HAVE_CURL
+ struct {
+ struct {
+ char *data;
+ size_t used;
+ size_t free;
+ } body;
+ struct {
+ char *data;
+ size_t used;
+ size_t free;
+ } hdrs;
+ } curlbuf;
+#endif
+ZEND_END_MODULE_GLOBALS(http)
+
+#endif /* PHP_HTTP_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PECL :: http |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.0 of the PHP license, that |
+ | is bundled with this package in the file LICENSE, and is available |
+ | through the world-wide-web at http://www.php.net/license/3_0.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef PHP_HTTP_API_H
+#define PHP_HTTP_API_H
+
+#ifdef PHP_WIN32
+#define PHP_HTTP_API __declspec(dllexport)
+#else
+#define PHP_HTTP_API
+#endif
+
+/* make functions that return SUCCESS|FAILURE more obvious */
+typedef int STATUS;
+
+/* {{{ enum http_range_status */
+typedef enum {
+ RANGE_OK,
+ RANGE_NO,
+ RANGE_ERR
+} http_range_status;
+/* }}} */
+
+/* {{{ enum http_send_mode */
+typedef enum {
+ SEND_DATA,
+ SEND_RSRC
+} http_send_mode;
+/* }}} */
+
+/* max URI length */
+#define HTTP_URI_MAXLEN 2048
+
+/* buffer size */
+#define HTTP_BUF_SIZE 2097152
+
+/* {{{ HAVE_CURL */
+#if defined(HAVE_CURL) && HAVE_CURL
+
+/* CURL buffer size */
+#define HTTP_CURLBUF_BODYSIZE 16384
+#define HTTP_CURLBUF_HDRSSIZE 4096
+
+/* {{{ http_curlbuf_member */
+typedef enum {
+ CURLBUF_BODY = 1,
+ CURLBUF_HDRS = 2,
+ CURLBUF_EVRY = 3
+} http_curlbuf_member;
+/* }}} */
+#endif
+/* }}} HAVE_CURL */
+
+/* {{{ HTTP_GSC(var, name, ret) */
+#define HTTP_GSC(var, name, ret) HTTP_GSP(var, name, return ret)
+/* }}} */
+
+/* {{{ HTTP_GSP(var, name, ret) */
+#define HTTP_GSP(var, name, ret) \
+ if (!(var = http_get_server_var(name))) { \
+ ret; \
+ } \
+ if (!Z_STRLEN_P(var)) { \
+ ret; \
+ }
+/* }}} */
+
+/* {{{ public API */
+#define http_date(t) _http_date((t) TSRMLS_CC)
+PHP_HTTP_API char *_http_date(time_t t TSRMLS_DC);
+
+PHP_HTTP_API time_t http_parse_date(const char *date);
+
+#define http_send_status(s) _http_send_status((s) TSRMLS_CC)
+PHP_HTTP_API inline STATUS _http_send_status(const int status TSRMLS_DC);
+
+#define http_send_header(h) _http_send_header((h) TSRMLS_CC)
+PHP_HTTP_API inline STATUS _http_send_header(const char *header TSRMLS_DC);
+
+#define http_send_status_header(s, h) _http_send_status_header((s), (h) TSRMLS_CC)
+PHP_HTTP_API inline STATUS _http_send_status_header(const int status, const char *header TSRMLS_DC);
+
+#define http_get_server_var(v) _http_get_server_var((v) TSRMLS_CC)
+PHP_HTTP_API inline zval *_http_get_server_var(const char *key TSRMLS_DC);
+
+#define http_ob_etaghandler(o, l, ho, hl, m) _http_ob_etaghandler((o), (l), (ho), (hl), (m) TSRMLS_CC)
+PHP_HTTP_API void _http_ob_etaghandler(char *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC);
+
+#define http_modified_match(entry, modified) _http_modified_match((entry), (modified) TSRMLS_CC)
+PHP_HTTP_API int _http_modified_match(const char *entry, const time_t t TSRMLS_DC);
+
+#define http_etag_match(entry, etag) _http_etag_match((entry), (etag) TSRMLS_CC)
+PHP_HTTP_API int _http_etag_match(const char *entry, const char *etag TSRMLS_DC);
+
+#define http_send_last_modified(t) _http_send_last_modified((t) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send_last_modified(const int t TSRMLS_DC);
+
+#define http_send_etag(e, l) _http_send_etag((e), (l) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send_etag(const char *etag, const int etag_len TSRMLS_DC);
+
+#define http_absolute_uri(url, proto) _http_absolute_uri((url), (proto) TSRMLS_CC)
+PHP_HTTP_API char *_http_absolute_uri(const char *url, const char *proto TSRMLS_DC);
+
+#define http_negotiate_language(supported, def) _http_negotiate_q("HTTP_ACCEPT_LANGUAGE", (supported), (def) TSRMLS_CC)
+#define http_negotiate_charset(supported, def) _http_negotiate_q("HTTP_ACCEPT_CHARSET", (supported), (def) TSRMLS_CC)
+#define http_negotiate_q(e, s, d, t) _http_negotiate_q((e), (s), (d), (t) TSRMLS_CC)
+PHP_HTTP_API char *_http_negotiate_q(const char *entry, const zval *supported, const char *def TSRMLS_DC);
+
+#define http_get_request_ranges(r, l) _http_get_request_ranges((r), (l) TSRMLS_CC)
+PHP_HTTP_API http_range_status _http_get_request_ranges(zval *zranges, const size_t length TSRMLS_DC);
+
+#define http_send_ranges(r, d, s, m) _http_send_ranges((r), (d), (s), (m) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send_ranges(zval *zranges, const void *data, const size_t size, const http_send_mode mode TSRMLS_DC);
+
+#define http_send(d, s, m) _http_send((d), (s), (m) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send(const void *data, const size_t data_size, const http_send_mode mode TSRMLS_DC);
+
+#define http_send_data(z) _http_send_data((z) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send_data(const zval *zdata TSRMLS_DC);
+
+#define http_send_stream(s) _http_send_stream((s) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send_stream(const php_stream *s TSRMLS_DC);
+
+#define http_send_file(f) _http_send_file((f) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_send_file(const zval *zfile TSRMLS_DC);
+
+#define http_chunked_decode(e, el, d, dl) _http_chunked_decode((e), (el), (d), (dl) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_chunked_decode(const char *encoded, const size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC);
+
+#define http_split_response(r, h, b) _http_split_response((r), (h), (b) TSRMLS_CC)
+PHP_HTTP_API void _http_split_response(const zval *zresponse, zval *zheaders, zval *zbody TSRMLS_DC);
+
+/* {{{ HAVE_CURL */
+#if defined(HAVE_CURL) && HAVE_CURL
+
+#define http_get(u, o, d, l) _http_get((u), (o), (d), (l) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_get(const char *URL, HashTable *options, char **data, size_t *data_len TSRMLS_DC);
+
+#define http_head(u, o, d, l) _http_head((u), (o), (d), (l) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_head(const char *URL, HashTable *options, char **data, size_t *data_len TSRMLS_DC);
+
+#define http_post_data(u, pd, pl, o, d, l) _http_post_data((u), (pd), (pl), (o), (d), (l) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_post_data(const char *URL, char *postdata, size_t postdata_len, HashTable *options, char **data, size_t *data_len TSRMLS_DC);
+
+#define http_post_array(u, p, o, d, l) _http_post_array((u), (p), (o), (d), (l) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_post_array(const char *URL, HashTable *postarray, HashTable *options, char **data, size_t *data_len TSRMLS_DC);
+
+#endif
+/* }}} HAVE_CURL */
+
+#define http_auth_credentials(u, p) _http_auth_credentials((u), (p) TSRMLS_CC)
+PHP_HTTP_API STATUS _http_auth_credentials(char **user, char **pass TSRMLS_DC);
+
+#define http_auth_header(t, r) _http_auth_header((t), (r) TSRMLS_CC)
+PHP_HTTP_API void _http_auth_header(const char *type, const char *realm TSRMLS_DC);
+
+/* }}} */
+
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP Version 5 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997-2004 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.0 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available through the world-wide-web at the following url: |
+ | http://www.php.net/license/3_0.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: Sara Golemon <pollita@php.net> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef PHP_HTTP_H
+#define PHP_HTTP_H
+
+#include "php.h"
+#include "ext/standard/php_smart_str.h"
+
+PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
+ const char *num_prefix, int num_prefix_len,
+ const char *key_prefix, int key_prefix_len,
+ const char *key_suffix, int key_suffix_len,
+ zval *type TSRMLS_DC);
+#define php_url_encode_hash(ht, formstr) php_url_encode_hash_ex((ht), (formstr), NULL, 0, NULL, 0, NULL, 0, NULL TSRMLS_CC)
+
+PHP_FUNCTION(http_build_query);
+
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
projects / m6w6 / ext-http / commitdiff
