warfiledriverfilewin32.cpp

ftpserver very good sample

    mCurrentFileOffset += dwBytesWritten;
}

void
WarFileDriverFileWin32::Flush() throw(WarException)
{
    Validate();
    ::FlushFileBuffers(mFileHandle);
}

war_flen_t WarFileDriverFileWin32::GetLength() throw(WarException)
{
    Validate();

    DWORD dwSizeLow = 0, dwSizeHigh = 0;

    dwSizeLow = GetFileSize(mFileHandle, &dwSizeHigh);
    if (dwSizeLow == 0xffffffff)
    {
        WarError system_error;
        system_error.Capture();
        if (system_error.SystemError() != NO_ERROR)
            WarThrow(system_error, NULL);
    }
    
    LARGE_INTEGER li;
    li.LowPart = dwSizeLow;
    li.HighPart = dwSizeHigh;

    return li.QuadPart;
}

war_flen_t
WarFileDriverFileWin32::Seek(war_flen_t fileOffset, 
                             SeekModes seekMode)
                             throw(WarException)
{
    Validate();

    war_flen_t new_offset = mCurrentFileOffset;

    switch(seekMode)
    {
    case WAR_SEEK_BEGIN:
        new_offset = fileOffset;
        break;
    case WAR_SEEK_CURRENT:
        new_offset += fileOffset;
        break;
    case WAR_SEEK_END:
        new_offset = GetLength() + fileOffset;
        break;
    default:
        WarThrow(WarError(WAR_ERR_INVALID_ARGUMENT), NULL);
    }

    if (new_offset < 0)
        WarThrow(WarError(WAR_ERR_INVALID_ARGUMENT), NULL);

    LARGE_INTEGER li;
    
    li.QuadPart = new_offset;

    li.LowPart = ::SetFilePointer(mFileHandle, li.LowPart, 
        &li.HighPart, FILE_BEGIN);
    
    WarSystemError sys_err(WAR_FERR_SEEK_FAILED);
    if (li.LowPart == 0xFFFFFFFF 
        && (sys_err.SystemError() != NO_ERROR))
        WarThrow(sys_err, NULL);
    
    return mCurrentFileOffset = li.QuadPart;
}

void WarFileDriverFileWin32::WriteWithCallback(
    war_transfer_buffer_ptr_t& outBuffer)
    throw(WarException)
{
    WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_WriteWithCallback);

    DWORD dwBytes = 0;
    ol_result_t *pResult = AllocResult(OP_WRITE);
    pResult->mBufferPtr = outBuffer;

    LARGE_INTEGER li;
    li.QuadPart = mCurrentFileOffset;
    pResult->mOverlappedData.Offset = li.LowPart;
    pResult->mOverlappedData.OffsetHigh  = li.HighPart ;

    if (!WriteFile(mFileHandle, 
        pResult->mBufferPtr->GetBuffer(),
        pResult->mBufferPtr->mBytesUsed,
        &dwBytes,
        &pResult->mOverlappedData))
    {
        WarSystemError system_error;
        
        switch(system_error.SystemError())
        {
        case ERROR_IO_PENDING:
            break; // No action
        case ERROR_HANDLE_EOF:
            DeleteResult(pResult);
            WarThrow(WarError(WAR_FERR_END_OF_FILE, ERROR_HANDLE_EOF), NULL);
            break;
        default:
            DeleteResult(pResult);
            WarThrow(system_error, NULL);
        }
    }

    // May move the internal file-offset off the physical size!
    mCurrentFileOffset += outBuffer->GetLength();
    
    WAR_DB_PERFMON_INC(WAR_PRFDEBUG_NUM_FILEPENDINGIO);
}

