MultipartUpload.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Embedded Web-Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: MultipartUpload.h 5813 2026-06-15 10:15:50Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2006 - 2023
 *
 *   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 __HttpMultipartUpload_h
#define __HttpMultipartUpload_h
 
#include "HttpServer.h"
#include "BaServerLib.h"
 
typedef enum
{
   MultipartUpload_NoError=0,
   MultipartUpload_ConnectionTerminated=-100,
   MultipartUpload_NoMemory,
   MultipartUpload_ParseError1,
   MultipartUpload_ParseError2,
   MultipartUpload_ParseError3,
   MultipartUpload_ParseError4,
   MultipartUpload_ParseError5,
   MultipartUpload_ParseError6,
   MultipartUpload_UserRetErr
} MultipartUpload_ErrorType;
 
#ifndef __DOXYGEN__
struct MultipartUpload;
#endif
 
typedef void (*MultipartUpload_EndOfReq)(
   struct MultipartUpload* o);
 
 
typedef int (*MultipartUpload_FormData)(
   struct MultipartUpload* o,
   const char* name,
   const char* value);
 
typedef int (*MultipartUpload_FileBegin)(
   struct MultipartUpload* o,
   const char* name,
   const char* fileName,
   const char* contentType,
   const char* contentTransferEncoding);
 
typedef int (*MultipartUpload_FileData)(
   struct MultipartUpload* o,
   const U8* data,
   U16 len);
 
typedef void (*MultipartUpload_Error)(
   struct MultipartUpload* o,
   MultipartUpload_ErrorType e);
 
 
 
typedef enum {
   MultipartUpload_ReadBoundaryTag,
   MultipartUpload_ReadHeaders,
   MultipartUpload_ReadFormData,
   MultipartUpload_ReadFileData
} MultipartUpload_States;
 
 
typedef struct MultipartUpload
{
#ifdef __cplusplus
     MultipartUpload() {}
 
      MultipartUpload(HttpServer* server,
                      MultipartUpload_EndOfReq onEndOfReq,
                      MultipartUpload_FormData onFormData,
                      MultipartUpload_FileBegin onFileBegin,
                      MultipartUpload_FileData onFileData,
                      MultipartUpload_Error onError,
                      U32 bufferSize,
                      AllocatorIntf* allocator = 0);
 
      ~MultipartUpload();
 
      int start(HttpRequest *req);
 
 
      int run(HttpRequest *req, bool setKeepAlive=true);
 
      HttpConnection* getCon(MultipartUpload* o);
 
      HttpServer* getServer();
 
   private:
#endif
      HttpConnection super; /* Inherits from HttpConnection */
 
       /* List used as a stack, containing Boundary tags. */
      DoubleList boundaryStack;
      MultipartUpload_EndOfReq endOfReq;
      MultipartUpload_FormData formData;
      MultipartUpload_FileBegin fileBegin;
      MultipartUpload_FileData fileData;
      MultipartUpload_Error onError;
      HttpConnection* con; /* Set if in blocking mode. NULL for asynch mode. */
      char* dataBuffer;
      char* name;
      char* fileName;
      char* contentType;
      char* contentTransferEncoding;
      char* currBName;
      AllocatorIntf* alloc;
      MultipartUpload_States state;
      U32 currentI;
      U32 readI;
      U32 lineStartI;
      U32 lineEndI;
      U32 dataBufferSize;
      U32 expandSize;
      U32 maxFormSize;
      BaBool newBoundaryTag;
      BaBool copyingHttpReqData;
} MultipartUpload;
 
 
#ifdef __cplusplus
extern "C" {
#endif
void
BA_API MultipartUpload_constructor(
   MultipartUpload* o,
   HttpServer* server,
   MultipartUpload_EndOfReq endOfReq,
   MultipartUpload_FormData formData,
   MultipartUpload_FileBegin fileBegin,
   MultipartUpload_FileData fileData,
   MultipartUpload_Error onError,
   U32 bufferSize,
   AllocatorIntf* allocator);
BA_API void MultipartUpload_destructor(MultipartUpload* o);
BA_API int MultipartUpload_start(MultipartUpload* o, HttpRequest *req);
BA_API int MultipartUpload_run(
   MultipartUpload* o, HttpRequest *req, BaBool setKeepAlive);
BA_API HttpConnection* MultipartUpload_getCon(MultipartUpload* o); 
#define MultipartUpload_getServer(o) \
   HttpConnection_getServer((HttpConnection*)(o))
#ifdef __cplusplus
}
inline MultipartUpload::MultipartUpload(
   HttpServer* server,
   MultipartUpload_EndOfReq endOfReq,
   MultipartUpload_FormData formData,
   MultipartUpload_FileBegin fileBegin,
   MultipartUpload_FileData fileData,
   MultipartUpload_Error onError,
   U32 size,
   AllocatorIntf* allocator) {
   MultipartUpload_constructor(this, server, endOfReq, formData,
                               fileBegin, fileData, onError, size, allocator);
}
inline MultipartUpload::~MultipartUpload() {
   MultipartUpload_destructor(this);
}
inline int MultipartUpload::start(HttpRequest *req){
   return MultipartUpload_start(this,req);
}
inline int MultipartUpload::run(HttpRequest *req, bool setKeepAlive) {
   return MultipartUpload_run(this,req,setKeepAlive?TRUE:FALSE);
}
inline HttpConnection* MultipartUpload::getCon(MultipartUpload* o){
   return MultipartUpload_getCon(this); }
inline HttpServer* MultipartUpload::getServer(){
   return MultipartUpload_getServer(this);
}
#endif
 /* end of HttpStack */
  
 
#endif