sl4c.h

/*
 *
 *    Copyright CAPLIN Systems Ltd 2000-2010
 *
 *
 *    $Author: dominic $
 *    $DateTime: 2018/10/16 11:00:22 $
 *    $Change: 312033 $
 *    $Id: //CDev/V-7_0/streamlink/streamlink/include/sl4c.h#3 $
 *
 *
 */


#ifndef STREAMLINK_H
#define STREAMLINK_H


#include <inttypes.h>
#include <sys/types.h>
#include <stdarg.h>

#ifndef WIN32
#include <stdbool.h>
#else
typedef unsigned char bool;
#define false 0
#define true 1
#endif


#ifndef WIN32
#define SL_EXPORT 
#else
#ifndef SL_EXPORT
#define SL_EXPORT __declspec(dllimport)
#endif
#endif


typedef struct sl_s streamlink;
typedef struct sl_subscription_s    sl_subscription;

typedef struct sl_subscription_s    sl_command;

typedef enum {
    sl_LOG_FINEST = 1,   
    sl_LOG_FINER,        
    sl_LOG_DEBUG,        
    sl_LOG_INFO,         
    sl_LOG_NOTIFY,       
    sl_LOG_WARN,         
    sl_LOG_ERROR,        
    sl_LOG_CRITICAL,     
    sl_LOG_CONFIG        
} sl_loglevel;

typedef enum {
    sl_STATUS_OK = 0,    
    sl_STATUS_LIMITED,   
    sl_STATUS_STALE,     
    sl_STATUS_INFO       
} sl_subjectstatus;


typedef enum {
    sl_SERVICE_OK,   
    sl_SERVICE_LIMITED,
    sl_SERVICE_DOWN
} sl_servicestatus;


typedef enum {
    sl_SOURCE_AVAILABLE,
    sl_SOURCE_UNAVAILABLE
} sl_sourcestatus;


typedef enum {
    sl_ERROR_OK = 0,       
    sl_ERROR_NOTFOUND,     
    sl_ERROR_UNAVAILABLE,  
    sl_ERROR_DELETED,      
    sl_ERROR_READ_DENIED,  
    sl_ERROR_WRITE_DENIED,  
    sl_ERROR_INVALID_PARAMETERS, 
    sl_ERROR_THROTTLE_FAILED,     
    sl_ERROR_CANCELLED,     
    sl_ERROR_EXPIRED,
} sl_subjecterror;

typedef enum {
    sl_REASON_NONE = 0,   
    sl_REASON_USER1,      
    sl_REASON_USER2,      
    sl_REASON_USER3,      
    sl_REASON_USER4,      
    sl_REASON_USER5,      
    sl_REASON_LICENCE     
} sl_error_reason;

typedef enum {
    sl_CONN_DISCONNECTED = 1,  
    sl_CONN_CONNECTING,    
    sl_CONN_FAILED,        
    sl_CONN_CONNECTED,     
    sl_CONN_RETRIEVING_CREDENTIALS,  
    sl_CONN_CREDENTIALS_RETRIEVED,   
    sl_CONN_RETRIEVING_CREDENTIALS_FAILED,  
    sl_CONN_LOGGEDIN,      
    sl_CONN_LOGINFAILED,   
    sl_CONN_EJECTED,       
    sl_CONN_LOST,          
    sl_CONN_RECONNECTED,   
    sl_CONN_UNREACHABLE,  
} sl_connectionstatus;

typedef enum {
    sl_LOGINFAILED_INVALID_USER = 1,   
    sl_LOGINFAILED_INVALID_PASS,       
    sl_LOGINFAILED_INVALID_IP,         
    sl_LOGINFAILED_ACCT_EXPIRED,       
    sl_LOGINFAILED_ALREADY_LOGGED_IN,  
    sl_LOGINFAILED_LICENSE_SITE,       
    sl_LOGINFAILED_LICENSE_USER,       
    sl_LOGINFAILED_CREDENTIALSERROR    
} sl_loginfailed_reason;


typedef enum {
    sl_THROTTLE_UP = 0,  
    sl_THROTTLE_DOWN,    
    sl_THROTTLE_MIN,     
    sl_THROTTLE_MAX,     
    sl_THROTTLE_STOP,    
    sl_THROTTLE_START,   
    sl_THROTTLE_DEF      
} sl_throttlecontrol;

typedef enum {
    sl_PERSISTENT_NONE,  
    sl_PERSISTENT_BEFORE, 
    sl_PERSISTENT_AFTER,  
    sl_PERSISTENT_CANCEL, 
    sl_PERSISTENT_TIMED,  
} sl_command_persistence;

typedef struct {
    char   *name;          
    char   *value;         
} sl_field;

