MQTTPacket.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2009, 2020 IBM Corp.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * and Eclipse Distribution License v1.0 which accompany this distribution. 
 *
 * The Eclipse Public License is available at 
 *    https://www.eclipse.org/legal/epl-2.0/
 * and the Eclipse Distribution License is available at 
 *   http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *    Ian Craggs - initial API and implementation and/or initial documentation
 *    Ian Craggs, Allan Stockdill-Mander - SSL updates
 *    Ian Craggs - MQTT 3.1.1 support
 *    Ian Craggs - big endian Linux reversed definition
 *    Ian Craggs - MQTT 5.0 support
 *******************************************************************************/

#if !defined(MQTTPACKET_H)
#define MQTTPACKET_H

#include "Socket.h"
#if defined(OPENSSL)
#include "SSLSocket.h"
#endif
#include "LinkedList.h"
#include "Clients.h"

typedef unsigned int bool;
typedef void* (*pf)(int, unsigned char, char*, size_t);

#include "MQTTProperties.h"
#include "MQTTReasonCodes.h"

enum errors
{
        MQTTPACKET_BAD = -4,
        MQTTPACKET_BUFFER_TOO_SHORT = -2,
        MQTTPACKET_READ_ERROR = -1,
        MQTTPACKET_READ_COMPLETE
};


enum msgTypes
{
        CONNECT = 1, CONNACK, PUBLISH, PUBACK, PUBREC, PUBREL,
        PUBCOMP, SUBSCRIBE, SUBACK, UNSUBSCRIBE, UNSUBACK,
        PINGREQ, PINGRESP, DISCONNECT, AUTH
};

#if defined(__linux__)
#include <endian.h>
#if __BYTE_ORDER == __BIG_ENDIAN
        #define REVERSED 1
#endif
#endif

typedef union
{
        /*unsigned*/ char byte; 
#if defined(REVERSED)
        struct
        {
                unsigned int type : 4;  
                bool dup : 1;                   
                unsigned int qos : 2;   
                bool retain : 1;                
        } bits;
#else
        struct
        {
                bool retain : 1;                
                unsigned int qos : 2;   
                bool dup : 1;                   
                unsigned int type : 4;  
        } bits;
#endif
} Header;


typedef struct
{
        Header header;  
        union
        {
                unsigned char all;      
#if defined(REVERSED)
                struct
                {
                        bool username : 1;                      
                        bool password : 1;                      
                        bool willRetain : 1;            
                        unsigned int willQoS : 2;       
                        bool will : 1;                  
                        bool cleanstart : 1;    
                        int : 1;        
                } bits;
#else
                struct
                {
                        int : 1;        
                        bool cleanstart : 1;    
                        bool will : 1;                  
                        unsigned int willQoS : 2;       
                        bool willRetain : 1;            
                        bool password : 1;                      
                        bool username : 1;                      
                } bits;
#endif
        } flags;        
        char *Protocol, 
                *clientID,      
        *willTopic,     
        *willMsg;       
        int keepAliveTimer;             
        unsigned char version;  
} Connect;


typedef struct
{
        Header header; 
        union
        {
                unsigned char all;      
#if defined(REVERSED)
                struct
                {
                        unsigned int reserved : 7;      
                        bool sessionPresent : 1;    
                } bits;
#else
                struct
                {
                        bool sessionPresent : 1;    
                        unsigned int reserved : 7;      
                } bits;
#endif
        } flags;         
        unsigned char rc; 
        unsigned int MQTTVersion;  
        MQTTProperties properties; 
} Connack;


typedef struct
{
        Header header;  
} MQTTPacket;


typedef struct
{
        Header header;  
        int msgId;              
        int MQTTVersion;  
        MQTTProperties properties; 
        List* qoss;             
} Suback;


typedef struct
{
        Header header;  
        int msgId;              
        int MQTTVersion;  
        MQTTProperties properties; 
        List* reasonCodes;      
} Unsuback;


typedef struct
{
        Header header;  
        char* topic;    
        int topiclen;
        int msgId;              
        char* payload;  
        int payloadlen; 
        int MQTTVersion;  
        MQTTProperties properties; 
        uint8_t mask[4]; 
} Publish;


typedef struct
{
        Header header;  
        int msgId;              
        unsigned char rc; 
        int MQTTVersion;  
        MQTTProperties properties; 
} Ack;

typedef Ack Puback;
typedef Ack Pubrec;
typedef Ack Pubrel;
typedef Ack Pubcomp;

int MQTTPacket_encode(char* buf, size_t length);
int MQTTPacket_decode(networkHandles* net, size_t* value);
int readInt(char** pptr);
char* readUTF(char** pptr, char* enddata);
unsigned char readChar(char** pptr);
void writeChar(char** pptr, char c);
void writeInt(char** pptr, int anInt);
void writeUTF(char** pptr, const char* string);
void writeData(char** pptr, const void* data, int datalen);

const char* MQTTPacket_name(int ptype);

void* MQTTPacket_Factory(int MQTTVersion, networkHandles* net, int* error);
int MQTTPacket_send(networkHandles* net, Header header, char* buffer, size_t buflen, int free, int MQTTVersion);
int MQTTPacket_sends(networkHandles* net, Header header, PacketBuffers* buffers, int MQTTVersion);

void* MQTTPacket_header_only(int MQTTVersion, unsigned char aHeader, char* data, size_t datalen);
int MQTTPacket_send_disconnect(Clients* client, enum MQTTReasonCodes reason, MQTTProperties* props);

void* MQTTPacket_publish(int MQTTVersion, unsigned char aHeader, char* data, size_t datalen);
void MQTTPacket_freePublish(Publish* pack);
int MQTTPacket_send_publish(Publish* pack, int dup, int qos, int retained, networkHandles* net, const char* clientID);
int MQTTPacket_send_puback(int MQTTVersion, int msgid, networkHandles* net, const char* clientID);
void* MQTTPacket_ack(int MQTTVersion, unsigned char aHeader, char* data, size_t datalen);

void MQTTPacket_freeAck(Ack* pack);
void MQTTPacket_freeSuback(Suback* pack);
void MQTTPacket_freeUnsuback(Unsuback* pack);
int MQTTPacket_send_pubrec(int MQTTVersion, int msgid, networkHandles* net, const char* clientID);
int MQTTPacket_send_pubrel(int MQTTVersion, int msgid, int dup, networkHandles* net, const char* clientID);
int MQTTPacket_send_pubcomp(int MQTTVersion, int msgid, networkHandles* net, const char* clientID);

void MQTTPacket_free_packet(MQTTPacket* pack);

void writeInt4(char** pptr, int anInt);
int readInt4(char** pptr);
void writeMQTTLenString(char** pptr, MQTTLenString lenstring);
int MQTTLenStringRead(MQTTLenString* lenstring, char** pptr, char* enddata);
int MQTTPacket_VBIlen(int rem_len);
int MQTTPacket_decodeBuf(char* buf, unsigned int* value);

#include "MQTTPacketOut.h"

#endif /* MQTTPACKET_H */