rtm.h

Go to the documentation of this file.

#ifndef CORE_RTM_H__INCLUDED
#define CORE_RTM_H__INCLUDED
#include <stddef.h>
#include <time.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <rtm_config.h>

#ifdef _WIN32
  #if !defined(__WINDOWS__)
    #define __WINDOWS__
  #endif
  #include <Winsock2.h>
  #include <BaseTsd.h>
  typedef SSIZE_T ssize_t;
#endif

#if defined(RTM_USE_GNUTLS)

#include <gnutls/gnutls.h>

#elif defined(RTM_USE_OPENSSL)

#include <openssl/conf.h>
#include <openssl/err.h>
#include <openssl/ssl.h>

#elif defined(RTM_USE_APPLE_SSL)

#include <Security/Security.h>
#include <Security/SecureTransport.h>

#endif


#if defined(rtm_core_sdk_EXPORTS) && defined(_WIN32)
#define RTM_API __declspec(dllexport)
#elif defined(_WIN32) && !defined(RTM_BUILD_STATIC)
#define RTM_API __declspec(dllimport)
#else
#define RTM_API
#endif

#if RTM_TEST_ENV
#define RTM_TEST_API RTM_API
#else
#define RTM_TEST_API
#endif

#define _RTM_SCRATCH_BUFFER_SIZE (256)
#define _RTM_WS_PRE_BUFFER 16

#define RTM_MAX_CHANNEL_SIZE (256)

#define RTM_MAX_MESSAGE_SIZE (65536)

#define RTM_PATH ("/v2")


#define RTM_MAX_ENDPOINT_SIZE (256)

#define RTM_MAX_APPKEY_SIZE (32)

#define RTM_MAX_ROLE_NAME_SIZE (512)

#define RTM_AUTHENTICATION_HASH_SIZE (24)

enum rtm_action_t {
    RTM_ACTION_UNKNOWN = 0,
    RTM_ACTION_AUTHENTICATE_ERROR,
    RTM_ACTION_AUTHENTICATE_OK,
    RTM_ACTION_DELETE_ERROR,
    RTM_ACTION_DELETE_OK,
    RTM_ACTION_GENERAL_ERROR,
    RTM_ACTION_HANDSHAKE_ERROR,
    RTM_ACTION_HANDSHAKE_OK,
    RTM_ACTION_PUBLISH_ERROR,
    RTM_ACTION_PUBLISH_OK,
    RTM_ACTION_READ_ERROR,
    RTM_ACTION_READ_OK,
    RTM_ACTION_SUBSCRIBE_ERROR,
    RTM_ACTION_SUBSCRIBE_OK,
    RTM_ACTION_SUBSCRIPTION_DATA,
    RTM_ACTION_SUBSCRIPTION_ERROR,
    RTM_ACTION_SUBSCRIPTION_INFO,
    RTM_ACTION_UNSUBSCRIBE_ERROR,
    RTM_ACTION_UNSUBSCRIBE_OK,
    RTM_ACTION_WRITE_ERROR,
    RTM_ACTION_WRITE_OK,
    RTM_ACTION_SENTINEL
};

typedef struct {
    char *position;
} rtm_list_iterator_t;

RTM_API char *rtm_iterate(rtm_list_iterator_t const *iterator);

typedef struct _rtm_pdu {
    unsigned request_id;
    enum rtm_action_t action;
    union {
        struct {
            union {
              char const *error;
              char const *info;
            };
            char const *reason;
        };
        struct {
            char const *position;
            char const *subscription_id;
            union {
                char const *message;
                rtm_list_iterator_t message_iterator;
            };
        };
        char const *body;
        char const *nonce;
    };
} rtm_pdu_t;

typedef struct rtm_client rtm_client_t;

typedef void(rtm_message_handler_t)(rtm_client_t *rtm, const char *subscription_id,
             const char *message);

