Code coverage report for lib/https.js

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
 
 
27
27
27
27
27
27
 
27
33
 
31
26
 
 
31
 
31
 
31
30
 
 
31
2
 
 
31
 
27
27
 
27
 
27
29
 
 
 
 
 
27
147
147
 
 
 
 
 
 
147
 
 
 
147
 
 
 
147
147
 
 
 
27
37
37
37
 
27
27
 
27
441
 
441
441
48
 
441
441
3
 
441
441
 
 
441
441
3
 
441
441
3
 
441
441
372
 
441
 
 
27
 
27
27
 
27
147
1
 
146
 
147
147
 
 
27
131
131
131
 
 
 
 
(function () { 'use strict';
 
const tls = require('tls');
const url = require('url');
const http = require('http');
const util = require('util');
const inherits = util.inherits;
const debug = util.debuglog('https');
 
function Server(opts, requestListener) {
  if (!(this instanceof Server)) return new Server(opts, requestListener);
 
  if (process.features.tls_npn && !opts.NPNProtocols) {
    opts.NPNProtocols = ['http/1.1', 'http/1.0'];
  }
 
  tls.Server.call(this, opts, http._connectionListener);
 
  this.httpAllowHalfOpen = false;
 
  if (requestListener) {
    this.addListener('request', requestListener);
  }
 
  this.addListener('clientError', function(err, conn) {
    conn.destroy();
  });
 
  this.timeout = 2 * 60 * 1000;
}
inherits(Server, tls.Server);
exports.Server = Server;
 
Server.prototype.setTimeout = http.Server.prototype.setTimeout;
 
exports.createServer = function(opts, requestListener) {
  return new Server(opts, requestListener);
};
 
 
// HTTPS agents.
 
function createConnection(port, host, options) {
  Eif (port !== null && typeof port === 'object') {
    options = port;
  } else if (host !== null && typeof host === 'object') {
    options = host;
  } else if (options === null || typeof options !== 'object') {
    options = {};
  }
 
  Iif (typeof port === 'number') {
    options.port = port;
  }
 
  Iif (typeof host === 'string') {
    options.host = host;
  }
 
  debug('createConnection', options);
  return tls.connect(options);
}
 
 
function Agent(options) {
  http.Agent.call(this, options);
  this.defaultPort = 443;
  this.protocol = 'https:';
}
inherits(Agent, http.Agent);
Agent.prototype.createConnection = createConnection;
 
Agent.prototype.getName = function(options) {
  var name = http.Agent.prototype.getName.call(this, options);
 
  name += ':';
  if (options.ca)
    name += options.ca;
 
  name += ':';
  if (options.cert)
    name += options.cert;
 
  name += ':';
  Iif (options.ciphers)
    name += options.ciphers;
 
  name += ':';
  if (options.key)
    name += options.key;
 
  name += ':';
  if (options.pfx)
    name += options.pfx;
 
  name += ':';
  if (options.rejectUnauthorized !== undefined)
    name += options.rejectUnauthorized;
 
  return name;
};
 
const globalAgent = new Agent();
 
exports.globalAgent = globalAgent;
exports.Agent = Agent;
 
exports.request = function(options, cb) {
  if (typeof options === 'string') {
    options = url.parse(options);
  } else {
    options = util._extend({}, options);
  }
  options._defaultAgent = globalAgent;
  return http.request(options, cb);
};
 
exports.get = function(options, cb) {
  var req = exports.request(options, cb);
  req.end();
  return req;
};
 
}());