Signature scanning in C

#include <stdint.h>
#include <link.h>
#include <dlfcn.h>
#include <stdio.h>

struct our_link_map {
    /* Base from link.h */
    ElfW(Addr) l_addr;
    const char* l_name;
    ElfW(Dyn) * l_ld;
    struct our_link_map* l_next;
    struct our_link_map* l_prev;

    /* Added */
    struct our_link_map* real;
    long int ns;
    struct libname_list* moduleName;
    ElfW(Dyn) *
      info[DT_NUM + DT_VERSIONTAGNUM + DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];
    const ElfW(Phdr) * phdr;
};

void* sigscan(const char* module, const char* pattern) {
    struct our_link_map* link = dlopen(module, RTLD_NOLOAD | RTLD_NOW);
    if (!link) {
        fprintf(stderr, "Can't open module \"%s\"", module);
        return NULL;
    }

    uint8_t* start = (uint8_t*)link->l_addr;
    uint8_t* end   = start + link->phdr[0].p_memsz;

    dlclose(link);

    return do_scan(start, end, pattern);
}

#include <stdbool.h>
#include <stdio.h>  /* fopen(), FILE* */
#include <stdlib.h> /* strtoull() */

typedef struct ModuleBounds {
    void* start;
    void* end;
    struct ModuleBounds* next;
} ModuleBounds;

ModuleBounds* get_module_bounds(const char* module_name) {
    FILE* fd = fopen("/proc/self/maps", "r");
    if (!fd)
        return NULL;

    /* For the first module. Start `ret' as NULL in case no module is valid. */
    ModuleBounds* ret = NULL;
    ModuleBounds* cur = ret;

    /* Buffers used in the loop by fgets() and sscanf() */
    static char line_buf[300];
    static char rwxp[5];
    static char pathname[200];

    while (fgets(line_buf, sizeof(line_buf), fd)) {
        pathname[0] = '\0';

        /* Scan the current line using sscanf(). We need to change address sizes
         * depending on the arch. */
        long unsigned start_num = 0, end_num = 0, offset = 0;
        int fmt_match_num =
          sscanf(line_buf, "%lx-%lx %4s %lx %*x:%*x %*d %200[^\n]\n",
                 &start_num, &end_num, rwxp, &offset, pathname);

        if (fmt_match_num < 4)
            return NULL;

        void* start_addr = (void*)start_num;
        void* end_addr   = (void*)end_num;

        /* Parse "rwxp". For now we only care about read permissions. */
        const bool is_readable = rwxp[0] == 'r';

        /* First, we make sure we got a name, and that it doesn't start with
         * '\0' or '['. Then, either we don't want to filter by module name
         * (module name is NULL) or we checked the module name and it matches. */
        const bool name_matches =
          fmt_match_num == 5 && pathname[0] != '\0' && pathname[0] != '[' &&
          (module_name == NULL || !strcmp(module_name, pathname));

        /* We can read it, and it's the module we are looking for. */
        if (is_readable && name_matches) {
            if (cur == NULL) {
                /* Allocate the first bounds struct */
                cur = (ModuleBounds*)malloc(sizeof(ModuleBounds));

                /* This one will be returned */
                ret = cur;

                /* Save the addresses from this line of maps */
                cur->start = start_addr;
                cur->end   = end_addr;
            } else if (cur->end == start_addr && cur->end < end_addr) {
                /* If the end address of the last struct is the start of this
                 * one, just merge them. */
                cur->end = end_addr;
            } else {
                /* There was a gap between the end of the last block and the
                 * start of this one, allocate new struct. */
                cur->next = (ModuleBounds*)malloc(sizeof(ModuleBounds));

                /* Set as current */
                cur = cur->next;

                /* Save the addresses from this line of maps */
                cur->start = start_addr;
                cur->end   = end_addr;
            }

            /* Indicate the end of the linked list */
            cur->next = NULL;
        }
    }

    fclose(fd);
    return ret;
}

/* Free a linked list of ModuleBounds structures */
void free_module_bounds(ModuleBounds* bounds) {
    ModuleBounds* cur = bounds;
    while (cur != NULL) {
        ModuleBounds* next = cur->next;
        free(cur);
        cur = next;
    }
}

/* Search for `ida_pattern' in the specified `module'. */
void* sigscan(const char* module, const char* ida_pattern) {
    /* Get a linked list of ModuleBounds, containing the start and end addresses
     * of all the regions that match `module'. */
    ModuleBounds* bounds = get_module_bounds(module);

    /* Iterate them, and scan each one until we find a match. */
    void* ret = NULL;
    for (ModuleBounds* cur = bounds; cur != NULL; cur = cur->next) {
        void* cur_result = do_scan(cur->start, cur->end, ida_pattern);

        if (cur_result != NULL) {
            ret = cur_result;
            break;
        }
    }

    /* Free the ModuleBounds linked list */
    free_module_bounds(bounds);

    return ret;
}