htmacho.cc

/* 
 *	HT Editor
 *	htmacho.cc
 *
 *	Copyright (C) 2003 Stefan Weyergraf
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License version 2 as
 *	published by the Free Software Foundation.
 *
 *	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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "elfstruc.h"
#include "log.h"
#include "htmacho.h"
#include "htmachohd.h"
#include "htmachoimg.h"
#include "endianess.h"
#include "stream.h"
#include "tools.h"

#include "machostruc.h"

#include <stdlib.h>

static format_viewer_if *htmacho_ifs[] = {
	&htmachoheader_if,
	&htmachoimage_if,
	0
};

static ht_view *htmacho_init(Bounds *b, File *file, ht_format_group *format_group)
{
	byte magic[4];
	file->seek(0);
	file->read(&magic, sizeof magic);
	if (memcmp(magic, "\xfe\xed\xfa\xce", 4) == 0) {
		ht_macho *g = new ht_macho();
		g->init(b, file, htmacho_ifs, format_group, 0, big_endian, false);
		return g;
	} else if (memcmp(magic, "\xfe\xed\xfa\xcf", 4) == 0) {
		ht_macho *g = new ht_macho();
		g->init(b, file, htmacho_ifs, format_group, 0, big_endian, true);
		return g;
	} else if (memcmp(magic, "\xce\xfa\xed\xfe", 4) == 0) {
		ht_macho *g = new ht_macho();
		g->init(b, file, htmacho_ifs, format_group, 0, little_endian, false);
		return g;
	} else if (memcmp(magic, "\xcf\xfa\xed\xfe", 4) == 0) {
		ht_macho *g = new ht_macho();
		g->init(b, file, htmacho_ifs, format_group, 0, little_endian, true);
		return g;
	}
	return NULL;
}

format_viewer_if htmacho_if = {
	htmacho_init,
	0
};

/*
 *	CLASS ht_macho
 */
