sysrepo.h

Go to the documentation of this file.

 
#ifndef _SYSREPO_H
#define _SYSREPO_H
 
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>
#ifdef __APPLE__
    #include <sys/types.h>
#endif
 
#include <libyang/libyang.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Logging API
 
typedef enum sr_error_e {
    SR_ERR_OK = 0,             
    SR_ERR_INVAL_ARG,          
    SR_ERR_LY,                 
    SR_ERR_SYS,                
    SR_ERR_NOMEM,              
    SR_ERR_NOT_FOUND,          
    SR_ERR_EXISTS,             
    SR_ERR_INTERNAL,           
    SR_ERR_UNSUPPORTED,        
    SR_ERR_VALIDATION_FAILED,  
    SR_ERR_OPERATION_FAILED,   
    SR_ERR_UNAUTHORIZED,       
    SR_ERR_LOCKED,             
    SR_ERR_TIME_OUT,           
    SR_ERR_CALLBACK_FAILED,    
    SR_ERR_CALLBACK_SHELVE     
} sr_error_t;
 
const char *sr_strerror(int err_code);
 
typedef enum {
    SR_LL_NONE = 0,  
    SR_LL_ERR,       
    SR_LL_WRN,       
    SR_LL_INF,       
    SR_LL_DBG        
} sr_log_level_t;
 
void sr_log_stderr(sr_log_level_t log_level);
 
sr_log_level_t sr_log_get_stderr(void);
 
void sr_log_syslog(const char *app_name, sr_log_level_t log_level);
 
sr_log_level_t sr_log_get_syslog(void);
 
typedef void (*sr_log_cb)(sr_log_level_t level, const char *message);
 
void sr_log_set_cb(sr_log_cb log_callback);
 
// Connection / Session Management
 
typedef struct sr_conn_ctx_s sr_conn_ctx_t;
 
typedef struct sr_session_ctx_s sr_session_ctx_t;
 
typedef enum sr_conn_flag_e {
    SR_CONN_DEFAULT = 0,            
    SR_CONN_CACHE_RUNNING = 1,      
    SR_CONN_NO_SCHED_CHANGES = 2,   
    SR_CONN_ERR_ON_SCHED_FAIL = 4   
} sr_conn_flag_t;
 
typedef uint32_t sr_conn_options_t;
 
typedef enum sr_datastore_e {
    SR_DS_STARTUP = 0,     
    SR_DS_RUNNING = 1,     
    SR_DS_CANDIDATE = 2,   
    SR_DS_OPERATIONAL = 3  
} sr_datastore_t;
 
typedef struct sr_error_info_msg_s {
    char *message; 
    char *xpath;   
} sr_error_info_msg_t;
 
typedef struct sr_error_info_s {
    sr_error_t err_code; 
    sr_error_info_msg_t *err; 
    size_t err_count;    
} sr_error_info_t;
 
int sr_connect(const sr_conn_options_t opts, sr_conn_ctx_t **conn);
 
int sr_disconnect(sr_conn_ctx_t *conn);
 
int sr_connection_count(uint32_t *conn_count);
 
const struct ly_ctx *sr_get_context(sr_conn_ctx_t *conn);
 
typedef int (*sr_diff_check_cb)(sr_session_ctx_t *session, const struct lyd_node *diff);
 
void sr_set_diff_check_callback(sr_conn_ctx_t *conn, sr_diff_check_cb callback);
 
int sr_session_start(sr_conn_ctx_t *conn, const sr_datastore_t datastore, sr_session_ctx_t **session);
 
int sr_session_stop(sr_session_ctx_t *session);
 
int sr_session_notif_buffer(sr_session_ctx_t *session);
 
int sr_session_switch_ds(sr_session_ctx_t *session, sr_datastore_t ds);
 
sr_datastore_t sr_session_get_ds(sr_session_ctx_t *session);
 
int sr_get_error(sr_session_ctx_t *session, const sr_error_info_t **error_info);
 
int sr_set_error(sr_session_ctx_t *session, const char *path, const char *format, ...);
 
uint32_t sr_session_get_id(sr_session_ctx_t *session);
 
uint32_t sr_session_get_event_sr_id(sr_session_ctx_t *session);
 
void sr_session_set_nc_id(sr_session_ctx_t *session, uint32_t nc_sid);
 
uint32_t sr_session_get_nc_id(sr_session_ctx_t *session);
 
uint32_t sr_session_get_event_nc_id(sr_session_ctx_t *session);
 
int sr_session_set_user(sr_session_ctx_t *session, const char *user);
 
const char *sr_session_get_user(sr_session_ctx_t *session);
 
const char *sr_session_get_event_user(sr_session_ctx_t *session);
 
sr_conn_ctx_t *sr_session_get_connection(sr_session_ctx_t *session);
 
// Schema Manipulation API
 
const char *sr_get_repo_path(void);
 
int sr_install_module(sr_conn_ctx_t *conn, const char *schema_path, const char *search_dirs, const char **features,
        int feat_count);
 
int sr_install_module_data(sr_conn_ctx_t *conn, const char *module_name, const char *data, const char *data_path,
        LYD_FORMAT format);
 
int sr_remove_module(sr_conn_ctx_t *conn, const char *module_name);
 
int sr_update_module(sr_conn_ctx_t *conn, const char *schema_path, const char *search_dirs);
 
int sr_cancel_update_module(sr_conn_ctx_t *conn, const char *module_name);
 
int sr_set_module_replay_support(sr_conn_ctx_t *conn, const char *module_name, int replay_support);
 
int sr_set_module_access(sr_conn_ctx_t *conn, const char *module_name, const char *owner, const char *group, mode_t perm);
 
int sr_get_module_access(sr_conn_ctx_t *conn, const char *module_name, char **owner, char **group, mode_t *perm);
 
int sr_enable_module_feature(sr_conn_ctx_t *conn, const char *module_name, const char *feature_name);
 
int sr_disable_module_feature(sr_conn_ctx_t *conn, const char *module_name, const char *feature_name);
 
int sr_get_module_info(sr_conn_ctx_t *conn, struct lyd_node **sysrepo_data);
 
// Data Retrieval API (get / get-config functionality)
 
typedef enum sr_type_e {
    /* special types that does not contain any data */
    SR_UNKNOWN_T,              
    SR_LIST_T,                 
    SR_CONTAINER_T,            
    SR_CONTAINER_PRESENCE_T,   
    SR_LEAF_EMPTY_T,           
    SR_NOTIFICATION_T,         
    /* types containing some data */
    SR_BINARY_T,       
    SR_BITS_T,         
    SR_BOOL_T,         
    SR_DECIMAL64_T,    
    SR_ENUM_T,         
    SR_IDENTITYREF_T,  
    SR_INSTANCEID_T,   
    SR_INT8_T,         
    SR_INT16_T,        
    SR_INT32_T,        
    SR_INT64_T,        
    SR_STRING_T,       
    SR_UINT8_T,        
    SR_UINT16_T,       
    SR_UINT32_T,       
    SR_UINT64_T,       
    SR_ANYXML_T,       
    SR_ANYDATA_T       
} sr_type_t;
 
typedef union sr_data_u {
    char *binary_val;       
    char *bits_val;         
    bool bool_val;          
    double decimal64_val;   
    char *enum_val;         
    char *identityref_val;  
    char *instanceid_val;   
    int8_t int8_val;        
    int16_t int16_val;      
    int32_t int32_val;      
    int64_t int64_val;      
    char *string_val;       
    uint8_t uint8_val;      
    uint16_t uint16_val;    
    uint32_t uint32_val;    
    uint64_t uint64_val;    
    char *anyxml_val;       
    char *anydata_val;      
} sr_data_t;
 
