/*eslint no-var:0, prefer-arrow-callback: 0, object-shorthand: 0 */
|
'use strict';
|
|
|
var Punycode = require('punycode');
|
|
|
var internals = {};
|
|
|
//
|
// Read rules from file.
|
//
|
internals.rules = require('./data/rules.json').map(function (rule) {
|
|
return {
|
rule: rule,
|
suffix: rule.replace(/^(\*\.|\!)/, ''),
|
punySuffix: -1,
|
wildcard: rule.charAt(0) === '*',
|
exception: rule.charAt(0) === '!'
|
};
|
});
|
|
|
//
|
// Check is given string ends with `suffix`.
|
//
|
internals.endsWith = function (str, suffix) {
|
|
return str.indexOf(suffix, str.length - suffix.length) !== -1;
|
};
|
|
|
//
|
// Find rule for a given domain.
|
//
|
internals.findRule = function (domain) {
|
|
var punyDomain = Punycode.toASCII(domain);
|
return internals.rules.reduce(function (memo, rule) {
|
|
if (rule.punySuffix === -1){
|
rule.punySuffix = Punycode.toASCII(rule.suffix);
|
}
|
if (!internals.endsWith(punyDomain, '.' + rule.punySuffix) && punyDomain !== rule.punySuffix) {
|
return memo;
|
}
|
// This has been commented out as it never seems to run. This is because
|
// sub tlds always appear after their parents and we never find a shorter
|
// match.
|
//if (memo) {
|
// var memoSuffix = Punycode.toASCII(memo.suffix);
|
// if (memoSuffix.length >= punySuffix.length) {
|
// return memo;
|
// }
|
//}
|
return rule;
|
}, null);
|
};
|
|
|
//
|
// Error codes and messages.
|
//
|
exports.errorCodes = {
|
DOMAIN_TOO_SHORT: 'Domain name too short.',
|
DOMAIN_TOO_LONG: 'Domain name too long. It should be no more than 255 chars.',
|
LABEL_STARTS_WITH_DASH: 'Domain name label can not start with a dash.',
|
LABEL_ENDS_WITH_DASH: 'Domain name label can not end with a dash.',
|
LABEL_TOO_LONG: 'Domain name label should be at most 63 chars long.',
|
LABEL_TOO_SHORT: 'Domain name label should be at least 1 character long.',
|
LABEL_INVALID_CHARS: 'Domain name label can only contain alphanumeric characters or dashes.'
|
};
|
|
|
//
|
// Validate domain name and throw if not valid.
|
//
|
// From wikipedia:
|
//
|
// Hostnames are composed of series of labels concatenated with dots, as are all
|
// domain names. Each label must be between 1 and 63 characters long, and the
|
// entire hostname (including the delimiting dots) has a maximum of 255 chars.
|
//
|
// Allowed chars:
|
//
|
// * `a-z`
|
// * `0-9`
|
// * `-` but not as a starting or ending character
|
// * `.` as a separator for the textual portions of a domain name
|
//
|
// * http://en.wikipedia.org/wiki/Domain_name
|
// * http://en.wikipedia.org/wiki/Hostname
|
//
|
internals.validate = function (input) {
|
|
// Before we can validate we need to take care of IDNs with unicode chars.
|
var ascii = Punycode.toASCII(input);
|
|
if (ascii.length < 1) {
|
return 'DOMAIN_TOO_SHORT';
|
}
|
if (ascii.length > 255) {
|
return 'DOMAIN_TOO_LONG';
|
}
|
|
// Check each part's length and allowed chars.
|
var labels = ascii.split('.');
|
var label;
|
|
for (var i = 0; i < labels.length; ++i) {
|
label = labels[i];
|
if (!label.length) {
|
return 'LABEL_TOO_SHORT';
|
}
|
if (label.length > 63) {
|
return 'LABEL_TOO_LONG';
|
}
|
if (label.charAt(0) === '-') {
|
return 'LABEL_STARTS_WITH_DASH';
|
}
|
if (label.charAt(label.length - 1) === '-') {
|
return 'LABEL_ENDS_WITH_DASH';
|
}
|
if (!/^[a-z0-9\-]+$/.test(label)) {
|
return 'LABEL_INVALID_CHARS';
|
}
|
}
|
};
|
|
|
//
|
// Public API
|
//
|
|
|
//
|
// Parse domain.
|
//
|
exports.parse = function (input) {
|
|
if (typeof input !== 'string') {
|
throw new TypeError('Domain name must be a string.');
|
}
|
|
// Force domain to lowercase.
|
var domain = input.slice(0).toLowerCase();
|
|
// Handle FQDN.
|
// TODO: Simply remove trailing dot?
|
if (domain.charAt(domain.length - 1) === '.') {
|
domain = domain.slice(0, domain.length - 1);
|
}
|
|
// Validate and sanitise input.
|
var error = internals.validate(domain);
|
if (error) {
|
return {
|
input: input,
|
error: {
|
message: exports.errorCodes[error],
|
code: error
|
}
|
};
|
}
|
|
var parsed = {
|
input: input,
|
tld: null,
|
sld: null,
|
domain: null,
|
subdomain: null,
|
listed: false
|
};
|
|
var domainParts = domain.split('.');
|
|
// Non-Internet TLD
|
if (domainParts[domainParts.length - 1] === 'local') {
|
return parsed;
|
}
|
|
var handlePunycode = function () {
|
|
if (!/xn--/.test(domain)) {
|
return parsed;
|
}
|
if (parsed.domain) {
|
parsed.domain = Punycode.toASCII(parsed.domain);
|
}
|
if (parsed.subdomain) {
|
parsed.subdomain = Punycode.toASCII(parsed.subdomain);
|
}
|
return parsed;
|
};
|
|
var rule = internals.findRule(domain);
|
|
// Unlisted tld.
|
if (!rule) {
|
if (domainParts.length < 2) {
|
return parsed;
|
}
|
parsed.tld = domainParts.pop();
|
parsed.sld = domainParts.pop();
|
parsed.domain = [parsed.sld, parsed.tld].join('.');
|
if (domainParts.length) {
|
parsed.subdomain = domainParts.pop();
|
}
|
return handlePunycode();
|
}
|
|
// At this point we know the public suffix is listed.
|
parsed.listed = true;
|
|
var tldParts = rule.suffix.split('.');
|
var privateParts = domainParts.slice(0, domainParts.length - tldParts.length);
|
|
if (rule.exception) {
|
privateParts.push(tldParts.shift());
|
}
|
|
parsed.tld = tldParts.join('.');
|
|
if (!privateParts.length) {
|
return handlePunycode();
|
}
|
|
if (rule.wildcard) {
|
tldParts.unshift(privateParts.pop());
|
parsed.tld = tldParts.join('.');
|
}
|
|
if (!privateParts.length) {
|
return handlePunycode();
|
}
|
|
parsed.sld = privateParts.pop();
|
parsed.domain = [parsed.sld, parsed.tld].join('.');
|
|
if (privateParts.length) {
|
parsed.subdomain = privateParts.join('.');
|
}
|
|
return handlePunycode();
|
};
|
|
|
//
|
// Get domain.
|
//
|
exports.get = function (domain) {
|
|
if (!domain) {
|
return null;
|
}
|
return exports.parse(domain).domain || null;
|
};
|
|
|
//
|
// Check whether domain belongs to a known public suffix.
|
//
|
exports.isValid = function (domain) {
|
|
var parsed = exports.parse(domain);
|
return Boolean(parsed.domain && parsed.listed);
|
};
|
