mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 03:25:56 +00:00
Settings gets two options, one per extra realm; turning on both runs all three realms. Each extra world keeps its own folder, configs, logs and ports (multiworld now handles a set of worlds instead of one second world), and Warcraft Reborn gets its own status card, realm list entry and firewall rule. Starting a server also sets CoA.ClassModel of the realm chosen on Overview to exactly that realm's model, so the shipped "coa wcr" default no longer shows two class models on a Conquest of Azeroth realm. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
569 lines
20 KiB
Rust
569 lines
20 KiB
Rust
//! "Play with Friends": which address friends use, opening the login/world servers to the network (and only those),
|
|
//! keeping the realm's advertised address right after every start, and the small package a friend needs.
|
|
|
|
use std::fs;
|
|
use std::io::Write;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::config::parser::ConfFile;
|
|
use crate::config::{take_snapshot, Scope};
|
|
use crate::db::{Account, Db};
|
|
use crate::error::{Error, Result};
|
|
use crate::fsx;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum Mode {
|
|
/// Only this computer.
|
|
Local,
|
|
/// Friends on the same home network.
|
|
Lan,
|
|
/// Friends over the internet through this connection (needs open ports).
|
|
Direct,
|
|
/// Friends join a private network (Tailscale); no router setup.
|
|
Private,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Settings {
|
|
pub mode: Mode,
|
|
/// The address friends type into their client for this mode.
|
|
pub host: Option<String>,
|
|
/// Independent of the effective host of the current mode. None means automatic LAN detection.
|
|
#[serde(default)]
|
|
pub lan_address_override: Option<String>,
|
|
}
|
|
|
|
impl Default for Settings {
|
|
fn default() -> Self {
|
|
Settings {
|
|
mode: Mode::Local,
|
|
host: None,
|
|
lan_address_override: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Settings {
|
|
/// Only LAN application changes the LAN preference. Other modes keep it for the next LAN session.
|
|
pub fn select_mode(&mut self, mode: Mode, host: String, lan_override: Option<String>) {
|
|
if mode == Mode::Lan {
|
|
self.lan_address_override = lan_override;
|
|
}
|
|
self.mode = mode;
|
|
self.host = Some(host);
|
|
}
|
|
}
|
|
|
|
fn file(meta: &Path) -> PathBuf {
|
|
meta.join("friends.json")
|
|
}
|
|
|
|
pub fn load(meta: &Path) -> Settings {
|
|
fsx::read_json(&file(meta)).unwrap_or_default()
|
|
}
|
|
|
|
pub fn save(meta: &Path, s: &Settings) -> Result<()> {
|
|
fsx::atomic_write_json(&file(meta), s)
|
|
}
|
|
|
|
fn host_ok(h: &str) -> bool {
|
|
!h.is_empty()
|
|
&& h.len() <= 253
|
|
&& h.chars()
|
|
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-'))
|
|
&& !h.starts_with('-')
|
|
}
|
|
|
|
/// The files whose `BindIP` decides who can reach the login and world servers.
|
|
fn bind_targets(root: &Path) -> Vec<PathBuf> {
|
|
[
|
|
"Settings/worldserver.conf.template",
|
|
"Core/configs/worldserver.conf",
|
|
"Settings/authserver.conf.template",
|
|
"Core/configs/authserver.conf",
|
|
]
|
|
.iter()
|
|
.map(|r| root.join(r))
|
|
.filter(|p| p.is_file())
|
|
.collect()
|
|
}
|
|
|
|
/// Whether the configuration currently lets other computers reach the login and world servers.
|
|
pub fn bind_is_open(root: &Path) -> bool {
|
|
if crate::docker::is_docker(root) {
|
|
return crate::docker::bind_is_open(root);
|
|
}
|
|
let files = bind_targets(root);
|
|
!files.is_empty()
|
|
&& files.iter().all(|p| {
|
|
fs::read(p)
|
|
.ok()
|
|
.and_then(|b| ConfFile::parse_bytes(&b).ok())
|
|
.and_then(|c| c.get("BindIP").map(|v| v.trim() == "\"0.0.0.0\""))
|
|
.unwrap_or(false)
|
|
})
|
|
}
|
|
|
|
/// Open (`0.0.0.0`) or close (`127.0.0.1`) the login and world servers to other computers. The database and the server
|
|
/// console are never touched. Returns true if anything changed (a restart is then needed). The old files are snapshotted.
|
|
pub fn set_open(root: &Path, meta: &Path, open: bool) -> Result<bool> {
|
|
if crate::docker::is_docker(root) {
|
|
return crate::docker::set_open(root, meta, open);
|
|
}
|
|
let want = if open { "\"0.0.0.0\"" } else { "\"127.0.0.1\"" };
|
|
let mut originals = Vec::new();
|
|
let mut edits = Vec::new();
|
|
for p in bind_targets(root) {
|
|
let bytes = fs::read(&p)?;
|
|
let mut conf = ConfFile::parse_bytes(&bytes)?;
|
|
if conf.get("BindIP").map(str::trim) == Some(want) {
|
|
continue;
|
|
}
|
|
conf.set("BindIP", want, &["Added by CoA Server Manager"]);
|
|
originals.push((p.clone(), bytes));
|
|
edits.push((p, conf.to_text()));
|
|
}
|
|
// Friends connect from other addresses, and the server only applies the CoA client protocol (extension packets,
|
|
// header mode) to loopback unless remote clients are allowed - so sharing must switch that on as well.
|
|
let coa_conf = root.join("Core/configs/modules/coa.conf");
|
|
if let Ok(bytes) = fs::read(&coa_conf) {
|
|
let mut conf = ConfFile::parse_bytes(&bytes)?;
|
|
// Opening turns it on; closing leaves it alone (it only matters while the servers listen beyond this computer).
|
|
if open && conf.get("CoA.AllowRemoteClients").map(str::trim) != Some("1") {
|
|
conf.set(
|
|
"CoA.AllowRemoteClients",
|
|
"1",
|
|
&["Set by CoA Server Manager together with the friends mode"],
|
|
);
|
|
originals.push((coa_conf.clone(), bytes));
|
|
edits.push((coa_conf, conf.to_text()));
|
|
}
|
|
}
|
|
if edits.is_empty() {
|
|
return Ok(false);
|
|
}
|
|
take_snapshot(
|
|
meta,
|
|
Scope::Server,
|
|
if open {
|
|
"before opening the servers to friends"
|
|
} else {
|
|
"before closing the servers to friends"
|
|
},
|
|
&originals,
|
|
)?;
|
|
for (p, text) in edits {
|
|
fsx::atomic_write(&p, text.as_bytes())?;
|
|
}
|
|
Ok(true)
|
|
}
|
|
|
|
/// Make the realm list advertise `host` to remote clients (the launcher resets it to 127.0.0.1 at every start, so this
|
|
/// runs after each start).
|
|
fn realm_address_sql(
|
|
host: &str,
|
|
local: Option<(std::net::Ipv4Addr, std::net::Ipv4Addr)>,
|
|
where_realms: &str,
|
|
) -> Result<String> {
|
|
if !host_ok(host) {
|
|
return Err(Error::Invalid("That address is not valid.".into()));
|
|
}
|
|
let local = local
|
|
.map(|(address, mask)| format!(",localAddress='{address}',localSubnetMask='{mask}'"))
|
|
.unwrap_or_default();
|
|
Ok(format!(
|
|
"UPDATE acore_auth.realmlist SET address='{host}'{local} WHERE {where_realms};"
|
|
))
|
|
}
|
|
|
|
pub fn apply_realm_address(root: &Path, settings: &Settings) -> Result<()> {
|
|
let host = settings.host.as_deref().unwrap_or("127.0.0.1");
|
|
let local = match settings.mode {
|
|
Mode::Direct | Mode::Lan => {
|
|
let address = if settings.mode == Mode::Lan {
|
|
host.to_owned()
|
|
} else {
|
|
crate::net::resolve_lan_host(
|
|
settings.lan_address_override.as_deref(),
|
|
crate::net::lan_ip(),
|
|
)?
|
|
};
|
|
let address = crate::net::validate_lan_address(&address)?;
|
|
let mask = if_addrs::get_if_addrs()?
|
|
.into_iter()
|
|
.find_map(|interface| match interface.addr {
|
|
if_addrs::IfAddr::V4(v4) if v4.ip == address => Some(v4.netmask),
|
|
_ => None,
|
|
})
|
|
.ok_or_else(|| {
|
|
Error::Invalid("The selected local network address is not connected.".into())
|
|
})?;
|
|
Some((address, mask))
|
|
}
|
|
Mode::Local => Some((
|
|
std::net::Ipv4Addr::LOCALHOST,
|
|
std::net::Ipv4Addr::new(255, 0, 0, 0),
|
|
)),
|
|
Mode::Private => None,
|
|
};
|
|
let db = Db::from_repack(root, Account::Admin)?;
|
|
let state = crate::realms::state(root)?;
|
|
let mut ids = vec![state.active];
|
|
ids.extend(state.extra_modes());
|
|
let where_realms = format!(
|
|
"id IN ({})",
|
|
ids.iter()
|
|
.map(|m| m.realm_id().to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(",")
|
|
);
|
|
db.query(&realm_address_sql(host, local, &where_realms)?)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Before every server start: when the owner shares the server with friends, make sure the login and world servers
|
|
/// listen on all addresses. The launcher's own tools (for example switching detailed logging off) restore the config
|
|
/// templates from older copies and would silently put `BindIP` back to 127.0.0.1 while the realm list still advertises
|
|
/// the shared address - the game then shows the realm and drops back to the login screen without any message.
|
|
pub fn ensure_bind(root: &Path, meta: &Path) -> Result<bool> {
|
|
match load(meta).mode {
|
|
Mode::Local => Ok(false),
|
|
_ => set_open(root, meta, true),
|
|
}
|
|
}
|
|
|
|
/// After every server start: put the chosen address back into the realm list (the launcher resets it to 127.0.0.1).
|
|
pub fn reapply(root: &Path, meta: &Path) -> Result<()> {
|
|
let s = load(meta);
|
|
match (s.mode, &s.host) {
|
|
(Mode::Local, _) | (_, None) => Ok(()),
|
|
(_, Some(_)) => apply_realm_address(root, &s),
|
|
}
|
|
}
|
|
|
|
/// Build the friend's package: instructions, a ready realmlist file and (optionally) the companion addon.
|
|
/// Only whitelisted content goes in - never credentials, configuration or database files.
|
|
pub fn make_friend_package(
|
|
root: &Path,
|
|
host: &str,
|
|
include_addon: bool,
|
|
out_zip: &Path,
|
|
) -> Result<()> {
|
|
if !host_ok(host) {
|
|
return Err(Error::Invalid("That address is not valid.".into()));
|
|
}
|
|
let file = fs::File::create(out_zip)?;
|
|
let mut zip = zip::ZipWriter::new(file);
|
|
let opts = zip::write::SimpleFileOptions::default()
|
|
.compression_method(zip::CompressionMethod::Deflated);
|
|
let mut add = |name: &str, bytes: &[u8]| -> Result<()> {
|
|
zip.start_file(name, opts)
|
|
.map_err(|e| Error::Invalid(e.to_string()))?;
|
|
zip.write_all(bytes)?;
|
|
Ok(())
|
|
};
|
|
add(
|
|
"HOW-TO-CONNECT.txt",
|
|
crate::net::instructions(host)
|
|
.replace('\n', "\r\n")
|
|
.as_bytes(),
|
|
)?;
|
|
add(
|
|
"realmlist.wtf",
|
|
format!("set realmlist {host}\r\n").as_bytes(),
|
|
)?;
|
|
if include_addon {
|
|
if let Some(src) = crate::client::addon_source(root) {
|
|
let mut stack = vec![src.clone()];
|
|
while let Some(dir) = stack.pop() {
|
|
for e in fs::read_dir(&dir)? {
|
|
let p = e?.path();
|
|
if p.is_dir() {
|
|
stack.push(p);
|
|
} else {
|
|
let rel = p
|
|
.strip_prefix(&src)
|
|
.unwrap()
|
|
.to_string_lossy()
|
|
.replace('\\', "/");
|
|
add(&format!("Interface/AddOns/CoABotUI/{rel}"), &fs::read(&p)?)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
zip.finish().map_err(|e| Error::Invalid(e.to_string()))?;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn setup() -> (tempfile::TempDir, PathBuf, PathBuf) {
|
|
let d = tempfile::tempdir().unwrap();
|
|
let root = d.path().join("srv");
|
|
let meta = d.path().join("srv.manager");
|
|
fs::create_dir_all(root.join("Settings")).unwrap();
|
|
fs::create_dir_all(root.join("Core/configs")).unwrap();
|
|
fs::create_dir_all(&meta).unwrap();
|
|
for (f, body) in [
|
|
(
|
|
"Settings/worldserver.conf.template",
|
|
"[worldserver]\r\nBindIP = \"127.0.0.1\"\r\nRa.IP = \"127.0.0.1\"\r\n",
|
|
),
|
|
(
|
|
"Core/configs/worldserver.conf",
|
|
"[worldserver]\r\nBindIP = \"127.0.0.1\"\r\nRa.IP = \"127.0.0.1\"\r\n",
|
|
),
|
|
(
|
|
"Settings/authserver.conf.template",
|
|
"[authserver]\nBindIP = \"127.0.0.1\"\n",
|
|
),
|
|
(
|
|
"Core/configs/authserver.conf",
|
|
"[authserver]\nBindIP = \"127.0.0.1\"\n",
|
|
),
|
|
] {
|
|
fs::write(root.join(f), body).unwrap();
|
|
}
|
|
(d, root, meta)
|
|
}
|
|
|
|
#[test]
|
|
fn opening_changes_only_bind_ip_of_login_and_world_and_never_the_console() {
|
|
let (_d, root, meta) = setup();
|
|
assert!(set_open(&root, &meta, true).unwrap());
|
|
let w = fs::read_to_string(root.join("Core/configs/worldserver.conf")).unwrap();
|
|
assert_eq!(
|
|
w, "[worldserver]\r\nBindIP = \"0.0.0.0\"\r\nRa.IP = \"127.0.0.1\"\r\n",
|
|
"console address untouched, line endings kept"
|
|
);
|
|
assert_eq!(
|
|
fs::read_to_string(root.join("Settings/authserver.conf.template")).unwrap(),
|
|
"[authserver]\nBindIP = \"0.0.0.0\"\n"
|
|
);
|
|
assert!(!set_open(&root, &meta, true).unwrap(), "idempotent");
|
|
assert!(
|
|
crate::config::list_snapshots(&meta)
|
|
.iter()
|
|
.any(|s| s.reason.contains("opening")),
|
|
"a snapshot was taken first"
|
|
);
|
|
assert!(set_open(&root, &meta, false).unwrap());
|
|
assert!(
|
|
fs::read_to_string(root.join("Core/configs/worldserver.conf"))
|
|
.unwrap()
|
|
.contains("BindIP = \"127.0.0.1\"")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn sharing_also_allows_remote_coa_clients_and_closing_leaves_it() {
|
|
let (_d, root, meta) = setup();
|
|
let coa = root.join("Core/configs/modules/coa.conf");
|
|
fs::create_dir_all(coa.parent().unwrap()).unwrap();
|
|
fs::write(
|
|
&coa,
|
|
"CoA.Enable = 1
|
|
CoA.AllowRemoteClients = 0
|
|
",
|
|
)
|
|
.unwrap();
|
|
assert!(set_open(&root, &meta, true).unwrap());
|
|
assert!(fs::read_to_string(&coa)
|
|
.unwrap()
|
|
.contains("CoA.AllowRemoteClients = 1"));
|
|
assert!(fs::read_to_string(&coa).unwrap().contains("CoA.Enable = 1"));
|
|
assert!(set_open(&root, &meta, false).unwrap());
|
|
assert!(
|
|
fs::read_to_string(&coa)
|
|
.unwrap()
|
|
.contains("CoA.AllowRemoteClients = 1"),
|
|
"closing only changes BindIP"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_shared_server_gets_its_bind_address_back_before_start_and_a_local_one_is_left_alone() {
|
|
let (_d, root, meta) = setup();
|
|
assert!(
|
|
!ensure_bind(&root, &meta).unwrap(),
|
|
"local mode: nothing to do"
|
|
);
|
|
save(
|
|
&meta,
|
|
&Settings {
|
|
mode: Mode::Private,
|
|
host: Some("100.64.1.2".into()),
|
|
..Settings::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
ensure_bind(&root, &meta).unwrap(),
|
|
"templates were reset to 127.0.0.1 -> reopened"
|
|
);
|
|
assert!(bind_is_open(&root));
|
|
assert!(
|
|
!ensure_bind(&root, &meta).unwrap(),
|
|
"already open: idempotent"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn settings_round_trip_and_default_to_local() {
|
|
let d = tempfile::tempdir().unwrap();
|
|
assert_eq!(load(d.path()).mode, Mode::Local);
|
|
save(
|
|
d.path(),
|
|
&Settings {
|
|
mode: Mode::Private,
|
|
host: Some("100.64.1.2".into()),
|
|
..Settings::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
let s = load(d.path());
|
|
assert_eq!(
|
|
(s.mode, s.host.as_deref()),
|
|
(Mode::Private, Some("100.64.1.2"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn realm_addresses_restore_lan_without_replacing_public_host() {
|
|
let sql = realm_address_sql(
|
|
"203.0.113.9",
|
|
Some((
|
|
"192.168.50.7".parse().unwrap(),
|
|
"255.255.254.0".parse().unwrap(),
|
|
)),
|
|
"id IN (1,2)",
|
|
)
|
|
.unwrap();
|
|
assert_eq!(sql, "UPDATE acore_auth.realmlist SET address='203.0.113.9',localAddress='192.168.50.7',localSubnetMask='255.255.254.0' WHERE id IN (1,2);");
|
|
assert_eq!(
|
|
realm_address_sql("100.64.1.2", None, "id=1").unwrap(),
|
|
"UPDATE acore_auth.realmlist SET address='100.64.1.2' WHERE id=1;"
|
|
);
|
|
assert!(realm_address_sql("bad'host", None, "id=1").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn old_settings_load_without_migrating_effective_host_to_override() {
|
|
let s: Settings = serde_json::from_str(r#"{"mode":"lan","host":"192.168.1.50"}"#).unwrap();
|
|
assert_eq!(s.mode, Mode::Lan);
|
|
assert_eq!(s.host.as_deref(), Some("192.168.1.50"));
|
|
assert_eq!(s.lan_address_override, None);
|
|
}
|
|
|
|
#[test]
|
|
fn lan_preference_survives_save_load_and_every_other_mode_and_can_be_cleared() {
|
|
let d = tempfile::tempdir().unwrap();
|
|
let mut s = Settings::default();
|
|
s.select_mode(
|
|
Mode::Lan,
|
|
"192.168.1.50".into(),
|
|
Some("192.168.1.50".into()),
|
|
);
|
|
for (mode, host) in [
|
|
(Mode::Private, "100.101.20.5"),
|
|
(Mode::Direct, "203.0.113.9"),
|
|
(Mode::Local, "127.0.0.1"),
|
|
] {
|
|
s.select_mode(mode, host.into(), None);
|
|
save(d.path(), &s).unwrap();
|
|
s = load(d.path());
|
|
assert_eq!(s.lan_address_override.as_deref(), Some("192.168.1.50"));
|
|
assert_eq!(s.host.as_deref(), Some(host));
|
|
let lan = crate::net::resolve_lan_host(
|
|
s.lan_address_override.as_deref(),
|
|
Some("192.168.0.169".parse().unwrap()),
|
|
)
|
|
.unwrap();
|
|
s.select_mode(Mode::Lan, lan, s.lan_address_override.clone());
|
|
assert_eq!(s.host.as_deref(), Some("192.168.1.50"));
|
|
}
|
|
s.select_mode(Mode::Lan, "192.168.0.169".into(), None);
|
|
save(d.path(), &s).unwrap();
|
|
assert_eq!(load(d.path()).lan_address_override, None);
|
|
}
|
|
|
|
#[test]
|
|
fn friend_package_contains_only_whitelisted_files() {
|
|
let (d, root, _m) = setup();
|
|
fs::write(
|
|
root.join("Settings/database.json"),
|
|
"{\"rootPassword\":\"SECRET\"}",
|
|
)
|
|
.unwrap();
|
|
fs::write(
|
|
root.join("Settings/repack.json"),
|
|
"{\"raPassword\":\"SECRET\"}",
|
|
)
|
|
.unwrap();
|
|
let addon = root.join("Extras/CoABotUI");
|
|
fs::create_dir_all(addon.join("Libs")).unwrap();
|
|
fs::write(addon.join("CoABotUI.toc"), "## Version: 1").unwrap();
|
|
fs::write(addon.join("Libs/x.lua"), "-- lib").unwrap();
|
|
let out = d.path().join("friend.zip");
|
|
make_friend_package(&root, "203.0.113.7", true, &out).unwrap();
|
|
let mut z = zip::ZipArchive::new(fs::File::open(&out).unwrap()).unwrap();
|
|
let names: Vec<String> = (0..z.len())
|
|
.map(|i| z.by_index(i).unwrap().name().to_string())
|
|
.collect();
|
|
assert!(
|
|
names.contains(&"HOW-TO-CONNECT.txt".to_string())
|
|
&& names.contains(&"realmlist.wtf".to_string())
|
|
);
|
|
assert!(names.contains(&"Interface/AddOns/CoABotUI/Libs/x.lua".to_string()));
|
|
assert!(
|
|
!names
|
|
.iter()
|
|
.any(|n| n.contains("database") || n.contains("repack") || n.contains("conf")),
|
|
"{names:?}"
|
|
);
|
|
let mut realm = String::new();
|
|
std::io::Read::read_to_string(&mut z.by_name("realmlist.wtf").unwrap(), &mut realm)
|
|
.unwrap();
|
|
assert_eq!(realm, "set realmlist 203.0.113.7\r\n");
|
|
for i in 0..z.len() {
|
|
let mut body = String::new();
|
|
let _ = std::io::Read::read_to_string(&mut z.by_index(i).unwrap(), &mut body);
|
|
assert!(!body.contains("SECRET"));
|
|
}
|
|
assert!(make_friend_package(&root, "bad host; x", false, &d.path().join("x.zip")).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn manual_lan_host_survives_startup_bind_restoration_and_drives_friend_package() {
|
|
let (d, root, meta) = setup();
|
|
let mut s = Settings::default();
|
|
s.select_mode(
|
|
Mode::Lan,
|
|
"192.168.1.50".into(),
|
|
Some("192.168.1.50".into()),
|
|
);
|
|
save(&meta, &s).unwrap();
|
|
assert!(ensure_bind(&root, &meta).unwrap());
|
|
assert!(bind_is_open(&root));
|
|
let restored = load(&meta);
|
|
assert_eq!(restored.host.as_deref(), Some("192.168.1.50"));
|
|
assert_eq!(
|
|
restored.lan_address_override.as_deref(),
|
|
Some("192.168.1.50")
|
|
);
|
|
let package = d.path().join("manual-lan.zip");
|
|
make_friend_package(&root, restored.host.as_deref().unwrap(), false, &package).unwrap();
|
|
let mut zip = zip::ZipArchive::new(fs::File::open(package).unwrap()).unwrap();
|
|
let mut realm = String::new();
|
|
std::io::Read::read_to_string(&mut zip.by_name("realmlist.wtf").unwrap(), &mut realm)
|
|
.unwrap();
|
|
assert_eq!(realm, "set realmlist 192.168.1.50\r\n");
|
|
}
|
|
}
|