CSE2410 Fall 2014 Bounce

// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

var util = require('util');

var net = require('net');

var Stream = require('stream');

var url = require('url');

var EventEmitter = require('events').EventEmitter;

var FreeList = require('freelist').FreeList;

var HTTPParser = process.binding('http_parser').HTTPParser;

var assert = require('assert').ok;

var END_OF_FILE = {};

var debug;

if (process.env.NODE_DEBUG && /http/.test(process.env.NODE_DEBUG)) {

  debug = function(x) { console.error('HTTP: %s', x); };

} else {

  debug = function() { };

}

// Only called in the slow case where slow means

// that the request headers were either fragmented

// across multiple TCP packets or too large to be

// processed in a single run. This method is also

// called to process trailing HTTP headers.

function parserOnHeaders(headers, url) {

  // Once we exceeded headers limit - stop collecting them

  if (this.maxHeaderPairs <= 0 ||

      this._headers.length < this.maxHeaderPairs) {

    this._headers = this._headers.concat(headers);

  }

  this._url += url;

}

// info.headers and info.url are set only if .onHeaders()

// has not been called for this request.

//

// info.url is not set for response parsers but that's not

// applicable here since all our parsers are request parsers.

function parserOnHeadersComplete(info) {

  var parser = this;

  var headers = info.headers;

  var url = info.url;

  if (!headers) {

    headers = parser._headers;

    parser._headers = [];

  }

  if (!url) {

    url = parser._url;

    parser._url = '';

  }

  parser.incoming = new IncomingMessage(parser.socket);

  parser.incoming.httpVersionMajor = info.versionMajor;

  parser.incoming.httpVersionMinor = info.versionMinor;

  parser.incoming.httpVersion = info.versionMajor + '.' + info.versionMinor;

  parser.incoming.url = url;

  var n = headers.length;

  // If parser.maxHeaderPairs <= 0 - assume that there're no limit

  if (parser.maxHeaderPairs > 0) {

    n = Math.min(n, parser.maxHeaderPairs);

  }

  for (var i = 0; i < n; i += 2) {

    var k = headers[i];

    var v = headers[i + 1];

    parser.incoming._addHeaderLine(k, v);

  }

  if (info.method) {

    // server only

    parser.incoming.method = info.method;

  } else {

    // client only

    parser.incoming.statusCode = info.statusCode;

    // CHECKME dead code? we're always a request parser

  }

  parser.incoming.upgrade = info.upgrade;

  var skipBody = false; // response to HEAD or CONNECT

  if (!info.upgrade) {

    // For upgraded connections and CONNECT method request,

    // we'll emit this after parser.execute

    // so that we can capture the first part of the new protocol

    skipBody = parser.onIncoming(parser.incoming, info.shouldKeepAlive);

  }

  return skipBody;

}

function parserOnBody(b, start, len) {

  var parser = this;

  var slice = b.slice(start, start + len);

  if (parser.incoming._paused || parser.incoming._pendings.length) {

    parser.incoming._pendings.push(slice);

  } else {

    parser.incoming._emitData(slice);

  }

}

function parserOnMessageComplete() {

  var parser = this;

  parser.incoming.complete = true;

  // Emit any trailing headers.

  var headers = parser._headers;

  if (headers) {

    for (var i = 0, n = headers.length; i < n; i += 2) {

      var k = headers[i];

      var v = headers[i + 1];

      parser.incoming._addHeaderLine(k, v);

    }

    parser._headers = [];

    parser._url = '';

  }

  if (!parser.incoming.upgrade) {

    // For upgraded connections, also emit this after parser.execute

    if (parser.incoming._paused || parser.incoming._pendings.length) {

      parser.incoming._pendings.push(END_OF_FILE);

    } else {

      parser.incoming.readable = false;

      parser.incoming._emitEnd();

    }

  }

  if (parser.socket.readable) {

    // force to read the next incoming message

    parser.socket.resume();

  }

}

