osaf/libs/agents/saf/ntfa/ntfa_api.c | 380 +++++++++++++++++++-------------
osaf/libs/agents/saf/ntfa/ntfa_util.c | 33 ++-
osaf/libs/common/ntfsv/ntfsv_enc_dec.c | 75 ++++-
osaf/libs/common/ntfsv/ntfsv_mem.c | 1 +
4 files changed, 306 insertions(+), 183 deletions(-)
Currently if any unadapted longDn consumer receives notification having
extended SaNameT
in notification (notificationObject(s), notifyingObject(s), value type as
LDAP_NAME)
will be crashed
The crash is due to invalid access to extended SaNameT
The patch makes longDn notification invisible to unadapted consumer. Also if
unadapted
producer is going to send a longDn notification or unadapted consumer specifies
longDn
object for filter, the error code SA_AIS_ERR_INVALID_PARAM is returned.
Affected APIs: saNtfNotificationSend, saNtfNotificationReadNext,
saNtfNotificationReadInitialize, saNtfNotificationSubscribe, saNtfPtrValGet, and
notificationCallback.
diff --git a/osaf/libs/agents/saf/ntfa/ntfa_api.c
b/osaf/libs/agents/saf/ntfa/ntfa_api.c
--- a/osaf/libs/agents/saf/ntfa/ntfa_api.c
+++ b/osaf/libs/agents/saf/ntfa/ntfa_api.c
@@ -39,6 +39,67 @@ ntfa_cb_t ntfa_cb = {
/* list of subscriptions for this process */
ntfa_subscriber_list_t *subscriberNoList = NULL;
+static SaAisErrorT checkNtfValueTypeRange(SaNtfValueTypeT type)
+{
+ return (type < SA_NTF_VALUE_UINT8 || type > SA_NTF_VALUE_ARRAY)?
SA_AIS_ERR_INVALID_PARAM
+
: SA_AIS_OK;
+}
+
+static SaAisErrorT checkNtfValue(v_data* pvdata, SaNtfValueTypeT type,
SaNtfValueT* value)
+{
+ SaAisErrorT rc = SA_AIS_OK;
+ SaNameT *ptr;
+ if ((rc = checkNtfValueTypeRange(type)) != SA_AIS_OK) {
+ TRACE_1("Invalid value type(%d)", type);
+ return rc;
+ }
+
+ if (type == SA_NTF_VALUE_LDAP_NAME) {
+ /* SaNameT must have length > 2 */
+ if (value->ptrVal.dataSize <= 2)
+ return SA_AIS_ERR_INVALID_PARAM;
+
+ /* Check SaNameT */
+ ptr = pvdata->p_base + value->ptrVal.dataOffset;
+ if (!ntfsv_sanamet_is_valid(ptr))
+ return SA_AIS_ERR_INVALID_PARAM;
+
+ /* Refill the extended SaNameT into variable data */
+ if (osaf_is_an_extended_name(ptr)) {
+ size_t length_to_copy;
+ void *p;
+ if (value->ptrVal.dataSize <
(osaf_extended_name_length(ptr) + 2)) {
+ LOG_ER("The allocated memory is not large
enough,"
+ " the object will be truncated
(%s)"
+ ,
osaf_extended_name_borrow(ptr));
+ length_to_copy = value->ptrVal.dataSize - 2;
+ } else
+ length_to_copy = osaf_extended_name_length(ptr);
+
+ p = pvdata->p_base + value->ptrVal.dataOffset + 2;
+ memcpy(p, osaf_extended_name_borrow(ptr),
length_to_copy);
+ } else {
+ if (value->ptrVal.dataSize >
SA_MAX_UNEXTENDED_NAME_LENGTH + 2)
+ value->ptrVal.dataSize =
SA_MAX_UNEXTENDED_NAME_LENGTH + 2;
+ }
+ }
+
+ return rc;
+}
+
+static SaAisErrorT checkFilterHeader(SaNtfNotificationFilterHeaderT *nfh) {
+
+ SaUint16T i;
+ for (i = 0; i != nfh->numNotificationObjects; ++i)
+ if (!ntfsv_sanamet_is_valid(&nfh->notificationObjects[i]))
+ return SA_AIS_ERR_INVALID_PARAM;
+ for (i = 0; i != nfh->numNotifyingObjects; ++i)
+ if (!ntfsv_sanamet_is_valid(&nfh->notifyingObjects[i]))
+ return SA_AIS_ERR_INVALID_PARAM;
+
+ return SA_AIS_OK;
+}
+
static SaAisErrorT checkAttributeChangeFilterParameters(ntfa_filter_hdl_rec_t
*attributeChangeFilterData)
{
SaUint16T i;
@@ -72,8 +133,8 @@ static SaAisErrorT checkAttributeChangeF
}
}
- TRACE_1("Returning SA_AIS_OK!");
- return SA_AIS_OK;
+ return checkFilterHeader(&attributeChangeFilterData->notificationFilter.
+
attributeChangeNotificationfilter.notificationFilterHeader);
}
@@ -111,8 +172,8 @@ static SaAisErrorT checkObjectCreateDele
}
}
- TRACE_1("Returning SA_AIS_OK!");
- return SA_AIS_OK;
+ return
checkFilterHeader(&objectCreateDeleteFilterData->notificationFilter.
+
objectCreateDeleteNotificationfilter.notificationFilterHeader);
}
@@ -155,9 +216,8 @@ static SaAisErrorT checkStateChangeFilte
return SA_AIS_ERR_INVALID_PARAM;
}
}
-
- TRACE_1("Returning SA_AIS_OK!");
- return SA_AIS_OK;
+ return checkFilterHeader(&stateChangeFilterData->notificationFilter.
+
stateChangeNotificationfilter.notificationFilterHeader);
}
static SaAisErrorT checkAlarmFilterParameters(ntfa_filter_hdl_rec_t
*alarmFilterData)
@@ -209,8 +269,8 @@ static SaAisErrorT checkAlarmFilterParam
}
}
- TRACE_1("Returning SA_AIS_OK!");
- return SA_AIS_OK;
+ return checkFilterHeader(&alarmFilterData->notificationFilter.
+
alarmNotificationfilter.notificationFilterHeader);
}
static SaAisErrorT checkSecurityAlarmFilterParameters(ntfa_filter_hdl_rec_t
*securityAlarmFilterData)
@@ -260,11 +320,9 @@ static SaAisErrorT checkSecurityAlarmFil
for (i = 0;
i <
securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.numSecurityAlarmDetectors;
i++) {
- if
(securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
- securityAlarmDetectors[i].valueType < SA_NTF_VALUE_UINT8
- ||
securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
- securityAlarmDetectors[i].valueType > SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid PercievedSeverity value = %d",
+ if
(checkNtfValueTypeRange(securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
+
securityAlarmDetectors[i].valueType) != SA_AIS_OK) {
+ TRACE_1("Invalid securityAlarmDetectors value type =
%d",
(int)securityAlarmFilterData->notificationFilter.
securityAlarmNotificationfilter.securityAlarmDetectors[i].valueType);
return SA_AIS_ERR_INVALID_PARAM;
@@ -273,11 +331,9 @@ static SaAisErrorT checkSecurityAlarmFil
for (i = 0; i <
securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.numServiceUsers;
i++) {
- if
(securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
- serviceUsers[i].valueType < SA_NTF_VALUE_UINT8
- ||
securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
- serviceUsers[i].valueType > SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid PercievedSeverity value = %d",
+ if
(checkNtfValueTypeRange(securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
+
serviceUsers[i].valueType) != SA_AIS_OK) {
+ TRACE_1("Invalid serviceUsers value type = %d",
(int)securityAlarmFilterData->notificationFilter.
securityAlarmNotificationfilter.serviceUsers[i].valueType);
return SA_AIS_ERR_INVALID_PARAM;
@@ -286,26 +342,24 @@ static SaAisErrorT checkSecurityAlarmFil
for (i = 0; i <
securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.numServiceProviders;
i++) {
- if
(securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
- serviceProviders[i].valueType < SA_NTF_VALUE_UINT8
- ||
securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
- serviceProviders[i].valueType > SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid PercievedSeverity value = %d",
+ if
(checkNtfValueTypeRange(securityAlarmFilterData->notificationFilter.securityAlarmNotificationfilter.
+
serviceProviders[i].valueType) != SA_AIS_OK) {
+ TRACE_1("Invalid serviceProviders value type = %d",
(int)securityAlarmFilterData->notificationFilter.
securityAlarmNotificationfilter.serviceProviders[i].valueType);
return SA_AIS_ERR_INVALID_PARAM;
}
}
- TRACE_1("Returning SA_AIS_OK!");
- return SA_AIS_OK;
+ return checkFilterHeader(&securityAlarmFilterData->notificationFilter.
+
securityAlarmNotificationfilter.notificationFilterHeader);
}
/* help functions */
-static SaAisErrorT checkHeader(SaNtfNotificationHeaderT *nh)
+static SaAisErrorT checkHeader(v_data *pvdata, SaNtfNotificationHeaderT *nh)
{
int i =0;
-
+ SaAisErrorT rc;
if (!ntfsv_sanamet_is_valid(nh->notificationObject) ||
!ntfsv_sanamet_is_valid(nh->notifyingObject)) {
TRACE_1("SaNameT is invaild");
@@ -313,80 +367,81 @@ static SaAisErrorT checkHeader(SaNtfNoti
}
for(i=0 ; i < nh->numAdditionalInfo ; i++ ) {
- if(nh->additionalInfo[i].infoType < SA_NTF_VALUE_UINT8 ||
- nh->additionalInfo[i].infoType > SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid numAdditionalInfo type value");
+ if ((rc = checkNtfValue(pvdata,
+
nh->additionalInfo[i].infoType,
+
&nh->additionalInfo[i].infoValue)) != SA_AIS_OK)
+ return rc;
+ }
+
+ return SA_AIS_OK;
+}
+
+static SaAisErrorT checkAlarmParameters(ntfa_notification_hdl_rec_t
*not_hdl_rec, v_data *pvdata)
+{
+ int i = 0;
+ SaNtfAlarmNotificationT *notification =
¬_hdl_rec->ntfNotification.ntfAlarmNotification;
+ if (*notification->probableCause < SA_NTF_ADAPTER_ERROR ||
+ *notification->probableCause > SA_NTF_UNSPECIFIED_REASON) {
+ TRACE_1("Invalid probableCause value");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
+
+ if (*notification->perceivedSeverity < SA_NTF_SEVERITY_CLEARED ||
+ *notification->perceivedSeverity > SA_NTF_SEVERITY_CRITICAL) {
+ TRACE_1("Invalid perceivedSeverity value");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
+
+ if (*notification->trend < SA_NTF_TREND_MORE_SEVERE ||
+ *notification->trend > SA_NTF_TREND_LESS_SEVERE) {
+ TRACE_1("Invalid trend value");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
+
+ for (i = 0; i < notification->numSpecificProblems; i++) {
+ if (checkNtfValue(pvdata
+ ,
notification->specificProblems[i].problemType
+ ,
¬ification->specificProblems[i].problemValue) != SA_AIS_OK) {
+ TRACE_1("Invalid specificProblems");
return SA_AIS_ERR_INVALID_PARAM;
}
}
- return SA_AIS_OK;
-}
-
-static SaAisErrorT checkAlarmParameters(SaNtfAlarmNotificationT
*alarmNotification)
-{
- int i = 0;
-
- if (*alarmNotification->probableCause < SA_NTF_ADAPTER_ERROR ||
- *alarmNotification->probableCause > SA_NTF_UNSPECIFIED_REASON) {
- TRACE_1("Invalid probableCause value");
- return SA_AIS_ERR_INVALID_PARAM;
+ for (i = 0; i < notification->numMonitoredAttributes; i++) {
+ if (checkNtfValue(pvdata
+ ,
notification->monitoredAttributes[i].attributeType
+ ,
¬ification->monitoredAttributes[i].attributeValue) != SA_AIS_OK) {
+ TRACE_1("Invalid monitoredAttributes");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
}
- if (*alarmNotification->perceivedSeverity < SA_NTF_SEVERITY_CLEARED ||
- *alarmNotification->perceivedSeverity > SA_NTF_SEVERITY_CRITICAL) {
- TRACE_1("Invalid perceivedSeverity value");
- return SA_AIS_ERR_INVALID_PARAM;
+ for (i = 0; i < notification->numProposedRepairActions; i++) {
+ if (checkNtfValue(pvdata
+ ,
notification->proposedRepairActions[i].actionValueType
+ ,
¬ification->proposedRepairActions[i].actionValue) != SA_AIS_OK) {
+ TRACE_1("Invalid proposedRepairActions");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
}
- if (*alarmNotification->trend < SA_NTF_TREND_MORE_SEVERE ||
- *alarmNotification->trend > SA_NTF_TREND_LESS_SEVERE) {
- TRACE_1("Invalid trend value");
- return SA_AIS_ERR_INVALID_PARAM;
- }
-
- for (i = 0; i < alarmNotification->numSpecificProblems; i++) {
- if (alarmNotification->specificProblems[i].problemType <
SA_NTF_VALUE_UINT8 ||
- alarmNotification->specificProblems[i].problemType >
SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid specific problem type value");
- return SA_AIS_ERR_INVALID_PARAM;
- }
- }
-
- for (i = 0; i < alarmNotification->numMonitoredAttributes; i++) {
- if (alarmNotification->monitoredAttributes[i].attributeType <
SA_NTF_VALUE_UINT8 ||
- alarmNotification->monitoredAttributes[i].attributeType >
SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid monitoredAttributes type value");
- return SA_AIS_ERR_INVALID_PARAM;
- }
- }
-
- for (i = 0; i < alarmNotification->numProposedRepairActions; i++) {
- if (alarmNotification->proposedRepairActions[i].actionValueType
< SA_NTF_VALUE_UINT8 ||
- alarmNotification->proposedRepairActions[i].actionValueType
> SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid proposedRepairActions type value");
- return SA_AIS_ERR_INVALID_PARAM;
- }
- }
-
- if(alarmNotification->thresholdInformation->thresholdValueType <
SA_NTF_VALUE_UINT8 ||
- alarmNotification->thresholdInformation->thresholdValueType >
SA_NTF_VALUE_ARRAY) {
+
if(checkNtfValueTypeRange(notification->thresholdInformation->thresholdValueType)
!= SA_AIS_OK) {
TRACE_1("Invalid thresholdInformation type value");
return SA_AIS_ERR_INVALID_PARAM;
}
- if (*alarmNotification->notificationHeader.eventType <
SA_NTF_ALARM_NOTIFICATIONS_START ||
- *alarmNotification->notificationHeader.eventType >
SA_NTF_ALARM_ENVIRONMENT) {
- TRACE_1("Invalid eventType value = %d",
(int)*alarmNotification->notificationHeader.eventType);
+ if (*notification->notificationHeader.eventType <
SA_NTF_ALARM_NOTIFICATIONS_START ||
+ *notification->notificationHeader.eventType >
SA_NTF_ALARM_ENVIRONMENT) {
+ TRACE_1("Invalid eventType value = %d",
(int)*notification->notificationHeader.eventType);
return SA_AIS_ERR_INVALID_PARAM;
}
- return checkHeader(&alarmNotification->notificationHeader);
+ return checkHeader(pvdata, ¬ification->notificationHeader);
}
-static SaAisErrorT
checkSecurityAlarmParameters(SaNtfSecurityAlarmNotificationT *notification)
+static SaAisErrorT checkSecurityAlarmParameters(ntfa_notification_hdl_rec_t
*not_hdl_rec, v_data *pvdata)
{
-
+ SaNtfSecurityAlarmNotificationT *notification =
¬_hdl_rec->ntfNotification.ntfSecurityAlarmNotification;
if (*notification->notificationHeader.eventType <
SA_NTF_SECURITY_ALARM_NOTIFICATIONS_START ||
*notification->notificationHeader.eventType >
SA_NTF_TIME_VIOLATION) {
TRACE_1("Invalid eventType value");
@@ -399,23 +454,39 @@ static SaAisErrorT checkSecurityAlarmPar
return SA_AIS_ERR_INVALID_PARAM;
}
- if (notification->securityAlarmDetector->valueType < SA_NTF_VALUE_UINT8
||
- notification->securityAlarmDetector->valueType >
SA_NTF_VALUE_ARRAY) {
- TRACE_1("Invalid securityAlarmDetector valueType");
+ if (checkNtfValue(pvdata
+ ,
notification->securityAlarmDetector->valueType
+ ,
¬ification->securityAlarmDetector->value) != SA_AIS_OK) {
+ TRACE_1("Invalid securityAlarmDetector");
return SA_AIS_ERR_INVALID_PARAM;
}
+ if (checkNtfValue(pvdata
+ ,
notification->serviceUser->valueType
+ ,
¬ification->serviceUser->value) != SA_AIS_OK) {
+ TRACE_1("Invalid serviceUser");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
+
+ if (checkNtfValue(pvdata
+ ,
notification->serviceProvider->valueType
+ ,
¬ification->serviceProvider->value) != SA_AIS_OK) {
+ TRACE_1("Invalid serviceProvider");
+ return SA_AIS_ERR_INVALID_PARAM;
+ }
+
if (*notification->severity < SA_NTF_SEVERITY_CLEARED ||
*notification->severity > SA_NTF_SEVERITY_CRITICAL) {
TRACE_1("Invalid Severity value");
return SA_AIS_ERR_INVALID_PARAM;
}
- return checkHeader(¬ification->notificationHeader);
+ return checkHeader(pvdata, ¬ification->notificationHeader);
}
-static SaAisErrorT checkStateChangeParameters(SaNtfStateChangeNotificationT
*notification)
+static SaAisErrorT checkStateChangeParameters(ntfa_notification_hdl_rec_t
*not_hdl_rec, v_data *pvdata)
{
int i;
+ SaNtfStateChangeNotificationT *notification =
¬_hdl_rec->ntfNotification.ntfStateChangeNotification;
if (*notification->notificationHeader.eventType <
SA_NTF_STATE_CHANGE_NOTIFICATIONS_START ||
(*notification->notificationHeader.eventType >
SA_NTF_OBJECT_STATE_CHANGE &&
*notification->notificationHeader.eventType <
SA_NTF_MISCELLANEOUS_NOTIFICATIONS_START) ||
@@ -435,12 +506,13 @@ static SaAisErrorT checkStateChangeParam
if (sp != SA_FALSE && sp != SA_TRUE)
return SA_AIS_ERR_INVALID_PARAM;
}
- return checkHeader(¬ification->notificationHeader);
+ return checkHeader(pvdata, ¬ification->notificationHeader);
}
-static SaAisErrorT
checkAttributeChangeParameters(SaNtfAttributeChangeNotificationT *notification)
+static SaAisErrorT checkAttributeChangeParameters(ntfa_notification_hdl_rec_t
*not_hdl_rec, v_data *pvdata)
{
int i;
+ SaNtfAttributeChangeNotificationT *notification =
¬_hdl_rec->ntfNotification.ntfAttributeChangeNotification;
if (*notification->notificationHeader.eventType <
SA_NTF_ATTRIBUTE_NOTIFICATIONS_START ||
*notification->notificationHeader.eventType >
SA_NTF_ATTRIBUTE_RESET) {
TRACE_1("Invalid eventType value");
@@ -457,18 +529,17 @@ static SaAisErrorT checkAttributeChangeP
SaBoolT sp =
notification->changedAttributes[i].oldAttributePresent;
if (sp != SA_FALSE && sp != SA_TRUE)
return SA_AIS_ERR_INVALID_PARAM;
- if(notification->changedAttributes[i].attributeType <
SA_NTF_VALUE_UINT8 ||
- notification->changedAttributes[i].attributeType >
SA_NTF_VALUE_ARRAY)
+
if(checkNtfValueTypeRange(notification->changedAttributes[i].attributeType) !=
SA_AIS_OK)
return SA_AIS_ERR_INVALID_PARAM;
}
- return checkHeader(¬ification->notificationHeader);
+ return checkHeader(pvdata, ¬ification->notificationHeader);
}
-static SaAisErrorT
checkObjectCreateDeleteParameters(SaNtfObjectCreateDeleteNotificationT
*notification)
+static SaAisErrorT
checkObjectCreateDeleteParameters(ntfa_notification_hdl_rec_t *not_hdl_rec,
v_data *pvdata)
{
int i = 0;
-
+ SaNtfObjectCreateDeleteNotificationT *notification =
¬_hdl_rec->ntfNotification.ntfObjectCreateDeleteNotification;
if (*notification->notificationHeader.eventType <
SA_NTF_OBJECT_NOTIFICATIONS_START ||
*notification->notificationHeader.eventType >
SA_NTF_OBJECT_DELETION) {
TRACE_1("Invalid eventType value");
@@ -482,14 +553,13 @@ static SaAisErrorT checkObjectCreateDele
}
for (i = 0; i < notification->numAttributes; i++) {
- if (notification->objectAttributes[i].attributeType <
SA_NTF_VALUE_UINT8 ||
- notification->objectAttributes[i].attributeType >
SA_NTF_VALUE_ARRAY) {
+ if
(checkNtfValueTypeRange(notification->objectAttributes[i].attributeType) !=
SA_AIS_OK) {
TRACE_1("Invalid attributeType value");
return SA_AIS_ERR_INVALID_PARAM;
}
}
- return checkHeader(¬ification->notificationHeader);
+ return checkHeader(pvdata, ¬ification->notificationHeader);
}
/**
@@ -1228,7 +1298,8 @@ SaAisErrorT saNtfNotificationSend(SaNtfN
msg.info.api_info.param.send_notification = send_param;
send_param->client_id = client_rec->ntfs_client_id;
send_param->notificationType =
notification_hdl_rec->ntfNotificationType;
-
+ ntfsv_v_data_cp(&send_param->variable_data,
¬ification_hdl_rec->variable_data);
+
osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0);
/* Check parameters, depending on type */
switch (notification_hdl_rec->ntfNotificationType) {
@@ -1237,36 +1308,34 @@ SaAisErrorT saNtfNotificationSend(SaNtfN
/* TODO: assign send_param for all */
send_param->notification.alarm =
notification_hdl_rec->ntfNotification.ntfAlarmNotification;
ntfHeader =
¬ification_hdl_rec->ntfNotification.ntfAlarmNotification.notificationHeader;
- rc =
checkAlarmParameters(¬ification_hdl_rec->ntfNotification.ntfAlarmNotification);
+ rc = checkAlarmParameters(notification_hdl_rec,
&send_param->variable_data);
break;
case SA_NTF_TYPE_SECURITY_ALARM:
TRACE_1("Checking Security Alarm Notification Parameters");
send_param->notification.securityAlarm =
notification_hdl_rec->ntfNotification.ntfSecurityAlarmNotification;
ntfHeader =
¬ification_hdl_rec->ntfNotification.ntfSecurityAlarmNotification.notificationHeader;
- rc =
checkSecurityAlarmParameters(¬ification_hdl_rec->ntfNotification.ntfSecurityAlarmNotification);
+ rc = checkSecurityAlarmParameters(notification_hdl_rec,
&send_param->variable_data);
break;
case SA_NTF_TYPE_STATE_CHANGE:
TRACE_1("Checking State Change Notification Parameters");
send_param->notification.stateChange =
notification_hdl_rec->ntfNotification.ntfStateChangeNotification;
ntfHeader =
¬ification_hdl_rec->ntfNotification.ntfStateChangeNotification.notificationHeader;
- rc =
checkStateChangeParameters(¬ification_hdl_rec->ntfNotification.ntfStateChangeNotification);
+ rc = checkStateChangeParameters(notification_hdl_rec,
&send_param->variable_data);
break;
case SA_NTF_TYPE_ATTRIBUTE_CHANGE:
TRACE_1("Checking Attribute Change Notification Parameters");
send_param->notification.attributeChange =
notification_hdl_rec->ntfNotification.ntfAttributeChangeNotification;
ntfHeader =
¬ification_hdl_rec->ntfNotification.ntfAttributeChangeNotification.notificationHeader;
- rc =
checkAttributeChangeParameters(¬ification_hdl_rec->ntfNotification.
-
ntfAttributeChangeNotification);
+ rc = checkAttributeChangeParameters(notification_hdl_rec,
&send_param->variable_data);
break;
case SA_NTF_TYPE_OBJECT_CREATE_DELETE:
TRACE_1("Checking Object Create/Delete Notification
Parameters");
send_param->notification.objectCreateDelete =
notification_hdl_rec->ntfNotification.ntfObjectCreateDeleteNotification;
ntfHeader =
¬ification_hdl_rec->ntfNotification.ntfObjectCreateDeleteNotification.notificationHeader;
- rc =
checkObjectCreateDeleteParameters(¬ification_hdl_rec->ntfNotification.
-
ntfObjectCreateDeleteNotification);
+ rc = checkObjectCreateDeleteParameters(notification_hdl_rec,
&send_param->variable_data);
break;
default:
TRACE_1("Unkown notification type");
@@ -1278,7 +1347,6 @@ SaAisErrorT saNtfNotificationSend(SaNtfN
TRACE_1("Invalid parameter");
goto done_give_hdls;
}
-
rc = fillSendStruct(ntfHeader, send_param);
if (rc != SA_AIS_OK) {
goto done_give_hdls;
@@ -1290,33 +1358,7 @@ SaAisErrorT saNtfNotificationSend(SaNtfN
rc = SA_AIS_ERR_TRY_AGAIN;
goto done_give_hdls;
}
- send_param->variable_data = notification_hdl_rec->variable_data;
- SaUint16T i = 0;
- for(i=0 ; i < ntfHeader->numAdditionalInfo ; i++ ) {
- if (ntfHeader->additionalInfo[i].infoType ==
SA_NTF_VALUE_LDAP_NAME) {
- SaNameT *ptr = send_param->variable_data.p_base +
-
ntfHeader->additionalInfo[i].infoValue.ptrVal.dataOffset;
- if (!ntfsv_sanamet_is_valid(ptr)) {
- rc = SA_AIS_ERR_INVALID_PARAM;
- goto done_give_hdls;
- }
- if (osaf_is_an_extended_name(ptr)) {
- size_t length_to_copy;
- void *p;
- if
(ntfHeader->additionalInfo[i].infoValue.ptrVal.dataSize
- <
(osaf_extended_name_length(ptr) + 2)) {
- LOG_ER("The allocated memory is not
large enough,"
- " the object will be
truncated (%s)"
- ,
osaf_extended_name_borrow(ptr));
- length_to_copy =
ntfHeader->additionalInfo[i].infoValue.ptrVal.dataSize - 2;
- } else
- length_to_copy =
osaf_extended_name_length(ptr);
- p = send_param->variable_data.p_base +
-
ntfHeader->additionalInfo[i].infoValue.ptrVal.dataOffset + 2;
- memcpy(p, osaf_extended_name_borrow(ptr),
length_to_copy);
- }
- }
- }
+
osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0);
/* Send a sync MDS message to obtain a notification id */
mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, &o_msg, timeout);
@@ -1392,6 +1434,8 @@ SaAisErrorT saNtfNotificationSend(SaNtfN
done_give_hdl:
ncshm_give_hdl(notificationHandle);
err_free:
+ if (send_param->variable_data.p_base != NULL)
+ free(send_param->variable_data.p_base);
free(send_param);
done:
TRACE_LEAVE();
@@ -2854,7 +2898,7 @@ SaAisErrorT saNtfNotificationReadNext(Sa
uint32_t timeout = NTFS_WAIT_TIME;
ntfsv_send_not_req_t *read_not = NULL;
ntfa_notification_hdl_rec_t *notification_hdl_rec = NULL;
-
+ SaNtfNotificationHeaderT *read_not_header = NULL;
TRACE_ENTER();
if(searchDirection < SA_NTF_SEARCH_OLDER || searchDirection >
SA_NTF_SEARCH_YOUNGER) {
@@ -2902,26 +2946,47 @@ SaAisErrorT saNtfNotificationReadNext(Sa
goto done_give_hdls;
}
- /* Send a sync MDS message */
- rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, &o_msg, timeout);
- if (rc != NCSCC_RC_SUCCESS) {
- rc = SA_AIS_ERR_TRY_AGAIN;
- goto done_give_hdls;
- }
-
- osafassert(o_msg != NULL);
- if (SA_AIS_OK != o_msg->info.api_resp_info.rc) {
- rc = o_msg->info.api_resp_info.rc;
- TRACE("error: response msg rc = %d", rc);
- goto done_give_hdls;
- }
- if (o_msg->info.api_resp_info.type != NTFSV_READ_NEXT_RSP) {
- TRACE("msg type (%d) failed",
(int)o_msg->info.api_resp_info.type);
- rc = SA_AIS_ERR_LIBRARY;
- goto done_give_hdls;
- }
-
- read_not =
o_msg->info.api_resp_info.param.read_next_rsp.readNotification;
+ do {
+ /* Send a sync MDS message */
+ rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, &o_msg, timeout);
+ if (rc != NCSCC_RC_SUCCESS) {
+ rc = SA_AIS_ERR_TRY_AGAIN;
+ goto done_give_hdls;
+ }
+
+ osafassert(o_msg != NULL);
+ if (SA_AIS_OK != o_msg->info.api_resp_info.rc) {
+ rc = o_msg->info.api_resp_info.rc;
+ TRACE("error: response msg rc = %d", rc);
+ goto done_give_hdls;
+ }
+ if (o_msg->info.api_resp_info.type != NTFSV_READ_NEXT_RSP) {
+ TRACE("msg type (%d) failed",
(int)o_msg->info.api_resp_info.type);
+ rc = SA_AIS_ERR_LIBRARY;
+ goto done_give_hdls;
+ }
+
+ read_not =
o_msg->info.api_resp_info.param.read_next_rsp.readNotification;
+ if (read_not->notificationType == SA_NTF_TYPE_ALARM)
+ read_not_header =
&read_not->notification.alarm.notificationHeader;
+ else if (read_not->notificationType ==
SA_NTF_TYPE_SECURITY_ALARM)
+ read_not_header =
&read_not->notification.securityAlarm.notificationHeader;
+ else {
+ TRACE_1("Notification type (%d) is not alarm!",
(int)read_not->notificationType);
+ rc = SA_AIS_ERR_NOT_SUPPORTED;
+ goto done_give_hdls;
+ }
+
+ /* Skip notification having longDns if this is unadapted
longDns consumer,
+ * continue reading next. Otherwise, any return code differs
SA_AIS_OK may stop
+ * the consumer reading then miss out the remaining
notifications (shortDns)
+ */
+ if
(!ntfsv_sanamet_is_valid(read_not_header->notificationObject)
+ ||
!ntfsv_sanamet_is_valid(read_not_header->notifyingObject)) {
+ ntfa_msg_destroy(o_msg);
+ } else
+ break;
+ } while (1);
/* Only alarm supported */
if (read_not->notificationType == SA_NTF_TYPE_ALARM) {
@@ -2996,9 +3061,6 @@ SaAisErrorT saNtfNotificationReadNext(Sa
ntfsv_copy_ntf_security_alarm(¬ification->notification.securityAlarmNotification,
&read_not->notification.securityAlarm);
osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0);
- } else {
- TRACE_1("Notification type (%d) is not alarm!",
(int)read_not->notificationType);
- rc = SA_AIS_ERR_NOT_SUPPORTED;
}
done_give_hdls:
diff --git a/osaf/libs/agents/saf/ntfa/ntfa_util.c
b/osaf/libs/agents/saf/ntfa/ntfa_util.c
--- a/osaf/libs/agents/saf/ntfa/ntfa_util.c
+++ b/osaf/libs/agents/saf/ntfa/ntfa_util.c
@@ -137,10 +137,16 @@ static SaAisErrorT ntfa_alloc_callback_n
SaAisErrorT rc = SA_AIS_OK;
ntfa_notification_hdl_rec_t *notification_hdl_rec;
notification->notificationType = not_cbk->notificationType;
-
+ SaNtfNotificationHeaderT *not_cbk_header;
switch (not_cbk->notificationType) {
case SA_NTF_TYPE_OBJECT_CREATE_DELETE:
TRACE_2("type: SA_NTF_TYPE_OBJECT_CREATE_DELETE");
+ not_cbk_header =
¬_cbk->notification.objectCreateDelete.notificationHeader;
+ if (!ntfsv_sanamet_is_valid(not_cbk_header->notificationObject)
+ ||
!ntfsv_sanamet_is_valid(not_cbk_header->notifyingObject)) {
+ rc = SA_AIS_ERR_NAME_TOO_LONG;
+ break;
+ }
rc =
saNtfObjectCreateDeleteNotificationAllocate(hdl_rec->local_hdl,
¬ification->notification.
objectCreateDeleteNotification,
@@ -175,6 +181,12 @@ static SaAisErrorT ntfa_alloc_callback_n
break;
case SA_NTF_TYPE_ATTRIBUTE_CHANGE:
TRACE_2("type: SA_NTF_TYPE_ATTRIBUTE_CHANGE");
+ not_cbk_header =
¬_cbk->notification.attributeChange.notificationHeader;
+ if (!ntfsv_sanamet_is_valid(not_cbk_header->notificationObject)
+ ||
!ntfsv_sanamet_is_valid(not_cbk_header->notifyingObject)) {
+ rc = SA_AIS_ERR_NAME_TOO_LONG;
+ break;
+ }
rc =
saNtfAttributeChangeNotificationAllocate(hdl_rec->local_hdl,
¬ification->notification.attributeChangeNotification,
not_cbk->notification.attributeChange.notificationHeader.
@@ -208,6 +220,12 @@ static SaAisErrorT ntfa_alloc_callback_n
break;
case SA_NTF_TYPE_STATE_CHANGE:
TRACE_2("type: SA_NTF_TYPE_STATE_CHANGE");
+ not_cbk_header =
¬_cbk->notification.stateChange.notificationHeader;
+ if (!ntfsv_sanamet_is_valid(not_cbk_header->notificationObject)
+ ||
!ntfsv_sanamet_is_valid(not_cbk_header->notifyingObject)) {
+ rc = SA_AIS_ERR_NAME_TOO_LONG;
+ break;
+ }
rc = saNtfStateChangeNotificationAllocate(hdl_rec->local_hdl,
¬ification->notification.stateChangeNotification,
not_cbk->notification.stateChange.notificationHeader.
@@ -240,6 +258,13 @@ static SaAisErrorT ntfa_alloc_callback_n
}
break;
case SA_NTF_TYPE_ALARM:
+ TRACE_2("type: SA_NTF_TYPE_ALARM");
+ not_cbk_header =
¬_cbk->notification.alarm.notificationHeader;
+ if (!ntfsv_sanamet_is_valid(not_cbk_header->notificationObject)
+ ||
!ntfsv_sanamet_is_valid(not_cbk_header->notifyingObject)) {
+ rc = SA_AIS_ERR_NAME_TOO_LONG;
+ break;
+ }
rc = saNtfAlarmNotificationAllocate(hdl_rec->local_hdl,
¬ification->notification.alarmNotification,
not_cbk->notification.alarm.
@@ -273,6 +298,12 @@ static SaAisErrorT ntfa_alloc_callback_n
break;
case SA_NTF_TYPE_SECURITY_ALARM:
TRACE_2("type: SA_NTF_TYPE_SECURITY_ALARM");
+ not_cbk_header =
¬_cbk->notification.securityAlarm.notificationHeader;
+ if (!ntfsv_sanamet_is_valid(not_cbk_header->notificationObject)
+ ||
!ntfsv_sanamet_is_valid(not_cbk_header->notifyingObject)) {
+ rc = SA_AIS_ERR_NAME_TOO_LONG;
+ break;
+ }
rc = saNtfSecurityAlarmNotificationAllocate(hdl_rec->local_hdl,
¬ification->notification.securityAlarmNotification,
not_cbk->notification.securityAlarm.notificationHeader.
diff --git a/osaf/libs/common/ntfsv/ntfsv_enc_dec.c
b/osaf/libs/common/ntfsv/ntfsv_enc_dec.c
--- a/osaf/libs/common/ntfsv/ntfsv_enc_dec.c
+++ b/osaf/libs/common/ntfsv/ntfsv_enc_dec.c
@@ -218,12 +218,11 @@ static uint32_t encodeSaNtfAttribute(NCS
return rv;
}
-static uint32_t decodeNtfValueT(NCS_UBAID *uba, SaNtfValueTypeT attributeType,
SaNtfValueT *ntfAttr)
+static uint32_t decodeNtfValueT(NCS_UBAID *uba, SaNtfValueTypeT attributeType,
SaNtfValueT *ntfAttr, bool checkExtLdapName)
{
uint8_t *p8;
uint8_t local_data[8];
binfl_t bf_val;
-
switch (attributeType) {
case SA_NTF_VALUE_UINT8:
p8 = ncs_dec_flatten_space(uba, local_data, 1);
@@ -301,6 +300,21 @@ static uint32_t decodeNtfValueT(NCS_UBAI
default:
TRACE_2("attributeType %d not valid", (int)attributeType);
}
+
+ if (checkExtLdapName && attributeType == SA_NTF_VALUE_LDAP_NAME) {
+ if (!osaf_is_extended_names_enabled()
+ && ntfAttr->ptrVal.dataSize >
SA_MAX_UNEXTENDED_NAME_LENGTH + 2) {
+ LOG_ER("Environment variable SA_ENABLE_EXTENDED_NAMES "
+ "is not set, or not using extended name
api");
+ ntfAttr->ptrVal.dataSize = 0;
+ }
+ if (ntfAttr->ptrVal.dataSize > kOsafMaxDnLength + 2) {
+ LOG_ER("Exceeding maximum of extended name length(%u)"
+ ,kOsafMaxDnLength);
+ ntfAttr->ptrVal.dataSize = 0;
+ }
+ }
+
return NCSCC_RC_SUCCESS;
}
@@ -314,9 +328,9 @@ static uint32_t decodeSaNtfAttributeChan
ntfAttr->oldAttributePresent = ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 8);
if (ntfAttr->oldAttributePresent) {
- rv = decodeNtfValueT(uba, ntfAttr->attributeType,
&ntfAttr->oldAttributeValue);
+ rv = decodeNtfValueT(uba, ntfAttr->attributeType,
&ntfAttr->oldAttributeValue, false);
}
- rv = decodeNtfValueT(uba, ntfAttr->attributeType,
&ntfAttr->newAttributeValue);
+ rv = decodeNtfValueT(uba, ntfAttr->attributeType,
&ntfAttr->newAttributeValue, false);
return rv;
}
@@ -329,7 +343,7 @@ static uint32_t decodeSaNtfAttribute(NCS
ntfAttr->attributeId = ncs_decode_16bit(&p8);
ntfAttr->attributeType = ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 4);
- rv = decodeNtfValueT(uba, ntfAttr->attributeType,
&ntfAttr->attributeValue);
+ rv = decodeNtfValueT(uba, ntfAttr->attributeType,
&ntfAttr->attributeValue, false);
return rv;
}
@@ -839,7 +853,7 @@ static uint32_t ntfsv_dec_not_header(NCS
param->additionalInfo[i].infoId = ncs_decode_16bit(&p8);
param->additionalInfo[i].infoType = ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 4);
- rv = decodeNtfValueT(uba, param->additionalInfo[i].infoType,
¶m->additionalInfo[i].infoValue);
+ rv = decodeNtfValueT(uba, param->additionalInfo[i].infoType,
¶m->additionalInfo[i].infoValue, true);
TRACE_2("dec additionalInfo Type: %d\n",
param->additionalInfo[i].infoType);
TRACE_2("dec additionaInfo Value int32: %d\n",
param->additionalInfo[i].infoValue.int32Val);
}
@@ -887,13 +901,16 @@ uint32_t ntfsv_dec_not_msg(NCS_UBAID *ub
ncs_dec_skip_space(uba, 12);
rv = decodeNtfValueT(uba,
param->notification.alarm.thresholdInformation->thresholdValueType,
-
¶m->notification.alarm.thresholdInformation->thresholdValue);
+
¶m->notification.alarm.thresholdInformation->thresholdValue,
+ false);
rv = decodeNtfValueT(uba,
param->notification.alarm.thresholdInformation->thresholdValueType,
-
¶m->notification.alarm.thresholdInformation->thresholdHysteresis);
+
¶m->notification.alarm.thresholdInformation->thresholdHysteresis,
+ false);
rv = decodeNtfValueT(uba,
param->notification.alarm.thresholdInformation->thresholdValueType,
-
¶m->notification.alarm.thresholdInformation->observedValue);
+
¶m->notification.alarm.thresholdInformation->observedValue,
+ false);
for (i = 0; i < param->notification.alarm.numSpecificProblems;
i++) {
p8 = ncs_dec_flatten_space(uba, local_data, 12);
param->notification.alarm.specificProblems[i].problemId
= ncs_decode_16bit(&p8);
@@ -904,7 +921,8 @@ uint32_t ntfsv_dec_not_msg(NCS_UBAID *ub
ncs_dec_skip_space(uba, 12);
rv = decodeNtfValueT(uba,
param->notification.alarm.specificProblems[i].problemType,
-
¶m->notification.alarm.specificProblems[i].problemValue);
+
¶m->notification.alarm.specificProblems[i].problemValue,
+ true);
}
for (i = 0; i <
param->notification.alarm.numMonitoredAttributes; i++) {
p8 = ncs_dec_flatten_space(uba, local_data, 4);
@@ -913,7 +931,8 @@ uint32_t ntfsv_dec_not_msg(NCS_UBAID *ub
ncs_dec_skip_space(uba, 4);
rv = decodeNtfValueT(uba,
param->notification.alarm.monitoredAttributes[i].attributeType,
-
¶m->notification.alarm.monitoredAttributes[i].attributeValue);
+
¶m->notification.alarm.monitoredAttributes[i].attributeValue,
+ true);
}
for (i = 0; i <
param->notification.alarm.numProposedRepairActions; i++) {
p8 = ncs_dec_flatten_space(uba, local_data, 4);
@@ -921,9 +940,9 @@ uint32_t ntfsv_dec_not_msg(NCS_UBAID *ub
param->notification.alarm.proposedRepairActions[i].actionValueType =
ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 4);
rv = decodeNtfValueT(uba,
-
param->notification.alarm.proposedRepairActions[i].
- actionValueType,
-
¶m->notification.alarm.proposedRepairActions[i].actionValue);
+
param->notification.alarm.proposedRepairActions[i].actionValueType,
+
¶m->notification.alarm.proposedRepairActions[i].actionValue,
+ true);
}
break;
@@ -941,8 +960,7 @@ uint32_t ntfsv_dec_not_msg(NCS_UBAID *ub
if (param->notification.objectCreateDelete.numAttributes > 0) {
for (i = 0; i <
param->notification.objectCreateDelete.numAttributes; i++) {
- rv =
- decodeSaNtfAttribute(uba,
+ rv = decodeSaNtfAttribute(uba,
¶m->notification.objectCreateDelete.objectAttributes[i]);
}
ntfsv_print_object_attributes(param->notification.objectCreateDelete.objectAttributes,
@@ -1000,20 +1018,22 @@ uint32_t ntfsv_dec_not_msg(NCS_UBAID *ub
ncs_dec_skip_space(uba, 10);
rv = decodeNtfValueT(uba,
param->notification.securityAlarm.securityAlarmDetector->valueType,
-
¶m->notification.securityAlarm.securityAlarmDetector->value);
+
¶m->notification.securityAlarm.securityAlarmDetector->value,
+ true);
p8 = ncs_dec_flatten_space(uba, local_data, 2);
param->notification.securityAlarm.serviceUser->valueType =
ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 2);
rv = decodeNtfValueT(uba,
param->notification.securityAlarm.serviceUser->valueType,
-
¶m->notification.securityAlarm.serviceUser->value);
+
¶m->notification.securityAlarm.serviceUser->value,
+ true);
p8 = ncs_dec_flatten_space(uba, local_data, 2);
param->notification.securityAlarm.serviceProvider->valueType =
ncs_decode_16bit(&p8);
ncs_dec_skip_space(uba, 2);
rv = decodeNtfValueT(uba,
param->notification.securityAlarm.serviceProvider->valueType,
-
¶m->notification.securityAlarm.serviceProvider->value);
-
+
¶m->notification.securityAlarm.serviceProvider->value,
+ true);
break;
default:
TRACE("notificationType not valid");
@@ -1547,7 +1567,10 @@ static uint32_t ntfsv_dec_filter_msg(NCS
p8 = ncs_dec_flatten_space(uba, local_data, 4);
f_rec->sec_al_filter->securityAlarmDetectors[i].valueType =
ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
- rv = decodeNtfValueT(uba,
f_rec->sec_al_filter->securityAlarmDetectors[i].valueType,
&f_rec->sec_al_filter->securityAlarmDetectors[i].value);
+ rv = decodeNtfValueT(uba,
+
f_rec->sec_al_filter->securityAlarmDetectors[i].valueType,
+
&f_rec->sec_al_filter->securityAlarmDetectors[i].value,
+ false);
if (rv != NCSCC_RC_SUCCESS)
goto error_free;
}
@@ -1555,7 +1578,10 @@ static uint32_t ntfsv_dec_filter_msg(NCS
p8 = ncs_dec_flatten_space(uba, local_data, 4);
f_rec->sec_al_filter->serviceProviders[i].valueType =
ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
- rv = decodeNtfValueT(uba,
f_rec->sec_al_filter->serviceProviders[i].valueType,
&f_rec->sec_al_filter->serviceProviders[i].value);
+ rv = decodeNtfValueT(uba,
+
f_rec->sec_al_filter->serviceProviders[i].valueType,
+
&f_rec->sec_al_filter->serviceProviders[i].value,
+ false);
if (rv != NCSCC_RC_SUCCESS)
goto error_free;
}
@@ -1563,7 +1589,10 @@ static uint32_t ntfsv_dec_filter_msg(NCS
p8 = ncs_dec_flatten_space(uba, local_data, 4);
f_rec->sec_al_filter->serviceUsers[i].valueType =
ncs_decode_32bit(&p8);
ncs_dec_skip_space(uba, 4);
- rv = decodeNtfValueT(uba,
f_rec->sec_al_filter->serviceUsers[i].valueType,
&f_rec->sec_al_filter->serviceUsers[i].value);
+ rv = decodeNtfValueT(uba,
+
f_rec->sec_al_filter->serviceUsers[i].valueType,
+
&f_rec->sec_al_filter->serviceUsers[i].value,
+ false);
if (rv != NCSCC_RC_SUCCESS)
goto error_free;
}
diff --git a/osaf/libs/common/ntfsv/ntfsv_mem.c
b/osaf/libs/common/ntfsv/ntfsv_mem.c
--- a/osaf/libs/common/ntfsv/ntfsv_mem.c
+++ b/osaf/libs/common/ntfsv/ntfsv_mem.c
@@ -822,6 +822,7 @@ SaAisErrorT ntfsv_ptr_val_alloc(v_data *
nv->ptrVal.dataOffset = vd->size;
nv->ptrVal.dataSize = data_size;
*data_ptr = vd->p_base + vd->size;
+ memset(*data_ptr, 0, data_size);
vd->size += data_size;
} else {
TRACE("SA_AIS_ERR_NO_SPACE\n");
------------------------------------------------------------------------------
Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer
Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports
Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper
Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer
http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk
_______________________________________________
Opensaf-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
