windows-xp/Source/XPSP1/NT/shell/ext/webcheck/utils.cpp

#include "private.h"
#include "chanmgr.h"
#include "chanmgrp.h"
#include "shguidp.h"
#include "resource.h"
#define DECL_CRTFREE
#include <crtfree.h>


#include <mluisupp.h>

#define TF_DUMPTRIGGER              0x80000000

#define PtrDifference(x,y)          ((LPBYTE)(x)-(LPBYTE)(y))

// Invoke Command verb strings
const CHAR c_szOpen[]          = "open";
const CHAR c_szDelete[]        = "delete";
const CHAR c_szProperties[]    = "properties";
const CHAR c_szCopy[]          = "copy";
const CHAR c_szRename[]        = "rename";
const CHAR c_szPaste[]         = "paste";

static TCHAR szNone[40] = {0};
static TCHAR szUnknown[40] = {0};

// For each notification handler CLSID in the registry, send a single CommandId and Cookie to each handler.
void FireSubscriptionEvent(int nCmdID, const SUBSCRIPTIONCOOKIE UNALIGNED *pCookie_ua)
{
    HKEY hkey;
    SUBSCRIPTIONCOOKIE cookie_buf;
    SUBSCRIPTIONCOOKIE *pCookie;

    ASSERT( pCookie_ua );

    if ( ! pCookie_ua )
    {
        TraceMsg(TF_ERROR, "FireSubscriptionEvent() - pCookie_ua is NULL!");
        return;
    }

    //
    // Make an aligned copy of pCookie_ua and set a pointer to it.
    //

    cookie_buf = *pCookie_ua;
    pCookie = &cookie_buf;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WEBCHECK_REGKEY_NOTF, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
    {
        LPOLESTR pszCookie;

        if (SUCCEEDED(StringFromCLSID(*pCookie, &pszCookie)))
        {
            VARIANT varCookie;

            varCookie.vt = VT_BSTR;
            varCookie.bstrVal = SysAllocString(pszCookie);

            if (varCookie.bstrVal)
            {
                for (int i = 0; ; i++)
                {
                    TCHAR szClsid[GUIDSTR_MAX];
                    DWORD cchClsid = ARRAYSIZE(szClsid);
                    DWORD dwType;
                    DWORD dwData;
                    DWORD cbData = sizeof(dwData);

                    int result = RegEnumValue(hkey, i, szClsid, &cchClsid, NULL, &dwType, (LPBYTE)&dwData, &cbData);

                    if (ERROR_NO_MORE_ITEMS == result)
                    {
                        break;
                    }

                    if ((ERROR_SUCCESS == result) && (dwData & nCmdID))
                    {
                        WCHAR wszClsid[GUIDSTR_MAX];
                        CLSID clsid;

                        SHTCharToUnicode(szClsid, wszClsid, ARRAYSIZE(wszClsid));

                        HRESULT hr = CLSIDFromString(wszClsid, &clsid);

                        if (SUCCEEDED(hr))
                        {
                            IOleCommandTarget *pCmdTarget;

                            hr = CoCreateInstance(*(&clsid), NULL, CLSCTX_ALL, IID_IOleCommandTarget, (void **)&pCmdTarget);
                            if (SUCCEEDED(hr))
                            {
                                pCmdTarget->Exec(&CLSID_SubscriptionMgr, nCmdID, 0, &varCookie, NULL);
                                pCmdTarget->Release();
                            }
                        }
                    }
                }

                VariantClear(&varCookie);
            }

            CoTaskMemFree(pszCookie);
        }

        RegCloseKey( hkey );
    }
}