var parsers = new FreeList('parsers', 1000, function() {

  var parser = new HTTPParser(HTTPParser.REQUEST);

  parser._headers = [];

  parser._url = '';

  // Only called in the slow case where slow means

  // that the request headers were either fragmented

  // across multiple TCP packets or too large to be

  // processed in a single run. This method is also

  // called to process trailing HTTP headers.

  parser.onHeaders = parserOnHeaders;

  parser.onHeadersComplete = parserOnHeadersComplete;

  parser.onBody = parserOnBody;

  parser.onMessageComplete = parserOnMessageComplete;

  return parser;

});

exports.parsers = parsers;

var CRLF = '\r\n';

var STATUS_CODES = exports.STATUS_CODES = {

  100 : 'Continue',

  101 : 'Switching Protocols',

  102 : 'Processing',                 // RFC 2518, obsoleted by RFC 4918

  200 : 'OK',

  201 : 'Created',

  202 : 'Accepted',

  203 : 'Non-Authoritative Information',

  204 : 'No Content',

  205 : 'Reset Content',

  206 : 'Partial Content',

  207 : 'Multi-Status',               // RFC 4918

  300 : 'Multiple Choices',

  301 : 'Moved Permanently',

  302 : 'Moved Temporarily',

  303 : 'See Other',

  304 : 'Not Modified',

  305 : 'Use Proxy',

  307 : 'Temporary Redirect',

  400 : 'Bad Request',

  401 : 'Unauthorized',

  402 : 'Payment Required',

  403 : 'Forbidden',

  404 : 'Not Found',

  405 : 'Method Not Allowed',

  406 : 'Not Acceptable',

  407 : 'Proxy Authentication Required',

  408 : 'Request Time-out',

  409 : 'Conflict',

  410 : 'Gone',

  411 : 'Length Required',

  412 : 'Precondition Failed',

  413 : 'Request Entity Too Large',

  414 : 'Request-URI Too Large',

  415 : 'Unsupported Media Type',

  416 : 'Requested Range Not Satisfiable',

  417 : 'Expectation Failed',

  418 : 'I\'m a teapot',              // RFC 2324

  422 : 'Unprocessable Entity',       // RFC 4918

  423 : 'Locked',                     // RFC 4918

  424 : 'Failed Dependency',          // RFC 4918

  425 : 'Unordered Collection',       // RFC 4918

  426 : 'Upgrade Required',           // RFC 2817

  428 : 'Precondition Required',      // RFC 6585

  429 : 'Too Many Requests',          // RFC 6585

  431 : 'Request Header Fields Too Large',// RFC 6585

  500 : 'Internal Server Error',

  501 : 'Not Implemented',

  502 : 'Bad Gateway',

  503 : 'Service Unavailable',

  504 : 'Gateway Time-out',

  505 : 'HTTP Version not supported',

  506 : 'Variant Also Negotiates',    // RFC 2295

  507 : 'Insufficient Storage',       // RFC 4918

  509 : 'Bandwidth Limit Exceeded',

  510 : 'Not Extended',               // RFC 2774

  511 : 'Network Authentication Required' // RFC 6585

};

var connectionExpression = /Connection/i;

var transferEncodingExpression = /Transfer-Encoding/i;

var closeExpression = /close/i;

var chunkExpression = /chunk/i;

var contentLengthExpression = /Content-Length/i;

var dateExpression = /Date/i;

var expectExpression = /Expect/i;

var continueExpression = /100-continue/i;

var dateCache;

function utcDate() {

  if (!dateCache) {

    var d = new Date();

    dateCache = d.toUTCString();

    setTimeout(function() {

      dateCache = undefined;

    }, 1000 - d.getMilliseconds());

  }

  return dateCache;

}

/* Abstract base class for ServerRequest and ClientResponse. */

function IncomingMessage(socket) {

  Stream.call(this);

  // TODO Remove one of these eventually.

  this.socket = socket;

  this.connection = socket;

  this.httpVersion = null;

  this.complete = false;

  this.headers = {};

  this.trailers = {};

  this.readable = true;

  this._paused = false;

  this._pendings = [];

  this._endEmitted = false;

  // request (server) only

  this.url = '';

  this.method = null;

  // response (client) only

  this.statusCode = null;

  this.client = this.socket;

}

