How to get access to the raw file descriptor?

[KJTsanaktsidis]

Basically, I'm writing a gRPC protocol that will be used over a unix socket, and I want to use Linux's new SO_PEERPIDFD sockopt (https://lore.kernel.org/all/[email protected]/) to get a pidfd for the peer being communicated with.

I think there are two things which need to be glued together to make that happen, but I can't quite figure out how to make it fit:

• From the unix example - I think I need to write a "something" to wrap the stream passed into serve_with_incoming to call getsockopt(SO_PEERPIDFD) on the unix sockets before passing them to tonic, and then
• From the tower example, I can write a Tower middleware to extract the pidfd from the "somewhere" and put it in req.extensions()
• From there it can be accessed inside the service handler through req.extensions()

Does anybody have any guidance to offer on what this "something" and "somewhere" are? Or am I going about this entirely the wrong way?

[KJTsanaktsidis]

Oh, I bet I need to wrap the UnixListenerStream in something with a custom implementation of the Connected trait:

tonic/tonic/src/transport/server/conn.rs

Lines 11 to 58 in fc940ce

	/// Trait that connected IO resources implement and use to produce info about the connection.
	///
	/// The goal for this trait is to allow users to implement
	/// custom IO types that can still provide the same connection
	/// metadata.
	///
	/// # Example
	///
	/// The `ConnectInfo` returned will be accessible through [request extensions][ext]:
	///
	/// ```
	/// use tonic::{Request, transport::server::Connected};
	///
	/// // A `Stream` that yields connections
	/// struct MyConnector {}
	///
	/// // Return metadata about the connection as `MyConnectInfo`
	/// impl Connected for MyConnector {
	/// type ConnectInfo = MyConnectInfo;
	///
	/// fn connect_info(&self) -> Self::ConnectInfo {
	/// MyConnectInfo {}
	/// }
	/// }
	///
	/// #[derive(Clone)]
	/// struct MyConnectInfo {
	/// // Metadata about your connection
	/// }
	///
	/// // The connect info can be accessed through request extensions:
	/// # fn foo(request: Request<()>) {
	/// let connect_info: &MyConnectInfo = request
	/// .extensions()
	/// .get::<MyConnectInfo>()
	/// .expect("bug in tonic");
	/// # }
	/// ```
	///
	/// [ext]: crate::Request::extensions
	pub trait Connected {
	/// The connection info type the IO resources generates.
	// all these bounds are necessary to set this as a request extension
	type ConnectInfo: Clone + Send + Sync + 'static;
	/// Create type holding information about the connection.
	fn connect_info(&self) -> Self::ConnectInfo;
	}