HttpAsynchResp.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Embedded Web-Server 
 ****************************************************************************
 *            HEADER
 *
 *   $Id: HttpAsynchResp.h 5355 2022-11-16 10:33:45Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2004-2022
 *
 *   This software is copyrighted by and is the sole property of Real
 *   Time Logic LLC.  All rights, title, ownership, or other interests in
 *   the software remain the property of Real Time Logic LLC.  This
 *   software may only be used in accordance with the terms and
 *   conditions stipulated in the corresponding license agreement under
 *   which the software has been supplied.  Any unauthorized use,
 *   duplication, transmission, distribution, or disclosure of this
 *   software is expressly forbidden.
 *                                                                        
 *   This Copyright notice may not be removed or modified without prior
 *   written consent of Real Time Logic LLC.
 *                                                                         
 *   Real Time Logic LLC. reserves the right to modify this software
 *   without notice.
 *
 *               http://www.realtimelogic.com
 ****************************************************************************
 *
 */
 
#ifndef __HttpAsynchResp_h
#define __HttpAsynchResp_h
 
#include <HttpServer.h>
 
 
#define RESPONSESTATE_IDLE 0
#define RESPONSESTATE_WRITEMODE 1
#define RESPONSESTATE_WRITEMODE_CHUNK 2
#define RESPONSESTATE_BODYSENT 3
#define RESPONSESTATE_CLOSED 4
 
 
 
typedef struct HttpAsynchResp
#ifdef __cplusplus
: public HttpConnection
{
      void *operator new(size_t s) { return ::baMalloc(s); }
      void operator delete(void* d) { if(d) ::baFree(d); }
      void *operator new(size_t, void *place) { return place; }
      void operator delete(void*, void *) { }
 
      HttpAsynchResp() {}
 
      HttpAsynchResp(char* buf, int size, HttpRequest* req);
 
      HttpAsynchResp(char* buf,int size,HttpConnection* con);
 
      bool isValid();
 
      void asynchThreadMode();
 
      ~HttpAsynchResp();
 
      void close();
 
      ThreadMutex* getMutex();
 
      int setConClose();
 
      int setLingeringClose();
 
 
      int setStatus(int statusCode, const char* protocol=0);
 
      int setHeader(const char *name, const char *value);
 
      int sendData(const void* data, int pktSize, int chunkSize);
 
      int sendNextChunk(const void* data,int chunkSize);
 
      BufPrint* getWriter();
#else
{
   HttpConnection super;
#endif
   BufPrint bufPrint;
   HttpConnection* con; /* pointer to 'super' or to a HttpAsyncReqResp */
   ThreadMutex* mutex; /* Can be set so code automatically locks mutex */
   BaBool statusSent;
   BaBool headerSent;
   U8 responseState;
   U8 doLingeringClose;
} HttpAsynchResp;
 
 
#ifdef __cplusplus
extern "C" {
#endif
BA_API void HttpAsynchResp_constructor(
   HttpAsynchResp* o, char* buf, int size, HttpRequest* req);
BA_API void HttpAsynchResp_constructor2(
   HttpAsynchResp* o, char* buf, int size, HttpConnection* con);
BA_API void HttpAsynchResp_ReqRespInit(
   HttpAsynchResp* o, char* buf, int size, HttpConnection* con);
BA_API BaBool HttpAsynchResp_isValid(HttpAsynchResp* o);
#define HttpAsynchResp_asynchThreadMode(o) \
   ((o)->mutex=HttpAsynchResp_getMutex(o))
BA_API void HttpAsynchResp_close(HttpAsynchResp* o);
#define HttpAsynchResp_destructor(o) HttpAsynchResp_close(o)
#define HttpAsynchResp_getMutex(o) \
   SoDisp_getMutex(HttpConnection_getDispatcher((HttpConnection*)(o)))
#define HttpAsynchResp_setConClose(o)\
   HttpConnection_clearKeepAlive((HttpConnection*)(o))
#define HttpAsynchResp_setLingeringClose(o) (o)->doLingeringClose=TRUE
BA_API int HttpAsynchResp_setStatus(
   HttpAsynchResp* o, int statusCode, const char* protocol);
BA_API int HttpAsynchResp_setHeader(
   HttpAsynchResp* o,const char *name,const char *value);
BA_API int HttpAsynchResp_sendData(
   HttpAsynchResp* o, const void* data, int pktSize, int chunkSize);
BA_API int HttpAsynchResp_sendNextChunk(
   HttpAsynchResp* o,const void* data,int chunkSize);
BA_API BufPrint* HttpAsynchResp_getWriter(HttpAsynchResp* o);
#define HttpAsynchResp_isAsynchThreadMode(o) ((o)->mutex ? TRUE : FALSE)
#ifdef __cplusplus
}
inline HttpAsynchResp::HttpAsynchResp(char* buf, int size, HttpRequest* req) {
    HttpAsynchResp_constructor(this, buf, size, req);
}
inline HttpAsynchResp::HttpAsynchResp(char* buf,int size,HttpConnection* con) {
    HttpAsynchResp_constructor2(this, buf, size, con);
}
inline bool HttpAsynchResp::isValid() {
      return HttpAsynchResp_isValid(this) ? TRUE : FALSE;
}
inline HttpAsynchResp::~HttpAsynchResp() {
   HttpAsynchResp_destructor(this);
}
inline void HttpAsynchResp::close() {
   HttpAsynchResp_close(this);
}
inline void HttpAsynchResp::asynchThreadMode() {
   HttpAsynchResp_asynchThreadMode(this);
}
inline ThreadMutex* HttpAsynchResp::getMutex() {
   return HttpAsynchResp_getMutex(this);
}
inline int HttpAsynchResp::setConClose() {
   return HttpAsynchResp_setConClose(this); 
}
inline int HttpAsynchResp::setLingeringClose() {
   return HttpAsynchResp_setConClose(this); 
}
inline int HttpAsynchResp::setStatus(int statusCode, const char* protocol) {
   return HttpAsynchResp_setStatus(this, statusCode, protocol); 
}
inline int HttpAsynchResp::setHeader(const char *name,const char *value) {
   return HttpAsynchResp_setHeader(this, name, value);
}
inline int HttpAsynchResp::sendData(
   const void* data, int pktSize, int chunkSize) {
   return HttpAsynchResp_sendData(this, data, pktSize, chunkSize);
}
inline int HttpAsynchResp::sendNextChunk(const void* data,int chunkSize) {
   return HttpAsynchResp_sendNextChunk(this,data,chunkSize); }
inline BufPrint* HttpAsynchResp::getWriter() {
   return HttpAsynchResp_getWriter(this);
}
#endif
 /* end of HttpStack */
  
 
#endif