BeSimpleSoap/src/BeSimple/SoapClient/WsdlDownloader.php

<?php

/*
 * This file is part of the BeSimpleSoapClient.
 *
 * (c) Christian Kerl <christian-kerl@web.de>
 * (c) Francis Besset <francis.besset@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace BeSimple\SoapClient;

use BeSimple\SoapCommon\Cache;
use BeSimple\SoapCommon\Helper;

/**
 * Downloads WSDL files with cURL. Uses the WSDL_CACHE_* constants and the
 * 'soap.wsdl_*' ini settings. Does only file caching as SoapClient only
 * supports a file name parameter. The class also resolves remote XML schema
 * includes.
 *
 * @author Andreas Schamberger <mail@andreass.net>
 */
class WsdlDownloader
{
    /**
     * Cache enabled.
     *
     * @var bool
     */
    protected $cacheEnabled;

    /**
     * Cache dir.
     *
     * @var string
     */
    protected $cacheDir;

    /**
     * Cache TTL.
     *
     * @var int
     */
    protected $cacheTtl;

    /**
     * cURL instance for downloads.
     *
     * @var unknown_type
     */
    protected $curl;

    /**
     * Resolve WSDl/XSD includes.
     *
     * @var bool
     */
    protected $resolveRemoteIncludes = true;

    /**
     * Constructor.
     *
     * @param \BeSimple\SoapClient\Curl $curl                  Curl instance
     * @param bool                      $resolveRemoteIncludes WSDL/XSD include enabled?
     * @param bool                      $cacheWsdl             Cache constant
     */
    public function __construct(Curl $curl, $resolveRemoteIncludes = true, $cacheWsdl = Cache::TYPE_DISK)
    {
        $this->curl = $curl;
        $this->resolveRemoteIncludes = (bool) $resolveRemoteIncludes;

        // get current WSDL caching config
        $this->cacheEnabled = $cacheWsdl === Cache::TYPE_NONE ? Cache::DISABLED : Cache::ENABLED == Cache::isEnabled();
        $this->cacheDir = Cache::getDirectory();
        $this->cacheTtl = Cache::getLifetime();
    }

    /**
     * Download given WSDL file and return name of cache file.
     *
     * @param string $wsdl WSDL file URL/path
     *
     * @return string
     */
    public function download($wsdl)
    {
        // download and cache remote WSDL files or local ones where we want to
        // resolve remote XSD includes
        $isRemoteFile = $this->isRemoteFile($wsdl);
        if ($isRemoteFile || $this->resolveRemoteIncludes) {
            $cacheFilePath = $this->cacheDir.DIRECTORY_SEPARATOR.'wsdl_'.md5($wsdl).'.cache';

            if (file_exists($cacheFilePath)) {
                clearstatcache();
                $xml = \XMLReader::open($cacheFilePath);
                $xml->setParserProperty(\XMLReader::VALIDATE, true);
                if (!filesize($cacheFilePath) || !$xml->isValid()) {
                    unlink($cacheFilePath);
                    throw new \Exception('There is something wrong with the WSDL file formatting. The file has been deleted from the cache and will be downloaded again on the next request.');
                }
            }

            if (!$this->cacheEnabled || !file_exists($cacheFilePath) || (filemtime($cacheFilePath) + $this->cacheTtl) < time()) {
                if ($isRemoteFile) {
                    // execute request
                    $responseSuccessfull = $this->curl->exec($wsdl);
                    // get content
                    if ($responseSuccessfull) {
                        $response = $this->curl->getResponseBody();

                        libxml_use_internal_errors(true);

                        $doc = simplexml_load_string($response);

                        if (!$doc) {
                            $errors = libxml_get_errors();
                            dump($errors);

                            if (count($errors)) {
                                throw new \Exception('There is something wrong with the WSDL file formatting. The file can\'t be downloaded to be cached.');
                            }

                            libxml_clear_errors();
                        }

                        if ($this->resolveRemoteIncludes) {
                            $this->resolveRemoteIncludes($response, $cacheFilePath, $wsdl);
                        } else {
                            file_put_contents($cacheFilePath, $response);
                        }
                    } else {
                        throw new \ErrorException("SOAP-ERROR: Parsing WSDL: Couldn't load from '".$wsdl."'");
                    }
                } elseif (file_exists($wsdl)) {
                    $response = file_get_contents($wsdl);
                    $this->resolveRemoteIncludes($response, $cacheFilePath);
                } else {
                    throw new \ErrorException("SOAP-ERROR: Parsing WSDL: Couldn't load from '".$wsdl."'");
                }
            }

            return $cacheFilePath;
        } elseif (file_exists($wsdl)) {
            return realpath($wsdl);
        }

        throw new \ErrorException("SOAP-ERROR: Parsing WSDL: Couldn't load from '".$wsdl."'");
    }

