| 1 | /*eslint no-var:0, prefer-arrow-callback: 0, object-shorthand: 0 */ |
| 2 | 'use strict'; |
| 3 | |
| 4 | |
| 5 | var Punycode = require('punycode'); |
| 6 | |
| 7 | |
| 8 | var internals = {}; |
| 9 | |
| 10 | |
| 11 | // |
| 12 | // Read rules from file. |
| 13 | // |
| 14 | internals.rules = require('./data/rules.json').map(function (rule) { |
| 15 | |
| 16 | return { |
| 17 | rule: rule, |
| 18 | suffix: rule.replace(/^(\*\.|\!)/, ''), |
| 19 | punySuffix: -1, |
| 20 | wildcard: rule.charAt(0) === '*', |
| 21 | exception: rule.charAt(0) === '!' |
| 22 | }; |
| 23 | }); |
| 24 | |
| 25 | |
| 26 | // |
| 27 | // Check is given string ends with `suffix`. |
| 28 | // |
| 29 | internals.endsWith = function (str, suffix) { |
| 30 | |
| 31 | return str.indexOf(suffix, str.length - suffix.length) !== -1; |
| 32 | }; |
| 33 | |
| 34 | |
| 35 | // |
| 36 | // Find rule for a given domain. |
| 37 | // |
| 38 | internals.findRule = function (domain) { |
| 39 | |
| 40 | var punyDomain = Punycode.toASCII(domain); |
| 41 | return internals.rules.reduce(function (memo, rule) { |
| 42 | |
| 43 | if (rule.punySuffix === -1){ |
| 44 | rule.punySuffix = Punycode.toASCII(rule.suffix); |
| 45 | } |
| 46 | if (!internals.endsWith(punyDomain, '.' + rule.punySuffix) && punyDomain !== rule.punySuffix) { |
| 47 | return memo; |
| 48 | } |
| 49 | // This has been commented out as it never seems to run. This is because |
| 50 | // sub tlds always appear after their parents and we never find a shorter |
| 51 | // match. |
| 52 | //if (memo) { |
| 53 | // var memoSuffix = Punycode.toASCII(memo.suffix); |
| 54 | // if (memoSuffix.length >= punySuffix.length) { |
| 55 | // return memo; |
| 56 | // } |
| 57 | //} |
| 58 | return rule; |
| 59 | }, null); |
| 60 | }; |
| 61 | |
| 62 | |
| 63 | // |
| 64 | // Error codes and messages. |
| 65 | // |
| 66 | exports.errorCodes = { |
| 67 | DOMAIN_TOO_SHORT: 'Domain name too short.', |
| 68 | DOMAIN_TOO_LONG: 'Domain name too long. It should be no more than 255 chars.', |
| 69 | LABEL_STARTS_WITH_DASH: 'Domain name label can not start with a dash.', |
| 70 | LABEL_ENDS_WITH_DASH: 'Domain name label can not end with a dash.', |
| 71 | LABEL_TOO_LONG: 'Domain name label should be at most 63 chars long.', |
| 72 | LABEL_TOO_SHORT: 'Domain name label should be at least 1 character long.', |
| 73 | LABEL_INVALID_CHARS: 'Domain name label can only contain alphanumeric characters or dashes.' |
| 74 | }; |
| 75 | |
| 76 | |
| 77 | // |
| 78 | // Validate domain name and throw if not valid. |
| 79 | // |
| 80 | // From wikipedia: |
| 81 | // |
| 82 | // Hostnames are composed of series of labels concatenated with dots, as are all |
| 83 | // domain names. Each label must be between 1 and 63 characters long, and the |
| 84 | // entire hostname (including the delimiting dots) has a maximum of 255 chars. |
| 85 | // |
| 86 | // Allowed chars: |
| 87 | // |
| 88 | // * `a-z` |
| 89 | // * `0-9` |
| 90 | // * `-` but not as a starting or ending character |
| 91 | // * `.` as a separator for the textual portions of a domain name |
| 92 | // |
| 93 | // * http://en.wikipedia.org/wiki/Domain_name |
| 94 | // * http://en.wikipedia.org/wiki/Hostname |
| 95 | // |
| 96 | internals.validate = function (input) { |
| 97 | |
| 98 | // Before we can validate we need to take care of IDNs with unicode chars. |
| 99 | var ascii = Punycode.toASCII(input); |
| 100 | |
| 101 | if (ascii.length < 1) { |
| 102 | return 'DOMAIN_TOO_SHORT'; |
| 103 | } |
| 104 | if (ascii.length > 255) { |
| 105 | return 'DOMAIN_TOO_LONG'; |
| 106 | } |
| 107 | |
| 108 | // Check each part's length and allowed chars. |
| 109 | var labels = ascii.split('.'); |
| 110 | var label; |
| 111 | |
| 112 | for (var i = 0; i < labels.length; ++i) { |
| 113 | label = labels[i]; |
| 114 | if (!label.length) { |
| 115 | return 'LABEL_TOO_SHORT'; |
| 116 | } |
| 117 | if (label.length > 63) { |
| 118 | return 'LABEL_TOO_LONG'; |
| 119 | } |
| 120 | if (label.charAt(0) === '-') { |
| 121 | return 'LABEL_STARTS_WITH_DASH'; |
| 122 | } |
| 123 | if (label.charAt(label.length - 1) === '-') { |
| 124 | return 'LABEL_ENDS_WITH_DASH'; |
| 125 | } |
| 126 | if (!/^[a-z0-9\-]+$/.test(label)) { |
| 127 | return 'LABEL_INVALID_CHARS'; |
| 128 | } |
| 129 | } |
| 130 | }; |
| 131 | |
| 132 | |
| 133 | // |
| 134 | // Public API |
| 135 | // |
| 136 | |
| 137 | |
| 138 | // |
| 139 | // Parse domain. |
| 140 | // |
| 141 | exports.parse = function (input) { |
| 142 | |
| 143 | if (typeof input !== 'string') { |
| 144 | throw new TypeError('Domain name must be a string.'); |
| 145 | } |
| 146 | |
| 147 | // Force domain to lowercase. |
| 148 | var domain = input.slice(0).toLowerCase(); |
| 149 | |
| 150 | // Handle FQDN. |
| 151 | // TODO: Simply remove trailing dot? |
| 152 | if (domain.charAt(domain.length - 1) === '.') { |
| 153 | domain = domain.slice(0, domain.length - 1); |
| 154 | } |
| 155 | |
| 156 | // Validate and sanitise input. |
| 157 | var error = internals.validate(domain); |
| 158 | if (error) { |
| 159 | return { |
| 160 | input: input, |
| 161 | error: { |
| 162 | message: exports.errorCodes[error], |
| 163 | code: error |
| 164 | } |
| 165 | }; |
| 166 | } |
| 167 | |
| 168 | var parsed = { |
| 169 | input: input, |
| 170 | tld: null, |
| 171 | sld: null, |
| 172 | domain: null, |
| 173 | subdomain: null, |
| 174 | listed: false |
| 175 | }; |
| 176 | |
| 177 | var domainParts = domain.split('.'); |
| 178 | |
| 179 | // Non-Internet TLD |
| 180 | if (domainParts[domainParts.length - 1] === 'local') { |
| 181 | return parsed; |
| 182 | } |
| 183 | |
| 184 | var handlePunycode = function () { |
| 185 | |
| 186 | if (!/xn--/.test(domain)) { |
| 187 | return parsed; |
| 188 | } |
| 189 | if (parsed.domain) { |
| 190 | parsed.domain = Punycode.toASCII(parsed.domain); |
| 191 | } |
| 192 | if (parsed.subdomain) { |
| 193 | parsed.subdomain = Punycode.toASCII(parsed.subdomain); |
| 194 | } |
| 195 | return parsed; |
| 196 | }; |
| 197 | |
| 198 | var rule = internals.findRule(domain); |
| 199 | |
| 200 | // Unlisted tld. |
| 201 | if (!rule) { |
| 202 | if (domainParts.length < 2) { |
| 203 | return parsed; |
| 204 | } |
| 205 | parsed.tld = domainParts.pop(); |
| 206 | parsed.sld = domainParts.pop(); |
| 207 | parsed.domain = [parsed.sld, parsed.tld].join('.'); |
| 208 | if (domainParts.length) { |
| 209 | parsed.subdomain = domainParts.pop(); |
| 210 | } |
| 211 | return handlePunycode(); |
| 212 | } |
| 213 | |
| 214 | // At this point we know the public suffix is listed. |
| 215 | parsed.listed = true; |
| 216 | |
| 217 | var tldParts = rule.suffix.split('.'); |
| 218 | var privateParts = domainParts.slice(0, domainParts.length - tldParts.length); |
| 219 | |
| 220 | if (rule.exception) { |
| 221 | privateParts.push(tldParts.shift()); |
| 222 | } |
| 223 | |
| 224 | parsed.tld = tldParts.join('.'); |
| 225 | |
| 226 | if (!privateParts.length) { |
| 227 | return handlePunycode(); |
| 228 | } |
| 229 | |
| 230 | if (rule.wildcard) { |
| 231 | tldParts.unshift(privateParts.pop()); |
| 232 | parsed.tld = tldParts.join('.'); |
| 233 | } |
| 234 | |
| 235 | if (!privateParts.length) { |
| 236 | return handlePunycode(); |
| 237 | } |
| 238 | |
| 239 | parsed.sld = privateParts.pop(); |
| 240 | parsed.domain = [parsed.sld, parsed.tld].join('.'); |
| 241 | |
| 242 | if (privateParts.length) { |
| 243 | parsed.subdomain = privateParts.join('.'); |
| 244 | } |
| 245 | |
| 246 | return handlePunycode(); |
| 247 | }; |
| 248 | |
| 249 | |
| 250 | // |
| 251 | // Get domain. |
| 252 | // |
| 253 | exports.get = function (domain) { |
| 254 | |
| 255 | if (!domain) { |
| 256 | return null; |
| 257 | } |
| 258 | return exports.parse(domain).domain || null; |
| 259 | }; |
| 260 | |
| 261 | |
| 262 | // |
| 263 | // Check whether domain belongs to a known public suffix. |
| 264 | // |
| 265 | exports.isValid = function (domain) { |
| 266 | |
| 267 | var parsed = exports.parse(domain); |
| 268 | return Boolean(parsed.domain && parsed.listed); |
| 269 | }; |