lnk/microser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0b8a6739f634ab2a0f5b9ed9a7ed16c858c1575c
microser/mmslib/mvlu/sclproc.c

3287 lines
126 KiB
C
Raw Normal View History

自主协议库编译通过
2026-06-15 15:48:16 +08:00
/************************************************************************/
/* SISCO SOFTWARE MODULE HEADER *****************************************/
/************************************************************************/
/* (c) Copyright Systems Integration Specialists Company, Inc., */
/* 2004-2006 All Rights Reserved */
/* */
/* MODULE NAME : sclproc.c */
/* PRODUCT(S) : MMS-EASE-LITE */
/* */
/* MODULE DESCRIPTION : */
/* Functions to "post-proccess" information parsed from SCL file. */
/* */
/* GLOBAL FUNCTIONS DEFINED IN THIS MODULE : */
/* scl2_datatype_create_all */
/* scl2_ld_create_all */
/* */
/* NOTE: FC must be "ST" "MX" "CO" "SP" "SG" "SE" "SV" "CF" "DC" or "EX"*/
/* */
/* NOTE: scl2_datatype_create_all allocates an array of RESERVED_INFO */
/* structures to save extra SCL data for each datatype created. */
/* The array pointer is saved in the reserved_1 member of */
/* RUNTIME_CTRL, to be used later by scl2_ld_create_all, */
/* which then frees it (see reserved_free_all). */
/* */
/* MODIFICATION LOG : */
/* Date Who Rev Comments */
/* -------- --- ------ ------------------------------------------- */
/* 07/30/08 JRB 47 Init DstAddress in GSSE control block. */
/* 05/14/08 JRB 46 rtadd_da_or_bda: save init Val for Enum too. */
/* Move FLOW log inside "if" for BasicType. */
/* 04/23/08 JRB 45 If SGCB configured, add it to "SP". */
/* Eliminate warnings. */
/* 04/20/08 JRB 44 Add DstAddress to GSSE control block. */
/* 03/03/08 JRB 43 Use new mvl_var_add_alloc (avoids extra alloc)*/
/* 02/25/08 JRB 42 Add ObjRef type and map to VisString129. */
/* Add INT64, INT64U types. */
/* 02/25/08 JRB 41 For bType=Enum, convert Val text as a number */
/* ONLY if text does not match any EnumVal. */
/* 12/20/07 JRB 40 Add rcb_name_no_index flag. */
/* 12/13/07 JRB 39 Allow nested SDO (needed for Wind Power). */
/* scl_gse_find: match "cbName" also. */
/* 10/29/07 JRB 38 strncat_safe obsolete, use strncat_maxstrlen.*/
/* 09/05/07 JRB 37 Chg "Check" (PACKED LIST) to bvstring. */
/* 08/13/07 MDE 36 Added more scl_debug_mode */
/* 08/10/07 JRB 35 scl2_dai_set_value: if no "Val", do nothing. */
/* 08/02/07 JRB 34 scl2_datatype_create: use new ms_rt_bld* */
/* features to avoid realloc. */
/* 07/03/07 JRB 33 Init DstAddress struct in MVL61850_GCB_DATA. */
/* Add scl_gse_find. */
/* 05/10/07 JRB 32 Reallocate reserved_1 smaller to save mem. */
/* 03/06/07 JRB 31 Fix LogRef initial value (ObjectReference). */
/* 02/13/07 JRB 30 Use RptEnabled max attribute for BRCB too. */
/* Save rpt scan rate in rpt_ctrl->scan_rate. */
/* 10/30/06 JRB 29 scl2_datatype_create_all: all args changed. */
/* scl2_ld_create_all: add vmd_ctrl, is_client args.*/
/* Use <Val> element of <DA> or <BDA> to init */
/* all variables containing the attribute. */
/* Instead of creating TDL, create RUNTIME_TYPE */
/* array directly (allows saving extra type info).*/
/* Don't need type names anymore. Only use names*/
/* if caller requests it. */
/* Allow bType="Check", "VisString???". */
/* 08/21/06 MDE 28 Added more scl_debug_mode */
/* 08/09/06 JRB 27 Create multiple RCBs for each URCB configured.*/
/* Add 01, 02, etc suffixes to all RCB names. */
/* Allow scl_rcb->datSet="" (i.e. datSet not */
/* present in ReportControl element of SCL file).*/
/* Allow datSet write with mvl61850_datset_wr_ind.*/
/* Chg DatSet in BRCB, URCB, GCB, LCB, MSVCB, */
/* and USVCB to Vstring129. */
/* Chg LogRef in LCB to Vstring129. */
/* Del mvlu_rpt_create_scan_ctrl2 call */
/* (new mvl61850_rpt_service automatically scans).*/
/* 08/04/06 MDE 26 Tweaked logging */
/* 08/04/06 MDE 25 Added scl_debug_mode, scl2_add_btype, etc. */
/* 06/22/06 RKR 24 Added Vstring129 */
/* 03/20/06 JRB 23 Add code for Sampled Value config (see svcb).*/
/* Del unused scl_rcb_counters. */
/* 12/14/05 JRB 22 Fix init val of DatSet in LCB or GCB */
/* (must be ObjectReference). */
/* 11/22/05 JRB 21 Fix spelling of "BufTm" in brcb, urcb. */
/* (Only UCA uses the spelling "BufTim"). */
/* 09/15/05 JRB 20 Fix spelling. */
/* 07/27/05 JRB 19 Don't set OptFlds len=9 (default=10 is good).*/
/* Don't set OptFlds bits bufovfl, entryID for URCB.*/
/* 07/25/05 JRB 18 scl2_ld_create_all: Add brcb_bufsize arg. */
/* 07/21/05 JRB 17 Set initial vals for LCB, GCB, SCB. */
/* 07/11/05 JRB 16 scl2_ld_create_all: Call */
/* mvl61850_ctl_lastapplerror_create. */
/* 06/27/05 JRB 15 Use mvl_nvl_add (mvlu_rpt_nvl_add is obsolete).*/
/* 05/27/05 JRB 14 Construct NVL name from LN & DataSet name */
/* as 61850-8-1 requires. */
/* 05/25/05 JRB 13 Del all code to generate RCB name & just use */
/* name configured in SCL file (scl_rcb->name). */
/* Add errflag so if one call to tdladd_string */
/* fails, subsequent calls fail too. */
/* 05/09/05 JRB 12 Chg leaf write functions for SqNum (in BRCB */
/* & URCB) to u_no_write_allowed. */
/* 04/05/05 MDE 11 Supress invalid log messages */
/* 03/18/05 JRB 10 Use mvl_max_dyn when creating domains. */
/* 02/15/05 JRB 09 Use new generated scl_ld->domName, not */
/* scl_ld->inst as domain name. */
/* Use new generated scl_fcda->domName, not */
/* scl_fcda->ldInst as domain name. */
/* Use new scl_ln->varName, generated once, */
/* instead of generating ln_name repeatedly. */
/* Compute max_num_var for mvl_dom_add call. */
/* 01/19/05 JRB 08 Add scl2_dai_set_value_all & use it to init */
/* data from DOI/SDI/DAI entries in SCL file. */
/* Fix len on all strncat calls. */
/* scl2_rcb_create_all: init ln_name just once. */
/* Improve some logging. */
/* 09/01/04 JRB 07 Map Octet64 to OVstring64 (to match 61850-8-1)*/
/* 08/29/04 JRB 06 Chg Quality type back to BVstring13 because */
/* final IEC-61850-8-1 changed back. */
/* 08/19/04 JRB 05 Init return value in scl2_ld_create_all. */
/* 07/19/04 JRB 04 Add tdladd_lg, tdladd_go_or_gs. */
/* 07/14/04 JRB 03 Chg Quality type to BVstring14. */
/* 07/09/04 JRB 02 scl2_ld_create_all: add reportScanRate arg */
/* to this and lower level functions. */
/* 07/02/04 JRB 01 Initial Revision. */
/************************************************************************/
#include "glbtypes.h"
#include "sysincs.h"
#include "scl.h"
#include "sx_log.h"
#include "mvl_defs.h"
#include "mvl_uca.h"
#include "mvl_log.h"
#include "str_util.h" /* for strn..._safe protos */
#include "sx_arb.h" /* for sxaText.... proto */
/*renxiaobao <20><><EFBFBD><EFBFBD>ӳ<EFBFBD><D3B3>*/
DATA_MAP_LINK *DATA_MAP_saddr=0;
int BRCB_NUM = 0,URCB_NUM = 0;
#ifdef DEBUG_SISCO
SD_CONST static ST_CHAR *SD_CONST thisFileName = __FILE__;
#endif
/* RESERVED_INFO: structure for extra type related info that is not */
/* contained in RUNTIME_TYPE or RUNTIME_CTRL. Allocate array of these. */
typedef struct
{
SCL_ENUMTYPE *scl_enumtype; /* SCL enumtype def for this type */
ST_CHAR *Val; /* SCL initial value for this type */
} RESERVED_INFO;
/* CRITICAL: this struct must be compatible with RUNTIME_TYPE. */
/* If either one changes, the other must change to match. */
typedef struct
{
ST_UINT8 LogEna; /* Bool */
ST_CHAR LogRef[MVL61850_MAX_OBJREF_LEN+1]; /* Vstring129 (ObjectReference) */
ST_CHAR DatSet[MVL61850_MAX_OBJREF_LEN+1]; /* Vstring129 (ObjectReference) */
MMS_BTIME6 OldEntrTim; /* Btime6 */
MMS_BTIME6 NewEntrTim; /* Btime6 */
ST_UINT8 OldEntr[8]; /* Ostring8 */
ST_UINT8 NewEntr[8]; /* Ostring8 */
MMS_BVSTRING TrgOps; /* BVstring6 - struct includes 1 byte data. Enough.*/
ST_UINT32 IntgPd; /* Ulong */
} MVL61850_LCB_DATA; /* struct to store data for LCB (IEC Log Control Block) */
/* CRITICAL: this struct must be compatible with RUNTIME_TYPE. */
/* If either one changes, the other must change to match. */
typedef struct
{
ST_BOOLEAN GoEna;
ST_CHAR GoID[66];
ST_CHAR DatSet[MVL61850_MAX_OBJREF_LEN+1]; /* Vstring129 (ObjectReference)*/
ST_UINT32 ConfRev;
ST_BOOLEAN NdsCom;
struct
{
ST_UCHAR Addr[6];
ST_UINT8 PRIORITY;
ST_UINT16 VID;
ST_UINT16 APPID;
} DstAddress;
} MVL61850_GCB_DATA; /* struct to store data for GCB (GOOSE Control Block) */
/* CRITICAL: this struct must be compatible with RUNTIME_TYPE. */
/* If either one changes, the other must change to match. */
typedef struct
{
ST_BOOLEAN GsEna;
ST_CHAR GsID[66];
ST_CHAR DNALabels[32][66];
ST_CHAR UserSTLabels[128][66];
struct
{
ST_CHAR GsID[66];
MMS_BTIME6 t;
ST_UINT32 SqNum;
ST_UINT32 StNum;
ST_UINT32 TAL;
ST_UINT32 usec;
ST_UINT16 PhsID;
ST_UCHAR DNA[8];
ST_UCHAR UserST[32];
} LSentData;
struct
{
ST_UCHAR Addr[6];
ST_UINT8 PRIORITY;
ST_UINT16 VID;
ST_UINT16 APPID;
} DstAddress;
} MVL61850_SCB_DATA; /* struct to store data for SCB (GSSE Control Block) */
typedef struct
{
ST_UINT8 SvEna; /* Bool */
ST_CHAR MsvID[MVL61850_MAX_RPTID_LEN+1]; /* Vstring65 */
ST_CHAR DatSet[MVL61850_MAX_OBJREF_LEN+1]; /* Vstring129 (ObjectReference) */
ST_UINT32 ConfRev; /* Ulong */
ST_UINT32 SmpRate; /* Ulong */
MMS_BVSTRING OptFlds; /* BVstring3 - struct includes 1 byte data. Enough.*/
} MVL61850_MSVCB_DATA; /* struct to store data for MSVCB */
typedef struct
{
ST_UINT8 SvEna; /* Bool */
ST_UINT8 Resv; /* Bool */
ST_CHAR UsvID[MVL61850_MAX_RPTID_LEN+1]; /* Vstring65 */
ST_CHAR DatSet[MVL61850_MAX_OBJREF_LEN+1]; /* Vstring129 (ObjectReference) */
ST_UINT32 ConfRev; /* Ulong */
ST_UINT32 SmpRate; /* Ulong */
MMS_BVSTRING OptFlds; /* BVstring3 - struct includes 1 byte data. Enough.*/
} MVL61850_USVCB_DATA; /* struct to store data for USVCB */
/* CRITICAL: this struct must be compatible with RUNTIME_TYPE. */
/* If either one changes, the other must change to match. */
typedef struct
{
ST_UINT8 NumOfSG;
ST_UINT8 ActSG;
ST_UINT8 EditSG;
ST_BOOLEAN CnfEdit;
MMS_UTC_TIME LActTm; /* TimeStamp */
} MVL61850_SGCB_DATA; /* struct to store data for SGCB (Setting Group Control Block) */
/************************************************************************/
/* STATIC FUNCTION PROTOTYPES */
/* Need prototypes for these static functions because rtadd_da_struct */
/* calls rtadd_da_or_bda and vice versa. */
/* Other static functions are just defined in the order they are needed */
/* so prototypes are not needed. */
/************************************************************************/
static ST_RET rtadd_da_struct (
RUNTIME_BUILD_CTXT *ctxt,
SCL_INFO *scl_info,
ST_CHAR *type_id,
ST_CHAR *comp_name);
static ST_RET rtadd_da_or_bda (
RUNTIME_BUILD_CTXT *ctxt,
SCL_INFO *scl_info,
ST_CHAR *name, /* DA or BDA name */
ST_CHAR *bType, /* DA or BDA bType */
ST_CHAR *type, /* DA or BDA type */
ST_UINT count, /* DA or BDA count */
ST_CHAR *Val); /* DA or BDA Val */
/************************************************************************/
/************************************************************************/
ST_BOOLEAN scl_debug_mode;
ST_INT scl_debug_mode_error_count;
SCL2_BTYPE *scl2_btype_list;
/* NOTE: setting this flag changes the way RCB names generated. */
ST_BOOLEAN rcb_name_no_index; /* change to SD_TRUE to skip RCB index */
/* suffix when maxClient==1 */
/************************************************************************/
/* Add a "custom" basic type to the RUNTIME_TYPE array. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_custom_btype (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *btype, ST_CHAR *comp_name)
{
SCL2_BTYPE *sclBtype;
sclBtype = scl2_btype_list;
while (sclBtype != NULL)
{
if (!strcmp (sclBtype->btype, btype))
{ /* already checked that this is simple type, so just use ...rt_first*/
return (ms_rt_bld_add_special (ctxt, comp_name, sclBtype->rt_ctrl->rt_first));
}
sclBtype = list_get_next (scl2_btype_list, sclBtype);
}
SXLOG_ERR1 ("bType='%s' is not recognized", btype);
return (SD_FAILURE);
}
/************************************************************************/
/* Add a basic type to the RUNTIME_TYPE array. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_btype (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *btype, ST_CHAR *comp_name)
{
/* First check for any of the PredefinedBasicTypes. */
if (strcmp (btype, "BOOLEAN") == 0)
return (ms_rt_bld_add_bool (ctxt, comp_name));
if (strcmp (btype, "INT8") == 0)
return (ms_rt_bld_add_int (ctxt, comp_name, 1));
if (strcmp (btype, "INT16") == 0)
return (ms_rt_bld_add_int (ctxt, comp_name, 2));
if (strcmp (btype, "INT32") == 0)
return (ms_rt_bld_add_int (ctxt, comp_name, 4));
if (strcmp (btype, "INT64") == 0)
{
#if defined(INT64_SUPPORT)
return (ms_rt_bld_add_int (ctxt, comp_name, 8));
#else
SXLOG_ERR0 ("INT64 not supported on this platform");
return (SD_FAILURE);
#endif
}
if (strcmp (btype, "INT8U") == 0)
return (ms_rt_bld_add_uint (ctxt, comp_name, 1));
if (strcmp (btype, "INT16U") == 0)
return (ms_rt_bld_add_uint (ctxt, comp_name, 2));
if (strcmp (btype, "INT32U") == 0)
return (ms_rt_bld_add_uint (ctxt, comp_name, 4));
if (strcmp (btype, "INT64U") == 0)
{
#if defined(INT64_SUPPORT)
return (ms_rt_bld_add_uint (ctxt, comp_name, 8));
#else
SXLOG_ERR0 ("INT64U not supported on this platform");
return (SD_FAILURE);
#endif
}
if (strcmp (btype, "FLOAT32") == 0)
return (ms_rt_bld_add_float (ctxt, comp_name, 4));
if (strcmp (btype, "FLOAT64") == 0)
return (ms_rt_bld_add_float (ctxt, comp_name, 8));
if (strcmp (btype, "Dbpos") == 0
|| strcmp (btype, "Tcmd") == 0)
return (ms_rt_bld_add_bstring (ctxt, comp_name, 2)); /* 2 bits*/
/* "Check" is PACKED LIST. Maps to BVstring. */
if (strcmp (btype, "Check") == 0)
return (ms_rt_bld_add_bvstring (ctxt, comp_name, 2)); /* max 2 bits*/
if (strcmp (btype, "Quality") == 0)
return (ms_rt_bld_add_bvstring (ctxt, comp_name, 13)); /* max 13 bits*/
if (strcmp (btype, "Timestamp") == 0)
return (ms_rt_bld_add_utctime (ctxt, comp_name));
if (strcmp (btype, "VisString32") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 32)); /* max 32 char*/
if (strcmp (btype, "VisString64") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 64)); /* max 64 char*/
if (strcmp (btype, "VisString65") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 65)); /* max 65 char*/
if (strcmp (btype, "VisString128") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 128)); /* max 128 char*/
if (strcmp (btype, "VisString129") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 129)); /* max 129 char*/
if (strcmp (btype, "ObjRef") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 129)); /* max 129 char*/
if (strcmp (btype, "VisString255") == 0)
return (ms_rt_bld_add_vstring (ctxt, comp_name, 255)); /* max 255 char*/
if (strcmp (btype, "Octet64") == 0)
/* 61850-8-1 says all octet strings are variable length*/
return (ms_rt_bld_add_ovstring (ctxt, comp_name, 64)); /* max 64 bytes*/
if (strcmp (btype, "EntryTime") == 0)
return (ms_rt_bld_add_btime6 (ctxt, comp_name));
if (strcmp (btype, "Unicode255") == 0)
return (ms_rt_bld_add_utf8vstring (ctxt, comp_name, 255)); /* max 255 char*/
/* If the "btype" does not match any PredefinedBasicTypes, */
/* see if it matches a "custom" type (i.e. a type created earlier by */
/* calling scl2_add_btype). */
return (ms_rt_bld_61850_add_custom_btype (ctxt, btype, comp_name));
}
/************************************************************************/
/* ms_rt_bld_61850_add_brcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_brcb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_vstring (ctxt, "RptID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_bool (ctxt, "RptEna");
ms_rt_bld_add_vstring (ctxt, "DatSet", MVL61850_MAX_OBJREF_LEN);
ms_rt_bld_add_uint (ctxt, "ConfRev", 4);
ms_rt_bld_add_bvstring (ctxt, "OptFlds", 10);
ms_rt_bld_add_uint (ctxt, "BufTm", 4);
ms_rt_bld_add_uint (ctxt, "SqNum", 2);
ms_rt_bld_add_bvstring (ctxt, "TrgOps", 6);
ms_rt_bld_add_uint (ctxt, "IntgPd", 4);
ms_rt_bld_add_bool (ctxt, "GI");
ms_rt_bld_add_bool (ctxt, "PurgeBuf");
ms_rt_bld_add_ostring (ctxt, "EntryID", 8);
ms_rt_bld_add_btime6 (ctxt, "TimeofEntry");
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_urcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_urcb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_vstring (ctxt, "RptID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_bool (ctxt, "RptEna");
ms_rt_bld_add_bool (ctxt, "Resv");
ms_rt_bld_add_vstring (ctxt, "DatSet", MVL61850_MAX_OBJREF_LEN);
ms_rt_bld_add_uint (ctxt, "ConfRev", 4);
ms_rt_bld_add_bvstring (ctxt, "OptFlds", 10);
ms_rt_bld_add_uint (ctxt, "BufTm", 4);
ms_rt_bld_add_uint (ctxt, "SqNum", 1);
ms_rt_bld_add_bvstring (ctxt, "TrgOps", 6);
ms_rt_bld_add_uint (ctxt, "IntgPd", 4);
ms_rt_bld_add_bool (ctxt, "GI");
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_lcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_lcb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_bool (ctxt, "LogEna");
ms_rt_bld_add_vstring (ctxt, "LogRef", MVL61850_MAX_OBJREF_LEN);
ms_rt_bld_add_vstring (ctxt, "DatSet", MVL61850_MAX_OBJREF_LEN);
#if 0 /*renxiaobao 20170106 mod*/
ms_rt_bld_add_btime6 (ctxt, "OldEntrTim");
ms_rt_bld_add_btime6 (ctxt, "NewEntrTim");
#else
ms_rt_bld_add_btime6 (ctxt, "OldEntrTm");
ms_rt_bld_add_btime6 (ctxt, "NewEntrTm");
#endif
ms_rt_bld_add_ostring (ctxt, "OldEntr", 8);
ms_rt_bld_add_ostring (ctxt, "NewEntr", 8);
ms_rt_bld_add_bvstring (ctxt, "TrgOps", 6);
ms_rt_bld_add_uint (ctxt, "IntgPd", 4);
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_gcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_gcb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_bool (ctxt, "GoEna");
ms_rt_bld_add_vstring (ctxt, "GoID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_vstring (ctxt, "DatSet", MVL61850_MAX_OBJREF_LEN);
ms_rt_bld_add_uint (ctxt, "ConfRev", 4);
ms_rt_bld_add_bool (ctxt, "NdsCom");
ms_rt_bld_add_str_start (ctxt, "DstAddress");
ms_rt_bld_add_ostring (ctxt, "Addr", 6);
ms_rt_bld_add_uint (ctxt, "PRIORITY", 1);
ms_rt_bld_add_uint (ctxt, "VID", 2);
ms_rt_bld_add_uint (ctxt, "APPID", 2);
ms_rt_bld_add_str_end (ctxt);
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_scb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_scb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_bool (ctxt, "GsEna");
ms_rt_bld_add_vstring (ctxt, "GsID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_arr_start (ctxt, "DNALabels", 32);
ms_rt_bld_add_vstring (ctxt, "DNALabels", 65);
ms_rt_bld_add_arr_end (ctxt);
ms_rt_bld_add_arr_start (ctxt, "UserSTLabels", 128);
ms_rt_bld_add_vstring (ctxt, "DNALabels", 65);
ms_rt_bld_add_arr_end (ctxt);
ms_rt_bld_add_str_start (ctxt, "LSentData");
ms_rt_bld_add_vstring (ctxt, "GsID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_btime6 (ctxt, "t");
ms_rt_bld_add_uint (ctxt, "SqNum", 4);
ms_rt_bld_add_uint (ctxt, "StNum", 4);
ms_rt_bld_add_uint (ctxt, "TAL", 4);
ms_rt_bld_add_uint (ctxt, "usec", 4);
ms_rt_bld_add_uint (ctxt, "PhsID", 2);
ms_rt_bld_add_bstring (ctxt, "DNA", 64);
ms_rt_bld_add_bstring (ctxt, "UserST", 256);
ms_rt_bld_add_str_end (ctxt);
ms_rt_bld_add_str_start (ctxt, "DstAddress");
ms_rt_bld_add_ostring (ctxt, "Addr", 6);
ms_rt_bld_add_uint (ctxt, "PRIORITY", 1);
ms_rt_bld_add_uint (ctxt, "VID", 2);
ms_rt_bld_add_uint (ctxt, "APPID", 2);
ms_rt_bld_add_str_end (ctxt);
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_msvcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_msvcb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_bool (ctxt, "SvEna");
ms_rt_bld_add_vstring (ctxt, "MsvID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_vstring (ctxt, "DatSet", MVL61850_MAX_OBJREF_LEN);
ms_rt_bld_add_uint (ctxt, "ConfRev", 4);
ms_rt_bld_add_uint (ctxt, "SmpRate", 4);
ms_rt_bld_add_bvstring (ctxt, "OptFlds", 3);
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_usvcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails, */
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_usvcb (RUNTIME_BUILD_CTXT *ctxt, ST_CHAR *comp_name)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, comp_name);
ms_rt_bld_add_bool (ctxt, "SvEna");
ms_rt_bld_add_bool (ctxt, "Resv");
ms_rt_bld_add_vstring (ctxt, "UsvID", MVL61850_MAX_RPTID_LEN);
ms_rt_bld_add_vstring (ctxt, "DatSet", MVL61850_MAX_OBJREF_LEN);
ms_rt_bld_add_uint (ctxt, "ConfRev", 4);
ms_rt_bld_add_uint (ctxt, "SmpRate", 4);
ms_rt_bld_add_bvstring (ctxt, "OptFlds", 3);
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* ms_rt_bld_61850_add_sgcb */
/* NOTE: check only last return code. If one "ms_rt_bld_add_*" call fails,*/
/* subsequent calls will fail too. */
/************************************************************************/
static ST_RET ms_rt_bld_61850_add_sgcb (RUNTIME_BUILD_CTXT *ctxt)
{
ST_RET retcode;
ms_rt_bld_add_str_start (ctxt, "SGCB"); /* fixed struct name */
ms_rt_bld_add_uint (ctxt, "NumOfSG", 1);
ms_rt_bld_add_uint (ctxt, "ActSG", 1);
ms_rt_bld_add_uint (ctxt, "EditSG", 1);
ms_rt_bld_add_bool (ctxt, "CnfEdit");
ms_rt_bld_add_utctime (ctxt, "LActTm");
retcode = ms_rt_bld_add_str_end (ctxt);
return (retcode);
}
/************************************************************************/
/* reserved_free_all */
/* Find all types used by this VMD. If rt_ctrl->reserved_1 is not NULL, */
/* we must have allocated it in "scl2_datatype_create", so free it and */
/* set it to NULL. */
/************************************************************************/
static ST_VOID reserved_free_all (MVL_VMD_CTRL *vmd_ctrl)
{
ST_INT type_id;
MVL_TYPE_CTRL *type_ctrl;
RUNTIME_CTRL *rt_ctrl;
/* This only works for "dynamic" types so start with first dynamic type.*/
for (type_id = mvl_num_types - mvl_max_dyn.types; type_id < mvl_num_types; type_id++)
{
type_ctrl = mvl_vmd_type_ctrl_find (vmd_ctrl, type_id);
if (type_ctrl) /* type found in this VMD */
{
rt_ctrl = type_ctrl->rt_ctrl; /* always valid */
if (rt_ctrl->reserved_1 != NULL)
{
chk_free (rt_ctrl->reserved_1);
rt_ctrl->reserved_1 = NULL;
}
}
}
}
/************************************************************************/
/* scl_make_objref */
/* Construct ObjectReference from SCL info. */
/************************************************************************/
static ST_RET scl_make_objref (
SCL_LD *scl_ld,
SCL_LN *scl_ln,
ST_CHAR *objName, /* Object (DataSet, Data) name */
ST_CHAR *objRef, /* ptr to resulting ObjRef string */
ST_UINT max_len) /* max len of resulting ObjRef string */
{
ST_RET retcode;
if (strlen (scl_ld->domName) +
strlen (scl_ln->prefix) + strlen (scl_ln->lnClass) + strlen (scl_ln->inst) +
strlen (objName) + 2 > max_len) /* 2 added for '/' and '$' */
{
SXLOG_ERR1 ("Constructed ObjectReference would be too long for '%s'.", objName);
retcode = SD_FAILURE;
}
else
{
sprintf (objRef, "%s/%s%s%s$%s", scl_ld->domName, scl_ln->prefix,
scl_ln->lnClass, scl_ln->inst, objName);
retcode = SD_SUCCESS;
}
return (retcode);
}
/************************************************************************/
/* scl_make_objref2 */
/* Construct ObjectReference from SCL info (LN Name not included). */
/* Similar to scl_make_objref, but does not include LN name. */
/************************************************************************/
static ST_RET scl_make_objref2 (
SCL_LD *scl_ld,
ST_CHAR *objName, /* Object name */
ST_CHAR *objRef, /* ptr to resulting ObjRef string */
ST_UINT max_len) /* max len of resulting ObjRef string */
{
ST_RET retcode;
if (strlen (scl_ld->domName) +
strlen (objName) + 2 > max_len) /* 2 added for '/' and '$' */
{
SXLOG_ERR1 ("Constructed ObjectReference would be too long for '%s'.", objName);
retcode = SD_FAILURE;
}
else
{
sprintf (objRef, "%s/%s", scl_ld->domName, objName);
retcode = SD_SUCCESS;
}
return (retcode);
}
/************************************************************************/
/* special_type_name */
/* Create type name for a special LN (one that includes RCB, LCB, etc.).*/
/* NOTE: do not use '$'. This will confuse "mvlu_set_leaf_param". */
/************************************************************************/
ST_RET special_type_name (ST_CHAR *prefix, SCL_LD *scl_ld, SCL_LN *scl_ln,
ST_CHAR *type_name, size_t type_name_size)
{ /* Create unique type name for this LN. */
size_t len = 0;
ST_RET retcode;
if (prefix) /* NOTE: if prefix is not NULL, add prefix. */
len += strlen (prefix);
len += strlen (scl_ld->inst);
len += strlen (scl_ln->prefix);
len += strlen (scl_ln->lnClass);
len += strlen (scl_ln->inst);
type_name [0] = '\0'; /* start with empty string */
if (len < type_name_size)
{ /* name will fit, so write it */
if (prefix)
strcat (type_name, prefix);
strcat (type_name, scl_ld->inst);
strcat (type_name, scl_ln->prefix);
strcat (type_name, scl_ln->lnClass);
strcat (type_name, scl_ln->inst);
retcode = SD_SUCCESS;
}
else
retcode = SD_FAILURE; /* name would be too long */
return (retcode);
}
/************************************************************************/
/* simple_type_name */
/* Create type name for a simple type. */
/* NOTE: do not use '$'. This will confuse "mvlu_set_leaf_param". */
/************************************************************************/
ST_RET simple_type_name (ST_CHAR *prefix, SCL_LNTYPE *scl_lntype,
ST_CHAR *type_name, size_t type_name_size)
{ /* Create unique type name for this LN. */
size_t len = 0;
ST_RET retcode;
if (prefix) /* NOTE: if prefix is not NULL, add prefix. */
len += strlen (prefix);
len += strlen (scl_lntype->id);
type_name [0] = '\0'; /* start with empty string */
if (len < type_name_size)
{ /* name will fit, so write it */
if (prefix)
strcat (type_name, prefix);
strcat (type_name, scl_lntype->id);
retcode = SD_SUCCESS;
}
else
retcode = SD_FAILURE; /* name would be too long */
return (retcode);
}
/************************************************************************/
/* scl_find_dotype */
/************************************************************************/
static SCL_DOTYPE *scl_find_dotype (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
ST_CHAR *type_id)
{
SCL_DOTYPE *scl_dotype;
for (scl_dotype = (SCL_DOTYPE *) list_find_last ((DBL_LNK *) scl_info->doTypeHead);
scl_dotype != NULL;
scl_dotype = (SCL_DOTYPE *) list_find_prev ((DBL_LNK *) scl_info->doTypeHead, (DBL_LNK *) scl_dotype))
{
if (strcmp (scl_dotype->id, type_id) ==0)
return (scl_dotype);
}
return (NULL); /* match not found */
}
/************************************************************************/
/* scl_find_datype */
/************************************************************************/
static SCL_DATYPE *scl_find_datype (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
ST_CHAR *type_id)
{
SCL_DATYPE *scl_datype;
for (scl_datype = (SCL_DATYPE *) list_find_last ((DBL_LNK *) scl_info->daTypeHead);
scl_datype != NULL;
scl_datype = (SCL_DATYPE *) list_find_prev ((DBL_LNK *) scl_info->daTypeHead, (DBL_LNK *) scl_datype))
{
if (strcmp (scl_datype->id, type_id) ==0)
return (scl_datype);
}
return (NULL); /* match not found */
}
/************************************************************************/
/************************************************************************/
static SCL_DATASET *scl_find_dataset (
SCL_LN *scl_ln,
ST_CHAR *dataset_name)
{
SCL_DATASET *scl_dataset;
for (scl_dataset = (SCL_DATASET *) list_find_last ((DBL_LNK *) scl_ln->datasetHead);
scl_dataset != NULL;
scl_dataset = (SCL_DATASET *) list_find_prev ((DBL_LNK *) scl_ln->datasetHead, (DBL_LNK *) scl_dataset))
{
if (strcmp (scl_dataset->name, dataset_name) ==0)
return (scl_dataset);
}
return (NULL); /* match not found */
}
/************************************************************************/
/* scl2_find_enumtype */
/************************************************************************/
SCL_ENUMTYPE *scl2_find_enumtype (SCL_INFO *scl_info, ST_CHAR *name)
{
SCL_ENUMTYPE *scl_enumtype;
for (scl_enumtype = (SCL_ENUMTYPE *) list_find_last ((DBL_LNK *) scl_info->enumTypeHead);
scl_enumtype != NULL;
scl_enumtype = (SCL_ENUMTYPE *) list_find_prev ((DBL_LNK *) scl_info->enumTypeHead, (DBL_LNK *) scl_enumtype))
{
if (strcmp (scl_enumtype->id, name) == 0)
break; /* found a match */
}
return (scl_enumtype);
}
/************************************************************************/
/* scl2_add_btype */
/************************************************************************/
SCL2_BTYPE *scl2_add_btype (ST_CHAR *btype, ST_CHAR *tdl)
{
SCL2_BTYPE *sclBtype;
RUNTIME_CTRL *rt_ctrl;
ST_UCHAR asn1_buf [200]; /* simple types only, so this should be big enough*/
sclBtype = NULL; /* assume failure for now */
rt_ctrl = ms_tdl_to_runtime (tdl, asn1_buf, sizeof(asn1_buf));
if (rt_ctrl)
{
if (rt_ctrl->rt_num == 1) /* must be simple type */
{
sclBtype = chk_calloc (1, sizeof (SCL2_BTYPE) + strlen (btype) + 1);
sclBtype->btype = (ST_CHAR *) (sclBtype + 1); /* point after struct*/
strcpy (sclBtype->btype, btype);
sclBtype->rt_ctrl = rt_ctrl; /* rt_ctrl allocated, just save ptr*/
list_add_last (&scl2_btype_list, sclBtype);
}
else
{ /* Complex type not allowed, so destroy it now. Err return already set*/
ms_runtime_destroy (rt_ctrl);
}
}
return (sclBtype);
}
/************************************************************************/
/* rtadd_sdo */
/* NOTE: if (error) returned, caller should break out of loop. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET rtadd_sdo (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
ST_CHAR *FC, /* FC to match */
ST_CHAR *name, /* SDO name */
ST_CHAR *type) /* SDO type */
{
SCL_DOTYPE *scl_dotype;
SCL_DA *scl_da;
ST_RET retcode;
ST_INT rt_num_after_str_start; /* index after str_start added */
/* First add SDO name (passed to this funct). May need rollback later */
if (ms_rt_bld_add_str_start (rt_ctxt, name)!=SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
/* Save current index. Use later to check if any types added. */
rt_num_after_str_start = ms_rt_bld_get_count (rt_ctxt);
/* Find DOType whose "id" matches the SDO "type". */
scl_dotype = scl_find_dotype (scl_info, type);
if (scl_dotype)
{
/* Find all DA or SDO in this DO that match the FC */
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_da = (SCL_DA *) list_find_last ((DBL_LNK *) scl_dotype->daHead);
scl_da != NULL;
scl_da = (SCL_DA *) list_find_prev ((DBL_LNK *) scl_dotype->daHead, (DBL_LNK *) scl_da))
{
if (scl_da->objtype == SCL_OBJTYPE_SDO)
{
/* This is a "nested" SDO. Just call rtadd_sdo again recursively. */
retcode = rtadd_sdo (rt_ctxt, scl_info, FC, scl_da->name, scl_da->type);
if (retcode != SD_SUCCESS) /* error (already logged) */
return (retcode); /* error */
}
else
{ /* objtype must be SCL_OBJTYPE_DA */
if (strcmp (scl_da->fc, FC) == 0) /* FC of this DA matches FC */
{
retcode = rtadd_da_or_bda (rt_ctxt, scl_info, scl_da->name, scl_da->bType,
scl_da->type, scl_da->count, scl_da->Val);
if (retcode != SD_SUCCESS) /* error (already logged) */
return (retcode); /* error */
}
}
} /* end "for (scl_da...)" loop */
}
else
{
SXLOG_ERR1 ("SDO type '%s' cannot be found", type);
return (SD_FAILURE); /* error */
}
/* Check if any types were added after start of struct */
if (ms_rt_bld_get_count (rt_ctxt) > rt_num_after_str_start)
{ /* types were added, so finish struct now */
if (ms_rt_bld_add_str_end (rt_ctxt) != SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
}
else
{ /* types NOT added so remove start of struct */
ms_rt_bld_remove_last (rt_ctxt);
}
return (SD_SUCCESS); /* only successful return */
}
/************************************************************************/
/* rtadd_da_or_bda */
/* NOTE: if (error) returned, caller should break out of loop. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET rtadd_da_or_bda (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
ST_CHAR *name, /* DA or BDA name */
ST_CHAR *bType, /* DA or BDA bType */
ST_CHAR *type, /* DA or BDA type */
ST_UINT count, /* DA or BDA count */
ST_CHAR *Val) /* DA or BDA Val (may be NULL) */
{
ST_RET retcode;
RESERVED_INFO *reserved_info; /* ptr to array of extra type info. */
/* Cast "reserved_1" pointer to the type we allocated. */
if (rt_ctxt->do_count)
reserved_info = NULL; /* rt_ctrl & reserved_1 not allocated yet*/
else
reserved_info = (RESERVED_INFO *) rt_ctxt->rt_ctrl->reserved_1;
/* If count!=0, this is array. */
if (count)
{
/* NOTE: comp_name stored on arr_start AND on first element of array.*/
if (ms_rt_bld_add_arr_start (rt_ctxt, name, count))
return (SD_FAILURE); /* error (already logged) */
}
/* Add different text depending on "bType" (Struct, Enum, or BasicType). */
if (strcmp (bType, "Struct") == 0)
{
/* NOTE: this may cause recursion */
/* (i.e. rtadd_da_struct may call rtadd_da_or_bda).*/
retcode = rtadd_da_struct (rt_ctxt, scl_info, type, name);
if (retcode != SD_SUCCESS)
{
SXLOG_ERR1 ("SCL ERROR: Can't add type definition for BDA Struct type=%s", type);
return (retcode);
}
}
else if (strcmp (bType, "Enum") == 0)
{
SCL_ENUMTYPE *scl_enumtype;
if ((scl_enumtype = scl2_find_enumtype (scl_info, type))==NULL)
{
SXLOG_ERR1 ("EnumType '%s' could not be found", type);
return (SD_FAILURE);
}
else
{
/* DEBUG: for now assume all enums are 8-bit */
/* Someday may need to chk for maximum "EnumVal ord" to determine # of bits */
/* Save the scl_enumtype pointer in reserved_info array. */
/* Also save "Val", if present. */
/* CRITICAL: Do this BEFORE calling "ms_rt_bld_add_*" so that */
/* scl_enumtype is saved in the current array entry. */
if (!rt_ctxt->do_count) /* if (do_count), reserved_info not set.*/
{
reserved_info[rt_ctxt->rt_ctrl->rt_num].scl_enumtype = scl_enumtype;
if (Val != NULL)
{
SXLOG_FLOW2 ("Saving Val='%s' for DA or BDA='%s'", Val, name);
reserved_info[rt_ctxt->rt_ctrl->rt_num].Val = Val;
}
}
if (ms_rt_bld_add_int (rt_ctxt, name, 1) != SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
}
}
else
{ /* must be BasicType */
/* Save initial value of this component, if present. */
/* CRITICAL: Do this BEFORE calling "ms_rt_bld_add_*" so that */
/* "Val" is saved in the current array entry. */
if (Val != NULL)
{
if (!rt_ctxt->do_count) /* if (do_count), reserved_info not set.*/
{
SXLOG_FLOW2 ("Saving Val='%s' for DA or BDA='%s'", Val, name);
reserved_info[rt_ctxt->rt_ctrl->rt_num].Val = Val;
}
}
if (ms_rt_bld_61850_add_btype (rt_ctxt, bType, name))
return (SD_FAILURE); /* error (already logged) */
}
/* If count!=0, this is array. */
if (count)
{ /* this BDA is array */
if (ms_rt_bld_add_arr_end (rt_ctxt))
return (SD_FAILURE); /* error (already logged) */
}
return (SD_SUCCESS); /* only successful return */
}
/************************************************************************/
/* rtadd_da_struct */
/* Add the RUNTIME_TYPE definitions for a DA that is "Struct". */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET rtadd_da_struct (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
ST_CHAR *type_id,
ST_CHAR *comp_name)
{
SCL_DATYPE *scl_datype;
SCL_BDA *scl_bda;
ST_RET retcode;
scl_datype = scl_find_datype (scl_info, type_id);
if (scl_datype)
{
if (ms_rt_bld_add_str_start (rt_ctxt, comp_name)!=SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
/* Add info for all BDA in this DAType. */
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_bda = (SCL_BDA *) list_find_last ((DBL_LNK *) scl_datype->bdaHead);
scl_bda != NULL;
scl_bda = (SCL_BDA *) list_find_prev ((DBL_LNK *) scl_datype->bdaHead, (DBL_LNK *) scl_bda))
{
retcode = rtadd_da_or_bda (rt_ctxt, scl_info, scl_bda->name, scl_bda->bType,
scl_bda->type, scl_bda->count, scl_bda->Val);
if (retcode != SD_SUCCESS) /* error (already logged) */
return (retcode); /* error */
} /* end "for (scl_bda...)" loop */
if (ms_rt_bld_add_str_end (rt_ctxt)!=SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
}
else
{
SXLOG_ERR1 ("SCL ERROR: DAType id=%s not found", type_id);
return (SD_FAILURE); /* error */
}
return (SD_SUCCESS); /* only successful return */
}
/************************************************************************/
/* rtadd_do */
/* Add the RUNTIME_TYPE definitions for one DO. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET rtadd_do (
RUNTIME_BUILD_CTXT *rt_ctxt,
char *FC,
SCL_INFO *scl_info,
ST_CHAR *do_name,
SCL_DOTYPE *scl_dotype)
{
SCL_DA *scl_da;
ST_RET retcode;
ST_INT rt_num_after_str_start; /* index after str_start added */
if (ms_rt_bld_add_str_start (rt_ctxt, do_name)!=SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
/* Save current index. Use later to check if any types added. */
rt_num_after_str_start = ms_rt_bld_get_count (rt_ctxt);
/* Find all DA or SDO in this DO that match the FC */
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_da = (SCL_DA *) list_find_last ((DBL_LNK *) scl_dotype->daHead);
scl_da != NULL;
scl_da = (SCL_DA *) list_find_prev ((DBL_LNK *) scl_dotype->daHead, (DBL_LNK *) scl_da))
{
if (scl_da->objtype == SCL_OBJTYPE_SDO)
{
/* Only "name" and "type" used for SDO. */
retcode = rtadd_sdo (rt_ctxt, scl_info, FC, scl_da->name, scl_da->type);
if (retcode != SD_SUCCESS) /* error (already logged) */
return (retcode); /* error */
}
else
{
/*renxiaobao <20><>ֵ */
if (strcmp ("SE", FC) == 0)
{
if (strcmp (scl_da->fc, "SG") == 0) /* FC of this DA matches FC */
{
retcode = rtadd_da_or_bda (rt_ctxt, scl_info, scl_da->name, scl_da->bType,
scl_da->type, scl_da->count, scl_da->Val);
if (retcode != SD_SUCCESS) /* error (already logged) */
return (retcode); /* error */
}
}
/* objtype must be SCL_OBJTYPE_DA */
if (strcmp (scl_da->fc, FC) == 0) /* FC of this DA matches FC */
{
retcode = rtadd_da_or_bda (rt_ctxt, scl_info, scl_da->name, scl_da->bType,
scl_da->type, scl_da->count, scl_da->Val);
if (retcode != SD_SUCCESS) /* error (already logged) */
return (retcode); /* error */
}
}
} /* end "for (scl_da...)" loop */
/* Check if any types were added after start of struct */
if (ms_rt_bld_get_count (rt_ctxt) > rt_num_after_str_start)
{ /* types were added, so finish struct now */
if (ms_rt_bld_add_str_end (rt_ctxt) != SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
}
else
{ /* types NOT added so remove start of struct */
ms_rt_bld_remove_last (rt_ctxt);
}
return (SD_SUCCESS); /* only successful return */
}
/************************************************************************/
/* rtadd_fc */
/* RETURNS: SD_SUCCESS or error code */
/* Add the types for one FC to the RUNTIME_BUILD_CTXT. */
/************************************************************************/
static ST_RET rtadd_fc (
RUNTIME_BUILD_CTXT *rt_ctxt,
ST_CHAR *FC,
SCL_INFO *scl_info,
SCL_LNTYPE *scl_lntype,
SCL_LN *scl_ln_special) /* needed for SGCB */
{
SCL_DO *scl_do;
SCL_DOTYPE *scl_dotype;
ST_RET retcode;
ST_INT rt_num_after_str_start; /* index after str_start added */
/* Add start of struct for this FC. Remove later if no DA's found.*/
if (ms_rt_bld_add_str_start (rt_ctxt, FC)!=SD_SUCCESS)
return (SD_FAILURE);
/* Save current index. Use later to check if any types added. */
rt_num_after_str_start = ms_rt_bld_get_count (rt_ctxt);
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_do = (SCL_DO *) list_find_last ((DBL_LNK *) scl_lntype->doHead);
scl_do != NULL;
scl_do = (SCL_DO *) list_find_prev ((DBL_LNK *) scl_lntype->doHead, (DBL_LNK *) scl_do))
{
/* Find DOType for this DO. */
scl_dotype = scl_find_dotype (scl_info, scl_do->type);
if (scl_dotype) /* found DOType */
{
retcode = rtadd_do (rt_ctxt, FC, scl_info, scl_do->name, scl_dotype);
if (retcode != SD_SUCCESS)
{
SXLOG_ERR1 ("ERROR adding type definitions for DO='%s'", scl_do->name);
return (retcode);
}
}
else
{ /* can't find DOType for this DO. Cannot continue. */
SXLOG_ERR2 ("Cannot find DOType='%s' for DO='%s'.",
scl_do->type, scl_do->name);
return (SD_FAILURE);
}
} /* end "for (scl_do...)" loop */
/* If SGCB configured and FC="SP", add SGCB here after other attributes.*/
if (scl_ln_special && scl_ln_special->sgcb && strcmp (FC, "SP") == 0)
{
retcode = ms_rt_bld_61850_add_sgcb (rt_ctxt); /* Add SGCB struct.*/
if (retcode != SD_SUCCESS)
{
SXLOG_ERR0 ("ERROR adding SGCB");
return (retcode);
}
}
/* Check if any types were added after start of struct */
if (ms_rt_bld_get_count (rt_ctxt) > rt_num_after_str_start)
{ /* types were added, so finish struct now */
if (ms_rt_bld_add_str_end (rt_ctxt) != SD_SUCCESS)
return (SD_FAILURE); /* error (already logged) */
}
else
{ /* types NOT added so remove start of struct */
ms_rt_bld_remove_last (rt_ctxt);
}
return (SD_SUCCESS); /* this is only "good" return */
}
/************************************************************************/
/* rtadd_rp_or_br */
/* RETURNS: SD_SUCCESS or error code */
/* Add runtime type definition for special FC=RP or FC=BR. */
/* CRITICAL: Last arg "buffered" must be SD_TRUE or SD_FALSE (other */
/* non-zero values NOT treated the same as SD_TRUE). */
/************************************************************************/
static ST_RET rtadd_rp_or_br (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
SCL_LNTYPE *scl_lntype,
SCL_LN *scl_ln,
ST_BOOLEAN buffered) /* SD_TRUE to add "buffered" reports */
/* SD_FALSE to add "unbuffered" reports */
/* CRITICAL: no other values allowed */
{
SCL_RCB *scl_rcb;
ST_INT count = 0;
ST_RET retcode = SD_SUCCESS;
ST_INT index, maxClient;
for (scl_rcb = (SCL_RCB *) list_find_last ((DBL_LNK *) scl_ln->rcbHead);
scl_rcb != NULL;
scl_rcb = (SCL_RCB *) list_find_prev ((DBL_LNK *) scl_ln->rcbHead, (DBL_LNK *) scl_rcb))
{
/* If RCB doesn't match the kind we're looking for, ignore it. */
if (scl_rcb->buffered != buffered)
continue;
/* NOTE: if NOT the type we're looking for, never get here (see 'continue' above)*/
/* NOTE: don't chk every rtadd.. return. If one call fails, subsequent calls fail too.*/
if (buffered) /* looking for buffered & this is buffered */
{
if (count==0)
ms_rt_bld_add_str_start (rt_ctxt, "BR");
}
else /* looking for unbuffered & this is unbuffered */
{
if (count==0)
ms_rt_bld_add_str_start (rt_ctxt, "RP");
}
maxClient = scl_rcb->maxClient; /* use value of "RptEnabled max" in SCL*/
/* Add type definitions for each RCB in a loop. */
for (index = 1; index<=maxClient; index++)
{
ST_CHAR rcb_name [MAX_IDENT_LEN + 1];
if (strlen (scl_rcb->name) <= MAX_IDENT_LEN - 2) /* make sure there's room*/
{
if (rcb_name_no_index && maxClient == 1)
sprintf (rcb_name, "%s", scl_rcb->name); /* do NOT add suffix*/
else
sprintf (rcb_name, "%s%02d", scl_rcb->name, index); /* construct RCB name*/
if (buffered) /* looking for buffered & this is buffered */
retcode = ms_rt_bld_61850_add_brcb (rt_ctxt, rcb_name);
else /* looking for unbuffered & this is unbuffered */
retcode = ms_rt_bld_61850_add_urcb (rt_ctxt, rcb_name);
}
else
retcode = SD_FAILURE; /* name too long. Should NEVER get this error*/
}
if (retcode) /* if error, stop */
return (retcode);
count++; /* increment count of rcb */
} /* end loop */
/* If any found, add ending text. */
if (count>0)
retcode = ms_rt_bld_add_str_end (rt_ctxt);
return (retcode); /* NOTE: may have returned sooner on some errors*/
} /* end rtadd_rp_or_br */
/************************************************************************/
/* rtadd_lg */
/* RETURNS: SD_SUCCESS or error code */
/* Add runtime type definition for special FC=LG. */
/* NOTE: OptFlds in 61850-7-2 not mapped to MMS. */
/************************************************************************/
static ST_RET rtadd_lg (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
SCL_LNTYPE *scl_lntype,
SCL_LN *scl_ln)
{
SCL_LCB *scl_lcb;
ST_INT count = 0;
SCL_DATASET *scl_dataset;
ST_RET retcode = SD_SUCCESS;
for (scl_lcb = (SCL_LCB *) list_find_last ((DBL_LNK *) scl_ln->lcbHead);
scl_lcb != NULL;
scl_lcb = (SCL_LCB *) list_find_prev ((DBL_LNK *) scl_ln->lcbHead, (DBL_LNK *) scl_lcb))
{
scl_dataset = scl_find_dataset (scl_ln, scl_lcb->datSet);
if (scl_dataset == NULL)
{
SXLOG_ERR1 ("rtadd_lg: datSet='%s' not found", scl_lcb->datSet);
return (SD_FAILURE);
}
if (count==0)
retcode = ms_rt_bld_add_str_start (rt_ctxt, "LG"); /* first one needs (LG) */
if (retcode) /* if error, stop */
return (retcode);
/* Add lcb name as component name.*/
retcode = ms_rt_bld_61850_add_lcb (rt_ctxt, scl_lcb->name);
if (retcode) /* if error, stop */
return (retcode);
count++; /* increment count of lcb */
} /* end loop */
/* If any found, add ending text. */
if (count>0)
retcode = ms_rt_bld_add_str_end (rt_ctxt);
return (retcode); /* NOTE: may have returned sooner on some errors*/
} /* end rtadd_lg */
/************************************************************************/
/* rtadd_go_or_gs */
/* RETURNS: SD_SUCCESS or error code */
/* Add runtime type definition for special FC=GO or FC=GS. */
/************************************************************************/
static ST_RET rtadd_go_or_gs (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
SCL_LNTYPE *scl_lntype,
SCL_LN *scl_ln,
ST_BOOLEAN isGoose) /* SD_TRUE to add GOOSE (FC=GO) */
/* SD_FALSE to add GSSE (FC=GS) */
/* CRITICAL: no other values allowed */
{
SCL_GCB *scl_gcb;
ST_INT count = 0;
SCL_DATASET *scl_dataset;
ST_RET retcode = SD_SUCCESS;
for (scl_gcb = (SCL_GCB *) list_find_last ((DBL_LNK *) scl_ln->gcbHead);
scl_gcb != NULL;
scl_gcb = (SCL_GCB *) list_find_prev ((DBL_LNK *) scl_ln->gcbHead, (DBL_LNK *) scl_gcb))
{
/* If GCB doesn't match the kind we're looking for, ignore it. */
if (scl_gcb->isGoose != isGoose)
continue;
/* NOTE: if NOT the type we're looking for, never get here (see 'continue' above)*/
if (scl_gcb->isGoose)
{
/* GOOSE needs dataset. Find it now. */
scl_dataset = scl_find_dataset (scl_ln, scl_gcb->datSet);
if (scl_dataset == NULL)
{
SXLOG_ERR1 ("rtadd_go_or_gs: datSet='%s' not found", scl_gcb->datSet);
return (SD_FAILURE);
}
if (count==0)
ms_rt_bld_add_str_start (rt_ctxt, "GO"); /* first one needs "GO" */
}
else
{
if (count==0)
ms_rt_bld_add_str_start (rt_ctxt, "GS"); /* first one needs "GS" */
}
if (retcode) /* if error, stop */
return (retcode);
if (scl_gcb->isGoose) /* looking for GOOSE & this is GOOSE */
retcode = ms_rt_bld_61850_add_gcb (rt_ctxt, scl_gcb->name);
else /* looking for GSSE & this is GSSE */
retcode = ms_rt_bld_61850_add_scb (rt_ctxt, scl_gcb->name);
if (retcode) /* if error, stop */
return (retcode);
count++; /* increment count of gcb */
} /* end loop */
/* If any found, add ending text. */
if (count>0)
retcode = ms_rt_bld_add_str_end (rt_ctxt);
return (retcode); /* NOTE: may have returned sooner on some errors*/
} /* end rtadd_go_or_gs */
/************************************************************************/
/* rtadd_ms_or_us */
/* RETURNS: SD_SUCCESS or error code */
/* Add runtime type definition for FC=MS or FC=US. */
/* CRITICAL: Last arg "multicast" must be SD_TRUE or SD_FALSE (other */
/* non-zero values NOT treated the same as SD_TRUE). */
/************************************************************************/
static ST_RET rtadd_ms_or_us (
RUNTIME_BUILD_CTXT *rt_ctxt,
SCL_INFO *scl_info,
SCL_LNTYPE *scl_lntype,
SCL_LN *scl_ln,
ST_BOOLEAN multicast) /* SD_TRUE to add all MSVCB (FC=MS) */
/* SD_FALSE to add all USVCB (FC=US) */
/* CRITICAL: no other values allowed */
{
SCL_SVCB *scl_svcb;
ST_INT count = 0;
SCL_DATASET *scl_dataset;
ST_RET retcode = SD_SUCCESS;
for (scl_svcb = (SCL_SVCB *) list_find_last ((DBL_LNK *) scl_ln->svcbHead);
scl_svcb != NULL;
scl_svcb = (SCL_SVCB *) list_find_prev ((DBL_LNK *) scl_ln->svcbHead, (DBL_LNK *) scl_svcb))
{
/* If svcb doesn't match the kind we're looking for, ignore it. */
if (scl_svcb->multicast != multicast)
continue;
scl_dataset = scl_find_dataset (scl_ln, scl_svcb->datSet);
if (scl_dataset == NULL)
{
SXLOG_ERR1 ("rtadd_ms_or_us: datSet='%s' not found", scl_svcb->datSet);
return (SD_FAILURE);
}
/* NOTE: if NOT the type we're looking for, never get here (see 'continue' above)*/
/* NOTE: don't chk every rtadd.. return. If one call fails, subsequent calls fail too.*/
if (multicast) /* looking for multicast & this is multicast */
{
if (count==0)
ms_rt_bld_add_str_start (rt_ctxt, "MS"); /* first one needs (MS) */
}
else /* looking for unicast & this is unicast */
{
if (count==0)
ms_rt_bld_add_str_start (rt_ctxt, "US"); /* first one needs (US) */
}
/* NOTE: if NOT the type we're looking for, never get here (see 'continue' above)*/
if (multicast) /* looking for multicast & this is multicast */
retcode = ms_rt_bld_61850_add_msvcb (rt_ctxt, scl_svcb->name);
else /* looking for unicast & this is unicast */
retcode = ms_rt_bld_61850_add_usvcb (rt_ctxt, scl_svcb->name);
if (retcode) /* if error, stop */
return (retcode);
count++; /* increment count of svcb */
} /* end loop */
/* If any found, add ending text. */
if (count>0)
retcode = ms_rt_bld_add_str_end (rt_ctxt);
return (retcode); /* NOTE: may have returned sooner on some errors*/
} /* end rtadd_ms_or_us */
/************************************************************************/
/* scl2_datatype_create */
/* Create MMS Data type for one Logical Node Type (LNodeType) */
/* defined in SCL. */
/* RETURNS: type_id (-1 on error) */
/************************************************************************/
static ST_INT scl2_datatype_create (
MVL_VMD_CTRL *vmd_ctrl, /* VMD in which to add this type */
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LNTYPE *scl_lntype, /* info for this LNType */
ST_INT max_rt_num, /* max num of RUNTIME_TYPE for this LNodeType*/
/* If you don't care, set this = 0. */
ST_BOOLEAN use_names, /* If set, use type names. */
ST_CHAR *name_prefix, /* unique prefix to add to each type name*/
/* only used if "use_names==SD_TRUE". */
SCL_LD *scl_ld_special, /* LD containing LN with "special stuff"*/
/* (i.e. ReportControl, LogControl, etc)*/
/* NULL if nothing special in LN. */
SCL_LN *scl_ln_special) /* LN with "special stuff" */
/* NULL if nothing special in LN. */
{
ST_RET retcode;
ST_INT type_id = -1; /* assumes failure. */
RUNTIME_BUILD_CTXT rt_ctxt;
MVL_TYPE_CTRL *type_ctrl;
ST_CHAR type_name[MAX_IDENT_LEN+1];
ST_INT loop; /* loop counter */
ST_INT save_rt_num=0; /* RUNTIME_TYPE count computed on first loop */
if (use_names)
{
/* Generate type_name. */
if (scl_ln_special)
{ /* Create unique type name for this LN. */
retcode = special_type_name (name_prefix, scl_ld_special, scl_ln_special, type_name, sizeof(type_name));
}
else
retcode = simple_type_name (name_prefix, scl_lntype, type_name, sizeof(type_name));
if (retcode)
{
SXLOG_ERR1 ("Error generating type name for LNodeType id='%s'", scl_lntype->id);
return (-1); /* return type_id of (-1) to indicate error */
}
}
/* Begin constructing the data type in rt_ctxt. */
/* Loop exactly 2 times. First iteration, just compute "rt_num". */
/* Call "ms_rt_bld_get_count" at end of loop to get the count. */
/* Second iteration, build type (pass rt_num to ms_rt_bld_start). */
/* CRITICAL: do not access rt_ctxt->rt_ctrl on first loop iteration. */
/* It is not set yet. */
for (loop = 0; loop < 2; loop++)
{
if (loop == 0)
ms_rt_bld_start (&rt_ctxt, 0); /* 2nd arg = 0 so bld functions */
/* just compute rt_num */
else
{
ms_rt_bld_start (&rt_ctxt, save_rt_num); /* first loop computed save_rt_num*/
/* Allocate extra array of structs. Free this when all SCL processing*/
/* done (see end of scl2_ld_create_all). */
rt_ctxt.rt_ctrl->reserved_1 = (ST_VOID *) chk_calloc (save_rt_num, sizeof (RESERVED_INFO)); /* array of ptrs*/
}
/* Go through all linked lists and create COMPLETE type definition. */
/* NOTE: order of FC specified in 61850-8-1 (section 6.1.3). */
/* NOTE: SCL only allows "ST" "MX" "CO" "SP" "SG" "SE" "SV" "CF" "DC" "EX".*/
/* "RP", "LG", and "BR" are special cases. */
do
{ /* "do-while" loop: only needed so we can break on first error. */
/* if any rtadd_* call fails, break and return error. */
if ((retcode = ms_rt_bld_add_str_start (&rt_ctxt, NULL)) != SD_SUCCESS) /* no comp name*/
break;
if ((retcode = rtadd_fc (&rt_ctxt, "MX", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "ST", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "CO", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "CF", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "DC", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "SP", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "SG", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
/* FC=RP is special case. Call special function. */
if (scl_ln_special)
{ /* special type for LN containing RCBs */
if ((retcode = rtadd_rp_or_br (&rt_ctxt, scl_info, scl_lntype, scl_ln_special, SD_FALSE)) != SD_SUCCESS)
break;
}
/* FC=LG is special case. Call special function. */
if (scl_ln_special)
{
if ((retcode = rtadd_lg (&rt_ctxt, scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
}
/* FC=BR is special case. Call special function. */
if (scl_ln_special)
{ /* special type for LN containing RCBs */
if ((retcode = rtadd_rp_or_br (&rt_ctxt, scl_info, scl_lntype, scl_ln_special, SD_TRUE)) != SD_SUCCESS)
break;
}
if (scl_ln_special)
{
/* FC=GO is special case. Call special function (last arg SD_TRUE). */
if ((retcode = rtadd_go_or_gs (&rt_ctxt, scl_info, scl_lntype, scl_ln_special, SD_TRUE)) != SD_SUCCESS)
break;
/* FC=GS is special case. Call special function (last arg SD_FALSE). */
if ((retcode = rtadd_go_or_gs (&rt_ctxt, scl_info, scl_lntype, scl_ln_special, SD_FALSE)) != SD_SUCCESS)
break;
}
if ((retcode = rtadd_fc (&rt_ctxt, "SV", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = rtadd_fc (&rt_ctxt, "SE", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
/* Add types for "MS" and "US" (sampled value control blocks). */
if (scl_ln_special)
{
/* FC=MS: This funct with arg = SD_TRUE adds types for FC=MS. */
if ((retcode = rtadd_ms_or_us (&rt_ctxt, scl_info, scl_lntype, scl_ln_special, SD_TRUE)) != SD_SUCCESS)
break;
/* FC=US: This funct with arg = SD_FALSE adds types for FC=US. */
if ((retcode = rtadd_ms_or_us (&rt_ctxt, scl_info, scl_lntype, scl_ln_special, SD_FALSE)) != SD_SUCCESS)
break;
}
if ((retcode = rtadd_fc (&rt_ctxt, "EX", scl_info, scl_lntype, scl_ln_special)) != SD_SUCCESS)
break;
if ((retcode = ms_rt_bld_add_str_end (&rt_ctxt)) != SD_SUCCESS)
break;
} while (0); /* end of "do-while" loop: only needed so we can break on first error. */
if (loop==0)
{
/* First loop: computing rt_num. Save rt_num to use on second loop.*/
/* CRITICAL: use ..get_max_count here to get "maximum" count. */
/* May be slightly larger than "current" count. */
save_rt_num = ms_rt_bld_get_max_count (&rt_ctxt);
/* NOTE: no need to call ms_rt_bld_finish (nothing to clean up). */
/* If max_rt_num != 0, and save_rt_num exceeds it, log and return error.*/
if (max_rt_num != 0 && save_rt_num > max_rt_num)
{
SXLOG_ERR3 ("Number of RUNTIME_TYPE elements (%d) exceeds maximum (%d). Cannot create type for LNodeType id=%s",
save_rt_num, max_rt_num, scl_lntype->id);
return (-1); /* error. Cannot continue */
}
else if (save_rt_num == 0)
{
SXLOG_ERR1 ("Number of RUNTIME_TYPE elements = 0. Cannot create type for LNodeType id=%s",
scl_lntype->id);
return (-1); /* error. Cannot continue */
}
}
/* On Second loop, nothing else to do. */
} /* end outer loop */
/* If retcode==SD_SUCCESS, ALL "rtadd_fc" calls were successful, so create type here */
if (retcode == SD_SUCCESS)
{
ms_rt_bld_finish (&rt_ctxt);
/* "rt_num" must NEVER exceed size allocated, but may be slightly less.*/
assert (rt_ctxt.rt_ctrl->rt_num <= save_rt_num);
SXLOG_FLOW2 ("RUNTIME_TYPE count for LNodeType id='%s' = %d",
scl_lntype->id, rt_ctxt.rt_ctrl->rt_num);
/* Create the type now. */
if (use_names)
type_id = mvl_vmd_type_id_create (vmd_ctrl, type_name, rt_ctxt.rt_ctrl);
else
type_id = mvl_vmd_type_id_create (vmd_ctrl, NULL, rt_ctxt.rt_ctrl);
}
else
{ /* build failed, so cleanup now */
chk_free (rt_ctxt.rt_ctrl->reserved_1);
ms_rt_bld_cancel (&rt_ctxt);
}
if (type_id >= 0)
{ /* type successfully created */
type_ctrl = mvl_type_ctrl_find (type_id);
if (mms_debug_sel & MMS_LOG_RT)
{
MLOG_ALWAYS1 ("RUNTIME_TYPE definition for LNodeType id='%s':", scl_lntype->id);
ms_log_runtime (type_ctrl->rt_ctrl->rt_first, type_ctrl->rt_ctrl->rt_num);
}
/* CRITICAL: we want the same leaf function for every leaf, so */
/* set leaf functions now in every RUNTIME_TYPE element. */
/* NOTE: leaf functions never used for RT_STR_START, RT_ARR_START,*/
/* etc. but they're set anyway because it's easier to set all.*/
/* NOTE: this function may be customized for each application. */
/* It should be placed in a "user" module. */
if (u_set_all_leaf_functions (type_ctrl->rt_ctrl) != SD_SUCCESS)
{
SXLOG_ERR1 ("Error setting leaf functions for LNodeType id=%s", scl_lntype->id);
mvl_type_id_destroy (type_id); /* destroy type just created */
type_id = -1; /* set invalid type_id to indicate error */
}
}
if (type_id < 0)
SXLOG_ERR1 ("scl2_datatype_create FAILED for LNodeType id=%s", scl_lntype->id);
else
SXLOG_FLOW1 ("scl2_datatype_create SUCCESSFUL for LNodeType id=%s", scl_lntype->id);
return (type_id);
}
/************************************************************************/
/* find_scl_lntype */
/* Search for lntype by name. */
/************************************************************************/
SCL_LNTYPE *find_scl_lntype (SCL_INFO *scl_info, ST_CHAR *name)
{
SCL_LNTYPE *scl_lntype;
for (scl_lntype = (SCL_LNTYPE *) list_find_last ((DBL_LNK *) scl_info->lnTypeHead);
scl_lntype != NULL;
scl_lntype = (SCL_LNTYPE *) list_find_prev ((DBL_LNK *) scl_info->lnTypeHead, (DBL_LNK *) scl_lntype))
{
if (strcmp (name, scl_lntype->id) == 0) /* type name matches*/
return (scl_lntype);
}
return (NULL); /* lntype not found*/
}
/************************************************************************/
/* scl2_datatype_create_all */
/* Create MMS Data types for all Logical Node Types (LNodeType) */
/* defined in SCL. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
ST_RET scl2_datatype_create_all (
MVL_VMD_CTRL *vmd_ctrl, /* VMD in which to add types. */
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
ST_INT max_rt_num, /* max num of RUNTIME_TYPE for each LNodeType*/
ST_BOOLEAN use_names, /* if SD_TRUE, generate a name for each type*/
ST_CHAR *name_prefix) /* unique prefix to add to each type name*/
/* only used if "use_names==SD_TRUE". */
{
ST_RET retcode;
SCL_LNTYPE *scl_lntype;
SCL_LD *scl_ld;
SCL_LN *scl_ln;
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
retcode = SD_SUCCESS;
/* CRITICAL: Don't allow this to be called again for the same SCL_INFO struct.*/
/* That would cause types to be created twice, and the "type_id" saved*/
/* in each SCL_LN and SCL_LNTYPE would be overwritten. */
if (scl_info->datatype_create_done)
{
SXLOG_ERR0 ("Data types already created for this SCL file. Cannot create again.");
return (SD_FAILURE);
}
else
scl_info->datatype_create_done = SD_TRUE; /* Set flag now */
/* Loop through all scl_lntype structs. For each one, create type & save type_id in scl_lntype->type_id.*/
for (scl_lntype = (SCL_LNTYPE *) list_find_last ((DBL_LNK *) scl_info->lnTypeHead);
scl_lntype != NULL;
scl_lntype = (SCL_LNTYPE *) list_find_prev ((DBL_LNK *) scl_info->lnTypeHead, (DBL_LNK *) scl_lntype))
{
scl_lntype->type_id = scl2_datatype_create (vmd_ctrl, scl_info, scl_lntype,
max_rt_num, use_names, name_prefix, NULL, NULL);
/* NOTE: could fail (type_id < 0). OK for now. Might not be used by any LN.*/
}
/* Loop through all Logical Nodes. If a Locical Node
* contains "special stuff" (i.e. ReportControl, LogControl, GSEControl),
* create a special type that includes the "special stuff".
* If not, use the appropriate type created by the above loop (scl_lntype->type_id).
* Must check all Logical Nodes (scl_ln) in all Logical Devices (scl_ld).
*/
for (scl_ld = (SCL_LD *) list_find_last ((DBL_LNK *) scl_info->ldHead);
scl_ld != NULL;
scl_ld = (SCL_LD *) list_find_prev ((DBL_LNK *) scl_info->ldHead, (DBL_LNK *) scl_ld))
{
for (scl_ln = (SCL_LN *) list_find_last ((DBL_LNK *) scl_ld->lnHead);
scl_ln != NULL;
scl_ln = (SCL_LN *) list_find_prev ((DBL_LNK *) scl_ld->lnHead, (DBL_LNK *) scl_ln))
{
scl_lntype = find_scl_lntype (scl_info, scl_ln->lnType); /* search for lntype by name*/
if (scl_lntype)
{
assert (scl_ln->type_id == 0); /* already set. Something's wrong*/
/* If rcbHead!=NULL, this LN contains ReportControl. */
/* If lcbHead!=NULL, this LN contains LogControl. */
/* If gcbHead!=NULL, this LN contains GSEControl. */
/* If svcbHead!=NULL, this LN contains SampledValueControl */
/* NOTE: do nothing if it fails. Detected later when rcb created.*/
if (scl_ln->rcbHead || scl_ln->lcbHead || scl_ln->gcbHead || scl_ln->svcbHead)
{ /* "Special" LN. Create special type just for this LN. */
/* Last 2 args point to LD & LN containing special info (rcb, gcb, etc.).*/
scl_ln->type_id = scl2_datatype_create (vmd_ctrl, scl_info, scl_lntype,
max_rt_num, use_names, name_prefix, scl_ld, scl_ln);
}
else
{ /* "Normal" LN. Save type_id created by first loop. */
scl_ln->type_id = scl_lntype->type_id;
}
}
else
{ /* type not found. Set invalid type_id. Error logged below.*/
scl_ln->type_id = -1;
}
if (scl_ln->type_id < 0)
{
SXLOG_ERR2 ("Could not find or create lnType '%s' for LN '%s'",
scl_ln->lnType, scl_ln->varName);
retcode = SD_FAILURE; /* create failed for this LN, return error.*/
/* NOTE: function fails, but continue looping to log other errors too.*/
}
}
}
if (retcode)
{
/* If anything failed, reserved_1 member of every */
/* RUNTIME_CTRL should no longer be needed. */
reserved_free_all (vmd_ctrl);
}
return (retcode);
}
/************************************************************************/
/* scl2_ln_init_lcb_vals */
/* Use mvlu_find_comp_type to find the data offset of each LCB in the LN.*/
/* Then write the SCL data there. */
/************************************************************************/
static ST_VOID scl2_ln_init_lcb_vals (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
ST_CHAR flatname [MAX_IDENT_LEN +1];
SCL_LCB *scl_lcb;
MVL61850_LCB_DATA *lcb_data;
RUNTIME_TYPE *comp_rt_type; /* first rt_type of component */
ST_INT comp_rt_num; /* num of rt_types in component */
ST_RET retcode = SD_SUCCESS;
for (scl_lcb = (SCL_LCB *) list_find_last ((DBL_LNK *) scl_ln->lcbHead);
scl_lcb != NULL;
scl_lcb = (SCL_LCB *) list_find_prev ((DBL_LNK *) scl_ln->lcbHead, (DBL_LNK *) scl_lcb))
{
/* NOTE: mvlu_find_comp_type uses flattened name without LN prefix. */
sprintf (flatname, "LG$%s", scl_lcb->name);
retcode = mvlu_find_comp_type (scl_ln->mvl_var_assoc->type_id,
flatname, &comp_rt_type, &comp_rt_num);
if (retcode!=SD_SUCCESS)
{
SXLOG_ERR2 ("Cannot find component '%s' in var '%s'. Initial values not set.",
flatname, scl_ln->mvl_var_assoc->name);
}
else
{
lcb_data = (MVL61850_LCB_DATA *)((ST_CHAR *) scl_ln->mvl_var_assoc->data + comp_rt_type->mvluTypeInfo.offSet);
/* Use SCL info to initialize LCB data. */
/* Construct ObjectReference for lcb_data->DatSet. */
scl_make_objref (scl_ld, scl_ln, scl_lcb->datSet,
lcb_data->DatSet, sizeof (lcb_data->DatSet) - 1);
lcb_data->IntgPd = (ST_UINT32) scl_lcb->intgPd;
/* Construct ObjectReference for lcb_data->LogRef. */
scl_make_objref2 (scl_ld, scl_lcb->logName,
lcb_data->LogRef, sizeof (lcb_data->LogRef) - 1);
lcb_data->LogEna = scl_lcb->logEna;
/* NOTE: "scl_lcb->reasonCode" may be read from SCL file, but it */
/* is not in LCB (according to 61850-8-1) so just ignore it. */
lcb_data->TrgOps.len = 6; /* Var len 6-bit bitstring */
lcb_data->TrgOps.data[0] = scl_lcb->TrgOps[0]; /* 1 byte of data */
}
} /* end loop */
}
/************************************************************************/
/* scl2_ln_init_gcb_vals */
/* Use mvlu_find_comp_type to find the data offset of each GCB in the LN.*/
/* Then write the SCL data there. */
/************************************************************************/
static ST_VOID scl2_ln_init_gcb_vals (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
ST_CHAR flatname [MAX_IDENT_LEN +1];
SCL_GCB *scl_gcb;
MVL61850_GCB_DATA *gcb_data; /* GOOSE Control Block data */
MVL61850_SCB_DATA *scb_data; /* GSSE Control Block data */
RUNTIME_TYPE *comp_rt_type; /* first rt_type of component */
ST_INT comp_rt_num; /* num of rt_types in component */
ST_RET retcode = SD_SUCCESS;
ST_CHAR *dataptr;
SCL_GSE *scl_gse; /* GOOSE addressing info */
for (scl_gcb = (SCL_GCB *) list_find_last ((DBL_LNK *) scl_ln->gcbHead);
scl_gcb != NULL;
scl_gcb = (SCL_GCB *) list_find_prev ((DBL_LNK *) scl_ln->gcbHead, (DBL_LNK *) scl_gcb))
{
/* NOTE: mvlu_find_comp_type uses flattened name without LN prefix. */
if (scl_gcb->isGoose) /* GOOSE */
sprintf (flatname, "GO$%s", scl_gcb->name);
else /* GSSE */
sprintf (flatname, "GS$%s", scl_gcb->name);
retcode = mvlu_find_comp_type (scl_ln->mvl_var_assoc->type_id,
flatname, &comp_rt_type, &comp_rt_num);
if (retcode!=SD_SUCCESS)
{
SXLOG_ERR2 ("Cannot find component '%s' in var '%s'. Initial values not set.",
flatname, scl_ln->mvl_var_assoc->name);
}
else
{
dataptr = (ST_CHAR *) scl_ln->mvl_var_assoc->data
+ comp_rt_type->mvluTypeInfo.offSet;
/* Use SCL info to initialize GCB data. */
if (scl_gcb->isGoose)
{ /* GOOSE */
gcb_data = (MVL61850_GCB_DATA *) dataptr;
/* Construct ObjectReference for gcb_data->DatSet. */
scl_make_objref (scl_ld, scl_ln, scl_gcb->datSet,
gcb_data->DatSet, sizeof (gcb_data->DatSet) - 1);
gcb_data->ConfRev = (ST_UINT32) scl_gcb->confRev;
/* 61850-8-1 maps appID to GoID */
strcpy (gcb_data->GoID, scl_gcb->appID);
/* NOTE: NdsCom is not configured in SCL so initial value of */
/* "gcb_data->NdsCom" is always 0. */
if ((scl_gse = scl_gse_find (scl_info, scl_ld, scl_gcb)) != NULL)
{
/* Initialize DstAddress structure. */
memcpy (gcb_data->DstAddress.Addr, scl_gse->MAC, CLNP_MAX_LEN_MAC);
gcb_data->DstAddress.PRIORITY = (ST_UINT8) scl_gse->VLANPRI;
gcb_data->DstAddress.VID = (ST_UINT16) scl_gse->VLANID;
gcb_data->DstAddress.APPID = (ST_UINT16) scl_gse->APPID;
}
else
MVL_LOG_ERR1 ("Cannot find GSE element to set address for GOOSE Control '%s'. DstAddress NOT INITIALIZED.",
scl_gcb->name);
}
else
{ /* GSSE */
scb_data = (MVL61850_SCB_DATA *) dataptr;
/* datSet, confRev ignored for GSSE. */
/* 61850-8-1 maps appID to GsID */
strcpy (scb_data->GsID, scl_gcb->appID);
if ((scl_gse = scl_gse_find (scl_info, scl_ld, scl_gcb)) != NULL)
{
/* Initialize DstAddress structure. */
memcpy (scb_data->DstAddress.Addr, scl_gse->MAC, CLNP_MAX_LEN_MAC);
scb_data->DstAddress.PRIORITY = (ST_UINT8) scl_gse->VLANPRI;
scb_data->DstAddress.VID = (ST_UINT16) scl_gse->VLANID;
scb_data->DstAddress.APPID = (ST_UINT16) scl_gse->APPID;
}
else
MVL_LOG_ERR1 ("Cannot find GSE element to set address for GSSE Control '%s'. DstAddress NOT INITIALIZED.",
scl_gcb->name);
}
}
} /* end loop */
}
/************************************************************************/
/* scl2_ln_init_svcb_vals */
/* Use mvlu_find_comp_type to find the data offset of each SVCB in the LN.*/
/* Then write the SCL data there. */
/************************************************************************/
static ST_VOID scl2_ln_init_svcb_vals (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
ST_CHAR flatname [MAX_IDENT_LEN +1];
SCL_SVCB *scl_svcb;
RUNTIME_TYPE *comp_rt_type; /* first rt_type of component */
ST_INT comp_rt_num; /* num of rt_types in component */
ST_RET retcode = SD_SUCCESS;
ST_CHAR *dataptr;
for (scl_svcb = (SCL_SVCB *) list_find_last ((DBL_LNK *) scl_ln->svcbHead);
scl_svcb != NULL;
scl_svcb = (SCL_SVCB *) list_find_prev ((DBL_LNK *) scl_ln->svcbHead, (DBL_LNK *) scl_svcb))
{
/* NOTE: mvlu_find_comp_type uses flattened name without LN prefix. */
if (scl_svcb->multicast)
sprintf (flatname, "MS$%s", scl_svcb->name);
else
sprintf (flatname, "US$%s", scl_svcb->name);
retcode = mvlu_find_comp_type (scl_ln->mvl_var_assoc->type_id,
flatname, &comp_rt_type, &comp_rt_num);
if (retcode!=SD_SUCCESS)
{
SXLOG_ERR2 ("Cannot find component '%s' in var '%s'. Initial values not set.",
flatname, scl_ln->mvl_var_assoc->name);
}
else
{
dataptr = (ST_CHAR *) scl_ln->mvl_var_assoc->data
+ comp_rt_type->mvluTypeInfo.offSet;
/* Use SCL info to initialize SVCB data. */
if (scl_svcb->multicast)
{ /* MSVCB */
MVL61850_MSVCB_DATA *msvcb_data = (MVL61850_MSVCB_DATA *) dataptr;
msvcb_data->SvEna = SD_FALSE; /* can't be configured. Init to FALSE*/
strcpy (msvcb_data->MsvID, scl_svcb->smvID);
/* Construct ObjectReference to initialize msvcb_data->DatSet. */
scl_make_objref (scl_ld, scl_ln, scl_svcb->datSet,
msvcb_data->DatSet, sizeof (msvcb_data->DatSet) - 1);
msvcb_data->ConfRev = scl_svcb->confRev;
msvcb_data->SmpRate = scl_svcb->smpRate;
msvcb_data->OptFlds.len = 3; /* Var len 3-bit bitstring */
msvcb_data->OptFlds.data[0] = scl_svcb->OptFlds[0]; /* 1 byte of data*/
}
else
{ /* USVCB */
MVL61850_USVCB_DATA *usvcb_data = (MVL61850_USVCB_DATA *) dataptr;
usvcb_data->SvEna = SD_FALSE; /* can't be configured. Init to FALSE*/
usvcb_data->Resv = SD_FALSE; /* can't be configured. Init to FALSE*/
strcpy (usvcb_data->UsvID, scl_svcb->smvID);
/* Construct ObjectReference to initialize usvcb_data->DatSet. */
scl_make_objref (scl_ld, scl_ln, scl_svcb->datSet,
usvcb_data->DatSet, sizeof (usvcb_data->DatSet) - 1);
usvcb_data->ConfRev = scl_svcb->confRev;
usvcb_data->SmpRate = scl_svcb->smpRate;
usvcb_data->OptFlds.len = 3; /* Var len 3-bit bitstring */
usvcb_data->OptFlds.data[0] = scl_svcb->OptFlds[0]; /* 1 byte of data*/
}
}
} /* end loop */
}
/************************************************************************/
/* scl2_ln_init_sgcb_vals */
/* Use mvlu_find_comp_type to find the data offset of the SGCB in the LN.*/
/* Then write the SCL data there. */
/************************************************************************/
static ST_VOID scl2_ln_init_sgcb_vals (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
ST_CHAR flatname [MAX_IDENT_LEN +1];
RUNTIME_TYPE *comp_rt_type; /* first rt_type of component */
ST_INT comp_rt_num; /* num of rt_types in component */
ST_RET retcode = SD_SUCCESS;
ST_CHAR *dataptr;
MVL61850_SGCB_DATA *sgcb_data;
/* Only 1 SGCB allowed. Don't need loop. */
if (scl_ln->sgcb)
{
/* NOTE: mvlu_find_comp_type uses flattened name without LN prefix. */
strcpy (flatname, "SP$SGCB");
retcode = mvlu_find_comp_type (scl_ln->mvl_var_assoc->type_id,
flatname, &comp_rt_type, &comp_rt_num);
if (retcode!=SD_SUCCESS)
{
SXLOG_ERR2 ("Cannot find component '%s' in var '%s'. Initial values not set.",
flatname, scl_ln->mvl_var_assoc->name);
}
else
{
dataptr = (ST_CHAR *) scl_ln->mvl_var_assoc->data
+ comp_rt_type->mvluTypeInfo.offSet;
/* Use SCL info to initialize SGCB data. */
sgcb_data = (MVL61850_SGCB_DATA *) dataptr;
sgcb_data->NumOfSG = scl_ln->sgcb->numOfSGs;
sgcb_data->ActSG = scl_ln->sgcb->actSG;
}
}
}
/************************************************************************/
/* scl2_ln_create */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_ln_create (
MVL_VMD_CTRL *vmd_ctrl,
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
ST_INT type_id;
MVL_VAR_ASSOC *var_assoc;
OBJECT_NAME object_name;
ST_RET retcode;
retcode = SD_FAILURE; /* assume failure */
type_id = scl_ln->type_id;
if (type_id < 0)
SXLOG_ERR2 ("Cannot find type='%s' for logical node='%s'", scl_ln->lnType, scl_ln->varName);
else
{
/* Construct object name from LD & LN info. */
object_name.object_tag = DOM_SPEC; /* ALWAYS Domain specific */
object_name.domain_id = scl_ld->domName;
object_name.obj_name.vmd_spec = scl_ln->varName;
/* Create the MMS variable (Logical Node). */
/* This function also allocates "var_alloc->data" where this */
/* variable's data is stored. */
var_assoc = mvl_var_add_alloc (vmd_ctrl, &object_name,
NULL, /* MVL_NET_INFO * */
type_id,
NULL); /* MVL_VAR_PROC * */
if (var_assoc == NULL)
SXLOG_ERR2 ("Cannot create LN='%s' in LD='%s'", scl_ln->varName, scl_ld->domName);
else
{
var_assoc->flags = MVL_VAR_FLAG_UCA; /* CRITICAL: must make it a UCA variable*/
/* NOTE: var_assoc->use_static_data flag is automatically set */
/* by mvl_vmd_var_add because data is never NULL. */
scl_ln->mvl_var_assoc = var_assoc; /* save var_assoc for later*/
retcode = SD_SUCCESS;
}
}
if (retcode == SD_SUCCESS)
{
/* Set initial vals for LCB, GCB, & SCB (i.e. GSSE control block). */
scl2_ln_init_lcb_vals (scl_info, scl_ld, scl_ln);
scl2_ln_init_gcb_vals (scl_info, scl_ld, scl_ln);
scl2_ln_init_svcb_vals (scl_info, scl_ld, scl_ln);
scl2_ln_init_sgcb_vals (scl_info, scl_ld, scl_ln);
}
return (retcode);
}
/************************************************************************/
/* scl2_dataset_create */
/* Create one DataSet (SCL_DATASET) for this Logical Node (SCL_LN). */
/* A DataSet maps to a MMS NamedVariableList (NVL). */
/* The MMS NVL name follows the form "LogicalNodeName$DataSetName". */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_dataset_create (
MVL_VMD_CTRL *vmd_ctrl,
SCL_LD *scl_ld,
SCL_LN *scl_ln,
SCL_DATASET *scl_dataset)
{
OBJECT_NAME nvl_obj;
MVL_NVLIST_CTRL *nvlist_ctrl;
ST_INT num_var = 0;
OBJECT_NAME *var_obj; /* array of var names */
SCL_FCDA *scl_fcda;
ST_RET ret;
/* allow extra char in var_name so strncat can go beyond limit. If it does, return error.*/
ST_CHAR *var_name_buf; /* one buf allocated to hold all var names */
ST_CHAR *var_name; /* ptr to current name being constructed */
ST_CHAR *dot_ptr; /* ptr to '.' within var_name */
ST_CHAR nvl_name [MAX_IDENT_LEN+1]; /* one extra byte for NULL */
ret = SD_SUCCESS; /* assume success */
/* Construct NVL object name from LD, LN, and DataSet info. */
if (strlen (scl_ln->prefix) + strlen (scl_ln->lnClass) + strlen (scl_ln->inst)
+ strlen (scl_dataset->name) + 1 > MAX_IDENT_LEN)
{
SXLOG_ERR1 ("Constructed NVL name would be too long for dataset '%s'.", scl_dataset->name);
return (SD_FAILURE);
}
sprintf (nvl_name, "%s%s%s$%s", scl_ln->prefix, scl_ln->lnClass, scl_ln->inst, scl_dataset->name);
nvl_obj.object_tag = DOM_SPEC; /* ALWAYS Domain specific */
nvl_obj.domain_id = scl_ld->domName;
nvl_obj.obj_name.vmd_spec = nvl_name; /* use constructed NVL name */
/* Go through list once just to count number of variables. */
for (scl_fcda = (SCL_FCDA *) list_find_last ((DBL_LNK *) scl_dataset->fcdaHead);
scl_fcda != NULL;
scl_fcda = (SCL_FCDA *) list_find_prev ((DBL_LNK *) scl_dataset->fcdaHead, (DBL_LNK *) scl_fcda))
{
num_var++;
}
/* Allocate var_obj array. */
var_obj = chk_calloc (num_var, sizeof (OBJECT_NAME));
/* NOTE: this is a bit tricky. OBJECT_NAME struct contains only a ptr
* to name, no storage. Need to allocate storage for names. Here we
* allocate one big buffer for all names. In the loop below,
* we use part of this buffer for each name.
*/
var_name_buf = chk_calloc (num_var, MAX_IDENT_LEN+2); /* Note +2 for NULL plus extra char*/
/* Go through list again to fill in var_obj array. */
num_var = 0;
for (scl_fcda = (SCL_FCDA *) list_find_last ((DBL_LNK *) scl_dataset->fcdaHead);
scl_fcda != NULL;
scl_fcda = (SCL_FCDA *) list_find_prev ((DBL_LNK *) scl_dataset->fcdaHead, (DBL_LNK *) scl_fcda))
{
/* Set "var_name" pointing to proper section of big buffer. */
var_name = var_name_buf + num_var*(MAX_IDENT_LEN+2);
/* Fill in "var_name". */
/* NOTE: allow 1 extra char. If it is used, name is too long, so return error.*/
strncpy (var_name, scl_fcda->prefix, MAX_IDENT_LEN+1);
strncat_maxstrlen (var_name, scl_fcda->lnClass, MAX_IDENT_LEN+1);
strncat_maxstrlen (var_name, scl_fcda->lnInst, MAX_IDENT_LEN+1);
strncat_maxstrlen (var_name, "$", MAX_IDENT_LEN+1);
strncat_maxstrlen (var_name, scl_fcda->fc, MAX_IDENT_LEN+1);
if (strlen (scl_fcda->doName))
{
strncat_maxstrlen (var_name, "$", MAX_IDENT_LEN+1);
strncat_maxstrlen (var_name, scl_fcda->doName, MAX_IDENT_LEN+1);
}
if (strlen (scl_fcda->daName))
{
strncat_maxstrlen (var_name, "$", MAX_IDENT_LEN+1);
strncat_maxstrlen (var_name, scl_fcda->daName, MAX_IDENT_LEN+1);
}
/* doName or daName may contain '.'. Each '.' must be replaced with '$'.*/
dot_ptr = var_name;
while ((dot_ptr = strchr (dot_ptr, '.')) != NULL)
*dot_ptr++ = '$';
if (strlen (var_name) > MAX_IDENT_LEN)
{
SXLOG_ERR1 ("Variable name generated from FCDA info too long '%s'", var_name);
ret = SD_FAILURE;
break; /* stop looping */
}
/* var_name generated, now fill in this "var_obj". */
var_obj[num_var].object_tag = DOM_SPEC; /* ALWAYS Domain specific */
var_obj[num_var].domain_id = scl_fcda->domName;
var_obj[num_var].obj_name.vmd_spec = var_name;
num_var++;
}
if (ret == SD_SUCCESS)
{
nvlist_ctrl = mvl_vmd_nvl_add (vmd_ctrl, &nvl_obj, NULL, num_var, var_obj, SD_TRUE);
if (nvlist_ctrl)
ret = SD_SUCCESS;
else
ret = SD_FAILURE;
}
/* NOTE: can free these now because mvl_vmd_nvl_add copied this info.*/
chk_free (var_obj);
chk_free (var_name_buf);
return (ret);
}
/************************************************************************/
/* scl2_dataset_create_all */
/* Create all DataSets (SCL_DATASET) for this Logical Node (SCL_LN). */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_dataset_create_all (
MVL_VMD_CTRL *vmd_ctrl,
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
SCL_DATASET *scl_dataset;
ST_RET ret;
ret = SD_SUCCESS; /* assume success */
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_dataset = (SCL_DATASET *) list_find_last ((DBL_LNK *) scl_ln->datasetHead);
scl_dataset != NULL;
scl_dataset = (SCL_DATASET *) list_find_prev ((DBL_LNK *) scl_ln->datasetHead, (DBL_LNK *) scl_dataset))
{
ST_UINT32 mvl_debug_sel_save;
mvl_debug_sel_save = mvl_debug_sel;
mvl_debug_sel &= ~MVLLOG_NERR;
ret = scl2_dataset_create (vmd_ctrl, scl_ld, scl_ln, scl_dataset);
mvl_debug_sel = mvl_debug_sel_save;
if (ret)
{
if (!scl_debug_mode)
break; /* if one fails, stop processing */
++scl_debug_mode_error_count;
}
else
{
SXLOG_FLOW3 ("scl2_dataset_create DONE for '%s' (LD=%s LN=%s)",
scl_dataset->name, scl_ld->domName, scl_ln->varName);
}
}
return (ret);
}
/************************************************************************/
/* init_basrcb_data */
/* Use other info in scl_rcb to initialize data in basrcb. */
/************************************************************************/
static ST_VOID init_basrcb_data (
MVLU_RPT_CTRL *rpt_ctrl,
SCL_RCB *scl_rcb)
{
MVLU_BASRCB *basrcb;
basrcb = &rpt_ctrl->only_client.basrcb;
/* If RptID configured in SCL, overwrite default RptID generated by mvlu_create_rpt_ctrl */
if (strlen (scl_rcb->rptID))
strncpy_safe (basrcb->RptID, scl_rcb->rptID, sizeof (basrcb->RptID)-1);
/* Use other info in scl_rcb to initialize data in basrcb */
/* NOTE: scl_rcb->name, scl_rcb->desc not used. */
basrcb->IntgPd = scl_rcb->intgPd;
basrcb->BufTim = scl_rcb->bufTime;
basrcb->TrgOps.len = 6; /* BVstring. Assume max len*/
basrcb->TrgOps.data [0] = scl_rcb->TrgOps [0];
/*renxiaobao <20><><EFBFBD><EFBFBD>*/
basrcb->TrgOps.data [0]|= TRGOPS_BITNUM_GENERAL_INTERROGATION;
basrcb->OptFlds.data_1 [0] = scl_rcb->OptFlds [0];
basrcb->OptFlds.data_1 [1] = scl_rcb->OptFlds [1];
if (!scl_rcb->buffered)
{ /* For URCB, 61850-8-1 says to ignore buffer-overflow, entryID bits, so clear them*/
BSTR_BIT_SET_OFF (basrcb->OptFlds.data_1, OPTFLD_BITNUM_BUFOVFL);
BSTR_BIT_SET_OFF (basrcb->OptFlds.data_1, OPTFLD_BITNUM_ENTRYID);
}
}
/************************************************************************/
/* init_rpt_ctrl */
/* Used only by loop in "scl2_rcb_create". */
/************************************************************************/
ST_RET init_rpt_ctrl (
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_RCB *scl_rcb,
MVL_NVLIST_CTRL *nvl,
MVL_VAR_ASSOC *base_va,
ST_CHAR *basrcb_var_namexx,
ST_CHAR *basrcb_type_namexx,
ST_UINT reportScanRate) /* report scan rate (millisec) */
{
ST_INT buftim_action;
ST_INT set_flags; /* flags for mvlu_set_leaf_param_name */
ST_RET ret;
ST_CHAR leaf_name [MAX_IDENT_LEN + 1];
MVLU_RPT_CTRL *rpt_ctrl;
/* DEBUG: nothing in SCL to set buftim_action. Is there another way to get this info? */
buftim_action = MVLU_RPT_BUFTIM_SEND_NOW;
/* Set all leaf functions required to implement RCB.
* NOTE: these leaf functions replace the default leaf functions
* set by "u_set_all_leaf_functions" when the datatype was created.
*/
/* Use same flags for all leafs */
set_flags = MVLU_SET_RD_FUN | MVLU_SET_WR_FUN | MVLU_SET_REF;
/* Start with good return value & OR all returns together. If ANY call
* to mvlu_set_leaf_param_name fails, this function will fail.
*/
ret = SD_SUCCESS;
/* CRITICAL: len of basrcb_type_name chked above, so none of these "sprintf"s
* will cause leaf_name to be exceeded.
*/
sprintf (leaf_name, "%s$RptID", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_rptid_rd_ind_fun",
"mvlu_rptid_wr_ind_fun",
"");
sprintf (leaf_name, "%s$RptEna", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_rptena_rd_ind_fun",
"mvlu_rptena_wr_ind_fun",
"");
if (!scl_rcb->buffered) /* "Resv" only for Unbuffered */
{
sprintf (leaf_name, "%s$Resv", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_resv_rd_ind_fun",
"mvlu_resv_wr_ind_fun",
"");
}
sprintf (leaf_name, "%s$DatSet", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_datsetna_rd_ind_fun",
"mvl61850_datset_wr_ind",
"");
sprintf (leaf_name, "%s$ConfRev", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_confrev_rd_ind",
"u_no_write_allowed", /* NOT writable */
"");
sprintf (leaf_name, "%s$OptFlds", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_optflds_rd_ind_fun",
"mvlu_optflds_wr_ind_fun",
"");
sprintf (leaf_name, "%s$BufTm", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_buftim_rd_ind_fun",
"mvlu_buftim_wr_ind_fun",
"");
sprintf (leaf_name, "%s$SqNum", basrcb_type_namexx);
if (scl_rcb->buffered)
{ /* Buffered uses INT16U for SqNum */
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_sqnum_int16u_rd_ind_fun",
"u_no_write_allowed",
"");
}
else
{ /* Unbuffered uses INT8U for SqNum */
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_sqnum_rd_ind_fun",
"u_no_write_allowed",
"");
}
sprintf (leaf_name, "%s$TrgOps", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_trgops_rd_ind_fun",
"mvlu_trgops_wr_ind_fun",
"");
sprintf (leaf_name, "%s$IntgPd", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_intgpd_rd_ind_fun",
"mvlu_intgpd_wr_ind_fun",
"");
sprintf (leaf_name, "%s$GI", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_gi_rd_ind",
"mvlu_gi_wr_ind",
"");
if (scl_rcb->buffered) /* only for Buffered */
{
sprintf (leaf_name, "%s$PurgeBuf", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_purgebuf_rd_ind",
"mvlu_purgebuf_wr_ind",
"");
sprintf (leaf_name, "%s$EntryID", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_entryid_rd_ind",
"mvlu_entryid_wr_ind",
"");
sprintf (leaf_name, "%s$TimeofEntry", basrcb_type_namexx);
ret |= mvlu_set_leaf_param_name2 (base_va->type_id, set_flags,
leaf_name,
"mvlu_timeofentry_rd_ind",
"u_no_write_allowed", /* NOT writable */
"");
} /* only for Buffered */
if (ret)
{
SXLOG_ERR1 ("At least one leaf function could not be found for RCB '%s'", basrcb_var_namexx);
if (scl_debug_mode)
{
++scl_debug_mode_error_count;
return (SD_SUCCESS); /* Don't let this stop us for now ... */
}
return (ret);
}
/* NOTE: nvl may be NULL. If so, it must be set later when client writes DatSet.*/
rpt_ctrl = mvl61850_create_rpt_ctrl (basrcb_var_namexx, nvl,
base_va,
(scl_rcb->buffered ? RCB_TYPE_IEC_BRCB : RCB_TYPE_IEC_URCB),
buftim_action,
scl_info->brcb_bufsize, /* BRCB bufsize */
scl_rcb->confRev); /* ConfRev */
if (rpt_ctrl)
{
init_basrcb_data (rpt_ctrl, scl_rcb); /* use scl_rcb to init data*/
rpt_ctrl->scan_rate = (ST_DOUBLE) reportScanRate; /* init scan rate*/
ret = SD_SUCCESS;
/* renxiaobao <20><><EFBFBD><EFBFBD>*/
if(scl_rcb->buffered==RCB_TYPE_IEC_BRCB) BRCB_NUM++;
else URCB_NUM++;
}
else
ret = SD_FAILURE;
return (ret);
}
/************************************************************************/
/* scl2_rcb_create */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_rcb_create (
MVL_VMD_CTRL *vmd_ctrl,
SCL_INFO *scl_info,
SCL_LD *scl_ld,
SCL_LN *scl_ln,
SCL_RCB *scl_rcb,
ST_UINT reportScanRate) /* report scan rate (millisec) */
{
ST_RET ret = SD_FAILURE;
ST_CHAR basrcb_var_name [MAX_IDENT_LEN + 1];
ST_CHAR basrcb_type_name [MAX_IDENT_LEN + 1]; /* for setting leaf functions*/
ST_CHAR basrcb_var_namexx [MAX_IDENT_LEN + 1]; /* name plus 2 char index*/
ST_CHAR basrcb_type_namexx [MAX_IDENT_LEN + 1]; /* name plus 2 char index*/
MVL_VAR_ASSOC *base_va;
OBJECT_NAME base_var_oname;
OBJECT_NAME nvl_oname;
MVL_NVLIST_CTRL *nvl;
SCL_DATASET *scl_dataset;
ST_CHAR nvl_name [MAX_IDENT_LEN+1];
ST_INT index, maxClient;
/* Initialize basrcb_type_name. Add $BR.. or $RP.. later. */
/* First part of name shouldn't matter now that init_rpt_ctrl uses */
/* mvlu_set_leaf_param_name2 to set leaf params. Use simple name. */
strcpy (basrcb_type_name, "b");
/* Generate basrcb_var_name from SCL info. The code below should generate a unique
* basrcb_var_name for every RCB in this LN.
*/
strcpy (basrcb_var_name, scl_ln->varName); /* never too long */
if (scl_rcb->buffered)
{
strncat_maxstrlen (basrcb_var_name, "$BR$", MAX_IDENT_LEN);
strncat_maxstrlen (basrcb_type_name, "$BR$", MAX_IDENT_LEN);
}
else
{
strncat_maxstrlen (basrcb_var_name, "$RP$", MAX_IDENT_LEN);
strncat_maxstrlen (basrcb_type_name, "$RP$", MAX_IDENT_LEN);
}
/* Add RCB name (read from SCL file). */
strncat_maxstrlen (basrcb_var_name, scl_rcb->name, MAX_IDENT_LEN);
strncat_maxstrlen (basrcb_type_name, scl_rcb->name, MAX_IDENT_LEN);
/* Make sure there's room for 2 char "index" plus longest suffix */
if (strlen (basrcb_var_name) + 2 + sizeof("$TimeOfEntry") > MAX_IDENT_LEN)
{
SXLOG_ERR1 ("BasRCB variable name '%s' too long", basrcb_var_name);
return (SD_FAILURE);
}
if (strlen (basrcb_type_name) + 2 + sizeof("$TimeOfEntry") > MAX_IDENT_LEN)
{
SXLOG_ERR1 ("BasRCB type name '%s' too long", basrcb_type_name);
return (SD_FAILURE);
}
/* If "datSet" is not NULL, try to find it. */
if (scl_rcb->datSet[0] != '\0')
{
scl_dataset = scl_find_dataset (scl_ln, scl_rcb->datSet);
if (scl_dataset == NULL)
{
SXLOG_ERR1 ("scl2_rcb_create: datSet='%s' not found", scl_rcb->datSet);
return (SD_FAILURE);
}
/* Construct NVL object name from LD, LN, and DataSet info. */
if (strlen (scl_ln->prefix) + strlen (scl_ln->lnClass) + strlen (scl_ln->inst)
+ strlen (scl_rcb->datSet) + 1 > MAX_IDENT_LEN)
{
SXLOG_ERR1 ("Constructed NVL name would be too long for dataset '%s'.", scl_rcb->datSet);
return (SD_FAILURE);
}
sprintf (nvl_name, "%s%s%s$%s", scl_ln->prefix, scl_ln->lnClass, scl_ln->inst, scl_rcb->datSet);
nvl_oname.object_tag = DOM_SPEC;
nvl_oname.domain_id = scl_ld->domName; /* domain name */
nvl_oname.obj_name.item_id = nvl_name; /* use constructed NVL name */
nvl = mvl_vmd_find_nvl (vmd_ctrl, &nvl_oname,
NULL); /* DOM_SPEC so net_info doesn't matter*/
if (nvl == NULL)
{
SXLOG_ERR3 ("Cannot find NVL '%s' in domain '%s' to create RCB '%s'",
nvl_oname.obj_name.item_id,
nvl_oname.domain_id,
basrcb_var_name);
return (SD_FAILURE);
}
}
else
nvl = NULL; /* datSet="" so can't find NVL */
/* Find the "base_va". Needed as arg to mvlu_create_rpt_ctrl. */
base_var_oname.object_tag = DOM_SPEC;
base_var_oname.domain_id = scl_ld->domName;
base_var_oname.obj_name.item_id = scl_ln->varName;
base_va = mvl_vmd_find_var (vmd_ctrl, &base_var_oname,
NULL); /* DOM_SPEC so net_info doesn't matter*/
if (base_va == NULL)
{
SXLOG_ERR1 ("Cannot find base variable='%s' for RCB", scl_ln->varName);
return (SD_FAILURE);
}
assert (scl_rcb->maxClient > 0 && scl_rcb->maxClient <= 99); /* was checked during parsing */
maxClient = scl_rcb->maxClient; /* use value of "RptEnabled max" in SCL*/
/* Create "maxClient" RCBs, each with "index" as a suffix. */
for (index = 1; index <= maxClient; index++)
{
if (rcb_name_no_index && maxClient == 1)
{ /* do NOT add suffix */
sprintf (basrcb_var_namexx, "%s", basrcb_var_name);
sprintf (basrcb_type_namexx, "%s", basrcb_type_name);
}
else
{
/* Add "index" suffix to var and type name. */
sprintf (basrcb_var_namexx, "%s%02d", basrcb_var_name, index);
sprintf (basrcb_type_namexx, "%s%02d", basrcb_type_name, index);
}
ret = init_rpt_ctrl (scl_info, scl_rcb, nvl, base_va,
basrcb_var_namexx, basrcb_type_namexx, reportScanRate);
if (ret)
break; /* stop looping on any error. */
} /* end of loop */
return (ret);
}
/************************************************************************/
/* scl2_rcb_create_all */
/* Create all Report Control Blocks (SCL_RCB) for this Logical Node (SCL_LN).*/
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_rcb_create_all (
MVL_VMD_CTRL *vmd_ctrl,
SCL_INFO *scl_info,
SCL_LD *scl_ld,
SCL_LN *scl_ln,
ST_UINT reportScanRate) /* report scan rate (millisec) */
{
SCL_RCB *scl_rcb;
ST_RET ret;
ret = SD_SUCCESS; /* assume success */
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_rcb = (SCL_RCB *) list_find_last ((DBL_LNK *) scl_ln->rcbHead);
scl_rcb != NULL;
scl_rcb = (SCL_RCB *) list_find_prev ((DBL_LNK *) scl_ln->rcbHead, (DBL_LNK *) scl_rcb))
{
ret = scl2_rcb_create (vmd_ctrl, scl_info, scl_ld, scl_ln, scl_rcb,
reportScanRate);
if (ret)
break; /* if one fails, stop processing */
else
SXLOG_FLOW3 ("scl2_rcb_create DONE for '%s' (LD=%s LN=%s)",
scl_rcb->name, scl_ld->domName, scl_ln->varName);
}
return (ret);
}
/************************************************************************/
/* convert_initial_value */
/* NOTE: This function does special conversion for "Enum" and "Boolean" */
/* values. For all other types, it just calls sxaTextToLocal. */
/************************************************************************/
ST_RET convert_initial_value (SCL_INFO *scl_info,
SCL_LD *scl_ld,
SCL_LN *scl_ln,
ST_CHAR *flattened_name, /* flattened variable name */
RUNTIME_CTRL *rt_ctrl,
ST_INT comp_rt_index, /* index to this comp in array */
ST_VOID *data, /* Pointer to converted data */
ST_CHAR *valstring) /* string to be converted. */
{
ST_RET ret = SD_SUCCESS;
RUNTIME_TYPE *comp_rt_type;
SCL_ENUMTYPE *scl_enumtype;
RESERVED_INFO *reserved_info; /* ptr to array of extra type info. */
short i;
char *ptr0,*ptr1;
/* Cast "reserved_1" pointer to the type we allocated. */
reserved_info = (RESERVED_INFO *) rt_ctrl->reserved_1;
comp_rt_type = rt_ctrl->rt_first + comp_rt_index;
scl_enumtype = reserved_info[comp_rt_index].scl_enumtype; /* may be NULL*/
/* Component must be primitive. */
assert (ms_is_rt_prim (comp_rt_type));
if (comp_rt_type->el_tag == RT_INTEGER && scl_enumtype) /* must be Enum */
{
/* Try to match text with EnumType definition.*/
SCL_ENUMVAL *scl_enumval;
ST_BOOLEAN found = SD_FALSE;
for (scl_enumval = (SCL_ENUMVAL *) list_find_last ((DBL_LNK *) scl_enumtype->enumvalHead);
scl_enumval != NULL;
scl_enumval = (SCL_ENUMVAL *) list_find_prev ((DBL_LNK *) scl_enumtype->enumvalHead, (DBL_LNK *) scl_enumval))
{
if (strcmp (scl_enumval->EnumVal, valstring) == 0)
{
*(ST_INT8*)data = (ST_INT8) scl_enumval->ord;
found = SD_TRUE;
break;
}
}
if (!found)
{
SXLOG_ERR3("%s$%s does not match any EnumVal. Trying numeric conversion. %s",scl_ln->varName,flattened_name,valstring);
/* SXLOG_ERR1 ("Val='$s' does not match any EnumVal. Trying numeric conversion.",valstring);*/
/* This is not required by IEC 61850, but if valstring does not match */
/* any EnumVal and it starts with a digit, do numeric conversion. */
if (isdigit (valstring[0]))
ret = sxaTextToLocal (valstring, data, 1, /* rt_num always 1 (primitive) */
comp_rt_type);
else
ret = SD_FAILURE;
}
}
else if (comp_rt_type->el_tag == RT_BOOL)
{ /* convert boolean (may be "0", "1", "true", or "false") */
if (strcmp (valstring, "true") == 0 || strcmp (valstring, "1") == 0)
*(ST_INT8 *)data = 1;
else if (strcmp (valstring, "false") == 0 || strcmp (valstring, "0") == 0)
*(ST_INT8 *)data = 0;
else
ret = SD_FAILURE;
}
/* Do special checking for visible strings. */
else if (comp_rt_type->el_tag == RT_VISIBLE_STRING)
{
ST_CHAR *ptr;
/* Visible string must not contain any control chars. */
for (ptr = valstring; *ptr!=0; ptr++)
{
if (*ptr < ' ') /* Check that character is not a control char. */
{
SXLOG_ERR1 ("Illegal character (0x%02x) in visible string",
(ST_UINT)(ST_UCHAR) *ptr); /* 2 casts to avoid sign extension*/
ret = SD_FAILURE;
break; /* stop on first error */
return SD_SUCCESS; /*renxiaobao da<64><61>ʼ<EFBFBD><CABC>*/
}
}
if (ret == SD_SUCCESS)
{
if (comp_rt_type->u.p.el_len < 0 /* variable len */
&& strlen (valstring) > (size_t) abs (comp_rt_type->u.p.el_len))
{
SXLOG_ERR2 ("String '%s' exceeds max len '%d'",
valstring, abs (comp_rt_type->u.p.el_len));
ret = SD_FAILURE;
return SD_SUCCESS; /*renxiaobao da<64><61>ʼ<EFBFBD><CABC>*/
}
else if (comp_rt_type->u.p.el_len >= 0 /* fixed len */
&& strlen (valstring) != (size_t) comp_rt_type->u.p.el_len)
{
/* Shouldn't get here because no fixed len in SCL, but just in case..*/
SXLOG_ERR2 ("String '%s' does not match fixed len '%d'",
valstring, comp_rt_type->u.p.el_len);
ret = SD_FAILURE;
return SD_SUCCESS; /*renxiaobao da<64><61>ʼ<EFBFBD><CABC>*/
}
else
strcpy (data, valstring); /* all is ok, so copy string*/
}
} /* end RT_VISIBLE_STRING */
/*renxiaobao UTF8<46><38><EFBFBD><EFBFBD>*/
else if (comp_rt_type->el_tag == RT_UTF8_STRING)
{
ptr0 = data;
ptr1 = valstring;
for(i=0;((i<comp_rt_type->el_size)&&ptr1[i]);i++)
{
ptr0[i] = ptr1[i];
}
}
else
{ /* handle all other element types */
ret = sxaTextToLocal (valstring, data, 1, /* rt_num always 1 (primitive) */
comp_rt_type);
}
if (ret)
{ /* Our conversion code failed. Let the user try. */
SCL2_IV_TRANSLATE_CTRL translate_ctrl;
memset (&translate_ctrl, 0, sizeof (SCL2_IV_TRANSLATE_CTRL));
translate_ctrl.scl_info = scl_info;
translate_ctrl.scl_ld = scl_ld;
translate_ctrl.scl_ln = scl_ln;
translate_ctrl.valText = valstring;
translate_ctrl.attrib = flattened_name;
translate_ctrl.dest = data;
translate_ctrl.numRt = 1; /* always 1 (primitive) */
translate_ctrl.rtHead = comp_rt_type;
ret = u_mvl_scl_set_initial_value (&translate_ctrl);/* call user funct*/
}
return (ret);
}
/************************************************************************/
/* scl2_dai_set_value */
/* Set initial data value from DAI input from SCL file. */
/* Use sxaTextToLocal to convert the text to data. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
int sAddr_num=0,sAddr_num_bak;
static ST_RET scl2_dai_set_value (SCL_INFO *scl_info,
SCL_LD *scl_ld,
SCL_LN *scl_ln,
SCL_DAI *scl_dai)
{
ST_CHAR fixed_name [MAX_IDENT_LEN +1];
ST_CHAR fixed_name1 [MAX_IDENT_LEN +1];
ST_CHAR leaf_name [MAX_IDENT_LEN +1];
ST_RET ret = SD_FAILURE;
MVL_VAR_ASSOC *var; /* MVL Variable Association created from LN info*/
RUNTIME_TYPE *comp_rt_type; /* first rt_type of component */
RUNTIME_TYPE *comp_rt_type1=0;
ST_INT comp_rt_num; /* num of rt_types in component */
ST_UINT32 mvl_debug_sel_save;
MVL_TYPE_CTRL *type_ctrl;
DATA_MAP_LINK *data_map;
ST_CHAR *LeafToFind;
ST_CHAR leafname [MAX_IDENT_LEN +1];
unsigned char *pdat;
/* It seems strange but "Val" is optional for DAI (i.e. Instantiated */
/* Data Attribute with no value). If "Val" not present, do nothing. */
/* //if (scl_dai->Val == NULL)
//{
// SXLOG_FLOW2 ("scl2_dai_set_value: 'Val' not present for attribute '%s' in '%s'. Do nothing.",
// scl_dai->flattened, scl_ln->varName);
// return (SD_SUCCESS); // nothing to do, so stop now
//}*/
var = scl_ln->mvl_var_assoc;
if (strlen (scl_dai->flattened) <= (MAX_IDENT_LEN-3))
{
/* Turn off false NERR log messages */
mvl_debug_sel_save = mvl_debug_sel;
mvl_debug_sel &= ~MVLLOG_NERR;
/* Find the attribute type. Don't know the FC, so try all possible */
/* FC (i.e."ST" "MX" "CO" "SP" "SG" "SE" "SV" "CF" "DC" or "EX"). */
do /* use "do-while" loop only so we can break out on success*/
{
strcpy (fixed_name, "ST$"); /* Try "ST" first. */
strcat (fixed_name, scl_dai->flattened);
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "MX", 2); /* replace FC prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "CO", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "SP", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "SG", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
{
/*renxiaobao <20><><EFBFBD><EFBFBD>ӳ<EFBFBD><D3B3>*/
strcpy (fixed_name1, "SE$"); /* Try "ST" first. */
strcat (fixed_name1, scl_dai->flattened);
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name1, &comp_rt_type1, &comp_rt_num)) != SD_SUCCESS)
{
printf("%s mvlu_find_comp_type error...\n",fixed_name1);
}
break; /* found it. done */
}
/*
//strncpy (fixed_name, "SE", 2); // replace prefix
//if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
//break; found it. done
*/
strncpy (fixed_name, "SV", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "CF", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "DC", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
strncpy (fixed_name, "EX", 2); /* replace prefix*/
if ((ret = mvlu_find_comp_type (var->type_id, fixed_name, &comp_rt_type, &comp_rt_num)) == SD_SUCCESS)
break; /* found it. done */
} while (0); /* end of do-while loop */
/* Restore MVL log mask settings */
mvl_debug_sel = mvl_debug_sel_save;
}
/*renxiaobao <20><><EFBFBD><EFBFBD>ӳ<EFBFBD><D3B3>*/
if(strlen(scl_dai->sAddr))
{
sAddr_num++;
sAddr_num_bak = sAddr_num;
sprintf(leaf_name,"%s$%s",scl_ln->varName,fixed_name);
data_map = chk_calloc (1, sizeof (DATA_MAP_LINK));
// logprint("%s",leaf_name);
strcpy(data_map->leaf,leaf_name);
strcpy(data_map->ldevice,scl_ld->domName);
strcpy(data_map->usr_data_info,scl_dai->sAddr);
list_add_last (&DATA_MAP_saddr, data_map);
strcpy(leafname,leaf_name);
LeafToFind = strstr(leafname,"$SG$");
if(LeafToFind)
{
strncpy(LeafToFind,"$SE$",4);
sAddr_num++;
data_map = chk_calloc (1, sizeof (DATA_MAP_LINK));
strcpy(data_map->leaf,leafname);
strcpy(data_map->ldevice,scl_ld->domName);
strcpy(data_map->usr_data_info,scl_dai->sAddr);
list_add_last (&DATA_MAP_saddr, data_map);
}
}
/* Tried all possible FC. Did we find a match. */
if (ret != SD_SUCCESS)
{
SXLOG_ERR2 ("scl2_dai_set_value: Attribute '%s' in '%s' not found.",
scl_dai->flattened, scl_ln->varName);
if (strchr (scl_dai->flattened, '[') != NULL)
SXLOG_CERR0 ("Initialization of array elements not yet supported.");
}
else if (comp_rt_num !=1)
{
SXLOG_ERR2 ("scl2_dai_set_value: Attribute '%s' in '%s' not a primitive type.",
scl_dai->flattened, scl_ln->varName);
ret = SD_FAILURE;
}
if(ret == SD_SUCCESS)
{
/*renxiaobao <20><><EFBFBD><EFBFBD>ӳ<EFBFBD><D3B3>*/
if(strlen(scl_dai->sAddr))
{
pdat = (unsigned char*)(var->data)+comp_rt_type->mvluTypeInfo.offSet;
*pdat = ((sAddr_num_bak-1)/1000)+0x80;
if(scl_dai->Val != NULL)
{
printf("warning:scl_dai sAddr and Val both exist(%s %s)...",scl_dai->sAddr,scl_dai->Val);
}
if(comp_rt_type1)
{
pdat = (unsigned char*)(var->data)+comp_rt_type1->mvluTypeInfo.offSet;
*pdat = ((sAddr_num-1)/1000)+0x80;
}
}
else if(scl_dai->Val != NULL)
{
type_ctrl = mvl_type_ctrl_find (var->type_id);
ret = convert_initial_value (scl_info, scl_ld, scl_ln, fixed_name,
type_ctrl->rt_ctrl,
comp_rt_type - type_ctrl->rt_ctrl->rt_first, /* index to this comp*/
(ST_INT8*)(var->data)+comp_rt_type->mvluTypeInfo.offSet,
scl_dai->Val);
}
}
if (ret == SD_SUCCESS)
{
SXLOG_FLOW3 ("scl2_dai_set_value: Val '%s' conversion for '%s$%s' SUCCESSFUL",
scl_dai->Val, scl_ln->varName, fixed_name);
}
else
{
SXLOG_ERR3 ("scl2_dai_set_value: Val '%s' conversion for '%s$%s' FAILED",
scl_dai->Val, scl_ln->varName, fixed_name);
printf ("scl2_dai_set_value: Val '%s' conversion for '%s$%s' FAILED",scl_dai->Val, scl_ln->varName, fixed_name);
}
if (scl_debug_mode)
{
if (ret != SD_SUCCESS)
++scl_debug_mode_error_count;
return (SD_SUCCESS); /* Don't let this stop us for now ... */
}
return (ret);
}
/************************************************************************/
/* scl2_da_or_bda_set_value_all */
/* NOTE: the same Val text might get converted many times by this */
/* function, but not enough info available to do conversion before now. */
/************************************************************************/
static ST_RET scl2_da_or_bda_set_value_all (SCL_INFO *scl_info,
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
ST_RET ret;
MVL_TYPE_CTRL *type_ctrl;
RUNTIME_TYPE *rt_type;
ST_INT rt_idx; /* index into RUNTIME_TYPE array. */
RESERVED_INFO *reserved_info; /* ptr to array of extra type info. */
ret = SD_SUCCESS; /* assume success */
/* If this var could not be created, don't crash */
if (scl_ln->mvl_var_assoc == NULL)
{
if (scl_debug_mode)
{
if (ret != SD_SUCCESS)
++scl_debug_mode_error_count;
return (SD_SUCCESS); /* Don't let this stop us for now ... */
}
}
type_ctrl = mvl_type_ctrl_find (scl_ln->mvl_var_assoc->type_id);
assert (type_ctrl);
/* Cast "reserved_1" pointer to the type we allocated. */
reserved_info = (RESERVED_INFO *) type_ctrl->rt_ctrl->reserved_1;
/* Loop through all elements of RUNTIME_TYPE array */
for (rt_idx = 0, rt_type = type_ctrl->rt_ctrl->rt_first;
rt_idx < type_ctrl->rt_ctrl->rt_num;
rt_idx++, rt_type++)
{
ST_CHAR *Val = reserved_info[rt_idx].Val;
if (Val) /* string to convert*/
{
/* Convert text to value & store in Variable. */
ret = convert_initial_value (scl_info, scl_ld, scl_ln,
NULL, /* don't know flattened_name in this case. */
type_ctrl->rt_ctrl,
rt_idx,
(ST_INT8*)(scl_ln->mvl_var_assoc->data) + rt_type->mvluTypeInfo.offSet,
Val); /* string to convert*/
if (ret != SD_SUCCESS)
{
SXLOG_ERR2 ("Cannot convert DA or BDA Val='%s' to data for '%s' attribute.",
Val, ms_comp_name_find(rt_type));
break; /* stop now */
}
}
}
return (ret);
}
/************************************************************************/
/* scl2_dai_set_value_all */
/* Initialize data for all DAI in this logical node. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_dai_set_value_all (SCL_INFO *scl_info,
SCL_LD *scl_ld,
SCL_LN *scl_ln)
{
SCL_DAI *scl_dai;
ST_RET ret;
ret = SD_SUCCESS; /* assume success */
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_dai = (SCL_DAI *) list_find_last ((DBL_LNK *) scl_ln->daiHead);
scl_dai != NULL;
scl_dai = (SCL_DAI *) list_find_prev ((DBL_LNK *) scl_ln->daiHead, (DBL_LNK *) scl_dai))
{
ret = scl2_dai_set_value (scl_info, scl_ld, scl_ln, scl_dai);
if (ret)
{
SXLOG_ERR3 ("scl2_dai_set_value FAILED for '%s' (LD=%s LN=%s)",
scl_dai->flattened, scl_ld->domName, scl_ln->varName);
break; /* if one fails, stop processing */
}
else
SXLOG_FLOW3 ("scl2_dai_set_value DONE for '%s' (LD=%s LN=%s)",
scl_dai->flattened, scl_ld->domName, scl_ln->varName);
}
ret = SD_SUCCESS; /*renxiaobao20221014 */
return (ret);
}
/************************************************************************/
/* scl2_ld_create_part1 */
/* Create Domain and all variables in it. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_ld_create_part1 (
MVL_VMD_CTRL *vmd_ctrl,
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld)
{
ST_RET ret = SD_SUCCESS; /* Assume success */
MVL_DOM_CTRL *dom_ctrl;
ST_INT max_num_var; /* compute from scl_ld info */
ST_INT max_num_nvl;
ST_INT max_num_jou;
SCL_LN *scl_ln;
/* Make sure there's room for all Logical Nodes (variables) defined in SCL.*/
/* plus room for the configured maximum number of dynamic variables. */
max_num_var = list_get_sizeof (scl_ld->lnHead) + mvl_max_dyn.dom_vars;
max_num_nvl = mvl_max_dyn.dom_nvls;
max_num_jou = mvl_max_dyn.journals;
/* First create MMS domain */
dom_ctrl = mvl_vmd_dom_add (vmd_ctrl,
scl_ld->domName, /* domain name */
max_num_var,
max_num_nvl,
max_num_jou,
SD_TRUE); /* always copy name to dom_ctrl */
if (!dom_ctrl)
ret = SD_FAILURE;
/* If MMS domain created successfully, create all MMS variables (logical nodes). */
if (ret == SD_SUCCESS)
{
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ln = (SCL_LN *) list_find_last ((DBL_LNK *) scl_ld->lnHead);
scl_ln != NULL;
scl_ln = (SCL_LN *) list_find_prev ((DBL_LNK *) scl_ld->lnHead, (DBL_LNK *) scl_ln))
{
ret = scl2_ln_create (vmd_ctrl, scl_info, scl_ld, scl_ln);
if (ret)
{
SXLOG_ERR1 ("scl2_ln_create FAILED for %s", scl_ln->varName);
break; /* if one fails, stop processing */
}
else
SXLOG_FLOW1 ("scl2_ln_create for %s SUCCESSFUL", scl_ln->varName);
}
}
return (ret);
}
/************************************************************************/
/* scl2_ld_create_part2 */
/* Create all NVLs and RCBs in this domain. */
/* NOTE: this cannot be done in "scl2_ld_create_part1" because NVL */
/* may include VAR from another Domain that was not defined yet. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
static ST_RET scl2_ld_create_part2 (
MVL_VMD_CTRL *vmd_ctrl,
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
SCL_LD *scl_ld,
ST_UINT reportScanRate, /* report scan rate (millisec) */
ST_BOOLEAN is_client) /* see description in scl2_ld_create_all*/
{
ST_RET ret = SD_SUCCESS; /* Assume success */
SCL_LN *scl_ln;
/* Create all MMS NVLs (DataSets).
* IEC 61850 defines a DataSet "inside" a Logical Node.
* This should seem a little strange, because
* a Logical Node maps to a MMS Variable, and a DataSet maps to a
* MMS Named Variable List, and of course, a Named Variable List CANNOT
* be "inside" of a Variable.
* This is resolved by simply creating a normal Named Variable List, and just
* adding it to the same Domain as the Variable.
* CRITICAL: THIS IS DONE AFTER ALL VARIABLES (LOGICAL NODES) CREATED BECAUSE
* DATASET MAY REFERENCE OTHER LOGICAL NODES.
*/
if (ret == SD_SUCCESS)
{
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ln = (SCL_LN *) list_find_last ((DBL_LNK *) scl_ld->lnHead);
scl_ln != NULL;
scl_ln = (SCL_LN *) list_find_prev ((DBL_LNK *) scl_ld->lnHead, (DBL_LNK *) scl_ln))
{
ret = scl2_dataset_create_all (vmd_ctrl, scl_ld, scl_ln);
if (ret)
{
break; /* if one fails, stop processing (error already logged) */
}
}
}
if (is_client)
{
SXLOG_FLOW0 ("Client configuration. Control blocks not created.");
return (ret); /* Stop now. Do NOT create RCB, LCB, etc. */
}
/* If all successful up to here, create all RCBs. */
if (ret == SD_SUCCESS)
{
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ln = (SCL_LN *) list_find_last ((DBL_LNK *) scl_ld->lnHead);
scl_ln != NULL;
scl_ln = (SCL_LN *) list_find_prev ((DBL_LNK *) scl_ld->lnHead, (DBL_LNK *) scl_ln))
{
ret = scl2_rcb_create_all (vmd_ctrl, scl_info, scl_ld, scl_ln, reportScanRate);
if (ret)
{
break; /* if one fails, stop processing (error already logged) */
}
}
}
/* If all successful up to here, set initial values from DA & BDA. */
if (ret == SD_SUCCESS)
{
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ln = (SCL_LN *) list_find_last ((DBL_LNK *) scl_ld->lnHead);
scl_ln != NULL;
scl_ln = (SCL_LN *) list_find_prev ((DBL_LNK *) scl_ld->lnHead, (DBL_LNK *) scl_ln))
{
ret = scl2_da_or_bda_set_value_all (scl_info, scl_ld, scl_ln);
if (ret)
{
break; /* if one fails, stop processing (error already logged) */
}
}
}
/* If all successful up to here, set initial data values from */
/* DOI/SDI/DAI entries found in the SCL file. */
if (ret == SD_SUCCESS)
{
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ln = (SCL_LN *) list_find_last ((DBL_LNK *) scl_ld->lnHead);
scl_ln != NULL;
scl_ln = (SCL_LN *) list_find_prev ((DBL_LNK *) scl_ld->lnHead, (DBL_LNK *) scl_ln))
{
ret = scl2_dai_set_value_all (scl_info, scl_ld, scl_ln);
if (ret)
{
break; /* if one fails, stop processing (error already logged) */
}
}
}
return (ret);
}
/************************************************************************/
/* scl2_ld_create_all */
/* Create all Logical Devices from SCL info saved in "scl_info". */
/* NOTE: must be done in 2 parts, because NVLs created in part2, may */
/* reference Vars from different domains created in part1. */
/* RETURNS: SD_SUCCESS or error code */
/************************************************************************/
ST_RET scl2_ld_create_all (
MVL_VMD_CTRL *vmd_ctrl, /* VMD in which to add Logical Devices. */
SCL_INFO *scl_info, /* main struct where all SCL info stored*/
ST_UINT reportScanRate, /* report scan rate (millisec) */
ST_INT brcb_bufsize, /* BRCB buffer size */
ST_BOOLEAN is_client) /* If this flag is set, Client model is */
/* created (i.e. Control Blocks NOT created).*/
{
ST_RET ret;
SCL_LD *scl_ld;
/* CRITICAL: Don't allow this to be called again for the same SCL_INFO struct.*/
/* That would cause duplicate objects. */
if (scl_info->ld_create_done)
{
SXLOG_ERR0 ("Logical Devices already created for this SCL file. Cannot create again.");
return (SD_FAILURE);
}
else
scl_info->ld_create_done = SD_TRUE; /* Set flag now */
/* Save BRCB buffer size in scl_info so lower functions can access it.*/
scl_info->brcb_bufsize = brcb_bufsize;
ret = SD_SUCCESS; /* default ret val: returned if LD linked list empty.*/
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ld = (SCL_LD *) list_find_last ((DBL_LNK *) scl_info->ldHead);
scl_ld != NULL;
scl_ld = (SCL_LD *) list_find_prev ((DBL_LNK *) scl_info->ldHead, (DBL_LNK *) scl_ld))
{
ret = scl2_ld_create_part1 (vmd_ctrl, scl_info, scl_ld);
if (ret)
{
SXLOG_ERR1 ("scl2_ld_create_part1 for '%s' FAILED", scl_ld->domName);
break; /* if one fails, stop processing */
}
else
{
SXLOG_FLOW1 ("scl2_ld_create_part1 for '%s' SUCCESSFUL", scl_ld->domName);
}
}
/* NOTE: linked list is in reverse order from data in SCL file, */
/* so get off list in reverse order. */
for (scl_ld = (SCL_LD *) list_find_last ((DBL_LNK *) scl_info->ldHead);
scl_ld != NULL;
scl_ld = (SCL_LD *) list_find_prev ((DBL_LNK *) scl_info->ldHead, (DBL_LNK *) scl_ld))
{
ret = scl2_ld_create_part2 (vmd_ctrl, scl_info, scl_ld, reportScanRate, is_client);
if (ret)
{
SXLOG_ERR1 ("scl2_ld_create_part2 for '%s' FAILED", scl_ld->domName);
if (!scl_debug_mode)
break; /* if one fails, stop processing */
++scl_debug_mode_error_count;
}
else
{
SXLOG_FLOW1 ("scl2_ld_create_part2 for '%s' SUCCESSFUL", scl_ld->domName);
}
}
/* Create "LastApplError" variable (required if "Control with */
/* enhanced security" supported). */
if (ret == SD_SUCCESS)
ret = mvl61850_ctl_lastapplerror_create ();
/* The reserved_1 member of every RUNTIME_CTRL is must now be freed. */
reserved_free_all (vmd_ctrl);
return (ret);
}
/************************************************************************/
/* scl_gse_find */
/* Find addressing info for this GCB in this LD. */
/************************************************************************/
SCL_GSE *scl_gse_find (SCL_INFO *scl_info, SCL_LD *scl_ld, SCL_GCB *scl_gcb)
{
SCL_SUBNET *scl_subnet;
SCL_CAP *scl_cap;
SCL_GSE *scl_gse;
for (scl_subnet = (SCL_SUBNET *) list_find_last ((DBL_LNK *) scl_info->subnetHead);
scl_subnet != NULL;
scl_subnet = (SCL_SUBNET *) list_find_prev ((DBL_LNK *) scl_info->subnetHead, (DBL_LNK *) scl_subnet))
{
for (scl_cap = (SCL_CAP *) list_find_last ((DBL_LNK *) scl_subnet->capHead);
scl_cap != NULL;
scl_cap = (SCL_CAP *) list_find_prev ((DBL_LNK *) scl_subnet->capHead, (DBL_LNK *) scl_cap))
{
if (strcmp (scl_info->iedName, scl_cap->iedName) == 0)
{ /* found matching iedName */
for (scl_gse = (SCL_GSE *) list_find_last ((DBL_LNK *) scl_cap->gseHead);
scl_gse != NULL;
scl_gse = (SCL_GSE *) list_find_prev ((DBL_LNK *) scl_cap->gseHead, (DBL_LNK *) scl_gse))
{
if (strcmp (scl_ld->inst, scl_gse->ldInst) == 0 &&
strcmp (scl_gcb->name, scl_gse->cbName) == 0)
{ /* Found it. Too many loops to break out of, so just return.*/
return (scl_gse);
}
} /* end scl_gse loop */
}
} /* end scl_cap loop */
} /* end scl_subnet loop */
return (NULL); /* Not found */
}
Reference in New Issue Copy Permalink