feat: barebones initial server-side upload-pack implementation

Cargo.toml

@@ -268,6 +268,7 @@ members = [
     "gix-transport",
     "gix-credentials",
     "gix-protocol",
+    "gix-serve",
     "gix-pack",
     "gix-odb",
     "gix-tempfile",

gix-protocol/Cargo.toml

@@ -53,6 +53,17 @@ fetch = [
     "dep:gix-trace",
 ]
 
+#! ### _Server_
+#! The _server_ portion uses `gix-transport` to communicate with a client.
+
+## If set, blocking server-side protocol implementations are available.
+blocking-server = [
+    "gix-transport/blocking-server",
+    "serve",
+]
+## Add implementations for serving (upload-pack).
+serve = []
+
 #! ### Other
 ## Enable support for the SHA-1 hash by enabling the respective feature in the `gix-hash` crate.
 sha1 = ["gix-hash/sha1"]
@@ -69,6 +80,11 @@ name = "async"
 path = "tests/async-protocol.rs"
 required-features = ["async-client"]
 
+[[test]]
+name = "blocking-server"
+path = "tests/blocking-server.rs"
+required-features = ["blocking-server"]
+
 [dependencies]
 gix-features = { version = "^0.46.2", path = "../gix-features", features = [
     "progress",

gix-protocol/src/lib.rs

@@ -71,3 +71,7 @@ pub use ls_refs::function::LsRefsCommand;
 
 mod util;
 pub use util::*;
+
+#[cfg(feature = "serve")]
+///
+pub mod serve;

gix-protocol/src/serve/mod.rs

@@ -0,0 +1,17 @@
+mod ref_advertisement;
+pub use ref_advertisement::{write_capabilities_v2, write_v1, write_v2_ls_refs};
+
+///
+pub mod upload_pack;
+
+/// A reference to advertise to clients.
+pub struct RefAdvertisement<'a> {
+    /// The ref name, e.g. `refs/heads/main`.
+    pub name: &'a [u8],
+    /// The object ID the ref points to.
+    pub object_id: &'a gix_hash::oid,
+    /// The peeled object ID, if this is an annotated tag.
+    pub peeled: Option<&'a gix_hash::oid>,
+    /// The symref target, e.g. `refs/heads/main` for `HEAD`.
+    pub symref_target: Option<&'a [u8]>,
+}

gix-protocol/src/serve/ref_advertisement.rs

@@ -0,0 +1,98 @@
+use std::io::{self, Write};
+
+use crate::transport::packetline::blocking_io::encode::{data_to_write, flush_to_write};
+
+use crate::serve::RefAdvertisement;
+
+/// Write a V1 ref advertisement to `writer`.
+pub fn write_v1<W: Write>(writer: &mut W, refs: &[RefAdvertisement<'_>], capabilities: &[&str]) -> io::Result<()> {
+    let mut all_caps: Vec<String> = refs
+        .iter()
+        .filter_map(|r| {
+            r.symref_target.map(|target| {
+                format!(
+                    "symref={}:{}",
+                    std::str::from_utf8(r.name).expect("valid UTF-8 ref name"),
+                    std::str::from_utf8(target).expect("valid UTF-8 symref target")
+                )
+            })
+        })
+        .collect();
+    all_caps.extend(capabilities.iter().map(ToString::to_string));
+    let caps = all_caps.join(" ");
+
+    if refs.is_empty() {
+        let mut line = Vec::new();
+        gix_hash::ObjectId::null(gix_hash::Kind::Sha1).write_hex_to(&mut line)?;
+        line.extend_from_slice(b" capabilities^{}\0");
+        line.extend_from_slice(caps.as_bytes());
+        line.push(b'\n');
+        data_to_write(&line, &mut *writer)?;
+    } else {
+        for (i, r) in refs.iter().enumerate() {
+            let mut line = Vec::new();
+            r.object_id.write_hex_to(&mut line)?;
+            line.push(b' ');
+            line.extend_from_slice(r.name);
+            if i == 0 {
+                line.push(b'\0');
+                line.extend_from_slice(caps.as_bytes());
+            }
+            line.push(b'\n');
+            data_to_write(&line, &mut *writer)?;
+
+            if let Some(peeled) = r.peeled {
+                let mut line = Vec::new();
+                peeled.write_hex_to(&mut line)?;
+                line.push(b' ');
+                line.extend_from_slice(r.name);
+                line.extend_from_slice(b"^{}\n");
+                data_to_write(&line, &mut *writer)?;
+            }
+        }
+    }
+
+    flush_to_write(&mut *writer)?;
+    Ok(())
+}
+
+/// Write a V2 ls-refs response to `writer`.
+pub fn write_v2_ls_refs<W: Write>(writer: &mut W, refs: &[RefAdvertisement<'_>]) -> io::Result<()> {
+    for r in refs.iter() {
+        let mut line = Vec::new();
+        r.object_id.write_hex_to(&mut line)?;
+        line.push(b' ');
+        line.extend_from_slice(r.name);
+
+        if let Some(symref_target) = r.symref_target {
+            line.extend_from_slice(b" symref-target:");
+            line.extend_from_slice(symref_target);
+        }
+
+        if let Some(peeled) = r.peeled {
+            line.extend_from_slice(b" peeled:");
+            peeled.write_hex_to(&mut line)?;
+        }
+        line.push(b'\n');
+        data_to_write(&line, &mut *writer)?;
+    }
+    flush_to_write(&mut *writer)?;
+    Ok(())
+}
+
+/// Write a V2 capabilities advertisement to `writer`.
+pub fn write_capabilities_v2<W: Write>(writer: &mut W, capabilities: &[(&str, Option<&str>)]) -> io::Result<()> {
+    data_to_write(b"version 2\n", &mut *writer)?;
+    for (name, val) in capabilities {
+        let mut line = Vec::new();
+        line.extend_from_slice(name.as_bytes());
+        if let Some(value) = val {
+            line.push(b'=');
+            line.extend_from_slice(value.as_bytes());
+        }
+        line.push(b'\n');
+        data_to_write(&line, &mut *writer)?;
+    }
+    flush_to_write(&mut *writer)?;
+    Ok(())
+}

gix-protocol/src/serve/upload_pack/ack.rs

@@ -0,0 +1,38 @@
+use std::io::{self, Write};
+
+use crate::transport::packetline::blocking_io::encode::data_to_write;
+
+/// The status of an ACK response during negotiation.
+pub enum AckStatus {
+    /// The server has this object in common with the client.
+    Common,
+    /// The server has enough common objects and is ready to send the pack.
+    Ready,
+    /// Final ACK sent after the client's `done`, before the pack.
+    Final,
+}
+
+/// Write an ACK line.
+pub fn write_ack<W: Write>(writer: &mut W, id: &gix_hash::oid, status: AckStatus) -> io::Result<()> {
+    let mut line = Vec::new();
+    line.extend_from_slice(b"ACK ");
+    id.write_hex_to(&mut line)?;
+    match status {
+        AckStatus::Common => {
+            line.extend_from_slice(b" common");
+        }
+        AckStatus::Ready => {
+            line.extend_from_slice(b" ready");
+        }
+        AckStatus::Final => {}
+    }
+    line.push(b'\n');
+    data_to_write(&line, &mut *writer)?;
+    Ok(())
+}
+
+/// Write a NAK line.
+pub fn write_nak<W: Write>(writer: &mut W) -> io::Result<()> {
+    data_to_write(b"NAK\n", &mut *writer)?;
+    Ok(())
+}

gix-protocol/src/serve/upload_pack/function.rs

@@ -0,0 +1,172 @@
+use std::io::{self, Read, Write};
+
+use gix_hash::ObjectId;
+
+use bstr::ByteSlice;
+
+use crate::serve::{
+    upload_pack::{parse_haves, parse_wants, write_ack, write_nak, AckStatus, Error},
+    write_capabilities_v2, write_v1, write_v2_ls_refs, RefAdvertisement,
+};
+use crate::transport::{
+    packetline::{
+        blocking_io::encode::{data_to_write, delim_to_write, flush_to_write},
+        PacketLineRef,
+    },
+    server::blocking_io::connection::Connection,
+};
+use crate::Command;
+
+/// Serve a V1 upload-pack session.
+pub fn serve_upload_pack_v1<R: Read, W: Write>(
+    connection: &mut Connection<R, W>,
+    refs: &[RefAdvertisement<'_>],
+    has_object: impl Fn(&gix_hash::oid) -> bool,
+    generate_pack: impl FnOnce(&[ObjectId], &[ObjectId], &mut dyn Write) -> io::Result<()>,
+    capabilities: &[&str],
+) -> Result<(), Error> {
+    write_v1(&mut connection.writer, refs, capabilities)?;
+
+    let wants = parse_wants(&mut connection.line_provider)?;
+    if wants.wants.is_empty() {
+        return Ok(());
+    }
+
+    connection.line_provider.reset();
+
+    let mut common = Vec::new();
+    loop {
+        let haves = parse_haves(&mut connection.line_provider)?;
+        let mut found_common = false;
+        for oid in &haves.haves {
+            if has_object(oid) {
+                write_ack(&mut connection.writer, oid, AckStatus::Common)?;
+                common.push(*oid);
+                found_common = true;
+            }
+        }
+
+        if haves.done {
+            break;
+        }
+
+        if !found_common {
+            write_nak(&mut connection.writer)?;
+        }
+        connection.line_provider.reset();
+    }
+
+    if let Some(last) = common.last() {
+        write_ack(&mut connection.writer, last, AckStatus::Final)?;
+    } else {
+        write_nak(&mut connection.writer)?;
+    }
+
+    let want_ids: Vec<ObjectId> = wants.wants.iter().map(|w| w.id).collect();
+    generate_pack(&want_ids, &common, &mut connection.writer)?;
+
+    Ok(())
+}
+
+/// Serve a V2 upload-pack session.
+pub fn serve_upload_pack_v2<R: Read, W: Write>(
+    connection: &mut Connection<R, W>,
+    refs: &[RefAdvertisement<'_>],
+    has_object: impl Fn(&gix_hash::oid) -> bool,
+    generate_pack: impl FnOnce(&[ObjectId], &[ObjectId], &mut dyn Write) -> io::Result<()>,
+    capabilities: &[(&str, Option<&str>)],
+) -> Result<(), Error> {
+    write_capabilities_v2(&mut connection.writer, capabilities)?;
+
+    loop {
+        connection.line_provider.reset();
+
+        let line = match connection.line_provider.read_line() {
+            Some(Ok(line)) => line?,
+            Some(Err(e)) if e.kind() == io::ErrorKind::UnexpectedEof => break,
+            Some(Err(e)) => return Err(e.into()),
+            None => break, // connection closed
+        };
+        let command = match line {
+            PacketLineRef::Data(data) => parse_command(data)?,
+            _ => break,
+        };
+
+        match command {
+            Command::LsRefs => {
+                while let Some(line) = connection.line_provider.read_line() {
+                    let _ = line??;
+                }
+                write_v2_ls_refs(&mut connection.writer, refs)?;
+            }
+            Command::Fetch => {
+                // V2 sends all arguments in one flush-terminated group.
+                let mut want_ids = Vec::new();
+                let mut have_ids = Vec::new();
+                let mut done = false;
+
+                while let Some(line) = connection.line_provider.read_line() {
+                    let line = line??;
+                    match line {
+                        PacketLineRef::Data(data) => {
+                            let data = data.trim();
+                            if let Some(hex) = data.strip_prefix(b"want ") {
+                                let id =
+                                    ObjectId::from_hex(hex).map_err(|_| Error::UnexpectedLine { line: hex.into() })?;
+                                want_ids.push(id);
+                            } else if let Some(hex) = data.strip_prefix(b"have ") {
+                                let id =
+                                    ObjectId::from_hex(hex).map_err(|_| Error::UnexpectedLine { line: hex.into() })?;
+                                have_ids.push(id);
+                            } else if data == b"done" {
+                                done = true;
+                            }
+                            // Skip unknown lines (capabilities like thin-pack, ofs-delta).
+                        }
+                        PacketLineRef::Delimiter => {}
+                        _ => break,
+                    }
+                }
+
+                data_to_write(b"acknowledgments\n", &mut connection.writer)?;
+                let mut common = Vec::new();
+                for oid in &have_ids {
+                    if has_object(oid) {
+                        write_ack(&mut connection.writer, oid, AckStatus::Common)?;
+                        common.push(*oid);
+                    }
+                }
+                if common.is_empty() {
+                    write_nak(&mut connection.writer)?;
+                }
+
+                if !done {
+                    flush_to_write(&mut connection.writer)?;
+                    continue;
+                }
+
+                data_to_write(b"ready\n", &mut connection.writer)?;
+                delim_to_write(&mut connection.writer)?;
+
+                data_to_write(b"packfile\n", &mut connection.writer)?;
+                generate_pack(&want_ids, &common, &mut connection.writer)?;
+                flush_to_write(&mut connection.writer)?;
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn parse_command(data: &[u8]) -> Result<Command, Error> {
+    let name = data
+        .trim()
+        .strip_prefix(b"command=")
+        .ok_or_else(|| Error::UnexpectedLine { line: data.into() })?;
+    match name {
+        b"ls-refs" => Ok(Command::LsRefs),
+        b"fetch" => Ok(Command::Fetch),
+        _ => Err(Error::UnexpectedLine { line: data.into() }),
+    }
+}