fatmach0.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2010-2013 nibble <nibble.ds@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <stdio.h>
#include <rz_types.h>
#include <rz_util.h>
#include "fatmach0.h"
 
static int rz_bin_fatmach0_init(struct rz_bin_fatmach0_obj_t *bin) {
    ut32 size;
    ut32 i;
    ut8 hdrbytes[sizeof(struct fat_header)] = { 0 };
    int len = rz_buf_read_at(bin->b, 0, &hdrbytes[0], sizeof(struct fat_header));
    if (len != sizeof(struct fat_header)) {
        RZ_LOG_ERROR("Cannot read fat_header\n");
        return false;
    }
    bin->hdr.magic = rz_read_be32(&hdrbytes[0]);
    bin->hdr.nfat_arch = rz_read_be32(&hdrbytes[4]);
    bin->nfat_arch = bin->hdr.nfat_arch;
    if (sizeof(struct fat_header) + bin->nfat_arch * sizeof(struct fat_arch) > bin->size) {
        return false;
    }
    if (bin->hdr.magic != FAT_MAGIC || !bin->nfat_arch || bin->nfat_arch < 1) {
        RZ_LOG_ERROR("Invalid FAT_MAGIC\n");
        return false;
    }
    size = bin->nfat_arch * sizeof(struct fat_arch);
    if (size < bin->nfat_arch) {
        return false;
    }
    if (!(bin->archs = malloc(size))) {
        RZ_LOG_ERROR("Cannot allocate fat_arch with size %u bytes\n", size);
        return false;
    }
    for (i = 0; i < bin->nfat_arch; i++) {
        ut8 archbytes[sizeof(struct fat_arch)] = { 0 };
        len = rz_buf_read_at(bin->b, 8 + i * sizeof(struct fat_arch), &archbytes[0], sizeof(struct fat_arch));
        if (len != sizeof(struct fat_arch)) {
            RZ_LOG_ERROR("Cannot read fat_arch\n");
            RZ_FREE(bin->archs);
            return false;
        }
        bin->archs[i].cputype = rz_read_be32(&archbytes[0]);
        bin->archs[i].cpusubtype = rz_read_be32(&archbytes[4]);
        bin->archs[i].offset = rz_read_be32(&archbytes[8]);
        bin->archs[i].size = rz_read_be32(&archbytes[12]);
        bin->archs[i].align = rz_read_be32(&archbytes[16]);
    }
    return true;
}
 
struct rz_bin_fatmach0_arch_t *rz_bin_fatmach0_extract(struct rz_bin_fatmach0_obj_t *bin, int idx, int *narch) {
    if (!bin || (idx < 0) || (idx > bin->nfat_arch)) {
        return NULL;
    }
    if (bin->archs[idx].offset > bin->size ||
        bin->archs[idx].offset + bin->archs[idx].size > bin->size) {
        return NULL;
    }
    if (narch) {
        *narch = bin->nfat_arch;
    }
    struct rz_bin_fatmach0_arch_t *ret = RZ_NEW0(struct rz_bin_fatmach0_arch_t);
    if (ret) {
        ret->size = bin->archs[idx].size;
        if (!ret->size || ret->size > bin->size) {
            eprintf("Skipping corrupted sub-bin %d arch %d\n", idx, bin->archs[idx].size);
            free(ret);
            return NULL;
        }
        ret->offset = bin->archs[idx].offset;
        ret->b = rz_buf_new_slice(bin->b, ret->offset, ret->size);
    }
    return ret;
}
 
void *rz_bin_fatmach0_free(struct rz_bin_fatmach0_obj_t *bin) {
    if (!bin) {
        return NULL;
    }
    free(bin->archs);
    rz_buf_free(bin->b);
    RZ_FREE(bin);
    return NULL;
}
 
struct rz_bin_fatmach0_obj_t *rz_bin_fatmach0_new(const char *file) {
    struct rz_bin_fatmach0_obj_t *bin = RZ_NEW0(struct rz_bin_fatmach0_obj_t);
    if (!bin) {
        return NULL;
    }
    bin->file = file;
    size_t binsz;
    ut8 *buf = (ut8 *)rz_file_slurp(file, &binsz);
    bin->size = binsz;
    if (!buf) {
        return rz_bin_fatmach0_free(bin);
    }
    bin->b = rz_buf_new_with_bytes(NULL, 0);
    if (!rz_buf_set_bytes(bin->b, buf, bin->size)) {
        free(buf);
        return rz_bin_fatmach0_free(bin);
    }
    free(buf);
    if (!rz_bin_fatmach0_init(bin)) {
        return rz_bin_fatmach0_free(bin);
    }
    return bin;
}
 
struct rz_bin_fatmach0_obj_t *rz_bin_fatmach0_from_buffer_new(RzBuffer *b) {
    rz_return_val_if_fail(b, NULL);
    struct rz_bin_fatmach0_obj_t *bo = RZ_NEW0(struct rz_bin_fatmach0_obj_t);
    if (bo) {
        bo->b = rz_buf_ref(b);
        bo->size = rz_buf_size(bo->b); // XXX implicit in bo->b
        if (!rz_bin_fatmach0_init(bo)) {
            return rz_bin_fatmach0_free(bo);
        }
    }
    return bo;
}
 
struct rz_bin_fatmach0_obj_t *rz_bin_fatmach0_from_bytes_new(const ut8 *buf, ut64 size) {
    struct rz_bin_fatmach0_obj_t *bin = RZ_NEW0(struct rz_bin_fatmach0_obj_t);
    if (!bin) {
        return NULL;
    }
    if (!buf) {
        return rz_bin_fatmach0_free(bin);
    }
    bin->b = rz_buf_new_with_bytes(NULL, 0);
    bin->size = size;
    if (!rz_buf_set_bytes(bin->b, buf, size)) {
        return rz_bin_fatmach0_free(bin);
    }
    if (!rz_bin_fatmach0_init(bin)) {
        return rz_bin_fatmach0_free(bin);
    }
    return bin;
}