fix!: parse 'handshake' of file:// based protocol version 0.

This special protocol kicks in when `git` serves `file://` directly
and no version number is specified. Then it doesn't advertise capabilities
at all, but shows 0000 right away.
Make sure we can parse it, and show it by adding `Version::V0` as well.

Author: Byron

gix-transport/src/client/async_io/bufread_ext.rs

@@ -125,7 +125,7 @@ impl<'a, T: AsyncRead + Unpin> ExtendedBufRead for gix_packetline::read::WithSid
     }
     fn reset(&mut self, version: Protocol) {
         match version {
-            Protocol::V1 => self.reset_with(&[gix_packetline::PacketLineRef::Flush]),
+            Protocol::V0 | Protocol::V1 => self.reset_with(&[gix_packetline::PacketLineRef::Flush]),
             Protocol::V2 => self.reset_with(&[
                 gix_packetline::PacketLineRef::Delimiter,
                 gix_packetline::PacketLineRef::Flush,

gix-transport/src/client/blocking_io/bufread_ext.rs

@@ -113,7 +113,7 @@ impl<'a, T: io::Read> ExtendedBufRead for gix_packetline::read::WithSidebands<'a
     }
     fn reset(&mut self, version: Protocol) {
         match version {
-            Protocol::V1 => self.reset_with(&[gix_packetline::PacketLineRef::Flush]),
+            Protocol::V0 | Protocol::V1 => self.reset_with(&[gix_packetline::PacketLineRef::Flush]),
             Protocol::V2 => self.reset_with(&[
                 gix_packetline::PacketLineRef::Delimiter,
                 gix_packetline::PacketLineRef::Flush,

gix-transport/src/client/capabilities.rs

@@ -23,13 +23,29 @@ pub enum Error {
 }
 
 /// A structure to represent multiple [capabilities][Capability] or features supported by the server.
-#[derive(Debug, Clone, Default)]
+///
+/// ### Deviation
+///
+/// As a *shortcoming*, we are unable to parse `V1` as emitted from `git-upload-pack` without a `git-daemon` or server,
+/// as it will not emit any capabilities for some reason. Only `V2` and `V0` work in that context.
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Capabilities {
     data: BString,
     value_sep: u8,
 }
 
+/// This implementation yields exactly those minimal capabilities that are required for `gix` to work, nothing more and nothing less.
+///
+/// This is a bit of a hack just get tests with Protocol V0 to work, which is a good way to enforce stateful transports.
+/// Of course, V1 would also do that but when calling `git-upload-pack` directly, it advertises so badly that this is easier to implement.
+impl Default for Capabilities {
+    fn default() -> Self {
+        Capabilities::from_lines("version 2\nmulti_ack_detailed\nside-band-64k\n".into())
+            .expect("valid format, known at compile time")
+    }
+}
+
 /// The name of a single capability.
 pub struct Capability<'a>(&'a BStr);
 
@@ -185,44 +201,50 @@ pub mod recv {
             // format looks like, thus there is no binary blob that could ever look like an ERR line by accident.
             rd.fail_on_err_lines(true);
 
-            let line = rd
-                .peek_line()
-                .ok_or(client::Error::ExpectedLine("capabilities or version"))???;
-            let line = line.as_text().ok_or(client::Error::ExpectedLine("text"))?;
-
-            let version = Capabilities::extract_protocol(line)?;
-            match version {
-                Protocol::V1 => {
-                    let (capabilities, delimiter_position) = Capabilities::from_bytes(line.0)?;
-                    rd.peek_buffer_replace_and_truncate(delimiter_position, b'\n');
-                    Ok(Outcome {
-                        capabilities,
-                        refs: Some(Box::new(rd.as_read())),
-                        protocol: Protocol::V1,
-                    })
-                }
-                Protocol::V2 => Ok(Outcome {
-                    capabilities: {
-                        let mut rd = rd.as_read();
-                        let mut buf = Vec::new();
-                        while let Some(line) = rd.read_data_line() {
-                            let line = line??;
-                            match line.as_bstr() {
-                                Some(line) => {
-                                    buf.push_str(line);
-                                    if buf.last() != Some(&b'\n') {
-                                        buf.push(b'\n');
-                                    }
-                                }
-                                None => break,
+            Ok(match rd.peek_line() {
+                Some(line) => {
+                    let line = line??.as_text().ok_or(client::Error::ExpectedLine("text"))?;
+                    let version = Capabilities::extract_protocol(line)?;
+                    match version {
+                        Protocol::V0 => unreachable!("already handled in `None` case"),
+                        Protocol::V1 => {
+                            let (capabilities, delimiter_position) = Capabilities::from_bytes(line.0)?;
+                            rd.peek_buffer_replace_and_truncate(delimiter_position, b'\n');
+                            Outcome {
+                                capabilities,
+                                refs: Some(Box::new(rd.as_read())),
+                                protocol: Protocol::V1,
                             }
                         }
-                        Capabilities::from_lines(buf.into())?
-                    },
-                    refs: None,
-                    protocol: Protocol::V2,
-                }),
-            }
+                        Protocol::V2 => Outcome {
+                            capabilities: {
+                                let mut rd = rd.as_read();
+                                let mut buf = Vec::new();
+                                while let Some(line) = rd.read_data_line() {
+                                    let line = line??;
+                                    match line.as_bstr() {
+                                        Some(line) => {
+                                            buf.push_str(line);
+                                            if buf.last() != Some(&b'\n') {
+                                                buf.push(b'\n');
+                                            }
+                                        }
+                                        None => break,
+                                    }
+                                }
+                                Capabilities::from_lines(buf.into())?
+                            },
+                            refs: None,
+                            protocol: Protocol::V2,
+                        },
+                    }
+                }
+                None => Outcome {
+                    capabilities: Capabilities::default(),
+                    refs: Some(Box::new(rd.as_read())),
+                    protocol: Protocol::V0,
+                },
+            })
         }
     }
 }
@@ -263,45 +285,50 @@ pub mod recv {
             // format looks like, thus there is no binary blob that could ever look like an ERR line by accident.
             rd.fail_on_err_lines(true);
 
-            let line = rd
-                .peek_line()
-                .await
-                .ok_or(client::Error::ExpectedLine("capabilities or version"))???;
-            let line = line.as_text().ok_or(client::Error::ExpectedLine("text"))?;
-
-            let version = Capabilities::extract_protocol(line)?;
-            match version {
-                Protocol::V1 => {
-                    let (capabilities, delimiter_position) = Capabilities::from_bytes(line.0)?;
-                    rd.peek_buffer_replace_and_truncate(delimiter_position, b'\n');
-                    Ok(Outcome {
-                        capabilities,
-                        refs: Some(Box::new(rd.as_read())),
-                        protocol: Protocol::V1,
-                    })
-                }
-                Protocol::V2 => Ok(Outcome {
-                    capabilities: {
-                        let mut rd = rd.as_read();
-                        let mut buf = Vec::new();
-                        while let Some(line) = rd.read_data_line().await {
-                            let line = line??;
-                            match line.as_bstr() {
-                                Some(line) => {
-                                    buf.push_str(line);
-                                    if buf.last() != Some(&b'\n') {
-                                        buf.push(b'\n');
-                                    }
-                                }
-                                None => break,
+            Ok(match rd.peek_line().await {
+                Some(line) => {
+                    let line = line??.as_text().ok_or(client::Error::ExpectedLine("text"))?;
+                    let version = Capabilities::extract_protocol(line)?;
+                    match version {
+                        Protocol::V0 => unreachable!("already handled in `None` case"),
+                        Protocol::V1 => {
+                            let (capabilities, delimiter_position) = Capabilities::from_bytes(line.0)?;
+                            rd.peek_buffer_replace_and_truncate(delimiter_position, b'\n');
+                            Outcome {
+                                capabilities,
+                                refs: Some(Box::new(rd.as_read())),
+                                protocol: Protocol::V1,
                             }
                         }
-                        Capabilities::from_lines(buf.into())?
-                    },
-                    refs: None,
-                    protocol: Protocol::V2,
-                }),
-            }
+                        Protocol::V2 => Outcome {
+                            capabilities: {
+                                let mut rd = rd.as_read();
+                                let mut buf = Vec::new();
+                                while let Some(line) = rd.read_data_line().await {
+                                    let line = line??;
+                                    match line.as_bstr() {
+                                        Some(line) => {
+                                            buf.push_str(line);
+                                            if buf.last() != Some(&b'\n') {
+                                                buf.push(b'\n');
+                                            }
+                                        }
+                                        None => break,
+                                    }
+                                }
+                                Capabilities::from_lines(buf.into())?
+                            },
+                            refs: None,
+                            protocol: Protocol::V2,
+                        },
+                    }
+                }
+                None => Outcome {
+                    capabilities: Capabilities::default(),
+                    refs: Some(Box::new(rd.as_read())),
+                    protocol: Protocol::V0,
+                },
+            })
         }
     }
 }

gix-transport/src/lib.rs

@@ -23,6 +23,8 @@ pub use gix_packetline as packetline;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[allow(missing_docs)]
 pub enum Protocol {
+    /// Version 0 is like V1, but doesn't show capabilities at all, at least when hosted without `git-daemon`.
+    V0 = 0,
     /// Version 1 was the first one conceived, is stateful, and our implementation was seen to cause deadlocks. Prefer V2
     V1 = 1,
     /// A command-based and stateless protocol with clear semantics, and the one to use assuming the server isn't very old.

gix-transport/tests/client/capabilities.rs

@@ -49,3 +49,18 @@ fn from_bytes() -> crate::Result {
     );
     Ok(())
 }
+
+#[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
+async fn from_lines_with_version_detection_v0() -> crate::Result {
+    let mut buf = Vec::<u8>::new();
+    gix_packetline::encode::flush_to_write(&mut buf).await?;
+    let mut stream =
+        gix_packetline::StreamingPeekableIter::new(buf.as_slice(), &[gix_packetline::PacketLineRef::Flush]);
+    let caps = Capabilities::from_lines_with_version_detection(&mut stream)
+        .await
+        .expect("we can parse V0 as very special case, useful for testing stateful connections in other crates")
+        .capabilities;
+    assert!(caps.contains("multi_ack_detailed"));
+    assert!(caps.contains("side-band-64k"));
+    Ok(())
+}

gix-transport/tests/client/mod.rs

@@ -1,5 +1,4 @@
 #[cfg(feature = "blocking-client")]
 mod blocking_io;
-#[cfg(not(feature = "http-client-curl"))]
 mod capabilities;
 mod git;