stream info: add interface name of the local side of the upstream connection

envoy/network/socket.h

@@ -85,6 +85,12 @@ class ConnectionInfoProvider {
    **/
   virtual absl::optional<uint64_t> connectionID() const PURE;
 
+  /**
+   * @return the name of the network interface used by local end of the connection, or unset if not
+   *available.
+   **/
+  virtual absl::optional<absl::string_view> interfaceName() const PURE;
+
   /**
    * Dumps the state of the ConnectionInfoProvider to the given ostream.
    *
@@ -143,6 +149,12 @@ class ConnectionInfoSetter : public ConnectionInfoProvider {
    **/
   virtual void setConnectionID(uint64_t id) PURE;
 
+  /**
+   * @param interface_name the name of the network interface used by the local end of the
+   *connection.
+   **/
+  virtual void setInterfaceName(absl::string_view interface_name) PURE;
+
   /**
    * @param connection_info sets the downstream ssl connection.
    */

envoy/stream_info/stream_info.h

@@ -346,6 +346,17 @@ class UpstreamInfo {
    */
   virtual absl::optional<uint64_t> upstreamConnectionId() const PURE;
 
+  /**
+   * @param interface name of the upstream connection's local socket.
+   */
+  virtual void setUpstreamInterfaceName(absl::string_view interface_name) PURE;
+
+  /**
+   * @return interface name of the upstream connection's local socket, or absl::nullopt if not
+   * available.
+   */
+  virtual absl::optional<absl::string_view> upstreamInterfaceName() const PURE;
+
   /**
    * @param connection_info sets the upstream ssl connection.
    */

source/common/http/filter_manager.h

@@ -628,6 +628,9 @@ class OverridableRemoteConnectionInfoSetterStreamInfo : public StreamInfo::Strea
   absl::optional<uint64_t> connectionID() const override {
     return StreamInfoImpl::downstreamAddressProvider().connectionID();
   }
+  absl::optional<absl::string_view> interfaceName() const override {
+    return StreamInfoImpl::downstreamAddressProvider().interfaceName();
+  }
   Ssl::ConnectionInfoConstSharedPtr sslConnection() const override {
     return StreamInfoImpl::downstreamAddressProvider().sslConnection();
   }

source/common/network/connection_impl.cc

@@ -923,6 +923,16 @@ void ClientConnectionImpl::connect() {
 
 void ClientConnectionImpl::onConnected() {
   stream_info_.upstreamInfo()->upstreamTiming().onUpstreamConnectComplete(dispatcher_.timeSource());
+  // There are no meaningful socket source address semantics for non-IP sockets, so skip.
+  if (socket_->connectionInfoProviderSharedPtr()->remoteAddress()->ip()) {
+    // interfaceName makes a syscall. Call once to minimize perf hit.
+    const auto maybe_interface_name = ioHandle().interfaceName();
+    if (maybe_interface_name.has_value()) {
+      ENVOY_CONN_LOG_EVENT(debug, "conn_interface", "connected on local interface '{}'", *this,
+                           maybe_interface_name.value());
+      socket_->connectionInfoProvider().setInterfaceName(maybe_interface_name.value());
+    }
+  }
   ConnectionImpl::onConnected();
 }
 

source/common/network/socket_impl.h

@@ -52,6 +52,10 @@ class ConnectionInfoSetterImpl : public ConnectionInfoSetter {
   }
   absl::optional<uint64_t> connectionID() const override { return connection_id_; }
   void setConnectionID(uint64_t id) override { connection_id_ = id; }
+  absl::optional<absl::string_view> interfaceName() const override { return interface_name_; }
+  void setInterfaceName(absl::string_view interface_name) override {
+    interface_name_ = std::string(interface_name);
+  }
   Ssl::ConnectionInfoConstSharedPtr sslConnection() const override { return ssl_info_; }
   void setSslConnection(const Ssl::ConnectionInfoConstSharedPtr& ssl_connection_info) override {
     ASSERT(!ssl_info_);
@@ -67,6 +71,7 @@ class ConnectionInfoSetterImpl : public ConnectionInfoSetter {
   Address::InstanceConstSharedPtr direct_remote_address_;
   std::string server_name_;
   absl::optional<uint64_t> connection_id_;
+  absl::optional<std::string> interface_name_;
   Ssl::ConnectionInfoConstSharedPtr ssl_info_;
   std::string ja3_hash_;
 };

source/common/router/upstream_request.cc

@@ -447,6 +447,11 @@ void UpstreamRequest::onPoolReady(
     upstream_info.setUpstreamConnectionId(info.downstreamAddressProvider().connectionID().value());
   }
 
+  if (info.downstreamAddressProvider().interfaceName().has_value()) {
+    upstream_info.setUpstreamInterfaceName(
+        info.downstreamAddressProvider().interfaceName().value());
+  }
+
   stream_info_.setUpstreamBytesMeter(upstream_->bytesMeter());
   StreamInfo::StreamInfo::syncUpstreamAndDownstreamBytesMeter(parent_.callbacks()->streamInfo(),
                                                               stream_info_);

source/common/stream_info/stream_info_impl.h

@@ -28,6 +28,14 @@ struct UpstreamInfoImpl : public UpstreamInfo {
 
   absl::optional<uint64_t> upstreamConnectionId() const override { return upstream_connection_id_; }
 
+  void setUpstreamInterfaceName(absl::string_view interface_name) override {
+    upstream_connection_interface_name_ = std::string(interface_name);
+  }
+
+  absl::optional<absl::string_view> upstreamInterfaceName() const override {
+    return upstream_connection_interface_name_;
+  }
+
   void
   setUpstreamSslConnection(const Ssl::ConnectionInfoConstSharedPtr& ssl_connection_info) override {
     upstream_ssl_info_ = ssl_connection_info;
@@ -76,6 +84,7 @@ struct UpstreamInfoImpl : public UpstreamInfo {
   UpstreamTiming upstream_timing_;
   Ssl::ConnectionInfoConstSharedPtr upstream_ssl_info_;
   absl::optional<uint64_t> upstream_connection_id_;
+  absl::optional<std::string> upstream_connection_interface_name_;
   std::string upstream_transport_failure_reason_;
   FilterStateSharedPtr upstream_filter_state_;
   size_t num_streams_{};

test/common/router/router_test.cc

@@ -5078,6 +5078,7 @@ TEST_F(RouterTest, UpstreamSSLConnection) {
   EXPECT_EQ(session_id,
             callbacks_.streamInfo().upstreamInfo()->upstreamSslConnection()->sessionId());
   EXPECT_FALSE(callbacks_.streamInfo().upstreamInfo()->upstreamConnectionId().has_value());
+  EXPECT_FALSE(callbacks_.streamInfo().upstreamInfo()->upstreamInterfaceName().has_value());
 }
 
 // Verify that upstream timing information is set into the StreamInfo after the upstream

test/common/stream_info/stream_info_impl_test.cc

@@ -207,6 +207,11 @@ TEST_F(StreamInfoImplTest, MiscSettersAndGetters) {
     ASSERT_TRUE(stream_info.upstreamInfo()->upstreamConnectionId().has_value());
     EXPECT_EQ(12345, stream_info.upstreamInfo()->upstreamConnectionId().value());
 
+    EXPECT_FALSE(stream_info.upstreamInfo()->upstreamInterfaceName().has_value());
+    stream_info.upstreamInfo()->setUpstreamInterfaceName("lo");
+    ASSERT_TRUE(stream_info.upstreamInfo()->upstreamInterfaceName().has_value());
+    EXPECT_EQ("lo", stream_info.upstreamInfo()->upstreamInterfaceName().value());
+
     std::shared_ptr<UpstreamInfo> new_info = std::make_shared<UpstreamInfoImpl>();
     EXPECT_NE(stream_info.upstreamInfo(), new_info);
     stream_info.setUpstreamInfo(new_info);

test/extensions/filters/listener/proxy_protocol/proxy_protocol_test.cc

@@ -361,6 +361,15 @@ TEST_P(ProxyProtocolTest, ErrorRecv_2) {
           [this](os_fd_t sockfd, sockaddr* addr, socklen_t* addrlen) -> Api::SysCallSocketResult {
             return os_sys_calls_actual_.accept(sockfd, addr, addrlen);
           }));
+  EXPECT_CALL(os_sys_calls, supportsGetifaddrs())
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          Invoke([this]() -> bool { return os_sys_calls_actual_.supportsGetifaddrs(); }));
+  EXPECT_CALL(os_sys_calls, getifaddrs(_))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke([this](Api::InterfaceAddressVector& vector) -> Api::SysCallIntResult {
+        return os_sys_calls_actual_.getifaddrs(vector);
+      }));
   connect(false);
   write(buffer, sizeof(buffer));
 
@@ -422,6 +431,15 @@ TEST_P(ProxyProtocolTest, ErrorRecv_1) {
           [this](os_fd_t sockfd, sockaddr* addr, socklen_t* addrlen) -> Api::SysCallSocketResult {
             return os_sys_calls_actual_.accept(sockfd, addr, addrlen);
           }));
+  EXPECT_CALL(os_sys_calls, supportsGetifaddrs())
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          Invoke([this]() -> bool { return os_sys_calls_actual_.supportsGetifaddrs(); }));
+  EXPECT_CALL(os_sys_calls, getifaddrs(_))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke([this](Api::InterfaceAddressVector& vector) -> Api::SysCallIntResult {
+        return os_sys_calls_actual_.getifaddrs(vector);
+      }));
   connect(false);
   write(buffer, sizeof(buffer));
 
@@ -658,6 +676,15 @@ TEST_P(ProxyProtocolTest, V2ParseExtensionsRecvError) {
           [this](os_fd_t sockfd, sockaddr* addr, socklen_t* addrlen) -> Api::SysCallSocketResult {
             return os_sys_calls_actual_.accept(sockfd, addr, addrlen);
           }));
+  EXPECT_CALL(os_sys_calls, supportsGetifaddrs())
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          Invoke([this]() -> bool { return os_sys_calls_actual_.supportsGetifaddrs(); }));
+  EXPECT_CALL(os_sys_calls, getifaddrs(_))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke([this](Api::InterfaceAddressVector& vector) -> Api::SysCallIntResult {
+        return os_sys_calls_actual_.getifaddrs(vector);
+      }));
   connect(false);
   write(buffer, sizeof(buffer));
   dispatcher_->run(Event::Dispatcher::RunType::NonBlock);
