feat!: HTTP transport uses url identity if username and password is set.

Note that this also changes `http::Transport::new(...)` to accept a `gix_url::Url`
instead of a string as it's typically the input and makes it easier to derive an
identity.

Author: Byron

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

@@ -23,7 +23,7 @@ pub(crate) mod function {
         Ok(match url.scheme {
             gix_url::Scheme::Ext(_) => return Err(Error::UnsupportedScheme(url.scheme)),
             gix_url::Scheme::File => {
-                if url.user().is_some() || url.host().is_some() || url.port.is_some() {
+                if url.user().is_some() || url.password().is_some() || url.host().is_some() || url.port.is_some() {
                     return Err(Error::UnsupportedUrlTokens {
                         url: url.to_bstring(),
                         scheme: url.scheme,
@@ -59,10 +59,9 @@ pub(crate) mod function {
             #[cfg(not(any(feature = "http-client-curl", feature = "http-client-reqwest")))]
             gix_url::Scheme::Https | gix_url::Scheme::Http => return Err(Error::CompiledWithoutHttp(url.scheme)),
             #[cfg(any(feature = "http-client-curl", feature = "http-client-reqwest"))]
-            gix_url::Scheme::Https | gix_url::Scheme::Http => Box::new(crate::client::http::connect(
-                &url.to_bstring().to_string(),
-                options.version,
-            )),
+            gix_url::Scheme::Https | gix_url::Scheme::Http => {
+                Box::new(crate::client::http::connect(url, options.version))
+            }
         })
     }
 }

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

@@ -217,26 +217,40 @@ pub struct Transport<H: Http> {
 impl<H: Http> Transport<H> {
     /// Create a new instance with `http` as implementation to communicate to `url` using the given `desired_version`.
     /// Note that we will always fallback to other versions as supported by the server.
-    pub fn new_http(http: H, url: &str, desired_version: Protocol) -> Self {
+    pub fn new_http(http: H, url: gix_url::Url, desired_version: Protocol) -> Self {
+        let identity = url
+            .user()
+            .zip(url.password())
+            .map(|(user, pass)| gix_sec::identity::Account {
+                username: user.to_string(),
+                password: pass.to_string(),
+            });
         Transport {
-            url: url.to_owned(),
+            url: url.to_bstring().to_string(),
             user_agent_header: concat!("User-Agent: git/oxide-", env!("CARGO_PKG_VERSION")),
             desired_version,
             actual_version: Default::default(),
             service: None,
             http,
             line_provider: None,
-            identity: None,
+            identity,
         }
     }
 }
 
+impl<H: Http> Transport<H> {
+    /// Returns the identity that the transport uses when connecting to the remote.
+    pub fn identity(&self) -> Option<&gix_sec::identity::Account> {
+        self.identity.as_ref()
+    }
+}
+
 #[cfg(any(feature = "http-client-curl", feature = "http-client-reqwest"))]
 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 {
+    pub fn new(url: gix_url::Url, desired_version: Protocol) -> Self {
         Self::new_http(Impl::default(), url, desired_version)
     }
 }
@@ -497,13 +511,13 @@ 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> {
+pub fn connect_http<H: Http>(http: H, url: gix_url::Url, 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(any(feature = "http-client-curl", feature = "http-client-reqwest"))]
-pub fn connect(url: &str, desired_version: Protocol) -> Transport<Impl> {
+pub fn connect(url: gix_url::Url, desired_version: Protocol) -> Transport<Impl> {
     Transport::new(url, desired_version)
 }
 

gix-transport/tests/client/blocking_io/http/mock.rs

@@ -99,13 +99,13 @@ pub fn serve_and_connect(
     version: Protocol,
 ) -> Result<(Server, http::Transport<http::Impl>), crate::Error> {
     let server = serve_once(name);
-    let url = format!(
+    let url_str = format!(
         "http://{}:{}/{}",
         &server.addr.ip().to_string(),
         &server.addr.port(),
         path
     );
-    let client = gix_transport::client::http::connect(&url, version);
-    assert_eq!(url, client.to_url().as_ref());
+    let client = gix_transport::client::http::connect(url_str.as_str().try_into()?, version);
+    assert_eq!(url_str, client.to_url().as_ref());
     Ok((server, client))
 }

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

@@ -46,6 +46,21 @@ fn http_status_500_is_communicated_via_special_io_error() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn http_identity_is_picked_up_from_url() -> crate::Result {
+    let transport =
+        gix_transport::client::http::connect("https://user:[email protected]/repo".try_into()?, Protocol::V2);
+    assert_eq!(transport.to_url().as_ref(), "https://user:[email protected]/repo");
+    assert_eq!(
+        transport.identity(),
+        Some(&gix_sec::identity::Account {
+            username: "user".into(),
+            password: "pass".into()
+        })
+    );
+    Ok(())
+}
+
 // based on a test in cargo
 #[test]
 fn http_will_use_pipelining() {
@@ -108,7 +123,8 @@ fn http_will_use_pipelining() {
     });
 
     let url = format!("http://{}:{}/reponame", &addr.ip().to_string(), &addr.port(),);
-    let mut client = gix_transport::client::http::connect(&url, gix_transport::Protocol::V2);
+    let mut client =
+        gix_transport::client::http::connect(url.try_into().expect("valid url"), gix_transport::Protocol::V2);
     match client.handshake(gix_transport::Service::UploadPack, &[]) {
         Ok(_) => unreachable!("expecting permission denied to be detected"),
         Err(gix_transport::client::Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied => {}