http_funcs.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _HTTP_FUNCS_H
#define _HTTP_FUNCS_H
 
#include <nbrtos.h>
#include <nettypes.h>
#include <dns.h>
#include <webclient/web_buffers.h>
 
class ParsedURI
{
public:
    enum eProtocol_t {
        eProto_None,
        eProto_HTTP,
        eProto_HTTPS,
        eProto_SSH,
        eProto_SMTP,
        eProto_MQTT,
        eProto_MQTTS,
        eProto_WS,
        eProto_WSS
    };
private:
 
    char URIBuf[256];
    const char *CachedProtoStr;
    char *CachedHost;
    char *CachedPath;
    const char *UserAgent;
    IPADDR CachedHostIp;
    tick_t ValidUntil;
    uint16_t CachedPort;
    eProtocol_t CachedProto;
    uint8_t len;
 
    #ifdef WEB_CLIENT_SSL_SUPPORT
        bool secure;
    #endif
 
    int  advanceCompareState(int state);
    bool equals(const char *pUrl);
    bool equals(const ParsedURI &rhs);
    static ParsedURI *getParsedURI(OS_FIFO *pFifo);
   public:
        void NewUri(const char *uri, uint16_t timeout = 20 * TICKS_PER_SECOND, bool skipLookup = false);
 
 
        ParsedURI();
 
        ParsedURI(const char *uri, uint16_t timeout = 20 * TICKS_PER_SECOND, bool skipLookup = false)
            : ParsedURI()
        {
            NewUri(uri, timeout, skipLookup);
        };
 
 
        bool valid() const
        {
            return ((ValidUntil == 0xFFFFFFFF)|| (ValidUntil &&(((uint32_t)((int32_t)ValidUntil - ((int32_t)TimeTick))) >= 0)))&& URIBuf[0];
        };
 
 
        const char *GetPath()
        {
                if(CachedPath) return CachedPath;
                return "";
        };
 
 
        const char *GetHost()
        {
                return CachedHost;
        };
 
 
        IPADDR GetAddr()
        {
            if (valid())
                return CachedHostIp;
            else
                return IPADDR4::NullIP();
        };
 
 
        uint16_t GetPort()
        {
                return CachedPort;
        };
 
        eProtocol_t GetProto()
        {
                return CachedProto;
        }
 
        #ifdef WEB_CLIENT_SSL_SUPPORT
            bool IsSecure()
            {
                return secure;
            }
        #endif
        void dump();
 
        void Invalidate() { ValidUntil = 0;  CachedHostIp.SetNull(); };
        void Resolve(bool block = true, uint16_t timeout = 20 * TICKS_PER_SECOND);
 
        //Get an FD from UDP rx and send out requests...
        int start_fd_dns();
        bool process_fd_dns(int fd);
 
        ParsedURI & operator=(const char *rhs) { NewUri(rhs); return *this; }
        ParsedURI & operator=(const ParsedURI &rhs);
        bool operator==(const ParsedURI &rhs) { return equals(rhs); }
        bool operator!=(const ParsedURI &rhs) { return !equals(rhs); }
        void SetUserAgent(const char* ua){UserAgent=ua;}
        const char * GetUserAgent() {return UserAgent; }
};
 
 
class HttpMethod {
public:
    enum Value : uint8_t {
        Options = 0, //< @b
        Get     = 1, //< @b
        Head    = 2, //< @b
        Post    = 3, //< @b
        Put     = 4, //< @b
        Delete  = 5, //< @b
        Trace   = 6, //< @b
        Connect = 7, //< @b
        Patch   = 8, //< @b
 
        Unknown = 0xFF //< @b
    };
 
    HttpMethod() = default;
    constexpr HttpMethod(Value v) : val(v) { }
 
    // Allow switch and comparisons.
    constexpr operator Value() const { return val; }
    // Prevent usage: if(method)
    explicit operator bool() const = delete;
 
