mirror of
https://github.com/yiisoft/yii2.git
synced 2025-11-04 06:37:55 +08:00
1139 lines
43 KiB
PHP
1139 lines
43 KiB
PHP
<?php
|
|
/**
|
|
* @link http://www.yiiframework.com/
|
|
* @copyright Copyright (c) 2008 Yii Software LLC
|
|
* @license http://www.yiiframework.com/license/
|
|
*/
|
|
|
|
namespace yii\web;
|
|
|
|
use Yii;
|
|
use yii\base\InvalidArgumentException;
|
|
use yii\base\InvalidConfigException;
|
|
use yii\helpers\FileHelper;
|
|
use yii\helpers\Inflector;
|
|
use yii\helpers\StringHelper;
|
|
use yii\helpers\Url;
|
|
|
|
/**
|
|
* The web Response class represents an HTTP response.
|
|
*
|
|
* It holds the [[headers]], [[cookies]] and [[content]] that is to be sent to the client.
|
|
* It also controls the HTTP [[statusCode|status code]].
|
|
*
|
|
* Response is configured as an application component in [[\yii\web\Application]] by default.
|
|
* You can access that instance via `Yii::$app->response`.
|
|
*
|
|
* You can modify its configuration by adding an array to your application config under `components`
|
|
* as it is shown in the following example:
|
|
*
|
|
* ```php
|
|
* 'response' => [
|
|
* 'format' => yii\web\Response::FORMAT_JSON,
|
|
* 'charset' => 'UTF-8',
|
|
* // ...
|
|
* ]
|
|
* ```
|
|
*
|
|
* For more details and usage information on Response, see the [guide article on responses](guide:runtime-responses).
|
|
*
|
|
* @property-read CookieCollection $cookies The cookie collection. This property is read-only.
|
|
* @property-write string $downloadHeaders The attachment file name. This property is write-only.
|
|
* @property-read HeaderCollection $headers The header collection. This property is read-only.
|
|
* @property-read bool $isClientError Whether this response indicates a client error. This property is
|
|
* read-only.
|
|
* @property-read bool $isEmpty Whether this response is empty. This property is read-only.
|
|
* @property-read bool $isForbidden Whether this response indicates the current request is forbidden. This
|
|
* property is read-only.
|
|
* @property-read bool $isInformational Whether this response is informational. This property is read-only.
|
|
* @property-read bool $isInvalid Whether this response has a valid [[statusCode]]. This property is
|
|
* read-only.
|
|
* @property-read bool $isNotFound Whether this response indicates the currently requested resource is not
|
|
* found. This property is read-only.
|
|
* @property-read bool $isOk Whether this response is OK. This property is read-only.
|
|
* @property-read bool $isRedirection Whether this response is a redirection. This property is read-only.
|
|
* @property-read bool $isServerError Whether this response indicates a server error. This property is
|
|
* read-only.
|
|
* @property-read bool $isSuccessful Whether this response is successful. This property is read-only.
|
|
* @property int $statusCode The HTTP status code to send with the response.
|
|
* @property-write \Exception|\Error|\Throwable $statusCodeByException The exception object. This property is
|
|
* write-only.
|
|
*
|
|
* @author Qiang Xue <qiang.xue@gmail.com>
|
|
* @author Carsten Brandt <mail@cebe.cc>
|
|
* @since 2.0
|
|
*/
|
|
class Response extends \yii\base\Response
|
|
{
|
|
/**
|
|
* @event \yii\base\Event an event that is triggered at the beginning of [[send()]].
|
|
*/
|
|
const EVENT_BEFORE_SEND = 'beforeSend';
|
|
/**
|
|
* @event \yii\base\Event an event that is triggered at the end of [[send()]].
|
|
*/
|
|
const EVENT_AFTER_SEND = 'afterSend';
|
|
/**
|
|
* @event \yii\base\Event an event that is triggered right after [[prepare()]] is called in [[send()]].
|
|
* You may respond to this event to filter the response content before it is sent to the client.
|
|
*/
|
|
const EVENT_AFTER_PREPARE = 'afterPrepare';
|
|
const FORMAT_RAW = 'raw';
|
|
const FORMAT_HTML = 'html';
|
|
const FORMAT_JSON = 'json';
|
|
const FORMAT_JSONP = 'jsonp';
|
|
const FORMAT_XML = 'xml';
|
|
|
|
/**
|
|
* @var string the response format. This determines how to convert [[data]] into [[content]]
|
|
* when the latter is not set. The value of this property must be one of the keys declared in the [[formatters]] array.
|
|
* By default, the following formats are supported:
|
|
*
|
|
* - [[FORMAT_RAW]]: the data will be treated as the response content without any conversion.
|
|
* No extra HTTP header will be added.
|
|
* - [[FORMAT_HTML]]: the data will be treated as the response content without any conversion.
|
|
* The "Content-Type" header will set as "text/html".
|
|
* - [[FORMAT_JSON]]: the data will be converted into JSON format, and the "Content-Type"
|
|
* header will be set as "application/json".
|
|
* - [[FORMAT_JSONP]]: the data will be converted into JSONP format, and the "Content-Type"
|
|
* header will be set as "text/javascript". Note that in this case `$data` must be an array
|
|
* with "data" and "callback" elements. The former refers to the actual data to be sent,
|
|
* while the latter refers to the name of the JavaScript callback.
|
|
* - [[FORMAT_XML]]: the data will be converted into XML format. Please refer to [[XmlResponseFormatter]]
|
|
* for more details.
|
|
*
|
|
* You may customize the formatting process or support additional formats by configuring [[formatters]].
|
|
* @see formatters
|
|
*/
|
|
public $format = self::FORMAT_HTML;
|
|
/**
|
|
* @var string the MIME type (e.g. `application/json`) from the request ACCEPT header chosen for this response.
|
|
* This property is mainly set by [[\yii\filters\ContentNegotiator]].
|
|
*/
|
|
public $acceptMimeType;
|
|
/**
|
|
* @var array the parameters (e.g. `['q' => 1, 'version' => '1.0']`) associated with the [[acceptMimeType|chosen MIME type]].
|
|
* This is a list of name-value pairs associated with [[acceptMimeType]] from the ACCEPT HTTP header.
|
|
* This property is mainly set by [[\yii\filters\ContentNegotiator]].
|
|
*/
|
|
public $acceptParams = [];
|
|
/**
|
|
* @var array the formatters for converting data into the response content of the specified [[format]].
|
|
* The array keys are the format names, and the array values are the corresponding configurations
|
|
* for creating the formatter objects.
|
|
* @see format
|
|
* @see defaultFormatters
|
|
*/
|
|
public $formatters = [];
|
|
/**
|
|
* @var mixed the original response data. When this is not null, it will be converted into [[content]]
|
|
* according to [[format]] when the response is being sent out.
|
|
* @see content
|
|
*/
|
|
public $data;
|
|
/**
|
|
* @var string the response content. When [[data]] is not null, it will be converted into [[content]]
|
|
* according to [[format]] when the response is being sent out.
|
|
* @see data
|
|
*/
|
|
public $content;
|
|
/**
|
|
* @var resource|array|callable the stream to be sent. This can be a stream handle or an array of stream handle,
|
|
* the begin position and the end position. Alternatively it can be set to a callable, which returns
|
|
* (or [yields](https://www.php.net/manual/en/language.generators.syntax.php)) an array of strings that should
|
|
* be echoed and flushed out one by one.
|
|
*
|
|
* Note that when this property is set, the [[data]] and [[content]] properties will be ignored by [[send()]].
|
|
*/
|
|
public $stream;
|
|
/**
|
|
* @var string the charset of the text response. If not set, it will use
|
|
* the value of [[Application::charset]].
|
|
*/
|
|
public $charset;
|
|
/**
|
|
* @var string the HTTP status description that comes together with the status code.
|
|
* @see httpStatuses
|
|
*/
|
|
public $statusText = 'OK';
|
|
/**
|
|
* @var string the version of the HTTP protocol to use. If not set, it will be determined via `$_SERVER['SERVER_PROTOCOL']`,
|
|
* or '1.1' if that is not available.
|
|
*/
|
|
public $version;
|
|
/**
|
|
* @var bool whether the response has been sent. If this is true, calling [[send()]] will do nothing.
|
|
*/
|
|
public $isSent = false;
|
|
/**
|
|
* @var array list of HTTP status codes and the corresponding texts
|
|
*/
|
|
public static $httpStatuses = [
|
|
100 => 'Continue',
|
|
101 => 'Switching Protocols',
|
|
102 => 'Processing',
|
|
118 => 'Connection timed out',
|
|
200 => 'OK',
|
|
201 => 'Created',
|
|
202 => 'Accepted',
|
|
203 => 'Non-Authoritative',
|
|
204 => 'No Content',
|
|
205 => 'Reset Content',
|
|
206 => 'Partial Content',
|
|
207 => 'Multi-Status',
|
|
208 => 'Already Reported',
|
|
210 => 'Content Different',
|
|
226 => 'IM Used',
|
|
300 => 'Multiple Choices',
|
|
301 => 'Moved Permanently',
|
|
302 => 'Found',
|
|
303 => 'See Other',
|
|
304 => 'Not Modified',
|
|
305 => 'Use Proxy',
|
|
306 => 'Reserved',
|
|
307 => 'Temporary Redirect',
|
|
308 => 'Permanent Redirect',
|
|
310 => 'Too many 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 Time-out',
|
|
409 => 'Conflict',
|
|
410 => 'Gone',
|
|
411 => 'Length Required',
|
|
412 => 'Precondition Failed',
|
|
413 => 'Request Entity Too Large',
|
|
414 => 'Request-URI Too Long',
|
|
415 => 'Unsupported Media Type',
|
|
416 => 'Requested range unsatisfiable',
|
|
417 => 'Expectation failed',
|
|
418 => 'I\'m a teapot',
|
|
421 => 'Misdirected Request',
|
|
422 => 'Unprocessable entity',
|
|
423 => 'Locked',
|
|
424 => 'Method failure',
|
|
425 => 'Unordered Collection',
|
|
426 => 'Upgrade Required',
|
|
428 => 'Precondition Required',
|
|
429 => 'Too Many Requests',
|
|
431 => 'Request Header Fields Too Large',
|
|
449 => 'Retry With',
|
|
450 => 'Blocked by Windows Parental Controls',
|
|
451 => 'Unavailable For Legal Reasons',
|
|
500 => 'Internal Server Error',
|
|
501 => 'Not Implemented',
|
|
502 => 'Bad Gateway or Proxy Error',
|
|
503 => 'Service Unavailable',
|
|
504 => 'Gateway Time-out',
|
|
505 => 'HTTP Version not supported',
|
|
507 => 'Insufficient storage',
|
|
508 => 'Loop Detected',
|
|
509 => 'Bandwidth Limit Exceeded',
|
|
510 => 'Not Extended',
|
|
511 => 'Network Authentication Required',
|
|
];
|
|
|
|
/**
|
|
* @var int the HTTP status code to send with the response.
|
|
*/
|
|
private $_statusCode = 200;
|
|
/**
|
|
* @var HeaderCollection
|
|
*/
|
|
private $_headers;
|
|
|
|
|
|
/**
|
|
* Initializes this component.
|
|
*/
|
|
public function init()
|
|
{
|
|
if ($this->version === null) {
|
|
if (isset($_SERVER['SERVER_PROTOCOL']) && $_SERVER['SERVER_PROTOCOL'] === 'HTTP/1.0') {
|
|
$this->version = '1.0';
|
|
} else {
|
|
$this->version = '1.1';
|
|
}
|
|
}
|
|
if ($this->charset === null) {
|
|
$this->charset = Yii::$app->charset;
|
|
}
|
|
$this->formatters = array_merge($this->defaultFormatters(), $this->formatters);
|
|
}
|
|
|
|
/**
|
|
* @return int the HTTP status code to send with the response.
|
|
*/
|
|
public function getStatusCode()
|
|
{
|
|
return $this->_statusCode;
|
|
}
|
|
|
|
/**
|
|
* Sets the response status code.
|
|
* This method will set the corresponding status text if `$text` is null.
|
|
* @param int $value the status code
|
|
* @param string $text the status text. If not set, it will be set automatically based on the status code.
|
|
* @throws InvalidArgumentException if the status code is invalid.
|
|
* @return $this the response object itself
|
|
*/
|
|
public function setStatusCode($value, $text = null)
|
|
{
|
|
if ($value === null) {
|
|
$value = 200;
|
|
}
|
|
$this->_statusCode = (int) $value;
|
|
if ($this->getIsInvalid()) {
|
|
throw new InvalidArgumentException("The HTTP status code is invalid: $value");
|
|
}
|
|
if ($text === null) {
|
|
$this->statusText = isset(static::$httpStatuses[$this->_statusCode]) ? static::$httpStatuses[$this->_statusCode] : '';
|
|
} else {
|
|
$this->statusText = $text;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets the response status code based on the exception.
|
|
* @param \Exception|\Error|\Throwable $e the exception object.
|
|
* @throws InvalidArgumentException if the status code is invalid.
|
|
* @return $this the response object itself
|
|
* @since 2.0.12
|
|
*/
|
|
public function setStatusCodeByException($e)
|
|
{
|
|
if ($e instanceof HttpException) {
|
|
$this->setStatusCode($e->statusCode);
|
|
} else {
|
|
$this->setStatusCode(500);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the header collection.
|
|
* The header collection contains the currently registered HTTP headers.
|
|
* @return HeaderCollection the header collection
|
|
*/
|
|
public function getHeaders()
|
|
{
|
|
if ($this->_headers === null) {
|
|
$this->_headers = new HeaderCollection();
|
|
}
|
|
|
|
return $this->_headers;
|
|
}
|
|
|
|
/**
|
|
* Sends the response to the client.
|
|
*/
|
|
public function send()
|
|
{
|
|
if ($this->isSent) {
|
|
return;
|
|
}
|
|
$this->trigger(self::EVENT_BEFORE_SEND);
|
|
$this->prepare();
|
|
$this->trigger(self::EVENT_AFTER_PREPARE);
|
|
$this->sendHeaders();
|
|
$this->sendContent();
|
|
$this->trigger(self::EVENT_AFTER_SEND);
|
|
$this->isSent = true;
|
|
}
|
|
|
|
/**
|
|
* Clears the headers, cookies, content, status code of the response.
|
|
*/
|
|
public function clear()
|
|
{
|
|
$this->_headers = null;
|
|
$this->_cookies = null;
|
|
$this->_statusCode = 200;
|
|
$this->statusText = 'OK';
|
|
$this->data = null;
|
|
$this->stream = null;
|
|
$this->content = null;
|
|
$this->isSent = false;
|
|
}
|
|
|
|
/**
|
|
* Sends the response headers to the client.
|
|
*/
|
|
protected function sendHeaders()
|
|
{
|
|
if (headers_sent($file, $line)) {
|
|
throw new HeadersAlreadySentException($file, $line);
|
|
}
|
|
if ($this->_headers) {
|
|
foreach ($this->getHeaders() as $name => $values) {
|
|
$name = str_replace(' ', '-', ucwords(str_replace('-', ' ', $name)));
|
|
// set replace for first occurrence of header but false afterwards to allow multiple
|
|
$replace = true;
|
|
foreach ($values as $value) {
|
|
header("$name: $value", $replace);
|
|
$replace = false;
|
|
}
|
|
}
|
|
}
|
|
$statusCode = $this->getStatusCode();
|
|
header("HTTP/{$this->version} {$statusCode} {$this->statusText}");
|
|
$this->sendCookies();
|
|
}
|
|
|
|
/**
|
|
* Sends the cookies to the client.
|
|
*/
|
|
protected function sendCookies()
|
|
{
|
|
if ($this->_cookies === null) {
|
|
return;
|
|
}
|
|
$request = Yii::$app->getRequest();
|
|
if ($request->enableCookieValidation) {
|
|
if ($request->cookieValidationKey == '') {
|
|
throw new InvalidConfigException(get_class($request) . '::cookieValidationKey must be configured with a secret key.');
|
|
}
|
|
$validationKey = $request->cookieValidationKey;
|
|
}
|
|
foreach ($this->getCookies() as $cookie) {
|
|
$value = $cookie->value;
|
|
if ($cookie->expire != 1 && isset($validationKey)) {
|
|
$value = Yii::$app->getSecurity()->hashData(serialize([$cookie->name, $value]), $validationKey);
|
|
}
|
|
if (PHP_VERSION_ID >= 70300) {
|
|
setcookie($cookie->name, $value, [
|
|
'expires' => $cookie->expire,
|
|
'path' => $cookie->path,
|
|
'domain' => $cookie->domain,
|
|
'secure' => $cookie->secure,
|
|
'httpOnly' => $cookie->httpOnly,
|
|
'sameSite' => !empty($cookie->sameSite) ? $cookie->sameSite : null,
|
|
]);
|
|
} else {
|
|
// Work around for setting sameSite cookie prior PHP 7.3
|
|
// https://stackoverflow.com/questions/39750906/php-setcookie-samesite-strict/46971326#46971326
|
|
$cookiePath = $cookie->path;
|
|
if (!is_null($cookie->sameSite)) {
|
|
$cookiePath .= '; samesite=' . $cookie->sameSite;
|
|
}
|
|
setcookie($cookie->name, $value, $cookie->expire, $cookiePath, $cookie->domain, $cookie->secure, $cookie->httpOnly);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sends the response content to the client.
|
|
*/
|
|
protected function sendContent()
|
|
{
|
|
if ($this->stream === null) {
|
|
echo $this->content;
|
|
|
|
return;
|
|
}
|
|
|
|
// Try to reset time limit for big files
|
|
if (!function_exists('set_time_limit') || !@set_time_limit(0)) {
|
|
Yii::warning('set_time_limit() is not available', __METHOD__);
|
|
}
|
|
|
|
if (is_callable($this->stream)) {
|
|
$data = call_user_func($this->stream);
|
|
foreach ($data as $datum) {
|
|
echo $datum;
|
|
flush();
|
|
}
|
|
return;
|
|
}
|
|
|
|
$chunkSize = 8 * 1024 * 1024; // 8MB per chunk
|
|
|
|
if (is_array($this->stream)) {
|
|
list($handle, $begin, $end) = $this->stream;
|
|
|
|
// only seek if stream is seekable
|
|
if ($this->isSeekable($handle)) {
|
|
fseek($handle, $begin);
|
|
}
|
|
|
|
while (!feof($handle) && ($pos = ftell($handle)) <= $end) {
|
|
if ($pos + $chunkSize > $end) {
|
|
$chunkSize = $end - $pos + 1;
|
|
}
|
|
echo fread($handle, $chunkSize);
|
|
flush(); // Free up memory. Otherwise large files will trigger PHP's memory limit.
|
|
}
|
|
fclose($handle);
|
|
} else {
|
|
while (!feof($this->stream)) {
|
|
echo fread($this->stream, $chunkSize);
|
|
flush();
|
|
}
|
|
fclose($this->stream);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sends a file to the browser.
|
|
*
|
|
* Note that this method only prepares the response for file sending. The file is not sent
|
|
* until [[send()]] is called explicitly or implicitly. The latter is done after you return from a controller action.
|
|
*
|
|
* The following is an example implementation of a controller action that allows requesting files from a directory
|
|
* that is not accessible from web:
|
|
*
|
|
* ```php
|
|
* public function actionFile($filename)
|
|
* {
|
|
* $storagePath = Yii::getAlias('@app/files');
|
|
*
|
|
* // check filename for allowed chars (do not allow ../ to avoid security issue: downloading arbitrary files)
|
|
* if (!preg_match('/^[a-z0-9]+\.[a-z0-9]+$/i', $filename) || !is_file("$storagePath/$filename")) {
|
|
* throw new \yii\web\NotFoundHttpException('The file does not exists.');
|
|
* }
|
|
* return Yii::$app->response->sendFile("$storagePath/$filename", $filename);
|
|
* }
|
|
* ```
|
|
*
|
|
* @param string $filePath the path of the file to be sent.
|
|
* @param string $attachmentName the file name shown to the user. If null, it will be determined from `$filePath`.
|
|
* @param array $options additional options for sending the file. The following options are supported:
|
|
*
|
|
* - `mimeType`: the MIME type of the content. If not set, it will be guessed based on `$filePath`
|
|
* - `inline`: boolean, whether the browser should open the file within the browser window. Defaults to false,
|
|
* meaning a download dialog will pop up.
|
|
*
|
|
* @return $this the response object itself
|
|
* @see sendContentAsFile()
|
|
* @see sendStreamAsFile()
|
|
* @see xSendFile()
|
|
*/
|
|
public function sendFile($filePath, $attachmentName = null, $options = [])
|
|
{
|
|
if (!isset($options['mimeType'])) {
|
|
$options['mimeType'] = FileHelper::getMimeTypeByExtension($filePath);
|
|
}
|
|
if ($attachmentName === null) {
|
|
$attachmentName = basename($filePath);
|
|
}
|
|
$handle = fopen($filePath, 'rb');
|
|
$this->sendStreamAsFile($handle, $attachmentName, $options);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sends the specified content as a file to the browser.
|
|
*
|
|
* Note that this method only prepares the response for file sending. The file is not sent
|
|
* until [[send()]] is called explicitly or implicitly. The latter is done after you return from a controller action.
|
|
*
|
|
* @param string $content the content to be sent. The existing [[content]] will be discarded.
|
|
* @param string $attachmentName the file name shown to the user.
|
|
* @param array $options additional options for sending the file. The following options are supported:
|
|
*
|
|
* - `mimeType`: the MIME type of the content. Defaults to 'application/octet-stream'.
|
|
* - `inline`: boolean, whether the browser should open the file within the browser window. Defaults to false,
|
|
* meaning a download dialog will pop up.
|
|
*
|
|
* @return $this the response object itself
|
|
* @throws RangeNotSatisfiableHttpException if the requested range is not satisfiable
|
|
* @see sendFile() for an example implementation.
|
|
*/
|
|
public function sendContentAsFile($content, $attachmentName, $options = [])
|
|
{
|
|
$headers = $this->getHeaders();
|
|
|
|
$contentLength = StringHelper::byteLength($content);
|
|
$range = $this->getHttpRange($contentLength);
|
|
|
|
if ($range === false) {
|
|
$headers->set('Content-Range', "bytes */$contentLength");
|
|
throw new RangeNotSatisfiableHttpException();
|
|
}
|
|
|
|
list($begin, $end) = $range;
|
|
if ($begin != 0 || $end != $contentLength - 1) {
|
|
$this->setStatusCode(206);
|
|
$headers->set('Content-Range', "bytes $begin-$end/$contentLength");
|
|
$this->content = StringHelper::byteSubstr($content, $begin, $end - $begin + 1);
|
|
} else {
|
|
$this->setStatusCode(200);
|
|
$this->content = $content;
|
|
}
|
|
|
|
$mimeType = isset($options['mimeType']) ? $options['mimeType'] : 'application/octet-stream';
|
|
$this->setDownloadHeaders($attachmentName, $mimeType, !empty($options['inline']), $end - $begin + 1);
|
|
|
|
$this->format = self::FORMAT_RAW;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sends the specified stream as a file to the browser.
|
|
*
|
|
* Note that this method only prepares the response for file sending. The file is not sent
|
|
* until [[send()]] is called explicitly or implicitly. The latter is done after you return from a controller action.
|
|
*
|
|
* @param resource $handle the handle of the stream to be sent.
|
|
* @param string $attachmentName the file name shown to the user.
|
|
* @param array $options additional options for sending the file. The following options are supported:
|
|
*
|
|
* - `mimeType`: the MIME type of the content. Defaults to 'application/octet-stream'.
|
|
* - `inline`: boolean, whether the browser should open the file within the browser window. Defaults to false,
|
|
* meaning a download dialog will pop up.
|
|
* - `fileSize`: the size of the content to stream this is useful when size of the content is known
|
|
* and the content is not seekable. Defaults to content size using `ftell()`.
|
|
* This option is available since version 2.0.4.
|
|
*
|
|
* @return $this the response object itself
|
|
* @throws RangeNotSatisfiableHttpException if the requested range is not satisfiable
|
|
* @see sendFile() for an example implementation.
|
|
*/
|
|
public function sendStreamAsFile($handle, $attachmentName, $options = [])
|
|
{
|
|
$headers = $this->getHeaders();
|
|
if (isset($options['fileSize'])) {
|
|
$fileSize = $options['fileSize'];
|
|
} else {
|
|
if ($this->isSeekable($handle)) {
|
|
fseek($handle, 0, SEEK_END);
|
|
$fileSize = ftell($handle);
|
|
} else {
|
|
$fileSize = 0;
|
|
}
|
|
}
|
|
|
|
$range = $this->getHttpRange($fileSize);
|
|
if ($range === false) {
|
|
$headers->set('Content-Range', "bytes */$fileSize");
|
|
throw new RangeNotSatisfiableHttpException();
|
|
}
|
|
|
|
list($begin, $end) = $range;
|
|
if ($begin != 0 || $end != $fileSize - 1) {
|
|
$this->setStatusCode(206);
|
|
$headers->set('Content-Range', "bytes $begin-$end/$fileSize");
|
|
} else {
|
|
$this->setStatusCode(200);
|
|
}
|
|
|
|
$mimeType = isset($options['mimeType']) ? $options['mimeType'] : 'application/octet-stream';
|
|
$this->setDownloadHeaders($attachmentName, $mimeType, !empty($options['inline']), $end - $begin + 1);
|
|
|
|
$this->format = self::FORMAT_RAW;
|
|
$this->stream = [$handle, $begin, $end];
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets a default set of HTTP headers for file downloading purpose.
|
|
* @param string $attachmentName the attachment file name
|
|
* @param string $mimeType the MIME type for the response. If null, `Content-Type` header will NOT be set.
|
|
* @param bool $inline whether the browser should open the file within the browser window. Defaults to false,
|
|
* meaning a download dialog will pop up.
|
|
* @param int $contentLength the byte length of the file being downloaded. If null, `Content-Length` header will NOT be set.
|
|
* @return $this the response object itself
|
|
*/
|
|
public function setDownloadHeaders($attachmentName, $mimeType = null, $inline = false, $contentLength = null)
|
|
{
|
|
$headers = $this->getHeaders();
|
|
|
|
$disposition = $inline ? 'inline' : 'attachment';
|
|
$headers->setDefault('Pragma', 'public')
|
|
->setDefault('Accept-Ranges', 'bytes')
|
|
->setDefault('Expires', '0')
|
|
->setDefault('Cache-Control', 'must-revalidate, post-check=0, pre-check=0')
|
|
->setDefault('Content-Disposition', $this->getDispositionHeaderValue($disposition, $attachmentName));
|
|
|
|
if ($mimeType !== null) {
|
|
$headers->setDefault('Content-Type', $mimeType);
|
|
}
|
|
|
|
if ($contentLength !== null) {
|
|
$headers->setDefault('Content-Length', $contentLength);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Determines the HTTP range given in the request.
|
|
* @param int $fileSize the size of the file that will be used to validate the requested HTTP range.
|
|
* @return array|bool the range (begin, end), or false if the range request is invalid.
|
|
*/
|
|
protected function getHttpRange($fileSize)
|
|
{
|
|
$rangeHeader = Yii::$app->getRequest()->getHeaders()->get('Range', '-');
|
|
if ($rangeHeader === '-') {
|
|
return [0, $fileSize - 1];
|
|
}
|
|
if (!preg_match('/^bytes=(\d*)-(\d*)$/', $rangeHeader, $matches)) {
|
|
return false;
|
|
}
|
|
if ($matches[1] === '') {
|
|
$start = $fileSize - $matches[2];
|
|
$end = $fileSize - 1;
|
|
} elseif ($matches[2] !== '') {
|
|
$start = $matches[1];
|
|
$end = $matches[2];
|
|
if ($end >= $fileSize) {
|
|
$end = $fileSize - 1;
|
|
}
|
|
} else {
|
|
$start = $matches[1];
|
|
$end = $fileSize - 1;
|
|
}
|
|
if ($start < 0 || $start > $end) {
|
|
return false;
|
|
}
|
|
|
|
return [$start, $end];
|
|
}
|
|
|
|
/**
|
|
* Sends existing file to a browser as a download using x-sendfile.
|
|
*
|
|
* X-Sendfile is a feature allowing a web application to redirect the request for a file to the webserver
|
|
* that in turn processes the request, this way eliminating the need to perform tasks like reading the file
|
|
* and sending it to the user. When dealing with a lot of files (or very big files) this can lead to a great
|
|
* increase in performance as the web application is allowed to terminate earlier while the webserver is
|
|
* handling the request.
|
|
*
|
|
* The request is sent to the server through a special non-standard HTTP-header.
|
|
* When the web server encounters the presence of such header it will discard all output and send the file
|
|
* specified by that header using web server internals including all optimizations like caching-headers.
|
|
*
|
|
* As this header directive is non-standard different directives exists for different web servers applications:
|
|
*
|
|
* - Apache: [X-Sendfile](http://tn123.org/mod_xsendfile)
|
|
* - Lighttpd v1.4: [X-LIGHTTPD-send-file](http://redmine.lighttpd.net/projects/lighttpd/wiki/X-LIGHTTPD-send-file)
|
|
* - Lighttpd v1.5: [X-Sendfile](http://redmine.lighttpd.net/projects/lighttpd/wiki/X-LIGHTTPD-send-file)
|
|
* - Nginx: [X-Accel-Redirect](http://wiki.nginx.org/XSendfile)
|
|
* - Cherokee: [X-Sendfile and X-Accel-Redirect](http://www.cherokee-project.com/doc/other_goodies.html#x-sendfile)
|
|
*
|
|
* So for this method to work the X-SENDFILE option/module should be enabled by the web server and
|
|
* a proper xHeader should be sent.
|
|
*
|
|
* **Note**
|
|
*
|
|
* This option allows to download files that are not under web folders, and even files that are otherwise protected
|
|
* (deny from all) like `.htaccess`.
|
|
*
|
|
* **Side effects**
|
|
*
|
|
* If this option is disabled by the web server, when this method is called a download configuration dialog
|
|
* will open but the downloaded file will have 0 bytes.
|
|
*
|
|
* **Known issues**
|
|
*
|
|
* There is a Bug with Internet Explorer 6, 7 and 8 when X-SENDFILE is used over an SSL connection, it will show
|
|
* an error message like this: "Internet Explorer was not able to open this Internet site. The requested site
|
|
* is either unavailable or cannot be found.". You can work around this problem by removing the `Pragma`-header.
|
|
*
|
|
* **Example**
|
|
*
|
|
* ```php
|
|
* Yii::$app->response->xSendFile('/home/user/Pictures/picture1.jpg');
|
|
* ```
|
|
*
|
|
* @param string $filePath file name with full path
|
|
* @param string $attachmentName file name shown to the user. If null, it will be determined from `$filePath`.
|
|
* @param array $options additional options for sending the file. The following options are supported:
|
|
*
|
|
* - `mimeType`: the MIME type of the content. If not set, it will be guessed based on `$filePath`
|
|
* - `inline`: boolean, whether the browser should open the file within the browser window. Defaults to false,
|
|
* meaning a download dialog will pop up.
|
|
* - xHeader: string, the name of the x-sendfile header. Defaults to "X-Sendfile".
|
|
*
|
|
* @return $this the response object itself
|
|
* @see sendFile()
|
|
*/
|
|
public function xSendFile($filePath, $attachmentName = null, $options = [])
|
|
{
|
|
if ($attachmentName === null) {
|
|
$attachmentName = basename($filePath);
|
|
}
|
|
if (isset($options['mimeType'])) {
|
|
$mimeType = $options['mimeType'];
|
|
} elseif (($mimeType = FileHelper::getMimeTypeByExtension($filePath)) === null) {
|
|
$mimeType = 'application/octet-stream';
|
|
}
|
|
if (isset($options['xHeader'])) {
|
|
$xHeader = $options['xHeader'];
|
|
} else {
|
|
$xHeader = 'X-Sendfile';
|
|
}
|
|
|
|
$disposition = empty($options['inline']) ? 'attachment' : 'inline';
|
|
$this->getHeaders()
|
|
->setDefault($xHeader, $filePath)
|
|
->setDefault('Content-Type', $mimeType)
|
|
->setDefault('Content-Disposition', $this->getDispositionHeaderValue($disposition, $attachmentName));
|
|
|
|
$this->format = self::FORMAT_RAW;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns Content-Disposition header value that is safe to use with both old and new browsers.
|
|
*
|
|
* Fallback name:
|
|
*
|
|
* - Causes issues if contains non-ASCII characters with codes less than 32 or more than 126.
|
|
* - Causes issues if contains urlencoded characters (starting with `%`) or `%` character. Some browsers interpret
|
|
* `filename="X"` as urlencoded name, some don't.
|
|
* - Causes issues if contains path separator characters such as `\` or `/`.
|
|
* - Since value is wrapped with `"`, it should be escaped as `\"`.
|
|
* - Since input could contain non-ASCII characters, fallback is obtained by transliteration.
|
|
*
|
|
* UTF name:
|
|
*
|
|
* - Causes issues if contains path separator characters such as `\` or `/`.
|
|
* - Should be urlencoded since headers are ASCII-only.
|
|
* - Could be omitted if it exactly matches fallback name.
|
|
*
|
|
* @param string $disposition
|
|
* @param string $attachmentName
|
|
* @return string
|
|
*
|
|
* @since 2.0.10
|
|
*/
|
|
protected function getDispositionHeaderValue($disposition, $attachmentName)
|
|
{
|
|
$fallbackName = str_replace(
|
|
['%', '/', '\\', '"', "\x7F"],
|
|
['_', '_', '_', '\\"', '_'],
|
|
Inflector::transliterate($attachmentName, Inflector::TRANSLITERATE_LOOSE)
|
|
);
|
|
$utfName = rawurlencode(str_replace(['%', '/', '\\'], '', $attachmentName));
|
|
|
|
$dispositionHeader = "{$disposition}; filename=\"{$fallbackName}\"";
|
|
if ($utfName !== $fallbackName) {
|
|
$dispositionHeader .= "; filename*=utf-8''{$utfName}";
|
|
}
|
|
|
|
return $dispositionHeader;
|
|
}
|
|
|
|
/**
|
|
* Redirects the browser to the specified URL.
|
|
*
|
|
* This method adds a "Location" header to the current response. Note that it does not send out
|
|
* the header until [[send()]] is called. In a controller action you may use this method as follows:
|
|
*
|
|
* ```php
|
|
* return Yii::$app->getResponse()->redirect($url);
|
|
* ```
|
|
*
|
|
* In other places, if you want to send out the "Location" header immediately, you should use
|
|
* the following code:
|
|
*
|
|
* ```php
|
|
* Yii::$app->getResponse()->redirect($url)->send();
|
|
* return;
|
|
* ```
|
|
*
|
|
* In AJAX mode, this normally will not work as expected unless there are some
|
|
* client-side JavaScript code handling the redirection. To help achieve this goal,
|
|
* this method will send out a "X-Redirect" header instead of "Location".
|
|
*
|
|
* If you use the "yii" JavaScript module, it will handle the AJAX redirection as
|
|
* described above. Otherwise, you should write the following JavaScript code to
|
|
* handle the redirection:
|
|
*
|
|
* ```javascript
|
|
* $document.ajaxComplete(function (event, xhr, settings) {
|
|
* var url = xhr && xhr.getResponseHeader('X-Redirect');
|
|
* if (url) {
|
|
* window.location = url;
|
|
* }
|
|
* });
|
|
* ```
|
|
*
|
|
* @param string|array $url the URL to be redirected to. This can be in one of the following formats:
|
|
*
|
|
* - a string representing a URL (e.g. "http://example.com")
|
|
* - a string representing a URL alias (e.g. "@example.com")
|
|
* - an array in the format of `[$route, ...name-value pairs...]` (e.g. `['site/index', 'ref' => 1]`).
|
|
* Note that the route is with respect to the whole application, instead of relative to a controller or module.
|
|
* [[Url::to()]] will be used to convert the array into a URL.
|
|
*
|
|
* Any relative URL that starts with a single forward slash "/" will be converted
|
|
* into an absolute one by prepending it with the host info of the current request.
|
|
*
|
|
* @param int $statusCode the HTTP status code. Defaults to 302.
|
|
* See <https://tools.ietf.org/html/rfc2616#section-10>
|
|
* for details about HTTP status code
|
|
* @param bool $checkAjax whether to specially handle AJAX (and PJAX) requests. Defaults to true,
|
|
* meaning if the current request is an AJAX or PJAX request, then calling this method will cause the browser
|
|
* to redirect to the given URL. If this is false, a `Location` header will be sent, which when received as
|
|
* an AJAX/PJAX response, may NOT cause browser redirection.
|
|
* Takes effect only when request header `X-Ie-Redirect-Compatibility` is absent.
|
|
* @return $this the response object itself
|
|
*/
|
|
public function redirect($url, $statusCode = 302, $checkAjax = true)
|
|
{
|
|
if (is_array($url) && isset($url[0])) {
|
|
// ensure the route is absolute
|
|
$url[0] = '/' . ltrim($url[0], '/');
|
|
}
|
|
$request = Yii::$app->getRequest();
|
|
$url = Url::to($url);
|
|
if (strncmp($url, '/', 1) === 0 && strncmp($url, '//', 2) !== 0) {
|
|
$url = $request->getHostInfo() . $url;
|
|
}
|
|
|
|
if ($checkAjax) {
|
|
if ($request->getIsAjax()) {
|
|
if (in_array($statusCode, [301, 302]) && preg_match('/Trident\/|MSIE[ ]/', $request->userAgent)) {
|
|
$statusCode = 200;
|
|
}
|
|
if ($request->getIsPjax()) {
|
|
$this->getHeaders()->set('X-Pjax-Url', $url);
|
|
} else {
|
|
$this->getHeaders()->set('X-Redirect', $url);
|
|
}
|
|
} else {
|
|
$this->getHeaders()->set('Location', $url);
|
|
}
|
|
} else {
|
|
$this->getHeaders()->set('Location', $url);
|
|
}
|
|
|
|
$this->setStatusCode($statusCode);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Refreshes the current page.
|
|
* The effect of this method call is the same as the user pressing the refresh button of his browser
|
|
* (without re-posting data).
|
|
*
|
|
* In a controller action you may use this method like this:
|
|
*
|
|
* ```php
|
|
* return Yii::$app->getResponse()->refresh();
|
|
* ```
|
|
*
|
|
* @param string $anchor the anchor that should be appended to the redirection URL.
|
|
* Defaults to empty. Make sure the anchor starts with '#' if you want to specify it.
|
|
* @return Response the response object itself
|
|
*/
|
|
public function refresh($anchor = '')
|
|
{
|
|
return $this->redirect(Yii::$app->getRequest()->getUrl() . $anchor);
|
|
}
|
|
|
|
private $_cookies;
|
|
|
|
/**
|
|
* Returns the cookie collection.
|
|
*
|
|
* Through the returned cookie collection, you add or remove cookies as follows,
|
|
*
|
|
* ```php
|
|
* // add a cookie
|
|
* $response->cookies->add(new Cookie([
|
|
* 'name' => $name,
|
|
* 'value' => $value,
|
|
* ]);
|
|
*
|
|
* // remove a cookie
|
|
* $response->cookies->remove('name');
|
|
* // alternatively
|
|
* unset($response->cookies['name']);
|
|
* ```
|
|
*
|
|
* @return CookieCollection the cookie collection.
|
|
*/
|
|
public function getCookies()
|
|
{
|
|
if ($this->_cookies === null) {
|
|
$this->_cookies = new CookieCollection();
|
|
}
|
|
|
|
return $this->_cookies;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response has a valid [[statusCode]].
|
|
*/
|
|
public function getIsInvalid()
|
|
{
|
|
return $this->getStatusCode() < 100 || $this->getStatusCode() >= 600;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response is informational
|
|
*/
|
|
public function getIsInformational()
|
|
{
|
|
return $this->getStatusCode() >= 100 && $this->getStatusCode() < 200;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response is successful
|
|
*/
|
|
public function getIsSuccessful()
|
|
{
|
|
return $this->getStatusCode() >= 200 && $this->getStatusCode() < 300;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response is a redirection
|
|
*/
|
|
public function getIsRedirection()
|
|
{
|
|
return $this->getStatusCode() >= 300 && $this->getStatusCode() < 400;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response indicates a client error
|
|
*/
|
|
public function getIsClientError()
|
|
{
|
|
return $this->getStatusCode() >= 400 && $this->getStatusCode() < 500;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response indicates a server error
|
|
*/
|
|
public function getIsServerError()
|
|
{
|
|
return $this->getStatusCode() >= 500 && $this->getStatusCode() < 600;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response is OK
|
|
*/
|
|
public function getIsOk()
|
|
{
|
|
return $this->getStatusCode() == 200;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response indicates the current request is forbidden
|
|
*/
|
|
public function getIsForbidden()
|
|
{
|
|
return $this->getStatusCode() == 403;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response indicates the currently requested resource is not found
|
|
*/
|
|
public function getIsNotFound()
|
|
{
|
|
return $this->getStatusCode() == 404;
|
|
}
|
|
|
|
/**
|
|
* @return bool whether this response is empty
|
|
*/
|
|
public function getIsEmpty()
|
|
{
|
|
return in_array($this->getStatusCode(), [201, 204, 304]);
|
|
}
|
|
|
|
/**
|
|
* @return array the formatters that are supported by default
|
|
*/
|
|
protected function defaultFormatters()
|
|
{
|
|
return [
|
|
self::FORMAT_HTML => [
|
|
'class' => 'yii\web\HtmlResponseFormatter',
|
|
],
|
|
self::FORMAT_XML => [
|
|
'class' => 'yii\web\XmlResponseFormatter',
|
|
],
|
|
self::FORMAT_JSON => [
|
|
'class' => 'yii\web\JsonResponseFormatter',
|
|
],
|
|
self::FORMAT_JSONP => [
|
|
'class' => 'yii\web\JsonResponseFormatter',
|
|
'useJsonp' => true,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Prepares for sending the response.
|
|
* The default implementation will convert [[data]] into [[content]] and set headers accordingly.
|
|
* @throws InvalidConfigException if the formatter for the specified format is invalid or [[format]] is not supported
|
|
*
|
|
* @see https://tools.ietf.org/html/rfc7231#page-53
|
|
* @see https://tools.ietf.org/html/rfc7232#page-18
|
|
*/
|
|
protected function prepare()
|
|
{
|
|
if (in_array($this->getStatusCode(), [204, 304])) {
|
|
// A 204/304 response cannot contain a message body according to rfc7231/rfc7232
|
|
$this->content = '';
|
|
$this->stream = null;
|
|
return;
|
|
}
|
|
|
|
if ($this->stream !== null) {
|
|
return;
|
|
}
|
|
|
|
if (isset($this->formatters[$this->format])) {
|
|
$formatter = $this->formatters[$this->format];
|
|
if (!is_object($formatter)) {
|
|
$this->formatters[$this->format] = $formatter = Yii::createObject($formatter);
|
|
}
|
|
if ($formatter instanceof ResponseFormatterInterface) {
|
|
$formatter->format($this);
|
|
} else {
|
|
throw new InvalidConfigException("The '{$this->format}' response formatter is invalid. It must implement the ResponseFormatterInterface.");
|
|
}
|
|
} elseif ($this->format === self::FORMAT_RAW) {
|
|
if ($this->data !== null) {
|
|
$this->content = $this->data;
|
|
}
|
|
} else {
|
|
throw new InvalidConfigException("Unsupported response format: {$this->format}");
|
|
}
|
|
|
|
if (is_array($this->content)) {
|
|
throw new InvalidArgumentException('Response content must not be an array.');
|
|
} elseif (is_object($this->content)) {
|
|
if (method_exists($this->content, '__toString')) {
|
|
$this->content = $this->content->__toString();
|
|
} else {
|
|
throw new InvalidArgumentException('Response content must be a string or an object implementing __toString().');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if a stream is seekable
|
|
*
|
|
* @param $handle
|
|
* @return bool
|
|
*/
|
|
private function isSeekable($handle)
|
|
{
|
|
if (!is_resource($handle)) {
|
|
return true;
|
|
}
|
|
|
|
$metaData = stream_get_meta_data($handle);
|
|
return isset($metaData['seekable']) && $metaData['seekable'] === true;
|
|
}
|
|
}
|