lib/_http_outgoing.js

   1 'use strict';
   2
   3 const assert = require('assert').ok;
   4 const Stream = require('stream');
   5 const timers = require('timers');
   6 const util = require('util');
   7 const internalUtil = require('internal/util');
   8 const Buffer = require('buffer').Buffer;
   9 const common = require('_http_common');
  10
  11 const CRLF = common.CRLF;
  12 const chunkExpression = common.chunkExpression;
  13 const debug = common.debug;
  14
  15 const connectionExpression = /^Connection$/i;
  16 const transferEncodingExpression = /^Transfer-Encoding$/i;
  17 const closeExpression = /close/i;
  18 const contentLengthExpression = /^Content-Length$/i;
  19 const dateExpression = /^Date$/i;
  20 const expectExpression = /^Expect$/i;
  21 const trailerExpression = /^Trailer$/i;
  22
  23 const automaticHeaders = {
  24   connection: true,
  25   'content-length': true,
  26   'transfer-encoding': true,
  27   date: true
  28 };
  29
  30
  31 var dateCache;
  32 function utcDate() {
  33   if (!dateCache) {
  34     var d = new Date();
  35     dateCache = d.toUTCString();
  36     timers.enroll(utcDate, 1000 - d.getMilliseconds());
  37     timers._unrefActive(utcDate);
  38   }
  39   return dateCache;
  40 }
  41 utcDate._onTimeout = function() {
  42   dateCache = undefined;
  43 };
  44
  45
  46 function OutgoingMessage() {
  47   Stream.call(this);
  48
  49   // Queue that holds all currently pending data, until the response will be
  50   // assigned to the socket (until it will its turn in the HTTP pipeline).
  51   this.output = [];
  52   this.outputEncodings = [];
  53   this.outputCallbacks = [];
  54
  55   // `outputSize` is an approximate measure of how much data is queued on this
  56   // response. `_onPendingData` will be invoked to update similar global
  57   // per-connection counter. That counter will be used to pause/unpause the
  58   // TCP socket and HTTP Parser and thus handle the backpressure.
  59   this.outputSize = 0;
  60
  61   this.writable = true;
  62
  63   this._last = false;
  64   this.chunkedEncoding = false;
  65   this.shouldKeepAlive = true;
  66   this.useChunkedEncodingByDefault = true;
  67   this.sendDate = false;
  68   this._removedHeader = {};
  69
  70   this._contentLength = null;
  71   this._hasBody = true;
  72   this._trailer = '';
  73
  74   this.finished = false;
  75   this._headerSent = false;
  76
  77   this.socket = null;
  78   this.connection = null;
  79   this._header = null;
  80   this._headers = null;
  81   this._headerNames = {};
  82
  83   this._onPendingData = null;
  84 }
  85 util.inherits(OutgoingMessage, Stream);
  86
  87
  88 exports.OutgoingMessage = OutgoingMessage;
  89
  90
  91 OutgoingMessage.prototype.setTimeout = function(msecs, callback) {
  92   if (callback)
  93     this.on('timeout', callback);
  94
  95   if (!this.socket) {
  96     this.once('socket', function(socket) {
  97       socket.setTimeout(msecs);
  98     });
  99   } else {
 100     this.socket.setTimeout(msecs);
 101   }
 102   return this;
 103 };
 104
 105
 106 // It's possible that the socket will be destroyed, and removed from
 107 // any messages, before ever calling this.  In that case, just skip
 108 // it, since something else is destroying this connection anyway.
 109 OutgoingMessage.prototype.destroy = function(error) {
 110   if (this.socket)
 111     this.socket.destroy(error);
 112   else
 113     this.once('socket', function(socket) {
 114       socket.destroy(error);
 115     });
 116 };
 117
 118
 119 // This abstract either writing directly to the socket or buffering it.
 120 OutgoingMessage.prototype._send = function(data, encoding, callback) {
 121   // This is a shameful hack to get the headers and first body chunk onto
 122   // the same packet. Future versions of Node are going to take care of
 123   // this at a lower level and in a more general way.
 124   if (!this._headerSent) {
 125     if (typeof data === 'string' &&
 126         encoding !== 'hex' &&
 127         encoding !== 'base64') {
 128       data = this._header + data;
 129     } else {
 130       this.output.unshift(this._header);
 131       this.outputEncodings.unshift('binary');
 132       this.outputCallbacks.unshift(null);
 133       this.outputSize += this._header.length;
 134       if (typeof this._onPendingData === 'function')
 135         this._onPendingData(this._header.length);
 136     }
 137     this._headerSent = true;
 138   }
 139   return this._writeRaw(data, encoding, callback);
 140 };
 141
 142
 143 OutgoingMessage.prototype._writeRaw = function(data, encoding, callback) {
 144   if (typeof encoding === 'function') {
 145     callback = encoding;
 146     encoding = null;
 147   }
 148
 149   var connection = this.connection;
 150   if (connection &&
 151       connection._httpMessage === this &&
 152       connection.writable &&
 153       !connection.destroyed) {
 154     // There might be pending data in the this.output buffer.
 155     var outputLength = this.output.length;
 156     if (outputLength > 0) {
 157       this._flushOutput(connection);
 158     } else if (data.length === 0) {
 159       if (typeof callback === 'function')
 160         process.nextTick(callback);
 161       return true;
 162     }
 163
 164     // Directly write to socket.
 165     return connection.write(data, encoding, callback);
 166   } else if (connection && connection.destroyed) {
 167     // The socket was destroyed.  If we're still trying to write to it,
 168     // then we haven't gotten the 'close' event yet.
 169     return false;
 170   } else {
 171     // buffer, as long as we're not destroyed.
 172     return this._buffer(data, encoding, callback);
 173   }
 174 };
 175
 176
 177 OutgoingMessage.prototype._buffer = function(data, encoding, callback) {
 178   this.output.push(data);
 179   this.outputEncodings.push(encoding);
 180   this.outputCallbacks.push(callback);
 181   this.outputSize += data.length;
 182   if (typeof this._onPendingData === 'function')
 183     this._onPendingData(data.length);
 184   return false;
 185 };
 186
 187
 188 OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {
 189   // firstLine in the case of request is: 'GET /index.html HTTP/1.1\r\n'
 190   // in the case of response it is: 'HTTP/1.1 200 OK\r\n'
 191   var state = {
 192     sentConnectionHeader: false,
 193     sentContentLengthHeader: false,
 194     sentTransferEncodingHeader: false,
 195     sentDateHeader: false,
 196     sentExpect: false,
 197     sentTrailer: false,
 198     messageHeader: firstLine
 199   };
 200
 201   if (headers) {
 202     var keys = Object.keys(headers);
 203     var isArray = Array.isArray(headers);
 204     var field, value;
 205
 206     for (var i = 0, l = keys.length; i < l; i++) {
 207       var key = keys[i];
 208       if (isArray) {
 209         field = headers[key][0];
 210         value = headers[key][1];
 211       } else {
 212         field = key;
 213         value = headers[key];
 214       }
 215
 216       if (Array.isArray(value)) {
 217         for (var j = 0; j < value.length; j++) {
 218           storeHeader(this, state, field, value[j]);
 219         }
 220       } else {
 221         storeHeader(this, state, field, value);
 222       }
 223     }
 224   }
 225
 226   // Date header
 227   if (this.sendDate === true && state.sentDateHeader === false) {
 228     state.messageHeader += 'Date: ' + utcDate() + CRLF;
 229   }
 230
 231   // Force the connection to close when the response is a 204 No Content or
 232   // a 304 Not Modified and the user has set a "Transfer-Encoding: chunked"
 233   // header.
 234   //
 235   // RFC 2616 mandates that 204 and 304 responses MUST NOT have a body but
 236   // node.js used to send out a zero chunk anyway to accommodate clients
 237   // that don't have special handling for those responses.
 238   //
 239   // It was pointed out that this might confuse reverse proxies to the point
 240   // of creating security liabilities, so suppress the zero chunk and force
 241   // the connection to close.
 242   var statusCode = this.statusCode;
 243   if ((statusCode === 204 || statusCode === 304) &&
 244       this.chunkedEncoding === true) {
 245     debug(statusCode + ' response should not use chunked encoding,' +
 246           ' closing connection.');
 247     this.chunkedEncoding = false;
 248     this.shouldKeepAlive = false;
 249   }
 250
 251   // keep-alive logic
 252   if (this._removedHeader.connection) {
 253     this._last = true;
 254     this.shouldKeepAlive = false;
 255   } else if (state.sentConnectionHeader === false) {
 256     var shouldSendKeepAlive = this.shouldKeepAlive &&
 257         (state.sentContentLengthHeader ||
 258          this.useChunkedEncodingByDefault ||
 259          this.agent);
 260     if (shouldSendKeepAlive) {
 261       state.messageHeader += 'Connection: keep-alive\r\n';
 262     } else {
 263       this._last = true;
 264       state.messageHeader += 'Connection: close\r\n';
 265     }
 266   }
 267
 268   if (state.sentContentLengthHeader === false &&
 269       state.sentTransferEncodingHeader === false) {
 270     if (!this._hasBody) {
 271       // Make sure we don't end the 0\r\n\r\n at the end of the message.
 272       this.chunkedEncoding = false;
 273     } else if (!this.useChunkedEncodingByDefault) {
 274       this._last = true;
 275     } else {
 276       if (!state.sentTrailer &&
 277           !this._removedHeader['content-length'] &&
 278           typeof this._contentLength === 'number') {
 279         state.messageHeader += 'Content-Length: ' + this._contentLength +
 280                                '\r\n';
 281       } else if (!this._removedHeader['transfer-encoding']) {
 282         state.messageHeader += 'Transfer-Encoding: chunked\r\n';
 283         this.chunkedEncoding = true;
 284       } else {
 285         // We should only be able to get here if both Content-Length and
 286         // Transfer-Encoding are removed by the user.
 287         // See: test/parallel/test-http-remove-header-stays-removed.js
 288         debug('Both Content-Length and Transfer-Encoding are removed');
 289       }
 290     }
 291   }
 292
 293   this._header = state.messageHeader + CRLF;
 294   this._headerSent = false;
 295
 296   // wait until the first body chunk, or close(), is sent to flush,
 297   // UNLESS we're sending Expect: 100-continue.
 298   if (state.sentExpect) this._send('');
 299 };
 300
 301 function storeHeader(self, state, field, value) {
 302   value = escapeHeaderValue(value);
 303   state.messageHeader += field + ': ' + value + CRLF;
 304
 305   if (connectionExpression.test(field)) {
 306     state.sentConnectionHeader = true;
 307     if (closeExpression.test(value)) {
 308       self._last = true;
 309     } else {
 310       self.shouldKeepAlive = true;
 311     }
 312
 313   } else if (transferEncodingExpression.test(field)) {
 314     state.sentTransferEncodingHeader = true;
 315     if (chunkExpression.test(value)) self.chunkedEncoding = true;
 316
 317   } else if (contentLengthExpression.test(field)) {
 318     state.sentContentLengthHeader = true;
 319   } else if (dateExpression.test(field)) {
 320     state.sentDateHeader = true;
 321   } else if (expectExpression.test(field)) {
 322     state.sentExpect = true;
 323   } else if (trailerExpression.test(field)) {
 324     state.sentTrailer = true;
 325   }
 326 }
 327
 328
 329 OutgoingMessage.prototype.setHeader = function(name, value) {
 330   if (typeof name !== 'string')
 331     throw new TypeError('`name` should be a string in setHeader(name, value).');
 332   if (value === undefined)
 333     throw new Error('`value` required in setHeader("' + name + '", value).');
 334   if (this._header)
 335     throw new Error('Can\'t set headers after they are sent.');
 336
 337   if (this._headers === null)
 338     this._headers = {};
 339
 340   var key = name.toLowerCase();
 341   this._headers[key] = value;
 342   this._headerNames[key] = name;
 343
 344   if (automaticHeaders[key])
 345     this._removedHeader[key] = false;
 346 };
 347
 348
 349 OutgoingMessage.prototype.getHeader = function(name) {
 350   if (arguments.length < 1) {
 351     throw new Error('`name` is required for getHeader(name).');
 352   }
 353
 354   if (!this._headers) return;
 355
 356   var key = name.toLowerCase();
 357   return this._headers[key];
 358 };
 359
 360
 361 OutgoingMessage.prototype.removeHeader = function(name) {
 362   if (arguments.length < 1) {
 363     throw new Error('`name` is required for removeHeader(name).');
 364   }
 365
 366   if (this._header) {
 367     throw new Error('Can\'t remove headers after they are sent.');
 368   }
 369
 370   var key = name.toLowerCase();
 371
 372   if (key === 'date')
 373     this.sendDate = false;
 374   else if (automaticHeaders[key])
 375     this._removedHeader[key] = true;
 376
 377   if (this._headers) {
 378     delete this._headers[key];
 379     delete this._headerNames[key];
 380   }
 381 };
 382
 383
 384 OutgoingMessage.prototype._renderHeaders = function() {
 385   if (this._header) {
 386     throw new Error('Can\'t render headers after they are sent to the client.');
 387   }
 388
 389   var headersMap = this._headers;
 390   if (!headersMap) return {};
 391
 392   var headers = {};
 393   var keys = Object.keys(headersMap);
 394   var headerNames = this._headerNames;
 395
 396   for (var i = 0, l = keys.length; i < l; i++) {
 397     var key = keys[i];
 398     headers[headerNames[key]] = headersMap[key];
 399   }
 400   return headers;
 401 };
 402
 403
 404 Object.defineProperty(OutgoingMessage.prototype, 'headersSent', {
 405   configurable: true,
 406   enumerable: true,
 407   get: function() { return !!this._header; }
 408 });
 409
 410
 411 OutgoingMessage.prototype.write = function(chunk, encoding, callback) {
 412   if (this.finished) {
 413     var err = new Error('write after end');
 414     process.nextTick(writeAfterEndNT, this, err, callback);
 415
 416     return true;
 417   }
 418
 419   if (!this._header) {
 420     this._implicitHeader();
 421   }
 422
 423   if (!this._hasBody) {
 424     debug('This type of response MUST NOT have a body. ' +
 425           'Ignoring write() calls.');
 426     return true;
 427   }
 428
 429   if (typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
 430     throw new TypeError('first argument must be a string or Buffer');
 431   }
 432
 433
 434   // If we get an empty string or buffer, then just do nothing, and
 435   // signal the user to keep writing.
 436   if (chunk.length === 0) return true;
 437
 438   var len, ret;
 439   if (this.chunkedEncoding) {
 440     if (typeof chunk === 'string' &&
 441         encoding !== 'hex' &&
 442         encoding !== 'base64' &&
 443         encoding !== 'binary') {
 444       len = Buffer.byteLength(chunk, encoding);
 445       chunk = len.toString(16) + CRLF + chunk + CRLF;
 446       ret = this._send(chunk, encoding, callback);
 447     } else {
 448       // buffer, or a non-toString-friendly encoding
 449       if (typeof chunk === 'string')
 450         len = Buffer.byteLength(chunk, encoding);
 451       else
 452         len = chunk.length;
 453
 454       if (this.connection && !this.connection.corked) {
 455         this.connection.cork();
 456         process.nextTick(connectionCorkNT, this.connection);
 457       }
 458       this._send(len.toString(16), 'binary', null);
 459       this._send(crlf_buf, null, null);
 460       this._send(chunk, encoding, null);
 461       ret = this._send(crlf_buf, null, callback);
 462     }
 463   } else {
 464     ret = this._send(chunk, encoding, callback);
 465   }
 466
 467   debug('write ret = ' + ret);
 468   return ret;
 469 };
 470
 471
 472 function writeAfterEndNT(self, err, callback) {
 473   self.emit('error', err);
 474   if (callback) callback(err);
 475 }
 476
 477
 478 function connectionCorkNT(conn) {
 479   if (conn)
 480     conn.uncork();
 481 }
 482
 483
 484 function escapeHeaderValue(value) {
 485   // Protect against response splitting. The regex test is there to
 486   // minimize the performance impact in the common case.
 487   return /[\r\n]/.test(value) ? value.replace(/[\r\n]+[ \t]*/g, '') : value;
 488 }
 489
 490
 491 OutgoingMessage.prototype.addTrailers = function(headers) {
 492   this._trailer = '';
 493   var keys = Object.keys(headers);
 494   var isArray = Array.isArray(headers);
 495   var field, value;
 496   for (var i = 0, l = keys.length; i < l; i++) {
 497     var key = keys[i];
 498     if (isArray) {
 499       field = headers[key][0];
 500       value = headers[key][1];
 501     } else {
 502       field = key;
 503       value = headers[key];
 504     }
 505
 506     this._trailer += field + ': ' + escapeHeaderValue(value) + CRLF;
 507   }
 508 };
 509
 510
 511 const crlf_buf = new Buffer('\r\n');
 512
 513
 514 OutgoingMessage.prototype.end = function(data, encoding, callback) {
 515   if (typeof data === 'function') {
 516     callback = data;
 517     data = null;
 518   } else if (typeof encoding === 'function') {
 519     callback = encoding;
 520     encoding = null;
 521   }
 522
 523   if (data && typeof data !== 'string' && !(data instanceof Buffer)) {
 524     throw new TypeError('first argument must be a string or Buffer');
 525   }
 526
 527   if (this.finished) {
 528     return false;
 529   }
 530
 531   var self = this;
 532   function finish() {
 533     self.emit('finish');
 534   }
 535
 536   if (typeof callback === 'function')
 537     this.once('finish', callback);
 538
 539   if (!this._header) {
 540     if (data) {
 541       if (typeof data === 'string')
 542         this._contentLength = Buffer.byteLength(data, encoding);
 543       else
 544         this._contentLength = data.length;
 545     } else {
 546       this._contentLength = 0;
 547     }
 548     this._implicitHeader();
 549   }
 550
 551   if (data && !this._hasBody) {
 552     debug('This type of response MUST NOT have a body. ' +
 553           'Ignoring data passed to end().');
 554     data = null;
 555   }
 556
 557   if (this.connection && data)
 558     this.connection.cork();
 559
 560   var ret;
 561   if (data) {
 562     // Normal body write.
 563     ret = this.write(data, encoding);
 564   }
 565
 566   if (this._hasBody && this.chunkedEncoding) {
 567     ret = this._send('0\r\n' + this._trailer + '\r\n', 'binary', finish);
 568   } else {
 569     // Force a flush, HACK.
 570     ret = this._send('', 'binary', finish);
 571   }
 572
 573   if (this.connection && data)
 574     this.connection.uncork();
 575
 576   this.finished = true;
 577
 578   // There is the first message on the outgoing queue, and we've sent
 579   // everything to the socket.
 580   debug('outgoing message end.');
 581   if (this.output.length === 0 &&
 582       this.connection &&
 583       this.connection._httpMessage === this) {
 584     this._finish();
 585   }
 586
 587   return ret;
 588 };
 589
 590
 591 OutgoingMessage.prototype._finish = function() {
 592   assert(this.connection);
 593   this.emit('prefinish');
 594 };
 595
 596
 597 // This logic is probably a bit confusing. Let me explain a bit:
 598 //
 599 // In both HTTP servers and clients it is possible to queue up several
 600 // outgoing messages. This is easiest to imagine in the case of a client.
 601 // Take the following situation:
 602 //
 603 //    req1 = client.request('GET', '/');
 604 //    req2 = client.request('POST', '/');
 605 //
 606 // When the user does
 607 //
 608 //   req2.write('hello world\n');
 609 //
 610 // it's possible that the first request has not been completely flushed to
 611 // the socket yet. Thus the outgoing messages need to be prepared to queue
 612 // up data internally before sending it on further to the socket's queue.
 613 //
 614 // This function, outgoingFlush(), is called by both the Server and Client
 615 // to attempt to flush any pending messages out to the socket.
 616 OutgoingMessage.prototype._flush = function() {
 617   var socket = this.socket;
 618   var ret;
 619
 620   if (socket && socket.writable) {
 621     // There might be remaining data in this.output; write it out
 622     ret = this._flushOutput(socket);
 623
 624     if (this.finished) {
 625       // This is a queue to the server or client to bring in the next this.
 626       this._finish();
 627     } else if (ret) {
 628       // This is necessary to prevent https from breaking
 629       this.emit('drain');
 630     }
 631   }
 632 };
 633
 634 OutgoingMessage.prototype._flushOutput = function _flushOutput(socket) {
 635   var ret;
 636   var outputLength = this.output.length;
 637   if (outputLength <= 0)
 638     return ret;
 639
 640   var output = this.output;
 641   var outputEncodings = this.outputEncodings;
 642   var outputCallbacks = this.outputCallbacks;
 643   socket.cork();
 644   for (var i = 0; i < outputLength; i++) {
 645     ret = socket.write(output[i], outputEncodings[i],
 646                        outputCallbacks[i]);
 647   }
 648   socket.uncork();
 649
 650   this.output = [];
 651   this.outputEncodings = [];
 652   this.outputCallbacks = [];
 653   if (typeof this._onPendingData === 'function')
 654     this._onPendingData(-this.outputSize);
 655   this.outputSize = 0;
 656
 657   return ret;
 658 };
 659
 660
 661 OutgoingMessage.prototype.flushHeaders = function() {
 662   if (!this._header) {
 663     this._implicitHeader();
 664   }
 665
 666   // Force-flush the headers.
 667   this._send('');
 668 };
 669
 670 OutgoingMessage.prototype.flush = internalUtil.deprecate(function() {
 671   this.flushHeaders();
 672 }, 'OutgoingMessage.flush is deprecated. Use flushHeaders instead.');