path: root/src/libr-ro.c

/*
 *
 *  Copyright (c) 2009 Erich Hoover
 *  Copyright (c) 2008-2009 Martin Rosenau
 *
 *  libr read-only Backend - Read resources from ELF binaries
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * To provide feedback, report bugs, or otherwise contact me:
 * ehoover at mines dot edu
 *
 */

/* Include compile-time parameters */
#include "config.h"

#include "libr.h"
#include "libr-internal.h"

/* malloc/free */
#include <stdlib.h>

/* For memory byte-wise compare */
#include <string.h>

/* For endian conversion */
#include "cvtendian.h"

#define RETURN_UNSUPPORTED RETURN(LIBR_ERROR_UNSUPPORTED, "The read-only backend does not support this operation");

#ifndef DOXYGEN_SHOULD_SKIP_THIS

typedef struct {
	unsigned char magic[4];
	eClass byte_size;
	eEncoding endian;
	unsigned char version;
	unsigned char padding[9];
} ElfPreHeader;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

#define ELF_HALF(b)  sizeof(uint16_t)
#define ELF_WORD(b)  sizeof(uint32_t)
#define ELF_XWORD(b) ((b == ELFCLASS32) ? sizeof(uint32_t) : sizeof(uint64_t))
#define ELF_ADDR(b)  ELF_XWORD(b)
#define ELF_OFF(b)   ELF_XWORD(b)

/* ELF Header Offsets */
#define HDROFF_TYPE(b)      sizeof(ElfPreHeader)             /* ElfXX_Half  e_type; */
#define HDROFF_MACHINE(b)   HDROFF_TYPE(b)+ELF_HALF(b)       /* ElfXX_Half  e_machine; */
#define HDROFF_VERSION(b)   HDROFF_MACHINE(b)+ELF_HALF(b)    /* ElfXX_Word  e_version; */
#define HDROFF_ENTRY(b)     HDROFF_VERSION(b)+ELF_WORD(b)    /* ElfXX_Addr  e_entry; */
#define HDROFF_PHOFF(b)     HDROFF_ENTRY(b)+ELF_ADDR(b)      /* ElfXX_Off   e_phoff; */
#define HDROFF_SHOFF(b)     HDROFF_PHOFF(b)+ELF_OFF(b)       /* ElfXX_Off   e_shoff; */
#define HDROFF_FLAGS(b)     HDROFF_SHOFF(b)+ELF_OFF(b)       /* ElfXX_Word  e_flags; */
#define HDROFF_EHSIZE(b)    HDROFF_FLAGS(b)+ELF_WORD(b)      /* ElfXX_Half  e_ehsize; */
#define HDROFF_PHENTSIZE(b) HDROFF_EHSIZE(b)+ELF_HALF(b)     /* ElfXX_Half  e_phentsize; */
#define HDROFF_PHNUM(b)     HDROFF_PHENTSIZE(b)+ELF_HALF(b)  /* ElfXX_Half  e_phnum; */
#define HDROFF_SHENTSIZE(b) HDROFF_PHNUM(b)+ELF_HALF(b)      /* ElfXX_Half  e_shentsize; */
#define HDROFF_SHNUM(b)     HDROFF_SHENTSIZE(b)+ELF_HALF(b)  /* ElfXX_Half  e_shnum; */
#define HDROFF_SHSTRNDX(b)  HDROFF_SHNUM(b)+ELF_HALF(b)      /* ElfXX_Half  e_shstrndx; */

/* ELF Section Offsets */
#define SECOFF_NAME(b)      0                                /* ElfXX_Word  sh_name; */
#define SECOFF_TYPE(b)      SECOFF_NAME(b)+ELF_WORD(b)       /* ElfXX_Word  sh_type; */
#define SECOFF_FLAGS(b)     SECOFF_TYPE(b)+ELF_WORD(b)       /* ElfXX_XWord sh_flags; */
#define SECOFF_ADDR(b)      SECOFF_FLAGS(b)+ELF_XWORD(b)     /* ElfXX_Addr  sh_addr; */
#define SECOFF_OFFSET(b)    SECOFF_ADDR(b)+ELF_ADDR(b)       /* ElfXX_Off   sh_offset; */
#define SECOFF_SIZE(b)      SECOFF_OFFSET(b)+ELF_OFF(b)      /* ElfXX_XWord sh_size; */
#define SECOFF_LINK(b)      SECOFF_SIZE(b)+ELF_XWORD(b)      /* ElfXX_Word  sh_link; */
#define SECOFF_INFO(b)      SECOFF_LINK(b)+ELF_WORD(b)       /* ElfXX_Word  sh_info; */
#define SECOFF_ADDRALIGN    SECOFF_INFO(b)+ELF_WORD(b)       /* ElfXX_XWord sh_addralign; */
#define SECOFF_ENTSIZE      SECOFF_ADDRALIGN(b)+ELF_XWORD(b) /* ElfXX_XWord sh_entsize; */

