MAINHACK

Viewing / Editing File: handle.js

'use strict'

var assert = require('assert')
var thing = require('handle-thing')
var httpDeceiver = require('http-deceiver')
var util = require('util')

function Handle (options, stream, socket) {
  var state = {}
  this._spdyState = state

state.options = options || {}

state.stream = stream
  state.socket = null
  state.rawSocket = socket || stream.connection.socket
  state.deceiver = null
  state.ending = false

var self = this
  thing.call(this, stream, {
    getPeerName: function () {
      return self._getPeerName()
    },
    close: function (callback) {
      return self._closeCallback(callback)
    }
  })

if (!state.stream) {
    this.on('stream', function (stream) {
      state.stream = stream
    })
  }
}
util.inherits(Handle, thing)
module.exports = Handle

Handle.create = function create (options, stream, socket) {
  return new Handle(options, stream, socket)
}

Handle.prototype._getPeerName = function _getPeerName () {
  var state = this._spdyState

if (state.rawSocket._getpeername) {
    return state.rawSocket._getpeername()
  }

return null
}

Handle.prototype._closeCallback = function _closeCallback (callback) {
  var state = this._spdyState
  var stream = state.stream

if (state.ending) {
    // The .end() method of the stream may be called by us or by the
    // .shutdown() method in our super-class. If the latter has already been
    // called, then calling the .end() method below will have no effect, with
    // the result that the callback will never get executed, leading to an ever
    // so subtle memory leak.
    if (stream._writableState.finished) {
      // NOTE: it is important to call `setImmediate` instead of `nextTick`,
      // since this is how regular `handle.close()` works in node.js core.
      //
      // Using `nextTick` will lead to `net.Socket` emitting `close` before
      // `end` on UV_EOF. This results in aborted request without `end` event.
      setImmediate(callback)
    } else if (stream._writableState.ending) {
      stream.once('finish', function () {
        callback(null)
      })
    } else {
      stream.end(callback)
    }
  } else {
    stream.abort(callback)
  }

// Only a single end is allowed
  state.ending = false
}

Handle.prototype.getStream = function getStream (callback) {
  var state = this._spdyState

if (!callback) {
    assert(state.stream)
    return state.stream
  }

if (state.stream) {
    process.nextTick(function () {
      callback(state.stream)
    })
    return
  }

this.on('stream', callback)
}

Handle.prototype.assignSocket = function assignSocket (socket, options) {
  var state = this._spdyState

state.socket = socket
  state.deceiver = httpDeceiver.create(socket, options)

function onStreamError (err) {
    state.socket.emit('error', err)
  }

this.getStream(function (stream) {
    stream.on('error', onStreamError)
  })
}

Handle.prototype.assignClientRequest = function assignClientRequest (req) {
  var state = this._spdyState
  var oldEnd = req.end
  var oldSend = req._send

// Catch the headers before request will be sent
  var self = this

// For old nodes
  if (thing.mode !== 'modern') {
    req.end = function end () {
      this.end = oldEnd

this._send('')

return this.end.apply(this, arguments)
    }
  }

req._send = function send (data) {
    this._headerSent = true

// for v0.10 and below, otherwise it will set `hot = false` and include
    // headers in first write
    this._header = 'ignore me'

// To prevent exception
    this.connection = state.socket

// It is very important to leave this here, otherwise it will be executed
    // on a next tick, after `_send` will perform write
    self.getStream(function (stream) {
      if (!stream.connection._isGoaway(stream.id)) {
        stream.send()
      }
    })

// We are ready to create stream
    self.emit('needStream')

// Ensure that the connection is still ok to use
    if (state.stream && state.stream.connection._isGoaway(state.stream.id)) {
      return
    }

req._send = oldSend

// Ignore empty writes
    if (req.method === 'GET' && data.length === 0) {
      return
    }

return req._send.apply(this, arguments)
  }

// No chunked encoding
  req.useChunkedEncodingByDefault = false

req.on('finish', function () {
    req.socket.end()
  })
}

Handle.prototype.assignRequest = function assignRequest (req) {
  // Emit trailing headers
  this.getStream(function (stream) {
    stream.on('headers', function (headers) {
      req.emit('trailers', headers)
    })
  })
}

Handle.prototype.assignResponse = function assignResponse (res) {
  var self = this

res.addTrailers = function addTrailers (headers) {
    self.getStream(function (stream) {
      stream.sendHeaders(headers)
    })
  }
}

Handle.prototype._transformHeaders = function _transformHeaders (kind, headers) {
  var state = this._spdyState

var res = {}
  var keys = Object.keys(headers)

if (kind === 'request' && state.options['x-forwarded-for']) {
    var xforwarded = state.stream.connection.getXForwardedFor()
    if (xforwarded !== null) {
      res['x-forwarded-for'] = xforwarded
    }
  }

for (var i = 0; i < keys.length; i++) {
    var key = keys[i]
    var value = headers[key]

if (key === ':authority') {
      res.host = value
    }
    if (/^:/.test(key)) {
      continue
    }

res[key] = value
  }
  return res
}

Handle.prototype.emitRequest = function emitRequest () {
  var state = this._spdyState
  var stream = state.stream

state.deceiver.emitRequest({
    method: stream.method,
    path: stream.path,
    headers: this._transformHeaders('request', stream.headers)
  })
}

Handle.prototype.emitResponse = function emitResponse (status, headers) {
  var state = this._spdyState

state.deceiver.emitResponse({
    status: status,
    headers: this._transformHeaders('response', headers)
  })
}

Cancel / Back

[ MAINHACK ]

Viewing / Editing File: handle.js

Server Info

System Features

User Info