void ht_macho::init(Bounds *b, File *f, format_viewer_if **ifs, ht_format_group *format_group, FileOfs header_ofs, Endianess image_endianess, bool _64)
{
	ht_format_group::init(b, VO_SELECTABLE | VO_BROWSABLE | VO_RESIZE, DESC_MACHO, f, false, true, 0, format_group);
	VIEW_DEBUG_NAME("ht_macho");

	String fn;
	file->getFilename(fn);
	LOG("%y: Mach-O: found header at %08qx", &fn, header_ofs);
	
	ht_macho_shared_data *macho_shared = ht_malloc(sizeof(ht_macho_shared_data));

	shared_data = macho_shared;
	macho_shared->image_endianess = image_endianess;
	macho_shared->_64 = _64;
	macho_shared->header_ofs = header_ofs;
	macho_shared->cmds.count = 0;
	macho_shared->cmds.cmds = NULL;

	FileOfs ofs;
	file->seek(header_ofs);
	if (_64) {
		file->read(&macho_shared->header64, sizeof macho_shared->header64);
		createHostStruct(&macho_shared->header64, MACHO_HEADER_64_struct, image_endianess);
		ofs = header_ofs + sizeof macho_shared->header64;
	} else {
		file->read(&macho_shared->header, sizeof macho_shared->header);
		createHostStruct(&macho_shared->header, MACHO_HEADER_struct, image_endianess);
		ofs = header_ofs + sizeof macho_shared->header;
	}

	/* read commands */
	uint nsections = 0;
	macho_shared->cmds.cmds = ht_malloc(sizeof (MACHO_COMMAND_U*) * macho_shared->header.ncmds);
	macho_shared->cmds.count = 0;
	for (uint i=0; i < macho_shared->header.ncmds; i++) {
		MACHO_COMMAND cmd;
		file->seek(ofs);
		file->read(&cmd, sizeof cmd);
		createHostStruct(&cmd, MACHO_COMMAND_struct, image_endianess);
		if (cmd.cmdsize > 1024*1024) break;
		macho_shared->cmds.cmds[i] = ht_malloc(cmd.cmdsize);
		file->seek(ofs);
		if (file->read(macho_shared->cmds.cmds[i], cmd.cmdsize) != cmd.cmdsize) {
			LOG_EX(LOG_ERROR, "%y: Mach-O: error processing command idx %d "
				"(read error %d bytes from %08qx)", &fn, i, cmd.cmdsize, ofs);
			free(macho_shared->cmds.cmds[i]);
			break;
		}
		switch (cmd.cmd) {
		case LC_SEGMENT:
			createHostStruct(macho_shared->cmds.cmds[i], MACHO_SEGMENT_COMMAND_struct, image_endianess);
			// already count sections (needed for reading sections, see below)
			nsections += macho_shared->cmds.cmds[i]->segment.nsects;
			break;
		case LC_SEGMENT_64:
			createHostStruct(macho_shared->cmds.cmds[i], MACHO_SEGMENT_64_COMMAND_struct, image_endianess);
			// already count sections (needed for reading sections, see below)
			nsections += macho_shared->cmds.cmds[i]->segment_64.nsects;
			break;
		case LC_SYMTAB:
			createHostStruct(macho_shared->cmds.cmds[i], MACHO_SYMTAB_COMMAND_struct, image_endianess);
			break;
		case LC_THREAD:
		case LC_UNIXTHREAD: {
			MACHO_THREAD_COMMAND *c = (MACHO_THREAD_COMMAND*)macho_shared->cmds.cmds[i];
			createHostStruct(macho_shared->cmds.cmds[i], MACHO_THREAD_COMMAND_struct, image_endianess);
			switch (macho_shared->header.cputype) {
			case MACHO_CPU_TYPE_ARM:
				switch (c->flavor) {
				case FLAVOR_ARM_THREAD_STATE:
					createHostStruct(&c->state, MACHO_ARM_THREAD_STATE_struct, image_endianess);
					break;
				}
				break;
			case MACHO_CPU_TYPE_I386:
				switch (c->flavor) {
				case -1:
					createHostStruct(&c->state, MACHO_I386_THREAD_STATE_struct, image_endianess);
					break;
				}
				break;
			case MACHO_CPU_TYPE_X86_64:
				switch (c->flavor) {
				case FLAVOR_X86_64_THREAD_STATE:
					createHostStruct(&c->state, MACHO_X86_64_THREAD_STATE_struct, image_endianess);
					break;
				}
				break;
			case MACHO_CPU_TYPE_POWERPC:
				switch (c->flavor) {
				case FLAVOR_PPC_THREAD_STATE:
					createHostStruct(&c->state, MACHO_PPC_THREAD_STATE_struct, image_endianess);
					break;
				}
				break;
			case MACHO_CPU_TYPE_POWERPC64:
				switch (c->flavor) {
				case FLAVOR_PPC_64_THREAD_STATE:
					createHostStruct(&c->state, MACHO_PPC_64_THREAD_STATE_struct, image_endianess);
					break;
				}
				break;
			}
			break;
		}
		default:
			createHostStruct(macho_shared->cmds.cmds[i], MACHO_COMMAND_struct, image_endianess);
		}
		ofs += cmd.cmdsize;
		macho_shared->cmds.count++;
	}

	/* read sections */
	if (_64) {
		ofs = header_ofs + sizeof macho_shared->header64;
	} else {
		ofs = header_ofs + sizeof macho_shared->header;
	}
	macho_shared->section_count = nsections;
	macho_shared->sections = ht_malloc(sizeof (MACHO_SECTION_U) * macho_shared->section_count);
	uint sec = 0;
	for (uint i=0; i < macho_shared->cmds.count; i++) {
		if (macho_shared->cmds.cmds[i]->cmd.cmd == LC_SEGMENT) {
			FileOfs sofs = ofs + sizeof (MACHO_SEGMENT_COMMAND);
			file->seek(sofs);
			for (uint j=0; j < macho_shared->cmds.cmds[i]->segment.nsects; j++) {
				macho_shared->sections[sec]._64 = false;
				file->read(&macho_shared->sections[sec].s, sizeof (MACHO_SECTION));
				createHostStruct(&macho_shared->sections[sec].s, MACHO_SECTION_struct, image_endianess);
				sec++;
			}
		} else if (macho_shared->cmds.cmds[i]->cmd.cmd == LC_SEGMENT_64) {
			FileOfs sofs = ofs + sizeof (MACHO_SEGMENT_64_COMMAND);
			file->seek(sofs);
			for (uint j=0; j < macho_shared->cmds.cmds[i]->segment_64.nsects; j++) {
				macho_shared->sections[sec]._64 = true;
				file->read(&macho_shared->sections[sec].s64, sizeof (MACHO_SECTION_64));
				createHostStruct(&macho_shared->sections[sec].s64, MACHO_SECTION_64_struct, image_endianess);
				sec++;
			}
		}
		ofs += macho_shared->cmds.cmds[i]->cmd.cmdsize;
	}

	/* init ifs */
	ht_format_group::init_ifs(ifs);
}

