/*
 * Australian Public Licence B (OZPLB)
 * 
 * Version 1-0
 * 
 * Copyright (c) 2004 University of New South Wales
 * 
 * All rights reserved. 
 * 
 * Developed by: Operating Systems and Distributed Systems Group (DiSy)
 *               University of New South Wales
 *               http://www.disy.cse.unsw.edu.au
 * 
 * Permission is granted by University of New South Wales, free of charge, to
 * any person obtaining a copy of this software and any associated
 * documentation files (the "Software") to deal with the Software without
 * restriction, including (without limitation) the rights to use, copy,
 * modify, adapt, merge, publish, distribute, communicate to the public,
 * sublicense, and/or sell, lend or rent out copies of the Software, and
 * to permit persons to whom the Software is furnished to do so, subject
 * to the following conditions:
 * 
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimers.
 * 
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimers in the documentation and/or other materials provided
 *       with the distribution.
 * 
 *     * Neither the name of University of New South Wales, nor the names of its
 *       contributors, may be used to endorse or promote products derived
 *       from this Software without specific prior written permission.
 * 
 * EXCEPT AS EXPRESSLY STATED IN THIS LICENCE AND TO THE FULL EXTENT
 * PERMITTED BY APPLICABLE LAW, THE SOFTWARE IS PROVIDED "AS-IS", AND
 * NATIONAL ICT AUSTRALIA AND ITS CONTRIBUTORS MAKE NO REPRESENTATIONS,
 * WARRANTIES OR CONDITIONS OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS
 * REGARDING THE CONTENTS OR ACCURACY OF THE SOFTWARE, OR OF TITLE,
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT,
 * THE ABSENCE OF LATENT OR OTHER DEFECTS, OR THE PRESENCE OR ABSENCE OF
 * ERRORS, WHETHER OR NOT DISCOVERABLE.
 * 
 * TO THE FULL EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL
 * NATIONAL ICT AUSTRALIA OR ITS CONTRIBUTORS BE LIABLE ON ANY LEGAL
 * THEORY (INCLUDING, WITHOUT LIMITATION, IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHERWISE) FOR ANY CLAIM, LOSS, DAMAGES OR OTHER
 * LIABILITY, INCLUDING (WITHOUT LIMITATION) LOSS OF PRODUCTION OR
 * OPERATION TIME, LOSS, DAMAGE OR CORRUPTION OF DATA OR RECORDS; OR LOSS
 * OF ANTICIPATED SAVINGS, OPPORTUNITY, REVENUE, PROFIT OR GOODWILL, OR
 * OTHER ECONOMIC LOSS; OR ANY SPECIAL, INCIDENTAL, INDIRECT,
 * CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES, ARISING OUT OF OR IN
 * CONNECTION WITH THIS LICENCE, THE SOFTWARE OR THE USE OF OR OTHER
 * DEALINGS WITH THE SOFTWARE, EVEN IF NATIONAL ICT AUSTRALIA OR ITS
 * CONTRIBUTORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH CLAIM, LOSS,
 * DAMAGES OR OTHER LIABILITY.
 * 
 * If applicable legislation implies representations, warranties, or
 * conditions, or imposes obligations or liability on University of New South
 * Wales or one of its contributors in respect of the Software that
 * cannot be wholly or partly excluded, restricted or modified, the
 * liability of University of New South Wales or the contributor is limited, to
 * the full extent permitted by the applicable legislation, at its
 * option, to:
 * a.  in the case of goods, any one or more of the following:
 * i.  the replacement of the goods or the supply of equivalent goods;
 * ii.  the repair of the goods;
 * iii. the payment of the cost of replacing the goods or of acquiring
 *  equivalent goods;
 * iv.  the payment of the cost of having the goods repaired; or
 * b.  in the case of services:
 * i.  the supplying of the services again; or
 * ii.  the payment of the cost of having the services supplied again.
 * 
 * The construction, validity and performance of this licence is governed
 * by the laws in force in New South Wales, Australia.
 */
void *str;
#include <elf/elf.h>
#include <string.h>
#include <stdio.h>

/*
 * Checks that elfFile points to a valid elf file. Returns 0 if the elf
 * file is valid, < 0 if invalid. 
 */

#define ISELF32(elfFile) ( ((struct Elf32_Header*)elfFile)->e_ident[EI_CLASS] == ELFCLASS32 )
#define ISELF64(elfFile) ( ((struct Elf64_Header*)elfFile)->e_ident[EI_CLASS] == ELFCLASS64 )

