b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
867 lines
29 KiB
JavaScript
Executable file
867 lines
29 KiB
JavaScript
Executable file
/**
|
|
* Common code for creating and working with various account types.
|
|
**/
|
|
|
|
define(
|
|
[
|
|
'./a64',
|
|
'logic',
|
|
'./allback',
|
|
'require',
|
|
'module',
|
|
'exports'
|
|
],
|
|
function(
|
|
$a64,
|
|
logic,
|
|
allback,
|
|
require,
|
|
$module,
|
|
exports
|
|
) {
|
|
|
|
var latchedWithRejections = allback.latchedWithRejections;
|
|
|
|
// The number of milliseconds to wait for various (non-ActiveSync) XHRs to
|
|
// complete during the autoconfiguration process. This value is intentionally
|
|
// fairly large so that we don't abort an XHR just because the network is
|
|
// spotty.
|
|
var AUTOCONFIG_TIMEOUT_MS = 30 * 1000;
|
|
|
|
var ISPDB_AUTOCONFIG_ROOT =
|
|
'https://live.mozillamessaging.com/autoconfig/v1.1/';
|
|
|
|
function requireConfigurator(type, fn) {
|
|
if (type === 'activesync') {
|
|
require(['activesync/configurator'], fn);
|
|
} else if (type === 'pop3+smtp' || type === 'imap+smtp') {
|
|
require(['composite/configurator'], fn);
|
|
}
|
|
}
|
|
|
|
function accountTypeToClass(type, callback) {
|
|
requireConfigurator(type, function(mod) {
|
|
callback(mod.account.Account);
|
|
});
|
|
}
|
|
exports.accountTypeToClass = accountTypeToClass;
|
|
|
|
// Simple hard-coded autoconfiguration by domain...
|
|
var autoconfigByDomain = exports._autoconfigByDomain = {
|
|
'localhost': {
|
|
type: 'imap+smtp',
|
|
incoming: {
|
|
hostname: 'localhost',
|
|
port: 143,
|
|
socketType: 'plain',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
outgoing: {
|
|
hostname: 'localhost',
|
|
port: 25,
|
|
socketType: 'plain',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
},
|
|
'fakeimaphost': {
|
|
type: 'imap+smtp',
|
|
incoming: {
|
|
hostname: 'localhost',
|
|
port: 0,
|
|
socketType: 'plain',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
outgoing: {
|
|
hostname: 'localhost',
|
|
port: 0,
|
|
socketType: 'plain',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
},
|
|
'fakepop3host': {
|
|
type: 'pop3+smtp',
|
|
incoming: {
|
|
hostname: 'localhost',
|
|
port: 0,
|
|
socketType: 'plain',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
outgoing: {
|
|
hostname: 'localhost',
|
|
port: 0,
|
|
socketType: 'plain',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
},
|
|
'slocalhost': {
|
|
type: 'imap+smtp',
|
|
incoming: {
|
|
hostname: 'localhost',
|
|
port: 993,
|
|
socketType: 'SSL',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
outgoing: {
|
|
hostname: 'localhost',
|
|
port: 465,
|
|
socketType: 'SSL',
|
|
username: '%EMAILLOCALPART%',
|
|
},
|
|
},
|
|
'fakeashost': {
|
|
type: 'activesync',
|
|
displayName: 'Test',
|
|
incoming: {
|
|
// This string will be clobbered with the correct port number when running
|
|
// as a unit test.
|
|
server: 'http://localhost:8880',
|
|
username: '%EMAILADDRESS%',
|
|
},
|
|
},
|
|
// like slocalhost, really just exists to generate a test failure
|
|
'saslocalhost': {
|
|
type: 'activesync',
|
|
displayName: 'Test',
|
|
incoming: {
|
|
server: 'https://localhost:443',
|
|
username: '%EMAILADDRESS%',
|
|
},
|
|
},
|
|
// Mapping for a nonexistent domain for testing a bad domain without it being
|
|
// detected ahead of time by the autoconfiguration logic or otherwise.
|
|
'nonesuch.nonesuch': {
|
|
type: 'imap+smtp',
|
|
imapHost: 'nonesuch.nonesuch',
|
|
imapPort: 993,
|
|
imapCrypto: true,
|
|
smtpHost: 'nonesuch.nonesuch',
|
|
smtpPort: 465,
|
|
smtpCrypto: true,
|
|
usernameIsFullEmail: false,
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Recreate the array of identities for a given account.
|
|
*
|
|
* @param universe the MailUniverse
|
|
* @param accountId the ID for this account
|
|
* @param oldIdentities an array of the old identities
|
|
* @return the new identities
|
|
*/
|
|
function recreateIdentities(universe, accountId, oldIdentities) {
|
|
var identities = [];
|
|
for (var iter in Iterator(oldIdentities)) {
|
|
var oldIdentity = iter[1];
|
|
identities.push({
|
|
id: accountId + '/' + $a64.encodeInt(universe.config.nextIdentityNum++),
|
|
name: oldIdentity.name,
|
|
address: oldIdentity.address,
|
|
replyTo: oldIdentity.replyTo,
|
|
signature: oldIdentity.signature,
|
|
signatureEnabled: oldIdentity.signatureEnabled
|
|
});
|
|
}
|
|
return identities;
|
|
}
|
|
exports.recreateIdentities = recreateIdentities;
|
|
|
|
function fillConfigPlaceholders(userDetails, sourceConfigInfo) {
|
|
// Return a mutated copy, don't mutate the original.
|
|
var configInfo = JSON.parse(JSON.stringify(sourceConfigInfo));
|
|
|
|
var details = userDetails.emailAddress.split('@');
|
|
var emailLocalPart = details[0], emailDomainPart = details[1];
|
|
var domain = emailDomainPart.toLowerCase();
|
|
|
|
var placeholderFields = {
|
|
incoming: ['username', 'hostname', 'server'],
|
|
outgoing: ['username', 'hostname'],
|
|
};
|
|
|
|
function fillPlaceholder(value) {
|
|
return value.replace('%EMAILADDRESS%', userDetails.emailAddress)
|
|
.replace('%EMAILLOCALPART%', emailLocalPart)
|
|
.replace('%EMAILDOMAIN%', emailDomainPart)
|
|
.replace('%REALNAME%', userDetails.displayName);
|
|
}
|
|
|
|
for (var serverType in placeholderFields) {
|
|
var fields = placeholderFields[serverType];
|
|
var server = configInfo[serverType];
|
|
if (!server) {
|
|
continue;
|
|
}
|
|
|
|
for (var iField = 0; iField < fields.length; iField++) {
|
|
var field = fields[iField];
|
|
|
|
if (server.hasOwnProperty(field)) {
|
|
server[field] = fillPlaceholder(server[field]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return configInfo;
|
|
}
|
|
exports.fillConfigPlaceholders = fillConfigPlaceholders;
|
|
|
|
|
|
/**
|
|
* The Autoconfigurator tries to automatically determine account settings, in
|
|
* large part by taking advantage of Thunderbird's prior work on autoconfig:
|
|
* <https://developer.mozilla.org/en-US/docs/Thunderbird/Autoconfiguration>.
|
|
* There are some important differences, however, since we support ActiveSync
|
|
* whereas Thunderbird does not.
|
|
*
|
|
* The v2 process is as follows. All of this is done without a password (since
|
|
* it might turn out we don't need a password in the case of OAuth2-based auth.)
|
|
*
|
|
* 1) Get the domain from the user's email address
|
|
* 2) Check hardcoded-into-GELAM account settings for the domain (useful for
|
|
* unit tests)
|
|
* 3) Check locally stored XML config files in Gaia for the domain at
|
|
* `/autoconfig/<domain>`
|
|
* 4) In parallel:
|
|
* - Do server-hosted autoconfig checks at URLs, passing the user's email
|
|
* address in the query string (as `emailaddress`)
|
|
* - `https://autoconfig.<domain>/mail/config-v1.1.xml` and
|
|
* - `https://<domain>/.well-known/autoconfig/mail/config-v1.1.xml`,
|
|
* - Check the Mozilla ISPDB for the domain:
|
|
* - `https://live.mozillamessaging.com/autoconfig/v1.1/<domain>`
|
|
* - Having the Mozilla ISPDB do an MX lookup.
|
|
* 5) If we didn't reach a conclusion in step 4, check the MX lookup result.
|
|
* If it differed from the domain, then re-lookup the locally stored XML
|
|
* config and failing that, check the ISPDB for that domain.
|
|
* 6) If that didn't net us anything, look for evidence of ActiveSync
|
|
* AutoDiscover endpoints at the following locations in parallel:
|
|
* `https://<domain>/autodiscover/autodiscover.xml`
|
|
* `https://autodiscover.<domain>/autodiscover/autodiscover.xml`
|
|
*
|
|
* This differs from the v1 process in that:
|
|
* - v1 did everything in serial not parallel
|
|
* - v1 used http, not httpS, to look for self-hosted autoconfig servers.
|
|
* - v1 ran autodiscover before checking with the ISPDB but after local and
|
|
* server-hosted ISPDB autoconfig files.
|
|
* - v1 actually ran autodiscover. Now we just look for evidence of
|
|
* autodiscover. AutoDiscover requires being able to authenticate the user
|
|
* which implies having the password. Since we're not sure if we need a
|
|
* password or not, we can't do that yet. We leave AutoDiscover up to the
|
|
* ActiveSync configurator to perform.
|
|
* - v1 wanted the user's password
|
|
*
|
|
* These changes were informed by the following needs and observations:
|
|
* - http was a bad idea security-wise, but was done for consistency with
|
|
* Thunderbird. The Thunderbird rationale involved DNS also being insecure,
|
|
* so an attacker could already win with local network control. However,
|
|
* Thunderbird also allowed autoconfig to return settings that didn't
|
|
* use SSL/TLS, whereas we do not. (We ignore them).
|
|
*
|
|
* Thunderbird has recently come around to the use of https instead of http
|
|
* for this purpose. It's also worth noting that as far as we know, almost
|
|
* no one actually hosts their own autoconfig servers.
|
|
*
|
|
* - AutoDiscover can be very slow, especially if we're waiting for our requests
|
|
* to timeout.
|
|
*
|
|
* - It's become common to see servers that implement ActiveSync (which we
|
|
* strongly dislike) as well as IMAP (which we strongly prefer). By letting
|
|
* ActiveSync derail the decision-making process we rob ourselves of the
|
|
* ability to have the ISPDB indicate the IMAP is an option.
|
|
*
|
|
* - If the user's server supports OAuth2, there's no need to make them type in
|
|
* their password; it might even be confusing to them.
|
|
*
|
|
* Our ConfigInfo structures look like the following:
|
|
*
|
|
* {
|
|
* type: 'imap+smtp',
|
|
* incoming: {
|
|
* hostname: <imap hostname>,
|
|
* port: <imap port number>,
|
|
* socketType: <one of 'plain', 'SSL', 'STARTTLS'>,
|
|
* username: <imap username>,
|
|
* authentication: <one of 'password-cleartext', 'xoauth2'>
|
|
* },
|
|
* outgoing: {
|
|
* hostname: <smtp hostname>,
|
|
* port: <smtp port>,
|
|
* socketType: <one of 'plain', 'SSL', 'STARTTLS'>,
|
|
* username: <smtp username>,
|
|
* authentication: <one of 'password-cleartext', 'xoauth2'>
|
|
* },
|
|
* oauth2Settings: null or {
|
|
* secretGroup: <group identify which app secrets should be used>,
|
|
* authEndpoint: <auth url of the page to show to the user>,
|
|
* tokenEndpoint: <url for getting/refreshing tokens (no user ui)>,
|
|
* scope: <space-delimited scopes to request>
|
|
* }
|
|
* }
|
|
*
|
|
* POP3 is similar to IMAP/SMTP but it's 'pop3+smtp'. ActiveSync looks
|
|
* like:
|
|
*
|
|
* {
|
|
* type: 'activesync',
|
|
* displayName: <display name>, (optional)
|
|
* incoming: {
|
|
* server: 'https://<activesync hostname>'
|
|
* },
|
|
* }
|
|
*/
|
|
function Autoconfigurator() {
|
|
this.timeout = AUTOCONFIG_TIMEOUT_MS;
|
|
logic.defineScope(this, 'Autoconfigurator');
|
|
}
|
|
exports.Autoconfigurator = Autoconfigurator;
|
|
Autoconfigurator.prototype = {
|
|
/**
|
|
* The list of fatal error codes.
|
|
*
|
|
* What's fatal and why:
|
|
* - bad-user-or-pass: We found a server, it told us the credentials were
|
|
* bogus. There is no point going on.
|
|
* - not-authorized: We found a server, it told us the credentials are fine
|
|
* but the access rights are insufficient. There is no point going on.
|
|
*
|
|
* Non-fatal and why:
|
|
* - unknown: If something failed we should keep checking other info sources.
|
|
* - no-config-info: The specific source had no details; we should keep
|
|
* checking other sources.
|
|
*/
|
|
_fatalErrors: ['bad-user-or-pass', 'not-authorized'],
|
|
|
|
/**
|
|
* Check the supplied error and return true if it's really a "success" or if
|
|
* it's a fatal error we can't recover from.
|
|
*
|
|
* @param error the error code
|
|
* @return true if the error is a "success" or if it's a fatal error
|
|
*/
|
|
_isSuccessOrFatal: function(error) {
|
|
return !error || this._fatalErrors.indexOf(error) !== -1;
|
|
},
|
|
|
|
/**
|
|
* Get an XML config file from the supplied url. The format is defined at
|
|
* <https://wiki.mozilla.org/Thunderbird:Autoconfiguration:ConfigFileFormat>.
|
|
*
|
|
* @param url the URL to fetch the config file from
|
|
* @param callback a callback taking an error string (if any) and the config
|
|
* info, formatted as JSON
|
|
*/
|
|
_getXmlConfig: function getXmlConfig(url) {
|
|
return new Promise(function(resolve, reject) {
|
|
|
|
var scope = logic.subscope(this, { method: 'GET', url: url });
|
|
logic(scope, 'xhr:start');
|
|
var xhr = new XMLHttpRequest({mozSystem: true});
|
|
xhr.open('GET', url, true);
|
|
xhr.timeout = this.timeout;
|
|
|
|
xhr.onload = function() {
|
|
logic(scope, 'xhr:end', { status: xhr.status });
|
|
if (xhr.status < 200 || xhr.status >= 300) {
|
|
reject('status' + xhr.status);
|
|
return;
|
|
}
|
|
// XXX: For reasons which are currently unclear (possibly a platform
|
|
// issue), trying to use responseXML results in a SecurityError when
|
|
// running XPath queries. So let's just do an end-run around the
|
|
// "security".
|
|
self.postMessage({
|
|
uid: 0,
|
|
type: 'configparser',
|
|
cmd: 'accountcommon',
|
|
args: [xhr.responseText]
|
|
});
|
|
|
|
self.addEventListener('message', function onworkerresponse(evt) {
|
|
var data = evt.data;
|
|
if (data.type != 'configparser' || data.cmd != 'accountcommon') {
|
|
return;
|
|
}
|
|
self.removeEventListener(evt.type, onworkerresponse);
|
|
var args = data.args;
|
|
var config = args[0], status = args[1];
|
|
resolve(config);
|
|
});
|
|
};
|
|
|
|
// Caution: don't overwrite ".onerror" twice here. Just be careful
|
|
// to only assign that once until <http://bugzil.la/949722> is fixed.
|
|
|
|
xhr.ontimeout = function() {
|
|
logic(scope, 'xhr:end', { status: 'timeout' });
|
|
reject('timeout');
|
|
};
|
|
|
|
xhr.onerror = function() {
|
|
logic(scope, 'xhr:end', { status: 'error' });
|
|
reject('error');
|
|
};
|
|
|
|
// At least in the past, Gecko might synchronously throw when we call
|
|
// send for a locally-hosted file, so we're sticking with this until the
|
|
// end of time.
|
|
try {
|
|
xhr.send();
|
|
}
|
|
catch(e) {
|
|
logic(scope, 'xhr:end', { status: 'sync-error' });
|
|
reject('status404');
|
|
}
|
|
}.bind(this));
|
|
},
|
|
|
|
/**
|
|
* Attempt to get an XML config file locally.
|
|
*
|
|
* @param domain the domain part of the user's email address
|
|
* @param callback a callback taking an error string (if any) and the config
|
|
* info, formatted as JSON
|
|
*/
|
|
_getConfigFromLocalFile: function getConfigFromLocalFile(domain) {
|
|
return this._getXmlConfig('/autoconfig/' + encodeURIComponent(domain));
|
|
},
|
|
|
|
/**
|
|
* Check whether it looks like there's an AutoDiscover endpoint at the given
|
|
* URL. AutoDiscover wants us to be authenticated, so we treat a 401 status
|
|
* as success and anything else as failure.
|
|
*
|
|
* For maximum realism we perform a POST.
|
|
*/
|
|
_checkAutodiscoverUrl: function(url) {
|
|
return new Promise(function(resolve, reject) {
|
|
var scope = logic.subscope(this, { method: 'POST', url: url });
|
|
logic(scope, 'autodiscoverProbe:start');
|
|
var xhr = new XMLHttpRequest({mozSystem: true});
|
|
xhr.open('POST', url, true);
|
|
xhr.timeout = this.timeout;
|
|
|
|
var victory = function() {
|
|
resolve({
|
|
type: 'activesync',
|
|
incoming: {
|
|
autodiscoverEndpoint: url
|
|
}
|
|
});
|
|
}.bind(this);
|
|
|
|
xhr.onload = function() {
|
|
logic(scope, 'autodiscoverProbe:end', { status: xhr.status });
|
|
if (xhr.status === 401) {
|
|
victory();
|
|
return;
|
|
}
|
|
reject('status' + xhr.status);
|
|
};
|
|
|
|
xhr.ontimeout = function() {
|
|
logic(scope, 'autodiscoverProbe:end', { status: 'timeout' });
|
|
reject('timeout');
|
|
};
|
|
|
|
xhr.onerror = function() {
|
|
logic(scope, 'autodiscoverProbe:end', { status: 'error' });
|
|
reject('error');
|
|
};
|
|
|
|
try {
|
|
xhr.send(null);
|
|
}
|
|
catch(e) {
|
|
logic(scope, 'autodiscoverProbe:end', { status: 'sync-error' });
|
|
reject('status404');
|
|
}
|
|
}.bind(this));
|
|
},
|
|
|
|
/**
|
|
* Look for AutoDiscover endpoints for the given domain. If we find one, we
|
|
* return what amounts to pseudo-config information. We don't actually know
|
|
* enough information to do a full autodiscover at this point, so we need to
|
|
* return enough for our ActiveSync account's tryToCreateAccount method to
|
|
* handle things from there.
|
|
*/
|
|
_probeForAutodiscover: function(domain) {
|
|
var subdirUrl = 'https://' + domain + '/autodiscover/autodiscover.xml';
|
|
var domainUrl = 'https://autodiscover.' + domain +
|
|
'/autodiscover/autodiscover.xml';
|
|
return latchedWithRejections({
|
|
subdir: this._checkAutodiscoverUrl(subdirUrl),
|
|
domain: this._checkAutodiscoverUrl(domainUrl)
|
|
}).then(function(results) {
|
|
// Favor the subdirectory discovery point.
|
|
if (results.subdir.resolved && results.subdir.value) {
|
|
return results.subdir.value;
|
|
}
|
|
if (results.domain.resolved && results.domain.value) {
|
|
return results.domain.value;
|
|
}
|
|
// Yeah, no AutoDiscover possible.
|
|
return null;
|
|
}.bind(this));
|
|
},
|
|
|
|
/**
|
|
* Attempt to get an XML config file from the Mozilla ISPDB.
|
|
*
|
|
* @param domain the domain part of the user's email address
|
|
*/
|
|
_getConfigFromISPDB: function(domain) {
|
|
return this._getXmlConfig(ISPDB_AUTOCONFIG_ROOT +
|
|
encodeURIComponent(domain));
|
|
},
|
|
|
|
/**
|
|
* Look up the DNS MX record for a domain. This currently uses a web service
|
|
* instead of querying it directly.
|
|
*
|
|
* @param domain the domain part of the user's email address
|
|
*
|
|
* @return {Promise}
|
|
* If we locate a MX domain and that domain differs from our own domain, we
|
|
* will resolve the promise with that String. If there is no MX domain or
|
|
* it is the same as our existing domain, we will resolve with a null value.
|
|
* In the event of a problem contacting the ISPDB server, we will reject
|
|
* the promise.
|
|
*/
|
|
_getMX: function getMX(domain) {
|
|
return new Promise(function(resolve, reject) {
|
|
|
|
var scope = logic.subscope(this, { domain: domain });
|
|
logic(scope, 'mxLookup:begin');
|
|
var xhr = new XMLHttpRequest({mozSystem: true});
|
|
xhr.open('GET', 'https://live.mozillamessaging.com/dns/mx/' +
|
|
encodeURIComponent(domain), true);
|
|
xhr.timeout = this.timeout;
|
|
|
|
xhr.onload = function() {
|
|
var reportDomain = null;
|
|
if (xhr.status === 200) {
|
|
var normStr = xhr.responseText.split('\n')[0];
|
|
if (normStr) {
|
|
normStr = normStr.toLowerCase();
|
|
// XXX: We need to normalize the domain here to get the base domain,
|
|
// but that's complicated because people like putting dots in
|
|
// TLDs. For now, let's just pretend no one would do such a horrible
|
|
// thing.
|
|
var mxDomain = normStr.split('.').slice(-2).join('.');
|
|
if (mxDomain !== domain) {
|
|
reportDomain = mxDomain;
|
|
}
|
|
}
|
|
}
|
|
logic(scope, 'mxLookup:end',
|
|
{ 'raw': normStr, normalized: mxDomain, reporting: reportDomain });
|
|
resolve(reportDomain);
|
|
};
|
|
|
|
xhr.ontimeout = function() {
|
|
logic(scope, 'mxLookup:end', { status: 'timeout' });
|
|
reject('timeout');
|
|
};
|
|
xhr.onerror = function() {
|
|
logic(scope, 'mxLookup:end', { status: 'error' });
|
|
reject('error');
|
|
};
|
|
|
|
xhr.send();
|
|
}.bind(this));
|
|
},
|
|
|
|
_getHostedAndISPDBConfigs: function(domain, emailAddress) {
|
|
var commonAutoconfigSuffix = '/mail/config-v1.1.xml?emailaddress=' +
|
|
encodeURIComponent(emailAddress);
|
|
// subdomain autoconfig URL
|
|
var subdomainAutoconfigUrl =
|
|
'https://autoconfig.' + domain + commonAutoconfigSuffix;
|
|
// .well-known autoconfig URL
|
|
var wellKnownAutoconfigUrl =
|
|
'https://' + domain + '/.well-known/autoconfig' +
|
|
commonAutoconfigSuffix;
|
|
|
|
return latchedWithRejections({
|
|
autoconfigSubdomain: this._getXmlConfig(subdomainAutoconfigUrl),
|
|
autoconfigWellKnown: this._getXmlConfig(wellKnownAutoconfigUrl),
|
|
ispdb: this._getConfigFromISPDB(domain),
|
|
mxDomain: this._getMX(domain)
|
|
}).then(function(results) {
|
|
// Favor the autoconfig subdomain for historical reasons
|
|
if (results.autoconfigSubdomain.resolved &&
|
|
results.autoconfigSubdomain.value) {
|
|
return { type: 'config', source: 'autoconfig-subdomain',
|
|
config: results.autoconfigSubdomain.value };
|
|
}
|
|
// Then the well-known
|
|
if (results.autoconfigWellKnown.resolved &&
|
|
results.autoconfigWellKnown.value) {
|
|
return { type: 'config', source: 'autoconfig-wellknown',
|
|
config: results.autoconfigWellKnown.value };
|
|
}
|
|
// Then the ISPDB
|
|
if (results.ispdb.resolved &&
|
|
results.ispdb.value) {
|
|
return { type: 'config', source: 'ispdb',
|
|
config: results.ispdb.value };
|
|
}
|
|
if (results.mxDomain.resolved &&
|
|
results.mxDomain.value &&
|
|
results.mxDomain.value !== domain) {
|
|
return { type: 'mx', domain: results.mxDomain.value };
|
|
}
|
|
return { type: null };
|
|
}.bind(this));
|
|
|
|
},
|
|
|
|
/**
|
|
* Attempt to get an XML config file by checking the DNS MX record and
|
|
* querying the Mozilla ISPDB.
|
|
*
|
|
* @param domain the domain part of the user's email address
|
|
* @param callback a callback taking an error string (if any) and the config
|
|
* info, formatted as JSON
|
|
*/
|
|
_getConfigFromMX: function getConfigFromMX(domain, callback) {
|
|
var self = this;
|
|
this._getMX(domain, function(error, mxDomain, errorDetails) {
|
|
if (error)
|
|
return callback(error, null, errorDetails);
|
|
|
|
console.log(' Found MX for', mxDomain);
|
|
|
|
if (domain === mxDomain)
|
|
return callback('no-config-info', null, { status: 'mxsame' });
|
|
|
|
// If we found a different domain after MX lookup, we should look in our
|
|
// local file store (mostly to support Google Apps domains) and, if that
|
|
// doesn't work, the Mozilla ISPDB.
|
|
console.log(' Looking in local file store');
|
|
self._getConfigFromLocalFile(mxDomain, function(error, config,
|
|
errorDetails) {
|
|
// (Local XML lookup should not have any fatal errors)
|
|
if (!error) {
|
|
callback(error, config, errorDetails);
|
|
return;
|
|
}
|
|
|
|
console.log(' Looking in the Mozilla ISPDB');
|
|
self._getConfigFromDB(mxDomain, callback);
|
|
});
|
|
});
|
|
},
|
|
|
|
_checkGelamConfig: function(domain) {
|
|
if (autoconfigByDomain.hasOwnProperty(domain)) {
|
|
return autoconfigByDomain[domain];
|
|
}
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* See the MailAPI.learnAboutAccount documentation for usage information.
|
|
*
|
|
* Internals:
|
|
*
|
|
*
|
|
*
|
|
* @return {Promise}
|
|
*/
|
|
learnAboutAccount: function(details) {
|
|
return new Promise(function(resolve, reject) {
|
|
var emailAddress = details.emailAddress;
|
|
var emailParts = emailAddress.split('@');
|
|
var emailLocalPart = emailParts[0], emailDomainPart = emailParts[1];
|
|
var domain = emailDomainPart.toLowerCase();
|
|
var scope = logic.subscope(this, { domain: domain });
|
|
logic(scope, 'autoconfig:begin');
|
|
|
|
// Call this when we find a usable config setting to perform appropriate
|
|
// normalization, logging, and promise resolution.
|
|
var victory = function(sourceConfigInfo, source) {
|
|
var configInfo = null, result;
|
|
if (sourceConfigInfo) {
|
|
configInfo = fillConfigPlaceholders(details, sourceConfigInfo);
|
|
if (configInfo.incoming &&
|
|
configInfo.incoming.authentication === 'xoauth2') {
|
|
result = 'need-oauth2';
|
|
} else {
|
|
result = 'need-password';
|
|
}
|
|
} else {
|
|
result = 'no-config-info';
|
|
}
|
|
logic(scope, 'autoconfig:end', {
|
|
result: result,
|
|
source: source,
|
|
configInfo: configInfo
|
|
});
|
|
resolve({ result: result, source: source, configInfo: configInfo });
|
|
}.bind(this);
|
|
// Call this if we can't find a configuration.
|
|
var failsafeFailure = function(err) {
|
|
logic(this, 'autoconfig:end', { err: {
|
|
message: err && err.message,
|
|
stack: err && err.stack
|
|
}});
|
|
resolve({ result: 'no-config-info', configInfo: null });
|
|
}.bind(this);
|
|
|
|
// Helper that turns a rejection into a null and outputs a log entry.
|
|
var coerceRejectionToNull = function(err) {
|
|
logic(scope, 'autoconfig:coerceRejection', { err: err });
|
|
return null;
|
|
}.bind(this);
|
|
|
|
// -- Synchronous logic
|
|
// - Group 0: hardcoded in GELAM (testing only)
|
|
var hardcodedConfig = this._checkGelamConfig(domain);
|
|
if (hardcodedConfig) {
|
|
victory(hardcodedConfig, 'hardcoded');
|
|
return;
|
|
}
|
|
|
|
// -- Asynchronous setup
|
|
// This all wants to be a generator. It doesn't make a lot of sense to
|
|
// structure this as a chain of then's since we do want an early return.
|
|
// This is a good candidate for 'koa' or something like it in the near
|
|
// future.
|
|
|
|
// - Group 1: local config
|
|
var localConfigHandler = function(info) {
|
|
if (info) {
|
|
victory(info, 'local');
|
|
return null;
|
|
}
|
|
|
|
// We don't need to coerce because there will be no rejections.
|
|
return this._getHostedAndISPDBConfigs(domain, emailAddress)
|
|
.then(selfHostedAndISPDBHandler);
|
|
}.bind(this);
|
|
|
|
// - Group 2: self-hosted autoconfig, ISPDB first checks
|
|
var mxDomain;
|
|
var selfHostedAndISPDBHandler = function(typedResult) {
|
|
if (typedResult.type === 'config') {
|
|
victory(typedResult.config, typedResult.source);
|
|
return null;
|
|
}
|
|
// Did we get a different MX result?
|
|
if (typedResult.type === 'mx') {
|
|
mxDomain = typedResult.domain;
|
|
return this._getConfigFromLocalFile(mxDomain)
|
|
.catch(coerceRejectionToNull)
|
|
.then(mxLocalHandler);
|
|
}
|
|
// No MX result, probe autodiscover.
|
|
return this._probeForAutodiscover(domain)
|
|
.then(autodiscoverHandler);
|
|
}.bind(this);
|
|
|
|
// - Group 3: MX-derived lookups
|
|
var mxLocalHandler = function(info) {
|
|
if (info) {
|
|
victory(info, 'mx local');
|
|
return null;
|
|
}
|
|
// We didn't know about it locally, ask the ISPDB
|
|
return this._getConfigFromISPDB(mxDomain)
|
|
.catch(coerceRejectionToNull)
|
|
.then(mxISPDBHandler);
|
|
}.bind(this);
|
|
|
|
var mxISPDBHandler = function(info) {
|
|
if (info) {
|
|
victory(info, 'mx ispdb');
|
|
return null;
|
|
}
|
|
// The ISPDB didn't know, probe for autodiscovery. No coercion needed.
|
|
return this._probeForAutodiscover(domain)
|
|
.then(autodiscoverHandler);
|
|
}.bind(this);
|
|
|
|
// - Group 4: Autodiscover probing
|
|
var autodiscoverHandler = function(info) {
|
|
// This is either success or we're simply done.
|
|
victory(info, info ? 'autodiscover' : null);
|
|
return null;
|
|
}.bind(this);
|
|
|
|
// -- Kick it off.
|
|
this._getConfigFromLocalFile(domain)
|
|
// Coerce the rejection for our then handler's purpose.
|
|
.catch(coerceRejectionToNull)
|
|
.then(localConfigHandler)
|
|
// Register a catch-handler against localConfigHandler and all of the
|
|
// follow-on handlers we associate. Technically we should never call
|
|
// this, but better safe than sorry.
|
|
.catch(failsafeFailure);
|
|
}.bind(this));
|
|
},
|
|
|
|
/**
|
|
* Try to create an account for the user's email address by running through
|
|
* autoconfigure and, if successful, delegating to the appropriate account
|
|
* type.
|
|
*
|
|
* @param universe the MailUniverse object
|
|
* @param userDetails an object containing `emailAddress` and `password`
|
|
* attributes
|
|
* @param callback a callback taking an error string (if any) and the config
|
|
* info, formatted as JSON
|
|
*/
|
|
tryToCreateAccount: function(universe, userDetails, callback) {
|
|
this.learnAboutAccount(userDetails).then(
|
|
function success(results) {
|
|
// If we found a config and we just need a password, then we're good
|
|
// to go.
|
|
if (results.result === 'need-password') {
|
|
var config = results.configInfo;
|
|
requireConfigurator(config.type, function (mod) {
|
|
mod.configurator.tryToCreateAccount(universe, userDetails, config,
|
|
callback);
|
|
});
|
|
return;
|
|
}
|
|
|
|
logic(this, 'legacyCreateFail', { result: results.result });
|
|
// need-oauth2 is not supported via this code-path; coerce to a config
|
|
// failure...
|
|
callback('no-config-info');
|
|
}.bind(this),
|
|
function failure(err) {
|
|
callback(err, null, null);
|
|
}.bind(this));
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Recreate an existing account, e.g. after a database upgrade.
|
|
*
|
|
* @param universe the MailUniverse
|
|
* @param oldVersion the old database version, to help with migration
|
|
* @param accountInfo the old account info
|
|
* @param callback a callback to fire when we've completed recreating the
|
|
* account
|
|
*/
|
|
function recreateAccount(universe, oldVersion, accountInfo, callback) {
|
|
requireConfigurator(accountInfo.def.type, function (mod) {
|
|
mod.configurator.recreateAccount(universe, oldVersion,
|
|
accountInfo, callback);
|
|
});
|
|
}
|
|
exports.recreateAccount = recreateAccount;
|
|
|
|
function tryToManuallyCreateAccount(universe, userDetails, domainInfo,
|
|
callback) {
|
|
requireConfigurator(domainInfo.type, function (mod) {
|
|
mod.configurator.tryToCreateAccount(universe, userDetails, domainInfo,
|
|
callback);
|
|
});
|
|
}
|
|
exports.tryToManuallyCreateAccount = tryToManuallyCreateAccount;
|
|
|
|
}); // end define
|