forked from Wavyzz/dolibarr
bbde552979
* Fix script generating trailing whitespace * Add nusoap as a stub for better analysis * Qual: Return type for fetch_name_optionals_label to fix phan message * Qual: Enable Phan Rules and update baseline # Qual: Enable Phan Rules and update baseline This enables all of the rules that are currently also enabled for cti, but sets the baseline to ignore the exceptions already present. This will help detect exceptions added by code modifications if the rule is not ignored for the given file.
3952 lines
108 KiB
PHP
3952 lines
108 KiB
PHP
<?php
|
|
|
|
/**
|
|
* The Mail_Mime class provides an OO interface to create MIME
|
|
* enabled email messages. This way you can create emails that
|
|
* contain plain-text bodies, HTML bodies, attachments, inline
|
|
* images and specific headers.
|
|
*
|
|
* @category Mail
|
|
* @package Mail_Mime
|
|
* @author Richard Heyes <richard@phpguru.org>
|
|
* @author Tomas V.V. Cox <cox@idecnet.com>
|
|
* @author Cipriano Groenendal <cipri@php.net>
|
|
* @author Sean Coates <sean@php.net>
|
|
* @copyright 2003-2006 PEAR <pear-group@php.net>
|
|
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
|
|
* @version Release: @package_version@
|
|
* @link http://pear.php.net/package/Mail_mime
|
|
*/
|
|
class Mail_mime
|
|
{
|
|
/**
|
|
* Contains the plain text part of the email
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_txtbody;
|
|
/**
|
|
* Contains the html part of the email
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_htmlbody;
|
|
/**
|
|
* list of the attached images
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $_html_images = array();
|
|
/**
|
|
* list of the attachements
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $_parts = array();
|
|
/**
|
|
* Headers for the mail
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $_headers = array();
|
|
/**
|
|
* Build parameters
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $_build_params = array(
|
|
// What encoding to use for the headers
|
|
// Options: quoted-printable or base64
|
|
'head_encoding' => 'quoted-printable',
|
|
// What encoding to use for plain text
|
|
// Options: 7bit, 8bit, base64, or quoted-printable
|
|
'text_encoding' => 'quoted-printable',
|
|
// What encoding to use for html
|
|
// Options: 7bit, 8bit, base64, or quoted-printable
|
|
'html_encoding' => 'quoted-printable',
|
|
// The character set to use for html
|
|
'html_charset' => 'ISO-8859-1',
|
|
// The character set to use for text
|
|
'text_charset' => 'ISO-8859-1',
|
|
// The character set to use for headers
|
|
'head_charset' => 'ISO-8859-1',
|
|
// End-of-line sequence
|
|
'eol' => "\r\n",
|
|
// Delay attachment files IO until building the message
|
|
'delay_file_io' => \false,
|
|
);
|
|
/**
|
|
* Constructor function
|
|
*
|
|
* @param mixed $params Build parameters that change the way the email
|
|
* is built. Should be an associative array.
|
|
* See $_build_params.
|
|
*
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
public function Mail_mime($params = array())
|
|
{
|
|
}
|
|
/**
|
|
* Set build parameter value
|
|
*
|
|
* @param string $name Parameter name
|
|
* @param string $value Parameter value
|
|
*
|
|
* @return void
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function setParam($name, $value)
|
|
{
|
|
}
|
|
/**
|
|
* Get build parameter value
|
|
*
|
|
* @param string $name Parameter name
|
|
*
|
|
* @return mixed Parameter value
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function getParam($name)
|
|
{
|
|
}
|
|
/**
|
|
* Accessor function to set the body text. Body text is used if
|
|
* it's not an html mail being sent or else is used to fill the
|
|
* text/plain part that emails clients who don't support
|
|
* html should show.
|
|
*
|
|
* @param string $data Either a string or
|
|
* the file name with the contents
|
|
* @param bool $isfile If true the first param should be treated
|
|
* as a file name, else as a string (default)
|
|
* @param bool $append If true the text or file is appended to
|
|
* the existing body, else the old body is
|
|
* overwritten
|
|
*
|
|
* @return mixed True on success or PEAR_Error object
|
|
* @access public
|
|
*/
|
|
public function setTXTBody($data, $isfile = \false, $append = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Get message text body
|
|
*
|
|
* @return string Text body
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function getTXTBody()
|
|
{
|
|
}
|
|
/**
|
|
* Adds a html part to the mail.
|
|
*
|
|
* @param string $data Either a string or the file name with the
|
|
* contents
|
|
* @param bool $isfile A flag that determines whether $data is a
|
|
* filename, or a string(false, default)
|
|
*
|
|
* @return bool True on success
|
|
* @access public
|
|
*/
|
|
public function setHTMLBody($data, $isfile = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Get message HTML body
|
|
*
|
|
* @return string HTML body
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function getHTMLBody()
|
|
{
|
|
}
|
|
/**
|
|
* Adds an image to the list of embedded images.
|
|
*
|
|
* @param string $file The image file name OR image data itself
|
|
* @param string $c_type The content type
|
|
* @param string $name The filename of the image.
|
|
* Only used if $file is the image data.
|
|
* @param bool $isfile Whether $file is a filename or not.
|
|
* Defaults to true
|
|
* @param string $content_id Desired Content-ID of MIME part
|
|
* Defaults to generated unique ID
|
|
*
|
|
* @return bool True on success
|
|
* @access public
|
|
*/
|
|
public function addHTMLImage($file, $c_type = 'application/octet-stream', $name = '', $isfile = \true, $content_id = \null)
|
|
{
|
|
}
|
|
/**
|
|
* Adds a file to the list of attachments.
|
|
*
|
|
* @param string $file The file name of the file to attach
|
|
* or the file contents itself
|
|
* @param string $c_type The content type
|
|
* @param string $name The filename of the attachment
|
|
* Only use if $file is the contents
|
|
* @param bool $isfile Whether $file is a filename or not. Defaults to true
|
|
* @param string $encoding The type of encoding to use. Defaults to base64.
|
|
* Possible values: 7bit, 8bit, base64 or quoted-printable.
|
|
* @param string $disposition The content-disposition of this file
|
|
* Defaults to attachment.
|
|
* Possible values: attachment, inline.
|
|
* @param string $charset The character set of attachment's content.
|
|
* @param string $language The language of the attachment
|
|
* @param string $location The RFC 2557.4 location of the attachment
|
|
* @param string $n_encoding Encoding of the attachment's name in Content-Type
|
|
* By default filenames are encoded using RFC2231 method
|
|
* Here you can set RFC2047 encoding (quoted-printable
|
|
* or base64) instead
|
|
* @param string $f_encoding Encoding of the attachment's filename
|
|
* in Content-Disposition header.
|
|
* @param string $description Content-Description header
|
|
* @param string $h_charset The character set of the headers e.g. filename
|
|
* If not specified, $charset will be used
|
|
* @param array $add_headers Additional part headers. Array keys can be in form
|
|
* of <header_name>:<parameter_name>
|
|
*
|
|
* @return mixed True on success or PEAR_Error object
|
|
* @access public
|
|
*/
|
|
public function addAttachment($file, $c_type = 'application/octet-stream', $name = '', $isfile = \true, $encoding = 'base64', $disposition = 'attachment', $charset = '', $language = '', $location = '', $n_encoding = \null, $f_encoding = \null, $description = '', $h_charset = \null, $add_headers = array())
|
|
{
|
|
}
|
|
/**
|
|
* Get the contents of the given file name as string
|
|
*
|
|
* @param string $file_name Path of file to process
|
|
*
|
|
* @return string Contents of $file_name
|
|
* @access private
|
|
*/
|
|
public function _file2str($file_name)
|
|
{
|
|
}
|
|
/**
|
|
* Adds a text subpart to the mimePart object and
|
|
* returns it during the build process.
|
|
*
|
|
* @param mixed &$obj The object to add the part to, or
|
|
* anything else if a new object is to be created.
|
|
* @param string $text The text to add.
|
|
*
|
|
* @return object The text mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addTextPart(&$obj, $text = '')
|
|
{
|
|
}
|
|
/**
|
|
* Adds a html subpart to the mimePart object and
|
|
* returns it during the build process.
|
|
*
|
|
* @param mixed &$obj The object to add the part to, or
|
|
* anything else if a new object is to be created.
|
|
*
|
|
* @return object The html mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addHtmlPart(&$obj)
|
|
{
|
|
}
|
|
/**
|
|
* Creates a new mimePart object, using multipart/mixed as
|
|
* the initial content-type and returns it during the
|
|
* build process.
|
|
*
|
|
* @return object The multipart/mixed mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addMixedPart()
|
|
{
|
|
}
|
|
/**
|
|
* Adds a multipart/alternative part to a mimePart
|
|
* object (or creates one), and returns it during
|
|
* the build process.
|
|
*
|
|
* @param mixed &$obj The object to add the part to, or
|
|
* anything else if a new object is to be created.
|
|
*
|
|
* @return object The multipart/mixed mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addAlternativePart(&$obj)
|
|
{
|
|
}
|
|
/**
|
|
* Adds a multipart/related part to a mimePart
|
|
* object (or creates one), and returns it during
|
|
* the build process.
|
|
*
|
|
* @param mixed &$obj The object to add the part to, or
|
|
* anything else if a new object is to be created
|
|
*
|
|
* @return object The multipart/mixed mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addRelatedPart(&$obj)
|
|
{
|
|
}
|
|
/**
|
|
* Adds an html image subpart to a mimePart object
|
|
* and returns it during the build process.
|
|
*
|
|
* @param object &$obj The mimePart to add the image to
|
|
* @param array $value The image information
|
|
*
|
|
* @return object The image mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addHtmlImagePart(&$obj, $value)
|
|
{
|
|
}
|
|
/**
|
|
* Adds an attachment subpart to a mimePart object
|
|
* and returns it during the build process.
|
|
*
|
|
* @param object &$obj The mimePart to add the image to
|
|
* @param array $value The attachment information
|
|
*
|
|
* @return object The image mimePart object
|
|
* @access private
|
|
*/
|
|
public function &_addAttachmentPart(&$obj, $value)
|
|
{
|
|
}
|
|
/**
|
|
* Returns the complete e-mail, ready to send using an alternative
|
|
* mail delivery method. Note that only the mailpart that is made
|
|
* with Mail_Mime is created. This means that,
|
|
* YOU WILL HAVE NO TO: HEADERS UNLESS YOU SET IT YOURSELF
|
|
* using the $headers parameter!
|
|
*
|
|
* @param string $separation The separation between these two parts.
|
|
* @param array $params The Build parameters passed to the
|
|
* get() function. See get() for more info.
|
|
* @param array $headers The extra headers that should be passed
|
|
* to the headers() method.
|
|
* See that function for more info.
|
|
* @param bool $overwrite Overwrite the existing headers with new.
|
|
*
|
|
* @return mixed The complete e-mail or PEAR error object
|
|
* @access public
|
|
*/
|
|
public function getMessage($separation = \null, $params = \null, $headers = \null, $overwrite = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Returns the complete e-mail body, ready to send using an alternative
|
|
* mail delivery method.
|
|
*
|
|
* @param array $params The Build parameters passed to the
|
|
* get() method. See get() for more info.
|
|
*
|
|
* @return mixed The e-mail body or PEAR error object
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function getMessageBody($params = \null)
|
|
{
|
|
}
|
|
/**
|
|
* Writes (appends) the complete e-mail into file.
|
|
*
|
|
* @param string $filename Output file location
|
|
* @param array $params The Build parameters passed to the
|
|
* get() method. See get() for more info.
|
|
* @param array $headers The extra headers that should be passed
|
|
* to the headers() function.
|
|
* See that function for more info.
|
|
* @param bool $overwrite Overwrite the existing headers with new.
|
|
*
|
|
* @return mixed True or PEAR error object
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function saveMessage($filename, $params = \null, $headers = \null, $overwrite = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Writes (appends) the complete e-mail body into file.
|
|
*
|
|
* @param string $filename Output file location
|
|
* @param array $params The Build parameters passed to the
|
|
* get() method. See get() for more info.
|
|
*
|
|
* @return mixed True or PEAR error object
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function saveMessageBody($filename, $params = \null)
|
|
{
|
|
}
|
|
/**
|
|
* Builds the multipart message from the list ($this->_parts) and
|
|
* returns the mime content.
|
|
*
|
|
* @param array $params Build parameters that change the way the email
|
|
* is built. Should be associative. See $_build_params.
|
|
* @param resource $filename Output file where to save the message instead of
|
|
* returning it
|
|
* @param boolean $skip_head True if you want to return/save only the message
|
|
* without headers
|
|
*
|
|
* @return mixed The MIME message content string, null or PEAR error object
|
|
* @access public
|
|
*/
|
|
public function get($params = \null, $filename = \null, $skip_head = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Returns an array with the headers needed to prepend to the email
|
|
* (MIME-Version and Content-Type). Format of argument is:
|
|
* $array['header-name'] = 'header-value';
|
|
*
|
|
* @param array $xtra_headers Assoc array with any extra headers (optional)
|
|
* (Don't set Content-Type for multipart messages here!)
|
|
* @param bool $overwrite Overwrite already existing headers.
|
|
* @param bool $skip_content Don't return content headers: Content-Type,
|
|
* Content-Disposition and Content-Transfer-Encoding
|
|
*
|
|
* @return array Assoc array with the mime headers
|
|
* @access public
|
|
*/
|
|
public function headers($xtra_headers = \null, $overwrite = \false, $skip_content = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Get the text version of the headers
|
|
* (usefull if you want to use the PHP mail() function)
|
|
*
|
|
* @param array $xtra_headers Assoc array with any extra headers (optional)
|
|
* (Don't set Content-Type for multipart messages here!)
|
|
* @param bool $overwrite Overwrite the existing headers with new.
|
|
* @param bool $skip_content Don't return content headers: Content-Type,
|
|
* Content-Disposition and Content-Transfer-Encoding
|
|
*
|
|
* @return string Plain text headers
|
|
* @access public
|
|
*/
|
|
public function txtHeaders($xtra_headers = \null, $overwrite = \false, $skip_content = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Sets message Content-Type header.
|
|
* Use it to build messages with various content-types e.g. miltipart/raport
|
|
* not supported by _contentHeaders() function.
|
|
*
|
|
* @param string $type Type name
|
|
* @param array $params Hash array of header parameters
|
|
*
|
|
* @return void
|
|
* @access public
|
|
* @since 1.7.0
|
|
*/
|
|
public function setContentType($type, $params = array())
|
|
{
|
|
}
|
|
/**
|
|
* Sets the Subject header
|
|
*
|
|
* @param string $subject String to set the subject to.
|
|
*
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
public function setSubject($subject)
|
|
{
|
|
}
|
|
/**
|
|
* Set an email to the From (the sender) header
|
|
*
|
|
* @param string $email The email address to use
|
|
*
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
public function setFrom($email)
|
|
{
|
|
}
|
|
/**
|
|
* Add an email to the To header
|
|
* (multiple calls to this method are allowed)
|
|
*
|
|
* @param string $email The email direction to add
|
|
*
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
public function addTo($email)
|
|
{
|
|
}
|
|
/**
|
|
* Add an email to the Cc (carbon copy) header
|
|
* (multiple calls to this method are allowed)
|
|
*
|
|
* @param string $email The email direction to add
|
|
*
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
public function addCc($email)
|
|
{
|
|
}
|
|
/**
|
|
* Add an email to the Bcc (blank carbon copy) header
|
|
* (multiple calls to this method are allowed)
|
|
*
|
|
* @param string $email The email direction to add
|
|
*
|
|
* @return void
|
|
* @access public
|
|
*/
|
|
public function addBcc($email)
|
|
{
|
|
}
|
|
/**
|
|
* Since the PHP send function requires you to specify
|
|
* recipients (To: header) separately from the other
|
|
* headers, the To: header is not properly encoded.
|
|
* To fix this, you can use this public method to
|
|
* encode your recipients before sending to the send
|
|
* function
|
|
*
|
|
* @param string $recipients A comma-delimited list of recipients
|
|
*
|
|
* @return string Encoded data
|
|
* @access public
|
|
*/
|
|
public function encodeRecipients($recipients)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes headers as per RFC2047
|
|
*
|
|
* @param array $input The header data to encode
|
|
* @param array $params Extra build parameters
|
|
*
|
|
* @return array Encoded data
|
|
* @access private
|
|
*/
|
|
public function _encodeHeaders($input, $params = array())
|
|
{
|
|
}
|
|
/**
|
|
* Encodes a header as per RFC2047
|
|
*
|
|
* @param string $name The header name
|
|
* @param string $value The header data to encode
|
|
* @param string $charset Character set name
|
|
* @param string $encoding Encoding name (base64 or quoted-printable)
|
|
*
|
|
* @return string Encoded header data (without a name)
|
|
* @access public
|
|
* @since 1.5.3
|
|
*/
|
|
public function encodeHeader($name, $value, $charset, $encoding)
|
|
{
|
|
}
|
|
/**
|
|
* Get file's basename (locale independent)
|
|
*
|
|
* @param string $filename Filename
|
|
*
|
|
* @return string Basename
|
|
* @access private
|
|
*/
|
|
public function _basename($filename)
|
|
{
|
|
}
|
|
/**
|
|
* Get Content-Type and Content-Transfer-Encoding headers of the message
|
|
*
|
|
* @return array Headers array
|
|
* @access private
|
|
*/
|
|
public function _contentHeaders()
|
|
{
|
|
}
|
|
/**
|
|
* Validate and set build parameters
|
|
*
|
|
* @return void
|
|
* @access private
|
|
*/
|
|
public function _checkParams()
|
|
{
|
|
}
|
|
/**
|
|
* PEAR::isError implementation
|
|
*
|
|
* @param mixed $data Object
|
|
*
|
|
* @return bool True if object is an instance of PEAR_Error
|
|
* @access private
|
|
*/
|
|
public function _isError($data)
|
|
{
|
|
}
|
|
/**
|
|
* PEAR::raiseError implementation
|
|
*
|
|
* @param $message A text error message
|
|
*
|
|
* @return PEAR_Error Instance of PEAR_Error
|
|
* @access private
|
|
*/
|
|
public function _raiseError($message)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* The Mail_mimePart class is used to create MIME E-mail messages
|
|
*
|
|
* This class enables you to manipulate and build a mime email
|
|
* from the ground up. The Mail_Mime class is a userfriendly api
|
|
* to this class for people who aren't interested in the internals
|
|
* of mime mail.
|
|
* This class however allows full control over the email.
|
|
*
|
|
* Compatible with PHP versions 4 and 5
|
|
*
|
|
* LICENSE: This LICENSE is in the BSD license style.
|
|
* Copyright (c) 2002-2003, Richard Heyes <richard@phpguru.org>
|
|
* Copyright (c) 2003-2006, PEAR <pear-group@php.net>
|
|
* 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 authors, 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 COPYRIGHT OWNER 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.
|
|
*
|
|
* @category Mail
|
|
* @package Mail_Mime
|
|
* @author Richard Heyes <richard@phpguru.org>
|
|
* @author Cipriano Groenendal <cipri@php.net>
|
|
* @author Sean Coates <sean@php.net>
|
|
* @author Aleksander Machniak <alec@php.net>
|
|
* @copyright 2003-2006 PEAR <pear-group@php.net>
|
|
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
|
|
* @version CVS: $Id$
|
|
* @link http://pear.php.net/package/Mail_mime
|
|
*/
|
|
/**
|
|
* The Mail_mimePart class is used to create MIME E-mail messages
|
|
*
|
|
* This class enables you to manipulate and build a mime email
|
|
* from the ground up. The Mail_Mime class is a userfriendly api
|
|
* to this class for people who aren't interested in the internals
|
|
* of mime mail.
|
|
* This class however allows full control over the email.
|
|
*
|
|
* @category Mail
|
|
* @package Mail_Mime
|
|
* @author Richard Heyes <richard@phpguru.org>
|
|
* @author Cipriano Groenendal <cipri@php.net>
|
|
* @author Sean Coates <sean@php.net>
|
|
* @author Aleksander Machniak <alec@php.net>
|
|
* @copyright 2003-2006 PEAR <pear-group@php.net>
|
|
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
|
|
* @version Release: @package_version@
|
|
* @link http://pear.php.net/package/Mail_mime
|
|
*/
|
|
class Mail_mimePart
|
|
{
|
|
/**
|
|
* The encoding type of this part
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_encoding;
|
|
/**
|
|
* An array of subparts
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $_subparts;
|
|
/**
|
|
* The output of this part after being built
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_encoded;
|
|
/**
|
|
* Headers for this part
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $_headers;
|
|
/**
|
|
* The body of this part (not encoded)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_body;
|
|
/**
|
|
* The location of file with body of this part (not encoded)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_body_file;
|
|
/**
|
|
* The end-of-line sequence
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $_eol = "\r\n";
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* Sets up the object.
|
|
*
|
|
* @param string $body The body of the mime part if any.
|
|
* @param array $params An associative array of optional parameters:
|
|
* content_type - The content type for this part eg multipart/mixed
|
|
* encoding - The encoding to use, 7bit, 8bit,
|
|
* base64, or quoted-printable
|
|
* charset - Content character set
|
|
* cid - Content ID to apply
|
|
* disposition - Content disposition, inline or attachment
|
|
* filename - Filename parameter for content disposition
|
|
* description - Content description
|
|
* name_encoding - Encoding of the attachment name (Content-Type)
|
|
* By default filenames are encoded using RFC2231
|
|
* Here you can set RFC2047 encoding (quoted-printable
|
|
* or base64) instead
|
|
* filename_encoding - Encoding of the attachment filename (Content-Disposition)
|
|
* See 'name_encoding'
|
|
* headers_charset - Charset of the headers e.g. filename, description.
|
|
* If not set, 'charset' will be used
|
|
* eol - End of line sequence. Default: "\r\n"
|
|
* headers - Hash array with additional part headers. Array keys can be
|
|
* in form of <header_name>:<parameter_name>
|
|
* body_file - Location of file with part's body (instead of $body)
|
|
*
|
|
* @access public
|
|
*/
|
|
public function Mail_mimePart($body = '', $params = array())
|
|
{
|
|
}
|
|
/**
|
|
* Encodes and returns the email. Also stores
|
|
* it in the encoded member variable
|
|
*
|
|
* @param string $boundary Pre-defined boundary string
|
|
*
|
|
* @return An associative array containing two elements,
|
|
* body and headers. The headers element is itself
|
|
* an indexed array. On error returns PEAR error object.
|
|
* @access public
|
|
*/
|
|
public function encode($boundary = \null)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes and saves the email into file. File must exist.
|
|
* Data will be appended to the file.
|
|
*
|
|
* @param string $filename Output file location
|
|
* @param string $boundary Pre-defined boundary string
|
|
* @param boolean $skip_head True if you don't want to save headers
|
|
*
|
|
* @return array An associative array containing message headers
|
|
* or PEAR error object
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function encodeToFile($filename, $boundary = \null, $skip_head = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes given email part into file
|
|
*
|
|
* @param string $fh Output file handle
|
|
* @param string $boundary Pre-defined boundary string
|
|
* @param boolean $skip_head True if you don't want to save headers
|
|
*
|
|
* @return array True on sucess or PEAR error object
|
|
* @access private
|
|
*/
|
|
public function _encodePartToFile($fh, $boundary = \null, $skip_head = \false)
|
|
{
|
|
}
|
|
/**
|
|
* Adds a subpart to current mime part and returns
|
|
* a reference to it
|
|
*
|
|
* @param string $body The body of the subpart, if any.
|
|
* @param array $params The parameters for the subpart, same
|
|
* as the $params argument for constructor.
|
|
*
|
|
* @return Mail_mimePart A reference to the part you just added. In PHP4, it is
|
|
* crucial if using multipart/* in your subparts that
|
|
* you use =& in your script when calling this function,
|
|
* otherwise you will not be able to add further subparts.
|
|
* @access public
|
|
*/
|
|
public function &addSubpart($body, $params)
|
|
{
|
|
}
|
|
/**
|
|
* Returns encoded data based upon encoding passed to it
|
|
*
|
|
* @param string $data The data to encode.
|
|
* @param string $encoding The encoding type to use, 7bit, base64,
|
|
* or quoted-printable.
|
|
*
|
|
* @return string
|
|
* @access private
|
|
*/
|
|
public function _getEncodedData($data, $encoding)
|
|
{
|
|
}
|
|
/**
|
|
* Returns encoded data based upon encoding passed to it
|
|
*
|
|
* @param string $filename Data file location
|
|
* @param string $encoding The encoding type to use, 7bit, base64,
|
|
* or quoted-printable.
|
|
* @param resource $fh Output file handle. If set, data will be
|
|
* stored into it instead of returning it
|
|
*
|
|
* @return string Encoded data or PEAR error object
|
|
* @access private
|
|
*/
|
|
public function _getEncodedDataFromFile($filename, $encoding, $fh = \null)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes data to quoted-printable standard.
|
|
*
|
|
* @param string $input The data to encode
|
|
* @param int $line_max Optional max line length. Should
|
|
* not be more than 76 chars
|
|
*
|
|
* @return string Encoded data
|
|
*
|
|
* @access private
|
|
*/
|
|
public function _quotedPrintableEncode($input, $line_max = 76)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes the parameter of a header.
|
|
*
|
|
* @param string $name The name of the header-parameter
|
|
* @param string $value The value of the paramter
|
|
* @param string $charset The characterset of $value
|
|
* @param string $language The language used in $value
|
|
* @param string $encoding Parameter encoding. If not set, parameter value
|
|
* is encoded according to RFC2231
|
|
* @param int $maxLength The maximum length of a line. Defauls to 75
|
|
*
|
|
* @return string
|
|
*
|
|
* @access private
|
|
*/
|
|
public function _buildHeaderParam($name, $value, $charset = \null, $language = \null, $encoding = \null, $maxLength = 75)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes header parameter as per RFC2047 if needed
|
|
*
|
|
* @param string $name The parameter name
|
|
* @param string $value The parameter value
|
|
* @param string $charset The parameter charset
|
|
* @param string $encoding Encoding type (quoted-printable or base64)
|
|
* @param int $maxLength Encoded parameter max length. Default: 76
|
|
*
|
|
* @return string Parameter line
|
|
* @access private
|
|
*/
|
|
public function _buildRFC2047Param($name, $value, $charset, $encoding = 'quoted-printable', $maxLength = 76)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes a header as per RFC2047
|
|
*
|
|
* @param string $name The header name
|
|
* @param string $value The header data to encode
|
|
* @param string $charset Character set name
|
|
* @param string $encoding Encoding name (base64 or quoted-printable)
|
|
* @param string $eol End-of-line sequence. Default: "\r\n"
|
|
*
|
|
* @return string Encoded header data (without a name)
|
|
* @access public
|
|
* @since 1.6.1
|
|
*/
|
|
public function encodeHeader($name, $value, $charset = 'ISO-8859-1', $encoding = 'quoted-printable', $eol = "\r\n")
|
|
{
|
|
}
|
|
/**
|
|
* Explode quoted string
|
|
*
|
|
* @param string $delimiter Delimiter expression string for preg_match()
|
|
* @param string $string Input string
|
|
*
|
|
* @return array String tokens array
|
|
* @access private
|
|
*/
|
|
public function _explodeQuotedString($delimiter, $string)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes a header value as per RFC2047
|
|
*
|
|
* @param string $value The header data to encode
|
|
* @param string $charset Character set name
|
|
* @param string $encoding Encoding name (base64 or quoted-printable)
|
|
* @param int $prefix_len Prefix length. Default: 0
|
|
* @param string $eol End-of-line sequence. Default: "\r\n"
|
|
*
|
|
* @return string Encoded header data
|
|
* @access public
|
|
* @since 1.6.1
|
|
*/
|
|
public function encodeHeaderValue($value, $charset, $encoding, $prefix_len = 0, $eol = "\r\n")
|
|
{
|
|
}
|
|
/**
|
|
* Encodes the given string using quoted-printable
|
|
*
|
|
* @param string $str String to encode
|
|
*
|
|
* @return string Encoded string
|
|
* @access public
|
|
* @since 1.6.0
|
|
*/
|
|
public function encodeQP($str)
|
|
{
|
|
}
|
|
/**
|
|
* Encodes the given string using base64 or quoted-printable.
|
|
* This method makes sure that encoded-word represents an integral
|
|
* number of characters as per RFC2047.
|
|
*
|
|
* @param string $str String to encode
|
|
* @param string $charset Character set name
|
|
* @param string $encoding Encoding name (base64 or quoted-printable)
|
|
* @param int $prefix_len Prefix length. Default: 0
|
|
* @param string $eol End-of-line sequence. Default: "\r\n"
|
|
*
|
|
* @return string Encoded string
|
|
* @access public
|
|
* @since 1.8.0
|
|
*/
|
|
public function encodeMB($str, $charset, $encoding, $prefix_len = 0, $eol = "\r\n")
|
|
{
|
|
}
|
|
/**
|
|
* Callback function to replace extended characters (\x80-xFF) with their
|
|
* ASCII values (RFC2047: quoted-printable)
|
|
*
|
|
* @param array $matches Preg_replace's matches array
|
|
*
|
|
* @return string Encoded character string
|
|
* @access private
|
|
*/
|
|
public function _qpReplaceCallback($matches)
|
|
{
|
|
}
|
|
/**
|
|
* Callback function to replace extended characters (\x80-xFF) with their
|
|
* ASCII values (RFC2231)
|
|
*
|
|
* @param array $matches Preg_replace's matches array
|
|
*
|
|
* @return string Encoded character string
|
|
* @access private
|
|
*/
|
|
public function _encodeReplaceCallback($matches)
|
|
{
|
|
}
|
|
/**
|
|
* PEAR::isError implementation
|
|
*
|
|
* @param mixed $data Object
|
|
*
|
|
* @return bool True if object is an instance of PEAR_Error
|
|
* @access private
|
|
*/
|
|
public function _isError($data)
|
|
{
|
|
}
|
|
/**
|
|
* PEAR::raiseError implementation
|
|
*
|
|
* @param $message A text error message
|
|
*
|
|
* @return PEAR_Error Instance of PEAR_Error
|
|
* @access private
|
|
*/
|
|
public function _raiseError($message)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* nusoap_base
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_base
|
|
{
|
|
/**
|
|
* Identification for HTTP headers.
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $title = 'NuSOAP';
|
|
/**
|
|
* Version for HTTP headers.
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $version = '0.9.11';
|
|
/**
|
|
* CVS revision for HTTP headers.
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $revision = '$Revision: 1.123 $';
|
|
/**
|
|
* Current error string (manipulated by getError/setError)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $error_str = '';
|
|
/**
|
|
* Current debug string (manipulated by debug/appendDebug/clearDebug/getDebug/getDebugAsXMLComment)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $debug_str = '';
|
|
/**
|
|
* toggles automatic encoding of special characters as entities
|
|
* (should always be true, I think)
|
|
*
|
|
* @var boolean
|
|
* @access private
|
|
*/
|
|
public $charencoding = \true;
|
|
/**
|
|
* the debug level for this instance
|
|
*
|
|
* @var integer
|
|
* @access private
|
|
*/
|
|
public $debugLevel;
|
|
/**
|
|
* set schema version
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $XMLSchemaVersion = 'http://www.w3.org/2001/XMLSchema';
|
|
/**
|
|
* charset encoding for outgoing messages
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $soap_defencoding = 'ISO-8859-1';
|
|
//var $soap_defencoding = 'UTF-8';
|
|
/**
|
|
* namespaces in an array of prefix => uri
|
|
*
|
|
* this is "seeded" by a set of constants, but it may be altered by code
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
public $namespaces = array('SOAP-ENV' => 'http://schemas.xmlsoap.org/soap/envelope/', 'xsd' => 'http://www.w3.org/2001/XMLSchema', 'xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'SOAP-ENC' => 'http://schemas.xmlsoap.org/soap/encoding/');
|
|
/**
|
|
* namespaces used in the current context, e.g. during serialization
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $usedNamespaces = array();
|
|
/**
|
|
* XML Schema types in an array of uri => (array of xml type => php type)
|
|
* is this legacy yet?
|
|
* no, this is used by the nusoap_xmlschema class to verify type => namespace mappings.
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
public $typemap = array('http://www.w3.org/2001/XMLSchema' => array(
|
|
'string' => 'string',
|
|
'boolean' => 'boolean',
|
|
'float' => 'double',
|
|
'double' => 'double',
|
|
'decimal' => 'double',
|
|
'duration' => '',
|
|
'dateTime' => 'string',
|
|
'time' => 'string',
|
|
'date' => 'string',
|
|
'gYearMonth' => '',
|
|
'gYear' => '',
|
|
'gMonthDay' => '',
|
|
'gDay' => '',
|
|
'gMonth' => '',
|
|
'hexBinary' => 'string',
|
|
'base64Binary' => 'string',
|
|
// abstract "any" types
|
|
'anyType' => 'string',
|
|
'anySimpleType' => 'string',
|
|
// derived datatypes
|
|
'normalizedString' => 'string',
|
|
'token' => 'string',
|
|
'language' => '',
|
|
'NMTOKEN' => '',
|
|
'NMTOKENS' => '',
|
|
'Name' => '',
|
|
'NCName' => '',
|
|
'ID' => '',
|
|
'IDREF' => '',
|
|
'IDREFS' => '',
|
|
'ENTITY' => '',
|
|
'ENTITIES' => '',
|
|
'integer' => 'integer',
|
|
'nonPositiveInteger' => 'integer',
|
|
'negativeInteger' => 'integer',
|
|
'long' => 'integer',
|
|
'int' => 'integer',
|
|
'short' => 'integer',
|
|
'byte' => 'integer',
|
|
'nonNegativeInteger' => 'integer',
|
|
'unsignedLong' => '',
|
|
'unsignedInt' => '',
|
|
'unsignedShort' => '',
|
|
'unsignedByte' => '',
|
|
'positiveInteger' => '',
|
|
), 'http://www.w3.org/2000/10/XMLSchema' => array('i4' => '', 'int' => 'integer', 'boolean' => 'boolean', 'string' => 'string', 'double' => 'double', 'float' => 'double', 'dateTime' => 'string', 'timeInstant' => 'string', 'base64Binary' => 'string', 'base64' => 'string', 'ur-type' => 'array'), 'http://www.w3.org/1999/XMLSchema' => array('i4' => '', 'int' => 'integer', 'boolean' => 'boolean', 'string' => 'string', 'double' => 'double', 'float' => 'double', 'dateTime' => 'string', 'timeInstant' => 'string', 'base64Binary' => 'string', 'base64' => 'string', 'ur-type' => 'array'), 'http://soapinterop.org/xsd' => array('SOAPStruct' => 'struct'), 'http://schemas.xmlsoap.org/soap/encoding/' => array('base64' => 'string', 'array' => 'array', 'Array' => 'array'), 'http://xml.apache.org/xml-soap' => array('Map'));
|
|
/**
|
|
* XML entities to convert
|
|
*
|
|
* @var array
|
|
* @access public
|
|
* @deprecated
|
|
* @see expandEntities
|
|
*/
|
|
public $xmlEntities = array('quot' => '"', 'amp' => '&', 'lt' => '<', 'gt' => '>', 'apos' => "'");
|
|
/**
|
|
* HTTP Content-type to be used for SOAP calls and responses
|
|
*
|
|
* @var string
|
|
*/
|
|
public $contentType = "text/xml";
|
|
/**
|
|
* constructor
|
|
*
|
|
* @access public
|
|
*/
|
|
public function __construct()
|
|
{
|
|
}
|
|
/**
|
|
* gets the global debug level, which applies to future instances
|
|
*
|
|
* @return integer Debug level 0-9, where 0 turns off
|
|
* @access public
|
|
*/
|
|
public function getGlobalDebugLevel()
|
|
{
|
|
}
|
|
/**
|
|
* sets the global debug level, which applies to future instances
|
|
*
|
|
* @param int $level Debug level 0-9, where 0 turns off
|
|
* @access public
|
|
*/
|
|
public function setGlobalDebugLevel($level)
|
|
{
|
|
}
|
|
/**
|
|
* gets the debug level for this instance
|
|
*
|
|
* @return int Debug level 0-9, where 0 turns off
|
|
* @access public
|
|
*/
|
|
public function getDebugLevel()
|
|
{
|
|
}
|
|
/**
|
|
* sets the debug level for this instance
|
|
*
|
|
* @param int $level Debug level 0-9, where 0 turns off
|
|
* @access public
|
|
*/
|
|
public function setDebugLevel($level)
|
|
{
|
|
}
|
|
/**
|
|
* adds debug data to the instance debug string with formatting
|
|
*
|
|
* @param string $string debug data
|
|
* @access private
|
|
*/
|
|
public function debug($string)
|
|
{
|
|
}
|
|
/**
|
|
* adds debug data to the instance debug string without formatting
|
|
*
|
|
* @param string $string debug data
|
|
* @access public
|
|
*/
|
|
public function appendDebug($string)
|
|
{
|
|
}
|
|
/**
|
|
* clears the current debug data for this instance
|
|
*
|
|
* @access public
|
|
*/
|
|
public function clearDebug()
|
|
{
|
|
}
|
|
/**
|
|
* gets the current debug data for this instance
|
|
*
|
|
* @return string data
|
|
* @access public
|
|
*/
|
|
public function &getDebug()
|
|
{
|
|
}
|
|
/**
|
|
* gets the current debug data for this instance as an XML comment
|
|
* this may change the contents of the debug data
|
|
*
|
|
* @return string data as an XML comment
|
|
* @access public
|
|
*/
|
|
public function &getDebugAsXMLComment()
|
|
{
|
|
}
|
|
/**
|
|
* expands entities, e.g. changes '<' to '<'.
|
|
*
|
|
* @param string $val The string in which to expand entities.
|
|
* @access private
|
|
*/
|
|
public function expandEntities($val)
|
|
{
|
|
}
|
|
/**
|
|
* returns error string if present
|
|
*
|
|
* @return false|string error string or false
|
|
* @access public
|
|
*/
|
|
public function getError()
|
|
{
|
|
}
|
|
/**
|
|
* sets error string
|
|
*
|
|
* @return void
|
|
* @access private
|
|
*/
|
|
public function setError($str)
|
|
{
|
|
}
|
|
/**
|
|
* detect if array is a simple array or a struct (associative array)
|
|
*
|
|
* @param mixed $val The PHP array
|
|
* @return string (arraySimple|arrayStruct)
|
|
* @access private
|
|
*/
|
|
public function isArraySimpleOrStruct($val)
|
|
{
|
|
}
|
|
/**
|
|
* serializes PHP values in accordance w/ section 5. Type information is
|
|
* not serialized if $use == 'literal'.
|
|
*
|
|
* @param mixed $val The value to serialize
|
|
* @param string $name The name (local part) of the XML element
|
|
* @param string $type The XML schema type (local part) for the element
|
|
* @param string $name_ns The namespace for the name of the XML element
|
|
* @param string $type_ns The namespace for the type of the element
|
|
* @param array $attributes The attributes to serialize as name=>value pairs
|
|
* @param string $use The WSDL "use" (encoded|literal)
|
|
* @param boolean $soapval Whether this is called from soapval.
|
|
* @return string The serialized element, possibly with child elements
|
|
* @access public
|
|
*/
|
|
public function serialize_val($val, $name = \false, $type = \false, $name_ns = \false, $type_ns = \false, $attributes = \false, $use = 'encoded', $soapval = \false)
|
|
{
|
|
}
|
|
/**
|
|
* serializes a message
|
|
*
|
|
* @param string $body the XML of the SOAP body
|
|
* @param mixed $headers optional string of XML with SOAP header content, or array of soapval objects for SOAP headers, or associative array
|
|
* @param array $namespaces optional the namespaces used in generating the body and headers
|
|
* @param string $style optional (rpc|document)
|
|
* @param string $use optional (encoded|literal)
|
|
* @param string $encodingStyle optional (usually 'http://schemas.xmlsoap.org/soap/encoding/' for encoded)
|
|
* @return string the message
|
|
* @access public
|
|
*/
|
|
public function serializeEnvelope($body, $headers = \false, $namespaces = array(), $style = 'rpc', $use = 'encoded', $encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/')
|
|
{
|
|
}
|
|
/**
|
|
* formats a string to be inserted into an HTML stream
|
|
*
|
|
* @param string $str The string to format
|
|
* @return string The formatted string
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function formatDump($str)
|
|
{
|
|
}
|
|
/**
|
|
* contracts (changes namespace to prefix) a qualified name
|
|
*
|
|
* @param string $qname qname
|
|
* @return string contracted qname
|
|
* @access private
|
|
*/
|
|
public function contractQname($qname)
|
|
{
|
|
}
|
|
/**
|
|
* expands (changes prefix to namespace) a qualified name
|
|
*
|
|
* @param string $qname qname
|
|
* @return string expanded qname
|
|
* @access private
|
|
*/
|
|
public function expandQname($qname)
|
|
{
|
|
}
|
|
/**
|
|
* returns the local part of a prefixed string
|
|
* returns the original string, if not prefixed
|
|
*
|
|
* @param string $str The prefixed string
|
|
* @return string The local part
|
|
* @access public
|
|
*/
|
|
public function getLocalPart($str)
|
|
{
|
|
}
|
|
/**
|
|
* returns the prefix part of a prefixed string
|
|
* returns false, if not prefixed
|
|
*
|
|
* @param string $str The prefixed string
|
|
* @return false|string The prefix or false if there is no prefix
|
|
* @access public
|
|
*/
|
|
public function getPrefix($str)
|
|
{
|
|
}
|
|
/**
|
|
* pass it a prefix, it returns a namespace
|
|
*
|
|
* @param string $prefix The prefix
|
|
* @return mixed The namespace, false if no namespace has the specified prefix
|
|
* @access public
|
|
*/
|
|
public function getNamespaceFromPrefix($prefix)
|
|
{
|
|
}
|
|
/**
|
|
* returns the prefix for a given namespace (or prefix)
|
|
* or false if no prefixes registered for the given namespace
|
|
*
|
|
* @param string $ns The namespace
|
|
* @return false|string The prefix, false if the namespace has no prefixes
|
|
* @access public
|
|
*/
|
|
public function getPrefixFromNamespace($ns)
|
|
{
|
|
}
|
|
/**
|
|
* returns the time in ODBC canonical form with microseconds
|
|
*
|
|
* @return string The time in ODBC canonical form with microseconds
|
|
* @access public
|
|
*/
|
|
public function getmicrotime()
|
|
{
|
|
}
|
|
/**
|
|
* Returns a string with the output of var_dump
|
|
*
|
|
* @param mixed $data The variable to var_dump
|
|
* @return string The output of var_dump
|
|
* @access public
|
|
*/
|
|
public function varDump($data)
|
|
{
|
|
}
|
|
/**
|
|
* represents the object as a string
|
|
*
|
|
* @return string
|
|
* @access public
|
|
*/
|
|
public function __toString()
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* Contains information for a SOAP fault.
|
|
* Mainly used for returning faults from deployed functions
|
|
* in a server instance.
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_fault extends \nusoap_base
|
|
{
|
|
/**
|
|
* The fault code (client|server)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $faultcode;
|
|
/**
|
|
* The fault actor
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $faultactor;
|
|
/**
|
|
* The fault string, a description of the fault
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $faultstring;
|
|
/**
|
|
* The fault detail, typically a string or array of string
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $faultdetail;
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param string $faultcode (SOAP-ENV:Client | SOAP-ENV:Server)
|
|
* @param string $faultactor only used when msg routed between multiple actors
|
|
* @param string $faultstring human readable error message
|
|
* @param mixed $faultdetail detail, typically a string or array of string
|
|
*/
|
|
public function __construct($faultcode, $faultactor = '', $faultstring = '', $faultdetail = '')
|
|
{
|
|
}
|
|
/**
|
|
* serialize a fault
|
|
*
|
|
* @return string The serialization of the fault instance.
|
|
* @access public
|
|
*/
|
|
public function serialize()
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* Backward compatibility
|
|
*/
|
|
class soap_fault extends \nusoap_fault
|
|
{
|
|
}
|
|
/**
|
|
* parses an XML Schema, allows access to it's data, other utility methods.
|
|
* imperfect, no validation... yet, but quite functional.
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_xmlschema extends \nusoap_base
|
|
{
|
|
// files
|
|
public $schema = '';
|
|
public $xml = '';
|
|
// namespaces
|
|
public $enclosingNamespaces;
|
|
// schema info
|
|
public $schemaInfo = array();
|
|
public $schemaTargetNamespace = '';
|
|
// types, elements, attributes defined by the schema
|
|
public $attributes = array();
|
|
public $complexTypes = array();
|
|
public $complexTypeStack = array();
|
|
public $currentComplexType = \null;
|
|
public $elements = array();
|
|
public $elementStack = array();
|
|
public $currentElement = \null;
|
|
public $simpleTypes = array();
|
|
public $simpleTypeStack = array();
|
|
public $currentSimpleType = \null;
|
|
// imports
|
|
public $imports = array();
|
|
// parser vars
|
|
public $parser;
|
|
public $position = 0;
|
|
public $depth = 0;
|
|
public $depth_array = array();
|
|
public $message = array();
|
|
public $defaultNamespace = array();
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param string $schema schema document URI
|
|
* @param string $xml xml document URI
|
|
* @param string $namespaces namespaces defined in enclosing XML
|
|
* @access public
|
|
*/
|
|
public function __construct($schema = '', $xml = '', $namespaces = array())
|
|
{
|
|
}
|
|
/**
|
|
* parse an XML file
|
|
*
|
|
* @param string $xml path/URL to XML file
|
|
* @param string $type (schema | xml)
|
|
* @return boolean
|
|
* @access public
|
|
*/
|
|
public function parseFile($xml, $type)
|
|
{
|
|
}
|
|
/**
|
|
* parse an XML string
|
|
*
|
|
* @param string $xml path or URL
|
|
* @param string $type (schema|xml)
|
|
* @access private
|
|
*/
|
|
public function parseString($xml, $type)
|
|
{
|
|
}
|
|
/**
|
|
* gets a type name for an unnamed type
|
|
*
|
|
* @param string $ename Element name
|
|
* @return string A type name for an unnamed type
|
|
* @access private
|
|
*/
|
|
public function CreateTypeName($ename)
|
|
{
|
|
}
|
|
/**
|
|
* start-element handler
|
|
*
|
|
* @param string $parser XML parser object
|
|
* @param string $name element name
|
|
* @param array $attrs associative array of attributes
|
|
* @access private
|
|
*/
|
|
public function schemaStartElement($parser, $name, $attrs)
|
|
{
|
|
}
|
|
/**
|
|
* end-element handler
|
|
*
|
|
* @param string $parser XML parser object
|
|
* @param string $name element name
|
|
* @access private
|
|
*/
|
|
public function schemaEndElement($parser, $name)
|
|
{
|
|
}
|
|
/**
|
|
* element content handler
|
|
*
|
|
* @param string $parser XML parser object
|
|
* @param string $data element content
|
|
* @access private
|
|
*/
|
|
public function schemaCharacterData($parser, $data)
|
|
{
|
|
}
|
|
/**
|
|
* serialize the schema
|
|
*
|
|
* @access public
|
|
*/
|
|
public function serializeSchema()
|
|
{
|
|
}
|
|
/**
|
|
* adds debug data to the clas level debug string
|
|
*
|
|
* @param string $string debug data
|
|
* @access private
|
|
*/
|
|
public function xdebug($string)
|
|
{
|
|
}
|
|
/**
|
|
* get the PHP type of a user defined type in the schema
|
|
* PHP type is kind of a misnomer since it actually returns 'struct' for assoc. arrays
|
|
* returns false if no type exists, or not w/ the given namespace
|
|
* else returns a string that is either a native php type, or 'struct'
|
|
*
|
|
* @param string $type name of defined type
|
|
* @param string $ns namespace of type
|
|
* @return mixed
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function getPHPType($type, $ns)
|
|
{
|
|
}
|
|
/**
|
|
* returns an associative array of information about a given type
|
|
* returns false if no type exists by the given name
|
|
*
|
|
* For a complexType typeDef = array(
|
|
* 'restrictionBase' => '',
|
|
* 'phpType' => '',
|
|
* 'compositor' => '(sequence|all)',
|
|
* 'elements' => array(), // refs to elements array
|
|
* 'attrs' => array() // refs to attributes array
|
|
* ... and so on (see addComplexType)
|
|
* )
|
|
*
|
|
* For simpleType or element, the array has different keys.
|
|
*
|
|
* @param string $type
|
|
* @return mixed
|
|
* @access public
|
|
* @see addComplexType
|
|
* @see addSimpleType
|
|
* @see addElement
|
|
*/
|
|
public function getTypeDef($type)
|
|
{
|
|
}
|
|
/**
|
|
* returns a sample serialization of a given type, or false if no type by the given name
|
|
*
|
|
* @param string $type name of type
|
|
* @return false|string
|
|
* @access public
|
|
*/
|
|
public function serializeTypeDef($type)
|
|
{
|
|
}
|
|
/**
|
|
* returns HTML form elements that allow a user
|
|
* to enter values for creating an instance of the given type.
|
|
*
|
|
* @param string $name name for type instance
|
|
* @param string $type name of type
|
|
* @return string
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function typeToForm($name, $type)
|
|
{
|
|
}
|
|
/**
|
|
* adds a complex type to the schema
|
|
* example: array
|
|
* addType(
|
|
* 'ArrayOfstring',
|
|
* 'complexType',
|
|
* 'array',
|
|
* '',
|
|
* 'SOAP-ENC:Array',
|
|
* array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'string[]'),
|
|
* 'xsd:string'
|
|
* );
|
|
* example: PHP associative array ( SOAP Struct )
|
|
* addType(
|
|
* 'SOAPStruct',
|
|
* 'complexType',
|
|
* 'struct',
|
|
* 'all',
|
|
* array('myVar'=> array('name'=>'myVar','type'=>'string')
|
|
* );
|
|
*
|
|
* @param string $name
|
|
* @param string $typeClass (complexType|simpleType|attribute)
|
|
* @param string $phpType : currently supported are array and struct (php assoc array)
|
|
* @param string $compositor (all|sequence|choice)
|
|
* @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
|
|
* @param array $elements = array ( name = array(name=>'',type=>'') )
|
|
* @param array $attrs = array(
|
|
* array(
|
|
* 'ref' => "http://schemas.xmlsoap.org/soap/encoding/:arrayType",
|
|
* "http://schemas.xmlsoap.org/wsdl/:arrayType" => "string[]"
|
|
* )
|
|
* )
|
|
* @param array $arrayType : namespace:name (http://www.w3.org/2001/XMLSchema:string)
|
|
*
|
|
* @access public
|
|
* @see getTypeDef
|
|
*/
|
|
public function addComplexType($name, $typeClass = 'complexType', $phpType = 'array', $compositor = '', $restrictionBase = '', $elements = array(), $attrs = array(), $arrayType = '')
|
|
{
|
|
}
|
|
/**
|
|
* adds a simple type to the schema
|
|
*
|
|
* @param string $name
|
|
* @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
|
|
* @param string $typeClass (should always be simpleType)
|
|
* @param string $phpType (should always be scalar)
|
|
* @param array $enumeration array of values
|
|
* @access public
|
|
* @see nusoap_xmlschema
|
|
* @see getTypeDef
|
|
*/
|
|
public function addSimpleType($name, $restrictionBase = '', $typeClass = 'simpleType', $phpType = 'scalar', $enumeration = array())
|
|
{
|
|
}
|
|
/**
|
|
* adds an element to the schema
|
|
*
|
|
* @param array $attrs attributes that must include name and type
|
|
* @see nusoap_xmlschema
|
|
* @access public
|
|
*/
|
|
public function addElement($attrs)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* Backward compatibility
|
|
*/
|
|
class XMLSchema extends \nusoap_xmlschema
|
|
{
|
|
}
|
|
/**
|
|
* For creating serializable abstractions of native PHP types. This class
|
|
* allows element name/namespace, XSD type, and XML attributes to be
|
|
* associated with a value. This is extremely useful when WSDL is not
|
|
* used, but is also useful when WSDL is used with polymorphic types, including
|
|
* xsd:anyType and user-defined types.
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class soapval extends \nusoap_base
|
|
{
|
|
/**
|
|
* The XML element name
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $name;
|
|
/**
|
|
* The XML type name (string or false)
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $type;
|
|
/**
|
|
* The PHP value
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $value;
|
|
/**
|
|
* The XML element namespace (string or false)
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $element_ns;
|
|
/**
|
|
* The XML type namespace (string or false)
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $type_ns;
|
|
/**
|
|
* The XML element attributes (array or false)
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $attributes;
|
|
/** @var false|resource */
|
|
public $fp;
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param string $name optional name
|
|
* @param mixed $type optional type name
|
|
* @param mixed $value optional value
|
|
* @param mixed $element_ns optional namespace of value
|
|
* @param mixed $type_ns optional namespace of type
|
|
* @param mixed $attributes associative array of attributes to add to element serialization
|
|
* @access public
|
|
*/
|
|
public function __construct($name = 'soapval', $type = \false, $value = -1, $element_ns = \false, $type_ns = \false, $attributes = \false)
|
|
{
|
|
}
|
|
/**
|
|
* return serialized value
|
|
*
|
|
* @param string $use The WSDL use value (encoded|literal)
|
|
* @return string XML data
|
|
* @access public
|
|
*/
|
|
public function serialize($use = 'encoded')
|
|
{
|
|
}
|
|
/**
|
|
* decodes a soapval object into a PHP native type
|
|
*
|
|
* @return mixed
|
|
* @access public
|
|
*/
|
|
public function decode()
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* transport class for sending/receiving data via HTTP and HTTPS
|
|
* NOTE: PHP must be compiled with the CURL extension for HTTPS support
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class soap_transport_http extends \nusoap_base
|
|
{
|
|
public $query = '';
|
|
public $tryagain = \false;
|
|
public $url = '';
|
|
public $uri = '';
|
|
public $digest_uri = '';
|
|
public $scheme = '';
|
|
public $host = '';
|
|
public $port = '';
|
|
public $path = '';
|
|
public $request_method = 'POST';
|
|
public $protocol_version = '1.0';
|
|
public $encoding = '';
|
|
public $outgoing_headers = array();
|
|
public $incoming_headers = array();
|
|
public $incoming_cookies = array();
|
|
public $outgoing_payload = '';
|
|
public $incoming_payload = '';
|
|
public $response_status_line;
|
|
// HTTP response status line
|
|
public $useSOAPAction = \true;
|
|
public $persistentConnection = \false;
|
|
public $ch = \false;
|
|
// cURL handle
|
|
public $ch_options = array();
|
|
// cURL custom options
|
|
public $use_curl = \false;
|
|
// force cURL use
|
|
public $proxy = \null;
|
|
// proxy information (associative array)
|
|
public $username = '';
|
|
public $password = '';
|
|
public $authtype = '';
|
|
public $digestRequest = array();
|
|
public $certRequest = array();
|
|
// keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, certpassword (optional), verifypeer (optional), verifyhost (optional)
|
|
// cainfofile: certificate authority file, e.g. '$pathToPemFiles/rootca.pem'
|
|
// sslcertfile: SSL certificate file, e.g. '$pathToPemFiles/mycert.pem'
|
|
// sslkeyfile: SSL key file, e.g. '$pathToPemFiles/mykey.pem'
|
|
// passphrase: SSL key password/passphrase
|
|
// certpassword: SSL certificate password
|
|
// verifypeer: default is 1
|
|
// verifyhost: default is 1
|
|
/** @var false|resource */
|
|
public $fp;
|
|
public $errno;
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param string $url The URL to which to connect
|
|
* @param array $curl_options User-specified cURL options
|
|
* @param boolean $use_curl Whether to try to force cURL use
|
|
* @access public
|
|
*/
|
|
public function __construct($url, $curl_options = \null, $use_curl = \false)
|
|
{
|
|
}
|
|
/**
|
|
* sets a cURL option
|
|
*
|
|
* @param mixed $option The cURL option (always integer?)
|
|
* @param mixed $value The cURL option value
|
|
* @access private
|
|
*/
|
|
public function setCurlOption($option, $value)
|
|
{
|
|
}
|
|
/**
|
|
* sets an HTTP header
|
|
*
|
|
* @param string $name The name of the header
|
|
* @param string $value The value of the header
|
|
* @access private
|
|
*/
|
|
public function setHeader($name, $value)
|
|
{
|
|
}
|
|
/**
|
|
* unsets an HTTP header
|
|
*
|
|
* @param string $name The name of the header
|
|
* @access private
|
|
*/
|
|
public function unsetHeader($name)
|
|
{
|
|
}
|
|
/**
|
|
* sets the URL to which to connect
|
|
*
|
|
* @param string $url The URL to which to connect
|
|
* @access private
|
|
*/
|
|
public function setURL($url)
|
|
{
|
|
}
|
|
/**
|
|
* gets the I/O method to use
|
|
*
|
|
* @return string I/O method to use (socket|curl|unknown)
|
|
* @access private
|
|
*/
|
|
public function io_method()
|
|
{
|
|
}
|
|
/**
|
|
* establish an HTTP connection
|
|
*
|
|
* @param integer $connection_timeout set connection timeout in seconds
|
|
* @param integer $response_timeout set response timeout in seconds
|
|
* @return boolean true if connected, false if not
|
|
* @access private
|
|
*/
|
|
public function connect($connection_timeout = 0, $response_timeout = 30)
|
|
{
|
|
}
|
|
/**
|
|
* sends the SOAP request and gets the SOAP response via HTTP[S]
|
|
*
|
|
* @param string $data message data
|
|
* @param integer $timeout set connection timeout in seconds
|
|
* @param integer $response_timeout set response timeout in seconds
|
|
* @param array $cookies cookies to send
|
|
* @return string data
|
|
* @access public
|
|
*/
|
|
public function send($data, $timeout = 0, $response_timeout = 30, $cookies = \null)
|
|
{
|
|
}
|
|
/**
|
|
* sends the SOAP request and gets the SOAP response via HTTPS using CURL
|
|
*
|
|
* @param string $data message data
|
|
* @param integer $timeout set connection timeout in seconds
|
|
* @param integer $response_timeout set response timeout in seconds
|
|
* @param array $cookies cookies to send
|
|
* @return string data
|
|
* @access public
|
|
*/
|
|
public function sendHTTPS($data, $timeout = 0, $response_timeout = 30, $cookies = \NULL)
|
|
{
|
|
}
|
|
/**
|
|
* if authenticating, set user credentials here
|
|
*
|
|
* @param string $username
|
|
* @param string $password
|
|
* @param string $authtype (basic|digest|certificate|ntlm)
|
|
* @param array $digestRequest (keys must be nonce, nc, realm, qop)
|
|
* @param array $certRequest (keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, certpassword (optional), verifypeer (optional), verifyhost (optional): see corresponding options in cURL docs)
|
|
* @access public
|
|
*/
|
|
public function setCredentials($username, $password, $authtype = 'basic', $digestRequest = array(), $certRequest = array())
|
|
{
|
|
}
|
|
/**
|
|
* set the soapaction value
|
|
*
|
|
* @param string $soapaction
|
|
* @access public
|
|
*/
|
|
public function setSOAPAction($soapaction)
|
|
{
|
|
}
|
|
/**
|
|
* use http encoding
|
|
*
|
|
* @param string $enc encoding style. supported values: gzip, deflate, or both
|
|
* @access public
|
|
*/
|
|
public function setEncoding($enc = 'gzip, deflate')
|
|
{
|
|
}
|
|
/**
|
|
* set proxy info here
|
|
*
|
|
* @param string $proxyhost use an empty string to remove proxy
|
|
* @param string $proxyport
|
|
* @param string $proxyusername
|
|
* @param string $proxypassword
|
|
* @param string $proxyauthtype (basic|ntlm)
|
|
* @access public
|
|
*/
|
|
public function setProxy($proxyhost, $proxyport, $proxyusername = '', $proxypassword = '', $proxyauthtype = 'basic')
|
|
{
|
|
}
|
|
/**
|
|
* Test if the given string starts with a header that is to be skipped.
|
|
* Skippable headers result from chunked transfer and proxy requests.
|
|
*
|
|
* @param string $data The string to check.
|
|
* @returns boolean Whether a skippable header was found.
|
|
* @access private
|
|
*/
|
|
public function isSkippableCurlHeader($data)
|
|
{
|
|
}
|
|
/**
|
|
* decode a string that is encoded w/ "chunked' transfer encoding
|
|
* as defined in RFC2068 19.4.6
|
|
*
|
|
* @param string $buffer
|
|
* @param string $lb
|
|
* @returns string
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function decodeChunked($buffer, $lb)
|
|
{
|
|
}
|
|
/**
|
|
* Writes the payload, including HTTP headers, to $this->outgoing_payload.
|
|
*
|
|
* @param string $data HTTP body
|
|
* @param string $cookie_str data for HTTP Cookie header
|
|
* @return void
|
|
* @access private
|
|
*/
|
|
public function buildPayload($data, $cookie_str = '')
|
|
{
|
|
}
|
|
/**
|
|
* sends the SOAP request via HTTP[S]
|
|
*
|
|
* @param string $data message data
|
|
* @param array $cookies cookies to send
|
|
* @return boolean true if OK, false if problem
|
|
* @access private
|
|
*/
|
|
public function sendRequest($data, $cookies = \null)
|
|
{
|
|
}
|
|
/**
|
|
* gets the SOAP response via HTTP[S]
|
|
*
|
|
* @return string the response (also sets member variables like incoming_payload)
|
|
* @access private
|
|
*/
|
|
public function getResponse()
|
|
{
|
|
}
|
|
/**
|
|
* sets the content-type for the SOAP message to be sent
|
|
*
|
|
* @param string $type the content type, MIME style
|
|
* @param mixed $charset character set used for encoding (or false)
|
|
* @access public
|
|
*/
|
|
public function setContentType($type, $charset = \false)
|
|
{
|
|
}
|
|
/**
|
|
* specifies that an HTTP persistent connection should be used
|
|
*
|
|
* @return boolean whether the request was honored by this method.
|
|
* @access public
|
|
*/
|
|
public function usePersistentConnection()
|
|
{
|
|
}
|
|
/**
|
|
* parse an incoming Cookie into it's parts
|
|
*
|
|
* @param string $cookie_str content of cookie
|
|
* @return array with data of that cookie
|
|
* @access private
|
|
*/
|
|
/*
|
|
* TODO: allow a Set-Cookie string to be parsed into multiple cookies
|
|
*/
|
|
public function parseCookie($cookie_str)
|
|
{
|
|
}
|
|
/**
|
|
* sort out cookies for the current request
|
|
*
|
|
* @param array $cookies array with all cookies
|
|
* @param boolean $secure is the send-content secure or not?
|
|
* @return string for Cookie-HTTP-Header
|
|
* @access private
|
|
*/
|
|
public function getCookiesForRequest($cookies, $secure = \false)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* nusoap_server allows the user to create a SOAP server
|
|
* that is capable of receiving messages and returning responses
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_server extends \nusoap_base
|
|
{
|
|
/**
|
|
* HTTP headers of request
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $headers = array();
|
|
/**
|
|
* HTTP request
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $request = '';
|
|
/**
|
|
* SOAP headers from request (incomplete namespace resolution; special characters not escaped) (text)
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $requestHeaders = '';
|
|
/**
|
|
* SOAP Headers from request (parsed)
|
|
*
|
|
* @var mixed
|
|
* @access public
|
|
*/
|
|
public $requestHeader = \null;
|
|
/**
|
|
* SOAP body request portion (incomplete namespace resolution; special characters not escaped) (text)
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $document = '';
|
|
/**
|
|
* SOAP payload for request (text)
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $requestSOAP = '';
|
|
/**
|
|
* requested method namespace URI
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $methodURI = '';
|
|
/**
|
|
* name of method requested
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $methodname = '';
|
|
/**
|
|
* name of the response tag name
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $responseTagName = '';
|
|
/**
|
|
* method parameters from request
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $methodparams = array();
|
|
/**
|
|
* SOAP Action from request
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $SOAPAction = '';
|
|
/**
|
|
* character set encoding of incoming (request) messages
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $xml_encoding = '';
|
|
/**
|
|
* toggles whether the parser decodes element content w/ utf8_decode()
|
|
*
|
|
* @var boolean
|
|
* @access public
|
|
*/
|
|
public $decode_utf8 = \true;
|
|
/**
|
|
* HTTP headers of response
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
public $outgoing_headers = array();
|
|
/**
|
|
* HTTP response
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $response = '';
|
|
/**
|
|
* SOAP headers for response (text or array of soapval or associative array)
|
|
*
|
|
* @var mixed
|
|
* @access public
|
|
*/
|
|
public $responseHeaders = '';
|
|
/**
|
|
* SOAP payload for response (text)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $responseSOAP = '';
|
|
/**
|
|
* SOAP attachments in response
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $attachments = '';
|
|
/**
|
|
* method return value to place in response
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $methodreturn = \false;
|
|
/**
|
|
* whether $methodreturn is a string of literal XML
|
|
*
|
|
* @var boolean
|
|
* @access public
|
|
*/
|
|
public $methodreturnisliteralxml = \false;
|
|
/**
|
|
* SOAP fault for response (or false)
|
|
*
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
public $fault = \false;
|
|
/**
|
|
* text indication of result (for debugging)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $result = 'successful';
|
|
/**
|
|
* assoc array of operations => opData; operations are added by the register()
|
|
* method or by parsing an external WSDL definition
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
public $operations = array();
|
|
/**
|
|
* wsdl instance (if one)
|
|
*
|
|
* @var false|wsdl
|
|
* @access private
|
|
*/
|
|
public $wsdl = \false;
|
|
/**
|
|
* URL for WSDL (if one)
|
|
*
|
|
* @var false|string
|
|
* @access private
|
|
*/
|
|
public $externalWSDLURL = \false;
|
|
/**
|
|
* whether to append debug to response as XML comment
|
|
*
|
|
* @var boolean
|
|
* @access public
|
|
*/
|
|
public $debug_flag = \false;
|
|
/** @var array */
|
|
public $opData;
|
|
/**
|
|
* constructor
|
|
* the optional parameter is a path to a WSDL file that you'd like to bind the server instance to.
|
|
*
|
|
* @param false|string|wsdl $wsdl file path or URL (string), or wsdl instance (object)
|
|
* @access public
|
|
*/
|
|
public function __construct($wsdl = \false)
|
|
{
|
|
}
|
|
/**
|
|
* processes request and returns response
|
|
*
|
|
* @param string $data usually is the value of $HTTP_RAW_POST_DATA
|
|
* @access public
|
|
*/
|
|
public function service($data)
|
|
{
|
|
}
|
|
/**
|
|
* parses HTTP request headers.
|
|
*
|
|
* The following fields are set by this function (when successful)
|
|
*
|
|
* headers
|
|
* request
|
|
* xml_encoding
|
|
* SOAPAction
|
|
*
|
|
* @access private
|
|
*/
|
|
public function parse_http_headers()
|
|
{
|
|
}
|
|
/**
|
|
* parses a request
|
|
*
|
|
* The following fields are set by this function (when successful)
|
|
*
|
|
* headers
|
|
* request
|
|
* xml_encoding
|
|
* SOAPAction
|
|
* request
|
|
* requestSOAP
|
|
* methodURI
|
|
* methodname
|
|
* methodparams
|
|
* requestHeaders
|
|
* document
|
|
*
|
|
* This sets the fault field on error
|
|
*
|
|
* @param string $data XML string
|
|
* @access private
|
|
*/
|
|
public function parse_request($data = '')
|
|
{
|
|
}
|
|
/**
|
|
* invokes a PHP function for the requested SOAP method
|
|
*
|
|
* The following fields are set by this function (when successful)
|
|
*
|
|
* methodreturn
|
|
*
|
|
* Note that the PHP function that is called may also set the following
|
|
* fields to affect the response sent to the client
|
|
*
|
|
* responseHeaders
|
|
* outgoing_headers
|
|
*
|
|
* This sets the fault field on error
|
|
*
|
|
* @access private
|
|
*/
|
|
public function invoke_method()
|
|
{
|
|
}
|
|
/**
|
|
* serializes the return value from a PHP function into a full SOAP Envelope
|
|
*
|
|
* The following fields are set by this function (when successful)
|
|
*
|
|
* responseSOAP
|
|
*
|
|
* This sets the fault field on error
|
|
*
|
|
* @access private
|
|
*/
|
|
public function serialize_return()
|
|
{
|
|
}
|
|
/**
|
|
* sends an HTTP response
|
|
*
|
|
* The following fields are set by this function (when successful)
|
|
*
|
|
* outgoing_headers
|
|
* response
|
|
*
|
|
* @access private
|
|
*/
|
|
public function send_response()
|
|
{
|
|
}
|
|
/**
|
|
* takes the value that was created by parsing the request
|
|
* and compares to the method's signature, if available.
|
|
*
|
|
* @param string $operation The operation to be invoked
|
|
* @param array $request The array of parameter values
|
|
* @return boolean Whether the operation was found
|
|
* @access private
|
|
*/
|
|
public function verify_method($operation, $request)
|
|
{
|
|
}
|
|
/**
|
|
* processes SOAP message received from client
|
|
*
|
|
* @param array $headers The HTTP headers
|
|
* @param string $data unprocessed request data from client
|
|
* @return false|void void or false on error
|
|
* @access private
|
|
*/
|
|
public function parseRequest($headers, $data)
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP body for the current response.
|
|
*
|
|
* @param string $soapmsg The SOAP payload
|
|
* @return string The HTTP body, which includes the SOAP payload
|
|
* @access private
|
|
*/
|
|
public function getHTTPBody($soapmsg)
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type for the current response.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type for the current response.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentType()
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type charset for the current response.
|
|
* returns false for non-text content types.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type charset for the current response.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentTypeCharset()
|
|
{
|
|
}
|
|
/**
|
|
* add a method to the dispatch map (this has been replaced by the register method)
|
|
*
|
|
* @param string $methodname
|
|
* @param string $in array of input values
|
|
* @param string $out array of output values
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function add_to_map($methodname, $in, $out)
|
|
{
|
|
}
|
|
/**
|
|
* register a service function with the server
|
|
*
|
|
* @param string $name the name of the PHP function, class.method or class..method
|
|
* @param array $in assoc array of input values: key = param name, value = param type
|
|
* @param array $out assoc array of output values: key = param name, value = param type
|
|
* @param mixed $namespace the element namespace for the method or false
|
|
* @param mixed $soapaction the soapaction for the method or false
|
|
* @param mixed $style optional (rpc|document) or false Note: when 'document' is specified, parameter and return wrappers are created for you automatically
|
|
* @param mixed $use optional (encoded|literal) or false
|
|
* @param string $documentation optional Description to include in WSDL
|
|
* @param string $encodingStyle optional (usually 'http://schemas.xmlsoap.org/soap/encoding/' for encoded)
|
|
* @param string $customResponseTagName optional Name of the outgoing response, default $name . 'Response'
|
|
* @access public
|
|
*/
|
|
public function register($name, $in = array(), $out = array(), $namespace = \false, $soapaction = \false, $style = \false, $use = \false, $documentation = '', $encodingStyle = '', $customResponseTagName = '')
|
|
{
|
|
}
|
|
/**
|
|
* Specify a fault to be returned to the client.
|
|
* This also acts as a flag to the server that a fault has occured.
|
|
*
|
|
* @param string $faultcode
|
|
* @param string $faultstring
|
|
* @param string $faultactor
|
|
* @param string $faultdetail
|
|
* @access public
|
|
*/
|
|
public function fault($faultcode, $faultstring, $faultactor = '', $faultdetail = '')
|
|
{
|
|
}
|
|
/**
|
|
* Sets up wsdl object.
|
|
* Acts as a flag to enable internal WSDL generation
|
|
*
|
|
* @param string $serviceName , name of the service
|
|
* @param mixed $namespace optional 'tns' service namespace or false
|
|
* @param mixed $endpoint optional URL of service endpoint or false
|
|
* @param string $style optional (rpc|document) WSDL style (also specified by operation)
|
|
* @param string $transport optional SOAP transport
|
|
* @param mixed $schemaTargetNamespace optional 'types' targetNamespace for service schema or false
|
|
*/
|
|
public function configureWSDL($serviceName, $namespace = \false, $endpoint = \false, $style = 'rpc', $transport = 'http://schemas.xmlsoap.org/soap/http', $schemaTargetNamespace = \false)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* Backward compatibility
|
|
*/
|
|
class soap_server extends \nusoap_server
|
|
{
|
|
}
|
|
/**
|
|
* parses a WSDL file, allows access to it's data, other utility methods.
|
|
* also builds WSDL structures programmatically.
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class wsdl extends \nusoap_base
|
|
{
|
|
// URL or filename of the root of this WSDL
|
|
public $wsdl;
|
|
// define internal arrays of bindings, ports, operations, messages, etc.
|
|
public $schemas = array();
|
|
public $currentSchema;
|
|
public $message = array();
|
|
public $complexTypes = array();
|
|
public $messages = array();
|
|
public $currentMessage;
|
|
public $currentOperation;
|
|
public $portTypes = array();
|
|
public $currentPortType;
|
|
public $bindings = array();
|
|
public $currentBinding;
|
|
public $ports = array();
|
|
public $currentPort;
|
|
public $opData = array();
|
|
public $status = '';
|
|
public $documentation = \false;
|
|
public $endpoint = '';
|
|
// array of wsdl docs to import
|
|
public $import = array();
|
|
// parser vars
|
|
public $parser;
|
|
public $position = 0;
|
|
public $depth = 0;
|
|
public $depth_array = array();
|
|
// for getting wsdl
|
|
public $proxyhost = '';
|
|
public $proxyport = '';
|
|
public $proxyusername = '';
|
|
public $proxypassword = '';
|
|
public $timeout = 0;
|
|
public $response_timeout = 30;
|
|
public $curl_options = array();
|
|
// User-specified cURL options
|
|
public $use_curl = \false;
|
|
// whether to always try to use cURL
|
|
// for HTTP authentication
|
|
public $username = '';
|
|
// Username for HTTP authentication
|
|
public $password = '';
|
|
// Password for HTTP authentication
|
|
public $authtype = '';
|
|
// Type of HTTP authentication
|
|
public $certRequest = array();
|
|
// Certificate for HTTP SSL authentication
|
|
/** @var mixed */
|
|
public $currentPortOperation;
|
|
/** @var string */
|
|
public $opStatus;
|
|
/** @var mixed */
|
|
public $serviceName;
|
|
public $wsdl_info;
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param string $wsdl WSDL document URL
|
|
* @param string $proxyhost
|
|
* @param string $proxyport
|
|
* @param string $proxyusername
|
|
* @param string $proxypassword
|
|
* @param integer $timeout set the connection timeout
|
|
* @param integer $response_timeout set the response timeout
|
|
* @param array $curl_options user-specified cURL options
|
|
* @param boolean $use_curl try to use cURL
|
|
* @access public
|
|
*/
|
|
public function __construct($wsdl = '', $proxyhost = \false, $proxyport = \false, $proxyusername = \false, $proxypassword = \false, $timeout = 0, $response_timeout = 30, $curl_options = \null, $use_curl = \false)
|
|
{
|
|
}
|
|
/**
|
|
* fetches the WSDL document and parses it
|
|
*
|
|
* @access public
|
|
*/
|
|
public function fetchWSDL($wsdl)
|
|
{
|
|
}
|
|
/**
|
|
* parses the wsdl document
|
|
*
|
|
* @param string $wsdl path or URL
|
|
* @access private
|
|
*/
|
|
public function parseWSDL($wsdl = '')
|
|
{
|
|
}
|
|
/**
|
|
* start-element handler
|
|
*
|
|
* @param string $parser XML parser object
|
|
* @param string $name element name
|
|
* @param array $attrs associative array of attributes
|
|
* @access private
|
|
*/
|
|
public function start_element($parser, $name, $attrs)
|
|
{
|
|
}
|
|
/**
|
|
* end-element handler
|
|
*
|
|
* @param string $parser XML parser object
|
|
* @param string $name element name
|
|
* @access private
|
|
*/
|
|
public function end_element($parser, $name)
|
|
{
|
|
}
|
|
/**
|
|
* element content handler
|
|
*
|
|
* @param string $parser XML parser object
|
|
* @param string $data element content
|
|
* @access private
|
|
*/
|
|
public function character_data($parser, $data)
|
|
{
|
|
}
|
|
/**
|
|
* if authenticating, set user credentials here
|
|
*
|
|
* @param string $username
|
|
* @param string $password
|
|
* @param string $authtype (basic|digest|certificate|ntlm)
|
|
* @param array $certRequest (keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, certpassword (optional), verifypeer (optional), verifyhost (optional): see corresponding options in cURL docs)
|
|
* @access public
|
|
*/
|
|
public function setCredentials($username, $password, $authtype = 'basic', $certRequest = array())
|
|
{
|
|
}
|
|
public function getBindingData($binding)
|
|
{
|
|
}
|
|
/**
|
|
* returns an assoc array of operation names => operation data
|
|
*
|
|
* @param string $portName WSDL port name
|
|
* @param string $bindingType eg: soap, smtp, dime (only soap and soap12 are currently supported)
|
|
* @return array
|
|
* @access public
|
|
*/
|
|
public function getOperations($portName = '', $bindingType = 'soap')
|
|
{
|
|
}
|
|
/**
|
|
* returns an associative array of data necessary for calling an operation
|
|
*
|
|
* @param string $operation name of operation
|
|
* @param string $bindingType type of binding eg: soap, soap12
|
|
* @return array
|
|
* @access public
|
|
*/
|
|
public function getOperationData($operation, $bindingType = 'soap')
|
|
{
|
|
}
|
|
/**
|
|
* returns an associative array of data necessary for calling an operation
|
|
*
|
|
* @param string $soapAction soapAction for operation
|
|
* @param string $bindingType type of binding eg: soap, soap12
|
|
* @return array
|
|
* @access public
|
|
*/
|
|
public function getOperationDataForSoapAction($soapAction, $bindingType = 'soap')
|
|
{
|
|
}
|
|
/**
|
|
* returns an array of information about a given type
|
|
* returns false if no type exists by the given name
|
|
* typeDef = array(
|
|
* 'elements' => array(), // refs to elements array
|
|
* 'restrictionBase' => '',
|
|
* 'phpType' => '',
|
|
* 'order' => '(sequence|all)',
|
|
* 'attrs' => array() // refs to attributes array
|
|
* )
|
|
*
|
|
* @param string $type the type
|
|
* @param string $ns namespace (not prefix) of the type
|
|
* @return false
|
|
* @access public
|
|
* @see nusoap_xmlschema
|
|
*/
|
|
public function getTypeDef($type, $ns)
|
|
{
|
|
}
|
|
/**
|
|
* prints html description of services
|
|
*
|
|
* @access private
|
|
*/
|
|
public function webDescription()
|
|
{
|
|
}
|
|
/**
|
|
* serialize the parsed wsdl
|
|
*
|
|
* @param mixed $debug whether to put debug=1 in endpoint URL
|
|
* @return string serialization of WSDL
|
|
* @access public
|
|
*/
|
|
public function serialize($debug = 0)
|
|
{
|
|
}
|
|
/**
|
|
* determine whether a set of parameters are unwrapped
|
|
* when they are expect to be wrapped, Microsoft-style.
|
|
*
|
|
* @param string $type the type (element name) of the wrapper
|
|
* @param array $parameters the parameter values for the SOAP call
|
|
* @return boolean whether they parameters are unwrapped (and should be wrapped)
|
|
* @access private
|
|
*/
|
|
public function parametersMatchWrapped($type, $parameters)
|
|
{
|
|
}
|
|
/**
|
|
* serialize PHP values according to a WSDL message definition
|
|
* contrary to the method name, this is not limited to RPC
|
|
*
|
|
* TODO
|
|
* - multi-ref serialization
|
|
* - validate PHP values against type definitions, return errors if invalid
|
|
*
|
|
* @param string $operation operation name
|
|
* @param string $direction (input|output)
|
|
* @param mixed $parameters parameter value(s)
|
|
* @param string $bindingType (soap|soap12)
|
|
* @return false|string parameters serialized as XML or false on error (e.g. operation not found)
|
|
* @access public
|
|
*/
|
|
public function serializeRPCParameters($operation, $direction, $parameters, $bindingType = 'soap')
|
|
{
|
|
}
|
|
/**
|
|
* serialize a PHP value according to a WSDL message definition
|
|
*
|
|
* TODO
|
|
* - multi-ref serialization
|
|
* - validate PHP values against type definitions, return errors if invalid
|
|
*
|
|
* @param string $operation operation name
|
|
* @param string $direction (input|output)
|
|
* @param mixed $parameters parameter value(s)
|
|
* @return false|string parameters serialized as XML or false on error (e.g. operation not found)
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function serializeParameters($operation, $direction, $parameters)
|
|
{
|
|
}
|
|
/**
|
|
* serializes a PHP value according a given type definition
|
|
*
|
|
* @param string $name name of value (part or element)
|
|
* @param string $type XML schema type of value (type or element)
|
|
* @param mixed $value a native PHP value (parameter value)
|
|
* @param string $use use for part (encoded|literal)
|
|
* @param string $encodingStyle SOAP encoding style for the value (if different than the enclosing style)
|
|
* @param boolean $unqualified a kludge for what should be XML namespace form handling
|
|
* @return string value serialized as an XML string
|
|
* @access private
|
|
*/
|
|
public function serializeType($name, $type, $value, $use = 'encoded', $encodingStyle = \false, $unqualified = \false)
|
|
{
|
|
}
|
|
/**
|
|
* serializes the attributes for a complexType
|
|
*
|
|
* @param array $typeDef our internal representation of an XML schema type (or element)
|
|
* @param mixed $value a native PHP value (parameter value)
|
|
* @param string $ns the namespace of the type
|
|
* @param string $uqType the local part of the type
|
|
* @return string value serialized as an XML string
|
|
* @access private
|
|
*/
|
|
public function serializeComplexTypeAttributes($typeDef, $value, $ns, $uqType)
|
|
{
|
|
}
|
|
/**
|
|
* serializes the elements for a complexType
|
|
*
|
|
* @param array $typeDef our internal representation of an XML schema type (or element)
|
|
* @param mixed $value a native PHP value (parameter value)
|
|
* @param string $ns the namespace of the type
|
|
* @param string $uqType the local part of the type
|
|
* @param string $use use for part (encoded|literal)
|
|
* @param string $encodingStyle SOAP encoding style for the value (if different than the enclosing style)
|
|
* @return string value serialized as an XML string
|
|
* @access private
|
|
*/
|
|
public function serializeComplexTypeElements($typeDef, $value, $ns, $uqType, $use = 'encoded', $encodingStyle = \false)
|
|
{
|
|
}
|
|
/**
|
|
* adds an XML Schema complex type to the WSDL types
|
|
*
|
|
* @param string $name
|
|
* @param string $typeClass (complexType|simpleType|attribute)
|
|
* @param string $phpType currently supported are array and struct (php assoc array)
|
|
* @param string $compositor (all|sequence|choice)
|
|
* @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
|
|
* @param array $elements e.g. array ( name => array(name=>'',type=>'') )
|
|
* @param array $attrs e.g. array(array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'xsd:string[]'))
|
|
* @param string $arrayType as namespace:name (xsd:string)
|
|
* @see nusoap_xmlschema
|
|
* @access public
|
|
*/
|
|
public function addComplexType($name, $typeClass = 'complexType', $phpType = 'array', $compositor = '', $restrictionBase = '', $elements = array(), $attrs = array(), $arrayType = '')
|
|
{
|
|
}
|
|
/**
|
|
* adds an XML Schema simple type to the WSDL types
|
|
*
|
|
* @param string $name
|
|
* @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array)
|
|
* @param string $typeClass (should always be simpleType)
|
|
* @param string $phpType (should always be scalar)
|
|
* @param array $enumeration array of values
|
|
* @see nusoap_xmlschema
|
|
* @access public
|
|
*/
|
|
public function addSimpleType($name, $restrictionBase = '', $typeClass = 'simpleType', $phpType = 'scalar', $enumeration = array())
|
|
{
|
|
}
|
|
/**
|
|
* adds an element to the WSDL types
|
|
*
|
|
* @param array $attrs attributes that must include name and type
|
|
* @see nusoap_xmlschema
|
|
* @access public
|
|
*/
|
|
public function addElement($attrs)
|
|
{
|
|
}
|
|
/**
|
|
* register an operation with the server
|
|
*
|
|
* @param string $name operation (method) name
|
|
* @param array $in assoc array of input values: key = param name, value = param type
|
|
* @param array $out assoc array of output values: key = param name, value = param type
|
|
* @param string $namespace optional The namespace for the operation
|
|
* @param string $soapaction optional The soapaction for the operation
|
|
* @param string $style (rpc|document) optional The style for the operation Note: when 'document' is specified, parameter and return wrappers are created for you automatically
|
|
* @param string $use (encoded|literal) optional The use for the parameters (cannot mix right now)
|
|
* @param string $documentation optional The description to include in the WSDL
|
|
* @param string $encodingStyle optional (usually 'http://schemas.xmlsoap.org/soap/encoding/' for encoded)
|
|
* @param string $customResponseTagName optional Name of the outgoing response
|
|
* @access public
|
|
*/
|
|
public function addOperation($name, $in = \false, $out = \false, $namespace = \false, $soapaction = \false, $style = 'rpc', $use = 'encoded', $documentation = '', $encodingStyle = '', $customResponseTagName = '')
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* nusoap_parser class parses SOAP XML messages into native PHP values
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_parser extends \nusoap_base
|
|
{
|
|
public $parser = \null;
|
|
public $methodNamespace = '';
|
|
public $xml = '';
|
|
public $xml_encoding = '';
|
|
public $method = '';
|
|
public $root_struct = '';
|
|
public $root_struct_name = '';
|
|
public $root_struct_namespace = '';
|
|
public $root_header = '';
|
|
public $document = '';
|
|
// incoming SOAP body (text)
|
|
// determines where in the message we are (envelope,header,body,method)
|
|
public $status = '';
|
|
public $position = 0;
|
|
public $depth = 0;
|
|
public $default_namespace = '';
|
|
public $namespaces = array();
|
|
public $message = array();
|
|
public $parent = '';
|
|
public $fault = \false;
|
|
public $fault_code = '';
|
|
public $fault_str = '';
|
|
public $fault_detail = '';
|
|
public $depth_array = array();
|
|
public $debug_flag = \true;
|
|
public $soapresponse = \null;
|
|
// parsed SOAP Body
|
|
public $soapheader = \null;
|
|
// parsed SOAP Header
|
|
public $responseHeaders = '';
|
|
// incoming SOAP headers (text)
|
|
public $body_position = 0;
|
|
// for multiref parsing:
|
|
// array of id => pos
|
|
public $ids = array();
|
|
// array of id => hrefs => pos
|
|
public $multirefs = array();
|
|
// toggle for auto-decoding element content
|
|
public $decode_utf8 = \true;
|
|
public $attachments = array();
|
|
/**
|
|
* constructor that actually does the parsing
|
|
*
|
|
* @param string $xml SOAP message
|
|
* @param string $encoding character encoding scheme of message
|
|
* @param string $method method for which XML is parsed (unused?)
|
|
* @param string $decode_utf8 whether to decode UTF-8 to ISO-8859-1
|
|
* @access public
|
|
*/
|
|
public function __construct($xml, $encoding = 'UTF-8', $method = '', $decode_utf8 = \true)
|
|
{
|
|
}
|
|
/**
|
|
* start-element handler
|
|
*
|
|
* @param resource $parser XML parser object
|
|
* @param string $name element name
|
|
* @param array $attrs associative array of attributes
|
|
* @access private
|
|
*/
|
|
public function start_element($parser, $name, $attrs)
|
|
{
|
|
}
|
|
/**
|
|
* end-element handler
|
|
*
|
|
* @param resource $parser XML parser object
|
|
* @param string $name element name
|
|
* @access private
|
|
*/
|
|
public function end_element($parser, $name)
|
|
{
|
|
}
|
|
/**
|
|
* element content handler
|
|
*
|
|
* @param resource $parser XML parser object
|
|
* @param string $data element content
|
|
* @access private
|
|
*/
|
|
public function character_data($parser, $data)
|
|
{
|
|
}
|
|
/**
|
|
* get the parsed message (SOAP Body)
|
|
*
|
|
* @return mixed
|
|
* @access public
|
|
* @deprecated use get_soapbody instead
|
|
*/
|
|
public function get_response()
|
|
{
|
|
}
|
|
/**
|
|
* get the parsed SOAP Body (null if there was none)
|
|
*
|
|
* @return mixed
|
|
* @access public
|
|
*/
|
|
public function get_soapbody()
|
|
{
|
|
}
|
|
/**
|
|
* get the parsed SOAP Header (null if there was none)
|
|
*
|
|
* @return mixed
|
|
* @access public
|
|
*/
|
|
public function get_soapheader()
|
|
{
|
|
}
|
|
/**
|
|
* get the unparsed SOAP Header
|
|
*
|
|
* @return string XML or empty if no Header
|
|
* @access public
|
|
*/
|
|
public function getHeaders()
|
|
{
|
|
}
|
|
/**
|
|
* decodes simple types into PHP variables
|
|
*
|
|
* @param string $value value to decode
|
|
* @param string $type XML type to decode
|
|
* @param string $typens XML type namespace to decode
|
|
* @return mixed PHP value
|
|
* @access private
|
|
*/
|
|
public function decodeSimple($value, $type, $typens)
|
|
{
|
|
}
|
|
/**
|
|
* builds response structures for compound values (arrays/structs)
|
|
* and scalars
|
|
*
|
|
* @param integer $pos position in node tree
|
|
* @return mixed PHP value
|
|
* @access private
|
|
*/
|
|
public function buildVal($pos)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* Backward compatibility
|
|
*/
|
|
class soap_parser extends \nusoap_parser
|
|
{
|
|
}
|
|
/**
|
|
*
|
|
* [nu]soapclient higher level class for easy usage.
|
|
*
|
|
* usage:
|
|
*
|
|
* // instantiate client with server info
|
|
* $soapclient = new nusoap_client( string path [ ,mixed wsdl] );
|
|
*
|
|
* // call method, get results
|
|
* echo $soapclient->call( string methodname [ ,array parameters] );
|
|
*
|
|
* // bye bye client
|
|
* unset($soapclient);
|
|
*
|
|
* @author Dietrich Ayala <dietrich@ganx4.com>
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @version $Id: nusoap.php,v 1.123 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_client extends \nusoap_base
|
|
{
|
|
public $attachments = '';
|
|
public $return = \null;
|
|
public $operation = '';
|
|
public $opData = array();
|
|
public $username = '';
|
|
// Username for HTTP authentication
|
|
public $password = '';
|
|
// Password for HTTP authentication
|
|
public $authtype = '';
|
|
// Type of HTTP authentication
|
|
public $certRequest = array();
|
|
// Certificate for HTTP SSL authentication
|
|
public $requestHeaders = \false;
|
|
// SOAP headers in request (text)
|
|
public $responseHeaders = '';
|
|
// SOAP headers from response (incomplete namespace resolution) (text)
|
|
public $responseHeader = \null;
|
|
// SOAP Header from response (parsed)
|
|
public $document = '';
|
|
// SOAP body response portion (incomplete namespace resolution) (text)
|
|
public $endpoint;
|
|
public $forceEndpoint = '';
|
|
// overrides WSDL endpoint
|
|
public $proxyhost = '';
|
|
public $proxyport = '';
|
|
public $proxyusername = '';
|
|
public $proxypassword = '';
|
|
public $portName = '';
|
|
// port name to use in WSDL
|
|
public $xml_encoding = '';
|
|
// character set encoding of incoming (response) messages
|
|
public $http_encoding = \false;
|
|
public $timeout = 0;
|
|
// HTTP connection timeout
|
|
public $response_timeout = 30;
|
|
// HTTP response timeout
|
|
public $endpointType = '';
|
|
// soap|wsdl, empty for WSDL initialization error
|
|
public $persistentConnection = \false;
|
|
public $defaultRpcParams = \false;
|
|
// This is no longer used
|
|
public $request = '';
|
|
// HTTP request
|
|
public $response = '';
|
|
// HTTP response
|
|
public $responseData = '';
|
|
// SOAP payload of response
|
|
public $cookies = array();
|
|
// Cookies from response or for request
|
|
public $decode_utf8 = \true;
|
|
// toggles whether the parser decodes element content w/ utf8_decode()
|
|
public $operations = array();
|
|
// WSDL operations, empty for WSDL initialization error
|
|
public $curl_options = array();
|
|
// User-specified cURL options
|
|
public $bindingType = '';
|
|
// WSDL operation binding type
|
|
public $use_curl = \false;
|
|
// whether to always try to use cURL
|
|
/*
|
|
* fault related variables
|
|
*/
|
|
/**
|
|
* @var bool
|
|
* @access public
|
|
*/
|
|
public $fault;
|
|
/**
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $faultcode;
|
|
/**
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $faultstring;
|
|
/**
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $faultdetail;
|
|
/** @var wsdl|null */
|
|
public $wsdl;
|
|
/** @var mixed */
|
|
public $wsdlFile;
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param mixed $endpoint SOAP server or WSDL URL (string), or wsdl instance (object)
|
|
* @param mixed $wsdl optional, set to 'wsdl' or true if using WSDL
|
|
* @param string $proxyhost optional
|
|
* @param string $proxyport optional
|
|
* @param string $proxyusername optional
|
|
* @param string $proxypassword optional
|
|
* @param integer $timeout set the connection timeout
|
|
* @param integer $response_timeout set the response timeout
|
|
* @param string $portName optional portName in WSDL document
|
|
* @access public
|
|
*/
|
|
public function __construct($endpoint, $wsdl = \false, $proxyhost = \false, $proxyport = \false, $proxyusername = \false, $proxypassword = \false, $timeout = 0, $response_timeout = 30, $portName = '')
|
|
{
|
|
}
|
|
/**
|
|
* calls method, returns PHP native type
|
|
*
|
|
* @param string $operation SOAP server URL or path
|
|
* @param mixed $params An array, associative or simple, of the parameters
|
|
* for the method call, or a string that is the XML
|
|
* for the call. For rpc style, this call will
|
|
* wrap the XML in a tag named after the method, as
|
|
* well as the SOAP Envelope and Body. For document
|
|
* style, this will only wrap with the Envelope and Body.
|
|
* IMPORTANT: when using an array with document style,
|
|
* in which case there
|
|
* is really one parameter, the root of the fragment
|
|
* used in the call, which encloses what programmers
|
|
* normally think of parameters. A parameter array
|
|
* *must* include the wrapper.
|
|
* @param string $namespace optional method namespace (WSDL can override)
|
|
* @param string $soapAction optional SOAPAction value (WSDL can override)
|
|
* @param mixed $headers optional string of XML with SOAP header content, or array of soapval objects for SOAP headers, or associative array
|
|
* @param boolean $rpcParams optional (no longer used)
|
|
* @param string $style optional (rpc|document) the style to use when serializing parameters (WSDL can override)
|
|
* @param string $use optional (encoded|literal|literal wrapped) the use when serializing parameters (WSDL can override)
|
|
* @return mixed response from SOAP call, normally an associative array mirroring the structure of the XML response, false for certain fatal errors
|
|
* @access public
|
|
*/
|
|
public function call($operation, $params = array(), $namespace = 'http://tempuri.org', $soapAction = '', $headers = \false, $rpcParams = \null, $style = 'rpc', $use = 'encoded')
|
|
{
|
|
}
|
|
/**
|
|
* check WSDL passed as an instance or pulled from an endpoint
|
|
*
|
|
* @access private
|
|
*/
|
|
public function checkWSDL()
|
|
{
|
|
}
|
|
/**
|
|
* instantiate wsdl object and parse wsdl file
|
|
*
|
|
* @access public
|
|
*/
|
|
public function loadWSDL()
|
|
{
|
|
}
|
|
/**
|
|
* get available data pertaining to an operation
|
|
*
|
|
* @param string $operation operation name
|
|
* @return array|false array of data pertaining to the operation, false on error or no data
|
|
* @access public
|
|
*/
|
|
public function getOperationData($operation)
|
|
{
|
|
}
|
|
/**
|
|
* send the SOAP message
|
|
*
|
|
* Note: if the operation has multiple return values
|
|
* the return value of this method will be an array
|
|
* of those values.
|
|
*
|
|
* @param string $msg a SOAPx4 soapmsg object
|
|
* @param string $soapaction SOAPAction value
|
|
* @param integer $timeout set connection timeout in seconds
|
|
* @param integer $response_timeout set response timeout in seconds
|
|
* @return mixed native PHP types.
|
|
* @access private
|
|
*/
|
|
public function send($msg, $soapaction = '', $timeout = 0, $response_timeout = 30)
|
|
{
|
|
}
|
|
/**
|
|
* processes SOAP message returned from server
|
|
*
|
|
* @param array $headers The HTTP headers
|
|
* @param string $data unprocessed response data from server
|
|
* @return mixed value of the message, decoded into a PHP type
|
|
* @access private
|
|
*/
|
|
public function parseResponse($headers, $data)
|
|
{
|
|
}
|
|
/**
|
|
* sets user-specified cURL options
|
|
*
|
|
* @param mixed $option The cURL option (always integer?)
|
|
* @param mixed $value The cURL option value
|
|
* @access public
|
|
*/
|
|
public function setCurlOption($option, $value)
|
|
{
|
|
}
|
|
/**
|
|
* sets the SOAP endpoint, which can override WSDL
|
|
*
|
|
* @param string $endpoint The endpoint URL to use, or empty string or false to prevent override
|
|
* @access public
|
|
*/
|
|
public function setEndpoint($endpoint)
|
|
{
|
|
}
|
|
/**
|
|
* set the SOAP headers
|
|
*
|
|
* @param mixed $headers String of XML with SOAP header content, or array of soapval objects for SOAP headers
|
|
* @access public
|
|
*/
|
|
public function setHeaders($headers)
|
|
{
|
|
}
|
|
/**
|
|
* get the SOAP response headers (namespace resolution incomplete)
|
|
*
|
|
* @return string
|
|
* @access public
|
|
*/
|
|
public function getHeaders()
|
|
{
|
|
}
|
|
/**
|
|
* get the SOAP response Header (parsed)
|
|
*
|
|
* @return mixed
|
|
* @access public
|
|
*/
|
|
public function getHeader()
|
|
{
|
|
}
|
|
/**
|
|
* set proxy info here
|
|
*
|
|
* @param string $proxyhost
|
|
* @param string $proxyport
|
|
* @param string $proxyusername
|
|
* @param string $proxypassword
|
|
* @access public
|
|
*/
|
|
public function setHTTPProxy($proxyhost, $proxyport, $proxyusername = '', $proxypassword = '')
|
|
{
|
|
}
|
|
/**
|
|
* if authenticating, set user credentials here
|
|
*
|
|
* @param string $username
|
|
* @param string $password
|
|
* @param string $authtype (basic|digest|certificate|ntlm)
|
|
* @param array $certRequest (keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, verifypeer (optional), verifyhost (optional): see corresponding options in cURL docs)
|
|
* @access public
|
|
*/
|
|
public function setCredentials($username, $password, $authtype = 'basic', $certRequest = array())
|
|
{
|
|
}
|
|
/**
|
|
* use HTTP encoding
|
|
*
|
|
* @param string $enc HTTP encoding
|
|
* @access public
|
|
*/
|
|
public function setHTTPEncoding($enc = 'gzip, deflate')
|
|
{
|
|
}
|
|
/**
|
|
* Set whether to try to use cURL connections if possible
|
|
*
|
|
* @param boolean $use Whether to try to use cURL
|
|
* @access public
|
|
*/
|
|
public function setUseCURL($use)
|
|
{
|
|
}
|
|
/**
|
|
* use HTTP persistent connections if possible
|
|
*
|
|
* @access public
|
|
*/
|
|
public function useHTTPPersistentConnection()
|
|
{
|
|
}
|
|
/**
|
|
* gets the default RPC parameter setting.
|
|
* If true, default is that call params are like RPC even for document style.
|
|
* Each call() can override this value.
|
|
*
|
|
* This is no longer used.
|
|
*
|
|
* @return boolean
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function getDefaultRpcParams()
|
|
{
|
|
}
|
|
/**
|
|
* sets the default RPC parameter setting.
|
|
* If true, default is that call params are like RPC even for document style
|
|
* Each call() can override this value.
|
|
*
|
|
* This is no longer used.
|
|
*
|
|
* @param boolean $rpcParams
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
public function setDefaultRpcParams($rpcParams)
|
|
{
|
|
}
|
|
/**
|
|
* dynamically creates an instance of a proxy class,
|
|
* allowing user to directly call methods from wsdl
|
|
*
|
|
* @return object soap_proxy object
|
|
* @access public
|
|
*/
|
|
public function getProxy()
|
|
{
|
|
}
|
|
/**
|
|
* dynamically creates proxy class code
|
|
*
|
|
* @return string PHP/NuSOAP code for the proxy class
|
|
* @access private
|
|
*/
|
|
public function _getProxyClassCode($r)
|
|
{
|
|
}
|
|
/**
|
|
* dynamically creates proxy class code
|
|
*
|
|
* @return string PHP/NuSOAP code for the proxy class
|
|
* @access public
|
|
*/
|
|
public function getProxyClassCode()
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP body for the current request.
|
|
*
|
|
* @param string $soapmsg The SOAP payload
|
|
* @return string The HTTP body, which includes the SOAP payload
|
|
* @access private
|
|
*/
|
|
public function getHTTPBody($soapmsg)
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type for the current request.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type for the current request.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentType()
|
|
{
|
|
}
|
|
/**
|
|
* allows you to change the HTTP ContentType of the request.
|
|
*
|
|
* @param string $contentTypeNew
|
|
* @return void
|
|
*/
|
|
public function setHTTPContentType($contentTypeNew = "text/xml")
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type charset for the current request.
|
|
* returns false for non-text content types.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type charset for the current request.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentTypeCharset()
|
|
{
|
|
}
|
|
/*
|
|
* whether or not parser should decode utf8 element content
|
|
*
|
|
* @return always returns true
|
|
* @access public
|
|
*/
|
|
public function decodeUTF8($bool)
|
|
{
|
|
}
|
|
/**
|
|
* adds a new Cookie into $this->cookies array
|
|
*
|
|
* @param string $name Cookie Name
|
|
* @param string $value Cookie Value
|
|
* @return boolean if cookie-set was successful returns true, else false
|
|
* @access public
|
|
*/
|
|
public function setCookie($name, $value)
|
|
{
|
|
}
|
|
/**
|
|
* gets all Cookies
|
|
*
|
|
* @return array with all internal cookies
|
|
* @access public
|
|
*/
|
|
public function getCookies()
|
|
{
|
|
}
|
|
/**
|
|
* checks all Cookies and delete those which are expired
|
|
*
|
|
* @return boolean always return true
|
|
* @access private
|
|
*/
|
|
public function checkCookies()
|
|
{
|
|
}
|
|
/**
|
|
* updates the current cookies with a new set
|
|
*
|
|
* @param array $cookies new cookies with which to update current ones
|
|
* @return boolean always return true
|
|
* @access private
|
|
*/
|
|
public function UpdateCookies($cookies)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* caches instances of the wsdl class
|
|
*
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @author Ingo Fischer <ingo@apollon.de>
|
|
* @version $Id: class.wsdlcache.php,v 1.7 2007/04/17 16:34:03 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_wsdlcache
|
|
{
|
|
/**
|
|
* @var resource
|
|
* @access private
|
|
*/
|
|
public $fplock;
|
|
/**
|
|
* @var integer
|
|
* @access private
|
|
*/
|
|
public $cache_lifetime;
|
|
/**
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $cache_dir;
|
|
/**
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
public $debug_str = '';
|
|
/**
|
|
* constructor
|
|
*
|
|
* @param string $cache_dir directory for cache-files
|
|
* @param integer $cache_lifetime lifetime for caching-files in seconds or 0 for unlimited
|
|
* @access public
|
|
*/
|
|
public function __construct($cache_dir = '.', $cache_lifetime = 0)
|
|
{
|
|
}
|
|
/**
|
|
* creates the filename used to cache a wsdl instance
|
|
*
|
|
* @param string $wsdl The URL of the wsdl instance
|
|
* @return string The filename used to cache the instance
|
|
* @access private
|
|
*/
|
|
public function createFilename($wsdl)
|
|
{
|
|
}
|
|
/**
|
|
* adds debug data to the class level debug string
|
|
*
|
|
* @param string $string debug data
|
|
* @access private
|
|
*/
|
|
public function debug($string)
|
|
{
|
|
}
|
|
/**
|
|
* gets a wsdl instance from the cache
|
|
*
|
|
* @param string $wsdl The URL of the wsdl instance
|
|
* @return object wsdl The cached wsdl instance, null if the instance is not in the cache
|
|
* @access public
|
|
*/
|
|
public function get($wsdl)
|
|
{
|
|
}
|
|
/**
|
|
* obtains the local mutex
|
|
*
|
|
* @param string $filename The Filename of the Cache to lock
|
|
* @param string $mode The open-mode ("r" or "w") or the file - affects lock-mode
|
|
* @return boolean Lock successfully obtained ?!
|
|
* @access private
|
|
*/
|
|
public function obtainMutex($filename, $mode)
|
|
{
|
|
}
|
|
/**
|
|
* adds a wsdl instance to the cache
|
|
*
|
|
* @param wsdl $wsdl_instance The wsdl instance to add
|
|
* @return boolean WSDL successfully cached
|
|
* @access public
|
|
*/
|
|
public function put($wsdl_instance)
|
|
{
|
|
}
|
|
/**
|
|
* releases the local mutex
|
|
*
|
|
* @param string $filename The Filename of the Cache to lock
|
|
* @return boolean Lock successfully released
|
|
* @access private
|
|
*/
|
|
public function releaseMutex($filename)
|
|
{
|
|
}
|
|
/**
|
|
* removes a wsdl instance from the cache
|
|
*
|
|
* @param string $wsdl The URL of the wsdl instance
|
|
* @return boolean Whether there was an instance to remove
|
|
* @access public
|
|
*/
|
|
public function remove($wsdl)
|
|
{
|
|
}
|
|
}
|
|
/**
|
|
* For backward compatibility
|
|
*/
|
|
class wsdlcache extends \nusoap_wsdlcache
|
|
{
|
|
}
|
|
/**
|
|
* nusoap_client_mime client supporting MIME attachments defined at
|
|
* http://www.w3.org/TR/SOAP-attachments. It depends on the PEAR Mail_MIME library.
|
|
*
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @author Thanks to Guillaume and Henning Reich for posting great attachment code to the mail list
|
|
* @version $Id: nusoapmime.php,v 1.13 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_client_mime extends \nusoap_client
|
|
{
|
|
/**
|
|
* @var array Each array element in the return is an associative array with keys
|
|
* data, filename, contenttype, cid
|
|
* @access private
|
|
*/
|
|
public $requestAttachments = array();
|
|
/**
|
|
* @var array Each array element in the return is an associative array with keys
|
|
* data, filename, contenttype, cid
|
|
* @access private
|
|
*/
|
|
public $responseAttachments;
|
|
/**
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $mimeContentType;
|
|
/**
|
|
* adds a MIME attachment to the current request.
|
|
*
|
|
* If the $data parameter contains an empty string, this method will read
|
|
* the contents of the file named by the $filename parameter.
|
|
*
|
|
* If the $cid parameter is false, this method will generate the cid.
|
|
*
|
|
* @param string $data The data of the attachment
|
|
* @param string $filename The filename of the attachment (default is empty string)
|
|
* @param string $contenttype The MIME Content-Type of the attachment (default is application/octet-stream)
|
|
* @param string $cid The content-id (cid) of the attachment (default is false)
|
|
* @return string The content-id (cid) of the attachment
|
|
* @access public
|
|
*/
|
|
public function addAttachment($data, $filename = '', $contenttype = 'application/octet-stream', $cid = \false)
|
|
{
|
|
}
|
|
/**
|
|
* clears the MIME attachments for the current request.
|
|
*
|
|
* @access public
|
|
*/
|
|
public function clearAttachments()
|
|
{
|
|
}
|
|
/**
|
|
* gets the MIME attachments from the current response.
|
|
*
|
|
* Each array element in the return is an associative array with keys
|
|
* data, filename, contenttype, cid. These keys correspond to the parameters
|
|
* for addAttachment.
|
|
*
|
|
* @return array The attachments.
|
|
* @access public
|
|
*/
|
|
public function getAttachments()
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP body for the current request.
|
|
*
|
|
* @param string $soapmsg The SOAP payload
|
|
* @return string The HTTP body, which includes the SOAP payload
|
|
* @access private
|
|
*/
|
|
public function getHTTPBody($soapmsg)
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type for the current request.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type for the current request.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentType()
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type charset for the current request.
|
|
* returns false for non-text content types.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type charset for the current request.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentTypeCharset()
|
|
{
|
|
}
|
|
/**
|
|
* processes SOAP message returned from server
|
|
*
|
|
* @param array $headers The HTTP headers
|
|
* @param string $data unprocessed response data from server
|
|
* @return mixed value of the message, decoded into a PHP type
|
|
* @access private
|
|
*/
|
|
public function parseResponse($headers, $data)
|
|
{
|
|
}
|
|
}
|
|
class soapclientmime extends \nusoap_client_mime
|
|
{
|
|
}
|
|
/**
|
|
* nusoap_server_mime server supporting MIME attachments defined at
|
|
* http://www.w3.org/TR/SOAP-attachments. It depends on the PEAR Mail_MIME library.
|
|
*
|
|
* @author Scott Nichol <snichol@users.sourceforge.net>
|
|
* @author Thanks to Guillaume and Henning Reich for posting great attachment code to the mail list
|
|
* @version $Id: nusoapmime.php,v 1.13 2010/04/26 20:15:08 snichol Exp $
|
|
* @access public
|
|
*/
|
|
class nusoap_server_mime extends \nusoap_server
|
|
{
|
|
/**
|
|
* @var array Each array element in the return is an associative array with keys
|
|
* data, filename, contenttype, cid
|
|
* @access private
|
|
*/
|
|
public $requestAttachments = array();
|
|
/**
|
|
* @var array Each array element in the return is an associative array with keys
|
|
* data, filename, contenttype, cid
|
|
* @access private
|
|
*/
|
|
public $responseAttachments;
|
|
/**
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
public $mimeContentType;
|
|
/**
|
|
* adds a MIME attachment to the current response.
|
|
*
|
|
* If the $data parameter contains an empty string, this method will read
|
|
* the contents of the file named by the $filename parameter.
|
|
*
|
|
* If the $cid parameter is false, this method will generate the cid.
|
|
*
|
|
* @param string $data The data of the attachment
|
|
* @param string $filename The filename of the attachment (default is empty string)
|
|
* @param string $contenttype The MIME Content-Type of the attachment (default is application/octet-stream)
|
|
* @param string $cid The content-id (cid) of the attachment (default is false)
|
|
* @return string The content-id (cid) of the attachment
|
|
* @access public
|
|
*/
|
|
public function addAttachment($data, $filename = '', $contenttype = 'application/octet-stream', $cid = \false)
|
|
{
|
|
}
|
|
/**
|
|
* clears the MIME attachments for the current response.
|
|
*
|
|
* @access public
|
|
*/
|
|
public function clearAttachments()
|
|
{
|
|
}
|
|
/**
|
|
* gets the MIME attachments from the current request.
|
|
*
|
|
* Each array element in the return is an associative array with keys
|
|
* data, filename, contenttype, cid. These keys correspond to the parameters
|
|
* for addAttachment.
|
|
*
|
|
* @return array The attachments.
|
|
* @access public
|
|
*/
|
|
public function getAttachments()
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP body for the current response.
|
|
*
|
|
* @param string $soapmsg The SOAP payload
|
|
* @return string The HTTP body, which includes the SOAP payload
|
|
* @access private
|
|
*/
|
|
public function getHTTPBody($soapmsg)
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type for the current response.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type for the current response.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentType()
|
|
{
|
|
}
|
|
/**
|
|
* gets the HTTP content type charset for the current response.
|
|
* returns false for non-text content types.
|
|
*
|
|
* Note: getHTTPBody must be called before this.
|
|
*
|
|
* @return string the HTTP content type charset for the current response.
|
|
* @access private
|
|
*/
|
|
public function getHTTPContentTypeCharset()
|
|
{
|
|
}
|
|
/**
|
|
* processes SOAP message received from client
|
|
*
|
|
* @param array $headers The HTTP headers
|
|
* @param string $data unprocessed request data from client
|
|
* @return mixed value of the message, decoded into a PHP type
|
|
* @access private
|
|
*/
|
|
public function parseRequest($headers, $data)
|
|
{
|
|
}
|
|
}
|
|
/*
|
|
* For backwards compatiblity
|
|
*/
|
|
class nusoapservermime extends \nusoap_server_mime
|
|
{
|
|
}
|
|
// XML Schema Datatype Helper Functions
|
|
//xsd:dateTime helpers
|
|
/**
|
|
* convert unix timestamp to ISO 8601 compliant date string
|
|
*
|
|
* @param int $timestamp Unix time stamp
|
|
* @param boolean $utc Whether the time stamp is UTC or local
|
|
* @return false|string ISO 8601 date string or false
|
|
* @access public
|
|
*/
|
|
function timestamp_to_iso8601($timestamp, $utc = \true)
|
|
{
|
|
}
|
|
/**
|
|
* convert ISO 8601 compliant date string to unix timestamp
|
|
*
|
|
* @param string $datestr ISO 8601 compliant date string
|
|
* @return false|int Unix timestamp (int) or false
|
|
* @access public
|
|
*/
|
|
function iso8601_to_timestamp($datestr)
|
|
{
|
|
}
|
|
/**
|
|
* sleeps some number of microseconds
|
|
*
|
|
* @param string $usec the number of microseconds to sleep
|
|
* @access public
|
|
* @deprecated
|
|
*/
|
|
function usleepWindows($usec)
|
|
{
|
|
}
|