2 * @file HTTP(S) Router that treats the first directory in a URL's path as
10 const dlog
= (msg
) => console
.log(msg
)
13 /** Regular expression for valid routes
14 * @prop {Object.RegEx} validRoutes - matches valid route names
16 validRoutes
: /[a-zA-Z][a-zA-Z0-9\-_]*/,
19 * @prop {Object.Map} routes - all the routes!
23 /** Parameters set on bootup (startHttpServer)
24 * @prop {string[2]} skelPage - html document split in twain for JS injection
25 * @prop {string} clientJS - jerverscripps to inject in skelPage for clients
26 * @prop {string} hostJS - jerverscripps for the hosts
27 * @prop {string} httpdRoot - a normalized path for http-servable files
28 * @prop {string} bindJail - jail bindings to this path
37 * @summary Start main HTTP server
38 * @desc starts up an HTTP or HTTPS server used for routing
39 * @arg {Object} conf - object containing configuration properties
40 * @prop {number|string} conf.port - local system port to bind to
41 * @prop {string} conf.skelFile - location of the skeleton HTML page
42 * @prop {string} conf.clientJS - client JS file
43 * @prop {string} conf.hostJS - host JS file
44 * @prop {string} [conf.httpdRoot] - root path of http-accessible files, if
45 * undefined no files are accessible
46 * @prop {Object} [conf.tls] - if present, startHttpServer will use tls
47 * @prop {string} [conf.tls.certFile] - tls certificate file
48 * @prop {string} [conf.tls.keyFile] - tls public key file
50 startHttpServer: function (conf
) {
52 throw new Error('httpd already running')
53 if (conf
.tls
== undefined)
54 this.httpd
= require('http').createServer((req
, res
) =>
55 this.httpdListener(req
, res
))
56 else if (!('keyFile' in conf
.tls
) || !('certFile' in conf
.tls
))
57 throw new Error('HTTPS requires a valid key and cert')
59 this.syncReads([conf
.tls
.keyFile
, conf
.tls
.certFile
]).then((results
) => {
60 Object
.defineProperty(this, 'httpsOpts', {
62 key
: results
[conf
.tls
.keyFile
],
63 cert
: results
[conf
.tls
.certFile
]
67 require('https').createServer(this.httpsOpts
, (request
,response
) =>
68 this.httpdListener(request
,response
))
72 this.httpdRoot
= require('path').normalize(conf
.httpdRoot
)
73 while (this.httpdRoot
[this.httpdRoot
.length
- 1] == require('path').sep
)
74 this.httpdRoot
= this.httpdRoot
.slice(0,-1)
76 this.syncReads([conf
.skelFile
, conf
.clientJS
, conf
.hostJS
])
78 this.skelPage
= results
[conf
.skelFile
].split('<!--STRAPP_SRC-->')
79 this.clientJS
= results
[conf
.clientJS
]
80 this.hostJS
= results
[conf
.hostJS
]
85 console
.log(`HTTP${(conf.tls == undefined) ? '' : 'S'} ` +
87 `Server Started on port ${conf.port}${this.httpdRoot ?
89 `Server Started on port ${conf.port}
${this.httpdRoot
?
90 >>>>>>> 3f5fce84645ec2c59aec0908807d1e9cb3e05e2d
91 `, serving files from ${this.httpdRoot}`:''}`)
95 * @summary Create a binding for the server
96 * @desc makes a new route which is bound to a file or a path. routes
97 * bound to files always serve that file, regardless of any
98 * additional path parameters provided by the URI
99 * @arg {string} routeName - the route to create
100 * @arg {string} path - the path to the file or directory to bind
102 createBind: function (routeName, path) {
103 dlog(`Binding ${routeName} to ${path}
`)
104 if (routeName in this.routes)
105 throw new Error(`route ${routeName} already exists
`)
106 path = require('path').normalize(path)
108 && path.indexOf(`${this.bindJail}
/`) !== 0
109 && this.bindJail != path)
110 throw new Error(`${routeName}
:${path} jailed to ${this.bindJail}
`)
111 if (require('fs').existsSync(path)) {
112 this.routes[routeName] = {
115 dir: require('fs').lstatSync(path).isDirectory()
120 throw new Error(`${path} not found
, ${routeName} not bound
`)
125 * @desc listens for http client requests and services routes/files
126 * @arg {http.ClientRequest} request
127 * @arg {http.ServerResponse} response
129 httpdListener: function (request,response) {
130 dlog(`Received request ${request.method} ${request.url}
`)
131 let htArgv = request.url.slice(1).split('?')
132 const routeName = htArgv[0].split('/')[0]
133 let route = this.routes[routeName]
135 console.log(`route is ${route}
`)
137 >>>>>>> 3f5fce84645ec2c59aec0908807d1e9cb3e05e2d
138 /* If the route exists, check if we are a returning host or a new client */
141 htArgv[0] = htArgv[0].replace(`${routeName}
`,'')
142 if (htArgv[0][0] === '/')
143 htArgv[0] = htArgv[0].slice(1)
144 this.serveBind(response, route.bind, htArgv)
146 //TODO: auth better than this (ip spoofing is easy)
147 // but this will require a more involved host-creation process
148 // that isn't just "give you a route if it's available" on visit
149 /* else if (route.origin == (request.headers['x-forwarded-for'] ||
150 request.connection.remoteAddress))
151 this.serveHost(response, route, htArgv)
156 >>>>>>> 3f5fce84645ec2c59aec0908807d1e9cb3e05e2d
157 this.serveClient(request, response, route)
160 /* If it's a valid routename that doesn't exist, make this client a host */
161 else if (this.validRoutes.test(routeName)) {
162 this.routes[routeName] = true
163 require('get-port')()
165 this.createHost(routeName, htArgv, port, request, response)
168 delete this.routes[routeName]
172 /* Try servicing files if we have a root directory for it */
173 else if (this.httpdRoot) {
174 let realPath = require('path').join(this.httpdRoot, htArgv[0])
175 if (realPath == this.httpdRoot)
176 realPath += '/index.html'
177 if (realPath.indexOf(`${this.httpdRoot}
/`) == 0) {
178 const stat_cb = (err, stat) => {
180 response.writeHead(404)
184 else if (stat.isDirectory()) {
185 realPath += '/index.html'
186 require('fs').lstat(realPath, stat_cb)
188 else if (stat.isFile())
189 this.serveFile(response, realPath)
191 response.writeHead(403)
195 require('fs').lstat(realPath, stat_cb)
198 response.writeHead(400)
204 response.writeHead(404)
210 * @summary Serves a binding to a client
211 * @desc Resolves a binding and serves a response to the client
212 * @arg {http.ServerResponse} response - the response to use
213 * @arg {Object} bind - the binding to serve the client
214 * @arg {string[]} argv - path and arguments for the bind
216 serveBind: function (response, bind, argv) {
217 dlog(`Serving binding ${bind.path}
/${argv[0]}
`)
220 argv[0] = 'index.html'
221 this.serveFile(response, require('path').join(bind.path, argv[0]))
224 this.serveFile(response, bind.path)
228 * @summary Serve a route to an http client
229 * @desc routes may be bound to the filesystem, or to an outgoing host
230 * @arg {http.ClientRequest} request - request from the client
231 * @arg {http.ServerResponse} response - response object to use
232 * @arg {Object} route - route associated with client request
234 serveClient: function (request, response, route) {
235 const type = request.headers['x-strapp-type']
236 const pubKey = request.headers['x-strapp-pubkey']
237 dlog(`Client ${type || 'HT'} request routed to ${route.name}
`)
241 response.writeHead(200, { 'Content-Type': 'text/html' })
242 response.write(`${this.skelPage[0]}${this.clientJS}${this.skelPage[1]}
`)
245 case 'ice-candidate-request':
246 case 'ice-candidate-submission':
247 case 'client-sdp-offer':
250 let data = request.headers['x-strapp-offer']
251 route.pendingResponses.addResponse(pubKey, response)
252 route.socket.send(`${pubKey} ${type} ${data}
`)
255 response.writeHead(401)
260 response.writeHead(400)
269 >>>>>>> 3f5fce84645ec2c59aec0908807d1e9cb3e05e2d
270 * @summary Create a new route for a host
271 * @desc makes a new route for the given route name
272 * @arg {string} routeName - name of the new route
273 * @arg {string[]} argv - Origin address from the request that made this
274 * route (for security verification on the socket)
275 * @arg {number|string} port - the port to listen on for websocket
276 * @arg {http.ClientRequest} request - host's request
277 * @arg {http.ServerResponse} response - responder
279 createHost: function (routeName, argv, port, request, response) {
280 const origin = (request.headers['x-forwarded-for'] ||
281 request.connection.remoteAddress)
282 dlog(`New ${this.httpsOpts?'TLS ':''}route ${routeName}
:${port}
=>${origin}
`)
283 const httpd = this.httpsOpts
284 ? require('https').createServer(this.httpsOpts)
285 : require('http').createServer()
287 pendingResponses: new Map([]),
295 route.httpd.listen(port)
296 route.wsd = new (require('ws').Server)({ server: httpd })
297 .on('connection', (socket) => {
298 route.socket = socket
299 socket.on('message', (msg) =>
300 this.hostMessage(msg,route))
302 route.pendingResponses.addResponse = function (key, response_p) {
303 let responses = this.get(key) || []
305 responses.push(response_p)
306 this.set(key, responses)
308 this.set(key, responses.push(response_p))
309 >>>>>>> 3f5fce84645ec2c59aec0908807d1e9cb3e05e2d
311 this.routes[routeName] = route
312 this.serveHost(response, route, argv)
319 >>>>>>> 3f5fce84645ec2c59aec0908807d1e9cb3e05e2d
320 * @summary Serve a route to an authorized http host
321 * @desc services host application to the client, establishing a socket
322 * @arg {http.ServerResponse} response - response object to use
323 * @arg {Object} route - the route that belongs to this host
324 * @arg {string[]} argv - vector of arguments sent to the host
326 serveHost: function (response, route, argv) {
327 dlog(`Serving host ${route.origin}
`)
328 response.writeHead(200, { 'Content-Type': 'text/html' })
329 response.write(`${this.skelPage[0]}
` +
330 `\tconst _strapp_port
= ${route.port}
\n` +
331 `\tconst _strapp_protocol
= ` +
332 `'${this.httpsOpts ? 'wss' : 'ws'}'\n` +
333 `${this.hostJS}
\n${this.skelPage[1]}
`)
338 * @summary handle host message
339 * @desc receives a message from a host, handles the command (first character),
340 * and responds to either the host or the client, or both. Commands
341 * are whitespace separated strings.
343 * Forward Payload to Client)
344 * < clientKey payload [header]
345 * Route 'payload' to the client identified by 'clientKey'.
346 * The optional 'header' argument is a stringified JSON object,
347 * which will be written to the HTTP response header
348 * In case of multiple requests from a single client, the
349 * oldest request will be serviced on arrival of message
350 * Translate SDP and Forward to Client)
351 * ^ clientKey sdp [header]
352 * Route the JSON object 'sdp' to the client, after translating
353 * for interop between browsers using planB or Unified. Other
354 * than the interop step, this is identical to the '<' command
356 * ! errorMessage errorCode [offendingMessage]
357 * Notify host that an error has occured, providing a message
358 * and error code. 'offendingMessage', if present, is the
359 * message received from the remote that triggered the error.
360 * @arg {string} message - raw string from the host
361 * @arg {Object} route - the route over
363 hostMessage: function (message, route) {
364 const argv = message.split(' ')
365 const command = argv[0][0]
367 dlog(`Received host message
from ${route.name}
: ${command}
`)
370 if (argv.length < 2) {
371 dlog(`Malformed
'${command}' command
from ${route.origin}
`)
372 route.socket.send(`! "Insufficient arguments" 0 ${message}
`)
375 argv[1] = JSON.parse(argv[1])
377 argv[1] = JSON.stringify(argv[1])
378 //TODO: argv[1] = encryptForClient(argv[0], argv[1])
379 /* Fallthrough to '<' behavior after translating argv[1] */
381 const response = route.pendingResponses.get(argv[0]).shift()
383 route.socket.send(`! "No pending responses for client ${argv[0]}" 0 `
385 else if (argv.length === 2 || argv.length === 3) {
386 const header = argv.length === 3 ? JSON.parse(argv[2]) : {}
387 if (!('Content-Type' in header))
388 header['Content-Type'] = 'application/octet-stream'
389 response.writeHead(200, header)
390 response.write(argv[1])
394 route.socket.send(`! "Insufficient arguments" 0 ${message}
`)
397 if (argv.length === 3)
398 argv[0] += `\nIn message
: ${argv[2]}
`
399 console.log(`Error
[${route.origin}
|${argv[1]}
]:${argv[0]}
`)
402 route.socket.send(`! "Unknown command '${command}'" 0 ${message}
`)
403 dlog(`Host ${route.origin} send unknown command
: ${message}
`)
409 * @summary Serve a file to an http client after a request
410 * @desc reads files from the system to be distributed to clients, and
411 * buffers recently accessed files
412 * @arg {http.ServerResponse} response - the response object to use
413 * @arg {string} filePath - relative location of the file
415 serveFile: function (response, filePath, rootPath) {
416 //TODO: Make a buffer to hold recently used files, and only read if we
417 // have to (don't forget to preserve mimetype)
418 require('fs').readFile(filePath, { encoding: 'utf8' }, (err, data) => {
419 if (err || data == undefined)
420 response.writeHead(404)
422 response.writeHead(200, {
423 'Content-Type': require('mime').lookup(filePath)
432 * @summary Synchronize Reading Multiple Files
433 * @desc reads an array of files into an object, whose keys are the
434 * input filenames, and values are the data read
435 * @arg {string[]} files - array of file names to read
436 * @arg {Object} [readOpts] - options to pass to fs.readFile()
438 syncReads: (files, readOpts) => new Promise((resolve,reject) => {
439 dlog(`syncing reads
from ${files}
`)
442 const read_cb = (fileName) => (err, data) => {
446 results[fileName] = data
447 if (++count === files.length)
450 if (readOpts == undefined)
451 readOpts = { encoding: 'utf8' }
452 files.forEach((file) =>
453 require('fs').readFile(file, readOpts, read_cb(file)))
457 module.exports = exports