#ifdef UNICODE
HRESULT IExtractIcon_GetIconLocationThunk(IExtractIconW *peiw, UINT uFlags, LPSTR szIconFile, UINT cchMax, int * piIndex, UINT * pwFlags)
{
    HRESULT hr;
    WCHAR *pwszIconFile = new WCHAR[cchMax];

    if (NULL != pwszIconFile)
    {
        hr = peiw->GetIconLocation(uFlags, pwszIconFile, cchMax, piIndex, pwFlags);

        if (SUCCEEDED(hr))
        {
            WideCharToMultiByte(CP_ACP, 0, pwszIconFile, -1, szIconFile, cchMax, NULL, NULL);
        }

        delete [] pwszIconFile;
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    return hr;
}

HRESULT IExtractIcon_ExtractThunk(IExtractIconW *peiw, LPCSTR pszFile, UINT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIconSize)
{
    HRESULT hr;
    int len = lstrlenA(pszFile) + 1;
    WCHAR *pwszFile = new WCHAR[len];

    if (NULL != pwszFile)
    {
        MultiByteToWideChar(CP_ACP, 0, pszFile, len, pwszFile, len);

        hr = peiw->Extract(pwszFile, nIconIndex, phiconLarge, phiconSmall, nIconSize);

        delete [] pwszFile;
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    return hr;
}
#endif

DWORD Random(DWORD nMax)
{
    static DWORD dwSeed = GetTickCount();

    if (nMax)
    {
        return dwSeed = (dwSeed * 214013L + 2531011L) % nMax;
    }
    else
    {
        return 0;
    }
}

void CreateCookie(GUID UNALIGNED *pCookie_ua)
{
    static DWORD dwCount = 0;

    union CUCookie
    {
        GUID guidCookie;
        struct XCookie {
            FILETIME ft;
            DWORD    dwCount;
            DWORD    dwRand;
        } x;
    };

    CUCookie uc;
    GetSystemTimeAsFileTime(&uc.x.ft);
    uc.x.dwCount = dwCount++;
    uc.x.dwRand = Random(0xffffffff);

    *pCookie_ua = uc.guidCookie;
}

void VariantTimeToFileTime(double dt, FILETIME& ft)
{
    SYSTEMTIME st;

    VariantTimeToSystemTime(dt, &st);
    SystemTimeToFileTime(&st, &ft);
}

void FileTimeToVariantTime(FILETIME& ft, double *pdt)
{
    SYSTEMTIME st;

    FileTimeToSystemTime(&ft, &st);
    SystemTimeToVariantTime(&st, pdt);
}


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

//
// Cache helper functions
//

// Caller should MemFree *lpCacheConfigInfo when done. Should pass *lpCacheConfigInfo
//  into SetCacheSize
HRESULT GetCacheInfo(
    LPINTERNET_CACHE_CONFIG_INFOA *lplpCacheConfigInfo,
    DWORD                        *pdwSizeInKB,
    DWORD                        *pdwPercent)
{
    HRESULT hr = S_OK;
    LPINTERNET_CACHE_CONFIG_INFOA lpCCI = NULL;
    DWORD dwSize;

    dwSize = sizeof(INTERNET_CACHE_CONFIG_INFOA);

    lpCCI = (LPINTERNET_CACHE_CONFIG_INFOA)MemAlloc(LPTR, dwSize);

    if (!lpCCI)
    {
        hr = E_OUTOFMEMORY;
        goto cleanup;
    }

    lpCCI->dwStructSize = sizeof(INTERNET_CACHE_CONFIG_INFOA);

    if (!GetUrlCacheConfigInfoA(lpCCI, &dwSize, CACHE_CONFIG_CONTENT_PATHS_FC))
    {
        hr = E_FAIL; // HRESULT_FROM_WIN32(GetLastError());
        goto cleanup;
    }

    // there should be at least one cache path structure
    if (dwSize < sizeof(INTERNET_CACHE_CONFIG_INFOA) ||
        lpCCI->dwNumCachePaths != 1)
    {
        // something is messed up
        hr = E_FAIL;
        goto cleanup;
    }

    *lplpCacheConfigInfo = lpCCI;
    *pdwSizeInKB = lpCCI->dwQuota;
    *pdwPercent = 10; // good faith estimate

    ASSERT(*pdwSizeInKB);   // Better not be 0...

cleanup:

    if (FAILED(hr))
    {
        SAFELOCALFREE(lpCCI);
    }

    return hr;
}

HRESULT SetCacheSize(
            LPINTERNET_CACHE_CONFIG_INFOA lpCacheConfigInfo,
            DWORD                        dwSizeInKB)
{
//  lpCacheConfigInfo->dwNumCachePaths = 1;
//  lpCacheConfigInfo->CachePaths[0].dwCacheSize = dwSizeInKB;
    lpCacheConfigInfo->dwContainer = 0; // CONTENT;
    lpCacheConfigInfo->dwQuota = dwSizeInKB;

    if (!SetUrlCacheConfigInfoA(lpCacheConfigInfo, CACHE_CONFIG_QUOTA_FC))
    {
        return E_FAIL; // HRESULT_FROM_WIN32(GetLastError());
    }

    return S_OK;
}


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

//
// Registry helper functions
//
BOOL ReadRegValue(HKEY hkeyRoot, const TCHAR *pszKey, const TCHAR *pszValue,
                   void *pData, DWORD dwBytes)
{
    long    lResult;
    HKEY    hkey;
    DWORD   dwType;

    lResult = RegOpenKey(hkeyRoot, pszKey, &hkey);
    if (lResult != ERROR_SUCCESS) {
        return FALSE;
    }

    lResult = RegQueryValueEx(hkey, pszValue, NULL, &dwType, (BYTE *)pData,
        &dwBytes);
    RegCloseKey(hkey);

    if (lResult != ERROR_SUCCESS)
        return FALSE;

    if(dwType == REG_SZ) {
        // null terminate string
        ((TCHAR *)pData)[dwBytes] = 0;
    }

    return TRUE;
}

BOOL WriteRegValue(HKEY hkeyRoot, const TCHAR *pszKey, const TCHAR *pszValue,
                    void *pData, DWORD dwBytes, DWORD dwType)
{
    HKEY    hkey;
    long    lResult;
    DWORD   dwStatus;

    lResult = RegCreateKeyEx(hkeyRoot, pszKey, 0, NULL,
            REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hkey, &dwStatus);
    if (lResult != ERROR_SUCCESS) {
        return FALSE;
    }

    lResult = RegSetValueEx(hkey, pszValue, 0, dwType, (BYTE *)pData, dwBytes);
    RegCloseKey(hkey);

    return (lResult == ERROR_SUCCESS) ? TRUE : FALSE;
}

DWORD ReadRegDWORD(HKEY hkeyRoot, const TCHAR *pszKey, const TCHAR *pszValue)
{
    DWORD dwData;
    if (ReadRegValue(hkeyRoot, pszKey, pszValue, &dwData, sizeof(dwData)))
        return dwData;
    else
        return 0;
}

HRESULT CreateShellFolderPath(LPCTSTR pszPath, LPCTSTR pszGUID, BOOL bUICLSID)
{
    if (!PathFileExists(pszPath))
    CreateDirectory(pszPath, NULL);

    // Mark the folder as a system directory
    if (SetFileAttributes(pszPath, FILE_ATTRIBUTE_READONLY))
    {
        TCHAR szDesktopIni[MAX_PATH];
        // Write in the desktop.ini the cache folder class ID
        PathCombine(szDesktopIni, pszPath, TEXT("desktop.ini"));

        // If the desktop.ini already exists, make sure it is writable
        if (PathFileExists(szDesktopIni))
            SetFileAttributes(szDesktopIni, FILE_ATTRIBUTE_NORMAL);

        // (First, flush the cache to make sure the desktop.ini
        // file is really created.)
        WritePrivateProfileString(NULL, NULL, NULL, szDesktopIni);
        WritePrivateProfileString(TEXT(".ShellClassInfo"), bUICLSID ? TEXT("UICLSID") : TEXT("CLSID"), pszGUID, szDesktopIni);
        WritePrivateProfileString(NULL, NULL, NULL, szDesktopIni);

        // Hide the desktop.ini since the shell does not selectively
        // hide it.
        SetFileAttributes(szDesktopIni, FILE_ATTRIBUTE_HIDDEN);

        return NOERROR;
    }
    else
    {
        DebugMsg(DM_TRACE, TEXT("Cannot make %s a system folder"), pszPath);
        return E_FAIL;
    }
}

void CleanupShellFolder(LPCTSTR pszPath)
{
    if (PathFileExists(pszPath))
    {
        TCHAR szDesktopIni[MAX_PATH];

        // make the history a normal folder
        SetFileAttributes(pszPath, FILE_ATTRIBUTE_NORMAL);
        PathCombine(szDesktopIni, pszPath, TEXT("desktop.ini"));

        // If the desktop.ini already exists, make sure it is writable
        if (PathFileExists(szDesktopIni))
        {
            SetFileAttributes(szDesktopIni, FILE_ATTRIBUTE_NORMAL);
            DeleteFile(szDesktopIni);
        }

        // remove the history directory
        RemoveDirectory(pszPath);
    }
}

BOOL GetSubscriptionFolderPath(LPTSTR pszPath)
{
    DWORD dwDummy;
    HKEY hk;

    if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_LOCAL_MACHINE,
                                        REGSTR_PATH_SUBSCRIPTION,
                                        0, TEXT(""),
                                        REG_OPTION_NON_VOLATILE,
                                        KEY_READ|KEY_WRITE, NULL, &hk, &dwDummy))
    {
        DWORD cbData = MAX_PATH * sizeof(TCHAR);
        if (ERROR_SUCCESS != RegQueryValueEx(hk, REGSTR_VAL_DIRECTORY , NULL, NULL, (LPBYTE)pszPath, &cbData))
        {
            TCHAR szWindows[MAX_PATH];
            GetWindowsDirectory(szWindows, ARRAYSIZE(szWindows));
            PathCombine(pszPath, szWindows, TEXT("Offline Web Pages"));
        }
        RegCloseKey(hk);

        return TRUE;
    }
    return FALSE;
}

HRESULT GetChannelPath(LPCTSTR pszURL, LPTSTR pszPath, int cch,
                       IChannelMgrPriv** ppIChannelMgrPriv)
{
    ASSERT(pszURL);
    ASSERT(pszPath || 0 == cch);
    ASSERT(ppIChannelMgrPriv);

    HRESULT hr;
    BOOL    bCoinit = FALSE;

    hr = CoCreateInstance(CLSID_ChannelMgr, NULL, CLSCTX_INPROC_SERVER,
                          IID_IChannelMgrPriv, (void**)ppIChannelMgrPriv);

    if ((hr == CO_E_NOTINITIALIZED || hr == REGDB_E_IIDNOTREG) &&
        SUCCEEDED(CoInitialize(NULL)))
    {
        bCoinit = TRUE;
        hr = CoCreateInstance(CLSID_ChannelMgr, NULL, CLSCTX_INPROC_SERVER,
                          IID_IChannelMgrPriv, (void**)ppIChannelMgrPriv);
    }

    if (SUCCEEDED(hr))
    {
        ASSERT(*ppIChannelMgrPriv);

        IChannelMgr* pIChannelMgr;

        hr = (*ppIChannelMgrPriv)->QueryInterface(IID_IChannelMgr,
                                                (void**)&pIChannelMgr);

        if (SUCCEEDED(hr))
        {
            ASSERT(pIChannelMgr);

            WCHAR wszURL[INTERNET_MAX_URL_LENGTH];
            MyStrToOleStrN(wszURL, ARRAYSIZE(wszURL), pszURL);

            IEnumChannels* pIEnumChannels;

            hr = pIChannelMgr->EnumChannels(CHANENUM_ALLFOLDERS | CHANENUM_PATH,
                                            wszURL, &pIEnumChannels);

            if (SUCCEEDED(hr))
            {
                ASSERT(pIEnumChannels);

                CHANNELENUMINFO ci;

                if (S_OK == pIEnumChannels->Next(1, &ci, NULL))
                {
                    MyOleStrToStrN(pszPath, cch, ci.pszPath);

                    CoTaskMemFree(ci.pszPath);
                }
                else
                {
                    hr = E_FAIL;
                }

                pIEnumChannels->Release();
            }

            pIChannelMgr->Release();
        }

    }

    if (bCoinit)
        CoUninitialize();

    ASSERT((SUCCEEDED(hr) && *ppIChannelMgrPriv) || FAILED(hr));

    return hr;
}


//  Caller is responsible for calling ILFree on *ppidl.
HRESULT ConvertPathToPidl(LPCTSTR path, LPITEMIDLIST * ppidl)
{
    WCHAR wszPath[MAX_PATH];
    IShellFolder * pDesktopFolder;
    HRESULT hr;

    ASSERT(path && ppidl);
    * ppidl = NULL;

    MyStrToOleStrN(wszPath, MAX_PATH, path);
    hr = SHGetDesktopFolder(&pDesktopFolder);
    if (hr != NOERROR)
        return hr;

    ULONG uChEaten;

    hr = pDesktopFolder->ParseDisplayName(NULL, NULL, wszPath,
                                            &uChEaten, ppidl, NULL);
    SAFERELEASE(pDesktopFolder);

    return hr;
}

LPITEMIDLIST    GetSubscriptionFolderPidl(void)
{
    TCHAR szPath[MAX_PATH];
    static LPITEMIDLIST pidlFolder = NULL;  //  We leak here.

    if (!pidlFolder)  {
        if (!(GetSubscriptionFolderPath(szPath)))
            return NULL;
        if (FAILED(ConvertPathToPidl(szPath, &pidlFolder)))
            return NULL;
        ASSERT(pidlFolder);
    }
    return (LPITEMIDLIST)pidlFolder;
}

STDAPI OfflineFolderRegisterServer(void)
{
    TCHAR szOldSubscriptionPath[MAX_PATH];

    GetWindowsDirectory(szOldSubscriptionPath, ARRAYSIZE(szOldSubscriptionPath));
    PathCombine(szOldSubscriptionPath, szOldSubscriptionPath, TEXT("Subscriptions"));
    CleanupShellFolder(szOldSubscriptionPath);

    TCHAR szPath[MAX_PATH];

    if (!(GetSubscriptionFolderPath(szPath)))
        goto CleanUp;

    // we pass FALSE because history folder uses CLSID
    if (FAILED(CreateShellFolderPath(szPath, TEXT("{F5175861-2688-11d0-9C5E-00AA00A45957}"), FALSE)))
        goto CleanUp;

    return NOERROR;

CleanUp:        // cleanup stuff if any of our reg stuff fails

    return E_FAIL;
}

