@fails-components/webtransport 0.1.0-macarmbuild.5 → 0.1.0

package/src/http3server.cc

@@ -400,5 +400,116 @@ namespace quic
       };
       obj->eventloop_->Schedule(task);
     }
+    else
+      return Napi::Error::New(Env(), "No path set for addPath").ThrowAsJavaScriptException();
+  }
+
+  void Http3ServerJS::finishSessionRequest(const Napi::CallbackInfo &info)
+  {
+    Http3Server *obj = getObj();
+
+    if (!info[0].IsUndefined())
+    {
+      // needs two properties
+      int status = -1;
+      std::string path = "";
+      Napi::Object lobj = info[0].ToObject();
+      if (!lobj.IsEmpty())
+      {
+        if (lobj.Has("status") && !(lobj).Get("status").IsEmpty())
+        {
+          Napi::Value statusValue = (lobj).Get("status");
+          status = statusValue.As<Napi::Number>().Int32Value();
+        }
+        else
+          return Napi::Error::New(Env(), "No status code passed for finishSessionRequest").ThrowAsJavaScriptException();
+
+        if (lobj.Has("path") && !(lobj).Get("path").IsEmpty())
+        {
+          Napi::Value pathValue = (lobj).Get("path");
+          path = pathValue.ToString().Utf8Value();
+        }
+        else
+          return Napi::Error::New(Env(), "No status code passed for finishSessionRequest").ThrowAsJavaScriptException();
+        WebTransportSession *session = nullptr;
+        if (lobj.Has("session") && !(lobj).Get("session").IsEmpty())
+        {
+          Napi::Value sessionVal = (lobj).Get("session");
+          if (!sessionVal.IsExternal())
+            return Napi::Error::New(Env(), "Session is not external for finishSessionRequest").ThrowAsJavaScriptException();
+          Napi::External<WebTransportSession> sessionExt = sessionVal.As<Napi::External<WebTransportSession>>();
+          session = sessionExt.Data();
+        }
+        else
+          return Napi::Error::New(Env(), "No session passed for finishSessionRequest").ThrowAsJavaScriptException();
+
+        if (lobj.Has("promise") && !(lobj).Get("promise").IsEmpty())
+        {
+          Napi::Value promiseVal = (lobj).Get("promise");
+          if (!promiseVal.IsExternal())
+            return Napi::Error::New(Env(), "Promise is not external for finishSessionRequest").ThrowAsJavaScriptException();
+          Napi::External<Http3ServerBackend::WebTransportRespPromisePtr> promise = promiseVal.As<Napi::External<Http3ServerBackend::WebTransportRespPromisePtr>>();
+
+          Http3ServerBackend::WebTransportRespPromisePtr *prom = promise.Data();
+          Napi::Reference<Napi::Value> *headerValue = nullptr;
+          if (status == 200)
+          {
+
+            if (lobj.Has("header") && !(lobj).Get("header").IsEmpty())
+            {
+              napi_ref ref;
+              napi_status status = napi_create_reference(Env(), lobj.Get("header"), 1, &ref);
+              NAPI_THROW_IF_FAILED(Env(), status, Reference<Napi::Value>());
+              headerValue = new Napi::Reference<Napi::Value>(Env(), ref);
+            }
+            else
+              return Napi::Error::New(Env(), "No status code passed for finishSessionRequest").ThrowAsJavaScriptException();
+          }
+          std::function<void()> task = [status, prom, path, headerValue, session, obj, this]()
+          {
+            if (status != 200)
+            {
+              std::unique_ptr<Http3ServerBackend::WebTransportResponse> response = std::make_unique<Http3ServerBackend::WebTransportResponse>();
+              response->response_headers[":status"] = std::to_string(status);
+              (*prom)->resolve(std::move(response));
+            }
+            else
+            {
+              std::unique_ptr<Http3ServerBackend::WebTransportResponse> response = std::make_unique<Http3ServerBackend::WebTransportResponse>();
+              response->response_headers[":status"] = std::to_string(status);
+              Http3WTSession *wtsession = new Http3WTSession();
+              wtsession->init(session, obj->eventloop_);
+              response->visitor =
+                  std::make_unique<Http3WTSession::Visitor>(wtsession);
+              obj->eventloop_->informAboutNewSession(obj, static_cast<Http3WTSession *>(wtsession), path, headerValue);
+              (*prom)->resolve(std::move(response));
+            }
+          };
+          obj->eventloop_->Schedule(task);
+        }
+        else
+          return Napi::Error::New(Env(), "No promise passed for finishSessionRequest").ThrowAsJavaScriptException();
+      }
+      else
+        return Napi::Error::New(Env(), "No object passed for finishSessionRequest").ThrowAsJavaScriptException();
+    }
+  }
+
+  void Http3ServerJS::setJSRequestHandler(const Napi::CallbackInfo &info)
+  {
+    Http3Server *obj = getObj();
+
+    if (!info[0].IsUndefined())
+    {
+
+      bool hashandler = info[0].ToBoolean();
+      std::function<void()> task = [obj, hashandler]()
+      {
+        obj->http3_server_backend_.setJSHandler(hashandler);
+      };
+      obj->eventloop_->Schedule(task);
+    }
+    else
+      return Napi::Error::New(Env(), "No bool set for setJSRequestHandler").ThrowAsJavaScriptException();
   }
 }