typedef void(rtm_pdu_handler_t)(rtm_client_t *rtm, const rtm_pdu_t *pdu);
typedef void(rtm_raw_pdu_handler_t)(rtm_client_t *rtm, char const *raw_pdu);

typedef void(rtm_error_logger_t)(const char *message);

typedef enum {
    RTM_OK = 0,                   
    RTM_WOULD_BLOCK,              
    RTM_ERR_OOM = -100,           
    RTM_ERR_PARAM = -99,          
    RTM_ERR_PARAM_INVALID = -98,  
    RTM_ERR_CONNECT = -97,        
    RTM_ERR_NETWORK = -96,        
    RTM_ERR_CLOSED = -95,         
    RTM_ERR_READ = -94,           
    RTM_ERR_WRITE = -93,          
    RTM_ERR_PROTOCOL = -92,       
    RTM_ERR_TLS = -91,            
    RTM_ERR_TIMEOUT = -90         
} rtm_status;

RTM_API extern const size_t rtm_client_size;

RTM_API void rtm_set_error_logger(rtm_client_t *rtm, rtm_error_logger_t *error_logger);


typedef void *(rtm_malloc_fn_t)(rtm_client_t *rtm, size_t size);

typedef void (rtm_free_fn_t)(rtm_client_t *rtm, void *ptr);

RTM_API void *rtm_system_malloc(rtm_client_t *rtm, size_t size);

RTM_API void rtm_system_free(rtm_client_t *rtm, void *mem);

RTM_API void *rtm_null_malloc(rtm_client_t *rtm, size_t size);

RTM_API void rtm_null_free(rtm_client_t *rtm, void *mem);

RTM_API void rtm_set_allocator(rtm_client_t *rtm, rtm_malloc_fn_t *malloc_ptr, rtm_free_fn_t *free_ptr);

RTM_API void rtm_default_error_logger(const char *message);

RTM_API void rtm_default_message_handler(rtm_client_t *rtm, const char *channel,
                                 const char *message);

RTM_API void rtm_default_pdu_handler(rtm_client_t *rtm, const rtm_pdu_t *pdu);

RTM_API time_t rtm_get_ws_ping_interval(rtm_client_t *rtm);

RTM_API void rtm_set_connection_timeout(rtm_client_t *rtm, unsigned timeout_in_seconds);

RTM_API void rtm_set_ws_ping_interval(rtm_client_t *rtm, time_t ws_ping_interval);

RTM_API rtm_client_t *rtm_init(
  void *memory,
  rtm_pdu_handler_t *pdu_handler,
  void *user_context);

#define RTM_CLIENT_SIZE_WITH_BUFFERS(buffer_size) (sizeof(struct _rtm_client_priv) + _RTM_WS_PRE_BUFFER + 2*buffer_size)

#define RTM_CLIENT_SIZE (RTM_CLIENT_SIZE_WITH_BUFFERS(RTM_MAX_MESSAGE_SIZE))

RTM_API rtm_client_t *rtm_init_ex(
  void *memory,
  size_t memory_size,
  rtm_pdu_handler_t *pdu_handler,
  void *user_context);

RTM_API rtm_status rtm_connect(rtm_client_t *rtm,
                       const char *endpoint,
                       const char *appkey);

RTM_API rtm_status rtm_connect_via_https_proxy(
    rtm_client_t *rtm,
    char const *endpoint,
    char const *appkey,
    char const *proxy_endpoint);

RTM_API void rtm_set_raw_pdu_handler(rtm_client_t *rtm, rtm_raw_pdu_handler_t *handler);

RTM_API void rtm_enable_verbose_logging(rtm_client_t *rtm);

RTM_API void rtm_disable_verbose_logging(rtm_client_t *rtm);

RTM_API void rtm_close(rtm_client_t *rtm);

RTM_API rtm_status rtm_handshake(rtm_client_t *rtm,
                         const char *role, unsigned *ack_id);

