HttpClient.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Application Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: HttpClient.h 5971 2026-09-11 10:01:39Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2009-2026
 *
 *   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 __HttpClient_h
#define __HttpClient_h
 
#include <DynBuffer.h>
#ifndef NO_SHARKSSL
#include <SharkSslEx.h>
#endif
 
struct HttpClient;
 
 
typedef struct HttpClientKeyVal
{
      const char* key;
      const char* val;
} HttpClientKeyVal;
 
 
 
typedef struct
{
#ifdef __cplusplus
      const char* getKey(HttpClient* c);
      const char* getVal(HttpClient* c);
#endif
      U16 key;
      U16 val;
} HttpClientHeader;
 
#define HttpClientHeader_key(c,o) ((c)->db.super.buf + (o)->key)
#define HttpClientHeader_val(c,o) ((c)->db.super.buf + (o)->val)
 
 
#define HTTP_CLIENT_MAX_HEADERS 64
 
#define HttpClient_SocksProxy   1
#define HttpClient_ProxyConnect 2
#define HttpClient_Persistent   4
#define HttpClient_IPv6         8
/* Reserved for future use */
#define HttpClient_NoHostHeader 16
#define HttpClient_NotUsed2    32
/* May be set by code using the HttpClient lib */
#define HttpClient_UserDef1    64
#define HttpClient_UserDef2   128
 
 
typedef struct HttpClient
#ifdef __cplusplus
: public SoDispCon
{
      HttpClient(SoDisp* disp, U8 mode=HttpClient_Persistent);
 
      ~HttpClient();
 
      void setSSL(SharkSsl* ssl);
 
      void setReadTmo(BaTime timeout);
 
      static int isURL(const char* url);
 
      SharkSslConTrust trusted(void);
 
      void setAcceptTrusted(bool acceptTrusted);
 
      int request(HttpMethod methodType,
                  const char* url,
                  const char* userPass=0,
                  const HttpClientKeyVal* query=0,
                  const HttpClientKeyVal* headers=0,
                  BaFileSize size=0);
 
      int sendData(const void* data, int len);
 
      int getBufSize();
 
      int readData(void* buf, int bufSize);
 
      const char* getHeaderValue(const char* name);
 
      HttpClientHeader* getHeaders(int* hlen);
 
      void close();
 
      int getStatus();
 
      int getError();
 
   SharkSslCon* getSharkSslCon();
 
      SoDispCon* getSoDispCon();
#else
{
      SoDispCon super;
#endif
      DynBuffer db;
      HttpClientHeader headers[HTTP_CLIENT_MAX_HEADERS];
 
      struct SharkSsl* sharkSslClient; /* optional SSL client */
 
      /* Variable proxyPortNo and the following 3 variables must be
       * set and managed by the user of this class.
       */
      const char* proxy; /* Proxy name/IP addr, if any */
      const char* proxyUserPass; /* Format:  "user:password" */
      const char* intfName; /* If 0: bind to any intf, or bind to intfName */
 
      char* data; /* Pointer to start of payload data */
      char* host; /* Server host name */
      BaFileSize size; /* Send or receive data size */
      BaTime readTmo; /* Default read timeout is 20 seconds */
      int chunkSize;
      int lastError;
      int portNo; /* host port number */
      U16 proxyPortNo; /* host port number */
      U16 headerLen;
      S16 httpStatus;
      BaBool chunkEncoding;
      BaBool respManaged; /* Func HttpClient_manageEndOfRequest */
      BaBool closeCon;
      BaBool acceptTrusted; /* Accept only trusted connections */
      /*
        HttpClient_SocksProxy
        HttpClient_Persistent
        HttpClient_IPv6
       */
      U8 mode;
      U8 methodType;
} HttpClient;
 
#ifdef __cplusplus
extern "C" {
#endif
 
void HttpClient_constructor(HttpClient* o, SoDisp* disp, U8 mode);
#define HttpClient_setSSL(o, ssl) (o)->sharkSslClient=ssl
#define HttpClient_setReadTmo(o, timeout) (o)->readTmo=timeout
#ifndef NO_SHARKSSL
SharkSslCon* HttpClient_getSharkSslCon(HttpClient* o);
#endif
 
void HttpClient_destructor(HttpClient* o);
int HttpClient_isURL(const char* url);
int HttpClient_request(HttpClient* o,
                       HttpMethod methodType,
                       const char* url,
                       const char* userPass,
                       const HttpClientKeyVal* params,
                       const HttpClientKeyVal* headers,
                       BaFileSize size);
 
int HttpClient_sendData(HttpClient* o, const void* data, int len);
int HttpClient_getBufSize(HttpClient* o);
int HttpClient_readDataBuffered(HttpClient* o, void* buf, int bufSize);
int HttpClient_readData(HttpClient* o, void* buf, int bufSize);
const char* HttpClient_getHeaderValue(HttpClient* o, const char* name);
HttpClientHeader* HttpClient_getHeaders(HttpClient* o, int* hlen);
void HttpClient_close(HttpClient* o);
int HttpClient_getStatus(HttpClient* o);
#define HttpClient_getError(o) (o)->lastError
#define HttpClient_getSoDispCon(o) ((SoDispCon*)(o))
#ifndef NO_SHARKSSL
SharkSslConTrust HttpClient_trusted(HttpClient* o);
#endif
#define HttpClient_setAcceptTrusted(o, t) (o)->acceptTrusted=t
 
#ifdef __cplusplus
}
 
inline HttpClient::HttpClient(SoDisp* disp, U8 mode) {
   HttpClient_constructor(this,disp, mode);
}
 
inline HttpClient::~HttpClient() {
   HttpClient_destructor(this);
}
 
inline void HttpClient::setSSL(SharkSsl* ssl) {
   HttpClient_setSSL(this,ssl);
}
 
inline void HttpClient::setReadTmo(BaTime timeout) {
   HttpClient_setReadTmo(this,timeout);
}
 
inline int HttpClient::isURL(const char* url) {
   return HttpClient_isURL(url);
}
 
 
inline SharkSslConTrust HttpClient::trusted(void){
   return HttpClient_trusted(this);
}
 
inline void HttpClient::setAcceptTrusted(bool t) {
   HttpClient_setAcceptTrusted(this, t?TRUE:FALSE);
}
 
 
inline SharkSslCon* HttpClient::getSharkSslCon() {
   return HttpClient_getSharkSslCon(this);
}
 
 
inline int HttpClient::request(HttpMethod methodType,
                               const char* url,
                               const char* userPass,
                               const HttpClientKeyVal* params,
                               const HttpClientKeyVal* headers,
                               BaFileSize size)
{
   return HttpClient_request(this,methodType,url,userPass,params,headers,size);
}
 
inline int HttpClient::sendData(const void* data, int len) {
   return HttpClient_sendData(this, data, len);
}
 
inline int HttpClient::getBufSize() {
   return HttpClient_getBufSize(this);
}
 
inline int HttpClient::readData(void* buf, int bufSize) {
   return HttpClient_readData(this, buf, bufSize);
}
 
inline const char* HttpClient::getHeaderValue(const char* name) {
   return HttpClient_getHeaderValue(this, name);
}
 
inline HttpClientHeader* HttpClient::getHeaders(int* hlen) {
   return HttpClient_getHeaders(this, hlen);
}
 
inline void HttpClient::close() {
   HttpClient_close(this);
}
 
inline int HttpClient::getStatus() {
   return HttpClient_getStatus(this);
}
 
 
inline int HttpClient::getError() {
   return HttpClient_getError(this);
}
 
inline SoDispCon* HttpClient::getSoDispCon() {
   return HttpClient_getSoDispCon(this);
}
 
inline const char* HttpClientHeader::getKey(HttpClient* c) {
   return c->db.buf + key;
}
inline const char* HttpClientHeader::getVal(HttpClient* c) {
   return c->db.buf + val;
}
#endif
 /* End group HttpClient */
 
 
#endif