nusoap/lib/nusoapmime.php

   1 <?php
   2 /*
   3 $Id: nusoapmime.php,v 1.13 2010/04/26 20:15:08 snichol Exp $
   4
   5 NuSOAP - Web Services Toolkit for PHP
   6
   7 Copyright (c) 2002 NuSphere Corporation
   8
   9 This library is free software; you can redistribute it and/or
  10 modify it under the terms of the GNU Lesser General Public
  11 License as published by the Free Software Foundation; either
  12 version 2.1 of the License, or (at your option) any later version.
  13
  14 This library is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 Lesser General Public License for more details.
  18
  19 You should have received a copy of the GNU Lesser General Public
  20 License along with this library; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22
  23 The NuSOAP project home is:
  24 http://sourceforge.net/projects/nusoap/
  25
  26 The primary support for NuSOAP is the mailing list:
  27 nusoap-general@lists.sourceforge.net
  28
  29 If you have any questions or comments, please email:
  30
  31 Dietrich Ayala
  32 dietrich@ganx4.com
  33 http://dietrich.ganx4.com/nusoap
  34
  35 NuSphere Corporation
  36 http://www.nusphere.com
  37
  38 */
  39
  40 /*require_once('nusoap.php');*/
  41 /* PEAR Mail_MIME library */
  42 require_once('Mail/mimeDecode.php');
  43 require_once('Mail/mimePart.php');
  44
  45 /**
  46 * nusoap_client_mime client supporting MIME attachments defined at
  47 * http://www.w3.org/TR/SOAP-attachments.  It depends on the PEAR Mail_MIME library.
  48 *
  49 * @author   Scott Nichol <snichol@users.sourceforge.net>
  50 * @author       Thanks to Guillaume and Henning Reich for posting great attachment code to the mail list
  51 * @version  $Id: nusoapmime.php,v 1.13 2010/04/26 20:15:08 snichol Exp $
  52 * @access   public
  53 */
  54 class nusoap_client_mime extends nusoap_client {
  55         /**
  56          * @var array Each array element in the return is an associative array with keys
  57          * data, filename, contenttype, cid
  58          * @access private
  59          */
  60         var $requestAttachments = array();
  61         /**
  62          * @var array Each array element in the return is an associative array with keys
  63          * data, filename, contenttype, cid
  64          * @access private
  65          */
  66         var $responseAttachments;
  67         /**
  68          * @var string
  69          * @access private
  70          */
  71         var $mimeContentType;
  72
  73         /**
  74         * adds a MIME attachment to the current request.
  75         *
  76         * If the $data parameter contains an empty string, this method will read
  77         * the contents of the file named by the $filename parameter.
  78         *
  79         * If the $cid parameter is false, this method will generate the cid.
  80         *
  81         * @param string $data The data of the attachment
  82         * @param string $filename The filename of the attachment (default is empty string)
  83         * @param string $contenttype The MIME Content-Type of the attachment (default is application/octet-stream)
  84         * @param string $cid The content-id (cid) of the attachment (default is false)
  85         * @return string The content-id (cid) of the attachment
  86         * @access public
  87         */
  88         function addAttachment($data, $filename = '', $contenttype = 'application/octet-stream', $cid = false) {
  89                 if (! $cid) {
  90                         $cid = md5(uniqid(time()));
  91                 }
  92
  93                 $info['data'] = $data;
  94                 $info['filename'] = $filename;
  95                 $info['contenttype'] = $contenttype;
  96                 $info['cid'] = $cid;
  97
  98                 $this->requestAttachments[] = $info;
  99
 100                 return $cid;
 101         }
 102
 103         /**
 104         * clears the MIME attachments for the current request.
 105         *
 106         * @access public
 107         */
 108         function clearAttachments() {
 109                 $this->requestAttachments = array();
 110         }
 111
 112         /**
 113         * gets the MIME attachments from the current response.
 114         *
 115         * Each array element in the return is an associative array with keys
 116         * data, filename, contenttype, cid.  These keys correspond to the parameters
 117         * for addAttachment.
 118         *
 119         * @return array The attachments.
 120         * @access public
 121         */
 122         function getAttachments() {
 123                 return $this->responseAttachments;
 124         }
 125
 126         /**
 127         * gets the HTTP body for the current request.
 128         *
 129         * @param string $soapmsg The SOAP payload
 130         * @return string The HTTP body, which includes the SOAP payload
 131         * @access private
 132         */
 133         function getHTTPBody($soapmsg) {
 134                 if (count($this->requestAttachments) > 0) {
 135                         $params['content_type'] = 'multipart/related; type="text/xml"';
 136                         $mimeMessage = new Mail_mimePart('', $params);
 137                         unset($params);
 138
 139                         $params['content_type'] = 'text/xml';
 140                         $params['encoding']     = '8bit';
 141                         $params['charset']      = $this->soap_defencoding;
 142                         $mimeMessage->addSubpart($soapmsg, $params);
 143
 144                         foreach ($this->requestAttachments as $att) {
 145                                 unset($params);
 146
 147                                 $params['content_type'] = $att['contenttype'];
 148                                 $params['encoding']     = 'base64';
 149                                 $params['disposition']  = 'attachment';
 150                                 $params['dfilename']    = $att['filename'];
 151                                 $params['cid']          = $att['cid'];
 152
 153                                 if ($att['data'] == '' && $att['filename'] <> '') {
 154                                         if ($fd = fopen($att['filename'], 'rb')) {
 155                                                 $data = fread($fd, filesize($att['filename']));
 156                                                 fclose($fd);
 157                                         } else {
 158                                                 $data = '';
 159                                         }
 160                                         $mimeMessage->addSubpart($data, $params);
 161                                 } else {
 162                                         $mimeMessage->addSubpart($att['data'], $params);
 163                                 }
 164                         }
 165
 166                         $output = $mimeMessage->encode();
 167                         $mimeHeaders = $output['headers'];
 168
 169                         foreach ($mimeHeaders as $k => $v) {
 170                                 $this->debug("MIME header $k: $v");
 171                                 if (strtolower($k) == 'content-type') {
 172                                         // PHP header() seems to strip leading whitespace starting
 173                                         // the second line, so force everything to one line
 174                                         $this->mimeContentType = str_replace("\r\n", " ", $v);
 175                                 }
 176                         }
 177
 178                         return $output['body'];
 179                 }
 180
 181                 return parent::getHTTPBody($soapmsg);
 182         }
 183
 184         /**
 185         * gets the HTTP content type for the current request.
 186         *
 187         * Note: getHTTPBody must be called before this.
 188         *
 189         * @return string the HTTP content type for the current request.
 190         * @access private
 191         */
 192         function getHTTPContentType() {
 193                 if (count($this->requestAttachments) > 0) {
 194                         return $this->mimeContentType;
 195                 }
 196                 return parent::getHTTPContentType();
 197         }
 198
 199         /**
 200         * gets the HTTP content type charset for the current request.
 201         * returns false for non-text content types.
 202         *
 203         * Note: getHTTPBody must be called before this.
 204         *
 205         * @return string the HTTP content type charset for the current request.
 206         * @access private
 207         */
 208         function getHTTPContentTypeCharset() {
 209                 if (count($this->requestAttachments) > 0) {
 210                         return false;
 211                 }
 212                 return parent::getHTTPContentTypeCharset();
 213         }
 214
 215         /**
 216         * processes SOAP message returned from server
 217         *
 218         * @param        array   $headers        The HTTP headers
 219         * @param        string  $data           unprocessed response data from server
 220         * @return       mixed   value of the message, decoded into a PHP type
 221         * @access   private
 222         */
 223     function parseResponse($headers, $data) {
 224                 $this->debug('Entering parseResponse() for payload of length ' . strlen($data) . ' and type of ' . $headers['content-type']);
 225                 $this->responseAttachments = array();
 226                 if (strstr($headers['content-type'], 'multipart/related')) {
 227                         $this->debug('Decode multipart/related');
 228                         $input = '';
 229                         foreach ($headers as $k => $v) {
 230                                 $input .= "$k: $v\r\n";
 231                         }
 232                         $params['input'] = $input . "\r\n" . $data;
 233                         $params['include_bodies'] = true;
 234                         $params['decode_bodies'] = true;
 235                         $params['decode_headers'] = true;
 236
 237                         $structure = Mail_mimeDecode::decode($params);
 238
 239                         foreach ($structure->parts as $part) {
 240                                 if (!isset($part->disposition) && (strstr($part->headers['content-type'], 'text/xml'))) {
 241                                         $this->debug('Have root part of type ' . $part->headers['content-type']);
 242                                         $root = $part->body;
 243                                         $return = parent::parseResponse($part->headers, $part->body);
 244                                 } else {
 245                                         $this->debug('Have an attachment of type ' . $part->headers['content-type']);
 246                                         $info['data'] = $part->body;
 247                                         $info['filename'] = isset($part->d_parameters['filename']) ? $part->d_parameters['filename'] : '';
 248                                         $info['contenttype'] = $part->headers['content-type'];
 249                                         $info['cid'] = $part->headers['content-id'];
 250                                         $this->responseAttachments[] = $info;
 251                                 }
 252                         }
 253
 254                         if (isset($return)) {
 255                                 $this->responseData = $root;
 256                                 return $return;
 257                         }
 258
 259                         $this->setError('No root part found in multipart/related content');
 260                         return '';
 261                 }
 262                 $this->debug('Not multipart/related');
 263                 return parent::parseResponse($headers, $data);
 264         }
 265 }
 266
 267 /*
 268  *      For backwards compatiblity, define soapclientmime unless the PHP SOAP extension is loaded.
 269  */
 270 if (!extension_loaded('soap')) {
 271         class soapclientmime extends nusoap_client_mime {
 272         }
 273 }
 274
 275 /**
 276 * nusoap_server_mime server supporting MIME attachments defined at
 277 * http://www.w3.org/TR/SOAP-attachments.  It depends on the PEAR Mail_MIME library.
 278 *
 279 * @author   Scott Nichol <snichol@users.sourceforge.net>
 280 * @author       Thanks to Guillaume and Henning Reich for posting great attachment code to the mail list
 281 * @version  $Id: nusoapmime.php,v 1.13 2010/04/26 20:15:08 snichol Exp $
 282 * @access   public
 283 */
 284 class nusoap_server_mime extends nusoap_server {
 285         /**
 286          * @var array Each array element in the return is an associative array with keys
 287          * data, filename, contenttype, cid
 288          * @access private
 289          */
 290         var $requestAttachments = array();
 291         /**
 292          * @var array Each array element in the return is an associative array with keys
 293          * data, filename, contenttype, cid
 294          * @access private
 295          */
 296         var $responseAttachments;
 297         /**
 298          * @var string
 299          * @access private
 300          */
 301         var $mimeContentType;
 302
 303         /**
 304         * adds a MIME attachment to the current response.
 305         *
 306         * If the $data parameter contains an empty string, this method will read
 307         * the contents of the file named by the $filename parameter.
 308         *
 309         * If the $cid parameter is false, this method will generate the cid.
 310         *
 311         * @param string $data The data of the attachment
 312         * @param string $filename The filename of the attachment (default is empty string)
 313         * @param string $contenttype The MIME Content-Type of the attachment (default is application/octet-stream)
 314         * @param string $cid The content-id (cid) of the attachment (default is false)
 315         * @return string The content-id (cid) of the attachment
 316         * @access public
 317         */
 318         function addAttachment($data, $filename = '', $contenttype = 'application/octet-stream', $cid = false) {
 319                 if (! $cid) {
 320                         $cid = md5(uniqid(time()));
 321                 }
 322
 323                 $info['data'] = $data;
 324                 $info['filename'] = $filename;
 325                 $info['contenttype'] = $contenttype;
 326                 $info['cid'] = $cid;
 327
 328                 $this->responseAttachments[] = $info;
 329
 330                 return $cid;
 331         }
 332
 333         /**
 334         * clears the MIME attachments for the current response.
 335         *
 336         * @access public
 337         */
 338         function clearAttachments() {
 339                 $this->responseAttachments = array();
 340         }
 341
 342         /**
 343         * gets the MIME attachments from the current request.
 344         *
 345         * Each array element in the return is an associative array with keys
 346         * data, filename, contenttype, cid.  These keys correspond to the parameters
 347         * for addAttachment.
 348         *
 349         * @return array The attachments.
 350         * @access public
 351         */
 352         function getAttachments() {
 353                 return $this->requestAttachments;
 354         }
 355
 356         /**
 357         * gets the HTTP body for the current response.
 358         *
 359         * @param string $soapmsg The SOAP payload
 360         * @return string The HTTP body, which includes the SOAP payload
 361         * @access private
 362         */
 363         function getHTTPBody($soapmsg) {
 364                 if (count($this->responseAttachments) > 0) {
 365                         $params['content_type'] = 'multipart/related; type="text/xml"';
 366                         $mimeMessage = new Mail_mimePart('', $params);
 367                         unset($params);
 368
 369                         $params['content_type'] = 'text/xml';
 370                         $params['encoding']     = '8bit';
 371                         $params['charset']      = $this->soap_defencoding;
 372                         $mimeMessage->addSubpart($soapmsg, $params);
 373
 374                         foreach ($this->responseAttachments as $att) {
 375                                 unset($params);
 376
 377                                 $params['content_type'] = $att['contenttype'];
 378                                 $params['encoding']     = 'base64';
 379                                 $params['disposition']  = 'attachment';
 380                                 $params['dfilename']    = $att['filename'];
 381                                 $params['cid']          = $att['cid'];
 382
 383                                 if ($att['data'] == '' && $att['filename'] <> '') {
 384                                         if ($fd = fopen($att['filename'], 'rb')) {
 385                                                 $data = fread($fd, filesize($att['filename']));
 386                                                 fclose($fd);
 387                                         } else {
 388                                                 $data = '';
 389                                         }
 390                                         $mimeMessage->addSubpart($data, $params);
 391                                 } else {
 392                                         $mimeMessage->addSubpart($att['data'], $params);
 393                                 }
 394                         }
 395
 396                         $output = $mimeMessage->encode();
 397                         $mimeHeaders = $output['headers'];
 398
 399                         foreach ($mimeHeaders as $k => $v) {
 400                                 $this->debug("MIME header $k: $v");
 401                                 if (strtolower($k) == 'content-type') {
 402                                         // PHP header() seems to strip leading whitespace starting
 403                                         // the second line, so force everything to one line
 404                                         $this->mimeContentType = str_replace("\r\n", " ", $v);
 405                                 }
 406                         }
 407
 408                         return $output['body'];
 409                 }
 410
 411                 return parent::getHTTPBody($soapmsg);
 412         }
 413
 414         /**
 415         * gets the HTTP content type for the current response.
 416         *
 417         * Note: getHTTPBody must be called before this.
 418         *
 419         * @return string the HTTP content type for the current response.
 420         * @access private
 421         */
 422         function getHTTPContentType() {
 423                 if (count($this->responseAttachments) > 0) {
 424                         return $this->mimeContentType;
 425                 }
 426                 return parent::getHTTPContentType();
 427         }
 428
 429         /**
 430         * gets the HTTP content type charset for the current response.
 431         * returns false for non-text content types.
 432         *
 433         * Note: getHTTPBody must be called before this.
 434         *
 435         * @return string the HTTP content type charset for the current response.
 436         * @access private
 437         */
 438         function getHTTPContentTypeCharset() {
 439                 if (count($this->responseAttachments) > 0) {
 440                         return false;
 441                 }
 442                 return parent::getHTTPContentTypeCharset();
 443         }
 444
 445         /**
 446         * processes SOAP message received from client
 447         *
 448         * @param        array   $headers        The HTTP headers
 449         * @param        string  $data           unprocessed request data from client
 450         * @return       mixed   value of the message, decoded into a PHP type
 451         * @access   private
 452         */
 453     function parseRequest($headers, $data) {
 454                 $this->debug('Entering parseRequest() for payload of length ' . strlen($data) . ' and type of ' . $headers['content-type']);
 455                 $this->requestAttachments = array();
 456                 if (strstr($headers['content-type'], 'multipart/related')) {
 457                         $this->debug('Decode multipart/related');
 458                         $input = '';
 459                         foreach ($headers as $k => $v) {
 460                                 $input .= "$k: $v\r\n";
 461                         }
 462                         $params['input'] = $input . "\r\n" . $data;
 463                         $params['include_bodies'] = true;
 464                         $params['decode_bodies'] = true;
 465                         $params['decode_headers'] = true;
 466
 467                         $structure = Mail_mimeDecode::decode($params);
 468
 469                         foreach ($structure->parts as $part) {
 470                                 if (!isset($part->disposition) && (strstr($part->headers['content-type'], 'text/xml'))) {
 471                                         $this->debug('Have root part of type ' . $part->headers['content-type']);
 472                                         $return = parent::parseRequest($part->headers, $part->body);
 473                                 } else {
 474                                         $this->debug('Have an attachment of type ' . $part->headers['content-type']);
 475                                         $info['data'] = $part->body;
 476                                         $info['filename'] = isset($part->d_parameters['filename']) ? $part->d_parameters['filename'] : '';
 477                                         $info['contenttype'] = $part->headers['content-type'];
 478                                         $info['cid'] = $part->headers['content-id'];
 479                                         $this->requestAttachments[] = $info;
 480                                 }
 481                         }
 482
 483                         if (isset($return)) {
 484                                 return $return;
 485                         }
 486
 487                         $this->setError('No root part found in multipart/related content');
 488                         return;
 489                 }
 490                 $this->debug('Not multipart/related');
 491                 return parent::parseRequest($headers, $data);
 492         }
 493 }
 494
 495 /*
 496  *      For backwards compatiblity
 497  */
 498 class nusoapservermime extends nusoap_server_mime {
 499 }
 500
 501 ?>