STDAPI OfflineFolderUnregisterServer(void)
{
    TCHAR szPath[MAX_PATH];

    if (!(GetSubscriptionFolderPath(szPath)))
        goto CleanUp;

    // we pass FALSE because history folder uses CLSID
    CleanupShellFolder(szPath);

    return NOERROR;

CleanUp:        // cleanup stuff if any of our reg stuff fails

    return E_FAIL;
}



HMENU LoadPopupMenu(UINT id, UINT uSubOffset)
{
    HMENU hmParent, hmPopup;

    hmParent = LoadMenu(MLGetHinst(), MAKEINTRESOURCE(id));
    if (!hmParent)
        return NULL;

    hmPopup = GetSubMenu(hmParent, uSubOffset);
    RemoveMenu(hmParent, uSubOffset, MF_BYPOSITION);
    DestroyMenu(hmParent);

    return hmPopup;
}

UINT MergePopupMenu(HMENU *phMenu, UINT idResource, UINT uSubOffset, UINT indexMenu,  UINT idCmdFirst, UINT idCmdLast)
{
    HMENU hmMerge;

    if (*phMenu == NULL)
    {
        *phMenu = CreatePopupMenu();
        if (*phMenu == NULL)
            return 0;

        indexMenu = 0;    // at the bottom
    }

    hmMerge = LoadPopupMenu(idResource, uSubOffset);
    if (!hmMerge)
        return 0;

    idCmdLast = Shell_MergeMenus(*phMenu, hmMerge, indexMenu, idCmdFirst, idCmdLast, MM_ADDSEPARATOR);

    DestroyMenu(hmMerge);
    return idCmdLast;
}

HMENU GetMenuFromID(HMENU hmenu, UINT idm)
{
    MENUITEMINFO mii = { sizeof(mii), MIIM_SUBMENU, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0 };
    GetMenuItemInfo(hmenu, idm, FALSE, &mii);
    return mii.hSubMenu;
}

UINT MergeMenuHierarchy(HMENU hmenuDst, HMENU hmenuSrc, UINT idcMin, UINT idcMax, BOOL bTop)
{
    UINT idcMaxUsed = idcMin;
    int imi = GetMenuItemCount(hmenuSrc);

    while (--imi >= 0)
    {
        MENUITEMINFO mii = {
                sizeof(MENUITEMINFO),
                MIIM_ID | MIIM_SUBMENU,
                0,/* fType */ 0,/* fState */ 0,/*wId*/ NULL,
                NULL, NULL, 0,
                NULL, 0 };

        if (GetMenuItemInfo(hmenuSrc, imi, TRUE, &mii))
        {
            UINT idcT = Shell_MergeMenus(
                            GetMenuFromID(hmenuDst, mii.wID),
                            mii.hSubMenu, (bTop)?0:1024, idcMin, idcMax,
                            MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
            idcMaxUsed = max(idcMaxUsed, idcT);
        }
    }
    return idcMaxUsed;
}

///////////////////////////////////////////////////////////////////////////////
//
// Helper Fuctions for item.cpp and folder.cpp
//
///////////////////////////////////////////////////////////////////////////////

int _CompareURL(LPMYPIDL pooi1, LPMYPIDL pooi2)
{
    return UrlCompare(URL(&(pooi1->ooe)), URL(&(pooi2->ooe)), TRUE);
}

int _CompareShortName(LPMYPIDL pooi1, LPMYPIDL pooi2)
{
    PCTSTR pszNameLocal1;
    PCTSTR pszNameLocal2;

    LPTSTR szNameUnaligned1 = NAME(&(pooi1->ooe));
    LPTSTR szNameUnaligned2 = NAME(&(pooi2->ooe));

    TSTR_ALIGNED_STACK_COPY( &pszNameLocal1, szNameUnaligned1 );
    TSTR_ALIGNED_STACK_COPY( &pszNameLocal2, szNameUnaligned2 );

    return StrCmp( pszNameLocal1, pszNameLocal2 );
}

int _CompareLastUpdate(LPMYPIDL pooi1, LPMYPIDL pooi2)
{
    if (pooi1->ooe.m_LastUpdated - pooi2->ooe.m_LastUpdated > 0)
        return 1;
    return -1;
}

int _CompareCookie(REFCLSID cookie1, REFCLSID cookie2)
{
    return memcmp(&cookie1, &cookie2, sizeof(CLSID));
}

int _CompareStatus(LPMYPIDL pooi1, LPMYPIDL pooi2)
{
    return StrCmp(STATUS(&(pooi1->ooe)), STATUS(&(pooi2->ooe)));
}

int _CompareIdentities(LPMYPIDL pooi1, LPMYPIDL pooi2)
{
    if (pooi1->ooe.clsidDest != pooi2->ooe.clsidDest)
        return -1;

    if (!IsNativeAgent(pooi1->ooe.clsidDest))
        return _CompareCookie(pooi1->ooe.m_Cookie, pooi2->ooe.m_Cookie);

    return _CompareURL(pooi1, pooi2);
}

BOOL _ValidateIDListArray(UINT cidl, LPCITEMIDLIST *ppidl)
{
    UINT i;

    for (i = 0; i < cidl; i++)
    {
        if (!IS_VALID_MYPIDL(ppidl[i]))
            return FALSE;
    }

    return TRUE;
}

int _LaunchApp(HWND hwnd, LPCTSTR pszPath)
{
    SHELLEXECUTEINFO ei = { 0 };

    ei.cbSize           = sizeof(SHELLEXECUTEINFO);
    ei.hwnd             = hwnd;
    ei.lpFile           = pszPath;
    ei.nShow            = SW_SHOWNORMAL;

    return ShellExecuteEx(&ei);
}

void _GenerateEvent(LONG lEventId, LPITEMIDLIST pidlIn, LPITEMIDLIST pidlNewIn, BOOL bRefresh)
{
    LPITEMIDLIST pidlFolder = GetSubscriptionFolderPidl();
    if (!pidlFolder)
        return;

    LPITEMIDLIST pidl = ILCombine(pidlFolder, pidlIn);
    if (pidl)
    {
        if (pidlNewIn)
        {
            LPITEMIDLIST pidlNew = ILCombine(pidlFolder, pidlNewIn);
            if (pidlNew)
            {
                SHChangeNotify(lEventId, SHCNF_IDLIST, pidl, pidlNew);
                ILFree(pidlNew);
            }
        }
        else
        {
            SHChangeNotify(lEventId, SHCNF_IDLIST, pidl, NULL);
        }
        if (bRefresh)
            SHChangeNotifyHandleEvents();
        ILFree(pidl);
    }
}

BOOL _InitComCtl32()
{
    static BOOL fInitialized = FALSE;

    if (!fInitialized)
    {
        INITCOMMONCONTROLSEX icc;

        icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
        icc.dwICC = ICC_NATIVEFNTCTL_CLASS | ICC_DATE_CLASSES;
        fInitialized = InitCommonControlsEx(&icc);
    }
    return fInitialized;
}

const struct {
    LPCSTR pszVerb;
    UINT idCmd;
} rgcmds[] = {
    { c_szOpen,         RSVIDM_OPEN },
    { c_szCopy,         RSVIDM_COPY },
    { c_szRename,       RSVIDM_RENAME},
    { c_szPaste,        RSVIDM_PASTE},
    { c_szDelete,       RSVIDM_DELETE },
    { c_szProperties,   RSVIDM_PROPERTIES }
};

int _GetCmdID(LPCSTR pszCmd)
{
    if (HIWORD(pszCmd))
    {
        int i;
        for (i = 0; i < ARRAYSIZE(rgcmds); i++)
        {
            if (lstrcmpiA(rgcmds[i].pszVerb, pszCmd) == 0)
            {
                return rgcmds[i].idCmd;
            }
        }

        return -1;  // unknown
    }
    return (int)LOWORD(pszCmd);
}

BOOL CALLBACK _AddOnePropSheetPage(HPROPSHEETPAGE hpage, LPARAM lParam)
{
    PROPSHEETHEADER * ppsh = (PROPSHEETHEADER *) lParam;

    if (ppsh->nPages < MAX_PROP_PAGES)
    {
        ppsh->phpage[ppsh->nPages++] = hpage;
        return TRUE;
    }
    return FALSE;
}

HRESULT _CreatePropSheet(HWND hwnd, POOEBuf pBuf)
{
    ASSERT(pBuf);

    ISubscriptionMgr    * pSub= NULL;
    HRESULT hr = CoInitialize(NULL);
    RETURN_ON_FAILURE(hr);

    hr = CoCreateInstance(CLSID_SubscriptionMgr, NULL, CLSCTX_INPROC_SERVER,
                IID_ISubscriptionMgr, (void **)&pSub);
    CoUninitialize();
    RETURN_ON_FAILURE(hr);
    ASSERT(pSub);

    BSTR bstrURL = NULL;
    hr = CreateBSTRFromTSTR(&bstrURL, pBuf->m_URL);
    if (S_OK == hr)
        hr = pSub->ShowSubscriptionProperties(bstrURL, hwnd);
    SAFERELEASE(pSub);
    SAFEFREEBSTR(bstrURL);
    return hr;
}

//  Note:
//      We return FALSE on illegal DATE data.

BOOL DATE2DateTimeString(CFileTime& ft, LPTSTR pszText)
{
    SYSTEMTIME st;

    if (ft == 0)    {
        if (szUnknown[0] == 0)
            MLLoadString(IDS_UNKNOWN, szUnknown, ARRAYSIZE(szUnknown));

        StrCpy(pszText, szUnknown);
        return FALSE;
    }

    if (!FileTimeToSystemTime(&ft, &st))
    {
        if (szNone[0] == 0)
            MLLoadString(IDS_NONE, szNone, ARRAYSIZE(szNone));

        StrCpy(pszText, szNone);
        return FALSE;
    }
    GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, pszText, 64);
    pszText += lstrlen(pszText);
    *pszText++ = ' ';
    GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, pszText, 64);
    return TRUE;
}

