comunicationLeap/node_modules/xmlhttprequest/lib/XMLHttpRequest.js
node_modules/xmlhttprequest/lib/XMLHttpRequest.jsRaw
1/**
2 * Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
3 *
4 * This can be used with JS designed for browsers to improve reuse of code and
5 * allow the use of existing libraries.
6 *
7 * Usage: include("XMLHttpRequest.js") and use XMLHttpRequest per W3C specs.
8 *
9 * @author Dan DeFelippi <dan@driverdan.com>
10 * @contributor David Ellis <d.f.ellis@ieee.org>
11 * @license MIT
12 */
13
14var fs = require('fs');
15var Url = require('url');
16var spawn = require('child_process').spawn;
17
18/**
19 * Module exports.
20 */
21
22module.exports = XMLHttpRequest;
23
24// backwards-compat
25XMLHttpRequest.XMLHttpRequest = XMLHttpRequest;
26
27/**
28 * `XMLHttpRequest` constructor.
29 *
30 * Supported options for the `opts` object are:
31 *
32 * - `agent`: An http.Agent instance; http.globalAgent may be used; if 'undefined', agent usage is disabled
33 *
34 * @param {Object} opts optional "options" object
35 */
36
37function XMLHttpRequest(opts) {
38 /**
39 * Private variables
40 */
41 var self = this;
42 var http = require('http');
43 var https = require('https');
44
45 // Holds http.js objects
46 var request;
47 var response;
48
49 // Request settings
50 var settings = {};
51
52 // Disable header blacklist.
53 // Not part of XHR specs.
54 var disableHeaderCheck = false;
55
56 // Set some default headers
57 var defaultHeaders = {
58 "User-Agent": "node-XMLHttpRequest",
59 "Accept": "*/*"
60 };
61
62 var headers = defaultHeaders;
63
64 // These headers are not user setable.
65 // The following are allowed but banned in the spec:
66 // * user-agent
67 var forbiddenRequestHeaders = [
68 "accept-charset",
69 "accept-encoding",
70 "access-control-request-headers",
71 "access-control-request-method",
72 "connection",
73 "content-length",
74 "content-transfer-encoding",
75 "cookie",
76 "cookie2",
77 "date",
78 "expect",
79 "host",
80 "keep-alive",
81 "origin",
82 "referer",
83 "te",
84 "trailer",
85 "transfer-encoding",
86 "upgrade",
87 "via"
88 ];
89
90 // These request methods are not allowed
91 var forbiddenRequestMethods = [
92 "TRACE",
93 "TRACK",
94 "CONNECT"
95 ];
96
97 // Send flag
98 var sendFlag = false;
99 // Error flag, used when errors occur or abort is called
100 var errorFlag = false;
101
102 // Event listeners
103 var listeners = {};
104
105 /**
106 * Constants
107 */
108
109 this.UNSENT = 0;
110 this.OPENED = 1;
111 this.HEADERS_RECEIVED = 2;
112 this.LOADING = 3;
113 this.DONE = 4;
114
115 /**
116 * Public vars
117 */
118
119 // Current state
120 this.readyState = this.UNSENT;
121
122 // default ready state change handler in case one is not set or is set late
123 this.onreadystatechange = null;
124
125 // Result & response
126 this.responseText = "";
127 this.responseXML = "";
128 this.status = null;
129 this.statusText = null;
130
131 /**
132 * Private methods
133 */
134
135 /**
136 * Check if the specified header is allowed.
137 *
138 * @param string header Header to validate
139 * @return boolean False if not allowed, otherwise true
140 */
141 var isAllowedHttpHeader = function(header) {
142 return disableHeaderCheck || (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
143 };
144
145 /**
146 * Check if the specified method is allowed.
147 *
148 * @param string method Request method to validate
149 * @return boolean False if not allowed, otherwise true
150 */
151 var isAllowedHttpMethod = function(method) {
152 return (method && forbiddenRequestMethods.indexOf(method) === -1);
153 };
154
155 /**
156 * Public methods
157 */
158
159 /**
160 * Open the connection. Currently supports local server requests.
161 *
162 * @param string method Connection method (eg GET, POST)
163 * @param string url URL for the connection.
164 * @param boolean async Asynchronous connection. Default is true.
165 * @param string user Username for basic authentication (optional)
166 * @param string password Password for basic authentication (optional)
167 */
168 this.open = function(method, url, async, user, password) {
169 this.abort();
170 errorFlag = false;
171
172 // Check for valid request method
173 if (!isAllowedHttpMethod(method)) {
174 throw "SecurityError: Request method not allowed";
175 }
176
177 settings = {
178 "method": method,
179 "url": url.toString(),
180 "async": (typeof async !== "boolean" ? true : async),
181 "user": user || null,
182 "password": password || null
183 };
184
185 setState(this.OPENED);
186 };
187
188 /**
189 * Disables or enables isAllowedHttpHeader() check the request. Enabled by default.
190 * This does not conform to the W3C spec.
191 *
192 * @param boolean state Enable or disable header checking.
193 */
194 this.setDisableHeaderCheck = function(state) {
195 disableHeaderCheck = state;
196 };
197
198 /**
199 * Sets a header for the request.
200 *
201 * @param string header Header name
202 * @param string value Header value
203 */
204 this.setRequestHeader = function(header, value) {
205 if (this.readyState != this.OPENED) {
206 throw "INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN";
207 }
208 if (!isAllowedHttpHeader(header)) {
209 console.warn('Refused to set unsafe header "' + header + '"');
210 return;
211 }
212 if (sendFlag) {
213 throw "INVALID_STATE_ERR: send flag is true";
214 }
215 headers[header] = value;
216 };
217
218 /**
219 * Gets a header from the server response.
220 *
221 * @param string header Name of header to get.
222 * @return string Text of the header or null if it doesn't exist.
223 */
224 this.getResponseHeader = function(header) {
225 if (typeof header === "string"
226 && this.readyState > this.OPENED
227 && response.headers[header.toLowerCase()]
228 && !errorFlag
229 ) {
230 return response.headers[header.toLowerCase()];
231 }
232
233 return null;
234 };
235
236 /**
237 * Gets all the response headers.
238 *
239 * @return string A string with all response headers separated by CR+LF
240 */
241 this.getAllResponseHeaders = function() {
242 if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
243 return "";
244 }
245 var result = "";
246
247 for (var i in response.headers) {
248 // Cookie headers are excluded
249 if (i !== "set-cookie" && i !== "set-cookie2") {
250 result += i + ": " + response.headers[i] + "\r\n";
251 }
252 }
253 return result.substr(0, result.length - 2);
254 };
255
256 /**
257 * Gets a request header
258 *
259 * @param string name Name of header to get
260 * @return string Returns the request header or empty string if not set
261 */
262 this.getRequestHeader = function(name) {
263 // @TODO Make this case insensitive
264 if (typeof name === "string" && headers[name]) {
265 return headers[name];
266 }
267
268 return "";
269 };
270
271 /**
272 * Sends the request to the server.
273 *
274 * @param string data Optional data to send as request body.
275 */
276 this.send = function(data) {
277 if (this.readyState != this.OPENED) {
278 throw "INVALID_STATE_ERR: connection must be opened before send() is called";
279 }
280
281 if (sendFlag) {
282 throw "INVALID_STATE_ERR: send has already been called";
283 }
284
285 var ssl = false, local = false;
286 var url = Url.parse(settings.url);
287 var host;
288 // Determine the server
289 switch (url.protocol) {
290 case 'https:':
291 ssl = true;
292 // SSL & non-SSL both need host, no break here.
293 case 'http:':
294 host = url.hostname;
295 break;
296
297 case 'file:':
298 local = true;
299 break;
300
301 case undefined:
302 case '':
303 host = "localhost";
304 break;
305
306 default:
307 throw "Protocol not supported.";
308 }
309
310 // Load files off the local filesystem (file://)
311 if (local) {
312 if (settings.method !== "GET") {
313 throw "XMLHttpRequest: Only GET method is supported";
314 }
315
316 if (settings.async) {
317 fs.readFile(url.pathname, 'utf8', function(error, data) {
318 if (error) {
319 self.handleError(error);
320 } else {
321 self.status = 200;
322 self.responseText = data;
323 setState(self.DONE);
324 }
325 });
326 } else {
327 try {
328 this.responseText = fs.readFileSync(url.pathname, 'utf8');
329 this.status = 200;
330 setState(self.DONE);
331 } catch(e) {
332 this.handleError(e);
333 }
334 }
335
336 return;
337 }
338
339 // Default to port 80. If accessing localhost on another port be sure
340 // to use http://localhost:port/path
341 var port = url.port || (ssl ? 443 : 80);
342 // Add query string if one is used
343 var uri = url.pathname + (url.search ? url.search : '');
344
345 // Set the Host header or the server may reject the request
346 headers["Host"] = host;
347 if (!((ssl && port === 443) || port === 80)) {
348 headers["Host"] += ':' + url.port;
349 }
350
351 // Set Basic Auth if necessary
352 if (settings.user) {
353 if (typeof settings.password == "undefined") {
354 settings.password = "";
355 }
356 var authBuf = new Buffer(settings.user + ":" + settings.password);
357 headers["Authorization"] = "Basic " + authBuf.toString("base64");
358 }
359
360 // Set content length header
361 if (settings.method === "GET" || settings.method === "HEAD") {
362 data = null;
363 } else if (data) {
364 headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
365
366 if (!headers["Content-Type"]) {
367 headers["Content-Type"] = "text/plain;charset=UTF-8";
368 }
369 } else if (settings.method === "POST") {
370 // For a post with no data set Content-Length: 0.
371 // This is required by buggy servers that don't meet the specs.
372 headers["Content-Length"] = 0;
373 }
374
375 var agent = false;
376 if (opts && opts.agent) {
377 agent = opts.agent;
378 }
379 var options = {
380 host: host,
381 port: port,
382 path: uri,
383 method: settings.method,
384 headers: headers,
385 agent: agent
386 };
387
388 // Reset error flag
389 errorFlag = false;
390
391 // Handle async requests
392 if (settings.async) {
393 // Use the proper protocol
394 var doRequest = ssl ? https.request : http.request;
395
396 // Request is being sent, set send flag
397 sendFlag = true;
398
399 // As per spec, this is called here for historical reasons.
400 self.dispatchEvent("readystatechange");
401
402 // Handler for the response
403 function responseHandler(resp) {
404 // Set response var to the response we got back
405 // This is so it remains accessable outside this scope
406 response = resp;
407 // Check for redirect
408 // @TODO Prevent looped redirects
409 if (response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
410 // Change URL to the redirect location
411 settings.url = response.headers.location;
412 var url = Url.parse(settings.url);
413 // Set host var in case it's used later
414 host = url.hostname;
415 // Options for the new request
416 var newOptions = {
417 hostname: url.hostname,
418 port: url.port,
419 path: url.path,
420 method: response.statusCode === 303 ? 'GET' : settings.method,
421 headers: headers
422 };
423
424 // Issue the new request
425 request = doRequest(newOptions, responseHandler).on('error', errorHandler);
426 request.end();
427 // @TODO Check if an XHR event needs to be fired here
428 return;
429 }
430
431 response.setEncoding("utf8");
432
433 setState(self.HEADERS_RECEIVED);
434 self.status = response.statusCode;
435
436 response.on('data', function(chunk) {
437 // Make sure there's some data
438 if (chunk) {
439 self.responseText += chunk;
440 }
441 // Don't emit state changes if the connection has been aborted.
442 if (sendFlag) {
443 setState(self.LOADING);
444 }
445 });
446
447 response.on('end', function() {
448 if (sendFlag) {
449 // Discard the 'end' event if the connection has been aborted
450 setState(self.DONE);
451 sendFlag = false;
452 }
453 });
454
455 response.on('error', function(error) {
456 self.handleError(error);
457 });
458 }
459
460 // Error handler for the request
461 function errorHandler(error) {
462 self.handleError(error);
463 }
464
465 // Create the request
466 request = doRequest(options, responseHandler).on('error', errorHandler);
467
468 // Node 0.4 and later won't accept empty data. Make sure it's needed.
469 if (data) {
470 request.write(data);
471 }
472
473 request.end();
474
475 self.dispatchEvent("loadstart");
476 } else { // Synchronous
477 // Create a temporary file for communication with the other Node process
478 var contentFile = ".node-xmlhttprequest-content-" + process.pid;
479 var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
480 fs.writeFileSync(syncFile, "", "utf8");
481 // The async request the other Node process executes
482 var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
483 + "var doRequest = http" + (ssl ? "s" : "") + ".request;"
484 + "var options = " + JSON.stringify(options) + ";"
485 + "var responseText = '';"
486 + "var req = doRequest(options, function(response) {"
487 + "response.setEncoding('utf8');"
488 + "response.on('data', function(chunk) {"
489 + " responseText += chunk;"
490 + "});"
491 + "response.on('end', function() {"
492 + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-STATUS:' + response.statusCode + ',' + responseText, 'utf8');"
493 + "fs.unlinkSync('" + syncFile + "');"
494 + "});"
495 + "response.on('error', function(error) {"
496 + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
497 + "fs.unlinkSync('" + syncFile + "');"
498 + "});"
499 + "}).on('error', function(error) {"
500 + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
501 + "fs.unlinkSync('" + syncFile + "');"
502 + "});"
503 + (data ? "req.write('" + data.replace(/'/g, "\\'") + "');":"")
504 + "req.end();";
505 // Start the other Node Process, executing this string
506 var syncProc = spawn(process.argv[0], ["-e", execString]);
507 var statusText;
508 while(fs.existsSync(syncFile)) {
509 // Wait while the sync file is empty
510 }
511 self.responseText = fs.readFileSync(contentFile, 'utf8');
512 // Kill the child process once the file has data
513 syncProc.stdin.end();
514 // Remove the temporary file
515 fs.unlinkSync(contentFile);
516 if (self.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
517 // If the file returned an error, handle it
518 var errorObj = self.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, "");
519 self.handleError(errorObj);
520 } else {
521 // If the file returned okay, parse its data and move to the DONE state
522 self.status = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:([0-9]*),.*/, "$1");
523 self.responseText = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:[0-9]*,(.*)/, "$1");
524 setState(self.DONE);
525 }
526 }
527 };
528
529 /**
530 * Called when an error is encountered to deal with it.
531 */
532 this.handleError = function(error) {
533 this.status = 503;
534 this.statusText = error;
535 this.responseText = error.stack;
536 errorFlag = true;
537 setState(this.DONE);
538 };
539
540 /**
541 * Aborts a request.
542 */
543 this.abort = function() {
544 if (request) {
545 request.abort();
546 request = null;
547 }
548
549 headers = defaultHeaders;
550 this.responseText = "";
551 this.responseXML = "";
552
553 errorFlag = true;
554
555 if (this.readyState !== this.UNSENT
556 && (this.readyState !== this.OPENED || sendFlag)
557 && this.readyState !== this.DONE) {
558 sendFlag = false;
559 setState(this.DONE);
560 }
561 this.readyState = this.UNSENT;
562 };
563
564 /**
565 * Adds an event listener. Preferred method of binding to events.
566 */
567 this.addEventListener = function(event, callback) {
568 if (!(event in listeners)) {
569 listeners[event] = [];
570 }
571 // Currently allows duplicate callbacks. Should it?
572 listeners[event].push(callback);
573 };
574
575 /**
576 * Remove an event callback that has already been bound.
577 * Only works on the matching funciton, cannot be a copy.
578 */
579 this.removeEventListener = function(event, callback) {
580 if (event in listeners) {
581 // Filter will return a new array with the callback removed
582 listeners[event] = listeners[event].filter(function(ev) {
583 return ev !== callback;
584 });
585 }
586 };
587
588 /**
589 * Dispatch any events, including both "on" methods and events attached using addEventListener.
590 */
591 this.dispatchEvent = function(event) {
592 if (typeof self["on" + event] === "function") {
593 self["on" + event]();
594 }
595 if (event in listeners) {
596 for (var i = 0, len = listeners[event].length; i < len; i++) {
597 listeners[event][i].call(self);
598 }
599 }
600 };
601
602 /**
603 * Changes readyState and calls onreadystatechange.
604 *
605 * @param int state New state
606 */
607 var setState = function(state) {
608 if (self.readyState !== state) {
609 self.readyState = state;
610
611 if (settings.async || self.readyState < self.OPENED || self.readyState === self.DONE) {
612 self.dispatchEvent("readystatechange");
613 }
614
615 if (self.readyState === self.DONE && !errorFlag) {
616 self.dispatchEvent("load");
617 // @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
618 self.dispatchEvent("loadend");
619 }
620 }
621 };
622};