@@ -835,6 +862,15 @@ TEST_P(ProxyProtocolTest, V2Fragmented4Error) {
           [this](os_fd_t sockfd, sockaddr* addr, socklen_t* addrlen) -> Api::SysCallSocketResult {
             return os_sys_calls_actual_.accept(sockfd, addr, addrlen);
           }));
+  EXPECT_CALL(os_sys_calls, supportsGetifaddrs())
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          Invoke([this]() -> bool { return os_sys_calls_actual_.supportsGetifaddrs(); }));
+  EXPECT_CALL(os_sys_calls, getifaddrs(_))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke([this](Api::InterfaceAddressVector& vector) -> Api::SysCallIntResult {
+        return os_sys_calls_actual_.getifaddrs(vector);
+      }));
   connect(false);
   write(buffer, 17);
 
@@ -902,6 +938,15 @@ TEST_P(ProxyProtocolTest, V2Fragmented5Error) {
           [this](os_fd_t sockfd, sockaddr* addr, socklen_t* addrlen) -> Api::SysCallSocketResult {
             return os_sys_calls_actual_.accept(sockfd, addr, addrlen);
           }));
+  EXPECT_CALL(os_sys_calls, supportsGetifaddrs())
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          Invoke([this]() -> bool { return os_sys_calls_actual_.supportsGetifaddrs(); }));
+  EXPECT_CALL(os_sys_calls, getifaddrs(_))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke([this](Api::InterfaceAddressVector& vector) -> Api::SysCallIntResult {
+        return os_sys_calls_actual_.getifaddrs(vector);
+      }));
   connect(false);
   write(buffer, 10);
   dispatcher_->run(Event::Dispatcher::RunType::NonBlock);