#include "php_soap.h"

#include "ext/standard/base64.h"

#include "ext/standard/md5.h"

#include "ext/standard/php_rand.h"

static char *get_http_header_value(char *headers, char *type);

static int get_http_body(php_stream *socketd, int close, char *headers, char **response, int *out_size TSRMLS_DC);

static int get_http_headers(php_stream *socketd,char **response, int *out_size TSRMLS_DC);

#define smart_str_append_const(str, const) \

smart_str_appendl(str,const,sizeof(const)-1)

int proxy_authentication(zval* this_ptr, smart_str* soap_headers TSRMLS_DC)

{

zval **login, **password;

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_login", sizeof("_proxy_login"), (void **)&login) == SUCCESS) {

unsigned char* buf;

int len;

smart_str auth = {0};

smart_str_appendl(&auth, Z_STRVAL_PP(login), Z_STRLEN_PP(login));

smart_str_appendc(&auth, ':');

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_password", sizeof("_proxy_password"), (void **)&password) == SUCCESS) {

smart_str_appendl(&auth, Z_STRVAL_PP(password), Z_STRLEN_PP(password));

}

smart_str_0(&auth);

buf = php_base64_encode((unsigned char*)auth.c, auth.len, &len);

smart_str_append_const(soap_headers, "Proxy-Authorization: Basic ");

smart_str_appendl(soap_headers, (char*)buf, len);

smart_str_append_const(soap_headers, "\r\n");

efree(buf);

smart_str_free(&auth);

return 1;

}

return 0;

}

int basic_authentication(zval* this_ptr, smart_str* soap_headers TSRMLS_DC)

{

zval **login, **password;

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login"), (void **)&login) == SUCCESS &&

!zend_hash_exists(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest"))) {

unsigned char* buf;

int len;

smart_str auth = {0};

smart_str_appendl(&auth, Z_STRVAL_PP(login), Z_STRLEN_PP(login));

smart_str_appendc(&auth, ':');

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS) {

smart_str_appendl(&auth, Z_STRVAL_PP(password), Z_STRLEN_PP(password));

}

smart_str_0(&auth);

buf = php_base64_encode((unsigned char*)auth.c, auth.len, &len);

smart_str_append_const(soap_headers, "Authorization: Basic ");

smart_str_appendl(soap_headers, (char*)buf, len);

smart_str_append_const(soap_headers, "\r\n");

efree(buf);

smart_str_free(&auth);

return 1;

}

return 0;

}

void http_context_headers(php_stream_context* context,

smart_str* soap_headers TSRMLS_DC)

{

zval **tmp;

if (context &&

php_stream_context_get_option(context, "http", "header", &tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING && Z_STRLEN_PP(tmp)) {

char *s = Z_STRVAL_PP(tmp);

char *p;

int name_len;

while (*s) {

/* skip leading newlines and spaces */

while (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n') {

s++;

}

/* extract header name */

p = s;

name_len = -1;

while (*p) {

if (*p == ':') {

if (name_len < 0) name_len = p - s;

break;

} else if (*p == ' ' || *p == '\t') {

if (name_len < 0) name_len = p - s;

} else if (*p == '\r' || *p == '\n') {

break;

}

p++;

}

if (*p == ':') {

/* extract header value */

while (*p && *p != '\r' && *p != '\n') {

p++;

}

/* skip some predefined headers */

if ((name_len != sizeof("host")-1 ||

strncasecmp(s, "host", sizeof("host")-1) != 0) &&

(name_len != sizeof("connection")-1 ||

strncasecmp(s, "connection", sizeof("connection")-1) != 0) &&

(name_len != sizeof("user-agent")-1 ||

strncasecmp(s, "user-agent", sizeof("user-agent")-1) != 0) &&

(name_len != sizeof("content-length")-1 ||

strncasecmp(s, "content-length", sizeof("content-length")-1) != 0) &&

(name_len != sizeof("content-type")-1 ||

strncasecmp(s, "content-type", sizeof("content-type")-1) != 0) &&

(!has_cookies ||

name_len != sizeof("cookie")-1 ||

strncasecmp(s, "cookie", sizeof("cookie")-1) != 0) &&

(!has_authorization ||

name_len != sizeof("authorization")-1 ||

strncasecmp(s, "authorization", sizeof("authorization")-1) != 0) &&

(!has_proxy_authorization ||

name_len != sizeof("proxy-authorization")-1 ||

strncasecmp(s, "proxy-authorization", sizeof("proxy-authorization")-1) != 0)) {

/* add header */

smart_str_appendl(soap_headers, s, p-s);

smart_str_append_const(soap_headers, "\r\n");

}

}

s = (*p) ? (p + 1) : p;

}

}

}

static php_stream* http_connect(zval* this_ptr, php_url *phpurl, int use_ssl, php_stream_context *context, int *use_proxy TSRMLS_DC)

{

php_stream *stream;

zval **proxy_host, **proxy_port, **tmp;

char *host;

char *name;

long namelen;

int port;

int old_error_reporting;

struct timeval tv;

struct timeval *timeout = NULL;

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_host", sizeof("_proxy_host"), (void **) &proxy_host) == SUCCESS &&

Z_TYPE_PP(proxy_host) == IS_STRING &&

zend_hash_find(Z_OBJPROP_P(this_ptr), "_proxy_port", sizeof("_proxy_port"), (void **) &proxy_port) == SUCCESS &&

Z_TYPE_PP(proxy_port) == IS_LONG) {

host = Z_STRVAL_PP(proxy_host);

port = Z_LVAL_PP(proxy_port);

*use_proxy = 1;

} else {

host = phpurl->host;

port = phpurl->port;

}

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_connection_timeout", sizeof("_connection_timeout"), (void **) &tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_LONG && Z_LVAL_PP(tmp) > 0) {

tv.tv_sec = Z_LVAL_PP(tmp);

tv.tv_usec = 0;

timeout = &tv;

}

