cfg.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
 *
 * 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 _H_cfg
#define _H_cfg
/*  FILE: cfg.h
*********************************************************************
*                                                                   *
*                         P U R P O S E                             *
*                                                                   *
*********************************************************************/
 
/*********************************************************************
*                                                                   *
*                   C H A N G E         H I S T O R Y               *
*                                                                   *
*********************************************************************
 
date             init     comment
----------------------------------------------------------------------
15-apr-06    abb      Begun.
29-may-08    abb      Converted NCX database model to simplified
                      YANG object model
*/
#include <xmlstring.h>
 
#ifndef _H_dlq
#include "dlq.h"
#endif
 
#ifndef _H_ncx
#include "ncx.h"
#endif
 
#ifndef _H_ncxconst
#include "ncxconst.h"
#endif
 
#ifndef _H_plock
#include "plock.h"
#endif
 
#ifndef _H_ses
#include "ses.h"
#endif
 
#ifndef _H_status
#include "status.h"
#endif
 
#ifndef _H_val
#include "val.h"
#endif
 
#ifndef _H_val_util
#include "val_util.h"
#endif
 
#ifndef _H_thd
#include "thd.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
/********************************************************************
*                                                                   *
*                         C O N S T A N T S                         *
*                                                                   *
*********************************************************************/
 
/* bit definitions for the cfg_template->flags field */
#define CFG_FL_TARGET       bit0
#define CFG_FL_DIRTY        bit1
#define CFG_FL_FORCE_DEADNODES bit2
#define CFG_FL_FORCE_TOP_DEFAULTS bit3
#define CFG_FL_EXTERN_NVSTORE  bit4
 
#define CFG_INITIAL_TXID (ncx_transaction_id_t)0
 
/* this must match the number of enums in ncx_cfg_t (NCX_CFGID_CNT) */
#define CFG_NUM_STATIC   3
 
#define CFG_GET_FORCE_DEADNODES(C) ((C)->flags & CFG_FL_FORCE_DEADNODES)
 
#define CFG_SET_FORCE_DEADNODES(C) (C)->flags |= CFG_FL_FORCE_DEADNODES
 
#define CFG_GET_FORCE_TOP_DEFAULTS(C) ((C)->flags & CFG_FL_FORCE_TOP_DEFAULTS)
 
#define CFG_SET_FORCE_TOP_DEFAULTS(C) (C)->flags |= CFG_FL_FORCE_TOP_DEFAULTS
 
 
#define CFG_SET_EXTERN_NVSTORE(C)   (C)->flags |= CFG_FL_EXTERN_NVSTORE
 
#define CFG_IS_EXTERN_NVSTORE(C)    ((C)->flags & CFG_FL_EXTERN_NVSTORE)
 
/*
 * Define constants for use with cfg_rwlock_acquire_xxx() functions
 * and data structures:
 */
 
#define CFG_RWLOCK_READ_ACCESS  FALSE
#define CFG_RWLOCK_WRITE_ACCESS TRUE
#define READ_ACCESS CFG_RWLOCK_READ_ACCESS
#define WRITE_ACCESS CFG_RWLOCK_WRITE_ACCESS
 
#define CFG_GET_ROOT(C) ((C)->root)
 
#define CFG_GET_ID(C) ((C)->cfg_id)
 
#define CFG_IN_CC_ROLLBACK(C) (C)->in_cc_rollback
 
#define CFG_DEFER_LOAD(C) ((C)->defer_load)
 
 
/********************************************************************
*                                                                   *
*                        T Y P E S                                  *
*                                                                   *
*********************************************************************/
 
 
 
typedef enum cfg_state_t_ {
    CFG_ST_NONE,                  
    CFG_ST_INIT,                  
    CFG_ST_READY,                 
    CFG_ST_PLOCK,                 
    CFG_ST_FLOCK,                 
    CFG_ST_CLEANUP                
} cfg_state_t;
 
 
typedef enum cfg_source_t_ {
    CFG_SRC_NONE,
    CFG_SRC_INTERNAL,
    CFG_SRC_NETCONF,
    CFG_SRC_CLI,
    CFG_SRC_SNMP,
    CFG_SRC_HTTP,
    CFG_SRC_OTHER
} cfg_source_t;
 
 
typedef enum cfg_location_t_ {
    CFG_LOC_NONE,
    CFG_LOC_FILE,
    CFG_LOC_REMOTE_URL
} cfg_location_t;
 
 
typedef struct cfg_template_t_ {
    ncx_cfg_t      cfg_id;
 
    cfg_location_t cfg_loc;
 
    cfg_state_t    cfg_state;
 
    ncx_transaction_id_t last_txid;
 
    ncx_transaction_id_t cur_txid;
 
    time_t last_modified;
 
    xmlChar       *name;
 
    xmlChar       *src_url;
 
    time_t         lock_itime;
 
    xmlChar        lock_time[TSTAMP_MIN_SIZE];
 
    xmlChar        last_ch_time[TSTAMP_MIN_SIZE]; // TBD: remove!
 
    uint32         flags;
 
    ses_id_t       locked_by;
 
    boolean        locked_by_lockall;
 
    /* source of the config lock:
     * If the database is locked, identifies the protocol or other
     * source that currently caused the database to be locked.
     */
    cfg_source_t   lock_src;
 
    dlq_hdr_t      load_errQ;
 
    /* Queue of plock_cb_t for partial lock support */
    dlq_hdr_t      plockQ;
 
    boolean rwlock_initialized;
 
    pthread_rwlock_t rwlock;
 
    ses_id_t         rw_wrlocked_by;
 
    ses_id_t         rw_rdlocked_by;
 
    boolean          rw_wrlocked;
 
    boolean          rw_rdlocked;
 
    boolean          wrlock_pending;
 
    val_value_t     *root;
 
    boolean          fake_candidate;
 
    boolean          in_cc_rollback;
 
    boolean          defer_load;
 
} cfg_template_t;
 
 
typedef void (*cfg_reload_candidate_cb_t) (void);
 
 
 
/********************************************************************
*                                                                   *
*                       V A R I A B L E S                           *
*                                                                   *
*********************************************************************/
 
#ifdef PTHREADS
extern boolean wrlock_pending;
#endif
 
/********************************************************************
*                                                                   *
*                        F U N C T I O N S                          *
*                                                                   *
*********************************************************************/
 
 
extern void
    cfg_ypinit (void);
 
 
extern void
    cfg_clean_roots (void);
 
 
extern void
    cfg_cleanup (void);
 
 
 
#ifdef PTHREADS
extern status_t cfg_rwlock_rdlock (thd_tcb_t *tcb, cfg_template_t *cfg);
 
 
extern status_t cfg_rwlock_wrlock (thd_tcb_t *tcb, cfg_template_t *cfg);
 
 
extern status_t cfg_rwlock_unlock (thd_tcb_t *tcb, cfg_template_t *cfg);
 
 
extern status_t cfg_rwlock_init_req_locks (thd_tcb_t *tcb);
 
 
extern status_t cfg_rwlock_release_all_locks (thd_tcb_t *tcb);
 
 
extern status_t cfg_rwlock_acquire_locks (thd_tcb_t *tcb);
 
 
extern status_t
    cfg_rwlock_acquire_lock_pair (thd_tcb_t *tcb,
                                  cfg_template_t *cfg1,
                                  boolean wrlock1,
                                  cfg_template_t *cfg2,
                                  boolean wrlock2);
 
 
extern status_t cfg_rwlock_acquire_single_lock (thd_tcb_t *tcb,
                     cfg_template_t *cfg,
                     boolean wrlock);
 
 
extern status_t
    cfg_rwlock_acquire_single_rdlock (thd_tcb_t *tcb, cfg_template_t *cfg);
 
 
 
extern status_t
    cfg_rwlock_acquire_single_wrlock (thd_tcb_t *tcb, cfg_template_t *cfg);
 
#endif   // PTHREADS
 
 
extern status_t
    cfg_init_static_db (ncx_cfg_t cfg_id);
 
 
extern cfg_template_t *
    cfg_new_template (const xmlChar *name,
              ncx_cfg_t cfg_id);
 
 
extern void
    cfg_free_template (cfg_template_t *cfg);
 
 
extern void
    cfg_set_state (ncx_cfg_t cfg_id,
           cfg_state_t new_state);
 
 
extern cfg_state_t
    cfg_get_state (ncx_cfg_t cfg_id);
 
 
extern cfg_template_t *
    cfg_get_config (const xmlChar *cfgname);
 
 
extern const xmlChar *
    cfg_get_config_name (ncx_cfg_t cfgid);
 
 
extern cfg_template_t *
    cfg_get_config_id (ncx_cfg_t cfgid);
 
 
extern void
    cfg_set_target (ncx_cfg_t cfg_id);
 
 
extern status_t
    cfg_fill_candidate_from_running (ses_id_t sesid);
 
 
extern status_t
    cfg_fill_candidate_from_startup (ses_id_t sesid);
 
 
extern status_t
    cfg_fill_candidate_from_inline (ses_id_t sesid,
                                    val_value_t *newroot);
 
 
extern void
    cfg_set_dirty_flag (cfg_template_t *cfg);
 
 
void cfg_clear_dirty_flag (cfg_template_t *cfg);
 
 
extern void
    cfg_clear_running_dirty_flag (void);
 
 
extern void
    cfg_clear_candidate_dirty_flag (void);
 
 
