topbit 1.0.0 → 3.0.0

package/src/httpc.js

@@ -0,0 +1,251 @@
+'use strict'
+
+const http2 = require('node:http2')
+const fs = require('node:fs')
+const process = require('node:process');
+const checkHeaderLimit = require('./headerLimit.js')
+const sendmsg = require('./sendmsg.js');
+
+let Httpc = function () {
+  if ( !(this instanceof Httpc) ) {
+    return new Httpc()
+  }
+
+  this.logger = null
+  this.config = null
+  this.fpurl = null
+  this.host = ''
+}
+
+/**
+ * 
+ * @param {object} app titbit实例
+ */
+
+Httpc.prototype.init = function (app) {
+  app.config.server.allowHTTP1 = true
+
+  app.httpServ.run = this.run
+
+  app.httpServ.onRequest = this.onRequest
+}
+
+Httpc.prototype.onRequest = function () {
+  let self = this
+
+  let callback = (req, res) => {
+    req.on('error', (err) => {
+      self.requestError(err, req, req.headers)
+    })
+
+    res.on('error', (err) => {
+      self.requestError(err, res, req.headers)
+    })
+
+    req.on('aborted', err => {
+      err && self.requestError(err, req, req.headers)
+      !err && req.destroy()
+    })
+
+    let remote_ip = req.socket.remoteAddress || ''
+
+    if (req.url.length > self.config.maxUrlLength) {
+      req.url = req.url.substring(0, self.config.maxUrlLength)
+    }
+
+    if (self.config.globalLog) {
+      
+      let real_ip = '-'
+      if (self.config.realIP) {
+        real_ip = req.headers['x-real-ip'] || req.headers['x-forwarded-for'] || '-'
+      }
+
+      res.on('finish', () => {
+        if (!req || !res) return;
+        
+        checkHeaderLimit(req.headers, 'user-agent', 111)
+
+        if (req.httpVersion[0] === '1') {
+          checkHeaderLimit(req.headers, 'host', 300)
+
+          self.logger({
+            method : req.method,
+            status : res.statusCode,
+            ip : remote_ip,
+            link: `https://${req.headers.host || self.host}${req.url}`,
+            agent : req.headers['user-agent'] || '-',
+            real_ip : real_ip,
+          })
+
+        } else {
+
+          if (res.stream.rstCode == http2.constants.NGHTTP2_NO_ERROR) {
+            checkHeaderLimit(req.headers, ':authority', 300)
+
+            self.logger({
+              method : req.method,
+              status : res.statusCode,
+              ip : remote_ip,
+              link : `https://${req.authority}${req.url}`,
+              agent : req.headers['user-agent'] || '-',
+              real_ip : real_ip,
+            })
+
+          }
+
+        }
+
+      })
+
+    }
+
+    let urlobj = self.fpurl(req.url, self.config.autoDecodeQuery,
+                    self.config.fastParseQuery,
+                    self.config.maxQuery)
+
+    let rt = self.router.findRealPath(urlobj.path, req.method)
+
+    if (rt === null) {
+      res.statusCode = 404
+      res.end(self.config.notFound)
+      return
+    }
+
+    let ctx = self.ctxpool.getctx() || new self.Context()
+
+    if (req.httpVersion[0] === '1') {
+      ctx.version = '1.1'
+      ctx.major = 1
+      ctx.host = req.headers.host || self.host
+    } else {
+      ctx.version = '2'
+      ctx.major = 2
+      ctx.host = req.authority
+    }
+
+    ctx.bodyLength = 0
+    ctx.maxBody = self.config.maxBody
+    ctx.service = self.service
+
+    ctx.method = req.method
+    ctx.protocol = 'https'
+    ctx.ip = remote_ip
+
+    ctx.port = req.socket.remotePort
+    ctx.req = req
+    ctx.res = res
+    ctx.stream = res
+
+    ctx.headers = req.headers
+
+    ctx.path = urlobj.path
+    ctx.query = urlobj.query
+    ctx.routepath = rt.key
+    ctx.requestCall = rt.reqcall.reqCall
+    ctx.name = rt.reqcall.name
+    ctx.group = rt.reqcall.group
+    ctx.param = rt.args
+    rt = null
+
+    return self.midware.run(ctx).finally(()=>{
+      ctx.stream = null
+      self.ctxpool.free(ctx)
+      ctx = null
+    })
+
+  }
+
+  return callback
+}
+
+/** 
+   * 运行HTTP/1.1服务
+   * @param {number} port 端口号
+   * @param {string} host IP地址，可以是IPv4或IPv6
+   * 0.0.0.0 对应使用IPv6则是::
+  */
+Httpc.prototype.run = function (port, host) {
+  let self = this
+  let serv = null
+
+  if (this.config.key && this.config.cert) {
+    try {
+        this.config.server.key  = fs.readFileSync(this.config.key)
+        this.config.server.cert = fs.readFileSync(this.config.cert)
+    } catch (err) {
+        !this.isWorker && console.error(err)
+        sendmsg('_server-error', err.message, {autoExit: true, exitCode: 1})
+    }
+  } else if (!this.config.server.SNICallback || typeof this.config.server.SNICallback !== 'function') {
+      !this.isWorker && console.error('APLN协议需要启用HTTPS，请设置cert和key 或 server.SNICallback。')
+      sendmsg('_server-error', '请设置cert和key或server.SNICallback。', {autoExit: true, exitCode: 1})
+  }
+
+  this.config.server.allowHTTP1 = true
+  
+  serv = http2.createSecureServer(this.config.server, this.onRequest())
+
+  serv.on('tlsClientError', (err, tls) => {
+    self.config.errorHandle(err, '--ERR-TLS-CLIENT--');
+    !tls.destroyed && tls.destroy();
+  })
+
+  serv.on('secureConnection', (sock) => {
+    sock.on('error', err => {
+      self.config.errorHandle(err, '--ERR-CONNECTION--')
+    })
+  })
+
+  serv.on('clientError', (err, sock) => {
+    !sock.destroyed && sock.destroy()
+  })
+
+  serv.on('unknownProtocol', tls_sock => {
+    !tls_sock.destroyed && tls_sock.destroy()
+  })
+
+  serv.on('error', (e) => {
+    if (e.code === 'EADDRINUSE') {
+      if (process.send !== undefined && typeof process.send === 'function') {
+        process.send({type: '_eaddr'}, (err) => {})
+      } else {
+        console.error('该端口已被使用，请先停止进程')
+        process.exit(1)
+      }
+    } else {
+      self.config.errorHandle(e, '--ERR--')
+    }
+  })
+  
+  serv.setTimeout(this.config.timeout, (sock) => {
+    !sock.destroyed && sock.destroy()
+  })
+  
+  for (let k in this.events) {
+    for (let ecall of this.events[k]) { 
+      if (typeof ecall !== 'function') {
+        continue
+      }
+
+      serv.on(k, ecall)
+    }
+  }
+
+  this.events = {}
+ 
+  //说明是使用unix socket模式监听服务
+  if (typeof port === 'string' && port.indexOf('.sock') > 0) {
+    serv.listen(port)
+  } else {
+    this.host = host
+    if (port !== 443) {
+      this.host += `:${port}`
+    }
+
+    serv.listen(port, host)
+  }
+
+  return serv
+}
+
+module.exports = Httpc

