sysrepo.h

Go to the documentation of this file.

#ifndef _SYSREPO_H
#define _SYSREPO_H

#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

#include <libyang/libyang.h>

#include "sysrepo_types.h"

#ifdef __cplusplus
extern "C" {
#endif

// Logging API

const char *sr_strerror(int err_code);

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);

void sr_log_set_cb(sr_log_cb log_callback);

// Connection / Session Management

int sr_connect(const sr_conn_options_t opts, sr_conn_ctx_t **conn);

int sr_disconnect(sr_conn_ctx_t *conn);

const struct ly_ctx *sr_acquire_context(sr_conn_ctx_t *conn);

const struct ly_ctx *sr_session_acquire_context(sr_session_ctx_t *session);

void sr_release_context(sr_conn_ctx_t *conn);

void sr_session_release_context(sr_session_ctx_t *session);

uint32_t sr_get_content_id(sr_conn_ctx_t *conn);

int sr_get_plugins(sr_conn_ctx_t *conn, const char ***ds_plugins, const char ***ntf_plugins);

uid_t sr_get_su_uid(void);

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_unsubscribe(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_session_set_orig_name(sr_session_ctx_t *session, const char *orig_name);

const char *sr_session_get_orig_name(sr_session_ctx_t *session);

int sr_session_push_orig_data(sr_session_ctx_t *session, uint32_t size, const void *data);

void sr_session_del_orig_data(sr_session_ctx_t *session);

int sr_session_get_orig_data(sr_session_ctx_t *session, uint32_t idx, uint32_t *size, const void **data);

int sr_session_get_error(sr_session_ctx_t *session, const sr_error_info_t **error_info);

int sr_session_dup_error(sr_session_ctx_t *src_session, sr_session_ctx_t *trg_session);

int sr_session_set_error(sr_session_ctx_t *session, const char *err_format_name, sr_error_t err_code,
        const char *err_msg_format, ...);

int sr_session_set_error_message(sr_session_ctx_t *session, const char *format, ...);

int sr_session_set_error_format(sr_session_ctx_t *session, const char *error_format);

int sr_session_push_error_data(sr_session_ctx_t *session, uint32_t size, const void *data);

int sr_get_error_data(const sr_error_info_err_t *err, uint32_t idx, uint32_t *size, const void **data);

uint32_t sr_session_get_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);

sr_conn_ctx_t *sr_session_get_connection(sr_session_ctx_t *session);

// Schema Manipulation API

const char *sr_get_repo_path(void);

const char *sr_get_shm_path(void);

const char *sr_get_shm_prefix(void);

int sr_install_module(sr_conn_ctx_t *conn, const char *schema_path, const char *search_dirs, const char **features);

const sr_module_ds_t *sr_get_module_ds_default(void);

int sr_install_module2(sr_conn_ctx_t *conn, const char *schema_path, const char *search_dirs, const char **features,
        const sr_module_ds_t *module_ds, const char *owner, const char *group, mode_t perm, const char *data,
        const char *data_path, LYD_FORMAT format);

int sr_install_modules(sr_conn_ctx_t *conn, const char **schema_paths, const char *search_dirs,
        const char ***features);

int sr_install_modules2(sr_conn_ctx_t *conn, const sr_install_mod_t *modules, uint32_t module_count,
        const char *search_dirs, const char *data, const char *data_path, LYD_FORMAT format);

int sr_remove_module(sr_conn_ctx_t *conn, const char *module_name, int force);

int sr_remove_modules(sr_conn_ctx_t *conn, const char **module_names, int force);

int sr_update_module(sr_conn_ctx_t *conn, const char *schema_path, const char *search_dirs);

int sr_update_modules(sr_conn_ctx_t *conn, const char **schema_paths, const char *search_dirs);

int sr_set_module_replay_support(sr_conn_ctx_t *conn, const char *module_name, int enable);

int sr_get_module_replay_support(sr_conn_ctx_t *conn, const char *module_name, struct timespec *earliest_notif,
        int *enabled);

int sr_set_module_ds_access(sr_conn_ctx_t *conn, const char *module_name, int mod_ds, const char *owner,
        const char *group, mode_t perm);

int sr_get_module_ds_access(sr_conn_ctx_t *conn, const char *module_name, int mod_ds, char **owner, char **group,
        mode_t *perm);

int sr_check_module_ds_access(sr_conn_ctx_t *conn, const char *module_name, int mod_ds, int *read, int *write);

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, sr_data_t **sysrepo_data);

int sr_is_module_internal(const struct lys_module *ly_mod);

// Data Retrieval API (get / get-config functionality)

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_options_t opts,
        sr_val_t **values, size_t *value_cnt);

int sr_session_acquire_data(sr_session_ctx_t *session, struct lyd_node *tree, sr_data_t **data);

int sr_acquire_data(sr_conn_ctx_t *conn, struct lyd_node *tree, sr_data_t **data);

int sr_get_subtree(sr_session_ctx_t *session, const char *path, uint32_t timeout_ms, sr_data_t **subtree);

int sr_get_data(sr_session_ctx_t *session, const char *xpath, uint32_t max_depth, uint32_t timeout_ms,
        const sr_get_options_t opts, sr_data_t **data);

int sr_get_node(sr_session_ctx_t *session, const char *path, uint32_t timeout_ms, sr_data_t **node);

void sr_release_data(sr_data_t *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)

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_oper_delete_item_str(sr_session_ctx_t *session, const char *path, const char *value, const sr_edit_options_t opts);

int sr_discard_items(sr_session_ctx_t *session, const char *xpath);

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 sr_has_changes(sr_session_ctx_t *session);

