TnbFtpFile.h

[詳解]

#pragma once
#include "TnbInternetHandle.h"
#include "TnbWriter.h"
#include "TnbDummyCollection.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CFtpSession
{
public:
 
    CFtpSession(void)
    {
    }
 
    CFtpSession(const CFtpSession& other) : m_hWininet(other.m_hWininet), m_hSession(other.m_hSession) 
    {
    }
 
    CFtpSession& operator=(const CFtpSession& other)
    {
        m_hWininet = other.m_hWininet;
        m_hSession = other.m_hSession;
        return *this;
    }
 
    bool IsValid(void) const
    {
        return m_hSession.IsValid();
    }
 
    bool Open(LPCTSTR lpszAgent, LPCTSTR lpszServerName, LPCTSTR lpszUserName = NULL, LPCTSTR lpszPassword = NULL)
    {
        Close();
        if ( ! m_hWininet.Open(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0) )
        {
            return false;
        }
        m_hSession = m_hWininet.Connect(lpszServerName, INTERNET_DEFAULT_FTP_PORT,
                            lpszUserName, lpszPassword, INTERNET_SERVICE_FTP, 0, 0);
        return m_hSession.IsValid();
    }
 
    void Close(void)
    {
        m_hWininet.Close();
        m_hSession.Close();
    }
 
    operator CInternetHandle&(void)
    {
        return m_hSession;
    }
 
    bool CreateRemoteDir(LPCTSTR lpszRemoteDir)
    {
        return m_hSession.CreateDirectory(lpszRemoteDir);
    }
 
    bool RemoveRemoteDir(LPCTSTR lpszRemoteDir)
    {
        return m_hSession.RemoveDirectory(lpszRemoteDir);
    }
 
    bool GetCurrentRemoteDir(LPTSTR _lpszCurrentRemoteDir, DWORD& _length)
    {
        return m_hSession.GetCurrentDirectory(_lpszCurrentRemoteDir, &_length);
    }
 
    bool SetCurrentRemoteDir(LPCTSTR lpszRemoteDir)
    {
        return m_hSession.SetCurrentDirectory(lpszRemoteDir);
    }   
 
    bool GetRemoteFile(LPCTSTR lpszNewLocalFile, LPCTSTR lpszRemoteFile, BOOL fFailIfExists, DWORD dwFlagsAndAttributes, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        return m_hSession.GetFile(lpszRemoteFile, lpszNewLocalFile, fFailIfExists, dwFlagsAndAttributes, dwFlags, dwContext);
    }
 
    bool PutLocalFile(LPCTSTR lpszNewRemoteFile, LPCTSTR lpszLocalFile, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        return m_hSession.PutFile(lpszLocalFile, lpszNewRemoteFile, dwFlags, dwContext);
    }
 
    bool DeleteRemoteFile(LPCTSTR lpszRemoteFile)
    {
        return m_hSession.DeleteFile(lpszRemoteFile);
    }
 
    bool RenameRemoteFile(LPCTSTR lpszOldName, LPCTSTR lpszNewName)
    {
        return m_hSession.RenameFile(lpszOldName, lpszNewName);
    }
 
private:
    CInternetHandle m_hWininet;     
    CInternetHandle m_hSession;     
};
 
 
 
class CFtpFileReader : public IReader
{
    DEFSUPER(IReader);
    mutable CFtpSession             m_hSession;     
    mutable CPointerHandleT<DWORD>  m_phdwPointer;  
    mutable CInternetHandle         m_hFile;        
    CStr                            m_strFileName;  
    DWORD                           m_dwAccess;     
    DWORD                           m_dwFlags;      
    DWORD_PTR                       m_dwContext;    
    friend class CFtpFileWriter;                    
 
    size_t m_Padding(size_t size) const
    {
        try
        {
            CDummyCollectionT<BYTE> dc;
            return ReadInto(dc, size);
        }
        catch(CTnbException& e)
        {
            e.OnCatch();
        }
        return INVALID_SIZE;
    }
 
    void m_SetFilePointer(DWORD dw) const
    {
        m_phdwPointer = new DWORD(dw);
    }
 
    DWORD m_GetFilePointer(void) const
    {
        if ( m_phdwPointer.IsNull() )
        {
            return 0;
        }
        return *m_phdwPointer;
    }
 
    void m_SetParamForOpen(LPCTSTR lpszFileName, DWORD dwAccess, DWORD dwFlags, DWORD_PTR dwContext)
    {
        m_strFileName   = lpszFileName;
        m_dwAccess      = GENERIC_READ;
        m_dwFlags       = dwFlags;
        m_dwContext     = dwContext;
    }
 
    bool m_Reopen(void) const
    {
        CInternetHandle& h = m_hSession;
        if ( h.IsValid() )
        {
            m_hFile.Close();
            m_hFile = h.OpenFile(m_strFileName, m_dwAccess, m_dwFlags, m_dwContext);
            m_SetFilePointer(0);
            return m_hFile.IsValid();
        }
        return false;
    }
 
