const common = require('../common.js');

const bench = common.createBenchmark(main, {

dur: [5],

type: ['buf', 'asc', 'utf'],

sendchunklen: [256, 32 * 1024, 128 * 1024, 16 * 1024 * 1024],

recvbuflen: [0, 64 * 1024, 1024 * 1024],

recvbufgenfn: ['true', 'false']

const fixtures = require('../../test/common/fixtures');

let options;

let recvbuf;

let received = 0;

const tls = require('tls');

function main({ dur, type, sendchunklen, recvbuflen, recvbufgenfn }) {

if (isFinite(recvbuflen) && recvbuflen > 0)

recvbuf = Buffer.alloc(recvbuflen);

let encoding;

let chunk;

switch (type) {

case 'buf':

chunk = Buffer.alloc(sendchunklen, 'b');

break;

case 'asc':

chunk = 'a'.repeat(sendchunklen);

encoding = 'ascii';

break;

case 'utf':

chunk = 'ü'.repeat(sendchunklen / 2);

encoding = 'utf8';

break;

default:

throw new Error('invalid type');

}

options = {

key: fixtures.readKey('rsa_private.pem'),

cert: fixtures.readKey('rsa_cert.crt'),

ca: fixtures.readKey('rsa_ca.crt'),

ciphers: 'AES256-GCM-SHA384'

};

let socketOpts;

if (recvbuf === undefined) {

socketOpts = { port: common.PORT, rejectUnauthorized: false };

} else {

let buffer = recvbuf;

if (recvbufgenfn === 'true') {

let bufidx = -1;

const bufpool = [

recvbuf,

Buffer.from(recvbuf),

Buffer.from(recvbuf),

];

buffer = () => {

bufidx = (bufidx + 1) % bufpool.length;

return bufpool[bufidx];

};

}

socketOpts = {

port: common.PORT,

rejectUnauthorized: false,

onread: {

buffer,

callback: function(nread, buf) {

received += nread;

}

}

};

}

const server = tls.createServer(options, (socket) => {

socket.on('data', (buf) => {

socket.on('drain', write);

write();

});

function write() {

while (false !== socket.write(chunk, encoding));

}

});

let conn;

server.listen(common.PORT, () => {

conn = tls.connect(socketOpts, () => {

setTimeout(done, dur * 1000);

bench.start();

conn.write('hello');

});

conn.on('data', (chunk) => {

received += chunk.length;

});

});

function done() {

const mbits = (received * 8) / (1024 * 1024);

bench.end(mbits);

process.exit(0);

}

* `onread` {Object} If the `socket` option is missing, incoming data is

stored in a single `buffer` and passed to the supplied `callback` when

data arrives on the socket, otherwise the option is ignored. See the

`onread` option of [`net.Socket`][] for details.

onread: !socket ? tlsOptions.onread : null,

onread: options.onread,

} else if (options.fd !== undefined) {

const { fd } = options;

let err;

// createHandle will throw ERR_INVALID_FD_TYPE if `fd` is not

// a valid `PIPE` or `TCP` descriptor

this._handle = createHandle(fd, false);

err = this._handle.open(fd);

// While difficult to fabricate, in some architectures

// `open` may return an error code for valid file descriptors

// which cannot be opened. This is difficult to test as most

// un-openable fds will throw on `createHandle`

if (err)

throw errnoException(err, 'open');

this[async_id_symbol] = this._handle.getAsyncId();

if ((fd === 1 || fd === 2) &&

(this._handle instanceof Pipe) && isWindows) {

// Make stdout and stderr blocking on Windows

err = this._handle.setBlocking(true);

throw errnoException(err, 'setBlocking');

this._writev = null;

this._write = makeSyncWrite(fd);

// makeSyncWrite adjusts this value like the original handle would, so

// we need to let it do that by turning it into a writable, own

// property.

ObjectDefineProperty(this._handle, 'bytesWritten', {

value: 0, writable: true

});

}

}

const onread = options.onread;

if (onread !== null && typeof onread === 'object' &&

(isUint8Array(onread.buffer) || typeof onread.buffer === 'function') &&

typeof onread.callback === 'function') {

if (typeof onread.buffer === 'function') {

this[kBuffer] = true;

this[kBufferGen] = onread.buffer;

} else {

this[kBuffer] = onread.buffer;

this[kBufferCb] = onread.callback;