X-Git-Url: https://git.kengrimes.com/?p=henge%2Fkiak.git;a=blobdiff_plain;f=main.js;h=b2d4c7ab7f52f81011d52202de422d0c830948c9;hp=b24e9f39f6c16c208bd17d6d21f32ae44c27f82c;hb=44e0b2d571c71ebd410b78366c8bc9dc463a96c4;hpb=69adc9a3512752d627e126dde85c859fcba9fb63 diff --git a/main.js b/main.js index b24e9f3..b2d4c7a 100644 --- a/main.js +++ b/main.js @@ -1,129 +1,220 @@ -const fs = require('fs') -const ws = require('ws') -const https = require('https') -const getport = require('get-port') -const mime = require('mime') - -const argv = require('minimist')(process.argv.slice(2), { - string: [ 'ca-cert', 'ca-key', 'config', 'client-js', 'host-js', 'electron', 'port' ], - boolean: [ 'remote-host' ], - alias: { c: 'config', - j: 'client-js', - J: 'host-js', - C: 'ca-cert', - K: 'ca-key', - e: 'electron', - r: 'remote-host', - p: 'port' - }, - default: { config: undefined, - 'client-js': 'client.js', - 'host-js': 'host.js', - 'ca-cert': 'stunnel.cert', - 'ca-key': 'stunnel.key', - 'remote-host': true, - 'port': 2443 - }, - stopEarly: true, - unknown: (opt) => { - console.log(process.argv.join(" ") + '\nUnknown operator: ' + opt + ` -Usage: strapp [OPTION]... -Route https connections from a hardware port to a remote host, and initiate -peer-to-peer connection with clients. - -CONFIG - -c, --config=path Configuration file to use (/etc/strapp.conf) - - overridden by command line opts - -j, --client-js=path Path to the client Strapp code (./strapp-client.js) - -J, --host-js=path Path to the host Strapp code (./strapp-host.js) - -C, --ca-cert=path Accessible location of the CA Cert (./stunnel.cert) - -K, --ca-key=path Accessible location of the CA Key (./stunnel.key) - -p, --port=number The local port to bind HTTPS listener to (2443) - -ROUTING - -e, --electron=route Route to the local electron user (nil) - - enables optional electron dependency - -d, --dedicated=route Route all incoming connections to this route (nil) - - used in conjunction with '-e=my_route' - -(c)2017 jk software -`) - process.exit() - } -}) - -//TODO: if (argv['config'] !== undefined), read and apply to argv without overwrite -if (argv['www-path'] == undefined) - argv['www-path'] = 'www' -else if (String(argv['www-path']).endsWith('/')) - argv['www-path'] = argv['www-path'].slice(0,-1) - -const routerOpts = { - key: fs.readFileSync(argv['ca-key']), - cert: fs.readFileSync(argv['ca-cert']) -} -const skelPage = String(fs.readFileSync('skel.html')).split("") -const clientJS = fs.readFileSync(argv['client-js']) -const hostJS = fs.readFileSync(argv['host-js']) -const routes = {} -const fileBuf = {} -let fbSize = 0 -fs.readdirSync(argv['www-path']).forEach((file) => { - if (fbSize++ < 50) { - fileBuf[file] = { mime: mime.lookup(argv['www-path'] + '/' + file), - data: fs.readFileSync(argv['www-path'] + '/' + file) - } - } -}) - -const router = https.createServer(routerOpts, (request, response) => { - const htArgv = request.url.slice(1).split("?") - let routeName = htArgv[0].split('/')[0] - if (routeName === '') - routeName = 'index.html' - if (routeName.indexOf('.') != -1) { - if (routeName in fileBuf) { - response.writeHead(200, { 'Content-Type': fileBuf[routeName].mime }) - response.write(fileBuf[routeName].data) - } - else { - if ('404.html' in fileBuf) { - response.writeHead(404, fileBuf['404.html'].mime) - response.write(fileBuf['404.html'].data) - } - else - response.writeHead(404) - } - response.end() - } - else if (routeName in routes) { - const route = routes[routeName] - response.writeHead(200, { 'Content-Type': 'text/html' }) - response.write(skelPage[0] + clientJS + skelPage[1]) - response.end() - route.socket.send(request.headers['x-forwarded-for'] || request.connection.remoteAddress) - } - else { - routes[htArgv[0]] = true - const newRoute = {} - newRoute.host = request.headers['x-forwarded-for'] || request.connection.remoteAddress - getport().then( (port) => { - newRoute.port = port - newRoute.httpd = https.createServer(routerOpts, (request, response) => { - }).listen(newRoute.port) - - newRoute.ws = new ws.Server( { server: newRoute.httpd } ) - newRoute.ws.on('connection', (ws) => { console.log("socket connected"); newRoute.socket = ws; ws.send("CONNECTED") } ) - newRoute.ws.on('message', (msg) => { console.log("Received message" + msg) }) - console.log("Listening for websocket " + newRoute.host + " on port " + newRoute.port) - routes[htArgv[0]] = newRoute - }).then(() => { - response.writeHead(200, { 'Content-Type': 'text/html' }) - response.write(skelPage[0] + 'const _strapp_host = \'www.strapp.io\'\n\tconst _strapp_port = \'' + newRoute.port + '\'\n' + hostJS + skelPage[1]) - response.end() - }) - } -}).listen(argv['port']) - -//TODO: if ("electron" in process.versions) open a local renderwindow, and route to it - +/** +* @file Node entry and main driver +* @author Jordan Lavatai, Ken Grimes +* @version 0.0.1 +* @license AGPL-3.0 +* @copyright loljk 2017 +* @summ ary HTTP(S) Router that uses the first directory in the requested URL +* as the route name +*/ +const fs = require('fs') +const ws = require('ws') +const path = require('path') +const http = require('http') +const https = require('https') +const getport = require('get-port') +const mime = require('mime') +const opts = require('./opts.js') + +const router = { + skelPage: fs.readFileSync('./skel.html', { encoding: 'utf8' }).split(''), + clientJS: fs.readFileSync(opts['client-js']), + hostJS: fs.readFileSync(opts['host-js']), + routes: {}, + httpsOpt: undefined, + httpd: undefined, + wsProtocol: opts['no-tls'] ? 'ws' : 'wss', + respond: (request,response) => { + console.log('server handling request') + const serveFile = (fPath) => { + fs.readFile(fPath, { encoding: 'utf8' }, (err, data) => { + if (err || data == undefined) { + response.writeHead(404) + response.end() + } + else { + response.writeHead(200, { 'Content-Type': mime.lookup(fPath) }) + response.write(data) + response.end() + } + }) + } + const htArgv = request.url.slice(1).split("?") + let routePath = htArgv[0].split('/') + let routeName = routePath[0] + + + if (routeName === '' || routeName === 'index.html') + serveFile(opts['index']) + else if (routeName in opts['bindings']) { + let localPath = path.normalize(opts['bindings'][routeName].concat(path.sep + routePath.slice(1).join(path.sep))) + if (localPath.includes(opts['bindings'][routeName])) { + fs.readdir(localPath, (err, files) => { + if (err) + serveFile(localPath) + else + serveFile(`${localPath}/index.html`) + }) + } + else { + console.log(`SEC: ${localPath} references files not in route`) + } + } + /* TODO: Handle reconnecting host */ + else if (routeName in router.routes) { + const route = router.routes[routeName] + const clients = route['clients'] + const headerData = request.headers['x-strapp-type'] + + + + + /* Client is INIT GET */ + if (headerData === undefined) { + console.log('client init GET') + response.writeHead(200, { 'Content-Type': 'text/html' }) + response.write(`${router.skelPage[0]}${router.clientJS}${router.skelPage[1]}`) + response.end() + //TODO: if route.socket == undefined: have server delay this send until host connects + // (this happens when a client connects to an active route with no currently-online host) + } + else if (headerData.localeCompare('ice-candidate-request') === 0) { + console.log('Server: received ice-candidate-request from Client ') + let pubKey = request.headers['x-client-pubkey'] + clients.set(pubKey, response) + pubKey = '{ "pubKey": "' + pubKey + '" }' + route.socket.send(pubKey) + } + else if (headerData.localeCompare('ice-candidate-submission') === 0) { + console.log('Server: recieved ice-candidate-submission from Client') + let data = [] + request.on('data', (chunk) => { + data.push(chunk) + }).on('end', () => { + console.log('Sending ice-candidate-submission to Host') + data = Buffer.concat(data).toString(); + clients.set(JSON.parse(data)['pubKey'], response) + route.socket.send(data) + }) + } + else if (headerData.localeCompare('client-sdp-offer') === 0){ /* Client sent offer, waiting for answer */ + console.log('Server: Sending client offer to host') + clients.set(JSON.parse(request.headers['x-client-offer'])['pubKey'], response) + route.socket.send(request.headers['x-client-offer']) + } else { + console.log('Unhandled stuff') + console.log(request.headers) + } + + } + else { + router.routes[routeName] = true + const newRoute = {} + newRoute.clients = new Map([]) + newRoute.host = request.headers['x-forwarded-for'] || request.connection.remoteAddress + getport().then( (port) => { + newRoute.port = port + if (opts['no-tls']) + newRoute.httpd = http.createServer() + else + newRoute.httpd = https.createServer(router.httpsOpts) + newRoute.httpd.listen(newRoute.port) + newRoute.wsd = new ws.Server( { server: newRoute.httpd } ) + newRoute.wsd.on('connection', (sock) => { + console.log(`${routeName} server has been established`) + newRoute.socket = sock + + /* Handle all messages from host */ + sock.on('message', (hostMessage) => { + hostMessage = JSON.parse(hostMessage) + response = newRoute.clients.get(hostMessage['clientPubKey']) + + /* If the host response is a answer */ + if (hostMessage['cmd'].localeCompare('< sdp pubKey') === 0) { + console.log('Server: Sending host answer to client') + response.writeHead(200, { 'Content-Type': 'application/json' }) + response.write(JSON.stringify(hostMessage)) + response.end() + } + else if (hostMessage['cmd'].localeCompare('< ice pubKey') === 0){ + /* if the host response is an ice candidate */ + console.log('Server: Handling host ICE message') + let iceState = hostMessage['iceState'] + /* If there are any ice candidates, send them back */ + switch(iceState) { + case "a": + response.writeHead('200', {'x-strapp-type': 'ice-candidate-available'}) + response.write(JSON.stringify(hostMessage)) + response.end() + break + case "g": + console.log('Server: Host is still gathering candidates, keep trying') + response.writeHead('200', {'x-strapp-type': 'ice-state-gathering'}) + response.write(JSON.stringify(hostMessage)) + response.end() + break + case "c": + console.log('Server: Host has completed gathering candidates') + response.writeHead('200', {'x-strapp-type': 'ice-state-complete'}) + response.write(JSON.stringify(hostMessage)) + response.end() + break + default: + console.log('unhandled iceState from host') + break + } + } + + }) + }) + + console.log(`Listening for websocket ${newRoute.host} on port ${newRoute.port}`) + router.routes[routeName] = newRoute + }).then(() => { + response.writeHead(200, { 'Content-Type': 'text/html' }) + response.write(`${router.skelPage[0]}` + + `\tconst _strapp_port = ${newRoute.port}\n` + + `\tconst _strapp_protocol = '${router.wsProtocol}'\n` + + `${router.hostJS}\n${router.skelPage[1]}`) + response.end() + }) + } + + + } + } + + /** + * @summary Boot up the router. With TLS, we must wait for file reads to sync. + */ + if (!opts['no-tls']) { + console.log('tls') + let filesRead = 0 + let key = undefined + let cert = undefined + const syncRead = () => { + if (++filesRead == 2) { + if (key == undefined) + console.log(`ERR: Key ${opts['ca-key']} inaccessible, tls will fail`) + if(cert == undefined) + console.log(`ERR: Cert ${opts['ca-cert']} inaccessible, tls will fail`) + else if (key != undefined) { + router.httpsOpts = { cert: cert, key: key} + router.httpd = https.createServer(router.httpsOpts, router.respond) + .listen(opts['port']) + } + } + } + fs.readFile(opts['ca-key'], { encoding: 'utf8' }, (err, data) => { + if (!err) key = data + syncRead() + }) + fs.readFile(opts['ca-cert'], { encoding: 'utf8' }, (err, data) => { + if (!err) cert = data + syncRead() + }) + } + else + router.httpd = http.createServer(router.respond).listen(opts['port']) + + //TODO: if ("electron" in process.versions) open a local renderwindow, and route to it