old_error_reporting = EG(error_reporting);

EG(error_reporting) &= ~(E_WARNING|E_NOTICE|E_USER_WARNING|E_USER_NOTICE);

namelen = spprintf(&name, 0, "%s://%s:%d", (use_ssl && !*use_proxy)? "ssl" : "tcp", host, port);

stream = php_stream_xport_create(name, namelen,

REPORT_ERRORS,

STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT,

NULL /*persistent_id*/,

timeout,

context,

NULL, NULL);

efree(name);

/* SSL & proxy */

if (stream && *use_proxy && use_ssl) {

smart_str soap_headers = {0};

char *http_headers;

int http_header_size;

smart_str_append_const(&soap_headers, "CONNECT ");

smart_str_appends(&soap_headers, phpurl->host);

smart_str_appendc(&soap_headers, ':');

smart_str_append_unsigned(&soap_headers, phpurl->port);

smart_str_append_const(&soap_headers, " HTTP/1.1\r\n");

smart_str_append_const(&soap_headers, "Host: ");

smart_str_appends(&soap_headers, phpurl->host);

if (phpurl->port != 80) {

smart_str_appendc(&soap_headers, ':');

smart_str_append_unsigned(&soap_headers, phpurl->port);

}

smart_str_append_const(&soap_headers, "\r\n");

proxy_authentication(this_ptr, &soap_headers TSRMLS_CC);

smart_str_append_const(&soap_headers, "\r\n");

if (php_stream_write(stream, soap_headers.c, soap_headers.len) != soap_headers.len) {

php_stream_close(stream);

stream = NULL;

}

smart_str_free(&soap_headers);

if (stream) {

if (!get_http_headers(stream, &http_headers, &http_header_size TSRMLS_CC) || http_headers == NULL) {

php_stream_close(stream);

stream = NULL;

}

if (http_headers) {

efree(http_headers);

}

}

/* enable SSL transport layer */

if (stream) {

if (php_stream_xport_crypto_setup(stream, STREAM_CRYPTO_METHOD_SSLv23_CLIENT, NULL TSRMLS_CC) < 0 ||

php_stream_xport_crypto_enable(stream, 1 TSRMLS_CC) < 0) {

php_stream_close(stream);

stream = NULL;

}

}

}

EG(error_reporting) = old_error_reporting;

return stream;

}

static int in_domain(const char *host, const char *domain)

{

if (domain[0] == '.') {

int l1 = strlen(host);

int l2 = strlen(domain);

if (l1 > l2) {

return strcmp(host+l1-l2,domain) == 0;

} else {

return 0;

}

} else {

return strcmp(host,domain) == 0;

}

}

int make_http_soap_request(zval *this_ptr,

int *buffer_len TSRMLS_DC)

