Merge branch 'main' into fetch-pack

Conflicts:
	git-transport/src/client/blocking_io/http/mod.rs

Author: Byron

Makefile

@@ -115,6 +115,7 @@ check: ## Build all code in suitable configurations
 					 && cargo check --features blocking-client \
 					 && cargo check --features async-client \
 					 && cargo check --features async-client,async-std \
+					 && cargo check --features http-client \
 					 && cargo check --features http-client-curl
 	cd git-transport && if cargo check --all-features 2>/dev/null; then false; else true; fi
 	cd git-protocol && cargo check \

git-discover/tests/upwards/mod.rs

@@ -182,6 +182,10 @@ fn cross_fs() -> crate::Result {
     use std::{os::unix::fs::symlink, process::Command};
 
     use git_discover::upwards::Options;
+    if git_testtools::is_ci::cached() {
+        // Don't run on CI as it's too slow there, resource busy, it fails more often than it succeeds by now.
+        return Ok(());
+    }
 
     let top_level_repo = git_testtools::scripted_fixture_repo_writable("make_basic_repo.sh")?;
 

git-object/src/object/mod.rs

@@ -180,7 +180,14 @@ impl<'a> ObjectRef<'a> {
     /// Deserialize an object from a loose serialisation
     pub fn from_loose(data: &'a [u8]) -> Result<ObjectRef<'a>, LooseDecodeError> {
         let (kind, size, offset) = loose_header(data)?;
-        Ok(Self::from_bytes(kind, &data[offset..][..size])?)
+
+        let body = &data[offset..]
+            .get(..size)
+            .ok_or(LooseHeaderDecodeError::InvalidHeader {
+                message: "object data was shorter than its size declared in the header",
+            })?;
+
+        Ok(Self::from_bytes(kind, body)?)
     }
 
     /// Deserialize an object of `kind` from the given `data`.

git-object/tests/loose.rs

@@ -1,5 +1,5 @@
 use bstr::ByteSlice;
-use git_object::{decode, encode, Kind};
+use git_object::{decode, encode, Kind, ObjectRef};
 
 #[test]
 fn all() -> Result<(), Box<dyn std::error::Error>> {
@@ -18,3 +18,11 @@ fn all() -> Result<(), Box<dyn std::error::Error>> {
     }
     Ok(())
 }
+
+#[test]
+fn shorter_than_advertised() {
+    assert_eq!(
+        ObjectRef::from_loose(b"tree 1000\x00").unwrap_err().to_string(),
+        "object data was shorter than its size declared in the header"
+    );
+}

git-transport/Cargo.toml

@@ -20,8 +20,10 @@ default = []
 
 ## If set, blocking implementations of the typical git transports become available in `crate::client`
 blocking-client = ["git-packetline/blocking-io"]
-## Implies `blocking-client`, and adds support for the http and https transports using the Rust bindings for `libcurl`.
-http-client-curl = ["curl", "base64", "git-features/io-pipe", "blocking-client"]
+## Implies `blocking-client`, and adds support for the http and https transports.
+http-client = ["base64", "git-features/io-pipe", "blocking-client"]
+## Implies `http-client`, and adds support for the http and https transports using the Rust bindings for `libcurl`.
+http-client-curl = ["curl", "http-client"]
 ## If set, an async implementations of the git transports becomes available in `crate::client`.
 ## Suitable for implementing your own transports while using git's way of communication, typically in conjunction with a custom server.
 ## **Note** that the _blocking_ client has a wide range of available transports, with the _async_ version of it supporting only the TCP based `git` transport leaving you
@@ -62,11 +64,13 @@ futures-io = { version = "0.3.16", optional = true }
 futures-lite = { version  = "1.12.0", optional = true }
 pin-project-lite = { version = "0.2.6", optional = true }
 
+# for http-client
+base64 = { version = "0.13.0", optional = true }
+
 # for http-client-curl
 # zlib-ng-compat doesn't force zlib-ng
 curl = { version = "0.4", optional = true, features = ["static-curl", "static-ssl", "zlib-ng-compat"] }
 thiserror = "1.0.26"
-base64 = { version = "0.13.0", optional = true }
 
 ## If used in conjunction with `async-client`, the `connect()` method will be come available along with supporting the git protocol over TCP,
 ## where the TCP stream is created using this crate.

git-transport/src/client/blocking_io/http/mod.rs

@@ -35,31 +35,41 @@ pub struct Transport<H: Http> {
     identity: Option<git_sec::identity::Account>,
 }
 
-impl Transport<Impl> {
-    /// Create a new instance to communicate to `url` using the given `desired_version` of the `git` protocol.
-    pub fn new(url: &str, desired_version: Protocol) -> Self {
+impl<H: Http> Transport<H> {
+    /// Create a new instance with `http` as implementation to communicate to `url` using the given `desired_version` of the `git` protocol.
+    pub fn new_http(http: H, url: &str, desired_version: Protocol) -> Self {
         Transport {
             url: url.to_owned(),
             user_agent_header: concat!("User-Agent: git/oxide-", env!("CARGO_PKG_VERSION")),
             desired_version,
             actual_version: desired_version,
             supported_versions: [desired_version],
             service: None,
-            http: Impl::default(),
+            http,
             line_provider: None,
             identity: None,
         }
     }
 }
 
+#[cfg(feature = "http-client-curl")]
+impl Transport<Impl> {
+    /// Create a new instance to communicate to `url` using the given `desired_version` of the `git` protocol.
+    ///
+    /// Note that the actual implementation depends on feature toggles.
+    pub fn new(url: &str, desired_version: Protocol) -> Self {
+        Self::new_http(Impl::default(), url, desired_version)
+    }
+}
+
 impl<H: Http> Transport<H> {
     fn check_content_type(service: Service, kind: &str, headers: <H as Http>::Headers) -> Result<(), client::Error> {
-        let wanted_content_type = format!("Content-Type: application/x-{}-{}", service.as_str(), kind);
+        let wanted_content_type = format!("content-type: application/x-{}-{}", service.as_str(), kind);
         if !headers
             .lines()
             .collect::<Result<Vec<_>, _>>()?
             .iter()
-            .any(|l| l == &wanted_content_type)
+            .any(|l| l.to_lowercase() == wanted_content_type)
         {
             return Err(client::Error::Http(Error::Detail {
                 description: format!(
@@ -289,7 +299,14 @@ impl<H: Http, B: ExtendedBufRead + Unpin> ExtendedBufRead for HeadersThenBody<H,
     }
 }
 
+/// Connect to the given `url` via HTTP/S using the `desired_version` of the `git` protocol, with `http` as implementation.
+#[cfg(all(feature = "http-client", not(feature = "http-client-curl")))]
+pub fn connect_http<H: Http>(http: H, url: &str, desired_version: Protocol) -> Transport<H> {
+    Transport::new_http(http, url, desired_version)
+}
+
 /// Connect to the given `url` via HTTP/S using the `desired_version` of the `git` protocol.
+#[cfg(feature = "http-client-curl")]
 pub fn connect(url: &str, desired_version: Protocol) -> Transport<Impl> {
     Transport::new(url, desired_version)
 }

git-transport/src/client/blocking_io/mod.rs

@@ -4,7 +4,7 @@ pub mod connect;
 ///
 pub mod file;
 ///
-#[cfg(feature = "http-client-curl")]
+#[cfg(feature = "http-client")]
 pub mod http;
 
 mod bufread_ext;

git-transport/src/client/mod.rs

@@ -10,7 +10,7 @@ pub use traits::TransportWithoutIO;
 
 #[cfg(feature = "blocking-client")]
 mod blocking_io;
-#[cfg(all(feature = "blocking-client", feature = "http-client-curl"))]
+#[cfg(feature = "http-client")]
 pub use blocking_io::http;
 #[cfg(feature = "blocking-client")]
 pub use blocking_io::{

git-transport/src/client/non_io_types.rs

@@ -58,12 +58,12 @@ mod error {
     use bstr::BString;
 
     use crate::client::capabilities;
-    #[cfg(feature = "http-client-curl")]
+    #[cfg(feature = "http-client")]
     use crate::client::http;
 
-    #[cfg(feature = "http-client-curl")]
+    #[cfg(feature = "http-client")]
     type HttpError = http::Error;
-    #[cfg(not(feature = "http-client-curl"))]
+    #[cfg(not(feature = "http-client"))]
     type HttpError = std::convert::Infallible;
 
     /// The error used in most methods of the [`client`][crate::client] module

git-transport/tests/client/blocking_io/http/mod.rs

@@ -455,3 +455,15 @@ Git-Protocol: version=2
     );
     Ok(())
 }
+
+#[test]
+fn check_content_type_is_case_insensitive() -> crate::Result {
+    let (_server, mut client) = mock::serve_and_connect(
+        "v2/http-handshake-lowercase-headers.response",
+        "path/not/important/due/to/mock",
+        Protocol::V2,
+    )?;
+    let result = client.handshake(Service::UploadPack, &[]);
+    assert!(result.is_ok());
+    Ok(())
+}