source: pmb4.2/trunk/fuentes/pmb/admin/connecteurs/out/webdav/lib/Sabre/DAV/Client.php @ 815

Last change on this file since 815 was 815, checked in by jrpelegrina, 4 years ago

Initial release of pmb 4.2

  • Property svn:executable set to *
File size: 16.6 KB
Line 
1<?php
2
3namespace Sabre\DAV;
4
5/**
6 * SabreDAV DAV client
7 *
8 * This client wraps around Curl to provide a convenient API to a WebDAV
9 * server.
10 *
11 * NOTE: This class is experimental, it's api will likely change in the future.
12 *
13 * @copyright Copyright (C) 2007-2013 Rooftop Solutions. All rights reserved.
14 * @author Evert Pot (http://www.rooftopsolutions.nl/)
15 * @license http://code.google.com/p/sabredav/wiki/License Modified BSD License
16 */
17class Client {
18
19    /**
20     * The propertyMap is a key-value array.
21     *
22     * If you use the propertyMap, any {DAV:}multistatus responses with the
23     * proeprties listed in this array, will automatically be mapped to a
24     * respective class.
25     *
26     * The {DAV:}resourcetype property is automatically added. This maps to
27     * Sabre\DAV\Property\ResourceType
28     *
29     * @var array
30     */
31    public $propertyMap = array();
32
33    protected $baseUri;
34    protected $userName;
35    protected $password;
36    protected $proxy;
37    protected $trustedCertificates;
38
39    /**
40     * Basic authentication
41     */
42    const AUTH_BASIC = 1;
43
44    /**
45     * Digest authentication
46     */
47    const AUTH_DIGEST = 2;
48
49    /**
50     * The authentication type we're using.
51     *
52     * This is a bitmask of AUTH_BASIC and AUTH_DIGEST.
53     *
54     * If DIGEST is used, the client makes 1 extra request per request, to get
55     * the authentication tokens.
56     *
57     * @var int
58     */
59    protected $authType;
60
61    /**
62     * Indicates if SSL verification is enabled or not.
63     *
64     * @var boolean
65     */
66    private $verifyPeer;
67
68    /**
69     * Constructor
70     *
71     * Settings are provided through the 'settings' argument. The following
72     * settings are supported:
73     *
74     *   * baseUri
75     *   * userName (optional)
76     *   * password (optional)
77     *   * proxy (optional)
78     *
79     * @param array $settings
80     */
81    public function __construct(array $settings) {
82
83        if (!isset($settings['baseUri'])) {
84            throw new \InvalidArgumentException('A baseUri must be provided');
85        }
86
87        $validSettings = array(
88            'baseUri',
89            'userName',
90            'password',
91            'proxy',
92        );
93
94        foreach($validSettings as $validSetting) {
95            if (isset($settings[$validSetting])) {
96                $this->$validSetting = $settings[$validSetting];
97            }
98        }
99
100        if (isset($settings['authType'])) {
101            $this->authType = $settings['authType'];
102        } else {
103            $this->authType = self::AUTH_BASIC | self::AUTH_DIGEST;
104        }
105
106        $this->propertyMap['{DAV:}resourcetype'] = 'Sabre\\DAV\\Property\\ResourceType';
107
108    }
109
110    /**
111     * Add trusted root certificates to the webdav client.
112     *
113     * The parameter certificates should be a absolute path to a file
114     * which contains all trusted certificates
115     *
116     * @param string $certificates
117     */
118    public function addTrustedCertificates($certificates) {
119        $this->trustedCertificates = $certificates;
120    }
121
122    /**
123     * Enables/disables SSL peer verification
124     *
125     * @param boolean $value
126     */
127    public function setVerifyPeer($value) {
128        $this->verifyPeer = $value;
129    }
130
131    /**
132     * Does a PROPFIND request
133     *
134     * The list of requested properties must be specified as an array, in clark
135     * notation.
136     *
137     * The returned array will contain a list of filenames as keys, and
138     * properties as values.
139     *
140     * The properties array will contain the list of properties. Only properties
141     * that are actually returned from the server (without error) will be
142     * returned, anything else is discarded.
143     *
144     * Depth should be either 0 or 1. A depth of 1 will cause a request to be
145     * made to the server to also return all child resources.
146     *
147     * @param string $url
148     * @param array $properties
149     * @param int $depth
150     * @return array
151     */
152    public function propFind($url, array $properties, $depth = 0) {
153
154        $body = '<?xml version="1.0"?>' . "\n";
155        $body.= '<d:propfind xmlns:d="DAV:">' . "\n";
156        $body.= '  <d:prop>' . "\n";
157
158        foreach($properties as $property) {
159
160            list(
161                $namespace,
162                $elementName
163            ) = XMLUtil::parseClarkNotation($property);
164
165            if ($namespace === 'DAV:') {
166                $body.='    <d:' . $elementName . ' />' . "\n";
167            } else {
168                $body.="    <x:" . $elementName . " xmlns:x=\"" . $namespace . "\"/>\n";
169            }
170
171        }
172
173        $body.= '  </d:prop>' . "\n";
174        $body.= '</d:propfind>';
175
176        $response = $this->request('PROPFIND', $url, $body, array(
177            'Depth' => $depth,
178            'Content-Type' => 'application/xml'
179        ));
180
181        $result = $this->parseMultiStatus($response['body']);
182
183        // If depth was 0, we only return the top item
184        if ($depth===0) {
185            reset($result);
186            $result = current($result);
187            return isset($result[200])?$result[200]:array();
188        }
189
190        $newResult = array();
191        foreach($result as $href => $statusList) {
192
193            $newResult[$href] = isset($statusList[200])?$statusList[200]:array();
194
195        }
196
197        return $newResult;
198
199    }
200
201    /**
202     * Updates a list of properties on the server
203     *
204     * The list of properties must have clark-notation properties for the keys,
205     * and the actual (string) value for the value. If the value is null, an
206     * attempt is made to delete the property.
207     *
208     * @todo Must be building the request using the DOM, and does not yet
209     *       support complex properties.
210     * @param string $url
211     * @param array $properties
212     * @return void
213     */
214    public function propPatch($url, array $properties) {
215
216        $body = '<?xml version="1.0"?>' . "\n";
217        $body.= '<d:propertyupdate xmlns:d="DAV:">' . "\n";
218
219        foreach($properties as $propName => $propValue) {
220
221            list(
222                $namespace,
223                $elementName
224            ) = XMLUtil::parseClarkNotation($propName);
225
226            if ($propValue === null) {
227
228                $body.="<d:remove><d:prop>\n";
229
230                if ($namespace === 'DAV:') {
231                    $body.='    <d:' . $elementName . ' />' . "\n";
232                } else {
233                    $body.="    <x:" . $elementName . " xmlns:x=\"" . $namespace . "\"/>\n";
234                }
235
236                $body.="</d:prop></d:remove>\n";
237
238            } else {
239
240                $body.="<d:set><d:prop>\n";
241                if ($namespace === 'DAV:') {
242                    $body.='    <d:' . $elementName . '>';
243                } else {
244                    $body.="    <x:" . $elementName . " xmlns:x=\"" . $namespace . "\">";
245                }
246                // Shitty.. i know
247                $body.=htmlspecialchars($propValue, ENT_NOQUOTES, 'UTF-8');
248                if ($namespace === 'DAV:') {
249                    $body.='</d:' . $elementName . '>' . "\n";
250                } else {
251                    $body.="</x:" . $elementName . ">\n";
252                }
253                $body.="</d:prop></d:set>\n";
254
255            }
256
257        }
258
259        $body.= '</d:propertyupdate>';
260
261        $this->request('PROPPATCH', $url, $body, array(
262            'Content-Type' => 'application/xml'
263        ));
264
265    }
266
267    /**
268     * Performs an HTTP options request
269     *
270     * This method returns all the features from the 'DAV:' header as an array.
271     * If there was no DAV header, or no contents this method will return an
272     * empty array.
273     *
274     * @return array
275     */
276    public function options() {
277
278        $result = $this->request('OPTIONS');
279        if (!isset($result['headers']['dav'])) {
280            return array();
281        }
282
283        $features = explode(',', $result['headers']['dav']);
284        foreach($features as &$v) {
285            $v = trim($v);
286        }
287        return $features;
288
289    }
290
291    /**
292     * Performs an actual HTTP request, and returns the result.
293     *
294     * If the specified url is relative, it will be expanded based on the base
295     * url.
296     *
297     * The returned array contains 3 keys:
298     *   * body - the response body
299     *   * httpCode - a HTTP code (200, 404, etc)
300     *   * headers - a list of response http headers. The header names have
301     *     been lowercased.
302     *
303     * @param string $method
304     * @param string $url
305     * @param string $body
306     * @param array $headers
307     * @return array
308     */
309    public function request($method, $url = '', $body = null, $headers = array()) {
310
311        $url = $this->getAbsoluteUrl($url);
312
313        $curlSettings = array(
314            CURLOPT_RETURNTRANSFER => true,
315            // Return headers as part of the response
316            CURLOPT_HEADER => true,
317            CURLOPT_POSTFIELDS => $body,
318            // Automatically follow redirects
319            CURLOPT_FOLLOWLOCATION => true,
320            CURLOPT_MAXREDIRS => 5,
321        );
322
323        if($this->verifyPeer !== null) {
324            $curlSettings[CURLOPT_SSL_VERIFYPEER] = $this->verifyPeer;
325        }
326
327        if($this->trustedCertificates) {
328            $curlSettings[CURLOPT_CAINFO] = $this->trustedCertificates;
329        }
330
331        switch ($method) {
332            case 'HEAD' :
333
334                // do not read body with HEAD requests (this is necessary because cURL does not ignore the body with HEAD
335                // requests when the Content-Length header is given - which in turn is perfectly valid according to HTTP
336                // specs...) cURL does unfortunately return an error in this case ("transfer closed transfer closed with
337                // ... bytes remaining to read") this can be circumvented by explicitly telling cURL to ignore the
338                // response body
339                $curlSettings[CURLOPT_NOBODY] = true;
340                $curlSettings[CURLOPT_CUSTOMREQUEST] = 'HEAD';
341                break;
342
343            default:
344                $curlSettings[CURLOPT_CUSTOMREQUEST] = $method;
345                break;
346
347        }
348
349        // Adding HTTP headers
350        $nHeaders = array();
351        foreach($headers as $key=>$value) {
352
353            $nHeaders[] = $key . ': ' . $value;
354
355        }
356        $curlSettings[CURLOPT_HTTPHEADER] = $nHeaders;
357
358        if ($this->proxy) {
359            $curlSettings[CURLOPT_PROXY] = $this->proxy;
360        }
361
362        if ($this->userName && $this->authType) {
363            $curlType = 0;
364            if ($this->authType & self::AUTH_BASIC) {
365                $curlType |= CURLAUTH_BASIC;
366            }
367            if ($this->authType & self::AUTH_DIGEST) {
368                $curlType |= CURLAUTH_DIGEST;
369            }
370            $curlSettings[CURLOPT_HTTPAUTH] = $curlType;
371            $curlSettings[CURLOPT_USERPWD] = $this->userName . ':' . $this->password;
372        }
373
374        list(
375            $response,
376            $curlInfo,
377            $curlErrNo,
378            $curlError
379        ) = $this->curlRequest($url, $curlSettings);
380
381        $headerBlob = substr($response, 0, $curlInfo['header_size']);
382        $response = substr($response, $curlInfo['header_size']);
383
384        // In the case of 100 Continue, or redirects we'll have multiple lists
385        // of headers for each separate HTTP response. We can easily split this
386        // because they are separated by \r\n\r\n
387        $headerBlob = explode("\r\n\r\n", trim($headerBlob, "\r\n"));
388
389        // We only care about the last set of headers
390        $headerBlob = $headerBlob[count($headerBlob)-1];
391
392        // Splitting headers
393        $headerBlob = explode("\r\n", $headerBlob);
394
395        $headers = array();
396        foreach($headerBlob as $header) {
397            $parts = explode(':', $header, 2);
398            if (count($parts)==2) {
399                $headers[strtolower(trim($parts[0]))] = trim($parts[1]);
400            }
401        }
402
403        $response = array(
404            'body' => $response,
405            'statusCode' => $curlInfo['http_code'],
406            'headers' => $headers
407        );
408
409        if ($curlErrNo) {
410            throw new Exception('[CURL] Error while making request: ' . $curlError . ' (error code: ' . $curlErrNo . ')');
411        }
412
413        if ($response['statusCode']>=400) {
414            switch ($response['statusCode']) {
415                case 400 :
416                    throw new Exception\BadRequest('Bad request');
417                case 401 :
418                    throw new Exception\NotAuthenticated('Not authenticated');
419                case 402 :
420                    throw new Exception\PaymentRequired('Payment required');
421                case 403 :
422                    throw new Exception\Forbidden('Forbidden');
423                case 404:
424                    throw new Exception\NotFound('Resource not found.');
425                case 405 :
426                    throw new Exception\MethodNotAllowed('Method not allowed');
427                case 409 :
428                    throw new Exception\Conflict('Conflict');
429                case 412 :
430                    throw new Exception\PreconditionFailed('Precondition failed');
431                case 416 :
432                    throw new Exception\RequestedRangeNotSatisfiable('Requested Range Not Satisfiable');
433                case 500 :
434                    throw new Exception('Internal server error');
435                case 501 :
436                    throw new Exception\NotImplemented('Not Implemented');
437                case 507 :
438                    throw new Exception\InsufficientStorage('Insufficient storage');
439                default:
440                    throw new Exception('HTTP error response. (errorcode ' . $response['statusCode'] . ')');
441            }
442        }
443
444        return $response;
445
446    }
447
448    /**
449     * Wrapper for all curl functions.
450     *
451     * The only reason this was split out in a separate method, is so it
452     * becomes easier to unittest.
453     *
454     * @param string $url
455     * @param array $settings
456     * @return array
457     */
458    // @codeCoverageIgnoreStart
459    protected function curlRequest($url, $settings) {
460
461        $curl = curl_init($url);
462        curl_setopt_array($curl, $settings);
463
464        return array(
465            curl_exec($curl),
466            curl_getinfo($curl),
467            curl_errno($curl),
468            curl_error($curl)
469        );
470
471    }
472    // @codeCoverageIgnoreEnd
473
474    /**
475     * Returns the full url based on the given url (which may be relative). All
476     * urls are expanded based on the base url as given by the server.
477     *
478     * @param string $url
479     * @return string
480     */
481    protected function getAbsoluteUrl($url) {
482
483        // If the url starts with http:// or https://, the url is already absolute.
484        if (preg_match('/^http(s?):\/\//', $url)) {
485            return $url;
486        }
487
488        // If the url starts with a slash, we must calculate the url based off
489        // the root of the base url.
490        if (strpos($url,'/') === 0) {
491            $parts = parse_url($this->baseUri);
492            return $parts['scheme'] . '://' . $parts['host'] . (isset($parts['port'])?':' . $parts['port']:'') . $url;
493        }
494
495        // Otherwise...
496        return $this->baseUri . $url;
497
498    }
499
500    /**
501     * Parses a WebDAV multistatus response body
502     *
503     * This method returns an array with the following structure
504     *
505     * array(
506     *   'url/to/resource' => array(
507     *     '200' => array(
508     *        '{DAV:}property1' => 'value1',
509     *        '{DAV:}property2' => 'value2',
510     *     ),
511     *     '404' => array(
512     *        '{DAV:}property1' => null,
513     *        '{DAV:}property2' => null,
514     *     ),
515     *   )
516     *   'url/to/resource2' => array(
517     *      .. etc ..
518     *   )
519     * )
520     *
521     *
522     * @param string $body xml body
523     * @return array
524     */
525    public function parseMultiStatus($body) {
526
527        $body = XMLUtil::convertDAVNamespace($body);
528
529        $responseXML = simplexml_load_string($body, null, LIBXML_NOBLANKS | LIBXML_NOCDATA);
530        if ($responseXML===false) {
531            throw new \InvalidArgumentException('The passed data is not valid XML');
532        }
533
534        $responseXML->registerXPathNamespace('d', 'urn:DAV');
535
536        $propResult = array();
537
538        foreach($responseXML->xpath('d:response') as $response) {
539            $response->registerXPathNamespace('d', 'urn:DAV');
540            $href = $response->xpath('d:href');
541            $href = (string)$href[0];
542
543            $properties = array();
544
545            foreach($response->xpath('d:propstat') as $propStat) {
546
547                $propStat->registerXPathNamespace('d', 'urn:DAV');
548                $status = $propStat->xpath('d:status');
549                list($httpVersion, $statusCode, $message) = explode(' ', (string)$status[0],3);
550
551                $properties[$statusCode] = XMLUtil::parseProperties(dom_import_simplexml($propStat), $this->propertyMap);
552
553            }
554
555            $propResult[$href] = $properties;
556
557        }
558
559        return $propResult;
560
561    }
562
563}
Note: See TracBrowser for help on using the repository browser.