http.h

Go to the documentation of this file.

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _NB_HTTP_H
#define _NB_HTTP_H
 
#include <nettypes.h>
#include <stddef.h>
#include <config_obj.h>
 
const int CONFIG_ACCESS_GROUP = 99;
 
enum HTTP_RequestTypes
{
    tUnknown,   
    tGet,       
    tPost,      
    tHead       
};
 
enum HTTP_ACCESS
{
    HTTP_OK_TO_SERVE,       //< Ok to serve the page
    HTTP_NEED_PASSWORD,     //< Either the password in the HTTP request is wrong or missing
    HTTP_NOTFOUND,          //< Report the page is not found
    HTTP_FORBIDEN,          //< Report the page forbiden
    HTTP_RESPONSE_HANDLED   //< This means this function handled the full response, including closing the socket.
};
 
enum WebsocketFlags
{
    WS_UPGRADE = 0x1,
    WS_CONNECT = 0x2,
    WS_VER_13 = 0x4,
    WS_KEY_CONFIRM = 0x8
};
 
struct HTTP_Request
{
    PSTR pURL;                 
    PSTR pAuthorization;       
    PSTR pFirstCookie;         
    PSTR pData;                
    PSTR pSep;                 
    PSTR pHost;                
    PSTR last_datarx;          
    PSTR wsKey;                
    PSTR wsProtocol;           
    uint16_t sep_len;          
    uint32_t content_length;   
    uint32_t rx_length;        
    IPADDR client_IPaddr;      
    uint8_t websocketFlags;    
    HTTP_RequestTypes req;     
 
    void ProcessLine(PSTR startofline);                           
    int Respond(int socket);                                      
    bool ExtractAuthentication(char **pPassword, char **pUser);   
} __attribute__((packed));
 
 
HTTP_Request * GetActiveHttpRequest();
 
 
 
 
struct HTTP_Socket
{
    int FileDescriptor;
    uint32_t StartTime;
    IPADDR client_IPaddr;
} __attribute__((packed));
 
 
enum eWEB_ERROR
{
    eTCP_CONN_OPEN_NO_DATA,   // WEB client open TCP port#80 conn, but no data request was sent
    eTCP_CONN_OPEN_TO_LONG,   // WEB client open TCP connect and send endless data ( for example - never ending POST).
};
 
class HtmlPageHandler
{
   protected:
    HtmlPageHandler *m_pNextHandler;    
    const char *m_pUrlName;             
    int m_access_group;                 
    HTTP_RequestTypes m_requestTypes;   
 
    void InsertSort(HtmlPageHandler *&ph);   
    int SortValue(HtmlPageHandler *pv);      
    void Remove();
    virtual bool Match(HTTP_Request &req);
 
   public:
    HtmlPageHandler(const char *url, HTTP_RequestTypes rt = tGet, int accessGroup = 0, bool Before_Files = false);
    ~HtmlPageHandler();
 
    static HtmlPageHandler *FindHandler(HTTP_Request &req, bool bBeforeFiles);
 
    virtual int ProcessRaw(int sock, HTTP_Request &pd) = 0;
 
    inline int GetGroup() { return m_access_group; };
};
 
typedef int(http_gethandlerfunc)(int sock, HTTP_Request &pd);
 
 
typedef bool(http_matchhandlerfunc)(HTTP_Request &pd);
 
class CallBackFunctionPageHandler : public HtmlPageHandler
{
   protected:
    http_gethandlerfunc *m_pf;
    http_matchhandlerfunc *m_mhf;
 
   public:
    inline virtual int ProcessRaw(int sock, HTTP_Request &pdt) { return m_pf(sock, pdt); };
 
    inline CallBackFunctionPageHandler(const char *pUrl,
                                       http_gethandlerfunc *pFunction,
                                       HTTP_RequestTypes reqType = tGet,
                                       int accessGroup = 0,
                                       bool beforeFiles = false)
        : HtmlPageHandler(pUrl, reqType, accessGroup, beforeFiles), m_pf(pFunction)
    {
        m_mhf = 0;
    };
 
    inline CallBackFunctionPageHandler(const char *pUrl,
                                       http_gethandlerfunc *pFunction,
                                       http_matchhandlerfunc *pMatchFunction,
                                       HTTP_RequestTypes reqType = tGet,
                                       int accessGroup = 0,
                                       bool beforeFiles = false)
        : HtmlPageHandler(pUrl, reqType, accessGroup, beforeFiles), m_pf(pFunction)
    {
        m_mhf = pMatchFunction;
    };
 
    virtual bool Match(HTTP_Request &req)
    {
        if (m_mhf)
            return m_mhf(req);
        else
            return HtmlPageHandler::Match(req);
    }
};
 
 
 
 
class HtmlConfigExposer : public HtmlPageHandler
{
protected:
    config_leaf * pLeaf;
public:
    inline HtmlConfigExposer(const char *pUrl, config_leaf & leaf,
                                        HTTP_RequestTypes reqType = tGet,
                                        int accessGroup = 0,
                                        bool beforeFiles = false
                                        )
        : HtmlPageHandler(pUrl, reqType, accessGroup, beforeFiles), pLeaf(&leaf)
    {
    }
 
virtual int ProcessRaw(int sock, HTTP_Request &pd);
};
 
 
typedef void (ws_createhandlerfunc)(int web_socket_fd);
 
class CallBackWSEndPoint : public HtmlPageHandler
{
    ws_createhandlerfunc *m_pf;
public:
    int ProcessRaw(int sock, HTTP_Request &pdt);
    inline CallBackWSEndPoint(const char *pUrl,
                                           ws_createhandlerfunc *pFunction,
                                           int accessGroup = 0,
                                           bool beforeFiles = false)
            : HtmlPageHandler(pUrl, tGet, accessGroup, beforeFiles), m_pf(pFunction){};
 
 
};
 
 
 
 
extern const char *pHttpRealm;   // The realm used for password requests
 
HTTP_ACCESS CheckHttpAccess(int sock, int access_level, HTTP_Request &Req);
 
void StartHttp(uint16_t port /* = 80 */, bool RunConfigMirror /* = true */);
 
typedef int(http_errorhandler)(IPADDR ip, enum eWEB_ERROR Err, void *prm);
 
/*Setup a custom WEB Error Report Handler */
http_errorhandler *SetNewErrorHandler(http_errorhandler *newhandler);
 
void StopHttp();
 
void SendHTMLHeader(int sock);
 
void SendHTMLHeaderWCookie(int sock, char *cookie);
 
void SendTextHeader(int sock);
 
void SendGifHeader(int sock);
 
void EmptyResponse(int sock);
 
void NoContentResponse(int sock);
 
void RedirectResponse(int sock, PCSTR new_page);
 
void NotFoundResponse(int sock, PCSTR new_page);
 
void ForbiddenResponse(int sock, PCSTR new_page);
 
void NotAvailableResponse(int sock, PCSTR new_page);
 
void BadRequestResponse(int sock, PCSTR url, PCSTR data);
 
void writesafestring(int fd, PCSTR str);
 
int writeallsafestring(int fd, PCSTR str);
 
int writesafestring(int fd, PCSTR str, size_t strLength);
 
// Encode a uri component
int decodeURI(char *str);
 
int httpstricmp(PCSTR str1, PCSTR strIsUpper2);
 
void append(char *&cpto, const char *cpfrm);
 
#endif