#include "php.h"
#include "php_ini.h"
-#include "snprintf.h"
#include "ext/standard/info.h"
#include "ext/session/php_session.h"
#include "ext/standard/php_string.h"
#include "SAPI.h"
-#include "php_http.h"
-#include "php_http_api.h"
-#include "php_http_curl_api.h"
-#include "php_http_std_defs.h"
-
#include "phpstr/phpstr.h"
-ZEND_DECLARE_MODULE_GLOBALS(http)
+#include "php_http.h"
+#include "php_http_std_defs.h"
+#include "php_http_api.h"
+#include "php_http_auth_api.h"
+#include "php_http_request_api.h"
+#include "php_http_cache_api.h"
+#include "php_http_request_api.h"
+#include "php_http_date_api.h"
+#include "php_http_headers_api.h"
+#include "php_http_message_api.h"
+#include "php_http_send_api.h"
+#include "php_http_url_api.h"
+
+ZEND_EXTERN_MODULE_GLOBALS(http)
/* {{{ proto string http_date([int timestamp])
*
RETURN_FALSE;
}
if (status < 100 || status > 510) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid HTTP status code (100-510): %d", status);
+ http_error_ex(E_WARNING, HTTP_E_HEADER, "Invalid HTTP status code (100-510): %d", status);
RETURN_FALSE;
}
}
if (!ct_len) {
- RETURN_SUCCESS(http_send_content_type("application/x-octetstream", sizeof("application/x-octetstream") - 1));
+ RETURN_SUCCESS(http_send_content_type("application/x-octetstream", lenof("application/x-octetstream")));
}
RETURN_SUCCESS(http_send_content_type(ct, ct_len));
}
}
if (for_range) {
- RETURN_BOOL(http_modified_match("HTTP_IF_UNMODIFIED_SINCE", t));
+ RETURN_BOOL(http_match_last_modified("HTTP_IF_UNMODIFIED_SINCE", t));
}
- RETURN_BOOL(http_modified_match("HTTP_IF_MODIFIED_SINCE", t));
+ RETURN_BOOL(http_match_last_modified("HTTP_IF_MODIFIED_SINCE", t));
}
/* }}} */
}
if (for_range) {
- RETURN_BOOL(http_etag_match("HTTP_IF_MATCH", etag));
+ RETURN_BOOL(http_match_etag("HTTP_IF_MATCH", etag));
}
- RETURN_BOOL(http_etag_match("HTTP_IF_NONE_MATCH", etag));
+ RETURN_BOOL(http_match_etag("HTTP_IF_NONE_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
+ * If timestamp_or_expires 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 time in seconds, which means that if the
send_modified = last_modified;
}
- RETURN_SUCCESS(http_cache_last_modified(last_modified, send_modified, HTTP_DEFAULT_CACHECONTROL, sizeof(HTTP_DEFAULT_CACHECONTROL) - 1));
+ RETURN_SUCCESS(http_cache_last_modified(last_modified, send_modified, HTTP_DEFAULT_CACHECONTROL, lenof(HTTP_DEFAULT_CACHECONTROL)));
}
/* }}} */
RETURN_FALSE;
}
- RETURN_SUCCESS(http_cache_etag(etag, etag_len, HTTP_DEFAULT_CACHECONTROL, sizeof(HTTP_DEFAULT_CACHECONTROL) - 1));
+ RETURN_SUCCESS(http_cache_etag(etag, etag_len, HTTP_DEFAULT_CACHECONTROL, lenof(HTTP_DEFAULT_CACHECONTROL)));
}
/* }}} */
-/* {{{ proto string ob_httpetaghandler(string data, int mode)
+/* {{{ proto string ob_etaghandler(string data, int mode)
*
* For use with ob_start().
- * Note that this has to be started as first output buffer.
- * WARNING: Don't use with http_send_*().
*/
-PHP_FUNCTION(ob_httpetaghandler)
+PHP_FUNCTION(ob_etaghandler)
{
char *data;
int data_len;
RETURN_FALSE;
}
- if (mode & PHP_OUTPUT_HANDLER_START) {
- if (HTTP_G(etag_started)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "ob_httpetaghandler can only be used once");
- RETURN_STRINGL(data, data_len, 1);
- }
- http_send_header("Cache-Control: " HTTP_DEFAULT_CACHECONTROL);
- HTTP_G(etag_started) = 1;
- }
-
- if (OG(ob_nesting_level) > 1) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "ob_httpetaghandler must be started prior to other output buffers");
- RETURN_STRINGL(data, data_len, 1);
- }
-
Z_TYPE_P(return_value) = IS_STRING;
http_ob_etaghandler(data, data_len, &Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value), mode);
}
/* }}} */
+/* {{{ proto void http_throttle(double sec[, long bytes = 2097152])
+ *
+ * Use with http_send() API.
+ *
+ * Example:
+ * <pre>
+ * <?php
+ * // ~ 20 kbyte/s
+ * # http_throttle(1, 20000);
+ * # http_throttle(0.5, 10000);
+ * # http_throttle(0.1, 2000);
+ * http_send_file('document.pdf');
+ * ?>
+ * </pre>
+ */
+PHP_FUNCTION(http_throttle)
+{
+ long chunk_size;
+ double interval;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "dl", &interval, &chunk_size)) {
+ return;
+ }
+
+ HTTP_G(send).throttle_delay = interval;
+ HTTP_G(send).buffer_size = chunk_size;
+}
+/* }}} */
+
/* {{{ proto void http_redirect([string url[, array params[, bool session,[ bool permanent]]]])
*
* Redirect to a given url.
size_t query_len = 0;
zend_bool session = 0, permanent = 0;
zval *params = NULL;
- char *query, *url, *URI,
+ char *query = NULL, *url = NULL, *URI,
LOC[HTTP_URI_MAXLEN + sizeof("Location: ")],
RED[HTTP_URI_MAXLEN * 2 + sizeof("Redirecting to <a href=\"%s?%s\">%s?%s</a>.\n")];
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");
+ http_error(E_WARNING, HTTP_E_ENCODE, "Could not append session information");
}
}
}
convert_to_string_ex(&zdata);
- http_send_header("Accept-Ranges: bytes");
RETURN_SUCCESS(http_send_data(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)));
}
/* }}} */
RETURN_FALSE;
}
- http_send_header("Accept-Ranges: bytes");
RETURN_SUCCESS(http_send_file(file));
}
/* }}} */
}
php_stream_from_zval(file, &zstream);
- http_send_header("Accept-Ranges: bytes");
RETURN_SUCCESS(http_send_stream(file));
}
/* }}} */
RETURN_FALSE;
}
- if (SUCCESS == http_chunked_decode(encoded, encoded_len, &decoded, &decoded_len)) {
+ if (NULL != http_chunked_decode(encoded, encoded_len, &decoded, &decoded_len)) {
RETURN_STRINGL(decoded, decoded_len, 0);
} else {
RETURN_FALSE;
* <?php
* array(
* 0 => array(
- * 'Status' => '200 Ok',
+ * 'Response Status' => '200 Ok',
* 'Content-Type' => 'text/plain',
-
* 'Content-Language' => 'en-US'
* ),
* 1 => "Hello World!"
*/
PHP_FUNCTION(http_split_response)
{
- zval *zresponse, *zbody, *zheaders;
+ char *response, *body;
+ int response_len;
+ size_t body_len;
+ zval *zheaders;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zresponse) != SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &response, &response_len) != SUCCESS) {
RETURN_FALSE;
}
- convert_to_string(zresponse);
-
- MAKE_STD_ZVAL(zbody);
MAKE_STD_ZVAL(zheaders);
array_init(zheaders);
- if (SUCCESS != http_split_response(zresponse, zheaders, zbody)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not parse HTTP response");
+ if (SUCCESS != http_split_response(response, response_len, Z_ARRVAL_P(zheaders), &body, &body_len)) {
+ http_error(E_WARNING, HTTP_E_PARSE, "Could not parse HTTP response");
RETURN_FALSE;
}
array_init(return_value);
add_index_zval(return_value, 0, zheaders);
- add_index_zval(return_value, 1, zbody);
+ add_index_stringl(return_value, 1, body, body_len, 0);
}
/* }}} */
*/
PHP_FUNCTION(http_parse_headers)
{
- char *header, *rnrn;
+ char *header;
int header_len;
if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &header, &header_len)) {
}
array_init(return_value);
-
- if (rnrn = strstr(header, HTTP_CRLF HTTP_CRLF)) {
- header_len = rnrn - header + 2;
- }
- if (SUCCESS != http_parse_headers(header, header_len, return_value)) {
- php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not parse HTTP headers");
+ if (SUCCESS != http_parse_headers(header, return_value)) {
+ http_error(E_WARNING, HTTP_E_PARSE, "Could not parse HTTP headers");
zval_dtor(return_value);
RETURN_FALSE;
}
/* {{{ proto array http_get_request_headers(void)
*
+ * Get a list of incoming HTTP headers.
*/
PHP_FUNCTION(http_get_request_headers)
{
}
/* }}} */
+/* {{{ proto string http_get_request_body(void)
+ *
+ * Get the raw request body (e.g. POST or PUT data).
+ */
+PHP_FUNCTION(http_get_request_body)
+{
+ char *body;
+ size_t length;
+
+ NO_ARGS;
+
+ if (SUCCESS == http_get_request_body(&body, &length)) {
+ RETURN_STRING(body, (int) length, 0);
+ } else {
+ RETURN_NULL();
+ }
+}
+/* }}} */
+
+/* {{{ proto bool http_match_request_header(string header, string value[, bool match_case = false])
+ *
+ * Match an incoming HTTP header.
+ */
+PHP_FUNCTION(http_match_request_header)
+{
+ char *header, *value;
+ int header_len, value_len;
+ zend_bool match_case = 0, result = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &header, &header_len, &value, &value_len, &match_case)) {
+ RETURN_FALSE;
+ }
+
+ RETURN_BOOL(http_match_request_header_ex(header, value, match_case));
+}
+/* }}} */
+
/* {{{ HAVE_CURL */
#ifdef HTTP_HAVE_CURL
* - lastmodified: int, timestamp for If-(Un)Modified-Since header
* - timeout: int, seconds the request may take
* - connecttimeout: int, seconds the connect may take
+ * - onprogress: mixed, progress callback
+ * - ondebug: mixed, debug callback
* </pre>
*
* The optional third parameter will be filled with some additional information
*/
PHP_FUNCTION(http_get)
{
- char *URL, *data = NULL;
- size_t data_len = 0;
- int URL_len;
zval *options = NULL, *info = NULL;
+ char *URL;
+ int URL_len;
+ phpstr response;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
RETURN_FALSE;
array_init(info);
}
- if (SUCCESS == http_get(URL, HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
- RETURN_STRINGL(data, data_len, 0);
+ phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
+ if (SUCCESS == http_get(URL, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+ RETURN_PHPSTR_VAL(response);
} else {
RETURN_FALSE;
}
*/
PHP_FUNCTION(http_head)
{
- char *URL, *data = NULL;
- size_t data_len = 0;
- int URL_len;
zval *options = NULL, *info = NULL;
+ char *URL;
+ int URL_len;
+ phpstr response;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
RETURN_FALSE;
array_init(info);
}
- if (SUCCESS == http_head(URL, HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
- RETURN_STRINGL(data, data_len, 0);
+ phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
+ if (SUCCESS == http_head(URL, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+ RETURN_PHPSTR_VAL(response);
} else {
RETURN_FALSE;
}
*/
PHP_FUNCTION(http_post_data)
{
- char *URL, *postdata, *data = NULL;
- size_t data_len = 0;
- int postdata_len, URL_len;
zval *options = NULL, *info = NULL;
+ char *URL, *postdata;
+ int postdata_len, URL_len;
+ phpstr response;
+ http_request_body body;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &postdata, &postdata_len, &options, &info) != SUCCESS) {
RETURN_FALSE;
array_init(info);
}
- if (SUCCESS == http_post_data(URL, postdata, (size_t) postdata_len, HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
- RETURN_STRINGL(data, data_len, 0);
+ body.type = HTTP_REQUEST_BODY_CSTRING;
+ body.data = postdata;
+ body.size = postdata_len;
+
+ phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
+ if (SUCCESS == http_post(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+ RETVAL_PHPSTR_VAL(response);
} else {
- RETURN_FALSE;
+ RETVAL_FALSE;
}
}
/* }}} */
-/* {{{ proto string http_post_array(string url, array data[, array options[, array &info]])
+/* {{{ proto string http_post_fields(string url, array data[, array files[, array options[, array &info]]])
*
* 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)
+PHP_FUNCTION(http_post_fields)
+{
+ zval *options = NULL, *info = NULL, *fields, *files = NULL;
+ char *URL;
+ int URL_len;
+ phpstr response;
+ http_request_body body;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|aa/!z", &URL, &URL_len, &fields, &files, &options, &info) != SUCCESS) {
+ RETURN_FALSE;
+ }
+
+ if (SUCCESS != http_request_body_fill(&body, Z_ARRVAL_P(fields), files ? Z_ARRVAL_P(files) : NULL)) {
+ RETURN_FALSE;
+ }
+
+ if (info) {
+ zval_dtor(info);
+ array_init(info);
+ }
+
+ phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
+ if (SUCCESS == http_post(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+ RETVAL_PHPSTR_VAL(response);
+ } else {
+ RETVAL_FALSE;
+ }
+ http_request_body_dtor(&body);
+}
+/* }}} */
+
+/* {{{ proto string http_put_file(string url, string file[, array options[, array &info]])
+ *
+ * Performs an HTTP PUT request, uploading file.
+ * Returns the HTTP response as string.
+ * See http_get() for a full list of available options.
+ */
+PHP_FUNCTION(http_put_file)
+{
+ char *URL, *file;
+ int URL_len, f_len;
+ zval *options = NULL, *info = NULL;
+ phpstr response;
+ php_stream *stream;
+ php_stream_statbuf ssb;
+ http_request_body body;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &file, &f_len, &options, &info)) {
+ RETURN_FALSE;
+ }
+
+ if (!(stream = php_stream_open_wrapper(file, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL))) {
+ RETURN_FALSE;
+ }
+ if (php_stream_stat(stream, &ssb)) {
+ php_stream_close(stream);
+ RETURN_FALSE;
+ }
+
+ if (info) {
+ zval_dtor(info);
+ array_init(info);
+ }
+
+ body.type = HTTP_REQUEST_BODY_UPLOADFILE;
+ body.data = stream;
+ body.size = ssb.sb.st_size;
+
+ phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
+ if (SUCCESS == http_put(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+ RETVAL_PHPSTR_VAL(response);
+ } else {
+ RETVAL_FALSE;
+ }
+ http_request_body_dtor(&body);
+}
+/* }}} */
+
+/* {{{ proto string http_put_stream(string url, resource stream[, array options[, array &info]])
+ *
+ * Performs an HTTP PUT request, uploading stream.
+ * Returns the HTTP response as string.
+ * See http_get() for a full list of available options.
+ */
+PHP_FUNCTION(http_put_stream)
{
- char *URL, *data = NULL;
- size_t data_len = 0;
+ zval *resource, *options = NULL, *info = NULL;
+ char *URL;
int URL_len;
- zval *options = NULL, *info = NULL, *postdata;
+ phpstr response;
+ php_stream *stream;
+ php_stream_statbuf ssb;
+ http_request_body body;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sr|a/!z", &URL, &URL_len, &resource, &options, &info)) {
+ RETURN_FALSE;
+ }
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a/!z", &URL, &URL_len, &postdata, &options, &info) != SUCCESS) {
+ php_stream_from_zval(stream, &resource);
+ if (php_stream_stat(stream, &ssb)) {
RETURN_FALSE;
}
array_init(info);
}
- if (SUCCESS == http_post_array(URL, Z_ARRVAL_P(postdata), HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
- RETURN_STRINGL(data, data_len, 0);
+ body.type = HTTP_REQUEST_BODY_UPLOADFILE;
+ body.data = stream;
+ body.size = ssb.sb.st_size;
+
+ phpstr_init_ex(&response, HTTP_CURLBUF_SIZE, 0);
+ if (SUCCESS == http_put(URL, &body, options ? Z_ARRVAL_P(options) : NULL, info ? Z_ARRVAL_P(info) : NULL, &response)) {
+ RETURN_PHPSTR_VAL(response);
} else {
+ RETURN_NULL();
+ }
+}
+/* }}} */
+
+/* {{{ proto long http_request_method_register(string method)
+ *
+ * Register a custom request method.
+ */
+PHP_FUNCTION(http_request_method_register)
+{
+ char *method;
+ int *method_len;
+ unsigned long existing;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len)) {
+ RETURN_FALSE;
+ }
+ if (existing = http_request_method_exists(1, 0, method)) {
+ RETURN_LONG((long) existing);
+ }
+
+ RETVAL_LONG((long) http_request_method_register(method));
+}
+/* }}} */
+
+/* {{{ proto bool http_request_method_unregister(mixed method)
+ *
+ * Unregister a previously registered custom request method.
+ */
+PHP_FUNCTION(http_request_method_unregister)
+{
+ zval *method;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &method)) {
RETURN_FALSE;
}
+
+ switch (Z_TYPE_P(method))
+ {
+ case IS_OBJECT:
+ convert_to_string(method);
+ case IS_STRING:
+#include "zend_operators.h"
+ if (is_numeric_string(Z_STRVAL_P(method), Z_STRLEN_P(method), NULL, NULL, 1)) {
+ convert_to_long(method);
+ } else {
+ unsigned long mn;
+ if (!(mn = http_request_method_exists(1, 0, Z_STRVAL_P(method)))) {
+ RETURN_FALSE;
+ }
+ zval_dtor(method);
+ ZVAL_LONG(method, (long)mn);
+ }
+ case IS_LONG:
+ RETURN_SUCCESS(http_request_method_unregister(Z_LVAL_P(method)));
+ default:
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto long http_request_method_exists(mixed method)
+ *
+ * Check if a request method is registered (or available by default).
+ */
+PHP_FUNCTION(http_request_method_exists)
+{
+ IF_RETVAL_USED {
+ zval *method;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &method)) {
+ RETURN_FALSE;
+ }
+
+ switch (Z_TYPE_P(method))
+ {
+ case IS_OBJECT:
+ convert_to_string(method);
+ case IS_STRING:
+ if (is_numeric_string(Z_STRVAL_P(method), Z_STRLEN_P(method), NULL, NULL, 1)) {
+ convert_to_long(method);
+ } else {
+ RETURN_LONG((long) http_request_method_exists(1, 0, Z_STRVAL_P(method)));
+ }
+ case IS_LONG:
+ RETURN_LONG((long) http_request_method_exists(0, Z_LVAL_P(method), NULL));
+ default:
+ RETURN_FALSE;
+ }
+ }
}
/* }}} */
+/* {{{ proto string http_request_method_name(long method)
+ *
+ * Get the literal string representation of a standard or registered request method.
+ */
+PHP_FUNCTION(http_request_method_name)
+{
+ IF_RETVAL_USED {
+ long method;
+
+ if ((SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &method)) || (method < 0)) {
+ RETURN_FALSE;
+ }
+
+ RETURN_STRING(estrdup(http_request_method_name((unsigned long) method)), 0);
+ }
+}
+/* }}} */
#endif
/* }}} HAVE_CURL */
realm = "Restricted";
}
- if (SUCCESS != http_auth_credentials(&suser, &spass)) {
- http_auth_header("Basic", realm);
+ if (SUCCESS != http_auth_basic_credentials(&suser, &spass)) {
+ http_auth_basic_header(realm);
RETURN_FALSE;
}
if (strcasecmp(suser, user)) {
- http_auth_header("Basic", realm);
+ http_auth_basic_header(realm);
RETURN_FALSE;
}
if (strcmp(spass, pass)) {
- http_auth_header("Basic", realm);
+ http_auth_basic_header(realm);
RETURN_FALSE;
}
realm = "Restricted";
}
- if (SUCCESS != http_auth_credentials(&user, &pass)) {
- http_auth_header("Basic", realm);
+ if (SUCCESS != http_auth_basic_credentials(&user, &pass)) {
+ http_auth_basic_header(realm);
RETURN_FALSE;
}
{
efree(zparams[1]);
if (!result) {
- http_auth_header("Basic", realm);
+ http_auth_basic_header(realm);
}
RETURN_BOOL(result);
/* {{{ Sara Golemons http_build_query() */
#ifndef ZEND_ENGINE_2
-/* {{{ proto string http_build_query(mixed formdata [, string prefix])
+/* {{{ proto string http_build_query(mixed formdata [, string prefix[, string arg_separator]])
Generates a form-encoded query string from an associative array or object. */
PHP_FUNCTION(http_build_query)
{
zval *formdata;
- char *prefix = NULL, *arg_sep = NULL;
- int prefix_len = 0;
- phpstr *formstr = phpstr_new();
+ char *prefix = NULL, *arg_sep = INI_STR("arg_separator.output");
+ int prefix_len = 0, arg_sep_len = strlen(arg_sep);
+ phpstr *formstr;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &formdata, &prefix, &prefix_len) != SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ss", &formdata, &prefix, &prefix_len, &arg_sep, &arg_sep_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.");
+ http_error(E_WARNING, HTTP_E_PARAM, "Parameter 1 expected to be Array or Object. Incorrect value given.");
RETURN_FALSE;
}
- if (!strlen(arg_sep = INI_STR("arg_separator.output"))) {
- arg_sep = HTTP_URL_ARGSEP_DEFAULT;
+ if (!arg_sep_len) {
+ arg_sep = HTTP_URL_ARGSEP;
}
- if (SUCCESS != http_urlencode_hash_implementation_ex(HASH_OF(formdata), formstr, arg_sep, prefix, prefix_len, NULL, 0, NULL, 0, (Z_TYPE_P(formdata) == IS_OBJECT ? formdata : NULL) TSRMLS_CC)) {
+ formstr = phpstr_new();
+ if (SUCCESS != http_urlencode_hash_implementation_ex(HASH_OF(formdata), formstr, arg_sep, prefix, prefix_len, NULL, 0, NULL, 0, (Z_TYPE_P(formdata) == IS_OBJECT ? formdata : NULL))) {
phpstr_free(formstr);
RETURN_FALSE;
}
PHP_FUNCTION(http_test)
{
+ RETURN_NULL();
}
/*
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
-
projects / m6w6 / ext-http / blobdiff