libyang.h

Go to the documentation of this file.

 
#ifndef LY_LIBYANG_H_
#define LY_LIBYANG_H_
 
#include <stdio.h>

#define LY_ENABLED_CACHE

#define LY_ENABLED_LATEST_REVISIONS

#define LY_ENABLED_LYD_PRIV

#define _PACKED __attribute__((__packed__))
 
#include "tree_schema.h"
#include "tree_data.h"
#include "xml.h"
#include "dict.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define LY_VERSION_MAJOR 1 
#define LY_VERSION_MINOR 9 
#define LY_VERSION_MICRO 2 
#define LY_VERSION "1.9.2" 





















struct ly_ctx;

 
#define LY_CTX_ALLIMPLEMENTED 0x01 
#define LY_CTX_TRUSTED        0x02 
#define LY_CTX_NOYANGLIBRARY  0x04 
#define LY_CTX_DISABLE_SEARCHDIRS 0x08  
#define LY_CTX_DISABLE_SEARCHDIR_CWD 0x10 
#define LY_CTX_PREFER_SEARCHDIRS 0x20 

struct ly_ctx *ly_ctx_new(const char *search_dir, int options);

struct ly_ctx *ly_ctx_new_ylpath(const char *search_dir, const char *path, LYD_FORMAT format, int options);

struct ly_ctx *ly_ctx_new_ylmem(const char *search_dir, const char *data, LYD_FORMAT format, int options);

unsigned int ly_ctx_internal_modules_count(struct ly_ctx *ctx);

int ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir);

void ly_ctx_unset_searchdirs(struct ly_ctx *ctx, int index);

const char * const *ly_ctx_get_searchdirs(const struct ly_ctx *ctx);

int ly_ctx_get_options(struct ly_ctx *ctx);

void ly_ctx_set_disable_searchdirs(struct ly_ctx *ctx);

void ly_ctx_unset_disable_searchdirs(struct ly_ctx *ctx);

void ly_ctx_set_disable_searchdir_cwd(struct ly_ctx *ctx);

void ly_ctx_unset_disable_searchdir_cwd(struct ly_ctx *ctx);

void ly_ctx_set_prefer_searchdirs(struct ly_ctx *ctx);

void ly_ctx_unset_prefer_searchdirs(struct ly_ctx *ctx);

void ly_ctx_set_allimplemented(struct ly_ctx *ctx);

void ly_ctx_unset_allimplemented(struct ly_ctx *ctx);

void ly_ctx_set_trusted(struct ly_ctx *ctx);

void ly_ctx_unset_trusted(struct ly_ctx *ctx);

uint16_t ly_ctx_get_module_set_id(const struct ly_ctx *ctx);

struct lyd_node *ly_ctx_info(struct ly_ctx *ctx);

const struct lys_module *ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *idx);

const struct lys_module *ly_ctx_get_disabled_module_iter(const struct ly_ctx *ctx, uint32_t *idx);

const struct lys_module *ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision, int implemented);

const struct lys_module *ly_ctx_get_module_older(const struct ly_ctx *ctx, const struct lys_module *module);

const struct lys_module *ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision);

typedef const char *(*ly_module_imp_clb)(const char *mod_name, const char *mod_rev, const char *submod_name, const char *sub_rev,
                                   void *user_data, LYS_INFORMAT *format, void (**free_module_data)(void *model_data, void *user_data));

void ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data);

ly_module_imp_clb ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data);

typedef const struct lys_module *(*ly_module_data_clb)(struct ly_ctx *ctx, const char *name, const char *ns,
                                                       int options, void *user_data);
 
/* Module is in the context, but is not implemented, so to continue with the data operation, it must be implemented. */
#define LY_MODCLB_NOT_IMPLEMENTED 0x01

void ly_ctx_set_module_data_clb(struct ly_ctx *ctx, ly_module_data_clb clb, void *user_data);

ly_module_data_clb ly_ctx_get_module_data_clb(const struct ly_ctx *ctx, void **user_data);
 
#ifdef LY_ENABLED_LYD_PRIV
 
void ly_ctx_set_priv_dup_clb(struct ly_ctx *ctx, void *(*priv_dup_clb)(const void *priv));
 
#endif

const struct lys_module *ly_ctx_get_module_by_ns(const struct ly_ctx *ctx, const char *ns, const char *revision, int implemented);

const struct lys_submodule *ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *module, const char *revision,
                                                 const char *submodule, const char *sub_revision);

const struct lys_submodule *ly_ctx_get_submodule2(const struct lys_module *main_module, const char *submodule);

const struct lys_node *ly_ctx_get_node(const struct ly_ctx *ctx, const struct lys_node *start, const char *data_path, int output);

struct ly_set *ly_ctx_find_path(struct ly_ctx *ctx, const char *path);

int ly_ctx_remove_module(const struct lys_module *module,
                         void (*private_destructor)(const struct lys_node *node, void *priv));

void ly_ctx_clean(struct ly_ctx *ctx, void (*private_destructor)(const struct lys_node *node, void *priv));

void ly_ctx_destroy(struct ly_ctx *ctx, void (*private_destructor)(const struct lys_node *node, void *priv));

char *ly_path_xml2json(struct ly_ctx *ctx, const char *xml_path, struct lyxml_elem *xml);

char *ly_path_data2schema(struct ly_ctx *ctx, const char *data_path);



union ly_set_set {
    struct lys_node **s;         
    struct lyd_node **d;         
    void **g;                    
};

struct ly_set {
    unsigned int size;               
    unsigned int number;             
    union ly_set_set set;            
};

#define LY_SET_OPT_USEASLIST 0x01

struct ly_set *ly_set_new(void);

struct ly_set *ly_set_dup(const struct ly_set *set);

int ly_set_add(struct ly_set *set, void *node, int options);

int ly_set_merge(struct ly_set *trg, struct ly_set *src, int options);

int ly_set_contains(const struct ly_set *set, void *node);

int ly_set_clean(struct ly_set *set);

int ly_set_rm(struct ly_set *set, void *node);

int ly_set_rm_index(struct ly_set *set, unsigned int index);

void ly_set_free(struct ly_set *set);


#define LYP_WITHSIBLINGS  0x01  
#define LYP_FORMAT        0x02  
#define LYP_KEEPEMPTYCONT 0x04  
#define LYP_WD_MASK       0xF0  
#define LYP_WD_EXPLICIT   0x00  
#define LYP_WD_TRIM       0x10  
#define LYP_WD_ALL        0x20  
#define LYP_WD_ALL_TAG    0x40  
#define LYP_WD_IMPL_TAG   0x80  
#define LYP_NETCONF       0x100 



typedef enum {
    LY_LLERR = 0,     
    LY_LLWRN = 1,     
    LY_LLVRB = 2,     
    LY_LLDBG = 3      
} LY_LOG_LEVEL;

LY_LOG_LEVEL ly_verb(LY_LOG_LEVEL level);

#define LY_LOLOG        0x01 
#define LY_LOSTORE      0x02 
#define LY_LOSTORE_LAST 0x06 


int ly_log_options(int opts);
 
#ifndef NDEBUG

 
#define LY_LDGDICT  0x01 
#define LY_LDGYANG  0x02 
#define LY_LDGYIN   0x04 
#define LY_LDGXPATH 0x08 
#define LY_LDGDIFF  0x10 
#define LY_LDGAPI   0x20 
#define LY_LDGHASH  0x40 


void ly_verb_dbg(int dbg_groups);
 
#endif

void ly_set_log_clb(void (*clb)(LY_LOG_LEVEL level, const char *msg, const char *path), int path);

void (*ly_get_log_clb(void))(LY_LOG_LEVEL, const char *, const char *);

typedef enum {
    LY_SUCCESS = 0, 
    LY_EMEM,        
    LY_ESYS,        
    LY_EINVAL,      
    LY_EINT,        
    LY_EVALID,      
    LY_EPLUGIN      
} LY_ERR;

