HttpUpload.h

/*
 *     ____             _________                __                _
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/
 *                                                       /____/
 *
 *                  Barracuda Embedded Web-Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: HttpUpload.h 2282 2011-01-15 03:35:20Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2006-2008
 *               http://www.realtimelogic.com
 *
 *   The copyright to the program herein is the property of
 *   Real Time Logic. The program may be used or copied only
 *   with the written permission from Real Time Logic LLC or
 *   in accordance with the terms and conditions stipulated in
 *   the agreement under which the program has been supplied.
 ****************************************************************************
 *
 *
 */

#ifndef _HttpUpload_h
#define _HttpUpload_h

#include <HttpAsynchReq.h>
#include <MultipartUpload.h>
#include <AuthenticatedUser.h>
#include <IoIntf.h>

struct HttpConnection;

#ifdef __cplusplus

struct HttpUploadNode
{
      const char* getName();

      const char* getUrl();

      HttpAsynchResp* getResponse();

      struct HttpConnection* getConnection();

      IoIntfPtr getIoIntf();

      HttpSession* getSession();


      bool isMultipartUpload();
};
#else
struct HttpUploadNode;
#endif

#ifdef __cplusplus
extern "C" {
#endif
BA_API const char* HttpUploadNode_getName(struct HttpUploadNode* o);
BA_API const char* HttpUploadNode_getUrl(struct HttpUploadNode* o);
BA_API HttpAsynchResp* HttpUploadNode_getResponse(struct HttpUploadNode* o);
BA_API struct HttpConnection* HttpUploadNode_getConnection(
   struct HttpUploadNode* o);
BA_API IoIntfPtr HttpUploadNode_getIoIntf(struct HttpUploadNode* o);
BA_API void* HttpUploadNode_getdata(struct HttpUploadNode* o);
BA_API HttpSession* HttpUploadNode_getSession(struct HttpUploadNode* o);
BA_API BaBool HttpUploadNode_isMultipartUpload(struct HttpUploadNode* o);
BA_API BaBool HttpUploadNode_isResponseMode(struct HttpUploadNode* o);
BA_API BaBool HttpUploadNode_initial(struct HttpUploadNode* o);
BA_API int HttpUploadNode_decrRef(struct HttpUploadNode* o);
BA_API void HttpUploadNode_incRef(struct HttpUploadNode* o);
BA_API void set_inflategzip(IoIntf_InflateGzip ptr);
BA_API IoIntf_InflateGzip get_inflategzip(void);
#ifdef __cplusplus
}
inline const char* HttpUploadNode::getName() {
   return HttpUploadNode_getName(this); }
inline const char* HttpUploadNode::getUrl() {
   return  HttpUploadNode_getUrl(this); }
inline HttpAsynchResp* HttpUploadNode::getResponse() {
   return HttpUploadNode_getResponse(this); }
inline struct HttpConnection* HttpUploadNode::getConnection() {
   return HttpUploadNode_getConnection(this); }
inline IoIntfPtr HttpUploadNode::getIoIntf() {
   return HttpUploadNode_getIoIntf(this); }
inline  HttpSession* HttpUploadNode::getSession() {
   return HttpUploadNode_getSession(this); }
inline bool HttpUploadNode::isMultipartUpload() {
   return HttpUploadNode_isMultipartUpload(this) ? true : false; }
#endif



#ifndef __DOXYGEN__
struct HttpUploadCbIntf;
#endif

typedef void (*HttpUploadCbIntf_OnFile)(
   struct HttpUploadCbIntf* o, struct HttpUploadNode* node, BaBool completed);
typedef void (*HttpUploadCbIntf_OnError)(
   struct HttpUploadCbIntf* o, struct HttpUploadNode* node,
   int ecode, const char* extraEcode);

typedef struct HttpUploadCbIntf
{
#ifdef __cplusplus
      HttpUploadCbIntf(){}

      HttpUploadCbIntf(HttpUploadCbIntf_OnFile of,HttpUploadCbIntf_OnError oe);
#endif
      HttpUploadCbIntf_OnFile onFileFp;
      HttpUploadCbIntf_OnError onErrorFp;
} HttpUploadCbIntf;

#define HttpUploadCbIntf_constructor(o, onFile, onError) do { \
   (o)->onFileFp=onFile; \
   (o)->onErrorFp=onError; \
} while(0)

#ifdef __cplusplus
      inline HttpUploadCbIntf::HttpUploadCbIntf(
         HttpUploadCbIntf_OnFile of,HttpUploadCbIntf_OnError oe) {
         HttpUploadCbIntf_constructor(this, of, oe);
      }
#endif


typedef struct HttpUpload
{
#ifdef __cplusplus
      HttpUpload() {}

      HttpUpload(IoIntfPtr io, AllocatorIntf* alloc,
                 HttpUploadCbIntf* uploadCb, int maxUploads);

      ~HttpUpload();

      int service(const char* name, HttpCommand* cmd, void* userdata=0);

      IoIntfPtr getIoIntf();
#endif

      DoubleList uploadNodeList;
      IoIntfPtr io;
      AllocatorIntf* alloc;
      HttpUploadCbIntf* uploadCb;
      int uploadsLeft;
} HttpUpload;

#ifdef __cplusplus
extern "C" {
#endif
BA_API void HttpUpload_constructor(
   HttpUpload* o, IoIntfPtr io, AllocatorIntf* alloc,
   HttpUploadCbIntf* uploadCb, int maxUploads);
BA_API void HttpUpload_destructor(HttpUpload* o);
BA_API int HttpUpload_service(
   HttpUpload* o, const char* name, HttpCommand* cmd, void* userdata);
#define HttpUpload_getIoIntf(o) (o)->io
#ifdef __cplusplus
}
inline HttpUpload::HttpUpload(IoIntfPtr io, AllocatorIntf* alloc,
                              HttpUploadCbIntf* uploadCb, int maxUploads) {
   HttpUpload_constructor(this, io, alloc, uploadCb, maxUploads); }
inline HttpUpload::~HttpUpload() {
    HttpUpload_destructor(this); }
inline int HttpUpload::service(const char* name, HttpCommand* cmd, void* userdata) {
   return  HttpUpload_service(this, name, cmd,userdata); }
inline IoIntfPtr HttpUpload::getIoIntf() {
   return HttpUpload_getIoIntf(this); }
#endif
 /* end of HttpUpload */

#endif