util.inherits(IncomingMessage, Stream);

exports.IncomingMessage = IncomingMessage;

IncomingMessage.prototype.destroy = function(error) {

  this.socket.destroy(error);

};

IncomingMessage.prototype.setEncoding = function(encoding) {

  var StringDecoder = require('string_decoder').StringDecoder; // lazy load

  this._decoder = new StringDecoder(encoding);

};

IncomingMessage.prototype.pause = function() {

  this._paused = true;

  this.socket.pause();

};

IncomingMessage.prototype.resume = function() {

  this._paused = false;

  if (this.socket) {

    this.socket.resume();

  }

  this._emitPending();

};

IncomingMessage.prototype._emitPending = function(callback) {

  if (this._pendings.length) {

    var self = this;

    process.nextTick(function() {

      while (!self._paused && self._pendings.length) {

        var chunk = self._pendings.shift();

        if (chunk !== END_OF_FILE) {

          assert(Buffer.isBuffer(chunk));

          self._emitData(chunk);

        } else {

          assert(self._pendings.length === 0);

          self.readable = false;

          self._emitEnd();

        }

      }

      if (callback) {

        callback();

      }

    });

  } else if (callback) {

    callback();

  }

};

IncomingMessage.prototype._emitData = function(d) {

  if (this._decoder) {

    var string = this._decoder.write(d);

    if (string.length) {

      this.emit('data', string);

    }

  } else {

    this.emit('data', d);

  }

};

IncomingMessage.prototype._emitEnd = function() {

  if (!this._endEmitted) {

    this.emit('end');

  }

  this._endEmitted = true;

};

// Add the given (field, value) pair to the message

//

// Per RFC2616, section 4.2 it is acceptable to join multiple instances of the

// same header with a ', ' if the header in question supports specification of

// multiple values this way. If not, we declare the first instance the winner

// and drop the second. Extended header fields (those beginning with 'x-') are

// always joined.

IncomingMessage.prototype._addHeaderLine = function(field, value) {

  var dest = this.complete ? this.trailers : this.headers;

  field = field.toLowerCase();

  switch (field) {

    // Array headers:

    case 'set-cookie':

      if (field in dest) {

        dest[field].push(value);

      } else {

        dest[field] = [value];

      }

      break;

    // Comma separate. Maybe make these arrays?

    case 'accept':

    case 'accept-charset':

    case 'accept-encoding':

    case 'accept-language':

    case 'connection':

    case 'cookie':

    case 'pragma':

    case 'link':

    case 'www-authenticate':

    case 'sec-websocket-extensions':

    case 'sec-websocket-protocol':

      if (field in dest) {

        dest[field] += ', ' + value;

      } else {

        dest[field] = value;

      }

      break;

    default:

      if (field.slice(0, 2) == 'x-') {

        // except for x-

        if (field in dest) {

          dest[field] += ', ' + value;

        } else {

          dest[field] = value;

        }

      } else {

        // drop duplicates

        if (!(field in dest)) dest[field] = value;

      }

      break;

  }

};

function OutgoingMessage() {

  Stream.call(this);

  this.output = [];

  this.outputEncodings = [];

  this.writable = true;

  this._last = false;

  this.chunkedEncoding = false;

  this.shouldKeepAlive = true;

  this.useChunkedEncodingByDefault = true;

  this.sendDate = false;

  this._hasBody = true;

  this._trailer = '';

  this.finished = false;

}

util.inherits(OutgoingMessage, Stream);

exports.OutgoingMessage = OutgoingMessage;

OutgoingMessage.prototype.destroy = function(error) {

  this.socket.destroy(error);

};

// This abstract either writing directly to the socket or buffering it.

OutgoingMessage.prototype._send = function(data, encoding) {

  // This is a shameful hack to get the headers and first body chunk onto

  // the same packet. Future versions of Node are going to take care of

  // this at a lower level and in a more general way.

  if (!this._headerSent) {

    if (typeof data === 'string') {

      data = this._header + data;

    } else {

      this.output.unshift(this._header);

      this.outputEncodings.unshift('ascii');

    }

    this._headerSent = true;

  }

  return this._writeRaw(data, encoding);

};

