alinex-validator/dist/type/IP.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _es6Promisify = require('es6-promisify');

var _es6Promisify2 = _interopRequireDefault(_es6Promisify);

var _Any = require('./Any');

var _Any2 = _interopRequireDefault(_Any);

var _Error = require('../Error');

var _Error2 = _interopRequireDefault(_Error);

var _Reference = require('../Reference');

var _Reference2 = _interopRequireDefault(_Reference);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const specialRanges = {
  unspecified: ['0.0.0.0/8', '0::/128'],
  broadcast: ['255.255.255.255/32'],
  multicast: ['224.0.0.0/4', 'ff00::/8'],
  linklocal: ['169.254.0.0/16', 'fe80::/10'],
  loopback: ['127.0.0.0/8', '::1/128'],
  private: ['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16'],

  reserved: ['192.0.0.0/24', '192.88.99.0/24', '198.51.100.0/24', '203.0.113.0/24', '240.0.0.0/4', '2001:db8::/32'],
  uniquelocal: ['fc00::/7'],
  ipv4mapped: ['::ffff:0:0/96'],
  rfc6145: ['::ffff:0:0:0/96'],
  rfc6052: ['64:ff9b::/96'],
  '6to4': ['2002::/16'],
  teredo: ['2001::/32'],
  special: [] };
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;

try {
  for (var _iterator = Object.keys(specialRanges)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
    const key = _step.value;

    if (key !== 'special') specialRanges.special.push(specialRanges[key]);
  }
} catch (err) {
  _didIteratorError = true;
  _iteratorError = err;
} finally {
  try {
    if (!_iteratorNormalCompletion && _iterator.return) {
      _iterator.return();
    }
  } finally {
    if (_didIteratorError) {
      throw _iteratorError;
    }
  }
}

class IPSchema extends _Any2.default {
  constructor(base) {
    super(base);
    this._setting.format = 'short';

    let raw = this._rules.descriptor.pop();
    let allow = this._rules.descriptor.pop();
    this._rules.descriptor.push(this._typeDescriptor, allow, this._versionDescriptor, this._formatDescriptor, raw);
    raw = this._rules.validator.pop();
    allow = this._rules.validator.pop();
    this._rules.validator.push(this._typeValidator, allow, this._versionValidator, this._formatValidator, raw);
  }

  lookup(flag) {
    return this._setFlag('lookup', flag);
  }

  _typeDescriptor() {
    return 'An IP address as string or byte array is needed here.\n';
  }

  _typeValidator(data) {
    const check = this._check;

    return Promise.resolve().then(() => require('ipaddr.js')).then(ipaddr => {
      if (Array.isArray(data.value) && (data.value.length === 4 || data.value.length === 16)) {
        const ip = ipaddr.fromByteArray(data.value);
        data.value = ip;
        return Promise.resolve();
      }
      if (typeof data.value === 'string') {
        let ip = null;
        try {
          ip = ipaddr.parse(data.value);
        } catch (err) {
          if (check.lookup) {
            return Promise.resolve().then(() => require('dns')).then(dns => (0, _es6Promisify2.default)(dns.lookup)(data.value, { family: check.version }).then(resolved => {
              data.value = ipaddr.parse(resolved);
              return true;
            }));
          }
        }
        if (!ip) return Promise.reject(new Error('The given value could not be parsed as any valid IP address'));
        data.value = ip;
        return Promise.resolve();
      }
      return Promise.reject(new _Error2.default(this, data, `An ${typeof data.value} could not be transformed to an IP address`));
    });
  }

