SMQ.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 ****************************************************************************
 *            HEADER
 *
 *   $Id: SMQ.h 6686 2026-10-29 23:59:57Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2014 - 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.
 *
 *               https://realtimelogic.com
 ****************************************************************************
 * SMQ C library:
 *  https://realtimelogic.com/ba/doc/en/C/reference/html/group__SMQClient.html
 */
 
#ifndef __SMQClient_h
#define __SMQClient_h
 
#define SMQ_NONSEC
 
#include "selib.h"
 
#ifndef ISDIGIT
#define ISDIGIT isdigit
#endif
 
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
 
#define SMQE_BUF_OVERFLOW    -10000
 
#define SMQE_INVALID_URL     -10002 
 
#define SMQE_PROTOCOL_ERROR  -10003 
 
#define SMQE_DISCONNECT      -10004
 
 
#define SMQE_PONGTIMEOUT     -10005
 /* end SMQClientErrorCodes */
 
 
#define SMQ_SUBACK           -20000
 
#define SMQ_CREATEACK        -20001
 
#define SMQ_CREATESUBACK     -20002
 
#define SMQ_SUBCHANGE        -20003
 
#define SMQ_TIMEOUT         -20004
 
 /* end SMQClientRespCodes */
 
 
#define SMQSTR(str) str, (sizeof(str)-1)
 
typedef struct SMQ
{
   SOCKET sock;
 
   U8* buf; 
#ifdef SMQ_ENABLE_SENDBUF
   U8* sBuf;
#endif
 
   U32 timeout;
   S32 pingTmoCounter,pingTmo;
   U32 clientTid; 
   U32 tid;  
   U32 ptid; 
   U32 subtid; 
   int status; 
   U16 bufLen;
   U16 rBufIx;
#ifdef SMQ_ENABLE_SENDBUF
   U16 sBufIx;
#endif
   U16 frameLen; 
   U16 bytesRead;
   U8 inRecv; /* boolean set to true when thread blocked in SMQ_recv */
   U8 recvPending; /* partial frame retained after timeout */
#ifdef __cplusplus
 
   SMQ(U8* buf, U16 bufLen);
 
 
   int init(const char* url, U32* rnd);
 
   int connect(const char* uid, int uidLen, const char* credentials,
                    U8 credLen, const char* info, int infoLen);
 
 
   void disconnect();
 
 
   ~SMQ();
 
 
   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
} SMQ;
 
#ifdef __cplusplus
extern "C" {
#endif
 
void SMQ_constructor(SMQ* o, U8* buf, U16 bufLen);
 
 
#define SMQ_setCtx(o, ctx) SOCKET_constructor(&(o)->sock, ctx)
 
 
int SMQ_init(SMQ* o, const char* url, U32* rnd);
 
int SMQ_connect(SMQ* o, const char* uid, int uidLen, const char* credentials,
                U8 credLen, const char* info, int infoLen);
 
 
void SMQ_disconnect(SMQ* o);
 
 
void SMQ_destructor(SMQ* o);
 
 
int SMQ_create(SMQ* o, const char* topic);
 
 
int SMQ_createsub(SMQ* o, const char* subtopic);
 
 
int SMQ_subscribe(SMQ* o, const char* topic);
 
 
int SMQ_unsubscribe(SMQ* o, U32 tid);
 
 
int SMQ_publish(SMQ* o, const void* data, int len, U32 tid, U32 subtid);
 
 
int SMQ_wrtstr(SMQ* o, const char* str);
 
int SMQ_write(SMQ* o,  const void* data, int len);
 
int SMQ_pubflush(SMQ* o, U32 tid, U32 subtid);
 
 
int SMQ_observe(SMQ* o, U32 tid);
 
 
int SMQ_unobserve(SMQ* o, U32 tid);
 
 
int SMQ_getMessage(SMQ* o, U8** msg);
 
 
#define SMQ_getMsgSize(o) ((o)->frameLen-15)
 /* end group SMQClient_C */ 
 
#ifdef __cplusplus
}
inline SMQ::SMQ(U8* buf, U16 bufLen) {
   SMQ_constructor(this,buf, bufLen);
}
 
