yumapro  23.10T-9
YumaPro SDK
Loading...
Searching...
No Matches
cfg.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
3 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
4 *
5 * Unless required by applicable law or agreed to in writing,
6 * software distributed under the License is distributed on an
7 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
8 * KIND, either express or implied. See the License for the
9 * specific language governing permissions and limitations
10 * under the License.
11 */
12#ifndef _H_cfg
13#define _H_cfg
14/* FILE: cfg.h
15*********************************************************************
16* *
17* P U R P O S E *
18* *
19*********************************************************************/
20
85/*********************************************************************
86* *
87* C H A N G E H I S T O R Y *
88* *
89*********************************************************************
90
91date init comment
92----------------------------------------------------------------------
9315-apr-06 abb Begun.
9429-may-08 abb Converted NCX database model to simplified
95 YANG object model
96*/
97#include <xmlstring.h>
98
99#ifndef _H_dlq
100#include "dlq.h"
101#endif
102
103#ifndef _H_ncx
104#include "ncx.h"
105#endif
106
107#ifndef _H_ncxconst
108#include "ncxconst.h"
109#endif
110
111#ifndef _H_plock
112#include "plock.h"
113#endif
114
115#ifndef _H_ses
116#include "ses.h"
117#endif
118
119#ifndef _H_status
120#include "status.h"
121#endif
122
123#ifndef _H_val
124#include "val.h"
125#endif
126
127#ifndef _H_val_util
128#include "val_util.h"
129#endif
130
131#ifndef _H_thd
132#include "thd.h"
133#endif
134
135#ifdef __cplusplus
136extern "C" {
137#endif
138
139/********************************************************************
140* *
141* C O N S T A N T S *
142* *
143*********************************************************************/
144
145/* bit definitions for the cfg_template->flags field */
146#define CFG_FL_TARGET bit0
147#define CFG_FL_DIRTY bit1
148#define CFG_FL_FORCE_DEADNODES bit2
149#define CFG_FL_FORCE_TOP_DEFAULTS bit3
150#define CFG_FL_EXTERN_NVSTORE bit4
151
152#define CFG_INITIAL_TXID (ncx_transaction_id_t)0
153
154/* this must match the number of enums in ncx_cfg_t (NCX_CFGID_CNT) */
155#define CFG_NUM_STATIC 3
156
157#define CFG_GET_FORCE_DEADNODES(C) ((C)->flags & CFG_FL_FORCE_DEADNODES)
158
159#define CFG_SET_FORCE_DEADNODES(C) (C)->flags |= CFG_FL_FORCE_DEADNODES
160
161#define CFG_GET_FORCE_TOP_DEFAULTS(C) ((C)->flags & CFG_FL_FORCE_TOP_DEFAULTS)
162
163#define CFG_SET_FORCE_TOP_DEFAULTS(C) (C)->flags |= CFG_FL_FORCE_TOP_DEFAULTS
164
165
166#define CFG_SET_EXTERN_NVSTORE(C) (C)->flags |= CFG_FL_EXTERN_NVSTORE
167
168#define CFG_IS_EXTERN_NVSTORE(C) ((C)->flags & CFG_FL_EXTERN_NVSTORE)
169
170/*
171 * Define constants for use with cfg_rwlock_acquire_xxx() functions
172 * and data structures:
173 */
174
175#define CFG_RWLOCK_READ_ACCESS FALSE
176#define CFG_RWLOCK_WRITE_ACCESS TRUE
177#define READ_ACCESS CFG_RWLOCK_READ_ACCESS
178#define WRITE_ACCESS CFG_RWLOCK_WRITE_ACCESS
179
180#define CFG_GET_ROOT(C) ((C)->root)
181
182#define CFG_GET_ID(C) ((C)->cfg_id)
183
184#define CFG_IN_CC_ROLLBACK(C) (C)->in_cc_rollback
185
186#define CFG_DEFER_LOAD(C) ((C)->defer_load)
187
188
189/********************************************************************
190* *
191* T Y P E S *
192* *
193*********************************************************************/
194
195
196
198typedef enum cfg_state_t_ {
206
207
209typedef enum cfg_source_t_ {
210 CFG_SRC_NONE,
211 CFG_SRC_INTERNAL,
212 CFG_SRC_NETCONF,
213 CFG_SRC_CLI,
214 CFG_SRC_SNMP,
215 CFG_SRC_HTTP,
216 CFG_SRC_OTHER
218
219
221typedef enum cfg_location_t_ {
222 CFG_LOC_NONE,
223 CFG_LOC_FILE,
224 CFG_LOC_REMOTE_URL
226
227
229typedef struct cfg_template_t_ {
232
237
240
243
246
249
251 xmlChar *name;
252
256 xmlChar *src_url;
257
260
262 xmlChar lock_time[TSTAMP_MIN_SIZE];
263
265 xmlChar last_ch_time[TSTAMP_MIN_SIZE]; // TBD: remove!
266
268 uint32 flags;
269
274
277
278 /* source of the config lock:
279 * If the database is locked, identifies the protocol or other
280 * source that currently caused the database to be locked.
281 */
282 cfg_source_t lock_src;
283
288 dlq_hdr_t load_errQ;
289
290 /* Queue of plock_cb_t for partial lock support */
291 dlq_hdr_t plockQ;
292
299
301 pthread_rwlock_t rwlock;
302
305
311
313 boolean rw_wrlocked;
314
316 boolean rw_rdlocked;
317
320
325
328
335
337 boolean defer_load;
338
340
341
345typedef void (*cfg_reload_candidate_cb_t) (void);
346
347
348
349/********************************************************************
350* *
351* V A R I A B L E S *
352* *
353*********************************************************************/
354
355#ifdef PTHREADS
356extern boolean wrlock_pending;
357#endif
358
359/********************************************************************
360* *
361* F U N C T I O N S *
362* *
363*********************************************************************/
364
365
373extern void
374 cfg_ypinit (void);
375
376
381extern void
382 cfg_clean_roots (void);
383
384
389extern void
390 cfg_cleanup (void);
391
392
393
394#ifdef PTHREADS
404
405
416
417
428
429
440
441
450
451
459
460
473extern status_t
475 cfg_template_t *cfg1,
476 boolean wrlock1,
477 cfg_template_t *cfg2,
478 boolean wrlock2);
479
480
492 cfg_template_t *cfg,
493 boolean wrlock);
494
495
505extern status_t
507
508
509
519extern status_t
521
522#endif // PTHREADS
523
524
531extern status_t
533
534
544extern cfg_template_t *
545 cfg_new_template (const xmlChar *name,
546 ncx_cfg_t cfg_id);
547
548
555extern void
557
558
565extern void
566 cfg_set_state (ncx_cfg_t cfg_id,
567 cfg_state_t new_state);
568
569
576extern cfg_state_t
577 cfg_get_state (ncx_cfg_t cfg_id);
578
579
586extern cfg_template_t *
587 cfg_get_config (const xmlChar *cfgname);
588
589
596extern const xmlChar *
598
599
606extern cfg_template_t *
608
609
615extern void
616 cfg_set_target (ncx_cfg_t cfg_id);
617
618
626extern status_t
628
629
638extern status_t
640
641
651extern status_t
653 val_value_t *newroot);
654
655
662extern void
664
665
673
674
680extern void
682
683
689extern void
691
692
699extern boolean
701
702
710extern status_t
711 cfg_ok_to_lock (const cfg_template_t *cfg);
712
713
722extern status_t
724 ses_id_t sesid);
725
726
737extern status_t
739 ses_id_t sesid,
740 boolean lockall);
741
742
749extern status_t
750 cfg_ok_to_read (const cfg_template_t *cfg);
751
752
764extern status_t
766 ses_id_t sesid);
767
768
775extern boolean
777
778
785extern boolean
787
788
799extern status_t
801 ses_id_t *sesid,
802 const xmlChar **locktime);
803
804
817extern status_t
819 ses_id_t locked_by,
820 cfg_source_t lock_src);
821
822
836extern status_t
838 ses_id_t locked_by,
839 cfg_source_t lock_src,
840 boolean lockall);
841
842
851extern status_t
853 ses_id_t locked_by);
854
855
865extern status_t
867 ses_id_t locked_by,
868 boolean lockall);
869
870
871
884extern status_t
886 ses_id_t locked_by,
887 boolean skip_reload);
888
889
896extern void
898
899
906extern void
908
909
918extern void
920 val_value_t *retval);
921
922
929extern void
931 val_value_t *newroot);
932
933
940extern void
942 time_t *timestamp);
943
944
951extern void
954
955
962extern void
964 cfg_template_t *dest);
965
966
973extern const xmlChar *
975
976
985
986
996extern status_t
998 xmlChar *buff,
999 int32 buffsize);
1000
1001
1012extern status_t
1014 xmlChar *buff,
1015 int32 buffsize);
1016
1017
1032extern status_t
1034 plock_cb_t *plcb);
1035
1036
1045extern plock_cb_t *
1047 plock_id_t lockid);
1048
1049
1057extern plock_cb_t *
1059
1060
1068extern plock_cb_t *
1069 cfg_next_partial_lock (plock_cb_t *curplockcb);
1070
1071
1078extern void
1080 plock_id_t lockid);
1081
1082
1090extern status_t
1092
1093
1100extern val_value_t *
1101 cfg_get_root (ncx_cfg_t cfgid);
1102
1103
1110extern status_t
1111 cfg_setup_running (void);
1112
1113
1122extern void
1124
1125
1131extern const xmlChar *
1133
1134
1135#ifdef PTHREADS
1141extern boolean
1143
1144
1150extern boolean
1152
1153#endif // PTHREADS
1154
1155
1164extern cfg_template_t *
1165 cfg_new_fake_candidate (const xmlChar *name,
1166 ncx_cfg_t cfg_id);
1167
1168
1174extern void
1175 cfg_set_defer_load (boolean val);
1176
1177
1178
1185extern time_t
1187
1188
1196extern status_t
1198
1199
1202#ifdef __cplusplus
1203} /* end extern 'C' */
1204#endif
1205
1206#endif /* _H_cfg */
dlq provides general double-linked list and queue support:
boolean cfg_candidate_is_wrlocked(void)
Check if the candidate datastore is currently pthreads write-locked.
Definition: cfg.c:3469
void cfg_set_defer_load(boolean val)
Set the config defer load flag to the config.
Definition: cfg.c:3619
void cfg_update_stamps(cfg_template_t *source, cfg_template_t *dest)
Update the last-modified and last-txid stamps.
Definition: cfg.c:2967
const xmlChar * cfg_get_startup_filespec(void)
Get the filespec string for the XML file to save the running database.
Definition: cfg.c:3428
cfg_template_t * cfg_new_template(const xmlChar *name, ncx_cfg_t cfg_id)
Malloc and initialize a cfg_template_t struct.
Definition: cfg.c:1336
status_t cfg_ok_to_unlock2(const cfg_template_t *cfg, ses_id_t sesid, boolean lockall)
Check if the specified config can be unlocked right now by the specified session ID; for global lock ...
Definition: cfg.c:2166
status_t cfg_get_global_lock_info(const cfg_template_t *cfg, ses_id_t *sesid, const xmlChar **locktime)
Get the current global lock info.
Definition: cfg.c:2476
cfg_template_t * cfg_get_config(const xmlChar *cfgname)
Get the config struct from its name.
Definition: cfg.c:1452
boolean cfg_is_partial_locked(const cfg_template_t *cfg)
Check if the specified config has any active partial locks.
Definition: cfg.c:2443
status_t cfg_fill_candidate_from_running(ses_id_t sesid)
Fill the <candidate> config with the config contents of the <running> config.
Definition: cfg.c:1562
status_t cfg_add_partial_lock(cfg_template_t *cfg, plock_cb_t *plcb)
Add a partial lock the specified config.
Definition: cfg.c:3118
status_t cfg_lock2(cfg_template_t *cfg, ses_id_t locked_by, cfg_source_t lock_src, boolean lockall)
Lock the specified config (with lockall)
Definition: cfg.c:2549
void cfg_cleanup(void)
Cleanup the config manager.
Definition: cfg.c:1250
status_t cfg_rwlock_acquire_lock_pair(thd_tcb_t *tcb, cfg_template_t *cfg1, boolean wrlock1, cfg_template_t *cfg2, boolean wrlock2)
Acquire multiple (2) locks in predetermined, repeatable in order to help prevent deadlock.
Definition: cfg.c:829
status_t cfg_setup_running(void)
Setup the running config root if load_running_config did not add anything.
Definition: cfg.c:3371
cfg_location_t
classify the config location
Definition: cfg.h:221
void cfg_ypinit(void)
Initialize the config manager.
Definition: cfg.c:1196
void cfg_release_partial_locks(ses_id_t sesid)
Release any configuration locks held by the specified session.
Definition: cfg.c:2778
status_t cfg_rwlock_acquire_single_wrlock(thd_tcb_t *tcb, cfg_template_t *cfg)
Acquire a single RWLOCK for write access.
Definition: cfg.c:963
void cfg_set_dirty_flag(cfg_template_t *cfg)
Mark the config as 'changed'.
Definition: cfg.c:1967
plock_cb_t * cfg_find_partial_lock(cfg_template_t *cfg, plock_id_t lockid)
Find a partial lock in the specified config.
Definition: cfg.c:3153
status_t cfg_unlock2(cfg_template_t *cfg, ses_id_t locked_by, boolean lockall)
Unlock the specified config (2nd rev)
Definition: cfg.c:2671
status_t cfg_ok_to_unlock(const cfg_template_t *cfg, ses_id_t sesid)
Check if the specified config can be unlocked right now by the specified session ID; for global lock ...
Definition: cfg.c:2146
cfg_state_t
current configuration state
Definition: cfg.h:198
boolean cfg_running_is_wrlocked(void)
Check if the running datastore is currently pthreads write-locked.
Definition: cfg.c:3449
plock_cb_t * cfg_first_partial_lock(cfg_template_t *cfg)
Get the first partial lock in the specified config.
Definition: cfg.c:3189
void cfg_clear_running_dirty_flag(void)
Clear the running dirty flag when it is saved to NV-storage or loaded into running from startup.
Definition: cfg.c:2010
status_t cfg_rwlock_wrlock(thd_tcb_t *tcb, cfg_template_t *cfg)
Take out a write lock associated with a cfg (datastore) RWLOCK structure.
Definition: cfg.c:368
time_t cfg_get_lock_itime(ncx_cfg_t cfg_id)
Get the lock_itime field.
Definition: cfg.c:3556
boolean cfg_get_dirty_flag(const cfg_template_t *cfg)
Get the config dirty flag value.
Definition: cfg.c:2052
void cfg_clear_candidate_dirty_flag(void)
Clear the candidate dirty flag when it is saved to NV-storage or loaded into running from startup.
Definition: cfg.c:2030
status_t cfg_fill_candidate_from_startup(ses_id_t sesid)
Fill the <candidate> config with the config contents of the <startup> config.
Definition: cfg.c:1740
status_t cfg_ok_to_partial_lock(const cfg_template_t *cfg)
Check if the specified config can be locked right now for partial lock only.
Definition: cfg.c:3289
status_t cfg_rwlock_init_req_locks(thd_tcb_t *tcb)
Initialize TCB multiple lock structure.
Definition: cfg.c:627
void cfg_clean_roots(void)
Cleanup the cfg->root nodes before all the objects are freed.
Definition: cfg.c:1224
status_t cfg_lock(cfg_template_t *cfg, ses_id_t locked_by, cfg_source_t lock_src)
Lock the specified config.
Definition: cfg.c:2522
status_t cfg_ok_to_lock(const cfg_template_t *cfg)
Check if the specified config can be locked right now for global lock only.
Definition: cfg.c:2081
void cfg_free_template(cfg_template_t *cfg)
Clean and free the cfg_template_t struct.
Definition: cfg.c:1375
status_t cfg_ok_to_read(const cfg_template_t *cfg)
Check if the specified config can be read right now.
Definition: cfg.c:2231
const xmlChar * cfg_get_last_ch_time(cfg_template_t *cfg)
Get the last-modified timestamp.
Definition: cfg.c:2992
const xmlChar * cfg_get_config_name(ncx_cfg_t cfgid)
Get the config name from its ID.
Definition: cfg.c:1475
status_t cfg_rwlock_acquire_locks(thd_tcb_t *tcb)
Acquire multiple locks in order to help prevent deadlock.
Definition: cfg.c:705
void cfg_get_lock_list(ses_id_t sesid, val_value_t *retval)
Get a list of all the locks held by a session.
Definition: cfg.c:2832
status_t cfg_ok_to_write(const cfg_template_t *cfg, ses_id_t sesid)
Check if the specified config can be written right now by the specified session ID.
Definition: cfg.c:2289
void cfg_delete_partial_lock(cfg_template_t *cfg, plock_id_t lockid)
Remove a partial lock from the specified config.
Definition: cfg.c:3238
void cfg_release_locks(ses_id_t sesid)
Release any configuration locks held by the specified session.
Definition: cfg.c:2720
status_t cfg_init_static_db(ncx_cfg_t cfg_id)
Initialize the specified static configuration slot.
Definition: cfg.c:1280
cfg_template_t * cfg_get_config_id(ncx_cfg_t cfgid)
Get the config struct from its ID.
Definition: cfg.c:1512
void cfg_register_reload_candidate_cb(cfg_reload_candidate_cb_t cbfn)
Register a callback function to be called anytime the.
Definition: cfg.c:3413
void cfg_set_state(ncx_cfg_t cfg_id, cfg_state_t new_state)
Change the state of the specified static config.
Definition: cfg.c:1398
status_t cfg_rwlock_release_all_locks(thd_tcb_t *tcb)
Release all RWLOCKs recorded in TCB lock state structure.
Definition: cfg.c:662
status_t cfg_rwlock_acquire_single_rdlock(thd_tcb_t *tcb, cfg_template_t *cfg)
Acquire a single RWLOCK for read access.
Definition: cfg.c:942
ncx_transaction_id_t cfg_get_last_txid(cfg_template_t *cfg)
Get the last good transaction ID.
Definition: cfg.c:3014
status_t cfg_lock_hold_timeout(ncx_cfg_t cfg_id)
Force a cfg lock to be undone due to max-lock-hold-time.
Definition: cfg.c:3583
cfg_state_t cfg_get_state(ncx_cfg_t cfg_id)
Get the state of the specified static config.
Definition: cfg.c:1426
void cfg_update_last_ch_time(cfg_template_t *cfg, time_t *timestamp)
Update the last-modified timestamp.
Definition: cfg.c:2913
void cfg_update_last_txid(cfg_template_t *cfg, ncx_transaction_id_t txid)
Update the last good transaction ID.
Definition: cfg.c:2946
status_t cfg_rwlock_acquire_single_lock(thd_tcb_t *tcb, cfg_template_t *cfg, boolean wrlock)
Acquire a single RWLOCK.
Definition: cfg.c:870
void(* cfg_reload_candidate_cb_t)(void)
support for server callback anytime the candidate config is reloaded from the running config <discard...
Definition: cfg.h:345
status_t cfg_unlock(cfg_template_t *cfg, ses_id_t locked_by)
Unlock the specified config.
Definition: cfg.c:2649
status_t cfg_fill_candidate_from_inline(ses_id_t sesid, val_value_t *newroot)
Fill the <candidate> config with the config contents of the <config> inline XML node.
Definition: cfg.c:1882
void cfg_apply_load_root(cfg_template_t *cfg, val_value_t *newroot)
Apply the AGT_CB_APPLY function for the OP_EDITOP_LOAD operation.
Definition: cfg.c:2880
plock_cb_t * cfg_next_partial_lock(plock_cb_t *curplockcb)
Get the next partial lock in the specified config.
Definition: cfg.c:3214
void cfg_clear_dirty_flag(cfg_template_t *cfg)
Clear the cfg dirty flag upon request.
Definition: cfg.c:1991
void cfg_set_target(ncx_cfg_t cfg_id)
Set the CFG_FL_TARGET flag in the specified config.
Definition: cfg.c:1533
cfg_source_t
classify the config source
Definition: cfg.h:209
status_t cfg_rwlock_rdlock(thd_tcb_t *tcb, cfg_template_t *cfg)
Take out the read lock associated with a cfg (datastore) RWLOCK structure May be called recursively.
Definition: cfg.c:251
val_value_t * cfg_get_root(ncx_cfg_t cfgid)
Get the config root for the specified config.
Definition: cfg.c:3346
status_t cfg_sprintf_etag(cfg_template_t *cfg, xmlChar *buff, int32 buffsize)
Write the Entity Tag for the datastore to the specified buffer.
Definition: cfg.c:3040
boolean cfg_is_global_locked(const cfg_template_t *cfg)
Check if the specified config has ab active global lock.
Definition: cfg.c:2415
status_t cfg_rwlock_unlock(thd_tcb_t *tcb, cfg_template_t *cfg)
Release a lock associated with a cfg (datastore) RWLOCK structure.
Definition: cfg.c:526
cfg_template_t * cfg_new_fake_candidate(const xmlChar *name, ncx_cfg_t cfg_id)
Malloc and initialize a new fake Candidate cfg_template_t struct.
Definition: cfg.c:3497
status_t cfg_unlock_ex(cfg_template_t *cfg, ses_id_t locked_by, boolean skip_reload)
Unlock the specified config.
Definition: cfg.c:2698
status_t cfg_sprintf_etag_id(ncx_transaction_id_t id, xmlChar *buff, int32 buffsize)
Write the Entity Tag for the datastore to the specified buffer Use the last_id instead of the cfg tem...
Definition: cfg.c:3068
@ CFG_ST_INIT
init in progress
Definition: cfg.h:200
@ CFG_ST_NONE
not set
Definition: cfg.h:199
@ CFG_ST_CLEANUP
cleanup in progress
Definition: cfg.h:204
@ CFG_ST_PLOCK
partial lock active
Definition: cfg.h:202
@ CFG_ST_READY
ready and no locks
Definition: cfg.h:201
@ CFG_ST_FLOCK
full lock active
Definition: cfg.h:203
uint32 plock_id_t
matches lock-id-type in YANG module
Definition: plock_cb.h:78
status_t
global error return code
Definition: status_enum.h:210
uint32 ses_id_t
Session ID.
Definition: ses.h:335
#define TSTAMP_MIN_SIZE
normal minimum buffer size for a tstamp buffer
Definition: tstamp.h:71
ncx_cfg_t
hardwire the 3 standard configs
Definition: ncxtypes.h:548
uint64 ncx_transaction_id_t
transaction is scoped to single session write operation on a config
Definition: ncxtypes.h:724
YANG module utility functions.
Contains NCX constants.
RFC 57517 partial lock support.
NETCONF Session Common definitions module.
Global error messages for status code enumerations.
struct representing 1 configuration database
Definition: cfg.h:229
boolean defer_load
TRUE if load is deferred due to sil-sa bundles.
Definition: cfg.h:337
boolean fake_candidate
TRUE if this is YANG-PATCH request fake candidate template.
Definition: cfg.h:327
xmlChar * name
datastore name string
Definition: cfg.h:251
boolean rw_wrlocked
PTHREADS=1 only: TRUE if currently write-locked.
Definition: cfg.h:313
cfg_location_t cfg_loc
config location: Enumeration identifying the configuration source location.
Definition: cfg.h:236
boolean locked_by_lockall
Flag indicating the global lock is from lock-all not lock.
Definition: cfg.h:276
pthread_rwlock_t rwlock
PTHREADS=1 only: rwlock data.
Definition: cfg.h:301
ses_id_t rw_wrlocked_by
PTHREADS=1 only: Single write lock holder, if any.
Definition: cfg.h:304
boolean rwlock_initialized
RWLOCK for this config - used by multiple reader/writer threads according to RWLOCK rules: basically,...
Definition: cfg.h:298
boolean wrlock_pending
TRUE if the wrlock is active and set.
Definition: cfg.h:319
ses_id_t locked_by
Session ID that owns the global configuration lock, if the database is currently locked.
Definition: cfg.h:273
dlq_hdr_t load_errQ
Queue of rpc_err_rec_t structures that represent any <rpc-error> records that were generated when the...
Definition: cfg.h:288
ncx_transaction_id_t cur_txid
current edit transaction ID
Definition: cfg.h:245
time_t lock_itime
time_t timestamp for max-lock-hold-time enforcement
Definition: cfg.h:259
xmlChar * src_url
source URL: URL for use with 'cfg_loc' to identify the configuration source.
Definition: cfg.h:256
uint32 flags
Internal configuration flags.
Definition: cfg.h:268
ses_id_t rw_rdlocked_by
Most recent read lock holder only, used for debugging if the background thread locks the cfg for fill...
Definition: cfg.h:310
boolean rw_rdlocked
PTHREADS=1 only: TRUE if currently read-locked.
Definition: cfg.h:316
ncx_transaction_id_t last_txid
last edit transaction ID
Definition: cfg.h:242
cfg_state_t cfg_state
config state: Current internal configuration state.
Definition: cfg.h:239
boolean in_cc_rollback
YPW-2036: flag to allow rollback transaction to indicate if the transaction is due to a confirmed-com...
Definition: cfg.h:334
ncx_cfg_t cfg_id
config ID: Internal configuration ID assigned to this configuration.
Definition: cfg.h:231
time_t last_modified
last modified timestamp
Definition: cfg.h:248
val_value_t * root
datastore root value.
Definition: cfg.h:324
struct representing 1 configuration database
Definition: plock_cb.h:81
Thread control block (TCB)
Definition: thd.h:175
one value to match one type
Definition: val.h:912
Thread support (for now limited to netconfd)
Value Node Basic Support.
Value Node Utilities.