@fails-components/webtransport-transport-http3-quiche 1.0.0-rc.1

package/lib/index.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'fs'
+import { createRequire } from 'module'
+import * as path from 'path'
+import * as url from 'url'
+import { arch, platform } from 'node:process'
+import { logger } from './utils.js'
+
+const log = logger(`webtransport:native(${process?.pid})`)
+
+const binplatform = platform + '_' + arch
+const require = createRequire(import.meta.url)
+const dirname = url.fileURLToPath(new URL('.', import.meta.url))
+let buildpath = '../build_' + binplatform
+
+if (!existsSync(path.join(dirname, buildpath))) buildpath = '../build' // use precompiled only if own compilation does not exist
+
+let wtpath = buildpath + '/Release/webtransport.node'
+
+if (
+  process.env.NODE_ENV !== 'production' &&
+  existsSync(path.join(dirname, buildpath + '/Debug/webtransport.node'))
+) {
+  wtpath = buildpath + '/Debug/webtransport.node'
+}
+log('load webtransport binary:', wtpath)
+
+export const wtrouter = require(wtpath)
+export const quicheInit = wtrouter.quicheInit
+
+let quicheInited = false
+
+/**
+ * @param {{quicheLogVerbose?: Number, path?: string}} [args]
+ */
+export const checkQuicheInit = function (args) {
+  if (!quicheInited) {
+    quicheInit({
+      quicheLogVerbose: args?.quicheLogVerbose ? args.quicheLogVerbose : -1
+    })
+    quicheInited = true
+  }
+}
+
+export const Http3WebTransportClient = wtrouter.Http3WebTransportClient
+export const Http3WebTransportServer = wtrouter.Http3WebTransportServer
+export { Http3WebTransportClientSocket } from './clientsocket.js'
+export { Http3WebTransportServerSocket } from './serversocket.js'

package/lib/serversocket.js

@@ -0,0 +1,80 @@
+import { createSocket } from 'node:dgram'
+import { lookup } from 'node:dns/promises'
+
+import { logger } from './utils.js'
+import { Http3WebTransportSocket } from './socket.js'
+
+const log = logger(`webtransport:Http3WebTransportServerSocket(${process.pid})`)
+
+export class Http3WebTransportServerSocket extends Http3WebTransportSocket {
+  /**
+   * @param {import('../../../main/lib/types.js').HttpWebTransportInit|undefined} args
+   */
+  constructor(args) {
+    super(args)
+    let port = args?.port
+    if (typeof port === 'undefined') port = 443
+    this.port = Number(port)
+    this.host = args?.host || 'localhost'
+    /** @type {import('../../../main/lib/session.js').HttpServer} */
+    // @ts-ignore
+    this.jsobj = undefined // the transport will set this
+
+    /** @type {import('node:dns').LookupAddress|undefined} */
+    this.address = undefined
+  }
+
+  init() {
+    lookup(this.host)
+      .then((result) => {
+        this.address = result
+        this.socketInt = createSocket({
+          type: result.family === 4 ? 'udp4' : 'udp6'
+        })
+
+        this.socketInt.on('listening', () => {
+          const addr = this.socketInt.address()
+          const retObj = {
+            port: addr?.port,
+            host: addr?.address
+          }
+          this.jsobj.onServerListening(retObj)
+        })
+
+        this.socketInt.on('error', (error) => {
+          this.jsobj.onServerError(error)
+        })
+
+        this.socketInt.on('close', () => {
+          this.jsobj.onServerClose()
+        })
+
+        this.socketInt.on('message', (msg, rinfo) => {
+          // console.log('srv msg', msg, rinfo)
+          const haschlos = this.cobj.recvPaket({
+            msg,
+            rinfo,
+            selfaddress: this.socketInt.address()
+          })
+          if (!this.chlosSched && haschlos) {
+            setImmediate(this.doProcessBufferedChlos)
+            this.chlosSched = true
+          }
+        })
+        this.socketInt.bind(this.port, this.address?.address)
+        this.cobj.onCanWrite()
+      })
+      .catch((error) => {
+        log('Problem server:', error)
+        // hostname not known
+        this.jsobj.onServerError()
+      })
+  }
+
+  stopServer() {
+    this.cobj.destroy()
+    this.socketInt.close()
+    this.closed = true
+    // TODO call close on all sessions
+  }
+}

