SMQ.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 ****************************************************************************
 *            HEADER
 *
 *   This file is part of SharkMQ:
 *            https://realtimelogic.com/products/sharkssl/SharkMQ/
 *
 *   $Id: SMQ.h 5029 2022-01-16 21:32:09Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2014 - 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://sharkssl.com
 ****************************************************************************
 *
 */
 
#ifndef __SharkMQ_h
#define __SharkMQ_h
 
#define SMQ_SEC
 
#include "selib.h"
 
#ifdef ENABLE_PROXY
#define ENABLE_HTTPS_PROXY
#define ENABLE_SOCKS_PROXY
#endif
 
#if defined(ENABLE_HTTPS_PROXY) || defined(ENABLE_SOCKS_PROXY)
#ifndef ENABLE_PROXY
#define ENABLE_PROXY
#endif
#include "proxy.h"
#endif
 
 
#define SMQE_BUF_OVERFLOW    -10000
 
#define SMQE_ONACK_DENIED    -10000
 
#define SMQE_INVALID_URL     -10002 
 
#define SMQE_PROTOCOL_ERROR  -10003 
 
#define SMQE_DISCONNECT      -10004
 
 
#define SMQE_PONGTIMEOUT     -10005
 /* end SharkMQErrorCodes */
 
 
#define SMQ_SUBACK           -20000
 
#define SMQ_CREATEACK        -20001
 
#define SMQ_CREATESUBACK     -20002
 
#define SMQ_SUBCHANGE        -20003
 
#define SMQ_TIMEOUT         -20004
 /* end SharkMQRespCodes */
 
 
#define SMQSTR(str) str, (sizeof(str)-1)
 
typedef struct SharkMQ
{
   SOCKET sock;
   SharkSslCon* scon;
 
   U8* sharkBuf; /* SharkSSL read buffer is set when we have data from Shark */
   U8* buf; /* buffer provided by user via constructor */
 
   U16 sharkBufLen; /* TLS frame len */
   U16 sharkBufIx; /* Current read index in sharkBuf */
 
   U16 bufLen; /* User buffer total len */
   U16 bufIx; /* Current read index in user buffer */
 
 
   U32 timeout;
   S32 pingTmoCounter,pingTmo;
   U32 clientTid; 
   U32 tid;  
   U32 ptid; 
   U32 subtid; 
   int status; 
   U16 sendBufIx;
   U16 frameLen; 
   U16 bytesRead;
#ifdef ENABLE_PROXY
   Proxy* proxy;
#endif
 
#ifdef __cplusplus
 
   SharkMQ(U8* buf, U16 bufLen);
 
 
   int init(SharkSslCon* scon, const char* url, U32* rnd);
 
   int connect(const char* uid, int uidLen, const char* credentials,
               U8 credLen, const char* info, int infoLen,
               U16 maxTlsFrameSize);
 
 
   void disconnect();
 
 
   ~SharkMQ();
 
 
   int create(const char* topic);
 
 
   int createsub(const char* subtopic);
 
 
   int subscribe(const char* topic);
 
 
   int unsubscribe(U32 tid);
 
 
   int publish(const void* data, int len, U32 tid, U32 subtid);
 
 
   int wrtstr(const char* str);
 
   int write( const void* data, int len);
 
   int pubflush(U32 tid, U32 subtid);
 
 
   int observe(U32 tid);
 
 
   int unobserve(U32 tid);
 
 
   int getMessage(U8** msg);
 
 
   int getMsgSize();
 
#endif
 
} SharkMQ;
 