OutgoingMessage.prototype._writeRaw = function(data, encoding) {

  if (data.length === 0) {

    return true;

  }

  if (this.connection &&

      this.connection._httpMessage === this &&

      this.connection.writable) {

    // There might be pending data in the this.output buffer.

    while (this.output.length) {

      if (!this.connection.writable) {

        this._buffer(data, encoding);

        return false;

      }

      var c = this.output.shift();

      var e = this.outputEncodings.shift();

      this.connection.write(c, e);

    }

    // Directly write to socket.

    return this.connection.write(data, encoding);

  } else {

    this._buffer(data, encoding);

    return false;

  }

};

OutgoingMessage.prototype._buffer = function(data, encoding) {

  if (data.length === 0) return;

  var length = this.output.length;

  if (length === 0 || typeof data != 'string') {

    this.output.push(data);

    this.outputEncodings.push(encoding);

    return false;

  }

  var lastEncoding = this.outputEncodings[length - 1];

  var lastData = this.output[length - 1];

  if ((encoding && lastEncoding === encoding) ||

      (!encoding && data.constructor === lastData.constructor)) {

    this.output[length - 1] = lastData + data;

    return false;

  }

  this.output.push(data);

  this.outputEncodings.push(encoding);

  return false;

};

OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {

  var sentConnectionHeader = false;

  var sentContentLengthHeader = false;

  var sentTransferEncodingHeader = false;

  var sentDateHeader = false;

  var sentExpect = false;

  // firstLine in the case of request is: 'GET /index.html HTTP/1.1\r\n'

  // in the case of response it is: 'HTTP/1.1 200 OK\r\n'

  var messageHeader = firstLine;

  var field, value;

  var self = this;

  function store(field, value) {

    messageHeader += field + ': ' + value + CRLF;

    if (connectionExpression.test(field)) {

      sentConnectionHeader = true;

      if (closeExpression.test(value)) {

        self._last = true;

      } else {

        self.shouldKeepAlive = true;

      }

    } else if (transferEncodingExpression.test(field)) {

      sentTransferEncodingHeader = true;

      if (chunkExpression.test(value)) self.chunkedEncoding = true;

    } else if (contentLengthExpression.test(field)) {

      sentContentLengthHeader = true;

    } else if (dateExpression.test(field)) {

      sentDateHeader = true;

    } else if (expectExpression.test(field)) {

      sentExpect = true;

    }

  }

  if (headers) {

    var keys = Object.keys(headers);

    var isArray = (Array.isArray(headers));

    var field, value;

    for (var i = 0, l = keys.length; i < l; i++) {

      var key = keys[i];

      if (isArray) {

        field = headers[key][0];

        value = headers[key][1];

      } else {

        field = key;

        value = headers[key];

      }

      if (Array.isArray(value)) {

        for (var j = 0; j < value.length; j++) {

          store(field, value[j]);

        }

      } else {

        store(field, value);

      }

    }

  }

  // Date header

  if (this.sendDate == true && sentDateHeader == false) {

    messageHeader += 'Date: ' + utcDate() + CRLF;

  }

  // keep-alive logic

  if (sentConnectionHeader === false) {

    var shouldSendKeepAlive = this.shouldKeepAlive &&

        (sentContentLengthHeader ||

         this.useChunkedEncodingByDefault ||

         this.agent);

    if (shouldSendKeepAlive) {

      messageHeader += 'Connection: keep-alive\r\n';

    } else {

      this._last = true;

      messageHeader += 'Connection: close\r\n';

    }

  }

  if (sentContentLengthHeader == false && sentTransferEncodingHeader == false) {

    if (this._hasBody) {

      if (this.useChunkedEncodingByDefault) {

        messageHeader += 'Transfer-Encoding: chunked\r\n';

        this.chunkedEncoding = true;

      } else {

        this._last = true;

      }

    } else {

      // Make sure we don't end the 0\r\n\r\n at the end of the message.

      this.chunkedEncoding = false;

    }

  }

  this._header = messageHeader + CRLF;

  this._headerSent = false;

  // wait until the first body chunk, or close(), is sent to flush,

  // UNLESS we're sending Expect: 100-continue.

  if (sentExpect) this._send('');

};