int
elf_checkFile(void *elfFile)
{
	return ISELF32 (elfFile)
		? elf32_checkFile(elfFile)
		: elf64_checkFile(elfFile);
}

/* Program Headers Access functions */
uint16_t
elf_getNumProgramHeaders(void *elfFile)
{
	return ISELF32 (elfFile)
		? elf32_getNumProgramHeaders(elfFile)
		: elf64_getNumProgramHeaders(elfFile);
}

uint32_t
elf_getProgramHeaderFlags(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderFlags(elfFile, ph)
		: elf64_getProgramHeaderFlags(elfFile, ph);
}

uint32_t
elf_getProgramHeaderType(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderType(elfFile, ph)
		: elf64_getProgramHeaderType(elfFile, ph);
}

uint64_t
elf_getProgramHeaderPaddr(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderPaddr(elfFile, ph)
		: elf64_getProgramHeaderPaddr(elfFile, ph);
}

uint64_t
elf_getProgramHeaderVaddr(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderVaddr(elfFile, ph)
		: elf64_getProgramHeaderVaddr(elfFile, ph);
}

uint64_t
elf_getProgramHeaderMemorySize(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderMemorySize(elfFile, ph)
		: elf64_getProgramHeaderMemorySize(elfFile, ph);
}

uint64_t
elf_getProgramHeaderFileSize(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderFileSize(elfFile, ph)
		: elf64_getProgramHeaderFileSize(elfFile, ph);
}

uint64_t
elf_getProgramHeaderOffset(void *elfFile, uint16_t ph)
{
	return ISELF32 (elfFile)
		? elf32_getProgramHeaderOffset(elfFile, ph)
		: elf64_getProgramHeaderOffset(elfFile, ph);
}

char *
elf_getSegmentStringTable(void *elfFile)
{
	return ISELF32 (elfFile)
		? elf32_getSegmentStringTable(elfFile)
		: elf64_getSegmentStringTable(elfFile);
}

char *
elf_getStringTable(void *elfFile, int string_segment)
{
	return ISELF32 (elfFile)
		? elf32_getStringTable(elfFile)
		: elf64_getStringTable(elfFile, string_segment);
}


unsigned
elf_getNumSections(void *elfFile)
{
	return ISELF32 (elfFile)
		? elf32_getNumSections(elfFile)
		: elf64_getNumSections(elfFile);
}

char *
elf_getSectionName(void *elfFile, int i)
{
	return ISELF32 (elfFile)
		? elf32_getSectionName(elfFile, i)
		: elf64_getSectionName(elfFile, i);
}

uint32_t
elf_getSectionFlags(void *elfFile, int i)
{
	return ISELF32 (elfFile)
		? elf32_getSectionFlags(elfFile, i)
		: elf64_getSectionFlags(elfFile, i);
}

uint32_t
elf_getSectionType(void *elfFile, int i)
{
	return ISELF32 (elfFile)
		? elf32_getSectionType(elfFile, i)
		: elf64_getSectionType(elfFile, i);
}

uint64_t
elf_getSectionSize(void *elfFile, int i)
{
	return ISELF32 (elfFile)
		? elf32_getSectionSize(elfFile, i)
		: elf64_getSectionSize(elfFile, i);
}

uint64_t
elf_getSectionAddr(void *elfFile, int i)
{
	return ISELF32 (elfFile)
		? elf32_getSectionAddr(elfFile, i)
		: elf64_getSectionAddr(elfFile, i);
}


void *
elf_getSection(void *elfFile, int i)
{
	return ISELF32 (elfFile)
		? elf32_getSection(elfFile, i)
		: elf64_getSection(elfFile, i);
}

void *
elf_getSectionNamed(void *elfFile, char *_str)
{
	return ISELF32 (elfFile)
		? elf32_getSectionNamed(elfFile, _str)
		: elf64_getSectionNamed(elfFile, _str);
}

void
elf_getProgramHeaderInfo(void *elfFile, uint16_t ph, uint64_t *p_vaddr, 
			 uint64_t *p_paddr, uint64_t *p_filesz, uint64_t *p_offset, 
			 uint64_t *p_memsz)
{
	*p_vaddr = elf_getProgramHeaderVaddr(elfFile, ph);
	*p_paddr = elf_getProgramHeaderPaddr(elfFile, ph);
	*p_filesz = elf_getProgramHeaderFileSize(elfFile, ph);
	*p_offset = elf_getProgramHeaderOffset(elfFile, ph);
	*p_memsz = elf_getProgramHeaderMemorySize(elfFile, ph);
}

