var $request\_compression\; =\; \text{'}\text{'};$

CURL handle: used for keep-alive connections (PHP 4.3.8 up, see: http://curl.haxx.se/docs/faq.html#7.3) */ var xmlrpc_curl_handle = null; Wheter to use persistent connections for http 1.1 and https var $keepalive\; =\; false;\; Charset\; encodings\; that\; can\; be\; decoded\; without\; problems\; by\; the\; client\; var$accepted_charset_encodings = array(); Charset encoding to be used in serializing request. NULL = use ASCII var $request\_charset\_encoding\; =\; \text{'}\text{'};$

Decides the content of xmlrpcresp objects returned by calls to send() valid strings are 'xmlrpcvals', 'phpvals' or 'xml'

                var return_type = 'xmlrpcvals';

                

parameter: string $path\; either\; the\; complete\; server\; URL\; or\; the\; PATH\; part\; of\; the\; xmlrc\; server\; URL,\; e.g.\; /xmlrpc/server.php$
parameter: string server the server name / ip address
parameter: integer $port\; the\; port\; the\; server\; is\; listening\; on,\; defaults\; to\; 80\; or\; 443\; depending\; on\; protocol\; used$
parameter: string method the http protocol variant: defaults to 'http', 'https' and 'http11' can be used if CURL is installed

                function xmlrpc_client($path,$server='', $port=\text{'}\text{'},$method='')
                {
                        // allow user to specify all params in $path\; if($server == '' and $port\; ==\; \text{'}\text{'}\; and$method == '')
                        {
                                $parts\; =\; parse\_url($path);
                                $server\; =$parts['host'];
                                $path\; =$parts['path'];
                                if(isset($parts[\text{'}query\text{'}]))\; \{$path .= '?'.$parts[\text{'}query\text{'}];\; \}\; if(isset($parts['fragment']))
                                {
                                        $path\; .=\; \text{'}\#\text{'}.$parts['fragment'];
                                }
                                if(isset($parts[\text{'}port\text{'}]))\; \{$port = $parts[\text{'}port\text{'}];\; \}\; if(isset($parts['scheme']))
                                {
                                        $method\; =$parts['scheme'];
                                }
                                if(isset($parts[\text{'}user\text{'}]))\; \{$this->username = $parts[\text{'}user\text{'}];\; \}\; if(isset($parts['pass']))
                                {
                                        $this->password\; =$parts['pass'];
                                }
                        }
                        if($path\; ==\; \text{'}\text{'}\; ||$path[0] != '/')
                        {
                                $this->path=\text{'}/\text{'}.$path;
                        }
                        else
                        {
                                $this->path=$path;
                        }
                        $this->server=$server;
                        if($port\; !=\; \text{'}\text{'})\; \{$this->port=$port;\; \}\; if($method != '')
                        {
                                $this->method=$method;
                        }

                        // if ZLIB is enabled, let the client by default accept compressed responses
                        if(function_exists('gzinflate') || (
                                function_exists('curl_init') && ((info) && strpos($info,\; \text{'}zlib\text{'})\; !==\; null)\; ||\; isset($info['libz_version'])))
                        ))
                        {
                                this->keepalive = true;
                        }

                        // by default the xml parser can support these 3 charset encodings
                        $this->accepted\_charset\_encodings\; =\; array(\text{'}UTF-8\text{'},\; \text{'}ISO-8859-1\text{'},\; \text{'}US-ASCII\text{'});\; \}$

Enables/disables the echoing to screen of the xmlrpc responses received
parameter: integer debug values 0, 1 and 2 are supported (2 = echo sent msg too, before received response) @access public

                function setDebug($in)\; \{$this->debug=$in;\; \}$

Add some http BASIC AUTH credentials, used by the client to authenticate
parameter: string u username
parameter: string $p\; password$
parameter: integer t auth type. See curl_setopt man page for supported auth types. Defaults to CURLAUTH_BASIC (basic auth) @access public

                function setCredentials($u,$p, $t=1)\; \{$this->username=$u;$this->password=$p;$this->authtype=$t;\; \}$

Add a client-side https certificate
parameter: string cert
parameter: string $certpass\; @access\; public$

                function setCertificate(cert, $certpass)\; \{$this->cert = $cert;$this->certpass = $certpass;\; \}$

Add a CA certificate to verify server with (see man page about CURLOPT_CAINFO for more details
parameter: string cacert certificate file name (or dir holding certificates)
parameter: bool $is\_dir\; set\; to\; true\; to\; indicate\; cacert\; is\; a\; dir.\; defaults\; to\; false\; @access\; public$

                function setCaCertificate(cacert, $is\_dir=false)\; \{\; if\; ($is_dir)
                        {
                                $this->cacert\; =$cacert;
                        }
                        else
                        {
                                $this->cacertdir\; =$cacert;
                        }
                }

                

Set attributes for SSL communication: private SSL key
parameter: string $key\; The\; name\; of\; a\; file\; containing\; a\; private\; SSL\; key$
parameter: string keypass The secret password needed to use the private SSL key @access public NB: does not work in older php/curl installs Thanks to Daniel Convissor

                function setKey($key,$keypass)
                {
                        $this->key\; =$key;
                        $this->keypass\; =$keypass;
                }

                

Set attributes for SSL communication: verify server certificate
parameter: bool $i\; enable/disable\; verification\; of\; peer\; certificate\; @access\; public$

                function setSSLVerifyPeer(i)
                {
                        $this->verifypeer\; =$i;
                }

                

Set attributes for SSL communication: verify match of server cert w. hostname
parameter: int $i\; @access\; public$

                function setSSLVerifyHost(i)
                {
                        $this->verifyhost\; =$i;
                }

                

Set proxy info
parameter: string $proxyhost$
parameter: string proxyport Defaults to 8080 for HTTP and 443 for HTTPS
parameter: string $proxyusername\; Leave\; blank\; if\; proxy\; has\; public\; access$
parameter: string proxypassword Leave blank if proxy has public access
parameter: int $proxyauthtype\; set\; to\; constant\; CURLAUTH\_MTLM\; to\; use\; NTLM\; auth\; with\; proxy\; @access\; public$

                function setProxy(proxyhost, $proxyport,$proxyusername = '', $proxypassword\; =\; \text{'}\text{'},$proxyauthtype = 1)
                {
                        $this->proxy\; =$proxyhost;
                        $this->proxyport\; =$proxyport;
                        $this->proxy\_user\; =$proxyusername;
                        $this->proxy\_pass\; =$proxypassword;
                        $this->proxy\_autthtype\; =$proxyauthtype;
                }

                

Enables/disables reception of compressed xmlrpc responses. Note that enabling reception of compressed responses merely adds some standard http headers to xmlrpc requests. It is up to the xmlrpc server to return compressed responses when receiving such requests.
parameter: string $compmethod\; either\; \text{'}gzip\text{'},\; \text{'}deflate\text{'},\; \text{'}any\text{'}\; or\; \text{'}\text{'}\; @access\; public$

                function setAcceptedCompression(compmethod)
                {
                        if ($compmethod\; ==\; \text{'}any\text{'})$this->accepted_compression = array('gzip', 'deflate');
                        else
                                $this->accepted\_compression\; =\; array($compmethod);
                }

                

Enables/disables http compression of xmlrpc request. Take care when sending compressed requests: servers might not support them (and automatic fallback to uncompressed requests is not yet implemented)
parameter: string $compmethod\; either\; \text{'}gzip\text{'},\; \text{'}deflate\text{'}\; or\; \text{'}\text{'}\; @access\; public$

                function setRequestCompression(compmethod)
                {
                        $this->request\_compression\; =$compmethod;
                }

                

Adds a cookie to list of cookies that will be sent to server. NB: setting any param but name and value will turn the cookie into a 'version 1' cookie: do not do it unless you know what you are doing
parameter: string $name$
parameter: string value
parameter: string $path$
parameter: string domain
parameter: int $port\; @access\; public\; @todo\; check\; correctness\; of\; urlencoding\; cookie\; value\; (copied\; from\; php\; way\; of\; doing\; it...)$

                function setCookie(name, $value=\text{'}\text{'},$path='', $domain=\text{'}\text{'},$port=null)
                {
                        $this->cookies[$name]['value'] = urlencode($value);\; if\; ($path || $domain\; ||$port)
                        {
                                $this->cookies[$name]['path'] = $path;$this->cookies[$name][\text{'}domain\text{'}]\; =$domain;
                                $this->cookies[$name]['port'] = $port;$this->cookies[$name][\text{'}version\text{'}]\; =\; 1;\; \}\; else\; \{$this->cookies[$name][\text{'}version\text{'}]\; =\; 0;\; \}\; \}$

Send an xmlrpc request
parameter: mixed msg The message object, or an array of messages for using multicall, or the complete xml representation of a request
parameter: integer $timeoutConnectiontimeout,\; in\; seconds,\; If\; unspecified,\; a\; platform\; specific\; timeout\; will\; apply$
parameter: string method if left unspecified, the http protocol chosen during creation of the object will be used
returns: xmlrpcresp @access public

                function& send($msg,$timeout=0, $method=\text{'}\text{'})\; \{\; //\; if\; user\; deos\; not\; specify\; http\; protocol,\; use\; native\; method\; of\; this\; client\; //\; (i.e.\; method\; set\; during\; call\; to\; constructor)\; if($method == '')
                        {
                                $method\; =$this->method;
                        }

                        if(is_array($msg))\; \{\; //$msg is an array of xmlrpcmsg's
                                $r\; =$this->multicall($msg,$timeout, $method);\; return$r;
                        }
                        elseif(is_string($msg))\; \{$n =& new xmlrpcmsg('');
                                $n->payload\; =$msg;
                                $msg\; =$n;
                        }

                        // where msg is an xmlrpcmsg
                        $msg->debug=$this->debug;

                        if($method\; ==\; \text{'}https\text{'})\; \{$r =& $this->sendPayloadHTTPS($msg,
                                        $this->server,$this->port,
                                        $timeout,$this->username,
                                        $this->password,$this->authtype,
                                        $this->cert,$this->certpass,
                                        $this->cacert,$this->cacertdir,
                                        $this->proxy,$this->proxyport,
                                        $this->proxy\_user,$this->proxy_pass,
                                        $this->proxy\_authtype,$this->keepalive,
                                        $this->key,$this->keypass
                                );
                        }
                        elseif($method\; ==\; \text{'}http11\text{'})\; \{$r =& $this->sendPayloadCURL($msg,
                                        $this->server,$this->port,
                                        $timeout,$this->username,
                                        $this->password,$this->authtype,
                                        null,
                                        null,
                                        null,
                                        null,
                                        $this->proxy,$this->proxyport,
                                        $this->proxy\_user,$this->proxy_pass,
                                        $this->proxy\_authtype,\; \text{'}http\text{'},$this->keepalive
                                );
                        }
                        else
                        {
                                this->sendPayloadHTTP10(
                                        $msg,$this->server,
                                        $this->port,$timeout,
                                        $this->username,$this->password,
                                        $this->authtype,$this->proxy,
                                        $this->proxyport,$this->proxy_user,
                                        $this->proxy\_pass,$this->proxy_authtype
                                );
                        }

                        return $r;\; \}$

@access private

                function &sendPayloadHTTP10(msg, $server,$port, $timeout=0,$username='', $password=\text{'}\text{'},$authtype=1, $proxyhost=\text{'}\text{'},$proxyport=0, $proxyusername=\text{'}\text{'},$proxypassword='', $proxyauthtype=1)\; \{\; if($port==0)
                        {
                                $port=80;\; \}\; //\; Only\; create\; the\; payload\; if\; it\; was\; not\; created\; previously\; if(empty($msg->payload))
                        {
                                $msg->createPayload($this->request_charset_encoding);
                        }

                        $payload\; =$msg->payload;
                        // Deflate request body and set appropriate request headers
                        if(function_exists('gzdeflate') && ($this->request\_compression\; ==\; \text{'}gzip\text{'}\; ||$this->request_compression == 'deflate'))
                        {
                                if($this->request\_compression\; ==\; \text{'}gzip\text{'})\; \{$a = @gzencode($payload);\; if($a)
                                        {
                                                $payload\; =$a;
                                                $encoding\_hdr\; =\; "Content-Encoding:\; gzip\backslash r\backslash n";\; \}\; \}\; else\; \{$a = @gzcompress($payload);\; if($a)
                                        {
                                                $payload\; =$a;
                                                $encoding\_hdr\; =\; "Content-Encoding:\; deflate\backslash r\backslash n";\; \}\; \}\; \}\; else\; \{$encoding_hdr = '';
                        }

                        // thanks to Grant Rauscher <grant7@firstworld.net> for this
                        $credentials=\text{'}\text{'};\; if($username!='')
                        {
                                $credentials=\text{'}Authorization:\; Basic\; \text{'}\; .\; base64\_encode($username . ':' . $password)\; .\; "\backslash r\backslash n";\; if\; ($authtype != 1)
                                {
                                        error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth is supported with HTTP 1.0');
                                }
                        }

                        $accepted\_encoding\; =\; \text{'}\text{'};\; if(is\_array($this->accepted_compression) && count($this->accepted\_compression))\; \{$accepted_encoding = 'Accept-Encoding: ' . implode(', ', $this->accepted\_compression)\; .\; "\backslash r\backslash n";\; \}$proxy_credentials = '';
                        if($proxyhost)\; \{\; if($proxyport == 0)
                                {
                                        $proxyport\; =\; 8080;\; \}$connectserver = $proxyhost;$connectport = $proxyport;$uri = 'http://'.$server.':'.$port.$this->path;
                                if($proxyusername\; !=\; \text{'}\text{'})\; \{\; if\; ($proxyauthtype != 1)
                                        {
                                                error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth to proxy is supported with HTTP 1.0');
                                        }
                                        $proxy\_credentials\; =\; \text{'}Proxy-Authorization:\; Basic\; \text{'}\; .\; base64\_encode($proxyusername.':'.$proxypassword)\; .\; "\backslash r\backslash n";\; \}\; \}\; else\; \{$connectserver = $server;$connectport = $port;$uri = $this->path;\; \}\; //\; Cookie\; generation,\; as\; per\; rfc2965\; (version\; 1\; cookies)\; or\; //\; netscape\text{'}s\; rules\; (version\; 0\; cookies)$cookieheader='';
                        foreach ($this->cookies\; as$name => $cookie)\; \{\; if\; ($cookie['version'])
                                {
                                        $cookieheader\; .=\; \text{'}Cookie:$Version="' . $cookie[\text{'}version\text{'}]\; .\; \text{'}";\; \text{'};$cookieheader .= $name\; .\; \text{'}="\text{'}\; .$cookie['value'] . '";';
                                        if ($cookie[\text{'}path\text{'}])$cookieheader .= ' $Path="\text{'}\; .$cookie['path'] . '";';
                                        if ($cookie[\text{'}domain\text{'}])$cookieheader .= ' $Domain="\text{'}\; .$cookie['domain'] . '";';
                                        if ($cookie[\text{'}port\text{'}])$cookieheader .= ' $Port="\text{'}\; .$cookie['domain'] . '";';
                                        $cookieheader\; =\; substr($cookieheader, 0, -1) . "\r\n";
                                }
                                else
                                {
                                        $cookieheader\; .=\; \text{'}Cookie:\; \text{'}\; .$name . '=' . $cookie[\text{'}value\text{'}]\; .\; "\backslash r\backslash n";\; \}\; \}$op= 'POST ' . $uri.\; "\; HTTP/1.0\backslash r\backslash n"\; .\; \text{'}User-Agent:\; \text{'}\; .$GLOBALS['xmlrpcName'] . ' ' . $GLOBALS[\text{'}xmlrpcVersion\text{'}]\; .\; "\backslash r\backslash n"\; .\; \text{'}Host:\; \text{'}.$server . ':' . $port\; .\; "\backslash r\backslash n"\; .$credentials .
                                $proxy\_credentials\; .$accepted_encoding .
                                $encoding\_hdr\; .\; \text{'}Accept-Charset:\; \text{'}\; .\; implode(\text{'},\text{'},$this->accepted_charset_encodings) . "\r\n" .
                                $cookieheader\; .\; \text{'}Content-Type:\; \text{'}\; .$msg->content_type . "\r\nContent-Length: " .
                                strlen($payload)\; .\; "\backslash r\backslash n\backslash r\backslash n"\; .$payload;

                        if(op) . "\n---END---\n</PRE>";
                                // let the client see this now in case http times out...
                                flush();
                        }

                        if($timeout>0)\; \{$fp=@fsockopen($connectserver,$connectport, $this->errno,$this->errstr, $timeout);\; \}\; else\; \{$fp=@fsockopen($connectserver,$connectport, $this->errno,$this->errstr);
                        }
                        if($fp)\; \{\; if($timeout>0 && function_exists('stream_set_timeout'))
                                {
                                        stream_set_timeout($fp,$timeout);
                                }
                        }
                        else
                        {
                                $this->errstr=\text{'}Connect\; error:\; \text{'}.$this->errstr;
                                GLOBALS['xmlrpcerr']['http_error'], $this->errstr\; .\; \text{'}\; (\text{'}\; .$this->errno . ')');
                                return $r;\; \}\; if(!fputs($fp, $op,\; strlen($op)))
                        {
                                $this->errstr=\text{'}Write\; error\text{'};$r=&new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}http\_error\text{'}],$this->errstr);
                                return $r;\; \}\; else\; \{\; //\; reset\; errno\; and\; errstr\; on\; succesful\; socket\; connection$this->errstr = '';
                        }
                        // G. Giunta 2005/10/24: close socket before parsing.
                        // should yeld slightly better execution times, and make easier recursive calls (e.g. to follow http redirects)
                        $ipd=\text{'}\text{'};\; while($data=fread($fp,\; 32768))\; \{\; //\; shall\; we\; check\; for$data === FALSE?
                                // as per the manual, it signals an error
                                $ipd.=$data;
                        }
                        fclose($fp);$r =& $msg->parseResponse($ipd, false, $this->return\_type);\; return$r;

                }

                

@access private

                function &sendPayloadHTTPS($msg,$server, $port,$timeout=0, $username=\text{'}\text{'},$password='', $authtype=1,$cert='',$certpass=\text{'}\text{'},$cacert='', $cacertdir=\text{'}\text{'},$proxyhost='', $proxyport=0,$proxyusername='', $proxypassword=\text{'}\text{'},$proxyauthtype=1,
                        $keepalive=false,$key='', $keypass=\text{'}\text{'})\; \{$r =& $this->sendPayloadCURL($msg, $server,$port, $timeout,$username,
                                $password,$authtype, $cert,$certpass, $cacert,$cacertdir, $proxyhost,$proxyport,
                                $proxyusername,$proxypassword, $proxyauthtype,\; \text{'}https\text{'},$keepalive, $key,$keypass);
                        return $r;\; \}$

Contributed by Justin Miller <justin@voxel.net> Requires curl to be built into PHP NB: CURL versions before 7.11.10 cannot use proxy to talk to https servers! @access private

                function &sendPayloadCURL(msg, $server,$port, $timeout=0,$username='',
                        $password=\text{'}\text{'},$authtype=1, $cert=\text{'}\text{'},$certpass='', $cacert=\text{'}\text{'},$cacertdir='',
                        $proxyhost=\text{'}\text{'},$proxyport=0, $proxyusername=\text{'}\text{'},$proxypassword='', $proxyauthtype=1,$method='https',
                        $keepalive=false,$key='', $keypass=\text{'}\text{'})\; \{\; if(!function\_exists(\text{'}curl\_init\text{'}))\; \{$this->errstr='CURL unavailable on this install';
                                GLOBALS['xmlrpcerr']['no_curl'], $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}no\_curl\text{'}]);\; return$r;
                        }
                        if($method\; ==\; \text{'}https\text{'})\; \{\; if(($info = curl_version()) &&
                                        ((is_string(info, 'OpenSSL') === null) || (is_array(info['ssl_version']))))
                                {
                                        $this->errstr=\text{'}SSL\; unavailable\; on\; this\; install\text{'};$r=&new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}no\_ssl\text{'}],$GLOBALS['xmlrpcstr']['no_ssl']);
                                        return $r;\; \}\; \}\; if($port == 0)
                        {
                                if($method\; ==\; \text{'}http\text{'})\; \{$port = 80;
                                }
                                else
                                {
                                        $port\; =\; 443;\; \}\; \}\; //\; Only\; create\; the\; payload\; if\; it\; was\; not\; created\; previously\; if(empty($msg->payload))
                        {
                                $msg->createPayload($this->request_charset_encoding);
                        }

                        // Deflate request body and set appropriate request headers
                        $payload\; =$msg->payload;
                        if(function_exists('gzdeflate') && ($this->request\_compression\; ==\; \text{'}gzip\text{'}\; ||$this->request_compression == 'deflate'))
                        {
                                if($this->request\_compression\; ==\; \text{'}gzip\text{'})\; \{$a = @gzencode($payload);\; if($a)
                                        {
                                                $payload\; =$a;
                                                $encoding\_hdr\; =\; \text{'}Content-Encoding:\; gzip\text{'};\; \}\; \}\; else\; \{$a = @gzcompress($payload);\; if($a)
                                        {
                                                $payload\; =$a;
                                                $encoding\_hdr\; =\; \text{'}Content-Encoding:\; deflate\text{'};\; \}\; \}\; \}\; else\; \{$encoding_hdr = '';
                        }

                        if(payload) . "\n---END---\n</PRE>";
                                // let the client see this now in case http times out...
                                flush();
                        }

                        if(!$keepalive\; ||\; !$this->xmlrpc_curl_handle)
                        {
                                $curl\; =\; curl\_init($method . '://' . $server\; .\; \text{'}:\text{'}\; .$port . $this->path);\; if($keepalive)
                                {
                                        $this->xmlrpc\_curl\_handle\; =$curl;
                                }
                        }
                        else
                        {
                                $curl\; =$this->xmlrpc_curl_handle;
                        }

                        // results into variable
                        curl_setopt($curl,\; CURLOPT\_RETURNTRANSFER,\; 1);\; if($this->debug)
                        {
                                curl_setopt($curl,\; CURLOPT\_VERBOSE,\; 1);\; \}\; curl\_setopt($curl, CURLOPT_USERAGENT, $GLOBALS[\text{'}xmlrpcName\text{'}].\text{'}\; \text{'}.$GLOBALS['xmlrpcVersion']);
                        // required for XMLRPC: post the data
                        curl_setopt($curl,\; CURLOPT\_POST,\; 1);\; //\; the\; data\; curl\_setopt($curl, CURLOPT_POSTFIELDS, $payload);\; //\; return\; the\; header\; too\; curl\_setopt($curl, CURLOPT_HEADER, 1);

                        // will only work with PHP >= 5.0
                        // NB: if we set an empty string, CURL will add http header indicating
                        // ALL methods it is supporting. This is possibly a better option than
                        // letting the user tell what curl can / cannot do...
                        if(is_array(this->accepted_compression))
                        {
                                //curl_setopt($curl,\; CURLOPT\_ENCODING,\; implode(\text{'},\text{'},$this->accepted_compression));
                                // empty string means 'any supported by CURL' (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
                                if (count($this->accepted\_compression)\; ==\; 1)\; \{\; curl\_setopt($curl, CURLOPT_ENCODING, $this->accepted\_compression[0]);\; \}\; else\; curl\_setopt($curl, CURLOPT_ENCODING, '');
                        }
                        // extra headers
                        $headers\; =\; array(\text{'}Content-Type:\; \text{'}\; .$msg->content_type , 'Accept-Charset: ' . implode(',', $this->accepted\_charset\_encodings));\; //\; if\; no\; keepalive\; is\; wanted,\; let\; the\; server\; know\; it\; in\; advance\; if(!$keepalive)
                        {
                                $headers[]\; =\; \text{'}Connection:\; close\text{'};\; \}\; //\; request\; compression\; header\; if($encoding_hdr)
                        {
                                $headers[]\; =$encoding_hdr;
                        }

                        curl_setopt($curl,\; CURLOPT\_HTTPHEADER,$headers);
                        // timeout is borked
                        if($timeout)\; \{\; curl\_setopt($curl, CURLOPT_TIMEOUT, $timeout\; ==\; 1\; ?\; 1\; :$timeout - 1);
                        }

                        if(password)
                        {
                                curl_setopt($curl,\; CURLOPT\_USERPWD,$username.':'.$password);\; if\; (defined(\text{'}CURLOPT\_HTTPAUTH\text{'}))\; \{\; curl\_setopt($curl, CURLOPT_HTTPAUTH, $authtype);\; \}\; else\; if\; ($authtype != 1)
                                {
                                        error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth is supported by the current PHP/curl install');
                                }
                        }

                        if($method\; ==\; \text{'}https\text{'})\; \{\; //\; set\; cert\; file\; if($cert)
                                {
                                        curl_setopt($curl,\; CURLOPT\_SSLCERT,$cert);
                                }
                                // set cert password
                                if($certpass)\; \{\; curl\_setopt($curl, CURLOPT_SSLCERTPASSWD, $certpass);\; \}\; //\; whether\; to\; verify\; remote\; host\text{'}s\; cert\; curl\_setopt($curl, CURLOPT_SSL_VERIFYPEER, $this->verifypeer);\; //\; set\; ca\; certificates\; file/dir\; if($cacert)
                                {
                                        curl_setopt($curl,\; CURLOPT\_CAINFO,$cacert);
                                }
                                if($cacertdir)\; \{\; curl\_setopt($curl, CURLOPT_CAPATH, $cacertdir);\; \}\; //\; set\; key\; file\; (shall\; we\; catch\; errors\; in\; case\; CURLOPT\_SSLKEY\; undefined\; ?)\; if($key)
                                {
                                        curl_setopt($curl,\; CURLOPT\_SSLKEY,$key);
                                }
                                // set key password (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
                                if($keypass)\; \{\; curl\_setopt($curl, CURLOPT_SSLKEYPASSWD, $keypass);\; \}\; //\; whether\; to\; verify\; cert\text{'}s\; common\; name\; (CN);\; 0\; for\; no,\; 1\; to\; verify\; that\; it\; exists,\; and\; 2\; to\; verify\; that\; it\; matches\; the\; hostname\; used\; curl\_setopt($curl, CURLOPT_SSL_VERIFYHOST, $this->verifyhost);\; \}\; //\; proxy\; info\; if($proxyhost)
                        {
                                if($proxyport\; ==\; 0)\; \{$proxyport = 8080; // NB: even for HTTPS, local connection is on port 8080
                                }
                                curl_setopt($curl,\; CURLOPT\_PROXY,$proxyhost.':'.$proxyport);\; //curl\_setopt($curl, CURLOPT_PROXYPORT,$proxyport);\; if($proxyusername)
                                {
                                        curl_setopt($curl,\; CURLOPT\_PROXYUSERPWD,$proxyusername.':'.$proxypassword);\; if\; (defined(\text{'}CURLOPT\_PROXYAUTH\text{'}))\; \{\; curl\_setopt($curl, CURLOPT_PROXYAUTH, $proxyauthtype);\; \}\; else\; if\; ($proxyauthtype != 1)
                                        {
                                                error_log('XML-RPC: xmlrpc_client::send: warning. Only Basic auth to proxy is supported by the current PHP/curl install');
                                        }
                                }
                        }

                        // NB: should we build cookie http headers by hand rather than let CURL do it?
                        // the following code does not honour 'expires', 'path' and 'domain' cookie attributes
                        // set to clint obj the the user...
                        if (count($this->cookies))\; \{$cookieheader = '';
                                foreach ($this->cookies\; as$name => $cookie)\; \{$cookieheader .= $name\; .\; \text{'}=\text{'}\; .$cookie['value'] . ', ';
                                }
                                curl_setopt($curl,\; CURLOPT\_COOKIE,\; substr($cookieheader, 0, -2));
                        }

                        $result\; =\; curl\_exec($curl);

                        if(!$result)\; \{$this->errstr='no response';
                                GLOBALS['xmlrpcerr']['curl_fail'], $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}curl\_fail\text{'}].\; \text{'}:\; \text{'}.\; curl\_error($curl));
                                if(!$keepalive)\; \{\; curl\_close($curl);
                                }
                        }
                        else
                        {
                                if(!$keepalive)\; \{\; curl\_close($curl);
                                }
                                msg->parseResponse($result,\; true,$this->return_type);
                        }
                        return $resp;\; \}$

