TnbInternetHandle.h

[詳解]

#pragma once
#include "TnbDynamicFunc.h"
#include "TnbPointerHandle.h"
#include "TnbStrVector.h"
 
 
 
#include <Wininet.h>
#pragma comment(lib,"Wininet.lib")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 struct TPhInternetCloseHandle
 {
    void operator()(HINTERNET P) { ::InternetCloseHandle(P); }
 };
#endif
 
 
 
typedef TNB::CPointerHandleBaseT<HINTERNET, TPhInternetCloseHandle> CInternetHandleHandle;
 
 
 
class CInternetHandle
{
    CInternetHandleHandle m_handle; 
 
public:
 
    CInternetHandle(HINTERNET h = NULL) : m_handle(h) 
    {
    }
 
    CInternetHandle(const CInternetHandle& other) : m_handle(other.m_handle) 
    {
    }
 
    CInternetHandle& operator=(const CInternetHandle& other)
    {
        m_handle = other.m_handle;
        return *this;
    }
 
    void Close(void)
    {
        m_handle.Null();
    }
 
    bool IsValid(void) const
    {
        return ! m_handle.IsNull();
    }
 
    bool Open(LPCTSTR lpszAgent, DWORD dwAccessType, LPCTSTR lpszProxy = NULL, 
                LPCTSTR lpszProxyBypass = NULL, DWORD dwFlags = 0)
    {
        m_handle = ::InternetOpen(lpszAgent, dwAccessType, lpszProxy, lpszProxyBypass, dwFlags);
        return ! m_handle.IsNull();
    }
 
    CInternetHandle Connect(LPCTSTR lpszServerName, INTERNET_PORT tPort, LPCTSTR lpszUserName,
            LPCTSTR lpszPassword, DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        return ::InternetConnect(m_handle, lpszServerName, tPort, lpszUserName, lpszPassword, dwService, dwFlags, dwContext);   
    }
 
    CInternetHandle OpenUrl(LPCTSTR lpszUrl, LPCTSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        return ::InternetOpenUrl(m_handle, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext);
    }
 
    CInternetHandle HttpOpenRequest(LPCTSTR lpszVerb, LPCTSTR lpszObjectName, LPCTSTR lpszVersion, LPCTSTR lpszReferrer, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        return ::HttpOpenRequest(m_handle, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, NULL, dwFlags, dwContext);
 
    }
 
    CInternetHandle HttpOpenRequest(LPCTSTR lpszVerb, LPCTSTR lpszObjectName, LPCTSTR lpszVersion, LPCTSTR lpszReferrer, const CStrVector& acceptTypes, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        CWorkMemT<LPCTSTR> a(acceptTypes.GetSize() + 1);
        loop ( i, acceptTypes )
        {
            a[i] = acceptTypes.ReferBuffer()->ReferBuffer();
        }
        a[acceptTypes.GetSize()] = NULL;
        return ::HttpOpenRequest(m_handle, lpszVerb, lpszObjectName, lpszVersion, lpszReferrer, a, dwFlags, dwContext);
    }
 
    bool HttpSendRequest(LPCTSTR lpszHeaders, DWORD dwHeadersLength, LPVOID lpOptional, DWORD dwOptionalLength)
    {
        return !! ::HttpSendRequest(m_handle, lpszHeaders, dwHeadersLength, lpOptional, dwOptionalLength);
    }
 
