2105 lines
75 KiB
C++
2105 lines
75 KiB
C++
#ifndef _CDL_H_
|
|
#define _CDL_H_
|
|
|
|
#define MAX_DEBUG_STRING_LENGTH 2048
|
|
#define MAX_DEBUG_FORMAT_STRING_LENGTH 1024
|
|
#define MAX_VERSIONLENGTH 27 // sizeof(2DWORDS)/(log 10 base 2) + 3 (seperators)
|
|
// == 64/3 + 3 == 25
|
|
// CDL.h
|
|
// Code Downloader header file
|
|
//
|
|
// Read "class descriptions" first for understanding how the
|
|
// code downloader works.
|
|
|
|
#define STRING(x) (((x) != NULL) ? (x) : (L"(null)"))
|
|
|
|
#ifndef ARRAY_ELEMENTS
|
|
#define ARRAY_ELEMENTS(array) \
|
|
(sizeof(array)/sizeof(array[0]))
|
|
#endif /* ARRAY_ELEMENTS */
|
|
|
|
#include <safeocx.h>
|
|
#include "debmacro.h"
|
|
#include <msxml.h>
|
|
#include "wvtp.h"
|
|
//#include "..\inc\clist.hxx"
|
|
#ifndef unix
|
|
#include "..\utils\coll.hxx"
|
|
#else
|
|
#include "../utils/coll.hxx"
|
|
#endif /* !unix */
|
|
#include "packet.hxx"
|
|
#include "shlwapi.h"
|
|
#include "strids.h"
|
|
|
|
#include <pkgmgr.h>
|
|
|
|
#ifdef WX86
|
|
#ifdef __cplusplus // make classes invisible to 'C'
|
|
// Support for multiple architectures during code download. This must
|
|
// be declared before softdist.hxx can be included.
|
|
class CMultiArch {
|
|
public:
|
|
CMultiArch() { m_RequiredArch = PROCESSOR_ARCHITECTURE_UNKNOWN; };
|
|
DWORD GetRequiredArch() { return m_RequiredArch;}
|
|
HRESULT RequirePrimaryArch();
|
|
HRESULT RequireAlternateArch();
|
|
VOID SelectArchitecturePreferences(
|
|
char *szNativeArch,
|
|
char *szIntelArch,
|
|
char **pszPreferredArch,
|
|
char **pszAlternateArch);
|
|
|
|
private:
|
|
DWORD m_RequiredArch;
|
|
};
|
|
#endif
|
|
#endif
|
|
|
|
#include "softdist.hxx"
|
|
|
|
#include <capi.h>
|
|
|
|
#define MAX_REGSTR_LEN 1024
|
|
|
|
#define DU_TAG_SOFTDIST L"SOFTPKG"
|
|
#define DU_TAG_NATIVECODE L"msicd::NativeCode"
|
|
#define DU_TAG_JAVA L"msicd::Java"
|
|
#define DU_TAG_EXPIRE L"msicd::Expire"
|
|
|
|
#define DU_TAG_UNINSTALL_OLD L"msicd::UninstallOld"
|
|
#define INF_TAG_UNINSTALL_OLD "UninstallOld"
|
|
|
|
#define DU_TAG_CODE L"Code"
|
|
#define DU_TAG_CODEBASE L"CodeBase"
|
|
#define DU_TAG_PACKAGE L"Package"
|
|
#define DU_TAG_TITLE L"TITLE"
|
|
#define DU_TAG_ABSTRACT L"ABSTRACT"
|
|
#define DU_TAG_LANG L"LANGUAGE"
|
|
#define DU_TAG_DEPENDENCY L"Dependency"
|
|
#define DU_TAG_PROCESSOR L"Processor"
|
|
#define DU_TAG_PLATFORM L"Platform"
|
|
#define DU_TAG_CONFIG L"IMPLEMENTATION"
|
|
#define DU_TAG_USAGE L"Usage"
|
|
#define DU_TAG_OS L"OS"
|
|
#define DU_TAG_OSVERSION L"OSVersion"
|
|
#define DU_TAG_NAMESPACE L"NameSpace"
|
|
#define DU_TAG_DELETEONINSTALL L"DeleteOnInstall"
|
|
|
|
#define DU_ATTRIB_NAME L"NAME"
|
|
#define DU_ATTRIB_FILENAME L"FILENAME"
|
|
#define DU_ATTRIB_VALUE L"VALUE"
|
|
#define DU_ATTRIB_VERSION L"VERSION"
|
|
#define DU_ATTRIB_STYLE L"STYLE"
|
|
#define DU_ATTRIB_SIZE L"SIZE"
|
|
#define DU_ATTRIB_PRECACHE L"PRECACHE"
|
|
#define DU_ATTRIB_AUTOINSTALL L"AUTOINSTALL"
|
|
#define DU_ATTRIB_EMAIL L"EMAIL"
|
|
#define DU_ATTRIB_HREF L"HREF"
|
|
#define DU_ATTRIB_ACTION L"ACTION"
|
|
#define DU_ATTRIB_CLSID L"CLASSID"
|
|
#define DU_ATTRIB_DL_GROUP L"GROUP"
|
|
#define DU_ATTRIB_RANDOM L"RANDOM"
|
|
|
|
#define DU_STYLE_MSICD "MSICD"
|
|
#define DU_STYLE_ACTIVE_SETUP "ActiveSetup"
|
|
#define DU_STYLE_MSINSTALL "MSInstall.SoftDist"
|
|
#define DU_STYLE_LOGO3 "MSAppLogo5"
|
|
|
|
#define DU_TAG_SYSTEM L"System"
|
|
|
|
// Used by JAVA
|
|
#define DU_TAG_NEEDSTRUSTEDSOURCE L"NeedsTrustedSource"
|
|
|
|
#define CHANNEL_ATTRIB_BASE L"BASE"
|
|
|
|
#define MAX_EXPIRE_DAYS 3650
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "fdi.h"
|
|
|
|
#ifndef DEB_CODEDL
|
|
#define DEB_CODEDL 1
|
|
#endif
|
|
|
|
// JIT Window data
|
|
|
|
#define JIT_DIALOG_CLASS_NAME "Internet Explorer_TridentDlgFrame"
|
|
#define JIT_DIALOG_CAPTION "Internet Explorer Install on Demand"
|
|
|
|
// return value from the JIT setup page.
|
|
#define JITPAGE_RETVAL_SUCCESS 0x0 // successfully installed
|
|
#define JITPAGE_RETVAL_CANCELLED 0x1 // was cancelled by user
|
|
#define JITPAGE_RETVAL_DONTASK_THISWINDOW 0x2 // don;t ask again in this
|
|
// window
|
|
#define JITPAGE_RETVAL_DONTASK_EVER 0x3 // don't ask ever. user
|
|
// goes to addon page to
|
|
// install
|
|
#define JITPAGE_RETVAL_NEED_REBOOT ERROR_SUCCESS_REBOOT_REQUIRED
|
|
|
|
// FaultInIEFeature flags
|
|
// urlmon.idl flag definition
|
|
// internal flags are here
|
|
|
|
#define FIEF_FLAG_CHECK_CIFVERSION 0x100 // checks if requested version
|
|
// can be installed by JIT
|
|
|
|
#define REGSTR_PATH_INFODEL_REST "Software\\Policies\\Microsoft\\Internet Explorer\\Infodelivery\\Restrictions"
|
|
#define REGVAL_JIT_REST "NoJITSetup"
|
|
#define REGKEY_WEBJITURLS "Software\\Microsoft\\Active Setup\\WebJITURLS"
|
|
#define REGVAL_WEBJIT_REST "NoWebJITSetup"
|
|
#define REGVAL_UI_REST "NoWinVerifyTrustUI"
|
|
|
|
// registry paths for ModuleUsage
|
|
#define REGSTR_PATH_SHAREDDLLS "Software\\Microsoft\\Windows\\CurrentVersion\\SharedDlls"
|
|
|
|
#define REGSTR_PATH_MODULE_USAGE "Software\\Microsoft\\Windows\\CurrentVersion\\ModuleUsage"
|
|
|
|
#define REGSTR_PATH_CODE_STORE "Software\\Microsoft\\Code Store Database"
|
|
#define REGSTR_PATH_DIST_UNITS "Software\\Microsoft\\Code Store Database\\Distribution Units"
|
|
#define REGSTR_PATH_JAVA_PKGS "Software\\Microsoft\\Code Store Database\\Java Packages"
|
|
|
|
#define REGSTR_PATH_IE_SETTINGS "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"
|
|
#define REGSTR_PATH_IE_MAIN "Software\\Microsoft\\Internet Explorer\\Main"
|
|
|
|
#define REGSTR_PATH_LOGO3_SETTINGS "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
|
|
#define REGVAL_LOGO3_MAJORVERSION "VersionMajor"
|
|
#define REGVAL_LOGO3_MINORVERSION "VersionMinor"
|
|
#define REGSTR_LOGO3_ADVERTISED_VERSION "AdvertisedVersion"
|
|
#define REGKEY_LOGO3_AVAILABLE_VERSION "AvailableVersion"
|
|
|
|
#define REGSTR_PATH_NT5_LOCKDOWN_TEST "Software\\Microsoft\\Code Store Database\\NT5LockDownTest"
|
|
#define REGVAL_USE_COINSTALL "UseCoInstall"
|
|
|
|
// If you modify this then make appropriate entries in urlmon\dll\selfreg.inx
|
|
// to clean this out on urlmon dlluninstall
|
|
// this key will be renamed before ship of each major release
|
|
// so we won't remember the rejected features in PP1 and not prompt for final
|
|
// release
|
|
|
|
#define REGKEY_DECLINED_COMPONENTS "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Declined Components IE5"
|
|
|
|
#define REGKEY_DECLINED_IOD "Software\\Microsoft\\Active Setup\\Declined Install On Demand IEv5"
|
|
|
|
#define REGKEY_ACTIVESETUP_COMPONENTS "Software\\Microsoft\\Active Setup\\Installed Components"
|
|
#define REGKEY_ACTIVESETUP "Software\\Microsoft\\Active Setup"
|
|
#define REGKEY_ACTIVESETUP_CLSIDFEATURE "Software\\Microsoft\\Active Setup\\ClsidFeature"
|
|
#define REGKEY_ACTIVESETUP_MIMEFEATURE "Software\\Microsoft\\Active Setup\\MimeFeature"
|
|
#define REGKEY_ACTIVESETUP_FEATURECOMPID "Software\\Microsoft\\Active Setup\\FeatureComponentID"
|
|
#define REGVAL_VERSION_AVAILABLE "Version available"
|
|
#define REGVAL_VERSION_ADVERTISED "Version advertised"
|
|
#define REGVAL_ABSTRACT_AVAILABLE "Abstract"
|
|
#define REGVAL_TITLE_AVAILABLE "Title available"
|
|
#define REGVAL_HREF_AVAILABLE "HREF available"
|
|
#define REGVAL_FIRST_HOME_PAGE "First Home Page"
|
|
#define REGKEY_MSICD_ADVERTISED_VERSION "AdvertisedVersion"
|
|
#define REGVAL_ADSTATE "AdState"
|
|
|
|
#define DISTUNIT_NAME_IE4 "{89820200-ECBD-11cf-8B85-00AA005B4383}"
|
|
|
|
|
|
// Code Download Setup Flags
|
|
// DWORD g_dwCodeDownloadSetupFlags = 0;
|
|
typedef enum {
|
|
CDSF_INIT,
|
|
CDSF_USE_SETUPAPI
|
|
} CodeDownloadSetupFlags;
|
|
|
|
// buffer size for downloads in CBSC::m_cbuffer
|
|
#define BUFFERMAX 2048
|
|
|
|
// File Name List
|
|
//
|
|
// used as pFilesToExtract to track files in the CAB we need extracted
|
|
//
|
|
// or a pFileList in PSESSION
|
|
//
|
|
// We keep track of all files that are in a cabinet
|
|
// keeping their names in a list and when the download
|
|
// is complete we use this list to delete temp files
|
|
|
|
struct sFNAME {
|
|
LPSTR pszFilename;
|
|
struct sFNAME *pNextName;
|
|
DWORD status; /* out */
|
|
};
|
|
|
|
typedef struct sFNAME FNAME;
|
|
typedef FNAME *PFNAME;
|
|
|
|
// SFNAME.status: success is 0 or non-zero error code in extraction
|
|
#define SFNAME_INIT 1
|
|
#define SFNAME_EXTRACTED 0
|
|
|
|
// FILE extentions we know about
|
|
typedef enum {
|
|
FILEXTN_NONE,
|
|
FILEXTN_UNKNOWN,
|
|
FILEXTN_CAB,
|
|
FILEXTN_DLL,
|
|
FILEXTN_OCX,
|
|
FILEXTN_INF,
|
|
FILEXTN_EXE,
|
|
FILEXTN_OSD,
|
|
FILEXTN_CAT
|
|
} FILEXTN;
|
|
|
|
|
|
//
|
|
// Master State Information for File Extraction: used by extract.c
|
|
//
|
|
|
|
typedef struct {
|
|
UINT cbCabSize;
|
|
ERF erf;
|
|
PFNAME pFileList; // List of Files in CAB
|
|
UINT cFiles;
|
|
DWORD flags; // flags: see below for list
|
|
char achLocation[MAX_PATH]; // Dest Dir
|
|
char achFile[MAX_PATH]; // Current File
|
|
char achCabPath[MAX_PATH]; // Current Path to cabs
|
|
PFNAME pFilesToExtract; // files to extract;null=enumerate only
|
|
|
|
} SESSION, *PSESSION;
|
|
|
|
typedef enum {
|
|
SESSION_FLAG_NONE = 0x0,
|
|
SESSION_FLAG_ENUMERATE = 0x1,
|
|
SESSION_FLAG_EXTRACT_ALL = 0x2,
|
|
SESSION_FLAG_EXTRACTED_ALL = 0x4
|
|
} SESSION_FLAGS;
|
|
|
|
typedef struct CodeDownloadDataTag {
|
|
LPCWSTR szDistUnit; // Distribution unit to look for
|
|
LPCWSTR szClassString; // clsid (or class string) of object desired
|
|
LPCWSTR szURL; // codebase to download
|
|
LPCWSTR szMimeType; // mime type (com translate -> clsid)
|
|
LPCWSTR szExtension; // extension (com translate -> clsid)
|
|
LPCWSTR szDll; // dll to load object from after download (for zero impact)
|
|
DWORD dwFileVersionMS; // file version
|
|
DWORD dwFileVersionLS;
|
|
DWORD dwFlags; // flags
|
|
} CodeDownloadData;
|
|
|
|
#define chPATH_SEP1 '\\'
|
|
#define chPATH_SEP2 '/'
|
|
#define chDRIVE_SEP ':'
|
|
|
|
// size of [Add.Code] section in INF in bytes
|
|
#define MAX_INF_SECTIONS_SIZE 1024
|
|
|
|
// from extract.c
|
|
HRESULT Extract(PSESSION psess, LPCSTR lpCabName);
|
|
HRESULT ExtractFromCabinet(PSESSION ps, LPCSTR lpCabFileName);
|
|
VOID DeleteExtractedFiles(PSESSION psess);
|
|
BOOL catDirAndFile(
|
|
char *pszResult,
|
|
int cbResult,
|
|
char *pszDir,
|
|
char *pszFile);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#define CHECK_ERROR_EXIT(cond, iResID) if (!(cond)) { \
|
|
if (iResID) \
|
|
CodeDownloadDebugOut(DEB_CODEDL, TRUE, iResID); \
|
|
goto Exit;}
|
|
|
|
// Download states that a CDownload passes thru from obj creation to done.
|
|
typedef enum {
|
|
DLSTATE_INIT, // obj constructed
|
|
DLSTATE_BINDING, // download in progress
|
|
DLSTATE_DOWNLOADED, // at begining of OnStopBinding
|
|
DLSTATE_EXTRACTING, // begin CAB extraction (where applicable)
|
|
DLSTATE_INF_PROCESSING, // begin ProcessInf (where applicable)
|
|
DLSTATE_READY_TO_SETUP, // end of OnStopBinding
|
|
DLSTATE_SETUP, // Start DoSetup
|
|
DLSTATE_DONE, // all done, ready to free obj,
|
|
// delete temp files
|
|
DLSTATE_ABORT // aborted this download
|
|
} DLSTATE;
|
|
|
|
// INSTALL_STATE used to give BINDSTATUS_INSTALLING_COMPONENTS OnProgress
|
|
// during setup phase
|
|
// given as INSTALL_COPY of INSTALL_PHASES, szStatusText pointing to filename
|
|
|
|
typedef enum {
|
|
INSTALL_INIT = 0,
|
|
INSTALL_VERIFY = 1,
|
|
INSTALL_COPY = 2,
|
|
INSTALL_REGISTER =3,
|
|
INSTALL_PHASES = 4
|
|
} INSTALL_STATE;
|
|
|
|
#define INSTALL_DONE INSTALL_PHASES
|
|
|
|
|
|
// directions to CSetup on dest dir for file if no prev version exists
|
|
typedef enum {
|
|
|
|
LDID_OCXCACHE=0, // ocxcache dir, now = windows\ocxcache
|
|
LDID_WIN=10, // INF convetion to mean windows dir
|
|
LDID_SYS=11 // INF convetion to mean sysdir
|
|
|
|
} DESTINATION_DIR ;
|
|
|
|
|
|
// Software distribution styles
|
|
typedef enum {
|
|
STYLE_UNKNOWN = -1, // Unknown otherwise.
|
|
STYLE_MSICD = 1,
|
|
STYLE_ACTIVE_SETUP,
|
|
STYLE_LOGO3,
|
|
STYLE_MSINSTALL, // Darwin
|
|
STYLE_OTHER // Provides own ISoftDistExt interface for access
|
|
};
|
|
|
|
#ifdef __cplusplus // make classes invisible to 'C'
|
|
|
|
#include "langcode.h"
|
|
|
|
// <Config> tag processor. Shared by Code Download and CSoftDist.
|
|
HRESULT ProcessImplementation(IXMLElement *pConfig,
|
|
CList<CCodeBaseHold *, CCodeBaseHold *> *pcbhList,
|
|
LCID lcidOverride,
|
|
#ifdef WX86
|
|
CMultiArch *MultiArch,
|
|
#endif
|
|
LPWSTR szBaseURL = NULL);
|
|
HRESULT ProcessCodeBaseList(IXMLElement *pCodeBase,
|
|
CList<CCodeBaseHold *, CCodeBaseHold *> *pcbhList,
|
|
LPWSTR szBaseURL = NULL);
|
|
|
|
// %%Classes: ----------------------------------------------------------------
|
|
|
|
/*
|
|
* class descriptions
|
|
*
|
|
* CCodeDownload (main class tracking as a whole)
|
|
* It has the client's BSC and creates a CClBinding for client.
|
|
*
|
|
* CClBinding (For client's IBinding for code download)
|
|
*
|
|
* CDownload (tracks individual downloads) implements a
|
|
*
|
|
* CBindStatusCallback (BSC)
|
|
*
|
|
* Csetup obj: zero or more associated with every CDownload obj
|
|
* Some CDownload's may have no CSetup (eg. INF file)
|
|
*
|
|
*
|
|
*
|
|
*
|
|
* We do our code download in 2 stages.
|
|
* 1) download stage
|
|
* 2) setup and registeration stage
|
|
*
|
|
* CCodeDownload is the main class for codedownload.
|
|
* AsyncGetClassBits() the entry into the Code downloader creates this obj
|
|
* for the given CODE, CLSID, FileVersion, BSC (from BindCtx)
|
|
* we do not check to see if a code download is already in progress
|
|
* in the system at a given moment. Nor we do we keep track of individual
|
|
* downloads and possible clashes between various silmultaneous code
|
|
* downloads system wide. We leave it to URL moniker (above us) to ensure
|
|
* that duplicate calls are not made into AsynGetClassBits. The second
|
|
* problem of different code downloads trying to bring down a common
|
|
* dependent DLL is POSTPONED to version 2 implementation.
|
|
*
|
|
* The CodeDownload obj once created is asked to perform its function
|
|
* thru CCodeDownload::DoCodeDownload().
|
|
* This triggers creation of the first CDownload object for the CODE url
|
|
* if a local check for CLSID,FileVersion returns update_needed.
|
|
* (note : it is interesting to note here that if a control needs to just
|
|
* update a dependent DLL file it still needs to update the FileVersion
|
|
* of the primary control file (with CLSID implementation) for triggering
|
|
* any download at all!
|
|
*
|
|
* Once DoCodeDownload determines that an update is in order it creates
|
|
* a CClBinding for its client to call client BSC::OnstartBinding with.
|
|
*
|
|
* It then adds this CDownload obj to its list of downloads.
|
|
*
|
|
* If the m_url is a CAB or INF we need to download it before we know
|
|
* what we need to do next. Otherwise we create a CSetup obj for the
|
|
* download and add it to CDownload's list of pending Setup processing for
|
|
* stage 2 (setup and registeration). CSetup details later.
|
|
*
|
|
* CDownload is the basic download obj. It's action entry point is DoDownload
|
|
* Here it creates a URL moniker for the given m_url and a bind ctx to go
|
|
* with it and then calls pmk->BindToStorage to get the bits. Note how we
|
|
* use URL mon's services to get the bits even as URLmon is our client for
|
|
* the Code Download. We are its client for individual downloads. CDownload
|
|
* has a BSC implementation to track progress and completion. This BSC is
|
|
* where the magic of taking us from one state to next occurs.
|
|
*
|
|
* BSC::OnProgress
|
|
* Here we get the master CodeDownload obj to collate progress and report
|
|
* cumulative code download progress to client BSC::OnProgress.
|
|
*
|
|
* BSC::OnDataAvailable
|
|
* At the last notification we get the filename URLmon has downloaded the
|
|
* m_url data to and rename it to a file in the temp dir.
|
|
*
|
|
* BSC:: OnStopBinding
|
|
* we get here when we have fully downloaded 'this'. this is the place
|
|
* to call into WinVerifyTrust api if appropriate
|
|
* This triggers a change state in our state machine. Depending on the
|
|
* obj we have downloaded (a CAB or INF or DLL/OCX/EXE) we:
|
|
*
|
|
* OCX:
|
|
* Csetup for this download is usually previously created
|
|
* mark this download as done and
|
|
* call into main CodeDownload::CompleteOne (state analyser)
|
|
*
|
|
* CAB:
|
|
* if we don't have an INF already we look for one in the CAB
|
|
* if INF in CAB
|
|
* process INF (may trigger further extractions/downloads/Csetup)
|
|
* else
|
|
* look for primary OCX in CAB and create CSetup or it.
|
|
*
|
|
* INF:
|
|
* Process INF
|
|
*
|
|
* CCodeDownload::CompleteOne is called whenever a CDownload obj completes
|
|
* its download and initiates further downloads if necessary (eg. ProcessInf)
|
|
* It does nothing until all pending downloads are complete. Until then it
|
|
* just returns and we unwind back to BSC::OnStopBinding
|
|
*
|
|
* When all downloads completed, we then start processingall the Csetups
|
|
* We do this code download in two stages to
|
|
* keep capability to back out of entire code download for as late as we can
|
|
* until the setup stage calling CClBinding::Abort with IBinding returned by
|
|
* code downloader in client's BSC::OnStartBinding will cleanly abort and
|
|
* restore initial state.
|
|
* We don't honor Abort once in setup stage.
|
|
*
|
|
* To keep this stage as clean and failsafe as we can we check for
|
|
* disk space in the OCX cache as well as check for IN USE OCXes that we
|
|
* plan on updating. We abort on either of these two conditions.
|
|
*
|
|
* CCodeDownload::CompleteOne than proceeds to walk thru all its download objs
|
|
* calling DoSetup which in turn causes CSetup::DoSetup() to get invoked
|
|
* for every CSetup.
|
|
*
|
|
* In the guts of Csetup we move the temp OCX file to the dest dir ( usually
|
|
* OCXCACHE dir unless upgrading over previous version), and we call
|
|
* register OCX (if version info suggests so)
|
|
*
|
|
* When done with the setup stage CompleteOne calls client's BSC::OnStopBinding
|
|
* and then frees all memory and clens up temp files.
|
|
*
|
|
*/
|
|
|
|
class CLocalComponentInfo {
|
|
public:
|
|
|
|
CLocalComponentInfo();
|
|
~CLocalComponentInfo();
|
|
HRESULT MakeDestDir();
|
|
|
|
BOOL IsPresent() { return (dwLocFVMS | dwLocFVLS); }
|
|
BOOL IsLastModifiedTimeAvailable() {
|
|
return ( ftLastModified.dwHighDateTime | ftLastModified.dwLowDateTime);
|
|
}
|
|
FILETIME * GetLastModifiedTime() {
|
|
return IsLastModifiedTimeAvailable()?&ftLastModified:NULL;
|
|
}
|
|
|
|
LPSTR GetLocalVersionEtag() { return pbEtag;}
|
|
|
|
LCID GetLocalVersionLCID() { return lcid; }
|
|
|
|
// data members
|
|
|
|
char szExistingFileName[MAX_PATH];
|
|
LPSTR pBaseExistingFileName;
|
|
LPSTR lpDestDir;
|
|
DWORD dwLocFVMS;
|
|
DWORD dwLocFVLS;
|
|
FILETIME ftLastModified;
|
|
LPSTR pbEtag;
|
|
LCID lcid;
|
|
BOOL bForceLangGetLatest;
|
|
DWORD dwAvailMS;
|
|
DWORD dwAvailLS;
|
|
};
|
|
|
|
// CModuleUsage: created for every module added to ModuleUsage
|
|
// is walked thru and run after all setups are complete in COmpleteAll
|
|
// can also be used to optionally rollback a setup
|
|
|
|
|
|
class CModuleUsage {
|
|
public:
|
|
|
|
// constructor
|
|
CModuleUsage(LPCSTR lpFileName, DWORD dwFlags, HRESULT *phr);
|
|
~CModuleUsage();
|
|
|
|
HRESULT Update(LPCSTR szClientName);
|
|
LPCSTR GetFileName() {return m_szFileName;}
|
|
|
|
// data members
|
|
|
|
LPSTR m_szFileName;
|
|
DWORD m_dwFlags;
|
|
};
|
|
|
|
// CSetup: created for every setup item
|
|
// each CDownload has zero or more of these linked into a list
|
|
|
|
typedef enum {
|
|
|
|
// the default behaviour for
|
|
// registering a server is to do
|
|
// so only when the version rsrc
|
|
// has the string "OleSelfregister"
|
|
// the user can override this
|
|
// behaviour with setting in .INF
|
|
// registerserver=yes/no
|
|
|
|
CST_FLAG_REGISTERSERVER_OVERRIDE=1, // when set user has overriden
|
|
CST_FLAG_REGISTERSERVER=2 // when set along with above
|
|
// means user wants us to register
|
|
// server
|
|
|
|
} CST_FLAGS;
|
|
|
|
class CDownload;
|
|
|
|
typedef enum {
|
|
CJS_FLAG_INIT=0,
|
|
CJS_FLAG_NOSETUP=1, // don't setup just mark that this
|
|
// java package is used by this dist
|
|
// unit.
|
|
CJS_FLAG_SYSTEM=2, // system class
|
|
CJS_FLAG_NEEDSTRUSTEDSOURCE=4, // need trusted source
|
|
};
|
|
|
|
class CJavaSetup {
|
|
public:
|
|
|
|
CJavaSetup(
|
|
CDownload *pdl,
|
|
LPCWSTR szPackageName,
|
|
LPCWSTR szNameSpace,
|
|
IXMLElement *pPackage,
|
|
DWORD dwVersionMS,
|
|
DWORD dwVersionLS,
|
|
DWORD flags,
|
|
HRESULT *phr);
|
|
|
|
~CJavaSetup();
|
|
|
|
HRESULT DoSetup();
|
|
|
|
INSTALL_STATE GetState() const { return m_state;}
|
|
VOID SetState(INSTALL_STATE state) { m_state = state;}
|
|
|
|
LPCWSTR GetPackageName() { return m_szPackageName; }
|
|
LPCWSTR GetNameSpace() { return m_szNameSpace; }
|
|
void GetPackageVersion(DWORD &dwVersionMS, DWORD &dwVersionLS) {
|
|
dwVersionMS = m_dwVersionMS;
|
|
dwVersionLS = m_dwVersionLS;
|
|
}
|
|
DWORD GetPackageFlags() { return m_flags; }
|
|
IXMLElement *GetPackageXMLElement() { return m_pPackage; }
|
|
|
|
private:
|
|
|
|
INSTALL_STATE m_state; // state of install operation
|
|
CDownload* m_pdl;
|
|
LPWSTR m_szPackageName;
|
|
LPWSTR m_szNameSpace;
|
|
IXMLElement * m_pPackage;
|
|
DWORD m_dwVersionMS;
|
|
DWORD m_dwVersionLS;
|
|
DWORD m_flags;
|
|
};
|
|
|
|
class CSetup {
|
|
|
|
public:
|
|
|
|
HRESULT DoSetup(CCodeDownload *pcdl, CDownload *pdl);
|
|
|
|
LPCSTR GetSrcFileName() const {return m_pSrcFileName;}
|
|
|
|
HRESULT SetSrcFileName(LPCSTR pSrcFileName);
|
|
|
|
FILEXTN GetExtn() const {return m_extn;}
|
|
|
|
CSetup *GetNext() const { return m_pSetupnext;}
|
|
VOID SetNext(CSetup *pSetupnext) { m_pSetupnext = pSetupnext;}
|
|
|
|
INSTALL_STATE GetState() const { return m_state;}
|
|
VOID SetState(INSTALL_STATE state) { m_state = state;}
|
|
|
|
LPCSTR GetBaseFileName() const { return m_pBaseFileName; }
|
|
|
|
// constructor
|
|
CSetup(LPCSTR pSrcFileName, LPCSTR pBaseFileName, FILEXTN extn, LPCSTR pDestDir, HRESULT *phr, DESTINATION_DIR dest = LDID_OCXCACHE);
|
|
~CSetup();
|
|
|
|
HRESULT GetDestDir(CCodeDownload *pcdl, LPSTR szDestDir, int iLen);
|
|
|
|
HRESULT CheckForNameCollision(CCodeDownload *pcdl, LPCSTR szCacheDir);
|
|
|
|
HRESULT InstallFile(
|
|
CCodeDownload *pcdl,
|
|
LPSTR szDestDir,
|
|
int iLen,
|
|
LPWSTR szStatusText,
|
|
LPUINT pcbStatusText);
|
|
|
|
VOID SetCopyFlags(DWORD dwcf) {
|
|
m_advcopyflags = dwcf;
|
|
}
|
|
|
|
VOID SetUserOverrideRegisterServer(BOOL fRegister) {
|
|
m_flags |= CST_FLAG_REGISTERSERVER_OVERRIDE;
|
|
if (fRegister) {
|
|
m_flags |= CST_FLAG_REGISTERSERVER;
|
|
}
|
|
}
|
|
|
|
BOOL UserOverrideRegisterServer() {
|
|
return (m_flags & CST_FLAG_REGISTERSERVER_OVERRIDE);
|
|
}
|
|
|
|
BOOL WantsRegisterServer() {
|
|
return (m_flags & CST_FLAG_REGISTERSERVER);
|
|
}
|
|
|
|
void SetExactVersion(BOOL bFlag) {m_bExactVersion = bFlag;}
|
|
|
|
private:
|
|
|
|
CSetup* m_pSetupnext;
|
|
|
|
LPSTR m_pSrcFileName; // fully qualified src file name
|
|
LPSTR m_pBaseFileName; // base filename
|
|
FILEXTN m_extn;
|
|
|
|
LPCSTR m_pExistDir; // dest dir for setting up obj
|
|
// if null default to ocxcache dir
|
|
|
|
INSTALL_STATE m_state; // state of install operation
|
|
|
|
DESTINATION_DIR m_dest;
|
|
|
|
DWORD m_flags; // overrides for register server
|
|
DWORD m_advcopyflags; // flags for AdvInstallFile
|
|
BOOL m_bExactVersion;
|
|
};
|
|
|
|
// CClBinding to pass to client of CodeDownload in client's BSC::OnStartBinding
|
|
|
|
class CClBinding : public IBinding {
|
|
|
|
public:
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid,void ** ppv);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IBinding methods
|
|
STDMETHOD(Abort)( void);
|
|
STDMETHOD(Suspend)( void);
|
|
STDMETHOD(Resume)( void);
|
|
STDMETHOD(SetPriority)(LONG nPriority);
|
|
STDMETHOD(GetPriority)(LONG *pnPriority);
|
|
STDMETHOD(GetBindResult)(CLSID *pclsidProtocol, DWORD *pdwResult, LPWSTR *pszResult,DWORD *pdwReserved);
|
|
|
|
|
|
CClBinding::CClBinding(
|
|
CCodeDownload *pcdl,
|
|
IBindStatusCallback *pAssClientBSC,
|
|
IBindCtx *pAssClientBC,
|
|
REFCLSID rclsid,
|
|
DWORD dwClsContext,
|
|
LPVOID pvReserved,
|
|
REFIID riid,
|
|
IInternetHostSecurityManager* m_pHostSecurityManager);
|
|
|
|
~CClBinding();
|
|
|
|
HRESULT InstantiateObjectAndReport(CCodeDownload *pcdl);
|
|
|
|
REFCLSID GetClsid() const { return m_clsid;}
|
|
|
|
HRESULT ReleaseClient();
|
|
|
|
DWORD GetState() const { return m_dwState;}
|
|
VOID SetState(DWORD dwState) { m_dwState = dwState;}
|
|
|
|
IBindStatusCallback* GetAssBSC() {return m_pAssClientBSC;}
|
|
|
|
IBindCtx* GetAssBC() {return m_pAssClientBC;}
|
|
|
|
ICodeInstall* GetICodeInstall(); // side-effect: sets m_pCodeInstall!
|
|
IWindowForBindingUI* GetIWindowForBindingUI(); // side-effect: sets m_pWindowForBindingUI!
|
|
|
|
IBindHost* GetIBindHost(); // side-effect: sets m_pBindHost!
|
|
|
|
IInternetHostSecurityManager* GetHostSecurityManager();
|
|
|
|
HWND GetHWND(REFGUID rguidReason = IID_ICodeInstall);
|
|
|
|
HRESULT SetClassString(LPCWSTR pszClassString);
|
|
const LPWSTR GetClassString();
|
|
|
|
private:
|
|
|
|
CLSID m_clsid;
|
|
// foll: for CoGetClassObject
|
|
DWORD m_dwClsContext; // CLSCTX flags
|
|
LPVOID m_pvReserved; // Must be NULL
|
|
REFIID m_riid; // Usually IID_IClassFactory
|
|
|
|
|
|
DWORD m_cRef;
|
|
LONG m_nPriority; // priority of this binding
|
|
DWORD m_dwState; // state of operation
|
|
CCodeDownload* m_pcdl;
|
|
IBindStatusCallback* m_pAssClientBSC; // associated Client BSC
|
|
IBindCtx* m_pAssClientBC; // associated client bind ctx
|
|
|
|
|
|
IBindHost* m_pBindHost; // IBindHost
|
|
|
|
IWindowForBindingUI* m_pWindowForBindingUI; // IWindowForBindingUI
|
|
// passed in by client
|
|
// to pass in hwnd for
|
|
// WinVerifyTrust as well
|
|
|
|
IInternetHostSecurityManager* m_pHostSecurityManager;
|
|
|
|
ICodeInstall* m_pCodeInstall; // ICodeInstall
|
|
// passed in by client
|
|
// to pass in hwnd for
|
|
// WinVerifyTrust as well
|
|
// as handle module update
|
|
// contingencies like
|
|
// out of disk space and
|
|
// permission to update
|
|
// existing file with newer ver
|
|
|
|
HWND m_hWnd; // client hwnd obtained thru
|
|
// ICodeInstall
|
|
// ::NeedVerificationUI
|
|
// safe to cache this?
|
|
LPWSTR m_wszClassString;
|
|
};
|
|
|
|
|
|
// CodeDownload states
|
|
typedef enum
|
|
{
|
|
CDL_NoOperation = 0, // operation did not start yet
|
|
CDL_Downloading, // downloading in progress
|
|
CDL_Suspend, // operation suspended
|
|
CDL_Aborted, // operation aborted
|
|
CDL_ReadyToSetup, // ready to setup
|
|
CDL_Setup, // setup in progress
|
|
CDL_SetupDone, // setup done
|
|
CDL_Completed // done, and complete signalled CompleteAll
|
|
} CDL_STATE;
|
|
|
|
// values for CCodeDownload::m_flags
|
|
// these will be defined in objbase.h. For now make sure they are defined so we don't break the build
|
|
#ifndef CD_FLAGS_DEFINED
|
|
#define CD_FLAGS_DEFINED
|
|
typedef enum {
|
|
CD_FLAGS_INIT = 0x0,
|
|
CD_FLAGS_FORCE_DOWNLOAD = 0x1,
|
|
CD_FLAGS_PEEK_STATE = 0x2,
|
|
CD_FLAGS_NEED_CLASSFACTORY = 0x4,
|
|
CD_FLAGS_PARANOID_VERSION_CHECK = 0x8,
|
|
CD_FLAGS_SKIP_DECLINED_LIST_CHECK = 0x20,
|
|
CD_FLAGS_USE_CODEBASE_ONLY = 0x80, // Set by OLE32 Class Store
|
|
CD_FLAGS_HINT_JAVA = 0x100, // to turn off advance
|
|
// disabling of code download
|
|
// if ActiveX Signed+Unsigned
|
|
// is off unless this flag is
|
|
// passed any distunit that looks
|
|
// like a clsid will not code
|
|
// download if ActiveX is off
|
|
CD_FLAGS_HINT_ACTIVEX = 0x200,
|
|
CD_FLAGS_FORCE_INTERNET_DOWNLOAD = 0x400, // For OLE32 CoInstall
|
|
|
|
// below are internal flags
|
|
|
|
CD_FLAGS_WAITING_FOR_EXE = 0x40,
|
|
CD_FLAGS_SILENTOPERATION = 0x800,
|
|
CD_FLAGS_NEED_REBOOT = 0x1000,
|
|
CD_FLAGS_BITS_IN_CACHE = 0x2000,
|
|
CD_FLAGS_NEW_CONTEXT_MONIKER = 0x4000,
|
|
CD_FLAGS_FAKE_SUCCESS = 0x8000,
|
|
CD_FLAGS_DELETE_EXE = 0x10000,
|
|
CD_FLAGS_UNSAFE_ABORT = 0x20000,
|
|
CD_FLAGS_USER_CANCELLED = 0x40000,
|
|
CD_FLAGS_HAVE_INF = 0x80000,
|
|
CD_FLAGS_ONSTACK = 0x100000,
|
|
CD_FLAGS_USED_CODE_URL = 0x200000,
|
|
CD_FLAGS_EXACT_VERSION = 0x400000,
|
|
CD_FLAGS_TRUST_SOME_FAILED = 0x800000
|
|
|
|
|
|
} CD_FLAGS;
|
|
|
|
#endif // CD_FLAGS_DEFINED
|
|
|
|
#define CD_FLAGS_EXTERNAL_MASK (CD_FLAGS_FORCE_DOWNLOAD| \
|
|
CD_FLAGS_PEEK_STATE| \
|
|
CD_FLAGS_NEED_CLASSFACTORY| \
|
|
CD_FLAGS_PARANOID_VERSION_CHECK| \
|
|
CD_FLAGS_SKIP_DECLINED_LIST_CHECK| \
|
|
CD_FLAGS_USE_CODEBASE_ONLY| \
|
|
CD_FLAGS_HINT_JAVA| \
|
|
CD_FLAGS_HINT_ACTIVEX| \
|
|
CD_FLAGS_FORCE_INTERNET_DOWNLOAD)
|
|
|
|
class CDownload;
|
|
class DebugLogElement;
|
|
class CDLDebugLog;
|
|
|
|
// main class
|
|
class CCodeDownload {
|
|
|
|
public:
|
|
|
|
// constructor
|
|
CCodeDownload(
|
|
LPCWSTR szDistUnit,
|
|
LPCWSTR szURL,
|
|
LPCWSTR szType,
|
|
LPCWSTR szExt,
|
|
DWORD dwFileVersionMS,
|
|
DWORD dwFileVersionLS,
|
|
HRESULT *phr);
|
|
|
|
~CCodeDownload();
|
|
|
|
HRESULT DoCodeDownload(
|
|
CLocalComponentInfo *plci,
|
|
DWORD flags);
|
|
|
|
HRESULT CCodeDownload::CreateClientBinding(
|
|
CClBinding **ppClientBinding,
|
|
IBindCtx* pClientBC,
|
|
IBindStatusCallback* pClientbsc,
|
|
REFCLSID rclsid,
|
|
DWORD dwClsContext,
|
|
LPVOID pvReserved,
|
|
REFIID riid,
|
|
BOOL fAddHead,
|
|
IInternetHostSecurityManager *pHostSecurityManager);
|
|
|
|
int GetCountClientBindings() const {
|
|
return m_pClientbinding.GetCount();
|
|
}
|
|
|
|
CClBinding* GetClientBinding() const {
|
|
return m_pClientbinding.GetHead();
|
|
}
|
|
|
|
IBindStatusCallback* GetClientBSC() const {
|
|
return (GetClientBinding())->GetAssBSC();
|
|
}
|
|
|
|
IBindCtx* GetClientBC() const {
|
|
return (GetClientBinding())->GetAssBC();
|
|
}
|
|
|
|
REFCLSID GetClsid() const {
|
|
return (GetClientBinding())->GetClsid();
|
|
}
|
|
|
|
CDownload* GetDownloadHead() const {
|
|
return m_pDownloads.GetHead();
|
|
}
|
|
|
|
VOID AddDownloadToList(CDownload *pdl);
|
|
|
|
HRESULT FindDupCABInThread(IMoniker *pmk, CDownload **ppdlMatch);
|
|
HRESULT FindCABInDownloadList(LPCWSTR szURL, CDownload *pdlHint, CDownload **ppdlMatch);
|
|
|
|
VOID CompleteOne(CDownload *pdl, HRESULT hrOSB, HRESULT hrStatus, HRESULT hrResponseHdr, LPCWSTR szError);
|
|
|
|
VOID CompleteAll(HRESULT hr, LPCWSTR szError);
|
|
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
HRESULT ProcessHooks(CDownload *pdl);
|
|
HRESULT ProcessHookSection(LPCSTR lpCurHook, CDownload *pdl);
|
|
|
|
HRESULT GetSatelliteName( LPSTR lpCurCode, int iLen);
|
|
|
|
BOOL IsSectionInINF(LPCSTR lpCurCode);
|
|
|
|
HRESULT GetInfCodeLocation( LPCSTR lpCurCode, LPSTR szURL);
|
|
|
|
HRESULT GetInfSectionInfo(
|
|
LPSTR lpCurCode,
|
|
int iLen,
|
|
LPSTR szURL,
|
|
LPCLSID *plpClsid,
|
|
LPDWORD pdwFileVersionMS,
|
|
LPDWORD pdwFileVersionLS,
|
|
DESTINATION_DIR *pdest,
|
|
LPDWORD pdwRegisterServer,
|
|
LPDWORD pdwCopyFlags,
|
|
BOOL *pbDestDir
|
|
);
|
|
|
|
HRESULT SetupInf(const char *szInf, char *szInfBaseName,CDownload *pdl);
|
|
|
|
VOID ProcessInf(CDownload *pdl);
|
|
|
|
HRESULT ParseOSD(const char *szOSD, char *szOSDBaseName, CDownload *pdl);
|
|
|
|
HRESULT QueueModuleUsage( LPCSTR szFileName, LONG muFlags);
|
|
HRESULT UpdateModuleUsage();
|
|
|
|
HRESULT StartDownload(
|
|
LPSTR szCurCode,
|
|
CDownload *pdl,
|
|
LPSTR szURL,
|
|
DESTINATION_DIR dest,
|
|
LPSTR szDestDir,
|
|
DWORD dwRegisterServer,
|
|
DWORD dwCopyFlags,
|
|
CList <CCodeBaseHold *, CCodeBaseHold *> *pcbhList = NULL);
|
|
|
|
BOOL HaveManifest() {return (HaveInf() || GetOSD());}
|
|
|
|
BOOL NeedToReboot() const {return (m_flags & CD_FLAGS_NEED_REBOOT);}
|
|
VOID SetRebootRequired() {m_flags |= CD_FLAGS_NEED_REBOOT;}
|
|
|
|
BOOL IsSilentMode() const {return (m_flags & CD_FLAGS_SILENTOPERATION);}
|
|
VOID SetSilentMode() {m_flags |= CD_FLAGS_SILENTOPERATION;}
|
|
|
|
BOOL IsAllTrusted() const {return ((m_flags & CD_FLAGS_TRUST_SOME_FAILED) == 0);}
|
|
VOID SetTrustSomeFailed() {m_flags |= CD_FLAGS_TRUST_SOME_FAILED;}
|
|
|
|
BOOL ForceDownload() const {return (m_flags & CD_FLAGS_FORCE_DOWNLOAD);}
|
|
|
|
BOOL HaveInf() const {return (m_flags & CD_FLAGS_HAVE_INF);}
|
|
VOID SetHaveInf() {m_flags |= CD_FLAGS_HAVE_INF;}
|
|
|
|
BOOL UsedCodeURL() const {return (m_flags & CD_FLAGS_USED_CODE_URL);}
|
|
VOID SetUsedCodeURL() {m_flags |= CD_FLAGS_USED_CODE_URL;}
|
|
|
|
BOOL SafeToAbort() const {return ((m_flags & CD_FLAGS_UNSAFE_ABORT) == 0);}
|
|
VOID SetUnsafeToAbort() {m_flags |= CD_FLAGS_UNSAFE_ABORT;}
|
|
|
|
BOOL BitsInCache() const {return (m_flags & CD_FLAGS_BITS_IN_CACHE);}
|
|
VOID SetBitsInCache() {m_flags |= CD_FLAGS_BITS_IN_CACHE;}
|
|
|
|
BOOL FakeSuccess() const {return (m_flags & CD_FLAGS_FAKE_SUCCESS);}
|
|
VOID SetFakeSuccess() {m_flags |= CD_FLAGS_FAKE_SUCCESS;}
|
|
|
|
HRESULT HandleUnSafeAbort();
|
|
|
|
BOOL NeedObject() const {return (m_flags & CD_FLAGS_NEED_CLASSFACTORY);}
|
|
VOID SetNeedObject(DWORD fl) { m_flags |= (fl & CD_FLAGS_NEED_CLASSFACTORY);}
|
|
|
|
BOOL UseCodebaseOnly() const {return (m_flags & CD_FLAGS_USE_CODEBASE_ONLY);}
|
|
VOID SetUseCodebaseOnly(DWORD fl) { m_flags |= (fl & CD_FLAGS_USE_CODEBASE_ONLY);}
|
|
|
|
BOOL RelContextMk() {return (m_flags & CD_FLAGS_NEW_CONTEXT_MONIKER);}
|
|
VOID MarkNewContextMoniker() {m_flags |= CD_FLAGS_NEW_CONTEXT_MONIKER;}
|
|
VOID ResetNewContextMoniker() {m_flags &= ~CD_FLAGS_NEW_CONTEXT_MONIKER;}
|
|
|
|
BOOL WaitingForEXE() {return (m_flags & CD_FLAGS_WAITING_FOR_EXE);}
|
|
VOID SetNotWaitingForEXE() {m_flags &= ~CD_FLAGS_WAITING_FOR_EXE;}
|
|
|
|
BOOL UserCancelled() {return (m_flags & CD_FLAGS_USER_CANCELLED);}
|
|
VOID SetUserCancelled() {m_flags |= CD_FLAGS_USER_CANCELLED;}
|
|
|
|
BOOL IsOnStack() const {return (m_flags & CD_FLAGS_ONSTACK);}
|
|
BOOL SetOnStack() {
|
|
if (IsOnStack()) {
|
|
return FALSE;
|
|
} else {
|
|
m_flags |= CD_FLAGS_ONSTACK;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
VOID ResetOnStack() {m_flags &= ~CD_FLAGS_ONSTACK;}
|
|
|
|
BOOL SkipDeclinedListCheck() const {return (m_flags & CD_FLAGS_SKIP_DECLINED_LIST_CHECK);}
|
|
|
|
BOOL DeleteEXEWhenDone() {return (m_flags & CD_FLAGS_DELETE_EXE);}
|
|
VOID SetDeleteEXEWhenDone() {m_flags |= CD_FLAGS_DELETE_EXE;}
|
|
VOID ResetDeleteEXEWhenDone() {m_flags &= ~CD_FLAGS_DELETE_EXE;}
|
|
|
|
HRESULT SetWaitingForEXE(LPCSTR szStatusText, BOOL bDeleteEXEWhenDone);
|
|
VOID SetWaitingForEXEHandle(HANDLE hEXE) {m_pi.hProcess = hEXE;}
|
|
|
|
LPSTR GetDestDirHint() const { return m_plci->lpDestDir;}
|
|
BOOL LocalVersionPresent() const { return m_plci->IsPresent();}
|
|
FILETIME * GetLastModifiedTime() { return m_plci->GetLastModifiedTime();}
|
|
|
|
VOID InitLastModifiedFromDistUnit();
|
|
|
|
IMoniker* GetContextMoniker() const {return m_pmkContext;}
|
|
VOID SetContextMoniker(IMoniker* pmk) {m_pmkContext = pmk;}
|
|
|
|
ICodeInstall* GetICodeInstall() const {
|
|
return GetClientBinding()->GetICodeInstall();
|
|
}
|
|
|
|
LPCWSTR GetMainURL() const { return m_url;}
|
|
LPCWSTR GetMainDistUnit() const { return m_szDistUnit;}
|
|
LPCWSTR GetMainType() const { return m_szType;}
|
|
LPCWSTR GetMainExt() const { return m_szExt;}
|
|
|
|
LPCSTR GetCacheDir() const { return m_szCacheDir;}
|
|
HRESULT ResolveCacheDirNameConflicts();
|
|
|
|
void SetExactVersion(BOOL bExactVersion) { m_bExactVersion = bExactVersion;
|
|
if (m_bExactVersion) {
|
|
m_bUninstallOld = TRUE; // implied
|
|
}
|
|
}
|
|
|
|
VOID SetListCookie(LISTPOSITION pos) {m_ListCookie = pos;}
|
|
LISTPOSITION GetListCookie() const {return m_ListCookie;}
|
|
|
|
HRESULT AcquireSetupCookie();
|
|
HRESULT RelinquishSetupCookie();
|
|
|
|
HRESULT PiggybackDupRequest(
|
|
IBindStatusCallback *pDupClientBSC,
|
|
IBindCtx *pbc,
|
|
REFCLSID rclsid,
|
|
DWORD dwClsContext,
|
|
LPVOID pvReserved,
|
|
REFIID riid);
|
|
|
|
BOOL GenerateErrStrings(HRESULT hr, char **ppszErrMsg, WCHAR **ppwszError);
|
|
|
|
static HRESULT CCodeDownload::AnyCodeDownloadsInThread();
|
|
|
|
static HRESULT CCodeDownload::HasUserDeclined(
|
|
LPCWSTR szDistUnit,
|
|
LPCWSTR szType,
|
|
LPCWSTR szExt,
|
|
IBindStatusCallback *pClientBSC,
|
|
IInternetHostSecurityManager *pHostSecurityManager);
|
|
|
|
static HRESULT CCodeDownload::HandleDuplicateCodeDownloads(
|
|
LPCWSTR szURL,
|
|
LPCWSTR szType,
|
|
LPCWSTR szExt,
|
|
REFCLSID rclsid,
|
|
LPCWSTR szDistUnit,
|
|
DWORD dwClsContext,
|
|
LPVOID pvReserved,
|
|
REFIID riid,
|
|
IBindCtx* pbc,
|
|
IBindStatusCallback *pDupClientBSC,
|
|
DWORD dwFlags,
|
|
IInternetHostSecurityManager *pHostSecurityManager);
|
|
|
|
HRESULT CCodeDownload::SetUserDeclined();
|
|
|
|
HRESULT IsDuplicateHook(LPCSTR szHook);
|
|
HRESULT IsDuplicateJavaSetup( LPCWSTR szPackage);
|
|
|
|
HRESULT ProcessJavaManifest(IXMLElement *pJava, const char *szOSD, char *szOSDBaseName, CDownload *pdl);
|
|
HRESULT ProcessDependency(CDownload *pdl, IXMLElement *pDepend);
|
|
HRESULT ProcessNativeCode(CDownload *pdl, IXMLElement *pCode);
|
|
HRESULT ExtractInnerCAB(CDownload *pdl, LPSTR szCABFile);
|
|
HRESULT AddDistUnitList(LPWSTR szDistUnit);
|
|
|
|
VOID DoSetup();
|
|
|
|
HRESULT DealWithExistingFile(
|
|
LPSTR szExistingFile,
|
|
DWORD cbExistingFile,
|
|
LPSTR pBaseExistingName,
|
|
LPSTR *ppDestDir,
|
|
LPDWORD pdwLocFVMS,
|
|
LPDWORD pdwLocFVLS,
|
|
FILETIME *pftLastModified = NULL);
|
|
|
|
BOOL NeedLatestVersion() {
|
|
return (( m_dwFileVersionMS == -1) && (m_dwFileVersionLS == -1));
|
|
}
|
|
LPSTR GetEtag() { return m_pbEtag;}
|
|
VOID SetEtag(LPSTR szEtag) { m_pbEtag = szEtag;}
|
|
LPSTR GetLocalVersionEtag() { return m_plci->GetLocalVersionEtag();}
|
|
|
|
LPSTR GetLastMod() { return m_szLastMod[0]?m_szLastMod:NULL;}
|
|
VOID SetLastModifiedTime(LPCSTR szLastMod) {
|
|
lstrcpy(m_szLastMod, szLastMod);
|
|
}
|
|
|
|
HRESULT DelayRegisterOCX(LPCSTR pszSrcFileName, FILEXTN extn);
|
|
|
|
HRESULT InstallOCX(LPCSTR lpSrcFileName, FILEXTN extn, BOOL fLocalServer);
|
|
HRESULT RegisterPEDll( LPCSTR lpSrcFileName);
|
|
|
|
#ifdef WX86
|
|
HRESULT RegisterWx86Dll( LPCSTR lpSrcFileName);
|
|
CMultiArch *GetMultiArch() { return &m_MultiArch; }
|
|
#endif
|
|
|
|
// BUGBUG: put these three in a SearchPath class
|
|
HRESULT SetupCODEUrl(LPWSTR *ppDownloadURL, FILEXTN *pextn);
|
|
|
|
HRESULT GetNextComponent( LPSTR szList, LPSTR *ppCur);
|
|
|
|
HRESULT GetNextOnInternetSearchPath(
|
|
REFCLSID rclsid,
|
|
HGLOBAL *phPostData,
|
|
DWORD *pcbPostData,
|
|
LPWSTR szURL,
|
|
DWORD dwSize,
|
|
LPWSTR *ppDownloadURL,
|
|
FILEXTN *pextn);
|
|
|
|
HRESULT SelfRegEXETimeout();
|
|
|
|
HRESULT AbortBinding(CClBinding *pbinding);
|
|
|
|
BOOL WeAreReadyToSetup();
|
|
|
|
LPCSTR GetMainInf() { return m_szInf;}
|
|
LPCSTR GetOSD() { return m_szOSD;}
|
|
LCID GetLCID() { return m_lcid;}
|
|
|
|
BOOL VersionFromManifest(LPSTR szVersionInManifest, int iLen);
|
|
|
|
HRESULT SetManifest(FILEXTN extn, LPCSTR szManifest);
|
|
|
|
CLangInfo *GetLangInfo() { return &m_langinfo;}
|
|
void CodeDownloadDebugOut(int iOption, BOOL fOperationFailed,
|
|
UINT iResId, ...);
|
|
|
|
HRESULT IsPackageLocallyInstalled(LPCWSTR szPackageName, LPCWSTR szNameSpace, DWORD dwVersionMS, DWORD dwVersionLS);
|
|
|
|
IJavaPackageManager * GetPackageManager() { return m_pPackageManager;}
|
|
HRESULT SetCatalogFile(LPSTR szCatalogFile);
|
|
LPSTR GetCatalogFile();
|
|
HRESULT SetMainCABJavaTrustPermissions(PJAVA_TRUST pbJavaTrust);
|
|
PJAVA_TRUST GetJavaTrust();
|
|
void SetDebugLog(CDLDebugLog * debuglog);
|
|
|
|
void SetCatalogInstalled()
|
|
{
|
|
m_bCatalogInstalled = TRUE;
|
|
}
|
|
|
|
BOOL IsCatalogInstalled()
|
|
{
|
|
return m_bCatalogInstalled;
|
|
}
|
|
|
|
void SetAtom(ATOM atom)
|
|
{
|
|
if(m_atom)
|
|
DeleteAtom(m_atom);
|
|
m_atom = atom;
|
|
}
|
|
|
|
HRESULT VerifyFileAgainstSystemCatalog(LPCSTR pFileName, LPWSTR pwszFullCatalogPath, DWORD* pdwBuffer)
|
|
{
|
|
return m_wvt.VerifyFileAgainstSystemCatalog(pFileName, pwszFullCatalogPath, pdwBuffer);
|
|
}
|
|
|
|
BOOL FileProtectionCheckSucceeded(LPCSTR lpszExistingFileName);
|
|
|
|
BOOL IsFileProtected(LPCSTR pFileName);
|
|
|
|
private:
|
|
|
|
CDL_STATE GetState() const { return m_state;}
|
|
VOID SetState(CDL_STATE state) { m_state = state;}
|
|
|
|
HRESULT UpdateFileList(HKEY hKeyContains);
|
|
HRESULT UpdateDependencyList(HKEY hKeyContains);
|
|
HRESULT UpdateJavaList(HKEY hKeyContains);
|
|
HRESULT UpdateDistUnit(CLocalComponentInfo *plci);
|
|
HRESULT UpdateLanguageCheck(CLocalComponentInfo *plci);
|
|
|
|
void DumpDebugLog(char *szCacheFileName, LPTSTR szErrorMsg, HRESULT hrError);
|
|
void DestroyPCBHList(CList<CCodeBaseHold *, CCodeBaseHold *> *pcbhList);
|
|
|
|
DWORD m_cRef;
|
|
|
|
CDL_STATE m_state; // state of code download
|
|
|
|
LPWSTR m_url;
|
|
LPWSTR m_szDistUnit;
|
|
LPWSTR m_szType;
|
|
LPWSTR m_szExt;
|
|
LPSTR m_szDisplayName;
|
|
LPSTR m_szVersionInManifest;
|
|
|
|
IMoniker* m_pmkContext; // first download's pmk
|
|
// becomes the context
|
|
// for handling subsequent
|
|
// relative URLs
|
|
|
|
DWORD m_dwFileVersionMS; // little quirky that
|
|
DWORD m_dwFileVersionLS; // this really the primary
|
|
// control's fileversion
|
|
// can really be something
|
|
// else if deemed appropriate
|
|
// eg: subversion of clsid
|
|
|
|
LCID m_lcid; // cache lcid client needs
|
|
// this is pulled out of the
|
|
// bindctx (BIND_OPTS2)
|
|
|
|
CList<CModuleUsage*,CModuleUsage*> // linked list of module usage
|
|
m_ModuleUsage; // entries to add
|
|
|
|
CList<CClBinding*,CClBinding*> // linked list of client
|
|
m_pClientbinding; // IBindings
|
|
|
|
CList<CDownload*,CDownload*> // linked list of CDownload
|
|
m_pDownloads; // pieces
|
|
|
|
CList<LPWSTR,LPWSTR> // linked list of dependent
|
|
m_pDependencies; // distribution units
|
|
|
|
DWORD m_flags; // provision for hacks :)
|
|
// used internally now to
|
|
// mark if we have an INF file
|
|
// and if safe to abort
|
|
|
|
LPSTR m_szInf; // INF filename if one exists
|
|
LPSTR m_szOSD; // INF filename if one exists
|
|
|
|
LPSTR m_szCacheDir; // OCCACHE dir that is setup
|
|
// for each code download
|
|
// is usually = g_szOCXCacheDir
|
|
// but if a name conflict arises
|
|
// it can be OCCACHE\CONFLICT.n
|
|
|
|
|
|
|
|
LPSTR m_pAddCodeSection; // Add.Code section in INF
|
|
// bunch of null terminated
|
|
// strings, last one double
|
|
// null terminated (like env)
|
|
LPSTR m_pCurCode; // points at what ProcessInf
|
|
// is pending processing
|
|
|
|
HKEY m_hKeySearchPath; // key to REGSTR_PATH_ISP
|
|
|
|
LPSTR m_pSearchPath; // List of searchpath comps
|
|
LPSTR m_pSearchPathNextComp; // pointer into list above at
|
|
// current component
|
|
|
|
CLangInfo m_langinfo;
|
|
|
|
LPSTR m_szWaitForEXE; // str that points to name of
|
|
// self registering EXE that we
|
|
// are waiting now to complete
|
|
// This is used to give
|
|
// detailed CodeInstallProblem
|
|
// when we get a ClientBinding::
|
|
// Abort wahile waiting for an
|
|
// EXE to complete setup/reg
|
|
|
|
PROCESS_INFORMATION m_pi; // PI for the currently self-
|
|
// registering EXE that we
|
|
// are running
|
|
|
|
LISTPOSITION m_ListCookie; // cookie to remove this
|
|
// download from the per-thread
|
|
// list of CCodeDownload's in
|
|
// progress (CList)
|
|
|
|
HRESULT m_hr; // hr to pass to CompleteAll
|
|
// this store away the first
|
|
// real failure code in a
|
|
// multipart code download
|
|
|
|
|
|
char m_szLastMod[INTERNET_RFC1123_BUFSIZE+1];
|
|
// last modified date of the
|
|
// main URL (typically CODEBASE
|
|
// or the URL redirected by
|
|
// Object Index). We save this
|
|
// with the dist unit DB to use
|
|
// later for Get Latest.
|
|
|
|
DWORD m_dwExpire; // number of days before DU eligible
|
|
// for scavenging.
|
|
|
|
DWORD m_dwSystemComponent;
|
|
|
|
char *m_pbEtag;
|
|
|
|
CLocalComponentInfo* m_plci;
|
|
|
|
IJavaPackageManager* m_pPackageManager; // Java pkg mgr
|
|
|
|
DWORD m_grfBINDF;
|
|
CList<CCodeBaseHold *, CCodeBaseHold *> *m_pcbhList;
|
|
LPSTR m_szCatalogFile;
|
|
BOOL m_bCatalogInstalled;
|
|
ATOM m_atom;
|
|
PJAVA_TRUST m_pbJavaTrust;
|
|
CDLDebugLog * m_debuglog;
|
|
|
|
BOOL m_bUninstallOld;
|
|
BOOL m_bExactVersion;
|
|
HMODULE m_hModSFC;
|
|
|
|
Cwvt m_wvt;
|
|
|
|
#ifdef WX86
|
|
CMultiArch m_MultiArch;
|
|
#endif
|
|
};
|
|
|
|
class DebugLogElement {
|
|
public:
|
|
DebugLogElement() : m_szMessage(NULL) {}
|
|
DebugLogElement(LPSTR szMessage);
|
|
DebugLogElement(const DebugLogElement &ref);
|
|
virtual ~DebugLogElement();
|
|
|
|
public:
|
|
LPCSTR GetLogMessage() { return m_szMessage; }
|
|
HRESULT SetLogMessage(LPSTR szMessage);
|
|
|
|
private:
|
|
LPSTR m_szMessage;
|
|
};
|
|
|
|
|
|
// Class to make a debug log and pass out error messages
|
|
|
|
// Note reguarding wide strings vs. ANSI:
|
|
// For file-write compatiblity, the private strings of CDLDebugLog
|
|
// are stored as multibyte, but the primary accessors (the private
|
|
// variables in CCodeDownLoad) are wide characters. Hence, the
|
|
// return values for the accesors are Multibyte, since these are used
|
|
// primarily by this class, while the set parameters are wide character
|
|
class CDLDebugLog {
|
|
public:
|
|
~CDLDebugLog();
|
|
|
|
// Name accessor functions
|
|
// Return the current value for the requested name (may be "")
|
|
LPCTSTR GetMainClsid() {return m_szMainClsid;}
|
|
LPCTSTR GetMainType() {return m_szMainType;}
|
|
LPCTSTR GetMainExt() {return m_szMainExt;}
|
|
LPCTSTR GetMainUrl() {return m_szMainUrl;}
|
|
LPCTSTR GetFileName() {return m_szFileName;}
|
|
LPCTSTR GetUrlName() {return m_szUrlName;}
|
|
|
|
// Functions to access or output error messages
|
|
void DebugOut(int iOption, BOOL fOperationFailed,
|
|
UINT iResId, ...);
|
|
void DebugOutPreFormatted(int iOption, BOOL fOperationFailed,
|
|
LPTSTR szDebugString);
|
|
void DumpDebugLog(LPTSTR pszCacheFileName, int cbBufLen,
|
|
LPTSTR szErrorMsg, HRESULT hrError);
|
|
|
|
// Deletion and Initialization functions
|
|
void Clear();
|
|
BOOL Init(CCodeDownload * pcdl);
|
|
BOOL Init(LPCWSTR wszMainClsid, LPCWSTR wszMainType,
|
|
LPCWSTR wszMainExt, LPCWSTR wszMainUrl);
|
|
void MakeFile();
|
|
|
|
|
|
// Static functions for storing and accessing stored debug logs
|
|
static void AddDebugLog(CDLDebugLog * dlog);
|
|
static void RemoveDebugLog(CDLDebugLog * dlog);
|
|
static CDLDebugLog * GetDebugLog(LPCWSTR wszMainClsid, LPCWSTR wszMainType,
|
|
LPCWSTR wszMainExt, LPCWSTR wszMainUrl);
|
|
// Static functions for saving an error message for the download
|
|
static BOOL SetSavedMessage(LPCTSTR szMessage, BOOL bOverwrite);
|
|
static LPCTSTR GetSavedMessage();
|
|
|
|
// Static function for debug log construction
|
|
static CDLDebugLog * MakeDebugLog();
|
|
|
|
// Com-type add and release functions
|
|
int AddRef();
|
|
int Release();
|
|
|
|
private:
|
|
|
|
CDLDebugLog();
|
|
CList<DebugLogElement *, DebugLogElement *>
|
|
m_DebugLogList;
|
|
BOOL m_fAddedDebugLogHead;
|
|
TCHAR m_szFileName[INTERNET_MAX_URL_LENGTH];
|
|
TCHAR m_szUrlName[INTERNET_MAX_URL_LENGTH];
|
|
TCHAR m_szMainClsid[MAX_DEBUG_STRING_LENGTH];
|
|
TCHAR m_szMainType[MAX_DEBUG_STRING_LENGTH];
|
|
TCHAR m_szMainExt[MAX_DEBUG_STRING_LENGTH];
|
|
TCHAR m_szMainUrl[INTERNET_MAX_URL_LENGTH];
|
|
|
|
// Support addref and release
|
|
int m_iRefCount;
|
|
|
|
// List and mutex for stored CDLDebugLog's
|
|
static CList<CDLDebugLog *, CDLDebugLog *>
|
|
s_dlogList;
|
|
static CMutexSem s_mxsDLogList;
|
|
static CMutexSem s_mxsMessage;
|
|
|
|
// Saved error message
|
|
static TCHAR s_szMessage[];
|
|
static BOOL s_bMessage;
|
|
|
|
};
|
|
|
|
|
|
|
|
// values for CDownload::m_flags
|
|
typedef enum {
|
|
DL_FLAGS_INIT = 0x0,
|
|
DL_FLAGS_TRUST_VERIFIED= 0x1,
|
|
DL_FLAGS_EXTRACT_ALL= 0x2,
|
|
DL_FLAGS_CDL_PROTOCOL= 0x4 // using cdl:// to kick off DL
|
|
} DL_FLAGS;
|
|
|
|
class CParentCDL {
|
|
|
|
public:
|
|
|
|
CParentCDL(CCodeDownload *pcdl) {m_pcdl = pcdl;m_bCompleteSignalled = FALSE;}
|
|
|
|
CCodeDownload* m_pcdl;
|
|
BOOL m_bCompleteSignalled;
|
|
};
|
|
|
|
class CBindStatusCallback;
|
|
class CSetupHook;
|
|
|
|
// one for each individual downloads
|
|
class CDownload {
|
|
|
|
public:
|
|
|
|
// constructor
|
|
CDownload(LPCWSTR szURL, FILEXTN extn, HRESULT *phr);
|
|
~CDownload();
|
|
|
|
void CDownload::CleanUp();
|
|
|
|
HRESULT AddParent(CCodeDownload *pcdl);
|
|
HRESULT ReleaseParent(CCodeDownload *pcdl);
|
|
|
|
HRESULT CompleteSignal(HRESULT hrOSB, HRESULT hrStatus, HRESULT hrResponseHdr, LPCWSTR szError);
|
|
|
|
HRESULT DoDownload(LPMONIKER *ppmkContext, DWORD grfBINDF,
|
|
CList<CCodeBaseHold *, CCodeBaseHold *> *pcbhList = NULL);
|
|
|
|
HRESULT Abort(CCodeDownload *pcdl);
|
|
|
|
BOOL IsSignalled(CCodeDownload *pcdl);
|
|
|
|
// for each in list CSetup::DoSetup
|
|
HRESULT DoSetup();
|
|
|
|
BOOL IsDuplicateSetup(LPCSTR pBaseFileName);
|
|
|
|
// called by CBSC::OnStopBinding as soon as the binding completes
|
|
VOID ProcessPiece();
|
|
|
|
// for each in list CSetup::CheckForNameCollision
|
|
HRESULT CheckForNameCollision(LPCSTR szCacheDir);
|
|
|
|
HRESULT CleanupFiles();
|
|
|
|
CDownload *GetNext() const { return m_pdlnext;}
|
|
VOID SetNext(CDownload *pdlnext) { m_pdlnext = pdlnext;}
|
|
|
|
CSetup* GetSetupHead() const {return m_pSetuphead;}
|
|
VOID AddSetupToList(CSetup *pSetup);
|
|
HRESULT RemoveSetupFromList(CSetup *pSetup);
|
|
|
|
HRESULT AddHook(
|
|
LPCSTR szHook,
|
|
LPCSTR szInf,
|
|
LPCSTR szInfSection,
|
|
DWORD flags);
|
|
|
|
HRESULT AddSetupToExistingCAB(
|
|
char *lpCode,
|
|
const char * szDestDir,
|
|
DESTINATION_DIR dest,
|
|
DWORD dwRegisterServer,
|
|
DWORD dwCopyFlags);
|
|
|
|
CCodeDownload* GetCodeDownload() const { return (m_ParentCDL.GetHead())->m_pcdl;}
|
|
|
|
CBindStatusCallback* GetBSC() const { return m_pbsc;}
|
|
IBindCtx* GetBindCtx() const { return m_pbc;}
|
|
|
|
VOID SetUnkForCacheFileRelease(IUnknown *pUnk) {m_pUnkForCacheFileRelease = pUnk;}
|
|
|
|
LPCSTR GetFileName() const { return m_pFileName;}
|
|
VOID SetFileName(LPSTR pFileName) { m_pFileName = pFileName;}
|
|
|
|
HRESULT IsDownloadedVersionRequired();
|
|
|
|
LPCWSTR GetURL() const { return m_url;}
|
|
|
|
HRESULT GetFriendlyName(LPSTR szUrlPath, LPSTR *ppBaseFileName);
|
|
|
|
IMoniker* GetMoniker() const {return m_pmk;}
|
|
|
|
HRESULT SetURLAndExtn(LPCWSTR szURL, FILEXTN extn);
|
|
|
|
HRESULT SniffType();
|
|
|
|
FILEXTN GetExtn() const {return m_extn;}
|
|
PFNAME GetFilesToExtract() const { return m_pFilesToExtract;}
|
|
|
|
DLSTATE GetDLState() const { return m_state;}
|
|
VOID SetDLState(DLSTATE state)
|
|
{
|
|
m_state = state;
|
|
}
|
|
|
|
VOID SetProgress(ULONG ulProgress, ULONG ulProgressMax) { m_ulProgress = ulProgress; m_ulProgressMax = ulProgressMax;}
|
|
VOID SumProgress(ULONG *pulProgress, ULONG *pulProgressMax) { *pulProgress += m_ulProgress; *pulProgressMax += m_ulProgressMax;}
|
|
|
|
|
|
PSESSION GetSession() const { return m_psess;}
|
|
VOID SetSession(PSESSION psess) { m_psess = psess;}
|
|
|
|
HGLOBAL GetPostData(DWORD *pcbPostData) const {
|
|
*pcbPostData = m_cbPostData;
|
|
return m_hPostData;
|
|
}
|
|
|
|
VOID SetPostData(HGLOBAL hPostData, DWORD cbPostData) {
|
|
m_hPostData = hPostData;
|
|
m_cbPostData = cbPostData;
|
|
}
|
|
BOOL DoPost() const { return (m_hPostData != NULL);}
|
|
|
|
HRESULT GetResponseHeaderStatus() const {return m_hrResponseHdr;}
|
|
VOID SetResponseHeaderStatus( HRESULT hrResponseHdr) {
|
|
m_hrResponseHdr = hrResponseHdr;}
|
|
|
|
VOID VerifyTrust();
|
|
|
|
BOOL TrustVerified() const {return (m_flags & DL_FLAGS_TRUST_VERIFIED);}
|
|
VOID SetTrustVerified() {m_flags |= DL_FLAGS_TRUST_VERIFIED;}
|
|
|
|
BOOL NeedToExtractAllFiles() const {return(m_flags & DL_FLAGS_EXTRACT_ALL);}
|
|
VOID SetNeedToExtractAll() {m_flags |= DL_FLAGS_EXTRACT_ALL;}
|
|
|
|
BOOL UsingCdlProtocol() const {return(m_flags & DL_FLAGS_CDL_PROTOCOL);}
|
|
HRESULT SetUsingCdlProtocol(LPWSTR szDistUnit);
|
|
LPWSTR GetDistUnitName() const {return(m_wszDistUnit);}
|
|
|
|
HRESULT ExtractManifest(FILEXTN extn, LPSTR szFileName, LPSTR& pBaseFileName);
|
|
|
|
CSetupHook* FindHook(LPCSTR szHook);
|
|
CJavaSetup* FindJavaSetup(LPCWSTR szPackageName);
|
|
|
|
HRESULT AddJavaSetup(LPCWSTR szPackageName, LPCWSTR szNameSpace, IXMLElement *pPackage, DWORD dwVersionMS, DWORD dwVersionLS, DWORD flags);
|
|
CList<CJavaSetup*,CJavaSetup*> *GetJavaSetupList() { return &m_JavaSetupList;}
|
|
BOOL HasJavaPermissions();
|
|
BOOL HasAllActiveXPermissions();
|
|
PJAVA_TRUST GetJavaTrust() {return m_pbJavaTrust;}
|
|
|
|
HRESULT PerformVirusScan(LPSTR szFileName);
|
|
|
|
STDMETHODIMP DownloadRedundantCodeBase();
|
|
HRESULT SetMainCABJavaTrustPermissions(PJAVA_TRUST pbJavaTrust);
|
|
|
|
void SetExactVersion(BOOL bFlag) {m_bExactVersion = bFlag;}
|
|
|
|
private:
|
|
|
|
LPWSTR m_url;
|
|
FILEXTN m_extn;
|
|
LPSTR m_pFileName; // filename in temp once downloaded
|
|
|
|
IMoniker* m_pmk;
|
|
IBindCtx* m_pbc;
|
|
|
|
IUnknown* m_pUnkForCacheFileRelease;
|
|
|
|
CBindStatusCallback* m_pbsc;
|
|
|
|
CDownload* m_pdlnext;
|
|
|
|
CList<CParentCDL *,CParentCDL *> // linked list of CCodeDownloads
|
|
m_ParentCDL; // that have interest in us
|
|
|
|
ULONG m_ulProgress;
|
|
ULONG m_ulProgressMax;
|
|
|
|
DLSTATE m_state;
|
|
|
|
PSESSION m_psess; // CAB extraction struc
|
|
PFNAME m_pFilesToExtract; // applicable only for CAB objs
|
|
|
|
CSetup* m_pSetuphead; // list of CSetup's for this dwld
|
|
|
|
DWORD m_flags; // provision for hacks :)
|
|
|
|
HGLOBAL m_hPostData; // has the query for the clsid
|
|
|
|
DWORD m_cbPostData; // has size of post data
|
|
|
|
BOOL m_bCompleteSignalled;
|
|
|
|
LPWSTR m_wszDistUnit; // name of distribution for cdl:// dl
|
|
|
|
HRESULT m_hrOSB; // this is the hr we got
|
|
// from OnStopBinding
|
|
HRESULT m_hrStatus; // this is the hr we got
|
|
// URLMON for the binding
|
|
HRESULT m_hrResponseHdr; // this is the hr we got
|
|
// from the response headers
|
|
// when querying for this clsid
|
|
// this is to make sure we have the
|
|
// right error status even when
|
|
// urlmon does not pass back right
|
|
// OnError.
|
|
|
|
PJAVA_TRUST m_pbJavaTrust;
|
|
|
|
CList<CSetupHook*,CSetupHook*> // linked list of setup hooks
|
|
m_SetupHooks;
|
|
|
|
CList<CJavaSetup*,CJavaSetup*> // linked list of Java setups
|
|
m_JavaSetupList;
|
|
|
|
Cwvt m_wvt; // WinVerifyTrust delay load
|
|
// magic in this class
|
|
|
|
CList<CCodeBaseHold *, CCodeBaseHold *> *m_pcbhList;
|
|
DWORD m_grfBINDF;
|
|
LPMONIKER *m_ppmkContext;
|
|
|
|
BOOL m_bExactVersion;
|
|
|
|
};
|
|
|
|
// BSC for our indiv. CDownloads
|
|
class CBindStatusCallback : public IBindStatusCallback
|
|
,public IHttpNegotiate
|
|
,public IWindowForBindingUI
|
|
,public IServiceProvider
|
|
,public ICatalogFileInfo
|
|
{
|
|
|
|
public:
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid,void ** ppv);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IBindStatusCallback methods
|
|
STDMETHODIMP GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo);
|
|
STDMETHODIMP OnDataAvailable(DWORD grfBSCF, DWORD dwSize, FORMATETC *pFmtetc, STGMEDIUM __RPC_FAR *pstgmed);
|
|
STDMETHODIMP OnObjectAvailable( REFIID riid, IUnknown* punk);
|
|
|
|
STDMETHODIMP OnStartBinding(DWORD grfBSCOPTION,IBinding* pbinding);
|
|
STDMETHODIMP GetPriority(LONG* pnPriority);
|
|
STDMETHODIMP OnLowResource(DWORD dwReserved);
|
|
STDMETHODIMP OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode,
|
|
LPCWSTR pwzStatusText);
|
|
STDMETHODIMP OnStopBinding(HRESULT hrResult, LPCWSTR szError);
|
|
|
|
// *** IHttpNegotiate methods ***
|
|
STDMETHOD(BeginningTransaction) (
|
|
LPCWSTR szURL,
|
|
LPCWSTR szHeaders,
|
|
DWORD dwReserved,
|
|
LPWSTR *pszAdditionalHeaders);
|
|
|
|
STDMETHOD(OnResponse) (
|
|
DWORD dwResponseCode,
|
|
LPCWSTR szResponseHeaders,
|
|
LPCWSTR szRequestHeaders,
|
|
LPWSTR *pszAdditionalRequestHeaders);
|
|
|
|
// *** IWindowForBindingUI methods ***
|
|
STDMETHOD(GetWindow) (
|
|
REFGUID rguidreason,
|
|
HWND *phWnd);
|
|
|
|
// *** IServiceProvider ***
|
|
STDMETHOD(QueryService) (
|
|
REFGUID guidService,
|
|
REFIID riid,
|
|
LPVOID *ppv);
|
|
|
|
|
|
// *** ICatalogFileInfo ***
|
|
STDMETHODIMP GetCatalogFile(LPSTR *ppszCatalogFile);
|
|
STDMETHODIMP GetJavaTrust(void **ppJavaTrust);
|
|
|
|
// constructor
|
|
CBindStatusCallback(CDownload *pdl, DWORD grfBINDF);
|
|
~CBindStatusCallback();
|
|
|
|
IBinding* GetBinding() const {return m_pbinding;}
|
|
|
|
private:
|
|
|
|
DWORD m_cRef;
|
|
IBinding* m_pbinding;
|
|
CDownload* m_pdl; // point up into download obj
|
|
DWORD m_grfBINDF;
|
|
|
|
BYTE m_cbBuffer[BUFFERMAX];
|
|
|
|
};
|
|
|
|
class CSetupHook {
|
|
public:
|
|
|
|
CSetupHook(
|
|
CDownload *pdl,
|
|
LPCSTR szHook,
|
|
LPCSTR szInf,
|
|
LPCSTR szInfSection,
|
|
DWORD flags,
|
|
HRESULT *phr);
|
|
|
|
~CSetupHook();
|
|
|
|
HRESULT Run();
|
|
|
|
static HRESULT ExpandCommandLine(
|
|
LPSTR szSrc,
|
|
LPSTR szBuf,
|
|
DWORD cbBuffer,
|
|
const char * szVars[], // array of variable names eg. %EXTRACT_DIR%
|
|
const char * szValues[]); // corresponding values to expand of vars
|
|
|
|
static HRESULT ExpandVar(
|
|
LPSTR& pchSrc, // passed by ref!
|
|
LPSTR& pchOut, // passed by ref!
|
|
DWORD& cbLen, // passed by ref!
|
|
DWORD cbBuffer, // size of out buffer
|
|
const char * szVars[], // array of variable names eg. %EXTRACT_DIR%
|
|
const char * szValues[]);// corresponding values to expand of vars
|
|
|
|
HRESULT TranslateString();
|
|
|
|
INSTALL_STATE GetState() const { return m_state;}
|
|
VOID SetState(INSTALL_STATE state) { m_state = state;}
|
|
|
|
LPSTR GetHookName() { return m_szHook; }
|
|
|
|
const char * GetObjectDir() {
|
|
|
|
if (m_pdl && m_pdl->GetCodeDownload())
|
|
return m_pdl->GetCodeDownload()->GetCacheDir();
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
LPCWSTR GetSrcURL() {
|
|
if (m_pdl) {
|
|
return m_pdl->GetURL();
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
LPSTR GetHookDir() {
|
|
|
|
if (m_pdl && m_pdl->GetSession())
|
|
return m_pdl->GetSession()->achLocation;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
private:
|
|
|
|
INSTALL_STATE m_state; // state of install operation
|
|
CDownload* m_pdl;
|
|
LPSTR m_szHook;
|
|
LPSTR m_szInf;
|
|
LPSTR m_szInfSection;
|
|
DWORD m_flags;
|
|
};
|
|
|
|
HRESULT SetCodeDownloadTLSVars();
|
|
|
|
// private helpers
|
|
|
|
// from isctrl.cxx
|
|
HRESULT IsControlLocallyInstalled(
|
|
LPSTR lpCurCode,
|
|
const LPCLSID lpclsid,
|
|
LPCWSTR szDistUnit,
|
|
DWORD dwFileVersionMS,
|
|
DWORD dwFileVersionLS,
|
|
CLocalComponentInfo *plci,
|
|
LPSTR szDestDirHint,
|
|
BOOL bExactVersion = FALSE);
|
|
|
|
// from isctrl.cxx
|
|
HRESULT IsCLSIDLocallyInstalled(
|
|
LPSTR lpCurCode,
|
|
const LPCLSID lpclsid,
|
|
LPCWSTR szDistUnit,
|
|
DWORD dwFileVersionMS,
|
|
DWORD dwFileVersionLS,
|
|
CLocalComponentInfo *plci,
|
|
LPSTR szDestDirHint,
|
|
HRESULT *pHrExtra,
|
|
BOOL bExactVersion
|
|
);
|
|
|
|
HRESULT
|
|
IsDistUnitLocallyInstalled(
|
|
LPCWSTR szDistUnit,
|
|
DWORD dwFileVersionMS,
|
|
DWORD dwFileVersionLS,
|
|
CLocalComponentInfo *plci,
|
|
LPSTR szDestDirHint,
|
|
LPBOOL pbParanoidCheck,
|
|
DWORD flags);
|
|
|
|
HRESULT
|
|
IsPackageLocallyInstalled(
|
|
IJavaPackageManager **ppPackageManager,
|
|
LPCWSTR szPackageName,
|
|
LPCWSTR szNameSpace,
|
|
DWORD dwVersionMS,
|
|
DWORD dwVersionLS);
|
|
|
|
HRESULT LocalVersionOK(
|
|
HKEY hkeyClsid,
|
|
CLocalComponentInfo *plci,
|
|
DWORD dwFileVersionMS,
|
|
DWORD dwFileVersionLS,
|
|
BOOL bExactVersion
|
|
);
|
|
|
|
|
|
HRESULT GetFileVersion(
|
|
CLocalComponentInfo *plci,
|
|
LPDWORD pdwFileVersionMS,
|
|
LPDWORD pdwFileVersionLS);
|
|
|
|
HRESULT GetVersionFromString(
|
|
const char *szBuf,
|
|
LPDWORD pdwFileVersionMS,
|
|
LPDWORD pdwFileVersionLS,
|
|
char cSeperator = ',');
|
|
|
|
BOOL AdviseForceDownload( const LPCLSID lpclsid, DWORD dwClsContext);
|
|
|
|
// flags for UpdateModuleUsage
|
|
|
|
#define MU_CLIENT 0 // mark us as a client
|
|
#define MU_OWNER 1 // mark us as the owner (iff no prev ver exists)
|
|
|
|
HRESULT
|
|
UpdateModuleUsage(
|
|
LPCSTR szFileName,
|
|
LPCSTR szClientName,
|
|
LPCSTR szClientPath,
|
|
LONG muFlags);
|
|
|
|
HRESULT UpdateSharedDlls( LPCSTR szFileName);
|
|
|
|
BOOL SupportsSelfRegister(LPSTR szFileName);
|
|
BOOL WantsAutoExpire(LPSTR szFileName, DWORD *pnExpireDays );
|
|
|
|
// from wvt.cxx
|
|
HRESULT GetActivePolicy(IInternetHostSecurityManager* pZoneManager,
|
|
LPCWSTR pwszZone,
|
|
DWORD dwUrlAction,
|
|
DWORD& dwPolicy,
|
|
BOOL fEnforceRestricted);
|
|
|
|
// from peldr.cxx
|
|
HRESULT IsCompatibleFile(const char *szFileName, LPDWORD lpdwMachineType=NULL);
|
|
HRESULT IsRegisterableDLL(const char *szFileName);
|
|
|
|
|
|
// fro, softdist.cxx
|
|
HRESULT GetLangString(LCID localeID, char *szThisLang, int iLen);
|
|
HRESULT InitBrowserLangStrings();
|
|
|
|
// from duman.cxx
|
|
HRESULT GetSoftDistFromOSD(LPCSTR szFile, IXMLElement **ppSoftDist);
|
|
|
|
HRESULT GetFirstChildTag(IXMLElement *pRoot, LPCWSTR szTag, IXMLElement **ppChildReq);
|
|
HRESULT GetNextChildTag(IXMLElement *pRoot, LPCWSTR szTag, IXMLElement **ppChildReq, int &nLastChild);
|
|
|
|
HRESULT GetAttribute(IXMLElement *pElem, LPWSTR szAttribName, VARIANT *pvProp);
|
|
HRESULT GetAttributeA(IXMLElement *pElem, LPWSTR szAttribName, LPSTR pAttribValue, DWORD dwBufferLen);
|
|
HRESULT DupAttributeA(IXMLElement *pElem, LPWSTR szAttribName, LPSTR *ppszRet);
|
|
HRESULT DupAttribute(IXMLElement *pElem, LPWSTR szAttribName, LPWSTR *ppszRet);
|
|
HRESULT GetTextContent(IXMLElement *pRoot, LPCWSTR szTag, LPWSTR *ppszContent);
|
|
|
|
// from jit.cxx
|
|
HRESULT
|
|
GetIEFeatureFromMime(LPWSTR *ppwszIEFeature, LPCWSTR pwszMimeType, QUERYCONTEXT *pQuery, QUERYCONTEXT *pQueryRec=NULL);
|
|
HRESULT
|
|
GetIEFeatureFromClass(LPWSTR *ppwszIEFeature, REFCLSID clsid, QUERYCONTEXT *pQuery, QUERYCONTEXT *pQueryRec=NULL);
|
|
|
|
// from client.cxx
|
|
IInternetHostSecurityManager* GetHostSecurityManager(IBindStatusCallback *pclientbsc);
|
|
|
|
// from helpers.cxx
|
|
HRESULT CheckFileImplementsCLSID(const char *pszFileName, REFCLSID rClsid);
|
|
FILEXTN GetExtnAndBaseFileName( char *szName, char **plpBaseFileName);
|
|
HRESULT MakeUniqueTempDirectory(LPCSTR szTempDir, LPSTR szUniqueTempDir, int iLen);
|
|
HRESULT ComposeHackClsidFromMime(LPSTR szHackMimeType, int iLen, LPCSTR szClsid);
|
|
|
|
HRESULT GetHeaderValue (
|
|
LPCWSTR szResponseHeadersBuffer,
|
|
DWORD cbResponseHeadersBuffer,
|
|
LPCWSTR lpcszHeaderName,
|
|
LPWSTR pHeaderValue,
|
|
DWORD cbHeaderValue);
|
|
|
|
HRESULT
|
|
GetClsidFromExtOrMime(
|
|
REFCLSID rclsid,
|
|
CLSID &clsidout,
|
|
LPCWSTR szExt,
|
|
LPCWSTR szTYPE,
|
|
LPSTR *ppFileName);
|
|
|
|
STDAPI
|
|
AsyncGetClassBitsEx(
|
|
REFCLSID rclsid, // CLSID
|
|
CodeDownloadData * pcdd, // Contains requested object's descriptors
|
|
IBindCtx *pbc, // bind ctx: should contain BSC
|
|
DWORD dwClsContext, // CLSCTX flags
|
|
LPVOID pvReserved, // Must be NULL
|
|
REFIID riid); // Usually IID_IClassFactory
|
|
|
|
STDAPI
|
|
AsyncGetClassBits2Ex(
|
|
LPCWSTR szClientID, // client ID, root object if NULL
|
|
CodeDownloadData * pcdd, // Contains requested object's descriptors
|
|
IBindCtx *pbc, // bind ctx
|
|
DWORD dwClsContext, // CLSCTX flags
|
|
LPVOID pvReserved, // Must be NULL
|
|
REFIID riid, // Usually IID_IClassFactory
|
|
IUnknown **pUnk);
|
|
|
|
|
|
STDAPI
|
|
AsyncInstallDistributionUnitEx(
|
|
CodeDownloadData * pcdd, // Contains requested object's descriptors
|
|
IBindCtx *pbc, // bind ctx
|
|
REFIID riid,
|
|
IUnknown **pUnk,
|
|
LPVOID pvReserved); // Must be NULL
|
|
|
|
|
|
// backwards compatability
|
|
STDAPI
|
|
AsyncGetClassBits(
|
|
REFCLSID rclsid, // CLSID
|
|
LPCWSTR szType, // MIME type
|
|
LPCWSTR szExtension, // or Extension
|
|
// as alternate
|
|
// if CLSID == CLSID_NULL
|
|
|
|
DWORD dwFileVersionMS, // CODE=http://foo#Version=a,b,c,d
|
|
DWORD dwFileVersionLS, // MAKEDWORD(c,b) of above
|
|
LPCWSTR szURL, // CODEBASE= in OBJECT tag
|
|
IBindCtx *pbc, // bind ctx: should contain BSC
|
|
DWORD dwClsContext, // CLSCTX flags
|
|
LPVOID pvReserved, // Must be NULL
|
|
REFIID riid, // Usually IID_IClassFactory
|
|
DWORD flags);
|
|
STDAPI
|
|
AsyncInstallDistributionUnit(
|
|
LPCWSTR szDistUnit,
|
|
LPCWSTR szTYPE,
|
|
LPCWSTR szExt,
|
|
DWORD dwFileVersionMS, // CODEBASE=http://foo#Version=a,b,c,d
|
|
DWORD dwFileVersionLS, // MAKEDWORD(c,b) of above
|
|
LPCWSTR szURL, // CODEBASE
|
|
IBindCtx *pbc, // bind ctx
|
|
LPVOID pvReserved, // Must be NULL
|
|
DWORD flags);
|
|
STDAPI
|
|
AsyncGetClassBits2(
|
|
LPCWSTR szClientID, // client ID, root object if NULL
|
|
LPCWSTR szDistUnit, // CLSID, can be an arbit unique str
|
|
LPCWSTR szTYPE,
|
|
LPCWSTR szExt,
|
|
DWORD dwFileVersionMS, // CODE=http://foo#Version=a,b,c,d
|
|
DWORD dwFileVersionLS, // MAKEDWORD(c,b) of above
|
|
LPCWSTR szURL, // CODE= in INSERT tag
|
|
IBindCtx *pbc, // bind ctx
|
|
DWORD dwClsContext, // CLSCTX flags
|
|
LPVOID pvReserved, // Must be NULL
|
|
REFIID riid, // Usually IID_IClassFactory
|
|
DWORD flags);
|
|
|
|
|
|
#ifdef unix
|
|
extern "C"
|
|
#endif /* unix */
|
|
STDAPI_(DWORD)
|
|
CDLGetLongPathNameA(
|
|
LPSTR lpszLong,
|
|
LPCSTR lpszShort,
|
|
DWORD cchBuffer
|
|
);
|
|
|
|
#ifdef unix
|
|
extern "C"
|
|
#endif /* unix */
|
|
STDAPI_(DWORD)
|
|
CDLGetLongPathNameW(
|
|
LPWSTR lpszLongPath,
|
|
LPCWSTR lpszShortPath,
|
|
DWORD cchBuffer
|
|
);
|
|
|
|
HRESULT
|
|
GetActiveXSafetyProvider(
|
|
IActiveXSafetyProvider **ppProvider
|
|
);
|
|
|
|
extern int g_CPUType;
|
|
extern BOOL g_fRunningOnNT;
|
|
extern BOOL g_bNT5OrGreater;
|
|
#ifdef WX86
|
|
extern BOOL g_fWx86Present;
|
|
#endif
|
|
|
|
VOID
|
|
DetermineOSAndCPUVersion();
|
|
|
|
#ifdef UNICODE
|
|
#define CDLGetLongPathName CDLGetLongPathNameW
|
|
#else
|
|
#define CDLGetLongPathName CDLGetLongPathNameA
|
|
#endif // !UNICODE
|
|
|
|
#endif /* end hide classes from 'C' */
|
|
#endif // _CDL_H_
|