void WarFileDriverFileWin32::ReadWithCallback(
    war_transfer_buffer_ptr_t& inBuffer)
    throw(WarException)
{
    WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_ReadWithCallback);


    DWORD dwBytes = 0;
    ol_result_t *pResult;

    {
        WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_ReadWithCallback_ALLOC);
        pResult = AllocResult(OP_READ);
    }

    {
        WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_ReadWithCallback_PREP);
        
        pResult->mBufferPtr = inBuffer;

        LARGE_INTEGER li;
        li.QuadPart = mCurrentFileOffset;
        pResult->mOverlappedData.Offset = li.LowPart;
        pResult->mOverlappedData.OffsetHigh  = li.HighPart ;
    }

    BOOL result;
    
    {
        WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_ReadWithCallback_READFILE);

        result = ReadFile(mFileHandle, 
            pResult->mBufferPtr->GetBuffer(),
            pResult->mBufferPtr->GetLength(),
            &dwBytes,
            &pResult->mOverlappedData);
    }

    {
        WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_ReadWithCallback_POSTPRC);
        
        if (!result)
        {
            WarSystemError system_error;
            WarError throw_error;
            
            switch(system_error.SystemError())
            {
            case ERROR_IO_PENDING:
                break; // No action
            case ERROR_HANDLE_EOF:
                throw_error = WarError(WAR_FERR_END_OF_FILE, ERROR_HANDLE_EOF);
                break;
            default:
                throw_error = system_error;
                break;
            }
            
            if (throw_error.LocalError() != WAR_ERR_OK)
            {
                DeleteResult(pResult);
                WarThrow(throw_error, NULL);
            }
        }
        
        // May move the internal file-offset off the physical size!
        mCurrentFileOffset += inBuffer->GetLength();
    }

    WAR_DB_PERFMON_INC(WAR_PRFDEBUG_NUM_FILEPENDINGIO);
}

//============================= ACCESS     ===================================
//============================= INQUIRY    ===================================

bool WarFileDriverFileWin32::IsOpen()
{
    return (mFileHandle != INVALID_HANDLE_VALUE);
}


/////////////////////////////// PROTECTED  ///////////////////////////////////

WarFileDriverFileWin32::ol_result_def *
WarFileDriverFileWin32::AllocResult(WarFileDriverFileWin32::IoOperationE operation)
{
    WarAutoLock my_lock(msBufferLock);

    ol_result_t *p;

    if (mspBufferList)
    {
        p = mspBufferList;
        mspBufferList = mspBufferList->mpNext;
    }
    else
    {
        WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_AllocResult_NEW);

        p = new ol_result_t;
    }
    
    
    WAR_PROFILE_FUNC(WAR_FP_WarFileDriverFileWin32_AllocResult_ASSIGN);
    
    p->mpThis = this;
    p->mFilePtr = mpCompanion;
    memset(&(p->mOverlappedData), 0, sizeof(OVERLAPPED));
    p->mOperation = operation;
    
    
    return p;
}


VOID CALLBACK WarFileDriverFileWin32::FileIOCompletionRoutine(
        DWORD dwErrorCode,                // completion code
        DWORD dwNumberOfBytesTransfered,  // number of bytes transferred
        LPOVERLAPPED lpOverlapped         // I/O information buffer
        )
{
    WarLog err_log(WARLOG_ERROR, "WarFileDriverFileWin32::FileIOCompletionRoutine()");
    ol_result_t *pResult = (ol_result_def *)lpOverlapped;
    WarError err((dwErrorCode != WAR_ERR_OK) 
        ? WAR_ERR_SYSTEM_ERROR : WAR_ERR_OK, (int)dwErrorCode);

    try
    {
        pResult->mBufferPtr->mBytesUsed 
            = dwNumberOfBytesTransfered;

        if (err && (err.SystemError() == ERROR_HANDLE_EOF))
            err = WAR_FERR_END_OF_FILE;

        switch(pResult->mOperation)
        {
        case OP_READ:
            WAR_DB_PERFMON_DEC(WAR_PRFDEBUG_NUM_FILEPENDINGIO);
            pResult->mpThis->OnRead(err, pResult->mBufferPtr);
            break;
        case OP_WRITE:
            WAR_DB_PERFMON_DEC(WAR_PRFDEBUG_NUM_FILEPENDINGIO);
            pResult->mpThis->OnWritten(err, pResult->mBufferPtr);
            break;
        }
    }
    
    catch(WarException& ex)
    {
        err_log << "Caught unexcpected exception. Operation was "
            << pResult->mOperation
            << ' '
            << ex.Explain();
            war_endl;
    }
#if WAR_CATCH_ALL
    catch(...)
    {
         err_log << "Caught unhandled exception. Operation was "
            << pResult->mOperation
            << war_endl;
    }
#endif
    
    DeleteResult(pResult);
}

void WarFileDriverFileWin32::DeleteResult(ol_result_def *presult)
{
    WarAutoLock my_lock(msBufferLock);

    // Prepere for re-use
    presult->mpNext = mspBufferList;
    mspBufferList = presult;

    // Release autopointers
    presult->mFilePtr = NULL;
    presult->mBufferPtr = NULL;
}


/////////////////////////////// PRIVATE    ///////////////////////////////////