// --------------------------------------------------------------------------------
// Exploder.cpp
// --------------------------------------------------------------------------------
#include "pch.hxx"
#include "resource.h"

// --------------------------------------------------------------------------------
// Constants
// --------------------------------------------------------------------------------
#define CCHMAX_RES              1024
#define CCHMAX_PATH_EXPLODER    1024

// --------------------------------------------------------------------------------
// String Consts
// --------------------------------------------------------------------------------
static const char c_szRegCmd[]      = "/reg";
static const char c_szUnRegCmd[]    = "/unreg";
static const char c_szReg[]         = "Reg";
static const char c_szUnReg[]       = "UnReg";
static const char c_szAdvPackDll[]  = "ADVPACK.DLL";
static const char c_szSource[]      = "/SOURCE:";
static const char c_szDest[]        = "/DEST:";

// --------------------------------------------------------------------------------
// Globals
// --------------------------------------------------------------------------------
HINSTANCE       g_hInst=NULL;
CHAR            g_szTitle[CCHMAX_RES];
IMalloc        *g_pMalloc=NULL;

// --------------------------------------------------------------------------------
// BODYFILEINFO
// --------------------------------------------------------------------------------
typedef struct tagBODYFILEINFO {
    HBODY           hBody;
    LPSTR           pszCntId;
    LPSTR           pszCntLoc;
    LPSTR           pszFileName;
    LPSTR           pszFilePath;
    BYTE            fIsHtml;
    IStream        *pStmFile;
} BODYFILEINFO, *LPBODYFILEINFO;

// --------------------------------------------------------------------------------
// Prototypes
// --------------------------------------------------------------------------------
HRESULT CallRegInstall(LPCSTR szSection);
HRESULT ReplaceContentIds(LPSTREAM pStmHtml, LPBODYFILEINFO prgBody, DWORD cBodies);
int     WinMainT(HINSTANCE hInst, HINSTANCE hInstPrev, LPTSTR pszCmdLine, int nCmdShow);
HRESULT MimeOleExplodeMhtmlFile(LPCSTR pszSrcFile, LPSTR pszDstDir, INT *pnError);

// --------------------------------------------------------------------------------
// IF_FAILEXIT_ERROR
// --------------------------------------------------------------------------------
#define IF_FAILEXIT_ERROR(_nError, hrExp) \
    if (FAILED(hrExp)) { \
        TraceResult(hr); \
        *pnError = _nError; \
        goto exit; \
    } else

// --------------------------------------------------------------------------------
// ModuleEntry - Stolen from the CRT, used to shirink our code
// --------------------------------------------------------------------------------
int _stdcall ModuleEntry(void)
{
    // Locals
    int             i;
    STARTUPINFOA    si;
    LPTSTR          pszCmdLine;

    // Get Malloc
    CoGetMalloc(1, &g_pMalloc);

    // Get the command line
    pszCmdLine = GetCommandLine();

    // We don't want the "No disk in drive X:" requesters, so we set the critical error mask such that calls will just silently fail
    SetErrorMode(SEM_FAILCRITICALERRORS);

    // Parse the command line
    if (*pszCmdLine == TEXT('\"')) 
    {
        // Scan, and skip over, subsequent characters until another double-quote or a null is encountered.
        while ( *++pszCmdLine && (*pszCmdLine != TEXT('\"')))
            {};

        // If we stopped on a double-quote (usual case), skip over it.
        if (*pszCmdLine == TEXT('\"'))
            pszCmdLine++;
    }
    else 
    {
        while (*pszCmdLine > TEXT(' '))
            pszCmdLine++;
    }

    // Skip past any white space preceeding the second token.
    while (*pszCmdLine && (*pszCmdLine <= TEXT(' '))) 
        pszCmdLine++;

    // Register
    if (0 == lstrcmpi(c_szRegCmd, pszCmdLine))
    {
        CallRegInstall(c_szReg);
        goto exit;
    }

    // Unregister
    else if (0 == lstrcmpi(c_szUnRegCmd, pszCmdLine))
    {
        CallRegInstall(c_szUnReg);
        goto exit;
    }

    // Get startup information...
    si.dwFlags = 0;
    GetStartupInfoA(&si);

    // Call the real winmain
    i = WinMainT(GetModuleHandle(NULL), NULL, pszCmdLine, si.dwFlags & STARTF_USESHOWWINDOW ? si.wShowWindow : SW_SHOWDEFAULT);

exit:
    // Cleanup
    SafeRelease(g_pMalloc);

    // Since we now have a way for an extension to tell us when it is finished, we will terminate all processes when the main thread goes away.
    ExitProcess(i);

    // Done
    return i;
}

// --------------------------------------------------------------------------------
// WinMainT
// --------------------------------------------------------------------------------
int WinMainT(HINSTANCE hInst, HINSTANCE hInstPrev, LPTSTR pszCmdLine, int nCmdShow)
{
    // Locals
    HRESULT         hr;
    CHAR            szRes[CCHMAX_RES];
    CHAR            szSource[CCHMAX_PATH_EXPLODER];
    CHAR            szDest[CCHMAX_PATH_EXPLODER];
    LPSTR           pszT;
    DWORD           i;
    INT             nError;

    // Message
    LoadString(hInst, IDS_TITLE, g_szTitle, ARRAYSIZE(g_szTitle));

    // Message
    LoadString(hInst, IDS_HELP, szRes, ARRAYSIZE(szRes));

    // If Command Line is Empty...
    if (NULL == pszCmdLine || StrStrA(pszCmdLine, szRes) || *pszCmdLine == '?' || lstrcmpi("\\?", pszCmdLine) == 0)
    {
        // Message
        LoadString(hInst, IDS_CMDLINE_FORMAT, szRes, ARRAYSIZE(szRes));

        // Message
        MessageBox(NULL, szRes, g_szTitle, MB_OK | MB_ICONINFORMATION);

        // Done
        goto exit;
    }

    // Null Out Source and Dest
    *szSource = '\0';
    *szDest = '\0';

    // If pszCmdLine specifies a specific, existing file...
    if (PathFileExists(pszCmdLine))
    {
        // Copy To source
        lstrcpyn(szSource, pszCmdLine, ARRAYSIZE(szSource));

        // Pick a Temporary Location to store the thicket
        GetTempPath(ARRAYSIZE(szDest), szDest);
    }

    // Otherwise, try to get a source
    else
    {
        // Lets Upper Case the Command Line
        CharUpper(pszCmdLine);

        // Try to locate /SOURCE:
        pszT = StrStrA(pszCmdLine, c_szSource);

        // If we found /SOURCE, then read the contents...
        if (pszT)
        {
            // Step over /SOURCE:
            pszT += lstrlen(c_szSource);

            // Initialize
            i = 0;

            // Read into szSource, until I hit a / or end of string...
            while ('\0' != *pszT && '/' != *pszT && i < CCHMAX_PATH_EXPLODER)
                szSource[i++] = *pszT++;

            // Pound in a Null
            szSource[i] = '\0';

            // Strip Leading and Trailing Whitespace
            UlStripWhitespace(szSource, TRUE, TRUE, NULL);

            // See if file exists
            if (FALSE == PathFileExists(szSource))
            {
                // Locals
                CHAR szError[CCHMAX_RES + CCHMAX_PATH_EXPLODER];

                // Message
                LoadString(hInst, IDS_FILE_NOEXIST, szRes, ARRAYSIZE(szRes));

                // Format the error message
                wsprintf(szError, szRes, szSource);

                // Message
                INT nAnswer = MessageBox(NULL, szError, g_szTitle, MB_YESNO | MB_ICONEXCLAMATION );

                // Done
                if (IDNO == nAnswer)
                    goto exit;

                // Otherwise, clear szSource
                *szSource = '\0';
            }
        }

        // No Source File, lets browser for one
        if (FIsEmptyA(szSource))
        {
            // Locals
            OPENFILENAME    ofn;            
            CHAR            rgszFilter[CCHMAX_PATH_EXPLODER];
            CHAR            szDir[MAX_PATH];

            // Copy in the source of exploder.exe
            GetModuleFileName(hInst, szDir, ARRAYSIZE(szDir));

            // Initialize szDest
            PathRemoveFileSpecA(szDir);

            // Initialize ofn
            ZeroMemory(&ofn, sizeof(OPENFILENAME));

            // Initialize the STring
            *szSource ='\0';

            // Load the MHTML File Filter
            LoadString(hInst, IDS_MHTML_FILTER, rgszFilter, ARRAYSIZE(rgszFilter));

            // Fixup the String
            ReplaceChars(rgszFilter, '|', '\0');

            // Initialize the Open File Structure
            ofn.lStructSize     = sizeof(OPENFILENAME);
            ofn.hwndOwner       = NULL;
            ofn.hInstance       = hInst;
            ofn.lpstrFilter     = rgszFilter;
            ofn.nFilterIndex    = 1;
            ofn.lpstrFile       = szSource;
            ofn.nMaxFile        = CCHMAX_PATH_EXPLODER;
            ofn.lpstrInitialDir = szDir;
            ofn.Flags           = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;

            // Get Open File Name
            if (FALSE == GetOpenFileName(&ofn))
                goto exit;
        }
    }

    // Do we have a valid destination...
    if (FALSE == PathIsDirectoryA(szDest))
    {
        // Try to locate /DEST:
        pszT = StrStrA(pszCmdLine, c_szDest);

        // If we found /DEST, then read the contents...
        if (pszT)
        {
            // Step over /DEST:
            pszT += lstrlen(c_szDest);

            // Initialize
            i = 0;

            // Read into szSource, until I hit a / or end of string...
            while ('\0' != *pszT && '/' != *pszT && i < CCHMAX_PATH_EXPLODER)
                szDest[i++] = *pszT++;

            // Pound in a Null
            szDest[i] = '\0';

            // Strip Leading and Trailing Whitespace
            UlStripWhitespace(szDest, TRUE, TRUE, NULL);

            // See if file exists
            if (FALSE == PathIsDirectoryA(szDest))
            {
                // Locals
                CHAR szError[CCHMAX_RES + CCHMAX_PATH_EXPLODER];

                // Message
                LoadString(hInst, IDS_DIRECTORY_NOEXIST, szRes, ARRAYSIZE(szRes));

                // Format the error message
                wsprintf(szError, szRes, szDest);

                // Message
                INT nAnswer = MessageBox(NULL, szError, g_szTitle, MB_YESNO | MB_ICONEXCLAMATION );

                // Done
                if (IDNO == nAnswer)
                    goto exit;

                // Try to create the directory
                if (FALSE == CreateDirectory(szDest, NULL))
                {
                    // Message
                    LoadString(hInst, IDS_NOCREATE_DIRECTORY, szRes, ARRAYSIZE(szRes));

                    // Format the error message
                    wsprintf(szError, szRes, szDest);

                    // Message
                    INT nAnswer = MessageBox(NULL, szError, g_szTitle, MB_YESNO | MB_ICONEXCLAMATION );

                    // Done
                    if (IDNO == nAnswer)
                        goto exit;

                    // Clear *szDest
                    *szDest = '\0';
                }
            }
        }

        // No Source File, lets browser for one
        if (FIsEmptyA(szDest))
        {
            // Copy in the source of exploder.exe
            GetModuleFileName(hInst, szDest, ARRAYSIZE(szDest));

            // Initialize szDest
            PathRemoveFileSpecA(szDest);

            // Failure
            if (FALSE == BrowseForFolder(hInst, NULL, szDest, ARRAYSIZE(szDest), IDS_BROWSE_DEST, TRUE))
                goto exit;

            // Better be a directory
            Assert(PathIsDirectoryA(szDest));
        }
    }

    // Validate the dest and source
    Assert(PathIsDirectoryA(szDest) && PathFileExists(szSource));

    // Explode the file
    nError = 0;
    hr = MimeOleExplodeMhtmlFile(szSource, szDest, &nError);

    // Failure ?
    if (FAILED(hr) || 0 != nError)
    {
        // Locals
        CHAR szError[CCHMAX_RES + CCHMAX_PATH_EXPLODER];

        // Message
        LoadString(hInst, nError, szRes, ARRAYSIZE(szRes));

        // Need to format with file name ?
        if (IDS_OPEN_FILE == nError || IDS_LOAD_FAILURE == nError || IDS_NO_HTML == nError)
        {
            // Format the error message
            wsprintf(szError, szRes, szSource, hr);
        }

        // Otherwise,
        else
        {
            // Format the error message
            wsprintf(szError, szRes, hr);
        }

        // Message
        MessageBox(NULL, szError, g_szTitle, MB_OK | MB_ICONEXCLAMATION);
    }

exit:
    // Done
    return(1);
}

// --------------------------------------------------------------------------------
// MimeOleExplodeMhtmlFile
// --------------------------------------------------------------------------------
HRESULT MimeOleExplodeMhtmlFile(LPCSTR pszSrcFile, LPSTR pszDstDir, INT *pnError)
{
    // Locals
    HRESULT             hr=S_OK;
    IStream            *pStmFile=NULL;
    IMimeMessage       *pMessage=NULL;
    HBODY               hRootHtml=NULL;
    DWORD               cMaxBodies;
    DWORD               cBodies=0;
    FINDBODY            FindBody={0};
    DWORD               cchDstDir;
    DWORD               iRootBody=0xffffffff;
    HBODY               hBody;
    PROPVARIANT         Variant;
    SHELLEXECUTEINFO    ExecuteInfo;
    LPBODYFILEINFO      prgBody=NULL;
    LPBODYFILEINFO      pInfo;
    DWORD               i;
    IMimeBody          *pBody=NULL;

    // Trace
    TraceCall("MimeOleExplodeMhtmlFile");

    // Invalid Args
    if (FALSE == PathIsDirectoryA(pszDstDir) || FALSE == PathFileExists(pszSrcFile) || NULL == pnError)
        return TraceResult(E_INVALIDARG);

    // Initialize
    *pnError = 0;

    // Get DstDir Length
    cchDstDir = lstrlen(pszDstDir);

    // Remove last \\ from pszDstDir
    if (cchDstDir && pszDstDir[cchDstDir - 1] == '\\')
    {
        pszDstDir[cchDstDir - 1] = '\0';
        cchDstDir--;
    }

    // Create a Mime Message
    IF_FAILEXIT_ERROR(IDS_MEMORY, hr = MimeOleCreateMessage(NULL, &pMessage));

    // Initialize the message
    IF_FAILEXIT_ERROR(IDS_GENERAL_ERROR, hr = pMessage->InitNew());

    // Create a stream on the file
    IF_FAILEXIT_ERROR(IDS_OPEN_FILE, hr = OpenFileStream((LPSTR)pszSrcFile, OPEN_EXISTING, GENERIC_READ, &pStmFile));

    // Load the Message
    IF_FAILEXIT_ERROR(IDS_LOAD_FAILURE, hr = pMessage->Load(pStmFile));

    // Invalid Message
    if (MIME_S_INVALID_MESSAGE == hr)
    {
        *pnError = IDS_LOAD_FAILURE;
        goto exit;
    }

    // Count the Bodies
    IF_FAILEXIT(hr = pMessage->CountBodies(NULL, TRUE, &cMaxBodies));

    // Allocate
    IF_FAILEXIT_ERROR(IDS_MEMORY, hr = HrAlloc((LPVOID *)&prgBody, sizeof(BODYFILEINFO) * cMaxBodies));

    // Zero
    ZeroMemory(prgBody, sizeof(BODYFILEINFO) * cMaxBodies);

    // Get the root body...
    IF_FAILEXIT_ERROR(IDS_NO_HTML, hr = pMessage->GetTextBody(TXT_HTML, IET_DECODED, NULL, &hRootHtml));

    // Loop through all the bodies
    hr = pMessage->FindFirst(&FindBody, &hBody);

    // Loop
    while(SUCCEEDED(hr))
    {
        // Must have an hBody
        Assert(hBody);

        // Skip Multipart Bodies
        if (S_FALSE == pMessage->IsContentType(hBody, STR_CNT_MULTIPART, NULL))
        {
            // Is this the root ?
            if (hBody == hRootHtml)
                iRootBody = cBodies;

            // Readability
            pInfo = &prgBody[cBodies];

            // Better not over run prgBody
            pInfo->hBody = hBody;

            // Init the Variant
            Variant.vt = VT_LPSTR;

            // Get the Content Id
            if (SUCCEEDED(pMessage->GetBodyProp(hBody, PIDTOSTR(PID_HDR_CNTID), 0, &Variant)))
                pInfo->pszCntId = Variant.pszVal;

            // Get the Content Location
            if (SUCCEEDED(pMessage->GetBodyProp(hBody, PIDTOSTR(PID_HDR_CNTLOC), 0, &Variant)))
                pInfo->pszCntLoc = Variant.pszVal;

            // Generate a filename
            if (SUCCEEDED(pMessage->GetBodyProp(hBody, PIDTOSTR(PID_ATT_GENFNAME), 0, &Variant)))
                pInfo->pszFileName = Variant.pszVal;

            // If its html, lets make sure that the filename has a .html file extension
            pInfo->fIsHtml = (S_OK == pMessage->IsContentType(hBody, STR_CNT_TEXT, STR_SUB_HTML)) ? TRUE : FALSE;

            // Take the filename and build the file path
            Assert(pInfo->pszFileName);

            // Don't Crash
            if (NULL == pInfo->pszFileName)
            {
                hr = TraceResult(E_UNEXPECTED);
                goto exit;
            }

            // Validate Extension
            if (pInfo->fIsHtml)
            {
                // Get Extension
                LPSTR pszExt = PathFindExtensionA(pInfo->pszFileName);

                // If Null or not .html..
                if (NULL == pszExt || lstrcmpi(pszExt, ".html") != 0)
                {
                    // Re-allocate pInfo->pszFileName...
                    IF_FAILEXIT_ERROR(IDS_MEMORY, hr = HrRealloc((LPVOID *)&pInfo->pszFileName, lstrlen(pInfo->pszFileName) + 10));

                    // Rename the Extension
                    PathRenameExtensionA(pInfo->pszFileName, ".html");
                }
            }

            // Build that full file path
            IF_FAILEXIT_ERROR(IDS_MEMORY, hr = HrAlloc((LPVOID *)&pInfo->pszFilePath, lstrlen(pszDstDir) + lstrlen(pInfo->pszFileName) + 10));

            // Formath the filepath
            wsprintf(pInfo->pszFilePath, "%s\\%s", pszDstDir, pInfo->pszFileName);

            // Save the body to the file
            IF_FAILEXIT(hr = pMessage->BindToObject(hBody, IID_IMimeBody, (LPVOID *)&pBody));

            // Save to the file
            IF_FAILEXIT(hr = pBody->SaveToFile(IET_DECODED, pInfo->pszFilePath));

            // Open a file stream
            if (pInfo->fIsHtml)
            {
                // Open it if its html
                IF_FAILEXIT(hr = OpenFileStream(pInfo->pszFilePath, OPEN_ALWAYS, GENERIC_READ | GENERIC_WRITE, &pInfo->pStmFile));
            }

            // Increment cBodies
            cBodies++;
        }

        // Loop through all the bodies
        hr = pMessage->FindNext(&FindBody, &hBody);
    }

    // Reset hr
    hr = S_OK;

    // Root Body was not found
    Assert(iRootBody != 0xffffffff);

    // Bad News
    if (0xffffffff == iRootBody)
    {
        hr = TraceResult(E_UNEXPECTED);
        goto exit;
    }

    // Walk through and fixup all HTML files and close all streams
    for (i=0; i<cBodies; i++)
    {
        // Readability
        pInfo = &prgBody[i];

        // If HTML...
        if (pInfo->fIsHtml)
        {
            // Better have an open stream
            Assert(pInfo->pStmFile);

            // Failure
            if (NULL == pInfo->pStmFile)
            {
                hr = TraceResult(E_UNEXPECTED);
                goto exit;
            }

            // Replace all the CID references with file references...
            ReplaceContentIds(pInfo->pStmFile, prgBody, cBodies);
        }

        // Release this stream
        SafeRelease(pInfo->pStmFile);
    }

    // Launch the Currently Registered HTML Editor ontop of iRootBody pszFilePath
    ZeroMemory(&ExecuteInfo, sizeof(SHELLEXECUTEINFO));
    ExecuteInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
    ExecuteInfo.cbSize = sizeof(SHELLEXECUTEINFO);
    ExecuteInfo.lpVerb = "Edit";
    ExecuteInfo.lpFile = prgBody[iRootBody].pszFilePath;
    ExecuteInfo.lpParameters = NULL;
    ExecuteInfo.lpDirectory = pszDstDir;
    ExecuteInfo.nShow = SW_SHOWNORMAL;

    // Compress szBlobFile
    ShellExecuteEx(&ExecuteInfo);

exit:
    // General Error
    if (FAILED(hr) && 0 == *pnError)
        *pnError = IDS_GENERAL_ERROR;

    // Free prgBody
    if (prgBody)
    {
        // Loop
        for (i=0; i<cBodies; i++)
        {
            SafeMemFree(prgBody[i].pszCntId);
            SafeMemFree(prgBody[i].pszCntLoc);
            SafeMemFree(prgBody[i].pszFileName);
            SafeMemFree(prgBody[i].pszFilePath);
            SafeRelease(prgBody[i].pStmFile);
        }

        // Free the Array
        CoTaskMemFree(prgBody);
    }

    // Cleanup
    SafeRelease(pStmFile);
    SafeRelease(pBody);
    SafeRelease(pMessage);

    // Done
    return hr;
}

// --------------------------------------------------------------------------------
// ReplaceContentIds
// --------------------------------------------------------------------------------
HRESULT ReplaceContentIds(LPSTREAM pStmHtml, LPBODYFILEINFO prgBody, DWORD cBodies)
{
    // Locals
    HRESULT         hr=S_OK;
    DWORD           cb;
    LPSTR           pszFound;
    LPSTR           pszT;
    LPSTR           pszHtml=NULL;
    LPSTR           pszCntId=NULL;
    DWORD           i;
    DWORD           cchCntId;
    ULARGE_INTEGER  uliSize;

    // Trac
    TraceCall("ReplaceContentIds");

    // Invalid Args
    Assert(pStmHtml && prgBody && cBodies);

    // Loop through the bodies
    for (i=0; i<cBodies; i++)
    {
        // No Content-ID here...
        if (NULL == prgBody[i].pszCntId)
            continue;

        // Better have a filename
        Assert(prgBody[i].pszFileName);

        // Load the stream into memory...
        IF_FAILEXIT(hr = HrGetStreamSize(pStmHtml, &cb));

        // Allocate Memory
        IF_FAILEXIT(hr = HrAlloc((LPVOID *)&pszHtml, cb + 1));

        // Rewind
        IF_FAILEXIT(hr = HrRewindStream(pStmHtml));

        // Read the Stream
        IF_FAILEXIT(hr = pStmHtml->Read(pszHtml, cb, NULL));

        // Stuff Null terminator
        pszHtml[cb] = '\0';

        // Kill pStmHtml
        uliSize.QuadPart = 0;
        IF_FAILEXIT(hr = pStmHtml->SetSize(uliSize));

        // Allocate Memory
        IF_FAILEXIT(hr = HrAlloc((LPVOID *)&pszCntId, lstrlen(prgBody[i].pszCntId) + lstrlen("cid:") + 5));

        // Format
        pszT = prgBody[i].pszCntId;
        if (*pszT == '<')
            pszT++;
        wsprintf(pszCntId, "cid:%s", pszT);

        // Remove trailing >
        cchCntId = lstrlen(pszCntId);
        if (pszCntId[cchCntId - 1] == '>')
            pszCntId[cchCntId - 1] = '\0';

        // Set pszT
        pszT = pszHtml;

        // Begin replace loop
        while(1)
        {
            // Find pszCntId
            pszFound = StrStrA(pszT, pszCntId);

            // Done
            if (NULL == pszFound)
            {
                // Write from pszT to pszFound
                IF_FAILEXIT(hr = pStmHtml->Write(pszT, (pszHtml + cb) - pszT, NULL));

                // Done
                break;
            }

            // Write from pszT to pszFound
            IF_FAILEXIT(hr = pStmHtml->Write(pszT, pszFound - pszT, NULL));

            // Write 
            IF_FAILEXIT(hr = pStmHtml->Write(prgBody[i].pszFileName, lstrlen(prgBody[i].pszFileName), NULL));

            // Set pszT
            pszT = pszFound + lstrlen(pszCntId);
        }

        // Commit
        IF_FAILEXIT(hr = pStmHtml->Commit(STGC_DEFAULT));

        // Cleanup
        SafeMemFree(pszHtml);
        SafeMemFree(pszCntId);
    }

exit:
    // Cleanup
    SafeMemFree(pszHtml);
    SafeMemFree(pszCntId);

    // Done
    return hr;
}

// --------------------------------------------------------------------------------
// CallRegInstall
// --------------------------------------------------------------------------------
HRESULT CallRegInstall(LPCSTR szSection)
{
    int         cch;
    HRESULT     hr;
    HINSTANCE   hAdvPack, hinst;
    REGINSTALL  pfnri;
    char        szExploderDll[CCHMAX_PATH_EXPLODER], szDir[CCHMAX_PATH_EXPLODER];
    STRENTRY    seReg[2];
    STRTABLE    stReg;
    char        c_szExploder[] = "EXPLODER";
    char        c_szExploderDir[] = "EXPLODER_DIR";


    hr = E_FAIL;

    hinst = GetModuleHandle(NULL);

    hAdvPack = LoadLibraryA(c_szAdvPackDll);
    if (hAdvPack != NULL)
        {
        // Get Proc Address for registration util
        pfnri = (REGINSTALL)GetProcAddress(hAdvPack, achREGINSTALL);
        if (pfnri != NULL)
            {
            stReg.cEntries = 0;
            stReg.pse = seReg;

            GetModuleFileName(hinst, szExploderDll, ARRAYSIZE(szExploderDll));
            seReg[stReg.cEntries].pszName = c_szExploder;
            seReg[stReg.cEntries].pszValue = szExploderDll;
            stReg.cEntries++;

            lstrcpy(szDir, szExploderDll);
            cch = lstrlen(szDir);
            for ( ; cch > 0; cch--)
                {
                if (szDir[cch] == '\\')
                    {
                    szDir[cch] = 0;
                    break;
                    }
                }
            seReg[stReg.cEntries].pszName = c_szExploderDir;
            seReg[stReg.cEntries].pszValue = szDir;
            stReg.cEntries++;

            // Call the self-reg routine
            hr = pfnri(hinst, szSection, &stReg);
            }

        FreeLibrary(hAdvPack);
        }

    return(hr);
}