+
+ zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int HttpRequest::getMethod()
+ Get the previously set request method. */
+PHP_METHOD(HttpRequest, getMethod)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(method);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setContentType(string content_type)
+ Set the content type the post request should have. */
+PHP_METHOD(HttpRequest, setContentType)
+{
+ char *ctype;
+ int ct_len;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ct_len)) {
+ RETURN_FALSE;
+ }
+
+ if (ct_len) {
+ HTTP_CHECK_CONTENT_TYPE(ctype, RETURN_FALSE);
+ }
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("contentType")-1, ctype, ct_len TSRMLS_CC);
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getContentType()
+ Get the previously content type. */
+PHP_METHOD(HttpRequest, getContentType)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(contentType);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setQueryData([mixed query_data])
+ Set the URL query parameters to use, overwriting previously set query parameters. */
+PHP_METHOD(HttpRequest, setQueryData)
+{
+ zval *qdata = NULL;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!", &qdata)) {
+ RETURN_FALSE;
+ }
+
+ if ((!qdata) || Z_TYPE_P(qdata) == IS_NULL) {
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, "", 0 TSRMLS_CC);
+ } else if ((Z_TYPE_P(qdata) == IS_ARRAY) || (Z_TYPE_P(qdata) == IS_OBJECT)) {
+ char *query_data = NULL;
+
+ if (SUCCESS != http_urlencode_hash(HASH_OF(qdata), &query_data)) {
+ RETURN_FALSE;
+ }
+
+ zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("queryData")-1, query_data TSRMLS_CC);
+ efree(query_data);
+ } else {
+ zval *data = http_zsep(IS_STRING, qdata);
+
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, Z_STRVAL_P(data), Z_STRLEN_P(data) TSRMLS_CC);
+ zval_ptr_dtor(&data);
+ }
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getQueryData()
+ Get the current query data in form of an urlencoded query string. */
+PHP_METHOD(HttpRequest, getQueryData)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(queryData);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::addQueryData(array query_params)
+ Add parameters to the query parameter list, leaving previously set unchanged. */
+PHP_METHOD(HttpRequest, addQueryData)
+{
+ zval *qdata, *old_qdata;
+ char *query_data = NULL;
+ size_t query_data_len = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &qdata)) {
+ RETURN_FALSE;
+ }
+
+ old_qdata = zend_read_property(THIS_CE, getThis(), ZEND_STRS("queryData")-1, 0 TSRMLS_CC);
+
+ if (SUCCESS != http_urlencode_hash_ex(HASH_OF(qdata), 1, Z_STRVAL_P(old_qdata), Z_STRLEN_P(old_qdata), &query_data, &query_data_len)) {
+ RETURN_FALSE;
+ }
+
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, query_data, query_data_len TSRMLS_CC);
+ efree(query_data);
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::addPostFields(array post_data)
+ Adds POST data entries, leaving previously set unchanged, unless a post entry with the same name already exists. */
+PHP_METHOD(HttpRequest, addPostFields)
+{
+ zval *post_data, *old_post, *new_post;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &post_data)) {
+ RETURN_FALSE;
+ }
+
+ if (zend_hash_num_elements(Z_ARRVAL_P(post_data))) {
+ MAKE_STD_ZVAL(new_post);
+ array_init(new_post);
+ old_post = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, 0 TSRMLS_CC);
+ if (Z_TYPE_P(old_post) == IS_ARRAY) {
+ array_copy(Z_ARRVAL_P(old_post), Z_ARRVAL_P(new_post));
+ }
+ array_join(Z_ARRVAL_P(post_data), Z_ARRVAL_P(new_post), 0, 0);
+ zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, new_post TSRMLS_CC);
+ zval_ptr_dtor(&new_post);
+ }
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setPostFields([array post_data])
+ Set the POST data entries, overwriting previously set POST data. */
+PHP_METHOD(HttpRequest, setPostFields)
+{
+ zval *post, *post_data = NULL;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &post_data)) {
+ RETURN_FALSE;
+ }
+
+ MAKE_STD_ZVAL(post);
+ array_init(post);
+ if (post_data && zend_hash_num_elements(Z_ARRVAL_P(post_data))) {
+ array_copy(Z_ARRVAL_P(post_data), Z_ARRVAL_P(post));
+ }
+ zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, post TSRMLS_CC);
+ zval_ptr_dtor(&post);
+
+ RETURN_TRUE;
+}
+/* }}}*/
+
+/* {{{ proto array HttpRequest::getPostFields()
+ Get previously set POST data. */
+PHP_METHOD(HttpRequest, getPostFields)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(postFields);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setBody([string request_body_data])
+ Set request body to send, overwriting previously set request body. Don't forget to specify a content type. */
+PHP_METHOD(HttpRequest, setBody)
+{
+ char *raw_data = NULL;
+ int data_len = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &raw_data, &data_len)) {
+ RETURN_FALSE;
+ }
+
+ if (!raw_data) {
+ raw_data = "";
+ }
+
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, raw_data, data_len TSRMLS_CC);
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::addBody(string request_body_data)
+ Add request body data, leaving previously set request body data unchanged. */
+PHP_METHOD(HttpRequest, addBody)
+{
+ char *raw_data;
+ int data_len;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &raw_data, &data_len)) {
+ RETURN_FALSE;
+ }
+
+ if (data_len) {
+ zval *data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, 0 TSRMLS_CC);
+
+ if (Z_STRLEN_P(data)) {
+ Z_STRVAL_P(data) = erealloc(Z_STRVAL_P(data), (Z_STRLEN_P(data) += data_len) + 1);
+ Z_STRVAL_P(data)[Z_STRLEN_P(data)] = '\0';
+ memcpy(Z_STRVAL_P(data) + Z_STRLEN_P(data) - data_len, raw_data, data_len);
+ } else {
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, raw_data, data_len TSRMLS_CC);
+ }
+ }
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getBody()
+ Get previously set request body data. */
+PHP_METHOD(HttpRequest, getBody)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(requestBody);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::addPostFile(string name, string file[, string content_type = "application/x-octetstream"])
+ Add a file to the POST request, leaving previously set files unchanged. */
+PHP_METHOD(HttpRequest, addPostFile)
+{
+ zval *entry, *old_post, *new_post;
+ char *name, *file, *type = NULL;
+ int name_len, file_len, type_len = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &name, &name_len, &file, &file_len, &type, &type_len)) {
+ RETURN_FALSE;
+ }
+
+ if (type_len) {
+ HTTP_CHECK_CONTENT_TYPE(type, RETURN_FALSE);
+ } else {
+ type = "application/x-octetstream";
+ type_len = sizeof("application/x-octetstream") - 1;
+ }
+
+ MAKE_STD_ZVAL(entry);
+ array_init(entry);
+
+ add_assoc_stringl(entry, "name", name, name_len, 1);
+ add_assoc_stringl(entry, "type", type, type_len, 1);
+ add_assoc_stringl(entry, "file", file, file_len, 1);
+
+ MAKE_STD_ZVAL(new_post);
+ array_init(new_post);
+ old_post = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, 0 TSRMLS_CC);
+ if (Z_TYPE_P(old_post) == IS_ARRAY) {
+ array_copy(Z_ARRVAL_P(old_post), Z_ARRVAL_P(new_post));
+ }
+ add_next_index_zval(new_post, entry);
+ zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, new_post TSRMLS_CC);
+ zval_ptr_dtor(&new_post);
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setPostFiles([array post_files])
+ Set files to post, overwriting previously set post files. */
+PHP_METHOD(HttpRequest, setPostFiles)
+{
+ zval *files = NULL, *post;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!/", &files)) {
+ RETURN_FALSE;
+ }
+
+ MAKE_STD_ZVAL(post);
+ array_init(post);
+ if (files && (Z_TYPE_P(files) == IS_ARRAY)) {
+ array_copy(Z_ARRVAL_P(files), Z_ARRVAL_P(post));
+ }
+ zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, post TSRMLS_CC);
+ zval_ptr_dtor(&post);
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto array HttpRequest::getPostFiles()
+ Get all previously added POST files. */
+PHP_METHOD(HttpRequest, getPostFiles)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(postFiles);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setPutFile([string file])
+ Set file to put. Affects only PUT requests. */
+PHP_METHOD(HttpRequest, setPutFile)
+{
+ char *file = "";
+ int file_len = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &file, &file_len)) {
+ RETURN_FALSE;
+ }
+
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putFile")-1, file, file_len TSRMLS_CC);
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getPutFile()
+ Get previously set put file. */
+PHP_METHOD(HttpRequest, getPutFile)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(putFile);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::setPutData([string put_data])
+ Set PUT data to send, overwriting previously set PUT data. */
+PHP_METHOD(HttpRequest, setPutData)
+{
+ char *put_data = NULL;
+ int data_len = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &put_data, &data_len)) {
+ RETURN_FALSE;
+ }
+
+ if (!put_data) {
+ put_data = "";
+ }
+
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putData")-1, put_data, data_len TSRMLS_CC);
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto bool HttpRequest::addPutData(string put_data)
+ Add PUT data, leaving previously set PUT data unchanged. */
+PHP_METHOD(HttpRequest, addPutData)
+{
+ char *put_data;
+ int data_len;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &put_data, &data_len)) {
+ RETURN_FALSE;
+ }
+
+ if (data_len) {
+ zval *data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putData")-1, 0 TSRMLS_CC);
+
+ if (Z_STRLEN_P(data)) {
+ Z_STRVAL_P(data) = erealloc(Z_STRVAL_P(data), (Z_STRLEN_P(data) += data_len) + 1);
+ Z_STRVAL_P(data)[Z_STRLEN_P(data)] = '\0';
+ memcpy(Z_STRVAL_P(data) + Z_STRLEN_P(data) - data_len, put_data, data_len);
+ } else {
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putData")-1, put_data, data_len TSRMLS_CC);
+ }
+ }
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getPutData()
+ Get previously set PUT data. */
+PHP_METHOD(HttpRequest, getPutData)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(putData);
+ }
+}
+/* }}} */
+
+/* {{{ proto array HttpRequest::getResponseData()
+ Get all response data after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseData)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ char *body;
+ size_t body_len;
+ zval *headers, *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
+
+ if (Z_TYPE_P(message) == IS_OBJECT) {
+ getObjectEx(http_message_object, msg, message);
+
+ array_init(return_value);
+
+ MAKE_STD_ZVAL(headers);
+ array_init(headers);
+ zend_hash_copy(Z_ARRVAL_P(headers), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ add_assoc_zval(return_value, "headers", headers);
+
+ phpstr_data(PHPSTR(msg->message), &body, &body_len);
+ add_assoc_stringl(return_value, "body", body, body_len, 0);
+ }
+ }
+}
+/* }}} */
+
+/* {{{ proto mixed HttpRequest::getResponseHeader([string name])
+ Get response header(s) after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseHeader)
+{
+ if (return_value_used) {
+ zval *header;
+ char *header_name = NULL;
+ int header_len = 0;
+
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &header_name, &header_len)) {
+ zval *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
+
+ if (Z_TYPE_P(message) == IS_OBJECT) {
+ getObjectEx(http_message_object, msg, message);
+
+ if (header_len) {
+ if ((header = http_message_header_ex(msg->message, pretty_key(header_name, header_len, 1, 1), header_len + 1, 0))) {
+ RETURN_ZVAL(header, 1, 1);
+ }
+ } else {
+ array_init(return_value);
+ zend_hash_copy(Z_ARRVAL_P(return_value), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
+ return;
+ }
+ }
+ }
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto array HttpRequest::getResponseCookies([int flags[, array allowed_extras]])
+ Get response cookie(s) after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseCookies)
+{
+ if (return_value_used) {
+ long flags = 0;
+ zval *allowed_extras_array = NULL;
+
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|la!", &flags, &allowed_extras_array)) {
+ int i = 0;
+ HashKey key = initHashKey(0);
+ char **allowed_extras = NULL;
+ zval **header = NULL, **entry = NULL, *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
+ HashPosition pos, pos1, pos2;
+
+ if (Z_TYPE_P(message) == IS_OBJECT) {
+ getObjectEx(http_message_object, msg, message);
+
+ array_init(return_value);
+
+ if (allowed_extras_array) {
+ allowed_extras = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(allowed_extras_array)) + 1, sizeof(char *));
+ FOREACH_VAL(pos, allowed_extras_array, entry) {
+ zval *data = http_zsep(IS_STRING, *entry);
+ allowed_extras[i++] = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
+ zval_ptr_dtor(&data);
+ }
+ }
+
+ FOREACH_HASH_KEYVAL(pos1, &msg->message->hdrs, key, header) {
+ if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "Set-Cookie")) {
+ http_cookie_list list;
+
+ if (Z_TYPE_PP(header) == IS_ARRAY) {
+ zval **single_header;
+
+ FOREACH_VAL(pos2, *header, single_header) {
+ zval *data = http_zsep(IS_STRING, *single_header);
+
+ if (http_parse_cookie_ex(&list, Z_STRVAL_P(data), flags, allowed_extras)) {
+ zval *cookie;
+
+ MAKE_STD_ZVAL(cookie);
+ object_init(cookie);
+ http_cookie_list_tostruct(&list, cookie);
+ add_next_index_zval(return_value, cookie);
+ http_cookie_list_dtor(&list);
+ }
+ zval_ptr_dtor(&data);
+ }
+ } else {
+ zval *data = http_zsep(IS_STRING, *header);
+ if (http_parse_cookie_ex(&list, Z_STRVAL_P(data), flags, allowed_extras)) {
+ zval *cookie;
+
+ MAKE_STD_ZVAL(cookie);
+ object_init(cookie);
+ http_cookie_list_tostruct(&list, cookie);
+ add_next_index_zval(return_value, cookie);
+ http_cookie_list_dtor(&list);
+ }
+ zval_ptr_dtor(&data);
+ }
+ }
+ }
+
+ if (allowed_extras) {
+ for (i = 0; allowed_extras[i]; ++i) {
+ efree(allowed_extras[i]);
+ }
+ efree(allowed_extras);
+ }
+
+ return;
+ }
+ }
+ RETURN_FALSE;
+ }
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getResponseBody()
+ Get the response body after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseBody)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ zval *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
+
+ if (Z_TYPE_P(message) == IS_OBJECT) {
+ getObjectEx(http_message_object, msg, message);
+ RETURN_PHPSTR_DUP(&msg->message->body);
+ } else {
+ RETURN_FALSE;
+ }
+ }
+}
+/* }}} */
+
+/* {{{ proto int HttpRequest::getResponseCode()
+ Get the response code after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseCode)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(responseCode);
+ }
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getResponseStatus()
+ Get the response status (i.e. the string after the response code) after the message has been sent. */
+PHP_METHOD(HttpRequest, getResponseStatus)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP(responseStatus);
+ }
+}
+/* }}} */
+
+/* {{{ proto mixed HttpRequest::getResponseInfo([string name])
+ Get response info after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseInfo)
+{
+ if (return_value_used) {
+ zval *info, **infop;
+ char *info_name = NULL;
+ int info_len = 0;
+
+ if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &info_name, &info_len)) {
+ RETURN_FALSE;
+ }
+
+ info = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseInfo")-1, 0 TSRMLS_CC);
+
+ if (Z_TYPE_P(info) != IS_ARRAY) {
+ RETURN_FALSE;
+ }
+
+ if (info_len && info_name) {
+ if (SUCCESS == zend_hash_find(Z_ARRVAL_P(info), pretty_key(info_name, info_len, 0, 0), info_len + 1, (void *) &infop)) {
+ RETURN_ZVAL(*infop, 1, 0);
+ } else {
+ http_error_ex(HE_NOTICE, HTTP_E_INVALID_PARAM, "Could not find response info named %s", info_name);
+ RETURN_FALSE;
+ }
+ } else {
+ RETURN_ZVAL(info, 1, 0);
+ }
+ }
+}
+/* }}}*/
+
+/* {{{ proto HttpMessage HttpRequest::getResponseMessage()
+ Get the full response as HttpMessage object after the request has been sent. */
+PHP_METHOD(HttpRequest, getResponseMessage)
+{
+ NO_ARGS {
+ zval *message;
+
+ SET_EH_THROW_HTTP();
+ message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
+ if (Z_TYPE_P(message) == IS_OBJECT) {
+ RETVAL_OBJECT(message, 1);
+ } else {
+ http_error(HE_WARNING, HTTP_E_RUNTIME, "HttpRequest does not contain a response message");
+ }
+ SET_EH_NORMAL();
+ }
+}
+/* }}} */
+
+/* {{{ proto HttpMessage HttpRequest::getRequestMessage()
+ Get sent HTTP message. */
+PHP_METHOD(HttpRequest, getRequestMessage)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ http_message *msg;
+ getObject(http_request_object, obj);
+
+ SET_EH_THROW_HTTP();
+ if ((msg = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request)))) {
+ RETVAL_OBJVAL(http_request_object_message(getThis(), msg), 0);
+ }
+ SET_EH_NORMAL();
+ }
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getRawRequestMessage()
+ Get sent HTTP message. */
+PHP_METHOD(HttpRequest, getRawRequestMessage)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ getObject(http_request_object, obj);
+
+ RETURN_PHPSTR_DUP(&obj->request->conv.request);
+ }
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getRawResponseMessage()
+ Get the entire HTTP response. */
+PHP_METHOD(HttpRequest, getRawResponseMessage)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ getObject(http_request_object, obj);
+
+ RETURN_PHPSTR_DUP(&obj->request->conv.response);
+ }
+}
+/* }}} */
+
+/* {{{ proto HttpMessage HttpRequest::getHistory()
+ Get all sent requests and received responses as an HttpMessage object. */
+PHP_METHOD(HttpRequest, getHistory)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ zval *hist;
+
+ SET_EH_THROW_HTTP();
+ hist = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
+ if (Z_TYPE_P(hist) == IS_OBJECT) {
+ RETVAL_OBJECT(hist, 1);
+ } else {
+ http_error(HE_WARNING, HTTP_E_RUNTIME, "The history is empty");
+ }
+ SET_EH_NORMAL();
+ }
+}
+/* }}} */
+
+/* {{{ proto void HttpRequest::clearHistory()
+ Clear the history. */
+PHP_METHOD(HttpRequest, clearHistory)
+{
+ NO_ARGS {
+ zval *hist;
+
+ MAKE_STD_ZVAL(hist);
+ ZVAL_NULL(hist);
+ zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
+ zval_ptr_dtor(&hist);
+ }
+}
+/* }}} */
+
+/* {{{ proto string HttpRequest::getMessageClass()
+ Get the message class name. */
+PHP_METHOD(HttpRequest, getMessageClass)
+{
+ NO_ARGS;
+
+ if (return_value_used) {
+ RETURN_PROP("messageClass");
+ }
+}
+/* }}} */
+
+/* {{{ proto void setMessageClass(string class_name)
+ Set the message class name. */
+PHP_METHOD(HttpRequest, setMessageClass)
+{
+ char *cn;
+ int cl;
+
+ if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &cn, &cl)) {
+ zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("messageClass")-1, cn, cl TSRMLS_CC);
+ }
+}
+/* }}} */
+
+/* {{{ proto HttpMessage HttpRequest::send()
+ Send the HTTP request. */
+PHP_METHOD(HttpRequest, send)
+{
+ getObject(http_request_object, obj);
+
+ NO_ARGS;
+
+ SET_EH_THROW_HTTP();
+
+ RETVAL_FALSE;
+
+ if (obj->pool) {
+ http_error(HE_WARNING, HTTP_E_RUNTIME, "Cannot perform HttpRequest::send() while attached to an HttpRequestPool");
+ } else if (SUCCESS == http_request_object_requesthandler(obj, getThis())) {
+ http_request_exec(obj->request);
+ if (SUCCESS == http_request_object_responsehandler(obj, getThis())) {
+ RETVAL_OBJECT(zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC), 1);
+ }
+ }
+
+ SET_EH_NORMAL();