mqtt_msg_reqs.h

#ifndef  __MQTT_MSG_REQS_H
#define  __MQTT_MSG_REQS_H
#include <predef.h>
#include <basictypes.h>
#include <nbstring.h>
#include <webclient/http_funcs.h>
#include <mqtt/msg_types.h>
 
namespace MQTT {

namespace PacketInfo {
struct ConnectAck {
    uint8_t flags;
    uint32_t remLen;
    bool sessPresent;
    uint32_t propsLen;
    Pkt::eReasonCode_t reason;
};
 
struct Publish {
    uint8_t flags;
    uint32_t remLen;
    NBString *topic;
    uint16_t pktId;
    uint32_t propsLen;
    uint32_t payLen;
};
 
struct PublishAck{
    uint8_t flags;
    uint32_t remLen;
    uint16_t pktId;
    uint32_t propsLen;
    Pkt::eReasonCode_t reason;
};
 
struct SubscribeAck {
    uint8_t flags;
    uint32_t remLen;
    uint16_t pktId;
    uint32_t propsLen;
    Pkt::eReasonCode_t reason;
    NBString *reasonStr;
};
 
struct UnsubscribeAck {
    uint8_t flags;
    uint32_t remLen;
    uint16_t pktId;
    uint32_t propsLen;
    uint32_t paylLen;
    Pkt::eReasonCode_t reason;
    uint32_t subId;
    NBString *reasonStr;
};
 
struct Disconnect {
    uint8_t flags;
    uint32_t remLen;
    uint32_t propsLen;
    Pkt::eReasonCode_t reason;
    NBString *reasonStr;
    NBString *serverRef;
};

struct Msg {
    union {
        struct {
            uint8_t flags;         
            uint32_t remLen;       
        };
        ConnectAck       connack;  
        Publish          publish;  
        PublishAck       puback;   
        SubscribeAck     suback;   
        UnsubscribeAck   unsuback; 
        Disconnect       disconn;  
    };
    inline Pkt::eType_t GetType()
        { return (Pkt::eType_t)(flags>>4); }

    inline uint8_t GetFlags()
        { return (flags & 0xF); }

    Msg() {};
    ~Msg() {};
};
 
 
}
 
class Client;
 
typedef int (*ConnAckCb_t) (Client *mConn, int mqttFd, void *ctx, PacketInfo::ConnectAck *connack);
typedef bool(*TopicMatchCb_t)(Client *mConn, NBString *topicName, void *matchCtx);
typedef int (*WrPropCb_t) (Client *mConn, int mqttFd, void *ctx, uint32_t propLen);
typedef int (*WrPayloadCb_t) (Client *mClient, int mqttFd, void *ctx, uint32_t payloadLen);
typedef int (*AckCb_t) (Client *mClient, void *ctx, PacketInfo::PublishAck *ack);
typedef int (*DisconnCb_t) (Client *mClient, PacketInfo::Disconnect *disconn);
 
struct TopicHandler;
 
struct AckCbCtx {
    AckCb_t cb;
    void *ctx;
};
 
typedef enum {
    ePropListType_PData,
    ePropListType_PList,
    ePropListType_Callback,
    ePropListType_None
} ePropertyListType;
 
typedef enum {
    ePayloadType_PData,
    ePayloadType_PoolPtr,
    ePayloadType_Callback,
    ePayloadType_None
} ePayloadType;
 
typedef enum {
    ePropValType_ValByte,
    ePropValType_ValShort,
    ePropValType_ValLong,
    ePropValType_ValPStr,
    ePropValType_ValPStrPair,
    ePropValType_ValPData,
    ePropValType_ValLocStr,
    ePropValType_ValLocStrPair,
    ePropValType_ValLocData,
    ePropValType_Callback
} ePropertyValueType;
 
struct RequestProperty {
    RequestProperty *pNext;
    ePropertyValueType valType;
    uint8_t prop;
    union {
        struct {
            union {
                uint8_t  valByte;
                uint16_t valShort;
                uint32_t valLong;
                uint16_t data_len;
                uint16_t sLen[2];
            };
            union {
                char * pStr[2];
                uint8_t * pData;
                struct {
                    WrPayloadCb_t cb;
                    void *ctx;
                };
            };
        };
        struct {
            union {
                uint8_t  _val8;
                uint16_t _val16;
                uint32_t _val32;
                uint16_t _data_len;
            };
            uint8_t data[];
        };
    };
    uint32_t GetEncodedLength();
    uint32_t ListGetEncodedLength();
};
 
struct PublishRequest;

struct ConnectRequest {
    ParsedURI brokerURI;
    uint8_t flags;
    uint16_t keepalive;
    const char *clientId;
    const char *username;
    const char *password;
 
