1#include <stdio.h>
  2#include <stdlib.h>
  3#include <stddef.h>
  4#include <string.h>
  5#include "vos_program_module.h"
  6
  7static uint16_t big16(uint8_t ** src)
  8{
  9	uint16_t ret = *((*src)++) << 8;
 10	ret |= *((*src)++);
 11	return ret;
 12}
 13
 14static uint32_t big32(uint8_t ** src)
 15{
 16	uint32_t ret = *((*src)++) << 24;
 17	ret |= *((*src)++) << 16;
 18	ret |= *((*src)++) << 8;
 19	ret |= *((*src)++);
 20	return ret;
 21}
 22
 23static void string_(uint8_t ** src, uint16_t *len, char * str, uint32_t storage)
 24{
 25	*len = big16(src);
 26	memcpy(str, *src, storage);
 27	*src += storage;
 28	if (*len >= storage)
 29	{
 30		*len = storage;
 31	} else {
 32		str[*len] = 0;
 33	}
 34	if (storage & 1)
 35	{
 36		(*src)++;
 37	}
 38}
 39
 40#define string(src, field) string_(src, &(field).len, (field).str, sizeof((field).str))
 41
 42
 43int vos_read_header(FILE * f, vos_program_module *out)
 44{
 45	uint8_t buffer[4096];
 46	if (fread(buffer, 1, sizeof(buffer), f) != sizeof(buffer))
 47	{
 48		return 0;
 49	}
 50	uint8_t *cur = buffer;
 51	out->version = big16(&cur);
 52	string(&cur, out->binder_version);
 53	string(&cur, out->binder_options);
 54	string(&cur, out->system_name);
 55	string(&cur, out->user_name);
 56	out->date_bound = big32(&cur);
 57	out->main_entry_link.code_address = big32(&cur);
 58	out->main_entry_link.static_address = big32(&cur);
 59	out->user_boundary = big32(&cur);
 60	out->n_modules = big16(&cur);
 61	out->n_external_vars = big16(&cur);
 62	out->n_link_names = big16(&cur);
 63	out->n_unsnapped_links = big16(&cur);
 64	out->n_vm_pages = big16(&cur);
 65	out->n_header_pages = big16(&cur);
 66	for (int i = 0; i < 3; i++)
 67	{
 68		for (int j = 0; j < 4; j++)
 69		{
 70			out->info[i][j].address = big32(&cur);
 71			out->info[i][j].len = big32(&cur);
 72		}
 73	}
 74	out->module_map_address = big32(&cur);
 75	out->module_map_len = big32(&cur);
 76	out->external_vars_map_address = big32(&cur);
 77	out->external_vars_map_len = big32(&cur);
 78	out->link_names_map_address = big32(&cur);
 79	out->link_names_map_len = big32(&cur);
 80	out->link_map_address = big32(&cur);
 81	out->link_map_len = big32(&cur);
 82	out->header_address = big32(&cur);
 83	out->header_len = big32(&cur);
 84	memcpy(out->access_info, cur, sizeof(out->access_info));
 85	cur += sizeof(out->access_info);
 86	out->flags = big32(&cur);
 87	out->n_tasks = big16(&cur);
 88	for (int i = 0; i < 3; i++)
 89	{
 90		out->task_static_len[i] = big32(&cur);
 91	}
 92	out->stack_len = big32(&cur);
 93	out->n_entries = big16(&cur);
 94	out->entry_map_address = big32(&cur);
 95	out->entry_map_len = big32(&cur);
 96	out->pop_version = big16(&cur);
 97	out->processor = big16(&cur);
 98	string(&cur, out->release_name);
 99	out->relocation_info.map_address = big32(&cur);
100	out->relocation_info.map_len = big32(&cur);
101	out->relocation_info.n_relocations = big32(&cur);
102	out->high_water_mark = big32(&cur);
103	string(&cur, out->copyright_notice);
104	for (int i = 0; i < 14; i++)
105	{
106		out->module_origins[i] = big32(&cur);
107	}
108	out->processor_family = big16(&cur);
109	string(&cur, out->program_name);
110	out->string_pool_address = big32(&cur);
111	out->string_pool_len = big32(&cur);
112	out->obj_dir_map_address = big32(&cur);
113	out->obj_dir_map_len = big32(&cur);
114	for (int i = 0; i < 3; i++)
115	{
116		out->global_offset_table_address[i] = big32(&cur);
117	}
118	for (int i = 0; i < 3; i++)
119	{
120		out->block_map_info[i].address = big32(&cur);
121		out->block_map_info[i].len = big32(&cur);
122	}
123	out->section_map_file_address = big32(&cur);
124	out->section_map_address = big32(&cur);
125	out->section_map_len = big32(&cur);
126	out->n_sections = big16(&cur);
127	out->max_heap_size = big32(&cur);
128	out->max_program_size = big32(&cur);
129	out->max_stack_size = big32(&cur);
130	out->stack_fence_size = big32(&cur);
131
132	out->module_map_entries = NULL;
133	out->external_vars = NULL;
134	return 1;
135}
136
137#define MODULE_MAP_ENTRY_SIZE 74
138
139int vos_read_alloc_module_map(FILE * f, vos_program_module *header)
140{
141	if (header->module_map_len != header->n_modules * MODULE_MAP_ENTRY_SIZE)
142	{
143		return 0;
144	}
145	uint8_t * buf = malloc(header->module_map_len);
146	fseek(f, header->module_map_address + 0x1000 - header->user_boundary, SEEK_SET);
147	if (fread(buf, 1, header->module_map_len, f) != header->module_map_len)
148	{
149		free(buf);
150		return 0;
151	}
152	uint8_t * cur = buf;
153	header->module_map_entries = malloc(sizeof(vos_module_map_entry) * header->n_modules);
154	for (int i = 0; i < header->n_modules; i++)
155	{
156		string(&cur, header->module_map_entries[i].name);
157		for (int j = 0; j < 5; j++)
158		{
159			header->module_map_entries[i].unknown[j] = big16(&cur);
160		}
161		header->module_map_entries[i].code_address = big32(&cur);
162		header->module_map_entries[i].code_length = big32(&cur);
163		header->module_map_entries[i].foo_address = big32(&cur);
164		header->module_map_entries[i].foo_length = big32(&cur);
165		header->module_map_entries[i].bar_address = big32(&cur);
166		header->module_map_entries[i].bar_length = big32(&cur);
167		for (int j = 0; j < 3; j++)
168		{
169			header->module_map_entries[i].unknown2[j] = big16(&cur);
170		}
171	}
172	return 1;
173}
174
175#define EXTERNAL_VAR_ENTRY_SIZE 44
176
177int vos_read_alloc_external_vars(FILE * f, vos_program_module *header)
178{
179	if (header->external_vars_map_len != header->n_external_vars * EXTERNAL_VAR_ENTRY_SIZE)
180	{
181		return 0;
182	}
183	uint8_t * buf = malloc(header->external_vars_map_len);
184	fseek(f, header->external_vars_map_address + 0x1000 - header->user_boundary, SEEK_SET);
185	if (fread(buf, 1, header->external_vars_map_len, f) != header->external_vars_map_len)
186	{
187		free(buf);
188		return 0;
189	}
190	uint8_t * cur = buf;
191	header->external_vars = malloc(sizeof(vos_external_var_entry) * header->n_external_vars);
192	for (int i = 0; i < header->n_external_vars; i++)
193	{
194		string(&cur, header->external_vars[i].name);
195		header->external_vars[i].address = big32(&cur);
196		for (int j = 0; j < 3; j++)
197		{
198			header->external_vars[i].unknown[j] = big16(&cur);
199		}
200	}
201	return 1;
202}
203
204void vos_header_cleanup(vos_program_module *header)
205{
206	free(header->module_map_entries);
207	free(header->external_vars);
208}