diff options
Diffstat (limited to 'nsframework/framework_unified/client/NS_NPServiceIf/src')
3 files changed, 1707 insertions, 0 deletions
diff --git a/nsframework/framework_unified/client/NS_NPServiceIf/src/makefile_PosixBasedOS001 b/nsframework/framework_unified/client/NS_NPServiceIf/src/makefile_PosixBasedOS001 new file mode 100644 index 00000000..cbfc140f --- /dev/null +++ b/nsframework/framework_unified/client/NS_NPServiceIf/src/makefile_PosixBasedOS001 @@ -0,0 +1,208 @@ +# +# @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# +# Standard Module Makefile version 2.0 +# + +# Name of the componet (team/domain prefix '_' component name) +COMPONENT_NAME = NS_NPServiceIf + +ifndef PRJ_ROOT +export PRJ_ROOT = $(CURDIR)/../ +endif +include $(PRJ_ROOT)cfg/depends.mk + +# Name of the componet (team/domain prefix '_' component name) +# This must be the same as the RTC Component name and Eclipse Project Name +COMPONENT_NAME = NS_NPServiceIf + + +# Additive Compile Flags (Flags from initiating make process will still apply) +DEFS += + +# Set local includes and then the reference includes (priority order determines search path) +# Default pattern are any configuration includes (which would be things like PosixBasedOS001), local (Team) component directories, +# dependencies includes (other teams) +# Local (current component references should be in the form of +# $(CC_IFLAG)$(TEAM_ROOT)$(COMPONENT_NAME)/directory +# Example your public include directory would be +# $(CC_IFLAG)$(TEAM_ROOT)$(COMPONENT_NAME)/inc +# Team references should only be to other's public includes such as +# $(CC_IFLAG)$(TEAM_ROOT)NS_MessageCenter/inc +# Global (non-team) references should be only to other's public includes such +# these are found in the depends include file and captured in the (DEPENDS_INCLUDES) variable +INCLUDES = \ + $(CFG_INCS) \ + $(CC_IFLAG)./ \ + $(DEPENDS_INCLUDES) \ + $(CC_IFLAG)$(TEAM_ROOT)NS_MessageCenter/inc \ + $(CC_IFLAG)$(TEAM_ROOT)$(COMPONENT_NAME)/inc \ + $(CC_IFLAG)$(TEAM_ROOT)NS_UtilityCenter/inc + + +# Do the same if you need to include library paths as well +# Do an incremental in case additional library paths are defined +# at the top-level make. Use similar guidelines as for includes +# for example to include a team component library it would be +# $(TEAM_ROOT)NS_MessageCenter/lib/NS_MessageCenter/ +LIB_PATHS += \ + $(DEPENDS_LIB_PATHS) \ + + + +# Define binary outputs. These can be libraries or executables. +# Name a variable for each deliverable. Suffixes should be +# EXEC - For Executables -> output to the bin directory +#TIME_EXEC = $(BIN_PATH)time +# LIB - For Static Libraries -> output to lib directory with specific naming +#MATH_LIB = $(LIB_PATH)$(LIB_PREFIX)math.$(LIB_EXT) +# SLIB - For Shared Objects +#FRMWRK_SLIB = $(SLIB_PATH)frmwrk.$(SO_EXT) +# LIB - Define the static library for Message Queue +# +# +ifdef DYNAMIC + COMPONENT_LIB = $(SLIB_PATH)$(LIB_PREFIX)$(COMPONENT_NAME)$(DEBUG_EXT).$(SO_EXT) +else + COMPONENT_LIB = $(LIB_PATH)$(LIB_PREFIX)$(COMPONENT_NAME)$(DEBUG_EXT).$(LIB_EXT) +endif + +## Sources Section + +# Define Library & Executable Sources (on a per deliverable basis) +# This includes sources located in subdirectories. + +# Define generic line that pulls all c, cc, cpp files +# since your in the src folder is pull only files from there +COMPONENT_SRCS = \ + $(wildcard *.c) \ + $(wildcard *.cpp) + +# Define sources that my not be local to your component +# here, you can define indivial files or wildcard from +# a different folder. +NON_LOCAL_SRCS = \ + + +# List of all sources to be built. Can be assembled from the other defintitions. +# This only defines sources for the current directory, so if there are subdirectories +# those are not included. (Those are found in simple subdirectory makefiles that only +# direct the building of sources, but no linking into a binary) +SOURCES = \ + $(COMPONENT_SRCS) \ + $(NON_LOCAL_SRCS) \ + + + +# +# Convert the source files to object files with correct folder location. +# +# +C_LANG_OBJECTS = $(addprefix $(BLD_PATH),$(addsuffix .$(OBJ_EXT),$(basename $(filter %.c ,$(SOURCES) ) ) ) ) +CPP_LANG_OBJECTS = $(addprefix $(BLD_PATH),$(addsuffix .$(OBJ_EXT),$(basename $(filter %.cpp %.cc %.cxx,$(SOURCES) ) ) ) ) + + +# List of all sources to be generated. Can be assembled from the other defintitions. +OBJECTS = \ + $(C_LANG_OBJECTS) \ + $(CPP_LANG_OBJECTS) + + + +# All headers that are dependencies. Wildcard is easy to pickup local headers. +# This is only to automate the rebuilding, all builds on the servers are cleans +# So this is not a huge deal when building on a component level. +HEADERS = \ + $(wildcard *.h) \ + $(wildcard $(PRJ_ROOT)../$(COMPONENT_NAME)/inc/*.h) \ + + +LIBRARIES = \ + $(COMPONENT_LIB) \ + +ifdef DYNAMIC + DYNAMIC_LIBS += \ + NS_MessageCenter$(DEBUG_EXT) +else + STATIC_LIBS += +endif + +# Make targets +# Standard +all: banner module_dirs subdirs local library binary + +debug: + $(MAKE) TARGET=arm DEBUG=TRUE all + +base: banner module_dirs subdirs local + +# Standard Building of Source Files (Default builds for all objects defined above) +$(C_LANG_OBJECTS): $(SOURCES) $(HEADERS) + $(CC_CMD) + +$(CPP_LANG_OBJECTS): $(SOURCES) $(HEADERS) + $(CPP_CMD) + +local: $(OBJECTS) + +# Defines specific for each deliverable + +$(COMPONENT_LIB): $(OBJECTS) +ifdef DYNAMIC +# For a dynamic library + $(SLIB_CMD) + $(HIDE_ECHO_FLAG)$(OBJCPY) --only-keep-debug $(@) $(@).debug + $(HIDE_ECHO_FLAG)$(OBJCPY) --strip-all $(@) + $(HIDE_ECHO_FLAG)$(OBJCPY) --add-gnu-debuglink=$(@).debug $(@) +else +# For a static library + $(AR_CMD) +endif + +# Standard set of derived targets +library: base \ + $(LIBRARIES) + @echo "***** `date` Done building library: $(COMPONENT_NAME) ******" + +binary: base \ + $(BINARIES) + +# Subdirs should be to jump to subdirectories +# standard form is of +# $(MAKE) -C subdirectory_name $(MAKECMDGOALS) +subdirs: + +clean: + -rm -f $(BINARIES) + -rm -f $(LIBRARIES) + -rm -f $(OBJECTS) + -rm -f $(COMPONENT_LIB).map + -rm -f $(COMPONENT_LIB).debug + +-v: + @echo "objs: --> $(OBJECTS)" + @echo "sources: --> $(SOURCES)" + @echo "headers: --> $(HEADERS)" + @echo "includes: --> $(INCLUDES)" + @echo "lib paths: --> $(LIB_PATHS)" + @echo "static libs: --> $(LD_STATIC_LIBS)" + @echo "dynamic libs: --> $(LD_DYNAMIC_LIBS)" + @echo "lib: --> $(LIBRARIES)" + @echo "bin: --> $(BINARIES)" + + +module_dirs: build_dirs diff --git a/nsframework/framework_unified/client/NS_NPServiceIf/src/ns_np_service_api.c b/nsframework/framework_unified/client/NS_NPServiceIf/src/ns_np_service_api.c new file mode 100644 index 00000000..d41514d1 --- /dev/null +++ b/nsframework/framework_unified/client/NS_NPServiceIf/src/ns_np_service_api.c @@ -0,0 +1,1001 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NPService +/// \brief APIs to be used by clients while invoking Notification Service. +/// +/// Implementation of APIs for Publishers and Subscribers of notifications. +/// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Include Files +/////////////////////////////////////////////////////////////////////////////// +#include <native_service/ns_np_service.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/ns_np_service_if.h> +#include <native_service/ns_message_center_if.h> +#include <native_service/ns_mc_system_info.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <limits.h> +#include <other_service/strlcpy.h> + +// define user name as blank for global persistence file +#define GLOBAL_PERSISTENCE "" + +// this is the maximum number of notifications that can be registered/ unregistered at once +const UI_32 maxNotification = UINT_MAX / sizeof(NC_register_notif_msg); + + + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPRegisterNotifications +/// API to send message to Notification Service to register a set of notifications +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of Publisher message queue +/// \param [in] numNotifications +/// PCSTR - Name of Notification +/// \param [in] pNotificationArray +/// NotificationInfo - Array of notifications +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPRegisterNotifications(HANDLE hNPMsgQ, PCSTR pPublisherName, UI_32 numNotifications, + NotificationInfo *pNotificationArray) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (maxNotification < numNotifications) { + return eFrameworkunifiedStatusFail; + } + + size_t sizeOfMsg = (sizeof(NC_register_notif_msg) * numNotifications) + sizeof(UI_32); + if (NULL == pNotificationArray) { + return eFrameworkunifiedStatusInvldParam; + } + + PCHAR *pMsgBuffer = (PCHAR *)malloc(sizeOfMsg); + + if (NULL == pMsgBuffer) { + return eFrameworkunifiedStatusFail; + } + + NC_register_multiple_notif_msg *pNotifMsg = (NC_register_multiple_notif_msg *)pMsgBuffer; + + pNotifMsg->numNotifications = numNotifications; + memcpy(&pNotifMsg->notifierList[0], pNotificationArray, sizeof(NC_register_notif_msg) * numNotifications); + + for(UI_32 i = 0; i < numNotifications; i++) { + // Insert \0 at the end of character (up to 64bytes) by copying with strlcpy. + strlcpy(pNotifMsg->notifierList[i].notificationName, + pNotificationArray[i].notificationName, + sizeof(pNotificationArray[i].notificationName)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_REGISTER_EV_REQ, (UI_32)sizeOfMsg, (PVOID)pNotifMsg) ; + + free(pMsgBuffer); + pMsgBuffer = NULL; + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup NPUnRegisterNotifications +/// API to send message to Notification Service to remove a set of notifications +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of Publisher message queue +/// \param [in] numNotifications +/// PCSTR - Name of Notification +/// \param [in] pNotificationArray +/// NotificationInfo - Array of notifications +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPUnRegisterNotifications(HANDLE hNPMsgQ, PCSTR pPublisherName, UI_32 numNotifications, + NotificationInfo *pNotificationArray) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (maxNotification < numNotifications) { + return eFrameworkunifiedStatusFail; + } + + size_t sizeOfMsg = (sizeof(NC_unregister_notif_msg) * numNotifications) + sizeof(UI_32); + UI_32 i = 0; + if (NULL == pNotificationArray) { + return eFrameworkunifiedStatusInvldParam; + } + + PCHAR *pMsgBuffer = (PCHAR *)malloc(sizeOfMsg); + + if (NULL == pMsgBuffer) { + return eFrameworkunifiedStatusFail; + } + + NC_unregister_multiple_notif_msg *pNotifMsg = (NC_unregister_multiple_notif_msg *)pMsgBuffer; + + pNotifMsg->numNotifications = numNotifications; + + for (i = 0; i < numNotifications; ++i) { + strlcpy(pNotifMsg->notificationList[i].notificationName, pNotificationArray[i].notificationName, + sizeof(pNotifMsg->notificationList[i].notificationName)); + } + + // mb20110110 Fixed issue 135 + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_UNREGISTER_EV_REQ, (UI_32)sizeOfMsg, (VOID *)pMsgBuffer) ; + + free(pMsgBuffer); + pMsgBuffer = NULL; // mb20110110 issue 134 + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPRegisterNotification +/// API to send message to Notification Service to register a notification +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of Publisher message queue +/// \param [in] notif_name +/// PCSTR - Name of Notification +/// \param [in] max_length +/// const UI_32 - Max size of the notification message +/// \param [in] bIsPersistent +/// const UI_8 - Flag to indicate if it has to be persistent +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPRegisterNotification(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR notificationName, + const UI_32 maxLength, const EFrameworkunifiedNotificationType perstype) + +{ + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != notificationName) { + if (strlen(pPublisherName) && strlen(notificationName)) { + NotificationInfo data = {}; + strlcpy(data.notificationName, notificationName, sizeof(data.notificationName)); + data.persType = perstype; + data.maxLength = maxLength; + + eFrameworkunifiedStatus = NPRegisterNotifications(hNPMsgQ, pPublisherName, 1, &data); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPUnRegisterNotification +/// API to send message to Notification Service to remove a notification +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of Publisher message queue +/// \param [in] pNotification +/// PCSTR - Name of Notification +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPUnRegisterNotification(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pNotification) { + + NotificationInfo data = {}; + strlcpy(data.notificationName, pNotification, sizeof(data.notificationName)); + return (NPUnRegisterNotifications(hNPMsgQ, pPublisherName, 1, &data)); +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPPublishNotification +/// API to send message to Notification Service to notify subscribers +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of Publisher message queue +/// \param [in] pNotification +/// PCSTR - Name of Notification +/// \param [in] pData +/// VOID * - Data buffer +/// \param [in] iLength +/// const UI_32 - Size of data buffer +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPPublishNotification(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pNotification, + PCVOID pData, const UI_32 iLength) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pNotification) { + if (strlen(pPublisherName) && strlen(pNotification)) { + if (strlen(pNotification) < MAX_STRING_SIZE_NOTIFICATION) { + // Insert \0 at the end of characters (up to 64bytes) by copying pNotification to local variables with strlcpy. + char tmp_notification[MAX_STRING_SIZE_NOTIFICATION] = {0}; + strlcpy(tmp_notification, pNotification, MAX_STRING_SIZE_NOTIFICATION); + eFrameworkunifiedStatus = McSendWithSysInfo(hNPMsgQ, pPublisherName, NPS_PUBLISH_EV_REQ, + tmp_notification, iLength, pData, 0); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPSubscribeToNotification +/// API to send message to Notification Service to add to subscription list for +/// that notification +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pSubscriberName +/// PCSTR - Name of subscriber message queue +/// \param [in] pNotification +/// PCSTR - Name of Notification +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSubscribeToNotification(HANDLE hNPMsgQ, PCSTR pSubscriberName, PCSTR pNotification) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + if (NULL != hNPMsgQ && NULL != pSubscriberName && NULL != pNotification) { + if (strlen(pSubscriberName) && strlen(pNotification)) { + NC_subscribe_msg data; + snprintf(data.notificationName, sizeof(data.notificationName), "%s", pNotification); + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pSubscriberName, NPS_SUBSCRIBE_TO_EV_REQ, sizeof(NC_subscribe_msg), (PVOID)&data); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +// NPSubscribeToNotifications +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSubscribeToNotifications(HANDLE hNPMsgQ, PCSTR pSubscriberName, UI_32 numNotifications, + SubscribeInfo *pSubscribeInfoArray) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (maxNotification < numNotifications) { + return eFrameworkunifiedStatusFail; + } + + size_t sizeOfMsg = (sizeof(NC_subscribe_msg) * numNotifications) + sizeof(UI_32); + if (NULL == pSubscribeInfoArray) { + return eFrameworkunifiedStatusInvldParam; + } + + PCHAR *pMsgBuffer = (PCHAR *)malloc(sizeOfMsg); + + if (NULL == pMsgBuffer) { + return eFrameworkunifiedStatusFail; + } + + NC_subscribe_multiple_notif_msg *pSubscribeMsg = (NC_subscribe_multiple_notif_msg *)pMsgBuffer; + + pSubscribeMsg->numNotifications = numNotifications; + memcpy(&pSubscribeMsg->notificationList[0], pSubscribeInfoArray, sizeof(NC_subscribe_msg) * numNotifications); + + for(UI_32 i = 0; i < numNotifications; i++) { + // Insert \0 at the end of character (up to 64bytes) by copying with strlcpy. + strlcpy(pSubscribeMsg->notificationList[i].notificationName, + pSubscribeInfoArray[i].notificationName, + sizeof(pSubscribeInfoArray[i].notificationName)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pSubscriberName, NPS_BATCH_SUBSCRIBE_TO_EV_REQ, (UI_32)sizeOfMsg, (PVOID)pSubscribeMsg) ; + + free(pMsgBuffer); + pMsgBuffer = NULL; + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPUnsubscribeFromNotification +/// API to send message to Notification Service to remove from subscription list for +/// that notification +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pSubscriberName +/// PCSTR - Name of subscriber message queue +/// \param [in] pNotification +/// PCSTR - Name of Notification +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPUnsubscribeFromNotification(HANDLE hNPMsgQ, PCSTR pSubscriberName, PCSTR pNotification) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pSubscriberName && NULL != pNotification) { + if (strlen(pSubscriberName) && strlen(pNotification)) { + NC_unsubscribe_frm_notif_msg data; + snprintf(data.notificationName, sizeof(data.notificationName), "%s", pNotification); + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pSubscriberName, NPS_UNSUBSCRIBE_FROM_EV_REQ, sizeof(NC_unsubscribe_frm_notif_msg), + (PVOID)&data); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +// NPUnsubscribeToNotifications +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPUnsubscribeFromNotifications(HANDLE hNPMsgQ, PCSTR pUnSubscriberName, UI_32 numNotifications, + SubscribeInfo *pUnSubscribeInfoArray) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pUnSubscriberName) { + if (strlen(pUnSubscriberName)) { + if (maxNotification < numNotifications) { + return eFrameworkunifiedStatusFail; + } + + size_t sizeOfMsg = (sizeof(NC_subscribe_msg) * numNotifications) + sizeof(UI_32); + if (NULL == pUnSubscribeInfoArray) { + return eFrameworkunifiedStatusInvldParam; + } + + PCHAR *pMsgBuffer = (PCHAR *)malloc(sizeOfMsg); + + if (NULL == pMsgBuffer) { + return eFrameworkunifiedStatusFail; + } + + NC_unsubscribe_multiple_notif_msg *pUnSubscribeMsg = (NC_unsubscribe_multiple_notif_msg *)pMsgBuffer; + + pUnSubscribeMsg->numNotifications = numNotifications; + memcpy(&pUnSubscribeMsg->notificationList[0], pUnSubscribeInfoArray, sizeof(NC_subscribe_msg) * numNotifications); + + for(UI_32 i = 0; i < numNotifications; i++) { + // Insert \0 at the end of character (up to 64bytes) by copying with strlcpy. + strlcpy(pUnSubscribeMsg->notificationList[i].notificationName, + pUnSubscribeInfoArray[i].notificationName, + sizeof(pUnSubscribeInfoArray[i].notificationName)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pUnSubscriberName, NPS_BATCH_UNSUBSCRIBE_FROM_EV_REQ, (UI_32)sizeOfMsg, (PVOID)pUnSubscribeMsg) ; + + free(pMsgBuffer); + pMsgBuffer = NULL; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPReadPersistedData +/// API to requested the persistent data corresponding to specified notification if available +/// The caller recieves an acknowledgement once NPS completes data retrieval and sends it. +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of publisher message queue +/// \param [in] notification +/// PCSTR - Name of Notification +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPReadPersistedData(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR notification) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != notification) { + if (strlen(pPublisherName) && strlen(notification)) { + NC_get_pers_data_msg msg; + + snprintf(msg.notificationName, sizeof(msg.notificationName), "%s", notification); + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_GET_PERS_DATA_REQ, sizeof(msg), (PVOID)&msg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup NPSavePersistentData +/// API to send message to Notification Service to save all persisted data that in Ram +/// to the filesystem via a file write. +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of publisher message queue +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSavePersistentData(HANDLE hNPMsgQ, PCSTR pPublisherName) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_SAVE_PERS_DATA_REQ, 0, NULL) ; + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPRegisterPersistentFile +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPRegisterPersistentFile(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pTag, + BOOL bIsUserFile) { // EFrameworkunifiedRegisterType eRegisterType) + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pTag) { + if (strlen(pPublisherName) && strlen(pTag)) { + NC_RegisterPersistentFileMsg tMsg; + + snprintf(tMsg.cFileTag, sizeof(tMsg.cFileTag), "%s", pTag); + tMsg.bIsUserFile = bIsUserFile; + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_SET_PERSIST_FILE_PATH_REQ, sizeof(tMsg), + (PVOID)&tMsg); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPLoadPersistentFile +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPLoadPersistentFile(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pDstFilePath, + PCSTR pTag, HANDLE hUser) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && + NULL != pDstFilePath && NULL != pTag) { + if (strlen(pPublisherName) && strlen(pDstFilePath) && strlen(pTag)) { + NC_LoadPersistedFileMsg tMsg = {}; + + snprintf(tMsg.cFilePath, sizeof(tMsg.cFilePath), "%s", pDstFilePath); + snprintf(tMsg.cFileTag, sizeof(tMsg.cFileTag), "%s", pTag); + + if (hUser) { + NC_User *pUser = (NC_User *) hUser; + snprintf(tMsg.cUsername, sizeof(tMsg.cUsername), "%s", pUser->cUsername != 0 ? pUser->cUsername : NULL); + } else { + strlcpy(tMsg.cUsername, GLOBAL_PERSISTENCE, sizeof(tMsg.cUsername)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_GET_PERS_FILE_REQ, sizeof(tMsg), (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPReleasePersistentFile +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPReleasePersistentFile(HANDLE hNPMsgQ, PCSTR pPublisherName, EFrameworkunifiedReleaseType eFrameworkunifiedReleaseType, PCSTR pTag, + PCSTR pFullFilePath, HANDLE hUser) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && + NULL != pTag && NULL != pFullFilePath) { + if (strlen(pPublisherName) && strlen(pTag) && strlen(pFullFilePath)) { + NC_ReleasePersistentFileMsg tMsg = {eFrameworkunifiedReleaseType, {0}, {0}}; + + snprintf(tMsg.cFilePath, sizeof(tMsg.cFilePath), "%s", pFullFilePath); + snprintf(tMsg.cFileTag, sizeof(tMsg.cFileTag), "%s", pTag); + + if (hUser) { + NC_User *pUser = (NC_User *) hUser; + snprintf(tMsg.cUsername, sizeof(tMsg.cUsername), "%s", pUser->cUsername != 0 ? pUser->cUsername : NULL); + } else { + strlcpy(tMsg.cUsername, GLOBAL_PERSISTENCE, sizeof(tMsg.cUsername)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_RELEASE_PERS_FILE_REQ, sizeof(tMsg), (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPPersistentSync +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPPersistentSync(PCSTR SrcName, HANDLE hNPMsgQ, UI_32 sessionid, PCSTR pPublisherName) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + CHAR data[4]; + UI_32 length; + HANDLE hResponse; + char mc_invoker_name[MAX_QUEUE_NAME_SIZE]; + + McCreateInvokerName(SrcName, sessionid, mc_invoker_name, sizeof(mc_invoker_name)); + hResponse = McOpenSyncReceiver(&mc_invoker_name[0]); + if (hResponse != NULL) { + eFrameworkunifiedStatus = McInvokeSync(hNPMsgQ, pPublisherName, NPS_NPP_SYNC_REQ , sizeof(data), data, sessionid, + hResponse, 0, NULL, &length); + McClose(hResponse); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + return eFrameworkunifiedStatus; +} +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPSetPersonality +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSetPersonality(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pUserName) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pUserName) { + if (strlen(pPublisherName) && strlen(pUserName)) { + // NC_SetPersonalityMsg tMsg; + NC_User tMsg; + + snprintf(tMsg.cUsername, sizeof(tMsg.cUsername), "%s", pUserName); + + // eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_SET_PERSONALITY_REQ, sizeof(tMsg), (PVOID)&tMsg ) ; + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_CHANGE_PERSONALITY_REQ, sizeof(tMsg), (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPRegisterPersistentFolder +/// API to register persistence tag to folder that need to persist +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of publisher message queue +/// \param [in] pTag +/// PCSTR - Tag associated to folder that need to persist +/// \param [in] bIsUserFolder +/// BOOL - TRUE - user specific folder +/// FALSE - global file +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPRegisterPersistentFolder(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pTag, BOOL bIsUserFolder) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pTag) { + if (strlen(pPublisherName) && strlen(pTag)) { + NC_RegisterPersistentFolderMsg tMsg; + + snprintf(tMsg.cFolderTag, sizeof(tMsg.cFolderTag), "%s", pTag); + tMsg.bIsUserFolder = bIsUserFolder; + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_SET_PERSIST_FOLDER_PATH_REQ, sizeof(tMsg), + (PVOID)&tMsg); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPLoadPersistentFolder +/// API to load folder to given path and associated with given tag from persistent memory +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of publisher message queue +/// \param [in] pDstFolderPath +/// PCSTR - Destination where folder needs to be loaded +/// \param [in] pTag +/// PCSTR - Tag associated to folder that need to loaded from persistent memory +/// \param [in] hUser +/// HANDLE - Handle of the user +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPLoadPersistentFolder(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pDstFolderPath, + PCSTR pTag, HANDLE hUser) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && + NULL != pDstFolderPath && NULL != pTag) { + if (strlen(pPublisherName) && strlen(pDstFolderPath) && strlen(pTag)) { + NC_LoadPersistedFolderMsg tMsg; + + snprintf(tMsg.cFolderPath, sizeof(tMsg.cFolderPath), "%s", pDstFolderPath); + snprintf(tMsg.cFolderTag, sizeof(tMsg.cFolderTag), "%s", pTag); + + if (hUser) { + NC_User *pUser = (NC_User *) hUser; + snprintf(tMsg.cUsername, sizeof(tMsg.cUsername), "%s", pUser->cUsername != 0 ? pUser->cUsername : NULL); + } else { + strlcpy(tMsg.cUsername, GLOBAL_PERSISTENCE, sizeof(tMsg.cUsername)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_GET_PERS_FOLDER_REQ, sizeof(tMsg), (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPReleasePersistentFolder +/// API to release folder for saving with tag name to persistent memory +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of publisher message queue +/// \param [in] eFrameworkunifiedReleaseType +/// EFrameworkunifiedReleaseType - eFrameworkunifiedNotOnRelease :not on release +/// eFrameworkunifiedPersistOnShutdown:persist on shutdown +/// eFrameworkunifiedPersistInstantly :persist instantly +/// \param [in] pTag +/// PCSTR - Tag associated to folder that need to persist +/// \param [in] pFullFolderPath +/// PCSTR - full folder path of folder that need to be stored in persistent memory +/// \param [in] hUser +/// HANDLE - Handle of the user +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPReleasePersistentFolder(HANDLE hNPMsgQ, PCSTR pPublisherName, EFrameworkunifiedReleaseType eFrameworkunifiedReleaseType, + PCSTR pTag, PCSTR pFullFolderPath, HANDLE hUser) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && + NULL != pTag && NULL != pFullFolderPath) { + if (strlen(pPublisherName) && strlen(pFullFolderPath) && strlen(pTag)) { + NC_ReleasePersistentFolderMsg tMsg = {eFrameworkunifiedReleaseType, {0}, {0}}; + + snprintf(tMsg.cFolderPath, sizeof(tMsg.cFolderPath), "%s", pFullFolderPath); + snprintf(tMsg.cFolderTag, sizeof(tMsg.cFolderTag), "%s", pTag); + + if (hUser) { + NC_User *pUser = (NC_User *) hUser; + snprintf(tMsg.cUsername, sizeof(tMsg.cUsername), "%s", pUser->cUsername != 0 ? pUser->cUsername : NULL); + } else { + strlcpy(tMsg.cUsername, GLOBAL_PERSISTENCE, sizeof(tMsg.cUsername)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_RELEASE_PERS_FOLDER_REQ, sizeof(tMsg), (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPChangePersonality +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPChangePersonality(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pUserName) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != pUserName && 0 != strlen(pUserName)) { + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_CHANGE_PERSONALITY_REQ, sizeof(pUserName), (PVOID)&pUserName) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SendStopToNSNPP +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus SendStopToNSNPP(HANDLE hNPMsgQ, PCSTR pPublisherName, EFrameworkunifiedShutdownType eShutdownType, UI_32 uiStopMsgData) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != pPublisherName && 0 != strlen(pPublisherName)) { + NC_StopMsgData tMsg; + tMsg.eShutdownType = eShutdownType; + tMsg.uiStopMsgData = uiStopMsgData; + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_NPP_STOP_REQ, sizeof(tMsg), (PVOID)&tMsg); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPGetReadyStatusOfNPP +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPGetReadyStatusOfNPP(HANDLE hNPMsgQ, PCSTR pRequesterName) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != pRequesterName && 0 != strlen(pRequesterName)) { + eFrameworkunifiedStatus = McSend(hNPMsgQ, pRequesterName, NPS_GET_READYSTATUS_REQ, 0, NULL); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPRegisterImmediateNotifications +/// API to send message to Notification Service to register a set of notifications +/// +/// \param [in] hNPMsgQ +/// HANDLE - Handle to message queue of Notification service. +/// \param [in] pPublisherName +/// PCSTR - Name of Publisher message queue +/// \param [in] numNotifications +/// PCSTR - Name of Notification +/// \param [in] pNotificationArray +/// ImmediateNotificationInfo - Array of notifications +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPRegisterImmediateNotifications(HANDLE hNPMsgQ, PCSTR pPublisherName, UI_32 numNotifications, + ImmediateNotificationInfo *pNotificationArray) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (maxNotification < numNotifications) { + return eFrameworkunifiedStatusFail; + } + + size_t sizeOfMsg = (sizeof(NC_register_immediate_notif_msg) * numNotifications) + sizeof(UI_32); + if (NULL == pNotificationArray) { + return eFrameworkunifiedStatusInvldParam; + } + + PCHAR *pMsgBuffer = (PCHAR *)malloc(sizeOfMsg); + + if (NULL == pMsgBuffer) { + return eFrameworkunifiedStatusFail; + } + + NC_register_multiple_immediate_notif_msg *pNotifMsg = (NC_register_multiple_immediate_notif_msg *)pMsgBuffer; + + if (NULL != pNotifMsg) { + pNotifMsg->numNotifications = numNotifications; + } + + memcpy(&pNotifMsg->notifierList[0], pNotificationArray, sizeof(NC_register_immediate_notif_msg) * numNotifications); + + for(UI_32 i = 0; i < numNotifications; i++ ) { + // Insert \0 at the end of character (up to 64bytes) by copying with strlcpy. + strlcpy(pNotifMsg->notifierList[i].notificationName, + pNotificationArray[i].notificationName, + sizeof(pNotificationArray[i].notificationName)); + } + + eFrameworkunifiedStatus = McSend(hNPMsgQ, pPublisherName, NPS_REGISTER_NOR_EV_REQ, (UI_32)sizeOfMsg, (PVOID)pNotifMsg) ; + + if (NULL != pMsgBuffer) { + free(pMsgBuffer); + pMsgBuffer = NULL; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPClearPersistedData +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPClearPersistedData(HANDLE hNPMsgQ, PCSTR pRequesterName, EFrameworkunifiedClearPersistence eFrameworkunifiedClearPersistenceScope) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if ((NULL != hNPMsgQ) && (NULL != pRequesterName) && (0 != strlen(pRequesterName))) { + NC_ClearPersistedDataReq tMsg = {}; + tMsg.ePersistenceData = eFrameworkunifiedClearPersistenceScope; + + eFrameworkunifiedStatus = McSend(hNPMsgQ, + pRequesterName, + NPS_DELETE_PERSISTED_DATA_REQ, + sizeof(tMsg), + &tMsg); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPSetPersistNotfnDefaultValue +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSetPersistNotfnDefaultValue(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pNotification, PCVOID pData, + const UI_32 iLength) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pNotification) { + if ((0 != strlen(pPublisherName)) && (0 != strlen(pNotification))) { + + // Insert \0 at the end of characters (up to 64bytes) by copying pNotification to local variables with strlcpy. + char tmp_notification[MAX_STRING_SIZE_NOTIFICATION] = {0}; + strlcpy(tmp_notification, pNotification, MAX_STRING_SIZE_NOTIFICATION); + + eFrameworkunifiedStatus = McSendWithSysInfo(hNPMsgQ, + pPublisherName, + NPS_SET_DEFAULT_PERS_DATA, + (PCHAR)tmp_notification, + iLength, + pData, + 0); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPSetPersistentNotfnType +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSetPersistentNotfnType(HANDLE hNPMsgQ, PCSTR pPublisherName, PCSTR pNotification, + EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pNotification) { + if ((0 != strlen(pPublisherName)) && (0 != strlen(pNotification))) { + + // Insert \0 at the end of characters (up to 64bytes) by copying pNotification to local variables with strlcpy. + char tmp_notification[MAX_STRING_SIZE_NOTIFICATION] = {0}; + strlcpy(tmp_notification, pNotification, MAX_STRING_SIZE_NOTIFICATION); + + eFrameworkunifiedStatus = McSendWithSysInfo(hNPMsgQ, + pPublisherName, + NPS_SET_NOTFN_PERSISTENT_TYPE, + (PCHAR)tmp_notification, + sizeof(ePersistCategory), + &ePersistCategory, + 0); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPSetFilePersistentType +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSetFilePersistentType(HANDLE hNPMsgQ, PCSTR pPublisherName, + PCSTR pTag, EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pTag) { + if ((0 != strlen(pPublisherName)) && (0 != strlen(pTag))) { + NC_SetFilePersistType tMsg = {}; + + tMsg.ePersistType = ePersistCategory; + + snprintf(tMsg.cTag, sizeof(tMsg.cTag), "%s", pTag); + + eFrameworkunifiedStatus = McSend(hNPMsgQ, + pPublisherName, + NPS_SET_FILE_PERSISTENT_TYPE, + sizeof(tMsg), + (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPSetFolderPersistentType +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSetFolderPersistentType(HANDLE hNPMsgQ, PCSTR pPublisherName, + PCSTR pTag, EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != hNPMsgQ && NULL != pPublisherName && NULL != pTag) { + if ((0 != strlen(pPublisherName)) && (0 != strlen(pTag))) { + NC_SetFolderPersistType tMsg = {}; + + tMsg.ePersistType = ePersistCategory; + snprintf(tMsg.cTag, sizeof(tMsg.cTag), "%s", pTag); + + eFrameworkunifiedStatus = McSend(hNPMsgQ, + pPublisherName, + NPS_SET_FOLDER_PERSISTENT_TYPE, + sizeof(tMsg), + (PVOID)&tMsg) ; + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +// EOF diff --git a/nsframework/framework_unified/client/NS_NPServiceIf/src/ns_np_service_nor_persistence.cpp b/nsframework/framework_unified/client/NS_NPServiceIf/src/ns_np_service_nor_persistence.cpp new file mode 100644 index 00000000..a7777432 --- /dev/null +++ b/nsframework/framework_unified/client/NS_NPServiceIf/src/ns_np_service_nor_persistence.cpp @@ -0,0 +1,498 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NPService +/// \brief This file contains the API to store and retrieve immediate +/// notification data from and to persistent storage. +/// +/// +/// +/////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////// +// Include Files +/////////////////////////////////////////////////////////////////////////////// +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <dirent.h> +#include <semaphore.h> +#include <aglpath.h> + +#include <native_service/ns_np_service.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/ns_np_service_if.h> +#include <native_service/ns_message_center_if.h> +#include <native_service/ns_util_directory.h> +#include <native_service/ns_np_service_nor_persistence.h> +#include <native_service/frameworkunified_framework_types.h> + +#include <string> + +#include <native_service/ns_np_service_nor_persistence_internal.h> +#include <native_service/ns_np_types.h> +#include <native_service/ns_mc_system_info.h> + +sem_t g_FileAccessSemaphore; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NPSynchronousReadPersistentData +/// Read immediate persistent data from the persistent memory +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSynchronousReadPersistentData(PCSTR pAppName, + PCSTR notif_name, + PVOID pData, + UI_32 uiDataSize, + const EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + NC_NorPersistentData l_tNorPersistentData = {}; + + if (NULL != pAppName && NULL != notif_name && NULL != pData) { + if (eFrameworkunifiedStatusOK != NPSynchronousGetPersistentData(pAppName, notif_name, pData, uiDataSize, l_tNorPersistentData, + ePersistCategory)) { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NPSynchronousGetPersistentData +/// Get the notification data from the persistent storage +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSynchronousGetPersistentData(PCSTR pAppName, + PCSTR notif_name, + PVOID pData, + UI_32 uiDataSize, + NC_NorPersistentData &ptImmediatePersistentData, // NOLINT (readability/nolint) + const EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + + if (NULL != notif_name && NULL != pData && 0 < uiDataSize) { + FILE *l_fFilePtr = NULL; + + if (0 == sem_init(&g_FileAccessSemaphore, 1, 1)) { // LCOV_EXCL_BR_LINE 5: sem_init's error case + if (sem_wait(&g_FileAccessSemaphore) == 0) { // LCOV_EXCL_BR_LINE 5: sem_wait's error case + // Create unique filename + std::string l_cTempPath = notif_name; + size_t l_uiTempPathSize = 0; + + std::string l_cPath = ""; + std::string l_cNewPath = IMMEDIATE_PERSISTENCE_STORAGE_V2; + std::string l_cOldPath = IMMEDIATE_PERSISTENCE_STORAGE_V1; + + // replace all '/' by '_' + l_uiTempPathSize = l_cTempPath.find_first_of("/"); + while (std::string::npos != l_uiTempPathSize) { + l_cTempPath[l_uiTempPathSize] = '_'; + l_uiTempPathSize = l_cTempPath.find_first_of("/", l_uiTempPathSize + 1); + } + + switch (ePersistCategory) { + case eFrameworkunifiedFactoryData: { + l_cNewPath.append(FACTORYDATADIR); + } + break; + + case eFrameworkunifiedFactoryCustomerData: { + l_cNewPath.append(FACTORYCUSTOMERDATADIR); + } + break; + + case eFrameworkunifiedDealerData: { + l_cNewPath.append(DEALERDATADIR); + } + break; + + case eFrameworkunifiedUserData: + default: { + l_cNewPath.append(USERDATADIR); + l_cNewPath.append(ALLUSERAPPDATADIR); + } + break; + } + + l_cNewPath.append(IMMEDIATEDATADIR); + l_cNewPath.append(l_cTempPath); + + if (NULL != pAppName) { // LCOV_EXCL_BR_LINE 6: pAppName was checed in NPSynchronousReadPersistentData + l_cNewPath.append(pAppName); + } + + if (0 == access(l_cNewPath.c_str(), F_OK)) { + l_cPath.assign(l_cNewPath); + } else { + l_cOldPath.append(l_cTempPath); + if (NULL != pAppName) { // LCOV_EXCL_BR_LINE 6: pAppName was checed in NPSynchronousReadPersistentData + l_cOldPath.append(pAppName); + } + + if (0 == access(l_cOldPath.c_str(), F_OK)) { + l_cPath.assign(l_cOldPath); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFileLoadError; + } + } + + if (eFrameworkunifiedStatusOK == eFrameworkunifiedStatus) { + size_t PersistData; + // Open and read from a file + l_fFilePtr = fopen(l_cPath.c_str(), "re"); + if (NULL != l_fFilePtr) { + // read notification info structure + if (fread(&ptImmediatePersistentData, 1, sizeof(ptImmediatePersistentData), + l_fFilePtr) == sizeof(ptImmediatePersistentData)) { + if (0 == feof(l_fFilePtr)) { + // read data + PersistData = fread(pData, 1, uiDataSize, l_fFilePtr); + if (PersistData != uiDataSize) { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + fclose(l_fFilePtr); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + } + + sem_post(&g_FileAccessSemaphore); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusErrOther; + } + sem_destroy(&g_FileAccessSemaphore); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusErrOther; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NPSynchronousWritePersistentData +/// Store the notification data on the persistent memory +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSynchronousWritePersistentData(PCSTR pAppName, + PCSTR notif_name, + PVOID pData, + const UI_32 uiDataSize, + const EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + HANDLE l_hReceiverMq = NULL; + + // if this API is used to write the data directly then max data size will be same as data write size + l_eStatus = SynchronousWritePersistentData(pAppName, notif_name, pData, uiDataSize, 0, uiDataSize, ePersistCategory); + + l_hReceiverMq = McOpenSender(FRAMEWORKUNIFIED_NS_NPSERVICE); + + if (NULL != l_hReceiverMq) { + (VOID)McSendWithSysInfo(l_hReceiverMq, + pAppName, + NPS_SYNCHRONOUS_WRITE_NOTIFY_REQ, + (PCHAR)notif_name, + uiDataSize, + pData, + 0); + + McClose(l_hReceiverMq); + } + + return l_eStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SynchronousWritePersistentData +/// Store the notification data on the persistent memory +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus SynchronousWritePersistentData(PCSTR pAppName, + PCSTR notif_name, + PVOID pData, + const UI_32 uiDataSize, + const UI_32 uiDelay, + const UI_32 uiMaxSize, + const EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + FILE *l_fFilePtr = NULL; + NC_NorPersistentData l_tImmediatePersistentData = {}; + + if (NULL != notif_name && NULL != pAppName && NULL != pData) { + if (strlen(notif_name) < MAX_STRING_SIZE_NOTIFICATION && strlen(pAppName) < MAX_NAME_SIZE_APP) { + // Create unique filename + std::string l_cTempPath = notif_name; + size_t l_uiTempPathSize = 0; + + // replace all '/' by '_' + l_uiTempPathSize = l_cTempPath.find_first_of("/"); + while (std::string::npos != l_uiTempPathSize) { + l_cTempPath[l_uiTempPathSize] = '_'; + l_uiTempPathSize = l_cTempPath.find_first_of("/", l_uiTempPathSize + 1); + } + + strncpy(l_tImmediatePersistentData.notificationName, notif_name, + sizeof(l_tImmediatePersistentData.notificationName) - 1); + strncpy(l_tImmediatePersistentData.pPublisherName, pAppName, + sizeof(l_tImmediatePersistentData.pPublisherName) - 1); + l_tImmediatePersistentData.dataSize = uiDataSize; + l_tImmediatePersistentData.uiDelay = uiDelay; + l_tImmediatePersistentData.uiMaxSize = uiMaxSize; + + if (0 == sem_init(&g_FileAccessSemaphore, 1, 1)) { // LCOV_EXCL_BR_LINE 5: sem_init's error case + if (sem_wait(&g_FileAccessSemaphore) == 0) { // LCOV_EXCL_BR_LINE 5: sem_wait's error case + std::string l_cPath = IMMEDIATE_PERSISTENCE_STORAGE_V2; + + switch (ePersistCategory) { + case eFrameworkunifiedFactoryData: { + l_cPath.append(FACTORYDATADIR); + } + break; + + case eFrameworkunifiedFactoryCustomerData: { + l_cPath.append(FACTORYCUSTOMERDATADIR); + } + break; + + case eFrameworkunifiedDealerData: { + l_cPath.append(DEALERDATADIR); + } + break; + + case eFrameworkunifiedUserData: + default: { + l_cPath.append(USERDATADIR); + l_cPath.append(ALLUSERAPPDATADIR); + } + break; + } + + l_cPath.append(IMMEDIATEDATADIR); + + if (!DoesDirecotryExist(l_cPath)) { + eFrameworkunifiedStatus = CreateDirectory(l_cPath); + } + + if (eFrameworkunifiedStatusOK == eFrameworkunifiedStatus) { + l_cPath.append(l_cTempPath); + + l_cPath.append(pAppName); + + l_fFilePtr = fopen(l_cPath.c_str(), "we"); + if (NULL != l_fFilePtr) { + // write header + fwrite(&l_tImmediatePersistentData , 1 , sizeof(l_tImmediatePersistentData) , l_fFilePtr); + if (0 == ferror(l_fFilePtr)) { + // write data + fwrite(pData , 1 , uiDataSize , l_fFilePtr); + if (0 != ferror(l_fFilePtr)) { + eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; + } + } + fsync(fileno(l_fFilePtr)); + fclose(l_fFilePtr); + } + } + + sem_post(&g_FileAccessSemaphore); + } + sem_destroy(&g_FileAccessSemaphore); + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusErrOther; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusFail; + } + } else { + eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam; + } + return eFrameworkunifiedStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NPSynchronousGetPersistentDataSize +/// Get the size of the notification data stored in the persistent memory +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPSynchronousGetPersistentDataSize(PCSTR notif_name, PUI_32 uiDataSize, + const EFrameworkunifiedPersistCategory ePersistCategory) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + if (NULL != notif_name && NULL != uiDataSize) { + FILE *l_fFilePtr = NULL; + NC_NorPersistentData l_ptImmediatePersistentData = {}; + + *uiDataSize = 0; + + if (0 == sem_init(&g_FileAccessSemaphore, 1, 1)) { // LCOV_EXCL_BR_LINE 5: sem_init's error case + if (sem_wait(&g_FileAccessSemaphore) == 0) { // LCOV_EXCL_BR_LINE 5: sem_wait's error case + // Create unique filename + std::string l_cTempPath = notif_name; + size_t l_uiTempPathSize = 0; + + std::string l_cPath = ""; + std::string l_cNewPath = IMMEDIATE_PERSISTENCE_STORAGE_V2; + std::string l_cOldPath = IMMEDIATE_PERSISTENCE_STORAGE_V1; + + // replace all '/' by '_' + l_uiTempPathSize = l_cTempPath.find_first_of("/"); + while (std::string::npos != l_uiTempPathSize) { + l_cTempPath[l_uiTempPathSize] = '_'; + l_uiTempPathSize = l_cTempPath.find_first_of("/", l_uiTempPathSize + 1); + } + + switch (ePersistCategory) { + case eFrameworkunifiedFactoryData: { + l_cNewPath.append(FACTORYDATADIR); + } + break; + + case eFrameworkunifiedFactoryCustomerData: { + l_cNewPath.append(FACTORYCUSTOMERDATADIR); + } + break; + + case eFrameworkunifiedDealerData: { + l_cNewPath.append(DEALERDATADIR); + } + break; + + case eFrameworkunifiedUserData: + default: { + l_cNewPath.append(USERDATADIR); + l_cNewPath.append(ALLUSERAPPDATADIR); + } + break; + } + + l_cNewPath.append(IMMEDIATEDATADIR); + l_cNewPath.append(l_cTempPath); + + if (0 == access(l_cNewPath.c_str(), F_OK)) { + l_cPath.assign(l_cNewPath); + } else { + l_cOldPath.append(l_cTempPath); + + if (0 == access(l_cOldPath.c_str(), F_OK)) { + l_cPath.assign(l_cOldPath); + } else { + l_eStatus = eFrameworkunifiedStatusFileLoadError; + } + } + + if (eFrameworkunifiedStatusOK == l_eStatus) { + size_t PersistData; + // Open and read from a file + l_fFilePtr = fopen(l_cPath.c_str(), "re"); + if (NULL != l_fFilePtr) { + // read notification info structure + PersistData = fread(&l_ptImmediatePersistentData, 1, sizeof(l_ptImmediatePersistentData), l_fFilePtr); + if (PersistData == sizeof(l_ptImmediatePersistentData)) { + *uiDataSize = l_ptImmediatePersistentData.dataSize; + } else { + *uiDataSize = static_cast<UI_32>(PersistData); + } + fclose(l_fFilePtr); + } + } + + sem_post(&g_FileAccessSemaphore); + } else { + l_eStatus = eFrameworkunifiedStatusErrOther; + } + + sem_destroy(&g_FileAccessSemaphore); + } else { + l_eStatus = eFrameworkunifiedStatusErrOther; + } + } else { + l_eStatus = eFrameworkunifiedStatusInvldParam; + } + + return l_eStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SynchronousMovePersistentData +/// API to move all the immediate notification data from f_cSrcDir directory to +/// f_cDestDir directory +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus SynchronousMovePersistentData(PCSTR f_cSrcDir, + PCSTR f_cDestDir) { + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + if (NULL != f_cSrcDir && NULL != f_cDestDir) { + if (0 == sem_init(&g_FileAccessSemaphore, 1, 1)) { + if (sem_wait(&g_FileAccessSemaphore) == 0) { // LCOV_EXCL_BR_LINE 5: sem_init's error case + if (DoesDirecotryExist(f_cSrcDir)) { // LCOV_EXCL_BR_LINE 5: sem_wait's error case + if (!DoesDirecotryExist(f_cDestDir)) { + l_eStatus = CreateDirectory(f_cDestDir); + } + + if (eFrameworkunifiedStatusOK == l_eStatus) { + DIR *l_pDir = NULL; + struct dirent *l_pdirent = NULL; + + std::string l_cSrcPath = ""; + std::string l_cDestPath = ""; + + if (NULL != (l_pDir = opendir(f_cSrcDir))) { + while (NULL != (l_pdirent = readdir(l_pDir))) { + if (0 != std::strcmp(l_pdirent->d_name, ".") && + 0 != std::strcmp(l_pdirent->d_name, "..")) { + l_cSrcPath.assign(f_cSrcDir); + l_cSrcPath.append(l_pdirent->d_name); + + l_cDestPath.assign(f_cDestDir); + l_cDestPath.append(l_pdirent->d_name); + + // move the old app user data to the UserData fodler + if (0 != rename(l_cSrcPath.c_str(), l_cDestPath.c_str())) { + l_eStatus = eFrameworkunifiedStatusFail; + } + } + } + closedir(l_pDir); + + sync(); + } else { + l_eStatus = eFrameworkunifiedStatusFileLoadError; + } + } + } + + sem_post(&g_FileAccessSemaphore); + } else { + l_eStatus = eFrameworkunifiedStatusFail; + } + + sem_destroy(&g_FileAccessSemaphore); + } else { + l_eStatus = eFrameworkunifiedStatusFail; + } + } else { + l_eStatus = eFrameworkunifiedStatusInvldParam; + } + + return l_eStatus; +} |