public __construct( [ array $config = array(0) ] ) (defined in Kohana_Response)

Parameters

• array $config = array(0) - Setup the response object

Return Values

• void

public function __construct(array $config = array())
{
	$this->_header = new HTTP_Header;

	foreach ($config as $key => $value)
	{
		if (property_exists($this, $key))
		{
			if ($key == '_header')
			{
				$this->headers($value);
			}
			else
			{
				$this->$key = $value;
			}
		}
	}
}

public __toString( ) (defined in Kohana_Response)

Return Values

• string

public function __toString()
{
	return $this->_body;
}

public body( ) (defined in Kohana_Response)

Return Values

• mixed

public function body($content = NULL)
{
	if ($content === NULL)
		return $this->_body;

	$this->_body = (string) $content;
	return $this;
}

public content_length( ) (defined in Kohana_Response)

Return Values

• integer

public function content_length()
{
	return strlen($this->body());
}

public cookie( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Response)

// Get the cookies set to the response
$cookies = $response->cookie();

// Set a cookie to the response
$response->cookie('session', array(
     'value' => $value,
     'expiration' => 12352234
));

Parameters

• mixed $key = NULL - Cookie name, or array of cookie values
• string $value = NULL - Value to set to cookie

Return Values

• string
• void
• [Response]

public function cookie($key = NULL, $value = NULL)
{
	// Handle the get cookie calls
	if ($key === NULL)
		return $this->_cookies;
	elseif ( ! is_array($key) AND ! $value)
		return Arr::get($this->_cookies, $key);

	// Handle the set cookie calls
	if (is_array($key))
	{
		reset($key);
		while (list($_key, $_value) = each($key))
		{
			$this->cookie($_key, $_value);
		}
	}
	else
	{
		if ( ! is_array($value))
		{
			$value = array(
				'value' => $value,
				'expiration' => Cookie::$expiration
			);
		}
		elseif ( ! isset($value['expiration']))
		{
			$value['expiration'] = Cookie::$expiration;
		}

		$this->_cookies[$key] = $value;
	}

	return $this;
}

public delete_cookie( string $name ) (defined in Kohana_Response)

Parameters

• string $name required - $name

Return Values

• Response

public function delete_cookie($name)
{
	unset($this->_cookies[$name]);
	return $this;
}

public delete_cookies( ) (defined in Kohana_Response)

Return Values

• Response

public function delete_cookies()
{
	$this->_cookies = array();
	return $this;
}

public static factory( [ array $config = array(0) ] ) (defined in Kohana_Response)

 // Create a new response
 $response = Response::factory();

 // Create a new response with headers
 $response = Response::factory(array('status' => 200));

Parameters

• array $config = array(0) - Setup the response object

Return Values

• Response

public static function factory(array $config = array())
{
	return new Response($config);
}

public generate_etag( ) (defined in Kohana_Response)

Tags

• Throws - Request_Exception

Return Values

• String - Generated ETag

public function generate_etag()
{
    if ($this->_body === '')
	{
		throw new Request_Exception('No response yet associated with request - cannot auto generate resource ETag');
	}

	// Generate a unique hash for the response
	return '"'.sha1($this->render()).'"';
}

public headers( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Response)

  // Get a header
  $accept = $response->headers('Content-Type');

  // Set a header
  $response->headers('Content-Type', 'text/html');

  // Get all headers
  $headers = $response->headers();

  // Set multiple headers
  $response->headers(array('Content-Type' => 'text/html', 'Cache-Control' => 'no-cache'));

Parameters

• mixed $key = NULL - $key
• string $value = NULL - $value

Return Values

• mixed

public function headers($key = NULL, $value = NULL)
{
	if ($key === NULL)
	{
		return $this->_header;
	}
	elseif (is_array($key))
	{
		$this->_header->exchangeArray($key);
		return $this;
	}
	elseif ($value === NULL)
	{
		return Arr::get($this->_header, $key);
	}
	else
	{
		$this->_header[$key] = $value;
		return $this;
	}
}

public protocol( [ string $protocol = NULL ] ) (defined in Kohana_Response)

Parameters

• string $protocol = NULL - Protocol to set to the request/response

Return Values

• mixed

public function protocol($protocol = NULL)
{
	if ($protocol)
	{
		$this->_protocol = strtoupper($protocol);
		return $this;
	}

	if ($this->_protocol === NULL)
	{
		$this->_protocol = HTTP::$protocol;
	}

	return $this->_protocol;
}

