windows-xp/Source/XPSP1/NT/admin/pchealth/sr/srrpc/client/diskcleanup.cpp

/******************************************************************
   Copyright (c) 2000 Microsoft Corporation

   diskcleanup.cpp -- disk cleanup COM object for SR

   Description:
        delete datastores from stale builds


******************************************************************/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>

#include <windef.h>
#include <wtypes.h>
#include <winuser.h>
#include "diskcleanup.h"
#include "resource.h"
#include <utils.h>
#include <srdefs.h>

extern HMODULE ghModule;

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::LoadBootIni
//
//  Synopsis:   parse the boot.ini file
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD CSREmptyVolumeCache2::LoadBootIni()
{
    HANDLE hFile = INVALID_HANDLE_VALUE;
    WCHAR *pwszThisGuid = NULL;
    CHAR *pszContent = NULL;
    CHAR *pszLine = NULL;
    DWORD dwErr = ERROR_SUCCESS;
    CHAR szArcName[MAX_PATH];
    CHAR szOptions[MAX_PATH];

    pwszThisGuid = GetMachineGuid ();  // always exclude the current datastore
    if (pwszThisGuid != NULL && pwszThisGuid[0] != L'\0')
    {
        lstrcpyW (_wszGuid[_ulGuids], s_cszRestoreDir);
        lstrcatW (_wszGuid[_ulGuids], pwszThisGuid );
        _ulGuids++;
    }

    // Read the contents of the boot.ini file into a string.

    hFile = CreateFileW (L"c:\\boot.ini", 
                             GENERIC_READ, 
                             FILE_SHARE_READ,
                             NULL, OPEN_EXISTING, 0, NULL);

    if (INVALID_HANDLE_VALUE == hFile)
    {
        dwErr = GetLastError();
        return dwErr;
    }

    DWORD dwBytesRead = 0;
    DWORD dwBytesToRead = GetFileSize(hFile, NULL);

    if (dwBytesToRead == 0xFFFFFFFF || 0 == dwBytesToRead)
    {
        dwErr = GetLastError();
        goto Err;
    }

    pszContent = new CHAR [dwBytesToRead];

    if (pszContent == NULL)
    {
        dwErr = ERROR_NOT_ENOUGH_MEMORY;
        goto Err;
    }

    if (FALSE==ReadFile(hFile, pszContent, dwBytesToRead, &dwBytesRead, NULL))
    {
        dwErr = GetLastError();
        goto Err;
    }

    if (dwBytesToRead != dwBytesRead)
    {
        dwErr = ERROR_READ_FAULT;
        goto Err;
    }

    CloseHandle (hFile);
    hFile = INVALID_HANDLE_VALUE;

    pszLine = pszContent;
    for (UINT i = 0; i < dwBytesRead; i++)
    {
        if (pszContent[i] == '=')    // field indicator
            pszContent[i] = '\0';    // process only the 1st field

        if (pszContent[i] == '\n')   // end-of-line indicator
        {
            pszContent[i] = '\0';

            if (strncmp (pszLine, "multi", 5) == 0)
            {
                HANDLE hGuidFile;
                WCHAR wcsPath[MAX_PATH];
                WCHAR wcsGuid [RESTOREGUID_STRLEN];
                OBJECT_ATTRIBUTES oa;
                UNICODE_STRING us;
                IO_STATUS_BLOCK iosb;

                wsprintfW (wcsPath, L"\\ArcName\\%hs\\System32\\Restore\\"
                                    L"MachineGuid.txt", pszLine);

                RtlInitUnicodeString (&us, wcsPath);

                InitializeObjectAttributes ( &oa, &us, OBJ_CASE_INSENSITIVE, 
                                             NULL, NULL);

                NTSTATUS nts = NtCreateFile (&hGuidFile,
                        FILE_GENERIC_READ,
                        &oa,
                        &iosb,
                        NULL,
                        FILE_ATTRIBUTE_NORMAL,
                        FILE_SHARE_WRITE | FILE_SHARE_DELETE | FILE_SHARE_READ,
                        FILE_OPEN,
                        FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
                        NULL,
                        0);

                if (!NT_SUCCESS(nts))
                {
                    dwErr = RtlNtStatusToDosError (nts);
                }
                else
                {
                    dwBytesToRead = RESTOREGUID_STRLEN * sizeof(WCHAR);
                    DWORD dwRead = 0;

                    dwErr = ERROR_SUCCESS;

                    if (FALSE == ReadFile (hGuidFile, (BYTE *) wcsGuid, 
                                 dwBytesToRead, &dwRead, NULL))
                    {
                        dwErr = GetLastError();
                    }

                    if (_ulGuids < ARRAYSIZE && ERROR_SUCCESS == dwErr)
                    {
                       lstrcpyW (_wszGuid[_ulGuids], s_cszRestoreDir);
                       lstrcatW (_wszGuid[_ulGuids], (wcsGuid[0]==0xFEFF) ?
                            &wcsGuid[1] : wcsGuid );
                       _ulGuids++;
                    }
                    NtClose (hGuidFile);
                 }
            }
            pszLine = &pszContent [i+1];  // skip to next line
        }
    }

Err:
    if (pszContent != NULL)
        delete [] pszContent;

    if (hFile != INVALID_HANDLE_VALUE)
        CloseHandle (hFile);

    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::EnumDataStores
//
//  Synopsis:   enumerate the data store on a volume
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

DWORD CSREmptyVolumeCache2::EnumDataStores (DWORDLONG *pdwlSpaceUsed,
                                            IEmptyVolumeCacheCallBack *picb,
                                            BOOL fPurge,
                                            WCHAR *pwszVolume)
{
    HANDLE hFind = NULL;
    DWORD dwErr = ERROR_SUCCESS;
    WIN32_FIND_DATA wfd;
    WCHAR wcsPath [MAX_PATH];

    *pdwlSpaceUsed = 0;

    if (pwszVolume == NULL || pwszVolume[0] == L'\0')   // no volume defined
        return dwErr;

    wsprintfW (wcsPath, L"%s%s\\%s*", pwszVolume,
                                      s_cszSysVolInfo, s_cszRestoreDir);

    hFind = FindFirstFileW (wcsPath, &wfd);

    if (hFind == INVALID_HANDLE_VALUE)    // no files
        return dwErr;

    do
    {
        if (TRUE == _fStop)
        {
            FindClose (hFind);
            return ERROR_OPERATION_ABORTED;
        }

        if (!lstrcmp(wfd.cFileName, L".") || !lstrcmp(wfd.cFileName, L".."))
            continue;

        for (UINT i=0; i < _ulGuids; i++)
        {
            if (lstrcmpi (_wszGuid[i], wfd.cFileName) == 0)
            {
                break;   // data store match
            }
        }

        if (i >= _ulGuids)  // no data store match
        {
            if (picb != NULL)
            {
                WCHAR wcsDataStore[MAX_PATH];

                lstrcpyW (wcsPath, pwszVolume);
                lstrcatW (wcsPath, s_cszSysVolInfo);
                lstrcatW (wcsPath, L"\\");
                lstrcatW (wcsPath, wfd.cFileName);

                if (!fPurge)    // calculate space usage
                {
                    dwErr = GetFileSize_Recurse (wcsPath, 
                                                 (INT64*) pdwlSpaceUsed, 
                                                 &_fStop);
                }
                else            // delete the data store
                {
                    dwErr = Delnode_Recurse (wcsPath, TRUE, &_fStop);
                }
            }
            else
            {
                *pdwlSpaceUsed = 1;  // indicate something to clean up
            }
        }
    }
    while (FindNextFileW (hFind, &wfd));

    FindClose (hFind);

    if (picb != NULL)   // update the progress bar
    {
        if (!fPurge)
            picb->ScanProgress (*pdwlSpaceUsed, EVCCBF_LASTNOTIFICATION , NULL); 
        else
            picb->PurgeProgress (*pdwlSpaceUsed,0,EVCCBF_LASTNOTIFICATION,NULL);
    }

    return dwErr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::ForAllMountPoints
//
//  Synopsis:   call EnumerateDataStores for each mount point
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

HRESULT CSREmptyVolumeCache2::ForAllMountPoints (DWORDLONG *pdwlSpaceUsed,
                                                IEmptyVolumeCacheCallBack *picb,
                                                 BOOL fPurge)
{
    DWORD dwErr = ERROR_SUCCESS;

    dwErr = EnumDataStores (pdwlSpaceUsed, picb, fPurge, _wszVolume);

    if (ERROR_SUCCESS == dwErr)
    {
        WCHAR wszMount [MAX_PATH];
        HANDLE hFind = FindFirstVolumeMountPoint (_wszVolume,wszMount,MAX_PATH);

        if (hFind != INVALID_HANDLE_VALUE)
        {
            do
            {
                dwErr = EnumDataStores (pdwlSpaceUsed, picb, fPurge, wszMount);

                if (dwErr != ERROR_SUCCESS)
                    break;
            }
            while (FindNextVolumeMountPoint (hFind, wszMount, MAX_PATH));

            FindVolumeMountPointClose (hFind);
        }
    }

    return HRESULT_FROM_WIN32 (dwErr);
}

//+---------------------------------------------------------------------------
//
//  Function:   CSRClassFactory::CreateInstance
//
//  Synopsis:   create the disk cleanup plugin object
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

HRESULT CSRClassFactory::CreateInstance (IUnknown *pUnkOuter,
                REFIID riid,
                void **ppvObject)
{
    HRESULT hr = S_OK;

    if (pUnkOuter != NULL)
        return CLASS_E_NOAGGREGATION;

    CSREmptyVolumeCache2 *pevc = new CSREmptyVolumeCache2();
    if (pevc == NULL)
        return E_OUTOFMEMORY;

    hr = pevc->QueryInterface (riid, ppvObject);

    pevc->Release();  // release constructor's reference

    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::InitializeEx
//
//  Synopsis:   initialize the disk cleanup plugin object
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

HRESULT CSREmptyVolumeCache2::InitializeEx (
	HKEY hkRegKey,
	const WCHAR *pcwszVolume,
	const WCHAR *pcwszKeyName,
	WCHAR **ppwszDisplayName,
	WCHAR **ppwszDescription,
	WCHAR **ppwszBtnText,
	DWORD *pdwFlags)
{
    DWORDLONG dwlSpaceUsed = 0;
    WCHAR *pwszDisplay = NULL;
    WCHAR *pwszDescription = NULL;
    HRESULT hr=S_OK;

    pwszDisplay = (WCHAR *) CoTaskMemAlloc (MAX_PATH / 2 * sizeof(WCHAR)); 
    if (NULL == pwszDisplay)
    {
        hr = E_OUTOFMEMORY;
        goto Err;
    }

    pwszDescription = (WCHAR *) CoTaskMemAlloc (MAX_PATH * 2 * sizeof(WCHAR));
    if (NULL == pwszDescription)
    {
        hr = E_OUTOFMEMORY;
        goto Err;
    }
    
    if (0 == LoadStringW (ghModule, IDS_DISKCLEANUP_DISPLAY, 
                          pwszDisplay, MAX_PATH / 2))
    {
        hr = HRESULT_FROM_WIN32 (GetLastError());
        goto Err;
    }

    if (0 == LoadStringW (ghModule, IDS_DISKCLEANUP_DESCRIPTION, 
                          pwszDescription, MAX_PATH * 2))
    {
        hr = HRESULT_FROM_WIN32 (GetLastError());
        goto Err;
    }
                               
    lstrcpyW (_wszVolume, pcwszVolume);

    LoadBootIni();  // best effort, okay to fail

    ForAllMountPoints (&dwlSpaceUsed, NULL, FALSE);

    if (pdwFlags)
    {
        *pdwFlags |= (EVCF_ENABLEBYDEFAULT |
                      EVCF_ENABLEBYDEFAULT_AUTO |
                      EVCF_DONTSHOWIFZERO);
    }

    if (dwlSpaceUsed == 0)
        hr = S_FALSE;

Err:
    if (FAILED(hr))
    {
        if (pwszDisplay)
            CoTaskMemFree (pwszDisplay);
        if (pwszDescription)
            CoTaskMemFree (pwszDescription);

        if (ppwszDisplayName)
            *ppwszDisplayName = NULL;
        if (ppwszDescription)
            *ppwszDescription = NULL;
    }
    else
    {
        if (ppwszDisplayName)
            *ppwszDisplayName = pwszDisplay;
        if (ppwszDescription)
            *ppwszDescription = pwszDescription;
    }

    if (ppwszBtnText)                // no advanced button text
        *ppwszBtnText = NULL;

    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::GetSpaceUsed
//
//  Synopsis:   returns how much space can be freed on a volume
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

HRESULT CSREmptyVolumeCache2::GetSpaceUsed ( DWORDLONG *pdwlSpaceUsed,
 	                                         IEmptyVolumeCacheCallBack *picb)

{
    return ForAllMountPoints (pdwlSpaceUsed, picb, FALSE); 
}

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::Purge
//
//  Synopsis:   frees the disk space on a volume
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

HRESULT CSREmptyVolumeCache2::Purge ( DWORDLONG dwlSpaceToFree,
                                      IEmptyVolumeCacheCallBack *picb)
{
    return ForAllMountPoints (&dwlSpaceToFree, picb, TRUE); 
}

//+---------------------------------------------------------------------------
//
//  Function:   CSREmptyVolumeCache2::Deactivate
//
//  Synopsis:   signal the disk cleanup plugin to stop processing
//
//  Arguments:
//
//  History:    20-Jul-2000  HenryLee    Created
//
//----------------------------------------------------------------------------

HRESULT CSREmptyVolumeCache2::Deactivate (DWORD *pdwFlags)
{
    HRESULT hr=S_OK;

    if (pdwFlags)
        *pdwFlags = 0;  // no flags to be returned

    _fStop = TRUE;

    return hr;
}