package/lib/socket.js

@@ -0,0 +1,118 @@
+import { X509Certificate, createVerify } from 'node:crypto'
+import { logger } from './utils.js'
+import { rootCertificates } from 'node:tls'
+const log = logger(`webtransport:Http3WebTransportSocket(${process.pid})`)
+
+globalThis.FAILSsetTimeoutAlarm = (
+  /** @type {{ fireJS: () => void; }} */ alarm,
+  /** @type {number} */ delay
+) => {
+  return setTimeout(alarm.fireJS.bind(alarm), delay)
+}
+
+globalThis.FAILSVerifyProof = (
+  /** @type {{ certs: string[]; hostname: string; server_config?: string; signature?: string; }} */ obj
+) => {
+  try {
+    if (obj.certs.length < 1) return false
+    const leafcert = new X509Certificate(obj.certs[0])
+    if (!leafcert.checkHost(obj.hostname)) return false
+
+    if (obj.server_config) {
+      if (!obj.signature) return false
+      const verify = createVerify('SHA256')
+      verify.write(obj.server_config)
+      verify.end()
+      if (!verify.verify(leafcert.publicKey, obj.signature, 'hex')) return false
+    }
+
+    const curdate = new Date()
+
+    if (
+      new Date(leafcert.validFrom) > curdate ||
+      new Date(leafcert.validTo) < curdate
+    )
+      return false
+
+    let curcert = leafcert
+    for (let certnum = 1; certnum < obj.certs.length; certnum++) {
+      const nextcert = new X509Certificate(obj.certs[certnum])
+
+      if (
+        new Date(nextcert.validFrom) > curdate ||
+        new Date(nextcert.validTo) < curdate
+      )
+        return false
+
+      if (!curcert.checkIssued(nextcert)) return false
+      if (!curcert.verify(nextcert.publicKey)) return false
+      curcert = nextcert
+    }
+    // curcert must be one of the rootCertificates
+
+    if (
+      !rootCertificates.some((rootCA) => {
+        const testCert = new X509Certificate(rootCA)
+        if (curcert.checkIssued(testCert)) {
+          if (!curcert.verify(testCert.publicKey)) return false
+          else return true
+        } else return false
+      })
+    )
+      return false
+  } catch (error) {
+    log('VerifyProof error:', error)
+    return false
+  }
+  return true
+}
+
+export class Http3WebTransportSocket {
+  /**
+   * @param {import('../../../main/lib/types.js').HttpWebTransportInit|undefined} args
+   */
+  constructor(args) {
+    /** @type {import('node:dgram').Socket} */
+    // @ts-ignore
+    this.socketInt = undefined // the transport will set this
+    // @ts-ignore
+    this.cobj = undefined // the transport will set this
+    this.chlosSched = false
+    this.packetSendCB = this.packetSendCB.bind(this)
+    this.doProcessBufferedChlos = this.doProcessBufferedChlos.bind(this)
+    this.blocked = false
+    this.closed = false
+  }
+
+  doProcessBufferedChlos() {
+    this.cobj.processBufferedChlos()
+    this.chlosSched = false
+  }
+
+  /**
+   * @param {import('./types').UDPServerSocketSend} args
+   */
+
+  sendPacket({ msg, offset, length, port, address }) {
+    if (this.closed) return true
+    this.socketInt.send(
+      msg, // It seems that we need a copy, so maybe a js side buffer is a better choice, we copy now on c++ side
+      offset,
+      length,
+      port,
+      address,
+      this.packetSendCB
+    )
+    // @ts-ignore
+    const blocked = this.socketInt.getSendQueueCount() > 0
+    this.blocked = this.blocked || blocked
+    return blocked
+  }
+
+  packetSendCB() {
+    // @ts-ignore
+    if (this.socketInt.getSendQueueCount() === 0 && this.blocked) {
+      this.cobj.onCanWrite()
+    }
+  }
+}

package/lib/types.ts

@@ -0,0 +1,15 @@
+
+export interface UDPServerSocketSend {
+    msg:  Uint8Array
+    offset: number
+    length: number
+    port:number
+    address: string
+  }
+
+  export interface Logger {
+    (formatter: any, ...args: any[]): void
+    error: (formatter: any, ...args: any[]) => void
+    trace: (formatter: any, ...args: any[]) => void
+  }
+  

package/lib/utils.js

