Zend/Uri/Http.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category  Zend
  16  * @package   Zend_Uri
  17  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18  * @license   http://framework.zend.com/license/new-bsd     New BSD License
  19
  20  */
  21
  22 /**
  23  * @see Zend_Uri
  24  */
  25 require_once 'Zend/Uri.php';
  26
  27 /**
  28  * @see Zend_Validate_Hostname
  29  */
  30 require_once 'Zend/Validate/Hostname.php';
  31
  32 /**
  33  * HTTP(S) URI handler
  34  *
  35  * @category  Zend
  36  * @package   Zend_Uri
  37  * @uses      Zend_Uri
  38  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  39  * @license   http://framework.zend.com/license/new-bsd     New BSD License
  40  */
  41 class Zend_Uri_Http extends Zend_Uri
  42 {
  43     /**
  44      * Character classes for validation regular expressions
  45      */
  46     const CHAR_ALNUM    = 'A-Za-z0-9';
  47     const CHAR_MARK     = '-_.!~*\'()\[\]';
  48     const CHAR_RESERVED = ';\/?:@&=+$,';
  49     const CHAR_SEGMENT  = ':@&=+$,;';
  50     const CHAR_UNWISE   = '{}|\\\\^`';
  51
  52     /**
  53      * HTTP username
  54      *
  55      * @var string
  56      */
  57     protected $_username = '';
  58
  59     /**
  60      * HTTP password
  61      *
  62      * @var string
  63      */
  64     protected $_password = '';
  65
  66     /**
  67      * HTTP host
  68      *
  69      * @var string
  70      */
  71     protected $_host = '';
  72
  73     /**
  74      * HTTP post
  75      *
  76      * @var string
  77      */
  78     protected $_port = '';
  79
  80     /**
  81      * HTTP part
  82      *
  83      * @var string
  84      */
  85     protected $_path = '';
  86
  87     /**
  88      * HTTP query
  89      *
  90      * @var string
  91      */
  92     protected $_query = '';
  93
  94     /**
  95      * HTTP fragment
  96      *
  97      * @var string
  98      */
  99     protected $_fragment = '';
 100
 101     /**
 102      * Regular expression grammar rules for validation; values added by constructor
 103      *
 104      * @var array
 105      */
 106     protected $_regex = array();
 107
 108     /**
 109      * Constructor accepts a string $scheme (e.g., http, https) and a scheme-specific part of the URI
 110      * (e.g., example.com/path/to/resource?query=param#fragment)
 111      *
 112      * @param  string $scheme         The scheme of the URI
 113      * @param  string $schemeSpecific The scheme-specific part of the URI
 114      * @throws Zend_Uri_Exception When the URI is not valid
 115      */
 116     protected function __construct($scheme, $schemeSpecific = '')
 117     {
 118         // Set the scheme
 119         $this->_scheme = $scheme;
 120
 121         // Set up grammar rules for validation via regular expressions. These
 122         // are to be used with slash-delimited regular expression strings.
 123
 124         // Escaped special characters (eg. '%25' for '%')
 125         $this->_regex['escaped']    = '%[[:xdigit:]]{2}';
 126
 127         // Unreserved characters
 128         $this->_regex['unreserved'] = '[' . self::CHAR_ALNUM . self::CHAR_MARK . ']';
 129
 130         // Segment can use escaped, unreserved or a set of additional chars
 131         $this->_regex['segment']    = '(?:' . $this->_regex['escaped'] . '|[' .
 132             self::CHAR_ALNUM . self::CHAR_MARK . self::CHAR_SEGMENT . '])*';
 133
 134         // Path can be a series of segmets char strings seperated by '/'
 135         $this->_regex['path']       = '(?:\/(?:' . $this->_regex['segment'] . ')?)+';
 136
 137         // URI characters can be escaped, alphanumeric, mark or reserved chars
 138         $this->_regex['uric']       = '(?:' . $this->_regex['escaped'] . '|[' .
 139             self::CHAR_ALNUM . self::CHAR_MARK . self::CHAR_RESERVED .
 140
 141         // If unwise chars are allowed, add them to the URI chars class
 142             (self::$_config['allow_unwise'] ? self::CHAR_UNWISE : '') . '])';
 143
 144         // If no scheme-specific part was supplied, the user intends to create
 145         // a new URI with this object.  No further parsing is required.
 146         if (strlen($schemeSpecific) === 0) {
 147             return;
 148         }
 149
 150         // Parse the scheme-specific URI parts into the instance variables.
 151         $this->_parseUri($schemeSpecific);
 152
 153         // Validate the URI
 154         if ($this->valid() === false) {
 155             require_once 'Zend/Uri/Exception.php';
 156             throw new Zend_Uri_Exception('Invalid URI supplied');
 157         }
 158     }
 159
 160     /**
 161      * Creates a Zend_Uri_Http from the given string
 162      *
 163      * @param  string $uri String to create URI from, must start with
 164      *                     'http://' or 'https://'
 165      * @throws InvalidArgumentException  When the given $uri is not a string or
 166      *                                   does not start with http:// or https://
 167      * @throws Zend_Uri_Exception        When the given $uri is invalid
 168      * @return Zend_Uri_Http
 169      */
 170     public static function fromString($uri)
 171     {
 172         if (is_string($uri) === false) {
 173             require_once 'Zend/Uri/Exception.php';
 174             throw new Zend_Uri_Exception('$uri is not a string');
 175         }
 176
 177         $uri            = explode(':', $uri, 2);
 178         $scheme         = strtolower($uri[0]);
 179         $schemeSpecific = isset($uri[1]) === true ? $uri[1] : '';
 180
 181         if (in_array($scheme, array('http', 'https')) === false) {
 182             require_once 'Zend/Uri/Exception.php';
 183             throw new Zend_Uri_Exception("Invalid scheme: '$scheme'");
 184         }
 185
 186         $schemeHandler = new Zend_Uri_Http($scheme, $schemeSpecific);
 187         return $schemeHandler;
 188     }
 189
 190     /**
 191      * Parse the scheme-specific portion of the URI and place its parts into instance variables.
 192      *
 193      * @param  string $schemeSpecific The scheme-specific portion to parse
 194      * @throws Zend_Uri_Exception When scheme-specific decoposition fails
 195      * @throws Zend_Uri_Exception When authority decomposition fails
 196      * @return void
 197      */
 198     protected function _parseUri($schemeSpecific)
 199     {
 200         // High-level decomposition parser
 201         $pattern = '~^((//)([^/?#]*))([^?#]*)(\?([^#]*))?(#(.*))?$~';
 202         $status  = @preg_match($pattern, $schemeSpecific, $matches);
 203         if ($status === false) {
 204             require_once 'Zend/Uri/Exception.php';
 205             throw new Zend_Uri_Exception('Internal error: scheme-specific decomposition failed');
 206         }
 207
 208         // Failed decomposition; no further processing needed
 209         if ($status === false) {
 210             return;
 211         }
 212
 213         // Save URI components that need no further decomposition
 214         $this->_path     = isset($matches[4]) === true ? $matches[4] : '';
 215         $this->_query    = isset($matches[6]) === true ? $matches[6] : '';
 216         $this->_fragment = isset($matches[8]) === true ? $matches[8] : '';
 217
 218         // Additional decomposition to get username, password, host, and port
 219         $combo   = isset($matches[3]) === true ? $matches[3] : '';
 220         $pattern = '~^(([^:@]*)(:([^@]*))?@)?([^:]+)(:(.*))?$~';
 221         $status  = @preg_match($pattern, $combo, $matches);
 222         if ($status === false) {
 223             require_once 'Zend/Uri/Exception.php';
 224             throw new Zend_Uri_Exception('Internal error: authority decomposition failed');
 225         }
 226
 227         // Failed decomposition; no further processing needed
 228         if ($status === false) {
 229             return;
 230         }
 231
 232         // Save remaining URI components
 233         $this->_username = isset($matches[2]) === true ? $matches[2] : '';
 234         $this->_password = isset($matches[4]) === true ? $matches[4] : '';
 235         $this->_host     = isset($matches[5]) === true ? $matches[5] : '';
 236         $this->_port     = isset($matches[7]) === true ? $matches[7] : '';
 237
 238     }
 239
 240     /**
 241      * Returns a URI based on current values of the instance variables. If any
 242      * part of the URI does not pass validation, then an exception is thrown.
 243      *
 244      * @throws Zend_Uri_Exception When one or more parts of the URI are invalid
 245      * @return string
 246      */
 247     public function getUri()
 248     {
 249         if ($this->valid() === false) {
 250             require_once 'Zend/Uri/Exception.php';
 251             throw new Zend_Uri_Exception('One or more parts of the URI are invalid');
 252         }
 253
 254         $password = strlen($this->_password) > 0 ? ":$this->_password" : '';
 255         $auth     = strlen($this->_username) > 0 ? "$this->_username$password@" : '';
 256         $port     = strlen($this->_port) > 0 ? ":$this->_port" : '';
 257         $query    = strlen($this->_query) > 0 ? "?$this->_query" : '';
 258         $fragment = strlen($this->_fragment) > 0 ? "#$this->_fragment" : '';
 259
 260         return $this->_scheme
 261              . '://'
 262              . $auth
 263              . $this->_host
 264              . $port
 265              . $this->_path
 266              . $query
 267              . $fragment;
 268     }
 269
 270     /**
 271      * Validate the current URI from the instance variables. Returns true if and only if all
 272      * parts pass validation.
 273      *
 274      * @return boolean
 275      */
 276     public function valid()
 277     {
 278         // Return true if and only if all parts of the URI have passed validation
 279         return $this->validateUsername()
 280            and $this->validatePassword()
 281            and $this->validateHost()
 282            and $this->validatePort()
 283            and $this->validatePath()
 284            and $this->validateQuery()
 285            and $this->validateFragment();
 286     }
 287
 288     /**
 289      * Returns the username portion of the URL, or FALSE if none.
 290      *
 291      * @return string
 292      */
 293     public function getUsername()
 294     {
 295         return strlen($this->_username) > 0 ? $this->_username : false;
 296     }
 297
 298     /**
 299      * Returns true if and only if the username passes validation. If no username is passed,
 300      * then the username contained in the instance variable is used.
 301      *
 302      * @param  string $username The HTTP username
 303      * @throws Zend_Uri_Exception When username validation fails
 304      * @return boolean
 305      * @link   http://www.faqs.org/rfcs/rfc2396.html
 306      */
 307     public function validateUsername($username = null)
 308     {
 309         if ($username === null) {
 310             $username = $this->_username;
 311         }
 312
 313         // If the username is empty, then it is considered valid
 314         if (strlen($username) === 0) {
 315             return true;
 316         }
 317
 318         // Check the username against the allowed values
 319         $status = @preg_match('/^(?:' . $this->_regex['escaped'] . '|[' .
 320             self::CHAR_ALNUM . self::CHAR_MARK . ';:&=+$,' . '])+$/', $username);
 321
 322         if ($status === false) {
 323             require_once 'Zend/Uri/Exception.php';
 324             throw new Zend_Uri_Exception('Internal error: username validation failed');
 325         }
 326
 327         return $status === 1;
 328     }
 329
 330     /**
 331      * Sets the username for the current URI, and returns the old username
 332      *
 333      * @param  string $username The HTTP username
 334      * @throws Zend_Uri_Exception When $username is not a valid HTTP username
 335      * @return string
 336      */
 337     public function setUsername($username)
 338     {
 339         if ($this->validateUsername($username) === false) {
 340             require_once 'Zend/Uri/Exception.php';
 341             throw new Zend_Uri_Exception("Username \"$username\" is not a valid HTTP username");
 342         }
 343
 344         $oldUsername     = $this->_username;
 345         $this->_username = $username;
 346
 347         return $oldUsername;
 348     }
 349
 350     /**
 351      * Returns the password portion of the URL, or FALSE if none.
 352      *
 353      * @return string
 354      */
 355     public function getPassword()
 356     {
 357         return strlen($this->_password) > 0 ? $this->_password : false;
 358     }
 359
 360     /**
 361      * Returns true if and only if the password passes validation. If no password is passed,
 362      * then the password contained in the instance variable is used.
 363      *
 364      * @param  string $password The HTTP password
 365      * @throws Zend_Uri_Exception When password validation fails
 366      * @return boolean
 367      * @link   http://www.faqs.org/rfcs/rfc2396.html
 368      */
 369     public function validatePassword($password = null)
 370     {
 371         if ($password === null) {
 372             $password = $this->_password;
 373         }
 374
 375         // If the password is empty, then it is considered valid
 376         if (strlen($password) === 0) {
 377             return true;
 378         }
 379
 380         // If the password is nonempty, but there is no username, then it is considered invalid
 381         if (strlen($password) > 0 and strlen($this->_username) === 0) {
 382             return false;
 383         }
 384
 385         // Check the password against the allowed values
 386         $status = @preg_match('/^(?:' . $this->_regex['escaped'] . '|[' .
 387             self::CHAR_ALNUM . self::CHAR_MARK . ';:&=+$,' . '])+$/', $password);
 388
 389         if ($status === false) {
 390             require_once 'Zend/Uri/Exception.php';
 391             throw new Zend_Uri_Exception('Internal error: password validation failed.');
 392         }
 393
 394         return $status == 1;
 395     }
 396
 397     /**
 398      * Sets the password for the current URI, and returns the old password
 399      *
 400      * @param  string $password The HTTP password
 401      * @throws Zend_Uri_Exception When $password is not a valid HTTP password
 402      * @return string
 403      */
 404     public function setPassword($password)
 405     {
 406         if ($this->validatePassword($password) === false) {
 407             require_once 'Zend/Uri/Exception.php';
 408             throw new Zend_Uri_Exception("Password \"$password\" is not a valid HTTP password.");
 409         }
 410
 411         $oldPassword     = $this->_password;
 412         $this->_password = $password;
 413
 414         return $oldPassword;
 415     }
 416
 417     /**
 418      * Returns the domain or host IP portion of the URL, or FALSE if none.
 419      *
 420      * @return string
 421      */
 422     public function getHost()
 423     {
 424         return strlen($this->_host) > 0 ? $this->_host : false;
 425     }
 426
 427     /**
 428      * Returns true if and only if the host string passes validation. If no host is passed,
 429      * then the host contained in the instance variable is used.
 430      *
 431      * @param  string $host The HTTP host
 432      * @return boolean
 433      * @uses   Zend_Filter
 434      */
 435     public function validateHost($host = null)
 436     {
 437         if ($host === null) {
 438             $host = $this->_host;
 439         }
 440
 441         // If the host is empty, then it is considered invalid
 442         if (strlen($host) === 0) {
 443             return false;
 444         }
 445
 446         // Check the host against the allowed values; delegated to Zend_Filter.
 447         $validate = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_ALL);
 448
 449         return $validate->isValid($host);
 450     }
 451
 452     /**
 453      * Sets the host for the current URI, and returns the old host
 454      *
 455      * @param  string $host The HTTP host
 456      * @throws Zend_Uri_Exception When $host is nota valid HTTP host
 457      * @return string
 458      */
 459     public function setHost($host)
 460     {
 461         if ($this->validateHost($host) === false) {
 462             require_once 'Zend/Uri/Exception.php';
 463             throw new Zend_Uri_Exception("Host \"$host\" is not a valid HTTP host");
 464         }
 465
 466         $oldHost     = $this->_host;
 467         $this->_host = $host;
 468
 469         return $oldHost;
 470     }
 471
 472     /**
 473      * Returns the TCP port, or FALSE if none.
 474      *
 475      * @return string
 476      */
 477     public function getPort()
 478     {
 479         return strlen($this->_port) > 0 ? $this->_port : false;
 480     }
 481
 482     /**
 483      * Returns true if and only if the TCP port string passes validation. If no port is passed,
 484      * then the port contained in the instance variable is used.
 485      *
 486      * @param  string $port The HTTP port
 487      * @return boolean
 488      */
 489     public function validatePort($port = null)
 490     {
 491         if ($port === null) {
 492             $port = $this->_port;
 493         }
 494
 495         // If the port is empty, then it is considered valid
 496         if (strlen($port) === 0) {
 497             return true;
 498         }
 499
 500         // Check the port against the allowed values
 501         return ctype_digit((string) $port) and 1 <= $port and $port <= 65535;
 502     }
 503
 504     /**
 505      * Sets the port for the current URI, and returns the old port
 506      *
 507      * @param  string $port The HTTP port
 508      * @throws Zend_Uri_Exception When $port is not a valid HTTP port
 509      * @return string
 510      */
 511     public function setPort($port)
 512     {
 513         if ($this->validatePort($port) === false) {
 514             require_once 'Zend/Uri/Exception.php';
 515             throw new Zend_Uri_Exception("Port \"$port\" is not a valid HTTP port.");
 516         }
 517
 518         $oldPort     = $this->_port;
 519         $this->_port = $port;
 520
 521         return $oldPort;
 522     }
 523
 524     /**
 525      * Returns the path and filename portion of the URL, or FALSE if none.
 526      *
 527      * @return string
 528      */
 529     public function getPath()
 530     {
 531         return strlen($this->_path) > 0 ? $this->_path : '/';
 532     }
 533
 534     /**
 535      * Returns true if and only if the path string passes validation. If no path is passed,
 536      * then the path contained in the instance variable is used.
 537      *
 538      * @param  string $path The HTTP path
 539      * @throws Zend_Uri_Exception When path validation fails
 540      * @return boolean
 541      */
 542     public function validatePath($path = null)
 543     {
 544         if ($path === null) {
 545             $path = $this->_path;
 546         }
 547
 548         // If the path is empty, then it is considered valid
 549         if (strlen($path) === 0) {
 550             return true;
 551         }
 552
 553         // Determine whether the path is well-formed
 554         $pattern = '/^' . $this->_regex['path'] . '$/';
 555         $status  = @preg_match($pattern, $path);
 556         if ($status === false) {
 557             require_once 'Zend/Uri/Exception.php';
 558             throw new Zend_Uri_Exception('Internal error: path validation failed');
 559         }
 560
 561         return (boolean) $status;
 562     }
 563
 564     /**
 565      * Sets the path for the current URI, and returns the old path
 566      *
 567      * @param  string $path The HTTP path
 568      * @throws Zend_Uri_Exception When $path is not a valid HTTP path
 569      * @return string
 570      */
 571     public function setPath($path)
 572     {
 573         if ($this->validatePath($path) === false) {
 574             require_once 'Zend/Uri/Exception.php';
 575             throw new Zend_Uri_Exception("Path \"$path\" is not a valid HTTP path");
 576         }
 577
 578         $oldPath     = $this->_path;
 579         $this->_path = $path;
 580
 581         return $oldPath;
 582     }
 583
 584     /**
 585      * Returns the query portion of the URL (after ?), or FALSE if none.
 586      *
 587      * @return string
 588      */
 589     public function getQuery()
 590     {
 591         return strlen($this->_query) > 0 ? $this->_query : false;
 592     }
 593
 594     /**
 595      * Returns the query portion of the URL (after ?) as a
 596      * key-value-array. If the query is empty an empty array
 597      * is returned
 598      *
 599      * @return array
 600      */
 601     public function getQueryAsArray()
 602     {
 603         $query = $this->getQuery();
 604         $querryArray = array();
 605         if ($query !== false) {
 606             parse_str($query, $querryArray);
 607         }
 608         return $querryArray;
 609     }
 610
 611     /**
 612      * Returns true if and only if the query string passes validation. If no query is passed,
 613      * then the query string contained in the instance variable is used.
 614      *
 615      * @param  string $query The query to validate
 616      * @throws Zend_Uri_Exception When query validation fails
 617      * @return boolean
 618      * @link   http://www.faqs.org/rfcs/rfc2396.html
 619      */
 620     public function validateQuery($query = null)
 621     {
 622         if ($query === null) {
 623             $query = $this->_query;
 624         }
 625
 626         // If query is empty, it is considered to be valid
 627         if (strlen($query) === 0) {
 628             return true;
 629         }
 630
 631         // Determine whether the query is well-formed
 632         $pattern = '/^' . $this->_regex['uric'] . '*$/';
 633         $status  = @preg_match($pattern, $query);
 634         if ($status === false) {
 635             require_once 'Zend/Uri/Exception.php';
 636             throw new Zend_Uri_Exception('Internal error: query validation failed');
 637         }
 638
 639         return $status == 1;
 640     }
 641
 642     /**
 643      * Add or replace params in the query string for the current URI, and
 644      * return the old query.
 645      *
 646      * @param  array $queryParams
 647      * @return string Old query string
 648      */
 649     public function addReplaceQueryParameters(array $queryParams)
 650     {
 651         $queryParams = array_merge($this->getQueryAsArray(), $queryParams);
 652         return $this->setQuery($queryParams);
 653     }
 654
 655     /**
 656      * Remove params in the query string for the current URI, and
 657      * return the old query.
 658      *
 659      * @param  array $queryParamKeys
 660      * @return string Old query string
 661      */
 662     public function removeQueryParameters(array $queryParamKeys)
 663     {
 664         $queryParams = array_diff_key($this->getQueryAsArray(), array_fill_keys($queryParamKeys, 0));
 665         return $this->setQuery($queryParams);
 666     }
 667
 668     /**
 669      * Set the query string for the current URI, and return the old query
 670      * string This method accepts both strings and arrays.
 671      *
 672      * @param  string|array $query The query string or array
 673      * @throws Zend_Uri_Exception When $query is not a valid query string
 674      * @return string              Old query string
 675      */
 676     public function setQuery($query)
 677     {
 678         $oldQuery = $this->_query;
 679
 680         // If query is empty, set an empty string
 681         if (empty($query) === true) {
 682             $this->_query = '';
 683             return $oldQuery;
 684         }
 685
 686         // If query is an array, make a string out of it
 687         if (is_array($query) === true) {
 688             $query = http_build_query($query, '', '&');
 689         } else {
 690             // If it is a string, make sure it is valid. If not parse and encode it
 691             $query = (string) $query;
 692             if ($this->validateQuery($query) === false) {
 693                 parse_str($query, $queryArray);
 694                 $query = http_build_query($queryArray, '', '&');
 695             }
 696         }
 697
 698         // Make sure the query is valid, and set it
 699         if ($this->validateQuery($query) === false) {
 700             require_once 'Zend/Uri/Exception.php';
 701             throw new Zend_Uri_Exception("'$query' is not a valid query string");
 702         }
 703
 704         $this->_query = $query;
 705
 706         return $oldQuery;
 707     }
 708
 709     /**
 710      * Returns the fragment portion of the URL (after #), or FALSE if none.
 711      *
 712      * @return string|false
 713      */
 714     public function getFragment()
 715     {
 716         return strlen($this->_fragment) > 0 ? $this->_fragment : false;
 717     }
 718
 719     /**
 720      * Returns true if and only if the fragment passes validation. If no fragment is passed,
 721      * then the fragment contained in the instance variable is used.
 722      *
 723      * @param  string $fragment Fragment of an URI
 724      * @throws Zend_Uri_Exception When fragment validation fails
 725      * @return boolean
 726      * @link   http://www.faqs.org/rfcs/rfc2396.html
 727      */
 728     public function validateFragment($fragment = null)
 729     {
 730         if ($fragment === null) {
 731             $fragment = $this->_fragment;
 732         }
 733
 734         // If fragment is empty, it is considered to be valid
 735         if (strlen($fragment) === 0) {
 736             return true;
 737         }
 738
 739         // Determine whether the fragment is well-formed
 740         $pattern = '/^' . $this->_regex['uric'] . '*$/';
 741         $status  = @preg_match($pattern, $fragment);
 742         if ($status === false) {
 743             require_once 'Zend/Uri/Exception.php';
 744             throw new Zend_Uri_Exception('Internal error: fragment validation failed');
 745         }
 746
 747         return (boolean) $status;
 748     }
 749
 750     /**
 751      * Sets the fragment for the current URI, and returns the old fragment
 752      *
 753      * @param  string $fragment Fragment of the current URI
 754      * @throws Zend_Uri_Exception When $fragment is not a valid HTTP fragment
 755      * @return string
 756      */
 757     public function setFragment($fragment)
 758     {
 759         if ($this->validateFragment($fragment) === false) {
 760             require_once 'Zend/Uri/Exception.php';
 761             throw new Zend_Uri_Exception("Fragment \"$fragment\" is not a valid HTTP fragment");
 762         }
 763
 764         $oldFragment     = $this->_fragment;
 765         $this->_fragment = $fragment;
 766
 767         return $oldFragment;
 768     }
 769 }