BOOL Date2LocalDateString(SYSTEMTIME * st, LPTSTR dtStr, int size)
{
    ASSERT(dtStr);

    return GetDateFormat(LOCALE_USER_DEFAULT, 0, st, NULL, dtStr, size);
}

void CopyToOOEBuf(POOEntry pooe, POOEBuf pBuf)
{
    ASSERT(pooe);
    ASSERT(pBuf);

    pBuf->dwFlags           = pooe->dwFlags;
    pBuf->m_LastUpdated     = pooe->m_LastUpdated;
    pBuf->m_NextUpdate      = pooe->m_NextUpdate;
    pBuf->m_SizeLimit       = pooe->m_SizeLimit;
    pBuf->m_ActualSize      = pooe->m_ActualSize;
    pBuf->m_RecurseLevels   = pooe->m_RecurseLevels;
    pBuf->m_RecurseFlags    = pooe->m_RecurseFlags;
    pBuf->m_Priority        = pooe->m_Priority;
    pBuf->bDesktop          = pooe->bDesktop;
    pBuf->bChannel          = pooe->bChannel;
    pBuf->bMail             = pooe->bMail;
    pBuf->bGleam            = pooe->bGleam;
    pBuf->bChangesOnly      = pooe->bChangesOnly;
    pBuf->fChannelFlags     = pooe->fChannelFlags;
    pBuf->bNeedPassword     = pooe->bNeedPassword;
    pBuf->m_Cookie          = pooe->m_Cookie;
    pBuf->groupCookie       = pooe->groupCookie;
    pBuf->grfTaskTrigger    = pooe->grfTaskTrigger;
    pBuf->m_Trigger         = pooe->m_Trigger;
    pBuf->clsidDest         = pooe->clsidDest;
    pBuf->status            = pooe->status;

    StrCpyN(pBuf->m_URL,       URL(pooe),      MAX_URL);
    StrCpyN(pBuf->m_Name,      NAME(pooe),     MAX_NAME);
    StrCpyN(pBuf->username,    UNAME(pooe),    MAX_USERNAME);
    StrCpyN(pBuf->password,    PASSWD(pooe),   MAX_PASSWORD);
    StrCpyN(pBuf->statusStr,   STATUS(pooe),   MAX_STATUS);
}