/*
 * Safely read a parameter from the ELF binary
 */
static int read_param(FILE *handle, void *result, size_t bytes, eClass endian)
{
	if(fread(result, 1, bytes, handle) != bytes)
		return 0;
	if(ferror(handle))
		return 0;
	if(endian != HOST_ENDIAN && !ConvertEndian(result, bytes))
		return 0;
	return 1;
}

/*
 * The read-only backend requires no initialization
 */
void initialize_backend(void)
{
	if(sizeof(ElfPreHeader) != 16)
		fprintf(stderr, "WARNING: Your compiler did not properly pack important structures!\n");
}

/*
 * The read-only backend cannot write an output file
 */
void write_output(libr_file *file_handle) {}

/*
 * The read-only backend cannot add sections
 */
libr_intstatus add_section(libr_file *file_handle, char *resource_name, libr_section **retscn)
{
	RETURN_UNSUPPORTED;
}

/*
 * Return the name of a section
 */
char *section_name(libr_file *file_handle, libr_section *scn)
{
	if(scn == NULL)
		return NULL;
	return scn->name;
}

/*
 * Return the pointer to the actual data in the section
 */
void *data_pointer(libr_section *scn, libr_data *data)
{
	return (void *) data;
}

/*
 * Return the size of the data in the section
 */
size_t data_size(libr_section *scn, libr_data *data)
{
	return scn->size;
}

/*
 * Find the resource stored in the ELF binary
 */
libr_intstatus find_section(libr_file *file_handle, char *section, libr_section **retscn)
{
	char *test_name;
	int i;
	
	for(i=0; i<file_handle->total_sections; i++)
	{
		test_name = section_name(file_handle, &(file_handle->secdata[i]));
		if(test_name != NULL && strcmp(test_name, section) == 0)
			break;
	}
	if(i >= file_handle->total_sections)
		RETURN(LIBR_ERROR_NOSECTION, "ELF resource section not found");
	
	/* Found the resource, hurray! */
	*retscn = &(file_handle->secdata[i]);
	RETURN_OK;
}

/*
 * Read the section from the ELF binary
 */
libr_data *get_data(libr_file *file_handle, libr_section *scn)
{
	FILE *handle = file_handle->handle;
	libr_data *data = NULL;
	size_t n;
	
	fseek(handle, scn->data_offset, SEEK_SET);
	data = (libr_data *) malloc(scn->size);
	n = fread(data, 1, scn->size, handle);
	if(n == 0)
		goto failed; /* Empty section? */
	if(ferror(handle))
		goto failed;
	
	/* Succeeded in reading the data */
	return data;
failed:
	free(data);
	return NULL;
}

/*
 * UNSUPORTED BY BACKEND: Create a new data section
 */
libr_data *new_data(libr_file *file_handle, libr_section *scn)
{
	return NULL;
}

/*
 * Find the next section given a section pointer
 */
libr_section *next_section(libr_file *file_handle, libr_section *scn)
{
	int total_sections = file_handle->total_sections;
	libr_section *test_scn = NULL;
	int i;
	
	if(total_sections == 0)
		return NULL;
	/* Requesting the first section */
	if(scn == NULL)
	{
		i = 0;
		/* Do not return an empty section */
		while(test_scn == NULL || test_scn->size == 0)
		{
			if(i > total_sections)
				return NULL;
			test_scn = &(file_handle->secdata[i++]);
		}
		return test_scn;
	}
	/* Return the next section given a section pointer */
	for(i=0; i<total_sections; i++)
	{
		test_scn = &(file_handle->secdata[i]);
		
		if(test_scn == scn && (i+1) < total_sections)
		{
			libr_section *next_scn = &(file_handle->secdata[i+1]);
			
			/* Returning empty sections is pointless */
			if(next_scn->size != 0)
				return next_scn;
		}
	}
	return NULL;
}

/*
 * UNSUPORTED BY BACKEND: Remove a section
 */
libr_intstatus remove_section(libr_file *file_handle, libr_section *scn)
{
	RETURN_UNSUPPORTED;
}

