738 lines
25 KiB
C
738 lines
25 KiB
C
|
/************************************************************************/
|
||
|
|
/* SISCO SOFTWARE MODULE HEADER *****************************************/
|
||
|
|
/************************************************************************/
|
||
|
|
/* (c) Copyright Systems Integration Specialists Company, Inc., */
|
||
|
|
/* 2004-2006 All Rights Reserved */
|
||
|
|
/* */
|
||
|
|
/* MODULE NAME : sclstore.c */
|
||
|
|
/* PRODUCT(S) : MMS-EASE-LITE */
|
||
|
|
/* */
|
||
|
|
/* MODULE DESCRIPTION : */
|
||
|
|
/* Functions to store information parsed from SCL file. */
|
||
|
|
/* */
|
||
|
|
/* GLOBAL FUNCTIONS DEFINED IN THIS MODULE : */
|
||
|
|
/* scl_lntype_create */
|
||
|
|
/* scl_lntype_add_do */
|
||
|
|
/* scl_dotype_create */
|
||
|
|
/* scl_dotype_add_da */
|
||
|
|
/* scl_dotype_add_sdo */
|
||
|
|
/* scl_datype_create */
|
||
|
|
/* scl_datype_add_bda */
|
||
|
|
/* scl_enumtype_create */
|
||
|
|
/* scl_enumtype_add_enumval */
|
||
|
|
/* scl_fcda_add */
|
||
|
|
/* scl_dai_add */
|
||
|
|
/* scl_dataset_add */
|
||
|
|
/* scl_rcb_add */
|
||
|
|
/* scl_lcb_add */
|
||
|
|
/* scl_gcb_add */
|
||
|
|
/* scl_ln_add */
|
||
|
|
/* scl_ld_create */
|
||
|
|
/* scl_info_destroy */
|
||
|
|
/* */
|
||
|
|
/* MODIFICATION LOG : */
|
||
|
|
/* Date Who Rev Comments */
|
||
|
|
/* -------- --- ------ ------------------------------------------- */
|
||
|
|
/* 04/23/08 JRB 11 Add scl_sgcb_add. */
|
||
|
|
/* 07/26/06 JRB 10 Add scl_subnet_add, scl_cap_add, scl_gse_add,*/
|
||
|
|
/* scl_smv_add. */
|
||
|
|
/* 04/04/06 JRB 09 Add scl_svcb_add: alloc SCL_SVCB & add to list.*/
|
||
|
|
/* 03/15/06 JRB 08 Simplify functions: Do not copy data. */
|
||
|
|
/* Most functions take only (SCL_INFO *) arg & */
|
||
|
|
/* just alloc struct and add to linked list. */
|
||
|
|
/* Del scl_dotype_add_da_val, */
|
||
|
|
/* scl_datype_add_bda_val, scl_header_save. */
|
||
|
|
/* 01/30/06 GLB 07 Integrated porting changes for VMS */
|
||
|
|
/* 07/25/05 JRB 06 If nameStructure!=IEDName, ignore it and */
|
||
|
|
/* assume nameStructure=IEDName anyway. */
|
||
|
|
/* 06/29/05 CRM 05 Add scl_info_destroy. */
|
||
|
|
/* 06/24/05 JRB 04 Chg "ord" from unsigned to signed value. */
|
||
|
|
/* 02/15/05 JRB 03 Chg scl_ld_create to generate scl_ld->domName.*/
|
||
|
|
/* Chg scl_fcda_add to generate scl_fcda->domName.*/
|
||
|
|
/* Chg scl_ln_add to generate scl_ln->varName. */
|
||
|
|
/* Add scl_header_save. */
|
||
|
|
/* 07/19/04 JRB 02 Add scl_lcb_add, scl_gcb_add. */
|
||
|
|
/* 06/10/04 JRB 01 Initial Revision. */
|
||
|
|
/************************************************************************/
|
||
|
|
#include "glbtypes.h"
|
||
|
|
#include "sysincs.h"
|
||
|
|
#include "scl.h"
|
||
|
|
#include "sx_log.h"
|
||
|
|
#include "str_util.h"
|
||
|
|
|
||
|
|
#ifdef DEBUG_SISCO
|
||
|
|
SD_CONST static ST_CHAR *SD_CONST thisFileName = __FILE__;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
/* NOTE:
|
||
|
|
* Functions with "scl_" prefix used while parsing SCL file to
|
||
|
|
* store data in linked lists.
|
||
|
|
* Functions with "scl2_" prefix (see sclproc.c) used to read info from
|
||
|
|
* linked lists and create MMS objects (Domains, variables, NVLs, etc.).
|
||
|
|
*/
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_lntype_create */
|
||
|
|
/* Begin creation of a Logical Node Type (LNodeType). */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_LNTYPE *scl_lntype_create (
|
||
|
|
SCL_INFO *scl_info) /* struct to store all SCL info */
|
||
|
|
{
|
||
|
|
SCL_LNTYPE *scl_lntype;
|
||
|
|
|
||
|
|
scl_lntype = (SCL_LNTYPE *) chk_calloc (1, sizeof (SCL_LNTYPE));
|
||
|
|
/* Add LNType to front of LNType List. */
|
||
|
|
list_add_first (&scl_info->lnTypeHead, scl_lntype);
|
||
|
|
return (scl_lntype);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_lntype_add_do */
|
||
|
|
/* Add a Data Object (DO) to a Logical Node Type (LNodeType). */
|
||
|
|
/* Adds to lntype created by most recent call to "scl_lntype_create". */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DO *scl_lntype_add_do (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_DO *scl_do = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->lnTypeHead)
|
||
|
|
{
|
||
|
|
scl_do = (SCL_DO *) chk_calloc (1, sizeof (SCL_DO));
|
||
|
|
/* Add DO to front of DO List in first entry of LNType list */
|
||
|
|
list_add_first (&scl_info->lnTypeHead->doHead, scl_do);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add DO to NULL LNTYPE");
|
||
|
|
return (scl_do);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_dotype_create */
|
||
|
|
/* Begin creation of a Data Object Type (DOType). */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DOTYPE *scl_dotype_create (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_DOTYPE *scl_dotype;
|
||
|
|
|
||
|
|
scl_dotype = (SCL_DOTYPE *) chk_calloc (1, sizeof (SCL_DOTYPE));
|
||
|
|
/* Add DOType to front of DOType List. */
|
||
|
|
list_add_first (&scl_info->doTypeHead, scl_dotype);
|
||
|
|
return (scl_dotype);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_dotype_add_da */
|
||
|
|
/* Add a Data Attribute (DA) to a Data Object Type (DOType). */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DA *scl_dotype_add_da (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_DA *scl_da = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->doTypeHead)
|
||
|
|
{
|
||
|
|
scl_da = (SCL_DA *) chk_calloc (1, sizeof (SCL_DA));
|
||
|
|
/* CRITICAL: DA and SDO use same struct, "objtype" tells which one it is.*/
|
||
|
|
scl_da->objtype = SCL_OBJTYPE_DA;
|
||
|
|
/* Add DA to front of DA List in first entry of DOType list */
|
||
|
|
list_add_first (&scl_info->doTypeHead->daHead, scl_da);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add DA to NULL DO");
|
||
|
|
return (scl_da);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_dotype_add_sdo */
|
||
|
|
/* Add a (SDO) to a Data Object Type (DOType). */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DA *scl_dotype_add_sdo (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_DA *scl_da = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->doTypeHead)
|
||
|
|
{
|
||
|
|
scl_da = (SCL_DA *) chk_calloc (1, sizeof (SCL_DA));
|
||
|
|
/* CRITICAL: DA and SDO use same struct, "objtype" tells which one it is.
|
||
|
|
* NOTE: Because this is SDO, the sAddr, bType, and valKind members of
|
||
|
|
* the scl_da structure are NOT used.
|
||
|
|
*/
|
||
|
|
scl_da->objtype = SCL_OBJTYPE_SDO;
|
||
|
|
/* Add DA to front of DA List in first entry of DOType list */
|
||
|
|
list_add_first (&scl_info->doTypeHead->daHead, scl_da);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add SDO to NULL DO");
|
||
|
|
return (scl_da);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_datype_create */
|
||
|
|
/* Begin creation of a Data Attribute Type (DAType). */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DATYPE *scl_datype_create (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_DATYPE *scl_datype;
|
||
|
|
|
||
|
|
scl_datype = (SCL_DATYPE *) chk_calloc (1, sizeof (SCL_DATYPE));
|
||
|
|
/* Add DAType to front of DAType List. */
|
||
|
|
list_add_first (&scl_info->daTypeHead, scl_datype);
|
||
|
|
return (scl_datype);
|
||
|
|
}
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_datype_add_bda */
|
||
|
|
/* Add a Basic Data Attribute (BDA) to a Data Attribute Type (DAType). */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_BDA *scl_datype_add_bda (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_BDA *scl_bda = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->daTypeHead)
|
||
|
|
{
|
||
|
|
scl_bda = (SCL_BDA *) chk_calloc (1, sizeof (SCL_BDA));
|
||
|
|
/* Add BDA to front of BDA List in first entry of DAType list */
|
||
|
|
list_add_first (&scl_info->daTypeHead->bdaHead, scl_bda);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add BDA to NULL DATYPE");
|
||
|
|
return (scl_bda);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_enumtype_create */
|
||
|
|
/* Begin creation of an EnumType. */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_ENUMTYPE *scl_enumtype_create (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_ENUMTYPE *scl_enumtype;
|
||
|
|
|
||
|
|
scl_enumtype = (SCL_ENUMTYPE *) chk_calloc (1, sizeof (SCL_ENUMTYPE));
|
||
|
|
/* Add EnumType to front of EnumType List. */
|
||
|
|
list_add_first (&scl_info->enumTypeHead, scl_enumtype);
|
||
|
|
return (scl_enumtype);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_enumtype_add_enumval */
|
||
|
|
/* Add an EnumVal to an EnumType. */
|
||
|
|
/* Add to EnumType created by most recent call to scl_enumtype_create. */
|
||
|
|
/* RETURNS: SD_SUCCESS or error code */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_ENUMVAL *scl_enumtype_add_enumval (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_ENUMVAL *scl_enumval = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->enumTypeHead)
|
||
|
|
{
|
||
|
|
scl_enumval = (SCL_ENUMVAL *) chk_calloc (1, sizeof (SCL_ENUMVAL));
|
||
|
|
/* Add EnumVal to front of EnumVal List in first entry of EnumType list */
|
||
|
|
list_add_first (&scl_info->enumTypeHead->enumvalHead, scl_enumval);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add ENUMVAL to NULL ENUMTYPE");
|
||
|
|
return (scl_enumval);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_fcda_add */
|
||
|
|
/* Allocates a SCL_FCDA struct */
|
||
|
|
/* and adds it to the linked list "fcdaHead" in SCL_DATASET. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_FCDA *scl_fcda_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_FCDA *scl_fcda = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead
|
||
|
|
&& scl_info->ldHead->lnHead->datasetHead)
|
||
|
|
{
|
||
|
|
scl_fcda = (SCL_FCDA *) chk_calloc (1, sizeof (SCL_FCDA));
|
||
|
|
/* Add FCDA to front of FCDA List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->datasetHead->fcdaHead, scl_fcda);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add FCDA to NULL DATASET");
|
||
|
|
|
||
|
|
return (scl_fcda);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_dai_add */
|
||
|
|
/* Allocates a SCL_DAI struct */
|
||
|
|
/* and adds it to the linked list "daiHead" in SCL_LN. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DAI *scl_dai_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_DAI *scl_dai = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
scl_dai = (SCL_DAI *) chk_calloc (1, sizeof (SCL_DAI));
|
||
|
|
/* Add DAI to front of DAI List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->daiHead, scl_dai);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add DAI to NULL LN");
|
||
|
|
return (scl_dai);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_dataset_add */
|
||
|
|
/* Allocates a SCL_DATASET struct */
|
||
|
|
/* and adds it to the linked list "datasetHead" in SCL_LN. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_DATASET *scl_dataset_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
/* TRUNCATED if longer than buffer */
|
||
|
|
{
|
||
|
|
SCL_DATASET *scl_dataset = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
scl_dataset = (SCL_DATASET *) chk_calloc (1, sizeof (SCL_DATASET));
|
||
|
|
/* Add DATASET to front of DATASET List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->datasetHead, scl_dataset);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add DATASET to NULL LN");
|
||
|
|
return (scl_dataset);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_rcb_add */
|
||
|
|
/* Alloc & add SCL_RCB struct to the linked list "rcbHead" in SCL_LN. */
|
||
|
|
/* NOTE: struct is not filled in yet. */
|
||
|
|
/* NOTE: the RptEnabled element of the SCL file is ignored. SISCO software*/
|
||
|
|
/* does not need to know which clients may access the RCB. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_RCB *scl_rcb_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_RCB *scl_rcb = NULL;
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
scl_rcb = (SCL_RCB *) chk_calloc (1, sizeof (SCL_RCB));
|
||
|
|
/* Add RCB to front of RCB List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->rcbHead, scl_rcb);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add RCB to NULL LN");
|
||
|
|
return (scl_rcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_lcb_add */
|
||
|
|
/* Alloc & add a SCL_LCB struct to the linked list "lcbHead" in SCL_LN. */
|
||
|
|
/* NOTE: struct is not filled in yet. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_LCB *scl_lcb_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_LCB *scl_lcb = NULL;
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
scl_lcb = (SCL_LCB *) chk_calloc (1, sizeof (SCL_LCB));
|
||
|
|
/* Add LCB to front of LCB List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->lcbHead, scl_lcb);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add LCB to NULL LN");
|
||
|
|
return (scl_lcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_gcb_add */
|
||
|
|
/* Add a GOOSE Control Block (GCB). */
|
||
|
|
/* Allocates a SCL_GCB struct */
|
||
|
|
/* and adds it to the linked list "gcbHead" in SCL_LN. */
|
||
|
|
/* NOTE: The SCL file may also contain one or more "IEDName" elements to*/
|
||
|
|
/* indicate IEDs that should subscribe for GOOSE data. We have no */
|
||
|
|
/* way to use this information, so it is ignored. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_GCB *scl_gcb_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_GCB *scl_gcb = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
scl_gcb = (SCL_GCB *) chk_calloc (1, sizeof (SCL_GCB));
|
||
|
|
/* Add GCB to front of GCB List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->gcbHead, scl_gcb);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add GCB (GOOSE Control Block) to NULL LN");
|
||
|
|
return (scl_gcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_sgcb_add */
|
||
|
|
/* Add a Setting Group Control Block (SGCB). */
|
||
|
|
/* Allocates a SCL_SGCB struct, stores ptr in "sgcb" in SCL_LN. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_SGCB *scl_sgcb_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_SGCB *scl_sgcb = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
/* Only one SGCB allowed. Make sure not already set. */
|
||
|
|
if (scl_info->ldHead->lnHead->sgcb != NULL)
|
||
|
|
{
|
||
|
|
SXLOG_ERR0 ("Duplicate SGCB (Setting Group Control Block) not allowed");
|
||
|
|
return (NULL);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
scl_info->ldHead->lnHead->sgcb = scl_sgcb = (SCL_SGCB *) chk_calloc (1, sizeof (SCL_SGCB));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add SGCB (Setting Group Control Block) to NULL LN");
|
||
|
|
return (scl_sgcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_svcb_add */
|
||
|
|
/* Alloc & add SCL_SVCB struct to the linked list "svcbHead" in SCL_LN. */
|
||
|
|
/* NOTE: struct is not filled in yet. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_SVCB *scl_svcb_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_SVCB *scl_svcb = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead
|
||
|
|
&& scl_info->ldHead->lnHead)
|
||
|
|
{
|
||
|
|
scl_svcb = (SCL_SVCB *) chk_calloc (1, sizeof(SCL_SVCB));
|
||
|
|
/* Add to front of list. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead->svcbHead, scl_svcb);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add SVCB to NULL LN");
|
||
|
|
return (scl_svcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_ln_add */
|
||
|
|
/* Allocates a SCL_LN struct */
|
||
|
|
/* and adds it to the linked list "lnHead" in SCL_LD. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_LN *scl_ln_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_LN *scl_ln = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->ldHead)
|
||
|
|
{
|
||
|
|
scl_ln = (SCL_LN *) chk_calloc (1, sizeof (SCL_LN));
|
||
|
|
/* Add LN to front of LN List. */
|
||
|
|
list_add_first (&scl_info->ldHead->lnHead, scl_ln);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add LN to NULL LD");
|
||
|
|
return (scl_ln);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_ld_create */
|
||
|
|
/* Allocates SCL_LD struct */
|
||
|
|
/* and adds it to the linked list "ldHead" in SCL_INFO. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_LD *scl_ld_create (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_LD *scl_ld = NULL; /* assume failure */
|
||
|
|
|
||
|
|
scl_ld = (SCL_LD *) chk_calloc (1, sizeof (SCL_LD));
|
||
|
|
/* Add LD to front of LD List. */
|
||
|
|
list_add_first (&scl_info->ldHead, scl_ld);
|
||
|
|
|
||
|
|
return (scl_ld);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_subnet_add */
|
||
|
|
/* Allocates SCL_SUBNET struct */
|
||
|
|
/* and adds it to the linked list "subnetHead" in SCL_INFO. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_SUBNET *scl_subnet_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_SUBNET *scl_subnet = NULL; /* assume failure */
|
||
|
|
|
||
|
|
scl_subnet = (SCL_SUBNET *) chk_calloc (1, sizeof (SCL_SUBNET));
|
||
|
|
/* Add to front of list. */
|
||
|
|
list_add_first (&scl_info->subnetHead, scl_subnet);
|
||
|
|
|
||
|
|
return (scl_subnet);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_cap_add */
|
||
|
|
/* Allocates a SCL_CAP struct */
|
||
|
|
/* and adds it to the linked list "capHead" in SCL_SUBNET. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_CAP *scl_cap_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_CAP *scl_cap = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->subnetHead)
|
||
|
|
{
|
||
|
|
scl_cap = (SCL_CAP *) chk_calloc (1, sizeof (SCL_CAP));
|
||
|
|
/* Add to front of list. */
|
||
|
|
list_add_first (&scl_info->subnetHead->capHead, scl_cap);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add CAP to NULL SUBNET");
|
||
|
|
return (scl_cap);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_gse_add */
|
||
|
|
/* Allocates a SCL_GSE struct */
|
||
|
|
/* and adds it to the linked list "gseHead" in SCL_CAP. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_GSE *scl_gse_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_GSE *scl_gse = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->subnetHead->capHead)
|
||
|
|
{
|
||
|
|
scl_gse = (SCL_GSE *) chk_calloc (1, sizeof (SCL_GSE));
|
||
|
|
/* Add to front of list. */
|
||
|
|
list_add_first (&scl_info->subnetHead->capHead->gseHead, scl_gse);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add GSE to NULL CAP");
|
||
|
|
return (scl_gse);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_smv_add */
|
||
|
|
/* Allocates a SCL_SMV struct */
|
||
|
|
/* and adds it to the linked list "smvHead" in SCL_CAP. */
|
||
|
|
/************************************************************************/
|
||
|
|
SCL_SMV *scl_smv_add (
|
||
|
|
SCL_INFO *scl_info) /* main struct where all SCL info stored*/
|
||
|
|
{
|
||
|
|
SCL_SMV *scl_smv = NULL; /* assume failure */
|
||
|
|
|
||
|
|
/* All higher level linked lists must be initialized. */
|
||
|
|
if (scl_info->subnetHead->capHead)
|
||
|
|
{
|
||
|
|
scl_smv = (SCL_SMV *) chk_calloc (1, sizeof (SCL_SMV));
|
||
|
|
/* Add to front of list. */
|
||
|
|
list_add_first (&scl_info->subnetHead->capHead->smvHead, scl_smv);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
SXLOG_ERR0 ("Cannot add SMV to NULL CAP");
|
||
|
|
return (scl_smv);
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* scl_info_destroy */
|
||
|
|
/* Destroy all info stored in the SCL_INFO structure by "scl_parse". */
|
||
|
|
/* NOTE: most buffers were allocated by functions in this module. The */
|
||
|
|
/* elements "Val" and "desc" in several structures were allocated */
|
||
|
|
/* by functions in "sclparse.c". */
|
||
|
|
/************************************************************************/
|
||
|
|
ST_VOID scl_info_destroy (SCL_INFO *scl_info)
|
||
|
|
{
|
||
|
|
SCL_LNTYPE *lnType;
|
||
|
|
SCL_DO *scl_do;
|
||
|
|
SCL_LD *scl_ld;
|
||
|
|
SCL_LN *scl_ln;
|
||
|
|
SCL_RCB *scl_rcb;
|
||
|
|
SCL_LCB *scl_lcb;
|
||
|
|
SCL_GCB *scl_gcb;
|
||
|
|
SCL_SVCB *scl_svcb;
|
||
|
|
SCL_DAI *scl_dai;
|
||
|
|
SCL_DATASET *scl_dataset;
|
||
|
|
SCL_FCDA *scl_fcda;
|
||
|
|
SCL_DATYPE * scl_daType;
|
||
|
|
SCL_BDA *scl_bda;
|
||
|
|
SCL_ENUMTYPE *scl_enum;
|
||
|
|
SCL_ENUMVAL *scl_enumval;
|
||
|
|
SCL_DOTYPE *scl_doType;
|
||
|
|
SCL_DA *scl_da;
|
||
|
|
SCL_SUBNET *scl_subnet;
|
||
|
|
SCL_CAP *scl_cap;
|
||
|
|
SCL_GSE *scl_gse;
|
||
|
|
SCL_SMV *scl_smv;
|
||
|
|
|
||
|
|
while ((scl_subnet = (SCL_SUBNET *) list_get_first(&scl_info->subnetHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_cap = (SCL_CAP *) list_get_first(&scl_subnet->capHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_gse = (SCL_GSE *) list_get_first(&scl_cap->gseHead)) != NULL)
|
||
|
|
{
|
||
|
|
chk_free(scl_gse);
|
||
|
|
}
|
||
|
|
while ((scl_smv = (SCL_SMV *) list_get_first(&scl_cap->smvHead)) != NULL)
|
||
|
|
{
|
||
|
|
chk_free(scl_smv);
|
||
|
|
}
|
||
|
|
if (scl_cap->desc)
|
||
|
|
chk_free (scl_cap->desc);
|
||
|
|
chk_free (scl_cap);
|
||
|
|
}
|
||
|
|
if (scl_subnet->desc)
|
||
|
|
chk_free (scl_subnet->desc);
|
||
|
|
chk_free (scl_subnet);
|
||
|
|
}
|
||
|
|
|
||
|
|
while ((scl_daType = (SCL_DATYPE *) list_get_first (&scl_info->daTypeHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_bda = (SCL_BDA *) list_get_first (&scl_daType->bdaHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_bda->desc)
|
||
|
|
chk_free (scl_bda->desc);
|
||
|
|
if (scl_bda->Val)
|
||
|
|
chk_free (scl_bda->Val);
|
||
|
|
chk_free (scl_bda);
|
||
|
|
}
|
||
|
|
chk_free (scl_daType);
|
||
|
|
}
|
||
|
|
|
||
|
|
while ((lnType = (SCL_LNTYPE *) list_get_first (&scl_info->lnTypeHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_do = (SCL_DO *) list_get_first (&lnType->doHead)) != NULL)
|
||
|
|
{
|
||
|
|
chk_free (scl_do);
|
||
|
|
}
|
||
|
|
chk_free (lnType);
|
||
|
|
}
|
||
|
|
while ((scl_doType = (SCL_DOTYPE *) list_get_first (&scl_info->doTypeHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_da = (SCL_DA *) list_get_first (&scl_doType->daHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_da->desc)
|
||
|
|
chk_free (scl_da->desc);
|
||
|
|
if (scl_da->Val)
|
||
|
|
chk_free (scl_da->Val);
|
||
|
|
chk_free (scl_da);
|
||
|
|
}
|
||
|
|
chk_free (scl_doType);
|
||
|
|
}
|
||
|
|
while ((scl_enum = (SCL_ENUMTYPE *) list_get_first (&scl_info->enumTypeHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_enumval = (SCL_ENUMVAL *) list_get_first (&scl_enum->enumvalHead)) != NULL)
|
||
|
|
{
|
||
|
|
chk_free (scl_enumval);
|
||
|
|
}
|
||
|
|
chk_free (scl_enum);
|
||
|
|
}
|
||
|
|
while ((scl_ld = (SCL_LD *) list_get_first (&scl_info->ldHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_ln = (SCL_LN *) list_get_first (&scl_ld->lnHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_dai = (SCL_DAI *) list_get_first (&scl_ln->daiHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_dai->Val)
|
||
|
|
chk_free (scl_dai->Val);
|
||
|
|
chk_free (scl_dai);
|
||
|
|
}
|
||
|
|
|
||
|
|
while ((scl_dataset = (SCL_DATASET *) list_get_first (&scl_ln->datasetHead)) != NULL)
|
||
|
|
{
|
||
|
|
while ((scl_fcda = (SCL_FCDA *) list_get_first (&scl_dataset->fcdaHead)) != NULL)
|
||
|
|
{
|
||
|
|
chk_free (scl_fcda);
|
||
|
|
}
|
||
|
|
if (scl_dataset->desc)
|
||
|
|
chk_free (scl_dataset->desc);
|
||
|
|
chk_free (scl_dataset);
|
||
|
|
}
|
||
|
|
|
||
|
|
while ((scl_rcb = (SCL_RCB *) list_get_first (&scl_ln->rcbHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_rcb->desc)
|
||
|
|
chk_free (scl_rcb->desc);
|
||
|
|
chk_free (scl_rcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
while ((scl_lcb = (SCL_LCB *) list_get_first (&scl_ln->lcbHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_lcb->desc)
|
||
|
|
chk_free (scl_lcb->desc);
|
||
|
|
chk_free (scl_lcb);
|
||
|
|
}
|
||
|
|
|
||
|
|
while ((scl_gcb = (SCL_GCB *) list_get_first (&scl_ln->gcbHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_gcb->desc)
|
||
|
|
chk_free (scl_gcb->desc);
|
||
|
|
chk_free (scl_gcb);
|
||
|
|
}
|
||
|
|
while ((scl_svcb = (SCL_SVCB *) list_get_first (&scl_ln->svcbHead)) != NULL)
|
||
|
|
{
|
||
|
|
if (scl_svcb->desc)
|
||
|
|
chk_free (scl_svcb->desc);
|
||
|
|
chk_free (scl_svcb);
|
||
|
|
}
|
||
|
|
/* Only one SGCB allowed (no linked list) */
|
||
|
|
if (scl_ln->sgcb)
|
||
|
|
{
|
||
|
|
if (scl_ln->sgcb->desc)
|
||
|
|
chk_free (scl_ln->sgcb->desc);
|
||
|
|
chk_free (scl_ln->sgcb);
|
||
|
|
}
|
||
|
|
if (scl_ln->desc)
|
||
|
|
chk_free (scl_ln->desc);
|
||
|
|
chk_free (scl_ln);
|
||
|
|
}
|
||
|
|
if (scl_ld->desc)
|
||
|
|
chk_free (scl_ld->desc);
|
||
|
|
chk_free (scl_ld);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|