src/third_party/devtools/node_modules/xmlhttprequest-ssl/lib/XMLHttpRequest.js - cobalt - Git at Google

 /**
  * Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
  *
  * This can be used with JS designed for browsers to improve reuse of code and
  * allow the use of existing libraries.
  *
  * Usage: include("XMLHttpRequest.js") and use XMLHttpRequest per W3C specs.
  *
  * @author Dan DeFelippi <dan@driverdan.com>
  * @contributor David Ellis <d.f.ellis@ieee.org>
  * @license MIT
  */

 var fs = require('fs');
 var Url = require('url');
 var spawn = require('child_process').spawn;

 /**
  * Module exports.
  */

 module.exports = XMLHttpRequest;

 // backwards-compat
 XMLHttpRequest.XMLHttpRequest = XMLHttpRequest;

 /**
  * `XMLHttpRequest` constructor.
  *
  * Supported options for the `opts` object are:
  *
  *  - `agent`: An http.Agent instance; http.globalAgent may be used; if 'undefined', agent usage is disabled
  *
  * @param {Object} opts optional "options" object
  */

 function XMLHttpRequest(opts) {
   "use strict";

   opts = opts || {};

   /**
    * Private variables
    */
   var self = this;
   var http = require('http');
   var https = require('https');

   // Holds http.js objects
   var request;
   var response;

   // Request settings
   var settings = {};

   // Disable header blacklist.
   // Not part of XHR specs.
   var disableHeaderCheck = false;

   // Set some default headers
   var defaultHeaders = {
     "User-Agent": "node-XMLHttpRequest",
     "Accept": "*/*"
   };

   var headers = Object.assign({}, defaultHeaders);

   // These headers are not user setable.
   // The following are allowed but banned in the spec:
   // * user-agent
   var forbiddenRequestHeaders = [
     "accept-charset",
     "accept-encoding",
     "access-control-request-headers",
     "access-control-request-method",
     "connection",
     "content-length",
     "content-transfer-encoding",
     "cookie",
     "cookie2",
     "date",
     "expect",
     "host",
     "keep-alive",
     "origin",
     "referer",
     "te",
     "trailer",
     "transfer-encoding",
     "upgrade",
     "via"
   ];

   // These request methods are not allowed
   var forbiddenRequestMethods = [
     "TRACE",
     "TRACK",
     "CONNECT"
   ];

   // Send flag
   var sendFlag = false;
   // Error flag, used when errors occur or abort is called
   var errorFlag = false;

   // Event listeners
   var listeners = {};

   /**
    * Constants
    */

   this.UNSENT = 0;
   this.OPENED = 1;
   this.HEADERS_RECEIVED = 2;
   this.LOADING = 3;
   this.DONE = 4;

   /**
    * Public vars
    */

   // Current state
   this.readyState = this.UNSENT;

   // default ready state change handler in case one is not set or is set late
   this.onreadystatechange = null;

   // Result & response
   this.responseText = "";
   this.responseXML = "";
   this.status = null;
   this.statusText = null;

   /**
    * Private methods
    */

   /**
    * Check if the specified header is allowed.
    *
    * @param string header Header to validate
    * @return boolean False if not allowed, otherwise true
    */
   var isAllowedHttpHeader = function(header) {
     return disableHeaderCheck || (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
   };

   /**
    * Check if the specified method is allowed.
    *
    * @param string method Request method to validate
    * @return boolean False if not allowed, otherwise true
    */
   var isAllowedHttpMethod = function(method) {
     return (method && forbiddenRequestMethods.indexOf(method) === -1);
   };

   /**
    * Public methods
    */

   /**
    * Open the connection. Currently supports local server requests.
    *
    * @param string method Connection method (eg GET, POST)
    * @param string url URL for the connection.
    * @param boolean async Asynchronous connection. Default is true.
    * @param string user Username for basic authentication (optional)
    * @param string password Password for basic authentication (optional)
    */
   this.open = function(method, url, async, user, password) {
     this.abort();
     errorFlag = false;

     // Check for valid request method
     if (!isAllowedHttpMethod(method)) {
       throw "SecurityError: Request method not allowed";
     }

     settings = {
       "method": method,
       "url": url.toString(),
       "async": (typeof async !== "boolean" ? true : async),
       "user": user || null,
       "password": password || null
     };

     setState(this.OPENED);
   };

   /**
    * Disables or enables isAllowedHttpHeader() check the request. Enabled by default.
    * This does not conform to the W3C spec.
    *
    * @param boolean state Enable or disable header checking.
    */
   this.setDisableHeaderCheck = function(state) {
     disableHeaderCheck = state;
   };

   /**
    * Sets a header for the request.
    *
    * @param string header Header name
    * @param string value Header value
    * @return boolean Header added
    */
   this.setRequestHeader = function(header, value) {
     if (this.readyState != this.OPENED) {
       throw "INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN";
       return false;
     }
     if (!isAllowedHttpHeader(header)) {
       console.warn('Refused to set unsafe header "' + header + '"');
       return false;
     }
     if (sendFlag) {
       throw "INVALID_STATE_ERR: send flag is true";
       return false;
     }
     headers[header] = value;
     return true;
   };

   /**
    * Gets a header from the server response.
    *
    * @param string header Name of header to get.
    * @return string Text of the header or null if it doesn't exist.
    */
   this.getResponseHeader = function(header) {
     if (typeof header === "string"
       && this.readyState > this.OPENED
       && response.headers[header.toLowerCase()]
       && !errorFlag
     ) {
       return response.headers[header.toLowerCase()];
     }

     return null;
   };

   /**
    * Gets all the response headers.
    *
    * @return string A string with all response headers separated by CR+LF
    */
   this.getAllResponseHeaders = function() {
     if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
       return "";
     }
     var result = "";

     for (var i in response.headers) {
       // Cookie headers are excluded
       if (i !== "set-cookie" && i !== "set-cookie2") {
         result += i + ": " + response.headers[i] + "\r\n";
       }
     }
     return result.substr(0, result.length - 2);
   };

   /**
    * Gets a request header
    *
    * @param string name Name of header to get
    * @return string Returns the request header or empty string if not set
    */
   this.getRequestHeader = function(name) {
     // @TODO Make this case insensitive
     if (typeof name === "string" && headers[name]) {
       return headers[name];
     }

     return "";
   };

   /**
    * Sends the request to the server.
    *
    * @param string data Optional data to send as request body.
    */
   this.send = function(data) {
     if (this.readyState != this.OPENED) {
       throw "INVALID_STATE_ERR: connection must be opened before send() is called";
     }

     if (sendFlag) {
       throw "INVALID_STATE_ERR: send has already been called";
     }

     var ssl = false, local = false;
     var url = Url.parse(settings.url);
     var host;
     // Determine the server
     switch (url.protocol) {
       case 'https:':
         ssl = true;
         // SSL & non-SSL both need host, no break here.
       case 'http:':
         host = url.hostname;
         break;

       case 'file:':
         local = true;
         break;

       case undefined:
       case '':
         host = "localhost";
         break;

       default:
         throw "Protocol not supported.";
     }

     // Load files off the local filesystem (file://)
     if (local) {
       if (settings.method !== "GET") {
         throw "XMLHttpRequest: Only GET method is supported";
       }

       if (settings.async) {
         fs.readFile(url.pathname, 'utf8', function(error, data) {
           if (error) {
             self.handleError(error);
           } else {
             self.status = 200;
             self.responseText = data;
             setState(self.DONE);
           }
         });
       } else {
         try {
           this.responseText = fs.readFileSync(url.pathname, 'utf8');
           this.status = 200;
           setState(self.DONE);
         } catch(e) {
           this.handleError(e);
         }
       }

       return;
     }

     // Default to port 80. If accessing localhost on another port be sure
     // to use http://localhost:port/path
     var port = url.port || (ssl ? 443 : 80);
     // Add query string if one is used
     var uri = url.pathname + (url.search ? url.search : '');

     // Set the Host header or the server may reject the request
     headers["Host"] = host;
     if (!((ssl && port === 443) || port === 80)) {
       headers["Host"] += ':' + url.port;
     }

     // Set Basic Auth if necessary
     if (settings.user) {
       if (typeof settings.password == "undefined") {
         settings.password = "";
       }
       var authBuf = new Buffer(settings.user + ":" + settings.password);
       headers["Authorization"] = "Basic " + authBuf.toString("base64");
     }

     // Set content length header
     if (settings.method === "GET" || settings.method === "HEAD") {
       data = null;
     } else if (data) {
       headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);

       if (!headers["Content-Type"]) {
         headers["Content-Type"] = "text/plain;charset=UTF-8";
       }
     } else if (settings.method === "POST") {
       // For a post with no data set Content-Length: 0.
       // This is required by buggy servers that don't meet the specs.
       headers["Content-Length"] = 0;
     }

     var agent = opts.agent || false;
     var options = {
       host: host,
       port: port,
       path: uri,
       method: settings.method,
       headers: headers,
       agent: agent
     };

     if (ssl) {
       options.pfx = opts.pfx;
       options.key = opts.key;
       options.passphrase = opts.passphrase;
       options.cert = opts.cert;
       options.ca = opts.ca;
       options.ciphers = opts.ciphers;
       options.rejectUnauthorized = opts.rejectUnauthorized;
     }

     // Reset error flag
     errorFlag = false;

     // Handle async requests
     if (settings.async) {
       // Use the proper protocol
       var doRequest = ssl ? https.request : http.request;

       // Request is being sent, set send flag
       sendFlag = true;

       // As per spec, this is called here for historical reasons.
       self.dispatchEvent("readystatechange");

       // Handler for the response
       var responseHandler = function(resp) {
         // Set response var to the response we got back
         // This is so it remains accessable outside this scope
         response = resp;
         // Check for redirect
         // @TODO Prevent looped redirects
         if (response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
           // Change URL to the redirect location
           settings.url = response.headers.location;
           var url = Url.parse(settings.url);
           // Set host var in case it's used later
           host = url.hostname;
           // Options for the new request
           var newOptions = {
             hostname: url.hostname,
             port: url.port,
             path: url.path,
             method: response.statusCode === 303 ? 'GET' : settings.method,
             headers: headers
           };

           if (ssl) {
             newOptions.pfx = opts.pfx;
             newOptions.key = opts.key;
             newOptions.passphrase = opts.passphrase;
             newOptions.cert = opts.cert;
             newOptions.ca = opts.ca;
             newOptions.ciphers = opts.ciphers;
             newOptions.rejectUnauthorized = opts.rejectUnauthorized;
           }

           // Issue the new request
           request = doRequest(newOptions, responseHandler).on('error', errorHandler);
           request.end();
           // @TODO Check if an XHR event needs to be fired here
           return;
         }

         if (response && response.setEncoding) {
           response.setEncoding("utf8");
         }

         setState(self.HEADERS_RECEIVED);
         self.status = response.statusCode;

         response.on('data', function(chunk) {
           // Make sure there's some data
           if (chunk) {
             self.responseText += chunk;
           }
           // Don't emit state changes if the connection has been aborted.
           if (sendFlag) {
             setState(self.LOADING);
           }
         });

         response.on('end', function() {
           if (sendFlag) {
             // The sendFlag needs to be set before setState is called.  Otherwise if we are chaining callbacks
             // there can be a timing issue (the callback is called and a new call is made before the flag is reset).
             sendFlag = false;
             // Discard the 'end' event if the connection has been aborted
             setState(self.DONE);
           }
         });

         response.on('error', function(error) {
           self.handleError(error);
         });
       }

       // Error handler for the request
       var errorHandler = function(error) {
         self.handleError(error);
       }

       // Create the request
       request = doRequest(options, responseHandler).on('error', errorHandler);

       // Node 0.4 and later won't accept empty data. Make sure it's needed.
       if (data) {
         request.write(data);
       }

       request.end();

       self.dispatchEvent("loadstart");
     } else { // Synchronous
       // Create a temporary file for communication with the other Node process
       var contentFile = ".node-xmlhttprequest-content-" + process.pid;
       var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
       fs.writeFileSync(syncFile, "", "utf8");
       // The async request the other Node process executes
       var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
         + "var doRequest = http" + (ssl ? "s" : "") + ".request;"
         + "var options = " + JSON.stringify(options) + ";"
         + "var responseText = '';"
         + "var req = doRequest(options, function(response) {"
         + "response.setEncoding('utf8');"
         + "response.on('data', function(chunk) {"
         + "  responseText += chunk;"
         + "});"
         + "response.on('end', function() {"
         + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-STATUS:' + response.statusCode + ',' + responseText, 'utf8');"
         + "fs.unlinkSync('" + syncFile + "');"
         + "});"
         + "response.on('error', function(error) {"
         + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
         + "fs.unlinkSync('" + syncFile + "');"
         + "});"
         + "}).on('error', function(error) {"
         + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
         + "fs.unlinkSync('" + syncFile + "');"
         + "});"
         + (data ? "req.write('" + data.replace(/'/g, "\\'") + "');":"")
         + "req.end();";
       // Start the other Node Process, executing this string
       var syncProc = spawn(process.argv[0], ["-e", execString]);
       var statusText;
       while(fs.existsSync(syncFile)) {
         // Wait while the sync file is empty
       }
       self.responseText = fs.readFileSync(contentFile, 'utf8');
       // Kill the child process once the file has data
       syncProc.stdin.end();
       // Remove the temporary file
       fs.unlinkSync(contentFile);
       if (self.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
         // If the file returned an error, handle it
         var errorObj = self.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, "");
         self.handleError(errorObj);
       } else {
         // If the file returned okay, parse its data and move to the DONE state
         self.status = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:([0-9]*),.*/, "$1");
         self.responseText = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:[0-9]*,(.*)/, "$1");
         setState(self.DONE);
       }
     }
   };

   /**
    * Called when an error is encountered to deal with it.
    */
   this.handleError = function(error) {
     this.status = 503;
     this.statusText = error;
     this.responseText = error.stack;
     errorFlag = true;
     setState(this.DONE);
   };

   /**
    * Aborts a request.
    */
   this.abort = function() {
     if (request) {
       request.abort();
       request = null;
     }

     headers = Object.assign({}, defaultHeaders);
     this.responseText = "";
     this.responseXML = "";

     errorFlag = true;

     if (this.readyState !== this.UNSENT
         && (this.readyState !== this.OPENED || sendFlag)
         && this.readyState !== this.DONE) {
       sendFlag = false;
       setState(this.DONE);
     }
     this.readyState = this.UNSENT;
   };

   /**
    * Adds an event listener. Preferred method of binding to events.
    */
   this.addEventListener = function(event, callback) {
     if (!(event in listeners)) {
       listeners[event] = [];
     }
     // Currently allows duplicate callbacks. Should it?
     listeners[event].push(callback);
   };

   /**
    * Remove an event callback that has already been bound.
    * Only works on the matching funciton, cannot be a copy.
    */
   this.removeEventListener = function(event, callback) {
     if (event in listeners) {
       // Filter will return a new array with the callback removed
       listeners[event] = listeners[event].filter(function(ev) {
         return ev !== callback;
       });
     }
   };

   /**
    * Dispatch any events, including both "on" methods and events attached using addEventListener.
    */
   this.dispatchEvent = function(event) {
     if (typeof self["on" + event] === "function") {
       self["on" + event]();
     }
     if (event in listeners) {
       for (var i = 0, len = listeners[event].length; i < len; i++) {
         listeners[event][i].call(self);
       }
     }
   };

   /**
    * Changes readyState and calls onreadystatechange.
    *
    * @param int state New state
    */
   var setState = function(state) {
     if (self.readyState !== state) {
       self.readyState = state;

       if (settings.async || self.readyState < self.OPENED || self.readyState === self.DONE) {
         self.dispatchEvent("readystatechange");
       }

       if (self.readyState === self.DONE && !errorFlag) {
         self.dispatchEvent("load");
         // @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
         self.dispatchEvent("loadend");
       }
     }
   };
 };
	/**
	* Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
	*
	* This can be used with JS designed for browsers to improve reuse of code and
	* allow the use of existing libraries.
	*
	* Usage: include("XMLHttpRequest.js") and use XMLHttpRequest per W3C specs.
	*
	* @author Dan DeFelippi <dan@driverdan.com>
	* @contributor David Ellis <d.f.ellis@ieee.org>
	* @license MIT
	*/

	var fs = require('fs');
	var Url = require('url');
	var spawn = require('child_process').spawn;

	/**
	* Module exports.
	*/

	module.exports = XMLHttpRequest;

	// backwards-compat
	XMLHttpRequest.XMLHttpRequest = XMLHttpRequest;

	/**
	* `XMLHttpRequest` constructor.
	*
	* Supported options for the `opts` object are:
	*
	* - `agent`: An http.Agent instance; http.globalAgent may be used; if 'undefined', agent usage is disabled
	*
	* @param {Object} opts optional "options" object
	*/

	function XMLHttpRequest(opts) {
	"use strict";

	opts = opts \|\| {};

	/**
	* Private variables
	*/
	var self = this;
	var http = require('http');
	var https = require('https');

	// Holds http.js objects
	var request;
	var response;

	// Request settings
	var settings = {};

	// Disable header blacklist.
	// Not part of XHR specs.
	var disableHeaderCheck = false;

	// Set some default headers
	var defaultHeaders = {
	"User-Agent": "node-XMLHttpRequest",
	"Accept": "/"
	};

	var headers = Object.assign({}, defaultHeaders);

	// These headers are not user setable.
	// The following are allowed but banned in the spec:
	// * user-agent
	var forbiddenRequestHeaders = [
	"accept-charset",
	"accept-encoding",
	"access-control-request-headers",
	"access-control-request-method",
	"connection",
	"content-length",
	"content-transfer-encoding",
	"cookie",
	"cookie2",
	"date",
	"expect",
	"host",
	"keep-alive",
	"origin",
	"referer",
	"te",
	"trailer",
	"transfer-encoding",
	"upgrade",
	"via"
	];

	// These request methods are not allowed
	var forbiddenRequestMethods = [
	"TRACE",
	"TRACK",
	"CONNECT"
	];

	// Send flag
	var sendFlag = false;
	// Error flag, used when errors occur or abort is called
	var errorFlag = false;

	// Event listeners
	var listeners = {};

	/**
	* Constants
	*/

	this.UNSENT = 0;
	this.OPENED = 1;
	this.HEADERS_RECEIVED = 2;
	this.LOADING = 3;
	this.DONE = 4;

	/**
	* Public vars
	*/

	// Current state
	this.readyState = this.UNSENT;

	// default ready state change handler in case one is not set or is set late
	this.onreadystatechange = null;

	// Result & response
	this.responseText = "";
	this.responseXML = "";
	this.status = null;
	this.statusText = null;

	/**
	* Private methods
	*/

	/**
	* Check if the specified header is allowed.
	*
	* @param string header Header to validate
	* @return boolean False if not allowed, otherwise true
	*/
	var isAllowedHttpHeader = function(header) {
	return disableHeaderCheck \|\| (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
	};

	/**
	* Check if the specified method is allowed.
	*
	* @param string method Request method to validate
	* @return boolean False if not allowed, otherwise true
	*/
	var isAllowedHttpMethod = function(method) {
	return (method && forbiddenRequestMethods.indexOf(method) === -1);
	};

	/**
	* Public methods
	*/

	/**
	* Open the connection. Currently supports local server requests.
	*
	* @param string method Connection method (eg GET, POST)
	* @param string url URL for the connection.
	* @param boolean async Asynchronous connection. Default is true.
	* @param string user Username for basic authentication (optional)
	* @param string password Password for basic authentication (optional)
	*/
	this.open = function(method, url, async, user, password) {
	this.abort();
	errorFlag = false;

	// Check for valid request method
	if (!isAllowedHttpMethod(method)) {
	throw "SecurityError: Request method not allowed";
	}

	settings = {
	"method": method,
	"url": url.toString(),
	"async": (typeof async !== "boolean" ? true : async),
	"user": user \|\| null,
	"password": password \|\| null
	};

	setState(this.OPENED);
	};

	/**
	* Disables or enables isAllowedHttpHeader() check the request. Enabled by default.
	* This does not conform to the W3C spec.
	*
	* @param boolean state Enable or disable header checking.
	*/
	this.setDisableHeaderCheck = function(state) {
	disableHeaderCheck = state;
	};

	/**
	* Sets a header for the request.
	*
	* @param string header Header name
	* @param string value Header value
	* @return boolean Header added
	*/
	this.setRequestHeader = function(header, value) {
	if (this.readyState != this.OPENED) {
	throw "INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN";
	return false;
	}
	if (!isAllowedHttpHeader(header)) {
	console.warn('Refused to set unsafe header "' + header + '"');
	return false;
	}
	if (sendFlag) {
	throw "INVALID_STATE_ERR: send flag is true";
	return false;
	}
	headers[header] = value;
	return true;
	};

	/**
	* Gets a header from the server response.
	*
	* @param string header Name of header to get.
	* @return string Text of the header or null if it doesn't exist.
	*/
	this.getResponseHeader = function(header) {
	if (typeof header === "string"
	&& this.readyState > this.OPENED
	&& response.headers[header.toLowerCase()]
	&& !errorFlag
	) {
	return response.headers[header.toLowerCase()];
	}

	return null;
	};

	/**
	* Gets all the response headers.
	*
	* @return string A string with all response headers separated by CR+LF
	*/
	this.getAllResponseHeaders = function() {
	if (this.readyState < this.HEADERS_RECEIVED \|\| errorFlag) {
	return "";
	}
	var result = "";

	for (var i in response.headers) {
	// Cookie headers are excluded
	if (i !== "set-cookie" && i !== "set-cookie2") {
	result += i + ": " + response.headers[i] + "\r\n";
	}
	}
	return result.substr(0, result.length - 2);
	};

	/**
	* Gets a request header
	*
	* @param string name Name of header to get
	* @return string Returns the request header or empty string if not set
	*/
	this.getRequestHeader = function(name) {
	// @TODO Make this case insensitive
	if (typeof name === "string" && headers[name]) {
	return headers[name];
	}

	return "";
	};

	/**
	* Sends the request to the server.
	*
	* @param string data Optional data to send as request body.
	*/
	this.send = function(data) {
	if (this.readyState != this.OPENED) {
	throw "INVALID_STATE_ERR: connection must be opened before send() is called";
	}

	if (sendFlag) {
	throw "INVALID_STATE_ERR: send has already been called";
	}

	var ssl = false, local = false;
	var url = Url.parse(settings.url);
	var host;
	// Determine the server
	switch (url.protocol) {
	case 'https:':
	ssl = true;
	// SSL & non-SSL both need host, no break here.
	case 'http:':
	host = url.hostname;
	break;

	case 'file:':
	local = true;
	break;

	case undefined:
	case '':
	host = "localhost";
	break;

	default:
	throw "Protocol not supported.";
	}

	// Load files off the local filesystem (file://)
	if (local) {
	if (settings.method !== "GET") {
	throw "XMLHttpRequest: Only GET method is supported";
	}

	if (settings.async) {
	fs.readFile(url.pathname, 'utf8', function(error, data) {
	if (error) {
	self.handleError(error);
	} else {
	self.status = 200;
	self.responseText = data;
	setState(self.DONE);
	}
	});
	} else {
	try {
	this.responseText = fs.readFileSync(url.pathname, 'utf8');
	this.status = 200;
	setState(self.DONE);
	} catch(e) {
	this.handleError(e);
	}
	}

	return;
	}

	// Default to port 80. If accessing localhost on another port be sure
	// to use http://localhost:port/path
	var port = url.port \|\| (ssl ? 443 : 80);
	// Add query string if one is used
	var uri = url.pathname + (url.search ? url.search : '');

	// Set the Host header or the server may reject the request
	headers["Host"] = host;
	if (!((ssl && port === 443) \|\| port === 80)) {
	headers["Host"] += ':' + url.port;
	}

	// Set Basic Auth if necessary
	if (settings.user) {
	if (typeof settings.password == "undefined") {
	settings.password = "";
	}
	var authBuf = new Buffer(settings.user + ":" + settings.password);
	headers["Authorization"] = "Basic " + authBuf.toString("base64");
	}

	// Set content length header
	if (settings.method === "GET" \|\| settings.method === "HEAD") {
	data = null;
	} else if (data) {
	headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);

	if (!headers["Content-Type"]) {
	headers["Content-Type"] = "text/plain;charset=UTF-8";
	}
	} else if (settings.method === "POST") {
	// For a post with no data set Content-Length: 0.
	// This is required by buggy servers that don't meet the specs.
	headers["Content-Length"] = 0;
	}

	var agent = opts.agent \|\| false;
	var options = {
	host: host,
	port: port,
	path: uri,
	method: settings.method,
	headers: headers,
	agent: agent
	};

	if (ssl) {
	options.pfx = opts.pfx;
	options.key = opts.key;
	options.passphrase = opts.passphrase;
	options.cert = opts.cert;
	options.ca = opts.ca;
	options.ciphers = opts.ciphers;
	options.rejectUnauthorized = opts.rejectUnauthorized;
	}

	// Reset error flag
	errorFlag = false;

	// Handle async requests
	if (settings.async) {
	// Use the proper protocol
	var doRequest = ssl ? https.request : http.request;

	// Request is being sent, set send flag
	sendFlag = true;

	// As per spec, this is called here for historical reasons.
	self.dispatchEvent("readystatechange");

	// Handler for the response
	var responseHandler = function(resp) {
	// Set response var to the response we got back
	// This is so it remains accessable outside this scope
	response = resp;
	// Check for redirect
	// @TODO Prevent looped redirects
	if (response.statusCode === 302 \|\| response.statusCode === 303 \|\| response.statusCode === 307) {
	// Change URL to the redirect location
	settings.url = response.headers.location;
	var url = Url.parse(settings.url);
	// Set host var in case it's used later
	host = url.hostname;
	// Options for the new request
	var newOptions = {
	hostname: url.hostname,
	port: url.port,
	path: url.path,
	method: response.statusCode === 303 ? 'GET' : settings.method,
	headers: headers
	};

	if (ssl) {
	newOptions.pfx = opts.pfx;
	newOptions.key = opts.key;
	newOptions.passphrase = opts.passphrase;
	newOptions.cert = opts.cert;
	newOptions.ca = opts.ca;
	newOptions.ciphers = opts.ciphers;
	newOptions.rejectUnauthorized = opts.rejectUnauthorized;
	}

	// Issue the new request
	request = doRequest(newOptions, responseHandler).on('error', errorHandler);
	request.end();
	// @TODO Check if an XHR event needs to be fired here
	return;
	}

	if (response && response.setEncoding) {
	response.setEncoding("utf8");
	}

	setState(self.HEADERS_RECEIVED);
	self.status = response.statusCode;

	response.on('data', function(chunk) {
	// Make sure there's some data
	if (chunk) {
	self.responseText += chunk;
	}
	// Don't emit state changes if the connection has been aborted.
	if (sendFlag) {
	setState(self.LOADING);
	}
	});

	response.on('end', function() {
	if (sendFlag) {
	// The sendFlag needs to be set before setState is called. Otherwise if we are chaining callbacks
	// there can be a timing issue (the callback is called and a new call is made before the flag is reset).
	sendFlag = false;
	// Discard the 'end' event if the connection has been aborted
	setState(self.DONE);
	}
	});

	response.on('error', function(error) {
	self.handleError(error);
	});
	}

	// Error handler for the request
	var errorHandler = function(error) {
	self.handleError(error);
	}

	// Create the request
	request = doRequest(options, responseHandler).on('error', errorHandler);

	// Node 0.4 and later won't accept empty data. Make sure it's needed.
	if (data) {
	request.write(data);
	}

	request.end();

	self.dispatchEvent("loadstart");
	} else { // Synchronous
	// Create a temporary file for communication with the other Node process
	var contentFile = ".node-xmlhttprequest-content-" + process.pid;
	var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
	fs.writeFileSync(syncFile, "", "utf8");
	// The async request the other Node process executes
	var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
	+ "var doRequest = http" + (ssl ? "s" : "") + ".request;"
	+ "var options = " + JSON.stringify(options) + ";"
	+ "var responseText = '';"
	+ "var req = doRequest(options, function(response) {"
	+ "response.setEncoding('utf8');"
	+ "response.on('data', function(chunk) {"
	+ " responseText += chunk;"
	+ "});"
	+ "response.on('end', function() {"
	+ "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-STATUS:' + response.statusCode + ',' + responseText, 'utf8');"
	+ "fs.unlinkSync('" + syncFile + "');"
	+ "});"
	+ "response.on('error', function(error) {"
	+ "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
	+ "fs.unlinkSync('" + syncFile + "');"
	+ "});"
	+ "}).on('error', function(error) {"
	+ "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
	+ "fs.unlinkSync('" + syncFile + "');"
	+ "});"
	+ (data ? "req.write('" + data.replace(/'/g, "\\'") + "');":"")
	+ "req.end();";
	// Start the other Node Process, executing this string
	var syncProc = spawn(process.argv[0], ["-e", execString]);
	var statusText;
	while(fs.existsSync(syncFile)) {
	// Wait while the sync file is empty
	}
	self.responseText = fs.readFileSync(contentFile, 'utf8');
	// Kill the child process once the file has data
	syncProc.stdin.end();
	// Remove the temporary file
	fs.unlinkSync(contentFile);
	if (self.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
	// If the file returned an error, handle it
	var errorObj = self.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, "");
	self.handleError(errorObj);
	} else {
	// If the file returned okay, parse its data and move to the DONE state
	self.status = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:([0-9]),./, "$1");
	self.responseText = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:[0-9],(.)/, "$1");
	setState(self.DONE);
	}
	}
	};

	/**
	* Called when an error is encountered to deal with it.
	*/
	this.handleError = function(error) {
	this.status = 503;
	this.statusText = error;
	this.responseText = error.stack;
	errorFlag = true;
	setState(this.DONE);
	};

	/**
	* Aborts a request.
	*/
	this.abort = function() {
	if (request) {
	request.abort();
	request = null;
	}

	headers = Object.assign({}, defaultHeaders);
	this.responseText = "";
	this.responseXML = "";

	errorFlag = true;

	if (this.readyState !== this.UNSENT
	&& (this.readyState !== this.OPENED \|\| sendFlag)
	&& this.readyState !== this.DONE) {
	sendFlag = false;
	setState(this.DONE);
	}
	this.readyState = this.UNSENT;
	};

	/**
	* Adds an event listener. Preferred method of binding to events.
	*/
	this.addEventListener = function(event, callback) {
	if (!(event in listeners)) {
	listeners[event] = [];
	}
	// Currently allows duplicate callbacks. Should it?
	listeners[event].push(callback);
	};

	/**
	* Remove an event callback that has already been bound.
	* Only works on the matching funciton, cannot be a copy.
	*/
	this.removeEventListener = function(event, callback) {
	if (event in listeners) {
	// Filter will return a new array with the callback removed
	listeners[event] = listeners[event].filter(function(ev) {
	return ev !== callback;
	});
	}
	};

	/**
	* Dispatch any events, including both "on" methods and events attached using addEventListener.
	*/
	this.dispatchEvent = function(event) {
	if (typeof self["on" + event] === "function") {
	self["on" + event]();
	}
	if (event in listeners) {
	for (var i = 0, len = listeners[event].length; i < len; i++) {
	listeners[event][i].call(self);
	}
	}
	};

	/**
	* Changes readyState and calls onreadystatechange.
	*
	* @param int state New state
	*/
	var setState = function(state) {
	if (self.readyState !== state) {
	self.readyState = state;

	if (settings.async \|\| self.readyState < self.OPENED \|\| self.readyState === self.DONE) {
	self.dispatchEvent("readystatechange");
	}

	if (self.readyState === self.DONE && !errorFlag) {
	self.dispatchEvent("load");
	// @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
	self.dispatchEvent("loadend");
	}
	}
	};
	};