Universal-Debloater-Alliance/universal-android-debloater-next-generation · error

remote list is bigger than 8MiB

Error message

remote list is bigger than 8MiB

What it means

load_debloat_lists downloads the remote debloat list JSON via an HTTP client whose body reader is configured with an 8 MiB limit (1 << 20 * 8). If the remote response exceeds that limit, the reader returns an error and `.expect("remote list is bigger than 8MiB")` panics. It is a deliberate size guard: the app refuses to consume an unexpectedly huge (or hostile) remote list.

Solutions

1. Bump the limit, e.g. `.limit(1 << (4 + 10 + 10))` (16 MiB) or make it configurable, to track the real list size.
2. Handle the body-read error instead of expecting: return OperationResult::Retry with a warn! so the app falls back to the cached list.
3. Stream the response to disk with a cap rather than reading the whole body into a String.
4. Pin/check the remote list URL is the official endpoint and not a redirect target.

Example fix

// before
.read_to_string()
.expect("remote list is bigger than 8MiB");
// after
.read_to_string()
.unwrap_or_else(|e| {
    warn!("Failed to read remote list (limit 8MiB): {e}");
    String::new()
})

let resp = reqwest::get(LIST_URL).await?;
let len = resp.content_length().unwrap_or(0);
if len > 8 * 1024 * 1024 {
    eprintln!("remote list too large: {len} bytes; falling back to cache");
}

match data.body_mut().with_config().limit(8 * 1024 * 1024).read_to_string() {
    Ok(text) => cache_and_use(&text),
    Err(e) => { warn!("remote list unreadable/oversized: {e}"); use_cached_list() }
}

When it happens

Trigger: Calling load_debloat_lists (directly or via update_lists / list_packages / init_apps_view) when the remote list endpoint serves a body larger than 8 MiB — e.g. the upstream list file has grown past 8 MiB, a mirror/proxy returns an error page or concatenated content, or DNS/captive-portal redirects the request to an HTML page that balloons the body.

Common situations: A UAD release used long after the remote debloat list grew beyond the hard-coded 8 MiB cap; corporate proxies intercepting the request and returning large HTML; a user pointing the list URL at a different, much larger JSON file.

Understand the failure class

Background: payload too large / request exceeds maximum size: why libraries cap bytes and how to fix oversize payloads — this error's family across 50 libraries.

Related errors

• Unable to parse
• {e}
• There must be 1 tab after serial
• There must be at least 1 ':'-separated component
• string assumed to be UID numeral

AI-assisted analysis of Universal-Debloater-Alliance/universal-android-debloater-next-generation@64465c850c (2026-09-12). Data as JSON: /api/errors/14b8afc1da4138be. Report an issue: GitHub.

Appendix: source

Thrown at crates/uad-core/src/uad_lists.rs:230

            match ureq::get(format!(
                "https://raw.githubusercontent.com\
                    /Universal-Debloater-Alliance\
                    /universal-android-debloater\
                    /main\
                    /resources\
                    /assets\
                    /{LIST_FNAME}"
            ))
            .call()
            {
                Ok(mut data) => {
                    // https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation/discussions/608
                    let text = data
                        .body_mut()
                        .with_config()
                        .limit(1 << (3 + 10 + 10))
                        .read_to_string()
                        .expect("remote list is bigger than 8MiB");
                    fs::write(cached_uad_lists.clone(), &text).expect("Unable to write file");
                    let list: PackageHashMap =
                        serde_json::from_str(&text).expect("Unable to parse");
                    OperationResult::Ok(list)
                }
                Err(e) => {
                    warn!("Could not load remote debloat list: {e}");
                    error = true;
                    OperationResult::Retry(PackageHashMap::new())
                }
            }
        })
        .unwrap_or_else(|_| get_local_lists())
    } else {
        warn!("Could not load remote debloat list");
        get_local_lists()
    };

View on GitHub (pinned to 64465c850c)