// ===========================================================================
// File: CSETUP.CXX
//    CSetup class implementation
//


#include <cdlpch.h>
#include "verp.h"

#include <advpub.h>
#include "advpkp.h"
extern CRunSetupHook g_RunSetupHook;
extern BOOL g_bRunOnWin95;

inline
DWORD Win32ErrorFromHResult( HRESULT hr)
{
    // BUGBUG: assert failed?
    //BUGBUG: assert win32 facility?
    return (DWORD)(hr & 0x0000ffff);
}

DWORD GetFullPathNameA_Wrap(
  LPCSTR lpFileName,  // file name
  DWORD nBufferLength, // size of path buffer
  LPSTR lpBuffer,     // path buffer
  LPSTR *lpFilePart   // address of file name in path
);


// ---------------------------------------------------------------------------
// %%Function: CSetup::CSetup
//
//  Csetup obj: zero or more associated with every CDownload obj
//  Some CDownload's may have no CSetup (eg. INF file)
// ---------------------------------------------------------------------------
CSetup::CSetup(LPCSTR pSrcFileName, LPCSTR pBaseFileName, FILEXTN extn, 
                LPCSTR pDestDir, HRESULT *phr, DESTINATION_DIR dest)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CSetup::CSetup",
                "this=%#x, %.80q, %.80q, %#x, %.80q, %#x, %#x",
                this, pSrcFileName, pBaseFileName, extn, pDestDir, phr, dest
                ));
                
    m_pSetupnext = NULL;

    m_extn = extn;
    m_dest = dest;

    m_flags = 0;
    m_advcopyflags = 0;     // flags for AdvInstallFile

    m_state = INSTALL_INIT;

    m_pExistDir = NULL;

    if (pDestDir) {
        m_pExistDir = new char [lstrlen(pDestDir)+1];

        if (m_pExistDir)
            lstrcpy((char *)m_pExistDir, pDestDir);
        else
            *phr = E_OUTOFMEMORY;
    }

    Assert(pBaseFileName);
    if (pBaseFileName) {
        m_pBaseFileName = new char [lstrlen(pBaseFileName)+1];

        if (m_pBaseFileName)
            lstrcpy(m_pBaseFileName, pBaseFileName);
        else
            *phr = E_OUTOFMEMORY;
    }

    if (pSrcFileName) {

        m_pSrcFileName = new char [lstrlen(pSrcFileName)+1];

        if (m_pSrcFileName)
            lstrcpy(m_pSrcFileName, pSrcFileName);
        else
            *phr = E_OUTOFMEMORY;
    }

    m_bExactVersion = FALSE;

    DEBUG_LEAVE(0);
}

// ---------------------------------------------------------------------------
// %%Function: CSetup::~CSetup
// ---------------------------------------------------------------------------
CSetup::~CSetup()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CSetup::~CSetup",
                "this=%#x",
                this
                ));
                
    if (m_pSrcFileName)
        delete (LPSTR)m_pSrcFileName;

    if (m_pBaseFileName)
        delete (LPSTR)m_pBaseFileName;

    if (m_pExistDir)
        delete (LPSTR)m_pExistDir;

    DEBUG_LEAVE(0);
}

// ---------------------------------------------------------------------------
// %%Function: CSetup::SetSrcFileName
// ---------------------------------------------------------------------------
HRESULT CSetup::SetSrcFileName(LPCSTR pSrcFileName)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSetup::SetSrcFileName",
                "this=%#x, %.80q",
                this, pSrcFileName
                ));
                
    if (m_pSrcFileName) {
        SAFEDELETE(m_pSrcFileName);
    }


    ASSERT(pSrcFileName);
    ASSERT(pSrcFileName[0] != '\0');

    HRESULT hr = S_OK;

    if (pSrcFileName) {

        m_pSrcFileName = new char [lstrlen(pSrcFileName)+1];

        if (m_pSrcFileName)
            lstrcpy(m_pSrcFileName, pSrcFileName);
        else
            hr = E_OUTOFMEMORY;
    } else {
        hr = E_INVALIDARG;
    }

    DEBUG_LEAVE(hr);
    return hr;
}