@@ -0,0 +1,12 @@
+import debug from 'debug'
+
+/**
+ * @param {string} name
+ * @returns {import('./types').Logger}
+ */
+export function logger(name) {
+  return Object.assign(debug(name), {
+    error: debug(`${name}:error`),
+    trace: process?.env.DEBUG_TRACE ? debug(`${name}:trace`) : () => {}
+  })
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@fails-components/webtransport-transport-http3-quiche",
+  "version": "1.0.0-rc.1",
+  "description": "A component to add webtransport support (server and client) to node.js, transport using libquiche",
+  "exports": {
+    ".": {
+      "node": "./lib/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=16.5"
+  },
+  "type": "module",
+  "types": "./dist/lib/index.d.ts",
+  "scripts": {
+    "start": "node test/echoserver.js",
+    "install": "node build.js install",
+    "dobuild": "node build.js build",
+    "rebuild": "node build.js rebuild",
+    "rebuild-debug": "node build.js rebuild-debug -D",
+    "build-debug": "node build.js build-debug",
+    "prebuild": "node build.js prebuild",
+    "types": "tsc",
+    "lint": "eslint lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fails-components/webtransport.git"
+  },
+  "keywords": [
+    "webtransport"
+  ],
+  "author": "Marten Richter",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/fails-components/webtransport/issues"
+  },
+  "homepage": "https://github.com/fails-components/webtransport#readme",
+  "dependencies": {
+    "@types/debug": "^4.1.7",
+    "bindings": "^1.5.0",
+    "cmake-js": "^7.2.1",
+    "debug": "^4.3.4",
+    "node-addon-api": "^7.0.0",
+    "prebuild-install": "^7.1.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.17.10",
+    "@babel/eslint-parser": "^7.17.0",
+    "@babel/plugin-syntax-import-attributes": "^7.23.3",
+    "@types/node": "^18.15.3",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^7.2.0",
+    "eslint-config-standard": "^16.0.2",
+    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.4.1",
+    "eslint-plugin-promise": "^4.3.1",
+    "eslint-plugin-standard": "^4.1.0",
+    "prettier": "^2.4.1",
+    "typescript": "^4.8.4"
+  },
+  "binary": {
+    "napi_versions": [
+      6
+    ]
+  }
+}

package/platform/icufix/fakedata.cpp

@@ -0,0 +1,8 @@
+#include "unicode/putil.h"
+#include "unicode/udata.h"
+#include "unicode/uversion.h"
+#include "ucmndata.h"
+
+extern "C" const DataHeader U_DATA_API U_ICUDATA_ENTRY_POINT;
+
+const DataHeader  U_ICUDATA_ENTRY_POINT = { {0,0,0}, {0,0,0,0,0,0,0,0,0}};

package/platform/quiche/quic/core/io/socket_win.inc

@@ -0,0 +1,3 @@
+#include "absl/strings/ascii.h"
+#warning "Fake socketwin included"
+#include "third_party/quiche/quiche/quic/core/io/socket_win.inc"

package/platform/quiche_platform_impl/quiche_bug_tracker_impl.h

@@ -0,0 +1,7 @@
+// use default impl
+#ifndef QUICHE_BUG_TRACKER
+#define QUICHE_BUG_TRACKER
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_bug_tracker_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_client_stats_impl.h

@@ -0,0 +1,7 @@
+// use default impl
+#ifndef QUICHE_CLIENT_STATS_IMPL
+#define QUICHE_CLIENT_STATS_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_client_stats_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_command_line_flags_impl.h

@@ -0,0 +1,7 @@
+// use default impl
+#ifndef QUICHE_COMMAND_LINE_FLAGS_IMPL
+#define QUICHE_COMMAND_LINE_FLAGS_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_command_line_flags_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_containers_impl.h

@@ -0,0 +1,7 @@
+// use default impl
+#ifndef QUICHE_CONTAINER_IMPL
+#define QUICHE_CONTAINER_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_containers_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_event_loop_impl.h

@@ -0,0 +1,7 @@
+// use default impl
+#ifndef QUICHE_EVENT_LOOP_IMPL
+#define QUICHE_EVENT_LOOP_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_event_loop_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_export_impl.h

@@ -0,0 +1,6 @@
+#ifndef QUICHE_EXPORT_IMPL_HEADER
+#define QUICHE_EXPORT_IMPL_HEADER
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_export_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_flag_utils_impl.h