void CopyToMyPooe(POOEBuf pBuf, POOEntry pooe)
{
    UINT    offset = sizeof(OOEntry);
    UINT    srcLen = lstrlen(pBuf->m_URL) + 1;

    ASSERT(pooe);
    ASSERT(pBuf);

    pooe->dwFlags           = pBuf->dwFlags;
    pooe->m_LastUpdated     = pBuf->m_LastUpdated;
    pooe->m_NextUpdate      = pBuf->m_NextUpdate;
    pooe->m_SizeLimit       = pBuf->m_SizeLimit;
    pooe->m_ActualSize      = pBuf->m_ActualSize;
    pooe->m_RecurseLevels   = pBuf->m_RecurseLevels;
    pooe->m_Priority        = pBuf->m_Priority;
    pooe->m_RecurseFlags    = pBuf->m_RecurseFlags;
    pooe->bDesktop          = pBuf->bDesktop;
    pooe->bChannel          = pBuf->bChannel;
    pooe->bMail             = pBuf->bMail;
    pooe->bGleam            = pBuf->bGleam;
    pooe->bChangesOnly      = pBuf->bChangesOnly;
    pooe->fChannelFlags     = pBuf->fChannelFlags;
    pooe->bNeedPassword     = pBuf->bNeedPassword;
    pooe->m_Cookie          = pBuf->m_Cookie;
    pooe->groupCookie       = pBuf->groupCookie;
    pooe->m_Trigger         = pBuf->m_Trigger;
    pooe->grfTaskTrigger    = pBuf->grfTaskTrigger;
    pooe->clsidDest         = pBuf->clsidDest;
    pooe->status            = pBuf->status;

    pooe->m_URL = (LPTSTR)((LPBYTE)pooe + offset);
    srcLen = lstrlen(pBuf->m_URL) + 1;
    StrCpyN(pooe->m_URL, pBuf->m_URL, srcLen);
    offset += srcLen * sizeof (TCHAR);
    pooe->m_URL = (LPTSTR) PtrDifference(pooe->m_URL, pooe);

    pooe->m_Name = (LPTSTR)((LPBYTE)pooe + offset);
    srcLen = lstrlen(pBuf->m_Name) + 1;
    StrCpyN(pooe->m_Name, pBuf->m_Name, srcLen);
    offset += srcLen * sizeof (TCHAR);
    pooe->m_Name = (LPTSTR) PtrDifference(pooe->m_Name, pooe);

    pooe->username = (LPTSTR)((LPBYTE)pooe + offset);
    srcLen = lstrlen(pBuf->username) + 1;
    StrCpyN(pooe->username, pBuf->username, srcLen);
    offset += srcLen * sizeof (TCHAR);
    pooe->username = (LPTSTR) PtrDifference(pooe->username, pooe);

    pooe->password = (LPTSTR)((LPBYTE)pooe + offset);
    srcLen = lstrlen(pBuf->password) + 1;
    StrCpyN(pooe->password, pBuf->password, srcLen);
    offset += srcLen * sizeof (TCHAR);
    pooe->password = (LPTSTR) PtrDifference(pooe->password, pooe);

    pooe->statusStr = (LPTSTR)((LPBYTE)pooe + offset);
    srcLen = lstrlen(pBuf->statusStr) + 1;
    StrCpyN(pooe->statusStr, pBuf->statusStr, srcLen);
    offset += srcLen * sizeof (TCHAR);
    pooe->statusStr = (LPTSTR) PtrDifference(pooe->statusStr, pooe);

    pooe->dwSize = offset;
}

UINT BufferSize(POOEBuf pBuf)
{
    UINT strLen = 0;
    ASSERT(pBuf);

    strLen += lstrlen(pBuf->m_URL)      + 1;
    strLen += lstrlen(pBuf->m_Name)     + 1;
    strLen += lstrlen(pBuf->username)   + 1;
    strLen += lstrlen(pBuf->password)   + 1;
    strLen += lstrlen(pBuf->statusStr)  + 1;

    return strLen * sizeof(TCHAR);
}


typedef struct
{
    int cItems;
    LPCTSTR pszName;
    LPCTSTR pszUrl;
} DELETE_CONFIRM_INFO;

INT_PTR CALLBACK ConfirmDeleteDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{

    switch(message) {

        case WM_INITDIALOG:
        {
            DELETE_CONFIRM_INFO* pInfo = (DELETE_CONFIRM_INFO*)lParam;
            ASSERT (pInfo);
            ASSERT(pInfo->cItems == 1);

            SetListViewToString (GetDlgItem (hDlg, IDC_NAME), pInfo->pszName);
            SetListViewToString (GetDlgItem (hDlg, IDC_LOCATION), pInfo->pszUrl);
        }
        break;

        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDYES:
                case IDNO:
                case IDCANCEL:
                    EndDialog(hDlg, wParam);
                    break;
            }
            break;

        case WM_NOTIFY:
            if (LOWORD(wParam) == IDC_LOCATION)
            {
                NM_LISTVIEW * pnmlv = (NM_LISTVIEW *)lParam;
                ASSERT(pnmlv);
                if (pnmlv->hdr.code == LVN_GETINFOTIP)
                {
                    TCHAR szURL[MAX_URL];
                    LV_ITEM lvi = {0};
                    lvi.mask = LVIF_TEXT;
                    lvi.pszText = szURL;
                    lvi.cchTextMax = ARRAYSIZE(szURL);
                    if (!ListView_GetItem (GetDlgItem (hDlg, IDC_LOCATION), &lvi))
                        return FALSE;

                    NMLVGETINFOTIP  * pTip = (NMLVGETINFOTIP *)pnmlv;
                    ASSERT(pTip->pszText);
                    StrCpyN(pTip->pszText, szURL, pTip->cchTextMax);
                    return TRUE;
                }
            }
        return FALSE;

        default:
            return FALSE;

    } // end of switch

    return TRUE;
}