// ---------------------------------------------------------------------------
// %%Function: CSetup::CheckForNameCollisions
// This checks if the given cache dir has name collision for this file
// ---------------------------------------------------------------------------
HRESULT CSetup::CheckForNameCollision(CCodeDownload *pcdl, LPCSTR szCacheDir)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSetup::CheckForNameCollision",
                "this=%#x, %#x, %.80q",
                this, pcdl, szCacheDir
                ));

    HRESULT hr = S_OK;
    char szDest[MAX_PATH];


    // INFs don't matter for name collisions or prev version exists
    // the way to handle this is to doc that evryone should choose
    // same name INFs as their primary OCX. This way the INF and OCX will
    // reside in the same dir (szCacheDir) and the primary OCX will handle
    // name collisions and be located in a non-conflicting dir.
    // So, INFs will always be overwritten. If someone defies convention
    // we might end up losing an INF, so we have to gerbage collect the
    // OCX to recover space on disk.

    if ( (m_extn == FILEXTN_INF) || (m_extn == FILEXTN_OSD))
        goto Exit;


    if (m_pExistDir)     // if a previous version exists and this is a
        goto Exit;      // and this is a overwrite all OK (no accidental
                        // name collision issues


    // we don't care now if the dest is either Windows or System dir
    // This case will be tackled in CSetup::DoSetup after we have established
    // a non-colliding OCXCACHE dir for m_dest == LDID_OCXCACHE case
    // to put rest of this OCX files in
    if ((m_dest == LDID_SYS) || (m_dest == LDID_WIN))
        goto Exit;

    if (lstrlen(m_pBaseFileName) + lstrlen(szCacheDir) + 1 > MAX_PATH) {
        // Fatal! The length of the filepath is beyond MAX_PATH.
        hr = E_UNEXPECTED;
        goto Exit;
    }

    lstrcpy(szDest, szCacheDir);
    lstrcat(szDest, "\\");
    lstrcat(szDest, m_pBaseFileName);

    if (GetFileAttributes(szDest) != -1) {    // file exists?


        if (!IsEqualGUID(pcdl->GetClsid() , CLSID_NULL)) {
            hr = S_FALSE;                       // report name conflict
            goto Exit;
        }

        // check if that file implements the main clsid
        HRESULT hr1 = CheckFileImplementsCLSID(szDest, pcdl->GetClsid());

        if (FAILED(hr1))
            hr = S_FALSE;                       // report name conflict
    }

Exit:

    DEBUG_LEAVE(hr);
    return hr;
}


// ---------------------------------------------------------------------------
// %%Function: CSetup::InstallFile
// ---------------------------------------------------------------------------
HRESULT CSetup::InstallFile(CCodeDownload *pcdl, LPSTR szDest, int iLen, LPWSTR szStatusText, 
                            LPUINT pcbStatusText)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSetup::InstallFile",
                "this=%#x, %#x, %.80q, %.80wq, %#x",
                this, pcdl, szDest, szStatusText, pcbStatusText
                ));
                
    char *pSrcBaseName;
    char pSrcDir[MAX_PATH];
    HWND hWnd = pcdl->GetClientBinding()->GetHWND();
    HRESULT hr = S_OK;
    char szDestDir[MAX_PATH];
    char szDestDirShort[MAX_PATH];
    DWORD dwMachineType = 0;


    SetState(INSTALL_COPY);

    GetDestDir(pcdl, szDestDir, sizeof(szDestDir));

    if (g_bRunOnWin95) {
        if (!GetShortPathName(szDestDir, szDestDirShort, MAX_PATH)) {
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto Exit;
        }
        lstrcpy(szDestDir, szDestDirShort);
    }

    StrNCpy(szDest, szDestDir, iLen);
    StrCatBuff(szDest, "\\", iLen);
    StrCatBuff(szDest, m_pBaseFileName, iLen);

    //may be MAX_PATH (instead of *pcbStatusText, which in the only case this is called is = INTERNET_MAX_URL_LENGTH + 2*MAX_PATH)
    *pcbStatusText = MultiByteToWideChar(CP_ACP, 0, szDest, -1, szStatusText,
                        MAX_PATH);

    pcdl->GetClientBSC()->OnProgress( INSTALL_COPY, INSTALL_PHASES,
        BINDSTATUS_INSTALLINGCOMPONENTS, szStatusText);


    // get src dir + srcbasename out of src filename
    if (!GetFullPathNameA_Wrap(m_pSrcFileName, MAX_PATH, 
            pSrcDir, &pSrcBaseName)) {

        hr = HRESULT_FROM_WIN32(GetLastError());
        goto Exit;
    }
    
    // Installed catalog => this setup might be for a SFP-protected file.
    // So check if this file is protected, and if it is 
    if (g_bNT5OrGreater && pcdl->IsCatalogInstalled())
    {
        LPSTR pszFile;
        DWORD cbLen = lstrlen(szDestDir) + lstrlen(m_pBaseFileName);
        pszFile = new CHAR[cbLen+2];
        BOOL bRet;

        if (pszFile)
        {
            lstrcpy(pszFile, szDestDir);
            lstrcat(pszFile, "\\");
            lstrcat(pszFile, m_pBaseFileName);

            bRet = pcdl->IsFileProtected(pszFile);
            delete [] pszFile;

            if (bRet && FAILED(pcdl->VerifyFileAgainstSystemCatalog(pSrcDir, NULL, NULL)))
            {
                hr = INET_E_CANNOT_REPLACE_SFP_FILE;
                goto Exit;
            }
        }
    }

    Assert(pSrcDir != pSrcBaseName);
    Assert(pSrcBaseName);

    *(pSrcBaseName-1) = '\0'; // make a dir out of pSrcDir

    // sniff machine type of PE
            
    hr = IsCompatibleFile(m_pSrcFileName, &dwMachineType);

    if (hr == HRESULT_FROM_WIN32(ERROR_EXE_MACHINE_TYPE_MISMATCH)) {

        // if its of wrong CPU flavor fail and clean up the OCX
        pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_INCOMPATIBLE_BINARY, m_pSrcFileName);
        goto Exit;
    }

#ifdef WX86
    if (g_fWx86Present && dwMachineType == IMAGE_FILE_MACHINE_I386) {
        //
        // From here on out, all other binaries downloaded must also be i386
        //
        hr = pcdl->GetMultiArch()->RequireAlternateArch();
        if (FAILED(hr)) {
            //
            // We're in the middle of downloading an Alpha piece, and we ended
            // up finding an x86-only piece.  Fail the download.
            //
            pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_INCOMPATIBLE_BINARY, m_pSrcFileName);
            goto Exit;
        }
    }

    if (pcdl->GetMultiArch()->GetRequiredArch() == PROCESSOR_ARCHITECTURE_INTEL) {
        //
        // Use x86 advpack.dll to install
        //
        hr = g_RunSetupHook.AdvInstallFileX86(hWnd, pSrcDir, pSrcBaseName,
                                              szDestDir, m_pBaseFileName,
                                              m_advcopyflags, 0);
    } else {
        //
        // Use native advpack.dll to install
        //
        hr = g_RunSetupHook.AdvInstallFile(hWnd, pSrcDir, pSrcBaseName,
                                           szDestDir, m_pBaseFileName,
                                           m_advcopyflags, 0);
    }
#else
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "g_RunSetupHook.AdvInstallFile",
                "%#x, %.80q, %.80q, %.80q, %.80q, %x",
                hWnd, pSrcDir, pSrcBaseName, szDestDir, m_pBaseFileName, m_advcopyflags
                ));
                
    hr = g_RunSetupHook.AdvInstallFile(hWnd, pSrcDir, pSrcBaseName,
                                       szDestDir, m_pBaseFileName,
                                       m_advcopyflags, 0);
    DEBUG_LEAVE(hr);
#endif

    if (FAILED(hr)) {
        goto Exit;
    }

    // if error_success_reboot_required
    // then preserve this and return for overall download
    // if overall download fails beyond this point then, we should raise the
    // CIP and then fail with the subsequent error.

    if (hr == ERROR_SUCCESS_REBOOT_REQUIRED) {
        pcdl->SetRebootRequired();
    }

Exit:

    DEBUG_LEAVE(hr);
    return hr;
}


// ---------------------------------------------------------------------------
// %%Function: CSetup::GetDestDir
// ---------------------------------------------------------------------------
HRESULT CSetup::GetDestDir(CCodeDownload *pcdl, LPSTR szDestDir, int iLen)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSetup::GetDestDir",
                "this=%#x, %#x, %.80q",
                this, pcdl, szDestDir
                ));

    if (!m_pExistDir) {

        // no existing version of file on client machine
        // if no suggested dest dir was specified move to ocxcachedir
        switch (m_dest) {

        case LDID_SYS:
#ifdef WX86
                if (pcdl->GetMultiArch()->GetRequiredArch() == PROCESSOR_ARCHITECTURE_INTEL) {
                    // An x86 control is downloading.  Tell GetSystemDirectory
                    // to return the sys32x86 dir instead of system32
                    NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll = TRUE;
                }
#endif
                GetSystemDirectory(szDestDir, MAX_PATH);
                break;

        case LDID_WIN:
                GetWindowsDirectory(szDestDir, MAX_PATH);
                break;

        case LDID_OCXCACHE:

                Assert(pcdl->GetCacheDir());
                StrNCpy(szDestDir, pcdl->GetCacheDir(), iLen);
                break;

        }

    } else {
        StrNCpy(szDestDir, m_pExistDir, iLen);
    }

    DEBUG_LEAVE(S_OK);
    return S_OK;
}


