/**
* Creates a new response
*
* @param peer.http.HttpResponse response
* @param webservices.rest.ResponseReader reader
* @param var type (Deprecated)
*/
public function __construct(HttpResponse $response, ResponseReader $reader = NULL, $type = NULL)
{
$this->response = $response;
$this->reader = $reader;
$this->type = $type;
$this->input = $response->getInputStream();
}
public function testGetters()
{
$response = new HttpResponse(200, array('Age: 42'), 'Hey');
$this->assertEquals(200, $response->getStatus());
$this->assertEquals(array('Age: 42'), $response->getHeaders());
$this->assertEquals('Hey', $response->getBody());
}
public static function post($url, $params, $auth)
{
try {
if (!function_exists("curl_init") && !function_exists("curl_setopt") && !function_exists("curl_exec") && !function_exists("curl_close")) {
throw new Exception('CURL is required.');
}
$data = array("data" => $params->getJSONEncode(), "version" => Config::version);
$httpResponse = new HttpResponse();
ob_start();
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, self::get_furl($url));
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data, '', '&'));
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, '0');
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, '0');
curl_setopt($ch, CURLOPT_HTTPHEADER, $auth);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, Config::timeout);
curl_exec($ch);
$httpResponse->setResponse(urldecode(ob_get_contents()));
$httpResponse->setCode(curl_getinfo($ch, CURLINFO_HTTP_CODE));
ob_end_clean();
if (curl_errno($ch)) {
curl_close($ch);
throw new Exception(curl_error($ch));
}
curl_close($ch);
return $httpResponse;
} catch (Exception $e) {
curl_close($ch);
throw new HttpException($e->getMessage());
}
}
/**
* @param string
* @param array
* @return HttpRequest
*/
public function render($template, $context)
{
$render = $this->get('render');
$response = new HttpResponse();
$response->setData($render->render($template, $context));
return $response;
}
/**
* Creates a new response
*
* @param peer.http.HttpResponse response
* @param webservices.rest.RestDeserializer deserializer
* @param lang.Type type
*/
public function __construct(HttpResponse $response, RestDeserializer $deserializer = NULL, Type $type = NULL)
{
$this->response = $response;
$this->deserializer = $deserializer;
$this->type = $type;
$this->input = $response->getInputStream();
}
public function dispatch(Request $request, Response $response = null)
{
if (!$response) {
$response = new HttpResponse();
}
$response->setContent(__METHOD__);
return $response;
}
public function run()
{
if ($this->_isRequestMatching()) {
$this->_controller = $this->_getControllerInstance();
$this->_response->setBody($this->_callAction());
$this->_response->send();
}
}
function test_set_body_with_empty_string()
{
$response = new HttpResponse(200);
$headers = array();
$headers['content-encoding'] = 'gzip';
$response->headers = $headers;
$response->body = "";
$this->assertTrue($response->is_success(), 'Should have handled empty body without causing error');
}
public static function makeRequest(HttpRequest $request)
{
$requestUri = $request->getRequestUri()->getUri();
// if the request is towards a file URL, return the response constructed
// from file
if (0 === strpos($requestUri, "file:///")) {
return HttpResponse::fromFile($requestUri);
}
$httpResponse = new HttpResponse();
$curlChannel = curl_init();
curl_setopt($curlChannel, CURLOPT_URL, $requestUri);
curl_setopt($curlChannel, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($curlChannel, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curlChannel, CURLOPT_TIMEOUT, 10);
if ($request->getRequestMethod() === "POST") {
curl_setopt($curlChannel, CURLOPT_POST, 1);
curl_setopt($curlChannel, CURLOPT_POSTFIELDS, $request->getContent());
}
$basicAuthUser = $request->getBasicAuthUser();
$basicAuthPass = $request->getBasicAuthPass();
if (NULL !== $basicAuthUser) {
$request->setHeader("Authorization", "Basic " . base64_encode($basicAuthUser . ":" . $basicAuthPass));
}
// Including HTTP headers in request
$headers = $request->getHeaders(TRUE);
if (!empty($headers)) {
curl_setopt($curlChannel, CURLOPT_HTTPHEADER, $headers);
}
// Connect to SSL/TLS server, validate certificate and host
if ($request->getRequestUri()->getScheme() === "https") {
curl_setopt($curlChannel, CURLOPT_SSL_VERIFYPEER, 1);
curl_setopt($curlChannel, CURLOPT_SSL_VERIFYHOST, 2);
}
// Callback to extract all the HTTP headers from the response...
// In order to really correctly parse HTTP headers one would have to look at RFC 2616...
curl_setopt($curlChannel, CURLOPT_HEADERFUNCTION, function ($curlChannel, $header) use($httpResponse) {
// Ignore Status-Line (RFC 2616, section 6.1)
if (0 === preg_match('|^HTTP/\\d+.\\d+ [1-5]\\d\\d|', $header)) {
// Only deal with header lines that contain a colon
if (strpos($header, ":") !== FALSE) {
// Only deal with header lines that contain a colon
list($key, $value) = explode(":", trim($header));
$httpResponse->setHeader(trim($key), trim($value));
}
}
return strlen($header);
});
$output = curl_exec($curlChannel);
if ($errorNumber = curl_errno($curlChannel)) {
throw new OutgoingHttpRequestException(curl_error($curlChannel));
}
$httpResponse->setStatusCode(curl_getinfo($curlChannel, CURLINFO_HTTP_CODE));
$httpResponse->setContent($output);
curl_close($curlChannel);
return $httpResponse;
}
/**
* Construct the OAuth 2 error using a response object
*
* @param \HttpResponse $response The response object
*/
public function __construct($response)
{
$response->error = $this;
$this->response = $response;
$parsedResponse = $response->parse();
if (is_array($parsedResponse)) {
$this->code = isset($parsedResponse['error']) ? $parsedResponse['error'] : 0;
$this->message = isset($parsedResponse['error_description']) ? $parsedResponse['error_description'] : null;
}
}
public function send($url)
{
curl_setopt($this->handler, CURLOPT_URL, $url);
$this->response_body = curl_exec($this->handler);
$response = HttpResponse::separate($this->response_body, array('header_size' => curl_getinfo($this->handler, CURLINFO_HEADER_SIZE)));
return $response;
}
/**
* Implement a virtual 'headers' class property to return their respective objects.
*
* @param string $name The property name.
* @return string $value The property value.
*/
public function __get($name)
{
if ($name == 'headers') {
return $this->getHeaders();
}
return parent::__get($name);
}
function HttpServletResponse(&$servletcontext)
{
parent::HttpResponse();
if (ServletContext::validClass($servletcontext)) {
$this->context =& $servletcontext;
}
}
public function getRedirectResponse()
{
if (!$this->isRedirect()) {
throw new RuntimeException('This response does not support redirection.');
}
$output = json_encode($this->getData());
return HttpResponse::create($output);
}
private function _getResponse($request)
{
$response = [];
$request['httpStatus'] = "200";
$request['httpReasonPhrase'] = "OK";
$request['body'] = "";
if (file_exists('.' . $request['uri']) === true) {
$request['body'] = file_get_contents('.' . $request['uri']);
} else {
$request['httpStatus'] = "400";
$request['httpReasonPhrase'] = "NOT FOUND";
}
$httpResponse = new HttpResponse($request);
$response['header'] = $httpResponse->getResponseHeader();
$response['body'] = $httpResponse->getResponseBody();
return $response;
}
/**
* Test HttpResponse.
*/
function test_HttpResponse()
{
HttpResponse::setCache(true);
HttpResponse::setContentType('application/pdf');
HttpResponse::setContentDisposition("test.pdf", false);
HttpResponse::setFile('sheet.pdf');
HttpResponse::send();
}
/**
* Executes an HTTP transaction and returns the response.
*
* @param HttpRequest $request
* @return HttpResponse
*/
public function getResponse(HttpRequest $request)
{
$uri = $request->getUrl();
$headers = $request->getHeaders();
$flatHeaders = [];
foreach ($headers as $key => $value) {
$flatHeaders[] = $key . ": " . $value;
}
$flatHeaders[] = 'Connection: Keep-Alive';
$flatHeaders[] = 'Expect:';
$flatHeaders[] = 'Accept-Language: en-GB';
$flatHeaders[] = 'Cache-Control: no-cache';
$flatHeaders[] = 'User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)';
$curl = curl_init($uri);
curl_setopt($curl, CURLOPT_HEADER, false);
$payload = $request->getPayload();
switch ($request->getMethod()) {
case "head":
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "HEAD");
break;
case "delete":
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "DELETE");
break;
case "post":
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, $payload);
break;
case "put":
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, $payload);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "PUT");
break;
}
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl, CURLOPT_HTTPHEADER, $flatHeaders);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
$responseCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
$httpResponse = new HttpResponse();
$httpResponse->setResponseBody($response);
$httpResponse->setResponseCode($responseCode);
return $httpResponse;
}
/**
* Redirect client to other URL.
* This is done by issuing a "Location" header and exiting if wanted.
*
* Returns true on succes (or exits) or false if headers have already been sent.
* Will append output rewrite vars.
*
* @param string $url URL where the redirect should go to.
* @param array $params Associative array of query parameters
* @param boolean $rewrite Add URL rewrite variables (null is auto-detect)
* @param int $status HTTP status code to use for redirect, valid values are 301, 302, 303 and 307.
* @return boolean
*/
public static function redirect($url, $params = array(), $rewrite = null, $status = 302)
{
if ($rewrite || $rewrite === null && strpos(':', $url) === false) {
if (!is_array($params)) {
$params = (array) $params;
}
$params += self::getUrlRewriteVars();
}
return parent::redirect($url, $params, false, $status);
}
function ajaxShutdown()
{
$isError = false;
if ($error = error_get_last()) {
switch ($error['type']) {
case E_ERROR:
case E_CORE_ERROR:
case E_COMPILE_ERROR:
case E_USER_ERROR:
case E_PARSE:
$log_file = ini_get("error_log");
if (file_exists($log_file)) {
$number_of_characters_to_get = 5000;
$bf = new BigFile($log_file);
$text = $bf->getFromEnd($number_of_characters_to_get);
$lines = array_reverse(explode("\n", $text));
$backtrace = "";
foreach ($lines as $i => $line) {
if (strstr($line, "Fatal")) {
for ($j = $i; $j > 0; $j--) {
$backtrace .= $lines[$j] . "\n";
}
break;
}
}
if ($backtrace == "") {
$backtrace = "No Fatal error found in the last {$number_of_characters_to_get} lines of {$log_file}";
}
} else {
$backtrace = "No error log found at " . $log_file;
}
$isError = true;
break;
}
}
if ($isError) {
send_http_error(new Exception("E_ERROR " . $error['message'] . "\n file: " . $error['file'] . " (" . $error['line'] . ")", E_FATAL_ERROR), "FATAL ERROR. shutdown function tried to restore backtrace from php error log ({$log_file}):\n" . $backtrace, true);
$response = new HttpResponse();
$response->setStatus("400 Bad Request");
$response->write("E_ERROR " . $error['message'] . "\n file: " . $error['file'] . " (" . $error['line'] . ")");
$response->flush();
}
}
/**
* @param \Blar\Curl\Curl $curl Curl.
* @param \Blar\Http\HttpResponse $response Response.
* @return $this
*/
protected function configureCurl(Curl $curl, HttpResponse $response)
{
$curl->setMethod($this->getMethod());
$curl->setUrl($this->getUrl());
if ($this->getHeaders()) {
$headers = $this->createHeadersArray($this->getHeaders());
$curl->setOption(CURLOPT_HTTPHEADER, $headers);
}
if ($this->getBody()) {
$curl->setBody($this->getBody());
}
$curl->setHeaderCallback(function ($header) use($response) {
$response->setHeaderLine($header);
});
$curl->setWriteCallback(function ($part) use($response) {
$response->addBodyPart($part);
});
return $this;
}
function threadmain()
{
// Read request block
$buf = "";
while (true) {
$rl = socket_read($this->sock, 4096, PHP_BINARY_READ);
if (false == $rl) {
socket_close($this->sock);
return;
} else {
$buf = $buf . $rl;
}
if (strpos($buf, "\r\n\r\n")) {
break;
} else {
console::writeLn('%s', $buf);
}
}
$db = explode("\r\n\r\n", $buf);
$data = $db[0];
// Put back the rest of the buffer for posts etc
$buf = join('', array_slice($db, 1));
$request = new HttpRequest($data);
// data
$response = new HttpResponse();
// Pop the header off the buffer
$status = call_user_func_array($this->handler, array(&$request, &$response));
if ($status == 0) {
$status = 200;
}
$peer = "";
$port = 0;
socket_getpeername($this->sock, $peer, $port);
console::writeLn("%s %s:%d %d %s", $request->getMethod(), $peer, $port, $status, $request->getUri());
$response->writeHeaders($this->sock, 200);
$response->writeContent($this->sock);
socket_shutdown($this->sock, 2);
usleep(50000);
socket_close($this->sock);
}
/**
* Sends a request
*
* @param peer.http.HttpRequest request
* @param int timeout default 60
* @param float connecttimeout default 2.0
* @return peer.http.HttpResponse response object
*/
public function send(HttpRequest $request, $timeout = 60, $connecttimeout = 2.0)
{
// Use proxy socket and Modify target if a proxy is to be used for this request,
// a proxy wants "GET http://example.com/ HTTP/X.X"
if ($this->proxy && !$this->proxy->isExcluded($url = $request->getUrl())) {
$request->setTarget(sprintf('%s://%s%s%s', $url->getScheme(), $url->getHost(), $url->getPort() ? ':' . $url->getPort() : '', $url->getPath('/')));
$s = $this->proxySocket;
} else {
$s = $this->socket;
}
// Socket still open from last request. This is the case when unread
// data is left on the socket (by not reading the body, e.g.), so do
// it the quick & dirty way: Close and reopen!
$s->isConnected() && $s->close();
$s->setTimeout($timeout);
$s->connect($connecttimeout);
$s->write($request->getRequestString());
$this->cat && $this->cat->info('>>>', $request->getHeaderString());
$response = new HttpResponse(new SocketInputStream($s));
$this->cat && $this->cat->info('<<<', $response->getHeaderString());
return $response;
}
public static function curl($url, $httpMethod = "GET", $postFields = null, $headers = null)
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $httpMethod);
if (ENABLE_HTTP_PROXY) {
curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
curl_setopt($ch, CURLOPT_PROXY, HTTP_PROXY_IP);
curl_setopt($ch, CURLOPT_PROXYPORT, HTTP_PROXY_PORT);
curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
}
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_FAILONERROR, false);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, is_array($postFields) ? self::getPostHttpBody($postFields) : $postFields);
if (self::$readTimeout) {
curl_setopt($ch, CURLOPT_TIMEOUT, self::$readTimeout);
}
if (self::$connectTimeout) {
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, self::$connectTimeout);
}
//https request
if (strlen($url) > 5 && strtolower(substr($url, 0, 5)) == "https") {
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
}
if (is_array($headers) && 0 < count($headers)) {
$httpHeaders = self::getHttpHearders($headers);
curl_setopt($ch, CURLOPT_HTTPHEADER, $httpHeaders);
}
$httpResponse = new HttpResponse();
$httpResponse->setBody(curl_exec($ch));
$httpResponse->setStatus(curl_getinfo($ch, CURLINFO_HTTP_CODE));
if (curl_errno($ch)) {
throw new ClientException("Speicified endpoint or uri is not valid.", "SDK.ServerUnreachable");
}
curl_close($ch);
return $httpResponse;
}
/**
* Sends a request
*
* @param peer.http.HttpRequest $request
* @param int $timeout default 60
* @param float $connecttimeout default 2.0
* @return peer.http.HttpResponse response object
*/
public function send(HttpRequest $request, $timeout = 60, $connecttimeout = 2.0)
{
$curl = curl_copy_handle($this->handle);
curl_setopt($curl, CURLOPT_URL, $request->url->getCanonicalURL());
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $request->getRequestString());
curl_setopt($curl, CURLOPT_TIMEOUT, $timeout);
if ($this->proxy && !$this->proxy->excludes()->contains($request->getUrl())) {
curl_setopt($curl, CURLOPT_PROXY, $this->proxy->host());
curl_setopt($curl, CURLOPT_PROXYPORT, $this->proxy->port());
$read = function ($transfer) {
if (preg_match('#^HTTP/[0-9]\\.[0-9] [0-9]{3} .+\\r\\n\\r\\n#', $transfer, $matches)) {
// Strip "HTTP/x.x 200 Connection established" which is followed by
// the real HTTP message: headers and body
return substr($transfer, strlen($matches[0]));
} else {
return $transfer;
}
};
} else {
$read = function ($transfer) {
return $transfer;
};
}
$return = curl_exec($curl);
if (false === $return) {
$errno = curl_errno($curl);
$error = curl_error($curl);
curl_close($curl);
throw new \io\IOException(sprintf('%d: %s', $errno, $error));
}
// ensure handle is closed
curl_close($curl);
$this->cat && $this->cat->info('>>>', $request->getHeaderString());
$response = new HttpResponse(new MemoryInputStream($read($return)), false);
$this->cat && $this->cat->info('<<<', $response->getHeaderString());
return $response;
}
/**
* Sends a request
*
* @param peer.http.HttpRequest request
* @param int timeout default 60
* @param float connecttimeout default 2.0
* @return peer.http.HttpResponse response object
*/
public function send(HttpRequest $request, $timeout = 60, $connecttimeout = 2.0)
{
$curl = curl_copy_handle($this->handle);
curl_setopt($curl, CURLOPT_URL, $request->url->getCanonicalURL());
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $request->getRequestString());
curl_setopt($curl, CURLOPT_TIMEOUT, $timeout);
if ($this->proxy && !$this->proxy->isExcluded($request->getUrl())) {
curl_setopt($curl, CURLOPT_PROXY, $this->proxy->host);
curl_setopt($curl, CURLOPT_PROXYPORT, $this->proxy->port);
}
$response = curl_exec($curl);
if (FALSE === $response) {
$errno = curl_errno($curl);
$error = curl_error($curl);
curl_close($curl);
throw new IOException(sprintf('%d: %s', $errno, $error));
}
// ensure handle is closed
curl_close($curl);
$this->cat && $this->cat->info('>>>', $request->getHeaderString());
$response = new HttpResponse(new MemoryInputStream($response));
$this->cat && $this->cat->info('<<<', $response->getHeaderString());
return $response;
}
/**
* Sends the response using the result
*
* @param mixed $result Result
* @return void
*/
public function send($result = null)
{
if ($result instanceof HttpResponse) {
$result->send();
exit;
}
// Output the result
if (!$result instanceof GenericResult) {
$result = new SuccessResult($result);
}
$result = elgg_trigger_plugin_hook('result', 'graph', null, $result);
$output = elgg_view('graph/output', array('result' => $result));
if (elgg_get_viewtype() === 'default') {
$layout = elgg_view_layout('one_column', array('content' => $output));
$output = elgg_view_page('', $layout);
}
$this->response->setStatusCode($result->getStatusCode())->setContent($output)->prepare($this->request)->send();
exit;
}
/**
* Processes this batch. This sends the captured requests to the server as one batch.
*
* @throws ClientException
* @return bool - true if processing of the batch was or the HttpResponse object in case of a failure. A successful process just means that tha parts were processed. Each part has it's own response though and should be checked on its own.
*/
public function process()
{
$this->stopCapture();
$this->setBatchRequest(true);
$data = '';
$batchParts = $this->getBatchParts();
if (count($batchParts) == 0) {
throw new ClientException('Can\'t process empty batch.');
}
/** @var $partValue BatchPart */
foreach ($batchParts as $partValue) {
$data .= '--' . HttpHelper::MIME_BOUNDARY . HttpHelper::EOL;
$data .= 'Content-Type: application/x-arango-batchpart' . HttpHelper::EOL;
if (!is_null($partValue->getId())) {
$data .= 'Content-Id: ' . (string) $partValue->getId() . HttpHelper::EOL . HttpHelper::EOL;
} else {
$data .= HttpHelper::EOL;
}
$data .= (string) $partValue->getRequest() . HttpHelper::EOL;
}
$data .= '--' . HttpHelper::MIME_BOUNDARY . '--' . HttpHelper::EOL . HttpHelper::EOL;
$params = array();
$url = UrlHelper::appendParamsUrl(Urls::URL_BATCH, $params);
$this->_batchResponse = $this->_connection->post($url, $data);
if ($this->_batchResponse->getHttpCode() !== 200) {
return $this->_batchResponse;
}
$body = $this->_batchResponse->getBody();
$body = trim($body, '--' . HttpHelper::MIME_BOUNDARY . '--');
$batchParts = $this->splitWithContentIdKey('--' . HttpHelper::MIME_BOUNDARY . HttpHelper::EOL, $body);
foreach ($batchParts as $partKey => $partValue) {
$response = new HttpResponse($partValue);
$body = $response->getBody();
$response = new HttpResponse($body);
$batchPartResponses[$partKey] = $response;
$this->getPart($partKey)->setResponse($batchPartResponses[$partKey]);
}
return $this;
}
function testGeneral()
{
$str = <<<EOF
HTTP/1.1 500 Server error
Host: localhost:8080
X-Powered-By: PHP/5.4.31
bc-param1: hello, world
Content-Type: text/plain
Exception: exception 'PDOException'
EOF;
$res = new HttpResponse($str);
$this->assertEquals(500, $res->code);
$this->assertEquals("Server error", $res->message);
$this->assertEquals("localhost:8080", $res->headers["HOST"]);
$this->assertEquals("Exception: exception 'PDOException'", $res->body);
$this->assertEquals("hello, world", $res->getHeader("bc-param1"));
$this->assertEquals("hello, world", $res->getBCParam("param1"));
$this->assertNull($res->getHeader("bc-param2"));
$this->assertNull($res->getBCParam("param2"));
$this->assertEquals($str, $res->toString());
}
/**
* Attempts to cache the sent entity by its last modification date
* @param int last modified time as unix timestamp
* @param string strong entity tag validator
* @param int optional expiration time
* @return int date of the client's cache version, if available
* @throws TerminateException
*/
public function lastModified($lastModified, $etag = NULL, $expire = NULL)
{
if (!Environment::isProduction()) {
return NULL;
}
$httpResponse = $this->getHttpResponse();
$match = FALSE;
if ($lastModified > 0) {
$httpResponse->setHeader('Last-Modified', HttpResponse::date($lastModified));
}
if ($etag != NULL) {
// intentionally ==
$etag = '"' . addslashes($etag) . '"';
$httpResponse->setHeader('ETag', $etag);
}
if ($expire !== NULL) {
$httpResponse->expire($expire);
}
$ifNoneMatch = $this->getHttpRequest()->getHeader('if-none-match');
$ifModifiedSince = $this->getHttpRequest()->getHeader('if-modified-since');
if ($ifModifiedSince !== NULL) {
$ifModifiedSince = strtotime($ifModifiedSince);
}
if ($ifNoneMatch !== NULL) {
if ($ifNoneMatch === '*') {
$match = TRUE;
// match, check if-modified-since
} elseif ($etag == NULL || strpos(' ' . strtr($ifNoneMatch, ",\t", ' '), ' ' . $etag) === FALSE) {
return $ifModifiedSince;
// no match, ignore if-modified-since
} else {
$match = TRUE;
// match, check if-modified-since
}
}
if ($ifModifiedSince !== NULL) {
if ($lastModified > 0 && $lastModified <= $ifModifiedSince) {
$match = TRUE;
} else {
return $ifModifiedSince;
}
}
if ($match) {
$httpResponse->setCode(IHttpResponse::S304_NOT_MODIFIED);
$httpResponse->setHeader('Content-Length', '0');
$this->terminate();
} else {
return $ifModifiedSince;
}
return NULL;
}
/**
* Test's the init function of the http parser instance
*/
public function testInitFunction()
{
$parser = $this->parser;
// build up request
$parser->parseStartLine('GET / HTTP/1.1');
$parser->parseHeaderLine('Host: localhost');
// build up response
$parser->getResponse()->setStatus(200);
$parser->getResponse()->appendBodyStream('Hello World');
// get clean request and response objects
$cleanRequest = new HttpRequest();
$cleanResponse = new HttpResponse();
// remove those resources to be able to compare them via php unit
$cleanRequest->setBodyStream(null);
$cleanResponse->setBodyStream(null);
// finally init parser
$parser->init();
// remove those resources to be able to compare them via php unit
$parser->getRequest()->setBodyStream(null);
$parser->getResponse()->setBodyStream(null);
$this->assertEquals($cleanRequest, $parser->getRequest());
$this->assertEquals($cleanResponse, $parser->getResponse());
}
