http_funcs.h

Go to the documentation of this file.

/*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)
 {
 NewUri(uri, timeout);
 };
 
 
 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; }
};
 
 
void SetHttpDiag(bool b);
 
 
#ifndef WebErrorReporterFunc
typedef void(WebErrorReporterFunc)(int ErrorState);
#endif
 
extern WebErrorReporterFunc *pWebErrorReporter;
 
 
class ParsedJsonDataSet; // Forward declaration
 
 
int DoMultipartStartPost(ParsedURI &TheUri,
 const char *separator,
 uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND,
 uint32_t contentLength = 0);
 
int DoMultipartStartPost(const char *pUrl,
 const char *separator,
 uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND,
 uint32_t contentLength = 0);
 
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);
 
bool DoUrlEncodedFormPost( ParsedURI & TheUri,
 char * headers,
 char * form_data,
 buffer_object & result_buffer,
 uint16_t TIMEOUT_WAIT);
 
bool DoUrlEncodedFormPost( const char * pUrl,
 char * headers,
 char * form_data,
 buffer_object & result_buffer,
 uint16_t TIMEOUT_WAIT);
 
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);
 
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);
 
bool DoJsonPost(const char *pUrl,
 ParsedJsonDataSet &jsonout,
 buffer_object &result_buffer,
 const char *AdditionalHeaders,
 uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
bool DoJsonPost(ParsedURI &TheUri,
 ParsedJsonDataSet &jsonout,
 buffer_object &result_buffer,
 const char *AdditionalHeaders,
 uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
// Do a JSON post using a JSON file template with function file variables call backs etc... like the webserver
bool DoJsonPostHttpFile(const char *pUrl,
 const char *FragmentName,
 buffer_object &result_buffer,
 const char *AdditionalHeaders,
 uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
bool DoJsonPostHttpFile(ParsedURI &TheUri,
 const char *FragmentName,
 buffer_object &result_buffer,
 const char *AdditionalHeaders,
 uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
bool DoGet(ParsedURI &TheUri, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
bool DoGetEx(ParsedURI &TheUri,const char * headers, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
bool DoGet(const char *pUrl, buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
bool DoGetEx(const char *pUrl,const char * headers,buffer_object &result_buffer, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
 
int DoGet(ParsedURI &TheUri, unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
int DoGetEx(ParsedURI &TheUri, const char* headers,unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
int DoGet(const char *pUrl, unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
int DoGetEx(const char *pUrl,const char * headers,unsigned char *result, int maxl, uint16_t TIMEOUT_WAIT = 10 * TICKS_PER_SECOND);
 
 
 
//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 tcpp 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 * Action,
 int content_len=0, 
 const char * content_type=0,
 const char * extra_header=0);
 
 
 
 
/* Returns an FD otherwise starts a transaction and sends headers...
including the host: heder type.
headers should be formatted without leading and trailing \r\n 
*/
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