asymcute.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2018 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
#include "assert.h"
#include "event/timeout.h"
#include "event/callback.h"
#include "net/mqttsn.h"
#include "net/sock/udp.h"
#include "net/sock/util.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef CONFIG_ASYMCUTE_DEFAULT_PORT
#define CONFIG_ASYMCUTE_DEFAULT_PORT    (1883U)
#endif
 
#ifndef CONFIG_ASYMCUTE_BUFSIZE
#define CONFIG_ASYMCUTE_BUFSIZE         (128U)
#endif
 
#ifndef CONFIG_ASYMCUTE_TOPIC_MAXLEN
#define CONFIG_ASYMCUTE_TOPIC_MAXLEN    (32U)
#endif
 
#ifndef CONFIG_ASYMCUTE_KEEPALIVE
#define CONFIG_ASYMCUTE_KEEPALIVE       (360)
#endif
 
#ifndef CONFIG_ASYMCUTE_KEEPALIVE_PING
#define CONFIG_ASYMCUTE_KEEPALIVE_PING  ((CONFIG_ASYMCUTE_KEEPALIVE / 4) * 3)
#endif
 
#ifndef CONFIG_ASYMCUTE_T_RETRY
#define CONFIG_ASYMCUTE_T_RETRY         (10U)
#endif
 
#ifndef CONFIG_ASYMCUTE_N_RETRY
#define CONFIG_ASYMCUTE_N_RETRY         (3U)
#endif
#ifndef ASYMCUTE_HANDLER_PRIO
#define ASYMCUTE_HANDLER_PRIO           (THREAD_PRIORITY_MAIN - 2)
#endif
 
#ifndef ASYMCUTE_HANDLER_STACKSIZE
#define ASYMCUTE_HANDLER_STACKSIZE      (THREAD_STACKSIZE_DEFAULT)
#endif
 
enum {
    ASYMCUTE_OK         =  0,       
    ASYMCUTE_OVERFLOW   = -1,       
    ASYMCUTE_GWERR      = -2,       
    ASYMCUTE_NOTSUP     = -3,       
    ASYMCUTE_BUSY       = -4,       
    ASYMCUTE_REGERR     = -5,       
    ASYMCUTE_SUBERR     = -6,       
    ASYMCUTE_SENDERR    = -7,       
};
 
enum {
    ASYMCUTE_TIMEOUT,               
    ASYMCUTE_CANCELED,              
    ASYMCUTE_REJECTED,              
    ASYMCUTE_CONNECTED,             
    ASYMCUTE_DISCONNECTED,          
    ASYMCUTE_REGISTERED,            
    ASYMCUTE_PUBLISHED,             
    ASYMCUTE_SUBSCRIBED,            
    ASYMCUTE_UNSUBSCRIBED,          
};
 
typedef struct asymcute_con asymcute_con_t;
 
typedef struct asymcute_req asymcute_req_t;
 
typedef struct asymcute_sub asymcute_sub_t;
 
typedef struct asymcute_topic asymcute_topic_t;
 
typedef struct asymcute_will asymcute_will_t;
 
typedef void(*asymcute_evt_cb_t)(asymcute_req_t *req, unsigned evt_type);
 
typedef void(*asymcute_sub_cb_t)(const asymcute_sub_t *sub, unsigned evt_type,
                                 const void *data, size_t len, void *arg);
 
typedef unsigned(*asymcute_to_cb_t)(asymcute_con_t *con, asymcute_req_t *req);
 
struct asymcute_req {
    mutex_t lock;                   
    struct asymcute_req *next;      
    asymcute_con_t *con;            
    asymcute_to_cb_t cb;            
    void *arg;                      
    event_callback_t to_evt;        
    event_timeout_t to_timer;       
    uint8_t data[CONFIG_ASYMCUTE_BUFSIZE]; 
    size_t data_len;                
    uint16_t msg_id;                
    uint8_t retry_cnt;              
};
 
struct asymcute_con {
    mutex_t lock;                       
    sock_udp_t sock;                    
    asymcute_req_t *pending;            
    asymcute_sub_t *subscriptions;      
    asymcute_evt_cb_t user_cb;          
    event_callback_t keepalive_evt;     
    event_timeout_t keepalive_timer;    
    uint16_t last_id;                   
    uint8_t keepalive_retry_cnt;        
    uint8_t state;                      
    uint8_t rxbuf[CONFIG_ASYMCUTE_BUFSIZE];    
    char cli_id[MQTTSN_CLI_ID_MAXLEN + 1];  
};
 
struct asymcute_topic {
    asymcute_con_t *con;        
    char name[CONFIG_ASYMCUTE_TOPIC_MAXLEN + 1];   
    uint8_t flags;              
    uint16_t id;                
};
 
struct asymcute_sub {
    asymcute_sub_t *next;       
    asymcute_topic_t *topic;    
    asymcute_sub_cb_t cb;       
    void *arg;                  
};
 
struct asymcute_will {
    const char *topic;          
    void *msg;                  
    size_t msg_len;             
};
 
static inline bool asymcute_req_in_use(const asymcute_req_t *req)
{
    assert(req);
    return (req->con != NULL);
}
 
static inline bool asymcute_sub_active(const asymcute_sub_t *sub)
{
    assert(sub);
    return (sub->topic != NULL);
}
 
static inline void asymcute_topic_reset(asymcute_topic_t *topic)
{
    assert(topic);
    memset(topic, 0, sizeof(asymcute_topic_t));
}
 
static inline bool asymcute_topic_is_reg(const asymcute_topic_t *topic)
{
    assert(topic);
    return (topic->con != NULL);
}
 
static inline bool asymcute_topic_is_short(const asymcute_topic_t *topic)
{
    assert(topic);
    return ((topic->flags & MQTTSN_TIT_SHORT) != 0);
}
 
static inline bool asymcute_topic_is_predef(const asymcute_topic_t *topic)
{
    assert(topic);
    return ((topic->flags & MQTTSN_TIT_PREDEF) != 0);
}
 
static inline bool asymcute_topic_is_init(const asymcute_topic_t *topic)
{
    assert(topic);
    return (topic->name[0] != '\0');
}
 
static inline bool asymcute_topic_equal(const asymcute_topic_t *a,
                                        const asymcute_topic_t *b)
{
    assert(a);
    assert(b);
 
    return ((a->flags == b->flags) && (a->id == b->id));
}
 
int asymcute_topic_init(asymcute_topic_t *topic, const char *topic_name,
                        uint16_t topic_id);
 
void asymcute_handler_run(void);
 
bool asymcute_is_connected(const asymcute_con_t *con);
 
int asymcute_connect(asymcute_con_t *con, asymcute_req_t *req,
                     sock_udp_ep_t *server, const char *cli_id, bool clean,
                     asymcute_will_t *will, asymcute_evt_cb_t callback);
 
int asymcute_disconnect(asymcute_con_t *con, asymcute_req_t *req);
 
int asymcute_register(asymcute_con_t *con, asymcute_req_t *req,
                      asymcute_topic_t *topic);
 
int asymcute_publish(asymcute_con_t *con, asymcute_req_t *req,
                     const asymcute_topic_t *topic,
                     const void *data, size_t data_len, uint8_t flags);
 
int asymcute_subscribe(asymcute_con_t *con, asymcute_req_t *req,
                       asymcute_sub_t *sub, asymcute_topic_t *topic,
                       asymcute_sub_cb_t callback, void *arg, uint8_t flags);
 
int asymcute_unsubscribe(asymcute_con_t *con, asymcute_req_t *req,
                         asymcute_sub_t *sub);
 
#ifdef __cplusplus
}
#endif