warfiledriver.cpp

ftpserver very good sample

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


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

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

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

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


/// Try to move a file. If that fails, try to copy it.
void WarFileDriver::WarGenericMoveFile(const WarUrl& From, 
                                    const WarUrl& To) const
                                    throw(WarException)
{
    try
    {
        WarMoveFile(From, To);
        return;
    }
    catch(WarException)
    {
    }

    try
    {
        WarCopyFile(From, To);
    }
    catch(WarException& e)
    {
        throw e;
    }

    try
    {
        WarDeleteFile(From);
    }
    catch(WarException)
    {
    }
}

void WarFileDriver::WarGenericCreateDirectories(const WarUrl& Path) const
throw(WarException)
{
    WarUrl my_url = Path;
    my_url.ErasePath();

    war_cfsysstr_t p = Path.GetFilePath().GetPath();
    std::basic_string<war_sysch_t> segment;
    const war_syspath_t& origin = Path.GetFilePath();
    bool virgin = true;

    if (!*p)
        return;
        
    for(;; p++)
    {
        if (!*p || origin.IsSlash(*p))
        {
            my_url << segment.c_str();
            if (!virgin && !segment.empty())
            {   
                war_stat_t st;
                FileTypeE my_type = WarExamine(my_url, st);

                if (my_type == FT_VOID)
                    WarCreateDirectory(my_url);
            }
            
            if (!*p)
                break;

            segment = (war_sysch_t)origin.GetSlash();
            virgin = false;
        }
        else
        {
            segment += *p;
        }
    }
}


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

std::string WarFileDriver::WarExplainFags(war_uint32_t fileFlags) const
{
    std::string explanation;
    
    if (fileFlags & F_CALLBACK)
        explanation += "F_CALLBACK ";

    if (fileFlags & F_READ)
        explanation += "F_READ ";

    if (fileFlags & F_WRITE)
        explanation += "F_WRITE ";

    if (fileFlags & F_APPEND)
        explanation += "F_APPEND ";

    if (fileFlags & F_UNLINK)
        explanation += "F_UNLINK ";

    if (fileFlags & F_EXECUTE)
        explanation += "F_EXECUTE ";

    if (fileFlags & F_SHREAD)
        explanation += "F_SHREAD ";

    if (fileFlags & F_SHWRITE)
        explanation += "F_SHWRITE ";

    if (fileFlags & F_EXCLUSIVE)
        explanation += "F_EXCLUSIVE ";

    if (fileFlags & F_TEXT)
        explanation += "F_TEXT ";

    if (fileFlags & F_CALLBACK)
        explanation += "F_CALLBACK ";

    if (fileFlags & F_CREATE)
        explanation += "F_CREATE ";

    if (fileFlags & F_NOTEXIST)
        explanation += "F_NOTEXIST ";

    if (fileFlags & F_MUSTEXIST)
        explanation += "F_MUSTEXIST ";

    if (fileFlags & F_TRUNCATE)
        explanation += "F_TRUNCATE ";

    if (fileFlags & F_SEQUENTIAL)
        explanation += "F_SEQUENTIAL ";

    if (fileFlags & F_TEMPORARY)
        explanation += "F_TEMPORARY ";

    if (fileFlags & F_RATIO)
        explanation += "F_RATIO ";

    return explanation;
}

/// Examines a file. Does not throw.
WarFileDriver::FileTypeE 
WarFileDriver::WarExamine(const WarUrl& path, war_stat_t& st) const
{
    FileTypeE rval = FT_INVALID;

    ::memset(&st, 0, sizeof(st));

    try
    {
        WarStat(path, st);
    
        if ((st.st_mode & S_IFDIR) == S_IFDIR)
            rval = FT_DIR;
#ifndef WIN32
        else if ((st.st_mode & S_IFLNK) == S_IFLNK)
            rval = FT_LINK;
#endif
        else if ((st.st_mode & S_IFREG) == S_IFREG)
            rval = FT_NORMAL;
        else
            rval = FT_SPECIAL;
    }
    catch(WarException)
    {
        rval = FT_VOID;
    }

    return rval;
}

void WarFileDriver::WarGetFileModTime(const WarUrl& fsysUrl,
                      WarTime& outTime,
                      size_t& outPrecision) const
                      throw(WarException)
{
    war_stat_t st;
    WarStat(fsysUrl, st);
    outTime = st.st_mtime;
}




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

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