  _allowValidator(data) {
    const check = this._check;
    this._checkArray('allow');
    this._checkArray('deny');

    const deny = [];
    if (check.deny) {
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = check.deny[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          const e = _step2.value;

          if (specialRanges[e]) {
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
              for (var _iterator3 = specialRanges[e][Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                const n = _step3.value;
                deny.push(`${n}#`);
              }
            } catch (err) {
              _didIteratorError3 = true;
              _iteratorError3 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion3 && _iterator3.return) {
                  _iterator3.return();
                }
              } finally {
                if (_didIteratorError3) {
                  throw _iteratorError3;
                }
              }
            }
          } else deny.push(e);
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
    const allow = [];
    if (check.allow) {
      var _iteratorNormalCompletion4 = true;
      var _didIteratorError4 = false;
      var _iteratorError4 = undefined;

      try {
        for (var _iterator4 = check.allow[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
          const e = _step4.value;

          if (specialRanges[e]) {
            var _iteratorNormalCompletion5 = true;
            var _didIteratorError5 = false;
            var _iteratorError5 = undefined;

            try {
              for (var _iterator5 = specialRanges[e][Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                const n = _step5.value;
                allow.push(`${n}#`);
              }
            } catch (err) {
              _didIteratorError5 = true;
              _iteratorError5 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion5 && _iterator5.return) {
                  _iterator5.return();
                }
              } finally {
                if (_didIteratorError5) {
                  throw _iteratorError5;
                }
              }
            }
          } else allow.push(e);
        }
      } catch (err) {
        _didIteratorError4 = true;
        _iteratorError4 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion4 && _iterator4.return) {
            _iterator4.return();
          }
        } finally {
          if (_didIteratorError4) {
            throw _iteratorError4;
          }
        }
      }
    }
    if (allow && deny && allow.length && deny.length) {
      check.deny = check.deny.filter(e => !check.allow.includes(e));
    }

    return Promise.resolve().then(() => require('ipaddr.js')).then(ipaddr => {
      let denyBits = 0;
      if (deny.length) {
        var _iteratorNormalCompletion6 = true;
        var _didIteratorError6 = false;
        var _iteratorError6 = undefined;

        try {
          for (var _iterator6 = deny[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
            const e = _step6.value;

            const n = e.replace(/#$/, '');
            let range;
            if (n.match(/\//)) range = ipaddr.parseCIDR(n);else {
              const ip = ipaddr.parse(n);
              range = ip.kind === 4 ? [ip, 32] : [ip, 128];
            }
            if (data.value.match(range)) {
              let bits = n.length < e.length ? 1 : range[1];
              if (Number.isNaN(bits)) bits = 0;
              if (bits > denyBits) denyBits = bits;
            }
          }
        } catch (err) {
          _didIteratorError6 = true;
          _iteratorError6 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion6 && _iterator6.return) {
              _iterator6.return();
            }
          } finally {
            if (_didIteratorError6) {
              throw _iteratorError6;
            }
          }
        }
      }
      let allowBits = 0;
      if (allow.length) {
        allowBits = -1;
        var _iteratorNormalCompletion7 = true;
        var _didIteratorError7 = false;
        var _iteratorError7 = undefined;

        try {
          for (var _iterator7 = allow[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
            const e = _step7.value;

            const n = e.replace(/#$/, '');
            let range;
            if (n.match(/\//)) range = ipaddr.parseCIDR(n);else {
              const ip = ipaddr.parse(n);
              range = ip.kind === 4 ? [ip, 32] : [ip, 128];
            }
            if (data.value.match(range)) {
              let bits = n.length < e.length ? 1 : range[1];
              if (Number.isNaN(bits)) bits = 0;
              if (bits > allowBits) allowBits = bits;
            }
          }
        } catch (err) {
          _didIteratorError7 = true;
          _iteratorError7 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion7 && _iterator7.return) {
              _iterator7.return();
            }
          } finally {
            if (_didIteratorError7) {
              throw _iteratorError7;
            }
          }
        }
      }

      if (denyBits > allowBits) {
        return Promise.reject(new _Error2.default(this, data, 'Element found in blacklist (denied item).'));
      }
      return Promise.resolve();
    });
  }

  version(value) {
    return this._setAny('version', value);
  }
  mapping(flag) {
    return this._setFlag('mapping', flag);
  }

  _versionDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.version) {
      if (this._isReference('version')) {
        msg += `Valid addresses has to be of IP version defined at ${set.version.description}. `;
      } else msg += `Only IPv${set.version} addresses are valid. `;
    }
    if (set.mapping) {
      if (this._isReference('mapping')) {
        msg += `IPv4 adresses may be automatically converted if set under ${set.mapping.description}. `;
      } else msg += 'IPv4 addresses may be automatically converted. ';
    }
    return msg.length ? `${msg.trim()}\n` : msg;
  }

  _versionValidator(data) {
    const check = this._check;
    try {
      this._checkNumber('version');
      this._checkBoolean('mapping');
      if (check.version && ![4, 6].includes(check.version)) {
        throw new Error(`Only IP version 4 or 6 are valid, ${check.version} is unknown`);
      }
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (check.version) {
      if (check.version === 4) {
        if (data.value.kind() === 'ipv6') {
          if (check.mapping && data.value.isIPv4MappedAddress()) data.value = data.value.toIPv4Address();else {
            return Promise.reject(new _Error2.default(this, data, `The given value is no valid IPv${check.version} address`));
          }
        }
      } else if (data.value.kind() === 'ipv4') {
        if (check.mapping) data.value = data.value.toIPv4MappedAddress();else {
          return Promise.reject(new _Error2.default(this, data, `The given value is no valid IPv${check.version} address`));
        }
      }
    }
    return Promise.resolve();
  }

  format(value = 'short') {
    return this._setAny('format', value);
  }

  _formatDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.format) {
      if (this._isReference('format')) {
        msg += `The ip address will be formatted like defined under ${set.format.description}. `;
      } else msg += `The ip address will be formatted in ${set.format} form. `;
    }
    return msg.length ? `${msg.trim()}\n` : msg;
  }

  _formatValidator(data) {
    const check = this._check;
    try {
      this._checkString('format');
      if (!['short', 'long', 'array'].includes(check.format)) {
        throw new Error(`One of 'short', 'long' or 'array' is needed for format but ${check.format} \
was given`);
      }
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (check.format === 'array') {
      data.value = data.value.octets || data.value.parts;
    } else if (data.value.kind() === 'ipv6' && check.format === 'long') {
      data.value = data.value.toNormalizedString();
    } else data.value = data.value.toString();
    return Promise.resolve();
  }
}

exports.default = IPSchema;