forked from sysrepo/sysrepo
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathsysrepo.h
1992 lines (1815 loc) · 97.2 KB
/
sysrepo.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/**
* @file sysrepo.h
* @author Rastislav Szabo <raszabo@cisco.com>, Lukas Macko <lmacko@cisco.com>
* @brief Sysrepo Client Library public API.
*
* @copyright
* Copyright 2015 Cisco Systems, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SYSREPO_H_
#define SYSREPO_H_
/**
* @defgroup cl Client Library
* @{
*
* @brief Provides the public API towards applications using sysrepo to store
* their configuration data, or towards management agents.
*
* Communicates with Sysrepo Engine (@ref cm), which is running either inside
* of dedicated sysrepo daemon, or within this library if daemon is not alive.
*
* Access to the sysrepo datastore is connection- and session- oriented. Before
* calling any data access/manipulation API, one needs to connect to the datastore
* via ::sr_connect and open a session via ::sr_session_start. One connection
* can serve multiple sessions.
*
* Each data access/manipulation request call is blocking - blocks the connection
* until the response from Sysrepo Engine comes, or until an error occurs. It is
* safe to call multiple requests on the same session (or different session that
* belongs to the same connection) from multiple threads at the same time,
* however it is not effective, since each call is blocked until previous one
* finishes. If you need fast multi-threaded access to sysrepo, use a dedicated
* connection for each thread.
*
* @see
* See @ref main_page "Sysrepo Introduction" for details about sysrepo architecture.
* @see
* @ref xp_page "XPath Addressing" is used for node identification in data-related calls.
*/
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>
#ifdef __APPLE__
#include <sys/types.h>
#endif
////////////////////////////////////////////////////////////////////////////////
// Common typedefs and API
////////////////////////////////////////////////////////////////////////////////
/**
* @brief Sysrepo connection context used to identify a connection to sysrepo datastore.
*/
typedef struct sr_conn_ctx_s sr_conn_ctx_t;
/**
* @brief Sysrepo session context used to identify a configuration session.
*/
typedef struct sr_session_ctx_s sr_session_ctx_t;
/**
* @brief Memory context used for efficient memory management for values, trees and GPB messages.
*/
typedef struct sr_mem_ctx_s sr_mem_ctx_t;
/**
* @brief Possible types of an data element stored in the sysrepo datastore.
*/
typedef enum sr_type_e {
/* special types that does not contain any data */
SR_UNKNOWN_T, /**< Element unknown to sysrepo (unsupported element). */
SR_TREE_ITERATOR_T, /**< Special type of tree node used to store all data needed for iterative tree loading. */
SR_LIST_T, /**< List instance. ([RFC 6020 sec 7.8](http://tools.ietf.org/html/rfc6020#section-7.8)) */
SR_CONTAINER_T, /**< Non-presence container. ([RFC 6020 sec 7.5](http://tools.ietf.org/html/rfc6020#section-7.5)) */
SR_CONTAINER_PRESENCE_T, /**< Presence container. ([RFC 6020 sec 7.5.1](http://tools.ietf.org/html/rfc6020#section-7.5.1)) */
SR_LEAF_EMPTY_T, /**< A leaf that does not hold any value ([RFC 6020 sec 9.11](http://tools.ietf.org/html/rfc6020#section-9.11)) */
/* types containing some data */
SR_BINARY_T, /**< Base64-encoded binary data ([RFC 6020 sec 9.8](http://tools.ietf.org/html/rfc6020#section-9.8)) */
SR_BITS_T, /**< A set of bits or flags ([RFC 6020 sec 9.7](http://tools.ietf.org/html/rfc6020#section-9.7)) */
SR_BOOL_T, /**< A boolean value ([RFC 6020 sec 9.5](http://tools.ietf.org/html/rfc6020#section-9.5)) */
SR_DECIMAL64_T, /**< 64-bit signed decimal number ([RFC 6020 sec 9.3](http://tools.ietf.org/html/rfc6020#section-9.3)) */
SR_ENUM_T, /**< A string from enumerated strings list ([RFC 6020 sec 9.6](http://tools.ietf.org/html/rfc6020#section-9.6)) */
SR_IDENTITYREF_T, /**< A reference to an abstract identity ([RFC 6020 sec 9.10](http://tools.ietf.org/html/rfc6020#section-9.10)) */
SR_INSTANCEID_T, /**< References a data tree node ([RFC 6020 sec 9.13](http://tools.ietf.org/html/rfc6020#section-9.13)) */
SR_INT8_T, /**< 8-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_INT16_T, /**< 16-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_INT32_T, /**< 32-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_INT64_T, /**< 64-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_STRING_T, /**< Human-readable string ([RFC 6020 sec 9.4](http://tools.ietf.org/html/rfc6020#section-9.4)) */
SR_UINT8_T, /**< 8-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_UINT16_T, /**< 16-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_UINT32_T, /**< 32-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_UINT64_T, /**< 64-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
SR_ANYXML_T, /**< Unknown chunk of XML ([RFC 6020 sec 7.10](https://tools.ietf.org/html/rfc6020#section-7.10)) */
SR_ANYDATA_T, /**< Unknown set of nodes, encoded in XML ([RFC 7950 sec 7.10](https://tools.ietf.org/html/rfc7950#section-7.10)) */
} sr_type_t;
/**
* @brief Data of an element (if applicable), properly set according to the type.
*/
typedef union sr_data_u {
char *binary_val; /**< Base64-encoded binary data ([RFC 6020 sec 9.8](http://tools.ietf.org/html/rfc6020#section-9.8)) */
char *bits_val; /**< A set of bits or flags ([RFC 6020 sec 9.7](http://tools.ietf.org/html/rfc6020#section-9.7)) */
bool bool_val; /**< A boolean value ([RFC 6020 sec 9.5](http://tools.ietf.org/html/rfc6020#section-9.5)) */
double decimal64_val; /**< 64-bit signed decimal number ([RFC 6020 sec 9.3](http://tools.ietf.org/html/rfc6020#section-9.3)) */
char *enum_val; /**< A string from enumerated strings list ([RFC 6020 sec 9.6](http://tools.ietf.org/html/rfc6020#section-9.6)) */
char *identityref_val; /**< A reference to an abstract identity ([RFC 6020 sec 9.10](http://tools.ietf.org/html/rfc6020#section-9.10)) */
char *instanceid_val; /**< References a data tree node ([RFC 6020 sec 9.13](http://tools.ietf.org/html/rfc6020#section-9.13)) */
int8_t int8_val; /**< 8-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
int16_t int16_val; /**< 16-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
int32_t int32_val; /**< 32-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
int64_t int64_val; /**< 64-bit signed integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
char *string_val; /**< Human-readable string ([RFC 6020 sec 9.4](http://tools.ietf.org/html/rfc6020#section-9.4)) */
uint8_t uint8_val; /**< 8-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
uint16_t uint16_val; /**< 16-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
uint32_t uint32_val; /**< 32-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
uint64_t uint64_val; /**< 64-bit unsigned integer ([RFC 6020 sec 9.2](http://tools.ietf.org/html/rfc6020#section-9.2)) */
char *anyxml_val; /**< Unknown chunk of XML ([RFC 6020 sec 7.10](https://tools.ietf.org/html/rfc6020#section-7.10)) */
char *anydata_val; /**< Unknown set of nodes, encoded in XML ([RFC 7950 sec 7.10](https://tools.ietf.org/html/rfc7950#section-7.10)) */
} sr_data_t;
/**
* @brief Structure that contains value of an data element stored in the sysrepo datastore.
*/
typedef struct sr_val_s {
/**
* Memory context used internally by Sysrepo for efficient storage
* and conversion of this structure.
*/
sr_mem_ctx_t *_sr_mem;
/**
* XPath identifier of the data element, as defined in
* @ref xp_page "Path Addressing" documentation
*/
char *xpath;
/** Type of an element. */
sr_type_t type;
/**
* Flag for node with default value (applicable only for leaves).
* It is set to TRUE only if the value was *implicitly* set by the datastore as per
* module schema. Explicitly set/modified data element (through the sysrepo API) always
* has this flag unset regardless of the entered value.
*/
bool dflt;
/** Data of an element (if applicable), properly set according to the type. */
sr_data_t data;
} sr_val_t;
/**
* @brief A data element stored in the sysrepo datastore represented as a tree node.
*
* @note Can be safely casted to ::sr_val_t, only *xpath* member will point to node name rather
* than to an actual xpath.
*/
typedef struct sr_node_s {
/**
* Memory context used internally by Sysrepo for efficient storage
* and conversion of this structure.
*/
sr_mem_ctx_t *_sr_mem;
/** Name of the node. */
char *name;
/** Type of an element. */
sr_type_t type;
/** Flag for default node (applicable only for leaves). */
bool dflt;
/** Data of an element (if applicable), properly set according to the type. */
sr_data_t data;
/**
* Name of the module that defines scheme of this node.
* NULL if it is the same as that of the predecessor.
*/
char *module_name;
/** Pointer to the parent node (NULL in case of root node). */
struct sr_node_s *parent;
/** Pointer to the next sibling node (NULL if there is no one). */
struct sr_node_s *next;
/** Pointer to the previous sibling node (NULL if there is no one). */
struct sr_node_s *prev;
/** Pointer to the first child node (NULL if this is a leaf). */
struct sr_node_s *first_child;
/** Pointer to the last child node (NULL if this is a leaf). */
struct sr_node_s *last_child;
} sr_node_t;
/**
* @brief Sysrepo error codes.
*/
typedef enum sr_error_e {
SR_ERR_OK = 0, /**< No error. */
SR_ERR_INVAL_ARG, /**< Invalid argument. */
SR_ERR_NOMEM, /**< Not enough memory. */
SR_ERR_NOT_FOUND, /**< Item not found. */
SR_ERR_INTERNAL, /**< Other internal error. */
SR_ERR_INIT_FAILED, /**< Sysrepo infra initialization failed. */
SR_ERR_IO, /**< Input/Output error. */
SR_ERR_DISCONNECT, /**< The peer disconnected. */
SR_ERR_MALFORMED_MSG, /**< Malformed message. */
SR_ERR_UNSUPPORTED, /**< Unsupported operation requested. */
SR_ERR_UNKNOWN_MODEL, /**< Request includes unknown schema */
SR_ERR_BAD_ELEMENT, /**< Unknown element in existing schema */
SR_ERR_VALIDATION_FAILED, /**< Validation of the changes failed. */
SR_ERR_OPERATION_FAILED, /**< An operation failed. */
SR_ERR_DATA_EXISTS, /**< Item already exists. */
SR_ERR_DATA_MISSING, /**< Item does not exists. */
SR_ERR_UNAUTHORIZED, /**< Operation not authorized. */
SR_ERR_INVAL_USER, /**< Invalid username. */
SR_ERR_LOCKED, /**< Requested resource is already locked. */
SR_ERR_TIME_OUT, /**< Time out has expired. */
SR_ERR_RESTART_NEEDED, /**< Sysrepo Engine restart is needed. */
SR_ERR_VERSION_MISMATCH, /**< Incompatible client library used to communicate with sysrepo. */
} sr_error_t;
/**
* @brief Detailed sysrepo error information.
*/
typedef struct sr_error_info_s {
const char *message; /**< Error message. */
const char *xpath; /**< XPath to the node where the error has been discovered. */
} sr_error_info_t;
/**
* @brief Returns the error message corresponding to the error code.
*
* @param[in] err_code Error code.
*
* @return Error message (statically allocated, do not free).
*/
const char *sr_strerror(int err_code);
/**
* @brief Log levels used to determine if message of certain severity should be printed.
*/
typedef enum {
SR_LL_NONE, /**< Do not print any messages. */
SR_LL_ERR, /**< Print only error messages. */
SR_LL_WRN, /**< Print error and warning messages. */
SR_LL_INF, /**< Besides errors and warnings, print some other informational messages. */
SR_LL_DBG, /**< Print all messages including some development debug messages. */
} sr_log_level_t;
/**
* @brief Enables / disables / changes log level (verbosity) of logging to
* standard error output.
*
* By default, logging to stderr is disabled. Setting log level to any value
* other than SR_LL_NONE enables the logging to stderr. Setting log level
* back to SR_LL_NONE disables the logging to stderr.
*
* @param[in] log_level requested log level (verbosity).
*/
void sr_log_stderr(sr_log_level_t log_level);
/**
* @brief Enables / disables / changes log level (verbosity) of logging to system log.
*
* By default, logging into syslog is disabled. Setting log level to any value
* other than SR_LL_NONE enables the logging into syslog. Setting log level
* back to SR_LL_NONE disables the logging into syslog.
*
* @note Please note that enabling logging into syslog will overwrite your syslog
* connection settings (calls openlog), if you are connected to syslog already.
*
* @param[in] log_level requested log level (verbosity).
*/
void sr_log_syslog(sr_log_level_t log_level);
/**
* @brief Sets callback that will be called when a log entry would be populated.
*
* @param[in] level Verbosity level of the log entry.
* @param[in] message Message of the log entry.
*/
typedef void (*sr_log_cb)(sr_log_level_t level, const char *message);
/**
* @brief Sets callback that will be called when a log entry would be populated.
* Callback will be called for each message with any log level.
*
* @param[in] log_callback Callback to be called when a log entry would populated.
*/
void sr_log_set_cb(sr_log_cb log_callback);
////////////////////////////////////////////////////////////////////////////////
// Connection / Session Management
////////////////////////////////////////////////////////////////////////////////
/**
* @brief Flags used to override default connection handling by ::sr_connect call.
*/
typedef enum sr_conn_flag_e {
SR_CONN_DEFAULT = 0, /**< Default behavior - instantiate library-local Sysrepo Engine if
the connection to sysrepo daemon is not possible. */
SR_CONN_DAEMON_REQUIRED = 1, /**< Require daemon connection - do not instantiate library-local Sysrepo Engine
if the library cannot connect to the sysrepo daemon (and return an error instead). */
SR_CONN_DAEMON_START = 2, /**< If sysrepo daemon is not running, and SR_CONN_DAEMON_REQUIRED was specified,
start it (only if the process calling ::sr_connect is running under root privileges). */
} sr_conn_flag_t;
/**
* @brief Options overriding default connection handling by ::sr_connect call,
* it is supposed to be bitwise OR-ed value of any ::sr_conn_flag_t flags.
*/
typedef uint32_t sr_conn_options_t;
/**
* @brief Flags used to override default session handling (used by ::sr_session_start
* and ::sr_session_start_user calls).
*/
typedef enum sr_session_flag_e {
SR_SESS_DEFAULT = 0, /**< Default (normal) session behavior. */
SR_SESS_CONFIG_ONLY = 1, /**< Session will process only configuration data (e.g. sysrepo won't
return any state data by ::sr_get_items / ::sr_get_items_iter calls). */
SR_SESS_ENABLE_NACM = 2, /**< Enable NETCONF access control for this session (disabled by default). */
SR_SESS_MUTABLE_OPTS = 3 /**< Bit-mask of options that can be set by the user
(immutable flags are defined in sysrepo.proto file). */
} sr_session_flag_t;
/**
* @brief Options overriding default connection session handling,
* it is supposed to be bitwise OR-ed value of any ::sr_session_flag_t flags.
*/
typedef uint32_t sr_sess_options_t;
/**
* @brief Data stores that sysrepo supports. Both are editable via implicit candidate.
* To make changes permanent in edited datastore ::sr_commit must be issued.
* @see @ref ds_page "Datastores & Sessions" information page.
*/
typedef enum sr_datastore_e {
SR_DS_STARTUP = 0, /**< Contains configuration data that should be loaded by the controlled application when it starts. */
SR_DS_RUNNING = 1, /**< Contains currently applied configuration and state data of a running application.
@note This datastore is supported only by applications that subscribe for notifications
about the changes made in the datastore (e.g. ::sr_module_change_subscribe). */
SR_DS_CANDIDATE = 2, /**< Contains configuration that can be manipulated without impacting the current configuration.
Its content is set to the content of running datastore by default. Changes made within
the candidate can be later committed to the running datastore or copied to any datastore.
@note The main difference between working with running and candidate datastore is in commit
operation - commit of candidate session causes the content of running configuration to be set
the value of the candidate configuration (running datastore is overwritten), whereas commit of
runnnig session merges the changes made within the session with the actual state of running. */
} sr_datastore_t;
/**
* @brief Connects to the sysrepo datastore (Sysrepo Engine).
*
* @note If the client library loses connection to the Sysrepo Engine during
* the lifetime of the application, all Sysrepo API calls will start returning
* ::SR_ERR_DISCONNECT error on active sessions. In this case, the application is supposed to reconnect
* with another ::sr_connect call and restart all lost sessions.
*
* @param[in] app_name Name of the application connecting to the datastore
* (can be a static string). Used only for accounting purposes.
* @param[in] opts Options overriding default connection handling by this call.
* @param[out] conn_ctx Connection context that can be used for subsequent API calls
* (automatically allocated, it is supposed to be released by the caller using ::sr_disconnect).
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_connect(const char *app_name, const sr_conn_options_t opts, sr_conn_ctx_t **conn_ctx);
/**
* @brief Disconnects from the sysrepo datastore (Sysrepo Engine).
*
* Cleans up and frees connection context allocated by ::sr_connect. All sessions
* started within the connection will be automatically stopped and cleaned up too.
*
* @param[in] conn_ctx Connection context acquired with ::sr_connect call.
*/
void sr_disconnect(sr_conn_ctx_t *conn_ctx);
/**
* @brief Starts a new configuration session.
*
* @see @ref ds_page "Datastores & Sessions" for more information about datastores and sessions.
*
* @param[in] conn_ctx Connection context acquired with ::sr_connect call.
* @param[in] datastore Datastore on which all sysrepo functions within this
* session will operate. Later on, datastore can be later changed using
* ::sr_session_switch_ds call. Functionality of some sysrepo calls does not depend on
* datastore. If your session will contain just calls like these, you can pass
* any valid value (e.g. SR_RUNNING).
* @param[in] opts Options overriding default session handling.
* @param[out] session Session context that can be used for subsequent API
* calls (automatically allocated, can be released by calling ::sr_session_stop).
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_session_start(sr_conn_ctx_t *conn_ctx, const sr_datastore_t datastore,
const sr_sess_options_t opts, sr_session_ctx_t **session);
/**
* @brief Starts a new configuration session on behalf of a different user.
*
* This call is intended for northbound access to sysrepo from management
* applications, that need sysrepo to authorize the operations not only
* against the user under which the management application is running, but
* also against another user (e.g. user that connected to the management application).
*
* @note Be aware that authorization of specified user may fail with unexpected
* errors in case that the client library uses its own Sysrepo Engine at the
* moment and your process in not running under root privileges. To prevent
* this situation, consider specifying SR_CONN_DAEMON_REQUIRED flag by
* ::sr_connect call or using ::sr_session_start instead of this function.
*
* @see @ref ds_page "Datastores & Sessions" for more information about datastores and sessions.
*
* @param[in] conn_ctx Connection context acquired with ::sr_connect call.
* @param[in] user_name Effective user name used to authorize the access to
* datastore (in addition to automatically-detected real user name).
* @param[in] datastore Datastore on which all sysrepo functions within this
* session will operate. Functionality of some sysrepo calls does not depend on
* datastore. If your session will contain just calls like these, you can pass
* any valid value (e.g. SR_RUNNING).
* @param[in] opts Options overriding default session handling.
* @param[out] session Session context that can be used for subsequent API calls
* (automatically allocated, it is supposed to be released by caller using ::sr_session_stop).
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_session_start_user(sr_conn_ctx_t *conn_ctx, const char *user_name, const sr_datastore_t datastore,
const sr_sess_options_t opts, sr_session_ctx_t **session);
/**
* @brief Stops current session and releases resources tied to the session.
*
* @param[in] session Session context acquired with ::sr_session_start call.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_session_stop(sr_session_ctx_t *session);
/**
* @brief Refreshes configuration data cached within the session and starts
* operating on fresh data loaded from the datastore.
*
* Call this function in case that you leave session open for longer time period
* and you expect that the data in the datastore may have been changed since
* last data (re)load (which occurs by ::sr_session_start, ::sr_commit and
* ::sr_discard_changes).
*
* @see @ref ds_page "Datastores & Sessions" for information about session data caching.
*
* @param[in] session Session context acquired with ::sr_session_start call.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_session_refresh(sr_session_ctx_t *session);
/**
* @brief Checks aliveness and validity of the session & connection tied to it.
*
* If the connection to the Sysrepo Engine has been lost in the meantime, returns SR_ERR_DICONNECT.
* In this case, the application is supposed to stop the session (::sr_session_stop), disconnect (::sr_disconnect)
* and then reconnect (::sr_connect) and start a new session (::sr_session_start).
*
* @note If the client library loses connection to the Sysrepo Engine during the lifetime of the application,
* all Sysrepo API calls will start returning SR_ERR_DISCONNECT error on active sessions. This is the primary
* mechanism that can be used to detect connection issues, ::sr_session_check is just an addition to it. Since
* ::sr_session_check sends a message to the Sysrepo Engine and waits for the response, it costs some extra overhead
* in contrast to catching SR_ERR_DISCONNECT error.
*
* @param[in] session Session context acquired with ::sr_session_start call.
*
* @return Error code (SR_ERR_OK in case that the session is healthy,
* SR_ERR_DICONNECT in case that connection to the Sysrepo Engine has been lost).
*/
int sr_session_check(sr_session_ctx_t *session);
/**
* @brief Changes datastore to which the session is tied to. All subsequent
* calls will be issued on the chosen datastore.
*
* @param [in] session
* @param [in] ds
* @return Error code (SR_ERR_OK on success)
*/
int sr_session_switch_ds(sr_session_ctx_t *session, sr_datastore_t ds);
/**
* @brief Alter the session options. E.g.: set/unset SR_SESS_CONFIG_ONLY flag.
*
* @param [in] session
* @param [in] opts - new value for session options
* @return Error code (SR_ERR_OK on success)
*/
int sr_session_set_options(sr_session_ctx_t *session, const sr_sess_options_t opts);
/**
* @brief Retrieves detailed information about the error that has occurred
* during the last operation executed within provided session.
*
* If multiple errors has occurred within the last operation, only the first
* one is returned. This call is sufficient for all data retrieval and data
* manipulation functions that operate on single-item basis. For operations
* such as ::sr_validate or ::sr_commit where multiple errors can occur,
* use ::sr_get_last_errors instead.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[out] error_info Detailed error information. Be aware that
* returned pointer may change by the next API call executed within the provided
* session, so it's not safe to use this function by concurrent access to the
* same session within multiple threads. Do not free or modify returned values.
*
* @return Error code of the last operation executed within provided session.
*/
int sr_get_last_error(sr_session_ctx_t *session, const sr_error_info_t **error_info);
/**
* @brief Retrieves detailed information about all errors that have occurred
* during the last operation executed within provided session.
*
* Use this call instead of ::sr_get_last_error by operations where multiple
* errors can occur, such as ::sr_validate or ::sr_commit.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[out] error_info Array of detailed error information. Be aware that
* returned pointer may change by the next API call executed within the provided
* session, so it's not safe to use this function by concurrent access to the
* same session within multiple threads. Do not free or modify returned values.
* @param[out] error_cnt Number of errors returned in the error_info array.
*
* @return Error code of the last operation executed within provided session.
*/
int sr_get_last_errors(sr_session_ctx_t *session, const sr_error_info_t **error_info, size_t *error_cnt);
/**
* @brief Sets detailed error information into provided session. Used to notify
* the client library about errors that occurred in application code.
*
* @note Intended for commit verifiers (notification session) - the call has no
* impact on any other sessions.
*
* @param[in] session Session context passed into notification callback.
* @param[in] message Human-readable error message.
* @param[in] xpath XPath to the node where the error has occurred. NULL value
* is also accepted.
*
* @return Error code (SR_ERR_OK on success)
*/
int sr_set_error(sr_session_ctx_t *session, const char *message, const char *xpath);
/**
* @brief Returns the assigned id of the session. Can be used to pair the session with
* netconf-config-change notification initiator.
* @param [in] session
* @return session id or 0 in case of error
*/
uint32_t sr_session_get_id(sr_session_ctx_t *session);
////////////////////////////////////////////////////////////////////////////////
// Data Retrieval API (get / get-config functionality)
////////////////////////////////////////////////////////////////////////////////
/**
* @brief Structure that contains information about one particular schema file installed in sysrepo.
*/
typedef struct sr_sch_revision_s {
const char *revision; /**< Revision of the module/submodule. */
const char *file_path_yang; /**< Absolute path to file where the module/submodule is stored (YANG format). */
const char *file_path_yin; /**< Absolute path to file where the module/submodule is stored (.yin format). */
} sr_sch_revision_t;
/**
* @brief Structure that contains information about submodules of a module installed in sysrepo.
*/
typedef struct sr_sch_submodule_s {
const char *submodule_name; /**< Submodule name. */
sr_sch_revision_t revision; /**< Revision of the submodule. */
} sr_sch_submodule_t;
/**
* @brief Structure that contains information about a module installed in sysrepo.
*/
typedef struct sr_schema_s {
/**
* Memory context used internally by Sysrepo for efficient storage
* and conversion of this structure.
*/
sr_mem_ctx_t *_sr_mem;
const char *module_name; /**< Name of the module. */
const char *ns; /**< Namespace of the module used in @ref xp_page "XPath". */
const char *prefix; /**< Prefix of the module. */
bool installed; /**< TRUE if the module was explicitly installed. */
bool implemented; /**< TRUE if the module is implemented (does not have to be installed),
not just imported. */
sr_sch_revision_t revision; /**< Revision the module. */
sr_sch_submodule_t *submodules; /**< Array of all installed submodules of the module. */
size_t submodule_count; /**< Number of module's submodules. */
char **enabled_features; /**< Array of enabled features */
size_t enabled_feature_cnt; /**< Number of enabled feature */
} sr_schema_t;
/**
* @brief Format types of ::sr_get_schema result
*/
typedef enum sr_schema_format_e {
SR_SCHEMA_YANG, /**< YANG format */
SR_SCHEMA_YIN /**< YIN format */
} sr_schema_format_t;
/**
* @brief Iterator used for accessing data nodes via ::sr_get_items_iter call.
*/
typedef struct sr_val_iter_s sr_val_iter_t;
/**
* @brief Retrieves list of schemas installed in the sysrepo datastore.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[out] schemas Array of installed schemas information (allocated by
* the function, it is supposed to be freed by caller using ::sr_free_schemas call).
* @param[out] schema_cnt Number of schemas returned in the array.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_list_schemas(sr_session_ctx_t *session, sr_schema_t **schemas, size_t *schema_cnt);
/**
* @brief Retrieves the content of specified schema file. If the module
* can not be found SR_ERR_NOT_FOUND is returned.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] module_name Name of the requested module.
* @param[in] revision Requested revision of the module. If NULL
* is passed, the latest revision will be returned.
* @param[in] submodule_name Name of the requested submodule. Pass NULL if you are
* requesting the content of the main module.
* @param[in] format of the returned schema
* @param[out] schema_content Content of the specified schema file. Automatically
* allocated by the function, should be freed by the caller.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_get_schema(sr_session_ctx_t *session, const char *module_name, const char *revision,
const char *submodule_name, sr_schema_format_t format, char **schema_content);
/**
* @brief Retrieves the content of the specified submodule schema file. If the submodule
* cannot be found, SR_ERR_NOT_FOUND is returned.
*
* @param[in] session Session context acquired from ::sr_session_start call.
* @param[in] submodule_name Name of the requested submodule.
* @param[in] submodule_revision Requested revision of the submodule. If NULL
* is passed, the latest revision will be returned.
* @param[in] format of the returned schema.
* @param[out] schema_content Content of the specified schema file. Automatically
* allocated by the function, should be freed by the caller.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_get_submodule_schema(sr_session_ctx_t *session, const char *submodule_name, const char *submodule_revision,
sr_schema_format_t format, char **schema_content);
/**
* @brief Retrieves a single data element stored under provided XPath. If multiple
* nodes matches the xpath SR_ERR_INVAL_ARG is returned.
*
* If the xpath identifies an empty leaf, a list or a container, the value
* has no data filled in and its type is set properly (SR_LEAF_EMPTY_T / SR_LIST_T / SR_CONTAINER_T / SR_CONTAINER_PRESENCE_T).
*
* @see @ref xp_page "Path Addressing" documentation, or
* https://tools.ietf.org/html/draft-ietf-netmod-yang-json#section-6.11
* for XPath syntax used for identification of yang nodes in sysrepo calls.
*
* @see Use ::sr_get_items or ::sr_get_items_iter for retrieving larger chunks
* of data from the datastore. Since they retrieve the data from datastore in
* larger chunks, they can work much more efficiently than multiple ::sr_get_item calls.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier of the data element to be retrieved.
* @param[out] value Structure containing information about requested element
* (allocated by the function, it is supposed to be freed by the caller using ::sr_free_val).
*
* @return Error code (SR_ERR_OK on success)
*/
int sr_get_item(sr_session_ctx_t *session, const char *xpath, sr_val_t **value);
/**
* @brief Retrieves an array of data elements matching provided XPath
*
* All data elements are transferred within one message from the datastore,
* which is much more efficient that calling multiple ::sr_get_item calls.
*
* If the user does not have read permission to access certain nodes, these
* won't be part of the result. SR_ERR_NOT_FOUND will be returned if there are
* no nodes matching xpath in the data tree, or the user does not have read permission to access them.
*
* If the response contains too many elements time out may be exceeded, SR_ERR_TIME_OUT
* will be returned, use ::sr_get_items_iter.
*
* @see @ref xp_page "Path Addressing" documentation
* for Path syntax used for identification of yang nodes in sysrepo calls.
*
* @see ::sr_get_items_iter can be used for the same purpose as ::sr_get_items
* call if you expect that ::sr_get_items could return too large data sets.
* Since ::sr_get_items_iter also retrieves the data from datastore in larger chunks,
* in can still work very efficiently for large datasets.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier of the data element to be retrieved.
* @param[out] values Array of structures containing information about requested data elements
* (allocated by the function, it is supposed to be freed by the caller using ::sr_free_values).
* @param[out] value_cnt Number of returned elements in the values array.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_get_items(sr_session_ctx_t *session, const char *xpath, sr_val_t **values, size_t *value_cnt);
/**
* @brief Creates an iterator for retrieving of the data elements stored under provided xpath.
*
* Requested data elements are transferred from the datastore in larger chunks
* of pre-defined size, which is much more efficient that calling multiple
* ::sr_get_item calls, and may be less memory demanding than calling ::sr_get_items
* on very large datasets.
*
* @see @ref xp_page "Path Addressing" documentation, or
* https://tools.ietf.org/html/draft-ietf-netmod-yang-json#section-6.11
* for XPath syntax used for identification of yang nodes in sysrepo calls.
*
* @see ::sr_get_item_next for iterating over returned data elements.
* @note Iterator allows to iterate through the values once. To start iteration
* from the beginning new iterator must be created.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier of the data element / subtree to be retrieved.
* @param[out] iter Iterator context that can be used to retrieve individual data
* elements via ::sr_get_item_next calls. Allocated by the function, should be
* freed with ::sr_free_val_iter.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_get_items_iter(sr_session_ctx_t *session, const char *xpath, sr_val_iter_t **iter);
/**
* @brief Returns the next item from the dataset of provided iterator created
* by ::sr_get_items_iter call. If there is no item left SR_ERR_NOT_FOUND is returned.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in,out] iter Iterator acquired with ::sr_get_items_iter call.
* @param[out] value Structure containing information about requested element
* (allocated by the function, it is supposed to be freed by the caller using ::sr_free_val).
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_get_item_next(sr_session_ctx_t *session, sr_val_iter_t *iter, sr_val_t **value);
/**
* @brief Flags used to customize the behaviour of ::sr_get_subtree and ::sr_get_subtrees calls.
*/
typedef enum sr_get_subtree_flag_e {
/**
* Default get-subtree(s) behaviour.
* All matched subtrees are sent with all their content in one message.
*/
SR_GET_SUBTREE_DEFAULT = 0,
/**
* The iterative get-subtree(s) behaviour.
* The matched subtrees are sent in chunks and only as needed while they are iterated
* through using functions ::sr_node_get_child, ::sr_node_get_next_sibling and
* ::sr_node_get_parent from "sysrepo/trees.h". This behaviour gives much better
* performance than the default one if only a small portion of matched subtree(s) is
* actually iterated through.
* @note It is considered a programming error to access \p next, \p prev, \p parent,
* \p first_child and \p last_child data members of ::sr_node_t on a partially loaded tree.
*/
SR_GET_SUBTREE_ITERATIVE = 1
} sr_get_subtree_flag_t;
/**
* @brief Options for get-subtree and get-subtrees operations.
* It is supposed to be bitwise OR-ed value of any ::sr_get_subtree_flag_t flags.
*/
typedef uint32_t sr_get_subtree_options_t;
/**
* @brief Retrieves a single subtree whose root node is stored under the provided XPath.
* If multiple nodes matches the xpath SR_ERR_INVAL_ARG is returned.
*
* The functions returns values and all associated information stored under the root node and
* all its descendants. While the same data can be obtained using ::sr_get_items in combination
* with the expressive power of XPath addressing, the recursive nature of the output data type
* also preserves the hierarchical relationships between data elements.
*
* Values of internal nodes of the subtree have no data filled in and their type is set properly
* (SR_LIST_T / SR_CONTAINER_T / SR_CONTAINER_PRESENCE_T), whereas leaf nodes are carrying actual
* data (apart from SR_LEAF_EMPTY_T).
*
* @see @ref xp_page "Path Addressing" documentation
* for XPath syntax used for identification of yang nodes in sysrepo calls.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier referencing the root node of the subtree to be retrieved.
* @param[in] opts Options overriding default behavior of this operation.
* @param[out] subtree Nested structure storing all data of the requested subtree
* (allocated by the function, it is supposed to be freed by the caller using ::sr_free_tree).
*
* @return Error code (SR_ERR_OK on success)
*/
int sr_get_subtree(sr_session_ctx_t *session, const char *xpath, sr_get_subtree_options_t opts,
sr_node_t **subtree);
/**
* @brief Retrieves an array of subtrees whose root nodes match the provided XPath.
*
* If the user does not have read permission to access certain nodes, these together with
* their descendants won't be part of the result. SR_ERR_NOT_FOUND will be returned if there are
* no nodes matching xpath in the data tree, or the user does not have read permission to access them.
*
* Subtrees that match the provided XPath are not merged even if they overlap. This significantly
* simplifies the implementation and decreases the cost of this operation. The downside is that
* the user must choose the XPath carefully. If the subtree selection process results in too many
* node overlaps, the cost of the operation may easily outshine the benefits. As an example,
* a common XPath expression "//." is normally used to select all nodes in a data tree, but for this
* operation it would result in an excessive duplication of transfered data elements.
* Since you get all the descendants of each matched node implicitly, you probably should not need
* to use XPath wildcards deeper than on the top-level.
* (i.e. "/." is preferred alternative to "//." for get-subtrees operation).
*
* If the response contains too many elements time out may be exceeded, SR_ERR_TIME_OUT
* will be returned.
*
* @see @ref xp_page "Path Addressing" documentation, or
* https://tools.ietf.org/html/draft-ietf-netmod-yang-json#section-6.11
* for XPath syntax used for identification of yang nodes in sysrepo calls.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier referencing root nodes of subtrees to be retrieved.
* @param[in] opts Options overriding default behavior of this operation.
* @param[out] subtrees Array of nested structures storing all data of the requested subtrees
* (allocated by the function, it is supposed to be freed by the caller using ::sr_free_trees).
* @param[out] subtree_cnt Number of returned trees in the subtrees array.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_get_subtrees(sr_session_ctx_t *session, const char *xpath, sr_get_subtree_options_t opts,
sr_node_t **subtrees, size_t *subtree_cnt);
////////////////////////////////////////////////////////////////////////////////
// Data Manipulation API (edit-config functionality)
////////////////////////////////////////////////////////////////////////////////
/**
* @brief Flags used to override default behavior of data manipulation calls.
*/
typedef enum sr_edit_flag_e {
SR_EDIT_DEFAULT = 0, /**< Default behavior - recursive and non-strict. */
SR_EDIT_NON_RECURSIVE = 1, /**< Non-recursive behavior:
by ::sr_set_item, all preceding nodes (parents) of the identified element must exist,
by ::sr_delete_item xpath must not identify an non-empty list or non-empty container. */
SR_EDIT_STRICT = 2 /**< Strict behavior:
by ::sr_set_item the identified element must not exist (similar to netconf create operation),
by ::sr_delete_item the identified element must exist (similar to netconf delete operation). */
} sr_edit_flag_t;
/**
* @brief Options overriding default behavior of data manipulation calls,
* it is supposed to be bitwise OR-ed value of any ::sr_edit_flag_t flags.
*/
typedef uint32_t sr_edit_options_t;
/**
* @brief Options for specifying move direction of ::sr_move_item call.
*/
typedef enum sr_move_position_e {
SR_MOVE_BEFORE = 0, /**< Move the specified item before the selected sibling. */
SR_MOVE_AFTER = 1, /**< Move the specified item after the selected. */
SR_MOVE_FIRST = 2, /**< Move the specified item to the position of the first child. */
SR_MOVE_LAST = 3, /**< Move the specified item to the position of the last child. */
} sr_move_position_t;
/**
* @brief Sets the value of the leaf, leaf-list, list or presence container.
*
* With default options it recursively creates all missing nodes (containers and
* lists including their key leaves) in the xpath to the specified node (can be
* turned off with SR_EDIT_NON_RECURSIVE option). If SR_EDIT_STRICT flag is set,
* the node must not exist (otherwise an error is returned).
*
* To create a list use xpath with key values included and pass NULL as value argument.
*
* Setting of a leaf-list value appends the value at the end of the leaf-list.
* A value of leaf-list can be specified either by predicate in xpath or by value argument.
* If both are present, value argument is ignored and xpath predicate is used.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier of the data element to be set.
* @param[in] value Value to be set on specified xpath. xpath member of the
* ::sr_val_t structure can be NULL. Value will be copied - can be allocated on stack.
* @param[in] opts Options overriding default behavior of this call.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_set_item(sr_session_ctx_t *session, const char *xpath, const sr_val_t *value, const sr_edit_options_t opts);
/**
* @brief Functions is similar to ::sr_set_item with the difference that the value to be set
* is provided as string.
* @param [in] session Session context acquired with ::sr_session_start call.
* @param [in] xpath @ref xp_page "Data Path" identifier of the data element to be set.
* @param [in] value string representation of the value to be set
* @param [in] opts same as for ::sr_set_item
* @return Error code (SR_ERR_OK on success).
*/
int sr_set_item_str(sr_session_ctx_t *session, const char *xpath, const char *value, const sr_edit_options_t opts);
/**
* @brief Deletes the nodes under the specified xpath.
*
* To delete non-empty lists or containers SR_EDIT_NON_RECURSIVE flag must not be set.
* If SR_EDIT_STRICT flag is set the specified node must must exist in the datastore.
* If the xpath includes the list keys, the specified list instance is deleted.
* If the xpath to list does not include keys, all instances of the list are deleted.
* SR_ERR_UNAUTHORIZED will be returned if the user does not have write permission to any affected node.
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier of the data element to be deleted.
* @param[in] opts Options overriding default behavior of this call.
*
* @return Error code (SR_ERR_OK on success).
**/
int sr_delete_item(sr_session_ctx_t *session, const char *xpath, const sr_edit_options_t opts);
/**
* @brief Move the instance of an user-ordered list or leaf-list to the specified position.
*
* Item can be move to the first or last position or positioned relatively to its sibling.
* @note To determine current order, you can issue a ::sr_get_items call
* (without specifying keys of the list in question).
*
* @param[in] session Session context acquired with ::sr_session_start call.
* @param[in] xpath @ref xp_page "Data Path" identifier of the data element to be moved.
* @param[in] position Requested move direction.
* @param[in] relative_item xpath Identifier of the data element that is used
* to determine relative position, used only if position argument is SR_MOVE_BEFORE or SR_MOVE_AFTER.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_move_item(sr_session_ctx_t *session, const char *xpath, const sr_move_position_t position, const char *relative_item);
/**
* @brief Perform the validation of changes made in current session, but do not
* commit nor discard them.
*
* Provides only YANG validation, commit verify subscribers won't be notified in this case.
*
* @see Use ::sr_get_last_errors to retrieve error information if the validation
* returned with an error.
*
* @param[in] session Session context acquired with ::sr_session_start call.
*
* @return Error code (SR_ERR_OK on success).
*/
int sr_validate(sr_session_ctx_t *session);
/**
* @brief Apply changes made in current session.