fn parse_elf()

in src/extract_execute.rs [73:150]
68 lines of code
11 McCabe index (conditional complexity)

fn parse_elf(elf: &elf::Elf, buffer: &[u8]) -> BinaryInfo {
    let mut sections = Vec::new();

    for sh in &elf.section_headers {
        let name = if let Some(name) = elf.shdr_strtab.get_at(sh.sh_name) {
            name.to_string()
        } else {
            String::new()
        };

        let section_info = SectionInfo {
            name,
            virtual_address: sh.sh_addr,
            virtual_size: sh.sh_size,
            raw_address: sh.sh_offset,
            raw_size: sh.sh_size,
            characteristics_num: 0,
            characteristics_str: String::new(),
        };

        sections.push(section_info);
    }
    let architecture = elf::header::machine_to_str(elf.header.e_machine);

    let mut imports: HashMap<String, HashSet<String>> = HashMap::new();
    let mut exports = HashSet::new();

    let mut needed_libraries = Vec::new();
    if let Some(dynamic) = &elf.dynamic {
        needed_libraries = dynamic.get_libraries(&elf.dynstrtab);
    }

    let mut needed_libraries_str = String::new();
    for library in needed_libraries {
        if needed_libraries_str.is_empty() {
            needed_libraries_str = library.to_string();
        } else {
            needed_libraries_str += "\n";
            needed_libraries_str += library;
        }
    }

    let mut imports_str = String::new();

    for dynsym in elf.dynsyms.iter() {
        let Some(name) = elf.dynstrtab.get_at(dynsym.st_name) else {
            continue;
        };
        if name.is_empty() {
            continue;
        }
        if dynsym.is_import() {
            if imports_str.is_empty() {
                imports_str = name.to_string();
            } else {
                imports_str += "\n";
                imports_str += name;
            }
        } else {
            exports.insert(name.to_string());
        }
    }

    imports.insert(needed_libraries_str.clone(), HashSet::new());
    if let Some(entry) = imports.get_mut(&needed_libraries_str) {
        entry.insert(imports_str);
    }

    BinaryInfo {
        format: "ELF".to_string(),
        entry: format!("0x{:x}", elf.header.e_entry),
        architecture: architecture.to_string(),
        size: buffer.len() as u64,
        sections,
        imports,
        exports,
    }
}