Send an array of request messages and return an array of responses. Unless this->no_multicall has been set to true, it will try first to use one single xmlrpc call to server method system.multicall, and revert to sending many successive calls in case of failure. This failure is also stored in $this->no\_multicall\; for\; subsequent\; calls.\; Unfortunately,\; there\; is\; no\; server\; error\; code\; universally\; used\; to\; denote\; the\; fact\; that\; multicall\; is\; unsupported,\; so\; there\; is\; no\; way\; to\; reliably\; distinguish\; between\; that\; and\; a\; temporary\; failure.\; If\; you\; are\; sure\; that\; server\; supports\; multicall\; and\; do\; not\; want\; to\; fallback\; to\; using\; many\; single\; calls,\; set\; the\; fourth\; parameter\; to\; FALSE.\; NB:\; trying\; to\; shoehorn\; extra\; functionality\; into\; existing\; syntax\; has\; resulted\; in\; pretty\; much\; convoluted\; code...$
parameter: array msgs an array of xmlrpcmsg objects
parameter: integer $timeout\; connection\; timeout\; (in\; seconds)$
parameter: string method the http protocol variant to be used
parameter: boolen fallback When true, upon receiveing an error during multicall, multiple single calls will be attempted
returns: array @access public

                function multicall($msgs,$timeout=0, $method=\text{'}http\text{'},$fallback=true)
                {
                        if(!$this->no\_multicall)\; \{$results = $this->\_try\_multicall($msgs, $timeout,$method);
                                if(is_array($results))\; \{\; //\; System.multicall\; succeeded\; return$results;
                                }
                                else
                                {
                                        // either system.multicall is unsupported by server,
                                        // or call failed for some other reason.
                                        if ($fallback)\; \{\; //\; Don\text{'}t\; try\; it\; next\; time...$this->no_multicall = true;
                                        }
                                        else
                                        {
                                                if (is_a($results,\; \text{'}xmlrpcresp\text{'}))\; \{$result = $results;\; \}\; else\; \{$result =& new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}multicall\_error\text{'}],$GLOBALS['xmlrpcstr']['multicall_error']);
                                                }
                                        }
                                }
                        }
                        else
                        {
                                // override fallback, in case careless user tries to do two
                                // opposite things at the same time
                                $fallback\; =\; true;\; \}$results = array();
                        if ($fallback)\; \{\; //\; system.multicall\; is\; (probably)\; unsupported\; by\; server:\; //\; emulate\; multicall\; via\; multiple\; requests\; foreach($msgs as $msg)\; \{$results[] =& $this->send($msg, $timeout,$method);
                                }
                        }
                        else
                        {
                                // user does NOT want to fallback on many single calls:
                                // since we should always return an array of responses,
                                // return an array with the same error repeated n times
                                foreach($msgs\; as$msg)
                                {
                                        $results[]\; =$result;
                                }
                        }
                        return $results;\; \}$

Attempt to boxcar msgs via system.multicall. Returns either an array of xmlrpcreponses, an xmlrpc error response or false (when recived response does not respect valid multiccall syntax) @access private

                function _try_multicall($msgs,$timeout, $method)\; \{\; //\; Construct\; multicall\; message$calls = array();
                        foreach($msgs\; as$msg)
                        {
                                msg->method(),'string');
                                $numParams\; =$msg->getNumParams();
                                $params\; =\; array();\; for($i = 0; numParams; $i++)\; \{$params[$i]\; =$msg->getParam($i);\; \}$call['params'] =& new xmlrpcval($params,\; \text{'}array\text{'});$calls[] =& new xmlrpcval($call,\; \text{'}struct\text{'});\; \}$multicall =& new xmlrpcmsg('system.multicall');
                        $multicall->addParam(new\; xmlrpcval($calls, 'array'));

                        // Attempt RPC call
                        this->send($multicall,$timeout, $method);\; if($result->faultCode() != 0)
                        {
                                // call to system.multicall failed
                                return $result;\; \}\; //\; Unpack\; responses.$rets = $result->value();\; if\; ($this->return_type == 'xml')
                        {
                                        return $rets;\; \}\; else\; if\; ($this->return_type == 'phpvals')
                        {

@todo test this code branch... $rets\; =$result->value(); if(!is_array($rets))\; \{\; return\; false;$// bad return type from system.multicall } numRets = count($rets);\; if($numRets != count($msgs))\; \{\; return\; false;$// wrong number of return values. }

                                response = array();
                                for($i\; =\; 0;$i < $numRets;$i++)
                                {
                                        $val\; =$rets[$i];\; if\; (!is\_array($val)) {
                                                return false;
                                        }
                                        switch(count($val))\; \{\; case\; 1:\; if(!isset($val[0]))
                                                        {
                                                                return false;                // Bad value
                                                        }
                                                        // Normal return value
                                                        $response[$i] =& new xmlrpcresp($val[0],\; 0,\; \text{'}\text{'},\; \text{'}phpvals\text{'});\; break;\; case\; 2:$

@todo remove usage of @: it is apparently quite slow code = @$val[\text{'}faultCode\text{'}];\; if(!is\_int($code)) { return false; } $str\; =\; @$val['faultString']; if(!is_string($str))\; \{\; return\; false;\; \}$response[code, $str);\; break;\; default:\; return\; false;\; \}\; \}\; return$response; } else // return type == 'xmlrpcvals' { $rets\; =$result->value(); if($rets->kindOf()\; !=\; \text{'}array\text{'})\; \{\; return\; false;$// bad return type from system.multicall } numRets = $rets->arraysize();\; if($numRets != count($msgs))\; \{\; return\; false;$// wrong number of return values. }

                                response = array();
                                for($i\; =\; 0;$i < $numRets;$i++)
                                {
                                        $val\; =$rets->arraymem($i);\; switch($val->kindOf())
                                        {
                                                case 'array':
                                                        if($val->arraysize()\; !=\; 1)\; \{\; return\; false;\; //\; Bad\; value\; \}\; //Normalreturn\; value$response[val->arraymem(0));
                                                        break;
                                                case 'struct':
                                                        $code\; =$val->structmem('faultCode');
                                                        if($code->kindOf()\; !=\; \text{'}scalar\text{'}\; ||$code->scalartyp() != 'int')
                                                        {
                                                                return false;
                                                        }
                                                        $str\; =$val->structmem('faultString');
                                                        if($str->kindOf()\; !=\; \text{'}scalar\text{'}\; ||$str->scalartyp() != 'string')
                                                        {
                                                                return false;
                                                        }
                                                        $response[$i] =& new xmlrpcresp(0, $code->scalarval(),$str->scalarval());
                                                        break;
                                                default:
                                                        return false;
                                        }
                                }
                                return $response;\; \}\; \}\; \}\; //\; end\; class\; xmlrpc\_client\; class\; xmlrpcresp\; \{\; var$val = 0;
                var $valtyp;\; var$errno = 0;
                var $errstr\; =\; \text{'}\text{'};\; var$payload;
                var $hdrs\; =\; array();\; var$_cookies = array();
                var $content\_type\; =\; \text{'}text/xml\text{'};\; var$raw_data = '';

                

