osaf/libs/saf/include/saLog.h | 8 +- osaf/services/saf/logsv/lgs/lgs_imm.c | 806 +++++++++++++++++++++++++++----- osaf/services/saf/logsv/lgs/lgs_util.c | 2 +- 3 files changed, 667 insertions(+), 149 deletions(-)
Fix incorrect existing validation and add missing validation when a stream configuration object is created or modified diff --git a/osaf/libs/saf/include/saLog.h b/osaf/libs/saf/include/saLog.h --- a/osaf/libs/saf/include/saLog.h +++ b/osaf/libs/saf/include/saLog.h @@ -170,9 +170,11 @@ extern "C" { /* Log file full actions */ typedef enum { - SA_LOG_FILE_FULL_ACTION_WRAP = 1, - SA_LOG_FILE_FULL_ACTION_HALT = 2, - SA_LOG_FILE_FULL_ACTION_ROTATE = 3 + SA_LOG_FULL_ACTION_BEGIN = 0, + SA_LOG_FILE_FULL_ACTION_WRAP = 1, /* Not supported */ + SA_LOG_FILE_FULL_ACTION_HALT = 2, /* Not supported */ + SA_LOG_FILE_FULL_ACTION_ROTATE = 3, + SA_LOG_FULL_ACTION_END } SaLogFileFullActionT; /* Log file creation attributes */ diff --git a/osaf/services/saf/logsv/lgs/lgs_imm.c b/osaf/services/saf/logsv/lgs/lgs_imm.c --- a/osaf/services/saf/logsv/lgs/lgs_imm.c +++ b/osaf/services/saf/logsv/lgs/lgs_imm.c @@ -938,8 +938,325 @@ static SaAisErrorT config_ccb_completed( return rc; } +/********************************************** + * Help functions for check_attr_validity(...) + **********************************************/ + +typedef struct { + /* Store default values for the stream config class. The values are fetched + * using saImmOmClassDescriptionGet(...) + * Note: Only values relevant for validity checks are stored. + */ + SaUint64T saLogStreamMaxLogFileSize; + SaUint32T saLogStreamFixedLogRecordSize; +} lgs_stream_defval_t; + +static bool lgs_stream_defval_updated_flag = false; +static lgs_stream_defval_t lgs_stream_defval; + /** - * Verify that attribute values are reasonable. + * Return a stream config class default values. Fetched using imm om interface + * + * @return struct of type lgs_stream_defval_t + */ +static lgs_stream_defval_t *get_SaLogStreamConfig_default(void) +{ + SaImmHandleT om_handle = 0; + SaAisErrorT rc = SA_AIS_OK; + SaImmClassCategoryT cc; + SaImmAttrDefinitionT_2 **attributes = NULL; + SaImmAttrDefinitionT_2 *attribute = NULL; + int i = 0; + + TRACE_ENTER2("448"); + if (lgs_stream_defval_updated_flag == false) { + /* Get class defaults for SaLogStreamConfig class from IMM + * We are only interested in saLogStreamMaxLogFileSize and + * saLogStreamFixedLogRecordSize + */ + int iu_setting = immutilWrapperProfile.errorsAreFatal; + immutilWrapperProfile.errorsAreFatal = 0; + + rc = immutil_saImmOmInitialize(&om_handle, NULL, &immVersion); + if (rc != SA_AIS_OK) { + TRACE("\t448 immutil_saImmOmInitialize fail rc=%d", rc); + } + if (rc == SA_AIS_OK) { + rc = immutil_saImmOmClassDescriptionGet_2(om_handle, "SaLogStreamConfig", + &cc, &attributes); + } + + if (rc == SA_AIS_OK) { + while ((attribute = attributes[i++]) != NULL) { + if (!strcmp(attribute->attrName, "saLogStreamMaxLogFileSize")) { + TRACE("\t448 Got saLogStreamMaxLogFileSize"); + lgs_stream_defval.saLogStreamMaxLogFileSize = + *((SaUint64T *) attribute->attrDefaultValue); + TRACE("\t448 value = %lld", + lgs_stream_defval.saLogStreamMaxLogFileSize); + } else if (!strcmp(attribute->attrName, "saLogStreamFixedLogRecordSize")) { + TRACE("\t448 Got saLogStreamFixedLogRecordSize"); + lgs_stream_defval.saLogStreamFixedLogRecordSize = + *((SaUint32T *) attribute->attrDefaultValue); + TRACE("\t448 value = %d", + lgs_stream_defval.saLogStreamFixedLogRecordSize); + } + } + + rc = immutil_saImmOmClassDescriptionMemoryFree_2(om_handle, attributes); + if (rc != SA_AIS_OK) { + LOG_ER("448 %s: Failed to free class description memory rc=%d", + __FUNCTION__, rc); + osafassert(0); + } + lgs_stream_defval_updated_flag = true; + } else { + /* Default values are not fetched. Temporary use hard coded values. + */ + TRACE("\t448 saImmOmClassDescriptionGet_2 failed rc=%d", rc); + lgs_stream_defval.saLogStreamMaxLogFileSize = 5000000; + lgs_stream_defval.saLogStreamFixedLogRecordSize = 150; + } + + rc = immutil_saImmOmFinalize(om_handle); + if (rc != SA_AIS_OK) { + TRACE("\t448 immutil_saImmOmFinalize fail rc=%d", rc); + } + + immutilWrapperProfile.errorsAreFatal = iu_setting; + } else { + TRACE("\t448 Defaults are already fetched"); + TRACE("\t448 saLogStreamMaxLogFileSize=%lld", + lgs_stream_defval.saLogStreamMaxLogFileSize); + TRACE("\t448 saLogStreamFixedLogRecordSize=%d", + lgs_stream_defval.saLogStreamFixedLogRecordSize); + } + + + TRACE_LEAVE2("448"); + return &lgs_stream_defval; +} + +/** + * Check if a stream with the same file name and relative path already + * exist + * + * @param immOiHandle + * @param fileName + * @param pathName + * @param stream + * @param operationType + * @return true if exists +*/ +bool chk_filepath_stream_exist( + char *fileName, + char *pathName, + log_stream_t *stream, + enum CcbUtilOperationType operationType) +{ + log_stream_t *i_stream = NULL; + char *i_fileName = NULL; + char *i_pathName = NULL; + bool rc = false; + + TRACE_ENTER2("448"); + TRACE("\t448 fileName \"%s\", pathName \"%s\"", fileName, pathName); + + /* If a stream is modified only the name may be modified. The path name + * must be fetched from the stream. + */ + if (operationType == CCBUTIL_MODIFY) { + TRACE("\t448 MODIFY"); + if (stream == NULL) { + /* No stream to modify. Should never happen */ + osafassert(0); + } + if ((fileName == NULL) && (pathName == NULL)) { + /* Nothing has changed */ + TRACE("\t448 Nothing has changed"); + return false; + } + if (fileName == NULL) { + i_fileName = stream->fileName; + TRACE("\t448 From stream: fileName \"%s\"", i_fileName); + } else { + i_fileName = fileName; + } + if (pathName == NULL) { + i_pathName = stream->pathName; + TRACE("\t448 From stream: pathName \"%s\"", i_pathName); + } else { + i_pathName = pathName; + } + } else if (operationType == CCBUTIL_CREATE) { + TRACE("\t448 CREATE"); + if ((fileName == NULL) || (pathName == NULL)) { + /* Should never happen + * A valid fileName and pathName is always given at create */ + LOG_ER("448 fileName or pathName is not a string"); + osafassert(0); + } + + i_fileName = fileName; + i_pathName = pathName; + } else { + /* Unknown operationType. Should never happen */ + osafassert(0); + } + + /* Check if any stream has given filename and path */ + TRACE("\t448 Check if any stream has given filename and path"); + i_stream = log_stream_getnext_by_name(NULL); + while (i_stream != NULL) { + TRACE("\t448 Check stream \"%s\"", i_stream->name); + if ((strncmp(i_stream->fileName, i_fileName, NAME_MAX) == 0) && + (strncmp(i_stream->pathName, i_pathName, SA_MAX_NAME_LENGTH) == 0)) { + rc = true; + break; + } + i_stream = log_stream_getnext_by_name(i_stream->name); + } + + TRACE_LEAVE2("448 rc = %d", rc); + return rc; +} + +/** + * Verify fixedLogRecordSize and maxLogFileSize. + * Rules: + * - fixedLogRecordSize must be less than maxLogFileSize + * - fixedLogRecordSize must be less than or equal to logMaxLogrecsize + * - fixedLogRecordSize can be 0. Means variable record size + * - maxLogFileSize must be bigger than 0. No limit is not supported + * - maxLogFileSize must be bigger than logMaxLogrecsize + * + * The ..._flag variable == true means that the corresponding attribute is + * changed. + * + * @param immOiHandle + * @param maxLogFileSize + * @param maxLogFileSize_flag + * @param fixedLogRecordSize + * @param fixedLogRecordSize_flag + * @param stream + * @param operationType + * @return false if error + */ +static bool chk_max_filesize_recordsize_compatible(SaImmOiHandleT immOiHandle, + SaUint64T maxLogFileSize, + bool maxLogFileSize_mod, + SaUint32T fixedLogRecordSize, + bool fixedLogRecordSize_mod, + log_stream_t *stream, + enum CcbUtilOperationType operationType, + SaImmOiCcbIdT ccbId) +{ + SaUint64T i_maxLogFileSize = 0; + SaUint32T i_fixedLogRecordSize = 0; + SaUint32T i_logMaxLogrecsize = 0; + lgs_stream_defval_t *stream_default; + + bool rc = true; + + TRACE_ENTER2("448"); + + /** Get all parameters **/ + + /* Get logMaxLogrecsize from configuration parameters */ + i_logMaxLogrecsize = *(SaUint32T *) lgs_imm_logconf_get( + LGS_IMM_LOG_MAX_LOGRECSIZE, NULL); + TRACE("\t448 i_logMaxLogrecsize = %d", i_logMaxLogrecsize); + /* Get stream default settings */ + stream_default = get_SaLogStreamConfig_default(); + + if (operationType == CCBUTIL_MODIFY) { + TRACE("\t448 operationType == CCBUTIL_MODIFY"); + /* The stream exists. + */ + if (stream == NULL) { + /* Should never happen */ + LOG_ER("448 %s stream == NULL", __FUNCTION__); + osafassert(0); + } + if (fixedLogRecordSize_mod == false) { + /* fixedLogRecordSize is not given. Get from stream */ + i_fixedLogRecordSize = stream->fixedLogRecordSize; + TRACE("\t448 Get from stream, fixedLogRecordSize = %d", + i_fixedLogRecordSize); + } else { + i_fixedLogRecordSize = fixedLogRecordSize; + } + + if (maxLogFileSize_mod == false) { + /* maxLogFileSize is not given. Get from stream */ + i_maxLogFileSize = stream->maxLogFileSize; + TRACE("\t448 Get from stream, maxLogFileSize = %lld", + i_maxLogFileSize); + } else { + i_maxLogFileSize = maxLogFileSize; + TRACE("\t448 Modified maxLogFileSize = %lld", i_maxLogFileSize); + } + } else if (operationType == CCBUTIL_CREATE) { + TRACE("\t448 operationType == CCBUTIL_CREATE"); + /* The stream does not yet exist + */ + if (fixedLogRecordSize_mod == false) { + /* fixedLogRecordSize is not given. Use default */ + i_fixedLogRecordSize = stream_default->saLogStreamFixedLogRecordSize; + TRACE("\t448 Get default, fixedLogRecordSize = %d", + i_fixedLogRecordSize); + } else { + i_fixedLogRecordSize = fixedLogRecordSize; + } + + if (maxLogFileSize_mod == false) { + /* maxLogFileSize is not given. Use default */ + i_maxLogFileSize = stream_default->saLogStreamMaxLogFileSize; + TRACE("\t448 Get default, maxLogFileSize = %lld", + i_maxLogFileSize); + } else { + i_maxLogFileSize = maxLogFileSize; + } + } else { + /* Unknown operationType */ + LOG_ER("%s Unknown operationType", __FUNCTION__); + osafassert(0); + } + + /** Do the verification **/ + if (i_maxLogFileSize <= i_logMaxLogrecsize) { + /* maxLogFileSize must be bigger than logMaxLogrecsize */ + report_oi_error(immOiHandle, ccbId, + "maxLogFileSize out of range"); + TRACE("\t448 i_maxLogFileSize (%lld) <= i_logMaxLogrecsize (%d)", + i_maxLogFileSize, i_logMaxLogrecsize); + rc = false; + } else if (i_fixedLogRecordSize == 0) { + /* fixedLogRecordSize can be 0. Means variable record size */ + TRACE("\t448 fixedLogRecordSize = 0"); + rc = true; + } else if (i_fixedLogRecordSize >= i_maxLogFileSize) { + /* fixedLogRecordSize must be less than maxLogFileSize */ + report_oi_error(immOiHandle, ccbId, + "fixedLogRecordSize out of range"); + TRACE("\t448 i_fixedLogRecordSize >= i_maxLogFileSize"); + rc = false; + } else if (i_fixedLogRecordSize > i_logMaxLogrecsize) { + /* fixedLogRecordSize must be less than maxLogFileSize */ + report_oi_error(immOiHandle, ccbId, + "fixedLogRecordSize out of range"); + TRACE("\t448 i_fixedLogRecordSize > i_logMaxLogrecsize"); + rc = false; + } + + TRACE_LEAVE2("448 rc = %d", rc); + return rc; +} + +/** + * Validate input parameters creation and modify of a persistent stream + * i.e. a stream that has a configuration object. + * * @param ccbUtilOperationData * * @return SaAisErrorT @@ -948,161 +1265,360 @@ static SaAisErrorT check_attr_validity(S const struct CcbUtilOperationData *opdata) { SaAisErrorT rc = SA_AIS_OK; - void *value; - int n = 0; - const SaImmAttrValuesT_2 *attribute; - log_stream_t *stream = (opdata->operationType == CCBUTIL_CREATE) ? NULL - : log_stream_get_by_name((char *) opdata->param.modify.objectName->value); + void *value = NULL; + int aindex = 0; + const SaImmAttrValuesT_2 *attribute = NULL; + log_stream_t *stream = NULL; + + /* Attribute values to be checked + */ + /* Mandatory if create. Can be modified */ + char *i_fileName = NULL; + bool i_fileName_mod = false; + /* Mandatory if create. Cannot be changed (handled in class definition) */ + char *i_pathName = NULL; + bool i_pathName_mod = false; + /* Modification flag -> true if modified */ + SaUint32T i_fixedLogRecordSize = 0; + bool i_fixedLogRecordSize_mod = false; + SaUint64T i_maxLogFileSize = 0; + bool i_maxLogFileSize_mod = false; + SaUint32T i_logFullAction = 0; + bool i_logFullAction_mod = false; + char *i_logFileFormat = NULL; + bool i_logFileFormat_mod = false; + SaUint32T i_logFullHaltThreshold = 0; + bool i_logFullHaltThreshold_mod = false; + SaUint32T i_maxFilesRotated = 0; + bool i_maxFilesRotated_mod = false; + SaUint32T i_severityFilter = 0; + bool i_severityFilter_mod = false; + + TRACE_ENTER2("448"); + + /* Get first attribute if any and fill in name and path if the stream + * exist (modify) + */ + if (opdata->operationType == CCBUTIL_MODIFY) { + TRACE("\t448 Validate for MODIFY"); + stream = log_stream_get_by_name( + (char *) opdata->param.modify.objectName->value); + if (stream == NULL) { + /* No stream to modify */ + report_oi_error(immOiHandle, opdata->ccbId, + "Stream does not exist"); + TRACE("\t448 Stream does not exist"); + rc = SA_AIS_ERR_BAD_OPERATION; + goto done; + } else { + /* Get first attribute */ + if (opdata->param.modify.attrMods[aindex] != NULL) { + attribute = &opdata->param.modify.attrMods[aindex]->modAttr; + aindex++; + TRACE("\t448 First attribute \"%s\" fetched", + attribute->attrName); + } else { + TRACE("\t448 No attributes found"); + } + /* Get relative path and file name from stream. + * Name may be modified + */ + i_pathName = stream->pathName; + i_fileName = stream->fileName; + TRACE("\t448 From stream: pathName \"%s\", fileName \"%s\"", + i_pathName, i_fileName); + } + } else if (opdata->operationType == CCBUTIL_CREATE){ + TRACE("\t448 Validate for CREATE"); + /* Check if stream already exist after parameters are saved. + * Parameter value for fileName is needed. + */ + /* Get first attribute */ + attribute = opdata->param.create.attrValues[aindex]; + aindex++; + TRACE("\t448 First attribute \"%s\" fetched", attribute->attrName); + } else { + /* Invalid operation type */ + LOG_ER("%s Invalid operation type", __FUNCTION__); + osafassert(0); + } + - TRACE_ENTER(); - - int i = 0; - while (rc == SA_AIS_OK) { + while ((attribute != NULL) && (rc == SA_AIS_OK)){ + /* Save all changed/given attribute values + */ + + /* Get the value */ + if (attribute->attrValuesNumber > 0) { + value = attribute->attrValues[0]; + } else if (opdata->operationType == CCBUTIL_MODIFY) { + /* An attribute without a value is never valid if modify */ + report_oi_error(immOiHandle, opdata->ccbId, + "Attribute %s has no value",attribute->attrName); + TRACE("\t448 Modify: Attribute %s has no value",attribute->attrName); + rc = SA_AIS_ERR_BAD_OPERATION; + goto done; + } else { + /* If create all attributes will be present also the ones without + * any value. + */ + TRACE("\t448 Create: Attribute %s has no value",attribute->attrName); + goto next; + } + + /* Save attributes with a value */ + if (!strcmp(attribute->attrName, "saLogStreamFileName")) { + /* Save filename. Check later together with path name */ + i_fileName = *((char **) value); + i_fileName_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamPathName")) { + /* Save path name. Check later together with filename */ + i_pathName = *((char **) value); + i_pathName_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamMaxLogFileSize")) { + /* Save and compare with FixedLogRecordSize after all attributes + * are read. Must be bigger than FixedLogRecordSize + */ + i_maxLogFileSize = *((SaUint64T *) value); + i_maxLogFileSize_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamFixedLogRecordSize")) { + /* Save and compare with MaxLogFileSize after all attributes + * are read. Must be smaller than MaxLogFileSize + */ + i_fixedLogRecordSize = *((SaUint64T *) value); + i_fixedLogRecordSize_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamLogFullAction")) { + i_logFullAction = *((SaUint32T *) value); + i_logFullAction_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamLogFileFormat")) { + i_logFileFormat = *((char **) value); + i_logFileFormat_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamLogFullHaltThreshold")) { + i_logFullHaltThreshold = *((SaUint32T *) value); + i_logFullHaltThreshold_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamMaxFilesRotated")) { + i_maxFilesRotated = *((SaUint32T *) value); + i_maxFilesRotated_mod = true; + TRACE("\t448 Saved attribute \"%s\"", attribute->attrName); + + } else if (!strcmp(attribute->attrName, "saLogStreamSeverityFilter")) { + i_severityFilter = *((SaUint32T *) value); + i_severityFilter_mod = true; + TRACE("\t448 Saved attribute \"%s\" = %d", attribute->attrName, + i_severityFilter); + + } + + /* Get next attribute or detect no more attributes */ + next: if (opdata->operationType == CCBUTIL_CREATE) { - attribute = opdata->param.create.attrValues[i]; - value = (attribute != NULL && attribute->attrValuesNumber > 0) ? - attribute->attrValues[0] : NULL; + attribute = opdata->param.create.attrValues[aindex]; } else { - // CCBUTIL_MODIFY - attribute = (opdata->param.modify.attrMods[i] != NULL) ? - &opdata->param.modify.attrMods[i]->modAttr : NULL; - value = (attribute != NULL && attribute->attrValuesNumber > 0) ? - attribute->attrValues[0] : NULL; + /* CCBUTIL_MODIFY */ + if (opdata->param.modify.attrMods[aindex] != NULL) { + attribute = &opdata->param.modify.attrMods[aindex]->modAttr; + } else { + attribute = NULL; + } + } + aindex++; + } + + /* Check all attributes: + * Attributes must be within limits + * Note: Mandatory attributes are flagged SA_INITIALIZED meaning that + * IMM will reject create if these attributes are not defined. Therefore + * this is not checked here. + */ + if (rc == SA_AIS_OK) { + /* saLogStreamPathName + * Must be valid and not outside of root path + */ + if (i_pathName_mod) { + TRACE("\t448 Checking saLogStreamPathName"); + if (i_pathName == NULL) { + /* Must point to a string */ + rc = SA_AIS_ERR_BAD_OPERATION; + report_oi_error(immOiHandle, opdata->ccbId, + "NULL pointer to saLogStreamPathName"); + TRACE("\t448 NULL pointer to saLogStreamPathName"); + goto done; + } + + if (lgs_relative_path_check_ts(i_pathName) == true) { + report_oi_error(immOiHandle, opdata->ccbId, + "Path %s not valid", i_pathName); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 Path %s not valid", i_pathName); + goto done; + } + } + + /* saLogStreamFileName + * Must be a name. A stream with this name and relative path must not + * already exist. + */ + if (i_fileName_mod) { + TRACE("\t448 Checking saLogStreamFileName"); + if (i_fileName == NULL) { + /* Must point to a string */ + rc = SA_AIS_ERR_BAD_OPERATION; + report_oi_error(immOiHandle, opdata->ccbId, + "NULL pointer to saLogStreamFileName"); + TRACE("\t448 NULL pointer to saLogStreamFileName"); + goto done; + } + + if (chk_filepath_stream_exist(i_fileName, i_pathName, + stream, opdata->operationType)) { + report_oi_error(immOiHandle, opdata->ccbId, + "Path/file %s/%s already exist", i_pathName, i_fileName); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 Path/file %s/%s already exist", + i_pathName, i_fileName); + goto done; + } + } + + /* saLogStreamMaxLogFileSize or saLogStreamFixedLogRecordSize + * See chk_max_filesize_recordsize_compatible() for rules + */ + if (i_maxLogFileSize_mod || i_fixedLogRecordSize_mod) { + TRACE("\t448 Check saLogStreamMaxLogFileSize," + " saLogStreamFixedLogRecordSize"); + if (chk_max_filesize_recordsize_compatible(immOiHandle, + i_maxLogFileSize, + i_maxLogFileSize_mod, + i_fixedLogRecordSize, + i_fixedLogRecordSize_mod, + stream, + opdata->operationType, + opdata->ccbId) == false) { + /* report_oi_error is done within check function */ + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 chk_max_filesize_recordsize_compatible Fail"); + goto done; + } + } + + /* saLogStreamLogFullAction + * 1, 2 and 3 are valid according to AIS but only action rotate (3) + * is supported. + */ + if (i_logFullAction_mod) { + TRACE("\t448 Check saLogStreamLogFullAction"); + /* If this attribute is changed an oi error report is written + * and the value is changed (backwards compatible) but this will + * not affect change action + */ + if ((i_logFullAction < SA_LOG_FILE_FULL_ACTION_WRAP) || + (i_logFullAction > SA_LOG_FILE_FULL_ACTION_ROTATE)) { + report_oi_error(immOiHandle, opdata->ccbId, + "logFullAction out of range"); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 logFullAction out of range"); + goto done; + } + if ((i_logFullAction == SA_LOG_FILE_FULL_ACTION_WRAP) || + (i_logFullAction == SA_LOG_FILE_FULL_ACTION_HALT)) { + report_oi_error(immOiHandle, opdata->ccbId, + "logFullAction:Current Implementation doesn't support Wrap and halt"); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 logFullAction: Not supported"); + goto done; + } } - if (attribute != NULL && value != NULL) { - TRACE("attribute %s", attribute->attrName); - - if (!strcmp(attribute->attrName, "saLogStreamFileName")) { - char *fileName = *((char **) value); - if (fileName == NULL) { - rc = SA_AIS_ERR_INVALID_PARAM; + /* saLogStreamLogFileFormat + * If create the only possible stream type is application and no stream + * is yet created. All streams can be modified. + */ + if (i_logFileFormat_mod) { + SaBoolT dummy; + if (opdata->operationType == CCBUTIL_CREATE) { + if (!lgs_is_valid_format_expression(i_logFileFormat, STREAM_TYPE_APPLICATION, &dummy)) { report_oi_error(immOiHandle, opdata->ccbId, - "NULL pointer to saLogStreamFileName"); - } else if (lgs_check_path_exists_h(fileName) == 0) { + "Invalid logFileFormat: %s", i_logFileFormat); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 Create: Invalid logFileFormat: %s", + i_logFileFormat); + goto done; + } + } + else { + if (!lgs_is_valid_format_expression(i_logFileFormat, stream->streamType, &dummy)) { report_oi_error(immOiHandle, opdata->ccbId, - "File %s already exist", fileName); - rc = SA_AIS_ERR_EXIST; - TRACE("fileName: %s", fileName); + "Invalid logFileFormat: %s", i_logFileFormat); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 Modify: Invalid logFileFormat: %s", + i_logFileFormat); + goto done; } - } else if (!strcmp(attribute->attrName, "saLogStreamPathName")) { - char stream_path[PATH_MAX]; - n = snprintf(stream_path, PATH_MAX, "%s//%s//.", - lgs_cb->logsv_root_dir, - *((char **) value)); - if (n >= PATH_MAX) { - report_oi_error(immOiHandle, opdata->ccbId, - "Path > PATH_MAX"); - rc = SA_AIS_ERR_BAD_OPERATION; - } else if (lgs_relative_path_check_ts(stream_path)) { - report_oi_error(immOiHandle, opdata->ccbId, - "Path %s not valid", stream_path); - rc = SA_AIS_ERR_INVALID_PARAM; - } else if (lgs_check_path_exists_h(lgs_cb->logsv_root_dir) != 0) { - report_oi_error(immOiHandle, opdata->ccbId, - "Path %s does not exist", stream_path); - rc = SA_AIS_ERR_BAD_OPERATION; - } - TRACE("Stream path: %s", stream_path); - } else if (!strcmp(attribute->attrName, "saLogStreamMaxLogFileSize")) { - SaUint64T maxLogFileSize = *((SaUint64T *) value); - // maxLogFileSize == 0 is interpreted as "infinite" size. - if (maxLogFileSize > 0 && - stream != NULL && - maxLogFileSize < stream->fixedLogRecordSize) { - report_oi_error(immOiHandle, opdata->ccbId, - "maxLogFileSize out of range"); - rc = SA_AIS_ERR_BAD_OPERATION; - } - TRACE("maxLogFileSize: %llu", maxLogFileSize); - } else if (!strcmp(attribute->attrName, "saLogStreamFixedLogRecordSize")) { - SaUint32T fixedLogRecordSize = *((SaUint32T *) value); - if (stream != NULL && - stream->maxLogFileSize > 0 && - fixedLogRecordSize > stream->maxLogFileSize) { - report_oi_error(immOiHandle, opdata->ccbId, - "fixedLogRecordSize out of range"); - rc = SA_AIS_ERR_BAD_OPERATION; - } - TRACE("fixedLogRecordSize: %u", fixedLogRecordSize); - } else if (!strcmp(attribute->attrName, "saLogStreamLogFullAction")) { - SaLogFileFullActionT logFullAction = *((SaUint32T *) value); - if ((logFullAction < SA_LOG_FILE_FULL_ACTION_WRAP) || - (logFullAction > SA_LOG_FILE_FULL_ACTION_ROTATE)) { - report_oi_error(immOiHandle, opdata->ccbId, - "logFullAction out of range"); - rc = SA_AIS_ERR_BAD_OPERATION; - } - if ((logFullAction == SA_LOG_FILE_FULL_ACTION_WRAP) || - (logFullAction == SA_LOG_FILE_FULL_ACTION_HALT)) { - report_oi_error(immOiHandle, opdata->ccbId, - "logFullAction:Current Implementation doesn't support Wrap and halt"); - rc = SA_AIS_ERR_NOT_SUPPORTED; - } - TRACE("logFullAction: %u", logFullAction); - } else if (!strcmp(attribute->attrName, "saLogStreamLogFullHaltThreshold")) { - SaUint32T logFullHaltThreshold = *((SaUint32T *) value); - if (logFullHaltThreshold >= 100) { - report_oi_error(immOiHandle, opdata->ccbId, - "logFullHaltThreshold out of range"); - rc = SA_AIS_ERR_BAD_OPERATION; - } - TRACE("logFullHaltThreshold: %u", logFullHaltThreshold); - } else if (!strcmp(attribute->attrName, "saLogStreamMaxFilesRotated")) { - SaUint32T maxFilesRotated = *((SaUint32T *) value); - if (maxFilesRotated < 1 || maxFilesRotated > 128) { - report_oi_error(immOiHandle, opdata->ccbId, - "maxFilesRotated out of range (min 1, max 127): %u", - maxFilesRotated); - rc = SA_AIS_ERR_BAD_OPERATION; - } - TRACE("maxFilesRotated: %u", maxFilesRotated); - } else if (!strcmp(attribute->attrName, "saLogStreamLogFileFormat")) { - SaBoolT dummy; - char *logFileFormat = *((char **) value); - TRACE("logFileFormat: %s", logFileFormat); - - if (opdata->operationType == CCBUTIL_CREATE) { - if (!lgs_is_valid_format_expression(logFileFormat, STREAM_TYPE_APPLICATION, &dummy)) { - report_oi_error(immOiHandle, opdata->ccbId, - "Invalid logFileFormat: %s", logFileFormat); - rc = SA_AIS_ERR_BAD_OPERATION; - } - } - else { - if (!lgs_is_valid_format_expression(logFileFormat, stream->streamType, &dummy)) { - report_oi_error(immOiHandle, opdata->ccbId, - "Invalid logFileFormat: %s", logFileFormat); - rc = SA_AIS_ERR_BAD_OPERATION; - } - } - } else if (!strcmp(attribute->attrName, "saLogStreamSeverityFilter")) { - SaUint32T severityFilter = *((SaUint32T *) value); - if (severityFilter > 0x7f) { - report_oi_error(immOiHandle, opdata->ccbId, - "Invalid severity: %x", severityFilter); - rc = SA_AIS_ERR_BAD_OPERATION; - } - TRACE("severityFilter: %u", severityFilter); - } else if (!strncmp(attribute->attrName, "SaImm", 5) || - !strncmp(attribute->attrName, "safLg", 5)) { - ; - } else { - report_oi_error(immOiHandle, opdata->ccbId, - "invalid attribute %s", attribute->attrName); - rc = SA_AIS_ERR_BAD_OPERATION; - } - } else { - TRACE("i: %d, attribute: %d, value: %d", i, attribute == NULL ? 0 : 1 - , value == NULL ? 0 : 1); - if (attribute == NULL) { - break; } } - i++; + + /* saLogStreamLogFullHaltThreshold + * Not supported and not used. For backwards compatibility the + * value can still be set/changed between 0 and 99 (percent) + */ + if (i_logFullHaltThreshold_mod) { + TRACE("\t448 Checking saLogStreamLogFullHaltThreshold"); + if (i_logFullHaltThreshold >= 100) { + report_oi_error(immOiHandle, opdata->ccbId, + "logFullHaltThreshold out of range"); + rc = SA_AIS_ERR_BAD_OPERATION; + goto done; + } + } + + /* saLogStreamMaxFilesRotated + * < 127 + */ + if (i_maxFilesRotated_mod) { + TRACE("\t448 Checking saLogStreamMaxFilesRotated"); + if ((i_maxFilesRotated < 1) || (i_maxFilesRotated > 127)) { + report_oi_error(immOiHandle, opdata->ccbId, + "maxFilesRotated out of range (min 1, max 127): %u", + i_maxFilesRotated); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 maxFilesRotated out of range " + "(min 1, max 127): %u", i_maxFilesRotated); + goto done; + } + } + + /* saLogStreamSeverityFilter + * < 0x7f + */ + if (i_severityFilter_mod) { + TRACE("\t448 Checking saLogStreamSeverityFilter"); + if (i_severityFilter >= 0x7f) { + report_oi_error(immOiHandle, opdata->ccbId, + "Invalid severity: %x", i_severityFilter); + rc = SA_AIS_ERR_BAD_OPERATION; + TRACE("\t448 Invalid severity: %x", i_severityFilter); + goto done; + } + } } - TRACE_LEAVE2(); - return rc; + + done: + TRACE_LEAVE2("448 rc = %d", rc); + return rc; } /** diff --git a/osaf/services/saf/logsv/lgs/lgs_util.c b/osaf/services/saf/logsv/lgs/lgs_util.c --- a/osaf/services/saf/logsv/lgs/lgs_util.c +++ b/osaf/services/saf/logsv/lgs/lgs_util.c @@ -427,7 +427,7 @@ void lgs_free_write_log(const lgsv_write * Note: This function must be thread safe * * @param path - * @return true if path is allowed + * @return true if path is not allowed */ bool lgs_relative_path_check_ts(const char* path) { ------------------------------------------------------------------------------ _______________________________________________ Opensaf-devel mailing list Opensaf-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/opensaf-devel