{

char *request;

smart_str soap_headers = {0};

smart_str soap_headers_z = {0};

int request_size, err;

php_url *phpurl = NULL;

php_stream *stream;

zval **trace, **tmp;

int use_proxy = 0;

int use_ssl;

char *http_headers, *http_body, *content_type, *http_version, *cookie_itt;

int http_header_size, http_body_size, http_close;

char *connection;

int http_1_1;

int http_status;

int content_type_xml = 0;

long redirect_max = 20;

char *content_encoding;

char *http_msg = NULL;

zend_bool old_allow_url_fopen;

php_stream_context *context = NULL;

zend_bool has_authorization = 0;

zend_bool has_proxy_authorization = 0;

zend_bool has_cookies = 0;

if (this_ptr == NULL || Z_TYPE_P(this_ptr) != IS_OBJECT) {

return FALSE;

}

request = buf;

request_size = buf_size;

/* Compress request */

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "compression", sizeof("compression"), (void **)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) {

int level = Z_LVAL_PP(tmp) & 0x0f;

int kind = Z_LVAL_PP(tmp) & SOAP_COMPRESSION_DEFLATE;

if (level > 9) {level = 9;}

if ((Z_LVAL_PP(tmp) & SOAP_COMPRESSION_ACCEPT) != 0) {

smart_str_append_const(&soap_headers_z,"Accept-Encoding: gzip, deflate\r\n");

}

if (level > 0) {

zval func;

zval retval;

zval param1, param2, param3;

zval *params[3];

int n;

params[0] = &param1;

INIT_PZVAL(params[0]);

params[1] = &param2;

INIT_PZVAL(params[1]);

params[2] = &param3;

INIT_PZVAL(params[2]);

ZVAL_STRINGL(params[0], buf, buf_size, 0);

ZVAL_LONG(params[1], level);

if (kind == SOAP_COMPRESSION_DEFLATE) {

n = 2;

ZVAL_STRING(&func, "gzcompress", 0);

smart_str_append_const(&soap_headers_z,"Content-Encoding: deflate\r\n");

} else {

n = 3;

ZVAL_STRING(&func, "gzencode", 0);

smart_str_append_const(&soap_headers_z,"Content-Encoding: gzip\r\n");

ZVAL_LONG(params[2], 0x1f);

}

if (call_user_function(CG(function_table), (zval**)NULL, &func, &retval, n, params TSRMLS_CC) == SUCCESS &&

Z_TYPE(retval) == IS_STRING) {

request = Z_STRVAL(retval);

request_size = Z_STRLEN(retval);

} else {

if (request != buf) {efree(request);}

smart_str_free(&soap_headers_z);

return FALSE;

}

}

}

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"), (void **)&tmp) == SUCCESS) {

php_stream_from_zval_no_verify(stream,tmp);

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"), (void **)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) {

use_proxy = Z_LVAL_PP(tmp);

}

} else {

stream = NULL;

}

if (location != NULL && location[0] != '\000') {

phpurl = php_url_parse(location);

}

if (SUCCESS == zend_hash_find(Z_OBJPROP_P(this_ptr),

"_stream_context", sizeof("_stream_context"), (void**)&tmp)) {

context = php_stream_context_from_zval(*tmp, 0);

}

if (context &&

php_stream_context_get_option(context, "http", "max_redirects", &tmp) == SUCCESS) {

if (Z_TYPE_PP(tmp) != IS_STRING || !is_numeric_string(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), &redirect_max, NULL, 1)) {

if (Z_TYPE_PP(tmp) == IS_LONG)

redirect_max = Z_LVAL_PP(tmp);

}

}

try_again:

if (phpurl == NULL || phpurl->host == NULL) {

if (phpurl != NULL) {php_url_free(phpurl);}

if (request != buf) {efree(request);}

add_soap_fault(this_ptr, "HTTP", "Unable to parse URL", NULL, NULL TSRMLS_CC);

smart_str_free(&soap_headers_z);

return FALSE;

}

use_ssl = 0;

if (phpurl->scheme != NULL && strcmp(phpurl->scheme, "https") == 0) {

use_ssl = 1;

} else if (phpurl->scheme == NULL || strcmp(phpurl->scheme, "http") != 0) {

php_url_free(phpurl);

if (request != buf) {efree(request);}

add_soap_fault(this_ptr, "HTTP", "Unknown protocol. Only http and https are allowed.", NULL, NULL TSRMLS_CC);

smart_str_free(&soap_headers_z);

return FALSE;

}