uint64_t
elf_getEntryPoint(void *elfFile)
{
	return ISELF32 (elfFile)
		? elf32_getEntryPoint (elfFile)
		: elf64_getEntryPoint (elfFile);
}

void
elf_fprintf(FILE *f, void *file, int size, const char *name, int flags)
{
	elf32_fprintf(f, file, size, name, flags);

}

bool
elf_getMemoryBounds(void *elfFile, bool phys, uint64_t *min, uint64_t *max)
{
	uint64_t mem_min = UINT64_MAX;
	uint64_t mem_max = 0;
	int i;

	if (elf_checkFile(elfFile) != 0) {
		return false;
	}

	for(i=0; i < elf_getNumProgramHeaders(elfFile); i++) {
		uint64_t sect_min, sect_max;

		if (elf_getProgramHeaderMemorySize(elfFile, i) == 0) {
			continue;
		}

		if (phys) {
			sect_min = elf_getProgramHeaderPaddr(elfFile, i);
		} else {
			sect_min = elf_getProgramHeaderVaddr(elfFile, i);
		}

		sect_max = sect_min + elf_getProgramHeaderMemorySize(elfFile, i);

		if (sect_max > mem_max) {
			mem_max = sect_max;
		}
		if (sect_min < mem_min) {
			mem_min = sect_min;
		}
	}
	*min = mem_min;
	*max = mem_max;

	return true;
};

bool
elf_vaddrInProgramHeader(void *elfFile, uint16_t ph, uint64_t vaddr)
{
	uint64_t min = elf_getProgramHeaderVaddr(elfFile, ph);
	uint64_t max = min + elf_getProgramHeaderMemorySize(elfFile, ph);
	if (vaddr >= min && vaddr < max) {
		return true;
	} else {
		return false;
	}
}

uint64_t
elf_vtopProgramHeader(void *elfFile, uint16_t ph, uint64_t vaddr)
{
	uint64_t ph_phys = elf_getProgramHeaderPaddr(elfFile, ph);
	uint64_t ph_virt = elf_getProgramHeaderVaddr(elfFile, ph);
	uint64_t paddr;

	paddr = vaddr - ph_virt + ph_phys;

	return paddr;
}

bool
elf_loadFile(void *elfFile, bool phys)
{
	int i;
	int num_pheaders;
	int pheader_offset;
	int pheader_type;
	if (elf_checkFile(elfFile) != 0) {
		return false;
	}

	num_pheaders = elf_getNumProgramHeaders(elfFile);
	pheader_offset = elf_getProgramHeaderOffset(elfFile, 0);
	//printf("Number of program headers: %d\n", num_pheaders);
	//printf("Program header offset of first header from file beginning: 0x%p\n",pheader_offset);

	/*
	 * FIXME:
	 * This should have a linked list of mapped ranges so that it can check
	 * at run-time whether any images are overlapping in their LMA and refuse to load.
	 */
	for(i=0; i < num_pheaders; i++) {
		/* Load that section */
		uint64_t dest, src;
		uint32_t clrsize;
		size_t len;
		if (phys) {
			dest = elf_getProgramHeaderPaddr(elfFile, i);
		//	printf("Elf file pheader physical: 0x%x\n", (unsigned int)dest);
		//	printf("Elf file pheader virtual: 0x%x\n",
		//	       (unsigned int)elf_getProgramHeaderVaddr(elfFile,i));
		} else {
		//	printf("Elf file pheader virtual: 0x%x\n", (unsigned int)dest);
			dest = elf_getProgramHeaderVaddr(elfFile, i);
		}
		len = elf_getProgramHeaderFileSize(elfFile, i);
	//	printf("This section's size in file: %p\n", len);
		src = (uint64_t) (uintptr_t) elfFile + elf_getProgramHeaderOffset(elfFile, i);
	//	printf("Elf program header offset: %p\n", src);
		pheader_type = elf_getProgramHeaderType(elfFile, i);
	//	printf("Elf program header type: %p\n", pheader_type);
// Comment
//printf("Copying to range from 0x%x to 0x%x of size: 0x%x\n", (unsigned int)dest, (unsigned int)dest + (unsigned int)len, (unsigned int)len);
		memcpy((void*) (uintptr_t) dest, (void*) (uintptr_t) src, len);
		dest += len;
		clrsize = elf_getProgramHeaderMemorySize(elfFile, i) - len;
//		printf("Clearing memory... starting from %x, size: %x\n", (unsigned int)dest, (unsigned int)clrsize);
		memset((void*) (uintptr_t) dest, 0, clrsize);
//		printf("Memory cleared.\n");
	}
// And this one
//	printf("\n");

	return true;
}
