1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
'use strict';
const common = require('../common');
if (!common.hasCrypto)
common.skip('missing crypto');
const assert = require('assert');
const fixtures = require('../common/fixtures');
const tls = require('tls');
const tick = require('../common/tick');
const initHooks = require('./init-hooks');
const { checkInvocations } = require('./hook-checks');
const hooks = initHooks();
hooks.enable();
// TODO(@sam-github) assumes server handshake completes before client, true for
// 1.2, not for 1.3. Might need a rewrite for TLS1.3.
tls.DEFAULT_MAX_VERSION = 'TLSv1.2';
//
// Creating server and listening on port
//
const server = tls
.createServer({
cert: fixtures.readKey('rsa_cert.crt'),
key: fixtures.readKey('rsa_private.pem')
})
.on('listening', common.mustCall(onlistening))
.on('secureConnection', common.mustCall(onsecureConnection))
.listen(0);
let svr, client;
function onlistening() {
//
// Creating client and connecting it to server
//
tls
.connect(server.address().port, { rejectUnauthorized: false })
.on('secureConnect', common.mustCall(onsecureConnect));
const as = hooks.activitiesOfTypes('TLSWRAP');
assert.strictEqual(as.length, 1);
svr = as[0];
assert.strictEqual(svr.type, 'TLSWRAP');
assert.strictEqual(typeof svr.uid, 'number');
assert.strictEqual(typeof svr.triggerAsyncId, 'number');
checkInvocations(svr, { init: 1 }, 'server: when client connecting');
}
function onsecureConnection() {
//
// Server received client connection
//
const as = hooks.activitiesOfTypes('TLSWRAP');
assert.strictEqual(as.length, 2);
// TODO(@sam-github) This happens after onsecureConnect, with TLS1.3.
client = as[1];
assert.strictEqual(client.type, 'TLSWRAP');
assert.strictEqual(typeof client.uid, 'number');
assert.strictEqual(typeof client.triggerAsyncId, 'number');
// TODO(thlorenz) which callback did the server wrap execute that already
// finished as well?
checkInvocations(svr, { init: 1, before: 1, after: 1 },
'server: when server has secure connection');
checkInvocations(client, { init: 1, before: 2, after: 1 },
'client: when server has secure connection');
}
function onsecureConnect() {
//
// Client connected to server
//
checkInvocations(svr, { init: 1, before: 2, after: 1 },
'server: when client connected');
checkInvocations(client, { init: 1, before: 2, after: 2 },
'client: when client connected');
//
// Destroying client socket
//
this.destroy(); // This destroys client before server handshakes, with TLS1.3
checkInvocations(svr, { init: 1, before: 2, after: 1 },
'server: when destroying client');
checkInvocations(client, { init: 1, before: 2, after: 2 },
'client: when destroying client');
tick(5, tick1);
function tick1() {
checkInvocations(svr, { init: 1, before: 2, after: 2 },
'server: when client destroyed');
// TODO: why is client not destroyed here even after 5 ticks?
// or could it be that it isn't actually destroyed until
// the server is closed?
if (client.before.length < 3) {
tick(5, tick1);
return;
}
checkInvocations(client, { init: 1, before: 3, after: 3 },
'client: when client destroyed');
//
// Closing server
//
server.close(common.mustCall(onserverClosed));
// No changes to invocations until server actually closed below
checkInvocations(svr, { init: 1, before: 2, after: 2 },
'server: when closing server');
checkInvocations(client, { init: 1, before: 3, after: 3 },
'client: when closing server');
}
}
function onserverClosed() {
//
// Server closed
//
tick(1E4, common.mustCall(() => {
checkInvocations(svr, { init: 1, before: 2, after: 2 },
'server: when server closed');
checkInvocations(client, { init: 1, before: 3, after: 3 },
'client: when server closed');
}));
}
process.on('exit', onexit);
function onexit() {
hooks.disable();
hooks.sanityCheck('TLSWRAP');
checkInvocations(svr, { init: 1, before: 2, after: 2 },
'server: when process exits');
checkInvocations(client, { init: 1, before: 3, after: 3 },
'client: when process exits');
}
|