    uint32_t propsType:4;
    uint32_t propsLen:28;
    union {
        const uint8_t *propBuf;
        RequestProperty *propList;
        struct {
            WrPropCb_t propWrCb;
            void * propWrCtx;
        };
    };
    PublishRequest *pLwtReq;
    ConnAckCb_t   connAckCb;
    void         *connAckCtx;
};

struct PublishRequest {
    PublishRequest *pNextReq;
    PublishRequest *pPrevReq;
    uint8_t flags;
    const char *topicName;
    uint32_t propsType : 4; // ePropertyValueType
    uint32_t propsLen : 28;
 
    union {
        const uint8_t *propBuf;
        RequestProperty *propList;
        struct {
            WrPropCb_t propWrCb;
            void *propWrCtx;
        };
    };
    uint32_t payloadType : 4;
    uint32_t payloadLen : 28;
    union {
        const uint8_t *pBuf;
//        PoolPtr pp;
        pool_buffer * pp;
        struct {
            WrPayloadCb_t payWrCb;
            void *payWrCtx;
        };
    };
    AckCbCtx *cbCtx;
    void dump();
};
 
typedef enum {
    eSubReq_Pay_cstr,
    eSubReq_Pay_cstrList,
    eSubReq_Pay_nbstr,
    eSubReq_Pay_nbstrList,
    eSubReq_Pay_cb,
} eSubscribeRequestPayloadType;
 
typedef enum {
    eSubReq_UProp_None,
    eSubReq_UProp_up,
    eSubReq_UProp_ptrupList,
    eSubReq_UProp_upList,
    eSubReq_UProp_nbstr,
    eSubReq_UProp_ptrnbstrList,
    eSubReq_UProp_nbstrList,
    eSubReq_UProp_cb,
} eSubscribeRequestUserPropertyType;
 
struct UserProperty {
    const char *key;
    const char *val;
};
 
struct UserProperty_NbStr {
    const NBString *key;
    const NBString *val;
};

struct SubscribeFilter {
    const char *filter;
    uint8_t     opts;
};

struct SubscribeFilter_NbStr {
    const NBString *filter;
    uint8_t     opts;
};

struct SubscribeRequest {
    SubscribeRequest *pNextSubReq;
    int     subId;
    uint8_t subType : 4;
    uint8_t propsType: 4;
    TopicHandler *pubHandler;
    union {
        SubscribeFilter_NbStr filterNB;
        SubscribeFilter filter;
        SubscribeFilter *filterList;
        SubscribeFilter_NbStr *filterListNB;
        struct {
            uint32_t totalStrLen;
            WrPayloadCb_t filtersCb;
            void *filtersCtx;
        };
    };
    union{
        struct {
            uint32_t listLen;
            UserProperty *pUPropList;
        };
        UserProperty UProp; // optional, needs both key and val
        UserProperty_NbStr nbUProp;
        struct {
            uint32_t _listLen0;
            UserProperty_NbStr *pUPropNBList;
        };
        struct {
            uint32_t _listLen1;
            UserProperty UPropList[];
        };
        struct {
            uint32_t _listLen2;
            UserProperty_NbStr UPropNBList[];
        };
        struct {
            uint32_t totalUserPropsLen;
            WrPayloadCb_t UPropsCb;
            void *UPropsCbCtx;
        };
    };
};
 
struct SubUnsubQueueMsg {
    SubUnsubQueueMsg *pNextReq;
    SubscribeRequest *req;
    AckCbCtx *cb;
    uint16_t handlerIdx;
    bool unsub;
};
 
}
 
 
#endif   /* ----- #ifndef __MQTT_MSG_REQS_H  ----- */