util.js

/* exported Util, Params, DummyRateLimit */
/* global Config */

/**
A JavaScript WebRTC snowflake proxy

Contains helpers for parsing query strings and other utilities.
*/

class Util {

  static genSnowflakeID() {
    return Math.random().toString(36).substring(2);
  }

  static hasWebRTC() {
    return typeof RTCPeerConnection === 'function';
  }

  static hasCookies() {
    return navigator.cookieEnabled;
  }

  /**
   * @returns {Promise<"restricted" | "unrestricted">}
   * resolves to "restricted" if we
   * fail to make a test connection to a known restricted
   * NAT, "unrestricted" if the test connection succeeds, and
   * "unknown" if we fail to reach the probe test server
   * @param {number} timeout
   */
  static checkNATType(timeout) {
    let pc = new RTCPeerConnection({iceServers: [
      {urls: 'stun:stun1.l.google.com:19302'}
    ]});
    let channel = pc.createDataChannel("NAT test");
    return (new Promise((fulfill, reject) => {
      let open = false;
      channel.onopen = function() {
        open = true;
        fulfill("unrestricted");
      };
      pc.onicecandidate = (evt) => {
        if (evt.candidate == null) {
          //ice gathering is finished
          Util.sendOffer(pc.localDescription)
          .then((answer) => {
            setTimeout(() => {
              if(!open) {
                fulfill("restricted");
              }
            }, timeout);
            pc.setRemoteDescription(JSON.parse(answer));
          }).catch((e) => {
            console.log(e);
            reject("Error receiving probetest answer");
          });
        }
      };
      pc.createOffer()
      .then((offer) =>  pc.setLocalDescription(offer))
      .catch((e) => {
        console.log(e);
        reject("Error creating offer for probetest");
      });
    }).finally(() => {
      channel.close();
      pc.close();
    }));
  }

  /**
   * Assumes getClientOffer happened, and a WebRTC SDP answer has been generated.
   * Sends it back to the broker, which passes it back to the original client.
   * @param {RTCSessionDescription} offer
   */
  static sendOffer(offer) {
    return new Promise((fulfill, reject) => {
      const xhr = new XMLHttpRequest();
      xhr.timeout = 30 * 1000;
      xhr.onreadystatechange = function() {
        if (xhr.DONE !== xhr.readyState) {
          return;
        }
        switch (xhr.status) {
          case 200: {
            const response = JSON.parse(xhr.responseText);
            return fulfill(response.Answer); // Should contain offer.
          }
          default:
            console.log('Probe ERROR: Unexpected ' + xhr.status + ' - ' + xhr.statusText);
            return reject('Failed to get answer from probe service');
        }
      };
      const data = {"Status": "client match", "Offer": JSON.stringify(offer)};
      try {
        xhr.open('POST', Config.PROBEURL);
      } catch (error) {
        console.log('Signaling Server: exception while connecting: ' + error.message);
        return reject('unable to connect to signaling server');
      }
      xhr.send(JSON.stringify(data));
    });
  }
}


class Parse {

  /**
   * @param {typeof document.cookie} cookies
   * Parse a cookie data string (usually document.cookie). The return type is an
   * object mapping cookies names to values. Returns null on error.
   * http://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-8747038
   */
  static cookie(cookies) {
    const result = {};
    const strings = cookies ? cookies.split(';') : [];
    for (let i = 0, len = strings.length; i < len; i++) {
      const string = strings[i];
      const j = string.indexOf('=');
      if (-1 === j) {
        return null;
      }
      const name = decodeURIComponent(string.substr(0, j).trim());
      const value = decodeURIComponent(string.substr(j + 1).trim());
      if (!(name in result)) {
        result[name] = value;
      }
    }
    return result;
  }

  /**
   * Parse a count of bytes. A suffix of 'k', 'm', or 'g' (or uppercase)
   * does what you would think. Returns null on error.
   */
  static byteCount(spec) {
    let matches = spec.match(/^(\d+(?:\.\d*)?)(\w*)$/);
    if (matches === null) {
      return null;
    }
    let count = Number(matches[1]);
    if (isNaN(count)) {
      return null;
    }
    const UNITS = new Map([
      ['', 1],
      ['k', 1024],
      ['m', 1024*1024],
      ['g', 1024*1024*1024],
    ]);
    let unit = matches[2].toLowerCase();
    if (!UNITS.has(unit)) {
      return null;
    }
    let multiplier = UNITS.get(unit);
    return count * multiplier;
  }