/*
 *	address conversion routines
 */

bool macho_phys_and_mem_section(MACHO_SECTION_U *s)
{
	return true;
}

bool macho_valid_section(MACHO_SECTION_U *s)
{
	return true;
}

bool macho_addr_to_ofs(MACHO_SECTION_U *s, uint section_count, MACHOAddress addr, FileOfs *ofs)
{
	for (uint i=0; i < section_count; i++) {
		if (macho_phys_and_mem_section(s)) {
			if (s->_64) {
				if (addr >= s->s64.vmaddr 
				 && addr < s->s64.vmaddr + s->s64.vmsize) {
					*ofs = addr - s->s64.vmaddr + s->s64.fileoff;
					return true;
				}
			} else {
				if (addr >= s->s.vmaddr 
				 && addr < s->s.vmaddr + s->s.vmsize) {
					*ofs = addr - s->s.vmaddr + s->s.fileoff;
					return true;
				}
			}
		}
		s++;
	}
	return false;
}

bool macho_addr_to_section(MACHO_SECTION_U *s, uint section_count, MACHOAddress addr, int *section)
{
	for (uint i=0; i < section_count; i++) {
		if (s->_64) {
			if (macho_valid_section(s) && addr >= s->s64.vmaddr && addr < s->s64.vmaddr + s->s64.vmsize) {
				*section = i;
				return true;
			}
		} else {
			if (macho_valid_section(s) && addr >= s->s.vmaddr && addr < s->s.vmaddr + s->s.vmsize) {
				*section = i;
				return true;
			}
		}
		s++;
	}
	return false;
}

bool macho_addr_is_valid(MACHO_SECTION_U *s, uint section_count, MACHOAddress addr)
{
	for (uint i=0; i < section_count; i++) {
		if (s->_64) {
			if (macho_valid_section(s) && addr >= s->s64.vmaddr && addr < s->s64.vmaddr + s->s64.vmsize) {
				return true;
			}
		} else {
			if (macho_valid_section(s) && addr >= s->s.vmaddr && addr < s->s.vmaddr + s->s.vmsize) {
				return true;
			}
		}
		s++;
	}
	return false;
}

/*
 *	offset conversion routines
 */

bool macho_ofs_to_addr(MACHO_SECTION_U *s, uint section_count, FileOfs ofs, MACHOAddress *addr)
{
	for (uint i=0; i < section_count; i++) {
		if (s->_64) {
			if (macho_phys_and_mem_section(s) && ofs >= s->s64.fileoff && ofs < s->s64.fileoff+s->s64.vmsize) {
				*addr = ofs - s->s64.fileoff + s->s64.vmaddr;
				return true;
			}
		} else {
			if (macho_phys_and_mem_section(s) && ofs >= s->s.fileoff && ofs < s->s.fileoff+s->s.vmsize) {
				*addr = ofs - s->s.fileoff + s->s.vmaddr;
				return true;
			}
		}
		s++;
	}
	return false;
}

bool macho_ofs_to_section(MACHO_SECTION_U *s, uint section_count, FileOfs ofs, int *section)
{
	for (uint i=0; i < section_count; i++) {
		if (s->_64) {
			if (macho_valid_section(s) && ofs >= s->s64.fileoff && ofs < s->s64.fileoff+s->s64.vmsize) {
				*section = i;
				return true;
			}
		} else {
			if (macho_valid_section(s) && ofs >= s->s.fileoff && ofs < s->s.fileoff+s->s.vmsize) {
				*section = i;
				return true;
			}
		}
		s++;
	}
	return false;
}