I sent out a fix for osaf_secutil.h as part of ticket [#777]. regards, Anders Widell
On 12/10/2015 08:37 AM, Vu Minh Nguyen wrote: > Hi Lennart, > > osaf_secutil.h is a common header file, it is out of OpenSAF LOG scope. So I > leave the fix to other responsible person. > I have noticed this error and wrote notes when sending email out for review. > > Also, I would like to update the patch so that it can apply successfully on > latest changeset. > > Regards, Vu. > > >> -----Original Message----- >> From: Lennart Lund [mailto:lennart.l...@ericsson.com] >> Sent: Wednesday, December 09, 2015 10:19 PM >> To: Vu Minh Nguyen; mathi.naic...@oracle.com; Anders Widell >> Cc: opensaf-devel@lists.sourceforge.net >> Subject: RE: [PATCH 1 of 1] log: switching to use the C++ compiler [#1624] >> >> Hi Vu, >> >> Some (minor) comments: >> >> The osaf_secutil.h needs the following for the _GNU_SOURCE define >> #ifndef _GNU_SOURCE >> #define _GNU_SOURCE >> #endif >> >> The #1527 patch is now pushed. >> There are changes in this patch that that change things that's also changed > in >> the #1527 patch. This gives merge conflicts. >> This patch cannot be pushed and the original #1527 patch shall/can not be >> used. >> >> Thanks >> Lennart >> >>> -----Original Message----- >>> From: Vu Minh Nguyen [mailto:vu.m.ngu...@dektech.com.au] >>> Sent: den 8 december 2015 13:33 >>> To: mathi.naic...@oracle.com; Lennart Lund; Anders Widell >>> Cc: opensaf-devel@lists.sourceforge.net >>> Subject: [PATCH 1 of 1] log: switching to use the C++ compiler [#1624] >>> >>> osaf/services/saf/logsv/lgs/Makefile.am | 34 ++++--- >>> osaf/services/saf/logsv/lgs/lgs.h | 10 ++- >>> osaf/services/saf/logsv/lgs/lgs_amf.c | 4 +- >>> osaf/services/saf/logsv/lgs/lgs_cb.h | 8 + >>> osaf/services/saf/logsv/lgs/lgs_config.c | 113 > ++++++++++++++------------ >>> osaf/services/saf/logsv/lgs/lgs_config.h | 4 +- >>> osaf/services/saf/logsv/lgs/lgs_evt.c | 17 ++- >>> osaf/services/saf/logsv/lgs/lgs_evt.h | 9 ++ >>> osaf/services/saf/logsv/lgs/lgs_file.c | 45 ++++++---- >>> osaf/services/saf/logsv/lgs/lgs_filehdl.c | 22 +++-- >>> osaf/services/saf/logsv/lgs/lgs_fmt.c | 26 +++-- >>> osaf/services/saf/logsv/lgs/lgs_fmt.h | 8 + >>> osaf/services/saf/logsv/lgs/lgs_imm.c | 118 > ++++++++++++++------------- >>> osaf/services/saf/logsv/lgs/lgs_main.c | 13 +- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv.c | 123 > ++++++++++++++------------ >>> -- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv.h | 2 +- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.c | 28 +++--- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.h | 6 +- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.c | 34 ++++---- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.c | 26 +++--- >>> osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.c | 26 +++--- >>> osaf/services/saf/logsv/lgs/lgs_mds.c | 40 +++++---- >>> osaf/services/saf/logsv/lgs/lgs_stream.c | 64 +++++++------- >>> osaf/services/saf/logsv/lgs/lgs_stream.h | 8 + >>> osaf/services/saf/logsv/lgs/lgs_util.c | 36 ++++--- >>> osaf/services/saf/logsv/lgs/lgs_util.h | 9 ++ >>> 26 files changed, 467 insertions(+), 366 deletions(-) >>> >>> >>> Fix error messages when using C++ compiler >>> >>> diff --git a/osaf/services/saf/logsv/lgs/Makefile.am >>> b/osaf/services/saf/logsv/lgs/Makefile.am >>> --- a/osaf/services/saf/logsv/lgs/Makefile.am >>> +++ b/osaf/services/saf/logsv/lgs/Makefile.am >>> @@ -40,28 +40,30 @@ noinst_HEADERS = \ >>> osaf_execbindir = $(pkglibdir) >>> osaf_execbin_PROGRAMS = osaflogd >>> >>> +osaflogd_CXXFLAGS = $(AM_CXXFLAGS) >>> + >>> osaflogd_CPPFLAGS = \ >>> $(AM_CPPFLAGS) \ >>> -I$(top_srcdir)/osaf/libs/common/logsv/include \ >>> -I$(top_srcdir)/osaf/libs/common/immsv/include >>> >>> osaflogd_SOURCES = \ >>> - lgs_amf.c \ >>> - lgs_evt.c \ >>> - lgs_fmt.c \ >>> - lgs_imm.c \ >>> - lgs_main.c \ >>> - lgs_mbcsv.c \ >>> - lgs_mbcsv_v1.c \ >>> - lgs_mbcsv_v2.c \ >>> - lgs_mds.c \ >>> - lgs_stream.c \ >>> - lgs_util.c \ >>> - lgs_file.c \ >>> - lgs_filehdl.c \ >>> - lgs_mbcsv_v3.c \ >>> - lgs_config.c \ >>> - lgs_mbcsv_v5.c >>> + lgs_amf.cc \ >>> + lgs_evt.cc \ >>> + lgs_fmt.cc \ >>> + lgs_imm.cc \ >>> + lgs_main.cc \ >>> + lgs_mbcsv.cc \ >>> + lgs_config.cc \ >>> + lgs_mbcsv_v1.cc \ >>> + lgs_mbcsv_v2.cc \ >>> + lgs_mds.cc \ >>> + lgs_stream.cc \ >>> + lgs_util.cc \ >>> + lgs_file.cc \ >>> + lgs_filehdl.cc \ >>> + lgs_mbcsv_v3.cc \ >>> + lgs_mbcsv_v5.cc >>> >>> osaflogd_LDADD = \ >>> $(top_builddir)/osaf/tools/safimm/src/libimmutil.la \ >>> diff --git a/osaf/services/saf/logsv/lgs/lgs.h >>> b/osaf/services/saf/logsv/lgs/lgs.h >>> --- a/osaf/services/saf/logsv/lgs/lgs.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs.h >>> @@ -49,6 +49,10 @@ >>> >>> #include "lgs_config.h" >>> >>> +#ifdef __cplusplus >>> +extern "C" { >>> +#endif >>> + >>> /* >>> ========================================================== >>> ============== >>> * DEFINITIONS >>> * >>> ========================================================== >>> ============== >>> @@ -97,7 +101,7 @@ extern pthread_mutex_t lgs_OI_init_mutex >>> >>> extern uint32_t lgs_configure_mailbox(void); >>> >>> -extern uint32_t lgs_amf_init(lgs_cb_t *); >>> +extern SaAisErrorT lgs_amf_init(lgs_cb_t *cb); >>> extern uint32_t lgs_mds_init(lgs_cb_t *cb); >>> extern uint32_t lgs_mds_finalize(lgs_cb_t *cb); >>> extern uint32_t lgs_mds_change_role(lgs_cb_t *cb); >>> @@ -117,4 +121,8 @@ extern void lgs_imm_init_OI_handle(SaImm >>> SaSelectionObjectT *immSelectionObject); >>> extern void lgs_imm_impl_set(SaImmOiHandleT immOiHandle); >>> >>> +#ifdef __cplusplus >>> +} >>> +#endif >>> + >>> #endif /* ifndef __LGS_H */ >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_amf.c >>> b/osaf/services/saf/logsv/lgs/lgs_amf.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_amf.c >>> rename to osaf/services/saf/logsv/lgs/lgs_amf.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_amf.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_amf.cc >>> @@ -171,7 +171,7 @@ static SaAisErrorT amf_quiesced_state_ha >>> >>> mds_role = cb->mds_role; >>> cb->mds_role = V_DEST_RL_QUIESCED; >>> - if ((rc = lgs_mds_change_role(cb)) != NCSCC_RC_SUCCESS) { >>> + if (lgs_mds_change_role(cb) != NCSCC_RC_SUCCESS) { >>> LOG_ER("lgs_mds_change_role FAILED"); >>> rc = SA_AIS_ERR_FAILED_OPERATION; >>> cb->mds_role = mds_role; >>> @@ -306,7 +306,7 @@ static void amf_csi_set_callback(SaInvoc >>> } >>> >>> /* Inform MBCSV of HA state change */ >>> - if (NCSCC_RC_SUCCESS != (error = >>> lgs_mbcsv_change_HA_state(lgs_cb))) >>> + if (NCSCC_RC_SUCCESS != >>> lgs_mbcsv_change_HA_state(lgs_cb)) >>> error = >>> SA_AIS_ERR_FAILED_OPERATION; >>> } >>> >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_cb.h >>> b/osaf/services/saf/logsv/lgs/lgs_cb.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_cb.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_cb.h >>> @@ -25,6 +25,10 @@ >>> #include <ncs_edu_pub.h> >>> #include "lgs_stream.h" >>> >>> +#ifdef __cplusplus >>> +extern "C" { >>> +#endif >>> + >>> /* Default HA state assigned locally during lgs initialization */ >>> #define LGS_HA_INIT_STATE 0 >>> >>> @@ -92,4 +96,8 @@ extern uint32_t lgs_cb_init(lgs_cb_t *); >>> extern void lgs_process_mbx(SYSF_MBX *mbx); >>> extern uint32_t lgs_stream_add(lgs_cb_t *cb, log_stream_t *stream); >>> >>> +#ifdef __cplusplus >>> +} >>> #endif >>> + >>> +#endif >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_config.c >>> b/osaf/services/saf/logsv/lgs/lgs_config.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_config.c >>> rename to osaf/services/saf/logsv/lgs/lgs_config.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_config.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_config.cc >>> @@ -15,7 +15,9 @@ >>> * >>> */ >>> >>> +#ifndef _GNU_SOURCE >>> #define _GNU_SOURCE >>> +#endif >>> #include "lgs_config.h" >>> #include <stdio.h> >>> #include <stdlib.h> >>> @@ -124,47 +126,9 @@ static struct { >>> SaUint32T logMaxApplicationStreams; >>> SaUint32T logFileIoTimeout; >>> SaUint32T logFileSysConfig; >>> -} lgs_conf_def = { >>> - .logRootDirectory = PKGLOGDIR, >>> - .logDataGroupname = "", >>> - .logStreamFileFormat = DEFAULT_APP_SYS_FORMAT_EXP, >>> - .logStreamSystemHighLimit = 0, >>> - .logStreamSystemLowLimit = 0, >>> - .logStreamAppHighLimit = 0, >>> - .logStreamAppLowLimit = 0, >>> - .logMaxLogrecsize = 1024, >>> - .logMaxApplicationStreams = 64, >>> - .logFileIoTimeout = 500, >>> - .logFileSysConfig = 1, >>> -}; >>> +} lgs_conf_def; >>> >>> -static lgs_conf_t lgs_conf = { >>> - /* >>> - * For the following flags, LGS_CNF_DEF means that no >>> external >>> - * configuration exists and the corresponding attributes hard- >>> coded >>> - * default value is used.Is set to false if configuration is found >>> in >>> - * IMM object or environment variable. >>> - * See function lgs_logconf_get() for more info. >>> - */ >>> - .OpenSafLogConfig_object_exist = false, >>> - >>> - .logRootDirectory_cnfflag = LGS_CNF_DEF, >>> - .logStreamSystemHighLimit_cnfflag = LGS_CNF_DEF, >>> - .logStreamSystemLowLimit_cnfflag = LGS_CNF_DEF, >>> - .logStreamAppHighLimit_cnfflag = LGS_CNF_DEF, >>> - .logStreamAppLowLimit_cnfflag = LGS_CNF_DEF, >>> - .logDataGroupname_cnfflag = LGS_CNF_DEF, >>> - /* >>> - * The following attributes cannot be configured in the config >>> file >>> - * Will be set to false if the attribute exists in the IMM config >>> object >>> - */ >>> - .logMaxLogrecsize_cnfflag = LGS_CNF_DEF, >>> - .logMaxApplicationStreams_cnfflag = LGS_CNF_DEF, >>> - .logFileIoTimeout_cnfflag = LGS_CNF_DEF, >>> - .logFileSysConfig_cnfflag = LGS_CNF_DEF, >>> - .logStreamFileFormat_cnfflag = LGS_CNF_DEF, >>> -}; >>> - >>> +static lgs_conf_t lgs_conf; >>> >>> >>> /********************************************************** >>> ******************** >>> * Internal functions >>> @@ -177,6 +141,49 @@ static int verify_all_init(void); >>> * Utility functions >>> */ >>> >>> +static void lgs_conf_def_init(void) >>> +{ >>> + lgs_conf_def.logRootDirectory = PKGLOGDIR; >>> + lgs_conf_def.logDataGroupname = ""; >>> + lgs_conf_def.logStreamFileFormat = >>> DEFAULT_APP_SYS_FORMAT_EXP; >>> + lgs_conf_def.logStreamSystemHighLimit = 0; >>> + lgs_conf_def.logStreamSystemLowLimit = 0; >>> + lgs_conf_def.logStreamAppHighLimit = 0; >>> + lgs_conf_def.logStreamAppLowLimit = 0; >>> + lgs_conf_def.logMaxLogrecsize = 1024; >>> + lgs_conf_def.logMaxApplicationStreams = 64; >>> + lgs_conf_def.logFileIoTimeout = 500; >>> + lgs_conf_def.logFileSysConfig = 1; >>> +} >>> + >>> +// Initialize lgs_conf global variable >>> +static void lgs_conf_init(void) >>> +{ >>> + /* >>> + * For the following flags, LGS_CNF_DEF means that no >>> external >>> + * configuration exists and the corresponding attributes hard- >>> coded >>> + * default value is used.Is set to false if configuration is found >>> in >>> + * IMM object or environment variable. >>> + * See function lgs_logconf_get() for more info. >>> + */ >>> + lgs_conf.OpenSafLogConfig_object_exist = false; >>> + lgs_conf.logRootDirectory_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logStreamSystemHighLimit_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logStreamSystemLowLimit_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logStreamAppHighLimit_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logStreamAppLowLimit_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logDataGroupname_cnfflag = LGS_CNF_DEF; >>> + /* >>> + * The following attributes cannot be configured in the config >>> file >>> + * Will be set to false if the attribute exists in the IMM config >>> object >>> + */ >>> + lgs_conf.logMaxLogrecsize_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logMaxApplicationStreams_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logFileIoTimeout_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logFileSysConfig_cnfflag = LGS_CNF_DEF; >>> + lgs_conf.logStreamFileFormat_cnfflag = LGS_CNF_DEF; >>> +}; >>> + >>> /** >>> * Set default values for all parameters >>> */ >>> @@ -219,7 +226,7 @@ static void init_default(void) >>> * NOTE! Must be initiated before first call > {NULL, 0} >>> * >>> */ >>> -void lgs_cfgupd_list_create(char *name_str, char *value_str, >>> +void lgs_cfgupd_list_create(const char *name_str, char *value_str, >>> lgs_config_chg_t *config_data) >>> { >>> char *tmp_char_ptr = NULL; >>> @@ -230,7 +237,7 @@ void lgs_cfgupd_list_create(char *name_s >>> TRACE_ENTER2("name_str '%s', value_str \"%s\"", name_str, >>> value_str); >>> >>> cfg_size = strlen(name_str) + strlen(value_str) + 2; >>> - cfg_param_str = malloc(cfg_size); >>> + cfg_param_str = (char *) malloc(cfg_size); >>> if (cfg_param_str == NULL) { >>> TRACE("%s: malloc Fail Aborted", >>> __FUNCTION__); >>> osaf_abort(0); >>> @@ -363,7 +370,7 @@ int lgs_cfg_update(const lgs_config_chg_ >>> * since the information is changed by the strok() function. The >>> * original config_data must not be changed. >>> */ >>> - allocmem_ptr = calloc(1,config_data->ckpt_buffer_size); >>> + allocmem_ptr = (char *) calloc(1,config_data- >>>> ckpt_buffer_size); >>> param_ptr = allocmem_ptr; >>> (void) memcpy(param_ptr, config_data->ckpt_buffer_ptr, >>> config_data->ckpt_buffer_size); >>> >>> @@ -381,7 +388,7 @@ int lgs_cfg_update(const lgs_config_chg_ >>> value_str = strtok_r(NULL, "=", &saveptr); >>> if (value_str == NULL) { >>> TRACE("%s: value_str is NULL", >>> __FUNCTION__); >>> - value_str = ""; >>> + value_str = const_cast<char *> >>> (""); >>> } >>> >>> /* Update config data */ >>> @@ -1135,7 +1142,11 @@ static void read_log_config_environ_var_ >>> void lgs_cfg_init(SaImmOiHandleT immOiHandle, SaAmfHAStateT ha_state) >>> { >>> TRACE_ENTER2("immOiHandle = %lld", immOiHandle); >>> - >>> + >>> + /* Initialize the global variables */ >>> + lgs_conf_def_init(); >>> + lgs_conf_init(); >>> + >>> /* Initiate the default values for all parameters >>> */ >>> init_default(); >>> @@ -1367,7 +1378,7 @@ void conf_runtime_obj_create(SaImmOiHand >>> char *nameptr = namestr; >>> void *valarr[] = { &nameptr }; >>> const SaImmAttrValuesT_2 attr_logConfig = { >>> - .attrName = "logConfig", >>> + .attrName = (SaImmAttrNameT) "logConfig", >>> .attrValueType = SA_IMM_ATTR_SASTRINGT, >>> .attrValuesNumber = 1, >>> .attrValues = valarr >>> @@ -1384,7 +1395,7 @@ void conf_runtime_obj_create(SaImmOiHand >>> parent_name_p = &parent_name; >>> >>> rc = saImmOiRtObjectCreate_2(immOiHandle, >>> - "OpenSafLogCurrentConfig", >>> + (SaImmClassNameT) >>> "OpenSafLogCurrentConfig", >>> parent_name_p, >>> attrValues); >>> >>> @@ -1510,13 +1521,13 @@ static char *cnfflag_str(lgs_conf_flg_t >>> { >>> switch (cnfflag) { >>> case LGS_CNF_OBJ: >>> - return "Config object"; >>> + return const_cast<char *> ("Config object"); >>> case LGS_CNF_ENV: >>> - return "Environment variable"; >>> + return const_cast<char *> ("Environment >>> variable"); >>> case LGS_CNF_DEF: >>> - return "Default value"; >>> + return const_cast<char *> ("Default value"); >>> default: >>> - return "Bad input"; >>> + return const_cast <char *> ("Bad input"); >>> } >>> } >>> >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_config.h >>> b/osaf/services/saf/logsv/lgs/lgs_config.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_config.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_config.h >>> @@ -23,7 +23,7 @@ >>> #include "saImmOi.h" >>> #include "saAmf.h" >>> >>> -#ifdef __cplusplus >>> +#ifdef __cplusplus >>> extern "C" { >>> #endif >>> >>> @@ -74,7 +74,7 @@ typedef struct config_chkpt { >>> void lgs_cfg_init(SaImmOiHandleT immOiHandle, SaAmfHAStateT ha_state); >>> const void *lgs_cfg_get(lgs_logconfGet_t param); >>> bool lgs_path_is_writeable_dir_h(const char *pathname); >>> -void lgs_cfgupd_list_create(char *name_str, char *value_str, >>> +void lgs_cfgupd_list_create(const char *name_str, char *value_str, >>> lgs_config_chg_t *config_data); >>> char *lgs_cfgupd_list_read(char **name_str, char **value_str, >>> char *next_param_ptr, lgs_config_chg_t *cfgupd_ptr); >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_evt.c >>> b/osaf/services/saf/logsv/lgs/lgs_evt.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_evt.c >>> rename to osaf/services/saf/logsv/lgs/lgs_evt.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_evt.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_evt.cc >>> @@ -104,7 +104,9 @@ log_client_t *lgs_client_new(MDS_DEST md >>> lgs_cb->last_client_id++; >>> } >>> >>> - if (NULL == (client = calloc(1, sizeof(log_client_t)))) { >>> + client = (log_client_t *) calloc(1, sizeof(log_client_t)); >>> + >>> + if (NULL == client) { >>> LOG_WA("lgs_client_new calloc FAILED"); >>> goto done; >>> } >>> @@ -210,7 +212,8 @@ int lgs_client_stream_add(uint32_t clien >>> goto err_exit; >>> } >>> >>> - if ((stream = malloc(sizeof(lgs_stream_list_t))) == NULL) { >>> + stream = (lgs_stream_list_t *) >>> malloc(sizeof(lgs_stream_list_t)); >>> + if (stream == NULL) { >>> LOG_WA("malloc FAILED"); >>> rs = -1; >>> goto err_exit; >>> @@ -567,7 +570,6 @@ uint32_t lgs_cb_init(lgs_cb_t *lgs_cb) >>> reg_param.key_size = sizeof(uint32_t); >>> >>> /* Assign Initial HA state */ >>> - lgs_cb->ha_state = LGS_HA_INIT_STATE; >>> lgs_cb->csi_assigned = false; >>> >>> /* Assign Version. Currently, hardcoded, This will change later >>> */ >>> @@ -782,6 +784,7 @@ static SaAisErrorT create_new_app_stream >>> log_stream_t *stream; >>> SaBoolT twelveHourModeFlag; >>> uint32_t len = 0; >>> + SaUint32T logMaxLogrecsize_conf = 0; >>> >>> TRACE_ENTER(); >>> >>> @@ -846,7 +849,7 @@ static SaAisErrorT create_new_app_stream >>> } >>> >>> /* Verify that the fixedLogRecordSize is in valid range */ >>> - SaUint32T logMaxLogrecsize_conf = *(SaUint32T *) >>> lgs_cfg_get(LGS_IMM_LOG_MAX_LOGRECSIZE); >>> + logMaxLogrecsize_conf = *(SaUint32T *) >>> lgs_cfg_get(LGS_IMM_LOG_MAX_LOGRECSIZE); >>> if ((open_sync_param->maxLogRecordSize != 0) && >>> ((open_sync_param->maxLogRecordSize < >>> SA_LOG_MIN_RECORD_SIZE) || >>> (open_sync_param->maxLogRecordSize > >>> logMaxLogrecsize_conf))) { >>> @@ -1151,6 +1154,7 @@ static uint32_t proc_write_log_async_msg >>> lgsv_ckpt_msg_v1_t ckpt_v1; >>> lgsv_ckpt_msg_v2_t ckpt_v2; >>> void *ckpt_ptr; >>> + uint32_t max_logrecsize = 0; >>> >>> TRACE_ENTER2("client_id %u, stream ID %u", param- >>>> client_id, param->lstr_id); >>> @@ -1177,11 +1181,10 @@ static uint32_t proc_write_log_async_msg >>> ** To avoid truncation we support fixedLogRecordSize==0. We >>> then allocate an >>> ** a buffer with an implementation defined size instead. We >>> also do not pad in this mode. >>> */ >>> - uint32_t max_logrecsize = *(uint32_t *) lgs_cfg_get( >>> - LGS_IMM_LOG_MAX_LOGRECSIZE); >>> + max_logrecsize = *(uint32_t *) >>> lgs_cfg_get(LGS_IMM_LOG_MAX_LOGRECSIZE); >>> >>> buf_size = stream->fixedLogRecordSize == 0 ? max_logrecsize >>> : stream->fixedLogRecordSize; >>> - logOutputString = calloc(1, buf_size+1); /* Make room for a '\0' >>> termination */ >>> + logOutputString = (char *) calloc(1, buf_size + 1); /* Make >>> room for a '\0' termination */ >>> if (logOutputString == NULL) { >>> LOG_ER("Could not allocate %d bytes", stream- >>>> fixedLogRecordSize + 1); >>> error = SA_AIS_ERR_NO_MEMORY; >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_evt.h >>> b/osaf/services/saf/logsv/lgs/lgs_evt.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_evt.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_evt.h >>> @@ -24,6 +24,10 @@ >>> >>> #include "lgs_cb.h" >>> >>> +#ifdef __cplusplus >>> +extern "C" { >>> +#endif >>> + >>> typedef enum lgsv_lgs_evt_type { >>> LGSV_LGS_LGSV_MSG = 0, >>> LGSV_LGS_EVT_LGA_UP = 1, >>> @@ -77,4 +81,9 @@ extern uint32_t lgs_remove_lga_down_rec( >>> extern void lgs_send_write_log_ack(uint32_t client_id, SaInvocationT >>> invocation, SaAisErrorT error, MDS_DEST mds_dest); >>> extern void lgs_free_write_log(const lgsv_write_log_async_req_t *param); >>> >>> +#ifdef __cplusplus >>> +} >>> +#endif >>> + >>> + >>> #endif /*!LGS_EVT_H */ >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_file.c >>> b/osaf/services/saf/logsv/lgs/lgs_file.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_file.c >>> rename to osaf/services/saf/logsv/lgs/lgs_file.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_file.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_file.cc >>> @@ -55,15 +55,7 @@ struct file_communicate { >>> /* Used for synchronizing and transfer of data ownership between main >>> thread >>> * and file thread. >>> */ >>> -static struct file_communicate lgs_com_data = { >>> - .answer_f = false, >>> - .request_f = false, >>> - .timeout_f = false, >>> - .request_code = LGSF_NOREQ, >>> - .return_code = LGSF_NORETC, >>> - .indata_ptr = NULL, >>> - .outdata_ptr = NULL >>> -}; >>> +static struct file_communicate lgs_com_data; >>> >>> static pthread_t file_thread_id; >>> >>> @@ -73,6 +65,18 @@ static pthread_t file_thread_id; >>> >>> static int start_file_thread(void); >>> >>> +static void file_communicate_init(void) >>> +{ >>> + lgs_com_data.answer_f = false; >>> + lgs_com_data.request_f = false; >>> + lgs_com_data.timeout_f = false; >>> + lgs_com_data.request_code = LGSF_NOREQ; >>> + lgs_com_data.return_code = LGSF_NORETC; >>> + lgs_com_data.indata_ptr = NULL; >>> + lgs_com_data.outdata_ptr = NULL; >>> + lgs_com_data.outdata_size = 0; >>> +} >>> + >>> /** >>> * Creates absolute time to use with pthread_cond_timedwait. >>> * >>> @@ -216,6 +220,9 @@ static int start_file_thread(void) >>> >>> TRACE_ENTER(); >>> >>> + // Initialize the global data >>> + file_communicate_init(); >>> + >>> /* Init thread handling */ >>> rc = pthread_mutex_init(&lgs_ftcom_mutex, NULL); >>> if (rc != 0) { >>> @@ -346,12 +353,12 @@ lgsf_retcode_t log_file_api(lgsf_apipar_ >>> int rc = 0; >>> struct timespec timeout_time; >>> int fd = 0; >>> - >>> /* If this flag is true always return LGSF_BUSY */ >>> bool busy_close_flag = false; >>> - >>> + uint32_t max_waittime_ms = 0; >>> + >>> osaf_mutex_lock_ordie(&lgs_ftcom_mutex); /* LOCK */ >>> - >>> + >>> /* If busy_f is true the file thread is hanging. In this case don't >>> send >>> * a request. >>> */ >>> @@ -420,7 +427,7 @@ lgsf_retcode_t log_file_api(lgsf_apipar_ >>> if (rc != 0) osaf_abort(rc); >>> >>> /* Wait for an answer */ >>> - uint32_t max_waittime_ms = *(SaUint32T *) >>> lgs_cfg_get(LGS_IMM_FILEHDL_TIMEOUT); >>> + max_waittime_ms = *(SaUint32T *) >>> lgs_cfg_get(LGS_IMM_FILEHDL_TIMEOUT); >>> get_timeout_time(&timeout_time, max_waittime_ms); >>> >>> while (lgs_com_data.answer_f == false) { >>> @@ -469,19 +476,19 @@ api_exit: >>> char *lgsf_retcode_str(lgsf_retcode_t rc) >>> { >>> static char errstr[256]; >>> - >>> + >>> switch (rc) { >>> case LGSF_SUCESS: >>> - return "LGSF_SUCESS"; >>> + return const_cast<char *> ("LGSF_SUCESS"); >>> case LGSF_BUSY: >>> - return "LGSF_BUSY"; >>> + return const_cast<char *> ("LGSF_BUSY"); >>> case LGSF_TIMEOUT: >>> - return "LGSF_TIMEOUT"; >>> + return const_cast<char *> ("LGSF_TIMEOUT"); >>> case LGSF_FAIL: >>> - return "LGSF_FAIL"; >>> + return const_cast<char *> ("LGSF_FAIL"); >>> default: >>> sprintf(errstr,"Unknown lgsf_retcode %d",rc); >>> return errstr; >>> } >>> - return "dummy"; >>> + return const_cast<char *> ("dummy"); >>> } >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_filehdl.c >>> b/osaf/services/saf/logsv/lgs/lgs_filehdl.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_filehdl.c >>> rename to osaf/services/saf/logsv/lgs/lgs_filehdl.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_filehdl.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_filehdl.cc >>> @@ -163,8 +163,8 @@ int create_config_file_hdl(void *indata, >>> { >>> int rc = 0; >>> FILE *filp; >>> - ccfh_t *params_in = (ccfh_t *) indata; >>> - char *logFileFormat = (char *) (indata + sizeof(ccfh_t)); >>> + ccfh_t *params_in = static_cast<ccfh_t *>(indata); >>> + char *logFileFormat = static_cast<char *>(indata) + >>> sizeof(ccfh_t); >>> char *file_path = (logFileFormat + params_in- >>>> logFileFormat_size); >>> TRACE_ENTER(); >>> @@ -244,7 +244,8 @@ done: >>> */ >>> int write_log_record_hdl(void *indata, void *outdata, size_t > max_outsize, >>> bool *timeout_f) >>> { >>> - int rc, bytes_written = 0; >>> + int rc = 0; >>> + uint32_t bytes_written = 0; >>> off_t file_length = 0; >>> wlrh_t *params_in = (wlrh_t *) indata; >>> /* Get log record pointed by lgs_rec pointer */ >>> @@ -356,7 +357,9 @@ int make_log_dir_hdl(void *indata, void >>> char *epath_p; >>> struct stat statbuf; >>> int n; >>> - >>> + int path_len = 0; >>> + char *rootpp = NULL; >>> + >>> TRACE_ENTER(); >>> >>> TRACE("rootpath \"%s\"",rootpath); >>> @@ -375,7 +378,7 @@ int make_log_dir_hdl(void *indata, void >>> rootpath = PKGLOGDIR; >>> #endif >>> n = snprintf(out_path, max_outsize, "%s", >>> rootpath); >>> - if (n >= max_outsize) { >>> + if ((uint32_t) n >= max_outsize) { >>> LOG_WA("Invalid root path > >>> max_outsize"); >>> mldh_rc = -1; >>> goto done; >>> @@ -395,7 +398,8 @@ int make_log_dir_hdl(void *indata, void >>> mldh_rc = -1; >>> goto done; >>> } >>> - char *rootpp = mpath; >>> + >>> + rootpp = mpath; >>> while (*rootpp == '/') rootpp++; /* Remove preceding '/' */ >>> while (mpath[strlen(mpath)-1] == '/') { /* Remove trailing '/' if >>> needed */ >>> mpath[strlen(mpath)-1] = '\0'; >>> @@ -419,7 +423,6 @@ int make_log_dir_hdl(void *indata, void >>> TRACE("%s - Path to create >>> \"%s\"",__FUNCTION__,dir_to_make); >>> >>> /* Create the path */ >>> - int path_len = 0; >>> spath_p = epath_p = dir_to_make; >>> while ((epath_p = strchr(epath_p, '/')) != NULL) { >>> if (epath_p == spath_p) { >>> @@ -692,7 +695,7 @@ int get_number_of_log_files_hdl(void *in >>> TRACE_1("oldest: %s", namelist[old_ind]- >>>> d_name); >>> n = snprintf(oldest_file, max_outsize, "%s/%s", >>> path, >>> namelist[old_ind]->d_name); >>> - if (n >= max_outsize) { >>> + if ((uint32_t) n >= max_outsize) { >>> LOG_WA("oldest_file > >>> max_outsize"); >>> rc = -1; >>> goto done_free; >>> @@ -729,6 +732,7 @@ int own_log_files_by_group_hdl(void *ind >>> int n, files, i; >>> olfbgh_t *params_in; >>> int rc = 0; >>> + gid_t gid = 0; >>> >>> TRACE_ENTER(); >>> >>> @@ -762,7 +766,7 @@ int own_log_files_by_group_hdl(void *ind >>> goto done_exit; >>> } >>> >>> - gid_t gid = lgs_get_data_gid(params_in->groupname); >>> + gid = lgs_get_data_gid(params_in->groupname); >>> >>> while (n--) { >>> char file[PATH_MAX]; >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_fmt.c >>> b/osaf/services/saf/logsv/lgs/lgs_fmt.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_fmt.c >>> rename to osaf/services/saf/logsv/lgs/lgs_fmt.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_fmt.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_fmt.cc >>> @@ -531,11 +531,13 @@ static int extractCommonField(char *dest >>> const struct tm >>> *timeStampData, const SaLogRecordT *logRecord, SaUint16T rec_size) >>> { >>> SaInt32T fieldSize; >>> - size_t stringSize; >>> + size_t stringSize, i; >>> SaUint16T fieldSizeOffset = 0; >>> int characters = 0; >>> char *hex_string = NULL, *hex_string_ptr = NULL; >>> - int no_ch = 0, i; >>> + int no_ch = 0; >>> + SaTimeT us = 0; >>> + long gmtOffset = 0, uGmtOffset = 0; >>> >>> *fmtExpPtrOffset = DEFAULT_FMT_EXP_PTR_OFFSET; >>> >>> @@ -697,17 +699,17 @@ static int extractCommonField(char *dest >>> case C_TIME_MILLISECOND_LETTER: >>> stringSize = 4 * sizeof(char); >>> /* Extract millisecond from logTimestamp */ >>> - SaTimeT us = logRecord->logTimeStamp / >>> SA_TIME_ONE_MICROSECOND; >>> + us = logRecord->logTimeStamp / >>> SA_TIME_ONE_MICROSECOND; >>> characters = snprintf(dest, dest_size, "%03lld", >>> us % SA_TIME_ONE_MICROSECOND); >>> break; >>> >>> case C_TIME_TIMEZONE_LETTER: >>> stringSize = 6 * sizeof(char); >>> /* Get timezone offset from localtime to UTC >>> time */ >>> - long gmtOffset = (timeStampData->tm_gmtoff / >>> SECOND_PER_HOUR) * 100 + >>> + gmtOffset = (timeStampData->tm_gmtoff / >>> SECOND_PER_HOUR) * 100 + >>> (timeStampData->tm_gmtoff % >>> SECOND_PER_HOUR) / SECOND_PER_MINUTE; >>> >>> - long uGmtOffset = (gmtOffset >= 0) ? >>> (gmtOffset) : (gmtOffset * -1); >>> + uGmtOffset = (gmtOffset >= 0) ? (gmtOffset) : >>> (gmtOffset * -1); >>> characters = snprintf(dest, dest_size, >>> "%c%04ld", gmtOffset >= 0 ? '+' : '-', uGmtOffset); >>> break; >>> >>> @@ -794,7 +796,7 @@ static int extractCommonField(char *dest >>> if (characters == -1) >>> characters = 0; >>> >>> - if (characters > dest_size) >>> + if (characters > (int) dest_size) >>> characters = dest_size; >>> >>> return characters; >>> @@ -820,6 +822,7 @@ static int extractNotificationField(char >>> SaInt32T fieldSize; >>> SaInt32T characters = 0; >>> SaUint16T fieldSizeOffset = 0; >>> + long gmtOffset = 0, uGmtOffset = 0; >>> >>> *fmtExpPtrOffset = DEFAULT_FMT_EXP_PTR_OFFSET; >>> >>> @@ -981,11 +984,10 @@ static int extractNotificationField(char >>> >>> case N_EVENT_TIME_TIMEZONE_LETTER: >>> /* Get time offset from localtime to UTC */ >>> - characters = 6; /* to avoid using {} >>> */ >>> - long gmtOffset = (eventTimeData->tm_gmtoff / >>> SECOND_PER_HOUR) * 100 + >>> + gmtOffset = (eventTimeData->tm_gmtoff / >>> SECOND_PER_HOUR) * 100 + >>> (eventTimeData->tm_gmtoff % >>> SECOND_PER_HOUR) / SECOND_PER_MINUTE; >>> >>> - long uGmtOffset = (gmtOffset >= 0) ? >>> (gmtOffset) : (gmtOffset * -1); >>> + uGmtOffset = (gmtOffset >= 0) ? (gmtOffset) : >>> (gmtOffset * -1); >>> characters = snprintf(dest, dest_size, >>> "%c%04ld", gmtOffset >= 0 ? '+' : '-', uGmtOffset); >>> break; >>> >>> @@ -1049,7 +1051,7 @@ static int extractNotificationField(char >>> if (characters == -1) >>> characters = 0; >>> >>> - if (characters > dest_size) >>> + if (characters > (int) dest_size) >>> characters = dest_size; >>> >>> return characters; >>> @@ -1134,7 +1136,7 @@ static int extractSystemField(char *dest >>> if (characters == -1) >>> characters = 0; >>> >>> - if (characters > dest_size) >>> + if (characters > (int) dest_size) >>> characters = dest_size; >>> >>> return characters; >>> @@ -1240,7 +1242,7 @@ int lgs_format_log_record(SaLogRecordT * >>> struct tm *timeStampData; >>> SaBoolT _twelveHourModeFlag = SA_FALSE; >>> const SaBoolT *twelveHourModeFlag = >>> &_twelveHourModeFlag; >>> - int i = 0; >>> + size_t i = 0; >>> SaUint16T rec_size = dest_size; >>> >>> if (formatExpression == NULL) { >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_fmt.h >>> b/osaf/services/saf/logsv/lgs/lgs_fmt.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_fmt.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_fmt.h >>> @@ -21,6 +21,10 @@ >>> #include <saAis.h> >>> #include <saLog.h> >>> >>> +#ifdef __cplusplus >>> +extern "C" { >>> +#endif >>> + >>> #define TOKEN_START_SYMBOL '@' >>> #define STRING_END_CHARACTER '\0' >>> #define TERMINATION_CHARACTER '\n' >>> @@ -175,4 +179,8 @@ extern SaBoolT lgs_is_valid_format_expre >>> extern int lgs_format_log_record(SaLogRecordT *, const SaStringT, >>> SaUint64T logFileSize, SaUint16T fixedLogRecordSize, >>> size_t dest_size, char *dest, SaUint32T); >>> >>> +#ifdef __cplusplus >>> +} >>> #endif >>> + >>> +#endif >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_imm.c >>> b/osaf/services/saf/logsv/lgs/lgs_imm.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_imm.c >>> rename to osaf/services/saf/logsv/lgs/lgs_imm.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_imm.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_imm.cc >>> @@ -26,7 +26,9 @@ >>> * Examples can be found in file lgs_stream.c, e.g. function > fileopen(...) >>> */ >>> >>> +#ifndef _GNU_SOURCE >>> #define _GNU_SOURCE >>> +#endif >>> #include <poll.h> >>> #include <stdio.h> >>> #include <errno.h> >>> @@ -40,7 +42,6 @@ >>> #include <saImmOm.h> >>> #include <saImmOi.h> >>> >>> -#include "osaf_secutil.h" >>> #include "immutil.h" >>> #include "osaf_time.h" >>> #include "lgs.h" >>> @@ -72,7 +73,7 @@ const unsigned int max_waiting_time_60s >>> const unsigned int max_waiting_time_10s = 10 * 1000; /* 10 secs > */ >>> /* Must be able to index this array using streamType */ >>> -static char *log_file_format[] = { >>> +static const char *log_file_format[] = { >>> DEFAULT_ALM_NOT_FORMAT_EXP, >>> DEFAULT_ALM_NOT_FORMAT_EXP, >>> DEFAULT_APP_SYS_FORMAT_EXP, >>> @@ -82,6 +83,8 @@ static char *log_file_format[] = { >>> static SaVersionT immVersion = { 'A', 2, 11 }; >>> >>> static const SaImmOiImplementerNameT implementerName = >>> (SaImmOiImplementerNameT)"safLogService"; >>> +static const SaImmClassNameT safLogConfig_str = (SaImmClassNameT) >>> "OpenSafLogConfig"; >>> +static const SaImmClassNameT streamConfig_str = (SaImmClassNameT) >>> "SaLogStreamConfig"; >>> >>> extern struct ImmutilWrapperProfile immutilWrapperProfile; >>> >>> @@ -122,18 +125,23 @@ static void report_om_error(SaImmOiHandl >>> { >>> char ao_err_string[256]; >>> SaStringT p_ao_err_string = ao_err_string; >>> + char admop_err[256]; >>> + strcpy(admop_err, (const char *) >>> SA_IMM_PARAM_ADMOP_ERROR); >>> SaImmAdminOperationParamsT_2 ao_err_param = { >>> - SA_IMM_PARAM_ADMOP_ERROR, >>> - SA_IMM_ATTR_SASTRINGT, >>> - &p_ao_err_string }; >>> + admop_err, >>> + SA_IMM_ATTR_SASTRINGT, >>> + &p_ao_err_string >>> + }; >>> const SaImmAdminOperationParamsT_2 *ao_err_params[2] = >>> { >>> - &ao_err_param, >>> - NULL }; >>> - >>> + &ao_err_param, >>> + NULL >>> + }; >>> + >>> va_list ap; >>> va_start(ap, format); >>> (void) vsnprintf(ao_err_string, 256, format, ap); >>> va_end(ap); >>> + >>> TRACE("%s",ao_err_string); >>> (void) saImmOiAdminOperationResult_o2(immOiHandle, >>> invocation, >>> SA_AIS_ERR_INVALID_PARAM, >>> @@ -439,7 +447,7 @@ static void adminOperationCallback(SaImm >>> stream->severityFilter = severityFilter; >>> >>> (void)immutil_update_one_rattr(immOiHandle, >>> (char *)objectName->value, >>> - >>> "saLogStreamSeverityFilter", SA_IMM_ATTR_SAUINT32T, >>> + (SaImmAttrNameT) >>> "saLogStreamSeverityFilter", SA_IMM_ATTR_SAUINT32T, >>> >>> &stream->severityFilter); >>> >>> >>> (void)immutil_saImmOiAdminOperationResult(immOiHandle, >>> invocation, SA_AIS_OK); >>> @@ -929,8 +937,9 @@ static lgs_stream_defval_t *get_SaLogStr >>> >>> TRACE("immutil_saImmOmInitialize fail rc=%d", rc); >>> } >>> if (rc == SA_AIS_OK) { >>> - rc = >>> immutil_saImmOmClassDescriptionGet_2(om_handle, "SaLogStreamConfig", >>> - &cc, >>> &attributes); >>> + rc = >>> immutil_saImmOmClassDescriptionGet_2(om_handle, >>> + >>> (SaImmClassNameT) "SaLogStreamConfig", >>> + &cc, &attributes); >>> } >>> >>> if (rc == SA_AIS_OK) { >>> @@ -1992,7 +2001,7 @@ static void config_ccb_apply_modify(cons >>> root_dir_chg_flag = true; >>> } else if (!strcmp(attribute->attrName, >>> LOG_DATA_GROUPNAME)) { >>> if (value == NULL) { >>> - value_str = ""; >>> + value_str = >>> const_cast<char *> (""); >>> } else { >>> value_str = *((char >>> **)value); >>> } >>> @@ -2002,7 +2011,7 @@ static void config_ccb_apply_modify(cons >>> } else if (!strcmp(attribute->attrName, >>> LOG_STREAM_FILE_FORMAT)) { >>> if (value == NULL) { >>> /* Use built-in file >>> format as default */ >>> - value_str = >>> DEFAULT_APP_SYS_FORMAT_EXP; >>> + value_str = >>> const_cast<char *> (DEFAULT_APP_SYS_FORMAT_EXP); >>> } else { >>> value_str = *((char >>> **)value); >>> } >>> @@ -2168,7 +2177,7 @@ static SaAisErrorT stream_create_and_con >>> (*stream)- >>>> fixedLogRecordSize = *((SaUint32T *) value); >>> TRACE("fixedLogRecordSize: %u", (*stream)- >>>> fixedLogRecordSize); >>> } else if (!strcmp(ccb- >>>> param.create.attrValues[i]->attrName, "saLogStreamLogFullAction")) { >>> - (*stream)- >>>> logFullAction = *((SaUint32T *) value); >>> + (*stream)- >>>> logFullAction = *((SaLogFileFullActionT *) value); >>> TRACE("logFullAction: %u", (*stream)->logFullAction); >>> } else if (!strcmp(ccb- >>>> param.create.attrValues[i]->attrName, >>> "saLogStreamLogFullHaltThreshold")) { >>> (*stream)- >>>> logFullHaltThreshold = *((SaUint32T *) value); >>> @@ -2201,7 +2210,7 @@ static SaAisErrorT stream_create_and_con >>> >>> /* Update creation timestamp */ >>> (void) immutil_update_one_rattr(lgs_cb->immOiHandle, >>> (const char*) objectName.value, >>> - >>> "saLogStreamCreationTimestamp", SA_IMM_ATTR_SATIMET, >>> + (SaImmAttrNameT) >>> "saLogStreamCreationTimestamp", SA_IMM_ATTR_SATIMET, >>> &(*stream)- >>>> creationTimeStamp); >>> done: >>> @@ -2270,7 +2279,7 @@ static void stream_ccb_apply_modify(cons >>> stream->fixedLogRecordSize = >>> fixedLogRecordSize; >>> new_cfg_file_needed = true; >>> } else if (!strcmp(attribute->attrName, >>> "saLogStreamLogFullAction")) { >>> - SaLogFileFullActionT logFullAction >>> = *((SaUint32T *)value); >>> + SaLogFileFullActionT logFullAction >>> = *((SaLogFileFullActionT *)value); >>> stream->logFullAction = >>> logFullAction; >>> new_cfg_file_needed = true; >>> } else if (!strcmp(attribute->attrName, >>> "saLogStreamLogFullHaltThreshold")) { >>> @@ -2299,7 +2308,7 @@ static void stream_ccb_apply_modify(cons >>> >>> osaf_clock_gettime(CLOCK_REALTIME, &curtime_tspec); >>> time_t cur_time = curtime_tspec.tv_sec; >>> - const char *root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *root_path = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> if (new_cfg_file_needed) { >>> int rc; >>> if ((rc = >>> log_stream_config_change(LGS_STREAM_CREATE_FILES, >>> @@ -2531,16 +2540,16 @@ static SaAisErrorT stream_create_and_con >>> int i = 0; >>> log_stream_t *stream; >>> char *attribute_names[] = { >>> - "saLogStreamFileName", >>> - "saLogStreamPathName", >>> - "saLogStreamMaxLogFileSize", >>> - "saLogStreamFixedLogRecordSize", >>> - "saLogStreamLogFullAction", >>> - "saLogStreamLogFullHaltThreshold", >>> - "saLogStreamMaxFilesRotated", >>> - "saLogStreamLogFileFormat", >>> - "saLogStreamSeverityFilter", >>> - "saLogStreamCreationTimestamp", >>> + const_cast<char *> ("saLogStreamFileName"), >>> + const_cast<char *> ("saLogStreamPathName"), >>> + const_cast<char *> >>> ("saLogStreamMaxLogFileSize"), >>> + const_cast<char *> >>> ("saLogStreamFixedLogRecordSize"), >>> + const_cast<char *> >>> ("saLogStreamLogFullAction"), >>> + const_cast<char *> >>> ("saLogStreamLogFullHaltThreshold"), >>> + const_cast<char *> >>> ("saLogStreamMaxFilesRotated"), >>> + const_cast<char *> >>> ("saLogStreamLogFileFormat"), >>> + const_cast<char *> >>> ("saLogStreamSeverityFilter"), >>> + const_cast<char *> >>> ("saLogStreamCreationTimestamp"), >>> NULL >>> }; >>> >>> @@ -2594,7 +2603,7 @@ static SaAisErrorT stream_create_and_con >>> stream->fixedLogRecordSize = >>> *((SaUint32T *)value); >>> TRACE("fixedLogRecordSize: %u", >>> stream->fixedLogRecordSize); >>> } else if (!strcmp(attribute->attrName, >>> "saLogStreamLogFullAction")) { >>> - stream->logFullAction = >>> *((SaUint32T *)value); >>> + stream->logFullAction = >>> *((SaLogFileFullActionT *)value); >>> TRACE("logFullAction: %u", >>> stream->logFullAction); >>> } else if (!strcmp(attribute->attrName, >>> "saLogStreamLogFullHaltThreshold")) { >>> stream->logFullHaltThreshold = >>> *((SaUint32T *)value); >>> @@ -2667,10 +2676,10 @@ SaAisErrorT lgs_imm_create_configStream( >>> int streamId = 0; >>> int errorsAreFatal; >>> SaNameT objectName; >>> - SaNameT root_name = { >>> - .value = "safApp=safLogService", >>> - .length = sizeof("safApp=safLogService") >>> - }; >>> + SaNameT root_name; >>> + >>> + strcpy((char *) root_name.value, "safApp=safLogService"); >>> + root_name.length = sizeof("safApp=safLogService"); >>> >>> >>> TRACE_ENTER(); >>> @@ -2679,7 +2688,7 @@ SaAisErrorT lgs_imm_create_configStream( >>> (void)immutil_saImmOmAccessorInitialize(omHandle, >>> &accessorHandle); >>> >>> /* Search for all objects of class "SaLogStreamConfig" */ >>> - objectSearch.searchOneAttr.attrName = "safLgStrCfg"; >>> + objectSearch.searchOneAttr.attrName = (SaImmAttrNameT) >>> "safLgStrCfg"; >>> objectSearch.searchOneAttr.attrValueType = >>> SA_IMM_ATTR_SASTRINGT; >>> objectSearch.searchOneAttr.attrValue = NULL; >>> >>> @@ -2714,8 +2723,8 @@ SaAisErrorT lgs_imm_create_configStream( >>> stream = log_stream_getnext_by_name(NULL); >>> while (stream != NULL) { >>> (void)immutil_update_one_rattr(cb- >>>> immOiHandle, stream->name, >>> - >>> "saLogStreamCreationTimestamp", SA_IMM_ATTR_SATIMET, >>> - >>> &stream->creationTimeStamp); >>> + >>> (SaImmAttrNameT) "saLogStreamCreationTimestamp", >>> SA_IMM_ATTR_SATIMET, >>> + &stream- >>>> creationTimeStamp); >>> log_stream_open_fileinit(stream); >>> stream = >>> log_stream_getnext_by_name(stream->name); >>> @@ -2754,12 +2763,11 @@ void lgs_imm_init_OI_handle(SaImmOiHandl >>> SaSelectionObjectT *immSelectionObject) >>> { >>> SaAisErrorT rc; >>> - int msecs_waited; >>> + uint32_t msecs_waited = 0; >>> >>> TRACE_ENTER(); >>> >>> /* Initialize IMM OI service */ >>> - msecs_waited = 0; >>> rc = saImmOiInitialize_2(immOiHandle, &callbacks, >>> &immVersion); >>> while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < >>> max_waiting_time_60s)) { >>> usleep(sleep_delay_ms * 1000); >>> @@ -2794,13 +2802,12 @@ void lgs_imm_init_OI_handle(SaImmOiHandl >>> static SaAisErrorT imm_impl_set_sequence(SaImmOiHandleT immOiHandle) >>> { >>> SaAisErrorT rc = SA_AIS_OK; >>> - int msecs_waited; >>> + uint32_t msecs_waited = 0; >>> >>> TRACE_ENTER(); >>> >>> /* Become object implementer >>> */ >>> - msecs_waited = 0; >>> rc = saImmOiImplementerSet(immOiHandle, >>> implementerName); >>> while (((rc == SA_AIS_ERR_TRY_AGAIN) || (rc == >>> SA_AIS_ERR_EXIST)) && >>> (msecs_waited < >>> max_waiting_time_60s)) { >>> @@ -2817,14 +2824,13 @@ static SaAisErrorT imm_impl_set_sequence >>> * Become class implementer for the OpenSafLogConfig class if >>> it exists >>> */ >>> if ( true == *(bool*) >>> lgs_cfg_get(LGS_IMM_LOG_OPENSAFLOGCONFIG_CLASS_EXIST)) { >>> - >>> (void)immutil_saImmOiClassImplementerSet(immOiHandle, >>> "OpenSafLogConfig"); >>> msecs_waited = 0; >>> - rc = >>> saImmOiClassImplementerSet(immOiHandle, "OpenSafLogConfig"); >>> + rc = >>> saImmOiClassImplementerSet(immOiHandle, safLogConfig_str); >>> while (((rc == SA_AIS_ERR_TRY_AGAIN) || (rc >>> == SA_AIS_ERR_EXIST)) >>> && (msecs_waited >>> < max_waiting_time_60s)) { >>> usleep(sleep_delay_ms * 1000); >>> msecs_waited += >>> sleep_delay_ms; >>> - rc = >>> saImmOiClassImplementerSet(immOiHandle, "OpenSafLogConfig"); >>> + rc = >>> saImmOiClassImplementerSet(immOiHandle, safLogConfig_str); >>> } >>> if (rc != SA_AIS_OK) { >>> >>> TRACE("saImmOiClassImplementerSet OpenSafLogConfig >>> failed %s", saf_error(rc)); >>> @@ -2832,21 +2838,19 @@ static SaAisErrorT imm_impl_set_sequence >>> } >>> } >>> >>> - if (*(bool*) >>> lgs_cfg_get(LGS_IMM_LOG_OPENSAFLOGCONFIG_CLASS_EXIST)) { >>> - msecs_waited = 0; >>> - rc = >>> saImmOiClassImplementerSet(immOiHandle, "SaLogStreamConfig"); >>> - while (((rc == SA_AIS_ERR_TRY_AGAIN) || (rc >>> == SA_AIS_ERR_EXIST)) >>> - && (msecs_waited >>> < max_waiting_time_60s)) { >>> - usleep(sleep_delay_ms * 1000); >>> - msecs_waited += >>> sleep_delay_ms; >>> - rc = >>> saImmOiClassImplementerSet(immOiHandle, "SaLogStreamConfig"); >>> - } >>> - if (rc != SA_AIS_OK) { >>> - >>> TRACE("saImmOiClassImplementerSet SaLogStreamConfig >>> failed %u", rc); >>> - goto done; >>> - } >>> + msecs_waited = 0; >>> + rc = saImmOiClassImplementerSet(immOiHandle, >>> streamConfig_str); >>> + while (((rc == SA_AIS_ERR_TRY_AGAIN) || (rc == >>> SA_AIS_ERR_EXIST)) >>> + && (msecs_waited < >>> max_waiting_time_60s)) { >>> + usleep(sleep_delay_ms * 1000); >>> + msecs_waited += sleep_delay_ms; >>> + rc = >>> saImmOiClassImplementerSet(immOiHandle, streamConfig_str); >>> } >>> - >>> + if (rc != SA_AIS_OK) { >>> + TRACE("saImmOiClassImplementerSet >>> SaLogStreamConfig failed %u", rc); >>> + goto done; >>> + } >>> + >>> done: >>> return rc; >>> TRACE_LEAVE(); >>> @@ -2907,7 +2911,7 @@ static void *imm_impl_init_thread(void * >>> * This will reinstall IMM poll event handling >>> */ >>> lgsv_lgs_evt_t *lgsv_evt; >>> - lgsv_evt = calloc(1, sizeof(lgsv_lgs_evt_t)); >>> + lgsv_evt = (lgsv_lgs_evt_t *) calloc(1, sizeof(lgsv_lgs_evt_t)); >>> osafassert(lgsv_evt); >>> lgsv_evt->evt_type = LGSV_EVT_NO_OP; >>> if (m_NCS_IPC_SEND(&lgs_mbx, lgsv_evt, >>> LGS_IPC_PRIO_CTRL_MSGS) != >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_main.c >>> b/osaf/services/saf/logsv/lgs/lgs_main.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_main.c >>> rename to osaf/services/saf/logsv/lgs/lgs_main.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_main.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_main.cc >>> @@ -20,8 +20,9 @@ >>> * INCLUDE FILES >>> * >>> ========================================================== >>> ============== >>> */ >>> - >>> +#ifndef _GNU_SOURCE >>> #define _GNU_SOURCE >>> +#endif >>> #include <string.h> >>> #include <stdio.h> >>> #include <stdlib.h> >>> @@ -110,7 +111,7 @@ static void rda_cb(uint32_t cb_hdl, PCS_ >>> >>> TRACE_ENTER(); >>> >>> - evt = calloc(1, sizeof(lgsv_lgs_evt_t)); >>> + evt = (lgsv_lgs_evt_t *) calloc(1, sizeof(lgsv_lgs_evt_t)); >>> if (NULL == evt) { >>> LOG_ER("calloc failed"); >>> goto done; >>> @@ -209,6 +210,8 @@ static uint32_t log_initialize(void) >>> uint32_t rc = NCSCC_RC_FAILURE; >>> >>> TRACE_ENTER(); >>> + char *logsv_root_dir = NULL; >>> + char *logsv_data_groupname = NULL; >>> >>> /* Determine how this process was started, by NID or AMF */ >>> if (getenv("SA_AMF_COMPONENT_NAME") == NULL) >>> @@ -239,8 +242,8 @@ static uint32_t log_initialize(void) >>> lgs_trace_config(); /* Show all configuration in TRACE */ >>> >>> /* Show some configurtion info in sysylog */ >>> - char *logsv_root_dir = (char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> - char *logsv_data_groupname = (char *) >>> lgs_cfg_get(LGS_IMM_DATA_GROUPNAME); >>> + logsv_root_dir = (char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + logsv_data_groupname = (char *) >>> lgs_cfg_get(LGS_IMM_DATA_GROUPNAME); >>> LOG_NO("LOG root directory is: \"%s\"", logsv_root_dir); >>> LOG_NO("LOG data group is: \"%s\"", >>> logsv_data_groupname); >>> >>> @@ -342,7 +345,7 @@ static uint32_t log_initialize(void) >>> >>> done: >>> if (lgs_cb->nid_started && >>> - nid_notify("LOGD", rc, NULL) != NCSCC_RC_SUCCESS) { >>> + nid_notify(const_cast<char *>("LOGD"), rc, NULL) != >>> NCSCC_RC_SUCCESS) { >>> LOG_ER("nid_notify failed"); >>> rc = NCSCC_RC_FAILURE; >>> } >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv.c >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_mbcsv.c >>> rename to osaf/services/saf/logsv/lgs/lgs_mbcsv.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv.cc >>> @@ -157,7 +157,7 @@ uint32_t edp_ed_open_stream_rec(EDU_HDL >>> memset(*ckpt_open_stream_msg_dec_ptr, >>> '\0', sizeof(lgs_ckpt_stream_open_t)); >>> ckpt_open_stream_msg_ptr = >>> *ckpt_open_stream_msg_dec_ptr; >>> } else { >>> - ckpt_open_stream_msg_ptr = ptr; >>> + ckpt_open_stream_msg_ptr = >>> (lgs_ckpt_stream_open_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_open_stream_rec_ed_rules, ckpt_open_stream_msg_ptr, >>> @@ -621,13 +621,13 @@ static uint32_t edu_enc_streams(lgs_cb_t >>> { >>> log_stream_t *log_stream_rec = NULL; >>> lgs_ckpt_stream_open_t *ckpt_stream_rec; >>> - EDU_ERR ederror = 0; >>> + EDU_ERR ederror; >>> uint32_t rc = NCSCC_RC_SUCCESS, num_rec = 0; >>> uint8_t *pheader = NULL; >>> lgsv_ckpt_header_t ckpt_hdr; >>> >>> /* Prepare reg. structure to encode */ >>> - ckpt_stream_rec = malloc(sizeof(lgs_ckpt_stream_open_t)); >>> + ckpt_stream_rec = (lgs_ckpt_stream_open_t *) >>> malloc(sizeof(lgs_ckpt_stream_open_t)); >>> if (ckpt_stream_rec == NULL) { >>> LOG_WA("malloc FAILED"); >>> return (NCSCC_RC_FAILURE); >>> @@ -691,14 +691,14 @@ static uint32_t edu_enc_reg_list(lgs_cb_ >>> { >>> log_client_t *client = NULL; >>> lgs_ckpt_initialize_msg_t *ckpt_reg_rec; >>> - EDU_ERR ederror = 0; >>> + EDU_ERR ederror; >>> uint32_t rc = NCSCC_RC_SUCCESS, num_rec = 0; >>> uint8_t *pheader = NULL; >>> lgsv_ckpt_header_t ckpt_hdr; >>> >>> TRACE_ENTER(); >>> /* Prepare reg. structure to encode */ >>> - ckpt_reg_rec = malloc(sizeof(lgs_ckpt_initialize_msg_t)); >>> + ckpt_reg_rec = (lgs_ckpt_initialize_msg_t *) >>> malloc(sizeof(lgs_ckpt_initialize_msg_t)); >>> if (ckpt_reg_rec == NULL) { >>> LOG_WA("malloc FAILED"); >>> return (NCSCC_RC_FAILURE); >>> @@ -771,7 +771,7 @@ static uint32_t ckpt_encode_async_update >>> lgsv_ckpt_msg_v2_t *data_v2 = NULL; >>> lgsv_ckpt_msg_v1_t *data_v1 = NULL; >>> void * vdata = NULL; >>> - EDU_ERR ederror = 0; >>> + EDU_ERR ederror; >>> uint32_t rc = NCSCC_RC_SUCCESS; >>> EDU_PROG_HANDLER edp_function; >>> >>> @@ -953,11 +953,11 @@ static uint32_t ckpt_decode_log_write(lg >>> const int max_waiting_time_ms = 100; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = ckpt_msg; >>> + lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = >>> (lgsv_ckpt_msg_v2_t *) ckpt_msg; >>> write_log = &ckpt_msg_v2->ckpt_rec.write_log; >>> edp_function = edp_ed_write_rec_v2; >>> } else { >>> - lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = ckpt_msg; >>> + lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = >>> (lgsv_ckpt_msg_v1_t *) ckpt_msg; >>> write_log = &ckpt_msg_v1->ckpt_rec.write_log; >>> edp_function = edp_ed_write_rec_v1; >>> } >>> @@ -995,11 +995,11 @@ static uint32_t ckpt_decode_log_close(lg >>> EDU_PROG_HANDLER edp_function; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = ckpt_msg; >>> + lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = >>> (lgsv_ckpt_msg_v2_t *) ckpt_msg; >>> stream_close = &ckpt_msg_v2- >>>> ckpt_rec.stream_close; >>> edp_function = edp_ed_close_stream_rec_v2; >>> } else { >>> - lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = ckpt_msg; >>> + lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = >>> (lgsv_ckpt_msg_v1_t *) ckpt_msg; >>> stream_close = &ckpt_msg_v1- >>>> ckpt_rec.stream_close; >>> edp_function = edp_ed_close_stream_rec_v1; >>> } >>> @@ -1019,11 +1019,11 @@ static uint32_t ckpt_decode_log_client_f >>> EDU_PROG_HANDLER edp_function; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = ckpt_msg; >>> + lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = >>> (lgsv_ckpt_msg_v2_t *) ckpt_msg; >>> finalize_client = &ckpt_msg_v2- >>>> ckpt_rec.finalize_client; >>> edp_function = edp_ed_finalize_rec_v2; >>> } else { >>> - lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = ckpt_msg; >>> + lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = >>> (lgsv_ckpt_msg_v1_t *) ckpt_msg; >>> finalize_client = &ckpt_msg_v1- >>>> ckpt_rec.finalize_client; >>> edp_function = edp_ed_finalize_rec_v1; >>> } >>> @@ -1043,11 +1043,11 @@ static uint32_t ckpt_decode_log_client_d >>> EDU_PROG_HANDLER edp_function; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = ckpt_msg; >>> + lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = >>> (lgsv_ckpt_msg_v2_t *) ckpt_msg; >>> client_down = &ckpt_msg_v2- >>>> ckpt_rec.agent_down; >>> edp_function = edp_ed_agent_down_rec_v2; >>> } else { >>> - lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = ckpt_msg; >>> + lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = >>> (lgsv_ckpt_msg_v1_t *) ckpt_msg; >>> client_down = &ckpt_msg_v1- >>>> ckpt_rec.agent_dest; >>> edp_function = ncs_edp_mds_dest; >>> } >>> @@ -1067,11 +1067,11 @@ static uint32_t ckpt_decode_log_cfg_stre >>> EDU_PROG_HANDLER edp_function; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = ckpt_msg; >>> + lgsv_ckpt_msg_v2_t *ckpt_msg_v2 = >>> (lgsv_ckpt_msg_v2_t *) ckpt_msg; >>> stream_cfg = &ckpt_msg_v2- >>>> ckpt_rec.stream_cfg; >>> edp_function = edp_ed_cfg_stream_rec_v2; >>> } else { >>> - lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = ckpt_msg; >>> + lgsv_ckpt_msg_v1_t *ckpt_msg_v1 = >>> (lgsv_ckpt_msg_v1_t *) ckpt_msg; >>> stream_cfg = &ckpt_msg_v1- >>>> ckpt_rec.stream_cfg; >>> edp_function = edp_ed_cfg_stream_rec_v1; >>> } >>> @@ -1094,15 +1094,15 @@ static uint32_t ckpt_decode_log_cfg(lgs_ >>> lgsv_ckpt_msg_v2_t *ckpt_msg_v2; >>> >>> if (lgs_is_peer_v5()) { >>> - ckpt_msg_v5 = ckpt_msg; >>> + ckpt_msg_v5 = (lgsv_ckpt_msg_v5_t *) >>> ckpt_msg; >>> lgs_cfg = &ckpt_msg_v5->ckpt_rec.lgs_cfg; >>> edp_function = edp_ed_lgs_cfg_rec_v5; >>> } else if (lgs_is_peer_v4()) { >>> - ckpt_msg_v3 = ckpt_msg; >>> + ckpt_msg_v3 = (lgsv_ckpt_msg_v3_t *) >>> ckpt_msg; >>> lgs_cfg = &ckpt_msg_v3->ckpt_rec.lgs_cfg; >>> edp_function = edp_ed_lgs_cfg_rec_v3; >>> } else if (lgs_is_peer_v2()) { >>> - ckpt_msg_v2 = ckpt_msg; >>> + ckpt_msg_v2 = (lgsv_ckpt_msg_v2_t *) >>> ckpt_msg; >>> lgs_cfg = &ckpt_msg_v2->ckpt_rec.lgs_cfg; >>> edp_function = edp_ed_lgs_cfg_rec_v2; >>> } else { >>> @@ -1286,7 +1286,7 @@ static uint32_t ckpt_decode_async_update >>> static uint32_t ckpt_decode_cold_sync(lgs_cb_t *cb, NCS_MBCSV_CB_ARG >>> *cbk_arg) >>> { >>> uint32_t rc = NCSCC_RC_SUCCESS; >>> - EDU_ERR ederror = 0; >>> + EDU_ERR ederror; >>> lgsv_ckpt_msg_v1_t msg_v1; >>> lgsv_ckpt_msg_v2_t msg_v2; >>> uint32_t num_rec = 0; >>> @@ -1436,7 +1436,7 @@ static uint32_t process_ckpt_data(lgs_cb >>> { >>> uint32_t rc = NCSCC_RC_SUCCESS; >>> lgsv_ckpt_msg_type_t lgsv_ckpt_msg_type; >>> - lgsv_ckpt_msg_v2_t *data_v1; >>> + lgsv_ckpt_msg_v1_t *data_v1; >>> lgsv_ckpt_msg_v2_t *data_v2; >>> lgsv_ckpt_msg_v3_t *data_v3; >>> lgsv_ckpt_msg_v5_t *data_v5; >>> @@ -1447,16 +1447,16 @@ static uint32_t process_ckpt_data(lgs_cb >>> } >>> >>> if (lgs_is_peer_v5()) { >>> - data_v5 = data; >>> + data_v5 = (lgsv_ckpt_msg_v5_t *) data; >>> lgsv_ckpt_msg_type = data_v5- >>>> header.ckpt_rec_type; >>> } else if (lgs_is_peer_v4()) { >>> - data_v3 = data; >>> + data_v3 = (lgsv_ckpt_msg_v3_t *) data; >>> lgsv_ckpt_msg_type = data_v3- >>>> header.ckpt_rec_type; >>> } else if (lgs_is_peer_v2()) { >>> - data_v2 = data; >>> + data_v2 = (lgsv_ckpt_msg_v2_t *) data; >>> lgsv_ckpt_msg_type = data_v2- >>>> header.ckpt_rec_type; >>> } else { >>> - data_v1 = data; >>> + data_v1 = (lgsv_ckpt_msg_v1_t *) data; >>> lgsv_ckpt_msg_type = data_v1- >>>> header.ckpt_rec_type; >>> } >>> >>> @@ -1498,10 +1498,10 @@ static uint32_t ckpt_proc_initialize_cli >>> lgs_ckpt_initialize_msg_t *param; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> param = &data_v2->ckpt_rec.initialize_client; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> param = &data_v1->ckpt_rec.initialize_client; >>> } >>> >>> @@ -1559,7 +1559,8 @@ static void insert_localmsg_in_stream(lo >>> const int LOG_REC_ID = 0; >>> const int sleep_delay_ms = 10; >>> const int max_waiting_time_ms = 100; >>> - >>> + int msecs_waited = 0; >>> + >>> /* Log record common */ >>> //log_record.logTimeStamp = setLogTime(); >>> log_record.logTimeStamp = setLogTime(); >>> @@ -1606,7 +1607,7 @@ static void insert_localmsg_in_stream(lo >>> uint32_t max_logrecsize = *(uint32_t *) lgs_cfg_get( >>> LGS_IMM_LOG_MAX_LOGRECSIZE); >>> buf_size = stream->fixedLogRecordSize == 0 ? max_logrecsize >>> : stream->fixedLogRecordSize; >>> - logOutputString = calloc(1, buf_size+1); /* Make room for a '\0' >>> termination */ >>> + logOutputString = (char *) calloc(1, buf_size+1); /* Make room >>> for a '\0' termination */ >>> if (logOutputString == NULL) { >>> LOG_ER("%s - Could not allocate %d >>> bytes",__FUNCTION__, stream->fixedLogRecordSize + 1); >>> goto done; >>> @@ -1621,7 +1622,6 @@ static void insert_localmsg_in_stream(lo >>> } >>> >>> /* Write the log record to file */ >>> - int msecs_waited = 0; >>> rc = log_stream_write_h(stream, logOutputString, n); >>> while ((rc == -2) && (msecs_waited < max_waiting_time_ms)) >>> { >>> usleep(sleep_delay_ms * 1000); >>> @@ -1632,7 +1632,7 @@ static void insert_localmsg_in_stream(lo >>> Therefore, need to re-allocate memory & retry >>> writing log. >>> */ >>> if (logOutputString == NULL) { >>> - logOutputString = calloc(1, >>> buf_size + 1); /* Make room for a '\0' termination */ >>> + logOutputString = (char *) >>> calloc(1, buf_size + 1); /* Make room for a '\0' termination */ >>> if (logOutputString == NULL) { >>> LOG_ER("%s - >>> Could not allocate %d bytes",__FUNCTION__, stream->fixedLogRecordSize + >>> 1); >>> } >>> @@ -1700,7 +1700,7 @@ static uint32_t ckpt_proc_log_write(lgs_ >>> TRACE_ENTER(); >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> streamId = data_v2- >>>> ckpt_rec.write_log.streamId; >>> recordId = data_v2- >>>> ckpt_rec.write_log.recordId; >>> curFileSize = data_v2- >>>> ckpt_rec.write_log.curFileSize; >>> @@ -1708,7 +1708,7 @@ static uint32_t ckpt_proc_log_write(lgs_ >>> logRecord = data_v2- >>>> ckpt_rec.write_log.logRecord; >>> c_file_close_time_stamp = data_v2- >>>> ckpt_rec.write_log.c_file_close_time_stamp; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> streamId = data_v1- >>>> ckpt_rec.write_log.streamId; >>> recordId = data_v1- >>>> ckpt_rec.write_log.recordId; >>> curFileSize = data_v1- >>>> ckpt_rec.write_log.curFileSize; >>> @@ -1737,7 +1737,7 @@ static uint32_t ckpt_proc_log_write(lgs_ >>> * in log file. >>> */ >>> if ((stream->stb_logRecordId + 1) != recordId) { >>> - >>> insert_localmsg_in_stream(stream, "Possible loss of log >>> record"); >>> + >>> insert_localmsg_in_stream(stream, const_cast<char *> >>> ("Possible loss of log record")); >>> } >>> >>> /* Make a limited number of attempts to write if >>> file IO timed out when >>> @@ -1803,13 +1803,13 @@ static uint32_t ckpt_proc_close_stream(l >>> TRACE_ENTER(); >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> streamId = data_v2- >>>> ckpt_rec.stream_close.streamId; >>> clientId = data_v2- >>>> ckpt_rec.stream_close.clientId; >>> /* Set time for closing. Used for renaming */ >>> closetime_ptr = (time_t *) &data_v2- >>>> ckpt_rec.stream_close.c_file_close_time_stamp; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> streamId = data_v1- >>>> ckpt_rec.stream_close.streamId; >>> clientId = data_v1- >>>> ckpt_rec.stream_close.clientId; >>> closetime_ptr = NULL; >>> @@ -1858,15 +1858,17 @@ uint32_t ckpt_proc_open_stream(lgs_cb_t >>> TRACE_ENTER(); >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> param = &data_v2->ckpt_rec.stream_open; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> param = &data_v1->ckpt_rec.stream_open; >>> } >>> >>> + uint32_t invalidClient = (uint32_t) (-1); >>> /* Check that client still exist */ >>> - if ((param->clientId != -1) && (lgs_client_get_by_id(param- >>>> clientId) == NULL)) { >>> + if ((param->clientId != invalidClient) && >>> + (lgs_client_get_by_id(param->clientId) == >>> NULL)) { >>> LOG_WA("\tClient %u does not exist, failed to >>> create stream '%s'", param->clientId, param->logStreamName); >>> goto done; >>> } >>> @@ -1928,7 +1930,8 @@ uint32_t ckpt_proc_open_stream(lgs_cb_t >>> ** Create an association between this client_id and the >>> stream >>> ** A client ID of -1 indicates that no client exist, skip this > step. >>> */ >>> - if ((param->clientId != -1) && lgs_client_stream_add(param- >>>> clientId, stream->streamId) != 0) { >>> + if ((param->clientId != invalidClient) && >>> + lgs_client_stream_add(param->clientId, stream- >>>> streamId) != 0) { >>> /* Do not allow standby to get out of sync */ >>> LOG_ER("%s - Failed to add stream '%s' to client >>> %u",__FUNCTION__, >>> param- >>>> logStreamName, param->clientId); >>> @@ -1968,12 +1971,12 @@ static uint32_t ckpt_proc_finalize_clien >>> time_t *closetime_ptr; >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> lgs_ckpt_finalize_msg_v2_t *param = >>> &data_v2->ckpt_rec.finalize_client; >>> closetime_ptr = (time_t *) ¶m- >>>> c_file_close_time_stamp; >>> client_id = param->client_id; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> lgs_ckpt_finalize_msg_v1_t *param = >>> &data_v1->ckpt_rec.finalize_client; >>> closetime_ptr = NULL; >>> client_id = param->client_id; >>> @@ -2011,12 +2014,12 @@ uint32_t ckpt_proc_agent_down(lgs_cb_t * >>> TRACE_ENTER(); >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> closetime_ptr = (time_t *) &data_v2- >>>> ckpt_rec.agent_down.c_file_close_time_stamp; >>> agent_dest = (MDS_DEST) data_v2- >>>> ckpt_rec.agent_down.agent_dest; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> closetime_ptr = NULL; >>> agent_dest = data_v1->ckpt_rec.agent_dest; >>> } >>> @@ -2070,10 +2073,10 @@ static uint32_t ckpt_proc_cfg_stream(lgs >>> TRACE_ENTER(); >>> >>> if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = >>> (lgsv_ckpt_msg_v2_t *) data; >>> name = data_v2->ckpt_rec.stream_cfg.name; >>> fileName = data_v2- >>>> ckpt_rec.stream_cfg.fileName; >>> - pathName = data_v2- >>>> ckpt_rec.stream_cfg.pathName; >>> + pathName = data_v2- >>>> ckpt_rec.stream_cfg.pathName; >>> maxLogFileSize = data_v2- >>>> ckpt_rec.stream_cfg.maxLogFileSize; >>> fixedLogRecordSize = data_v2- >>>> ckpt_rec.stream_cfg.fixedLogRecordSize; >>> logFullAction = data_v2- >>>> ckpt_rec.stream_cfg.logFullAction; >>> @@ -2084,10 +2087,10 @@ static uint32_t ckpt_proc_cfg_stream(lgs >>> logFileCurrent = data_v2- >>>> ckpt_rec.stream_cfg.logFileCurrent; >>> closetime = data_v2- >>>> ckpt_rec.stream_cfg.c_file_close_time_stamp; >>> } else { >>> - lgsv_ckpt_msg_v1_t *data_v1 = data; >>> + lgsv_ckpt_msg_v1_t *data_v1 = >>> (lgsv_ckpt_msg_v1_t *) data; >>> name = data_v1->ckpt_rec.stream_cfg.name; >>> fileName = data_v1- >>>> ckpt_rec.stream_cfg.fileName; >>> - pathName = data_v1- >>>> ckpt_rec.stream_cfg.pathName; >>> + pathName = data_v1- >>>> ckpt_rec.stream_cfg.pathName; >>> maxLogFileSize = data_v1- >>>> ckpt_rec.stream_cfg.maxLogFileSize; >>> fixedLogRecordSize = data_v1- >>>> ckpt_rec.stream_cfg.fixedLogRecordSize; >>> logFullAction = data_v1- >>>> ckpt_rec.stream_cfg.logFullAction; >>> @@ -2124,7 +2127,7 @@ static uint32_t ckpt_proc_cfg_stream(lgs >>> /* If split file mode, update standby files */ >>> if (lgs_is_split_file_system()) { >>> int rc=0; >>> - const char *root_path = lgs_cfg_get( >>> + const char *root_path = (const char *) >>> lgs_cfg_get( >>> >>> LGS_IMM_LOG_ROOT_DIRECTORY); >>> if ((rc = >>> log_stream_config_change(LGS_STREAM_CREATE_FILES, >>> root_path, stream, >>> @@ -2180,16 +2183,16 @@ uint32_t lgs_ckpt_send_async(lgs_cb_t *c >>> lgsv_ckpt_msg_type_t ckpt_rec_type; >>> >>> if (lgs_is_peer_v5()) { >>> - lgsv_ckpt_msg_v5_t *ckpt_rec_v5 = ckpt_rec; >>> + lgsv_ckpt_msg_v5_t *ckpt_rec_v5 = >>> (lgsv_ckpt_msg_v5_t *) ckpt_rec; >>> ckpt_rec_type = ckpt_rec_v5- >>>> header.ckpt_rec_type; >>> } else if (lgs_is_peer_v4()) { >>> - lgsv_ckpt_msg_v3_t *ckpt_rec_v3 = ckpt_rec; >>> + lgsv_ckpt_msg_v3_t *ckpt_rec_v3 = >>> (lgsv_ckpt_msg_v3_t *) ckpt_rec; >>> ckpt_rec_type = ckpt_rec_v3- >>>> header.ckpt_rec_type; >>> } else if (lgs_is_peer_v2()) { >>> - lgsv_ckpt_msg_v2_t *ckpt_rec_v2 = ckpt_rec; >>> + lgsv_ckpt_msg_v2_t *ckpt_rec_v2 = >>> (lgsv_ckpt_msg_v2_t *) ckpt_rec; >>> ckpt_rec_type = ckpt_rec_v2- >>>> header.ckpt_rec_type; >>> } else { >>> - lgsv_ckpt_msg_v1_t *ckpt_rec_v1 = ckpt_rec; >>> + lgsv_ckpt_msg_v1_t *ckpt_rec_v1 = >>> (lgsv_ckpt_msg_v1_t *) ckpt_rec; >>> ckpt_rec_type = ckpt_rec_v1- >>>> header.ckpt_rec_type; >>> } >>> >>> @@ -2198,8 +2201,8 @@ uint32_t lgs_ckpt_send_async(lgs_cb_t *c >>> memset(&mbcsv_arg, '\0', sizeof(NCS_MBCSV_ARG)); >>> mbcsv_arg.i_op = NCS_MBCSV_OP_SEND_CKPT; >>> mbcsv_arg.i_mbcsv_hdl = cb->mbcsv_hdl; >>> - mbcsv_arg.info.send_ckpt.i_action = action; >>> - mbcsv_arg.info.send_ckpt.i_ckpt_hdl = >>> (NCS_MBCSV_CKPT_HDL)cb->mbcsv_ckpt_hdl; >>> + mbcsv_arg.info.send_ckpt.i_action = >>> (NCS_MBCSV_ACT_TYPE) action; >>> + mbcsv_arg.info.send_ckpt.i_ckpt_hdl = >>> (NCS_MBCSV_CKPT_HDL) cb->mbcsv_ckpt_hdl; >>> mbcsv_arg.info.send_ckpt.i_reo_hdl = >>> NCS_PTR_TO_UNS64_CAST(ckpt_rec); /*Will be used in encode callback >>> */ >>> >>> /* Just store the address of the data to be send as an >>> @@ -2329,7 +2332,7 @@ static uint32_t edp_ed_stream_list(EDU_H >>> } else if (op == EDP_OP_TYPE_DEC) { >>> ckpt_stream_list_msg_dec_ptr = >>> (lgs_stream_list_t **)ptr; >>> if (*ckpt_stream_list_msg_dec_ptr == NULL) { >>> - *ckpt_stream_list_msg_dec_ptr >>> = calloc(1, sizeof(lgs_stream_list_t)); >>> + *ckpt_stream_list_msg_dec_ptr >>> = (lgs_stream_list *) calloc(1, sizeof(lgs_stream_list_t)); >>> if >>> (*ckpt_stream_list_msg_dec_ptr == NULL) { >>> LOG_WA("calloc >>> FAILED"); >>> *o_err = >>> EDU_ERR_MEM_FAIL; >>> @@ -2339,7 +2342,7 @@ static uint32_t edp_ed_stream_list(EDU_H >>> memset(*ckpt_stream_list_msg_dec_ptr, '\0', >>> sizeof(lgs_stream_list_t)); >>> ckpt_stream_list_msg_ptr = >>> *ckpt_stream_list_msg_dec_ptr; >>> } else { >>> - ckpt_stream_list_msg_ptr = ptr; >>> + ckpt_stream_list_msg_ptr = (lgs_stream_list *) >>> ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_stream_list_ed_rules, ckpt_stream_list_msg_ptr, ptr_data_len, >>> @@ -2374,7 +2377,7 @@ uint32_t edp_ed_reg_rec(EDU_HDL *edu_hdl >>> memset(*ckpt_reg_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_initialize_msg_t)); >>> ckpt_reg_msg_ptr = *ckpt_reg_msg_dec_ptr; >>> } else { >>> - ckpt_reg_msg_ptr = ptr; >>> + ckpt_reg_msg_ptr = (lgs_ckpt_initialize_msg_t >>> *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_reg_rec_ed_rules, ckpt_reg_msg_ptr, ptr_data_len, >>> @@ -2427,7 +2430,7 @@ uint32_t edp_ed_header_rec(EDU_HDL *edu_ >>> memset(*ckpt_header_dec_ptr, '\0', >>> sizeof(lgsv_ckpt_header_t)); >>> ckpt_header_ptr = *ckpt_header_dec_ptr; >>> } else { >>> - ckpt_header_ptr = ptr; >>> + ckpt_header_ptr = (lgsv_ckpt_header_t *) ptr; >>> } >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_header_rec_ed_rules, ckpt_header_ptr, ptr_data_len, >>> buf_env, op, >>> o_err); >>> @@ -2547,7 +2550,7 @@ static uint32_t dec_ckpt_header(NCS_UBAI >>> return NCSCC_RC_FAILURE; >>> } >>> p8 = ncs_dec_flatten_space(uba, local_data, 4); >>> - header->ckpt_rec_type = ncs_decode_32bit(&p8); >>> + header->ckpt_rec_type = (lgsv_ckpt_msg_type_t) >>> ncs_decode_32bit(&p8); >>> ncs_dec_skip_space(uba, 4); >>> >>> p8 = ncs_dec_flatten_space(uba, local_data, 4); >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv.h >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv.h >>> @@ -88,7 +88,7 @@ typedef struct { >>> char *logPath; /* log file path */ >>> uint64_t maxFileSize; /* max file size configurable */ >>> int32_t maxLogRecordSize; /* constant size of the records */ >>> - int32_t logFileFullAction; >>> + SaLogFileFullActionT logFileFullAction; >>> int32_t maxFilesRotated; /* max number of rotation files >>> configurable */ >>> char *fileFmt; >>> /* end correspond to SaLogFileCreateAttributes */ >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.c >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.c >>> rename to osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.cc >>> @@ -68,7 +68,7 @@ uint32_t edp_ed_write_rec_v1(EDU_HDL *ed >>> memset(*ckpt_write_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_write_log_v1_t)); >>> ckpt_write_msg_ptr = >>> *ckpt_write_msg_dec_ptr; >>> } else { >>> - ckpt_write_msg_ptr = ptr; >>> + ckpt_write_msg_ptr = (lgs_ckpt_write_log_v1_t >>> *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_write_rec_ed_rules, ckpt_write_msg_ptr, ptr_data_len, >>> @@ -121,7 +121,7 @@ uint32_t edp_ed_close_stream_rec_v1(EDU_ >>> memset(*ckpt_close_stream_msg_dec_ptr, >>> '\0', sizeof(lgs_ckpt_stream_close_v1_t)); >>> ckpt_close_stream_msg_ptr = >>> *ckpt_close_stream_msg_dec_ptr; >>> } else { >>> - ckpt_close_stream_msg_ptr = ptr; >>> + ckpt_close_stream_msg_ptr = >>> (lgs_ckpt_stream_close_v1_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_close_stream_rec_ed_rules, >>> @@ -173,7 +173,7 @@ uint32_t edp_ed_finalize_rec_v1(EDU_HDL >>> memset(*ckpt_final_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_finalize_msg_v1_t)); >>> ckpt_final_msg_ptr = *ckpt_final_msg_dec_ptr; >>> } else { >>> - ckpt_final_msg_ptr = ptr; >>> + ckpt_final_msg_ptr = >>> (lgs_ckpt_finalize_msg_v1_t *) ptr; >>> } >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_final_rec_ed_rules, ckpt_final_msg_ptr, ptr_data_len, >>> buf_env, op, >>> o_err); >>> @@ -235,7 +235,7 @@ uint32_t edp_ed_cfg_stream_rec_v1(EDU_HD >>> memset(*ckpt_stream_cfg_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_stream_cfg_v1_t)); >>> ckpt_stream_cfg_msg_ptr = >>> *ckpt_stream_cfg_msg_dec_ptr; >>> } else { >>> - ckpt_stream_cfg_msg_ptr = ptr; >>> + ckpt_stream_cfg_msg_ptr = >>> (lgs_ckpt_stream_cfg_v1_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_stream_cfg_rec_ed_rules, ckpt_stream_cfg_msg_ptr, ptr_data_len, >>> @@ -282,40 +282,40 @@ uint32_t edp_ed_ckpt_msg_v1(EDU_HDL *edu >>> (EDU_EXEC_RTINE)ckpt_msg_test_type}, >>> >>> /* Reg Record */ >>> - {EDU_EXEC, edp_ed_reg_rec, 0, 0, EDU_EXIT, >>> + {EDU_EXEC, edp_ed_reg_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.initialize_client, 0, NULL}, >>> /* Finalize record */ >>> - {EDU_EXEC, edp_ed_finalize_rec_v1, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_finalize_rec_v1, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.finalize_client, 0, NULL}, >>> /* write log Record */ >>> - {EDU_EXEC, edp_ed_write_rec_v1, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_write_rec_v1, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.write_log, 0, NULL}, >>> /* Open stream */ >>> - {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.stream_open, 0, NULL}, >>> /* Close stream */ >>> - {EDU_EXEC, edp_ed_close_stream_rec_v1, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_close_stream_rec_v1, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.stream_close, 0, NULL}, >>> /* Agent dest */ >>> - {EDU_EXEC, ncs_edp_mds_dest, 0, 0, EDU_EXIT, >>> + {EDU_EXEC, ncs_edp_mds_dest, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.agent_dest, 0, NULL}, >>> /* Cfg stream */ >>> - {EDU_EXEC, edp_ed_cfg_stream_rec_v1, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_cfg_stream_rec_v1, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v1_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> {EDU_END, 0, 0, 0, 0, 0, 0, NULL}, >>> }; >>> >>> if (op == EDP_OP_TYPE_ENC) { >>> - ckpt_msg_ptr = (lgsv_ckpt_msg_v1_t *)ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v1_t *) ptr; >>> } else if (op == EDP_OP_TYPE_DEC) { >>> - ckpt_msg_dec_ptr = (lgsv_ckpt_msg_v1_t >>> **)ptr; >>> + ckpt_msg_dec_ptr = (lgsv_ckpt_msg_v1_t **) >>> ptr; >>> if (*ckpt_msg_dec_ptr == NULL) { >>> *o_err = EDU_ERR_MEM_FAIL; >>> return NCSCC_RC_FAILURE; >>> @@ -323,7 +323,7 @@ uint32_t edp_ed_ckpt_msg_v1(EDU_HDL *edu >>> memset(*ckpt_msg_dec_ptr, '\0', >>> sizeof(lgsv_ckpt_msg_v1_t)); >>> ckpt_msg_ptr = *ckpt_msg_dec_ptr; >>> } else { >>> - ckpt_msg_ptr = ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v1_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_msg_ed_rules, ckpt_msg_ptr, ptr_data_len, buf_env, op, o_err); >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.h >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v1.h >>> @@ -19,13 +19,13 @@ >>> #ifndef LGS_MBCSV_V1_H >>> #define LGS_MBCSV_V1_H >>> >>> +#include "lgs.h" >>> +#include "lgs_mbcsv.h" >>> + >>> #ifdef __cplusplus >>> extern "C" { >>> #endif >>> >>> -#include "lgs.h" >>> -#include "lgs_mbcsv.h" >>> - >>> /* Structures for Checkpoint data ver 1 (to be replicated at the > standby) */ >>> /* Finalize checkpoint record, used in cold/async checkpoint updates */ >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.c >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.c >>> rename to osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v2.cc >>> @@ -50,12 +50,12 @@ uint32_t ckpt_proc_lgs_cfg_v2(lgs_cb_t * >>> LOG_ER("%s ERROR: Called when ceck-point >>> version 1",__FUNCTION__); >>> osafassert(0); >>> } >>> - lgsv_ckpt_msg_v2_t *data_v2 = data; >>> + lgsv_ckpt_msg_v2_t *data_v2 = (lgsv_ckpt_msg_v2_t *) data; >>> lgs_ckpt_lgs_cfg_v2_t *param = &data_v2->ckpt_rec.lgs_cfg; >>> >>> /* Handle log files for new directory if configured for split file >>> system */ >>> if (lgs_is_split_file_system()) { >>> - const char *old_root = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *old_root = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> const char *new_root = param- >>>> logRootDirectory; >>> /* Change root path in configuration struct */ >>> lgs_rootpathconf_set(param- >>>> logRootDirectory); >>> @@ -123,7 +123,7 @@ uint32_t edp_ed_write_rec_v2(EDU_HDL *ed >>> memset(*ckpt_write_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_write_log_v2_t)); >>> ckpt_write_msg_ptr = >>> *ckpt_write_msg_dec_ptr; >>> } else { >>> - ckpt_write_msg_ptr = ptr; >>> + ckpt_write_msg_ptr = (lgs_ckpt_write_log_v2_t >>> *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_write_rec_ed_rules, ckpt_write_msg_ptr, ptr_data_len, >>> @@ -178,7 +178,7 @@ uint32_t edp_ed_close_stream_rec_v2(EDU_ >>> memset(*ckpt_close_stream_msg_dec_ptr, >>> '\0', sizeof(lgs_ckpt_stream_close_v2_t)); >>> ckpt_close_stream_msg_ptr = >>> *ckpt_close_stream_msg_dec_ptr; >>> } else { >>> - ckpt_close_stream_msg_ptr = ptr; >>> + ckpt_close_stream_msg_ptr = >>> (lgs_ckpt_stream_close_v2_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_close_stream_rec_ed_rules, >>> @@ -232,7 +232,7 @@ uint32_t edp_ed_finalize_rec_v2(EDU_HDL >>> memset(*ckpt_final_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_finalize_msg_v2_t)); >>> ckpt_final_msg_ptr = *ckpt_final_msg_dec_ptr; >>> } else { >>> - ckpt_final_msg_ptr = ptr; >>> + ckpt_final_msg_ptr = >>> (lgs_ckpt_finalize_msg_v2_t *) ptr; >>> } >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_final_rec_ed_rules, ckpt_final_msg_ptr, ptr_data_len, >>> buf_env, op, >>> o_err); >>> @@ -296,7 +296,7 @@ uint32_t edp_ed_cfg_stream_rec_v2(EDU_HD >>> memset(*ckpt_stream_cfg_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_stream_cfg_v2_t)); >>> ckpt_stream_cfg_msg_ptr = >>> *ckpt_stream_cfg_msg_dec_ptr; >>> } else { >>> - ckpt_stream_cfg_msg_ptr = ptr; >>> + ckpt_stream_cfg_msg_ptr = >>> (lgs_ckpt_stream_cfg_v2_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_stream_cfg_rec_ed_rules, ckpt_stream_cfg_msg_ptr, ptr_data_len, >>> @@ -349,7 +349,7 @@ uint32_t edp_ed_lgs_cfg_rec_v2(EDU_HDL * >>> memset(*ckpt_lgs_cfg_msg_dec_ptr, '\0', >>> sizeof(lgs_ckpt_lgs_cfg_v2_t)); >>> ckpt_lgs_cfg_msg_ptr = >>> *ckpt_lgs_cfg_msg_dec_ptr; >>> } else { >>> - ckpt_lgs_cfg_msg_ptr = ptr; >>> + ckpt_lgs_cfg_msg_ptr = (lgs_ckpt_lgs_cfg_v2_t >>> *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_lgs_cfg_rec_ed_rules, ckpt_lgs_cfg_msg_ptr, ptr_data_len, >>> @@ -403,7 +403,7 @@ uint32_t edp_ed_agent_down_rec_v2(EDU_HD >>> memset(*ckpt_agent_down_dec_ptr, '\0', >>> sizeof(lgs_ckpt_agent_down_v2_t)); >>> ckpt_agent_down_msg_ptr = >>> *ckpt_agent_down_dec_ptr; >>> } else { >>> - ckpt_agent_down_msg_ptr = ptr; >>> + ckpt_agent_down_msg_ptr = >>> (lgs_ckpt_agent_down_v2_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_lgs_agent_down_ed_rules, ckpt_agent_down_msg_ptr, ptr_data_len, >>> @@ -450,36 +450,36 @@ uint32_t edp_ed_ckpt_msg_v2(EDU_HDL *edu >>> (EDU_EXEC_RTINE)ckpt_msg_test_type}, >>> >>> /* Reg Record */ >>> - {EDU_EXEC, edp_ed_reg_rec, 0, 0, EDU_EXIT, >>> + {EDU_EXEC, edp_ed_reg_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.initialize_client, 0, NULL}, >>> /* Finalize record */ >>> - {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.finalize_client, 0, NULL}, >>> /* write log Record */ >>> - {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.write_log, 0, NULL}, >>> /* Open stream */ >>> - {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.stream_open, 0, NULL}, >>> /* Close stream */ >>> - {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.stream_close, 0, NULL}, >>> /* Agent dest */ >>> - {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> >>> /* Cfg stream */ >>> - {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> /* Lgs cfg */ >>> - {EDU_EXEC, edp_ed_lgs_cfg_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_lgs_cfg_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v2_t *)0)- >>>> ckpt_rec.lgs_cfg, 0, NULL}, >>> {EDU_END, 0, 0, 0, 0, 0, 0, NULL}, >>> @@ -496,7 +496,7 @@ uint32_t edp_ed_ckpt_msg_v2(EDU_HDL *edu >>> memset(*ckpt_msg_dec_ptr, '\0', >>> sizeof(lgsv_ckpt_msg_v2_t)); >>> ckpt_msg_ptr = *ckpt_msg_dec_ptr; >>> } else { >>> - ckpt_msg_ptr = ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v2_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_msg_ed_rules, ckpt_msg_ptr, ptr_data_len, buf_env, op, o_err); >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.c >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.c >>> rename to osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v3.cc >>> @@ -50,7 +50,7 @@ uint32_t ckpt_proc_lgs_cfg_v3(lgs_cb_t * >>> osafassert(0); >>> } >>> >>> - lgsv_ckpt_msg_v3_t *data_v3 = data; >>> + lgsv_ckpt_msg_v3_t *data_v3 = (lgsv_ckpt_msg_v3_t *) data; >>> lgs_ckpt_lgs_cfg_v3_t *param = &data_v3->ckpt_rec.lgs_cfg; >>> >>> if (strcmp(param->logRootDirectory, logsv_root_dir) != 0) { >>> @@ -59,7 +59,7 @@ uint32_t ckpt_proc_lgs_cfg_v3(lgs_cb_t * >>> if (lgs_is_split_file_system()) { >>> /* Move log files on standby also >>> */ >>> const char *new_root_path = >>> param->logRootDirectory; >>> - const char *old_root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *old_root_path = >>> (const char *) lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> /* Update configuration with new >>> root path */ >>> lgs_rootpathconf_set(param- >>>> logRootDirectory); >>> logRootDirectory_filemove(new_root_path, old_root_path, >>> @@ -188,45 +188,45 @@ uint32_t edp_ed_ckpt_msg_v3(EDU_HDL *edu >>> (EDU_EXEC_RTINE)ckpt_msg_test_type}, >>> >>> /* Reg Record */ >>> - {EDU_EXEC, edp_ed_reg_rec, 0, 0, EDU_EXIT, >>> + {EDU_EXEC, edp_ed_reg_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.initialize_client, 0, NULL}, >>> /* Finalize record */ >>> - {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.finalize_client, 0, NULL}, >>> /* write log Record */ >>> - {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.write_log, 0, NULL}, >>> /* Open stream */ >>> - {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.stream_open, 0, NULL}, >>> /* Close stream */ >>> - {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.stream_close, 0, NULL}, >>> /* Agent dest */ >>> - {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> >>> /* Cfg stream */ >>> - {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> /* Lgs cfg */ >>> - {EDU_EXEC, edp_ed_lgs_cfg_rec_v3, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_lgs_cfg_rec_v3, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v3_t *)0)- >>>> ckpt_rec.lgs_cfg, 0, NULL}, >>> {EDU_END, 0, 0, 0, 0, 0, 0, NULL}, >>> }; >>> >>> if (op == EDP_OP_TYPE_ENC) { >>> - ckpt_msg_ptr = (lgsv_ckpt_msg_v3_t *)ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v3_t *) ptr; >>> } else if (op == EDP_OP_TYPE_DEC) { >>> - ckpt_msg_dec_ptr = (lgsv_ckpt_msg_v3_t >>> **)ptr; >>> + ckpt_msg_dec_ptr = (lgsv_ckpt_msg_v3_t **) >>> ptr; >>> if (*ckpt_msg_dec_ptr == NULL) { >>> *o_err = EDU_ERR_MEM_FAIL; >>> return NCSCC_RC_FAILURE; >>> @@ -234,7 +234,7 @@ uint32_t edp_ed_ckpt_msg_v3(EDU_HDL *edu >>> memset(*ckpt_msg_dec_ptr, '\0', >>> sizeof(lgsv_ckpt_msg_v3_t)); >>> ckpt_msg_ptr = *ckpt_msg_dec_ptr; >>> } else { >>> - ckpt_msg_ptr = ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v3_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_msg_ed_rules, ckpt_msg_ptr, ptr_data_len, buf_env, op, o_err); >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.c >>> b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.c >>> rename to osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mbcsv_v5.cc >>> @@ -64,7 +64,7 @@ uint32_t ckpt_proc_lgs_cfg_v5(lgs_cb_t * >>> osafassert(0); >>> } >>> >>> - lgsv_ckpt_msg_v5_t *data_v5 = data; >>> + lgsv_ckpt_msg_v5_t *data_v5 = (lgsv_ckpt_msg_v5_t *) data; >>> lgs_ckpt_lgs_cfg_v5_t *param = &data_v5->ckpt_rec.lgs_cfg; >>> >>> /* Act on configuration changes >>> @@ -95,7 +95,7 @@ uint32_t ckpt_proc_lgs_cfg_v5(lgs_cb_t * >>> if ((strcmp(name_str, LOG_ROOT_DIRECTORY) >>> == 0) && >>> (lgs_is_split_file_system() == true)){ >>> const char *new_root_path = >>> value_str; >>> - const char *old_root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *old_root_path = >>> (const char *) lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> >>> logRootDirectory_filemove(new_root_path, old_root_path, >>> (time_t *) ¶m- >>>> c_file_close_time_stamp); >>> } else if ((strcmp(name_str, >>> LOG_DATA_GROUPNAME) == 0) && >>> @@ -251,44 +251,44 @@ uint32_t edp_ed_ckpt_msg_v5(EDU_HDL *edu >>> (EDU_EXEC_RTINE)ckpt_msg_test_type}, >>> >>> /* Reg Record */ >>> - {EDU_EXEC, edp_ed_reg_rec, 0, 0, EDU_EXIT, >>> + {EDU_EXEC, edp_ed_reg_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.initialize_client, 0, NULL}, >>> /* Finalize record */ >>> - {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_finalize_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.finalize_client, 0, NULL}, >>> /* write log Record */ >>> - {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_write_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.write_log, 0, NULL}, >>> /* Open stream */ >>> - {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_open_stream_rec, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.stream_open, 0, NULL}, >>> /* Close stream */ >>> - {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_close_stream_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.stream_close, 0, NULL}, >>> /* Agent dest */ >>> - {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_agent_down_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> /* Cfg stream */ >>> - {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_cfg_stream_rec_v2, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.stream_cfg, 0, NULL}, >>> /* Lgs cfg */ >>> - {EDU_EXEC, edp_ed_lgs_cfg_rec_v5, 0, 0, >>> EDU_EXIT, >>> + {EDU_EXEC, edp_ed_lgs_cfg_rec_v5, 0, 0, >>> (int)EDU_EXIT, >>> (long)&((lgsv_ckpt_msg_v5_t *)0)- >>>> ckpt_rec.lgs_cfg, 0, NULL}, >>> {EDU_END, 0, 0, 0, 0, 0, 0, NULL}, >>> }; >>> >>> if (op == EDP_OP_TYPE_ENC) { >>> - ckpt_msg_ptr = (lgsv_ckpt_msg_v5_t *)ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v5_t *) ptr; >>> } else if (op == EDP_OP_TYPE_DEC) { >>> - ckpt_msg_dec_ptr = (lgsv_ckpt_msg_v5_t >>> **)ptr; >>> + ckpt_msg_dec_ptr = (lgsv_ckpt_msg_v5_t **) >>> ptr; >>> if (*ckpt_msg_dec_ptr == NULL) { >>> *o_err = EDU_ERR_MEM_FAIL; >>> return NCSCC_RC_FAILURE; >>> @@ -296,7 +296,7 @@ uint32_t edp_ed_ckpt_msg_v5(EDU_HDL *edu >>> memset(*ckpt_msg_dec_ptr, '\0', >>> sizeof(lgsv_ckpt_msg_v5_t)); >>> ckpt_msg_ptr = *ckpt_msg_dec_ptr; >>> } else { >>> - ckpt_msg_ptr = ptr; >>> + ckpt_msg_ptr = (lgsv_ckpt_msg_v5_t *) ptr; >>> } >>> >>> rc = m_NCS_EDU_RUN_RULES(edu_hdl, edu_tkn, >>> ckpt_msg_ed_rules, >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_mds.c >>> b/osaf/services/saf/logsv/lgs/lgs_mds.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_mds.c >>> rename to osaf/services/saf/logsv/lgs/lgs_mds.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_mds.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_mds.cc >>> @@ -179,15 +179,16 @@ static uint32_t dec_lstr_open_sync_msg(N >>> p8 = ncs_dec_flatten_space(uba, local_data, 24); >>> param->maxLogFileSize = ncs_decode_64bit(&p8); >>> param->maxLogRecordSize = ncs_decode_32bit(&p8); >>> - param->haProperty = ncs_decode_32bit(&p8); >>> - param->logFileFullAction = ncs_decode_32bit(&p8); >>> + param->haProperty = (SaBoolT) ncs_decode_32bit(&p8); >>> + param->logFileFullAction = (SaLogFileFullActionT) >>> ncs_decode_32bit(&p8); >>> param->maxFilesRotated = ncs_decode_16bit(&p8); >>> len = ncs_decode_16bit(&p8); >>> ncs_dec_skip_space(uba, 24); >>> >>> /* Decode format string if initiated */ >>> if (len > 0) { >>> - if ((param->logFileFmt = malloc(len)) == NULL) { >>> + param->logFileFmt = (char *) malloc(len); >>> + if (param->logFileFmt == NULL) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> goto done; >>> @@ -269,7 +270,7 @@ static uint32_t dec_write_log_async_msg( >>> param->lstr_id = ncs_decode_32bit(&p8); >>> ncs_dec_skip_space(uba, 20); >>> >>> - param->logRecord = malloc(sizeof(SaLogRecordT)); >>> + param->logRecord = (SaLogRecordT *) >>> malloc(sizeof(SaLogRecordT)); >>> if (!param->logRecord) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -281,7 +282,7 @@ static uint32_t dec_write_log_async_msg( >>> /* ************* SaLogRecord decode ************** */ >>> p8 = ncs_dec_flatten_space(uba, local_data, 12); >>> param->logRecord->logTimeStamp = ncs_decode_64bit(&p8); >>> - param->logRecord->logHdrType = ncs_decode_32bit(&p8); >>> + param->logRecord->logHdrType = (SaLogHeaderTypeT) >>> ncs_decode_32bit(&p8); >>> ncs_dec_skip_space(uba, 12); >>> >>> /* >>> @@ -299,9 +300,9 @@ static uint32_t dec_write_log_async_msg( >>> >>> p8 = ncs_dec_flatten_space(uba, local_data, >>> 14); >>> ntfLogH->notificationId = >>> ncs_decode_64bit(&p8); >>> - ntfLogH->eventType = ncs_decode_32bit(&p8); >>> + ntfLogH->eventType = (SaNtfEventTypeT) >>> ncs_decode_32bit(&p8); >>> >>> - ntfLogH->notificationObject = >>> malloc(sizeof(SaNameT) + 1); >>> + ntfLogH->notificationObject = (SaNameT *) >>> malloc(sizeof(SaNameT) + 1); >>> if (!ntfLogH->notificationObject) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -320,7 +321,7 @@ static uint32_t dec_write_log_async_msg( >>> >>> ntfLogH->notificationObject->value, ntfLogH->notificationObject->length); >>> ntfLogH->notificationObject->value[ntfLogH- >>>> notificationObject->length] = '\0'; >>> - ntfLogH->notifyingObject = >>> malloc(sizeof(SaNameT) + 1); >>> + ntfLogH->notifyingObject = (SaNameT *) >>> malloc(sizeof(SaNameT) + 1); >>> if (!ntfLogH->notifyingObject) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -339,7 +340,7 @@ static uint32_t dec_write_log_async_msg( >>> ncs_decode_n_octets_from_uba(uba, ntfLogH- >>>> notifyingObject->value, ntfLogH->notifyingObject->length); >>> ntfLogH->notifyingObject->value[ntfLogH- >>>> notifyingObject->length] = '\0'; >>> - ntfLogH->notificationClassId = >>> malloc(sizeof(SaNtfClassIdT)); >>> + ntfLogH->notificationClassId = (SaNtfClassIdT *) >>> malloc(sizeof(SaNtfClassIdT)); >>> if (!ntfLogH->notificationClassId) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -358,7 +359,7 @@ static uint32_t dec_write_log_async_msg( >>> /* Initiate general header pointers */ >>> genLogH->notificationClassId = NULL; >>> >>> - genLogH->notificationClassId = >>> malloc(sizeof(SaNtfClassIdT)); >>> + genLogH->notificationClassId = (SaNtfClassIdT *) >>> malloc(sizeof(SaNtfClassIdT)); >>> if (!genLogH->notificationClassId) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -369,7 +370,7 @@ static uint32_t dec_write_log_async_msg( >>> genLogH->notificationClassId->majorId = >>> ncs_decode_16bit(&p8); >>> genLogH->notificationClassId->minorId = >>> ncs_decode_16bit(&p8); >>> >>> - logSvcUsrName = malloc(sizeof(SaNameT) + 1); >>> + logSvcUsrName = (SaNameT *) >>> malloc(sizeof(SaNameT) + 1); >>> if (!logSvcUsrName) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -403,7 +404,7 @@ static uint32_t dec_write_log_async_msg( >>> goto err_done; >>> } >>> >>> - param->logRecord->logBuffer = malloc(sizeof(SaLogBufferT)); >>> + param->logRecord->logBuffer = (SaLogBufferT *) >>> malloc(sizeof(SaLogBufferT)); >>> if (!param->logRecord->logBuffer) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -417,7 +418,7 @@ static uint32_t dec_write_log_async_msg( >>> ncs_dec_skip_space(uba, 4); >>> >>> /* Make sure at least one byte is allocated for later */ >>> - param->logRecord->logBuffer->logBuf = calloc(1, param- >>>> logRecord->logBuffer->logBufSize + 1); >>> + param->logRecord->logBuffer->logBuf = (SaUint8T *) calloc(1, >>> param->logRecord->logBuffer->logBufSize + 1); >>> if (param->logRecord->logBuffer->logBuf == NULL) { >>> LOG_WA("malloc FAILED"); >>> rc = NCSCC_RC_FAILURE; >>> @@ -769,7 +770,8 @@ static uint32_t mds_dec(struct ncsmds_ca >>> } >>> >>> /** allocate an LGSV_LGS_EVENT now **/ >>> - if (NULL == (evt = calloc(1, sizeof(lgsv_lgs_evt_t)))) { >>> + evt = (lgsv_lgs_evt_t *) calloc(1, sizeof(lgsv_lgs_evt_t)); >>> + if (NULL == evt) { >>> LOG_WA("calloc FAILED"); >>> goto err; >>> } >>> @@ -778,12 +780,12 @@ static uint32_t mds_dec(struct ncsmds_ca >>> info->info.dec.o_msg = (uint8_t *)evt; >>> >>> p8 = ncs_dec_flatten_space(uba, local_data, 4); >>> - evt->info.msg.type = ncs_decode_32bit(&p8); >>> + evt->info.msg.type = (lgsv_msg_type_t) >>> ncs_decode_32bit(&p8); >>> ncs_dec_skip_space(uba, 4); >>> >>> if (LGSV_LGA_API_MSG == evt->info.msg.type) { >>> p8 = ncs_dec_flatten_space(uba, local_data, 4); >>> - evt->info.msg.info.api_info.type = >>> ncs_decode_32bit(&p8); >>> + evt->info.msg.info.api_info.type = >>> (lgsv_api_msg_type_t) ncs_decode_32bit(&p8); >>> ncs_dec_skip_space(uba, 4); >>> >>> /* FIX error handling for dec functions */ >>> @@ -1040,7 +1042,8 @@ static uint32_t mds_quiesced_ack(struct >>> >>> TRACE_ENTER(); >>> >>> - if (NULL == (lgsv_evt = calloc(1, sizeof(lgsv_lgs_evt_t)))) { >>> + lgsv_evt = (lgsv_lgs_evt_t *) calloc(1, sizeof(lgsv_lgs_evt_t)); >>> + if (NULL == lgsv_evt) { >>> LOG_WA("calloc FAILED"); >>> goto err; >>> } >>> @@ -1097,7 +1100,8 @@ static uint32_t mds_svc_event(struct ncs >>> info- >>>> info.svc_evt.i_dest, info->info.svc_evt.i_node_id, info- >>>> info.svc_evt.i_svc_id); >>> /* As of now we are only >>> interested in LGA events */ >>> - if (NULL == (evt = calloc(1, >>> sizeof(lgsv_lgs_evt_t)))) { >>> + evt = (lgsv_lgs_evt_t *) calloc(1, >>> sizeof(lgsv_lgs_evt_t)); >>> + if (NULL == evt) { >>> LOG_WA("calloc >>> FAILED"); >>> rc = >>> NCSCC_RC_FAILURE; >>> goto done; >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_stream.c >>> b/osaf/services/saf/logsv/lgs/lgs_stream.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_stream.c >>> rename to osaf/services/saf/logsv/lgs/lgs_stream.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_stream.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_stream.cc >>> @@ -246,7 +246,7 @@ static int rotate_if_needed(log_stream_t >>> ** Remove until we have one less than allowed, we are just >>> about to >>> ** create a new one again. >>> */ >>> - while (file_cnt >= stream->maxFilesRotated) { >>> + while (file_cnt >= (int) stream->maxFilesRotated) { >>> if ((rc = file_unlink_h(oldest_file)) == -1) { >>> LOG_NO("Could not delete: %s - >>> %s", oldest_file, strerror(errno)); >>> goto done; >>> @@ -313,7 +313,7 @@ static uint32_t log_stream_remove(const >>> void log_initiate_stream_files(log_stream_t *stream) >>> { >>> int errno_save; >>> - const char *log_root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *log_root_path = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> >>> TRACE_ENTER(); >>> >>> @@ -500,6 +500,7 @@ log_stream_t *log_stream_new(SaNameT *dn >>> { >>> int rc; >>> log_stream_t *stream = NULL; >>> + uint32_t invalidId = (uint32_t) (-1); >>> >>> osafassert(dn != NULL); >>> TRACE_ENTER2("%s, l: %u", dn->value, dn->length); >>> @@ -507,7 +508,7 @@ log_stream_t *log_stream_new(SaNameT *dn >>> if (lgs_relative_path_check_ts(pathname)) { >>> goto done; >>> } >>> - stream = calloc(1, sizeof(log_stream_t)); >>> + stream = (log_stream_t *) calloc(1, sizeof(log_stream_t)); >>> if (stream == NULL) { >>> LOG_WA("log_stream_new calloc FAILED"); >>> goto done; >>> @@ -546,7 +547,7 @@ log_stream_t *log_stream_new(SaNameT *dn >>> } >>> >>> /* Add stream to array */ >>> - if (stream->streamId == -1) >>> + if (stream->streamId == invalidId) >>> rc = lgs_stream_array_insert_new(stream, >>> &stream->streamId); >>> else >>> rc = lgs_stream_array_insert(stream, stream- >>>> streamId); >>> @@ -575,7 +576,7 @@ log_stream_t *log_stream_new(SaNameT *dn >>> >>> void *arr1[] = { &rdnstr }; >>> const SaImmAttrValuesT_2 attr_safLgStr = { >>> - .attrName = "safLgStr", >>> + .attrName = (SaImmAttrNameT) >>> "safLgStr", >>> .attrValueType = >>> SA_IMM_ATTR_SASTRINGT, >>> .attrValuesNumber = 1, >>> .attrValues = arr1 >>> @@ -583,7 +584,7 @@ log_stream_t *log_stream_new(SaNameT *dn >>> char *str2 = stream->fileName; >>> void *arr2[] = { &str2 }; >>> const SaImmAttrValuesT_2 >>> attr_safLogStreamFileName = { >>> - .attrName = >>> "saLogStreamFileName", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamFileName", >>> .attrValueType = >>> SA_IMM_ATTR_SASTRINGT, >>> .attrValuesNumber = 1, >>> .attrValues = arr2 >>> @@ -591,42 +592,42 @@ log_stream_t *log_stream_new(SaNameT *dn >>> char *str3 = stream->pathName; >>> void *arr3[] = { &str3 }; >>> const SaImmAttrValuesT_2 >>> attr_safLogStreamPathName = { >>> - .attrName = >>> "saLogStreamPathName", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamPathName", >>> .attrValueType = >>> SA_IMM_ATTR_SASTRINGT, >>> .attrValuesNumber = 1, >>> .attrValues = arr3 >>> }; >>> void *arr4[] = { &stream->maxLogFileSize }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamMaxLogFileSize = { >>> - .attrName = >>> "saLogStreamMaxLogFileSize", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamMaxLogFileSize", >>> .attrValueType = >>> SA_IMM_ATTR_SAUINT64T, >>> .attrValuesNumber = 1, >>> .attrValues = arr4 >>> }; >>> void *arr5[] = { &stream->fixedLogRecordSize }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamFixedLogRecordSize = { >>> - .attrName = >>> "saLogStreamFixedLogRecordSize", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamFixedLogRecordSize", >>> .attrValueType = >>> SA_IMM_ATTR_SAUINT32T, >>> .attrValuesNumber = 1, >>> .attrValues = arr5 >>> }; >>> void *arr6[] = { &stream->haProperty }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamHaProperty = { >>> - .attrName = >>> "saLogStreamHaProperty", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamHaProperty", >>> .attrValueType = >>> SA_IMM_ATTR_SAUINT32T, >>> .attrValuesNumber = 1, >>> .attrValues = arr6 >>> }; >>> void *arr7[] = { &stream->logFullAction }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamLogFullAction = { >>> - .attrName = >>> "saLogStreamLogFullAction", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamLogFullAction", >>> .attrValueType = >>> SA_IMM_ATTR_SAUINT32T, >>> .attrValuesNumber = 1, >>> .attrValues = arr7 >>> }; >>> void *arr8[] = { &stream->maxFilesRotated }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamMaxFilesRotated = { >>> - .attrName = >>> "saLogStreamMaxFilesRotated", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamMaxFilesRotated", >>> .attrValueType = >>> SA_IMM_ATTR_SAUINT32T, >>> .attrValuesNumber = 1, >>> .attrValues = arr8 >>> @@ -634,21 +635,21 @@ log_stream_t *log_stream_new(SaNameT *dn >>> char *str9 = stream->logFileFormat; >>> void *arr9[] = { &str9 }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamLogFileFormat = { >>> - .attrName = >>> "saLogStreamLogFileFormat", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamLogFileFormat", >>> .attrValueType = >>> SA_IMM_ATTR_SASTRINGT, >>> .attrValuesNumber = 1, >>> .attrValues = arr9 >>> }; >>> void *arr10[] = { &stream->severityFilter }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamSeverityFilter = { >>> - .attrName = >>> "saLogStreamSeverityFilter", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamSeverityFilter", >>> .attrValueType = >>> SA_IMM_ATTR_SAUINT32T, >>> .attrValuesNumber = 1, >>> .attrValues = arr10 >>> }; >>> void *arr11[] = { &stream->creationTimeStamp >>> }; >>> const SaImmAttrValuesT_2 >>> attr_saLogStreamCreationTimestamp = { >>> - .attrName = >>> "saLogStreamCreationTimestamp", >>> + .attrName = (SaImmAttrNameT) >>> "saLogStreamCreationTimestamp", >>> .attrValueType = >>> SA_IMM_ATTR_SATIMET, >>> .attrValuesNumber = 1, >>> .attrValues = arr11 >>> @@ -673,7 +674,8 @@ log_stream_t *log_stream_new(SaNameT *dn >>> SaAisErrorT rv; >>> >>> rv = >>> saImmOiRtObjectCreate_2(lgs_cb->immOiHandle, >>> - >>> "SaLogStream", parentName, attrValues); >>> + >>> >>> (SaImmClassNameT) "SaLogStream", >>> + >>> >>> parentName, attrValues); >>> free(dndup); >>> >>> if (rv != SA_AIS_OK) { >>> @@ -700,11 +702,11 @@ log_stream_t *log_stream_new_2(SaNameT * >>> { >>> int rc; >>> log_stream_t *stream = NULL; >>> - >>> + uint32_t invalidId = (uint32_t) (-1); >>> osafassert(name != NULL); >>> TRACE_ENTER2("%s, l: %u", name->value, (unsigned int)name- >>>> length); >>> - stream = calloc(1, sizeof(log_stream_t)); >>> + stream = (log_stream_t *) calloc(1, sizeof(log_stream_t)); >>> if (stream == NULL) { >>> LOG_WA("calloc FAILED"); >>> goto done; >>> @@ -727,7 +729,7 @@ log_stream_t *log_stream_new_2(SaNameT * >>> } >>> >>> /* Add stream to array */ >>> - if (stream->streamId == -1) >>> + if (stream->streamId == invalidId) >>> rc = lgs_stream_array_insert_new(stream, >>> &stream->streamId); >>> else >>> rc = lgs_stream_array_insert(stream, stream- >>>> streamId); >>> @@ -843,12 +845,12 @@ void log_stream_close(log_stream_t **s, >>> log_stream_t *stream = *s; >>> char *file_to_rename = NULL; >>> char *timeString = NULL; >>> - int msecs_waited = 0; >>> + uint32_t msecs_waited = 0; >>> const unsigned int max_waiting_time = 8 * 1000; /* 8 >>> secs */ >>> const unsigned int sleep_delay_ms = 500; >>> SaUint32T trace_num_openers; >>> struct timespec closetime_tspec; >>> - const char *root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *root_path = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> >>> osafassert(stream != NULL); >>> TRACE_ENTER2("%s", stream->name); >>> @@ -978,7 +980,10 @@ static int get_number_of_log_files_h(log >>> int rc, n; >>> >>> TRACE_ENTER(); >>> - >>> + >>> + char *logsv_root_dir = (char *) >>> + >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + >>> n = snprintf(parameters_in.file_name, >>> SA_MAX_NAME_LENGTH, "%s", logStream->fileName); >>> if (n >= SA_MAX_NAME_LENGTH) { >>> rc = -1; >>> @@ -986,9 +991,6 @@ static int get_number_of_log_files_h(log >>> goto done; >>> } >>> >>> - char *logsv_root_dir = (char *) >>> - >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> - >>> n = snprintf(parameters_in.logsv_root_dir, PATH_MAX, "%s", >>> logsv_root_dir); >>> if (n >= PATH_MAX) { >>> rc = -1; >>> @@ -1047,7 +1049,7 @@ static int log_rotation_stb(log_stream_t >>> char *current_time_str; >>> char new_current_log_filename[NAME_MAX]; >>> bool do_rotate = false; >>> - const char *root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *root_path = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> >>> TRACE_ENTER(); >>> >>> @@ -1145,7 +1147,7 @@ static int log_rotation_act(log_stream_t >>> int errno_save; >>> int errno_ret; >>> struct timespec closetime_tspec; >>> - const char *root_path = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + const char *root_path = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> >>> /* If file size > max file size: >>> * - Close the log file and create a new. >>> @@ -1387,7 +1389,7 @@ static int lgs_stream_array_insert(log_s >>> static int lgs_stream_array_insert_new(log_stream_t *stream, uint32_t > *id) >>> { >>> int rc = -1; >>> - int i; >>> + uint32_t i = 0; >>> >>> osafassert(id != NULL); >>> >>> @@ -1419,7 +1421,7 @@ static int lgs_stream_array_remove(int i >>> { >>> int rc = -1; >>> >>> - if (0 <= id && id < stream_array_size) { >>> + if (0 <= id && id < (int) stream_array_size) { >>> osafassert(stream_array[id] != NULL); >>> stream_array[id] = NULL; >>> rc = 0; >>> @@ -1435,7 +1437,7 @@ static int lgs_stream_array_remove(int i >>> */ >>> void log_stream_id_print(void) >>> { >>> - int i; >>> + uint32_t i = 0; >>> >>> TRACE(" Current number of streams: %u", >>> numb_of_streams); >>> for (i = 0; i < stream_array_size; i++) { >>> @@ -1454,7 +1456,7 @@ uint32_t log_stream_init(void) >>> stream_array_size += value; >>> >>> TRACE("Max %u application log streams", stream_array_size - >>> 3); >>> - stream_array = calloc(1, sizeof(log_stream_t *) * >>> stream_array_size); >>> + stream_array = (log_stream_t **) calloc(1, >>> sizeof(log_stream_t *) * stream_array_size); >>> if (stream_array == NULL) { >>> LOG_WA("calloc FAILED"); >>> return NCSCC_RC_FAILURE; >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_stream.h >>> b/osaf/services/saf/logsv/lgs/lgs_stream.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_stream.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_stream.h >>> @@ -23,6 +23,10 @@ >>> #include "lgs_fmt.h" >>> #include <ncspatricia.h> >>> >>> +#ifdef __cplusplus >>> +extern "C" { >>> +#endif >>> + >>> /** >>> * Stream descriptor. >>> * Contains both the IMM LOG Class attributes and implementation >>> dependent >>> @@ -116,4 +120,8 @@ extern log_stream_t *log_stream_getnext_ >>> extern void log_stream_print(log_stream_t *stream); >>> extern log_stream_t *log_stream_get_by_id(uint32_t id); >>> >>> +#ifdef __cplusplus >>> +} >>> #endif >>> + >>> +#endif >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_util.c >>> b/osaf/services/saf/logsv/lgs/lgs_util.cc >>> rename from osaf/services/saf/logsv/lgs/lgs_util.c >>> rename to osaf/services/saf/logsv/lgs/lgs_util.cc >>> --- a/osaf/services/saf/logsv/lgs/lgs_util.c >>> +++ b/osaf/services/saf/logsv/lgs/lgs_util.cc >>> @@ -62,10 +62,14 @@ int lgs_create_config_file_h(const char >>> size_t params_in_size; >>> char *logFileFormat_p; >>> char *pathname_p; >>> - >>> + >>> int rc; >>> - int path_len, n; >>> + int path_len; >>> + uint32_t n = 0; >>> char pathname[PATH_MAX]; >>> + size_t logFileFormat_size = 0; >>> + size_t pathname_size = 0; >>> + >>> >>> TRACE_ENTER(); >>> >>> @@ -116,11 +120,11 @@ int lgs_create_config_file_h(const char >>> params_in = malloc(params_in_size); >>> >>> /* Set pointers to allocated memory */ >>> - header_in_p = params_in; >>> - logFileFormat_p = params_in + sizeof(ccfh_t); >>> - size_t logFileFormat_size = params_in_size - sizeof(ccfh_t); >>> + header_in_p = (ccfh_t *) params_in; >>> + logFileFormat_p = (char *) params_in + sizeof(ccfh_t); >>> + logFileFormat_size = params_in_size - sizeof(ccfh_t); >>> pathname_p = logFileFormat_p + strlen(stream- >>>> logFileFormat) + 1; >>> - size_t pathname_size = logFileFormat_size - (strlen(stream- >>>> logFileFormat) + 1); >>> + pathname_size = logFileFormat_size - (strlen(stream- >>>> logFileFormat) + 1); >>> /* Fill in in parameters */ >>> header_in_p->version.releaseCode = lgs_cb- >>>> log_version.releaseCode; >>> @@ -269,7 +273,9 @@ int lgs_file_rename_h( >>> char *oldpath_in_p; >>> char *newpath_in_p; >>> size_t *oldpath_str_size_p; >>> - >>> + size_t oldpath_size = 0; >>> + size_t newpath_size = 0; >>> + >>> TRACE_ENTER(); >>> >>> n = snprintf(oldpath, PATH_MAX, "%s/%s/%s%s", >>> @@ -301,15 +307,15 @@ int lgs_file_rename_h( >>> TRACE_4(" to %s", newpath); >>> >>> /* Allocate memory for parameters */ >>> - size_t oldpath_size = strlen(oldpath)+1; >>> - size_t newpath_size = strlen(newpath)+1; >>> + oldpath_size = strlen(oldpath) + 1; >>> + newpath_size = strlen(newpath) + 1; >>> params_in_size = sizeof(size_t) + oldpath_size + >>> newpath_size; >>> >>> params_in_p = malloc(params_in_size); >>> >>> /* Fill in pointer addresses */ >>> - oldpath_str_size_p = params_in_p; >>> - oldpath_in_p = params_in_p + sizeof(size_t); >>> + oldpath_str_size_p = (size_t *) params_in_p; >>> + oldpath_in_p = (char *) params_in_p + sizeof(size_t); >>> newpath_in_p = oldpath_in_p + oldpath_size; >>> >>> /* Fill in parameters */ >>> @@ -407,7 +413,7 @@ void lgs_send_write_log_ack(uint32_t cli >>> >>> rc = ncsmds_api(&mds_info); >>> if (rc != NCSCC_RC_SUCCESS) >>> - LOG_NO("Send of WRITE ack to %"PRIu64"x >>> FAILED: %u", mds_dest, rc); >>> + LOG_NO("Failed (%u) to send of WRITE ack to: >>> %" PRIu64, rc, mds_dest); >>> >>> TRACE_LEAVE(); >>> } >>> @@ -615,6 +621,9 @@ int lgs_own_log_files_h(log_stream_t *st >>> >>> TRACE_ENTER2("stream %s",stream->name); >>> >>> + /* Set in parameter dir_path */ >>> + const char *logsv_root_dir = (const char *) >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> + >>> /* Set in parameter file_name */ >>> n = snprintf(data_in->file_name, SA_MAX_NAME_LENGTH, >>> "%s", stream->fileName); >>> if (n >= SA_MAX_NAME_LENGTH) { >>> @@ -623,9 +632,6 @@ int lgs_own_log_files_h(log_stream_t *st >>> goto done; >>> } >>> >>> - /* Set in parameter dir_path */ >>> - const char *logsv_root_dir = >>> lgs_cfg_get(LGS_IMM_LOG_ROOT_DIRECTORY); >>> - >>> n = snprintf(data_in->dir_path, PATH_MAX, "%s/%s", >>> logsv_root_dir, stream->pathName); >>> if (n >= PATH_MAX) { >>> diff --git a/osaf/services/saf/logsv/lgs/lgs_util.h >>> b/osaf/services/saf/logsv/lgs/lgs_util.h >>> --- a/osaf/services/saf/logsv/lgs/lgs_util.h >>> +++ b/osaf/services/saf/logsv/lgs/lgs_util.h >>> @@ -29,6 +29,10 @@ >>> #include "lgs_stream.h" >>> #include "lgs_evt.h" >>> >>> +#ifdef __cplusplus >>> +extern "C" { >>> +#endif >>> + >>> /* >>> ========================================================== >>> ============== >>> * DEFINITIONS >>> * >>> ========================================================== >>> ============== >>> @@ -68,4 +72,9 @@ extern int lgs_check_path_exists_h(const >>> extern gid_t lgs_get_data_gid(char *groupname); >>> extern int lgs_own_log_files_h(log_stream_t *stream, const char >>> *groupname); >>> extern bool lgs_has_special_char(const char *str); >>> + >>> +#ifdef __cplusplus >>> +} >>> +#endif >>> + >>> #endif /* ifndef __LGS_UTIL_H */ ------------------------------------------------------------------------------ _______________________________________________ Opensaf-devel mailing list Opensaf-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/opensaf-devel