// ---------------------------------------------------------------------------
// %%Function: CSetup::DoSetup
//    The main action item for CSetup
//    installs file in proper dest dir (if null) defaults to ocxcache dir
//    It then registers the file if registerable
// ---------------------------------------------------------------------------
HRESULT CSetup::DoSetup(CCodeDownload *pcdl, CDownload *pdl)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSetup::DoSetup",
                "this=%#x, %#x, %#x",
                this, pcdl, pdl
                ));
                
    char szDest[MAX_PATH];
    BOOL bModuleUsage = TRUE;

    // url + filename + other parts of msg 
    WCHAR szStatusText[INTERNET_MAX_URL_LENGTH+MAX_PATH+MAX_PATH];

    IBindStatusCallback* pClientBSC = pcdl->GetClientBSC();
    HRESULT hr = S_OK;
    UINT nStatusText =  0;

    BOOL bReboot = FALSE;

    // side-effect of below: changes szStatusText, nStatusText and 
    // fills in szDest to be destination file
    hr = InstallFile(pcdl, szDest, sizeof(szDest), szStatusText, &nStatusText);

    if (hr == ERROR_SUCCESS_REBOOT_REQUIRED) {
        bReboot = TRUE;
        hr = S_OK;
        pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_FILE_INUSE, szDest);
    }

    if (hr != S_OK)     // skip or abort?
        goto Exit;


    SetState(INSTALL_REGISTER);

    if ((m_extn == FILEXTN_INF) || (m_extn == FILEXTN_OSD)) {
        // nothing to register!
        // but, remember the name of the installed INF/OSD
        // to store away in registry.

        hr = pcdl->SetManifest(m_extn, szDest);
        goto Exit;
    }

    pClientBSC->OnProgress( INSTALL_REGISTER, INSTALL_PHASES, BINDSTATUS_INSTALLINGCOMPONENTS, szStatusText);

    // document one thing and do something else!
    // if its not an EXE try to self register no matter what?!
    // unless overriden not to.
    if (m_extn == FILEXTN_EXE) {

        BOOL bLocalServer = (UserOverrideRegisterServer() && WantsRegisterServer()) || (!UserOverrideRegisterServer() && SupportsSelfRegister(szDest));

        if ( bLocalServer ||
            ((pdl->GetExtn() != FILEXTN_CAB) && !UserOverrideRegisterServer())){

            pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_DLL_REGISTERED, szDest);
            hr = pcdl->InstallOCX(szDest, m_extn, bLocalServer);

            // if we executed an EXE that was not a local server it is
            // probably just a setup EXE that needs to be cleaned up when
            // done. So we don't do ModuleUsage for those.
            if (!bLocalServer)
                bModuleUsage = FALSE;
        }

    } else {

        if (!UserOverrideRegisterServer() || WantsRegisterServer()) {
            if (!bReboot) {
                hr = pcdl->InstallOCX(szDest, m_extn, FALSE);
            } else {

                // we are going to reboot the machine to install the new
                // version of the OCX. So, no point trying to register it here
                // instead we will make it register on the next reboot
                // and proceed here as if it succeded.


                // what could be broken here is that if we proceed and
                // some other setup required this OCX to be registered 
                // then it will fail
                // the work around is for those guys have interdependent
                // registerations to install using a custom EXE that will
                // force the user to reboot.

                if (IsRegisterableDLL(m_pSrcFileName) == S_OK) {
                    hr = pcdl->DelayRegisterOCX(szDest, m_extn);
                    pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_DLL_REGISTERED, szDest);
                }

            }
        }
    }

    if (FAILED(hr)) {

        if (!m_pExistDir)
            DeleteFile(szDest);

    } else {

        // make sure we have a ref count for the code downloader in
        // shareddlls as well as mark us as a client in the usage section
        // if there is no prev version we are upgrading over
        // mark us as the owner

        if (bModuleUsage) {
            if (m_bExactVersion) {
                // Need to do this because in a exact version scenario,
                // we may have upgraded/downgraded in which case m_pExistDir
                // is non-NULL. We want us to be listed as our own owner
                // instead of "Unknown Owner" so OCCache can remove us later.
                hr = pcdl->QueueModuleUsage(szDest, MU_OWNER);
                if (FAILED(hr)) {
                    goto Exit;
                }
            }
            else {
                if (FAILED((hr= pcdl->QueueModuleUsage(szDest,
                                        (m_pExistDir)?MU_CLIENT:MU_OWNER))))
                    goto Exit;
            }
        }

    }

Exit:

    if (FAILED(hr)) {
        pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_DOSETUP_FAILED, hr, m_pBaseFileName, m_pExistDir, m_dest);
    } else {
        pcdl->CodeDownloadDebugOut(DEB_CODEDL, TRUE, ID_CDLDBG_SETUP_COMPLETE, m_pBaseFileName, m_pExistDir, m_dest);
    }

    SetState(INSTALL_DONE);

    DEBUG_LEAVE(hr);
    return hr;
}