Context Navigation

kLibTweaker.c

Last change on this file was 2791, checked in by bird, 10 years ago
kLibTweaker: New tool for playing with Microsoft import libraries (currently).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.0 KB

Rev	Line
[1001]	1	/* $Id: kLibTweaker.c 2791 2015-09-15 22:57:44Z bird $ */
	2	/** @file
[2791]	3	* kLibTweaker - Import library tweaker for windows.
[1184]	4	*/
	5
	6	/*
[2791]	7	* Copyright (c) 2007-2015 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
[1001]	8	*
	9	* This file is part of kBuild.
	10	*
	11	* kBuild is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
[2019]	13	* the Free Software Foundation; either version 3 of the License, or
[1001]	14	* (at your option) any later version.
	15	*
	16	* kBuild is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
[2019]	22	* along with kBuild. If not, see <http://www.gnu.org/licenses/>
[1001]	23	*
	24	*/
	25
[2791]	26	/*********************************************************************************************************************************
	27	* Header Files *
	28	*********************************************************************************************************************************/
[1042]	29	#if 0
	30	# define ELECTRIC_HEAP
	31	# include "../kmk/electric.h"
[2627]	32	# include "../kmk/electric.c"
[1042]	33	#endif
[2791]	34	#include <ctype.h>
[1001]	35	#include <string.h>
	36	#include <stdlib.h>
	37	#include <stdarg.h>
	38	#include <stdio.h>
	39	#include <errno.h>
	40	#include <assert.h>
[1040]	41
[2791]	42	#include "k/kLdrFmts/pe.h"
[1001]	43
[1040]	44
[2791]	45	/*********************************************************************************************************************************
	46	* Structures and Typedefs *
	47	*********************************************************************************************************************************/
	48	/**
	49	* Microsoft import library archive header.
	50	*
	51	* This has the same size as a COFF header, which is probably not a coincidence.
	52	*/
	53	typedef struct COFFIMPLIBHDR
	54	{
	55	KU16 uSig1; /* 0 */
	56	KU16 uSig2; /* 0xffff */
	57	KU16 uVersion; /* 0 */
	58	KU16 uMachine; /* IMAGE_FILE_MACHINE_I386, ... */
	59	KU32 uTimeDateStamp;
	60	KU32 cbData;
	61	KU16 uOrdinalOrHint;
	62	KU16 uFlags;
	63	} COFFIMPLIBHDR;
