Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
41 changes: 41 additions & 0 deletions doc/api/http2.md
Original file line number Diff line number Diff line change
Expand Up @@ -4904,6 +4904,45 @@ const server = http2.createServer((req, res) => {
});
```

#### `response.setHeaders(headers)`

<!-- YAML
added: REPLACEME
-->

* `headers` {Headers|Map}

Sets multiple header values for implicit headers.
`headers` must be an instance of [`Headers`][] or `Map`.
If a header already exists in the to-be-sent headers,
its value will be replaced.

```js
const headers = new Headers({ foo: 'bar' });
response.setHeaders(headers);
```

or

```js
const headers = new Map([['foo', 'bar']]);
response.setHeaders(headers);
```

When headers have been set with [`response.setHeaders()`][],
they will be merged with any headers passed to [`response.writeHead()`][],
with the headers passed to [`response.writeHead()`][] given precedence.

```js
// Returns content-type = text/plain
const server = http2.createServer((req, res) => {
const headers = new Headers({ 'Content-Type': 'text/html' });
res.setHeaders(headers);
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('ok');
});
```

#### `response.setTimeout(msecs[, callback])`

<!-- YAML
Expand Down Expand Up @@ -5302,6 +5341,7 @@ you need to implement any fall-back behavior yourself.
[`Duplex`]: stream.md#class-streamduplex
[`ERR_HTTP2_STREAM_ABORTED`]: errors.md#err_http2_stream_aborted
[`ERR_HTTP2_STREAM_ERROR`]: errors.md#err_http2_stream_error
[`Headers`]: globals.md#class-headers
[`Http2ServerRequest`]: #class-http2http2serverrequest
[`Http2ServerResponse`]: #class-http2http2serverresponse
[`Http2Session` and Sockets]: #http2session-and-sockets
Expand Down Expand Up @@ -5330,6 +5370,7 @@ you need to implement any fall-back behavior yourself.
[`request.socket`]: #requestsocket
[`response.end()`]: #responseenddata-encoding-callback
[`response.setHeader()`]: #responsesetheadername-value
[`response.setHeaders()`]: #responsesetheadersheaders
[`response.socket`]: #responsesocket
[`response.writableEnded`]: #responsewritableended
[`response.write()`]: #responsewritechunk-encoding-callback
Expand Down
40 changes: 40 additions & 0 deletions lib/internal/http2/compat.js
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,7 @@ const {
ERR_HTTP2_NO_SOCKET_MANIPULATION,
ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED,
ERR_HTTP2_STATUS_INVALID,
ERR_INVALID_ARG_TYPE,
ERR_INVALID_ARG_VALUE,
ERR_INVALID_HTTP_TOKEN,
ERR_STREAM_WRITE_AFTER_END,
Expand Down Expand Up @@ -687,6 +688,45 @@ class Http2ServerResponse extends Stream {
this[kSetHeader](name, value);
}

setHeaders(headers) {
if (this[kStream].headersSent)
throw new ERR_HTTP2_HEADERS_SENT();

if (
!headers ||
ArrayIsArray(headers) ||
typeof headers.keys !== 'function' ||
typeof headers.get !== 'function'
) {
throw new ERR_INVALID_ARG_TYPE('headers', ['Headers', 'Map'], headers);
}

// Headers object joins multiple cookies with a comma when using
// the getter to retrieve the value,
// unless iterating over the headers directly.
// We also cannot safely split by comma.
// To avoid setHeader overwriting the previous value we push
// set-cookie values in array and set them all at once.
let cookies = null;

for (const { 0: key, 1: value } of headers) {
if (key === 'set-cookie') {
if (ArrayIsArray(value)) {
cookies ??= [];
cookies.push(...value);
} else {
cookies ??= [];
cookies.push(value);
}
continue;
}
this.setHeader(key, value);
}
if (cookies != null) {
this.setHeader('set-cookie', cookies);
}
}

[kSetHeader](name, value) {
name = name.trim().toLowerCase();
assertValidHeader(name, value);
Expand Down
204 changes: 204 additions & 0 deletions test/parallel/test-http2-server-set-headers.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,204 @@
'use strict';

const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const http2 = require('http2');
const body =
'<html><head></head><body><h1>this is some data</h2></body></html>';

// Starts a server with the given request handler, sends one request and
// calls onResponse with the response headers.
function testResponse(onRequest, onResponse) {
const server = http2.createServer(onRequest);
server.on('error', common.mustNotCall());

server.listen(0, common.mustCall(() => {
const client = http2.connect(`http://localhost:${server.address().port}`);
const req = client.request({ ':path': '/' });
req.setEncoding('utf8');
req.on('response', onResponse);

let data = '';
req.on('data', (d) => data += d);
req.on('end', common.mustCall(() => {
assert.strictEqual(data, body);
server.close();
client.close();
}));
req.end();
}));
}