    void m_AddFilePointer(DWORD dw) const
    {
        if ( m_phdwPointer.IsNull() )
        {
            m_phdwPointer = new DWORD(dw);
        }
        else
        {
            *m_phdwPointer += dw;
        }
    }
 
public:
 
    bool Open(CFtpSession& sec, LPCTSTR lpszFileName, DWORD dwFlags = FTP_TRANSFER_TYPE_BINARY, DWORD_PTR dwContext = 0)
    {
        Close();
        m_hSession = sec;
        m_SetParamForOpen(lpszFileName, GENERIC_READ, dwFlags, dwContext);
        return m_Reopen();
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        DWORD dwRead;
        if ( m_hFile.ReadFile(_P, ToDword(size), &dwRead) )
        {
            m_AddFilePointer(dwRead);
            return dwRead;
        }
        throw CReadFailureException(::GetLastError());
    }
 
    LPCTSTR GetOpenName(void) const
    {
        return m_strFileName;
    }
 
    virtual bool CanRead(void) const
    {
        return m_hFile.IsValid();
    }
 
    LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        INT_PTR r = -1;
        int size = ToInt(GetSize());
        int ofs = ToInt(llOffset);
        DWORD current = m_GetFilePointer();
        switch ( eSeek )
        {
        case TOP:
            if ( ofs >= 0 && ofs <= size )
            {
                r = ofs;
            }
            break;
        case CURRENT:
            r = current + ofs;
            if ( r > size )
            {
                r = -1;
            }
            break;
        case END:
            if ( (-ofs) >= 0 && (-ofs) <= size )
            {
                r = size + ofs;
            }
            break;
        default:
            ASSERT(false);
            break;
        }
        if ( r >= 0 )
        {
            INT_PTR i = r - current;    //現在の位置から正負の方向？
            if ( i < 0 )
            {
                //== 負ならReopenする。
                if ( ! m_Reopen() )
                {
                    r = -1;
                }
                else
                {
                    i = r;
                }
            }
            if ( i > 0 )
            {
                r = m_Padding(i);
            }
            if ( r >= 0 )
            {
                r = m_GetFilePointer();
            }
        }
        return r;
    }
 
    LONGLONG GetSize(void) const
    {
        ::SetLastError(NO_ERROR);
        ULARGE_INTEGER r;
        r.LowPart = m_hFile.GetFileSize(&r.HighPart);
        if ( ::GetLastError() != NO_ERROR )
        {
            return -1;
        }
        return static_cast<LONGLONG>(r.QuadPart);
    }
 
    void Close(void)
    {
        m_hFile.Close();
        m_hSession.Close();
    }
};
 
 
 
class CFtpFileWriter : public IWriter
{
    DEFSUPER(IWriter);
    CFtpFileReader      m_ftp;  
public:
 
    virtual void Close(void)
    {
        m_ftp.Close();
    }
 
    bool Open(CFtpSession& sec, LPCTSTR lpszFileName, DWORD dwFlags = FTP_TRANSFER_TYPE_BINARY, DWORD_PTR dwContext = 0)
    {
        Close();
        m_ftp.m_hSession = sec;
        m_ftp.m_SetParamForOpen(lpszFileName, GENERIC_READ | GENERIC_WRITE, dwFlags, dwContext);
        return m_ftp.m_Reopen();
    }
 
    bool New(CFtpSession& sec, LPCTSTR lpszFileName, DWORD dwFlags = FTP_TRANSFER_TYPE_BINARY, DWORD_PTR dwContext = 0)
    {
        Close();
        if ( ! sec.DeleteRemoteFile(lpszFileName) )
        {
            return false;
        }
        return Open(sec, lpszFileName, dwFlags, dwContext);
    }
 
    LPCTSTR GetOpenName(void) const
    {
        return m_ftp.m_strFileName;
    }
 
    virtual bool CanRead(void) const
    {
        return m_ftp.m_hFile.IsValid();
    }
 
    virtual bool CanWrite(void) const
    {
        return CanRead() && (m_ftp.m_dwAccess & GENERIC_WRITE) != 0;
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        return m_ftp.Read(size, _P);
    }
 
    virtual void SetEnd(void)
    {
        throw CNotSupportException();
    }
 
    virtual void Write(size_t size, LPCVOID P)
    {
        DWORD dwWriten;
        if ( m_ftp.m_hFile.WriteFile(P, ToDword(size), &dwWriten) )
        {
            m_ftp.m_AddFilePointer(dwWriten);
            if ( size == dwWriten )
            {
                return;
            }
        }
        throw CWriteFailureException(::GetLastError());
    }
 
    LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        return m_ftp.Seek(llOffset, eSeek);
    }
 
    virtual LONGLONG GetSize(void) const
    {
        return m_ftp.GetSize();
    }
};
 
 
 
}; // TNB