File: /var/www/html/tmpr/../tmpr/../tmpr/../scraper/web_server.php
<?php
// CubicleSoft PHP WebServer class.
// (C) 2018 CubicleSoft. All Rights Reserved.
// Make sure PHP doesn't introduce weird limitations.
ini_set("memory_limit", "-1");
set_time_limit(0);
// Requires the CubicleSoft PHP HTTP class.
// Compression support requires the CubicleSoft PHP DeflateStream class.
class WebServer
{
private $fp, $ssl, $initclients, $clients, $readreadyclients, $writereadyclients, $nextclientid;
private $defaulttimeout, $defaultclienttimeout, $maxrequests, $defaultclientoptions, $usegzip, $cachedir;
public function __construct()
{
$this->Reset();
}
public function Reset()
{
if (!class_exists("HTTP", false)) require_once str_replace("\\", "/", dirname(__FILE__)) . "/http.php";
$this->fp = false;
$this->ssl = false;
$this->initclients = array();
$this->clients = array();
$this->readreadyclients = array();
$this->writereadyclients = array();
$this->nextclientid = 1;
$this->defaulttimeout = 30;
$this->defaultclienttimeout = 30;
$this->maxrequests = 30;
$this->defaultclientoptions = array();
$this->usegzip = false;
$this->cachedir = false;
}
public function __destruct()
{
$this->Stop();
}
public function SetDefaultTimeout($timeout)
{
$this->defaulttimeout = (int)$timeout;
}
public function SetDefaultClientTimeout($timeout)
{
$this->defaultclienttimeout = (int)$timeout;
}
public function SetMaxRequests($num)
{
$this->maxrequests = (int)$num;
}
public function SetDefaultClientOptions($options)
{
$this->defaultclientoptions = $options;
}
public function EnableCompression($compress)
{
if (!class_exists("DeflateStream", false)) require_once str_replace("\\", "/", dirname(__FILE__)) . "/deflate_stream.php";
$this->usegzip = (bool)$compress;
}
public static function MakeTempDir($prefix, $perms = 0770)
{
$dir = sys_get_temp_dir();
$dir = str_replace("\\", "/", $dir);
if (substr($dir, -1) !== "/") $dir .= "/";
$dir .= $prefix . "_" . getmypid() . "_" . microtime(true);
@mkdir($dir, 0770, true);
@chmod($dir, $perms);
return $dir;
}
public function SetCacheDir($cachedir)
{
if ($cachedir !== false)
{
$cachedir = str_replace("\\", "/", $cachedir);
if (substr($cachedir, -1) !== "/") $cachedir .= "/";
}
$this->cachedir = $cachedir;
}
public function GetCacheDir()
{
return $this->cachedir;
}
// Starts the server on the host and port.
// $host is usually 0.0.0.0 or 127.0.0.1 for IPv4 and [::0] or [::1] for IPv6.
public function Start($host, $port, $sslopts = false)
{
$this->Stop();
$context = stream_context_create();
if (is_array($sslopts))
{
stream_context_set_option($context, "ssl", "ciphers", HTTP::GetSSLCiphers());
stream_context_set_option($context, "ssl", "disable_compression", true);
stream_context_set_option($context, "ssl", "allow_self_signed", true);
stream_context_set_option($context, "ssl", "verify_peer", false);
// 'local_cert' and 'local_pk' are common options.
foreach ($sslopts as $key => $val)
{
stream_context_set_option($context, "ssl", $key, $val);
}
$this->ssl = true;
}
$this->fp = stream_socket_server("tcp://" . $host . ":" . $port, $errornum, $errorstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context);
if ($this->fp === false) return array("success" => false, "error" => HTTP::HTTPTranslate("Bind() failed. Reason: %s (%d)", $errorstr, $errornum), "errorcode" => "bind_failed");
// Enable non-blocking mode.
stream_set_blocking($this->fp, 0);
return array("success" => true);
}
public function Stop()
{
if ($this->fp !== false)
{
foreach ($this->initclients as $id => $client)
{
@fclose($client->fp);
}
foreach ($this->clients as $id => $client)
{
$this->RemoveClient($id);
}
fclose($this->fp);
$this->initclients = array();
$this->clients = array();
$this->readreadyclients = array();
$this->writereadyclients = array();
$this->fp = false;
$this->ssl = false;
}
$this->nextclientid = 1;
}
// Dangerous but allows for stream_select() calls on multiple, separate stream handles.
public function GetStream()
{
return $this->fp;
}
public function AddClientRecvHeader($id, $name, $val)
{
if ($name === "" && $val === "") return;
$client = $this->clients[$id];
if (substr($name, -2) !== "[]") $client->requestvars[$name] = $val;
else
{
$name = substr($name, 0, -2);
if (!isset($client->requestvars[$name]) || !is_array($client->requestvars[$name])) $client->requestvars[$name] = array();
$client->requestvars[$name][] = $val;
}
}
public function ProcessClientRequestHeaders($request, $headers, $id)
{
if (!isset($this->clients[$id])) return false;
$client = $this->clients[$id];
$client->request = $request;
$client->headers = array();
foreach ($headers as $key => $vals)
{
$client->headers[$key] = $vals[count($vals) - 1];
}
if (isset($client->headers["Content-Type"])) $client->contenttype = HTTP::ExtractHeader($client->headers["Content-Type"]);
if (isset($client->headers["Host"])) $client->headers["Host"] = preg_replace('/[^a-z0-9.:\[\]_-]/', "", strtolower($client->headers["Host"]));
$client->url = (substr($request["path"], 0, 1) === "/" ? ($client->ssl === "on" ? "https" : "http") . "://" . (isset($client->headers["Host"]) ? $client->headers["Host"] : "localhost") . $request["path"] : $request["path"]);
// Process cookies.
$client->cookievars = array();
$client->requestvars = array();
if (isset($client->headers["Cookie"]))
{
$cookies = explode(";", $client->headers["Cookie"]);
foreach ($cookies as $cookie)
{
$pos = strpos($cookie, "=");
if ($pos === false)
{
$name = $cookie;
$val = "";
}
else
{
$name = substr($cookie, 0, $pos);
$val = urldecode(trim(substr($cookie, $pos + 1)));
}
$name = urldecode(trim($name));
$this->AddClientRecvHeader($id, $name, $val);
if (substr($name, -2) !== "[]") $client->cookievars[$name] = $val;
else
{
$name = substr($name, 0, -2);
if (!isset($client->cookievars[$name]) || !is_array($client->cookievars[$name])) $client->cookievars[$name] = array();
$client->cookievars[$name][] = $val;
}
}
}
// Process query string.
$url = HTTP::ExtractURL($client->url);
foreach ($url["queryvars"] as $name => $vals)
{
foreach ($vals as $val) $this->AddClientRecvHeader($id, $name, $val);
}
return true;
}
public function ProcessClientRequestBody($request, $body, $id)
{
if (!isset($this->clients[$id])) return false;
$client = $this->clients[$id];
if ($body !== "")
{
if (is_object($client->readdata)) $client->readdata->Write($body);
else
{
$client->readdata .= $body;
if (strlen($client->readdata) > 262144) return false;
if ($client->contenttype !== false)
{
if ($client->contenttype[""] === "application/x-www-form-urlencoded")
{
$pos = 0;
$pos2 = strpos($client->readdata, "&");
while ($pos2 !== false)
{
$str = (string)substr($client->readdata, $pos, $pos2 - $pos);
$pos3 = strpos($str, "=");
if ($pos3 === false)
{
$name = $str;
$val = "";
}
else
{
$name = substr($str, 0, $pos3);
$val = urldecode(trim(substr($str, $pos3 + 1)));
}
$name = urldecode(trim($name));
$this->AddClientRecvHeader($id, $name, $val);
$pos = $pos2 + 1;
$pos2 = strpos($client->readdata, "&", $pos);
}
if ($pos) $client->readdata = substr($client->readdata, $pos);
}
else if ($client->contenttype[""] === "multipart/form-data" && isset($client->contenttype["boundary"]))
{
$pos = 0;
do
{
$origmode = $client->mode;
switch ($client->mode)
{
case "handle_request":
{
$pos2 = strpos($client->readdata, "\n", $pos);
if ($pos2 === false) break;
$str = trim(substr($client->readdata, $pos, $pos2 - $pos));
if ($str === "--" . $client->contenttype["boundary"] . "--")
{
$pos = $pos2 + 1;
}
else if ($str === "--" . $client->contenttype["boundary"])
{
$pos = $pos2 + 1;
$client->mode = "handle_request_mime_headers";
$client->mimeheaders = array();
$client->lastmimeheader = "";
}
break;
}
case "handle_request_mime_headers":
{
while (($pos2 = strpos($client->readdata, "\n", $pos)) !== false)
{
$header = rtrim(substr($client->readdata, $pos, $pos2 - $pos));
$pos = $pos2 + 1;
if ($header != "")
{
if ($client->lastmimeheader != "" && (substr($header, 0, 1) == " " || substr($header, 0, 1) == "\t")) $client->mimeheaders[$client->lastmimeheader] .= $header;
else
{
$pos2 = strpos($header, ":");
if ($pos2 === false) $pos2 = strlen($header);
$client->lastmimeheader = HTTP::HeaderNameCleanup(substr($header, 0, $pos2));
$client->mimeheaders[$client->lastmimeheader] = ltrim(substr($header, $pos2 + 1));
}
if (isset($client->httpstate["options"]["maxheaders"]) && count($client->mimeheaders) > $client->httpstate["options"]["maxheaders"]) return false;
}
else
{
if (!isset($client->mimeheaders["Content-Disposition"])) $client->mode = "handle_request_mime_content_skip";
else
{
$client->mime_contentdisposition = HTTP::ExtractHeader($client->mimeheaders["Content-Disposition"]);
if ($client->mime_contentdisposition[""] !== "form-data" || !isset($client->mime_contentdisposition["name"]) || $client->mime_contentdisposition["name"] === "")
{
$client->mode = "handle_request_mime_content_skip";
}
else if ($this->cachedir !== false && isset($client->mime_contentdisposition["filename"]) && $client->mime_contentdisposition["filename"] !== "")
{
if ($client->currfile !== false) $client->files[$client->currfile]->Close();
$filename = $this->cachedir . $id . "_" . $client->requests . "_" . count($client->files) . ".dat";
$client->currfile = $filename;
if (!is_dir($this->cachedir)) @mkdir($this->cachedir, 0770, true);
if (file_exists($filename)) @unlink($filename);
$tempfile = new WebServer_TempFile();
$tempfile->filename = $filename;
if ($tempfile->Open() === false) return false;
$client->files[$filename] = $tempfile;
$this->AddClientRecvHeader($id, $client->mime_contentdisposition["name"], $tempfile);
$client->mode = "handle_request_mime_content_file";
}
else
{
$client->mime_value = "";
$client->mode = "handle_request_mime_content";
}
}
break;
}
}
break;
}
case "handle_request_mime_content_skip":
case "handle_request_mime_content_file":
case "handle_request_mime_content":
{
$pos3 = $pos2 = strpos($client->readdata, "\r\n--" . $client->contenttype["boundary"], $pos);
if ($pos3 === false)
{
$pos3 = strlen($client->readdata) - strlen($client->contenttype["boundary"]) - 6;
if ($pos3 < $pos) $pos3 = $pos;
}
$data = (string)substr($client->readdata, $pos, $pos3 - $pos);
if ($data !== "")
{
if ($origmode === "handle_request_mime_content_file") $client->files[$client->currfile]->Write($data);
else if ($origmode === "handle_request_mime_content")
{
$client->mime_value .= $data;
if (strlen($client->mime_value) > 262144) return false;
}
}
if ($pos2 === false) $pos = $pos3;
else
{
if ($client->mode === "handle_request_mime_content") $this->AddClientRecvHeader($id, $client->mime_contentdisposition["name"], $client->mime_value);
$client->mode = "handle_request";
$pos = $pos2 + 2;
}
break;
}
}
} while ($origmode !== $client->mode);
if ($pos) $client->readdata = (string)substr($client->readdata, $pos);
}
else if ($this->cachedir !== false && strlen($client->readdata) > 100000)
{
$client->contenthandled = false;
$filename = $this->cachedir . $id . "_" . $client->requests . ".dat";
$client->currfile = $filename;
if (!is_dir($this->cachedir)) @mkdir($this->cachedir, 0770, true);
if (file_exists($filename)) @unlink($filename);
$tempfile = new WebServer_TempFile();
$tempfile->filename = $filename;
if ($tempfile->Open() === false) return false;
$client->files[$filename] = $tempfile;
$client->files[$filename]->Write($client->readdata);
$client->readdata = $tempfile;
}
else
{
$client->contenthandled = false;
}
}
}
}
return true;
}
public function ProcessClientResponseBody(&$data, &$bodysize, $id)
{
if (!isset($this->clients[$id])) return false;
$client = $this->clients[$id];
$data .= $client->writedata;
$client->writedata = "";
if ($bodysize === false && $client->responsefinalized) $bodysize = true;
return true;
}
public function UpdateStreamsAndTimeout($prefix, &$timeout, &$readfps, &$writefps)
{
if ($this->fp !== false) $readfps[$prefix . "http_s"] = $this->fp;
if ($timeout === false || $timeout > $this->defaulttimeout) $timeout = $this->defaulttimeout;
$ts = microtime(true);
foreach ($this->initclients as $id => $client)
{
if ($client->mode === "init")
{
$readfps[$prefix . "http_c_" . $id] = $client->fp;
if ($timeout > 1) $timeout = 1;
}
}
if (count($this->readreadyclients)) $timeout = 0;
foreach ($this->clients as $id => $client)
{
if ($client->httpstate !== false)
{
if ($ts < $client->httpstate["waituntil"] && $timeout > $client->httpstate["waituntil"] - $ts + 0.5)
{
$timeout = (int)($client->httpstate["waituntil"] - $ts + 0.5);
$client->lastts = $ts;
}
else if (HTTP::WantRead($client->httpstate)) $readfps[$prefix . "http_c_" . $id] = $client->fp;
else if ($client->mode !== "init_response" && ($client->writedata !== "" || $client->httpstate["data"] !== "")) $writefps[$prefix . "http_c_" . $id] = $client->fp;
else if ($client->responsefinalized)
{
$this->writereadyclients[$id] = $client->fp;
$timeout = 0;
}
}
}
}
// Sometimes keyed arrays don't work properly.
public static function FixedStreamSelect(&$readfps, &$writefps, &$exceptfps, $timeout)
{
// In order to correctly detect bad outputs, no '0' integer key is allowed.
if (isset($readfps[0]) || isset($writefps[0]) || ($exceptfps !== NULL && isset($exceptfps[0]))) return false;
$origreadfps = $readfps;
$origwritefps = $writefps;
$origexceptfps = $exceptfps;
$result2 = @stream_select($readfps, $writefps, $exceptfps, $timeout);
if ($result2 === false) return false;
if (isset($readfps[0]))
{
$fps = array();
foreach ($origreadfps as $key => $fp) $fps[(int)$fp] = $key;
foreach ($readfps as $num => $fp)
{
$readfps[$fps[(int)$fp]] = $fp;
unset($readfps[$num]);
}
}
if (isset($writefps[0]))
{
$fps = array();
foreach ($origwritefps as $key => $fp) $fps[(int)$fp] = $key;
foreach ($writefps as $num => $fp)
{
$writefps[$fps[(int)$fp]] = $fp;
unset($writefps[$num]);
}
}
if ($exceptfps !== NULL && isset($exceptfps[0]))
{
$fps = array();
foreach ($origexceptfps as $key => $fp) $fps[(int)$fp] = $key;
foreach ($exceptfps as $num => $fp)
{
$exceptfps[$fps[(int)$fp]] = $fp;
unset($exceptfps[$num]);
}
}
return true;
}
public function InitNewClient()
{
$client = new WebServer_Client();
$client->id = $this->nextclientid;
$client->mode = "init";
$client->ssl = ($this->ssl ? "start" : "off");
$client->httpstate = false;
$client->readdata = "";
$client->request = false;
$client->url = "";
$client->headers = false;
$client->contenttype = false;
$client->contenthandled = true;
$client->cookievars = false;
$client->requestvars = false;
$client->requestcomplete = false;
$client->keepalive = true;
$client->requests = 0;
$client->responseheaders = false;
$client->responsefinalized = false;
$client->deflate = false;
$client->writedata = "";
$client->lastts = microtime(true);
$client->fp = false;
$client->ipaddr = false;
$client->currfile = false;
$client->files = array();
// Intended for application storage.
$client->appdata = false;
$this->initclients[$this->nextclientid] = $client;
$this->nextclientid++;
return $client;
}
protected function HandleNewConnections(&$readfps, &$writefps)
{
if (isset($readfps["http_s"]))
{
while (($fp = @stream_socket_accept($this->fp, 0)) !== false)
{
// Enable non-blocking mode.
stream_set_blocking($fp, 0);
$client = $this->InitNewClient();
$client->fp = $fp;
$client->ipaddr = stream_socket_get_name($fp, true);
}
unset($readfps["http_s"]);
}
}
protected function HandleResponseCompleted($id, $result)
{
}
// Handles new connections, the initial conversation, basic packet management, rate limits, and timeouts.
// Can wait on more streams than just sockets and/or more sockets. Useful for waiting on other resources.
// 'http_s' and the 'http_c_' prefix are reserved.
// Returns an array of clients that may need more processing.
public function Wait($timeout = false, $readfps = array(), $writefps = array(), $exceptfps = NULL)
{
$this->UpdateStreamsAndTimeout("", $timeout, $readfps, $writefps);
$result = array("success" => true, "clients" => array(), "removed" => array(), "readfps" => array(), "writefps" => array(), "exceptfps" => array());
if (!count($readfps) && !count($writefps)) return $result;
$result2 = self::FixedStreamSelect($readfps, $writefps, $exceptfps, $timeout);
if ($result2 === false) return array("success" => false, "error" => HTTP::HTTPTranslate("Wait() failed due to stream_select() failure. Most likely cause: Connection failure."), "errorcode" => "stream_select_failed");
// Handle new connections.
$this->HandleNewConnections($readfps, $writefps);
// Handle ready clients.
foreach ($this->readreadyclients as $id => $fp) $readfps["http_c_" . $id] = $fp;
$this->readreadyclients = array();
// Handle clients in the read queue.
foreach ($readfps as $cid => $fp)
{
if (!is_string($cid) || strlen($cid) < 8 || substr($cid, 0, 7) !== "http_c_") continue;
$id = (int)substr($cid, 7);
if (!isset($this->clients[$id])) continue;
$client = $this->clients[$id];
$client->lastts = microtime(true);
if ($client->httpstate !== false)
{
$result2 = HTTP::ProcessState($client->httpstate);
if ($result2["success"])
{
// Trigger the last variable to process when extracting form variables.
if ($client->contenttype !== false && $client->contenttype[""] === "application/x-www-form-urlencoded") $this->ProcessClientRequestBody($result2["request"], "&", $id);
if ($client->currfile !== false)
{
$client->files[$client->currfile]->Close();
$client->currfile = false;
}
$result["clients"][$id] = $client;
$client->requestcomplete = true;
$client->requests++;
$client->mode = "init_response";
$client->responseheaders = array();
$client->responsefinalized = false;
$client->responsebodysize = true;
$client->httpstate["type"] = "request";
$client->httpstate["startts"] = microtime(true);
$client->httpstate["waituntil"] = -1.0;
$client->httpstate["data"] = "";
$client->httpstate["bodysize"] = false;
$client->httpstate["chunked"] = false;
$client->httpstate["secure"] = ($client->ssl === "on");
$client->httpstate["state"] = "send_data";
$client->SetResponseCode(200);
$client->SetResponseContentType("text/html; charset=UTF-8");
if (isset($client->headers["Connection"]))
{
$connection = HTTP::ExtractHeader($client->headers["Connection"]);
if (strtolower($connection[""]) === "close") $client->keepalive = false;
}
$ver = explode("/", $client->request["httpver"]);
$ver = (double)array_pop($ver);
if ($ver < 1.1) $client->keepalive = false;
if ($client->requests >= $this->maxrequests) $client->keepalive = false;
if ($this->usegzip && isset($client->headers["Accept-Encoding"]))
{
$encodings = HTTP::ExtractHeader($client->headers["Accept-Encoding"]);
$encodings = explode(",", $encodings[""]);
$gzip = false;
foreach ($encodings as $encoding)
{
if (strtolower(trim($encoding)) === "gzip") $gzip = true;
}
if ($gzip)
{
$client->deflate = new DeflateStream();
$client->deflate->Init("wb", -1, array("type" => "gzip"));
$client->AddResponseHeader("Content-Encoding", "gzip", true);
}
}
}
else if ($result2["errorcode"] !== "no_data")
{
if ($client->requests) $result["removed"][$id] = array("result" => $result2, "client" => $client);
// Client was closed by the underlying library.
$client->fp = false;
$this->RemoveClient($id);
}
else if ($client->requestcomplete === false && $client->httpstate["state"] !== "request_line" && $client->httpstate["state"] !== "headers")
{
// Allows the caller an opportunity to adjust some client options based on inputs on a per-client basis (e.g. recvlimit).
$this->readreadyclients[$id] = $fp;
$result["clients"][$id] = $client;
}
}
unset($readfps[$cid]);
}
// Handle ready clients.
foreach ($this->writereadyclients as $id => $fp) $writefps["http_c_" . $id] = $fp;
$this->writereadyclients = array();
// Handle clients in the write queue.
foreach ($writefps as $cid => $fp)
{
if (!is_string($cid) || strlen($cid) < 6 || substr($cid, 0, 7) !== "http_c_") continue;
$id = (int)substr($cid, 7);
if (!isset($this->clients[$id])) continue;
$client = $this->clients[$id];
$client->lastts = microtime(true);
if ($client->httpstate !== false)
{
// Transform the client response into real data.
if ($client->mode === "response_ready")
{
if ($client->responsefinalized)
{
if ($client->responsebodysize !== false) $client->AddResponseHeader("Content-Length", (string)strlen($client->writedata), true);
$client->httpstate["bodysize"] = strlen($client->writedata);
}
else if ($client->responsebodysize !== true)
{
$client->AddResponseHeader("Content-Length", (string)$client->responsebodysize, true);
$client->httpstate["bodysize"] = $client->responsebodysize;
}
else if ($client->keepalive)
{
$client->AddResponseHeader("Transfer-Encoding", "chunked", true);
$client->httpstate["chunked"] = true;
}
$client->AddResponseHeader("Date", gmdate("D, d M Y H:i:s T"), true);
if (!$client->keepalive || $client->requests >= $this->maxrequests) $client->AddResponseHeader("Connection", "close", true);
foreach ($client->responseheaders as $name => $vals)
{
foreach ($vals as $val) $client->httpstate["data"] .= $name . ": " . $val . "\r\n";
}
$client->responseheaders = false;
$client->httpstate["data"] .= "\r\n";
$client->httpstate["result"]["rawsendheadersize"] = strlen($client->httpstate["data"]);
$client->mode = "handle_response";
}
$result2 = HTTP::ProcessState($client->httpstate);
if ($result2["success"])
{
if (!$client->responsefinalized)
{
$result["clients"][$id] = $client;
}
else if ($client->keepalive && $client->requests < $this->maxrequests)
{
$this->HandleResponseCompleted($id, $result2);
// Reset client for another request.
$client->mode = ($client->ssl === "start" ? "init" : "init_request");
$client->readdata = $client->httpstate["nextread"];
$client->httpstate = false;
$client->request = false;
$client->url = "";
$client->headers = false;
$client->contenttype = false;
$client->contenthandled = true;
$client->cookievars = false;
$client->requestvars = false;
$client->requestcomplete = false;
$client->deflate = false;
$client->writedata = "";
foreach ($client->files as $filename => $tempfile)
{
$client->files[$filename]->Free();
unset($client->files[$filename]);
}
$client->files = array();
$this->initclients[$id] = $client;
unset($this->clients[$id]);
if ($client->readdata !== "") $this->readreadyclients[$id] = $fp;
}
else
{
$this->HandleResponseCompleted($id, $result2);
$result["removed"][$id] = array("result" => array("success" => true), "client" => $client);
$this->RemoveClient($id);
}
}
else if ($result2["errorcode"] !== "no_data")
{
$this->HandleResponseCompleted($id, $result2);
$result["removed"][$id] = array("result" => $result2, "client" => $client);
// Client was closed by the underlying library.
$client->fp = false;
$this->RemoveClient($id);
}
}
unset($writefps[$cid]);
}
// Initialize new clients.
foreach ($this->initclients as $id => $client)
{
do
{
$origmode = $client->mode;
switch ($client->mode)
{
case "init":
{
$result2 = ($client->ssl === "start" ? @stream_socket_enable_crypto($client->fp, true, STREAM_CRYPTO_METHOD_TLSv1_1_SERVER | STREAM_CRYPTO_METHOD_TLSv1_2_SERVER) : true);
if ($result2 === true)
{
if ($client->ssl === "start") $client->ssl = "on";
$client->mode = "init_request";
}
else if ($result2 === false)
{
@fclose($client->fp);
unset($this->initclients[$id]);
}
break;
}
case "init_request":
{
// Use the HTTP class in server mode to handle state.
// The callback functions are located in WebServer to avoid the issue of pass-by-reference memory leaks.
$options = $this->defaultclientoptions;
$options["async"] = true;
$options["read_headers_callback"] = array($this, "ProcessClientRequestHeaders");
$options["read_headers_callback_opts"] = $id;
$options["read_body_callback"] = array($this, "ProcessClientRequestBody");
$options["read_body_callback_opts"] = $id;
$options["write_body_callback"] = array($this, "ProcessClientResponseBody");
$options["write_body_callback_opts"] = $id;
if (!isset($options["readlinelimit"])) $options["readlinelimit"] = 116000;
if (!isset($options["maxheaders"])) $options["maxheaders"] = 1000;
if (!isset($options["recvlimit"])) $options["recvlimit"] = 1000000;
$startts = microtime(true);
$timeout = (isset($options["timeout"]) ? $options["timeout"] : false);
$result2 = array("success" => true, "rawsendsize" => 0, "rawsendheadersize" => 0, "rawrecvsize" => 0, "rawrecvheadersize" => 0, "startts" => $startts);
$debug = (isset($options["debug"]) && $options["debug"]);
if ($debug)
{
$result2["rawsend"] = "";
$result2["rawrecv"] = "";
}
$client->httpstate = HTTP::InitResponseState($client->fp, $debug, $options, $startts, $timeout, $result2, false, $client->readdata, false);
$client->readdata = "";
$client->mode = "handle_request";
$client->lastts = microtime(true);
$this->clients[$id] = $client;
unset($this->initclients[$id]);
break;
}
}
} while (isset($this->initclients[$id]) && $origmode !== $client->mode);
}
// Handle client timeouts.
$ts = microtime(true);
foreach ($this->clients as $id => $client)
{
if ($client->lastts + $this->defaultclienttimeout < $ts)
{
if ($client->requests)
{
$result2 = array("success" => false, "error" => HTTP::HTTPTranslate("Client timed out. Most likely cause: Connection failure."), "errorcode" => "client_timeout");
$result["removed"][$id] = array("result" => $result2, "client" => $client);
}
$this->RemoveClient($id);
}
}
// Return any extra handles that were being waited on.
$result["readfps"] = $readfps;
$result["writefps"] = $writefps;
$result["exceptfps"] = $exceptfps;
return $result;
}
public function GetClients()
{
return $this->clients;
}
public function NumClients()
{
return count($this->clients);
}
public function GetClient($id)
{
return (isset($this->clients[$id]) ? $this->clients[$id] : false);
}
public function DetachClient($id)
{
if (!isset($this->clients[$id])) return false;
$client = $this->clients[$id];
unset($this->clients[$id]);
unset($this->readreadyclients[$id]);
return $client;
}
public function RemoveClient($id)
{
if (isset($this->clients[$id]))
{
$client = $this->clients[$id];
// Remove the client.
foreach ($client->files as $filename => $tempfile)
{
$client->files[$filename]->Free();
}
if ($client->fp !== false) @fclose($client->fp);
unset($this->clients[$id]);
unset($this->readreadyclients[$id]);
}
}
}
// Internal class used to construct file objects to minimize the number of open file handles.
// Otherwise an attacker could easily consume all available file handles in a single request.
class WebServer_TempFile
{
public $fp, $filename;
public function Open()
{
$this->Close();
$this->fp = fopen($this->filename, "w+b");
return $this->fp;
}
public function Read($size)
{
if ($this->fp === false) return false;
$data = fread($this->fp, $size);
if ($data === false || feof($this->fp)) $this->Close();
if ($data === false) $data = "";
return $data;
}
public function Write($data)
{
return fwrite($this->fp, $data);
}
public function Close()
{
if (is_resource($this->fp)) fclose($this->fp);
$this->fp = false;
}
public function Free()
{
$this->Close();
unlink($this->filename);
}
}
// Internal client class constructed by the web server class.
class WebServer_Client
{
public function GetHTTPOptions()
{
return ($this->httpstate !== false ? $this->httpstate["options"] : false);
}
public function SetHTTPOptions($options)
{
if ($this->httpstate !== false) $this->httpstate["options"] = $options;
}
public function SetResponseCode($code)
{
if ($this->requestcomplete && $this->mode !== "handle_response")
{
if (is_int($code))
{
$codemap = array(
100 => "Continue", 101 => "Switching Protocols", 102 => "Processing",
200 => "OK", 201 => "Created", 202 => "Accepted", 203 => "Non-Authoritative Information", 204 => "No Content", 205 => "Reset Content",
206 => "Partial Content", 207 => "Multi-Status", 208 => "Already Reported", 226 => "IM Used",
300 => "Multiple Choices", 301 => "Moved Permanently", 302 => "Found", 303 => "See Other", 304 => "Not Modified", 305 => "Use Proxy",
306 => "Switch Proxy", 307 => "Temporary Redirect", 308 => "Permanent Redirect",
400 => "Bad Request", 401 => "Unauthorized", 402 => "Payment Required", 403 => "Forbidden", 404 => "Not Found", 405 => "Method Not Allowed",
406 => "Not Acceptable", 407 => "Proxy Authentication Required", 408 => "Request Timeout", 409 => "Conflict", 410 => "Gone",
411 => "Length Required", 412 => "Precondition Failed", 413 => "Payload Too Large", 414 => "URI Too Long", 415 => "Unsupported Media Type",
416 => "Range Not Satisfiable", 417 => "Expectation Failed", 418 => "I'm a teapot", 421 => "Misdirected Request",
422 => "Unprocessable Entity", 423 => "Locked", 424 => "Failed Dependency", 426 => "Upgrade Required", 428 => "Precondition Required",
429 => "Too Many Requests", 431 => "Request Header Fields Too Large", 451 => "Unavailable For Legal Reasons",
500 => "Internal Server Error", 501 => "Not Implemented", 502 => "Bad Gateway", 503 => "Service Unavailable", 504 => "Gateway Timeout",
505 => "HTTP Version Not Supported", 506 => "Variant Also Negotiates", 507 => "Insufficient Storage", 508 => "Loop Detected",
510 => "Not Extended", 511 => "Network Authentication Required",
);
if (!isset($codemap[$code])) $code = 500;
if ($this->responsebodysize === true && (($code >= 100 && $code < 200) || $code === 204 || $code === 304)) $this->responsebodysize = false;
$code = $code . " " . $codemap[$code];
}
$this->httpstate["data"] = $this->request["httpver"] . " " . $code . "\r\n";
$this->writedata = "";
}
}
public function SetResponseContentType($contenttype)
{
$this->AddResponseHeader("Content-Type", $contenttype, true);
}
public function SetResponseCookie($name, $value = "", $expires = 0, $path = "", $domain = "", $secure = false, $httponly = false)
{
if (!empty($domain))
{
// Remove port information.
$pos = strpos($domain, "]");
if (substr($domain, 0, 1) == "[" && $pos !== false) $domain = substr($domain, 0, $pos + 1);
else
{
$port = strpos($domain, ":");
if ($port !== false) $domain = substr($domain, 0, $port);
// Fix the domain to accept domains with and without 'www.'.
if (strtolower(substr($domain, 0, 4)) == "www.") $domain = substr($domain, 4);
if (strpos($domain, ".") === false) $domain = "";
else if (substr($domain, 0, 1) != ".") $domain = "." . $domain;
}
}
$this->AddResponseHeader("Set-Cookie", rawurlencode($name) . "=" . rawurlencode($value)
. (empty($expires) ? "" : "; expires=" . gmdate("D, d-M-Y H:i:s", $expires) . " GMT")
. (empty($path) ? "" : "; path=" . $path)
. (empty($domain) ? "" : "; domain=" . $domain)
. (!$secure ? "" : "; secure")
. (!$httponly ? "" : "; HttpOnly"));
}
public function SetResponseNoCache()
{
$this->AddResponseHeader("Expires", "Tue, 03 Jul 2001 06:00:00 GMT", true);
$this->AddResponseHeader("Last-Modified", gmdate("D, d M Y H:i:s T"), true);
$this->AddResponseHeader("Cache-Control", "max-age=0, no-cache, must-revalidate, proxy-revalidate", true);
}
public function AddResponseHeader($name, $val, $replace = false)
{
if ($this->requestcomplete && $this->mode !== "handle_response")
{
$name = preg_replace('/\s+/', "-", trim(preg_replace('/[^A-Za-z0-9 ]/', " ", $name)));
if (!isset($this->responseheaders[$name]) || $replace) $this->responseheaders[$name] = array();
$this->responseheaders[$name][] = str_replace(array("\r", "\n"), array("", ""), $val);
}
}
public function AddResponseHeaders($headers, $replace = false)
{
if ($this->requestcomplete && $this->mode !== "handle_response")
{
foreach ($headers as $name => $vals)
{
if (is_string($vals)) $vals = array($vals);
$name = preg_replace('/\s+/', "-", trim(preg_replace('/[^A-Za-z0-9 ]/', " ", $name)));
if (!isset($this->responseheaders[$name]) || $replace) $this->responseheaders[$name] = array();
foreach ($vals as $val) $this->responseheaders[$name][] = $val;
}
}
}
public function SetResponseContentLength($bodysize)
{
if ($this->requestcomplete && !$this->responsefinalized)
{
$this->responsebodysize = $bodysize;
}
}
public function AddResponseContent($data)
{
if ($this->requestcomplete && !$this->responsefinalized)
{
if ($this->deflate !== false)
{
$this->deflate->Write($data);
$data = $this->deflate->Read();
}
$this->writedata .= $data;
if ($this->mode !== "handle_response") $this->mode = "response_ready";
}
}
public function FinalizeResponse()
{
if ($this->requestcomplete && !$this->responsefinalized)
{
if ($this->deflate !== false)
{
$this->deflate->Finalize();
$data = $this->deflate->Read();
$this->writedata .= $data;
$this->deflate = false;
}
if ($this->mode !== "handle_response") $this->mode = "response_ready";
$this->responsefinalized = true;
}
}
}
?>