inline int SMQ::init(const char* url, U32* rnd) {
   return SMQ_init(this, url, rnd);
}
 
inline int SMQ::connect(const char* uid, int uidLen, const char* credentials,
                        U8 credLen, const char* info, int infoLen) {
   return SMQ_connect(this,  uid, uidLen, credentials, credLen, info, infoLen);
}
 
inline void SMQ::disconnect() {
   return SMQ_disconnect(this);
}
 
inline SMQ::~SMQ() {
   SMQ_destructor(this);
}
 
inline int SMQ::create(const char* topic) {
   return SMQ_create(this, topic);
}
 
inline int SMQ::createsub(const char* subtopic) {
   return SMQ_createsub(this, subtopic);
}
 
inline int SMQ::subscribe(const char* topic) {
   return SMQ_subscribe(this, topic);
}
 
inline int SMQ::unsubscribe(U32 _tid) {
   return SMQ_unsubscribe(this, _tid);
}
 
inline int SMQ::publish(const void* data, int len, U32 _tid, U32 _subtid) {
   return SMQ_publish(this, data, len, _tid, _subtid);
}
 
inline int SMQ::wrtstr(const char* str) {
   return SMQ_wrtstr(this, str);
}
 
inline int SMQ::write( const void* data, int len) {
   return SMQ_write(this, data, len);
}
 
inline int SMQ::pubflush(U32 _tid, U32 _subtid) {
   return SMQ_pubflush(this, _tid, _subtid);
}
 
inline int SMQ::observe(U32 _tid) {
   return SMQ_observe(this, _tid);
}
 
inline int SMQ::unobserve(U32 _tid) {
   return SMQ_unobserve(this, _tid);
}
 
inline int SMQ::getMessage(U8** msg) {
   return SMQ_getMessage(this, msg);
}
 
inline int SMQ::getMsgSize() {
   return SMQ_getMsgSize(this);
}
 
#endif
 
 
/*
  The SharkMQ (secure SMQ) compatibility API makes it easy to write
  code that can later be upgraded to a secure version, if needed.
*/
#ifndef SHARKMQ_COMPAT
#define SHARKMQ_COMPAT 1
#endif
 
#if SHARKMQ_COMPAT
#define SharkMQ SMQ
#define SharkSslCon void
#define SharkMQ_constructor(o, buf, bufLen) SMQ_constructor(o, buf, bufLen)
#define SharkMQ_setCtx(o, ctx) SMQ_setCtx(o, ctx)
#define SharkMQ_init(o, scon, url, rnd) SMQ_init(o, url, rnd)
#define SharkMQ_connect(o, uid, uidLen, credentials, credLen, info, infoLen, NotApplicable) \
   SMQ_connect(o, uid, uidLen, credentials, credLen, info, infoLen)
#define SharkMQ_disconnect(o) SMQ_disconnect(o)
#define SharkMQ_destructor(o) SMQ_destructor(o)
#define SharkMQ_create(o, topic) SMQ_create(o, topic)
#define SharkMQ_createsub(o, subtopic) SMQ_createsub(o, subtopic)
#define SharkMQ_subscribe(o, topic) SMQ_subscribe(o, topic)
#define SharkMQ_unsubscribe(o, tid) SMQ_unsubscribe(o, tid)
#define SharkMQ_publish(o, data, len, tid, subtid) \
   SMQ_publish(o, data, len, tid, subtid)
#define SharkMQ_wrtstr(o, str) SMQ_wrtstr(o, str)
#define SharkMQ_write(o,  data, len) SMQ_write(o,  data, len)
#define SharkMQ_pubflush(o, tid, subtid) SMQ_pubflush(o, tid, subtid)
#define SharkMQ_observe(o, tid) SMQ_observe(o, tid)
#define SharkMQ_unobserve(o, tid) SMQ_unobserve(o, tid)
#define SharkMQ_getMessage(o, msg) SMQ_getMessage(o, msg)
#define SharkMQ_getMsgSize(o) SMQ_getMsgSize(o)
#endif
 
 /* end group selib */
 
#endif