    constexpr bool operator==(HttpMethod rhs) const { return val == rhs.val; }
    constexpr bool operator!=(HttpMethod rhs) const { return val != rhs.val; }
    constexpr bool operator==(Value rhs) const { return val == rhs; }
    constexpr bool operator!=(Value rhs) const { return val != rhs; }
 
    constexpr const HttpMethod &operator=(HttpMethod rhs) { val = rhs.val; return *this; }
 
    const char *String() const;
    int Strlen() const;
 
    bool ReqBodyAllowed() const;
    bool RespBodyAllowed() const;
private:
    Value val;
 
};
 
void SetHttpDiag(bool b);
void SetHttpDiag(int level);
 
 
#ifndef WebErrorReporterFunc
typedef void(WebErrorReporterFunc)(int ErrorState);
#endif
 
extern WebErrorReporterFunc *pWebErrorReporter;
 
 
class ParsedJsonDataSet;   // Forward declaration
 
int DoMultipartStartHttp(HttpMethod method,
                         ParsedURI &TheUri,
                         const char *separator,
                         uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND,
                         uint32_t contentLength = 0
                         );
 
int DoMultipartStartHttp(HttpMethod method,
                         const char *pUrl,
                         const char *separator,
                         uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND,
                         uint32_t contentLength = 0);
 
inline int DoMultipartStartPost(ParsedURI &TheUri,
                         const char *separator,
                         uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND,
                         uint32_t contentLength = 0)
{
    return DoMultipartStartHttp(HttpMethod::Post, TheUri, separator, TIMEOUT_WAIT,
            contentLength);
}
 
inline int DoMultipartStartPost(const char *pUrl,
                         const char *separator,
                         uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND,
                         uint32_t contentLength = 0)
{
    return DoMultipartStartHttp(HttpMethod::Post, pUrl, separator, TIMEOUT_WAIT, contentLength);
}
 
void DoMultipartItem(int tcpfd, const char *Disposition, const char *separator,const unsigned char * data, int len);
 
void DoMultipartBoundary(int tcpfd, const char *Disposition, const char *separator);
 