typedef struct {
    int          num;      
    sl_field    *fields;   
    int          fields_alloc_size;  
    /* TODO: Add in fields for SYNC offset/latency */
} sl_fieldlist;

typedef enum {
    sl_subjecttype_UNKNOWN = 200,
    sl_subjecttype_DIRECTORY = 220,
    sl_subjecttype_PAGE = 221,
    sl_subjecttype_RECORD = 222,
    sl_subjecttype_NEWS = 223,
    sl_subjecttype_STORY = 224,
    sl_subjecttype_RECORD2 = 225,
    sl_subjecttype_RECORD3 = 226,
    sl_subjecttype_CHAT = 227,
    sl_subjecttype_CONTAINER = 228,
    sl_subjecttype_PERMISSION = 230
} sl_subjecttype;

typedef struct sl_autoelem_s sl_autoelem;

struct sl_autoelem_s {
    sl_autoelem      *next;              
    char             *subject;             
    sl_subjecttype       type;              
    int               position;          
#ifdef BUILD_API
    /* Private below here - TODO: Sort this out properly */
    int            object_number;     
    UT_hash_handle hh;                
#endif
};

typedef struct {
    void  (*clear)(void *context);     
    void  (*insert)(void *context, int index, sl_autoelem *elem); 
    void  (*remove)(void *context, int index, sl_autoelem *elem);
    void  (*move)(void *context, int from, int to, sl_autoelem *elem);
} sl_container_model;

typedef enum {
    ACTION_CLEAR,
    ACTION_INSERT,
    ACTION_REMOVE,
    ACTION_MOVE
} sl_container_action_type;

typedef struct  {
    sl_container_action_type   type;    
    sl_autoelem               *elem;    
    int                        from;    
    int                        to;      
} sl_container_action;





typedef struct {
    int             size;             
    sl_autoelem    *added;            
    sl_autoelem    *removed;          
    sl_autoelem   **order;            
    int             changed_order_size; 
    sl_autoelem   **changed_order;      
    int             num_actions;      
    sl_container_action *actions;    
#ifdef BUILD_API
    int             ctrstart;         
    int             ctrend;           
#endif
} sl_container_event;

SL_EXPORT void        sl_container_apply_to_model(sl_container_event *ev, sl_container_model *model, void *context);


typedef enum {
    action_UPDATE,
    action_DELETE,
    action_CLEAR
} sl_update_action;


typedef struct {
    sl_autoelem     *added;    
    sl_autoelem     *removed;  
} sl_directory_event;

typedef struct {
    sl_update_action      action;     
    char                 *key;        
    sl_fieldlist         *fields;     
} sl_permission_event;

typedef struct {
    sl_update_action      action;     
    char                 *keyfield;   
    sl_fieldlist         *fields;     
} sl_record2_event;

typedef struct {
    sl_update_action      action;    
    sl_fieldlist         *fields;    
} sl_record3_event;


typedef struct {
    int          x;             
    int          y;             
    char        *value;         
} sl_page_segment;

typedef struct {
    int               maxx;     
    int               maxy;     
    int               num_segments;   
    sl_page_segment  *page_segments;  
} sl_page_event;

typedef struct {
    char             *headline;    
    char             *date;        
    char             *storycode;   
    sl_fieldlist     *fields;     
} sl_news_event;

typedef struct {
    char             *text;       
} sl_story_event;

typedef enum {
    sl_chat_MESSAGE = 0,       
    sl_chat_USER_ADDED = 1,    
    sl_chat_USER_REMOVED = 2,  
    sl_chat_JOINED = 3         
} sl_chat_update_type;

typedef struct {
    sl_chat_update_type   type;      
    char                 *user;      
    char                 *time;      
    char                 *message;   
} sl_chat_event;



typedef struct sl_subscription_parameters_s sl_subscription_parameters;


typedef struct {
    void       (*record_updated)(streamlink *client, void *ctx, const char *subject, sl_fieldlist *fields, char isimage);


    void       (*record_type2_updated)(streamlink *client, void *ctx, const char *subject, sl_record2_event *event, char isimage);

    void       (*record_type3_updated)(streamlink *client, void *ctx, const char *subject, sl_record3_event *event, char isimage);


    void       (*page_updated)(streamlink *client, void *ctx, const char *subject, sl_page_event *event, char isimage);

    void       (*news_updated)(streamlink *client, void *ctx, const char *subject, sl_news_event *event, char isimage);

    void       (*story_updated)(streamlink *client, void *ctx, const char *subject, sl_story_event *event, char isimage);


    void       (*permission_updated)(streamlink *client, void *ctx, const char *subject, sl_permission_event *event, char isimage);

    void       (*container_updated)(streamlink *client, void *ctx, const char *subject, sl_container_event *event, char isimage);

    void       (*directory_updated)(streamlink *client, void *ctx, const char *subject, sl_directory_event *event, char isimage);


    void       (*chat_updated)(streamlink *client, void *ctx, const char *subject, sl_chat_event *event, char isimage);

    void       (*error)(streamlink *client, void *ctx, const char *subject, sl_subjecterror error, sl_error_reason reason);
    void       (*status)(streamlink *client, void *ctx, const char *subject, sl_subjectstatus status, sl_fieldlist *fields);
} sl_subjectlistener;

