cHttpClient.h

Go to the documentation of this file.

//
//
#ifndef _INC_cHttpClient_H
#define _INC_cHttpClient_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cHttpHeader.h"
#include "../Net/cNetURL.h"
#include "../Net/cNetStream.h"
#include "GrayCore/include/cStreamQueue.h"
#include "GrayCore/include/cFile.h"
#include "GrayCore/include/cFileCopier.h"
#include "GrayCore/include/cIniSection.h"
#include "GrayCore/include/cMime.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cHttpClient);
 
        class GRAYLIB_LINK cHttpPart
        {
 
        public:
                static const StrLen_t k_nLenBoundaryPrefix = 2;         
                static const StrLen_t k_nLenBoundary = (8 + 16);        
 
                MIME_TYPE m_eContentType;                       
                cStringA m_sContentDisposition;         
 
        protected:
                virtual size_t get_BodyLength() const = 0;
                virtual HRESULT WriteBody(cStreamOutput* pClient, IStreamProgressCallback* pProgress = nullptr) = 0;
 
        public:
                static void GRAYCALL CreateBoundary(OUT char* pszBoundary);
                static StrLen_t GRAYCALL GetBoundarySize();
                static HRESULT GRAYCALL WriteBoundary(cStreamOutput* pClient, const char* pszBoundary);
 
                cHttpPart(MIME_TYPE eContentType = MIME_TEXT, cStringA sContentDisposition = "")
                        : m_eContentType(eContentType)
                        , m_sContentDisposition(sContentDisposition)
                {
                }
                virtual ~cHttpPart()
                {
                }
 
                size_t get_PartLength() const;
                HRESULT WritePart(cStreamOutput* pClient, const char* pszBoundary, IStreamProgressCallback* pProgress = nullptr);
        };
 
        class GRAYLIB_LINK cHttpPartStr : public cHttpPart
        {
        public:
                cStringA m_sBody;       
 
        public:
                cHttpPartStr(MIME_TYPE eContentType = MIME_TEXT, cStringA sContentDisposition = "")
                        : cHttpPart(eContentType, sContentDisposition)
                {
                }
                virtual ~cHttpPartStr()
                {
                }
                virtual size_t get_BodyLength() const
                {
                        return m_sBody.GetLength();
                }
                virtual HRESULT WriteBody(cStreamOutput* pClient, IStreamProgressCallback* pProgress = nullptr)
                {
                        UNREFERENCED_PARAMETER(pProgress);
                        if (pClient == nullptr)
                                return E_POINTER;
                        return pClient->WriteString(m_sBody);
                }
        };
 
        class GRAYLIB_LINK cHttpPartFile : public cHttpPart
        {
        public:
                cFile m_File;   
        public:
                cHttpPartFile(MIME_TYPE eContentType = MIME_TEXT, cStringA sContentDisposition = "")
                        : cHttpPart(eContentType, sContentDisposition)
                {
                }
                virtual ~cHttpPartFile()
                {
                }
                virtual size_t get_BodyLength() const
                {
                        return m_File.GetLength();
                }
                virtual HRESULT WriteBody(cStreamOutput* pClient, IStreamProgressCallback* pProgress = nullptr)
                {
                        if (pClient == nullptr)
                                return E_POINTER;
                        return pClient->WriteStream(m_File, UINT_MAX, pProgress);
                }
        };
 
        class GRAYLIB_LINK cHttpClientBody
        {
 
        public:
                static const size_t k_MaxChunkSize = 1024 * 1024;       
 
                cHeapBlock m_datablock;
 
                bool m_bTransferEncodingChunked;                
                bool m_bWaitForChunkHeader;                             
                cStreamProgress m_TransferChunk;                
 
#ifdef USE_ZLIB
                cStreamQueue m_DecoderQueue;                    
                cNewPtr<cStreamInput> m_pDecoder;               
#endif
 
        public:
                cHttpClientBody(bool bTransferEncodingChunked)
                        : m_bTransferEncodingChunked(bTransferEncodingChunked)
                        , m_bWaitForChunkHeader(bTransferEncodingChunked)
                        , m_TransferChunk(0, 0)
                {
                }
 
                HRESULT InitContentEncoding(cStringA sContentEncoding, STREAM_POS_t nTotal);
        };
 
        class GRAYLIB_LINK cHttpClient
                : public IFileCopier
                , public cHttpCommon
        {
 
        public:
                const char* const m_pszAgentName;       
                cNetURL m_url;                  
 
        protected:
                cStream* m_pStream;             
 
        public:
                cHttpClient(cStream* pStream = nullptr, const char* pszServerURL = nullptr, const char* pszAgentName = GRAY_NAMES);
                virtual ~cHttpClient();
 
                void AttachStream(cStream* pStream)
                {
                        // redirect to another stream. Maybe for SSL.
                        m_pStream = pStream;
                }
                cStream* get_Stream() const
                {
                        return m_pStream;
                }
 
                static StrLen_t GRAYCALL Encode_POST(char* pszArgs, StrLen_t nLenMax, const cIniSectionData& args);
 
                HRESULT Send_GET(HTTPVERB_TYPE eVerb, cStringA sObject);
                HRESULT Send_POST(const char* pszReferer, const char* pszArgs, StrLen_t nLenArgs);
                HRESULT Send_POST(const char* pszReferer, const cIniSectionData& args);
                HRESULT Send_POST(cHttpPart** ppParts, int iParts, IStreamProgressCallback* pProgress = nullptr);
 
                // IFileCopier
                virtual cStringA get_ConnectName() const override;
                virtual HRESULT Connect(const FILECHAR_t* pszServerURL) 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;
 
                HRESULT WaitForHeader(OUT cHttpHeaderServer& Head, IStreamProgressCallback* pProgress, TIMESYSD_t timeout = cTimeSys::k_DMAX);
                HRESULT ReadBodyChunk(cHttpClientBody& body);
                HRESULT WaitForBody(const cHttpHeader& Head, cStreamOutput* psBody, IStreamProgressCallback* pProgress, OUT FILE_SIZE_t* pnRequestSizeEst);
                HRESULT WaitForResponse(OUT cHttpHeaderServer& Head, cStreamOutput* psBody, IStreamProgressCallback* pProgress, FILE_SIZE_t* pnRequestSizeEst);
 
                UNITTEST_FRIEND(cHttpClient);
        };
 
        class GRAYLIB_LINK cHttpCopier : public cHttpClient
        {
                typedef cHttpClient SUPER_t;
 
        public:
                cNetStream m_Stream;    
 
        public:
                cHttpCopier(const char* pszServerURL = nullptr, const char* pszAgentName = GRAY_NAMES);
                virtual ~cHttpCopier();
 
                virtual HRESULT Connect(const FILECHAR_t* pszServerURL) override;
                void Close();
 
                bool isConnected() const
                {
                        // ASSUME m_pStream == m_Stream;
                        return m_Stream.isConnected();
                }
        };
} 
#endif // _INC_cHttpClient_H