Adding upstream version 1:0.1.9998svn3589+dfsg.upstream/1%0.1.9998svn3589+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 814 insertions, 0 deletions

diff --git a/src/kLibTweaker/Makefile.kmk b/src/kLibTweaker/Makefile.kmk
new file mode 100644
index 0000000..016e118
--- /dev/null
+++ b/src/kLibTweaker/Makefile.kmk
@@ -0,0 +1,39 @@
+# $Id: Makefile.kmk 2791 2015-09-15 22:57:44Z bird $
+## @file
+# Sub-makefile for kLibTweaker.
+#
+
+#
+# Copyright (c) 2007-2015 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+#
+# This file is part of kBuild.
+#
+# kBuild is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# kBuild 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 kBuild.  If not, see <http://www.gnu.org/licenses/>
+#
+#
+
+SUB_DEPTH = ../..
+include $(PATH_KBUILD)/subheader.kmk
+
+PROGRAMS += kLibTweaker
+kLibTweaker_TEMPLATE = BIN
+kLibTweaker_DEFS.release = NASSERT
+kLibTweaker_SOURCES = kLibTweaker.c
+kLibTweaker_INCS = ../lib
+kLibTweaker_LIBS = \
+	$(LIB_KDEP) \
+	$(LIB_KUTIL)
+
+include $(KBUILD_PATH)/subfooter.kmk
+
diff --git a/src/kLibTweaker/kLibTweaker.c b/src/kLibTweaker/kLibTweaker.c
new file mode 100644
index 0000000..ecfce56
--- /dev/null
+++ b/src/kLibTweaker/kLibTweaker.c
@@ -0,0 +1,775 @@
+/* $Id: kLibTweaker.c 2791 2015-09-15 22:57:44Z bird $ */
+/** @file
+ * kLibTweaker - Import library tweaker for windows.
+ */
+
+/*
+ * Copyright (c) 2007-2015 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ *
+ * This file is part of kBuild.
+ *
+ * kBuild is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * kBuild 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 kBuild.  If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#if 0
+# define ELECTRIC_HEAP
+# include "../kmk/electric.h"
+# include "../kmk/electric.c"
+#endif
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "k/kLdrFmts/pe.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Microsoft import library archive header.
+ *
+ * This has the same size as a COFF header, which is probably not a coincidence.
+ */
+typedef struct COFFIMPLIBHDR
+{
+    KU16            uSig1;    /* 0 */
+    KU16            uSig2;    /* 0xffff */
+    KU16            uVersion; /* 0 */
+    KU16            uMachine; /* IMAGE_FILE_MACHINE_I386, ... */
+    KU32            uTimeDateStamp;
+    KU32            cbData;
+    KU16            uOrdinalOrHint;
+    KU16            uFlags;
+} COFFIMPLIBHDR;
+
+/**
+ * COFF symbol.
+ *
+ * This one has an odd size and will cause misaligned accesses on platforms
+ * which cares about such.
+ */
+#pragma pack(1)
+typedef struct COFFSYMBOL
+{
+    union
+    {
+        char        e_name[8];
+        struct
+        {
+            KU32    e_zeros;    /**< Zero to distinguish it from ascii name. */
+            KU32    e_offset;   /**< String table offset. */
+        } e;
+    } e;
+    KU32            e_value;
+    KI16            e_scnum;
+    KU16            e_type;
+    KU8             e_sclass;
+    KU8             e_numaux;
+} COFFSYMBOL;
+#pragma pack()
+
+/**
+ * Archive file header.
+ */
+typedef struct ARCHFILEHDR
+{
+    char        achName[16];
+    char        achModtime[12];
+    char        achOwnerId[6];
+    char        achGroupId[6];
+    char        achMode[8];
+    char        achSize[10];
+    char        achMagic[2];
+} ARCHFILEHDR;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Whether verbose output is enabled. */
+static unsigned g_cVerbosityLevel = 0;
+/** What to prefix the errors with. */
+static char g_szErrorPrefix[128];
+
+
+void FatalMsg(const char *pszFormat, ...)
+{
+    va_list va;
+
+    if (g_szErrorPrefix[0])
+        fprintf(stderr, "%s - fatal error: ", g_szErrorPrefix);
+    else
+        fprintf(stderr, "fatal error: ");
+
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+}
+
+
+void FatalDie(const char *pszFormat, ...)
+{
+    va_list va;
+
+    if (g_szErrorPrefix[0])
+        fprintf(stderr, "%s - fatal error: ", g_szErrorPrefix);
+    else
+        fprintf(stderr, "fatal error: ");
+
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+
+    exit(1);
+}
+
+
+static int ErrorMsg(const char *pszFormat, ...)
+{
+    va_list va;
+
+    if (g_szErrorPrefix[0])
+        fprintf(stderr, "%s - error: ", g_szErrorPrefix);
+    else
+        fprintf(stderr, "error: ");
+
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+
+    return 1;
+}
+
+
+static void InfoMsg(unsigned uLevel, const char *pszFormat, ...)
+{
+    if (uLevel <= g_cVerbosityLevel)
+    {
+        va_list va;
+
+        if (g_szErrorPrefix[0])
+            fprintf(stderr, "%s - info: ", g_szErrorPrefix);
+        else
+            fprintf(stderr, "info: ");
+
+        va_start(va, pszFormat);
+        vfprintf(stderr, pszFormat, va);
+        va_end(va);
+    }
+}
+
+
+static void SetErrorPrefix(const char *pszPrefix, ...)
+{
+    int cch;
+    va_list va;
+
+    va_start(va, pszPrefix);
+#if defined(_MSC_VER) || defined(__sun__)
+    cch = vsprintf(g_szErrorPrefix, pszPrefix, va);
+    if (cch >= sizeof(g_szErrorPrefix))
+        FatalDie("Buffer overflow setting error prefix!\n");
+#else
+    vsnprintf(g_szErrorPrefix, sizeof(g_szErrorPrefix), pszPrefix, va);
+#endif
+    va_end(va);
+    (void)cch;
+}
+
+#ifndef ELECTRIC_HEAP
+void *xmalloc(size_t cb)
+{
+    void *pv = malloc(cb);
+    if (!pv)
+        FatalDie("out of memory (%d)\n", (int)cb);
+    return pv;
+}
+
+
+void *xrealloc(void *pvOld, size_t cb)
+{
+    void *pv = realloc(pvOld, cb);
+    if (!pv)
+        FatalDie("out of memory (%d)\n", (int)cb);
+    return pv;
+}
+
+
+char *xstrdup(const char *pszIn)
+{
+    char *psz;
+    if (pszIn)
+    {
+        psz = strdup(pszIn);
+        if (!psz)
+            FatalDie("out of memory (%d)\n", (int)strlen(pszIn));
+    }
+    else
+        psz = NULL;
+    return psz;
+}
+#endif
+
+
+void *xmallocz(size_t cb)
+{
+    void *pv = xmalloc(cb);
+    memset(pv, 0, cb);
+    return pv;
+}
+
+
+/**
+ * Adds the arguments found in the pszCmdLine string to argument vector.
+ *
+ * The parsing of the pszCmdLine string isn't very sophisticated, no
+ * escaping or quotes.
+ *
+ * @param   pcArgs      Pointer to the argument counter.
+ * @param   ppapszArgs  Pointer to the argument vector pointer.
+ * @param   pszCmdLine  The command line to parse and append.
+ * @param   pszWedgeArg Argument to put infront of anything found in pszCmdLine.
+ */
+static void AppendArgs(int *pcArgs, char ***ppapszArgs, const char *pszCmdLine, const char *pszWedgeArg)
+{
+    int i;
+    int cExtraArgs;
+    const char *psz;
+    char **papszArgs;
+
+    /*
+     * Count the new arguments.
+     */
+    cExtraArgs = 0;
+    psz = pszCmdLine;
+    while (*psz)
+    {
+        while (isspace(*psz))
+            psz++;
+        if (!psz)
+            break;
+        cExtraArgs++;
+        while (!isspace(*psz) && *psz)
+            psz++;
+    }
+    if (!cExtraArgs)
+        return;
+
+    /*
+     * Allocate a new vector that can hold the arguments.
+     * (Reallocating might not work since the argv might not be allocated
+     *  from the heap but off the stack or somewhere... )
+     */
+    i = *pcArgs;
+    *pcArgs = i + cExtraArgs + !!pszWedgeArg;
+    papszArgs = xmalloc((*pcArgs + 1) * sizeof(char *));
+    *ppapszArgs = memcpy(papszArgs, *ppapszArgs, i * sizeof(char *));
+
+    if (pszWedgeArg)
+        papszArgs[i++] = xstrdup(pszWedgeArg);
+
+    psz = pszCmdLine;
+    while (*psz)
+    {
+        size_t cch;
+        const char *pszEnd;
+        while (isspace(*psz))
+            psz++;
+        if (!psz)
+            break;
+        pszEnd = psz;
+        while (!isspace(*pszEnd) && *pszEnd)
+            pszEnd++;
+
+        cch = pszEnd - psz;
+        papszArgs[i] = xmalloc(cch + 1);
+        memcpy(papszArgs[i], psz, cch);
+        papszArgs[i][cch] = '\0';
+
+        i++;
+        psz = pszEnd;
+    }
+
+    papszArgs[i] = NULL;
+}
+
+
+
+
+static fpos_t kLibTweakerAsciiToSize(const char *pch, size_t cch)
+{
+    fpos_t cb = 0;
+
+    /* strip leading spaces. */
+    while (cch > 0 && (*pch == ' ' || *pch == '\t'))
+        cch--, pch++;
+
+    /* Convert decimal to binary. */
+    while (cch-- > 0)
+    {
+        char ch = *pch++;
+        if (ch >= '0' && ch <= '9')
+        {
+            cb *= 10;
+            cb += ch - '0';
+        }
+        else
+            break;
+    }
+
+    return cb;
+}
+
+
+static int kLibMyReadAt(FILE *pFile, void *pv, size_t cb, fpos_t off, int fEofOk)
+{
+    if (fsetpos(pFile, &off) == 0)
+    {
+        size_t cbActual = fread(pv, 1, cb, pFile);
+        if (cbActual == cb)
+            return 0;
+        if (!fEofOk || !feof(pFile))
+            ErrorMsg("fread returned %#lx, expected %#lx!\n", (unsigned long)cbActual, (unsigned long)cb);
+    }
+    else
+        ErrorMsg("seek error!\n");
+    return 1;
+}
+
+
+static int kLibMyWriteAt(FILE *pFile, const void *pv, size_t cb, fpos_t off)
+{
+    if (fsetpos(pFile, &off) == 0)
+    {
+        size_t cbActual = fwrite(pv, 1, cb, pFile);
+        if (cbActual == cb)
+            return 0;
+        ErrorMsg("fwrite returned %#lx, expected %#lx!\n", (unsigned long)cbActual, (unsigned long)cb);
+    }
+    else
+        ErrorMsg("seek error!\n");
+    return 1;
+}
+
+
+static int kLibFillNullThunkData(FILE *pFile, fpos_t cbFile, fpos_t offFileBytes)
+{
+    size_t                  off;
+    IMAGE_FILE_HEADER       CoffHdr;
+    IMAGE_SECTION_HEADER    SecHdr;
+    unsigned                iSecHdr;
+    fpos_t                  offCur;
+    unsigned                cbMachineWord;
+    KU32                    cbStrTab;
+    COFFSYMBOL             *paSymbols;
+    int                     rcRet = 0;
+
+    /*
+     * Read the COFF file header and filter out unlikly files based on
+     * section and symbol counts.
+     */
+    if (cbFile <= sizeof(IMAGE_FILE_HEADER) + sizeof(IMAGE_SECTION_HEADER) * 2 + 4)
+        return 0;
+    if (kLibMyReadAt(pFile, &CoffHdr, sizeof(CoffHdr), offFileBytes, 0) != 0)
+        return 1;
+    if (   CoffHdr.Machine != IMAGE_FILE_MACHINE_I386
+        && CoffHdr.Machine != IMAGE_FILE_MACHINE_AMD64)
+        return 0;
+    cbMachineWord = CoffHdr.Machine == IMAGE_FILE_MACHINE_I386 ? 4 : 8;
+    if (   CoffHdr.NumberOfSections == 0
+        || CoffHdr.NumberOfSymbols == 0)
+        return 0;
+    off = sizeof(IMAGE_FILE_HEADER) + CoffHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
+    if ((fpos_t)off >= cbFile)
+        return 0;
+    if (   CoffHdr.PointerToSymbolTable >= (KU64)cbFile
+        || CoffHdr.PointerToSymbolTable < off)
+        return 0;
+
+    /*
+     * Search for the .idata$5 section which the thunk data is usually found in.
+     */
+    offCur = offFileBytes + sizeof(CoffHdr);
+    for (iSecHdr = 0; iSecHdr < CoffHdr.NumberOfSections; iSecHdr++)
+    {
+        if (kLibMyReadAt(pFile, &SecHdr, sizeof(SecHdr), offCur, 0) != 0)
+            return 1;
+        InfoMsg(2, "#2: %.8s VirtualSize=%#lx\n", SecHdr.Name, SecHdr.SizeOfRawData);
+        if (   !memcmp(SecHdr.Name, ".idata$5", 8)
+            && SecHdr.SizeOfRawData == cbMachineWord)
+            break;
+        offCur += sizeof(SecHdr);
+    }
+    if (iSecHdr == CoffHdr.NumberOfSections)
+        return 0;
+
+    /*
+     * Read in the symbo and string tables.
+     */
+    off = CoffHdr.PointerToSymbolTable + CoffHdr.NumberOfSymbols * sizeof(COFFSYMBOL);
+    if (kLibMyReadAt(pFile, &cbStrTab, sizeof(cbStrTab), offFileBytes + off, 0) != 0)
+        return 1;
+    InfoMsg(2, "#2: Found COFF file header, cbStrTab=%#x; off=%#lx NumberOfSymbols=%#x PointerToSymbolTable=%#x\n",
+            cbStrTab, (long)off, CoffHdr.NumberOfSymbols, CoffHdr.PointerToSymbolTable);
+    if (   cbStrTab <= 4U
+        || cbStrTab >= 16*1024*1024U /* 16MB */
+        || (fpos_t)off + cbStrTab > cbFile)
+        return 0;
+    paSymbols = xmalloc(CoffHdr.NumberOfSymbols * sizeof(COFFSYMBOL) + cbStrTab + 1);
+    if (kLibMyReadAt(pFile, paSymbols, CoffHdr.NumberOfSymbols * sizeof(COFFSYMBOL) + cbStrTab,
+                     offFileBytes + CoffHdr.PointerToSymbolTable, 0) == 0)
+    {
+        char       *pchStrTab = (char *)&paSymbols[CoffHdr.NumberOfSymbols];
+        unsigned    iSym;
+
+        pchStrTab[cbStrTab] = '\0';
+        pchStrTab[0] = '\0';
+        pchStrTab[1] = '\0';
+        pchStrTab[2] = '\0';
+        pchStrTab[3] = '\0';
+
+        for (iSym = 0; iSym < CoffHdr.NumberOfSymbols; iSym++)
+        {
+            static char const s_szSuffix[] = "NULL_THUNK_DATA";
+            const char *pchName;
+            size_t      cchName;
+            if (paSymbols[iSym].e.e.e_zeros != 0)
+            {
+                pchName = &paSymbols[iSym].e.e_name[0];
+                cchName = (char *)memchr(pchName, '\0', sizeof(paSymbols[iSym].e.e_name)) - pchName;
+                if (cchName > sizeof(paSymbols[iSym].e.e_name))
+                    cchName = sizeof(paSymbols[iSym].e.e_name);
+            }
+            else if (   paSymbols[iSym].e.e.e_offset == 0
+                     || paSymbols[iSym].e.e.e_offset >= cbStrTab)
+                continue;
+            else
+            {
+                pchName = &pchStrTab[paSymbols[iSym].e.e.e_offset];
+                cchName = strlen(pchName);
+            }
+
+            if (   *pchName == 0x7f
+                && cchName >= sizeof(s_szSuffix)
+                && memcmp(&pchName[cchName - sizeof(s_szSuffix) + 1], s_szSuffix, sizeof(s_szSuffix) - 1) == 0)
+            {
+                if (pchName[cchName] == '\0')
+                    InfoMsg(1, "#2: Found '%s': value=%#lx\n", pchName, paSymbols[iSym].e_value);
+                else
+                    InfoMsg(1, "#2: Found '%.8s': value=%#lx\n", pchName, paSymbols[iSym].e_value);
+                if (   paSymbols[iSym].e_scnum > 0
+                    && paSymbols[iSym].e_scnum <= CoffHdr.NumberOfSections)
+                {
+                    if (paSymbols[iSym].e_scnum != iSecHdr + 1)
+                        InfoMsg(0, "#2: '%s' in section %u, expected %u\n", pchName, paSymbols[iSym].e_scnum, iSecHdr);
+                    else if (paSymbols[iSym].e_value != 0)
+                        InfoMsg(0, "#2: '%s' in value %#xu, expected 0x0\n", pchName, paSymbols[iSym].e_value);
+                    else if (   SecHdr.PointerToRawData < sizeof(CoffHdr) + CoffHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
+                             || (fpos_t)SecHdr.PointerToRawData + cbMachineWord > cbFile)
+                        InfoMsg(0, "#2: Unexpected PointerToRawData value: %#x\n", SecHdr.PointerToRawData);
+                    else
+                    {
+                        union
+                        {
+                            KU8  ab[8];
+                            KU32 u32;
+                            KU64 u64;
+                        } uBuf;
+                        uBuf.u64 = 0;
+                        off = offFileBytes + SecHdr.PointerToRawData;
+                        if (kLibMyReadAt(pFile, &uBuf, cbMachineWord, off, 0) == 0)
+                        {
+                            static const KU8 s_abGarbage[8] = { 0xaa, 0x99, 0x88, 0xbb,  0xbb, 0xaa, 0x88, 0x99 };
+                            static const KU8 s_abZero[8]    = { 0, 0, 0, 0,  0, 0, 0, 0 };
+                            if (memcmp(&uBuf, s_abZero,cbMachineWord) == 0)
+                            {
+                                rcRet = kLibMyWriteAt(pFile, s_abGarbage, cbMachineWord, off);
+                                if (!rcRet)
+                                    InfoMsg(1, "#2: Updated '%s'\n", pchName);
+                            }
+                            else if (memcmp(&uBuf, s_abGarbage, cbMachineWord) == 0)
+                            {
+                                InfoMsg(1, "#2: Already modified '%s'\n", pchName);
+                                rcRet = 0;
+                            }
+                            else
+                                rcRet = ErrorMsg(0, "#2: Unexpected '%s' data: %02x %02x %02x %02x %02x %02x %02x %02x\n",
+                                                 pchName,
+                                                 uBuf.ab[0], uBuf.ab[1], uBuf.ab[2], uBuf.ab[3],
+                                                 uBuf.ab[4], uBuf.ab[5], uBuf.ab[6], uBuf.ab[7]);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+
+    }
+    else
+        rcRet = 1;
+    free(paSymbols);
+    return rcRet;
+}
+
+
+/**
+ * Clears timestamps to avoid rebuilding stuff just because the internal
+ * timestamps changed in an import library.
+ */
+static int kLibClearTimestamps(FILE *pFile, fpos_t offFileHdr, ARCHFILEHDR *pFileHdr, fpos_t cbFile, fpos_t offFileBytes)
+{
+    union
+    {
+        IMAGE_FILE_HEADER   CoffHdr;
+        COFFIMPLIBHDR       ImpLibHdr;
+    } u;
+    if (sizeof(u.CoffHdr) != sizeof(u.ImpLibHdr))
+        FatalDie("Oops!");
+
+    /*
+     * Clear the timestamp in the library file header.
+     */
+    memset(pFileHdr->achModtime, '0', sizeof(pFileHdr->achModtime));
+    if (kLibMyWriteAt(pFile, pFileHdr, sizeof(*pFileHdr), offFileHdr) != 0)
+        return 1;
+
+    /*
+     * Clear the timestamp in the COFF header, if we find one.
+     */
+    if (cbFile <= sizeof(IMAGE_FILE_HEADER))
+        return 0;
+    if (kLibMyReadAt(pFile, &u.CoffHdr, sizeof(u.CoffHdr), offFileBytes, 0) != 0)
+        return 1;
+
+    if (   (   u.CoffHdr.Machine == IMAGE_FILE_MACHINE_I386
+            || u.CoffHdr.Machine == IMAGE_FILE_MACHINE_AMD64)
+        &&     sizeof(IMAGE_FILE_HEADER)
+             + u.CoffHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
+           <= (KU64)cbFile
+        && u.CoffHdr.PointerToSymbolTable <= (KU64)cbFile)
+    {
+        InfoMsg(1, "Found COFF file header\n");
+        if (u.CoffHdr.TimeDateStamp != 0)
+        {
+            u.CoffHdr.TimeDateStamp = 0;
+            return kLibMyWriteAt(pFile, &u.CoffHdr, sizeof(u.CoffHdr), offFileBytes);
+        }
+    }
+    else if (   u.ImpLibHdr.uSig1    == 0
+             && u.ImpLibHdr.uSig2    == 0xffff
+             && u.ImpLibHdr.uVersion == 0
+             && (   u.ImpLibHdr.uMachine == IMAGE_FILE_MACHINE_I386
+                 || u.ImpLibHdr.uMachine == IMAGE_FILE_MACHINE_AMD64)
+             && u.ImpLibHdr.cbData <= cbFile)
+    {
+        InfoMsg(1, "Found COFF import library header\n");
+        if (u.ImpLibHdr.uTimeDateStamp)
+        {
+            u.ImpLibHdr.uTimeDateStamp = 0;
+            return kLibMyWriteAt(pFile, &u.ImpLibHdr, sizeof(u.ImpLibHdr), offFileBytes);
+        }
+    }
+    else
+        InfoMsg(1, "CoffHdr.Machine=%#x ImpLibHdr.Machine=%#x\n", u.CoffHdr.Machine, u.ImpLibHdr.uMachine);
+
+    return 0;
+}
+
+
+static int kLibTweakerDoIt(const char *pszLib, int fClearTimestamps, int fFillNullThunkData)
+{
+    int   rcRet = 0;
+    FILE *pFile = fopen(pszLib, "r+b");
+    if (pFile)
+    {
+        /*
+         * Read the header.
+         */
+        static char s_szMagic[] = "!<arch>\n";
+        union
+        {
+            char                ab[1024];
+            IMAGE_FILE_HEADER   CoffHdr;
+        } uBuf;
+        if (   fread(uBuf.ab, 1, sizeof(s_szMagic) - 1, pFile) == sizeof(s_szMagic) - 1
+            && memcmp(uBuf.ab, s_szMagic, sizeof(s_szMagic) - 1) == 0)
+        {
+            fpos_t offFileHdr = sizeof(s_szMagic) - 1;
+            while (!feof(pFile))
+            {
+                ARCHFILEHDR     FileHdr;
+                if (kLibMyReadAt(pFile, &FileHdr, sizeof(FileHdr), offFileHdr, 1) != 0)
+                {
+                    if (feof(pFile))
+                        break;
+                    rcRet = ErrorMsg("failed reading the file header (offset %ld)\n", (long)offFileHdr);
+                    break;
+                }
+                if (   FileHdr.achMagic[0] == 0x60
+                    && FileHdr.achMagic[1] == 0x0a)
+                {
+                    fpos_t const offFileBytes = offFileHdr + sizeof(FileHdr);
+
+                    /*
+                     * Convert the size from decimal to binary as we need it to skip to
+                     * the next file header.
+                     */
+                    fpos_t const cb = kLibTweakerAsciiToSize(FileHdr.achSize, sizeof(FileHdr.achSize));
+                    InfoMsg(1, "Found header at %#lx: cbFile=%#lx, bytes at %#lx\n",
+                            (unsigned long)offFileHdr, (unsigned long)cb, (unsigned long)offFileBytes);
+
+                    /*
+                     * Make the requested changes.
+                     */
+                    if (fClearTimestamps)
+                        rcRet |= kLibClearTimestamps(pFile, offFileHdr, &FileHdr, cb, offFileBytes);
+
+                    if (fFillNullThunkData)
+                        rcRet |= kLibFillNullThunkData(pFile, cb, offFileBytes);
+
+                    /*
+                     * Skip to the next header.
+                     */
+                    offFileHdr = offFileBytes + ((cb + 1) & ~(fpos_t)1);
+                }
+                else
+                    rcRet = ErrorMsg("invalid file header magic (offset %ld)\n", (long)offFileHdr);
+            }
+        }
+        else
+            rcRet = ErrorMsg("Didn't find '!<arch>\\n' magic in '%s' (or read error)\n", pszLib);
+
+        if (fclose(pFile) != 0)
+            rcRet = ErrorMsg("Error closing '%s'\n");
+    }
+    else
+        rcRet = ErrorMsg("Failed to open '%s' for read+write\n", pszLib);
+    return rcRet;
+}
+
+
+/**
+ * Prints a syntax error and returns the appropriate exit code
+ *
+ * @returns approriate exit code.
+ * @param   pszFormat   The syntax error message.
+ * @param   ...         Message args.
+ */
+static int SyntaxError(const char *pszFormat, ...)
+{
+    va_list va;
+    fprintf(stderr, "kObjCache: syntax error: ");
+    va_start(va, pszFormat);
+    vfprintf(stderr, pszFormat, va);
+    va_end(va);
+    return 1;
+}
+
+
+/**
+ * Prints the usage.
+ * @returns 0.
+ */
+static int usage(FILE *pOut)
+{
+    fprintf(pOut,
+            "syntax: kLibTweaker [-v|--verbose] [--clear-timestamps] <lib>\n"
+            "\n");
+    return 0;
+}
+
+
+int main(int argc, char **argv)
+{
+    char *psz;
+    int i;
+
+    int fClearTimestamps = 0;
+    int fFillNullThunkData = 0;
+    const char *pszLib = NULL;
+
+    SetErrorPrefix("kLibTweaker");
+
+    /*
+     * Arguments passed in the environmnet?
+     */
+    psz = getenv("KLIBTWEAKER_OPTS");
+    if (psz)
+        AppendArgs(&argc, &argv, psz, NULL);
+
+/** @todo Add the capability to produce import/stub libraries from ELF shared
+ * objects that we can use while linking and break up linking dependencies
+ * (i.e. not relink everything just because something in VBoxRT change that
+ * didn't make any difference to the symbols it exports). */
+
+    /*
+     * Parse the arguments.
+     */
+    if (argc <= 1)
+        return usage(stderr) + 1;
+    for (i = 1; i < argc; i++)
+    {
+        if (!strcmp(argv[i], "--clear-timestamps"))
+            fClearTimestamps = 1;
+        else if (!strcmp(argv[i], "--fill-null_thunk_data"))
+            fFillNullThunkData = 1;
+        /* Standard stuff: */
+        else if (!strcmp(argv[i], "--help"))
+            return usage(stderr);
+        else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose"))
+            g_cVerbosityLevel++;
+        else if (!strcmp(argv[i], "-q") || !strcmp(argv[i], "--quiet"))
+            g_cVerbosityLevel = 0;
+        else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-?")
+              || !strcmp(argv[i], "/h") || !strcmp(argv[i], "/?") || !strcmp(argv[i], "/help"))
+            return usage(stdout);
+        else if (!strcmp(argv[i], "-V") || !strcmp(argv[i], "--version"))
+        {
+            printf("kLibTweaker - kBuild version %d.%d.%d ($Revision: 2791 $)\n"
+                   "Copyright (c) 2007-2015 knut st. osmundsen\n",
+                   KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR, KBUILD_VERSION_PATCH);
+            return 0;
+        }
+        else if (!strcmp(argv[i], "--"))
+        {
+            i++;
+            if (i == argc)
+                return SyntaxError("No library given!\n");
+            if (i + 1 != argc || pszLib)
+                return SyntaxError("Only one library can be tweaked at a time!\n");
+            pszLib = argv[i];
+            break;
+        }
+        else if (argv[i][0] == '-')
+            return SyntaxError("Doesn't grok '%s'!\n", argv[i]);
+        else if (!pszLib)
+            pszLib = argv[i];
+        else
+            return SyntaxError("Only one library can be tweaked at a time!\n");
+    }
+    if (!pszLib)
+        return SyntaxError("No library given!\n");
+
+    return kLibTweakerDoIt(pszLib, fClearTimestamps, fFillNullThunkData);
+}
+