---

melf.h

/*
 * ELF manipulation library
 *
 * skape
 * [email protected]
 */
#ifndef _MELF_H
#define _MELF_H

#ifdef MELF_COMP
        #include "stdelf.h"
#else
        #include <stdelf.h>
#endif

#define IS_OVERFLOW(melf, base, addr) ((melf)->imageSize < ((unsigned long)(addr) - (unsigned long)(base)))

#define MELF_ACCESS_READ            (1 << 0)

#define MELF_ACCESS_WRITE           (1 << 1)

#define MELF_ACCESS_ALL             (MELF_ACCESS_READ | MELF_ACCESS_WRITE)

#define MELF_HAS_ACCESS(ctx, flag)  ((ctx)->access & (flag))

enum ElfHeaderType
{
        ELF_HEADER_TYPE_SECTION = 0,
        ELF_HEADER_TYPE_PROGRAM = 1,
};

typedef struct _elf_spec_header {

        unsigned long           index;
        unsigned long           identifier;
        enum ElfHeaderType      type;

        union
        {

                Elf32_Shdr section;
                Elf32_Phdr program;

        } spec;

        void                    *content;
        unsigned long           contentLength;

        void                    *contentListHead;
        void                    *contentListTail;
        unsigned long           contentListSize;

        struct _elf_spec_header *prev;
        struct _elf_spec_header *next;

} ELF_SPEC_HEADER;

typedef struct _elf_spec_header_list {

        ELF_SPEC_HEADER *head;
        ELF_SPEC_HEADER *tail;

        unsigned long   seq;
        unsigned long   length;

} ELF_SPEC_HEADER_LIST;

typedef struct _elf_section_entry {

        void *next;
        void *prev;

} ELF_SECTION_ENTRY;

typedef struct _melf {

        char                 image[1024];
        unsigned long        imageSize;

        int                  access;

        Elf32_Ehdr           header;

        ELF_SPEC_HEADER_LIST sections;

        ELF_SPEC_HEADER_LIST programs;

} MELF;

MELF *melf_new();
MELF *melf_open(const char *image, int access);
void melf_destroy(MELF *melf);

unsigned long melf_synchronize(MELF *melf);
unsigned long melf_save(MELF *melf, const char *path);

unsigned long melf_version();

// Elf header functions

void melf_elfSetRaw(MELF *melf, Elf32_Ehdr *header);
Elf32_Ehdr *melf_elfGetRaw(MELF *melf);

void melf_elfSetType(MELF *melf, Elf32_Half type);
Elf32_Half melf_elfGetType(MELF *melf);

void melf_elfSetMachine(MELF *melf, Elf32_Half machine);
Elf32_Half melf_elfGetMachine(MELF *melf);

void melf_elfSetVersion(MELF *melf, Elf32_Word version);
Elf32_Word melf_elfGetVersion(MELF *melf);

void melf_elfSetEntry(MELF *melf, Elf32_Addr entry);
Elf32_Addr melf_elfGetEntry(MELF *melf);

void melf_elfSetProgramHeaderOffset(MELF *melf, Elf32_Off offset);
Elf32_Off melf_elfGetProgramHeaderOffset(MELF *melf);

void melf_elfSetSectionHeaderOffset(MELF *melf, Elf32_Off offset);
Elf32_Off melf_elfGetSectionHeaderOffset(MELF *melf);

void melf_elfSetProgramHeaderCount(MELF *melf, Elf32_Half count);
Elf32_Half melf_elfGetProgramHeaderCount(MELF *melf);

void melf_elfSetSectionHeaderEntrySize(MELF *melf, Elf32_Half size);
Elf32_Half melf_elfGetSectionEntrySize(MELF *melf);
void melf_elfSetProgramHeaderEntrySize(MELF *melf, Elf32_Half size);
Elf32_Half melf_elfGetProgramEntrySize(MELF *melf);

void melf_elfSetSectionHeaderCount(MELF *melf, Elf32_Half count);
Elf32_Half melf_elfGetSectionHeaderCount(MELF *melf);

void melf_elfSetStringTableIndex(MELF *melf, Elf32_Half index);
Elf32_Half melf_elfGetStringTableIndex(MELF *melf);

// Section functions