typedef enum {
    LYVE_SUCCESS = 0,  
 
    LYVE_XML_MISS,     
    LYVE_XML_INVAL,    
    LYVE_XML_INCHAR,   
 
    LYVE_EOF,          
    LYVE_INSTMT,       
    /* */
    LYVE_INPAR,        
    LYVE_INID,         
    LYVE_INDATE,       
    LYVE_INARG,        
    LYVE_MISSSTMT,     
    /* */
    LYVE_MISSARG,      
    LYVE_TOOMANY,      
    LYVE_DUPID,        
    LYVE_DUPLEAFLIST,  
    LYVE_DUPLIST,      
    LYVE_NOUNIQ,       
    LYVE_ENUM_INVAL,   
    LYVE_ENUM_INNAME,  
    /* */
    /* */
    LYVE_ENUM_WS,      
    LYVE_BITS_INVAL,   
    LYVE_BITS_INNAME,  
    /* */
    /* */
    LYVE_INMOD,        
    /* */
    LYVE_KEY_NLEAF,    
    LYVE_KEY_TYPE,     
    LYVE_KEY_CONFIG,   
    LYVE_KEY_MISS,     
    LYVE_KEY_DUP,      
    LYVE_INREGEX,      
    LYVE_INRESOLV,     
    LYVE_INSTATUS,     
    LYVE_CIRC_LEAFREFS,
    LYVE_CIRC_FEATURES,
    LYVE_CIRC_IMPORTS, 
    LYVE_CIRC_INCLUDES,
    LYVE_INVER,        
    LYVE_SUBMODULE,    
 
    LYVE_OBSDATA,      
    /* */
    LYVE_NORESOLV,     
    LYVE_INELEM,       
    /* */
    LYVE_MISSELEM,     
    LYVE_INVAL,        
    LYVE_INMETA,       
    LYVE_INATTR,       
    LYVE_MISSATTR,     
    LYVE_NOCONSTR,     
    LYVE_INCHAR,       
    LYVE_INPRED,       
    LYVE_MCASEDATA,    
    LYVE_NOMUST,       
    LYVE_NOWHEN,       
    LYVE_INORDER,      
    LYVE_INWHEN,       
    LYVE_NOMIN,        
    LYVE_NOMAX,        
    LYVE_NOREQINS,     
    LYVE_NOLEAFREF,    
    LYVE_NOMANDCHOICE, 
 
    LYVE_XPATH_INTOK,  
    LYVE_XPATH_EOF,    
    LYVE_XPATH_INOP,   
    /* */
    LYVE_XPATH_INCTX,  
    LYVE_XPATH_INMOD,  
    LYVE_XPATH_INFUNC, 
    LYVE_XPATH_INARGCOUNT, 
    LYVE_XPATH_INARGTYPE, 
    LYVE_XPATH_DUMMY,  
    LYVE_XPATH_NOEND,  
 
    LYVE_PATH_INCHAR,  
    LYVE_PATH_INMOD,   
    LYVE_PATH_MISSMOD, 
    LYVE_PATH_INNODE,  
    LYVE_PATH_INKEY,   
    LYVE_PATH_MISSKEY, 
    LYVE_PATH_INIDENTREF, 
    LYVE_PATH_EXISTS,  
    LYVE_PATH_MISSPAR, 
    LYVE_PATH_PREDTOOMANY, 
} LY_VECODE;

LY_ERR *ly_errno_glob_address(void);

#define ly_errno (*ly_errno_glob_address())

LY_VECODE ly_vecode(const struct ly_ctx *ctx);

const char *ly_errmsg(const struct ly_ctx *ctx);

const char *ly_errpath(const struct ly_ctx *ctx);

const char *ly_errapptag(const struct ly_ctx *ctx);

struct ly_err_item {
    LY_LOG_LEVEL level;
    LY_ERR no;
    LY_VECODE vecode;
    char *msg;
    char *path;
    char *apptag;
    struct ly_err_item *next;
    struct ly_err_item *prev; /* first item's prev points to the last item */
};

struct ly_err_item *ly_err_first(const struct ly_ctx *ctx);

void ly_err_print(struct ly_err_item *eitem);

void ly_err_clean(struct ly_ctx *ctx, struct ly_err_item *eitem);

 
#ifdef __cplusplus
}
#endif
 
#endif /* LY_LIBYANG_H_ */