libyang  6.4.26
libyang is YANG data modelling language parser and toolkit written (and providing API) in C.
xpath1.0.c
Go to the documentation of this file.
1 
15 #define _GNU_SOURCE
16 
17 #include "plugins_types.h"
18 
19 #include <assert.h>
20 #include <stdint.h>
21 #include <stdlib.h>
22 #include <string.h>
23 
24 #include "compat.h"
25 #include "dict.h"
26 #include "ly_common.h"
27 #include "xml.h"
28 #include "xpath.h"
29 
39 LIBYANG_API_DEF LY_ERR
40 lyplg_type_xpath10_print_token(const char *token, uint16_t tok_len, ly_bool is_nametest, const struct lys_module **context_mod,
41  const struct ly_ctx *resolve_ctx, LY_VALUE_FORMAT resolve_format, const void *resolve_prefix_data,
42  LY_VALUE_FORMAT get_format, void *get_prefix_data, char **token_p, struct ly_err_item **err)
43 {
44  LY_ERR ret = LY_SUCCESS;
45  const char *str_begin, *str_next, *prefix;
46  ly_bool is_prefix, has_prefix = 0;
47  char *str = NULL;
48  uint32_t len, str_size = 0, str_len = 0, pref_len;
49  const struct lys_module *mod;
50 
51  str_begin = token;
52 
53  while (!(ret = ly_value_prefix_next(str_begin, token + tok_len, &len, &is_prefix, &str_next)) && len) {
54  if (!is_prefix) {
55  if (!has_prefix && is_nametest && (get_format == LY_VALUE_XML) && *context_mod) {
56  /* get the prefix */
57  prefix = lyplg_type_get_prefix(*context_mod, get_format, get_prefix_data);
58  assert(prefix);
59 
60  /* append the nametest and prefix */
61  LY_CHECK_ERR_GOTO(ly_append_str(&str, &str_size, &str_len, "%s:%.*s", prefix, (int)len, str_begin),
62  ret = ly_err_new_no_mem(err), cleanup);
63  } else {
64  /* just append the string, we may get the first expression node without a prefix but since this
65  * is not strictly forbidden, allow it */
66  LY_CHECK_ERR_GOTO(ly_append_str(&str, &str_size, &str_len, "%.*s", (int)len, str_begin),
67  ret = ly_err_new_no_mem(err), cleanup);
68  }
69  } else {
70  /* remember there was a prefix found */
71  has_prefix = 1;
72 
73  /* resolve the module in the original format */
74  mod = lys_find_module(resolve_ctx, NULL, str_begin, len, resolve_format, resolve_prefix_data);
75  if (!mod && is_nametest) {
76  ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Failed to resolve prefix \"%.*s\".",
77  (int)len, str_begin);
78  goto cleanup;
79  }
80 
81  if (is_nametest && ((get_format == LY_VALUE_JSON) || (get_format == LY_VALUE_LYB)) && (*context_mod == mod)) {
82  /* inherit the prefix and do not print it again */
83  } else {
84  if (mod) {
85  /* get the prefix in the target format */
86  prefix = lyplg_type_get_prefix(mod, get_format, get_prefix_data);
87  assert(prefix);
88  pref_len = strlen(prefix);
89  } else {
90  /* invalid prefix, just copy it */
91  prefix = str_begin;
92  pref_len = len;
93  }
94 
95  /* append the prefix */
96  LY_CHECK_ERR_GOTO(ly_append_str(&str, &str_size, &str_len, "%.*s:", (int)pref_len, prefix),
97  ret = ly_err_new_no_mem(err), cleanup);
98  }
99 
100  if (is_nametest) {
101  /* update context module */
102  *context_mod = mod;
103  }
104  }
105 
106  str_begin = str_next;
107  }
108 
109 cleanup:
110  if (ret) {
111  free(str);
112  } else {
113  *token_p = str;
114  }
115  return ret;
116 }
117 
134 static LY_ERR
135 xpath10_print_subexpr_r(uint16_t *cur_idx, enum lyxp_token end_tok, const struct lys_module *context_mod,
136  const struct lyd_value_xpath10 *xp_val, LY_VALUE_FORMAT format, void *prefix_data, char **str_value,
137  uint32_t *str_size, uint32_t *str_len, struct ly_err_item **err)
138 {
139  LY_ERR r;
140  enum lyxp_token cur_tok, sub_end_tok;
141  char *str_tok;
142  const char *cur_exp_ptr;
143  ly_bool is_nt;
144  const struct lys_module *orig_context_mod = context_mod;
145 
146  while (*cur_idx < xp_val->exp->used) {
147  cur_tok = xp_val->exp->tokens[*cur_idx];
148  cur_exp_ptr = xp_val->exp->expr + xp_val->exp->tok_pos[*cur_idx];
149 
150  if ((cur_tok == LYXP_TOKEN_NAMETEST) || (cur_tok == LYXP_TOKEN_LITERAL)) {
151  /* tokens that may include prefixes, get them in the target format */
152  is_nt = (cur_tok == LYXP_TOKEN_NAMETEST) ? 1 : 0;
153  LY_CHECK_RET(lyplg_type_xpath10_print_token(cur_exp_ptr, xp_val->exp->tok_len[*cur_idx], is_nt, &context_mod,
154  xp_val->ctx, xp_val->format, xp_val->prefix_data, format, prefix_data, &str_tok, err));
155 
156  /* append the converted token */
157  r = ly_append_str(str_value, str_size, str_len, "%s", str_tok);
158  free(str_tok);
159  LY_CHECK_GOTO(r, error_mem);
160 
161  /* token processed */
162  ++(*cur_idx);
163  } else {
164  if ((cur_tok == LYXP_TOKEN_OPER_LOG) || (cur_tok == LYXP_TOKEN_OPER_UNI) || (cur_tok == LYXP_TOKEN_OPER_MATH)) {
165  /* copy the token with spaces around */
166  LY_CHECK_GOTO(ly_append_str(str_value, str_size, str_len, " %.*s ", (int)xp_val->exp->tok_len[*cur_idx],
167  cur_exp_ptr), error_mem);
168 
169  /* reset context mod */
170  context_mod = orig_context_mod;
171  } else {
172  /* just copy the token */
173  LY_CHECK_GOTO(ly_append_str(str_value, str_size, str_len, "%.*s", (int)xp_val->exp->tok_len[*cur_idx],
174  cur_exp_ptr), error_mem);
175  }
176 
177  /* token processed but keep it in cur_tok */
178  ++(*cur_idx);
179 
180  if (end_tok && (cur_tok == end_tok)) {
181  /* end token found */
182  break;
183  } else if ((cur_tok == LYXP_TOKEN_BRACK1) || (cur_tok == LYXP_TOKEN_PAR1)) {
184  sub_end_tok = (cur_tok == LYXP_TOKEN_BRACK1) ? LYXP_TOKEN_BRACK2 : LYXP_TOKEN_PAR2;
185 
186  /* parse the subexpression separately, use the current context mod */
187  LY_CHECK_RET(xpath10_print_subexpr_r(cur_idx, sub_end_tok, context_mod, xp_val, format, prefix_data,
188  str_value, str_size, str_len, err));
189  }
190  }
191  }
192 
193  return LY_SUCCESS;
194 
195 error_mem:
196  return ly_err_new_no_mem(err);
197 }
198 
199 LIBYANG_API_DEF LY_ERR
200 lyplg_type_print_xpath10_value(const struct lyd_value_xpath10 *xp_val, LY_VALUE_FORMAT format, void *prefix_data,
201  char **str_value, struct ly_err_item **err)
202 {
203  LY_ERR ret = LY_SUCCESS;
204  uint16_t expr_idx = 0;
205  uint32_t str_size = 0, str_len = 0;
206  const struct lys_module *local_mod = NULL;
207  struct ly_set *mods;
208 
209  *str_value = NULL;
210  *err = NULL;
211 
212  switch (format) {
213  case LY_VALUE_XML:
214  /* zero the local module so that all the prefixes are printed */
215  mods = prefix_data;
216  local_mod = mods->objs[0];
217  mods->objs[0] = NULL;
218  break;
219  case LY_VALUE_SCHEMA:
221  /* nothing to do */
222  break;
223  case LY_VALUE_CANON:
224  case LY_VALUE_CBOR:
225  case LY_VALUE_JSON:
226  case LY_VALUE_LYB:
227  case LY_VALUE_STR_NS:
228  /* zero the local module so that the first node is always prefixed */
229  prefix_data = NULL;
230  break;
231  }
232 
233  /* recursively print the expression */
234  ret = xpath10_print_subexpr_r(&expr_idx, 0, NULL, xp_val, format, prefix_data, str_value, &str_size, &str_len, err);
235 
236  if (local_mod) {
237  mods->objs[0] = (void *)local_mod;
238  }
239  if (ret) {
240  free(*str_value);
241  *str_value = NULL;
242  }
243  return ret;
244 }
245 
246 static LY_ERR
247 lyplg_type_store_xpath10(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, uint64_t value_size_bits,
248  uint32_t options, LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
249  struct lyd_value *storage, struct lys_glob_unres *UNUSED(unres), struct ly_err_item **err)
250 {
251  LY_ERR ret = LY_SUCCESS;
252  const struct ly_err_item *e;
253  uint32_t value_size, *prev_lo, temp_lo = LY_LOSTORE;
254  struct lyd_value_xpath10 *val;
255  char *canon;
256 
257  /* init storage */
258  memset(storage, 0, sizeof *storage);
259  LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
260  LY_CHECK_ERR_GOTO(!val, ret = ly_err_new_no_mem(err), cleanup);
261  storage->realtype = type;
262 
263  /* check value length */
264  ret = lyplg_type_check_value_size("xpath1.0", format, value_size_bits, LYPLG_LYB_SIZE_VARIABLE_BYTES, 0,
265  &value_size, err);
266  LY_CHECK_GOTO(ret, cleanup);
267 
268  /* check hints */
269  ret = lyplg_type_check_hints(hints, value, value_size, type->basetype, NULL, err);
270  LY_CHECK_GOTO(ret, cleanup);
271 
272  /* parse */
273  prev_lo = ly_temp_log_options(&temp_lo);
274  ret = lyxp_expr_parse(ctx, NULL, value_size ? value : "", value_size, 1, &val->exp);
275  ly_temp_log_options(prev_lo);
276  if (ret) {
277  /* get a copy of the error */
278  e = ly_err_last(ctx);
279  if (e) {
280  ly_err_new(err, e->err, e->vecode, e->data_path, e->apptag, "%s", e->msg);
281  ly_err_clean(ctx, (struct ly_err_item *)e);
282  }
283  goto cleanup;
284  }
285  val->ctx = ctx;
286 
287  if (ctx_node && !strcmp(ctx_node->name, "parent-reference") && !strcmp(ctx_node->module->name, "ietf-yang-schema-mount")) {
288  /* special case, this type uses prefix-namespace mapping provided directly in data, keep empty for now */
289  val->format = format = LY_VALUE_STR_NS;
290  ret = ly_set_new((struct ly_set **)&val->prefix_data);
291  LY_CHECK_GOTO(ret, cleanup);
292  } else {
293  /* store format-specific data and context for later prefix resolution */
294  ret = lyplg_type_prefix_data_new(ctx, value, value_size, format, prefix_data, &val->format, &val->prefix_data);
295  LY_CHECK_GOTO(ret, cleanup);
296  }
297 
298  switch (format) {
299  case LY_VALUE_CANON:
300  case LY_VALUE_CBOR:
301  case LY_VALUE_JSON:
302  case LY_VALUE_LYB:
303  case LY_VALUE_STR_NS:
304  /* store canonical value */
305  if (options & LYPLG_TYPE_STORE_DYNAMIC) {
306  ret = lydict_insert_zc(ctx, (char *)value, &storage->_canonical);
307  options &= ~LYPLG_TYPE_STORE_DYNAMIC;
308  LY_CHECK_GOTO(ret, cleanup);
309  } else {
310  ret = lydict_insert(ctx, value_size ? value : "", value_size, &storage->_canonical);
311  LY_CHECK_GOTO(ret, cleanup);
312  }
313  break;
314  case LY_VALUE_SCHEMA:
316  case LY_VALUE_XML:
317  /* JSON format with prefix is the canonical one */
318  ret = lyplg_type_print_xpath10_value(val, LY_VALUE_JSON, NULL, &canon, err);
319  LY_CHECK_GOTO(ret, cleanup);
320 
321  ret = lydict_insert_zc(ctx, canon, &storage->_canonical);
322  LY_CHECK_GOTO(ret, cleanup);
323  break;
324  }
325 
326 cleanup:
327  if (options & LYPLG_TYPE_STORE_DYNAMIC) {
328  free((void *)value);
329  }
330 
331  if (ret) {
332  lyplg_type_free_xpath10(ctx, storage);
333  } else if (val->format == LY_VALUE_STR_NS) {
334  /* needs validation */
335  return LY_EINCOMPLETE;
336  }
337  return ret;
338 }
339 
348 static LY_ERR
349 xpath10_add_ns(struct ly_set *set, const char *pref, const char *uri)
350 {
351  LY_ERR rc = LY_SUCCESS;
352  struct lyxml_ns *ns = NULL;
353 
354  /* create new ns */
355  ns = calloc(1, sizeof *ns);
356  if (!ns) {
357  rc = LY_EMEM;
358  goto cleanup;
359  }
360  ns->prefix = strdup(pref);
361  ns->uri = strdup(uri);
362  if (!ns->prefix || !ns->uri) {
363  rc = LY_EMEM;
364  goto cleanup;
365  }
366  ns->depth = 1;
367 
368  /* add into the XML namespace set */
369  if ((rc = ly_set_add(set, ns, 1, NULL))) {
370  goto cleanup;
371  }
372  ns = NULL;
373 
374 cleanup:
375  if (ns) {
376  free(ns->prefix);
377  free(ns->uri);
378  free(ns);
379  }
380  return rc;
381 }
382 
386 static LY_ERR
387 lyplg_type_validate_tree_xpath10(const struct ly_ctx *UNUSED(ctx), const struct lysc_type *UNUSED(type),
388  const struct lyd_node *ctx_node, const struct lyd_node *UNUSED(tree), const struct ly_ht *UNUSED(unres_ht),
389  struct lyd_value *storage, struct ly_err_item **err)
390 {
391  LY_ERR ret = LY_SUCCESS;
392  struct lyd_value_xpath10 *val;
393  struct ly_set *set = NULL;
394  uint32_t i;
395  const char *pref, *uri;
396  const struct ly_err_item *eitem;
397 
398  *err = NULL;
399  LYD_VALUE_GET(storage, val);
400 
401  if (val->format != LY_VALUE_STR_NS) {
402  /* nothing to validate */
403  return LY_SUCCESS;
404  }
405 
406  /* the XML namespace set must exist */
407  assert(val->prefix_data);
408 
409  /* special handling of this particular node */
410  assert(!strcmp(LYD_NAME(ctx_node), "parent-reference") &&
411  !strcmp(ctx_node->schema->module->name, "ietf-yang-schema-mount"));
412 
413  /* get all the prefix mappings */
414  if ((ret = lyd_find_xpath(ctx_node, "../../../namespace", &set))) {
415  goto cleanup;
416  }
417 
418  for (i = 0; i < set->count; ++i) {
419  assert(!strcmp(LYD_NAME(lyd_child(set->dnodes[i])), "prefix"));
420  pref = lyd_get_value(lyd_child(set->dnodes[i]));
421 
422  if (!lyd_child(set->dnodes[i])->next) {
423  /* missing URI - invalid mapping, skip */
424  continue;
425  }
426  assert(!strcmp(LYD_NAME(lyd_child(set->dnodes[i])->next), "uri"));
427  uri = lyd_get_value(lyd_child(set->dnodes[i])->next);
428 
429  /* new NS */
430  if ((ret = xpath10_add_ns(val->prefix_data, pref, uri))) {
431  goto cleanup;
432  }
433  }
434 
435 cleanup:
436  ly_set_free(set, NULL);
437  if (ret == LY_EMEM) {
439  } else if (ret) {
440  eitem = ly_err_last(LYD_CTX(ctx_node));
441  ly_err_new(err, ret, LYVE_DATA, eitem->data_path, NULL, "%s", eitem->msg);
442  }
443  return ret;
444 }
445 
446 LIBYANG_API_DEF const void *
447 lyplg_type_print_xpath10(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
448  void *prefix_data, ly_bool *dynamic, uint64_t *value_size_bits)
449 {
450  struct lyd_value_xpath10 *val;
451  char *ret;
452  struct ly_err_item *err = NULL;
453 
454  LYD_VALUE_GET(value, val);
455 
456  /* LY_VALUE_STR_NS should never be transformed */
457  if ((val->format == LY_VALUE_STR_NS) || (format == LY_VALUE_CANON) || (format == LY_VALUE_JSON) ||
458  (format == LY_VALUE_LYB) || (format == LY_VALUE_CBOR)) {
459  /* canonical */
460  if (dynamic) {
461  *dynamic = 0;
462  }
463  if (value_size_bits) {
464  *value_size_bits = strlen(value->_canonical) * 8;
465  }
466  return value->_canonical;
467  }
468 
469  /* print in the specific format */
470  if (lyplg_type_print_xpath10_value(val, format, prefix_data, &ret, &err)) {
471  if (err) {
472  ly_err_print(ctx, err, NULL, NULL);
473  ly_err_free(err);
474  }
475  return NULL;
476  }
477 
478  *dynamic = 1;
479  if (value_size_bits) {
480  *value_size_bits = strlen(ret) * 8;
481  }
482  return ret;
483 }
484 
485 LIBYANG_API_DEF LY_ERR
486 lyplg_type_dup_xpath10(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
487 {
488  LY_ERR ret = LY_SUCCESS;
489  struct lyd_value_xpath10 *orig_val, *dup_val;
490 
491  /* init dup value */
492  memset(dup, 0, sizeof *dup);
493  dup->realtype = original->realtype;
494 
495  ret = lydict_insert(ctx, original->_canonical, 0, &dup->_canonical);
496  LY_CHECK_GOTO(ret, cleanup);
497 
498  LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
499  LY_CHECK_ERR_GOTO(!dup_val, LOGMEM(ctx); ret = LY_EMEM, cleanup);
500  dup_val->ctx = ctx;
501 
502  LYD_VALUE_GET(original, orig_val);
503  ret = lyxp_expr_dup(ctx, orig_val->exp, 0, 0, &dup_val->exp);
504  LY_CHECK_GOTO(ret, cleanup);
505 
506  ret = lyplg_type_prefix_data_dup(ctx, orig_val->format, orig_val->prefix_data, &dup_val->prefix_data);
507  LY_CHECK_GOTO(ret, cleanup);
508  dup_val->format = orig_val->format;
509 
510 cleanup:
511  if (ret) {
513  }
514  return ret;
515 }
516 
517 LIBYANG_API_DEF void
518 lyplg_type_free_xpath10(const struct ly_ctx *ctx, struct lyd_value *value)
519 {
520  struct lyd_value_xpath10 *val;
521 
522  lydict_remove(ctx, value->_canonical);
523  value->_canonical = NULL;
524  LYD_VALUE_GET(value, val);
525  if (val) {
526  lyxp_expr_free(val->exp);
528 
530  }
531 }
532 
540 const struct lyplg_type_record plugins_xpath10[] = {
541  {
542  .module = "ietf-yang-types",
543  .revision = NULL,
544  .name = "xpath1.0",
545 
546  .plugin.id = "ly2 xpath1.0",
547  .plugin.lyb_size = lyplg_type_lyb_size_variable_bytes,
548  .plugin.store = lyplg_type_store_xpath10,
549  .plugin.validate_value = NULL,
550  .plugin.validate_tree = lyplg_type_validate_tree_xpath10,
551  .plugin.compare = lyplg_type_compare_simple,
552  .plugin.sort = lyplg_type_sort_simple,
553  .plugin.print = lyplg_type_print_xpath10,
554  .plugin.duplicate = lyplg_type_dup_xpath10,
555  .plugin.free = lyplg_type_free_xpath10,
556  },
557  {0}
558 };
libyang dictionary
libyang context handler.
#define LYD_CTX(node)
Macro to get context from a data tree node.
Definition: tree_data.h:580
LIBYANG_API_DECL LY_ERR lydict_insert(const struct ly_ctx *ctx, const char *value, size_t len, const char **str_p)
Insert string into dictionary. If the string is already present, only a reference counter is incremen...
LIBYANG_API_DECL LY_ERR lydict_remove(const struct ly_ctx *ctx, const char *value)
Remove specified string from the dictionary. It decrement reference counter for the string and if it ...
LIBYANG_API_DECL LY_ERR lydict_insert_zc(const struct ly_ctx *ctx, char *value, const char **str_p)
Insert string into dictionary - zerocopy version. If the string is already present,...
LY_ERR err
Definition: log.h:300
LY_VECODE vecode
Definition: log.h:301
char * data_path
Definition: log.h:303
char * apptag
Definition: log.h:306
char * msg
Definition: log.h:302
LIBYANG_API_DECL const struct ly_err_item * ly_err_last(const struct ly_ctx *ctx)
Get the latest (thread, context-specific) generated error structure.
LIBYANG_API_DECL void ly_err_print(const struct ly_ctx *ctx, const struct ly_err_item *eitem, const struct lyd_node *lnode, const struct lysc_node *snode)
Print the error structure as if just generated.
LY_ERR
libyang's error codes returned by the libyang functions.
Definition: log.h:252
LIBYANG_API_DECL void ly_err_clean(const struct ly_ctx *ctx, struct ly_err_item *eitem)
Free error structures from a context.
@ LYVE_DATA
Definition: log.h:290
@ LY_EMEM
Definition: log.h:254
@ LY_EVALID
Definition: log.h:260
@ LY_SUCCESS
Definition: log.h:253
@ LY_EINCOMPLETE
Definition: log.h:262
Libyang full error structure.
Definition: log.h:298
LIBYANG_API_DECL uint32_t * ly_temp_log_options(uint32_t *opts)
Set temporary thread-safe (thread-specific) logger options overwriting those set by ly_log_options().
#define LY_LOSTORE
Definition: log.h:121
uint32_t count
Definition: set.h:49
LIBYANG_API_DECL void ly_set_free(struct ly_set *set, void(*destructor)(void *obj))
Free the ly_set data. If the destructor is not provided, it frees only the set structure content,...
LIBYANG_API_DECL LY_ERR ly_set_add(struct ly_set *set, const void *object, ly_bool list, uint32_t *index_p)
Add an object into the set.
LIBYANG_API_DECL LY_ERR ly_set_new(struct ly_set **set_p)
Create and initiate new ly_set structure.
Structure to hold a set of (not necessary somehow connected) objects. Usually used for lyd_node,...
Definition: set.h:47
const char * module
#define LYPLG_TYPE_VAL_INLINE_PREPARE(storage, type_val)
Prepare value memory for storing a specific type value, may be allocated dynamically.
LIBYANG_API_DECL void ly_err_free(void *ptr)
Destructor for the error records created with ly_err_new().
LIBYANG_API_DECL LY_ERR lyplg_type_check_hints(uint32_t hints, const char *value, uint32_t value_len, LY_DATA_TYPE type, int *base, struct ly_err_item **err)
Check that the type is suitable for the parser's hints (if any) in the specified format.
LIBYANG_API_DEF LY_ERR lyplg_type_print_xpath10_value(const struct lyd_value_xpath10 *xp_val, LY_VALUE_FORMAT format, void *prefix_data, char **str_value, struct ly_err_item **err)
Print xpath1.0 value in the specific format.
Definition: xpath1.0.c:200
#define LYPLG_TYPE_VAL_INLINE_DESTROY(type_val)
Destroy a prepared value.
LIBYANG_API_DEF LY_ERR lyplg_type_xpath10_print_token(const char *token, uint16_t tok_len, ly_bool is_nametest, const struct lys_module **context_mod, const struct ly_ctx *resolve_ctx, LY_VALUE_FORMAT resolve_format, const void *resolve_prefix_data, LY_VALUE_FORMAT get_format, void *get_prefix_data, char **token_p, struct ly_err_item **err)
Print xpath1.0 token in the specific format.
Definition: xpath1.0.c:40
LIBYANG_API_DEF LY_ERR lyplg_type_dup_xpath10(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
Implementation of lyplg_type_dup_clb for the ietf-yang-types xpath1.0 type.
Definition: xpath1.0.c:486
LIBYANG_API_DECL LY_ERR lyplg_type_prefix_data_new(const struct ly_ctx *ctx, const void *value, uint32_t value_size, LY_VALUE_FORMAT format, const void *prefix_data, LY_VALUE_FORMAT *format_p, void **prefix_data_p)
Store used prefixes in a string into an internal libyang structure used in lyd_value.
LIBYANG_API_DECL const char * lyplg_type_get_prefix(const struct lys_module *mod, LY_VALUE_FORMAT format, void *prefix_data)
Get format-specific prefix for a module.
LIBYANG_API_DECL LY_ERR lyplg_type_check_value_size(const char *type_name, LY_VALUE_FORMAT format, uint64_t value_size_bits, enum lyplg_lyb_size_type lyb_size_type, uint64_t lyb_fixed_size_bits, uint32_t *value_size, struct ly_err_item **err)
Check a value type in bits is correct and as expected.
LIBYANG_API_DEF const void * lyplg_type_print_xpath10(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format, void *prefix_data, ly_bool *dynamic, uint64_t *value_size_bits)
Implementation of lyplg_type_print_clb for the ietf-yang-types xpath1.0 type.
Definition: xpath1.0.c:447
LIBYANG_API_DECL LY_ERR ly_err_new(struct ly_err_item **err, LY_ERR ecode, LY_VECODE vecode, char *data_path, char *apptag, const char *err_format,...) _FORMAT_PRINTF(6
Create and fill an error structure.
LIBYANG_API_DEF void lyplg_type_free_xpath10(const struct ly_ctx *ctx, struct lyd_value *value)
Implementation of lyplg_type_free_clb for the ietf-yang-types xpath1.0 type.
Definition: xpath1.0.c:518
LIBYANG_API_DECL LY_ERR lyplg_type_prefix_data_dup(const struct ly_ctx *ctx, LY_VALUE_FORMAT format, const void *orig, void **dup)
Duplicate prefix data.
LIBYANG_API_DECL LY_ERR LIBYANG_API_DECL LY_ERR ly_err_new_no_mem(struct ly_err_item **err)
Create and fill an error structure with a no-memory error.
LIBYANG_API_DECL void lyplg_type_prefix_data_free(LY_VALUE_FORMAT format, void *prefix_data)
Free internal prefix data.
@ LYPLG_LYB_SIZE_VARIABLE_BYTES
LIBYANG_API_DEF int lyplg_type_sort_simple(const struct ly_ctx *ctx, const struct lyd_value *val1, const struct lyd_value *val2)
Implementation of lyplg_type_sort_clb for a generic simple type.
LIBYANG_API_DECL LY_ERR lyplg_type_compare_simple(const struct ly_ctx *ctx, const struct lyd_value *val1, const struct lyd_value *val2)
Implementation of lyplg_type_compare_clb for a generic simple type.
LIBYANG_API_DECL void lyplg_type_lyb_size_variable_bytes(const struct lysc_type *type, enum lyplg_lyb_size_type *size_type, uint64_t *fixed_size_bits)
Implementation of lyplg_type_lyb_size_clb for a type with variable length rounded to bytes.
#define LYPLG_TYPE_STORE_DYNAMIC
const char * name
Definition: tree_schema.h:2244
LY_DATA_TYPE basetype
Definition: tree_schema.h:1278
struct lys_module * module
Definition: tree_schema.h:1416
const char * name
Definition: tree_schema.h:1423
const char * prefix
Definition: tree_schema.h:2247
LIBYANG_API_DECL const struct lys_module * lys_find_module(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *prefix, uint32_t prefix_len, LY_VALUE_FORMAT format, const void *prefix_data)
Find a module matching a prefix (or a default one).
Available YANG schema tree structures representing YANG module.
Definition: tree_schema.h:2242
Compiled YANG data node.
Definition: tree_schema.h:1412
uint8_t ly_bool
Type to indicate boolean value.
Definition: log.h:29
libyang hash table.
API for (user) types plugins.
LIBYANG_API_DECL LY_ERR lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
Search in the given data for instances of nodes matching the provided XPath.
const struct lysc_type * realtype
Definition: tree_data.h:614
const struct lysc_node * schema
Definition: tree_data.h:881
struct lyxp_expr * exp
Definition: tree_data.h:788
#define LYD_NAME(node)
Get the name (associated with) of a data node. Works for opaque nodes as well.
Definition: tree_data.h:992
LY_VALUE_FORMAT format
Definition: tree_data.h:791
const struct ly_ctx * ctx
Definition: tree_data.h:789
#define LYD_VALUE_GET(value, type_val)
Get the value in format specific to the type.
Definition: tree_data.h:653
const char * _canonical
Definition: tree_data.h:611
void * prefix_data
Definition: tree_data.h:790
Generic structure for a data node.
Definition: tree_data.h:875
YANG data representation.
Definition: tree_data.h:610
Special lyd_value structure for ietf-yang-types xpath1.0 values.
Definition: tree_data.h:787
LY_VALUE_FORMAT
All kinds of supported value formats and prefix mappings to modules.
Definition: utils.h:93
@ LY_VALUE_JSON
Definition: utils.h:98
@ LY_VALUE_SCHEMA
Definition: utils.h:95
@ LY_VALUE_CBOR
Definition: utils.h:99
@ LY_VALUE_CANON
Definition: utils.h:94
@ LY_VALUE_XML
Definition: utils.h:97
@ LY_VALUE_STR_NS
Definition: utils.h:101
@ LY_VALUE_SCHEMA_RESOLVED
Definition: utils.h:96
@ LY_VALUE_LYB
Definition: utils.h:100
const struct lyplg_type_record plugins_xpath10[]
Plugin information for xpath1.0 type implementation.
Definition: xpath1.0.c:540