// ===========================================================================
// File: DL.CXX
// implements CDownload, CBindStatusCallback classes
//
#include <cdlpch.h>
// SILENT MODE
#include <winineti.h>
#include <shlwapi.h>
#include <shlwapip.h>
#include <comcat.h>
#include <initguid.h> // office antivirus goo
#define AVVENDOR // don't look at unwanted office defs
#include <msoav.h>
extern char g_szOCXTempDir[MAX_PATH];
extern IEnumFORMATETC *g_pEFmtETC;
extern FORMATETC g_rgfmtetc[];
// ---------------------------------------------------------------------------
// %%Function: CDownload::CDownload
// CDownload is the basic download obj.
// ---------------------------------------------------------------------------
CDownload::CDownload(LPCWSTR szURL, FILEXTN extn, HRESULT *phr)
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::CDownload",
"this=%#x, %.80wq, %#x, %#x",
this, szURL, extn, phr
));
DllAddRef();
DWORD len = lstrlenW(szURL); // make private copy
m_url = new WCHAR [len + 1];
if (m_url)
StrCpyW(m_url, szURL);
else
*phr = E_OUTOFMEMORY;
m_pmk = 0;
m_pbc = 0;
m_pbsc = 0;
m_pdlnext= NULL;
m_ParentCDL.RemoveAll();
m_extn = extn;
m_pFileName = NULL; // we don't know the dest filename
// till we create a temp file in the first
// notification of OnDataAvailable
// This is guaranteed to get set before
// OnStopBinding
m_ulProgress = 0;
m_ulProgressMax = 0;
m_state = DLSTATE_INIT;
m_psess = NULL;
m_pFilesToExtract = NULL;
m_pSetuphead = NULL;
m_hPostData = NULL;
m_cbPostData = 0;
m_hrOSB = S_OK;
m_hrStatus = S_OK;
m_hrResponseHdr = S_OK;
m_bCompleteSignalled = FALSE;
m_flags = DL_FLAGS_INIT;
m_SetupHooks.RemoveAll();
m_JavaSetupList.RemoveAll();
m_pUnkForCacheFileRelease = NULL;
m_pbJavaTrust = NULL;
m_wszDistUnit = NULL;
m_pcbhList = NULL;
m_ppmkContext = NULL;
m_grfBINDF = 0;
m_bExactVersion = FALSE;
DEBUG_LEAVE(0);
} // CDownload
// ---------------------------------------------------------------------------
// %%Function: CDownload::~CDownload
// ---------------------------------------------------------------------------
CDownload::~CDownload()
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::~CDownload",
"this=%#x",
this
));
int i;
CCodeBaseHold *pcbh = NULL;
LISTPOSITION lpos = 0;
CleanUp();
LISTPOSITION pos = m_ParentCDL.GetHeadPosition();
int iNum = m_ParentCDL.GetCount();
Assert(iNum == 0);
for (i=0; i < iNum; i++) {
CParentCDL *pParentCDL = m_ParentCDL.GetNext(pos); // pass ref!
delete pParentCDL;
}
m_ParentCDL.RemoveAll();
if (m_pcbhList != NULL) {
lpos = m_pcbhList->GetHeadPosition();
while (lpos) {
pcbh = m_pcbhList->GetNext(lpos);
delete pcbh;
}
m_pcbhList->RemoveAll();
}
SAFEDELETE(m_pcbhList);
SAFEDELETE(m_wszDistUnit);
pos = m_SetupHooks.GetHeadPosition();
iNum = m_SetupHooks.GetCount();
for (i=0; i < iNum; i++) {
CSetupHook *pSetupHook = m_SetupHooks.GetNext(pos); // pass ref!
delete pSetupHook;
}
m_SetupHooks.RemoveAll();
pos = m_JavaSetupList.GetHeadPosition();
iNum = m_JavaSetupList.GetCount();
for (i=0; i < iNum; i++) {
CJavaSetup *pJavaSetup = m_JavaSetupList.GetNext(pos); // pass ref!
delete pJavaSetup;
}
m_JavaSetupList.RemoveAll();
DllRelease();
DEBUG_LEAVE(0);
} // ~CDownload
// ---------------------------------------------------------------------------
// %%Function: CDownload::HasJavaPermissions
// ---------------------------------------------------------------------------
BOOL
CDownload::HasJavaPermissions()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Bool,
"CDownload::HasJavaPermissions",
"this=%#x",
this
));
if (m_pbJavaTrust) {
// new jaavcypt > 2151 succeeds even if one of activex/java
// is allowed
DEBUG_LEAVE((m_pbJavaTrust->pbJavaPermissions != NULL));
return (m_pbJavaTrust->pbJavaPermissions != NULL);
}
DEBUG_LEAVE(FALSE);
return FALSE;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::HasAllActiveXPermissions
// ---------------------------------------------------------------------------
BOOL
CDownload::HasAllActiveXPermissions()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Bool,
"CDownload::HasAllActiveXPermissions",
"this=%#x",
this
));
PJAVA_TRUST pbJavaTrust = NULL;
if (m_pbJavaTrust) {
// new jaavcypt > 2151 succeeds even if one of activex/java
// is allowed
DEBUG_LEAVE(m_pbJavaTrust->fAllActiveXPermissions);
return m_pbJavaTrust->fAllActiveXPermissions;
}
else {
pbJavaTrust = GetCodeDownload()->GetJavaTrust();
if (pbJavaTrust) {
DEBUG_LEAVE(pbJavaTrust->fAllActiveXPermissions);
return pbJavaTrust->fAllActiveXPermissions;
}
}
DEBUG_LEAVE(FALSE);
return FALSE;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::CompleteSignal
// ---------------------------------------------------------------------------
HRESULT
CDownload::CompleteSignal(HRESULT hrOSB, HRESULT hrStatus, HRESULT hrResponseHdr, LPCWSTR szError)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::CompleteSignal",
"this=%#x, %#x, %#x, %#x, %.80wq",
this, hrOSB, hrStatus, hrResponseHdr, szError
));
int i, iNum;
LISTPOSITION pos;
m_hrOSB = hrOSB;
m_hrStatus = hrStatus;
m_hrResponseHdr = hrResponseHdr;
m_bCompleteSignalled = TRUE;
restart:
iNum = m_ParentCDL.GetCount();
Assert(iNum);
pos = m_ParentCDL.GetHeadPosition();
for (i=0; i < iNum; i++) {
CParentCDL *pParentCDL = m_ParentCDL.GetNext(pos); // pass ref!
if (!pParentCDL->m_bCompleteSignalled) {
// unsignalled code download
pParentCDL->m_bCompleteSignalled = TRUE;
pParentCDL->m_pcdl->CompleteOne( this ,hrOSB, hrStatus, hrResponseHdr, szError);
if (iNum > 1) {
// failed complete reports could cause CodeDownloads to release
// us and thus change the list
goto restart;
}
}
}
DEBUG_LEAVE(S_OK);
return S_OK;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::AddParent(CCodeDownload *pcdl)
// ---------------------------------------------------------------------------
HRESULT
CDownload::AddParent(CCodeDownload *pcdl)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::AddParent",
"this=%#x, %#x",
this, pcdl
));
HRESULT hr = S_OK;
CParentCDL *pParentCDL = new CParentCDL(pcdl);
if (pParentCDL)
m_ParentCDL.AddTail(pParentCDL);
else
hr = E_OUTOFMEMORY;
if (SUCCEEDED(hr)) {
if (m_bCompleteSignalled) {
pParentCDL->m_bCompleteSignalled = TRUE;
pcdl->CompleteOne(this ,m_hrOSB, m_hrStatus, m_hrResponseHdr, NULL);
} else {
hr = FAILED(m_hrOSB)?m_hrOSB:(FAILED(m_hrStatus)?m_hrStatus:(FAILED(m_hrResponseHdr)?m_hrResponseHdr:S_OK));
}
}
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::IsSignalled(CCodeDownload *pcdl)
// ---------------------------------------------------------------------------
BOOL
CDownload::IsSignalled(CCodeDownload *pcdl)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Bool,
"CDownload::IsSignalled",
"this=%#x, %#x",
this, pcdl
));
CParentCDL *pParentCDL = NULL;
BOOL bRet = FALSE;
LISTPOSITION pos = 0;
DLSTATE dls;
int iNum = 0;
int i;
dls = GetDLState();
if (dls == DLSTATE_DONE || dls == DLSTATE_READY_TO_SETUP) {
bRet = TRUE;
goto Exit;
}
iNum = m_ParentCDL.GetCount();
Assert(iNum);
pos = m_ParentCDL.GetHeadPosition();
for (i=0; i < iNum; i++) {
pParentCDL = m_ParentCDL.GetNext(pos); // pass ref!
if (pParentCDL->m_pcdl == pcdl && pParentCDL->m_bCompleteSignalled) {
bRet = TRUE;
break;
}
}
Exit:
DEBUG_LEAVE(bRet);
return bRet;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::Abort(CCodeDownload *pcdl)
// ---------------------------------------------------------------------------
HRESULT
CDownload::Abort(CCodeDownload *pcdl)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::Abort",
"this=%#x, %#x",
this, pcdl
));
int i;
CParentCDL *pThisParentCDL = NULL;
BOOL bDelinkParent = FALSE;
BOOL fWaitForAbortCompletion = FALSE;
HRESULT hr = S_OK;
int iNum = m_ParentCDL.GetCount();
Assert(iNum);
LISTPOSITION pos = m_ParentCDL.GetHeadPosition();
for (i=0; i < iNum; i++) {
CParentCDL *pParentCDL = m_ParentCDL.GetNext(pos); // pass ref!
if (pParentCDL->m_pcdl == pcdl)
pThisParentCDL = pParentCDL;
else if ( !pParentCDL->m_bCompleteSignalled )
bDelinkParent = TRUE;
}
Assert(pThisParentCDL);
if (!pThisParentCDL)
{
DEBUG_LEAVE(E_FAIL);
return E_FAIL;
}
if (bDelinkParent) {
// multiple code downloads interested in this
// delink this parent, by marking as complete signalled
pThisParentCDL->m_bCompleteSignalled = TRUE;
DEBUG_LEAVE(S_OK);
return S_OK;
}
switch ( GetDLState()) {
case DLSTATE_BINDING:
GetBSC()->GetBinding()->Abort();
break;
case DLSTATE_ABORT:
// have aborted this but the OSB has not been recieved yet
// so wait for that to come to us before we complteall
// or post the setup packet to completeall
fWaitForAbortCompletion = TRUE;
break;
case DLSTATE_DONE:
case DLSTATE_READY_TO_SETUP:
break;
default:
// packet processing pending for this state. we will check for
// DLSTATE_ABORT in each packet processing state and if true
// it will call CompleteOne(us), which marks each piece DLSTATE_DONE
SetDLState(DLSTATE_ABORT);
fWaitForAbortCompletion = TRUE;
}
if (fWaitForAbortCompletion) {
hr = S_FALSE;
}
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::ReleaseParent(CCodeDownload *pcdl)
// ---------------------------------------------------------------------------
HRESULT
CDownload::ReleaseParent(CCodeDownload *pcdl)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::ReleaseParent",
"this=%#x, %#x",
this, pcdl
));
int iNum = m_ParentCDL.GetCount();
Assert(iNum);
LISTPOSITION pos = m_ParentCDL.GetHeadPosition();
for (int i=0; i < iNum; i++) {
CParentCDL *pParentCDL = m_ParentCDL.GetNext(pos); // pass ref!
if (pParentCDL->m_pcdl == pcdl) {
// found the item
// getnext would have stepped past the position
pos = m_ParentCDL.Find(pParentCDL);
m_ParentCDL.RemoveAt(pos);
iNum = m_ParentCDL.GetCount();
if (iNum == 0) {
CleanupFiles();
delete this;
}
DEBUG_LEAVE(S_OK);
return S_OK;
}
}
// not found in list
Assert(TRUE);
DEBUG_LEAVE(E_FAIL);
return E_FAIL;
}
// ---------------------------------------------------------------------------
// HRESULT CDownload::IsDownloadedVersionRequired()
// returns S_OK if downloaded version is required
// error if local version is OK and new verison is not required
// ---------------------------------------------------------------------------
HRESULT CDownload::IsDownloadedVersionRequired()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::IsDownloadedVersionRequired",
"this=%#x",
this
));
HRESULT hr = S_OK;
char szFullURL[INTERNET_MAX_URL_LENGTH];
DWORD dwLen = INTERNET_MAX_URL_LENGTH;
FILETIME *pftLastMod = GetCodeDownload()->GetLastModifiedTime();
HANDLE hf = INVALID_HANDLE_VALUE;
if (!GetCodeDownload()->LocalVersionPresent()) {
// if no prev version always download
DEBUG_LEAVE(hr);
return hr;
} else {
// if prev version exists, but we are not doing Get Latest
// then accept the download.
if (!GetCodeDownload()->NeedLatestVersion())
{
DEBUG_LEAVE(hr);
return hr;
}
}
if (GetMoniker() != GetCodeDownload()->GetContextMoniker()){
// if we are not the context (or the main moniker then
// -1 does not apply (to secondary CABs)
DEBUG_LEAVE(hr);
return hr;
}
dwLen = WideCharToMultiByte(CP_ACP, 0, GetURL(), -1,
szFullURL, INTERNET_MAX_URL_LENGTH, NULL, NULL);
Assert(dwLen);
if (!dwLen) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if (StrCmpNI(szFullURL, "file:", 5) == 0) {
WIN32_FIND_DATA fd;
hf = FindFirstFile(GetFileName(), &fd);
if (hf == INVALID_HANDLE_VALUE) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
// BUGBUG: Defend against Bug#40696 - Vatsan should check to see if this is the _right_ defense.
if ( pftLastMod != NULL &&
CompareFileTime(pftLastMod, &(fd.ftLastWriteTime)) >= 0) {
// if the file needs no upgrade then fail!
// if we succeed then an update will take place.
hr = HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
goto Exit;
}
}
Exit:
if ( hf != INVALID_HANDLE_VALUE)
FindClose(hf);
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::GetFriendlyName
// ---------------------------------------------------------------------------
HRESULT CDownload::GetFriendlyName(LPSTR szUrlPath, LPSTR *ppBaseFileName)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::GetFriendlyName",
"this=%#x, %.80q, %#x",
this, szUrlPath, ppBaseFileName
));
HRESULT hr = S_OK;
char szFullURL[INTERNET_MAX_URL_LENGTH];
DWORD dwLen = INTERNET_MAX_URL_LENGTH;
URL_COMPONENTS UrlComponents;
char *pBaseFileName = NULL;
dwLen = WideCharToMultiByte(CP_ACP, 0, GetURL(), -1,
szFullURL, INTERNET_MAX_URL_LENGTH, NULL, NULL);
memset(&UrlComponents, 0, sizeof(URL_COMPONENTS));
UrlComponents.dwStructSize = sizeof(URL_COMPONENTS);
UrlComponents.lpszUrlPath = szUrlPath;
UrlComponents.dwUrlPathLength = INTERNET_MAX_URL_LENGTH;
if (!InternetCrackUrl( szFullURL, 0,
ICU_DECODE, &UrlComponents)) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
Assert(UrlComponents.lpszUrlPath);
Assert(UrlComponents.dwUrlPathLength);
if ( !UrlComponents.dwUrlPathLength ||
!UrlComponents.lpszUrlPath ) {
hr = E_UNEXPECTED;
goto Exit;
}
if (ppBaseFileName)
GetExtnAndBaseFileName(szUrlPath, ppBaseFileName);
Exit:
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::SniffType
// ---------------------------------------------------------------------------
HRESULT CDownload::SniffType()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::SniffType",
"this=%#x",
this
));
HANDLE hFile = INVALID_HANDLE_VALUE;
HRESULT hr = S_OK;
DWORD dwSignature;
DWORD dwBytesRead = 0;
#define CAB_SIG 0x4643534d
if (GetExtn() != FILEXTN_CAB) {
if ( (hFile = CreateFile(GetFileName(), GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, 0)) == INVALID_HANDLE_VALUE) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
if ((ReadFile(hFile, &dwSignature, sizeof(DWORD), &dwBytesRead, NULL))
&& (dwSignature == CAB_SIG)) {
SetURLAndExtn(NULL, FILEXTN_CAB);
} else {
// here if its not a CAB
// check if of compatible type
hr = IsCompatibleFile(GetFileName());
}
}
Exit:
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::VerifyTrust
// ---------------------------------------------------------------------------
VOID CDownload::VerifyTrust()
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::VerifyTrust",
"this=%#x",
this
));
HANDLE hFile = INVALID_HANDLE_VALUE;
HRESULT hr = S_OK;
HWND hWnd = GetCodeDownload()->GetClientBinding()->GetHWND();
WCHAR szDisplayUrl[INTERNET_MAX_URL_LENGTH];
DWORD cchDisplayUrl = INTERNET_MAX_URL_LENGTH;
LPSTR szCatalogFile = NULL;
CUrlMkTls tls(hr); // hr passed by reference!
if (FAILED(hr)) // if tls ctor failed above
goto Exit;
if ( GetDLState() == DLSTATE_ABORT) {
hr = E_ABORT;
goto Exit;
}
// sniff file for detecting CAB extensions
// and if not CAB, assume PE and check if of compatible type
// before calling trust on it. The reason we presniff for
// compat is because it will make for better user experience to
// fail if not of correct binary before we present trust dialogs
hr = SniffType();
if (FAILED(hr))
goto Exit;
Assert(tls->pTrustCookie);
// need to serialize all trust verification on this thread
// grab the trust cookie
hr = tls->pTrustCookie->Acquire(this);
if (hr != S_OK) {
Assert(!tls->pTrustCookie->IsFree());
Assert(!tls->pTrustCookie->IsOwner(this));
DEBUG_LEAVE(0);
return; // wait till we get posted a message when the current owner
// relinquishes the cookie
}
// have the cookie
Assert(tls->pTrustCookie->IsOwner(this));
if ( (hFile = CreateFile(GetFileName(), GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, 0)) == INVALID_HANDLE_VALUE) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
}
// form friendly displayable URL (ie. decode) in browser mode
hr = UrlUnescapeW((LPWSTR)GetURL(), szDisplayUrl, &cchDisplayUrl, 0);
Assert(!GetCodeDownload()->IsSilentMode() || hWnd == INVALID_HANDLE_VALUE);
// Try to get a catalog file
szCatalogFile = GetCodeDownload()->GetCatalogFile();
hr = m_wvt.VerifyTrust(hFile, hWnd, &m_pbJavaTrust, szDisplayUrl,
GetCodeDownload()->GetClientBinding()->GetHostSecurityManager(),
(char *)GetFileName(), szCatalogFile, this);
if(SUCCEEDED(hr)) {
SetTrustVerified();
} else {
// trust failed on this file. Delete it from the cache for
// added safety.
// remove entry from cache only if we're not in silent mode.
// or we are in silent mode and the hr != TRUST_E_SUBJECT_NOT_TRUSTED
// when ui choice is NONE, WVT reurns the special error code to
// mean that all was OK but could not trust because we did not
// allow them to put up confirmation UI.
if (!GetCodeDownload()->IsSilentMode())
{
CHAR szURL[INTERNET_MAX_URL_LENGTH];
DWORD cchURL = INTERNET_MAX_URL_LENGTH;
WideCharToMultiByte(CP_ACP, 0, GetURL(), -1, szURL,
INTERNET_MAX_URL_LENGTH, 0,0);
// If we still have the file open when we call DeleteUrlCacheEntry, then
// WinInet won't be able to delete it. Having untrusted bits in the cache
// is dangerous.
if ( hFile != INVALID_HANDLE_VALUE)
{
CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
}
DeleteUrlCacheEntryA(szURL);
}
else
GetCodeDownload()->SetTrustSomeFailed();
}
Exit:
// reset status to resume the rest of download if we're in
// silent mode
if (GetCodeDownload()->IsSilentMode() && FAILED(hr) && (hr != E_ABORT))
hr = S_OK;
if (tls->pTrustCookie->IsOwner(this)) {
tls->pTrustCookie->Relinquish(this);
}
if (SUCCEEDED(hr)) {
CCDLPacket *pPkt= new CCDLPacket(CODE_DOWNLOAD_PROCESS_PIECE, this, 0);
if (pPkt) {
hr = pPkt->Post();
} else {
hr = E_OUTOFMEMORY;
}
}
if (FAILED(hr)) {
// does all the master state analysis
CompleteSignal(hr, S_OK, S_OK, NULL);
}
if ( hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
DEBUG_LEAVE(0);
return;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::SetCdlProtocol
// ---------------------------------------------------------------------------
HRESULT
CDownload::SetUsingCdlProtocol(LPWSTR wszDistUnit)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::SetUsingCdlProtocol",
"this=%#x, %.80wq",
this, wszDistUnit
));
HRESULT hr = S_OK;
m_wszDistUnit = new WCHAR [lstrlenW(wszDistUnit) + 1];
if (m_wszDistUnit)
StrCpyW(m_wszDistUnit, wszDistUnit);
else
hr = E_OUTOFMEMORY;
m_flags |= DL_FLAGS_CDL_PROTOCOL;
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::ExtractManifest()
// ---------------------------------------------------------------------------
HRESULT
CDownload::ExtractManifest(FILEXTN extn, LPSTR szFileName, LPSTR& pBaseFileName)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::ExtractManifest",
"this=%#x, %#x, %.80q, %#x",
this, extn, szFileName, &pBaseFileName
));
CCodeDownload *pcdl = GetCodeDownload();
char * pFileName;
PSESSION psess = NULL;
PFNAME pf = NULL;
HRESULT hr = S_FALSE; // assume not found
Assert(m_psess);
for (pf = m_psess->pFileList; pf != NULL; pf = pf->pNextName) {
FILEXTN curextn = ::GetExtnAndBaseFileName(pf->pszFilename,
&pBaseFileName);
if (( curextn == extn) &&
((szFileName[0] == '\0') ||
(lstrcmpi(szFileName, pBaseFileName) == 0))) {
FNAME fne;
memset(&fne, 0, sizeof(FNAME));
fne.pszFilename = pf->pszFilename;
// INF present in CAB, extract it and process it
m_psess->pFilesToExtract = &fne;
m_psess->flags &= ~SESSION_FLAG_ENUMERATE; // already enumerated
if (FAILED((hr=ExtractFromCabinet(m_psess, GetFileName()))))
goto Exit;
// side effect!
// if extract succeeds we also have set the return hr to S_OK.
// hr = S_OK;
m_psess->pFilesToExtract = NULL;
if (!catDirAndFile(szFileName, MAX_PATH, m_psess->achLocation,
pf->pszFilename)) {
hr = E_UNEXPECTED;
}
goto Exit;
}
}
Exit:
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::ProcessPiece
// CBSC::OnStopBinding calls us as soon as a piece gets downloaded
// and trust is verified.
// ie. this CDownload obj has completed binding
// Depending on the Content type we will process further
// 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
//
// ---------------------------------------------------------------------------
VOID
CDownload::ProcessPiece()
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::ProcessPiece",
"this=%#x",
this
));
CCodeDownload *pcdl = GetCodeDownload();
char * pFileName;
char *pBaseFileName;
PSESSION psess = NULL;
PFNAME pf = NULL;
HRESULT hr = S_OK; // assume all OK
CSetup *pSetup;
char szBuf[INTERNET_MAX_URL_LENGTH];
char szCatalogBuf[INTERNET_MAX_URL_LENGTH];
FILEXTN extn = m_extn;
if ( GetDLState() == DLSTATE_ABORT) {
hr = E_ABORT;
goto Exit;
}
//REVIEW: Virus scanning a CAB or INF file may not be a bright thing to do since
// they are not executable.
if (FAILED(hr = PerformVirusScan((char *)GetFileName()))) {
goto Exit;
}
switch (extn) {
case FILEXTN_EXE:
case FILEXTN_OCX:
case FILEXTN_DLL:
case FILEXTN_NONE:
case FILEXTN_UNKNOWN:
pSetup = GetSetupHead();
if (pSetup) {
// If a CSetup exists for this m_pdl then initialize its
// m_pSrcFileName using the m_pFileName
Assert(pSetup->GetNext() == NULL);
pSetup->SetSrcFileName(GetFileName());
} else {
if (!HasAllActiveXPermissions()) {
if (GetCodeDownload()->IsSilentMode())
{
GetCodeDownload()->SetBitsInCache();
}
hr = TRUST_E_FAIL;
goto Exit;
}
// If no CSetup exists then make one and attach it to the m_pdl
// initiated at top level
hr = GetFriendlyName(szBuf, &pBaseFileName);
if (pBaseFileName[0] == '\0') {
hr = E_UNEXPECTED; // No filename to setup!
goto Exit;
}
if (FAILED(hr)) {
goto Exit;
}
pSetup = new CSetup(GetFileName(), pBaseFileName, extn,
pcdl->GetDestDirHint(), &hr);
if (!pSetup) {
hr = E_OUTOFMEMORY;
goto Exit;
} else if (FAILED(hr)) {
delete pSetup;
goto Exit;
}
AddSetupToList(pSetup);
}
break;
case FILEXTN_CAB:
// if CAB then make SESSION for this CDownload
Assert(!(GetSession()));
psess = new SESSION;
if (!psess) {
hr = E_OUTOFMEMORY;
goto Exit;
}
SetSession(psess);
// Initialize the structure
psess->pFileList = NULL;
psess->cFiles = 0;
psess->cbCabSize = 0;
psess->flags = SESSION_FLAG_ENUMERATE;
// extract files in a CAB into a unique dir so that
// parallel downloads of CABs containing same name
// components can go on without conflict.
// By serailizing the setup phase we make sure the right
// latest version is finally left on client machine.
hr = MakeUniqueTempDirectory(g_szOCXTempDir, psess->achLocation, sizeof(psess->achLocation));
if (FAILED(hr)) {
goto Exit;
}
psess->pFilesToExtract = NULL; // just enumerate first
if (!pcdl->HaveManifest() || NeedToExtractAllFiles()) {
psess->flags |= SESSION_FLAG_EXTRACT_ALL;
}
// enumerate the files of the CAB
if (FAILED((hr = ExtractFromCabinet(psess, GetFileName()))))
goto Exit;
if (!pcdl->HaveManifest() || NeedToExtractAllFiles()) {
psess->flags |= SESSION_FLAG_EXTRACTED_ALL;
}
// if we don't have INF already look for one
if (!pcdl->HaveManifest()) {
// Extract catalog file
szCatalogBuf[0] = '\0';
if (ExtractManifest(FILEXTN_CAT, szCatalogBuf, pBaseFileName) == S_OK) {
if (FAILED(pcdl->SetCatalogFile(szCatalogBuf))) {
goto Exit;
}
}
szBuf[0] = '\0';
hr = ExtractManifest(FILEXTN_OSD , szBuf, pBaseFileName);
if (FAILED(hr))
goto Exit;
if (hr == S_FALSE) {
szBuf[0] = '\0';
// if no dist unit profile, process old INF
hr = ExtractManifest(FILEXTN_INF , szBuf, pBaseFileName);
if (FAILED(hr))
goto Exit;
if (hr == S_OK) {
hr=pcdl->SetupInf(szBuf, pBaseFileName, this);
goto Exit;
}
} else {
// process dist unit profile
hr=pcdl->ParseOSD(szBuf, pBaseFileName, this);
goto Exit;
}
if (!pcdl->HaveManifest()) { // still don't have an INF?
if (!HasAllActiveXPermissions()) {
if (GetCodeDownload()->IsSilentMode())
{
GetCodeDownload()->SetBitsInCache();
}
hr = TRUST_E_FAIL;
goto Exit;
}
// only valid case at this point is
// case where we have a CAB file with ONE file in it
if (psess->cFiles != 1) {
hr = E_INVALIDARG;
goto Exit;
}
pf = psess->pFilesToExtract = psess->pFileList;
psess->flags &= ~SESSION_FLAG_ENUMERATE; // already enumerated
if (FAILED((hr=ExtractFromCabinet(psess, GetFileName()))))
goto Exit;
extn = GetExtnAndBaseFileName(pf->pszFilename, &pBaseFileName);
if (!catDirAndFile(szBuf, MAX_PATH, psess->achLocation,
pf->pszFilename)) {
hr = E_UNEXPECTED;
goto Exit;
}
psess->pFilesToExtract = NULL;
pSetup = new CSetup(szBuf, pBaseFileName, extn,
pcdl->GetDestDirHint(), &hr);
if (!pSetup) {
hr = E_OUTOFMEMORY;
goto Exit;
} else if (FAILED(hr)) {
delete pSetup;
goto Exit;
}
AddSetupToList(pSetup);
}
} else { /* have inf */
// INF processor would have made Csetup already
psess->pFilesToExtract = GetFilesToExtract();
if (!psess->pFilesToExtract) {
// no files to extract, means there was only a hook
// in this CAB and no other particular files
// the general code downloader is looking for
// so no setup work either.
Assert(NeedToExtractAllFiles());
break;
}
psess->flags &= ~SESSION_FLAG_ENUMERATE; // already enumerated
CSetup *pSetupCur = m_pSetuphead;
Assert(m_pSetuphead);
// set fully qual names for all of these
for (; pSetupCur; pSetupCur = pSetupCur->GetNext()) {
if (!catDirAndFile(szBuf, MAX_PATH, m_psess->achLocation,
(LPSTR)pSetupCur->GetSrcFileName())) {
hr = E_UNEXPECTED;
goto Exit;
}
pSetupCur->SetSrcFileName(szBuf);
}
if (FAILED((hr=ExtractFromCabinet(psess, GetFileName()))))
goto Exit;
}
break;
case FILEXTN_INF:
if(pcdl->HaveManifest()) {
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
goto Exit;
}
hr = GetFriendlyName(szBuf, &pBaseFileName);
if (FAILED(hr)) {
goto Exit;
}
// get friendly name for INF from URL
hr=pcdl->SetupInf(GetFileName(), pBaseFileName, this);
if (FAILED(hr)) {
SetDLState(DLSTATE_DONE);
}
goto Exit;
case FILEXTN_OSD:
if(pcdl->HaveManifest()) {
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
goto Exit;
}
hr = GetFriendlyName(szBuf, &pBaseFileName);
if (FAILED(hr)) {
goto Exit;
}
// get friendly name for OSD from URL
hr=pcdl->ParseOSD(GetFileName(), pBaseFileName, this);
goto Exit;
} /* end switch (extn) */
// done with this CDownload. Mark it ready for setup
SetDLState(DLSTATE_READY_TO_SETUP);
Assert(SUCCEEDED(hr));
Exit:
if ( (FAILED(hr)) || (GetDLState() == DLSTATE_READY_TO_SETUP)) {
CompleteSignal(hr, S_OK, S_OK, NULL);
}
// if success setupInf would have dispatched a msg for
// INF processing and only when that completes this
// CDownload is deemed completed/ready_to_setup
DEBUG_LEAVE(0);
return;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::SetURLAndExnt(LPCWSTR szURL, FILEXTN extn);
// ---------------------------------------------------------------------------
HRESULT
CDownload::SetURLAndExtn(LPCWSTR szURL, FILEXTN extn)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::ProcessPiece",
"this=%#x, %.80wq, %#x",
this, szURL, extn
));
m_extn = extn;
if (!szURL)
{
DEBUG_LEAVE(S_OK);
return S_OK;
}
DWORD len = lstrlenW(szURL); // make private copy
LPWSTR lpch = new WCHAR [len + 1];
if (!lpch)
{
DEBUG_LEAVE(E_OUTOFMEMORY);
return E_OUTOFMEMORY;
}
StrCpyW(lpch, szURL);
if (m_url)
SAFEDELETE(m_url);
m_url = lpch;
DEBUG_LEAVE(S_OK);
return S_OK;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::CheckForNameCollision(LPCSTR szCacheDir);
// for each in list CSetup::CheckForNameCollision
// ---------------------------------------------------------------------------
HRESULT
CDownload::CheckForNameCollision(LPCSTR szCacheDir)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::CheckForNameCollision",
"this=%#x, %.80q",
this, szCacheDir
));
CSetup *pSetupCur = m_pSetuphead;
HRESULT hr = S_OK;
for (pSetupCur = m_pSetuphead; pSetupCur; pSetupCur =pSetupCur->GetNext()) {
if ((hr=pSetupCur->CheckForNameCollision(GetCodeDownload(), szCacheDir)) == S_FALSE)
break;
}
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::FindJavaSetup
// ---------------------------------------------------------------------------
CJavaSetup*
CDownload::FindJavaSetup(LPCWSTR szPackageName)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Pointer,
"CDownload::FindJavaSetup",
"this=%#x, %.80wq",
this, szPackageName
));
HRESULT hr = S_OK;
CJavaSetup *pjs = NULL;
if (!szPackageName)
{
DEBUG_LEAVE(NULL);
return NULL;
}
int iNumJavaSetup = m_JavaSetupList.GetCount();
LISTPOSITION curpos = m_JavaSetupList.GetHeadPosition();
for (int i=0; i < iNumJavaSetup; i++) {
pjs = m_JavaSetupList.GetNext(curpos);
if (pjs->GetPackageName() && (StrCmpIW(szPackageName, pjs->GetPackageName()) == 0)) {
DEBUG_LEAVE(pjs);
return pjs;
}
}
DEBUG_LEAVE(NULL);
return NULL;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::FindHook
// ---------------------------------------------------------------------------
CSetupHook*
CDownload::FindHook(LPCSTR szHook)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Pointer,
"CDownload::FindHook",
"this=%#x, %.80q",
this, szHook
));
HRESULT hr = S_OK;
CSetupHook *psh = NULL;
if (!szHook)
{
DEBUG_LEAVE(NULL);
return NULL;
}
int iNumHooks = m_SetupHooks.GetCount();
LISTPOSITION curpos = m_SetupHooks.GetHeadPosition();
for (int i=0; i < iNumHooks; i++) {
psh = m_SetupHooks.GetNext(curpos);
if (psh->GetHookName() && (lstrcmpi(szHook, psh->GetHookName()) == 0)) {
DEBUG_LEAVE(psh);
return psh;
}
}
DEBUG_LEAVE(NULL);
return NULL;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::DoSetup
// ---------------------------------------------------------------------------
HRESULT
CDownload::DoSetup()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::DoSetup",
"this=%#x",
this
));
CSetup *pSetupCur = m_pSetuphead;
HRESULT hr = S_OK;
int nSetupsPerCall = 0;
int iNumHooks,i;
POSITION curpos;
SetDLState(DLSTATE_SETUP);
// SILENT MODE
// determine if we're in silent mode
if (GetCodeDownload()->IsSilentMode() && !GetCodeDownload()->IsAllTrusted())
{
SetDLState(DLSTATE_DONE);
DEBUG_LEAVE(hr);
return hr;
}
if (m_JavaSetupList.GetCount() != 0) {
CJavaSetup *pjs = m_JavaSetupList.GetHead();
curpos = m_JavaSetupList.GetHeadPosition();
BOOL bInstallReqd = FALSE;
if (pjs != NULL) {
for (int i=0; i< m_JavaSetupList.GetCount(); i++) {
CJavaSetup *pjs = m_JavaSetupList.GetNext(curpos);
Assert(pjs != NULL);
if (pjs->GetState() != INSTALL_DONE) {
bInstallReqd = TRUE;
break;
}
}
if (bInstallReqd) {
Assert(HasJavaPermissions());
// the below check is our final security test
// we should never need to test this in retail
// but, we do anyway
if (HasJavaPermissions())
hr = pjs->DoSetup();
else
hr = TRUST_E_FAIL;
if (FAILED(hr))
goto Exit;
else
{
DEBUG_LEAVE(S_OK);
return S_OK;
}
}
}
}
// done processing Java Setups
// process all hooks
iNumHooks = m_SetupHooks.GetCount();
curpos = m_SetupHooks.GetHeadPosition();
for (i=0; i < iNumHooks; i++) {
CSetupHook *psh = m_SetupHooks.GetNext(curpos);
if (psh->GetState() == INSTALL_DONE)
continue;
if (nSetupsPerCall++) {
// here if we have already done 1 hook and there's more to
// do in this CDownload
// we don't set DLState to DONE and just return
DEBUG_LEAVE(S_OK);
return S_OK;
}
Assert(HasAllActiveXPermissions());
// the below check is our final security test
// we should never need to test this in retail
// but, we do anyway
if (HasAllActiveXPermissions())
hr=psh->Run();
else
hr = TRUST_E_FAIL;
if (FAILED(hr))
goto Exit;
if (psh->GetState() != INSTALL_DONE) {
// more work left in this setup hook
// wait for next msg, don't mark ourselves done yet.
DEBUG_LEAVE(S_OK);
return S_OK;
}
}
// processed all Java Setups, hooks, now run setups
for (pSetupCur = m_pSetuphead; pSetupCur; pSetupCur = pSetupCur->GetNext()) {
if (pSetupCur->GetState() == INSTALL_DONE)
continue;
if (nSetupsPerCall++) {
// here if we have already done 1 setup and there's more to
// do in this CDownload
// we don't set DLState to DONE and just return
DEBUG_LEAVE(S_OK);
return S_OK;
}
if (m_bExactVersion) {
pSetupCur->SetExactVersion(TRUE);
}
if (pSetupCur->GetExtn() == FILEXTN_OSD) {
hr=pSetupCur->DoSetup(GetCodeDownload(), this);
} else {
Assert(HasAllActiveXPermissions());
// the below check is our final security test
// we should never need to test this in retail
// but, we do anyway
if (HasAllActiveXPermissions())
hr=pSetupCur->DoSetup(GetCodeDownload(), this);
else
hr = TRUST_E_FAIL;
}
if (FAILED(hr))
break;
if (pSetupCur->GetState() != INSTALL_DONE) {
// more work left in this CSetup (pSetupCur)
// wait for next msg, don't mark ourselves done yet.
DEBUG_LEAVE(S_OK);
return S_OK;
}
} /* for each CSetup */
Exit:
SetDLState(DLSTATE_DONE);
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::AddJavaSetup
//
// create and add a new JavaSetup to the list of setup hooks in this cab
// ---------------------------------------------------------------------------
HRESULT
CDownload::AddJavaSetup(
LPCWSTR szPackageName,
LPCWSTR szNameSpace,
IXMLElement *pPackage,
DWORD dwVersionMS,
DWORD dwVersionLS,
DWORD flags)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::AddJavaSetup",
"this=%#x, %.80wq, %.80wq, %#x, %#x, %#x, %#x",
this, szPackageName, szNameSpace, pPackage, dwVersionMS, dwVersionLS, flags
));
HRESULT hr = S_OK;
CJavaSetup *pJavaSetup = NULL;
if (GetCodeDownload()->IsDuplicateJavaSetup(szPackageName) == S_OK) {
goto Exit;
}
// create a CJavaSetup OBJ and add it to the CDownload obj
pJavaSetup = new CJavaSetup(this, szPackageName, szNameSpace, pPackage, dwVersionMS, dwVersionLS, flags, &hr);
if(!pJavaSetup) {
hr = E_OUTOFMEMORY;
}
if (FAILED(hr)) {
SAFEDELETE(pJavaSetup);
goto Exit;
}
m_JavaSetupList.AddTail(pJavaSetup);
Exit:
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::AddHook
//
// create and add a new hook to the list of setup hooks in this cab
// ---------------------------------------------------------------------------
HRESULT
CDownload::AddHook(
LPCSTR szHook,
LPCSTR szInf,
LPCSTR szInfSection,
DWORD flags)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::AddHook",
"this=%#x, %.80wq, %.80wq, %.80wq, %#x",
this, szHook, szInf, szInfSection, flags
));
HRESULT hr = S_OK;
CSetupHook *psh;
Assert(m_state != DLSTATE_EXTRACTING);
if (GetCodeDownload()->IsDuplicateHook(szHook) == S_OK) {
goto Exit;
}
if (m_extn == FILEXTN_CAB) { // if a CAB
if (m_state > DLSTATE_DOWNLOADED) {
// this CAB is ready, extract this code first
// BUGBUG: multi-threading issue: we are relying on
// not being re-enterant in our extraction
Assert(m_psess);
if (!m_psess) {
hr = E_UNEXPECTED;
goto Exit;
}
if (!(m_psess->flags & SESSION_FLAG_EXTRACTED_ALL)) {
m_psess->pFilesToExtract = NULL;
m_psess->flags &= ~SESSION_FLAG_ENUMERATE; // already enumerated
m_psess->flags |= SESSION_FLAG_EXTRACT_ALL;
if (FAILED((hr = ExtractFromCabinet(m_psess, m_pFileName)))) {
goto Exit;
}
m_psess->flags |= SESSION_FLAG_EXTRACTED_ALL;
}
} else {
// newly initiated download, mark CDownload as extract all.
SetNeedToExtractAll();
}
}
psh = new CSetupHook(this, szHook, szInf, szInfSection, flags, &hr);
if (psh && SUCCEEDED(hr)) {
m_SetupHooks.AddTail(psh);
} else {
if (psh)
delete psh;
hr = E_OUTOFMEMORY;
}
Exit:
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::AddSetupToExistingCAB
// if CAB is already downloaded
// extract file; create CSetup to install it (piggy back to pdl)
// else if some other CAB that has been set for download
// attach file to be extracted to pFilesToExtract
// attach a CSetup for this file
// else
// ---------------------------------------------------------------------------
HRESULT
CDownload::AddSetupToExistingCAB(char * lpCode, const char * szDestDir, DESTINATION_DIR dest, DWORD dwRegisterServer, DWORD dwCopyFlags)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::AddSetupToExistingCAB",
"this=%#x, %.80q, %.80q, %#x, %#x, %#x",
this, lpCode, szDestDir, dest, dwRegisterServer, dwCopyFlags
));
char *pBaseFileName = lpCode;
FILEXTN extn;
HRESULT hr = NO_ERROR;
CSetup* pSetup = NULL;
char szBuf[MAX_PATH];
Assert(lpCode);
if (!lpCode) {
hr = E_INVALIDARG;
goto Exit;
}
if (IsDuplicateSetup(lpCode))
goto Exit;
// assumes that both CAB extraction and download
// are into same temp dir
// make a name for extraction ie: tempdir\curcode
extn = GetExtnAndBaseFileName( lpCode, &pBaseFileName);
// this check is totally legit : ie no race condition here
// we are on the main wininet thread and all onstopbindgs get
// posted on this thread. So a newly initialted download could not
// have completed, and even if so CAB extraction could not have started
Assert(m_state != DLSTATE_EXTRACTING);
Assert(m_state != DLSTATE_SETUP);
Assert(m_state != DLSTATE_DONE);
if (m_state > DLSTATE_DOWNLOADED) {
// part of CAB that the INF is in,
// or part of a CAB of some other code download that matches our spec.
// extract this code first
Assert(m_psess);
if (!m_psess) {
hr = E_UNEXPECTED;
goto Exit;
}
FNAME fname;
fname.pszFilename = pBaseFileName;
fname.pNextName = NULL;
fname.status = SFNAME_INIT;
m_psess->pFilesToExtract = &fname;
m_psess->flags &= ~SESSION_FLAG_ENUMERATE; // already enumerated
if (FAILED((hr = ExtractFromCabinet(m_psess, m_pFileName)))) {
goto Exit;
}
m_psess->pFilesToExtract = NULL;
} else {
// newly initiated download, piggy back to end of extraction list
PFNAME pf = new FNAME;
if (!pf) {
hr = E_OUTOFMEMORY;
goto Exit;
}
pf->pszFilename = new char [lstrlen(pBaseFileName)+1];
if (!pf->pszFilename) {
delete pf;
hr = E_OUTOFMEMORY;
goto Exit;
}
lstrcpy(pf->pszFilename, pBaseFileName);
pf->status = SFNAME_INIT;
pf->pNextName = m_pFilesToExtract; // add to list
m_pFilesToExtract = pf;
}
if (!catDirAndFile(szBuf, MAX_PATH,
(m_psess)?m_psess->achLocation:NULL, pBaseFileName)) {
hr = E_UNEXPECTED;
goto Exit;
}
// create a CSetup OBJ and add it to us
pSetup = new CSetup(szBuf, pBaseFileName, extn, szDestDir, &hr, dest);
if (!pSetup) {
hr = E_OUTOFMEMORY;
goto Exit;
} else if (FAILED(hr)) {
delete pSetup;
goto Exit;
}
AddSetupToList(pSetup);
pSetup->SetCopyFlags (dwCopyFlags);
if (dwRegisterServer) {
pSetup->SetUserOverrideRegisterServer(dwRegisterServer&CST_FLAG_REGISTERSERVER);
}
Exit:
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::IsDuplicateSetup
// ---------------------------------------------------------------------------
BOOL
CDownload::IsDuplicateSetup(LPCSTR pBaseFileName)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Bool,
"CDownload::IsDuplicateSetup",
"this=%#x, %.80q",
this, pBaseFileName
));
CSetup *pSetupCur = m_pSetuphead;
for (pSetupCur = m_pSetuphead; pSetupCur; pSetupCur=pSetupCur->GetNext()) {
if (lstrcmpi(pBaseFileName, pSetupCur->GetBaseFileName()) == 0)
{
DEBUG_LEAVE(TRUE);
return TRUE;
}
}
DEBUG_LEAVE(FALSE);
return FALSE;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::AddSetupToList
// ---------------------------------------------------------------------------
VOID
CDownload::AddSetupToList(CSetup *pSetup)
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::AddSetupToList",
"this=%#x, %#x",
this, pSetup
));
pSetup->SetNext(m_pSetuphead);
m_pSetuphead = pSetup;
DEBUG_LEAVE(0);
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::RemoveSetupFromList
// ---------------------------------------------------------------------------
HRESULT
CDownload::RemoveSetupFromList(CSetup *pSetup)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::RemoveSetupFromList",
"this=%#x, %#x",
this, pSetup
));
CSetup *pSetupCur = m_pSetuphead;
HRESULT hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
Assert(pSetup);
Assert(pSetupCur); // empty list?
if (pSetupCur == pSetup) {
m_pSetuphead = pSetup->GetNext();
hr = S_OK;
goto Exit;
}
do {
if (pSetupCur->GetNext() == pSetup) {
pSetupCur->SetNext(pSetup->GetNext());
hr = S_OK;
goto Exit;
}
} while ( (pSetupCur = pSetupCur->GetNext()));
Exit:
DEBUG_LEAVE(hr);
return hr; // not found in list!
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::CleanupFiles
// ---------------------------------------------------------------------------
HRESULT
CDownload::CleanupFiles()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::CleanupFiles",
"this=%#x",
this
));
if (m_psess) { // CAB?
DeleteExtractedFiles(m_psess);
RemoveDirectoryAndChildren(m_psess->achLocation);
SAFEDELETE(m_psess);
}
if (!m_pSetuphead) {
if (m_pFileName) {
delete (LPSTR)m_pFileName;
m_pFileName = NULL;
}
} else {
CSetup *pSetupCur = m_pSetuphead;
CSetup *pSetupNext;
for (pSetupCur = m_pSetuphead; pSetupCur;
pSetupCur = pSetupNext) {
pSetupNext = pSetupCur->GetNext();
SAFEDELETE(pSetupCur);
}
}
if (m_pUnkForCacheFileRelease)
SAFERELEASE(m_pUnkForCacheFileRelease);
DEBUG_LEAVE(S_OK);
return S_OK;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::DoDownload
// 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.
//
// ---------------------------------------------------------------------------
HRESULT
CDownload::DoDownload(LPMONIKER *ppmkContext, DWORD grfBINDF,
CList<CCodeBaseHold *, CCodeBaseHold *> *pcbhList)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::DoDownload",
"this=%#x, %#x, %#x, %#x",
this, ppmkContext, grfBINDF, pcbhList
));
HRESULT hr = NOERROR;
IBindHost *pBindHost = NULL;
m_pcbhList = pcbhList;
m_ppmkContext = ppmkContext;
m_grfBINDF = grfBINDF;
pBindHost = GetCodeDownload()->GetClientBinding()->GetIBindHost();
hr = CreateBindCtx(0, &m_pbc);
if (FAILED(hr)) {
goto Exit;
}
// register the format enumerator with the bind ctx if one exists
if (g_pEFmtETC) {
hr = RegisterFormatEnumerator(m_pbc, g_pEFmtETC, 0);
}
if( SUCCEEDED(hr) ) {
m_pbsc = new CBindStatusCallback(this, grfBINDF);
if (m_pbsc == NULL)
hr = E_OUTOFMEMORY;
if (!pBindHost)
if (SUCCEEDED(hr))
hr = RegisterBindStatusCallback(m_pbc, m_pbsc, 0, 0);
}
if (FAILED(hr)) {
goto Exit;
}
if (pBindHost) {
IMoniker *pmk;
hr = pBindHost->CreateMoniker(m_url, m_pbc, &pmk, 0);
if (FAILED(hr)) {
goto Exit;
}
if (*ppmkContext == NULL) { // no context moniker yet?
m_pmk = pmk;
m_ppmkContext = &pmk;
} else {
hr = (*ppmkContext)->ComposeWith(pmk, FALSE, &m_pmk);
pmk->Release();
}
} else {
hr = CreateURLMoniker(*ppmkContext, m_url, &m_pmk);
}
if( SUCCEEDED(hr) ) {
// store away the full URL
SAFEDELETE(m_url);
hr = m_pmk->GetDisplayName(m_pbc, NULL, &m_url);
if (FAILED(hr))
goto Exit;
// everything succeeded
if (*ppmkContext == NULL) { // no context moniker yet?
// make this the context moniker
*ppmkContext = m_pmk;
}
IUnknown *pUnk = NULL;
if (pBindHost) {
hr = pBindHost->MonikerBindToStorage(m_pmk, m_pbc, m_pbsc,
IID_IUnknown, (void **)&pUnk);
} else {
hr = m_pmk->BindToStorage(m_pbc, 0, IID_IUnknown, (void**)&pUnk);
}
// m_pbc will get the onstopbinding, ondatavailable, and onprogress
// messages and pass them on to m_pbsc; wait asynchronously
if (pUnk) {
pUnk->Release();
}
}
Exit:
if (FAILED(hr) && hr != E_PENDING) {
// real failure!
m_hrOSB = hr;
SetDLState(DLSTATE_DONE);
if (*ppmkContext == m_pmk)
*ppmkContext = NULL;
}
else {
/*
// everything succeeded
if (*ppmkContext == NULL) { // no context moniker yet?
// make this the context moniker
*ppmkContext = m_pmk;
}
*/
hr = MK_S_ASYNCHRONOUS;
}
DEBUG_LEAVE(hr);
return hr;
} // CDownload::DoDownload
// ---------------------------------------------------------------------------
// %%Function: CDownload::PerformVirusScan
// S_OK : continue with operation
// S_FALSE : cancel operation.
// ---------------------------------------------------------------------------
HRESULT CDownload::PerformVirusScan(LPSTR szFileName)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::PerformVirusScan",
"this=%#x, %.80q",
this, szFileName
));
HRESULT hr = S_OK, hrReturn = S_OK;
ICatInformation * pci = NULL; // category manager
IEnumCLSID * peclsid = NULL; // enum of av objects
IOfficeAntiVirus * poav = NULL; // current av interface
CLSID clsidCurrent; // current av clsid
ULONG pcFetched;
MSOAVINFO msavi; // antivirus struct
BOOL fInitStruct = FALSE;
//
// Get COM category manager and get an enumerator for our virus
// scanner category
//
// If something goes wrong finding AV objects, proceed as normal.
//
hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL,
CLSCTX_INPROC_SERVER, IID_ICatInformation, (void **)&pci);
if(FAILED(hr))
{
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
hr = pci->EnumClassesOfCategories(1, (GUID *)&CATID_MSOfficeAntiVirus, 0, NULL, &peclsid);
pci->Release();
if(FAILED(hr))
{
DEBUG_LEAVE(NOERROR);
return NOERROR;
}
//
// Call all scanners. If any fail, return E_FAIL.
//
hr = peclsid->Next(1, &clsidCurrent, &pcFetched);
while(SUCCEEDED(hr) && pcFetched > 0)
{
if(FALSE == fInitStruct)
{
if (FAILED(Ansi2Unicode(szFileName,&msavi.u.pwzFullPath)))
{
break;
}
msavi.cbsize = sizeof(msavi);
msavi.fPath = TRUE;
msavi.fHttpDownload = TRUE;
msavi.fReadOnlyRequest = FALSE;
msavi.fInstalled = FALSE;
msavi.hwnd = GetCodeDownload()->GetClientBinding()->GetHWND();
msavi.pwzOrigURL = (LPWSTR)GetURL();
// per office spec, this is only meant as a method for the scanner
// to differentiate the caller. Not localized.
msavi.pwzHostName = L"Urlmon";
fInitStruct = TRUE;
}
// have clsid of av component
hr = CoCreateInstance(clsidCurrent, NULL, CLSCTX_INPROC_SERVER,
IID_IOfficeAntiVirus, (void **)&poav);
if(SUCCEEDED(hr))
{
// call scan method
hr = poav->Scan(&msavi);
poav->Release();
if(hr == E_FAIL)
{
// file could not be cleaned
hrReturn = E_FAIL;
}
}
hr = peclsid->Next(1, &clsidCurrent, &pcFetched);
}
//
// clean up
//
peclsid->Release();
if(fInitStruct)
{
SAFEDELETE(msavi.u.pwzFullPath);
}
DEBUG_LEAVE(hrReturn);
return hrReturn;
}
// ---------------------------------------------------------------------------
// %%Function: CDownload::DownloadRedundantCodeBase()
// Returns S_OK if starting next download, or S_FALSE if no redundant
// codebases remaining to try.
// ---------------------------------------------------------------------------
STDMETHODIMP CDownload::DownloadRedundantCodeBase()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CDownload::DownloadRedundantCodeBase",
"this=%#x",
this
));
HRESULT hr = S_FALSE;
LISTPOSITION lpos = 0;
CCodeBaseHold *pcbh = NULL;
if (m_pcbhList == NULL) {
goto Exit;
}
lpos = m_pcbhList->GetHeadPosition();
while (lpos) {
pcbh = m_pcbhList->GetNext(lpos);
if (!(pcbh->dwFlags & CBH_FLAGS_DOWNLOADED)) {
RevokeBindStatusCallback(GetBindCtx(), GetBSC());
CleanUp();
m_url = new WCHAR[lstrlenW(pcbh->wszCodeBase) + 1];
if (m_url == NULL) {
hr = E_OUTOFMEMORY;
goto Exit;
}
StrCpyW(m_url, pcbh->wszCodeBase);
SetResponseHeaderStatus(S_OK);
pcbh->dwFlags |= CBH_FLAGS_DOWNLOADED;
// Try another download
hr = DoDownload(m_ppmkContext, m_grfBINDF, m_pcbhList);
break;
}
}
Exit:
if (hr == S_FALSE) {
GetCodeDownload()->CodeDownloadDebugOut(DEB_CODEDL, FALSE, ID_CDLDBG_DL_REDUNDANT_FAILED);
}
else {
LPSTR szUrl = NULL;
Unicode2Ansi(m_url, &szUrl);
GetCodeDownload()->CodeDownloadDebugOut(DEB_CODEDL, FALSE, ID_CDLDBG_DL_REDUNDANT, (szUrl == NULL) ? ("") : (szUrl), hr);
delete szUrl;
}
DEBUG_LEAVE(hr);
return hr;
}
void CDownload::CleanUp()
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::CleanUp",
"this=%#x",
this
));
LISTPOSITION pos = 0;
int i, iNum;
SAFERELEASE(m_pmk);
SAFERELEASE(m_pbc);
SAFERELEASE(m_pbsc);
SAFEDELETE(m_url);
if (m_pFilesToExtract) {
PFNAME pf = m_pFilesToExtract;
PFNAME pfnext;
for (;pf != NULL; pf = pfnext) {
delete pf->pszFilename;
pfnext = pf->pNextName;
delete pf;
}
}
m_pFilesToExtract = NULL;
if (m_hPostData)
GlobalFree(m_hPostData);
SAFERELEASE(m_pUnkForCacheFileRelease);
SAFEDELETE(m_pbJavaTrust);
DEBUG_LEAVE(0);
}
HRESULT CDownload::SetMainCABJavaTrustPermissions(PJAVA_TRUST pbJavaTrust)
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CDownload::SetMainCABJavaTrustPermissions",
"this=%#x, %#x",
this, pbJavaTrust
));
HRESULT hr = GetCodeDownload()->SetMainCABJavaTrustPermissions(pbJavaTrust);
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::CBindStatusCallback
// The BSC implementation for CDownload to track progress of indiv dwlds
// ---------------------------------------------------------------------------
CBindStatusCallback::CBindStatusCallback(CDownload *pdl, DWORD grfBINDF)
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CBindStatusCallback::CBindStatusCallback",
"this=%#x, %#x, %#x",
this, pdl, grfBINDF
));
DllAddRef();
m_pbinding = NULL;
m_cRef = 1; // equ of internal addref
m_pdl = pdl;
m_grfBINDF = grfBINDF;
DEBUG_LEAVE(0);
} // CBindStatusCallback
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::~CBindStatusCallback
// ---------------------------------------------------------------------------
CBindStatusCallback::~CBindStatusCallback()
{
DEBUG_ENTER((DBG_DOWNLOAD,
None,
"CBindStatusCallback::~CBindStatusCallback",
"this=%#x",
this
));
SAFERELEASE(m_pbinding);
DllRelease();
DEBUG_LEAVE(0);
} // ~CBindStatusCallback
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::AddRef
// ---------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CBindStatusCallback::AddRef()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Dword,
"CBindStatusCallback::IUnknown::AddRef",
"this=%#x",
this
));
ULONG ulRet = m_cRef++;
DEBUG_LEAVE(ulRet);
return ulRet;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::Release
// ---------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CBindStatusCallback::Release()
{
DEBUG_ENTER((DBG_DOWNLOAD,
Dword,
"CBindStatusCallback::IUnknown::Release",
"this=%#x",
this
));
if (--m_cRef == 0) {
delete this;
DEBUG_LEAVE(0);
return 0;
}
DEBUG_LEAVE(m_cRef);
return m_cRef;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::QueryInterface
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::QueryInterface(REFIID riid, void** ppv)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IUnknown::QueryInterface",
"this=%#x, %#x, %#x",
this, &riid, ppv
));
*ppv = NULL;
if (riid==IID_IUnknown || riid==IID_IBindStatusCallback)
*ppv = (IBindStatusCallback *)this;
if (riid==IID_IHttpNegotiate)
*ppv = (IHttpNegotiate *)this;
if (riid==IID_IWindowForBindingUI)
*ppv = (IWindowForBindingUI*)this;
if (riid==IID_IServiceProvider)
*ppv = (IServiceProvider *)this;
if (riid==IID_ICatalogFileInfo)
*ppv = (ICatalogFileInfo *)this;
if (*ppv == NULL)
{
DEBUG_LEAVE(E_NOINTERFACE);
return E_NOINTERFACE;
}
AddRef();
DEBUG_LEAVE(S_OK);
return S_OK;
} // CBindStatusCallback::QueryInterface
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::GetWindow
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::GetWindow(REFGUID rguidreason, HWND *phWnd)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IWindowForBindingUI::GetWindow",
"this=%#x, %#x, %#x",
this, &rguidreason, phWnd
));
HRESULT hr = S_OK;
CCodeDownload *pcdl = m_pdl->GetCodeDownload();
HWND hWnd = pcdl->GetClientBinding()->GetHWND(rguidreason);
if (hWnd == INVALID_HANDLE_VALUE)
hr = S_FALSE;
*phWnd = hWnd;
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::QueryService
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::QueryService(REFGUID guidService, REFIID riid, LPVOID *ppv)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IServiceProvider::QueryService",
"this=%#x, %#x, %#x, %#x",
this, &guidService, &riid, ppv
));
IBindStatusCallback *pbsc = m_pdl->GetCodeDownload()->GetClientBSC();
IServiceProvider *psp = NULL;
HRESULT hr = E_NOINTERFACE;
ASSERT(pbsc);
if (pbsc && SUCCEEDED(pbsc->QueryInterface(IID_IServiceProvider, (void **)&psp)) && psp) {
hr = psp->QueryService(guidService, riid, ppv);
SAFERELEASE(psp);
}
// Since this is QueryService we can QI on our client's BSC object too.
if (FAILED(hr)) {
// This is special case we handle so we can bind to client's ultimate IBindHost
// if one exists. BUG BUG: Support other interfaces here, in general?
// BUG BUG: Rearrange order of comparisons for performance.
if (IsEqualGUID(guidService, riid) &&
(IsEqualGUID(riid, IID_IBindHost) ||
IsEqualGUID(riid, IID_IWindowForBindingUI) ||
IsEqualGUID(riid, IID_ICodeInstall) ||
IsEqualGUID(riid, IID_ICatalogFileInfo) ||
IsEqualGUID(riid, IID_IInternetHostSecurityManager))) {
hr = pbsc->QueryInterface(riid, (void **)ppv);
}
}
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::GetBindInfo
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindInfo)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::GetBindInfo",
"this=%#x, %#x, %#x",
this, pgrfBINDF, pbindInfo
));
if ((pgrfBINDF == NULL) || (pbindInfo == NULL) || (pbindInfo->cbSize == 0))
{
DEBUG_LEAVE(E_INVALIDARG);
return E_INVALIDARG;
}
*pgrfBINDF = m_grfBINDF;
// clear BINDINFO but keep its size
DWORD cbSize = pbindInfo->cbSize;
ZeroMemory( pbindInfo, cbSize );
pbindInfo->cbSize = cbSize;
// use IE5's utf-8 policy
pbindInfo->dwOptions |= BINDINFO_OPTIONS_USE_IE_ENCODING;
if (m_pdl->DoPost()) {
pbindInfo->dwBindVerb = BINDVERB_POST;
pbindInfo->stgmedData.tymed = TYMED_HGLOBAL;
pbindInfo->stgmedData.hGlobal = m_pdl->GetPostData(&(pbindInfo->cbstgmedData));
pbindInfo->stgmedData.pUnkForRelease = (IUnknown *) (IBindStatusCallback *) this;
AddRef(); // AddRef ourselves so we stick around; caller must release!
}
DWORD grfBINDF = 0;
BINDINFO bindInfo;
memset(&bindInfo, 0, sizeof(BINDINFO));
bindInfo.cbSize = sizeof(BINDINFO);
CCodeDownload *pcdl = m_pdl->GetCodeDownload();
pcdl->GetClientBSC()->GetBindInfo(&grfBINDF, &bindInfo);
if (grfBINDF & BINDF_SILENTOPERATION)
{
*pgrfBINDF |= BINDF_SILENTOPERATION;
pcdl->SetSilentMode();
}
if (grfBINDF & BINDF_OFFLINEOPERATION)
*pgrfBINDF |= BINDF_OFFLINEOPERATION;
if (grfBINDF & BINDF_GETNEWESTVERSION)
*pgrfBINDF |= BINDF_GETNEWESTVERSION;
if (grfBINDF & BINDF_RESYNCHRONIZE)
*pgrfBINDF |= BINDF_RESYNCHRONIZE;
// or should we always insist on this regardless of what client wants?
if (grfBINDF & BINDF_PREFERDEFAULTHANDLER)
*pgrfBINDF |= BINDF_PREFERDEFAULTHANDLER;
if (grfBINDF & BINDF_ENFORCERESTRICTED)
*pgrfBINDF |= BINDF_ENFORCERESTRICTED;
// To make sure the file winds up on disk even for SSL connections, we need to add
*pgrfBINDF |= BINDF_NEEDFILE;
// BINDINFO_FIX(LaszloG 8/15/97)
ReleaseBindInfo(&bindInfo);
DEBUG_LEAVE(S_OK);
return S_OK;
} // CBindStatusCallback::GetBindInfo
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::OnStartBinding
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnStartBinding(DWORD grfBSCOPTION,IBinding* pbinding)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::OnStartBinding",
"this=%#x, %#x, %#x",
this, grfBSCOPTION, pbinding
));
CCodeDownload *pcdl = m_pdl->GetCodeDownload();
Assert(pbinding);
if (m_pbinding != NULL)
SAFERELEASE(m_pbinding);
m_pbinding = pbinding;
if (m_pbinding != NULL)
m_pbinding->AddRef();
m_pdl->SetDLState(DLSTATE_BINDING);
// call the client BSC::OnStartBinding if not already done
CClBinding *pClientBinding = pcdl->GetClientBinding();
if(pClientBinding->GetState() == CDL_NoOperation){
Assert(pClientBinding->GetAssBSC() == pcdl->GetClientBSC());
pClientBinding->SetState(CDL_Downloading);
pcdl->AddRef();
pcdl->GetClientBSC()->OnStartBinding(grfBSCOPTION, pClientBinding);
}
DEBUG_LEAVE(S_OK);
return S_OK;
} // CBindStatusCallback::OnStartBinding
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::GetPriority
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::GetPriority(LONG* pnPriority)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::GetPriority",
"this=%#x, %#x",
this, pnPriority
));
DEBUG_LEAVE(E_NOTIMPL);
return E_NOTIMPL;
} // CBindStatusCallback::GetPriority
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::OnProgress
// Here we get the master CodeDownload obj to collate progress and report
// cumulative code download progress to client BSC::OnProgress.
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::GetPriority",
"this=%#x, %#x, %#x, %#x, %.80wq",
this, ulProgress, ulProgressMax, ulStatusCode, szStatusText
));
IBindStatusCallback *pClientBSC = m_pdl->GetCodeDownload()->GetClientBSC();
char szURL[INTERNET_MAX_URL_LENGTH];
FILEXTN extn;
char *pBaseFileName;
HRESULT hr = S_OK;
IMoniker *pmk = NULL;
CCodeDownload *pcdl = m_pdl->GetCodeDownload();
// if this a redirect set the context appropriately
// also use this URL to get the extension and base dest name for this
// component, if its a POST (Search Path)
if (m_pdl->DoPost() && (ulStatusCode == BINDSTATUS_REDIRECTING)) {
WideCharToMultiByte(CP_ACP, 0, szStatusText, -1, szURL,
INTERNET_MAX_URL_LENGTH, 0,0);
// BUGBUG: use mime type in response header to determine extn
extn = GetExtnAndBaseFileName( szURL, &pBaseFileName);
hr = m_pdl->SetURLAndExtn( szStatusText, extn);
if (SUCCEEDED(hr)) {
IBindHost *pBH = pcdl->GetClientBinding()->GetIBindHost();
if (pBH) {
hr = pBH->CreateMoniker((LPOLESTR)szStatusText, m_pdl->GetBindCtx(), &pmk, 0);
} else {
hr = CreateURLMoniker(NULL, szStatusText, &pmk);
}
if (SUCCEEDED(hr)) {
pcdl->SetContextMoniker(pmk);
pcdl->MarkNewContextMoniker();
}
}
if (FAILED(hr))
m_pdl->SetResponseHeaderStatus( hr );
}
// we are only interested in cumulative numbers for "downloading" status
// for all others progress is usually: "connecting: 0 of 0", so we
// pass these as is to our client
if ((ulStatusCode != BINDSTATUS_DOWNLOADINGDATA ) &&
(ulStatusCode != BINDSTATUS_ENDDOWNLOADDATA )) {
// pass on progress as is to our client
pClientBSC->OnProgress(ulProgress, ulProgressMax, ulStatusCode,
szStatusText);
DEBUG_LEAVE(S_OK);
return S_OK;
}
// here if Downloading Data progress
m_pdl->SetProgress(ulProgress, ulProgressMax); // update my dl-object's prog
// now summate stats and report to client
CDownload *pdl = m_pdl->GetCodeDownload()->GetDownloadHead();
ULONG ulSum = 0;
ULONG ulSumMax = 0;
// walk each dl object and make a sum of all ulProgress and ulProgressMax
do {
pdl->SumProgress(&ulSum, &ulSumMax);
} while ((pdl = pdl->GetNext()) != NULL);
// pass on cumulative downloading progress to our client
pClientBSC->OnProgress(ulSum, ulSumMax, BINDSTATUS_DOWNLOADINGDATA,
m_pdl->GetCodeDownload()->GetMainURL());
if (ulStatusCode == BINDSTATUS_ENDDOWNLOADDATA ) {
// pass on progress as is to our client
pClientBSC->OnProgress(ulProgress, ulProgressMax, ulStatusCode,
szStatusText);
}
DEBUG_LEAVE(NOERROR);
return(NOERROR);
} // CBindStatusCallback
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::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.
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnDataAvailable(DWORD grfBSC, DWORD dwSize, FORMATETC *pFmtetc, STGMEDIUM __RPC_FAR *pstgmed)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::OnDataAvailable",
"this=%#x, %#x, %#x, %#x, %#x",
this, grfBSC, dwSize, pFmtetc, pstgmed
));
HRESULT hr = NO_ERROR;
// never forward OnDataAvailable to code download's client BSC
if (grfBSC & BSCF_LASTDATANOTIFICATION)
{
// if this is the final notification then get the data and display it
// we asked for IUnknown, we should get back a filename
Assert((pFmtetc->tymed & TYMED_FILE));
if (pFmtetc->tymed & TYMED_FILE) {
char szFile[MAX_PATH];
DWORD dwLen = 0;
if (!(dwLen = WideCharToMultiByte(CP_ACP, 0 , pstgmed->lpszFileName , -1 , szFile, MAX_PATH, NULL, NULL))) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto Exit;
} else {
LPSTR lpFileName = new char[dwLen + 1];
if (!lpFileName) {
hr = E_OUTOFMEMORY;
goto Exit;
} else {
lstrcpy(lpFileName, szFile);
m_pdl->SetFileName(lpFileName);
}
}
// check last modified date for file: URLs
// maybe we don't need the file
HRESULT hr1 = m_pdl->IsDownloadedVersionRequired();
if (FAILED(hr1)) {
m_pdl->SetResponseHeaderStatus(hr1);
goto Exit;
}
// ref count on the cache
// file.
pstgmed->pUnkForRelease->AddRef();
m_pdl->SetUnkForCacheFileRelease(pstgmed->pUnkForRelease);
}
}
Exit:
DEBUG_LEAVE(hr);
return hr;
} // CBindStatusCallback::OnDataAvailable
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::OnObjectAvailable
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnObjectAvailable( REFIID riid, IUnknown* punk)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::OnObjectAvailable",
"this=%#x, %#x, %#x",
this, &riid, punk
));
// Not applicable: we call pmk->BTS not BTO
DEBUG_LEAVE(E_NOTIMPL);
return E_NOTIMPL;
} // CBindStatusCallback::OnObjectAvailable
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::OnLowResource
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnLowResource(DWORD dwReserved)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::OnObjectAvailable",
"this=%#x, %#x",
this, dwReserved
));
DEBUG_LEAVE(E_NOTIMPL);
return E_NOTIMPL;
} // CBindStatusCallback::OnLoadResource
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::OnStopBinding
//
// we get here when we have fully downloaded 'this'.
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnStopBinding(HRESULT hrStatus, LPCWSTR szError)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IBindingStatusCallback::OnStopBinding",
"this=%#x, %#x, %.80wq",
this, hrStatus, szError
));
CCodeDownload *pcdl = m_pdl->GetCodeDownload();
HRESULT hrResponseHdr = m_pdl->GetResponseHeaderStatus();
IBindHost *pBindHost = NULL;
HRESULT hr = S_OK; // assume all OK
if (pcdl) {
pcdl->CodeDownloadDebugOut(DEB_CODEDL, FALSE, ID_CDLDBG_DL_ON_STOP_BINDING, hrStatus, hrResponseHdr);
}
if ((FAILED(hrStatus) && (SCODE_FACILITY(hrStatus) == FACILITY_INTERNET)) ||
FAILED(hrResponseHdr) || SCODE_CODE(hrStatus) == ERROR_MOD_NOT_FOUND) {
hr = m_pdl->DownloadRedundantCodeBase();
if (hr == E_PENDING || hr == MK_S_ASYNCHRONOUS) {
goto Exit;
}
}
m_pdl->SetDLState(DLSTATE_DOWNLOADED);
pBindHost = pcdl->GetClientBinding()->GetIBindHost();
SAFERELEASE(m_pbinding);
if (!pBindHost) {
hr = RevokeBindStatusCallback(m_pdl->GetBindCtx(), m_pdl->GetBSC());
}
if (FAILED(hr)) {
goto OSB_Complete;
}
// if URLMON failed the download or if the response hdr indicated
// a failure that URLMON failed to detect properly
// pass the problem to pcdl->CompleteOne(). This will determine if it
// will query for the clsid with more urls in the CodeSearchPath
// in the registry.
if (FAILED(hrStatus) || FAILED(hrResponseHdr)) {
goto OSB_Complete;
}
// BUGBUG: also check here for Last Modified Date on the Cache Entry
// versus Last Modified if a previous version exists and we are doung
// GetLatest. If data is in the cache then wininet ignores our
// if-modified-since and so we will end up re-installing even though
// there is no version change.
if (m_pdl->GetFileName() != NULL) { // should be set by OnDataAvailable
// This takes us to the next state. VerifyTrust moves us when
// complete to the next state of processing the ProcessPiece.
CCDLPacket *pPkt= new CCDLPacket(CODE_DOWNLOAD_TRUST_PIECE, m_pdl, 0);
if (pPkt) {
hr = pPkt->Post();
} else {
hr = E_OUTOFMEMORY;
}
if (SUCCEEDED(hr))
goto Exit;
// else fall thru to OSB_Complete
} else if (!m_pdl->UsingCdlProtocol()) {
// In case of CDL protocol handler we don't need OnDataAvailable or
// Trust Verification done here.
// BindToStorage may have not detected the error
if (m_pdl->DoPost())
hrResponseHdr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
else
hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
}
OSB_Complete:
// does all the master state analysis
m_pdl->CompleteSignal(hr, hrStatus, hrResponseHdr, szError);
// This very BSC may already have been deleted if all done.
// Don't access any members. Just return !!!
Exit:
DEBUG_LEAVE(S_OK);
return S_OK; // always succeed to url mon.
} // CBindStatusCallback::OnStopBinding
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::BeginningTransaction
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::BeginningTransaction(
LPCWSTR szURL,
LPCWSTR szHeaders,
DWORD dwReserved,
LPWSTR *pszAdditionalHeaders)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IHttpNegotiate::BeginningTransaction",
"this=%#x, %.80wq, %.80wq, %#x, %#x",
this, szURL, szHeaders, dwReserved, pszAdditionalHeaders
));
HRESULT hr = S_OK;
char szHttpDate[INTERNET_RFC1123_BUFSIZE+1];
DWORD dwLen = 0;
LPWSTR szAHdrs = NULL;
static const char cszHeaderFmt[] = "%s %s\r\n";
static const char szIfMod[] = "If-Modified-Since:";
static const char szNONEMATCH[] = "If-None-Match:";
static const WCHAR szFORM[] = L"Content-Type: application/x-www-form-urlencoded\r\n";
static const char szAcceptLanguageFmt[] = "Accept-Language: %s\r\n";
char szBuf[MAX_PATH];
WCHAR szAcceptLanguage[MAX_PATH];
char szLangBuf[10];
char *pszNoneMatch = NULL;
CCodeDownload *pcdl = m_pdl->GetCodeDownload();
LCID lcid = pcdl->GetLCID();
// BUGBUG: we currently only support primary lang or default
// it should really be "en-us, en", instead of just "en"
// waiting for note from TonyCi about some servers like Apache
// broken by this
lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(LANGIDFROMLCID(lcid)), SUBLANG_DEFAULT), SORT_DEFAULT);
DEBUG_PRINT(DOWNLOAD,
INFO,
("this=%#x, m_lcid: %d (%#x), lcid: %d (%#x)\n",
this, pcdl->GetLCID(), pcdl->GetLCID(), lcid, lcid
));
*szAcceptLanguage = L'\0';
if (pcdl->GetLangInfo()->GetAcceptLanguageString(lcid, szLangBuf, sizeof(szLangBuf))
&& (*szLangBuf != '\0'))
{
wnsprintf(szBuf, sizeof(szBuf)-1, szAcceptLanguageFmt, szLangBuf);
dwLen = MultiByteToWideChar(CP_ACP, 0, szBuf, -1, szAcceptLanguage, MAX_PATH);
}
Assert((pszAdditionalHeaders != NULL));
FILETIME *pftLastMod = pcdl->GetLastModifiedTime();
SYSTEMTIME sSysTime;
BOOL bSendNoneMatch = !pcdl->ForceDownload() && ( pcdl->LocalVersionPresent() && (pcdl->GetLocalVersionEtag()) ) && pcdl->NeedLatestVersion();
BOOL bSendLastMod = !bSendNoneMatch && (!pcdl->ForceDownload() && ( pcdl->LocalVersionPresent() && (pftLastMod) ) && pcdl->NeedLatestVersion());
if ( bSendLastMod) {
Assert( (pftLastMod != NULL) ); // Check for bug#40696
// need to send If-Modified-Since
if (!FileTimeToSystemTime(pftLastMod, &sSysTime)) {
m_pdl->SetResponseHeaderStatus( HRESULT_FROM_WIN32(GetLastError()));
goto Exit;
}
if (!InternetTimeFromSystemTimeA(&sSysTime, INTERNET_RFC1123_FORMAT,
szHttpDate, INTERNET_RFC1123_BUFSIZE)) {
m_pdl->SetResponseHeaderStatus( HRESULT_FROM_WIN32(GetLastError()));
goto Exit;
}
dwLen += (INTERNET_RFC1123_BUFSIZE + 1 + sizeof(szIfMod) +
sizeof(cszHeaderFmt));
}
if (bSendNoneMatch) {
DWORD dwNoneMatch = lstrlen(pcdl->GetLocalVersionEtag()) + sizeof(szNONEMATCH) + sizeof(cszHeaderFmt);
pszNoneMatch = new char [dwNoneMatch+1];
wsprintf(pszNoneMatch, cszHeaderFmt, szNONEMATCH, pcdl->GetLocalVersionEtag());
dwLen += dwNoneMatch;
}
if (m_pdl->DoPost()) {
dwLen += sizeof(szFORM);
}
if (dwLen) {
szAHdrs = new WCHAR [dwLen + 1];
if (!szAHdrs) {
m_pdl->SetResponseHeaderStatus( E_OUTOFMEMORY );
// BUGBUG: Clean all this up to never return right away, and
// goto exit to cleanup
SAFEDELETE(pszNoneMatch);
DEBUG_LEAVE(hr);
return hr;
}
szAHdrs[0] = '\0';
}
if (bSendLastMod) {
char *szTemp = new char [dwLen + 1];
if (!szTemp) {
hr = E_OUTOFMEMORY;
delete szAHdrs;
goto Exit;
}
wsprintf(szTemp, cszHeaderFmt, szIfMod, szHttpDate);
MultiByteToWideChar(CP_ACP, 0, szTemp, -1, szAHdrs, dwLen);
delete szTemp;
}
if (bSendNoneMatch) {
MultiByteToWideChar(CP_ACP, 0, pszNoneMatch, -1, szAHdrs, dwLen);
}
if (m_pdl->DoPost()) {
StrCatW(szAHdrs, szFORM);
}
if (*szAcceptLanguage != L'\0')
{
StrCatW(szAHdrs, szAcceptLanguage);
}
Exit:
SAFEDELETE(pszNoneMatch);
*pszAdditionalHeaders = szAHdrs;
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::OnResponse
// ---------------------------------------------------------------------------
STDMETHODIMP
CBindStatusCallback::OnResponse(
DWORD dwResponseCode,
LPCWSTR szResponseHeaders,
LPCWSTR szRequestHeaders,
LPWSTR *pszAdditionalRequestHeaders)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::IHttpNegotiate::OnResponse",
"this=%#x, %#x, %.80wq, %.80wq, %#x",
this, dwResponseCode, szResponseHeaders, szRequestHeaders, pszAdditionalRequestHeaders
));
HRESULT hr = S_OK;
// propogate errors here to CSBC::OnStopBinding
// we need this as urlmon might just convert any error returned here
// as user_cancelled
if (dwResponseCode != HTTP_STATUS_OK) {
if (dwResponseCode == HTTP_STATUS_NOT_MODIFIED) {
hr = HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
} else {
hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
}
m_pdl->SetResponseHeaderStatus( hr );
}
if (m_pdl->DoPost() ||
(m_pdl->GetMoniker() == m_pdl->GetCodeDownload()->GetContextMoniker())){
// Get the HttpQueryInfo wrapper object.
IWinInetHttpInfo *pHttpInfo = NULL;
HRESULT hr = GetBinding()->QueryInterface
(IID_IWinInetHttpInfo, (void **) &pHttpInfo);
if (SUCCEEDED(hr)) {
DWORD cbLen = INTERNET_RFC1123_BUFSIZE + 1;
char szHttpDate[INTERNET_RFC1123_BUFSIZE+1];
if ((pHttpInfo->QueryInfo (HTTP_QUERY_LAST_MODIFIED,
(LPVOID)szHttpDate, &cbLen, NULL, 0) == S_OK) && cbLen)
m_pdl->GetCodeDownload()->SetLastModifiedTime(szHttpDate);
cbLen = 0; // reset
if ( (pHttpInfo->QueryInfo (HTTP_QUERY_ETAG,
(LPVOID)NULL, &cbLen, NULL, 0) == S_OK) && cbLen) {
char *pbEtag = new char [cbLen +1];
if (pbEtag)
{
*pbEtag = '\0'; // clr
pHttpInfo->QueryInfo (HTTP_QUERY_ETAG,
(LPVOID)pbEtag, &cbLen, NULL, 0);
if (*pbEtag)
m_pdl->GetCodeDownload()->SetEtag(pbEtag);
}
}
pHttpInfo->Release();
}
}
DEBUG_LEAVE(S_OK);
return S_OK;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::GetCatalogFile
// ---------------------------------------------------------------------------
STDMETHODIMP CBindStatusCallback::GetCatalogFile(LPSTR *ppszCatalogFile)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::ICatalogFileInfo::GetCatalogFile",
"this=%#x, %#x",
this, ppszCatalogFile
));
HRESULT hr = S_OK;
LPSTR pszCatFile = NULL;
if (ppszCatalogFile) {
pszCatFile = m_pdl->GetCodeDownload()->GetCatalogFile();
if (pszCatFile) {
*ppszCatalogFile = new char[lstrlen(pszCatFile) + 1];
if (*ppszCatalogFile == NULL) {
hr = E_OUTOFMEMORY;
}
else {
lstrcpy(*ppszCatalogFile, pszCatFile);
}
}
else {
*ppszCatalogFile = NULL;
}
}
else {
hr = E_INVALIDARG;
}
DEBUG_LEAVE(hr);
return hr;
}
// ---------------------------------------------------------------------------
// %%Function: CBindStatusCallback::GetJavaTrust
// ---------------------------------------------------------------------------
STDMETHODIMP CBindStatusCallback::GetJavaTrust(void **ppJavaTrust)
{
DEBUG_ENTER((DBG_DOWNLOAD,
Hresult,
"CBindStatusCallback::ICatalogFileInfo::GetJavaTrust",
"this=%#x, %#x",
this, ppJavaTrust
));
HRESULT hr = S_OK;
if (ppJavaTrust) {
*ppJavaTrust = (void *)m_pdl->GetCodeDownload()->GetJavaTrust();
}
else {
hr = E_INVALIDARG;
}
DEBUG_LEAVE(hr);
return hr;
}