Store authority/path on MoQSession

Summary:
Add `authority_` and `path_` string fields to `MoQSession` with public
get/set accessors.  Three code paths populate them:

- **WebTransport (server)**: `MoQServer::Handler::onHeadersComplete` sets
  them from the HTTP `Host` header and request path immediately after
  creating the session.
- **Native QUIC (server)**: `MoQSession::onClientSetup` sets them (if not
  already set) from the `AUTHORITY` and `PATH` parameters in the incoming
  `CLIENT_SETUP` message.
- **Client side**: `MoQClientBase::completeSetupMoQSession` sets them from
  `url_` before calling `setup()`.

A `getFirstStringParam` helper is added to `MoQTypes.h`, parallel to the
existing `getFirstIntParam` template, to extract string setup parameters
by key.

Reviewed By: sharmafb

Differential Revision: D95593897

fbshipit-source-id: 6fc8436f26fac3856e3675ff5a773f0ae422ff64

Author: afrind

moxygen/MoQClientBase.cpp

@@ -89,6 +89,9 @@ folly::coro::Task<ServerSetup> MoQClientBase::completeSetupMoQSession(
   moqSession_ =
       createSession(folly::MaybeManagedPtr<proxygen::WebTransport>(wt));
 
+  moqSession_->setPath(url_.getPath());
+  moqSession_->setAuthority(url_.getHostAndPortOmitDefault());
+
   // Configure session based on negotiated ALPN
   // If there is no ALPN negotiation, the negotiation will be done in the
   // Setup messages.

moxygen/MoQServer.cpp

@@ -294,6 +294,9 @@ void MoQServer::Handler::onHeadersComplete(
   clientSession_ = server_.createSession(
       folly::MaybeManagedPtr<proxygen::WebTransport>(wt),
       server_.getOrCreateExecutor(evb));
+  clientSession_->setAuthority(
+      std::string(req->getHeaders().getSingleOrEmpty(HTTP_HEADER_HOST)));
+  clientSession_->setPath(std::string(req->getPathAsStringPiece()));
   if (server_.mLoggerFactory_) {
     auto logger = server_.createLogger();
     // Set QUIC connection IDs and addresses on the logger from the underlying

moxygen/MoQSession.cpp

@@ -2341,6 +2341,18 @@ folly::coro::Task<ServerSetup> MoQSession::setup(ClientSetup setup) {
 
   auto maxRequestID = getMaxRequestIDIfPresent(setup.params);
 
+  // Set authority/path from CLIENT_SETUP params if present
+  auto setupAuthority = getFirstStringParam(
+      setup.params, folly::to_underlying(SetupKey::AUTHORITY));
+  if (!setupAuthority.empty()) {
+    authority_ = std::move(setupAuthority);
+  }
+  auto setupPath =
+      getFirstStringParam(setup.params, folly::to_underlying(SetupKey::PATH));
+  if (!setupPath.empty()) {
+    path_ = std::move(setupPath);
+  }
+
   if (shouldIncludeMoqtImplementationParam(setup.supportedVersions)) {
     setup.params.insertParam(SetupParameter(
         {folly::to_underlying(SetupKey::MOQT_IMPLEMENTATION),
@@ -2463,6 +2475,30 @@ void MoQSession::onClientSetup(ClientSetup clientSetup) {
       std::min(kMaxSendTokenCacheSize, peerAuthCacheSize),
       /*evict=*/true);
 
+  auto clientAuthority = getFirstStringParam(
+      clientSetup.params, folly::to_underlying(SetupKey::AUTHORITY));
+  if (!clientAuthority.empty()) {
+    if (!authority_.empty()) {
+      XLOG(ERR) << "AUTHORITY in CLIENT_SETUP conflicts with pre-set authority"
+                << " sess=" << this;
+      close(SessionCloseErrorCode::PROTOCOL_VIOLATION);
+      return;
+    }
+    authority_ = std::move(clientAuthority);
+  }
+
+  auto clientPath = getFirstStringParam(
+      clientSetup.params, folly::to_underlying(SetupKey::PATH));
+  if (!clientPath.empty()) {
+    if (!path_.empty()) {
+      XLOG(ERR) << "PATH in CLIENT_SETUP conflicts with pre-set path"
+                << " sess=" << this;
+      close(SessionCloseErrorCode::PROTOCOL_VIOLATION);
+      return;
+    }
+    path_ = std::move(clientPath);
+  }
+
   auto serverSetup =
       serverSetupCallback_->onClientSetup(clientSetup, shared_from_this());
   if (!serverSetup.hasValue()) {

moxygen/MoQSession.h

@@ -148,6 +148,19 @@ class MoQSession : public Subscriber,
     return closed_;
   }
 
+  void setAuthority(std::string a) {
+    authority_ = std::move(a);
+  }
+  void setPath(std::string p) {
+    path_ = std::move(p);
+  }
+  const std::string& getAuthority() const {
+    return authority_;
+  }
+  const std::string& getPath() const {
+    return path_;
+  }
+
   explicit MoQSession(
       folly::MaybeManagedPtr<proxygen::WebTransport> wt,
       std::shared_ptr<MoQExecutor> exec);
@@ -912,5 +925,7 @@ class MoQSession : public Subscriber,
   mutable quic::TransportInfo cachedTransportInfo_;
   mutable std::chrono::steady_clock::time_point lastTransportInfoUpdate_{};
   bool closed_{false};
+  std::string authority_;
+  std::string path_;
 };
 } // namespace moxygen

moxygen/MoQTypes.h

@@ -573,6 +573,18 @@ std::optional<uint64_t> getFirstIntParam(
   return std::nullopt;
 }
 
+// Helper function to extract a string parameter by key from a parameter list
+inline std::string getFirstStringParam(
+    const SetupParameters& params,
+    uint64_t key) {
+  for (const auto& param : params) {
+    if (param.key == key) {
+      return param.asString;
+    }
+  }
+  return {};
+}
+
 struct ClientSetup {
   std::vector<uint64_t> supportedVersions;
   SetupParameters params{FrameType::CLIENT_SETUP};

moxygen/test/MoQSessionTests.cpp

@@ -186,11 +186,45 @@ TEST(MoQSessionTest, ServerSetupVersion15WithoutAlpnShouldFail) {
     serverSession->close(SessionCloseErrorCode::NO_ERROR);
   }
 }
-CO_TEST_P_X(MoQSessionTest, Goaway) {
+// === AUTHORITY / PATH tests ===
+
+using MoQAuthorityPathTest = MoQSessionTest;
+INSTANTIATE_TEST_SUITE_P(
+    MoQAuthorityPathTest,
+    MoQAuthorityPathTest,
+    testing::ValuesIn(getSupportedVersionParams()));
+
+// After a normal setup the server session's path should be populated from the
+// PATH parameter in CLIENT_SETUP, and authority should remain empty (no
+// AUTHORITY param is sent in the test ClientSetup).
+CO_TEST_P_X(MoQAuthorityPathTest, ServerSessionPathFromClientSetup) {
   co_await setupMoQSession();
+  EXPECT_EQ(serverSession_->getPath(), "/foo");
+  EXPECT_EQ(serverSession_->getAuthority(), "");
+  clientSession_->close(SessionCloseErrorCode::NO_ERROR);
+}
+
+// If authority/path are already set on the server session before CLIENT_SETUP
+// arrives (e.g. populated from HTTP Host/request-path in the WT case), a
+// CLIENT_SETUP that also carries PATH is a protocol violation and must close
+// the session.
+CO_TEST_P_X(MoQAuthorityPathTest, PathInClientSetupConflictsWithPreSetPath) {
+  serverSession_->setPath("/pre-set-path");
 
-  // Make a SUBSCRIBE request so that we don't immediately close when goaway()
-  // is called.
+  clientSession_->setPublishHandler(clientPublisher);
+  clientSession_->setSubscribeHandler(clientSubscriber);
+  clientSession_->start();
+  serverSession_->setPublishHandler(serverPublisher);
+  serverSession_->setSubscribeHandler(serverSubscriber);
+  serverSession_->start();
+
+  auto result = co_await folly::coro::co_awaitTry(
+      clientSession_->setup(getClientSetup(initialMaxRequestID_)));
+  EXPECT_TRUE(result.hasException() || serverWt_->isSessionClosed());
+}
+
+CO_TEST_P_X(MoQSessionTest, Goaway) {
+  co_await setupMoQSession();
   expectSubscribe([](auto sub, auto pub) -> TaskSubscribeResult {
     auto pubResult = pub->beginSubgroup(0, 0, 0);
     EXPECT_FALSE(pubResult.hasError());