@@ -0,0 +1,11 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_UTILS_IMPL_H_
+#define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_UTILS_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flag_utils_impl.h"
+
+
+#endif  // NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_UTILS_IMPL_H_

package/platform/quiche_platform_impl/quiche_flags_impl.h

@@ -0,0 +1,8 @@
+// only for redirects
+
+#ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_IMPL_H_
+#define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAG_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_googleurl_impl.h

@@ -0,0 +1,8 @@
+// only for redirects
+
+#ifndef NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_GOOGLEURL_IMPL_H_
+#define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_GOOGLEURL_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_googleurl_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_iovec_impl.h

@@ -0,0 +1,10 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_QUICHE_PLATFORM_IMPL_QUIC_IOVEC_IMPL_H_
+#define NET_QUICHE_PLATFORM_IMPL_QUIC_IOVEC_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_iovec_impl.h"
+
+#endif  // NET_QUIC_PLATFORM_IMPL_QUIC_IOVEC_IMPL_H_

package/platform/quiche_platform_impl/quiche_logging_impl.h

@@ -0,0 +1,21 @@
+// modified for fails webtransport by Marten Richter
+
+//original Copyright by
+
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file does not actually implement logging, it merely provides enough of
+// logging code for QUICHE to compile.  QUICHE embedders are encouraged to
+// override this file with their own logic.  If at some point logging becomes a
+// part of Abseil, this file will likely start using that instead.
+
+
+
+#ifndef QUICHE_COMMON_PLATFORM_NODE_QUICHE_PLATFORM_IMPL_QUICHE_LOGGING_IMPL_H_
+#define QUICHE_COMMON_PLATFORM_NODE_QUICHE_PLATFORM_IMPL_QUICHE_LOGGING_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h"
+
+#endif  // QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_LOGGING_IMPL_H_

package/platform/quiche_platform_impl/quiche_mem_slice_impl.h

@@ -0,0 +1,2 @@
+// use the default
+#include "quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h"

package/platform/quiche_platform_impl/quiche_mutex_impl.h

@@ -0,0 +1,8 @@
+// from envoy so LICENSE.envoy applies
+// use default impl
+#ifndef QUICHE_MUTEX_IMPL
+#define QUICHE_MUTEX_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_prefetch_impl.h

@@ -0,0 +1,11 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_PREFETCH_IMPL_H_
+#define QUICHE_PREFETCH_IMPL_H_
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h"
+
+
+#endif  

package/platform/quiche_platform_impl/quiche_reference_counted_impl.h

@@ -0,0 +1,16 @@
+// from envoy so LICENSE.envoy applies
+#ifndef NET_QUIC_PLATFORM_IMPL_QUIC_REFERENCE_COUNTED_IMPL_H_
+#define NET_QUIC_PLATFORM_IMPL_QUIC_REFERENCE_COUNTED_IMPL_H_
+
+// NOLINT(namespace-envoy)
+
+// This file is part of the QUICHE platform implementation, and is not to be
+// consumed or referenced directly by other Envoy code. It serves purely as a
+// porting layer for QUICHE.
+
+
+
+#include "quiche/common/platform/default/quiche_platform_impl/quiche_reference_counted_impl.h"
+
+
+#endif  // NET_QUIC_PLATFORM_IMPL_QUIC_REFERENCE_COUNTED_IMPL_H_

package/platform/quiche_platform_impl/quiche_server_stats_impl.h

@@ -0,0 +1,7 @@
+// from envoy so LICENSE.envoy applies
+#ifndef QUICHE_SERVER_STATS_IMPL
+#define QUICHE_SERVER_STATS_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_server_stats_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_stack_trace_impl.h

@@ -0,0 +1,12 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_QUICHE_PLATFORM_IMPL_QUICHE_STACK_TRACE_IMPL_H_
+#define NET_QUICHE_PLATFORM_IMPL_QUICHE_STACK_TRACE_IMPL_H_
+
+#include <string>
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.h"
+
+#endif  // NET_QUIC_PLATFORM_IMPL_QUIC_STACK_TRACE_IMPL_H_

package/platform/quiche_platform_impl/quiche_stream_buffer_allocator_impl.h