public render( ) (defined in Kohana_Response)

Return Values

• string

public function render()
{
	if ( ! $this->_header->offsetExists('content-type'))
	{
		// Add the default Content-Type header if required
		$this->_header['content-type'] = Kohana::$content_type.'; charset='.Kohana::$charset;
	}

	// Set the content length
	$this->headers('content-length', (string) $this->content_length());

	// If Kohana expose, set the user-agent
	if (Kohana::$expose)
	{
		$this->headers('user-agent', Kohana::version());
	}

	// Prepare cookies
	if ($this->_cookies)
	{
		if (extension_loaded('http'))
		{
			$cookies = version_compare(phpversion('http'), '2.0.0', '>=') ?
				(string) new \http\Cookie($this->_cookies) :
				http_build_cookie($this->_cookies);
			$this->_header['set-cookie'] = $cookies;
		}
		else
		{
			$cookies = array();

			// Parse each
			foreach ($this->_cookies as $key => $value)
			{
				$string = $key.'='.$value['value'].'; expires='.date('l, d M Y H:i:s T', $value['expiration']);
				$cookies[] = $string;
			}

			// Create the cookie string
			$this->_header['set-cookie'] = $cookies;
		}
	}

	$output = $this->_protocol.' '.$this->_status.' '.Response::$messages[$this->_status]."\r\n";
	$output .= (string) $this->_header;
	$output .= $this->_body;

	return $output;
}

public send_file( string $filename [, string $download = NULL , array $options = NULL ] ) (defined in Kohana_Response)

$request->send_file('media/packages/kohana.zip');

$request->response($content);
$request->send_file(TRUE, $filename);

Parameters

• string $filename required - Filename with path, or TRUE for the current response
• string $download = NULL - Downloaded file name
• array $options = NULL - Additional options

Tags

• Throws - Kohana_Exception
• Uses - File::mime_by_ext, File::mime, Request::send_headers

Return Values

• void

public function send_file($filename, $download = NULL, array $options = NULL)
{
	if ( ! empty($options['mime_type']))
	{
		// The mime-type has been manually set
		$mime = $options['mime_type'];
	}

	if ($filename === TRUE)
	{
		if (empty($download))
		{
			throw new Kohana_Exception('Download name must be provided for streaming files');
		}

		// Temporary files will automatically be deleted
		$options['delete'] = FALSE;

		if ( ! isset($mime))
		{
			// Guess the mime using the file extension
			$mime = File::mime_by_ext(strtolower(pathinfo($download, PATHINFO_EXTENSION)));
		}

		// Force the data to be rendered if
		$file_data = (string) $this->_body;

		// Get the content size
		$size = strlen($file_data);

		// Create a temporary file to hold the current response
		$file = tmpfile();

		// Write the current response into the file
		fwrite($file, $file_data);

		// File data is no longer needed
		unset($file_data);
	}
	else
	{
		// Get the complete file path
		$filename = realpath($filename);

		if (empty($download))
		{
			// Use the file name as the download file name
			$download = pathinfo($filename, PATHINFO_BASENAME);
		}

		// Get the file size
		$size = filesize($filename);

		if ( ! isset($mime))
		{
			// Get the mime type from the extension of the download file
			$mime = File::mime_by_ext(pathinfo($download, PATHINFO_EXTENSION));
		}

		// Open the file for reading
		$file = fopen($filename, 'rb');
	}

	if ( ! is_resource($file))
	{
		throw new Kohana_Exception('Could not read file to send: :file', array(
			':file' => $download,
		));
	}

	// Inline or download?
	$disposition = empty($options['inline']) ? 'attachment' : 'inline';

	// Calculate byte range to download.
	list($start, $end) = $this->_calculate_byte_range($size);

	if ( ! empty($options['resumable']))
	{
		if ($start > 0 OR $end < ($size - 1))
		{
			// Partial Content
			$this->_status = 206;
		}

		// Range of bytes being sent
		$this->_header['content-range'] = 'bytes '.$start.'-'.$end.'/'.$size;
		$this->_header['accept-ranges'] = 'bytes';
	}

	// Set the headers for a download
	$this->_header['content-disposition'] = $disposition.'; filename="'.$download.'"';
	$this->_header['content-type']        = $mime;
	$this->_header['content-length']      = (string) (($end - $start) + 1);

	if (Request::user_agent('browser') === 'Internet Explorer')
	{
		// Naturally, IE does not act like a real browser...
		if (Request::$initial->secure())
		{
			// http://support.microsoft.com/kb/316431
			$this->_header['pragma'] = $this->_header['cache-control'] = 'public';
		}

		if (version_compare(Request::user_agent('version'), '8.0', '>='))
		{
			// http://ajaxian.com/archives/ie-8-security
			$this->_header['x-content-type-options'] = 'nosniff';
		}
	}

	// Send all headers now
	$this->send_headers();

	while (ob_get_level())
	{
		// Flush all output buffers
		ob_end_flush();
	}

	// Manually stop execution
	ignore_user_abort(TRUE);

	if ( ! Kohana::$safe_mode)
	{
		// Keep the script running forever
		set_time_limit(0);
	}

	// Send data in 16kb blocks
	$block = 1024 * 16;

	fseek($file, $start);

	while ( ! feof($file) AND ($pos = ftell($file)) <= $end)
	{
		if (connection_aborted())
			break;

		if ($pos + $block > $end)
		{
			// Don't read past the buffer.
			$block = $end - $pos + 1;
		}

		// Output a block of the file
		echo fread($file, $block);

		// Send the data now
		flush();
	}

	// Close the file
	fclose($file);

	if ( ! empty($options['delete']))
	{
		try
		{
			// Attempt to remove the file
			unlink($filename);
		}
		catch (Exception $e)
		{
			// Create a text version of the exception
			$error = Kohana_Exception::text($e);

			if (is_object(Kohana::$log))
			{
				// Add this exception to the log
				Kohana::$log->add(Log::ERROR, $error);

				// Make sure the logs are written
				Kohana::$log->write();
			}

			// Do NOT display the exception, it will corrupt the output!
		}
	}

	// Stop execution
	exit;
}