parameter: mixed $val\; either\; an\; xmlrpcval\; obj,\; a\; php\; value\; or\; the\; xml\; serialization\; of\; an\; xmlrpcval\; (a\; string)$
parameter: integer fcode set it to anything but 0 to create an error response
parameter: string $fstr\; the\; error\; string,\; in\; case\; of\; an\; error\; response$
parameter: string valtyp either 'xmlrpcvals', 'phpvals' or 'xml' @todo add check that $val\; /$fcode / $fstr\; is\; of\; correct\; type???\; NB:\; as\; of\; now\; we\; do\; not\; do\; it,\; since\; it\; might\; be\; either\; an\; xmlrpcval\; or\; a\; plain\; php\; val,\; or\; a\; complete\; xml\; chunk,\; depending\; on\; usage\; of\; xmlrpc\_client::send()\; inside\; which\; creator\; is\; called...$

                function xmlrpcresp(val, $fcode\; =\; 0,$fstr = '', $valtyp=\text{'}\text{'})\; \{\; if($fcode != 0)
                        {
                                // error response
                                $this->errno\; =$fcode;
                                $this->errstr\; =$fstr;
                                //$this->errstr\; =\; htmlspecialchars($fstr); // XXX: encoding probably shouldn't be done here; fix later.
                        }
                        else
                        {
                                // successful response
                                $this->val\; =$val;
                                if ($valtyp\; ==\; \text{'}\text{'})\; \{\; //\; user\; did\; not\; declare\; type\; of\; response\; value:\; try\; to\; guess\; it\; if\; (is\_object($this->val) && is_a($this->val,\; \text{'}xmlrpcval\text{'}))\; \{$this->valtyp = 'xmlrpcvals';
                                        }
                                        else if (is_string($this->val))\; \{$this->valtyp = 'xml';

                                        }
                                        else
                                        {
                                                $this->valtyp\; =\; \text{'}phpvals\text{'};\; \}\; \}\; else\; \{\; //\; user\; declares\; type\; of\; resp\; value:\; believe\; him$this->valtyp = $valtyp;\; \}\; \}\; \}$

Returns the error code of the response.
returns: integer the error code of this response (0 for not-error responses) @access public

                function faultCode()
                {
                        return this->errno;
                }

                

Returns the error code of the response.
returns: string the error string of this response ('' for not-error responses) @access public

                function faultString()
                {
                        return $this->errstr;\; \}$

Returns the value received by the server.
returns: mixed the xmlrpcval object returned by the server. Might be an xml string or php value if the response has been created by specially configured xmlrpc_client objects @access public

                function value()
                {
                        return this->val;
                }

                

Returns an array with the cookies received from the server. Array has the form: $cookiename\; =>\; array\; (\text{'}value\text{'}\; =>$val, $attr1\; =>$val1, $attr2\; =$val2, ...) with attributes being e.g. 'expires', 'path', domain'. NB: cookies sent as 'expired' by the server (i.e. with an expiry date in the past) are still present in the array. It is up to the user-defined code to decide how to use the received cookies, and wheter they have to be sent back with the next request to the server (using xmlrpc_client::setCookie) or not
returns: array array of cookies received from the server @access public

                function cookies()
                {
                        return $this->\_cookies;\; \}$

Returns xml representation of the response. XML prologue not included
parameter: string charset_encoding the charset to be used for serialization. if null, US-ASCII is assumed
returns: string the xml representation of the response @access public

                function serialize($charset\_encoding=\text{'}\text{'})\; \{\; if\; ($charset_encoding != '')
                                $this->content\_type\; =\; \text{'}text/xml;\; charset=\text{'}\; .$charset_encoding;
                        else
                                $this->content\_type\; =\; \text{'}text/xml\text{'};$result = "<methodResponse>\n";
                        if($this->errno)\; \{\; //\; G.\; Giunta\; 2005/2/13:\; let\; non-ASCII\; response\; messages\; be\; tolerated\; by\; clients\; //\; by\; xml-encoding\; non\; ascii\; chars$result .= "<fault>\n" .
"<value>\n<struct><member><name>faultCode</name>\n<value><int>" . $this->errno\; .\; "$</int></value>\n</member>\n<member>\n<name>faultString</name>\n<value><string>" .
xmlrpc_encode_entitites(this->errstr, $GLOBALS[\text{'}xmlrpc\_internalencoding\text{'}],$charset_encoding) . "</string></value>\n</member>\n" .
"</struct>\n</value>\n</fault>";
                        }
                        else
                        {
                                if(!is_object($this->val)\; ||\; !is\_a($this->val, 'xmlrpcval'))
                                {
                                        if (is_string(this->valtyp == 'xml')
                                        {
                                                $result\; .=\; "$<params>\n<param>\n" .
                                                        this->val .
                                                        "</param>\n</params>";
                                        }
                                        else
                                        {

@todo try to build something serializable? die('cannot serialize xmlrpcresp objects whose content is native php values'); } } else { $result\; .=\; "$<params>\n<param>\n" . this->val->serialize($charset\_encoding)\; .\; "$</param>\n</params>"; } } result .= "\n</methodResponse>"; $this->payload\; =$result; return $result;\; \}\; \}$

	class xmlrpcmsg
        {
                var payload;
                var $methodname;\; var$params=array();
                var $debug=0;\; var$content_type = 'text/xml';

                

parameter: string $meth\; the\; name\; of\; the\; method\; to\; invoke$
parameter: array pars array of parameters to be paased to the method (xmlrpcval objects)

                function xmlrpcmsg($meth,$pars=0)
                {
                        $this->methodname=$meth;
                        if(is_array(pars)>0)
                        {
                                for($i=0;$i<count($pars);$i++)
                                {
                                        $this->addParam($pars[$i]);\; \}\; \}\; \}$

@access private

                function xml_header(charset_encoding='')
                {
                        if ($charset\_encoding\; !=\; \text{'}\text{'})\; \{\; return\; "$<?xml version=\"1.0\" encoding=\"charset_encoding\" ?" . ">\n<methodCall>\n";
                        }
                        else
                        {
                                return "<?xml version=\"1.0\"?" . ">\n<methodCall>\n";
                        }
                }

                

@access private

                function xml_footer()
                {
                        return '</methodCall>';
                }

                

@access private

                function kindOf()
                {
                        return 'msg';
                }

                

@access private

                function createPayload($charset\_encoding=\text{'}\text{'})\; \{\; if\; ($charset_encoding != '')
                                $this->content\_type\; =\; \text{'}text/xml;\; charset=\text{'}\; .$charset_encoding;
                        else
                                $this->content\_type\; =\; \text{'}text/xml\text{'};$this->payload=$this->xml\_header($charset_encoding);
                        $this->payload.=\text{'}$<methodName>' . this->methodname . "</methodName>\n";
                        $this->payload.="$<params>\n";
                        for(i=0; $i$<count(this->params); $i++)\; \{$p=$this->params[$i];
                                $this->payload.="$<param>\n" . p->serialize($charset\_encoding)\; .\; "$</param>\n";
                        }
                        this->payload.="</params>\n";
                        $this->payload.=$this->xml_footer();
                }

                

Gets/sets the xmlrpc method to be invoked
parameter: string $meth\; the\; method\; to\; be\; set\; (leave\; empty\; not\; to\; set\; it)$
returns: string the method that will be invoked @access public

                function method(meth='')
                {
                        if($meth!=\text{'}\text{'})\; \{$this->methodname=$meth;\; \}\; return$this->methodname;
                }

                

Returns xml representation of the message. XML prologue included
returns: string the xml representation of the message, xml prologue included @access public

                function serialize($charset\_encoding=\text{'}\text{'})\; \{$this->createPayload($charset\_encoding);\; return$this->payload;
                }

                

Add a parameter to the list of parameters to be used upon method invocation
parameter: xmlrpcval $par$
returns: boolean false on failure @access public

                function addParam(par)
                {
                        // add check: do not add to self params which are not xmlrpcvals
                        if(is_object(par, 'xmlrpcval'))
                        {
                                $this->params[]=$par;
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                

Returns the nth parameter in the message. The index zero-based.
parameter: integer $i\; the\; index\; of\; the\; parameter\; to\; fetch\; (zero\; based)$
returns: xmlrpcval the i-th parameter @access public

                function getParam(i) { return $this->params[$i]; }

                

Returns the number of parameters in the messge.
returns: integer the number of parameters currently set @access public

                function getNumParams() { return count($this->params);\; \}$

Given an open file handle, read all data available and parse it as axmlrpc response. NB: the file handle is not closed by this function. @access public
returns: xmlrpcresp @todo add 2nd & 3rd param to be passed to ParseResponse() ???

                function &parseResponseFile(fp)
                {
                        $ipd=\text{'}\text{'};\; while($data=fread($fp,\; 32768))\; \{$ipd.=$data;\; \}\; //fclose($fp);
                        this->parseResponse($ipd);\; return$r;
                }

                

Parses HTTP headers and separates them from data. @access private

                function &parseResponseHeaders(&$data,$headers_processed=false)
                {
                                // Strip HTTP 1.1 100 Continue header if present
                                while(preg_match('/^HTTP\/1\.1 1[0-9]{2} /', $data))\; \{$pos = strpos($data,\; \text{'}HTTP\text{'},\; 12);\; //\; server\; sent\; a\; Continue\; header\; without\; any\; (valid)\; content\; following...\; //\; give\; the\; client\; a\; chance\; to\; know\; it\; if(!$pos && !is_int($pos))\; //\; works\; fine\; in\; php\; 3,\; 4\; and\; 5\; \{\; break;\; \}$data = substr($data,$pos);
                                }
                                if(!preg_match('/^HTTP\/[0-9.]+ 200 /', $data))\; \{$errstr= substr($data,\; 0,\; strpos($data, "\n")-1);
                                        error_log('XML-RPC: xmlrpcmsg::parseResponse: HTTP error, got response: ' .$errstr);$r=&new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}http\_error\text{'}],$GLOBALS['xmlrpcstr']['http_error']. ' (' . $errstr\; .\; \text{'})\text{'});\; return$r;
                                }

                                $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}]\; =\; array();$GLOBALS['_xh']['cookies'] = array();

                                // be tolerant to usage of \n instead of \r\n to separate headers and data
                                // (even though it is not valid http)
                                $pos\; =\; strpos($data,"\r\n\r\n");
                                if($pos\; ||\; is\_int($pos))
                                {
                                        $bd\; =$pos+4;
                                }
                                else
                                {
                                        $pos\; =\; strpos($data,"\n\n");
                                        if($pos\; ||\; is\_int($pos))
                                        {
                                                $bd\; =$pos+2;
                                        }
                                        else
                                        {
                                                // No separation between response headers and body: fault?
                                                $bd\; =\; 0;\; \}\; \}\; //\; be\; tolerant\; to\; line\; endings,\; and\; extra\; empty\; lines$ar = split("\r?\n", trim(substr($data,\; 0,$pos)));
                                while(list(,$line)\; =\; @each($ar))
                                {
                                        // take care of multi-line headers and cookies
                                        $arr\; =\; explode(\text{'}:\text{'},$line,2);
                                        if(count($arr)\; >\; 1)\; \{$header_name = strtolower(trim($arr[0]));$

@todo some other headers (the ones that allow a CSV list of values) do allow many values to be passed using multiple header lines. We should add content to GLOBALS['_xh']['headers'][$header\_name]\; instead\; of\; replacing\; it\; for\; those...\; if\; ($header_name == 'set-cookie' || $header\_name\; ==\; \text{'}set-cookie2\text{'})\; \{\; if\; ($header_name == 'set-cookie2') { // version 2 cookies: // there could be many cookies on one line, comma separated $cookies\; =\; explode(\text{'},\text{'},$arr[1]); } else { $cookies\; =\; array($arr[1]); } foreach ($cookies\; as$cookie) { // glue together all received cookies, using a comma to separate them // (same as php does with getallheaders()) if (isset($GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}][$header_name])) $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}][$header_name] .= ', ' . trim($cookie);\; else$GLOBALS['_xh']['headers'][$header\_name]\; =\; trim($cookie); // parse cookie attributes, in case user wants to coorectly honour then // feature creep: only allow rfc-compliant cookie attributes? $cookie\; =\; explode(\text{'};\text{'},$cookie); foreach ($cookie\; as$pos => $val)\; \{$val = explode('=', $val,\; 2);$tag = trim($val[0]);$val = trim(@$val[1]);\; @todo\; with\; version\; 1\; cookies,\; we\; should\; strip\; leading\; and\; trailing\; "\; chars\; if\; ($pos == 0) { $cookiename\; =$tag; $GLOBALS[\text{'}\_xh\text{'}][\text{'}cookies\text{'}][$tag] = array(); $GLOBALS[\text{'}\_xh\text{'}][\text{'}cookies\text{'}][$cookiename]['value'] = urldecode($val);\; \}\; else\; \{$GLOBALS['_xh']['cookies'][$cookiename][$tag] = $val;\; \}\; \}\; \}\; \}\; else\; \{$GLOBALS['_xh']['headers'][$header\_name]\; =\; trim($arr[1]); } } elseif(isset($header\_name))\; \{\; @todo\; version1\; cookies\; might\; span\; multiple\; lines,\; thus\; breaking\; the\; parsing\; above$GLOBALS['_xh']['headers'][$header\_name]\; .=\; \text{'}\; \text{'}\; .\; trim($line); } }

                                $data\; =\; substr($data, $bd);\; if($this->debug && count(GLOBALS['_xh']['headers'] as $header\; =>$value)
                                        {
                                                print "HEADER: $header:$value\n";
                                        }
                                        foreach($GLOBALS[\text{'}\_xh\text{'}][\text{'}cookies\text{'}]\; as$header => $value)\; \{\; print\; "COOKIE:$header={headers_processed)
                                {
                                        // Decode chunked encoding sent by http 1.1 servers
                                        if(isset(GLOBALS['_xh']['headers']['transfer-encoding'] == 'chunked')
                                        {
                                                if(!$data\; =\; decode\_chunked($data))
                                                {
                                                        error_log('XML-RPC: xmlrpcmsg::parseResponse: errors occurred when trying to rebuild the chunked data received from server');
                                                        GLOBALS['xmlrpcerr']['dechunk_fail'], $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}dechunk\_fail\text{'}]);\; return$r;
                                                }
                                        }

                                        // Decode gzip-compressed stuff
                                        // code shamelessly inspired from nusoap library by Dietrich Ayala
                                        if(isset($GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}][\text{'}content-encoding\text{'}]))\; \{$GLOBALS['_xh']['headers']['content-encoding'] = str_replace('x-', '', $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}][\text{'}content-encoding\text{'}]);\; if($GLOBALS['_xh']['headers']['content-encoding'] == 'deflate' || $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}][\text{'}content-encoding\text{'}]\; ==\; \text{'}gzip\text{'})\; \{\; //\; if\; decoding\; works,\; use\; it.\; else\; assume\; data\; wasn\text{'}t\; gzencoded\; if(function\_exists(\text{'}gzinflate\text{'}))\; \{\; if($GLOBALS['_xh']['headers']['content-encoding'] == 'deflate' && $degzdata\; =\; @gzuncompress($data))
                                                                {
                                                                        $data\; =$degzdata;
                                                                        if(data)." chars]---\n" . htmlentities(GLOBALS['_xh']['headers']['content-encoding'] == 'gzip' && $degzdata\; =\; @gzinflate(substr($data, 10)))
                                                                {
                                                                        $data\; =$degzdata;
                                                                        if(data)." chars]---\n" . htmlentities(r =& new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}decompress\_fail\text{'}],$GLOBALS['xmlrpcstr']['decompress_fail']);
                                                                        return $r;\; \}\; \}\; else\; \{\; error\_log(\text{'}XML-RPC:\; xmlrpcmsg::parseResponse:\; the\; server\; sent\; deflated\; data.\; Your\; php\; install\; must\; have\; the\; Zlib\; extension\; compiled\; in\; to\; support\; this.\text{'});$r =& new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}cannot\_decompress\text{'}],$GLOBALS['xmlrpcstr']['cannot_decompress']);
                                                                return $r;\; \}\; \}\; \}\; \}\; //\; end\; of\; \text{'}if\; needed,\; de-chunk,\; re-inflate\; response\text{'}\; //\; real\; stupid\; hack\; to\; avoid\; PHP\; 4\; complaining\; about\; returning\; NULL\; by\; ref$r = null;
                                r;
                                return $r;\; \}$

Parse the xmlrpc response containeed in the string data and return an xmlrpcresp object.
parameter: string $data\; the\; xmlrpc\; response,\; eventually\; including\; http\; headers$
parameter: bool headers_processed when true prevents parsing HTTP headers for interpretation of content-encoding and consequent decoding
parameter: string $return\_type\; decides\; return\; type,\; i.e.\; content\; of\; response->value().\; Either\; \text{'}xmlrpcvals\text{'},\; \text{'}xml\text{'}\; or\; \text{'}phpvals\text{'}$
returns: xmlrpcresp @access public

                function &parseResponse(data='', $headers\_processed=false,$return_type='xmlrpcvals')
                {
                        if(data) . "\n---END---\n</PRE>";
                                $start\; =\; strpos($data, '<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
                                if ($start)\; \{$start += strlen('<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
                                        $end\; =\; strpos($data, '-->', $start);$comments = substr($data,$start, end-start);
                                        print "<PRE>---SERVER DEBUG INFO (DECODED) ---\n\t".htmlentities(str_replace("\n", "\n\t", base64_decode(data == '')
                        {
                                error_log('XML-RPC: xmlrpcmsg::parseResponse: no response received from server.');
                                GLOBALS['xmlrpcerr']['no_data'], $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}no\_data\text{'}]);\; return$r;
                        }

                        $GLOBALS[\text{'}\_xh\text{'}]=array();$raw_data = $data;\; //\; parse\; the\; HTTP\; headers\; of\; the\; response,\; if\; present,\; and\; separate\; them\; from\; data\; if(substr($data, 0, 4) == 'HTTP')
                        {
                                this->parseResponseHeaders($data,$headers_processed);
                                if ($r)\; \{\; //\; failed\; processing\; of\; HTTP\; response\; headers\; //\; save\; into\; response\; obj\; the\; full\; payload\; received,\; for\; debugging$r->raw_data = $data;\; return$r;
                                }
                        }
                        else
                        {
                                $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}]\; =\; array();$GLOBALS['_xh']['cookies'] = array();
                        }

                        // be tolerant of extra whitespace in response body
                        $data\; =\; trim($data);

@todo return an error msg if $data==\text{'}\text{'}\; ?$

                        // be tolerant of junk after methodResponse (e.g. javascript ads automatically inserted by free hosts)
                        // idea from Luca Mariano <luca.mariano@email.it> originally in PEARified version of the lib
                        bd = false;
                        // Poor man's version of strrpos for php 4...
                        $pos\; =\; strpos($data, '</methodResponse>');
                        while($pos\; ||\; is\_int($pos))
                        {
                                $bd\; =$pos+17;
                                $pos\; =\; strpos($data, '</methodResponse>', $bd);\; \}\; if($bd)
                        {
                                $data\; =\; substr($data, 0, $bd);\; \}\; //\; if\; user\; wants\; back\; raw\; xml,\; give\; it\; to\; him\; if\; ($return_type == 'xml')
                        {
                                data, 0, '', 'xml');
                                $r->hdrs\; =$GLOBALS['_xh']['headers'];
                                $r->\_cookies\; =$GLOBALS['_xh']['cookies'];
                                $r->raw\_data\; =$raw_data;
                                return $r;\; \}\; //\; try\; to\; \text{'}guestimate\text{'}\; the\; character\; encoding\; of\; the\; received\; response$resp_encoding = guess_encoding(@$GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}][\text{'}content-type\text{'}],$data);

                        $GLOBALS[\text{'}\_xh\text{'}][\text{'}ac\text{'}]=\text{'}\text{'};\; //$GLOBALS['_xh']['qt']=''; //unused...
                        $GLOBALS[\text{'}\_xh\text{'}][\text{'}stack\text{'}]\; =\; array();$GLOBALS['_xh']['valuestack'] = array();
                        $GLOBALS[\text{'}\_xh\text{'}][\text{'}isf\text{'}]=0;\; //\; 0\; =\; OK,\; 1\; for\; xmlrpc\; fault\; responses,\; 2\; =\; invalid\; xmlrpc$GLOBALS['_xh']['isf_reason']='';
                        $GLOBALS[\text{'}\_xh\text{'}][\text{'}rt\text{'}]=\text{'}\text{'};\; //\; \text{'}methodcall\; or\; \text{'}methodresponse\text{'}\; //\; if\; response\; charset\; encoding\; is\; not\; known\; /\; supported,\; try\; to\; use\; //\; the\; default\; encoding\; and\; parse\; the\; xml\; anyway,\; but\; log\; a\; warning...\; if\; (!in\_array($resp_encoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
                        // the following code might be better for mb_string enabled installs, but
                        // makes the lib about 200% slower...
                        //if (!is_valid_charset($resp\_encoding,\; array(\text{'}UTF-8\text{'},\; \text{'}ISO-8859-1\text{'},\; \text{'}US-ASCII\text{'})))\; \{\; error\_log(\text{'}XML-RPC:\; xmlrpcmsg::parseResponse:\; invalid\; charset\; encoding\; of\; received\; response:\; \text{'}.$resp_encoding);
                                $resp\_encoding\; =$GLOBALS['xmlrpc_defencoding'];
                        }
                        $parser\; =\; xml\_parser\_create($resp_encoding);
                        xml_parser_set_option($parser,\; XML\_OPTION\_CASE\_FOLDING,\; true);\; //\; G.\; Giunta\; 2005/02/13:\; PHP\; internally\; uses\; ISO-8859-1,\; so\; we\; have\; to\; tell\; //\; the\; xml\; parser\; to\; give\; us\; back\; data\; in\; the\; expected\; charset\; xml\_parser\_set\_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS[\text{'}xmlrpc\_internalencoding\text{'}]);\; if\; ($return_type == 'phpvals')
                        {
                                xml_set_element_handler($parser,\; \text{'}xmlrpc\_se\text{'},\; \text{'}xmlrpc\_ee\_fast\text{'});\; \}\; else\; \{\; xml\_set\_element\_handler($parser, 'xmlrpc_se', 'xmlrpc_ee');
                        }

                        xml_set_character_data_handler($parser,\; \text{'}xmlrpc\_cd\text{'});\; xml\_set\_default\_handler($parser, 'xmlrpc_dh');

                        // first error check: xml not well formed
                        if(!xml_parse($parser,$data, count($data)))\; \{\; //\; thanks\; to\; Peter\; Kocks$<peter.kocks@baygate.com>
                                if((xml_get_current_line_number(parser)) == 1)
                                {
                                        $errstr\; =\; \text{'}XML\; error\; at\; line\; 1,\; check\; URL\text{'};\; \}\; else\; \{$errstr = sprintf('XML error: %s at line %d, column %d',
                                                xml_error_string(xml_get_error_code($parser)),\; xml\_get\_current\_line\_number($parser), xml_get_current_column_number($parser));\; \}\; error\_log($errstr);
                                GLOBALS['xmlrpcerr']['invalid_return'], $GLOBALS[\text{'}xmlrpcstr\text{'}][\text{'}invalid\_return\text{'}].\text{'}\; (\text{'}.$errstr.')');
                                xml_parser_free($parser);\; if($this->debug)
                                {
                                        print $errstr;\; \}$r->hdrs = $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}];$r->_cookies = $GLOBALS[\text{'}\_xh\text{'}][\text{'}cookies\text{'}];$r->raw_data = $raw\_data;\; return$r;
                        }
                        xml_parser_free($parser);\; //\; second\; error\; check:\; xml\; well\; formed\; but\; not\; xml-rpc\; compliant\; if\; ($GLOBALS['_xh']['isf'] > 1)
                        {
                                if ($this->debug)\; \{$

@todo echo something for user? }

                                r =& new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}invalid\_return\text{'}],$GLOBALS['xmlrpcstr']['invalid_return'] . ' ' . $GLOBALS[\text{'}\_xh\text{'}][\text{'}isf\_reason\text{'}]);\; \}\; //\; third\; error\; check:\; parsing\; of\; the\; response\; has\; somehow\; gone\; boink.\; //\; NB:\; shall\; we\; omit\; this\; check,\; since\; we\; trust\; the\; parsing\; code?\; elseif\; ($return_type == 'xmlrpcvals' && !is_object($GLOBALS[\text{'}\_xh\text{'}][\text{'}value\text{'}]))\; \{\; //\; something\; odd\; has\; happened\; //\; and\; it\text{'}s\; time\; to\; generate\; a\; client\; side\; error\; //\; indicating\; something\; odd\; went\; on$r=&new xmlrpcresp(0, $GLOBALS[\text{'}xmlrpcerr\text{'}][\text{'}invalid\_return\text{'}],$GLOBALS['xmlrpcstr']['invalid_return']);
                        }
                        else
                        {
                                if (GLOBALS['_xh']['value']);
                                        print "\n---END---</PRE>";
                                }

                                // note that using =& will raise an error if $GLOBALS[\text{'}\_xh\text{'}][\text{'}st\text{'}]\; does\; not\; generate\; an\; object.$v =& $GLOBALS[\text{'}\_xh\text{'}][\text{'}value\text{'}];\; if($GLOBALS['_xh']['isf'])
                                {

@todo we should test here if server sent an int and a string, and/or coerce them into such... if ($return\_type\; ==\; \text{'}xmlrpcvals\text{'})\; \{$errno_v = $v->structmem(\text{'}faultCode\text{'});$errstr_v = $v->structmem(\text{'}faultString\text{'});$errno = $errno\_v->scalarval();$errstr = $errstr\_v->scalarval();\; \}\; else\; \{$errno = $v[\text{'}faultCode\text{'}];$errstr = $v[\text{'}faultString\text{'}];\; \}$

                                        if(errno == 0)
                                        {
                                                // FAULT returned, errno needs to reflect that
                                                $errno\; =\; -1;\; \}$r =& new xmlrpcresp(0, $errno,$errstr);
                                }
                                else
                                {
                                        v, 0, '', $return\_type);\; \}\; \}$r->hdrs = $GLOBALS[\text{'}\_xh\text{'}][\text{'}headers\text{'}];$r->_cookies = $GLOBALS[\text{'}\_xh\text{'}][\text{'}cookies\text{'}];$r->raw_data = $raw\_data;\; return$r;
                }
        }

	class xmlrpcval
        {
                var $me=array();\; var$mytype=0;
                var $\_php\_class=null;$

parameter: mixed val
parameter: string $type\; any\; valid\; xmlrpc\; type\; name\; (lowercase).\; If\; null,\; \text{'}string\text{'}\; is\; assumed$

                function xmlrpcval(val=-1, $type=\text{'}\text{'})\; \{$

@todo: optimization creep - do not call addXX, do it all inline. downside: booleans will not be coerced anymore if(val!==-1 || $type!=\text{'}\text{'})\; \{$// optimization creep: inlined all work done by constructor switch(type) { case '': $this->mytype=1;$this->me['string']=$val;\; break;\; case\; \text{'}i4\text{'}:\; case\; \text{'}int\text{'}:\; case\; \text{'}double\text{'}:\; case\; \text{'}string\text{'}:\; case\; \text{'}boolean\text{'}:\; case\; \text{'}dateTime.iso8601\text{'}:\; case\; \text{'}base64\text{'}:\; case\; \text{'}null\text{'}:$this->mytype=1; $this->me[$type]=$val;\; break;\; case\; \text{'}array\text{'}:$this->mytype=2; $this->me[\text{'}array\text{'}]=$val; break; case 'struct': $this->mytype=3;$this->me['struct']=$val;\; break;\; default:\; error\_log("XML-RPC:\; xmlrpcval::xmlrpcval:\; not\; a\; known\; type\; ($type)"); } /*if($type==\text{'}\text{'})\; \{$type='string'; } if($GLOBALS[\text{'}xmlrpcTypes\text{'}][$type]==1) { $this->addScalar($val,$type);\; \}\; elseif($GLOBALS['xmlrpcTypes'][$type]==2)\; \{$this->addArray($val);\; \}\; elseif($GLOBALS['xmlrpcTypes'][$type]==3)\; \{$this->addStruct($val);\; \}$

                        }
                }

                

Add a single php value to an (unitialized) xmlrpcval
parameter: mixed val
parameter: string $type$
returns: int 1 or 0 on failure

                function addScalar(val, $type=\text{'}string\text{'})\; \{$typeof=@$GLOBALS[\text{'}xmlrpcTypes\text{'}][$type];
                        if($typeof!=1)\; \{\; error\_log("XML-RPC:\; xmlrpcval::addScalar:\; not\; a\; scalar\; type\; ($type)");
                                return 0;
                        }

                        // coerce booleans into correct values
                        // NB: we should iether do it for datetimes, integers and doubles, too,
                        // or just plain remove this check, implemnted on booleans only...
                        if($type==$GLOBALS['xmlrpcBoolean'])
                        {
                                if(strcasecmp($val,\text{'}true\text{'})==0\; ||$val==1 || (val,'false')))
                                {
                                        $val=true;\; \}\; else\; \{$val=false;
                                }
                        }

                        switch($this->mytype)\; \{\; case\; 1:\; error\_log(\text{'}XML-RPC:\; xmlrpcval::addScalar:\; scalar\; xmlrpcval\; can\; have\; only\; one\; value\text{'});\; return\; 0;\; case\; 3:\; error\_log(\text{'}XML-RPC:\; xmlrpcval::addScalar:\; cannot\; add\; anonymous\; scalar\; to\; struct\; xmlrpcval\text{'});\; return\; 0;\; case\; 2:\; //\; we\text{'}re\; adding\; a\; scalar\; value\; to\; an\; array\; here\; //$ar=$this->me[\text{'}array\text{'}];\; //$ar[]=&new xmlrpcval($val,$type);
                                        //$this->me[\text{'}array\text{'}]=$ar;
                                        // Faster (?) avoid all the costly array-copy-by-val done here...
                                        val, $type);\; return\; 1;\; default:\; //\; a\; scalar,\; so\; set\; the\; value\; and\; remember\; we\text{'}re\; scalar$this->me[$type]=$val;
                                        $this->mytype=$typeof;
                                        return 1;
                        }
                }

                

