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	void* __fastcall load_pe(const char *path)
		47	{
		48	md_t *md;
		49
		50
		51
		52
		53	return (void*)md->base;
		54
		55
		56	};
		57	*/
		58
		59
914	serge	60	{
892	serge	61	PIMAGE_DOS_HEADER dos;
		62	PIMAGE_NT_HEADERS32 nt;
		63
		64
		65
		66
		67	return false;
		68
		69
		70	return false;
		71
		72
		73
		74
		75	return false;
		76
		77
		78	return false;
		79
		80
914	serge	81	return false;
		82
		83
		84	return false;
		85
		86
892	serge	87	return false;
		88
		89
914	serge	90	return false;
		91
		92
892	serge	93	{
		94	if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)
		95	return false;
		96	}
		97	else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment)
		98	return false;
		99
		100
		101	!IsPowerOf2(nt->OptionalHeader.FileAlignment))
		102	return false;
		103
		104
		105	return false;
		106
		107
		108	}
		109
		110
1066	serge	111	{
892	serge	112	PIMAGE_DOS_HEADER dos;
		113	PIMAGE_NT_HEADERS32 nt;
		114
		115
1066	serge	116
892	serge	117
		118	addr_t img_base;
		119	count_t img_pages;
		120
		121
		122	void *raw;
		123
		124
		125
		126
		127
		128
		129
		130
		131	{
		132	DBG("file not found: %s\n", path);
		133	return NULL;
		134	};
		135
		136
914	serge	137	{
2971	Serge	138	DBG("invalid pe file %s\n", path);
892	serge	139	mem_free(raw);
		140	return NULL;
2971	Serge	141	}
		142
892	serge	143
		144	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		145
		146
		147
		148
1066	serge	149
892	serge	150
1066	serge	151
892	serge	152
1066	serge	153	{
892	serge	154	mem_free(raw);
		155	return NULL;
		156	};
		157
		158
1066	serge	159
892	serge	160
914	serge	161
892	serge	162
		163
		164
		165	// nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		166
		167
1066	serge	168	};
892	serge	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	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		213
		214
		215
		216
		217
		218
		219
		220
		221	{
		222	addr_t src_ptr;
		223	addr_t dest_ptr;
		224	size_t sec_size;
		225
		226
		227	dest_ptr = MakePtr(addr_t,img_base, img_sec->VirtualAddress);
		228
		229
		230	sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);
		231
		232
914	serge	233	{
		234	sec_size = (img_sec->Misc.VirtualSize + sec_align -1) & -sec_align;
2971	Serge	235
892	serge	236
2971	Serge	237	sec_clear(dest_ptr + img_sec->SizeOfRawData,
		238	sec_size - img_sec->SizeOfRawData);
		239	};
914	serge	240	img_sec++;
892	serge	241	};
914	serge	242
892	serge	243
		244	{
		245	PIMAGE_BASE_RELOCATION reloc;
		246
		247
		248
		249
		250
		251
		252	nt->OptionalHeader.DataDirectory[5].VirtualAddress);
		253
		254
		255	{
		256	u32_t cnt;
		257	u16_t *entry;
		258	u16_t reltype;
		259	u32_t offs;
		260
		261
		262	entry = MakePtr( u16_t, reloc, sizeof(reloc) );
		263
		264
		265	{
		266	u16_t *p16;
		267	u32_t *p32;
		268
		269
		270	offs = (*entry & 0x0FFF) + reloc->VirtualAddress;
		271	switch(reltype)
		272	{
		273	case 1:
		274	p16 = MakePtr(u16_t*, img_base, offs);
		275	*p16+= (u16_t)(delta>>16);
		276	break;
		277	case 2:
		278	p16 = MakePtr(u16_t*, img_base, offs);
		279	*p16+= (u16_t)delta;
		280	break;
		281	case 3:
		282	p32 = MakePtr(u32_t*, img_base, offs);
		283	*p32+= delta;
		284	}
		285	entry++;
		286	}
		287	reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock);
		288	}
		289	};
		290
		291
		292	nt->OptionalHeader.SizeOfImage, nt->FileHeader.NumberOfSections);
		293	};
		294
		295
		296
		297	{
		298	PIMAGE_DOS_HEADER dos;
		299	PIMAGE_NT_HEADERS32 nt;
		300
		301
		302
		303
		304
		305
		306	nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
		307
		308
		309	{
		310	PIMAGE_IMPORT_DESCRIPTOR imp;
		311
		312
		313	nt->OptionalHeader.DataDirectory[1].VirtualAddress);
		314
		315
		316	{
		317	PIMAGE_THUNK_DATA32 thunk;
		318
		319
		320	PIMAGE_NT_HEADERS32 expnt;
		321	PIMAGE_EXPORT_DIRECTORY exp;
		322
		323
		324	char *libname;
		325	addr_t *functions;
		326	u16_t *ordinals;
		327	char **funcname;
		328
		329
		330
		331
		332	break;
		333
		334
		335
		336
		337
		338
908	serge	339	if(exp_dll != NULL)
892	serge	340	{
		341	DBG("find %s\n", exp_dll->img_name);
		342	}
		343	else
		344	{
		345	DBG("can't find %s\n", libname);
		346	return false;
		347	}
		348
		349
		350
		351
		352	ordinals = MakePtr(WORD*, exp->AddressOfNameOrdinals,exp_dll->img_base);
		353	funcname = MakePtr(char**, exp->AddressOfNames,exp_dll->img_base);
		354
		355
		356	imp->Characteristics, img_base);
		357	iat= MakePtr(DWORD*,imp->FirstThunk, img_base);
		358
		359
		360	{
		361	PIMAGE_IMPORT_BY_NAME ord;
		362	addr_t addr;
		363
		364
		365	break;
		366
		367
		368	{
		369	// printf(" %4u\n", thunk->u1.Ordinal & 0xFFFF);
		370	break;
		371	}
		372	else
		373	{
		374	ord = MakePtr(PIMAGE_IMPORT_BY_NAME,
		375	thunk->u1.AddressOfData, img_base);
		376	*iat=0;
		377
		378
		379
		380
		381	MakePtr(char*,funcname[ord->Hint],exp_dll->img_base),32))
		382	{
		383	int ind;
		384	char **names=funcname;
		385
		386
		387	ind < exp->NumberOfNames; names++,ind++)
		388	{
		389	if(!strncmp(ord->Name,MakePtr(char,names,exp_dll->img_base),32))
		390	{
		391	u16_t ordinal;
908	serge	392	ordinal = ordinals[ind];
		393	DBG(" \t\tat %x\n", functions[ordinal] + exp_dll->img_base);
		394	*iat = functions[ordinal] + exp_dll->img_base;
		395	break;
892	serge	396	};
		397	};
		398	if(ind == exp->NumberOfNames)
		399	{
		400	DBG(" unresolved import %s\n",ord->Name);
		401	warn=1;
		402	};
		403	}
		404	else
		405	{
		406	DBG(" \tat %x\n", functions[ord->Hint] + exp_dll->img_base);
		407	*iat = functions[ord->Hint] + exp_dll->img_base;
		408	};
		409	};
		410	thunk++; // Advance to next thunk
		411	iat++;
		412	}
		413	imp++; // advance to next IMAGE_IMPORT_DESCRIPTOR
		414	};
		415	};
		416
		417
		418	return true;
		419	else
2971	Serge	420	return false;
892	serge	421	}
		422

Subversion Repositories Kolibri OS

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