cWinINet.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWinINet_H
#define _INC_cWinINet_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetAddr.h"
#include "cNetURL.h"
#include "../Http/cHttpCommon.h"
#include "GrayCore/include/cFile.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cFileCopier.h"
 
#ifdef _WIN32
#define USE_WinInet
#endif
 
#ifdef USE_WinInet
#include <WinInet.h>
 
#ifdef _MFC_VER
#include <afxinet.h>
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cWinINet);
 
        class cWinINetSession;
        class cWinINetConnection;
 
        class GRAYLIB_LINK cWinINetHandle       // : public cHandlePtr<HINTERNET>
        {
 
        private:
                HINTERNET m_h;  
 
        public:
                cWinINetHandle(HINTERNET h = HANDLE_NULL) noexcept
                : m_h(h)
                {
                }
                ~cWinINetHandle()
                {
                        Close();
                }
 
                void Close();
 
                HINTERNET get_Handle() const noexcept
                {
                        return m_h;
                }
                bool isValidHandle() const noexcept
                {
                        return m_h != HANDLE_NULL ;
                }
 
                void AttachHandle(HINTERNET h)
                {
                        if (m_h != h)
                        {
                                Close();
                                m_h = h;
                        }
                }
 
                bool QueryOption(DWORD dwOption, void* pData, OUT DWORD* pdwDataSize)
                {
                        return ::InternetQueryOption(get_Handle(), dwOption, pData, pdwDataSize);
                }
                bool SetOption(DWORD dwOption, void* pData, DWORD dwDataSize)
                {
                        return ::InternetSetOption(get_Handle(), dwOption, pData, dwDataSize);
                }
        };
 
        class GRAYLIB_LINK cWinINetBase : public cWinINetHandle
        {
 
                friend class cWinINetSession;
                typedef cWinINetHandle SUPER_t;
 
        public:
                virtual cWinINetBase* GetParent() const noexcept = 0;
                virtual cWinINetSession* GetSession() const noexcept = 0;
 
        protected:
                cWinINetBase() noexcept
                {
                }
                virtual ~cWinINetBase()
                {
                        ASSERT(!isValidHandle());
                }
                virtual void Close()
                {
                        SUPER_t::Close();
                }
        };
 
        //**************************************************************************
 
        class GRAYLIB_LINK cWinINetFile
        : public cWinINetBase
        , public cRefBase
        , public cStream
        {
                typedef cWinINetBase SUPER_t;
 
        public:
                cRefPtr<cWinINetConnection> m_pConnection;      
 
        protected:
                cWinINetFile(cWinINetConnection* pConnection);
                virtual ~cWinINetFile();
 
        public:
                virtual cWinINetBase* GetParent() const noexcept;
                virtual cWinINetSession* GetSession() const noexcept;
 
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override;
        };
 
        class GRAYLIB_LINK cHttpRequest : public cWinINetFile
        {
                typedef cWinINetFile SUPER_t;
        public:
                cHttpRequest(cWinINetConnection* pConnection, HTTPVERB_TYPE nVerb, const GChar_t* pstrObjectName,
                        const GChar_t* pszReferrer = nullptr,
                        const GChar_t** ppszAcceptTypes = nullptr,
                        DWORD dwFlags = INTERNET_FLAG_EXISTING_CONNECT | INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_UI);
                virtual ~cHttpRequest()
                {
                        Close();
                }
 
                bool AddRequestHeaders(const GChar_t* pstrHeaders, StrLen_t  dwHeadersLen, DWORD dwModifiers);
                bool SendRequest(const GChar_t* pstrHeaders = nullptr, StrLen_t dwHeadersLen = 0, LPVOID lpOptional = nullptr, DWORD dwOptionalLen = 0);
                bool SendRequestEx(LPINTERNET_BUFFERS lpBuffersIn);
                // void AddRequestHeaders(const GChar_t* pszHeaders);
                bool QueryInfoStatusCode(DWORD& dwStatusCode);
                bool QueryInfo(DWORD dwInfoLevel, cString& str, DWORD* pdwIndex = nullptr) const;
        };
        typedef cRefPtr<cHttpRequest> cHttpRequestPtr;
 
        class GRAYLIB_LINK cFtpRequest : public cWinINetFile
        {
                typedef cWinINetFile SUPER_t;
        public:
                cFtpRequest(cWinINetConnection* pConnection) noexcept
                        : cWinINetFile(pConnection)
                {
                }
                virtual ~cFtpRequest()
                {
                        Close();
                }
        };
 
        //**************************************************************************
 
        class GRAYLIB_LINK cWinINetConnection
        : public cWinINetBase
        , public cRefBase
        {
 
                typedef cWinINetBase SUPER_t;
                friend class cWinINetSession;
 
        protected:
                cWinINetSession* m_pSession;    
                int m_eConnectState;                    
 
                CString m_strServerName;                
                NET_PORT_t m_wPort;
 
        public:
                cWinINetConnection(cWinINetSession* pSession, const GChar_t* pstrServer,
                        NET_PORT_t nPort = k_NET_PORT_INVALID);
                virtual ~cWinINetConnection();
 
                virtual cWinINetBase* GetParent() const noexcept override;
                virtual cWinINetSession* GetSession() const noexcept override
                {
                        return m_pSession;      // get my parent.
                }
                CString GetServerName() const noexcept
                {
                        return m_strServerName;
                }
                bool isConnected() const noexcept;
        };
 
        class GRAYLIB_LINK cHttpConnection : public cWinINetConnection
        {
                typedef cWinINetConnection SUPER_t;
        public:
                cHttpConnection(cWinINetSession* pSession,
                        const GChar_t* pstrServer, NET_PORT_t nPort = k_NET_PORT_INVALID,
                        const GChar_t* pstrUserName = nullptr, const GChar_t* pstrPassword = nullptr);
                virtual ~cHttpConnection()
                {
                        Close();
                }
 
                cHttpRequestPtr OpenRequest(HTTPVERB_TYPE nVerb, const GChar_t* pstrObjectName,
                        const GChar_t* pstrReferer = nullptr,
                        const GChar_t** ppstrAcceptTypes = nullptr,
                        DWORD dwFlags = INTERNET_FLAG_EXISTING_CONNECT | INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_UI);
        };
        typedef cRefPtr<cHttpConnection> cHttpConnectionPtr;
 
        class GRAYLIB_LINK cFtpConnection : public cWinINetConnection
        {
                typedef cWinINetFile SUPER_t;
        public:
                cFtpConnection(cWinINetSession* pSession,
                        const GChar_t* pstrServer)
                        : cWinINetConnection(pSession, pstrServer)
                {}
                virtual ~cFtpConnection()
                {
                        Close();
                }
        };
 
        //**************************************************************************
 
        class GRAYLIB_LINK cWinINetSession : public cWinINetBase
        {
 
                typedef cWinINetBase SUPER_t;
                friend class cWinINetConnection;
                friend class cWinINetFile;
 
        public:
                bool m_bCallbackEnabled;
 
        private:
                static void CALLBACK OnStatusCallbackStatic(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus,
                        LPVOID lpvStatusInformation, DWORD dwStatusInformationLength); // static
 
        public:
                /* explicit */ cWinINetSession(const GChar_t* pstrAgent = nullptr,
                        DWORD dwAccessType = PRE_CONFIG_INTERNET_ACCESS,
                        const GChar_t* pstrProxyName = nullptr,
                        const GChar_t* pstrProxyBypass = nullptr,
                        DWORD dwFlags = 0);
                virtual ~cWinINetSession();
 
                cHttpConnectionPtr GetHttpConnection(const GChar_t* pstrServer,
                        NET_PORT_t nPort = k_NET_PORT_INVALID,
                        const GChar_t* pstrUserName = nullptr, const GChar_t* pstrPassword = nullptr);
 
                virtual cWinINetBase* GetParent() const noexcept override
                {
                        return nullptr;
                }
                virtual cWinINetSession* GetSession() const noexcept override
                {
                        return const_cast<cWinINetSession*>(this);
                }
 
                bool EnableStatusCallback(bool bEnable = true);
                virtual void Close() override;
 
                static HRESULT GRAYCALL GetProxyConfig(cString& rsProxy, cString& rsProxyBypass);
 
                // Overridables
                virtual void OnStatusCallback(cWinINetBase* pContext, DWORD dwInternetStatus,
                        LPVOID lpvStatusInformation, DWORD dwStatusInformationLength);
 
                UNITTEST_FRIEND(cWinINet);
        };
 
        class GRAYLIB_LINK cWinINetCopier
        : public cWinINetSession
        , public IFileCopier
        {
                typedef cWinINetSession SUPER_t;
 
        public:
                // cRefPtr<cWinINetConnection> m_pConnection;   //!< the connection to the HTTP/FTP server.
                cRefPtr<cHttpConnection> m_pConnection; 
                cNetURL m_url;                          
 
        public:
                cWinINetCopier(const GChar_t* pszAgent = _GT(GRAY_NAMES), DWORD dwAccessType = PRE_CONFIG_INTERNET_ACCESS);
                virtual ~cWinINetCopier();
 
                bool isConnected() const
                {
                        if (m_pConnection == nullptr)
                                return false;
                        return m_pConnection->isConnected();
                }
 
                void Close();
 
                // IFileCopier
                virtual cStringA get_ConnectName() const override;
                virtual HRESULT Connect(const FILECHAR_t* pszDevice) override;
                virtual HRESULT RequestFile(const FILECHAR_t* pszSrcName, const FILECHAR_t* pszDestPath, IStreamProgressCallback* pProgress, FILE_SIZE_t nOffsetStart, FILE_SIZE_t* pnRequestSizeEst) override;
                virtual HRESULT SendFile(const FILECHAR_t* pszSrcPath, const FILECHAR_t* pszDestName, IStreamProgressCallback* pProgress, FILE_SIZE_t nOffsetStart, FILE_SIZE_t nSize) override;
 
                // cWinINetSession
                virtual void OnStatusCallback(cWinINetBase* pContext, DWORD dwInternetStatus,
                        LPVOID lpvStatusInformation, DWORD dwStatusInformationLength) override;
        };
} 
#endif
#endif