masque_server_session: factor out event handlers for connect-udp and connect-ip

PiperOrigin-RevId: 530565627
diff --git a/quiche/quic/masque/masque_server_session.cc b/quiche/quic/masque/masque_server_session.cc
index 5d51677..5a5f75b 100644
--- a/quiche/quic/masque/masque_server_session.cc
+++ b/quiche/quic/masque/masque_server_session.cc
@@ -333,97 +333,103 @@
     }
   });
 
-  do {  // CONNECT-UDP
-    auto it = absl::c_find_if(connect_udp_server_states_,
-                              [fd](const ConnectUdpServerState& connect_udp) {
-                                return connect_udp.fd() == fd;
-                              });
-    if (it == connect_udp_server_states_.end()) {
+  if (!(HandleConnectUdpSocketEvent(fd, events) ||
+        HandleConnectIpSocketEvent(fd, events))) {
+    QUIC_BUG(MasqueServerSession_OnSocketEvent_UnhandledEvent)
+        << "Got unexpected event mask " << events << " on unknown fd " << fd;
+    std::move(rearm).Cancel();
+  }
+}
+
+bool MasqueServerSession::HandleConnectUdpSocketEvent(
+    QuicUdpSocketFd fd, QuicSocketEventMask events) {
+  auto it = absl::c_find_if(connect_udp_server_states_,
+                            [fd](const ConnectUdpServerState& connect_udp) {
+                              return connect_udp.fd() == fd;
+                            });
+  if (it == connect_udp_server_states_.end()) {
+    return false;
+  }
+  QuicSocketAddress expected_target_server_address =
+      it->target_server_address();
+  QUICHE_DCHECK(expected_target_server_address.IsInitialized());
+  QUIC_DVLOG(1) << "Received readable event on fd " << fd << " (mask " << events
+                << ") stream ID " << it->stream()->id() << " server "
+                << expected_target_server_address;
+  QuicUdpSocketApi socket_api;
+  BitMask64 packet_info_interested(QuicUdpPacketInfoBit::PEER_ADDRESS);
+  char packet_buffer[1 + kMaxIncomingPacketSize];
+  packet_buffer[0] = 0;  // context ID.
+  char control_buffer[kDefaultUdpPacketControlBufferSize];
+  while (true) {
+    QuicUdpSocketApi::ReadPacketResult read_result;
+    read_result.packet_buffer = {packet_buffer + 1, sizeof(packet_buffer) - 1};
+    read_result.control_buffer = {control_buffer, sizeof(control_buffer)};
+    socket_api.ReadPacket(fd, packet_info_interested, &read_result);
+    if (!read_result.ok) {
+      // Most likely there is nothing left to read, break out of read loop.
       break;
     }
-    QuicSocketAddress expected_target_server_address =
-        it->target_server_address();
-    QUICHE_DCHECK(expected_target_server_address.IsInitialized());
-    QUIC_DVLOG(1) << "Received readable event on fd " << fd << " (mask "
-                  << events << ") stream ID " << it->stream()->id()
-                  << " server " << expected_target_server_address;
-    QuicUdpSocketApi socket_api;
-    BitMask64 packet_info_interested(QuicUdpPacketInfoBit::PEER_ADDRESS);
-    char packet_buffer[1 + kMaxIncomingPacketSize];
-    packet_buffer[0] = 0;  // context ID.
-    char control_buffer[kDefaultUdpPacketControlBufferSize];
-    while (true) {
-      QuicUdpSocketApi::ReadPacketResult read_result;
-      read_result.packet_buffer = {packet_buffer + 1,
-                                   sizeof(packet_buffer) - 1};
-      read_result.control_buffer = {control_buffer, sizeof(control_buffer)};
-      socket_api.ReadPacket(fd, packet_info_interested, &read_result);
-      if (!read_result.ok) {
-        // Most likely there is nothing left to read, break out of read loop.
-        break;
-      }
-      if (!read_result.packet_info.HasValue(
-              QuicUdpPacketInfoBit::PEER_ADDRESS)) {
-        QUIC_BUG(quic_bug_10974_2)
-            << "Missing peer address when reading from fd " << fd;
-        continue;
-      }
-      if (read_result.packet_info.peer_address() !=
-          expected_target_server_address) {
-        QUIC_DLOG(ERROR) << "Ignoring UDP packet on fd " << fd
-                         << " from unexpected server address "
-                         << read_result.packet_info.peer_address()
-                         << " (expected " << expected_target_server_address
-                         << ")";
-        continue;
-      }
-      if (!connection()->connected()) {
-        QUIC_BUG(quic_bug_10974_3)
-            << "Unexpected incoming UDP packet on fd " << fd << " from "
-            << expected_target_server_address
-            << " because MASQUE connection is closed";
-        return;
-      }
-      // The packet is valid, send it to the client in a DATAGRAM frame.
-      MessageStatus message_status =
-          it->stream()->SendHttp3Datagram(absl::string_view(
-              packet_buffer, read_result.packet_buffer.buffer_len + 1));
-      QUIC_DVLOG(1) << "Sent UDP packet from " << expected_target_server_address
-                    << " of length " << read_result.packet_buffer.buffer_len
-                    << " with stream ID " << it->stream()->id()
-                    << " and got message status "
-                    << MessageStatusToString(message_status);
+    if (!read_result.packet_info.HasValue(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
+      QUIC_BUG(MasqueServerSession_HandleConnectUdpSocketEvent_MissingPeer)
+          << "Missing peer address when reading from fd " << fd;
+      continue;
     }
-  } while (false);
-
-  do {  // CONNECT-IP
-    auto it = absl::c_find_if(connect_ip_server_states_,
-                              [fd](const ConnectIpServerState& connect_ip) {
-                                return connect_ip.fd() == fd;
-                              });
-    if (it == connect_ip_server_states_.end()) {
+    if (read_result.packet_info.peer_address() !=
+        expected_target_server_address) {
+      QUIC_DLOG(ERROR) << "Ignoring UDP packet on fd " << fd
+                       << " from unexpected server address "
+                       << read_result.packet_info.peer_address()
+                       << " (expected " << expected_target_server_address
+                       << ")";
+      continue;
+    }
+    if (!connection()->connected()) {
+      QUIC_BUG(MasqueServerSession_HandleConnectUdpSocketEvent_ConnectionClosed)
+          << "Unexpected incoming UDP packet on fd " << fd << " from "
+          << expected_target_server_address
+          << " because MASQUE connection is closed";
       break;
     }
-    char datagram[1501];
-    datagram[0] = 0;  // Context ID.
-    while (true) {
-      ssize_t read_size = read(fd, datagram + 1, sizeof(datagram) - 1);
-      if (read_size < 0) {
-        break;
-      }
-      MessageStatus message_status = it->stream()->SendHttp3Datagram(
-          absl::string_view(datagram, 1 + read_size));
-      QUIC_DVLOG(1) << "Encapsulated IP packet of length " << read_size
-                    << " with stream ID " << it->stream()->id()
-                    << " and got message status "
-                    << MessageStatusToString(message_status);
-    }
-    return;
-  } while (false);
+    // The packet is valid, send it to the client in a DATAGRAM frame.
+    MessageStatus message_status =
+        it->stream()->SendHttp3Datagram(absl::string_view(
+            packet_buffer, read_result.packet_buffer.buffer_len + 1));
+    QUIC_DVLOG(1) << "Sent UDP packet from " << expected_target_server_address
+                  << " of length " << read_result.packet_buffer.buffer_len
+                  << " with stream ID " << it->stream()->id()
+                  << " and got message status "
+                  << MessageStatusToString(message_status);
+  }
+  return true;
+}
 
-  QUIC_BUG(quic_bug_10974_1)
-      << "Got unexpected event mask " << events << " on unknown fd " << fd;
-  std::move(rearm).Cancel();
+bool MasqueServerSession::HandleConnectIpSocketEvent(
+    QuicUdpSocketFd fd, QuicSocketEventMask events) {
+  auto it = absl::c_find_if(connect_ip_server_states_,
+                            [fd](const ConnectIpServerState& connect_ip) {
+                              return connect_ip.fd() == fd;
+                            });
+  if (it == connect_ip_server_states_.end()) {
+    return false;
+  }
+  QUIC_DVLOG(1) << "Received readable event on fd " << fd << " (mask " << events
+                << ") stream ID " << it->stream()->id();
+  char datagram[1501];
+  datagram[0] = 0;  // Context ID.
+  while (true) {
+    ssize_t read_size = read(fd, datagram + 1, sizeof(datagram) - 1);
+    if (read_size < 0) {
+      break;
+    }
+    MessageStatus message_status = it->stream()->SendHttp3Datagram(
+        absl::string_view(datagram, 1 + read_size));
+    QUIC_DVLOG(1) << "Encapsulated IP packet of length " << read_size
+                  << " with stream ID " << it->stream()->id()
+                  << " and got message status "
+                  << MessageStatusToString(message_status);
+  }
+  return true;
 }
 
 bool MasqueServerSession::OnSettingsFrame(const SettingsFrame& frame) {
diff --git a/quiche/quic/masque/masque_server_session.h b/quiche/quic/masque/masque_server_session.h
index 2dbed18..4b5ad94 100644
--- a/quiche/quic/masque/masque_server_session.h
+++ b/quiche/quic/masque/masque_server_session.h
@@ -55,6 +55,11 @@
   QuicEventLoop* event_loop() const { return event_loop_; }
 
  private:
+  bool HandleConnectUdpSocketEvent(QuicUdpSocketFd fd,
+                                   QuicSocketEventMask events);
+  bool HandleConnectIpSocketEvent(QuicUdpSocketFd fd,
+                                  QuicSocketEventMask events);
+
   // State that the MasqueServerSession keeps for each CONNECT-UDP request.
   class QUIC_NO_EXPORT ConnectUdpServerState
       : public QuicSpdyStream::Http3DatagramVisitor {