AsyncHttpServerConnection.h

Go to the documentation of this file.

 
#ifndef ASYNC_HTTP_SERVER_CONNECTION_INCLUDED
#define ASYNC_HTTP_SERVER_CONNECTION_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <stdint.h>
#include <vector>
#include <deque>
#include <cstring>
#include <map>
#include <string>
#include <sstream>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncTcpConnection.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class HttpServerConnection : public TcpConnection
{
  public:
    typedef std::map<std::string, std::string> Headers;
    struct Request
    {
      std::string method;
      std::string target;
      unsigned ver_major;
      unsigned ver_minor;
      Headers headers;
 
      Request(void)
      {
        clear();
      }
 
      void clear(void)
      {
        method.clear();
        target.clear();
        headers.clear();
        ver_major = 0;
        ver_minor = 0;
        headers.clear();
      }
 
      Request& operator=(Request&& other)
      {
        method = std::move(other.method);
        target = std::move(other.target);
        ver_major = other.ver_major;
        ver_minor = other.ver_minor;
        headers = std::move(other.headers);
        other.clear();
        return *this;
      }
    };
 
    class Response
    {
      public:
        Response(void) : m_code(0), m_send_content(false) {}
 
        unsigned code(void) const { return m_code; }
        void setCode(unsigned code) { m_code = code; }
 
        const Headers& headers(void) const { return m_headers; }
        template <typename T>
        void setHeader(const std::string& key, T value)
        {
          std::ostringstream os;
          os << value;
          m_headers[key] = os.str();
        }
 
        const std::string& content(void) const { return m_content; }
        void setContent(const std::string& content_type,
                        const std::string& content)
        {
          m_content = content;
          setHeader("Content-type", content_type);
          setHeader("Content-length", m_content.size());
          setSendContent(true);
        }
        bool sendContent(void) const { return m_send_content; }
        void setSendContent(bool send_content)
        {
          m_send_content = send_content;
        }
 
        void clear(void)
        {
          m_code = 0;
          m_headers.clear();
          m_content.clear();
        }
 
      private:
        unsigned    m_code;
        Headers     m_headers;
        std::string m_content;
        bool        m_send_content;
    };
 
    explicit HttpServerConnection(size_t recv_buf_len = DEFAULT_RECV_BUF_LEN);
 
    HttpServerConnection(int sock, const IpAddress& remote_addr,
                        uint16_t remote_port,
                        size_t recv_buf_len = DEFAULT_RECV_BUF_LEN);
 
    virtual ~HttpServerConnection(void);
 
    virtual TcpConnection& operator=(TcpConnection&& other_base) override;
 
    void setChunked(void) { m_chunked = true; }
 
    virtual bool write(const Response& res);
 
    virtual bool write(const char* buf, int len);
 
    sigc::signal<void, HttpServerConnection *, DisconnectReason> disconnected;
 
    sigc::signal<void, HttpServerConnection *, Request&> requestReceived;
 
  protected:
    sigc::signal<void, bool> sendBufferFull;
 
    virtual void closeConnection(void) override;
 
    virtual void onDisconnected(DisconnectReason reason) override;
 
    virtual int onDataReceived(void *buf, int count) override;
 
    virtual void emitDisconnected(DisconnectReason reason) override
    {
      disconnected(this, reason);
      TcpConnection::emitDisconnected(reason);
    }
 
  private:
    enum State {
      STATE_DISCONNECTED, STATE_EXPECT_START_LINE, STATE_EXPECT_HEADER,
      STATE_EXPECT_PAYLOAD, STATE_REQ_COMPLETE
    };
 
    State                   m_state;
    std::string             m_row;
    Request                 m_req;
    bool                    m_chunked;
 
    HttpServerConnection(const HttpServerConnection&);
    HttpServerConnection& operator=(const HttpServerConnection&);
    using TcpConnection::write;
    void handleStartLine(void);
    void handleHeader(void);
    //void onSendBufferFull(bool is_full);
    void disconnectCleanup(void);
    const char* codeToString(unsigned code);
 
};  /* class HttpServerConnection */
 
 
} /* namespace */
 
#endif /* ASYNC_HTTP_SERVER_CONNECTION_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */