BOOL ComputeChecksum(LPCTSTR pszFile, DWORD* pdwResult)
{
  HANDLE h = CreateFile(pszFile, GENERIC_READ, FILE_SHARE_READ,
       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  HANDLE hfm = CreateFileMapping(h, NULL, PAGE_READ, 0, 0, NULL);
  void *pv = MapViewOfFile(hfm, FILE_MAP_READ, 0, 0, 0);
  DWORD dwHeaderSum;
  CheckSumMappedFile(pvBase, GetFileSize(h, NULL),
           &dwHeaderSum, pdwResult);
  UnmapViewOfFile(pv);
  CloseHandle(hfm);
  CloseHandle(h);
  return TRUE;
}

	template<typename T, typename F>
	class handle_guard : noncopyable
	{
		T handle;
		F destructor;
		T invalid_handle;
	public:
		handle_guard(T handle, F destructor, T invalid_handle) : handle(handle), destructor(destructor), invalid_handle(invalid_handle)
		{
		}
		~handle_guard()
		{
			if( handle != invalid_handle )
				destructor(handle);
		}
		T release() {
			T tmp = handle;
			handle = invalid_handle;
			return tmp;
		}
		void reset(T handle) {
			if( this->handle != invalid_handle )
				destructor(this->handle);
			this->handle = handle;
		}
	public:
		operator T() const
		{
			return handle;
		}
	}; // class handle_guard..

    //////////////////////////////////////////////////////////////////////////
    // Константы
    //

    const HANDLE INVALID_HANDLE = NULL;
    const HMODULE INVALIDE_MODULE = NULL;
    const FARPROC INVALIDE_FARPROC = NULL;

    //////////////////////////////////////////////////////////////////////////
    // Типы
    //

    // тип для хранения переменных типа HANDLE
    typedef handle_guard<HANDLE, BOOL (WINAPI*)(HANDLE)> HandleGuard;
    // тип для хранения переменных типа HLOCAL
    typedef handle_guard<HLOCAL, HLOCAL (WINAPI*)(HLOCAL)> LocalMemoryGuard;
    // тип для хранения переменных типа HANDLE
    typedef handle_guard<HMODULE, BOOL (WINAPI*)(HMODULE)> ModuleGuard;

    //////////////////////////////////////////////////////////////////////////
    //  Исключение
    //
    class WinApiException : public std::runtime_error
    {
        // категория (домен) ошибки (сетевая, к примеру, или ошибка базы данных) 
        // определяется приложением
        WORD m_category;

    public:
        explicit WinApiException(const std::string& m, WORD category = 0)
            : std::runtime_error(m), m_category(category)
        {
        }

        explicit WinApiException(const char *m, WORD category = 0)
            : std::runtime_error(m), m_category(category)
        {
        }

        WORD Category() const {
            return m_category;
        }
    }; // class ExecuteException..

    //////////////////////////////////////////////////////////////////////////
    // Утилиты
    // 

    // вернуть объект исключения соответствующий заданному коду ошибки dw
    inline WinApiException GenerateException(WORD category, const std::string& operation, DWORD dw = GetLastError()) {
        HLOCAL lpMsgBuf = 0;
        FormatMessage(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
            FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            dw,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPTSTR) &lpMsgBuf,
            0, NULL );
        LocalMemoryGuard msgGuard(lpMsgBuf, LocalFree, 0); 
        std::string msg(operation);
        if( !msg.empty() ) 
            msg += ": ";
        if( lpMsgBuf )
            msg += reinterpret_cast<const char*>(lpMsgBuf);
        else
            msg += "failed";
        return WinApiException(msg, category);
    }

    // проверить результат вызова WINAPI функции (result) на успех (successResult) и в случае ошибки
    // выбросить исключение в зависимости от значения resultAsWinError
    template<typename T> T CheckSuccess(WORD category, const std::string& operation, T result, T successResult, BOOL resultAsWinError = FALSE) {
        if( result != successResult ) {
            throw GenerateException(category, operation, resultAsWinError ? result : GetLastError());
        }
        return result;
    }

    // проверить результат вызова WINAPI функции (result) на неуспех (failureResult) и в случае ошибки
    // выбросить исключение
    template<typename T> T CheckFailure(WORD category, const std::string& operation, T result, T failureResult) {
        if( result == failureResult ) {
            throw GenerateException(category, operation, GetLastError());
        }
        return result;
    }

BOOL ComputeChecksum(LPCTSTR pszFile, DWORD* pdwResult)
{
  HandleGuard h(
        CheckFailure(0, 
                          "CreateFile", 
                           CreateFile(pszFile, GENERIC_READ, FILE_SHARE_READ,
                                          NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL),
                           INVALID_HANDLE),
        CloseHandle,
        INVALID_HANDLE
  );

  HandleGuard hfm (
        CheckFailure(0, 
                          "CreateFileMapping", 
                           CreateFileMapping(h, NULL, PAGE_READ, 0, 0, NULL),
                           INVALID_HANDLE),
        CloseHandle,
        INVALID_HANDLE
  );
  handle_guard<LPVOID, BOOL (WINAPI*)(LPCVOID)> pv(
        CheckFailure(0, 
                          "MapViewOfFile", 
                           MapViewOfFile(hfm, FILE_MAP_READ, 0, 0, 0),
                           0),
        UnmapViewOfFile,
        0
  );
  DWORD dwHeaderSum;
  CheckSumMappedFile(pvBase, GetFileSize(h, NULL),
           &dwHeaderSum, pdwResult);
  return TRUE;
}