bare-http1 3.2.1 → 3.3.0

package/README.md

@@ -6,7 +6,9 @@ HTTP/1 library for JavaScript.
 npm i bare-http1
 ```
 
-Only HTTP servers at the moment and currently does NOT support server request bodies, but supports most other HTTP features (keep-alive, chunked encoding, etc.) and streaming server responses.
+Currently HTTP servers does NOT support server request bodies, but supports most other HTTP features (keep-alive, chunked encoding, etc.) and streaming server responses.
+
+Basic HTTP client is supported, but currently it does NOT support keep-alive and protocol negotiation.
 
 ## Usage
 
@@ -23,7 +25,13 @@ const server = http.createServer(function (req, res) {
 })
 
 server.listen(0, function () {
-  console.log('server is bound on', server.address().port)
+  const { port } = server.address()
+  console.log('server is bound on', port)
+
+  const client = http.request({ port }, res => {
+    res.on('data', (data) => console.log(data.toString()))
+  })
+  client.end()
 })
 ```
 

package/index.js

@@ -5,6 +5,9 @@ const Server = exports.Server = require('./lib/server')
 exports.ServerResponse = require('./lib/server-response')
 exports.ServerConnection = require('./lib/server-connection')
 
+const Request = exports.ClientRequest = require('./lib/client-request')
+exports.ClientConnection = require('./lib/client-connection')
+
 exports.constants = require('./lib/constants')
 
 exports.STATUS_CODES = exports.constants.status // For Node.js compatibility
@@ -12,3 +15,37 @@ exports.STATUS_CODES = exports.constants.status // For Node.js compatibility
 exports.createServer = function createServer (opts, onrequest) {
   return new Server(opts, onrequest)
 }
+
+exports.request = function request (url, opts, onresponse) {
+  if (typeof opts === 'function') {
+    onresponse = opts
+    opts = {}
+  }
+
+  if (typeof url === 'string') url = new URL(url)
+
+  if (URL.isURL(url)) {
+    opts = opts ? { ...opts } : {}
+
+    opts.host = url.hostname
+    opts.path = url.pathname
+    opts.port = url.port ? parseInt(url.port, 10) : defaultPort(url)
+  } else {
+    opts = url
+  }
+
+  return new Request(opts, onresponse)
+}
+
+// https://url.spec.whatwg.org/#default-port
+function defaultPort (url) {
+  switch (url.protocol) {
+    case 'ftp:': return 21
+    case 'http':
+    case 'ws': return 80
+    case 'https':
+    case 'wss': return 443
+  }
+
+  return null
+}

package/lib/client-connection.js