package/src/lib/npargv.js

@@ -0,0 +1,354 @@
+'use strict'
+
+/**
+ * {
+ *    '-a' : {
+ *      name: 'a',
+ *      type: 'number|string|int|float|bool',
+ *      min: 0,
+ *      max: 100,
+ *      match: RegExp,
+ *      default : any
+ *    },
+ *    
+ *    '$2': {
+ * 
+ *    },
+ *    {
+ *      '--port=' : {
+ *        name : 'port',
+ *        type : 'int',
+ *        min: 2000,
+ *        max: 5000,
+ *        default: 3456
+ *      }
+ *    }
+ * }
+ * 
+ */
+
+function setVal (a, ainfo, obj, next) {
+
+  if (ainfo.type && ['int', 'float', 'number'].indexOf(ainfo.type) >= 0) {
+      if (isNaN(next)) {
+        return {
+          ok: false,
+          message: `${a} 类型错误，要求参数必须是数字类型：${next}`
+        }
+      }
+
+      if (ainfo.type === 'int' || ainfo.type === 'number') {
+        next = parseInt(next)
+      } else {
+        next = parseFloat(next)
+      }
+  }
+
+  if (ainfo.min !== undefined) {
+    if (next < ainfo.min) {
+      return {
+        ok: false,
+        message: `${a} 数值不能低于 ${ainfo.min}`
+      }
+    }
+  }
+
+  if (ainfo.max !== undefined) {
+    if (next > ainfo.max) {
+      return {
+        ok: false,
+        message: `${a} 数值不能大于 ${ainfo.max}`
+      }
+    }
+  }
+
+  if (ainfo.match && ainfo.match instanceof RegExp) {
+    if (!ainfo.match.test(next)) {
+      return {
+        ok: false,
+        message: `${a} 数值无法匹配 ${next}`
+      }
+    }
+  }
+
+  let val = next
+
+  if (ainfo.callback && typeof ainfo.callback === 'function') {
+    val = ainfo.callback(next)
+    if (val === undefined) val = next
+  }
+
+  obj[ ainfo.name || a ] = val
+
+  return {
+    ok: true,
+    message: ''
+  }
+
+}
+
+function checkAndSet (a, ainfo, obj, next) {
+
+  if (typeof ainfo === 'boolean') {
+    obj[a] = true
+    return {
+      ok: true,
+      message: '',
+      op: 'none'
+    }
+  }
+
+  if (ainfo.type === 'bool' || ainfo.type === 'boolean') {
+    obj[ ainfo.name || a ] = true
+
+    return {
+      ok: true,
+      message: '',
+      op: 'none'
+    }
+  }
+
+  if (next === null) {
+    return {
+      ok: false,
+      message: `${a} 必须携带参数。`
+    }
+  }
+
+  let r = setVal(a, ainfo, obj, next)
+
+  if (!r.ok && ainfo.default !== undefined) {
+    r.ok = true
+  }
+
+  if (r.ok) {
+    r.op = 'next'
+
+    if (a[a.length - 1] === '=') {
+      r.op = 'none'
+    }
+  }
+
+  return r
+}
+
+function setAutoDefault (opts, k) {
+  switch (opts[k].type) {
+    case 'number':
+    case 'int':
+    case 'float':
+      opts[k].default = 0
+      if (opts[k].min)
+        opts[k].default = opts[k].min;
+      break
+
+    case 'string':
+      opts[k].default = ''
+      break
+
+    case 'bool':
+    case 'boolean':
+      opts[k].default = false
+      break
+  }
+}
+
+/*
+ * opts['@autoDefault'] = true 表示自动设定默认值
+ *
+ * */
+
+function parseArgv (options = null, obj = null) {
+  if (!options) options = {}
+
+  if (obj === null) obj = {}
+
+  let opts = {}
+
+  for (let k in options) {
+    opts[k] = options[k]
+  }
+
+  let autoDefault = false
+
+  if (opts['@autoDefault'] === undefined) opts['@autoDefault'] = true;
+
+  if (opts['@autoDefault'] !== undefined) {
+    autoDefault = !!opts['@autoDefault']
+    delete opts['@autoDefault']
+  }
+
+  let commands = []
+  if (opts['@command'] !== undefined) {
+    if (typeof opts['@command'] === 'string') {
+      opts['@command'].split(' ').filter(p => p.length > 0).forEach(a => {
+        commands.push(a.trim())
+      })
+    } else if (Array.isArray(opts['@command'])) {
+      commands = opts['@command'];
+    }
+    delete opts['@command'];
+  }
+
+  let defaultCommand = ''
+  if (opts['@defaultCommand'] !== undefined && commands.indexOf(opts['@defaultCommand']) >= 0) {
+    defaultCommand = opts['@defaultCommand'];
+    delete opts['@defaultCommand'];
+  }
+
+  let userCommand = null
+  let commandFromInput = false
+  if (commands.length > 0) {
+    if (process.argv.length < 3) {
+      if (defaultCommand) userCommand = defaultCommand;
+      else {
+        return {
+          ok: false,
+          message: '请使用子命令：' + commands.join('|'),
+          args: obj
+        }
+      }
+    } else if  (commands.indexOf(process.argv[2]) < 0) {
+      if (defaultCommand) userCommand = defaultCommand;
+      else {
+        return {
+          ok: false,
+          message: '不支持的子命令',
+          args: obj
+        }
+      }
+    } else {
+      commandFromInput = true
+      userCommand = process.argv[2]
+    }
+  }
+
+  let tmp_val
+
+  for (let k in opts) {
+    if (typeof opts[k] === 'string' && opts[k].trim().length > 0) {
+      opts[k] = {
+        name: opts[k].trim(),
+        type: 'boolean',
+        default: false
+      }
+    }
+
+    if (typeof opts[k] !== 'object' || opts[k].toString() !== '[object Object]') {
+
+      opts[k] = {
+        type : 'boolean',
+        name : k,
+        default: false
+      }
+
+    } else if (opts[k].type === undefined) {
+
+      if (k.indexOf('=') > 0) {
+        opts[k].type = 'string'
+      } else if (opts[k].match || opts[k].callback) {
+        opts[k].type = 'string'
+      } else {
+          if (opts[k].min !== undefined || opts[k].max !== undefined) {
+            opts[k].type = 'int'
+          } else if (opts[k].default !== undefined) {
+            tmp_val = typeof opts[k].default
+            if (tmp_val === 'number' || tmp_val === 'boolean' || tmp_val === 'string') {
+              opts[k].type = tmp_val
+            } else {
+              opts[k].type = 'string'
+            }
+          } else {
+            opts[k].type = 'bool'
+          }
+      }
+
+    }
+
+    autoDefault && opts[k].default === undefined && setAutoDefault(opts, k)
+
+    if (opts[k].type === 'bool' || opts[k].type === 'boolean') {
+      obj[ opts[k].name || k ] = false
+    } else if (opts[k].default !== undefined) {
+      obj[ opts[k].name || k ] = opts[k].default
+    }
+
+  }
+
+  for (let k in opts) {
+    if (opts[k].alias && typeof opts[k].alias === 'string' && opts[k].alias !== k) {
+      opts[opts[k].alias] = opts[k]
+    }
+  }
+
+  let a
+  let next
+  let next_end = process.argv.length - 1
+  let r = ''
+  let i = 2
+  let offset = 1
+  if (commands.length > 0 && commandFromInput) {
+    i++
+    offset = 2
+  }
+
+  let ind = 0
+  let pos_key = ''
+  let aList = []
+
+  while (i < process.argv.length) {
+
+    //先检测是否存在对位置的引用
+    pos_key = '$' + `${i-offset}`
+    if (opts[pos_key]) {
+      r = checkAndSet(pos_key, opts[pos_key], obj, process.argv[i])
+      if (!r.ok) {
+        r.args = obj
+        return r
+      }
+      i++
+      continue
+    }
+
+    a = process.argv[i]
+    
+    next = i < next_end ? process.argv[i+1] : null
+
+    ind = a.indexOf('=')
+
+    if (ind > 0) {
+      a = a.substring(0, ind+1)
+      next = process.argv[i].substring(ind+1)
+    }
+
+    if (opts[a]) {
+      r = checkAndSet(a, opts[a], obj, next)
+      if (!r.ok) {
+        r.args = obj
+        return r
+      }
+
+      if (r.op === 'next') {
+        i += 2
+        continue
+      }
+
+    } else {
+      if (a[0] !== '-') {
+        a[0] !== '\\' ? aList.push(a) : aList.push(a.substring(1))
+      }
+    }
+
+    i++
+  }
+
+  return {
+    ok: true,
+    message: '',
+    args: obj,
+    list: aList,
+    command: userCommand
+  }
+}
+
+module.exports = parseArgv

package/src/lib/zipdata.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const zlib = require('zlib')
+const fs = require('fs')
+
+const fsp = fs.promises
+
+let zipdata = async (pathfile, isData=false) => {
+  let d
+
+  if (isData) {
+    d = pathfile
+  } else {
+    d = await fsp.readFile(pathfile)
+  }
+
+  return await new Promise((rv, rj) => {
+      zlib.gzip(d, (err, zipdata) => {
+        if (err) {
+          rj (err)
+        }
+
+        rv(zipdata)
+      })
+  })
+}
+
+zipdata.unzip = async (pathfile, isData = false) => {
+  let d
+  if (isData) {
+    d = pathfile
+  } else {
+    d = await fsp.readFile(pathfile)
+  }
+
+  return new Promise((rv, rj) => {
+    zlib.unzip(d, (err, data) => {
+      if (err) rj(err)
+
+      rv(data)
+    })
+  })
+}
+
+module.exports = zipdata