ELF_SPEC_HEADER *melf_sectionAdd(MELF *melf);
ELF_SPEC_HEADER *melf_sectionGetEnum(MELF *melf);
ELF_SPEC_HEADER *melf_sectionEnumNext(MELF *melf, ELF_SPEC_HEADER *en);
ELF_SPEC_HEADER *melf_sectionEnumPrev(MELF *melf, ELF_SPEC_HEADER *en);

ELF_SPEC_HEADER *melf_sectionFindType(MELF *melf, unsigned long type);
ELF_SPEC_HEADER *melf_sectionFindIndex(MELF *melf, unsigned long index);
ELF_SPEC_HEADER *melf_sectionFindName(MELF *melf, const char *name);

void melf_sectionSetContent(MELF *melf, ELF_SPEC_HEADER *section, void *content, unsigned long contentLength);
void *melf_sectionGetContent(MELF *melf, ELF_SPEC_HEADER *section);

unsigned long melf_sectionInsertContent(MELF *melf, ELF_SPEC_HEADER *section, unsigned long offset, void *content, unsigned long contentLength);

void melf_sectionSetName(MELF *melf, ELF_SPEC_HEADER *section, const char *name);
const char *melf_sectionGetName(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetType(MELF *melf, ELF_SPEC_HEADER *section, unsigned long type);
unsigned long melf_sectionGetType(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetOffset(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Off offset);
Elf32_Off melf_sectionGetOffset(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetSize(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Half size);
Elf32_Half melf_sectionGetSize(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetAddress(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Addr addr);
Elf32_Addr melf_sectionGetAddress(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetLink(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Word link);
Elf32_Word melf_sectionGetLink(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetInfo(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Word info);
Elf32_Word melf_sectionGetInfo(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetFlags(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Word flags);
Elf32_Word melf_sectionGetFlags(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetEntrySize(MELF *melf, ELF_SPEC_HEADER *section, Elf32_Word entsize);
Elf32_Word melf_sectionGetEntrySize(MELF *melf, ELF_SPEC_HEADER *section);

unsigned long melf_sectionGetIndex(MELF *melf, ELF_SPEC_HEADER *section);

void melf_sectionSetStringTableHeader(MELF *melf, ELF_SPEC_HEADER *section, ELF_SPEC_HEADER *stringTable);
ELF_SPEC_HEADER *melf_sectionGetStringTableHeader(MELF *melf, ELF_SPEC_HEADER *section);

unsigned long melf_sectionRemove(MELF *melf, unsigned long id);

ELF_SPEC_HEADER *melf_programAdd(MELF *melf);
ELF_SPEC_HEADER *melf_programGetEnum(MELF *melf);
ELF_SPEC_HEADER *melf_programEnumNext(MELF *melf, ELF_SPEC_HEADER *en);
ELF_SPEC_HEADER *melf_programEnumPrev(MELF *melf, ELF_SPEC_HEADER *en);

void melf_programSetType(MELF *melf, ELF_SPEC_HEADER *program, Elf32_Word type);
Elf32_Word melf_programGetType(MELF *melf, ELF_SPEC_HEADER *program);

void melf_programSetVirtualAddress(MELF *melf, ELF_SPEC_HEADER *program, Elf32_Addr addr);
Elf32_Addr melf_programGetVirtualAddress(MELF *melf, ELF_SPEC_HEADER *program);

void melf_programSetPhysicalAddress(MELF *melf, ELF_SPEC_HEADER *program, Elf32_Addr addr);
Elf32_Addr melf_programGetPhysicalAddress(MELF *melf, ELF_SPEC_HEADER *program);

void melf_programSetVirtualSize(MELF *melf, ELF_SPEC_HEADER *program, Elf32_Word size);
Elf32_Word melf_programGetVirtualSize(MELF *melf, ELF_SPEC_HEADER *program);

void melf_programSetPhysicalSize(MELF *melf, ELF_SPEC_HEADER *program, Elf32_Word size);
Elf32_Word melf_programGetPhysicalSize(MELF *melf, ELF_SPEC_HEADER *program);

void melf_programSetFlags(MELF *melf, ELF_SPEC_HEADER *program, Elf32_Word flags);
Elf32_Word melf_programGetFlags(MELF *melf, ELF_SPEC_HEADER *program);

unsigned long melf_programRemove(MELF *melf, unsigned long id);

ELF_SPEC_HEADER *melf_stringTableCreate(MELF *melf, const char *name);

void melf_stringTableInitializeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_stringTableSynchronizeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);

unsigned long melf_stringTableSetString(MELF *melf, ELF_SPEC_HEADER *stringTable, const char *name);
unsigned long melf_stringTableGetStringIndex(MELF *melf, ELF_SPEC_HEADER *stringTable, const char *name);
const char *melf_stringTableGetString(MELF *melf, ELF_SPEC_HEADER *stringTable, unsigned long index);

ELF_SPEC_HEADER *melf_dynamicCreate(MELF *melf);

void melf_dynamicInitializeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_dynamicSynchronizeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);


Elf32_Dyn *melf_dynamicAddTag(MELF *melf, ELF_SPEC_HEADER *dynamic, Elf32_Sword tag, Elf32_Word val);
unsigned long melf_dynamicRemoveTag(MELF *melf, ELF_SPEC_HEADER *dynamic, Elf32_Sword tag);
unsigned long melf_dynamicRemoveIndex(MELF *melf, ELF_SPEC_HEADER *dynamic, unsigned long index);
Elf32_Dyn *melf_dynamicGetTag(MELF *melf, ELF_SPEC_HEADER *dynamic, Elf32_Sword tag);
Elf32_Dyn *melf_dynamicGetIndex(MELF *melf, ELF_SPEC_HEADER *dynamic, unsigned long index);
unsigned long melf_dynamicSetTag(MELF *melf, ELF_SPEC_HEADER *dynamic, Elf32_Sword tag, Elf32_Word val);
unsigned long melf_dynamicSetIndex(MELF *melf, ELF_SPEC_HEADER *dynamic, unsigned long index, Elf32_Word val);

ELF_SPEC_HEADER *melf_noteCreate(MELF *melf, const char *name, unsigned long createProgramHeader);

void melf_noteInitializeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_noteSynchronizeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);

Elf32_Nhdr *melf_noteAdd(MELF *melf, ELF_SPEC_HEADER *note, Elf32_Word type, const char *name, unsigned char *desc, unsigned long descLength);
Elf32_Nhdr *melf_noteEnum(MELF *melf, ELF_SPEC_HEADER *note, unsigned long index);
unsigned long melf_noteRemove(MELF *melf, ELF_SPEC_HEADER *note, Elf32_Nhdr *item);

unsigned long melf_noteGetType(MELF *melf, ELF_SPEC_HEADER *note, Elf32_Nhdr *item);
const char *melf_noteGetName(MELF *melf, ELF_SPEC_HEADER *note, Elf32_Nhdr *item);
unsigned char *melf_noteGetDesc(MELF *melf, ELF_SPEC_HEADER *note, Elf32_Nhdr *item);

ELF_SPEC_HEADER *melf_symbolTableCreate(MELF *melf, const char *name);

void melf_symbolTableInitializeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_symbolTableSynchronizeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);

Elf32_Sym *melf_symbolTableAddSymbol(MELF *melf, ELF_SPEC_HEADER *symTable, const char *name);
Elf32_Sym *melf_symbolTableEnum(MELF *melf, ELF_SPEC_HEADER *symTable, unsigned long index);
unsigned long melf_symbolTableRemoveSymbol(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *symbol);

unsigned long melf_symbolTableRecalculateOffsets(MELF *melf, ELF_SPEC_HEADER *relatedSection, unsigned long offset, unsigned long contentLength);

void melf_symbolSetName(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym, const char *name);
const char *melf_symbolGetName(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym);

void melf_symbolSetValue(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym, Elf32_Addr value);
Elf32_Addr melf_symbolGetValue(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym);

void melf_symbolSetSize(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym, Elf32_Word size);
Elf32_Word melf_symbolGetSize(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym);

void melf_symbolSetBinding(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym, unsigned char binding);
unsigned char melf_symbolGetBinding(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym);

void melf_symbolSetType(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym, unsigned char type);
unsigned char melf_symbolGetType(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym);

void melf_symbolSetSectionIndex(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym, Elf32_Half shndx);
Elf32_Half melf_symbolGetSectionIndex(MELF *melf, ELF_SPEC_HEADER *symTable, Elf32_Sym *sym);

typedef enum _Elf32_ResType {
        ELF_RES_TYPE_UNKNOWN = 0,
        ELF_RES_TYPE_STRING  = 1,
        ELF_RES_TYPE_BINARY  = 2,
} Elf32_ResType;

typedef struct _Elf32_Res {

        // Stored on disk:
        struct _Elf32_Res_Header {

                unsigned long length;
                Elf32_ResType type;
                unsigned long identifier;
        } header;

        void          *data;    

        // Not stored on disk, internal use only:
        unsigned long index;
        unsigned long offset;

} Elf32_Res;

ELF_SPEC_HEADER *melf_resOpen(MELF *melf);
ELF_SPEC_HEADER *melf_resCreate(MELF *melf);

void melf_resInitializeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_resSynchronizeEntryList(MELF *melf, ELF_SPEC_HEADER *sect);

unsigned char melf_resEnum(MELF *melf, ELF_SPEC_HEADER *resTable, unsigned long index, Elf32_Res *res);
unsigned char melf_resGetType(MELF *melf, ELF_SPEC_HEADER *resTable, Elf32_ResType type, Elf32_Res *res);
unsigned char melf_resGetId(MELF *melf, ELF_SPEC_HEADER *resTable, unsigned long id, Elf32_Res *res);
unsigned char melf_resAdd(MELF *melf, ELF_SPEC_HEADER *resTable, Elf32_ResType type, unsigned long length, unsigned long id, void *data);
unsigned char melf_resUpdate(MELF *melf, ELF_SPEC_HEADER *resTable, Elf32_ResType type, unsigned long length, unsigned long id, void *data);
unsigned char melf_resRemove(MELF *melf, ELF_SPEC_HEADER *resTable, Elf32_Res *res);
void melf_resClose(MELF *melf, ELF_SPEC_HEADER *resTable);

ELF_SPEC_HEADER *melf_relocTableCreate(MELF *melf, const char *name, unsigned char hasAddends);

void melf_relocInitializeRelEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_relocSynchronizeRelEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_relocInitializeRelaEntryList(MELF *melf, ELF_SPEC_HEADER *sect);
void melf_relocSynchronizeRelaEntryList(MELF *melf, ELF_SPEC_HEADER *sect);

void melf_relocTableSetSymbolTableHeader(MELF *melf, ELF_SPEC_HEADER *relocTable, ELF_SPEC_HEADER *symTable);

Elf32_Rel *melf_relocTableAddRel(MELF *melf, ELF_SPEC_HEADER *relocTable);
Elf32_Rel *melf_relocTableEnumRel(MELF *melf, ELF_SPEC_HEADER *relocTable, unsigned long index);
unsigned long melf_relocTableRemoveRel(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel);

Elf32_Rela *melf_relocTableAddRela(MELF *melf, ELF_SPEC_HEADER *relocTable);
Elf32_Rela *melf_relocTableEnumRela(MELF *melf, ELF_SPEC_HEADER *relocTable, unsigned long index);
unsigned long melf_relocTableRemoveRela(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela);
unsigned long melf_relocRecalculateOffsets(MELF *melf, ELF_SPEC_HEADER *relatedSection, unsigned long offset, unsigned long contentLength);


void melf_relocRelInitialize(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel, Elf32_Addr offset, unsigned char symbolIndex, unsigned char type);

void melf_relocRelSetOffset(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel, Elf32_Addr offset);
Elf32_Addr melf_relocRelGetOffset(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel);

void melf_relocRelSetSymbol(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel, unsigned char symbolIndex);
unsigned char melf_relocRelGetSymbol(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel);

void melf_relocRelSetType(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel, unsigned char type);
unsigned char melf_relocRelGetType(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rel *rel);

void melf_relocRelaInitialize(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela, Elf32_Addr offset, unsigned char symbolIndex, unsigned char type, Elf32_Sword addend);

void melf_relocRelaSetOffset(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela, Elf32_Addr offset);
Elf32_Addr melf_relocRelaGetOffset(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela);

void melf_relocRelaSetSymbol(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela, unsigned char symbolIndex);
unsigned char melf_relocRelaGetSymbol(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela);

void melf_relocRelaSetType(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela, unsigned char type);
unsigned char melf_relocRelaGetType(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela);

void melf_relocRelaSetAddend(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela, Elf32_Sword addend);
Elf32_Sword melf_relocRelaGetAddend(MELF *melf, ELF_SPEC_HEADER *relocTable, Elf32_Rela *rela);

#ifdef MELF_COMP
#include "melf_internal.h"
#endif

#endif

---