Add an array of xmlrpcval objects to an xmlrpcval
parameter: array $vals$
returns: int 1 or 0 on failure @access public @todo add some checking for vals to be an array of xmlrpcvals?

                function addArray($vals)\; \{\; if($this->mytype==0)
                        {
                                $this->mytype=$GLOBALS['xmlrpcTypes']['array'];
                                $this->me[\text{'}array\text{'}]=$vals;
                                return 1;
                        }
                        elseif($this->mytype==2)\; \{\; //\; we\text{'}re\; adding\; to\; an\; array\; here$this->me['array'] = array_merge($this->me[\text{'}array\text{'}],$vals);
                                return 1;
                        }
                        else
                        {
                                error_log('XML-RPC: xmlrpcval::addArray: already initialized as a [' . $this->kindOf()\; .\; \text{'}]\text{'});\; return\; 0;\; \}\; \}$

Add an array of named xmlrpcval objects to an xmlrpcval
parameter: array vals
returns: int 1 or 0 on failure @access public @todo add some checking for $vals\; to\; be\; an\; array?$

                function addStruct(vals)
                {
                        if($this->mytype==0)\; \{$this->mytype=$GLOBALS[\text{'}xmlrpcTypes\text{'}][\text{'}struct\text{'}];$this->me['struct']=$vals;\; return\; 1;\; \}\; elseif($this->mytype==3)
                        {
                                // we're adding to a struct here
                                $this->me[\text{'}struct\text{'}]\; =\; array\_merge($this->me['struct'], $vals);\; return\; 1;\; \}\; else\; \{\; error\_log(\text{'}XML-RPC:\; xmlrpcval::addStruct:\; already\; initialized\; as\; a\; [\text{'}\; .$this->kindOf() . ']');
                                return 0;
                        }
                }

                // poor man's version of print_r ???
                // DEPRECATED!
                function dump($ar)\; \{\; foreach($ar as $key\; =>$val)
                        {
                                echo "$key\; =>$val<br />";
                                if($key\; ==\; \text{'}array\text{'})\; \{\; while(list($key2, $val2)\; =\; each($val))
                                        {
                                                echo "-- $key2\; =>$val2<br />";
                                        }
                                }
                        }
                }

                

