mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-22 11:25:56 +00:00
Integrate isolated rulesets, portable admission, and compatible relay authentication
This commit is contained in:
commit
d5f1e9cc83
112 files changed
+5892
-965
No files matched your search
@@ -63,9 +63,41 @@ impl LocalBackend {
|
||||
}
|
||||
}
|
||||
|
||||
fn require_portable(&self, local_id: &str) -> Result<()> {
|
||||
let settings = settings::load(&self.settings_dir)?;
|
||||
if settings.realms.get(local_id).is_some_and(|cfg| cfg.allow_portable) {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::Invalid("The realm owner has disabled portable characters.".into()))
|
||||
}
|
||||
}
|
||||
|
||||
fn access(&self, local_id: &str) -> Result<RealmAccess> {
|
||||
find_access(&self.descriptors, &(self.installs)(), local_id)
|
||||
.ok_or_else(|| Error::Invalid("That realm is not known to this Manager.".into()))
|
||||
let access =
|
||||
find_access(&self.descriptors, &(self.installs)(), local_id).ok_or_else(|| {
|
||||
Error::Invalid(format!(
|
||||
"That realm is not known to this Manager: {local_id}"
|
||||
))
|
||||
})?;
|
||||
if let Some((_base, rs)) = local_id.split_once(':') {
|
||||
let expected_mode = match rs {
|
||||
"coa" => crate::realms::Mode::Coa,
|
||||
"wildcard" => crate::realms::Mode::Wildcard,
|
||||
"reborn" => crate::realms::Mode::Reborn,
|
||||
_ => {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Malformed or unknown ruleset suffix in local_id: {rs}"
|
||||
)))
|
||||
}
|
||||
};
|
||||
if access.mode != Some(expected_mode) {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Realm access mode {:?} does not match expected ruleset in local_id {local_id}",
|
||||
access.mode
|
||||
)));
|
||||
}
|
||||
}
|
||||
Ok(access)
|
||||
}
|
||||
|
||||
fn account(&self, local_id: &str, filter: &str) -> Result<Option<AccountRow>> {
|
||||
@@ -86,9 +118,39 @@ impl LocalBackend {
|
||||
impl RealmBackend for LocalBackend {
|
||||
fn info(&self, local_id: &str) -> Result<RealmInfo> {
|
||||
let cfg = settings::load(&self.settings_dir)?.realms.remove(local_id);
|
||||
let access = self.access(local_id)?;
|
||||
let db = access.db()?;
|
||||
let ruleset = realm::ruleset_of(&db).map_err(|e| Error::Invalid(e.to_string()))?;
|
||||
|
||||
// Explicit local-id -> ruleset invariant:
|
||||
// local_id ruleset == RealmAccess.mode == Db.realm() == RealmInfo.ruleset
|
||||
if let Some((_base, rs)) = local_id.split_once(':') {
|
||||
let expected_ruleset: crate::portable::Ruleset = rs
|
||||
.parse()
|
||||
.map_err(|_| Error::Invalid(format!("Unknown ruleset in local_id: {rs}")))?;
|
||||
if ruleset != expected_ruleset {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Ruleset of realm DB ({ruleset:?}) does not match local_id {local_id}"
|
||||
)));
|
||||
}
|
||||
if access.mode.map(|m| m.name()) != Some(expected_ruleset.as_str()) {
|
||||
return Err(Error::Invalid(format!(
|
||||
"RealmAccess mode ({:?}) does not match local_id {local_id}",
|
||||
access.mode
|
||||
)));
|
||||
}
|
||||
if db.realm().name() != expected_ruleset.as_str() {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Db realm ({:?}) does not match local_id {local_id}",
|
||||
db.realm()
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(RealmInfo {
|
||||
automatic: cfg.as_ref().is_none_or(|c| !c.existing_only),
|
||||
route: cfg.and_then(|c| c.route),
|
||||
ruleset,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -203,6 +265,7 @@ impl RealmBackend for LocalBackend {
|
||||
}
|
||||
|
||||
fn export(&self, local_id: &str, _account_id: u32, guid: u32) -> Result<ClaimExport> {
|
||||
self.require_portable(local_id)?;
|
||||
let id = local_id.to_string();
|
||||
let bundle = self
|
||||
.portable
|
||||
@@ -211,6 +274,7 @@ impl RealmBackend for LocalBackend {
|
||||
.map_err(|e| unavailable("export", e))?;
|
||||
Ok(ClaimExport {
|
||||
character_id: bundle.character_id.as_uuid(),
|
||||
ruleset: bundle.ruleset,
|
||||
payload: bundle.payload,
|
||||
sha256: bundle.content_hash,
|
||||
collections: bundle.collections,
|
||||
@@ -223,6 +287,7 @@ impl RealmBackend for LocalBackend {
|
||||
character_id: Uuid,
|
||||
revision: u64,
|
||||
) -> Result<PreflightVerdict> {
|
||||
self.require_portable(local_id)?;
|
||||
let id = local_id.to_string();
|
||||
let cid = crate::portable::CharacterId::from_uuid(character_id)
|
||||
.map_err(|e| unavailable("character id", e))?;
|
||||
@@ -237,10 +302,230 @@ impl RealmBackend for LocalBackend {
|
||||
local_id: &str,
|
||||
params: RemoteImportParams,
|
||||
) -> Result<RemoteImportOutcome> {
|
||||
self.require_portable(local_id)?;
|
||||
let id = local_id.to_string();
|
||||
self.portable
|
||||
.call(move |s| s.import_remote_character(&id, params))
|
||||
.map_err(|e| unavailable("portable engine", e))?
|
||||
.map_err(|e| unavailable("import remote", e))
|
||||
}
|
||||
|
||||
fn world_port(&self, local_id: &str) -> Result<u16> {
|
||||
if let Ok(override_port) = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT") {
|
||||
if let Ok(p) = override_port.parse::<u16>() {
|
||||
return Ok(p);
|
||||
}
|
||||
}
|
||||
let access = self.access(local_id)?;
|
||||
let mode = if let Some(m) = access.mode {
|
||||
m
|
||||
} else if let Some((_base, _rs)) = local_id.split_once(':') {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Unresolved mode for ruleset suffix in {local_id}"
|
||||
)));
|
||||
} else {
|
||||
// Legacy unsuffixed CoA realm ONLY
|
||||
crate::realms::Mode::Coa
|
||||
};
|
||||
if let Some(ref root) = access.root {
|
||||
crate::realms::world_port_for_mode(root, mode)
|
||||
} else {
|
||||
Err(Error::Invalid(format!(
|
||||
"No server installation root for {local_id} to resolve world port"
|
||||
)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::fs;
|
||||
use tempfile::tempdir;
|
||||
|
||||
#[test]
|
||||
fn portable_access_requires_owner_opt_in_and_revokes_immediately() {
|
||||
let dir = tempdir().unwrap();
|
||||
let rt = PortableRuntime::start(&dir.path().join("portable"), Box::new(Vec::new), None).unwrap();
|
||||
let backend = LocalBackend::new(Arc::new(rt), dir.path(), dir.path(), Arc::new(Vec::new));
|
||||
assert!(backend.require_portable("srv-test").is_err());
|
||||
let mut cfg = settings::RegistrySettings::default();
|
||||
cfg.realms.insert("srv-test".into(), settings::PublishConfig {
|
||||
realm_id: None, enabled: true, display_name: "Test".into(), description: String::new(),
|
||||
language: "en".into(), region: None, existing_only: false, allow_portable: true, route: None,
|
||||
});
|
||||
settings::save(dir.path(), &cfg).unwrap();
|
||||
assert!(backend.require_portable("srv-test").is_ok());
|
||||
cfg.realms.get_mut("srv-test").unwrap().allow_portable = false;
|
||||
settings::save(dir.path(), &cfg).unwrap();
|
||||
assert!(backend.export("srv-test", 1, 1).unwrap_err().to_string().contains("disabled portable"));
|
||||
assert!(backend.check_transfer("srv-test", Uuid::new_v4(), 1).unwrap_err().to_string().contains("disabled portable"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unreadable_or_unknown_realm_fails_closed_in_info() {
|
||||
let dir = tempdir().unwrap();
|
||||
let settings = dir.path().join("Settings");
|
||||
fs::create_dir_all(&settings).unwrap();
|
||||
fs::write(settings.join("registry.json"), "{}").unwrap();
|
||||
|
||||
let desc_dir = dir.path().join("descriptors");
|
||||
fs::create_dir_all(&desc_dir).unwrap();
|
||||
|
||||
let portable_dir = dir.path().join("portable");
|
||||
let rt = PortableRuntime::start(&portable_dir, Box::new(Vec::new), None).unwrap();
|
||||
let backend = LocalBackend::new(Arc::new(rt), &settings, &desc_dir, Arc::new(Vec::new));
|
||||
|
||||
// Unknown realm id must return Err, never Ok(RealmInfo { ruleset: Ruleset::Coa, .. })
|
||||
assert!(backend.info("srv-unknown").is_err());
|
||||
assert!(backend.info("srv-unknown:wildcard").is_err());
|
||||
assert!(backend.info("srv-unknown:reborn").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn world_port_for_mode_distinguishes_simultaneous_realms() {
|
||||
let dir = tempdir().unwrap();
|
||||
let root = dir.path().join("srv");
|
||||
fs::create_dir_all(root.join("Settings")).unwrap();
|
||||
fs::write(root.join("Settings/repack.json"), r#"{"worldPort": 8085}"#).unwrap();
|
||||
fs::write(
|
||||
root.join("Settings/realm-profile.json"),
|
||||
r#"{"active": "coa", "wildcard_created": true, "simultaneous": true, "secondary_world_port": 8086}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
crate::realms::world_port_for_mode(&root, crate::realms::Mode::Coa).unwrap(),
|
||||
8085
|
||||
);
|
||||
assert_eq!(
|
||||
crate::realms::world_port_for_mode(&root, crate::realms::Mode::Wildcard).unwrap(),
|
||||
8086
|
||||
);
|
||||
|
||||
let desc_dir = dir.path().join("descriptors");
|
||||
let portable_dir = dir.path().join("portable");
|
||||
let rt = PortableRuntime::start(&portable_dir, Box::new(Vec::new), None).unwrap();
|
||||
let root_clone = root.clone();
|
||||
let backend = LocalBackend::new(
|
||||
Arc::new(rt),
|
||||
root.join("Settings"),
|
||||
&desc_dir,
|
||||
Arc::new(move || vec![("test1".to_string(), root_clone.clone())]),
|
||||
);
|
||||
|
||||
assert_eq!(backend.world_port("srv-test1:coa").unwrap(), 8085);
|
||||
assert_eq!(backend.world_port("srv-test1:wildcard").unwrap(), 8086);
|
||||
|
||||
// When simultaneous is false and active is CoA:
|
||||
fs::write(
|
||||
root.join("Settings/realm-profile.json"),
|
||||
r#"{"active": "coa", "wildcard_created": true, "simultaneous": false}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// CoA succeeds with 8085
|
||||
assert_eq!(backend.world_port("srv-test1:coa").unwrap(), 8085);
|
||||
// Wildcard must FAIL CLOSED, never return 8085
|
||||
let err_wc_mode =
|
||||
crate::realms::world_port_for_mode(&root, crate::realms::Mode::Wildcard).unwrap_err();
|
||||
assert!(
|
||||
err_wc_mode.to_string().contains("not active"),
|
||||
"Expected not active error, got: {err_wc_mode}"
|
||||
);
|
||||
assert!(backend.world_port("srv-test1:wildcard").is_err());
|
||||
|
||||
// Reborn must FAIL CLOSED
|
||||
let err_reb_mode =
|
||||
crate::realms::world_port_for_mode(&root, crate::realms::Mode::Reborn).unwrap_err();
|
||||
assert!(
|
||||
err_reb_mode.to_string().contains("not active"),
|
||||
"Expected not active error, got: {err_reb_mode}"
|
||||
);
|
||||
assert!(backend.world_port("srv-test1:reborn").is_err());
|
||||
|
||||
// When active is Reborn:
|
||||
fs::write(
|
||||
root.join("Settings/realm-profile.json"),
|
||||
r#"{"active": "reborn", "wildcard_created": true, "reborn_created": true, "simultaneous": false}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Reborn succeeds with primary world port 8085
|
||||
assert_eq!(backend.world_port("srv-test1:reborn").unwrap(), 8085);
|
||||
// CoA must FAIL CLOSED when Reborn is active
|
||||
assert!(backend.world_port("srv-test1:coa").is_err());
|
||||
// Wildcard must FAIL CLOSED when Reborn is active
|
||||
assert!(backend.world_port("srv-test1:wildcard").is_err());
|
||||
|
||||
// Malformed and unknown suffixes must fail closed
|
||||
assert!(backend.access("srv-test1:unknown").is_err());
|
||||
assert!(backend.access("srv-test1:garbage").is_err());
|
||||
assert!(backend.access("srv-test1:coa:extra").is_err());
|
||||
assert!(backend.world_port("srv-test1:unknown").is_err());
|
||||
assert!(backend.world_port("srv-test1:garbage").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn world_port_lookup_failure_causes_direct_and_relay_to_fail_closed() {
|
||||
let dir = tempdir().unwrap();
|
||||
let root = dir.path().join("srv");
|
||||
fs::create_dir_all(root.join("Settings")).unwrap();
|
||||
fs::write(root.join("Settings/repack.json"), r#"{"worldPort": 8085}"#).unwrap();
|
||||
// Server only has active CoA, simultaneous is off
|
||||
fs::write(
|
||||
root.join("Settings/realm-profile.json"),
|
||||
r#"{"active": "coa", "wildcard_created": false, "simultaneous": false}"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let desc_dir = dir.path().join("descriptors");
|
||||
let portable_dir = dir.path().join("portable");
|
||||
let rt = PortableRuntime::start(&portable_dir, Box::new(Vec::new), None).unwrap();
|
||||
let root_clone = root.clone();
|
||||
let backend = Arc::new(LocalBackend::new(
|
||||
Arc::new(rt),
|
||||
root.join("Settings"),
|
||||
&desc_dir,
|
||||
Arc::new(move || vec![("test1".to_string(), root_clone.clone())]),
|
||||
));
|
||||
|
||||
let store = Arc::new(std::sync::Mutex::new(
|
||||
crate::control::store::ControlStore::open_in_memory().unwrap(),
|
||||
));
|
||||
let service = Arc::new(crate::control::service::HostService::new(
|
||||
"srv-test1:wildcard",
|
||||
coa_registry_proto::sign::RealmId::new(),
|
||||
store,
|
||||
backend,
|
||||
));
|
||||
|
||||
// 1. HostService::local_world_port fails closed
|
||||
assert!(service.local_world_port().is_err());
|
||||
|
||||
// 2. Direct route manager cannot find a direct route because world port resolution failed
|
||||
let mut direct_mgr =
|
||||
crate::control::direct_route::DirectRouteManager::start(None, service.clone());
|
||||
assert!(!direct_mgr.is_direct_ready());
|
||||
assert!(service.direct_route().is_none());
|
||||
direct_mgr.shutdown();
|
||||
|
||||
// 3. When relay link has no world port resolved, AllocateRelay refuses
|
||||
let mut session = crate::control::service::Session::default();
|
||||
let player = uuid::Uuid::now_v7();
|
||||
let resp = service.handle(
|
||||
&mut session,
|
||||
&player,
|
||||
"KEY",
|
||||
coa_control_proto::app::Request::AllocateRelay { player_id: player },
|
||||
);
|
||||
assert!(matches!(
|
||||
resp,
|
||||
coa_control_proto::app::Response::Error {
|
||||
code: coa_control_proto::app::AppError::NoAccount
|
||||
| coa_control_proto::app::AppError::RelayUnavailable,
|
||||
..
|
||||
}
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -33,8 +33,13 @@ impl DirectIngress {
|
||||
local_auth_port: u16,
|
||||
local_world_port: u16,
|
||||
) -> Result<Self> {
|
||||
let auth_host = if auth_bind_port == 0 {
|
||||
"127.0.0.1"
|
||||
} else {
|
||||
"0.0.0.0"
|
||||
};
|
||||
let auth_listener =
|
||||
TcpListener::bind(format!("0.0.0.0:{auth_bind_port}")).map_err(|e| {
|
||||
TcpListener::bind(format!("{auth_host}:{auth_bind_port}")).map_err(|e| {
|
||||
Error::Invalid(format!(
|
||||
"Cannot bind direct auth listener on port {auth_bind_port}: {e}"
|
||||
))
|
||||
@@ -47,8 +52,13 @@ impl DirectIngress {
|
||||
.map_err(|e| Error::Invalid(e.to_string()))?
|
||||
.port();
|
||||
|
||||
let world_host = if world_bind_port == 0 {
|
||||
"127.0.0.1"
|
||||
} else {
|
||||
"0.0.0.0"
|
||||
};
|
||||
let world_listener =
|
||||
TcpListener::bind(format!("0.0.0.0:{world_bind_port}")).map_err(|e| {
|
||||
TcpListener::bind(format!("{world_host}:{world_bind_port}")).map_err(|e| {
|
||||
Error::Invalid(format!(
|
||||
"Cannot bind direct world listener on port {world_bind_port}: {e}"
|
||||
))
|
||||
@@ -114,7 +124,11 @@ impl DirectIngress {
|
||||
std::thread::Builder::new()
|
||||
.name("direct-world-worker".into())
|
||||
.spawn(move || {
|
||||
let _ = handle_world_client(client_stream, local_world_port);
|
||||
if let Err(e) =
|
||||
handle_world_client(client_stream, local_world_port)
|
||||
{
|
||||
eprintln!("handle_world_client error: {e}");
|
||||
}
|
||||
})
|
||||
.ok();
|
||||
}
|
||||
@@ -174,8 +188,21 @@ fn handle_auth_client(
|
||||
local_auth_port: u16,
|
||||
world_target: Arc<std::sync::RwLock<String>>,
|
||||
) -> Result<()> {
|
||||
let mut server = TcpStream::connect(format!("127.0.0.1:{local_auth_port}"))
|
||||
.map_err(|e| Error::Invalid(format!("Cannot connect to local authserver: {e}")))?;
|
||||
let mut server = None;
|
||||
for _ in 0..5 {
|
||||
match TcpStream::connect(format!("127.0.0.1:{local_auth_port}")) {
|
||||
Ok(s) => {
|
||||
server = Some(s);
|
||||
break;
|
||||
}
|
||||
Err(_) => std::thread::sleep(Duration::from_millis(20)),
|
||||
}
|
||||
}
|
||||
let mut server = server.ok_or_else(|| {
|
||||
Error::Invalid(format!(
|
||||
"Cannot connect to local authserver: {local_auth_port}"
|
||||
))
|
||||
})?;
|
||||
|
||||
let _ = client.set_read_timeout(Some(Duration::from_millis(500)));
|
||||
let _ = server.set_read_timeout(Some(Duration::from_millis(500)));
|
||||
@@ -213,7 +240,7 @@ fn handle_auth_client(
|
||||
}
|
||||
done_c.store(true, Ordering::Relaxed);
|
||||
if let Some(s) = server_shutdown {
|
||||
let _ = s.shutdown(std::net::Shutdown::Both);
|
||||
let _ = s.shutdown(std::net::Shutdown::Write);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -261,8 +288,21 @@ fn handle_auth_client(
|
||||
}
|
||||
|
||||
fn handle_world_client(mut client: TcpStream, local_world_port: u16) -> Result<()> {
|
||||
let mut server = TcpStream::connect(format!("127.0.0.1:{local_world_port}"))
|
||||
.map_err(|e| Error::Invalid(format!("Cannot connect to local worldserver: {e}")))?;
|
||||
let mut server = None;
|
||||
for _ in 0..5 {
|
||||
match TcpStream::connect(format!("127.0.0.1:{local_world_port}")) {
|
||||
Ok(s) => {
|
||||
server = Some(s);
|
||||
break;
|
||||
}
|
||||
Err(_) => std::thread::sleep(Duration::from_millis(20)),
|
||||
}
|
||||
}
|
||||
let mut server = server.ok_or_else(|| {
|
||||
Error::Invalid(format!(
|
||||
"Cannot connect to local worldserver: {local_world_port}"
|
||||
))
|
||||
})?;
|
||||
|
||||
let _ = client.set_nonblocking(false);
|
||||
let _ = server.set_nonblocking(false);
|
||||
@@ -278,11 +318,11 @@ fn handle_world_client(mut client: TcpStream, local_world_port: u16) -> Result<(
|
||||
|
||||
let t_c2s = std::thread::spawn(move || {
|
||||
let _ = std::io::copy(&mut client_read, &mut server_write);
|
||||
let _ = server_write.shutdown(std::net::Shutdown::Both);
|
||||
let _ = server_write.shutdown(std::net::Shutdown::Write);
|
||||
});
|
||||
|
||||
let _ = std::io::copy(&mut server, &mut client);
|
||||
let _ = client.shutdown(std::net::Shutdown::Both);
|
||||
let _ = client.shutdown(std::net::Shutdown::Write);
|
||||
|
||||
let _ = t_c2s.join();
|
||||
Ok(())
|
||||
@@ -320,6 +360,7 @@ mod tests {
|
||||
let n = stream.read(&mut buf).unwrap();
|
||||
assert_eq!(&buf[..n], b"WORLD_PING");
|
||||
stream.write_all(b"WORLD_PONG").unwrap();
|
||||
stream.flush().unwrap();
|
||||
let _ = stream.shutdown(std::net::Shutdown::Write);
|
||||
});
|
||||
|
||||
@@ -337,25 +378,27 @@ mod tests {
|
||||
let mut buf = [0u8; 16];
|
||||
let _ = stream.read(&mut buf).unwrap();
|
||||
|
||||
let mut fake_realm_list = vec![
|
||||
0x10, // Opcode CMD_REALM_LIST
|
||||
0x00, 0x00, // Size placeholder
|
||||
0x00, 0x00, 0x00, 0x00, // Unused
|
||||
0x01, 0x00, // Realm count: 1
|
||||
0x01, 0x00, 0x00, 0x00, // Icon
|
||||
0x00, // Lock
|
||||
0x00, // Flags
|
||||
];
|
||||
fake_realm_list.extend_from_slice(b"RealmOne\0");
|
||||
fake_realm_list.extend_from_slice(b"127.0.0.1:8085\0"); // original target
|
||||
fake_realm_list.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); // Population
|
||||
fake_realm_list.extend_from_slice(&[0x01]); // Num characters
|
||||
fake_realm_list.extend_from_slice(&[0x01]); // Timezone
|
||||
fake_realm_list.extend_from_slice(&[0x00]); // Realm ID
|
||||
fake_realm_list.extend_from_slice(&[0x02, 0x00]); // Footer
|
||||
let name_bytes = b"RealmOne\0";
|
||||
let addr_bytes = b"127.0.0.1:8085\0";
|
||||
let body_len = 4 + 2 + 3 + name_bytes.len() + addr_bytes.len() + 4 + 1 + 1 + 1 + 2;
|
||||
|
||||
let body_len = (fake_realm_list.len() - 3) as u16;
|
||||
fake_realm_list[1..3].copy_from_slice(&body_len.to_le_bytes());
|
||||
let mut fake_realm_list = Vec::new();
|
||||
fake_realm_list.push(0x10); // Opcode
|
||||
fake_realm_list.extend_from_slice(&(body_len as u16).to_le_bytes()); // Length
|
||||
fake_realm_list.extend_from_slice(&0u32.to_le_bytes()); // Unused
|
||||
fake_realm_list.extend_from_slice(&1u16.to_le_bytes()); // Realm count = 1
|
||||
|
||||
// Realm info:
|
||||
fake_realm_list.extend_from_slice(&[1, 0, 0]); // type, lock, flag
|
||||
fake_realm_list.extend_from_slice(name_bytes);
|
||||
fake_realm_list.extend_from_slice(addr_bytes);
|
||||
fake_realm_list.extend_from_slice(&[0, 0, 0, 0]); // pop
|
||||
fake_realm_list.extend_from_slice(&[0]); // chars
|
||||
fake_realm_list.extend_from_slice(&[1]); // timezone
|
||||
fake_realm_list.extend_from_slice(&[1]); // realm id
|
||||
|
||||
// Footer:
|
||||
fake_realm_list.extend_from_slice(&[0x10, 0x00]);
|
||||
|
||||
stream.write_all(&fake_realm_list).unwrap();
|
||||
let _ = stream.shutdown(std::net::Shutdown::Write);
|
||||
@@ -386,7 +429,7 @@ mod tests {
|
||||
let mock_world_port = mock_world.local_addr().unwrap().port();
|
||||
|
||||
// DirectIngress binds to ephemeral ports (0, 0), so actual ingress port != 8085
|
||||
let ingress = DirectIngress::start(
|
||||
let mut ingress = DirectIngress::start(
|
||||
0,
|
||||
0,
|
||||
"198.51.100.1".to_string(),
|
||||
@@ -415,25 +458,27 @@ mod tests {
|
||||
let mut buf = [0u8; 16];
|
||||
let _ = stream.read(&mut buf).unwrap();
|
||||
|
||||
let mut fake_realm_list = vec![
|
||||
0x10, // Opcode CMD_REALM_LIST
|
||||
0x00, 0x00, // Size placeholder
|
||||
0x00, 0x00, 0x00, 0x00, // Unused
|
||||
0x01, 0x00, // Realm count: 1
|
||||
0x01, 0x00, 0x00, 0x00, // Icon
|
||||
0x00, // Lock
|
||||
0x00, // Flags
|
||||
];
|
||||
fake_realm_list.extend_from_slice(b"RealmOne\0");
|
||||
fake_realm_list.extend_from_slice(b"127.0.0.1:8085\0");
|
||||
fake_realm_list.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]);
|
||||
fake_realm_list.extend_from_slice(&[0x01]);
|
||||
fake_realm_list.extend_from_slice(&[0x01]);
|
||||
fake_realm_list.extend_from_slice(&[0x00]);
|
||||
fake_realm_list.extend_from_slice(&[0x02, 0x00]);
|
||||
let name_bytes = b"RealmOne\0";
|
||||
let addr_bytes = b"127.0.0.1:8085\0";
|
||||
let body_len = 4 + 2 + 3 + name_bytes.len() + addr_bytes.len() + 4 + 1 + 1 + 1 + 2;
|
||||
|
||||
let body_len = (fake_realm_list.len() - 3) as u16;
|
||||
fake_realm_list[1..3].copy_from_slice(&body_len.to_le_bytes());
|
||||
let mut fake_realm_list = Vec::new();
|
||||
fake_realm_list.push(0x10); // Opcode
|
||||
fake_realm_list.extend_from_slice(&(body_len as u16).to_le_bytes()); // Length
|
||||
fake_realm_list.extend_from_slice(&0u32.to_le_bytes()); // Unused
|
||||
fake_realm_list.extend_from_slice(&1u16.to_le_bytes()); // Realm count = 1
|
||||
|
||||
// Realm info:
|
||||
fake_realm_list.extend_from_slice(&[1, 0, 0]); // type, lock, flag
|
||||
fake_realm_list.extend_from_slice(name_bytes);
|
||||
fake_realm_list.extend_from_slice(addr_bytes);
|
||||
fake_realm_list.extend_from_slice(&[0, 0, 0, 0]); // pop
|
||||
fake_realm_list.extend_from_slice(&[0]); // chars
|
||||
fake_realm_list.extend_from_slice(&[1]); // timezone
|
||||
fake_realm_list.extend_from_slice(&[1]); // realm id
|
||||
|
||||
// Footer:
|
||||
fake_realm_list.extend_from_slice(&[0x10, 0x00]);
|
||||
|
||||
stream.write_all(&fake_realm_list).unwrap();
|
||||
let _ = stream.shutdown(std::net::Shutdown::Write);
|
||||
@@ -462,5 +507,84 @@ mod tests {
|
||||
|
||||
drop(client_auth);
|
||||
t_auth.join().unwrap();
|
||||
ingress.stop();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_direct_ingress_wildcard_port_rewrites_to_mapped_port_and_never_advertises_coa_8085() {
|
||||
let ext_wildcard_port = 48086;
|
||||
|
||||
let mock_auth = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let mock_auth_port = mock_auth.local_addr().unwrap().port();
|
||||
|
||||
let mock_world = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let mock_world_port = mock_world.local_addr().unwrap().port();
|
||||
|
||||
// DirectIngress configured for Wildcard (local_world = mock_world_port, ext_world = 48086)
|
||||
let mut ingress = DirectIngress::start(
|
||||
0,
|
||||
0,
|
||||
"198.51.100.1".to_string(),
|
||||
ext_wildcard_port,
|
||||
mock_auth_port,
|
||||
mock_world_port,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Verify Auth rewrite rewrites to external port 48086 and never mentions 8085 or 8086
|
||||
let t_auth = std::thread::spawn(move || {
|
||||
let (mut stream, _) = mock_auth.accept().unwrap();
|
||||
let mut buf = [0u8; 16];
|
||||
let _ = stream.read(&mut buf).unwrap();
|
||||
|
||||
let name_bytes = b"Wildcard\0";
|
||||
let addr_bytes = b"127.0.0.1:8086\0";
|
||||
let body_len = 4 + 2 + 3 + name_bytes.len() + addr_bytes.len() + 4 + 1 + 1 + 1 + 2;
|
||||
|
||||
let mut fake_realm_list = Vec::new();
|
||||
fake_realm_list.push(0x10); // Opcode
|
||||
fake_realm_list.extend_from_slice(&(body_len as u16).to_le_bytes()); // Length
|
||||
fake_realm_list.extend_from_slice(&0u32.to_le_bytes()); // Unused
|
||||
fake_realm_list.extend_from_slice(&1u16.to_le_bytes()); // Realm count = 1
|
||||
|
||||
// Realm info:
|
||||
fake_realm_list.extend_from_slice(&[1, 0, 0]); // type, lock, flag
|
||||
fake_realm_list.extend_from_slice(name_bytes);
|
||||
fake_realm_list.extend_from_slice(addr_bytes);
|
||||
fake_realm_list.extend_from_slice(&[0, 0, 0, 0]); // pop
|
||||
fake_realm_list.extend_from_slice(&[0]); // chars
|
||||
fake_realm_list.extend_from_slice(&[1]); // timezone
|
||||
fake_realm_list.extend_from_slice(&[1]); // realm id
|
||||
|
||||
// Footer:
|
||||
fake_realm_list.extend_from_slice(&[0x10, 0x00]);
|
||||
|
||||
stream.write_all(&fake_realm_list).unwrap();
|
||||
let _ = stream.shutdown(std::net::Shutdown::Write);
|
||||
});
|
||||
|
||||
let mut client_auth =
|
||||
TcpStream::connect(format!("127.0.0.1:{}", ingress.auth_port())).unwrap();
|
||||
client_auth.write_all(b"AUTH_HELLO").unwrap();
|
||||
let mut auth_buf = [0u8; 512];
|
||||
let an = client_auth.read(&mut auth_buf).unwrap();
|
||||
let payload = String::from_utf8_lossy(&auth_buf[..an]);
|
||||
|
||||
assert!(
|
||||
payload.contains("198.51.100.1:48086"),
|
||||
"Expected rewritten realm list to contain external port 48086, got: {payload}"
|
||||
);
|
||||
assert!(
|
||||
!payload.contains("8085"),
|
||||
"DirectIngress for Wildcard must never advertise CoA port 8085"
|
||||
);
|
||||
assert!(
|
||||
!payload.contains(":8086"),
|
||||
"DirectIngress for Wildcard must rewrite internal port 8086 to external 48086"
|
||||
);
|
||||
|
||||
drop(client_auth);
|
||||
t_auth.join().unwrap();
|
||||
ingress.stop();
|
||||
}
|
||||
}
|
||||
@@ -304,10 +304,25 @@ fn attempt_route_discovery(
|
||||
.ok()
|
||||
.and_then(|p| p.parse().ok())
|
||||
.unwrap_or(coa_control_proto::relay::LOCAL_AUTH_PORT);
|
||||
let local_world = std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT")
|
||||
let local_world = match std::env::var("COA_OVERRIDE_LOCAL_WORLD_PORT")
|
||||
.ok()
|
||||
.and_then(|p| p.parse().ok())
|
||||
.unwrap_or(coa_control_proto::relay::LOCAL_WORLD_PORT);
|
||||
{
|
||||
Some(p) => p,
|
||||
None => match service.local_world_port() {
|
||||
Ok(p) => p,
|
||||
Err(e) => {
|
||||
set_status(
|
||||
status,
|
||||
RouteStatus::RelayOnly {
|
||||
reason: format!("Cannot resolve local world port: {e}"),
|
||||
},
|
||||
);
|
||||
service.set_direct_route(None);
|
||||
return;
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
let desired_auth_port: u16 = std::env::var("COA_DIRECT_AUTH_PORT")
|
||||
.ok()
|
||||
@@ -316,7 +331,7 @@ fn attempt_route_discovery(
|
||||
let desired_world_port: u16 = std::env::var("COA_DIRECT_WORLD_PORT")
|
||||
.ok()
|
||||
.and_then(|p| p.parse().ok())
|
||||
.unwrap_or(8085);
|
||||
.unwrap_or(local_world);
|
||||
|
||||
let ingress = match DirectIngress::start(
|
||||
desired_auth_port,
|
||||
|
||||
@@ -159,7 +159,7 @@ fn session(
|
||||
) -> Result<(), LinkError> {
|
||||
let mut ws = transport::connect(url, POLL)?;
|
||||
let nonce = match transport::next_frame(&mut ws, Duration::from_secs(15))? {
|
||||
Frame::Challenge { nonce, .. } => nonce,
|
||||
Frame::Challenge { protocol, nonce } if protocol == coord::COORDINATOR_PROTOCOL_VERSION => nonce,
|
||||
_ => return Err(LinkError::Protocol("a challenge was expected".into())),
|
||||
};
|
||||
transport::send_text(
|
||||
|
||||
@@ -24,6 +24,7 @@ pub struct HostControlRealm {
|
||||
pub local_id: String,
|
||||
pub realm_id: String,
|
||||
pub link: LinkStatus,
|
||||
pub relay: Option<crate::control::relay_link::RelayStatus>,
|
||||
}
|
||||
|
||||
pub struct HostControl {
|
||||
@@ -95,18 +96,27 @@ impl HostControl {
|
||||
store.clone(),
|
||||
backend.clone(),
|
||||
));
|
||||
let relay_link =
|
||||
crate::control::transport::relay_url(&base, "/relay/v1/host").map(
|
||||
|r_url| {
|
||||
let rl = crate::control::relay_link::RelayLink::start(
|
||||
r_url,
|
||||
realm_id,
|
||||
key.clone(),
|
||||
);
|
||||
service.set_relay(rl.clone());
|
||||
rl
|
||||
},
|
||||
);
|
||||
let relay_link = match service.local_world_port() {
|
||||
Ok(world_port) => {
|
||||
crate::control::transport::relay_url(&base, "/relay/v1/host").map(
|
||||
|r_url| {
|
||||
let rl =
|
||||
crate::control::relay_link::RelayLink::start_with_ports(
|
||||
r_url,
|
||||
realm_id,
|
||||
key.clone(),
|
||||
Some(world_port),
|
||||
);
|
||||
service.set_relay(rl.clone());
|
||||
rl
|
||||
},
|
||||
)
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("Relay link unavailable for {local_id}: cannot resolve world port: {e}");
|
||||
None
|
||||
}
|
||||
};
|
||||
let direct_route =
|
||||
Some(crate::control::direct_route::DirectRouteManager::start(
|
||||
Some(base.clone()),
|
||||
@@ -135,6 +145,7 @@ impl HostControl {
|
||||
local_id: id.clone(),
|
||||
realm_id: r.realm_id.to_string(),
|
||||
link: r.link.status(),
|
||||
relay: r.relay_link.as_ref().map(|relay| relay.status()),
|
||||
},
|
||||
)
|
||||
})
|
||||
|
||||
@@ -115,6 +115,7 @@ pub struct AccountOutcome {
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Claimed {
|
||||
pub character_id: Uuid,
|
||||
pub ruleset: String,
|
||||
pub payload: Vec<u8>,
|
||||
pub sha256: [u8; 32],
|
||||
pub collections: BTreeMap<String, Vec<u32>>,
|
||||
@@ -347,13 +348,14 @@ impl PlayerControl {
|
||||
|
||||
pub fn claim(&self, ch: &mut PlayerChannel, token: u32) -> R<Claimed> {
|
||||
let r = ch.request(&Request::Claim { token })?;
|
||||
let (character_id, sha256, payload, collections) = expect(r, |r| match r {
|
||||
let (character_id, ruleset, sha256, payload, collections) = expect(r, |r| match r {
|
||||
Response::Claimed {
|
||||
character_id,
|
||||
ruleset,
|
||||
sha256,
|
||||
payload,
|
||||
collections,
|
||||
} => Ok((character_id, sha256, payload, collections)),
|
||||
} => Ok((character_id, ruleset, sha256, payload, collections)),
|
||||
other => Err(other),
|
||||
})?;
|
||||
let payload = base64::engine::general_purpose::STANDARD
|
||||
@@ -373,6 +375,7 @@ impl PlayerControl {
|
||||
})?;
|
||||
Ok(Claimed {
|
||||
character_id,
|
||||
ruleset,
|
||||
payload,
|
||||
sha256: hash,
|
||||
collections,
|
||||
@@ -413,6 +416,7 @@ impl PlayerControl {
|
||||
&self,
|
||||
ch: &mut PlayerChannel,
|
||||
character_id: Uuid,
|
||||
ruleset: &str,
|
||||
canonical_revision: u64,
|
||||
payload: &[u8],
|
||||
content_hash: [u8; 32],
|
||||
@@ -423,6 +427,7 @@ impl PlayerControl {
|
||||
let offer = Request::TransferOffer {
|
||||
transfer_id,
|
||||
character_id,
|
||||
ruleset: ruleset.to_string(),
|
||||
canonical_revision,
|
||||
content_hash: content_hash_str.clone(),
|
||||
total_size: payload.len(),
|
||||
|
||||
@@ -35,7 +35,7 @@ impl PlayerChannel {
|
||||
Duration::from_millis(500),
|
||||
)?;
|
||||
let nonce = match transport::next_frame(&mut ws, STEP)? {
|
||||
Frame::Challenge { nonce, .. } => nonce,
|
||||
Frame::Challenge { protocol, nonce } if protocol == coord::COORDINATOR_PROTOCOL_VERSION => nonce,
|
||||
_ => return Err(LinkError::Protocol("a challenge was expected".into())),
|
||||
};
|
||||
transport::send_text(
|
||||
|
||||
@@ -71,6 +71,15 @@ impl RelayProvider for RelayLink {
|
||||
|
||||
impl RelayLink {
|
||||
pub fn start(url: String, realm_id: RealmId, key: SigningKey) -> Arc<Self> {
|
||||
Self::start_with_ports(url, realm_id, key, None)
|
||||
}
|
||||
|
||||
pub fn start_with_ports(
|
||||
url: String,
|
||||
realm_id: RealmId,
|
||||
key: SigningKey,
|
||||
local_world_port: Option<u16>,
|
||||
) -> Arc<Self> {
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let status = Arc::new(Mutex::new(RelayStatus::default()));
|
||||
let (alloc_tx, alloc_rx) = channel();
|
||||
@@ -79,7 +88,7 @@ impl RelayLink {
|
||||
let st = status.clone();
|
||||
let join = std::thread::Builder::new()
|
||||
.name("control-relay-host".into())
|
||||
.spawn(move || run(&url, realm_id, &key, alloc_rx, &s, &st))
|
||||
.spawn(move || run(&url, realm_id, &key, alloc_rx, &s, &st, local_world_port))
|
||||
.ok();
|
||||
|
||||
Arc::new(RelayLink {
|
||||
@@ -127,11 +136,15 @@ fn run(
|
||||
)>,
|
||||
stop: &AtomicBool,
|
||||
status: &Mutex<RelayStatus>,
|
||||
local_world_port: Option<u16>,
|
||||
) {
|
||||
let mut failures = 0u32;
|
||||
while !stop.load(Ordering::SeqCst) {
|
||||
let began = Instant::now();
|
||||
let result = session(url, realm, key, &alloc_rx, stop, status);
|
||||
let result = session(url, realm, key, &alloc_rx, stop, status, local_world_port);
|
||||
if let Err(error) = &result {
|
||||
tracing::warn!(%realm, %error, "game relay connection lost; retrying");
|
||||
}
|
||||
set_status(status, |s| {
|
||||
s.connected = false;
|
||||
s.active_streams = 0;
|
||||
@@ -176,6 +189,7 @@ fn session(
|
||||
)>,
|
||||
stop: &AtomicBool,
|
||||
status: &Mutex<RelayStatus>,
|
||||
local_world_port: Option<u16>,
|
||||
) -> Result<(), LinkError> {
|
||||
let mut ws = transport::connect(url, POLL)?;
|
||||
|
||||
@@ -305,8 +319,21 @@ fn session(
|
||||
TunnelMsg::Connect {
|
||||
stream_id, target, ..
|
||||
} => {
|
||||
// Strictly predefined local targets: Auth (3724) or World (8085)
|
||||
let local_port = target.local_port();
|
||||
// Strictly predefined local targets: Auth (3724) or World (8085 or bound realm world port)
|
||||
let local_port = match target {
|
||||
RelayTarget::Auth => target.local_port(),
|
||||
RelayTarget::World => match local_world_port {
|
||||
Some(p) => p,
|
||||
None => {
|
||||
eprintln!("RelayLink cannot connect to World: local_world_port was not provided (fail-closed)");
|
||||
let _ = ws_out_tx.send(TunnelMsg::ConnectErr {
|
||||
stream_id,
|
||||
error: "World port unresolved".into(),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
},
|
||||
};
|
||||
match TcpStream::connect(("127.0.0.1", local_port)) {
|
||||
Ok(tcp) => {
|
||||
let (stream_tx, stream_rx) = channel::<TunnelMsg>();
|
||||
|
||||
@@ -26,6 +26,7 @@ pub struct RealmInfo {
|
||||
pub automatic: bool,
|
||||
/// An address a player's game client can reach right now, when the owner has stated one. Not a relay and not discovery.
|
||||
pub route: Option<String>,
|
||||
pub ruleset: crate::portable::model::Ruleset,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
@@ -55,6 +56,7 @@ pub struct CharInfo {
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ClaimExport {
|
||||
pub character_id: Uuid,
|
||||
pub ruleset: crate::portable::Ruleset,
|
||||
pub payload: Vec<u8>,
|
||||
pub sha256: [u8; 32],
|
||||
pub collections: BTreeMap<String, Vec<u32>>,
|
||||
@@ -118,6 +120,8 @@ pub trait RealmBackend: Send + Sync {
|
||||
local_id: &str,
|
||||
params: RemoteImportParams,
|
||||
) -> Result<RemoteImportOutcome>;
|
||||
/// Local world port for this realm. Must fail closed if the realm port cannot be resolved.
|
||||
fn world_port(&self, local_id: &str) -> Result<u16>;
|
||||
}
|
||||
|
||||
/// State of one channel.
|
||||
@@ -218,6 +222,10 @@ impl HostService {
|
||||
self.realm_id
|
||||
}
|
||||
|
||||
pub fn local_world_port(&self) -> Result<u16> {
|
||||
self.backend.world_port(&self.local_id)
|
||||
}
|
||||
|
||||
/// The player's public key is the one recorded for this player id when there is a record; `None` when the player is new here.
|
||||
pub fn key_matches(&self, player: &Uuid, public_key: &str) -> bool {
|
||||
match self
|
||||
@@ -303,6 +311,7 @@ impl HostService {
|
||||
Request::TransferOffer {
|
||||
transfer_id,
|
||||
character_id,
|
||||
ruleset,
|
||||
canonical_revision,
|
||||
content_hash,
|
||||
total_size,
|
||||
@@ -311,6 +320,7 @@ impl HostService {
|
||||
player,
|
||||
transfer_id,
|
||||
character_id,
|
||||
ruleset,
|
||||
canonical_revision,
|
||||
content_hash,
|
||||
total_size,
|
||||
@@ -691,6 +701,7 @@ impl HostService {
|
||||
use base64::Engine;
|
||||
Response::Claimed {
|
||||
character_id: exported.character_id,
|
||||
ruleset: exported.ruleset.as_str().to_string(),
|
||||
sha256: hex::encode(exported.sha256),
|
||||
payload: base64::engine::general_purpose::STANDARD.encode(&exported.payload),
|
||||
collections: exported.collections,
|
||||
@@ -726,6 +737,7 @@ impl HostService {
|
||||
player: &Uuid,
|
||||
transfer_id: Uuid,
|
||||
character_id: Uuid,
|
||||
ruleset: String,
|
||||
canonical_revision: u64,
|
||||
content_hash: String,
|
||||
total_size: usize,
|
||||
@@ -741,6 +753,30 @@ impl HostService {
|
||||
);
|
||||
};
|
||||
|
||||
// 0. Strict ruleset isolation: target realm ruleset must match offer ruleset
|
||||
let info = match self.backend.info(&self.local_id) {
|
||||
Ok(i) => i,
|
||||
Err(e) => return unavailable("reading realm info", &e),
|
||||
};
|
||||
let offer_ruleset = match crate::portable::model::Ruleset::parse(&ruleset) {
|
||||
Ok(r) => r,
|
||||
Err(_) => return err(AppError::Incompatible, "Invalid ruleset in transfer offer."),
|
||||
};
|
||||
if offer_ruleset != info.ruleset {
|
||||
return err(
|
||||
AppError::Incompatible,
|
||||
"Character ruleset does not match this realm.",
|
||||
);
|
||||
}
|
||||
for kind in collections.keys() {
|
||||
if !crate::portable::session::protocol::carried_kind_for(kind, offer_ruleset) {
|
||||
return err(
|
||||
AppError::Incompatible,
|
||||
"Collection kind does not belong to this ruleset.",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Ownership check: another player cannot overwrite a character claimed here
|
||||
if let Ok(Some(claim)) = self
|
||||
.store
|
||||
@@ -834,6 +870,7 @@ impl HostService {
|
||||
realm_local_id: self.local_id.clone(),
|
||||
transfer_id,
|
||||
character_id,
|
||||
ruleset: offer_ruleset.as_str().to_string(),
|
||||
player_id: *player,
|
||||
revision: canonical_revision,
|
||||
content_hash,
|
||||
@@ -1008,18 +1045,55 @@ impl HostService {
|
||||
Err(e) => return unavailable("reading transfer file", &Error::Invalid(e.to_string())),
|
||||
};
|
||||
|
||||
use sha2::{Digest, Sha256};
|
||||
let hash = hex::encode(Sha256::digest(&payload));
|
||||
if hash != t.content_hash {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(AppError::Invalid, "Content hash mismatch.");
|
||||
}
|
||||
|
||||
let mut hash_bytes = [0u8; 32];
|
||||
if hex::decode_to_slice(&t.content_hash, &mut hash_bytes).is_err() {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(AppError::Invalid, "Invalid content hash format.");
|
||||
}
|
||||
|
||||
let decoded = match crate::portable::snapshot::decode(&payload, Some(&hash_bytes)) {
|
||||
Ok(d) => d,
|
||||
Err(e) => {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(AppError::Invalid, &format!("Corrupt snapshot: {e}"));
|
||||
}
|
||||
};
|
||||
let transfer_ruleset: crate::portable::Ruleset = match t.ruleset.parse() {
|
||||
Ok(r) => r,
|
||||
Err(_) => {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(AppError::Incompatible, "Invalid transfer ruleset.");
|
||||
}
|
||||
};
|
||||
if decoded.character_id.as_uuid() != t.character_id {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(
|
||||
AppError::Invalid,
|
||||
"Snapshot character id does not match TransferOffer.",
|
||||
);
|
||||
}
|
||||
if decoded.ruleset != transfer_ruleset {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(
|
||||
AppError::Incompatible,
|
||||
"Snapshot ruleset does not match TransferOffer.",
|
||||
);
|
||||
}
|
||||
let info = match self.backend.info(&self.local_id) {
|
||||
Ok(i) => i,
|
||||
Err(e) => {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return unavailable("reading realm info", &e);
|
||||
}
|
||||
};
|
||||
if transfer_ruleset != info.ruleset {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
return err(
|
||||
AppError::Incompatible,
|
||||
"Transfer ruleset does not match target realm ruleset.",
|
||||
);
|
||||
}
|
||||
|
||||
let Some(m) = self.mapping(player) else {
|
||||
return err(AppError::NoAccount, "Player has no account on this realm.");
|
||||
};
|
||||
@@ -1083,6 +1157,7 @@ impl HostService {
|
||||
#[cfg(any(test, feature = "testkit"))]
|
||||
pub mod fake {
|
||||
use super::*;
|
||||
use crate::portable::Ruleset;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct FakeRealm {
|
||||
@@ -1095,6 +1170,7 @@ pub mod fake {
|
||||
pub seen_passwords: Mutex<Vec<String>>,
|
||||
pub imported: Mutex<HashMap<Uuid, (u32, Uuid)>>,
|
||||
pub incompatible: Mutex<std::collections::HashSet<Uuid>>,
|
||||
pub world_port: Mutex<Option<Result<u16>>>,
|
||||
}
|
||||
|
||||
impl FakeRealm {
|
||||
@@ -1141,6 +1217,7 @@ pub mod fake {
|
||||
impl RealmBackend for FakeRealm {
|
||||
fn info(&self, _: &str) -> Result<RealmInfo> {
|
||||
Ok(RealmInfo {
|
||||
ruleset: Ruleset::Coa,
|
||||
automatic: *self.automatic.lock().unwrap(),
|
||||
route: self.route.lock().unwrap().clone(),
|
||||
})
|
||||
@@ -1245,6 +1322,7 @@ pub mod fake {
|
||||
.or_insert_with(Uuid::now_v7);
|
||||
Ok(ClaimExport {
|
||||
character_id: id,
|
||||
ruleset: crate::portable::Ruleset::Coa,
|
||||
payload: format!("payload-{guid}").into_bytes(),
|
||||
sha256: [7; 32],
|
||||
collections: BTreeMap::from([("coa:appearance".to_string(), vec![1, 2, 3])]),
|
||||
@@ -1284,6 +1362,16 @@ pub mod fake {
|
||||
notes: vec![],
|
||||
})
|
||||
}
|
||||
fn world_port(&self, _: &str) -> Result<u16> {
|
||||
if let Some(res) = self.world_port.lock().unwrap().as_ref() {
|
||||
match res {
|
||||
Ok(p) => Ok(*p),
|
||||
Err(e) => Err(Error::Invalid(e.to_string())),
|
||||
}
|
||||
} else {
|
||||
Ok(8085)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1424,7 +1512,7 @@ mod tests {
|
||||
&Uuid::now_v7(),
|
||||
"K",
|
||||
Request::Hello {
|
||||
protocol: 1,
|
||||
protocol: coa_control_proto::CONTROL_PROTOCOL_VERSION,
|
||||
client: "t".into(),
|
||||
},
|
||||
)
|
||||
@@ -1655,6 +1743,7 @@ mod tests {
|
||||
);
|
||||
let Response::Claimed {
|
||||
character_id,
|
||||
ruleset,
|
||||
sha256,
|
||||
payload,
|
||||
collections,
|
||||
@@ -1662,6 +1751,7 @@ mod tests {
|
||||
else {
|
||||
panic!()
|
||||
};
|
||||
assert_eq!(ruleset, "coa");
|
||||
assert_eq!(sha256, hex::encode([7u8; 32]));
|
||||
assert!(!payload.is_empty() && collections["coa:appearance"] == vec![1, 2, 3]);
|
||||
// asking again returns the same character
|
||||
@@ -1857,6 +1947,14 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
fn test_snapshot(cid: Uuid, ruleset: crate::portable::Ruleset) -> (Vec<u8>, String) {
|
||||
let mut model = crate::portable::fixtures::geared_level_eighty();
|
||||
model.character_id = crate::portable::CharacterId::from_uuid(cid).unwrap();
|
||||
model.ruleset = ruleset;
|
||||
let encoded = crate::portable::snapshot::encode(&model).unwrap();
|
||||
(encoded.payload, hex::encode(encoded.content_hash))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remote_transfer_lifecycle_empty_realm_import_and_ack() {
|
||||
let (realm, s, p, _acc) = claimed_setup();
|
||||
@@ -1864,12 +1962,11 @@ mod tests {
|
||||
let cid = Uuid::now_v7();
|
||||
let tid = Uuid::now_v7();
|
||||
|
||||
let payload = b"portable_character_snapshot_payload_test_data".to_vec();
|
||||
use sha2::{Digest, Sha256};
|
||||
let hash = hex::encode(Sha256::digest(&payload));
|
||||
let (payload, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa);
|
||||
|
||||
// 1. Offer
|
||||
let offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -1943,6 +2040,7 @@ mod tests {
|
||||
realm.incompatible.lock().unwrap().insert(cid);
|
||||
|
||||
let offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -1973,15 +2071,12 @@ mod tests {
|
||||
let cid = Uuid::now_v7();
|
||||
let tid = Uuid::now_v7();
|
||||
|
||||
let chunk1 = b"first_chunk_of_payload_";
|
||||
let chunk2 = b"second_chunk_of_payload";
|
||||
let mut full = chunk1.to_vec();
|
||||
full.extend_from_slice(chunk2);
|
||||
|
||||
use sha2::{Digest, Sha256};
|
||||
let hash = hex::encode(Sha256::digest(&full));
|
||||
let (full, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa);
|
||||
let mid = full.len() / 2;
|
||||
let (chunk1, chunk2) = full.split_at(mid);
|
||||
|
||||
let offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -2071,11 +2166,10 @@ mod tests {
|
||||
let cid = Uuid::now_v7();
|
||||
let tid = Uuid::now_v7();
|
||||
|
||||
let payload = b"idempotency_test_payload".to_vec();
|
||||
use sha2::{Digest, Sha256};
|
||||
let hash = hex::encode(Sha256::digest(&payload));
|
||||
let (payload, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa);
|
||||
|
||||
let offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -2138,6 +2232,7 @@ mod tests {
|
||||
// Client starts a new transfer for the exact same committed revision: discovers committed state
|
||||
let tid2 = Uuid::now_v7();
|
||||
let offer2 = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid2,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -2169,11 +2264,10 @@ mod tests {
|
||||
let cid = Uuid::now_v7();
|
||||
let tid = Uuid::now_v7();
|
||||
|
||||
let payload = b"player_1_character_data".to_vec();
|
||||
use sha2::{Digest, Sha256};
|
||||
let hash = hex::encode(Sha256::digest(&payload));
|
||||
let (payload, hash) = test_snapshot(cid, crate::portable::Ruleset::Coa);
|
||||
|
||||
let offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -2240,6 +2334,7 @@ mod tests {
|
||||
|
||||
let tid_impostor = Uuid::now_v7();
|
||||
let impostor_offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid_impostor,
|
||||
character_id: cid,
|
||||
canonical_revision: 2,
|
||||
@@ -2267,9 +2362,7 @@ mod tests {
|
||||
let cid = Uuid::now_v7();
|
||||
let tid1 = Uuid::now_v7();
|
||||
|
||||
let payload1 = b"character_revision_1_data".to_vec();
|
||||
use sha2::{Digest, Sha256};
|
||||
let hash1 = hex::encode(Sha256::digest(&payload1));
|
||||
let (payload1, hash1) = test_snapshot(cid, crate::portable::Ruleset::Coa);
|
||||
|
||||
// Rev 1
|
||||
s.handle(
|
||||
@@ -2277,6 +2370,7 @@ mod tests {
|
||||
&p,
|
||||
"K",
|
||||
Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid1,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
@@ -2321,13 +2415,18 @@ mod tests {
|
||||
|
||||
// Rev 2
|
||||
let tid2 = Uuid::now_v7();
|
||||
let payload2 = b"character_revision_2_newer_data".to_vec();
|
||||
let hash2 = hex::encode(Sha256::digest(&payload2));
|
||||
let mut model2 = crate::portable::fixtures::geared_level_eighty();
|
||||
model2.character_id = crate::portable::CharacterId::from_uuid(cid).unwrap();
|
||||
model2.progression.money += 500;
|
||||
let enc2 = crate::portable::snapshot::encode(&model2).unwrap();
|
||||
let (payload2, hash2) = (enc2.payload, hex::encode(enc2.content_hash));
|
||||
|
||||
let r = s.handle(
|
||||
&mut session,
|
||||
&p,
|
||||
"K",
|
||||
Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid2,
|
||||
character_id: cid,
|
||||
canonical_revision: 2,
|
||||
@@ -2377,4 +2476,190 @@ mod tests {
|
||||
"update, not duplicate import"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cross_ruleset_transfer_offers_are_rejected_before_mutation() {
|
||||
let (realm, s, p, _acc) = claimed_setup();
|
||||
let mut session = Session::default();
|
||||
let cid = Uuid::now_v7();
|
||||
let tid = Uuid::now_v7();
|
||||
|
||||
// 1. Host is CoA, offer is Wildcard -> Rejected
|
||||
let wc_offer = Request::TransferOffer {
|
||||
ruleset: "wildcard".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
content_hash: "a".repeat(64),
|
||||
total_size: 100,
|
||||
collections: BTreeMap::new(),
|
||||
};
|
||||
let r = s.handle(&mut session, &p, "K", wc_offer);
|
||||
assert!(matches!(
|
||||
r,
|
||||
Response::Error {
|
||||
code: AppError::Incompatible,
|
||||
..
|
||||
}
|
||||
));
|
||||
|
||||
// 2. Host is CoA, offer is Reborn -> Rejected
|
||||
let rb_offer = Request::TransferOffer {
|
||||
ruleset: "reborn".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
content_hash: "a".repeat(64),
|
||||
total_size: 100,
|
||||
collections: BTreeMap::new(),
|
||||
};
|
||||
let r = s.handle(&mut session, &p, "K", rb_offer);
|
||||
assert!(matches!(
|
||||
r,
|
||||
Response::Error {
|
||||
code: AppError::Incompatible,
|
||||
..
|
||||
}
|
||||
));
|
||||
|
||||
// 3. Collection kinds for another ruleset -> Rejected
|
||||
let foreign_coll_offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
content_hash: "a".repeat(64),
|
||||
total_size: 100,
|
||||
collections: BTreeMap::from([("wildcard:appearance".into(), vec![1, 2, 3])]),
|
||||
};
|
||||
let r = s.handle(&mut session, &p, "K", foreign_coll_offer);
|
||||
assert!(matches!(
|
||||
r,
|
||||
Response::Error {
|
||||
code: AppError::Incompatible,
|
||||
..
|
||||
}
|
||||
));
|
||||
|
||||
// Ensure 0 DB imports happened
|
||||
assert!(realm.imported.lock().unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tampered_payload_at_commit_aborts_with_zero_mutation() {
|
||||
let (realm, s, p, _acc) = claimed_setup();
|
||||
let mut session = Session::default();
|
||||
let cid = Uuid::now_v7();
|
||||
let tid = Uuid::now_v7();
|
||||
|
||||
// 1. Offer announces CoA
|
||||
let (payload_coa, hash_coa) = test_snapshot(cid, crate::portable::Ruleset::Coa);
|
||||
let offer = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
content_hash: hash_coa,
|
||||
total_size: payload_coa.len(),
|
||||
collections: BTreeMap::new(),
|
||||
};
|
||||
s.handle(&mut session, &p, "K", offer);
|
||||
|
||||
// Attacker creates a Wildcard snapshot with the same CID, but uploads it under the CoA offer
|
||||
let (payload_wc, hash_wc) = test_snapshot(cid, crate::portable::Ruleset::Wildcard);
|
||||
|
||||
// Uploading chunks of payload_wc will mismatch the offered hash
|
||||
use base64::Engine;
|
||||
let data = base64::engine::general_purpose::STANDARD.encode(&payload_wc);
|
||||
s.handle(
|
||||
&mut session,
|
||||
&p,
|
||||
"K",
|
||||
Request::TransferChunk {
|
||||
transfer_id: tid,
|
||||
offset: 0,
|
||||
data,
|
||||
},
|
||||
);
|
||||
let commit = Request::TransferCommit { transfer_id: tid };
|
||||
let r = s.handle(&mut session, &p, "K", commit);
|
||||
assert!(matches!(
|
||||
r,
|
||||
Response::Error {
|
||||
code: AppError::Invalid,
|
||||
..
|
||||
}
|
||||
));
|
||||
assert!(realm.imported.lock().unwrap().is_empty());
|
||||
|
||||
// 2. What if attacker offered hash_wc matching payload_wc, but offer.ruleset is "coa"?
|
||||
let tid2 = Uuid::now_v7();
|
||||
let offer2 = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid2,
|
||||
character_id: cid,
|
||||
canonical_revision: 1,
|
||||
content_hash: hash_wc,
|
||||
total_size: payload_wc.len(),
|
||||
collections: BTreeMap::new(),
|
||||
};
|
||||
s.handle(&mut session, &p, "K", offer2);
|
||||
let data2 = base64::engine::general_purpose::STANDARD.encode(&payload_wc);
|
||||
s.handle(
|
||||
&mut session,
|
||||
&p,
|
||||
"K",
|
||||
Request::TransferChunk {
|
||||
transfer_id: tid2,
|
||||
offset: 0,
|
||||
data: data2,
|
||||
},
|
||||
);
|
||||
let commit2 = Request::TransferCommit { transfer_id: tid2 };
|
||||
let r2 = s.handle(&mut session, &p, "K", commit2);
|
||||
assert!(matches!(
|
||||
r2,
|
||||
Response::Error {
|
||||
code: AppError::Incompatible,
|
||||
..
|
||||
}
|
||||
));
|
||||
assert!(realm.imported.lock().unwrap().is_empty());
|
||||
|
||||
// 3. What if snapshot contains a different character_id than offer?
|
||||
let tid3 = Uuid::now_v7();
|
||||
let other_cid = Uuid::now_v7();
|
||||
let (payload_other, hash_other) = test_snapshot(other_cid, crate::portable::Ruleset::Coa);
|
||||
let offer3 = Request::TransferOffer {
|
||||
ruleset: "coa".into(),
|
||||
transfer_id: tid3,
|
||||
character_id: cid, // offered cid
|
||||
canonical_revision: 1,
|
||||
content_hash: hash_other,
|
||||
total_size: payload_other.len(),
|
||||
collections: BTreeMap::new(),
|
||||
};
|
||||
s.handle(&mut session, &p, "K", offer3);
|
||||
let data3 = base64::engine::general_purpose::STANDARD.encode(&payload_other);
|
||||
s.handle(
|
||||
&mut session,
|
||||
&p,
|
||||
"K",
|
||||
Request::TransferChunk {
|
||||
transfer_id: tid3,
|
||||
offset: 0,
|
||||
data: data3,
|
||||
},
|
||||
);
|
||||
let commit3 = Request::TransferCommit { transfer_id: tid3 };
|
||||
let r3 = s.handle(&mut session, &p, "K", commit3);
|
||||
assert!(matches!(
|
||||
r3,
|
||||
Response::Error {
|
||||
code: AppError::Invalid,
|
||||
..
|
||||
}
|
||||
));
|
||||
assert!(realm.imported.lock().unwrap().is_empty());
|
||||
}
|
||||
}
|
||||
@@ -56,6 +56,7 @@ CREATE TABLE IF NOT EXISTS host_transfer(
|
||||
realm_local_id TEXT NOT NULL,
|
||||
transfer_id TEXT NOT NULL PRIMARY KEY,
|
||||
character_id TEXT NOT NULL,
|
||||
ruleset TEXT NOT NULL DEFAULT 'coa',
|
||||
player_id TEXT NOT NULL,
|
||||
revision INTEGER NOT NULL,
|
||||
content_hash TEXT NOT NULL,
|
||||
@@ -155,6 +156,7 @@ pub struct HostTransfer {
|
||||
pub realm_local_id: String,
|
||||
pub transfer_id: Uuid,
|
||||
pub character_id: Uuid,
|
||||
pub ruleset: String,
|
||||
pub player_id: Uuid,
|
||||
pub revision: u64,
|
||||
pub content_hash: String,
|
||||
@@ -199,6 +201,10 @@ impl ControlStore {
|
||||
.map_err(db)?;
|
||||
let _ = conn.pragma_update(None, "journal_mode", "WAL");
|
||||
conn.execute_batch(SCHEMA).map_err(db)?;
|
||||
let _ = conn.execute(
|
||||
"ALTER TABLE host_transfer ADD COLUMN ruleset TEXT NOT NULL DEFAULT 'coa'",
|
||||
[],
|
||||
);
|
||||
Ok(Self { conn })
|
||||
}
|
||||
|
||||
@@ -307,7 +313,7 @@ impl ControlStore {
|
||||
pub fn host_transfer(&self, realm: &str, transfer_id: &Uuid) -> Result<Option<HostTransfer>> {
|
||||
self.conn
|
||||
.query_row(
|
||||
"SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections FROM host_transfer WHERE realm_local_id = ?1 AND transfer_id = ?2",
|
||||
"SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, ruleset FROM host_transfer WHERE realm_local_id = ?1 AND transfer_id = ?2",
|
||||
params![realm, transfer_id.to_string()],
|
||||
row_transfer,
|
||||
)
|
||||
@@ -323,7 +329,7 @@ impl ControlStore {
|
||||
) -> Result<Option<HostTransfer>> {
|
||||
self.conn
|
||||
.query_row(
|
||||
"SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections FROM host_transfer WHERE realm_local_id = ?1 AND character_id = ?2 ORDER BY updated_at DESC LIMIT 1",
|
||||
"SELECT realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, ruleset FROM host_transfer WHERE realm_local_id = ?1 AND character_id = ?2 ORDER BY updated_at DESC LIMIT 1",
|
||||
params![realm, character_id.to_string()],
|
||||
row_transfer,
|
||||
)
|
||||
@@ -337,8 +343,8 @@ impl ControlStore {
|
||||
let coll_json = serde_json::to_string(&t.collections).unwrap_or_default();
|
||||
self.conn
|
||||
.execute(
|
||||
"INSERT INTO host_transfer(realm_local_id, transfer_id, character_id, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, created_at, updated_at)
|
||||
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)
|
||||
"INSERT INTO host_transfer(realm_local_id, transfer_id, character_id, ruleset, player_id, revision, content_hash, total_size, received_size, state, local_guid, session_id, projected_level, notes, collections, created_at, updated_at)
|
||||
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17)
|
||||
ON CONFLICT(transfer_id) DO UPDATE SET
|
||||
received_size = excluded.received_size,
|
||||
state = excluded.state,
|
||||
@@ -347,11 +353,13 @@ impl ControlStore {
|
||||
projected_level = excluded.projected_level,
|
||||
notes = excluded.notes,
|
||||
collections = excluded.collections,
|
||||
ruleset = excluded.ruleset,
|
||||
updated_at = excluded.updated_at",
|
||||
params![
|
||||
t.realm_local_id,
|
||||
t.transfer_id.to_string(),
|
||||
t.character_id.to_string(),
|
||||
t.ruleset,
|
||||
t.player_id.to_string(),
|
||||
t.revision as i64,
|
||||
t.content_hash,
|
||||
@@ -540,11 +548,13 @@ fn row_transfer(r: &rusqlite::Row<'_>) -> rusqlite::Result<Result<HostTransfer>>
|
||||
let collections = coll_str
|
||||
.and_then(|s| serde_json::from_str::<BTreeMap<String, Vec<u32>>>(&s).ok())
|
||||
.unwrap_or_default();
|
||||
let ruleset: String = r.get(14).unwrap_or_else(|_| "coa".to_string());
|
||||
Ok((|| {
|
||||
Ok(HostTransfer {
|
||||
realm_local_id,
|
||||
transfer_id: uuid(tid)?,
|
||||
character_id: uuid(cid)?,
|
||||
ruleset,
|
||||
player_id: uuid(pid)?,
|
||||
revision: revision as u64,
|
||||
content_hash,
|
||||
@@ -677,6 +687,7 @@ mod tests {
|
||||
realm_local_id: "live".into(),
|
||||
transfer_id: t,
|
||||
character_id: c,
|
||||
ruleset: "coa".into(),
|
||||
player_id: p,
|
||||
revision: 3,
|
||||
content_hash: "a".repeat(64),
|
||||
|
||||
Reference in new issue
Block a user