@@ -0,0 +1,183 @@
+const HTTPIncomingMessage = require('./incoming-message')
+const constants = require('./constants')
+const errors = require('./errors')
+
+module.exports = class HTTPClientConnection {
+  constructor (socket, opts = {}) {
+    const {
+      IncomingMessage = HTTPIncomingMessage
+    } = opts
+
+    this.socket = socket
+
+    this.req = null
+    this.res = null
+
+    this._IncomingMessage = IncomingMessage
+
+    this._state = constants.state.BEFORE_HEAD
+    this._length = -1
+    this._read = 0
+    this._buffer = null
+
+    socket
+      .on('error', this._onerror.bind(this))
+      .on('close', this._onclose.bind(this))
+      .on('end', this._onend.bind(this))
+      .on('data', this._ondata.bind(this))
+      .on('drain', this._ondrain.bind(this))
+  }
+
+  _onerror (err) {
+    if (this.req) this.req.destroy(err)
+  }
+
+  _onclose () {
+    if (this.req) this.req._continueFinal()
+  }
+
+  _onend () {
+    if (this.req) this.req.destroy(errors.CONNECTION_LOST())
+  }
+
+  _ondata (data) {
+    if (this._state === constants.state.IN_BODY) return this._onbody(data)
+
+    if (this._buffer !== null) {
+      this._buffer = Buffer.concat([this._buffer, data])
+    } else {
+      this._buffer = data
+    }
+
+    let hits = 0
+
+    for (let i = 0; i < this._buffer.byteLength; i++) {
+      const b = this._buffer[i]
+
+      if (hits === 0 && b === 13) {
+        hits++
+      } else if (hits === 1 && b === 10) {
+        hits++
+
+        if (this._state === constants.state.BEFORE_CHUNK) {
+          const head = this._buffer.subarray(0, i - 1)
+          this._buffer = i + 1 === this._buffer.byteLength ? null : this._buffer.subarray(i + 1)
+          i = 0
+          hits = 0
+          this._onchunklength(head)
+
+          if (this._buffer === null) break
+        } else if (this._state === constants.state.IN_CHUNK) {
+          const chunk = this._buffer.subarray(0, i - 1)
+
+          if (chunk.byteLength !== this._length) {
+            hits = 0
+            continue
+          }
+
+          this._buffer = i + 1 === this._buffer.byteLength ? null : this._buffer.subarray(i + 1)
+          i = 0
+          hits = 0
+          this._onchunk(chunk)
+
+          if (this._buffer === null) break
+        }
+      } else if (hits === 2 && b === 13) {
+        hits++
+      } else if (hits === 3 && b === 10) {
+        if (this._state === constants.state.BEFORE_HEAD) {
+          const head = this._buffer.subarray(0, i - 3)
+          this._buffer = i + 1 === this._buffer.byteLength ? null : this._buffer.subarray(i + 1)
+          i = 0
+          hits = 0
+          this._onhead(head)
+
+          if (this._buffer === null) break
+        }
+      } else {
+        hits = 0
+      }
+    }
+  }
+
+  _onhead (data) {
+    this._state = constants.state.IN_HEAD
+
+    const r = data.toString().split('\r\n')
+    if (r.length === 0) return this.socket.destroy()
+
+    const [, statusCode, statusMessage] = r[0].split(' ')
+    if (!statusCode || !statusMessage) return this.socket.destroy()
+
+    const headers = {}
+
+    for (let i = 1; i < r.length; i++) {
+      const [name, value] = r[i].split(': ')
+      headers[name.toLowerCase()] = value
+    }
+
+    this.res = new this._IncomingMessage(this.socket, headers, { statusCode: parseInt(statusCode, 10), statusMessage })
+
+    this.req.on('close', () => { this.req = null })
+    this.res.on('close', () => { this.res = null; this._onreset() })
+
+    this.req.emit('response', this.res)
+
+    if (headers['transfer-encoding'] === 'chunked') {
+      this._state = constants.state.BEFORE_CHUNK
+    } else {
+      this._length = parseInt(headers['content-length'], 10) || 0
+
+      if (this._length === 0) return this._onfinished()
+
+      this._state = constants.state.IN_BODY
+
+      if (this._buffer) {
+        const body = this._buffer
+        this._buffer = null
+        this._onbody(body)
+      }
+    }
+  }
+
+  _onchunklength (data) {
+    this._length = parseInt(data.toString(), 16)
+
+    if (this._length === 0) this._onfinished()
+    else this._state = constants.state.IN_CHUNK
+  }
+
+  _onchunk (data) {
+    this._read += data.byteLength
+
+    this.res.push(data)
+
+    this._state = constants.state.BEFORE_CHUNK
+  }
+
+  _onbody (data) {
+    this._read += data.byteLength
+
+    this.res.push(data)
+
+    if (this._read === this._length) this._onfinished()
+  }
+
+  _onfinished () {
+    if (this.res) this.res.push(null)
+    if (this.req) this.req._continueFinal()
+
+    this.socket.end()
+  }
+
+  _onreset () {
+    this._state = constants.state.BEFORE_HEAD
+    this._length = -1
+    this._read = 0
+    this._buffer = null
+  }
+
+  _ondrain () {
+    if (this.res) this.res._continueWrite()
+  }
+}

package/lib/client-request.js

@@ -0,0 +1,69 @@
+const tcp = require('bare-tcp')
+const HTTPOutgoingMessage = require('./outgoing-message')
+const HTTPClientConnection = require('./client-connection')
+
+module.exports = class HTTPClientRequest extends HTTPOutgoingMessage {
+  constructor (opts = {}, onresponse = null) {
+    if (typeof opts === 'function') {
+      onresponse = opts
+      opts = {}
+    }
+
+    const {
+      connection = new HTTPClientConnection(tcp.createConnection(opts))
+    } = opts
+
+    super(connection.socket)
+
+    connection.req = this
+
+    this.method = opts.method || 'GET'
+    this.path = opts.path || '/'
+    const host = opts.host || 'localhost'
+    const port = opts.port || 80
+
+    this.headers = { host: host + ':' + port }
+
+    this._connection = connection
+
+    this._pendingFinal = null
+
+    if (onresponse) this.once('response', onresponse)
+  }
+
+  _header () {
+    let h = `${this.method} ${this.path} HTTP/1.1\r\n`
+
+    for (const name of Object.keys(this.headers)) {
+      const n = name.toLowerCase()
+      const v = this.headers[name]
+
+      h += `${httpCase(n)}: ${v}\r\n`
+    }
+
+    h += '\r\n'
+
+    return h
+  }
+
+  _final (cb) {
+    if (this.headersSent === false) this.flushHeaders()
+
+    this._pendingFinal = cb
+  }
+
+  _continueFinal () {
+    if (this._pendingFinal === null) return
+    const cb = this._pendingFinal
+    this._pendingFinal = null
+    cb(null)
+  }
+}
+
+function httpCase (n) {
+  let s = ''
+  for (const part of n.split('-')) {
+    s += (s ? '-' : '') + part.slice(0, 1).toUpperCase() + part.slice(1)
+  }
+  return s
+}

package/lib/constants.js

@@ -1,4 +1,11 @@
 module.exports = {
+  state: {
+    BEFORE_HEAD: 1,
+    IN_HEAD: 2,
+    IN_BODY: 3,
+    BEFORE_CHUNK: 4,
+    IN_CHUNK: 5
+  },
   status: {
     100: 'Continue',
     101: 'Switching Protocols',

package/lib/errors.js

@@ -0,0 +1,22 @@
+module.exports = class HTTPError extends Error {
+  constructor (msg, code, fn = HTTPError) {
+    super(`${code}: ${msg}`)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name () {
+    return 'HTTPError'
+  }
+
+  static NOT_IMPLEMENTED (msg = 'Method not implemented') {
+    return new HTTPError(msg, 'NOT_IMPLEMENTED', HTTPError.NOT_IMPLEMENTED)
+  }
+
+  static CONNECTION_LOST (msg = 'Socket hung up') {
+    return new HTTPError(msg, 'CONNECTION_LOST', HTTPError.CONNECTION_LOST)
+  }
+}

package/lib/incoming-message.js

@@ -1,15 +1,19 @@
 const { Readable } = require('bare-stream')
 
 module.exports = class HTTPIncomingMessage extends Readable {
-  constructor (socket, method, url, headers) {
+  constructor (socket, headers, args = {}) {
     super()
 
     this.socket = socket
-    this.method = method
-    this.url = url
     this.headers = headers
 
-    this.push(null)
+    // Server arguments
+    this.method = args.method || ''
+    this.url = args.url || ''
+
+    // Client arguments
+    this.statusCode = args.statusCode || 0
+    this.statusMessage = args.statusMessage || ''
   }
 
   get httpVersion () {

package/lib/outgoing-message.js

@@ -1,13 +1,11 @@
 const { Writable } = require('bare-stream')
-const constants = require('./constants')
+const errors = require('./errors')
 
 module.exports = class HTTPOutgoingMessage extends Writable {
   constructor (socket) {
-    super({ map: mapToBuffer })
+    super({ mapWritable })
 
     this.socket = socket
-    this.statusCode = 200
-    this.statusMessage = null
     this.headers = {}
     this.headersSent = false
   }
@@ -31,39 +29,19 @@ module.exports = class HTTPOutgoingMessage extends Writable {
   flushHeaders () {
     if (this.headersSent === true) return
 
-    let h = 'HTTP/1.1 ' + this.statusCode + ' ' + (this.statusMessage === null ? constants.status[this.statusCode] : this.statusMessage) + '\r\n'
-
-    for (const name of Object.keys(this.headers)) {
-      const n = name.toLowerCase()
-      const v = this.headers[name]
-
-      if (n === 'content-length') this._chunked = false
-      if (n === 'connection' && v === 'close') this._close = true
-
-      h += httpCase(n) + ': ' + v + '\r\n'
-    }
-
-    if (this._chunked) h += 'Transfer-Encoding: chunked\r\n'
-
-    h += '\r\n'
-
-    this.socket.write(Buffer.from(h))
+    this.socket.write(Buffer.from(this._header()))
     this.headersSent = true
   }
 
-  _predestroy () {
-    this.socket.destroy()
+  _header () {
+    throw errors.NOT_IMPLEMENTED()
   }
-}
 
-function httpCase (n) {
-  let s = ''
-  for (const part of n.split('-')) {
-    s += (s ? '-' : '') + part.slice(0, 1).toUpperCase() + part.slice(1)
+  _predestroy () {
+    this.socket.destroy()
   }
-  return s
 }
 
-function mapToBuffer (b) {
-  return typeof b === 'string' ? Buffer.from(b) : b
+function mapWritable (data) {
+  return typeof data === 'string' ? Buffer.from(data) : data
 }

package/lib/server-connection.js

@@ -1,5 +1,6 @@
 const HTTPIncomingMessage = require('./incoming-message')
 const HTTPServerResponse = require('./server-response')
+const constants = require('./constants')
 
 module.exports = class HTTPServerConnection {
   constructor (server, socket, opts = {}) {
@@ -8,15 +9,18 @@ module.exports = class HTTPServerConnection {
       ServerResponse = HTTPServerResponse
     } = opts
 
-    this._server = server
-    this._socket = socket
+    this.server = server
+    this.socket = socket
+
+    this.req = null
+    this.res = null
 
     this._IncomingMessage = IncomingMessage
     this._ServerResponse = ServerResponse
 
-    this._requests = new Set()
-    this._responses = new Set()
-
+    this._state = constants.state.BEFORE_HEAD
+    this._length = -1
+    this._read = 0
     this._buffer = null
 
     socket
@@ -26,7 +30,7 @@ module.exports = class HTTPServerConnection {
   }
 
   _onerror (err) {
-    this._socket.destroy(err)
+    this.socket.destroy(err)
   }
 
   _ondata (data) {
@@ -48,25 +52,29 @@ module.exports = class HTTPServerConnection {
       } else if (hits === 2 && b === 13) {
         hits++
       } else if (hits === 3 && b === 10) {
-        hits = 0
-
-        const head = this._buffer.subarray(0, i + 1)
-        this._buffer = i + 1 === this._buffer.byteLength ? null : this._buffer.subarray(i + 1)
-        this._onrequest(head)
-
-        if (this._buffer === null) break
+        if (this._state === constants.state.BEFORE_HEAD) {
+          const head = this._buffer.subarray(0, i - 3)
+          this._buffer = i + 1 === this._buffer.byteLength ? null : this._buffer.subarray(i + 1)
+          i = 0
+          hits = 0
+          this._onhead(head)
+
+          if (this._buffer === null) break
+        }
       } else {
         hits = 0
       }
     }
   }
 
-  _onrequest (head) {
-    const r = head.toString().trim().split('\r\n')
-    if (r.length === 0) return this._socket.destroy()
+  _onhead (data) {
+    this._state = constants.state.IN_HEAD
+
+    const r = data.toString().split('\r\n')
+    if (r.length === 0) return this.socket.destroy()
 
     const [method, url] = r[0].split(' ')
-    if (!method || !url) return this._socket.destroy()
+    if (!method || !url) return this.socket.destroy()
 
     const headers = {}
 
@@ -75,19 +83,25 @@ module.exports = class HTTPServerConnection {
       headers[name.toLowerCase()] = value
     }
 
-    const req = new this._IncomingMessage(this._socket, method, url, headers)
-    const res = new this._ServerResponse(this._socket, req, headers.connection === 'close')
+    this.req = new this._IncomingMessage(this.socket, headers, { method, url })
+    this.res = new this._ServerResponse(this.socket, this.req, headers.connection === 'close')
+
+    this.req.on('close', () => { this.req = null })
+    this.res.on('close', () => { this.res = null; this._onreset() })
 
-    this._requests.add(req)
-    this._responses.add(res)
+    this.req.push(null)
 
-    req.on('close', () => this._requests.delete(req))
-    res.on('close', () => this._responses.delete(res))
+    this.server.emit('request', this.req, this.res)
+  }
 
-    this._server.emit('request', req, res)
+  _onreset () {
+    this._state = constants.state.BEFORE_HEAD
+    this._length = -1
+    this._read = 0
+    this._buffer = null
   }
 
   _ondrain () {
-    for (const res of this._responses) res._continueWrite()
+    if (this.res) this.res._continueWrite()
   }
 }

package/lib/server-response.js

@@ -1,4 +1,5 @@
 const HTTPOutgoingMessage = require('./outgoing-message')
+const constants = require('./constants')
 
 module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
   constructor (socket, req, close) {
@@ -6,6 +7,9 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
 
     this.req = req
 
+    this.statusCode = 200
+    this.statusMessage = null
+
     this._chunked = true
     this._close = close
     this._finishing = false
@@ -30,6 +34,26 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     this.headers = headers || {}
   }
 
+  _header () {
+    let h = 'HTTP/1.1 ' + this.statusCode + ' ' + (this.statusMessage === null ? constants.status[this.statusCode] : this.statusMessage) + '\r\n'
+
+    for (const name of Object.keys(this.headers)) {
+      const n = name.toLowerCase()
+      const v = this.headers[name]
+
+      if (n === 'content-length') this._chunked = false
+      if (n === 'connection' && v === 'close') this._close = true
+
+      h += httpCase(n) + ': ' + v + '\r\n'
+    }
+
+    if (this._chunked) h += 'Transfer-Encoding: chunked\r\n'
+
+    h += '\r\n'
+
+    return h
+  }
+
   _write (data, cb) {
     if (this.headersSent === false) {
       if (this._finishing) {
@@ -78,3 +102,11 @@ module.exports = class HTTPServerResponse extends HTTPOutgoingMessage {
     cb(null)
   }
 }
+
+function httpCase (n) {
+  let s = ''
+  for (const part of n.split('-')) {
+    s += (s ? '-' : '') + part.slice(0, 1).toUpperCase() + part.slice(1)
+  }
+  return s
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-http1",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "Native HTTP/1 library for JavaScript",
   "exports": {
     ".": "./index.js",
@@ -30,7 +30,6 @@
     "bare-tcp": "^1.1.2"
   },
   "devDependencies": {
-    "bare-subprocess": "^2.0.0",
     "brittle": "^3.3.0",
     "mime-types": "^2.1.35",
     "pump": "^3.0.0",