public send_headers( [ boolean $replace = bool FALSE , callback $callback = NULL ] ) (defined in Kohana_Response)

Parameters

• boolean $replace = bool FALSE - Replace existing headers
• callback $callback = NULL - Function to handle header output

Return Values

• mixed

public function send_headers($replace = FALSE, $callback = NULL)
{
	return $this->_header->send_headers($this, $replace, $callback);
}

public status( [ integer $status = NULL ] ) (defined in Kohana_Response)

 // Set the HTTP status to 404 Not Found
 $response = Response::factory()
         ->status(404);

 // Get the current status
 $status = $response->status();

Parameters

• integer $status = NULL - Status to set to this response

Return Values

• mixed

public function status($status = NULL)
{
	if ($status === NULL)
	{
		return $this->_status;
	}
	elseif (array_key_exists($status, Response::$messages))
	{
		$this->_status = (int) $status;
		return $this;
	}
	else
	{
		throw new Kohana_Exception(__METHOD__.' unknown status value : :value', array(':value' => $status));
	}
}

protected _calculate_byte_range( integer $size ) (defined in Kohana_Response)

Parameters

• integer $size required - $size

Return Values

• array

protected function _calculate_byte_range($size)
{
	// Defaults to start with when the HTTP_RANGE header doesn't exist.
	$start = 0;
	$end = $size - 1;

	if ($range = $this->_parse_byte_range())
	{
		// We have a byte range from HTTP_RANGE
		$start = $range[1];

		if ($start[0] === '-')
		{
			// A negative value means we start from the end, so -500 would be the
			// last 500 bytes.
			$start = $size - abs($start);
		}

		if (isset($range[2]))
		{
			// Set the end range
			$end = $range[2];
		}
	}

	// Normalize values.
	$start = abs(intval($start));

	// Keep the the end value in bounds and normalize it.
	$end = min(abs(intval($end)), $size - 1);

	// Keep the start in bounds.
	$start = ($end < $start) ? 0 : max($start, 0);

	return array($start, $end);
}

protected _parse_byte_range( ) (defined in Kohana_Response)

Tags

• Link - http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35

Return Values

• array|FALSE

protected function _parse_byte_range()
{
	if ( ! isset($_SERVER['HTTP_RANGE']))
	{
		return FALSE;
	}

	// TODO, speed this up with the use of string functions.
	preg_match_all('/(-?[0-9]++(?:-(?![0-9]++))?)(?:-?([0-9]++))?/', $_SERVER['HTTP_RANGE'], $matches, PREG_SET_ORDER);

	return $matches[0];
}