Returns a string containing "struct", "array" or "scalar" describing the base type of the value
returns: string @access public

                function kindOf()
                {
                        switch($this->mytype)\; \{\; case\; 3:\; return\; \text{'}struct\text{'};\; break;\; case\; 2:\; return\; \text{'}array\text{'};\; break;\; case\; 1:\; return\; \text{'}scalar\text{'};\; break;\; default:\; return\; \text{'}undef\text{'};\; \}\; \}$

@access private

                function serializedata(typ, $val,$charset_encoding='')
                {
                        $rs=\text{'}\text{'};\; switch(@$GLOBALS['xmlrpcTypes'][$typ])\; \{\; case\; 1:\; switch($typ)
                                        {
                                                case $GLOBALS[\text{'}xmlrpcBase64\text{'}]:$rs.="<$\{typ\}>"\; .\; base64\_encode($val) . "</$\{typ\}>";\; break;\; case$GLOBALS['xmlrpcBoolean']:
                                                        {typ}>" . ({typ}>";
                                                        break;
                                                case $GLOBALS[\text{'}xmlrpcString\text{'}]:\; //\; G.\; Giunta\; 2005/2/13:\; do\; NOT\; use\; htmlentities,\; since\; //\; it\; will\; produce\; named\; html\; entities,\; which\; are\; invalid\; xml$rs.="<$\{typ\}>"\; .\; xmlrpc\_encode\_entitites($val, $GLOBALS[\text{'}xmlrpc\_internalencoding\text{'}],$charset_encoding). "</$\{typ\}>";\; break;\; case$GLOBALS['xmlrpcInt']:
                                                case $GLOBALS[\text{'}xmlrpcI4\text{'}]:$rs.="<$\{typ\}>".(int)$val."</$\{typ\}>";\; break;\; case$GLOBALS['xmlrpcDouble']:
                                                        {typ}>".(double){typ}>";
                                                        break;
                                                case $GLOBALS[\text{'}xmlrpcNull\text{'}]:$rs.="<nil/>";
                                                        break;
                                                default:
                                                        // no standard type value should arrive here, but provide a possibility
                                                        // for xmlrpcvals of unknown type...
                                                        {typ}>{typ}>";
                                        }
                                        break;
                                case 3:
                                        // struct
                                        if ($this->\_php\_class)\; \{$rs.='<struct php_class="' . $this->\_php\_class\; .\; "\backslash ">\backslash n";\; \}\; else\; \{$rs.="<struct>\n";
                                        }
                                        foreach($val\; as$key2 => $val2)\; \{$rs.='<member><name>'.xmlrpc_encode_entitites($key2,$GLOBALS['xmlrpc_internalencoding'], $charset\_encoding)."$</name>\n";
                                                //rs.=$this->serializeval($val2);
                                                $rs.=$val2->serialize($charset\_encoding);$rs.="</member>\n";
                                        }
                                        $rs.=\text{'}$</struct>';
                                        break;
                                case 2:
                                        // array
                                        rs.="<array>\n<data>\n";
                                        for($i=0;$i<count($val);$i++)
                                        {
                                                //$rs.=$this->serializeval($val[$i]);
                                                $rs.=$val[$i]->serialize($charset_encoding);
                                        }
                                        $rs.="$</data>\n</array>";
                                        break;
                                default:
                                        break;
                        }
                        return rs;
                }

                

Returns xml representation of the value. XML prologue not included
parameter: string $charset\_encoding\; the\; charset\; to\; be\; used\; for\; serialization.\; if\; null,\; US-ASCII\; is\; assumed$
returns: string @access public

                function serialize(charset_encoding='')
                {
                        // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
                        //if (is_object(o) == 'xmlrpcval' || is_subclass_of($o,\; \text{'}xmlrpcval\text{'})))\; //\{\; reset($this->me);
                                list($typ,$val) = each($this->me);\; return\; \text{'}$<value>' . this->serializedata($typ,$val, $charset\_encoding)\; .\; "$</value>\n";
                        //}
                }

                // DEPRECATED
                function serializeval(o)
                {
                        // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
                        //if (is_object(o) == 'xmlrpcval' || is_subclass_of($o,\; \text{'}xmlrpcval\text{'})))\; //\{$ar=$o->me;\; reset($ar);
                                list($typ,$val) = each($ar);\; return\; \text{'}$<value>' . this->serializedata($typ,$val) . "</value>\n";
                        //}
                }

                

Checks wheter a struct member with a given name is present. Works only on xmlrpcvals of type struct.
parameter: string $m\; the\; name\; of\; the\; struct\; member\; to\; be\; looked\; up$
returns: boolean @access public

                function structmemexists(m)
                {
                        return array_key_exists($m,$this->me['struct']);
                }

                

Returns the value of a given struct member (an xmlrpcval object in itself). Will raise a php warning if struct member of given name does not exist
parameter: string $m\; the\; name\; of\; the\; struct\; member\; to\; be\; looked\; up$
returns: xmlrpcval @access public

                function structmem(m)
                {
                        return $this->me[\text{'}struct\text{'}][$m];
                }

                

Reset internal pointer for xmlrpcvals of type struct. @access public

                function structreset()
                {
                        reset($this->me[\text{'}struct\text{'}]);\; \}$

Return next member element for xmlrpcvals of type struct.
returns: xmlrpcval @access public

                function structeach()
                {
                        return each(this->me['struct']);
                }

                // DEPRECATED! this code looks like it is very fragile and has not been fixed
                // for a long long time. Shall we remove it for 2.0?
                function getval()
                {
                        // UNSTABLE
                        reset($this->me);\; list($a,$b)=each($this->me);
                        // contributed by I Sofer, 2001-03-24
                        // add support for nested arrays to scalarval
                        // i've created a new method here, so as to
                        // preserve back compatibility

                        if(is_array($b))\; \{\; @reset($b);
                                while(list($id,$cont) = @each($b))\; \{$b[$id]\; =$cont->scalarval();
                                }
                        }

                        // add support for structures directly encoding php objects
                        if(is_object($b))\; \{$t = get_object_vars($b);\; @reset($t);
                                while(list($id,$cont) = @each($t))\; \{$t[$id]\; =$cont->scalarval();
                                }
                                @reset($t);\; while(list($id,$cont)\; =\; @each($t))
                                {
                                        @$b->$id = $cont;\; \}\; \}\; //\; end\; contrib\; return$b;
                }

                

Returns the value of a scalar xmlrpcval
returns: mixed @access public

                function scalarval()
                {
                        reset($this->me);\; list(,$b)=each($this->me);\; return$b;
                }

                

Returns the type of the xmlrpcval. For integers, 'int' is always returned in place of 'i4'
returns: string @access public

                function scalartyp()
                {
                        reset($this->me);\; list($a,)=each($this->me);\; if($a==$GLOBALS[\text{'}xmlrpcI4\text{'}])\; \{$a=$GLOBALS[\text{'}xmlrpcInt\text{'}];\; \}\; return$a;
                }

                

Returns the m-th member of an xmlrpcval of struct type
parameter: integer $m\; the\; index\; of\; the\; value\; to\; be\; retrieved\; (zero\; based)$
returns: xmlrpcval @access public

                function arraymem(m)
                {
                        return $this->me[\text{'}array\text{'}][$m];
                }

                

Returns the number of members in an xmlrpcval of array type
returns: integer @access public

                function arraysize()
                {
                        return count($this->me[\text{'}array\text{'}]);\; \}$

Returns the number of members in an xmlrpcval of struct type
returns: integer @access public

                function structsize()
                {
                        return count(this->me['struct']);
                }
        }

        // date helpers

        

Given a timestamp, return the corresponding ISO8601 encoded string. Really, timezones ought to be supported but the XML-RPC spec says: "Don't assume a timezone. It should be specified by the server in its documentation what assumptions it makes about timezones." These routines always assume localtime unless $utc\; is\; set\; to\; 1,\; in\; which\; case\; UTC\; is\; assumed\; and\; an\; adjustment\; for\; locale\; is\; made\; when\; encoding$
parameter: int timet (timestamp)
parameter: int $utc\; (0\; or\; 1)$
returns: string

        function iso8601_encode(timet, $utc=0)\; \{\; if(!$utc)
                {
                        $t=strftime("\%Y\%m\%dT\%H:\%M:\%S",$timet);
                }
                else
                {
                        if(function_exists('gmstrftime'))
                        {
                                // gmstrftime doesn't exist in some versions
                                // of PHP
                                $t=gmstrftime("\%Y\%m\%dT\%H:\%M:\%S",$timet);
                        }
                        else
                        {
                                $t=strftime("\%Y\%m\%dT\%H:\%M:\%S",$timet-date('Z'));
                        }
                }
                return $t;\; \}$

Given an ISO8601 date string, return a timet in the localtime, or UTC
parameter: string idate
parameter: int $utc\; either\; 0\; or\; 1$
returns: int (datetime)

        function iso8601_decode(idate, $utc=0)\; \{$t=0;
                if(preg_match('/([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})/', $idate,$regs))
                {
                        if($utc)\; \{$t=gmmktime($regs[4],$regs[5], $regs[6],$regs[2], $regs[3],$regs[1]);
                        }
                        else
                        {
                                $t=mktime($regs[4], $regs[5],$regs[6], $regs[2],$regs[3], $regs[1]);\; \}\; \}\; return$t;
        }

        

Takes an xmlrpc value in PHP xmlrpcval object format and translates it into native PHP types. Works with xmlrpc message objects as input, too. Given proper options parameter, can rebuild generic php object instances (provided those have been encoded to xmlrpc format using a corresponding option in php_xmlrpc_encode()) PLEASE NOTE that rebuilding php objects involves calling their constructor function. This means that the remote communication end can decide which php code will get executed on your server, leaving the door possibly open to 'php-injection' style of attacks (provided you have some classes defined on your server that might wreak havoc if instances are built outside an appropriate context). Make sure you trust the remote server/client before eanbling this!
author: Dan Libby (dan@libby.com)
parameter: xmlrpcval $xmlrpc\_val$
parameter: array options if 'decode_php_objs' is set in the options array, xmlrpc structs can be decoded into php objects
returns: mixed

        function php_xmlrpc_decode($xmlrpc\_val,$options=array())
        {
                switch($xmlrpc\_val->kindOf())\; \{\; case\; \text{'}scalar\text{'}:\; if\; (in\_array(\text{'}extension\_api\text{'},$options))
                                {
                                        reset($xmlrpc\_val->me);\; list($typ,$val)\; =\; each($xmlrpc_val->me);
                                        switch ($typ)\; \{\; case\; \text{'}dateTime.iso8601\text{'}:$xmlrpc_val->scalar = $val;$xmlrpc_val->xmlrpc_type = 'datetime';
                                                        $xmlrpc\_val->timestamp\; =\; iso8601\_decode($val);
                                                        return $xmlrpc\_val;\; case\; \text{'}base64\text{'}:$xmlrpc_val->scalar = $val;$xmlrpc_val->type = $typ;\; return$xmlrpc_val;
                                                default:
                                                        return $xmlrpc\_val->scalarval();\; \}\; \}\; return$xmlrpc_val->scalarval();
                        case 'array':
                                $size\; =$xmlrpc_val->arraysize();
                                $arr\; =\; array();\; for($i = 0; size; $i++)\; \{$arr[] = php_xmlrpc_decode($xmlrpc\_val->arraymem($i), $options);\; \}\; return$arr;
                        case 'struct':
                                $xmlrpc\_val->structreset();\; //\; If\; user\; said\; so,\; try\; to\; rebuild\; php\; objects\; for\; specific\; struct\; vals.$

@todo should we raise a warning for class not found? // shall we check for proper subclass of xmlrpcval instead of // presence of _php_class to detect what we can do? if (in_array('decode_php_objs', options) && xmlrpc_val->_php_class)) { $obj\; =\; @new$xmlrpc_val->_php_class; while(list($key,$value)=$xmlrpc\_val->structeach())\; \{$obj->$key\; =\; php\_xmlrpc\_decode($value, $options);\; \}\; return$obj; } else { $arr\; =\; array();\; while(list($key,$value)=$xmlrpc_val->structeach()) { $arr[$key] = php_xmlrpc_decode($value,$options); } return $arr;\; \}\; case\; \text{'}msg\text{'}:$paramcount = $xmlrpc\_val->getNumParams();$arr = array(); for($i\; =\; 0;$i < $paramcount;$i++) { $arr[]\; =\; php\_xmlrpc\_decode($xmlrpc_val->getParam($i));\; \}\; return$arr; } }

        // This constant left here only for historical reasons...
        // it was used to decide if we have to define xmlrpc_encode on our own, but
        // we do not do it anymore
        if(function_exists('xmlrpc_decode'))
        {
                define('XMLRPC_EPI_ENABLED','1');
        }
        else
        {
                define('XMLRPC_EPI_ENABLED','0');
        }

        

Takes native php types and encodes them into xmlrpc PHP object format. It will not re-encode xmlrpcval objects. Feature creep -- could support more types via optional type argument (string => datetime support has been added, ??? => base64 not yet) If given a proper options parameter, php object instances will be encoded into 'special' xmlrpc values, that can later be decoded into php objects by calling php_xmlrpc_decode() with a corresponding option
author: Dan Libby (dan@libby.com)
parameter: mixed $php\_val\; the\; value\; to\; be\; converted\; into\; an\; xmlrpcval\; object$
parameter: array options can include 'encode_php_objs', 'auto_dates', 'null_extension' or 'extension_api'
returns: xmlrpcval

        function &php_xmlrpc_encode($php\_val,$options=array())
        {
                $type\; =\; gettype($php_val);
                switch($type)\; \{\; case\; \text{'}string\text{'}:\; if\; (in\_array(\text{'}auto\_dates\text{'},$options) && preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/\text{'},$php_val))
                                        php_val, $GLOBALS[\text{'}xmlrpcDateTime\text{'}]);\; else$xmlrpc_val =& new xmlrpcval($php\_val,$GLOBALS['xmlrpcString']);
                                break;
                        case 'integer':
                                php_val, $GLOBALS[\text{'}xmlrpcInt\text{'}]);\; break;\; case\; \text{'}double\text{'}:$xmlrpc_val =& new xmlrpcval($php\_val,$GLOBALS['xmlrpcDouble']);
                                break;
                                // <G_Giunta_2001-02-29>
                                // Add support for encoding/decoding of booleans, since they are supported in PHP
                        case 'boolean':
                                php_val, tmp = array_diff(array_keys($php\_val),\; range(0,\; count($php_val)-1));
                                // but execution time skyrockets!
                                $j\; =\; 0;$arr = array();
                                $ko\; =\; false;\; foreach($php_val as $key\; =>$val)
                                {
                                        $arr[$key] =& php_xmlrpc_encode($val,$options);
                                        if(!key !== $j)\; \{$ko = true;
                                        }
                                        $j++;\; \}\; if($ko)
                                {
                                        arr, $GLOBALS[\text{'}xmlrpcStruct\text{'}]);\; \}\; else\; \{$xmlrpc_val =& new xmlrpcval($arr,$GLOBALS['xmlrpcArray']);
                                }
                                break;
                        case 'object':
                                if(is_a($php\_val,\; \text{'}xmlrpcval\text{'}))\; \{$xmlrpc_val = $php\_val;\; \}\; else\; \{$arr = array();
                                        while(list($k,$v) = each($php\_val))\; \{$arr[$k]\; =\; php\_xmlrpc\_encode($v, $options);\; \}$xmlrpc_val =& new xmlrpcval($arr,$GLOBALS['xmlrpcStruct']);
                                        if (in_array('encode_php_objs', $options))\; \{\; //\; let\text{'}s\; save\; original\; class\; name\; into\; xmlrpcval:\; //\; might\; be\; useful\; later\; on...$xmlrpc_val->_php_class = get_class($php\_val);\; \}\; \}\; break;\; case\; \text{'}NULL\text{'}:\; if\; (in\_array(\text{'}extension\_api\text{'},$options))
                                {
                                        GLOBALS['xmlrpcString']);
                                }
                                if (in_array('null_extension', $options))\; \{$xmlrpc_val =& new xmlrpcval('', $GLOBALS[\text{'}xmlrpcNull\text{'}]);\; \}\; else\; \{$xmlrpc_val =& new xmlrpcval();
                                }
                                break;
                        case 'resource':
                                if (in_array('extension_api', $options))\; \{$xmlrpc_val =& new xmlrpcval((int)$php\_val,$GLOBALS['xmlrpcInt']);
                                }
                                else
                                {
                                        <ping@alt.it>
                                // it has to return
                                // an empty object in case, not a boolean.
                                xmlrpc_val =& new xmlrpcval();
                                break;
                        }
                        return $xmlrpc\_val;\; \}$

Convert the xml representation of a method call, method request or single xmlrpc value into the appropriate object (a.k.a. deserialize)
parameter: string xml_val
parameter: array $options$
returns: mixed false on error, or an instance of either xmlrpcval, xmlrpcmsg or xmlrpcresp

        function php_xmlrpc_decode_xml(xml_val, $options=array())\; \{$GLOBALS['_xh'] = array();
                $GLOBALS[\text{'}\_xh\text{'}][\text{'}ac\text{'}]\; =\; \text{'}\text{'};$GLOBALS['_xh']['stack'] = array();
                $GLOBALS[\text{'}\_xh\text{'}][\text{'}valuestack\text{'}]\; =\; array();$GLOBALS['_xh']['params'] = array();
                $GLOBALS[\text{'}\_xh\text{'}][\text{'}pt\text{'}]\; =\; array();$GLOBALS['_xh']['isf'] = 0;
                $GLOBALS[\text{'}\_xh\text{'}][\text{'}isf\_reason\text{'}]\; =\; \text{'}\text{'};$GLOBALS['_xh']['method'] = false;
                $GLOBALS[\text{'}\_xh\text{'}][\text{'}rt\text{'}]\; =\; \text{'}\text{'};$

@todo 'guestimate' encoding parser = xml_parser_create(); xml_parser_set_option($parser,\; XML\_OPTION\_CASE\_FOLDING,\; true);\; xml\_parser\_set\_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS[\text{'}xmlrpc\_internalencoding\text{'}]);\; xml\_set\_element\_handler($parser, 'xmlrpc_se_any', 'xmlrpc_ee'); xml_set_character_data_handler($parser,\; \text{'}xmlrpc\_cd\text{'});\; xml\_set\_default\_handler($parser, 'xmlrpc_dh'); if(!xml_parse($parser,$xml_val, 1)) { $errstr\; =\; sprintf(\text{'}XML\; error:$\%s at line \%d, column \%d', xml_error_string(xml_get_error_code(parser)), xml_get_current_line_number($parser),\; xml\_get\_current\_column\_number($parser)); error_log($errstr);\; xml\_parser\_free($parser); return false; } xml_parser_free($parser);\; if\; ($GLOBALS['_xh']['isf'] > 1) // test that $GLOBALS[\text{'}\_xh\text{'}][\text{'}value\text{'}]\; is\; an\; obj,\; too???\; \{\; error\_log($GLOBALS['_xh']['isf_reason']); return false; } switch ($GLOBALS[\text{'}\_xh\text{'}][\text{'}rt\text{'}])\; \{\; case\; \text{'}methodresponse\text{'}:$v =& $GLOBALS[\text{'}\_xh\text{'}][\text{'}value\text{'}];\; if\; ($GLOBALS['_xh']['isf'] == 1) { $vc\; =$v->structmem('faultCode'); $vs\; =$v->structmem('faultString'); vc->scalarval(), $vs->scalarval());\; \}\; else\; \{$r =& new xmlrpcresp($v);\; \}\; return$r; case 'methodcall': GLOBALS['_xh']['method']); for($i=0;$i < count($GLOBALS[\text{'}\_xh\text{'}][\text{'}params\text{'}]);$i++) { $m->addParam($GLOBALS['_xh']['params'][$i]);\; \}\; return$m; case 'value': return $GLOBALS[\text{'}\_xh\text{'}][\text{'}value\text{'}];\; default:\; return\; false;\; \}\; \}$

decode a string that is encoded w/ "chunked" transfer encoding as defined in rfc2068 par. 19.4.6 code shamelessly stolen from nusoap library by Dietrich Ayala
parameter: string buffer the string to be decoded
returns: string

        function decode_chunked($buffer)\; \{\; //\; length\; :=\; 0$length = 0;
                $new\; =\; \text{'}\text{'};\; //\; read\; chunk-size,\; chunk-extension\; (if\; any)\; and\; crlf\; //\; get\; the\; position\; of\; the\; linebreak$chunkend = strpos($buffer,"\backslash r\backslash n")\; +\; 2;$temp = substr($buffer,0,$chunkend);
                $chunk\_size\; =\; hexdec(\; trim($temp) );
                $chunkstart\; =$chunkend;
                while($chunk\_size\; >\; 0)\; \{$chunkend = strpos($buffer,\; "\backslash r\backslash n",$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 + 2;

                        $chunkend\; =\; strpos($buffer,"\r\n",$chunkstart)+2;\; 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;
        }

        

xml charset encoding guessing helper function. Tries to determine the charset encoding of an XML chunk received over HTTP. NB: according to the spec (RFC 3023, if text/xml content-type is received over HTTP without a content-type, we SHOULD assume it is strictly US-ASCII. But we try to be more tolerant of unconforming (legacy?) clients/servers, which will be most probably using UTF-8 anyway...
parameter: string $httpheaders\; the\; http\; Content-type\; header$
parameter: string xmlchunk xml content buffer
parameter: string $encoding\_prefs\; comma\; separated\; list\; of\; character\; encodings\; to\; be\; used\; as\; default\; (when\; mb\; extension\; is\; enabled)\; @todo\; explore\; usage\; of\; mb\_http\_input():\; does\; it\; detect\; http\; headers\; +\; post\; data?\; if\; so,\; use\; it\; instead\; of\; hand-detection!!!$

        function guess_encoding(httpheader='', $xmlchunk=\text{'}\text{'},$encoding_prefs=null)
        {
                // discussion: see http://www.yale.edu/pclt/encoding/
		// 1 - test if encoding is specified in HTTP HEADERS

                //Details:
                // LWS:           (\13\10)?( |\t)+
                // token:         (any char but excluded stuff)+
                // header:        Content-type = ...; charset=value(; ...)*
                //   where value is of type token, no LWS allowed between 'charset' and value
                // Note: we do not check for invalid chars in VALUE:
                //   this had better be done using pure ereg as below

@todo this test will pass if ANY header has charset specification, not only Content-Type. Fix it? $matches\; =\; array();\; if(preg\_match(\text{'}/;\backslash s*charset=([^;]+)/i\text{'},$httpheader, $matches))\; \{\; return\; strtoupper(trim($matches[1])); }

                // 2 - scan the first bytes of the data for a UTF-16 (or other) BOM pattern
                //     (source: http://www.w3.org/TR/2000/REC-xml-20001006)
		//     NOTE: actually, according to the spec, even if we find the BOM and determine
                //     an encoding, we should check if there is an encoding specified
                //     in the xml declaration, and verify if they match.

@todo implement check as described above? @todo implement check for first bytes of string even without a BOM? (It sure looks harder than for cases WITH a BOM) if(preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlchunk))\; \{\; return\; \text{'}UCS-4\text{'};\; \}\; elseif(preg\_match(\text{'}/^(\backslash xFE\backslash xFF|\backslash xFF\backslash xFE)/\text{'},$xmlchunk)) { return 'UTF-16'; } elseif(preg_match('/^(\xEF\xBB\xBF)/', $xmlchunk))\; \{\; return\; \text{'}UTF-8\text{'};\; \}$

                // 3 - test if encoding is specified in the xml declaration
                // Details:
                // SPACE:         (#x20 | #x9 | #xD | #xA)+ === [ \x9\xD\xA]+
                // EQ:            SPACE?=SPACE? === [ \x9\xD\xA]*=[ \x9\xD\xA]*
                if (preg_match('/^<\?xml\s+version\s*=\s*'. "((?:\"[a-zA-Z0-9_.:-]+\")|(?:'[a-zA-Z0-9_.:-]+'))".
                        '\s+encoding\s*=\s*' . "((?:\"[A-Za-z][A-Za-z0-9._-]*\")|(?:'[A-Za-z][A-Za-z0-9._-]*'))/",
                        xmlchunk, $matches))\; \{\; return\; strtoupper(substr($matches[2], 1, -1));
                }

                // 4 - if mbstring is available, let it do the guesswork
                // NB: we favour finding an encoding that is compatible with what we can process
                if(extension_loaded('mbstring'))
                {
                        if($encoding\_prefs)\; \{$enc = mb_detect_encoding($xmlchunk,$encoding_prefs);
                        }
                        else
                        {
                                $enc\; =\; mb\_detect\_encoding($xmlchunk);
                        }
                        // NB: mb_detect likes to call it ascii, xml parser likes to call it US_ASCII...
                        // IANA also likes better US-ASCII, so go with it
                        if($enc\; ==\; \text{'}ASCII\text{'})\; \{$enc = 'US-'.$enc;\; \}\; return$enc;
                }
                else
                {
                        // no encoding specified: as per HTTP1.1 assume it is iso-8859-1?
                        // Both RFC 2616 (HTTP 1.1) and 1945(http 1.0) clearly state that for text/xxx content types
                        // this should be the standard. And we should be getting text/xml as request and response.
                        // BUT we have to be backward compatible with the lib, which always used UTF-8 as default...
                        return $GLOBALS[\text{'}xmlrpc\_defencoding\text{'}];\; \}\; \}$

Checks if a given charset encoding is present in a list of encodings or if it is a valid subset of any encoding in the list
parameter: string encoding charset to be tested
parameter: mixed $validlist\; comma\; separated\; list\; of\; valid\; charsets\; (or\; array\; of\; charsets)$

        function is_valid_charset(encoding, $validlist)\; \{$charset_supersets = array(
                        'US-ASCII' => array ('ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
                                'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8',
                                'ISO-8859-9', 'ISO-8859-10', 'ISO-8859-11', 'ISO-8859-12',
                                'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'UTF-8',
                                'EUC-JP', 'EUC-', 'EUC-KR', 'EUC-CN')
                );
                if (is_string($validlist))$validlist = explode(',', $validlist);\; if\; (@in\_array(strtoupper($encoding), $validlist))\; return\; true;\; else\; \{\; if\; (array\_key\_exists($encoding, $charset\_supersets))\; foreach\; ($validlist as $allowed)\; if\; (in\_array($allowed, $charset\_supersets[$encoding]))
                                                return true;
                                return false;
                }
        }

?>

---

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

---

(C) Æliens 20/2/2008

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.