OutgoingMessage.prototype.setHeader = function(name, value) {

  if (arguments.length < 2) {

    throw new Error('`name` and `value` are required for setHeader().');

  }

  if (this._header) {

    throw new Error('Can\'t set headers after they are sent.');

  }

  var key = name.toLowerCase();

  this._headers = this._headers || {};

  this._headerNames = this._headerNames || {};

  this._headers[key] = value;

  this._headerNames[key] = name;

};

OutgoingMessage.prototype.getHeader = function(name) {

  if (arguments.length < 1) {

    throw new Error('`name` is required for getHeader().');

  }

  if (!this._headers) return;

  var key = name.toLowerCase();

  return this._headers[key];

};

OutgoingMessage.prototype.removeHeader = function(name) {

  if (arguments.length < 1) {

    throw new Error('`name` is required for removeHeader().');

  }

  if (this._header) {

    throw new Error('Can\'t remove headers after they are sent.');

  }

  if (!this._headers) return;

  var key = name.toLowerCase();

  delete this._headers[key];

  delete this._headerNames[key];

};

OutgoingMessage.prototype._renderHeaders = function() {

  if (this._header) {

    throw new Error('Can\'t render headers after they are sent to the client.');

  }

  if (!this._headers) return {};

  var headers = {};

  var keys = Object.keys(this._headers);

  for (var i = 0, l = keys.length; i < l; i++) {

    var key = keys[i];

    headers[this._headerNames[key]] = this._headers[key];

  }

  return headers;

};

OutgoingMessage.prototype.write = function(chunk, encoding) {

  if (!this._header) {

    this._implicitHeader();

  }

  if (!this._hasBody) {

    debug('This type of response MUST NOT have a body. ' +

          'Ignoring write() calls.');

    return true;

  }

  if (typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) {

    throw new TypeError('first argument must be a string or Buffer');

  }

  if (chunk.length === 0) return false;

  var len, ret;

  if (this.chunkedEncoding) {

    if (typeof(chunk) === 'string') {

      len = Buffer.byteLength(chunk, encoding);

      chunk = len.toString(16) + CRLF + chunk + CRLF;

      ret = this._send(chunk, encoding);

    } else {

      // buffer

      len = chunk.length;

      this._send(len.toString(16) + CRLF);

      this._send(chunk);

      ret = this._send(CRLF);

    }

  } else {

    ret = this._send(chunk, encoding);

  }

  debug('write ret = ' + ret);

  return ret;

};

OutgoingMessage.prototype.addTrailers = function(headers) {

  this._trailer = '';

  var keys = Object.keys(headers);

  var isArray = (Array.isArray(headers));

  var field, value;

  for (var i = 0, l = keys.length; i < l; i++) {

    var key = keys[i];

    if (isArray) {

      field = headers[key][0];

      value = headers[key][1];

    } else {

      field = key;

      value = headers[key];

    }

    this._trailer += field + ': ' + value + CRLF;

  }

};

OutgoingMessage.prototype.end = function(data, encoding) {

  if (this.finished) {

    return false;

  }

  if (!this._header) {

    this._implicitHeader();

  }

  if (data && !this._hasBody) {

    debug('This type of response MUST NOT have a body. ' +

          'Ignoring data passed to end().');

    data = false;

  }

  var ret;

  var hot = this._headerSent === false &&

            typeof(data) === 'string' &&

            data.length > 0 &&

            this.output.length === 0 &&

            this.connection &&

            this.connection.writable &&

            this.connection._httpMessage === this;

  if (hot) {

    // Hot path. They're doing

    //   res.writeHead();

    //   res.end(blah);

    // HACKY.

    if (this.chunkedEncoding) {

      var l = Buffer.byteLength(data, encoding).toString(16);

      ret = this.connection.write(this._header + l + CRLF +

                                  data + '\r\n0\r\n' +

                                  this._trailer + '\r\n', encoding);

    } else {

      ret = this.connection.write(this._header + data, encoding);

    }

    this._headerSent = true;

  } else if (data) {

    // Normal body write.

    ret = this.write(data, encoding);

  }

  if (!hot) {

    if (this.chunkedEncoding) {

      ret = this._send('0\r\n' + this._trailer + '\r\n'); // Last chunk.

    } else {

      // Force a flush, HACK.

      ret = this._send('');

    }

  }

  this.finished = true;

  // There is the first message on the outgoing queue, and we've sent

  // everything to the socket.

  debug('outgoing message end.');

  if (this.output.length === 0 && this.connection._httpMessage === this) {

    this._finish();

  }

  return ret;

};

