/**
* Apply cookies for request
* @param Request $req
*/
public function applyCookie($req)
{
// fetch cookies
$host = $req->getHeader('host');
$path = $req->getUrlParam('path');
$cookies = $this->fetchCookieToSend($host, $path);
if ($this !== $req) {
$cookies = array_merge($cookies, $req->fetchCookieToSend($host, $path));
}
// add to header
$req->setHeader('cookie', null);
foreach (array_chunk(array_values($cookies), 3) as $chunk) {
$req->addHeader('cookie', implode('; ', $chunk));
}
}
/**
* Extracts and returns the full URI (including both host and resource URIs) of the current Request, by striping the query string.
* @param Request $request Request to extract the URI from
* @return string URI
*/
private static function getFullURI(Request $request)
{
$host = $request->getHeader("HTTP_HOST");
//if ($request->getHeader("HTTP_X_FORWARDED_HOST") != null) $host = $request->getHeader("HTTP_X_FORWARDED_HOST");
$URI = "http://" . $host . "/" . self::getPath($request);
return $URI;
}
/**
* {@inheritdoc}
*/
public function createResponse(Application $application, Request $request, Socket $socket) : Response
{
if ($request->getMethod() !== 'GET') {
$sink = new MemorySink('Only GET requests allowed for WebSocket connections.');
return new BasicResponse(Response::METHOD_NOT_ALLOWED, ['Connection' => 'close', 'Upgrade' => 'websocket', 'Content-Length' => $sink->getLength(), 'Content-Type' => 'text/plain'], $sink);
}
if (!in_array('upgrade', array_map('trim', explode(',', strtolower($request->getHeader('Connection')))), true) || strtolower($request->getHeader('Upgrade')) !== 'websocket') {
$sink = new MemorySink('Must upgrade to WebSocket connection for requested resource.');
return new BasicResponse(Response::UPGRADE_REQUIRED, ['Connection' => 'close', 'Upgrade' => 'websocket', 'Content-Length' => $sink->getLength(), 'Content-Type' => 'text/plain'], $sink);
}
if (!$this->protocol->isProtocol($request)) {
$sink = new MemorySink('Unsupported protocol version.');
return new BasicResponse(Response::UPGRADE_REQUIRED, ['Connection' => 'close', 'Content-Length' => $sink->getLength(), 'Content-Type' => 'text/plain', 'Upgrade' => 'websocket', 'Sec-WebSocket-Version' => $this->getSupportedVersions()], $sink);
}
return $this->protocol->createResponse($application, $request, $socket);
}
public function hasBadWordpressTrackback()
{
// Fake WordPress trackbacks
// Real ones do not contain Accept:, and have a charset defined
// Real WP trackbacks may contain Accept: depending on the HTTP transport being used by the sending host
return $this->request->hasHeader('content-type') && strpos($this->request->getUserAgent(), 'wordpress') !== false && strpos($this->request->getHeader('content-type'), 'charset=') !== false;
}
/**
* @param \Request $request
* @return void
* @throws AuthenticationException
*/
public function __construct(\Request $request)
{
$header = $request->getHeader('Authentication');
if (false != $header) {
list($method, $auth) = sscanf($header, "%s %s");
$this->auth = $auth;
$this->type = $method;
} else {
throw new AuthenticationException(401, 'No valid access token sent!');
}
}
/**
* (non-PHPdoc)
* @see HttpClient::send()
*/
public function send(Request $request)
{
$ch = $this->curlAdapter->init($request->getUri());
$this->curlAdapter->setOption($ch, $this->curlAdapter->getOptConstant('CUSTOMREQUEST'), $request->getMethod());
$headers = array();
foreach ($request->getHeader() as $name => $value) {
$headers[] = $request->getHeader()->joinField($name, $value);
}
$this->curlAdapter->setOption($ch, $this->curlAdapter->getOptConstant('HTTPHEADER'), $headers);
$this->curlAdapter->setOption($ch, $this->curlAdapter->getOptConstant('POSTFIELDS'), $request->getPayload());
$this->curlAdapter->setOption($ch, $this->curlAdapter->getOptConstant('RETURNTRANSFER'), 1);
$this->curlAdapter->setOption($ch, $this->curlAdapter->getOptConstant('HEADERFUNCTION'), array($this, 'headerCallback'));
$this->response->flush();
$content = $this->curlAdapter->exec($ch);
if (false === $content) {
throw new \RuntimeException($this->curlAdapter->getError($ch), $this->curlAdapter->getErrno($ch));
}
$this->response->setContent($content);
$this->response->setStatusCode($this->curlAdapter->getInfo($ch, $this->curlAdapter->getInfoConstant('HTTP_CODE')));
$this->curlAdapter->close($ch);
return clone $this->response;
}
/**
* {@inheritdoc}
*/
public function buildOutgoingResponse(Response $response, Request $request = null, float $timeout = 0, bool $allowPersistent = false) : \Generator
{
if ('upgrade' === strtolower($response->getHeader('Connection'))) {
return $response;
}
if ($allowPersistent && null !== $request && 'keep-alive' === strtolower($request->getHeader('Connection'))) {
$response = $response->withHeader('Connection', 'keep-alive')->withHeader('Keep-Alive', sprintf('timeout=%d, max=%d', $this->keepAliveTimeout, $this->keepAliveMax));
} else {
$response = $response->withHeader('Connection', 'close');
}
$response = $response->withoutHeader('Content-Encoding');
if ($this->compressionEnabled && null !== $request && $request->hasHeader('Accept-Encoding') && $response->hasHeader('Content-Type') && preg_match('/gzip|deflate/i', $request->getHeader('Accept-Encoding'), $matches)) {
$encoding = strtolower($matches[0]);
$contentType = $response->getHeader('Content-Type');
foreach ($this->compressTypes as $pattern) {
if (preg_match($pattern, $contentType)) {
$response = $response->withHeader('Content-Encoding', $encoding);
break;
}
}
}
return yield from $this->buildOutgoingStream($response, $timeout);
}
/**
* 验证token
* @return bool true为合法，false为非法
*/
protected function verifyToken()
{
$request = new Request();
$token = $request->getHeader('singou-token');
//如果token不为空则检查，为空放行
if (!empty($token)) {
$model_token = new Token();
$dbToken = $model_token->findFirst(array('token' => $token));
$offset = time() - intval($dbToken->expire());
if ($offset < 0) {
return false;
}
return true;
}
}
protected function isRequestComplete()
{
$contentLength = $this->request->getHeader('Content-Length');
// if there is no content length, there should
// be no content so we can say it's done
if (!$contentLength) {
return true;
}
// if the content is present and has the
// right length, we're good to go
if ($contentLength[0] && strlen($this->buffer) >= $contentLength[0]) {
// store the expected content length
$this->length = $contentLength[0];
return true;
}
return false;
}
/**
* Authorizes a request
*
* @param Request $request
* @return Request
*/
protected static function authorize($request)
{
try {
$token = str_replace('Basic ', '', $request->getHeader('Authorization'));
$decrypted = base64_decode($token);
list($username, $password) = explode(':', $decrypted);
$user = User::find(array('username' => $username));
if (!$user) {
throw new Exception();
} elseif (password_verify($password, $user->get('password'))) {
$request->user = $user;
} else {
throw new Exception();
}
} catch (Exception $e) {
static::response(array(), 401, 'Not Authorized');
}
return $request;
}
public function __construct()
{
Core::$curent_class = get_called_class();
// initialisation de la variable locale time limit
Core::setTimeLimit();
// initialisation des constantes des chemins de l'application
Core::setPathConst();
// initialisation des constantes issus du fichier de parametres
Core::SetParameters();
// initialisation du DNS (PDO)
Core::SetDns();
// initialisation de l'autoloader de classe
spl_autoload_register(array(__CLASS__, 'setAutoload'), true, false);
//tret
// initialisation des requetes serveur
Request::init();
/*Core::$abstract= new AbstractModel();*/
// initialisation de la session
Session::start();
$_SESSION = array();
/*session_destroy();
exit;/**/
// initialisation de l'instance PDO
Core::$pdo = new PdoControllers(new PdoInstance(DSN, DB_USER, DB_PASS));
// initialisation du filemanager
//Core::$file_manager = new FileManager();
// initialisation de la base de données
if (DB_RESET) {
Core::setTimeLimit(0);
DbInit::init();
Core::setTimeLimit();
}
// initialisation Twig
$path = Request::getController() != 'asset' ? View : Asset;
Core::$twig = new Twig_Environment(new Twig_Loader_Filesystem($path), array('cache' => TWIG_CACHE == 1 ? CACHE : false, 'auto_reload' => TWIG_AUTO_RELOAD == 1 ? true : false));
Core::$twig->addExtension(new Project_Twig_Extension(Core::$curent_class));
// initialisation du header de la page
header(Request::getHeader());
}
public static function asText()
{
self::getInstance();
if (isset(self::$_instance)) {
if (Request::getHeader("X-Powered-By") == "XMLHTTPRequestHola") {
header("Content-type: application/json");
}
for ($i = 0; $i < count(self::$_headers); $i++) {
header(self::$_headers[$i]["key"] . ": " . self::$_headers[$i]["value"]);
}
if (Request::getHeader("X-Powered-By") != "XMLHTTPRequestHola") {
echo self::$_docType;
} else {
self::$_content = iconv("windows-1251", "UTF-8", self::$_content);
}
//echo self::$_content; die;
//self::$_content = iconv( "UTF-8", "windows-1251", self::$_content );
self::$_content = iconv("UTF-8", "windows-1251", self::$_content);
return (string) self::$_content;
} else {
return NULL;
}
}
/**
* Will render some text.
*
* Is the _base_ method for render_file.
*
* This method is useful when you want to output some text without using the template engine
*
* In case the action was already performed we will silently exit,
* otherwise, we set the response status and body and
* switch the action_performed flag to <i>TRUE</i>
*
* @param string text [optional]the text you want to send, default is an empty string
* @param Response::SC_* status, [optional] status code, default is 200 OK
*/
protected function render_text($text = '', $status = NULL)
{
if ($this->action_performed) {
$this->logger->warn('[Medick] >> Action already performed...');
return;
}
$status = $status === NULL ? HTTPResponse::SC_OK : $status;
// add ETag header
if ($this->use_etag && $status == HTTPResponse::SC_OK && strlen($text) > 0) {
$this->set_etag_headers($text);
if ($this->request->getHeader('If-None-Match') == md5($text)) {
$this->logger->debug('[Medick] >> Got response from browser cache (code=304, body="").');
$this->_perform(HTTPResponse::SC_NOT_MODIFIED, '');
} else {
$this->_perform($status, $text);
}
} else {
$this->_perform($status, $text);
}
$this->action_performed = TRUE;
$this->logger->debug('[Medick] >> Action performed.');
if ($this->session->hasValue('flash')) {
$this->session->removeValue('flash');
}
}
/**
* {@inheritdoc}
*/
public function validateResponse(Request $request, Response $response) : bool
{
if (Response::SWITCHING_PROTOCOLS !== $response->getStatusCode()) {
return false;
}
if ('upgrade' !== strtolower($response->getHeader('Connection'))) {
return false;
}
if ('websocket' !== strtolower($response->getHeader('Upgrade'))) {
return false;
}
$key = $request->getHeader('Sec-WebSocket-Key');
if (!$response->hasHeader('Sec-WebSocket-Accept')) {
return false;
}
return $this->responseKey($key) === $response->getHeader('Sec-WebSocket-Accept');
}
/**
* @param Request $request
* @param bool $redirectsEnabled
* @param int $maxRedirects
* @return Response
* @throws RequestException
*/
public function send(Request $request, $redirectsEnabled = false, $maxRedirects = 20)
{
/// Is there curl_init function
if (!function_exists('curl_init')) {
throw new RequestException('curl_init doesn\'t exists. Is curl extension instaled and enabled?');
}
/// Dont send request without url
if (!$request->getUrl()) {
return new Response();
}
$url = $request->getUrl();
if (!empty($this->params)) {
$url .= '?' . http_build_query($this->params);
}
@curl_setopt($this->handle, CURLOPT_URL, $url);
if ($request->getJSON() !== null) {
$request->addHeaders(array('Content-Type' => 'application/json'));
}
$this->setCookies($request->getCookies());
$this->setHeaders($request->getHeaders());
$this->setMethod($request->getMethod());
/// Set post fields to CURL handle
if (count($request->getPostFields()) > 0 || $request->getJSON()) {
$fields = $request->getJSON() ? json_encode($request->getJSON()) : $request->getPostFields();
$this->setPostFields($fields, $request->getMethod(), $request->getHeader('Content-Type'));
$request->setJSON(null);
}
/// Execute
$response = curl_exec($this->handle);
/// Remove content type header to not be used in further requests
$request->unsetHeader('Content-Type');
/// Handle CURL error
if ($response == FALSE) {
throw new RequestException("CURL error [" . curl_errno($this->handle) . "]: " . curl_error($this->handle), curl_errno($this->handle));
}
/// Separate response header and body
/// Http 100 workaround
$parts = explode("\r\n\r\nHTTP/", $response);
$parts = (count($parts) > 1 ? 'HTTP/' : '') . array_pop($parts);
list($headers, $body) = explode("\r\n\r\n", $parts, 2);
$response = new Response(curl_getinfo($this->handle, CURLINFO_HTTP_CODE), $headers, $body);
/// If cookiesEnabled then call addCookies with response cookies
if ($request->isCookiesEnabled()) {
$request->addCookies($response->getCookies());
}
/// Are redirects enabled? (Also check redirects count)
if ($redirectsEnabled && ($response->getCode() == 301 || $response->getCode() == 302 || $response->getCode() == 303) && $this->redirectCount < $maxRedirects) {
$response = $this->doFollow($request, $response, $maxRedirects);
} else {
if ($this->redirectCount == $maxRedirects) {
throw new RequestException("Maximum of " . $maxRedirects . " redirects reached.");
}
$this->redirectCount = 0;
}
return $response;
}
public function __invoke(Request $request, Response $response, ...$args)
{
if ($request->getMethod() !== "GET") {
$response->setStatus(HTTP_STATUS["METHOD_NOT_ALLOWED"]);
$response->setHeader("Allow", "GET");
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
if ($request->getProtocolVersion() !== "1.1") {
$response->setStatus(HTTP_STATUS["HTTP_VERSION_NOT_SUPPORTED"]);
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
$body = $request->getBody();
if (!$body instanceof NullBody) {
$response->setStatus(HTTP_STATUS["BAD_REQUEST"]);
$response->setReason("Bad Request: Entity body disallowed for websocket endpoint");
$response->setHeader("Connection", "close");
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
$hasUpgradeWebsocket = false;
foreach ($request->getHeaderArray("Upgrade") as $value) {
if (strcasecmp($value, "websocket") === 0) {
$hasUpgradeWebsocket = true;
break;
}
}
if (empty($hasUpgradeWebsocket)) {
$response->setStatus(HTTP_STATUS["UPGRADE_REQUIRED"]);
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
$hasConnectionUpgrade = false;
foreach ($request->getHeaderArray("Connection") as $value) {
$values = array_map("trim", explode(",", $value));
foreach ($values as $token) {
if (strcasecmp($token, "Upgrade") === 0) {
$hasConnectionUpgrade = true;
break;
}
}
}
if (empty($hasConnectionUpgrade)) {
$response->setStatus(HTTP_STATUS["UPGRADE_REQUIRED"]);
$response->setReason("Bad Request: \"Connection: Upgrade\" header required");
$response->setHeader("Upgrade", "websocket");
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
if (!($acceptKey = $request->getHeader("Sec-Websocket-Key"))) {
$response->setStatus(HTTP_STATUS["BAD_REQUEST"]);
$response->setReason("Bad Request: \"Sec-Websocket-Key\" header required");
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
if (!in_array("13", $request->getHeaderArray("Sec-Websocket-Version"))) {
$response->setStatus(HTTP_STATUS["BAD_REQUEST"]);
$response->setReason("Bad Request: Requested Websocket version unavailable");
$response->setHeader("Sec-WebSocket-Version", "13");
$response->setHeader("Aerys-Generic-Response", "enable");
$response->end();
return;
}
$handshaker = new Handshake($response, $acceptKey);
$onHandshakeResult = $this->application->onHandshake($request, $handshaker, ...$args);
if ($onHandshakeResult instanceof \Generator) {
$onHandshakeResult = (yield from $onHandshakeResult);
}
$request->setLocalVar("aerys.websocket", $onHandshakeResult);
$handshaker->end();
}
public function testGetHeaderArray()
{
$request = new Request('http://google.com', 'GET');
$request->setHeader('field', array('value1', 'value2'));
$this->assertEquals('value1,value2', $request->getHeader('field'), 'Wrong value');
}
