Struct ProguardCache

Source

pub struct ProguardCache<'data> { /* private fields */ }

Expand description

The serialized ProguardCache binary format.

Implementations§

Source §

impl<'data> ProguardCache<'data>

Source

pub fn debug_classes<'r>( &'r self, ) -> impl Iterator<Item = ClassDebug<'r, 'data>>

Returns an iterator over class entries in this cache file that can be debug printed.

Source

pub fn debug_members<'r>( &'r self, ) -> impl Iterator<Item = MemberDebug<'r, 'data>>

Returns an iterator over member entries in this cache file that can be debug printed.

Source

pub fn debug_members_by_params<'r>( &'r self, ) -> impl Iterator<Item = MemberDebug<'r, 'data>>

Returns an iterator over by-params member entries in this cache file that can be debug printed.

Source

pub fn display(&self) -> CacheDebug<'_, '_>

Creates a view of the cache that implements Display.

The Display impl is very similar to the original proguard format.

Source §

impl<'data> ProguardCache<'data>

Source

pub fn parse(buf: &'data [u8]) -> Result<Self, CacheError>

Parses a ProguardCache out of bytes.

Source

pub fn write<W: Write>( mapping: &ProguardMapping<'_>, writer: &mut W, ) -> Result<()>

Writes a ProguardMapping into a writer in the proguard cache format.

Source

pub fn test(&self)

Tests the integrity of this cache.

Specifically it checks the following:

All string offsets in class and member entries are either u32::MAX or defined.
Member entries are ordered by the class they belong to.
All is_synthesized fields on classes and members are either 0 or 1.

Source §

impl<'data> ProguardCache<'data>

Source

pub fn remap_class(&self, class: &str) -> Option<&'data str>

Remaps an obfuscated Class.

This works on the fully-qualified name of the class, with its complete module prefix.

§Examples

use proguard::{ProguardMapping, ProguardCache};
let mapping = ProguardMapping::new(br#"android.arch.core.executor.ArchTaskExecutor -> a.a.a.a.c:"#);
let mut cache = Vec::new();
ProguardCache::write(&mapping, &mut cache).unwrap();
let cache = ProguardCache::parse(&cache).unwrap();

let mapped = cache.remap_class("a.a.a.a.c");
assert_eq!(mapped, Some("android.arch.core.executor.ArchTaskExecutor"));

Source

pub fn remap_method( &self, class: &str, method: &str, ) -> Option<(&'data str, &'data str)>

Remaps an obfuscated Class Method.

The class argument has to be the fully-qualified obfuscated name of the class, with its complete module prefix.

If the method can be resolved unambiguously, it will be returned alongside the remapped class, otherwise None is being returned.

Source

pub fn remap_frame<'r: 'data>( &'r self, frame: &StackFrame<'data>, ) -> RemappedFrameIter<'r, 'data>

Remaps a single Stackframe.

Returns zero or more StackFrames, based on the information in the proguard mapping. This can return more than one frame in the case of inlined functions. In that case, frames are sorted top to bottom.

Source

pub fn remap_frame_with_context<'r>( &'r self, frame: &StackFrame<'data>, exception_descriptor: Option<&str>, apply_rewrite: bool, carried_outline_pos: &mut Option<usize>, ) -> Option<RemappedFrameIter<'r, 'data>>
where 'r: 'data,

Remaps a single stack frame through the complete processing pipeline.

This method combines:

Outline frame detection via is_outline_frame
Frame preparation via prepare_frame_for_mapping
Lazy frame remapping with rewrite rules applied via skip_count

§Arguments

frame - The frame to remap
exception_descriptor - Optional exception descriptor for rewrite rules (e.g., Ljava/lang/NullPointerException;)
apply_rewrite - Whether to apply rewrite rules (typically true only for the first frame after an exception)
carried_outline_pos - Mutable reference to track outline position across frames

§Returns

None if this is an outline frame (caller should skip, carried_outline_pos is updated internally)
Some(iterator) with remapped frames. Use [RemappedFrameIter::had_mappings] after collecting to detect if rewrite rules cleared all frames (skip if had_mappings() && collected.is_empty())

Source

pub fn remap_throwable<'a>( &'a self, throwable: &Throwable<'a>, ) -> Option<Throwable<'a>>

Remaps a throwable which is the first line of a full stacktrace.

§Example

use proguard::{ProguardMapping, ProguardCache, Throwable};

let mapping = ProguardMapping::new(b"com.example.Mapper -> a.b:");
let mut cache = Vec::new();
ProguardCache::write(&mapping, &mut cache).unwrap();
let cache = ProguardCache::parse(&cache).unwrap();

let throwable = Throwable::try_parse(b"a.b: Crash").unwrap();
let mapped = cache.remap_throwable(&throwable);

assert_eq!(
    Some(Throwable::with_message("com.example.Mapper", "Crash")),
    mapped
);

Source

pub fn is_outline_frame(&self, class: &str, method: &str) -> bool

Determines if a frame refers to an outline method via the method-level flag. Outline metadata is consistent across all mapping entries for a method, so we only need to inspect the method metadata instead of individual lines.

Source