@@ -0,0 +1,8 @@
+
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#ifndef NET_QUIC_PLATFORM_IMPL_QUIC_STREAM_BUFFER_ALLOCATOR_IMPL_H_
+#define NET_QUIC_PLATFORM_IMPL_QUIC_STREAM_BUFFER_ALLOCATOR_IMPL_H_
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_stream_buffer_allocator_impl.h"
+#endif  // NET_QUIC_PLATFORM_IMPL_QUIC_STREAM_BUFFER_ALLOCATOR_IMPL_H_

package/platform/quiche_platform_impl/quiche_testvalue_impl.h

@@ -0,0 +1 @@
+#include "quiche/common/platform/default/quiche_platform_impl/quiche_testvalue_impl.h"

package/platform/quiche_platform_impl/quiche_thread_local_impl.h

@@ -0,0 +1,6 @@
+#ifndef QUICHE_THREAD_LOCAL_IMPL
+#define QUICHE_THREAD_LOCAL_IMPL
+
+#include "quiche/common/platform/default/quiche_platform_impl/quiche_thread_local_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_time_utils_impl.h

@@ -0,0 +1,13 @@
+// from envoy so LICENSE.envoy applies
+// NOLINT(namespace-envoy)
+
+// This file is part of the QUICHE platform implementation, and is not to be
+// consumed or referenced directly by other Envoy code. It serves purely as a
+// porting layer for QUICHE.
+
+#ifndef QUICHE_TIME_UTILS_IMPL
+#define QUICHE_TIME_UTILS_IMPL
+
+#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_time_utils_impl.h"
+
+#endif

package/platform/quiche_platform_impl/quiche_udp_socket_platform_impl.h

@@ -0,0 +1,39 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_QUICHE_PLATFORM_IMPL_QUICHE_UDP_SOCKET_PLATFORM_IMPL_H_
+#define NET_QUICHE_PLATFORM_IMPL_QUICHE_UDP_SOCKET_PLATFORM_IMPL_H_
+
+#ifndef WIN32
+#include <sys/socket.h>
+#endif
+
+#include <cstddef>
+#include <cstdint>
+
+namespace quiche {
+
+const size_t kCmsgSpaceForGooglePacketHeaderImpl = 0;
+
+inline bool GetGooglePacketHeadersFromControlMessageImpl(
+    struct ::cmsghdr* cmsg,
+    char** packet_headers,
+    size_t* packet_headers_len) {
+  return false;
+}
+
+inline void SetGoogleSocketOptionsImpl(int fd) {}
+
+inline int GetEcnCmsgArgsPreserveDscpImpl(const int /*fd*/,
+                                          const int /*address_family*/,
+                                          uint8_t /*ecn_codepoint*/,
+                                          int& /*type*/, void* /*value*/,
+                                          socklen_t& /*value_len*/) {
+  // TODO(b/273081493): implement this.
+  return 0;
+}
+
+}  // namespace quic
+
+#endif  // NET_QUIC_PLATFORM_IMPL_QUIC_UDP_SOCKET_PLATFORM_IMPL_H_

package/readme.md

@@ -0,0 +1,20 @@
+!["FAILS logo"](failslogo.svg)
+# Fancy automated internet lecture system (**FAILS**) - components (Webtransport module)
+
+Linux tests on master ![master](https://github.com/fails-components/webtransport/actions/workflows/libtest-linux.yml/badge.svg?branch=master)
+
+Windows tests on master ![master](https://github.com/fails-components/webtransport/actions/workflows/libtest-windows.yml/badge.svg?branch=master)
+
+Macos tests on master ![master](https://github.com/fails-components/webtransport/actions/workflows/libtest-macos.yml/badge.svg?branch=master)
+
+(c) 2022- Marten Richter
+
+The package provides the http/3 libquiche transports or the main package.
+
+This package is part of FAILS.
+A web-based lecture system developed out of university lectures.
+
+While FAILS as a whole is licensed via GNU Affero GPL version 3.0, this package is licensed under a BSD-style license that can be found in the LICENSE file, while code taken from other projects is still under their respective license (see LICENSE file for details).
+This package is licensed more permissive since it can be useful outside of the FAILS environment.
+
+This package only provides the C++ binding to libquiche for http/3 support, please see the `@fails-components/webtransport` package for complete information in [readme.md](../../main/readme.md). Note you can not and should not use this package without the main package. The version of this package must match the version number of the main package. This package ABI or API is not stable and should only be used by the node.js package and not in another package.