OutgoingMessage.prototype._finish = function() {

  assert(this.connection);

  if (this instanceof ServerResponse) {

    DTRACE_HTTP_SERVER_RESPONSE(this.connection);

  } else {

    assert(this instanceof ClientRequest);

    DTRACE_HTTP_CLIENT_REQUEST(this, this.connection);

  }

  this.emit('finish');

};

OutgoingMessage.prototype._flush = function() {

  // This logic is probably a bit confusing. Let me explain a bit:

  //

  // In both HTTP servers and clients it is possible to queue up several

  // outgoing messages. This is easiest to imagine in the case of a client.

  // Take the following situation:

  //

  //    req1 = client.request('GET', '/');

  //    req2 = client.request('POST', '/');

  //

  // When the user does

  //

  //   req2.write('hello world\n');

  //

  // it's possible that the first request has not been completely flushed to

  // the socket yet. Thus the outgoing messages need to be prepared to queue

  // up data internally before sending it on further to the socket's queue.

  //

  // This function, outgoingFlush(), is called by both the Server and Client

  // to attempt to flush any pending messages out to the socket.

  if (!this.socket) return;

  var ret;

  while (this.output.length) {

    if (!this.socket.writable) return; // XXX Necessary?

    var data = this.output.shift();

    var encoding = this.outputEncodings.shift();

    ret = this.socket.write(data, encoding);

  }

  if (this.finished) {

    // This is a queue to the server or client to bring in the next this.

    this._finish();

  } else if (ret) {

    // This is necessary to prevent https from breaking

    this.emit('drain');

  }

};

function ServerResponse(req) {

  OutgoingMessage.call(this);

  if (req.method === 'HEAD') this._hasBody = false;

  this.sendDate = true;

  if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {

    this.useChunkedEncodingByDefault = false;

    this.shouldKeepAlive = false;

  }

}

util.inherits(ServerResponse, OutgoingMessage);

exports.ServerResponse = ServerResponse;

ServerResponse.prototype.statusCode = 200;

function onServerResponseClose() {

  this._httpMessage.emit('close');

}

ServerResponse.prototype.assignSocket = function(socket) {

  assert(!socket._httpMessage);

  socket._httpMessage = this;

  socket.on('close', onServerResponseClose);

  this.socket = socket;

  this.connection = socket;

  this._flush();

};

ServerResponse.prototype.detachSocket = function(socket) {

  assert(socket._httpMessage == this);

  socket.removeListener('close', onServerResponseClose);

  socket._httpMessage = null;

  this.socket = this.connection = null;

};

ServerResponse.prototype.writeContinue = function() {

  this._writeRaw('HTTP/1.1 100 Continue' + CRLF + CRLF, 'ascii');

  this._sent100 = true;

};

ServerResponse.prototype._implicitHeader = function() {

  this.writeHead(this.statusCode);

};