/*
 * UNSUPORTED BY BACKEND: Set the data for a section
 */
libr_intstatus set_data(libr_file *file_handle, libr_section *scn, libr_data *data, off_t offset, char *buffer, size_t size)
{
	RETURN_UNSUPPORTED;
}

/*
 * Open a handle to the ELF binary (provided that read-only access is requested)
 */
libr_intstatus open_handles(libr_file *file_handle, char *filename, libr_access_t access)
{
	const char elf_magic[] = {'\x7F','E','L','F'};
	uint16_t total_sections, sh_size, strings_sec;
	ElfPreHeader file_info;
	libr_section *secdata;
	FILE *handle = NULL;
	uint64_t sh_offset;
	unsigned long i;
	
	if(access == LIBR_READ_WRITE)
		RETURN_UNSUPPORTED;
	handle = fopen(filename, "rb");
	if(!handle)
		RETURN(LIBR_ERROR_OPENFAILED, "Failed to open input file");
	if(fread(&file_info, 1, sizeof(ElfPreHeader), handle) != sizeof(ElfPreHeader))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Failed to read pre-header bytes from input file");
	if(memcmp(file_info.magic, elf_magic, sizeof(elf_magic)) != 0)
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: not an ELF binary");

	/* Confirm processor (byte size) and packing (endian) */
	if(!enum_valid(file_info.byte_size, ELFCLASS))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: invalid byte size");
	if(!enum_valid(file_info.endian, ELFDATA))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: invalid endian type");
	
	/* Get the file offset to the Section Header tables */
	fseek(handle, HDROFF_SHOFF(file_info.byte_size), SEEK_SET);
	if(!read_param(handle, &sh_offset, ELF_OFF(file_info.byte_size), file_info.endian))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section header offset");
	/* Get the size of the Section Header tables */
	fseek(handle, HDROFF_SHENTSIZE(file_info.byte_size), SEEK_SET);
	if(!read_param(handle, &sh_size, ELF_HALF(file_info.byte_size), file_info.endian))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section header size");
	/* Get the total number of sections */
	fseek(handle, HDROFF_SHNUM(file_info.byte_size), SEEK_SET);
	if(!read_param(handle, &total_sections, ELF_HALF(file_info.byte_size), file_info.endian))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read total number of sections");
	/* Get the ID of the "strings" section */
	fseek(handle, HDROFF_SHSTRNDX(file_info.byte_size), SEEK_SET);
	if(!read_param(handle, &strings_sec, ELF_HALF(file_info.byte_size), file_info.endian))
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read string section ID");
	if(strings_sec >= total_sections)
		RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: invalid string section ID");
	secdata = (libr_section *) malloc(sizeof(libr_section)*total_sections);
	
	/* Load section information */
	for(i=0; i<total_sections; i++)
	{
		long sec_start = sh_offset+sh_size*i;
		
		/* Grab the offset in the string table to the name of the section */
		fseek(handle, sec_start+SECOFF_NAME(file_info.byte_size), SEEK_SET);
		if(!read_param(handle, &(secdata[i].name_offset), ELF_WORD(file_info.byte_size), file_info.endian))
			RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section name offset");
		/* Grab the offset to the data for the section */
		fseek(handle, sec_start+SECOFF_OFFSET(file_info.byte_size), SEEK_SET);
		if(!read_param(handle, &(secdata[i].data_offset), ELF_OFF(file_info.byte_size), file_info.endian))
			RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section data offset");
		/* Grab the size of the data for the section */
		fseek(handle, sec_start+SECOFF_SIZE(file_info.byte_size), SEEK_SET);
		if(!read_param(handle, &(secdata[i].size), ELF_XWORD(file_info.byte_size), file_info.endian))
			RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section size");
	}
	/* Locate the name offset within the "strings" section and load the string */
	for(i=0; i<total_sections; i++)
	{
		long stringsec_start = secdata[strings_sec].data_offset;
		size_t n;
		
		fseek(handle, stringsec_start+secdata[i].name_offset, SEEK_SET);
		n = fread(secdata[i].name, 1, ELFSTRING_MAX-1, handle);
		if(ferror(handle))
			RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read string");
		secdata[i].name[n] = '\0';
	}
	
	/* Hold onto the important parameters */
	file_handle->secdata = secdata;
	file_handle->total_sections = total_sections;
	file_handle->endian = file_info.endian;
	file_handle->byte_size = file_info.byte_size;
	file_handle->handle = handle;
	file_handle->filename = filename;
	file_handle->access = access;
	RETURN_OK;
}