--- /dev/null
+/.idea
+composer.phar
+composer.lock
+/vendor/*
+/tests/coverage/*
+/build/*
--- /dev/null
+language: php
+
+php:
+ - 5.3
+ - 5.4
+ - 5.5
+ - 5.6
+ - 7.0
+ - 7.1
+ # hhvm is not available any more on default travis images
+ #- hhvm
+
+before_install:
+ # This is mandatory or the 'apt-get install' calls following will fail
+ - sudo apt-get update -qq
+ - sudo apt-get install -y apache2 libapache2-mod-fastcgi
+ - sudo apt-get install -y privoxy
+
+install:
+ - composer self-update && composer install
+
+before_script:
+ # Disable xdebug for speed.
+ # NB: this should NOT be done for hhvm and php 7.0.
+ # Also we use the php 5.6 run to generate code coverage reports, and we need xdebug for that
+ - if [ "$TRAVIS_PHP_VERSION" != "hhvm" -a "$TRAVIS_PHP_VERSION" != "7.0" -a "$TRAVIS_PHP_VERSION" != "5.6" ]; then phpenv config-rm xdebug.ini; fi
+
+ # Set up Apache and Privoxy instances inside the Travis VM and use them for testing against
+ - if [ "$TRAVIS_PHP_VERSION" != "hhvm" ]; then ./tests/ci/travis/setup_php_fpm.sh; ./tests/ci/travis/setup_apache.sh; fi
+ - if [ "$TRAVIS_PHP_VERSION" = "hhvm" ]; then ./tests/ci/travis/setup_hhvm.sh; ./tests/ci/travis/setup_apache_hhvm.sh; fi
+ - ./tests/ci/travis/setup_privoxy.sh
+
+ # output what version of phpunit we got going
+ - vendor/bin/phpunit --version
+
+script:
+ # Travis currently compiles PHP with an oldish cURL/GnuTLS combination;
+ # to make the tests pass when Apache has a bogus SSL cert whe need the full set of options below
+ vendor/bin/phpunit --coverage-clover=coverage.clover tests LOCALSERVER=localhost URI=/demo/server/server.php HTTPSSERVER=localhost HTTPSURI=/demo/server/server.php PROXY=localhost:8080 HTTPSVERIFYHOST=0 HTTPSIGNOREPEER=1 SSLVERSION=3 DEBUG=1
+
+after_failure:
+ # Save as much info as we can to help developers
+ - cat apache_error.log
+ - cat apache_access.log
+ #- cat /var/log/hhvm/error.log
+ #- if [ "$TRAVIS_PHP_VERSION" = "hhvm" ]; then php -i; fi
+
+after_script:
+ # Upload code-coverage to Scrutinizer
+ - if [ "$TRAVIS_PHP_VERSION" = "5.6" ]; then wget https://scrutinizer-ci.com/ocular.phar; fi
+ - if [ "$TRAVIS_PHP_VERSION" = "5.6" ]; then php ocular.phar code-coverage:upload --format=php-clover coverage.clover; fi
+ # Upload code-coverage CodeClimate
+ - if [ "$TRAVIS_PHP_VERSION" = "5.6" ]; then CODECLIMATE_REPO_TOKEN=7fa6ee01e345090e059e5e42f3bfbcc8692feb8340396382dd76390a3019ac13 ./vendor/bin/test-reporter --coverage-report=coverage.clover; fi
--- /dev/null
+NB: All recent commits are available online.
+This file will not be updated further.
+See https://github.com/gggeek/phpxmlrpc/commits/master
+
+2014-05-26 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * removed bundled phpunit
+ * converted all tabs to spaces in php files and removed closing tags
+
+2014-05-12 - Samu Voutilainen (smar@smar.fi)
+
+ * removed obsolete xml.so open; dl() is deprecated and removed from 5.3.0
+ * removed deprecated xmlEntities
+ * removed deprecated xmlrpc_backslash
+ * converted $GLOBALS to internal class. This makes testing much easier and should be more flexible regarding other projects
+ * changed verifyhost from 1 to 2. This makes modern php versions work properly.
+ * split off each class in its own file
+
+2014-02-03 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * bumped up requirements to php 5.1.0
+
+2014-01-10 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: when using curl and keepalive, reset curl handle if we did not get back an http 200 response (eg a 302)
+
+ * testsuite.php, parse_args.php: update testsuite
+
+ * debugger/controller.php: change default path to javascript debugger
+
+2010-05-23 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: omit port on http 'Host' header if it is 80;
+ add a namespace declaration in response if ex:nil is in use
+
+2010-04-12 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * testsuite.php, parse_args.php: testsuite allows interrogating https servers ignoring their certs
+
+ * xmlrpc.inc: method setAcceptedCompression was failing to disable reception
+ of compressed responses if the client supported them (triggering a bug with
+ https and php < 5.3 on windows); remove a php warning that could be
+ generated when using debug=2 in a client connecting to an https
+ server
+
+2010-04-11 - G. Giunta (giunta.gaetano@gmail.com) thanks amoe
+
+ * fixed: bad variables in "make install" make target
+
+2009-11-11 - G. Giunta (giunta.gaetano@gmail.com) thanks Ikiro Watanabe
+
+ * added INSTALL file
+
+2009-09-05 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpcs.inc, xmlrpcs.inc: remove code that was left for compatibility
+ with php 4; use __METHOD__ constant for error messages instead of hardcoded
+ values
+
+ * xmlrpcs.inc: catch exceptions thrown during execution of invoked methods;
+ check for $_SERVER having been disabled via php.ini and log an error if so
+
+ * server.php, testsuite.php: add a new test and server method for exception
+ catching in the server
+
+ * xmlrpc.inc: added new method SetUserAgent to client to allow having different
+ user-agent http headers
+
+ * tagged and released as 3.0.0 beta
+
+2009-08-05 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc_wrappers.inc: improve compatibility with php 5.0 when registering
+ class/object methods
+
+2009-08-02 - G. Giunta (giunta.gaetano@gmail.com) thanks Laurens
+
+ * xmlrpcs.inc: add a new member var in server class to allow fine-tuning
+ of the encoding of returned values when the server is in 'phpvals' mode;
+ allow servers in 'xmlrpcvals' mode to also register plain php functions by
+ defining them in the dispatch map with an added option:
+ 'parameters_type' => 'phpvals' (feature request #2806628)
+
+ * xmlrpc.inc: added new method xmrlpc_client::SetCurlOptions($array) to
+ allow extra flexibility in tweaking http config, such as explicitly
+ binding to an ip address (feature request #2787468); fix bad encoding if
+ same object is encoded twice using php_xmlrpc_encode; removed some by-ref
+ assignments and declarations
+
+2009-07-31 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: add support for dateTime objects in both in php_xmlrpc_encode
+ and as parameter for constructor of xmlrpcvals; add support for timestamps
+ as parameter for constructor of xmlrpcvals; add option 'dates_as_objects' to
+ php_xmlrpc_decode to return dateTime objects for xmlrpc datetimes
+
+ * benchmark.php, xmlrpc_wrappers.inc: remove usage of split(), deprecated in
+ php 5.3
+
+ * benchmark.php: fixed url of server page used for testing; improved
+ verification of correspondence of test results; added more variants for
+ http options comparison
+
+ * verify_compat.php: check for php version 5 for client side too
+
+ * makefile: remove from build the compat directory
+
+2009-07-26 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * server.php: remove usage of ereg*(), deprecated in php 5.3
+
+2009-07-16 - G. Giunta (giunta.gaetano@gmail.com) thanks Jean-Jacques Sarton
+
+ * xmlrpc.inc: add support for the <ex:nil/> from the apache library, both
+ in input and output (feature request #...)
+
+ * xmlrpc.inc, testsuite.php: remove usage of split(), deprecated in php 5.3
+
+ * testsuite.php: flush better results with output_buffering on
+
+ * server: php: avoid one warning about static function calls
+
+2009-07-02 - G. Giunta (giunta.gaetano@gmail.com) thanks Heiko Stuebner
+
+ * xmlrpc.inc: fix: when checking the parameters against the signatures xmlrpc
+ checks for "array" but PHP returns "Array" resulting in a not matches signature
+
+2009-05-07 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * replace all usage of '= & new' with '= new', as this is deprecated in php 5
+ and has been shown to cause problems too
+
+2009-05-06 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * create php4 branch, rename trunk to 3.0.0beta - it will be the php5-only version
+
+ * xmlrpc.inc: removed test for php version and inclusion of compat patches for really
+ really old versions of php 4
+
+2009-03-16 - G. Giunta (giunta.gaetano@gmail.com) thanks Tommaso Trani
+
+ * move from CVS to SVN on sf.net; file layout now is the same as in packaged lib
+
+ * xmlrpc.inc: fix php warning when receiving 'false' in a bool value
+
+ * Makefile, doc/Makefile: alter to follow new file layout
+
+ * tagged and released as 2.2.2
+
+2009-02-03 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * debugger/action.php: improve code robustness when parsing system.listmethods
+ and system.describemethods call
+
+ * xmlrpc.inc: format floating point values using the correct decimal separator
+ even when php locale is set to one that uses comma (bug #2517579);
+ use feof() to test if socket connections are to be closed instead of the
+ number of bytes read (bug #2556209)
+
+2008-10-29 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpcs.inc: allow add_to_map server method to add docs for single params, too
+
+2008-09-20 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc_wrappers.inc: added the possibility to wrap for exposure as xmlrpc
+ methods plain php class methods, object methods and even whole classes
+
+ * testsuite.php, server.php: added test cases for the new code
+
+2008-09-07 - G. Giunta (giunta.gaetano@gmail.com) thanks Bruno Zanetti Melotti
+
+ * xmlrpc.inc: be more tolerant in detection of charset in http headers (fix for bug #2058158)
+
+2008-04-05 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: fix encoding of UTF8 chars outside of the BMP
+
+ * xmlrpcs.inc: fix detection of zlib.output_compression (thanks xbert)
+
+2008-03-06 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * tagged and released as 2.2.1
+
+ * Makefile: improve usage on windows xp despite cmd's broken mkdir
+
+2007-10-26 - G. Giunta (giunta.gaetano@gmail.com) thanks sajo_raftman
+
+ * xmlrpc.inc: remove one warning in xmlrpc_client creator
+
+2007-10-26 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: improve support for windows cp1252 character set (still
+ commented in the code)
+
+2007-09-05 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc, xmlrps.inc: do not try to set invalid charsets as output for
+ xml parser, even if user set them up for internal_encoding (helps encoding
+ to exotic charsets, while decoding to UTF8)
+
+2007-09-05 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: fix parsing of '1e+1' as valid float
+
+2007-09-01 - G. Giunta (giunta.gaetano@gmail.com), thanks Frederic Lecointre
+
+ * xmlrpcs.inc: allow errorlevel 3 to work when prev. error handler was a static method
+
+ * testsuite.php: fix test on setCookie()
+
+2007-08-31 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: minor fix in cookie parsing
+
+2007-07-31 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: Fix usage of client::setcookie() for multiple cookies in non-ssl mode
+
+2007-07-26 - G. Giunta (giunta.gaetano@gmail.com) thanks Mark Olive
+
+ * xmlrpc.inc: Fix for bug # 1756274 (usage of cookies in ssl mode)
+
+2007-04-28 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: give more detailed curl information when DEBUG = 2; fix handling
+ of case where curl w. keepalive is used and one connection of many fails
+
+ * testsuite improvements: add one testcase; give feedbcak while tests are
+ running
+
+2007-04-01 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * doc/makefile, doc/custom.fo.xsl: improve pdf rendering of php source code
+
+ * makefile: recover version number from source instead of having it hardcoded
+
+2007-03-10 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * doc/makefile, doc/convert.php, doc/*.xsl: created customizations xslt to
+ produce a documentation more in line with the php manual, esp. with regards
+ to functions synopsis; added jellyfish book cover as local resource and a
+ screenshot of the debugger too; various updates to the manual source; added
+ a php script to highlight examples inside html docs
+
+2007-03-09 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * debugger/action.php: css tweak for IE
+
+ * added phpunit license file in the phpunit directory
+
+ * added link to license (on sf.net site) to many files
+
+2007-03-04 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * Makefile, doc/makefile: assorted improvements
+
+2007-03-03 - G. Giunta (giunta.gaetano@gmail.com)
+
+ * xmlrpc.inc: micro-optimization in declaration of global vars xmlrpcerr, xmlrpcstr
+
+2007-02-25 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * removed a couple of warnings emitted in testsuite.php
+
+ * doc/makefile: added command for invocation of xxe to generate docs
+
+ * better rendering of docs in xml+css format for function prototypes
+
+ * updated documentation
+
+ * tagged and released as 2.2
+
+2007-02-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * debugger: workaround for case of magic_quotes_gpc being set (properly
+ unescape user input); fix case of user not setting msg id in jsonrpc case
+ when executing a remote method; allow strings, false, true and null as msg id
+
+2007-02-13 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * testsuite.php: added one test for automatic encoding/decoding case
+
+2007-02-05 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: slightly faster encoding of UTF8 data to ascii
+
+2007-01-11 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: when calling client::multicall() with an unspecified http version,
+ use the client default rather than the fixed 'http 1.0'
+
+2006-09-17 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc, xmlrpcs.inc, testsuite.php: added support for <NIL/> and
+ system.getCapabilities, and one more testcase to go with it
+
+2006-09-05 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix support for https through proxies; client parses debug
+ messages sent by client even for compressed responses;
+
+ * testsuite.php, parse_args.php: added 3 test cases for proxy connections
+
+2006-09-01 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ xmlrpc_wrappers.inc: add two more options in wrap_xmlrpc_method and fix
+ typo to allow obj encoding
+
+2006-08-28 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc_wrappers.inc: more options added to wrap_php_function and
+ wrap_xmlrpc_method
+
+ * xmlrpc.inc: pave the way to support for <nil/>
+
+ * doc/xmlrpc_php.xml documentation updated
+
+ * tagged and released as 2.1
+
+2006-08-25 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: stricter parsing of incoming messages: detect two DATA elements
+ inside an ARRAY, a STRUCT or SCALAR inside an already filled VALUE
+
+ * testsuite.php: added two testcases to check for the above cases
+
+2006-08-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: more code optimization in xmlrpcval::serialize() and
+ php_xmlrpc_encode(); fixed bug where struct elements with non-ascii chars
+ in their name would not be properly encoded
+
+ * testsuite.php: added a testcase for the new bug
+
+2006-08-23 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * remove old code left in comments across many files; many more javadoc
+ comments added
+
+ * xmlrpc.inc: a bit of code optimization: reorder switch() statements of
+ xml parsing element handlers; inline code for xmlrpcval() - this breaks
+ new xmlrpcval('true') and changes error msgs on new xmlrpcval($x, 'invalid_type')
+
+ * testsuite.php: change according to above
+
+ * benchmark.php: basic support for xdebug 2 profiling
+
+2006-08-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: addscalar() and addstruct() where not returning 1 when adding
+ data to an already formed value
+
+2006-08-21 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc, xmlrpc.inc: added support for emulating the xmlrpc-extension
+ API (the full emulation layer is part of the extras package);
+ fix support for the HTTP 'deflate' encoding
+
+ * xmlrpc.inc: better support for http compression with and without CURL;
+ a minor decoding speedup; added a new function: php_xmlrpc_decode_xml(),
+ that will convert into the appropriate object the xml representation of
+ either a request, response or a single value; log reception of invalid
+ datetime values
+
+ * xmlrpcs.inc: add a new parameter and return type to server->service();
+ let server->add_to_map() accept method definitions without parameter types
+
+ * xmlrpc_wrappers.inc: more logging of errors; wrap_php_functions now takes
+ more options; better support for jsonrpc; escape quote chars when wrapping
+ remothe servers / remote methods
+
+ * added cvs Id tag to files that missed it; speling fixes; updated NEWS files
+
+2006-08-07 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * assorted fixes to make the suite more compatible with php 4.0.5 and 5.x
+
+2006-07-02 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc_warppers.inc: added new function to wrap entire remote server into
+ a local php class; changed default calling synopsis of wrap_remote_method,
+ to ease passing multiple options at a time (but old syntax still works!)
+
+ * updated makefile, debugger/action.php in accord with the above
+
+2006-06-30 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * added to debugger capability to generate json-rpc code stubs
+
+ * added to debugger capability to load and launch self correctly if
+ controller.php is called directly from outside processes (single url access)
+
+2006-06-26 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * moved wrap_php_functions and wrap_xmlrpc_method into a file of their own.
+ This will let us add further stub functionality without the base lib growing too much.
+ All of the files that reference this functionality have been modified accordingly.
+
+ * made wrap_xmlrpc_method generate better code (with php type juggling), and
+ some phpdoc for the generated function, too
+
+ * added to debugger an option to produce for the user the generated php code
+ for wrapping a call to a remote method into a php function
+
+2006-06-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: added description of parameters for system.xxx methods (useful with
+ html-self-documenting servers);
+ server->service() now returns response object, in case user has need for it...
+
+ * xmlrpc.inc: save full response payload into xmlrpcresp obj for better debugging
+
+2006-06-15 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * verify_compat.php: more tests
+
+2006-06-09 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: fixed sending of compressed responses when output compression
+ is already enabled in php.ini
+
+ * verify_compat.php: split tests between server and client cases
+
+2006-05-29 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * added new file: verify_compat.php, to help troubleshooting platform
+ support for the library; added it to makefile, too
+
+2006-05-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: removed residual usage of regexp in favour of pregexps; fixed
+ a bug in specifying Host http header with non std ports
+
+2006-05-23 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: improvements to wrap_php_function: let it deal correctly
+ with php functions returning xmlrpcresp objs; make it generate also
+ docs for single parameters (useful for documenting_xmlrpc_server class)
+
+2006-05-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc, xmlrpcs.inc: minor performance tuning updates: replaced
+ some explode vs. split, ereg vs. preg, single vs. double quotes
+
+ * xmlrpc.inc: fix wrap_xmlrpc_method to NOT rebuild php objects received
+ from the server by default, as it might pose a security risk
+
+2006-04-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * minor fixes makefiles. Tagged and released as 2.0 final
+
+2006-04-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * debugger/*: added option to set cainfo; improve web layout
+
+ * xmlrpc.inc: set sslverifypeer to TRUE instaed of 1 by default
+
+ * doc/php_xmlrpc.xml: documentation updates
+
+2006-04-21 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: added option to set ca certs dir instead of single cert
+ (used to validate server in https connetions)
+
+2006-04-18 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed bug in xmlrpcval::structmemexists()
+
+ * testsuite.php: added test case for xmlrpcval::structmemexists()
+
+2006-04-03 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: add support for Digest and NTLM authentication, both to server
+ and to proxies (note: must use CURL for this to work)
+
+ * debugger/*: add support for Digest/NTLM auth to remote servers
+
+2006-03-19 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix a bug parsing of 'true' bool values;
+ added a new method to the client class: SetCaCertificate;
+ add column number in xml parsing error messages;
+ fix serialization of messages to ISO-8859-1 charset with php 5 (by adding
+ encoding to the xml prologue of generated messages)
+
+ * xmlrpcs.inc: correct detection of charset in http headers;
+ add column number in xml parsing error messages;
+ fix serialization of responses to ISO-8859-1 charset with php 5 (by adding
+ encoding to the xml prologue of generated responses)
+
+ * testsuite.php: added two more tests on charset encoding
+
+ * NEWS: update info for impending release
+
+2006-03-23 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * added a new demo file: simple_call.php
+
+2006-02-20 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: more error checking and logging with regard to user-coded
+ method handler functions not being well behaved;
+ fix a case where error handler would not be reset upon user function
+ returning not valid xmlrpresp
+
+ * xmlrpc.inc: fix bug in detection of php 4.3.0
+
+ * Makefile: fix uppercase filenames
+
+2006-02-15
+
+ * xmlrpc.inc: parse 'true' and 'false' as valid booleans, even though the
+ spec is quite clear on that; fix small bug w. internal_encoding = utf8; add
+ definition of $GLOBALS['xmlrpcNull'] for extensibility, e.g. json or
+ extensions to the xmlrpc spec
+
+2006-02-05 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix bug in wrap_xmlrpc_method if client passed to function has
+ return_type=phpvals
+
+ * all demo files: review code, add more comments and information
+
+ * added 2 demo files: proxy.php (implementing an xmlrpc proxy server) and
+ wrap.php (showing usage of wrap_method_call)
+
+2006-02-04 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix bug in multicall in case of no fallback and server error
+
+2006-01-30 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix recursive serialization of xmlrpcvals loosing UTF8 charset;
+ correctly set type field of xmlrpcvals returned by send() calls
+
+ * xmlrpcs.inc: add to server checks for correct return type of user-coded
+ method handling function; tolerate xmlrpcval instead of xmlrpcresp
+
+ * minor change in xmlrpcresp internals, to ease subclassing (store payload
+ in an internal var on serialize(), same as xmlrpcclient does)
+
+2006-01-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * benchmark.php: do not run http 1.1 tests if CURL notfound
+
+ * Released as 2.0 Rc3
+
+2006-01-19 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: make xmlrpc_client::setDebug() accept int values instead of
+ boolean. At level 2, the request payload is printed to screen before being
+ sent; fix bug with repeated sending of the same msg object and using request
+ compression w. php 5.1.2 (objects passed by ref by default!!!)
+
+ * xmlrpcs.inc: fix detection of clients accepting compressed responses
+
+ * comment.php: remove warnings due to liberal usage of $HTTP_POST/GET_VARS
+
+ * benchmark.php: add a test using http compression of both requests and
+ responses
+
+ * testsuite.php: added test for fix in xmlrpc.inc
+
+2006-01-17 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.php: minor fix: do not raise a PHP warning when std server is
+ called via GET (global HTTP_RAW_POST_DATA undefined). Some might have called
+ it a security breach (path disclosure)...
+
+2006-01-15 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * testsuite.php: minor fix to expected date format in http cookie hedaer
+ to cope with PHP 5.1.2
+
+2006-01-05 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: merge code from the 'extras' subclass that allows server
+ to register plain php functions in dispatch map instead of functions
+ accepting a single xmlrpcmgs obj parameter.
+ One step closer to the kitchen sink!!!
+
+2005-12-31 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: let the server accept 'class::method' syntax in the dispatch
+ map
+
+ * testsuite.php, server.php: added new tests for the recent charset encoding
+ capabilities
+
+2005-12-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: correctly serialize() string xmlrpcvals that have been
+ created out of non-string php variables, when internal encoding is UTF8;
+ serialize to '0' int and double values created out of non-string php
+ variables, eg. 'hello', instead of creating invalid xmlrpc;
+ extend the php_xmlrpc_encode function to allow serializing string values
+ to charsets other tha US-ASCII;
+ minor tweak to xml parsing to allow correct parsing of empty strings when
+ in 'direct to php values' mode
+
+ * xmlrpcs.inc: advances in system.multicall with plain php values
+
+2005-12-17 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: let the functions implementing the system.* methods work
+ fine when called with plain php values as parameters instead of xmlrpcmsg
+ objects (multicall not quite finished yet...);
+ encode level 3 debug info as base64 data, to avoid charset encoding hell
+
+ * xmlrpc.inc: added a new xmlrpc_2_php_type function, to get the name of
+ php types corresponding to xmlrpc types;
+ in debug mode, when detecting base64 server debug info, print it out fine
+
+ * server.php: cosmetic fixes
+
+2005-12-09 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: remove one warning emitted when received xml contains an
+ unknown tag; remove warnings emitted when custom error handler is set
+ and user calls php_xmlrpc_encode/decode without the 2nd parameter
+
+ * xmlrpcs.inc: added a param to service(), to allow the server to parse
+ data other than the POST body (useful for subclassing and debugging);
+ reworked the implementation of server debug messages at debug level 2:
+ since the debug info generated has no known charset, and putting it back
+ into the response's xml would most likely break it, send it back to the
+ client as a base64 encoded comment. Clients can decode it if they need it...
+ Add some more javadocs
+
+ * testsuite.php: modified the string test, to see if the server can echo
+ back to the client the received data without breaking the response's xml
+
+2005-12-05 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc, xmlrpcs.inc: let server and client objects decide if they
+ want to use some charset encoding other than US-ASCII for serialized data:
+ add a new var to both objects, and lots of parameters to function calls
+ that took none up to now;
+ refactored server method service() and parseRequest(), implementing a
+ new parserequestHeaders() method to explicitly deal with HTTP
+
+2005-12-01 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * moved the jsonrpc implementation and the new wsdl stuff to a separate
+ CVS module; updated the makefile to reflect it
+
+2005-11-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * modified php_xmlrpc_decode() to work on xmlrpcmessages too, besides
+ xmlrpcvals. To achieve this, added a new method: xmlrpcmsg::kindOf()
+
+2005-11-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * released as 2.0 RC2
+
+2005-11-21 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix warnings about references for PHP 4.1.X
+
+ * Whitespace cleanup on all the lib
+
+2005-11-16 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: rewritten xmlrpc_encode_entitites adding two extra parameters
+ that specify input and output charset encodings. This corrects the bug that
+ prevented native UTF-8 strings to be correctly serialized (to have them
+ encoded the user must set $xmlrpc_internalencoing appropriately).
+
+ * xmlrpc.inc: added new method xmlrpcmsg::parseResponseHeaders(), refactoring
+ parseResponse(). This makes the code more modular and eases subclassing.
+
+ * xmlrpc.inc: set cookies and http headers to xmlrpcresp objs even when calls
+ to send() do not complete correctly
+
+ * added new file: jsonrpcs.inc, to accomodate server jsonrpc objects in the future
+
+ * jsonrpc.inc: slow progress...
+
+2005-11-10 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed the xmlrpc_client send and sendpayloadhttps methods
+ to fix errors in calling https servers;
+ added a new xmlrpc_client->setkey method to allow usage of client-side ssl
+ certs in recent php builds;
+ added to xmlrpcresp objects a content_type var, to be used in HTTP headers
+
+ * xmlrpcs.inc: separate generation of content-type http header and xml prologue
+ from the service() method, to ease subclassing
+
+2005-11-03 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: moved the 'text/xml' mimetype string as class var of the xmlrpcmsg
+ object instead of having it cabled into xmlrpc_client->send(): this allows to
+ create subclasses of xmlrpcmsg that use a different mimetype
+
+ * jsonrpc.inc: added a new file, with an extremely experimental set of classes,
+ designed to implement a json-rpc client and server, taking advantage of the
+ existing xml-rpc infrastructure
+
+2005-10-28 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: changed constructor method for xmlrpcresp, making it smarter in
+ case user does not declare the type of value it is passing to it;
+ minor changes in serialization of xmlrpcresp with error codes, so that it
+ utputs LF instead of CRLF on windows boxes after an FTP transfer of the code, too
+
+2005-10-26 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: added a new var of class xmlrpc_client, indicating what kind of
+ object will be stored in the value() of xmlrpcresp's gotten from the send()
+ method: xmlrpxc objects, plain php variables or raw xml. This allow the coder
+ to make use of xmlrpc_decode for better performances if he wishes so.
+ Modified creator of xmlrpcresp class to allow it to distinguish between being
+ created out of raw xml or a plain php string (in the former case, serialization
+ is still possible, opening a new world of opportunity for server-side programming:
+ the php function implementing a web service has to provide the xml for the
+ return value on its own).
+ Modified xmlrpc_client::multicall() to suit; also added a new parameter which
+ allows calls to multicall without automatic fallback to many-calls in case of
+ error (speeding up the process of doing a failed multicall() call quite a bit)
+ Fixed two bugs in guess_encoding.
+ Audited all regexps and fixed some.
+ xmlrpc_client::send() does not call xmlrpcmsg::parseresponsefile() anymore.
+ Shuffled parseresponse() a little bit
+
+ * testsuite.php: added a new testcase for the modifications to multicall():
+ now we test the case where xmlrpc_client returns php values, too
+
+2005-10-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed guess_encoding() to always return uppercase chars
+
+ * added new file: benchmark.php. It contains a few tests used to evaluate
+ speed of the lib in common use cases
+
+ * added file parse_args.php, containing common code for benchmark and
+ testsuite, and modified testsuite.php accordingly
+
+ * modified makefile adding new files
+
+ * testsuite.php: added a couple of new test cases; fixed one warning
+ emitted in php 5 E_STRICT mode
+
+2005-10-20 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: modify 3d param of ParseResponse(), allowing the function to
+ return the raw xml received as value of the xmlrpcresponse object.
+ This allows eg. to have epi-xmlrpc decode the xml for faster execution.
+
+2005-10-09 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed error that prevented usage of HTTPS (the client
+ always determined that ssl support was not present)
+
+2005-10-03 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc, xmlrpcs.inc: revert direction of stack growth during xml
+ parsing for faster execution time; add support for detecting charset
+ encoding of received xml; add support for cookies; better parsing of
+ javadoc when building stub code in wrap_php_function; add a lot of
+ javadoc comments everywhere; rewrite most error messages
+
+ * testsuite.php: add many tests for newly introduced features
+
+ * server.php: add a couple of new functions to support debugging new
+ features
+
+ * debugger: add switches to enable all the latest lib features; minor
+ improvements to layout
+
+ * synch included phpunit with latest PEAR release
+
+ * reorganize files included in the distribution in a new hierarchy of folders
+
+ * bump revision number to 2.0RC1 and release
+
+2005-8-14 Miles Lott <milos@groupwhere.org>
+
+ * xmlrpc.inc, xmlrpcs.inc: Remove all use of eval() to avoid potential
+ security hole.
+
+ * As of this release we are no longer php3-compatible.
+
+2005-8-10 Miles Lott <milos@groupwhere.org>
+
+ * xmlrpc.inc, xmlrpcs.inc: Switched to using $GLOBALS instead of calling
+ global $varname
+
+2005-07-22 Miles Lott <milos@groupwhere.org>
+
+ * Removed: bug_* files
+
+2005-07-14 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * debugger: added a workaround to disable using the debugger for attacking
+ older versions of the lib
+
+ * testsuite.php: added code to test wrap_xmlrpc_method;
+ use different wording for failed tests
+
+ * xmlrpcs.inc: change for() with foreach() in system.* methods implementations;
+ remove a possible cause of php warning;
+
+ * xmlrpc.inc: let wrap_php_function and wrap_xmlrpc_method find suitable
+ function names if default function names are already in use;
+ correct wrap_xmlrpc_method to not set http protocol to 1.0 when not asked to;
+ detect curl compiles without SSL
+
+2005-07-14 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: more auto-fix of xmlrpc_client path: '' -> '/';
+ change to the method used for detecting failed evals (php 4.0.x compatibility);
+ complete rework of return-by-ref functions to comply with php 4.4.0
+
+ * xmlrpcs.inc: change to the method used for detecting failed evals (php 4.0.x
+ compatibility)
+
+ * testsuite.php: major rewrite of the multi- tests, to give better feedback on
+ number of failed tests;
+ flush html page title to screen before starting tests;
+
+2005-07-13 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: let xmlrpcmsg creator be forgiving of target paths that miss the
+ starting '/' char;
+ completely reworked assign-by-ref to be compliant with php 4.4.0 stricter
+ warnings
+
+ * testsuite.php: added ability to be run from cli: (really dumb) separation of
+ html and plain text outputs + parsing of argv parameters
+
+2005-07-12 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: compatibility fixes with PHP versions 4.0.x (and remove some for
+ PHP 3)
+
+ * xmlrpcs.inc: compatibility fixes for PHP 4.0.x versions
+
+ * testsuite.php: better support for running with php versions 4.0.x;
+ do not generate runtime errors but finish tests anyway if some calls to
+ localhost fail;
+ correctly detect a localhost port different from 80 for running tests against
+
+2005-07-11 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: preliminary building of method signature and docs in
+ wrap_php_function;
+ fix a bug in extracting function description from javadoc block in
+ wrap_php_function;
+ small fix for better compatibility with php < 4.2.0
+
+ * added compat subdir with extra code, taken form PEAR package Compat, to let
+ the lib run fine with php 4 versions < 4.1
+
+2005-07-10 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: some nazi whitespace corrections;
+ declared global $xmlrpcBoolean too (was the only one missing);
+ used @eval inside getval() to have less path disclosure security reports filed
+ in the future;
+ added new global var: $xmlrpcValue, to be used in server dispatch maps as
+ placeholder for a param which can be of any kind;
+ big chunks (but still incomplete) of javadoc parsing in wrap_php_function
+ + changed type of return val - now it is the complete array to be put in the
+ dispatch map
+
+ * xmlrpcs.inc: let previous error handler be called by server to handle errors
+ even if in debug level 3;
+ default to compress responses if zlib installed;
+ added a new val useful for only checking number (not type) of params in method
+ calls;
+ let user use object methods in dispatch map using the
+ array($obj, 'fmethodname') format
+
+ * server.php: Added code called by testsuite.php to exercise registration of
+ object methods as xmlrpc methods and auto-registration of php functions as xmlrpc
+ methods
+
+ * testsuite.php: added tests to exercice server registering object methods as
+ xmlrpc methods and automatic registration of php functions as server methods;
+ added a hint to enable debug if some test goes wrong;
+ renamed https test for better clarity
+
+2005-07-07 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: added function to be used for 'guestimating' charset encoding of
+ received xml (not activated yet)
+
+ * server.php: Let server compress content by default if user asks so: it allows
+ testsuite to check for compressed responses
+
+ * testsuite.php: added suite of tests for compressed responses; test CURL
+ (http1.1) with all possible compression combinations too
+
+2005-07-06 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: Enable setting usage of keepalives on/off (for CURL cases);
+ implement compression of xmlrpc requests; enable new syntax of xmlrpclient
+ constructor: 1 - allow preferred http method to be set at creation time,
+ 2 - allow user to insert a single complete URL as only parameter and parse it;
+ try to detect if curl is present whether it has been compiled w. zlib to enable
+ automatically the reception of compressed responses
+
+ * xmlrpcs.inc: do not add into logs the content of the request, if it was
+ received gzipped/deflated, to avoid breaking the xml sent back as response
+ (NB: might be investigated further: is the problem caused by windows chars in
+ the range 128-160 ?)
+
+ * testsuite.php: run all localhost tests 2 more times, to stress request
+ compression;
+ run all localhost tests in a row using keepalives, to test keepalive
+ functionality
+
+2005-07-05 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: let CURL pass back to caller function the complete PHP headers
+ as it did before: it enables better logging / debugging of communication;
+ small change to the way CURL declares its ability to receive compressed
+ messages (fix for the case where zlib is compiled in PHP but not in curl);
+ added Keep-alive (ON BY DEFAULT) for http 1.1 and https messages (had to modify
+ a lot of functions for that);
+ always make sure a 'Connection: close' header is sent with curl connections if
+ keep-alive is not wanted
+
+ * phpunit.php: switched to PEAR PHPUnit (rel 1.2.3), since it is maintained a
+ lot more than the old version we were using
+
+ * added new folder with code of phpunit classes
+
+ * testsuite.php: added a new run of tests to check for compliance of client
+ when using http 1.1;
+ switched to PEAR PHPUnit classes;
+ divided test for client ability to do multicall() into 2 separate tests
+
+2005-06-30 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ tagged and released version 1.1.1, backporting security fixes from HEAD
+
+2005-06-28 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: fix changes introuced yesterday in a rush;
+ do not list system.* methods for a server that has them explicitly disabled
+
+ * bug_inject.xml: new test case used to check for code injection vulnerability
+
+ * testsuite.php: added a test case for zero parameters method calls;
+ added two test cases for recently found code injection vulnerabilities
+
+2005-06-27 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: (tentative) fix for security problem reported by
+ security@gulftech.org: we were not properly php-escaping xml received for
+ BASE64 and NAME tags;
+ some more patching related to junk received in xml messages/responses: if the
+ PHP code built from the parsed xml is broken, catch any generated errors
+ without echoing it to screen but take note of the error and propagate to user
+ code
+
+ * xmlrpcs.inc: some more patching related to junk received in xml messages/
+ responses: if the PHP code built from the parsed xml is broken, catch any
+ generated errors without echoing it to screen but take note of the error and
+ propagate to user code
+
+2005-06-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed php_xmlrpc_encode detection of php arrays (again!);
+ removed from wrap_php_function the part about setting a custom error handler
+ (it can be activated using the more general $server->setdebug(3) anyway)
+
+ * xmlrpcs.inc: added to server the capability to trap all processing errors
+ during execution of user functions and add them to debug info inside responses;
+ return a (new) xmlrpcerr response instead of raising some obscure php execution
+ error if there is an undefined function in the dispatch map
+
+ * testsuite.php: Added new testcases for recently implemented stuff
+
+2005-06-23 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: added new method: xmlrpcval->structmemexists, to check for
+ presence of a wanted struct member without having to loop through all members;
+ fix wrap_php_functions: correctly return false for php internal functions,
+ whose param list is unknown;
+ let addscalar fail as it should if called on struct vals;
+ fix addstruct: do not fail when called for adding stuff to initialized structs;
+ removed a warning generated when calling addscalar with inexistent type;
+ massive code review for speed: replaced each() loops with foreach(), removed
+ lots of useless assignments and duplications of data;
+ added 'http11' as valid method param for xmlrpclient->send: makes use of curl
+ for sending http 1.1 requests;
+ changed a couple '=' into '=&' where objects are returned;
+ fixed wrap_php_function() to better detect php errors while processing wrapped
+ function
+
+ * xmlrpcs.inc: Fix php warnings generated when clients requested method
+ signature / description for a method that had none in its dispatch map;
+ turned server->debug into an integer value that will change the amount of
+ logging going as comments into xmlrpc responses
+
+ * server.php: set default server debug level to 2
+
+ * testsuite.php: removed calls to deleted functions (xmlrpc_encode,
+ xmlrpc_decode);
+ added html page title describing target servers used for tests;
+ added an assign-by-ref
+
+ * phpunit.php: Do not consider as failures PHP 5 E_STRICT errors (arbitrary
+ choice, but lib is targeted at PHP 4)
+
+2005-06-22 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: removed lottsa old code that had been left in commented
+
+ * xmlrpc.inc: fixed setting of proxy port
+
+ * xmlrpc.inc: removed one warning when trying to decompress junk sent as
+ deflated response
+
+ * xmlrpc.inc: changed the error messages (but not the code) that will be found
+ in xmlrpcresponses when there are socket errors, to differentiate from HTTP
+ errors
+
+ * xmlrpc.inc: refactored xmlrpcclient->sendpayloadHTTPS: now it calls a new
+ method (sendpayloadCURL) that could be used also for generating HTTP 1.1
+ requests
+
+ * xmlrpc.inc: added two new methods: wrap_php_function and wrap_xmlrpc_method:
+ designed to let the lazy programmer automagically convert php functions to
+ xmlrpc methods and vice versa. Details are in the code
+
+ * debugger/*: added initial revision of a 'universal xmlrpc debugger'
+
+2005-06-20 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: replace usage of 'echo' with error_log when errors arise
+ in manipulation of xmlrpcval objects
+
+ * xmlrpc.inc: replaced <br> with <br /> in dump function
+
+ * xmlrpc.inc: added method structsize to xmlrpcval class (alias for arraysize)
+
+ * xmlrpc.inc: addarray() now will add extra members to an xmlrpcval object
+ of array type; addstruct() can be used to add members to an xmlrpcval object
+ of struct type
+
+ * xmlrpcs.inc: Added member allow_system_funcs to server: controls whether the
+ server accepts or not calls to system.* functions
+
+2005-05-10 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fix regression in php_xmlrpc_encode when encoding php hashes;
+ fix decompression of gzip/deflated xmlrpc responses;
+ set user agent string correctly in SSL mode (was forgetting lib name);
+ add allowed encoding http headers in requests;
+ do not pass http headers back from curl to parseresponse, to avoid re-decoding
+ compressed xml or http 100 headers
+
+ * xmlrpcs.inc: added method setDebug;
+ renamed compress_output to compress_response;
+ do not try to set http headers if they have already been sent, because trying
+ to do so will raise a PHP error, and if headers have been sent something has
+ gone wrong already (shall we send a meaningful error response instead?)
+
+2005-05-08 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc, xmlrpcs.inc: reverted to usage of '=& new' for better
+ performance on (some) php4 installs.
+ NB: PHP 3 compatibility is deprecated from now on!
+
+ * xmlrpc.inc: decode xmlrpc boolean type to native php boolean
+
+ * xmlrpcs.inc, xmlrpcs.inc: switched $_xh[$parser] to $_xh, since indexing
+ an array by object will give a warning in php 5 (and we were resetting the
+ array of _xh elements on every call anyway)
+
+ * xmlrpc.inc: commented unused code used originally for escaping content
+
+ * xmlrpc.inc: commented deprecated methods xmlrpc_encode and xmlrpc_decode
+
+ * xmlrpc.inc: php_xmlrpc_encode: encode integer-indexed php arrays as xmlrpc
+ arrays instead of structs; if object given to encode is an xmlrpcval return it
+ instead of reencoding (makes easier calling encode on an array of xmlrpcvals)
+
+ * xmlrpcs.inc: added $debug field to server class; if false will prevent
+ the server from echoing debug info back to the client as xml comment
+
+ * xmlrpcs.inc: let the server add to the debug messages the complete request
+ payload received and (if php installed as apache module) http headers, so that
+ the client in debug mode can echo a complete fingerprint of the communication
+
+ * xmlrpcs.inc: changed API of ParseRequest method: now it cannot be called
+ without a 'data' parameter; added 2nd parameter (http encoding); changed the
+ call to this method from inside service() method
+
+ * xmlrpc.inc, xmlrpcs.inc: enable both server and client to parse compressed xml
+ (if php is compiled with zlib); client should also be able to decode chunked
+ http encoding
+
+ * xmlrpc.inc: add support for proxies (only basic auth supported); default port
+ is 8080 (if left unspecified)
+
+ * xmlrpc.inc: use lowercase for names of http headers received (makes using
+ them much simpler, since servers can use any upper/lowercase combination)
+
+ * xmlrpc.inc: bumped version number to '2.0 beta'
+
+2005-05-08 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * release of version 1.1
+
+2005-04-24 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: removed charset declaration from xml prologue of responses,
+ since we are now escaping all non-ascii chars in an encoding-independent way
+
+ * bug_http.xml: modified to exercise some extra functonality of the lib
+ (it should now be failed by the current PEAR implementation of the lib)
+
+ * xmlrpc.inc: bumped up rev. number to 1.1
+
+ * doc/xmlrpc_php.xml, doc/announce1_1.txt: documentation updates
+
+ * Makefile: updated to reflect new xml doc source, modified filelist
+
+2005-04-17 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * client.php, agesort.php, introspect.php, introspect_demo.php,
+ which.php, test.pl, test.py: use as default target the server.php page hosted
+ on phpxmlrpc.sf.net
+
+ * server.php: fix for register_globals off; refer to docs on phpxmlrpc.sf.net
+
+2005-04-15 Miles Lott <milos@groupwhere.org>
+
+ code formatting and comments
+
+2005-04-03 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: make use of global var $xmlrpcName in building User_Agent HTTP
+ header (in conjunction with $xmlrpcVersion)
+
+ * agesort.php, client.php, comment.php, dicuss.php, mail.php, server.php,
+ which.php: various janitorial fixes
+ + always html escape content received from xmlrpc server or from user input
+ + make the scripts run fine with register_globals off an register_long_arrays off
+ + always use the functions php_xmlrpc_en(de)code, even if the EPI extension
+ is not installed
+ + in mail.php, allow user to see script source even if support for .phps files
+ is not configured in the local web server
+
+ * testsuite.php: better detection of local webserver hostname for running tests
+ against (if the user did not supply a webserver name)
+
+2005-03-21 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: revert to a PHP3 compatible script (change '=& new' to '= new')
+
+ * xmlrpc.inc: revert to a PHP3 compatible script (lottsa fixes)
+
+ * testsuite.php: default to using local server as test target if no user
+ provided values are available instead of heddley.com server
+
+ * testsuite.php: play nice to PHP3 in retrieving user-passed values
+
+ * testsuite.php: fix constructor method name for a type of tests
+
+ * phpunit.php: fix all cases of call-time-pass-by-ref
+
+ * phpunit.php: rename Exception class to _Exception if the script is run with
+ PHP 5 (exception is a reserverd word)
+
+2005-03-19 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed bug in new http header parsing code in case there is
+ no correct separator between response headers and body
+
+ * xmlrpc.inc: added recognizing and stripping of HTTP/1.1 100 response headers
+
+ * xmlrpc.inc: strip extra whitespace from response body, as well as any junk
+ that comes after the last </MethodResponse> tag. It allows the server code to
+ be put on public providers that add e.g. javascript advertising to served pages
+
+ * xmlrpc.inc: removed unused parts of code, trailing whitespace
+
+ * xmlrpc.inc: fix possible bug (?) in xmlrpc_ee for BOOLEAN values: true was
+ being handled differently than false
+
+ * testsuite.php: added a new file-based test to stress the response parsing
+ modifications recently introduced; enabled debugging for file based tests
+
+2005-03-15 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: fixed missing declaration of global vars in xmlrpc_dh,
+ sendpayloadhttps and sendpayloadhttp10
+
+ * xmlrpc.inc: changed error message for invalid responses: 'enable debugging'
+ is more clear that 'enabling debugging' (the user is being encouraged to do it)
+
+ * xmlrpc.inc: rewrote HTTP response header parsing. It should be more tolerant
+ of invalid headers, give more accurate error messages and be marginally faster,
+ too.
+
+ * xmlrpc.inc: cosmetic whitespace fixes and remove useless one-liners
+
+ * xmlrpc.inc: build a shorter PHP command line to be evaluated for rebuilding
+ values from parsed xml: use '$val =& nex xmlrpcval("value")' for string values
+ instead of '$val =& nex xmlrpcval("value", $xmlrpcString)'
+
+ * xmlrpc.inc: fix change introduced 2005/01/30 moving call to curl_close()
+ too early: it did not work on error situations
+
+ * testsuite.php: fix name of testAddingTest method, renamed testErrosString
+ into testErrorString and removed useless warning for register_globals=off case
+
+2005-02-27 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: do not echo XML parsing error to screen (it is already dumped
+ into error log)
+
+ * xmlrpc.inc: set hdrs field into response object in case of XML parsing error
+ (uniform behaviour with other responses)
+
+2005-02-26 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: use global var $xmlrpcVersion as number for user agent string
+
+ * xmlrpcs.inc: eliminate server side PHP warning and give back to caller
+ a better error msg in case the called method exists but no signature matches
+ the number of parameters
+
+2005-02-20 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: accept a + sign in front of floats / integers, since the spec
+ clearly mentions it
+
+ * xmlrpc.inc, xmlrpcs.inc: renamed function XmlEntities to xmlrpc_encode_entitites,
+ to avoid using the same name as an array already defined
+
+ * xmlrpc.inc: fix bug introduced with escaping of UTF8 chars in xmlrpc error
+ responses: correct behaviour is to escape chars inside serialize(), not when
+ calling the xmlrpcresp creator
+
+ * testsuite.php: made test suite more friendly to modern PHP configs, allowing
+ register_globals to be off and to set in the URL all testing parameters;
+ added tests for newly introduced fixes; renamed existing tests acording to the
+ docs inside phpunit.php (e.g. no subclass of TestCase should have a name
+ starting with test...)
+
+2005-02-19 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: accept patch 683153 by mah0: if timeout is set, allow all socket
+ operations to timeout at the given time, not only the socket connection
+
+2005-02-13 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: be tolerant to double values received in exponential notation:
+ even though the spec forbids their usage PHP is fine with them
+
+ * xmlrpc.inc: fix bug: new xmlrpcval('-1') was creating an empty value instead
+ of a string value!
+
+ * xmlrpc.inc, xmlrpcs.inc: fix the payload encoding changes introduced by
+ Andres Salomon on 2004-03-17: sending named html entities inside an xml chunk
+ makes it invalid, and thus renders the lib absolutely non-interoperable with
+ any other xmlrpc implementation; moreover the current implementation only ever
+ worked for non-ascii requests, while breaking client-parsing of responses
+ containing non-ascii chars.
+ The principle of using entities is preserved though, because it allows the
+ client to send correct xml regardless of php internal charset encoding vs.
+ xml request charset encoding, but using 'character references' instead.
+
+ * xmlrpc.inc: encode (non-ascii) chars into charset entities also for error
+ strings
+
+ * xmlrpcs.inc: encode (non-ascii) chars into charset entities also for debug
+ messages
+
+ * xmlrpcs.inc: added 'Accept-Charset' header in http request to let the server
+ know what kind of charset encoding we do expect to be used for responses
+
+ * xmlrpc.inc, xmlrpcs.inc: explicitly tell the xml parser what charset the
+ application expects to receive content in (notably strings). A new variable,
+ $xmlrpc_internalencoding, (defaulting to ISO-8859-1) defines what charset the
+ parser will use for passing back string xmlrpcvals to the PHP application
+ (both server-side and client-side).
+ This allows transparent usage of e.g. UTF-8 for encoding xml messages between
+ server and client and ISO-8859-1 for internal string handling.
+ ISO-8859-1 is, AFAIK, PHP internal encoding for all installs except
+ mbstring-enabled ones.
+
+2005-02-12 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpcs.inc: use '$var =& new(' construct to assign objects: on older versions
+ of PHP objects are first built then copied over if the ampersand is omitted.
+ Using it should make the code a little bit faster...
+
+ * doc/xmlrpc.php: update lib version number, release date in preparation for
+ next release
+
+ * makefile: update lib version number in preparation for next release
+
+ * xmlrpc.inc: split up parsing of xmlrpc INT and DOUBLE values. This allows
+ finer-grained control over valid values: now the '.' char is not allowed
+ any more inside int values.
+
+ * xmlrpc.inc: fix for bug #560303: ints and doubles starting with '0' chars are
+ no more parsed as octal values
+
+2005-01-30 Gaetano Giunta <giunta.gaetano@gmail.com>
+
+ * xmlrpc.inc: Modifed last change by Miles: the functions php_xmlrpc_encode
+ and php_xmlrpc_decode are now always defined, regardless of the existence of
+ XMLRPC-EPI. This allows users to start using these functions as the 'default'
+ functions, and pave the way for future deprecation of xmlrpc_encode/encode
+ while maintaining a stable API.
+
+ * xmlrpc.inc: use '$var =& new(' construct to assign objects: on older versions
+ of PHP objects are first built then copied over if the ampersand is omitted.
+ Using it should make the code a little bit faster...
+
+ * xmlrpc.inc: close curl connection as soon as possible for https requests:
+ it could save some memory / resources.
+
+ * xmlrpc.inc: added some extra info in the PHP error log message generated
+ when an invalid xmlrpc integer/float value is encountered and we try to
+ deserialize it.
+
+ * xmlrpc.inc: added @ char before fsockopen to avoid echoing useless warnings
+ when connection to server fails; added the same to avoid echoing warnings when
+ deserializing data of an unknown type
+
+ * xmlrpc.inc: reset the _xh array on each xmlrpc call: otherwise a new array
+ member is created for each consecutive call and never destroyed, thus making it
+ impossible to build an xmlrpc-client daemon beacuse of memory leaking.
+
+ * xmlrpc.inc: declare global the variables that are used as 'constants',
+ so that xmlrpc.inc will work even if it is included from within a function
+
+2004-12-27 Miles Lott <milos@groupwhere.org>
+ * xmlrpc.inc: A new constant, XMLRPC_EPI_ENABLED, is defined depending on
+ the existence of the function, xmlrpc_decode. This function will exist in
+ PHP if the extension, XMLRPC-EPI (http://xmlrpc-epi.sourceforge.net), is
+ loaded. It defines the functions xmlrpc_encode and xmlrpc_decode, which
+ will conflict with functions of the same name in xmlrpc.inc. If this
+ extension is loaded, we instead use the names php_xmlrpc_encode and
+ php_xmlrpc_decode. Please look at server.php, testsuite.php, etc., for
+ how this should be handled if using these functions.
+
+2003-04-17 Andres Salomon <dilinger@voxel.net>
+ * xmlrpc.inc: encode strings using htmlentities() instead of
+ htmlspecialchars(), and add xmlrpc_html_entity_xlate(). This
+ should fix longstanding issues with sending weird chars (from
+ non-USASCII codesets like UTF-8, ISO-8859-1, etc) that caused
+ the xml parser to choke. Multi-byte chars are now changed to
+ entities before sending, so that the xmlrpc server doesn't need
+ to know the encoding type of the POST data.
+ * xmlrpcs.inc: call xmlrpc_html_entity_xlate before parsing
+ request packet. The parser chokes on unknown entities (the
+ entities created by htmlentities() are exactly that; html
+ entities, not xml entities), so they must be converted from
+ name form (é) to numerical form (é).
+
+2003-01-12 Andres Salomon <dilinger@voxel.net>
+
+ * released 1.0.99.2.
+ * Makefile: separate doc/Makefile a bit more from Makefile,
+ and add clean rules.
+
+2003-01-10 Andres Salomon <dilinger@voxel.net>
+
+ * xmlrpc.inc: xmlrpcresp and parseResponse cleanups; variable
+ name renames ('xv' to 'val', for example), type checking, and
+ stricter default values.
+ * xmlrpc.inc: fix xmlrpcresp's faultcode; return -1 for FAULT
+ responses from the server whose faultcodes don't reflect any
+ errors.
+
+2003-01-08 Andres Salomon <dilinger@voxel.net>
+
+ * xmlrpc.inc: rename $_xh[$parser]['ha'] to
+ $_xh[$parser]['headers'].
+ * xmlrpc.inc: fix bugs related to $_xh[$parser]['headers];
+ some places treated this as an array, others as a scalar.
+ Treat unconditionally as an array. Also wrap header debugging
+ output in PRE tags.
+
+2002-12-17 Andres Salomon <dilinger@voxel.net>
+
+ * released 1.0.99.
+ * Makefile: changed the tarball format/dist rule to a more
+ conventional form, as well as normal release updates.
+ * xmlrpc.inc: added setSSLVerifyPeer and setSSLVerifyHost; as
+ of curl 7.10, various certificate checks are done (by default).
+ The default for CURLOPT_SSL_VERIFYHOST is to ensure the common
+ name on the cert matches the provided hostname. This breaks a
+ lot of stuff, so allow users to override it.
+ * doc/xmlrpc_php.sgml: updated documentation accordingly.
+
+2002-09-06 Geoffrey T. Dairiki <dairiki@dairiki.org>
+
+ Add support for system.multicall() to both the client
+ and the server.
+
+ * testsuite.php: Add new tests 'testServerMulticall',
+ and 'testClientMulticall'.
+
+ * xmlrpc.inc: Added new error messages for system.multicall().
+ * xmlrpcs.inc: Added new procedure call system.multicall().
+ See http://www.xmlrpc.com/discuss/msgReader$1208 for details.
+
+ * xmlrpc.inc: Added system.multicall functionality to
+ xmlrpc_client. xmlrpc_client::send can now take an array of
+ xmlrpcmsg's as an argument. In that case it will attempt
+ to execute the whole array of procure calls in a single
+ HTTP request using system.multicall(). (If that attempt fails,
+ then the calls will be excuted one at a time.) The return
+ value will be an array of xmlrpcresp's (or 0 upon transport
+ failure.)
+
+2001-11-29 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpc.inc: fixed problem with processing HTTP headers that
+ broke any payload with more than one consecutive newline in it.
+ also initialise the 'ac' array member to empty string at start.
+ * testsuite.php: added unit test to exercise above bug
+ * xmlrpcs.inc: fixed uninitialized variable $plist
+
+2001-09-25 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpc.inc: applied urgent security fixes as identified by Dan
+ Libby
+
+2001-08-27 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpc.inc: Merged in HTTPS support from Justin Miller, with a
+ few additions for better traceability of failure conditions. Added
+ small fix from Giancarlo Pinerolo. Bumped rev to 1.0. Changed
+ license to BSD license.
+
+2001-06-15 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpcs.inc: Added \r into return MIME headers for server class
+
+2001-04-25 Edd Dumbill <edd@usefulinc.com>
+
+ * server.php: Added interop suite of methods.
+
+2001-04-24 Edd Dumbill <edd@usefulinc.com>
+
+ * testsuite.php: added in test case for string handling bug.
+
+ * xmlrpc.inc: merged in minor fixes from G Giunta to fix
+ noninitialization. Created new method, getval(), which includes
+ experimental support for recreating nested arrays, from Giunta and
+ Sofer. Fixed string handling bug where characters after </string>
+ but before </value> weren't ignored. Added in support for native
+ boolean type into xmlrpc_encode (Giunta).
+
+ * xmlrpcs.inc: updated copyright notice
+
+2001-01-15 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpc.inc: fixed bug with creation of booleans. Put checks in
+ to ensure that numbers were really numeric. Fixed bug with
+ non-escaping of dollar signs in strings.
+
+ * testsuite.php: created test suite.
+
+2000-08-26 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpcs.inc: added xmlrpc_debugmsg() function which outputs
+ debug information in comments inside the return payload XML
+
+ * xmlrpc.inc: merged in some changes from Dan Libby which fix up
+ whitespace handling.
+
+ * xmlrpcs.inc: added Content-length header on response (bug from
+ Jan Varga <varga@utcru.sk>. This means you can no longer print
+ during processing
+
+ * xmlrpc.inc: changed ereg_replace to str_replace in several
+ places (thanks to Dan Libby <dan@libby.com> for this).
+
+ * xmlrpc.inc: added xmlrpc_encode() and xmlrpc_decode() from Dan
+ Libby--these helper routines make it easier to work in native PHP
+ data structures.
+
+2000-07-21 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpc.inc: added xmlrpc_client::setCredentials method to pass
+ in authorization information, and modified sendPayload* methods to
+ send this OK. Thanks to Grant Rauscher for the impetus to do this.
+ Also, made the client send empty <params></params> if there are no
+ parameters set by the user.
+
+ * doc/xmlrpc_php.sgml: updated documentation to reflect recent
+ changes
+
+
+2000-07-18 Edd Dumbill <edd@usefulinc.com>
+
+ * server.php: added examples.invertBooleans method to server as a
+ useful test method for boolean values.
+
+ * xmlrpc.inc: rearranged the way booleans are handled to fix
+ outstanding problems. Fixed calling addScalar() on arrays so it
+ works. Finally fixed backslashification issues to remove the
+ problem will dollar signs disappearing.
+
+ * booltest.php: really fixed booleans this time.
+
+2000-06-03 Edd Dumbill <edd@usefulinc.com>
+
+ * xmlrpcs.inc: made signature verification more useful - now
+ returns what it found was wrong
+
+ * xmlrpc.inc: fixed bug with decoding dateTimes. Also fixed a bug
+ which meant a PHP syntax error happened when attempting to receive
+ empty arrays or structs. Also fixed bug with booleans always being
+ interpreted as 'true'.
+
+ * server.php: Added validator1 suite of tests to test against
+ validator.xmlrpc.com
+
+
+2000-05-06 Edd Dumbill <edd@usefulinc.com>
+
+ * released 1.0b6
+
+ * added test.pl and test.py, Perl and Python scripts that exercise
+ server.php somewhat (but not a lot)
+
+ * added extra fault condition for a non 200 OK response from the
+ remote server.
+
+ * added iso8601_encode() and iso8601_decode() to give some support
+ for passing dates around. They translate to and from UNIX
+ timestamps. Updated documentation accordingly.
+
+ * fixed string backslashification -- was previously a little
+ overzealous! new behavior is '\' --> '\\' and '"' -->
+ '\"'. Everything else gets left alone.
+
+2000-04-12 Edd Dumbill <edd@usefulinc.com>
+
+ * updated and bugfixed the documentation
+
+ * fixed base 64 encoding to only happen at serialize() time,
+ rather than when a base64 value is created. This fixes the double
+ encoding bug reported by Nicolay Mausz
+ <castor@flying-dog.com>. The same approach ought to be taken with
+ encoding XML entities in the data - this is a TODO.
+
+ * integrated further code from Peter Kocks: used his new code for
+ send(), adding a second, optional, parameter which is a timeout
+ parameter to fsockopen()
+
+1999-10-11 Edd Dumbill <edd@usefulinc.com>
+
+ * added bug fixes from Peter Kocks <peter.kocks@baygate.com>
+
+1999-10-10 Edd Dumbill <edd@usefulinc.com>
+
+ * updated the documentation
+
+1999-10-08 Edd Dumbill <edd@usefulinc.com>
+
+ * added system.* methods and dispatcher, plus documentation
+
+ * fixed bug which meant request::getNumParams was returning an
+ incorrect value
+
+ * added signatures into the dispatch map. This BREAKS
+ COMPATIBILITY with previous releases of this code
+
+1999-08-18 Edd Dumbill <edd@usefulinc.com>
+
+ * made entity encoding and decoding transparent now on string
+ passing.
+
+ * de-globalised the globals in the parse routines, using an
+ associative array to hold all parser state $_xh
+
+ * changed default input encoding to be UTF-8 to match expectation
+
+ * separated out parseResponse into parseResponse and
+ parseResponseFile so that you can call parseResponse on a string
+ if you have one handy
+
+1999-07-20 Edd Dumbill <edd@usefulinc.com>
+
+ * Moved documentation into Docbook format
+
+1999-07-19 Edd Dumbill <edd@usefulinc.com>
+
+ * Added an echo server into server.php and echotest.php, a client
+ which will exercise the new echo routine.
+
+ * Added test for no valid value returned: in this case will now
+ throw the error "invalid payload"
+
+ * Added serialize() method to xmlrpcresp to return a string with
+ the response serialized as XML
+
+ * Added automatic encoding and decoding for base64 types
+
+ * Added setDebug() method to client to enable HTML output
+ debugging in the client
+
+1999-07-08 Edd Dumbill <edd@usefulinc.com>
+
+ * Improved XML parse error reporting on the server side to send it
+ back in a faultCode packet. expat errors now begin at 100
+
+1999-07-07 Edd Dumbill <edd@usefulinc.com>
+
+ * Changed the structmem and arraymem methods of xmlrpcval to always
+ return xmlrpc vals whether they referred to scalars or complex
+ types.
+
+ * Added the server class and demonstrations
+
+ * Fixed bugs in the XML parsing and reworked it
--- /dev/null
+XMLRPC for PHP
+==============
+
+Requirements
+------------
+
+The following requirements should be met prior to using 'XMLRPC for PHP':
+
+* PHP 5.3.0 or later
+
+* the php "curl" extension is needed if you wish to use SSL or HTTP 1.1 to
+ communicate with remote servers
+
+The php "xmlrpc" native extension is not required, but if it is installed,
+there will be no interference with the operation of this library.
+
+
+Installation instructions
+-------------------------
+
+Installation of the library is quite easy:
+
+1. Via Composer (highly recommended):
+
+ 1. Install composer if you don't have it already present on your system.
+ Depending on how you install, you may end up with a composer.phar file in your directory.
+ In that case, no worries! Just substitute 'php composer.phar' for 'composer' in the commands below.
+
+ 2. If you're creating a new project, create a new empty directory for it.
+
+ 3. Open a terminal and use Composer to grab the library.
+
+ $ composer require phpxmlrpc/phpxmlrpc:4.0
+
+ 4. Write your code.
+ Once Composer has downloaded the component(s), all you need to do is include the vendor/autoload.php file that
+ was generated by Composer. This file takes care of autoloading all of the libraries so that you can use them
+ immediately, including phpxmlrpc:
+
+ // File example: src/script.php
+
+ // update this to the path to the "vendor/" directory, relative to this file
+ require_once __DIR__.'/../vendor/autoload.php';
+
+ use PhpXmlRpc\Value;
+ use PhpXmlRpc\Request;
+ use PhpXmlRpc\Client;
+
+ $client = new Client('http://some/server');
+ $response = $client->send(new Request('method', array(new Value('parameter'))));
+
+ 5. IMPORTANT! Make sure that the vendor/phpxmlrpc directory is not directly accessible from the internet,
+ as leaving it open to access means that any visitor can trigger execution of php code such as
+ the built-in debugger.
+
+
+2. Via manual download and autoload configuration
+
+ 1. copy the contents of the src/ folder to any location required by your
+ application (it can be inside the web server root or not).
+
+ 2. configure your app autoloading mechanism so that all classes in the PhpXmlRpc namespace are loaded
+ from that location: any PSR-4 compliant autoloader can do that, if you don't have any there is one
+ available in src/Autoloader.php
+
+ 3. Write your code.
+
+ // File example: script.php
+
+ require_once __DIR__.'my_autoloader.php';
+
+ use PhpXmlRpc\Value;
+ use PhpXmlRpc\Request;
+ use PhpXmlRpc\Client;
+
+ $client = new Client('http://some/server');
+ $response = $client->send(new Request('method', array(new Value('parameter'))));
+
+ 5. IMPORTANT! Make sure that the vendor/phpxmlrpc directory is not directly accessible from the internet,
+ as leaving it open to access means that any visitor can trigger execution of php code such as
+ the built-in debugger.
+
+Tips
+----
+
+Please note that usage of the 'pake' command is not required for installation of the library.
+At this moment it is only useful to build the html and pdf versions of the documentation, and the tarballs
+for distribution of the library.
--- /dev/null
+XML-RPC for PHP version 4.2.0 - 2017/6/30
+
+* improved: allow a DateTimeImmutable object also be detected as a date when encoding
+
+
+XML-RPC for PHP version 4.1.1 - 2016/10/1
+
+* fixed: error in server class: undefined function php_xmlrpc_encode (only triggered when not using the compatibility
+ shim with old versions)
+
+
+XML-RPC for PHP version 4.1.0 - 2016/6/26
+
+* improved: Added support for receiving <I8> and <EX:I8> integers, sending <I8>
+
+ If php is compiled in 32 bit mode, and an i8 int is received from a 3rd party, and error will be emitted.
+ Integers sent from the library to 3rd parties can be encoded using the i8 tag, but default to using 'int' by default;
+ the developer will have to create values as i8 explicitly if needed.
+ The library does *not* check if an outgoing integer is too big to fit in 4 bytes and convert it to an i8 automatically.
+
+
+XML-RPC for PHP version 4.0.1 - 2016/3/27
+
+* improved: all of the API documentation has been moved out of the manual and into the source code phpdoc comments
+
+* fixed: when the internal character set is set to UTF-8 and the client sends requests (or the server responses), too
+ many characters were encoded as numeric entities, whereas some, like åäö, needed not not be
+
+* fixed: the 'valtyp' property of Response was not present in all cases; the ValType property had been added by error
+ and has been removed
+
+
+XML-RPC for PHP version 4.0.0 - 2016/1/20
+
+This release does away with the past and starts a transition to modern-world php.
+
+Code has been heavily refactored, taking care to preserve backwards compatibility as much as possible,
+but some breackage is to be expected.
+
+The minimum required php version has been increased to 5.3, even though we strongly urge you to use
+more recent versions.
+
+PLEASE READ CAREFULLY THE NOTES BELOW to insure a smooth upgrade.
+
+* new: introduction of namespaces and full OOP.
+
+ All php classes have been renamed and moved to separate files.
+ Class autoloading can now be done in accord with the PSR-4 standard.
+ All global variables and global functions have been removed.
+ Iterating over xmlrpc value objects is now easier thank to support for ArrayAccess and Traversable interfaces.
+
+ Backward compatibility is maintained via lib/xmlrpc.inc, lib/xmlrpcs.inc and lib/xmlrpc_wrappers.inc.
+ For more details, head on to doc/api_changes_v4.md
+
+* changed: the default character encoding delivered from the library to your code is now utf8.
+ It can be changed at any time setting a value to PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding
+
+* improved: the library now accepts requests/responses sent using other character sets than UTF-8/ISO-8859-1/ASCII.
+ This only works when the mbstring php extension is enabled.
+
+* improved: no need to call anymore $client->setSSLVerifyHost(2) to silence a curl warning when using https
+ with recent curl builds
+
+* improved: the xmlrpcval class now supports the interfaces Countable and IteratorAggregate
+
+* improved: a specific option allows users to decide the version of SSL to use for https calls.
+ This is useful f.e. for the testing suite, when the server target of calls has no proper ssl certificate,
+ and the cURL extension has been compiled with GnuTLS (such as on Travis VMs)
+
+* improved: the function wrap_php_function() now can be used to wrap closures (it is now a method btw)
+
+* improved: all wrap_something() functions now return a closure by default instead of a function name
+
+* improved: debug messages are not html-escaped any more when executing from the command line
+
+* improved: the library is now tested using Travis ( https://travis-ci.org/ ).
+ Tests are executed using all php versions from 5.3 to 7.0 nightly, plus HHVM; code-coverage information
+ is generated using php 5.6 and uploaded to both Code Coverage and Scrutinizer online services
+
+* improved: phpunit is now installed via composer, not bundled anymore
+
+* improved: when phpunit is used to generate code-coverage data, the code executed server-side is accounted for
+
+* improved: the test suite has basic checks for the debugger and demo files
+
+* improved: more tests in the test suite
+
+* fixed: the server would not reset the user-set debug messages between subsequent service() calls
+
+* fixed: the server would not reset previous php error handlers when an exception was thrown by user code and
+ exception_handling set to 2
+
+* fixed: the server would fail to decode a request with ISO-8859-1 payload and character set declaration in the xml
+ prolog only
+
+* fixed: the client would fail to decode a response with ISO-8859-1 payload and character set declaration in the xml
+ prolog only
+
+* fixed: the function decode_xml() would not decode an xml with character set declaration in the xml prolog
+
+* fixed: the client can now successfully call methods using ISO-8859-1 or UTF-8 characters in their name
+
+* fixed: the debugger would fail sending a request with ISO-8859-1 payload (it missed the character set declaration).
+ It would have a hard time coping with ISO-8859-1 in other fields, such as e.g. the remote method name
+
+* fixed: the debugger would generate a bad payload via the 'load method synopsis' button for signatures containing NULL
+ or undefined parameters
+
+* fixed: the debugger would generate a bad payload via the 'load method synopsis' button for methods with multiple
+ signatures
+
+* improved: the debugger is displayed using UTF-8, making it more useful to debug any kind of service
+
+* improved: echo all debug messages even when there are characters in them which php deems to be in a wrong encoding;
+ previously those messages would just disappear (this is visible e.g. in the debugger)
+
+* changed: debug info handling
+ - at debug level 1, the rebuilt php objects are not dumped to screen (server-side already did that)
+ - at debug level 1, curl communication info are not dumped to screen
+ - at debug level 1, the tests echo payloads of failures; at debug level 2 all payloads
+
+* improved: makefiles have been replaced with a php_based pakefile
+
+* improved: the source for the manual is stored in asciidoc format, which can be displayed natively by GitHub
+ with nice html formatting. Also the HTML version generated by hand and bundled in tarballs is much nicer
+ to look at than previous versions
+
+* improved: all php code is now formatted according to the PSR-2 standard
+
+
+XML-RPC for PHP version 3.0.0 - 2014/6/15
+
+This release corrects all bugs that have been reported and successfully reproduced since
+version 3.0.0 beta.
+
+The requirements have increased to php 5.1.0 - which is still way older than what you should be running for any serious
+purpose, really.
+
+It also is the first release to be installable via composer.
+
+See the Changelog file or the pdf docs for a complete list of changes.
+
+
+XML-RPC for PHP version 3.0.0 beta - 2009/09/05
+
+This is the first release of the library to only support PHP 5.
+Some legacy code has been removed, and support for features such as exceptions
+and dateTime objects introduced.
+
+The "beta" tag is meant to indicate the fact that the refactoring has been more widespread
+than in precedent releases and that more changes are likely to be introduced with time -
+the library is still considered to be production quality.
+
+* improved: removed all usage of php functions deprecated in php 5.3, usage of assign-by-ref when creating new objects
+ etc...
+* improved: add support for the <ex:nil/> tag used by the apache library, both in input and output
+* improved: add support for dateTime objects in both in php_xmlrpc_encode and as parameter for constructor of xmlrpcval
+* improved: add support for timestamps as parameter for constructor of xmlrpcval
+* improved: add option 'dates_as_objects' to php_xmlrpc_decode to return dateTime objects for xmlrpc datetimes
+* improved: add new method SetCurlOptions to xmrlpc_client to allow extra flexibility in tweaking http config, such as
+ explicitly binding to an ip address
+* improved: add new method SetUserAgent to xmrlpc_client to to allow having different user-agent http headers
+* improved: add a new member variable in server class to allow fine-tuning of the encoding of returned values when the
+ server is in 'phpvals' mode
+* improved: allow servers in 'xmlrpcvals' mode to also register plain php functions by defining them in the dispatch map
+ with an added option
+* improved: catch exceptions thrown during execution of php functions exposed as methods by the server
+* fixed: bad encoding if same object is encoded twice using php_xmlrpc_encode
+
+
+XML-RPC for PHP version 2.2.2 - 2009/03/16
+
+This release corrects all bugs that have been reported and sucesfully reproduced since
+version 2.2.1.
+Regardless of the intimidating message about dropping PHP 4 support, it still does
+support that ancient, broken and insecure platform.
+
+
+* fixed: php warning when receiving 'false' in a bool value
+* fixed: improve robustness of the debugger when parsing weird results from non-compliant servers
+* fixed: format floating point values using the correct decimal separator even when php locale is set to one that uses
+ comma
+* fixed: use feof() to test if socket connections are to be closed instead of the number of bytes read (rare bug when
+ communicating with some servers)
+* fixed: be more tolerant in detection of charset in http headers
+* fixed: fix encoding of UTF8 chars outside of the BMP plane
+* fixed: fix detection of zlib.output_compression
+* improved: allow the add_to_map server method to add docs for single params too
+* improved: added the possibility to wrap for exposure as xmlrpc methods plain php class methods, object methods and
+ even whole classes
+
+
+XML-RPC for PHP version 2.2.1 - 2008/03/06
+
+This release corrects all bugs that have been reported and sucesfully reproduced.
+It is the last release of the library that will support PHP 4.
+
+* fixed: work around bug in php 5.2.2 which broke support of HTTP_RAW_POST_DATA
+* fixed: is_dir parameter of setCaCertificate() method is reversed
+* fixed: a php warning in xmlrpc_client creator method
+* fixed: parsing of '1e+1' as valid float
+* fixed: allow errorlevel 3 to work when prev. error handler was a static method
+* fixed: usage of client::setcookie() for multiple cookies in non-ssl mode
+* improved: support for CP1252 charset is not part or the library but almost possible
+* improved: more info when curl is enabled and debug mode is on
+
+
+XML-RPC for PHP version 2.2 - 2007/02/25
+
+This release corrects a couple of bugs and adds a few minor features.
+
+* fixed: debugger errors on php installs with magic_quotes_gpc on
+* fixed: support for https connections via proxy
+* fixed: wrap_xmlrpc_method() generated code failed to properly encode php objects
+* improved: slightly faster encoding of data which is internally UTF-8
+* improved: debugger always generates a 'null' id for jsonrpc if user omits it
+* new: debugger can take advantage of a graphical value builder
+ (it has to be downloaded separately, as part of jsxmlrpc package)
+* new: support for the <NIL/> xmlrpc extension
+* new: server support for the system.getCapabilities xmlrpc extension
+* new: wrap_xmlrpc_method() accepts two new options: debug and return_on_fault
+
+
+XML-RPC for PHP version 2.1 - 2006/08/28
+
+This release corrects quite a few bugs and adds some interesting new features.
+There is a minor security enhancement and overall speedup too.
+
+It has been tested with PHP 4.0.5 up to 4.4.4 and 5.1.5.
+Please note that 404pl1 is NOT supported, and has not been since 2.0.
+
+*** PLEASE READ CAREFULLY BELOW ***
+
+CHANGES THAT MIGHT AFFECT DEPLOYED APPLICATIONS:
+
+The wrap_php_function and wrap_xmlrpc_method functions have been moved out of
+the base library file xmlrpc.inc into a file of their own: xmlrpc_wrappers.inc.
+You will have to include() / require() it in your scripts if you have been using
+those functions.
+
+For increased security, the automatic rebuilding of php object instances out of
+received xmlrpc structs in wrap_xmlrpc_method() has been disabled (but it can be
+optionally reenabled).
+
+The constructor of xmlrpcval() values has seen major changes, and it will not
+throw a php warning anymore when invoked using an unknown xmlrpc type: the
+error will only be written to php error log. Also new xmlrpcval('true', 'boolean')
+is not supported anymore.
+
+MAJOR IMPROVEMENTS:
+
+The new function php_xmlrpc_decode_xml() will take the xml representation of
+either an xmlrpc request, response or single value and return the corresponding
+php-xmlrpc object instance.
+
+Both wrap_php_function() and wrap_xmlrpc_method() functions accept many more
+options to fine tune their behaviour, including one to return the php code to
+be saved and later used as standalone php script.
+
+A new function wrap_xmlrpc_server() has been added, to wrap all (or some) of the
+methods exposed by a remote xmlrpc server into a php class.
+
+Lib internals have been modified to provide better support for grafting extra
+functionality on top of it. Stay tuned for future releases of the EXTRAS package.
+
+Last but not least a new file has been added: verify_compat.php, to help users
+diagnose the level of compliance of the current php install with the library.
+
+CHANGELOG IN DETAIL:
+
+* fixed bug 1311927: client not playing nice with some proxy/firewall on ports != 80
+* fixed bug 1334340: all ereg_ functions have been replaced with corresponding preg_
+* fixed bug: wrong handling of 'deflate' http encoding, both server and client side
+* fixed bug: sending compressed responses when php output compression is enabled was not working
+* fixed bug: addarray() and addstruct() where not returning 1 when adding data to already initialized values
+* fixed bug: non-ascii chars used in struct element names where not being encoded correctly
+* restored compatibility with php 4.0.5 (for those poor souls still stuck on it)
+* server->service() now returns either the payload or xmlrpcresp instance
+* server->add_to_map() now accepts methods with no param definitions
+* added new function: php_xmlrpc_decode_xml()
+* added new function: wrap_xmlrpc_server()
+* major improvements and security enhancements to wrap_php_function() and wrap_xmlrpc_method()
+* documentation for single parameters of exposed methods can be added to the dispatch map
+ (and turned into html docs in conjunction with a future release of the extras package)
+* full response payload is saved into xmlrpcresp object for further debugging
+* stricter parsing of incoming xmlrpc messages: two more invalid cases are now detected
+ (double data element inside array and struct/array after scalar inside value element)
+* debugger can now generate code that wraps a remote method into php function (works for jsonrpc, too)
+* debugger has better support for being activated via a single GET call (for integration into other tools?)
+* more logging of errors in a lot of situations
+* javadoc documentation of lib files almost complete
+* the usual amount of new testcases in the testsuite
+* many performance tweaks and code cleanups
+* added foundation for emulating the API of the xmlrpc extension (extras package needed)
+
+
+XML-RPC for PHP version 2.0 - 2006/04/24
+
+I'm pleased to announce XML-RPC for PHP version 2.0, final.
+
+With respect to the last release candidate, this release corrects a few small
+bugs and adds a couple of new features: more authentication options (digest and
+ntlm for servers, ntlm for proxies, and some https custom certificates stuff);
+all the examples have been reviewed and some demo files added,
+including a ready-made xmlrpc proxy (useful e.g. for ajax calls, when the xmlrpc
+client is a browser); the server logs more warning messages for incorrect situations;
+both client and server are more tolerant of commonly-found mistakes.
+The debugger has been upgraded to reflect the new client capabilities.
+
+In greater detail:
+
+* fixed bug: method xmlrpcval::structmemexists($value) would not work
+* fixed bug: wrap_xmlrpc_method would fail if invoked with a client object that
+ has return_type=phpvals
+* fixed bug: in case of call to client::multicall without fallback and server error
+* fixed bug: recursive serialization of xmlrpcvals loosing specified UTF8 charset
+* fixed bug: serializing to ISO-8859-1 with php 5 would raise an error if non-ascii
+ chars where found when decoding
+* new: client can use NTLM and Digest authentication methods for https and http 1.1
+ connections; authentication to proxy can be set to NTLM, too
+* new: server tolerates user functions returning a single xmlrpcval object instead
+ of an xmlrpcresp
+* new: server does more checks for presence and correct return type of user
+ coded method handling functions, and logs inconsistencies to php error log
+* new: client method SetCaCertificate($cert, $is_dir) to validate server against
+* new: both server and client tolerate receiving 'true' and 'false' for bool values
+ (which btw are not valid according to the xmlrpc spec)
+
+
+XML-RPC for PHP version 2.0RC3 - 2006/01/22
+
+This release corrects a few bugs and adds some interesting new features.
+It has been tested with PHP up to 4.4.2 and 5.1.2.
+
+* fixed bug: server not recognizing clients that declare support for http compression
+* fixed bug: serialization of new xmlrpcval (8, 'string') when internal encoding
+ set to UTF-8
+* fixed bug: serialization of new xmlrpcval ('hello', 'int') would produce
+ invalid xml-rpc
+* new: let the server accept 'class::method' syntax in the dispatch map
+* new: php_xmlrpc_decode() can decode xmlrpcmessage objects
+* new: both client and server can specify a charset to be used for serializing
+ values instead of the default 'US-ASCII+xml-entities-for-other-characters'.
+ Values allowed: ISO-8859-1 and UTF-8
+* new: the server object can register 'plain' php functions instead of functions
+ that accept a single parameter of type xmlrpcmsg. Faster, uses less memory
+ (but comes with minor drawbacks as well, read the manual for more details)
+* new: client::setDebug(2) can be used to have the request payload printed to
+ screen before being sent
+* new: server::service($data) lets user parse data other than POST body, for
+ easier testing / subclassing
+* changed: framework-generated debug messages are sent back by the server base64
+ encoded, to avoid any charset/xml compatibility problem
+* other minor fixes
+
+The usual refactoring of a lot of (private) methods has taken place, with new
+parameters added to some functions.
+Javadoc documentation has been improved a lot.
+The HTML documentation has been shuffled around a bit, hoping to give it a more
+logical organization.
+
+The experimental support for the JSON protocol has been removed, and will be
+packaged as a separate download with some extra very interesting stuff (human
+readable auto-generated documentation, anyone?).
+
+
+XML-RPC for PHP version 2.0RC2 - 2005/11/22
+
+This release corrects a few bugs and adds basically one new method for better
+HTTPS support:
+
+ * fixed two bugs that prevented xmlrpc calls to take place over https
+ * fixed two bugs that prevented proper recognition of xml character set
+ when it was declared inside the xml prologue
+ * added xmlrpc_client::setKey($key, $keypass) method, to allow using client
+ side certificates for https connections
+ * fixed bug that prevented proper serialization of string xmlrpcvals when
+ $xmlrpc_internalencoding was set to UTF-8
+ * fixed bug in xmlrpc_server::echoInput() (and marked method as deprecated)
+ * correctly set cookies/http headers into xmlrpcresp objects even when the
+ send() method call fails for some reason
+ * added a benchmark file in the testsuite directory
+
+A couple of (private/protected) methods have been refactored, as well as a
+couple of extra parameters added to some (private) functions - this has no
+impact on the public API and should be of interest primarily to people extending
+/ subclassing the lib.
+
+There is also new, PARTIAL support for the JSON-RPC protocol, implemented in
+two files in the extras dir (more info about json-rpc at http://json-rpc.org)
+
+
+XML-RPC for PHP version 2.0RC1 - 2005/10/03
+
+I'm pleased to announce XML-RPC for PHP version 2.0, release candidate 1.
+
+This release introduces so many new features it is almost impossible to list them
+here, making the library finally on pair with, if not more advanced than, any other
+similar offer (e.g. the PEAR XMLRPC package or the Incutio IXR library).
+No, really, trust me.
+
+The minimum supported PHP version is now 4.2 - natively - or 4.0.4pl1 - by usage of
+a couple of compatibility classes (code taken from PEAR php_compat package).
+
+The placement of files and directories in the distribution has been deeply modified,
+in the hope of making it more clear, now that the file count has increased.
+I hope you find it easy.
+
+Support for "advanced" HTTP features such as cookies, proxies and keep-alives has
+been added at last.
+
+It is now much easier to convert between xmlrpcval objects and php values, and
+in fact php_xmlrpc_encode and php_xmlrpc_decode are now the recommended methods
+for all cases, except when encoding base64 data.
+
+Two new (experimental) functions have been added, allowing automagic conversion
+of a php function into an xmlrpc method to be exposed and vice-versa.
+
+PHP objects can be now automatically serialized as xmlrpc struct values and
+correctly deserialized on the other end of the transmission, provided that the
+same class definition is present on both sides and no object members are of
+type resource.
+
+A lot of the existing class methods have been overloaded with extra parameters
+or new functionality, and a few added ex-novo, making usage easier than ever.
+
+A complete debugger solution is included in the distribution. It needs a web server
+to run (a freely available version of the same debugger is accessible online, it
+can be found at http://phpxmlrpc.sourceforge.net).
+
+For a more detailed list of changes, please read carefully chapter 2 of the
+included documentation, or, even better, take a look at the source code, which
+is commented in javadoc style quite a bit.
+
+
+XML-RPC for PHP version 1.2 - 2005/08/14
+
+This removes all use of eval(), which is a potential security problem.
+All users are encouraged to upgrade as soon as possible.
+As of this release we are no longer php3-compatible.
+
+
+XML-RPC for PHP version 1.1.1 - 2005/06/30
+
+This is a security vulnerability fix release.
+All users are invited to upgrade as soon as possible.
+
+
+XML-RPC for PHP version 1.1 - 2005/05/03
+
+I'm pleased to announce XML-RPC for PHP version 1.1
+It's taken two years to get to the this point, but here we are, finally.
+
+This is a bugfix and maintenance release. No major new features have been added.
+All known bugs have been ironed out, unless fixing would have meant breaking
+the API.
+The code has been tested with PHP 3, 4 and 5, even tough PHP 4 is the main
+development platform (and some warnings will be emitted when running PHP5).
+
+Noteworthy changes include:
+
+ * do not clash any more with the EPI xmlrpc extension bundled with PHP 4 and 5
+ * fixed the unicode/charset problems that have been plaguing the lib for years
+ * proper parsing of int and float values prepended with zeroes or the '+' char
+ * accept float values in exponential notation
+ * configurable http user-agent string
+ * use the same timeout on client socket reads as used for connecting
+ * more explicative error messages in xmlrpcresponse in many cases
+ * much more tolerant parsing of malformed http responses from xmlrpc servers
+ * fixed memleak that prevented the client to be used in never-ending scripts
+ * parse bigger xmlrpc messages without crashing (1MB in size or more)
+ * be tolerant to xmlrpc responses generated on public servers that add
+ javascript advertising at the end of hosted content
+ * the lib generates quite a few less PHP warnings during standard operation
+
+This is the last release that will support PHP 3.
+The next release will include better support for PHP 5 and (possibly) a slew of
+new features.
+
+The changelog is available at:
+http://cvs.sourceforge.net/viewcvs.py/phpxmlrpc/xmlrpc/ChangeLog?view=markup
+
+Please report bugs to the XML-RPC PHP mailing list or to the sourceforge project
+pages at http://sourceforge.net/projects/phpxmlrpc/
+
+
+XML-RPC for PHP version 1.0
+
+I'm pleased to announce XML-RPC for PHP version 1.0 (final). It's taken
+two years to get to the 1.0 point, but here we are, finally. The major change
+is re-licensing with the BSD open source license, a move from the custom
+license previously used.
+
+After this release I expect to move the project to SourceForge and find
+another primary maintainer for the code. More details will follow to the
+mailing list.
+
+It can be downloaded from http://xmlrpc.usefulinc.com/php.html
+
+Comprehensive documentation is available in the distribution, but you
+can also browse it at http://xmlrpc.usefulinc.com/doc/
+
+Bugfixes in this release include:
+
+ * Small fixes and tidying up.
+
+New features include:
+
+ * experimental support for SSL via the curl extensions to PHP. Needs
+ PHP 4.0.2 or greater, but not PHP 4.0.6 which has broken SSL support.
+
+The changelog is available at: http://xmlrpc.usefulinc.com/ChangeLog.txt
+
+Please report bugs to the XML-RPC PHP mailing list, of which more details are
+available at http://xmlrpc.usefulinc.com/list.html, or to
+<xmlrpc@usefulinc.com>.
+
+
+XML-RPC for PHP version 1.0 beta 9
+
+I'm pleased to announce XML-RPC for PHP version 1.0 beta 9. This is
+is largely a bugfix release.
+
+It can be downloaded from http://xmlrpc.usefulinc.com/php.html
+
+Comprehensive documentation is available in the distribution, but you
+can also browse it at http://xmlrpc.usefulinc.com/doc/
+
+Bugfixes in this release include:
+
+ * Fixed string handling bug where characters between a </string>
+ and </value> tag were not ignored.
+
+ * Added in support for PHP's native boolean type.
+
+New features include:
+
+ * new getval() method (experimental only) which has support for
+ recreating nested arrays.
+ * fledgling unit test suite
+ * server.php has support for basic interop test suite
+
+The changelog is available at: http://xmlrpc.usefulinc.com/ChangeLog.txt
+
+Please test this as hard as possible and report bugs to the XML-RPC PHP
+mailing list, of which more details are available at
+http://xmlrpc.usefulinc.com/list.html, or to <xmlrpc@usefulinc.com>.
+
+
+XML-RPC for PHP version 1.0 beta 8
+
+I'm pleased to announce XML-RPC for PHP version 1.0 beta 8.
+
+This release fixes several bugs and adds a couple of new helper
+functions. The most critical change in this release is that you can no
+longer print debug info in comments inside a server method -- you must
+now use the new xmlrpc_debugmsg() function.
+
+It can be downloaded from http://xmlrpc.usefulinc.com/php.html
+
+Comprehensive documentation is available in the distribution, but you
+can also browse it at http://xmlrpc.usefulinc.com/doc/
+
+Bugfixes in this release include:
+
+ * fixed whitespace handling in values
+ * correct sending of Content-length from the server
+
+New features include:
+
+ * xmlrpc_debugmsg() method allows sending of debug info in comments in
+ the return payload from a server
+
+ * xmlrpc_encode() and xmlrpc_decode() translate between xmlrpcval
+ objects and PHP language arrays. They aren't suitable for all
+ datatypes, but can speed up coding in simple scenarios. Thanks to Dan
+ Libby for these.
+
+The changelog is available at: http://xmlrpc.usefulinc.com/ChangeLog.txt
+
+Please test this as hard as possible and report bugs to the XML-RPC PHP
+mailing list, of which more details are available at
+http://xmlrpc.usefulinc.com/list.html, or to <xmlrpc@usefulinc.com>.
+
+
+XML-RPC for PHP version 1.0 beta 7
+
+I'm pleased to announce XML-RPC for PHP version 1.0 beta 7. This is
+fixes some critical bugs that crept in. If it shows itself to be stable
+then it'll become the 1.0 release.
+
+It can be downloaded from http://xmlrpc.usefulinc.com/php.html
+
+Comprehensive documentation is available in the distribution, but you
+can also browse it at http://xmlrpc.usefulinc.com/doc/
+
+Bugfixes in this release include:
+
+ * Passing of booleans should now work as expected
+ * Dollar signs and backslashes in strings should pass OK
+ * addScalar() now works properly to append to array vals
+
+New features include:
+
+ * Added support for HTTP Basic authorization through the
+ xmlrpc_client::setCredentials method.
+
+ * Added test script and method for verifying correct passing of
+ booleans
+
+The changelog is available at: http://xmlrpc.usefulinc.com/ChangeLog.txt
+
+Please test this as hard as possible and report bugs to the XML-RPC PHP
+mailing list, of which more details are available at
+http://xmlrpc.usefulinc.com/list.html, or to <xmlrpc@usefulinc.com>.
+
+
+XML-RPC for PHP version 1.0 beta 6
+
+I'm pleased to announce XML-RPC for PHP version 1.0 beta 6. This is the
+final beta before the 1.0 release.
+
+It can be downloaded from http://xmlrpc.usefulinc.com/php.html
+
+Comprehensive documentation is available in the distribution, but you
+can also browse it at http://xmlrpc.usefulinc.com/doc/
+
+New features in this release include:
+
+ * Perl and Python test programs for the demo server
+ * Proper fault generation on a non-"200 OK" response from a remote host
+ * Bugfixed base64 decoding
+ * ISO8601 helper routines for translation to and from UNIX timestamps
+ * reorganization of code to allow eventual integration of alternative
+ transports
+
+The changelog is available at: http://xmlrpc.usefulinc.com/ChangeLog.txt
+
+Please test this as hard as possible and report bugs to the XML-RPC PHP
+mailing list, of which more details are available at
+http://xmlrpc.usefulinc.com/list.html, or to <xmlrpc@usefulinc.com>.
--- /dev/null
+XMLRPC for PHP
+==============
+A php library for building xml-rpc clients and servers.
+
+Installation
+------------
+The recommended way to install this library is using Composer.
+
+Detailed installation instructions are in the [INSTALL.md](INSTALL.md) file, along with system requirements listing.
+
+Documentation
+-------------
+
+*NB: the user manual has not been updated yet with all the changes made in version 4. Please consider it unreliable!*
+
+*You are encouraged to look instead the code examples found in the demo/ directory*
+
+The user manual can be found in the doc/manual directory, in Asciidoc format: [phpxmlrpc_manual.adoc](doc/manual/phpxmlrpc_manual.adoc)
+
+Release tarballs also contain the HTML and PDF versions, as well as an automatically generated API documentation.
+
+Upgrading
+---------
+If you are upgrading from version 3 or earlier you have two options:
+
+1. adapt your code to the new API (all changes needed are described in [doc/api_changes_v4.md](doc/api_changes_v4.md))
+
+2. use instead the *compatibility layer* which is provided. Instructions and pitfalls described in [doc/api_changes_v4.md](doc/api_changes_v4.md##enabling-compatibility-with-legacy-code)
+
+In any case, read carefully the docs in [doc/api_changes_v4.md](doc/api_changes_v4.md) and report back any undocumented
+issue using GitHub.
+
+License
+-------
+Use of this software is subject to the terms in the [license.txt](license.txt) file
+
+SSL-certificate
+---------------
+The passphrase for the rsakey.pem certificate is 'test'.
+
+
+[](https://packagist.org/packages/phpxmlrpc/phpxmlrpc)
+[](https://packagist.org/packages/phpxmlrpc/phpxmlrpc)
+[](https://packagist.org/packages/phpxmlrpc/phpxmlrpc)
+
+[](https://travis-ci.org/gggeek/phpxmlrpc)
+[](https://codeclimate.com/github/gggeek/phpxmlrpc)
+[](https://scrutinizer-ci.com/g/gggeek/phpxmlrpc/?branch=php53)
--- /dev/null
+{
+ "name": "phpxmlrpc/phpxmlrpc",
+ "description": "A php library for building xmlrpc clients and servers",
+ "license": "BSD-3-Clause",
+ "homepage": "http://gggeek.github.io/phpxmlrpc/",
+ "keywords": [ "xmlrpc", "webservices" ],
+ "require": {
+ "php": ">=5.3.0",
+ "ext-xml": "*"
+ },
+ "require-dev": {
+ "phpunit/phpunit": ">=4.0.0, <6.0.0",
+ "phpunit/phpunit-selenium": "*",
+ "codeclimate/php-test-reporter": "dev-master",
+ "ext-curl": "*",
+ "ext-mbstring": "*",
+ "indeyets/pake": "~1.99",
+ "sami/sami": "~3.1",
+ "docbook/docbook-xsl": "~1.78"
+ },
+ "suggest": {
+ "ext-curl": "Needed for HTTPS and HTTP 1.1 support, NTLM Auth etc...",
+ "ext-zlib": "Needed for sending compressed requests and receiving compressed responses, if cURL is not available",
+ "ext-mbstring": "Needed to allow reception of requests/responses in character sets other than ASCII,LATIN-1,UTF-8"
+ },
+ "autoload": {
+ "psr-4": {"PhpXmlRpc\\": "src/"}
+ },
+ "config": {
+ "secure-http": false
+ },
+ "repositories": [
+ {
+ "type": "package",
+ "package": {
+ "name": "docbook/docbook-xsl",
+ "version": "1.78.1",
+ "dist": {
+ "url": "https://sourceforge.net/projects/docbook/files/docbook-xsl/1.78.1/docbook-xsl-1.78.1.zip/download",
+ "type": "zip"
+ }
+ }
+ }
+ ]
+}
--- /dev/null
+<?php
+/**
+ * @author Gaetano Giunta
+ * @copyright (C) 2005-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ *
+ * @todo switch params for http compression from 0,1,2 to values to be used directly
+ * @todo use ob_start to catch debug info and echo it AFTER method call results?
+ * @todo be smarter in creating client stub for proxy/auth cases: only set appropriate property of client obj
+ **/
+
+header('Content-Type: text/html; charset=utf-8');
+
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+ <title>XMLRPC Debugger</title>
+ <meta name="robots" content="index,nofollow"/>
+ <style type="text/css">
+ <!--
+ body {
+ border-top: 1px solid gray;
+ padding: 1em;
+ font-family: Verdana, Arial, Helvetica;
+ font-size: 8pt;
+ }
+
+ h3 {
+ font-size: 9.5pt;
+ }
+
+ h2 {
+ font-size: 12pt;
+ }
+
+ .dbginfo {
+ padding: 1em;
+ background-color: #EEEEEE;
+ border: 1px dashed silver;
+ font-family: monospace;
+ }
+
+ #response {
+ padding: 1em;
+ margin-top: 1em;
+ background-color: #DDDDDD;
+ border: 1px solid gray;
+ white-space: pre;
+ font-family: monospace;
+ }
+
+ table {
+ padding: 2px;
+ margin-top: 1em;
+ }
+
+ th {
+ background-color: navy;
+ color: white;
+ padding: 0.5em;
+ }
+
+ td {
+ padding: 0.5em;
+ font-family: monospace;
+ }
+
+ td form {
+ margin: 0;
+ }
+
+ .oddrow {
+ background-color: #EEEEEE;
+ }
+
+ .evidence {
+ color: blue;
+ }
+
+ #phpcode {
+ background-color: #EEEEEE;
+ padding: 1em;
+ margin-top: 1em;
+ }
+
+ -->
+ </style>
+</head>
+<body>
+<?php
+
+include __DIR__ . '/common.php';
+if ($action) {
+
+ include_once __DIR__ . "/../src/Autoloader.php";
+ PhpXmlRpc\Autoloader::register();
+
+ // make sure the script waits long enough for the call to complete...
+ if ($timeout) {
+ set_time_limit($timeout + 10);
+ }
+
+ if ($wstype == 1) {
+ @include 'jsonrpc.inc';
+ if (!class_exists('jsonrpc_client')) {
+ die('Error: to debug the jsonrpc protocol the jsonrpc.inc file is needed');
+ }
+ $clientClass = 'PhpJsRpc\Client';
+ $requestClass = 'PhpJsRpc\Request';
+ $protoName = 'JSONRPC';
+ } else {
+ $clientClass = 'PhpXmlRpc\Client';
+ $requestClass = 'PhpXmlRpc\Request';
+ $protoName = 'XMLRPC';
+ }
+
+ if ($port != "") {
+ $client = new $clientClass($path, $host, $port);
+ $server = "$host:$port$path";
+ } else {
+ $client = new $clientClass($path, $host);
+ $server = "$host$path";
+ }
+ if ($protocol == 2) {
+ $server = 'https://' . $server;
+ } else {
+ $server = 'http://' . $server;
+ }
+ if ($proxy != '') {
+ $pproxy = explode(':', $proxy);
+ if (count($pproxy) > 1) {
+ $pport = $pproxy[1];
+ } else {
+ $pport = 8080;
+ }
+ $client->setProxy($pproxy[0], $pport, $proxyuser, $proxypwd);
+ }
+
+ if ($protocol == 2) {
+ $client->setSSLVerifyPeer($verifypeer);
+ $client->setSSLVerifyHost($verifyhost);
+ if ($cainfo) {
+ $client->setCaCertificate($cainfo);
+ }
+ $httpprotocol = 'https';
+ } elseif ($protocol == 1) {
+ $httpprotocol = 'http11';
+ } else {
+ $httpprotocol = 'http';
+ }
+
+ if ($username) {
+ $client->setCredentials($username, $password, $authtype);
+ }
+
+ $client->setDebug($debug);
+
+ switch ($requestcompression) {
+ case 0:
+ $client->request_compression = '';
+ break;
+ case 1:
+ $client->request_compression = 'gzip';
+ break;
+ case 2:
+ $client->request_compression = 'deflate';
+ break;
+ }
+
+ switch ($responsecompression) {
+ case 0:
+ $client->accepted_compression = '';
+ break;
+ case 1:
+ $client->accepted_compression = array('gzip');
+ break;
+ case 2:
+ $client->accepted_compression = array('deflate');
+ break;
+ case 3:
+ $client->accepted_compression = array('gzip', 'deflate');
+ break;
+ }
+
+ $cookies = explode(',', $clientcookies);
+ foreach ($cookies as $cookie) {
+ if (strpos($cookie, '=')) {
+ $cookie = explode('=', $cookie);
+ $client->setCookie(trim($cookie[0]), trim(@$cookie[1]));
+ }
+ }
+
+ $msg = array();
+ switch ($action) {
+ // fall thru intentionally
+ case 'describe':
+ case 'wrap':
+ $msg[0] = new $requestClass('system.methodHelp', array(), $id);
+ $msg[0]->addparam(new PhpXmlRpc\Value($method));
+ $msg[1] = new $requestClass('system.methodSignature', array(), $id + 1);
+ $msg[1]->addparam(new PhpXmlRpc\Value($method));
+ $actionname = 'Description of method "' . $method . '"';
+ break;
+ case 'list':
+ $msg[0] = new $requestClass('system.listMethods', array(), $id);
+ $actionname = 'List of available methods';
+ break;
+ case 'execute':
+ if (!payload_is_safe($payload)) {
+ die("Tsk tsk tsk, please stop it or I will have to call in the cops!");
+ }
+ $msg[0] = new $requestClass($method, array(), $id);
+ // hack! build xml payload by hand
+ if ($wstype == 1) {
+ $msg[0]->payload = "{\n" .
+ '"method": "' . $method . "\",\n\"params\": [" .
+ $payload .
+ "\n],\n\"id\": ";
+ // fix: if user gave an empty string, use NULL, or we'll break json syntax
+ if ($id == "") {
+ $msg[0]->payload .= "null\n}";
+ } else {
+ if (is_numeric($id) || $id == 'false' || $id == 'true' || $id == 'null') {
+ $msg[0]->payload .= "$id\n}";
+ } else {
+ $msg[0]->payload .= "\"$id\"\n}";
+ }
+ }
+ } else {
+ $msg[0]->payload = $msg[0]->xml_header($inputcharset) .
+ '<methodName>' . $method . "</methodName>\n<params>" .
+ $payload .
+ "</params>\n" . $msg[0]->xml_footer();
+ }
+ $actionname = 'Execution of method ' . $method;
+ break;
+ default: // give a warning
+ $actionname = '[ERROR: unknown action] "' . $action . '"';
+ }
+
+ // Before calling execute, echo out brief description of action taken + date and time ???
+ // this gives good user feedback for long-running methods...
+ echo '<h2>' . htmlspecialchars($actionname, ENT_COMPAT, $inputcharset) . ' on server ' . htmlspecialchars($server, ENT_COMPAT, $inputcharset) . " ...</h2>\n";
+ flush();
+
+ $response = null;
+ // execute method(s)
+ if ($debug) {
+ echo '<div class="dbginfo"><h2>Debug info:</h2>';
+ } /// @todo use ob_start instead
+ $resp = array();
+ $time = microtime(true);
+ foreach ($msg as $message) {
+ // catch errors: for older xmlrpc libs, send does not return by ref
+ @$response = $client->send($message, $timeout, $httpprotocol);
+ $resp[] = $response;
+ if (!$response || $response->faultCode()) {
+ break;
+ }
+ }
+ $time = microtime(true) - $time;
+ if ($debug) {
+ echo "</div>\n";
+ }
+
+ if ($response) {
+ if ($response->faultCode()) {
+ // call failed! echo out error msg!
+ //echo '<h2>'.htmlspecialchars($actionname, ENT_COMPAT, $inputcharset).' on server '.htmlspecialchars($server, ENT_COMPAT, $inputcharset).'</h2>';
+ echo "<h3>$protoName call FAILED!</h3>\n";
+ echo "<p>Fault code: [" . htmlspecialchars($response->faultCode(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) .
+ "] Reason: '" . htmlspecialchars($response->faultString(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) . "'</p>\n";
+ echo(strftime("%d/%b/%Y:%H:%M:%S\n"));
+ } else {
+ // call succeeded: parse results
+ //echo '<h2>'.htmlspecialchars($actionname, ENT_COMPAT, $inputcharset).' on server '.htmlspecialchars($server, ENT_COMPAT, $inputcharset).'</h2>';
+ printf("<h3>%s call(s) OK (%.2f secs.)</h3>\n", $protoName, $time);
+ echo(strftime("%d/%b/%Y:%H:%M:%S\n"));
+
+ switch ($action) {
+ case 'list':
+
+ $v = $response->value();
+ if ($v->kindOf() == "array") {
+ $max = $v->count();
+ echo "<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n";
+ echo "<thead>\n<tr><th>Method ($max)</th><th>Description</th></tr>\n</thead>\n<tbody>\n";
+ foreach($v as $i => $rec) {
+ if ($i % 2) {
+ $class = ' class="oddrow"';
+ } else {
+ $class = ' class="evenrow"';
+ }
+ echo("<tr><td$class>" . htmlspecialchars($rec->scalarval(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) . "</td><td$class><form action=\"controller.php\" method=\"get\" target=\"frmcontroller\">" .
+ "<input type=\"hidden\" name=\"host\" value=\"" . htmlspecialchars($host, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"port\" value=\"" . htmlspecialchars($port, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"path\" value=\"" . htmlspecialchars($path, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"id\" value=\"" . htmlspecialchars($id, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"debug\" value=\"$debug\" />" .
+ "<input type=\"hidden\" name=\"username\" value=\"" . htmlspecialchars($username, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"password\" value=\"" . htmlspecialchars($password, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"authtype\" value=\"$authtype\" />" .
+ "<input type=\"hidden\" name=\"verifyhost\" value=\"$verifyhost\" />" .
+ "<input type=\"hidden\" name=\"verifypeer\" value=\"$verifypeer\" />" .
+ "<input type=\"hidden\" name=\"cainfo\" value=\"" . htmlspecialchars($cainfo, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxy\" value=\"" . htmlspecialchars($proxy, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxyuser\" value=\"" . htmlspecialchars($proxyuser, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxypwd\" value=\"" . htmlspecialchars($proxypwd, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"responsecompression\" value=\"$responsecompression\" />" .
+ "<input type=\"hidden\" name=\"requestcompression\" value=\"$requestcompression\" />" .
+ "<input type=\"hidden\" name=\"clientcookies\" value=\"" . htmlspecialchars($clientcookies, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"protocol\" value=\"$protocol\" />" .
+ "<input type=\"hidden\" name=\"timeout\" value=\"" . htmlspecialchars($timeout, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"method\" value=\"" . htmlspecialchars($rec->scalarval(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) . "\" />" .
+ "<input type=\"hidden\" name=\"wstype\" value=\"$wstype\" />" .
+ "<input type=\"hidden\" name=\"action\" value=\"describe\" />" .
+ "<input type=\"hidden\" name=\"run\" value=\"now\" />" .
+ "<input type=\"submit\" value=\"Describe\" /></form></td>");
+ //echo("</tr>\n");
+
+ // generate the skeleton for method payload per possible tests
+ //$methodpayload="<methodCall>\n<methodName>".$rec->scalarval()."</methodName>\n<params>\n<param><value></value></param>\n</params>\n</methodCall>";
+
+ /*echo ("<form action=\"{$_SERVER['PHP_SELF']}\" method=\"get\"><td>".
+ "<input type=\"hidden\" name=\"host\" value=\"$host\" />".
+ "<input type=\"hidden\" name=\"port\" value=\"$port\" />".
+ "<input type=\"hidden\" name=\"path\" value=\"$path\" />".
+ "<input type=\"hidden\" name=\"method\" value=\"".$rec->scalarval()."\" />".
+ "<input type=\"hidden\" name=\"methodpayload\" value=\"$payload\" />".
+ "<input type=\"hidden\" name=\"action\" value=\"execute\" />".
+ "<input type=\"submit\" value=\"Test\" /></td></form>");*/
+ echo("</tr>\n");
+ }
+ echo "</tbody>\n</table>";
+ }
+ break;
+
+ case 'describe':
+
+ $r1 = $resp[0]->value();
+ $r2 = $resp[1]->value();
+
+ echo "<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n";
+ echo "<thead>\n<tr><th>Method</th><th>" . htmlspecialchars($method, ENT_COMPAT, $inputcharset) . "</th><th> </th><th> </th></tr>\n</thead>\n<tbody>\n";
+ $desc = htmlspecialchars($r1->scalarval(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding);
+ if ($desc == "") {
+ $desc = "-";
+ }
+ echo "<tr><td class=\"evenrow\">Description</td><td colspan=\"3\" class=\"evenrow\">$desc</td></tr>\n";
+
+ if ($r2->kindOf() != "array") {
+ echo "<tr><td class=\"oddrow\">Signature</td><td class=\"oddrow\">Unknown</td><td class=\"oddrow\"> </td></tr>\n";
+ } else {
+ foreach($r2 as $i => $x) {
+ $payload = "";
+ $alt_payload = "";
+ if ($i + 1 % 2) {
+ $class = ' class="oddrow"';
+ } else {
+ $class = ' class="evenrow"';
+ }
+ echo "<tr><td$class>Signature " . ($i + 1) . "</td><td$class>";
+ if ($x->kindOf() == "array") {
+ $ret = $x[0];
+ echo "<code>OUT: " . htmlspecialchars($ret->scalarval(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) . "<br />IN: (";
+ if ($x->count() > 1) {
+ foreach($x as $k => $y) {
+ if ($k == 0) continue;
+ echo htmlspecialchars($y->scalarval(), ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding);
+ if ($wstype != 1) {
+ $type = $y->scalarval();
+ $payload .= '<param><value>';
+ switch($type) {
+ case 'undefined':
+ break;
+ case 'null';
+ $type = 'nil';
+ // fall thru intentionally
+ default:
+ $payload .= '<' .
+ htmlspecialchars($type, ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) .
+ '></' . htmlspecialchars($type, ENT_COMPAT, \PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding) .
+ '>';
+ }
+ $payload .= "</value></param>\n";
+ }
+ $alt_payload .= $y->scalarval();
+ if ($k < $x->count() - 1) {
+ $alt_payload .= ';';
+ echo ", ";
+ }
+ }
+ }
+ echo ")</code>";
+ } else {
+ echo 'Unknown';
+ }
+ echo '</td>';
+ // button to test this method
+ //$payload="<methodCall>\n<methodName>$method</methodName>\n<params>\n$payload</params>\n</methodCall>";
+ echo "<td$class><form action=\"controller.php\" target=\"frmcontroller\" method=\"get\">" .
+ "<input type=\"hidden\" name=\"host\" value=\"" . htmlspecialchars($host, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"port\" value=\"" . htmlspecialchars($port, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"path\" value=\"" . htmlspecialchars($path, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"id\" value=\"" . htmlspecialchars($id, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"debug\" value=\"$debug\" />" .
+ "<input type=\"hidden\" name=\"username\" value=\"" . htmlspecialchars($username, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"password\" value=\"" . htmlspecialchars($password, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"authtype\" value=\"$authtype\" />" .
+ "<input type=\"hidden\" name=\"verifyhost\" value=\"$verifyhost\" />" .
+ "<input type=\"hidden\" name=\"verifypeer\" value=\"$verifypeer\" />" .
+ "<input type=\"hidden\" name=\"cainfo\" value=\"" . htmlspecialchars($cainfo, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxy\" value=\"" . htmlspecialchars($proxy, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxyuser\" value=\"" . htmlspecialchars($proxyuser, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxypwd\" value=\"" . htmlspecialchars($proxypwd, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"responsecompression\" value=\"$responsecompression\" />" .
+ "<input type=\"hidden\" name=\"requestcompression\" value=\"$requestcompression\" />" .
+ "<input type=\"hidden\" name=\"clientcookies\" value=\"" . htmlspecialchars($clientcookies, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"protocol\" value=\"$protocol\" />" .
+ "<input type=\"hidden\" name=\"timeout\" value=\"" . htmlspecialchars($timeout, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"method\" value=\"" . htmlspecialchars($method, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"methodpayload\" value=\"" . htmlspecialchars($payload, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"altmethodpayload\" value=\"" . htmlspecialchars($alt_payload, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"wstype\" value=\"$wstype\" />" .
+ "<input type=\"hidden\" name=\"action\" value=\"execute\" />";
+ if ($wstype != 1) {
+ echo "<input type=\"submit\" value=\"Load method synopsis\" />";
+ }
+ echo "</form></td>\n";
+
+ echo "<td$class><form action=\"controller.php\" target=\"frmcontroller\" method=\"get\">" .
+ "<input type=\"hidden\" name=\"host\" value=\"" . htmlspecialchars($host, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"port\" value=\"" . htmlspecialchars($port, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"path\" value=\"" . htmlspecialchars($path, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"id\" value=\"" . htmlspecialchars($id, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"debug\" value=\"$debug\" />" .
+ "<input type=\"hidden\" name=\"username\" value=\"" . htmlspecialchars($username, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"password\" value=\"" . htmlspecialchars($password, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"authtype\" value=\"$authtype\" />" .
+ "<input type=\"hidden\" name=\"verifyhost\" value=\"$verifyhost\" />" .
+ "<input type=\"hidden\" name=\"verifypeer\" value=\"$verifypeer\" />" .
+ "<input type=\"hidden\" name=\"cainfo\" value=\"" . htmlspecialchars($cainfo, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxy\" value=\"" . htmlspecialchars($proxy, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxyuser\" value=\"" . htmlspecialchars($proxyuser, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"proxypwd\" value=\"" . htmlspecialchars($proxypwd, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"responsecompression\" value=\"$responsecompression\" />" .
+ "<input type=\"hidden\" name=\"requestcompression\" value=\"$requestcompression\" />" .
+ "<input type=\"hidden\" name=\"clientcookies\" value=\"" . htmlspecialchars($clientcookies, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"protocol\" value=\"$protocol\" />" .
+ "<input type=\"hidden\" name=\"timeout\" value=\"" . htmlspecialchars($timeout, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"method\" value=\"" . htmlspecialchars($method, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"methodsig\" value=\"" . $i . "\" />" .
+ "<input type=\"hidden\" name=\"methodpayload\" value=\"" . htmlspecialchars($payload, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"altmethodpayload\" value=\"" . htmlspecialchars($alt_payload, ENT_COMPAT, $inputcharset) . "\" />" .
+ "<input type=\"hidden\" name=\"wstype\" value=\"$wstype\" />" .
+ "<input type=\"hidden\" name=\"run\" value=\"now\" />" .
+ "<input type=\"hidden\" name=\"action\" value=\"wrap\" />" .
+ "<input type=\"submit\" value=\"Generate method call stub code\" />";
+ echo "</form></td></tr>\n";
+ }
+ }
+ echo "</tbody>\n</table>";
+
+ break;
+
+ case 'wrap':
+ $r1 = $resp[0]->value();
+ $r2 = $resp[1]->value();
+ if ($r2->kindOf() != "array" || $r2->count() <= $methodsig) {
+ echo "Error: signature unknown\n";
+ } else {
+ $mdesc = $r1->scalarval();
+ $encoder = new PhpXmlRpc\Encoder();
+ $msig = $encoder->decode($r2);
+ $msig = $msig[$methodsig];
+ $proto = $protocol == 2 ? 'https' : $protocol == 1 ? 'http11' : '';
+ if ($proxy == '' && $username == '' && !$requestcompression && !$responsecompression &&
+ $clientcookies == ''
+ ) {
+ $opts = 1; // simple client copy in stub code
+ } else {
+ $opts = 0; // complete client copy in stub code
+ }
+ if ($wstype == 1) {
+ $prefix = 'jsonrpc';
+ } else {
+ $prefix = 'xmlrpc';
+ }
+ $wrapper = new PhpXmlRpc\Wrapper();
+ $code = $wrapper->buildWrapMethodSource($client, $method, array('timeout' => $timeout, 'protocol' => $proto, 'simple_client_copy' => $opts, 'prefix' => $prefix), str_replace('.', '_', $prefix . '_' . $method), $msig, $mdesc);
+ //if ($code)
+ //{
+ echo "<div id=\"phpcode\">\n";
+ highlight_string("<?php\n" . $code['docstring'] . $code['source'] . '?>');
+ echo "\n</div>";
+ //}
+ //else
+ //{
+ // echo 'Error while building php code stub...';
+ }
+
+ break;
+
+ case 'execute':
+ echo '<div id="response"><h2>Response:</h2>' . htmlspecialchars($response->serialize()) . '</div>';
+ break;
+
+ default: // give a warning
+ }
+ } // if !$response->faultCode()
+ } // if $response
+} else {
+ // no action taken yet: give some instructions on debugger usage
+ ?>
+
+ <h3>Instructions on usage of the debugger</h3>
+ <ol>
+ <li>Run a 'list available methods' action against desired server</li>
+ <li>If list of methods appears, click on 'describe method' for desired method</li>
+ <li>To run method: click on 'load method synopsis' for desired method. This will load a skeleton for method call
+ parameters in the form above. Complete all xmlrpc values with appropriate data and click 'Execute'
+ </li>
+ </ol>
+ <?php
+ if (!extension_loaded('curl')) {
+ echo "<p class=\"evidence\">You will need to enable the CURL extension to use the HTTPS and HTTP 1.1 transports</p>\n";
+ }
+ ?>
+
+ <h3>Example</h3>
+ <p>
+ Server Address: phpxmlrpc.sourceforge.net<br/>
+ Path: /server.php
+ </p>
+
+ <h3>Notice</h3>
+ <p>all usernames and passwords entered on the above form will be written to the web server logs of this server. Use
+ with care.</p>
+
+ <h3>Changelog</h3>
+ <ul>
+ <li>2015-05-30: fix problems with generating method payloads for NIL and Undefined parameters</li>
+ <li>2015-04-19: fix problems with LATIN-1 characters in payload</li>
+ <li>2007-02-20: add visual editor for method payload; allow strings, bools as jsonrpc msg id</li>
+ <li>2006-06-26: support building php code stub for calling remote methods</li>
+ <li>2006-05-25: better support for long running queries; check for no-curl installs</li>
+ <li>2006-05-02: added support for JSON-RPC. Note that many interesting json-rpc features are not implemented
+ yet, such as notifications or multicall.
+ </li>
+ <li>2006-04-22: added option for setting custom CA certs to verify peer with in SSLmode</li>
+ <li>2006-03-05: added option for setting Basic/Digest/NTLM auth type</li>
+ <li>2006-01-18: added option echoing to screen xmlrpc request before sending it ('More' debug)</li>
+ <li>2005-10-01: added option for setting cookies to be sent to server</li>
+ <li>2005-08-07: added switches for compression of requests and responses and http 1.1</li>
+ <li>2005-06-27: fixed possible security breach in parsing malformed xml</li>
+ <li>2005-06-24: fixed error with calling methods having parameters...</li>
+ </ul>
+<?php
+
+}
+?>
+</body>
+</html>
--- /dev/null
+<?php
+/**
+ * @author Gaetano Giunta
+ * @copyright (C) 2005-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ *
+ * Parses GET/POST variables
+ *
+ * @todo switch params for http compression from 0,1,2 to values to be used directly
+ * @todo do some more sanitization of received parameters
+ */
+
+// work around magic quotes
+if (get_magic_quotes_gpc()) {
+ function stripslashes_deep($value)
+ {
+ $value = is_array($value) ?
+ array_map('stripslashes_deep', $value) :
+ stripslashes($value);
+
+ return $value;
+ }
+
+ $_GET = array_map('stripslashes_deep', $_GET);
+}
+
+$preferredEncodings = 'UTF-8, ASCII, ISO-8859-1, UTF-7, EUC-JP, SJIS, eucJP-win, SJIS-win, JIS, ISO-2022-JP';
+$inputcharset = mb_detect_encoding(urldecode($_SERVER['REQUEST_URI']), $preferredEncodings);
+if (isset($_GET['usepost']) && $_GET['usepost'] === 'true') {
+ $_GET = $_POST;
+ $inputcharset = mb_detect_encoding(implode('', $_GET), $preferredEncodings);
+}
+
+/// @todo if $inputcharset is not UTF8, we should probably re-encode $_GET to make it UTF-8
+
+// recover input parameters
+$debug = false;
+$protocol = 0;
+$run = false;
+$wstype = 0;
+$id = '';
+if (isset($_GET['action'])) {
+ if (isset($_GET['wstype']) && $_GET['wstype'] == '1') {
+ $wstype = 1;
+ if (isset($_GET['id'])) {
+ $id = $_GET['id'];
+ }
+ }
+ $host = isset($_GET['host']) ? $_GET['host'] : 'localhost'; // using '' will trigger an xmlrpc error...
+ if (isset($_GET['protocol']) && ($_GET['protocol'] == '1' || $_GET['protocol'] == '2')) {
+ $protocol = $_GET['protocol'];
+ }
+ if (strpos($host, 'http://') === 0) {
+ $host = substr($host, 7);
+ } elseif (strpos($host, 'https://') === 0) {
+ $host = substr($host, 8);
+ $protocol = 2;
+ }
+ $port = isset($_GET['port']) ? $_GET['port'] : '';
+ $path = isset($_GET['path']) ? $_GET['path'] : '';
+ // in case user forgot initial '/' in xmlrpc server path, add it back
+ if ($path && ($path[0]) != '/') {
+ $path = '/' . $path;
+ }
+
+ if (isset($_GET['debug']) && ($_GET['debug'] == '1' || $_GET['debug'] == '2')) {
+ $debug = $_GET['debug'];
+ }
+
+ $verifyhost = (isset($_GET['verifyhost']) && ($_GET['verifyhost'] == '1' || $_GET['verifyhost'] == '2')) ? $_GET['verifyhost'] : 0;
+ if (isset($_GET['verifypeer']) && $_GET['verifypeer'] == '1') {
+ $verifypeer = true;
+ } else {
+ $verifypeer = false;
+ }
+ $cainfo = isset($_GET['cainfo']) ? $_GET['cainfo'] : '';
+ $proxy = isset($_GET['proxy']) ? $_GET['proxy'] : 0;
+ if (strpos($proxy, 'http://') === 0) {
+ $proxy = substr($proxy, 7);
+ }
+ $proxyuser = isset($_GET['proxyuser']) ? $_GET['proxyuser'] : '';
+ $proxypwd = isset($_GET['proxypwd']) ? $_GET['proxypwd'] : '';
+ $timeout = isset($_GET['timeout']) ? $_GET['timeout'] : 0;
+ if (!is_numeric($timeout)) {
+ $timeout = 0;
+ }
+ $action = $_GET['action'];
+
+ $method = isset($_GET['method']) ? $_GET['method'] : '';
+ $methodsig = isset($_GET['methodsig']) ? $_GET['methodsig'] : 0;
+ $payload = isset($_GET['methodpayload']) ? $_GET['methodpayload'] : '';
+ $alt_payload = isset($_GET['altmethodpayload']) ? $_GET['altmethodpayload'] : '';
+
+ if (isset($_GET['run']) && $_GET['run'] == 'now') {
+ $run = true;
+ }
+
+ $username = isset($_GET['username']) ? $_GET['username'] : '';
+ $password = isset($_GET['password']) ? $_GET['password'] : '';
+
+ $authtype = (isset($_GET['authtype']) && ($_GET['authtype'] == '2' || $_GET['authtype'] == '8')) ? $_GET['authtype'] : 1;
+
+ if (isset($_GET['requestcompression']) && ($_GET['requestcompression'] == '1' || $_GET['requestcompression'] == '2')) {
+ $requestcompression = $_GET['requestcompression'];
+ } else {
+ $requestcompression = 0;
+ }
+ if (isset($_GET['responsecompression']) && ($_GET['responsecompression'] == '1' || $_GET['responsecompression'] == '2' || $_GET['responsecompression'] == '3')) {
+ $responsecompression = $_GET['responsecompression'];
+ } else {
+ $responsecompression = 0;
+ }
+
+ $clientcookies = isset($_GET['clientcookies']) ? $_GET['clientcookies'] : '';
+} else {
+ $host = '';
+ $port = '';
+ $path = '';
+ $action = '';
+ $method = '';
+ $methodsig = 0;
+ $payload = '';
+ $alt_payload = '';
+ $username = '';
+ $password = '';
+ $authtype = 1;
+ $verifyhost = 0;
+ $verifypeer = false;
+ $cainfo = '';
+ $proxy = '';
+ $proxyuser = '';
+ $proxypwd = '';
+ $timeout = 0;
+ $requestcompression = 0;
+ $responsecompression = 0;
+ $clientcookies = '';
+}
+
+// check input for known XMLRPC attacks against this or other libs
+function payload_is_safe($input)
+{
+ return true;
+}
--- /dev/null
+<?php
+/**
+ * @author Gaetano Giunta
+ * @copyright (C) 2005-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ *
+ * @todo add links to documentation from every option caption
+ * @todo switch params for http compression from 0,1,2 to values to be used directly
+ * @todo add a little bit more CSS formatting: we broke IE box model getting a width > 100%...
+ * @todo add support for more options, such as ntlm auth to proxy, or request charset encoding
+ * @todo parse content of payload textarea to be fed to visual editor
+ * @todo add http no-cache headers
+ **/
+
+// make sure we set the correct charset type for output, so that we can display all characters
+header('Content-Type: text/html; charset=utf-8');
+
+include __DIR__ . '/common.php';
+if ($action == '') {
+ $action = 'list';
+}
+
+// relative path to the visual xmlrpc editing dialog
+$editorpath = '../../phpjsrpc/debugger/';
+$editorlibs = '../../phpjsrpc/lib/';
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+ <title>XMLRPC Debugger</title>
+ <meta name="robots" content="index,nofollow"/>
+ <script type="text/javascript" language="Javascript">
+ if (window.name != 'frmcontroller')
+ top.location.replace('index.php?run=' + escape(self.location));
+ </script>
+ <!-- xmlrpc/jsonrpc base library -->
+ <script type="text/javascript" src="<?php echo $editorlibs; ?>xmlrpc_lib.js"></script>
+ <script type="text/javascript" src="<?php echo $editorlibs; ?>jsonrpc_lib.js"></script>
+ <style type="text/css">
+ <!--
+ html {
+ overflow: -moz-scrollbars-vertical;
+ }
+
+ body {
+ padding: 0.5em;
+ background-color: #EEEEEE;
+ font-family: Verdana, Arial, Helvetica;
+ font-size: 8pt;
+ }
+
+ h1 {
+ font-size: 12pt;
+ margin: 0.5em;
+ }
+
+ h2 {
+ font-size: 10pt;
+ display: inline;
+ vertical-align: top;
+ }
+
+ table {
+ border: 1px solid gray;
+ margin-bottom: 0.5em;
+ padding: 0.25em;
+ width: 100%;
+ }
+
+ #methodpayload {
+ display: inline;
+ }
+
+ td {
+ vertical-align: top;
+ font-family: Verdana, Arial, Helvetica;
+ font-size: 8pt;
+ }
+
+ .labelcell {
+ text-align: right;
+ }
+
+ -->
+ </style>
+ <script language="JavaScript" type="text/javascript">
+ <!--
+ function verifyserver() {
+ if (document.frmaction.host.value == '') {
+ alert('Please insert a server name or address');
+ return false;
+ }
+ if (document.frmaction.path.value == '')
+ document.frmaction.path.value = '/';
+ var action = '';
+ for (counter = 0; counter < document.frmaction.action.length; counter++)
+ if (document.frmaction.action[counter].checked) {
+ action = document.frmaction.action[counter].value;
+ }
+ if (document.frmaction.method.value == '' && (action == 'execute' || action == 'wrap' || action == 'describe')) {
+ alert('Please insert a method name');
+ return false;
+ }
+ if (document.frmaction.authtype.value != '1' && document.frmaction.username.value == '') {
+ alert('No username for authenticating to server: authentication disabled');
+ }
+ return true;
+ }
+
+ function switchaction() {
+ // reset html layout depending on action to be taken
+ var action = '';
+ for (counter = 0; counter < document.frmaction.action.length; counter++)
+ if (document.frmaction.action[counter].checked) {
+ action = document.frmaction.action[counter].value;
+ }
+ if (action == 'execute') {
+ document.frmaction.methodpayload.disabled = false;
+ displaydialogeditorbtn(true);//if (document.getElementById('methodpayloadbtn') != undefined) document.getElementById('methodpayloadbtn').disabled = false;
+ document.frmaction.method.disabled = false;
+ document.frmaction.methodpayload.rows = 10;
+ }
+ else {
+ document.frmaction.methodpayload.rows = 1;
+ if (action == 'describe' || action == 'wrap') {
+ document.frmaction.methodpayload.disabled = true;
+ displaydialogeditorbtn(false); //if (document.getElementById('methodpayloadbtn') != undefined) document.getElementById('methodpayloadbtn').disabled = true;
+ document.frmaction.method.disabled = false;
+ }
+ else // list
+ {
+ document.frmaction.methodpayload.disabled = true;
+ displaydialogeditorbtn(false); //if (document.getElementById('methodpayloadbtn') != undefined) document.getElementById('methodpayloadbtn').disabled = false;
+ document.frmaction.method.disabled = true;
+ }
+ }
+ }
+
+ function switchssl() {
+ if (document.frmaction.protocol.value != '2') {
+ document.frmaction.verifypeer.disabled = true;
+ document.frmaction.verifyhost.disabled = true;
+ document.frmaction.cainfo.disabled = true;
+ }
+ else {
+ document.frmaction.verifypeer.disabled = false;
+ document.frmaction.verifyhost.disabled = false;
+ document.frmaction.cainfo.disabled = false;
+ }
+ }
+
+ function switchauth() {
+ if (document.frmaction.protocol.value != '0') {
+ document.frmaction.authtype.disabled = false;
+ }
+ else {
+ document.frmaction.authtype.disabled = true;
+ document.frmaction.authtype.value = 1;
+ }
+ }
+
+ function swicthcainfo() {
+ if (document.frmaction.verifypeer.checked == true) {
+ document.frmaction.cainfo.disabled = false;
+ }
+ else {
+ document.frmaction.cainfo.disabled = true;
+ }
+ }
+
+ function switchtransport(is_json) {
+ if (is_json == 0) {
+ document.getElementById("idcell").style.visibility = 'hidden';
+ document.frmjsonrpc.yes.checked = false;
+ document.frmxmlrpc.yes.checked = true;
+ document.frmaction.wstype.value = "0";
+ }
+ else {
+ document.getElementById("idcell").style.visibility = 'visible';
+ document.frmjsonrpc.yes.checked = true;
+ document.frmxmlrpc.yes.checked = false;
+ document.frmaction.wstype.value = "1";
+ }
+ }
+
+ function displaydialogeditorbtn(show) {
+ if (show && ((typeof base64_decode) == 'function')) {
+ document.getElementById('methodpayloadbtn').innerHTML = '[<a href="#" onclick="activateeditor(); return false;">Edit</a>]';
+ }
+ else {
+ document.getElementById('methodpayloadbtn').innerHTML = '';
+ }
+ }
+
+ function activateeditor() {
+ var url = '<?php echo $editorpath; ?>visualeditor.php?params=<?php echo $alt_payload; ?>';
+ if (document.frmaction.wstype.value == "1")
+ url += '&type=jsonrpc';
+ var wnd = window.open(url, '_blank', 'width=750, height=400, location=0, resizable=1, menubar=0, scrollbars=1');
+ }
+
+ // if javascript version of the lib is found, allow it to send us params
+ function buildparams(base64data) {
+ if (typeof base64_decode == 'function') {
+ if (base64data == '0') // workaround for bug in base64_encode...
+ document.getElementById('methodpayload').value = '';
+ else
+ document.getElementById('methodpayload').value = base64_decode(base64data);
+ }
+ }
+
+ // use GET for ease of refresh, switch to POST when payload is too big to fit in url (in IE: 2048 bytes! see http://support.microsoft.com/kb/q208427/)
+ function switchFormMethod() {
+ /// @todo use a more precise calculation, adding the rest of the fields to the actual generated url lenght
+ if (document.frmaction.methodpayload.value.length > 1536) {
+ document.frmaction.action = 'action.php?usepost=true';
+ document.frmaction.method = 'post';
+ }
+ }
+
+ //-->
+ </script>
+</head>
+<body
+ onload="switchtransport(<?php echo $wstype; ?>); switchaction(); switchssl(); switchauth(); swicthcainfo();<?php if ($run) {
+ echo ' document.forms[2].submit();';
+ } ?>">
+<h1>XMLRPC
+ <form name="frmxmlrpc" style="display: inline;" action="."><input name="yes" type="radio" onclick="switchtransport(0);"/></form>
+ /
+ <form name="frmjsonrpc" style="display: inline;" action="."><input name="yes" type="radio" onclick="switchtransport(1);"/></form>
+ JSONRPC Debugger (based on the <a href="http://gggeek.github.io/phpxmlrpc/">PHP-XMLRPC</a> library)
+</h1>
+<form name="frmaction" method="get" action="action.php" target="frmaction" onSubmit="switchFormMethod();">
+
+ <table id="serverblock">
+ <tr>
+ <td><h2>Target server</h2></td>
+ <td class="labelcell">Address:</td>
+ <td><input type="text" name="host" value="<?php echo htmlspecialchars($host, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td class="labelcell">Port:</td>
+ <td><input type="text" name="port" value="<?php echo htmlspecialchars($port, ENT_COMPAT, $inputcharset); ?>" size="5" maxlength="5"/>
+ </td>
+ <td class="labelcell">Path:</td>
+ <td><input type="text" name="path" value="<?php echo htmlspecialchars($path, ENT_COMPAT, $inputcharset); ?>"/></td>
+ </tr>
+ </table>
+
+ <table id="actionblock">
+ <tr>
+ <td><h2>Action</h2></td>
+ <td>List available methods<input type="radio" name="action" value="list"<?php if ($action == 'list') { echo ' checked="checked"'; } ?> onclick="switchaction();"/></td>
+ <td>Describe method<input type="radio" name="action" value="describe"<?php if ($action == 'describe') { echo ' checked="checked"'; } ?> onclick="switchaction();"/></td>
+ <td>Execute method<input type="radio" name="action" value="execute"<?php if ($action == 'execute') { echo ' checked="checked"'; } ?> onclick="switchaction();"/></td>
+ <td>Generate stub for method call<input type="radio" name="action" value="wrap"<?php if ($action == 'wrap') { echo ' checked="checked"'; } ?> onclick="switchaction();"/></td>
+ </tr>
+ </table>
+ <input type="hidden" name="methodsig" value="<?php echo htmlspecialchars($methodsig, ENT_COMPAT, $inputcharset); ?>"/>
+
+ <table id="methodblock">
+ <tr>
+ <td><h2>Method</h2></td>
+ <td class="labelcell">Name:</td>
+ <td><input type="text" name="method" value="<?php echo htmlspecialchars($method, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td class="labelcell">Payload:<br/>
+ <div id="methodpayloadbtn"></div>
+ </td>
+ <td><textarea id="methodpayload" name="methodpayload" rows="1" cols="40"><?php echo htmlspecialchars($payload, ENT_COMPAT, $inputcharset); ?></textarea></td>
+ <td class="labelcell" id="idcell">Msg id: <input type="text" name="id" size="3" value="<?php echo htmlspecialchars($id, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td><input type="hidden" name="wstype" value="<?php echo $wstype; ?>"/>
+ <input type="submit" value="Execute" onclick="return verifyserver();"/></td>
+ </tr>
+ </table>
+
+ <table id="optionsblock">
+ <tr>
+ <td><h2>Client options</h2></td>
+ <td class="labelcell">Show debug info:</td>
+ <td><select name="debug">
+ <option value="0"<?php if ($debug == 0) { echo ' selected="selected"'; } ?>>No</option>
+ <option value="1"<?php if ($debug == 1) { echo ' selected="selected"'; } ?>>Yes</option>
+ <option value="2"<?php if ($debug == 2) { echo ' selected="selected"'; } ?>>More</option>
+ </select>
+ </td>
+ <td class="labelcell">Timeout:</td>
+ <td><input type="text" name="timeout" size="3" value="<?php if ($timeout > 0) { echo $timeout; } ?>"/></td>
+ <td class="labelcell">Protocol:</td>
+ <td><select name="protocol" onchange="switchssl(); switchauth(); swicthcainfo();">
+ <option value="0"<?php if ($protocol == 0) { echo ' selected="selected"'; } ?>>HTTP 1.0</option>
+ <option value="1"<?php if ($protocol == 1) { echo ' selected="selected"'; } ?>>HTTP 1.1</option>
+ <option value="2"<?php if ($protocol == 2) { echo ' selected="selected"'; } ?>>HTTPS</option>
+ </select></td>
+ </tr>
+ <tr>
+ <td class="labelcell">AUTH:</td>
+ <td class="labelcell">Username:</td>
+ <td><input type="text" name="username" value="<?php echo htmlspecialchars($username, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td class="labelcell">Pwd:</td>
+ <td><input type="password" name="password" value="<?php echo htmlspecialchars($password, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td class="labelcell">Type</td>
+ <td><select name="authtype">
+ <option value="1"<?php if ($authtype == 1) { echo ' selected="selected"'; } ?>>Basic</option>
+ <option value="2"<?php if ($authtype == 2) { echo ' selected="selected"'; } ?>>Digest</option>
+ <option value="8"<?php if ($authtype == 8) { echo ' selected="selected"'; } ?>>NTLM</option>
+ </select></td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class="labelcell">SSL:</td>
+ <td class="labelcell">Verify Host's CN:</td>
+ <td><select name="verifyhost">
+ <option value="0"<?php if ($verifyhost == 0) { echo ' selected="selected"'; } ?>>No</option>
+ <option value="1"<?php if ($verifyhost == 1) { echo ' selected="selected"'; } ?>>Check CN existence</option>
+ <option value="2"<?php if ($verifyhost == 2) { echo ' selected="selected"'; } ?>>Check CN match</option>
+ </select></td>
+ <td class="labelcell">Verify Cert:</td>
+ <td><input type="checkbox" value="1" name="verifypeer" onclick="swicthcainfo();"<?php if ($verifypeer) { echo ' checked="checked"'; } ?> /></td>
+ <td class="labelcell">CA Cert file:</td>
+ <td><input type="text" name="cainfo" value="<?php echo htmlspecialchars($cainfo, ENT_COMPAT, $inputcharset); ?>"/></td>
+ </tr>
+ <tr>
+ <td class="labelcell">PROXY:</td>
+ <td class="labelcell">Server:</td>
+ <td><input type="text" name="proxy" value="<?php echo htmlspecialchars($proxy, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td class="labelcell">Proxy user:</td>
+ <td><input type="text" name="proxyuser" value="<?php echo htmlspecialchars($proxyuser, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td class="labelcell">Proxy pwd:</td>
+ <td><input type="password" name="proxypwd" value="<?php echo htmlspecialchars($proxypwd, ENT_COMPAT, $inputcharset); ?>"/></td>
+ </tr>
+ <tr>
+ <td class="labelcell">COMPRESSION:</td>
+ <td class="labelcell">Request:</td>
+ <td><select name="requestcompression">
+ <option value="0"<?php if ($requestcompression == 0) { echo ' selected="selected"'; } ?>>None </option>
+ <option value="1"<?php if ($requestcompression == 1) { echo ' selected="selected"'; } ?>>Gzip</option>
+ <option value="2"<?php if ($requestcompression == 2) { echo ' selected="selected"'; } ?>>Deflate</option>
+ </select></td>
+ <td class="labelcell">Response:</td>
+ <td><select name="responsecompression">
+ <option value="0"<?php if ($responsecompression == 0) { echo ' selected="selected"'; } ?>>None</option>
+ <option value="1"<?php if ($responsecompression == 1) { echo ' selected="selected"'; } ?>>Gzip</option>
+ <option value="2"<?php if ($responsecompression == 2) { echo ' selected="selected"'; } ?>>Deflate</option>
+ <option value="3"<?php if ($responsecompression == 3) { echo ' selected="selected"'; } ?>>Any</option>
+ </select></td>
+ <td></td>
+ </tr>
+ <tr>
+ <td class="labelcell">COOKIES:</td>
+ <td colspan="4" class="labelcell"><input type="text" name="clientcookies" size="80" value="<?php echo htmlspecialchars($clientcookies, ENT_COMPAT, $inputcharset); ?>"/></td>
+ <td colspan="2">Format: 'cookie1=value1, cookie2=value2'</td>
+ </tr>
+ </table>
+
+</form>
+</body>
+</html>
--- /dev/null
+<?php
+$query = '';
+if (isset($_GET['run'])) {
+ $path = parse_url($_GET['run']);
+ if (isset($path['query'])) {
+ $query = '?' . $path['query'];
+ }
+}
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+<html>
+<head>
+ <title>XMLRPC Debugger</title>
+</head>
+<frameset rows="360,*">
+ <frame name="frmcontroller" src="controller.php<?php echo htmlspecialchars($query); ?>" marginwidth="0"
+ marginheight="0" frameborder="0"/>
+ <frame name="frmaction" src="action.php" marginwidth="0" marginheight="0" frameborder="0"/>
+</frameset>
+</html>
--- /dev/null
+<html>
+<head><title>xmlrpc - Agesort demo</title></head>
+<body>
+<h1>Agesort demo</h1>
+
+<h2>Send an array of 'name' => 'age' pairs to the server that will send it back sorted.</h2>
+
+<h3>The source code demonstrates basic lib usage, including handling of xmlrpc arrays and structs</h3>
+
+<p></p>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+$inAr = array("Dave" => 24, "Edd" => 45, "Joe" => 37, "Fred" => 27);
+print "This is the input data:<br/><pre>";
+foreach($inAr as $key => $val) {
+ print $key . ", " . $val . "\n";
+}
+print "</pre>";
+
+// create parameters from the input array: an xmlrpc array of xmlrpc structs
+$p = array();
+foreach ($inAr as $key => $val) {
+ $p[] = new PhpXmlRpc\Value(
+ array(
+ "name" => new PhpXmlRpc\Value($key),
+ "age" => new PhpXmlRpc\Value($val, "int")
+ ),
+ "struct"
+ );
+}
+$v = new PhpXmlRpc\Value($p, "array");
+print "Encoded into xmlrpc format it looks like this: <pre>\n" . htmlentities($v->serialize()) . "</pre>\n";
+
+// create client and message objects
+$req = new PhpXmlRpc\Request('examples.sortByAge', array($v));
+$client = new PhpXmlRpc\Client("http://phpxmlrpc.sourceforge.net/server.php");
+
+// set maximum debug level, to have the complete communication printed to screen
+$client->setDebug(2);
+
+// send request
+print "Now sending request (detailed debug info follows)";
+$resp = $client->send($req);
+
+// check response for errors, and take appropriate action
+if (!$resp->faultCode()) {
+ print "The server gave me these results:<pre>";
+ $value = $resp->value();
+ foreach ($value as $struct) {
+ $name = $struct["name"];
+ $age = $struct["age"];
+ print htmlspecialchars($name->scalarval()) . ", " . htmlspecialchars($age->scalarval()) . "\n";
+ }
+
+ print "<hr/>For nerds: I got this value back<br/><pre>" .
+ htmlentities($resp->serialize()) . "</pre><hr/>\n";
+} else {
+ print "An error occurred:<pre>";
+ print "Code: " . htmlspecialchars($resp->faultCode()) .
+ "\nReason: '" . htmlspecialchars($resp->faultString()) . '\'</pre><hr/>';
+}
+
+?>
+</body>
+</html>
--- /dev/null
+<html>
+<head><title>xmlrpc - Getstatename demo</title></head>
+<body>
+<h1>Getstatename demo</h1>
+
+<h2>Send a U.S. state number to the server and get back the state name</h2>
+
+<h3>The code demonstrates usage of automatic encoding/decoding of php variables into xmlrpc values</h3>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+if (isset($_POST["stateno"]) && $_POST["stateno"] != "") {
+ $stateNo = (integer)$_POST["stateno"];
+ $encoder = new PhpXmlRpc\Encoder();
+ $req = new PhpXmlRpc\Request('examples.getStateName',
+ array($encoder->encode($stateNo))
+ );
+ print "Sending the following request:<pre>\n\n" . htmlentities($req->serialize()) . "\n\n</pre>Debug info of server data follows...\n\n";
+ $client = new PhpXmlRpc\Client("http://phpxmlrpc.sourceforge.net/server.php");
+ $client->setDebug(1);
+ $r = $client->send($req);
+ if (!$r->faultCode()) {
+ $v = $r->value();
+ print "<br/>State number <b>" . $stateNo . "</b> is <b>"
+ . htmlspecialchars($encoder->decode($v)) . "</b><br/>";
+ } else {
+ print "An error occurred: ";
+ print "Code: " . htmlspecialchars($r->faultCode())
+ . " Reason: '" . htmlspecialchars($r->faultString()) . "'</pre><br/>";
+ }
+} else {
+ $stateNo = "";
+}
+
+print "<form action=\"getstatename.php\" method=\"POST\">
+<input name=\"stateno\" value=\"" . $stateNo . "\"><input type=\"submit\" value=\"go\" name=\"submit\"></form>
+<p>Enter a state number to query its name</p>";
+
+?>
+</body>
+</html>
--- /dev/null
+<html>
+<head><title>xmlrpc - Introspect demo</title></head>
+<body>
+<h1>Introspect demo</h1>
+<h2>Query server for available methods and their description</h2>
+<h3>The code demonstrates usage of multicall and introspection methods</h3>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+function display_error($r)
+{
+ print "An error occurred: ";
+ print "Code: " . $r->faultCode()
+ . " Reason: '" . $r->faultString() . "'<br/>";
+}
+
+$client = new PhpXmlRpc\Client("http://phpxmlrpc.sourceforge.net/server.php");
+
+// First off, let's retrieve the list of methods available on the remote server
+print "<h3>methods available at http://" . $client->server . $client->path . "</h3>\n";
+$req = new PhpXmlRpc\Request('system.listMethods');
+$resp = $client->send($req);
+
+if ($resp->faultCode()) {
+ display_error($resp);
+} else {
+ $v = $resp->value();
+
+ // Then, retrieve the signature and help text of each available method
+ foreach ($v as $methodName) {
+ print "<h4>" . $methodName->scalarval() . "</h4>\n";
+ // build messages first, add params later
+ $m1 = new PhpXmlRpc\Request('system.methodHelp');
+ $m2 = new PhpXmlRpc\Request('system.methodSignature');
+ $val = new PhpXmlRpc\Value($methodName->scalarval(), "string");
+ $m1->addParam($val);
+ $m2->addParam($val);
+ // Send multiple requests in one http call.
+ // If server does not support multicall, client will automatically fall back to 2 separate calls
+ $ms = array($m1, $m2);
+ $rs = $client->send($ms);
+ if ($rs[0]->faultCode()) {
+ display_error($rs[0]);
+ } else {
+ $val = $rs[0]->value();
+ $txt = $val->scalarval();
+ if ($txt != "") {
+ print "<h4>Documentation</h4><p>${txt}</p>\n";
+ } else {
+ print "<p>No documentation available.</p>\n";
+ }
+ }
+ if ($rs[1]->faultCode()) {
+ display_error($rs[1]);
+ } else {
+ print "<h4>Signature</h4><p>\n";
+ // note: using PhpXmlRpc\Encoder::decode() here would lead to cleaner code
+ $val = $rs[1]->value();
+ if ($val->kindOf() == "array") {
+ foreach ($val as $x) {
+ $ret = $x[0];
+ print "<code>" . $ret->scalarval() . " "
+ . $methodName->scalarval() . "(";
+ if ($x->count() > 1) {
+ for ($k = 1; $k < $x->count(); $k++) {
+ $y = $x[$k];
+ print $y->scalarval();
+ if ($k < $x->count() - 1) {
+ print ", ";
+ }
+ }
+ }
+ print ")</code><br/>\n";
+ }
+ } else {
+ print "Signature unknown\n";
+ }
+ print "</p>\n";
+ }
+ }
+}
+?>
+</body>
+</html>
--- /dev/null
+<?php
+// Allow users to see the source of this file even if PHP is not configured for it
+if (isset($_GET['showSource']) && $_GET['showSource']) {
+ highlight_file(__FILE__);
+ die();
+}
+?>
+<html>
+<head><title>xmlrpc - Mail demo</title></head>
+<body>
+<h1>Mail demo</h1>
+
+<p>This form enables you to send mail via an XML-RPC server.
+ When you press <kbd>Send</kbd> this page will reload, showing you the XML-RPC request sent to the host server, the
+ XML-RPC response received and the internal evaluation done by the PHP implementation.</p>
+
+<p>You can find the source to this page here: <a href="mail.php?showSource=1">mail.php</a><br/>
+ And the source to a functionally identical mail-by-XML-RPC server in the file <a
+ href="../server/server.php?showSource=1">server.php</a> included with the library (look for the 'mail_send'
+ method)</p>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+if (isset($_POST["mailto"]) && $_POST["mailto"]) {
+ $server = "http://phpxmlrpc.sourceforge.net/server.php";
+ $req = new PhpXmlRpc\Request('mail.send', array(
+ new PhpXmlRpc\Value($_POST["mailto"]),
+ new PhpXmlRpc\Value($_POST["mailsub"]),
+ new PhpXmlRpc\Value($_POST["mailmsg"]),
+ new PhpXmlRpc\Value($_POST["mailfrom"]),
+ new PhpXmlRpc\Value($_POST["mailcc"]),
+ new PhpXmlRpc\Value($_POST["mailbcc"]),
+ new PhpXmlRpc\Value("text/plain")
+ ));
+
+ $client = new PhpXmlRpc\Client($server);
+ $client->setDebug(2);
+ $resp = $client->send($req);
+ if (!$resp->faultCode()) {
+ print "Mail sent OK<br/>\n";
+ } else {
+ print "<fonr color=\"red\">";
+ print "Mail send failed<br/>\n";
+ print "Fault: ";
+ print "Code: " . htmlspecialchars($resp->faultCode()) .
+ " Reason: '" . htmlspecialchars($resp->faultString()) . "'<br/>";
+ print "</font><br/>";
+ }
+}
+?>
+<form method="POST">
+ From <input size="60" name="mailfrom" value=""/><br/>
+ <hr/>
+ To <input size="60" name="mailto" value=""/><br/>
+ Cc <input size="60" name="mailcc" value=""/><br/>
+ Bcc <input size="60" name="mailbcc" value=""/><br/>
+ <hr/>
+ Subject <input size="60" name="mailsub" value="A message from xmlrpc"/>
+ <hr/>
+ Body <textarea rows="7" cols="60" name="mailmsg">Your message here</textarea><br/>
+ <input type="Submit" value="Send"/>
+</form>
+</body>
+</html>
--- /dev/null
+<html>
+<head><title>xmlrpc - Proxy demo</title></head>
+<body>
+<h1>proxy demo</h1>
+<h2>Query server using a 'proxy' object</h2>
+<h3>The code demonstrates usage for the terminally lazy. For a more complete proxy, look at at the Wrapper class</h3>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+class PhpXmlRpcProxy
+{
+ protected $client;
+ protected $prefix = 'examples.';
+
+ public function __construct(PhpXmlRpc\Client $client)
+ {
+ $this->client = $client;
+ }
+
+ /**
+ * Translates any method call to an xmlrpc call.
+ *
+ * @author Toth Istvan
+ *
+ * @param string $name remote function name. Will be prefixed
+ * @param array $arguments
+ *
+ * @return mixed
+ *
+ * @throws Exception
+ */
+ function __call($name, $arguments)
+ {
+ $encoder = new PhpXmlRpc\Encoder();
+ $valueArray = array();
+ foreach ($arguments as $parameter) {
+ $valueArray[] = $encoder->encode($parameter);
+ }
+
+ // just in case this was set to something else
+ $this->client->return_type = 'phpvals';
+
+ $resp = $this->client->send(new PhpXmlRpc\Request($this->prefix.$name, $valueArray));
+
+ if ($resp->faultCode()) {
+ throw new Exception($resp->faultString(), $resp->faultCode());
+ } else {
+ return $resp->value();
+ }
+ }
+
+}
+
+$stateNo = rand(1, 51);
+$proxy = new PhpXmlRpcProxy(new \PhpXmlRpc\Client('http://phpxmlrpc.sourceforge.net/server.php'));
+$stateName = $proxy->getStateName($stateNo);
+
+echo "State $stateNo is ".htmlspecialchars($stateName);
\ No newline at end of file
--- /dev/null
+<html>
+<head><title>xmlrpc - Which toolkit demo</title></head>
+<body>
+<h1>Which toolkit demo</h1>
+<h2>Query server for toolkit information</h2>
+<h3>The code demonstrates usage of the PhpXmlRpc\Encoder class</h3>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+$req = new PhpXmlRpc\Request('interopEchoTests.whichToolkit', array());
+$client = new PhpXmlRpc\Client("http://phpxmlrpc.sourceforge.net/server.php");
+$resp = $client->send($req);
+if (!$resp->faultCode()) {
+ $encoder = new PhpXmlRpc\Encoder();
+ $value = $encoder->decode($resp->value());
+ print "<pre>";
+ print "name: " . htmlspecialchars($value["toolkitName"]) . "\n";
+ print "version: " . htmlspecialchars($value["toolkitVersion"]) . "\n";
+ print "docs: " . htmlspecialchars($value["toolkitDocsUrl"]) . "\n";
+ print "os: " . htmlspecialchars($value["toolkitOperatingSystem"]) . "\n";
+ print "</pre>";
+} else {
+ print "An error occurred: ";
+ print "Code: " . htmlspecialchars($resp->faultCode()) . " Reason: '" . htmlspecialchars($resp->faultString()) . "'\n";
+}
+?>
+</body>
+</html>
--- /dev/null
+<html>
+<head><title>xmlrpc - Webservice wrappper demo</title></head>
+<body>
+<h1>Webservice wrappper demo</h1>
+
+<h2>Wrap methods exposed by server into php functions</h2>
+
+<h3>The code demonstrates usage of some the most automagic client usage possible:<br/>
+ 1) client that returns php values instead of xmlrpc value objects<br/>
+ 2) wrapping of remote methods into php functions<br/>
+ See also proxy.php for an alternative take
+</h3>
+<?php
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+$client = new PhpXmlRpc\Client("http://phpxmlrpc.sourceforge.net/server.php");
+$client->return_type = 'phpvals'; // let client give us back php values instead of xmlrpcvals
+$resp = $client->send(new PhpXmlRpc\Request('system.listMethods'));
+if ($resp->faultCode()) {
+ echo "<p>Server methods list could not be retrieved: error {$resp->faultCode()} '" . htmlspecialchars($resp->faultString()) . "'</p>\n";
+} else {
+ echo "<p>Server methods list retrieved, now wrapping it up...</p>\n<ul>\n";
+ flush();
+
+ $callable = false;
+ $wrapper = new PhpXmlRpc\Wrapper();
+ foreach ($resp->value() as $methodName) {
+ // $resp->value is an array of strings
+ if ($methodName == 'examples.getStateName') {
+ $callable = $wrapper->wrapXmlrpcMethod($client, $methodName);
+ if ($callable) {
+ echo "<li>Remote server method " . htmlspecialchars($methodName) . " wrapped into php function</li>\n";
+ } else {
+ echo "<li>Remote server method " . htmlspecialchars($methodName) . " could not be wrapped!</li>\n";
+ }
+ break;
+ }
+ }
+ echo "</ul>\n";
+ flush();
+
+ if ($callable) {
+ echo "Now testing function for remote method to convert U.S. state number into state name";
+ $stateNum = rand(1, 51);
+ // the 2nd parameter gets added to the closure - it is teh debug level to be used for the client
+ $stateName = $callable($stateNum, 2);
+ }
+}
+?>
+</body>
+</html>
--- /dev/null
+<?xml version="1.0"?>
+<methodResponse>
+ <params>
+ <param>
+ <value>
+ <struct>
+ <member>
+ <name>thearray</name>
+ <value>
+ <array>
+ <data>
+ <value>
+ <string>ABCDEFHIJ</string>
+ </value>
+ <value>
+ <int>1234</int>
+ </value>
+ <value>
+ <boolean>1</boolean>
+ </value>
+ </data>
+ </array>
+ </value>
+ </member>
+ <member>
+ <name>theint</name>
+ <value>
+ <int>23</int>
+ </value>
+ </member>
+ <member>
+ <name>thestring</name>
+ <value>
+ <string>foobarwhizz</string>
+ </value>
+ </member>
+ <member>
+ <name>thestruct</name>
+ <value>
+ <struct>
+ <member>
+ <name>one</name>
+ <value>
+ <int>1</int>
+ </value>
+ </member>
+ <member>
+ <name>two</name>
+ <value>
+ <int>2</int>
+ </value>
+ </member>
+ </struct>
+ </value>
+ </member>
+ </struct>
+ </value>
+ </param>
+ </params>
+</methodResponse>
--- /dev/null
+<?xml version="1.0"?>
+<methodResponse>
+ <params>
+ <param>
+ <value>
+ <string>South Dakota's own</string>
+ </value>
+ </param>
+ </params>
+</methodResponse>
--- /dev/null
+<?xml version="1.0"?>
+<methodResponse>
+ <fault>
+ <value>
+ <struct>
+ <member>
+ <name>faultCode</name>
+ <value>
+ <int>4</int>
+ </value>
+ </member>
+ <member>
+ <name>faultString</name>
+ <value>
+ <string>Too many parameters.</string>
+ </value>
+ </member>
+ </struct>
+ </value>
+ </fault>
+</methodResponse>
--- /dev/null
+<?php
+
+include_once __DIR__ . "/../../vendor/autoload.php";
+
+use PhpXmlRpc\Value;
+
+$addComment_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcString, Value::$xmlrpcString, Value::$xmlrpcString));
+
+$addComment_doc = 'Adds a comment to an item. The first parameter
+is the item ID, the second the name of the commenter, and the third
+is the comment itself. Returns the number of comments against that
+ID.';
+
+function addComment($req)
+{
+ $err = "";
+ // since validation has already been carried out for us,
+ // we know we got exactly 3 string values
+ $encoder = new PhpXmlRpc\Encoder();
+ $n = $encoder->decode($req);
+ $msgID = $n[0];
+ $name = $n[1];
+ $comment = $n[2];
+
+ $dbh = dba_open("/tmp/comments.db", "c", "db2");
+ if ($dbh) {
+ $countID = "${msgID}_count";
+ if (dba_exists($countID, $dbh)) {
+ $count = dba_fetch($countID, $dbh);
+ } else {
+ $count = 0;
+ }
+ // add the new comment in
+ dba_insert($msgID . "_comment_${count}", $comment, $dbh);
+ dba_insert($msgID . "_name_${count}", $name, $dbh);
+ $count++;
+ dba_replace($countID, $count, $dbh);
+ dba_close($dbh);
+ } else {
+ $err = "Unable to open comments database.";
+ }
+ // if we generated an error, create an error return response
+ if ($err) {
+ return new PhpXmlRpc\Response(0, PhpXmlRpc\PhpXmlRpc::$xmlrpcerruser, $err);
+ } else {
+ // otherwise, we create the right response
+ return new PhpXmlRpc\Response(new PhpXmlRpc\Value($count, "int"));
+ }
+}
+
+$getComments_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcString));
+
+$getComments_doc = 'Returns an array of comments for a given ID, which
+is the sole argument. Each array item is a struct containing name
+and comment text.';
+
+function getComments($req)
+{
+ $err = "";
+ $ra = array();
+ $encoder = new PhpXmlRpc\Encoder();
+ $msgID = $encoder->decode($req->getParam(0));
+ $dbh = dba_open("/tmp/comments.db", "r", "db2");
+ if ($dbh) {
+ $countID = "${msgID}_count";
+ if (dba_exists($countID, $dbh)) {
+ $count = dba_fetch($countID, $dbh);
+ for ($i = 0; $i < $count; $i++) {
+ $name = dba_fetch("${msgID}_name_${i}", $dbh);
+ $comment = dba_fetch("${msgID}_comment_${i}", $dbh);
+ // push a new struct onto the return array
+ $ra[] = array(
+ "name" => $name,
+ "comment" => $comment,
+ );
+ }
+ }
+ }
+ // if we generated an error, create an error return response
+ if ($err) {
+ return new PhpXmlRpc\Response(0, PhpXmlRpc\PhpXmlRpc::$xmlrpcerruser, $err);
+ } else {
+ // otherwise, we create the right response
+ return new PhpXmlRpc\Response($encoder->encode($ra));
+ }
+}
+
+$srv = new PhpXmlRpc\Server(array(
+ "discuss.addComment" => array(
+ "function" => "addComment",
+ "signature" => $addComment_sig,
+ "docstring" => $addComment_doc,
+ ),
+ "discuss.getComments" => array(
+ "function" => "getComments",
+ "signature" => $getComments_sig,
+ "docstring" => $getComments_doc,
+ ),
+));
--- /dev/null
+<?php
+/**
+ * XMLRPC server acting as proxy for requests to other servers
+ * (useful e.g. for ajax-originated calls that can only connect back to
+ * the originating server).
+ *
+ * @author Gaetano Giunta
+ * @copyright (C) 2006-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ */
+
+include_once __DIR__ . "/../../src/Autoloader.php";
+PhpXmlRpc\Autoloader::register();
+
+/**
+ * Forward an xmlrpc request to another server, and return to client the response received.
+ *
+ * DO NOT RUN AS IS IN PRODUCTION - this is an open relay !!!
+ *
+ * @param PhpXmlRpc\Request $req (see method docs below for a description of the expected parameters)
+ *
+ * @return PhpXmlRpc\Response
+ */
+function forward_request($req)
+{
+ $encoder = new \PhpXmlRpc\Encoder();
+
+ // create client
+ $timeout = 0;
+ $url = $encoder->decode($req->getParam(0));
+ $client = new PhpXmlRpc\Client($url);
+
+ if ($req->getNumParams() > 3) {
+ // we have to set some options onto the client.
+ // Note that if we do not untaint the received values, warnings might be generated...
+ $options = $encoder->decode($req->getParam(3));
+ foreach ($options as $key => $val) {
+ switch ($key) {
+ case 'Cookie':
+ break;
+ case 'Credentials':
+ break;
+ case 'RequestCompression':
+ $client->setRequestCompression($val);
+ break;
+ case 'SSLVerifyHost':
+ $client->setSSLVerifyHost($val);
+ break;
+ case 'SSLVerifyPeer':
+ $client->setSSLVerifyPeer($val);
+ break;
+ case 'Timeout':
+ $timeout = (integer)$val;
+ break;
+ } // switch
+ }
+ }
+
+ // build call for remote server
+ /// @todo find a way to forward client info (such as IP) to server, either
+ /// - as xml comments in the payload, or
+ /// - using std http header conventions, such as X-forwarded-for...
+ $reqMethod = $encoder->decode($req->getParam(1));
+ $pars = $req->getParam(2);
+ $req = new PhpXmlRpc\Request($reqMethod);
+ foreach ($pars as $par) {
+ $req->addParam($par);
+ }
+
+ // add debug info into response we give back to caller
+ PhpXmlRpc\Server::xmlrpc_debugmsg("Sending to server $url the payload: " . $req->serialize());
+
+ return $client->send($req, $timeout);
+}
+
+// run the server
+$server = new PhpXmlRpc\Server(
+ array(
+ 'xmlrpcproxy.call' => array(
+ 'function' => 'forward_request',
+ 'signature' => array(
+ array('mixed', 'string', 'string', 'array'),
+ array('mixed', 'string', 'string', 'array', 'struct'),
+ ),
+ 'docstring' => 'forwards xmlrpc calls to remote servers. Returns remote method\'s response. Accepts params: remote server url (might include basic auth credentials), method name, array of params, and (optionally) a struct containing call options',
+ ),
+ )
+);
--- /dev/null
+<?php
+/**
+ * Demo server for xmlrpc library.
+ *
+ * Implements a lot of webservices, including a suite of services used for
+ * interoperability testing (validator1 methods), and some whose only purpose
+ * is to be used for unit-testing the library.
+ *
+ * Please do not copy this file verbatim into your production server.
+ **/
+
+// give user a chance to see the source for this server instead of running the services
+if ($_SERVER['REQUEST_METHOD'] != 'POST' && isset($_GET['showSource'])) {
+ highlight_file(__FILE__);
+ die();
+}
+
+include_once __DIR__ . "/../../vendor/autoload.php";
+
+// out-of-band information: let the client manipulate the server operations.
+// we do this to help the testsuite script: do not reproduce in production!
+if (isset($_COOKIE['PHPUNIT_SELENIUM_TEST_ID']) && extension_loaded('xdebug')) {
+ $GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY'] = '/tmp/phpxmlrpc_coverage';
+ if (!is_dir($GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY'])) {
+ mkdir($GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY']);
+ }
+
+ include_once __DIR__ . "/../../vendor/phpunit/phpunit-selenium/PHPUnit/Extensions/SeleniumCommon/prepend.php";
+}
+
+use PhpXmlRpc\Value;
+
+/**
+ * Used to test usage of object methods in dispatch maps and in wrapper code.
+ */
+class xmlrpcServerMethodsContainer
+{
+ /**
+ * Method used to test logging of php warnings generated by user functions.
+ * @param PhpXmlRpc\Request $req
+ * @return PhpXmlRpc\Response
+ */
+ public function phpWarningGenerator($req)
+ {
+ $a = $undefinedVariable; // this triggers a warning in E_ALL mode, since $undefinedVariable is undefined
+ return new PhpXmlRpc\Response(new Value(1, Value::$xmlrpcBoolean));
+ }
+
+ /**
+ * Method used to test catching of exceptions in the server.
+ * @param PhpXmlRpc\Request $req
+ * @throws Exception
+ */
+ public function exceptionGenerator($req)
+ {
+ throw new Exception("it's just a test", 1);
+ }
+
+ /**
+ * @param string $msg
+ */
+ public function debugMessageGenerator($msg)
+ {
+ PhpXmlRpc\Server::xmlrpc_debugmsg($msg);
+ }
+
+ /**
+ * A PHP version of the state-number server. Send me an integer and i'll sell you a state.
+ * Used to test wrapping of PHP methods into xmlrpc methods.
+ *
+ * @param integer $num
+ * @return string
+ * @throws Exception
+ */
+ public static function findState($num)
+ {
+ return inner_findstate($num);
+ }
+
+ /**
+ * Returns an instance of stdClass.
+ * Used to test wrapping of PHP objects with class preservation
+ */
+ public function returnObject()
+ {
+ $obj = new stdClass();
+ $obj->hello = 'world';
+ return $obj;
+ }
+}
+
+// a PHP version of the state-number server
+// send me an integer and i'll sell you a state
+
+$stateNames = array(
+ "Alabama", "Alaska", "Arizona", "Arkansas", "California",
+ "Colorado", "Columbia", "Connecticut", "Delaware", "Florida",
+ "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas",
+ "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan",
+ "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada",
+ "New Hampshire", "New Jersey", "New Mexico", "New York", "North Carolina",
+ "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island",
+ "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont",
+ "Virginia", "Washington", "West Virginia", "Wisconsin", "Wyoming",
+);
+
+$findstate_sig = array(array(Value::$xmlrpcString, Value::$xmlrpcInt));
+$findstate_doc = 'When passed an integer between 1 and 51 returns the
+name of a US state, where the integer is the index of that state name
+in an alphabetic order.';
+
+function findState($req)
+{
+ global $stateNames;
+
+ $err = "";
+ // get the first param
+ $sno = $req->getParam(0);
+
+ // param must be there and of the correct type: server object does the validation for us
+
+ // extract the value of the state number
+ $snv = $sno->scalarval();
+ // look it up in our array (zero-based)
+ if (isset($stateNames[$snv - 1])) {
+ $stateName = $stateNames[$snv - 1];
+ } else {
+ // not there, so complain
+ $err = "I don't have a state for the index '" . $snv . "'";
+ }
+
+ // if we generated an error, create an error return response
+ if ($err) {
+ return new PhpXmlRpc\Response(0, PhpXmlRpc\PhpXmlRpc::$xmlrpcerruser, $err);
+ } else {
+ // otherwise, we create the right response with the state name
+ return new PhpXmlRpc\Response(new Value($stateName));
+ }
+}
+
+/**
+ * Inner code of the state-number server.
+ * Used to test wrapping of PHP functions into xmlrpc methods.
+ *
+ * @param integer $stateNo the state number
+ *
+ * @return string the name of the state (or error description)
+ *
+ * @throws Exception if state is not found
+ */
+function inner_findstate($stateNo)
+{
+ global $stateNames;
+
+ if (isset($stateNames[$stateNo - 1])) {
+ return $stateNames[$stateNo - 1];
+ } else {
+ // not, there so complain
+ throw new Exception("I don't have a state for the index '" . $stateNo . "'", PhpXmlRpc\PhpXmlRpc::$xmlrpcerruser);
+ }
+}
+
+$wrapper = new PhpXmlRpc\Wrapper();
+
+$findstate2_sig = $wrapper->wrapPhpFunction('inner_findstate');
+
+$findstate3_sig = $wrapper->wrapPhpFunction(array('xmlrpcServerMethodsContainer', 'findState'));
+
+$obj = new xmlrpcServerMethodsContainer();
+$findstate4_sig = $wrapper->wrapPhpFunction(array($obj, 'findstate'));
+
+$findstate5_sig = $wrapper->wrapPhpFunction('xmlrpcServerMethodsContainer::findState', '', array('return_source' => true));
+eval($findstate5_sig['source']);
+
+$findstate6_sig = $wrapper->wrapPhpFunction('inner_findstate', '', array('return_source' => true));
+eval($findstate6_sig['source']);
+
+$findstate7_sig = $wrapper->wrapPhpFunction(array('xmlrpcServerMethodsContainer', 'findState'), '', array('return_source' => true));
+eval($findstate7_sig['source']);
+
+$obj = new xmlrpcServerMethodsContainer();
+$findstate8_sig = $wrapper->wrapPhpFunction(array($obj, 'findstate'), '', array('return_source' => true));
+eval($findstate8_sig['source']);
+
+$findstate9_sig = $wrapper->wrapPhpFunction('xmlrpcServerMethodsContainer::findState', '', array('return_source' => true));
+eval($findstate9_sig['source']);
+
+$findstate10_sig = array(
+ "function" => function ($req) { return findState($req); },
+ "signature" => $findstate_sig,
+ "docstring" => $findstate_doc,
+);
+
+$findstate11_sig = $wrapper->wrapPhpFunction(function ($stateNo) { return inner_findstate($stateNo); });
+
+$c = new xmlrpcServerMethodsContainer;
+$moreSignatures = $wrapper->wrapPhpClass($c, array('prefix' => 'tests.', 'method_type' => 'all'));
+
+$returnObj_sig = $wrapper->wrapPhpFunction(array($c, 'returnObject'), '', array('encode_php_objs' => true));
+
+// used to test signatures with NULL params
+$findstate12_sig = array(
+ array(Value::$xmlrpcString, Value::$xmlrpcInt, Value::$xmlrpcNull),
+ array(Value::$xmlrpcString, Value::$xmlrpcNull, Value::$xmlrpcInt),
+);
+
+function findStateWithNulls($req)
+{
+ $a = $req->getParam(0);
+ $b = $req->getParam(1);
+
+ if ($a->scalartyp() == Value::$xmlrpcNull)
+ return new PhpXmlRpc\Response(new Value(inner_findstate($b->scalarval())));
+ else
+ return new PhpXmlRpc\Response(new Value(inner_findstate($a->scalarval())));
+}
+
+$addtwo_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcInt, Value::$xmlrpcInt));
+$addtwo_doc = 'Add two integers together and return the result';
+function addTwo($req)
+{
+ $s = $req->getParam(0);
+ $t = $req->getParam(1);
+
+ return new PhpXmlRpc\Response(new Value($s->scalarval() + $t->scalarval(), Value::$xmlrpcInt));
+}
+
+$addtwodouble_sig = array(array(Value::$xmlrpcDouble, Value::$xmlrpcDouble, Value::$xmlrpcDouble));
+$addtwodouble_doc = 'Add two doubles together and return the result';
+function addTwoDouble($req)
+{
+ $s = $req->getParam(0);
+ $t = $req->getParam(1);
+
+ return new PhpXmlRpc\Response(new Value($s->scalarval() + $t->scalarval(), Value::$xmlrpcDouble));
+}
+
+$stringecho_sig = array(array(Value::$xmlrpcString, Value::$xmlrpcString));
+$stringecho_doc = 'Accepts a string parameter, returns the string.';
+function stringEcho($req)
+{
+ // just sends back a string
+ return new PhpXmlRpc\Response(new Value($req->getParam(0)->scalarval()));
+}
+
+$echoback_sig = array(array(Value::$xmlrpcString, Value::$xmlrpcString));
+$echoback_doc = 'Accepts a string parameter, returns the entire incoming payload';
+function echoBack($req)
+{
+ // just sends back a string with what i got sent to me, just escaped, that's all
+ $s = "I got the following message:\n" . $req->serialize();
+
+ return new PhpXmlRpc\Response(new Value($s));
+}
+
+$echosixtyfour_sig = array(array(Value::$xmlrpcString, Value::$xmlrpcBase64));
+$echosixtyfour_doc = 'Accepts a base64 parameter and returns it decoded as a string';
+function echoSixtyFour($req)
+{
+ // Accepts an encoded value, but sends it back as a normal string.
+ // This is to test that base64 encoding is working as expected
+ $incoming = $req->getParam(0);
+
+ return new PhpXmlRpc\Response(new Value($incoming->scalarval(), Value::$xmlrpcString));
+}
+
+$bitflipper_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcArray));
+$bitflipper_doc = 'Accepts an array of booleans, and returns them inverted';
+function bitFlipper($req)
+{
+ $v = $req->getParam(0);
+ $rv = new Value(array(), Value::$xmlrpcArray);
+
+ foreach ($v as $b) {
+ if ($b->scalarval()) {
+ $rv[] = new Value(false, Value::$xmlrpcBoolean);
+ } else {
+ $rv[] = new Value(true, Value::$xmlrpcBoolean);
+ }
+ }
+
+ return new PhpXmlRpc\Response($rv);
+}
+
+// Sorting demo
+//
+// send me an array of structs thus:
+//
+// Dave 35
+// Edd 45
+// Fred 23
+// Barney 37
+//
+// and I'll return it to you in sorted order
+
+function agesorter_compare($a, $b)
+{
+ global $agesorter_arr;
+
+ // don't even ask me _why_ these come padded with hyphens, I couldn't tell you :p
+ $a = str_replace("-", "", $a);
+ $b = str_replace("-", "", $b);
+
+ if ($agesorter_arr[$a] == $agesorter_arr[$b]) {
+ return 0;
+ }
+
+ return ($agesorter_arr[$a] > $agesorter_arr[$b]) ? -1 : 1;
+}
+
+$agesorter_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcArray));
+$agesorter_doc = 'Send this method an array of [string, int] structs, eg:
+<pre>
+ Dave 35
+ Edd 45
+ Fred 23
+ Barney 37
+</pre>
+And the array will be returned with the entries sorted by their numbers.
+';
+function ageSorter($req)
+{
+ global $agesorter_arr, $s;
+
+ PhpXmlRpc\Server::xmlrpc_debugmsg("Entering 'agesorter'");
+ // get the parameter
+ $sno = $req->getParam(0);
+ // error string for [if|when] things go wrong
+ $err = "";
+ $agar = array();
+
+ $max = $sno->count();
+ PhpXmlRpc\Server::xmlrpc_debugmsg("Found $max array elements");
+ foreach ($sno as $i => $rec) {
+ if ($rec->kindOf() != "struct") {
+ $err = "Found non-struct in array at element $i";
+ break;
+ }
+ // extract name and age from struct
+ $n = $rec["name"];
+ $a = $rec["age"];
+ // $n and $a are xmlrpcvals,
+ // so get the scalarval from them
+ $agar[$n->scalarval()] = $a->scalarval();
+ }
+
+ // create the output value
+ $v = new Value(array(), Value::$xmlrpcArray);
+
+ $agesorter_arr = $agar;
+ // hack, must make global as uksort() won't
+ // allow us to pass any other auxiliary information
+ uksort($agesorter_arr, 'agesorter_compare');
+ while (list($key, $val) = each($agesorter_arr)) {
+ // recreate each struct element
+ $v[] = new Value(
+ array(
+ "name" => new Value($key),
+ "age" => new Value($val, "int")
+ ),
+ Value::$xmlrpcStruct
+ );
+ }
+
+ if ($err) {
+ return new PhpXmlRpc\Response(0, PhpXmlRpc\PhpXmlRpc::$xmlrpcerruser, $err);
+ } else {
+ return new PhpXmlRpc\Response($v);
+ }
+}
+
+// signature and instructions, place these in the dispatch map
+$mailsend_sig = array(array(
+ Value::$xmlrpcBoolean, Value::$xmlrpcString, Value::$xmlrpcString,
+ Value::$xmlrpcString, Value::$xmlrpcString, Value::$xmlrpcString,
+ Value::$xmlrpcString, Value::$xmlrpcString,
+));
+$mailsend_doc = 'mail.send(recipient, subject, text, sender, cc, bcc, mimetype)<br/>
+recipient, cc, and bcc are strings, comma-separated lists of email addresses, as described above.<br/>
+subject is a string, the subject of the message.<br/>
+sender is a string, it\'s the email address of the person sending the message. This string can not be
+a comma-separated list, it must contain a single email address only.<br/>
+text is a string, it contains the body of the message.<br/>
+mimetype, a string, is a standard MIME type, for example, text/plain.
+';
+// WARNING; this functionality depends on the sendmail -t option
+// it may not work with Windows machines properly; particularly
+// the Bcc option. Sneak on your friends at your own risk!
+function mailSend($req)
+{
+ $err = "";
+
+ $mTo = $req->getParam(0);
+ $mSub = $req->getParam(1);
+ $mBody = $req->getParam(2);
+ $mFrom = $req->getParam(3);
+ $mCc = $req->getParam(4);
+ $mBcc = $req->getParam(5);
+ $mMime = $req->getParam(6);
+
+ if ($mTo->scalarval() == "") {
+ $err = "Error, no 'To' field specified";
+ }
+
+ if ($mFrom->scalarval() == "") {
+ $err = "Error, no 'From' field specified";
+ }
+
+ $msgHdr = "From: " . $mFrom->scalarval() . "\n";
+ $msgHdr .= "To: " . $mTo->scalarval() . "\n";
+
+ if ($mCc->scalarval() != "") {
+ $msgHdr .= "Cc: " . $mCc->scalarval() . "\n";
+ }
+ if ($mBcc->scalarval() != "") {
+ $msgHdr .= "Bcc: " . $mBcc->scalarval() . "\n";
+ }
+ if ($mMime->scalarval() != "") {
+ $msgHdr .= "Content-type: " . $mMime->scalarval() . "\n";
+ }
+ $msgHdr .= "X-Mailer: XML-RPC for PHP mailer 1.0";
+
+ if ($err == "") {
+ if (!mail("",
+ $mSub->scalarval(),
+ $mBody->scalarval(),
+ $msgHdr)
+ ) {
+ $err = "Error, could not send the mail.";
+ }
+ }
+
+ if ($err) {
+ return new PhpXmlRpc\Response(0, PhpXmlRpc\PhpXmlRpc::$xmlrpcerruser, $err);
+ } else {
+ return new PhpXmlRpc\Response(new Value(true, Value::$xmlrpcBoolean));
+ }
+}
+
+$getallheaders_sig = array(array(Value::$xmlrpcStruct));
+$getallheaders_doc = 'Returns a struct containing all the HTTP headers received with the request. Provides limited functionality with IIS';
+function getAllHeaders_xmlrpc($req)
+{
+ $encoder = new PhpXmlRpc\Encoder();
+
+ if (function_exists('getallheaders')) {
+ return new PhpXmlRpc\Response($encoder->encode(getallheaders()));
+ } else {
+ $headers = array();
+ // IIS: poor man's version of getallheaders
+ foreach ($_SERVER as $key => $val) {
+ if (strpos($key, 'HTTP_') === 0) {
+ $key = ucfirst(str_replace('_', '-', strtolower(substr($key, 5))));
+ $headers[$key] = $val;
+ }
+ }
+
+ return new PhpXmlRpc\Response($encoder->encode($headers));
+ }
+}
+
+$setcookies_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcStruct));
+$setcookies_doc = 'Sends to client a response containing a single \'1\' digit, and sets to it http cookies as received in the request (array of structs describing a cookie)';
+function setCookies($req)
+{
+ $encoder = new PhpXmlRpc\Encoder();
+ $cookies = $req->getParam(0);
+ foreach ($cookies as $name => $value) {
+ $cookieDesc = $encoder->decode($value);
+ setcookie($name, @$cookieDesc['value'], @$cookieDesc['expires'], @$cookieDesc['path'], @$cookieDesc['domain'], @$cookieDesc['secure']);
+ }
+
+ return new PhpXmlRpc\Response(new Value(1, Value::$xmlrpcInt));
+}
+
+$getcookies_sig = array(array(Value::$xmlrpcStruct));
+$getcookies_doc = 'Sends to client a response containing all http cookies as received in the request (as struct)';
+function getCookies($req)
+{
+ $encoder = new PhpXmlRpc\Encoder();
+ return new PhpXmlRpc\Response($encoder->encode($_COOKIE));
+}
+
+$v1_arrayOfStructs_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcArray));
+$v1_arrayOfStructs_doc = 'This handler takes a single parameter, an array of structs, each of which contains at least three elements named moe, larry and curly, all <i4>s. Your handler must add all the struct elements named curly and return the result.';
+function v1_arrayOfStructs($req)
+{
+ $sno = $req->getParam(0);
+ $numCurly = 0;
+ foreach ($sno as $str) {
+ foreach ($str as $key => $val) {
+ if ($key == "curly") {
+ $numCurly += $val->scalarval();
+ }
+ }
+ }
+
+ return new PhpXmlRpc\Response(new Value($numCurly, Value::$xmlrpcInt));
+}
+
+$v1_easyStruct_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcStruct));
+$v1_easyStruct_doc = 'This handler takes a single parameter, a struct, containing at least three elements named moe, larry and curly, all <i4>s. Your handler must add the three numbers and return the result.';
+function v1_easyStruct($req)
+{
+ $sno = $req->getParam(0);
+ $moe = $sno["moe"];
+ $larry = $sno["larry"];
+ $curly = $sno["curly"];
+ $num = $moe->scalarval() + $larry->scalarval() + $curly->scalarval();
+
+ return new PhpXmlRpc\Response(new Value($num, Value::$xmlrpcInt));
+}
+
+$v1_echoStruct_sig = array(array(Value::$xmlrpcStruct, Value::$xmlrpcStruct));
+$v1_echoStruct_doc = 'This handler takes a single parameter, a struct. Your handler must return the struct.';
+function v1_echoStruct($req)
+{
+ $sno = $req->getParam(0);
+
+ return new PhpXmlRpc\Response($sno);
+}
+
+$v1_manyTypes_sig = array(array(
+ Value::$xmlrpcArray, Value::$xmlrpcInt, Value::$xmlrpcBoolean,
+ Value::$xmlrpcString, Value::$xmlrpcDouble, Value::$xmlrpcDateTime,
+ Value::$xmlrpcBase64,
+));
+$v1_manyTypes_doc = 'This handler takes six parameters, and returns an array containing all the parameters.';
+function v1_manyTypes($req)
+{
+ return new PhpXmlRpc\Response(new Value(
+ array(
+ $req->getParam(0),
+ $req->getParam(1),
+ $req->getParam(2),
+ $req->getParam(3),
+ $req->getParam(4),
+ $req->getParam(5)
+ ),
+ Value::$xmlrpcArray
+ ));
+}
+
+$v1_moderateSizeArrayCheck_sig = array(array(Value::$xmlrpcString, Value::$xmlrpcArray));
+$v1_moderateSizeArrayCheck_doc = 'This handler takes a single parameter, which is an array containing between 100 and 200 elements. Each of the items is a string, your handler must return a string containing the concatenated text of the first and last elements.';
+function v1_moderateSizeArrayCheck($req)
+{
+ $ar = $req->getParam(0);
+ $sz = $ar->count();
+ $first = $ar[0];
+ $last = $ar[$sz - 1];
+
+ return new PhpXmlRpc\Response(new Value($first->scalarval() .
+ $last->scalarval(), Value::$xmlrpcString));
+}
+
+$v1_simpleStructReturn_sig = array(array(Value::$xmlrpcStruct, Value::$xmlrpcInt));
+$v1_simpleStructReturn_doc = 'This handler takes one parameter, and returns a struct containing three elements, times10, times100 and times1000, the result of multiplying the number by 10, 100 and 1000.';
+function v1_simpleStructReturn($req)
+{
+ $sno = $req->getParam(0);
+ $v = $sno->scalarval();
+
+ return new PhpXmlRpc\Response(new Value(
+ array(
+ "times10" => new Value($v * 10, Value::$xmlrpcInt),
+ "times100" => new Value($v * 100, Value::$xmlrpcInt),
+ "times1000" => new Value($v * 1000, Value::$xmlrpcInt)
+ ),
+ Value::$xmlrpcStruct
+ ));
+}
+
+$v1_nestedStruct_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcStruct));
+$v1_nestedStruct_doc = 'This handler takes a single parameter, a struct, that models a daily calendar. At the top level, there is one struct for each year. Each year is broken down into months, and months into days. Most of the days are empty in the struct you receive, but the entry for April 1, 2000 contains a least three elements named moe, larry and curly, all <i4>s. Your handler must add the three numbers and return the result.';
+function v1_nestedStruct($req)
+{
+ $sno = $req->getParam(0);
+
+ $twoK = $sno["2000"];
+ $april = $twoK["04"];
+ $fools = $april["01"];
+ $curly = $fools["curly"];
+ $larry = $fools["larry"];
+ $moe = $fools["moe"];
+
+ return new PhpXmlRpc\Response(new Value($curly->scalarval() + $larry->scalarval() + $moe->scalarval(), Value::$xmlrpcInt));
+}
+
+$v1_countTheEntities_sig = array(array(Value::$xmlrpcStruct, Value::$xmlrpcString));
+$v1_countTheEntities_doc = 'This handler takes a single parameter, a string, that contains any number of predefined entities, namely <, >, & \' and ".<BR>Your handler must return a struct that contains five fields, all numbers: ctLeftAngleBrackets, ctRightAngleBrackets, ctAmpersands, ctApostrophes, ctQuotes.';
+function v1_countTheEntities($req)
+{
+ $sno = $req->getParam(0);
+ $str = $sno->scalarval();
+ $gt = 0;
+ $lt = 0;
+ $ap = 0;
+ $qu = 0;
+ $amp = 0;
+ for ($i = 0; $i < strlen($str); $i++) {
+ $c = substr($str, $i, 1);
+ switch ($c) {
+ case ">":
+ $gt++;
+ break;
+ case "<":
+ $lt++;
+ break;
+ case "\"":
+ $qu++;
+ break;
+ case "'":
+ $ap++;
+ break;
+ case "&":
+ $amp++;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return new PhpXmlRpc\Response(new Value(
+ array(
+ "ctLeftAngleBrackets" => new Value($lt, Value::$xmlrpcInt),
+ "ctRightAngleBrackets" => new Value($gt, Value::$xmlrpcInt),
+ "ctAmpersands" => new Value($amp, Value::$xmlrpcInt),
+ "ctApostrophes" => new Value($ap, Value::$xmlrpcInt),
+ "ctQuotes" => new Value($qu, Value::$xmlrpcInt)
+ ),
+ Value::$xmlrpcStruct
+ ));
+}
+
+// trivial interop tests
+// http://www.xmlrpc.com/stories/storyReader$1636
+
+$i_echoString_sig = array(array(Value::$xmlrpcString, Value::$xmlrpcString));
+$i_echoString_doc = "Echoes string.";
+
+$i_echoStringArray_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcArray));
+$i_echoStringArray_doc = "Echoes string array.";
+
+$i_echoInteger_sig = array(array(Value::$xmlrpcInt, Value::$xmlrpcInt));
+$i_echoInteger_doc = "Echoes integer.";
+
+$i_echoIntegerArray_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcArray));
+$i_echoIntegerArray_doc = "Echoes integer array.";
+
+$i_echoFloat_sig = array(array(Value::$xmlrpcDouble, Value::$xmlrpcDouble));
+$i_echoFloat_doc = "Echoes float.";
+
+$i_echoFloatArray_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcArray));
+$i_echoFloatArray_doc = "Echoes float array.";
+
+$i_echoStruct_sig = array(array(Value::$xmlrpcStruct, Value::$xmlrpcStruct));
+$i_echoStruct_doc = "Echoes struct.";
+
+$i_echoStructArray_sig = array(array(Value::$xmlrpcArray, Value::$xmlrpcArray));
+$i_echoStructArray_doc = "Echoes struct array.";
+
+$i_echoValue_doc = "Echoes any value back.";
+$i_echoValue_sig = array(array(Value::$xmlrpcValue, Value::$xmlrpcValue));
+
+$i_echoBase64_sig = array(array(Value::$xmlrpcBase64, Value::$xmlrpcBase64));
+$i_echoBase64_doc = "Echoes base64.";
+
+$i_echoDate_sig = array(array(Value::$xmlrpcDateTime, Value::$xmlrpcDateTime));
+$i_echoDate_doc = "Echoes dateTime.";
+
+function i_echoParam($req)
+{
+ $s = $req->getParam(0);
+
+ return new PhpXmlRpc\Response($s);
+}
+
+function i_echoString($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoInteger($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoFloat($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoStruct($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoStringArray($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoIntegerArray($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoFloatArray($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoStructArray($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoValue($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoBase64($req)
+{
+ return i_echoParam($req);
+}
+
+function i_echoDate($req)
+{
+ return i_echoParam($req);
+}
+
+$i_whichToolkit_sig = array(array(Value::$xmlrpcStruct));
+$i_whichToolkit_doc = "Returns a struct containing the following strings: toolkitDocsUrl, toolkitName, toolkitVersion, toolkitOperatingSystem.";
+
+function i_whichToolkit($req)
+{
+ global $SERVER_SOFTWARE;
+ $ret = array(
+ "toolkitDocsUrl" => "http://phpxmlrpc.sourceforge.net/",
+ "toolkitName" => PhpXmlRpc\PhpXmlRpc::$xmlrpcName,
+ "toolkitVersion" => PhpXmlRpc\PhpXmlRpc::$xmlrpcVersion,
+ "toolkitOperatingSystem" => isset($SERVER_SOFTWARE) ? $SERVER_SOFTWARE : $_SERVER['SERVER_SOFTWARE'],
+ );
+
+ $encoder = new PhpXmlRpc\Encoder();
+ return new PhpXmlRpc\Response($encoder->encode($ret));
+}
+
+$object = new xmlrpcServerMethodsContainer();
+$signatures = array(
+ "examples.getStateName" => array(
+ "function" => "findState",
+ "signature" => $findstate_sig,
+ "docstring" => $findstate_doc,
+ ),
+ "examples.sortByAge" => array(
+ "function" => "ageSorter",
+ "signature" => $agesorter_sig,
+ "docstring" => $agesorter_doc,
+ ),
+ "examples.addtwo" => array(
+ "function" => "addTwo",
+ "signature" => $addtwo_sig,
+ "docstring" => $addtwo_doc,
+ ),
+ "examples.addtwodouble" => array(
+ "function" => "addTwoDouble",
+ "signature" => $addtwodouble_sig,
+ "docstring" => $addtwodouble_doc,
+ ),
+ "examples.stringecho" => array(
+ "function" => "stringEcho",
+ "signature" => $stringecho_sig,
+ "docstring" => $stringecho_doc,
+ ),
+ "examples.echo" => array(
+ "function" => "echoBack",
+ "signature" => $echoback_sig,
+ "docstring" => $echoback_doc,
+ ),
+ "examples.decode64" => array(
+ "function" => "echoSixtyFour",
+ "signature" => $echosixtyfour_sig,
+ "docstring" => $echosixtyfour_doc,
+ ),
+ "examples.invertBooleans" => array(
+ "function" => "bitFlipper",
+ "signature" => $bitflipper_sig,
+ "docstring" => $bitflipper_doc,
+ ),
+ // signature omitted on purpose
+ "tests.generatePHPWarning" => array(
+ "function" => array($object, "phpWarningGenerator"),
+ ),
+ // signature omitted on purpose
+ "tests.raiseException" => array(
+ "function" => array($object, "exceptionGenerator"),
+ ),
+ // Greek word 'kosme'. NB: NOT a valid ISO8859 string!
+ // NB: we can only register this when setting internal encoding to UTF-8, or it will break system.listMethods
+ "tests.utf8methodname." . 'κόσμε' => array(
+ "function" => "stringEcho",
+ "signature" => $stringecho_sig,
+ "docstring" => $stringecho_doc,
+ ),
+ /*"tests.iso88591methodname." . chr(224) . chr(252) . chr(232) => array(
+ "function" => "stringEcho",
+ "signature" => $stringecho_sig,
+ "docstring" => $stringecho_doc,
+ ),*/
+ "examples.getallheaders" => array(
+ "function" => 'getAllHeaders_xmlrpc',
+ "signature" => $getallheaders_sig,
+ "docstring" => $getallheaders_doc,
+ ),
+ "examples.setcookies" => array(
+ "function" => 'setCookies',
+ "signature" => $setcookies_sig,
+ "docstring" => $setcookies_doc,
+ ),
+ "examples.getcookies" => array(
+ "function" => 'getCookies',
+ "signature" => $getcookies_sig,
+ "docstring" => $getcookies_doc,
+ ),
+ "mail.send" => array(
+ "function" => "mailSend",
+ "signature" => $mailsend_sig,
+ "docstring" => $mailsend_doc,
+ ),
+ "validator1.arrayOfStructsTest" => array(
+ "function" => "v1_arrayOfStructs",
+ "signature" => $v1_arrayOfStructs_sig,
+ "docstring" => $v1_arrayOfStructs_doc,
+ ),
+ "validator1.easyStructTest" => array(
+ "function" => "v1_easyStruct",
+ "signature" => $v1_easyStruct_sig,
+ "docstring" => $v1_easyStruct_doc,
+ ),
+ "validator1.echoStructTest" => array(
+ "function" => "v1_echoStruct",
+ "signature" => $v1_echoStruct_sig,
+ "docstring" => $v1_echoStruct_doc,
+ ),
+ "validator1.manyTypesTest" => array(
+ "function" => "v1_manyTypes",
+ "signature" => $v1_manyTypes_sig,
+ "docstring" => $v1_manyTypes_doc,
+ ),
+ "validator1.moderateSizeArrayCheck" => array(
+ "function" => "v1_moderateSizeArrayCheck",
+ "signature" => $v1_moderateSizeArrayCheck_sig,
+ "docstring" => $v1_moderateSizeArrayCheck_doc,
+ ),
+ "validator1.simpleStructReturnTest" => array(
+ "function" => "v1_simpleStructReturn",
+ "signature" => $v1_simpleStructReturn_sig,
+ "docstring" => $v1_simpleStructReturn_doc,
+ ),
+ "validator1.nestedStructTest" => array(
+ "function" => "v1_nestedStruct",
+ "signature" => $v1_nestedStruct_sig,
+ "docstring" => $v1_nestedStruct_doc,
+ ),
+ "validator1.countTheEntities" => array(
+ "function" => "v1_countTheEntities",
+ "signature" => $v1_countTheEntities_sig,
+ "docstring" => $v1_countTheEntities_doc,
+ ),
+ "interopEchoTests.echoString" => array(
+ "function" => "i_echoString",
+ "signature" => $i_echoString_sig,
+ "docstring" => $i_echoString_doc,
+ ),
+ "interopEchoTests.echoStringArray" => array(
+ "function" => "i_echoStringArray",
+ "signature" => $i_echoStringArray_sig,
+ "docstring" => $i_echoStringArray_doc,
+ ),
+ "interopEchoTests.echoInteger" => array(
+ "function" => "i_echoInteger",
+ "signature" => $i_echoInteger_sig,
+ "docstring" => $i_echoInteger_doc,
+ ),
+ "interopEchoTests.echoIntegerArray" => array(
+ "function" => "i_echoIntegerArray",
+ "signature" => $i_echoIntegerArray_sig,
+ "docstring" => $i_echoIntegerArray_doc,
+ ),
+ "interopEchoTests.echoFloat" => array(
+ "function" => "i_echoFloat",
+ "signature" => $i_echoFloat_sig,
+ "docstring" => $i_echoFloat_doc,
+ ),
+ "interopEchoTests.echoFloatArray" => array(
+ "function" => "i_echoFloatArray",
+ "signature" => $i_echoFloatArray_sig,
+ "docstring" => $i_echoFloatArray_doc,
+ ),
+ "interopEchoTests.echoStruct" => array(
+ "function" => "i_echoStruct",
+ "signature" => $i_echoStruct_sig,
+ "docstring" => $i_echoStruct_doc,
+ ),
+ "interopEchoTests.echoStructArray" => array(
+ "function" => "i_echoStructArray",
+ "signature" => $i_echoStructArray_sig,
+ "docstring" => $i_echoStructArray_doc,
+ ),
+ "interopEchoTests.echoValue" => array(
+ "function" => "i_echoValue",
+ "signature" => $i_echoValue_sig,
+ "docstring" => $i_echoValue_doc,
+ ),
+ "interopEchoTests.echoBase64" => array(
+ "function" => "i_echoBase64",
+ "signature" => $i_echoBase64_sig,
+ "docstring" => $i_echoBase64_doc,
+ ),
+ "interopEchoTests.echoDate" => array(
+ "function" => "i_echoDate",
+ "signature" => $i_echoDate_sig,
+ "docstring" => $i_echoDate_doc,
+ ),
+ "interopEchoTests.whichToolkit" => array(
+ "function" => "i_whichToolkit",
+ "signature" => $i_whichToolkit_sig,
+ "docstring" => $i_whichToolkit_doc,
+ ),
+
+ 'tests.getStateName.2' => $findstate2_sig,
+ 'tests.getStateName.3' => $findstate3_sig,
+ 'tests.getStateName.4' => $findstate4_sig,
+ 'tests.getStateName.5' => $findstate5_sig,
+ 'tests.getStateName.6' => $findstate6_sig,
+ 'tests.getStateName.7' => $findstate7_sig,
+ 'tests.getStateName.8' => $findstate8_sig,
+ 'tests.getStateName.9' => $findstate9_sig,
+ 'tests.getStateName.10' => $findstate10_sig,
+ 'tests.getStateName.11' => $findstate11_sig,
+
+ 'tests.getStateName.12' => array(
+ "function" => "findStateWithNulls",
+ "signature" => $findstate12_sig,
+ "docstring" => $findstate_doc,
+ ),
+
+ 'tests.returnPhpObject' => $returnObj_sig,
+);
+
+$signatures = array_merge($signatures, $moreSignatures);
+
+// enable support for the NULL extension
+PhpXmlRpc\PhpXmlRpc::$xmlrpc_null_extension = true;
+
+$s = new PhpXmlRpc\Server($signatures, false);
+$s->setdebug(3);
+$s->compress_response = true;
+
+// out-of-band information: let the client manipulate the server operations.
+// we do this to help the testsuite script: do not reproduce in production!
+if (isset($_GET['RESPONSE_ENCODING'])) {
+ $s->response_charset_encoding = $_GET['RESPONSE_ENCODING'];
+}
+if (isset($_GET['DETECT_ENCODINGS'])) {
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_detectencodings = $_GET['DETECT_ENCODINGS'];
+}
+if (isset($_GET['EXCEPTION_HANDLING'])) {
+ $s->exception_handling = $_GET['EXCEPTION_HANDLING'];
+}
+$s->service();
+// that should do all we need!
+
+// out-of-band information: let the client manipulate the server operations.
+// we do this to help the testsuite script: do not reproduce in production!
+if (isset($_COOKIE['PHPUNIT_SELENIUM_TEST_ID']) && extension_loaded('xdebug')) {
+ include_once __DIR__ . "/../../vendor/phpunit/phpunit-selenium/PHPUnit/Extensions/SeleniumCommon/append.php";
+}
--- /dev/null
+<html>
+<head><title>xmlrpc</title></head>
+<body>
+<?php
+
+include_once __DIR__ . "/../vendor/autoload.php";
+
+$req = new PhpXmlRpc\Request('examples.getStateName');
+
+print "<h3>Testing value serialization</h3>\n";
+
+$v = new PhpXmlRpc\Value(23, "int");
+print "<PRE>" . htmlentities($v->serialize()) . "</PRE>";
+$v = new PhpXmlRpc\Value("What are you saying? >> << &&");
+print "<PRE>" . htmlentities($v->serialize()) . "</PRE>";
+
+$v = new PhpXmlRpc\Value(
+ array(
+ new PhpXmlRpc\Value("ABCDEFHIJ"),
+ new PhpXmlRpc\Value(1234, 'int'),
+ new PhpXmlRpc\Value(1, 'boolean'),
+ ),
+ "array"
+);
+
+print "<PRE>" . htmlentities($v->serialize()) . "</PRE>";
+
+$v = new PhpXmlRpc\Value(
+ array(
+ "thearray" => new PhpXmlRpc\Value(
+ array(
+ new PhpXmlRpc\Value("ABCDEFHIJ"),
+ new PhpXmlRpc\Value(1234, 'int'),
+ new PhpXmlRpc\Value(1, 'boolean'),
+ new PhpXmlRpc\Value(0, 'boolean'),
+ new PhpXmlRpc\Value(true, 'boolean'),
+ new PhpXmlRpc\Value(false, 'boolean'),
+ ),
+ "array"
+ ),
+ "theint" => new PhpXmlRpc\Value(23, 'int'),
+ "thestring" => new PhpXmlRpc\Value("foobarwhizz"),
+ "thestruct" => new PhpXmlRpc\Value(
+ array(
+ "one" => new PhpXmlRpc\Value(1, 'int'),
+ "two" => new PhpXmlRpc\Value(2, 'int'),
+ ),
+ "struct"
+ ),
+ ),
+ "struct"
+);
+
+print "<PRE>" . htmlentities($v->serialize()) . "</PRE>";
+
+$w = new PhpXmlRpc\Value(array($v, new PhpXmlRpc\Value("That was the struct!")), "array");
+
+print "<PRE>" . htmlentities($w->serialize()) . "</PRE>";
+
+$w = new PhpXmlRpc\Value("Mary had a little lamb,
+Whose fleece was white as snow,
+And everywhere that Mary went
+the lamb was sure to go.
+
+Mary had a little lamb
+She tied it to a pylon
+Ten thousand volts went down its back
+And turned it into nylon", "base64"
+);
+print "<PRE>" . htmlentities($w->serialize()) . "</PRE>";
+print "<PRE>Value of base64 string is: '" . $w->scalarval() . "'</PRE>";
+
+$req->method('');
+$req->addParam(new PhpXmlRpc\Value("41", "int"));
+
+print "<h3>Testing request serialization</h3>\n";
+$op = $req->serialize();
+print "<PRE>" . htmlentities($op) . "</PRE>";
+
+print "<h3>Testing ISO date format</h3><pre>\n";
+
+$t = time();
+$date = PhpXmlRpc\Helper\Date::iso8601Encode($t);
+print "Now is $t --> $date\n";
+print "Or in UTC, that is " . PhpXmlRpc\Helper\Date::iso8601Encode($t, 1) . "\n";
+$tb = PhpXmlRpc\Helper\Date::iso8601Decode($date);
+print "That is to say $date --> $tb\n";
+print "Which comes out at " . PhpXmlRpc\Helper\Date::iso8601Encode($tb) . "\n";
+print "Which was the time in UTC at " . PhpXmlRpc\Helper\Date::iso8601Encode($date, 1) . "\n";
+
+print "</pre>\n";
+
+?>
+</body>
+</html>
--- /dev/null
+API Changes between library versions 3 and 4
+============================================
+
+Class loading
+-------------
+
+It is not necessary any more to include the files xmlrpc.inc, xmlrpcs.inc and xmlrpc_wrappers.inc to have the
+library classes available.
+
+Instead, it is recommended to rely on class autoloading.
+
+* If you are using Composer, just install the library by declaring it as dependency for your project in composer.json
+
+ "require": {
+ ...,
+ "phpxmlrpc/phpxmlrpc": "~4.0"
+ },
+
+* If you do not use Composer, an autoloader for the library can be found in src/Atuloader.php.
+ The php example files in the demo/client folder do make use of it.
+ Example code to set up the autoloader:
+
+ include_once <path to library> . "/src/Autoloader.php";
+ PhpXmlRpc\Autoloader::register();
+
+
+* If you still include manually xmlrpc.inc, xmlrpcs.inc or xmlrpc_wrappers.inc, you will not need to set up
+ class autoloading, as those files do include all the source files for the library classes
+
+
+New class naming
+----------------
+
+All classes have ben renamed, are now properly namespaced and follow the CamelCase naming convention.
+Existing class methods and members have been preserved; all new method names follow camelCase.
+
+Conversion table:
+
+| Old class | New class | Notes |
+| ------------- | ------------------ | ------------------------------------- |
+| xmlrpc_client | PhpXmlRpc\Client | |
+| xmlrpc_server | PhpXmlRpc\Server | Removed method: echoInput |
+| xmlrpcmsg | PhpXmlRpc\Request | |
+| xmlrpcresp | PhpXmlRpc\Response | |
+| xmlrpcval | PhpXmlRpc\Value | Removed methods: serializeval, getval |
+
+
+New class methods
+-----------------
+
+In case you had extended the classes of the library and added methods to the subclasses, you might find that your
+implementation clashes with the new one if you implemented:
+
+
+| Class | Method | Notes |
+| --------- | ------------ | --------------------------------------- |
+| xmlrpcval | count | implements interface: Countable |
+| xmlrpcval | getIterator | implements interface: IteratorAggregate |
+| xmlrpcval | offsetExists | implements interface: ArrayAccess |
+| xmlrpcval | offsetGet | implements interface: ArrayAccess |
+| xmlrpcval | offsetSet | implements interface: ArrayAccess |
+| xmlrpcval | offsetUnset | implements interface: ArrayAccess |
+
+
+Global variables cleanup
+------------------------
+
+All variables in the global scope have been moved into classes.
+
+Conversion table:
+
+| Old variable | New variable | Notes |
+| ------------------------ | ------------------------------------------- | --------- |
+| _xmlrpc_debuginfo | PhpXmlRpc\Server::$_xmlrpc_debuginfo | protected |
+| _xmlrpcs_capabilities | NOT AVAILABLE YET | |
+| _xmlrpcs_dmap | NOT AVAILABLE YET | |
+| _xmlrpcs_occurred_errors | PhpXmlRpc\Server::$_xmlrpcs_occurred_errors | protected |
+| _xmlrpcs_prev_ehandler | PhpXmlRpc\Server::$_xmlrpcs_prev_ehandler | protected |
+| xmlrpcWPFObjHolder | PhpXmlRpc\Wrapper::$objHolder | |
+| ... | | |
+
+
+Global functions cleanup
+------------------------
+
+Most functions in the global scope have been moved into classes.
+Some have been slightly changed.
+
+| Old function | New function | Notes |
+| -------------------------------- | ------------------------------------------- | ------------------------------------------------------ |
+| build_client_wrapper_code | none | |
+| build_remote_method_wrapper_code | PhpXmlRpc\Wrapper->buildWrapMethodSource | signature changed |
+| decode_chunked | PhpXmlRpc\Helper\Http::decodeChunked | |
+| guess_encoding | PhpXmlRpc\Helper\XMLParser::guessEncoding | |
+| has_encoding | PhpXmlRpc\Helper\XMLParser::hasEncoding | |
+| is_valid_charset | PhpXmlRpc\Helper\Charset->isValidCharset | this method is not static, you need a Charset obj |
+| iso8601_decode | PhpXmlRpc\Helper\Date::iso8601Decode | |
+| iso8601_encode | PhpXmlRpc\Helper\Date::iso8601Encode | |
+| php_2_xmlrpc_type | PhpXmlRpc\Wrapper->php2XmlrpcType | this method is not static, you need a Wrapper obj |
+| php_xmlrpc_decode | PhpXmlRpc\Encoder->decode | this method is not static, you need an Encoder obj |
+| php_xmlrpc_decode_xml | PhpXmlRpc\Encoder->decodeXml | this method is not static, you need an Encoder obj |
+| php_xmlrpc_encode | PhpXmlRpc\Encoder->encode | this method is not static, you need an Encoder obj |
+| wrap_php_class | PhpXmlRpc\Wrapper->wrapPhpClass | returns closures instead of function names by default |
+| wrap_php_function | PhpXmlRpc\Wrapper->wrapPhpFunction | returns closures instead of function names by default |
+| wrap_xmlrpc_method | PhpXmlRpc\Wrapper->wrapXmrlpcMethod | returns closures instead of function names by default |
+| wrap_xmlrpc_server | PhpXmlRpc\Wrapper->wrapXmrlpcServer | returns closures instead of function names by default; |
+| | | returns an array ready for usage in dispatch map |
+| xmlrpc_2_php_type | PhpXmlRpc\Wrapper->Xmlrpc2phpType | this method is not static, you need a Wrapper obj |
+| xmlrpc_debugmsg | PhpXmlRpc\Server->xmlrpc_debugmsg | |
+| xmlrpc_encode_entitites | PhpXmlRpc\Helper\Charset->encodeEntitities | this method is not static, you need a Charset obj |
+
+
+Character sets and encoding
+---------------------------
+
+The default character set used by the library to deliver data to your app is now UTF8.
+It is also the character set that the library expects data from your app to be in (including method names).
+The value can be changed (to either US-ASCII or ISO-8859-1) by setting the desired value to
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding
+
+Usage of closures for wrapping
+------------------------------
+
+...
+
+
+Differences in server behaviour
+-------------------------------
+
+The results for calls to system.listMethods and system.getCapabilities can not be set anymore via changes to
+global variables.
+
+
+Other
+-----
+
+* when serialize() is invoked on a response and its payload can not be serialized, an exception is thrown instead of
+ ending all execution
+
+* all error messages now mention the class and method which generated them
+
+* all library source code has been moved to the src/ directory
+
+* all source code has been reformatted according to modern PSR standards
+
+
+Enabling compatibility with legacy code
+---------------------------------------
+
+If you have code which relies on version 3 of the phpxmlrpc API, you *should* be able to use version 4 as a drop-in
+replacement, regardless of all of the changes mentioned above.
+
+The magic happens via the xmlrpc.inc, xmlrpcs.inc and xmlrpc_wrappers.inc files, which have been kept solely for
+the purpose of backwards compatibility (you might notice that they are still in the 'lib' directory, whereas all of
+the refactored code now sits in the 'src' directory).
+
+Of course, some minor changes where inevitable, and backwards compatibility can not be guaranteed at 100%.
+Below is the list of all known changes and possible pitfalls when enabling 'compatibility mode'.
+
+### Default character set used for application data
+
+* when including the xmlrpc.inc file, the defalt character set used by the lib to give data to your app gets switched
+ back to ISO-8859-1, as it was in previous versions
+
+* if yor app used to change that value, you will need to add one line to your code, to make sure it is properly used
+
+ // code as was before
+ include('xmlrpc.inc');
+ $GLOBALS['xmlrpc_internalencoding'] = 'UTF-8';
+ // new line needed now
+ PhpXmlRpc\PhpXmlRpc::importGlobals();
+
+### Usage of global variables
+
+* ALL global variables which existed after including xmlrpc.inc in version 3 still do exist after including it in v. 4
+
+* Code which relies on using (as in 'reading') their value will keep working unchanged
+
+* Changing the value of some of those variables does not have any effect anymore on library operation.
+ This is true for:
+
+ $GLOBALS['xmlrpcI4']
+ $GLOBALS['xmlrpcInt']
+ $GLOBALS['xmlrpcBoolean']
+ $GLOBALS['xmlrpcDouble']
+ $GLOBALS['xmlrpcString']
+ $GLOBALS['xmlrpcDatetTme']
+ $GLOBALS['xmlrpcBase64']
+ $GLOBALS['xmlrpcArray']
+ $GLOBALS['xmlrpcStruct']
+ $GLOBALS['xmlrpcValue']
+ $GLOBALS['xmlrpcNull']
+ $GLOBALS['xmlrpcTypes']
+ $GLOBALS['xmlrpc_valid_parents']
+ $GLOBALS['xml_iso88591_Entities']
+
+* Changing the value of the other global variables will still have an effect on operation of the library, but only after
+ a call to PhpXmlRpc::importGlobals()
+
+ Example:
+
+ // code as was before
+ include('xmlrpc.inc');
+ $GLOBALS['xmlrpc_null_apache_encoding'] = true;
+ // new line needed now
+ PhpXmlRpc\PhpXmlRpc::importGlobals();
+
+ Alternative solution:
+
+ include('xmlrpc.inc');
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_null_apache_encoding = true;
+
+* Not all variables which existed after including xmlrpcs.inc in version 3 are available
+
+ - $GLOBALS['_xmlrpcs_prev_ehandler'] has been replaced with protected static var PhpXmlRpc\Server::$_xmlrpcs_prev_ehandler
+ and is thus not available any more
+
+ - same for $GLOBALS['_xmlrpcs_occurred_errors']
+
+ - same for $GLOBALS['_xmlrpc_debuginfo']
+
+ - $GLOBALS['_xmlrpcs_capabilities'] and $GLOBALS['_xmlrpcs_dmap'] have been removed
+
+### Using typeof/class-name checks in your code
+
+* if you are checking the types of returned objects, your checks will most likely fail.
+ This is due to the fact that 'old' classes extend the 'new' versions, but library code that creates object
+ instances will return the new classes.
+
+ Example:
+
+ is_a(php_xmlrpc_encode('hello world'), 'xmlrpcval') => false
+ is_a(php_xmlrpc_encode('hello world'), 'PhpXmlRpc\Value') => true
+
+### server behaviour can not be changed by setting global variables (the ones starting with _xmlrpcs_ )
+
+might be fixed later?
--- /dev/null
+<?xml version='1.0'?>
+<xsl:stylesheet
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"
+ xmlns:fo="http://www.w3.org/1999/XSL/Format">
+<!--
+ Customization xsl stylesheet for docbook to pdf transform
+ @author Gaetano Giunta
+ @copyright (c) 2007-2015 G. Giunta
+ @license code licensed under the BSD License
+ @todo make the xsl more dynamic: the path to import docbook.xsl could be f.e. rewritten/injected by the php user
+-->
+
+
+<!-- import base stylesheet -->
+<xsl:import href="../../../../vendor/docbook/docbook-xsl/fo/docbook.xsl"/>
+
+
+<!-- customization vars -->
+<xsl:param name="fop1.extensions">1</xsl:param>
+<xsl:param name="draft.mode">no</xsl:param>
+<xsl:param name="funcsynopsis.style">ansi</xsl:param>
+<xsl:param name="id.warnings">0</xsl:param>
+<xsl:param name="highlight.source">1</xsl:param>
+<xsl:param name="highlight.default.language">php</xsl:param>
+<xsl:param name="paper.type">A4</xsl:param>
+<xsl:param name="shade.verbatim">1</xsl:param>
+
+<xsl:attribute-set name="verbatim.properties">
+ <xsl:attribute name="font-size">80%</xsl:attribute>
+</xsl:attribute-set>
+
+
+<!-- elements added / modified -->
+<xsl:template match="funcdef/function">
+ <xsl:choose>
+ <xsl:when test="$funcsynopsis.decoration != 0">
+ <fo:inline font-weight="bold">
+ <xsl:apply-templates/>
+ </fo:inline>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:apply-templates/>
+ </xsl:otherwise>
+ </xsl:choose>
+ <xsl:text> </xsl:text>
+</xsl:template>
+
+<xsl:template match="funcdef/type">
+ <xsl:apply-templates/>
+ <xsl:text> </xsl:text>
+</xsl:template>
+
+<xsl:template match="void">
+ <xsl:choose>
+ <xsl:when test="$funcsynopsis.style='ansi'">
+ <xsl:text>( void )</xsl:text>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:text>( )</xsl:text>
+ </xsl:otherwise>
+ </xsl:choose>
+</xsl:template>
+
+<xsl:template match="varargs">
+ <xsl:text>( ... )</xsl:text>
+</xsl:template>
+
+<xsl:template match="paramdef">
+ <xsl:variable name="paramnum">
+ <xsl:number count="paramdef" format="1"/>
+ </xsl:variable>
+ <xsl:if test="$paramnum=1">( </xsl:if>
+ <xsl:choose>
+ <xsl:when test="$funcsynopsis.style='ansi'">
+ <xsl:apply-templates/>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:apply-templates select="./parameter"/>
+ </xsl:otherwise>
+ </xsl:choose>
+ <xsl:choose>
+ <xsl:when test="following-sibling::paramdef">
+ <xsl:text>, </xsl:text>
+ </xsl:when>
+ <xsl:otherwise>
+ <xsl:text> )</xsl:text>
+ </xsl:otherwise>
+ </xsl:choose>
+</xsl:template>
+
+<xsl:template match="paramdef/type">
+ <xsl:apply-templates/>
+ <xsl:text> </xsl:text>
+</xsl:template>
+
+<!-- default values for function parameters -->
+<xsl:template match="paramdef/initializer">
+ <xsl:text> = </xsl:text>
+ <xsl:apply-templates/>
+</xsl:template>
+
+
+</xsl:stylesheet>
\ No newline at end of file
--- /dev/null
+<?xml version='1.0'?>
+<xsl:stylesheet
+ xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+<!--
+ Customization xsl stylesheet for docbook to chunked html transform
+ @author Gaetano Giunta
+ @copyright (c) 2007-2015 G. Giunta
+ @license code licensed under the BSD License
+
+ @todo make the xsl more dynamic: the path to import chunk.xsl could be f.e. rewritten/injected by the php user.
+ This would be needed f.e. if the lib is installed as a dependency and is not the top-level composer project.
+ Note: according to http://stackoverflow.com/questions/9861355/using-dynamic-href-in-xslt-import-include this is
+ not easy to do - it would have to be done f.e. by the invoking php script...
+-->
+
+
+<!-- import base stylesheet -->
+<xsl:import href="../../../../vendor/docbook/docbook-xsl/xhtml/chunk.xsl"/>
+
+
+<!-- customization vars -->
+<xsl:param name="draft.mode">no</xsl:param>
+<xsl:param name="funcsynopsis.style">ansi</xsl:param>
+<xsl:param name="html.stylesheet">xmlrpc.css</xsl:param>
+<xsl:param name="id.warnings">0</xsl:param>
+
+
+<!-- elements added / modified -->
+
+<!-- space between function name and opening parenthesis -->
+<xsl:template match="funcdef" mode="ansi-nontabular">
+ <code>
+ <xsl:apply-templates select="." mode="class.attribute"/>
+ <xsl:apply-templates mode="ansi-nontabular"/>
+ <xsl:text> ( </xsl:text>
+ </code>
+</xsl:template>
+
+<!-- space between return type and function name -->
+<xsl:template match="funcdef/type" mode="ansi-nontabular">
+ <xsl:apply-templates mode="ansi-nontabular"/>
+ <xsl:text> </xsl:text>
+</xsl:template>
+
+<!-- space between last param and closing parenthesis, remove tailing semicolon -->
+<xsl:template match="void" mode="ansi-nontabular">
+ <code>void )</code>
+</xsl:template>
+
+<xsl:template match="varargs" mode="ansi-nontabular">
+ <xsl:text>...</xsl:text>
+ <code> )</code>
+</xsl:template>
+
+<xsl:template match="paramdef" mode="ansi-nontabular">
+ <xsl:apply-templates mode="ansi-nontabular"/>
+ <xsl:choose>
+ <xsl:when test="following-sibling::*">
+ <xsl:text>, </xsl:text>
+ </xsl:when>
+ <xsl:otherwise>
+ <code> )</code>
+ </xsl:otherwise>
+ </xsl:choose>
+</xsl:template>
+
+<!-- param types get code formatted (leave a space after type, as it is supposed to be before param name) -->
+<xsl:template match="paramdef/type" mode="ansi-nontabular">
+ <xsl:choose>
+ <xsl:when test="$funcsynopsis.decoration != 0">
+ <code>
+ <xsl:apply-templates mode="ansi-nontabular"/>
+ </code>
+ </xsl:when>
+ <xsl:otherwise>
+ <code>
+ <xsl:apply-templates mode="ansi-nontabular"/>
+ </code>
+ </xsl:otherwise>
+ </xsl:choose>
+ <xsl:text> </xsl:text>
+</xsl:template>
+
+<!-- default values for function parameters -->
+<xsl:template match="paramdef/initializer" mode="ansi-nontabular">
+ <xsl:text> = </xsl:text>
+ <xsl:apply-templates mode="ansi-nontabular"/>
+</xsl:template>
+
+
+</xsl:stylesheet>
\ No newline at end of file
--- /dev/null
+= XML-RPC for PHP
+:revision: 4.0.0
+:keywords: xmlrpc, xml, rpc, webservices, http
+:toc: left
+:imagesdir: images
+:source-highlighter: highlightjs
+
+
+[preface]
+== Introduction
+
+WARNING: THIS MANUAL HAS NOT YET BEEN UPDATED TO REFLECT ALL THE CHANGES WHICH HAVE MADE IN VERSION 4. *DO NOT USE* FOR NOW. You can find the API documentation at link:$$http://gggeek.github.io/phpxmlrpc/doc-4/api/index.html$$[http://gggeek.github.io/phpxmlrpc/doc-4/api/index.html]
+
+This collection of PHP classes provides a framework for writing XML-RPC clients and servers in PHP.
+
+Main goals of the project are ease of use, flexibility and completeness.
+
+The original author is Edd Dumbill of link:$$http://usefulinc.com/$$[Useful Information Company]. As of the 1.0 stable
+ release, the project was opened to wider involvement and moved to
+ link:$$http://phpxmlrpc.sourceforge.net/$$[SourceForge]; later, to link:$$https://github.com/gggeek/phpxmlrpc$$[Github]
+
+XML-RPC is a format devised by link:$$http://www.userland.com/$$[Userland Software] for achieving remote procedure call
+ via XML using HTTP as the transport. XML-RPC has its own web site, link:$$http://www.xmlrpc.com/$$[www.xmlrpc.com]
+
+A list of XML-RPC implementations for other languages such as Perl and Python can be found on the
+ link:$$http://www.xmlrpc.com/$$[www.xmlrpc.com] site.
+
+=== Acknowledgements
+
+Daniel E. Baumann
+
+James Bercegay
+
+Leon Blackwell
+
+Stephane Bortzmeyer
+
+Daniel Convissor
+
+Geoffrey T. Dairiki
+
+Stefan Esser
+
+James Flemer
+
+Ernst de Haan
+
+Tom Knight
+
+Axel Kollmorgen
+
+Peter Kocks
+
+Daniel Krippner
+
+{empty}S. Kuip
+
+{empty}A. Lambert
+
+Frederic Lecointre
+
+Dan Libby
+
+Arnaud Limbourg
+
+Ernest MacDougal Campbell III
+
+Lukasz Mach
+
+Kjartan Mannes
+
+Ben Margolin
+
+Nicolay Mausz
+
+Justin Miller
+
+Jan Pfeifer
+
+Giancarlo Pinerolo
+
+Peter Russel
+
+Jean-Jacques Sarton
+
+Viliam Simko
+
+Idan Sofer
+
+Douglas Squirrel
+
+Heiko Stübner
+
+Anatoly Techtonik
+
+Tommaso Trani
+
+Eric van der Vlist
+
+Christian Wenz
+
+Jim Winstead
+
+Przemyslaw Wroblewski
+
+Bruno Zanetti Melotti
+
+
+[[requirements]]
+== System Requirements
+
+The library has been designed with goals of flexibility and backward compatibility. As such, it supports a wide range of
+ PHP installs. Note that not all features of the lib are available in every configuration.
+
+The __minimum supported__ PHP version is 5.3.
+
+If you wish to use HTTPS or HTTP 1.1 to communicate with remote servers, or to use NTLM authentication, you need the
+ *curl* extension compiled into your PHP installation.
+
+If you wish to receive XML-RPC requests or responses in any other character set than US-ASCII, ISO-8859-1 or UTF-8, you
+ will need the *mbstring* extension compiled into your PHP installation.
+
+The *xmlrpc* native extension is not required to be compiled into your PHP installation, but if it is, there will be no
+ interference with the operation of this library.
+
+
+[[manifest]]
+== Files in the distribution
+
+debugger/*:: a graphical debugger which can be used to test calls to xmlrpc servers
+
+demo/*:: example code for implementing both xmlrpc client and server functionality
+
+doc/*:: the documentation/ this manual, and the list of API changes between versions 3 and 4
+
+extras/rsakey.pem:: A test certificate key for the SSL support, which can be used to generate dummy certificates. It has
+ the passphrase "test."
+
+extras/test.pl, extras/test.py:: Perl and Python programs to exercise server.php to test that some of the methods work.
+
+extras/workspace.testPhpServer.fttb:: Frontier scripts to exercise the demo server. Thanks to Dave Winer for permission
+ to include these. See link:$$http://www.xmlrpc.com/discuss/msgReader$853$$[Dave's announcement of these.]
+
+lib/*:: a compatibility layer for applications which still rely on version 3 of the API
+
+src/*:: the XML-RPC library classes. You can autoload these via Composer, or via a dedicated Autoloader class
+
+tests/*:: the test suite for the library, written using PhpUnit, and the configuration to run it on Travis
+
+
+[[bugs]]
+
+== Known Bugs
+
+Known bugs are tracked using the link:$$https://github.com/gggeek/phpxmlrpc/issues$$[GitHub issue tracker]
+
+== Known limitations
+
+This started out as a bare framework. Many "nice" bits have been put in over time, but backwards compatibility has
+ always taken precedence over API cleanups. As such, you might find some API choices questionable.
+
+Specifically, very little type validation or coercion has been put in. PHP being a loosely-typed language, this is
+ going to have to be done explicitly (in other words: you can call a lot of library functions passing them arguments
+ of the wrong type and receive an error message only much further down the code, where it will be difficult to
+ understand).
+
+dateTime.iso8601 is supported opaquely. It can't be done natively as the XML-RPC specification explicitly forbids
+ passing of timezone specifiers in ISO8601 format dates. You can, however, use the PhpXmlRpc\Helper\Date class to do
+ the encoding and decoding for you.
+
+Very little HTTP response checking is performed (e.g. HTTP redirects are not followed and the Content-Length HTTP
+ header, mandated by the xml-rpc spec, is not validated); cookie support still involves quite a bit of coding on the
+ part of the user.
+
+Support for receiving from servers version 1 cookies (i.e. conforming to RFC 2965) is quite incomplete, and might cause
+ unforeseen errors.
+
+
+[[support]]
+
+== Support
+
+
+=== Online Support
+
+XML-RPC for PHP is offered "as-is" without any warranty or commitment to support. However, informal advice and help is
+ available via the XML-RPC for PHP website and mailing list.
+
+* The __XML-RPC for PHP__ development is hosted on
+ link:$$https://github.com/gggeek/phpxmlrpc$$[github.com/gggeek/phpxmlrpc]. Bugs, feature requests and patches can be
+ posted to the link:$$https://github.com/gggeek/phpxmlrpc/issues$$[project's website].
+
+* The __PHP XML-RPC interest mailing list__ is run by the original author. More details
+ link:$$http://lists.gnomehack.com/mailman/listinfo/phpxmlrpc$$[can be found here].
+
+
+[[jellyfish]]
+
+=== The Jellyfish Book
+
+image::progxmlrpc.s.gif[The Jellyfish Book]
+Together with Simon St.Laurent and Joe Johnston, Edd Dumbill wrote a book on XML-RPC for O'Reilly and Associates on
+ XML-RPC. It features a rather fetching jellyfish on the cover.
+
+Complete details of the book are link:$$http://www.oreilly.com/catalog/progxmlrpc/$$[available from O'Reilly's web site.]
+
+Edd is responsible for the chapter on PHP, which includes a worked example of creating a forum server, and hooking it up
+ the O'Reilly's link:$$http://meerkat.oreillynet.com/$$[Meerkat] service in order to allow commenting on news stories
+ from around the Web.
+
+If you've benefited from the effort that has been put into writing this software, then please consider buying the book!
+
+
+[[apidocs]]
+
+== Class documentation
+
+
+==== Notes on types
+
+===== int
+
+The type i4 is accepted as a synonym
+ for int when creating xmlrpcval objects. The
+ xml parsing code will always convert i4 to
+ int: int is regarded
+ by this implementation as the canonical name for this type.
+
+The type i8 on the other hand is considered as a separate type.
+ Note that the library will never output integers as 'i8' on its own,
+ even when php is compiled in 64-bit mode.
+
+===== base64
+
+Base 64 encoding is performed transparently to the caller when
+ using this type. Decoding is also transparent. Therefore you ought
+ to consider it as a "binary" data type, for use when you want to
+ pass data that is not 7-bit clean.
+
+===== boolean
+
+The php values ++true++ and
+ ++1++ map to ++true++. All other
+ values (including the empty string) are converted to
+ ++false++.
+
+===== string
+
+Characters <, >;, ', ", &, are encoded using their
+ entity reference as < > ' " and
+ & All other characters outside of the ASCII range are
+ encoded using their character reference representation (e.g.
+ È for é). The XML-RPC spec recommends only encoding
+ ++< >++ but this implementation goes further,
+ for reasons explained by link:$$http://www.w3.org/TR/REC-xml#syntax$$[the XML 1.0 recommendation]. In particular, using character reference
+ representation has the advantage of producing XML that is valid
+ independently of the charset encoding assumed.
+
+===== null
+
+There is no support for encoding ++null++
+ values in the XML-RPC spec, but at least a couple of extensions (and
+ many toolkits) do support it. Before using ++null++
+ values in your messages, make sure that the responding party accepts
+ them, and uses the same encoding convention (see ...).
+
+[[xmlrpcval-creation]]
+
+==== Xmlrpcval creation
+
+The constructor is the normal way to create an
+ xmlrpcval. The constructor can take these
+ forms:
+
+xmlrpcvalnew
+ xmlrpcval xmlrpcvalnew
+ xmlrpcval string $stringVal xmlrpcvalnew
+ xmlrpcval mixed $scalarVal string$scalartyp xmlrpcvalnew
+ xmlrpcval array $arrayVal string $arraytyp The first constructor creates an empty value, which must be
+ altered using the methods addScalar,
+ addArray or addStruct before
+ it can be used.
+
+The second constructor creates a simple string value.
+
+The third constructor is used to create a scalar value. The
+ second parameter must be a name of an XML-RPC type. Valid types are:
+ "++int++", "++boolean++",
+ "++string++", "++double++",
+ "++dateTime.iso8601++", "++base64++" or
+ "null".
+
+Examples:
+
+[source, php]
+----
+
+$myInt = new xmlrpcval(1267, "int");
+$myString = new xmlrpcval("Hello, World!", "string");
+$myBool = new xmlrpcval(1, "boolean");
+$myString2 = new xmlrpcval(1.24, "string"); // note: this will serialize a php float value as xmlrpc string
+
+----
+
+The fourth constructor form can be used to compose complex
+ XML-RPC values. The first argument is either a simple array in the
+ case of an XML-RPC array or an associative
+ array in the case of a struct. The elements of
+ the array __must be xmlrpcval objects themselves__.
+
+The second parameter must be either "++array++"
+ or "++struct++".
+
+Examples:
+
+[source, php]
+----
+
+$myArray = new xmlrpcval(
+ array(
+ new xmlrpcval("Tom"),
+ new xmlrpcval("Dick"),
+ new xmlrpcval("Harry")
+ ),
+ "array");
+
+// recursive struct
+$myStruct = new xmlrpcval(
+ array(
+ "name" => new xmlrpcval("Tom", "string"),
+ "age" => new xmlrpcval(34, "int"),
+ "address" => new xmlrpcval(
+ array(
+ "street" => new xmlrpcval("Fifht Ave", "string"),
+ "city" => new xmlrpcval("NY", "string")
+ ),
+ "struct")
+ ),
+ "struct");
+
+----
+
+See the file ++vardemo.php++ in this distribution
+ for more examples.
+
+[[xmlrpc-client]]
+
+==== Xmlrpc-client creation
+
+The constructor accepts one of two possible syntaxes:
+
+xmlrpc_clientnew
+ xmlrpc_clientstring$server_urlxmlrpc_clientnew
+ xmlrpc_clientstring$server_pathstring$server_hostnameint$server_port80string$transport'http'Here are a couple of usage examples of the first form:
+
+
+[source, php]
+----
+
+$client = new xmlrpc_client("http://phpxmlrpc.sourceforge.net/server.php");
+$another_client = new xmlrpc_client("https://james:bond@secret.service.com:443/xmlrpcserver?agent=007");
+
+----
+
+The second syntax does not allow to express a username and
+ password to be used for basic HTTP authorization as in the second
+ example above, but instead it allows to choose whether xmlrpc calls
+ will be made using the HTTP 1.0 or 1.1 protocol.
+
+Here's another example client set up to query Userland's XML-RPC
+ server at __betty.userland.com__:
+
+[source, php]
+----
+
+$client = new xmlrpc_client("/RPC2", "betty.userland.com", 80);
+
+----
+
+The server_port parameter is optional,
+ and if omitted will default to 80 when using HTTP and 443 when using
+ HTTPS (see the <<xmlrpc-client-send>> method
+ below).
+
+The transport parameter is optional, and
+ if omitted will default to 'http'. Allowed values are either
+ 'http', 'https' or
+ 'http11'. Its value can be overridden with every call
+ to the send method. See the
+ send method below for more details about the
+ meaning of the different values.
+
+
+[[xmlrpc-server]]
+
+=== xmlrpc_server
+
+The implementation of this class has been kept as simple to use as
+ possible. The constructor for the server basically does all the work.
+ Here's a minimal example:
+
+
+[source, php]
+----
+
+ function foo ($xmlrpcmsg) {
+ ...
+ return new xmlrpcresp($some_xmlrpc_val);
+ }
+
+ class bar {
+ function foobar($xmlrpcmsg) {
+ ...
+ return new xmlrpcresp($some_xmlrpc_val);
+ }
+ }
+
+ $s = new xmlrpc_server(
+ array(
+ "examples.myFunc1" => array("function" => "foo"),
+ "examples.myFunc2" => array("function" => "bar::foobar"),
+ ));
+
+----
+
+This performs everything you need to do with a server. The single
+ constructor argument is an associative array from xmlrpc method names to
+ php function names. The incoming request is parsed and dispatched to the
+ relevant php function, which is responsible for returning a
+ xmlrpcresp object, that will be serialized back
+ to the caller.
+
+
+==== Method handler functions
+
+Both php functions and class methods can be registered as xmlrpc
+ method handlers.
+
+The synopsis of a method handler function is:
+
+xmlrpcresp $resp = function (xmlrpcmsg $msg)
+
+No text should be echoed 'to screen' by the handler function, or
+ it will break the xml response sent back to the client. This applies
+ also to error and warning messages that PHP prints to screen unless
+ the appropriate parameters have been set in the php.in file. Another
+ way to prevent echoing of errors inside the response and facilitate
+ debugging is to use the server SetDebug method with debug level 3 (see
+ ...). Exceptions thrown duting execution of handler functions are
+ caught by default and a XML-RPC error reponse is generated instead.
+ This behaviour can be finetuned by usage of the
+ exception_handling member variable (see
+ ...).
+
+Note that if you implement a method with a name prefixed by
+ ++system.++ the handler function will be invoked by the
+ server with two parameters, the first being the server itself and the
+ second being the xmlrpcmsg object.
+
+The same php function can be registered as handler of multiple
+ xmlrpc methods.
+
+Here is a more detailed example of what the handler function
+ foo may do:
+
+
+[source, php]
+----
+
+ function foo ($xmlrpcmsg) {
+ global $xmlrpcerruser; // import user errcode base value
+
+ $meth = $xmlrpcmsg->method(); // retrieve method name
+ $par = $xmlrpcmsg->getParam(0); // retrieve value of first parameter - assumes at least one param received
+ $val = $par->scalarval(); // decode value of first parameter - assumes it is a scalar value
+
+ ...
+
+ if ($err) {
+ // this is an error condition
+ return new xmlrpcresp(0, $xmlrpcerruser+1, // user error 1
+ "There's a problem, Captain");
+ } else {
+ // this is a successful value being returned
+ return new xmlrpcresp(new xmlrpcval("All's fine!", "string"));
+ }
+ }
+
+----
+
+See __server.php__ in this distribution for
+ more examples of how to do this.
+
+Since release 2.0RC3 there is a new, even simpler way of
+ registering php functions with the server. See section 5.7
+ below
+
+
+==== The dispatch map
+
+The first argument to the xmlrpc_server
+ constructor is an array, called the __dispatch map__.
+ In this array is the information the server needs to service the
+ XML-RPC methods you define.
+
+The dispatch map takes the form of an associative array of
+ associative arrays: the outer array has one entry for each method, the
+ key being the method name. The corresponding value is another
+ associative array, which can have the following members:
+
+
+* ++function++ - this
+ entry is mandatory. It must be either a name of a function in the
+ global scope which services the XML-RPC method, or an array
+ containing an instance of an object and a static method name (for
+ static class methods the 'class::method' syntax is also
+ supported).
+
+
+* ++signature++ - this
+ entry is an array containing the possible signatures (see <<signatures>>) for the method. If this entry is present
+ then the server will check that the correct number and type of
+ parameters have been sent for this method before dispatching
+ it.
+
+
+* ++docstring++ - this
+ entry is a string containing documentation for the method. The
+ documentation may contain HTML markup.
+
+
+* ++$$signature_docs$$++ - this entry can be used
+ to provide documentation for the single parameters. It must match
+ in structure the 'signature' member. By default, only the
+ documenting_xmlrpc_server class in the
+ extras package will take advantage of this, since the
+ "system.methodHelp" protocol does not support documenting method
+ parameters individually.
+
+
+* ++$$parameters_type$$++ - this entry can be used
+ when the server is working in 'xmlrpcvals' mode (see ...) to
+ define one or more entries in the dispatch map as being functions
+ that follow the 'phpvals' calling convention. The only useful
+ value is currently the string ++phpvals++.
+
+Look at the __server.php__ example in the
+ distribution to see what a dispatch map looks like.
+
+[[signatures]]
+
+==== Method signatures
+
+A signature is a description of a method's return type and its
+ parameter types. A method may have more than one signature.
+
+Within a server's dispatch map, each method has an array of
+ possible signatures. Each signature is an array of types. The first
+ entry is the return type. For instance, the method
+[source, php]
+----
+string examples.getStateName(int)
+
+----
+
+ has the signature
+[source, php]
+----
+array($xmlrpcString, $xmlrpcInt)
+
+----
+
+ and, assuming that it is the only possible signature for the
+ method, it might be used like this in server creation:
+[source, php]
+----
+
+$findstate_sig = array(array($xmlrpcString, $xmlrpcInt));
+
+$findstate_doc = 'When passed an integer between 1 and 51 returns the
+name of a US state, where the integer is the index of that state name
+in an alphabetic order.';
+
+$s = new xmlrpc_server( array(
+ "examples.getStateName" => array(
+ "function" => "findstate",
+ "signature" => $findstate_sig,
+ "docstring" => $findstate_doc
+ )));
+
+----
+
+
+
+Note that method signatures do not allow to check nested
+ parameters, e.g. the number, names and types of the members of a
+ struct param cannot be validated.
+
+If a method that you want to expose has a definite number of
+ parameters, but each of those parameters could reasonably be of
+ multiple types, the array of acceptable signatures will easily grow
+ into a combinatorial explosion. To avoid such a situation, the lib
+ defines the global var $xmlrpcValue, which can be
+ used in method signatures as a placeholder for 'any xmlrpc
+ type':
+
+
+[source, php]
+----
+
+$echoback_sig = array(array($xmlrpcValue, $xmlrpcValue));
+
+$findstate_doc = 'Echoes back to the client the received value, regardless of its type';
+
+$s = new xmlrpc_server( array(
+ "echoBack" => array(
+ "function" => "echoback",
+ "signature" => $echoback_sig, // this sig guarantees that the method handler will be called with one and only one parameter
+ "docstring" => $echoback_doc
+ )));
+
+----
+
+Methods system.listMethods,
+ system.methodHelp,
+ system.methodSignature and
+ system.multicall are already defined by the
+ server, and should not be reimplemented (see Reserved Methods
+ below).
+
+
+==== Delaying the server response
+
+You may want to construct the server, but for some reason not
+ fulfill the request immediately (security verification, for instance).
+ If you omit to pass to the constructor the dispatch map or pass it a
+ second argument of ++0++ this will have the desired
+ effect. You can then use the service() method of
+ the server class to service the request. For example:
+
+
+[source, php]
+----
+
+$s = new xmlrpc_server($myDispMap, 0); // second parameter = 0 prevents automatic servicing of request
+
+// ... some code that does other stuff here
+
+$s->service();
+
+----
+
+Note that the service method will print
+ the complete result payload to screen and send appropriate HTTP
+ headers back to the client, but also return the response object. This
+ permits further manipulation of the response, possibly in combination
+ with output buffering.
+
+To prevent the server from sending HTTP headers back to the
+ client, you can pass a second parameter with a value of
+ ++TRUE++ to the service
+ method. In this case, the response payload will be returned instead of
+ the response object.
+
+Xmlrpc requests retrieved by other means than HTTP POST bodies
+ can also be processed. For example:
+
+
+[source, php]
+----
+
+$s = new xmlrpc_server(); // not passing a dispatch map prevents automatic servicing of request
+
+// ... some code that does other stuff here, including setting dispatch map into server object
+
+$resp = $s->service($xmlrpc_request_body, true); // parse a variable instead of POST body, retrieve response payload
+
+// ... some code that does other stuff with xml response $resp here
+
+----
+
+
+==== Modifying the server behaviour
+
+A couple of methods / class variables are available to modify
+ the behaviour of the server. The only way to take advantage of their
+ existence is by usage of a delayed server response (see above)
+
+
+===== setDebug()
+
+This function controls weather the server is going to echo
+ debugging messages back to the client as comments in response body.
+ Valid values: 0,1,2,3, with 1 being the default. At level 0, no
+ debug info is returned to the client. At level 2, the complete
+ client request is added to the response, as part of the xml
+ comments. At level 3, a new PHP error handler is set when executing
+ user functions exposed as server methods, and all non-fatal errors
+ are trapped and added as comments into the response.
+
+
+===== allow_system_funcs
+
+Default_value: TRUE. When set to FALSE, disables support for
+ System.xxx functions in the server. It
+ might be useful e.g. if you do not wish the server to respond to
+ requests to System.ListMethods.
+
+
+===== compress_response
+
+When set to TRUE, enables the server to take advantage of HTTP
+ compression, otherwise disables it. Responses will be transparently
+ compressed, but only when an xmlrpc-client declares its support for
+ compression in the HTTP headers of the request.
+
+Note that the ZLIB php extension must be installed for this to
+ work. If it is, compress_response will default to
+ TRUE.
+
+
+===== exception_handling
+
+This variable controls the behaviour of the server when an
+ exception is thrown by a method handler php function. Valid values:
+ 0,1,2, with 0 being the default. At level 0, the server catches the
+ exception and return an 'internal error' xmlrpc response; at 1 it
+ catches the exceptions and return an xmlrpc response with the error
+ code and error message corresponding to the exception that was
+ thron; at 2 = the exception is floated to the upper layers in the
+ code
+
+
+===== response_charset_encoding
+
+Charset encoding to be used for response (only affects string
+ values).
+
+If it can, the server will convert the generated response from
+ internal_encoding to the intended one.
+
+Valid values are: a supported xml encoding (only UTF-8 and
+ ISO-8859-1 at present, unless mbstring is enabled), null (leave
+ charset unspecified in response and convert output stream to
+ US_ASCII), 'default' (use xmlrpc library default as specified in
+ xmlrpc.inc, convert output stream if needed), or 'auto' (use
+ client-specified charset encoding or same as request if request
+ headers do not specify it (unless request is US-ASCII: then use
+ library default anyway).
+
+
+==== Fault reporting
+
+Fault codes for your servers should start at the value indicated
+ by the global ++$xmlrpcerruser++ + 1.
+
+Standard errors returned by the server include:
+
+++1++ Unknown method:: Returned if the server was asked to dispatch a method it
+ didn't know about
+
+++2++ Invalid return payload:: This error is actually generated by the client, not
+ server, code, but signifies that a server returned something it
+ couldn't understand. A more detailed error report is sometimes
+ added onto the end of the phrase above.
+
+++3++ Incorrect parameters:: This error is generated when the server has signature(s)
+ defined for a method, and the parameters passed by the client do
+ not match any of signatures.
+
+++4++ Can't introspect: method unknown:: This error is generated by the builtin
+ system.* methods when any kind of
+ introspection is attempted on a method undefined by the
+ server.
+
+++5++ Didn't receive 200 OK from remote server:: This error is generated by the client when a remote server
+ doesn't return HTTP/1.1 200 OK in response to a request. A more
+ detailed error report is added onto the end of the phrase
+ above.
+
+++6++ No data received from server:: This error is generated by the client when a remote server
+ returns HTTP/1.1 200 OK in response to a request, but no
+ response body follows the HTTP headers.
+
+++7++ No SSL support compiled in:: This error is generated by the client when trying to send
+ a request with HTTPS and the CURL extension is not available to
+ PHP.
+
+++8++ CURL error:: This error is generated by the client when trying to send
+ a request with HTTPS and the HTTPS communication fails.
+
+++9-14++ multicall errors:: These errors are generated by the server when something
+ fails inside a system.multicall request.
+
+++100-++ XML parse errors:: Returns 100 plus the XML parser error code for the fault
+ that occurred. The faultString returned
+ explains where the parse error was in the incoming XML
+ stream.
+
+
+==== 'New style' servers
+
+In the same spirit of simplification that inspired the
+ xmlrpc_client::return_type class variable, a new
+ class variable has been added to the server class:
+ functions_parameters_type. When set to 'phpvals',
+ the functions registered in the server dispatch map will be called
+ with plain php values as parameters, instead of a single xmlrpcmsg
+ instance parameter. The return value of those functions is expected to
+ be a plain php value, too. An example is worth a thousand
+ words:
+[source, php]
+----
+
+ function foo($usr_id, $out_lang='en') {
+ global $xmlrpcerruser;
+
+ ...
+
+ if ($someErrorCondition)
+ return new xmlrpcresp(0, $xmlrpcerruser+1, 'DOH!');
+ else
+ return array(
+ 'name' => 'Joe',
+ 'age' => 27,
+ 'picture' => new xmlrpcval(file_get_contents($picOfTheGuy), 'base64')
+ );
+ }
+
+ $s = new xmlrpc_server(
+ array(
+ "examples.myFunc" => array(
+ "function" => "bar::foobar",
+ "signature" => array(
+ array($xmlrpcString, $xmlrpcInt),
+ array($xmlrpcString, $xmlrpcInt, $xmlrpcString)
+ )
+ )
+ ), false);
+ $s->functions_parameters_type = 'phpvals';
+ $s->service();
+
+----
+
+There are a few things to keep in mind when using this
+ simplified syntax:
+
+to return an xmlrpc error, the method handler function must
+ return an instance of xmlrpcresp. The only
+ other way for the server to know when an error response should be
+ served to the client is to throw an exception and set the server's
+ exception_handling memeber var to 1;
+
+to return a base64 value, the method handler function must
+ encode it on its own, creating an instance of an xmlrpcval
+ object;
+
+the method handler function cannot determine the name of the
+ xmlrpc method it is serving, unlike standard handler functions that
+ can retrieve it from the message object;
+
+when receiving nested parameters, the method handler function
+ has no way to distinguish a php string that was sent as base64 value
+ from one that was sent as a string value;
+
+this has a direct consequence on the support of
+ system.multicall: a method whose signature contains datetime or base64
+ values will not be available to multicall calls;
+
+last but not least, the direct parsing of xml to php values is
+ much faster than using xmlrpcvals, and allows the library to handle
+ much bigger messages without allocating all available server memory or
+ smashing PHP recursive call stack.
+
+
+[[globalvars]]
+
+== Global variables
+
+Many global variables are defined in the xmlrpc.inc file. Some of
+ those are meant to be used as constants (and modifying their value might
+ cause unpredictable behaviour), while some others can be modified in your
+ php scripts to alter the behaviour of the xml-rpc client and
+ server.
+
+
+=== "Constant" variables
+
+
+==== $xmlrpcerruser
+
+$xmlrpcerruser800The minimum value for errors reported by user
+ implemented XML-RPC servers. Error numbers lower than that are
+ reserved for library usage.
+
+
+==== $xmlrpcI4, $xmlrpcI8 $xmlrpcInt, $xmlrpcBoolean, $xmlrpcDouble, $xmlrpcString, $xmlrpcDateTime, $xmlrpcBase64, $xmlrpcArray, $xmlrpcStruct, $xmlrpcValue, $xmlrpcNull
+
+For convenience the strings representing the XML-RPC types have
+ been encoded as global variables:
+[source, php]
+----
+
+$xmlrpcI4="i4";
+$xmlrpcI8="i8";
+$xmlrpcInt="int";
+$xmlrpcBoolean="boolean";
+$xmlrpcDouble="double";
+$xmlrpcString="string";
+$xmlrpcDateTime="dateTime.iso8601";
+$xmlrpcBase64="base64";
+$xmlrpcArray="array";
+$xmlrpcStruct="struct";
+$xmlrpcValue="undefined";
+$xmlrpcNull="null";
+
+----
+
+==== $xmlrpcTypes, $xmlrpc_valid_parents, $xmlrpcerr, $xmlrpcstr, $xmlrpcerrxml, $xmlrpc_backslash, $_xh, $xml_iso88591_Entities, $xmlEntities, $xmlrpcs_capabilities
+
+Reserved for internal usage.
+
+
+=== Variables whose value can be modified
+
+[[xmlrpc-defencoding]]
+
+==== xmlrpc_defencoding
+
+$xmlrpc_defencoding"UTF8"This variable defines the character set encoding that will be
+ used by the xml-rpc client and server to decode the received messages,
+ when a specific charset declaration is not found (in the messages sent
+ non-ascii chars are always encoded using character references, so that
+ the produced xml is valid regardless of the charset encoding
+ assumed).
+
+Allowed values: ++"UTF8"++,
+ ++"ISO-8859-1"++, ++"ASCII".++
+
+Note that the appropriate RFC actually mandates that XML
+ received over HTTP without indication of charset encoding be treated
+ as US-ASCII, but many servers and clients 'in the wild' violate the
+ standard, and assume the default encoding is UTF-8.
+
+
+==== xmlrpc_internalencoding
+
+$xmlrpc_internalencoding"ISO-8859-1"This variable defines the character set encoding
+ that the library uses to transparently encode into valid XML the
+ xml-rpc values created by the user and to re-encode the received
+ xml-rpc values when it passes them to the PHP application. It only
+ affects xml-rpc values of string type. It is a separate value from
+ xmlrpc_defencoding, allowing e.g. to send/receive xml messages encoded
+ on-the-wire in US-ASCII and process them as UTF-8. It defaults to the
+ character set used internally by PHP (unless you are running an
+ MBString-enabled installation), so you should change it only in
+ special situations, if e.g. the string values exchanged in the xml-rpc
+ messages are directly inserted into / fetched from a database
+ configured to return UTF8 encoded strings to PHP. Example
+ usage:
+
+[source, php]
+----
+
+<?php
+
+include('xmlrpc.inc');
+$xmlrpc_internalencoding = 'UTF-8'; // this has to be set after the inclusion above
+$v = new xmlrpcval('κόÏ\83με'); // This xmlrpc value will be correctly serialized as the greek word 'kosme'
+
+----
+
+==== xmlrpcName
+
+$xmlrpcName"XML-RPC for PHP"The string representation of the name of the XML-RPC
+ for PHP library. It is used by the client for building the User-Agent
+ HTTP header that is sent with every request to the server. You can
+ change its value if you need to customize the User-Agent
+ string.
+
+
+==== xmlrpcVersion
+
+$xmlrpcVersion"2.2"The string representation of the version number of
+ the XML-RPC for PHP library in use. It is used by the client for
+ building the User-Agent HTTP header that is sent with every request to
+ the server. You can change its value if you need to customize the
+ User-Agent string.
+
+
+==== xmlrpc_null_extension
+
+When set to TRUE, the lib will enable
+ support for the <NIL/> (and <EX:NIL/>) xmlrpc value, as
+ per the extension to the standard proposed here. This means that
+ <NIL> and <EX:NIL/> tags received will be parsed as valid
+ xmlrpc, and the corresponding xmlrpcvals will return "null" for
+ scalarTyp().
+
+
+==== xmlrpc_null_apache_encoding
+
+When set to ++TRUE++, php NULL values encoded
+ into xmlrpcval objects get serialized using the
+ ++<EX:NIL/>++ tag instead of
+ ++<NIL/>++. Please note that both forms are
+ always accepted as input regardless of the value of this
+ variable.
+
+
+[[helpers]]
+
+== Helper functions
+
+XML-RPC for PHP contains some helper functions which you can use to
+ make processing of XML-RPC requests easier.
+
+
+=== Date functions
+
+The XML-RPC specification has this to say on dates:
+
+[quote]
+____
+[[wrap_xmlrpc_method]]
+Don't assume a timezone. It should be
+ specified by the server in its documentation what assumptions it makes
+ about timezones.
+____
+
+
+Unfortunately, this means that date processing isn't
+ straightforward. Although XML-RPC uses ISO 8601 format dates, it doesn't
+ use the timezone specifier.
+
+We strongly recommend that in every case where you pass dates in
+ XML-RPC calls, you use UTC (GMT) as your timezone. Most computer
+ languages include routines for handling GMT times natively, and you
+ won't have to translate between timezones.
+
+For more information about dates, see link:$$http://www.uic.edu/year2000/datefmt.html$$[ISO 8601: The Right Format for Dates], which has a handy link to a PDF of the ISO
+ 8601 specification. Note that XML-RPC uses exactly one of the available
+ representations: CCYYMMDDTHH:MM:SS.
+
+[[iso8601encode]]
+
+==== iso8601_encode
+
+stringiso8601_encodestring$time_tint$utc0Returns an ISO 8601 formatted date generated from the UNIX
+ timestamp $time_t, as returned by the PHP
+ function time().
+
+The argument $utc can be omitted, in
+ which case it defaults to ++0++. If it is set to
+ ++1++, then the function corrects the time passed in
+ for UTC. Example: if you're in the GMT-6:00 timezone and set
+ $utc, you will receive a date representation
+ six hours ahead of your local time.
+
+The included demo program __vardemo.php__
+ includes a demonstration of this function.
+
+[[iso8601decode]]
+
+==== iso8601_decode
+
+intiso8601_decodestring$isoStringint$utc0Returns a UNIX timestamp from an ISO 8601 encoded time and date
+ string passed in. If $utc is
+ ++1++ then $isoString is assumed
+ to be in the UTC timezone, and thus the result is also UTC: otherwise,
+ the timezone is assumed to be your local timezone and you receive a
+ local timestamp.
+
+[[arrayuse]]
+
+=== Easy use with nested PHP values
+
+Dan Libby was kind enough to contribute two helper functions that
+ make it easier to translate to and from PHP values. This makes it easier
+ to deal with complex structures. At the moment support is limited to
+ int, double, string,
+ array, datetime and struct
+ datatypes; note also that all PHP arrays are encoded as structs, except
+ arrays whose keys are integer numbers starting with 0 and incremented by
+ 1.
+
+These functions reside in __xmlrpc.inc__.
+
+[[phpxmlrpcdecode]]
+
+==== php_xmlrpc_decode
+
+mixedphp_xmlrpc_decodexmlrpcval$xmlrpc_valarray$optionsarrayphp_xmlrpc_decodexmlrpcmsg$xmlrpcmsg_valstring$optionsReturns a native PHP value corresponding to the values found in
+ the xmlrpcval $xmlrpc_val,
+ translated into PHP types. Base-64 and datetime values are
+ automatically decoded to strings.
+
+In the second form, returns an array containing the parameters
+ of the given
+ xmlrpcmsg_val, decoded
+ to php types.
+
+The options parameter is optional. If
+ specified, it must consist of an array of options to be enabled in the
+ decoding process. At the moment the only valid option are
+ decode_php_objs and
+ ++$$dates_as_objects$$++. When the first is set, php
+ objects that have been converted to xml-rpc structs using the
+ php_xmlrpc_encode function and a corresponding
+ encoding option will be converted back into object values instead of
+ arrays (provided that the class definition is available at
+ reconstruction time). When the second is set, XML-RPC datetime values
+ will be converted into native dateTime objects
+ instead of strings.
+
+____WARNING__:__ please take
+ extreme care before enabling the decode_php_objs
+ option: when php objects are rebuilt from the received xml, their
+ constructor function will be silently invoked. This means that you are
+ allowing the remote end to trigger execution of uncontrolled PHP code
+ on your server, opening the door to code injection exploits. Only
+ enable this option when you have complete trust of the remote
+ server/client.
+
+Example:
+[source, php]
+----
+
+// wrapper to expose an existing php function as xmlrpc method handler
+function foo_wrapper($m)
+{
+ $params = php_xmlrpc_decode($m);
+ $retval = call_user_func_array('foo', $params);
+ return new xmlrpcresp(new xmlrpcval($retval)); // foo return value will be serialized as string
+}
+
+$s = new xmlrpc_server(array(
+ "examples.myFunc1" => array(
+ "function" => "foo_wrapper",
+ "signatures" => ...
+ )));
+
+----
+
+[[phpxmlrpcencode]]
+
+==== php_xmlrpc_encode
+
+xmlrpcvalphp_xmlrpc_encodemixed$phpvalarray$optionsReturns an xmlrpcval object populated with the PHP
+ values in $phpval. Works recursively on arrays
+ and objects, encoding numerically indexed php arrays into array-type
+ xmlrpcval objects and non numerically indexed php arrays into
+ struct-type xmlrpcval objects. Php objects are encoded into
+ struct-type xmlrpcvals, excepted for php values that are already
+ instances of the xmlrpcval class or descendants thereof, which will
+ not be further encoded. Note that there's no support for encoding php
+ values into base-64 values. Encoding of date-times is optionally
+ carried on on php strings with the correct format.
+
+The options parameter is optional. If
+ specified, it must consist of an array of options to be enabled in the
+ encoding process. At the moment the only valid options are
+ encode_php_objs, ++$$null_extension$$++
+ and auto_dates.
+
+The first will enable the creation of 'particular' xmlrpcval
+ objects out of php objects, that add a "php_class" xml attribute to
+ their serialized representation. This attribute allows the function
+ php_xmlrpc_decode to rebuild the native php objects (provided that the
+ same class definition exists on both sides of the communication). The
+ second allows to encode php ++NULL++ values to the
+ ++<NIL/>++ (or
+ ++<EX:NIL>++, see ...) tag. The last encodes any
+ string that matches the ISO8601 format into an XML-RPC
+ datetime.
+
+Example:
+[source, php]
+----
+
+// the easy way to build a complex xml-rpc struct, showing nested base64 value and datetime values
+$val = php_xmlrpc_encode(array(
+ 'first struct_element: an int' => 666,
+ 'second: an array' => array ('apple', 'orange', 'banana'),
+ 'third: a base64 element' => new xmlrpcval('hello world', 'base64'),
+ 'fourth: a datetime' => '20060107T01:53:00'
+ ), array('auto_dates'));
+
+----
+
+==== php_xmlrpc_decode_xml
+
+xmlrpcval | xmlrpcresp |
+ xmlrpcmsgphp_xmlrpc_decode_xmlstring$xmlarray$optionsDecodes the xml representation of either an xmlrpc request,
+ response or single value, returning the corresponding php-xmlrpc
+ object, or ++FALSE++ in case of an error.
+
+The options parameter is optional. If
+ specified, it must consist of an array of options to be enabled in the
+ decoding process. At the moment, no option is supported.
+
+Example:
+[source, php]
+----
+
+$text = '<value><array><data><value>Hello world</value></data></array></value>';
+$val = php_xmlrpc_decode_xml($text);
+if ($val) echo 'Found a value of type '.$val->kindOf(); else echo 'Found invalid xml';
+
+----
+
+=== Automatic conversion of php functions into xmlrpc methods (and vice versa)
+
+For the extremely lazy coder, helper functions have been added
+ that allow to convert a php function into an xmlrpc method, and a
+ remotely exposed xmlrpc method into a local php function - or a set of
+ methods into a php class. Note that these comes with many caveat.
+
+
+==== wrap_xmlrpc_method
+
+stringwrap_xmlrpc_method$client$methodname$extra_optionsstringwrap_xmlrpc_method$client$methodname$signum$timeout$protocol$funcnameGiven an xmlrpc server and a method name, creates a php wrapper
+ function that will call the remote method and return results using
+ native php types for both params and results. The generated php
+ function will return an xmlrpcresp object for failed xmlrpc
+ calls.
+
+The second syntax is deprecated, and is listed here only for
+ backward compatibility.
+
+The server must support the
+ system.methodSignature xmlrpc method call for
+ this function to work.
+
+The client param must be a valid
+ xmlrpc_client object, previously created with the address of the
+ target xmlrpc server, and to which the preferred communication options
+ have been set.
+
+The optional parameters can be passed as array key,value pairs
+ in the extra_options param.
+
+The signum optional param has the purpose
+ of indicating which method signature to use, if the given server
+ method has multiple signatures (defaults to 0).
+
+The timeout and
+ protocol optional params are the same as in the
+ xmlrpc_client::send() method.
+
+If set, the optional new_function_name
+ parameter indicates which name should be used for the generated
+ function. In case it is not set the function name will be
+ auto-generated.
+
+If the ++$$return_source$$++ optional parameter is
+ set, the function will return the php source code to build the wrapper
+ function, instead of evaluating it (useful to save the code and use it
+ later as stand-alone xmlrpc client).
+
+If the ++$$encode_php_objs$$++ optional parameter is
+ set, instances of php objects later passed as parameters to the newly
+ created function will receive a 'special' treatment that allows the
+ server to rebuild them as php objects instead of simple arrays. Note
+ that this entails using a "slightly augmented" version of the xmlrpc
+ protocol (ie. using element attributes), which might not be understood
+ by xmlrpc servers implemented using other libraries.
+
+If the ++$$decode_php_objs$$++ optional parameter is
+ set, instances of php objects that have been appropriately encoded by
+ the server using a coordinate option will be deserialized as php
+ objects instead of simple arrays (the same class definition should be
+ present server side and client side).
+
+__Note that this might pose a security risk__,
+ since in order to rebuild the object instances their constructor
+ method has to be invoked, and this means that the remote server can
+ trigger execution of unforeseen php code on the client: not really a
+ code injection, but almost. Please enable this option only when you
+ trust the remote server.
+
+In case of an error during generation of the wrapper function,
+ FALSE is returned, otherwise the name (or source code) of the new
+ function.
+
+Known limitations: server must support
+ system.methodsignature for the wanted xmlrpc
+ method; for methods that expose multiple signatures, only one can be
+ picked; for remote calls with nested xmlrpc params, the caller of the
+ generated php function has to encode on its own the params passed to
+ the php function if these are structs or arrays whose (sub)members
+ include values of type base64.
+
+Note: calling the generated php function 'might' be slow: a new
+ xmlrpc client is created on every invocation and an xmlrpc-connection
+ opened+closed. An extra 'debug' param is appended to the parameter
+ list of the generated php function, useful for debugging
+ purposes.
+
+Example usage:
+
+
+[source, php]
+----
+
+$c = new xmlrpc_client('http://phpxmlrpc.sourceforge.net/server.php');
+
+$function = wrap_xmlrpc_method($client, 'examples.getStateName');
+
+if (!$function)
+ die('Cannot introspect remote method');
+else {
+ $stateno = 15;
+ $statename = $function($a);
+ if (is_a($statename, 'xmlrpcresp')) // call failed
+ {
+ echo 'Call failed: '.$statename->faultCode().'. Calling again with debug on';
+ $function($a, true);
+ }
+ else
+ echo "OK, state nr. $stateno is $statename";
+}
+
+----
+
+[[wrap_php_function]]
+
+==== wrap_php_function
+
+arraywrap_php_functionstring$funcnamestring$wrapper_function_namearray$extra_optionsGiven a user-defined PHP function, create a PHP 'wrapper'
+ function that can be exposed as xmlrpc method from an xmlrpc_server
+ object and called from remote clients, and return the appropriate
+ definition to be added to a server's dispatch map.
+
+The optional $wrapper_function_name
+ specifies the name that will be used for the auto-generated
+ function.
+
+Since php is a typeless language, to infer types of input and
+ output parameters, it relies on parsing the javadoc-style comment
+ block associated with the given function. Usage of xmlrpc native types
+ (such as datetime.dateTime.iso8601 and base64) in the docblock @param
+ tag is also allowed, if you need the php function to receive/send data
+ in that particular format (note that base64 encoding/decoding is
+ transparently carried out by the lib, while datetime vals are passed
+ around as strings).
+
+Known limitations: only works for
+ user-defined functions, not for PHP internal functions (reflection
+ does not support retrieving number/type of params for those); the
+ wrapped php function will not be able to programmatically return an
+ xmlrpc error response.
+
+If the ++$$return_source$$++ optional parameter is
+ set, the function will return the php source code to build the wrapper
+ function, instead of evaluating it (useful to save the code and use it
+ later in a stand-alone xmlrpc server). It will be in the stored in the
+ ++source++ member of the returned array.
+
+If the ++$$suppress_warnings$$++ optional parameter
+ is set, any runtime warning generated while processing the
+ user-defined php function will be catched and not be printed in the
+ generated xml response.
+
+If the extra_options array contains the
+ ++$$encode_php_objs$$++ value, wrapped functions returning
+ php objects will generate "special" xmlrpc responses: when the xmlrpc
+ decoding of those responses is carried out by this same lib, using the
+ appropriate param in php_xmlrpc_decode(), the objects will be
+ rebuilt.
+
+In short: php objects can be serialized, too (except for their
+ resource members), using this function. Other libs might choke on the
+ very same xml that will be generated in this case (i.e. it has a
+ nonstandard attribute on struct element tags)
+
+If the ++$$decode_php_objs$$++ optional parameter is
+ set, instances of php objects that have been appropriately encoded by
+ the client using a coordinate option will be deserialized and passed
+ to the user function as php objects instead of simple arrays (the same
+ class definition should be present server side and client
+ side).
+
+__Note that this might pose a security risk__,
+ since in order to rebuild the object instances their constructor
+ method has to be invoked, and this means that the remote client can
+ trigger execution of unforeseen php code on the server: not really a
+ code injection, but almost. Please enable this option only when you
+ trust the remote clients.
+
+Example usage:
+
+
+[source, php]
+----
+/**
+* State name from state number decoder. NB: do NOT remove this comment block.
+* @param integer $stateno the state number
+* @return string the name of the state (or error description)
+*/
+function findstate($stateno)
+{
+ global $stateNames;
+ if (isset($stateNames[$stateno-1]))
+ {
+ return $stateNames[$stateno-1];
+ }
+ else
+ {
+ return "I don't have a state for the index '" . $stateno . "'";
+ }
+}
+
+// wrap php function, build xmlrpc server
+$methods = array();
+$findstate_sig = wrap_php_function('findstate');
+if ($findstate_sig)
+ $methods['examples.getStateName'] = $findstate_sig;
+$srv = new xmlrpc_server($methods);
+
+----
+
+[[deprecated]]
+
+=== Functions removed from the library
+
+The following two functions have been deprecated in version 1.1 of
+ the library, and removed in version 2, in order to avoid conflicts with
+ the EPI xml-rpc library, which also defines two functions with the same
+ names.
+
+To ease the transition to the new naming scheme and avoid breaking
+ existing implementations, the following scheme has been adopted:
+
+* If EPI-XMLRPC is not active in the current PHP installation,
+ the constant `XMLRPC_EPI_ENABLED` will be set to
+ '0'
+
+
+* If EPI-XMLRPC is active in the current PHP installation, the
+ constant `XMLRPC_EPI_ENABLED` will be set to
+ '1'
+
+
+
+The following documentation is kept for historical
+ reference:
+
+[[xmlrpcdecode]]
+
+==== xmlrpc_decode
+
+mixedx mlrpc_decode xmlrpcval $xmlrpc_val Alias for php_xmlrpc_decode.
+
+[[xmlrpcencode]]
+
+==== xmlrpc_encode
+
+xmlrpcval xmlrpc_encode mixed $phpvalAlias for php_xmlrpc_encode.
+
+[[debugging]]
+
+=== Debugging aids
+
+==== xmlrpc_debugmsg
+
+void xmlrpc_debugmsgstring$debugstringSends the contents of $debugstring in XML
+ comments in the server return payload. If a PHP client has debugging
+ turned on, the user will be able to see server debug
+ information.
+
+Use this function in your methods so you can pass back
+ diagnostic information. It is only available from
+ __xmlrpcs.inc__.
+
+
+[[reserved]]
+
+== Reserved methods
+
+In order to extend the functionality offered by XML-RPC servers
+ without impacting on the protocol, reserved methods are supported in this
+ release.
+
+All methods starting with system. are
+ considered reserved by the server. PHP for XML-RPC itself provides four
+ special methods, detailed in this chapter.
+
+Note that all server objects will automatically respond to clients
+ querying these methods, unless the property
+ allow_system_funcs has been set to
+ false before calling the
+ service() method. This might pose a security risk
+ if the server is exposed to public access, e.g. on the internet.
+
+
+=== system.getCapabilities
+
+
+=== system.listMethods
+
+This method may be used to enumerate the methods implemented by
+ the XML-RPC server.
+
+The system.listMethods method requires no
+ parameters. It returns an array of strings, each of which is the name of
+ a method implemented by the server.
+
+[[sysmethodsig]]
+
+=== system.methodSignature
+
+This method takes one parameter, the name of a method implemented
+ by the XML-RPC server.
+
+It returns an array of possible signatures for this method. A
+ signature is an array of types. The first of these types is the return
+ type of the method, the rest are parameters.
+
+Multiple signatures (i.e. overloading) are permitted: this is the
+ reason that an array of signatures are returned by this method.
+
+Signatures themselves are restricted to the top level parameters
+ expected by a method. For instance if a method expects one array of
+ structs as a parameter, and it returns a string, its signature is simply
+ "string, array". If it expects three integers, its signature is "string,
+ int, int, int".
+
+For parameters that can be of more than one type, the "undefined"
+ string is supported.
+
+If no signature is defined for the method, a not-array value is
+ returned. Therefore this is the way to test for a non-signature, if
+ $resp below is the response object from a method
+ call to system.methodSignature:
+
+[source, php]
+----
+
+$v = $resp->value();
+if ($v->kindOf() != "array") {
+ // then the method did not have a signature defined
+}
+
+----
+
+See the __introspect.php__ demo included in this
+ distribution for an example of using this method.
+
+[[sysmethhelp]]
+
+=== system.methodHelp
+
+This method takes one parameter, the name of a method implemented
+ by the XML-RPC server.
+
+It returns a documentation string describing the use of that
+ method. If no such string is available, an empty string is
+ returned.
+
+The documentation string may contain HTML markup.
+
+=== system.multicall
+
+This method takes one parameter, an array of 'request' struct
+ types. Each request struct must contain a
+ methodName member of type string and a
+ params member of type array, and corresponds to
+ the invocation of the corresponding method.
+
+It returns a response of type array, with each value of the array
+ being either an error struct (containing the faultCode and faultString
+ members) or the successful response value of the corresponding single
+ method call.
+
+
+[[examples]]
+
+== Examples
+
+The best examples are to be found in the sample files included with
+ the distribution. Some are included here.
+
+[[statename]]
+
+=== XML-RPC client: state name query
+
+Code to get the corresponding state name from a number (1-50) from
+ the demo server available on SourceForge
+
+[source, php]
+----
+
+ $m = new xmlrpcmsg('examples.getStateName',
+ array(new xmlrpcval($HTTP_POST_VARS["stateno"], "int")));
+ $c = new xmlrpc_client("/server.php", "phpxmlrpc.sourceforge.net", 80);
+ $r = $c->send($m);
+ if (!$r->faultCode()) {
+ $v = $r->value();
+ print "State number " . htmlentities($HTTP_POST_VARS["stateno"]) . " is " .
+ htmlentities($v->scalarval()) . "<BR>";
+ print "<HR>I got this value back<BR><PRE>" .
+ htmlentities($r->serialize()) . "</PRE><HR>\n";
+ } else {
+ print "Fault <BR>";
+ print "Code: " . htmlentities($r->faultCode()) . "<BR>" .
+ "Reason: '" . htmlentities($r->faultString()) . "'<BR>";
+ }
+
+----
+
+=== Executing a multicall call
+
+To be documented...
+
+
+[[faq]]
+
+[qanda]
+== Frequently Asked Questions
+
+==== How to send custom XML as payload of a method call::
+
+Unfortunately, at the time the XML-RPC spec was designed, support
+ for namespaces in XML was not as ubiquitous as it is now. As a
+ consequence, no support was provided in the protocol for embedding XML
+ elements from other namespaces into an xmlrpc request.
+
+To send an XML "chunk" as payload of a method call or response,
+ two options are available: either send the complete XML block as a
+ string xmlrpc value, or as a base64 value. Since the '<' character in
+ string values is encoded as '<' in the xml payload of the method
+ call, the XML string will not break the surrounding xmlrpc, unless
+ characters outside of the assumed character set are used. The second
+ method has the added benefits of working independently of the charset
+ encoding used for the xml to be transmitted, and preserving exactly
+ whitespace, whilst incurring in some extra message length and cpu load
+ (for carrying out the base64 encoding/decoding).
+
+
+==== Is there any limitation on the size of the requests / responses that can be successfully sent?::
+
+Yes. But I have no hard figure to give; it most likely will depend
+ on the version of PHP in usage and its configuration.
+
+Keep in mind that this library is not optimized for speed nor for
+ memory usage. Better alternatives exist when there are strict
+ requirements on throughput or resource usage, such as the php native
+ xmlrpc extension (see the PHP manual for more information).
+
+Keep in mind also that HTTP is probably not the best choice in
+ such a situation, and XML is a deadly enemy. CSV formatted data over
+ socket would be much more efficient.
+
+If you really need to move a massive amount of data around, and
+ you are crazy enough to do it using phpxmlrpc, your best bet is to
+ bypass usage of the xmlrpcval objects, at least in the decoding phase,
+ and have the server (or client) object return to the calling function
+ directly php values (see xmlrpc_client::return_type
+ and xmlrpc_server::functions_parameters_type for more
+ details).
+
+
+==== My server (client) returns an error whenever the client (server) returns accented characters
+
+To be documented...
+
+
+==== How to enable long-lasting method calls
+
+To be documented...
+
+
+==== My client returns "XML-RPC Fault #2: Invalid return payload: enable debugging to examine incoming payload": what should I do?
+
+The response you are seeing is a default error response that the
+ client object returns to the php application when the server did not
+ respond to the call with a valid xmlrpc response.
+
+The most likely cause is that you are not using the correct URL
+ when creating the client object, or you do not have appropriate access
+ rights to the web page you are requesting, or some other common http
+ misconfiguration.
+
+To find out what the server is really returning to your client,
+ you have to enable the debug mode of the client, using
+ $client->setdebug(1);
+
+
+==== How can I save to a file the xml of the xmlrpc responses received from servers?
+
+If what you need is to save the responses received from the server
+ as xml, you have two options:
+
+1- use the serialize() method on the response object.
+
+
+[source, php]
+----
+
+$resp = $client->send($msg);
+if (!$resp->faultCode())
+ $data_to_be_saved = $resp->serialize();
+
+----
+
+Note that this will not be 100% accurate, since the xml generated
+ by the response object can be different from the xml received,
+ especially if there is some character set conversion involved, or such
+ (eg. if you receive an empty string tag as <string/>, serialize()
+ will output <string></string>), or if the server sent back
+ as response something invalid (in which case the xml generated client
+ side using serialize() will correspond to the error response generated
+ internally by the lib).
+
+2 - set the client object to return the raw xml received instead
+ of the decoded objects:
+
+
+[source, php]
+----
+
+$client = new xmlrpc_client($url);
+$client->return_type = 'xml';
+$resp = $client->send($msg);
+if (!$resp->faultCode())
+ $data_to_be_saved = $resp->value();
+
+----
+
+Note that using this method the xml response response will not be
+ parsed at all by the library, only the http communication protocol will
+ be checked. This means that xmlrpc responses sent by the server that
+ would have generated an error response on the client (eg. malformed xml,
+ responses that have faultcode set, etc...) now will not be flagged as
+ invalid, and you might end up saving not valid xml but random
+ junk...
+
+
+==== Can I use the ms windows character set?
+
+If the data your application is using comes from a Microsoft
+ application, there are some chances that the character set used to
+ encode it is CP1252 (the same might apply to data received from an
+ external xmlrpc server/client, but it is quite rare to find xmlrpc
+ toolkits that encode to CP1252 instead of UTF8). It is a character set
+ which is "almost" compatible with ISO 8859-1, but for a few extra
+ characters.
+
+PHP-XMLRPC only supports the ISO 8859-1 and UTF8 character sets.
+ The net result of this situation is that those extra characters will not
+ be properly encoded, and will be received at the other end of the
+ XML-RPC transmission as "garbled data". Unfortunately the library cannot
+ provide real support for CP1252 because of limitations in the PHP 4 xml
+ parser. Luckily, we tried our best to support this character set anyway,
+ and, since version 2.2.1, there is some form of support, left commented
+ in the code.
+
+To properly encode outgoing data that is natively in CP1252, you
+ will have to uncomment all relative code in the file
+ __xmlrpc.inc__ (you can search for the string "1252"),
+ then set ++$$$GLOBALS['xmlrpc_internalencoding']='CP1252';$$++
+ Please note that all incoming data will then be fed to your application
+ as UTF-8 to avoid any potential data loss.
+
+
+==== Does the library support using cookies / http sessions?
+
+In short: yes, but a little coding is needed to make it
+ happen.
+
+The code below uses sessions to e.g. let the client store a value
+ on the server and retrieve it later.
+
+[source, php]
+----
+
+$resp = $client->send(new xmlrpcmsg('registervalue', array(new xmlrpcval('foo'), new xmlrpcval('bar'))));
+if (!$resp->faultCode())
+{
+ $cookies = $resp->cookies();
+ if (array_key_exists('PHPSESSID', $cookies)) // nb: make sure to use the correct session cookie name
+ {
+ $session_id = $cookies['PHPSESSID']['value'];
+
+ // do some other stuff here...
+
+ $client->setcookie('PHPSESSID', $session_id);
+ $val = $client->send(new xmlrpcmsg('getvalue', array(new xmlrpcval('foo')));
+ }
+}
+
+----
+
+Server-side sessions are handled normally like in any other
+ php application. Please see the php manual for more information about
+ sessions.
+
+NB: unlike web browsers, not all xmlrpc clients support usage of
+ http cookies. If you have troubles with sessions and control only the
+ server side of the communication, please check with the makers of the
+ xmlrpc client in use.
+
+
+[[integration]]
+
+[appendix]
+== Integration with the PHP xmlrpc extension
+
+To be documented more...
+
+In short: for the fastest execution possible, you can enable the php
+ native xmlrpc extension, and use it in conjunction with phpxmlrpc. The
+ following code snippet gives an example of such integration
+
+
+[source, php]
+----
+
+/*** client side ***/
+$c = new xmlrpc_client('http://phpxmlrpc.sourceforge.net/server.php');
+
+// tell the client to return raw xml as response value
+$c->return_type = 'xml';
+
+// let the native xmlrpc extension take care of encoding request parameters
+$r = $c->send(xmlrpc_encode_request('examples.getStateName', $_POST['stateno']));
+
+if ($r->faultCode())
+ // HTTP transport error
+ echo 'Got error '.$r->faultCode();
+else
+{
+ // HTTP request OK, but XML returned from server not parsed yet
+ $v = xmlrpc_decode($r->value());
+ // check if we got a valid xmlrpc response from server
+ if ($v === NULL)
+ echo 'Got invalid response';
+ else
+ // check if server sent a fault response
+ if (xmlrpc_is_fault($v))
+ echo 'Got xmlrpc fault '.$v['faultCode'];
+ else
+ echo'Got response: '.htmlentities($v);
+}
+
+----
+
+
+[[substitution]]
+
+[appendix]
+== Substitution of the PHP xmlrpc extension
+
+Yet another interesting situation is when you are using a ready-made
+ php application, that provides support for the XMLRPC protocol via the
+ native php xmlrpc extension, but the extension is not available on your
+ php install (e.g. because of shared hosting constraints).
+
+Since version 2.1, the PHP-XMLRPC library provides a compatibility
+ layer that aims to be 100% compliant with the xmlrpc extension API. This
+ means that any code written to run on the extension should obtain the
+ exact same results, albeit using more resources and a longer processing
+ time, using the PHP-XMLRPC library and the extension compatibility module.
+ The module is part of the EXTRAS package, available as a separate download
+ from the sourceforge.net website, since version 0.2
+
+
+[[enough]]
+
+[appendix]
+== 'Enough of xmlrpcvals!': new style library usage
+
+To be documented...
+
+In the meantime, see docs about xmlrpc_client::return_type and
+ xmlrpc_server::functions_parameters_types, as well as php_xmlrpc_encode,
+ php_xmlrpc_decode and php_xmlrpc_decode_xml
+
+
+[[debugger]]
+
+[appendix]
+== Usage of the debugger
+
+A webservice debugger is included in the library to help during
+ development and testing.
+
+The interface should be self-explicative enough to need little
+ documentation.
+
+image::debugger.gif[,,,,align="center"]
+
+The most useful feature of the debugger is without doubt the "Show
+ debug info" option. It allows to have a screen dump of the complete http
+ communication between client and server, including the http headers as
+ well as the request and response payloads, and is invaluable when
+ troubleshooting problems with charset encoding, authentication or http
+ compression.
+
+The debugger can take advantage of the JSONRPC library extension, to
+ allow debugging of JSON-RPC webservices, and of the JS-XMLRPC library
+ visual editor to allow easy mouse-driven construction of the payload for
+ remote methods. Both components have to be downloaded separately from the
+ sourceforge.net web pages and copied to the debugger directory to enable
+ the extra functionality:
+
+
+* to enable jsonrpc functionality, download the PHP-XMLRPC
+ EXTRAS package, and copy the file __jsonrpc.inc__
+ either to the same directory as the debugger or somewhere in your
+ php include path
+
+
+* to enable the visual value editing dialog, download the
+ JS-XMLRPC library, and copy somewhere in the web root files
+ __visualeditor.php__,
+ __visualeditor.css__ and the folders
+ __yui__ and __img__. Then edit the
+ debugger file __controller.php__ and set
+ appropriately the variable $editorpath.
+
+
+[[news]]
+
+[appendix]
+
+== Whats's new
+
+CAUTION: not all items the following list have (yet) been fully documented, and some might not be present in any other
+ chapter in the manual. To find a more detailed description of new functions and methods please take a look at the
+ source code of the library, which is quite thoroughly commented in phpdoc form.
+
+=== 4.0.0
+
+* new: introduction of namespaces and full OOP.
++
+All php classes have been renamed and moved to separate files.
++
+Class autoloading can now be done in accord with the PSR-4 standard.
++
+All global variables and global functions have been removed.
++
+Iterating over xmlrpc value objects is now easier thank to support for ArrayAccess and Traversable interfaces.
++
+Backward compatibility is maintained via _lib/xmlrpc.inc_, _lib/xmlrpcs.inc_ and _lib/xmlrpc_wrappers.inc_.
+ For more details, head on to doc/api_changes_v4.md
+
+* changed: the default character encoding delivered from the library to your code is now utf8.
+ It can be changed at any time setting a value to `PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding`
+
+* improved: the library now accepts requests/responses sent using other character sets than UTF-8/ISO-8859-1/ASCII.
+ This only works when the mbstring php extension is enabled.
+
+* improved: no need to call anymore `$client->setSSLVerifyHost(2)` to silence a curl warning when using https
+ with recent curl builds
+
+* improved: the xmlrpcval class now supports the interfaces `Countable` and `IteratorAggregate`
+
+* improved: a specific option allows users to decide the version of SSL to use for https calls.
+ This is useful f.e. for the testing suite, when the server target of calls has no proper ssl certificate,
+ and the cURL extension has been compiled with GnuTLS (such as on Travis VMs)
+
+* improved: the function `wrap_php_function()` now can be used to wrap closures (it is now a method btw)
+
+* improved: all _wrap_something()_ functions now return a closure by default instead of a function name
+
+* improved: debug messages are not html-escaped any more when executing from the command line
+
+* improved: the library is now tested using Travis ( https://travis-ci.org/ ).
+ Tests are executed using all php versions from 5.3 to 7.0 nightly, plus HHVM; code-coverage information
+ is generated using php 5.6 and uploaded to both Code Coverage and Scrutinizer online services
+
+* improved: phpunit is now installed via composer, not bundled anymore
+
+* improved: when phpunit is used to generate code-coverage data, the code executed server-side is accounted for
+
+* improved: the test suite has basic checks for the debugger and demo files
+
+* improved: more tests in the test suite
+
+* fixed: the server would not reset the user-set debug messages between subsequent `service()` calls
+
+* fixed: the server would not reset previous php error handlers when an exception was thrown by user code and
+ exception_handling set to 2
+
+* fixed: the server would fail to decode a request with ISO-8859-1 payload and character set declaration in the xml
+ prolog only
+
+* fixed: the client would fail to decode a response with ISO-8859-1 payload and character set declaration in the xml
+ prolog only
+
+* fixed: the function `decode_xml()` would not decode an xml with character set declaration in the xml prolog
+
+* fixed: the client can now successfully call methods using ISO-8859-1 or UTF-8 characters in their name
+
+* fixed: the debugger would fail sending a request with ISO-8859-1 payload (it missed the character set declaration).
+ It would have a hard time coping with ISO-8859-1 in other fields, such as e.g. the remote method name
+
+* fixed: the debugger would generate a bad payload via the 'load method synopsis' button for signatures containing NULL
+ or undefined parameters
+
+* fixed: the debugger would generate a bad payload via the 'load method synopsis' button for methods with multiple
+ signatures
+
+* improved: the debugger is displayed using UTF-8, making it more useful to debug any kind of service
+
+* improved: echo all debug messages even when there are characters in them which php deems to be in a wrong encoding;
+ previously those messages would just disappear (this is visible e.g. in the debugger)
+
+* changed: debug info handling
+ - at debug level 1, the rebuilt php objects are not dumped to screen (server-side already did that)
+ - at debug level 1, curl communication info are not dumped to screen
+ - at debug level 1, the tests echo payloads of failures; at debug level 2 all payloads
+
+* improved: makefiles have been replaced with a php_based pakefile
+
+* improved: the source for the manual is stored in asciidoc format, which can be displayed natively by GitHub
+ with nice html formatting. Also the HTML version generated by hand and bundled in tarballs is much nicer
+ to look at than previous versions
+
+* improved: all php code is now formatted according to the PSR-2 standard
+
+=== 3.0.0
+
+__Note:__ this is the last release of the library that will support PHP 5.1 and up. Future releases will target php 5.3
+ as minimum supported version.
+
+* when using curl and keepalive, reset curl handle if we did not get back an http 200 response (eg a 302)
+
+* omit port on http 'Host' header if it is 80
+
+* test suite allows interrogating https servers ignoring their certs
+
+* method `setAcceptedCompression` was failing to disable reception of compressed responses if the client supported them
+
+=== 3.0.0 beta
+
+This is the first release of the library to only support PHP 5. Some legacy code has been removed, and support for
+ features such as exceptions and dateTime objects introduced.
+
+The "beta" tag is meant to indicate the fact that the refactoring has been more widespread than in precedent releases
+ and that more changes are likely to be introduced with time - the library is still considered to be production
+ quality.
+
+* improved: removed all usage of php functions deprecated in php 5.3, usage of assign-by-ref when creating new objects
+ etc...
+
+* improved: add support for the `<ex:nil>` tag used by the apache library, both in input and output
+
+* improved: add support for dateTime objects in both in php_xmlrpc_encode and as parameter for constructor of xmlrpcval
+
+* improved: add support for timestamps as parameter for constructor of xmlrpcval
+
+* improved: add option `dates_as_objects` to `php_xmlrpc_decode` to return dateTime objects for xmlrpc datetimes
+
+* improved: add new method `SetCurlOptions` to xmrlpc_client to allow extra flexibility in tweaking http config, such as
+ explicitly binding to an ip address
+
+* improved: add new method `SetUserAgent` to xmrlpc_client to to allow having different user-agent http headers
+
+* improved: add a new member variable in server class to allow fine-tuning of the encoding of returned values when the
+ server is in 'phpvals' mode
+
+* improved: allow servers in 'xmlrpcvals' mode to also register plain php functions by defining them in the dispatch map
+ with an added option
+
+* improved: catch exceptions thrown during execution of php functions exposed as methods by the server
+
+* fixed: bad encoding if same object is encoded twice using `php_xmlrpc_encode`
+
+=== 2.2.2
+
+__Note:__ this is the last release of the library that will support PHP 4. Future releases (if any) should target
+ php 5.0 as minimum supported version.
+
+* fixed: encoding of utf-8 characters outside of the BMP plane
+
+* fixed: character set declarations surrounded by double quotes were not recognized in http headers
+
+* fixed: be more tolerant in detection of charset in http headers
+
+* fixed: fix detection of zlib.output_compression
+
+* fixed: use `feof()` to test if socket connections are to be closed instead of the number of bytes read (rare bug when
+ communicating with some servers)
+
+* fixed: format floating point values using the correct decimal separator even when php locale is set to one that uses
+ comma
+
+* fixed: improve robustness of the debugger when parsing weird results from non-compliant servers
+
+* php warning when receiving `false` in a bool value
+
+* improved: allow the add_to_map server method to add docs for single params too
+
+* improved: added the possibility to wrap for exposure as xmlrpc methods plain php class methods, object methods and even
+ whole classes
+
+=== 2.2.1
+
+* fixed: work aroung bug in php 5.2.2 which broke support of `HTTP_RAW_POST_DATA`
+
+* fixed: is_dir parameter of `setCaCertificate()` method is reversed
+
+* fixed: a php warning in xmlrpc_client creator method
+
+* fixed: parsing of `1e+1` as valid float
+
+* fixed: allow errorlevel 3 to work when prev. error handler was a static method
+
+* fixed: usage of `client::setcookie()` for multiple cookies in non-ssl mode
+
+* improved: support for CP1252 charset is not part or the library but almost possible
+
+* improved: more info when curl is enabled and debug mode is on
+
+=== 2.2
+
+* fixed: debugger errors on php installs with `magic_quotes_gpc` on
+
+* fixed: support for https connections via proxy
+
+* fixed: `wrap_xmlrpc_method()` generated code failed to properly encode php objects
+
+* improved: slightly faster encoding of data which is internally UTF-8
+
+* improved: debugger always generates a `null` id for jsonrpc if user omits it
+
+* new: debugger can take advantage of a graphical value builder (it has to be downloaded separately, as part of jsxmlrpc
+ package. See Appendix D for more details)
+
+* new: support for the `<NIL/>` xmlrpc extension. see below for more details
+
+* new: server support for the `system.getCapabilities` xmlrpc extension
+
+* new: `wrap_xmlrpc_method`, `wrap_xmlrpc_method()` accepts two new options: debug and return_on_fault
+
+=== 2.1
+
+* The wrap_php_function and wrap_xmlrpc_method functions have been moved out of the base library file _xmlrpc.inc_
+ into a file of their own: _xmlrpc_wrappers.php_. You will have to include() / require() it in your scripts if
+ you have been using those functions.
+ For increased security, the automatic rebuilding of php object instances out ofreceived xmlrpc structs in
+ `wrap_xmlrpc_method()` has been disabled (but it can be optionally re-enabled).
+ Both `wrap_php_function()` and `wrap_xmlrpc_method()` functions accept many more options to fine tune their behaviour,
+ including one to return the php code to be saved and later used as standalone php script
+
+* The constructor of xmlrpcval() values has seen some internal changes, and it will not throw a php warning anymore when
+ invoked using an unknown xmlrpc type: the error will only be written to php error log. Also
+ `new xmlrpcval('true', 'boolean')` is not supported anymore
+
+* The new function `php_xmlrpc_decode_xml()` will take the xml representation of either an xmlrpc request, response or
+ single value and return the corresponding php-xmlrpc object instance
+
+* A new function `wrap_xmlrpc_server()` has been added, to wrap all (or some) of the methods exposed by a remote xmlrpc
+ server into a php class
+
+* A new file has been added: _verify_compat.php_, to help users diagnose the level of compliance of their php
+ installation with the library
+
+* Restored compatibility with php 4.0.5 (for those poor souls still stuck on it)
+
+* Method `xmlrpc_server->service()` now returns a value: either the response payload or xmlrpcresp object instance
+
+* Method `xmlrpc_server->add_to_map()` now accepts xmlrpc methods with no param definitions
+
+* Documentation for single parameters of exposed methods can be added to the dispatch map (and turned into html docs in
+ conjunction with a future release of the 'extras' package)
+
+* Full response payload is saved into xmlrpcresp object for further debugging
+
+* The debugger can now generate code that wraps a remote method into a php function (works for jsonrpc, too); it also
+ has better support for being activated via a single GET call (e.g. for integration into other tools)
+
+* Stricter parsing of incoming xmlrpc messages: two more invalid cases are now detected (double `data` element inside
+ `array` and `struct`/`array` after scalar inside `value` element)
+
+* More logging of errors in a lot of situations
+
+* Javadoc documentation of lib files (almost) complete
+
+* Many performance tweaks and code cleanups, plus the usual crop of bugs fixed (see NEWS file for complete list of bugs)
+
+* Lib internals have been modified to provide better support for grafting extra functionality on top of it. Stay tuned
+ for future releases of the EXTRAS package (or go read Appendix B)...
+
+=== 2.0 final
+
+* Added to the client class the possibility to use Digest and NTLM authentication methods (when using the CURL library)
+ for connecting to servers and NTLM for connecting to proxies
+
+* Added to the client class the possibility to specify alternate certificate files/directories for authenticating the
+ peer with when using HTTPS communication
+
+* Reviewed all examples and added a new demo file, containing a proxy to forward xmlrpc requests to other servers
+ (useful e.g. for ajax coding)
+
+* The debugger has been upgraded to reflect the new client capabilities
+
+* All known bugs have been squashed, and the lib is more tolerant than ever of commonly-found mistakes
+
+=== 2.0 Release candidate 3
+
+* Added to server class the property functions_parameters_type, that allows the server to register plain php functions
+ as xmlrpc methods (i.e. functions that do not take an xmlrpcmsg object as unique param)
+
+* let server and client objects serialize calls using a specified character set encoding for the produced xml instead of
+ US-ASCII (ISO-8859-1 and UTF-8 supported)
+
+* let `php_xmlrpc_decode` accept xmlrpcmsg objects as valid input
+
+* 'class::method' syntax is now accepted in the server dispatch map
+
+* `xmlrpc_clent::SetDebug()` accepts integer values instead of a boolean value, with debugging level 2 adding to the
+ information printed to screen the complete client request
+
+=== 2.0 Release candidate 2
+
+* Added a new property of the client object: `xmlrpc_client->return_type`, indicating whether calls to the
+ send() method will return xmlrpcresp objects whose value() is an xmlrpcval object, a php value (automatically
+ decoded) or the raw xml received from the server.
+
+* Added in the extras dir. two new library files: _jsonrpc.inc_ and _jsonrpcs.inc_ containing new classes that
+ implement support for the json-rpc protocol (alpha quality code)
+
+* Added a new client method: `setKey($key, $keypass)` to be used in HTTPS connections
+
+* Added a new file containing some benchmarks in the testsuite directory
+
+=== 2.0 Release candidate 1
+
+* Support for HTTP proxies (new method: `xmlrpc_client::setProxy()`)
+
+* Support HTTP compression of both requests and responses.
+ Clients can specify what kind of compression they accept for responses between deflate/gzip/any, and whether to
+ compress the requests.
+ Servers by default compress responses to clients that explicitly declare support for compression (new methods:
+ `xmlrpc_client::setAcceptedCompression()`, `xmlrpc_client::setRequestCompression()`).
+ Note that the ZLIB php extension needs to be enabled in PHP to support compression.
+
+* Implement HTTP 1.1 connections, but only if CURL is enabled (added an extra parameter to
+ `xmlrpc_client::xmlrpc_client` to set the desired HTTP protocol at creation time and a new supported value for
+ the last parameter of `xmlrpc_client::send`, which now can be safely omitted if it has been specified at
+ creation time).
++
+With PHP versions greater than 4.3.8 keep-alives are enabled by default for HTTP 1.1 connections. This should yield
+ faster execution times when making multiple calls in sequence to the same xml-rpc server from a single client.
+
+* Introduce support for cookies.
+ Cookies to be sent to the server with a request can be set using `xmlrpc_client::setCookie()`, while cookies
+ received from the server are found in ++xmlrpcresp::cookies()++. It is left to the user to check for validity of
+ received cookies and decide whether they apply to successive calls or not.
+
+* Better support for detecting different character set encodings of xml-rpc requests and responses: both client and
+ server objects will correctly detect the charset encoding of received xml, and use an appropriate xml parser.
++
+Supported encodings are US-ASCII, UTF-8 and ISO-8859-1.
+
+* Added one new xmlrpcmsg constructor syntax, allowing usage of a single string with the complete URL of the target
+ server
+
+* Convert xml-rpc boolean values into native php values instead of 0 and 1
+
+* Force the `php_xmlrpc_encode` function to properly encode numerically indexed php arrays into xml-rpc arrays
+ (numerically indexed php arrays always start with a key of 0 and increment keys by values of 1)
+
+* Prevent the `php_xmlrpc_encode` function from further re-encoding any objects of class ++xmlrpcval++ that
+ are passed to it. This allows to call the function with arguments consisting of mixed php values / xmlrpcval objects
+
+* Allow a server to NOT respond to system.* method calls (setting the `$server->allow_system_funcs` property).
+
+* Implement a new xmlrpcval method to determine if a value of type struct has a member of a given name without having to
+ loop trough all members: `xmlrpcval::structMemExists()`
+
+* Expand methods `xmlrpcval::addArray`, `addScalar` and `addStruct` allowing extra php values to be added to
+ xmlrpcval objects already formed.
+
+* Let the `xmlrpc_client::send` method accept an XML string for sending instead of an xmlrpcmsg object, to
+ facilitate debugging and integration with the php native xmlrpc extension
+
+* Extend the `php_xmlrpc_encode` and `php_xmlrpc_decode` functions to allow serialization and rebuilding of
+ PHP objects. To successfully rebuild a serialized object, the object class must be defined in the deserializing end
+ of the transfer. Note that object members of type resource will be deserialized as NULL values.
++
+Note that his has been implemented adding a "php_class" attribute to xml representation of xmlrpcval of STRUCT type,
+ which, strictly speaking, breaks the xml-rpc spec. Other xmlrpc implementations are supposed to ignore such an
+ attribute (unless they implement a brain-dead custom xml parser...), so it should be safe enabling it in
+ heterogeneous environments. The activation of this feature is done by usage of an option passed as second parameter
+ to both `php_xmlrpc_encode` and `php_xmlrpc_decode`.
+
+* Extend the `php_xmlrpc_encode` function to allow automatic serialization of iso8601-conforming php strings as
+ datetime.iso8601 xmlrpcvals, by usage of an optional parameter
+
+* Added an automatic stub code generator for converting xmlrpc methods to php functions and vice-versa.
++
+This is done via two new functions: `wrap_php_function` and `wrap_xmlrpc_method`, and has many caveats,
+ with php being a typeless language and all...
+
+* Allow object methods to be used in server dispatch map
+
+* Added a complete debugger solution, in the __debugger__ folder
+
+* Added configurable server-side debug messages, controlled by the new method `xmlrpc_server::SetDebug()`.
+ At level 0, no debug messages are sent to the client; level 1 is the same as the old behaviour; at level 2 a lot
+ more info is echoed back to the client, regarding the received call; at level 3 all warnings raised during server
+ processing are trapped (this prevents breaking the xml to be echoed back to the client) and added to the debug info
+ sent back to the client
+
+* New XML parsing code, yields smaller memory footprint and faster execution times, not to mention complete elimination
+ of the dreaded __eval()__ construct, so prone to code injection exploits
+
+* Rewritten most of the error messages, making text more explicative
+
+++++++++++++++++++++++++++++++++++++++
+<!-- Keep this comment at the end of the file
+Local variables:
+mode: sgml
+sgml-omittag:nil
+sgml-shorttag:t
+sgml-minimize-attributes:nil
+sgml-always-quote-attributes:t
+sgml-indent-step:2
+sgml-indent-data:t
+sgml-parent-document:nil
+sgml-exposed-tags:nil
+sgml-local-catalogs:nil
+sgml-local-ecat-files:nil
+sgml-namecase-general:t
+sgml-general-insert-case:lower
+End:
+-->
+++++++++++++++++++++++++++++++++++++++
--- /dev/null
+-----BEGIN RSA PRIVATE KEY-----\r
+MIIBOgIBAAJBAM12w6/J20HMj0V9VC24xPFQG9RKSDt8vmviM+tnc1BgCrzPyF1v\r
+3/rWGoWDjkJrE9WFOeqIjJHeEWWT4uKq2ZkCAwEAAQJAZZYJ7Nld+et9DvuHak/H\r
+uBRGnjDYA+mKcObXitWMUzk2ZodL8UoCP1J9kKqV8Zp/l2cBZkLo0aWTN94sWkHy\r
+rQIhAOhxWxRXSZ4kArIQqZnDG9JgtOAeaaFso/zpxIHpN6OrAiEA4klzl+rUc32/\r
+7SDcJYa9j5vehp1jCTnkN+n0rujTM8sCIAGwMRUovSQk5tAcRt8TB7SzdxzZm7LM\r
+czR3DjJTW1AZAiEAlYN+svPgJ+cAdwdtLgZXHZoZb8xx8Vik6CTXHPKNCf0CIBQL\r
+zF4Qp8/C+gjsXtEZJvhxY7i1luHn6iNwNnE932r3\r
+-----END RSA PRIVATE KEY-----\r
--- /dev/null
+#!/usr/local/bin/perl\r
+\r
+use Frontier::Client;\r
+\r
+my $serverURL='http://phpxmlrpc.sourceforge.net/server.php';\r
+\r
+# try the simplest example\r
+\r
+my $client = Frontier::Client->new( 'url' => $serverURL,\r
+ 'debug' => 0, 'encoding' => 'iso-8859-1' );\r
+my $resp = $client->call("examples.getStateName", 32);\r
+\r
+print "Got '${resp}'\n";\r
+\r
+# now send a mail to nobody in particular\r
+\r
+$resp = $client->call("mail.send", ("edd", "Test", \r
+ "Bonjour. Je m'appelle Gérard. Mañana. ", "freddy", "", "", \r
+ 'text/plain; charset="iso-8859-1"'));\r
+\r
+if ($resp->value()) {\r
+ print "Mail sent OK.\n";\r
+} else {\r
+ print "Error sending mail.\n";\r
+}\r
+\r
+# test echoing of characters works fine\r
+\r
+$resp = $client->call("examples.echo", 'Three "blind" mice - ' . \r
+ "See 'how' they run");\r
+print $resp . "\n";\r
+\r
+# test name and age example. this exercises structs and arrays \r
+\r
+$resp = $client->call("examples.sortByAge", \r
+ [ { 'name' => 'Dave', 'age' => 35},\r
+ { 'name' => 'Edd', 'age' => 45 },\r
+ { 'name' => 'Fred', 'age' => 23 },\r
+ { 'name' => 'Barney', 'age' => 36 } ] );\r
+\r
+my $e;\r
+foreach $e (@$resp) {\r
+ print $$e{'name'} . ", " . $$e{'age'} . "\n";\r
+}\r
+\r
+# test base64\r
+\r
+$resp = $client->call("examples.decode64", \r
+ $client->base64("TWFyeSBoYWQgYSBsaXR0bGUgbGFtYiBTaGUgd" .\r
+ "GllZCBpdCB0byBhIHB5bG9u"));\r
+\r
+print $resp . "\n";\r
--- /dev/null
+#!/usr/local/bin/python\r
+\r
+from xmlrpclib import *\r
+import sys\r
+\r
+server = Server("http://phpxmlrpc.sourceforge.net/server.php")\r
+\r
+try:\r
+ print "Got '" + server.examples.getStateName(32) + "'"\r
+\r
+ r = server.mail.send("edd", "Test",\r
+ "Bonjour. Je m'appelle Gérard. Mañana. ", "freddy", "", "", \r
+ 'text/plain; charset="iso-8859-1"')\r
+ if r:\r
+ print "Mail sent OK"\r
+ else:\r
+ print "Error sending mail"\r
+\r
+\r
+ r = server.examples.echo('Three "blind" mice - ' + "See 'how' they run")\r
+ print r\r
+\r
+ # name/age example. this exercises structs and arrays\r
+\r
+ a = [ {'name': 'Dave', 'age': 35}, {'name': 'Edd', 'age': 45 },\r
+ {'name': 'Fred', 'age': 23}, {'name': 'Barney', 'age': 36 }]\r
+ r = server.examples.sortByAge(a)\r
+ print r\r
+\r
+ # test base 64\r
+ b = Binary("Mary had a little lamb She tied it to a pylon")\r
+ b.encode(sys.stdout)\r
+ r = server.examples.decode64(b)\r
+ print r\r
+ \r
+except Error, v:\r
+ print "XML-RPC Error:",v\r
--- /dev/null
+\r<!--\r#fatPage\r#version 1\r#docs http://www.scripting.com/fatPages/faq.html\r#adrPageData workspace.testPhpServer\r#objectType application/x-frontier-tabl\r#runnable false\r#pageData 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\r-->\r
\ No newline at end of file
--- /dev/null
+<?php
+// by Edd Dumbill (C) 1999-2002
+// <edd@usefulinc.com>
+
+// Copyright (c) 1999,2000,2002 Edd Dumbill.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided
+// with the distribution.
+//
+// * Neither the name of the "XML-RPC for PHP" nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/******************************************************************************
+ *
+ * *** DEPRECATED ***
+ *
+ * This file is only used to insure backwards compatibility
+ * with the API of the library <= rev. 3
+ *
+ * If it is included, the library will work without any further autoloading
+ *****************************************************************************/
+
+include_once(__DIR__.'/../src/PhpXmlRpc.php');
+include_once(__DIR__.'/../src/Value.php');
+include_once(__DIR__.'/../src/Request.php');
+include_once(__DIR__.'/../src/Response.php');
+include_once(__DIR__.'/../src/Client.php');
+include_once(__DIR__.'/../src/Encoder.php');
+include_once(__DIR__.'/../src/Helper/Charset.php');
+include_once(__DIR__.'/../src/Helper/Date.php');
+include_once(__DIR__.'/../src/Helper/Http.php');
+include_once(__DIR__.'/../src/Helper/Logger.php');
+include_once(__DIR__.'/../src/Helper/XMLParser.php');
+
+
+/* Expose the global variables which used to be defined */
+PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'ISO-8859-1'; // old default
+PhpXmlRpc\PhpXmlRpc::exportGlobals();
+
+/* some stuff deprecated enough that we do not want to put it in the new lib version */
+
+/// @deprecated
+$GLOBALS['xmlEntities'] = array(
+ 'amp' => '&',
+ 'quot' => '"',
+ 'lt' => '<',
+ 'gt' => '>',
+ 'apos' => "'"
+);
+
+// formulate backslashes for escaping regexp
+// Not in use anymore since 2.0. Shall we remove it?
+/// @deprecated
+$GLOBALS['xmlrpc_backslash'] = chr(92).chr(92);
+
+/* Expose with the old names the classes which have been namespaced */
+
+class xmlrpcval extends PhpXmlRpc\Value
+{
+ /**
+ * @deprecated
+ * @param xmlrpcval $o
+ * @return string
+ */
+ public function serializeval($o)
+ {
+ // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
+ //if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
+ //{
+ $ar = $o->me;
+ reset($ar);
+ list($typ, $val) = each($ar);
+
+ return '<value>' . $this->serializedata($typ, $val) . "</value>\n";
+ //}
+ }
+
+ /**
+ * @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?
+ */
+ public 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;
+ }
+
+ /// reset functionality added by parent class: same as it would happen if no interface was declared
+ public function count()
+ {
+ return 1;
+ }
+
+ /// reset functionality added by parent class: same as it would happen if no interface was declared
+ public function getIterator() {
+ return new ArrayIterator($this);
+ }
+}
+
+class xmlrpcmsg extends PhpXmlRpc\Request
+{
+}
+
+class xmlrpcresp extends PhpXmlRpc\Response
+{
+}
+
+class xmlrpc_client extends PhpXmlRpc\Client
+{
+}
+
+/* Expose as global functions the ones which are now class methods */
+
+/// Wrong speling, but we are adamant on backwards compatibility!
+function xmlrpc_encode_entitites($data, $srcEncoding='', $destEncoding='')
+{
+ return PhpXmlRpc\Helper\Charset::instance()->encodeEntitites($data, $srcEncoding, $destEncoding);
+}
+
+function iso8601_encode($timeT, $utc=0)
+{
+ return PhpXmlRpc\Helper\Date::iso8601Encode($timeT, $utc);
+}
+
+function iso8601_decode($iDate, $utc=0)
+{
+ return PhpXmlRpc\Helper\Date::iso8601Decode($iDate, $utc);
+}
+
+function decode_chunked($buffer)
+{
+ return PhpXmlRpc\Helper\Http::decodeChunked($buffer);
+}
+
+function php_xmlrpc_decode($xmlrpcVal, $options=array())
+{
+ $encoder = new PhpXmlRpc\Encoder();
+ return $encoder->decode($xmlrpcVal, $options);
+}
+
+function php_xmlrpc_encode($phpVal, $options=array())
+{
+ $encoder = new PhpXmlRpc\Encoder();
+ return $encoder->encode($phpVal, $options);
+}
+
+function php_xmlrpc_decode_xml($xmlVal, $options=array())
+{
+ $encoder = new PhpXmlRpc\Encoder();
+ return $encoder->decodeXml($xmlVal, $options);
+}
+
+function guess_encoding($httpHeader='', $xmlChunk='', $encodingPrefs=null)
+{
+ return PhpXmlRpc\Helper\XMLParser::guessEncoding($httpHeader, $xmlChunk, $encodingPrefs);
+}
+
+function has_encoding($xmlChunk)
+{
+ return PhpXmlRpc\Helper\XMLParser::hasEncoding($xmlChunk);
+}
+
+function is_valid_charset($encoding, $validList)
+{
+ return PhpXmlRpc\Helper\Charset::instance()->isValidCharset($encoding, $validList);
+}
--- /dev/null
+<?php
+
+/******************************************************************************
+ *
+ * *** DEPRECATED ***
+ *
+ * This file is only used to insure backwards compatibility
+ * with the API of the library <= rev. 3
+ *****************************************************************************/
+
+include_once(__DIR__.'/../src/Wrapper.php');
+
+/* Expose as global functions the ones which are now class methods */
+
+/**
+ * @see PhpXmlRpc\Wrapper::php_2_xmlrpc_type
+ * @param string $phpType
+ * @return string
+ */
+function php_2_xmlrpc_type($phpType)
+{
+ $wrapper = new PhpXmlRpc\Wrapper();
+ return $wrapper->php2XmlrpcType($phpType);
+}
+
+/**
+ * @see PhpXmlRpc\Wrapper::xmlrpc_2_php_type
+ * @param string $xmlrpcType
+ * @return string
+ */
+function xmlrpc_2_php_type($xmlrpcType)
+{
+ $wrapper = new PhpXmlRpc\Wrapper();
+ return $wrapper->xmlrpc2PhpType($xmlrpcType);
+}
+
+/**
+ * @see PhpXmlRpc\Wrapper::wrap_php_function
+ * @param callable $funcName
+ * @param string $newFuncName
+ * @param array $extraOptions
+ * @return array|false
+ */
+function wrap_php_function($funcName, $newFuncName='', $extraOptions=array())
+{
+ $wrapper = new PhpXmlRpc\Wrapper();
+ if (!isset($extraOptions['return_source']) || $extraOptions['return_source'] == false) {
+ // backwards compat: return string instead of callable
+ $extraOptions['return_source'] = true;
+ $wrapped = $wrapper->wrapPhpFunction($funcName, $newFuncName, $extraOptions);
+ eval($wrapped['source']);
+ } else {
+ $wrapped = $wrapper->wrapPhpFunction($funcName, $newFuncName, $extraOptions);
+ }
+ return $wrapped;
+}
+
+/**
+ * NB: this function returns an array in a format which is unsuitable for direct use in the server dispatch map, unlike
+ * PhpXmlRpc\Wrapper::wrapPhpClass. This behaviour might seem like a bug, but has been kept for backwards compatibility.
+ *
+ * @see PhpXmlRpc\Wrapper::wrap_php_class
+ * @param string|object $className
+ * @param array $extraOptions
+ * @return array|false
+ */
+function wrap_php_class($className, $extraOptions=array())
+{
+ $wrapper = new PhpXmlRpc\Wrapper();
+ $fix = false;
+ if (!isset($extraOptions['return_source']) || $extraOptions['return_source'] == false) {
+ // backwards compat: return string instead of callable
+ $extraOptions['return_source'] = true;
+ $fix = true;
+ }
+ $wrapped = $wrapper->wrapPhpClass($className, $extraOptions);
+ foreach($wrapped as $name => $value) {
+ if ($fix) {
+ eval($value['source']);
+ }
+ $wrapped[$name] = $value['function'];
+ }
+ return $wrapped;
+}
+
+/**
+ * @see PhpXmlRpc\Wrapper::wrapXmlrpcMethod
+ * @param xmlrpc_client $client
+ * @param string $methodName
+ * @param int|array $extraOptions the usage of an int as signature number is deprecated, use an option in $extraOptions
+ * @param int $timeout deprecated, use an option in $extraOptions
+ * @param string $protocol deprecated, use an option in $extraOptions
+ * @param string $newFuncName deprecated, use an option in $extraOptions
+ * @return array|callable|false
+ */
+function wrap_xmlrpc_method($client, $methodName, $extraOptions=0, $timeout=0, $protocol='', $newFuncName='')
+{
+ if (!is_array($extraOptions))
+ {
+ $sigNum = $extraOptions;
+ $extraOptions = array(
+ 'signum' => $sigNum,
+ 'timeout' => $timeout,
+ 'protocol' => $protocol,
+ 'new_function_name' => $newFuncName
+ );
+ }
+
+ $wrapper = new PhpXmlRpc\Wrapper();
+
+ if (!isset($extraOptions['return_source']) || $extraOptions['return_source'] == false) {
+ // backwards compat: return string instead of callable
+ $extraOptions['return_source'] = true;
+ $wrapped = $wrapper->wrapXmlrpcMethod($client, $methodName, $extraOptions);
+ eval($wrapped['source']);
+ $wrapped = $wrapped['function'];
+ } else {
+ $wrapped = $wrapper->wrapXmlrpcMethod($client, $methodName, $extraOptions);
+ }
+ return $wrapped;
+}
+
+/**
+ * @see PhpXmlRpc\Wrapper::wrap_xmlrpc_server
+ * @param xmlrpc_client $client
+ * @param array $extraOptions
+ * @return mixed
+ */
+function wrap_xmlrpc_server($client, $extraOptions=array())
+{
+ $wrapper = new PhpXmlRpc\Wrapper();
+ return $wrapper->wrapXmlrpcServer($client, $extraOptions);
+}
+
+/**
+ * Given the necessary info, build php code that creates a new function to invoke a remote xmlrpc method.
+ * Take care that no full checking of input parameters is done to ensure that valid php code is emitted.
+ * Only kept for backwards compatibility
+ * Note: real spaghetti code follows...
+ *
+ * @deprecated
+ */
+function build_remote_method_wrapper_code($client, $methodName, $xmlrpcFuncName,
+ $mSig, $mDesc = '', $timeout = 0, $protocol = '', $clientCopyMode = 0, $prefix = 'xmlrpc',
+ $decodePhpObjects = false, $encodePhpObjects = false, $decodeFault = false,
+ $faultResponse = '', $namespace = '\\PhpXmlRpc\\')
+{
+ $code = "function $xmlrpcFuncName (";
+ if ($clientCopyMode < 2) {
+ // client copy mode 0 or 1 == partial / full client copy in emitted code
+ $innerCode = build_client_wrapper_code($client, $clientCopyMode, $prefix, $namespace);
+ $innerCode .= "\$client->setDebug(\$debug);\n";
+ $this_ = '';
+ } else {
+ // client copy mode 2 == no client copy in emitted code
+ $innerCode = '';
+ $this_ = 'this->';
+ }
+ $innerCode .= "\$req = new {$namespace}Request('$methodName');\n";
+
+ if ($mDesc != '') {
+ // take care that PHP comment is not terminated unwillingly by method description
+ $mDesc = "/**\n* " . str_replace('*/', '* /', $mDesc) . "\n";
+ } else {
+ $mDesc = "/**\nFunction $xmlrpcFuncName\n";
+ }
+
+ // param parsing
+ $innerCode .= "\$encoder = new {$namespace}Encoder();\n";
+ $plist = array();
+ $pCount = count($mSig);
+ for ($i = 1; $i < $pCount; $i++) {
+ $plist[] = "\$p$i";
+ $pType = $mSig[$i];
+ if ($pType == 'i4' || $pType == 'i8' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
+ $pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
+ ) {
+ // only build directly xmlrpc values when type is known and scalar
+ $innerCode .= "\$p$i = new {$namespace}Value(\$p$i, '$pType');\n";
+ } else {
+ if ($encodePhpObjects) {
+ $innerCode .= "\$p$i = \$encoder->encode(\$p$i, array('encode_php_objs'));\n";
+ } else {
+ $innerCode .= "\$p$i = \$encoder->encode(\$p$i);\n";
+ }
+ }
+ $innerCode .= "\$req->addparam(\$p$i);\n";
+ $mDesc .= '* @param ' . xmlrpc_2_php_type($pType) . " \$p$i\n";
+ }
+ if ($clientCopyMode < 2) {
+ $plist[] = '$debug=0';
+ $mDesc .= "* @param int \$debug when 1 (or 2) will enable debugging of the underlying {$prefix} call (defaults to 0)\n";
+ }
+ $plist = implode(', ', $plist);
+ $mDesc .= '* @return ' . xmlrpc_2_php_type($mSig[0]) . " (or an {$namespace}Response obj instance if call fails)\n*/\n";
+
+ $innerCode .= "\$res = \${$this_}client->send(\$req, $timeout, '$protocol');\n";
+ if ($decodeFault) {
+ if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) || (strpos($faultResponse, '%faultString%') !== false))) {
+ $respCode = "str_replace(array('%faultCode%', '%faultString%'), array(\$res->faultCode(), \$res->faultString()), '" . str_replace("'", "''", $faultResponse) . "')";
+ } else {
+ $respCode = var_export($faultResponse, true);
+ }
+ } else {
+ $respCode = '$res';
+ }
+ if ($decodePhpObjects) {
+ $innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value(), array('decode_php_objs'));";
+ } else {
+ $innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value());";
+ }
+
+ $code = $code . $plist . ") {\n" . $innerCode . "\n}\n";
+
+ return array('source' => $code, 'docstring' => $mDesc);
+}
+
+/**
+ * @deprecated
+ */
+function build_client_wrapper_code($client, $verbatim_client_copy, $prefix='xmlrpc')
+{
+ $code = "\$client = new {$prefix}_client('".str_replace("'", "\'", $client->path).
+ "', '" . str_replace("'", "\'", $client->server) . "', $client->port);\n";
+
+ // copy all client fields to the client that will be generated runtime
+ // (this provides for future expansion or subclassing of client obj)
+ if ($verbatim_client_copy)
+ {
+ foreach($client as $fld => $val)
+ {
+ if($fld != 'debug' && $fld != 'return_type')
+ {
+ $val = var_export($val, true);
+ $code .= "\$client->$fld = $val;\n";
+ }
+ }
+ }
+ // only make sure that client always returns the correct data type
+ $code .= "\$client->return_type = '{$prefix}vals';\n";
+ //$code .= "\$client->setDebug(\$debug);\n";
+ return $code;
+}
--- /dev/null
+<?php
+// by Edd Dumbill (C) 1999-2002
+// <edd@usefulinc.com>
+
+// Copyright (c) 1999,2000,2002 Edd Dumbill.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided
+// with the distribution.
+//
+// * Neither the name of the "XML-RPC for PHP" nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/******************************************************************************
+ *
+ * *** DEPRECATED ***
+ *
+ * This file is only used to insure backwards compatibility
+ * with the API of the library <= rev. 3
+ *****************************************************************************/
+
+include_once(__DIR__.'/../src/Server.php');
+
+class xmlrpc_server extends PhpXmlRpc\Server
+{
+ /**
+ * A debugging routine: just echoes back the input packet as a string value
+ * @deprecated
+ */
+ public function echoInput()
+ {
+ $r = new Response(new PhpXmlRpc\Value("'Aha said I: '" . file_get_contents('php://input'), 'string'));
+ print $r->serialize();
+ }
+}
+
+/* Expose as global functions the ones which are now class methods */
+
+/**
+ * @see PhpXmlRpc\Server::xmlrpc_debugmsg
+ * @param string $m
+ */
+function xmlrpc_debugmsg($m)
+{
+ PhpXmlRpc\Server::xmlrpc_debugmsg($m);
+}
+
+function _xmlrpcs_getCapabilities($server, $m=null)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_getCapabilities($server, $m);
+}
+
+$_xmlrpcs_listMethods_sig=array(array($GLOBALS['xmlrpcArray']));
+$_xmlrpcs_listMethods_doc='This method lists all the methods that the XML-RPC server knows how to dispatch';
+$_xmlrpcs_listMethods_sdoc=array(array('list of method names'));
+function _xmlrpcs_listMethods($server, $m=null) // if called in plain php values mode, second param is missing
+{
+ return PhpXmlRpc\Server::_xmlrpcs_listMethods($server, $m);
+}
+
+$_xmlrpcs_methodSignature_sig=array(array($GLOBALS['xmlrpcArray'], $GLOBALS['xmlrpcString']));
+$_xmlrpcs_methodSignature_doc='Returns an array of known signatures (an array of arrays) for the method name passed. If no signatures are known, returns a none-array (test for type != array to detect missing signature)';
+$_xmlrpcs_methodSignature_sdoc=array(array('list of known signatures, each sig being an array of xmlrpc type names', 'name of method to be described'));
+function _xmlrpcs_methodSignature($server, $m)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_methodSignature($server, $m);
+}
+
+$_xmlrpcs_methodHelp_sig=array(array($GLOBALS['xmlrpcString'], $GLOBALS['xmlrpcString']));
+$_xmlrpcs_methodHelp_doc='Returns help text if defined for the method passed, otherwise returns an empty string';
+$_xmlrpcs_methodHelp_sdoc=array(array('method description', 'name of the method to be described'));
+function _xmlrpcs_methodHelp($server, $m)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_methodHelp($server, $m);
+}
+
+function _xmlrpcs_multicall_error($err)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_multicall_error($err);
+}
+
+function _xmlrpcs_multicall_do_call($server, $call)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_multicall_do_call($server, $call);
+}
+
+function _xmlrpcs_multicall_do_call_phpvals($server, $call)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_multicall_do_call_phpvals($server, $call);
+}
+
+$_xmlrpcs_multicall_sig = array(array($GLOBALS['xmlrpcArray'], $GLOBALS['xmlrpcArray']));
+$_xmlrpcs_multicall_doc = 'Boxcar multiple RPC calls in one request. See http://www.xmlrpc.com/discuss/msgReader$1208 for details';
+$_xmlrpcs_multicall_sdoc = array(array('list of response structs, where each struct has the usual members', 'list of calls, with each call being represented as a struct, with members "methodname" and "params"'));
+function _xmlrpcs_multicall($server, $m)
+{
+ return PhpXmlRpc\Server::_xmlrpcs_multicall($server, $m);
+}
--- /dev/null
+Software License Agreement (BSD License)
+
+Copyright (c) 1999,2000,2001 Edd Dumbill, Useful Information Company
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * Neither the name of the "XML-RPC for PHP" nor the names of its contributors
+ may be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
--- /dev/null
+<?php
+/**
+ * Makefile for phpxmlrpc library.
+ * To be used with the Pake tool: https://github.com/indeyets/pake/wiki
+ *
+ * @copyright (c) 2015 G. Giunta
+ *
+ * @todo !important allow user to specify location of docbook xslt instead of the one installed via composer
+ */
+
+namespace PhpXmlRpc {
+
+class Builder
+{
+ protected static $buildDir = 'build';
+ protected static $libVersion;
+ protected static $tools = array(
+ 'asciidoctor' => 'asciidoctor',
+ 'fop' => 'fop',
+ 'php' => 'php',
+ 'zip' => 'zip',
+ );
+ protected static $options = array(
+ 'repo' => 'https://github.com/gggeek/phpxmlrpc',
+ 'branch' => 'master'
+ );
+
+ public static function libVersion()
+ {
+ if (self::$libVersion == null)
+ throw new \Exception('Missing library version argument');
+ return self::$libVersion;
+ }
+
+ public static function buildDir()
+ {
+ return self::$buildDir;
+ }
+
+ public static function workspaceDir()
+ {
+ return self::buildDir().'/workspace';
+ }
+
+ /// most likely things will break if this one is moved outside of BuildDir
+ public static function distDir()
+ {
+ return self::buildDir().'/xmlrpc-'.self::libVersion();
+ }
+
+ /// these will be generated in BuildDir
+ public static function distFiles()
+ {
+ return array(
+ 'xmlrpc-'.self::libVersion().'.tar.gz',
+ 'xmlrpc-'.self::libVersion().'.zip',
+ );
+ }
+
+ public static function getOpts($args=array(), $cliOpts=array())
+ {
+ if (count($args) > 0)
+ // throw new \Exception('Missing library version argument');
+ self::$libVersion = $args[0];
+
+ foreach (self::$tools as $name => $binary) {
+ if (isset($cliOpts[$name])) {
+ self::$tools[$name] = $cliOpts[$name];
+ }
+ }
+
+ foreach (self::$options as $name => $value) {
+ if (isset($cliOpts[$name])) {
+ self::$options[$name] = $cliOpts[$name];
+ }
+ }
+
+ //pake_echo('---'.self::$libVersion.'---');
+ }
+
+ /**
+ * @param string $name
+ * @return string
+ */
+ public static function tool($name)
+ {
+ return self::$tools[$name];
+ }
+
+ /**
+ * @param string $name
+ * @return string
+ */
+ public static function option($name)
+ {
+ return self::$options[$name];
+ }
+
+ /**
+ * @param string $inFile
+ * @param string $xssFile
+ * @param string $outFileOrDir
+ * @throws \Exception
+ */
+ public static function applyXslt($inFile, $xssFile, $outFileOrDir)
+ {
+
+ if (!file_exists($inFile)) {
+ throw new \Exception("File $inFile cannot be found");
+ }
+ if (!file_exists($xssFile)) {
+ throw new \Exception("File $xssFile cannot be found");
+ }
+
+ // Load the XML source
+ $xml = new \DOMDocument();
+ $xml->load($inFile);
+ $xsl = new \DOMDocument();
+ $xsl->load($xssFile);
+
+ // Configure the transformer
+ $processor = new \XSLTProcessor();
+ if (version_compare(PHP_VERSION, '5.4', "<")) {
+ if (defined('XSL_SECPREF_WRITE_FILE')) {
+ ini_set("xsl.security_prefs", XSL_SECPREF_CREATE_DIRECTORY | XSL_SECPREF_WRITE_FILE);
+ }
+ } else {
+ // the php online docs only mention setSecurityPrefs, but somehow some installs have setSecurityPreferences...
+ if (method_exists('XSLTProcessor', 'setSecurityPrefs')) {
+ $processor->setSecurityPrefs(XSL_SECPREF_CREATE_DIRECTORY | XSL_SECPREF_WRITE_FILE);
+ } else {
+ $processor->setSecurityPreferences(XSL_SECPREF_CREATE_DIRECTORY | XSL_SECPREF_WRITE_FILE);
+ }
+ }
+ $processor->importStyleSheet($xsl); // attach the xsl rules
+
+ if (is_dir($outFileOrDir)) {
+ if (!$processor->setParameter('', 'base.dir', realpath($outFileOrDir))) {
+ echo "setting param base.dir KO\n";
+ }
+ }
+
+ $out = $processor->transformToXML($xml);
+
+ if (!is_dir($outFileOrDir)) {
+ file_put_contents($outFileOrDir, $out);
+ }
+ }
+
+ public static function highlightPhpInHtml($content)
+ {
+ $startTag = '<pre class="programlisting">';
+ $endTag = '</pre>';
+
+ //$content = file_get_contents($inFile);
+ $last = 0;
+ $out = '';
+ while (($start = strpos($content, $startTag, $last)) !== false) {
+ $end = strpos($content, $endTag, $start);
+ $code = substr($content, $start + strlen($startTag), $end - $start - strlen($startTag));
+ if ($code[strlen($code) - 1] == "\n") {
+ $code = substr($code, 0, -1);
+ }
+
+ $code = str_replace(array('>', '<'), array('>', '<'), $code);
+ $code = highlight_string('<?php ' . $code, true);
+ $code = str_replace('<span style="color: #0000BB"><?php <br />', '<span style="color: #0000BB">', $code);
+
+ $out = $out . substr($content, $last, $start + strlen($startTag) - $last) . $code . $endTag;
+ $last = $end + strlen($endTag);
+ }
+ $out .= substr($content, $last, strlen($content));
+
+ return $out;
+ }
+}
+
+}
+
+namespace {
+
+use PhpXmlRpc\Builder;
+
+function run_default($task=null, $args=array(), $cliOpts=array())
+{
+ echo "Syntax: pake {\$pake-options} \$task \$lib-version [\$git-tag] {\$task-options}\n";
+ echo "\n";
+ echo " Run 'pake help' to list all pake options\n";
+ echo " Run 'pake -T' to list available tasks\n";
+ echo " Run 'pake -P' to list all available tasks (including hidden ones) and their dependencies\n";
+ echo "\n";
+ echo " Task options:\n";
+ echo " --repo=REPO URL of the source repository to clone. Defaults to the github repo.\n";
+ echo " --branch=BRANCH The git branch to build from.\n";
+ echo " --asciidoctor=ASCIIDOCTOR Location of the asciidoctor command-line tool\n";
+ echo " --fop=FOP Location of the apache fop command-line tool\n";
+ echo " --php=PHP Location of the php command-line interpreter\n";
+ echo " --zip=ZIP Location of the zip tool\n";
+}
+
+function run_getopts($task=null, $args=array(), $cliOpts=array())
+{
+ Builder::getOpts($args, $cliOpts);
+}
+
+/**
+ * Downloads source code in the build workspace directory, optionally checking out the given branch/tag
+ */
+function run_init($task=null, $args=array(), $cliOpts=array())
+{
+ // download the current version into the workspace
+ $targetDir = Builder::workspaceDir();
+
+ // check if workspace exists and is not already set to the correct repo
+ if (is_dir($targetDir) && pakeGit::isRepository($targetDir)) {
+ $repo = new pakeGit($targetDir);
+ $remotes = $repo->remotes();
+ if (trim($remotes['origin']['fetch']) != Builder::option('repo')) {
+ throw new Exception("Directory '$targetDir' exists and is not linked to correct git repo");
+ }
+
+ /// @todo should we not just fetch instead?
+ $repo->pull();
+ } else {
+ pake_mkdirs(dirname($targetDir));
+ $repo = pakeGit::clone_repository(Builder::option('repo'), Builder::workspaceDir());
+ }
+
+ $repo->checkout(Builder::option('branch'));
+}
+
+/**
+ * Runs all the build steps.
+ *
+ * (does nothing by itself, as all the steps are managed via task dependencies)
+ */
+function run_build($task=null, $args=array(), $cliOpts=array())
+{
+}
+
+function run_clean_doc()
+{
+ pake_remove_dir(Builder::workspaceDir().'/doc/api');
+ $finder = pakeFinder::type('file')->name('*.html');
+ pake_remove($finder, Builder::workspaceDir().'/doc/manual');
+ $finder = pakeFinder::type('file')->name('*.xml');
+ pake_remove($finder, Builder::workspaceDir().'/doc/manual');
+}
+
+/**
+ * Generates documentation in all formats
+ */
+function run_doc($task=null, $args=array(), $cliOpts=array())
+{
+ $docDir = Builder::workspaceDir().'/doc';
+
+ // API docs
+
+ // from phpdoc comments using phpdocumentor
+ //$cmd = Builder::tool('php');
+ //pake_sh("$cmd vendor/phpdocumentor/phpdocumentor/bin/phpdoc run -d ".Builder::workspaceDir().'/src'." -t ".Builder::workspaceDir().'/doc/api --title PHP-XMLRPC');
+
+ // from phpdoc comments using Sami
+ $samiConfig = <<<EOT
+<?php
+ \$iterator = Symfony\Component\Finder\Finder::create()
+ ->files()
+ ->exclude('debugger')
+ ->exclude('demo')
+ ->exclude('doc')
+ ->exclude('tests')
+ ->in('./build/workspace');
+ return new Sami\Sami(\$iterator, array(
+ 'title' => 'PHP-XMLRPC',
+ 'build_dir' => 'build/workspace/doc/api',
+ 'cache_dir' => 'build/cache',
+ ));
+EOT;
+ file_put_contents('build/sami_config.php', $samiConfig);
+ $cmd = Builder::tool('php');
+ pake_sh("$cmd vendor/sami/sami/sami.php update -vvv build/sami_config.php");
+
+ // User Manual
+
+ // html (single file) from asciidoc
+ $cmd = Builder::tool('asciidoctor');
+ pake_sh("$cmd -d book $docDir/manual/phpxmlrpc_manual.adoc");
+
+ // then docbook from asciidoc
+ /// @todo create phpxmlrpc_manual.xml with the good version number
+ /// @todo create phpxmlrpc_manual.xml with the date set to the one of last commit (or today?)
+ pake_sh("$cmd -d book -b docbook $docDir/manual/phpxmlrpc_manual.adoc");
+
+ # Other tools for docbook...
+ #
+ # jade cmd yet to be rebuilt, starting from xml file and putting output in ./out dir, e.g.
+ # jade -t xml -d custom.dsl xmlrpc_php.xml
+ #
+ # convertdoc command for xmlmind xxe editor
+ # convertdoc docb.toHTML xmlrpc_php.xml -u out
+ #
+ # saxon + xerces xml parser + saxon extensions + xslthl: adds a little syntax highligting
+ # (bold and italics only, no color) for php source examples...
+ # java \
+ # -classpath c:\programmi\saxon\saxon.jar\;c:\programmi\saxon\xslthl.jar\;c:\programmi\xerces\xercesImpl.jar\;C:\htdocs\xmlrpc_cvs\docbook-xsl\extensions\saxon65.jar \
+ # -Djavax.xml.parsers.DocumentBuilderFactory=org.apache.xerces.jaxp.DocumentBuilderFactoryImpl \
+ # -Djavax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl \
+ # -Dxslthl.config=file:///c:/htdocs/xmlrpc_cvs/docbook-xsl/highlighting/xslthl-config.xml \
+ # com.icl.saxon.StyleSheet -o xmlrpc_php.fo.xml xmlrpc_php.xml custom.fo.xsl use.extensions=1
+
+ // HTML (multiple files) from docbook - discontinued, as we use the nicer-looking html gotten from asciidoc
+ /*Builder::applyXslt($docDir.'/manual/phpxmlrpc_manual.xml', $docDir.'/build/custom.xsl', $docDir.'/manual');
+ // post process html files to highlight php code samples
+ foreach(pakeFinder::type('file')->name('*.html')->in($docDir.'/manual') as $file)
+ {
+ file_put_contents($file, Builder::highlightPhpInHtml(file_get_contents($file)));
+ }*/
+
+ // PDF file from docbook
+
+ // convert to fo and then to pdf using apache fop
+ Builder::applyXslt($docDir.'/manual/phpxmlrpc_manual.xml', $docDir.'/build/custom.fo.xsl', $docDir.'/manual/phpxmlrpc_manual.fo.xml');
+ $cmd = Builder::tool('fop');
+ pake_sh("$cmd $docDir/manual/phpxmlrpc_manual.fo.xml $docDir/manual/phpxmlrpc_manual.pdf");
+
+ // cleanup
+ unlink($docDir.'/manual/phpxmlrpc_manual.xml');
+ unlink($docDir.'/manual/phpxmlrpc_manual.fo.xml');
+}
+
+function run_clean_dist()
+{
+ pake_remove_dir(Builder::distDir());
+ $finder = pakeFinder::type('file')->name(Builder::distFiles());
+ pake_remove($finder, Builder::buildDir());
+}
+
+/**
+ * Creates the tarballs for a release
+ */
+function run_dist($task=null, $args=array(), $cliOpts=array())
+{
+ // copy workspace dir into dist dir, without git
+ pake_mkdirs(Builder::distDir());
+ $finder = pakeFinder::type('any')->ignore_version_control();
+ pake_mirror($finder, realpath(Builder::workspaceDir()), realpath(Builder::distDir()));
+
+ // remove unwanted files from dist dir
+
+ // also: do we still need to run dos2unix?
+
+ // create tarballs
+ $cwd = getcwd();
+ chdir(dirname(Builder::distDir()));
+ foreach(Builder::distFiles() as $distFile) {
+ // php can not really create good zip files via phar: they are not compressed!
+ if (substr($distFile, -4) == '.zip') {
+ $cmd = Builder::tool('zip');
+ $extra = '-9 -r';
+ pake_sh("$cmd $distFile $extra ".basename(Builder::distDir()));
+ }
+ else {
+ $finder = pakeFinder::type('any')->pattern(basename(Builder::distDir()).'/**');
+ // see https://bugs.php.net/bug.php?id=58852
+ $pharFile = str_replace(Builder::libVersion(), '_LIBVERSION_', $distFile);
+ pakeArchive::createArchive($finder, '.', $pharFile);
+ rename($pharFile, $distFile);
+ }
+ }
+ chdir($cwd);
+}
+
+function run_clean_workspace($task=null, $args=array(), $cliOpts=array())
+{
+ pake_remove_dir(Builder::workspaceDir());
+}
+
+/**
+ * Cleans up the whole build directory
+ * @todo 'make clean' usually just removes the results of the build, distclean removes all but sources
+ */
+function run_clean($task=null, $args=array(), $cliOpts=array())
+{
+ pake_remove_dir(Builder::buildDir());
+}
+
+// helper task: display help text
+pake_task( 'default' );
+// internal task: parse cli options
+pake_task('getopts');
+pake_task('init', 'getopts');
+pake_task('doc', 'getopts', 'init', 'clean-doc');
+pake_task('build', 'getopts', 'init', 'doc');
+pake_task('dist', 'getopts', 'init', 'build', 'clean-dist');
+pake_task('clean-doc', 'getopts');
+pake_task('clean-dist', 'getopts');
+pake_task('clean-workspace', 'getopts');
+pake_task('clean', 'getopts');
+
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+/**
+ * In the unlikely event that you are not using Composer to manage class autoloading, here's an autoloader for this lib.
+ * For usage, see any file in the demo/client directory
+ */
+class Autoloader
+{
+ /**
+ * Registers PhpXmlRpc\Autoloader as an SPL autoloader.
+ *
+ * @param bool $prepend Whether to prepend the autoloader or not.
+ */
+ public static function register($prepend = false)
+ {
+ spl_autoload_register(array(__CLASS__, 'autoload'), true, $prepend);
+ }
+
+ /**
+ * Handles autoloading of classes.
+ *
+ * @param string $class A class name.
+ */
+ public static function autoload($class)
+ {
+ if (0 !== strpos($class, 'PhpXmlRpc\\')) {
+ return;
+ }
+
+ if (is_file($file = __DIR__ . str_replace(array('PhpXmlRpc\\', '\\'), '/', $class).'.php')) {
+ require $file;
+ }
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+use PhpXmlRpc\Helper\Logger;
+
+/**
+ * Used to represent a client of an XML-RPC server.
+ */
+class Client
+{
+ /// @todo: do these need to be public?
+ public $method = 'http';
+ public $server;
+ public $port = 0;
+ public $path;
+
+ public $errno;
+ public $errstr;
+ public $debug = 0;
+
+ public $username = '';
+ public $password = '';
+ public $authtype = 1;
+
+ public $cert = '';
+ public $certpass = '';
+ public $cacert = '';
+ public $cacertdir = '';
+ public $key = '';
+ public $keypass = '';
+ public $verifypeer = true;
+ public $verifyhost = 2;
+ public $sslversion = 0; // corresponds to CURL_SSLVERSION_DEFAULT
+
+ public $proxy = '';
+ public $proxyport = 0;
+ public $proxy_user = '';
+ public $proxy_pass = '';
+ public $proxy_authtype = 1;
+
+ public $cookies = array();
+ public $extracurlopts = array();
+
+ /**
+ * @var bool
+ *
+ * This determines whether the multicall() method will try to take advantage of the system.multicall xmlrpc method
+ * to dispatch to the server an array of requests in a single http roundtrip or simply execute many consecutive http
+ * calls. Defaults to FALSE, but it will be enabled automatically on the first failure of execution of
+ * system.multicall.
+ */
+ public $no_multicall = false;
+
+ /**
+ * List of http compression methods accepted by the client for responses.
+ * NB: PHP supports deflate, gzip compressions out of the box if compiled w. zlib.
+ *
+ * NNB: you can set it to any non-empty array for HTTP11 and HTTPS, since
+ * in those cases it will be up to CURL to decide the compression methods
+ * it supports. You might check for the presence of 'zlib' in the output of
+ * curl_version() to determine wheter compression is supported or not
+ */
+ public $accepted_compression = array();
+
+ /**
+ * Name of compression scheme to be used for sending requests.
+ * Either null, gzip or deflate.
+ */
+
+ public $request_compression = '';
+ /**
+ * CURL handle: used for keep-alive connections (PHP 4.3.8 up, see:
+ * http://curl.haxx.se/docs/faq.html#7.3).
+ */
+ public $xmlrpc_curl_handle = null;
+
+ /// Whether to use persistent connections for http 1.1 and https
+ public $keepalive = false;
+
+ /// Charset encodings that can be decoded without problems by the client
+ public $accepted_charset_encodings = array();
+
+ /**
+ * The charset encoding that will be used for serializing request sent by the client.
+ * It defaults to NULL, which means using US-ASCII and encoding all characters outside of the ASCII range using
+ * their xml character entity representation (this has the benefit that line end characters will not be mangled in
+ * the transfer, a CR-LF will be preserved as well as a singe LF).
+ * Valid values are 'US-ASCII', 'UTF-8' and 'ISO-8859-1'
+ */
+ public $request_charset_encoding = '';
+
+ /**
+ * Decides the content of Response objects returned by calls to send() and multicall().
+ * Valid values are 'xmlrpcvals', 'phpvals' or 'xml'.
+ *
+ * Determines whether the value returned inside an Response object as results of calls to the send() and multicall()
+ * methods will be a Value object, a plain php value or a raw xml string.
+ * Allowed values are 'xmlrpcvals' (the default), 'phpvals' and 'xml'.
+ * To allow the user to differentiate between a correct and a faulty response, fault responses will be returned as
+ * Response objects in any case.
+ * Note that the 'phpvals' setting will yield faster execution times, but some of the information from the original
+ * response will be lost. It will be e.g. impossible to tell whether a particular php string value was sent by the
+ * server as an xmlrpc string or base64 value.
+ */
+ public $return_type = 'xmlrpcvals';
+
+ /**
+ * Sent to servers in http headers.
+ */
+ public $user_agent;
+
+ /**
+ * @param string $path either the PATH part of the xmlrpc server URL, or complete server URL (in which case you
+ * should use and empty string for all other parameters)
+ * e.g. /xmlrpc/server.php
+ * e.g. http://phpxmlrpc.sourceforge.net/server.php
+ * e.g. https://james:bond@secret.service.com:443/xmlrpcserver?agent=007
+ * @param string $server the server name / ip address
+ * @param integer $port the port the server is listening on, when omitted defaults to 80 or 443 depending on
+ * protocol used
+ * @param string $method the http protocol variant: defaults to 'http'; 'https' and 'http11' can be used if CURL is
+ * installed. The value set here can be overridden in any call to $this->send().
+ */
+ public function __construct($path, $server = '', $port = '', $method = '')
+ {
+ // allow user to specify all params in $path
+ if ($server == '' and $port == '' and $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_init') && (($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');
+
+ // Add all charsets which mbstring can handle, but remove junk not found in IANA registry at
+ // in http://www.iana.org/assignments/character-sets/character-sets.xhtml
+ // NB: this is disabled to avoid making all the requests sent huge... mbstring supports more than 80 charsets!
+ /*if (function_exists('mb_list_encodings')) {
+
+ $encodings = array_diff(mb_list_encodings(), array('pass', 'auto', 'wchar', 'BASE64', 'UUENCODE', 'ASCII',
+ 'HTML-ENTITIES', 'Quoted-Printable', '7bit','8bit', 'byte2be', 'byte2le', 'byte4be', 'byte4le'));
+ $this->accepted_charset_encodings = array_unique(array_merge($this->accepted_charset_encodings, $encodings));
+ }*/
+
+ // initialize user_agent string
+ $this->user_agent = PhpXmlRpc::$xmlrpcName . ' ' . PhpXmlRpc::$xmlrpcVersion;
+ }
+
+ /**
+ * Enable/disable the echoing to screen of the xmlrpc responses received. The default is not no output anything.
+ *
+ * The debugging information at level 1 includes the raw data returned from the XML-RPC server it was querying
+ * (including bot HTTP headers and the full XML payload), and the PHP value the client attempts to create to
+ * represent the value returned by the server
+ * At level2, the complete payload of the xmlrpc request is also printed, before being sent t the server.
+ *
+ * This option can be very useful when debugging servers as it allows you to see exactly what the client sends and
+ * the server returns.
+ *
+ * @param integer $in values 0, 1 and 2 are supported (2 = echo sent msg too, before received response)
+ */
+ public function setDebug($level)
+ {
+ $this->debug = $level;
+ }
+
+ /**
+ * Sets the username and password for authorizing the client to the server.
+ *
+ * With the default (HTTP) transport, this information is used for HTTP Basic authorization.
+ * Note that username and password can also be set using the class constructor.
+ * With HTTP 1.1 and HTTPS transport, NTLM and Digest authentication protocols are also supported. To enable them use
+ * the constants CURLAUTH_DIGEST and CURLAUTH_NTLM as values for the auth type parameter.
+ *
+ * @param string $user username
+ * @param string $password password
+ * @param integer $authType auth type. See curl_setopt man page for supported auth types. Defaults to CURLAUTH_BASIC
+ * (basic auth). Note that auth types NTLM and Digest will only work if the Curl php
+ * extension is enabled.
+ */
+ public function setCredentials($user, $password, $authType = 1)
+ {
+ $this->username = $user;
+ $this->password = $password;
+ $this->authtype = $authType;
+ }
+
+ /**
+ * Set the optional certificate and passphrase used in SSL-enabled communication with a remote server.
+ *
+ * Note: to retrieve information about the client certificate on the server side, you will need to look into the
+ * environment variables which are set up by the webserver. Different webservers will typically set up different
+ * variables.
+ *
+ * @param string $cert the name of a file containing a PEM formatted certificate
+ * @param string $certPass the password required to use it
+ */
+ public function setCertificate($cert, $certPass = '')
+ {
+ $this->cert = $cert;
+ $this->certpass = $certPass;
+ }
+
+ /**
+ * Add a CA certificate to verify server with in SSL-enabled communication when SetSSLVerifypeer has been set to TRUE.
+ *
+ * See the php manual page about CURLOPT_CAINFO for more details.
+ *
+ * @param string $caCert certificate file name (or dir holding certificates)
+ * @param bool $isDir set to true to indicate cacert is a dir. defaults to false
+ */
+ public function setCaCertificate($caCert, $isDir = false)
+ {
+ if ($isDir) {
+ $this->cacertdir = $caCert;
+ } else {
+ $this->cacert = $caCert;
+ }
+ }
+
+ /**
+ * Set attributes for SSL communication: private SSL key.
+ *
+ * NB: does not work in older php/curl installs.
+ * Thanks to Daniel Convissor.
+ *
+ * @param string $key The name of a file containing a private SSL key
+ * @param string $keyPass The secret password needed to use the private SSL key
+ */
+ public function setKey($key, $keyPass)
+ {
+ $this->key = $key;
+ $this->keypass = $keyPass;
+ }
+
+ /**
+ * Set attributes for SSL communication: verify the remote host's SSL certificate, and cause the connection to fail
+ * if the cert verification fails.
+ *
+ * By default, verification is enabled.
+ * To specify custom SSL certificates to validate the server with, use the setCaCertificate method.
+ *
+ * @param bool $i enable/disable verification of peer certificate
+ */
+ public function setSSLVerifyPeer($i)
+ {
+ $this->verifypeer = $i;
+ }
+
+ /**
+ * Set attributes for SSL communication: verify the remote host's SSL certificate's common name (CN).
+ *
+ * Note that support for value 1 has been removed in cURL 7.28.1
+ *
+ * @param int $i Set to 1 to only the existence of a CN, not that it matches
+ */
+ public function setSSLVerifyHost($i)
+ {
+ $this->verifyhost = $i;
+ }
+
+ /**
+ * Set attributes for SSL communication: SSL version to use. Best left at 0 (default value ): let cURL decide
+ *
+ * @param int $i
+ */
+ public function setSSLVersion($i)
+ {
+ $this->sslversion = $i;
+ }
+
+ /**
+ * Set proxy info.
+ *
+ * NB: CURL versions before 7.11.10 cannot use a proxy to communicate with https servers.
+ *
+ * @param string $proxyHost
+ * @param string $proxyPort Defaults to 8080 for HTTP and 443 for HTTPS
+ * @param string $proxyUsername Leave blank if proxy has public access
+ * @param string $proxyPassword Leave blank if proxy has public access
+ * @param int $proxyAuthType defaults to CURLAUTH_BASIC (Basic authentication protocol); set to constant CURLAUTH_NTLM
+ * to use NTLM auth with proxy (has effect only when the client uses the HTTP 1.1 protocol)
+ */
+ 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;
+ }
+
+ /**
+ * Enables/disables reception of compressed xmlrpc responses.
+ *
+ * This requires the "zlib" extension to be enabled in your php install. If it is, by default xmlrpc_client
+ * instances will enable reception of compressed content.
+ * 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.
+ *
+ * @param string $compMethod either 'gzip', 'deflate', 'any' or ''
+ */
+ 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);
+ }
+ }
+
+ /**
+ * Enables/disables http compression of xmlrpc request.
+ *
+ * This requires the "zlib" extension to be enabled in your php install.
+ * Take care when sending compressed requests: servers might not support them (and automatic fallback to
+ * uncompressed requests is not yet implemented).
+ *
+ * @param string $compMethod either 'gzip', 'deflate' or ''
+ */
+ public function setRequestCompression($compMethod)
+ {
+ $this->request_compression = $compMethod;
+ }
+
+ /**
+ * Adds a cookie to list of cookies that will be sent to server with every further request (useful e.g. for keeping
+ * session info outside of the xml-rpc payload).
+ *
+ * NB: By default cookies are sent using the 'original/netscape' format, which is also the same as the RFC 2965;
+ * setting any param but name and value will turn the cookie into a 'version 1' cookie (i.e. RFC 2109 cookie) that
+ * might not be fully supported by the server. Note that RFC 2109 has currently 'historic' status...
+ *
+ * @param string $name nb: will not be escaped in the request's http headers. Take care not to use CTL chars or
+ * separators!
+ * @param string $value
+ * @param string $path leave this empty unless the xml-rpc server only accepts RFC 2109 cookies
+ * @param string $domain leave this empty unless the xml-rpc server only accepts RFC 2109 cookies
+ * @param int $port leave this empty unless the xml-rpc server only accepts RFC 2109 cookies
+ *
+ * @todo check correctness of urlencoding cookie value (copied from php way of doing it, but php is generally sending
+ * response not requests. We do the opposite...)
+ * @todo strip invalid chars from cookie name? As per RFC6265, we should follow RFC2616, Section 2.2
+ */
+ public function setCookie($name, $value = '', $path = '', $domain = '', $port = null)
+ {
+ $this->cookies[$name]['value'] = urlencode($value);
+ if ($path || $domain || $port) {
+ $this->cookies[$name]['path'] = $path;
+ $this->cookies[$name]['domain'] = $domain;
+ $this->cookies[$name]['port'] = $port;
+ $this->cookies[$name]['version'] = 1;
+ } else {
+ $this->cookies[$name]['version'] = 0;
+ }
+ }
+
+ /**
+ * Directly set cURL options, for extra flexibility (when in cURL mode).
+ *
+ * It allows eg. to bind client to a specific IP interface / address.
+ *
+ * @param array $options
+ */
+ public function setCurlOptions($options)
+ {
+ $this->extracurlopts = $options;
+ }
+
+ /**
+ * Set user-agent string that will be used by this client instance in http headers sent to the server.
+ *
+ * The default user agent string includes the name of this library and the version number.
+ *
+ * @param string $agentString
+ */
+ public function setUserAgent($agentString)
+ {
+ $this->user_agent = $agentString;
+ }
+
+ /**
+ * Send an xmlrpc request to the server.
+ *
+ * @param Request|Request[]|string $req The Request object, or an array of requests for using multicall, or the
+ * complete xml representation of a request.
+ * When sending an array of Request objects, the client will try to make use of
+ * a single 'system.multicall' xml-rpc method call to forward to the server all
+ * the requests in a single HTTP round trip, unless $this->no_multicall has
+ * been previously set to TRUE (see the multicall method below), in which case
+ * many consecutive xmlrpc requests will be sent. The method will return an
+ * array of Response objects in both cases.
+ * The third variant allows to build by hand (or any other means) a complete
+ * xmlrpc request message, and send it to the server. $req should be a string
+ * containing the complete xml representation of the request. It is e.g. useful
+ * when, for maximal speed of execution, the request is serialized into a
+ * string using the native php xmlrpc functions (see http://www.php.net/xmlrpc)
+ * @param integer $timeout Connection timeout, in seconds, If unspecified, a platform specific timeout will apply.
+ * This timeout value is passed to fsockopen(). It is also used for detecting server
+ * timeouts during communication (i.e. if the server does not send anything to the client
+ * for $timeout seconds, the connection will be closed).
+ * @param string $method valid values are 'http', 'http11' and 'https'. If left unspecified, the http protocol
+ * chosen during creation of the object will be used.
+ *
+ *
+ * @return Response|Response[] Note that the client will always return a Response object, even if the call fails
+ */
+ public function send($req, $timeout = 0, $method = '')
+ {
+ // 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 (is_array($req)) {
+ // $req is an array of Requests
+ $r = $this->multicall($req, $timeout, $method);
+
+ return $r;
+ } elseif (is_string($req)) {
+ $n = new Request('');
+ $n->payload = $req;
+ $req = $n;
+ }
+
+ // where req is a Request
+ $req->setDebug($this->debug);
+
+ if ($method == 'https') {
+ $r = $this->sendPayloadHTTPS(
+ $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,
+ $this->keepalive,
+ $this->key,
+ $this->keypass,
+ $this->sslversion
+ );
+ } elseif ($method == 'http11') {
+ $r = $this->sendPayloadCURL(
+ $req,
+ $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,
+ 'http',
+ $this->keepalive
+ );
+ } else {
+ $r = $this->sendPayloadHTTP10(
+ $req,
+ $this->server,
+ $this->port,
+ $timeout,
+ $this->username,
+ $this->password,
+ $this->authtype,
+ $this->proxy,
+ $this->proxyport,
+ $this->proxy_user,
+ $this->proxy_pass,
+ $this->proxy_authtype,
+ $method
+ );
+ }
+
+ return $r;
+ }
+
+ /**
+ * @param Request $req
+ * @param string $server
+ * @param int $port
+ * @param int $timeout
+ * @param string $username
+ * @param string $password
+ * @param int $authType
+ * @param string $proxyHost
+ * @param int $proxyPort
+ * @param string $proxyUsername
+ * @param string $proxyPassword
+ * @param int $proxyAuthType
+ * @param string $method
+ * @return Response
+ */
+ protected function sendPayloadHTTP10($req, $server, $port, $timeout = 0, $username = '', $password = '',
+ $authType = 1, $proxyHost = '', $proxyPort = 0, $proxyUsername = '', $proxyPassword = '', $proxyAuthType = 1,
+ $method='http')
+ {
+ if ($port == 0) {
+ $port = ( $method === "https" ) ? 443 : 80;
+ }
+
+ // Only create the payload if it was not created previously
+ if (empty($req->payload)) {
+ $req->createPayload($this->request_charset_encoding);
+ }
+
+ $payload = $req->payload;
+ // Deflate request body and set appropriate request headers
+ if (function_exists('gzdeflate') && ($this->request_compression == 'gzip' || $this->request_compression == 'deflate')) {
+ if ($this->request_compression == 'gzip') {
+ $a = @gzencode($payload);
+ if ($a) {
+ $payload = $a;
+ $encodingHdr = "Content-Encoding: gzip\r\n";
+ }
+ } else {
+ $a = @gzcompress($payload);
+ if ($a) {
+ $payload = $a;
+ $encodingHdr = "Content-Encoding: deflate\r\n";
+ }
+ }
+ } else {
+ $encodingHdr = '';
+ }
+
+ // thanks to Grant Rauscher <grant7@firstworld.net> for this
+ $credentials = '';
+ if ($username != '') {
+ $credentials = 'Authorization: Basic ' . base64_encode($username . ':' . $password) . "\r\n";
+ if ($authType != 1) {
+ error_log('XML-RPC: ' . __METHOD__ . ': warning. Only Basic auth is supported with HTTP 1.0');
+ }
+ }
+
+ $acceptedEncoding = '';
+ if (is_array($this->accepted_compression) && count($this->accepted_compression)) {
+ $acceptedEncoding = 'Accept-Encoding: ' . implode(', ', $this->accepted_compression) . "\r\n";
+ }
+
+ $proxyCredentials = '';
+ if ($proxyHost) {
+ if ($proxyPort == 0) {
+ $proxyPort = 8080;
+ }
+ $connectServer = $proxyHost;
+ $connectPort = $proxyPort;
+ $transport = "tcp";
+ $uri = 'http://' . $server . ':' . $port . $this->path;
+ if ($proxyUsername != '') {
+ if ($proxyAuthType != 1) {
+ error_log('XML-RPC: ' . __METHOD__ . ': warning. Only Basic auth to proxy is supported with HTTP 1.0');
+ }
+ $proxyCredentials = 'Proxy-Authorization: Basic ' . base64_encode($proxyUsername . ':' . $proxyPassword) . "\r\n";
+ }
+ } else {
+ $connectServer = $server;
+ $connectPort = $port;
+ /// @todo if supporting https, we should support all its current options as well: peer name verification etc...
+ $transport = ( $method === "https" ) ? "tls" : "tcp";
+ $uri = $this->path;
+ }
+
+ // Cookie generation, as per rfc2965 (version 1 cookies) or
+ // netscape's rules (version 0 cookies)
+ $cookieHeader = '';
+ if (count($this->cookies)) {
+ $version = '';
+ foreach ($this->cookies as $name => $cookie) {
+ if ($cookie['version']) {
+ $version = ' $Version="' . $cookie['version'] . '";';
+ $cookieHeader .= ' ' . $name . '="' . $cookie['value'] . '";';
+ if ($cookie['path']) {
+ $cookieHeader .= ' $Path="' . $cookie['path'] . '";';
+ }
+ if ($cookie['domain']) {
+ $cookieHeader .= ' $Domain="' . $cookie['domain'] . '";';
+ }
+ if ($cookie['port']) {
+ $cookieHeader .= ' $Port="' . $cookie['port'] . '";';
+ }
+ } else {
+ $cookieHeader .= ' ' . $name . '=' . $cookie['value'] . ";";
+ }
+ }
+ $cookieHeader = 'Cookie:' . $version . substr($cookieHeader, 0, -1) . "\r\n";
+ }
+
+ // omit port if 80
+ $port = ($port == 80) ? '' : (':' . $port);
+
+ $op = 'POST ' . $uri . " HTTP/1.0\r\n" .
+ 'User-Agent: ' . $this->user_agent . "\r\n" .
+ 'Host: ' . $server . $port . "\r\n" .
+ $credentials .
+ $proxyCredentials .
+ $acceptedEncoding .
+ $encodingHdr .
+ 'Accept-Charset: ' . implode(',', $this->accepted_charset_encodings) . "\r\n" .
+ $cookieHeader .
+ 'Content-Type: ' . $req->content_type . "\r\nContent-Length: " .
+ strlen($payload) . "\r\n\r\n" .
+ $payload;
+
+ if ($this->debug > 1) {
+ Logger::instance()->debugMessage("---SENDING---\n$op\n---END---");
+ }
+
+ if ($timeout > 0) {
+ $fp = @stream_socket_client("$transport://$connectServer:$connectPort", $this->errno, $this->errstr, $timeout);
+ } else {
+ $fp = @stream_socket_client("$transport://$connectServer:$connectPort", $this->errno, $this->errstr);
+ }
+ if ($fp) {
+ if ($timeout > 0) {
+ stream_set_timeout($fp, $timeout);
+ }
+ } else {
+ $this->errstr = 'Connect error: ' . $this->errstr;
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['http_error'], $this->errstr . ' (' . $this->errno . ')');
+
+ return $r;
+ }
+
+ if (!fputs($fp, $op, strlen($op))) {
+ fclose($fp);
+ $this->errstr = 'Write error';
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['http_error'], $this->errstr);
+
+ return $r;
+ } else {
+ // reset errno and errstr on successful socket connection
+ $this->errstr = '';
+ }
+ // G. Giunta 2005/10/24: close socket before parsing.
+ // should yield slightly better execution times, and make easier recursive calls (e.g. to follow http redirects)
+ $ipd = '';
+ do {
+ // shall we check for $data === FALSE?
+ // as per the manual, it signals an error
+ $ipd .= fread($fp, 32768);
+ } while (!feof($fp));
+ fclose($fp);
+ $r = $req->parseResponse($ipd, false, $this->return_type);
+
+ return $r;
+ }
+
+ /**
+ * @param Request $req
+ * @param string $server
+ * @param int $port
+ * @param int $timeout
+ * @param string $username
+ * @param string $password
+ * @param int $authType
+ * @param string $cert
+ * @param string $certPass
+ * @param string $caCert
+ * @param string $caCertDir
+ * @param string $proxyHost
+ * @param int $proxyPort
+ * @param string $proxyUsername
+ * @param string $proxyPassword
+ * @param int $proxyAuthType
+ * @param bool $keepAlive
+ * @param string $key
+ * @param string $keyPass
+ * @param int $sslVersion
+ * @return Response
+ */
+ protected function sendPayloadHTTPS($req, $server, $port, $timeout = 0, $username = '', $password = '',
+ $authType = 1, $cert = '', $certPass = '', $caCert = '', $caCertDir = '', $proxyHost = '', $proxyPort = 0,
+ $proxyUsername = '', $proxyPassword = '', $proxyAuthType = 1, $keepAlive = false, $key = '', $keyPass = '',
+ $sslVersion = 0)
+ {
+ return $this->sendPayloadCURL($req, $server, $port, $timeout, $username,
+ $password, $authType, $cert, $certPass, $caCert, $caCertDir, $proxyHost, $proxyPort,
+ $proxyUsername, $proxyPassword, $proxyAuthType, 'https', $keepAlive, $key, $keyPass, $sslVersion);
+ }
+
+ /**
+ * 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!
+ *
+ * @param Request $req
+ * @param string $server
+ * @param int $port
+ * @param int $timeout
+ * @param string $username
+ * @param string $password
+ * @param int $authType
+ * @param string $cert
+ * @param string $certPass
+ * @param string $caCert
+ * @param string $caCertDir
+ * @param string $proxyHost
+ * @param int $proxyPort
+ * @param string $proxyUsername
+ * @param string $proxyPassword
+ * @param int $proxyAuthType
+ * @param string $method
+ * @param bool $keepAlive
+ * @param string $key
+ * @param string $keyPass
+ * @param int $sslVersion
+ * @return Response
+ */
+ protected function sendPayloadCURL($req, $server, $port, $timeout = 0, $username = '', $password = '',
+ $authType = 1, $cert = '', $certPass = '', $caCert = '', $caCertDir = '', $proxyHost = '', $proxyPort = 0,
+ $proxyUsername = '', $proxyPassword = '', $proxyAuthType = 1, $method = 'https', $keepAlive = false, $key = '',
+ $keyPass = '', $sslVersion = 0)
+ {
+ if (!function_exists('curl_init')) {
+ $this->errstr = 'CURL unavailable on this install';
+ return new Response(0, PhpXmlRpc::$xmlrpcerr['no_curl'], PhpXmlRpc::$xmlrpcstr['no_curl']);
+ }
+ if ($method == 'https') {
+ if (($info = curl_version()) &&
+ ((is_string($info) && strpos($info, 'OpenSSL') === null) || (is_array($info) && !isset($info['ssl_version'])))
+ ) {
+ $this->errstr = 'SSL unavailable on this install';
+ return new Response(0, PhpXmlRpc::$xmlrpcerr['no_ssl'], PhpXmlRpc::$xmlrpcstr['no_ssl']);
+ }
+ }
+
+ if ($port == 0) {
+ if ($method == 'http') {
+ $port = 80;
+ } else {
+ $port = 443;
+ }
+ }
+
+ // Only create the payload if it was not created previously
+ if (empty($req->payload)) {
+ $req->createPayload($this->request_charset_encoding);
+ }
+
+ // Deflate request body and set appropriate request headers
+ $payload = $req->payload;
+ if (function_exists('gzdeflate') && ($this->request_compression == 'gzip' || $this->request_compression == 'deflate')) {
+ if ($this->request_compression == 'gzip') {
+ $a = @gzencode($payload);
+ if ($a) {
+ $payload = $a;
+ $encodingHdr = 'Content-Encoding: gzip';
+ }
+ } else {
+ $a = @gzcompress($payload);
+ if ($a) {
+ $payload = $a;
+ $encodingHdr = 'Content-Encoding: deflate';
+ }
+ }
+ } else {
+ $encodingHdr = '';
+ }
+
+ if ($this->debug > 1) {
+ Logger::instance()->debugMessage("---SENDING---\n$payload\n---END---");
+ }
+
+ if (!$keepAlive || !$this->xmlrpc_curl_handle) {
+ $curl = curl_init($method . '://' . $server . ':' . $port . $this->path);
+ if ($keepAlive) {
+ $this->xmlrpc_curl_handle = $curl;
+ }
+ } else {
+ $curl = $this->xmlrpc_curl_handle;
+ }
+
+ // results into variable
+ curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
+
+ if ($this->debug > 1) {
+ curl_setopt($curl, CURLOPT_VERBOSE, true);
+ /// @todo allow callers to redirect curlopt_stderr to some stream which can be buffered
+ }
+ curl_setopt($curl, CURLOPT_USERAGENT, $this->user_agent);
+ // 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);
+
+ // 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) && count($this->accepted_compression)) {
+ //curl_setopt($curl, CURLOPT_ENCODING, implode(',', $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('Content-Type: ' . $req->content_type, 'Accept-Charset: ' . implode(',', $this->accepted_charset_encodings));
+ // if no keepalive is wanted, let the server know it in advance
+ if (!$keepAlive) {
+ $headers[] = 'Connection: close';
+ }
+ // request compression header
+ if ($encodingHdr) {
+ $headers[] = $encodingHdr;
+ }
+
+ curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
+ // timeout is borked
+ if ($timeout) {
+ curl_setopt($curl, CURLOPT_TIMEOUT, $timeout == 1 ? 1 : $timeout - 1);
+ }
+
+ if ($username && $password) {
+ curl_setopt($curl, CURLOPT_USERPWD, $username . ':' . $password);
+ if (defined('CURLOPT_HTTPAUTH')) {
+ curl_setopt($curl, CURLOPT_HTTPAUTH, $authType);
+ } elseif ($authType != 1) {
+ error_log('XML-RPC: ' . __METHOD__ . ': warning. Only Basic auth is supported by the current PHP/curl install');
+ }
+ }
+
+ if ($method == 'https') {
+ // 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'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'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);
+ // allow usage of different SSL versions
+ curl_setopt($curl, CURLOPT_SSLVERSION, $sslVersion);
+ }
+
+ // 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);
+ if ($proxyUsername) {
+ curl_setopt($curl, CURLOPT_PROXYUSERPWD, $proxyUsername . ':' . $proxyPassword);
+ if (defined('CURLOPT_PROXYAUTH')) {
+ curl_setopt($curl, CURLOPT_PROXYAUTH, $proxyAuthType);
+ } elseif ($proxyAuthType != 1) {
+ error_log('XML-RPC: ' . __METHOD__ . ': 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 client obj the the user...
+ if (count($this->cookies)) {
+ $cookieHeader = '';
+ foreach ($this->cookies as $name => $cookie) {
+ $cookieHeader .= $name . '=' . $cookie['value'] . '; ';
+ }
+ curl_setopt($curl, CURLOPT_COOKIE, substr($cookieHeader, 0, -2));
+ }
+
+ foreach ($this->extracurlopts as $opt => $val) {
+ curl_setopt($curl, $opt, $val);
+ }
+
+ $result = curl_exec($curl);
+
+ if ($this->debug > 1) {
+ $message = "---CURL INFO---\n";
+ foreach (curl_getinfo($curl) as $name => $val) {
+ if (is_array($val)) {
+ $val = implode("\n", $val);
+ }
+ $message .= $name . ': ' . $val . "\n";
+ }
+ $message .= "---END---";
+ Logger::instance()->debugMessage($message);
+ }
+
+ if (!$result) {
+ /// @todo we should use a better check here - what if we get back '' or '0'?
+
+ $this->errstr = 'no response';
+ $resp = new Response(0, PhpXmlRpc::$xmlrpcerr['curl_fail'], PhpXmlRpc::$xmlrpcstr['curl_fail'] . ': ' . curl_error($curl));
+ curl_close($curl);
+ if ($keepAlive) {
+ $this->xmlrpc_curl_handle = null;
+ }
+ } else {
+ if (!$keepAlive) {
+ curl_close($curl);
+ }
+ $resp = $req->parseResponse($result, true, $this->return_type);
+ // if we got back a 302, we can not reuse the curl handle for later calls
+ if ($resp->faultCode() == PhpXmlRpc::$xmlrpcerr['http_error'] && $keepAlive) {
+ curl_close($curl);
+ $this->xmlrpc_curl_handle = null;
+ }
+ }
+
+ return $resp;
+ }
+
+ /**
+ * Send an array of requests 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...
+ *
+ * @param Request[] $reqs an array of Request objects
+ * @param integer $timeout connection timeout (in seconds). See the details in the docs for the send() method
+ * @param string $method the http protocol variant to be used. See the details in the docs for the send() method
+ * @param boolean fallback When true, upon receiving an error during multicall, multiple single calls will be
+ * attempted
+ *
+ * @return Response[]
+ */
+ public function multicall($reqs, $timeout = 0, $method = '', $fallback = true)
+ {
+ if ($method == '') {
+ $method = $this->method;
+ }
+ if (!$this->no_multicall) {
+ $results = $this->_try_multicall($reqs, $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't try it next time...
+ $this->no_multicall = true;
+ } else {
+ if (is_a($results, '\PhpXmlRpc\Response')) {
+ $result = $results;
+ } else {
+ $result = new Response(0, PhpXmlRpc::$xmlrpcerr['multicall_error'], PhpXmlRpc::$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 ($reqs as $req) {
+ $results[] = $this->send($req, $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 ($reqs as $req) {
+ $results[] = $result;
+ }
+ }
+
+ return $results;
+ }
+
+ /**
+ * Attempt to boxcar $reqs via system.multicall.
+ *
+ * Returns either an array of Response, a single error Response or false (when received response does not respect
+ * valid multicall syntax).
+ *
+ * @param Request[] $reqs
+ * @param int $timeout
+ * @param string $method
+ * @return Response[]|bool|mixed|Response
+ */
+ private function _try_multicall($reqs, $timeout, $method)
+ {
+ // Construct multicall request
+ $calls = array();
+ foreach ($reqs as $req) {
+ $call['methodName'] = new Value($req->method(), 'string');
+ $numParams = $req->getNumParams();
+ $params = array();
+ for ($i = 0; $i < $numParams; $i++) {
+ $params[$i] = $req->getParam($i);
+ }
+ $call['params'] = new Value($params, 'array');
+ $calls[] = new Value($call, 'struct');
+ }
+ $multiCall = new Request('system.multicall');
+ $multiCall->addParam(new Value($calls, 'array'));
+
+ // Attempt RPC call
+ $result = $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;
+ } elseif ($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($reqs)) {
+ 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 Response($val[0], 0, '', 'phpvals');
+ break;
+ case 2:
+ /// @todo remove usage of @: it is apparently quite slow
+ $code = @$val['faultCode'];
+ if (!is_int($code)) {
+ return false;
+ }
+ $str = @$val['faultString'];
+ if (!is_string($str)) {
+ return false;
+ }
+ $response[$i] = new Response(0, $code, $str);
+ break;
+ default:
+ return false;
+ }
+ }
+
+ return $response;
+ } else {
+ // return type == 'xmlrpcvals'
+
+ $rets = $result->value();
+ if ($rets->kindOf() != 'array') {
+ return false; // bad return type from system.multicall
+ }
+ $numRets = $rets->count();
+ if ($numRets != count($reqs)) {
+ return false; // wrong number of return values.
+ }
+
+ $response = array();
+ foreach($rets as $val) {
+ switch ($val->kindOf()) {
+ case 'array':
+ if ($val->count() != 1) {
+ return false; // Bad value
+ }
+ // Normal return value
+ $response[] = new Response($val[0]);
+ break;
+ case 'struct':
+ $code = $val['faultCode'];
+ if ($code->kindOf() != 'scalar' || $code->scalartyp() != 'int') {
+ return false;
+ }
+ $str = $val['faultString'];
+ if ($str->kindOf() != 'scalar' || $str->scalartyp() != 'string') {
+ return false;
+ }
+ $response[] = new Response(0, $code->scalarval(), $str->scalarval());
+ break;
+ default:
+ return false;
+ }
+ }
+
+ return $response;
+ }
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+use PhpXmlRpc\Helper\XMLParser;
+
+/**
+ * A helper class to easily convert between Value objects and php native values
+ */
+class Encoder
+{
+ /**
+ * Takes an xmlrpc value in object format and translates it into native PHP types.
+ *
+ * Works with xmlrpc requests 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)
+ *
+ * @param Value|Request $xmlrpcVal
+ * @param array $options if 'decode_php_objs' is set in the options array, xmlrpc structs can be decoded into php objects; if 'dates_as_objects' is set xmlrpc datetimes are decoded as php DateTime objects (standard is
+ *
+ * @return mixed
+ */
+ public function decode($xmlrpcVal, $options = array())
+ {
+ switch ($xmlrpcVal->kindOf()) {
+ case 'scalar':
+ if (in_array('extension_api', $options)) {
+ reset($xmlrpcVal->me);
+ list($typ, $val) = each($xmlrpcVal->me);
+ switch ($typ) {
+ case 'dateTime.iso8601':
+ $xmlrpcVal->scalar = $val;
+ $xmlrpcVal->type = 'datetime';
+ $xmlrpcVal->timestamp = \PhpXmlRpc\Helper\Date::iso8601Decode($val);
+
+ return $xmlrpcVal;
+ case 'base64':
+ $xmlrpcVal->scalar = $val;
+ $xmlrpcVal->type = $typ;
+
+ return $xmlrpcVal;
+ default:
+ return $xmlrpcVal->scalarval();
+ }
+ }
+ if (in_array('dates_as_objects', $options) && $xmlrpcVal->scalartyp() == 'dateTime.iso8601') {
+ // we return a Datetime object instead of a string
+ // since now the constructor of xmlrpc value accepts safely strings, ints and datetimes,
+ // we cater to all 3 cases here
+ $out = $xmlrpcVal->scalarval();
+ if (is_string($out)) {
+ $out = strtotime($out);
+ }
+ if (is_int($out)) {
+ $result = new \DateTime();
+ $result->setTimestamp($out);
+
+ return $result;
+ } elseif (is_a($out, 'DateTimeInterface')) {
+ return $out;
+ }
+ }
+
+ return $xmlrpcVal->scalarval();
+ case 'array':
+ $arr = array();
+ foreach($xmlrpcVal as $value) {
+ $arr[] = $this->decode($value, $options);
+ }
+
+ return $arr;
+ case 'struct':
+ // 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 xmlrpc value instead of
+ // presence of _php_class to detect what we can do?
+ if (in_array('decode_php_objs', $options) && $xmlrpcVal->_php_class != ''
+ && class_exists($xmlrpcVal->_php_class)
+ ) {
+ $obj = @new $xmlrpcVal->_php_class();
+ foreach ($xmlrpcVal as $key => $value) {
+ $obj->$key = $this->decode($value, $options);
+ }
+
+ return $obj;
+ } else {
+ $arr = array();
+ foreach ($xmlrpcVal as $key => $value) {
+ $arr[$key] = $this->decode($value, $options);
+ }
+
+ return $arr;
+ }
+ case 'msg':
+ $paramCount = $xmlrpcVal->getNumParams();
+ $arr = array();
+ for ($i = 0; $i < $paramCount; $i++) {
+ $arr[] = $this->decode($xmlrpcVal->getParam($i), $options);
+ }
+
+ return $arr;
+ }
+ }
+
+ /**
+ * Takes native php types and encodes them into xmlrpc PHP object format.
+ * It will not re-encode xmlrpc value 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)
+ *
+ * @param mixed $phpVal the value to be converted into an xmlrpc value object
+ * @param array $options can include 'encode_php_objs', 'auto_dates', 'null_extension' or 'extension_api'
+ *
+ * @return \PhpXmlrpc\Value
+ */
+ public function encode($phpVal, $options = array())
+ {
+ $type = gettype($phpVal);
+ switch ($type) {
+ case 'string':
+ if (in_array('auto_dates', $options) && preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $phpVal)) {
+ $xmlrpcVal = new Value($phpVal, Value::$xmlrpcDateTime);
+ } else {
+ $xmlrpcVal = new Value($phpVal, Value::$xmlrpcString);
+ }
+ break;
+ case 'integer':
+ $xmlrpcVal = new Value($phpVal, Value::$xmlrpcInt);
+ break;
+ case 'double':
+ $xmlrpcVal = new Value($phpVal, Value::$xmlrpcDouble);
+ break;
+ // <G_Giunta_2001-02-29>
+ // Add support for encoding/decoding of booleans, since they are supported in PHP
+ case 'boolean':
+ $xmlrpcVal = new Value($phpVal, Value::$xmlrpcBoolean);
+ break;
+ // </G_Giunta_2001-02-29>
+ case 'array':
+ // PHP arrays can be encoded to either xmlrpc structs or arrays,
+ // depending on wheter they are hashes or plain 0..n integer indexed
+ // A shorter one-liner would be
+ // $tmp = array_diff(array_keys($phpVal), range(0, count($phpVal)-1));
+ // but execution time skyrockets!
+ $j = 0;
+ $arr = array();
+ $ko = false;
+ foreach ($phpVal as $key => $val) {
+ $arr[$key] = $this->encode($val, $options);
+ if (!$ko && $key !== $j) {
+ $ko = true;
+ }
+ $j++;
+ }
+ if ($ko) {
+ $xmlrpcVal = new Value($arr, Value::$xmlrpcStruct);
+ } else {
+ $xmlrpcVal = new Value($arr, Value::$xmlrpcArray);
+ }
+ break;
+ case 'object':
+ if (is_a($phpVal, 'PhpXmlRpc\Value')) {
+ $xmlrpcVal = $phpVal;
+ } elseif (is_a($phpVal, 'DateTimeInterface')) {
+ $xmlrpcVal = new Value($phpVal->format('Ymd\TH:i:s'), Value::$xmlrpcStruct);
+ } else {
+ $arr = array();
+ reset($phpVal);
+ while (list($k, $v) = each($phpVal)) {
+ $arr[$k] = $this->encode($v, $options);
+ }
+ $xmlrpcVal = new Value($arr, Value::$xmlrpcStruct);
+ if (in_array('encode_php_objs', $options)) {
+ // let's save original class name into xmlrpc value:
+ // might be useful later on...
+ $xmlrpcVal->_php_class = get_class($phpVal);
+ }
+ }
+ break;
+ case 'NULL':
+ if (in_array('extension_api', $options)) {
+ $xmlrpcVal = new Value('', Value::$xmlrpcString);
+ } elseif (in_array('null_extension', $options)) {
+ $xmlrpcVal = new Value('', Value::$xmlrpcNull);
+ } else {
+ $xmlrpcVal = new Value();
+ }
+ break;
+ case 'resource':
+ if (in_array('extension_api', $options)) {
+ $xmlrpcVal = new Value((int)$phpVal, Value::$xmlrpcInt);
+ } else {
+ $xmlrpcVal = new Value();
+ }
+ // catch "user function", "unknown type"
+ default:
+ // giancarlo pinerolo <ping@alt.it>
+ // it has to return
+ // an empty object in case, not a boolean.
+ $xmlrpcVal = new Value();
+ break;
+ }
+
+ return $xmlrpcVal;
+ }
+
+ /**
+ * Convert the xml representation of a method response, method request or single
+ * xmlrpc value into the appropriate object (a.k.a. deserialize).
+ *
+ * @param string $xmlVal
+ * @param array $options
+ *
+ * @return mixed false on error, or an instance of either Value, Request or Response
+ */
+ public function decodeXml($xmlVal, $options = array())
+ {
+ // 'guestimate' encoding
+ $valEncoding = XMLParser::guessEncoding('', $xmlVal);
+ if ($valEncoding != '') {
+
+ // Since parsing will fail if charset is not specified in the xml prologue,
+ // the encoding is not UTF8 and there are non-ascii chars in the text, we try to work round that...
+ // The following code might be better for mb_string enabled installs, but
+ // makes the lib about 200% slower...
+ //if (!is_valid_charset($valEncoding, array('UTF-8'))
+ if (!in_array($valEncoding, array('UTF-8', 'US-ASCII')) && !XMLParser::hasEncoding($xmlVal)) {
+ if ($valEncoding == 'ISO-8859-1') {
+ $xmlVal = utf8_encode($xmlVal);
+ } else {
+ if (extension_loaded('mbstring')) {
+ $xmlVal = mb_convert_encoding($xmlVal, 'UTF-8', $valEncoding);
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of xml text: ' . $valEncoding);
+ }
+ }
+ }
+ }
+
+ $parser = xml_parser_create();
+ xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
+ // What if internal encoding is not in one of the 3 allowed?
+ // we use the broadest one, ie. utf8!
+ if (!in_array(PhpXmlRpc::$xmlrpc_internalencoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII'))) {
+ xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
+ } else {
+ xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, PhpXmlRpc::$xmlrpc_internalencoding);
+ }
+
+ $xmlRpcParser = new XMLParser();
+ xml_set_object($parser, $xmlRpcParser);
+
+ xml_set_element_handler($parser, 'xmlrpc_se_any', 'xmlrpc_ee');
+ xml_set_character_data_handler($parser, 'xmlrpc_cd');
+ xml_set_default_handler($parser, 'xmlrpc_dh');
+ if (!xml_parse($parser, $xmlVal, 1)) {
+ $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);
+ xml_parser_free($parser);
+
+ return false;
+ }
+ xml_parser_free($parser);
+ if ($xmlRpcParser->_xh['isf'] > 1) {
+ // test that $xmlrpc->_xh['value'] is an obj, too???
+
+ error_log($xmlRpcParser->_xh['isf_reason']);
+
+ return false;
+ }
+ switch ($xmlRpcParser->_xh['rt']) {
+ case 'methodresponse':
+ $v = &$xmlRpcParser->_xh['value'];
+ if ($xmlRpcParser->_xh['isf'] == 1) {
+ $vc = $v['faultCode'];
+ $vs = $v['faultString'];
+ $r = new Response(0, $vc->scalarval(), $vs->scalarval());
+ } else {
+ $r = new Response($v);
+ }
+
+ return $r;
+ case 'methodcall':
+ $req = new Request($xmlRpcParser->_xh['method']);
+ for ($i = 0; $i < count($xmlRpcParser->_xh['params']); $i++) {
+ $req->addParam($xmlRpcParser->_xh['params'][$i]);
+ }
+
+ return $req;
+ case 'value':
+ return $xmlRpcParser->_xh['value'];
+ default:
+ return false;
+ }
+ }
+
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc\Helper;
+
+use PhpXmlRpc\PhpXmlRpc;
+
+class Charset
+{
+ // tables used for transcoding different charsets into us-ascii xml
+ protected $xml_iso88591_Entities = array("in" => array(), "out" => array());
+ protected $xml_iso88591_utf8 = array("in" => array(), "out" => array());
+
+ /// @todo add to iso table the characters from cp_1252 range, i.e. 128 to 159?
+ /// These will NOT be present in true ISO-8859-1, but will save the unwary
+ /// windows user from sending junk (though no luck when receiving them...)
+ /*
+ protected $xml_cp1252_Entities = array('in' => array(), out' => array(
+ '€', '?', '‚', 'ƒ',
+ '„', '…', '†', '‡',
+ 'ˆ', '‰', 'Š', '‹',
+ 'Œ', '?', 'Ž', '?',
+ '?', '‘', '’', '“',
+ '”', '•', '–', '—',
+ '˜', '™', 'š', '›',
+ 'œ', '?', 'ž', 'Ÿ'
+ ));
+ */
+
+ protected $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',),
+ );
+
+ protected static $instance = null;
+
+ /**
+ * This class is singleton for performance reasons.
+ *
+ * @return Charset
+ */
+ public static function instance()
+ {
+ if (self::$instance === null) {
+ self::$instance = new self();
+ }
+
+ return self::$instance;
+ }
+
+ private function __construct()
+ {
+ for ($i = 0; $i < 32; $i++) {
+ $this->xml_iso88591_Entities["in"][] = chr($i);
+ $this->xml_iso88591_Entities["out"][] = "&#{$i};";
+ }
+
+ for ($i = 160; $i < 256; $i++) {
+ $this->xml_iso88591_Entities["in"][] = chr($i);
+ $this->xml_iso88591_Entities["out"][] = "&#{$i};";
+ }
+
+ /*for ($i = 128; $i < 160; $i++)
+ {
+ $this->xml_cp1252_Entities['in'][] = chr($i);
+ }*/
+ }
+
+ /**
+ * Convert a string to the correct XML representation in a target charset.
+ *
+ * To help correct communication of non-ascii chars inside strings, regardless of the charset used when sending
+ * requests, parsing them, sending responses and parsing responses, an option is to convert all non-ascii chars
+ * present in the message into their equivalent 'charset entity'. Charset entities enumerated this way are
+ * independent of the charset encoding used to transmit them, and all XML parsers are bound to understand them.
+ * Note that in the std case we are not sending a charset encoding mime type along with http headers, so we are
+ * bound by RFC 3023 to emit strict us-ascii.
+ *
+ * @todo do a bit of basic benchmarking (strtr vs. str_replace)
+ * @todo make usage of iconv() or recode_string() or mb_string() where available
+ *
+ * @param string $data
+ * @param string $srcEncoding
+ * @param string $destEncoding
+ *
+ * @return string
+ */
+ public function encodeEntities($data, $srcEncoding = '', $destEncoding = '')
+ {
+ if ($srcEncoding == '') {
+ // lame, but we know no better...
+ $srcEncoding = PhpXmlRpc::$xmlrpc_internalencoding;
+ }
+
+ $conversion = strtoupper($srcEncoding . '_' . $destEncoding);
+ switch ($conversion) {
+ case 'ISO-8859-1_':
+ case 'ISO-8859-1_US-ASCII':
+ $escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
+ $escapedData = str_replace($this->xml_iso88591_Entities['in'], $this->xml_iso88591_Entities['out'], $escapedData);
+ break;
+
+ case 'ISO-8859-1_UTF-8':
+ $escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
+ $escapedData = utf8_encode($escapedData);
+ break;
+
+ case 'ISO-8859-1_ISO-8859-1':
+ case 'US-ASCII_US-ASCII':
+ case 'US-ASCII_UTF-8':
+ case 'US-ASCII_':
+ case 'US-ASCII_ISO-8859-1':
+ case 'UTF-8_UTF-8':
+ //case 'CP1252_CP1252':
+ $escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
+ break;
+
+ case 'UTF-8_':
+ case 'UTF-8_US-ASCII':
+ case 'UTF-8_ISO-8859-1':
+ // NB: this will choke on invalid UTF-8, going most likely beyond EOF
+ $escapedData = '';
+ // be kind to users creating string xmlrpc values out of different php types
+ $data = (string)$data;
+ $ns = strlen($data);
+ for ($nn = 0; $nn < $ns; $nn++) {
+ $ch = $data[$nn];
+ $ii = ord($ch);
+ // 7 bits: 0bbbbbbb (127)
+ if ($ii < 128) {
+ /// @todo shall we replace this with a (supposedly) faster str_replace?
+ switch ($ii) {
+ case 34:
+ $escapedData .= '"';
+ break;
+ case 38:
+ $escapedData .= '&';
+ break;
+ case 39:
+ $escapedData .= ''';
+ break;
+ case 60:
+ $escapedData .= '<';
+ break;
+ case 62:
+ $escapedData .= '>';
+ break;
+ default:
+ $escapedData .= $ch;
+ } // switch
+ } // 11 bits: 110bbbbb 10bbbbbb (2047)
+ elseif ($ii >> 5 == 6) {
+ $b1 = ($ii & 31);
+ $ii = ord($data[$nn + 1]);
+ $b2 = ($ii & 63);
+ $ii = ($b1 * 64) + $b2;
+ $ent = sprintf('&#%d;', $ii);
+ $escapedData .= $ent;
+ $nn += 1;
+ } // 16 bits: 1110bbbb 10bbbbbb 10bbbbbb
+ elseif ($ii >> 4 == 14) {
+ $b1 = ($ii & 15);
+ $ii = ord($data[$nn + 1]);
+ $b2 = ($ii & 63);
+ $ii = ord($data[$nn + 2]);
+ $b3 = ($ii & 63);
+ $ii = ((($b1 * 64) + $b2) * 64) + $b3;
+ $ent = sprintf('&#%d;', $ii);
+ $escapedData .= $ent;
+ $nn += 2;
+ } // 21 bits: 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
+ elseif ($ii >> 3 == 30) {
+ $b1 = ($ii & 7);
+ $ii = ord($data[$nn + 1]);
+ $b2 = ($ii & 63);
+ $ii = ord($data[$nn + 2]);
+ $b3 = ($ii & 63);
+ $ii = ord($data[$nn + 3]);
+ $b4 = ($ii & 63);
+ $ii = ((((($b1 * 64) + $b2) * 64) + $b3) * 64) + $b4;
+ $ent = sprintf('&#%d;', $ii);
+ $escapedData .= $ent;
+ $nn += 3;
+ }
+ }
+
+ // when converting to latin-1, do not be so eager with using entities for characters 160-255
+ if ($conversion == 'UTF-8_ISO-8859-1') {
+ $escapedData = str_replace(array_slice($this->xml_iso88591_Entities['out'], 32), array_slice($this->xml_iso88591_Entities['in'], 32), $escapedData);
+ }
+ break;
+
+ /*
+ case 'CP1252_':
+ case 'CP1252_US-ASCII':
+ $escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
+ $escapedData = str_replace($this->xml_iso88591_Entities']['in'], $this->xml_iso88591_Entities['out'], $escapedData);
+ $escapedData = str_replace($this->xml_cp1252_Entities['in'], $this->xml_cp1252_Entities['out'], $escapedData);
+ break;
+ case 'CP1252_UTF-8':
+ $escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
+ /// @todo we could use real UTF8 chars here instead of xml entities... (note that utf_8 encode all allone will NOT convert them)
+ $escapedData = str_replace($this->xml_cp1252_Entities['in'], $this->xml_cp1252_Entities['out'], $escapedData);
+ $escapedData = utf8_encode($escapedData);
+ break;
+ case 'CP1252_ISO-8859-1':
+ $escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
+ // we might as well replace all funky chars with a '?' here, but we are kind and leave it to the receiving application layer to decide what to do with these weird entities...
+ $escapedData = str_replace($this->xml_cp1252_Entities['in'], $this->xml_cp1252_Entities['out'], $escapedData);
+ break;
+ */
+
+ default:
+ $escapedData = '';
+ error_log('XML-RPC: ' . __METHOD__ . ": Converting from $srcEncoding to $destEncoding: not supported...");
+ }
+
+ return $escapedData;
+ }
+
+ /**
+ * 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.
+ *
+ * @param string $encoding charset to be tested
+ * @param string|array $validList comma separated list of valid charsets (or array of charsets)
+ *
+ * @return bool
+ */
+ public function isValidCharset($encoding, $validList)
+ {
+ if (is_string($validList)) {
+ $validList = explode(',', $validList);
+ }
+ if (@in_array(strtoupper($encoding), $validList)) {
+ return true;
+ } else {
+ if (array_key_exists($encoding, $this->charset_supersets)) {
+ foreach ($validList as $allowed) {
+ if (in_array($allowed, $this->charset_supersets[$encoding])) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+ }
+
+ /**
+ * Used only for backwards compatibility
+ * @deprecated
+ *
+ * @param string $charset
+ *
+ * @return array
+ *
+ * @throws \Exception for unknown/unsupported charsets
+ */
+ public function getEntities($charset)
+ {
+ switch ($charset)
+ {
+ case 'iso88591':
+ return $this->xml_iso88591_Entities;
+ default:
+ throw new \Exception('Unsupported charset: ' . $charset);
+ }
+ }
+
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc\Helper;
+
+class Date
+{
+ /**
+ * 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
+ *
+ * @param int $timet (timestamp)
+ * @param int $utc (0 or 1)
+ *
+ * @return string
+ */
+ public static function iso8601Encode($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.
+ *
+ * @param string $idate
+ * @param int $utc either 0 or 1
+ *
+ * @return int (datetime)
+ */
+ public static function iso8601Decode($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;
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc\Helper;
+
+use PhpXmlRpc\PhpXmlRpc;
+
+class Http
+{
+ /**
+ * Decode a string that is encoded with "chunked" transfer encoding as defined in rfc2068 par. 19.4.6
+ * Code shamelessly stolen from nusoap library by Dietrich Ayala.
+ *
+ * @param string $buffer the string to be decoded
+ *
+ * @return string
+ */
+ public static function decodeChunked($buffer)
+ {
+ // length := 0
+ $length = 0;
+ $new = '';
+
+ // read chunk-size, chunk-extension (if any) and crlf
+ // get the position of the linebreak
+ $chunkEnd = strpos($buffer, "\r\n") + 2;
+ $temp = substr($buffer, 0, $chunkEnd);
+ $chunkSize = hexdec(trim($temp));
+ $chunkStart = $chunkEnd;
+ while ($chunkSize > 0) {
+ $chunkEnd = strpos($buffer, "\r\n", $chunkStart + $chunkSize);
+
+ // 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);
+ $chunkSize = hexdec(trim($temp));
+ $chunkStart = $chunkEnd;
+ }
+
+ return $new;
+ }
+
+ /**
+ * Parses HTTP an http response headers and separates them from the body.
+ *
+ * @param string $data the http response,headers and body. It will be stripped of headers
+ * @param bool $headersProcessed when true, we assume that response inflating and dechunking has been already carried out
+ *
+ * @return array with keys 'headers' and 'cookies'
+ * @throws \Exception
+ */
+ public function parseResponseHeaders(&$data, $headersProcessed = false, $debug=0)
+ {
+ $httpResponse = array('raw_data' => $data, 'headers'=> array(), 'cookies' => array());
+
+ // Support "web-proxy-tunelling" connections for https through proxies
+ if (preg_match('/^HTTP\/1\.[0-1] 200 Connection established/', $data)) {
+ // Look for CR/LF or simple LF as line separator,
+ // (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;
+ }
+ }
+ if ($bd) {
+ // this filters out all http headers from proxy.
+ // maybe we could take them into account, too?
+ $data = substr($data, $bd);
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': HTTPS via proxy error, tunnel connection possibly failed');
+ throw new \Exception(PhpXmlRpc::$xmlrpcstr['http_error'] . ' (HTTPS via proxy error, tunnel connection possibly failed)', PhpXmlRpc::$xmlrpcerr['http_error']);
+ }
+ }
+
+ // Strip HTTP 1.1 100 Continue header if present
+ while (preg_match('/^HTTP\/1\.1 1[0-9]{2} /', $data)) {
+ $pos = strpos($data, 'HTTP', 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: ' . __METHOD__ . ': HTTP error, got response: ' . $errstr);
+ throw new \Exception(PhpXmlRpc::$xmlrpcstr['http_error'] . ' (' . $errstr . ')', PhpXmlRpc::$xmlrpcerr['http_error']);
+ }
+
+ // 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?
+ // we could take some action here instead of going on...
+ $bd = 0;
+ }
+ }
+ // be tolerant to line endings, and extra empty lines
+ $ar = preg_split("/\r?\n/", trim(substr($data, 0, $pos)));
+ while (list(, $line) = @each($ar)) {
+ // take care of multi-line headers and cookies
+ $arr = explode(':', $line, 2);
+ if (count($arr) > 1) {
+ $headerName = 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 $xmlrpc->_xh['headers'][$headerName]
+ /// instead of replacing it for those...
+ if ($headerName == 'set-cookie' || $headerName == 'set-cookie2') {
+ if ($headerName == 'set-cookie2') {
+ // version 2 cookies:
+ // there could be many cookies on one line, comma separated
+ $cookies = explode(',', $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($httpResponse['headers'][$headerName])) {
+ $httpResponse['headers'][$headerName] .= ', ' . trim($cookie);
+ } else {
+ $httpResponse['headers'][$headerName] = trim($cookie);
+ }
+ // parse cookie attributes, in case user wants to correctly honour them
+ // feature creep: only allow rfc-compliant cookie attributes?
+ // @todo support for server sending multiple time cookie with same name, but using different PATHs
+ $cookie = explode(';', $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;
+ $httpResponse['cookies'][$tag] = array();
+ $httpResponse['cookies'][$cookiename]['value'] = urldecode($val);
+ } else {
+ if ($tag != 'value') {
+ $httpResponse['cookies'][$cookiename][$tag] = $val;
+ }
+ }
+ }
+ }
+ } else {
+ $httpResponse['headers'][$headerName] = trim($arr[1]);
+ }
+ } elseif (isset($headerName)) {
+ /// @todo version1 cookies might span multiple lines, thus breaking the parsing above
+ $httpResponse['headers'][$headerName] .= ' ' . trim($line);
+ }
+ }
+
+ $data = substr($data, $bd);
+
+ if ($debug && count($httpResponse['headers'])) {
+ $msg = '';
+ foreach ($httpResponse['headers'] as $header => $value) {
+ $msg .= "HEADER: $header: $value\n";
+ }
+ foreach ($httpResponse['cookies'] as $header => $value) {
+ $msg .= "COOKIE: $header={$value['value']}\n";
+ }
+ Logger::instance()->debugMessage($msg);
+ }
+
+ // if CURL was used for the call, http headers have been processed,
+ // and dechunking + reinflating have been carried out
+ if (!$headersProcessed) {
+ // Decode chunked encoding sent by http 1.1 servers
+ if (isset($httpResponse['headers']['transfer-encoding']) && $httpResponse['headers']['transfer-encoding'] == 'chunked') {
+ if (!$data = Http::decodeChunked($data)) {
+ error_log('XML-RPC: ' . __METHOD__ . ': errors occurred when trying to rebuild the chunked data received from server');
+ throw new \Exception(PhpXmlRpc::$xmlrpcstr['dechunk_fail'], PhpXmlRpc::$xmlrpcerr['dechunk_fail']);
+ }
+ }
+
+ // Decode gzip-compressed stuff
+ // code shamelessly inspired from nusoap library by Dietrich Ayala
+ if (isset($httpResponse['headers']['content-encoding'])) {
+ $httpResponse['headers']['content-encoding'] = str_replace('x-', '', $httpResponse['headers']['content-encoding']);
+ if ($httpResponse['headers']['content-encoding'] == 'deflate' || $httpResponse['headers']['content-encoding'] == 'gzip') {
+ // if decoding works, use it. else assume data wasn't gzencoded
+ if (function_exists('gzinflate')) {
+ if ($httpResponse['headers']['content-encoding'] == 'deflate' && $degzdata = @gzuncompress($data)) {
+ $data = $degzdata;
+ if ($debug) {
+ Logger::instance()->debugMessage("---INFLATED RESPONSE---[" . strlen($data) . " chars]---\n$data\n---END---");
+ }
+ } elseif ($httpResponse['headers']['content-encoding'] == 'gzip' && $degzdata = @gzinflate(substr($data, 10))) {
+ $data = $degzdata;
+ if ($debug) {
+ Logger::instance()->debugMessage("---INFLATED RESPONSE---[" . strlen($data) . " chars]---\n$data\n---END---");
+ }
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': errors occurred when trying to decode the deflated data received from server');
+ throw new \Exception(PhpXmlRpc::$xmlrpcstr['decompress_fail'], PhpXmlRpc::$xmlrpcerr['decompress_fail']);
+ }
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': the server sent deflated data. Your php install must have the Zlib extension compiled in to support this.');
+ throw new \Exception(PhpXmlRpc::$xmlrpcstr['cannot_decompress'], PhpXmlRpc::$xmlrpcerr['cannot_decompress']);
+ }
+ }
+ }
+ } // end of 'if needed, de-chunk, re-inflate response'
+
+ return $httpResponse;
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc\Helper;
+
+class Logger
+{
+ protected static $instance = null;
+
+ /**
+ * This class is singleton, so that later we can move to DI patterns.
+ *
+ * @return Logger
+ */
+ public static function instance()
+ {
+ if (self::$instance === null) {
+ self::$instance = new self();
+ }
+
+ return self::$instance;
+ }
+
+ /**
+ * Echoes a debug message, taking care of escaping it when not in console mode.
+ * NB: if the encoding of the message is not known or wrong, and we are working in web mode, there is no guarantee
+ * of 100% accuracy, which kind of defeats the purpose of debugging
+ *
+ * @param string $message
+ * @param string $encoding
+ */
+ public function debugMessage($message, $encoding=null)
+ {
+ // US-ASCII is a warning for PHP and a fatal for HHVM
+ if ($encoding == 'US-ASCII') {
+ $encoding = 'UTF-8';
+ }
+
+ if (PHP_SAPI != 'cli') {
+ $flags = ENT_COMPAT | ENT_HTML401 | ENT_SUBSTITUTE;
+ if ($encoding != null) {
+ print "<PRE>\n".htmlentities($message, $flags, $encoding)."\n</PRE>";
+ } else {
+ print "<PRE>\n".htmlentities($message, $flags)."\n</PRE>";
+ }
+ } else {
+ print "\n$message\n";
+ }
+
+ // let the user see this now in case there's a time out later...
+ flush();
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc\Helper;
+
+use PhpXmlRpc\PhpXmlRpc;
+use PhpXmlRpc\Value;
+
+/**
+ * Deals with parsing the XML.
+ */
+class XMLParser
+{
+ // used to store state during parsing
+ // quick explanation of components:
+ // ac - used to accumulate values
+ // stack - array with genealogy of xml elements names:
+ // used to validate nesting of xmlrpc elements
+ // valuestack - array used for parsing arrays and structs
+ // lv - used to indicate "looking for a value": implements
+ // the logic to allow values with no types to be strings
+ // isf - used to indicate a parsing fault (2) or xmlrpc response fault (1)
+ // isf_reason - used for storing xmlrpc response fault string
+ // method - used to store method name
+ // params - used to store parameters in method calls
+ // pt - used to store the type of each received parameter. Useful if parameters are automatically decoded to php values
+ // rt - 'methodcall or 'methodresponse'
+ public $_xh = array(
+ 'ac' => '',
+ 'stack' => array(),
+ 'valuestack' => array(),
+ 'isf' => 0,
+ 'isf_reason' => '',
+ 'method' => false, // so we can check later if we got a methodname or not
+ 'params' => array(),
+ 'pt' => array(),
+ 'rt' => '',
+ );
+
+ public $xmlrpc_valid_parents = array(
+ 'VALUE' => array('MEMBER', 'DATA', 'PARAM', 'FAULT'),
+ 'BOOLEAN' => array('VALUE'),
+ 'I4' => array('VALUE'),
+ 'I8' => array('VALUE'),
+ 'EX:I8' => array('VALUE'),
+ 'INT' => array('VALUE'),
+ 'STRING' => array('VALUE'),
+ 'DOUBLE' => array('VALUE'),
+ 'DATETIME.ISO8601' => array('VALUE'),
+ 'BASE64' => array('VALUE'),
+ 'MEMBER' => array('STRUCT'),
+ 'NAME' => array('MEMBER'),
+ 'DATA' => array('ARRAY'),
+ 'ARRAY' => array('VALUE'),
+ 'STRUCT' => array('VALUE'),
+ 'PARAM' => array('PARAMS'),
+ 'METHODNAME' => array('METHODCALL'),
+ 'PARAMS' => array('METHODCALL', 'METHODRESPONSE'),
+ 'FAULT' => array('METHODRESPONSE'),
+ 'NIL' => array('VALUE'), // only used when extension activated
+ 'EX:NIL' => array('VALUE'), // only used when extension activated
+ );
+
+ /**
+ * xml parser handler function for opening element tags.
+ */
+ public function xmlrpc_se($parser, $name, $attrs, $acceptSingleVals = false)
+ {
+ // if invalid xmlrpc already detected, skip all processing
+ if ($this->_xh['isf'] < 2) {
+ // check for correct element nesting
+ // top level element can only be of 2 types
+ /// @todo optimization creep: save this check into a bool variable, instead of using count() every time:
+ /// there is only a single top level element in xml anyway
+ if (count($this->_xh['stack']) == 0) {
+ if ($name != 'METHODRESPONSE' && $name != 'METHODCALL' && (
+ $name != 'VALUE' && !$acceptSingleVals)
+ ) {
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = 'missing top level xmlrpc element';
+
+ return;
+ } else {
+ $this->_xh['rt'] = strtolower($name);
+ }
+ } else {
+ // not top level element: see if parent is OK
+ $parent = end($this->_xh['stack']);
+ if (!array_key_exists($name, $this->xmlrpc_valid_parents) || !in_array($parent, $this->xmlrpc_valid_parents[$name])) {
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "xmlrpc element $name cannot be child of $parent";
+
+ return;
+ }
+ }
+
+ switch ($name) {
+ // optimize for speed switch cases: most common cases first
+ case 'VALUE':
+ /// @todo we could check for 2 VALUE elements inside a MEMBER or PARAM element
+ $this->_xh['vt'] = 'value'; // indicator: no value found yet
+ $this->_xh['ac'] = '';
+ $this->_xh['lv'] = 1;
+ $this->_xh['php_class'] = null;
+ break;
+ case 'I8':
+ case 'EX:I8':
+ if (PHP_INT_SIZE === 4) {
+ /// INVALID ELEMENT: RAISE ISF so that it is later recognized!!!
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "Received i8 element but php is compiled in 32 bit mode";
+
+ return;
+ }
+ // fall through voluntarily
+ case 'I4':
+ case 'INT':
+ case 'STRING':
+ case 'BOOLEAN':
+ case 'DOUBLE':
+ case 'DATETIME.ISO8601':
+ case 'BASE64':
+ if ($this->_xh['vt'] != 'value') {
+ // two data elements inside a value: an error occurred!
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "$name element following a {$this->_xh['vt']} element inside a single value";
+
+ return;
+ }
+ $this->_xh['ac'] = ''; // reset the accumulator
+ break;
+ case 'STRUCT':
+ case 'ARRAY':
+ if ($this->_xh['vt'] != 'value') {
+ //two data elements inside a value: an error occurred!
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "$name element following a {$this->_xh['vt']} element inside a single value";
+
+ return;
+ }
+ // create an empty array to hold child values, and push it onto appropriate stack
+ $curVal = array();
+ $curVal['values'] = array();
+ $curVal['type'] = $name;
+ // check for out-of-band information to rebuild php objs
+ // and in case it is found, save it
+ if (@isset($attrs['PHP_CLASS'])) {
+ $curVal['php_class'] = $attrs['PHP_CLASS'];
+ }
+ $this->_xh['valuestack'][] = $curVal;
+ $this->_xh['vt'] = 'data'; // be prepared for a data element next
+ break;
+ case 'DATA':
+ if ($this->_xh['vt'] != 'data') {
+ //two data elements inside a value: an error occurred!
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "found two data elements inside an array element";
+
+ return;
+ }
+ case 'METHODCALL':
+ case 'METHODRESPONSE':
+ case 'PARAMS':
+ // valid elements that add little to processing
+ break;
+ case 'METHODNAME':
+ case 'NAME':
+ /// @todo we could check for 2 NAME elements inside a MEMBER element
+ $this->_xh['ac'] = '';
+ break;
+ case 'FAULT':
+ $this->_xh['isf'] = 1;
+ break;
+ case 'MEMBER':
+ $this->_xh['valuestack'][count($this->_xh['valuestack']) - 1]['name'] = ''; // set member name to null, in case we do not find in the xml later on
+ //$this->_xh['ac']='';
+ // Drop trough intentionally
+ case 'PARAM':
+ // clear value type, so we can check later if no value has been passed for this param/member
+ $this->_xh['vt'] = null;
+ break;
+ case 'NIL':
+ case 'EX:NIL':
+ if (PhpXmlRpc::$xmlrpc_null_extension) {
+ if ($this->_xh['vt'] != 'value') {
+ //two data elements inside a value: an error occurred!
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "$name element following a {$this->_xh['vt']} element inside a single value";
+
+ return;
+ }
+ $this->_xh['ac'] = ''; // reset the accumulator
+ break;
+ }
+ // we do not support the <NIL/> extension, so
+ // drop through intentionally
+ default:
+ /// INVALID ELEMENT: RAISE ISF so that it is later recognized!!!
+ $this->_xh['isf'] = 2;
+ $this->_xh['isf_reason'] = "found not-xmlrpc xml element $name";
+ break;
+ }
+
+ // Save current element name to stack, to validate nesting
+ $this->_xh['stack'][] = $name;
+
+ /// @todo optimization creep: move this inside the big switch() above
+ if ($name != 'VALUE') {
+ $this->_xh['lv'] = 0;
+ }
+ }
+ }
+
+ /**
+ * Used in decoding xml chunks that might represent single xmlrpc values.
+ */
+ public function xmlrpc_se_any($parser, $name, $attrs)
+ {
+ $this->xmlrpc_se($parser, $name, $attrs, true);
+ }
+
+ /**
+ * xml parser handler function for close element tags.
+ */
+ public function xmlrpc_ee($parser, $name, $rebuildXmlrpcvals = true)
+ {
+ if ($this->_xh['isf'] < 2) {
+ // push this element name from stack
+ // NB: if XML validates, correct opening/closing is guaranteed and
+ // we do not have to check for $name == $currElem.
+ // we also checked for proper nesting at start of elements...
+ $currElem = array_pop($this->_xh['stack']);
+
+ switch ($name) {
+ case 'VALUE':
+ // This if() detects if no scalar was inside <VALUE></VALUE>
+ if ($this->_xh['vt'] == 'value') {
+ $this->_xh['value'] = $this->_xh['ac'];
+ $this->_xh['vt'] = Value::$xmlrpcString;
+ }
+
+ if ($rebuildXmlrpcvals) {
+ // build the xmlrpc val out of the data received, and substitute it
+ $temp = new Value($this->_xh['value'], $this->_xh['vt']);
+ // in case we got info about underlying php class, save it
+ // in the object we're rebuilding
+ if (isset($this->_xh['php_class'])) {
+ $temp->_php_class = $this->_xh['php_class'];
+ }
+ // check if we are inside an array or struct:
+ // if value just built is inside an array, let's move it into array on the stack
+ $vscount = count($this->_xh['valuestack']);
+ if ($vscount && $this->_xh['valuestack'][$vscount - 1]['type'] == 'ARRAY') {
+ $this->_xh['valuestack'][$vscount - 1]['values'][] = $temp;
+ } else {
+ $this->_xh['value'] = $temp;
+ }
+ } else {
+ /// @todo this needs to treat correctly php-serialized objects,
+ /// since std deserializing is done by php_xmlrpc_decode,
+ /// which we will not be calling...
+ if (isset($this->_xh['php_class'])) {
+ }
+
+ // check if we are inside an array or struct:
+ // if value just built is inside an array, let's move it into array on the stack
+ $vscount = count($this->_xh['valuestack']);
+ if ($vscount && $this->_xh['valuestack'][$vscount - 1]['type'] == 'ARRAY') {
+ $this->_xh['valuestack'][$vscount - 1]['values'][] = $this->_xh['value'];
+ }
+ }
+ break;
+ case 'BOOLEAN':
+ case 'I4':
+ case 'I8':
+ case 'EX:I8':
+ case 'INT':
+ case 'STRING':
+ case 'DOUBLE':
+ case 'DATETIME.ISO8601':
+ case 'BASE64':
+ $this->_xh['vt'] = strtolower($name);
+ /// @todo: optimization creep - remove the if/elseif cycle below
+ /// since the case() in which we are already did that
+ if ($name == 'STRING') {
+ $this->_xh['value'] = $this->_xh['ac'];
+ } elseif ($name == 'DATETIME.ISO8601') {
+ if (!preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $this->_xh['ac'])) {
+ error_log('XML-RPC: ' . __METHOD__ . ': invalid value received in DATETIME: ' . $this->_xh['ac']);
+ }
+ $this->_xh['vt'] = Value::$xmlrpcDateTime;
+ $this->_xh['value'] = $this->_xh['ac'];
+ } elseif ($name == 'BASE64') {
+ /// @todo check for failure of base64 decoding / catch warnings
+ $this->_xh['value'] = base64_decode($this->_xh['ac']);
+ } elseif ($name == 'BOOLEAN') {
+ // special case here: we translate boolean 1 or 0 into PHP
+ // constants true or false.
+ // Strings 'true' and 'false' are accepted, even though the
+ // spec never mentions them (see eg. Blogger api docs)
+ // NB: this simple checks helps a lot sanitizing input, ie no
+ // security problems around here
+ if ($this->_xh['ac'] == '1' || strcasecmp($this->_xh['ac'], 'true') == 0) {
+ $this->_xh['value'] = true;
+ } else {
+ // log if receiving something strange, even though we set the value to false anyway
+ if ($this->_xh['ac'] != '0' && strcasecmp($this->_xh['ac'], 'false') != 0) {
+ error_log('XML-RPC: ' . __METHOD__ . ': invalid value received in BOOLEAN: ' . $this->_xh['ac']);
+ }
+ $this->_xh['value'] = false;
+ }
+ } elseif ($name == 'DOUBLE') {
+ // we have a DOUBLE
+ // we must check that only 0123456789-.<space> are characters here
+ // NOTE: regexp could be much stricter than this...
+ if (!preg_match('/^[+-eE0123456789 \t.]+$/', $this->_xh['ac'])) {
+ /// @todo: find a better way of throwing an error than this!
+ error_log('XML-RPC: ' . __METHOD__ . ': non numeric value received in DOUBLE: ' . $this->_xh['ac']);
+ $this->_xh['value'] = 'ERROR_NON_NUMERIC_FOUND';
+ } else {
+ // it's ok, add it on
+ $this->_xh['value'] = (double)$this->_xh['ac'];
+ }
+ } else {
+ // we have an I4/I8/INT
+ // we must check that only 0123456789-<space> are characters here
+ if (!preg_match('/^[+-]?[0123456789 \t]+$/', $this->_xh['ac'])) {
+ /// @todo find a better way of throwing an error than this!
+ error_log('XML-RPC: ' . __METHOD__ . ': non numeric value received in INT: ' . $this->_xh['ac']);
+ $this->_xh['value'] = 'ERROR_NON_NUMERIC_FOUND';
+ } else {
+ // it's ok, add it on
+ $this->_xh['value'] = (int)$this->_xh['ac'];
+ }
+ }
+ $this->_xh['lv'] = 3; // indicate we've found a value
+ break;
+ case 'NAME':
+ $this->_xh['valuestack'][count($this->_xh['valuestack']) - 1]['name'] = $this->_xh['ac'];
+ break;
+ case 'MEMBER':
+ // add to array in the stack the last element built,
+ // unless no VALUE was found
+ if ($this->_xh['vt']) {
+ $vscount = count($this->_xh['valuestack']);
+ $this->_xh['valuestack'][$vscount - 1]['values'][$this->_xh['valuestack'][$vscount - 1]['name']] = $this->_xh['value'];
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': missing VALUE inside STRUCT in received xml');
+ }
+ break;
+ case 'DATA':
+ $this->_xh['vt'] = null; // reset this to check for 2 data elements in a row - even if they're empty
+ break;
+ case 'STRUCT':
+ case 'ARRAY':
+ // fetch out of stack array of values, and promote it to current value
+ $currVal = array_pop($this->_xh['valuestack']);
+ $this->_xh['value'] = $currVal['values'];
+ $this->_xh['vt'] = strtolower($name);
+ if (isset($currVal['php_class'])) {
+ $this->_xh['php_class'] = $currVal['php_class'];
+ }
+ break;
+ case 'PARAM':
+ // add to array of params the current value,
+ // unless no VALUE was found
+ if ($this->_xh['vt']) {
+ $this->_xh['params'][] = $this->_xh['value'];
+ $this->_xh['pt'][] = $this->_xh['vt'];
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': missing VALUE inside PARAM in received xml');
+ }
+ break;
+ case 'METHODNAME':
+ $this->_xh['method'] = preg_replace('/^[\n\r\t ]+/', '', $this->_xh['ac']);
+ break;
+ case 'NIL':
+ case 'EX:NIL':
+ if (PhpXmlRpc::$xmlrpc_null_extension) {
+ $this->_xh['vt'] = 'null';
+ $this->_xh['value'] = null;
+ $this->_xh['lv'] = 3;
+ break;
+ }
+ // drop through intentionally if nil extension not enabled
+ case 'PARAMS':
+ case 'FAULT':
+ case 'METHODCALL':
+ case 'METHORESPONSE':
+ break;
+ default:
+ // End of INVALID ELEMENT!
+ // shall we add an assert here for unreachable code???
+ break;
+ }
+ }
+ }
+
+ /**
+ * Used in decoding xmlrpc requests/responses without rebuilding xmlrpc Values.
+ */
+ public function xmlrpc_ee_fast($parser, $name)
+ {
+ $this->xmlrpc_ee($parser, $name, false);
+ }
+
+ /**
+ * xml parser handler function for character data.
+ */
+ public function xmlrpc_cd($parser, $data)
+ {
+ // skip processing if xml fault already detected
+ if ($this->_xh['isf'] < 2) {
+ // "lookforvalue==3" means that we've found an entire value
+ // and should discard any further character data
+ if ($this->_xh['lv'] != 3) {
+ $this->_xh['ac'] .= $data;
+ }
+ }
+ }
+
+ /**
+ * xml parser handler function for 'other stuff', ie. not char data or
+ * element start/end tag. In fact it only gets called on unknown entities...
+ */
+ public function xmlrpc_dh($parser, $data)
+ {
+ // skip processing if xml fault already detected
+ if ($this->_xh['isf'] < 2) {
+ if (substr($data, 0, 1) == '&' && substr($data, -1, 1) == ';') {
+ $this->_xh['ac'] .= $data;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * 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 non conforming (legacy?) clients/servers,
+ * which will be most probably using UTF-8 anyway...
+ * In order of importance checks:
+ * 1. http headers
+ * 2. BOM
+ * 3. XML declaration
+ * 4. guesses using mb_detect_encoding()
+ *
+ * @param string $httpHeader the http Content-type header
+ * @param string $xmlChunk xml content buffer
+ * @param string $encodingPrefs comma separated list of character encodings to be used as default (when mb extension is enabled).
+ * This can also be set globally using PhpXmlRpc::$xmlrpc_detectencodings
+ * @return string the encoding determined. Null if it can't be determined and mbstring is enabled,
+ * PhpXmlRpc::$xmlrpc_defencoding if it can't be determined and mbstring is not enabled
+ *
+ * @todo explore usage of mb_http_input(): does it detect http headers + post data? if so, use it instead of hand-detection!!!
+ */
+ public static function guessEncoding($httpHeader = '', $xmlChunk = '', $encodingPrefs = 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)+
+ // quoted string: " (any char but double quotes and control chars)* "
+ // 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
+ // Note 2: we might be removing whitespace/tabs that ought to be left in if
+ // the received charset is a quoted string. But nobody uses such charset names...
+
+ /// @todo this test will pass if ANY header has charset specification, not only Content-Type. Fix it?
+ $matches = array();
+ if (preg_match('/;\s*charset\s*=([^;]+)/i', $httpHeader, $matches)) {
+ return strtoupper(trim($matches[1], " \t\""));
+ }
+
+ // 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 'UCS-4';
+ } elseif (preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlChunk)) {
+ return 'UTF-16';
+ } elseif (preg_match('/^(\xEF\xBB\xBF)/', $xmlChunk)) {
+ return 'UTF-8';
+ }
+
+ // 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
+ if (extension_loaded('mbstring')) {
+ if ($encodingPrefs == null && PhpXmlRpc::$xmlrpc_detectencodings != null) {
+ $encodingPrefs = PhpXmlRpc::$xmlrpc_detectencodings;
+ }
+ if ($encodingPrefs) {
+ $enc = mb_detect_encoding($xmlChunk, $encodingPrefs);
+ } 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 == 'ASCII') {
+ $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 PhpXmlRpc::$xmlrpc_defencoding;
+ }
+ }
+
+ /**
+ * Helper function: checks if an xml chunk as a charset declaration (BOM or in the xml declaration)
+ *
+ * @param string $xmlChunk
+ * @return bool
+ */
+ public static function hasEncoding($xmlChunk)
+ {
+ // 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)
+ if (preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlChunk)) {
+ return true;
+ } elseif (preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlChunk)) {
+ return true;
+ } elseif (preg_match('/^(\xEF\xBB\xBF)/', $xmlChunk)) {
+ return true;
+ }
+
+ // 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 true;
+ }
+
+ return false;
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+/**
+ * Manages global configuration for operation of the library.
+ */
+class PhpXmlRpc
+{
+ static public $xmlrpcerr = array(
+ 'unknown_method' => 1,
+ 'invalid_return' => 2,
+ 'incorrect_params' => 3,
+ 'introspect_unknown' => 4,
+ 'http_error' => 5,
+ 'no_data' => 6,
+ 'no_ssl' => 7,
+ 'curl_fail' => 8,
+ 'invalid_request' => 15,
+ 'no_curl' => 16,
+ 'server_error' => 17,
+ 'multicall_error' => 18,
+ 'multicall_notstruct' => 9,
+ 'multicall_nomethod' => 10,
+ 'multicall_notstring' => 11,
+ 'multicall_recursion' => 12,
+ 'multicall_noparams' => 13,
+ 'multicall_notarray' => 14,
+
+ 'cannot_decompress' => 103,
+ 'decompress_fail' => 104,
+ 'dechunk_fail' => 105,
+ 'server_cannot_decompress' => 106,
+ 'server_decompress_fail' => 107,
+ );
+
+ static public $xmlrpcstr = array(
+ 'unknown_method' => 'Unknown method',
+ 'invalid_return' => 'Invalid return payload: enable debugging to examine incoming payload',
+ 'incorrect_params' => 'Incorrect parameters passed to method',
+ 'introspect_unknown' => "Can't introspect: method unknown",
+ 'http_error' => "Didn't receive 200 OK from remote server.",
+ 'no_data' => 'No data received from server.',
+ 'no_ssl' => 'No SSL support compiled in.',
+ 'curl_fail' => 'CURL error',
+ 'invalid_request' => 'Invalid request payload',
+ 'no_curl' => 'No CURL support compiled in.',
+ 'server_error' => 'Internal server error',
+ 'multicall_error' => 'Received from server invalid multicall response',
+ 'multicall_notstruct' => 'system.multicall expected struct',
+ 'multicall_nomethod' => 'missing methodName',
+ 'multicall_notstring' => 'methodName is not a string',
+ 'multicall_recursion' => 'recursive system.multicall forbidden',
+ 'multicall_noparams' => 'missing params',
+ 'multicall_notarray' => 'params is not an array',
+
+ 'cannot_decompress' => 'Received from server compressed HTTP and cannot decompress',
+ 'decompress_fail' => 'Received from server invalid compressed HTTP',
+ 'dechunk_fail' => 'Received from server invalid chunked HTTP',
+ 'server_cannot_decompress' => 'Received from client compressed HTTP request and cannot decompress',
+ 'server_decompress_fail' => 'Received from client invalid compressed HTTP request',
+ );
+
+ // The charset encoding used by the server for received requests and
+ // by the client for received responses when received charset cannot be determined
+ // and mbstring extension is not enabled
+ public static $xmlrpc_defencoding = "UTF-8";
+
+ // The list of encodings used by the server for requests and by the client for responses
+ // to detect the charset of the received payload when
+ // - the charset cannot be determined by looking at http headers, xml declaration or BOM
+ // - mbstring extension is enabled
+ public static $xmlrpc_detectencodings = array();
+
+ // The encoding used internally by PHP.
+ // String values received as xml will be converted to this, and php strings will be converted to xml
+ // as if having been coded with this.
+ // Valid also when defining names of xmlrpc methods
+ public static $xmlrpc_internalencoding = "UTF-8";
+
+ public static $xmlrpcName = "XML-RPC for PHP";
+ public static $xmlrpcVersion = "4.2.0";
+
+ // let user errors start at 800
+ public static $xmlrpcerruser = 800;
+ // let XML parse errors start at 100
+ public static $xmlrpcerrxml = 100;
+
+ // set to TRUE to enable correct decoding of <NIL/> and <EX:NIL/> values
+ public static $xmlrpc_null_extension = false;
+
+ // set to TRUE to enable encoding of php NULL values to <EX:NIL/> instead of <NIL/>
+ public static $xmlrpc_null_apache_encoding = false;
+
+ public static $xmlrpc_null_apache_encoding_ns = "http://ws.apache.org/xmlrpc/namespaces/extensions";
+
+ /**
+ * A function to be used for compatibility with legacy code: it creates all global variables which used to be declared,
+ * such as library version etc...
+ */
+ public static function exportGlobals()
+ {
+ $reflection = new \ReflectionClass('PhpXmlRpc\PhpXmlRpc');
+ foreach ($reflection->getStaticProperties() as $name => $value) {
+ $GLOBALS[$name] = $value;
+ }
+
+ // NB: all the variables exported into the global namespace below here do NOT guarantee 100%
+ // compatibility, as they are NOT reimported back during calls to importGlobals()
+
+ $reflection = new \ReflectionClass('PhpXmlRpc\Value');
+ foreach ($reflection->getStaticProperties() as $name => $value) {
+ $GLOBALS[$name] = $value;
+ }
+
+ $parser = new Helper\XMLParser();
+ $reflection = new \ReflectionClass('PhpXmlRpc\Helper\XMLParser');
+ foreach ($reflection->getProperties(\ReflectionProperty::IS_PUBLIC) as $name => $value) {
+ if (in_array($value->getName(), array('xmlrpc_valid_parents')))
+ {
+ $GLOBALS[$value->getName()] = $value->getValue($parser);
+ }
+ }
+
+ $charset = Helper\Charset::instance();
+ $GLOBALS['xml_iso88591_Entities'] = $charset->getEntities('iso88591');
+ }
+
+ /**
+ * A function to be used for compatibility with legacy code: it gets the values of all global variables which used
+ * to be declared, such as library version etc... and sets them to php classes.
+ * It should be used by code which changed the values of those global variables to alter the working of the library.
+ * Example code:
+ * 1. include xmlrpc.inc
+ * 2. set the values, e.g. $GLOBALS['xmlrpc_internalencoding'] = 'UTF-8';
+ * 3. import them: PhpXmlRpc\PhpXmlRpc::importGlobals();
+ * 4. run your own code.
+ */
+ public static function importGlobals()
+ {
+ $reflection = new \ReflectionClass('PhpXmlRpc\PhpXmlRpc');
+ $staticProperties = $reflection->getStaticProperties();
+ foreach ($staticProperties as $name => $value) {
+ if (isset($GLOBALS[$name])) {
+ self::$$name = $GLOBALS[$name];
+ }
+ }
+ }
+
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+use PhpXmlRpc\Helper\Charset;
+use PhpXmlRpc\Helper\Http;
+use PhpXmlRpc\Helper\Logger;
+use PhpXmlRpc\Helper\XMLParser;
+
+/**
+ * This class provides the representation of a request to an XML-RPC server.
+ * A client sends a PhpXmlrpc\Request to a server, and receives back an PhpXmlrpc\Response.
+ */
+class Request
+{
+ /// @todo: do these need to be public?
+ public $payload;
+ public $methodname;
+ public $params = array();
+ public $debug = 0;
+ public $content_type = 'text/xml';
+
+ // holds data while parsing the response. NB: Not a full Response object
+ protected $httpResponse = array();
+
+ /**
+ * @param string $methodName the name of the method to invoke
+ * @param Value[] $params array of parameters to be passed to the method (NB: Value objects, not plain php values)
+ */
+ public function __construct($methodName, $params = array())
+ {
+ $this->methodname = $methodName;
+ foreach ($params as $param) {
+ $this->addParam($param);
+ }
+ }
+
+ public function xml_header($charsetEncoding = '')
+ {
+ if ($charsetEncoding != '') {
+ return "<?xml version=\"1.0\" encoding=\"$charsetEncoding\" ?" . ">\n<methodCall>\n";
+ } else {
+ return "<?xml version=\"1.0\"?" . ">\n<methodCall>\n";
+ }
+ }
+
+ public function xml_footer()
+ {
+ return '</methodCall>';
+ }
+
+ public function createPayload($charsetEncoding = '')
+ {
+ if ($charsetEncoding != '') {
+ $this->content_type = 'text/xml; charset=' . $charsetEncoding;
+ } else {
+ $this->content_type = 'text/xml';
+ }
+ $this->payload = $this->xml_header($charsetEncoding);
+ $this->payload .= '<methodName>' . Charset::instance()->encodeEntities(
+ $this->methodname, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</methodName>\n";
+ $this->payload .= "<params>\n";
+ foreach ($this->params as $p) {
+ $this->payload .= "<param>\n" . $p->serialize($charsetEncoding) .
+ "</param>\n";
+ }
+ $this->payload .= "</params>\n";
+ $this->payload .= $this->xml_footer();
+ }
+
+ /**
+ * Gets/sets the xmlrpc method to be invoked.
+ *
+ * @param string $methodName the method to be set (leave empty not to set it)
+ *
+ * @return string the method that will be invoked
+ */
+ public function method($methodName = '')
+ {
+ if ($methodName != '') {
+ $this->methodname = $methodName;
+ }
+
+ return $this->methodname;
+ }
+
+ /**
+ * Returns xml representation of the message. XML prologue included.
+ *
+ * @param string $charsetEncoding
+ *
+ * @return string the xml representation of the message, xml prologue included
+ */
+ public function serialize($charsetEncoding = '')
+ {
+ $this->createPayload($charsetEncoding);
+
+ return $this->payload;
+ }
+
+ /**
+ * Add a parameter to the list of parameters to be used upon method invocation.
+ *
+ * Checks that $params is actually a Value object and not a plain php value.
+ *
+ * @param Value $param
+ *
+ * @return boolean false on failure
+ */
+ public function addParam($param)
+ {
+ // check: do not add to self params which are not xmlrpc values
+ if (is_object($param) && is_a($param, 'PhpXmlRpc\Value')) {
+ $this->params[] = $param;
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Returns the nth parameter in the request. The index zero-based.
+ *
+ * @param integer $i the index of the parameter to fetch (zero based)
+ *
+ * @return Value the i-th parameter
+ */
+ public function getParam($i)
+ {
+ return $this->params[$i];
+ }
+
+ /**
+ * Returns the number of parameters in the message.
+ *
+ * @return integer the number of parameters currently set
+ */
+ public function getNumParams()
+ {
+ return count($this->params);
+ }
+
+ /**
+ * Given an open file handle, read all data available and parse it as an xmlrpc response.
+ *
+ * NB: the file handle is not closed by this function.
+ * NNB: might have trouble in rare cases to work on network streams, as we check for a read of 0 bytes instead of
+ * feof($fp). But since checking for feof(null) returns false, we would risk an infinite loop in that case,
+ * because we cannot trust the caller to give us a valid pointer to an open file...
+ *
+ * @param resource $fp stream pointer
+ *
+ * @return Response
+ *
+ * @todo add 2nd & 3rd param to be passed to ParseResponse() ???
+ */
+ public function parseResponseFile($fp)
+ {
+ $ipd = '';
+ while ($data = fread($fp, 32768)) {
+ $ipd .= $data;
+ }
+ return $this->parseResponse($ipd);
+ }
+
+ /**
+ * Parse the xmlrpc response contained in the string $data and return a Response object.
+ *
+ * When $this->debug has been set to a value greater than 0, will echo debug messages to screen while decoding.
+ *
+ * @param string $data the xmlrpc response, possibly including http headers
+ * @param bool $headersProcessed when true prevents parsing HTTP headers for interpretation of content-encoding and
+ * consequent decoding
+ * @param string $returnType decides return type, i.e. content of response->value(). Either 'xmlrpcvals', 'xml' or
+ * 'phpvals'
+ *
+ * @return Response
+ */
+ public function parseResponse($data = '', $headersProcessed = false, $returnType = 'xmlrpcvals')
+ {
+ if ($this->debug) {
+ Logger::instance()->debugMessage("---GOT---\n$data\n---END---");
+ }
+
+ $this->httpResponse = array('raw_data' => $data, 'headers' => array(), 'cookies' => array());
+
+ if ($data == '') {
+ error_log('XML-RPC: ' . __METHOD__ . ': no response received from server.');
+ return new Response(0, PhpXmlRpc::$xmlrpcerr['no_data'], PhpXmlRpc::$xmlrpcstr['no_data']);
+ }
+
+ // parse the HTTP headers of the response, if present, and separate them from data
+ if (substr($data, 0, 4) == 'HTTP') {
+ $httpParser = new Http();
+ try {
+ $this->httpResponse = $httpParser->parseResponseHeaders($data, $headersProcessed, $this->debug);
+ } catch(\Exception $e) {
+ $r = new Response(0, $e->getCode(), $e->getMessage());
+ // failed processing of HTTP response headers
+ // save into response obj the full payload received, for debugging
+ $r->raw_data = $data;
+
+ return $r;
+ }
+ }
+
+ // be tolerant of extra whitespace in response body
+ $data = trim($data);
+
+ /// @todo return an error msg if $data=='' ?
+
+ // 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
+ $pos = strrpos($data, '</methodResponse>');
+ if ($pos !== false) {
+ $data = substr($data, 0, $pos + 17);
+ }
+
+ // try to 'guestimate' the character encoding of the received response
+ $respEncoding = XMLParser::guessEncoding(@$this->httpResponse['headers']['content-type'], $data);
+
+ if ($this->debug) {
+ $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);
+ Logger::instance()->debugMessage("---SERVER DEBUG INFO (DECODED) ---\n\t" .
+ str_replace("\n", "\n\t", base64_decode($comments)) . "\n---END---", $respEncoding);
+ }
+ }
+
+ // if user wants back raw xml, give it to him
+ if ($returnType == 'xml') {
+ $r = new Response($data, 0, '', 'xml');
+ $r->hdrs = $this->httpResponse['headers'];
+ $r->_cookies = $this->httpResponse['cookies'];
+ $r->raw_data = $this->httpResponse['raw_data'];
+
+ return $r;
+ }
+
+ if ($respEncoding != '') {
+
+ // Since parsing will fail if charset is not specified in the xml prologue,
+ // the encoding is not UTF8 and there are non-ascii chars in the text, we try to work round that...
+ // The following code might be better for mb_string enabled installs, but
+ // makes the lib about 200% slower...
+ //if (!is_valid_charset($respEncoding, array('UTF-8')))
+ if (!in_array($respEncoding, array('UTF-8', 'US-ASCII')) && !XMLParser::hasEncoding($data)) {
+ if ($respEncoding == 'ISO-8859-1') {
+ $data = utf8_encode($data);
+ } else {
+ if (extension_loaded('mbstring')) {
+ $data = mb_convert_encoding($data, 'UTF-8', $respEncoding);
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of received response: ' . $respEncoding);
+ }
+ }
+ }
+ }
+
+ $parser = xml_parser_create();
+ 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.
+ // What if internal encoding is not in one of the 3 allowed?
+ // we use the broadest one, ie. utf8
+ // This allows to send data which is native in various charset,
+ // by extending xmlrpc_encode_entities() and setting xmlrpc_internalencoding
+ if (!in_array(PhpXmlRpc::$xmlrpc_internalencoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII'))) {
+ xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
+ } else {
+ xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, PhpXmlRpc::$xmlrpc_internalencoding);
+ }
+
+ $xmlRpcParser = new XMLParser();
+ xml_set_object($parser, $xmlRpcParser);
+
+ if ($returnType == 'phpvals') {
+ xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee_fast');
+ } else {
+ xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee');
+ }
+
+ xml_set_character_data_handler($parser, 'xmlrpc_cd');
+ 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 = 'XML error at line 1, check URL';
+ } 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);
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['invalid_return'], PhpXmlRpc::$xmlrpcstr['invalid_return'] . ' (' . $errStr . ')');
+ xml_parser_free($parser);
+ if ($this->debug) {
+ print $errStr;
+ }
+ $r->hdrs = $this->httpResponse['headers'];
+ $r->_cookies = $this->httpResponse['cookies'];
+ $r->raw_data = $this->httpResponse['raw_data'];
+
+ return $r;
+ }
+ xml_parser_free($parser);
+ // second error check: xml well formed but not xml-rpc compliant
+ if ($xmlRpcParser->_xh['isf'] > 1) {
+ if ($this->debug) {
+ /// @todo echo something for user?
+ }
+
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['invalid_return'],
+ PhpXmlRpc::$xmlrpcstr['invalid_return'] . ' ' . $xmlRpcParser->_xh['isf_reason']);
+ }
+ // third error check: parsing of the response has somehow gone boink.
+ // NB: shall we omit this check, since we trust the parsing code?
+ elseif ($returnType == 'xmlrpcvals' && !is_object($xmlRpcParser->_xh['value'])) {
+ // something odd has happened
+ // and it's time to generate a client side error
+ // indicating something odd went on
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['invalid_return'],
+ PhpXmlRpc::$xmlrpcstr['invalid_return']);
+ } else {
+ if ($this->debug > 1) {
+ Logger::instance()->debugMessage(
+ "---PARSED---\n".var_export($xmlRpcParser->_xh['value'], true)."\n---END---"
+ );
+ }
+
+ // note that using =& will raise an error if $xmlRpcParser->_xh['st'] does not generate an object.
+ $v = &$xmlRpcParser->_xh['value'];
+
+ if ($xmlRpcParser->_xh['isf']) {
+ /// @todo we should test here if server sent an int and a string, and/or coerce them into such...
+ if ($returnType == 'xmlrpcvals') {
+ $errNo_v = $v['faultCode'];
+ $errStr_v = $v['faultString'];
+ $errNo = $errNo_v->scalarval();
+ $errStr = $errStr_v->scalarval();
+ } else {
+ $errNo = $v['faultCode'];
+ $errStr = $v['faultString'];
+ }
+
+ if ($errNo == 0) {
+ // FAULT returned, errno needs to reflect that
+ $errNo = -1;
+ }
+
+ $r = new Response(0, $errNo, $errStr);
+ } else {
+ $r = new Response($v, 0, '', $returnType);
+ }
+ }
+
+ $r->hdrs = $this->httpResponse['headers'];
+ $r->_cookies = $this->httpResponse['cookies'];
+ $r->raw_data = $this->httpResponse['raw_data'];
+
+ return $r;
+ }
+
+ /**
+ * Kept the old name even if Request class was renamed, for compatibility.
+ *
+ * @return string
+ */
+ public function kindOf()
+ {
+ return 'msg';
+ }
+
+ /**
+ * Enables/disables the echoing to screen of the xmlrpc responses received.
+ *
+ * @param integer $in values 0, 1, 2 are supported
+ */
+ public function setDebug($in)
+ {
+ $this->debug = $in;
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+use PhpXmlRpc\Helper\Charset;
+
+/**
+ * This class provides the representation of the response of an XML-RPC server.
+ * Server-side, a server method handler will construct a Response and pass it as its return value.
+ * An identical Response object will be returned by the result of an invocation of the send() method of the Client class.
+ */
+class Response
+{
+ /// @todo: do these need to be public?
+ public $val = 0;
+ public $valtyp;
+ public $errno = 0;
+ public $errstr = '';
+ public $payload;
+ public $hdrs = array();
+ public $_cookies = array();
+ public $content_type = 'text/xml';
+ public $raw_data = '';
+
+ /**
+ * @param mixed $val either a Value object, a php value or the xml serialization of an xmlrpc value (a string)
+ * @param integer $fCode set it to anything but 0 to create an error response. In that case, $val is discarded
+ * @param string $fString the error string, in case of an error response
+ * @param string $valType The type of $val passed in. Either 'xmlrpcvals', 'phpvals' or 'xml'. Leave empty to let
+ * the code guess the correct type.
+ *
+ * @todo add check that $val / $fCode / $fString is of correct type???
+ * NB: as of now we do not do it, since it might be either an xmlrpc value or a plain php val, or a complete
+ * xml chunk, depending on usage of Client::send() inside which creator is called...
+ */
+ public function __construct($val, $fCode = 0, $fString = '', $valType = '')
+ {
+ if ($fCode != 0) {
+ // error response
+ $this->errno = $fCode;
+ $this->errstr = $fString;
+ } else {
+ // successful response
+ $this->val = $val;
+ if ($valType == '') {
+ // user did not declare type of response value: try to guess it
+ if (is_object($this->val) && is_a($this->val, 'PhpXmlRpc\Value')) {
+ $this->valtyp = 'xmlrpcvals';
+ } elseif (is_string($this->val)) {
+ $this->valtyp = 'xml';
+ } else {
+ $this->valtyp = 'phpvals';
+ }
+ } else {
+ // user declares type of resp value: believe him
+ $this->valtyp = $valType;
+ }
+ }
+ }
+
+ /**
+ * Returns the error code of the response.
+ *
+ * @return integer the error code of this response (0 for not-error responses)
+ */
+ public function faultCode()
+ {
+ return $this->errno;
+ }
+
+ /**
+ * Returns the error code of the response.
+ *
+ * @return string the error string of this response ('' for not-error responses)
+ */
+ public function faultString()
+ {
+ return $this->errstr;
+ }
+
+ /**
+ * Returns the value received by the server. If the Response's faultCode is non-zero then the value returned by this
+ * method should not be used (it may not even be an object).
+ *
+ * @return Value|string|mixed the Value object returned by the server. Might be an xml string or plain php value
+ * depending on the convention adopted when creating the Response
+ */
+ public function value()
+ {
+ return $this->val;
+ }
+
+ /**
+ * Returns an array with the cookies received from the server.
+ * Array has the form: $cookiename => array ('value' => $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 whether they have to be sent back
+ * with the next request to the server (using Client::setCookie) or not.
+ *
+ * @return array array of cookies received from the server
+ */
+ public function cookies()
+ {
+ return $this->_cookies;
+ }
+
+ /**
+ * Returns xml representation of the response. XML prologue not included.
+ *
+ * @param string $charsetEncoding the charset to be used for serialization. If null, US-ASCII is assumed
+ *
+ * @return string the xml representation of the response
+ *
+ * @throws \Exception
+ */
+ public function serialize($charsetEncoding = '')
+ {
+ if ($charsetEncoding != '') {
+ $this->content_type = 'text/xml; charset=' . $charsetEncoding;
+ } else {
+ $this->content_type = 'text/xml';
+ }
+ if (PhpXmlRpc::$xmlrpc_null_apache_encoding) {
+ $result = "<methodResponse xmlns:ex=\"" . PhpXmlRpc::$xmlrpc_null_apache_encoding_ns . "\">\n";
+ } else {
+ $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>" .
+ Charset::instance()->encodeEntities($this->errstr, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</string></value>\n</member>\n" .
+ "</struct>\n</value>\n</fault>";
+ } else {
+ if (!is_object($this->val) || !is_a($this->val, 'PhpXmlRpc\Value')) {
+ if (is_string($this->val) && $this->valtyp == 'xml') {
+ $result .= "<params>\n<param>\n" .
+ $this->val .
+ "</param>\n</params>";
+ } else {
+ /// @todo try to build something serializable?
+ throw new \Exception('cannot serialize xmlrpc response objects whose content is native php values');
+ }
+ } else {
+ $result .= "<params>\n<param>\n" .
+ $this->val->serialize($charsetEncoding) .
+ "</param>\n</params>";
+ }
+ }
+ $result .= "\n</methodResponse>";
+ $this->payload = $result;
+
+ return $result;
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+use PhpXmlRpc\Helper\XMLParser;
+use PhpXmlRpc\Helper\Charset;
+
+/**
+ * Allows effortless implementation of XML-RPC servers
+ */
+class Server
+{
+ /**
+ * Array defining php functions exposed as xmlrpc methods by this server.
+ */
+ protected $dmap = array();
+
+ /**
+ * Defines how functions in dmap will be invoked: either using an xmlrpc request object
+ * or plain php values.
+ * Valid strings are 'xmlrpcvals', 'phpvals' or 'epivals'
+ */
+ public $functions_parameters_type = 'xmlrpcvals';
+
+ /**
+ * Option used for fine-tuning the encoding the php values returned from
+ * functions registered in the dispatch map when the functions_parameters_types
+ * member is set to 'phpvals'
+ * @see Encoder::encode for a list of values
+ */
+ public $phpvals_encoding_options = array('auto_dates');
+
+ /**
+ * Controls whether the server is going to echo debugging messages back to the client as comments in response body.
+ * Valid values: 0,1,2,3
+ */
+ public $debug = 1;
+
+ /**
+ * Controls behaviour of server when the invoked user function throws an exception:
+ * 0 = catch it and return an 'internal error' xmlrpc response (default)
+ * 1 = catch it and return an xmlrpc response with the error corresponding to the exception
+ * 2 = allow the exception to float to the upper layers
+ */
+ public $exception_handling = 0;
+
+ /**
+ * When set to true, it will enable HTTP compression of the response, in case
+ * the client has declared its support for compression in the request.
+ * Set at constructor time.
+ */
+ public $compress_response = false;
+
+ /**
+ * List of http compression methods accepted by the server for requests. Set at constructor time.
+ * NB: PHP supports deflate, gzip compressions out of the box if compiled w. zlib
+ */
+ public $accepted_compression = array();
+
+ /// Shall we serve calls to system.* methods?
+ public $allow_system_funcs = true;
+
+ /**
+ * List of charset encodings natively accepted for requests.
+ * Set at constructor time.
+ * UNUSED so far...
+ */
+ public $accepted_charset_encodings = array();
+
+ /**
+ * Charset encoding to be used for response.
+ * NB: if we can, we will convert the generated response from internal_encoding to the intended one.
+ * Can be: a supported xml encoding (only UTF-8 and ISO-8859-1 at present, unless mbstring is enabled),
+ * null (leave unspecified in response, convert output stream to US_ASCII),
+ * 'default' (use xmlrpc library default as specified in xmlrpc.inc, convert output stream if needed),
+ * or 'auto' (use client-specified charset encoding or same as request if request headers do not specify it (unless request is US-ASCII: then use library default anyway).
+ * NB: pretty dangerous if you accept every charset and do not have mbstring enabled)
+ */
+ public $response_charset_encoding = '';
+
+ /**
+ * Storage for internal debug info.
+ */
+ protected $debug_info = '';
+
+ /**
+ * Extra data passed at runtime to method handling functions. Used only by EPI layer
+ */
+ public $user_data = null;
+
+ protected static $_xmlrpc_debuginfo = '';
+ protected static $_xmlrpcs_occurred_errors = '';
+ protected static $_xmlrpcs_prev_ehandler = '';
+
+ /**
+ * @param array $dispatchMap the dispatch map with definition of exposed services
+ * @param boolean $serviceNow set to false to prevent the server from running upon construction
+ */
+ public function __construct($dispatchMap = null, $serviceNow = true)
+ {
+ // if ZLIB is enabled, let the server by default accept compressed requests,
+ // and compress responses sent to clients that support them
+ if (function_exists('gzinflate')) {
+ $this->accepted_compression = array('gzip', 'deflate');
+ $this->compress_response = true;
+ }
+
+ // by default the xml parser can support these 3 charset encodings
+ $this->accepted_charset_encodings = array('UTF-8', 'ISO-8859-1', 'US-ASCII');
+
+ // dispMap is a dispatch array of methods mapped to function names and signatures.
+ // If a method doesn't appear in the map then an unknown method error is generated
+ /* milosch - changed to make passing dispMap optional.
+ * instead, you can use the class add_to_map() function
+ * to add functions manually (borrowed from SOAPX4)
+ */
+ if ($dispatchMap) {
+ $this->dmap = $dispatchMap;
+ if ($serviceNow) {
+ $this->service();
+ }
+ }
+ }
+
+ /**
+ * Set debug level of server.
+ *
+ * @param integer $level debug lvl: determines info added to xmlrpc responses (as xml comments)
+ * 0 = no debug info,
+ * 1 = msgs set from user with debugmsg(),
+ * 2 = add complete xmlrpc request (headers and body),
+ * 3 = add also all processing warnings happened during method processing
+ * (NB: this involves setting a custom error handler, and might interfere
+ * with the standard processing of the php function exposed as method. In
+ * particular, triggering an USER_ERROR level error will not halt script
+ * execution anymore, but just end up logged in the xmlrpc response)
+ * Note that info added at level 2 and 3 will be base64 encoded
+ */
+ public function setDebug($level)
+ {
+ $this->debug = $level;
+ }
+
+ /**
+ * Add a string to the debug info that can be later serialized by the server
+ * as part of the response message.
+ * Note that for best compatibility, the debug string should be encoded using
+ * the PhpXmlRpc::$xmlrpc_internalencoding character set.
+ *
+ * @param string $msg
+ * @access public
+ */
+ public static function xmlrpc_debugmsg($msg)
+ {
+ static::$_xmlrpc_debuginfo .= $msg . "\n";
+ }
+
+ public static function error_occurred($msg)
+ {
+ static::$_xmlrpcs_occurred_errors .= $msg . "\n";
+ }
+
+ /**
+ * Return a string with the serialized representation of all debug info.
+ *
+ * @param string $charsetEncoding the target charset encoding for the serialization
+ *
+ * @return string an XML comment (or two)
+ */
+ public function serializeDebug($charsetEncoding = '')
+ {
+ // Tough encoding problem: which internal charset should we assume for debug info?
+ // It might contain a copy of raw data received from client, ie with unknown encoding,
+ // intermixed with php generated data and user generated data...
+ // so we split it: system debug is base 64 encoded,
+ // user debug info should be encoded by the end user using the INTERNAL_ENCODING
+ $out = '';
+ if ($this->debug_info != '') {
+ $out .= "<!-- SERVER DEBUG INFO (BASE64 ENCODED):\n" . base64_encode($this->debug_info) . "\n-->\n";
+ }
+ if (static::$_xmlrpc_debuginfo != '') {
+ $out .= "<!-- DEBUG INFO:\n" . Charset::instance()->encodeEntities(str_replace('--', '_-', static::$_xmlrpc_debuginfo), PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "\n-->\n";
+ // NB: a better solution MIGHT be to use CDATA, but we need to insert it
+ // into return payload AFTER the beginning tag
+ //$out .= "<![CDATA[ DEBUG INFO:\n\n" . str_replace(']]>', ']_]_>', static::$_xmlrpc_debuginfo) . "\n]]>\n";
+ }
+
+ return $out;
+ }
+
+ /**
+ * Execute the xmlrpc request, printing the response.
+ *
+ * @param string $data the request body. If null, the http POST request will be examined
+ * @param bool $returnPayload When true, return the response but do not echo it or any http header
+ *
+ * @return Response|string the response object (usually not used by caller...) or its xml serialization
+ *
+ * @throws \Exception in case the executed method does throw an exception (and depending on server configuration)
+ */
+ public function service($data = null, $returnPayload = false)
+ {
+ if ($data === null) {
+ $data = file_get_contents('php://input');
+ }
+ $rawData = $data;
+
+ // reset internal debug info
+ $this->debug_info = '';
+
+ // Save what we received, before parsing it
+ if ($this->debug > 1) {
+ $this->debugmsg("+++GOT+++\n" . $data . "\n+++END+++");
+ }
+
+ $r = $this->parseRequestHeaders($data, $reqCharset, $respCharset, $respEncoding);
+ if (!$r) {
+ // this actually executes the request
+ $r = $this->parseRequest($data, $reqCharset);
+ }
+
+ // save full body of request into response, for more debugging usages
+ $r->raw_data = $rawData;
+
+ if ($this->debug > 2 && static::$_xmlrpcs_occurred_errors) {
+ $this->debugmsg("+++PROCESSING ERRORS AND WARNINGS+++\n" .
+ static::$_xmlrpcs_occurred_errors . "+++END+++");
+ }
+
+ $payload = $this->xml_header($respCharset);
+ if ($this->debug > 0) {
+ $payload = $payload . $this->serializeDebug($respCharset);
+ }
+
+ // G. Giunta 2006-01-27: do not create response serialization if it has
+ // already happened. Helps building json magic
+ if (empty($r->payload)) {
+ $r->serialize($respCharset);
+ }
+ $payload = $payload . $r->payload;
+
+ if ($returnPayload) {
+ return $payload;
+ }
+
+ // if we get a warning/error that has output some text before here, then we cannot
+ // add a new header. We cannot say we are sending xml, either...
+ if (!headers_sent()) {
+ header('Content-Type: ' . $r->content_type);
+ // we do not know if client actually told us an accepted charset, but if he did
+ // we have to tell him what we did
+ header("Vary: Accept-Charset");
+
+ // http compression of output: only
+ // if we can do it, and we want to do it, and client asked us to,
+ // and php ini settings do not force it already
+ $phpNoSelfCompress = !ini_get('zlib.output_compression') && (ini_get('output_handler') != 'ob_gzhandler');
+ if ($this->compress_response && function_exists('gzencode') && $respEncoding != ''
+ && $phpNoSelfCompress
+ ) {
+ if (strpos($respEncoding, 'gzip') !== false) {
+ $payload = gzencode($payload);
+ header("Content-Encoding: gzip");
+ header("Vary: Accept-Encoding");
+ } elseif (strpos($respEncoding, 'deflate') !== false) {
+ $payload = gzcompress($payload);
+ header("Content-Encoding: deflate");
+ header("Vary: Accept-Encoding");
+ }
+ }
+
+ // do not output content-length header if php is compressing output for us:
+ // it will mess up measurements
+ if ($phpNoSelfCompress) {
+ header('Content-Length: ' . (int)strlen($payload));
+ }
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': http headers already sent before response is fully generated. Check for php warning or error messages');
+ }
+
+ print $payload;
+
+ // return request, in case subclasses want it
+ return $r;
+ }
+
+ /**
+ * Add a method to the dispatch map.
+ *
+ * @param string $methodName the name with which the method will be made available
+ * @param string $function the php function that will get invoked
+ * @param array $sig the array of valid method signatures
+ * @param string $doc method documentation
+ * @param array $sigDoc the array of valid method signatures docs (one string per param, one for return type)
+ */
+ public function add_to_map($methodName, $function, $sig = null, $doc = false, $sigDoc = false)
+ {
+ $this->dmap[$methodName] = array(
+ 'function' => $function,
+ 'docstring' => $doc,
+ );
+ if ($sig) {
+ $this->dmap[$methodName]['signature'] = $sig;
+ }
+ if ($sigDoc) {
+ $this->dmap[$methodName]['signature_docs'] = $sigDoc;
+ }
+ }
+
+ /**
+ * Verify type and number of parameters received against a list of known signatures.
+ *
+ * @param array|Request $in array of either xmlrpc value objects or xmlrpc type definitions
+ * @param array $sigs array of known signatures to match against
+ *
+ * @return array
+ */
+ protected function verifySignature($in, $sigs)
+ {
+ // check each possible signature in turn
+ if (is_object($in)) {
+ $numParams = $in->getNumParams();
+ } else {
+ $numParams = count($in);
+ }
+ foreach ($sigs as $curSig) {
+ if (count($curSig) == $numParams + 1) {
+ $itsOK = 1;
+ for ($n = 0; $n < $numParams; $n++) {
+ if (is_object($in)) {
+ $p = $in->getParam($n);
+ if ($p->kindOf() == 'scalar') {
+ $pt = $p->scalartyp();
+ } else {
+ $pt = $p->kindOf();
+ }
+ } else {
+ $pt = ($in[$n] == 'i4') ? 'int' : strtolower($in[$n]); // dispatch maps never use i4...
+ }
+
+ // param index is $n+1, as first member of sig is return type
+ if ($pt != $curSig[$n + 1] && $curSig[$n + 1] != Value::$xmlrpcValue) {
+ $itsOK = 0;
+ $pno = $n + 1;
+ $wanted = $curSig[$n + 1];
+ $got = $pt;
+ break;
+ }
+ }
+ if ($itsOK) {
+ return array(1, '');
+ }
+ }
+ }
+ if (isset($wanted)) {
+ return array(0, "Wanted ${wanted}, got ${got} at param ${pno}");
+ } else {
+ return array(0, "No method signature matches number of parameters");
+ }
+ }
+
+ /**
+ * Parse http headers received along with xmlrpc request. If needed, inflate request.
+ *
+ * @return mixed Response|null on success or an error Response
+ */
+ protected function parseRequestHeaders(&$data, &$reqEncoding, &$respEncoding, &$respCompression)
+ {
+ // check if $_SERVER is populated: it might have been disabled via ini file
+ // (this is true even when in CLI mode)
+ if (count($_SERVER) == 0) {
+ error_log('XML-RPC: ' . __METHOD__ . ': cannot parse request headers as $_SERVER is not populated');
+ }
+
+ if ($this->debug > 1) {
+ if (function_exists('getallheaders')) {
+ $this->debugmsg(''); // empty line
+ foreach (getallheaders() as $name => $val) {
+ $this->debugmsg("HEADER: $name: $val");
+ }
+ }
+ }
+
+ if (isset($_SERVER['HTTP_CONTENT_ENCODING'])) {
+ $contentEncoding = str_replace('x-', '', $_SERVER['HTTP_CONTENT_ENCODING']);
+ } else {
+ $contentEncoding = '';
+ }
+
+ // check if request body has been compressed and decompress it
+ if ($contentEncoding != '' && strlen($data)) {
+ if ($contentEncoding == 'deflate' || $contentEncoding == 'gzip') {
+ // if decoding works, use it. else assume data wasn't gzencoded
+ if (function_exists('gzinflate') && in_array($contentEncoding, $this->accepted_compression)) {
+ if ($contentEncoding == 'deflate' && $degzdata = @gzuncompress($data)) {
+ $data = $degzdata;
+ if ($this->debug > 1) {
+ $this->debugmsg("\n+++INFLATED REQUEST+++[" . strlen($data) . " chars]+++\n" . $data . "\n+++END+++");
+ }
+ } elseif ($contentEncoding == 'gzip' && $degzdata = @gzinflate(substr($data, 10))) {
+ $data = $degzdata;
+ if ($this->debug > 1) {
+ $this->debugmsg("+++INFLATED REQUEST+++[" . strlen($data) . " chars]+++\n" . $data . "\n+++END+++");
+ }
+ } else {
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['server_decompress_fail'], PhpXmlRpc::$xmlrpcstr['server_decompress_fail']);
+
+ return $r;
+ }
+ } else {
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['server_cannot_decompress'], PhpXmlRpc::$xmlrpcstr['server_cannot_decompress']);
+
+ return $r;
+ }
+ }
+ }
+
+ // check if client specified accepted charsets, and if we know how to fulfill
+ // the request
+ if ($this->response_charset_encoding == 'auto') {
+ $respEncoding = '';
+ if (isset($_SERVER['HTTP_ACCEPT_CHARSET'])) {
+ // here we should check if we can match the client-requested encoding
+ // with the encodings we know we can generate.
+ /// @todo we should parse q=0.x preferences instead of getting first charset specified...
+ $clientAcceptedCharsets = explode(',', strtoupper($_SERVER['HTTP_ACCEPT_CHARSET']));
+ // Give preference to internal encoding
+ $knownCharsets = array(PhpXmlRpc::$xmlrpc_internalencoding, 'UTF-8', 'ISO-8859-1', 'US-ASCII');
+ foreach ($knownCharsets as $charset) {
+ foreach ($clientAcceptedCharsets as $accepted) {
+ if (strpos($accepted, $charset) === 0) {
+ $respEncoding = $charset;
+ break;
+ }
+ }
+ if ($respEncoding) {
+ break;
+ }
+ }
+ }
+ } else {
+ $respEncoding = $this->response_charset_encoding;
+ }
+
+ if (isset($_SERVER['HTTP_ACCEPT_ENCODING'])) {
+ $respCompression = $_SERVER['HTTP_ACCEPT_ENCODING'];
+ } else {
+ $respCompression = '';
+ }
+
+ // 'guestimate' request encoding
+ /// @todo check if mbstring is enabled and automagic input conversion is on: it might mingle with this check???
+ $reqEncoding = XMLParser::guessEncoding(isset($_SERVER['CONTENT_TYPE']) ? $_SERVER['CONTENT_TYPE'] : '',
+ $data);
+
+ return;
+ }
+
+ /**
+ * Parse an xml chunk containing an xmlrpc request and execute the corresponding
+ * php function registered with the server.
+ *
+ * @param string $data the xml request
+ * @param string $reqEncoding (optional) the charset encoding of the xml request
+ *
+ * @return Response
+ *
+ * @throws \Exception in case the executed method does throw an exception (and depending on server configuration)
+ */
+ public function parseRequest($data, $reqEncoding = '')
+ {
+ // decompose incoming XML into request structure
+
+ if ($reqEncoding != '') {
+ // Since parsing will fail if charset is not specified in the xml prologue,
+ // the encoding is not UTF8 and there are non-ascii chars in the text, we try to work round that...
+ // The following code might be better for mb_string enabled installs, but
+ // makes the lib about 200% slower...
+ //if (!is_valid_charset($reqEncoding, array('UTF-8')))
+ if (!in_array($reqEncoding, array('UTF-8', 'US-ASCII')) && !XMLParser::hasEncoding($data)) {
+ if ($reqEncoding == 'ISO-8859-1') {
+ $data = utf8_encode($data);
+ } else {
+ if (extension_loaded('mbstring')) {
+ $data = mb_convert_encoding($data, 'UTF-8', $reqEncoding);
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of received request: ' . $reqEncoding);
+ }
+ }
+ }
+ }
+
+ $parser = xml_parser_create();
+ 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
+ // What if internal encoding is not in one of the 3 allowed?
+ // we use the broadest one, ie. utf8
+ // This allows to send data which is native in various charset,
+ // by extending xmlrpc_encode_entities() and setting xmlrpc_internalencoding
+ if (!in_array(PhpXmlRpc::$xmlrpc_internalencoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII'))) {
+ xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
+ } else {
+ xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, PhpXmlRpc::$xmlrpc_internalencoding);
+ }
+
+ $xmlRpcParser = new XMLParser();
+ xml_set_object($parser, $xmlRpcParser);
+
+ if ($this->functions_parameters_type != 'xmlrpcvals') {
+ xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee_fast');
+ } else {
+ xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee');
+ }
+ xml_set_character_data_handler($parser, 'xmlrpc_cd');
+ xml_set_default_handler($parser, 'xmlrpc_dh');
+ if (!xml_parse($parser, $data, 1)) {
+ // return XML error as a faultCode
+ $r = new Response(0,
+ PhpXmlRpc::$xmlrpcerrxml + xml_get_error_code($parser),
+ 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)));
+ xml_parser_free($parser);
+ } elseif ($xmlRpcParser->_xh['isf']) {
+ xml_parser_free($parser);
+ $r = new Response(0,
+ PhpXmlRpc::$xmlrpcerr['invalid_request'],
+ PhpXmlRpc::$xmlrpcstr['invalid_request'] . ' ' . $xmlRpcParser->_xh['isf_reason']);
+ } else {
+ xml_parser_free($parser);
+ // small layering violation in favor of speed and memory usage:
+ // we should allow the 'execute' method handle this, but in the
+ // most common scenario (xmlrpc values type server with some methods
+ // registered as phpvals) that would mean a useless encode+decode pass
+ if ($this->functions_parameters_type != 'xmlrpcvals' || (isset($this->dmap[$xmlRpcParser->_xh['method']]['parameters_type']) && ($this->dmap[$xmlRpcParser->_xh['method']]['parameters_type'] == 'phpvals'))) {
+ if ($this->debug > 1) {
+ $this->debugmsg("\n+++PARSED+++\n" . var_export($xmlRpcParser->_xh['params'], true) . "\n+++END+++");
+ }
+ $r = $this->execute($xmlRpcParser->_xh['method'], $xmlRpcParser->_xh['params'], $xmlRpcParser->_xh['pt']);
+ } else {
+ // build a Request object with data parsed from xml
+ $req = new Request($xmlRpcParser->_xh['method']);
+ // now add parameters in
+ for ($i = 0; $i < count($xmlRpcParser->_xh['params']); $i++) {
+ $req->addParam($xmlRpcParser->_xh['params'][$i]);
+ }
+
+ if ($this->debug > 1) {
+ $this->debugmsg("\n+++PARSED+++\n" . var_export($req, true) . "\n+++END+++");
+ }
+ $r = $this->execute($req);
+ }
+ }
+
+ return $r;
+ }
+
+ /**
+ * Execute a method invoked by the client, checking parameters used.
+ *
+ * @param mixed $req either a Request obj or a method name
+ * @param array $params array with method parameters as php types (if m is method name only)
+ * @param array $paramTypes array with xmlrpc types of method parameters (if m is method name only)
+ *
+ * @return Response
+ *
+ * @throws \Exception in case the executed method does throw an exception (and depending on server configuration)
+ */
+ protected function execute($req, $params = null, $paramTypes = null)
+ {
+ static::$_xmlrpcs_occurred_errors = '';
+ static::$_xmlrpc_debuginfo = '';
+
+ if (is_object($req)) {
+ $methName = $req->method();
+ } else {
+ $methName = $req;
+ }
+ $sysCall = $this->allow_system_funcs && (strpos($methName, "system.") === 0);
+ $dmap = $sysCall ? $this->getSystemDispatchMap() : $this->dmap;
+
+ if (!isset($dmap[$methName]['function'])) {
+ // No such method
+ return new Response(0,
+ PhpXmlRpc::$xmlrpcerr['unknown_method'],
+ PhpXmlRpc::$xmlrpcstr['unknown_method']);
+ }
+
+ // Check signature
+ if (isset($dmap[$methName]['signature'])) {
+ $sig = $dmap[$methName]['signature'];
+ if (is_object($req)) {
+ list($ok, $errStr) = $this->verifySignature($req, $sig);
+ } else {
+ list($ok, $errStr) = $this->verifySignature($paramTypes, $sig);
+ }
+ if (!$ok) {
+ // Didn't match.
+ return new Response(
+ 0,
+ PhpXmlRpc::$xmlrpcerr['incorrect_params'],
+ PhpXmlRpc::$xmlrpcstr['incorrect_params'] . ": ${errStr}"
+ );
+ }
+ }
+
+ $func = $dmap[$methName]['function'];
+ // let the 'class::function' syntax be accepted in dispatch maps
+ if (is_string($func) && strpos($func, '::')) {
+ $func = explode('::', $func);
+ }
+
+ if (is_array($func)) {
+ if (is_object($func[0])) {
+ $funcName = get_class($func[0]) . '->' . $func[1];
+ } else {
+ $funcName = implode('::', $func);
+ }
+ } else if ($func instanceof \Closure) {
+ $funcName = 'Closure';
+ } else {
+ $funcName = $func;
+ }
+
+ // verify that function to be invoked is in fact callable
+ if (!is_callable($func)) {
+ error_log("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler is not callable");
+ return new Response(
+ 0,
+ PhpXmlRpc::$xmlrpcerr['server_error'],
+ PhpXmlRpc::$xmlrpcstr['server_error'] . ": no function matches method"
+ );
+ }
+
+ // If debug level is 3, we should catch all errors generated during
+ // processing of user function, and log them as part of response
+ if ($this->debug > 2) {
+ self::$_xmlrpcs_prev_ehandler = set_error_handler(array('\PhpXmlRpc\Server', '_xmlrpcs_errorHandler'));
+ }
+
+ try {
+ // Allow mixed-convention servers
+ if (is_object($req)) {
+ if ($sysCall) {
+ $r = call_user_func($func, $this, $req);
+ } else {
+ $r = call_user_func($func, $req);
+ }
+ if (!is_a($r, 'PhpXmlRpc\Response')) {
+ error_log("XML-RPC: " . __METHOD__ . ": function '$funcName' registered as method handler does not return an xmlrpc response object but a " . gettype($r));
+ if (is_a($r, 'PhpXmlRpc\Value')) {
+ $r = new Response($r);
+ } else {
+ $r = new Response(
+ 0,
+ PhpXmlRpc::$xmlrpcerr['server_error'],
+ PhpXmlRpc::$xmlrpcstr['server_error'] . ": function does not return xmlrpc response object"
+ );
+ }
+ }
+ } else {
+ // call a 'plain php' function
+ if ($sysCall) {
+ array_unshift($params, $this);
+ $r = call_user_func_array($func, $params);
+ } else {
+ // 3rd API convention for method-handling functions: EPI-style
+ if ($this->functions_parameters_type == 'epivals') {
+ $r = call_user_func_array($func, array($methName, $params, $this->user_data));
+ // mimic EPI behaviour: if we get an array that looks like an error, make it
+ // an eror response
+ if (is_array($r) && array_key_exists('faultCode', $r) && array_key_exists('faultString', $r)) {
+ $r = new Response(0, (integer)$r['faultCode'], (string)$r['faultString']);
+ } else {
+ // functions using EPI api should NOT return resp objects,
+ // so make sure we encode the return type correctly
+ $encoder = new Encoder();
+ $r = new Response($encoder->encode($r, array('extension_api')));
+ }
+ } else {
+ $r = call_user_func_array($func, $params);
+ }
+ }
+ // the return type can be either a Response object or a plain php value...
+ if (!is_a($r, '\PhpXmlRpc\Response')) {
+ // what should we assume here about automatic encoding of datetimes
+ // and php classes instances???
+ $encoder = new Encoder();
+ $r = new Response($encoder->encode($r, $this->phpvals_encoding_options));
+ }
+ }
+ } catch (\Exception $e) {
+ // (barring errors in the lib) an uncatched exception happened
+ // in the called function, we wrap it in a proper error-response
+ switch ($this->exception_handling) {
+ case 2:
+ if ($this->debug > 2) {
+ if (self::$_xmlrpcs_prev_ehandler) {
+ set_error_handler(self::$_xmlrpcs_prev_ehandler);
+ } else {
+ restore_error_handler();
+ }
+ }
+ throw $e;
+ break;
+ case 1:
+ $r = new Response(0, $e->getCode(), $e->getMessage());
+ break;
+ default:
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['server_error'], PhpXmlRpc::$xmlrpcstr['server_error']);
+ }
+ }
+ if ($this->debug > 2) {
+ // note: restore the error handler we found before calling the
+ // user func, even if it has been changed inside the func itself
+ if (self::$_xmlrpcs_prev_ehandler) {
+ set_error_handler(self::$_xmlrpcs_prev_ehandler);
+ } else {
+ restore_error_handler();
+ }
+ }
+
+ return $r;
+ }
+
+ /**
+ * Add a string to the 'internal debug message' (separate from 'user debug message').
+ *
+ * @param string $string
+ */
+ protected function debugmsg($string)
+ {
+ $this->debug_info .= $string . "\n";
+ }
+
+ /**
+ * @param string $charsetEncoding
+ * @return string
+ */
+ protected function xml_header($charsetEncoding = '')
+ {
+ if ($charsetEncoding != '') {
+ return "<?xml version=\"1.0\" encoding=\"$charsetEncoding\"?" . ">\n";
+ } else {
+ return "<?xml version=\"1.0\"?" . ">\n";
+ }
+ }
+
+ /* Functions that implement system.XXX methods of xmlrpc servers */
+
+ /**
+ * @return array
+ */
+ public function getSystemDispatchMap()
+ {
+ return array(
+ 'system.listMethods' => array(
+ 'function' => 'PhpXmlRpc\Server::_xmlrpcs_listMethods',
+ // listMethods: signature was either a string, or nothing.
+ // The useless string variant has been removed
+ 'signature' => array(array(Value::$xmlrpcArray)),
+ 'docstring' => 'This method lists all the methods that the XML-RPC server knows how to dispatch',
+ 'signature_docs' => array(array('list of method names')),
+ ),
+ 'system.methodHelp' => array(
+ 'function' => 'PhpXmlRpc\Server::_xmlrpcs_methodHelp',
+ 'signature' => array(array(Value::$xmlrpcString, Value::$xmlrpcString)),
+ 'docstring' => 'Returns help text if defined for the method passed, otherwise returns an empty string',
+ 'signature_docs' => array(array('method description', 'name of the method to be described')),
+ ),
+ 'system.methodSignature' => array(
+ 'function' => 'PhpXmlRpc\Server::_xmlrpcs_methodSignature',
+ 'signature' => array(array(Value::$xmlrpcArray, Value::$xmlrpcString)),
+ 'docstring' => 'Returns an array of known signatures (an array of arrays) for the method name passed. If no signatures are known, returns a none-array (test for type != array to detect missing signature)',
+ 'signature_docs' => array(array('list of known signatures, each sig being an array of xmlrpc type names', 'name of method to be described')),
+ ),
+ 'system.multicall' => array(
+ 'function' => 'PhpXmlRpc\Server::_xmlrpcs_multicall',
+ 'signature' => array(array(Value::$xmlrpcArray, Value::$xmlrpcArray)),
+ 'docstring' => 'Boxcar multiple RPC calls in one request. See http://www.xmlrpc.com/discuss/msgReader$1208 for details',
+ 'signature_docs' => array(array('list of response structs, where each struct has the usual members', 'list of calls, with each call being represented as a struct, with members "methodname" and "params"')),
+ ),
+ 'system.getCapabilities' => array(
+ 'function' => 'PhpXmlRpc\Server::_xmlrpcs_getCapabilities',
+ 'signature' => array(array(Value::$xmlrpcStruct)),
+ 'docstring' => 'This method lists all the capabilites that the XML-RPC server has: the (more or less standard) extensions to the xmlrpc spec that it adheres to',
+ 'signature_docs' => array(array('list of capabilities, described as structs with a version number and url for the spec')),
+ ),
+ );
+ }
+
+ /**
+ * @return array
+ */
+ public function getCapabilities()
+ {
+ $outAr = array(
+ // xmlrpc spec: always supported
+ 'xmlrpc' => array(
+ 'specUrl' => 'http://www.xmlrpc.com/spec',
+ 'specVersion' => 1
+ ),
+ // if we support system.xxx functions, we always support multicall, too...
+ // Note that, as of 2006/09/17, the following URL does not respond anymore
+ 'system.multicall' => array(
+ 'specUrl' => 'http://www.xmlrpc.com/discuss/msgReader$1208',
+ 'specVersion' => 1
+ ),
+ // introspection: version 2! we support 'mixed', too
+ 'introspection' => array(
+ 'specUrl' => 'http://phpxmlrpc.sourceforge.net/doc-2/ch10.html',
+ 'specVersion' => 2,
+ ),
+ );
+
+ // NIL extension
+ if (PhpXmlRpc::$xmlrpc_null_extension) {
+ $outAr['nil'] = array(
+ 'specUrl' => 'http://www.ontosys.com/xml-rpc/extensions.php',
+ 'specVersion' => 1
+ );
+ }
+
+ return $outAr;
+ }
+
+ public static function _xmlrpcs_getCapabilities($server, $req = null)
+ {
+ $encoder = new Encoder();
+ return new Response($encoder->encode($server->getCapabilities()));
+ }
+
+ public static function _xmlrpcs_listMethods($server, $req = null) // if called in plain php values mode, second param is missing
+ {
+ $outAr = array();
+ foreach ($server->dmap as $key => $val) {
+ $outAr[] = new Value($key, 'string');
+ }
+ if ($server->allow_system_funcs) {
+ foreach ($server->getSystemDispatchMap() as $key => $val) {
+ $outAr[] = new Value($key, 'string');
+ }
+ }
+
+ return new Response(new Value($outAr, 'array'));
+ }
+
+ public static function _xmlrpcs_methodSignature($server, $req)
+ {
+ // let accept as parameter both an xmlrpc value or string
+ if (is_object($req)) {
+ $methName = $req->getParam(0);
+ $methName = $methName->scalarval();
+ } else {
+ $methName = $req;
+ }
+ if (strpos($methName, "system.") === 0) {
+ $dmap = $server->getSystemDispatchMap();
+ } else {
+ $dmap = $server->dmap;
+ }
+ if (isset($dmap[$methName])) {
+ if (isset($dmap[$methName]['signature'])) {
+ $sigs = array();
+ foreach ($dmap[$methName]['signature'] as $inSig) {
+ $curSig = array();
+ foreach ($inSig as $sig) {
+ $curSig[] = new Value($sig, 'string');
+ }
+ $sigs[] = new Value($curSig, 'array');
+ }
+ $r = new Response(new Value($sigs, 'array'));
+ } else {
+ // NB: according to the official docs, we should be returning a
+ // "none-array" here, which means not-an-array
+ $r = new Response(new Value('undef', 'string'));
+ }
+ } else {
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['introspect_unknown'], PhpXmlRpc::$xmlrpcstr['introspect_unknown']);
+ }
+
+ return $r;
+ }
+
+ public static function _xmlrpcs_methodHelp($server, $req)
+ {
+ // let accept as parameter both an xmlrpc value or string
+ if (is_object($req)) {
+ $methName = $req->getParam(0);
+ $methName = $methName->scalarval();
+ } else {
+ $methName = $req;
+ }
+ if (strpos($methName, "system.") === 0) {
+ $dmap = $server->getSystemDispatchMap();
+ } else {
+ $dmap = $server->dmap;
+ }
+ if (isset($dmap[$methName])) {
+ if (isset($dmap[$methName]['docstring'])) {
+ $r = new Response(new Value($dmap[$methName]['docstring']), 'string');
+ } else {
+ $r = new Response(new Value('', 'string'));
+ }
+ } else {
+ $r = new Response(0, PhpXmlRpc::$xmlrpcerr['introspect_unknown'], PhpXmlRpc::$xmlrpcstr['introspect_unknown']);
+ }
+
+ return $r;
+ }
+
+ public static function _xmlrpcs_multicall_error($err)
+ {
+ if (is_string($err)) {
+ $str = PhpXmlRpc::$xmlrpcstr["multicall_${err}"];
+ $code = PhpXmlRpc::$xmlrpcerr["multicall_${err}"];
+ } else {
+ $code = $err->faultCode();
+ $str = $err->faultString();
+ }
+ $struct = array();
+ $struct['faultCode'] = new Value($code, 'int');
+ $struct['faultString'] = new Value($str, 'string');
+
+ return new Value($struct, 'struct');
+ }
+
+ public static function _xmlrpcs_multicall_do_call($server, $call)
+ {
+ if ($call->kindOf() != 'struct') {
+ return static::_xmlrpcs_multicall_error('notstruct');
+ }
+ $methName = @$call['methodName'];
+ if (!$methName) {
+ return static::_xmlrpcs_multicall_error('nomethod');
+ }
+ if ($methName->kindOf() != 'scalar' || $methName->scalartyp() != 'string') {
+ return static::_xmlrpcs_multicall_error('notstring');
+ }
+ if ($methName->scalarval() == 'system.multicall') {
+ return static::_xmlrpcs_multicall_error('recursion');
+ }
+
+ $params = @$call['params'];
+ if (!$params) {
+ return static::_xmlrpcs_multicall_error('noparams');
+ }
+ if ($params->kindOf() != 'array') {
+ return static::_xmlrpcs_multicall_error('notarray');
+ }
+
+ $req = new Request($methName->scalarval());
+ foreach($params as $i => $param) {
+ if (!$req->addParam($param)) {
+ $i++; // for error message, we count params from 1
+ return static::_xmlrpcs_multicall_error(new Response(0,
+ PhpXmlRpc::$xmlrpcerr['incorrect_params'],
+ PhpXmlRpc::$xmlrpcstr['incorrect_params'] . ": probable xml error in param " . $i));
+ }
+ }
+
+ $result = $server->execute($req);
+
+ if ($result->faultCode() != 0) {
+ return static::_xmlrpcs_multicall_error($result); // Method returned fault.
+ }
+
+ return new Value(array($result->value()), 'array');
+ }
+
+ public static function _xmlrpcs_multicall_do_call_phpvals($server, $call)
+ {
+ if (!is_array($call)) {
+ return static::_xmlrpcs_multicall_error('notstruct');
+ }
+ if (!array_key_exists('methodName', $call)) {
+ return static::_xmlrpcs_multicall_error('nomethod');
+ }
+ if (!is_string($call['methodName'])) {
+ return static::_xmlrpcs_multicall_error('notstring');
+ }
+ if ($call['methodName'] == 'system.multicall') {
+ return static::_xmlrpcs_multicall_error('recursion');
+ }
+ if (!array_key_exists('params', $call)) {
+ return static::_xmlrpcs_multicall_error('noparams');
+ }
+ if (!is_array($call['params'])) {
+ return static::_xmlrpcs_multicall_error('notarray');
+ }
+
+ // this is a real dirty and simplistic hack, since we might have received a
+ // base64 or datetime values, but they will be listed as strings here...
+ $numParams = count($call['params']);
+ $pt = array();
+ $wrapper = new Wrapper();
+ foreach ($call['params'] as $val) {
+ $pt[] = $wrapper->php2XmlrpcType(gettype($val));
+ }
+
+ $result = $server->execute($call['methodName'], $call['params'], $pt);
+
+ if ($result->faultCode() != 0) {
+ return static::_xmlrpcs_multicall_error($result); // Method returned fault.
+ }
+
+ return new Value(array($result->value()), 'array');
+ }
+
+ public static function _xmlrpcs_multicall($server, $req)
+ {
+ $result = array();
+ // let accept a plain list of php parameters, beside a single xmlrpc msg object
+ if (is_object($req)) {
+ $calls = $req->getParam(0);
+ foreach($calls as $call) {
+ $result[] = static::_xmlrpcs_multicall_do_call($server, $call);
+ }
+ } else {
+ $numCalls = count($req);
+ for ($i = 0; $i < $numCalls; $i++) {
+ $result[$i] = static::_xmlrpcs_multicall_do_call_phpvals($server, $req[$i]);
+ }
+ }
+
+ return new Response(new Value($result, 'array'));
+ }
+
+ /**
+ * Error handler used to track errors that occur during server-side execution of PHP code.
+ * This allows to report back to the client whether an internal error has occurred or not
+ * using an xmlrpc response object, instead of letting the client deal with the html junk
+ * that a PHP execution error on the server generally entails.
+ *
+ * NB: in fact a user defined error handler can only handle WARNING, NOTICE and USER_* errors.
+ */
+ public static function _xmlrpcs_errorHandler($errCode, $errString, $filename = null, $lineNo = null, $context = null)
+ {
+ // obey the @ protocol
+ if (error_reporting() == 0) {
+ return;
+ }
+
+ //if($errCode != E_NOTICE && $errCode != E_WARNING && $errCode != E_USER_NOTICE && $errCode != E_USER_WARNING)
+ if ($errCode != E_STRICT) {
+ \PhpXmlRpc\Server::error_occurred($errString);
+ }
+ // Try to avoid as much as possible disruption to the previous error handling
+ // mechanism in place
+ if (self::$_xmlrpcs_prev_ehandler == '') {
+ // The previous error handler was the default: all we should do is log error
+ // to the default error log (if level high enough)
+ if (ini_get('log_errors') && (intval(ini_get('error_reporting')) & $errCode)) {
+ error_log($errString);
+ }
+ } else {
+ // Pass control on to previous error handler, trying to avoid loops...
+ if (self::$_xmlrpcs_prev_ehandler != array('\PhpXmlRpc\Server', '_xmlrpcs_errorHandler')) {
+ if (is_array(self::$_xmlrpcs_prev_ehandler)) {
+ // the following works both with static class methods and plain object methods as error handler
+ call_user_func_array(self::$_xmlrpcs_prev_ehandler, array($errCode, $errString, $filename, $lineNo, $context));
+ } else {
+ $method = self::$_xmlrpcs_prev_ehandler;
+ $method($errCode, $errString, $filename, $lineNo, $context);
+ }
+ }
+ }
+ }
+}
--- /dev/null
+<?php
+
+namespace PhpXmlRpc;
+
+use PhpXmlRpc\Helper\Charset;
+
+/**
+ * This class enables the creation of values for XML-RPC, by encapsulating plain php values.
+ */
+class Value implements \Countable, \IteratorAggregate, \ArrayAccess
+{
+ public static $xmlrpcI4 = "i4";
+ public static $xmlrpcI8 = "i8";
+ public static $xmlrpcInt = "int";
+ public static $xmlrpcBoolean = "boolean";
+ public static $xmlrpcDouble = "double";
+ public static $xmlrpcString = "string";
+ public static $xmlrpcDateTime = "dateTime.iso8601";
+ public static $xmlrpcBase64 = "base64";
+ public static $xmlrpcArray = "array";
+ public static $xmlrpcStruct = "struct";
+ public static $xmlrpcValue = "undefined";
+ public static $xmlrpcNull = "null";
+
+ public static $xmlrpcTypes = array(
+ "i4" => 1,
+ "i8" => 1,
+ "int" => 1,
+ "boolean" => 1,
+ "double" => 1,
+ "string" => 1,
+ "dateTime.iso8601" => 1,
+ "base64" => 1,
+ "array" => 2,
+ "struct" => 3,
+ "null" => 1,
+ );
+
+ /// @todo: do these need to be public?
+ public $me = array();
+ public $mytype = 0;
+ public $_php_class = null;
+
+ /**
+ * Build an xmlrpc value.
+ *
+ * When no value or type is passed in, the value is left uninitialized, and the value can be added later.
+ *
+ * @param mixed $val if passing in an array, all array elements should be PhpXmlRpc\Value themselves
+ * @param string $type any valid xmlrpc type name (lowercase): i4, int, boolean, string, double, dateTime.iso8601,
+ * base64, array, struct, null.
+ * If null, 'string' is assumed.
+ * You should refer to http://www.xmlrpc.com/spec for more information on what each of these mean.
+ */
+ public function __construct($val = -1, $type = '')
+ {
+ // optimization creep - do not call addXX, do it all inline.
+ // downside: booleans will not be coerced anymore
+ if ($val !== -1 || $type != '') {
+ switch ($type) {
+ case '':
+ $this->mytype = 1;
+ $this->me['string'] = $val;
+ break;
+ case 'i4':
+ case 'i8':
+ case 'int':
+ case 'double':
+ case 'string':
+ case 'boolean':
+ case 'dateTime.iso8601':
+ case 'base64':
+ case 'null':
+ $this->mytype = 1;
+ $this->me[$type] = $val;
+ break;
+ case 'array':
+ $this->mytype = 2;
+ $this->me['array'] = $val;
+ break;
+ case 'struct':
+ $this->mytype = 3;
+ $this->me['struct'] = $val;
+ break;
+ default:
+ error_log("XML-RPC: " . __METHOD__ . ": not a known type ($type)");
+ }
+ }
+ }
+
+ /**
+ * Add a single php value to an xmlrpc value.
+ *
+ * If the xmlrpc value is an array, the php value is added as its last element.
+ * If the xmlrpc value is empty (uninitialized), this method makes it a scalar value, and sets that value.
+ * Fails if the xmlrpc value is not an array and already initialized.
+ *
+ * @param mixed $val
+ * @param string $type allowed values: i4, i8, int, boolean, string, double, dateTime.iso8601, base64, null.
+ *
+ * @return int 1 or 0 on failure
+ */
+ public function addScalar($val, $type = 'string')
+ {
+ $typeOf = null;
+ if (isset(static::$xmlrpcTypes[$type])) {
+ $typeOf = static::$xmlrpcTypes[$type];
+ }
+
+ if ($typeOf !== 1) {
+ error_log("XML-RPC: " . __METHOD__ . ": not a scalar type ($type)");
+ return 0;
+ }
+
+ // coerce booleans into correct values
+ // NB: we should either do it for datetimes, integers, i8 and doubles, too,
+ // or just plain remove this check, implemented on booleans only...
+ if ($type == static::$xmlrpcBoolean) {
+ if (strcasecmp($val, 'true') == 0 || $val == 1 || ($val == true && strcasecmp($val, 'false'))) {
+ $val = true;
+ } else {
+ $val = false;
+ }
+ }
+
+ switch ($this->mytype) {
+ case 1:
+ error_log('XML-RPC: ' . __METHOD__ . ': scalar xmlrpc value can have only one value');
+ return 0;
+ case 3:
+ error_log('XML-RPC: ' . __METHOD__ . ': cannot add anonymous scalar to struct xmlrpc value');
+ return 0;
+ case 2:
+ // we're adding a scalar value to an array here
+ $this->me['array'][] = new Value($val, $type);
+
+ return 1;
+ default:
+ // a scalar, so set the value and remember we're scalar
+ $this->me[$type] = $val;
+ $this->mytype = $typeOf;
+
+ return 1;
+ }
+ }
+
+ /**
+ * Add an array of xmlrpc value objects to an xmlrpc value.
+ *
+ * If the xmlrpc value is an array, the elements are appended to the existing ones.
+ * If the xmlrpc value is empty (uninitialized), this method makes it an array value, and sets that value.
+ * Fails otherwise.
+ *
+ * @param Value[] $values
+ *
+ * @return int 1 or 0 on failure
+ *
+ * @todo add some checking for $values to be an array of xmlrpc values?
+ */
+ public function addArray($values)
+ {
+ if ($this->mytype == 0) {
+ $this->mytype = static::$xmlrpcTypes['array'];
+ $this->me['array'] = $values;
+
+ return 1;
+ } elseif ($this->mytype == 2) {
+ // we're adding to an array here
+ $this->me['array'] = array_merge($this->me['array'], $values);
+
+ return 1;
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': already initialized as a [' . $this->kindOf() . ']');
+ return 0;
+ }
+ }
+
+ /**
+ * Merges an array of named xmlrpc value objects into an xmlrpc value.
+ *
+ * If the xmlrpc value is a struct, the elements are merged with the existing ones (overwriting existing ones).
+ * If the xmlrpc value is empty (uninitialized), this method makes it a struct value, and sets that value.
+ * Fails otherwise.
+ *
+ * @param Value[] $values
+ *
+ * @return int 1 or 0 on failure
+ *
+ * @todo add some checking for $values to be an array?
+ */
+ public function addStruct($values)
+ {
+ if ($this->mytype == 0) {
+ $this->mytype = static::$xmlrpcTypes['struct'];
+ $this->me['struct'] = $values;
+
+ return 1;
+ } elseif ($this->mytype == 3) {
+ // we're adding to a struct here
+ $this->me['struct'] = array_merge($this->me['struct'], $values);
+
+ return 1;
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': already initialized as a [' . $this->kindOf() . ']');
+ return 0;
+ }
+ }
+
+ /**
+ * Returns a string containing either "struct", "array", "scalar" or "undef", describing the base type of the value.
+ *
+ * @return string
+ */
+ public function kindOf()
+ {
+ switch ($this->mytype) {
+ case 3:
+ return 'struct';
+ break;
+ case 2:
+ return 'array';
+ break;
+ case 1:
+ return 'scalar';
+ break;
+ default:
+ return 'undef';
+ }
+ }
+
+ protected function serializedata($typ, $val, $charsetEncoding = '')
+ {
+ $rs = '';
+
+ if (!isset(static::$xmlrpcTypes[$typ])) {
+ return $rs;
+ }
+
+ switch (static::$xmlrpcTypes[$typ]) {
+ case 1:
+ switch ($typ) {
+ case static::$xmlrpcBase64:
+ $rs .= "<${typ}>" . base64_encode($val) . "</${typ}>";
+ break;
+ case static::$xmlrpcBoolean:
+ $rs .= "<${typ}>" . ($val ? '1' : '0') . "</${typ}>";
+ break;
+ case static::$xmlrpcString:
+ // G. Giunta 2005/2/13: do NOT use htmlentities, since
+ // it will produce named html entities, which are invalid xml
+ $rs .= "<${typ}>" . Charset::instance()->encodeEntities($val, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</${typ}>";
+ break;
+ case static::$xmlrpcInt:
+ case static::$xmlrpcI4:
+ case static::$xmlrpcI8:
+ $rs .= "<${typ}>" . (int)$val . "</${typ}>";
+ break;
+ case static::$xmlrpcDouble:
+ // avoid using standard conversion of float to string because it is locale-dependent,
+ // and also because the xmlrpc spec forbids exponential notation.
+ // sprintf('%F') could be most likely ok but it fails eg. on 2e-14.
+ // The code below tries its best at keeping max precision while avoiding exp notation,
+ // but there is of course no limit in the number of decimal places to be used...
+ $rs .= "<${typ}>" . preg_replace('/\\.?0+$/', '', number_format((double)$val, 128, '.', '')) . "</${typ}>";
+ break;
+ case static::$xmlrpcDateTime:
+ if (is_string($val)) {
+ $rs .= "<${typ}>${val}</${typ}>";
+ } elseif (is_a($val, 'DateTime')) {
+ $rs .= "<${typ}>" . $val->format('Ymd\TH:i:s') . "</${typ}>";
+ } elseif (is_int($val)) {
+ $rs .= "<${typ}>" . strftime("%Y%m%dT%H:%M:%S", $val) . "</${typ}>";
+ } else {
+ // not really a good idea here: but what shall we output anyway? left for backward compat...
+ $rs .= "<${typ}>${val}</${typ}>";
+ }
+ break;
+ case static::$xmlrpcNull:
+ if (PhpXmlRpc::$xmlrpc_null_apache_encoding) {
+ $rs .= "<ex:nil/>";
+ } else {
+ $rs .= "<nil/>";
+ }
+ break;
+ default:
+ // no standard type value should arrive here, but provide a possibility
+ // for xmlrpc values of unknown type...
+ $rs .= "<${typ}>${val}</${typ}>";
+ }
+ break;
+ case 3:
+ // struct
+ if ($this->_php_class) {
+ $rs .= '<struct php_class="' . $this->_php_class . "\">\n";
+ } else {
+ $rs .= "<struct>\n";
+ }
+ $charsetEncoder = Charset::instance();
+ foreach ($val as $key2 => $val2) {
+ $rs .= '<member><name>' . $charsetEncoder->encodeEntities($key2, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "</name>\n";
+ //$rs.=$this->serializeval($val2);
+ $rs .= $val2->serialize($charsetEncoding);
+ $rs .= "</member>\n";
+ }
+ $rs .= '</struct>';
+ break;
+ case 2:
+ // array
+ $rs .= "<array>\n<data>\n";
+ foreach ($val as $element) {
+ //$rs.=$this->serializeval($val[$i]);
+ $rs .= $element->serialize($charsetEncoding);
+ }
+ $rs .= "</data>\n</array>";
+ break;
+ default:
+ break;
+ }
+
+ return $rs;
+ }
+
+ /**
+ * Returns the xml representation of the value. XML prologue not included.
+ *
+ * @param string $charsetEncoding the charset to be used for serialization. if null, US-ASCII is assumed
+ *
+ * @return string
+ */
+ public function serialize($charsetEncoding = '')
+ {
+ reset($this->me);
+ list($typ, $val) = each($this->me);
+
+ return '<value>' . $this->serializedata($typ, $val, $charsetEncoding) . "</value>\n";
+ }
+
+ /**
+ * Checks whether a struct member with a given name is present.
+ *
+ * Works only on xmlrpc values of type struct.
+ *
+ * @param string $key the name of the struct member to be looked up
+ *
+ * @return boolean
+ *
+ * @deprecated use array access, e.g. isset($val[$key])
+ */
+ public function structmemexists($key)
+ {
+ return array_key_exists($key, $this->me['struct']);
+ }
+
+ /**
+ * Returns the value of a given struct member (an xmlrpc value object in itself).
+ * Will raise a php warning if struct member of given name does not exist.
+ *
+ * @param string $key the name of the struct member to be looked up
+ *
+ * @return Value
+ *
+ * @deprecated use array access, e.g. $val[$key]
+ */
+ public function structmem($key)
+ {
+ return $this->me['struct'][$key];
+ }
+
+ /**
+ * Reset internal pointer for xmlrpc values of type struct.
+ * @deprecated iterate directly over the object using foreach instead
+ */
+ public function structreset()
+ {
+ reset($this->me['struct']);
+ }
+
+ /**
+ * Return next member element for xmlrpc values of type struct.
+ *
+ * @return Value
+ *
+ * @deprecated iterate directly over the object using foreach instead
+ */
+ public function structeach()
+ {
+ return each($this->me['struct']);
+ }
+
+ /**
+ * Returns the value of a scalar xmlrpc value (base 64 decoding is automatically handled here)
+ *
+ * @return mixed
+ */
+ public function scalarval()
+ {
+ reset($this->me);
+ list(, $b) = each($this->me);
+
+ return $b;
+ }
+
+ /**
+ * Returns the type of the xmlrpc value.
+ *
+ * For integers, 'int' is always returned in place of 'i4'. 'i8' is considered a separate type and returned as such
+ *
+ * @return string
+ */
+ public function scalartyp()
+ {
+ reset($this->me);
+ list($a,) = each($this->me);
+ if ($a == static::$xmlrpcI4) {
+ $a = static::$xmlrpcInt;
+ }
+
+ return $a;
+ }
+
+ /**
+ * Returns the m-th member of an xmlrpc value of array type.
+ *
+ * @param integer $key the index of the value to be retrieved (zero based)
+ *
+ * @return Value
+ *
+ * @deprecated use array access, e.g. $val[$key]
+ */
+ public function arraymem($key)
+ {
+ return $this->me['array'][$key];
+ }
+
+ /**
+ * Returns the number of members in an xmlrpc value of array type.
+ *
+ * @return integer
+ *
+ * @deprecated use count() instead
+ */
+ public function arraysize()
+ {
+ return count($this->me['array']);
+ }
+
+ /**
+ * Returns the number of members in an xmlrpc value of struct type.
+ *
+ * @return integer
+ *
+ * @deprecated use count() instead
+ */
+ public function structsize()
+ {
+ return count($this->me['struct']);
+ }
+
+ /**
+ * Returns the number of members in an xmlrpc value:
+ * - 0 for uninitialized values
+ * - 1 for scalar values
+ * - the number of elements for struct and array values
+ *
+ * @return integer
+ */
+ public function count()
+ {
+ switch ($this->mytype) {
+ case 3:
+ return count($this->me['struct']);
+ case 2:
+ return count($this->me['array']);
+ case 1:
+ return 1;
+ default:
+ return 0;
+ }
+ }
+
+ /**
+ * Implements the IteratorAggregate interface
+ *
+ * @return ArrayIterator
+ */
+ public function getIterator() {
+ switch ($this->mytype) {
+ case 3:
+ return new \ArrayIterator($this->me['struct']);
+ case 2:
+ return new \ArrayIterator($this->me['array']);
+ case 1:
+ return new \ArrayIterator($this->me);
+ default:
+ return new \ArrayIterator();
+ }
+ return new \ArrayIterator();
+ }
+
+ public function offsetSet($offset, $value) {
+
+ switch ($this->mytype) {
+ case 3:
+ if (!($value instanceof \PhpXmlRpc\Value)) {
+ throw new \Exception('It is only possible to add Value objects to an XML-RPC Struct');
+ }
+ if (is_null($offset)) {
+ // disallow struct members with empty names
+ throw new \Exception('It is not possible to add anonymous members to an XML-RPC Struct');
+ } else {
+ $this->me['struct'][$offset] = $value;
+ }
+ return;
+ case 2:
+ if (!($value instanceof \PhpXmlRpc\Value)) {
+ throw new \Exception('It is only possible to add Value objects to an XML-RPC Array');
+ }
+ if (is_null($offset)) {
+ $this->me['array'][] = $value;
+ } else {
+ // nb: we are not checking that $offset is above the existing array range...
+ $this->me['array'][$offset] = $value;
+ }
+ return;
+ case 1:
+// todo: handle i4 vs int
+ reset($this->me);
+ list($type,) = each($this->me);
+ if ($type != $offset) {
+ throw new \Exception('');
+ }
+ $this->me[$type] = $value;
+ return;
+ default:
+ // it would be nice to allow empty values to be be turned into non-empty ones this way, but we miss info to do so
+ throw new \Exception("XML-RPC Value is of type 'undef' and its value can not be set using array index");
+ }
+ }
+
+ public function offsetExists($offset) {
+ switch ($this->mytype) {
+ case 3:
+ return isset($this->me['struct'][$offset]);
+ case 2:
+ return isset($this->me['array'][$offset]);
+ case 1:
+// todo: handle i4 vs int
+ return $offset == $this->scalartyp();
+ default:
+ return false;
+ }
+ }
+
+ public function offsetUnset($offset) {
+ switch ($this->mytype) {
+ case 3:
+ unset($this->me['struct'][$offset]);
+ return;
+ case 2:
+ unset($this->me['array'][$offset]);
+ return;
+ case 1:
+ // can not remove value from a scalar
+ throw new \Exception("XML-RPC Value is of type 'scalar' and its value can not be unset using array index");
+ default:
+ throw new \Exception("XML-RPC Value is of type 'undef' and its value can not be unset using array index");
+ }
+ }
+
+ public function offsetGet($offset) {
+ switch ($this->mytype) {
+ case 3:
+ return isset($this->me['struct'][$offset]) ? $this->me['struct'][$offset] : null;
+ case 2:
+ return isset($this->me['array'][$offset]) ? $this->me['array'][$offset] : null;
+ case 1:
+// on bad type: null or exception?
+ reset($this->me);
+ list($type, $value) = each($this->me);
+ return $type == $offset ? $value : null;
+ default:
+// return null or exception?
+ throw new \Exception("XML-RPC Value is of type 'undef' and can not be accessed using array index");
+ }
+ }
+}
--- /dev/null
+<?php
+/**
+ * @author Gaetano Giunta
+ * @copyright (C) 2006-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ */
+
+namespace PhpXmlRpc;
+
+/**
+ * PHP-XMLRPC "wrapper" class - generate stubs to transparently access xmlrpc methods as php functions and vice-versa.
+ * Note: this class implements the PROXY pattern, but it is not named so to avoid confusion with http proxies.
+ *
+ * @todo use some better templating system for code generation?
+ * @todo implement method wrapping with preservation of php objs in calls
+ * @todo when wrapping methods without obj rebuilding, use return_type = 'phpvals' (faster)
+ */
+class Wrapper
+{
+ /// used to hold a reference to object instances whose methods get wrapped by wrapPhpFunction(), in 'create source' mode
+ public static $objHolder = array();
+
+ /**
+ * Given a string defining a php type or phpxmlrpc type (loosely defined: strings
+ * accepted come from javadoc blocks), return corresponding phpxmlrpc type.
+ * Notes:
+ * - for php 'resource' types returns empty string, since resources cannot be serialized;
+ * - for php class names returns 'struct', since php objects can be serialized as xmlrpc structs
+ * - for php arrays always return array, even though arrays sometimes serialize as json structs
+ * - for 'void' and 'null' returns 'undefined'
+ *
+ * @param string $phpType
+ *
+ * @return string
+ */
+ public function php2XmlrpcType($phpType)
+ {
+ switch (strtolower($phpType)) {
+ case 'string':
+ return Value::$xmlrpcString;
+ case 'integer':
+ case Value::$xmlrpcInt: // 'int'
+ case Value::$xmlrpcI4:
+ case Value::$xmlrpcI8:
+ return Value::$xmlrpcInt;
+ case Value::$xmlrpcDouble: // 'double'
+ return Value::$xmlrpcDouble;
+ case 'bool':
+ case Value::$xmlrpcBoolean: // 'boolean'
+ case 'false':
+ case 'true':
+ return Value::$xmlrpcBoolean;
+ case Value::$xmlrpcArray: // 'array':
+ return Value::$xmlrpcArray;
+ case 'object':
+ case Value::$xmlrpcStruct: // 'struct'
+ return Value::$xmlrpcStruct;
+ case Value::$xmlrpcBase64:
+ return Value::$xmlrpcBase64;
+ case 'resource':
+ return '';
+ default:
+ if (class_exists($phpType)) {
+ return Value::$xmlrpcStruct;
+ } else {
+ // unknown: might be any 'extended' xmlrpc type
+ return Value::$xmlrpcValue;
+ }
+ }
+ }
+
+ /**
+ * Given a string defining a phpxmlrpc type return the corresponding php type.
+ *
+ * @param string $xmlrpcType
+ *
+ * @return string
+ */
+ public function xmlrpc2PhpType($xmlrpcType)
+ {
+ switch (strtolower($xmlrpcType)) {
+ case 'base64':
+ case 'datetime.iso8601':
+ case 'string':
+ return Value::$xmlrpcString;
+ case 'int':
+ case 'i4':
+ case 'i8':
+ return 'integer';
+ case 'struct':
+ case 'array':
+ return 'array';
+ case 'double':
+ return 'float';
+ case 'undefined':
+ return 'mixed';
+ case 'boolean':
+ case 'null':
+ default:
+ // unknown: might be any xmlrpc type
+ return strtolower($xmlrpcType);
+ }
+ }
+
+ /**
+ * Given a user-defined PHP function, create a PHP 'wrapper' function that can
+ * be exposed as xmlrpc method from an xmlrpc server object and called from remote
+ * clients (as well as its corresponding signature info).
+ *
+ * Since php is a typeless language, to infer types of input and output parameters,
+ * it relies on parsing the javadoc-style comment block associated with the given
+ * function. Usage of xmlrpc native types (such as datetime.dateTime.iso8601 and base64)
+ * in the @param tag is also allowed, if you need the php function to receive/send
+ * data in that particular format (note that base64 encoding/decoding is transparently
+ * carried out by the lib, while datetime vals are passed around as strings)
+ *
+ * Known limitations:
+ * - only works for user-defined functions, not for PHP internal functions
+ * (reflection does not support retrieving number/type of params for those)
+ * - functions returning php objects will generate special structs in xmlrpc responses:
+ * when the xmlrpc decoding of those responses is carried out by this same lib, using
+ * the appropriate param in php_xmlrpc_decode, the php objects will be rebuilt.
+ * In short: php objects can be serialized, too (except for their resource members),
+ * using this function.
+ * Other libs might choke on the very same xml that will be generated in this case
+ * (i.e. it has a nonstandard attribute on struct element tags)
+ *
+ * Note that since rel. 2.0RC3 the preferred method to have the server call 'standard'
+ * php functions (ie. functions not expecting a single Request obj as parameter)
+ * is by making use of the functions_parameters_type class member.
+ *
+ * @param callable $callable the PHP user function to be exposed as xmlrpc method/ a closure, function name, array($obj, 'methodname') or array('class', 'methodname') are ok
+ * @param string $newFuncName (optional) name for function to be created. Used only when return_source in $extraOptions is true
+ * @param array $extraOptions (optional) array of options for conversion. valid values include:
+ * - bool return_source when true, php code w. function definition will be returned, instead of a closure
+ * - bool encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
+ * - bool decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
+ * - bool suppress_warnings remove from produced xml any warnings generated at runtime by the php function being invoked
+ *
+ * @return array|false false on error, or an array containing the name of the new php function,
+ * its signature and docs, to be used in the server dispatch map
+ *
+ * @todo decide how to deal with params passed by ref in function definition: bomb out or allow?
+ * @todo finish using phpdoc info to build method sig if all params are named but out of order
+ * @todo add a check for params of 'resource' type
+ * @todo add some trigger_errors / error_log when returning false?
+ * @todo what to do when the PHP function returns NULL? We are currently returning an empty string value...
+ * @todo add an option to suppress php warnings in invocation of user function, similar to server debug level 3?
+ * @todo add a verbatim_object_copy parameter to allow avoiding usage the same obj instance?
+ * @todo add an option to allow generated function to skip validation of number of parameters, as that is done by the server anyway
+ */
+ public function wrapPhpFunction($callable, $newFuncName = '', $extraOptions = array())
+ {
+ $buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
+
+ if (is_string($callable) && strpos($callable, '::') !== false) {
+ $callable = explode('::', $callable);
+ }
+ if (is_array($callable)) {
+ if (count($callable) < 2 || (!is_string($callable[0]) && !is_object($callable[0]))) {
+ error_log('XML-RPC: ' . __METHOD__ . ': syntax for function to be wrapped is wrong');
+ return false;
+ }
+ if (is_string($callable[0])) {
+ $plainFuncName = implode('::', $callable);
+ } elseif (is_object($callable[0])) {
+ $plainFuncName = get_class($callable[0]) . '->' . $callable[1];
+ }
+ $exists = method_exists($callable[0], $callable[1]);
+ } else if ($callable instanceof \Closure) {
+ // we do not support creating code which wraps closures, as php does not allow to serialize them
+ if (!$buildIt) {
+ error_log('XML-RPC: ' . __METHOD__ . ': a closure can not be wrapped in generated source code');
+ return false;
+ }
+
+ $plainFuncName = 'Closure';
+ $exists = true;
+ } else {
+ $plainFuncName = $callable;
+ $exists = function_exists($callable);
+ }
+
+ if (!$exists) {
+ error_log('XML-RPC: ' . __METHOD__ . ': function to be wrapped is not defined: ' . $plainFuncName);
+ return false;
+ }
+
+ $funcDesc = $this->introspectFunction($callable, $plainFuncName);
+ if (!$funcDesc) {
+ return false;
+ }
+
+ $funcSigs = $this->buildMethodSignatures($funcDesc);
+
+ if ($buildIt) {
+ $callable = $this->buildWrapFunctionClosure($callable, $extraOptions, $plainFuncName, $funcDesc);
+ } else {
+ $newFuncName = $this->newFunctionName($callable, $newFuncName, $extraOptions);
+ $code = $this->buildWrapFunctionSource($callable, $newFuncName, $extraOptions, $plainFuncName, $funcDesc);
+ }
+
+ $ret = array(
+ 'function' => $callable,
+ 'signature' => $funcSigs['sigs'],
+ 'docstring' => $funcDesc['desc'],
+ 'signature_docs' => $funcSigs['sigsDocs'],
+ );
+ if (!$buildIt) {
+ $ret['function'] = $newFuncName;
+ $ret['source'] = $code;
+ }
+ return $ret;
+ }
+
+ /**
+ * Introspect a php callable and its phpdoc block and extract information about its signature
+ *
+ * @param callable $callable
+ * @param string $plainFuncName
+ * @return array|false
+ */
+ protected function introspectFunction($callable, $plainFuncName)
+ {
+ // start to introspect PHP code
+ if (is_array($callable)) {
+ $func = new \ReflectionMethod($callable[0], $callable[1]);
+ if ($func->isPrivate()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is private: ' . $plainFuncName);
+ return false;
+ }
+ if ($func->isProtected()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is protected: ' . $plainFuncName);
+ return false;
+ }
+ if ($func->isConstructor()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is the constructor: ' . $plainFuncName);
+ return false;
+ }
+ if ($func->isDestructor()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is the destructor: ' . $plainFuncName);
+ return false;
+ }
+ if ($func->isAbstract()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is abstract: ' . $plainFuncName);
+ return false;
+ }
+ /// @todo add more checks for static vs. nonstatic?
+ } else {
+ $func = new \ReflectionFunction($callable);
+ }
+ if ($func->isInternal()) {
+ // Note: from PHP 5.1.0 onward, we will possibly be able to use invokeargs
+ // instead of getparameters to fully reflect internal php functions ?
+ error_log('XML-RPC: ' . __METHOD__ . ': function to be wrapped is internal: ' . $plainFuncName);
+ return false;
+ }
+
+ // retrieve parameter names, types and description from javadoc comments
+
+ // function description
+ $desc = '';
+ // type of return val: by default 'any'
+ $returns = Value::$xmlrpcValue;
+ // desc of return val
+ $returnsDocs = '';
+ // type + name of function parameters
+ $paramDocs = array();
+
+ $docs = $func->getDocComment();
+ if ($docs != '') {
+ $docs = explode("\n", $docs);
+ $i = 0;
+ foreach ($docs as $doc) {
+ $doc = trim($doc, " \r\t/*");
+ if (strlen($doc) && strpos($doc, '@') !== 0 && !$i) {
+ if ($desc) {
+ $desc .= "\n";
+ }
+ $desc .= $doc;
+ } elseif (strpos($doc, '@param') === 0) {
+ // syntax: @param type $name [desc]
+ if (preg_match('/@param\s+(\S+)\s+(\$\S+)\s*(.+)?/', $doc, $matches)) {
+ $name = strtolower(trim($matches[2]));
+ //$paramDocs[$name]['name'] = trim($matches[2]);
+ $paramDocs[$name]['doc'] = isset($matches[3]) ? $matches[3] : '';
+ $paramDocs[$name]['type'] = $matches[1];
+ }
+ $i++;
+ } elseif (strpos($doc, '@return') === 0) {
+ // syntax: @return type [desc]
+ if (preg_match('/@return\s+(\S+)(\s+.+)?/', $doc, $matches)) {
+ $returns = $matches[1];
+ if (isset($matches[2])) {
+ $returnsDocs = trim($matches[2]);
+ }
+ }
+ }
+ }
+ }
+
+ // execute introspection of actual function prototype
+ $params = array();
+ $i = 0;
+ foreach ($func->getParameters() as $paramObj) {
+ $params[$i] = array();
+ $params[$i]['name'] = '$' . $paramObj->getName();
+ $params[$i]['isoptional'] = $paramObj->isOptional();
+ $i++;
+ }
+
+ return array(
+ 'desc' => $desc,
+ 'docs' => $docs,
+ 'params' => $params, // array, positionally indexed
+ 'paramDocs' => $paramDocs, // array, indexed by name
+ 'returns' => $returns,
+ 'returnsDocs' =>$returnsDocs,
+ );
+ }
+
+ /**
+ * Given the method description given by introspection, create method signature data
+ *
+ * @todo support better docs with multiple types separated by pipes by creating multiple signatures
+ * (this is questionable, as it might produce a big matrix of possible signatures with many such occurrences)
+ *
+ * @param array $funcDesc as generated by self::introspectFunction()
+ *
+ * @return array
+ */
+ protected function buildMethodSignatures($funcDesc)
+ {
+ $i = 0;
+ $parsVariations = array();
+ $pars = array();
+ $pNum = count($funcDesc['params']);
+ foreach ($funcDesc['params'] as $param) {
+ /* // match by name real param and documented params
+ $name = strtolower($param['name']);
+ if (!isset($funcDesc['paramDocs'][$name])) {
+ $funcDesc['paramDocs'][$name] = array();
+ }
+ if (!isset($funcDesc['paramDocs'][$name]['type'])) {
+ $funcDesc['paramDocs'][$name]['type'] = 'mixed';
+ }*/
+
+ if ($param['isoptional']) {
+ // this particular parameter is optional. save as valid previous list of parameters
+ $parsVariations[] = $pars;
+ }
+
+ $pars[] = "\$p$i";
+ $i++;
+ if ($i == $pNum) {
+ // last allowed parameters combination
+ $parsVariations[] = $pars;
+ }
+ }
+
+ if (count($parsVariations) == 0) {
+ // only known good synopsis = no parameters
+ $parsVariations[] = array();
+ }
+
+ $sigs = array();
+ $sigsDocs = array();
+ foreach ($parsVariations as $pars) {
+ // build a signature
+ $sig = array($this->php2XmlrpcType($funcDesc['returns']));
+ $pSig = array($funcDesc['returnsDocs']);
+ for ($i = 0; $i < count($pars); $i++) {
+ $name = strtolower($funcDesc['params'][$i]['name']);
+ if (isset($funcDesc['paramDocs'][$name]['type'])) {
+ $sig[] = $this->php2XmlrpcType($funcDesc['paramDocs'][$name]['type']);
+ } else {
+ $sig[] = Value::$xmlrpcValue;
+ }
+ $pSig[] = isset($funcDesc['paramDocs'][$name]['doc']) ? $funcDesc['paramDocs'][$name]['doc'] : '';
+ }
+ $sigs[] = $sig;
+ $sigsDocs[] = $pSig;
+ }
+
+ return array(
+ 'sigs' => $sigs,
+ 'sigsDocs' => $sigsDocs
+ );
+ }
+
+ /**
+ * Creates a closure that will execute $callable
+ * @todo validate params? In theory all validation is left to the dispatch map...
+ * @todo add support for $catchWarnings
+ *
+ * @param $callable
+ * @param array $extraOptions
+ * @param string $plainFuncName
+ * @param string $funcDesc
+ * @return \Closure
+ */
+ protected function buildWrapFunctionClosure($callable, $extraOptions, $plainFuncName, $funcDesc)
+ {
+ $function = function($req) use($callable, $extraOptions, $funcDesc)
+ {
+ $nameSpace = '\\PhpXmlRpc\\';
+ $encoderClass = $nameSpace.'Encoder';
+ $responseClass = $nameSpace.'Response';
+ $valueClass = $nameSpace.'Value';
+
+ // validate number of parameters received
+ // this should be optional really, as we assume the server does the validation
+ $minPars = count($funcDesc['params']);
+ $maxPars = $minPars;
+ foreach ($funcDesc['params'] as $i => $param) {
+ if ($param['isoptional']) {
+ // this particular parameter is optional. We assume later ones are as well
+ $minPars = $i;
+ break;
+ }
+ }
+ $numPars = $req->getNumParams();
+ if ($numPars < $minPars || $numPars > $maxPars) {
+ return new $responseClass(0, 3, 'Incorrect parameters passed to method');
+ }
+
+ $encoder = new $encoderClass();
+ $options = array();
+ if (isset($extraOptions['decode_php_objs']) && $extraOptions['decode_php_objs']) {
+ $options[] = 'decode_php_objs';
+ }
+ $params = $encoder->decode($req, $options);
+
+ $result = call_user_func_array($callable, $params);
+
+ if (! is_a($result, $responseClass)) {
+ if ($funcDesc['returns'] == Value::$xmlrpcDateTime || $funcDesc['returns'] == Value::$xmlrpcBase64) {
+ $result = new $valueClass($result, $funcDesc['returns']);
+ } else {
+ $options = array();
+ if (isset($extraOptions['encode_php_objs']) && $extraOptions['encode_php_objs']) {
+ $options[] = 'encode_php_objs';
+ }
+
+ $result = $encoder->encode($result, $options);
+ }
+ $result = new $responseClass($result);
+ }
+
+ return $result;
+ };
+
+ return $function;
+ }
+
+ /**
+ * Return a name for a new function, based on $callable, insuring its uniqueness
+ * @param mixed $callable a php callable, or the name of an xmlrpc method
+ * @param string $newFuncName when not empty, it is used instead of the calculated version
+ * @return string
+ */
+ protected function newFunctionName($callable, $newFuncName, $extraOptions)
+ {
+ // determine name of new php function
+
+ $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
+
+ if ($newFuncName == '') {
+ if (is_array($callable)) {
+ if (is_string($callable[0])) {
+ $xmlrpcFuncName = "{$prefix}_" . implode('_', $callable);
+ } else {
+ $xmlrpcFuncName = "{$prefix}_" . get_class($callable[0]) . '_' . $callable[1];
+ }
+ } else {
+ if ($callable instanceof \Closure) {
+ $xmlrpcFuncName = "{$prefix}_closure";
+ } else {
+ $callable = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
+ array('_', ''), $callable);
+ $xmlrpcFuncName = "{$prefix}_$callable";
+ }
+ }
+ } else {
+ $xmlrpcFuncName = $newFuncName;
+ }
+
+ while (function_exists($xmlrpcFuncName)) {
+ $xmlrpcFuncName .= 'x';
+ }
+
+ return $xmlrpcFuncName;
+ }
+
+ /**
+ * @param $callable
+ * @param string $newFuncName
+ * @param array $extraOptions
+ * @param string $plainFuncName
+ * @param array $funcDesc
+ * @return string
+ *
+ * @todo add a nice phpdoc block in the generated source
+ */
+ protected function buildWrapFunctionSource($callable, $newFuncName, $extraOptions, $plainFuncName, $funcDesc)
+ {
+ $namespace = '\\PhpXmlRpc\\';
+
+ $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+ $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+ $catchWarnings = isset($extraOptions['suppress_warnings']) && $extraOptions['suppress_warnings'] ? '@' : '';
+
+ $i = 0;
+ $parsVariations = array();
+ $pars = array();
+ $pNum = count($funcDesc['params']);
+ foreach ($funcDesc['params'] as $param) {
+
+ if ($param['isoptional']) {
+ // this particular parameter is optional. save as valid previous list of parameters
+ $parsVariations[] = $pars;
+ }
+
+ $pars[] = "\$p[$i]";
+ $i++;
+ if ($i == $pNum) {
+ // last allowed parameters combination
+ $parsVariations[] = $pars;
+ }
+ }
+
+ if (count($parsVariations) == 0) {
+ // only known good synopsis = no parameters
+ $parsVariations[] = array();
+ $minPars = 0;
+ $maxPars = 0;
+ } else {
+ $minPars = count($parsVariations[0]);
+ $maxPars = count($parsVariations[count($parsVariations)-1]);
+ }
+
+ // build body of new function
+
+ $innerCode = "\$paramCount = \$req->getNumParams();\n";
+ $innerCode .= "if (\$paramCount < $minPars || \$paramCount > $maxPars) return new {$namespace}Response(0, " . PhpXmlRpc::$xmlrpcerr['incorrect_params'] . ", '" . PhpXmlRpc::$xmlrpcstr['incorrect_params'] . "');\n";
+
+ $innerCode .= "\$encoder = new {$namespace}Encoder();\n";
+ if ($decodePhpObjects) {
+ $innerCode .= "\$p = \$encoder->decode(\$req, array('decode_php_objs'));\n";
+ } else {
+ $innerCode .= "\$p = \$encoder->decode(\$req);\n";
+ }
+
+ // since we are building source code for later use, if we are given an object instance,
+ // we go out of our way and store a pointer to it in a static class var var...
+ if (is_array($callable) && is_object($callable[0])) {
+ self::$objHolder[$newFuncName] = $callable[0];
+ $innerCode .= "\$obj = PhpXmlRpc\\Wrapper::\$objHolder['$newFuncName'];\n";
+ $realFuncName = '$obj->' . $callable[1];
+ } else {
+ $realFuncName = $plainFuncName;
+ }
+ foreach ($parsVariations as $i => $pars) {
+ $innerCode .= "if (\$paramCount == " . count($pars) . ") \$retval = {$catchWarnings}$realFuncName(" . implode(',', $pars) . ");\n";
+ if ($i < (count($parsVariations) - 1))
+ $innerCode .= "else\n";
+ }
+ $innerCode .= "if (is_a(\$retval, '{$namespace}Response')) return \$retval; else\n";
+ if ($funcDesc['returns'] == Value::$xmlrpcDateTime || $funcDesc['returns'] == Value::$xmlrpcBase64) {
+ $innerCode .= "return new {$namespace}Response(new {$namespace}Value(\$retval, '{$funcDesc['returns']}'));";
+ } else {
+ if ($encodePhpObjects) {
+ $innerCode .= "return new {$namespace}Response(\$encoder->encode(\$retval, array('encode_php_objs')));\n";
+ } else {
+ $innerCode .= "return new {$namespace}Response(\$encoder->encode(\$retval));\n";
+ }
+ }
+ // shall we exclude functions returning by ref?
+ // if($func->returnsReference())
+ // return false;
+
+ $code = "function $newFuncName(\$req) {\n" . $innerCode . "\n}";
+
+ return $code;
+ }
+
+ /**
+ * Given a user-defined PHP class or php object, map its methods onto a list of
+ * PHP 'wrapper' functions that can be exposed as xmlrpc methods from an xmlrpc server
+ * object and called from remote clients (as well as their corresponding signature info).
+ *
+ * @param string|object $className the name of the class whose methods are to be exposed as xmlrpc methods, or an object instance of that class
+ * @param array $extraOptions see the docs for wrapPhpMethod for basic options, plus
+ * - string method_type 'static', 'nonstatic', 'all' and 'auto' (default); the latter will switch between static and non-static depending on whether $className is a class name or object instance
+ * - string method_filter a regexp used to filter methods to wrap based on their names
+ * - string prefix used for the names of the xmlrpc methods created
+ *
+ * @return array|false false on failure
+ */
+ public function wrapPhpClass($className, $extraOptions = array())
+ {
+ $methodFilter = isset($extraOptions['method_filter']) ? $extraOptions['method_filter'] : '';
+ $methodType = isset($extraOptions['method_type']) ? $extraOptions['method_type'] : 'auto';
+ $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : '';
+
+ $results = array();
+ $mList = get_class_methods($className);
+ foreach ($mList as $mName) {
+ if ($methodFilter == '' || preg_match($methodFilter, $mName)) {
+ $func = new \ReflectionMethod($className, $mName);
+ if (!$func->isPrivate() && !$func->isProtected() && !$func->isConstructor() && !$func->isDestructor() && !$func->isAbstract()) {
+ if (($func->isStatic() && ($methodType == 'all' || $methodType == 'static' || ($methodType == 'auto' && is_string($className)))) ||
+ (!$func->isStatic() && ($methodType == 'all' || $methodType == 'nonstatic' || ($methodType == 'auto' && is_object($className))))
+ ) {
+ $methodWrap = $this->wrapPhpFunction(array($className, $mName), '', $extraOptions);
+ if ($methodWrap) {
+ if (is_object($className)) {
+ $realClassName = get_class($className);
+ }else {
+ $realClassName = $className;
+ }
+ $results[$prefix."$realClassName.$mName"] = $methodWrap;
+ }
+ }
+ }
+ }
+ }
+
+ return $results;
+ }
+
+ /**
+ * Given an xmlrpc client and a method name, register a php wrapper function
+ * that will call it and return results using native php types for both
+ * params and results. The generated php function will return a Response
+ * object for failed xmlrpc calls.
+ *
+ * Known limitations:
+ * - server must support system.methodsignature for the wanted xmlrpc method
+ * - for methods that expose many signatures, only one can be picked (we
+ * could in principle check if signatures differ only by number of params
+ * and not by type, but it would be more complication than we can spare time)
+ * - nested xmlrpc params: the caller of the generated php function has to
+ * encode on its own the params passed to the php function if these are structs
+ * or arrays whose (sub)members include values of type datetime or base64
+ *
+ * Notes: the connection properties of the given client will be copied
+ * and reused for the connection used during the call to the generated
+ * php function.
+ * Calling the generated php function 'might' be slow: a new xmlrpc client
+ * is created on every invocation and an xmlrpc-connection opened+closed.
+ * An extra 'debug' param is appended to param list of xmlrpc method, useful
+ * for debugging purposes.
+ *
+ * @todo allow caller to give us the method signature instead of querying for it, or just say 'skip it'
+ * @todo if we can not retrieve method signature, create a php function with varargs
+ * @todo allow the created function to throw exceptions on method calls failures
+ * @todo if caller did not specify a specific sig, shall we support all of them?
+ * It might be hard (hence slow) to match based on type and number of arguments...
+ *
+ * @param Client $client an xmlrpc client set up correctly to communicate with target server
+ * @param string $methodName the xmlrpc method to be mapped to a php function
+ * @param array $extraOptions array of options that specify conversion details. Valid options include
+ * - integer signum the index of the method signature to use in mapping (if method exposes many sigs)
+ * - integer timeout timeout (in secs) to be used when executing function/calling remote method
+ * - string protocol 'http' (default), 'http11' or 'https'
+ * - string new_function_name the name of php function to create, when return_source is used. If unspecified, lib will pick an appropriate name
+ * - string return_source if true return php code w. function definition instead of function itself (closure)
+ * - bool encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
+ * - bool decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
+ * - mixed return_on_fault a php value to be returned when the xmlrpc call fails/returns a fault response (by default the Response object is returned in this case). If a string is used, '%faultCode%' and '%faultString%' tokens will be substituted with actual error values
+ * - bool debug set it to 1 or 2 to see debug results of querying server for method synopsis
+ * - int simple_client_copy set it to 1 to have a lightweight copy of the $client object made in the generated code (only used when return_source = true)
+ *
+ * @return \closure|array|false false on failure, closure by default and array for return_source = true
+ */
+ public function wrapXmlrpcMethod($client, $methodName, $extraOptions = array())
+ {
+ $newFuncName = isset($extraOptions['new_function_name']) ? $extraOptions['new_function_name'] : '';
+
+ $buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
+
+ $mSig = $this->retrieveMethodSignature($client, $methodName, $extraOptions);
+ if (!$mSig) {
+ return false;
+ }
+
+ if ($buildIt) {
+ return $this->buildWrapMethodClosure($client, $methodName, $extraOptions, $mSig);
+ } else {
+ // if in 'offline' mode, retrieve method description too.
+ // in online mode, favour speed of operation
+ $mDesc = $this->retrieveMethodHelp($client, $methodName, $extraOptions);
+
+ $newFuncName = $this->newFunctionName($methodName, $newFuncName, $extraOptions);
+
+ $results = $this->buildWrapMethodSource($client, $methodName, $extraOptions, $newFuncName, $mSig, $mDesc);
+ /* was: $results = $this->build_remote_method_wrapper_code($client, $methodName,
+ $newFuncName, $mSig, $mDesc, $timeout, $protocol, $simpleClientCopy,
+ $prefix, $decodePhpObjects, $encodePhpObjects, $decodeFault,
+ $faultResponse, $namespace);*/
+
+ $results['function'] = $newFuncName;
+
+ return $results;
+ }
+
+ }
+
+ /**
+ * Retrieves an xmlrpc method signature from a server which supports system.methodSignature
+ * @param Client $client
+ * @param string $methodName
+ * @param array $extraOptions
+ * @return false|array
+ */
+ protected function retrieveMethodSignature($client, $methodName, array $extraOptions = array())
+ {
+ $namespace = '\\PhpXmlRpc\\';
+ $reqClass = $namespace . 'Request';
+ $valClass = $namespace . 'Value';
+ $decoderClass = $namespace . 'Encoder';
+
+ $debug = isset($extraOptions['debug']) ? ($extraOptions['debug']) : 0;
+ $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+ $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+ $sigNum = isset($extraOptions['signum']) ? (int)$extraOptions['signum'] : 0;
+
+ $req = new $reqClass('system.methodSignature');
+ $req->addparam(new $valClass($methodName));
+ $client->setDebug($debug);
+ $response = $client->send($req, $timeout, $protocol);
+ if ($response->faultCode()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method signature from remote server for method ' . $methodName);
+ return false;
+ }
+
+ $mSig = $response->value();
+ if ($client->return_type != 'phpvals') {
+ $decoder = new $decoderClass();
+ $mSig = $decoder->decode($mSig);
+ }
+
+ if (!is_array($mSig) || count($mSig) <= $sigNum) {
+ error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method signature nr.' . $sigNum . ' from remote server for method ' . $methodName);
+ return false;
+ }
+
+ return $mSig[$sigNum];
+ }
+
+ /**
+ * @param Client $client
+ * @param string $methodName
+ * @param array $extraOptions
+ * @return string in case of any error, an empty string is returned, no warnings generated
+ */
+ protected function retrieveMethodHelp($client, $methodName, array $extraOptions = array())
+ {
+ $namespace = '\\PhpXmlRpc\\';
+ $reqClass = $namespace . 'Request';
+ $valClass = $namespace . 'Value';
+
+ $debug = isset($extraOptions['debug']) ? ($extraOptions['debug']) : 0;
+ $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+ $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+
+ $mDesc = '';
+
+ $req = new $reqClass('system.methodHelp');
+ $req->addparam(new $valClass($methodName));
+ $client->setDebug($debug);
+ $response = $client->send($req, $timeout, $protocol);
+ if (!$response->faultCode()) {
+ $mDesc = $response->value();
+ if ($client->return_type != 'phpvals') {
+ $mDesc = $mDesc->scalarval();
+ }
+ }
+
+ return $mDesc;
+ }
+
+ /**
+ * @param Client $client
+ * @param string $methodName
+ * @param array $extraOptions
+ * @param string $mSig
+ * @return \Closure
+ *
+ * @todo should we allow usage of parameter simple_client_copy to mean 'do not clone' in this case?
+ */
+ protected function buildWrapMethodClosure($client, $methodName, array $extraOptions, $mSig)
+ {
+ // we clone the client, so that we can modify it a bit independently of the original
+ $clientClone = clone $client;
+ $function = function() use($clientClone, $methodName, $extraOptions, $mSig)
+ {
+ $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+ $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+ $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+ $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+ if (isset($extraOptions['return_on_fault'])) {
+ $decodeFault = true;
+ $faultResponse = $extraOptions['return_on_fault'];
+ } else {
+ $decodeFault = false;
+ }
+
+ $namespace = '\\PhpXmlRpc\\';
+ $reqClass = $namespace . 'Request';
+ $encoderClass = $namespace . 'Encoder';
+ $valueClass = $namespace . 'Value';
+
+ $encoder = new $encoderClass();
+ $encodeOptions = array();
+ if ($encodePhpObjects) {
+ $encodeOptions[] = 'encode_php_objs';
+ }
+ $decodeOptions = array();
+ if ($decodePhpObjects) {
+ $decodeOptions[] = 'decode_php_objs';
+ }
+
+ /// @todo check for insufficient nr. of args besides excess ones? note that 'source' version does not...
+
+ // support one extra parameter: debug
+ $maxArgs = count($mSig)-1; // 1st element is the return type
+ $currentArgs = func_get_args();
+ if (func_num_args() == ($maxArgs+1)) {
+ $debug = array_pop($currentArgs);
+ $clientClone->setDebug($debug);
+ }
+
+ $xmlrpcArgs = array();
+ foreach($currentArgs as $i => $arg) {
+ if ($i == $maxArgs) {
+ break;
+ }
+ $pType = $mSig[$i+1];
+ if ($pType == 'i4' || $pType == 'i8' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
+ $pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
+ ) {
+ // by building directly xmlrpc values when type is known and scalar (instead of encode() calls),
+ // we make sure to honour the xmlrpc signature
+ $xmlrpcArgs[] = new $valueClass($arg, $pType);
+ } else {
+ $xmlrpcArgs[] = $encoder->encode($arg, $encodeOptions);
+ }
+ }
+
+ $req = new $reqClass($methodName, $xmlrpcArgs);
+ // use this to get the maximum decoding flexibility
+ $clientClone->return_type = 'xmlrpcvals';
+ $resp = $clientClone->send($req, $timeout, $protocol);
+ if ($resp->faultcode()) {
+ if ($decodeFault) {
+ if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) ||
+ (strpos($faultResponse, '%faultString%') !== false))) {
+ $faultResponse = str_replace(array('%faultCode%', '%faultString%'),
+ array($resp->faultCode(), $resp->faultString()), $faultResponse);
+ }
+ return $faultResponse;
+ } else {
+ return $resp;
+ }
+ } else {
+ return $encoder->decode($resp->value(), $decodeOptions);
+ }
+ };
+
+ return $function;
+ }
+
+ /**
+ * @param Client $client
+ * @param string $methodName
+ * @param array $extraOptions
+ * @param string $newFuncName
+ * @param array $mSig
+ * @param string $mDesc
+ * @return array
+ */
+ public function buildWrapMethodSource($client, $methodName, array $extraOptions, $newFuncName, $mSig, $mDesc='')
+ {
+ $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+ $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+ $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+ $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+ $clientCopyMode = isset($extraOptions['simple_client_copy']) ? (int)($extraOptions['simple_client_copy']) : 0;
+ $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
+ if (isset($extraOptions['return_on_fault'])) {
+ $decodeFault = true;
+ $faultResponse = $extraOptions['return_on_fault'];
+ } else {
+ $decodeFault = false;
+ $faultResponse = '';
+ }
+
+ $namespace = '\\PhpXmlRpc\\';
+
+ $code = "function $newFuncName (";
+ if ($clientCopyMode < 2) {
+ // client copy mode 0 or 1 == full / partial client copy in emitted code
+ $verbatimClientCopy = !$clientCopyMode;
+ $innerCode = $this->buildClientWrapperCode($client, $verbatimClientCopy, $prefix, $namespace);
+ $innerCode .= "\$client->setDebug(\$debug);\n";
+ $this_ = '';
+ } else {
+ // client copy mode 2 == no client copy in emitted code
+ $innerCode = '';
+ $this_ = 'this->';
+ }
+ $innerCode .= "\$req = new {$namespace}Request('$methodName');\n";
+
+ if ($mDesc != '') {
+ // take care that PHP comment is not terminated unwillingly by method description
+ $mDesc = "/**\n* " . str_replace('*/', '* /', $mDesc) . "\n";
+ } else {
+ $mDesc = "/**\nFunction $newFuncName\n";
+ }
+
+ // param parsing
+ $innerCode .= "\$encoder = new {$namespace}Encoder();\n";
+ $plist = array();
+ $pCount = count($mSig);
+ for ($i = 1; $i < $pCount; $i++) {
+ $plist[] = "\$p$i";
+ $pType = $mSig[$i];
+ if ($pType == 'i4' || $pType == 'i8' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
+ $pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
+ ) {
+ // only build directly xmlrpc values when type is known and scalar
+ $innerCode .= "\$p$i = new {$namespace}Value(\$p$i, '$pType');\n";
+ } else {
+ if ($encodePhpObjects) {
+ $innerCode .= "\$p$i = \$encoder->encode(\$p$i, array('encode_php_objs'));\n";
+ } else {
+ $innerCode .= "\$p$i = \$encoder->encode(\$p$i);\n";
+ }
+ }
+ $innerCode .= "\$req->addparam(\$p$i);\n";
+ $mDesc .= '* @param ' . $this->xmlrpc2PhpType($pType) . " \$p$i\n";
+ }
+ if ($clientCopyMode < 2) {
+ $plist[] = '$debug=0';
+ $mDesc .= "* @param int \$debug when 1 (or 2) will enable debugging of the underlying {$prefix} call (defaults to 0)\n";
+ }
+ $plist = implode(', ', $plist);
+ $mDesc .= '* @return ' . $this->xmlrpc2PhpType($mSig[0]) . " (or an {$namespace}Response obj instance if call fails)\n*/\n";
+
+ $innerCode .= "\$res = \${$this_}client->send(\$req, $timeout, '$protocol');\n";
+ if ($decodeFault) {
+ if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) || (strpos($faultResponse, '%faultString%') !== false))) {
+ $respCode = "str_replace(array('%faultCode%', '%faultString%'), array(\$res->faultCode(), \$res->faultString()), '" . str_replace("'", "''", $faultResponse) . "')";
+ } else {
+ $respCode = var_export($faultResponse, true);
+ }
+ } else {
+ $respCode = '$res';
+ }
+ if ($decodePhpObjects) {
+ $innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value(), array('decode_php_objs'));";
+ } else {
+ $innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value());";
+ }
+
+ $code = $code . $plist . ") {\n" . $innerCode . "\n}\n";
+
+ return array('source' => $code, 'docstring' => $mDesc);
+ }
+
+ /**
+ * Similar to wrapXmlrpcMethod, but will generate a php class that wraps
+ * all xmlrpc methods exposed by the remote server as own methods.
+ * For more details see wrapXmlrpcMethod.
+ *
+ * For a slimmer alternative, see the code in demo/client/proxy.php
+ *
+ * Note that unlike wrapXmlrpcMethod, we always have to generate php code here. It seems that php 7 will have anon classes...
+ *
+ * @param Client $client the client obj all set to query the desired server
+ * @param array $extraOptions list of options for wrapped code. See the ones from wrapXmlrpcMethod plus
+ * - string method_filter regular expression
+ * - string new_class_name
+ * - string prefix
+ * - bool simple_client_copy set it to true to avoid copying all properties of $client into the copy made in the new class
+ *
+ * @return mixed false on error, the name of the created class if all ok or an array with code, class name and comments (if the appropriatevoption is set in extra_options)
+ */
+ public function wrapXmlrpcServer($client, $extraOptions = array())
+ {
+ $methodFilter = isset($extraOptions['method_filter']) ? $extraOptions['method_filter'] : '';
+ $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+ $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+ $newClassName = isset($extraOptions['new_class_name']) ? $extraOptions['new_class_name'] : '';
+ $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+ $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+ $verbatimClientCopy = isset($extraOptions['simple_client_copy']) ? !($extraOptions['simple_client_copy']) : true;
+ $buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
+ $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
+ $namespace = '\\PhpXmlRpc\\';
+
+ $reqClass = $namespace . 'Request';
+ $decoderClass = $namespace . 'Encoder';
+
+ $req = new $reqClass('system.listMethods');
+ $response = $client->send($req, $timeout, $protocol);
+ if ($response->faultCode()) {
+ error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method list from remote server');
+
+ return false;
+ } else {
+ $mList = $response->value();
+ if ($client->return_type != 'phpvals') {
+ $decoder = new $decoderClass();
+ $mList = $decoder->decode($mList);
+ }
+ if (!is_array($mList) || !count($mList)) {
+ error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve meaningful method list from remote server');
+
+ return false;
+ } else {
+ // pick a suitable name for the new function, avoiding collisions
+ if ($newClassName != '') {
+ $xmlrpcClassName = $newClassName;
+ } else {
+ $xmlrpcClassName = $prefix . '_' . preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
+ array('_', ''), $client->server) . '_client';
+ }
+ while ($buildIt && class_exists($xmlrpcClassName)) {
+ $xmlrpcClassName .= 'x';
+ }
+
+ /// @todo add function setdebug() to new class, to enable/disable debugging
+ $source = "class $xmlrpcClassName\n{\npublic \$client;\n\n";
+ $source .= "function __construct()\n{\n";
+ $source .= $this->buildClientWrapperCode($client, $verbatimClientCopy, $prefix, $namespace);
+ $source .= "\$this->client = \$client;\n}\n\n";
+ $opts = array(
+ 'return_source' => true,
+ 'simple_client_copy' => 2, // do not produce code to copy the client object
+ 'timeout' => $timeout,
+ 'protocol' => $protocol,
+ 'encode_php_objs' => $encodePhpObjects,
+ 'decode_php_objs' => $decodePhpObjects,
+ 'prefix' => $prefix,
+ );
+ /// @todo build phpdoc for class definition, too
+ foreach ($mList as $mName) {
+ if ($methodFilter == '' || preg_match($methodFilter, $mName)) {
+ // note: this will fail if server exposes 2 methods called f.e. do.something and do_something
+ $opts['new_function_name'] = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
+ array('_', ''), $mName);
+ $methodWrap = $this->wrapXmlrpcMethod($client, $mName, $opts);
+ if ($methodWrap) {
+ if (!$buildIt) {
+ $source .= $methodWrap['docstring'];
+ }
+ $source .= $methodWrap['source'] . "\n";
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': will not create class method to wrap remote method ' . $mName);
+ }
+ }
+ }
+ $source .= "}\n";
+ if ($buildIt) {
+ $allOK = 0;
+ eval($source . '$allOK=1;');
+ if ($allOK) {
+ return $xmlrpcClassName;
+ } else {
+ error_log('XML-RPC: ' . __METHOD__ . ': could not create class ' . $xmlrpcClassName . ' to wrap remote server ' . $client->server);
+ return false;
+ }
+ } else {
+ return array('class' => $xmlrpcClassName, 'code' => $source, 'docstring' => '');
+ }
+ }
+ }
+ }
+
+ /**
+ * Given necessary info, generate php code that will build a client object just like the given one.
+ * Take care that no full checking of input parameters is done to ensure that
+ * valid php code is emitted.
+ * @param Client $client
+ * @param bool $verbatimClientCopy when true, copy all of the state of the client, except for 'debug' and 'return_type'
+ * @param string $prefix used for the return_type of the created client
+ * @param string $namespace
+ *
+ * @return string
+ */
+ protected function buildClientWrapperCode($client, $verbatimClientCopy, $prefix = 'xmlrpc', $namespace = '\\PhpXmlRpc\\' )
+ {
+ $code = "\$client = new {$namespace}Client('" . str_replace("'", "\'", $client->path) .
+ "', '" . str_replace("'", "\'", $client->server) . "', $client->port);\n";
+
+ // copy all client fields to the client that will be generated runtime
+ // (this provides for future expansion or subclassing of client obj)
+ if ($verbatimClientCopy) {
+ foreach ($client as $fld => $val) {
+ if ($fld != 'debug' && $fld != 'return_type') {
+ $val = var_export($val, true);
+ $code .= "\$client->$fld = $val;\n";
+ }
+ }
+ }
+ // only make sure that client always returns the correct data type
+ $code .= "\$client->return_type = '{$prefix}vals';\n";
+ //$code .= "\$client->setDebug(\$debug);\n";
+ return $code;
+ }
+}
--- /dev/null
+<?php
+/**
+ * @author JoakimLofgren
+ */
+
+use PhpXmlRpc\Helper\Charset;
+
+/**
+ * Test conversion between encodings
+ *
+ * For Windows if you want to test the output use Consolas font
+ * and run the following in cmd:
+ * chcp 28591 (latin1)
+ * chcp 65001 (utf8)
+ */
+class CharsetTest extends PHPUnit_Framework_TestCase
+{
+ // Consolas font should render these properly
+ protected $runes = "ᚠᛇᚻ᛫ᛒᛦᚦ᛫ᚠᚱᚩᚠᚢᚱ᛫ᚠᛁᚱᚪ᛫ᚷᛖᚻᚹᛦᛚᚳᚢᛗ";
+ protected $greek = "Τὴ γλῶσσα μοῦ ἔδωσαν ἑλληνικὴ";
+ protected $russian = "Река неслася; бедный чёлн";
+ protected $chinese = "我能吞下玻璃而不伤身体。";
+ protected $latinString;
+
+ protected function setUp()
+ {
+ // construct a latin string with all chars (except control ones)
+ $this->latinString = "\n\r\t";
+ for($i = 32; $i < 127; $i++) {
+ $this->latinString .= chr($i);
+ }
+ for($i = 160; $i < 256; $i++) {
+ $this->latinString .= chr($i);
+ }
+ }
+
+ protected function utfToLatin($data)
+ {
+ return Charset::instance()->encodeEntities(
+ $data,
+ 'UTF-8',
+ 'ISO-8859-1'
+ );
+ }
+
+ public function testUtf8ToLatin1All()
+ {
+ /*$this->assertEquals(
+ 'ISO-8859-1',
+ mb_detect_encoding($this->latinString, 'ISO-8859-1, UTF-8, WINDOWS-1251, ASCII', true),
+ 'Setup latinString is not ISO-8859-1 encoded...'
+ );*/
+ $string = utf8_encode($this->latinString);
+ $encoded = $this->utfToLatin($string);
+ $this->assertEquals(str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $this->latinString), $encoded);
+ }
+
+ public function testUtf8ToLatin1EuroSymbol()
+ {
+ $string = 'a.b.c.å.ä.ö.€.';
+ $encoded = $this->utfToLatin($string);
+ $this->assertEquals(utf8_decode('a.b.c.å.ä.ö.€.'), $encoded);
+ }
+
+ public function testUtf8ToLatin1Runes()
+ {
+ $string = $this->runes;
+ $encoded = $this->utfToLatin($string);
+ $this->assertEquals('ᚠᛇᚻ᛫ᛒᛦᚦ᛫ᚠᚱᚩᚠᚢᚱ᛫ᚠᛁᚱᚪ᛫ᚷᛖᚻᚹᛦᛚᚳᚢᛗ', $encoded);
+ }
+
+ public function testUtf8ToLatin1Greek()
+ {
+ $string = $this->greek;
+ $encoded = $this->utfToLatin($string);
+ $this->assertEquals('Τὴ γλῶσσα μοῦ ἔδωσαν ἑλληνικὴ', $encoded);
+ }
+
+ public function testUtf8ToLatin1Russian()
+ {
+ $string = $this->russian;
+ $encoded = $this->utfToLatin($string);
+ $this->assertEquals('Река неслася; бедный чёлн', $encoded);
+ }
+
+ public function testUtf8ToLatin1Chinese()
+ {
+ $string = $this->chinese;
+ $encoded = $this->utfToLatin($string);
+ $this->assertEquals('我能吞下玻璃而不伤身体。', $encoded);
+ }
+}
--- /dev/null
+<?php
+/**
+ * NB: do not let your IDE fool you. The correct encoding for this file is NOT UTF8.
+ */
+include_once __DIR__ . '/../lib/xmlrpc.inc';
+include_once __DIR__ . '/../lib/xmlrpcs.inc';
+
+include_once __DIR__ . '/parse_args.php';
+
+/**
+ * Tests involving parsing of xml and handling of xmlrpc values
+ */
+class ParsingBugsTests extends PHPUnit_Framework_TestCase
+{
+ public $args = array();
+
+ protected function setUp()
+ {
+ $this->args = argParser::getArgs();
+ if ($this->args['DEBUG'] == 1)
+ ob_start();
+ }
+
+ protected function tearDown()
+ {
+ if ($this->args['DEBUG'] != 1)
+ return;
+ $out = ob_get_clean();
+ $status = $this->getStatus();
+ if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR
+ || $status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE) {
+ echo $out;
+ }
+ }
+
+ protected function newMsg($methodName, $params = array())
+ {
+ $msg = new xmlrpcmsg($methodName, $params);
+ $msg->setDebug($this->args['DEBUG']);
+ return $msg;
+ }
+
+ public function testMinusOneString()
+ {
+ $v = new xmlrpcval('-1');
+ $u = new xmlrpcval('-1', 'string');
+ $t = new xmlrpcval(-1, 'string');
+ $this->assertEquals($v->scalarval(), $u->scalarval());
+ $this->assertEquals($v->scalarval(), $t->scalarval());
+ }
+
+ /**
+ * This looks funny, and we might call it a bug. But we strive for 100 backwards compat...
+ */
+ public function testMinusOneInt()
+ {
+ $u = new xmlrpcval();
+ $v = new xmlrpcval(-1);
+ $this->assertEquals($u->scalarval(), $v->scalarval());
+ }
+
+ public function testUnicodeInMemberName()
+ {
+ $str = "G" . chr(252) . "nter, El" . chr(232) . "ne";
+ $v = array($str => new xmlrpcval(1));
+ $r = new xmlrpcresp(new xmlrpcval($v, 'struct'));
+ $r = $r->serialize();
+ $m = $this->newMsg('dummy');
+ $r = $m->parseResponse($r);
+ $v = $r->value();
+ $this->assertEquals(true, $v->structmemexists($str));
+ }
+
+ public function testUnicodeInErrorString()
+ {
+ $response = utf8_encode(
+ '<?xml version="1.0"?>
+<!-- $Id -->
+<!-- found by G. giunta, covers what happens when lib receives
+ UTF8 chars in response text and comments -->
+<!-- ' . chr(224) . chr(252) . chr(232) . 'àüè -->
+<methodResponse>
+<fault>
+<value>
+<struct>
+<member>
+<name>faultCode</name>
+<value><int>888</int></value>
+</member>
+<member>
+<name>faultString</name>
+<value><string>' . chr(224) . chr(252) . chr(232) . 'àüè</string></value>
+</member>
+</struct>
+</value>
+</fault>
+</methodResponse>');
+ $m = $this->newMsg('dummy');
+ $r = $m->parseResponse($response);
+ $v = $r->faultString();
+ $this->assertEquals(chr(224) . chr(252) . chr(232) . chr(224) . chr(252) . chr(232), $v);
+ }
+
+ public function testValidNumbers()
+ {
+ $m = $this->newMsg('dummy');
+ $fp =
+ '<?xml version="1.0"?>
+<methodResponse>
+<params>
+<param>
+<value>
+<struct>
+<member>
+<name>integer1</name>
+<value><int>01</int></value>
+</member>
+<member>
+<name>integer2</name>
+<value><int>+1</int></value>
+</member>
+<member>
+<name>integer3</name>
+<value><i4>1</i4></value>
+</member>
+<member>
+<name>float1</name>
+<value><double>01.10</double></value>
+</member>
+<member>
+<name>float2</name>
+<value><double>+1.10</double></value>
+</member>
+<member>
+<name>float3</name>
+<value><double>-1.10e2</double></value>
+</member>
+</struct>
+</value>
+</param>
+</params>
+</methodResponse>';
+ $r = $m->parseResponse($fp);
+ $v = $r->value();
+ $s = $v->structmem('integer1');
+ $t = $v->structmem('integer2');
+ $u = $v->structmem('integer3');
+ $x = $v->structmem('float1');
+ $y = $v->structmem('float2');
+ $z = $v->structmem('float3');
+ $this->assertEquals(1, $s->scalarval());
+ $this->assertEquals(1, $t->scalarval());
+ $this->assertEquals(1, $u->scalarval());
+
+ $this->assertEquals(1.1, $x->scalarval());
+ $this->assertEquals(1.1, $y->scalarval());
+ $this->assertEquals(-110.0, $z->scalarval());
+ }
+
+ public function testI8()
+ {
+ if (PHP_INT_SIZE == 4 ) {
+ $this->markTestSkipped('did not find a locale which sets decimal separator to comma');
+ return;
+ }
+
+ $m = $this->newMsg('dummy');
+ $fp =
+ '<?xml version="1.0"?>
+<methodResponse>
+<params>
+<param>
+<value>
+<struct>
+<member>
+<name>integer1</name>
+<value><i8>1</i8></value>
+</member>
+</struct>
+</value>
+</param>
+</params>
+</methodResponse>';
+ $r = $m->parseResponse($fp);
+ $v = $r->value();
+ $s = $v->structmem('integer1');
+ $this->assertEquals(1, $s->scalarval());
+ }
+
+ public function testAddScalarToStruct()
+ {
+ $v = new xmlrpcval(array('a' => 'b'), 'struct');
+ // use @ operator in case error_log gets on screen
+ $r = @$v->addscalar('c');
+ $this->assertEquals(0, $r);
+ }
+
+ public function testAddStructToStruct()
+ {
+ $v = new xmlrpcval(array('a' => new xmlrpcval('b')), 'struct');
+ $r = $v->addstruct(array('b' => new xmlrpcval('c')));
+ $this->assertEquals(2, $v->structsize());
+ $this->assertEquals(1, $r);
+ $r = $v->addstruct(array('b' => new xmlrpcval('b')));
+ $this->assertEquals(2, $v->structsize());
+ }
+
+ public function testAddArrayToArray()
+ {
+ $v = new xmlrpcval(array(new xmlrpcval('a'), new xmlrpcval('b')), 'array');
+ $r = $v->addarray(array(new xmlrpcval('b'), new xmlrpcval('c')));
+ $this->assertEquals(4, $v->arraysize());
+ $this->assertEquals(1, $r);
+ }
+
+ public function testEncodeArray()
+ {
+ $r = range(1, 100);
+ $v = php_xmlrpc_encode($r);
+ $this->assertEquals('array', $v->kindof());
+ }
+
+ public function testEncodeRecursive()
+ {
+ $v = php_xmlrpc_encode(php_xmlrpc_encode('a simple string'));
+ $this->assertEquals('scalar', $v->kindof());
+ }
+
+ public function testBrokenRequests()
+ {
+ $s = new xmlrpc_server();
+ // omitting the 'params' tag: not tolerated by the lib anymore
+ $f = '<?xml version="1.0"?>
+<methodCall>
+<methodName>system.methodHelp</methodName>
+<param>
+<value><string>system.methodHelp</string></value>
+</param>
+</methodCall>';
+ $r = $s->parserequest($f);
+ $this->assertEquals(15, $r->faultCode());
+ // omitting a 'param' tag
+ $f = '<?xml version="1.0"?>
+<methodCall>
+<methodName>system.methodHelp</methodName>
+<params>
+<value><string>system.methodHelp</string></value>
+</params>
+</methodCall>';
+ $r = $s->parserequest($f);
+ $this->assertEquals(15, $r->faultCode());
+ // omitting a 'value' tag
+ $f = '<?xml version="1.0"?>
+<methodCall>
+<methodName>system.methodHelp</methodName>
+<params>
+<param><string>system.methodHelp</string></param>
+</params>
+</methodCall>';
+ $r = $s->parserequest($f);
+ $this->assertEquals(15, $r->faultCode());
+ }
+
+ public function testBrokenResponses()
+ {
+ $m = $this->newMsg('dummy');
+ // omitting the 'params' tag: no more tolerated by the lib...
+ $f = '<?xml version="1.0"?>
+<methodResponse>
+<param>
+<value><string>system.methodHelp</string></value>
+</param>
+</methodResponse>';
+ $r = $m->parseResponse($f);
+ $this->assertEquals(2, $r->faultCode());
+ // omitting the 'param' tag: no more tolerated by the lib...
+ $f = '<?xml version="1.0"?>
+<methodResponse>
+<params>
+<value><string>system.methodHelp</string></value>
+</params>
+</methodResponse>';
+ $r = $m->parseResponse($f);
+ $this->assertEquals(2, $r->faultCode());
+ // omitting a 'value' tag: KO
+ $f = '<?xml version="1.0"?>
+<methodResponse>
+<params>
+<param><string>system.methodHelp</string></param>
+</params>
+</methodResponse>';
+ $r = $m->parseResponse($f);
+ $this->assertEquals(2, $r->faultCode());
+ }
+
+ public function testBuggyHttp()
+ {
+ $s = $this->newMsg('dummy');
+ $f = 'HTTP/1.1 100 Welcome to the jungle
+
+HTTP/1.0 200 OK
+X-Content-Marx-Brothers: Harpo
+ Chico and Groucho
+Content-Length: who knows?
+
+
+
+<?xml version="1.0"?>
+<!-- First of all, let\'s check out if the lib properly handles a commented </methodResponse> tag... -->
+<methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>hello world. 2 newlines follow
+
+
+and there they were.</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+<script type="text\javascript">document.write(\'Hello, my name is added nag, I\\\'m happy to serve your content for free\');</script>
+ ';
+ $r = $s->parseResponse($f);
+ $v = $r->value();
+ $s = $v->structmem('content');
+ $this->assertEquals("hello world. 2 newlines follow\n\n\nand there they were.", $s->scalarval());
+ }
+
+ public function testStringBug()
+ {
+ $s = $this->newMsg('dummy');
+ $f = '<?xml version="1.0"?>
+<!-- $Id -->
+<!-- found by 2z69xks7bpy001@sneakemail.com, amongst others
+ covers what happens when there\'s character data after </string>
+ and before </value> -->
+<methodResponse>
+<params>
+<param>
+<value>
+<struct>
+<member>
+<name>success</name>
+<value>
+<boolean>1</boolean>
+</value>
+</member>
+<member>
+<name>sessionID</name>
+<value>
+<string>S300510007I</string>
+</value>
+</member>
+</struct>
+</value>
+</param>
+</params>
+</methodResponse> ';
+ $r = $s->parseResponse($f);
+ $v = $r->value();
+ $s = $v->structmem('sessionID');
+ $this->assertEquals('S300510007I', $s->scalarval());
+ }
+
+ public function testWhiteSpace()
+ {
+ $s = $this->newMsg('dummy');
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>hello world. 2 newlines follow
+
+
+and there they were.</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f);
+ $v = $r->value();
+ $s = $v->structmem('content');
+ $this->assertEquals("hello world. 2 newlines follow\n\n\nand there they were.", $s->scalarval());
+ }
+
+ public function testDoubleDataInArrayTag()
+ {
+ $s = $this->newMsg('dummy');
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value><array>
+<data></data>
+<data></data>
+</array></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f);
+ $v = $r->faultCode();
+ $this->assertEquals(2, $v);
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value><array>
+<data><value>Hello world</value></data>
+<data></data>
+</array></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f);
+ $v = $r->faultCode();
+ $this->assertEquals(2, $v);
+ }
+
+ public function testDoubleStuffInValueTag()
+ {
+ $s = $this->newMsg('dummy');
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value>
+<string>hello world</string>
+<array><data></data></array>
+</value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f);
+ $v = $r->faultCode();
+ $this->assertEquals(2, $v);
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value>
+<string>hello</string>
+<string>world</string>
+</value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f);
+ $v = $r->faultCode();
+ $this->assertEquals(2, $v);
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value>
+<string>hello</string>
+<struct><member><name>hello><value>world</value></member></struct>
+</value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f);
+ $v = $r->faultCode();
+ $this->assertEquals(2, $v);
+ }
+
+ public function testAutodecodeResponse()
+ {
+ $s = $this->newMsg('dummy');
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>hello world. 2 newlines follow
+
+
+and there they were.</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f, true, 'phpvals');
+ $v = $r->value();
+ $s = $v['content'];
+ $this->assertEquals("hello world. 2 newlines follow\n\n\nand there they were.", $s);
+ }
+
+ public function testNoDecodeResponse()
+ {
+ $s = $this->newMsg('dummy');
+ $f = '<?xml version="1.0"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>hello world. 2 newlines follow
+
+
+and there they were.</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>';
+ $r = $s->parseResponse($f, true, 'xml');
+ $v = $r->value();
+ $this->assertEquals($f, $v);
+ }
+
+ public function testAutoCoDec()
+ {
+ $data1 = array(1, 1.0, 'hello world', true, '20051021T23:43:00', -1, 11.0, '~!@#$%^&*()_+|', false, '20051021T23:43:00');
+ $data2 = array('zero' => $data1, 'one' => $data1, 'two' => $data1, 'three' => $data1, 'four' => $data1, 'five' => $data1, 'six' => $data1, 'seven' => $data1, 'eight' => $data1, 'nine' => $data1);
+ $data = array($data2, $data2, $data2, $data2, $data2, $data2, $data2, $data2, $data2, $data2);
+ //$keys = array('zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine');
+ $v1 = php_xmlrpc_encode($data, array('auto_dates'));
+ $v2 = php_xmlrpc_decode_xml($v1->serialize());
+ $this->assertEquals($v1, $v2);
+ $r1 = new PhpXmlRpc\Response($v1);
+ $r2 = php_xmlrpc_decode_xml($r1->serialize());
+ $r2->serialize(); // needed to set internal member payload
+ $this->assertEquals($r1, $r2);
+ $m1 = new PhpXmlRpc\Request('hello dolly', array($v1));
+ $m2 = php_xmlrpc_decode_xml($m1->serialize());
+ $m2->serialize(); // needed to set internal member payload
+ $this->assertEquals($m1, $m2);
+ }
+
+ public function testUTF8Request()
+ {
+ $sendstring = 'κόσμε'; // Greek word 'kosme'. NB: NOT a valid ISO8859 string!
+ $GLOBALS['xmlrpc_internalencoding'] = 'UTF-8';
+ \PhpXmlRpc\PhpXmlRpc::importGlobals();
+ $f = new xmlrpcval($sendstring, 'string');
+ $v = $f->serialize();
+ $this->assertEquals("<value><string>κόσμε</string></value>\n", $v);
+ $GLOBALS['xmlrpc_internalencoding'] = 'ISO-8859-1';
+ \PhpXmlRpc\PhpXmlRpc::importGlobals();
+ }
+
+ public function testUTF8Response()
+ {
+ $string = chr(224) . chr(252) . chr(232);
+
+ $s = $this->newMsg('dummy');
+ $f = "HTTP/1.1 200 OK\r\nContent-type: text/xml; charset=UTF-8\r\n\r\n" . '<?xml version="1.0"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>' . utf8_encode($string) . '</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f, false, 'phpvals');
+ $v = $r->value();
+ $v = $v['content'];
+ $this->assertEquals($string, $v);
+
+ $f = '<?xml version="1.0" encoding="UTF-8"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>' . utf8_encode($string) . '</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f, false, 'phpvals');
+ $v = $r->value();
+ $v = $v['content'];
+ $this->assertEquals($string, $v);
+
+ $r = php_xmlrpc_decode_xml($f);
+ $v = $r->value();
+ $v = $v->structmem('content')->scalarval();
+ $this->assertEquals($string, $v);
+ }
+
+ public function testLatin1Response()
+ {
+ $string = chr(224) . chr(252) . chr(232);
+
+ $s = $this->newMsg('dummy');
+ $f = "HTTP/1.1 200 OK\r\nContent-type: text/xml; charset=ISO-8859-1\r\n\r\n" . '<?xml version="1.0"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>' . $string . '</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f, false, 'phpvals');
+ $v = $r->value();
+ $v = $v['content'];
+ $this->assertEquals($string, $v);
+
+ $f = '<?xml version="1.0" encoding="ISO-8859-1"?><methodResponse><params><param><value><struct><member><name>userid</name><value>311127</value></member>
+<member><name>dateCreated</name><value><dateTime.iso8601>20011126T09:17:52</dateTime.iso8601></value></member><member><name>content</name><value>' . $string . '</value></member><member><name>postid</name><value>7414222</value></member></struct></value></param></params></methodResponse>
+';
+ $r = $s->parseResponse($f, false, 'phpvals');
+ $v = $r->value();
+ $v = $v['content'];
+ $this->assertEquals($string, $v);
+
+ $r = php_xmlrpc_decode_xml($f);
+ $v = $r->value();
+ $v = $v->structmem('content')->scalarval();
+ $this->assertEquals($string, $v);
+ }
+
+ public function testUTF8IntString()
+ {
+ $v = new xmlrpcval(100, 'int');
+ $s = $v->serialize('UTF-8');
+ $this->assertequals("<value><int>100</int></value>\n", $s);
+ }
+
+ public function testStringInt()
+ {
+ $v = new xmlrpcval('hello world', 'int');
+ $s = $v->serialize();
+ $this->assertequals("<value><int>0</int></value>\n", $s);
+ }
+
+ public function testStructMemExists()
+ {
+ $v = php_xmlrpc_encode(array('hello' => 'world'));
+ $b = $v->structmemexists('hello');
+ $this->assertequals(true, $b);
+ $b = $v->structmemexists('world');
+ $this->assertequals(false, $b);
+ }
+
+ public function testNilvalue()
+ {
+ // default case: we do not accept nil values received
+ $v = new xmlrpcval('hello', 'null');
+ $r = new xmlrpcresp($v);
+ $s = $r->serialize();
+ $m = $this->newMsg('dummy');
+ $r = $m->parseresponse($s);
+ $this->assertequals(2, $r->faultCode());
+ // enable reception of nil values
+ $GLOBALS['xmlrpc_null_extension'] = true;
+ \PhpXmlRpc\PhpXmlRpc::importGlobals();
+ $r = $m->parseresponse($s);
+ $v = $r->value();
+ $this->assertequals('null', $v->scalartyp());
+ // test with the apache version: EX:NIL
+ $GLOBALS['xmlrpc_null_apache_encoding'] = true;
+ \PhpXmlRpc\PhpXmlRpc::importGlobals();
+ // serialization
+ $v = new xmlrpcval('hello', 'null');
+ $s = $v->serialize();
+ $this->assertequals(1, preg_match('#<value><ex:nil/></value>#', $s));
+ // deserialization
+ $r = new xmlrpcresp($v);
+ $s = $r->serialize();
+ $r = $m->parseresponse($s);
+ $v = $r->value();
+ $this->assertequals('null', $v->scalartyp());
+ $GLOBALS['xmlrpc_null_extension'] = false;
+ \PhpXmlRpc\PhpXmlRpc::importGlobals();
+ $r = $m->parseresponse($s);
+ $this->assertequals(2, $r->faultCode());
+ }
+
+ public function testLocale()
+ {
+ $locale = setlocale(LC_NUMERIC, 0);
+ /// @todo on php 5.3/win setting locale to german does not seem to set decimal separator to comma...
+ if (setlocale(LC_NUMERIC, 'deu', 'de_DE@euro', 'de_DE', 'de', 'ge') !== false) {
+ $v = new xmlrpcval(1.1, 'double');
+ if (strpos($v->scalarval(), ',') == 1) {
+ $r = $v->serialize();
+ $this->assertequals(false, strpos($r, ','));
+ setlocale(LC_NUMERIC, $locale);
+ } else {
+ setlocale(LC_NUMERIC, $locale);
+ $this->markTestSkipped('did not find a locale which sets decimal separator to comma');
+ }
+ } else {
+ $this->markTestSkipped('did not find a locale which sets decimal separator to comma');
+ }
+ }
+
+ public function testArrayAccess()
+ {
+ $v1 = new xmlrpcval(array(new xmlrpcval('one'), new xmlrpcval('two')), 'array');
+ $this->assertequals(1, count($v1));
+ $out = array('me' => array(), 'mytype' => 2, '_php_class' => null);
+ foreach($v1 as $key => $val)
+ {
+ $expected = each($out);
+ $this->assertequals($expected['key'], $key);
+ if (gettype($expected['value']) == 'array') {
+ $this->assertequals('array', gettype($val));
+ } else {
+ $this->assertequals($expected['value'], $val);
+ }
+ }
+
+ $v2 = new \PhpXmlRpc\Value(array(new \PhpXmlRpc\Value('one'), new \PhpXmlRpc\Value('two')), 'array');
+ $this->assertequals(2, count($v2));
+ $out = array(0 => 'object', 1 => 'object');
+ foreach($v2 as $key => $val)
+ {
+ $expected = each($out);
+ $this->assertequals($expected['key'], $key);
+ $this->assertequals($expected['value'], gettype($val));
+ }
+ }
+}
--- /dev/null
+<?php
+
+include_once __DIR__ . '/../lib/xmlrpc.inc';
+
+include_once __DIR__ . '/parse_args.php';
+
+/**
+ * Tests involving requests sent to non-existing servers
+ */
+class InvalidHostTest extends PHPUnit_Framework_TestCase
+{
+ /** @var xmlrpc_client $client */
+ public $client = null;
+ public $args = array();
+
+ public function setUp()
+ {
+ $this->args = argParser::getArgs();
+
+ $this->client = new xmlrpc_client('/NOTEXIST.php', $this->args['LOCALSERVER'], 80);
+ $this->client->setDebug($this->args['DEBUG']);
+
+ if ($this->args['DEBUG'] == 1)
+ ob_start();
+ }
+
+ protected function tearDown()
+ {
+ if ($this->args['DEBUG'] != 1)
+ return;
+ $out = ob_get_clean();
+ $status = $this->getStatus();
+ if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR
+ || $status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE) {
+ echo $out;
+ }
+ }
+
+ public function test404()
+ {
+ $m = new xmlrpcmsg('examples.echo', array(
+ new xmlrpcval('hello', 'string'),
+ ));
+ $r = $this->client->send($m, 5);
+ $this->assertEquals(5, $r->faultCode());
+ }
+
+ public function testSrvNotFound()
+ {
+ $m = new xmlrpcmsg('examples.echo', array(
+ new xmlrpcval('hello', 'string'),
+ ));
+ $this->client->server .= 'XXX';
+ $r = $this->client->send($m, 5);
+ // make sure there's no freaking catchall DNS in effect
+ $dnsinfo = dns_get_record($this->client->server);
+ if ($dnsinfo) {
+ $this->markTestSkipped('Seems like there is a catchall DNS in effect: host ' . $this->client->server . ' found');
+ } else {
+ $this->assertEquals(5, $r->faultCode());
+ }
+ }
+
+ public function testCurlKAErr()
+ {
+ if (!function_exists('curl_init')) {
+ $this->markTestSkipped('CURL missing: cannot test curl keepalive errors');
+
+ return;
+ }
+ $m = new xmlrpcmsg('examples.stringecho', array(
+ new xmlrpcval('hello', 'string'),
+ ));
+ // test 2 calls w. keepalive: 1st time connection ko, second time ok
+ $this->client->server .= 'XXX';
+ $this->client->keepalive = true;
+ $r = $this->client->send($m, 5, 'http11');
+ // in case we have a "universal dns resolver" getting in the way, we might get a 302 instead of a 404
+ $this->assertTrue($r->faultCode() === 8 || $r->faultCode() == 5);
+
+ // now test a successful connection
+ $server = explode(':', $this->args['LOCALSERVER']);
+ if (count($server) > 1) {
+ $this->client->port = $server[1];
+ }
+ $this->client->server = $server[0];
+ $this->client->path = $this->args['URI'];
+
+ $r = $this->client->send($m, 5, 'http11');
+ $this->assertEquals(0, $r->faultCode());
+ $ro = $r->value();
+ is_object($ro) && $this->assertEquals('hello', $ro->scalarVal());
+ }
+}
--- /dev/null
+<?php
+
+include_once __DIR__ . '/../lib/xmlrpc.inc';
+include_once __DIR__ . '/../lib/xmlrpc_wrappers.inc';
+
+include_once __DIR__ . '/parse_args.php';
+
+/**
+ * Tests which involve interaction between the client and the server.
+ * They are run against the server found in demo/server.php
+ */
+class LocalhostTest extends PHPUnit_Framework_TestCase
+{
+ /** @var xmlrpc_client $client */
+ protected $client = null;
+ protected $method = 'http';
+ protected $timeout = 10;
+ protected $request_compression = null;
+ protected $accepted_compression = '';
+ protected $args = array();
+
+ protected static $failed_tests = array();
+
+ protected $testId;
+ /** @var boolean $collectCodeCoverageInformation */
+ protected $collectCodeCoverageInformation;
+ protected $coverageScriptUrl;
+
+ public static function fail($message = '')
+ {
+ // save in a static var that this particular test has failed
+ // (but only if not called from subclass objects / multitests)
+ if (function_exists('debug_backtrace') && strtolower(get_called_class()) == 'localhosttests') {
+ $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+ for ($i = 0; $i < count($trace); $i++) {
+ if (strpos($trace[$i]['function'], 'test') === 0) {
+ self::$failed_tests[$trace[$i]['function']] = true;
+ break;
+ }
+ }
+ }
+
+ parent::fail($message);
+ }
+
+ /**
+ * Reimplemented to allow us to collect code coverage info from the target server.
+ * Code taken from PHPUnit_Extensions_Selenium2TestCase
+ *
+ * @param PHPUnit_Framework_TestResult $result
+ * @return PHPUnit_Framework_TestResult
+ * @throws Exception
+ */
+ public function run(PHPUnit_Framework_TestResult $result = NULL)
+ {
+ $this->testId = get_class($this) . '__' . $this->getName();
+
+ if ($result === NULL) {
+ $result = $this->createResult();
+ }
+
+ $this->collectCodeCoverageInformation = $result->getCollectCodeCoverageInformation();
+
+ parent::run($result);
+
+ if ($this->collectCodeCoverageInformation) {
+ $coverage = new PHPUnit_Extensions_SeleniumCommon_RemoteCoverage(
+ $this->coverageScriptUrl,
+ $this->testId
+ );
+ $result->getCodeCoverage()->append(
+ $coverage->get(), $this
+ );
+ }
+
+ // do not call this before to give the time to the Listeners to run
+ //$this->getStrategy()->endOfTest($this->session);
+
+ return $result;
+ }
+
+ public function setUp()
+ {
+ $this->args = argParser::getArgs();
+
+ $server = explode(':', $this->args['LOCALSERVER']);
+ if (count($server) > 1) {
+ $this->client = new xmlrpc_client($this->args['URI'], $server[0], $server[1]);
+ } else {
+ $this->client = new xmlrpc_client($this->args['URI'], $this->args['LOCALSERVER']);
+ }
+
+ $this->client->setDebug($this->args['DEBUG']);
+ $this->client->request_compression = $this->request_compression;
+ $this->client->accepted_compression = $this->accepted_compression;
+
+ $this->coverageScriptUrl = 'http://' . $this->args['LOCALSERVER'] . '/' . str_replace( '/demo/server/server.php', 'tests/phpunit_coverage.php', $this->args['URI'] );
+
+ if ($this->args['DEBUG'] == 1)
+ ob_start();
+ }
+
+ protected function tearDown()
+ {
+ if ($this->args['DEBUG'] != 1)
+ return;
+ $out = ob_get_clean();
+ $status = $this->getStatus();
+ if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR
+ || $status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE) {
+ echo $out;
+ }
+ }
+
+ /**
+ * @param PhpXmlRpc\Request|array $msg
+ * @param int|array $errorCode
+ * @param bool $returnResponse
+ * @return mixed|\PhpXmlRpc\Response|\PhpXmlRpc\Response[]|\PhpXmlRpc\Value|string|void
+ */
+ protected function send($msg, $errorCode = 0, $returnResponse = false)
+ {
+ if ($this->collectCodeCoverageInformation) {
+ $this->client->setCookie('PHPUNIT_SELENIUM_TEST_ID', $this->testId);
+ }
+
+ $r = $this->client->send($msg, $this->timeout, $this->method);
+ // for multicall, return directly array of responses
+ if (is_array($r)) {
+ return $r;
+ }
+ if (is_array($errorCode)) {
+ $this->assertContains($r->faultCode(), $errorCode, 'Error ' . $r->faultCode() . ' connecting to server: ' . $r->faultString());
+ } else {
+ $this->assertEquals($errorCode, $r->faultCode(), 'Error ' . $r->faultCode() . ' connecting to server: ' . $r->faultString());
+ }
+ if (!$r->faultCode()) {
+ if ($returnResponse) {
+ return $r;
+ } else {
+ return $r->value();
+ }
+ } else {
+ return;
+ }
+ }
+
+ public function testString()
+ {
+ $sendString = "here are 3 \"entities\": < > & " .
+ "and here's a dollar sign: \$pretendvarname and a backslash too: " . chr(92) .
+ " - isn't that great? \\\"hackery\\\" at it's best " .
+ " also don't want to miss out on \$item[0]. " .
+ "The real weird stuff follows: CRLF here" . chr(13) . chr(10) .
+ "a simple CR here" . chr(13) .
+ "a simple LF here" . chr(10) .
+ "and then LFCR" . chr(10) . chr(13) .
+ "last but not least weird names: G" . chr(252) . "nter, El" . chr(232) . "ne, and an xml comment closing tag: -->";
+ $m = new xmlrpcmsg('examples.stringecho', array(
+ new xmlrpcval($sendString, 'string'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ // when sending/receiving non-US-ASCII encoded strings, XML says cr-lf can be normalized.
+ // so we relax our tests...
+ $l1 = strlen($sendString);
+ $l2 = strlen($v->scalarval());
+ if ($l1 == $l2) {
+ $this->assertEquals($sendString, $v->scalarval());
+ } else {
+ $this->assertEquals(str_replace(array("\r\n", "\r"), array("\n", "\n"), $sendString), $v->scalarval());
+ }
+ }
+ }
+
+ public function testLatin1String()
+ {
+ $sendString =
+ "last but not least weird names: G" . chr(252) . "nter, El" . chr(232) . "ne";
+ $x = '<?xml version="1.0" encoding="ISO-8859-1"?><methodCall><methodName>examples.stringecho</methodName><params><param><value>'.
+ $sendString.
+ '</value></param></params></methodCall>';
+ $v = $this->send($x);
+ if ($v) {
+ $this->assertEquals($sendString, $v->scalarval());
+ }
+ }
+
+ public function testExoticCharsetsRequests()
+ {
+ // note that we should disable this call also when mbstring is missing server-side
+ if (!function_exists('mb_convert_encoding')) {
+ $this->markTestSkipped('Miss mbstring extension to test exotic charsets');
+ return;
+ }
+ $sendString = 'κόσμε'; // Greek word 'kosme'. NB: NOT a valid ISO8859 string!
+ $str = '<?xml version="1.0" encoding="_ENC_"?>
+<methodCall>
+ <methodName>examples.stringecho</methodName>
+ <params>
+ <param>
+ <value><string>'.$sendString.'</string></value>
+ </param>
+ </params>
+</methodCall>';
+
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'UTF-8';
+ // we have to set the encoding declaration either in the http header or xml prolog, as mb_detect_encoding
+ // (used on the server side) will fail recognizing these 2 charsets
+ $v = $this->send(mb_convert_encoding(str_replace('_ENC_', 'UCS-4', $str), 'UCS-4', 'UTF-8'));
+ $this->assertEquals($sendString, $v->scalarval());
+ $v = $this->send(mb_convert_encoding(str_replace('_ENC_', 'UTF-16', $str), 'UTF-16', 'UTF-8'));
+ $this->assertEquals($sendString, $v->scalarval());
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'ISO-8859-1';
+ }
+
+ public function testExoticCharsetsRequests2()
+ {
+ // note that we should disable this call also when mbstring is missing server-side
+ if (!function_exists('mb_convert_encoding')) {
+ $this->markTestSkipped('Miss mbstring extension to test exotic charsets');
+ return;
+ }
+ $sendString = '安室奈美恵'; // No idea what this means :-) NB: NOT a valid ISO8859 string!
+ $str = '<?xml version="1.0"?>
+<methodCall>
+ <methodName>examples.stringecho</methodName>
+ <params>
+ <param>
+ <value><string>'.$sendString.'</string></value>
+ </param>
+ </params>
+</methodCall>';
+
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'UTF-8';
+ // no encoding declaration either in the http header or xml prolog, let mb_detect_encoding
+ // (used on the server side) sort it out
+ $this->client->path = $this->args['URI'].'?DETECT_ENCODINGS[]=EUC-JP&DETECT_ENCODINGS[]=UTF-8';
+ $v = $this->send(mb_convert_encoding($str, 'EUC-JP', 'UTF-8'));
+ $this->assertEquals($sendString, $v->scalarval());
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'ISO-8859-1';
+ }
+
+ public function testExoticCharsetsRequests3()
+ {
+ // note that we should disable this call also when mbstring is missing server-side
+ if (!function_exists('mb_convert_encoding')) {
+ $this->markTestSkipped('Miss mbstring extension to test exotic charsets');
+ return;
+ }
+ $sendString = utf8_decode('élève');
+ $str = '<?xml version="1.0"?>
+<methodCall>
+ <methodName>examples.stringecho</methodName>
+ <params>
+ <param>
+ <value><string>'.$sendString.'</string></value>
+ </param>
+ </params>
+</methodCall>';
+
+ // no encoding declaration either in the http header or xml prolog, let mb_detect_encoding
+ // (used on the server side) sort it out
+ $this->client->path = $this->args['URI'].'?DETECT_ENCODINGS[]=ISO-8859-1&DETECT_ENCODINGS[]=UTF-8';
+ $v = $this->send($str);
+ $this->assertEquals($sendString, $v->scalarval());
+ }
+
+ /*public function testLatin1Method()
+ {
+ $f = new xmlrpcmsg("tests.iso88591methodname." . chr(224) . chr(252) . chr(232), array(
+ new xmlrpcval('hello')
+ ));
+ $v = $this->send($f);
+ if ($v) {
+ $this->assertEquals('hello', $v->scalarval());
+ }
+ }*/
+
+ public function testUtf8Method()
+ {
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'UTF-8';
+ $m = new xmlrpcmsg("tests.utf8methodname." . 'κόσμε', array(
+ new xmlrpcval('hello')
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals('hello', $v->scalarval());
+ }
+ PhpXmlRpc\PhpXmlRpc::$xmlrpc_internalencoding = 'ISO-8859-1';
+ }
+
+ public function testAddingDoubles()
+ {
+ // note that rounding errors mean we
+ // keep precision to sensible levels here ;-)
+ $a = 12.13;
+ $b = -23.98;
+ $m = new xmlrpcmsg('examples.addtwodouble', array(
+ new xmlrpcval($a, 'double'),
+ new xmlrpcval($b, 'double'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals($a + $b, $v->scalarval());
+ }
+ }
+
+ public function testAdding()
+ {
+ $m = new xmlrpcmsg('examples.addtwo', array(
+ new xmlrpcval(12, 'int'),
+ new xmlrpcval(-23, 'int'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals(12 - 23, $v->scalarval());
+ }
+ }
+
+ public function testInvalidNumber()
+ {
+ $m = new xmlrpcmsg('examples.addtwo', array(
+ new xmlrpcval('fred', 'int'),
+ new xmlrpcval("\"; exec('ls')", 'int'),
+ ));
+ $v = $this->send($m);
+ /// @todo a fault condition should be generated here
+ /// by the server, which we pick up on
+ if ($v) {
+ $this->assertEquals(0, $v->scalarval());
+ }
+ }
+
+ public function testBoolean()
+ {
+ $m = new xmlrpcmsg('examples.invertBooleans', array(
+ new xmlrpcval(array(
+ new xmlrpcval(true, 'boolean'),
+ new xmlrpcval(false, 'boolean'),
+ new xmlrpcval(1, 'boolean'),
+ new xmlrpcval(0, 'boolean')
+ ),
+ 'array'
+ ),));
+ $answer = '0101';
+ $v = $this->send($m);
+ if ($v) {
+ $sz = $v->arraysize();
+ $got = '';
+ for ($i = 0; $i < $sz; $i++) {
+ $b = $v->arraymem($i);
+ if ($b->scalarval()) {
+ $got .= '1';
+ } else {
+ $got .= '0';
+ }
+ }
+ $this->assertEquals($answer, $got);
+ }
+ }
+
+ public function testBase64()
+ {
+ $sendString = 'Mary had a little lamb,
+Whose fleece was white as snow,
+And everywhere that Mary went
+the lamb was sure to go.
+
+Mary had a little lamb
+She tied it to a pylon
+Ten thousand volts went down its back
+And turned it into nylon';
+ $m = new xmlrpcmsg('examples.decode64', array(
+ new xmlrpcval($sendString, 'base64'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ if (strlen($sendString) == strlen($v->scalarval())) {
+ $this->assertEquals($sendString, $v->scalarval());
+ } else {
+ $this->assertEquals(str_replace(array("\r\n", "\r"), array("\n", "\n"), $sendString), $v->scalarval());
+ }
+ }
+ }
+
+ public function testDateTime()
+ {
+ $time = time();
+ $t1 = new xmlrpcval($time, 'dateTime.iso8601');
+ $t2 = new xmlrpcval(iso8601_encode($time), 'dateTime.iso8601');
+ $this->assertEquals($t1->serialize(), $t2->serialize());
+ if (class_exists('DateTime')) {
+ $datetime = new DateTime();
+ // skip this test for php 5.2. It is a bit harder there to build a DateTime from unix timestamp with proper TZ info
+ if (is_callable(array($datetime, 'setTimestamp'))) {
+ $t3 = new xmlrpcval($datetime->setTimestamp($time), 'dateTime.iso8601');
+ $this->assertEquals($t1->serialize(), $t3->serialize());
+ }
+ }
+ }
+
+ public function testCountEntities()
+ {
+ $sendString = "h'fd>onc>>l>>rw&bpu>q>e<v&gxs<ytjzkami<";
+ $m = new xmlrpcmsg('validator1.countTheEntities', array(
+ new xmlrpcval($sendString, 'string'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $got = '';
+ $expected = '37210';
+ $expect_array = array('ctLeftAngleBrackets', 'ctRightAngleBrackets', 'ctAmpersands', 'ctApostrophes', 'ctQuotes');
+ while (list(, $val) = each($expect_array)) {
+ $b = $v->structmem($val);
+ $got .= $b->me['int'];
+ }
+ $this->assertEquals($expected, $got);
+ }
+ }
+
+ public function _multicall_msg($method, $params)
+ {
+ $struct['methodName'] = new xmlrpcval($method, 'string');
+ $struct['params'] = new xmlrpcval($params, 'array');
+
+ return new xmlrpcval($struct, 'struct');
+ }
+
+ public function testServerMulticall()
+ {
+ // We manually construct a system.multicall() call to ensure
+ // that the server supports it.
+
+ // NB: This test will NOT pass if server does not support system.multicall.
+
+ // Based on http://xmlrpc-c.sourceforge.net/hacks/test_multicall.py
+ $good1 = $this->_multicall_msg(
+ 'system.methodHelp',
+ array(php_xmlrpc_encode('system.listMethods')));
+ $bad = $this->_multicall_msg(
+ 'test.nosuch',
+ array(php_xmlrpc_encode(1), php_xmlrpc_encode(2)));
+ $recursive = $this->_multicall_msg(
+ 'system.multicall',
+ array(new xmlrpcval(array(), 'array')));
+ $good2 = $this->_multicall_msg(
+ 'system.methodSignature',
+ array(php_xmlrpc_encode('system.listMethods')));
+ $arg = new xmlrpcval(
+ array($good1, $bad, $recursive, $good2),
+ 'array'
+ );
+
+ $m = new xmlrpcmsg('system.multicall', array($arg));
+ $v = $this->send($m);
+ if ($v) {
+ //$this->assertTrue($r->faultCode() == 0, "fault from system.multicall");
+ $this->assertTrue($v->arraysize() == 4, "bad number of return values");
+
+ $r1 = $v->arraymem(0);
+ $this->assertTrue(
+ $r1->kindOf() == 'array' && $r1->arraysize() == 1,
+ "did not get array of size 1 from good1"
+ );
+
+ $r2 = $v->arraymem(1);
+ $this->assertTrue(
+ $r2->kindOf() == 'struct',
+ "no fault from bad"
+ );
+
+ $r3 = $v->arraymem(2);
+ $this->assertTrue(
+ $r3->kindOf() == 'struct',
+ "recursive system.multicall did not fail"
+ );
+
+ $r4 = $v->arraymem(3);
+ $this->assertTrue(
+ $r4->kindOf() == 'array' && $r4->arraysize() == 1,
+ "did not get array of size 1 from good2"
+ );
+ }
+ }
+
+ public function testClientMulticall1()
+ {
+ // NB: This test will NOT pass if server does not support system.multicall.
+
+ $this->client->no_multicall = false;
+
+ $good1 = new xmlrpcmsg('system.methodHelp',
+ array(php_xmlrpc_encode('system.listMethods')));
+ $bad = new xmlrpcmsg('test.nosuch',
+ array(php_xmlrpc_encode(1), php_xmlrpc_encode(2)));
+ $recursive = new xmlrpcmsg('system.multicall',
+ array(new xmlrpcval(array(), 'array')));
+ $good2 = new xmlrpcmsg('system.methodSignature',
+ array(php_xmlrpc_encode('system.listMethods'))
+ );
+
+ $r = $this->send(array($good1, $bad, $recursive, $good2));
+ if ($r) {
+ $this->assertTrue(count($r) == 4, "wrong number of return values");
+ }
+
+ $this->assertTrue($r[0]->faultCode() == 0, "fault from good1");
+ if (!$r[0]->faultCode()) {
+ $val = $r[0]->value();
+ $this->assertTrue(
+ $val->kindOf() == 'scalar' && $val->scalartyp() == 'string',
+ "good1 did not return string"
+ );
+ }
+ $this->assertTrue($r[1]->faultCode() != 0, "no fault from bad");
+ $this->assertTrue($r[2]->faultCode() != 0, "no fault from recursive system.multicall");
+ $this->assertTrue($r[3]->faultCode() == 0, "fault from good2");
+ if (!$r[3]->faultCode()) {
+ $val = $r[3]->value();
+ $this->assertTrue($val->kindOf() == 'array', "good2 did not return array");
+ }
+ // This is the only assert in this test which should fail
+ // if the test server does not support system.multicall.
+ $this->assertTrue($this->client->no_multicall == false,
+ "server does not support system.multicall"
+ );
+ }
+
+ public function testClientMulticall2()
+ {
+ // NB: This test will NOT pass if server does not support system.multicall.
+
+ $this->client->no_multicall = true;
+
+ $good1 = new xmlrpcmsg('system.methodHelp',
+ array(php_xmlrpc_encode('system.listMethods')));
+ $bad = new xmlrpcmsg('test.nosuch',
+ array(php_xmlrpc_encode(1), php_xmlrpc_encode(2)));
+ $recursive = new xmlrpcmsg('system.multicall',
+ array(new xmlrpcval(array(), 'array')));
+ $good2 = new xmlrpcmsg('system.methodSignature',
+ array(php_xmlrpc_encode('system.listMethods'))
+ );
+
+ $r = $this->send(array($good1, $bad, $recursive, $good2));
+ if ($r) {
+ $this->assertTrue(count($r) == 4, "wrong number of return values");
+ }
+
+ $this->assertTrue($r[0]->faultCode() == 0, "fault from good1");
+ if (!$r[0]->faultCode()) {
+ $val = $r[0]->value();
+ $this->assertTrue(
+ $val->kindOf() == 'scalar' && $val->scalartyp() == 'string',
+ "good1 did not return string");
+ }
+ $this->assertTrue($r[1]->faultCode() != 0, "no fault from bad");
+ $this->assertTrue($r[2]->faultCode() == 0, "fault from (non recursive) system.multicall");
+ $this->assertTrue($r[3]->faultCode() == 0, "fault from good2");
+ if (!$r[3]->faultCode()) {
+ $val = $r[3]->value();
+ $this->assertTrue($val->kindOf() == 'array', "good2 did not return array");
+ }
+ }
+
+ public function testClientMulticall3()
+ {
+ // NB: This test will NOT pass if server does not support system.multicall.
+
+ $this->client->return_type = 'phpvals';
+ $this->client->no_multicall = false;
+
+ $good1 = new xmlrpcmsg('system.methodHelp',
+ array(php_xmlrpc_encode('system.listMethods')));
+ $bad = new xmlrpcmsg('test.nosuch',
+ array(php_xmlrpc_encode(1), php_xmlrpc_encode(2)));
+ $recursive = new xmlrpcmsg('system.multicall',
+ array(new xmlrpcval(array(), 'array')));
+ $good2 = new xmlrpcmsg('system.methodSignature',
+ array(php_xmlrpc_encode('system.listMethods'))
+ );
+
+ $r = $this->send(array($good1, $bad, $recursive, $good2));
+ if ($r) {
+ $this->assertTrue(count($r) == 4, "wrong number of return values");
+ }
+ $this->assertTrue($r[0]->faultCode() == 0, "fault from good1");
+ if (!$r[0]->faultCode()) {
+ $val = $r[0]->value();
+ $this->assertTrue(
+ is_string($val), "good1 did not return string");
+ }
+ $this->assertTrue($r[1]->faultCode() != 0, "no fault from bad");
+ $this->assertTrue($r[2]->faultCode() != 0, "no fault from recursive system.multicall");
+ $this->assertTrue($r[3]->faultCode() == 0, "fault from good2");
+ if (!$r[3]->faultCode()) {
+ $val = $r[3]->value();
+ $this->assertTrue(is_array($val), "good2 did not return array");
+ }
+ $this->client->return_type = 'xmlrpcvals';
+ }
+
+ public function testCatchWarnings()
+ {
+ $m = new xmlrpcmsg('tests.generatePHPWarning', array(
+ new xmlrpcval('whatever', 'string'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals(true, $v->scalarval());
+ }
+ }
+
+ public function testCatchExceptions()
+ {
+ $m = new xmlrpcmsg('tests.raiseException', array(
+ new xmlrpcval('whatever', 'string'),
+ ));
+ $v = $this->send($m, $GLOBALS['xmlrpcerr']['server_error']);
+ $this->client->path = $this->args['URI'] . '?EXCEPTION_HANDLING=1';
+ $v = $this->send($m, 1); // the error code of the expected exception
+ $this->client->path = $this->args['URI'] . '?EXCEPTION_HANDLING=2';
+ // depending on whether display_errors is ON or OFF on the server, we will get back a different error here,
+ // as php will generate an http status code of either 200 or 500...
+ $v = $this->send($m, array($GLOBALS['xmlrpcerr']['invalid_return'], $GLOBALS['xmlrpcerr']['http_error']));
+ }
+
+ public function testZeroParams()
+ {
+ $m = new xmlrpcmsg('system.listMethods');
+ $v = $this->send($m);
+ }
+
+ public function testNullParams()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.12', array(
+ new xmlrpcval('whatever', 'null'),
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+ $m = new xmlrpcmsg('tests.getStateName.12', array(
+ new xmlrpcval(23, 'int'),
+ new xmlrpcval('whatever', 'null'),
+ ));
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+ $m = new xmlrpcmsg('tests.getStateName.12', array(
+ new xmlrpcval(23, 'int')
+ ));
+ $v = $this->send($m, array($GLOBALS['xmlrpcerr']['incorrect_params']));
+ }
+
+ public function testCodeInjectionServerSide()
+ {
+ $m = new xmlrpcmsg('system.MethodHelp');
+ $m->payload = "<?xml version=\"1.0\"?><methodCall><methodName>validator1.echoStructTest</methodName><params><param><value><struct><member><name>','')); echo('gotcha!'); die(); //</name></member></struct></value></param></params></methodCall>";
+ $v = $this->send($m);
+ if ($v) {
+ $this->assertEquals(0, $v->structsize());
+ }
+ }
+
+ public function testServerWrappedFunction()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.2', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ // this generates an exception in the function which was wrapped, which is by default wrapped in a known error response
+ $m = new xmlrpcmsg('tests.getStateName.2', array(
+ new xmlrpcval(0, 'int'),
+ ));
+ $v = $this->send($m, $GLOBALS['xmlrpcerr']['server_error']);
+
+ // check if the generated function dispatch map is fine, by checking if the server registered it
+ $m = new xmlrpcmsg('system.methodSignature', array(
+ new xmlrpcval('tests.getStateName.2'),
+ ));
+ $v = $this->send($m);
+ $encoder = new \PhpXmlRpc\Encoder();
+ $this->assertEquals(array(array('string', 'int')), $encoder->decode($v));
+ }
+
+ public function testServerWrappedFunctionAsSource()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.6', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ // this generates an exception in the function which was wrapped, which is by default wrapped in a known error response
+ $m = new xmlrpcmsg('tests.getStateName.6', array(
+ new xmlrpcval(0, 'int'),
+ ));
+ $v = $this->send($m, $GLOBALS['xmlrpcerr']['server_error']);
+ }
+
+ public function testServerWrappedObjectMethods()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.3', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.4', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.5', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.7', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.8', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.9', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+
+ public function testServerWrappedObjectMethodsAsSource()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.7', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.8', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+
+ $m = new xmlrpcmsg('tests.getStateName.9', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+
+ public function testServerClosure()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.10', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+
+ public function testServerWrappedClosure()
+ {
+ $m = new xmlrpcmsg('tests.getStateName.11', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+
+ public function testServerWrappedClass()
+ {
+ $m = new xmlrpcmsg('tests.xmlrpcServerMethodsContainer.findState', array(
+ new xmlrpcval(23, 'int'),
+ ));
+ $v = $this->send($m);
+ $this->assertEquals('Michigan', $v->scalarval());
+ }
+
+ public function testWrappedMethod()
+ {
+ // make a 'deep client copy' as the original one might have many properties set
+ $func = wrap_xmlrpc_method($this->client, 'examples.getStateName', array('simple_client_copy' => 0));
+ if ($func == false) {
+ $this->fail('Registration of examples.getStateName failed');
+ } else {
+ $v = $func(23);
+ // work around bug in current (or old?) version of phpunit when reporting the error
+ /*if (is_object($v)) {
+ $v = var_export($v, true);
+ }*/
+ $this->assertEquals('Michigan', $v);
+ }
+ }
+
+ public function testWrappedMethodAsSource()
+ {
+ // make a 'deep client copy' as the original one might have many properties set
+ $func = wrap_xmlrpc_method($this->client, 'examples.getStateName', array('simple_client_copy' => 0, 'return_source' => true));
+ if ($func == false) {
+ $this->fail('Registration of examples.getStateName failed');
+ } else {
+ eval($func['source']);
+ $func = $func['function'];
+ $v = $func(23);
+ // work around bug in current (or old?) version of phpunit when reporting the error
+ /*if (is_object($v)) {
+ $v = var_export($v, true);
+ }*/
+ $this->assertEquals('Michigan', $v);
+ }
+ }
+
+ public function testWrappedClass()
+ {
+ // make a 'deep client copy' as the original one might have many properties set
+ // also for speed only wrap one method of the whole server
+ $class = wrap_xmlrpc_server($this->client, array('simple_client_copy' => 0, 'method_filter' => '/examples\.getStateName/' ));
+ if ($class == '') {
+ $this->fail('Registration of remote server failed');
+ } else {
+ $obj = new $class();
+ $v = $obj->examples_getStateName(23);
+ // work around bug in current (or old?) version of phpunit when reporting the error
+ /*if (is_object($v)) {
+ $v = var_export($v, true);
+ }*/
+ $this->assertEquals('Michigan', $v);
+ }
+ }
+
+ public function testTransferOfObjectViaWrapping()
+ {
+ // make a 'deep client copy' as the original one might have many properties set
+ $func = wrap_xmlrpc_method($this->client, 'tests.returnPhpObject', array('simple_client_copy' => true,
+ 'decode_php_objs' => true));
+ if ($func == false) {
+ $this->fail('Registration of tests.returnPhpObject failed');
+ } else {
+ $v = $func();
+ $obj = new stdClass();
+ $obj->hello = 'world';
+ $this->assertEquals($obj, $v);
+ }
+ }
+
+ public function testGetCookies()
+ {
+ // let server set to us some cookies we tell it
+ $cookies = array(
+ //'c1' => array(),
+ 'c2' => array('value' => 'c2'),
+ 'c3' => array('value' => 'c3', 'expires' => time() + 60 * 60 * 24 * 30),
+ 'c4' => array('value' => 'c4', 'expires' => time() + 60 * 60 * 24 * 30, 'path' => '/'),
+ 'c5' => array('value' => 'c5', 'expires' => time() + 60 * 60 * 24 * 30, 'path' => '/', 'domain' => 'localhost'),
+ );
+ $cookiesval = php_xmlrpc_encode($cookies);
+ $m = new xmlrpcmsg('examples.setcookies', array($cookiesval));
+ $r = $this->send($m, 0, true);
+ if ($r) {
+ $v = $r->value();
+ $this->assertEquals(1, $v->scalarval());
+ // now check if we decoded the cookies as we had set them
+ $rcookies = $r->cookies();
+ // remove extra cookies which might have been set by proxies
+ foreach ($rcookies as $c => $v) {
+ if (!in_array($c, array('c2', 'c3', 'c4', 'c5'))) {
+ unset($rcookies[$c]);
+ }
+ // Seems like we get this when using php-fpm and php 5.5+ ...
+ if (isset($rcookies[$c]['Max-Age'])) {
+ unset($rcookies[$c]['Max-Age']);
+ }
+ }
+ foreach ($cookies as $c => $v) {
+ // format for date string in cookies: 'Mon, 31 Oct 2005 13:50:56 GMT'
+ // but PHP versions differ on that, some use 'Mon, 31-Oct-2005 13:50:56 GMT'...
+ if (isset($v['expires'])) {
+ if (isset($rcookies[$c]['expires']) && strpos($rcookies[$c]['expires'], '-')) {
+ $cookies[$c]['expires'] = gmdate('D, d\-M\-Y H:i:s \G\M\T', $cookies[$c]['expires']);
+ } else {
+ $cookies[$c]['expires'] = gmdate('D, d M Y H:i:s \G\M\T', $cookies[$c]['expires']);
+ }
+ }
+ }
+
+ $this->assertEquals($cookies, $rcookies);
+ }
+ }
+
+ public function testSetCookies()
+ {
+ // let server set to us some cookies we tell it
+ $cookies = array(
+ 'c0' => null,
+ 'c1' => 1,
+ 'c2' => '2 3',
+ 'c3' => '!@#$%^&*()_+|}{":?><,./\';[]\\=-',
+ );
+ $m = new xmlrpcmsg('examples.getcookies', array());
+ foreach ($cookies as $cookie => $val) {
+ $this->client->setCookie($cookie, $val);
+ $cookies[$cookie] = (string)$cookies[$cookie];
+ }
+ $r = $this->client->send($m, $this->timeout, $this->method);
+ $this->assertEquals(0, $r->faultCode(), 'Error ' . $r->faultCode() . ' connecting to server: ' . $r->faultString());
+ if (!$r->faultCode()) {
+ $v = $r->value();
+ $v = php_xmlrpc_decode($v);
+
+ // take care for the extra cookie used for coverage collection
+ if (isset($v['PHPUNIT_SELENIUM_TEST_ID'])) {
+ unset($v['PHPUNIT_SELENIUM_TEST_ID']);
+ }
+
+ // on IIS and Apache getallheaders returns something slightly different...
+ $this->assertEquals($cookies, $v);
+ }
+ }
+
+ public function testServerComments()
+ {
+ $m = new xmlrpcmsg('tests.xmlrpcServerMethodsContainer.debugMessageGenerator', array(
+ new xmlrpcval('hello world', 'string'),
+ ));
+ $r = $this->send($m, 0, true);
+ $this->assertContains('hello world', $r->raw_data);
+ }
+
+ public function testSendTwiceSameMsg()
+ {
+ $m = new xmlrpcmsg('examples.stringecho', array(
+ new xmlrpcval('hello world', 'string'),
+ ));
+ $v1 = $this->send($m);
+ $v2 = $this->send($m);
+ if ($v1 && $v2) {
+ $this->assertEquals($v1, $v2);
+ }
+ }
+}
--- /dev/null
+<?php
+
+include_once __DIR__ . '/../lib/xmlrpc.inc';
+include_once __DIR__ . '/../lib/xmlrpc_wrappers.inc';
+
+include_once __DIR__ . '/parse_args.php';
+
+include_once __DIR__ . '/3LocalhostTest.php';
+
+/**
+ * Tests which stress http features of the library.
+ * Each of these tests iterates over (almost) all of the 'localhost' tests
+ */
+class LocalhostMultiTest extends LocalhostTest
+{
+ /**
+ * @todo reintroduce skipping of tests which failed when executed individually if test runs happen as separate processes
+ * @todo reintroduce skipping of tests within the loop
+ */
+ function _runtests()
+ {
+ $unsafeMethods = array('testHttps', 'testCatchExceptions', 'testUtf8Method', 'testServerComments', 'testExoticCharsetsRequests', 'testExoticCharsetsRequests2', 'testExoticCharsetsRequests3');
+ foreach(get_class_methods('LocalhostTest') as $method)
+ {
+ if(strpos($method, 'test') === 0 && !in_array($method, $unsafeMethods))
+ {
+ if (!isset(self::$failed_tests[$method]))
+ $this->$method();
+ }
+ /*if ($this->_failed)
+ {
+ break;
+ }*/
+ }
+ }
+
+ function testDeflate()
+ {
+ if(!function_exists('gzdeflate'))
+ {
+ $this->markTestSkipped('Zlib missing: cannot test deflate functionality');
+ return;
+ }
+ $this->client->accepted_compression = array('deflate');
+ $this->client->request_compression = 'deflate';
+ $this->_runtests();
+ }
+
+ function testGzip()
+ {
+ if(!function_exists('gzdeflate'))
+ {
+ $this->markTestSkipped('Zlib missing: cannot test gzip functionality');
+ return;
+ }
+ $this->client->accepted_compression = array('gzip');
+ $this->client->request_compression = 'gzip';
+ $this->_runtests();
+ }
+
+ function testKeepAlives()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test http 1.1');
+ return;
+ }
+ $this->method = 'http11';
+ $this->client->keepalive = true;
+ $this->_runtests();
+ }
+
+ function testProxy()
+ {
+ if ($this->args['PROXYSERVER'])
+ {
+ $this->client->setProxy($this->args['PROXYSERVER'], $this->args['PROXYPORT']);
+ $this->_runtests();
+ }
+ else
+ $this->markTestSkipped('PROXY definition missing: cannot test proxy');
+ }
+
+ function testHttp11()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test http 1.1');
+ return;
+ }
+ $this->method = 'http11'; // not an error the double assignment!
+ $this->client->method = 'http11';
+ //$this->client->verifyhost = 0;
+ //$this->client->verifypeer = 0;
+ $this->client->keepalive = false;
+ $this->_runtests();
+ }
+
+ function testHttp11Gzip()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test http 1.1');
+ return;
+ }
+ $this->method = 'http11'; // not an error the double assignment!
+ $this->client->method = 'http11';
+ $this->client->keepalive = false;
+ $this->client->accepted_compression = array('gzip');
+ $this->client->request_compression = 'gzip';
+ $this->_runtests();
+ }
+
+ function testHttp11Deflate()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test http 1.1');
+ return;
+ }
+ $this->method = 'http11'; // not an error the double assignment!
+ $this->client->method = 'http11';
+ $this->client->keepalive = false;
+ $this->client->accepted_compression = array('deflate');
+ $this->client->request_compression = 'deflate';
+ $this->_runtests();
+ }
+
+ function testHttp11Proxy()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test http 1.1 w. proxy');
+ return;
+ }
+ else if ($this->args['PROXYSERVER'] == '')
+ {
+ $this->markTestSkipped('PROXY definition missing: cannot test proxy w. http 1.1');
+ return;
+ }
+ $this->method = 'http11'; // not an error the double assignment!
+ $this->client->method = 'http11';
+ $this->client->setProxy($this->args['PROXYSERVER'], $this->args['PROXYPORT']);
+ //$this->client->verifyhost = 0;
+ //$this->client->verifypeer = 0;
+ $this->client->keepalive = false;
+ $this->_runtests();
+ }
+
+ function testHttps()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test https functionality');
+ return;
+ }
+ $this->client->server = $this->args['HTTPSSERVER'];
+ $this->method = 'https';
+ $this->client->method = 'https';
+ $this->client->path = $this->args['HTTPSURI'];
+ $this->client->setSSLVerifyPeer(!$this->args['HTTPSIGNOREPEER']);
+ $this->client->setSSLVerifyHost($this->args['HTTPSVERIFYHOST']);
+ $this->client->setSSLVersion($this->args['SSLVERSION']);
+ $this->_runtests();
+ }
+
+ function testHttpsProxy()
+ {
+ if(!function_exists('curl_init'))
+ {
+ $this->markTestSkipped('CURL missing: cannot test https functionality');
+ return;
+ }
+ else if ($this->args['PROXYSERVER'] == '')
+ {
+ $this->markTestSkipped('PROXY definition missing: cannot test proxy w. http 1.1');
+ return;
+ }
+ $this->client->server = $this->args['HTTPSSERVER'];
+ $this->method = 'https';
+ $this->client->method = 'https';
+ $this->client->setProxy($this->args['PROXYSERVER'], $this->args['PROXYPORT']);
+ $this->client->path = $this->args['HTTPSURI'];
+ $this->client->setSSLVerifyPeer(!$this->args['HTTPSIGNOREPEER']);
+ $this->client->setSSLVerifyHost($this->args['HTTPSVERIFYHOST']);
+ $this->client->setSSLVersion($this->args['SSLVERSION']);
+ $this->_runtests();
+ }
+
+ function testUTF8Responses()
+ {
+ //$this->client->path = strpos($URI, '?') === null ? $URI.'?RESPONSE_ENCODING=UTF-8' : $URI.'&RESPONSE_ENCODING=UTF-8';
+ $this->client->path = $this->args['URI'].'?RESPONSE_ENCODING=UTF-8';
+ $this->_runtests();
+ }
+
+ function testUTF8Requests()
+ {
+ $this->client->request_charset_encoding = 'UTF-8';
+ $this->_runtests();
+ }
+
+ function testISOResponses()
+ {
+ //$this->client->path = strpos($URI, '?') === null ? $URI.'?RESPONSE_ENCODING=UTF-8' : $URI.'&RESPONSE_ENCODING=UTF-8';
+ $this->client->path = $this->args['URI'].'?RESPONSE_ENCODING=ISO-8859-1';
+ $this->_runtests();
+ }
+
+ function testISORequests()
+ {
+ $this->client->request_charset_encoding = 'ISO-8859-1';
+ $this->_runtests();
+ }
+}
--- /dev/null
+<?php
+
+include_once __DIR__ . '/LocalFileTestCase.php';
+
+/**
+ * Tests for php files in the 'demo' directory
+ */
+class DemoFilesTest extends PhpXmlRpc_LocalFileTestCase
+{
+ public function setUp()
+ {
+ $this->args = argParser::getArgs();
+
+ $this->baseUrl = $this->args['LOCALSERVER'] . str_replace( '/demo/server/server.php', '/demo/', $this->args['URI'] );
+
+ $this->coverageScriptUrl = 'http://' . $this->args['LOCALSERVER'] . '/' . str_replace( '/demo/server/server.php', 'tests/phpunit_coverage.php', $this->args['URI'] );
+ }
+
+ public function testAgeSort()
+ {
+ $page = $this->request('client/agesort.php');
+ }
+
+ public function testGetStateName()
+ {
+ $page = $this->request('client/getstatename.php');
+ $page = $this->request('client/getstatename.php', 'POST', array('stateno' => '1'));
+ }
+
+ public function testIntrospect()
+ {
+ $page = $this->request('client/introspect.php');
+ }
+
+ public function testMail()
+ {
+ $page = $this->request('client/mail.php');
+ $page = $this->request('client/mail.php', 'POST', array(
+ "mailto" => '',
+ "mailsub" => '',
+ "mailmsg" => '',
+ "mailfrom" => '',
+ "mailcc" => '',
+ "mailbcc" => '',
+ ));
+ }
+
+ public function testProxy()
+ {
+ $page = $this->request('client/proxy.php', 'GET', null, true);
+ }
+
+ public function testWhich()
+ {
+ $page = $this->request('client/which.php');
+ }
+
+ public function testWrap()
+ {
+ $page = $this->request('client/wrap.php');
+ }
+
+ public function testDiscussServer()
+ {
+ $page = $this->request('server/discuss.php');
+ $this->assertContains('<name>faultCode</name>', $page);
+ $this->assertRegexp('#<int>10(5|3)</int>#', $page);
+ }
+
+ public function testProxyServer()
+ {
+ $page = $this->request('server/proxy.php');
+ $this->assertContains('<name>faultCode</name>', $page);
+ $this->assertRegexp('#<int>10(5|3)</int>#', $page);
+ }
+}
--- /dev/null
+<?php
+
+include_once __DIR__ . '/LocalFileTestCase.php';
+
+class DebuggerTest extends PhpXmlRpc_LocalFileTestCase
+{
+ public function setUp()
+ {
+ $this->args = argParser::getArgs();
+
+ $this->baseUrl = $this->args['LOCALSERVER'] . str_replace( '/demo/server/server.php', '/debugger/', $this->args['URI'] );
+
+ $this->coverageScriptUrl = 'http://' . $this->args['LOCALSERVER'] . '/' . str_replace( '/demo/server/server.php', 'tests/phpunit_coverage.php', $this->args['URI'] );
+ }
+
+ public function testIndex()
+ {
+ $page = $this->request('index.php');
+ }
+
+ public function testController()
+ {
+ $page = $this->request('controller.php');
+ }
+
+ /**
+ * @todo test:
+ * - list methods
+ * - describe a method
+ * - execute a method
+ * - wrap a method
+ */
+ public function testAction()
+ {
+ $page = $this->request('action.php');
+ }
+}
--- /dev/null
+<?php
+
+include_once __DIR__ . '/LocalFileTestCase.php';
+
+/**
+ * Tests for php files in the 'extras' directory
+ */
+class ExtraTest extends PhpXmlRpc_LocalFileTestCase
+{
+ public function setUp()
+ {
+ $this->args = argParser::getArgs();
+
+ $this->baseUrl = $this->args['LOCALSERVER'] . str_replace( '/demo/server/server.php', '/tests/', $this->args['URI'] );
+
+ $this->coverageScriptUrl = 'http://' . $this->args['LOCALSERVER'] . '/' . str_replace( '/demo/server/server.php', 'tests/phpunit_coverage.php', $this->args['URI'] );
+ }
+
+ public function testVerifyCompat()
+ {
+ $page = $this->request('verify_compat.php');
+ }
+}
\ No newline at end of file
--- /dev/null
+<?php
+
+include_once __DIR__ . '/parse_args.php';
+
+abstract class PhpXmlRpc_LocalFileTestCase extends PHPUnit_Framework_TestCase
+{
+ public $args = array();
+
+ protected $baseUrl;
+
+ protected $testId;
+ /** @var boolean $collectCodeCoverageInformation */
+ protected $collectCodeCoverageInformation;
+ protected $coverageScriptUrl;
+
+ public function run(PHPUnit_Framework_TestResult $result = NULL)
+ {
+ $this->testId = get_class($this) . '__' . $this->getName();
+
+ if ($result === NULL) {
+ $result = $this->createResult();
+ }
+
+ $this->collectCodeCoverageInformation = $result->getCollectCodeCoverageInformation();
+
+ parent::run($result);
+
+ if ($this->collectCodeCoverageInformation) {
+ $coverage = new PHPUnit_Extensions_SeleniumCommon_RemoteCoverage(
+ $this->coverageScriptUrl,
+ $this->testId
+ );
+ $result->getCodeCoverage()->append(
+ $coverage->get(), $this
+ );
+ }
+
+ // do not call this before to give the time to the Listeners to run
+ //$this->getStrategy()->endOfTest($this->session);
+
+ return $result;
+ }
+
+ protected function request($file, $method = 'GET', $payload = '', $emptyPageOk = false)
+ {
+ $url = $this->baseUrl . $file;
+
+ $ch = curl_init($url);
+ curl_setopt_array($ch, array(
+ CURLOPT_RETURNTRANSFER => true,
+ CURLOPT_FAILONERROR => true
+ ));
+ if ($method == 'POST')
+ {
+ curl_setopt_array($ch, array(
+ CURLOPT_POST => true,
+ CURLOPT_POSTFIELDS => $payload
+ ));
+ }
+ if ($this->collectCodeCoverageInformation)
+ {
+ curl_setopt($ch, CURLOPT_COOKIE, 'PHPUNIT_SELENIUM_TEST_ID=true');
+ }
+ if ($this->args['DEBUG'] > 0) {
+ curl_setopt($ch, CURLOPT_VERBOSE, 1);
+ }
+ $page = curl_exec($ch);
+ curl_close($ch);
+
+ $this->assertNotFalse($page);
+ if (!$emptyPageOk) {
+ $this->assertNotEquals('', $page);
+ }
+ $this->assertNotContains('Fatal error', $page);
+ $this->assertNotContains('Notice:', $page);
+
+ return $page;
+ }
+
+}
--- /dev/null
+<?php
+/**
+ * Benchmarking suite for the PHP-XMLRPC lib.
+ *
+ * @author Gaetano Giunta
+ * @copyright (c) 2005-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ *
+ * @todo add a test for response ok in call testing
+ * @todo add support for --help option to give users the list of supported parameters
+ **/
+
+use PhpXmlRpc\PhpXmlRpc;
+use PhpXmlRpc\Value;
+use PhpXmlRpc\Request;
+use PhpXmlRpc\Client;
+use PhpXmlRpc\Response;
+use PhpXmlRpc\Encoder;
+
+include_once __DIR__ . '/../vendor/autoload.php';
+
+include __DIR__ . '/parse_args.php';
+$args = argParser::getArgs();
+
+function begin_test($test_name, $test_case)
+{
+ global $test_results;
+ if (!isset($test_results[$test_name])) {
+ $test_results[$test_name] = array();
+ }
+ $test_results[$test_name][$test_case] = array();
+ $test_results[$test_name][$test_case]['time'] = microtime(true);
+}
+
+function end_test($test_name, $test_case, $test_result)
+{
+ global $test_results;
+ $end = microtime(true);
+ if (!isset($test_results[$test_name][$test_case])) {
+ trigger_error('ending test that was not started');
+ }
+ $test_results[$test_name][$test_case]['time'] = $end - $test_results[$test_name][$test_case]['time'];
+ $test_results[$test_name][$test_case]['result'] = $test_result;
+ echo '.';
+ flush();
+ @ob_flush();
+}
+
+// Set up PHP structures to be used in many tests
+
+$data1 = array(1, 1.0, 'hello world', true, '20051021T23:43:00', -1, 11.0, '~!@#$%^&*()_+|', false, '20051021T23:43:00');
+$data2 = array('zero' => $data1, 'one' => $data1, 'two' => $data1, 'three' => $data1, 'four' => $data1, 'five' => $data1, 'six' => $data1, 'seven' => $data1, 'eight' => $data1, 'nine' => $data1);
+$data = array($data2, $data2, $data2, $data2, $data2, $data2, $data2, $data2, $data2, $data2);
+$keys = array('zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine');
+
+// Begin execution
+
+$test_results = array();
+$is_web = isset($_SERVER['REQUEST_METHOD']);
+$xd = extension_loaded('xdebug') && ini_get('xdebug.profiler_enable');
+if ($xd) {
+ $num_tests = 1;
+} else {
+ $num_tests = 10;
+}
+
+$title = 'XML-RPC Benchmark Tests';
+
+if ($is_web) {
+ echo "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en\" xml:lang=\"en\">\n<head>\n<title>$title</title>\n</head>\n<body>\n<h1>$title</h1>\n<pre>\n";
+} else {
+ echo "$title\n\n";
+}
+
+if ($is_web) {
+ echo "<h3>Using lib version: " . PhpXmlRpc::$xmlrpcVersion . " on PHP version: " . phpversion() . "</h3>\n";
+ if ($xd) {
+ echo "<h4>XDEBUG profiling enabled: skipping remote tests. Trace file is: " . htmlspecialchars(xdebug_get_profiler_filename()) . "</h4>\n";
+ }
+ flush();
+ ob_flush();
+} else {
+ echo "Using lib version: " . PhpXmlRpc::$xmlrpcVersion . " on PHP version: " . phpversion() . "\n";
+ if ($xd) {
+ echo "XDEBUG profiling enabled: skipping remote tests\nTrace file is: " . xdebug_get_profiler_filename() . "\n";
+ }
+}
+
+// test 'manual style' data encoding vs. 'automatic style' encoding
+begin_test('Data encoding (large array)', 'manual encoding');
+for ($i = 0; $i < $num_tests; $i++) {
+ $vals = array();
+ for ($j = 0; $j < 10; $j++) {
+ $valarray = array();
+ foreach ($data[$j] as $key => $val) {
+ $values = array();
+ $values[] = new Value($val[0], 'int');
+ $values[] = new Value($val[1], 'double');
+ $values[] = new Value($val[2], 'string');
+ $values[] = new Value($val[3], 'boolean');
+ $values[] = new Value($val[4], 'dateTime.iso8601');
+ $values[] = new Value($val[5], 'int');
+ $values[] = new Value($val[6], 'double');
+ $values[] = new Value($val[7], 'string');
+ $values[] = new Value($val[8], 'boolean');
+ $values[] = new Value($val[9], 'dateTime.iso8601');
+ $valarray[$key] = new Value($values, 'array');
+ }
+ $vals[] = new Value($valarray, 'struct');
+ }
+ $value = new Value($vals, 'array');
+ $out = $value->serialize();
+}
+end_test('Data encoding (large array)', 'manual encoding', $out);
+
+begin_test('Data encoding (large array)', 'automatic encoding');
+$encoder = new Encoder();
+for ($i = 0; $i < $num_tests; $i++) {
+ $value = $encoder->encode($data, array('auto_dates'));
+ $out = $value->serialize();
+}
+end_test('Data encoding (large array)', 'automatic encoding', $out);
+
+if (function_exists('xmlrpc_set_type')) {
+ begin_test('Data encoding (large array)', 'xmlrpc-epi encoding');
+ for ($i = 0; $i < $num_tests; $i++) {
+ for ($j = 0; $j < 10; $j++) {
+ foreach ($keys as $k) {
+ xmlrpc_set_type($data[$j][$k][4], 'datetime');
+ xmlrpc_set_type($data[$j][$k][8], 'datetime');
+ }
+ }
+ $out = xmlrpc_encode($data);
+ }
+ end_test('Data encoding (large array)', 'xmlrpc-epi encoding', $out);
+}
+
+// test 'old style' data decoding vs. 'automatic style' decoding
+$dummy = new Request('');
+$out = new Response($value);
+$in = '<?xml version="1.0" ?>' . "\n" . $out->serialize();
+
+begin_test('Data decoding (large array)', 'manual decoding');
+for ($i = 0; $i < $num_tests; $i++) {
+ $response = $dummy->ParseResponse($in, true);
+ $value = $response->value();
+ $result = array();
+ foreach($value as $val1) {
+ $out = array();
+ foreach($val1 as $name => $val) {
+ $out[$name] = array();
+ foreach($val as $data) {
+ $out[$name][] = $data->scalarval();
+ }
+ }
+ $result[] = $out;
+ }
+}
+end_test('Data decoding (large array)', 'manual decoding', $result);
+
+begin_test('Data decoding (large array)', 'manual decoding deprecated');
+for ($i = 0; $i < $num_tests; $i++) {
+ $response = $dummy->ParseResponse($in, true);
+ $value = $response->value();
+ $result = array();
+ $l = $value->arraysize();
+ for ($k = 0; $k < $l; $k++) {
+ $val1 = $value->arraymem($k);
+ $out = array();
+ while (list($name, $val) = $val1->structeach()) {
+ $out[$name] = array();
+ $m = $val->arraysize();
+ for ($j = 0; $j < $m; $j++) {
+ $data = $val->arraymem($j);
+ $out[$name][] = $data->scalarval();
+ }
+ } // while
+ $result[] = $out;
+ }
+}
+end_test('Data decoding (large array)', 'manual decoding deprecated', $result);
+
+begin_test('Data decoding (large array)', 'automatic decoding');
+for ($i = 0; $i < $num_tests; $i++) {
+ $response = $dummy->ParseResponse($in, true, 'phpvals');
+ $value = $response->value();
+}
+end_test('Data decoding (large array)', 'automatic decoding', $value);
+
+if (function_exists('xmlrpc_decode')) {
+ begin_test('Data decoding (large array)', 'xmlrpc-epi decoding');
+ for ($i = 0; $i < $num_tests; $i++) {
+ $response = $dummy->ParseResponse($in, true, 'xml');
+ $value = xmlrpc_decode($response->value());
+ }
+ end_test('Data decoding (large array)', 'xmlrpc-epi decoding', $value);
+}
+
+if (!$xd) {
+
+ /// test multicall vs. many calls vs. keep-alives
+ $encoder = new Encoder();
+ $value = $encoder->encode($data1, array('auto_dates'));
+ $req = new Request('interopEchoTests.echoValue', array($value));
+ $reqs = array();
+ for ($i = 0; $i < 25; $i++) {
+ $reqs[] = $req;
+ }
+ $server = explode(':', $args['LOCALSERVER']);
+ if (count($server) > 1) {
+ $srv = $server[1] . '://' . $server[0] . $args['URI'];
+ $c = new Client($args['URI'], $server[0], $server[1]);
+ } else {
+ $srv = $args['LOCALSERVER'] . $args['URI'];
+ $c = new Client($args['URI'], $args['LOCALSERVER']);
+ }
+ // do not interfere with http compression
+ $c->accepted_compression = array();
+ //$c->debug=true;
+
+ $testName = "Repeated send (small array) to $srv";
+
+ if (function_exists('gzinflate')) {
+ $c->accepted_compression = null;
+ }
+ begin_test($testName, 'http 10');
+ $response = array();
+ for ($i = 0; $i < 25; $i++) {
+ $resp = $c->send($req);
+ $response[] = $resp->value();
+ }
+ end_test($testName, 'http 10', $response);
+
+ if (function_exists('curl_init')) {
+ begin_test($testName, 'http 11 w. keep-alive');
+ $response = array();
+ for ($i = 0; $i < 25; $i++) {
+ $resp = $c->send($req, 10, 'http11');
+ $response[] = $resp->value();
+ }
+ end_test($testName, 'http 11 w. keep-alive', $response);
+
+ $c->keepalive = false;
+ begin_test($testName, 'http 11');
+ $response = array();
+ for ($i = 0; $i < 25; $i++) {
+ $resp = $c->send($req, 10, 'http11');
+ $response[] = $resp->value();
+ }
+ end_test($testName, 'http 11', $response);
+ }
+
+ begin_test($testName, 'multicall');
+ $response = $c->send($reqs);
+ foreach ($response as $key => & $val) {
+ $val = $val->value();
+ }
+ end_test($testName, 'multicall', $response);
+
+ if (function_exists('gzinflate')) {
+ $c->accepted_compression = array('gzip');
+ $c->request_compression = 'gzip';
+
+ begin_test($testName, 'http 10 w. compression');
+ $response = array();
+ for ($i = 0; $i < 25; $i++) {
+ $resp = $c->send($req);
+ $response[] = $resp->value();
+ }
+ end_test($testName, 'http 10 w. compression', $response);
+
+ if (function_exists('curl_init')) {
+ begin_test($testName, 'http 11 w. keep-alive and compression');
+ $response = array();
+ for ($i = 0; $i < 25; $i++) {
+ $resp = $c->send($req, 10, 'http11');
+ $response[] = $resp->value();
+ }
+ end_test($testName, 'http 11 w. keep-alive and compression', $response);
+
+ $c->keepalive = false;
+ begin_test($testName, 'http 11 w. compression');
+ $response = array();
+ for ($i = 0; $i < 25; $i++) {
+ $resp = $c->send($req, 10, 'http11');
+ $response[] = $resp->value();
+ }
+ end_test($testName, 'http 11 w. compression', $response);
+ }
+
+ begin_test($testName, 'multicall w. compression');
+ $response = $c->send($reqs);
+ foreach ($response as $key => & $val) {
+ $val = $val->value();
+ }
+ end_test($testName, 'multicall w. compression', $response);
+ }
+} // end of 'if no xdebug profiling'
+
+
+echo "\n";
+foreach ($test_results as $test => $results) {
+ echo "\nTEST: $test\n";
+ foreach ($results as $case => $data) {
+ echo " $case: {$data['time']} secs - Output data CRC: " . crc32(serialize($data['result'])) . "\n";
+ }
+}
+
+if ($is_web) {
+ echo "\n</pre>\n</body>\n</html>\n";
+}
--- /dev/null
+# Configuration file for Apache running on Travis.
+# PHP setup in FCGI mode
+
+<VirtualHost *:80>
+
+ DocumentRoot %TRAVIS_BUILD_DIR%
+
+ ErrorLog "%TRAVIS_BUILD_DIR%/apache_error.log"
+ CustomLog "%TRAVIS_BUILD_DIR%/apache_access.log" combined
+
+ <Directory "%TRAVIS_BUILD_DIR%">
+ Options FollowSymLinks MultiViews ExecCGI
+ AllowOverride All
+ Order deny,allow
+ Allow from all
+ </Directory>
+
+ # Wire up Apache to use Travis CI's php-fpm.
+ <IfModule mod_fastcgi.c>
+ AddHandler php5-fcgi .php
+ Action php5-fcgi /php5-fcgi
+ Alias /php5-fcgi /usr/lib/cgi-bin/php5-fcgi
+ FastCgiExternalServer /usr/lib/cgi-bin/php5-fcgi -host 127.0.0.1:9000 -pass-header Authorization
+ </IfModule>
+
+</VirtualHost>
+
+<IfModule mod_ssl.c>
+
+<VirtualHost _default_:443>
+
+ DocumentRoot %TRAVIS_BUILD_DIR%
+
+ ErrorLog "%TRAVIS_BUILD_DIR%/apache_error.log"
+ CustomLog "%TRAVIS_BUILD_DIR%/apache_access.log" combined
+
+ <Directory "%TRAVIS_BUILD_DIR%">
+ Options FollowSymLinks MultiViews ExecCGI
+ AllowOverride All
+ Order deny,allow
+ Allow from all
+ </Directory>
+
+ # Wire up Apache to use Travis CI's php-fpm.
+ <IfModule mod_fastcgi.c>
+ AddHandler php5-fcgi .php
+ Action php5-fcgi /php5-fcgi
+ Alias /php5-fcgi /usr/lib/cgi-bin/php5-fcgi
+ #FastCgiExternalServer /usr/lib/cgi-bin/php5-fcgi -host 127.0.0.1:9000 -pass-header Authorization
+ </IfModule>
+
+ SSLEngine on
+ # This cert is bundled by default in Ubuntu
+ SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem
+ SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key
+
+ <FilesMatch "\.(cgi|shtml|phtml|php)$">
+ SSLOptions +StdEnvVars
+ </FilesMatch>
+
+ BrowserMatch "MSIE [2-6]" \
+ nokeepalive ssl-unclean-shutdown \
+ downgrade-1.0 force-response-1.0
+ BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown
+
+</VirtualHost>
+
+</IfModule>
--- /dev/null
+# Configuration file for Apache running on Travis.
+# HHVM setup in FCGI mode
+
+<VirtualHost *:80>
+
+ DocumentRoot %TRAVIS_BUILD_DIR%
+
+ ErrorLog "%TRAVIS_BUILD_DIR%/apache_error.log"
+ CustomLog "%TRAVIS_BUILD_DIR%/apache_access.log" combined
+
+ <Directory "%TRAVIS_BUILD_DIR%">
+ Options FollowSymLinks MultiViews ExecCGI
+ AllowOverride All
+ Order deny,allow
+ Allow from all
+ </Directory>
+
+ # Configure Apache for HHVM FastCGI.
+ # See https://github.com/facebook/hhvm/wiki/fastcgi
+ <IfModule mod_fastcgi.c>
+ <FilesMatch \.php$>
+ SetHandler hhvm-php-extension
+ </FilesMatch>
+ Alias /hhvm /hhvm
+ Action hhvm-php-extension /hhvm virtual
+ FastCgiExternalServer /hhvm -host 127.0.0.1:9000 -pass-header Authorization -idle-timeout 300
+ </IfModule>
+
+</VirtualHost>
+
+<IfModule mod_ssl.c>
+
+<VirtualHost _default_:443>
+
+ DocumentRoot %TRAVIS_BUILD_DIR%
+
+ ErrorLog "%TRAVIS_BUILD_DIR%/apache_error.log"
+ CustomLog "%TRAVIS_BUILD_DIR%/apache_access.log" combined
+
+ <Directory "%TRAVIS_BUILD_DIR%">
+ Options FollowSymLinks MultiViews ExecCGI
+ AllowOverride All
+ Order deny,allow
+ Allow from all
+ </Directory>
+
+ # Configure Apache for HHVM FastCGI.
+ # See https://github.com/facebook/hhvm/wiki/fastcgi
+ <IfModule mod_fastcgi.c>
+ <FilesMatch \.php$>
+ SetHandler hhvm-php-extension
+ </FilesMatch>
+ Alias /hhvm /hhvm
+ Action hhvm-php-extension /hhvm virtual
+ #FastCgiExternalServer /hhvm -host 127.0.0.1:9000 -pass-header Authorization -idle-timeout 300
+ </IfModule>
+
+ SSLEngine on
+ # This cert is bundled by default in Ubuntu
+ SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem
+ SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key
+
+ <FilesMatch "\.(cgi|shtml|phtml|php)$">
+ SSLOptions +StdEnvVars
+ </FilesMatch>
+
+ BrowserMatch "MSIE [2-6]" \
+ nokeepalive ssl-unclean-shutdown \
+ downgrade-1.0 force-response-1.0
+ BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown
+
+</VirtualHost>
+
+</IfModule>
--- /dev/null
+listen-address 127.0.0.1:8080
--- /dev/null
+#!/bin/sh
+
+# set up Apache for php-fpm
+# @see https://github.com/travis-ci/travis-ci.github.com/blob/master/docs/user/languages/php.md#apache--php
+
+sudo a2enmod rewrite actions fastcgi alias ssl
+
+# configure apache virtual hosts
+sudo cp -f tests/ci/travis/apache_vhost /etc/apache2/sites-available/default
+sudo sed -e "s?%TRAVIS_BUILD_DIR%?$(pwd)?g" --in-place /etc/apache2/sites-available/default
+sudo service apache2 restart
--- /dev/null
+#!/bin/sh
+
+# set up Apache for hhvm-fcgi
+# @see https://github.com/travis-ci/travis-ci.github.com/blob/master/docs/user/languages/php.md#apache--php
+
+sudo a2enmod rewrite actions fastcgi alias ssl
+
+# configure apache virtual hosts
+sudo cp -f tests/ci/travis/apache_vhost_hhvm /etc/apache2/sites-available/default
+sudo sed -e "s?%TRAVIS_BUILD_DIR%?$(pwd)?g" --in-place /etc/apache2/sites-available/default
+sudo service apache2 restart
--- /dev/null
+#!/bin/sh
+
+# start HHVM
+hhvm -m daemon -vServer.Type=fastcgi -vServer.Port=9000 -vServer.FixPathInfo=true
--- /dev/null
+#!/bin/sh
+
+# enable php-fpm
+sudo cp ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.conf.default ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.conf
+# work around travis issue #3385
+if [ "$TRAVIS_PHP_VERSION" = "7.0" -a -n "$(ls -A ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.d)" ]; then
+ sudo cp ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.d/www.conf.default ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.d/www.conf
+fi
+if [ "$TRAVIS_PHP_VERSION" = "7.1" -a -n "$(ls -A ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.d)" ]; then
+ sudo cp ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.d/www.conf.default ~/.phpenv/versions/$(phpenv version-name)/etc/php-fpm.d/www.conf
+fi
+echo "cgi.fix_pathinfo = 1" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
+echo "always_populate_raw_post_data = -1" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
+~/.phpenv/versions/$(phpenv version-name)/sbin/php-fpm
--- /dev/null
+#!/bin/sh
+
+# configure privoxy
+
+sudo cp -f tests/ci/travis/privoxy /etc/privoxy/config
+sudo service privoxy restart
--- /dev/null
+<?php
+
+/**
+ * Common parameter parsing for benchmark and tests scripts.
+ *
+ * @param integer DEBUG
+ * @param string LOCALSERVER
+ * @param string URI
+ * @param string HTTPSSERVER
+ * @param string HTTPSSURI
+ * @param string PROXY
+ * @param string NOPROXY
+ * @param bool HTTPSIGNOREPEER
+ * @param int HTTPSVERIFYHOST
+ * @param int SSLVERSION
+ *
+ * @copyright (C) 2007-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ **/
+class argParser
+{
+ public static function getArgs()
+ {
+ global $argv;
+
+ $args = array(
+ 'DEBUG' => 0,
+ 'LOCALSERVER' => 'localhost',
+ 'HTTPSSERVER' => 'gggeek.ssl.altervista.org',
+ 'HTTPSURI' => '/sw/xmlrpc/demo/server/server.php',
+ 'HTTPSIGNOREPEER' => false,
+ 'HTTPSVERIFYHOST' => 2,
+ 'SSLVERSION' => 0,
+ 'PROXYSERVER' => null,
+ 'NOPROXY' => false,
+ 'LOCALPATH' => __DIR__,
+ );
+
+ // check for command line vs web page input params
+ if (!isset($_SERVER['REQUEST_METHOD'])) {
+ if (isset($argv)) {
+ foreach ($argv as $param) {
+ $param = explode('=', $param);
+ if (count($param) > 1) {
+ $pname = strtoupper(ltrim($param[0], '-'));
+ $$pname = $param[1];
+ }
+ }
+ }
+ } else {
+ // NB: we might as well consider using $_GET stuff later on...
+ extract($_GET);
+ extract($_POST);
+ }
+
+ if (isset($DEBUG)) {
+ $args['DEBUG'] = intval($DEBUG);
+ }
+ if (isset($LOCALSERVER)) {
+ $args['LOCALSERVER'] = $LOCALSERVER;
+ } else {
+ if (isset($HTTP_HOST)) {
+ $args['LOCALSERVER'] = $HTTP_HOST;
+ } elseif (isset($_SERVER['HTTP_HOST'])) {
+ $args['LOCALSERVER'] = $_SERVER['HTTP_HOST'];
+ }
+ }
+ if (isset($HTTPSSERVER)) {
+ $args['HTTPSSERVER'] = $HTTPSSERVER;
+ }
+ if (isset($HTTPSURI)) {
+ $args['HTTPSURI'] = $HTTPSURI;
+ }
+ if (isset($HTTPSIGNOREPEER)) {
+ $args['HTTPSIGNOREPEER'] = (bool)$HTTPSIGNOREPEER;
+ }
+ if (isset($HTTPSVERIFYHOST)) {
+ $args['HTTPSVERIFYHOST'] = (int)$HTTPSVERIFYHOST;
+ }
+ if (isset($SSLVERSION)) {
+ $args['SSLVERSION'] = (int)$SSLVERSION;
+ }
+ if (isset($PROXY)) {
+ $arr = explode(':', $PROXY);
+ $args['PROXYSERVER'] = $arr[0];
+ if (count($arr) > 1) {
+ $args['PROXYPORT'] = $arr[1];
+ } else {
+ $args['PROXYPORT'] = 8080;
+ }
+ }
+ // used to silence testsuite warnings about proxy code not being tested
+ if (isset($NOPROXY)) {
+ $args['NOPROXY'] = true;
+ }
+ if (!isset($URI)) {
+ // GUESTIMATE the url of local demo server
+ // play nice to php 3 and 4-5 in retrieving URL of server.php
+ /// @todo filter out query string from REQUEST_URI
+ if (isset($REQUEST_URI)) {
+ $URI = str_replace('/tests/testsuite.php', '/demo/server/server.php', $REQUEST_URI);
+ $URI = str_replace('/testsuite.php', '/server.php', $URI);
+ $URI = str_replace('/tests/benchmark.php', '/demo/server/server.php', $URI);
+ $URI = str_replace('/benchmark.php', '/server.php', $URI);
+ } elseif (isset($_SERVER['PHP_SELF']) && isset($_SERVER['REQUEST_METHOD'])) {
+ $URI = str_replace('/tests/testsuite.php', '/demo/server/server.php', $_SERVER['PHP_SELF']);
+ $URI = str_replace('/testsuite.php', '/server.php', $URI);
+ $URI = str_replace('/tests/benchmark.php', '/demo/server/server.php', $URI);
+ $URI = str_replace('/benchmark.php', '/server.php', $URI);
+ } else {
+ $URI = '/demo/server/server.php';
+ }
+ }
+ if ($URI[0] != '/') {
+ $URI = '/' . $URI;
+ }
+ $args['URI'] = $URI;
+ if (isset($LOCALPATH)) {
+ $args['LOCALPATH'] = $LOCALPATH;
+ }
+
+ return $args;
+ }
+}
--- /dev/null
+<?php
+/**
+ * Used to serve back the server-side code coverage results to phpunit-selenium
+ *
+ * @copyright (C) 2007-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ **/
+
+$coverageFile = realpath(__DIR__ . "/../vendor/phpunit/phpunit-selenium/PHPUnit/Extensions/SeleniumCommon/phpunit_coverage.php");
+
+// has to be the same value as used in server.php
+$GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY'] = '/tmp/phpxmlrpc_coverage';
+
+chdir($GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY']);
+
+include_once $coverageFile;
\ No newline at end of file
--- /dev/null
+<?php
+/**
+ * Verify compatibility level of current php install with php-xmlrpc lib.
+ *
+ * @author Gaetano Giunta
+ * @copyright (C) 2006-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
+ *
+ * @todo add a test for php output buffering?
+ */
+
+function phpxmlrpc_verify_compat($mode = 'client')
+{
+ $tests = array();
+
+ if ($mode == 'server') {
+ // test for php version
+ $ver = phpversion();
+ $tests['php_version'] = array();
+ $tests['php_version']['description'] = 'PHP version found: ' . $ver . ".\n\n";
+ if (version_compare($ver, '5.3.0') < 0) {
+ $tests['php_version']['status'] = 0;
+ $tests['php_version']['description'] .= 'This version of PHP is not compatible with this release of the PHP XMLRPC library. Please upgrade to php 5.1.0 or later';
+ } else {
+ $tests['php_version']['status'] = 2;
+ $tests['php_version']['description'] .= 'This version of PHP is fully compatible with the PHP XMLRPC library';
+ }
+
+ // test for zlib
+ $tests['zlib'] = array();
+ if (!function_exists('gzinflate')) {
+ $tests['zlib']['status'] = 0;
+ $tests['zlib']['description'] = "The zlib extension is not enabled.\n\nYou will not be able to receive compressed requests or send compressed responses, unless using the cURL library (for 'HTTPS' and 'HTTP 1.1' connections)";
+ } else {
+ $tests['zlib']['status'] = 2;
+ $tests['zlib']['description'] = "The zlib extension is enabled.\n\nYou will be able to receive compressed requests and send compressed responses for the 'HTTP' protocol";
+ }
+
+ // test for dispaly of php errors in xml reponse
+ if (ini_get('display_errors')) {
+ if (intval(ini_get('error_reporting')) && E_NOTICE) {
+ $tests['display_errors']['status'] = 1;
+ $tests['display_errors']['description'] = "Error reporting level includes E_NOTICE errors, and display_errors is set to ON.\n\nAny error, warning or notice raised while executing php code exposed as xmlrpc method will result in an invalid xmlrpc response";
+ } else {
+ $tests['display_errors']['status'] = 1;
+ $tests['display_errors']['description'] = "display_errors is set to ON.\n\nAny error raised while executing php code exposed as xmlrpc method will result in an invalid xmlrpc response";
+ }
+ }
+ } else {
+
+ // test for php version
+ $ver = phpversion();
+ $tests['php_version'] = array();
+ $tests['php_version']['description'] = 'PHP version found: ' . $ver . ".\n\n";
+ if (version_compare($ver, '5.3.0') < 0) {
+ $tests['php_version']['status'] = 0;
+ $tests['php_version']['description'] .= 'This version of PHP is not compatible with the PHP XMLRPC library. Please upgrade to 5.1.0 or later';
+ } else {
+ $tests['php_version']['status'] = 2;
+ $tests['php_version']['description'] .= 'This version of PHP is fully compatible with the PHP XMLRPC library';
+ }
+
+ // test for zlib
+ $tests['zlib'] = array();
+ if (!function_exists('gzinflate')) {
+ $tests['zlib']['status'] = 0;
+ $tests['zlib']['description'] = "The zlib extension is not enabled.\n\nYou will not be able to send compressed requests or receive compressed responses, unless using the cURL library (for 'HTTPS' and 'HTTP 1.1' connections)";
+ } else {
+ $tests['zlib']['status'] = 2;
+ $tests['zlib']['description'] = "The zlib extension is enabled.\n\nYou will be able to send compressed requests and receive compressed responses for the 'HTTP' protocol";
+ }
+
+ // test for CURL
+ $tests['curl'] = array();
+ if (!extension_loaded('curl')) {
+ $tests['curl']['status'] = 0;
+ $tests['curl']['description'] = "The cURL extension is not enabled.\n\nYou will not be able to send and receive messages using 'HTTPS' and 'HTTP 1.1' protocols";
+ } else {
+ $info = curl_version();
+ $tests['curl']['status'] = 2;
+ $tests['curl']['description'] = "The cURL extension is enabled.\n\nYou will be able to send and receive messages using 'HTTPS' and 'HTTP 1.1' protocols";
+ if (version_compare($ver, '4.3.8') < 0) {
+ $tests['curl']['status'] = 1;
+ $tests['curl']['description'] .= ".\nPlease note that the current cURL install does not support keep-alives";
+ }
+ if (!((is_string($info) && strpos($info, 'zlib') !== null) || isset($info['libz_version']))) {
+ $tests['curl']['status'] = 1;
+ $tests['curl']['description'] .= ".\nPlease note that the current cURL install does not support compressed messages";
+ }
+ if (!((is_string($info) && strpos($info, 'OpenSSL') !== null) || isset($info['ssl_version']))) {
+ $tests['curl']['status'] = 1;
+ $tests['curl']['description'] .= ".\nPlease note that the current cURL install does not support HTTPS connections";
+ }
+ }
+ }
+
+ return $tests;
+}
+
+?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head>
+ <title>PHP XMLRPC compatibility assessment</title>
+ <style type="text/css">
+ body, html {
+ background-color: white;
+ font-family: Arial, Verdana, Geneva, sans-serif;
+ font-size: small;
+ }
+
+ table {
+ border: 1px solid gray;
+ padding: 0;
+ }
+
+ thead {
+ background-color: silver;
+ color: black;
+ }
+
+ td {
+ margin: 0;
+ padding: 0.5em;
+ }
+
+ tbody td {
+ border-top: 1px solid gray;
+ }
+
+ .res0 {
+ background-color: red;
+ color: black;
+ border-right: 1px solid gray;
+ }
+
+ .res1 {
+ background-color: yellow;
+ color: black;
+ border-right: 1px solid gray;
+ }
+
+ .res2 {
+ background-color: green;
+ color: black;
+ border-right: 1px solid gray;
+ }
+
+ .result {
+ white-space: pre;
+ }
+ </style>
+</head>
+<body>
+<h1>PHPXMLRPC compatibility assessment with the current PHP install</h1>
+<h4>For phpxmlrpc version 4.0 or later</h4>
+
+<h3>Server usage</h3>
+<table cellspacing="0">
+ <thead>
+ <tr>
+ <td>Test</td>
+ <td>Result</td>
+ </tr>
+ </thead>
+ <tbody>
+ <?php
+ $res = phpxmlrpc_verify_compat('server');
+ foreach ($res as $test => $result) {
+ echo '<tr><td class="res' . $result['status'] . '">' . htmlspecialchars($test) . '</td><td class="result">' . htmlspecialchars($result['description']) . "</td></tr>\n";
+ }
+ ?>
+ </tbody>
+</table>
+<h3>Client usage</h3>
+<table cellspacing="0">
+ <thead>
+ <tr>
+ <td>Test</td>
+ <td>Result</td>
+ </tr>
+ </thead>
+ <tbody>
+ <?php
+ $res = phpxmlrpc_verify_compat('client');
+ foreach ($res as $test => $result) {
+ echo '<tr><td class="res' . $result['status'] . '">' . htmlspecialchars($test) . '</td><td class="result">' . htmlspecialchars($result['description']) . "</td></tr>\n";
+ }
+ ?>
+ </tbody>
+</table>
+</body>
+</html>
git://git.onelab.eu / plcapi.git / commitdiff
