No OneTemporary
Actions

Size

70 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/autopatches/20150312.filechunk.2.sql b/resources/sql/autopatches/20150312.filechunk.2.sql
	new file mode 100644
	index 0000000000..a6bb5bf8ad
	--- /dev/null
	+++ b/resources/sql/autopatches/20150312.filechunk.2.sql
	@@ -0,0 +1,2 @@
	+ALTER TABLE {$NAMESPACE}_file.file
	+ ADD isPartial BOOL NOT NULL DEFAULT 0;
	diff --git a/resources/sql/autopatches/20150312.filechunk.3.sql b/resources/sql/autopatches/20150312.filechunk.3.sql
	new file mode 100644
	index 0000000000..82032692f8
	--- /dev/null
	+++ b/resources/sql/autopatches/20150312.filechunk.3.sql
	@@ -0,0 +1,2 @@
	+ALTER TABLE {$NAMESPACE}_file.file
	+ ADD KEY `key_partial` (authorPHID, isPartial);
	diff --git a/src/applications/files/conduit/FileAllocateConduitAPIMethod.php b/src/applications/files/conduit/FileAllocateConduitAPIMethod.php
	index 65d2602287..00e31b5ed1 100644
	--- a/src/applications/files/conduit/FileAllocateConduitAPIMethod.php
	+++ b/src/applications/files/conduit/FileAllocateConduitAPIMethod.php
	@@ -1,131 +1,131 @@
	<?php

	final class FileAllocateConduitAPIMethod
	extends FileConduitAPIMethod {

	public function getAPIMethodName() {
	return 'file.allocate';
	}

	public function getMethodDescription() {
	return pht('Prepare to upload a file.');
	}

	public function defineParamTypes() {
	return array(
	'name' => 'string',
	'contentLength' => 'int',
	'contentHash' => 'optional string',
	'viewPolicy' => 'optional string',

	// TODO: Remove this, it's just here to make testing easier.
	'forceChunking' => 'optional bool',
	);
	}

	public function defineReturnType() {
	return 'map<string, wild>';
	}

	public function defineErrorTypes() {
	return array();
	}

	protected function execute(ConduitAPIRequest $request) {
	$viewer = $request->getUser();

	$hash = $request->getValue('contentHash');
	$name = $request->getValue('name');
	$view_policy = $request->getValue('viewPolicy');
	$content_length = $request->getValue('contentLength');

	$force_chunking = $request->getValue('forceChunking');

	$properties = array(
	'name' => $name,
	'authorPHID' => $viewer->getPHID(),
	'viewPolicy' => $view_policy,
	'isExplicitUpload' => true,
	);

	if ($hash) {
	$file = PhabricatorFile::newFileFromContentHash(
	$hash,
	$properties);

	- if ($file && !$force_chunking) {
	+ if ($file) {
	return array(
	'upload' => false,
	'filePHID' => $file->getPHID(),
	);
	}

	$chunked_hash = PhabricatorChunkedFileStorageEngine::getChunkedHash(
	$viewer,
	$hash);
	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withContentHashes(array($chunked_hash))
	->executeOne();

	if ($file) {
	return array(
	- 'upload' => $file->isPartial(),
	+ 'upload' => (bool)$file->getIsPartial(),
	'filePHID' => $file->getPHID(),
	);
	}
	}

	$engines = PhabricatorFileStorageEngine::loadStorageEngines(
	$content_length);
	if ($engines) {

	if ($force_chunking) {
	foreach ($engines as $key => $engine) {
	if (!$engine->isChunkEngine()) {
	unset($engines[$key]);
	}
	}
	}

	// Pick the first engine. If the file is small enough to fit into a
	// single engine without chunking, this will be a non-chunk engine and
	// we'll just tell the client to upload the file.
	$engine = head($engines);
	if ($engine) {
	if (!$engine->isChunkEngine()) {
	return array(
	'upload' => true,
	'filePHID' => null,
	);
	}

	// Otherwise, this is a large file and we need to perform a chunked
	// upload.

	- $chunk_properties = array();
	+ $chunk_properties = $properties;

	if ($hash) {
	$chunk_properties += array(
	'chunkedHash' => $chunked_hash,
	);
	}

	$file = $engine->allocateChunks($content_length, $chunk_properties);

	return array(
	'upload' => true,
	'filePHID' => $file->getPHID(),
	);
	}
	}

	// None of the storage engines can accept this file.

	return array(
	'upload' => false,
	'filePHID' => null,
	);
	}

	}
	diff --git a/src/applications/files/conduit/FileConduitAPIMethod.php b/src/applications/files/conduit/FileConduitAPIMethod.php
	index bdcae6de91..2419303218 100644
	--- a/src/applications/files/conduit/FileConduitAPIMethod.php
	+++ b/src/applications/files/conduit/FileConduitAPIMethod.php
	@@ -1,109 +1,120 @@
	<?php

	abstract class FileConduitAPIMethod extends ConduitAPIMethod {

	final public function getApplication() {
	return PhabricatorApplication::getByClass('PhabricatorFilesApplication');
	}

	protected function loadFileByPHID(PhabricatorUser $viewer, $file_phid) {
	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($file_phid))
	->executeOne();
	if (!$file) {
	throw new Exception(pht('No such file "%s"!', $file_phid));
	}

	return $file;
	}

	protected function loadFileChunks(
	PhabricatorUser $viewer,
	PhabricatorFile $file) {
	return $this->newChunkQuery($viewer, $file)
	->execute();
	}

	protected function loadFileChunkForUpload(
	PhabricatorUser $viewer,
	PhabricatorFile $file,
	$start,
	$end) {

	$start = (int)$start;
	$end = (int)$end;

	$chunks = $this->newChunkQuery($viewer, $file)
	->withByteRange($start, $end)
	->execute();

	if (!$chunks) {
	throw new Exception(
	pht(
	'There are no file data chunks in byte range %d - %d.',
	$start,
	$end));
	}

	if (count($chunks) !== 1) {
	phlog($chunks);
	throw new Exception(
	pht(
	'There are multiple chunks in byte range %d - %d.',
	$start,
	$end));
	}

	$chunk = head($chunks);
	if ($chunk->getByteStart() != $start) {
	throw new Exception(
	pht(
	'Chunk start byte is %d, not %d.',
	$chunk->getByteStart(),
	$start));
	}

	if ($chunk->getByteEnd() != $end) {
	throw new Exception(
	pht(
	'Chunk end byte is %d, not %d.',
	$chunk->getByteEnd(),
	$end));
	}

	if ($chunk->getDataFilePHID()) {
	throw new Exception(
	pht(
	'Chunk has already been uploaded.'));
	}

	return $chunk;
	}

	protected function decodeBase64($data) {
	$data = base64_decode($data, $strict = true);
	if ($data === false) {
	throw new Exception(pht('Unable to decode base64 data!'));
	}
	return $data;
	}

	+ protected function loadAnyMissingChunk(
	+ PhabricatorUser $viewer,
	+ PhabricatorFile $file) {
	+
	+ return $this->newChunkQuery($viewer, $file)
	+ ->withIsComplete(false)
	+ ->setLimit(1)
	+ ->execute();
	+ }
	+
	private function newChunkQuery(
	PhabricatorUser $viewer,
	PhabricatorFile $file) {

	$engine = $file->instantiateStorageEngine();
	if (!$engine->isChunkEngine()) {
	throw new Exception(
	pht(
	'File "%s" does not have chunks!',
	$file->getPHID()));
	}

	return id(new PhabricatorFileChunkQuery())
	->setViewer($viewer)
	->withChunkHandles(array($file->getStorageHandle()));
	}

	+
	}
	diff --git a/src/applications/files/conduit/FileUploadChunkConduitAPIMethod.php b/src/applications/files/conduit/FileUploadChunkConduitAPIMethod.php
	index 25dc115698..c26ab42124 100644
	--- a/src/applications/files/conduit/FileUploadChunkConduitAPIMethod.php
	+++ b/src/applications/files/conduit/FileUploadChunkConduitAPIMethod.php
	@@ -1,74 +1,77 @@
	<?php

	final class FileUploadChunkConduitAPIMethod
	extends FileConduitAPIMethod {

	public function getAPIMethodName() {
	return 'file.uploadchunk';
	}

	public function getMethodDescription() {
	return pht('Upload a chunk of file data to the server.');
	}

	public function defineParamTypes() {
	return array(
	'filePHID' => 'phid',
	'byteStart' => 'int',
	'data' => 'string',
	'dataEncoding' => 'string',
	);
	}

	public function defineReturnType() {
	return 'void';
	}

	public function defineErrorTypes() {
	return array();
	}

	protected function execute(ConduitAPIRequest $request) {
	$viewer = $request->getUser();

	$file_phid = $request->getValue('filePHID');
	$file = $this->loadFileByPHID($viewer, $file_phid);

	$start = $request->getValue('byteStart');

	$data = $request->getValue('data');
	$encoding = $request->getValue('dataEncoding');
	switch ($encoding) {
	case 'base64':
	$data = $this->decodeBase64($data);
	break;
	case null:
	break;
	default:
	throw new Exception(pht('Unsupported data encoding.'));
	}
	$length = strlen($data);

	$chunk = $this->loadFileChunkForUpload(
	$viewer,
	$file,
	$start,
	$start + $length);

	// NOTE: These files have a view policy which prevents normal access. They
	// are only accessed through the storage engine.
	- $file = PhabricatorFile::newFromFileData(
	+ $chunk_data = PhabricatorFile::newFromFileData(
	$data,
	array(
	'name' => $file->getMonogram().'.chunk-'.$chunk->getID(),
	'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
	));

	- $chunk->setDataFilePHID($file->getPHID())->save();
	+ $chunk->setDataFilePHID($chunk_data->getPHID())->save();

	- // TODO: If all chunks are up, mark the file as complete.
	+ $missing = $this->loadAnyMissingChunk($viewer, $file);
	+ if (!$missing) {
	+ $file->setIsPartial(0)->save();
	+ }

	return null;
	}

	}
	diff --git a/src/applications/files/controller/PhabricatorFileDataController.php b/src/applications/files/controller/PhabricatorFileDataController.php
	index 9049a45c4c..6d793fa7b3 100644
	--- a/src/applications/files/controller/PhabricatorFileDataController.php
	+++ b/src/applications/files/controller/PhabricatorFileDataController.php
	@@ -1,208 +1,225 @@
	<?php

	final class PhabricatorFileDataController extends PhabricatorFileController {

	private $phid;
	private $key;
	private $token;
	+ private $file;

	public function willProcessRequest(array $data) {
	$this->phid = $data['phid'];
	$this->key = $data['key'];
	$this->token = idx($data, 'token');
	}

	public function shouldRequireLogin() {
	return false;
	}

	- protected function checkFileAndToken($file) {
	- if (!$file) {
	- return new Aphront404Response();
	- }
	-
	- if (!$file->validateSecretKey($this->key)) {
	- return new Aphront403Response();
	- }
	-
	- return null;
	- }
	-
	public function processRequest() {
	$request = $this->getRequest();
	+ $viewer = $this->getViewer();

	$alt = PhabricatorEnv::getEnvConfig('security.alternate-file-domain');
	$base_uri = PhabricatorEnv::getEnvConfig('phabricator.base-uri');
	$alt_uri = new PhutilURI($alt);
	$alt_domain = $alt_uri->getDomain();
	$req_domain = $request->getHost();
	$main_domain = id(new PhutilURI($base_uri))->getDomain();

	$cache_response = true;

	if (empty($alt) \|\| $main_domain == $alt_domain) {
	// Alternate files domain isn't configured or it's set
	// to the same as the default domain

	- // load the file with permissions checks;
	- $file = id(new PhabricatorFileQuery())
	- ->setViewer($request->getUser())
	- ->withPHIDs(array($this->phid))
	- ->executeOne();
	-
	- $error_response = $this->checkFileAndToken($file);
	- if ($error_response) {
	- return $error_response;
	+ $response = $this->loadFile($viewer);
	+ if ($response) {
	+ return $response;
	}
	+ $file = $this->getFile();

	// when the file is not CDNable, don't allow cache
	$cache_response = $file->getCanCDN();
	} else if ($req_domain != $alt_domain) {
	// Alternate domain is configured but this request isn't using it

	- // load the file with permissions checks;
	- $file = id(new PhabricatorFileQuery())
	- ->setViewer($request->getUser())
	- ->withPHIDs(array($this->phid))
	- ->executeOne();
	-
	- $error_response = $this->checkFileAndToken($file);
	- if ($error_response) {
	- return $error_response;
	+ $response = $this->loadFile($viewer);
	+ if ($response) {
	+ return $response;
	}
	+ $file = $this->getFile();

	// if the user can see the file, generate a token;
	// redirect to the alt domain with the token;
	$token_uri = $file->getCDNURIWithToken();
	$token_uri = new PhutilURI($token_uri);
	$token_uri = $this->addURIParameters($token_uri);

	return id(new AphrontRedirectResponse())
	->setIsExternal(true)
	->setURI($token_uri);

	} else {
	- // We are using the alternate domain
	-
	- // load the file, bypassing permission checks;
	- $file = id(new PhabricatorFileQuery())
	- ->setViewer(PhabricatorUser::getOmnipotentUser())
	- ->withPHIDs(array($this->phid))
	- ->executeOne();
	+ // We are using the alternate domain. We don't have authentication
	+ // on this domain, so we bypass policy checks when loading the file.

	- $error_response = $this->checkFileAndToken($file);
	- if ($error_response) {
	- return $error_response;
	+ $bypass_policies = PhabricatorUser::getOmnipotentUser();
	+ $response = $this->loadFile($bypass_policies);
	+ if ($response) {
	+ return $response;
	}
	+ $file = $this->getFile();

	$acquire_token_uri = id(new PhutilURI($file->getViewURI()))
	->setDomain($main_domain);
	$acquire_token_uri = $this->addURIParameters($acquire_token_uri);

	if ($this->token) {
	// validate the token, if it is valid, continue
	$validated_token = $file->validateOneTimeToken($this->token);

	if (!$validated_token) {
	$dialog = $this->newDialog()
	->setShortTitle(pht('Expired File'))
	->setTitle(pht('File Link Has Expired'))
	->appendParagraph(
	pht(
	'The link you followed to view this file is invalid or '.
	'expired.'))
	->appendParagraph(
	pht(
	'Continue to generate a new link to the file. You may be '.
	'required to log in.'))
	->addCancelButton(
	$acquire_token_uri,
	pht('Continue'));

	// Build an explicit response so we can respond with HTTP/403 instead
	// of HTTP/200.
	$response = id(new AphrontDialogResponse())
	->setDialog($dialog)
	->setHTTPResponseCode(403);

	return $response;
	}
	// return the file data without cache headers
	$cache_response = false;
	} else if (!$file->getCanCDN()) {
	// file cannot be served via cdn, and no token given
	// redirect to the main domain to aquire a token

	// This is marked as an "external" URI because it is fully qualified.
	return id(new AphrontRedirectResponse())
	->setIsExternal(true)
	->setURI($acquire_token_uri);
	}
	}

	$data = $file->loadFileData();
	$response = new AphrontFileResponse();
	$response->setContent($data);
	if ($cache_response) {
	$response->setCacheDurationInSeconds(60 * 60 * 24 * 30);
	}

	// NOTE: It's important to accept "Range" requests when playing audio.
	// If we don't, Safari has difficulty figuring out how long sounds are
	// and glitches when trying to loop them. In particular, Safari sends
	// an initial request for bytes 0-1 of the audio file, and things go south
	// if we can't respond with a 206 Partial Content.
	$range = $request->getHTTPHeader('range');
	if ($range) {
	$matches = null;
	if (preg_match('/^bytes=(\d+)-(\d+)$/', $range, $matches)) {
	$response->setHTTPResponseCode(206);
	$response->setRange((int)$matches[1], (int)$matches[2]);
	}
	} else if (isset($validated_token)) {
	// consume the one-time token if we have one.
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$validated_token->delete();
	unset($unguarded);
	}

	$is_viewable = $file->isViewableInBrowser();
	$force_download = $request->getExists('download');

	if ($is_viewable && !$force_download) {
	$response->setMimeType($file->getViewableMimeType());
	} else {
	if (!$request->isHTTPPost() && !$alt_domain) {
	// NOTE: Require POST to download files from the primary domain. We'd
	// rather go full-bore and do a real CSRF check, but can't currently
	// authenticate users on the file domain. This should blunt any
	// attacks based on iframes, script tags, applet tags, etc., at least.
	// Send the user to the "info" page if they're using some other method.

	// This is marked as "external" because it is fully qualified.
	return id(new AphrontRedirectResponse())
	->setIsExternal(true)
	->setURI(PhabricatorEnv::getProductionURI($file->getBestURI()));
	}
	$response->setMimeType($file->getMimeType());
	$response->setDownload($file->getName());
	}

	return $response;
	}

	/**
	* Add passthrough parameters to the URI so they aren't lost when we
	* redirect to acquire tokens.
	*/
	private function addURIParameters(PhutilURI $uri) {
	$request = $this->getRequest();

	if ($request->getBool('download')) {
	$uri->setQueryParam('download', 1);
	}

	return $uri;
	}

	+ private function loadFile(PhabricatorUser $viewer) {
	+ $file = id(new PhabricatorFileQuery())
	+ ->setViewer($viewer)
	+ ->withPHIDs(array($this->phid))
	+ ->executeOne();
	+
	+ if (!$file) {
	+ return new Aphront404Response();
	+ }
	+
	+ if (!$file->validateSecretKey($this->key)) {
	+ return new Aphront403Response();
	+ }
	+
	+ if ($file->getIsPartial()) {
	+ // We may be on the CDN domain, so we need to use a fully-qualified URI
	+ // here to make sure we end up back on the main domain.
	+ $info_uri = PhabricatorEnv::getURI($file->getInfoURI());
	+
	+ return $this->newDialog()
	+ ->setTitle(pht('Partial Upload'))
	+ ->appendParagraph(
	+ pht(
	+ 'This file has only been partially uploaded. It must be '.
	+ 'uploaded completely before you can download it.'))
	+ ->addCancelButton($info_uri);
	+ }
	+
	+ $this->file = $file;
	+
	+ return null;
	+ }
	+
	+ private function getFile() {
	+ if (!$this->file) {
	+ throw new Exception(pht('Call loadFile() before getFile()!'));
	+ }
	+ return $this->file;
	+ }
	+
	}
	diff --git a/src/applications/files/controller/PhabricatorFileInfoController.php b/src/applications/files/controller/PhabricatorFileInfoController.php
	index 58f315f067..27a67005d9 100644
	--- a/src/applications/files/controller/PhabricatorFileInfoController.php
	+++ b/src/applications/files/controller/PhabricatorFileInfoController.php
	@@ -1,361 +1,377 @@
	<?php

	final class PhabricatorFileInfoController extends PhabricatorFileController {

	private $phid;
	private $id;

	public function shouldAllowPublic() {
	return true;
	}

	public function willProcessRequest(array $data) {
	$this->phid = idx($data, 'phid');
	$this->id = idx($data, 'id');
	}

	public function processRequest() {
	$request = $this->getRequest();
	$user = $request->getUser();

	if ($this->phid) {
	$file = id(new PhabricatorFileQuery())
	->setViewer($user)
	->withPHIDs(array($this->phid))
	->executeOne();

	if (!$file) {
	return new Aphront404Response();
	}
	return id(new AphrontRedirectResponse())->setURI($file->getInfoURI());
	}
	$file = id(new PhabricatorFileQuery())
	->setViewer($user)
	->withIDs(array($this->id))
	->executeOne();
	if (!$file) {
	return new Aphront404Response();
	}

	$phid = $file->getPHID();

	$handle_phids = array_merge(
	array($file->getAuthorPHID()),
	$file->getObjectPHIDs());

	$this->loadHandles($handle_phids);
	$header = id(new PHUIHeaderView())
	->setUser($user)
	->setPolicyObject($file)
	->setHeader($file->getName());

	$ttl = $file->getTTL();
	if ($ttl !== null) {
	$ttl_tag = id(new PHUITagView())
	- ->setType(PHUITagView::TYPE_OBJECT)
	+ ->setType(PHUITagView::TYPE_STATE)
	+ ->setBackgroundColor(PHUITagView::COLOR_YELLOW)
	->setName(pht('Temporary'));
	$header->addTag($ttl_tag);
	}

	+ $partial = $file->getIsPartial();
	+ if ($partial) {
	+ $partial_tag = id(new PHUITagView())
	+ ->setType(PHUITagView::TYPE_STATE)
	+ ->setBackgroundColor(PHUITagView::COLOR_ORANGE)
	+ ->setName(pht('Partial Upload'));
	+ $header->addTag($partial_tag);
	+ }
	+
	$actions = $this->buildActionView($file);
	$timeline = $this->buildTransactionView($file);
	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(
	'F'.$file->getID(),
	$this->getApplicationURI("/info/{$phid}/"));

	$object_box = id(new PHUIObjectBoxView())
	->setHeader($header);

	$this->buildPropertyViews($object_box, $file, $actions);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$object_box,
	$timeline,
	),
	array(
	'title' => $file->getName(),
	'pageObjects' => array($file->getPHID()),
	));
	}

	private function buildTransactionView(PhabricatorFile $file) {
	$user = $this->getRequest()->getUser();

	$timeline = $this->buildTransactionTimeline(
	$file,
	new PhabricatorFileTransactionQuery());

	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$add_comment_header = $is_serious
	? pht('Add Comment')
	: pht('Question File Integrity');

	$draft = PhabricatorDraft::newFromUserAndKey($user, $file->getPHID());

	$add_comment_form = id(new PhabricatorApplicationTransactionCommentView())
	->setUser($user)
	->setObjectPHID($file->getPHID())
	->setDraft($draft)
	->setHeaderText($add_comment_header)
	->setAction($this->getApplicationURI('/comment/'.$file->getID().'/'))
	->setSubmitButtonName(pht('Add Comment'));

	return array(
	$timeline,
	$add_comment_form,
	);
	}

	private function buildActionView(PhabricatorFile $file) {
	$request = $this->getRequest();
	$viewer = $request->getUser();

	$id = $file->getID();

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$file,
	PhabricatorPolicyCapability::CAN_EDIT);

	$view = id(new PhabricatorActionListView())
	->setUser($viewer)
	->setObjectURI($this->getRequest()->getRequestURI())
	->setObject($file);

	+ $can_download = !$file->getIsPartial();
	+
	if ($file->isViewableInBrowser()) {
	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('View File'))
	->setIcon('fa-file-o')
	- ->setHref($file->getViewURI()));
	+ ->setHref($file->getViewURI())
	+ ->setDisabled(!$can_download)
	+ ->setWorkflow(!$can_download));
	} else {
	$view->addAction(
	id(new PhabricatorActionView())
	->setUser($viewer)
	- ->setRenderAsForm(true)
	- ->setDownload(true)
	+ ->setRenderAsForm($can_download)
	+ ->setDownload($can_download)
	->setName(pht('Download File'))
	->setIcon('fa-download')
	- ->setHref($file->getViewURI()));
	+ ->setHref($file->getViewURI())
	+ ->setDisabled(!$can_download)
	+ ->setWorkflow(!$can_download));
	}

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit File'))
	->setIcon('fa-pencil')
	->setHref($this->getApplicationURI("/edit/{$id}/"))
	->setWorkflow(!$can_edit)
	->setDisabled(!$can_edit));

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Delete File'))
	->setIcon('fa-times')
	->setHref($this->getApplicationURI("/delete/{$id}/"))
	->setWorkflow(true)
	->setDisabled(!$can_edit));

	return $view;
	}

	private function buildPropertyViews(
	PHUIObjectBoxView $box,
	PhabricatorFile $file,
	PhabricatorActionListView $actions) {
	$request = $this->getRequest();
	$user = $request->getUser();


	$properties = id(new PHUIPropertyListView());
	$properties->setActionList($actions);
	$box->addPropertyList($properties, pht('Details'));

	if ($file->getAuthorPHID()) {
	$properties->addProperty(
	pht('Author'),
	$this->getHandle($file->getAuthorPHID())->renderLink());
	}

	$properties->addProperty(
	pht('Created'),
	phabricator_datetime($file->getDateCreated(), $user));


	$finfo = id(new PHUIPropertyListView());
	$box->addPropertyList($finfo, pht('File Info'));

	$finfo->addProperty(
	pht('Size'),
	phutil_format_bytes($file->getByteSize()));

	$finfo->addProperty(
	pht('Mime Type'),
	$file->getMimeType());

	$width = $file->getImageWidth();
	if ($width) {
	$finfo->addProperty(
	pht('Width'),
	pht('%s px', new PhutilNumber($width)));
	}

	$height = $file->getImageHeight();
	if ($height) {
	$finfo->addProperty(
	pht('Height'),
	pht('%s px', new PhutilNumber($height)));
	}

	$is_image = $file->isViewableImage();
	if ($is_image) {
	$image_string = pht('Yes');
	$cache_string = $file->getCanCDN() ? pht('Yes') : pht('No');
	} else {
	$image_string = pht('No');
	$cache_string = pht('Not Applicable');
	}

	$finfo->addProperty(pht('Viewable Image'), $image_string);
	$finfo->addProperty(pht('Cacheable'), $cache_string);

	$builtin = $file->getBuiltinName();
	if ($builtin === null) {
	$builtin_string = pht('No');
	} else {
	$builtin_string = $builtin;
	}

	$finfo->addProperty(pht('Builtin'), $builtin_string);

	$storage_properties = new PHUIPropertyListView();
	$box->addPropertyList($storage_properties, pht('Storage'));

	$storage_properties->addProperty(
	pht('Engine'),
	$file->getStorageEngine());

	$storage_properties->addProperty(
	pht('Format'),
	$file->getStorageFormat());

	$storage_properties->addProperty(
	pht('Handle'),
	$file->getStorageHandle());


	$phids = $file->getObjectPHIDs();
	if ($phids) {
	$attached = new PHUIPropertyListView();
	$box->addPropertyList($attached, pht('Attached'));

	$attached->addProperty(
	pht('Attached To'),
	$this->renderHandlesForPHIDs($phids));
	}


	if ($file->isViewableImage()) {
	$image = phutil_tag(
	'img',
	array(
	'src' => $file->getViewURI(),
	'class' => 'phui-property-list-image',
	));

	$linked_image = phutil_tag(
	'a',
	array(
	'href' => $file->getViewURI(),
	),
	$image);

	$media = id(new PHUIPropertyListView())
	->addImageContent($linked_image);

	$box->addPropertyList($media);
	} else if ($file->isAudio()) {
	$audio = phutil_tag(
	'audio',
	array(
	'controls' => 'controls',
	'class' => 'phui-property-list-audio',
	),
	phutil_tag(
	'source',
	array(
	'src' => $file->getViewURI(),
	'type' => $file->getMimeType(),
	)));
	$media = id(new PHUIPropertyListView())
	->addImageContent($audio);

	$box->addPropertyList($media);
	}

	$engine = null;
	try {
	$engine = $file->instantiateStorageEngine();
	} catch (Exception $ex) {
	// Don't bother raising this anywhere for now.
	}

	if ($engine) {
	if ($engine->isChunkEngine()) {
	$chunkinfo = new PHUIPropertyListView();
	$box->addPropertyList($chunkinfo, pht('Chunks'));

	$chunks = id(new PhabricatorFileChunkQuery())
	->setViewer($user)
	->withChunkHandles(array($file->getStorageHandle()))
	->execute();
	$chunks = msort($chunks, 'getByteStart');

	$rows = array();
	$completed = array();
	foreach ($chunks as $chunk) {
	$is_complete = $chunk->getDataFilePHID();

	$rows[] = array(
	$chunk->getByteStart(),
	$chunk->getByteEnd(),
	($is_complete ? pht('Yes') : pht('No')),
	);

	if ($is_complete) {
	$completed[] = $chunk;
	}
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Offset'),
	pht('End'),
	pht('Complete'),
	))
	->setColumnClasses(
	array(
	'',
	'',
	'wide',
	));

	$chunkinfo->addProperty(
	pht('Total Chunks'),
	count($chunks));

	$chunkinfo->addProperty(
	pht('Completed Chunks'),
	count($completed));

	$chunkinfo->addRawContent($table);
	}
	}

	}

	}
	diff --git a/src/applications/files/query/PhabricatorFileChunkQuery.php b/src/applications/files/query/PhabricatorFileChunkQuery.php
	index e701c779ce..7c2a961fd0 100644
	--- a/src/applications/files/query/PhabricatorFileChunkQuery.php
	+++ b/src/applications/files/query/PhabricatorFileChunkQuery.php
	@@ -1,116 +1,134 @@
	<?php

	final class PhabricatorFileChunkQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $chunkHandles;
	private $rangeStart;
	private $rangeEnd;
	+ private $isComplete;
	private $needDataFiles;

	public function withChunkHandles(array $handles) {
	$this->chunkHandles = $handles;
	return $this;
	}

	public function withByteRange($start, $end) {
	$this->rangeStart = $start;
	$this->rangeEnd = $end;
	return $this;
	}

	+ public function withIsComplete($complete) {
	+ $this->isComplete = $complete;
	+ return $this;
	+ }
	+
	public function needDataFiles($need) {
	$this->needDataFiles = $need;
	return $this;
	}

	protected function loadPage() {
	$table = new PhabricatorFileChunk();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T %Q %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	return $table->loadAllFromArray($data);
	}

	protected function willFilterPage(array $chunks) {

	if ($this->needDataFiles) {
	$file_phids = mpull($chunks, 'getDataFilePHID');
	$file_phids = array_filter($file_phids);
	if ($file_phids) {
	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getViewer())
	->setParentQuery($this)
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');
	} else {
	$files = array();
	}

	foreach ($chunks as $key => $chunk) {
	$data_phid = $chunk->getDataFilePHID();
	if (!$data_phid) {
	$chunk->attachDataFile(null);
	continue;
	}

	$file = idx($files, $data_phid);
	if (!$file) {
	unset($chunks[$key]);
	$this->didRejectResult($chunk);
	continue;
	}

	$chunk->attachDataFile($file);
	}

	if (!$chunks) {
	return $chunks;
	}
	}

	return $chunks;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->chunkHandles !== null) {
	$where[] = qsprintf(
	$conn_r,
	'chunkHandle IN (%Ls)',
	$this->chunkHandles);
	}

	if ($this->rangeStart !== null) {
	$where[] = qsprintf(
	$conn_r,
	'byteEnd > %d',
	$this->rangeStart);
	}

	if ($this->rangeEnd !== null) {
	$where[] = qsprintf(
	$conn_r,
	'byteStart < %d',
	$this->rangeEnd);
	}

	+ if ($this->isComplete !== null) {
	+ if ($this->isComplete) {
	+ $where[] = qsprintf(
	+ $conn_r,
	+ 'dataFilePHID IS NOT NULL');
	+ } else {
	+ $where[] = qsprintf(
	+ $conn_r,
	+ 'dataFilePHID IS NULL');
	+ }
	+ }
	+
	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorFilesApplication';
	}

	}
	diff --git a/src/applications/files/storage/PhabricatorFile.php b/src/applications/files/storage/PhabricatorFile.php
	index 4b73934df5..b75df473a1 100644
	--- a/src/applications/files/storage/PhabricatorFile.php
	+++ b/src/applications/files/storage/PhabricatorFile.php
	@@ -1,1303 +1,1312 @@
	<?php

	/**
	* Parameters
	* ==========
	*
	* When creating a new file using a method like @{method:newFromFileData}, these
	* parameters are supported:
	*
	* \| name \| Human readable filename.
	* \| authorPHID \| User PHID of uploader.
	* \| ttl \| Temporary file lifetime, in seconds.
	* \| viewPolicy \| File visibility policy.
	* \| isExplicitUpload \| Used to show users files they explicitly uploaded.
	* \| canCDN \| Allows the file to be cached and delivered over a CDN.
	* \| mime-type \| Optional, explicit file MIME type.
	* \| builtin \| Optional filename, identifies this as a builtin.
	*
	*/
	final class PhabricatorFile extends PhabricatorFileDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorSubscribableInterface,
	PhabricatorFlaggableInterface,
	PhabricatorPolicyInterface,
	PhabricatorDestructibleInterface {

	const ONETIME_TEMPORARY_TOKEN_TYPE = 'file:onetime';
	const STORAGE_FORMAT_RAW = 'raw';

	const METADATA_IMAGE_WIDTH = 'width';
	const METADATA_IMAGE_HEIGHT = 'height';
	const METADATA_CAN_CDN = 'canCDN';
	const METADATA_BUILTIN = 'builtin';
	const METADATA_PARTIAL = 'partial';

	protected $name;
	protected $mimeType;
	protected $byteSize;
	protected $authorPHID;
	protected $secretKey;
	protected $contentHash;
	protected $metadata = array();
	protected $mailKey;

	protected $storageEngine;
	protected $storageFormat;
	protected $storageHandle;

	protected $ttl;
	protected $isExplicitUpload = 1;
	protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
	+ protected $isPartial = 0;

	private $objects = self::ATTACHABLE;
	private $objectPHIDs = self::ATTACHABLE;
	private $originalFile = self::ATTACHABLE;

	public static function initializeNewFile() {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withClasses(array('PhabricatorFilesApplication'))
	->executeOne();

	$view_policy = $app->getPolicy(
	FilesDefaultViewCapability::CAPABILITY);

	return id(new PhabricatorFile())
	->setViewPolicy($view_policy)
	+ ->setIsPartial(0)
	->attachOriginalFile(null)
	->attachObjects(array())
	->attachObjectPHIDs(array());
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'metadata' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text255?',
	'mimeType' => 'text255?',
	'byteSize' => 'uint64',
	'storageEngine' => 'text32',
	'storageFormat' => 'text32',
	'storageHandle' => 'text255',
	'authorPHID' => 'phid?',
	'secretKey' => 'bytes20?',
	'contentHash' => 'bytes40?',
	'ttl' => 'epoch?',
	'isExplicitUpload' => 'bool?',
	'mailKey' => 'bytes20',
	+ 'isPartial' => 'bool',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'authorPHID' => array(
	'columns' => array('authorPHID'),
	),
	'contentHash' => array(
	'columns' => array('contentHash'),
	),
	'key_ttl' => array(
	'columns' => array('ttl'),
	),
	'key_dateCreated' => array(
	'columns' => array('dateCreated'),
	),
	+ 'key_partial' => array(
	+ 'columns' => array('authorPHID', 'isPartial'),
	+ ),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorFileFilePHIDType::TYPECONST);
	}

	public function save() {
	if (!$this->getSecretKey()) {
	$this->setSecretKey($this->generateSecretKey());
	}
	if (!$this->getMailKey()) {
	$this->setMailKey(Filesystem::readRandomCharacters(20));
	}
	return parent::save();
	}

	public function getMonogram() {
	return 'F'.$this->getID();
	}

	public static function readUploadedFileData($spec) {
	if (!$spec) {
	throw new Exception('No file was uploaded!');
	}

	$err = idx($spec, 'error');
	if ($err) {
	throw new PhabricatorFileUploadException($err);
	}

	$tmp_name = idx($spec, 'tmp_name');
	$is_valid = @is_uploaded_file($tmp_name);
	if (!$is_valid) {
	throw new Exception('File is not an uploaded file.');
	}

	$file_data = Filesystem::readFile($tmp_name);
	$file_size = idx($spec, 'size');

	if (strlen($file_data) != $file_size) {
	throw new Exception('File size disagrees with uploaded size.');
	}

	self::validateFileSize(strlen($file_data));

	return $file_data;
	}

	public static function newFromPHPUpload($spec, array $params = array()) {
	$file_data = self::readUploadedFileData($spec);

	$file_name = nonempty(
	idx($params, 'name'),
	idx($spec, 'name'));
	$params = array(
	'name' => $file_name,
	) + $params;

	return self::newFromFileData($file_data, $params);
	}

	public static function newFromXHRUpload($data, array $params = array()) {
	self::validateFileSize(strlen($data));
	return self::newFromFileData($data, $params);
	}

	private static function validateFileSize($size) {
	$limit = PhabricatorEnv::getEnvConfig('storage.upload-size-limit');
	if (!$limit) {
	return;
	}

	$limit = phutil_parse_bytes($limit);
	if ($size > $limit) {
	throw new PhabricatorFileUploadException(-1000);
	}
	}


	/**
	* Given a block of data, try to load an existing file with the same content
	* if one exists. If it does not, build a new file.
	*
	* This method is generally used when we have some piece of semi-trusted data
	* like a diff or a file from a repository that we want to show to the user.
	* We can't just dump it out because it may be dangerous for any number of
	* reasons; instead, we need to serve it through the File abstraction so it
	* ends up on the CDN domain if one is configured and so on. However, if we
	* simply wrote a new file every time we'd potentially end up with a lot
	* of redundant data in file storage.
	*
	* To solve these problems, we use file storage as a cache and reuse the
	* same file again if we've previously written it.
	*
	* NOTE: This method unguards writes.
	*
	* @param string Raw file data.
	* @param dict Dictionary of file information.
	*/
	public static function buildFromFileDataOrHash(
	$data,
	array $params = array()) {

	$file = id(new PhabricatorFile())->loadOneWhere(
	'name = %s AND contentHash = %s LIMIT 1',
	self::normalizeFileName(idx($params, 'name')),
	self::hashFileContent($data));

	if (!$file) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file = PhabricatorFile::newFromFileData($data, $params);
	unset($unguarded);
	}

	return $file;
	}

	public static function newFileFromContentHash($hash, array $params) {
	// Check to see if a file with same contentHash exist
	$file = id(new PhabricatorFile())->loadOneWhere(
	'contentHash = %s LIMIT 1',
	$hash);

	if ($file) {
	// copy storageEngine, storageHandle, storageFormat
	$copy_of_storage_engine = $file->getStorageEngine();
	$copy_of_storage_handle = $file->getStorageHandle();
	$copy_of_storage_format = $file->getStorageFormat();
	$copy_of_byte_size = $file->getByteSize();
	$copy_of_mime_type = $file->getMimeType();

	$new_file = PhabricatorFile::initializeNewFile();

	$new_file->setByteSize($copy_of_byte_size);

	$new_file->setContentHash($hash);
	$new_file->setStorageEngine($copy_of_storage_engine);
	$new_file->setStorageHandle($copy_of_storage_handle);
	$new_file->setStorageFormat($copy_of_storage_format);
	$new_file->setMimeType($copy_of_mime_type);
	$new_file->copyDimensions($file);

	$new_file->readPropertiesFromParameters($params);

	$new_file->save();

	return $new_file;
	}

	return $file;
	}

	public static function newChunkedFile(
	PhabricatorFileStorageEngine $engine,
	$length,
	array $params) {

	$file = PhabricatorFile::initializeNewFile();

	$file->setByteSize($length);

	// TODO: We might be able to test the first chunk in order to figure
	// this out more reliably, since MIME detection usually examines headers.
	// However, enormous files are probably always either actually raw data
	// or reasonable to treat like raw data.
	$file->setMimeType('application/octet-stream');

	$chunked_hash = idx($params, 'chunkedHash');
	if ($chunked_hash) {
	$file->setContentHash($chunked_hash);
	} else {
	// See PhabricatorChunkedFileStorageEngine::getChunkedHash() for some
	// discussion of this.
	$file->setContentHash(
	PhabricatorHash::digest(
	Filesystem::readRandomBytes(64)));
	}

	$file->setStorageEngine($engine->getEngineIdentifier());
	$file->setStorageHandle(PhabricatorFileChunk::newChunkHandle());
	$file->setStorageFormat(self::STORAGE_FORMAT_RAW);
	+ $file->setIsPartial(1);

	$file->readPropertiesFromParameters($params);

	return $file;
	}

	private static function buildFromFileData($data, array $params = array()) {

	if (isset($params['storageEngines'])) {
	$engines = $params['storageEngines'];
	} else {
	$size = strlen($data);
	$engines = PhabricatorFileStorageEngine::loadStorageEngines($size);

	if (!$engines) {
	throw new Exception(
	pht(
	'No configured storage engine can store this file. See '.
	'"Configuring File Storage" in the documentation for '.
	'information on configuring storage engines.'));
	}
	}

	assert_instances_of($engines, 'PhabricatorFileStorageEngine');
	if (!$engines) {
	throw new Exception(pht('No valid storage engines are available!'));
	}

	$file = PhabricatorFile::initializeNewFile();

	$data_handle = null;
	$engine_identifier = null;
	$exceptions = array();
	foreach ($engines as $engine) {
	$engine_class = get_class($engine);
	try {
	list($engine_identifier, $data_handle) = $file->writeToEngine(
	$engine,
	$data,
	$params);

	// We stored the file somewhere so stop trying to write it to other
	// places.
	break;
	} catch (PhabricatorFileStorageConfigurationException $ex) {
	// If an engine is outright misconfigured (or misimplemented), raise
	// that immediately since it probably needs attention.
	throw $ex;
	} catch (Exception $ex) {
	phlog($ex);

	// If an engine doesn't work, keep trying all the other valid engines
	// in case something else works.
	$exceptions[$engine_class] = $ex;
	}
	}

	if (!$data_handle) {
	throw new PhutilAggregateException(
	'All storage engines failed to write file:',
	$exceptions);
	}

	$file->setByteSize(strlen($data));
	$file->setContentHash(self::hashFileContent($data));

	$file->setStorageEngine($engine_identifier);
	$file->setStorageHandle($data_handle);

	// TODO: This is probably YAGNI, but allows for us to do encryption or
	// compression later if we want.
	$file->setStorageFormat(self::STORAGE_FORMAT_RAW);

	$file->readPropertiesFromParameters($params);

	if (!$file->getMimeType()) {
	$tmp = new TempFile();
	Filesystem::writeFile($tmp, $data);
	$file->setMimeType(Filesystem::getMimeType($tmp));
	}

	try {
	$file->updateDimensions(false);
	} catch (Exception $ex) {
	// Do nothing
	}

	$file->save();

	return $file;
	}

	public static function newFromFileData($data, array $params = array()) {
	$hash = self::hashFileContent($data);
	$file = self::newFileFromContentHash($hash, $params);

	if ($file) {
	return $file;
	}

	return self::buildFromFileData($data, $params);
	}

	public function migrateToEngine(PhabricatorFileStorageEngine $engine) {
	if (!$this->getID() \|\| !$this->getStorageHandle()) {
	throw new Exception(
	"You can not migrate a file which hasn't yet been saved.");
	}

	$data = $this->loadFileData();
	$params = array(
	'name' => $this->getName(),
	);

	list($new_identifier, $new_handle) = $this->writeToEngine(
	$engine,
	$data,
	$params);

	$old_engine = $this->instantiateStorageEngine();
	$old_identifier = $this->getStorageEngine();
	$old_handle = $this->getStorageHandle();

	$this->setStorageEngine($new_identifier);
	$this->setStorageHandle($new_handle);
	$this->save();

	$this->deleteFileDataIfUnused(
	$old_engine,
	$old_identifier,
	$old_handle);

	return $this;
	}

	private function writeToEngine(
	PhabricatorFileStorageEngine $engine,
	$data,
	array $params) {

	$engine_class = get_class($engine);

	$data_handle = $engine->writeFile($data, $params);

	if (!$data_handle \|\| strlen($data_handle) > 255) {
	// This indicates an improperly implemented storage engine.
	throw new PhabricatorFileStorageConfigurationException(
	"Storage engine '{$engine_class}' executed writeFile() but did ".
	"not return a valid handle ('{$data_handle}') to the data: it ".
	"must be nonempty and no longer than 255 characters.");
	}

	$engine_identifier = $engine->getEngineIdentifier();
	if (!$engine_identifier \|\| strlen($engine_identifier) > 32) {
	throw new PhabricatorFileStorageConfigurationException(
	"Storage engine '{$engine_class}' returned an improper engine ".
	"identifier '{$engine_identifier}': it must be nonempty ".
	"and no longer than 32 characters.");
	}

	return array($engine_identifier, $data_handle);
	}


	public static function newFromFileDownload($uri, array $params = array()) {
	// Make sure we're allowed to make a request first
	if (!PhabricatorEnv::getEnvConfig('security.allow-outbound-http')) {
	throw new Exception('Outbound HTTP requests are disabled!');
	}

	$uri = new PhutilURI($uri);

	$protocol = $uri->getProtocol();
	switch ($protocol) {
	case 'http':
	case 'https':
	break;
	default:
	// Make sure we are not accessing any file:// URIs or similar.
	return null;
	}

	$timeout = 5;

	list($file_data) = id(new HTTPSFuture($uri))
	->setTimeout($timeout)
	->resolvex();

	$params = $params + array(
	'name' => basename($uri),
	);

	return self::newFromFileData($file_data, $params);
	}

	public static function normalizeFileName($file_name) {
	$pattern = "@[\\x00-\\x19#%&+!~'\$\"\/=\\\\?<> ]+@";
	$file_name = preg_replace($pattern, '_', $file_name);
	$file_name = preg_replace('@_+@', '_', $file_name);
	$file_name = trim($file_name, '_');

	$disallowed_filenames = array(
	'.' => 'dot',
	'..' => 'dotdot',
	'' => 'file',
	);
	$file_name = idx($disallowed_filenames, $file_name, $file_name);

	return $file_name;
	}

	public function delete() {
	// We want to delete all the rows which mark this file as the transformation
	// of some other file (since we're getting rid of it). We also delete all
	// the transformations of this file, so that a user who deletes an image
	// doesn't need to separately hunt down and delete a bunch of thumbnails and
	// resizes of it.

	$outbound_xforms = id(new PhabricatorFileQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withTransforms(
	array(
	array(
	'originalPHID' => $this->getPHID(),
	'transform' => true,
	),
	))
	->execute();

	foreach ($outbound_xforms as $outbound_xform) {
	$outbound_xform->delete();
	}

	$inbound_xforms = id(new PhabricatorTransformedFile())->loadAllWhere(
	'transformedPHID = %s',
	$this->getPHID());

	$this->openTransaction();
	foreach ($inbound_xforms as $inbound_xform) {
	$inbound_xform->delete();
	}
	$ret = parent::delete();
	$this->saveTransaction();

	$this->deleteFileDataIfUnused(
	$this->instantiateStorageEngine(),
	$this->getStorageEngine(),
	$this->getStorageHandle());

	return $ret;
	}


	/**
	* Destroy stored file data if there are no remaining files which reference
	* it.
	*/
	public function deleteFileDataIfUnused(
	PhabricatorFileStorageEngine $engine,
	$engine_identifier,
	$handle) {

	// Check to see if any files are using storage.
	$usage = id(new PhabricatorFile())->loadAllWhere(
	'storageEngine = %s AND storageHandle = %s LIMIT 1',
	$engine_identifier,
	$handle);

	// If there are no files using the storage, destroy the actual storage.
	if (!$usage) {
	try {
	$engine->deleteFile($handle);
	} catch (Exception $ex) {
	// In the worst case, we're leaving some data stranded in a storage
	// engine, which is not a big deal.
	phlog($ex);
	}
	}
	}


	public static function hashFileContent($data) {
	return sha1($data);
	}

	public function loadFileData() {

	$engine = $this->instantiateStorageEngine();
	$data = $engine->readFile($this->getStorageHandle());

	switch ($this->getStorageFormat()) {
	case self::STORAGE_FORMAT_RAW:
	$data = $data;
	break;
	default:
	throw new Exception('Unknown storage format.');
	}

	return $data;
	}

	public function getViewURI() {
	if (!$this->getPHID()) {
	throw new Exception(
	'You must save a file before you can generate a view URI.');
	}

	return $this->getCDNURI(null);
	}

	private function getCDNURI($token) {
	$name = phutil_escape_uri($this->getName());

	$parts = array();
	$parts[] = 'file';
	$parts[] = 'data';

	// If this is an instanced install, add the instance identifier to the URI.
	// Instanced configurations behind a CDN may not be able to control the
	// request domain used by the CDN (as with AWS CloudFront). Embedding the
	// instance identity in the path allows us to distinguish between requests
	// originating from different instances but served through the same CDN.
	$instance = PhabricatorEnv::getEnvConfig('cluster.instance');
	if (strlen($instance)) {
	$parts[] = '@'.$instance;
	}

	$parts[] = $this->getSecretKey();
	$parts[] = $this->getPHID();
	if ($token) {
	$parts[] = $token;
	}
	$parts[] = $name;

	- $path = implode('/', $parts);
	+ $path = '/'.implode('/', $parts);

	- return PhabricatorEnv::getCDNURI($path);
	+ // If this file is only partially uploaded, we're just going to return a
	+ // local URI to make sure that Ajax works, since the page is inevitably
	+ // going to give us an error back.
	+ if ($this->getIsPartial()) {
	+ return PhabricatorEnv::getURI($path);
	+ } else {
	+ return PhabricatorEnv::getCDNURI($path);
	+ }
	}

	/**
	* Get the CDN URI for this file, including a one-time-use security token.
	*
	*/
	public function getCDNURIWithToken() {
	if (!$this->getPHID()) {
	throw new Exception(
	'You must save a file before you can generate a CDN URI.');
	}

	return $this->getCDNURI($this->generateOneTimeToken());
	}


	public function getInfoURI() {
	return '/'.$this->getMonogram();
	}

	public function getBestURI() {
	if ($this->isViewableInBrowser()) {
	return $this->getViewURI();
	} else {
	return $this->getInfoURI();
	}
	}

	public function getDownloadURI() {
	$uri = id(new PhutilURI($this->getViewURI()))
	->setQueryParam('download', true);
	return (string) $uri;
	}

	private function getTransformedURI($transform) {
	$parts = array();
	$parts[] = 'file';
	$parts[] = 'xform';

	$instance = PhabricatorEnv::getEnvConfig('cluster.instance');
	if (strlen($instance)) {
	$parts[] = '@'.$instance;
	}

	$parts[] = $transform;
	$parts[] = $this->getPHID();
	$parts[] = $this->getSecretKey();

	$path = implode('/', $parts);
	$path = $path.'/';

	return PhabricatorEnv::getCDNURI($path);
	}

	public function getProfileThumbURI() {
	return $this->getTransformedURI('thumb-profile');
	}

	public function getThumb60x45URI() {
	return $this->getTransformedURI('thumb-60x45');
	}

	public function getThumb160x120URI() {
	return $this->getTransformedURI('thumb-160x120');
	}

	public function getPreview100URI() {
	return $this->getTransformedURI('preview-100');
	}

	public function getPreview220URI() {
	return $this->getTransformedURI('preview-220');
	}

	public function getThumb220x165URI() {
	return $this->getTransfomredURI('thumb-220x165');
	}

	public function getThumb280x210URI() {
	return $this->getTransformedURI('thumb-280x210');
	}

	public function isViewableInBrowser() {
	return ($this->getViewableMimeType() !== null);
	}

	public function isViewableImage() {
	if (!$this->isViewableInBrowser()) {
	return false;
	}

	$mime_map = PhabricatorEnv::getEnvConfig('files.image-mime-types');
	$mime_type = $this->getMimeType();
	return idx($mime_map, $mime_type);
	}

	public function isAudio() {
	if (!$this->isViewableInBrowser()) {
	return false;
	}

	$mime_map = PhabricatorEnv::getEnvConfig('files.audio-mime-types');
	$mime_type = $this->getMimeType();
	return idx($mime_map, $mime_type);
	}

	public function isTransformableImage() {
	// NOTE: The way the 'gd' extension works in PHP is that you can install it
	// with support for only some file types, so it might be able to handle
	// PNG but not JPEG. Try to generate thumbnails for whatever we can. Setup
	// warns you if you don't have complete support.

	$matches = null;
	$ok = preg_match(
	'@^image/(gif\|png\|jpe?g)@',
	$this->getViewableMimeType(),
	$matches);
	if (!$ok) {
	return false;
	}

	switch ($matches[1]) {
	case 'jpg';
	case 'jpeg':
	return function_exists('imagejpeg');
	break;
	case 'png':
	return function_exists('imagepng');
	break;
	case 'gif':
	return function_exists('imagegif');
	break;
	default:
	throw new Exception('Unknown type matched as image MIME type.');
	}
	}

	public static function getTransformableImageFormats() {
	$supported = array();

	if (function_exists('imagejpeg')) {
	$supported[] = 'jpg';
	}

	if (function_exists('imagepng')) {
	$supported[] = 'png';
	}

	if (function_exists('imagegif')) {
	$supported[] = 'gif';
	}

	return $supported;
	}

	public function instantiateStorageEngine() {
	return self::buildEngine($this->getStorageEngine());
	}

	public static function buildEngine($engine_identifier) {
	$engines = self::buildAllEngines();
	foreach ($engines as $engine) {
	if ($engine->getEngineIdentifier() == $engine_identifier) {
	return $engine;
	}
	}

	throw new Exception(
	"Storage engine '{$engine_identifier}' could not be located!");
	}

	public static function buildAllEngines() {
	$engines = id(new PhutilSymbolLoader())
	->setType('class')
	->setConcreteOnly(true)
	->setAncestorClass('PhabricatorFileStorageEngine')
	->selectAndLoadSymbols();

	$results = array();
	foreach ($engines as $engine_class) {
	$results[] = newv($engine_class['name'], array());
	}

	return $results;
	}

	public function getViewableMimeType() {
	$mime_map = PhabricatorEnv::getEnvConfig('files.viewable-mime-types');

	$mime_type = $this->getMimeType();
	$mime_parts = explode(';', $mime_type);
	$mime_type = trim(reset($mime_parts));

	return idx($mime_map, $mime_type);
	}

	public function getDisplayIconForMimeType() {
	$mime_map = PhabricatorEnv::getEnvConfig('files.icon-mime-types');
	$mime_type = $this->getMimeType();
	return idx($mime_map, $mime_type, 'fa-file-o');
	}

	public function validateSecretKey($key) {
	return ($key == $this->getSecretKey());
	}

	public function generateSecretKey() {
	return Filesystem::readRandomCharacters(20);
	}

	public function updateDimensions($save = true) {
	if (!$this->isViewableImage()) {
	throw new Exception(
	'This file is not a viewable image.');
	}

	if (!function_exists('imagecreatefromstring')) {
	throw new Exception(
	'Cannot retrieve image information.');
	}

	$data = $this->loadFileData();

	$img = imagecreatefromstring($data);
	if ($img === false) {
	throw new Exception(
	'Error when decoding image.');
	}

	$this->metadata[self::METADATA_IMAGE_WIDTH] = imagesx($img);
	$this->metadata[self::METADATA_IMAGE_HEIGHT] = imagesy($img);

	if ($save) {
	$this->save();
	}

	return $this;
	}

	public function copyDimensions(PhabricatorFile $file) {
	$metadata = $file->getMetadata();
	$width = idx($metadata, self::METADATA_IMAGE_WIDTH);
	if ($width) {
	$this->metadata[self::METADATA_IMAGE_WIDTH] = $width;
	}
	$height = idx($metadata, self::METADATA_IMAGE_HEIGHT);
	if ($height) {
	$this->metadata[self::METADATA_IMAGE_HEIGHT] = $height;
	}

	return $this;
	}


	/**
	* Load (or build) the {@class:PhabricatorFile} objects for builtin file
	* resources. The builtin mechanism allows files shipped with Phabricator
	* to be treated like normal files so that APIs do not need to special case
	* things like default images or deleted files.
	*
	* Builtins are located in `resources/builtin/` and identified by their
	* name.
	*
	* @param PhabricatorUser Viewing user.
	* @param list<string> List of builtin file names.
	* @return dict<string, PhabricatorFile> Dictionary of named builtins.
	*/
	public static function loadBuiltins(PhabricatorUser $user, array $names) {
	$specs = array();
	foreach ($names as $name) {
	$specs[] = array(
	'originalPHID' => PhabricatorPHIDConstants::PHID_VOID,
	'transform' => 'builtin:'.$name,
	);
	}

	// NOTE: Anyone is allowed to access builtin files.

	$files = id(new PhabricatorFileQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withTransforms($specs)
	->execute();

	$files = mpull($files, null, 'getName');

	$root = dirname(phutil_get_library_root('phabricator'));
	$root = $root.'/resources/builtin/';

	$build = array();
	foreach ($names as $name) {
	if (isset($files[$name])) {
	continue;
	}

	// This is just a sanity check to prevent loading arbitrary files.
	if (basename($name) != $name) {
	throw new Exception("Invalid builtin name '{$name}'!");
	}

	$path = $root.$name;

	if (!Filesystem::pathExists($path)) {
	throw new Exception("Builtin '{$path}' does not exist!");
	}

	$data = Filesystem::readFile($path);
	$params = array(
	'name' => $name,
	'ttl' => time() + (60 * 60 * 24 * 7),
	'canCDN' => true,
	'builtin' => $name,
	);

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$file = PhabricatorFile::newFromFileData($data, $params);
	$xform = id(new PhabricatorTransformedFile())
	->setOriginalPHID(PhabricatorPHIDConstants::PHID_VOID)
	->setTransform('builtin:'.$name)
	->setTransformedPHID($file->getPHID())
	->save();
	unset($unguarded);

	$file->attachObjectPHIDs(array());
	$file->attachObjects(array());

	$files[$name] = $file;
	}

	return $files;
	}


	/**
	* Convenience wrapper for @{method:loadBuiltins}.
	*
	* @param PhabricatorUser Viewing user.
	* @param string Single builtin name to load.
	* @return PhabricatorFile Corresponding builtin file.
	*/
	public static function loadBuiltin(PhabricatorUser $user, $name) {
	return idx(self::loadBuiltins($user, array($name)), $name);
	}

	public function getObjects() {
	return $this->assertAttached($this->objects);
	}

	public function attachObjects(array $objects) {
	$this->objects = $objects;
	return $this;
	}

	public function getObjectPHIDs() {
	return $this->assertAttached($this->objectPHIDs);
	}

	public function attachObjectPHIDs(array $object_phids) {
	$this->objectPHIDs = $object_phids;
	return $this;
	}

	public function getOriginalFile() {
	return $this->assertAttached($this->originalFile);
	}

	public function attachOriginalFile(PhabricatorFile $file = null) {
	$this->originalFile = $file;
	return $this;
	}

	public function getImageHeight() {
	if (!$this->isViewableImage()) {
	return null;
	}
	return idx($this->metadata, self::METADATA_IMAGE_HEIGHT);
	}

	public function getImageWidth() {
	if (!$this->isViewableImage()) {
	return null;
	}
	return idx($this->metadata, self::METADATA_IMAGE_WIDTH);
	}

	public function getCanCDN() {
	if (!$this->isViewableImage()) {
	return false;
	}

	return idx($this->metadata, self::METADATA_CAN_CDN);
	}

	public function setCanCDN($can_cdn) {
	$this->metadata[self::METADATA_CAN_CDN] = $can_cdn ? 1 : 0;
	return $this;
	}

	public function isBuiltin() {
	return ($this->getBuiltinName() !== null);
	}

	public function getBuiltinName() {
	return idx($this->metadata, self::METADATA_BUILTIN);
	}

	public function setBuiltinName($name) {
	$this->metadata[self::METADATA_BUILTIN] = $name;
	return $this;
	}

	protected function generateOneTimeToken() {
	$key = Filesystem::readRandomCharacters(16);

	// Save the new secret.
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$token = id(new PhabricatorAuthTemporaryToken())
	->setObjectPHID($this->getPHID())
	->setTokenType(self::ONETIME_TEMPORARY_TOKEN_TYPE)
	->setTokenExpires(time() + phutil_units('1 hour in seconds'))
	->setTokenCode(PhabricatorHash::digest($key))
	->save();
	unset($unguarded);

	return $key;
	}

	public function validateOneTimeToken($token_code) {
	$token = id(new PhabricatorAuthTemporaryTokenQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withObjectPHIDs(array($this->getPHID()))
	->withTokenTypes(array(self::ONETIME_TEMPORARY_TOKEN_TYPE))
	->withExpired(false)
	->withTokenCodes(array(PhabricatorHash::digest($token_code)))
	->executeOne();

	return $token;
	}


	/**
	* Write the policy edge between this file and some object.
	*
	* @param phid Object PHID to attach to.
	* @return this
	*/
	public function attachToObject($phid) {
	$edge_type = PhabricatorObjectHasFileEdgeType::EDGECONST;

	id(new PhabricatorEdgeEditor())
	->addEdge($phid, $edge_type, $this->getPHID())
	->save();

	return $this;
	}


	/**
	* Remove the policy edge between this file and some object.
	*
	* @param phid Object PHID to detach from.
	* @return this
	*/
	public function detachFromObject($phid) {
	$edge_type = PhabricatorObjectHasFileEdgeType::EDGECONST;

	id(new PhabricatorEdgeEditor())
	->removeEdge($phid, $edge_type, $this->getPHID())
	->save();

	return $this;
	}


	/**
	* Configure a newly created file object according to specified parameters.
	*
	* This method is called both when creating a file from fresh data, and
	* when creating a new file which reuses existing storage.
	*
	* @param map<string, wild> Bag of parameters, see @{class:PhabricatorFile}
	* for documentation.
	* @return this
	*/
	private function readPropertiesFromParameters(array $params) {
	$file_name = idx($params, 'name');
	$file_name = self::normalizeFileName($file_name);
	$this->setName($file_name);

	$author_phid = idx($params, 'authorPHID');
	$this->setAuthorPHID($author_phid);

	$file_ttl = idx($params, 'ttl');
	$this->setTtl($file_ttl);

	$view_policy = idx($params, 'viewPolicy');
	if ($view_policy) {
	$this->setViewPolicy($params['viewPolicy']);
	}

	$is_explicit = (idx($params, 'isExplicitUpload') ? 1 : 0);
	$this->setIsExplicitUpload($is_explicit);

	$can_cdn = idx($params, 'canCDN');
	if ($can_cdn) {
	$this->setCanCDN(true);
	}

	$builtin = idx($params, 'builtin');
	if ($builtin) {
	$this->setBuiltinName($builtin);
	}

	$mime_type = idx($params, 'mime-type');
	if ($mime_type) {
	$this->setMimeType($mime_type);
	}

	return $this;
	}

	public function getRedirectResponse() {
	$uri = $this->getBestURI();

	// TODO: This is a bit iffy. Sometimes, getBestURI() returns a CDN URI
	// (if the file is a viewable image) and sometimes a local URI (if not).
	// For now, just detect which one we got and configure the response
	// appropriately. In the long run, if this endpoint is served from a CDN
	// domain, we can't issue a local redirect to an info URI (which is not
	// present on the CDN domain). We probably never actually issue local
	// redirects here anyway, since we only ever transform viewable images
	// right now.

	$is_external = strlen(id(new PhutilURI($uri))->getDomain());

	return id(new AphrontRedirectResponse())
	->setIsExternal($is_external)
	->setURI($uri);
	}

	- public function isPartial() {
	- // TODO: Placeholder for resumable uploads.
	- return false;
	- }
	-

	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorFileEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorFileTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	/* -( PhabricatorPolicyInterface Implementation )-------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if ($this->isBuiltin()) {
	return PhabricatorPolicies::getMostOpenPolicy();
	}
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	$viewer_phid = $viewer->getPHID();
	if ($viewer_phid) {
	if ($this->getAuthorPHID() == $viewer_phid) {
	return true;
	}
	}

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	// If you can see the file this file is a transform of, you can see
	// this file.
	if ($this->getOriginalFile()) {
	return true;
	}

	// If you can see any object this file is attached to, you can see
	// the file.
	return (count($this->getObjects()) > 0);
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	$out = array();
	$out[] = pht('The user who uploaded a file can always view and edit it.');
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$out[] = pht(
	'Files attached to objects are visible to users who can view '.
	'those objects.');
	$out[] = pht(
	'Thumbnails are visible only to users who can view the original '.
	'file.');
	break;
	}

	return $out;
	}


	/* -( PhabricatorSubscribableInterface Implementation )-------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($this->authorPHID == $phid);
	}

	public function shouldShowSubscribersProperty() {
	return true;
	}

	public function shouldAllowSubscription($phid) {
	return true;
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 17:14 (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126850
Default Alt Text: (70 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions