mirror of
https://github.com/neondatabase/neon.git
synced 2026-05-16 20:50:37 +00:00
e61ec94fbc
Our rust-postgres fork is getting messy. Mostly because proxy wants more
control over the raw protocol than tokio-postgres provides. As such,
it's diverging more and more. Storage and compute also make use of
rust-postgres, but in more normal usage, thus they don't need our crazy
changes.
Idea:
* proxy maintains their subset
* other teams use a minimal patch set against upstream rust-postgres
Reviewing this code will be difficult. To implement it, I
1. Copied tokio-postgres, postgres-protocol and postgres-types from
00940fcdb5
2. Updated their package names with the `2` suffix to make them compile
in the workspace.
3. Updated proxy to use those packages
4. Copied in the code from tokio-postgres-rustls 0.13 (with some patches
applied https://github.com/jbg/tokio-postgres-rustls/pull/32
https://github.com/jbg/tokio-postgres-rustls/pull/33)
5. Removed as much dead code as I could find in the vendored libraries
6. Updated the tokio-postgres-rustls code to use our existing channel
binding implementation
78 lines
2.1 KiB
Rust
78 lines
2.1 KiB
Rust
//! MaybeTlsStream.
|
|
//!
|
|
//! Represents a stream that may or may not be encrypted with TLS.
|
|
use crate::tls::{ChannelBinding, TlsStream};
|
|
use std::io;
|
|
use std::pin::Pin;
|
|
use std::task::{Context, Poll};
|
|
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
|
|
|
|
/// A stream that may or may not be encrypted with TLS.
|
|
pub enum MaybeTlsStream<S, T> {
|
|
/// An unencrypted stream.
|
|
Raw(S),
|
|
/// An encrypted stream.
|
|
Tls(T),
|
|
}
|
|
|
|
impl<S, T> AsyncRead for MaybeTlsStream<S, T>
|
|
where
|
|
S: AsyncRead + Unpin,
|
|
T: AsyncRead + Unpin,
|
|
{
|
|
fn poll_read(
|
|
mut self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
buf: &mut ReadBuf<'_>,
|
|
) -> Poll<io::Result<()>> {
|
|
match &mut *self {
|
|
MaybeTlsStream::Raw(s) => Pin::new(s).poll_read(cx, buf),
|
|
MaybeTlsStream::Tls(s) => Pin::new(s).poll_read(cx, buf),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<S, T> AsyncWrite for MaybeTlsStream<S, T>
|
|
where
|
|
S: AsyncWrite + Unpin,
|
|
T: AsyncWrite + Unpin,
|
|
{
|
|
fn poll_write(
|
|
mut self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
buf: &[u8],
|
|
) -> Poll<io::Result<usize>> {
|
|
match &mut *self {
|
|
MaybeTlsStream::Raw(s) => Pin::new(s).poll_write(cx, buf),
|
|
MaybeTlsStream::Tls(s) => Pin::new(s).poll_write(cx, buf),
|
|
}
|
|
}
|
|
|
|
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
|
|
match &mut *self {
|
|
MaybeTlsStream::Raw(s) => Pin::new(s).poll_flush(cx),
|
|
MaybeTlsStream::Tls(s) => Pin::new(s).poll_flush(cx),
|
|
}
|
|
}
|
|
|
|
fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
|
|
match &mut *self {
|
|
MaybeTlsStream::Raw(s) => Pin::new(s).poll_shutdown(cx),
|
|
MaybeTlsStream::Tls(s) => Pin::new(s).poll_shutdown(cx),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<S, T> TlsStream for MaybeTlsStream<S, T>
|
|
where
|
|
S: AsyncRead + AsyncWrite + Unpin,
|
|
T: TlsStream + Unpin,
|
|
{
|
|
fn channel_binding(&self) -> ChannelBinding {
|
|
match self {
|
|
MaybeTlsStream::Raw(_) => ChannelBinding::none(),
|
|
MaybeTlsStream::Tls(s) => s.channel_binding(),
|
|
}
|
|
}
|
|
}
|