// Map, including a header name that is not lower case and a connection
// header, which is dropped with a warning.
{
const compatMsg = 'The provided connection header is not valid, ' +
'the value will be dropped from the header and ' +
'will never be in use.';
common.expectWarning('UnsupportedWarning', compatMsg);

testResponse(common.mustCall((req, res) => {
res.setHeaders(new Map([
['foobar', 'baz'],
['X-POWERED-BY', 'node-test'],
['connection', 'connection-test'],
]));
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers[':status'], 200);
assert.strictEqual(headers.foobar, 'baz');
assert.strictEqual(headers['x-powered-by'], 'node-test');
assert.strictEqual(headers.connection, undefined);
}));
}

// Headers instance.
{
testResponse(common.mustCall((req, res) => {
res.setHeaders(new Headers({ foo: '1', bar: '2' }));
res.writeHead(200);
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers[':status'], 200);
assert.strictEqual(headers.foo, '1');
assert.strictEqual(headers.bar, '2');
}));
}

// An existing header is replaced.
{
testResponse(common.mustCall((req, res) => {
res.setHeader('foo', '1');
res.setHeader('bar', '2');
res.setHeaders(new Headers({ foo: '3' }));
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers.foo, '3');
assert.strictEqual(headers.bar, '2');
}));
}

// Headers passed to writeHead() as an object take precedence.
{
testResponse(common.mustCall((req, res) => {
res.setHeaders(new Headers({ foo: '1', bar: '2' }));
res.writeHead(200, { foo: '3' });
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers[':status'], 200);
assert.strictEqual(headers.foo, '3');
assert.strictEqual(headers.bar, '2');
}));
}

// Headers passed to writeHead() as an array take precedence.
{
testResponse(common.mustCall((req, res) => {
res.setHeaders(new Headers({ foo: '1', bar: '2' }));
res.writeHead(200, ['foo', '3']);
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers[':status'], 200);
assert.strictEqual(headers.foo, '3');
assert.strictEqual(headers.bar, '2');
}));
}

// Multiple set-cookie values appended to a Headers instance.
{
testResponse(common.mustCall((req, res) => {
const headers = new Headers();
headers.append('Set-Cookie', 'a=b');
headers.append('Set-Cookie', 'c=d');
res.setHeaders(headers);
res.end(body);
}), common.mustCall((headers) => {
assert.deepStrictEqual(headers['set-cookie'], ['a=b', 'c=d']);
}));
}

// Multiple set-cookie values as an array in a Map, with a name that is not
// lower case.
{
testResponse(common.mustCall((req, res) => {
res.setHeaders(new Map([['Set-Cookie', ['a=b', 'c=d']]]));
res.end(body);
}), common.mustCall((headers) => {
assert.deepStrictEqual(headers['set-cookie'], ['a=b', 'c=d']);
}));
}

// Lower case set-cookie in a Map, as an array and as a single value.
{
testResponse(common.mustCall((req, res) => {
res.setHeaders(new Map([['set-cookie', ['a=b', 'c=d']]]));
res.end(body);
}), common.mustCall((headers) => {
assert.deepStrictEqual(headers['set-cookie'], ['a=b', 'c=d']);
}));

testResponse(common.mustCall((req, res) => {
res.setHeaders(new Map([['set-cookie', 'a=b']]));
res.end(body);
}), common.mustCall((headers) => {
assert.deepStrictEqual(headers['set-cookie'], ['a=b']);
}));
}

// set-cookie values replace the ones set before.
{
testResponse(common.mustCall((req, res) => {
res.setHeader('set-cookie', ['x=y']);
const headers = new Headers();
headers.append('Set-Cookie', 'a=b');
headers.append('Set-Cookie', 'c=d');
res.setHeaders(headers);
res.end(body);
}), common.mustCall((headers) => {
assert.deepStrictEqual(headers['set-cookie'], ['a=b', 'c=d']);
}));
}

// Throws when the headers have already been sent.
{
testResponse(common.mustCall((req, res) => {
res.writeHead(200);
assert.throws(() => {
res.setHeaders(new Headers({ foo: '1' }));
}, {
code: 'ERR_HTTP2_HEADERS_SENT',
name: 'Error',
});
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers.foo, undefined);
}));
}

// Throws when headers is neither a Headers instance nor a Map.
{
testResponse(common.mustCall((req, res) => {
for (const headers of [
['foo', '1'],
{ foo: '1' },
null,
undefined,
'test',
1,
{ keys() {} },
{ get() {} },
]) {
assert.throws(() => {
res.setHeaders(headers);
}, {
code: 'ERR_INVALID_ARG_TYPE',
name: 'TypeError',
});
}
res.end(body);
}), common.mustCall((headers) => {
assert.strictEqual(headers.foo, undefined);
}));
}
Loading