Initial commit

Author: Rob--W

.gitignore

@@ -0,0 +1,2 @@
+*.swp
+node_modules/

.jscsrc

@@ -0,0 +1,3 @@
+{
+  "preset": "node-style-guide"
+}

.jshintrc

@@ -0,0 +1,16 @@
+{
+  "camelcase": true,
+  "curly": true,
+  "eqeqeq": true,
+  "freeze": true,
+  "indent": 2,
+  "newcap": true,
+  "quotmark": "single",
+  "maxdepth": 3,
+  "maxlen": 80,
+  "eqnull": true,
+  "funcscope": true,
+  "node": true,
+  "undef": true,
+  "unused": "vars"
+}

README.md

@@ -0,0 +1,116 @@
+# proxy-from-env
+
+`proxy-from-env` is a Node.js package that exports a function (`getProxyForUrl`)
+that takes an input URL (a string) and returns the desired proxy URL (also a
+string) based on standard proxy environment variables. If no proxy is set, an
+empty string is returned.
+
+It is your responsibility to actually proxy the request using the given URL.
+
+Installation:
+
+```sh
+npm install proxy-from-env
+```
+
+## Example
+This example shows how the data for a URL can be fetched via the
+[`http` module](https://nodejs.org/api/http.html), in a proxy-aware way.
+
+```javascript
+var http = require('http');
+var parseUrl = require('url').parse;
+var getProxyForUrl = require('proxy-from-env').getProxyForUrl;
+
+var some_url = 'https://example.com/something';
+
+var proxy_url = getProxyForUrl(some_url);  // <-- Our magic.
+if (proxy_url) {
+  // Should be proxied through proxy_url.
+  var parsed_some_url = parseUrl(some_url);
+  var parsed_proxy_url = parseUrl(proxy_url);
+  // A HTTP proxy is quite simple. It is similar to a normal request, except the
+  // path is an absolute URL, and the proxied URL's host is put in the header
+  // instead of the server's actual host.
+  httpOptions = {
+    protocol: parsed_proxy_url.protocol,
+    hostname: parsed_proxy_url.hostname,
+    port: parsed_proxy_url.port,
+    path: parsed_some_url.href,
+    headers: {
+      Host: parsed_some_url.host,  // = host name + optional port.
+    },
+  };
+} else {
+  // Direct request.
+  httpOptions = some_url;
+}
+http.get(httpOptions, function(res) {
+  var responses = [];
+  res.on('data', function() { responses.push(chunk); });
+  res.on('end', function() { console.log(responses.join(''));  });
+});
+
+```
+
+## Environment variables
+The environment variables can be specified in lowercase or uppercase, with the
+lowercase name having precedence over the uppercase variant. A variable that is
+not set has the same meaning as a variable that is set but has no value.
+
+### NO\_PROXY
+
+`NO_PROXY` is a list of host names (optionally with a port). If the input URL
+matches any of the entries in `NO_PROXY`, then the input URL should be fetched
+by a direct request (i.e. without a proxy).
+
+Matching follows the following rules:
+
+- `NO_PROXY=*` disables all proxies.
+- Space and commas may be used to separate the entries in the `NO_PROXY` list.
+- If `NO_PROXY` does not contain any entries, then proxies are never disabled.
+- If a port is added after the host name, then the ports must match. If the URL
+  does not have an explicit port name, the protocol's default port is used.
+- Generally, the proxy is only disabled if the host name is an exact match for
+  an entry in the `NO_PROXY` list. The only exceptions are entries that start
+  with a dot or with a wildcard; then the proxy is disabled if the host name
+  ends with the entry.
+
+See `test.js` for examples of what should match and what does not.
+
+### \*\_PROXY
+
+The environment variable used for the proxy depends on the protocol of the URL.
+For example, `https://example,com` uses the "https" protocol, and therefore the
+proxy to be used is `HTTPS_PROXY` (_NOT_ `HTTP_PROXY`, which is _only_ used for
+http:-URLs).
+
+The library is not limited to http(s), other schemes such as
+`FTP_PROXY` (ftp:),
+`WSS_PROXY` (wss:),
+`WS_PROXY` (ws:)
+are also supported.
+
+If present, `ALL_PROXY` is used as fallback if there is no other match.
+
+
+## External resources
+The exact way of parsing the environment variables is not codified in any
+standard. This library is designed to be compatible with formats as expected by
+existing software.
+The following resources were used to determine the desired behavior:
+
+- cURL:
+  https://curl.haxx.se/docs/manpage.html#ENVIRONMENT  
+  https://github.com/curl/curl/blob/4af40b3646d3b09f68e419f7ca866ff395d1f897/lib/url.c#L4446-L4514  
+
+- wget: 
+  https://www.gnu.org/software/wget/manual/wget.html#Proxies  
+  http://git.savannah.gnu.org/cgit/wget.git/tree/src/init.c?id=636a5f9a1c508aa39e35a3a8e9e54520a284d93d#n383  
+  http://git.savannah.gnu.org/cgit/wget.git/tree/src/retr.c?id=93c1517c4071c4288ba5a4b038e7634e4c6b5482#n1278  
+
+- W3:
+  https://www.w3.org/Daemon/User/Proxies/ProxyClients.html  
+
+- Python's urllib:
+  https://github.com/python/cpython/blob/936135bb97fe04223aa30ca6e98eac8f3ed6b349/Lib/urllib/request.py#L2444-L2479

index.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var parseUrl = require('url').parse;
+
+var DEFAULT_PORTS = {
+  'ftp:': 21,
+  'gopher:': 70,
+  'http:': 80,
+  'https:': 443,
+  'ws:': 80,
+  'wss:': 443,
+};
+
+var stringEndsWith = String.prototype.endsWith || function(s) {
+  return s.length <= this.length &&
+    this.indexOf(s, this.length - s.length) !== -1;
+};
+
+/**
+ * @param {string} url - The URL
+ * @return {string} The URL of the proxy that should handle the request to the
+ *  given URL. If no proxy is set, this will be an empty string.
+ */
+function getProxyForUrl(url) {
+  var parsedUrl = parseUrl(url);
+  if (!parsedUrl.host || !shouldProxy(parsedUrl)) {
+    return '';  // Don't proxy invalid URLs or URLs that match NO_PROXY.
+  }
+
+  var proto = url.split(':', 1)[0];
+  return getEnv(proto + '_proxy') || getEnv('all_proxy');
+}
+
+/**
+ * Determines whether a given URL should be proxied.
+ *
+ * @param {object} parsedUrl - The result of url.parse
+ * @returns {boolean} Whether the given URL should be proxied.
+ * @private
+ */
+function shouldProxy(parsedUrl) {
+  var NO_PROXY = getEnv('no_proxy').toLowerCase();
+  if (!NO_PROXY) {
+    return true;  // Always proxy if NO_PROXY is not set.
+  }
+  if (NO_PROXY === '*') {
+    return false;  // Never proxy if wildcard is set.
+  }
+
+  var port = parseInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || 0;
+  // Stripping ports in this way instead of using parsedUrl.hostname to make
+  // sure that the brackets around IPv6 addresses are kept.
+  var hostname = parsedUrl.host.replace(/:\d*$/, '');
+
+  return NO_PROXY.split(/[,\s]/).every(function(proxy) {
+    if (!proxy) {
+      return true;  // Skip zero-length hosts.
+    }
+    var parsedProxy = proxy.match(/^(.+):(\d+)$/);
+    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
+    if (parsedProxyPort && parsedProxyPort !== port) {
+      return true;  // Skip if ports don't match.
+    }
+
+    if (!/^[.*]/.test(parsedProxyHostname)) {
+      // No wildcards, so stop proxying if there is an exact match.
+      return hostname !== parsedProxyHostname;
+    }
+
+    if (parsedProxyHostname.charAt(0) === '*') {
+      // Remove leading wildcard.
+      parsedProxyHostname = parsedProxyHostname.slice(1);
+    }
+    // Stop proxying if the hostname ends with the no_proxy host.
+    return !stringEndsWith.call(hostname, parsedProxyHostname);
+  });
+}
+
+/**
+ * Get the value for an environment variable.
+ *
+ * @param {string} key - The name of the environment variable.
+ * @return {string} The value of the environment variable.
+ * @private
+ */
+function getEnv(key) {
+  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
+}
+
+exports.getProxyForUrl = getProxyForUrl;

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "proxy-from-env",
+  "version": "0.0.1",
+  "description": "Offers getProxyForUrl to get the proxy URL for a URL, respecting the *_PROXY (e.g. HTTP_PROXY) and NO_PROXY environment variables.",
+  "main": "index.js",
+  "scripts": {
+    "lint": "jscs index.js && jshint index.js ;:",
+    "test": "./node_modules/.bin/mocha ./test.js --reporter spec"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rob--W/proxy-from-env.git"
+  },
+  "keywords": [
+    "proxy",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+    "environment"
+  ],
+  "author": "Rob Wu <[email protected]> (https://robwu.nl/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Rob--W/proxy-from-env/issues"
+  },
+  "homepage": "https://github.com/Rob--W/proxy-from-env#readme",
+  "devDependencies": {
+    "mocha": "^2.4.5"
+  }
+}