    /**
     * Do we have a remote file?
     *
     * @param string $file File URL/path
     *
     * @return bool
     */
    private function isRemoteFile($file)
    {
        // @parse_url to suppress E_WARNING for invalid urls
        if (false !== $url = @parse_url($file)) {
            if (isset($url['scheme']) && 'http' === substr($url['scheme'], 0, 4)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Resolves remote WSDL/XSD includes within the WSDL files.
     *
     * @param string $xml            XML file
     * @param string $cacheFilePath  Cache file name
     * @param bool   $parentFilePath Parent file name
     */
    private function resolveRemoteIncludes($xml, $cacheFilePath, $parentFilePath = null)
    {
        $doc = new \DOMDocument();
        $doc->loadXML($xml);

        $xpath = new \DOMXPath($doc);
        $xpath->registerNamespace(Helper::PFX_XML_SCHEMA, Helper::NS_XML_SCHEMA);
        $xpath->registerNamespace(Helper::PFX_WSDL, Helper::NS_WSDL);

        // WSDL include/import
        $query = './/'.Helper::PFX_WSDL.':include | .//'.Helper::PFX_WSDL.':import';
        $nodes = $xpath->query($query);
        if ($nodes->length > 0) {
            foreach ($nodes as $node) {
                $location = $node->getAttribute('location');
                if ($this->isRemoteFile($location)) {
                    $location = $this->download($location);
                    $node->setAttribute('location', $location);
                } elseif (null !== $parentFilePath) {
                    $location = $this->resolveRelativePathInUrl($parentFilePath, $location);
                    $location = $this->download($location);
                    $node->setAttribute('location', $location);
                }
            }
        }

        // XML schema include/import
        $query = './/'.Helper::PFX_XML_SCHEMA.':include | .//'.Helper::PFX_XML_SCHEMA.':import';
        $nodes = $xpath->query($query);
        if ($nodes->length > 0) {
            foreach ($nodes as $node) {
                if ($node->hasAttribute('schemaLocation')) {
                    $schemaLocation = $node->getAttribute('schemaLocation');
                    if ($this->isRemoteFile($schemaLocation)) {
                        $schemaLocation = $this->download($schemaLocation);
                        $node->setAttribute('schemaLocation', $schemaLocation);
                    } elseif (null !== $parentFilePath) {
                        $schemaLocation = $this->resolveRelativePathInUrl($parentFilePath, $schemaLocation);
                        $schemaLocation = $this->download($schemaLocation);
                        $node->setAttribute('schemaLocation', $schemaLocation);
                    }
                }
            }
        }

        $doc->save($cacheFilePath);
    }

    /**
     * Resolves the relative path to base into an absolute.
     *
     * @param string $base     Base path
     * @param string $relative Relative path
     *
     * @return string
     */
    private function resolveRelativePathInUrl($base, $relative)
    {
        $urlParts = parse_url($base);

        // combine base path with relative path
        if (isset($urlParts['path']) && '/' === $relative[0]) {
            // $relative is absolute path from domain (starts with /)
            $path = $relative;
        } elseif (isset($urlParts['path']) && strrpos($urlParts['path'], '/') === (strlen($urlParts['path']))) {
            // base path is directory
            $path = $urlParts['path'].$relative;
        } elseif (isset($urlParts['path'])) {
            // strip filename from base path
            $path = substr($urlParts['path'], 0, strrpos($urlParts['path'], '/')).'/'.$relative;
        } else {
            // no base path
            $path = '/'.$relative;
        }

        // foo/./bar ==> foo/bar
        // remove double slashes
        $path = preg_replace(array('#/\./#', '#/+#'), '/', $path);

        // split path by '/'
        $parts = explode('/', $path);

        // resolve /../
        foreach ($parts as $key => $part) {
            if ('..' === $part) {
                $keyToDelete = $key - 1;

                while ($keyToDelete > 0) {
                    if (isset($parts[$keyToDelete])) {
                        unset($parts[$keyToDelete]);

                        break;
                    }

                    --$keyToDelete;
                }

                unset($parts[$key]);
            }
        }

        $hostname = $urlParts['scheme'].'://'.$urlParts['host'];
        if (isset($urlParts['port'])) {
            $hostname .= ':'.$urlParts['port'];
        }

        return $hostname.implode('/', $parts);
    }
}