add hw2

node_modules/ip-address/src/ipv4.ts

@@ -0,0 +1,356 @@
+/* eslint-disable no-param-reassign */
+
+import * as common from './common';
+import * as constants from './v4/constants';
+import { AddressError } from './address-error';
+
+/**
+ * Represents an IPv4 address
+ * @class Address4
+ * @param {string} address - An IPv4 address string
+ */
+export class Address4 {
+  address: string;
+  addressMinusSuffix?: string;
+  groups: number = constants.GROUPS;
+  parsedAddress: string[] = [];
+  parsedSubnet: string = '';
+  subnet: string = '/32';
+  subnetMask: number = 32;
+  v4: boolean = true;
+
+  constructor(address: string) {
+    this.address = address;
+
+    const subnet = constants.RE_SUBNET_STRING.exec(address);
+
+    if (subnet) {
+      this.parsedSubnet = subnet[0].replace('/', '');
+      this.subnetMask = parseInt(this.parsedSubnet, 10);
+      this.subnet = `/${this.subnetMask}`;
+
+      if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {
+        throw new AddressError('Invalid subnet mask.');
+      }
+
+      address = address.replace(constants.RE_SUBNET_STRING, '');
+    }
+
+    this.addressMinusSuffix = address;
+
+    this.parsedAddress = this.parse(address);
+  }
+
+  static isValid(address: string): boolean {
+    try {
+      // eslint-disable-next-line no-new
+      new Address4(address);
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /*
+   * Parses a v4 address
+   */
+  parse(address: string) {
+    const groups = address.split('.');
+
+    if (!address.match(constants.RE_ADDRESS)) {
+      throw new AddressError('Invalid IPv4 address.');
+    }
+
+    return groups;
+  }
+
+  /**
+   * Returns the correct form of an address
+   * @memberof Address4
+   * @instance
+   * @returns {String}
+   */
+  correctForm(): string {
+    return this.parsedAddress.map((part) => parseInt(part, 10)).join('.');
+  }
+
+  /**
+   * Returns true if the address is correct, false otherwise
+   * @memberof Address4
+   * @instance
+   * @returns {Boolean}
+   */
+  isCorrect = common.isCorrect(constants.BITS);
+
+  /**
+   * Converts a hex string to an IPv4 address object
+   * @memberof Address4
+   * @static
+   * @param {string} hex - a hex string to convert
+   * @returns {Address4}
+   */
+  static fromHex(hex: string): Address4 {
+    const padded = hex.replace(/:/g, '').padStart(8, '0');
+    const groups = [];
+    let i;
+
+    for (i = 0; i < 8; i += 2) {
+      const h = padded.slice(i, i + 2);
+
+      groups.push(parseInt(h, 16));
+    }
+
+    return new Address4(groups.join('.'));
+  }
+
+  /**
+   * Converts an integer into a IPv4 address object
+   * @memberof Address4
+   * @static
+   * @param {integer} integer - a number to convert
+   * @returns {Address4}
+   */
+  static fromInteger(integer: number): Address4 {
+    return Address4.fromHex(integer.toString(16));
+  }
+
+  /**
+   * Return an address from in-addr.arpa form
+   * @memberof Address4
+   * @static
+   * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
+   * @returns {Adress4}
+   * @example
+   * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)
+   * address.correctForm(); // '192.0.2.42'
+   */
+  static fromArpa(arpaFormAddress: string): Address4 {
+    // remove ending ".in-addr.arpa." or just "."
+    const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, '');
+
+    const address = leader.split('.').reverse().join('.');
+
+    return new Address4(address);
+  }
+
+  /**
+   * Converts an IPv4 address object to a hex string
+   * @memberof Address4
+   * @instance
+   * @returns {String}
+   */
+  toHex(): string {
+    return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(':');
+  }
+
+  /**
+   * Converts an IPv4 address object to an array of bytes
+   * @memberof Address4
+   * @instance
+   * @returns {Array}
+   */
+  toArray(): number[] {
+    return this.parsedAddress.map((part) => parseInt(part, 10));
+  }
+
+  /**
+   * Converts an IPv4 address object to an IPv6 address group
+   * @memberof Address4
+   * @instance
+   * @returns {String}
+   */
+  toGroup6(): string {
+    const output = [];
+    let i;
+
+    for (i = 0; i < constants.GROUPS; i += 2) {
+      output.push(
+        `${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(
+          this.parsedAddress[i + 1],
+        )}`,
+      );
+    }
+
+    return output.join(':');
+  }
+
+  /**
+   * Returns the address as a `bigint`
+   * @memberof Address4
+   * @instance
+   * @returns {bigint}
+   */
+  bigInt(): bigint {
+    return BigInt(`0x${this.parsedAddress.map((n) => common.stringToPaddedHex(n)).join('')}`);
+  }
+
+  /**
+   * Helper function getting start address.
+   * @memberof Address4
+   * @instance
+   * @returns {bigint}
+   */
+  _startAddress(): bigint {
+    return BigInt(`0b${this.mask() + '0'.repeat(constants.BITS - this.subnetMask)}`);
+  }
+
+  /**
+   * The first address in the range given by this address' subnet.
+   * Often referred to as the Network Address.
+   * @memberof Address4
+   * @instance
+   * @returns {Address4}
+   */
+  startAddress(): Address4 {
+    return Address4.fromBigInt(this._startAddress());
+  }
+
+  /**
+   * The first host address in the range given by this address's subnet ie
+   * the first address after the Network Address
+   * @memberof Address4
+   * @instance
+   * @returns {Address4}
+   */
+  startAddressExclusive(): Address4 {
+    const adjust = BigInt('1');
+    return Address4.fromBigInt(this._startAddress() + adjust);
+  }
+
+  /**
+   * Helper function getting end address.
+   * @memberof Address4
+   * @instance
+   * @returns {bigint}
+   */
+  _endAddress(): bigint {
+    return BigInt(`0b${this.mask() + '1'.repeat(constants.BITS - this.subnetMask)}`);
+  }
+
+  /**
+   * The last address in the range given by this address' subnet
+   * Often referred to as the Broadcast
+   * @memberof Address4
+   * @instance
+   * @returns {Address4}
+   */
+  endAddress(): Address4 {
+    return Address4.fromBigInt(this._endAddress());
+  }
+
+  /**
+   * The last host address in the range given by this address's subnet ie
+   * the last address prior to the Broadcast Address
+   * @memberof Address4
+   * @instance
+   * @returns {Address4}
+   */
+  endAddressExclusive(): Address4 {
+    const adjust = BigInt('1');
+    return Address4.fromBigInt(this._endAddress() - adjust);
+  }
+
+  /**
+   * Converts a BigInt to a v4 address object
+   * @memberof Address4
+   * @static
+   * @param {bigint} bigInt - a BigInt to convert
+   * @returns {Address4}
+   */
+  static fromBigInt(bigInt: bigint): Address4 {
+    return Address4.fromHex(bigInt.toString(16));
+  }
+
+  /**
+   * Returns the first n bits of the address, defaulting to the
+   * subnet mask
+   * @memberof Address4
+   * @instance
+   * @returns {String}
+   */
+  mask(mask?: number): string {
+    if (mask === undefined) {
+      mask = this.subnetMask;
+    }
+
+    return this.getBitsBase2(0, mask);
+  }
+
+  /**
+   * Returns the bits in the given range as a base-2 string
+   * @memberof Address4
+   * @instance
+   * @returns {string}
+   */
+  getBitsBase2(start: number, end: number): string {
+    return this.binaryZeroPad().slice(start, end);
+  }
+
+  /**
+   * Return the reversed ip6.arpa form of the address
+   * @memberof Address4
+   * @param {Object} options
+   * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix
+   * @instance
+   * @returns {String}
+   */
+  reverseForm(options?: common.ReverseFormOptions): string {
+    if (!options) {
+      options = {};
+    }
+
+    const reversed = this.correctForm().split('.').reverse().join('.');
+
+    if (options.omitSuffix) {
+      return reversed;
+    }
+
+    return `${reversed}.in-addr.arpa.`;
+  }
+
+  /**
+   * Returns true if the given address is in the subnet of the current address
+   * @memberof Address4
+   * @instance
+   * @returns {boolean}
+   */
+  isInSubnet = common.isInSubnet;
+
+  /**
+   * Returns true if the given address is a multicast address
+   * @memberof Address4
+   * @instance
+   * @returns {boolean}
+   */
+  isMulticast(): boolean {
+    return this.isInSubnet(new Address4('224.0.0.0/4'));
+  }
+
+  /**
+   * Returns a zero-padded base-2 string representation of the address
+   * @memberof Address4
+   * @instance
+   * @returns {string}
+   */
+  binaryZeroPad(): string {
+    return this.bigInt().toString(2).padStart(constants.BITS, '0');
+  }
+
+  /**
+   * Groups an IPv4 address for inclusion at the end of an IPv6 address
+   * @returns {String}
+   */
+  groupForV6(): string {
+    const segments = this.parsedAddress;
+
+    return this.address.replace(
+      constants.RE_ADDRESS,
+      `<span class="hover-group group-v4 group-6">${segments
+        .slice(0, 2)
+        .join('.')}</span>.<span class="hover-group group-v4 group-7">${segments
+        .slice(2, 4)
+        .join('.')}</span>`,
+    );
+  }
+}