[1001]	64
[2791]	65	/**
	66	* COFF symbol.
	67	*
	68	* This one has an odd size and will cause misaligned accesses on platforms
	69	* which cares about such.
	70	*/
	71	#pragma pack(1)
	72	typedef struct COFFSYMBOL
	73	{
	74	union
	75	{
	76	char e_name[8];
	77	struct
	78	{
	79	KU32 e_zeros; /*< Zero to distinguish it from ascii name. /
	80	KU32 e_offset; /*< String table offset. /
	81	} e;
	82	} e;
	83	KU32 e_value;
	84	KI16 e_scnum;
	85	KU16 e_type;
	86	KU8 e_sclass;
	87	KU8 e_numaux;
	88	} COFFSYMBOL;
	89	#pragma pack()
[1003]	90
[2791]	91	/**
	92	* Archive file header.
	93	*/
	94	typedef struct ARCHFILEHDR
	95	{
	96	char achName[16];
	97	char achModtime[12];
	98	char achOwnerId[6];
	99	char achGroupId[6];
	100	char achMode[8];
	101	char achSize[10];
	102	char achMagic[2];
	103	} ARCHFILEHDR;
[1044]	104
[2612]	105
[2791]	106	/*********************************************************************************************************************************
	107	* Global Variables *
	108	*********************************************************************************************************************************/
[1040]	109	/** Whether verbose output is enabled. */
	110	static unsigned g_cVerbosityLevel = 0;
	111	/** What to prefix the errors with. */
	112	static char g_szErrorPrefix[128];
[1005]	113
[1040]	114
	115	void FatalMsg(const char *pszFormat, ...)
	116	{
	117	va_list va;
	118
	119	if (g_szErrorPrefix[0])
	120	fprintf(stderr, "%s - fatal error: ", g_szErrorPrefix);
	121	else
	122	fprintf(stderr, "fatal error: ");
	123
	124	va_start(va, pszFormat);
	125	vfprintf(stderr, pszFormat, va);
	126	va_end(va);
	127	}
	128
	129
	130	void FatalDie(const char *pszFormat, ...)
	131	{
	132	va_list va;
	133
	134	if (g_szErrorPrefix[0])
	135	fprintf(stderr, "%s - fatal error: ", g_szErrorPrefix);
	136	else
	137	fprintf(stderr, "fatal error: ");
	138
	139	va_start(va, pszFormat);
	140	vfprintf(stderr, pszFormat, va);
	141	va_end(va);
	142
	143	exit(1);
	144	}
	145
	146
[2791]	147	static int ErrorMsg(const char *pszFormat, ...)
[1040]	148	{
	149	va_list va;
	150
	151	if (g_szErrorPrefix[0])
	152	fprintf(stderr, "%s - error: ", g_szErrorPrefix);
	153	else
	154	fprintf(stderr, "error: ");
	155
	156	va_start(va, pszFormat);
	157	vfprintf(stderr, pszFormat, va);
	158	va_end(va);
[2791]	159
	160	return 1;
[1040]	161	}
	162
	163
	164	static void InfoMsg(unsigned uLevel, const char *pszFormat, ...)
	165	{
	166	if (uLevel <= g_cVerbosityLevel)
	167	{
	168	va_list va;
	169
	170	if (g_szErrorPrefix[0])
	171	fprintf(stderr, "%s - info: ", g_szErrorPrefix);
	172	else
	173	fprintf(stderr, "info: ");
	174
	175	va_start(va, pszFormat);
	176	vfprintf(stderr, pszFormat, va);
	177	va_end(va);
	178	}
	179	}
	180
	181
	182	static void SetErrorPrefix(const char *pszPrefix, ...)
	183	{
	184	int cch;
	185	va_list va;
	186
	187	va_start(va, pszPrefix);
	188	#if defined(_MSC_VER) \|\| defined(__sun__)
	189	cch = vsprintf(g_szErrorPrefix, pszPrefix, va);
	190	if (cch >= sizeof(g_szErrorPrefix))
	191	FatalDie("Buffer overflow setting error prefix!\n");
	192	#else
	193	vsnprintf(g_szErrorPrefix, sizeof(g_szErrorPrefix), pszPrefix, va);
	194	#endif
	195	va_end(va);
	196	(void)cch;
	197	}
	198
[1042]	199	#ifndef ELECTRIC_HEAP
[1040]	200	void *xmalloc(size_t cb)
	201	{
	202	void *pv = malloc(cb);
	203	if (!pv)
[1044]	204	FatalDie("out of memory (%d)\n", (int)cb);
[1040]	205	return pv;
	206	}
	207
	208
	209	void xrealloc(void pvOld, size_t cb)
	210	{
	211	void *pv = realloc(pvOld, cb);
	212	if (!pv)
[1044]	213	FatalDie("out of memory (%d)\n", (int)cb);
[1040]	214	return pv;
	215	}
	216
	217
	218	char xstrdup(const char pszIn)
	219	{
[2456]	220	char *psz;
	221	if (pszIn)
	222	{
	223	psz = strdup(pszIn);
	224	if (!psz)
	225	FatalDie("out of memory (%d)\n", (int)strlen(pszIn));
	226	}
	227	else
	228	psz = NULL;
[1040]	229	return psz;
	230	}
[1042]	231	#endif
[1040]	232
	233
[1042]	234	void *xmallocz(size_t cb)
	235	{
	236	void *pv = xmalloc(cb);
	237	memset(pv, 0, cb);
	238	return pv;
	239	}
[1040]	240
[1042]	241
[1040]	242	/**
	243	* Adds the arguments found in the pszCmdLine string to argument vector.
	244	*
	245	* The parsing of the pszCmdLine string isn't very sophisticated, no
	246	* escaping or quotes.
	247	*
	248	* @param pcArgs Pointer to the argument counter.
	249	* @param ppapszArgs Pointer to the argument vector pointer.
	250	* @param pszCmdLine The command line to parse and append.
	251	* @param pszWedgeArg Argument to put infront of anything found in pszCmdLine.
	252	*/
	253	static void AppendArgs(int pcArgs, char *ppapszArgs, const char pszCmdLine, const char *pszWedgeArg)
	254	{
	255	int i;
	256	int cExtraArgs;
	257	const char *psz;
	258	char **papszArgs;
	259
	260	/*
	261	* Count the new arguments.
	262	*/
	263	cExtraArgs = 0;
	264	psz = pszCmdLine;
	265	while (*psz)
	266	{
	267	while (isspace(*psz))
	268	psz++;
	269	if (!psz)
	270	break;
	271	cExtraArgs++;
	272	while (!isspace(psz) && psz)
	273	psz++;
	274	}
	275	if (!cExtraArgs)
	276	return;
	277
	278	/*
	279	* Allocate a new vector that can hold the arguments.
	280	* (Reallocating might not work since the argv might not be allocated
	281	* from the heap but off the stack or somewhere... )
	282	*/
	283	i = *pcArgs;
[1044]	284	*pcArgs = i + cExtraArgs + !!pszWedgeArg;
	285	papszArgs = xmalloc((pcArgs + 1) sizeof(char *));
[1040]	286	ppapszArgs = memcpy(papszArgs, ppapszArgs, i * sizeof(char *));
	287
	288	if (pszWedgeArg)
	289	papszArgs[i++] = xstrdup(pszWedgeArg);
	290
	291	psz = pszCmdLine;
	292	while (*psz)
	293	{
[1044]	294	size_t cch;
[1040]	295	const char *pszEnd;
	296	while (isspace(*psz))
	297	psz++;
	298	if (!psz)
	299	break;
	300	pszEnd = psz;
	301	while (!isspace(pszEnd) && pszEnd)
	302	pszEnd++;
	303
[1044]	304	cch = pszEnd - psz;
	305	papszArgs[i] = xmalloc(cch + 1);
	306	memcpy(papszArgs[i], psz, cch);
	307	papszArgs[i][cch] = '\0';
	308
[1040]	309	i++;
[1044]	310	psz = pszEnd;
[1040]	311	}
[1044]	312
	313	papszArgs[i] = NULL;
[1040]	314	}
	315
	316
	317
	318
[2791]	319	static fpos_t kLibTweakerAsciiToSize(const char *pch, size_t cch)
[2612]	320	{
[2791]	321	fpos_t cb = 0;
[1040]	322
[2791]	323	/* strip leading spaces. */
	324	while (cch > 0 && (pch == ' ' \|\| pch == '\t'))
	325	cch--, pch++;
[2612]	326
[2791]	327	/* Convert decimal to binary. */
	328	while (cch-- > 0)
[2612]	329	{
[2791]	330	char ch = *pch++;
	331	if (ch >= '0' && ch <= '9')
[2612]	332	{
[2791]	333	cb *= 10;
	334	cb += ch - '0';
[2612]	335	}
[2791]	336	else
	337	break;
[2612]	338	}
	339
[2791]	340	return cb;
[2612]	341	}
	342
	343
[2791]	344	static int kLibMyReadAt(FILE pFile, void pv, size_t cb, fpos_t off, int fEofOk)
[2612]	345	{
[2791]	346	if (fsetpos(pFile, &off) == 0)
[2612]	347	{
[2791]	348	size_t cbActual = fread(pv, 1, cb, pFile);
	349	if (cbActual == cb)
	350	return 0;
	351	if (!fEofOk \|\| !feof(pFile))
	352	ErrorMsg("fread returned %#lx, expected %#lx!\n", (unsigned long)cbActual, (unsigned long)cb);
[2612]	353	}
[2791]	354	else
	355	ErrorMsg("seek error!\n");
	356	return 1;
[2612]	357	}
	358
	359
[2791]	360	static int kLibMyWriteAt(FILE pFile, const void pv, size_t cb, fpos_t off)
[2618]	361	{
[2791]	362	if (fsetpos(pFile, &off) == 0)
[2618]	363	{
[2791]	364	size_t cbActual = fwrite(pv, 1, cb, pFile);
	365	if (cbActual == cb)
	366	return 0;
	367	ErrorMsg("fwrite returned %#lx, expected %#lx!\n", (unsigned long)cbActual, (unsigned long)cb);
[2618]	368	}
[2791]	369	else
	370	ErrorMsg("seek error!\n");
	371	return 1;
[2618]	372	}
	373
	374
[2791]	375	static int kLibFillNullThunkData(FILE *pFile, fpos_t cbFile, fpos_t offFileBytes)
[2612]	376	{
[2791]	377	size_t off;
	378	IMAGE_FILE_HEADER CoffHdr;
	379	IMAGE_SECTION_HEADER SecHdr;
	380	unsigned iSecHdr;
	381	fpos_t offCur;
	382	unsigned cbMachineWord;
	383	KU32 cbStrTab;
	384	COFFSYMBOL *paSymbols;
	385	int rcRet = 0;
[2612]	386
[2616]	387	/*
[2791]	388	* Read the COFF file header and filter out unlikly files based on
	389	* section and symbol counts.
[2616]	390	*/
[2791]	391	if (cbFile <= sizeof(IMAGE_FILE_HEADER) + sizeof(IMAGE_SECTION_HEADER) * 2 + 4)
[2616]	392	return 0;
[2791]	393	if (kLibMyReadAt(pFile, &CoffHdr, sizeof(CoffHdr), offFileBytes, 0) != 0)
	394	return 1;
	395	if ( CoffHdr.Machine != IMAGE_FILE_MACHINE_I386
	396	&& CoffHdr.Machine != IMAGE_FILE_MACHINE_AMD64)
[2616]	397	return 0;
[2791]	398	cbMachineWord = CoffHdr.Machine == IMAGE_FILE_MACHINE_I386 ? 4 : 8;
	399	if ( CoffHdr.NumberOfSections == 0
	400	\|\| CoffHdr.NumberOfSymbols == 0)
[2616]	401	return 0;
[2791]	402	off = sizeof(IMAGE_FILE_HEADER) + CoffHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
	403	if ((fpos_t)off >= cbFile)
[2616]	404	return 0;
[2791]	405	if ( CoffHdr.PointerToSymbolTable >= (KU64)cbFile
	406	\|\| CoffHdr.PointerToSymbolTable < off)
	407	return 0;
[2616]	408
	409	/*
[2791]	410	* Search for the .idata$5 section which the thunk data is usually found in.
[2616]	411	*/
[2791]	412	offCur = offFileBytes + sizeof(CoffHdr);
	413	for (iSecHdr = 0; iSecHdr < CoffHdr.NumberOfSections; iSecHdr++)
[2616]	414	{
[2791]	415	if (kLibMyReadAt(pFile, &SecHdr, sizeof(SecHdr), offCur, 0) != 0)
	416	return 1;
	417	InfoMsg(2, "#2: %.8s VirtualSize=%#lx\n", SecHdr.Name, SecHdr.SizeOfRawData);
	418	if ( !memcmp(SecHdr.Name, ".idata$5", 8)
	419	&& SecHdr.SizeOfRawData == cbMachineWord)
	420	break;
	421	offCur += sizeof(SecHdr);
[2616]	422	}
[2791]	423	if (iSecHdr == CoffHdr.NumberOfSections)
[2616]	424	return 0;
	425
[2618]	426	/*
[2791]	427	* Read in the symbo and string tables.
[2618]	428	*/
[2791]	429	off = CoffHdr.PointerToSymbolTable + CoffHdr.NumberOfSymbols * sizeof(COFFSYMBOL);
	430	if (kLibMyReadAt(pFile, &cbStrTab, sizeof(cbStrTab), offFileBytes + off, 0) != 0)
[1001]	431	return 1;
[2791]	432	InfoMsg(2, "#2: Found COFF file header, cbStrTab=%#x; off=%#lx NumberOfSymbols=%#x PointerToSymbolTable=%#x\n",
	433	cbStrTab, (long)off, CoffHdr.NumberOfSymbols, CoffHdr.PointerToSymbolTable);
	434	if ( cbStrTab <= 4U
	435	\|\| cbStrTab >= 1610241024U /* 16MB */
	436	\|\| (fpos_t)off + cbStrTab > cbFile)
[1001]	437	return 0;
[2791]	438	paSymbols = xmalloc(CoffHdr.NumberOfSymbols * sizeof(COFFSYMBOL) + cbStrTab + 1);
	439	if (kLibMyReadAt(pFile, paSymbols, CoffHdr.NumberOfSymbols * sizeof(COFFSYMBOL) + cbStrTab,
	440	offFileBytes + CoffHdr.PointerToSymbolTable, 0) == 0)
[1040]	441	{
[2791]	442	char pchStrTab = (char )&paSymbols[CoffHdr.NumberOfSymbols];
	443	unsigned iSym;
[1002]	444
[2791]	445	pchStrTab[cbStrTab] = '\0';
	446	pchStrTab[0] = '\0';
	447	pchStrTab[1] = '\0';
	448	pchStrTab[2] = '\0';
	449	pchStrTab[3] = '\0';
[1002]	450
[2791]	451	for (iSym = 0; iSym < CoffHdr.NumberOfSymbols; iSym++)
[1003]	452	{
[2791]	453	static char const s_szSuffix[] = "NULL_THUNK_DATA";
	454	const char *pchName;
	455	size_t cchName;
	456	if (paSymbols[iSym].e.e.e_zeros != 0)
[1003]	457	{
[2791]	458	pchName = &paSymbols[iSym].e.e_name[0];
	459	cchName = (char *)memchr(pchName, '\0', sizeof(paSymbols[iSym].e.e_name)) - pchName;
	460	if (cchName > sizeof(paSymbols[iSym].e.e_name))
	461	cchName = sizeof(paSymbols[iSym].e.e_name);
[1040]	462	}
[2791]	463	else if ( paSymbols[iSym].e.e.e_offset == 0
	464	\|\| paSymbols[iSym].e.e.e_offset >= cbStrTab)
	465	continue;
[1040]	466	else
	467	{
[2791]	468	pchName = &pchStrTab[paSymbols[iSym].e.e.e_offset];
	469	cchName = strlen(pchName);
	470	}
[1038]	471
[2791]	472	if ( *pchName == 0x7f
	473	&& cchName >= sizeof(s_szSuffix)
	474	&& memcmp(&pchName[cchName - sizeof(s_szSuffix) + 1], s_szSuffix, sizeof(s_szSuffix) - 1) == 0)
	475	{
	476	if (pchName[cchName] == '\0')
	477	InfoMsg(1, "#2: Found '%s': value=%#lx\n", pchName, paSymbols[iSym].e_value);
	478	else
	479	InfoMsg(1, "#2: Found '%.8s': value=%#lx\n", pchName, paSymbols[iSym].e_value);
	480	if ( paSymbols[iSym].e_scnum > 0
	481	&& paSymbols[iSym].e_scnum <= CoffHdr.NumberOfSections)
[1040]	482	{
[2791]	483	if (paSymbols[iSym].e_scnum != iSecHdr + 1)
	484	InfoMsg(0, "#2: '%s' in section %u, expected %u\n", pchName, paSymbols[iSym].e_scnum, iSecHdr);
	485	else if (paSymbols[iSym].e_value != 0)
	486	InfoMsg(0, "#2: '%s' in value %#xu, expected 0x0\n", pchName, paSymbols[iSym].e_value);
	487	else if ( SecHdr.PointerToRawData < sizeof(CoffHdr) + CoffHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
	488	\|\| (fpos_t)SecHdr.PointerToRawData + cbMachineWord > cbFile)
	489	InfoMsg(0, "#2: Unexpected PointerToRawData value: %#x\n", SecHdr.PointerToRawData);
[1003]	490	else
	491	{
[2791]	492	union
	493	{
	494	KU8 ab[8];
	495	KU32 u32;
	496	KU64 u64;
	497	} uBuf;
	498	uBuf.u64 = 0;
	499	off = offFileBytes + SecHdr.PointerToRawData;
	500	if (kLibMyReadAt(pFile, &uBuf, cbMachineWord, off, 0) == 0)
	501	{
	502	static const KU8 s_abGarbage[8] = { 0xaa, 0x99, 0x88, 0xbb, 0xbb, 0xaa, 0x88, 0x99 };
	503	static const KU8 s_abZero[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
	504	if (memcmp(&uBuf, s_abZero,cbMachineWord) == 0)
	505	{
	506	rcRet = kLibMyWriteAt(pFile, s_abGarbage, cbMachineWord, off);
	507	if (!rcRet)
	508	InfoMsg(1, "#2: Updated '%s'\n", pchName);
	509	}
	510	else if (memcmp(&uBuf, s_abGarbage, cbMachineWord) == 0)
	511	{
	512	InfoMsg(1, "#2: Already modified '%s'\n", pchName);
	513	rcRet = 0;
	514	}
	515	else
	516	rcRet = ErrorMsg(0, "#2: Unexpected '%s' data: %02x %02x %02x %02x %02x %02x %02x %02x\n",
	517	pchName,
	518	uBuf.ab[0], uBuf.ab[1], uBuf.ab[2], uBuf.ab[3],
	519	uBuf.ab[4], uBuf.ab[5], uBuf.ab[6], uBuf.ab[7]);
	520	}
	521	break;
[1003]	522	}
	523	}
[1040]	524	}
[1003]	525	}
[1001]	526
[1040]	527	}
	528	else
[2791]	529	rcRet = 1;
	530	free(paSymbols);
	531	return rcRet;
[1001]	532	}
	533
	534
	535	/**
[2791]	536	* Clears timestamps to avoid rebuilding stuff just because the internal
	537	* timestamps changed in an import library.
[1040]	538	*/
[2791]	539	static int kLibClearTimestamps(FILE pFile, fpos_t offFileHdr, ARCHFILEHDR pFileHdr, fpos_t cbFile, fpos_t offFileBytes)
[1040]	540	{
[2791]	541	union
[1045]	542	{
[2791]	543	IMAGE_FILE_HEADER CoffHdr;
	544	COFFIMPLIBHDR ImpLibHdr;
	545	} u;
	546	if (sizeof(u.CoffHdr) != sizeof(u.ImpLibHdr))
	547	FatalDie("Oops!");
[1045]	548
[1040]	549	/*
[2791]	550	* Clear the timestamp in the library file header.
[1040]	551	*/
[2791]	552	memset(pFileHdr->achModtime, '0', sizeof(pFileHdr->achModtime));
	553	if (kLibMyWriteAt(pFile, pFileHdr, sizeof(*pFileHdr), offFileHdr) != 0)
	554	return 1;
[1040]	555
	556	/*
[2791]	557	* Clear the timestamp in the COFF header, if we find one.
[1040]	558	*/
[2791]	559	if (cbFile <= sizeof(IMAGE_FILE_HEADER))
	560	return 0;
	561	if (kLibMyReadAt(pFile, &u.CoffHdr, sizeof(u.CoffHdr), offFileBytes, 0) != 0)
	562	return 1;
[1040]	563
[2791]	564	if ( ( u.CoffHdr.Machine == IMAGE_FILE_MACHINE_I386
	565	\|\| u.CoffHdr.Machine == IMAGE_FILE_MACHINE_AMD64)
	566	&& sizeof(IMAGE_FILE_HEADER)
	567	+ u.CoffHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
	568	<= (KU64)cbFile
	569	&& u.CoffHdr.PointerToSymbolTable <= (KU64)cbFile)
[1040]	570	{
[2791]	571	InfoMsg(1, "Found COFF file header\n");
	572	if (u.CoffHdr.TimeDateStamp != 0)
[1002]	573	{
[2791]	574	u.CoffHdr.TimeDateStamp = 0;
	575	return kLibMyWriteAt(pFile, &u.CoffHdr, sizeof(u.CoffHdr), offFileBytes);
[1002]	576	}
	577	}
[2791]	578	else if ( u.ImpLibHdr.uSig1 == 0
	579	&& u.ImpLibHdr.uSig2 == 0xffff
	580	&& u.ImpLibHdr.uVersion == 0
	581	&& ( u.ImpLibHdr.uMachine == IMAGE_FILE_MACHINE_I386
	582	\|\| u.ImpLibHdr.uMachine == IMAGE_FILE_MACHINE_AMD64)
	583	&& u.ImpLibHdr.cbData <= cbFile)
[1002]	584	{
[2791]	585	InfoMsg(1, "Found COFF import library header\n");
	586	if (u.ImpLibHdr.uTimeDateStamp)
[1002]	587	{
[2791]	588	u.ImpLibHdr.uTimeDateStamp = 0;
	589	return kLibMyWriteAt(pFile, &u.ImpLibHdr, sizeof(u.ImpLibHdr), offFileBytes);
[1002]	590	}
[1001]	591	}
[2791]	592	else
	593	InfoMsg(1, "CoffHdr.Machine=%#x ImpLibHdr.Machine=%#x\n", u.CoffHdr.Machine, u.ImpLibHdr.uMachine);
[1008]	594
[1040]	595	return 0;
	596	}
	597
	598
[2791]	599	static int kLibTweakerDoIt(const char *pszLib, int fClearTimestamps, int fFillNullThunkData)
[1001]	600	{
[2791]	601	int rcRet = 0;
	602	FILE *pFile = fopen(pszLib, "r+b");
	603	if (pFile)
[1040]	604	{
	605	/*
[2791]	606	* Read the header.
[1040]	607	*/
[2791]	608	static char s_szMagic[] = "!<arch>\n";
	609	union
[1040]	610	{
[2791]	611	char ab[1024];
	612	IMAGE_FILE_HEADER CoffHdr;
	613	} uBuf;
	614	if ( fread(uBuf.ab, 1, sizeof(s_szMagic) - 1, pFile) == sizeof(s_szMagic) - 1
	615	&& memcmp(uBuf.ab, s_szMagic, sizeof(s_szMagic) - 1) == 0)
[1040]	616	{
[2791]	617	fpos_t offFileHdr = sizeof(s_szMagic) - 1;
	618	while (!feof(pFile))
[1040]	619	{
[2791]	620	ARCHFILEHDR FileHdr;
	621	if (kLibMyReadAt(pFile, &FileHdr, sizeof(FileHdr), offFileHdr, 1) != 0)
[1017]	622	{
[2791]	623	if (feof(pFile))
[1017]	624	break;
[2791]	625	rcRet = ErrorMsg("failed reading the file header (offset %ld)\n", (long)offFileHdr);
	626	break;
[1017]	627	}
[2791]	628	if ( FileHdr.achMagic[0] == 0x60
	629	&& FileHdr.achMagic[1] == 0x0a)
[1017]	630	{
[2791]	631	fpos_t const offFileBytes = offFileHdr + sizeof(FileHdr);
[1017]	632
[2791]	633	/*
	634	* Convert the size from decimal to binary as we need it to skip to
	635	* the next file header.
	636	*/
	637	fpos_t const cb = kLibTweakerAsciiToSize(FileHdr.achSize, sizeof(FileHdr.achSize));
	638	InfoMsg(1, "Found header at %#lx: cbFile=%#lx, bytes at %#lx\n",
	639	(unsigned long)offFileHdr, (unsigned long)cb, (unsigned long)offFileBytes);
[1036]	640
[2791]	641	/*
	642	* Make the requested changes.
	643	*/
	644	if (fClearTimestamps)
	645	rcRet \|= kLibClearTimestamps(pFile, offFileHdr, &FileHdr, cb, offFileBytes);
[1017]	646
[2791]	647	if (fFillNullThunkData)
	648	rcRet \|= kLibFillNullThunkData(pFile, cb, offFileBytes);
[1017]	649
[2791]	650	/*
	651	* Skip to the next header.
	652	*/
	653	offFileHdr = offFileBytes + ((cb + 1) & ~(fpos_t)1);
	654	}
	655	else
	656	rcRet = ErrorMsg("invalid file header magic (offset %ld)\n", (long)offFileHdr);
[1017]	657	}
	658	}
[1040]	659	else
[2791]	660	rcRet = ErrorMsg("Didn't find '!<arch>\\n' magic in '%s' (or read error)\n", pszLib);
[1008]	661
[2791]	662	if (fclose(pFile) != 0)
	663	rcRet = ErrorMsg("Error closing '%s'\n");
[2620]	664	}
[1040]	665	else
[2791]	666	rcRet = ErrorMsg("Failed to open '%s' for read+write\n", pszLib);
	667	return rcRet;
[1001]	668	}
	669
	670
	671	/**
	672	* Prints a syntax error and returns the appropriate exit code
[1038]	673	*
[1001]	674	* @returns approriate exit code.
	675	* @param pszFormat The syntax error message.
	676	* @param ... Message args.
	677	*/
	678	static int SyntaxError(const char *pszFormat, ...)
	679	{
	680	va_list va;
	681	fprintf(stderr, "kObjCache: syntax error: ");
	682	va_start(va, pszFormat);
	683	vfprintf(stderr, pszFormat, va);
	684	va_end(va);
	685	return 1;
	686	}
	687
	688
	689	/**
	690	* Prints the usage.
	691	* @returns 0.
	692	*/
[1184]	693	static int usage(FILE *pOut)
[1001]	694	{
[1184]	695	fprintf(pOut,
[2791]	696	"syntax: kLibTweaker [-v\|--verbose] [--clear-timestamps] <lib>\n"
[1184]	697	"\n");
[1001]	698	return 0;
	699	}
	700
	701
	702	int main(int argc, char **argv)
	703	{
[1040]	704	char *psz;
[1001]	705	int i;
	706
[2791]	707	int fClearTimestamps = 0;
	708	int fFillNullThunkData = 0;
	709	const char *pszLib = NULL;
[1040]	710
[2791]	711	SetErrorPrefix("kLibTweaker");
	712
[1001]	713	/*
[1040]	714	* Arguments passed in the environmnet?
	715	*/
[2791]	716	psz = getenv("KLIBTWEAKER_OPTS");
[1040]	717	if (psz)
[2791]	718	AppendArgs(&argc, &argv, psz, NULL);
[1040]	719
[2791]	720	/** @todo Add the capability to produce import/stub libraries from ELF shared
	721	* objects that we can use while linking and break up linking dependencies
	722	* (i.e. not relink everything just because something in VBoxRT change that
	723	* didn't make any difference to the symbols it exports). */
	724
[1040]	725	/*
[1001]	726	* Parse the arguments.
	727	*/
[1041]	728	if (argc <= 1)
[2791]	729	return usage(stderr) + 1;
[1001]	730	for (i = 1; i < argc; i++)
	731	{
[2791]	732	if (!strcmp(argv[i], "--clear-timestamps"))
	733	fClearTimestamps = 1;
	734	else if (!strcmp(argv[i], "--fill-null_thunk_data"))
	735	fFillNullThunkData = 1;
	736	/* Standard stuff: */
[1001]	737	else if (!strcmp(argv[i], "--help"))
[1184]	738	return usage(stderr);
[1001]	739	else if (!strcmp(argv[i], "-v") \|\| !strcmp(argv[i], "--verbose"))
[1040]	740	g_cVerbosityLevel++;
[1001]	741	else if (!strcmp(argv[i], "-q") \|\| !strcmp(argv[i], "--quiet"))
[1040]	742	g_cVerbosityLevel = 0;
[1041]	743	else if (!strcmp(argv[i], "-h") \|\| !strcmp(argv[i], "-?")
	744	\|\| !strcmp(argv[i], "/h") \|\| !strcmp(argv[i], "/?") \|\| !strcmp(argv[i], "/help"))
[2791]	745	return usage(stdout);
[1001]	746	else if (!strcmp(argv[i], "-V") \|\| !strcmp(argv[i], "--version"))
	747	{
[2791]	748	printf("kLibTweaker - kBuild version %d.%d.%d ($Revision: 2791 $)\n"
	749	"Copyright (c) 2007-2015 knut st. osmundsen\n",
[1184]	750	KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR, KBUILD_VERSION_PATCH);
[1001]	751	return 0;
	752	}
[2791]	753	else if (!strcmp(argv[i], "--"))
[1040]	754	{
[2791]	755	i++;
	756	if (i == argc)
	757	return SyntaxError("No library given!\n");
	758	if (i + 1 != argc \|\| pszLib)
	759	return SyntaxError("Only one library can be tweaked at a time!\n");
	760	pszLib = argv[i];
	761	break;
[1040]	762	}
[2791]	763	else if (argv[i][0] == '-')
	764	return SyntaxError("Doesn't grok '%s'!\n", argv[i]);
	765	else if (!pszLib)
	766	pszLib = argv[i];
[1042]	767	else
[2791]	768	return SyntaxError("Only one library can be tweaked at a time!\n");
[1040]	769	}
[2791]	770	if (!pszLib)
	771	return SyntaxError("No library given!\n");
[1040]	772
[2791]	773	return kLibTweakerDoIt(pszLib, fClearTimestamps, fFillNullThunkData);
[1001]	774	}
	775

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/kLibTweaker/kLibTweaker.c

Download in other formats: