FM / spdy

/var/www/cobraambalaj/node_modules/spdy/lib/spdy/

/var/www/cobraambalaj/node_modules/spdy/lib/spdy

Name	Size	Mode	Actions
agent.js	6926	0644	edit dl rm
handle.js	5906	0644	edit dl rm
request.js	527	0644	edit dl rm
response.js	2923	0644	edit dl rm
server.js	7429	0644	edit dl rm
socket.js	921	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/spdy/lib/spdy/handle.js (5906B)

'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)
  })
}

cmd: