windows-server-2003/windows/appcompat/shimdbc/registry.cpp

////////////////////////////////////////////////////////////////////////////////////
//
// File:    registry.cpp
//
// History: 21-Mar-00   markder     Created.
//          13-Dec-00   markder     Renamed from appshelp.cpp
//
// Desc:    This file contains all code needed to produce matching info registry
//          files and setup files (INX) for the Windows 2000 (RTM) shim mechanism.
//
////////////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "registry.h"

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   DumpString, DumpDword, DumpBinVersion, InsertString
//
//  Desc:   Helper functions for CreateMessageBlob.
//
void DumpString( DWORD dwId, PBYTE* ppBlob, LONG* pnTotalBytes, CString& csString )
{
    DWORD   dwLen;

    **(DWORD**)ppBlob = dwId;
    *ppBlob += sizeof(DWORD);

    dwLen = csString.GetLength();
    **(DWORD**)ppBlob = ( dwLen + 1) * sizeof(WCHAR);
    *ppBlob += sizeof(DWORD);

    CopyMemory(*ppBlob, T2W((LPTSTR) (LPCTSTR) csString), (dwLen + 1) * sizeof(WCHAR));
    *ppBlob += (dwLen + 1) * sizeof(WCHAR);
    *pnTotalBytes += ((dwLen + 1) * sizeof(WCHAR) + 2 * sizeof(DWORD));
}

void DumpDword( DWORD dwId, PBYTE* ppBlob, LONG* pnTotalBytes, DWORD dwVal )
{
    **(DWORD**)ppBlob = dwId;
    *ppBlob += sizeof(DWORD);

    **(DWORD**)ppBlob = sizeof(DWORD);
    *ppBlob += sizeof(DWORD);

    **(DWORD**)ppBlob = dwVal;
    *ppBlob += sizeof(DWORD);

    *pnTotalBytes += 3 * sizeof(DWORD);
}

void DumpBinVersion(DWORD dwId, PBYTE* ppBlob, LONG* pnTotalBytes, ULONGLONG ullVersion)
{
   ULONGLONG ullMask  = 0;
   ULONGLONG ullVer   = 0;
   WORD      wVerPart = 0;
   LONG      j;
   PBYTE     pBlob    = *ppBlob;

   for( j = 0; j < 4; j++ ) {
      wVerPart = (WORD) (ullVersion >> (j*16));
      if (wVerPart != 0xFFFF) {
            ullVer += ((ULONGLONG)wVerPart) << (j*16);
            ullMask += ((ULONGLONG) 0xFFFF) << (j*16);
      }
   }

   //
   // id
   //
   *(DWORD*)pBlob = dwId;
   pBlob += sizeof(DWORD);

   // size
   *(DWORD*)pBlob = 2 * sizeof(ULONGLONG);
   pBlob += sizeof(DWORD);

   // version
   CopyMemory(pBlob, &ullVer, sizeof(ULONGLONG));
   pBlob += sizeof(ULONGLONG);

   // mask
   CopyMemory(pBlob, &ullMask, sizeof(ULONGLONG));
   pBlob += sizeof(ULONGLONG);

   *pnTotalBytes += (2 * sizeof(ULONGLONG) + 2 * sizeof(DWORD));
   *ppBlob = pBlob;
}

void InsertString( CString* pcs, DWORD dwIndex, CString csInsertedString )
{
    *pcs = pcs->Left( dwIndex ) + csInsertedString + pcs->Right( pcs->GetLength() - dwIndex );
}

BOOL WriteStringToFile(
    HANDLE hFile,
    CString& csString)
{
    CHAR  szBuffer[1024];
    DWORD dwConvBufReqSize;
    DWORD dwConvBufSize = sizeof(szBuffer);
    BOOL  b; // this will be set if default char is used, we make no use of this
    LPSTR szConvBuf = szBuffer;
    BOOL  bAllocated = FALSE;
    BOOL  bSuccess;
    DWORD dwBytesWritten;


    dwConvBufReqSize = WideCharToMultiByte(CP_ACP, 0, csString, -1, NULL, NULL, 0, &b);
    if (dwConvBufReqSize > sizeof(szBuffer)) {
        szConvBuf = (LPSTR) new CHAR [dwConvBufReqSize];
        dwConvBufSize  = dwConvBufReqSize;
        bAllocated = TRUE;
    }

    WideCharToMultiByte(CP_ACP, 0, csString, -1, szConvBuf, dwConvBufSize, 0, &b);

    bSuccess = WriteFile( hFile, szConvBuf, dwConvBufReqSize - 1, &dwBytesWritten, NULL);
    if (bAllocated) {
        delete [] szConvBuf;
    }

    return bSuccess;
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   FreeRegistryBlob, CreateRegistryBlob
//
//  Desc:   Creates a binary blob in the format of Windows 2000's
//          Message registry keys.
//
void FreeRegistryBlob( PBYTE pBlob )
{
    delete pBlob;
}

BOOL CreateRegistryBlob(
   SdbExe* pExe,
   PBYTE* ppBlob,
   DWORD* pdwSize,
   DWORD dwMessageID = 0,  // these two are optional
   DWORD dwBlobType  = 6)
{
    USES_CONVERSION;

    BOOL    bSuccess = FALSE;

    PBYTE   pBlob = (PBYTE) new BYTE[4096];
    PBYTE   pStartOfBlob = pBlob;

    DWORD   dwBufSize = 4096;
    DWORD   dwReqBufSize = 0;
    LONG    nTotalBytes = 0;
    LONG    i, j;
    LONG    nBytes;

    SdbMatchingFile* pMFile;
    FILETIME FileTime;
    CString* pcsFilename;
    ULONGLONG ullMask = 0;
    WORD wVerPart = 0;
    ULONGLONG ullVer = 0;

    *pdwSize = 0;

    // Prolog
    *((DWORD*)pBlob + 0) = 3 * sizeof(DWORD);

    // message id

    *((DWORD*)pBlob + 1) = dwMessageID;

    // type is not shim anymore

    *((DWORD*)pBlob + 2) = dwBlobType; // shim type

    pBlob += 3 * sizeof(DWORD);
    nTotalBytes += 3 * sizeof(DWORD);

    for( i = 0; i < pExe->m_rgMatchingFiles.GetSize(); i++ )
    {
        pMFile = (SdbMatchingFile *) pExe->m_rgMatchingFiles[i];

        if( pMFile->m_csName == _T("*") ) {
            pcsFilename = &(pExe->m_csName);
        } else {
            pcsFilename = &(pMFile->m_csName);
        }

        DumpString( VTID_REQFILE, &pBlob, &nTotalBytes, *pcsFilename );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_SIZE )
            DumpDword( VTID_FILESIZE, &pBlob, &nTotalBytes, pMFile->m_dwSize );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_CHECKSUM )
            DumpDword( VTID_CHECKSUM, &pBlob, &nTotalBytes, pMFile->m_dwChecksum );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_COMPANY_NAME )
            DumpString( VTID_COMPANYNAME, &pBlob, &nTotalBytes, pMFile->m_csCompanyName );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_PRODUCT_NAME )
            DumpString( VTID_PRODUCTNAME, &pBlob, &nTotalBytes, pMFile->m_csProductName );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_PRODUCT_VERSION )
            DumpString( VTID_PRODUCTVERSION, &pBlob, &nTotalBytes, pMFile->m_csProductVersion );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_FILE_DESCRIPTION )
            DumpString( VTID_FILEDESCRIPTION, &pBlob, &nTotalBytes, pMFile->m_csFileDescription );

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_BIN_FILE_VERSION )
            DumpBinVersion(VTID_BINFILEVER, &pBlob, &nTotalBytes, pMFile->m_ullBinFileVersion);

        if( pMFile->m_dwMask & SDB_MATCHINGINFO_BIN_PRODUCT_VERSION )
            DumpBinVersion(VTID_BINPRODUCTVER, &pBlob, &nTotalBytes, pMFile->m_ullBinProductVersion);

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_MODULE_TYPE)
           DumpDword( VTID_EXETYPE, &pBlob, &nTotalBytes, pMFile->m_dwModuleType );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_VERFILEDATEHI)
           DumpDword( VTID_FILEDATEHI, &pBlob, &nTotalBytes, pMFile->m_dwFileDateMS );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_VERFILEDATELO)
           DumpDword( VTID_FILEDATELO, &pBlob, &nTotalBytes, pMFile->m_dwFileDateLS );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_VERFILEOS)
           DumpDword( VTID_FILEVEROS, &pBlob, &nTotalBytes, pMFile->m_dwFileOS );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_VERFILETYPE)
           DumpDword( VTID_FILEVERTYPE, &pBlob, &nTotalBytes, pMFile->m_dwFileType );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_PE_CHECKSUM)
           DumpDword( VTID_PECHECKSUM, &pBlob, &nTotalBytes, (DWORD)pMFile->m_ulPECheckSum );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_FILE_VERSION)
           DumpString( VTID_FILEVERSION, &pBlob, &nTotalBytes, pMFile->m_csFileVersion );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_ORIGINAL_FILENAME)
           DumpString( VTID_ORIGINALFILENAME, &pBlob, &nTotalBytes, pMFile->m_csOriginalFileName );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_INTERNAL_NAME)
           DumpString( VTID_INTERNALNAME, &pBlob, &nTotalBytes, pMFile->m_csInternalName );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_LEGAL_COPYRIGHT)
           DumpString( VTID_LEGALCOPYRIGHT, &pBlob, &nTotalBytes, pMFile->m_csLegalCopyright );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_16BIT_DESCRIPTION)
           DumpString( VTID_16BITDESCRIPTION, &pBlob, &nTotalBytes, pMFile->m_cs16BitDescription );

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_UPTO_BIN_PRODUCT_VERSION)
           DumpBinVersion(VTID_UPTOBINPRODUCTVER, &pBlob, &nTotalBytes, pMFile->m_ullUpToBinProductVersion);

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_LINK_DATE) {
           SDBERROR(_T("LINK_DATE not allowed for Win2k registry matching."));
           goto eh;
        }

        if (pMFile->m_dwMask & SDB_MATCHINGINFO_UPTO_LINK_DATE) {
           SDBERROR(_T("UPTO_LINK_DATE not allowed for Win2k registry matching."));
           goto eh;
        }
    }

    // Terminator
    *((DWORD*)pBlob) = 0;
    pBlob += sizeof(DWORD);
    nTotalBytes += sizeof(DWORD);

    bSuccess = TRUE;

eh:

    if( bSuccess ) {
        *pdwSize = nTotalBytes;
        *ppBlob = pStartOfBlob;
    } else if( pStartOfBlob ) {
        FreeRegistryBlob( pStartOfBlob );
        *pdwSize = 0;
        *ppBlob = NULL;
    }

    return bSuccess;
}

BOOL RegistryBlobToString(PBYTE pBlob, DWORD dwBlobSize, CString& csBlob)
{
   DWORD i;
   CString csTemp;

   csBlob = "";
   for (i = 0; i < dwBlobSize; i++, ++pBlob) {
      csTemp.Format( _T("%02X"), (DWORD)*pBlob );

      if (i == dwBlobSize - 1) {   // this is the last char
         csTemp += _T("\r\n");
      }
      else {
         if ((i+1) % 27 == 0) {    // time to do end of the line ?
            csTemp += _T(",\\\r\n");
         }
         else {
            csTemp += _T(",");    // just add comma
         }
      }
      csBlob += csTemp;
   }

   return(TRUE);
}


////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   CreateMessageRegEntry, WriteMessageRegistryFiles
//
//  Desc:   These functions create Win2k-style registry entries for the old
//          Message mechanism, which exists in SHELL32!ShellExecute.
//
BOOL CreateMessageRegEntry(
   SdbExe* pExe,
   DWORD dwExeCount,
   CString& csReg,
   CString& csInx)
{
   PBYTE pBlob = NULL;
   BOOL bSuccess = FALSE;
   DWORD dwBlobSize = 0;
   CString csRegEntry, csInxEntry;
   CString csApp;
   CString csBlob;
   CString csTemp;

   if (!CreateRegistryBlob(pExe,
                           &pBlob,
                           &dwBlobSize,
                           (DWORD)_ttol(pExe->m_AppHelpRef.m_pAppHelp->m_csName),
                           pExe->m_AppHelpRef.m_pAppHelp->m_Type)) {
       SDBERROR(_T("Error in CreateRegistryBlob()"));
       goto eh;
   }

    csApp = pExe->m_pApp->m_csName;
    csApp.Remove(_T(' '));

    csTemp.Format(_T("[HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\AppCompatibility\\%s]\r\n\"%05X %s\"=hex:"),
    pExe->m_csName, dwExeCount, csApp.Left(25));

    csRegEntry = csTemp;

    csTemp.Format(_T("HKLM,\"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\AppCompatibility\\%s\",\"%05X %s\",0x00030003,\\\r\n"),
    pExe->m_csName, dwExeCount, csApp.Left(25) );

    csInxEntry = csTemp;

    //
    // now grab the blob
    //
    if (!RegistryBlobToString(pBlob, dwBlobSize, csBlob)) {
       SDBERROR(_T("Error in RegistryBlobToString()"));
       goto eh;
    }

    csRegEntry += csBlob;
    csInxEntry += csBlob;

    csReg = csRegEntry;
    csInx = csInxEntry;

    bSuccess = TRUE;

eh:

    if (NULL != pBlob) {
    FreeRegistryBlob( pBlob );
    }

    return(bSuccess);
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   CreateRegistryBlob, WriteRegistryFiles
//
//  Desc:   These functions create a Win2k-style registry entries for both
//          Message as well as a stub entry for shimming that provides no
//          additional matching info past EXE name. This allows the 'new'
//          Win2k version of the shim engine to 'bootstrap' itself into memory
//          via the original mechanism and then perform more detailed matching
//          in its own way.
//
BOOL CreateWin2kExeStubRegistryBlob(
   SdbExe* pExe,
   PBYTE* ppBlob,
   DWORD* pdwSize,
   DWORD dwMessageID = 0,  // these two are optional
   DWORD dwBlobType  = 6)
{
    USES_CONVERSION;

    BOOL    bSuccess = FALSE;
    DWORD   dwBufSize = sizeof(DWORD) * 4;
    LONG    nTotalBytes = 0;
    PBYTE   pStartOfBlob;

    PBYTE   pBlob = (PBYTE) new BYTE[dwBufSize];
    pStartOfBlob = pBlob;                                       
    *pdwSize = 0;
    if (NULL != pBlob) {

        // Prolog
        *((DWORD*)pBlob + 0) = 3 * sizeof(DWORD); // 0x0C 00 00 00

        // message id
        *((DWORD*)pBlob + 1) = dwMessageID;       // 0x00 00 00 00 

        // type is shim 
        *((DWORD*)pBlob + 2) = dwBlobType;        // 0x06 00 00 00

        pBlob += 3 * sizeof(DWORD);
        nTotalBytes += 3 * sizeof(DWORD);

        // Terminator
        *((DWORD*)pBlob) = 0;
        pBlob += sizeof(DWORD);
        nTotalBytes += sizeof(DWORD);

        *pdwSize = (DWORD)nTotalBytes;
        *ppBlob = pStartOfBlob;
        bSuccess = TRUE;
    }
    
    return bSuccess;
}


BOOL WriteRegistryFiles(
    SdbDatabase* pDatabase,
    CString csRegFile,
    CString csInxFile,
    BOOL bAddExeStubs)
{
    CString csRegEntry, csInxEntry, csTemp, csCmdLineREG, csCmdLineINX,
            csTemp1, csApp, csExeName;
    SdbExe* pExe;
    SdbApp* pApp;
    long i, j, l, m;
    DWORD k, dwBlobSize, dwBytesWritten, dwExeCount = 0;
    PBYTE pBlob;
    BOOL b, bSuccess = FALSE;
    CMapStringToPtr mapNames;
    SdbApp* pAppValue;
    
    HANDLE hRegFile = NULL;
    HANDLE hInxFile = NULL;

    hRegFile = CreateFile( csRegFile, GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
    hInxFile = CreateFile( csInxFile, GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );

    if( hRegFile == INVALID_HANDLE_VALUE ||
        hInxFile == INVALID_HANDLE_VALUE ) {
        SDBERROR_FORMAT((_T("Error creating registry files:\n%s\n%s\n"), csRegFile, csInxFile));
        goto eh;
    }

    if( ! WriteFile( hRegFile, "REGEDIT4\r\n\r\n", strlen("REGEDIT4\r\n\r\n"), &dwBytesWritten, NULL ) ) {
        SDBERROR(_T("Error writing header to .reg file.\n"));
        goto eh;
    }


    //
    // loop through all the apps, make apphelp entries
    //
    for (i = 0; i < pDatabase->m_rgExes.GetSize(); i++) {

        pExe = (SdbExe *) pDatabase->m_rgExes[i];

        if (pExe->m_AppHelpRef.m_pAppHelp == NULL) { // not an apphelp entry
            continue;
        }

        if (!(pExe->m_dwFilter & g_dwCurrentWriteFilter)) {
            continue;
        }


        b = CreateMessageRegEntry(pExe, dwExeCount, csRegEntry, csInxEntry);
        if (!b) {
            SDBERROR(_T("Error creating reg entry.\n"));
            goto eh;
        }

        if (!WriteStringToFile(hRegFile, csRegEntry)) {
            SDBERROR(_T("Error writing reg entry.\n"));
            goto eh;
        }

        if (!WriteStringToFile(hInxFile, csInxEntry)) {
            SDBERROR(_T("Error writing inx entry.\n"));
            goto eh;
        }

        ++dwExeCount;
    }

    //
    // Add the Win2k EXE stubs to bootstrap the new shim mechanism
    //
    if (bAddExeStubs) {

        for( i = 0; i < pDatabase->m_rgApps.GetSize(); i++ )
        {
            pApp = (SdbApp *) pDatabase->m_rgApps[i];

            csApp = pApp->m_csName;
            csApp.Remove(_T(' '));

            for( j = 0; j < pApp->m_rgExes.GetSize(); j++ )
            {
                pExe = (SdbExe *) pApp->m_rgExes[j];


                //
                // check whether this entry is apphelp-only
                // if so, skip to the next exe
                //
                if (pExe->m_AppHelpRef.m_pAppHelp) {
                    if (pExe->m_AppHelpRef.m_bApphelpOnly) {
                        continue;
                    }
                }

                if (pExe->m_bWildcardInName) {
                    continue;
                }

                if (!(pExe->m_dwFilter & g_dwCurrentWriteFilter)) {
                    continue;
                }

                csExeName = pExe->m_csName;
                csExeName.MakeUpper();
    
                // now we have to create an application entry -- if we have not hit this
                // exe name before
                if (mapNames.Lookup(csExeName, (VOID*&)pAppValue)) {
                    continue;
                }


                csRegEntry.Empty();
                csInxEntry.Empty();


                if (!CreateWin2kExeStubRegistryBlob(pExe, &pBlob, &dwBlobSize)) {
                    SDBERROR(_T("Error creating EXE stub.\n"));
                    goto eh;
                }


                //
                // To reduce the amount of space that we take, we substitute
                // app name for something short
                //
                csApp = _T("x");

                csTemp.Format( _T("[HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\AppCompatibility\\%s]\r\n\"%s\"=hex:"),
                                   pExe->m_csName, csApp.Left(25) );

                csRegEntry += csTemp;

                csTemp.Format( _T("HKLM,\"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\AppCompatibility\\%s\",\"%s\",0x00030003,\\\r\n"),
                                   pExe->m_csName, csApp.Left(25) );

                csInxEntry += csTemp;

                RegistryBlobToString(pBlob, dwBlobSize, csTemp);
                csRegEntry += csTemp;
                csInxEntry += csTemp;

                csCmdLineREG.Empty();
                csCmdLineINX.Empty();

                csTemp.Format( _T("\"DllPatch-%s\"=\"%s\"\r\n"),
                               csApp.Left(25), csCmdLineREG );

                csRegEntry += csTemp;

                csTemp.Format( _T("HKLM,\"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\AppCompatibility\\%s\",\"DllPatch-%s\",0x00000002,\"%s\"\r\n"),
                               pExe->m_csName, csApp.Left(25), csCmdLineINX );

                csInxEntry += csTemp;

                csRegEntry += _T("\r\n");
                csInxEntry += _T("\r\n");

                if (!WriteStringToFile(hRegFile, csRegEntry)) {
                    SDBERROR(_T("Error writing reg line.\n"));
                    goto eh;
                }

                if (!WriteStringToFile(hInxFile, csInxEntry)) {
                    SDBERROR(_T("Error writing inx line.\n"));
                    goto eh;
                }

                ++dwExeCount;

                // now update the map
                mapNames.SetAt(csExeName, (PVOID)pExe);

                FreeRegistryBlob( pBlob );
            }
        }
    }

    bSuccess = TRUE;

eh:
    if( hRegFile )
        CloseHandle( hRegFile );

    if( hInxFile )
        CloseHandle( hInxFile );

    return bSuccess;
}