extern boolean
    cfg_get_dirty_flag (const cfg_template_t *cfg);
 
 
extern status_t
    cfg_ok_to_lock (const cfg_template_t *cfg);
 
 
extern status_t
    cfg_ok_to_unlock (const cfg_template_t *cfg,
              ses_id_t sesid);
 
 
extern status_t
    cfg_ok_to_unlock2 (const cfg_template_t *cfg,
                       ses_id_t sesid,
                       boolean lockall);
 
 
extern status_t
    cfg_ok_to_read (const cfg_template_t *cfg);
 
 
extern status_t
    cfg_ok_to_write (const cfg_template_t *cfg,
             ses_id_t sesid);
 
 
extern boolean
    cfg_is_global_locked (const cfg_template_t *cfg);
 
 
extern boolean
    cfg_is_partial_locked (const cfg_template_t *cfg);
 
 
extern status_t
    cfg_get_global_lock_info (const cfg_template_t *cfg,
                              ses_id_t  *sesid,
                              const xmlChar **locktime);
 
 
extern status_t
    cfg_lock (cfg_template_t *cfg,
          ses_id_t locked_by,
          cfg_source_t  lock_src);
 
 
extern status_t
    cfg_lock2 (cfg_template_t *cfg,
               ses_id_t locked_by,
               cfg_source_t  lock_src,
               boolean lockall);
 
 
extern status_t
    cfg_unlock (cfg_template_t *cfg,
        ses_id_t locked_by);
 
 
extern status_t
    cfg_unlock2 (cfg_template_t *cfg,
                 ses_id_t locked_by,
                 boolean lockall);
 
 
 
extern status_t
    cfg_unlock_ex (cfg_template_t *cfg,
                   ses_id_t locked_by,
                   boolean skip_reload);
 
 
extern void
    cfg_release_locks (ses_id_t sesid);
 
 
extern void
    cfg_release_partial_locks (ses_id_t sesid);
 
 
extern void
    cfg_get_lock_list (ses_id_t sesid,
               val_value_t *retval);
 
 
extern void
    cfg_apply_load_root (cfg_template_t *cfg,
             val_value_t *newroot);
 
 
extern void
    cfg_update_last_ch_time (cfg_template_t *cfg,
                             time_t *timestamp);
 
 
extern void
    cfg_update_last_txid (cfg_template_t *cfg,
                          ncx_transaction_id_t txid);
 
 
extern void
    cfg_update_stamps (cfg_template_t *source,
                       cfg_template_t *dest);
 
 
extern const xmlChar *
    cfg_get_last_ch_time (cfg_template_t *cfg);
 
 
extern ncx_transaction_id_t
    cfg_get_last_txid (cfg_template_t *cfg);
 
 
extern status_t
    cfg_sprintf_etag (cfg_template_t *cfg,
                      xmlChar *buff,
                      int32 buffsize);
 
 
extern status_t
    cfg_sprintf_etag_id (ncx_transaction_id_t id,
                         xmlChar *buff,
                         int32 buffsize);
 
 
extern status_t
    cfg_add_partial_lock (cfg_template_t *cfg,
                          plock_cb_t *plcb);
 
 
extern plock_cb_t *
    cfg_find_partial_lock (cfg_template_t *cfg,
                           plock_id_t lockid);
 
 
extern plock_cb_t *
    cfg_first_partial_lock (cfg_template_t *cfg);
 
 
extern plock_cb_t *
    cfg_next_partial_lock (plock_cb_t *curplockcb);
 
 
extern void
    cfg_delete_partial_lock (cfg_template_t *cfg,
                             plock_id_t lockid);
 
 
extern status_t
    cfg_ok_to_partial_lock (const cfg_template_t *cfg);
 
 
extern val_value_t *
    cfg_get_root (ncx_cfg_t cfgid);
 
 
extern status_t
    cfg_setup_running (void);
 
 
extern void
    cfg_register_reload_candidate_cb (cfg_reload_candidate_cb_t cbfn);
 
 
extern const xmlChar *
    cfg_get_startup_filespec (void);
 
 
#ifdef PTHREADS
extern boolean
    cfg_running_is_wrlocked (void);
 
 
extern boolean
    cfg_candidate_is_wrlocked (void);
 
#endif  // PTHREADS
 
 
extern cfg_template_t *
    cfg_new_fake_candidate (const xmlChar *name,
                            ncx_cfg_t cfg_id);
 
 
extern void
    cfg_set_defer_load (boolean val);
 
 
 
extern time_t
    cfg_get_lock_itime (ncx_cfg_t cfg_id);
 
 
extern status_t
    cfg_lock_hold_timeout (ncx_cfg_t cfg_id);
 
 
#ifdef __cplusplus
}  /* end extern 'C' */
#endif
 
#endif            /* _H_cfg */