Collaboration diagram for HTTP_Response:

Public Member Functions
	HTTP_Response (&$sock, &$listeners)
	Constructor. More...

	process ($saveBody=true, $canHaveBody=true)
	Processes a HTTP response. More...

	_processHeader ($header)
	Processes the response header. More...

	_parseCookie ($headervalue)
	Parse a Set-Cookie header to fill $_cookies array. More...

	_readChunked ()
	Read a part of response body encoded with chunked Transfer-Encoding. More...

	_notify ($event, $data=null)
	Notifies all registered listeners of an event. More...

	_decodeGzip ($data)
	Decodes the message-body encoded by gzip. More...

Data Fields
	$_sock

	$_protocol

	$_code

	$_reason

	$_headers

	$_cookies

	$_body = ''

	$_chunkLength = 0

	$_listeners = array()

	$_toRead

Detailed Description

Definition at line 1130 of file Request.php.

Member Function Documentation

◆ _decodeGzip()

HTTP_Response::_decodeGzip ( $data )

Decodes the message-body encoded by gzip.

The real decoding work is done by gzinflate() built-in function, this method only parses the header and checks data for compliance with RFC 1952

@access private

Parameters

string gzip-encoded data

Returns: string decoded data

Definition at line 1433 of file Request.php.

    {
        if (HTTP_REQUEST_MBSTRING) {
            $oldEncoding = mb_internal_encoding();
            mb_internal_encoding('iso-8859-1');
        }
        $length = strlen($data);
        // If it doesn't look like gzip-encoded data, don't bother
        if (18 > $length || strcmp(substr($data, 0, 2), "\x1f\x8b")) {
            return $data;
        }
        $method = ord(substr($data, 2, 1));
        if (8 != $method) {
            return PEAR::raiseError('_decodeGzip(): unknown compression method', HTTP_REQUEST_ERROR_GZIP_METHOD);
        }
        $flags = ord(substr($data, 3, 1));
        if ($flags & 224) {
            return PEAR::raiseError('_decodeGzip(): reserved bits are set', HTTP_REQUEST_ERROR_GZIP_DATA);
        }
 
        // header is 10 bytes minimum. may be longer, though.
        $headerLength = 10;
        // extra fields, need to skip 'em
        if ($flags & 4) {
            if ($length - $headerLength - 2 < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $extraLength = unpack('v', substr($data, 10, 2));
            if ($length - $headerLength - 2 - $extraLength[1] < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $headerLength += $extraLength[1] + 2;
        }
        // file name, need to skip that
        if ($flags & 8) {
            if ($length - $headerLength - 1 < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $filenameLength = strpos(substr($data, $headerLength), chr(0));
            if (false === $filenameLength || $length - $headerLength - $filenameLength - 1 < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $headerLength += $filenameLength + 1;
        }
        // comment, need to skip that also
        if ($flags & 16) {
            if ($length - $headerLength - 1 < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $commentLength = strpos(substr($data, $headerLength), chr(0));
            if (false === $commentLength || $length - $headerLength - $commentLength - 1 < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $headerLength += $commentLength + 1;
        }
        // have a CRC for header. let's check
        if ($flags & 1) {
            if ($length - $headerLength - 2 < 8) {
                return PEAR::raiseError('_decodeGzip(): data too short', HTTP_REQUEST_ERROR_GZIP_DATA);
            }
            $crcReal   = 0xffff & crc32(substr($data, 0, $headerLength));
            $crcStored = unpack('v', substr($data, $headerLength, 2));
            if ($crcReal != $crcStored[1]) {
                return PEAR::raiseError('_decodeGzip(): header CRC check failed', HTTP_REQUEST_ERROR_GZIP_CRC);
            }
            $headerLength += 2;
        }
        // unpacked data CRC and size at the end of encoded data
        $tmp = unpack('V2', substr($data, -8));
        $dataCrc  = $tmp[1];
        $dataSize = $tmp[2];
 
        // finally, call the gzinflate() function
        // don't pass $dataSize to gzinflate, see bugs #13135, #14370
        $unpacked = gzinflate(substr($data, $headerLength, -8));
        if (false === $unpacked) {
            return PEAR::raiseError('_decodeGzip(): gzinflate() call failed', HTTP_REQUEST_ERROR_GZIP_READ);
        } elseif ($dataSize != strlen($unpacked)) {
            return PEAR::raiseError('_decodeGzip(): data size check failed', HTTP_REQUEST_ERROR_GZIP_READ);
        } elseif ((0xffffffff & $dataCrc) != (0xffffffff & crc32($unpacked))) {
            return PEAR::raiseError('_decodeGzip(): data CRC check failed', HTTP_REQUEST_ERROR_GZIP_CRC);
        }
        if (HTTP_REQUEST_MBSTRING) {
            mb_internal_encoding($oldEncoding);
        }
        return $unpacked;
    }

References $data, HTTP_REQUEST_ERROR_GZIP_CRC, HTTP_REQUEST_ERROR_GZIP_DATA, HTTP_REQUEST_ERROR_GZIP_METHOD, HTTP_REQUEST_ERROR_GZIP_READ, and PEAR\raiseError().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _notify()

HTTP_Response::_notify	(	$event,
		$data = `null`
	)

Notifies all registered listeners of an event.

Parameters

string	Event name
mixed	Additional data @access private

See also: HTTP_Request::_notify()

Definition at line 1414 of file Request.php.

    {
        foreach (array_keys($this->_listeners) as $id) {
            $this->_listeners[$id]->update($this, $event, $data);
        }
    }

References $data.

Referenced by process().

Here is the caller graph for this function:

◆ _parseCookie()

HTTP_Response::_parseCookie ( $headervalue )

Parse a Set-Cookie header to fill $_cookies array.

@access private

Parameters

string value of Set-Cookie header

Definition at line 1330 of file Request.php.

    {
        $cookie = array(
            'expires' => null,
            'domain'  => null,
            'path'    => null,
            'secure'  => false
        );
 
        // Only a name=value pair
        if (!strpos($headervalue, ';')) {
            $pos = strpos($headervalue, '=');
            $cookie['name']  = trim(substr($headervalue, 0, $pos));
            $cookie['value'] = trim(substr($headervalue, $pos + 1));
 
        // Some optional parameters are supplied
        } else {
            $elements = explode(';', $headervalue);
            $pos = strpos($elements[0], '=');
            $cookie['name']  = trim(substr($elements[0], 0, $pos));
            $cookie['value'] = trim(substr($elements[0], $pos + 1));
 
            for ($i = 1; $i < count($elements); $i++) {
                if (false === strpos($elements[$i], '=')) {
                    $elName  = trim($elements[$i]);
                    $elValue = null;
                } else {
                    list ($elName, $elValue) = array_map('trim', explode('=', $elements[$i]));
                }
                $elName = strtolower($elName);
                if ('secure' == $elName) {
                    $cookie['secure'] = true;
                } elseif ('expires' == $elName) {
                    $cookie['expires'] = str_replace('"', '', $elValue);
                } elseif ('path' == $elName || 'domain' == $elName) {
                    $cookie[$elName] = urldecode($elValue);
                } else {
                    $cookie[$elName] = $elValue;
                }
            }
        }
        $this->_cookies[] = $cookie;
    }

Referenced by _processHeader().

Here is the caller graph for this function:

◆ _processHeader()

HTTP_Response::_processHeader ( $header )

Processes the response header.

@access private

Parameters

string HTTP header

Definition at line 1303 of file Request.php.

    {
        if (false === strpos($header, ':')) {
            return;
        }
        list($headername, $headervalue) = explode(':', $header, 2);
        $headername  = strtolower($headername);
        $headervalue = ltrim($headervalue);
 
        if ('set-cookie' != $headername) {
            if (isset($this->_headers[$headername])) {
                $this->_headers[$headername] .= ',' . $headervalue;
            } else {
                $this->_headers[$headername]  = $headervalue;
            }
        } else {
            $this->_parseCookie($headervalue);
        }
    }

References $header, and _parseCookie().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _readChunked()

HTTP_Response::_readChunked ( )

Read a part of response body encoded with chunked Transfer-Encoding.

@access private

Returns: string

Definition at line 1381 of file Request.php.

    {
        // at start of the next chunk?
        if (0 == $this->_chunkLength) {
            $line = $this->_sock->readLine();
            if (preg_match('/^([0-9a-f]+)/i', $line, $matches)) {
                $this->_chunkLength = hexdec($matches[1]);
                // Chunk with zero length indicates the end
                if (0 == $this->_chunkLength) {
                    $this->_sock->readLine(); // make this an eof()
                    return '';
                }
            } else {
                return '';
            }
        }
        $data = $this->_sock->read($this->_chunkLength);
        $this->_chunkLength -= HTTP_REQUEST_MBSTRING? mb_strlen($data, 'iso-8859-1'): strlen($data);
        if (0 == $this->_chunkLength) {
            $this->_sock->readLine(); // Trailing CRLF
        }
        return $data;
    }

References $data.

Referenced by process().

Here is the caller graph for this function:

◆ HTTP_Response()

HTTP_Response::HTTP_Response	(	&	$sock,
		&	$listeners
	)

Constructor.

Parameters

Net_Socket	socket to read the response from
array	listeners attached to request

Definition at line 1198 of file Request.php.

    {
        $this->_sock      =& $sock;
        $this->_listeners =& $listeners;
    }

◆ process()

HTTP_Response::process	(	$saveBody = `true`,
		$canHaveBody = `true`
	)

Processes a HTTP response.

This extracts response code, headers, cookies and decodes body if it was encoded in some way

@access public

Parameters

bool	Whether to store response body in object property, set this to false if downloading a LARGE file and using a Listener. This is assumed to be true if body is gzip-encoded.
bool	Whether the response can actually have a message-body. Will be set to false for HEAD requests.

Exceptions

PEAR_Error

Returns: mixed true on success, PEAR_Error in case of malformed response

Definition at line 1220 of file Request.php.

    {
        do {
            $line = $this->_sock->readLine();
            if (!preg_match('!^(HTTP/\d\.\d) (\d{3})(?: (.+))?!', $line, $s)) {
                return PEAR::raiseError('Malformed response', HTTP_REQUEST_ERROR_RESPONSE);
            } else {
                $this->_protocol = $s[1];
                $this->_code     = intval($s[2]);
                $this->_reason   = empty($s[3])? null: $s[3];
            }
            while ('' !== ($header = $this->_sock->readLine())) {
                $this->_processHeader($header);
            }
        } while (100 == $this->_code);
 
        $this->_notify('gotHeaders', $this->_headers);
 
        // RFC 2616, section 4.4:
        // 1. Any response message which "MUST NOT" include a message-body ...
        // is always terminated by the first empty line after the header fields
        // 3. ... If a message is received with both a
        // Transfer-Encoding header field and a Content-Length header field,
        // the latter MUST be ignored.
        $canHaveBody = $canHaveBody && $this->_code >= 200 &&
                       $this->_code != 204 && $this->_code != 304;
 
        // If response body is present, read it and decode
        $chunked = isset($this->_headers['transfer-encoding']) && ('chunked' == $this->_headers['transfer-encoding']);
        $gzipped = isset($this->_headers['content-encoding']) && ('gzip' == $this->_headers['content-encoding']);
        $hasBody = false;
        if ($canHaveBody && ($chunked || !isset($this->_headers['content-length']) ||
                0 != $this->_headers['content-length']))
        {
            if ($chunked || !isset($this->_headers['content-length'])) {
                $this->_toRead = null;
            } else {
                $this->_toRead = $this->_headers['content-length'];
            }
            while (!$this->_sock->eof() && (is_null($this->_toRead) || 0 < $this->_toRead)) {
                if ($chunked) {
                    $data = $this->_readChunked();
                } elseif (is_null($this->_toRead)) {
                    $data = $this->_sock->read(4096);
                } else {
                    $data = $this->_sock->read(min(4096, $this->_toRead));
                    $this->_toRead -= HTTP_REQUEST_MBSTRING? mb_strlen($data, 'iso-8859-1'): strlen($data);
                }
                if ('' == $data && (!$this->_chunkLength || $this->_sock->eof())) {
                    break;
                } else {
                    $hasBody = true;
                    if ($saveBody || $gzipped) {
                        $this->_body .= $data;
                    }
                    $this->_notify($gzipped? 'gzTick': 'tick', $data);
                }
            }
        }
 
        if ($hasBody) {
            // Uncompress the body if needed
            if ($gzipped) {
                $body = $this->_decodeGzip($this->_body);
                if (PEAR::isError($body)) {
                    return $body;
                }
                $this->_body = $body;
                $this->_notify('gotBody', $this->_body);
            } else {
                $this->_notify('gotBody');
            }
        }
        return true;
    }

References $_toRead, $data, $header, _decodeGzip(), _notify(), _processHeader(), _readChunked(), HTTP_REQUEST_ERROR_RESPONSE, PEAR\isError(), and PEAR\raiseError().

Here is the call graph for this function:

Field Documentation

◆ $_body

HTTP_Response::$_body = ''

Definition at line 1172 of file Request.php.

◆ $_chunkLength

HTTP_Response::$_chunkLength = 0

Definition at line 1178 of file Request.php.

◆ $_code

HTTP_Response::$_code

Definition at line 1148 of file Request.php.

◆ $_cookies

HTTP_Response::$_cookies

Definition at line 1166 of file Request.php.

◆ $_headers

HTTP_Response::$_headers

Definition at line 1160 of file Request.php.

◆ $_listeners

HTTP_Response::$_listeners = array()

Definition at line 1184 of file Request.php.

◆ $_protocol

HTTP_Response::$_protocol

Definition at line 1142 of file Request.php.

◆ $_reason

HTTP_Response::$_reason

Definition at line 1154 of file Request.php.

◆ $_sock

HTTP_Response::$_sock

Definition at line 1136 of file Request.php.

◆ $_toRead

HTTP_Response::$_toRead

Definition at line 1190 of file Request.php.

Referenced by process().

The documentation for this class was generated from the following file:

Services/PEAR/lib/HTTP/Request.php

Public Member Functions

Data Fields

Detailed Description

Member Function Documentation

◆ _decodeGzip()

◆ _notify()

◆ _parseCookie()

◆ _processHeader()

◆ _readChunked()

◆ HTTP_Response()

◆ process()

Field Documentation

◆ $_body

◆ $_chunkLength

◆ $_code

◆ $_cookies

◆ $_headers

◆ $_listeners

◆ $_protocol

◆ $_reason

◆ $_sock

◆ $_toRead