const struct lyd_node *sr_get_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 sr_copy_config(sr_session_ctx_t *session, const char *module_name, sr_datastore_t src_datastore, uint32_t timeout_ms);

int sr_discard_oper_changes(sr_conn_ctx_t *conn, sr_session_ctx_t *session, const char *module_name, uint32_t timeout_ms);

int sr_get_oper_changes(sr_session_ctx_t *session, const char *module_name, sr_data_t **data);

int sr_set_oper_changes_order(sr_session_ctx_t *session, const char *module_name, uint32_t order);

int sr_get_oper_changes_order(sr_session_ctx_t *session, const char *module_name, uint32_t *order);

// Locking API

int sr_lock(sr_session_ctx_t *session, const char *module_name, uint32_t timeout_ms);

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,
        struct timespec *timestamp);

// Subscription API

int sr_get_event_pipe(sr_subscription_ctx_t *subscription, int *event_pipe);

int sr_subscription_process_events(sr_subscription_ctx_t *subscription, sr_session_ctx_t *session,
        struct timespec *wake_up_in);

uint32_t sr_subscription_get_last_sub_id(const sr_subscription_ctx_t *subscription);

int sr_subscription_get_suspended(sr_subscription_ctx_t *subscription, uint32_t sub_id, int *suspended);

int sr_subscription_suspend(sr_subscription_ctx_t *subscription, uint32_t sub_id);

int sr_subscription_resume(sr_subscription_ctx_t *subscription, uint32_t sub_id);

int sr_unsubscribe_sub(sr_subscription_ctx_t *subscription, uint32_t sub_id);

int sr_subscription_thread_suspend(sr_subscription_ctx_t *subscription);

int sr_subscription_thread_resume(sr_subscription_ctx_t *subscription);

int sr_unsubscribe(sr_subscription_ctx_t *subscription);

// Change Subscriptions API

int sr_module_change_set_order(sr_conn_ctx_t *conn, const char *module_name, sr_datastore_t ds, uint32_t priority);

int sr_module_change_get_order(sr_conn_ctx_t *conn, const char *module_name, sr_datastore_t ds, uint32_t *priority);

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_module_change_sub_get_info(sr_subscription_ctx_t *subscription, uint32_t sub_id, const char **module_name,
        sr_datastore_t *ds, const char **xpath, uint32_t *filtered_out);

int sr_module_change_sub_modify_xpath(sr_subscription_ctx_t *subscription, uint32_t sub_id, const char *xpath);

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, int *prev_dflt);

void sr_free_change_iter(sr_change_iter_t *iter);

const struct lyd_node *sr_get_change_diff(sr_session_ctx_t *session);

// RPC (Remote Procedure Calls) and Action API

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, sr_data_t **output);

// Notifications API

int sr_notif_subscribe(sr_session_ctx_t *session, const char *module_name, const char *xpath,
        const struct timespec *start_time, const struct timespec *stop_time, sr_event_notif_cb callback,
        void *private_data, sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);

int sr_notif_subscribe_tree(sr_session_ctx_t *session, const char *module_name, const char *xpath,
        const struct timespec *start_time, const struct timespec *stop_time, sr_event_notif_tree_cb callback,
        void *private_data, sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);

int sr_notif_send(sr_session_ctx_t *session, const char *path, const sr_val_t *values, const size_t values_cnt,
        uint32_t timeout_ms, int wait);

int sr_notif_send_tree(sr_session_ctx_t *session, struct lyd_node *notif, uint32_t timeout_ms, int wait);

int sr_notif_sub_get_info(sr_subscription_ctx_t *subscription, uint32_t sub_id, const char **module_name,
        const char **xpath, struct timespec *start_time, struct timespec *stop_time, uint32_t *filtered_out);

int sr_notif_sub_modify_xpath(sr_subscription_ctx_t *subscription, uint32_t sub_id, const char *xpath);

int sr_notif_sub_modify_stop_time(sr_subscription_ctx_t *subscription, uint32_t sub_id, const struct timespec *stop_time);

// Operational Data API

int sr_oper_get_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);

int sr_oper_poll_subscribe(sr_session_ctx_t *session, const char *module_name, const char *path, uint32_t valid_ms,
        sr_subscr_options_t opts, sr_subscription_ctx_t **subscription);

// sysrepo-plugind Plugin API

#define SRP_INIT_CB     "sr_plugin_init_cb"

#define SRP_CLEANUP_CB  "sr_plugin_cleanup_cb"

void srplg_log_errinfo(sr_error_info_t **err_info, const char *plg_name, const char *err_format_name,
        sr_error_t err_code, const char *format, ...) _FORMAT_PRINTF(5, 6);

int srplg_errinfo_push_error_data(sr_error_info_t *err_info, uint32_t size, const void *data);

void srplg_errinfo_free(sr_error_info_t **err_info);

#define SRPLG_LOG_ERR(plg_name, ...) srplg_log(plg_name, SR_LL_ERR, __VA_ARGS__)

#define SRPLG_LOG_WRN(plg_name, ...) srplg_log(plg_name, SR_LL_WRN, __VA_ARGS__)

#define SRPLG_LOG_INF(plg_name, ...) srplg_log(plg_name, SR_LL_INF, __VA_ARGS__)

#define SRPLG_LOG_DBG(plg_name, ...) srplg_log(plg_name, SR_LL_DBG, __VA_ARGS__)

void srplg_log(const char *plg_name, sr_log_level_t ll, const char *format, ...) _FORMAT_PRINTF(3, 4);

#ifdef __cplusplus
}
#endif

#endif /* _SYSREPO_H */