  /**
   * Parse a remote connection-address out of the "c=" Connection Data field
   * or the "a=" attribute fields of the session description.
   * Return undefined if none is found.
   * https://tools.ietf.org/html/rfc4566#section-5.7
   * https://tools.ietf.org/html/rfc5245#section-15
   */
  static ipFromSDP(sdp) {
    console.log(sdp);
    const ref = [
      /^a=candidate:[a-zA-Z0-9+/]+ \d+ udp \d+ ([\d.]+) /mg,
      /^a=candidate:[a-zA-Z0-9+/]+ \d+ udp \d+ ([0-9A-Fa-f:.]+) /mg,
      /^c=IN IP4 ([\d.]+)(?:(?:\/\d+)?\/\d+)?(:? |$)/mg,
      /^c=IN IP6 ([0-9A-Fa-f:.]+)(?:\/\d+)?(:? |$)/mg
    ];
    for (let i = 0, len = ref.length; i < len; i++) {
      const pattern = ref[i];
      let m = pattern.exec(sdp);
      while (m != null) {
        if(Parse.isRemoteIP(m[1])) return m[1];
        m = pattern.exec(sdp);
      }
    }
  }

  /**
   * Parse the mapped port out of an ice candidate returned from the
   * onicecandidate callback
   */
  static portFromCandidate(c) {
    const pattern = /(?:[\d.]+|[0-9A-Fa-f:.]+) (\d+) typ srflx/m;
    const m = pattern.exec(c);
    if (m != null) {
      return m[1];
    }
    return null;
  }

  /** Determine whether an IP address is a local, unspecified, or loopback address */
  static isRemoteIP(ip) {
    if (ip.includes(":")) {
      const ip6 = ip.split(':');
      // Loopback address
      const loopback = /^(?:0*:)*?:?0*1$/m;
      // Unspecified address
      const unspecified = /^(?:0*:)*?:?0*$/m;
      // Local IPv6 addresses are defined in https://tools.ietf.org/html/rfc4193
      return !((loopback.exec(ip) != null) || (unspecified.exec(ip) != null) ||
        (parseInt(ip6[0],16)&0xfe00) == 0xfc00);
    }

    // Local IPv4 addresses are defined in https://tools.ietf.org/html/rfc1918
    const ip4 = ip.split('.');
    return !(ip4[0] == 10 || ip4[0] == 127 || ip == "0.0.0.0" ||
      (ip4[0] == 172 && (ip4[1]&0xf0) == 16) ||
      (ip4[0] == 192 && ip4[1] == 168) ||
      // Carrier-Grade NAT as per https://tools.ietf.org/htm/rfc6598
      (ip4[0] == 100 && (ip4[1]&0xc0) == 64) ||
      // Dynamic Configuration as per https://tools.ietf.org/htm/rfc3927
      (ip4[0] == 169 && ip4[1] == 254));
  }

}


class Params {

  static getBool(query, param, defaultValue) {
    if (!query.has(param)) {
      return defaultValue;
    }
    const val = query.get(param);
    if ('true' === val || '1' === val || '' === val) {
      return true;
    }
    if ('false' === val || '0' === val) {
      return false;
    }
    return null;
  }

  /**
   * Get an object value and parse it as a byte count. Example byte counts are
   * '100' and '1.3m'. Returns |defaultValue| if param is not a key. Return null
   * on a parsing error.
   */
  static getByteCount(query, param, defaultValue) {
    if (!query.has(param)) {
      return defaultValue;
    }
    return Parse.byteCount(query.get(param));
  }

}


class BucketRateLimit {

  constructor(capacity, time) {
    this.capacity = capacity;
    this.time = time;
  }

  age() {
    const now = new Date();
    const delta = (now - this.lastUpdate) / 1000.0;
    this.lastUpdate = now;
    this.amount -= delta * this.capacity / this.time;
    if (this.amount < 0.0) {
      this.amount = 0.0;
    }
  }

  update(n) {
    this.age();
    this.amount += n;
    return this.amount <= this.capacity;
  }

  /** How many seconds in the future will the limit expire? */
  when() {
    this.age();
    return (this.amount - this.capacity) / (this.capacity / this.time);
  }

  isLimited() {
    this.age();
    return this.amount > this.capacity;
  }

}

BucketRateLimit.prototype.amount = 0.0;

BucketRateLimit.prototype.lastUpdate = new Date();


/** A rate limiter that never limits. */
class DummyRateLimit {

  constructor(capacity, time) {
    this.capacity = capacity;
    this.time = time;
  }

  update() {
    return true;
  }

  when() {
    return 0.0;
  }

  isLimited() {
    return false;
  }

}