elf.c

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "elf.h"
 
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
Elf_t* elf_create(uint8_t* buffer, size_t len) {
  Elf_t* elf = (Elf_t*)malloc(sizeof(Elf_t));
  // The main header will be at buffer[0].
  elf->header = (ElfHeader_t*)buffer;
 
  // Check the ident.
  if ((elf->header->ident[1] != 'E') || (elf->header->ident[2] != 'L') ||
      (elf->header->ident[3] != 'F') || (elf->header->ident[0] != 127)) {
    printf("ELF file: ident check failed!");
    return 0;
  }
 
  // Check the bit-length.
  if (elf->header->ident[4] != 1) {
    printf("ELF file: wrong bit length!");
    return 0;
  }
 
  // Load in the section headers.
  elf->section_headers =
      (ElfSectionHeader_t*)malloc(sizeof(ElfSectionHeader_t) * elf->header->shnum);
  memcpy((uint8_t*)elf->section_headers, &buffer[elf->header->shoff],
         elf->header->shnum * sizeof(ElfSectionHeader_t));
 
  // Find the section header string table.
  ElfSectionHeader_t* shstrtab_section = &elf->section_headers[elf->header->shstrndx];
 
  // Load the section header string table.
  char* shstrtab = (char*)malloc(shstrtab_section->size);
  memcpy((uint8_t*)shstrtab, &buffer[shstrtab_section->offset], shstrtab_section->size);
 
  ElfSectionHeader_t *symtab = 0, *strtab = 0;
  // Go through each section header, trying to find .symtab.
  for (int i = 0; i < elf->header->shnum; i++) {
    const char* str = shstrtab + elf->section_headers[i].name;
    if (!strcmp(str, ".symtab"))
      symtab = &elf->section_headers[i];
    if (!strcmp(str, ".strtab"))
      strtab = &elf->section_headers[i];
  }
 
  if (symtab == 0) {
    printf("ELF: symbol table not found!");
    return 0;
  } else {
    elf->symtabsz = symtab->size / sizeof(ElfSymbol_t);
    elf->symtab = (ElfSymbol_t*)malloc(symtab->size);
    memcpy((uint8_t*)elf->symtab, &buffer[symtab->offset], symtab->size);
  }
 
  if (strtab == 0) {
    printf("ELF: string table not found!");
    return 0;
  } else {
    elf->strtabsz = strtab->size;
    elf->strtab = (char*)malloc(strtab->size);
    memcpy((uint8_t*)elf->strtab, &buffer[strtab->offset], strtab->size);
  }
 
  elf->buffer = buffer;
 
  return elf;
}
 
ElfSymbol_t* elf_get_symbol(Elf_t* elf, const char* name) {
  for (size_t i = 0; i < elf->symtabsz; i++)
    if (!strcmp((char*)(elf->strtab + elf->symtab[i].name), name))
      return &(elf->symtab[i]);
  return 0;
}
 
uint8_t* elf_relptr(Elf_t* elf, ElfSymbol_t* sym, uint32_t ptr) {
  ElfSectionHeader_t* relsh = 0;
  for (size_t i = 0; i < elf->header->shnum; i++) {
    if (elf->section_headers[i].type == SHT_REL && elf->section_headers[i].info == sym->shndx) {
      relsh = &(elf->section_headers[i]);
      break;
    }
  }
  if (!relsh)
    return 0;
  ElfRel_t* rel = 0;
  for (size_t i = 0; i < (relsh->size / sizeof(ElfRel_t)); i++) {
    ElfRel_t* tmp = (ElfRel_t*)&(elf->buffer[relsh->offset + i * sizeof(ElfRel_t)]);
    if (tmp->offset == sym->value) {
      rel = tmp;
      break;
    }
  }
  if (!rel)
    return 0;
  ElfSymbol_t* relsym = &(elf->symtab[R_SYM(rel->info)]);
  if (ST_TYPE(relsym->info) != 3)
    return 0;
  return &elf->buffer[elf->section_headers[relsym->shndx].offset + ptr];
}