package/src/http3server.h

@@ -50,6 +50,9 @@ namespace quic
 
         void addPath(const Napi::CallbackInfo &info);
 
+        void finishSessionRequest(const Napi::CallbackInfo &info);
+
+        void setJSRequestHandler(const Napi::CallbackInfo &info);
 
         static void InitExports(Napi::Env env, Napi::Object exports)
         {
@@ -59,7 +62,11 @@ namespace quic
                                                  InstanceMethod<&Http3ServerJS::stopServer>("stopServer",
                                                                                             static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                  InstanceMethod<&Http3ServerJS::addPath>("addPath",
-                                                                                         static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
+                                                                                         static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                 InstanceMethod<&Http3ServerJS::finishSessionRequest>("finishSessionRequest",
+                                                                                                      static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                 InstanceMethod<&Http3ServerJS::setJSRequestHandler>("setJSRequestHandler",
+                                                                                                     static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
             exports.Set("Http3WebTransportServer", tplsrv);
         }
 
@@ -95,11 +102,12 @@ namespace quic
 
         Http3ServerJS *getJS() { return js_; };
 
-        ServerStatusDetails *getStatusDetails() {
-             ServerStatusDetails* details = new ServerStatusDetails();
-             details->host = host_;
-             details->port = port_;
-             return details;
+        ServerStatusDetails *getStatusDetails()
+        {
+            ServerStatusDetails *details = new ServerStatusDetails();
+            details->host = host_;
+            details->port = port_;
+            return details;
         }
 
     private:

package/src/http3serverbackend.cc

@@ -26,7 +26,6 @@
 #include "quiche/common/platform/api/quiche_file_utils.h"
 #include "quiche/common/quiche_text_utils.h"
 
-
 using spdy::Http2HeaderBlock;
 
 namespace quic
@@ -45,42 +44,56 @@ namespace quic
   }
   */
 
-  Http3ServerBackend::WebTransportResponse
+  Http3ServerBackend::WebTransportRespPromisePtr
   Http3ServerBackend::ProcessWebTransportRequest(
       const spdy::Http2HeaderBlock &request_headers,
       WebTransportSession *session)
   {
+    WebTransportRespPromisePtr promise = std::make_shared<WebTransportRespPromise>();
     if (!SupportsWebTransport())
     {
-      WebTransportResponse response;
-      response.response_headers[":status"] = "400";
-      return response;
+      std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
+      response->response_headers[":status"] = "400";
+      promise->resolve(std::move(response));
+      return promise;
     }
 
     auto path_it = request_headers.find(":path");
     if (path_it == request_headers.end())
     {
-      WebTransportResponse response;
-      response.response_headers[":status"] = "400";
-      return response;
+      std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
+      response->response_headers[":status"] = "400";
+      promise->resolve(std::move(response));
+      return promise;
     }
     std::string path(path_it->second);
 
     if (paths_.find(path) != paths_.end())
     { // to do handle our web transport paths
-      WebTransportResponse response;
-      Http3WTSession * wtsession = new Http3WTSession();
+      std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
+      Http3WTSession *wtsession = new Http3WTSession();
       wtsession->init(session, eventloop_);
-      response.response_headers[":status"] = "200";
-      response.visitor =
-          std::make_unique<Http3WTSession::Visitor>(wtsession); 
-      eventloop_->informAboutNewSession(server_, static_cast<Http3WTSession *>(wtsession), path);
-      return response;
+      response->response_headers[":status"] = "200";
+      response->visitor =
+          std::make_unique<Http3WTSession::Visitor>(wtsession);
+      eventloop_->informAboutNewSession(server_, static_cast<Http3WTSession *>(wtsession), path, nullptr);
+      promise->resolve(std::move(response));
+      return promise;
+    }
+    else if (jshandlerequesthandler_)
+    {
+      // first step pass header block along, due to thread safety, we need to copy
+      spdy::Http2HeaderBlock *reqheadcopy = new Http2HeaderBlock(request_headers.Clone());
+
+      // second step inform the js side
+      eventloop_->informAboutNewSessionRequest(server_, session, reqheadcopy, promise);
+      return promise;
     }
 
-    WebTransportResponse response;
-    response.response_headers[":status"] = "404";
-    return response;
+    std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
+    response->response_headers[":status"] = "404";
+    promise->resolve(std::move(response));
+    return promise;
   }
 
   Http3ServerBackend::~Http3ServerBackend()

package/src/http3serverbackend.h

@@ -23,6 +23,36 @@ namespace quic
   class Http3Server;
   class Http3EventLoop;
 
+  template <typename T>
+  class JSlikePromise
+  {
+  public:
+    void finally(std::function<void(T *)> func)
+    {
+      T *res = result.get();
+      if (res != nullptr)
+        func(res);
+      else
+        finallys.push_back(func);
+    }
+
+    void resolve(std::unique_ptr<T> res)
+    {
+      if (result.get() != nullptr)
+        return; // throw std::runtime_error("Promise already settled");
+      result = std::move(res);
+      for (auto finally : finallys)
+      {
+        finally(result.get());
+      }
+      finallys.clear();
+    }
+
+  protected:
+    std::unique_ptr<T> result;
+    std::list<std::function<void(T *)>> finallys;
+  };
+
   // This interface implements the functionality to fetch a response
   // from the backend (such as cache, http-proxy etc) to serve
   // requests received by a Quic Server
@@ -36,14 +66,18 @@ namespace quic
       std::unique_ptr<WebTransportVisitor> visitor;
     };
 
+    using WebTransportRespPromise = JSlikePromise<WebTransportResponse>;
+    using WebTransportRespPromisePtr = std::shared_ptr<WebTransportRespPromise>;
+
     Http3ServerBackend(Http3EventLoop *eventloop) : eventloop_(eventloop),
-     server_(nullptr) {}
+                                                    server_(nullptr), jshandlerequesthandler_(false) {}
 
     ~Http3ServerBackend();
 
     void setServer(Http3Server *server) { server_ = server; }
+    void setJSHandler(bool on) { jshandlerequesthandler_ = on; }
 
-    WebTransportResponse ProcessWebTransportRequest(
+    WebTransportRespPromisePtr ProcessWebTransportRequest(
         const spdy::Http2HeaderBlock & /*request_headers*/,
         WebTransportSession * /*session*/);
     bool SupportsWebTransport() { return true; }
@@ -53,8 +87,9 @@ namespace quic
     void addPath(std::string path) { paths_.insert(path); }
 
   protected:
-    Http3Server *server_; // unowned
+    Http3Server *server_;       // unowned
     Http3EventLoop *eventloop_; // unowned
+    bool jshandlerequesthandler_;
     std::set<std::string> paths_;
   };
 

package/src/http3serverstream.cc

@@ -59,6 +59,13 @@ namespace quic
   Http3ServerStream::~Http3ServerStream()
   {
     // http3_server_backend_->CloseBackendResponseStream(this);
+    for (auto prom : pending_proms_)
+    {
+      std::unique_ptr<Http3ServerBackend::WebTransportResponse> response =
+          std::make_unique<Http3ServerBackend::WebTransportResponse>();
+      response->response_headers[":status"] = "500"; // internal server error, probably implementation on js side
+      prom->resolve(std::move(response));
+    }
   }
 
   void Http3ServerStream::OnInitialHeadersComplete(
@@ -211,22 +218,28 @@ namespace quic
 
     if (web_transport() != nullptr)
     {
-      Http3ServerBackend::WebTransportResponse response =
+      // to do synchronize lifetime of object, so maybe store promises
+      Http3ServerBackend::WebTransportRespPromisePtr response =
           http3_server_backend_->ProcessWebTransportRequest(
               request_headers_, web_transport());
-      if (response.response_headers[":status"] == "200")
+      pending_proms_.insert(response);
+      response->finally([this, response](Http3ServerBackend::WebTransportResponse *resp)
+                        { 
+      pending_proms_.erase(response);
+      if (resp->response_headers[":status"] == "200")
       {
-        WriteHeaders(std::move(response.response_headers), false, nullptr);
-        if (response.visitor != nullptr)
+        WriteHeaders(std::move(resp->response_headers), false, nullptr);
+        if (resp->visitor != nullptr)
         {
-          web_transport()->SetVisitor(std::move(response.visitor));
+          web_transport()->SetVisitor(std::move(resp->visitor));
         }
         web_transport()->HeadersReceived(request_headers_);
       }
       else
       {
-        WriteHeaders(std::move(response.response_headers), true, nullptr);
+        WriteHeaders(std::move(resp->response_headers), true, nullptr);
       }
+      return; });
       return;
     }
 

package/src/http3serverstream.h

@@ -103,6 +103,8 @@ namespace quic
     spdy::Http2HeaderBlock request_headers_;
     int64_t content_length_;
     std::string body_;
+    // promises not fullfilled from js side or c++ side
+    std::set<Http3ServerBackend::WebTransportRespPromisePtr> pending_proms_;
 
   private:
     uint64_t generate_bytes_length_;

package/src/http3wtstreamvisitor.cc

@@ -69,7 +69,10 @@ namespace quic
     void Http3WTStream::doCanRead()
     {
         if (pause_reading_)
+        {
+            can_read_pending_ = true;
             return; // back pressure folks!
+        }
         // first figure out if we have readable data
         size_t readable = stream_->ReadableBytes();
         // ok create a string obj to hold the data

package/src/http3wtstreamvisitor.h

@@ -93,8 +93,9 @@ namespace quic
         void tryRead()
         {
             pause_reading_ = false;
-            if (stream_ && stream_->ReadableBytes() > 0)
+            if (stream_ && ((stream_->ReadableBytes() > 0) || can_read_pending_))
             {
+                can_read_pending_ = false;
                 doCanRead();
             }
         }
@@ -209,6 +210,7 @@ namespace quic
         bool fin_was_sent_ = false;
         bool stop_sending_received_ = false;
         bool pause_reading_ = false;
+        bool can_read_pending_ = false;
         std::deque<WChunks> chunks_;
     };
 

package/test/bidirectional-streams.spec.js

@@ -1,8 +1,9 @@
-/* eslint-disable no-undef */
+/* eslint-env mocha */
+
 import { createServer } from './fixtures/server.js'
 import { getReaderValue } from './fixtures/reader-value.js'
 import { WebTransport } from '../lib/index.js'
-import { expect } from 'chai'
+import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
 import { defer } from '../lib/utils.js'

package/test/datagrams.spec.js

@@ -1,8 +1,9 @@
-/* eslint-disable no-undef */
+/* eslint-env mocha */
+
 import { createServer } from './fixtures/server.js'
 import { getReaderValue } from './fixtures/reader-value.js'
 import { WebTransport } from '../lib/index.js'
-import { expect } from 'chai'
+import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
 import { defer } from '../lib/utils.js'

package/test/{event-loop.specoff.js → event-loop.spec.js}

@@ -1,8 +1,9 @@
-/* eslint-disable no-undef */
-import { expect } from 'chai'
+/* eslint-env mocha */
+
+import { expect } from './fixtures/chai.js'
 import { Http3EventLoop } from '../lib/event-loop.js'
 
-describe('event-loop', () => {
+describe.skip('event-loop', () => {
   beforeEach(() => {
     if (Http3EventLoop.globalLoop != null) {
       // shut down loop, otherwise we have to wait for
@@ -12,12 +13,12 @@ describe('event-loop', () => {
   })
 
   it('should start and stop the event loop', () => {
-    expect(Http3EventLoop.globalLoop).to.be.null
+    expect(Http3EventLoop.globalLoop).to.be.null()
 
     Http3EventLoop.createGlobalEventLoop()
-    expect(Http3EventLoop.globalLoop).to.not.be.null
+    expect(Http3EventLoop.globalLoop).to.not.be.null()
 
     Http3EventLoop.globalLoop?.shutdownEventLoop()
-    expect(Http3EventLoop.globalLoop).to.be.null
+    expect(Http3EventLoop.globalLoop).to.be.null()
   })
 })

package/test/fixtures/certificate.js

@@ -55,8 +55,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
 // @ts-expect-error node-forge has no types and @types/node-forge do not include oids
 import forge from 'node-forge'
-import { webcrypto as crypto } from 'crypto'
-import { X509Certificate } from 'crypto'
+import { webcrypto as crypto, X509Certificate } from 'crypto'
 
 const { pki, asn1, oids } = forge
 // taken from node-forge
@@ -111,8 +110,8 @@ function _dnToAsn1(obj) {
   return rval
 }
 
-const jan_1_1950 = new Date('1950-01-01T00:00:00Z')
-const jan_1_2050 = new Date('2050-01-01T00:00:00Z')
+const jan_1_1950 = new Date('1950-01-01T00:00:00Z') // eslint-disable-line camelcase
+const jan_1_2050 = new Date('2050-01-01T00:00:00Z') // eslint-disable-line camelcase
 // taken from node-forge almost not modified
 /**
  * Converts a Date object to ASN.1
@@ -123,6 +122,7 @@ const jan_1_2050 = new Date('2050-01-01T00:00:00Z')
  * @return the ASN.1 object representing the date.
  */
 function _dateToAsn1(date) {
+  // eslint-disable-next-line camelcase
   if (date >= jan_1_1950 && date < jan_1_2050) {
     return asn1.create(
       asn1.Class.UNIVERSAL,
@@ -149,10 +149,10 @@ function _dateToAsn1(date) {
  * @return ASN.1 object representing signature parameters
  */
 function _signatureParametersToAsn1(oid, params) {
+  const parts = []
+
   switch (oid) {
     case oids['RSASSA-PSS']:
-      const parts = []
-
       if (params.hash.algorithmOid !== undefined) {
         parts.push(
           asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
@@ -348,7 +348,7 @@ function toPositiveHex(hexString) {
  */
 export async function generateWebTransportCertificate(attrs, options) {
   try {
-    let keyPair = await crypto.subtle.generateKey(
+    const keyPair = await crypto.subtle.generateKey(
       {
         name: 'ECDSA',
         namedCurve: 'P-256'
@@ -371,7 +371,7 @@ export async function generateWebTransportCertificate(attrs, options) {
     cert.setSubject(attrs)
     cert.setIssuer(attrs)
 
-    let privateKey = crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
+    const privateKey = crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
     const publicKey = (cert.publicKey = await crypto.subtle.exportKey(
       'spki',
       keyPair.publicKey
@@ -408,7 +408,7 @@ export async function generateWebTransportCertificate(attrs, options) {
     oids['1.2.840.10045.4.3.2'] = 'ecdsa-with-sha256'
     oids['ecdsa-with-sha256'] = '1.2.840.10045.4.3.2'
 
-    cert.siginfo.algorithmOid = cert.signatureOid = '1.2.840.10045.4.3.2' //'ecdsa-with-sha256'
+    cert.siginfo.algorithmOid = cert.signatureOid = '1.2.840.10045.4.3.2' // 'ecdsa-with-sha256'
 
     cert.tbsCertificate = getTBSCertificate(cert)
     const encoded = Buffer.from(

package/test/fixtures/chai.js

@@ -0,0 +1,6 @@
+import chai from 'chai'
+import dirtyChai from 'dirty-chai'
+
+chai.use(dirtyChai)
+
+export const expect = chai.expect

package/test/fixtures/reader-value.js

@@ -1,10 +1,9 @@
-
 /**
  * @template T
  * @param {ReadableStream<T>} readableStream
  * @returns {Promise<T>}
  */
-export async function getReaderValue (readableStream) {
+export async function getReaderValue(readableStream) {
   const reader = readableStream.getReader()
 
   try {

package/test/fixtures/write-stream.js

@@ -1,4 +1,3 @@
-
 /**
  * Write contents to a stream and close it
  *
@@ -7,7 +6,7 @@
  * @param {T[]} input
  * @returns
  */
- export async function writeStream (writable, input) {
+export async function writeStream(writable, input) {
   const writer = writable.getWriter()
 
   for (const buf of input) {

package/test/unidirectional-streams.spec.js

@@ -1,4 +1,5 @@
-/* eslint-disable no-undef */
+/* eslint-env mocha */
+
 import { createServer } from './fixtures/server.js'
 import { getReaderValue } from './fixtures/reader-value.js'
 import { WebTransport } from '../lib/index.js'
@@ -124,4 +125,56 @@ describe('unidirectional streams', function () {
       'Did not receive the same bytes we sent'
     )
   })
+
+  it('handles fin when paused due to backpressure', async function () {
+    this.timeout(10000)
+
+    /** @type {Deferred<ReadableStream>} */
+    const serverStream = defer()
+
+    Promise.resolve().then(async () => {
+      const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      const stream = await getReaderValue(session.incomingUnidirectionalStreams)
+
+      serverStream.resolve(stream)
+    })
+
+    client = new WebTransport(`${url}${SERVER_PATH}`, {
+      serverCertificateHashes: [
+        {
+          algorithm: 'sha-256',
+          value: certificate.hash
+        }
+      ]
+    })
+    await client.ready
+
+    const clientStream = await client.createUnidirectionalStream()
+
+    const input = [
+      Uint8Array.from([0, 1, 2, 3, 4]),
+      Uint8Array.from([5, 6, 7, 8, 9]),
+      Uint8Array.from([10, 11, 12, 13, 14]),
+      Uint8Array.from([15, 16, 17, 18, 19]),
+      Uint8Array.from([20, 21, 22, 23, 24])
+    ]
+
+    const writer = clientStream.getWriter()
+
+    for (const buf of input) {
+      await writer.write(buf)
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    await writer.close()
+
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+
+    const received = await readStream(await serverStream.promise)
+    expect(received).to.deep.equal(
+      input,
+      'Did not receive the same bytes we sent'
+    )
+  })
 })

package/test/suite.specoff.js

@@ -1,9 +0,0 @@
-import { Http3EventLoop } from '../lib/event-loop.js'
-
-after(async () => {
-  if (Http3EventLoop.globalLoop != null) {
-    // shut down loop, otherwise we have to wait for
-    // it to time out which takes a long time.
-    Http3EventLoop.globalLoop.shutdownEventLoop()
-  }
-})