WebSVN – Kolibri OS – Blame – /kernel/branches/kolibri_pe/core/pe.c

Rev	Author	Line No.	Line
892	serge	1
		2	#include
		3	#include
		4	#include
		5	#include
		6	#include
		7	#include
		8
		9
		10
		11	{
		12	if(val == 0)
		13	return false;
		14	return (val & (val - 1)) == 0;
		15	}
		16
		17
		18
		19	{
		20	u32_t tmp;
		21	__asm__ __volatile__ (
		22	"shrl $2, %%ecx \n\t"
		23	"rep movsl"
		24	:"=c"(tmp),"=S"(tmp),"=D"(tmp)
		25	:"c"(len),"S"(src),"D"(dst)
		26	:"cc");
		27	};
		28
		29
		30	{
		31	u32_t tmp;
		32	__asm__ __volatile__ (
		33	"xorl %%eax, %%eax \n\t"
		34	"rep stosb"
		35	:"=c"(tmp),"=D"(tmp)
		36	:"c"(len),"D"(dst)
		37	:"eax","cc");
		38	};
		39
		40
		41
		42
		43
		44
		45
		46
		47	void* __fastcall load_pe(const char *path)
		48	{
		49	md_t *md;
		50
		51
		52
		53
		54	return (void*)md->base;
		55
		56
		57	};
		58	*/
		59
		60
914	serge	61	{
892	serge	62	PIMAGE_DOS_HEADER dos;
		63	PIMAGE_NT_HEADERS32 nt;
		64
		65
		66
		67
		68	return false;
		69
		70
		71	return false;
		72
		73
		74
		75
		76	return false;
		77
		78
		79	return false;
		80
		81
914	serge	82	return false;
		83
		84
		85	return false;
		86
		87
892	serge	88	return false;
		89
		90
914	serge	91	return false;
		92
		93
892	serge	94	{
		95	if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)
		96	return false;
		97	}
		98	else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment)
		99	return false;
		100
		101
		102	!IsPowerOf2(nt->OptionalHeader.FileAlignment))
		103	return false;
		104
		105
		106	return false;
		107
		108
		109	}
		110
		111
		112	{
		113	PIMAGE_DOS_HEADER dos;
		114	PIMAGE_NT_HEADERS32 nt;
		115
		116
		117
		118
		119	addr_t img_base;
		120	count_t img_pages;
		121
		122
		123	void *raw;
		124
		125
		126
		127
		128
		129
		130
		131
		132	{
		133	DBG("file not found: %s\n", path);
		134	return NULL;
		135	};
		136
		137
914	serge	138	{
892	serge	139	DBG("invalid pe file %s\n", path);
		140	mem_free(raw);
		141	return NULL;
		142	}
		143
		144
		145	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		146
		147
		148
		149
		150
		151
		152
		153	{
		154	mem_free(raw);
		155	return NULL;
		156	};
		157
		158
		159
		160
914	serge	161
892	serge	162
		163
		164
		165	// nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		166
		167
		168	};
		169
		170
		171
		172	addr_t get_proc_addr(addr_t module, char *name)
		173	{
		174	PIMAGE_DOS_HEADER expdos;
		175	PIMAGE_NT_HEADERS32 expnt;
		176	PIMAGE_EXPORT_DIRECTORY exp;
		177	u32_t *functions;
		178	char **funcname;
		179	int ind;
		180
		181
		182	expnt = MakePtr( PIMAGE_NT_HEADERS32, expdos, expdos->e_lfanew);
		183
		184
		185	expnt->OptionalHeader.DataDirectory[0].VirtualAddress);
		186
		187
		188	funcname = MakePtr(char**,exp->AddressOfNames,module);
		189
		190
		191	{
		192	if(!strcmp(name,MakePtr(char,funcname,module)))
		193	return functions[ind] + module;
		194	};
		195	return -1;
		196	};
		197	*/
		198
		199
		200
