source: trunk/EraserDll/FileLockResolver.cpp @ 32

// FileLockResolver.cpp
//
// Eraser. Secure data removal. For Windows.
// Copyright © 1997-2001  Sami Tolvanen (sami@tolvanen.com).
// Copyright © 2001-2006  Garrett Trant (support@heidi.ie).
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#include "stdafx.h"
#include "FileLockResolver.h"
#include <fstream>
#include <string>
#include <iterator>
#include <atlbase.h>

#define LOCKED_FILE_LIST_NAME _T("lock")
#define RUNONCE  "Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce"
#define LAUNCHER "Eraserl.exe"

CFileLockResolver::CFileLockResolver(BOOL askUser)
: m_bAskUser(askUser), m_hHandle(ERASER_INVALID_CONTEXT)
{

}
CFileLockResolver::CFileLockResolver(ERASER_HANDLE h, BOOL askUser)
: m_bAskUser(askUser)
{
    SetHandle(h);
}

void 
CFileLockResolver::SetHandle(ERASER_HANDLE h)
{
    m_hHandle = h;
    eraserSetErrorHandler(h, ErrorHandler, this);
}

CFileLockResolver::~CFileLockResolver(void)
{
    Close();
}
struct PathHelper
{
    CString& m_strLockFile;
    PathHelper(CString& lockFile, bool path_only = false)
        :m_strLockFile(lockFile)
    {
    
        char fullname[MAX_PATH];
        char filename[MAX_PATH];
        char extension[MAX_PATH];
        char pathname[MAX_PATH];
        char drive[10];



        GetModuleFileName(AfxGetInstanceHandle(),fullname,sizeof (fullname));
        _splitpath(fullname,drive, pathname, filename, extension); 
        
        m_strLockFile = drive;
        m_strLockFile += pathname;
        if (path_only )
            return;
        m_strLockFile.Format("%s%s%d.%s", drive, pathname, time(0), LOCKED_FILE_LIST_NAME);


    }
};
struct FileData
{
    std::string name;
    int method;
    unsigned int passes;

    FileData()
    {
    }
    FileData(const std::string& fname, int m, unsigned int pass)
        :name(fname), method(m), passes(pass)
    {
    }

    void read(std::istream& is)
    {
    
        is >> std::noskipws;
        std::getline(is, name);
        
    }

    void write(std::ostream& os) const
    {
        
        os << std::noskipws;
        os << name << std::endl;
        
    }
};
std::ostream& operator << (std::ostream& os, const FileData& data)
{
    data.write(os);
    return os;
}
std::istream& operator >> (std::istream& is, FileData& data)
{
    data.read(is);
    return is;
}
void 
CFileLockResolver::HandleError(LPCTSTR szFileName, DWORD dwErrorCode, int em, unsigned int passes)
{
    if (ERROR_LOCK_VIOLATION == dwErrorCode 
        || ERROR_DRIVE_LOCKED == dwErrorCode
        || ERROR_LOCKED == dwErrorCode
        || ERROR_SHARING_VIOLATION == dwErrorCode)
    {
        bool needResolve = true;
        if (TRUE == m_bAskUser )
        {
             needResolve = (IDYES == AfxGetMainWnd()->MessageBox("File locked by another process." 
            "Do you want to Erase after restart?", "Error", MB_YESNO | MB_ICONQUESTION));           
        }

        if (needResolve)
        {
            static PathHelper   path(m_strLockFileList);
            std::ofstream os(m_strLockFileList, std::ios_base::out | std::ios_base::app);       
            os << FileData(szFileName, em, passes);

        }
        

        /*if (TRUE == m_bAskUser 
        && IDYES == AfxGetMainWnd()->MessageBox("File locked by another process." 
        "Do you want to Erase after restart?", "Error", MB_YESNO | MB_ICONQUESTION))
        {
        static PathHelper   path(m_strLockFileList);
        std::ofstream os(m_strLockFileList, std::ios_base::out | std::ios_base::app);       
        os << FileData(szFileName, em, passes);
        }*/
        
    }
    
}

void 
CFileLockResolver::Resolve(LPCTSTR /*szFileName*/)
{
    
}

void 
CFileLockResolver::Resolve(LPCTSTR szFileName, CStringArray& ar)
{
    std::ifstream is(szFileName);
    if (is.fail())
        throw std::runtime_error("Unable to resolve locked files. Can't open file list");

    while (!is.eof()) 
    {
        FileData data;
        is >> data;
        if (!data.name.empty())
            ar.Add(data.name.c_str());
    }
    is.close();
    DeleteFile(szFileName);
}
DWORD 
CFileLockResolver::ErrorHandler(LPCTSTR szFileName, DWORD dwErrorCode, void* ctx, void* param)
{
    CFileLockResolver* self(static_cast<CFileLockResolver*>(param));
    CEraserContext* ectx(static_cast<CEraserContext* >(ctx));
    self->HandleError(szFileName, dwErrorCode, ectx->m_lpmMethod->m_nMethodID, ectx->m_lpmMethod->m_nPasses);
    return 0UL;
}

void
CFileLockResolver::Close()
{
    eraserSetErrorHandler(m_hHandle, NULL, NULL);

    if (m_strLockFileList.IsEmpty())
        return;

    CString strPath;
    PathHelper(strPath, true);
    strPath = CString("\"") + strPath ;
    strPath += LAUNCHER;
    strPath += "\" -rl \"";
    strPath += m_strLockFileList + "\"";

    extern bool no_registry;
    if (!no_registry)
    {
        CRegKey key;
        if (ERROR_SUCCESS == key.Open(HKEY_LOCAL_MACHINE, RUNONCE))
        {
            key.SetStringValue(LAUNCHER, strPath);
            m_strLockFileList = "";
        }
    }
}