HttpTrace.h

/*
 *     ____             _________                __                _
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/
 *                                                       /____/
 *
 *                  Barracuda Embedded Web-Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: HttpTrace.h 2376 2011-05-25 01:16:16Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2004-2008
 *               http://www.realtimelogic.com
 */


#ifndef __HttpTrace_h
#define __HttpTrace_h

#include <HttpServer.h>

#ifndef NO_HTTP_TRACE
#ifndef HTTP_TRACE
#define HTTP_TRACE
#endif
#endif

#define HttpTrace_doRequestMask          0x01
#define HttpTrace_doRequestHeadersMask   0x02
#define HttpTrace_doResponseHeadersMask  0x04
#define HttpTrace_doResponseBodyMask     0x08
#define HttpTrace_doHttp11StateMask      0x10
#define HttpTrace_doReqBufOverflowMask   0x20


typedef void (*HttpTrace_Flush)(char* buf, int bufLen);

typedef struct HttpTrace
{
#ifdef __cplusplus

      static void setFLushCallback(HttpTrace_Flush fcb);

      static void vprintf(int prio, const char* fmt, va_list argList);

      static void printf(int prio, const char* fmt, ...);

      static void write(int prio, const char* buf, int len = -1);

      static int setPrio(int prio);

      static BufPrint* getWriter();

      static void releaseWriter(void);

      static void setRequest(bool cmd);

      static void setRequestHeaders(bool cmd);

      static void setResponseHeaders(bool cmd);

      static void setResponseBody(bool cmd);

      static void setHttp11State(bool cmd);

      static void setReqBufOverflow(bool cmd);

      static int setBufSize(int size);

      static void flush();

      static bool isRequestSet();
      static bool isRequestHeadersSet();
      static bool isResponseHeadersSet();
      static bool isResponseBodySet();
      static bool isHttp11StateSet();

   private:
      inline HttpTrace() {}
#endif
      BufPrint print; /* As if inherited */
      int prio;
      U8 traceCmds;
}HttpTrace;

#ifdef __cplusplus
extern "C" {
#endif
BA_API int HttpTrace_setPrio(int prio);
BA_API void HttpTrace_setFLushCallback(HttpTrace_Flush fcb);
BA_API HttpTrace_Flush HttpTrace_getFLushCallback(void);
BA_API void HttpTrace_vprintf(int prio, const char* fmt, va_list argList);
BA_API void HttpTrace_printf(int prio, const char* fmt, ...);
BA_API void HttpTrace_write(int prio, const char* buf, int len);
BA_API void HttpTrace_flush(void);

BA_API void HttpTrace_setRequest(BaBool cmd);
BA_API void HttpTrace_setRequestHeaders(BaBool cmd);
BA_API void HttpTrace_setResponseHeaders(BaBool cmd);
BA_API void HttpTrace_setResponseBody(BaBool cmd);
BA_API void HttpTrace_setHttp11State(BaBool cmd);
BA_API void HttpTrace_setReqBufOverflow(BaBool cmd);
BA_API int HttpTrace_setBufSize(int size);

/* Internal funtion. Used by macros below */
BA_API U8 HttpTrace_getTraceCmds(void);
#define HttpTrace_isRequestSet() \
  (HttpTrace_getTraceCmds() & HttpTrace_doRequestMask ? TRUE : FALSE)
#define HttpTrace_isRequestHeadersSet() \
  (HttpTrace_getTraceCmds() & HttpTrace_doRequestHeadersMask ? TRUE : FALSE)
#define HttpTrace_isResponseHeadersSet() \
  (HttpTrace_getTraceCmds() & HttpTrace_doResponseHeadersMask ? TRUE : FALSE)
#define HttpTrace_isResponseBodySet() \
  (HttpTrace_getTraceCmds() & HttpTrace_doResponseBodyMask ? TRUE : FALSE)
#define HttpTrace_isHttp11StateSet() \
  (HttpTrace_getTraceCmds() & HttpTrace_doHttp11StateMask ? TRUE : FALSE)

/* Private Barracuda functions */

#ifdef HTTP_TRACE
#define TRPR(data) HttpTrace_TRPR data
BA_API void HttpTrace_TRPR(const char* fmt, ...);
#else
#define TRPR(data)
#endif
BA_API HttpTrace* HttpTrace_get(void);
#define HttpTrace_doRequest() \
  (HttpTrace_get()->traceCmds & HttpTrace_doRequestMask)
#define HttpTrace_doRequestHeaders() \
  (HttpTrace_get()->traceCmds & HttpTrace_doRequestHeadersMask)
#define HttpTrace_doResponseHeaders() \
  (HttpTrace_get()->traceCmds & HttpTrace_doResponseHeadersMask)
#define HttpTrace_doResponseBody() \
  (HttpTrace_get()->traceCmds & HttpTrace_doResponseBodyMask)
#define HttpTrace_doHttp11State() \
  (HttpTrace_get()->traceCmds & HttpTrace_doHttp11StateMask)
#define HttpTrace_doReqBufOverflow() \
  (HttpTrace_get()->traceCmds & HttpTrace_doReqBufOverflowMask)
BA_API BufPrint* HttpTrace_getWriter(void);
BA_API void HttpTrace_releaseWriter(void);
#ifdef __cplusplus
}
inline int HttpTrace::setPrio(int prio) {
   return HttpTrace_setPrio(prio);
}
inline void HttpTrace::setFLushCallback(HttpTrace_Flush fcb) {
   HttpTrace_setFLushCallback(fcb); }
inline void HttpTrace::vprintf(int prio, const char* fmt, va_list argList) {
   HttpTrace_vprintf(prio, fmt, argList); }
inline void HttpTrace::printf(int prio, const char* fmt, ...) {
   va_list varg;
   va_start(varg, fmt);
   HttpTrace_vprintf(prio, fmt, varg);
   va_end(varg);
}
inline void HttpTrace::write(int prio, const char* buf, int len) {
   HttpTrace_write(prio, buf, len); }

inline BufPrint* HttpTrace::getWriter() {
   return HttpTrace_getWriter(); }
inline void HttpTrace::releaseWriter(void) {
   HttpTrace_releaseWriter(); }
inline void HttpTrace::setRequest(bool cmd) {
   HttpTrace_setRequest(cmd); }
inline void HttpTrace::setRequestHeaders(bool cmd) {
   HttpTrace_setRequestHeaders(cmd); }
inline void HttpTrace::setResponseHeaders(bool cmd) {
   HttpTrace_setResponseHeaders(cmd); }
inline void HttpTrace::setResponseBody(bool cmd) {
   HttpTrace_setResponseBody(cmd); }
inline void HttpTrace::setHttp11State(bool cmd) {
   HttpTrace_setHttp11State(cmd); }
inline void HttpTrace::setReqBufOverflow(bool cmd) {
   HttpTrace_setReqBufOverflow(cmd); }
inline int HttpTrace::setBufSize(int size) {
   return HttpTrace_setBufSize(size); }
inline void HttpTrace::flush() {
   HttpTrace_flush();
}
inline bool HttpTrace::isRequestSet() {
   return HttpTrace_isRequestSet() ? true : false;
}
inline bool HttpTrace::isRequestHeadersSet() {
   return HttpTrace_isRequestHeadersSet() ? true : false;
}
inline bool HttpTrace::isResponseHeadersSet() {
   return HttpTrace_isResponseHeadersSet() ? true : false;
}
inline bool HttpTrace::isResponseBodySet() {
   return HttpTrace_isResponseBodySet() ? true : false;
}
inline bool HttpTrace::isHttp11StateSet() {
   return HttpTrace_isHttp11StateSet() ? true : false;
}
#endif

#ifdef __cplusplus

struct HttpTraceWriteLock
{
      HttpTraceWriteLock() {
         _bufPrint = HttpTrace_getWriter();
      }
      ~HttpTraceWriteLock() {
         release();
      }

      void release() {
         if(_bufPrint) {_bufPrint=0; HttpTrace_releaseWriter(); }
      }

      void lock() {
         if(!_bufPrint) {_bufPrint = HttpTrace_getWriter(); }
      }

      operator BufPrint*() { return _bufPrint; }

      BufPrint* operator -> () { return _bufPrint; }
   private:
      BufPrint* _bufPrint;
};
#endif



#endif