notls mode fixed, refactoring

[henge/kiak.git] / main.js

diff --git a/main.js b/main.js
index d767ef9..a058a1c 100644 (file)
--- a/main.js
+++ b/main.js
@@ -3,15 +3,131 @@
  * @author    Jordan Lavatai, Ken Grimes
  * @version   0.0.1
  * @license   AGPL-3.0
- * @copyright jk software 2017
+ * @copyright loljk 2017
  * @summary   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('<!--STRAPP_SRC-->'),
+  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) => {
+    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`)
+      }
+    }
+    else if (routeName in router.routes) {
+      const route = router.routes[routeName]
+      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)
+      route.socket.send(request.headers['x-forwarded-for'] || request.connection.remoteAddress)
+    }
+    else {
+      router.routes[routeName] = true
+      const newRoute = {}
+      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) => {
+         newRoute.socket = sock
+         sock.on('message', (msg) => { console.log(`[${newRoute.host}] ${msg}`) })
+       })
+       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']) {
+  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(this.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
+