From 9949be4659856993b6f3668c87cdcf158f6c2ddf Mon Sep 17 00:00:00 2001 From: Michael Wallner Date: Fri, 4 Feb 2005 16:22:27 +0000 Subject: [PATCH] * add to pecl --- EXPERIMENTAL | 0 config.m4 | 78 ++ config.w32 | 19 + http.c | 1003 ++++++++++++++++++++++++ http_api.c | 1670 ++++++++++++++++++++++++++++++++++++++++ http_build_query.c | 230 ++++++ package.xml | 56 ++ php_http.h | 99 +++ php_http_api.h | 182 +++++ php_http_build_query.h | 45 ++ 10 files changed, 3382 insertions(+) create mode 100644 EXPERIMENTAL create mode 100644 config.m4 create mode 100644 config.w32 create mode 100644 http.c create mode 100644 http_api.c create mode 100644 http_build_query.c create mode 100644 package.xml create mode 100644 php_http.h create mode 100644 php_http_api.h create mode 100644 php_http_build_query.h diff --git a/EXPERIMENTAL b/EXPERIMENTAL new file mode 100644 index 0000000..e69de29 diff --git a/config.m4 b/config.m4 new file mode 100644 index 0000000..26a5e91 --- /dev/null +++ b/config.m4 @@ -0,0 +1,78 @@ +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 /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 diff --git a/config.w32 b/config.w32 new file mode 100644 index 0000000..d06aa3f --- /dev/null +++ b/config.w32 @@ -0,0 +1,19 @@ +// 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"); + } +} diff --git a/http.c b/http.c new file mode 100644 index 0000000..f29b09b --- /dev/null +++ b/http.c @@ -0,0 +1,1003 @@ +/* + +----------------------------------------------------------------------+ + | 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 | + +----------------------------------------------------------------------+ +*/ + +/* $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 +#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: + * 
+ *  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
+ *
+ * + */ +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: + * 
+ * 
+ *
+ * + */ +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: + * 
+ * 
+ *
+ */ +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: + * 
+ * 
+ *
+ * + */ +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: + * + * 
+ * array(
+ *     0 => array(
+ *         'Status' => '200 Ok',
+ *         'Content-Type' => 'text/plain',
+ *         'Content-Language' => 'en-US'
+ *     ),
+ *     1 => "Hello World!"
+ * );
+ *
+ */ +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: + * 
+ *  - 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
+ *
+ */ +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: + * 
+ * Authorization failed!');
+ * }
+ * ?>
+ *
+ */ +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: + * 
+ * quoteSmart($user);
+ *     if (strlen($realpass = $db->getOne($query)) {
+ *         return $pass === $realpass;
+ *     }
+ *     return false;
+ * }
+ *
+ * if (!http_auth_basic_cb('auth_cb')) {
+ *     die('
Authorization failed
');
+ * }
+ * ?>
+ *
+ */ +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 + */ diff --git a/http_api.c b/http_api.c new file mode 100644 index 0000000..3fb260e --- /dev/null +++ b/http_api.c @@ -0,0 +1,1670 @@ +/* + +----------------------------------------------------------------------+ + | 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 | + +----------------------------------------------------------------------+ +*/ + +/* $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 + +#if defined(HAVE_CURL) && HAVE_CURL +#include +#include +#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, , 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 + */ diff --git a/http_build_query.c b/http_build_query.c new file mode 100644 index 0000000..689204c --- /dev/null +++ b/http_build_query.c @@ -0,0 +1,230 @@ +/* + +----------------------------------------------------------------------+ + | 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 | + +----------------------------------------------------------------------+ +*/ + +/* $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 + */ + diff --git a/package.xml b/package.xml new file mode 100644 index 0000000..a1ef2a2 --- /dev/null +++ b/package.xml @@ -0,0 +1,56 @@ + + + + pecl_http + Extended HTTP support + + + + PHP License 3.0 + + + + mike + Michael Wallner + mike@php.net + lead + + + + + 0.3.0 + 2005-02-xx + alpha + + + + + + + EXPERIMENTAL + docs/functions.html + config.w32 + config.m4 + http.c + php_http.h + http_api.c + php_http_api.h + http_build_query.c + php_http_build_query.h + + + + diff --git a/php_http.h b/php_http.h new file mode 100644 index 0000000..1012a12 --- /dev/null +++ b/php_http.h @@ -0,0 +1,99 @@ +/* + +----------------------------------------------------------------------+ + | 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 | + +----------------------------------------------------------------------+ +*/ + +/* $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 + */ diff --git a/php_http_api.h b/php_http_api.h new file mode 100644 index 0000000..d3ef217 --- /dev/null +++ b/php_http_api.h @@ -0,0 +1,182 @@ +/* + +----------------------------------------------------------------------+ + | 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 | + +----------------------------------------------------------------------+ +*/ + +/* $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 + */ diff --git a/php_http_build_query.h b/php_http_build_query.h new file mode 100644 index 0000000..bd87970 --- /dev/null +++ b/php_http_build_query.h @@ -0,0 +1,45 @@ +/* + +----------------------------------------------------------------------+ + | 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 | + +----------------------------------------------------------------------+ +*/ + +/* $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 + */ -- 2.30.2