libyang  4.0.2
libyang is YANG data modelling language parser and toolkit written (and providing API) in C.
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "libyang.h"
25 
26 #include "compat.h"
27 #include "ly_common.h"
28 #include "xml.h"
29 #include "xpath.h"
30 
40 LIBYANG_API_DEF LY_ERR
41 lyplg_type_xpath10_print_token(const char *token, uint16_t tok_len, ly_bool is_nametest, const struct lys_module **context_mod,
42  const struct ly_ctx *resolve_ctx, LY_VALUE_FORMAT resolve_format, const void *resolve_prefix_data,
43  LY_VALUE_FORMAT get_format, void *get_prefix_data, char **token_p, struct ly_err_item **err)
44 {
45  LY_ERR ret = LY_SUCCESS;
46  const char *str_begin, *str_next, *prefix;
47  ly_bool is_prefix, has_prefix = 0;
48  char *str = NULL;
49  void *mem;
50  uint32_t len, str_len = 0, pref_len;
51  const struct lys_module *mod;
52 
53  str_begin = token;
54 
55  while (!(ret = ly_value_prefix_next(str_begin, token + tok_len, &len, &is_prefix, &str_next)) && len) {
56  if (!is_prefix) {
57  if (!has_prefix && is_nametest && (get_format == LY_VALUE_XML) && *context_mod) {
58  /* get the prefix */
59  prefix = lyplg_type_get_prefix(*context_mod, get_format, get_prefix_data);
60  assert(prefix);
61 
62  /* append the nametest and prefix */
63  mem = realloc(str, str_len + strlen(prefix) + 1 + len + 1);
64  LY_CHECK_ERR_GOTO(!mem, ret = ly_err_new(err, LY_EMEM, LYVE_DATA, NULL, NULL, "No memory."), cleanup);
65  str = mem;
66  str_len += sprintf(str + str_len, "%s:%.*s", prefix, (int)len, str_begin);
67  } else {
68  /* just append the string, we may get the first expression node without a prefix but since this
69  * is not strictly forbidden, allow it */
70  mem = realloc(str, str_len + len + 1);
71  LY_CHECK_ERR_GOTO(!mem, ret = ly_err_new(err, LY_EMEM, LYVE_DATA, NULL, NULL, "No memory."), cleanup);
72  str = mem;
73  str_len += sprintf(str + str_len, "%.*s", (int)len, str_begin);
74  }
75  } else {
76  /* remember there was a prefix found */
77  has_prefix = 1;
78 
79  /* resolve the module in the original format */
80  mod = lyplg_type_identity_module(resolve_ctx, NULL, str_begin, len, resolve_format, resolve_prefix_data);
81  if (!mod && is_nametest) {
82  ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Failed to resolve prefix \"%.*s\".",
83  (int)len, str_begin);
84  goto cleanup;
85  }
86 
87  if (is_nametest && ((get_format == LY_VALUE_JSON) || (get_format == LY_VALUE_LYB)) && (*context_mod == mod)) {
88  /* inherit the prefix and do not print it again */
89  } else {
90  if (mod) {
91  /* get the prefix in the target format */
92  prefix = lyplg_type_get_prefix(mod, get_format, get_prefix_data);
93  assert(prefix);
94  pref_len = strlen(prefix);
95  } else {
96  /* invalid prefix, just copy it */
97  prefix = str_begin;
98  pref_len = len;
99  }
100 
101  /* append the prefix */
102  mem = realloc(str, str_len + pref_len + 2);
103  LY_CHECK_ERR_GOTO(!mem, ret = ly_err_new(err, LY_EMEM, LYVE_DATA, NULL, NULL, "No memory."), cleanup);
104  str = mem;
105  str_len += sprintf(str + str_len, "%.*s:", (int)pref_len, prefix);
106  }
107 
108  if (is_nametest) {
109  /* update context module */
110  *context_mod = mod;
111  }
112  }
113 
114  str_begin = str_next;
115  }
116 
117 cleanup:
118  if (ret) {
119  free(str);
120  } else {
121  *token_p = str;
122  }
123  return ret;
124 }
125 
141 static LY_ERR
142 xpath10_print_subexpr_r(uint16_t *cur_idx, enum lyxp_token end_tok, const struct lys_module *context_mod,
143  const struct lyd_value_xpath10 *xp_val, LY_VALUE_FORMAT format, void *prefix_data, char **str_value,
144  uint32_t *str_len, struct ly_err_item **err)
145 {
146  enum lyxp_token cur_tok, sub_end_tok;
147  char *str_tok;
148  void *mem;
149  const char *cur_exp_ptr;
150  ly_bool is_nt;
151  const struct lys_module *orig_context_mod = context_mod;
152 
153  while (*cur_idx < xp_val->exp->used) {
154  cur_tok = xp_val->exp->tokens[*cur_idx];
155  cur_exp_ptr = xp_val->exp->expr + xp_val->exp->tok_pos[*cur_idx];
156 
157  if ((cur_tok == LYXP_TOKEN_NAMETEST) || (cur_tok == LYXP_TOKEN_LITERAL)) {
158  /* tokens that may include prefixes, get them in the target format */
159  is_nt = (cur_tok == LYXP_TOKEN_NAMETEST) ? 1 : 0;
160  LY_CHECK_RET(lyplg_type_xpath10_print_token(cur_exp_ptr, xp_val->exp->tok_len[*cur_idx], is_nt, &context_mod,
161  xp_val->ctx, xp_val->format, xp_val->prefix_data, format, prefix_data, &str_tok, err));
162 
163  /* append the converted token */
164  mem = realloc(*str_value, *str_len + strlen(str_tok) + 1);
165  LY_CHECK_ERR_GOTO(!mem, free(str_tok), error_mem);
166  *str_value = mem;
167  *str_len += sprintf(*str_value + *str_len, "%s", str_tok);
168  free(str_tok);
169 
170  /* token processed */
171  ++(*cur_idx);
172  } else {
173  if ((cur_tok == LYXP_TOKEN_OPER_LOG) || (cur_tok == LYXP_TOKEN_OPER_UNI) || (cur_tok == LYXP_TOKEN_OPER_MATH)) {
174  /* copy the token with spaces around */
175  mem = realloc(*str_value, *str_len + 1 + xp_val->exp->tok_len[*cur_idx] + 2);
176  LY_CHECK_GOTO(!mem, error_mem);
177  *str_value = mem;
178  *str_len += sprintf(*str_value + *str_len, " %.*s ", (int)xp_val->exp->tok_len[*cur_idx], cur_exp_ptr);
179 
180  /* reset context mod */
181  context_mod = orig_context_mod;
182  } else {
183  /* just copy the token */
184  mem = realloc(*str_value, *str_len + xp_val->exp->tok_len[*cur_idx] + 1);
185  LY_CHECK_GOTO(!mem, error_mem);
186  *str_value = mem;
187  *str_len += sprintf(*str_value + *str_len, "%.*s", (int)xp_val->exp->tok_len[*cur_idx], cur_exp_ptr);
188  }
189 
190  /* token processed but keep it in cur_tok */
191  ++(*cur_idx);
192 
193  if (end_tok && (cur_tok == end_tok)) {
194  /* end token found */
195  break;
196  } else if ((cur_tok == LYXP_TOKEN_BRACK1) || (cur_tok == LYXP_TOKEN_PAR1)) {
197  sub_end_tok = (cur_tok == LYXP_TOKEN_BRACK1) ? LYXP_TOKEN_BRACK2 : LYXP_TOKEN_PAR2;
198 
199  /* parse the subexpression separately, use the current context mod */
200  LY_CHECK_RET(xpath10_print_subexpr_r(cur_idx, sub_end_tok, context_mod, xp_val, format, prefix_data,
201  str_value, str_len, err));
202  }
203  }
204  }
205 
206  return LY_SUCCESS;
207 
208 error_mem:
209  return ly_err_new(err, LY_EMEM, LYVE_DATA, NULL, NULL, "No memory.");
210 }
211 
212 LIBYANG_API_DEF LY_ERR
213 lyplg_type_print_xpath10_value(const struct lyd_value_xpath10 *xp_val, LY_VALUE_FORMAT format, void *prefix_data,
214  char **str_value, struct ly_err_item **err)
215 {
216  LY_ERR ret = LY_SUCCESS;
217  uint16_t expr_idx = 0;
218  uint32_t str_len = 0;
219  const struct lys_module *local_mod = NULL;
220  struct ly_set *mods;
221 
222  *str_value = NULL;
223  *err = NULL;
224 
225  if (format == LY_VALUE_XML) {
226  /* null the local module so that all the prefixes are printed */
227  mods = prefix_data;
228  local_mod = mods->objs[0];
229  mods->objs[0] = NULL;
230  }
231 
232  /* recursively print the expression */
233  ret = xpath10_print_subexpr_r(&expr_idx, 0, NULL, xp_val, format, prefix_data, str_value, &str_len, err);
234 
235  if (local_mod) {
236  mods->objs[0] = (void *)local_mod;
237  }
238  if (ret) {
239  free(*str_value);
240  *str_value = NULL;
241  }
242  return ret;
243 }
244 
245 static LY_ERR
246 lyplg_type_store_xpath10(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, uint32_t value_size_bits,
247  uint32_t options, LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
248  const struct lysc_ext_instance *UNUSED(top_ext), struct lyd_value *storage, struct lys_glob_unres *UNUSED(unres),
249  struct ly_err_item **err)
250 {
251  LY_ERR ret = LY_SUCCESS;
252  uint32_t value_size;
253  struct lyd_value_xpath10 *val;
254  char *canon;
255 
256  /* init storage */
257  memset(storage, 0, sizeof *storage);
258  LYPLG_TYPE_VAL_INLINE_PREPARE(storage, val);
259  LY_CHECK_ERR_GOTO(!val, ret = LY_EMEM, cleanup);
260  storage->realtype = type;
261 
262  /* check value length */
263  ret = lyplg_type_check_value_size("xpath1.0", format, value_size_bits, LYPLG_LYB_SIZE_VARIABLE_BYTES, 0,
264  &value_size, err);
265  LY_CHECK_GOTO(ret, cleanup);
266 
267  /* check hints */
268  ret = lyplg_type_check_hints(hints, value, value_size, type->basetype, NULL, err);
269  LY_CHECK_GOTO(ret, cleanup);
270 
271  /* parse */
272  ret = lyxp_expr_parse(ctx, value_size ? value : "", value_size, 1, &val->exp);
273  LY_CHECK_GOTO(ret, cleanup);
274  val->ctx = ctx;
275 
276  if (ctx_node && !strcmp(ctx_node->name, "parent-reference") && !strcmp(ctx_node->module->name, "ietf-yang-schema-mount")) {
277  /* special case, this type uses prefix-namespace mapping provided directly in data, keep empty for now */
278  val->format = format = LY_VALUE_STR_NS;
279  ret = ly_set_new((struct ly_set **)&val->prefix_data);
280  LY_CHECK_GOTO(ret, cleanup);
281  } else {
282  /* store format-specific data and context for later prefix resolution */
283  ret = lyplg_type_prefix_data_new(ctx, value, value_size, format, prefix_data, &val->format, &val->prefix_data);
284  LY_CHECK_GOTO(ret, cleanup);
285  }
286 
287  switch (format) {
288  case LY_VALUE_CANON:
289  case LY_VALUE_JSON:
290  case LY_VALUE_LYB:
291  case LY_VALUE_STR_NS:
292  /* store canonical value */
293  if (options & LYPLG_TYPE_STORE_DYNAMIC) {
294  ret = lydict_insert_zc(ctx, (char *)value, &storage->_canonical);
295  options &= ~LYPLG_TYPE_STORE_DYNAMIC;
296  LY_CHECK_GOTO(ret, cleanup);
297  } else {
298  ret = lydict_insert(ctx, value_size ? value : "", value_size, &storage->_canonical);
299  LY_CHECK_GOTO(ret, cleanup);
300  }
301  break;
302  case LY_VALUE_SCHEMA:
304  case LY_VALUE_XML:
305  /* JSON format with prefix is the canonical one */
306  ret = lyplg_type_print_xpath10_value(val, LY_VALUE_JSON, NULL, &canon, err);
307  LY_CHECK_GOTO(ret, cleanup);
308 
309  ret = lydict_insert_zc(ctx, canon, &storage->_canonical);
310  LY_CHECK_GOTO(ret, cleanup);
311  break;
312  }
313 
314 cleanup:
315  if (options & LYPLG_TYPE_STORE_DYNAMIC) {
316  free((void *)value);
317  }
318 
319  if (ret) {
320  lyplg_type_free_xpath10(ctx, storage);
321  } else if (val->format == LY_VALUE_STR_NS) {
322  /* needs validation */
323  return LY_EINCOMPLETE;
324  }
325  return ret;
326 }
327 
336 static LY_ERR
337 xpath10_add_ns(struct ly_set *set, const char *pref, const char *uri)
338 {
339  LY_ERR rc = LY_SUCCESS;
340  struct lyxml_ns *ns = NULL;
341 
342  /* create new ns */
343  ns = calloc(1, sizeof *ns);
344  if (!ns) {
345  rc = LY_EMEM;
346  goto cleanup;
347  }
348  ns->prefix = strdup(pref);
349  ns->uri = strdup(uri);
350  if (!ns->prefix || !ns->uri) {
351  rc = LY_EMEM;
352  goto cleanup;
353  }
354  ns->depth = 1;
355 
356  /* add into the XML namespace set */
357  if ((rc = ly_set_add(set, ns, 1, NULL))) {
358  goto cleanup;
359  }
360  ns = NULL;
361 
362 cleanup:
363  if (ns) {
364  free(ns->prefix);
365  free(ns->uri);
366  free(ns);
367  }
368  return rc;
369 }
370 
374 static LY_ERR
375 lyplg_type_validate_tree_xpath10(const struct ly_ctx *UNUSED(ctx), const struct lysc_type *UNUSED(type),
376  const struct lyd_node *ctx_node, const struct lyd_node *UNUSED(tree), const struct lysc_ext_instance *UNUSED(top_ext),
377  struct lyd_value *storage, struct ly_err_item **err)
378 {
379  LY_ERR ret = LY_SUCCESS;
380  struct lyd_value_xpath10 *val;
381  struct ly_set *set = NULL;
382  uint32_t i;
383  const char *pref, *uri;
384  const struct ly_err_item *eitem;
385 
386  *err = NULL;
387  LYD_VALUE_GET(storage, val);
388 
389  if (val->format != LY_VALUE_STR_NS) {
390  /* nothing to validate */
391  return LY_SUCCESS;
392  }
393 
394  /* the XML namespace set must exist */
395  assert(val->prefix_data);
396 
397  /* special handling of this particular node */
398  assert(!strcmp(LYD_NAME(ctx_node), "parent-reference") &&
399  !strcmp(ctx_node->schema->module->name, "ietf-yang-schema-mount"));
400 
401  /* get all the prefix mappings */
402  if ((ret = lyd_find_xpath(ctx_node, "../../../namespace", &set))) {
403  goto cleanup;
404  }
405 
406  for (i = 0; i < set->count; ++i) {
407  assert(!strcmp(LYD_NAME(lyd_child(set->dnodes[i])), "prefix"));
408  pref = lyd_get_value(lyd_child(set->dnodes[i]));
409 
410  if (!lyd_child(set->dnodes[i])->next) {
411  /* missing URI - invalid mapping, skip */
412  continue;
413  }
414  assert(!strcmp(LYD_NAME(lyd_child(set->dnodes[i])->next), "uri"));
415  uri = lyd_get_value(lyd_child(set->dnodes[i])->next);
416 
417  /* new NS */
418  if ((ret = xpath10_add_ns(val->prefix_data, pref, uri))) {
419  goto cleanup;
420  }
421  }
422 
423 cleanup:
424  ly_set_free(set, NULL);
425  if (ret == LY_EMEM) {
426  ly_err_new(err, LY_EMEM, LYVE_DATA, NULL, NULL, LY_EMEM_MSG);
427  } else if (ret) {
428  eitem = ly_err_last(LYD_CTX(ctx_node));
429  ly_err_new(err, ret, LYVE_DATA, eitem->data_path, NULL, "%s", eitem->msg);
430  }
431  return ret;
432 }
433 
434 LIBYANG_API_DEF const void *
435 lyplg_type_print_xpath10(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
436  void *prefix_data, ly_bool *dynamic, uint32_t *value_size_bits)
437 {
438  struct lyd_value_xpath10 *val;
439  char *ret;
440  struct ly_err_item *err = NULL;
441 
442  LYD_VALUE_GET(value, val);
443 
444  /* LY_VALUE_STR_NS should never be transformed */
445  if ((val->format == LY_VALUE_STR_NS) || (format == LY_VALUE_CANON) || (format == LY_VALUE_JSON) ||
446  (format == LY_VALUE_LYB)) {
447  /* canonical */
448  if (dynamic) {
449  *dynamic = 0;
450  }
451  if (value_size_bits) {
452  *value_size_bits = strlen(value->_canonical) * 8;
453  }
454  return value->_canonical;
455  }
456 
457  /* print in the specific format */
458  if (lyplg_type_print_xpath10_value(val, format, prefix_data, &ret, &err)) {
459  if (err) {
460  ly_err_print(ctx, err);
461  ly_err_free(err);
462  }
463  return NULL;
464  }
465 
466  *dynamic = 1;
467  if (value_size_bits) {
468  *value_size_bits = strlen(ret) * 8;
469  }
470  return ret;
471 }
472 
473 LIBYANG_API_DEF LY_ERR
474 lyplg_type_dup_xpath10(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
475 {
476  LY_ERR ret = LY_SUCCESS;
477  struct lyd_value_xpath10 *orig_val, *dup_val;
478 
479  /* init dup value */
480  memset(dup, 0, sizeof *dup);
481  dup->realtype = original->realtype;
482 
483  ret = lydict_insert(ctx, original->_canonical, 0, &dup->_canonical);
484  LY_CHECK_GOTO(ret, cleanup);
485 
486  LYPLG_TYPE_VAL_INLINE_PREPARE(dup, dup_val);
487  LY_CHECK_ERR_GOTO(!dup_val, LOGMEM(ctx); ret = LY_EMEM, cleanup);
488  dup_val->ctx = ctx;
489 
490  LYD_VALUE_GET(original, orig_val);
491  ret = lyxp_expr_dup(ctx, orig_val->exp, 0, 0, &dup_val->exp);
492  LY_CHECK_GOTO(ret, cleanup);
493 
494  ret = lyplg_type_prefix_data_dup(ctx, orig_val->format, orig_val->prefix_data, &dup_val->prefix_data);
495  LY_CHECK_GOTO(ret, cleanup);
496  dup_val->format = orig_val->format;
497 
498 cleanup:
499  if (ret) {
500  lyplg_type_free_xpath10(ctx, dup);
501  }
502  return ret;
503 }
504 
505 LIBYANG_API_DEF void
506 lyplg_type_free_xpath10(const struct ly_ctx *ctx, struct lyd_value *value)
507 {
508  struct lyd_value_xpath10 *val;
509 
510  lydict_remove(ctx, value->_canonical);
511  value->_canonical = NULL;
512  LYD_VALUE_GET(value, val);
513  if (val) {
514  lyxp_expr_free(val->exp);
516 
518  }
519 }
520 
529  {
530  .module = "ietf-yang-types",
531  .revision = "2013-07-15",
532  .name = "xpath1.0",
533 
534  .plugin.id = "ly2 xpath1.0",
535  .plugin.lyb_size = lyplg_type_lyb_size_variable_bytes,
536  .plugin.store = lyplg_type_store_xpath10,
537  .plugin.validate_value = NULL,
538  .plugin.validate_tree = lyplg_type_validate_tree_xpath10,
539  .plugin.compare = lyplg_type_compare_simple,
540  .plugin.sort = lyplg_type_sort_simple,
541  .plugin.print = lyplg_type_print_xpath10,
542  .plugin.duplicate = lyplg_type_dup_xpath10,
543  .plugin.free = lyplg_type_free_xpath10,
544  },
545  {0}
546 };
struct lysc_type * realtype
Definition: tree_data.h:567
Compiled YANG data node.
Definition: tree_schema.h:1434
memset(value->fixed_mem, 0, LYD_VALUE_FIXED_MEM_SIZE)
LIBYANG_API_DECL LY_ERR lyplg_type_check_value_size(const char *type_name, LY_VALUE_FORMAT format, uint32_t value_size_bits, enum lyplg_lyb_size_type lyb_size_type, uint32_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.
Generic structure for a data node.
Definition: tree_data.h:792
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.
YANG extension compiled instance.
Definition: plugins_exts.h:436
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.
LY_ERR
libyang&#39;s error codes returned by the libyang functions.
Definition: log.h:240
uint8_t ly_bool
Type to indicate boolean value.
Definition: log.h:28
const char * name
Definition: tree_schema.h:1445
#define LYPLG_TYPE_STORE_DYNAMIC
#define LOGMEM(CTX)
Definition: tree_edit.h:22
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.
char * msg
Definition: log.h:289
void * prefix_data
Definition: tree_data.h:712
LIBYANG_API_DECL 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:474
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 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 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...
struct lysc_node * schema
Definition: tree_data.h:798
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.
LYPLG_TYPE_VAL_INLINE_DESTROY(val)
Definition: log.h:242
The main libyang public header.
LIBYANG_API_DECL void lyplg_type_lyb_size_variable_bytes(const struct lysc_type *type, enum lyplg_lyb_size_type *size_type, uint32_t *fixed_size_bits)
Implementation of lyplg_type_lyb_size_clb for a type with variable length rounded to bytes...
YANG data representation.
Definition: tree_data.h:563
const char * _canonical
Definition: tree_data.h:564
uint32_t count
Definition: set.h:49
Libyang full error structure.
Definition: log.h:285
struct ly_ctx * ctx
Definition: tree_data.h:711
Definition: log.h:277
#define LYD_VALUE_GET(value, type_val)
Get the value in format specific to the type.
Definition: tree_data.h:606
LIBYANG_API_DECL LY_ERR LIBYANG_API_DECL void ly_err_free(void *ptr)
Destructor for the error records created with ly_err_new().
LIBYANG_API_DECL struct lys_module * lyplg_type_identity_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)
Get the corresponding module for the identity value.
struct lyplg_type_record plugins_xpath10[]
Plugin information for xpath1.0 type implementation.
Definition: xpath1.0.c:528
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 error structure.
#define LYD_NAME(node)
Get the name (associated with) of a data node. Works for opaque nodes as well.
Definition: tree_data.h:917
LIBYANG_API_DECL void ly_err_print(const struct ly_ctx *ctx, const struct ly_err_item *eitem)
Print the error structure as if just generated.
Structure to hold a set of (not necessary somehow connected) objects. Usually used for lyd_node...
Definition: set.h:47
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(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...
Available YANG schema tree structures representing YANG module.
Definition: tree_schema.h:2184
LIBYANG_API_DECL 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, uint32_t *value_len)
Implementation of lyplg_type_print_clb for the ietf-yang-types xpath1.0 type.
Definition: xpath1.0.c:435
Definition: log.h:248
const char * module
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 void lyplg_type_prefix_data_free(LY_VALUE_FORMAT format, void *prefix_data)
Free internal prefix data.
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, only a reference counter is incremented and no memory allocation is performed. This insert function variant avoids duplication of specified value - it is inserted into the dictionary directly.
struct lys_module * module
Definition: tree_schema.h:1438
Special lyd_value structure for ietf-yang-types xpath1.0 values.
Definition: tree_data.h:709
#define LYD_CTX(node)
Macro to get context from a data tree node.
Definition: tree_data.h:519
LIBYANG_API_DECL 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:213
LY_VALUE_FORMAT format
Definition: tree_data.h:713
LY_VALUE_FORMAT
All kinds of supported value formats and prefix mappings to modules.
Definition: tree.h:234
LIBYANG_API_DECL struct ly_err_item * ly_err_last(const struct ly_ctx *ctx)
Get the latest (thread, context-specific) generated error structure.
#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 LY_ERR ly_set_new(struct ly_set **set_p)
Create and initiate new ly_set structure.
LIBYANG_API_DECL 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:506
LY_DATA_TYPE basetype
Definition: tree_schema.h:1300
LIBYANG_API_DECL 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:41
struct lyxp_expr * exp
Definition: tree_data.h:710
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&#39;s hints (if any) in the specified format.
API for (user) types plugins.
libyang context handler.
const char * name
Definition: tree_schema.h:2186
char * data_path
Definition: log.h:290
assert(!value->_canonical)