How to use ip - 10 common examples

async checkStored(data) {
    try {
      const configuration = this.wazuhConfig.getConfig();
      const timeout = configuration ? configuration.timeout : 20000;
      const headers = {
        headers: { 'Content-Type': 'application/json' },
        timeout: timeout || 20000
      };
      const payload = { id: data };
      const result = await this.$http.post(
        chrome.addBasePath('/api/check-stored-api'),
        payload,
        headers
      );

      this.appState.setPatternSelector(configuration['ip.selector']);

      if (result.error) {
        return Promise.reject(result);
      }
      return result;
    } catch (error) {
      if (((error || {}).data || {}).code === 3099) {
        // Do nothing
        return 3099;
      }
      if (error.status && error.status === -1) {
        this.wzMisc.setApiIsDown(true);
      }
      return Promise.reject(error);
    }
  }

function ipMatch(ip1: string, ip2: string): boolean {
  // check ip1
  if (!(ip.isV4Format(ip1) || ip.isV6Format(ip1))) {
    throw new Error('invalid argument: ip1 in ipMatch() function is not an IP address.');
  }
  // check ip2
  const cidrParts: string[] = ip2.split('/');
  if (cidrParts.length === 2) {
    return ip.cidrSubnet(ip2).contains(ip1);
  } else {
    if (!(ip.isV4Format(ip2) || ip.isV6Format(ip2))) {
      console.log(ip2);
      throw new Error('invalid argument: ip2 in ipMatch() function is not an IP address.');
    }
    return ip.isEqual(ip1, ip2);
  }
}

function ipMatch(ip1: string, ip2: string): boolean {
  // check ip1
  if (!(ip.isV4Format(ip1) || ip.isV6Format(ip1))) {
    throw new Error('invalid argument: ip1 in ipMatch() function is not an IP address.');
  }
  // check ip2
  const cidrParts: string[] = ip2.split('/');
  if (cidrParts.length === 2) {
    return ip.cidrSubnet(ip2).contains(ip1);
  } else {
    if (!(ip.isV4Format(ip2) || ip.isV6Format(ip2))) {
      console.log(ip2);
      throw new Error('invalid argument: ip2 in ipMatch() function is not an IP address.');
    }
    return ip.isEqual(ip1, ip2);
  }
}

function ipMatch(ip1: string, ip2: string): boolean {
  // check ip1
  if (!(ip.isV4Format(ip1) || ip.isV6Format(ip1))) {
    throw new Error('invalid argument: ip1 in ipMatch() function is not an IP address.');
  }
  // check ip2
  const cidrParts: string[] = ip2.split('/');
  if (cidrParts.length === 2) {
    return ip.cidrSubnet(ip2).contains(ip1);
  } else {
    if (!(ip.isV4Format(ip2) || ip.isV6Format(ip2))) {
      console.log(ip2);
      throw new Error('invalid argument: ip2 in ipMatch() function is not an IP address.');
    }
    return ip.isEqual(ip1, ip2);
  }
}

remoteHost = {
                    host: buff.readString(hostLength),
                    port: buff.readUInt16BE()
                };
                // IPv6
            }
            else if (addressType === constants_1.Socks5HostType.IPv6) {
                // Check if data is available.
                const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6;
                if (this._receiveBuffer.length < dataNeeded) {
                    this._nextRequiredPacketBufferSize = dataNeeded;
                    return;
                }
                buff = smart_buffer_1.SmartBuffer.fromBuffer(this._receiveBuffer.get(dataNeeded).slice(4));
                remoteHost = {
                    host: ip.toString(buff.readBuffer(16)),
                    port: buff.readUInt16BE()
                };
            }
            this.state = constants_1.SocksClientState.Established;
            this.removeInternalSocketHandlers();
            this.emit('established', { socket: this._socket, remoteHost });
        }
    }
    get socksClientOptions() {

var root = process.cwd();
if (dir) {
	// use the provided directory
	root = dir;
} else if (file.match(/^\//)) {
	// .proto file is absolute path, use it
	root = file.substr(0, file.lastIndexOf('/'));
}

if (!fs.existsSync(root + '/' + file)) {
	fatal('Error: '.red + 'Could not find .proto file at ' + root + '/' + file);
}

var host = program.ip || config.ip;
if (!ip.isV4Format(host) && !ip.isV6Format(host)) {
	fatal('Error: '.red + 'Invalid IP address: ' + host);
}

var port = program.port || config.port;
if (!port.match(/^[0-9]{1,5}$/)) {
	fatal('Error: '.red + 'Invalid port: ' + port);
}

try {
	grpcli.init({
		proto_file: {
			root: root,
			file: file
		},
		host: host,
		port: port,

// if hostHeader doesn't have scheme, add // for parsing.
      /^(.+:)?\/\//.test(hostHeader) ? hostHeader : `//${hostHeader}`,
      false,
      true
    ).hostname;
    // always allow requests with explicit IPv4 or IPv6-address.
    // A note on IPv6 addresses:
    // hostHeader will always contain the brackets denoting
    // an IPv6-address in URLs,
    // these are removed from the hostname in url.parse(),
    // so we have the pure IPv6-address in hostname.
    // always allow localhost host, for convenience (hostname === 'localhost')
    // allow hostname of listening address  (hostname === this.hostname)
    const isValidHostname =
      ip.isV4Format(hostname) ||
      ip.isV6Format(hostname) ||
      hostname === 'localhost' ||
      hostname === this.hostname;

    if (isValidHostname) {
      return true;
    }
    // always allow localhost host, for convenience
    // allow if hostname is in allowedHosts
    if (this.allowedHosts && this.allowedHosts.length) {
      for (let hostIdx = 0; hostIdx < this.allowedHosts.length; hostIdx++) {
        const allowedHost = this.allowedHosts[hostIdx];

        if (allowedHost === hostname) {
          return true;
        }

// eslint-disable-next-line @typescript-eslint/camelcase
              keep_fnames: true
            }
          };
        }
        const UglifyJsPlugin = builder.require('uglifyjs-webpack-plugin');
        plugins.push(new UglifyJsPlugin(uglifyOpts));
      }
      plugins.push(new webpack.optimize.ModuleConcatenationPlugin());
    }
  }

  const backendOption = builder.backendUrl;
  const defines: any = {};
  if (backendOption) {
    defines.__BACKEND_URL__ = `'${backendOption.replace('{ip}', ip.address())}'`;
  }

  if (builder.require.probe('clean-webpack-plugin')) {
    const CleanWebpackPlugin = builder.require('clean-webpack-plugin');
    plugins = plugins.concat(new CleanWebpackPlugin(builder.buildDir));
  }

  if (stack.hasAny('dll')) {
    const name = getDllName(builder);
    plugins = [
      new webpack.DefinePlugin({
        'process.env.NODE_ENV': `"${buildNodeEnv}"`,
        ...defines,
        ...builder.defines
      }),
      new webpack.DllPlugin({

module.exports = function (_config, callback) {
    if (typeof _config == 'number') {
        _config = {
            port: _config
        }
    }
    config = Object.assign(config, _config);
    var proxy = this;
    var app = proxy.app;
    var httpServer = http.createServer(app.callback());
    proxy.httpServer = httpServer;
    proxy.port = config.port;
    proxy.localip = ip.address();
    proxy.localhost = proxy.localip + ':' + config.port;

    if (config.https) {
        // 下载cert证书
        proxy.when({
            fullUrl: config.loadCertUrl
        }, function (ctx) {
            ctx.logger.notice('Load Cert!');
            ctx.response.status = 200;
            ctx.response.body = config.cert;
            ctx.response.header['content-type'] = 'application/x-x509-ca-cert';
        });

        // 添加https代理服务
        if (config.cert && config.key) {
            let cxnEstablished = new Buffer(`HTTP/1.1 200 Connection Established\r\n\r\n`, 'ascii');

try {
    addr = maddr.nodeAddress()
  } catch (_) {
    // Might explode if maddr does not have an IP or cannot be converted
    // to a node address. This might happen if it's a relay. We do not print
    // or handle the error, otherwise we would get perhaps thousands of logs.
    return { isPrivate, isNearby }
  }

  // At this point, addr.address and publicIP must be valid IP addresses. Hence,
  // none of the calls bellow for ip library should fail.
  isPrivate = ip.isPrivate(addr.address)

  if (publicIP) {
    if (ip.isV4Format(addr.address)) {
      isNearby = ip.cidrSubnet(`${publicIP}/24`).contains(addr.address)
    } else if (ip.isV6Format(addr.address)) {
      isNearby = ip.cidrSubnet(`${publicIP}/48`).contains(addr.address) &&
        !ip.cidrSubnet('fc00::/8').contains(addr.address)
      // peerIP6 ∉ fc00::/8 to fix case of cjdns where IPs are not spatial allocated.
    }
  }

  return { isPrivate, isNearby }
}