warfiledriverfilewin32.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarFileDriverFileWin32.h"   // class implemented

#ifndef WAR_FILE_DRIVER_WIN32_H
#   include "WarFileDriverWin32.h"
#endif

#ifndef WAR_OS_H
#   include "WarOs.h"
#endif

#ifndef WAR_LOG_H
#   include "WarLog.h"
#endif

#ifndef WAR_FILE_H
#   include "WarFile.h"
#endif

#ifndef WAR_SVR_WIN32_NT_ENGINE_H
#   include "WarSvrWin32NtEngine.h"
#endif

#ifndef WAR_PERFMON_DEF_H
#   include "WarPerfmonDef.h"
#endif

#ifndef WAR_FUNCTION_PROFILER_H
#   include "WarFunctionProfiler.h"
#endif


#define Win32FileDriver() (*(WarFileDriverWin32 *)mpDriver)

#ifdef _DEBUG
#define Validate()\
if (mFileHandle == INVALID_HANDLE_VALUE) \
    WarThrow(WarError(WAR_ERR_NOT_OPEN), NULL);
#else
#define Validate()
#endif


/////////////////////////////// PUBLIC ///////////////////////////////////////


WarFileDriverFileWin32::ol_result_t *WarFileDriverFileWin32::mspBufferList;
WarCriticalSection WarFileDriverFileWin32::msBufferLock;

//============================= LIFECYCLE ====================================

WarFileDriverFileWin32::WarFileDriverFileWin32(WarFileDriver *pDriver)
: WarFileDriverFile(pDriver),
mFileHandle(INVALID_HANDLE_VALUE),
mCurrentFileOffset(0)
{}


WarFileDriverFileWin32::~WarFileDriverFileWin32()
{
}


//============================= OPERATORS ====================================



//============================= OPERATIONS ===================================


void
WarFileDriverFileWin32::Open(const WarUrl& openUrl, 
                             war_uint32_t openFlags) 
                             throw(WarException)
{
    if (mFileHandle != INVALID_HANDLE_VALUE)
        WarThrow(WarError(WAR_ERR_ALREADY_OPEN), NULL);

    WarLog debug_log(WARLOG_DEBUG, "WarFileDriverFileWin32::Open()");
    
    mPath = openUrl.GetFilePath();

    war_uint32_t file_access_mode = 0;
    war_uint32_t file_share_mode = 0;
    war_uint32_t file_creation_flags = 0;
    war_uint32_t file_creation_attributes = 0;
    war_uint32_t file_attributes = ::GetFileAttributes(mPath.GetPath());
    bool file_exist = (file_attributes != 0xffffffff);
    
    if (file_exist)
    {
        // Must be a file...
        if (file_attributes & FILE_ATTRIBUTE_DIRECTORY)
            WarThrow(WarError(WAR_FERR_PATH_IS_A_DIR), NULL);

        if (openFlags & F_NOTEXIST)
            WarThrow(WarError(WAR_ERR_NAME_EXIST), NULL);
    }
    
    /* Too buggy! Cannot create files 
    
      if (Win32FileDriver().GetCmpMode(openUrl) == PCMP_CASE_SENSITIVE)
    {
        file_creation_attributes |= FILE_FLAG_POSIX_SEMANTICS;
        mPath.MakePosixPath();
    } */  
    
    if (openFlags & F_READ)
    {
        file_access_mode |= GENERIC_READ;
        if (!(openFlags & (F_WRITE | F_APPEND)) &&
            !(openFlags & (F_CREATE | F_NOTEXIST | F_MUSTEXIST | F_TRUNCATE)))
            openFlags |= F_MUSTEXIST;
    }

    if (openFlags & (F_WRITE | F_APPEND))
    {
        file_access_mode |= GENERIC_WRITE;
        if (openFlags & F_TEXT)
            file_access_mode |= GENERIC_READ; // Need to read in order to seek in file

        if (!(openFlags & (F_READ)) &&
            !(openFlags & (F_CREATE | F_NOTEXIST | F_MUSTEXIST | F_TRUNCATE)))
            openFlags |= F_CREATE;
    }
    
    if (openFlags & F_SHREAD)
        file_share_mode |= FILE_SHARE_READ;
    
    if (openFlags & F_SHWRITE)
        file_share_mode |= FILE_SHARE_WRITE;
    
    if (openFlags & F_EXCLUSIVE)
        file_share_mode &= ~(F_SHWRITE | F_SHREAD);
    
    if (openFlags & F_SEQUENTIAL)
        file_creation_attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
    
    if ((openFlags & F_CALLBACK) && WarOs::GetOs().IsNt())
        file_creation_attributes |= FILE_FLAG_OVERLAPPED;
    
    
    switch (openFlags & (F_CREATE | F_NOTEXIST | F_MUSTEXIST | F_TRUNCATE))
    {
    case F_CREATE:
        if (openFlags & F_APPEND)
            file_creation_flags = OPEN_ALWAYS;
        else
            file_creation_flags = CREATE_ALWAYS;
        break;
    case F_CREATE | F_NOTEXIST:
        file_creation_flags = CREATE_NEW;
        break;
    case F_CREATE | F_MUSTEXIST:
        file_creation_flags = OPEN_EXISTING;
        break;
    case F_TRUNCATE:
    case F_CREATE | F_TRUNCATE:
        // TRUNCATE_EXISTING will fail if the file don't exist.
        if (!file_exist)
        {
            file_creation_flags = CREATE_ALWAYS;	// File don't exist
            break;
        }
        // Fall trough
    case F_MUSTEXIST | F_TRUNCATE:
    case F_CREATE | F_MUSTEXIST | F_TRUNCATE:
        file_creation_flags = TRUNCATE_EXISTING;
        //bCheckBannedList = TRUE;
        break;
    case F_NOTEXIST:
        file_creation_flags = CREATE_NEW;
        //bCheckBannedList = TRUE;
        break;
    case F_MUSTEXIST:
        file_creation_flags = OPEN_EXISTING;
        break;
    default:
        WarThrow(WarError(WAR_ERR_INVALID_ARGUMENT), NULL);
    }

retry_open:
    int num_retries = 0;
    
    mFileHandle = ::CreateFile(mPath.GetPath(), 
        file_access_mode, file_share_mode, NULL, 
        file_creation_flags, file_creation_attributes, NULL);
    
    if (mFileHandle == INVALID_HANDLE_VALUE)
    {
        WarSystemError syserr;

        if (!num_retries++ 
            && (syserr.SystemError() == ERROR_LOGON_FAILURE))
        {
            if (mpDriver->LogonToUrl(openUrl))
                goto retry_open; 
        }
        
        if (debug_log)
        {
            debug_log << "Open '"
                << mPath.GetPath()
                << "' failed. Open flags: "
                << syserr
                << mpDriver->WarExplainFags(openFlags)
                << war_endl;
        }
        
        WarThrow(syserr, NULL);
    }

    if (openFlags & F_CALLBACK)
    {
        if (::CreateIoCompletionPort(mFileHandle,
            WarSvrWin32NtEngine::GetEngine().GetPort(),
            (DWORD)FileIOCompletionRoutine,
            0) == NULL)
        {
            WarSystemError system_error;

            ::CloseHandle(mFileHandle);
            mFileHandle = INVALID_HANDLE_VALUE;
            
            if (debug_log)
            {
                debug_log << "Open '"
                    << mPath.GetPath()
                    << "' failed on CreateIoCompletionPort. openFlags: "
                    << system_error
                    << mpDriver->WarExplainFags(openFlags)
                    << war_endl;
            }
            
            WarThrow(system_error, "CreateIoCompletionPort()");
        }
    }
    
    if (openFlags & F_APPEND)
        Seek(0, WAR_SEEK_END);
    
    //done:
    mFlags = openFlags;
}


void
WarFileDriverFileWin32::Close() throw(WarException)
{
    if (mFileHandle != INVALID_HANDLE_VALUE)
        ::CloseHandle(mFileHandle);
    mFileHandle = INVALID_HANDLE_VALUE;
}

war_uint32_t
WarFileDriverFileWin32::Read(war_cptr_t Buf, 
                             war_uint32_t Bytes)
                             throw(WarException)
{
    Validate();
    
    DWORD dwBytesRead = 0;
    if (!::ReadFile(mFileHandle, Buf, Bytes, &dwBytesRead, NULL))
    {
        WarError syserr(WAR_FERR_READ_FAILED);
        syserr.Capture();

        if (syserr.SystemError() == ERROR_HANDLE_EOF)
            syserr = WAR_FERR_END_OF_FILE;
        
        WarThrow(syserr, NULL);
    }
    
    mCurrentFileOffset += dwBytesRead;
    return dwBytesRead;
}

void
WarFileDriverFileWin32::Write(war_ccptr_t Buf, 
                              war_uint32_t Bytes)
                              throw(WarException)
{
    Validate();
    DWORD dwBytesWritten = 0;
    if (!::WriteFile(mFileHandle, Buf, Bytes, &dwBytesWritten, NULL))
    {
        WarError sys_err;
        sys_err.Capture(WAR_FERR_WRITE_FAILED);
        WarThrow(sys_err, NULL);
    }

    if (Bytes != dwBytesWritten)
    {
        // Seek back to preserve file-offset integrity
        if (dwBytesWritten)
            Seek(mCurrentFileOffset - dwBytesWritten, WAR_SEEK_BEGIN);
        
        WarThrow(WarError(WAR_FERR_WRITE_FAILED), NULL);
    }