ServerResponse.prototype.writeHead = function(statusCode) {

  var reasonPhrase, headers, headerIndex;

  if (typeof arguments[1] == 'string') {

    reasonPhrase = arguments[1];

    headerIndex = 2;

  } else {

    reasonPhrase = STATUS_CODES[statusCode] || 'unknown';

    headerIndex = 1;

  }

  this.statusCode = statusCode;

  var obj = arguments[headerIndex];

  if (obj && this._headers) {

    // Slow-case: when progressive API and header fields are passed.

    headers = this._renderHeaders();

    if (Array.isArray(obj)) {

      // handle array case

      // TODO: remove when array is no longer accepted

      var field;

      for (var i = 0, len = obj.length; i < len; ++i) {

        field = obj[i][0];

        if (field in headers) {

          obj.push([field, headers[field]]);

        }

      }

      headers = obj;

    } else {

      // handle object case

      var keys = Object.keys(obj);

      for (var i = 0; i < keys.length; i++) {

        var k = keys[i];

        if (k) headers[k] = obj[k];

      }

    }

  } else if (this._headers) {

    // only progressive api is used

    headers = this._renderHeaders();

  } else {

    // only writeHead() called

    headers = obj;

  }

  var statusLine = 'HTTP/1.1 ' + statusCode.toString() + ' ' +

                   reasonPhrase + CRLF;

  if (statusCode === 204 || statusCode === 304 ||

      (100 <= statusCode && statusCode <= 199)) {

    // RFC 2616, 10.2.5:

    // The 204 response MUST NOT include a message-body, and thus is always

    // terminated by the first empty line after the header fields.

    // RFC 2616, 10.3.5:

    // The 304 response MUST NOT contain a message-body, and thus is always

    // terminated by the first empty line after the header fields.

    // RFC 2616, 10.1 Informational 1xx:

    // This class of status code indicates a provisional response,

    // consisting only of the Status-Line and optional headers, and is

    // terminated by an empty line.

    this._hasBody = false;

  }

  // don't keep alive connections where the client expects 100 Continue

  // but we sent a final status; they may put extra bytes on the wire.

  if (this._expect_continue && ! this._sent100) {

    this.shouldKeepAlive = false;

  }

  this._storeHeader(statusLine, headers);

};

ServerResponse.prototype.writeHeader = function() {

  this.writeHead.apply(this, arguments);

};

// New Agent code.

// The largest departure from the previous implementation is that

// an Agent instance holds connections for a variable number of host:ports.

// Surprisingly, this is still API compatible as far as third parties are

// concerned. The only code that really notices the difference is the

// request object.

// Another departure is that all code related to HTTP parsing is in

// ClientRequest.onSocket(). The Agent is now *strictly*

// concerned with managing a connection pool.

function Agent(options) {

  EventEmitter.call(this);

  var self = this;

  self.options = options || {};

  self.requests = {};

  self.sockets = {};

  self.maxSockets = self.options.maxSockets || Agent.defaultMaxSockets;

  self.on('free', function(socket, host, port, localAddress) {

    var name = host + ':' + port;

    if (localAddress) {

      name += ':' + localAddress;

    }

    if (self.requests[name] && self.requests[name].length) {

      self.requests[name].shift().onSocket(socket);

      if (self.requests[name].length === 0) {

        // don't leak

        delete self.requests[name];

      }

    } else {

      // If there are no pending requests just destroy the

      // socket and it will get removed from the pool. This

      // gets us out of timeout issues and allows us to

      // default to Connection:keep-alive.

      socket.destroy();

    }

  });

  self.createConnection = net.createConnection;

}

util.inherits(Agent, EventEmitter);

exports.Agent = Agent;

Agent.defaultMaxSockets = 5;

Agent.prototype.defaultPort = 80;

Agent.prototype.addRequest = function(req, host, port, localAddress) {

  var name = host + ':' + port;

  if (localAddress) {

    name += ':' + localAddress;

  }

  if (!this.sockets[name]) {

    this.sockets[name] = [];

  }

  if (this.sockets[name].length < this.maxSockets) {

    // If we are under maxSockets create a new one.

    req.onSocket(this.createSocket(name, host, port, localAddress, req));

  } else {

    // We are over limit so we'll add it to the queue.

    if (!this.requests[name]) {

      this.requests[name] = [];

    }

    this.requests[name].push(req);

  }

};