typedef struct {
    void       (*ok)(streamlink *client, void *ctx, const char *subject);
    void       (*error)(streamlink *client, void *ctx, const char *subject, sl_subjecterror error, sl_error_reason reason);
} sl_commandlistener;


#define SL_UNDEFINED_STATISTIC  -1

typedef struct {
    int      noop_last_roundtrip;   
    int      time_since_last_call;  
    uint64_t bytes_written_last;    
    uint64_t bytes_written;
    uint64_t bytes_read_last;
    uint64_t bytes_read;
    int      latency;               
    int      average_latency;       
    int      clock_offset;          
} sl_statistics;




typedef struct {
    void       (*status)(streamlink *client, void *ctx, const char *server_uri, sl_connectionstatus status, intptr_t extra);

    void       (*source_status)(streamlink *client, void *context, const char *server_uri, const char *sourcename, sl_sourcestatus status);
    void       (*service_status)(streamlink *client, void *context, const char *server_uri, const char *servicename, sl_servicestatus status);

    void       (*statistics)(streamlink *client, void *context, sl_statistics *statistics);
} sl_connectionlistener;


typedef struct {
    int     connect_timeout;    
    int     read_timeout;       
    int     write_timeout;      
    int     noop_period;        
    int     noop_timeout;       
    int     lost_retry_connect_time;  
    int     statistics_period;  
    int     login_wait_time;    
    int     sync_period;     
    int     sync_timeout;

    int     heartbeat_interval; 
    int     poll_interval;     
    char    disable_polling;   
    char    accept_all_ssl_certificates; 
    int     inactivity_timeout;  
    int     http_pad_length;     
} sl_configuration;



typedef struct {
    char      *username;     
    char      *password;     
} sl_credentials;


typedef struct sl_credentialsprovider_s sl_credentialsprovider;

struct sl_credentialsprovider_s {
    void              (*dealloc)(sl_credentialsprovider *provider);         
  
    sl_credentials   *(*get_credentials)(streamlink *client, sl_credentialsprovider *provider);
    void              (*free_credentials)(sl_credentialsprovider *provider, sl_credentials *credentials);
    void               *context;
};


SL_EXPORT sl_credentialsprovider     *sl_create_password_credentialsprovider(const char *username, const char *password);
SL_EXPORT sl_credentialsprovider     *sl_create_keymaster_credentialsprovider(const char *keymaster_uri, const char *streamlink_user, const char *auth_user, const char *auth_pass);



SL_EXPORT sl_subscription_parameters *sl_create_container_parameters(streamlink *client, int window_start, int window_size, sl_subscription_parameters *constituent_parameters);
SL_EXPORT sl_subscription_parameters *sl_create_record_parameters(streamlink *client, char is_image_filter, const char *filter, int num_fields, const char **fields);
SL_EXPORT sl_subscription_parameters *sl_create_text_parameters(streamlink *client, const char *parameters);
SL_EXPORT sl_subscription_parameters *sl_create_extended_container_parameters(streamlink *client, int window_start, int window_size, sl_subscription_parameters *constituent_parameters, const char *where, const char *sort, const char *groupby, bool structure_only, bool keep_inaccessible);


typedef void (*sl_log_cb)(void *ctx, sl_loglevel level, const char *message);