typedef struct sr_val_s {
    char *xpath;
 
    sr_type_t type;
 
    bool dflt;
 
    char *origin;
 
    sr_data_t data;
 
} sr_val_t;
 
typedef enum sr_get_oper_flag_e {
    SR_OPER_DEFAULT = 0,             
    SR_OPER_NO_STATE = 1,            
    SR_OPER_NO_CONFIG = 2,           
    SR_OPER_NO_SUBS = 4,             
    SR_OPER_NO_STORED = 8,           
    SR_OPER_WITH_ORIGIN = 16         
} sr_get_oper_flag_t;
 
typedef uint32_t sr_get_oper_options_t;
 
int sr_get_item(sr_session_ctx_t *session, const char *path, uint32_t timeout_ms, sr_val_t **value);
 
int sr_get_items(sr_session_ctx_t *session, const char *xpath, uint32_t timeout_ms, const sr_get_oper_options_t opts,
        sr_val_t **values, size_t *value_cnt);
 
int sr_get_subtree(sr_session_ctx_t *session, const char *path, uint32_t timeout_ms, struct lyd_node **subtree);
 
int sr_get_data(sr_session_ctx_t *session, const char *xpath, uint32_t max_depth, uint32_t timeout_ms,
        const sr_get_oper_options_t opts, struct lyd_node **data);
 
void sr_free_val(sr_val_t *value);
 
void sr_free_values(sr_val_t *values, size_t count);
 
// Data Manipulation API (edit-config functionality)
 
typedef enum sr_edit_flag_e {
    SR_EDIT_DEFAULT = 0,        
    SR_EDIT_NON_RECURSIVE = 1,  
    SR_EDIT_STRICT = 2,         
    SR_EDIT_ISOLATE = 4         
} sr_edit_flag_t;
 
typedef uint32_t sr_edit_options_t;
 
typedef enum sr_move_position_e {
    SR_MOVE_BEFORE = 0,    
    SR_MOVE_AFTER = 1,     
    SR_MOVE_FIRST = 2,     
    SR_MOVE_LAST = 3       
} sr_move_position_t;
 
int sr_set_item(sr_session_ctx_t *session, const char *path, const sr_val_t *value, const sr_edit_options_t opts);
 
int sr_set_item_str(sr_session_ctx_t *session, const char *path, const char *value, const char *origin,
        const sr_edit_options_t opts);
 
int sr_delete_item(sr_session_ctx_t *session, const char *path, const sr_edit_options_t opts);
 
int sr_move_item(sr_session_ctx_t *session, const char *path, const sr_move_position_t position, const char *list_keys,
        const char *leaflist_value, const char *origin, const sr_edit_options_t opts);
 
int sr_edit_batch(sr_session_ctx_t *session, const struct lyd_node *edit, const char *default_operation);
 
int sr_validate(sr_session_ctx_t *session, const char *module_name, uint32_t timeout_ms);
 
int sr_apply_changes(sr_session_ctx_t *session, uint32_t timeout_ms, int wait);
 
int sr_has_changes(sr_session_ctx_t *session);
 
int sr_discard_changes(sr_session_ctx_t *session);
 
int sr_replace_config(sr_session_ctx_t *session, const char *module_name, struct lyd_node *src_config,
        uint32_t timeout_ms, int wait);
 
int sr_copy_config(sr_session_ctx_t *session, const char *module_name, sr_datastore_t src_datastore, uint32_t timeout_ms,
        int wait);
 
// Locking API
 
int sr_lock(sr_session_ctx_t *session, const char *module_name);
 
int sr_unlock(sr_session_ctx_t *session, const char *module_name);
 
int sr_get_lock(sr_conn_ctx_t *conn, sr_datastore_t datastore, const char *module_name, int *is_locked, uint32_t *id,
        uint32_t *nc_id, time_t *timestamp);
 
// Subscription API
 
