| Server IP : 199.250.214.225 / Your IP : 3.133.116.152 Web Server : Apache System : Linux vps64074.inmotionhosting.com 3.10.0-1160.105.1.vz7.214.3 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : nicngo5 ( 1001) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /home/nicngo5/funds.upgrade.nicn.gov.ng/funds-upgraded/node_modules/spdy/lib/spdy/ |
Upload File : |
'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)
})
}