bool DoMultipartFinished(int tcpfd, const char *separator, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoMultipartFinished(int tcpfd, const char *separator, NBString &result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoMultipartFinished(tcpfd, separator, sbo,TIMEOUT_WAIT);
}
 
bool DoUrlEncodedFormHttp(  HttpMethod method,
                            ParsedURI & TheUri,
                            char * headers,
                            char * form_data,
                            buffer_object & result_buffer,
                            uint16_t TIMEOUT_WAIT);
 
inline bool DoUrlEncodedFormPost(  ParsedURI & TheUri,
                            char * headers,
                            char * form_data,
                            buffer_object & result_buffer,
                            uint16_t TIMEOUT_WAIT)
{
    return DoUrlEncodedFormHttp(HttpMethod::Post, TheUri, headers, form_data,
            result_buffer, TIMEOUT_WAIT);
}
 
inline bool DoUrlEncodedFormHttp(HttpMethod method,
                                ParsedURI & TheUri,
                                char * headers,
                                char * form_data,
                                NBString & result_string,
                                uint16_t TIMEOUT_WAIT)
{
    StringBufferObject sbo(result_string);
    return DoUrlEncodedFormHttp(method, TheUri,headers,form_data,sbo,TIMEOUT_WAIT);
}
 
inline bool DoUrlEncodedFormPost(  ParsedURI & TheUri,
                            char * headers,
                            char * form_data,
                            NBString & result_string,
                            uint16_t TIMEOUT_WAIT)
{
    StringBufferObject sbo(result_string);
    return DoUrlEncodedFormHttp(HttpMethod::Post, TheUri,headers,form_data,sbo,TIMEOUT_WAIT);
}
 
bool DoUrlEncodedFormHttp(  HttpMethod method,
                            const char * pUrl,
                            char * headers,
                            char * form_data,
                            buffer_object & result_buffer,
                            uint16_t TIMEOUT_WAIT);
 
inline bool DoUrlEncodedFormPost(  const char * pUrl,
                            char * headers,
                            char * form_data,
                            buffer_object & result_buffer,
                            uint16_t TIMEOUT_WAIT)
{
    return DoUrlEncodedFormHttp(HttpMethod::Post, pUrl, headers, form_data,
            result_buffer, TIMEOUT_WAIT);
}
 
inline bool DoUrlEncodedFormPost(  const char * pUrl,
                            char * headers,
                            char * form_data,
                            NBString  & result_string,
                            uint16_t TIMEOUT_WAIT)
{
    StringBufferObject sbo(result_string);
    return  DoUrlEncodedFormHttp(HttpMethod::Post, pUrl,headers,form_data,sbo,TIMEOUT_WAIT);
}
 
bool DoJsonHttp(HttpMethod method,
                const char *pUrl,
                const char *Json_Data_To_Post,
                buffer_object &result_buffer,
                const char *AdditionalHeaders = NULL,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoJsonPost(const char *pUrl,
                const char *Json_Data_To_Post,
                buffer_object &result_buffer,
                const char *AdditionalHeaders = NULL,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoJsonHttp(HttpMethod::Post, pUrl, Json_Data_To_Post, result_buffer,
            AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonHttp(HttpMethod method,
                    const char *pUrl,
                    const char *Json_Data_To_Post,
                    NBString  &result_string,
                    const char *AdditionalHeaders = NULL,
                    uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
return  DoJsonHttp(method, pUrl,Json_Data_To_Post,sbo,AdditionalHeaders,TIMEOUT_WAIT);
 
}
 
inline bool DoJsonPost(const char *pUrl,
                const char *Json_Data_To_Post,
                NBString  &result_string,
                const char *AdditionalHeaders = NULL,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
return  DoJsonHttp(HttpMethod::Post, pUrl,Json_Data_To_Post,sbo,AdditionalHeaders,TIMEOUT_WAIT);
 
}
 
bool DoJsonHttp(HttpMethod method,
                ParsedURI &TheUri,
                const char *Json_Data_To_Post,
                buffer_object &result_buffer,
                const char *AdditionalHeaders = NULL,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoJsonPost(ParsedURI &TheUri,
                const char *Json_Data_To_Post,
                buffer_object &result_buffer,
                const char *AdditionalHeaders = NULL,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoJsonHttp(HttpMethod::Post, TheUri, Json_Data_To_Post, result_buffer,
            AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonHttp(HttpMethod method,
                    ParsedURI &TheUri,
                    const char *Json_Data_To_Post,
                    NBString & result_string,
                    const char *AdditionalHeaders = NULL,
                    uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttp(method, TheUri,Json_Data_To_Post,sbo,AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonPost(ParsedURI &TheUri,
                const char *Json_Data_To_Post,
                NBString & result_string,
                const char *AdditionalHeaders = NULL,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttp(HttpMethod::Post, TheUri,Json_Data_To_Post,sbo,AdditionalHeaders, TIMEOUT_WAIT);
}
 
bool DoJsonHttp(HttpMethod method,
                const char *pUrl,
                ParsedJsonDataSet &jsonout,
                buffer_object &result_buffer,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoJsonPost(const char *pUrl,
                ParsedJsonDataSet &jsonout,
                buffer_object &result_buffer,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoJsonHttp(HttpMethod::Post, pUrl, jsonout, result_buffer,
            AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonHttp(HttpMethod method,
                const char *pUrl,
                ParsedJsonDataSet &jsonout,
                NBString  &result_string,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttp(method, pUrl,jsonout,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
inline bool DoJsonPost(const char *pUrl,
                ParsedJsonDataSet &jsonout,
                NBString  &result_string,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttp(HttpMethod::Post, pUrl,jsonout,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
bool DoJsonHttp(HttpMethod method,
            ParsedURI &TheUri,
            ParsedJsonDataSet &jsonout,
            buffer_object &result_buffer,
            const char *AdditionalHeaders,
            uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoJsonPost(ParsedURI &TheUri,
                ParsedJsonDataSet &jsonout,
                buffer_object &result_buffer,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return  DoJsonHttp(HttpMethod::Post, TheUri, jsonout, result_buffer,
            AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonHttp(HttpMethod method,
                ParsedURI &TheUri,
                ParsedJsonDataSet &jsonout,
                NBString &result_string,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttp(method, TheUri,jsonout,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
 
inline bool DoJsonPost(ParsedURI &TheUri,
                ParsedJsonDataSet &jsonout,
                NBString &result_string,
                const char *AdditionalHeaders,
                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttp(HttpMethod::Post, TheUri,jsonout,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
bool DoJsonHttpFile(HttpMethod method,
                    const char *pUrl,
                    const char *FragmentName,
                    buffer_object &result_buffer,
                    const char *AdditionalHeaders,
                    uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoJsonPostHttpFile( const char *pUrl,
                                const char *FragmentName,
                                buffer_object &result_buffer,
                                const char *AdditionalHeaders,
                                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoJsonHttpFile(HttpMethod::Post, pUrl, FragmentName, result_buffer,
            AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonHttpFile(HttpMethod method,
                        const char *pUrl,
                        const char *FragmentName,
                        NBString & result_string,
                        const char *AdditionalHeaders,
                        uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttpFile(method, pUrl,FragmentName,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
 
inline bool DoJsonPostHttpFile(const char *pUrl,
                        const char *FragmentName,
                        NBString & result_string,
                        const char *AdditionalHeaders,
                        uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttpFile(HttpMethod::Post, pUrl,FragmentName,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
 
bool DoJsonHttpFile(HttpMethod method,
                    ParsedURI &TheUri,
                    const char *FragmentName,
                    buffer_object &result_buffer,
                    const char *AdditionalHeaders,
                    uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
inline bool DoJsonPostHttpFile( ParsedURI &TheUri,
                                const char *FragmentName,
                                buffer_object &result_buffer,
                                const char *AdditionalHeaders,
                                uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoJsonHttpFile(HttpMethod::Post, TheUri, FragmentName, result_buffer,
            AdditionalHeaders, TIMEOUT_WAIT);
}
 
inline bool DoJsonHttpFile(HttpMethod method,
                        ParsedURI &TheUri,
                        const char *FragmentName,
                        NBString & result_string,
                        const char *AdditionalHeaders,
                        uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttpFile(method,TheUri,FragmentName,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
inline bool DoJsonPostHttpFile(ParsedURI &TheUri,
                        const char *FragmentName,
                        NBString & result_string,
                        const char *AdditionalHeaders,
                        uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoJsonHttpFile(HttpMethod::Post,TheUri,FragmentName,sbo,AdditionalHeaders,TIMEOUT_WAIT);
}
 
 
 
bool DoHttp(HttpMethod method, ParsedURI &TheUri, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline bool DoGet(ParsedURI &TheUri, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttp(HttpMethod::Get, TheUri, result_buffer, TIMEOUT_WAIT);
}
 
inline bool DoHttp(HttpMethod method, ParsedURI &TheUri, NBString & result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return  DoHttp(method, TheUri,sbo,TIMEOUT_WAIT);
}
 
 
 
inline bool DoGet(ParsedURI &TheUri, NBString & result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return  DoHttp(HttpMethod::Get, TheUri,sbo,TIMEOUT_WAIT);
}
 
 
bool DoHttpEx(HttpMethod method, ParsedURI &TheUri,const char * headers, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
inline bool DoGetEx(ParsedURI &TheUri,const char * headers, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttpEx(HttpMethod::Get, TheUri, headers, result_buffer, TIMEOUT_WAIT);
}
 
 
inline bool DoHttpEx(HttpMethod method, ParsedURI &TheUri,const char * headers, NBString & result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoHttpEx(method, TheUri, headers, sbo, TIMEOUT_WAIT);
}
 
 
inline bool DoGetEx(ParsedURI &TheUri,const char * headers, NBString & result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoHttpEx(HttpMethod::Get,TheUri,headers, sbo,TIMEOUT_WAIT);
}
 
 
bool DoHttp(HttpMethod method, const char *pUrl, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
inline bool DoGet(const char *pUrl, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttp(HttpMethod::Get, pUrl, result_buffer, TIMEOUT_WAIT);
}
 
inline bool DoHttp(HttpMethod method, const char *pUrl, NBString &result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return  DoHttp(method, pUrl,sbo,TIMEOUT_WAIT);
}
 
inline bool DoGet(const char *pUrl, NBString &result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return  DoHttp(HttpMethod::Get, pUrl,sbo,TIMEOUT_WAIT);
}
 
bool DoHttpEx(HttpMethod method, const char *pUrl,const char * headers,buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
inline bool DoGetEx(const char *pUrl,const char * headers,buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttpEx(HttpMethod::Get, pUrl, headers, result_buffer, TIMEOUT_WAIT);
}
 
 
inline bool DoHttpEx(HttpMethod method, const char * pUrl,const char * headers, NBString & result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoHttpEx(method, pUrl,headers, sbo,TIMEOUT_WAIT);
}
 
 
inline bool DoGetEx(const char * pUrl,const char * headers, NBString & result_string, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    StringBufferObject sbo(result_string);
    return DoHttpEx(HttpMethod::Get,pUrl,headers, sbo,TIMEOUT_WAIT);
}
 
int DoHttp(HttpMethod method, ParsedURI &TheUri, unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
int DoHttpEx(HttpMethod method, ParsedURI &TheUri, const char* headers,unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
int DoHttp(HttpMethod method, const char *pUrl, unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
int DoHttpEx(HttpMethod method, const char *pUrl,const char * headers,unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
inline int DoGet(ParsedURI &TheUri, unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttp(HttpMethod::Get,TheUri, result, maxl, TIMEOUT_WAIT);
}
 
inline int DoGetEx(ParsedURI &TheUri, const char* headers,unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttpEx(HttpMethod::Get, TheUri, headers, result, maxl, TIMEOUT_WAIT);
}
 
 
inline int DoGet(const char *pUrl, unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttp(HttpMethod::Get, pUrl, result, maxl, TIMEOUT_WAIT);
}
 
inline int DoGetEx(const char *pUrl,const char * headers,unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND)
{
    return DoHttpEx(HttpMethod::Get, pUrl, headers, result, maxl, TIMEOUT_WAIT);
}
 
 
//Turn on update diagnostics
void SetHttpUpDiag(bool b);
 
 
int DoGetUpdate(ParsedURI &TheUri, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
int DoGetUpdate(const char *pUrl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
 
int PopulateAuthHeader(const char * user, const char * password, char * buffer, int maxlen);
 
 
/* Parse the uri and open tcp to the correct host/port nothing is sent*/
int StartConnection(ParsedURI &TheUri,TickTimeout & TT);
 
 
inline int StartConnection(ParsedURI &TheUri,uint32_t timeout=TICKS_PER_SECOND*10)
{
    TickTimeout tt(timeout);
    return StartConnection(TheUri, tt);
}
 
int WriteHttpRequestHeaders(int fd,
                            ParsedURI &uri,
                            const char * methodStr,
                            int content_len=0,
                            const char * content_type=0,
                            const char * extra_header=0);
 
 
int StartTransaction(ParsedURI &TheUri, const char *headers = 0, const char *action = "GET", uint32_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
int StartTransaction(const char * pUrl, const char * headers=0,const char * action="GET", uint32_t TIMEOUT_WAIT= 10 * TICKS_PER_SECOND);
 
 
 
#endif