old_allow_url_fopen = PG(allow_url_fopen);

PG(allow_url_fopen) = 1;

if (use_ssl && php_stream_locate_url_wrapper("https://", NULL, STREAM_LOCATE_WRAPPERS_ONLY TSRMLS_CC) == NULL) {

php_url_free(phpurl);

if (request != buf) {efree(request);}

add_soap_fault(this_ptr, "HTTP", "SSL support is not available in this build", NULL, NULL TSRMLS_CC);

PG(allow_url_fopen) = old_allow_url_fopen;

smart_str_free(&soap_headers_z);

return FALSE;

}

if (phpurl->port == 0) {

phpurl->port = use_ssl ? 443 : 80;

}

/* Check if request to the same host */

if (stream != NULL) {

php_url *orig;

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"), (void **)&tmp) == SUCCESS &&

(orig = (php_url *) zend_fetch_resource(tmp TSRMLS_CC, -1, "httpurl", NULL, 1, le_url)) != NULL &&

((use_proxy && !use_ssl) ||

(((use_ssl && orig->scheme != NULL && strcmp(orig->scheme, "https") == 0) ||

(!use_ssl && orig->scheme == NULL) ||

(!use_ssl && strcmp(orig->scheme, "https") != 0)) &&

strcmp(orig->host, phpurl->host) == 0 &&

orig->port == phpurl->port))) {

} else {

php_stream_close(stream);

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));

stream = NULL;

use_proxy = 0;

}

}

/* Check if keep-alive connection is still opened */

if (stream != NULL && php_stream_eof(stream)) {

php_stream_close(stream);

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));

stream = NULL;

use_proxy = 0;

}

if (!stream) {

stream = http_connect(this_ptr, phpurl, use_ssl, context, &use_proxy TSRMLS_CC);

if (stream) {

php_stream_auto_cleanup(stream);

add_property_resource(this_ptr, "httpsocket", php_stream_get_resource_id(stream));

add_property_long(this_ptr, "_use_proxy", use_proxy);

} else {

php_url_free(phpurl);

if (request != buf) {efree(request);}

add_soap_fault(this_ptr, "HTTP", "Could not connect to host", NULL, NULL TSRMLS_CC);

PG(allow_url_fopen) = old_allow_url_fopen;

smart_str_free(&soap_headers_z);

return FALSE;

}

}

PG(allow_url_fopen) = old_allow_url_fopen;