BOOL ConfirmDelete(HWND hwnd, UINT cItems, LPMYPIDL * ppidl)
{
    ASSERT(ppidl);
    INT_PTR iRet;

    // Check if the user is restricted from deleting URLs.
    // If they're deleting multiple, we'll fail if any can fail.
    UINT i;
    for (i = 0; i < cItems; i++)
    {
        if (ppidl[i]->ooe.bChannel)
        {
            if (SHRestricted2(REST_NoRemovingChannels, URL(&(ppidl[i]->ooe)), 0))
            {
                if (IsWindow(hwnd))
                    SGMessageBox(hwnd, IDS_RESTRICTED, MB_OK);
                return FALSE;
            }
        }

        if (!ppidl[i]->ooe.bDesktop)
        {
            // FEATURE: What about desktop components?
            if (SHRestricted2(REST_NoRemovingSubscriptions, URL(&(ppidl[i]->ooe)), 0))
            {
                if (IsWindow(hwnd))
                    SGMessageBox(hwnd, IDS_RESTRICTED, MB_OK);
                return FALSE;
            }
        }
    }

    if (IsWindow(hwnd)) {
        DELETE_CONFIRM_INFO dci = {0};
        dci.cItems = cItems;
        if (cItems == 1)
        {
            dci.pszName = NAME(&(ppidl[0]->ooe));
            dci.pszUrl = URL(&(ppidl[0]->ooe));
            iRet = DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_OBJECTDEL_WARNING),
                        hwnd, ConfirmDeleteDlgProc, (LPARAM)&dci);
        }
        else
        {

            TCHAR szFormat[200];
            //  Enough room for format string and int as string
            TCHAR szBuf[ARRAYSIZE(szFormat) + 11];

            MLLoadString(IDS_DEL_MULTIPLE_FMT, szFormat, ARRAYSIZE(szFormat));
            wnsprintf(szBuf, ARRAYSIZE(szBuf), szFormat, cItems);

            MLLoadString(IDS_DELETE_CAPTION, szFormat, ARRAYSIZE(szFormat));

            MSGBOXPARAMS mbp;

            mbp.cbSize = sizeof(MSGBOXPARAMS);
            mbp.hwndOwner = hwnd;
            mbp.hInstance = MLGetHinst();
            mbp.lpszText = szBuf;
            mbp.lpszCaption = szFormat;
            mbp.dwStyle = MB_YESNO | MB_USERICON;
            mbp.lpszIcon = MAKEINTRESOURCE(IDI_OBJECTDELETED);
            iRet = MessageBoxIndirect(&mbp);
        }
        if (iRet == IDYES)
            return TRUE;
        return FALSE;
    } else  {
        return TRUE;
    }
}

BOOL IsHTTPPrefixed(LPCTSTR szURL)
{
    TCHAR szCanonicalURL[MAX_URL];
    DWORD dwSize = MAX_URL;
    URL_COMPONENTS uc;

    memset(&uc, 0, sizeof(URL_COMPONENTS));
    uc.dwStructSize = sizeof(URL_COMPONENTS);

    // Note:  We explicitly check for and allow the "about:home" URL to pass through here.  This allows
    // the Active Desktop "My Current Home Page" component to specify that URL when creating and managing
    // it's subscription which is consistent with it's use of that form in the browser.
    if (!InternetCanonicalizeUrl(szURL, szCanonicalURL, &dwSize, ICU_DECODE) ||
        !InternetCrackUrl(szCanonicalURL, 0, 0, &uc) ||
        ((INTERNET_SCHEME_HTTP != uc.nScheme) && (INTERNET_SCHEME_HTTPS != uc.nScheme) && (0 != StrCmpI(TEXT("about:home"), szURL))))
    {
        return FALSE;
    }
    return TRUE;
}

//   Checks if global state is offline

BOOL IsGlobalOffline(void)
{
    DWORD   dwState = 0, dwSize = sizeof(DWORD);
    BOOL    fRet = FALSE;
    HANDLE hModuleHandle = LoadLibraryA("wininet.dll");

    if(!hModuleHandle)
        return FALSE;

    if(InternetQueryOption(NULL, INTERNET_OPTION_CONNECTED_STATE, &dwState,
        &dwSize))
    {
        if(dwState & INTERNET_STATE_DISCONNECTED_BY_USER)
            fRet = TRUE;
    }

    return fRet;
}

void SetGlobalOffline(BOOL fOffline)
{
    INTERNET_CONNECTED_INFO ci;

    memset(&ci, 0, sizeof(ci));
    if(fOffline) {
        ci.dwConnectedState = INTERNET_STATE_DISCONNECTED_BY_USER;
        ci.dwFlags = ISO_FORCE_DISCONNECTED;
    } else {
        ci.dwConnectedState = INTERNET_STATE_CONNECTED;
    }

    InternetSetOption(NULL, INTERNET_OPTION_CONNECTED_STATE, &ci, sizeof(ci));
}


//helper function to create one column in a ListView control, add one item to that column,
//size the column to the width of the control, and color the control like a static...
//basically, like SetWindowText for a ListView.  Because we use a lot of ListViews to display
//urls that would otherwise be truncated... the ListView gives us automatic ellipsis and ToolTip.
void SetListViewToString (HWND hLV, LPCTSTR pszString)
{
    ASSERT(hLV);

    LV_COLUMN   lvc = {0};
    RECT lvRect;
    GetClientRect (hLV, &lvRect);
    lvc.mask = LVCF_WIDTH;
    lvc.cx = lvRect.right - lvRect.left;
    if (-1 == ListView_InsertColumn(hLV, 0, &lvc))   {
        ASSERT(0);
    }

    SendMessage(hLV, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_INFOTIP, LVS_EX_INFOTIP);

    LV_ITEM lvi = {0};
    lvi.iSubItem = 0;
    lvi.pszText = (LPTSTR)pszString;
    lvi.mask = LVIF_TEXT;
    ListView_InsertItem(hLV, &lvi);
    ListView_EnsureVisible(hLV, 0, TRUE);

    ListView_SetBkColor(hLV, GetSysColor(COLOR_BTNFACE));
    ListView_SetTextBkColor(hLV, GetSysColor(COLOR_BTNFACE));
}