914	serge	201	{
892	serge	202	PIMAGE_DOS_HEADER dos;
		203	PIMAGE_NT_HEADERS32 nt;
		204	PIMAGE_SECTION_HEADER img_sec;
		205
		206
		207	int i;
		208
		209
		210
		211
		212
		213	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		214
		215
		216
		217
		218
		219
		220
		221
		222	{
		223	addr_t src_ptr;
		224	addr_t dest_ptr;
		225	size_t sec_size;
		226
		227
		228	dest_ptr = MakePtr(addr_t,img_base, img_sec->VirtualAddress);
		229
		230
		231	sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);
		232
		233
914	serge	234	{
		235	sec_size = (img_sec->Misc.VirtualSize + sec_align -1) & -sec_align;
892	serge	236
		237
		238	sec_clear(dest_ptr + img_sec->SizeOfRawData,
		239	sec_size - img_sec->SizeOfRawData);
		240	};
914	serge	241	img_sec++;
892	serge	242	};
914	serge	243
892	serge	244
		245	{
		246	PIMAGE_BASE_RELOCATION reloc;
		247
		248
		249
		250
		251
		252
		253	nt->OptionalHeader.DataDirectory[5].VirtualAddress);
		254
		255
		256	{
		257	u32_t cnt;
		258	u16_t *entry;
		259	u16_t reltype;
		260	u32_t offs;
		261
		262
		263	entry = MakePtr( u16_t, reloc, sizeof(reloc) );
		264
		265
		266	{
		267	u16_t *p16;
		268	u32_t *p32;
		269
		270
		271	offs = (*entry & 0x0FFF) + reloc->VirtualAddress;
		272	switch(reltype)
		273	{
		274	case 1:
		275	p16 = MakePtr(u16_t*, img_base, offs);
		276	*p16+= (u16_t)(delta>>16);
		277	break;
		278	case 2:
		279	p16 = MakePtr(u16_t*, img_base, offs);
		280	*p16+= (u16_t)delta;
		281	break;
		282	case 3:
		283	p32 = MakePtr(u32_t*, img_base, offs);
		284	*p32+= delta;
		285	}
		286	entry++;
		287	}
		288	reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock);
		289	}
		290	};
		291
		292
		293	nt->OptionalHeader.SizeOfImage, nt->FileHeader.NumberOfSections);
		294	};
		295
		296
		297
		298	{
		299	PIMAGE_DOS_HEADER dos;
		300	PIMAGE_NT_HEADERS32 nt;
		301
		302
		303
		304
		305
		306
		307	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		308
		309
		310	{
		311	PIMAGE_IMPORT_DESCRIPTOR imp;
		312
		313
		314	nt->OptionalHeader.DataDirectory[1].VirtualAddress);
		315
		316
		317
		318
		319	{
		320	PIMAGE_THUNK_DATA32 thunk;
		321
		322
		323	PIMAGE_NT_HEADERS32 expnt;
		324	PIMAGE_EXPORT_DIRECTORY exp;
		325
		326
		327	char *libname;
		328	addr_t *functions;
		329	u16_t *ordinals;
		330	char **funcname;
		331
		332
		333
		334
		335	break;
		336
		337
		338
		339
		340
		341
908	serge	342	if(exp_dll != NULL)
892	serge	343	{
		344	DBG("find %s\n", exp_dll->img_name);
		345	}
		346	else
		347	{
		348	DBG("can't find %s\n", libname);
		349	return false;
		350	}
		351
		352
		353
		354
		355	ordinals = MakePtr(WORD*, exp->AddressOfNameOrdinals,exp_dll->img_base);
		356	funcname = MakePtr(char**, exp->AddressOfNames,exp_dll->img_base);
		357
		358
		359	imp->Characteristics, img_base);
		360	iat= MakePtr(DWORD*,imp->FirstThunk, img_base);
		361
		362
		363	{
		364	PIMAGE_IMPORT_BY_NAME ord;
		365	addr_t addr;
		366
		367
		368	break;
		369
		370
		371	{
		372	// printf(" %4u\n", thunk->u1.Ordinal & 0xFFFF);
		373	break;
		374	}
		375	else
		376	{
		377	ord = MakePtr(PIMAGE_IMPORT_BY_NAME,
		378	thunk->u1.AddressOfData, img_base);
		379	*iat=0;
		380
		381
		382
		383
		384	MakePtr(char*,funcname[ord->Hint],exp_dll->img_base),32))
		385	{
		386	int ind;
		387	char **names=funcname;
		388
		389
		390	ind < exp->NumberOfNames; names++,ind++)
		391	{
		392	if(!strncmp(ord->Name,MakePtr(char,names,exp_dll->img_base),32))
		393	{
		394	u16_t ordinal;
908	serge	395	ordinal = ordinals[ind];
		396	DBG(" \t\tat %x\n", functions[ordinal] + exp_dll->img_base);
		397	*iat = functions[ordinal] + exp_dll->img_base;
		398	break;
892	serge	399	};
		400	};
		401	if(ind == exp->NumberOfNames)
		402	{
		403	DBG(" unresolved import %s\n",ord->Name);
		404	warn=1;
		405	};
		406	}
		407	else
		408	{
		409	DBG(" \tat %x\n", functions[ord->Hint] + exp_dll->img_base);
		410	*iat = functions[ord->Hint] + exp_dll->img_base;
		411	};
		412	};
		413	thunk++; // Advance to next thunk
		414	iat++;
		415	}
		416	imp++; // advance to next IMAGE_IMPORT_DESCRIPTOR
		417	};
		418	};
		419
		420
		421	return true;
		422	else
		423	return false;
		424	}
		425

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/pe.c – Rev 914