RTM_API rtm_status rtm_authenticate(rtm_client_t *rtm, const char *role_secret, const char *nonce, unsigned *ack_id);



RTM_API rtm_status rtm_publish_json(rtm_client_t *rtm, const char *channel,
                            const char *json, unsigned *ack_id);

RTM_API rtm_status rtm_publish_string(rtm_client_t *rtm, const char *channel,
                              const char *string, unsigned *ack_id);

RTM_API rtm_status rtm_subscribe(rtm_client_t *rtm, const char *channel,
                         unsigned *ack_id);
RTM_API rtm_status rtm_subscribe_with_body(rtm_client_t *rtm, const char *body,
                                   unsigned *ack_id);

RTM_API rtm_status rtm_unsubscribe(rtm_client_t *rtm, const char *channel,
                           unsigned *ack_id);

RTM_API rtm_status rtm_parse_pdu(char *message, rtm_pdu_t *pdu);

RTM_API rtm_status rtm_read(rtm_client_t *rtm, const char *channel, unsigned *ack_id);

RTM_API rtm_status rtm_read_with_body(rtm_client_t *rtm, const char *body, unsigned *ack_id);

RTM_API rtm_status rtm_send_ws_ping(rtm_client_t *rtm);

RTM_API rtm_status rtm_write_string(rtm_client_t *rtm, const char *key, const char *string,
    unsigned *ack_id);

RTM_API rtm_status rtm_write_json(rtm_client_t *rtm, const char *key, const char *json,
    unsigned *ack_id);

RTM_API rtm_status rtm_delete(rtm_client_t *rtm, const char *key, unsigned *ack_id);

RTM_API rtm_status rtm_send_pdu(rtm_client_t *rtm, const char *json);

RTM_API rtm_status rtm_wait(rtm_client_t *rtm);

RTM_API rtm_status rtm_wait_timeout(rtm_client_t *rtm, int timeout_in_seconds);

RTM_API rtm_status rtm_poll(rtm_client_t *rtm);

RTM_API int rtm_get_fd(rtm_client_t *rtm);

RTM_API void *rtm_get_user_context(rtm_client_t *rtm);

RTM_API const char *rtm_error_string(rtm_status status);

struct _rtm_client_priv {

  void *user; 
  int fd; 
  size_t fragmented_message_length;

  size_t input_length;

  size_t skip_next_n_input_bytes;

  unsigned is_closed: 1; 
  unsigned is_used: 1; 
  unsigned is_verbose: 1; 
  unsigned skip_current_fragmented_message: 1;

  unsigned last_request_id; 
  unsigned last_ping_ts; 
  time_t ws_ping_interval; 
  unsigned is_secure: 1; 
  #if defined(RTM_USE_GNUTLS)
    gnutls_session_t session;
  #elif defined(RTM_USE_OPENSSL)
    SSL_CTX *ssl_context;
    SSL *ssl_connection;
  #elif defined(RTM_USE_APPLE_SSL)
    SSLContextRef sslContext;
  #endif

  unsigned connect_timeout; 
  rtm_pdu_handler_t *handle_pdu; 
  rtm_raw_pdu_handler_t *handle_raw_pdu; 
  rtm_error_logger_t *error_logger; 
  rtm_malloc_fn_t *malloc_fn; 
  rtm_free_fn_t *free_fn; 
  char scratch_buffer[_RTM_SCRATCH_BUFFER_SIZE];

  // The buffers are padded so we are always guaranteed to have
  // enough bytes to pre pad any buffer with websocket framing

  char *input_buffer;
  size_t input_buffer_size; 
  size_t output_buffer_size;
  char *output_buffer;

  size_t dynamic_input_buffer_size; 
  char *dynamic_input_buffer; 
};

struct rtm_client {
  struct _rtm_client_priv priv;
};


#ifdef __cplusplus
}
#endif

#endif // CORE_RTM_H__INCLUDED