mirror of https://github.com/lukechilds/node.git
Browse Source
At long last: The initial *experimental* implementation of HTTP/2.
This is an accumulation of the work that has been done in the nodejs/http2
repository, squashed down to a couple of commits. The original commit
history has been preserved in the nodejs/http2 repository.
This PR introduces the nghttp2 C library as a new dependency. This library
provides the majority of the HTTP/2 protocol implementation, with the rest
of the code here providing the mapping of the library into a usable JS API.
Within src, a handful of new node_http2_*.c and node_http2_*.h files are
introduced. These provide the internal mechanisms that interface with nghttp
and define the `process.binding('http2')` interface.
The JS API is defined within `internal/http2/*.js`.
There are two APIs provided: Core and Compat.
The Core API is HTTP/2 specific and is designed to be as minimal and as
efficient as possible.
The Compat API is intended to be as close to the existing HTTP/1 API as
possible, with some exceptions.
Tests, documentation and initial benchmarks are included.
The `http2` module is gated by a new `--expose-http2` command line flag.
When used, `require('http2')` will be exposed to users. Note that there
is an existing `http2` module on npm that would be impacted by the introduction
of this module, which is the main reason for gating this behind a flag.
When using `require('http2')` the first time, a process warning will be
emitted indicating that an experimental feature is being used.
To run the benchmarks, the `h2load` tool (part of the nghttp project) is
required: `./node benchmarks/http2/simple.js benchmarker=h2load`. Only
two benchmarks are currently available.
Additional configuration options to enable verbose debugging are provided:
```
$ ./configure --debug-http2 --debug-nghttp2
$ NODE_DEBUG=http2 ./node
```
The `--debug-http2` configuration option enables verbose debug statements
from the `src/node_http2_*` files. The `--debug-nghttp2` enables the nghttp
library's own verbose debug output. The `NODE_DEBUG=http2` enables JS-level
debug output.
The following illustrates as simple HTTP/2 server and client interaction:
(The HTTP/2 client and server support both plain text and TLS connections)
```jt client = http2.connect('http://localhost:80');
const req = client.request({ ':path': '/some/path' });
req.on('data', (chunk) => { /* do something with the data */ });
req.on('end', () => {
client.destroy();
});
// Plain text (non-TLS server)
const server = http2.createServer();
server.on('stream', (stream, requestHeaders) => {
stream.respond({ ':status': 200 });
stream.write('hello ');
stream.end('world');
});
server.listen(80);
```
```js
const http2 = require('http2');
const client = http2.connect('http://localhost');
```
Author: Anna Henningsen <anna@addaleax.net>
Author: Colin Ihrig <cjihrig@gmail.com>
Author: Daniel Bevenius <daniel.bevenius@gmail.com>
Author: James M Snell <jasnell@gmail.com>
Author: Jun Mukai
Author: Kelvin Jin
Author: Matteo Collina <matteo.collina@gmail.com>
Author: Robert Kowalski <rok@kowalski.gd>
Author: Santiago Gimeno <santiago.gimeno@gmail.com>
Author: Sebastiaan Deckers <sebdeckers83@gmail.com>
Author: Yosuke Furukawa <yosuke.furukawa@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/14239
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
v6
James M Snell
8 years ago
35 changed files with 9061 additions and 7 deletions
File diff suppressed because it is too large
@ -0,0 +1,27 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
|
process.emitWarning( |
||||
|
'The http2 module is an experimental API.', |
||||
|
'ExperimentalWarning', undefined, |
||||
|
'See https://github.com/nodejs/http2' |
||||
|
); |
||||
|
|
||||
|
const { |
||||
|
constants, |
||||
|
getDefaultSettings, |
||||
|
getPackedSettings, |
||||
|
getUnpackedSettings, |
||||
|
createServer, |
||||
|
createSecureServer, |
||||
|
connect |
||||
|
} = require('internal/http2/core'); |
||||
|
|
||||
|
module.exports = { |
||||
|
constants, |
||||
|
getDefaultSettings, |
||||
|
getPackedSettings, |
||||
|
getUnpackedSettings, |
||||
|
createServer, |
||||
|
createSecureServer, |
||||
|
connect |
||||
|
}; |
||||
@ -0,0 +1,570 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
|
const Stream = require('stream'); |
||||
|
const Readable = Stream.Readable; |
||||
|
const binding = process.binding('http2'); |
||||
|
const constants = binding.constants; |
||||
|
const errors = require('internal/errors'); |
||||
|
|
||||
|
const kFinish = Symbol('finish'); |
||||
|
const kBeginSend = Symbol('begin-send'); |
||||
|
const kState = Symbol('state'); |
||||
|
const kStream = Symbol('stream'); |
||||
|
const kRequest = Symbol('request'); |
||||
|
const kResponse = Symbol('response'); |
||||
|
const kHeaders = Symbol('headers'); |
||||
|
const kTrailers = Symbol('trailers'); |
||||
|
|
||||
|
let statusMessageWarned = false; |
||||
|
|
||||
|
// Defines and implements an API compatibility layer on top of the core
|
||||
|
// HTTP/2 implementation, intended to provide an interface that is as
|
||||
|
// close as possible to the current require('http') API
|
||||
|
|
||||
|
function assertValidHeader(name, value) { |
||||
|
if (isPseudoHeader(name)) |
||||
|
throw new errors.Error('ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED'); |
||||
|
if (value === undefined || value === null) |
||||
|
throw new errors.TypeError('ERR_HTTP2_INVALID_HEADER_VALUE'); |
||||
|
} |
||||
|
|
||||
|
function isPseudoHeader(name) { |
||||
|
switch (name) { |
||||
|
case ':status': |
||||
|
return true; |
||||
|
case ':method': |
||||
|
return true; |
||||
|
case ':path': |
||||
|
return true; |
||||
|
case ':authority': |
||||
|
return true; |
||||
|
case ':scheme': |
||||
|
return true; |
||||
|
default: |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function onStreamData(chunk) { |
||||
|
const request = this[kRequest]; |
||||
|
if (!request.push(chunk)) |
||||
|
this.pause(); |
||||
|
} |
||||
|
|
||||
|
function onStreamEnd() { |
||||
|
// Cause the request stream to end as well.
|
||||
|
const request = this[kRequest]; |
||||
|
request.push(null); |
||||
|
} |
||||
|
|
||||
|
function onStreamError(error) { |
||||
|
const request = this[kRequest]; |
||||
|
request.emit('error', error); |
||||
|
} |
||||
|
|
||||
|
function onRequestPause() { |
||||
|
const stream = this[kStream]; |
||||
|
stream.pause(); |
||||
|
} |
||||
|
|
||||
|
function onRequestResume() { |
||||
|
const stream = this[kStream]; |
||||
|
stream.resume(); |
||||
|
} |
||||
|
|
||||
|
function onRequestDrain() { |
||||
|
if (this.isPaused()) |
||||
|
this.resume(); |
||||
|
} |
||||
|
|
||||
|
function onStreamResponseDrain() { |
||||
|
const response = this[kResponse]; |
||||
|
response.emit('drain'); |
||||
|
} |
||||
|
|
||||
|
function onStreamResponseError(error) { |
||||
|
const response = this[kResponse]; |
||||
|
response.emit('error', error); |
||||
|
} |
||||
|
|
||||
|
function onStreamClosedRequest() { |
||||
|
const req = this[kRequest]; |
||||
|
req.push(null); |
||||
|
} |
||||
|
|
||||
|
function onStreamClosedResponse() { |
||||
|
const res = this[kResponse]; |
||||
|
res.writable = false; |
||||
|
res.emit('finish'); |
||||
|
} |
||||
|
|
||||
|
function onAborted(hadError, code) { |
||||
|
if ((this.writable) || |
||||
|
(this._readableState && !this._readableState.ended)) { |
||||
|
this.emit('aborted', hadError, code); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
class Http2ServerRequest extends Readable { |
||||
|
constructor(stream, headers, options) { |
||||
|
super(options); |
||||
|
this[kState] = { |
||||
|
statusCode: null, |
||||
|
closed: false, |
||||
|
closedCode: constants.NGHTTP2_NO_ERROR |
||||
|
}; |
||||
|
this[kHeaders] = headers; |
||||
|
this[kStream] = stream; |
||||
|
stream[kRequest] = this; |
||||
|
|
||||
|
// Pause the stream..
|
||||
|
stream.pause(); |
||||
|
stream.on('data', onStreamData); |
||||
|
stream.on('end', onStreamEnd); |
||||
|
stream.on('error', onStreamError); |
||||
|
stream.on('close', onStreamClosedRequest); |
||||
|
stream.on('aborted', onAborted.bind(this)); |
||||
|
const onfinish = this[kFinish].bind(this); |
||||
|
stream.on('streamClosed', onfinish); |
||||
|
stream.on('finish', onfinish); |
||||
|
this.on('pause', onRequestPause); |
||||
|
this.on('resume', onRequestResume); |
||||
|
this.on('drain', onRequestDrain); |
||||
|
} |
||||
|
|
||||
|
get closed() { |
||||
|
const state = this[kState]; |
||||
|
return Boolean(state.closed); |
||||
|
} |
||||
|
|
||||
|
get code() { |
||||
|
const state = this[kState]; |
||||
|
return Number(state.closedCode); |
||||
|
} |
||||
|
|
||||
|
get stream() { |
||||
|
return this[kStream]; |
||||
|
} |
||||
|
|
||||
|
get statusCode() { |
||||
|
return this[kState].statusCode; |
||||
|
} |
||||
|
|
||||
|
get headers() { |
||||
|
return this[kHeaders]; |
||||
|
} |
||||
|
|
||||
|
get rawHeaders() { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return []; |
||||
|
const tuples = Object.entries(headers); |
||||
|
const flattened = Array.prototype.concat.apply([], tuples); |
||||
|
return flattened.map(String); |
||||
|
} |
||||
|
|
||||
|
get trailers() { |
||||
|
return this[kTrailers]; |
||||
|
} |
||||
|
|
||||
|
get httpVersionMajor() { |
||||
|
return 2; |
||||
|
} |
||||
|
|
||||
|
get httpVersionMinor() { |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
get httpVersion() { |
||||
|
return '2.0'; |
||||
|
} |
||||
|
|
||||
|
get socket() { |
||||
|
return this.stream.session.socket; |
||||
|
} |
||||
|
|
||||
|
get connection() { |
||||
|
return this.socket; |
||||
|
} |
||||
|
|
||||
|
_read(nread) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream) { |
||||
|
stream.resume(); |
||||
|
} else { |
||||
|
throw new errors.Error('ERR_HTTP2_STREAM_CLOSED'); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
get method() { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return; |
||||
|
return headers[constants.HTTP2_HEADER_METHOD]; |
||||
|
} |
||||
|
|
||||
|
get authority() { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return; |
||||
|
return headers[constants.HTTP2_HEADER_AUTHORITY]; |
||||
|
} |
||||
|
|
||||
|
get scheme() { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return; |
||||
|
return headers[constants.HTTP2_HEADER_SCHEME]; |
||||
|
} |
||||
|
|
||||
|
get url() { |
||||
|
return this.path; |
||||
|
} |
||||
|
|
||||
|
set url(url) { |
||||
|
this.path = url; |
||||
|
} |
||||
|
|
||||
|
get path() { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return; |
||||
|
return headers[constants.HTTP2_HEADER_PATH]; |
||||
|
} |
||||
|
|
||||
|
set path(path) { |
||||
|
let headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
headers = this[kHeaders] = Object.create(null); |
||||
|
headers[constants.HTTP2_HEADER_PATH] = path; |
||||
|
} |
||||
|
|
||||
|
setTimeout(msecs, callback) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream === undefined) return; |
||||
|
stream.setTimeout(msecs, callback); |
||||
|
} |
||||
|
|
||||
|
[kFinish](code) { |
||||
|
const state = this[kState]; |
||||
|
if (state.closed) |
||||
|
return; |
||||
|
state.closedCode = code; |
||||
|
state.closed = true; |
||||
|
this.push(null); |
||||
|
this[kStream] = undefined; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
class Http2ServerResponse extends Stream { |
||||
|
constructor(stream, options) { |
||||
|
super(options); |
||||
|
this[kState] = { |
||||
|
sendDate: true, |
||||
|
statusCode: constants.HTTP_STATUS_OK, |
||||
|
headerCount: 0, |
||||
|
trailerCount: 0, |
||||
|
closed: false, |
||||
|
closedCode: constants.NGHTTP2_NO_ERROR |
||||
|
}; |
||||
|
this[kStream] = stream; |
||||
|
stream[kResponse] = this; |
||||
|
this.writable = true; |
||||
|
stream.on('drain', onStreamResponseDrain); |
||||
|
stream.on('error', onStreamResponseError); |
||||
|
stream.on('close', onStreamClosedResponse); |
||||
|
stream.on('aborted', onAborted.bind(this)); |
||||
|
const onfinish = this[kFinish].bind(this); |
||||
|
stream.on('streamClosed', onfinish); |
||||
|
stream.on('finish', onfinish); |
||||
|
} |
||||
|
|
||||
|
get finished() { |
||||
|
const stream = this[kStream]; |
||||
|
return stream === undefined || stream._writableState.ended; |
||||
|
} |
||||
|
|
||||
|
get closed() { |
||||
|
const state = this[kState]; |
||||
|
return Boolean(state.closed); |
||||
|
} |
||||
|
|
||||
|
get code() { |
||||
|
const state = this[kState]; |
||||
|
return Number(state.closedCode); |
||||
|
} |
||||
|
|
||||
|
get stream() { |
||||
|
return this[kStream]; |
||||
|
} |
||||
|
|
||||
|
get headersSent() { |
||||
|
const stream = this[kStream]; |
||||
|
return stream.headersSent; |
||||
|
} |
||||
|
|
||||
|
get sendDate() { |
||||
|
return Boolean(this[kState].sendDate); |
||||
|
} |
||||
|
|
||||
|
set sendDate(bool) { |
||||
|
this[kState].sendDate = Boolean(bool); |
||||
|
} |
||||
|
|
||||
|
get statusCode() { |
||||
|
return this[kState].statusCode; |
||||
|
} |
||||
|
|
||||
|
set statusCode(code) { |
||||
|
const state = this[kState]; |
||||
|
code |= 0; |
||||
|
if (code >= 100 && code < 200) |
||||
|
throw new errors.RangeError('ERR_HTTP2_INFO_STATUS_NOT_ALLOWED'); |
||||
|
if (code < 200 || code > 599) |
||||
|
throw new errors.RangeError('ERR_HTTP2_STATUS_INVALID', code); |
||||
|
state.statusCode = code; |
||||
|
} |
||||
|
|
||||
|
addTrailers(headers) { |
||||
|
let trailers = this[kTrailers]; |
||||
|
const keys = Object.keys(headers); |
||||
|
let key = ''; |
||||
|
if (keys.length > 0) |
||||
|
return; |
||||
|
if (trailers === undefined) |
||||
|
trailers = this[kTrailers] = Object.create(null); |
||||
|
for (var i = 0; i < keys.length; i++) { |
||||
|
key = String(keys[i]).trim().toLowerCase(); |
||||
|
const value = headers[key]; |
||||
|
assertValidHeader(key, value); |
||||
|
trailers[key] = String(value); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
getHeader(name) { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return; |
||||
|
name = String(name).trim().toLowerCase(); |
||||
|
return headers[name]; |
||||
|
} |
||||
|
|
||||
|
getHeaderNames() { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return []; |
||||
|
return Object.keys(headers); |
||||
|
} |
||||
|
|
||||
|
getHeaders() { |
||||
|
const headers = this[kHeaders]; |
||||
|
return Object.assign({}, headers); |
||||
|
} |
||||
|
|
||||
|
hasHeader(name) { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return false; |
||||
|
name = String(name).trim().toLowerCase(); |
||||
|
return Object.prototype.hasOwnProperty.call(headers, name); |
||||
|
} |
||||
|
|
||||
|
removeHeader(name) { |
||||
|
const headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
return; |
||||
|
name = String(name).trim().toLowerCase(); |
||||
|
delete headers[name]; |
||||
|
} |
||||
|
|
||||
|
setHeader(name, value) { |
||||
|
name = String(name).trim().toLowerCase(); |
||||
|
assertValidHeader(name, value); |
||||
|
let headers = this[kHeaders]; |
||||
|
if (headers === undefined) |
||||
|
headers = this[kHeaders] = Object.create(null); |
||||
|
headers[name] = String(value); |
||||
|
} |
||||
|
|
||||
|
flushHeaders() { |
||||
|
if (this[kStream].headersSent === false) |
||||
|
this[kBeginSend](); |
||||
|
} |
||||
|
|
||||
|
writeHead(statusCode, statusMessage, headers) { |
||||
|
if (typeof statusMessage === 'string' && statusMessageWarned === false) { |
||||
|
process.emitWarning( |
||||
|
'Status message is not supported by HTTP/2 (RFC7540 8.1.2.4)', |
||||
|
'UnsupportedWarning' |
||||
|
); |
||||
|
statusMessageWarned = true; |
||||
|
} |
||||
|
if (headers === undefined && typeof statusMessage === 'object') { |
||||
|
headers = statusMessage; |
||||
|
} |
||||
|
if (headers) { |
||||
|
const keys = Object.keys(headers); |
||||
|
let key = ''; |
||||
|
for (var i = 0; i < keys.length; i++) { |
||||
|
key = keys[i]; |
||||
|
this.setHeader(key, headers[key]); |
||||
|
} |
||||
|
} |
||||
|
this.statusCode = statusCode; |
||||
|
} |
||||
|
|
||||
|
write(chunk, encoding, cb) { |
||||
|
const stream = this[kStream]; |
||||
|
|
||||
|
if (typeof encoding === 'function') { |
||||
|
cb = encoding; |
||||
|
encoding = 'utf8'; |
||||
|
} |
||||
|
|
||||
|
if (stream === undefined) { |
||||
|
const err = new errors.Error('ERR_HTTP2_STREAM_CLOSED'); |
||||
|
if (cb) |
||||
|
process.nextTick(cb, err); |
||||
|
else |
||||
|
throw err; |
||||
|
return; |
||||
|
} |
||||
|
this[kBeginSend](); |
||||
|
return stream.write(chunk, encoding, cb); |
||||
|
} |
||||
|
|
||||
|
end(chunk, encoding, cb) { |
||||
|
const stream = this[kStream]; |
||||
|
|
||||
|
if (typeof chunk === 'function') { |
||||
|
cb = chunk; |
||||
|
chunk = null; |
||||
|
encoding = 'utf8'; |
||||
|
} else if (typeof encoding === 'function') { |
||||
|
cb = encoding; |
||||
|
encoding = 'utf8'; |
||||
|
} |
||||
|
if (chunk !== null && chunk !== undefined) { |
||||
|
this.write(chunk, encoding); |
||||
|
} |
||||
|
|
||||
|
if (typeof cb === 'function' && stream !== undefined) { |
||||
|
stream.once('finish', cb); |
||||
|
} |
||||
|
|
||||
|
this[kBeginSend]({endStream: true}); |
||||
|
|
||||
|
if (stream !== undefined) { |
||||
|
stream.end(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
destroy(err) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream === undefined) { |
||||
|
// nothing to do, already closed
|
||||
|
return; |
||||
|
} |
||||
|
stream.destroy(err); |
||||
|
} |
||||
|
|
||||
|
setTimeout(msecs, callback) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream === undefined) return; |
||||
|
stream.setTimeout(msecs, callback); |
||||
|
} |
||||
|
|
||||
|
sendContinue(headers) { |
||||
|
this.sendInfo(100, headers); |
||||
|
} |
||||
|
|
||||
|
sendInfo(code, headers) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream.headersSent === true) { |
||||
|
throw new errors.Error('ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND'); |
||||
|
} |
||||
|
if (headers && typeof headers !== 'object') |
||||
|
throw new errors.TypeError('ERR_HTTP2_HEADERS_OBJECT'); |
||||
|
if (stream === undefined) return; |
||||
|
code |= 0; |
||||
|
if (code < 100 || code >= 200) |
||||
|
throw new errors.RangeError('ERR_HTTP2_INVALID_INFO_STATUS', code); |
||||
|
|
||||
|
headers[constants.HTTP2_HEADER_STATUS] = code; |
||||
|
stream.respond(headers); |
||||
|
} |
||||
|
|
||||
|
createPushResponse(headers, callback) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream === undefined) { |
||||
|
throw new errors.Error('ERR_HTTP2_STREAM_CLOSED'); |
||||
|
} |
||||
|
stream.pushStream(headers, {}, function(stream, headers, options) { |
||||
|
const response = new Http2ServerResponse(stream); |
||||
|
callback(null, response); |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
[kBeginSend](options) { |
||||
|
const stream = this[kStream]; |
||||
|
if (stream !== undefined && stream.headersSent === false) { |
||||
|
const state = this[kState]; |
||||
|
const headers = this[kHeaders] || Object.create(null); |
||||
|
headers[constants.HTTP2_HEADER_STATUS] = state.statusCode; |
||||
|
if (stream.finished === true) |
||||
|
options.endStream = true; |
||||
|
if (stream.destroyed === false) { |
||||
|
stream.respond(headers, options); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
[kFinish](code) { |
||||
|
const state = this[kState]; |
||||
|
if (state.closed) |
||||
|
return; |
||||
|
state.closedCode = code; |
||||
|
state.closed = true; |
||||
|
this.end(); |
||||
|
this[kStream] = undefined; |
||||
|
this.emit('finish'); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function onServerStream(stream, headers, flags) { |
||||
|
const server = this; |
||||
|
const request = new Http2ServerRequest(stream, headers); |
||||
|
const response = new Http2ServerResponse(stream); |
||||
|
|
||||
|
// Check for the CONNECT method
|
||||
|
const method = headers[constants.HTTP2_HEADER_METHOD]; |
||||
|
if (method === 'CONNECT') { |
||||
|
if (!server.emit('connect', request, response)) { |
||||
|
response.statusCode = constants.HTTP_STATUS_METHOD_NOT_ALLOWED; |
||||
|
response.end(); |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// Check for Expectations
|
||||
|
if (headers.expect !== undefined) { |
||||
|
if (headers.expect === '100-continue') { |
||||
|
if (server.listenerCount('checkContinue')) { |
||||
|
server.emit('checkContinue', request, response); |
||||
|
} else { |
||||
|
response.sendContinue(); |
||||
|
server.emit('request', request, response); |
||||
|
} |
||||
|
} else if (server.listenerCount('checkExpectation')) { |
||||
|
server.emit('checkExpectation', request, response); |
||||
|
} else { |
||||
|
response.statusCode = constants.HTTP_STATUS_EXPECTATION_FAILED; |
||||
|
response.end(); |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
server.emit('request', request, response); |
||||
|
} |
||||
|
|
||||
|
module.exports = { onServerStream }; |
||||
File diff suppressed because it is too large
@ -0,0 +1,513 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
|
const binding = process.binding('http2'); |
||||
|
const errors = require('internal/errors'); |
||||
|
|
||||
|
const { |
||||
|
HTTP2_HEADER_STATUS, |
||||
|
HTTP2_HEADER_METHOD, |
||||
|
HTTP2_HEADER_AUTHORITY, |
||||
|
HTTP2_HEADER_SCHEME, |
||||
|
HTTP2_HEADER_PATH, |
||||
|
HTTP2_HEADER_AGE, |
||||
|
HTTP2_HEADER_AUTHORIZATION, |
||||
|
HTTP2_HEADER_CONTENT_ENCODING, |
||||
|
HTTP2_HEADER_CONTENT_LANGUAGE, |
||||
|
HTTP2_HEADER_CONTENT_LENGTH, |
||||
|
HTTP2_HEADER_CONTENT_LOCATION, |
||||
|
HTTP2_HEADER_CONTENT_MD5, |
||||
|
HTTP2_HEADER_CONTENT_RANGE, |
||||
|
HTTP2_HEADER_CONTENT_TYPE, |
||||
|
HTTP2_HEADER_COOKIE, |
||||
|
HTTP2_HEADER_DATE, |
||||
|
HTTP2_HEADER_ETAG, |
||||
|
HTTP2_HEADER_EXPIRES, |
||||
|
HTTP2_HEADER_FROM, |
||||
|
HTTP2_HEADER_IF_MATCH, |
||||
|
HTTP2_HEADER_IF_NONE_MATCH, |
||||
|
HTTP2_HEADER_IF_MODIFIED_SINCE, |
||||
|
HTTP2_HEADER_IF_RANGE, |
||||
|
HTTP2_HEADER_IF_UNMODIFIED_SINCE, |
||||
|
HTTP2_HEADER_LAST_MODIFIED, |
||||
|
HTTP2_HEADER_LOCATION, |
||||
|
HTTP2_HEADER_MAX_FORWARDS, |
||||
|
HTTP2_HEADER_PROXY_AUTHORIZATION, |
||||
|
HTTP2_HEADER_RANGE, |
||||
|
HTTP2_HEADER_REFERER, |
||||
|
HTTP2_HEADER_RETRY_AFTER, |
||||
|
HTTP2_HEADER_USER_AGENT, |
||||
|
|
||||
|
HTTP2_HEADER_CONNECTION, |
||||
|
HTTP2_HEADER_UPGRADE, |
||||
|
HTTP2_HEADER_HTTP2_SETTINGS, |
||||
|
HTTP2_HEADER_TE, |
||||
|
HTTP2_HEADER_TRANSFER_ENCODING, |
||||
|
HTTP2_HEADER_HOST, |
||||
|
HTTP2_HEADER_KEEP_ALIVE, |
||||
|
HTTP2_HEADER_PROXY_CONNECTION, |
||||
|
|
||||
|
HTTP2_METHOD_DELETE, |
||||
|
HTTP2_METHOD_GET, |
||||
|
HTTP2_METHOD_HEAD |
||||
|
} = binding.constants; |
||||
|
|
||||
|
// This set is defined strictly by the HTTP/2 specification. Only
|
||||
|
// :-prefixed headers defined by that specification may be added to
|
||||
|
// this set.
|
||||
|
const kValidPseudoHeaders = new Set([ |
||||
|
HTTP2_HEADER_STATUS, |
||||
|
HTTP2_HEADER_METHOD, |
||||
|
HTTP2_HEADER_AUTHORITY, |
||||
|
HTTP2_HEADER_SCHEME, |
||||
|
HTTP2_HEADER_PATH |
||||
|
]); |
||||
|
|
||||
|
// This set contains headers that are permitted to have only a single
|
||||
|
// value. Multiple instances must not be specified.
|
||||
|
const kSingleValueHeaders = new Set([ |
||||
|
HTTP2_HEADER_STATUS, |
||||
|
HTTP2_HEADER_METHOD, |
||||
|
HTTP2_HEADER_AUTHORITY, |
||||
|
HTTP2_HEADER_SCHEME, |
||||
|
HTTP2_HEADER_PATH, |
||||
|
HTTP2_HEADER_AGE, |
||||
|
HTTP2_HEADER_AUTHORIZATION, |
||||
|
HTTP2_HEADER_CONTENT_ENCODING, |
||||
|
HTTP2_HEADER_CONTENT_LANGUAGE, |
||||
|
HTTP2_HEADER_CONTENT_LENGTH, |
||||
|
HTTP2_HEADER_CONTENT_LOCATION, |
||||
|
HTTP2_HEADER_CONTENT_MD5, |
||||
|
HTTP2_HEADER_CONTENT_RANGE, |
||||
|
HTTP2_HEADER_CONTENT_TYPE, |
||||
|
HTTP2_HEADER_DATE, |
||||
|
HTTP2_HEADER_ETAG, |
||||
|
HTTP2_HEADER_EXPIRES, |
||||
|
HTTP2_HEADER_FROM, |
||||
|
HTTP2_HEADER_IF_MATCH, |
||||
|
HTTP2_HEADER_IF_MODIFIED_SINCE, |
||||
|
HTTP2_HEADER_IF_NONE_MATCH, |
||||
|
HTTP2_HEADER_IF_RANGE, |
||||
|
HTTP2_HEADER_IF_UNMODIFIED_SINCE, |
||||
|
HTTP2_HEADER_LAST_MODIFIED, |
||||
|
HTTP2_HEADER_LOCATION, |
||||
|
HTTP2_HEADER_MAX_FORWARDS, |
||||
|
HTTP2_HEADER_PROXY_AUTHORIZATION, |
||||
|
HTTP2_HEADER_RANGE, |
||||
|
HTTP2_HEADER_REFERER, |
||||
|
HTTP2_HEADER_RETRY_AFTER, |
||||
|
HTTP2_HEADER_USER_AGENT |
||||
|
]); |
||||
|
|
||||
|
// The HTTP methods in this set are specifically defined as assigning no
|
||||
|
// meaning to the request payload. By default, unless the user explicitly
|
||||
|
// overrides the endStream option on the request method, the endStream
|
||||
|
// option will be defaulted to true when these methods are used.
|
||||
|
const kNoPayloadMethods = new Set([ |
||||
|
HTTP2_METHOD_DELETE, |
||||
|
HTTP2_METHOD_GET, |
||||
|
HTTP2_METHOD_HEAD |
||||
|
]); |
||||
|
|
||||
|
// The following ArrayBuffer instances are used to share memory more efficiently
|
||||
|
// with the native binding side for a number of methods. These are not intended
|
||||
|
// to be used directly by users in any way. The ArrayBuffers are created on
|
||||
|
// the native side with values that are filled in on demand, the js code then
|
||||
|
// reads those values out. The set of IDX constants that follow identify the
|
||||
|
// relevant data positions within these buffers.
|
||||
|
const settingsBuffer = new Uint32Array(binding.settingsArrayBuffer); |
||||
|
const optionsBuffer = new Uint32Array(binding.optionsArrayBuffer); |
||||
|
|
||||
|
// Note that Float64Array is used here because there is no Int64Array available
|
||||
|
// and these deal with numbers that can be beyond the range of Uint32 and Int32.
|
||||
|
// The values set on the native side will always be integers. This is not a
|
||||
|
// unique example of this, this pattern can be found in use in other parts of
|
||||
|
// Node.js core as a performance optimization.
|
||||
|
const sessionState = new Float64Array(binding.sessionStateArrayBuffer); |
||||
|
const streamState = new Float64Array(binding.streamStateArrayBuffer); |
||||
|
|
||||
|
const IDX_SETTINGS_HEADER_TABLE_SIZE = 0; |
||||
|
const IDX_SETTINGS_ENABLE_PUSH = 1; |
||||
|
const IDX_SETTINGS_INITIAL_WINDOW_SIZE = 2; |
||||
|
const IDX_SETTINGS_MAX_FRAME_SIZE = 3; |
||||
|
const IDX_SETTINGS_MAX_CONCURRENT_STREAMS = 4; |
||||
|
const IDX_SETTINGS_MAX_HEADER_LIST_SIZE = 5; |
||||
|
const IDX_SETTINGS_FLAGS = 6; |
||||
|
|
||||
|
const IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE = 0; |
||||
|
const IDX_SESSION_STATE_EFFECTIVE_RECV_DATA_LENGTH = 1; |
||||
|
const IDX_SESSION_STATE_NEXT_STREAM_ID = 2; |
||||
|
const IDX_SESSION_STATE_LOCAL_WINDOW_SIZE = 3; |
||||
|
const IDX_SESSION_STATE_LAST_PROC_STREAM_ID = 4; |
||||
|
const IDX_SESSION_STATE_REMOTE_WINDOW_SIZE = 5; |
||||
|
const IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE = 6; |
||||
|
const IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE = 7; |
||||
|
const IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE = 8; |
||||
|
const IDX_STREAM_STATE = 0; |
||||
|
const IDX_STREAM_STATE_WEIGHT = 1; |
||||
|
const IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT = 2; |
||||
|
const IDX_STREAM_STATE_LOCAL_CLOSE = 3; |
||||
|
const IDX_STREAM_STATE_REMOTE_CLOSE = 4; |
||||
|
const IDX_STREAM_STATE_LOCAL_WINDOW_SIZE = 5; |
||||
|
|
||||
|
const IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE = 0; |
||||
|
const IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS = 1; |
||||
|
const IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH = 2; |
||||
|
const IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS = 3; |
||||
|
const IDX_OPTIONS_PADDING_STRATEGY = 4; |
||||
|
const IDX_OPTIONS_FLAGS = 5; |
||||
|
|
||||
|
function updateOptionsBuffer(options) { |
||||
|
var flags = 0; |
||||
|
if (typeof options.maxDeflateDynamicTableSize === 'number') { |
||||
|
flags |= (1 << IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE); |
||||
|
optionsBuffer[IDX_OPTIONS_MAX_DEFLATE_DYNAMIC_TABLE_SIZE] = |
||||
|
options.maxDeflateDynamicTableSize; |
||||
|
} |
||||
|
if (typeof options.maxReservedRemoteStreams === 'number') { |
||||
|
flags |= (1 << IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS); |
||||
|
optionsBuffer[IDX_OPTIONS_MAX_RESERVED_REMOTE_STREAMS] = |
||||
|
options.maxReservedRemoteStreams; |
||||
|
} |
||||
|
if (typeof options.maxSendHeaderBlockLength === 'number') { |
||||
|
flags |= (1 << IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH); |
||||
|
optionsBuffer[IDX_OPTIONS_MAX_SEND_HEADER_BLOCK_LENGTH] = |
||||
|
options.maxSendHeaderBlockLength; |
||||
|
} |
||||
|
if (typeof options.peerMaxConcurrentStreams === 'number') { |
||||
|
flags |= (1 << IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS); |
||||
|
optionsBuffer[IDX_OPTIONS_PEER_MAX_CONCURRENT_STREAMS] = |
||||
|
options.peerMaxConcurrentStreams; |
||||
|
} |
||||
|
if (typeof options.paddingStrategy === 'number') { |
||||
|
flags |= (1 << IDX_OPTIONS_PADDING_STRATEGY); |
||||
|
optionsBuffer[IDX_OPTIONS_PADDING_STRATEGY] = |
||||
|
options.paddingStrategy; |
||||
|
} |
||||
|
optionsBuffer[IDX_OPTIONS_FLAGS] = flags; |
||||
|
} |
||||
|
|
||||
|
function getDefaultSettings() { |
||||
|
settingsBuffer[IDX_SETTINGS_FLAGS] = 0; |
||||
|
binding.refreshDefaultSettings(); |
||||
|
const holder = Object.create(null); |
||||
|
|
||||
|
const flags = settingsBuffer[IDX_SETTINGS_FLAGS]; |
||||
|
|
||||
|
if ((flags & (1 << IDX_SETTINGS_HEADER_TABLE_SIZE)) === |
||||
|
(1 << IDX_SETTINGS_HEADER_TABLE_SIZE)) { |
||||
|
holder.headerTableSize = |
||||
|
settingsBuffer[IDX_SETTINGS_HEADER_TABLE_SIZE]; |
||||
|
} |
||||
|
|
||||
|
if ((flags & (1 << IDX_SETTINGS_ENABLE_PUSH)) === |
||||
|
(1 << IDX_SETTINGS_ENABLE_PUSH)) { |
||||
|
holder.enablePush = |
||||
|
settingsBuffer[IDX_SETTINGS_ENABLE_PUSH] === 1; |
||||
|
} |
||||
|
|
||||
|
if ((flags & (1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE)) === |
||||
|
(1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE)) { |
||||
|
holder.initialWindowSize = |
||||
|
settingsBuffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE]; |
||||
|
} |
||||
|
|
||||
|
if ((flags & (1 << IDX_SETTINGS_MAX_FRAME_SIZE)) === |
||||
|
(1 << IDX_SETTINGS_MAX_FRAME_SIZE)) { |
||||
|
holder.maxFrameSize = |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_FRAME_SIZE]; |
||||
|
} |
||||
|
|
||||
|
if ((flags & (1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS)) === |
||||
|
(1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS)) { |
||||
|
console.log('setting it'); |
||||
|
holder.maxConcurrentStreams = |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS]; |
||||
|
} |
||||
|
|
||||
|
if ((flags & (1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE)) === |
||||
|
(1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE)) { |
||||
|
holder.maxHeaderListSize = |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE]; |
||||
|
} |
||||
|
|
||||
|
return holder; |
||||
|
} |
||||
|
|
||||
|
// remote is a boolean. true to fetch remote settings, false to fetch local.
|
||||
|
// this is only called internally
|
||||
|
function getSettings(session, remote) { |
||||
|
const holder = Object.create(null); |
||||
|
if (remote) |
||||
|
binding.refreshRemoteSettings(session); |
||||
|
else |
||||
|
binding.refreshLocalSettings(session); |
||||
|
|
||||
|
holder.headerTableSize = |
||||
|
settingsBuffer[IDX_SETTINGS_HEADER_TABLE_SIZE]; |
||||
|
holder.enablePush = |
||||
|
!!settingsBuffer[IDX_SETTINGS_ENABLE_PUSH]; |
||||
|
holder.initialWindowSize = |
||||
|
settingsBuffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE]; |
||||
|
holder.maxFrameSize = |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_FRAME_SIZE]; |
||||
|
holder.maxConcurrentStreams = |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS]; |
||||
|
holder.maxHeaderListSize = |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE]; |
||||
|
return holder; |
||||
|
} |
||||
|
|
||||
|
function updateSettingsBuffer(settings) { |
||||
|
var flags = 0; |
||||
|
if (typeof settings.headerTableSize === 'number') { |
||||
|
flags |= (1 << IDX_SETTINGS_HEADER_TABLE_SIZE); |
||||
|
settingsBuffer[IDX_SETTINGS_HEADER_TABLE_SIZE] = |
||||
|
settings.headerTableSize; |
||||
|
} |
||||
|
if (typeof settings.maxConcurrentStreams === 'number') { |
||||
|
flags |= (1 << IDX_SETTINGS_MAX_CONCURRENT_STREAMS); |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_CONCURRENT_STREAMS] = |
||||
|
settings.maxConcurrentStreams; |
||||
|
} |
||||
|
if (typeof settings.initialWindowSize === 'number') { |
||||
|
flags |= (1 << IDX_SETTINGS_INITIAL_WINDOW_SIZE); |
||||
|
settingsBuffer[IDX_SETTINGS_INITIAL_WINDOW_SIZE] = |
||||
|
settings.initialWindowSize; |
||||
|
} |
||||
|
if (typeof settings.maxFrameSize === 'number') { |
||||
|
flags |= (1 << IDX_SETTINGS_MAX_FRAME_SIZE); |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_FRAME_SIZE] = |
||||
|
settings.maxFrameSize; |
||||
|
} |
||||
|
if (typeof settings.maxHeaderListSize === 'number') { |
||||
|
flags |= (1 << IDX_SETTINGS_MAX_HEADER_LIST_SIZE); |
||||
|
settingsBuffer[IDX_SETTINGS_MAX_HEADER_LIST_SIZE] = |
||||
|
settings.maxHeaderListSize; |
||||
|
} |
||||
|
if (typeof settings.enablePush === 'boolean') { |
||||
|
flags |= (1 << IDX_SETTINGS_ENABLE_PUSH); |
||||
|
settingsBuffer[IDX_SETTINGS_ENABLE_PUSH] = Number(settings.enablePush); |
||||
|
} |
||||
|
|
||||
|
settingsBuffer[IDX_SETTINGS_FLAGS] = flags; |
||||
|
} |
||||
|
|
||||
|
function getSessionState(session) { |
||||
|
const holder = Object.create(null); |
||||
|
binding.refreshSessionState(session); |
||||
|
holder.effectiveLocalWindowSize = |
||||
|
sessionState[IDX_SESSION_STATE_EFFECTIVE_LOCAL_WINDOW_SIZE]; |
||||
|
holder.effectiveRecvDataLength = |
||||
|
sessionState[IDX_SESSION_STATE_EFFECTIVE_RECV_DATA_LENGTH]; |
||||
|
holder.nextStreamID = |
||||
|
sessionState[IDX_SESSION_STATE_NEXT_STREAM_ID]; |
||||
|
holder.localWindowSize = |
||||
|
sessionState[IDX_SESSION_STATE_LOCAL_WINDOW_SIZE]; |
||||
|
holder.lastProcStreamID = |
||||
|
sessionState[IDX_SESSION_STATE_LAST_PROC_STREAM_ID]; |
||||
|
holder.remoteWindowSize = |
||||
|
sessionState[IDX_SESSION_STATE_REMOTE_WINDOW_SIZE]; |
||||
|
holder.outboundQueueSize = |
||||
|
sessionState[IDX_SESSION_STATE_OUTBOUND_QUEUE_SIZE]; |
||||
|
holder.deflateDynamicTableSize = |
||||
|
sessionState[IDX_SESSION_STATE_HD_DEFLATE_DYNAMIC_TABLE_SIZE]; |
||||
|
holder.inflateDynamicTableSize = |
||||
|
sessionState[IDX_SESSION_STATE_HD_INFLATE_DYNAMIC_TABLE_SIZE]; |
||||
|
return holder; |
||||
|
} |
||||
|
|
||||
|
function getStreamState(session, stream) { |
||||
|
const holder = Object.create(null); |
||||
|
binding.refreshStreamState(session, stream); |
||||
|
holder.state = |
||||
|
streamState[IDX_STREAM_STATE]; |
||||
|
holder.weight = |
||||
|
streamState[IDX_STREAM_STATE_WEIGHT]; |
||||
|
holder.sumDependencyWeight = |
||||
|
streamState[IDX_STREAM_STATE_SUM_DEPENDENCY_WEIGHT]; |
||||
|
holder.localClose = |
||||
|
streamState[IDX_STREAM_STATE_LOCAL_CLOSE]; |
||||
|
holder.remoteClose = |
||||
|
streamState[IDX_STREAM_STATE_REMOTE_CLOSE]; |
||||
|
holder.localWindowSize = |
||||
|
streamState[IDX_STREAM_STATE_LOCAL_WINDOW_SIZE]; |
||||
|
return holder; |
||||
|
} |
||||
|
|
||||
|
function isIllegalConnectionSpecificHeader(name, value) { |
||||
|
switch (name) { |
||||
|
case HTTP2_HEADER_CONNECTION: |
||||
|
case HTTP2_HEADER_UPGRADE: |
||||
|
case HTTP2_HEADER_HOST: |
||||
|
case HTTP2_HEADER_HTTP2_SETTINGS: |
||||
|
case HTTP2_HEADER_KEEP_ALIVE: |
||||
|
case HTTP2_HEADER_PROXY_CONNECTION: |
||||
|
case HTTP2_HEADER_TRANSFER_ENCODING: |
||||
|
return true; |
||||
|
case HTTP2_HEADER_TE: |
||||
|
const val = Array.isArray(value) ? value.join(', ') : value; |
||||
|
return val !== 'trailers'; |
||||
|
default: |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function assertValidPseudoHeader(key) { |
||||
|
if (!kValidPseudoHeaders.has(key)) { |
||||
|
const err = new errors.Error('ERR_HTTP2_INVALID_PSEUDOHEADER', key); |
||||
|
Error.captureStackTrace(err, assertValidPseudoHeader); |
||||
|
return err; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function assertValidPseudoHeaderResponse(key) { |
||||
|
if (key !== ':status') { |
||||
|
const err = new errors.Error('ERR_HTTP2_INVALID_PSEUDOHEADER', key); |
||||
|
Error.captureStackTrace(err, assertValidPseudoHeaderResponse); |
||||
|
return err; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function assertValidPseudoHeaderTrailer(key) { |
||||
|
const err = new errors.Error('ERR_HTTP2_INVALID_PSEUDOHEADER', key); |
||||
|
Error.captureStackTrace(err, assertValidPseudoHeaderTrailer); |
||||
|
return err; |
||||
|
} |
||||
|
|
||||
|
function mapToHeaders(map, |
||||
|
assertValuePseudoHeader = assertValidPseudoHeader) { |
||||
|
const ret = []; |
||||
|
const keys = Object.keys(map); |
||||
|
const singles = new Set(); |
||||
|
for (var i = 0; i < keys.length; i++) { |
||||
|
let key = keys[i]; |
||||
|
let value = map[key]; |
||||
|
let val; |
||||
|
if (typeof key === 'symbol' || value === undefined || !key) |
||||
|
continue; |
||||
|
key = String(key).toLowerCase(); |
||||
|
const isArray = Array.isArray(value); |
||||
|
if (isArray) { |
||||
|
switch (value.length) { |
||||
|
case 0: |
||||
|
continue; |
||||
|
case 1: |
||||
|
value = String(value[0]); |
||||
|
break; |
||||
|
default: |
||||
|
if (kSingleValueHeaders.has(key)) |
||||
|
return new errors.Error('ERR_HTTP2_HEADER_SINGLE_VALUE', key); |
||||
|
} |
||||
|
} |
||||
|
if (key[0] === ':') { |
||||
|
const err = assertValuePseudoHeader(key); |
||||
|
if (err !== undefined) |
||||
|
return err; |
||||
|
ret.unshift([key, String(value)]); |
||||
|
} else { |
||||
|
if (kSingleValueHeaders.has(key)) { |
||||
|
if (singles.has(key)) |
||||
|
return new errors.Error('ERR_HTTP2_HEADER_SINGLE_VALUE', key); |
||||
|
singles.add(key); |
||||
|
} |
||||
|
if (isIllegalConnectionSpecificHeader(key, value)) { |
||||
|
return new errors.Error('ERR_HTTP2_INVALID_CONNECTION_HEADERS'); |
||||
|
} |
||||
|
if (isArray) { |
||||
|
for (var k = 0; k < value.length; k++) { |
||||
|
val = String(value[k]); |
||||
|
ret.push([key, val]); |
||||
|
} |
||||
|
} else { |
||||
|
val = String(value); |
||||
|
ret.push([key, val]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
class NghttpError extends Error { |
||||
|
constructor(ret) { |
||||
|
super(binding.nghttp2ErrorString(ret)); |
||||
|
this.code = 'ERR_HTTP2_ERROR'; |
||||
|
this.name = 'Error [ERR_HTTP2_ERROR]'; |
||||
|
this.errno = ret; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function assertIsObject(value, name, types) { |
||||
|
if (value !== undefined && |
||||
|
(value === null || |
||||
|
typeof value !== 'object' || |
||||
|
Array.isArray(value))) { |
||||
|
const err = new errors.TypeError('ERR_INVALID_ARG_TYPE', |
||||
|
name, types || 'object'); |
||||
|
Error.captureStackTrace(err, assertIsObject); |
||||
|
throw err; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function assertWithinRange(name, value, min = 0, max = Infinity) { |
||||
|
if (value !== undefined && |
||||
|
(typeof value !== 'number' || value < min || value > max)) { |
||||
|
const err = new errors.RangeError('ERR_HTTP2_INVALID_SETTING_VALUE', |
||||
|
name, value); |
||||
|
err.min = min; |
||||
|
err.max = max; |
||||
|
err.actual = value; |
||||
|
Error.captureStackTrace(err, assertWithinRange); |
||||
|
throw err; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function toHeaderObject(headers) { |
||||
|
const obj = Object.create(null); |
||||
|
for (var n = 0; n < headers.length; n = n + 2) { |
||||
|
var name = headers[n]; |
||||
|
var value = headers[n + 1]; |
||||
|
if (name === HTTP2_HEADER_STATUS) |
||||
|
value |= 0; |
||||
|
var existing = obj[name]; |
||||
|
if (existing === undefined) { |
||||
|
obj[name] = value; |
||||
|
} else if (!kSingleValueHeaders.has(name)) { |
||||
|
if (name === HTTP2_HEADER_COOKIE) { |
||||
|
// https://tools.ietf.org/html/rfc7540#section-8.1.2.5
|
||||
|
// "...If there are multiple Cookie header fields after decompression,
|
||||
|
// these MUST be concatenated into a single octet string using the
|
||||
|
// two-octet delimiter of 0x3B, 0x20 (the ASCII string "; ") before
|
||||
|
// being passed into a non-HTTP/2 context."
|
||||
|
obj[name] = `${existing}; ${value}`; |
||||
|
} else { |
||||
|
if (Array.isArray(existing)) |
||||
|
existing.push(value); |
||||
|
else |
||||
|
obj[name] = [existing, value]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return obj; |
||||
|
} |
||||
|
|
||||
|
function isPayloadMeaningless(method) { |
||||
|
return kNoPayloadMethods.has(method); |
||||
|
} |
||||
|
|
||||
|
module.exports = { |
||||
|
assertIsObject, |
||||
|
assertValidPseudoHeaderResponse, |
||||
|
assertValidPseudoHeaderTrailer, |
||||
|
assertWithinRange, |
||||
|
getDefaultSettings, |
||||
|
getSessionState, |
||||
|
getSettings, |
||||
|
getStreamState, |
||||
|
isPayloadMeaningless, |
||||
|
mapToHeaders, |
||||
|
NghttpError, |
||||
|
toHeaderObject, |
||||
|
updateOptionsBuffer, |
||||
|
updateSettingsBuffer |
||||
|
}; |
||||
@ -0,0 +1,92 @@ |
|||||
|
#ifndef SRC_FREELIST_H_ |
||||
|
#define SRC_FREELIST_H_ |
||||
|
|
||||
|
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS |
||||
|
|
||||
|
#include "util.h" |
||||
|
|
||||
|
namespace node { |
||||
|
|
||||
|
struct DefaultFreelistTraits; |
||||
|
|
||||
|
template <typename T, |
||||
|
size_t kMaximumLength, |
||||
|
typename FreelistTraits = DefaultFreelistTraits> |
||||
|
class Freelist { |
||||
|
public: |
||||
|
typedef struct list_item { |
||||
|
T* item = nullptr; |
||||
|
list_item* next = nullptr; |
||||
|
} list_item; |
||||
|
|
||||
|
Freelist() {} |
||||
|
~Freelist() { |
||||
|
while (head_ != nullptr) { |
||||
|
list_item* item = head_; |
||||
|
head_ = item->next; |
||||
|
FreelistTraits::Free(item->item); |
||||
|
free(item); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void push(T* item) { |
||||
|
if (size_ > kMaximumLength) { |
||||
|
FreelistTraits::Free(item); |
||||
|
} else { |
||||
|
size_++; |
||||
|
FreelistTraits::Reset(item); |
||||
|
list_item* li = Calloc<list_item>(1); |
||||
|
li->item = item; |
||||
|
if (head_ == nullptr) { |
||||
|
head_ = li; |
||||
|
tail_ = li; |
||||
|
} else { |
||||
|
tail_->next = li; |
||||
|
tail_ = li; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
T* pop() { |
||||
|
if (head_ != nullptr) { |
||||
|
size_--; |
||||
|
list_item* cur = head_; |
||||
|
T* item = cur->item; |
||||
|
head_ = cur->next; |
||||
|
free(cur); |
||||
|
return item; |
||||
|
} else { |
||||
|
return FreelistTraits::template Alloc<T>(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
size_t size_ = 0; |
||||
|
list_item* head_ = nullptr; |
||||
|
list_item* tail_ = nullptr; |
||||
|
}; |
||||
|
|
||||
|
struct DefaultFreelistTraits { |
||||
|
template <typename T> |
||||
|
static T* Alloc() { |
||||
|
return ::new (Malloc<T>(1)) T(); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
static void Free(T* item) { |
||||
|
item->~T(); |
||||
|
free(item); |
||||
|
} |
||||
|
|
||||
|
template <typename T> |
||||
|
static void Reset(T* item) { |
||||
|
item->~T(); |
||||
|
::new (item) T(); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
} // namespace node
|
||||
|
|
||||
|
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
|
||||
|
#endif // SRC_FREELIST_H_
|
||||
File diff suppressed because it is too large
@ -0,0 +1,572 @@ |
|||||
|
#ifndef SRC_NODE_HTTP2_H_ |
||||
|
#define SRC_NODE_HTTP2_H_ |
||||
|
|
||||
|
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS |
||||
|
|
||||
|
#include "node_http2_core-inl.h" |
||||
|
#include "stream_base-inl.h" |
||||
|
#include "string_bytes.h" |
||||
|
|
||||
|
namespace node { |
||||
|
namespace http2 { |
||||
|
|
||||
|
using v8::Array; |
||||
|
using v8::Context; |
||||
|
using v8::EscapableHandleScope; |
||||
|
using v8::Isolate; |
||||
|
using v8::MaybeLocal; |
||||
|
|
||||
|
#define HTTP_KNOWN_METHODS(V) \ |
||||
|
V(ACL, "ACL") \ |
||||
|
V(BASELINE_CONTROL, "BASELINE-CONTROL") \ |
||||
|
V(BIND, "BIND") \ |
||||
|
V(CHECKIN, "CHECKIN") \ |
||||
|
V(CHECKOUT, "CHECKOUT") \ |
||||
|
V(CONNECT, "CONNECT") \ |
||||
|
V(COPY, "COPY") \ |
||||
|
V(DELETE, "DELETE") \ |
||||
|
V(GET, "GET") \ |
||||
|
V(HEAD, "HEAD") \ |
||||
|
V(LABEL, "LABEL") \ |
||||
|
V(LINK, "LINK") \ |
||||
|
V(LOCK, "LOCK") \ |
||||
|
V(MERGE, "MERGE") \ |
||||
|
V(MKACTIVITY, "MKACTIVITY") \ |
||||
|
V(MKCALENDAR, "MKCALENDAR") \ |
||||
|
V(MKCOL, "MKCOL") \ |
||||
|
V(MKREDIRECTREF, "MKREDIRECTREF") \ |
||||
|
V(MKWORKSPACE, "MKWORKSPACE") \ |
||||
|
V(MOVE, "MOVE") \ |
||||
|
V(OPTIONS, "OPTIONS") \ |
||||
|
V(ORDERPATCH, "ORDERPATCH") \ |
||||
|
V(PATCH, "PATCH") \ |
||||
|
V(POST, "POST") \ |
||||
|
V(PRI, "PRI") \ |
||||
|
V(PROPFIND, "PROPFIND") \ |
||||
|
V(PROPPATCH, "PROPPATCH") \ |
||||
|
V(PUT, "PUT") \ |
||||
|
V(REBIND, "REBIND") \ |
||||
|
V(REPORT, "REPORT") \ |
||||
|
V(SEARCH, "SEARCH") \ |
||||
|
V(TRACE, "TRACE") \ |
||||
|
V(UNBIND, "UNBIND") \ |
||||
|
V(UNCHECKOUT, "UNCHECKOUT") \ |
||||
|
V(UNLINK, "UNLINK") \ |
||||
|
V(UNLOCK, "UNLOCK") \ |
||||
|
V(UPDATE, "UPDATE") \ |
||||
|
V(UPDATEREDIRECTREF, "UPDATEREDIRECTREF") \ |
||||
|
V(VERSION_CONTROL, "VERSION-CONTROL") |
||||
|
|
||||
|
#define HTTP_KNOWN_HEADERS(V) \ |
||||
|
V(STATUS, ":status") \ |
||||
|
V(METHOD, ":method") \ |
||||
|
V(AUTHORITY, ":authority") \ |
||||
|
V(SCHEME, ":scheme") \ |
||||
|
V(PATH, ":path") \ |
||||
|
V(ACCEPT_CHARSET, "accept-charset") \ |
||||
|
V(ACCEPT_ENCODING, "accept-encoding") \ |
||||
|
V(ACCEPT_LANGUAGE, "accept-language") \ |
||||
|
V(ACCEPT_RANGES, "accept-ranges") \ |
||||
|
V(ACCEPT, "accept") \ |
||||
|
V(ACCESS_CONTROL_ALLOW_ORIGIN, "access-control-allow-origin") \ |
||||
|
V(AGE, "age") \ |
||||
|
V(ALLOW, "allow") \ |
||||
|
V(AUTHORIZATION, "authorization") \ |
||||
|
V(CACHE_CONTROL, "cache-control") \ |
||||
|
V(CONNECTION, "connection") \ |
||||
|
V(CONTENT_DISPOSITION, "content-disposition") \ |
||||
|
V(CONTENT_ENCODING, "content-encoding") \ |
||||
|
V(CONTENT_LANGUAGE, "content-language") \ |
||||
|
V(CONTENT_LENGTH, "content-length") \ |
||||
|
V(CONTENT_LOCATION, "content-location") \ |
||||
|
V(CONTENT_MD5, "content-md5") \ |
||||
|
V(CONTENT_RANGE, "content-range") \ |
||||
|
V(CONTENT_TYPE, "content-type") \ |
||||
|
V(COOKIE, "cookie") \ |
||||
|
V(DATE, "date") \ |
||||
|
V(ETAG, "etag") \ |
||||
|
V(EXPECT, "expect") \ |
||||
|
V(EXPIRES, "expires") \ |
||||
|
V(FROM, "from") \ |
||||
|
V(HOST, "host") \ |
||||
|
V(IF_MATCH, "if-match") \ |
||||
|
V(IF_MODIFIED_SINCE, "if-modified-since") \ |
||||
|
V(IF_NONE_MATCH, "if-none-match") \ |
||||
|
V(IF_RANGE, "if-range") \ |
||||
|
V(IF_UNMODIFIED_SINCE, "if-unmodified-since") \ |
||||
|
V(LAST_MODIFIED, "last-modified") \ |
||||
|
V(LINK, "link") \ |
||||
|
V(LOCATION, "location") \ |
||||
|
V(MAX_FORWARDS, "max-forwards") \ |
||||
|
V(PREFER, "prefer") \ |
||||
|
V(PROXY_AUTHENTICATE, "proxy-authenticate") \ |
||||
|
V(PROXY_AUTHORIZATION, "proxy-authorization") \ |
||||
|
V(RANGE, "range") \ |
||||
|
V(REFERER, "referer") \ |
||||
|
V(REFRESH, "refresh") \ |
||||
|
V(RETRY_AFTER, "retry-after") \ |
||||
|
V(SERVER, "server") \ |
||||
|
V(SET_COOKIE, "set-cookie") \ |
||||
|
V(STRICT_TRANSPORT_SECURITY, "strict-transport-security") \ |
||||
|
V(TRANSFER_ENCODING, "transfer-encoding") \ |
||||
|
V(TE, "te") \ |
||||
|
V(UPGRADE, "upgrade") \ |
||||
|
V(USER_AGENT, "user-agent") \ |
||||
|
V(VARY, "vary") \ |
||||
|
V(VIA, "via") \ |
||||
|
V(WWW_AUTHENTICATE, "www-authenticate") \ |
||||
|
V(HTTP2_SETTINGS, "http2-settings") \ |
||||
|
V(KEEP_ALIVE, "keep-alive") \ |
||||
|
V(PROXY_CONNECTION, "proxy-connection") |
||||
|
|
||||
|
enum http_known_headers { |
||||
|
HTTP_KNOWN_HEADER_MIN, |
||||
|
#define V(name, value) HTTP_HEADER_##name, |
||||
|
HTTP_KNOWN_HEADERS(V) |
||||
|
#undef V |
||||
|
HTTP_KNOWN_HEADER_MAX |
||||
|
}; |
||||
|
|
||||
|
#define HTTP_STATUS_CODES(V) \ |
||||
|
V(CONTINUE, 100) \ |
||||
|
V(SWITCHING_PROTOCOLS, 101) \ |
||||
|
V(PROCESSING, 102) \ |
||||
|
V(OK, 200) \ |
||||
|
V(CREATED, 201) \ |
||||
|
V(ACCEPTED, 202) \ |
||||
|
V(NON_AUTHORITATIVE_INFORMATION, 203) \ |
||||
|
V(NO_CONTENT, 204) \ |
||||
|
V(RESET_CONTENT, 205) \ |
||||
|
V(PARTIAL_CONTENT, 206) \ |
||||
|
V(MULTI_STATUS, 207) \ |
||||
|
V(ALREADY_REPORTED, 208) \ |
||||
|
V(IM_USED, 226) \ |
||||
|
V(MULTIPLE_CHOICES, 300) \ |
||||
|
V(MOVED_PERMANENTLY, 301) \ |
||||
|
V(FOUND, 302) \ |
||||
|
V(SEE_OTHER, 303) \ |
||||
|
V(NOT_MODIFIED, 304) \ |
||||
|
V(USE_PROXY, 305) \ |
||||
|
V(TEMPORARY_REDIRECT, 307) \ |
||||
|
V(PERMANENT_REDIRECT, 308) \ |
||||
|
V(BAD_REQUEST, 400) \ |
||||
|
V(UNAUTHORIZED, 401) \ |
||||
|
V(PAYMENT_REQUIRED, 402) \ |
||||
|
V(FORBIDDEN, 403) \ |
||||
|
V(NOT_FOUND, 404) \ |
||||
|
V(METHOD_NOT_ALLOWED, 405) \ |
||||
|
V(NOT_ACCEPTABLE, 406) \ |
||||
|
V(PROXY_AUTHENTICATION_REQUIRED, 407) \ |
||||
|
V(REQUEST_TIMEOUT, 408) \ |
||||
|
V(CONFLICT, 409) \ |
||||
|
V(GONE, 410) \ |
||||
|
V(LENGTH_REQUIRED, 411) \ |
||||
|
V(PRECONDITION_FAILED, 412) \ |
||||
|
V(PAYLOAD_TOO_LARGE, 413) \ |
||||
|
V(URI_TOO_LONG, 414) \ |
||||
|
V(UNSUPPORTED_MEDIA_TYPE, 415) \ |
||||
|
V(RANGE_NOT_SATISFIABLE, 416) \ |
||||
|
V(EXPECTATION_FAILED, 417) \ |
||||
|
V(TEAPOT, 418) \ |
||||
|
V(MISDIRECTED_REQUEST, 421) \ |
||||
|
V(UNPROCESSABLE_ENTITY, 422) \ |
||||
|
V(LOCKED, 423) \ |
||||
|
V(FAILED_DEPENDENCY, 424) \ |
||||
|
V(UNORDERED_COLLECTION, 425) \ |
||||
|
V(UPGRADE_REQUIRED, 426) \ |
||||
|
V(PRECONDITION_REQUIRED, 428) \ |
||||
|
V(TOO_MANY_REQUESTS, 429) \ |
||||
|
V(REQUEST_HEADER_FIELDS_TOO_LARGE, 431) \ |
||||
|
V(UNAVAILABLE_FOR_LEGAL_REASONS, 451) \ |
||||
|
V(INTERNAL_SERVER_ERROR, 500) \ |
||||
|
V(NOT_IMPLEMENTED, 501) \ |
||||
|
V(BAD_GATEWAY, 502) \ |
||||
|
V(SERVICE_UNAVAILABLE, 503) \ |
||||
|
V(GATEWAY_TIMEOUT, 504) \ |
||||
|
V(HTTP_VERSION_NOT_SUPPORTED, 505) \ |
||||
|
V(VARIANT_ALSO_NEGOTIATES, 506) \ |
||||
|
V(INSUFFICIENT_STORAGE, 507) \ |
||||
|
V(LOOP_DETECTED, 508) \ |
||||
|
V(BANDWIDTH_LIMIT_EXCEEDED, 509) \ |
||||
|
V(NOT_EXTENDED, 510) \ |
||||
|
V(NETWORK_AUTHENTICATION_REQUIRED, 511) |
||||
|
|
||||
|
enum http_status_codes { |
||||
|
#define V(name, code) HTTP_STATUS_##name = code, |
||||
|
HTTP_STATUS_CODES(V) |
||||
|
#undef V |
||||
|
}; |
||||
|
|
||||
|
enum padding_strategy_type { |
||||
|
// No padding strategy
|
||||
|
PADDING_STRATEGY_NONE, |
||||
|
// Padding will ensure all data frames are maxFrameSize
|
||||
|
PADDING_STRATEGY_MAX, |
||||
|
// Padding will be determined via JS callback
|
||||
|
PADDING_STRATEGY_CALLBACK |
||||
|
}; |
||||
|
|
||||
|
#define NGHTTP2_ERROR_CODES(V) \ |
||||
|
V(NGHTTP2_ERR_INVALID_ARGUMENT) \ |
||||
|
V(NGHTTP2_ERR_BUFFER_ERROR) \ |
||||
|
V(NGHTTP2_ERR_UNSUPPORTED_VERSION) \ |
||||
|
V(NGHTTP2_ERR_WOULDBLOCK) \ |
||||
|
V(NGHTTP2_ERR_PROTO) \ |
||||
|
V(NGHTTP2_ERR_INVALID_FRAME) \ |
||||
|
V(NGHTTP2_ERR_EOF) \ |
||||
|
V(NGHTTP2_ERR_DEFERRED) \ |
||||
|
V(NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE) \ |
||||
|
V(NGHTTP2_ERR_STREAM_CLOSED) \ |
||||
|
V(NGHTTP2_ERR_STREAM_CLOSING) \ |
||||
|
V(NGHTTP2_ERR_STREAM_SHUT_WR) \ |
||||
|
V(NGHTTP2_ERR_INVALID_STREAM_ID) \ |
||||
|
V(NGHTTP2_ERR_INVALID_STREAM_STATE) \ |
||||
|
V(NGHTTP2_ERR_DEFERRED_DATA_EXIST) \ |
||||
|
V(NGHTTP2_ERR_START_STREAM_NOT_ALLOWED) \ |
||||
|
V(NGHTTP2_ERR_GOAWAY_ALREADY_SENT) \ |
||||
|
V(NGHTTP2_ERR_INVALID_HEADER_BLOCK) \ |
||||
|
V(NGHTTP2_ERR_INVALID_STATE) \ |
||||
|
V(NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) \ |
||||
|
V(NGHTTP2_ERR_FRAME_SIZE_ERROR) \ |
||||
|
V(NGHTTP2_ERR_HEADER_COMP) \ |
||||
|
V(NGHTTP2_ERR_FLOW_CONTROL) \ |
||||
|
V(NGHTTP2_ERR_INSUFF_BUFSIZE) \ |
||||
|
V(NGHTTP2_ERR_PAUSE) \ |
||||
|
V(NGHTTP2_ERR_TOO_MANY_INFLIGHT_SETTINGS) \ |
||||
|
V(NGHTTP2_ERR_PUSH_DISABLED) \ |
||||
|
V(NGHTTP2_ERR_DATA_EXIST) \ |
||||
|
V(NGHTTP2_ERR_SESSION_CLOSING) \ |
||||
|
V(NGHTTP2_ERR_HTTP_HEADER) \ |
||||
|
V(NGHTTP2_ERR_HTTP_MESSAGING) \ |
||||
|
V(NGHTTP2_ERR_REFUSED_STREAM) \ |
||||
|
V(NGHTTP2_ERR_INTERNAL) \ |
||||
|
V(NGHTTP2_ERR_CANCEL) \ |
||||
|
V(NGHTTP2_ERR_FATAL) \ |
||||
|
V(NGHTTP2_ERR_NOMEM) \ |
||||
|
V(NGHTTP2_ERR_CALLBACK_FAILURE) \ |
||||
|
V(NGHTTP2_ERR_BAD_CLIENT_MAGIC) \ |
||||
|
V(NGHTTP2_ERR_FLOODED) |
||||
|
|
||||
|
const char* nghttp2_errname(int rv) { |
||||
|
switch (rv) { |
||||
|
#define V(code) case code: return #code; |
||||
|
NGHTTP2_ERROR_CODES(V) |
||||
|
#undef V |
||||
|
default: |
||||
|
return "NGHTTP2_UNKNOWN_ERROR"; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#define DEFAULT_SETTINGS_HEADER_TABLE_SIZE 4096 |
||||
|
#define DEFAULT_SETTINGS_ENABLE_PUSH 1 |
||||
|
#define DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE 65535 |
||||
|
#define DEFAULT_SETTINGS_MAX_FRAME_SIZE 16384 |
||||
|
#define MAX_MAX_FRAME_SIZE 16777215 |
||||
|
#define MIN_MAX_FRAME_SIZE DEFAULT_SETTINGS_MAX_FRAME_SIZE |
||||
|
#define MAX_INITIAL_WINDOW_SIZE 2147483647 |
||||
|
|
||||
|
class Http2Options { |
||||
|
public: |
||||
|
explicit Http2Options(Environment* env); |
||||
|
|
||||
|
~Http2Options() { |
||||
|
nghttp2_option_del(options_); |
||||
|
} |
||||
|
|
||||
|
nghttp2_option* operator*() { |
||||
|
return options_; |
||||
|
} |
||||
|
|
||||
|
void SetPaddingStrategy(uint32_t val) { |
||||
|
CHECK_LE(val, PADDING_STRATEGY_CALLBACK); |
||||
|
padding_strategy_ = static_cast<padding_strategy_type>(val); |
||||
|
} |
||||
|
|
||||
|
void SetMaxDeflateDynamicTableSize(size_t val) { |
||||
|
nghttp2_option_set_max_deflate_dynamic_table_size(options_, val); |
||||
|
} |
||||
|
|
||||
|
void SetMaxReservedRemoteStreams(uint32_t val) { |
||||
|
nghttp2_option_set_max_reserved_remote_streams(options_, val); |
||||
|
} |
||||
|
|
||||
|
void SetMaxSendHeaderBlockLength(size_t val) { |
||||
|
nghttp2_option_set_max_send_header_block_length(options_, val); |
||||
|
} |
||||
|
|
||||
|
void SetPeerMaxConcurrentStreams(uint32_t val) { |
||||
|
nghttp2_option_set_peer_max_concurrent_streams(options_, val); |
||||
|
} |
||||
|
|
||||
|
padding_strategy_type GetPaddingStrategy() { |
||||
|
return padding_strategy_; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
nghttp2_option* options_; |
||||
|
padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE; |
||||
|
}; |
||||
|
|
||||
|
static const size_t kAllocBufferSize = 64 * 1024; |
||||
|
|
||||
|
////
|
||||
|
typedef uint32_t(*get_setting)(nghttp2_session* session, |
||||
|
nghttp2_settings_id id); |
||||
|
|
||||
|
class Http2Session : public AsyncWrap, |
||||
|
public StreamBase, |
||||
|
public Nghttp2Session { |
||||
|
public: |
||||
|
Http2Session(Environment* env, |
||||
|
Local<Object> wrap, |
||||
|
nghttp2_session_type type) : |
||||
|
AsyncWrap(env, wrap, AsyncWrap::PROVIDER_HTTP2SESSION), |
||||
|
StreamBase(env) { |
||||
|
Wrap(object(), this); |
||||
|
|
||||
|
Http2Options opts(env); |
||||
|
|
||||
|
padding_strategy_ = opts.GetPaddingStrategy(); |
||||
|
|
||||
|
Init(env->event_loop(), type, *opts); |
||||
|
stream_buf_.AllocateSufficientStorage(kAllocBufferSize); |
||||
|
} |
||||
|
|
||||
|
~Http2Session() override { |
||||
|
CHECK_EQ(false, persistent().IsEmpty()); |
||||
|
ClearWrap(object()); |
||||
|
persistent().Reset(); |
||||
|
CHECK_EQ(true, persistent().IsEmpty()); |
||||
|
} |
||||
|
|
||||
|
static void OnStreamAllocImpl(size_t suggested_size, |
||||
|
uv_buf_t* buf, |
||||
|
void* ctx); |
||||
|
static void OnStreamReadImpl(ssize_t nread, |
||||
|
const uv_buf_t* bufs, |
||||
|
uv_handle_type pending, |
||||
|
void* ctx); |
||||
|
protected: |
||||
|
void OnFreeSession() override; |
||||
|
|
||||
|
ssize_t OnMaxFrameSizePadding(size_t frameLength, |
||||
|
size_t maxPayloadLen); |
||||
|
|
||||
|
ssize_t OnCallbackPadding(size_t frame, |
||||
|
size_t maxPayloadLen); |
||||
|
|
||||
|
bool HasGetPaddingCallback() override { |
||||
|
return padding_strategy_ == PADDING_STRATEGY_MAX || |
||||
|
padding_strategy_ == PADDING_STRATEGY_CALLBACK; |
||||
|
} |
||||
|
|
||||
|
ssize_t GetPadding(size_t frameLength, size_t maxPayloadLen) override { |
||||
|
if (padding_strategy_ == PADDING_STRATEGY_MAX) { |
||||
|
return OnMaxFrameSizePadding(frameLength, maxPayloadLen); |
||||
|
} |
||||
|
|
||||
|
CHECK_EQ(padding_strategy_, PADDING_STRATEGY_CALLBACK); |
||||
|
|
||||
|
return OnCallbackPadding(frameLength, maxPayloadLen); |
||||
|
} |
||||
|
|
||||
|
void OnHeaders(Nghttp2Stream* stream, |
||||
|
nghttp2_header_list* headers, |
||||
|
nghttp2_headers_category cat, |
||||
|
uint8_t flags) override; |
||||
|
void OnStreamClose(int32_t id, uint32_t code) override; |
||||
|
void Send(uv_buf_t* bufs, size_t total) override; |
||||
|
void OnDataChunk(Nghttp2Stream* stream, nghttp2_data_chunk_t* chunk) override; |
||||
|
void OnSettings(bool ack) override; |
||||
|
void OnPriority(int32_t stream, |
||||
|
int32_t parent, |
||||
|
int32_t weight, |
||||
|
int8_t exclusive) override; |
||||
|
void OnGoAway(int32_t lastStreamID, |
||||
|
uint32_t errorCode, |
||||
|
uint8_t* data, |
||||
|
size_t length) override; |
||||
|
void OnFrameError(int32_t id, uint8_t type, int error_code) override; |
||||
|
void OnTrailers(Nghttp2Stream* stream, |
||||
|
MaybeStackBuffer<nghttp2_nv>* trailers) override; |
||||
|
void AllocateSend(size_t recommended, uv_buf_t* buf) override; |
||||
|
|
||||
|
int DoWrite(WriteWrap* w, uv_buf_t* bufs, size_t count, |
||||
|
uv_stream_t* send_handle) override; |
||||
|
|
||||
|
AsyncWrap* GetAsyncWrap() override { |
||||
|
return static_cast<AsyncWrap*>(this); |
||||
|
} |
||||
|
|
||||
|
void* Cast() override { |
||||
|
return reinterpret_cast<void*>(this); |
||||
|
} |
||||
|
|
||||
|
// Required for StreamBase
|
||||
|
bool IsAlive() override { |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// Required for StreamBase
|
||||
|
bool IsClosing() override { |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// Required for StreamBase
|
||||
|
int ReadStart() override { return 0; } |
||||
|
|
||||
|
// Required for StreamBase
|
||||
|
int ReadStop() override { return 0; } |
||||
|
|
||||
|
// Required for StreamBase
|
||||
|
int DoShutdown(ShutdownWrap* req_wrap) override { |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
public: |
||||
|
void Consume(Local<External> external); |
||||
|
void Unconsume(); |
||||
|
|
||||
|
static void New(const FunctionCallbackInfo<Value>& args); |
||||
|
static void Consume(const FunctionCallbackInfo<Value>& args); |
||||
|
static void Unconsume(const FunctionCallbackInfo<Value>& args); |
||||
|
static void Destroy(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitSettings(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitRstStream(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitResponse(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitFile(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitRequest(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitPushPromise(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitPriority(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SendHeaders(const FunctionCallbackInfo<Value>& args); |
||||
|
static void ShutdownStream(const FunctionCallbackInfo<Value>& args); |
||||
|
static void StreamWrite(const FunctionCallbackInfo<Value>& args); |
||||
|
static void StreamReadStart(const FunctionCallbackInfo<Value>& args); |
||||
|
static void StreamReadStop(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SetNextStreamID(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SendShutdownNotice(const FunctionCallbackInfo<Value>& args); |
||||
|
static void SubmitGoaway(const FunctionCallbackInfo<Value>& args); |
||||
|
static void DestroyStream(const FunctionCallbackInfo<Value>& args); |
||||
|
|
||||
|
template <get_setting fn> |
||||
|
static void GetSettings(const FunctionCallbackInfo<Value>& args); |
||||
|
|
||||
|
size_t self_size() const override { |
||||
|
return sizeof(*this); |
||||
|
} |
||||
|
|
||||
|
char* stream_alloc() { |
||||
|
return *stream_buf_; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
StreamBase* stream_; |
||||
|
StreamResource::Callback<StreamResource::AllocCb> prev_alloc_cb_; |
||||
|
StreamResource::Callback<StreamResource::ReadCb> prev_read_cb_; |
||||
|
padding_strategy_type padding_strategy_ = PADDING_STRATEGY_NONE; |
||||
|
MaybeStackBuffer<char, kAllocBufferSize> stream_buf_; |
||||
|
}; |
||||
|
|
||||
|
class ExternalHeader : |
||||
|
public String::ExternalOneByteStringResource { |
||||
|
public: |
||||
|
explicit ExternalHeader(nghttp2_rcbuf* buf) |
||||
|
: buf_(buf), vec_(nghttp2_rcbuf_get_buf(buf)) { |
||||
|
} |
||||
|
|
||||
|
~ExternalHeader() override { |
||||
|
nghttp2_rcbuf_decref(buf_); |
||||
|
buf_ = nullptr; |
||||
|
} |
||||
|
|
||||
|
const char* data() const override { |
||||
|
return const_cast<const char*>(reinterpret_cast<char*>(vec_.base)); |
||||
|
} |
||||
|
|
||||
|
size_t length() const override { |
||||
|
return vec_.len; |
||||
|
} |
||||
|
|
||||
|
static Local<String> New(Isolate* isolate, nghttp2_rcbuf* buf) { |
||||
|
EscapableHandleScope scope(isolate); |
||||
|
nghttp2_vec vec = nghttp2_rcbuf_get_buf(buf); |
||||
|
if (vec.len == 0) { |
||||
|
nghttp2_rcbuf_decref(buf); |
||||
|
return scope.Escape(String::Empty(isolate)); |
||||
|
} |
||||
|
|
||||
|
ExternalHeader* h_str = new ExternalHeader(buf); |
||||
|
MaybeLocal<String> str = String::NewExternalOneByte(isolate, h_str); |
||||
|
isolate->AdjustAmountOfExternalAllocatedMemory(vec.len); |
||||
|
|
||||
|
if (str.IsEmpty()) { |
||||
|
delete h_str; |
||||
|
return scope.Escape(String::Empty(isolate)); |
||||
|
} |
||||
|
|
||||
|
return scope.Escape(str.ToLocalChecked()); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
nghttp2_rcbuf* buf_; |
||||
|
nghttp2_vec vec_; |
||||
|
}; |
||||
|
|
||||
|
class Headers { |
||||
|
public: |
||||
|
Headers(Isolate* isolate, Local<Context> context, Local<Array> headers) { |
||||
|
headers_.AllocateSufficientStorage(headers->Length()); |
||||
|
Local<Value> item; |
||||
|
Local<Array> header; |
||||
|
|
||||
|
for (size_t n = 0; n < headers->Length(); n++) { |
||||
|
item = headers->Get(context, n).ToLocalChecked(); |
||||
|
CHECK(item->IsArray()); |
||||
|
header = item.As<Array>(); |
||||
|
Local<Value> key = header->Get(context, 0).ToLocalChecked(); |
||||
|
Local<Value> value = header->Get(context, 1).ToLocalChecked(); |
||||
|
CHECK(key->IsString()); |
||||
|
CHECK(value->IsString()); |
||||
|
size_t keylen = StringBytes::StorageSize(isolate, key, ASCII); |
||||
|
size_t valuelen = StringBytes::StorageSize(isolate, value, ASCII); |
||||
|
headers_[n].flags = NGHTTP2_NV_FLAG_NONE; |
||||
|
Local<Value> flag = header->Get(context, 2).ToLocalChecked(); |
||||
|
if (flag->BooleanValue(context).ToChecked()) |
||||
|
headers_[n].flags |= NGHTTP2_NV_FLAG_NO_INDEX; |
||||
|
uint8_t* buf = Malloc<uint8_t>(keylen + valuelen); |
||||
|
headers_[n].name = buf; |
||||
|
headers_[n].value = buf + keylen; |
||||
|
headers_[n].namelen = |
||||
|
StringBytes::Write(isolate, |
||||
|
reinterpret_cast<char*>(headers_[n].name), |
||||
|
keylen, key, ASCII); |
||||
|
headers_[n].valuelen = |
||||
|
StringBytes::Write(isolate, |
||||
|
reinterpret_cast<char*>(headers_[n].value), |
||||
|
valuelen, value, ASCII); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
~Headers() { |
||||
|
for (size_t n = 0; n < headers_.length(); n++) |
||||
|
free(headers_[n].name); |
||||
|
} |
||||
|
|
||||
|
nghttp2_nv* operator*() { |
||||
|
return *headers_; |
||||
|
} |
||||
|
|
||||
|
size_t length() const { |
||||
|
return headers_.length(); |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
MaybeStackBuffer<nghttp2_nv> headers_; |
||||
|
}; |
||||
|
|
||||
|
} // namespace http2
|
||||
|
} // namespace node
|
||||
|
|
||||
|
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
|
||||
|
#endif // SRC_NODE_HTTP2_H_
|
||||
@ -0,0 +1,590 @@ |
|||||
|
#ifndef SRC_NODE_HTTP2_CORE_INL_H_ |
||||
|
#define SRC_NODE_HTTP2_CORE_INL_H_ |
||||
|
|
||||
|
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS |
||||
|
|
||||
|
#include "node_http2_core.h" |
||||
|
#include "node_internals.h" // arraysize |
||||
|
#include "freelist.h" |
||||
|
|
||||
|
namespace node { |
||||
|
namespace http2 { |
||||
|
|
||||
|
#define FREELIST_MAX 1024 |
||||
|
|
||||
|
#define LINKED_LIST_ADD(list, item) \ |
||||
|
do { \ |
||||
|
if (list ## _tail_ == nullptr) { \ |
||||
|
list ## _head_ = item; \ |
||||
|
list ## _tail_ = item; \ |
||||
|
} else { \ |
||||
|
list ## _tail_->next = item; \ |
||||
|
list ## _tail_ = item; \ |
||||
|
} \ |
||||
|
} while (0); |
||||
|
|
||||
|
extern Freelist<nghttp2_data_chunk_t, FREELIST_MAX> |
||||
|
data_chunk_free_list; |
||||
|
|
||||
|
extern Freelist<Nghttp2Stream, FREELIST_MAX> stream_free_list; |
||||
|
|
||||
|
extern Freelist<nghttp2_header_list, FREELIST_MAX> header_free_list; |
||||
|
|
||||
|
extern Freelist<nghttp2_data_chunks_t, FREELIST_MAX> |
||||
|
data_chunks_free_list; |
||||
|
|
||||
|
// See: https://nghttp2.org/documentation/nghttp2_submit_shutdown_notice.html
|
||||
|
inline void Nghttp2Session::SubmitShutdownNotice() { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: submitting shutdown notice\n", session_type_); |
||||
|
nghttp2_submit_shutdown_notice(session_); |
||||
|
} |
||||
|
|
||||
|
// Sends a SETTINGS frame on the current session
|
||||
|
// Note that this *should* send a SETTINGS frame even if niv == 0 and there
|
||||
|
// are no settings entries to send.
|
||||
|
inline int Nghttp2Session::SubmitSettings(const nghttp2_settings_entry iv[], |
||||
|
size_t niv) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: submitting settings, count: %d\n", |
||||
|
session_type_, niv); |
||||
|
return nghttp2_submit_settings(session_, NGHTTP2_FLAG_NONE, iv, niv); |
||||
|
} |
||||
|
|
||||
|
// Returns the Nghttp2Stream associated with the given id, or nullptr if none
|
||||
|
inline Nghttp2Stream* Nghttp2Session::FindStream(int32_t id) { |
||||
|
auto s = streams_.find(id); |
||||
|
if (s != streams_.end()) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: stream %d found\n", session_type_, id); |
||||
|
return s->second; |
||||
|
} else { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: stream %d not found\n", session_type_, id); |
||||
|
return nullptr; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Flushes any received queued chunks of data out to the JS layer
|
||||
|
inline void Nghttp2Stream::FlushDataChunks(bool done) { |
||||
|
while (data_chunks_head_ != nullptr) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: emitting data chunk\n", id_); |
||||
|
nghttp2_data_chunk_t* item = data_chunks_head_; |
||||
|
data_chunks_head_ = item->next; |
||||
|
// item will be passed to the Buffer instance and freed on gc
|
||||
|
session_->OnDataChunk(this, item); |
||||
|
} |
||||
|
data_chunks_tail_ = nullptr; |
||||
|
if (done) |
||||
|
session_->OnDataChunk(this, nullptr); |
||||
|
} |
||||
|
|
||||
|
// Passes all of the the chunks for a data frame out to the JS layer
|
||||
|
// The chunks are collected as the frame is being processed and sent out
|
||||
|
// to the JS side only when the frame is fully processed.
|
||||
|
inline void Nghttp2Session::HandleDataFrame(const nghttp2_frame* frame) { |
||||
|
int32_t id = frame->hd.stream_id; |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: handling data frame for stream %d\n", |
||||
|
session_type_, id); |
||||
|
Nghttp2Stream* stream = this->FindStream(id); |
||||
|
// If the stream does not exist, something really bad happened
|
||||
|
CHECK_NE(stream, nullptr); |
||||
|
bool done = (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) == |
||||
|
NGHTTP2_FLAG_END_STREAM; |
||||
|
stream->FlushDataChunks(done); |
||||
|
} |
||||
|
|
||||
|
// Passes all of the collected headers for a HEADERS frame out to the JS layer.
|
||||
|
// The headers are collected as the frame is being processed and sent out
|
||||
|
// to the JS side only when the frame is fully processed.
|
||||
|
inline void Nghttp2Session::HandleHeadersFrame(const nghttp2_frame* frame) { |
||||
|
int32_t id = (frame->hd.type == NGHTTP2_PUSH_PROMISE) ? |
||||
|
frame->push_promise.promised_stream_id : frame->hd.stream_id; |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: handling headers frame for stream %d\n", |
||||
|
session_type_, id); |
||||
|
Nghttp2Stream* stream = FindStream(id); |
||||
|
// If the stream does not exist, something really bad happened
|
||||
|
CHECK_NE(stream, nullptr); |
||||
|
OnHeaders(stream, |
||||
|
stream->headers(), |
||||
|
stream->headers_category(), |
||||
|
frame->hd.flags); |
||||
|
stream->FreeHeaders(); |
||||
|
} |
||||
|
|
||||
|
// Notifies the JS layer that a PRIORITY frame has been received
|
||||
|
inline void Nghttp2Session::HandlePriorityFrame(const nghttp2_frame* frame) { |
||||
|
nghttp2_priority priority_frame = frame->priority; |
||||
|
int32_t id = frame->hd.stream_id; |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: handling priority frame for stream %d\n", |
||||
|
session_type_, id); |
||||
|
// Ignore the priority frame if stream ID is <= 0
|
||||
|
// This actually should never happen because nghttp2 should treat this as
|
||||
|
// an error condition that terminates the session.
|
||||
|
if (id > 0) { |
||||
|
nghttp2_priority_spec spec = priority_frame.pri_spec; |
||||
|
OnPriority(id, spec.stream_id, spec.weight, spec.exclusive); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Notifies the JS layer that a GOAWAY frame has been received
|
||||
|
inline void Nghttp2Session::HandleGoawayFrame(const nghttp2_frame* frame) { |
||||
|
nghttp2_goaway goaway_frame = frame->goaway; |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: handling goaway frame\n", session_type_); |
||||
|
|
||||
|
OnGoAway(goaway_frame.last_stream_id, |
||||
|
goaway_frame.error_code, |
||||
|
goaway_frame.opaque_data, |
||||
|
goaway_frame.opaque_data_len); |
||||
|
} |
||||
|
|
||||
|
// Prompts nghttp2 to flush the queue of pending data frames
|
||||
|
inline void Nghttp2Session::SendPendingData() { |
||||
|
const uint8_t* data; |
||||
|
ssize_t len = 0; |
||||
|
size_t ncopy = 0; |
||||
|
uv_buf_t buf; |
||||
|
AllocateSend(SEND_BUFFER_RECOMMENDED_SIZE, &buf); |
||||
|
while (nghttp2_session_want_write(session_)) { |
||||
|
len = nghttp2_session_mem_send(session_, &data); |
||||
|
CHECK_GE(len, 0); // If this is less than zero, we're out of memory
|
||||
|
// While len is greater than 0, send a chunk
|
||||
|
while (len > 0) { |
||||
|
ncopy = len; |
||||
|
if (ncopy > buf.len) |
||||
|
ncopy = buf.len; |
||||
|
memcpy(buf.base, data, ncopy); |
||||
|
Send(&buf, ncopy); |
||||
|
len -= ncopy; |
||||
|
CHECK_GE(len, 0); // This should never be less than zero
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Initialize the Nghttp2Session handle by creating and
|
||||
|
// assigning the Nghttp2Session instance and associated
|
||||
|
// uv_loop_t.
|
||||
|
inline int Nghttp2Session::Init(uv_loop_t* loop, |
||||
|
const nghttp2_session_type type, |
||||
|
nghttp2_option* options, |
||||
|
nghttp2_mem* mem) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: initializing session\n", type); |
||||
|
loop_ = loop; |
||||
|
session_type_ = type; |
||||
|
int ret = 0; |
||||
|
|
||||
|
nghttp2_session_callbacks* callbacks |
||||
|
= callback_struct_saved[HasGetPaddingCallback() ? 1 : 0].callbacks; |
||||
|
|
||||
|
nghttp2_option* opts; |
||||
|
if (options != nullptr) { |
||||
|
opts = options; |
||||
|
} else { |
||||
|
nghttp2_option_new(&opts); |
||||
|
} |
||||
|
|
||||
|
switch (type) { |
||||
|
case NGHTTP2_SESSION_SERVER: |
||||
|
ret = nghttp2_session_server_new3(&session_, |
||||
|
callbacks, |
||||
|
this, |
||||
|
opts, |
||||
|
mem); |
||||
|
break; |
||||
|
case NGHTTP2_SESSION_CLIENT: |
||||
|
ret = nghttp2_session_client_new3(&session_, |
||||
|
callbacks, |
||||
|
this, |
||||
|
opts, |
||||
|
mem); |
||||
|
break; |
||||
|
} |
||||
|
if (opts != options) { |
||||
|
nghttp2_option_del(opts); |
||||
|
} |
||||
|
|
||||
|
// For every node::Http2Session instance, there is a uv_prep_t handle
|
||||
|
// whose callback is triggered on every tick of the event loop. When
|
||||
|
// run, nghttp2 is prompted to send any queued data it may have stored.
|
||||
|
uv_prepare_init(loop_, &prep_); |
||||
|
uv_prepare_start(&prep_, [](uv_prepare_t* t) { |
||||
|
Nghttp2Session* session = ContainerOf(&Nghttp2Session::prep_, t); |
||||
|
session->SendPendingData(); |
||||
|
}); |
||||
|
// uv_unref(reinterpret_cast<uv_handle_t*>(&prep_));
|
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
inline int Nghttp2Session::Free() { |
||||
|
assert(session_ != nullptr); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: freeing session\n", session_type_); |
||||
|
// Stop the loop
|
||||
|
uv_prepare_stop(&prep_); |
||||
|
auto PrepClose = [](uv_handle_t* handle) { |
||||
|
Nghttp2Session* session = |
||||
|
ContainerOf(&Nghttp2Session::prep_, |
||||
|
reinterpret_cast<uv_prepare_t*>(handle)); |
||||
|
|
||||
|
session->OnFreeSession(); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: session is free\n", |
||||
|
session->session_type_); |
||||
|
}; |
||||
|
uv_close(reinterpret_cast<uv_handle_t*>(&prep_), PrepClose); |
||||
|
|
||||
|
nghttp2_session_terminate_session(session_, NGHTTP2_NO_ERROR); |
||||
|
nghttp2_session_del(session_); |
||||
|
session_ = nullptr; |
||||
|
loop_ = nullptr; |
||||
|
return 1; |
||||
|
} |
||||
|
|
||||
|
// Write data received from the socket to the underlying nghttp2_session.
|
||||
|
inline ssize_t Nghttp2Session::Write(const uv_buf_t* bufs, unsigned int nbufs) { |
||||
|
size_t total = 0; |
||||
|
for (unsigned int n = 0; n < nbufs; n++) { |
||||
|
ssize_t ret = |
||||
|
nghttp2_session_mem_recv(session_, |
||||
|
reinterpret_cast<uint8_t*>(bufs[n].base), |
||||
|
bufs[n].len); |
||||
|
if (ret < 0) { |
||||
|
return ret; |
||||
|
} else { |
||||
|
total += ret; |
||||
|
} |
||||
|
} |
||||
|
SendPendingData(); |
||||
|
return total; |
||||
|
} |
||||
|
|
||||
|
inline void Nghttp2Session::AddStream(Nghttp2Stream* stream) { |
||||
|
streams_[stream->id()] = stream; |
||||
|
} |
||||
|
|
||||
|
// Removes a stream instance from this session
|
||||
|
inline void Nghttp2Session::RemoveStream(int32_t id) { |
||||
|
streams_.erase(id); |
||||
|
} |
||||
|
|
||||
|
// Implementation for Nghttp2Stream functions
|
||||
|
|
||||
|
inline Nghttp2Stream* Nghttp2Stream::Init( |
||||
|
int32_t id, |
||||
|
Nghttp2Session* session, |
||||
|
nghttp2_headers_category category) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: initializing stream\n", id); |
||||
|
Nghttp2Stream* stream = stream_free_list.pop(); |
||||
|
stream->ResetState(id, session, category); |
||||
|
session->AddStream(stream); |
||||
|
return stream; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Resets the state of the stream instance to defaults
|
||||
|
inline void Nghttp2Stream::ResetState( |
||||
|
int32_t id, |
||||
|
Nghttp2Session* session, |
||||
|
nghttp2_headers_category category) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: resetting stream state\n", id); |
||||
|
session_ = session; |
||||
|
queue_head_ = nullptr; |
||||
|
queue_tail_ = nullptr; |
||||
|
data_chunks_head_ = nullptr; |
||||
|
data_chunks_tail_ = nullptr; |
||||
|
current_headers_head_ = nullptr; |
||||
|
current_headers_tail_ = nullptr; |
||||
|
current_headers_category_ = category; |
||||
|
flags_ = NGHTTP2_STREAM_FLAG_NONE; |
||||
|
id_ = id; |
||||
|
code_ = NGHTTP2_NO_ERROR; |
||||
|
prev_local_window_size_ = 65535; |
||||
|
queue_head_index_ = 0; |
||||
|
queue_head_offset_ = 0; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
inline void Nghttp2Stream::Destroy() { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: destroying stream\n", id_); |
||||
|
// Do nothing if this stream instance is already destroyed
|
||||
|
if (IsDestroyed() || IsDestroying()) |
||||
|
return; |
||||
|
flags_ |= NGHTTP2_STREAM_DESTROYING; |
||||
|
Nghttp2Session* session = this->session_; |
||||
|
|
||||
|
if (session != nullptr) { |
||||
|
// Remove this stream from the associated session
|
||||
|
session_->RemoveStream(this->id()); |
||||
|
session_ = nullptr; |
||||
|
} |
||||
|
|
||||
|
// Free any remaining incoming data chunks.
|
||||
|
while (data_chunks_head_ != nullptr) { |
||||
|
nghttp2_data_chunk_t* chunk = data_chunks_head_; |
||||
|
data_chunks_head_ = chunk->next; |
||||
|
delete[] chunk->buf.base; |
||||
|
data_chunk_free_list.push(chunk); |
||||
|
} |
||||
|
data_chunks_tail_ = nullptr; |
||||
|
|
||||
|
// Free any remaining outgoing data chunks.
|
||||
|
while (queue_head_ != nullptr) { |
||||
|
nghttp2_stream_write_queue* head = queue_head_; |
||||
|
queue_head_ = head->next; |
||||
|
head->cb(head->req, UV_ECANCELED); |
||||
|
delete head; |
||||
|
} |
||||
|
queue_tail_ = nullptr; |
||||
|
|
||||
|
// Free any remaining headers
|
||||
|
FreeHeaders(); |
||||
|
|
||||
|
// Return this stream instance to the freelist
|
||||
|
stream_free_list.push(this); |
||||
|
} |
||||
|
|
||||
|
inline void Nghttp2Stream::FreeHeaders() { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: freeing headers\n", id_); |
||||
|
while (current_headers_head_ != nullptr) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: freeing header item\n", id_); |
||||
|
nghttp2_header_list* item = current_headers_head_; |
||||
|
current_headers_head_ = item->next; |
||||
|
header_free_list.push(item); |
||||
|
} |
||||
|
current_headers_tail_ = nullptr; |
||||
|
} |
||||
|
|
||||
|
// Submit informational headers for a stream.
|
||||
|
inline int Nghttp2Stream::SubmitInfo(nghttp2_nv* nva, size_t len) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: sending informational headers, count: %d\n", |
||||
|
id_, len); |
||||
|
CHECK_GT(len, 0); |
||||
|
return nghttp2_submit_headers(session_->session(), |
||||
|
NGHTTP2_FLAG_NONE, |
||||
|
id_, nullptr, |
||||
|
nva, len, nullptr); |
||||
|
} |
||||
|
|
||||
|
inline int Nghttp2Stream::SubmitPriority(nghttp2_priority_spec* prispec, |
||||
|
bool silent) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: sending priority spec\n", id_); |
||||
|
return silent ? |
||||
|
nghttp2_session_change_stream_priority(session_->session(), |
||||
|
id_, prispec) : |
||||
|
nghttp2_submit_priority(session_->session(), |
||||
|
NGHTTP2_FLAG_NONE, |
||||
|
id_, prispec); |
||||
|
} |
||||
|
|
||||
|
// Submit an RST_STREAM frame
|
||||
|
inline int Nghttp2Stream::SubmitRstStream(const uint32_t code) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: sending rst-stream, code: %d\n", id_, code); |
||||
|
session_->SendPendingData(); |
||||
|
return nghttp2_submit_rst_stream(session_->session(), |
||||
|
NGHTTP2_FLAG_NONE, |
||||
|
id_, |
||||
|
code); |
||||
|
} |
||||
|
|
||||
|
// Submit a push promise.
|
||||
|
inline int32_t Nghttp2Stream::SubmitPushPromise( |
||||
|
nghttp2_nv* nva, |
||||
|
size_t len, |
||||
|
Nghttp2Stream** assigned, |
||||
|
bool emptyPayload) { |
||||
|
CHECK_GT(len, 0); |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: sending push promise\n", id_); |
||||
|
int32_t ret = nghttp2_submit_push_promise(session_->session(), |
||||
|
NGHTTP2_FLAG_NONE, |
||||
|
id_, nva, len, |
||||
|
nullptr); |
||||
|
if (ret > 0) { |
||||
|
auto stream = Nghttp2Stream::Init(ret, session_); |
||||
|
if (emptyPayload) stream->Shutdown(); |
||||
|
if (assigned != nullptr) *assigned = stream; |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// Initiate a response. If the nghttp2_stream is still writable by
|
||||
|
// the time this is called, then an nghttp2_data_provider will be
|
||||
|
// initialized, causing at least one (possibly empty) data frame to
|
||||
|
// be sent.
|
||||
|
inline int Nghttp2Stream::SubmitResponse(nghttp2_nv* nva, |
||||
|
size_t len, |
||||
|
bool emptyPayload) { |
||||
|
CHECK_GT(len, 0); |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: submitting response\n", id_); |
||||
|
nghttp2_data_provider* provider = nullptr; |
||||
|
nghttp2_data_provider prov; |
||||
|
prov.source.ptr = this; |
||||
|
prov.read_callback = Nghttp2Session::OnStreamRead; |
||||
|
if (!emptyPayload && IsWritable()) |
||||
|
provider = &prov; |
||||
|
|
||||
|
return nghttp2_submit_response(session_->session(), id_, |
||||
|
nva, len, provider); |
||||
|
} |
||||
|
|
||||
|
// Initiate a response that contains data read from a file descriptor.
|
||||
|
inline int Nghttp2Stream::SubmitFile(int fd, nghttp2_nv* nva, size_t len) { |
||||
|
CHECK_GT(len, 0); |
||||
|
CHECK_GT(fd, 0); |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: submitting file\n", id_); |
||||
|
nghttp2_data_provider prov; |
||||
|
prov.source.ptr = this; |
||||
|
prov.source.fd = fd; |
||||
|
prov.read_callback = Nghttp2Session::OnStreamReadFD; |
||||
|
|
||||
|
return nghttp2_submit_response(session_->session(), id_, |
||||
|
nva, len, &prov); |
||||
|
} |
||||
|
|
||||
|
// Initiate a request. If writable is true (the default), then
|
||||
|
// an nghttp2_data_provider will be initialized, causing at
|
||||
|
// least one (possibly empty) data frame to to be sent.
|
||||
|
inline int32_t Nghttp2Session::SubmitRequest( |
||||
|
nghttp2_priority_spec* prispec, |
||||
|
nghttp2_nv* nva, |
||||
|
size_t len, |
||||
|
Nghttp2Stream** assigned, |
||||
|
bool emptyPayload) { |
||||
|
CHECK_GT(len, 0); |
||||
|
DEBUG_HTTP2("Nghttp2Session: submitting request\n"); |
||||
|
nghttp2_data_provider* provider = nullptr; |
||||
|
nghttp2_data_provider prov; |
||||
|
prov.source.ptr = this; |
||||
|
prov.read_callback = OnStreamRead; |
||||
|
if (!emptyPayload) |
||||
|
provider = &prov; |
||||
|
int32_t ret = nghttp2_submit_request(session_, |
||||
|
prispec, nva, len, |
||||
|
provider, nullptr); |
||||
|
// Assign the Nghttp2Stream handle
|
||||
|
if (ret > 0) { |
||||
|
Nghttp2Stream* stream = Nghttp2Stream::Init(ret, this); |
||||
|
if (emptyPayload) stream->Shutdown(); |
||||
|
if (assigned != nullptr) *assigned = stream; |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
// Queue the given set of uv_but_t handles for writing to an
|
||||
|
// nghttp2_stream. The callback will be invoked once the chunks
|
||||
|
// of data have been flushed to the underlying nghttp2_session.
|
||||
|
// Note that this does *not* mean that the data has been flushed
|
||||
|
// to the socket yet.
|
||||
|
inline int Nghttp2Stream::Write(nghttp2_stream_write_t* req, |
||||
|
const uv_buf_t bufs[], |
||||
|
unsigned int nbufs, |
||||
|
nghttp2_stream_write_cb cb) { |
||||
|
if (!IsWritable()) { |
||||
|
if (cb != nullptr) |
||||
|
cb(req, UV_EOF); |
||||
|
return 0; |
||||
|
} |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: queuing buffers to send, count: %d\n", |
||||
|
id_, nbufs); |
||||
|
nghttp2_stream_write_queue* item = new nghttp2_stream_write_queue; |
||||
|
item->cb = cb; |
||||
|
item->req = req; |
||||
|
item->nbufs = nbufs; |
||||
|
item->bufs.AllocateSufficientStorage(nbufs); |
||||
|
req->handle = this; |
||||
|
req->item = item; |
||||
|
memcpy(*(item->bufs), bufs, nbufs * sizeof(*bufs)); |
||||
|
|
||||
|
if (queue_head_ == nullptr) { |
||||
|
queue_head_ = item; |
||||
|
queue_tail_ = item; |
||||
|
} else { |
||||
|
queue_tail_->next = item; |
||||
|
queue_tail_ = item; |
||||
|
} |
||||
|
nghttp2_session_resume_data(session_->session(), id_); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
inline void Nghttp2Stream::ReadStart() { |
||||
|
// Has no effect if IsReading() is true.
|
||||
|
if (IsReading()) |
||||
|
return; |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: start reading\n", id_); |
||||
|
if (IsPaused()) { |
||||
|
// If handle->reading is less than zero, read_start had never previously
|
||||
|
// been called. If handle->reading is zero, reading had started and read
|
||||
|
// stop had been previously called, meaning that the flow control window
|
||||
|
// has been explicitly set to zero. Reset the flow control window now to
|
||||
|
// restart the flow of data.
|
||||
|
nghttp2_session_set_local_window_size(session_->session(), |
||||
|
NGHTTP2_FLAG_NONE, |
||||
|
id_, |
||||
|
prev_local_window_size_); |
||||
|
} |
||||
|
flags_ |= NGHTTP2_STREAM_READ_START; |
||||
|
flags_ &= ~NGHTTP2_STREAM_READ_PAUSED; |
||||
|
|
||||
|
// Flush any queued data chunks immediately out to the JS layer
|
||||
|
FlushDataChunks(); |
||||
|
} |
||||
|
|
||||
|
inline void Nghttp2Stream::ReadStop() { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: stop reading\n", id_); |
||||
|
// Has no effect if IsReading() is false, which will happen if we either
|
||||
|
// have not started reading yet at all (NGHTTP2_STREAM_READ_START is not
|
||||
|
// set) or if we're already paused (NGHTTP2_STREAM_READ_PAUSED is set.
|
||||
|
if (!IsReading()) |
||||
|
return; |
||||
|
flags_ |= NGHTTP2_STREAM_READ_PAUSED; |
||||
|
|
||||
|
// When not reading, explicitly set the local window size to 0 so that
|
||||
|
// the peer does not keep sending data that has to be buffered
|
||||
|
int32_t ret = |
||||
|
nghttp2_session_get_stream_local_window_size(session_->session(), id_); |
||||
|
if (ret >= 0) |
||||
|
prev_local_window_size_ = ret; |
||||
|
nghttp2_session_set_local_window_size(session_->session(), |
||||
|
NGHTTP2_FLAG_NONE, |
||||
|
id_, 0); |
||||
|
} |
||||
|
|
||||
|
nghttp2_data_chunks_t::~nghttp2_data_chunks_t() { |
||||
|
for (unsigned int n = 0; n < nbufs; n++) { |
||||
|
free(buf[n].base); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Nghttp2Session::Callbacks::Callbacks(bool kHasGetPaddingCallback) { |
||||
|
nghttp2_session_callbacks_new(&callbacks); |
||||
|
nghttp2_session_callbacks_set_on_begin_headers_callback( |
||||
|
callbacks, OnBeginHeadersCallback); |
||||
|
nghttp2_session_callbacks_set_on_header_callback2( |
||||
|
callbacks, OnHeaderCallback); |
||||
|
nghttp2_session_callbacks_set_on_frame_recv_callback( |
||||
|
callbacks, OnFrameReceive); |
||||
|
nghttp2_session_callbacks_set_on_stream_close_callback( |
||||
|
callbacks, OnStreamClose); |
||||
|
nghttp2_session_callbacks_set_on_data_chunk_recv_callback( |
||||
|
callbacks, OnDataChunkReceived); |
||||
|
nghttp2_session_callbacks_set_on_frame_not_send_callback( |
||||
|
callbacks, OnFrameNotSent); |
||||
|
|
||||
|
// nghttp2_session_callbacks_set_on_invalid_frame_recv(
|
||||
|
// callbacks, OnInvalidFrameReceived);
|
||||
|
|
||||
|
#ifdef NODE_DEBUG_HTTP2 |
||||
|
nghttp2_session_callbacks_set_error_callback( |
||||
|
callbacks, OnNghttpError); |
||||
|
#endif |
||||
|
|
||||
|
if (kHasGetPaddingCallback) { |
||||
|
nghttp2_session_callbacks_set_select_padding_callback( |
||||
|
callbacks, OnSelectPadding); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Nghttp2Session::Callbacks::~Callbacks() { |
||||
|
nghttp2_session_callbacks_del(callbacks); |
||||
|
} |
||||
|
|
||||
|
} // namespace http2
|
||||
|
} // namespace node
|
||||
|
|
||||
|
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
|
||||
|
#endif // SRC_NODE_HTTP2_CORE_INL_H_
|
||||
@ -0,0 +1,326 @@ |
|||||
|
#include "node_http2_core-inl.h" |
||||
|
|
||||
|
namespace node { |
||||
|
namespace http2 { |
||||
|
|
||||
|
#ifdef NODE_DEBUG_HTTP2 |
||||
|
int Nghttp2Session::OnNghttpError(nghttp2_session* session, |
||||
|
const char* message, |
||||
|
size_t len, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: Error '%.*s'\n", |
||||
|
handle->session_type_, len, message); |
||||
|
return 0; |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
// nghttp2 calls this at the beginning a new HEADERS or PUSH_PROMISE frame.
|
||||
|
// We use it to ensure that an Nghttp2Stream instance is allocated to store
|
||||
|
// the state.
|
||||
|
int Nghttp2Session::OnBeginHeadersCallback(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
int32_t id = (frame->hd.type == NGHTTP2_PUSH_PROMISE) ? |
||||
|
frame->push_promise.promised_stream_id : |
||||
|
frame->hd.stream_id; |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: beginning headers for stream %d\n", |
||||
|
handle->session_type_, id); |
||||
|
|
||||
|
Nghttp2Stream* stream = handle->FindStream(id); |
||||
|
if (stream == nullptr) { |
||||
|
Nghttp2Stream::Init(id, handle, frame->headers.cat); |
||||
|
} else { |
||||
|
stream->StartHeaders(frame->headers.cat); |
||||
|
} |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// nghttp2 calls this once for every header name-value pair in a HEADERS
|
||||
|
// or PUSH_PROMISE block. CONTINUATION frames are handled automatically
|
||||
|
// and transparently so we do not need to worry about those at all.
|
||||
|
int Nghttp2Session::OnHeaderCallback(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
nghttp2_rcbuf *name, |
||||
|
nghttp2_rcbuf *value, |
||||
|
uint8_t flags, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
int32_t id = (frame->hd.type == NGHTTP2_PUSH_PROMISE) ? |
||||
|
frame->push_promise.promised_stream_id : |
||||
|
frame->hd.stream_id; |
||||
|
Nghttp2Stream* stream = handle->FindStream(id); |
||||
|
nghttp2_header_list* header = header_free_list.pop(); |
||||
|
header->name = name; |
||||
|
header->value = value; |
||||
|
nghttp2_rcbuf_incref(name); |
||||
|
nghttp2_rcbuf_incref(value); |
||||
|
LINKED_LIST_ADD(stream->current_headers, header); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// When nghttp2 has completely processed a frame, it calls OnFrameReceive.
|
||||
|
// It is our responsibility to delegate out from there. We can ignore most
|
||||
|
// control frames since nghttp2 will handle those for us.
|
||||
|
int Nghttp2Session::OnFrameReceive(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: complete frame received: type: %d\n", |
||||
|
handle->session_type_, frame->hd.type); |
||||
|
bool ack; |
||||
|
switch (frame->hd.type) { |
||||
|
case NGHTTP2_DATA: |
||||
|
handle->HandleDataFrame(frame); |
||||
|
break; |
||||
|
case NGHTTP2_PUSH_PROMISE: |
||||
|
case NGHTTP2_HEADERS: |
||||
|
handle->HandleHeadersFrame(frame); |
||||
|
break; |
||||
|
case NGHTTP2_SETTINGS: |
||||
|
ack = (frame->hd.flags & NGHTTP2_FLAG_ACK) == NGHTTP2_FLAG_ACK; |
||||
|
handle->OnSettings(ack); |
||||
|
break; |
||||
|
case NGHTTP2_PRIORITY: |
||||
|
handle->HandlePriorityFrame(frame); |
||||
|
break; |
||||
|
case NGHTTP2_GOAWAY: |
||||
|
handle->HandleGoawayFrame(frame); |
||||
|
break; |
||||
|
default: |
||||
|
break; |
||||
|
} |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
int Nghttp2Session::OnFrameNotSent(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
int error_code, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: frame type %d was not sent, code: %d\n", |
||||
|
handle->session_type_, frame->hd.type, error_code); |
||||
|
// Do not report if the frame was not sent due to the session closing
|
||||
|
if (error_code != NGHTTP2_ERR_SESSION_CLOSING && |
||||
|
error_code != NGHTTP2_ERR_STREAM_CLOSED && |
||||
|
error_code != NGHTTP2_ERR_STREAM_CLOSING) |
||||
|
handle->OnFrameError(frame->hd.stream_id, frame->hd.type, error_code); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// Called when nghttp2 closes a stream, either in response to an RST_STREAM
|
||||
|
// frame or the stream closing naturally on it's own
|
||||
|
int Nghttp2Session::OnStreamClose(nghttp2_session *session, |
||||
|
int32_t id, |
||||
|
uint32_t code, |
||||
|
void *user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: stream %d closed, code: %d\n", |
||||
|
handle->session_type_, id, code); |
||||
|
Nghttp2Stream* stream = handle->FindStream(id); |
||||
|
// Intentionally ignore the callback if the stream does not exist
|
||||
|
if (stream != nullptr) |
||||
|
stream->Close(code); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// Called by nghttp2 multiple times while processing a DATA frame
|
||||
|
int Nghttp2Session::OnDataChunkReceived(nghttp2_session *session, |
||||
|
uint8_t flags, |
||||
|
int32_t id, |
||||
|
const uint8_t *data, |
||||
|
size_t len, |
||||
|
void *user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: buffering data chunk for stream %d, size: " |
||||
|
"%d, flags: %d\n", handle->session_type_, id, len, flags); |
||||
|
Nghttp2Stream* stream = handle->FindStream(id); |
||||
|
nghttp2_data_chunk_t* chunk = data_chunk_free_list.pop(); |
||||
|
chunk->buf = uv_buf_init(new char[len], len); |
||||
|
memcpy(chunk->buf.base, data, len); |
||||
|
if (stream->data_chunks_tail_ == nullptr) { |
||||
|
stream->data_chunks_head_ = |
||||
|
stream->data_chunks_tail_ = chunk; |
||||
|
} else { |
||||
|
stream->data_chunks_tail_->next = chunk; |
||||
|
stream->data_chunks_tail_ = chunk; |
||||
|
} |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// Called by nghttp2 when it needs to determine how much padding to apply
|
||||
|
// to a DATA or HEADERS frame
|
||||
|
ssize_t Nghttp2Session::OnSelectPadding(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
size_t maxPayloadLen, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
assert(handle->HasGetPaddingCallback()); |
||||
|
ssize_t padding = handle->GetPadding(frame->hd.length, maxPayloadLen); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: using padding, size: %d\n", |
||||
|
handle->session_type_, padding); |
||||
|
return padding; |
||||
|
} |
||||
|
|
||||
|
// Called by nghttp2 to collect the data while a file response is sent.
|
||||
|
// The buf is the DATA frame buffer that needs to be filled with at most
|
||||
|
// length bytes. flags is used to control what nghttp2 does next.
|
||||
|
ssize_t Nghttp2Session::OnStreamReadFD(nghttp2_session* session, |
||||
|
int32_t id, |
||||
|
uint8_t* buf, |
||||
|
size_t length, |
||||
|
uint32_t* flags, |
||||
|
nghttp2_data_source* source, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: reading outbound file data for stream %d\n", |
||||
|
handle->session_type_, id); |
||||
|
Nghttp2Stream* stream = handle->FindStream(id); |
||||
|
|
||||
|
int fd = source->fd; |
||||
|
int64_t offset = stream->fd_offset_; |
||||
|
ssize_t numchars; |
||||
|
|
||||
|
uv_buf_t data; |
||||
|
data.base = reinterpret_cast<char*>(buf); |
||||
|
data.len = length; |
||||
|
|
||||
|
uv_fs_t read_req; |
||||
|
numchars = uv_fs_read(handle->loop_, |
||||
|
&read_req, |
||||
|
fd, &data, 1, |
||||
|
offset, nullptr); |
||||
|
uv_fs_req_cleanup(&read_req); |
||||
|
|
||||
|
// Close the stream with an error if reading fails
|
||||
|
if (numchars < 0) |
||||
|
return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; |
||||
|
|
||||
|
// Update the read offset for the next read
|
||||
|
stream->fd_offset_ += numchars; |
||||
|
|
||||
|
// if numchars < length, assume that we are done.
|
||||
|
if (static_cast<size_t>(numchars) < length) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: no more data for stream %d\n", |
||||
|
handle->session_type_, id); |
||||
|
*flags |= NGHTTP2_DATA_FLAG_EOF; |
||||
|
// Sending trailers is not permitted with this provider.
|
||||
|
} |
||||
|
|
||||
|
return numchars; |
||||
|
} |
||||
|
|
||||
|
// Called by nghttp2 to collect the data to pack within a DATA frame.
|
||||
|
// The buf is the DATA frame buffer that needs to be filled with at most
|
||||
|
// length bytes. flags is used to control what nghttp2 does next.
|
||||
|
ssize_t Nghttp2Session::OnStreamRead(nghttp2_session* session, |
||||
|
int32_t id, |
||||
|
uint8_t* buf, |
||||
|
size_t length, |
||||
|
uint32_t* flags, |
||||
|
nghttp2_data_source* source, |
||||
|
void* user_data) { |
||||
|
Nghttp2Session* handle = static_cast<Nghttp2Session*>(user_data); |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: reading outbound data for stream %d\n", |
||||
|
handle->session_type_, id); |
||||
|
Nghttp2Stream* stream = handle->FindStream(id); |
||||
|
size_t remaining = length; |
||||
|
size_t offset = 0; |
||||
|
|
||||
|
// While there is data in the queue, copy data into buf until it is full.
|
||||
|
// There may be data left over, which will be sent the next time nghttp
|
||||
|
// calls this callback.
|
||||
|
while (stream->queue_head_ != nullptr) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: processing outbound data chunk\n", |
||||
|
handle->session_type_); |
||||
|
nghttp2_stream_write_queue* head = stream->queue_head_; |
||||
|
while (stream->queue_head_index_ < head->nbufs) { |
||||
|
if (remaining == 0) { |
||||
|
goto end; |
||||
|
} |
||||
|
|
||||
|
unsigned int n = stream->queue_head_index_; |
||||
|
// len is the number of bytes in head->bufs[n] that are yet to be written
|
||||
|
size_t len = head->bufs[n].len - stream->queue_head_offset_; |
||||
|
size_t bytes_to_write = len < remaining ? len : remaining; |
||||
|
memcpy(buf + offset, |
||||
|
head->bufs[n].base + stream->queue_head_offset_, |
||||
|
bytes_to_write); |
||||
|
offset += bytes_to_write; |
||||
|
remaining -= bytes_to_write; |
||||
|
if (bytes_to_write < len) { |
||||
|
stream->queue_head_offset_ += bytes_to_write; |
||||
|
} else { |
||||
|
stream->queue_head_index_++; |
||||
|
stream->queue_head_offset_ = 0; |
||||
|
} |
||||
|
} |
||||
|
stream->queue_head_offset_ = 0; |
||||
|
stream->queue_head_index_ = 0; |
||||
|
stream->queue_head_ = head->next; |
||||
|
head->cb(head->req, 0); |
||||
|
delete head; |
||||
|
} |
||||
|
stream->queue_tail_ = nullptr; |
||||
|
|
||||
|
end: |
||||
|
// If we are no longer writable and there is no more data in the queue,
|
||||
|
// then we need to set the NGHTTP2_DATA_FLAG_EOF flag.
|
||||
|
// If we are still writable but there is not yet any data to send, set the
|
||||
|
// NGHTTP2_ERR_DEFERRED flag. This will put the stream into a pending state
|
||||
|
// that will wait for data to become available.
|
||||
|
// If neither of these flags are set, then nghttp2 will call this callback
|
||||
|
// again to get the data for the next DATA frame.
|
||||
|
int writable = stream->queue_head_ != nullptr || stream->IsWritable(); |
||||
|
if (offset == 0 && writable && stream->queue_head_ == nullptr) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: deferring stream %d\n", |
||||
|
handle->session_type_, id); |
||||
|
return NGHTTP2_ERR_DEFERRED; |
||||
|
} |
||||
|
if (!writable) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: no more data for stream %d\n", |
||||
|
handle->session_type_, id); |
||||
|
*flags |= NGHTTP2_DATA_FLAG_EOF; |
||||
|
|
||||
|
// Only when we are done sending the last chunk of data do we check for
|
||||
|
// any trailing headers that are to be sent. This is the only opportunity
|
||||
|
// we have to make this check. If there are trailers, then the
|
||||
|
// NGHTTP2_DATA_FLAG_NO_END_STREAM flag must be set.
|
||||
|
MaybeStackBuffer<nghttp2_nv> trailers; |
||||
|
handle->OnTrailers(stream, &trailers); |
||||
|
if (trailers.length() > 0) { |
||||
|
DEBUG_HTTP2("Nghttp2Session %d: sending trailers for stream %d, " |
||||
|
"count: %d\n", handle->session_type_, id, trailers.length()); |
||||
|
*flags |= NGHTTP2_DATA_FLAG_NO_END_STREAM; |
||||
|
nghttp2_submit_trailer(session, |
||||
|
stream->id(), |
||||
|
*trailers, |
||||
|
trailers.length()); |
||||
|
} |
||||
|
for (size_t n = 0; n < trailers.length(); n++) { |
||||
|
free(trailers[n].name); |
||||
|
free(trailers[n].value); |
||||
|
} |
||||
|
} |
||||
|
assert(offset <= length); |
||||
|
return offset; |
||||
|
} |
||||
|
|
||||
|
Freelist<nghttp2_data_chunk_t, FREELIST_MAX> |
||||
|
data_chunk_free_list; |
||||
|
|
||||
|
Freelist<Nghttp2Stream, FREELIST_MAX> stream_free_list; |
||||
|
|
||||
|
Freelist<nghttp2_header_list, FREELIST_MAX> header_free_list; |
||||
|
|
||||
|
Freelist<nghttp2_data_chunks_t, FREELIST_MAX> |
||||
|
data_chunks_free_list; |
||||
|
|
||||
|
Nghttp2Session::Callbacks Nghttp2Session::callback_struct_saved[2] = { |
||||
|
Callbacks(false), |
||||
|
Callbacks(true) |
||||
|
}; |
||||
|
|
||||
|
} // namespace http2
|
||||
|
} // namespace node
|
||||
@ -0,0 +1,465 @@ |
|||||
|
#ifndef SRC_NODE_HTTP2_CORE_H_ |
||||
|
#define SRC_NODE_HTTP2_CORE_H_ |
||||
|
|
||||
|
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS |
||||
|
|
||||
|
#include "util.h" |
||||
|
#include "util-inl.h" |
||||
|
#include "uv.h" |
||||
|
#include "nghttp2/nghttp2.h" |
||||
|
|
||||
|
#include <stdio.h> |
||||
|
#include <unordered_map> |
||||
|
|
||||
|
namespace node { |
||||
|
namespace http2 { |
||||
|
|
||||
|
#ifdef NODE_DEBUG_HTTP2 |
||||
|
|
||||
|
// Adapted from nghttp2 own debug printer
|
||||
|
static inline void _debug_vfprintf(const char *fmt, va_list args) { |
||||
|
vfprintf(stderr, fmt, args); |
||||
|
} |
||||
|
|
||||
|
void inline debug_vfprintf(const char *format, ...) { |
||||
|
va_list args; |
||||
|
va_start(args, format); |
||||
|
_debug_vfprintf(format, args); |
||||
|
va_end(args); |
||||
|
} |
||||
|
|
||||
|
#define DEBUG_HTTP2(...) debug_vfprintf(__VA_ARGS__); |
||||
|
#else |
||||
|
#define DEBUG_HTTP2(...) \ |
||||
|
do { \ |
||||
|
} while (0) |
||||
|
#endif |
||||
|
|
||||
|
class Nghttp2Session; |
||||
|
class Nghttp2Stream; |
||||
|
|
||||
|
struct nghttp2_stream_write_t; |
||||
|
struct nghttp2_data_chunk_t; |
||||
|
struct nghttp2_data_chunks_t; |
||||
|
|
||||
|
#define MAX_BUFFER_COUNT 10 |
||||
|
#define SEND_BUFFER_RECOMMENDED_SIZE 4096 |
||||
|
|
||||
|
enum nghttp2_session_type { |
||||
|
NGHTTP2_SESSION_SERVER, |
||||
|
NGHTTP2_SESSION_CLIENT |
||||
|
}; |
||||
|
|
||||
|
enum nghttp2_shutdown_flags { |
||||
|
NGHTTP2_SHUTDOWN_FLAG_GRACEFUL |
||||
|
}; |
||||
|
|
||||
|
enum nghttp2_stream_flags { |
||||
|
NGHTTP2_STREAM_FLAG_NONE = 0x0, |
||||
|
// Writable side has ended
|
||||
|
NGHTTP2_STREAM_FLAG_SHUT = 0x1, |
||||
|
// Reading has started
|
||||
|
NGHTTP2_STREAM_READ_START = 0x2, |
||||
|
// Reading is paused
|
||||
|
NGHTTP2_STREAM_READ_PAUSED = 0x4, |
||||
|
// Stream is closed
|
||||
|
NGHTTP2_STREAM_CLOSED = 0x8, |
||||
|
// Stream is destroyed
|
||||
|
NGHTTP2_STREAM_DESTROYED = 0x10, |
||||
|
// Stream is being destroyed
|
||||
|
NGHTTP2_STREAM_DESTROYING = 0x20 |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
// Callbacks
|
||||
|
typedef void (*nghttp2_stream_write_cb)( |
||||
|
nghttp2_stream_write_t* req, |
||||
|
int status); |
||||
|
|
||||
|
struct nghttp2_stream_write_queue { |
||||
|
unsigned int nbufs = 0; |
||||
|
nghttp2_stream_write_t* req = nullptr; |
||||
|
nghttp2_stream_write_cb cb = nullptr; |
||||
|
nghttp2_stream_write_queue* next = nullptr; |
||||
|
MaybeStackBuffer<uv_buf_t, MAX_BUFFER_COUNT> bufs; |
||||
|
}; |
||||
|
|
||||
|
struct nghttp2_header_list { |
||||
|
nghttp2_rcbuf* name = nullptr; |
||||
|
nghttp2_rcbuf* value = nullptr; |
||||
|
nghttp2_header_list* next = nullptr; |
||||
|
}; |
||||
|
|
||||
|
// Handle Types
|
||||
|
class Nghttp2Session { |
||||
|
public: |
||||
|
// Initializes the session instance
|
||||
|
inline int Init( |
||||
|
uv_loop_t*, |
||||
|
const nghttp2_session_type type = NGHTTP2_SESSION_SERVER, |
||||
|
nghttp2_option* options = nullptr, |
||||
|
nghttp2_mem* mem = nullptr); |
||||
|
|
||||
|
// Frees this session instance
|
||||
|
inline int Free(); |
||||
|
|
||||
|
// Returns the pointer to the identified stream, or nullptr if
|
||||
|
// the stream does not exist
|
||||
|
inline Nghttp2Stream* FindStream(int32_t id); |
||||
|
|
||||
|
// Submits a new request. If the request is a success, assigned
|
||||
|
// will be a pointer to the Nghttp2Stream instance assigned.
|
||||
|
// This only works if the session is a client session.
|
||||
|
inline int32_t SubmitRequest( |
||||
|
nghttp2_priority_spec* prispec, |
||||
|
nghttp2_nv* nva, |
||||
|
size_t len, |
||||
|
Nghttp2Stream** assigned = nullptr, |
||||
|
bool emptyPayload = true); |
||||
|
|
||||
|
// Submits a notice to the connected peer that the session is in the
|
||||
|
// process of shutting down.
|
||||
|
inline void SubmitShutdownNotice(); |
||||
|
|
||||
|
// Submits a SETTINGS frame to the connected peer.
|
||||
|
inline int SubmitSettings(const nghttp2_settings_entry iv[], size_t niv); |
||||
|
|
||||
|
// Write data to the session
|
||||
|
inline ssize_t Write(const uv_buf_t* bufs, unsigned int nbufs); |
||||
|
|
||||
|
// Returns the nghttp2 library session
|
||||
|
inline nghttp2_session* session() { return session_; } |
||||
|
|
||||
|
protected: |
||||
|
// Adds a stream instance to this session
|
||||
|
inline void AddStream(Nghttp2Stream* stream); |
||||
|
|
||||
|
// Removes a stream instance from this session
|
||||
|
inline void RemoveStream(int32_t id); |
||||
|
|
||||
|
virtual void Send(uv_buf_t* buf, |
||||
|
size_t length) {} |
||||
|
virtual void OnHeaders(Nghttp2Stream* stream, |
||||
|
nghttp2_header_list* headers, |
||||
|
nghttp2_headers_category cat, |
||||
|
uint8_t flags) {} |
||||
|
virtual void OnStreamClose(int32_t id, uint32_t code) {} |
||||
|
virtual void OnDataChunk(Nghttp2Stream* stream, |
||||
|
nghttp2_data_chunk_t* chunk) {} |
||||
|
virtual void OnSettings(bool ack) {} |
||||
|
virtual void OnPriority(int32_t id, |
||||
|
int32_t parent, |
||||
|
int32_t weight, |
||||
|
int8_t exclusive) {} |
||||
|
virtual void OnGoAway(int32_t lastStreamID, |
||||
|
uint32_t errorCode, |
||||
|
uint8_t* data, |
||||
|
size_t length) {} |
||||
|
virtual void OnFrameError(int32_t id, |
||||
|
uint8_t type, |
||||
|
int error_code) {} |
||||
|
virtual ssize_t GetPadding(size_t frameLength, |
||||
|
size_t maxFrameLength) { return 0; } |
||||
|
virtual void OnTrailers(Nghttp2Stream* stream, |
||||
|
MaybeStackBuffer<nghttp2_nv>* nva) {} |
||||
|
virtual void OnFreeSession() {} |
||||
|
virtual void AllocateSend(size_t suggested_size, uv_buf_t* buf) = 0; |
||||
|
|
||||
|
virtual bool HasGetPaddingCallback() { return false; } |
||||
|
|
||||
|
private: |
||||
|
inline void SendPendingData(); |
||||
|
inline void HandleHeadersFrame(const nghttp2_frame* frame); |
||||
|
inline void HandlePriorityFrame(const nghttp2_frame* frame); |
||||
|
inline void HandleDataFrame(const nghttp2_frame* frame); |
||||
|
inline void HandleGoawayFrame(const nghttp2_frame* frame); |
||||
|
|
||||
|
/* callbacks for nghttp2 */ |
||||
|
#ifdef NODE_DEBUG_HTTP2 |
||||
|
static int OnNghttpError(nghttp2_session* session, |
||||
|
const char* message, |
||||
|
size_t len, |
||||
|
void* user_data); |
||||
|
#endif |
||||
|
|
||||
|
static int OnBeginHeadersCallback(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
void* user_data); |
||||
|
static int OnHeaderCallback(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
nghttp2_rcbuf* name, |
||||
|
nghttp2_rcbuf* value, |
||||
|
uint8_t flags, |
||||
|
void* user_data); |
||||
|
static int OnFrameReceive(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
void* user_data); |
||||
|
static int OnFrameNotSent(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
int error_code, |
||||
|
void* user_data); |
||||
|
static int OnStreamClose(nghttp2_session* session, |
||||
|
int32_t id, |
||||
|
uint32_t code, |
||||
|
void* user_data); |
||||
|
static int OnDataChunkReceived(nghttp2_session* session, |
||||
|
uint8_t flags, |
||||
|
int32_t id, |
||||
|
const uint8_t *data, |
||||
|
size_t len, |
||||
|
void* user_data); |
||||
|
static ssize_t OnStreamReadFD(nghttp2_session* session, |
||||
|
int32_t id, |
||||
|
uint8_t* buf, |
||||
|
size_t length, |
||||
|
uint32_t* flags, |
||||
|
nghttp2_data_source* source, |
||||
|
void* user_data); |
||||
|
static ssize_t OnStreamRead(nghttp2_session* session, |
||||
|
int32_t id, |
||||
|
uint8_t* buf, |
||||
|
size_t length, |
||||
|
uint32_t* flags, |
||||
|
nghttp2_data_source* source, |
||||
|
void* user_data); |
||||
|
static ssize_t OnSelectPadding(nghttp2_session* session, |
||||
|
const nghttp2_frame* frame, |
||||
|
size_t maxPayloadLen, |
||||
|
void* user_data); |
||||
|
|
||||
|
struct Callbacks { |
||||
|
inline explicit Callbacks(bool kHasGetPaddingCallback); |
||||
|
inline ~Callbacks(); |
||||
|
|
||||
|
nghttp2_session_callbacks* callbacks; |
||||
|
}; |
||||
|
|
||||
|
/* Use callback_struct_saved[kHasGetPaddingCallback ? 1 : 0] */ |
||||
|
static Callbacks callback_struct_saved[2]; |
||||
|
|
||||
|
nghttp2_session* session_; |
||||
|
uv_loop_t* loop_; |
||||
|
uv_prepare_t prep_; |
||||
|
nghttp2_session_type session_type_; |
||||
|
std::unordered_map<int32_t, Nghttp2Stream*> streams_; |
||||
|
|
||||
|
friend class Nghttp2Stream; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
|
||||
|
class Nghttp2Stream { |
||||
|
public: |
||||
|
static inline Nghttp2Stream* Init( |
||||
|
int32_t id, |
||||
|
Nghttp2Session* session, |
||||
|
nghttp2_headers_category category = NGHTTP2_HCAT_HEADERS); |
||||
|
|
||||
|
inline ~Nghttp2Stream() { |
||||
|
CHECK_EQ(session_, nullptr); |
||||
|
CHECK_EQ(queue_head_, nullptr); |
||||
|
CHECK_EQ(queue_tail_, nullptr); |
||||
|
CHECK_EQ(data_chunks_head_, nullptr); |
||||
|
CHECK_EQ(data_chunks_tail_, nullptr); |
||||
|
CHECK_EQ(current_headers_head_, nullptr); |
||||
|
CHECK_EQ(current_headers_tail_, nullptr); |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: freed\n", id_); |
||||
|
} |
||||
|
|
||||
|
inline void FlushDataChunks(bool done = false); |
||||
|
|
||||
|
// Resets the state of the stream instance to defaults
|
||||
|
inline void ResetState( |
||||
|
int32_t id, |
||||
|
Nghttp2Session* session, |
||||
|
nghttp2_headers_category category = NGHTTP2_HCAT_HEADERS); |
||||
|
|
||||
|
// Destroy this stream instance and free all held memory.
|
||||
|
// Note that this will free queued outbound and inbound
|
||||
|
// data chunks and inbound headers, so it's important not
|
||||
|
// to call this until those are fully consumed.
|
||||
|
//
|
||||
|
// Also note: this does not actually destroy the instance.
|
||||
|
// instead, it frees the held memory, removes the stream
|
||||
|
// from the parent session, and returns the instance to
|
||||
|
// the FreeList so that it can be reused.
|
||||
|
inline void Destroy(); |
||||
|
|
||||
|
// Returns true if this stream has been destroyed
|
||||
|
inline bool IsDestroyed() const { |
||||
|
return (flags_ & NGHTTP2_STREAM_DESTROYED) == NGHTTP2_STREAM_DESTROYED; |
||||
|
} |
||||
|
|
||||
|
inline bool IsDestroying() const { |
||||
|
return (flags_ & NGHTTP2_STREAM_DESTROYING) == NGHTTP2_STREAM_DESTROYING; |
||||
|
} |
||||
|
|
||||
|
// Queue outbound chunks of data to be sent on this stream
|
||||
|
inline int Write( |
||||
|
nghttp2_stream_write_t* req, |
||||
|
const uv_buf_t bufs[], |
||||
|
unsigned int nbufs, |
||||
|
nghttp2_stream_write_cb cb); |
||||
|
|
||||
|
// Initiate a response on this stream.
|
||||
|
inline int SubmitResponse(nghttp2_nv* nva, |
||||
|
size_t len, |
||||
|
bool emptyPayload = false); |
||||
|
|
||||
|
// Send data read from a file descriptor as the response on this stream.
|
||||
|
inline int SubmitFile(int fd, nghttp2_nv* nva, size_t len); |
||||
|
|
||||
|
// Submit informational headers for this stream
|
||||
|
inline int SubmitInfo(nghttp2_nv* nva, size_t len); |
||||
|
|
||||
|
// Submit a PRIORITY frame for this stream
|
||||
|
inline int SubmitPriority(nghttp2_priority_spec* prispec, |
||||
|
bool silent = false); |
||||
|
|
||||
|
// Submits an RST_STREAM frame using the given code
|
||||
|
inline int SubmitRstStream(const uint32_t code); |
||||
|
|
||||
|
// Submits a PUSH_PROMISE frame with this stream as the parent.
|
||||
|
inline int SubmitPushPromise( |
||||
|
nghttp2_nv* nva, |
||||
|
size_t len, |
||||
|
Nghttp2Stream** assigned = nullptr, |
||||
|
bool writable = true); |
||||
|
|
||||
|
// Marks the Writable side of the stream as being shutdown
|
||||
|
inline void Shutdown() { |
||||
|
flags_ |= NGHTTP2_STREAM_FLAG_SHUT; |
||||
|
nghttp2_session_resume_data(session_->session(), id_); |
||||
|
} |
||||
|
|
||||
|
// Returns true if this stream is writable.
|
||||
|
inline bool IsWritable() const { |
||||
|
return (flags_ & NGHTTP2_STREAM_FLAG_SHUT) == 0; |
||||
|
} |
||||
|
|
||||
|
// Start Reading. If there are queued data chunks, they are pushed into
|
||||
|
// the session to be emitted at the JS side
|
||||
|
inline void ReadStart(); |
||||
|
|
||||
|
// Stop/Pause Reading.
|
||||
|
inline void ReadStop(); |
||||
|
|
||||
|
// Returns true if reading is paused
|
||||
|
inline bool IsPaused() const { |
||||
|
return (flags_ & NGHTTP2_STREAM_READ_PAUSED) == NGHTTP2_STREAM_READ_PAUSED; |
||||
|
} |
||||
|
|
||||
|
// Returns true if this stream is in the reading state, which occurs when
|
||||
|
// the NGHTTP2_STREAM_READ_START flag has been set and the
|
||||
|
// NGHTTP2_STREAM_READ_PAUSED flag is *not* set.
|
||||
|
inline bool IsReading() const { |
||||
|
return ((flags_ & NGHTTP2_STREAM_READ_START) == NGHTTP2_STREAM_READ_START) |
||||
|
&& ((flags_ & NGHTTP2_STREAM_READ_PAUSED) == 0); |
||||
|
} |
||||
|
|
||||
|
inline void Close(int32_t code) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: closing with code %d\n", id_, code); |
||||
|
flags_ |= NGHTTP2_STREAM_CLOSED; |
||||
|
code_ = code; |
||||
|
session_->OnStreamClose(id_, code); |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: closed\n", id_); |
||||
|
} |
||||
|
|
||||
|
// Returns true if this stream has been closed either by receiving or
|
||||
|
// sending an RST_STREAM frame.
|
||||
|
inline bool IsClosed() const { |
||||
|
return (flags_ & NGHTTP2_STREAM_CLOSED) == NGHTTP2_STREAM_CLOSED; |
||||
|
} |
||||
|
|
||||
|
// Returns the RST_STREAM code used to close this stream
|
||||
|
inline int32_t code() const { |
||||
|
return code_; |
||||
|
} |
||||
|
|
||||
|
// Returns the stream identifier for this stream
|
||||
|
inline int32_t id() const { |
||||
|
return id_; |
||||
|
} |
||||
|
|
||||
|
inline nghttp2_header_list* headers() const { |
||||
|
return current_headers_head_; |
||||
|
} |
||||
|
|
||||
|
inline nghttp2_headers_category headers_category() const { |
||||
|
return current_headers_category_; |
||||
|
} |
||||
|
|
||||
|
inline void FreeHeaders(); |
||||
|
|
||||
|
void StartHeaders(nghttp2_headers_category category) { |
||||
|
DEBUG_HTTP2("Nghttp2Stream %d: starting headers, category: %d\n", |
||||
|
id_, category); |
||||
|
// We shouldn't be in the middle of a headers block already.
|
||||
|
// Something bad happened if this fails
|
||||
|
CHECK_EQ(current_headers_head_, nullptr); |
||||
|
CHECK_EQ(current_headers_tail_, nullptr); |
||||
|
current_headers_category_ = category; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
// The Parent HTTP/2 Session
|
||||
|
Nghttp2Session* session_ = nullptr; |
||||
|
|
||||
|
// The Stream Identifier
|
||||
|
int32_t id_ = 0; |
||||
|
|
||||
|
// Internal state flags
|
||||
|
int flags_ = 0; |
||||
|
|
||||
|
// Outbound Data... This is the data written by the JS layer that is
|
||||
|
// waiting to be written out to the socket.
|
||||
|
nghttp2_stream_write_queue* queue_head_ = nullptr; |
||||
|
nghttp2_stream_write_queue* queue_tail_ = nullptr; |
||||
|
unsigned int queue_head_index_ = 0; |
||||
|
size_t queue_head_offset_ = 0; |
||||
|
size_t fd_offset_ = 0; |
||||
|
|
||||
|
// The Current Headers block... As headers are received for this stream,
|
||||
|
// they are temporarily stored here until the OnFrameReceived is called
|
||||
|
// signalling the end of the HEADERS frame
|
||||
|
nghttp2_header_list* current_headers_head_ = nullptr; |
||||
|
nghttp2_header_list* current_headers_tail_ = nullptr; |
||||
|
nghttp2_headers_category current_headers_category_ = NGHTTP2_HCAT_HEADERS; |
||||
|
|
||||
|
// Inbound Data... This is the data received via DATA frames for this stream.
|
||||
|
nghttp2_data_chunk_t* data_chunks_head_ = nullptr; |
||||
|
nghttp2_data_chunk_t* data_chunks_tail_ = nullptr; |
||||
|
|
||||
|
// The RST_STREAM code used to close this stream
|
||||
|
int32_t code_ = NGHTTP2_NO_ERROR; |
||||
|
|
||||
|
int32_t prev_local_window_size_ = 65535; |
||||
|
|
||||
|
friend class Nghttp2Session; |
||||
|
}; |
||||
|
|
||||
|
struct nghttp2_stream_write_t { |
||||
|
void* data; |
||||
|
int status; |
||||
|
Nghttp2Stream* handle; |
||||
|
nghttp2_stream_write_queue* item; |
||||
|
}; |
||||
|
|
||||
|
struct nghttp2_data_chunk_t { |
||||
|
uv_buf_t buf; |
||||
|
nghttp2_data_chunk_t* next = nullptr; |
||||
|
}; |
||||
|
|
||||
|
struct nghttp2_data_chunks_t { |
||||
|
unsigned int nbufs = 0; |
||||
|
uv_buf_t buf[MAX_BUFFER_COUNT]; |
||||
|
|
||||
|
inline ~nghttp2_data_chunks_t(); |
||||
|
}; |
||||
|
|
||||
|
} // namespace http2
|
||||
|
} // namespace node
|
||||
|
|
||||
|
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
||||
|
|
||||
|
#endif // SRC_NODE_HTTP2_CORE_H_
|
||||
Loading…
Reference in new issue