rmcl 0.6.2

A fully featured Minecraft TUI launcher
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

// SPDX-FileCopyrightText: 2026 Constantin Bauer
// SPDX-License-Identifier: GPL-3.0-only

use std::io::Read;
use std::path::{Path, PathBuf};

const MAX_PACK_MANIFEST_BYTES: u64 = 8 * 1024 * 1024;

pub(super) fn read_pack_manifest(reader: impl Read) -> Result<Vec<u8>, String> {
    let mut bytes = Vec::new();
    reader
        .take(MAX_PACK_MANIFEST_BYTES + 1)
        .read_to_end(&mut bytes)
        .map_err(|error| error.to_string())?;
    if bytes.len() as u64 > MAX_PACK_MANIFEST_BYTES {
        return Err("Pack manifest exceeds 8 MiB".to_owned());
    }
    Ok(bytes)
}

fn relative_path(
    entry: &zip::read::ZipFile<'_, std::fs::File>,
    root: &str,
) -> Result<Option<PathBuf>, String> {
    let root = root.trim_matches('/');
    if root.is_empty() || !entry.name().starts_with(&format!("{root}/")) {
        return Ok(None);
    }
    let enclosed = entry
        .enclosed_name()
        .ok_or_else(|| format!("Unsafe override path: {}", entry.name()))?;
    let relative = enclosed
        .strip_prefix(root)
        .map_err(|_| format!("Invalid override path: {}", entry.name()))?;
    if relative.as_os_str().is_empty() {
        return Ok(Some(relative.to_owned()));
    }
    let relative = relative
        .to_str()
        .ok_or_else(|| "Override path is not UTF-8".to_owned())?;
    Ok(Some(PathBuf::from(super::portable_pack_path(relative)?)))
}

pub(super) fn override_files(path: &Path, roots: &[&str]) -> Result<Vec<PathBuf>, String> {
    let file = std::fs::File::open(path).map_err(|error| error.to_string())?;
    let mut archive = zip::ZipArchive::new(file).map_err(|error| error.to_string())?;
    let mut files = Vec::new();
    for index in 0..archive.len() {
        let entry = archive.by_index(index).map_err(|error| error.to_string())?;
        if entry.is_dir() {
            continue;
        }
        for root in roots {
            if let Some(relative) = relative_path(&entry, root)?
                && !relative.as_os_str().is_empty()
            {
                files.push(relative);
                break;
            }
        }
    }
    Ok(files)
}

pub(super) fn extract_overrides(
    path: &Path,
    destination: &Path,
    roots: &[&str],
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let file = std::fs::File::open(path)?;
    let mut archive = zip::ZipArchive::new(file)?;
    // Later roots override earlier ones, independently of ZIP entry order.
    for root in roots {
        for index in 0..archive.len() {
            let mut entry = archive.by_index(index)?;
            let Some(relative) = relative_path(&entry, root)? else {
                continue;
            };
            let target = destination.join(relative);
            if entry.is_dir() {
                std::fs::create_dir_all(&target)?;
                continue;
            }
            if let Some(parent) = target.parent() {
                std::fs::create_dir_all(parent)?;
            }
            let mut file = std::fs::File::create(&target)?;
            let size = std::io::copy(&mut entry, &mut file)?;
            tracing::trace!(
                "Extracted {} to {} ({} bytes)",
                entry.name(),
                target.display(),
                size
            );
        }
    }
    Ok(())
}