├── HTMLProxyHandler.class.php
├── ProxyHandler.class.php
├── README.md
├── composer.json
└── examples
    ├── .htaccess
    ├── advanced.php
    ├── cloudflare.php
    ├── errors.php
    ├── https.php
    └── index.php


/HTMLProxyHandler.class.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | include 'ProxyHandler.class.php';
  3 | 
  4 | class HTMLProxyHandler extends ProxyHandler {
  5 |     /**
  6 |      * Base URI of proxy itself
  7 |      *
  8 |      * @type string
  9 |      */
 10 |     private $_proxyBaseUri = '';
 11 | 
 12 |     /**
 13 |      * Base URI of request being proxied
 14 |      *
 15 |      * @type string
 16 |      */
 17 |     private $_baseUri;
 18 | 
 19 |     /**
 20 |      * @type string
 21 |      */
 22 |     private $_anchorTarget;
 23 | 
 24 |     public function __construct($options)
 25 |     {
 26 |         if (isset($options['proxyBaseUri']))
 27 |             $this->_proxyBaseUri = $options['proxyBaseUri'];
 28 |         if (!isset($options['bufferedContentTypes']))
 29 |             $options['bufferedContentTypes'] = array('text/html', 'text/css', 'text/javascript', 'application/javascript');
 30 |         if (isset($options['anchorTarget']))
 31 |             $this->_anchorTarget = $options['anchorTarget'];
 32 |         parent::__construct($options);
 33 | 
 34 |         // build base URI
 35 |         $translatedUri = $this->getTranslatedUri();
 36 |         $parsed_url = parse_url($translatedUri);
 37 |         if (!isset($parsed_url['scheme']))
 38 |             $parsed_url['scheme'] = 'http';
 39 |         $path = isset($parsed_url['path']) ? $parsed_url['path'] : '/';
 40 |         $this->_baseUri = self::unparse_url_base($parsed_url) . $path;
 41 |     }
 42 | 
 43 |     protected static function unparse_url_base($parsed_url)
 44 |     { 
 45 |         $scheme   = isset($parsed_url['scheme']) ? $parsed_url['scheme'] . '://' : ''; 
 46 |         $host     = isset($parsed_url['host']) ? $parsed_url['host'] : ''; 
 47 |         $port     = isset($parsed_url['port']) ? ':' . $parsed_url['port'] : ''; 
 48 |         $user     = isset($parsed_url['user']) ? $parsed_url['user'] : ''; 
 49 |         $pass     = isset($parsed_url['pass']) ? ':' . $parsed_url['pass']  : ''; 
 50 |         $pass     = ($user || $pass) ? "$pass@" : ''; 
 51 |         return "$scheme$user$pass$host$port";
 52 |     } 
 53 |     
 54 |     protected static function unparse_url_request($parsed_url)
 55 |     {
 56 |         $path     = isset($parsed_url['path']) ? $parsed_url['path'] : ''; 
 57 |         $query    = isset($parsed_url['query']) ? '?' . $parsed_url['query'] : ''; 
 58 |         $fragment = isset($parsed_url['fragment']) ? '#' . $parsed_url['fragment'] : ''; 
 59 |         return "$path$query$fragment"; 
 60 |     }
 61 | 
 62 |     public function getProxyBaseUri()
 63 |     {
 64 |         return $this->_proxyBaseUri;
 65 |     }
 66 | 
 67 |     /**
 68 |     /* Converts relative URLs to absolute ones, given a base URL.
 69 |     /* Modified version of code found at http://nashruddin.com/PHP_Script_for_Converting_Relative_to_Absolute_URL
 70 |     /*
 71 |     /* taken from miniProxy: https://github.com/joshdick/miniProxy
 72 |      */
 73 |     public function rel2abs($rel)
 74 |     {
 75 |         if (preg_match(',^{{.*}}$,', $rel))
 76 |             return $rel;
 77 | 
 78 |         if (empty($rel))
 79 |             $rel = ".";
 80 |         if (parse_url($rel, PHP_URL_SCHEME) != "") {
 81 |             // return if already an absolute URL
 82 |             return $rel;
 83 |         }
 84 |         if (strpos($rel, '//') === 0) {
 85 |             // prepend scheme
 86 |             return parse_url($this->_baseUri, PHP_URL_SCHEME) . ':' . $rel;
 87 |         }
 88 |     
 89 |         if ($rel[0] == "#" || $rel[0] == "?")
 90 |             return $this->_baseUri.$rel; //Queries and anchors
 91 |     
 92 |         extract(parse_url($this->_baseUri)); //Parse base URL and convert to local variables: $scheme, $host, $path
 93 |         $path = isset($path) ? preg_replace('#/[^/]*$#', "", $path) : "/"; //Remove non-directory element from path
 94 |         if ($rel[0] == '/') $path = ""; //Destroy path if relative url points to root
 95 |         if (isset($port) && (($scheme == "http" && $port != 80) || ($scheme == "https" && $port != 443)))
 96 |             $port = ":" . $port;
 97 |         else
 98 |             $port = "";
 99 |         $auth = "";
100 |         if (isset($user)) {
101 |             $auth = $user;
102 |             if (isset($pass)) {
103 |               $auth .= ":" . $pass;
104 |             }
105 |             $auth .= "@";
106 |         }
107 |         $abs = "$auth$host$path$port/$rel"; //Dirty absolute URL
108 |         for ($n = 1; $n > 0; $abs = preg_replace(array("#(/\.?/)#", "#/(?!\.\.)[^/]+/\.\./#"), "/", $abs, -1, $n)) {} //Replace '//' or '/./' or '/foo/../' with '/'
109 |         return $scheme . "://" . $abs; //Absolute URL is ready.
110 |     }
111 | 
112 |     /**
113 |     /* Replace text content of DOMNode
114 |      */
115 |     public static function replaceTextContent($n, $value)
116 |     {
117 |         // $n->nodeValue = htmlspecialchars($value, ENT_NOQUOTES);
118 |         while ($n->hasChildNodes()) {
119 |                $n->removeChild($n->firstChild);
120 |         }
121 |     
122 |         $n->appendChild($n->ownerDocument->createTextNode($value));
123 |     }
124 | 
125 |     /**
126 |      * Proxify URL
127 |      */
128 |     public function proxifyURL($url, $parsed_url = null, $is_redirect = false)
129 |     {
130 |         if (preg_match(',^{{.*}}$,', $url))
131 |             return $url;
132 | 
133 |         $proxy_base_uri = $this->getProxyBaseUri();
134 |         if (substr($url, 0, strlen($proxy_base_uri)) == $proxy_base_uri)
135 |             return $url;
136 | 
137 |         if (!$parsed_url)
138 |             $parsed_url = parse_url($url);
139 | 
140 |         $scheme = isset($parsed_url['scheme']) ? $parsed_url['scheme'] : '';
141 |         if ($scheme != "http" && $scheme != "https" && $scheme != "ftp")
142 |             return $url;
143 |     
144 |         return $proxy_base_uri . $url;
145 |     }
146 |     
147 |     /**
148 |      * Proxify CSS
149 |      *
150 |      * taken from miniProxy https://github.com/joshdick/miniProxy
151 |      */
152 |     protected function proxifyCSS($buffer)
153 |     {
154 |         $proxy = $this;
155 |         return preg_replace_callback(
156 |             '/url\((.*?)\)/i',
157 |             function($matches) use ($proxy) {
158 |                 $url = $matches[1];
159 |                 // Remove any surrounding single or double quotes from the URL so it can be passed to rel2abs - the quotes are optional in CSS
160 |                 // Assume that if there is a leading quote then there should be a trailing quote, so just use trim() to remove them
161 |                 if (strpos($url, "'") === 0) {
162 |                     $url = trim($url, "'");
163 |                 }
164 |                 if (strpos($url, "\"") === 0) {
165 |                     $url = trim($url, "\"");
166 |                 }
167 |                 if (stripos($url, "data:") === 0) {
168 |                     // the url isn't an HTTP URL but is actual binary data. Don't proxify it
169 |                     return "url($url)";
170 |                 }
171 |                 $new_url = $proxy->proxifyURL($proxy->rel2abs($url));
172 |                 return "url($new_url)";
173 |             },
174 |             $buffer);
175 |     }
176 | 
177 |     // Proxify XMLHttpRequest
178 |     protected function proxifyXMLHttpRequest($elem)
179 |     {
180 |         // Attempt to force AJAX requests to be made through the proxy by
181 |         // wrapping window.XMLHttpRequest.prototype.open in order to make
182 |         // all request URLs absolute and point back to the proxy.
183 |         // The rel2abs() JavaScript function serves the same purpose as the server-side one in this file,
184 |         // but is used in the browser to ensure all AJAX request URLs are absolute and not relative.
185 |         // Uses code from these sources:
186 |         // http://stackoverflow.com/questions/7775767/javascript-overriding-xmlhttprequest-open
187 |         // https://gist.github.com/1088850
188 |         // TODO: This is obviously only useful for browsers that use XMLHttpRequest but
189 |         // it's better than nothing.
190 |       
191 |         //Only bother trying to apply this hack if the DOM has a <head> or <body> element;
192 |         //insert some JavaScript at the top of whichever is available first.
193 |         //Protects against cases where the server sends a Content-Type of "text/html" when
194 |         //what's coming back is most likely not actually HTML.
195 |         //TODO: Do this check before attempting to do any sort of DOM parsing?
196 |         $script = $elem->ownerDocument->createElement("script");
197 |         self::replaceTextContent($script,
198 |           '(function() {
199 |               window.proxifyURL = function(url) {
200 |                 function parseURI(url) {
201 |                   var m = String(url).replace(/^\s+|\s+$/g, "").match(/^([^:\/?#]+:)?(\/\/(?:[^:@]*(?::[^:@]*)?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);
202 |                   // authority = "//" + user + ":" + pass "@" + hostname + ":" port
203 |                   return (m ? {
204 |                     href : m[0] || "",
205 |                     protocol : m[1] || "",
206 |                     authority: m[2] || "",
207 |                     host : m[3] || "",
208 |                     hostname : m[4] || "",
209 |                     port : m[5] || "",
210 |                     pathname : m[6] || "",
211 |                     search : m[7] || "",
212 |                     hash : m[8] || ""
213 |                   } : null);
214 |                 }
215 |     
216 |                 function rel2abs(base, href) { // RFC 3986
217 |                     function removeDotSegments(input) {
218 |                         var output = [];
219 |                         input.replace(/^(\.\.?(\/|$))+/, "")
220 |                             .replace(/\/(\.(\/|$))+/g, "/")
221 |                             .replace(/\/\.\.$/, "/../")
222 |                             .replace(/\/?[^\/]*/g, function (p) {
223 |                                 if (p === "/..") {
224 |                                     output.pop();
225 |                                 } else {
226 |                                     output.push(p);
227 |                                 }
228 |                             });
229 |                         return output.join("").replace(/^\//, input.charAt(0) === "/" ? "/" : "");
230 |                     }
231 |     
232 |                     base = parseURI(base || "");
233 |     
234 |                     return !href || !base ? null : (href.protocol || base.protocol) +
235 |                         (href.protocol || href.authority ? href.authority : base.authority) +
236 |                         removeDotSegments(href.protocol || href.authority || href.pathname.charAt(0) === "/" ? href.pathname : (href.pathname ? ((base.authority && !base.pathname ? "/" : "") + base.pathname.slice(0, base.pathname.lastIndexOf("/") + 1) + href.pathname) : base.pathname)) +
237 |                         (href.protocol || href.authority || href.pathname ? href.search : (href.search || base.search)) +
238 |                         href.hash;
239 |                 }
240 |     
241 |                 if (url == null || url == "" || url.indexOf("'.$this->getProxyBaseUri().'") === 0)
242 |                     return url;
243 |                 href = parseURI(url || "");
244 |                 if (href.protocol && href.protocol != "http:" && href.protocol != "https:" && href.protocol != "ftp:")
245 |                     return url;
246 |     
247 |                 url = rel2abs("'.$this->_baseUri.'", href);
248 |                 return "'.$this->getProxyBaseUri().'" + url;
249 |             };
250 |     
251 |             function set_property_descriptor(name, property, descriptor)
252 |             {
253 |                 obj = document.createElement(name);
254 |                 try {
255 |                     Object.defineProperty(Object.getPrototypeOf(obj), property, descriptor);
256 |                 } catch (err) {
257 |                     //console.log("Failed to set property descriptor for " + name + " (" + property + ")");
258 |                 }
259 |             }
260 | 
261 |             if (window.XMLHttpRequest) {
262 |               var proxied = window.XMLHttpRequest.prototype.open;
263 |               window.XMLHttpRequest.prototype.open = function() {
264 |                   arguments[1] = window.proxifyURL(arguments[1]);
265 |                   return proxied.apply(this, [].slice.call(arguments));
266 |               };
267 |             }
268 | 
269 |             var src_descriptor = {
270 |                 get: function() {
271 |                     return this.getAttribute("src");
272 |                 },
273 |                 set: function(val) {
274 |                     this.setAttribute("src", window.proxifyURL(val));
275 |                 },
276 |             };
277 |             set_property_descriptor("img", "src", src_descriptor);
278 |             set_property_descriptor("script", "src", src_descriptor);
279 | 
280 |             var href_descriptor = {
281 |                 get: function() {
282 |                     return this.getAttribute("href");
283 |                 },
284 |                 set: function(val) {
285 |                     this.setAttribute("href", window.proxifyURL(val));
286 |                 },
287 |             };
288 |             set_property_descriptor("a", "href", href_descriptor);
289 |           })();'
290 |         );
291 |         $script->setAttribute("type", "text/javascript");
292 |     
293 |         $elem->insertBefore($script, $elem->firstChild);
294 |     }
295 | 
296 |     /**
297 |      * Proxify HTML
298 |      *
299 |      * partially taken from miniProxy https://github.com/joshdick/miniProxy
300 |      */
301 |     protected function proxifyHTML($buffer)
302 |     {
303 |         static $html_links = array(
304 |             'a' => 'href',
305 |             'area' => 'href',
306 |             'link' => 'href',
307 |             'img' => array('src', 'longdesc', 'usemap'),
308 |             'object' => array('classid', 'codebase', 'data', 'usemap'),
309 |             'q' => 'cite',
310 |             'blockquote' => 'cite',
311 |             'ins' => 'cite',
312 |             'del' => 'cite',
313 |             'form' => 'action',
314 |             'input' => array('src', 'usemap'),
315 |             'head' => 'profile',
316 |             'base' => 'href',
317 |             'script' => array('src', 'for')
318 |         );
319 |         static $html_links_xpath;
320 |         if (!$html_links_xpath) {
321 |             foreach ($html_links as $e => &$attrs) {
322 |               if (is_string($attrs))
323 |                   $attrs = array($attrs);
324 |               foreach ($attrs as $a) {
325 |                   if ($html_links_xpath)
326 |                       $html_links_xpath .= ' | ';
327 |                   $html_links_xpath .= '//' . $e . '[@' . $a . ']';
328 |               }
329 |             }
330 |         }
331 |     
332 |         $detectedEncoding = mb_detect_encoding($buffer, "UTF-8, ISO-8859-1");
333 |         if ($detectedEncoding) {
334 |             $buffer = mb_convert_encoding($buffer, "HTML-ENTITIES", $detectedEncoding);
335 |         }
336 |     
337 |         $xpath = $this->loadHTML($buffer);
338 |     
339 |         // proxify html links
340 |         foreach ($xpath->query($html_links_xpath) as $e) {
341 |             if (!array_key_exists($e->nodeName, $html_links))
342 |                 continue;
343 |     
344 |             foreach ($html_links[$e->nodeName] as $a) {
345 |                 $value = $e->getAttribute($a);
346 |                 if (!$value)
347 |                     continue;
348 | 
349 |                 $new_value = $this->proxifyURL($this->rel2abs($value));
350 |                 if ($new_value != $value) {
351 |                     $e->setAttribute($a, $new_value);
352 |                 }
353 |                 if ($e->nodeName == 'a' && $this->_anchorTarget) {
354 |                     if (!$e->getAttribute('target')) {
355 |                         $e->setAttribute('target', $this->_anchorTarget);
356 |                     }
357 |                 }
358 |             }
359 |         }
360 |     
361 |         // proxify tags with a "style" attribute
362 |         foreach ($xpath->query('//*[@style]') as $e) {
363 |             $value = $e->getAttribute('style');
364 |             $new_value = $this->proxifyCSS($value);
365 |             if ($new_value != $value) {
366 |                 $e->setAttribute('style', $new_value);
367 |             }
368 |         }
369 |     
370 |         // proxify <style> tags
371 |         foreach ($xpath->query('//style') as $e) {
372 |             $value = $e->textContent;
373 |             if (!$value)
374 |                 continue;
375 |             $new_value = $this->proxifyCSS($value);
376 |             if ($new_value != $value) {
377 |                 self::replaceTextContent($e, $new_value);
378 |             }
379 |         }
380 |     
381 |         // proxify <script> tags
382 |         foreach ($xpath->query('//script[@type="text/javascript"]') as $e) {
383 |             $value = $e->textContent;
384 |             if (!$value)
385 |                 continue;
386 |             $new_value = $this->proxifyJS($value);
387 |             if ($new_value != $value) {
388 |                 self::replaceTextContent($e, $new_value);
389 |             }
390 |         }
391 | 
392 |         // proxify XMLHttpRequest
393 |         $head = $xpath->query('//head')->item(0);
394 |         $body = $xpath->query('//body')->item(0);
395 |         $root = $head != null ? $head : $body;
396 |         if ($root != null) {
397 |             $this->proxifyXMLHttpRequest($root);
398 |         }
399 | 
400 |         return $this->saveHTML($xpath);
401 |     }
402 | 
403 |     /**
404 |      * Proxify JavaScript
405 |      */
406 |     protected function proxifyJS($buffer)
407 |     {
408 |         return $buffer;
409 |     }
410 | 
411 |     /**
412 |      * Load HTML document
413 |      */
414 |     protected function loadHTML($buffer)
415 |     {
416 |         // workaround for parsing [<>] inside <script>
417 |         $buffer = preg_replace_callback(',(<script.*?>)(.*?)(</script>),',
418 |             function ($matches) {
419 |                 $text = str_replace(
420 |                     array('<', '>'),
421 |                     array('&lt;', '&gt;'),
422 |                     $matches[2]);
423 |                 return $matches[1].$text.$matches[3];
424 |             }, $buffer);
425 | 
426 |         $doc = new DOMDocument();
427 |         @$doc->loadHTML($buffer, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
428 |         return new DOMXpath($doc);
429 |     }
430 | 
431 |     /**
432 |      * Save HTML document
433 |      */
434 |     protected function saveHTML($xpath)
435 |     {
436 |         foreach ($xpath->query('//script') as $e) {
437 |             $value = $e->textContent;
438 |             if (!$value)
439 |                 continue;
440 |             $new_value = str_replace(
441 |                 array('&lt;', '&gt;'),
442 |                 array('<', '>'),
443 |                 $value);
444 |             if ($new_value != $value) {
445 |                 self::replaceTextContent($e, $new_value);
446 |             }
447 |         }
448 | 
449 |         // fix templates
450 |         return preg_replace(',%7B%7B([\w\.]+?)%7D%7D,', '{{$1}}', $xpath->document->saveHTML());
451 |     }
452 | 
453 |     /**
454 |      * Process buffered output
455 |      */
456 |     protected function processOutput()
457 |     {
458 |         if (!$this->isBuffered()) {
459 |             // nothing to do
460 |             return;
461 |         }
462 | 
463 |         $buffer = $this->getBuffer();
464 |         $content_type = $this->getContentType();
465 |         if ($content_type == "text/html") {
466 |             $buffer = $this->proxifyHTML($buffer);
467 |         } elseif ($content_type == "text/css") {
468 |             $buffer = $this->proxifyCSS($buffer);
469 |         } elseif (in_array($content_type, array("text/javascript", "application/javascript"))) {
470 |             $buffer = $this->proxifyJS($buffer);
471 |         }
472 |         $content_length = strlen($buffer);
473 |         header("Content-Length: $content_length");
474 |         echo($buffer);
475 |     }
476 | }
477 | 
478 | // vi: ts=4:sw=4:et:
479 | ?>
480 | 


--------------------------------------------------------------------------------
/ProxyHandler.class.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * php5rp_ng - PHP5 Reverse Proxy Next Generation
  4 |  *
  5 |  * @link      https://github.com/chricke/php5rp_ng
  6 |  * @copyright Copyright (c) 2010, 2013 Christian "chricke" Beckmann < mail@christian-beckmann.net >.
  7 |  * @license   https://github.com/chricke/php5rp_ng/blob/master/README.md BSD license.
  8 |  */
  9 | 
 10 | class ProxyHandler
 11 | {
 12 |     /**
 13 |      * @type string
 14 |      */
 15 |     const RN = "\r\n";
 16 | 
 17 |     /**
 18 |      * @type string
 19 |      */
 20 |     private $_translatedUri;
 21 |     /**
 22 |      * @type boolean
 23 |      */
 24 |     private $_cacheControl = false;
 25 |     /**
 26 |      * @type boolean
 27 |      */
 28 |     private $_chunked = false;
 29 |     /**
 30 |      * @type boolean
 31 |      */
 32 |     private $_buffered = false;
 33 |     /**
 34 |      * @type array
 35 |      */
 36 |     private $_bufferedContentTypes = array();
 37 |     /**
 38 |      * @type string
 39 |      */
 40 |     private $_contentType;
 41 |     /**
 42 |      * @type string
 43 |      */
 44 |     private $_buffer = '';
 45 |     /**
 46 |      * @type boolean
 47 |      */
 48 |     private $_follow_location = false;
 49 |     /**
 50 |      * @type string
 51 |      */
 52 |     private $_location = null;
 53 |     /**
 54 |      * @type array
 55 |      */
 56 |     private $_clientHeaders = array();
 57 |     /**
 58 |      * @type resource
 59 |      */
 60 |     private $_curlHandle;
 61 |     /**
 62 |      * @type boolean
 63 |      */
 64 |     private $_pragma = false;
 65 | 
 66 |     /**
 67 |      * Create a new ProxyHandler
 68 |      *
 69 |      * @param array|string $options
 70 |      */
 71 |     function __construct($options)
 72 |     {
 73 |         if (is_string($options)) {
 74 |             $options = array('proxyUri' => $options);
 75 |         }
 76 |         if (isset($options['forceBuffered']))
 77 |             $this->_buffered = true;
 78 |         if (isset($options['forceContentType']))
 79 |             $this->_contentType = $options['forceContentType'];
 80 |         if (isset($options['bufferedContentTypes']))
 81 |             $this->_bufferedContentTypes = $options['bufferedContentTypes'];
 82 | 
 83 |         // Trim slashes, we will append what is needed later
 84 |         $this->_translatedUri = rtrim($options['proxyUri'], '/');
 85 | 
 86 |         // Get all parameters from options
 87 | 
 88 |         $baseUri = '';
 89 |         if (isset($options['baseUri'])) {
 90 |             $baseUri = $options['baseUri'];
 91 |         }
 92 |         elseif (!empty($options['proxyUri'])) {
 93 |             $baseUri = parse_url($options['proxyUri'], PHP_URL_PATH);
 94 |             $baseUri = dirname($baseUri);
 95 |         }
 96 | 
 97 |         $requestUri = '';
 98 |         if (isset($options['requestUri'])) {
 99 |             $requestUri = $options['requestUri'];
100 |         }
101 |         else {
102 |             if (!empty($_SERVER['REQUEST_URI'])) {
103 |                 $requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
104 |             }
105 |             if (!empty($_SERVER['QUERY_STRING'])) {
106 |                 $requestUri .= '?' . $_SERVER['QUERY_STRING'];
107 |             }
108 |         }
109 | 
110 |         if (!empty($requestUri)) {
111 |             if (!empty($baseUri)) {
112 |                 $baseUriLength = strlen($baseUri);
113 |                 if (substr($requestUri, 0, $baseUriLength) === $baseUri) {
114 |                     $requestUri = substr($requestUri, $baseUriLength);
115 |                 }
116 |             }
117 |             $this->_translatedUri .= $requestUri;
118 |         }
119 |         else {
120 |             $this->_translatedUri .= '/';
121 |         }
122 | 
123 |         $this->_curlHandle = curl_init($this->_translatedUri);
124 | 
125 |         // Set various cURL options
126 |         if (!isset($options['noFollowLocation'])) {
127 |             $this->_follow_location = true;
128 |             $this->setCurlOption(CURLOPT_FOLLOWLOCATION, true);
129 |         }
130 |         if (isset($options['forceHttpVersion'])) {
131 |             $v = $options['forceHttpVersion'];
132 |             switch ($options['forceHttpVersion']) {
133 |             case 'HTTP/1.0':
134 |                 $this->setCurlOption(CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
135 |                 break;
136 |             case 'HTTP/1.1':
137 |                 $this->setCurlOption(CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
138 |                 break;
139 |             default:
140 |                 $this->setCurlOption(CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_NONE);
141 |                 break;
142 |             }
143 |         }
144 |         $this->setCurlOption(CURLOPT_RETURNTRANSFER, true);
145 |         // For images, etc.
146 |         $this->setCurlOption(CURLOPT_BINARYTRANSFER, true);
147 |         $this->setCurlOption(CURLOPT_WRITEFUNCTION, array($this, 'readResponse'));
148 |         $this->setCurlOption(CURLOPT_HEADERFUNCTION, array($this, 'readHeaders'));
149 | 
150 |         $requestMethod = '';
151 |         if (isset($options['requestMethod'])) {
152 |             $requestMethod = $options['requestMethod'];
153 |         }
154 |         elseif (!empty($_SERVER['REQUEST_METHOD'])) {
155 |             $requestMethod = $_SERVER['REQUEST_METHOD'];
156 |         }
157 | 
158 |         // Default cURL request method is 'GET'
159 |         if ($requestMethod !== 'GET') {
160 |             $this->setCurlOption(CURLOPT_CUSTOMREQUEST, $requestMethod);
161 | 
162 |             $inputStream = isset($options['inputStream']) ? $options['inputStream'] : 'php://input';
163 | 
164 |             switch($requestMethod) {
165 |                 case 'POST':
166 |                 case 'PATCH':
167 |                     $data = '';
168 |                     if (isset($options['data'])) {
169 |                         $data = $options['data'];
170 |                     }
171 |                     else {
172 |                         if (!isset($HTTP_RAW_POST_DATA)) {
173 |                             $HTTP_RAW_POST_DATA = file_get_contents($inputStream);
174 |                         }
175 |                         $data = $HTTP_RAW_POST_DATA;
176 |                     }
177 |                     $this->setCurlOption(CURLOPT_POSTFIELDS, $data);
178 |                     break;
179 |                     
180 |                 case 'PUT':
181 |                     // Set the request method.
182 |                     $this->setCurlOption(CURLOPT_UPLOAD, 1);
183 |                     // PUT data comes in on the stdin stream.
184 |                     $putData = fopen($inputStream, 'r');
185 |                     $this->setCurlOption(CURLOPT_READDATA, $putData);
186 |                     // TODO: set CURLOPT_INFILESIZE to the value of Content-Length.
187 |                     break;
188 |             }
189 |         }
190 | 
191 |         // Handle the client headers.
192 |         $this->handleClientHeaders();
193 |     }
194 | 
195 |     /**
196 |      * @return array
197 |      */
198 |     private function _getRequestHeaders()
199 |     {
200 |         if (function_exists('apache_request_headers')) {
201 |             if ($headers = apache_request_headers()) {
202 |                 return $headers;
203 |             }
204 |         }
205 | 
206 |         $headers = array();
207 |         foreach ($_SERVER as $key => $value) {
208 |             if (substr($key, 0, 5) == 'HTTP_' && !empty($value)) {
209 |                 $headerName = strtolower(substr($key, 5, strlen($key)));
210 |                 $headerName = str_replace(' ', '-', ucwords(str_replace('_', ' ', $headerName)));
211 |                 $headers[$headerName] = $value;
212 |             }
213 |         }
214 |         return $headers;
215 |     }
216 | 
217 |     /**
218 |      * @param string $headerName
219 |      * @return void
220 |      */
221 |     protected function _removeHeader($headerName)
222 |     {
223 |         if (function_exists('header_remove')) {
224 |             header_remove($headerName);
225 |         } else {
226 |             header($headerName . ': ');
227 |         }
228 |     }
229 | 
230 |     /**
231 |      * Adds the remote servers address to the 'X-Forwarded-For' headers,
232 |      * sets the 'X-Real-IP' header to the first address forwarded to and
233 |      * removes some headers we shouldn't pass through.
234 |      *
235 |      * @return void
236 |      */
237 |     protected function handleClientHeaders()
238 |     {
239 |         $headers = $this->_getRequestHeaders();
240 |         $xForwardedFor = array();
241 | 
242 |         foreach ($headers as $headerName => $value) {
243 |             switch($headerName) {
244 |                 case 'Host':
245 |                 case 'X-Real-IP':
246 |                 case 'Accept-Encoding':
247 |                     break;
248 |                     
249 |                 case 'X-Forwarded-For':
250 |                     $xForwardedFor[] = $value;
251 |                     break;
252 |                     
253 |                 default:
254 |                     $this->setClientHeader($headerName, $value);
255 |                     break;
256 |             }
257 |         }
258 | 
259 |         $xForwardedFor[] = $_SERVER['REMOTE_ADDR'];
260 |         $this->setClientHeader('X-Forwarded-For', implode(',', $xForwardedFor));
261 |         $this->setClientHeader('X-Real-IP', $xForwardedFor[0]);
262 |     }
263 | 
264 |     /**
265 |      * Our handler for cURL option CURLOPT_HEADERFUNCTION
266 |      *
267 |      * @param resource $cu
268 |      * @param string $string
269 |      * @return int
270 |      */
271 |     protected function readHeaders(&$cu, $header)
272 |     {
273 |         $length = strlen($header);
274 | 
275 |         $matches = array();
276 |         if (preg_match(',^Cache-Control:,', $header)) {
277 |             $this->_cacheControl = true;
278 |         }
279 |         elseif (preg_match(',^Pragma:,', $header)) {
280 |             $this->_pragma = true;
281 |         }
282 |         elseif (preg_match(',^Transfer-Encoding:,', $header)) {
283 |             $this->_chunked = strpos($header, 'chunked') !== false;
284 |         }
285 |         elseif (preg_match(',^Location:\s*(.*),', $header, $matches)) {
286 |             $this->_location = trim($matches[1]);
287 |         }
288 | 
289 |         if ($header !== self::RN) {
290 |             header(rtrim($header), false);
291 |         }
292 | 
293 |         return $length;
294 |     }
295 | 
296 |     /**
297 |      * Our handler for cURL option CURLOPT_WRITEFUNCTION
298 |      *
299 |      * @param resource $cu
300 |      * @param string $body
301 |      * @return int
302 |      */
303 |     protected function readResponse(&$cu, $body)
304 |     {
305 |         static $headersParsed = false;
306 | 
307 |         // Clear the Cache-Control and Pragma headers
308 |         // if they aren't passed from the proxy application.
309 |         if ($headersParsed === false) {
310 |             if (!$this->_cacheControl) {
311 |                 $this->_removeHeader('Cache-Control');
312 |             }
313 |             if (!$this->_pragma) {
314 |                 $this->_removeHeader('Pragma');
315 |             }
316 |             $info = $this->getCurlInfo();
317 |             if (isset($info['content_type']) && !isset($this->_contentType)) {
318 |                 $this->_contentType = preg_replace('/;.*/', '', $info['content_type']);
319 |             }
320 |             if (isset($this->_contentType) && in_array($this->_contentType, $this->_bufferedContentTypes)) {
321 |                 $this->_buffered = true;
322 |             }
323 |             if (!$this->_follow_location && $this->getLocation())
324 |                 $this->_buffered = true;
325 |             if ($this->_buffered) {
326 |                 $this->_removeHeader('Content-Length');
327 |                 $this->_removeHeader('Transfer-Encoding');
328 |                 $this->_removeHeader('Content-Encoding');
329 |             } elseif ($this->_chunked) {
330 |                 flush();
331 |             }
332 |             $headersParsed = true;
333 |         }
334 | 
335 |         $length = strlen($body);
336 |         if ($this->_buffered) {
337 |             $this->_buffer .= $body;
338 |         } elseif ($this->_chunked) {
339 |             echo dechex($length) . self::RN . $body . self::RN;
340 |         } else {
341 |             echo $body;
342 |         }
343 |         return $length;
344 |     }
345 | 
346 |     /**
347 |      * Close the cURL handle and a possible chunked response
348 |      *
349 |      * @return void
350 |      */
351 |     public function close()
352 |     {
353 |         if (!$this->_buffered && $this->_chunked) {
354 |             echo '0' . self::RN . self::RN;
355 |         }
356 |         curl_close($this->_curlHandle);
357 |     }
358 | 
359 |     /**
360 |      * Executes the cURL handler, making the proxy request.
361 |      * Returns true if request is successful, false if there was an error.
362 |      * By checking this return, you may output the return from getCurlError
363 |      * Or output your own bad gateway page.
364 |      *
365 |      * @return boolean
366 |      */
367 |     public function execute()
368 |     {
369 |         $this->setCurlOption(CURLOPT_HTTPHEADER, $this->_clientHeaders);
370 |         return curl_exec($this->_curlHandle) !== false;
371 |     }
372 | 
373 |     /**
374 |      * Get possible cURL error.
375 |      * Should NOT be called before exec.
376 |      *
377 |      * @return string
378 |      */
379 |     public function getCurlError()
380 |     {
381 |         return curl_error($this->_curlHandle);
382 |     }
383 | 
384 |     /**
385 |      * Get information about the request.
386 |      * Should NOT be called before exec.
387 |      *
388 |      * @return array
389 |      */
390 |     public function getCurlInfo()
391 |     {
392 |         return curl_getinfo($this->_curlHandle);
393 |     }
394 | 
395 |     /**
396 |      * Sets a new header that will be sent with the proxy request
397 |      *
398 |      * @param string $headerName
399 |      * @param string $value
400 |      * @return void
401 |      */
402 |     public function setClientHeader($headerName, $value)
403 |     {
404 |         $this->_clientHeaders[] = $headerName . ': ' . $value;
405 |     }
406 | 
407 |     /**
408 |      * Sets a cURL option.
409 |      *
410 |      * @param string $option
411 |      * @param string $value
412 |      * @return void
413 |      */
414 |     public function setCurlOption($option, $value)
415 |     {
416 |         curl_setopt($this->_curlHandle, $option, $value);
417 |     }
418 | 
419 |     /**
420 |      * Returns translated uri
421 |      */
422 |     public function getTranslatedUri()
423 |     {
424 |         return $this->_translatedUri;
425 |     }
426 | 
427 |     /**
428 |      * Returns true if request is buffered
429 |      */
430 |     public function isBuffered()
431 |     {
432 |         return $this->_buffered;
433 |     }
434 | 
435 |     /**
436 |      * Returns buffer
437 |      */
438 |     public function getBuffer()
439 |     {
440 |         return $this->_buffer;
441 |     }
442 | 
443 |     /**
444 |      * Returns content type
445 |      */
446 |     public function getContentType()
447 |     {
448 |         return $this->_contentType;
449 |     }
450 | 
451 |     /**
452 |      * Returns redirect location (if any)
453 |      */
454 |     public function getLocation()
455 |     {
456 |         return $this->_location;
457 |     }
458 | }
459 | 
460 | // vi: ts=4:sw=4:et:
461 | ?>
462 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # php5rp_ng
 2 | ### PHP5 Reverse Proxy Next Generation
 3 | 
 4 | # This software is no longer maintained. If you really want to use this please make sure you also read the infos under "Issues".
 5 | 
 6 | ### Description
 7 | 
 8 | php5rp_ng is a fork of <http://code.google.com/p/php5rp/> with all issues fixed
 9 | which are listed under <http://code.google.com/p/php5rp/issues/list>.
10 | 
11 | This is a reverse proxy written in PHP5. It uses cURL to handle the back-end connections.
12 | 
13 | What is it useful for? Some uses may include:
14 | 
15 | - Extend the class to add an SSO layer to back-end app servers not written in PHP
16 | - Extend to handle authorization and authentication to a back-end database (SVN, for example)
17 | 
18 | ### Installation
19 | 
20 | Example files on how to use it are available in the examples folder.
21 | 
22 | ### Report Bugs
23 | 
24 | Whenever you are bitten by any quirks, please don't hesitate to
25 | 
26 | 1.  send a bug report or even patches to <mail@christian-beckmann.net>,
27 | 2.  or create a ticket on the issue tracking interface
28 |     (<https://github.com/chricke/php5rp_ng/issues>)
29 |     provided by GitHub.
30 | 
31 | ### Source Repository
32 | 
33 | - Available on github at chricke/php5rp_ng (<https://github.com/chricke/php5rp_ng>).
34 | 
35 | ### TODO
36 | 
37 | - [ ] Add caching functionality
38 | 
39 | ### Authors
40 | 
41 | - Christian "chricke" Beckmann < mail@christian-beckmann.net >
42 | - drkibitz < info@drkibitz.com >
43 | - Brian Nelson < mrpoundsign@gmail.com >
44 | 
45 | ### Copyright & License
46 | 
47 |     Copyright (c) 2010, 2011 Christian "chricke" Beckmann < mail@christian-beckmann.net >.
48 | 
49 |     This software is licensed under the terms of the BSD license.
50 | 
51 |     Redistribution and use in source and binary forms, with or without
52 |     modification, are permitted provided that the following conditions are
53 |     met:
54 | 
55 |     *   Redistributions of source code must retain the above copyright
56 |         notice, this list of conditions and the following disclaimer.
57 | 
58 |     *   Redistributions in binary form must reproduce the above copyright
59 |         notice, this list of conditions and the following disclaimer in the
60 |         documentation and/or other materials provided with the distribution.
61 | 
62 |     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
63 |     IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
64 |     TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
65 |     PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
66 |     HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
67 |     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
68 |     TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
69 |     PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
70 |     LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
71 |     NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
72 |     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
73 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "archive": {
 3 |         "exclude": ["/examples"]
 4 |     },
 5 |     "authors": [
 6 |         {
 7 |             "name": "Brian Nelson",
 8 |             "email": "mrpoundsign@gmail.com"
 9 |         }, {
10 |             "name": "Christian \"chricke\" Beckmann",
11 |             "email": "mail@christian-beckmann.net",
12 |             "homepage": "http://http://christian-beckmann.net/"
13 |         }, {
14 |             "name": "drkibitz",
15 |             "email": "info@drkibitz.com",
16 |             "homepage": "http://drkibitz.com/"
17 |         }
18 |     ],
19 |     "autoload": {
20 |         "classmap": ["ProxyHandler.class.php"]
21 |     },
22 |     "name": "chricke/php5rp_ng",
23 |     "description": "PHP5 Reverse Proxy Next Generation",
24 |     "homepage": "http://chricke.github.io/php5rp_ng/",
25 |     "keywords": ["http", "proxy", "reverse", "curl"],
26 |     "license": "BSD-2-Clause",
27 |     "require": {
28 |         "php": ">=5.2"
29 |     },
30 |     "support": {
31 |         "email": "mail@christian-beckmann.net",
32 |         "issues": "https://github.com/chricke/php5rp_ng/issues",
33 |         "source": "https://github.com/chricke/php5rp_ng/"
34 |     },
35 |     "version": "1.0.0"
36 | }
37 | 


--------------------------------------------------------------------------------
/examples/.htaccess:
--------------------------------------------------------------------------------
1 | RewriteEngine On
2 | 
3 | RewriteCond %{REQUEST_FILENAME} !-l [NC]
4 | RewriteCond %{REQUEST_FILENAME} !-f [NC]
5 | RewriteCond %{REQUEST_FILENAME} !-d [NC]
6 | RewriteCond %{REQUEST_URI} !^/index.php
7 | RewriteRule ^(.+)$ index.php/$1 [QSA]
8 | 


--------------------------------------------------------------------------------
/examples/advanced.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function sendBadGateWay($message = 'proxy handler') {
 4 |     // Set status header
 5 |     $protocol = (isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0');
 6 |     header($protocol . ' 502: Bad Gateway');
 7 | 
 8 |     // Output error page
 9 | ?><html>
10 | <head><title>502 Bad Gateway</title></head>
11 | <body bgcolor="white">
12 | <center><h1>502 Bad Gateway</h1></center>
13 | <hr><center><?php echo $message; ?></center>
14 | </body>
15 | </html>
16 | <?php
17 | 
18 |     // You've probably seen this in other servers ;)
19 |     echo str_repeat("<!-- a padding to disable MSIE and Chrome friendly error page -->\n", 6);
20 |     exit;
21 | }
22 | 
23 | if (!@include __DIR__ . '/../ProxyHandler.class.php') {
24 |     sendBadGateWay('Could not load proxy');
25 | }
26 | 
27 | /* EXPECTED RESPONSE:
28 | {
29 |    "object_or_array": "object",
30 |    "empty": false,
31 |    "parse_time_nanoseconds": <int>,
32 |    "validate": true,
33 |    "size": 1
34 | }
35 | */
36 | 
37 | $proxy = new ProxyHandler(array(
38 |     'proxyUri' => 'http://validate.jsontest.com',
39 |     'requestMethod' => 'POST',
40 |     'data' => 'json=' . json_encode(array('some_key' => 'some_value'))
41 | ));
42 | 
43 | // Prevents cURL from hanging on errors
44 | $proxy->setCurlOption(CURLOPT_CONNECTTIMEOUT, 1);
45 | $proxy->setCurlOption(CURLOPT_TIMEOUT, 5);
46 | 
47 | // Check for a success
48 | if ($proxy->execute()) {
49 |     //print_r($proxy->getCurlInfo()); // Uncomment to see request info
50 | } else {
51 |     sendBadGateWay($proxy->getCurlError());
52 | }
53 | 
54 | $proxy->close();
55 | 


--------------------------------------------------------------------------------
/examples/cloudflare.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (!@include __DIR__ . '/../ProxyHandler.class.php') {
 4 |     die('Could not load proxy');
 5 | }
 6 | 
 7 | /**
 8 |  * CloudFlare doesn't allow a request to certain IPs
 9 |  * Namely the same IP the request is coming from.
10 |  * Stripping CloudFlare headers allows this.
11 |  */
12 | class CloudFlareSafeProxy extends ProxyHandler
13 | {
14 |     public function setClientHeader($headerName, $value) {
15 |         if (substr($headerName, 0, 3) !== 'Cf-') {
16 |             parent::setClientHeader($headerName, $value);
17 |         }
18 |     }
19 | }
20 | 
21 | $proxy = new CloudFlareSafeProxy('http://internal.example.org');
22 | 
23 | // Check for a success
24 | if ($proxy->execute()) {
25 |     //print_r($proxy->getCurlInfo()); // Uncomment to see request info
26 | } else {
27 |     echo $proxy->getCurlError();
28 | }
29 | 
30 | $proxy->close();
31 | 


--------------------------------------------------------------------------------
/examples/errors.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function sendBadGateWay($message = 'proxy handler') {
 4 |     // Set status header
 5 |     $protocol = (isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0');
 6 |     header($protocol . ' 502: Bad Gateway');
 7 | 
 8 |     // Output error page
 9 | ?><html>
10 | <head><title>502 Bad Gateway</title></head>
11 | <body bgcolor="white">
12 | <center><h1>502 Bad Gateway</h1></center>
13 | <hr><center><?php echo $message; ?></center>
14 | </body>
15 | </html>
16 | <?php
17 | 
18 |     // You've probably seen this in other servers ;)
19 |     echo str_repeat("<!-- a padding to disable MSIE and Chrome friendly error page -->\n", 6);
20 |     exit;
21 | }
22 | 
23 | if (!@include __DIR__ . '/../ProxyHandler.class.php') {
24 |     sendBadGateWay('Could not load proxy');
25 | }
26 | 
27 | $proxy = new ProxyHandler('http://internal.example.org');
28 | 
29 | // Prevents cURL from hanging on errors
30 | $proxy->setCurlOption(CURLOPT_CONNECTTIMEOUT, 1);
31 | $proxy->setCurlOption(CURLOPT_TIMEOUT, 5);
32 | 
33 | // Check for a success
34 | if ($proxy->execute()) {
35 |     //print_r($proxy->getCurlInfo()); // Uncomment to see request info
36 | } else {
37 |     sendBadGateWay($proxy->getCurlError());
38 | }
39 | 
40 | $proxy->close();
41 | 


--------------------------------------------------------------------------------
/examples/https.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (!@include __DIR__ . '/../ProxyHandler.class.php') {
 4 |     die('Could not load proxy');
 5 | }
 6 | 
 7 | $proxy = new ProxyHandler('https://raw.github.com/chricke/php5rp_ng/master/README.md');
 8 | 
 9 | // Prevents cURL from hanging on errors
10 | $proxy->setCurlOption(CURLOPT_CONNECTTIMEOUT, 1);
11 | $proxy->setCurlOption(CURLOPT_TIMEOUT, 5);
12 | 
13 | // This ignores HTTPS certificate verification, libcurl decided not to bundle ca certs anymore.
14 | // Alternatively, specify CURLOPT_CAINFO, or CURLOPT_CAPATH if you have access to your cert(s)
15 | $proxy->setCurlOption(CURLOPT_SSL_VERIFYPEER, false);
16 | 
17 | // Check for a success
18 | if ($proxy->execute()) {
19 |     //print_r($proxy->getCurlInfo()); // Uncomment to see request info
20 | } else {
21 |     echo $proxy->getCurlError();
22 | }
23 | 
24 | $proxy->close();
25 | 


--------------------------------------------------------------------------------
/examples/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (!@include __DIR__ . '/../ProxyHandler.class.php') {
 4 |     die('Could not load proxy');
 5 | }
 6 | 
 7 | $proxy = new ProxyHandler('http://internal.example.org');
 8 | 
 9 | // Check for a success
10 | if ($proxy->execute()) {
11 |     //print_r($proxy->getCurlInfo()); // Uncomment to see request info
12 | } else {
13 |     echo $proxy->getCurlError();
14 | }
15 | 
16 | $proxy->close();
17 | 


--------------------------------------------------------------------------------