SL_EXPORT streamlink      *sl_new(const char *uri, sl_credentialsprovider *credentials_provider);
SL_EXPORT void             sl_config_defaults(sl_configuration *config);
SL_EXPORT sl_configuration *sl_get_configuration(streamlink *client);
SL_EXPORT const char       *sl_get_reachability_address(streamlink *client);
SL_EXPORT void             sl_set_applicationid(streamlink *client, const char *applicationid);
SL_EXPORT void             sl_dealloc(streamlink *client);
SL_EXPORT void             sl_connect(streamlink *client);
SL_EXPORT void             sl_set_reachability(streamlink *client, int reachable);
SL_EXPORT void             sl_add_connection_listener(streamlink *client, sl_connectionlistener *listener, void *ctx);
SL_EXPORT void             sl_del_connection_listener(streamlink *client, sl_connectionlistener *listener);
SL_EXPORT void             sl_disconnect(streamlink *client);
SL_EXPORT void             sl_snapshot(streamlink *client, const char *subject, sl_subscription_parameters *params, sl_subjectlistener *listener, void *ctx);
SL_EXPORT sl_subscription *sl_subscribe(streamlink *client, const char *subject, sl_subscription_parameters *params, sl_subjectlistener *listener, void *ctx);
SL_EXPORT void             sl_unsubscribe(streamlink *client, sl_subscription *sub);
SL_EXPORT int              sl_subscription_setwindow(streamlink *client, sl_subscription *sub, sl_subscription_parameters *params);
SL_EXPORT sl_command      *sl_publish(streamlink *client,const char *subject, sl_fieldlist *fields, sl_commandlistener *listener, void *ctx);
SL_EXPORT sl_command      *sl_publish_bytime(streamlink *client,const char *subject, time_t bytime,  sl_fieldlist *fields, sl_commandlistener *listener, void *ctx);
SL_EXPORT void             sl_create(streamlink *client, const char *subject, sl_subjecttype type, sl_commandlistener *listener, void *ctx);
SL_EXPORT void             sl_delete(streamlink *client, const char *subject, sl_commandlistener *listener, void *ctx);
SL_EXPORT void             sl_throttle_subject(streamlink *client, const char *subject, sl_throttlecontrol command, sl_commandlistener *listener, void *ctx);
SL_EXPORT void             sl_throttle_global(streamlink *client,  sl_throttlecontrol command, sl_commandlistener *listener, void *ctx);

SL_EXPORT sl_command      *sl_publish_persist(streamlink *client,const char *subject, sl_command_persistence persist_mode, sl_fieldlist *fields, sl_commandlistener *listener, void *ctx);
SL_EXPORT void             sl_cancel_persistence(streamlink *client, sl_command *sub);
SL_EXPORT const char      *sl_get_name(streamlink *client);
SL_EXPORT int              sl_get_serviceurl(streamlink *client, const char *service_name, sl_fieldlist *user_params, char **url_ptr, char **body_ptr);


SL_EXPORT sl_connectionstatus sl_get_connectionstatus(streamlink *client);


SL_EXPORT sl_fieldlist    *sl_fieldlist_new(void);
SL_EXPORT void             sl_fieldlist_add(sl_fieldlist *list, const char *name, const char *value);
SL_EXPORT void             sl_fieldlist_delete(sl_fieldlist *list);
SL_EXPORT const char      *sl_fieldlist_find(sl_fieldlist *list, const char *name);
SL_EXPORT char            *sl_fieldlist_tostring(sl_fieldlist *fieldlist, char *buf, size_t buflen);


SL_EXPORT const char      *sl_get_connectionstatusstring(sl_connectionstatus status);
SL_EXPORT const char      *sl_get_logstring(sl_loglevel level);

SL_EXPORT const char      *sl_get_servicestatusstring(sl_servicestatus status);
SL_EXPORT const char      *sl_get_sourcestatusstring(sl_sourcestatus status);
SL_EXPORT const char      *sl_get_subjecttypestring(sl_subjecttype type);
SL_EXPORT const char      *sl_get_subjecterrorstring(sl_subjecterror error);
SL_EXPORT const char      *sl_get_subjectstatusstring(sl_subjectstatus status);
SL_EXPORT const char      *sl_get_loginfailedstring(sl_loginfailed_reason status);
SL_EXPORT const char      *sl_get_errorreasonstring(sl_error_reason status);

#ifdef HAVE_OPENSSL
SL_EXPORT void             sl_set_trust_manager(streamlink *client, int (*manager)(void *ctx, SSL *ssl), void *ctx);
#else
SL_EXPORT void             sl_set_trust_manager(streamlink *client, int (*manager)(void *ctx, void *trust), void *ctx);
#endif


SL_EXPORT void             sl_log(streamlink *client, sl_loglevel level, const char *fmt, ...);
SL_EXPORT void             sl_set_log_callback(streamlink *client, sl_log_cb callback, void *ctx);

SL_EXPORT void             sl_set_allocator(void *(*malloc_func)(size_t size), void *(*realloc_func)(void *orig, size_t size), void (*free_func)(void *));
SL_EXPORT void            *sl_malloc(size_t size);
SL_EXPORT void            *sl_realloc(void *orig, size_t size);
SL_EXPORT void             sl_free(void *);
SL_EXPORT char            *sl_strdup(const char *orig);
SL_EXPORT void            *sl_calloc(size_t nmemb, size_t size);




#endif