if (stream) {

zval **cookies, **login, **password;

int ret = zend_list_insert(phpurl, le_url TSRMLS_CC);

add_property_resource(this_ptr, "httpurl", ret);

/*zend_list_addref(ret);*/

if (context &&

php_stream_context_get_option(context, "http", "protocol_version", &tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_DOUBLE &&

Z_DVAL_PP(tmp) == 1.0) {

http_1_1 = 0;

} else {

http_1_1 = 1;

}

smart_str_append_const(&soap_headers, "POST ");

if (use_proxy && !use_ssl) {

smart_str_appends(&soap_headers, phpurl->scheme);

smart_str_append_const(&soap_headers, "://");

smart_str_appends(&soap_headers, phpurl->host);

smart_str_appendc(&soap_headers, ':');

smart_str_append_unsigned(&soap_headers, phpurl->port);

}

if (phpurl->path) {

smart_str_appends(&soap_headers, phpurl->path);

} else {

smart_str_appendc(&soap_headers, '/');

}

if (phpurl->query) {

smart_str_appendc(&soap_headers, '?');

smart_str_appends(&soap_headers, phpurl->query);

}

if (phpurl->fragment) {

smart_str_appendc(&soap_headers, '#');

smart_str_appends(&soap_headers, phpurl->fragment);

}

if (http_1_1) {

smart_str_append_const(&soap_headers, " HTTP/1.1\r\n");

} else {

smart_str_append_const(&soap_headers, " HTTP/1.0\r\n");

}

smart_str_append_const(&soap_headers, "Host: ");

smart_str_appends(&soap_headers, phpurl->host);

if (phpurl->port != (use_ssl?443:80)) {

smart_str_appendc(&soap_headers, ':');

smart_str_append_unsigned(&soap_headers, phpurl->port);

}

if (!http_1_1 ||

(zend_hash_find(Z_OBJPROP_P(this_ptr), "_keep_alive", sizeof("_keep_alive"), (void **)&tmp) == SUCCESS &&

Z_LVAL_PP(tmp) == 0)) {

smart_str_append_const(&soap_headers, "\r\n"

"Connection: close\r\n");

} else {

smart_str_append_const(&soap_headers, "\r\n"

"Connection: Keep-Alive\r\n");

}

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_user_agent", sizeof("_user_agent"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

if (Z_STRLEN_PP(tmp) > 0) {

smart_str_append_const(&soap_headers, "User-Agent: ");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

smart_str_append_const(&soap_headers, "\r\n");

}

} else if (context &&

php_stream_context_get_option(context, "http", "user_agent", &tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

if (Z_STRLEN_PP(tmp) > 0) {

smart_str_append_const(&soap_headers, "User-Agent: ");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

smart_str_append_const(&soap_headers, "\r\n");

}

} else if (FG(user_agent)) {

smart_str_append_const(&soap_headers, "User-Agent: ");

smart_str_appends(&soap_headers, FG(user_agent));

smart_str_append_const(&soap_headers, "\r\n");

} else {

smart_str_append_const(&soap_headers, "User-Agent: PHP-SOAP/"PHP_VERSION"\r\n");

}

smart_str_append(&soap_headers, &soap_headers_z);

if (soap_version == SOAP_1_2) {

smart_str_append_const(&soap_headers,"Content-Type: application/soap+xml; charset=utf-8");

if (soapaction) {

smart_str_append_const(&soap_headers,"; action=\"");

smart_str_appends(&soap_headers, soapaction);

smart_str_append_const(&soap_headers,"\"");

}

smart_str_append_const(&soap_headers,"\r\n");

} else {

smart_str_append_const(&soap_headers,"Content-Type: text/xml; charset=utf-8\r\n");

if (soapaction) {

smart_str_append_const(&soap_headers, "SOAPAction: \"");

smart_str_appends(&soap_headers, soapaction);

smart_str_append_const(&soap_headers, "\"\r\n");

}

}

smart_str_append_const(&soap_headers,"Content-Length: ");

smart_str_append_long(&soap_headers, request_size);

smart_str_append_const(&soap_headers, "\r\n");

/* HTTP Authentication */

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_login", sizeof("_login"), (void **)&login) == SUCCESS &&

Z_TYPE_PP(login) == IS_STRING) {

zval **digest;

has_authorization = 1;

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_digest", sizeof("_digest"), (void **)&digest) == SUCCESS) {

if (Z_TYPE_PP(digest) == IS_ARRAY) {

char HA1[33], HA2[33], response[33], cnonce[33], nc[9];

PHP_MD5_CTX md5ctx;

unsigned char hash[16];

PHP_MD5Init(&md5ctx);

snprintf(cnonce, sizeof(cnonce), "%ld", php_rand(TSRMLS_C));

PHP_MD5Update(&md5ctx, (unsigned char*)cnonce, strlen(cnonce));

PHP_MD5Final(hash, &md5ctx);

make_digest(cnonce, hash);

if (zend_hash_find(Z_ARRVAL_PP(digest), "nc", sizeof("nc"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_LONG) {

Z_LVAL_PP(tmp)++;

snprintf(nc, sizeof(nc), "%08ld", Z_LVAL_PP(tmp));

} else {

add_assoc_long(*digest, "nc", 1);

strcpy(nc, "00000001");

}

PHP_MD5Init(&md5ctx);

PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(login), Z_STRLEN_PP(login));

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

if (zend_hash_find(Z_ARRVAL_PP(digest), "realm", sizeof("realm"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS &&

Z_TYPE_PP(password) == IS_STRING) {

PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(password), Z_STRLEN_PP(password));

}

PHP_MD5Final(hash, &md5ctx);

make_digest(HA1, hash);

if (zend_hash_find(Z_ARRVAL_PP(digest), "algorithm", sizeof("algorithm"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING &&

Z_STRLEN_PP(tmp) == sizeof("md5-sess")-1 &&

stricmp(Z_STRVAL_PP(tmp), "md5-sess") == 0) {

PHP_MD5Init(&md5ctx);

PHP_MD5Update(&md5ctx, (unsigned char*)HA1, 32);

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

if (zend_hash_find(Z_ARRVAL_PP(digest), "nonce", sizeof("nonce"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

PHP_MD5Update(&md5ctx, (unsigned char*)cnonce, 8);

PHP_MD5Final(hash, &md5ctx);

make_digest(HA1, hash);

}

PHP_MD5Init(&md5ctx);

PHP_MD5Update(&md5ctx, (unsigned char*)"POST:", sizeof("POST:")-1);

if (phpurl->path) {

PHP_MD5Update(&md5ctx, (unsigned char*)phpurl->path, strlen(phpurl->path));

} else {

PHP_MD5Update(&md5ctx, (unsigned char*)"/", 1);

}

if (phpurl->query) {

PHP_MD5Update(&md5ctx, (unsigned char*)"?", 1);

PHP_MD5Update(&md5ctx, (unsigned char*)phpurl->query, strlen(phpurl->query));

}

/* TODO: Support for qop="auth-int" */

PHP_MD5Final(hash, &md5ctx);

make_digest(HA2, hash);

PHP_MD5Init(&md5ctx);

PHP_MD5Update(&md5ctx, (unsigned char*)HA1, 32);

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

if (zend_hash_find(Z_ARRVAL_PP(digest), "nonce", sizeof("nonce"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

PHP_MD5Update(&md5ctx, (unsigned char*)Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

if (zend_hash_find(Z_ARRVAL_PP(digest), "qop", sizeof("qop"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

PHP_MD5Update(&md5ctx, (unsigned char*)nc, 8);

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

PHP_MD5Update(&md5ctx, (unsigned char*)cnonce, 8);

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

/* TODO: Support for qop="auth-int" */

PHP_MD5Update(&md5ctx, (unsigned char*)"auth", sizeof("auth")-1);

PHP_MD5Update(&md5ctx, (unsigned char*)":", 1);

}

PHP_MD5Update(&md5ctx, (unsigned char*)HA2, 32);

PHP_MD5Final(hash, &md5ctx);

make_digest(response, hash);

smart_str_append_const(&soap_headers, "Authorization: Digest username=\"");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(login), Z_STRLEN_PP(login));

if (zend_hash_find(Z_ARRVAL_PP(digest), "realm", sizeof("realm"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

smart_str_append_const(&soap_headers, "\", realm=\"");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

if (zend_hash_find(Z_ARRVAL_PP(digest), "nonce", sizeof("nonce"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

smart_str_append_const(&soap_headers, "\", nonce=\"");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

smart_str_append_const(&soap_headers, "\", uri=\"");

if (phpurl->path) {

smart_str_appends(&soap_headers, phpurl->path);

} else {

smart_str_appendc(&soap_headers, '/');

}

if (phpurl->query) {

smart_str_appendc(&soap_headers, '?');

smart_str_appends(&soap_headers, phpurl->query);

}

if (phpurl->fragment) {

smart_str_appendc(&soap_headers, '#');

smart_str_appends(&soap_headers, phpurl->fragment);

}

if (zend_hash_find(Z_ARRVAL_PP(digest), "qop", sizeof("qop"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

/* TODO: Support for qop="auth-int" */

smart_str_append_const(&soap_headers, "\", qop=\"auth");

smart_str_append_const(&soap_headers, "\", nc=\"");

smart_str_appendl(&soap_headers, nc, 8);

smart_str_append_const(&soap_headers, "\", cnonce=\"");

smart_str_appendl(&soap_headers, cnonce, 8);

}

smart_str_append_const(&soap_headers, "\", response=\"");

smart_str_appendl(&soap_headers, response, 32);

if (zend_hash_find(Z_ARRVAL_PP(digest), "opaque", sizeof("opaque"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

smart_str_append_const(&soap_headers, "\", opaque=\"");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

if (zend_hash_find(Z_ARRVAL_PP(digest), "algorithm", sizeof("algorithm"), (void **)&tmp) == SUCCESS &&

Z_TYPE_PP(tmp) == IS_STRING) {

smart_str_append_const(&soap_headers, "\", algorithm=\"");

smart_str_appendl(&soap_headers, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));

}

smart_str_append_const(&soap_headers, "\"\r\n");

}

} else {

unsigned char* buf;

int len;

smart_str auth = {0};

smart_str_appendl(&auth, Z_STRVAL_PP(login), Z_STRLEN_PP(login));

smart_str_appendc(&auth, ':');

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_password", sizeof("_password"), (void **)&password) == SUCCESS &&

Z_TYPE_PP(password) == IS_STRING) {

smart_str_appendl(&auth, Z_STRVAL_PP(password), Z_STRLEN_PP(password));

}

smart_str_0(&auth);

buf = php_base64_encode((unsigned char*)auth.c, auth.len, &len);

smart_str_append_const(&soap_headers, "Authorization: Basic ");

smart_str_appendl(&soap_headers, (char*)buf, len);

smart_str_append_const(&soap_headers, "\r\n");

efree(buf);

smart_str_free(&auth);

}

}

/* Proxy HTTP Authentication */

if (use_proxy && !use_ssl) {

has_proxy_authorization = proxy_authentication(this_ptr, &soap_headers TSRMLS_CC);

}

/* Send cookies along with request */

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), (void **)&cookies) == SUCCESS) {

zval **data;

char *key;

int i, n;

has_cookies = 1;

n = zend_hash_num_elements(Z_ARRVAL_PP(cookies));

if (n > 0) {

zend_hash_internal_pointer_reset(Z_ARRVAL_PP(cookies));

smart_str_append_const(&soap_headers, "Cookie: ");

for (i = 0; i < n; i++) {

zend_hash_get_current_data(Z_ARRVAL_PP(cookies), (void **)&data);

zend_hash_get_current_key(Z_ARRVAL_PP(cookies), &key, NULL, FALSE);

if (Z_TYPE_PP(data) == IS_ARRAY) {

zval** value;

if (zend_hash_index_find(Z_ARRVAL_PP(data), 0, (void**)&value) == SUCCESS &&

Z_TYPE_PP(value) == IS_STRING) {

zval **tmp;

if ((zend_hash_index_find(Z_ARRVAL_PP(data), 1, (void**)&tmp) == FAILURE ||

strncmp(phpurl->path?phpurl->path:"/",Z_STRVAL_PP(tmp),Z_STRLEN_PP(tmp)) == 0) &&

(zend_hash_index_find(Z_ARRVAL_PP(data), 2, (void**)&tmp) == FAILURE ||

in_domain(phpurl->host,Z_STRVAL_PP(tmp))) &&

(use_ssl || zend_hash_index_find(Z_ARRVAL_PP(data), 3, (void**)&tmp) == FAILURE)) {

smart_str_appendl(&soap_headers, key, strlen(key));

smart_str_appendc(&soap_headers, '=');

smart_str_appendl(&soap_headers, Z_STRVAL_PP(value), Z_STRLEN_PP(value));

smart_str_appendc(&soap_headers, ';');

}

}

}

zend_hash_move_forward(Z_ARRVAL_PP(cookies));

}

smart_str_append_const(&soap_headers, "\r\n");

}

}

http_context_headers(context, has_authorization, has_proxy_authorization, has_cookies, &soap_headers TSRMLS_CC);

smart_str_append_const(&soap_headers, "\r\n");

smart_str_0(&soap_headers);

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&

Z_LVAL_PP(trace) > 0) {

add_property_stringl(this_ptr, "__last_request_headers", soap_headers.c, soap_headers.len, 1);

}

smart_str_appendl(&soap_headers, request, request_size);

smart_str_0(&soap_headers);

err = php_stream_write(stream, soap_headers.c, soap_headers.len);

if (err != soap_headers.len) {

if (request != buf) {efree(request);}

php_stream_close(stream);

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));

add_soap_fault(this_ptr, "HTTP", "Failed Sending HTTP SOAP request", NULL, NULL TSRMLS_CC);

smart_str_free(&soap_headers_z);

return FALSE;

}

smart_str_free(&soap_headers);

} else {

add_soap_fault(this_ptr, "HTTP", "Failed to create stream??", NULL, NULL TSRMLS_CC);

smart_str_free(&soap_headers_z);

return FALSE;

}

if (!buffer) {

php_stream_close(stream);

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));

smart_str_free(&soap_headers_z);

return TRUE;

}

do {

if (!get_http_headers(stream, &http_headers, &http_header_size TSRMLS_CC)) {

if (http_headers) {efree(http_headers);}

if (request != buf) {efree(request);}

php_stream_close(stream);

zend_hash_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket"));

zend_hash_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy"));

add_soap_fault(this_ptr, "HTTP", "Error Fetching http headers", NULL, NULL TSRMLS_CC);

smart_str_free(&soap_headers_z);

return FALSE;

}

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&

Z_LVAL_PP(trace) > 0) {

add_property_stringl(this_ptr, "__last_response_headers", http_headers, http_header_size, 1);

}

/* Check to see what HTTP status was sent */

http_1_1 = 0;

http_status = 0;

http_version = get_http_header_value(http_headers,"HTTP/");

if (http_version) {

char *tmp;

if (!strncmp(http_version,"1.1", 3)) {

http_1_1 = 1;

}

tmp = strstr(http_version," ");

if (tmp != NULL) {

tmp++;

http_status = atoi(tmp);

}

tmp = strstr(tmp," ");

if (tmp != NULL) {

tmp++;

if (http_msg) {

efree(http_msg);

}

http_msg = estrdup(tmp);

}

efree(http_version);

/* Try and get headers again */

if (http_status == 100) {

efree(http_headers);

}

}

} while (http_status == 100);

/* Grab and send back every cookie */

/* Not going to worry about Path: because

cookie_itt = strstr(http_headers,"Set-Cookie: ");

while (cookie_itt) {

char *end_pos, *cookie;

char *eqpos, *sempos;

zval **cookies;

if (zend_hash_find(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), (void **)&cookies) == FAILURE) {

zval *tmp_cookies;

MAKE_STD_ZVAL(tmp_cookies);

array_init(tmp_cookies);

zend_hash_update(Z_OBJPROP_P(this_ptr), "_cookies", sizeof("_cookies"), &tmp_cookies, sizeof(zval *), (void **)&cookies);

}

end_pos = strstr(cookie_itt,"\r\n");

cookie = get_http_header_value(cookie_itt,"Set-Cookie: ");

eqpos = strstr(cookie, "=");

sempos = strstr(cookie, ";");

if (eqpos != NULL && (sempos == NULL || sempos > eqpos)) {

smart_str name = {0};

int cookie_len;

zval *zcookie;

if (sempos != NULL) {

cookie_len = sempos-(eqpos+1);

} else {

cookie_len = strlen(cookie)-(eqpos-cookie)-1;

}

smart_str_appendl(&name, cookie, eqpos - cookie);

smart_str_0(&name);

ALLOC_INIT_ZVAL(zcookie);

array_init(zcookie);

add_index_stringl(zcookie, 0, eqpos + 1, cookie_len, 1);

if (sempos != NULL) {

char *options = cookie + cookie_len+1;

while (*options) {

while (*options == ' ') {options++;}

sempos = strstr(options, ";");

if (strstr(options,"path=") == options) {

eqpos = options + sizeof("path=")-1;

add_index_stringl(zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos), 1);

} else if (strstr(options,"domain=") == options) {

eqpos = options + sizeof("domain=")-1;

add_index_stringl(zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos), 1);

} else if (strstr(options,"secure") == options) {

add_index_bool(zcookie, 3, 1);

}

if (sempos != NULL) {

options = sempos+1;

} else {

break;

}

}

}

if (!zend_hash_index_exists(Z_ARRVAL_P(zcookie), 1)) {

char *t = phpurl->path?phpurl->path:"/";

char *c = strrchr(t, '/');

if (c) {

add_index_stringl(zcookie, 1, t, c-t, 1);

}

}

if (!zend_hash_index_exists(Z_ARRVAL_P(zcookie), 2)) {

add_index_string(zcookie, 2, phpurl->host, 1);

}

add_assoc_zval_ex(*cookies, name.c, name.len+1, zcookie);

smart_str_free(&name);

}

cookie_itt = strstr(cookie_itt + sizeof("Set-Cookie: "), "Set-Cookie: ");

efree(cookie);

}

/* See if the server requested a close */

if (http_1_1) {

http_close = FALSE;

if (use_proxy && !use_ssl) {

connection = get_http_header_value(http_headers,"Proxy-Connection: ");

if (connection) {

if (strncasecmp(connection, "close", sizeof("close")-1) == 0) {

http_close = TRUE;

}

efree(connection);

}

}

if (http_close == FALSE) {

connection = get_http_header_value(http_headers,"Connection: ");