typedef enum sr_subscr_flag_e {
    SR_SUBSCR_DEFAULT = 0,
 
    SR_SUBSCR_CTX_REUSE = 1,
 
    SR_SUBSCR_NO_THREAD = 2,
 
    SR_SUBSCR_PASSIVE = 4,
 
    SR_SUBSCR_DONE_ONLY = 8,
 
    SR_SUBSCR_ENABLED = 16,
 
    SR_SUBSCR_UPDATE = 32,
 
    SR_SUBSCR_UNLOCKED = 64,
 
    SR_SUBSCR_OPER_MERGE = 128
 
} sr_subscr_flag_t;
 
typedef struct sr_subscription_ctx_s sr_subscription_ctx_t;
 
typedef uint32_t sr_subscr_options_t;
 
int sr_get_event_pipe(sr_subscription_ctx_t *subscription, int *event_pipe);
 
int sr_process_events(sr_subscription_ctx_t *subscription, sr_session_ctx_t *session, time_t *stop_time_in);
 
int sr_unsubscribe(sr_subscription_ctx_t *subscription);
 
// Change Subscriptions API
 
typedef enum sr_event_e {
    SR_EV_UPDATE,  
    SR_EV_CHANGE,  
    SR_EV_DONE,    
    SR_EV_ABORT,   
    SR_EV_ENABLED, 
    SR_EV_RPC      
} sr_event_t;
 
typedef enum sr_change_oper_e {
    SR_OP_CREATED,   
    SR_OP_MODIFIED,  
    SR_OP_DELETED,   
    SR_OP_MOVED      
} sr_change_oper_t;
 
typedef struct sr_change_iter_s sr_change_iter_t;
 
typedef int (*sr_module_change_cb)(sr_session_ctx_t *session, const char *module_name, const char *xpath,
        sr_event_t event, uint32_t request_id, void *private_data);
 
int sr_module_change_subscribe(sr_session_ctx_t *session, const char *module_name, const char *xpath,
        sr_module_change_cb callback, void *private_data, uint32_t priority, sr_subscr_options_t opts,
        sr_subscription_ctx_t **subscription);
 
int sr_get_changes_iter(sr_session_ctx_t *session, const char *xpath, sr_change_iter_t **iter);
 
int sr_dup_changes_iter(sr_session_ctx_t *session, const char *xpath, sr_change_iter_t **iter);
 
int sr_get_change_next(sr_session_ctx_t *session, sr_change_iter_t *iter, sr_change_oper_t *operation,
        sr_val_t **old_value, sr_val_t **new_value);
 
int sr_get_change_tree_next(sr_session_ctx_t *session, sr_change_iter_t *iter, sr_change_oper_t *operation,
        const struct lyd_node **node, const char **prev_value, const char **prev_list, bool *prev_dflt);
 
void sr_free_change_iter(sr_change_iter_t *iter);
 
// RPC (Remote Procedure Calls) and Action API
 
typedef int (*sr_rpc_cb)(sr_session_ctx_t *session, const char *xpath, const sr_val_t *input, const size_t input_cnt,
        sr_event_t event, uint32_t request_id, sr_val_t **output, size_t *output_cnt, void *private_data);
 
typedef int (*sr_rpc_tree_cb)(sr_session_ctx_t *session, const char *op_path, const struct lyd_node *input,
        sr_event_t event, uint32_t request_id, struct lyd_node *output, void *private_data);
 
int sr_rpc_subscribe(sr_session_ctx_t *session, const char *xpath, sr_rpc_cb callback, void *private_data,
        uint32_t priority, sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);
 
int sr_rpc_subscribe_tree(sr_session_ctx_t *session, const char *xpath, sr_rpc_tree_cb callback,
        void *private_data, uint32_t priority, sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);
 
int sr_rpc_send(sr_session_ctx_t *session, const char *path, const sr_val_t *input, const size_t input_cnt,
        uint32_t timeout_ms, sr_val_t **output, size_t *output_cnt);
 
