{

use DeprecationLogger;

//use CharsetEncoderAware;

const USE_CURL_NEVER = 0;

const USE_CURL_ALWAYS = 1;

const USE_CURL_AUTO = 2;

const OPT_ACCEPTED_CHARSET_ENCODINGS = 'accepted_charset_encodings';

const OPT_ACCEPTED_COMPRESSION = 'accepted_compression';

const OPT_AUTH_TYPE = 'authtype';

const OPT_CA_CERT = 'cacert';

const OPT_CA_CERT_DIR = 'cacertdir';

const OPT_CERT = 'cert';

const OPT_CERT_PASS = 'certpass';

const OPT_COOKIES = 'cookies';

const OPT_DEBUG = 'debug';

const OPT_EXTRA_CURL_OPTS = 'extracurlopts';

const OPT_EXTRA_SOCKET_OPTS = 'extrasockopts';

const OPT_KEEPALIVE = 'keepalive';

const OPT_KEY = 'key';

const OPT_KEY_PASS = 'keypass';

const OPT_NO_MULTICALL = 'no_multicall';

const OPT_PASSWORD = 'password';

const OPT_PROXY = 'proxy';

const OPT_PROXY_AUTH_TYPE = 'proxy_authtype';

const OPT_PROXY_PASS = 'proxy_pass';

const OPT_PROXY_PORT = 'proxyport';

const OPT_PROXY_USER = 'proxy_user';

const OPT_REQUEST_CHARSET_ENCODING = 'request_charset_encoding';

const OPT_REQUEST_COMPRESSION = 'request_compression';

const OPT_RETURN_TYPE = 'return_type';

const OPT_SSL_VERSION = 'sslversion';

const OPT_TIMEOUT = 'timeout';

const OPT_USERNAME = 'username';

const OPT_USER_AGENT = 'user_agent';

const OPT_USE_CURL = 'use_curl';

const OPT_VERIFY_HOST = 'verifyhost';

const OPT_VERIFY_PEER = 'verifypeer';

const OPT_EXTRA_HEADERS = 'extra_headers';

/** @var string */

protected static $requestClass = '\\PhpXmlRpc\\Request';

/** @var string */

protected static $responseClass = '\\PhpXmlRpc\\Response';

/**

protected $errno;

/**

protected $errstr;

/// @todo: do all the ones below need to be public?

/**

protected $method = 'http';

/**

protected $server;

/**

protected $port = 0;

/**

protected $path;

/**

protected $debug = 0;

/**

protected $username = '';

/**

protected $password = '';

/**

protected $authtype = 1;

/**

protected $cert = '';

/**

protected $certpass = '';

/**

protected $cacert = '';

/**

protected $cacertdir = '';

/**

protected $key = '';

/**

protected $keypass = '';

/**

protected $verifypeer = true;

/**

protected $verifyhost = 2;

/**

protected $sslversion = 0;

/**

protected $proxy = '';

/**

protected $proxyport = 0;

/**

protected $proxy_user = '';

/**

protected $proxy_pass = '';

/**

protected $proxy_authtype = 1;

/**

protected $cookies = array();

/**

protected $extrasockopts = array();

/**

protected $extracurlopts = array();

/**

protected $timeout = 0;

/**

protected $use_curl = self::USE_CURL_AUTO;

/**

protected $no_multicall = false;

/**

protected $accepted_compression = array();

/**

protected $request_compression = '';

/**

protected $keepalive = false;

/**

protected $accepted_charset_encodings = array();

/**

protected $request_charset_encoding = '';

/**

protected $return_type = XMLParser::RETURN_XMLRPCVALS;

/**

protected $user_agent;

/**

protected $extra_headers = array();

/**

public $xmlrpc_curl_handle = null;

/**

protected static $options = array(

self::OPT_ACCEPTED_CHARSET_ENCODINGS,

self::OPT_ACCEPTED_COMPRESSION,

self::OPT_AUTH_TYPE,

self::OPT_CA_CERT,

self::OPT_CA_CERT_DIR,

self::OPT_CERT,

self::OPT_CERT_PASS,

self::OPT_COOKIES,

self::OPT_DEBUG,

self::OPT_EXTRA_CURL_OPTS,

self::OPT_EXTRA_SOCKET_OPTS,

self::OPT_KEEPALIVE,

self::OPT_KEY,

self::OPT_KEY_PASS,

self::OPT_NO_MULTICALL,

self::OPT_PASSWORD,

self::OPT_PROXY,

self::OPT_PROXY_AUTH_TYPE,

self::OPT_PROXY_PASS,

self::OPT_PROXY_USER,

self::OPT_PROXY_PORT,

self::OPT_REQUEST_CHARSET_ENCODING,

self::OPT_REQUEST_COMPRESSION,

self::OPT_RETURN_TYPE,

self::OPT_SSL_VERSION,

self::OPT_TIMEOUT,

self::OPT_USE_CURL,

self::OPT_USER_AGENT,

self::OPT_USERNAME,

self::OPT_VERIFY_HOST,

self::OPT_VERIFY_PEER,

self::OPT_EXTRA_HEADERS,

);

/**

public function __construct($path, $server = '', $port = '', $method = '')

{

// allow user to specify all params in $path

if ($server == '' && $port == '' && $method == '') {

$parts = parse_url($path);

$server = $parts['host'];

$path = isset($parts['path']) ? $parts['path'] : '';

if (isset($parts['query'])) {

$path .= '?' . $parts['query'];

}

if (isset($parts['fragment'])) {

$path .= '#' . $parts['fragment'];

}

if (isset($parts['port'])) {

$port = $parts['port'];

}

if (isset($parts['scheme'])) {

$method = $parts['scheme'];

}

if (isset($parts['user'])) {

$this->username = $parts['user'];

}

if (isset($parts['pass'])) {

$this->password = $parts['pass'];

}

}

if ($path == '' || $path[0] != '/') {

$this->path = '/' . $path;

} else {

$this->path = $path;

}

$this->server = $server;

if ($port != '') {

$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_version') && (($info = curl_version()) &&

((is_string($info) && strpos($info, 'zlib') !== null) || isset($info['libz_version'])))

)

) {

$this->accepted_compression = array('gzip', 'deflate');

}

// keepalives: enabled by default

$this->keepalive = true;

// by default the xml parser can support these 3 charset encodings

$this->accepted_charset_encodings = array('UTF-8', 'ISO-8859-1', 'US-ASCII');

// NB: this is disabled to avoid making all the requests sent huge... mbstring supports more than 80 charsets!

//$ch = $this->getCharsetEncoder();

//$this->accepted_charset_encodings = $ch->knownCharsets();

// initialize user_agent string

$this->user_agent = PhpXmlRpc::$xmlrpcName . ' ' . PhpXmlRpc::$xmlrpcVersion;

}

/**

public function setOption($name, $value)

{

if (in_array($name, static::$options)) {

$this->$name = $value;

return $this;

}

throw new ValueErrorException("Unsupported option '$name'");

}

/**

public function getOption($name)

{

if (in_array($name, static::$options)) {

return $this->$name;

}

throw new ValueErrorException("Unsupported option '$name'");

}

/**

public function getOptions()

{

$values = array();

foreach (static::$options as $opt) {

$values[$opt] = $this->getOption($opt);

}

return $values;

}

/**

public function setOptions($options)

{

foreach ($options as $name => $value) {

$this->setOption($name, $value);

}

return $this;

}

/**

public function setDebug($level)

{

$this->debug = $level;

return $this;

}

/**

public function setCredentials($user, $password, $authType = 1)

{

$this->username = $user;

$this->password = $password;

$this->authtype = $authType;

return $this;

}

/**

public function setCertificate($cert, $certPass = '')

{

$this->cert = $cert;

$this->certpass = $certPass;

return $this;

}

/**

public function setCaCertificate($caCert, $isDir = false)

{

if ($isDir) {

$this->cacertdir = $caCert;

} else {

$this->cacert = $caCert;

}

return $this;

}

/**

public function setKey($key, $keyPass)

{

$this->key = $key;

$this->keypass = $keyPass;

return $this;

}

/**

public function setSSLVerifyPeer($i)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->verifypeer = $i;

return $this;

}

/**

public function setSSLVerifyHost($i)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->verifyhost = $i;

return $this;

}

/**

public function setSSLVersion($i)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->sslversion = $i;

return $this;

}

/**

public function setProxy($proxyHost, $proxyPort, $proxyUsername = '', $proxyPassword = '', $proxyAuthType = 1)

{

$this->proxy = $proxyHost;

$this->proxyport = $proxyPort;

$this->proxy_user = $proxyUsername;

$this->proxy_pass = $proxyPassword;

$this->proxy_authtype = $proxyAuthType;

return $this;

}

/**

public function setAcceptedCompression($compMethod)

{

if ($compMethod == 'any') {

$this->accepted_compression = array('gzip', 'deflate');

} elseif ($compMethod == false) {

$this->accepted_compression = array();

} else {

$this->accepted_compression = array($compMethod);

}

return $this;

}

/**

public function setRequestCompression($compMethod)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->request_compression = $compMethod;

return $this;

}

/**

public function setCookie($name, $value = '', $path = '', $domain = '', $port = null)

{

$this->cookies[$name]['value'] = rawurlencode($value);

if ($path || $domain || $port) {

$this->cookies[$name]['path'] = $path;

$this->cookies[$name]['domain'] = $domain;

$this->cookies[$name]['port'] = $port;

}

return $this;

}

/**

public function setCurlOptions($options)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->extracurlopts = $options;

return $this;

}

/**

public function setUseCurl($useCurlMode)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->use_curl = $useCurlMode;

return $this;

}

/**

public function setUserAgent($agentString)

{

$this->logDeprecation('Method ' . __METHOD__ . ' is deprecated');

$this->user_agent = $agentString;

return $this;

}

/**

public function getUrl($component = null)

{

if (is_int($component) || ($component !== null && ctype_digit($component))) {

switch ($component) {

case PHP_URL_SCHEME:

return $this->method;

case PHP_URL_HOST:

return $this->server;

case PHP_URL_PORT:

return $this->port;

case PHP_URL_PATH:

return $this->path;

case '':

default:

throw new ValueErrorException("Unsupported component '$component'");

}

}

$url = $this->method . '://' . $this->server;

if ($this->port == 0 || ($this->port == 80 && in_array($this->method, array('http', 'http10', 'http11', 'http11_only', 'h2c'))) ||

($this->port == 443 && in_array($this->method, array('https', 'h2')))) {

return $url . $this->path;

} else {

return $url . ':' . $this->port . $this->path;

}

}

/**

public function send($req, $timeout = 0, $method = '')

{

if ($method !== '' || $timeout !== 0) {

$this->logDeprecation("Using non-default values for arguments 'method' and 'timeout' when calling method " . __METHOD__ . ' is deprecated');

}

// if user does not specify http protocol, use native method of this client

// (i.e. method set during call to constructor)

if ($method == '') {

$method = $this->method;

}

if ($timeout == 0) {

$timeout = $this->timeout;

}

if (is_array($req)) {

// $req is an array of Requests

/// @todo switch to the new syntax for multicall

return $this->multicall($req, $timeout, $method);

} elseif (is_string($req)) {

$n = new static::$requestClass('');

/// @todo we should somehow allow the caller to declare a custom contenttype too, esp. for the charset declaration

$n->setPayload($req);

$req = $n;

}

// where req is a Request

$req->setDebug($this->debug);

/// @todo move to its own function, to make it easier to change in subclasses

/// @todo we could be smarter about this:

/// - not force usage of curl if it is not present

/// - not force usage of curl for https (minor BC)

/// - use the presence of curl_extra_opts or socket_extra_opts as a hint

$useCurl = ($this->use_curl == self::USE_CURL_ALWAYS) || ($this->use_curl == self::USE_CURL_AUTO && (

in_array($method, array('https', 'http11', 'http11_only', 'h2c', 'h2')) ||

($this->username != '' && $this->authtype != 1) ||

($this->proxy != '' && $this->proxy_user != '' && $this->proxy_authtype != 1)

// uncomment the following if not forcing curl always for 'https'

//|| ($this->sslversion == 7 && PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION == '7.3')

//|| ($this->sslversion != 0 && PHP_MAJOR_VERSION < 6)

));

// BC - we go through sendPayloadCURL/sendPayloadSocket in case some subclass reimplemented those

if ($useCurl) {

$r = $this->sendPayloadCURL(

$req,

$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,

// BC - http11 was used to force enabling curl

$method == 'http11' ? 'http' : ($method == 'http11_only' ? 'http11' : $method),

$this->keepalive,

$this->key,

$this->keypass,

$this->sslversion

);

} else {

$r = $this->sendPayloadSocket(

$req,

$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,

$method == 'http11_only' ? 'http11' : $method,

$this->key,

$this->keypass,

$this->sslversion

);

}

return $r;

}

/**

protected function sendViaSocket($req, $method, $server, $port, $path, $opts)

{

/// @todo log a warning if passed an unsupported method

// Only create the payload if it was not created previously

/// @todo what if the request's payload was created with a different encoding?

/// Also, if we do not call serialize(), the request will not set its content-type to have the charset declared

$payload = $req->getPayload();

if (empty($payload)) {

$payload = $req->serialize($opts['request_charset_encoding']);

}

// Deflate request body and set appropriate request headers

$encodingHdr = '';

if ($opts['request_compression'] == 'gzip' || $opts['request_compression'] == 'deflate') {

if ($opts['request_compression'] == 'gzip' && function_exists('gzencode')) {

$a = @gzencode($payload);

if ($a) {

$payload = $a;

$encodingHdr = "Content-Encoding: gzip\r\n";

} else {

$this->getLogger()->warning('XML-RPC: ' . __METHOD__ . ': gzencode failure in compressing request');

}

} else if (function_exists('gzcompress')) {

$a = @gzcompress($payload);

if ($a) {

$payload = $a;

$encodingHdr = "Content-Encoding: deflate\r\n";

} else {

$this->getLogger()->warning('XML-RPC: ' . __METHOD__ . ': gzcompress failure in compressing request');

}

} else {

$this->getLogger()->warning('XML-RPC: ' . __METHOD__ . ': desired request compression method is unsupported by this PHP install');

}

} else {

if ($opts['request_compression'] != '') {

$this->getLogger()->warning('XML-RPC: ' . __METHOD__ . ': desired request compression method is unsupported');

}

}

// thanks to Grant Rauscher

$credentials = '';

if ($opts['username'] != '') {

if ($opts['authtype'] != 1) {

$this->getLogger()->error('XML-RPC: ' . __METHOD__ . ': warning. Only Basic auth is supported with HTTP 1.0');

return new static::$responseClass(0, PhpXmlRpc::$xmlrpcerr['unsupported_option'],

PhpXmlRpc::$xmlrpcerr['unsupported_option'] . ': only Basic auth is supported with HTTP 1.0');

}

$credentials = 'Authorization: Basic ' . base64_encode($opts['username'] . ':' . $opts['password']) . "\r\n";

}

$acceptedEncoding = '';

if (is_array($opts['accepted_compression']) && count($opts['accepted_compression'])) {

$acceptedEncoding = 'Accept-Encoding: ' . implode(', ', $opts['accepted_compression']) . "\r\n";

}

if ($port == 0) {

$port = ($method === 'https') ? 443 : 80;

}

$proxyCredentials = '';

if ($opts['proxy']) {

if ($opts['proxyport'] == 0) {

$opts['proxyport'] = 8080;

}

$connectServer = $opts['proxy'];

$connectPort = $opts['proxyport'];

$transport = 'tcp';

$protocol = $method;

if ($method === 'http10' || $method === 'http11') {

$protocol = 'http';