int WCMessageBox(HWND hwnd, UINT idTextFmt, UINT idCaption, UINT uType, ...)
{
    TCHAR szCaption[256];
    TCHAR szTextFmt[512];
    LPTSTR pszText;
    int result;
    va_list va;

    va_start(va, uType);

    szCaption[0] = 0;

    MLLoadString(idTextFmt, szTextFmt, ARRAYSIZE(szTextFmt));

    if (idCaption <= 0)
    {
        if (NULL != hwnd)
        {
            GetWindowText(hwnd, szCaption, ARRAYSIZE(szCaption));
        }

        //  This handles GetWindowText failure and a NULL hwnd
        if (0 == szCaption[0])
        {
            #if IDS_DEFAULT_MSG_CAPTION < 1
            #error IDS_DEFAULT_MSG_CAPTION is defined incorrectly
            #endif

            idCaption = IDS_DEFAULT_MSG_CAPTION;
        }
    }

    if (idCaption > 0)
    {
        MLLoadString(idCaption, szCaption, ARRAYSIZE(szCaption));
    }

    ASSERT(0 != szCaption[0]);

    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
                  szTextFmt, 0, 0, (LPTSTR)&pszText, 0, &va);

    result = MessageBox(hwnd, pszText, szCaption, uType);

    LocalFree(pszText);

    return result;
}


/////////////////////////////////////////////////////////////////////////////
// SGMessageBox
/////////////////////////////////////////////////////////////////////////////
int SGMessageBox
(
    HWND    hwndParent,
    UINT    idStringRes,
    UINT    uType
)
{
    ASSERT(hwndParent != NULL);
    ASSERT(IsWindow(hwndParent));

    TCHAR szError[512];
    if (!MLLoadString(idStringRes, szError, ARRAYSIZE(szError)))
        return 0;

    TCHAR szTitle[128];
    szTitle[0] = 0;

    if (hwndParent != NULL)
        GetWindowText(hwndParent, szTitle, ARRAYSIZE(szTitle));

    return MessageBox(  hwndParent,
                        szError,
                        ((hwndParent != NULL) ? szTitle : NULL),
                        uType);
}

#ifdef DEBUG
/////////////////////////////////////////////////////////////////////////////
// DumpTaskTrigger
/////////////////////////////////////////////////////////////////////////////
void DumpTaskTrigger
(
    TASK_TRIGGER * pTT
)
{
    TraceMsg(TF_DUMPTRIGGER, "----- BEGIN DumpTaskTrigger -----");

    TraceMsg(TF_DUMPTRIGGER, "cbTriggerSize = %d", pTT->cbTriggerSize);
    TraceMsg(TF_DUMPTRIGGER, "Reserved1 = %d", pTT->Reserved1);
    TraceMsg(TF_DUMPTRIGGER, "wBeginYear = %d", pTT->wBeginYear);
    TraceMsg(TF_DUMPTRIGGER, "wBeginMonth = %d", pTT->wBeginMonth);
    TraceMsg(TF_DUMPTRIGGER, "wBeginDay = %d", pTT->wBeginDay);
    TraceMsg(TF_DUMPTRIGGER, "wEndYear = %d", pTT->wEndYear);
    TraceMsg(TF_DUMPTRIGGER, "wEndMonth = %d", pTT->wEndMonth);
    TraceMsg(TF_DUMPTRIGGER, "wEndDay = %d", pTT->wEndDay);
    TraceMsg(TF_DUMPTRIGGER, "wStartHour = %d", pTT->wStartHour);
    TraceMsg(TF_DUMPTRIGGER, "wStartMinute = %d", pTT->wStartMinute);
    TraceMsg(TF_DUMPTRIGGER, "MinutesDuration = %d", pTT->MinutesDuration);
    TraceMsg(TF_DUMPTRIGGER, "MinutesInterval = %d", pTT->MinutesInterval);
    TraceMsg(TF_DUMPTRIGGER, "rgFlags = %d", pTT->rgFlags);
    TraceMsg(TF_DUMPTRIGGER, "Reserved2 = %d", pTT->Reserved2);
    TraceMsg(TF_DUMPTRIGGER, "wRandomMinutesInterval = %d", pTT->wRandomMinutesInterval);

    switch (pTT->TriggerType)
    {
        case TASK_TIME_TRIGGER_DAILY:
        {
            TraceMsg(TF_DUMPTRIGGER, "DAILY");
            TraceMsg(TF_DUMPTRIGGER, "DaysInterval = %d", pTT->Type.Daily.DaysInterval);
            break;
        }

        case TASK_TIME_TRIGGER_WEEKLY:
        {
            TraceMsg(TF_DUMPTRIGGER, "WEEKLY");
            TraceMsg(TF_DUMPTRIGGER, "WeeksInterval = %d", pTT->Type.Weekly.WeeksInterval);
            TraceMsg(TF_DUMPTRIGGER, "rgfDaysOfTheWeek = %d", pTT->Type.Weekly.rgfDaysOfTheWeek);
            break;
        }

        case TASK_TIME_TRIGGER_MONTHLYDATE:
        {
            TraceMsg(TF_DUMPTRIGGER, "MONTHLY DATE");
            TraceMsg(TF_DUMPTRIGGER, "rgfDays = %d", pTT->Type.MonthlyDate.rgfDays);
            TraceMsg(TF_DUMPTRIGGER, "rgfMonths = %d", pTT->Type.MonthlyDate.rgfMonths);
            break;
        }

        case TASK_TIME_TRIGGER_MONTHLYDOW:
        {
            TraceMsg(TF_DUMPTRIGGER, "MONTHLY DOW");
            TraceMsg(TF_DUMPTRIGGER, "wWhichWeek = %d", pTT->Type.MonthlyDOW.wWhichWeek);
            TraceMsg(TF_DUMPTRIGGER, "rgfDaysOfTheWeek = %d", pTT->Type.MonthlyDOW.rgfDaysOfTheWeek);
            TraceMsg(TF_DUMPTRIGGER, "rgfMonths = %d", pTT->Type.MonthlyDOW.rgfMonths);
            break;
        }

        default:
        {
            ASSERT(FALSE);
            break;
        }
    }

    TraceMsg(TF_DUMPTRIGGER, "-----  END DumpTaskTrigger  -----");
}
#endif  // DEBUG