int sr_rpc_send_tree(sr_session_ctx_t *session, struct lyd_node *input, uint32_t timeout_ms, struct lyd_node **output);
 
// Notifications API
 
typedef enum sr_ev_notif_type_e {
    SR_EV_NOTIF_REALTIME,         
    SR_EV_NOTIF_REPLAY,           
    SR_EV_NOTIF_REPLAY_COMPLETE,  
    SR_EV_NOTIF_STOP,             
    SR_EV_NOTIF_SUSPENDED,        
    SR_EV_NOTIF_RESUMED           
} sr_ev_notif_type_t;
 
typedef void (*sr_event_notif_cb)(sr_session_ctx_t *session, const sr_ev_notif_type_t notif_type, const char *xpath,
        const sr_val_t *values, const size_t values_cnt, time_t timestamp, void *private_data);
 
typedef void (*sr_event_notif_tree_cb)(sr_session_ctx_t *session, const sr_ev_notif_type_t notif_type,
        const struct lyd_node *notif, time_t timestamp, void *private_data);
 
int sr_event_notif_subscribe(sr_session_ctx_t *session, const char *module_name, const char *xpath, time_t start_time,
        time_t stop_time, sr_event_notif_cb callback, void *private_data, sr_subscr_options_t opts,
        sr_subscription_ctx_t **subscription);
 
int sr_event_notif_subscribe_tree(sr_session_ctx_t *session, const char *module_name, const char *xpath,
        time_t start_time, time_t stop_time, sr_event_notif_tree_cb callback, void *private_data,
        sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);
 
int sr_event_notif_send(sr_session_ctx_t *session, const char *path, const sr_val_t *values, const size_t values_cnt);
 
int sr_event_notif_send_tree(sr_session_ctx_t *session, struct lyd_node *notif);
 
uint32_t sr_event_notif_sub_id_get_last(const sr_subscription_ctx_t *subscription);
 
int sr_event_notif_sub_suspend(sr_subscription_ctx_t *subscription, uint32_t sub_id);
 
int sr_event_notif_sub_resume(sr_subscription_ctx_t *subscription, uint32_t sub_id);
 
// Operational Data API
 
typedef int (*sr_oper_get_items_cb)(sr_session_ctx_t *session, const char *module_name, const char *path,
        const char *request_xpath, uint32_t request_id, struct lyd_node **parent, void *private_data);
 
int sr_oper_get_items_subscribe(sr_session_ctx_t *session, const char *module_name, const char *path,
        sr_oper_get_items_cb callback, void *private_data, sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);
 
// Plugin API
 
#define SRP_INIT_CB     "sr_plugin_init_cb"
 
#define SRP_CLEANUP_CB  "sr_plugin_cleanup_cb"
 
typedef int (*srp_init_cb_t)(sr_session_ctx_t *session, void **private_data);
 
typedef void (*srp_cleanup_cb_t)(sr_session_ctx_t *session, void *private_data);
 
#define SRP_LOG_ERR(...) srp_log(SR_LL_ERR, __VA_ARGS__)
 
#define SRP_LOG_WRN(...) srp_log(SR_LL_WRN, __VA_ARGS__)
 
#define SRP_LOG_INF(...) srp_log(SR_LL_INF, __VA_ARGS__)
 
#define SRP_LOG_DBG(...) srp_log(SR_LL_DBG, __VA_ARGS__)
 
#define SRP_LOG_ERRMSG(msg) srp_log(SR_LL_ERR, msg)
 
#define SRP_LOG_WRNMSG(msg) srp_log(SR_LL_WRN, msg)
 
#define SRP_LOG_INFMSG(msg) srp_log(SR_LL_INF, msg)
 
#define SRP_LOG_DBGMSG(msg) srp_log(SR_LL_DBG, msg)
 
void srp_log(sr_log_level_t ll, const char *format, ...);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _SYSREPO_H */