Agent.prototype.createSocket = function(name, host, port, localAddress, req) {

  var self = this;

  var options = util._extend({}, self.options);

  options.port = port;

  options.host = host;

  options.localAddress = localAddress;

  options.servername = host;

  if (req) {

    var hostHeader = req.getHeader('host');

    if (hostHeader) {

      options.servername = hostHeader.replace(/:.*$/, '');

    }

  }

  var s = self.createConnection(options);

  if (!self.sockets[name]) {

    self.sockets[name] = [];

  }

  this.sockets[name].push(s);

  var onFree = function() {

    self.emit('free', s, host, port, localAddress);

  }

  s.on('free', onFree);

  var onClose = function(err) {

    // This is the only place where sockets get removed from the Agent.

    // If you want to remove a socket from the pool, just close it.

    // All socket errors end in a close event anyway.

    self.removeSocket(s, name, host, port, localAddress);

  }

  s.on('close', onClose);

  var onRemove = function() {

    // We need this function for cases like HTTP 'upgrade'

    // (defined by WebSockets) where we need to remove a socket from the pool

    //  because it'll be locked up indefinitely

    self.removeSocket(s, name, host, port, localAddress);

    s.removeListener('close', onClose);

    s.removeListener('free', onFree);

    s.removeListener('agentRemove', onRemove);

  }

  s.on('agentRemove', onRemove);

  return s;

};

Agent.prototype.removeSocket = function(s, name, host, port, localAddress) {

  if (this.sockets[name]) {

    var index = this.sockets[name].indexOf(s);

    if (index !== -1) {

      this.sockets[name].splice(index, 1);

      if (this.sockets[name].length === 0) {

        // don't leak

        delete this.sockets[name];

      }

    }

  }

  if (this.requests[name] && this.requests[name].length) {

    var req = this.requests[name][0];

    // If we have pending requests and a socket gets closed a new one

    this.createSocket(name, host, port, localAddress, req).emit('free');

  }

};

var globalAgent = new Agent();

exports.globalAgent = globalAgent;

function ClientRequest(options, cb) {

  var self = this;

  OutgoingMessage.call(self);

  self.agent = options.agent === undefined ? globalAgent : options.agent;

  var defaultPort = options.defaultPort || 80;

  var port = options.port || defaultPort;

  var host = options.hostname || options.host || 'localhost';

  if (options.setHost === undefined) {

    var setHost = true;

  }

  self.socketPath = options.socketPath;

  var method = self.method = (options.method || 'GET').toUpperCase();

  self.path = options.path || '/';

  if (cb) {

    self.once('response', cb);

  }

  if (!Array.isArray(options.headers)) {

    if (options.headers) {

      var keys = Object.keys(options.headers);

      for (var i = 0, l = keys.length; i < l; i++) {

        var key = keys[i];

        self.setHeader(key, options.headers[key]);

      }

    }

    if (host && !this.getHeader('host') && setHost) {

      var hostHeader = host;

      if (port && +port !== defaultPort) {

        hostHeader += ':' + port;

      }

      this.setHeader('Host', hostHeader);

    }

  }

  if (options.auth && !this.getHeader('Authorization')) {

    //basic auth

    this.setHeader('Authorization', 'Basic ' +

                   new Buffer(options.auth).toString('base64'));

  }

  if (method === 'GET' || method === 'HEAD' || method === 'CONNECT') {

    self.useChunkedEncodingByDefault = false;

  } else {

    self.useChunkedEncodingByDefault = true;

  }

  if (Array.isArray(options.headers)) {

    self._storeHeader(self.method + ' ' + self.path + ' HTTP/1.1\r\n',

                      options.headers);

  } else if (self.getHeader('expect')) {

    self._storeHeader(self.method + ' ' + self.path + ' HTTP/1.1\r\n',

                      self._renderHeaders());

  }

  if (self.socketPath) {

    self._last = true;

    self.shouldKeepAlive = false;

    if (options.createConnection) {

      self.onSocket(options.createConnection(self.socketPath));

    } else {

      self.onSocket(net.createConnection(self.socketPath));

    }

  } else if (self.agent) {

    // If there is an agent we should default to Connection:keep-alive.

    self._last = false;

    self.shouldKeepAlive = true;

    self.agent.addRequest(self, host, port, options.localAddress);

  } else {

    // No agent, default to Connection:close.

    self._last = true;

    self.shouldKeepAlive = false;

    if (options.createConnection) {

      options.port = port;

      options.host = host;