    bool HttpQueryInfo(DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
    {
        return !! ::HttpQueryInfo(m_handle, dwInfoLevel, lpBuffer, lpdwBufferLength, lpdwIndex);
    }
 
    bool QueryOption(DWORD dwOption, LPVOID _lpBuffer, LPDWORD _lpdwBufferLength) const
    {
        return !! ::InternetQueryOption(m_handle, dwOption, _lpBuffer, _lpdwBufferLength);
    }
 
    bool ReadFile(LPVOID _lpBuffer, DWORD dwNumberOfBytesToRead, LPDWORD _lpdwNumberOfBytesRead) const
    {
        return !! ::InternetReadFile(m_handle, _lpBuffer, dwNumberOfBytesToRead, _lpdwNumberOfBytesRead);
    }
 
    DWORD SetFilePointer(LONG lDistanceToMove, LONG* pReserved, DWORD dwMoveMethod, DWORD_PTR dwContext = 0) const
    {
        return ::InternetSetFilePointer(m_handle, lDistanceToMove, pReserved, dwMoveMethod, dwContext);
    }
 
    bool SetOption(DWORD dwOption, LPVOID lpBuffer, DWORD dwBufferLength)
    {
        return !! ::InternetSetOption(m_handle, dwOption, lpBuffer, dwBufferLength);
    }
 
    INTERNET_STATUS_CALLBACK SetStatusCallback(INTERNET_STATUS_CALLBACK pInetProc)
    {
        return ::InternetSetStatusCallback(m_handle, pInetProc);
    }
 
    bool FindNextFile(LPVOID pFindData) const
    {
        return !! ::InternetFindNextFile(m_handle, pFindData);
    }
 
    bool WriteFile(LPCVOID lpBuffer, DWORD dwNumberOfBytesToWrite, LPDWORD lpdwNumberOfBytesWritten)
    {
        return !! ::InternetWriteFile(m_handle, lpBuffer, dwNumberOfBytesToWrite, lpdwNumberOfBytesWritten);
    }
    
    bool CreateDirectory(LPCTSTR lpszDirName)
    {
        return !! ::FtpCreateDirectory(m_handle, lpszDirName);
    }
 
    bool DeleteFile(LPCTSTR lpszFileName)
    {
        return !! ::FtpDeleteFile(m_handle, lpszFileName);
    }
 
    CInternetHandle FindFirstFile(LPCTSTR lpszSearchFile, LPWIN32_FIND_DATA lpFindFileData, DWORD dwFlags, DWORD_PTR dwContext = 0) const
    {
        return ::FtpFindFirstFile(m_handle, lpszSearchFile, lpFindFileData, dwFlags, dwContext);
    }
 
    bool GetCurrentDirectory(LPTSTR _lpszCurrentDirectory, LPDWORD _lpdwLength) const
    {
        return !! ::FtpGetCurrentDirectory(m_handle, _lpszCurrentDirectory, _lpdwLength);
    }
 
    bool GetFile(LPCTSTR lpszRemoteFile, LPCTSTR lpszLocalFile, BOOL fFailIfExists, 
                DWORD dwFlagsAndAttributes, DWORD dwFlags, DWORD_PTR dwContext = 0) const
    {
        return !! ::FtpGetFile(m_handle, lpszRemoteFile, lpszLocalFile, fFailIfExists, dwFlagsAndAttributes, dwFlags, dwContext);
    }
 
    DWORD GetFileSize(LPDWORD _lpdwFileSizeHigh) const
    {
        typedef DWORD (WINAPI* P)(HINTERNET, LPDWORD);
        try
        {
            return CDynamicFuncT<P>("Wininet.dll", "FtpGetFileSize")()(m_handle, _lpdwFileSizeHigh);
        }
        catch(CNullPointerException& e)
        {
            ASSERT0(false, "CInternetHandle::GetFileSize()", 
                "API FtpGetFileSize()が見つかりません。\nWininet.dll が古い可能性があります。");
            e.OnCatch();
        }
        return 0;
    }
 
    CInternetHandle OpenFile(LPCTSTR lpszFileName, DWORD dwAccess, DWORD dwFlags, DWORD_PTR dwContext = 0)
    {
        return ::FtpOpenFile(m_handle, lpszFileName, dwAccess, dwFlags, dwContext);
    }
 
    bool PutFile(LPCTSTR lpszLocalFile, LPCTSTR lpszNewRemoteFile, DWORD dwFlags, DWORD_PTR dwContext)
    {
        return !! ::FtpPutFile(m_handle, lpszLocalFile, lpszNewRemoteFile, dwFlags, dwContext);
    }
 
    bool RemoveDirectory(LPCTSTR lpszDirName)
    {
        return !! ::FtpRemoveDirectory(m_handle, lpszDirName);
    }
 
    bool RenameFile(LPCTSTR lpszOldFileName, LPCTSTR lpszNewFileName)
    {
        return !! ::FtpRenameFile(m_handle, lpszOldFileName, lpszNewFileName);
    }
 
    bool SetCurrentDirectory(LPCTSTR lpszDirName)
    {
        return !! ::FtpSetCurrentDirectory(m_handle, lpszDirName);
    }
 
    static bool AttemptConnect(void)
    {
        return ::InternetAttemptConnect(0) == ERROR_SUCCESS;
    }
 
    static bool CanonicalizeUrl(LPTSTR _lpszDstUrl, DWORD& _dwDstSize, LPCTSTR lpszUrl, DWORD dwFlags, LPCTSTR lpszRelativeUrl = NULL)
    {
        BOOL boRc = FALSE;
        if ( lpszRelativeUrl == NULL )
        {
            boRc = ::InternetCanonicalizeUrl(lpszUrl, _lpszDstUrl, &_dwDstSize, dwFlags);
        }
        else
        {
            boRc = ::InternetCombineUrl(lpszUrl, lpszRelativeUrl, _lpszDstUrl, &_dwDstSize, dwFlags);
        }
        return !! boRc;
    }
};
 
 
 
}; // TNB