#ifdef __cplusplus
extern "C" {
#endif
 
void SharkMQ_constructor(SharkMQ* o, U8* buf, U16 bufLen);
 
#define SharkMQ_setProxy(o, proxyMA) (o)->proxy=proxyMA
 
#define SharkMQ_setCtx(o, ctx) SOCKET_constructor(&(o)->sock, ctx)
 
 
#define SharkMQ_getSendBufPtr(o) (SharkSslCon_getEncBufPtr((o)->scon) + 15)
 
#define SharkMQ_getSendBufSize(o) (SharkSslCon_getEncBufSize((o)->scon) - 15)
 
 
int SharkMQ_init(SharkMQ* o, SharkSslCon* scon, const char* url, U32* rnd);
 
int SharkMQ_connect(SharkMQ* o, const char* uid, int uidLen,
                    const char* credentials, U8 credLen,
                    const char* info, int infoLen,
                    U16 maxTlsFrameSize);
 
 
void SharkMQ_disconnect(SharkMQ* o);
 
 
void SharkMQ_destructor(SharkMQ* o);
 
 
int SharkMQ_create(SharkMQ* o, const char* topic);
 
 
int SharkMQ_createsub(SharkMQ* o, const char* subtopic);
 
 
int SharkMQ_subscribe(SharkMQ* o, const char* topic);
 
 
int SharkMQ_unsubscribe(SharkMQ* o, U32 tid);
 
 
int SharkMQ_publish(SharkMQ* o, const void* data, int len, U32 tid, U32 subtid);
 
 
int SharkMQ_wrtstr(SharkMQ* o, const char* str);
 
int SharkMQ_write(SharkMQ* o,  const void* data, int len);
 
int SharkMQ_pubflush(SharkMQ* o, U32 tid, U32 subtid);
 
 
int SharkMQ_observe(SharkMQ* o, U32 tid);
 
 
int SharkMQ_unobserve(SharkMQ* o, U32 tid);
 
 
int SharkMQ_getMessage(SharkMQ* o, U8** msg);
 
 
#define SharkMQ_getMsgSize(o) ((o)->frameLen-15)
 /* end group SMQLib_C */ 
 
#ifdef __cplusplus
}
 
inline SharkMQ::SharkMQ(U8* buf, U16 bufLen) {
   SharkMQ_constructor(this,buf, bufLen);
}
 
inline int SharkMQ::init(SharkSslCon* scon, const char* url, U32* rnd) {
   return SharkMQ_init(this, scon, url, rnd);
}
 
inline int SharkMQ::connect(const char* uid, int uidLen,
                            const char* credentials,
                            U8 credLen, const char* info, int infoLen,
                            U16 maxTlsFrameSize) {
   return SharkMQ_connect(
      this,uid,uidLen,credentials,credLen,info,infoLen,maxTlsFrameSize);
}
 
inline void SharkMQ::disconnect() {
   return SharkMQ_disconnect(this);
}
 
inline SharkMQ::~SharkMQ() {
   SharkMQ_destructor(this);
}
 
inline int SharkMQ::create(const char* topic) {
   return SharkMQ_create(this, topic);
}
 
inline int SharkMQ::createsub(const char* subtopic) {
   return SharkMQ_createsub(this, subtopic);
}
 
inline int SharkMQ::subscribe(const char* topic) {
   return SharkMQ_subscribe(this, topic);
}
 
inline int SharkMQ::unsubscribe(U32 tid) {
   return SharkMQ_unsubscribe(this, tid);
}
 
inline int SharkMQ::publish(const void* data, int len, U32 tid, U32 subtid) {
   return SharkMQ_publish(this, data, len, tid, subtid);
}
 
inline int SharkMQ::wrtstr(const char* str) {
   return SharkMQ_wrtstr(this, str);
}
 
inline int SharkMQ::write( const void* data, int len) {
   return SharkMQ_write(this, data, len);
}
 
inline int SharkMQ::pubflush(U32 tid, U32 subtid) {
   return SharkMQ_pubflush(this, tid, subtid);
}
 
inline int SharkMQ::observe(U32 tid) {
   return SharkMQ_observe(this, tid);
}
 
inline int SharkMQ::unobserve(U32 tid) {
   return SharkMQ_unobserve(this, tid);
}
 
inline int SharkMQ::getMessage(U8** msg) {
   return SharkMQ_getMessage(this, msg);
}
 
inline int SharkMQ::getMsgSize() {
   return SharkMQ_getMsgSize(this);
}
 
#endif
 
 
 /* end group SMQLib */
 
#endif