No OneTemporary
Actions

Size

35 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/DifferentialReplyHandler.php b/src/applications/differential/DifferentialReplyHandler.php
	index 49e03155a1..50b2c4099d 100644
	--- a/src/applications/differential/DifferentialReplyHandler.php
	+++ b/src/applications/differential/DifferentialReplyHandler.php
	@@ -1,188 +1,190 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	class DifferentialReplyHandler extends PhabricatorMailReplyHandler {

	private $receivedMail;

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof DifferentialRevision)) {
	throw new Exception("Receiver is not a DifferentialRevision!");
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'D');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('D');
	}

	public function getReplyHandlerDomain() {
	return PhabricatorEnv::getEnvConfig(
	'metamta.differential.reply-handler-domain');
	}

	/*
	* Generate text like the following from the supported commands.
	* "
	*
	* ACTIONS
	* Reply to comment, or !accept, !reject, !abandon, !resign, !reclaim.
	*
	* "
	*/
	public function getReplyHandlerInstructions() {
	if (!$this->supportsReplies()) {
	return null;
	}

	$supported_commands = $this->getSupportedCommands();
	$text = '';
	if (empty($supported_commands)) {
	return $text;
	}

	$comment_command_printed = false;
	if (in_array(DifferentialAction::ACTION_COMMENT, $supported_commands)) {
	$text .= 'Reply to comment';
	$comment_command_printed = true;

	$supported_commands = array_diff(
	$supported_commands, array(DifferentialAction::ACTION_COMMENT));
	}

	if (!empty($supported_commands)) {
	if ($comment_command_printed) {
	$text .= ', or ';
	}

	$modified_commands = array();
	foreach ($supported_commands as $command) {
	$modified_commands[] = '!'.$command;
	}

	$text .= implode(', ', $modified_commands);
	}

	$text .= ".";

	return $text;
	}

	public function getSupportedCommands() {
	$actions = array(
	DifferentialAction::ACTION_COMMENT,
	DifferentialAction::ACTION_REJECT,
	DifferentialAction::ACTION_ABANDON,
	DifferentialAction::ACTION_RECLAIM,
	DifferentialAction::ACTION_RESIGN,
	DifferentialAction::ACTION_RETHINK,
	'unsubscribe',
	);

	if (PhabricatorEnv::getEnvConfig('differential.enable-email-accept')) {
	$actions[] = DifferentialAction::ACTION_ACCEPT;
	}

	return $actions;
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$this->receivedMail = $mail;
	- $this->handleAction($mail->getCleanTextBody());
	+ $this->handleAction($mail->getCleanTextBody(), $mail->getAttachments());
	}

	- public function handleAction($body) {
	+ public function handleAction($body, array $attachments) {
	// all commands start with a bang and separated from the body by a newline
	// to make sure that actual feedback text couldn't trigger an action.
	// unrecognized commands will be parsed as part of the comment.
	$command = DifferentialAction::ACTION_COMMENT;
	$supported_commands = $this->getSupportedCommands();
	$regex = "/\A\n!(" . implode('\|', $supported_commands) . ")\n/";
	$matches = array();
	if (preg_match($regex, $body, $matches)) {
	$command = $matches[1];
	$body = trim(str_replace('!' . $command, '', $body));
	}

	$actor = $this->getActor();
	if (!$actor) {
	throw new Exception('No actor is set for the reply action.');
	}

	switch ($command) {
	case 'unsubscribe':
	$this->unsubscribeUser($this->getMailReceiver(), $actor);
	// TODO: Send the user a confirmation email?
	return null;
	}

	+ $body = $this->enhanceBodyWithAttachments($body, $attachments);
	+
	try {
	$editor = new DifferentialCommentEditor(
	$this->getMailReceiver(),
	$command);
	$editor->setActor($actor);
	$editor->setExcludeMailRecipientPHIDs(
	$this->getExcludeMailRecipientPHIDs());

	// NOTE: We have to be careful about this because Facebook's
	// implementation jumps straight into handleAction() and will not have
	// a PhabricatorMetaMTAReceivedMail object.
	if ($this->receivedMail) {
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $this->receivedMail->getID(),
	));
	$editor->setContentSource($content_source);
	$editor->setParentMessageID($this->receivedMail->getMessageID());
	}
	$editor->setMessage($body);
	$comment = $editor->save();

	return $comment->getID();

	} catch (Exception $ex) {
	$exception_mail = new DifferentialExceptionMail(
	$this->getMailReceiver(),
	$ex,
	$this->receivedMail->getRawTextBody());

	$exception_mail->setToPHIDs(array($this->getActor()->getPHID()));
	$exception_mail->send();

	throw $ex;
	}
	}

	private function unsubscribeUser(
	DifferentialRevision $revision,
	PhabricatorUser $user) {

	$revision->loadRelationships();
	DifferentialRevisionEditor::removeCCAndUpdateRevision(
	$revision,
	$user->getPHID(),
	$user->getPHID());
	}


	}
	diff --git a/src/applications/maniphest/ManiphestReplyHandler.php b/src/applications/maniphest/ManiphestReplyHandler.php
	index 423f36e1b4..5eb9ab23f7 100644
	--- a/src/applications/maniphest/ManiphestReplyHandler.php
	+++ b/src/applications/maniphest/ManiphestReplyHandler.php
	@@ -1,188 +1,182 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @group maniphest
	*/
	final class ManiphestReplyHandler extends PhabricatorMailReplyHandler {

	public function validateMailReceiver($mail_receiver) {
	if (!($mail_receiver instanceof ManiphestTask)) {
	throw new Exception("Mail receiver is not a ManiphestTask!");
	}
	}

	public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle) {
	return $this->getDefaultPrivateReplyHandlerEmailAddress($handle, 'T');
	}

	public function getPublicReplyHandlerEmailAddress() {
	return $this->getDefaultPublicReplyHandlerEmailAddress('T');
	}

	public function getReplyHandlerDomain() {
	return PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.reply-handler-domain');
	}

	public function getReplyHandlerInstructions() {
	if ($this->supportsReplies()) {
	return "Reply to comment or attach files, or !close, !claim, or ".
	"!unsubscribe.";
	} else {
	return null;
	}
	}

	protected function receiveEmail(PhabricatorMetaMTAReceivedMail $mail) {

	// NOTE: We'll drop in here on both the "reply to a task" and "create a
	// new task" workflows! Make sure you test both if you make changes!

	$task = $this->getMailReceiver();

	$is_new_task = !$task->getID();

	$user = $this->getActor();

	$body = $mail->getCleanTextBody();
	$body = trim($body);
	+ $body = $this->enhanceBodyWithAttachments($body, $mail->getAttachments());

	$xactions = array();
	-
	$content_source = PhabricatorContentSource::newForSource(
	PhabricatorContentSource::SOURCE_EMAIL,
	array(
	'id' => $mail->getID(),
	));

	$template = new ManiphestTransaction();
	$template->setContentSource($content_source);
	$template->setAuthorPHID($user->getPHID());

	+
	if ($is_new_task) {
	// If this is a new task, create a "User created this task." transaction
	// and then set the title and description.
	$xaction = clone $template;
	$xaction->setTransactionType(ManiphestTransactionType::TYPE_STATUS);
	$xaction->setNewValue(ManiphestTaskStatus::STATUS_OPEN);
	$xactions[] = $xaction;

	$task->setAuthorPHID($user->getPHID());
	$task->setTitle(nonempty($mail->getSubject(), 'Untitled Task'));
	$task->setDescription($body);
	$task->setPriority(ManiphestTaskPriority::getDefaultPriority());

	} else {
	$lines = explode("\n", trim($body));
	$first_line = head($lines);

	$command = null;
	$matches = null;
	if (preg_match('/^!(\w+)/', $first_line, $matches)) {
	$lines = array_slice($lines, 1);
	$body = implode("\n", $lines);
	$body = trim($body);

	$command = $matches[1];
	}

	$ttype = ManiphestTransactionType::TYPE_NONE;
	$new_value = null;
	switch ($command) {
	case 'close':
	$ttype = ManiphestTransactionType::TYPE_STATUS;
	$new_value = ManiphestTaskStatus::STATUS_CLOSED_RESOLVED;
	break;
	case 'claim':
	$ttype = ManiphestTransactionType::TYPE_OWNER;
	$new_value = $user->getPHID();
	break;
	case 'unsubscribe':
	$ttype = ManiphestTransactionType::TYPE_CCS;
	$ccs = $task->getCCPHIDs();
	foreach ($ccs as $k => $phid) {
	if ($phid == $user->getPHID()) {
	unset($ccs[$k]);
	}
	}
	$new_value = array_values($ccs);
	break;
	}

	$xaction = clone $template;
	$xaction->setTransactionType($ttype);
	$xaction->setNewValue($new_value);
	$xaction->setComments($body);

	$xactions[] = $xaction;
	}

	- // TODO: We should look at CCs on the mail and add them as CCs.
	-
	- $files = $mail->getAttachments();
	- if ($files) {
	- $file_xaction = clone $template;
	- $file_xaction->setTransactionType(ManiphestTransactionType::TYPE_ATTACH);
	-
	- $phid_type = PhabricatorPHIDConstants::PHID_TYPE_FILE;
	- $new = $task->getAttached();
	- foreach ($files as $file_phid) {
	- $new[$phid_type][$file_phid] = array();
	- }
	-
	- $file_xaction->setNewValue($new);
	- $xactions[] = $file_xaction;
	+ $ccs = $mail->loadCCPHIDs();
	+ if ($ccs) {
	+ $old_ccs = $task->getCCPHIDs();
	+ $new_ccs = array_unique(array_merge($old_ccs, $ccs));
	+ $cc_xaction = clone $template;
	+ $cc_xaction->setTransactionType(ManiphestTransactionType::TYPE_CCS);
	+ $cc_xaction->setNewValue($new_ccs);
	+ $xactions[] = $cc_xaction;
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
	array(
	'task' => $task,
	'mail' => $mail,
	'new' => $is_new_task,
	'transactions' => $xactions,
	));
	$event->setUser($user);
	PhutilEventEngine::dispatchEvent($event);

	$task = $event->getValue('task');
	$xactions = $event->getValue('transactions');


	$editor = new ManiphestTransactionEditor();
	$editor->setActor($user);
	$editor->setParentMessageID($mail->getMessageID());
	$editor->setExcludeMailRecipientPHIDs(
	$this->getExcludeMailRecipientPHIDs());
	$editor->applyTransactions($task, $xactions);

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
	array(
	'task' => $task,
	'new' => $is_new_task,
	'transactions' => $xactions,
	));
	$event->setUser($user);
	PhutilEventEngine::dispatchEvent($event);

	}

	}
	diff --git a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	index 02429d9d36..7ea011f1a9 100644
	--- a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	+++ b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	@@ -1,308 +1,332 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	abstract class PhabricatorMailReplyHandler {

	private $mailReceiver;
	private $actor;
	private $excludePHIDs = array();

	final public function setMailReceiver($mail_receiver) {
	$this->validateMailReceiver($mail_receiver);
	$this->mailReceiver = $mail_receiver;
	return $this;
	}

	final public function getMailReceiver() {
	return $this->mailReceiver;
	}

	final public function setActor(PhabricatorUser $actor) {
	$this->actor = $actor;
	return $this;
	}

	final public function getActor() {
	return $this->actor;
	}

	final public function setExcludeMailRecipientPHIDs(array $exclude) {
	$this->excludePHIDs = $exclude;
	return $this;
	}

	final public function getExcludeMailRecipientPHIDs() {
	return $this->excludePHIDs;
	}

	abstract public function validateMailReceiver($mail_receiver);
	abstract public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle);
	abstract public function getReplyHandlerDomain();
	abstract public function getReplyHandlerInstructions();
	abstract protected function receiveEmail(
	PhabricatorMetaMTAReceivedMail $mail);

	public function processEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$error = $this->sanityCheckEmail($mail);

	if ($error) {
	if ($this->shouldSendErrorEmail($mail)) {
	$this->sendErrorEmail($error, $mail);
	}
	return null;
	}

	return $this->receiveEmail($mail);
	}

	private function sanityCheckEmail(PhabricatorMetaMTAReceivedMail $mail) {
	- $body = $mail->getCleanTextBody();
	- if (empty($body)) {
	+ $body = $mail->getCleanTextBody();
	+ $attachments = $mail->getAttachments();
	+
	+ if (empty($body) && empty($attachments)) {
	return 'Empty email body. Email should begin with an !action and / or '.
	'text to comment. Inline replies and signatures are ignored.';
	}

	return null;
	}

	/**
	* Only send an error email if the user is talking to just Phabricator. We
	* can assume if there is only one To address it is a Phabricator address
	* since this code is running and everything.
	*/
	private function shouldSendErrorEmail(PhabricatorMetaMTAReceivedMail $mail) {
	return count($mail->getToAddresses() == 1) &&
	count($mail->getCCAddresses() == 0);
	}

	private function sendErrorEmail($error,
	PhabricatorMetaMTAReceivedMail $mail) {
	$template = new PhabricatorMetaMTAMail();
	$template->setSubject('Exception: unable to process your mail request');
	$template->setBody($this->buildErrorMailBody($error, $mail));
	$template->setRelatedPHID($mail->getRelatedPHID());
	$phid = $this->getActor()->getPHID();
	$tos = array(
	$phid => PhabricatorObjectHandleData::loadOneHandle($phid)
	);
	$mails = $this->multiplexMail($template, $tos, array());

	foreach ($mails as $email) {
	$email->saveAndSend();
	}

	return true;
	}

	private function buildErrorMailBody($error,
	PhabricatorMetaMTAReceivedMail $mail) {
	$original_body = $mail->getRawTextBody();

	$main_body = <<<EOBODY
	Your request failed because an error was encoutered while processing it:

	ERROR: {$error}

	-- Original Body -------------------------------------------------------------

	{$original_body}

	EOBODY;

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection($main_body);
	$body->addReplySection($this->getReplyHandlerInstructions());

	return $body->render();
	}

	public function supportsPrivateReplies() {
	return (bool)$this->getReplyHandlerDomain() &&
	!$this->supportsPublicReplies();
	}

	public function supportsPublicReplies() {
	if (!PhabricatorEnv::getEnvConfig('metamta.public-replies')) {
	return false;
	}
	if (!$this->getReplyHandlerDomain()) {
	return false;
	}
	return (bool)$this->getPublicReplyHandlerEmailAddress();
	}

	final public function supportsReplies() {
	return $this->supportsPrivateReplies() \|\|
	$this->supportsPublicReplies();
	}

	public function getPublicReplyHandlerEmailAddress() {
	return null;
	}

	final public function getRecipientsSummary(
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	$body = '';

	if (PhabricatorEnv::getEnvConfig('metamta.recipients.show-hints')) {
	if ($to_handles) {
	$body .= "To: ".implode(', ', mpull($to_handles, 'getName'))."\n";
	}
	if ($cc_handles) {
	$body .= "Cc: ".implode(', ', mpull($cc_handles, 'getName'))."\n";
	}
	}

	return $body;
	}

	final public function multiplexMail(
	PhabricatorMetaMTAMail $mail_template,
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	$result = array();

	// If MetaMTA is configured to always multiplex, skip the single-email
	// case.
	if (!PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
	// If private replies are not supported, simply send one email to all
	// recipients and CCs. This covers cases where we have no reply handler,
	// or we have a public reply handler.
	if (!$this->supportsPrivateReplies()) {
	$mail = clone $mail_template;
	$mail->addTos(mpull($to_handles, 'getPHID'));
	$mail->addCCs(mpull($cc_handles, 'getPHID'));

	if ($this->supportsPublicReplies()) {
	$reply_to = $this->getPublicReplyHandlerEmailAddress();
	$mail->setReplyTo($reply_to);
	}

	$result[] = $mail;

	return $result;
	}
	}

	$tos = mpull($to_handles, null, 'getPHID');
	$ccs = mpull($cc_handles, null, 'getPHID');

	// Merge all the recipients together. TODO: We could keep the CCs as real
	// CCs and send to a "noreply@domain.com" type address, but keep it simple
	// for now.
	$recipients = $tos + $ccs;

	// When multiplexing mail, explicitly include To/Cc information in the
	// message body and headers.

	$mail_template = clone $mail_template;

	$mail_template->addPHIDHeaders('X-Phabricator-To', array_keys($tos));
	$mail_template->addPHIDHeaders('X-Phabricator-Cc', array_keys($ccs));

	$body = $mail_template->getBody();
	$body .= "\n";
	$body .= $this->getRecipientsSummary($to_handles, $cc_handles);

	foreach ($recipients as $phid => $recipient) {
	$mail = clone $mail_template;
	if (isset($to_handles[$phid])) {
	$mail->addTos(array($phid));
	} else if (isset($cc_handles[$phid])) {
	$mail->addCCs(array($phid));
	} else {
	// not good - they should be a to or a cc
	continue;
	}

	$mail->setBody($body);

	$reply_to = null;
	if (!$reply_to && $this->supportsPrivateReplies()) {
	$reply_to = $this->getPrivateReplyHandlerEmailAddress($recipient);
	}

	if (!$reply_to && $this->supportsPublicReplies()) {
	$reply_to = $this->getPublicReplyHandlerEmailAddress();
	}

	if ($reply_to) {
	$mail->setReplyTo($reply_to);
	}

	$result[] = $mail;
	}

	return $result;
	}

	protected function getDefaultPublicReplyHandlerEmailAddress($prefix) {

	$receiver = $this->getMailReceiver();
	$receiver_id = $receiver->getID();
	$domain = $this->getReplyHandlerDomain();

	// We compute a hash using the object's own PHID to prevent an attacker
	// from blindly interacting with objects that they haven't ever received
	// mail about by just sending to D1@, D2@, etc...
	$hash = PhabricatorMetaMTAReceivedMail::computeMailHash(
	$receiver->getMailKey(),
	$receiver->getPHID());

	$address = "{$prefix}{$receiver_id}+public+{$hash}@{$domain}";
	return $this->getSingleReplyHandlerPrefix($address);
	}

	protected function getSingleReplyHandlerPrefix($address) {
	$single_handle_prefix = PhabricatorEnv::getEnvConfig(
	'metamta.single-reply-handler-prefix');
	return ($single_handle_prefix)
	? $single_handle_prefix . '+' . $address
	: $address;
	}

	protected function getDefaultPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle,
	$prefix) {

	if ($handle->getType() != PhabricatorPHIDConstants::PHID_TYPE_USER) {
	// You must be a real user to get a private reply handler address.
	return null;
	}

	$receiver = $this->getMailReceiver();
	$receiver_id = $receiver->getID();
	$user_id = $handle->getAlternateID();
	$hash = PhabricatorMetaMTAReceivedMail::computeMailHash(
	$receiver->getMailKey(),
	$handle->getPHID());
	$domain = $this->getReplyHandlerDomain();

	$address = "{$prefix}{$receiver_id}+{$user_id}+{$hash}@{$domain}";
	return $this->getSingleReplyHandlerPrefix($address);
	}

	+ final protected function enhanceBodyWithAttachments($body,
	+ array $attachments) {
	+ if (!$attachments) {
	+ return $body;
	+ }
	+
	+ $files = id(new PhabricatorFile())
	+ ->loadAllWhere('phid in (%Ls)', $attachments);
	+
	+ // if we have some text then double return before adding our file list
	+ if ($body) {
	+ $body .= "\n\n";
	+ }
	+
	+ foreach ($files as $file) {
	+ $file_str = sprintf('- {F%d, layout=link}', $file->getID());
	+ $body .= $file_str."\n";
	+ }
	+
	+ return rtrim($body);
	+ }
	+
	}
	diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAReceivedMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAReceivedMail.php
	index 2ddd902644..fcd6f60bde 100644
	--- a/src/applications/metamta/storage/PhabricatorMetaMTAReceivedMail.php
	+++ b/src/applications/metamta/storage/PhabricatorMetaMTAReceivedMail.php
	@@ -1,392 +1,400 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class PhabricatorMetaMTAReceivedMail extends PhabricatorMetaMTADAO {

	protected $headers = array();
	protected $bodies = array();
	protected $attachments = array();

	protected $relatedPHID;
	protected $authorPHID;
	protected $message;

	public function getConfiguration() {
	return array(
	self::CONFIG_SERIALIZATION => array(
	'headers' => self::SERIALIZATION_JSON,
	'bodies' => self::SERIALIZATION_JSON,
	'attachments' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

	public function setHeaders(array $headers) {
	// Normalize headers to lowercase.
	$normalized = array();
	foreach ($headers as $name => $value) {
	$normalized[strtolower($name)] = $value;
	}
	$this->headers = $normalized;
	return $this;
	}

	public function getMessageID() {
	return idx($this->headers, 'message-id');
	}

	public function getSubject() {
	return idx($this->headers, 'subject');
	}

	public function getCCAddresses() {
	return $this->getRawEmailAddresses(idx($this->headers, 'cc'));
	}

	public function getToAddresses() {
	return $this->getRawEmailAddresses(idx($this->headers, 'to'));
	}

	private function loadExcludeMailRecipientPHIDs() {
	$addresses = array_merge(
	$this->getToAddresses(),
	$this->getCCAddresses()
	);

	+ return $this->loadPHIDsFromAddresses($addresses);
	+ }
	+
	+ final public function loadCCPHIDs() {
	+ return $this->loadPHIDsFromAddresses($this->getCCAddresses());
	+ }
	+
	+ private function loadPHIDsFromAddresses(array $addresses) {
	$users = id(new PhabricatorUserEmail())
	->loadAllWhere('address IN (%Ls)', $addresses);
	$user_phids = mpull($users, 'getUserPHID');

	$mailing_lists = id(new PhabricatorMetaMTAMailingList())
	->loadAllWhere('email in (%Ls)', $addresses);
	$mailing_list_phids = mpull($mailing_lists, 'getPHID');

	return array_merge($user_phids, $mailing_list_phids);
	}

	/**
	* Parses "to" addresses, looking for a public create email address
	* first and if not found parsing the "to" address for reply handler
	* information: receiver name, user id, and hash.
	*/
	private function getPhabricatorToInformation() {
	// Only one "public" create address so far
	$create_task = PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.public-create-email');

	// For replies, look for an object address with a format like:
	// D291+291+b0a41ca848d66dcc@example.com
	$single_handle_prefix = PhabricatorEnv::getEnvConfig(
	'metamta.single-reply-handler-prefix');

	$prefixPattern = ($single_handle_prefix)
	? preg_quote($single_handle_prefix, '/') . '\+'
	: '';
	$pattern = "/^{$prefixPattern}((?:D\|T\|C)\d+)\+([\w]+)\+([a-f0-9]{16})@/U";

	$phabricator_address = null;
	$receiver_name = null;
	$user_id = null;
	$hash = null;
	foreach ($this->getToAddresses() as $address) {
	if ($address == $create_task) {
	$phabricator_address = $address;
	// it's okay to stop here because we just need to map a create
	// address to an application and don't need / won't have more
	// information in these cases.
	break;
	}

	$matches = null;
	$ok = preg_match(
	$pattern,
	$address,
	$matches);

	if ($ok) {
	$phabricator_address = $address;
	$receiver_name = $matches[1];
	$user_id = $matches[2];
	$hash = $matches[3];
	break;
	}
	}

	return array(
	$phabricator_address,
	$receiver_name,
	$user_id,
	$hash
	);
	}


	public function processReceivedMail() {

	// If Phabricator sent the mail, always drop it immediately. This prevents
	// loops where, e.g., the public bug address is also a user email address
	// and creating a bug sends them an email, which loops.
	$is_phabricator_mail = idx(
	$this->headers,
	'x-phabricator-sent-this-message');
	if ($is_phabricator_mail) {
	$message = "Ignoring email with 'X-Phabricator-Sent-This-Message' ".
	"header to avoid loops.";
	return $this->setMessage($message)->save();
	}

	list($to,
	$receiver_name,
	$user_id,
	$hash) = $this->getPhabricatorToInformation();
	if (!$to) {
	$raw_to = idx($this->headers, 'to');
	return $this->setMessage("Unrecognized 'to' format: {$raw_to}")->save();
	}

	$from = idx($this->headers, 'from');

	// TODO -- make this a switch statement / better if / when we add more
	// public create email addresses!
	$create_task = PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.public-create-email');

	if ($create_task && $to == $create_task) {
	$receiver = new ManiphestTask();

	$user = $this->lookupPublicUser();
	if ($user) {
	$this->setAuthorPHID($user->getPHID());
	} else {
	$default_author = PhabricatorEnv::getEnvConfig(
	'metamta.maniphest.default-public-author');

	if ($default_author) {
	$user = id(new PhabricatorUser())->loadOneWhere(
	'username = %s',
	$default_author);
	if ($user) {
	$receiver->setOriginalEmailSource($from);
	} else {
	throw new Exception(
	"Phabricator is misconfigured, the configuration key ".
	"'metamta.maniphest.default-public-author' is set to user ".
	"'{$default_author}' but that user does not exist.");
	}
	} else {
	// TODO: We should probably bounce these since from the user's
	// perspective their email vanishes into a black hole.
	return $this->setMessage("Invalid public user '{$from}'.")->save();
	}
	}

	$receiver->setAuthorPHID($user->getPHID());
	$receiver->setPriority(ManiphestTaskPriority::PRIORITY_TRIAGE);

	$editor = new ManiphestTransactionEditor();
	$editor->setActor($user);
	$handler = $editor->buildReplyHandler($receiver);

	$handler->setActor($user);
	$handler->setExcludeMailRecipientPHIDs(
	$this->loadExcludeMailRecipientPHIDs());
	$handler->processEmail($this);

	$this->setRelatedPHID($receiver->getPHID());
	$this->setMessage('OK');

	return $this->save();
	}

	if ($user_id == 'public') {
	if (!PhabricatorEnv::getEnvConfig('metamta.public-replies')) {
	return $this->setMessage("Public replies not enabled.")->save();
	}

	$user = $this->lookupPublicUser();

	if (!$user) {
	return $this->setMessage("Invalid public user '{$from}'.")->save();
	}

	$use_user_hash = false;
	} else {
	$user = id(new PhabricatorUser())->load($user_id);
	if (!$user) {
	return $this->setMessage("Invalid private user '{$user_id}'.")->save();
	}

	$use_user_hash = true;
	}

	if ($user->getIsDisabled()) {
	return $this->setMessage("User '{$user_id}' is disabled")->save();
	}

	$this->setAuthorPHID($user->getPHID());

	$receiver = self::loadReceiverObject($receiver_name);
	if (!$receiver) {
	return $this->setMessage("Invalid object '{$receiver_name}'")->save();
	}

	$this->setRelatedPHID($receiver->getPHID());

	if ($use_user_hash) {
	// This is a private reply-to address, check that the user hash is
	// correct.
	$check_phid = $user->getPHID();
	} else {
	// This is a public reply-to address, check that the object hash is
	// correct.
	$check_phid = $receiver->getPHID();
	}

	$expect_hash = self::computeMailHash($receiver->getMailKey(), $check_phid);

	// See note at computeOldMailHash().
	$old_hash = self::computeOldMailHash($receiver->getMailKey(), $check_phid);

	if ($expect_hash != $hash && $old_hash != $hash) {
	return $this->setMessage("Invalid mail hash!")->save();
	}

	if ($receiver instanceof ManiphestTask) {
	$editor = new ManiphestTransactionEditor();
	$editor->setActor($user);
	$handler = $editor->buildReplyHandler($receiver);
	} else if ($receiver instanceof DifferentialRevision) {
	$handler = DifferentialMail::newReplyHandlerForRevision($receiver);
	} else if ($receiver instanceof PhabricatorRepositoryCommit) {
	$handler = PhabricatorAuditCommentEditor::newReplyHandlerForCommit(
	$receiver);
	}

	$handler->setActor($user);
	$handler->setExcludeMailRecipientPHIDs(
	$this->loadExcludeMailRecipientPHIDs());
	$handler->processEmail($this);

	$this->setMessage('OK');

	return $this->save();
	}

	public function getCleanTextBody() {
	$body = idx($this->bodies, 'text');

	$parser = new PhabricatorMetaMTAEmailBodyParser();
	return $parser->stripTextBody($body);
	}

	public function getRawTextBody() {
	return idx($this->bodies, 'text');
	}

	public static function loadReceiverObject($receiver_name) {
	if (!$receiver_name) {
	return null;
	}

	$receiver_type = $receiver_name[0];
	$receiver_id = substr($receiver_name, 1);

	$class_obj = null;
	switch ($receiver_type) {
	case 'T':
	$class_obj = new ManiphestTask();
	break;
	case 'D':
	$class_obj = new DifferentialRevision();
	break;
	case 'C':
	$class_obj = new PhabricatorRepositoryCommit();
	break;
	default:
	return null;
	}

	return $class_obj->load($receiver_id);
	}

	public static function computeMailHash($mail_key, $phid) {
	$global_mail_key = PhabricatorEnv::getEnvConfig('phabricator.mail-key');

	$hash = PhabricatorHash::digest($mail_key.$global_mail_key.$phid);
	return substr($hash, 0, 16);
	}

	public static function computeOldMailHash($mail_key, $phid) {

	// TODO: Remove this method entirely in a couple of months. We've moved from
	// plain sha1 to sha1+hmac to make the codebase more auditable for good uses
	// of hash functions, but still accept the old hashes on email replies to
	// avoid breaking things. Once we've been sending only hmac hashes for a
	// while, remove this and start rejecting old hashes. See T547.

	$global_mail_key = PhabricatorEnv::getEnvConfig('phabricator.mail-key');

	$hash = sha1($mail_key.$global_mail_key.$phid);
	return substr($hash, 0, 16);
	}

	/**
	* Strip an email address down to the actual user@domain.tld part if
	* necessary, since sometimes it will have formatting like
	* '"Abraham Lincoln" <alincoln@logcab.in>'.
	*/
	private function getRawEmailAddress($address) {
	$matches = null;
	$ok = preg_match('/<(.*)>/', $address, $matches);
	if ($ok) {
	$address = $matches[1];
	}
	return $address;
	}

	private function getRawEmailAddresses($addresses) {
	$raw_addresses = array();
	foreach (explode(',', $addresses) as $address) {
	$raw_addresses[] = $this->getRawEmailAddress($address);
	}
	return $raw_addresses;
	}

	private function lookupPublicUser() {
	$from = idx($this->headers, 'from');
	$from = $this->getRawEmailAddress($from);

	$user = PhabricatorUser::loadOneWithEmailAddress($from);

	// If Phabricator is configured to allow "Reply-To" authentication, try
	// the "Reply-To" address if we failed to match the "From" address.
	$config_key = 'metamta.insecure-auth-with-reply-to';
	$allow_reply_to = PhabricatorEnv::getEnvConfig($config_key);

	if (!$user && $allow_reply_to) {
	$reply_to = idx($this->headers, 'reply-to');
	$reply_to = $this->getRawEmailAddress($reply_to);
	if ($reply_to) {
	$user = PhabricatorUser::loadOneWithEmailAddress($reply_to);
	}
	}

	return $user;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 15:52 (2 w, 6 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1126195
Default Alt Text: (35 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions