This file is indexed.

/usr/share/php/Cache/HTTP_Request.php is in php-cache 1.5.6-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
<?php
// +----------------------------------------------------------------------+
// | PEAR :: Cache                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.0 of the PHP license,       |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Fabien MARTY <fabien.marty@free.fr> |
// +----------------------------------------------------------------------+
//
// $Id: HTTP_Request.php 174777 2004-12-15 09:09:33Z dufuz $

require_once 'Cache.php';
require_once 'HTTP/Request.php';

define('CACHE_HTTP_REQUEST_GROUP_NAME', 'cache_http_request');
define('CACHE_HTTP_REQUEST_SUCCESS_RESPONSE_CODE', 200);
define('CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY', 1);
define('CACHE_HTTP_REQUEST_RETURN_FALSE', 2);
define('CACHE_HTTP_REQUEST_RETURN_PEAR_ERROR', 3);

/**
* HTTP_Request Cache
*
* The classical example is :
*
* You want to get news from another site through RSS remote files. But you
* don't want to access to to the remote site at every time you display
* its news on your site. Because, if the remote site is down or slow...
* So you you need a class which makes a local cache copy of the remote file.
* Every x hours, the cache is updated. But if the remote site is down, the
* local cache copy is keeped (you can also get error messages if you want).
*
* So you need this class!
*
* Cache_HTTP_Request inherits from Cache and use HTTP_Request to access to
* the remote file.
*
* Usage example :
*
* <?php
* require_once('Cache/HTTP_Request.php');
*
* $cache = &new Cache_HTTP_Request('http://www.php.net', null, 'file', null, 3600);
* $cache->sendRequest();
* $remoteFileBody = $cache->getResponseBody();
*
* (...)
* ?>
*
* @author   Fabien MARTY <fabien.marty@free.fr>
* @version  $Id: HTTP_Request.php 174777 2004-12-15 09:09:33Z dufuz $
* @package  Cache
*/

class Cache_HTTP_Request extends Cache
{

    // --- Private properties ---

    /**
    * Lifetime in seconds (0 endless)
    *
    * @var int $_expires
    */
    var $_expires;

    /**
    * HTTP Request
    *
    * @var object $_request
    */
    var $_request;

    /**
    * Cache id for the classic cache file
    *
    * @see sendRequest()
    * @var string $_id
    */
    var $_id;

    /**
    * Cache id for the endless cache file
    *
    * @see sendRequest()
    * @var string $_id
    */
    var $_id2;

    /**
    * Data to use
    *
    * @see getReponseBody(), getReponseHeader(), getReponseCode()
    * @var array $_data
    */
    var $_data ;

    // --- Public methods ---

    /**
    * Constructor
    *
    * @param $url The url to access
    * @param $params Associative array of parameters which can be:
    *                  method     - Method to use, GET, POST etc
    *                  http       - HTTP Version to use, 1.0 or 1.1
    *                  user       - Basic Auth username
    *                  pass       - Basic Auth password
    *                  proxy_host - Proxy server host
    *                  proxy_port - Proxy server port
    *                  proxy_user - Proxy auth username
    *                  proxy_pass - Proxy auth password
    * @param string $container Name of container class
    * @param array $containerOptions Array with container class options
    * @param int $mode What to do when the remote server is down :
    *                   CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY or
    *                   CACHE_HTTP_REQUEST_RETURN_FALSE or
    *                   CACHE_HTTP_REQUEST_RETURN_PEAR_ERROR
    * @param int $expires lifetime of the cached data in seconds - 0 for endless
    * @see Cache, HTTP_Request
    * @access public
    */
    function Cache_HTTP_Request($url, $params = null, $container  = 'file',
                                $containerOptions = null, $expires = 3600,
                                $mode = CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY)
    {
        if (!isset($params)) {
            $params = array();
        }

        if (!isset($containerOptions)) {
            $containerOptions = array (
                'cache_dir' => '/tmp/',
                'filename_prefix' => 'cache_'
            );
        }
        $this->Cache($container, $containerOptions);
        $this->_request = &new HTTP_Request($url, $params);
        $this->_id = md5($url.serialize($params));
        $this->_id2 = md5($this->_id); // we need two keys
        $this->_mode = $mode;
        $this->_expires = $expires;
    }

    /**
    * Deconstructor
    *
    * @access public
    */
    function _Cache_HTTP_Request()
    {
        $this->_Cache();
    }

    /**
    * Get and return the response body (null if no data available)
    *
    * @see sendRequest()
    * @return mixed response body
    * @access public
    */
    function getResponseBody()
    {
        return $this->_data['body'];
    }

    /**
    * Get and return the response code (null if no data available)
    *
    * @see sendRequest()
    * @return mixed response code
    * @access public
    */
    function getResponseCode()
    {
        return $this->_data['code'];
    }

    /**
    * Get and return the response header (null if no data available)
    *
    * @see sendRequest()
    * @return mixed response header
    * @access public
    */
    function getResponseHeader()
    {
        return $this->_data['header'];
    }


    /**
    * Set a new mode when the server is down
    *
    * @param int $newMode What to do when the remote server is down :
    *                      CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY or
    *                      CACHE_HTTP_REQUEST_RETURN_FALSE or
    *                      CACHE_HTTP_REQUEST_RETURN_PEAR_ERROR
    * @access public
    */
    function setMode($newMode)
    {
        $this->_mode = $newMode;
    }

    /**
    * Send the HTTP request or use the cache system
    *
    * If there is a cache file for this HTTP request, the request is not re-sent.
    * Cached response is used. Yet, if the cache is expired, the HTTP request
    * is re-sent. Then, if the remote server is down, this method will return :
    * (depending on the selected mode)
    * - false or
    * - a PEAR_Error or (better)
    * - true and the local copy of the latest valid response will be used.
    *
    * (technical)
    * For the last choice, there is a technical tips.
    * Indeed, there are two cache files. The first one (id key) is a classical one
    * with the given lifetime. But it can be removed by automatic garbage collection
    * for example. So to be able to use the latest valid response (when the remote
    * server is dead), we make a second cache file with no lifetime (id2 key).
    *
    * @return mixed true or false or a PEAR_ERROR
    * @access public
    */
    function sendRequest()
    {
        if ($data = $this->get($this->_id, CACHE_HTTP_REQUEST_GROUP_NAME)) {
            // --- Cache hit ---
            $this->_data = $data;
            return true;
        } else {
            // --- Cache miss ---
            if ($this->_sendRequestAndGetResponse()) {
                // So the remote server is ok...
                $this->save($this->_id, $this->_data, $this->_expires, CACHE_HTTP_REQUEST_GROUP_NAME);
                $this->save($this->_id2, $this->_data, 0, CACHE_HTTP_REQUEST_GROUP_NAME);
                return true;
            } else {
                if ($data_sav = $this->get($this->_id2, CACHE_HTTP_REQUEST_GROUP_NAME)) {
                    // Ok, the "recover cache" is available...
                    switch ($this->_mode) {
                    case CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY:
                        // We make a new local copy and keep it until it expires...
                        $this->save($this->_id, $data_sav, $this->_expires, CACHE_HTTP_REQUEST_GROUP_NAME);
                        $this->_data = $data_sav;
                        return true;
                        break;
                    case CACHE_HTTP_REQUEST_RETURN_FALSE:
                        // We return false
                        return false;
                        break;
                    case CACHE_HTTP_REQUEST_RETURN_PEAR_ERROR:
                        // We return a PEAR_Error!
                        return new Cache_Error('Remote file is not available!');
                        break;
                    }
                } else {
                    // It's terrible! The remote server is down and definitively no cache available!
                    return new Cache_Error('Remote server down and no cache available!');
                }
            }
        }
    }

    // --- Private Methods ---

    /**
    * Send HTTP request and get the response
    *
    * @return boolean success or not ?
    * @see HTTP_Request
    * @access private
    */
    function _sendRequestAndGetResponse()
    {
        $this->_request->sendRequest();
        $body = $this->_request->getResponseBody();
        $code = $this->_request->getResponseCode();
        $header = $this->_request->getResponseHeader();
        $this->_data = array(
            'body' => $body,
            'code' => $code,
            'header' => $header
        );
        return (($code==CACHE_HTTP_REQUEST_SUCCESS_RESPONSE_CODE) ? true : false);
    }

}
?>