Publisher and Subscriber in the same client about emqtt5 HOT 12 CLOSED

// Usual programs
#include <stdio.h>
#include <stdlib.h>

// We need MQTT client 
#include "Network/Clients/MQTT.hpp"


struct MessageReceiver : public Network::Client::MessageReceived
{
    void messageReceived(const Network::Client::MQTTv5::DynamicStringView & topic, const Network::Client::MQTTv5::DynamicBinDataView & payload, 
                         const uint16 packetIdentifier, const Network::Client::MQTTv5::PropertiesView & properties)
    {
        fprintf(stdout, "Msg received: (%04X)\n", packetIdentifier);
        fprintf(stdout, "  Topic: %.*s\n", topic.length, topic.data);
        fprintf(stdout, "  Payload: %.*s\n", payload.length, payload.data);
    }

};

Network::Client::MQTTv5::QoSDelivery QoS = Network::Client::MQTTv5::QoSDelivery::AtMostOne;

volatile bool cont = true;
void ctrlc(int sig)
{
    if (sig == SIGINT) cont = false;
}


int main(int argc, const char ** argv)
{
    
    const char * server = "yourserver.com";
    const uint16 port = 1883;
    const char * username = "bob";
    const char * password = "sponge";
    const char * subscribe = "/topic/to/subscribe/to";
    const char * publishTopic = "/topic/to/publish/to";
    const char * publishMessage = "I'm alive... again";
    unsigned keepAlive = 300; 
    
    MessageReceiver receiver;
    
    Network::Client::MQTTv5 client(clientID, &receiver);
    Network::Client::MQTTv5::DynamicBinDataView pw(strlen(password), (const uint8*)password);

    if (Network::Client::MQTTv5::ErrorType ret = client.connectTo(server, port, false, 
                                                                  (uint16)min(65535U, keepAlive), true, username, &pw))
    {
        return fprintf(stderr, "Failed connection to %s with error: %d\n", (const char*)serverURL.asText(), (int)ret); 
    }
    printf("Connected to %s\n", (const char*)serverURL.asText());

    // Check if we have some subscription
        if (Network::Client::MQTTv5::ErrorType ret = client.subscribe(subscribe, Protocol::MQTT::V5::GetRetainedMessageAtSubscriptionTime, true, QoS, false))
        {
            return fprintf(stderr, "Failed subscribing to %s with error: %d\n", (const char*)subscribe, (int)ret);
        }
        printf("Subscribed to %s\nWaiting for messages...\n", (const char*)subscribe);

        // Then enter the event loop here
        signal(SIGINT, ctrlc);
        time_t last = time(NULL);
        while (cont)
        {
            if (Network::Client::MQTTv5::ErrorType ret = client.eventLoop())
                return fprintf(stderr, "Event loop failed with error: %d\n", (int)ret);

            // Is it time to publish ?
            if (time(NULL) - last >= 1) {
                if (Network::Client::MQTTv5::ErrorType ret = client.publish(publishTopic, publishMessage, strlen(publishMessage), false, QoS)) {
                  return fprintf(stderr, "Failed publishing %s to %s with error: %d\n", publishMessage, publishTopic, (int)ret);
              }
              printf("Published %s to %s\n", publishMessage, publishTopic);
              last = time(NULL);
           }
       }


        return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <ctime>
#include <signal.h>

// We need MQTT client
#include "Network/Clients/MQTT.hpp"
int echoCheck=0;
char* data; 
struct MessageReceiver : public Network::Client::MessageReceived
{
    void messageReceived(const Network::Client::MQTTv5::DynamicStringView& topic,
                         const Network::Client::MQTTv5::DynamicBinDataView& payload,
                         const uint16_t packetIdentifier,
                         const Network::Client::MQTTv5::PropertiesView& properties)
    {
        fprintf(stdout, "Msg received: (%04X)\n", packetIdentifier);
        fprintf(stdout, "  Topic: %.*s\n", topic.length, topic.data);
        fprintf(stdout, "  Payload: %.*s\n", payload.length, payload.data);
        echoCheck=1;
    }
};

Network::Client::MQTTv5::QoSDelivery QoS = Network::Client::MQTTv5::QoSDelivery::AtMostOne;

volatile bool cont = true;

void ctrlc(int sig)
{
    if (sig == SIGINT)
        cont = false;
}

int main(int argc, const char** argv)
{
    const char* server = "localhost";
    const uint16_t port = 1883;
    const char* username = "bob1";
    const char* password = "sponge1";
    const char* subscribe = "topic1";
    const char* publishTopic = "topic2";
    const char* clientID = "Client2";
    unsigned keepAlive = 300;

    MessageReceiver receiver;

    Network::Client::MQTTv5 client(clientID, &receiver);
    Network::Client::MQTTv5::DynamicBinDataView pw(strlen(password), (const uint8_t*)password);

    if (Network::Client::MQTTv5::ErrorType ret = client.connectTo(server, port, false,
                                                                  (uint16_t)std::min(65535U, keepAlive), true,
                                                                  username, &pw))
    {
        return fprintf(stderr, "Failed connection to %s with error: %d\n", server, (int)ret);
    }
    printf("Connected to %s\n", server);

    // Check if we have some subscription
    if (Network::Client::MQTTv5::ErrorType ret =
            client.subscribe(subscribe, Protocol::MQTT::V5::GetRetainedMessageAtSubscriptionTime, true, QoS, false))
    {
        return fprintf(stderr, "Failed subscribing to %s with error: %d\n", subscribe, (int)ret);
    }
    printf("Subscribed to %s\nWaiting for messages...\n", subscribe);

    // Then enter the event loop here
    signal(SIGINT, ctrlc);
    time_t lastPublishTime = time(NULL);

    while (cont)
    {
        if (Network::Client::MQTTv5::ErrorType ret = client.eventLoop())
            return fprintf(stderr, "Event loop failed with error: %d\n", (int)ret);

        // Check if it's time to publish (every second)
        time_t currentTime = time(NULL);
        if (echoCheck == 1)
        {
            // Convert current time to string format
            char timestamp[20];
            strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", localtime(&currentTime));

            // Publish the timestamp
            if (Network::Client::MQTTv5::ErrorType ret =
                    client.publish(publishTopic, (const uint8_t*)timestamp, strlen(timestamp), false, QoS))
            {
                return fprintf(stderr, "Failed publishing %s to %s with error: %d\n", timestamp, publishTopic,
                               (int)ret);
            }

            printf("Published %s to %s\n", timestamp, publishTopic);
            lastPublishTime = currentTime;
            echoCheck=0;
        }
    }

    return 0;
}

        /** The receiving data buffer */
        uint8               recvBuffer[YOUR MAX EXPECTED PACKET SIZE HERE IN BYTE];
        /** The receiving VBInt size for the packet header */
        uint8               packetExpectedVBSize;
        BaseSocket    _socket; 

        uint16 allocatePacketID()
        {
            return ++publishCurrentId;
        }

        Impl(const char * clientID, MessageReceived * callback, const DynamicBinDataView * brokerCert)
             : _socket(YOUR TIMEOUT HERE IN MS), socket(0), brokerCert(brokerCert), clientID(clientID), cb(callback), timeoutMs({3, 0}), lastCommunication(0), publishCurrentId(0), keepAlive(300),
#if MQTTUseUnsubscribe == 1        
               unsubscribeId(0), lastUnsubscribeError(ErrorType::WaitingForResult),
#endif
               recvState(Ready), recvBufferSize(max(callback->maxPacketSize(), 8U)), maxPacketSize(65535), available(0), packetExpectedVBSize(Protocol::MQTT::Common::VBInt(recvBufferSize).getSize())
        {}
        ~Impl() { }

[...And around line 858...]
        void close()
        {
            _socket.close();
            socket = 0;
        }

        bool isOpen()
        {
            return socket;
        }

        int send(const char * buffer, const int size) { return socket ? socket->send(buffer, size) : -1; }

        int connectWith(const char * host, const uint16 port, const bool withTLS)
        {
            if (isOpen()) return -1;
            socket = &_socket;
            return socket ? socket->connect(host, port, brokerCert) : -1;
        }