diff --git a/configure.ac b/configure.ac index 604352a42..88a202da6 100644 --- a/configure.ac +++ b/configure.ac @@ -40,6 +40,19 @@ AC_ARG_ENABLE([gtestapp], [echo "Gtestapp is disabled"]) AM_CONDITIONAL([WITH_GTEST_SUPPORT], [test x$GTEST_SUPPORT_ENABLED = xtrue]) +AC_ARG_ENABLE([cord], + AS_HELP_STRING([--enable-cord],[enable CORD persistent storage support (default is no)]), + [ + case "${enableval}" in + yes) CORD_ENABLED=true + CFLAGS="$CFLAGS -DCORD_ENABLED";; + no) CORD_ENABLED=false;; + *) AC_MSG_ERROR([bad value ${enableval} for --enable-cord]);; + esac + ], + [CORD_ENABLED=false]) +AM_CONDITIONAL([WITH_CORD_SUPPORT], [test x$CORD_ENABLED = xtrue]) + AC_PREFIX_DEFAULT(`pwd`) AC_ENABLE_SHARED AC_DISABLE_STATIC diff --git a/scripts/ccsp_restart.sh b/scripts/ccsp_restart.sh index e7e3e6124..dd99355f6 100644 --- a/scripts/ccsp_restart.sh +++ b/scripts/ccsp_restart.sh @@ -72,11 +72,13 @@ exec 3>&1 4>&2 >>$SELFHEALFILE 2>&1 fi killall CcspLMLite killall CcspXdnsSsp +if [ "$VOICE_SUPPORTED" != "false" ]; then if [ -f "/tmp/mta_initialized" ] then rm -rf /tmp/mta_initialized fi killall CcspMtaAgentSsp +fi killall CcspHotspot @@ -174,6 +176,7 @@ ulimit -c unlimited sleep 3 #mta +if [ "$VOICE_SUPPORTED" != "false" ]; then if [ "$MODEL_NUM" = "DPC3939B" ] || [ "$MODEL_NUM" = "DPC3941B" ]; then echo_t "Disabling MTA for BWG " else @@ -185,7 +188,7 @@ ulimit -c unlimited $BINPATH/CcspMtaAgentSsp -subsys $Subsys fi fi - +fi sleep 3 echo "[`getDateTime`] RDKB_SELFHEAL : Resetting process webpa on atom reset" cd /usr/ccsp/webpa diff --git a/scripts/cosa_start_arm.sh b/scripts/cosa_start_arm.sh index 31868c4fe..157ec7ae6 100644 --- a/scripts/cosa_start_arm.sh +++ b/scripts/cosa_start_arm.sh @@ -75,7 +75,9 @@ if [ "x"$1 = "xkill" ] || [ "x"$2 = "xkill" ]; then # killall CcspRmSsp killall CcspCrSsp # killall CcspLmSsp +if [ "$VOICE_SUPPORTED" != "false" ]; then killall CcspMtaAgentSsp +fi killall CcspCMAgentSsp killall CcspLMLite killall CcspXdnsSsp diff --git a/scripts/cosa_start_rem.sh b/scripts/cosa_start_rem.sh index 94f123695..512a62a19 100644 --- a/scripts/cosa_start_rem.sh +++ b/scripts/cosa_start_rem.sh @@ -197,7 +197,7 @@ syscfg set mgmt_wan_sshaccess 1 syscfg commit echo_t "PWD is `pwd`" - +if [ "$VOICE_SUPPORTED" != "false" ]; then if [ "$MODEL_NUM" = "DPC3939B" ] || [ "$MODEL_NUM" = "DPC3941B" ]; then echo_t "Disabling MTA for BWG " else @@ -212,6 +212,7 @@ if [ -e ./mta ]; then cd .. fi fi +fi if [ -e ./moca ]; then cd moca diff --git a/source/ccsp/components/common/DataModel/dml/components/DslhObjController/dslh_objco_access.c b/source/ccsp/components/common/DataModel/dml/components/DslhObjController/dslh_objco_access.c index d7bd89de7..0d03c25cd 100644 --- a/source/ccsp/components/common/DataModel/dml/components/DslhObjController/dslh_objco_access.c +++ b/source/ccsp/components/common/DataModel/dml/components/DslhObjController/dslh_objco_access.c @@ -1028,7 +1028,11 @@ DslhObjcoGetParamValueByName /*AnscTraceVerbose(("DslhObjcoGetParamValueByName -- name %s\n", pName));*/ /* check whether it's a count of table (xxxNumberOfEntries) or not */ +#ifdef _64BIT_ARCH_SUPPORT_ if(pSlapVariable->Syntax == (ULONG)SLAP_VAR_SYNTAX_uint32) +#else + if(pSlapVariable->Syntax == SLAP_VAR_SYNTAX_uint32) +#endif { pFind = _ansc_strstr(pName, TR69_NUMBER_OF_ENTRIES_STRING); diff --git a/source/cosa/utilities/AnscObjectArray/AnscUIntArray/ansc_uint_array_co_process.c b/source/cosa/utilities/AnscObjectArray/AnscUIntArray/ansc_uint_array_co_process.c index 06bc14ca5..427612722 100644 --- a/source/cosa/utilities/AnscObjectArray/AnscUIntArray/ansc_uint_array_co_process.c +++ b/source/cosa/utilities/AnscObjectArray/AnscUIntArray/ansc_uint_array_co_process.c @@ -74,7 +74,6 @@ #include "ansc_uint_array_co_global.h" -#include /********************************************************************** @@ -276,7 +275,11 @@ AnscUIntArrayGetAt pStorage = (PUINT)pUIntArray->hStorage; - return (ANSC_OBJECT_ARRAY_DATA)(uintptr_t)pStorage[ulIndex]; +#ifdef _64BIT_ARCH_SUPPORT_ + return (ANSC_OBJECT_ARRAY_DATA)(ULONG)pStorage[ulIndex]; +#else + return (ANSC_OBJECT_ARRAY_DATA)pStorage[ulIndex]; +#endif } return (ANSC_OBJECT_ARRAY_DATA)NULL; @@ -332,7 +335,11 @@ AnscUIntArraySetAt PUINT pStorage; pStorage = (PUINT)pUIntArray->hStorage; - pStorage[ulIndex] = (uintptr_t)Data; +#ifdef _64BIT_ARCH_SUPPORT_ + pStorage[ulIndex] = (ULONG)Data; +#else + pStorage[ulIndex] = (UINT)Data; +#endif } } @@ -413,7 +420,11 @@ AnscUIntArrayInsertAt for (i = 0; i < ulCount; i ++) { - pStorage[i + ulIndex] = (uintptr_t)Data; +#ifdef _64BIT_ARCH_SUPPORT_ + pStorage[i + ulIndex] = (ULONG)Data; +#else + pStorage[i + ulIndex] = (UINT)Data; +#endif } } } @@ -528,7 +539,11 @@ AnscUIntArrayAdd PUINT pStorage; pStorage = (PUINT)pUIntArray->hStorage; - pStorage[pUIntArray->ulItemCount ++] = (uintptr_t)Data; +#ifdef _64BIT_ARCH_SUPPORT_ + pStorage[pUIntArray->ulItemCount ++] = (ULONG)Data; +#else + pStorage[pUIntArray->ulItemCount ++] = (UINT)Data; +#endif return pUIntArray->ulItemCount; } @@ -661,7 +676,11 @@ AnscUIntArrayFind LONG Count = pUIntArray->ulItemCount; LONG i; PUINT pStorage = (PUINT)pUIntArray->hStorage; - UINT uSample = (uintptr_t)Data; +#ifdef _64BIT_ARCH_SUPPORT_ + UINT uSample = (ULONG)Data; +#else + UINT uSample = (UINT)Data; +#endif for (i = 0; i < Count; i ++) { diff --git a/source/cosa/utilities/bsp_eng/bspeng_branch_co_process.c b/source/cosa/utilities/bsp_eng/bspeng_branch_co_process.c index cdb2c4660..4708e8103 100644 --- a/source/cosa/utilities/bsp_eng/bspeng_branch_co_process.c +++ b/source/cosa/utilities/bsp_eng/bspeng_branch_co_process.c @@ -678,7 +678,7 @@ BspTemplateBranchLoadBranchData if (!bSucc) return FALSE; - pBrData->type = (BSP_TEMPLATE_BRANCH_TYPE)ucType; + pBrData->type = (BSP_TEMPLATE_OPERATOR)ucType; switch (pBrData->type) { diff --git a/source/cosa/utilities/bsp_eng/bspeng_co_execute.c b/source/cosa/utilities/bsp_eng/bspeng_co_execute.c index cff8f8da8..900bd7142 100644 --- a/source/cosa/utilities/bsp_eng/bspeng_co_execute.c +++ b/source/cosa/utilities/bsp_eng/bspeng_co_execute.c @@ -72,7 +72,7 @@ **********************************************************************/ -#include + #include "bspeng_co_global.h" #include "safec_lib_common.h" @@ -6198,7 +6198,11 @@ BspTemplateEngGetSlapObjectString if (pString) { - rc = sprintf_s(pString, ulSize, "%.08X", (UINT)(uintptr_t)pSlapVar->Variant.varHandle); +#ifdef _64BIT_ARCH_SUPPORT_ + rc = sprintf_s(pString, ulSize, "%.08X", (UINT)(ULONG)pSlapVar->Variant.varHandle); +#else + rc = sprintf_s(pString, ulSize, "%.08X", (UINT)pSlapVar->Variant.varHandle); +#endif if(rc < EOK) { ERR_CHK(rc); @@ -6417,7 +6421,11 @@ BspTemplateEngGetSlapObjectString pString + AnscSizeOfString(pString), ulSize+1, (i == 0)? "%.08X" : ".%.08X", - (UINT)(uintptr_t)pArray->Array.arrayHandle[i] +#ifdef _64BIT_ARCH_SUPPORT_ + (UINT)(ULONG)pArray->Array.arrayHandle[i] +#else + (UINT)pArray->Array.arrayHandle[i] +#endif ); if(rc < EOK) { diff --git a/source/debug_api/ansc_debug.c b/source/debug_api/ansc_debug.c index 51faeca9f..24ebbfe2b 100644 --- a/source/debug_api/ansc_debug.c +++ b/source/debug_api/ansc_debug.c @@ -265,7 +265,9 @@ const char *CcspTraceGetRdkLogModule(const char *pComponentName) #if !defined (NO_MOCA_FEATURE_SUPPORT) if (strcmp(pComponentName, "moca") == 0) return "LOG.RDK.MOCA"; #endif +#if !defined (NO_MTA_FEATURE_SUPPORT) if (strcmp(pComponentName, "mta") == 0) return "LOG.RDK.MTA"; +#endif break; case 'n': #if defined (FEATURE_RDKB_NFC_MANAGER) diff --git a/source/debug_api/ansc_memory.c b/source/debug_api/ansc_memory.c index ae8230baf..e22b33b5f 100644 --- a/source/debug_api/ansc_memory.c +++ b/source/debug_api/ansc_memory.c @@ -958,8 +958,13 @@ AnscTraceMemoryTable2 sprintf ( pTraceMessage, +#ifdef _64BIT_ARCH_SUPPORT_ " *** mem_block = %p, size = %9d bytes, id = %6d, %s ***", pMemoryAllocItem->MemoryPointer, +#else + " *** mem_block = 0x%8X, size = %9d bytes, id = %6d, %s ***", + (UINT)pMemoryAllocItem->MemoryPointer, +#endif (int)pMemoryAllocItem->MemorySize, (int)pMemoryAllocItem->AllocId, pMemoryAllocItem->OwnerDesp @@ -1444,7 +1449,11 @@ void AnscLiveMemoryInspectRecordDetail pPrevAllocItem = AnscGetPrevMemoryAllocItem(pMemoryBlock); +#ifdef _64BIT_ARCH_SUPPORT_ printf("found %p\n",pPrevAllocItem); +#else + printf("found %x\n",(UINT)pPrevAllocItem); +#endif if ( !pPrevAllocItem ) { diff --git a/source/util_api/ansc/AnscPlatform/ansc_debug.c b/source/util_api/ansc/AnscPlatform/ansc_debug.c index 46284e6d8..e55f68d0b 100644 --- a/source/util_api/ansc/AnscPlatform/ansc_debug.c +++ b/source/util_api/ansc/AnscPlatform/ansc_debug.c @@ -650,7 +650,11 @@ AnscDumpMemory /* * Print the address */ +#ifdef _64BIT_ARCH_SUPPORT_ _ansc_sprintf(PrintBuffer, "%p", pCurr); +#else + _ansc_sprintf(PrintBuffer, "0x%08X", (unsigned int)pCurr); +#endif _ansc_strcat (PrintBuffer, ": "); /* @@ -691,7 +695,11 @@ AnscDumpMemory /* * Print the address */ +#ifdef _64BIT_ARCH_SUPPORT_ _ansc_sprintf(PrintBuffer, "%p", pCurr); +#else + _ansc_sprintf(PrintBuffer, "0x%08X", (unsigned int)pCurr); +#endif _ansc_strcat (PrintBuffer, ": " ); /* diff --git a/source/util_api/ansc/AnscPlatform/ansc_file_io.c b/source/util_api/ansc/AnscPlatform/ansc_file_io.c index a1932276f..6a2e1aa77 100644 --- a/source/util_api/ansc/AnscPlatform/ansc_file_io.c +++ b/source/util_api/ansc/AnscPlatform/ansc_file_io.c @@ -88,7 +88,7 @@ **********************************************************************/ -#include + #include "ansc_platform.h" #include "ansc_external_storage.h" #include "ansc_crypto_interface.h" @@ -245,7 +245,12 @@ AnscReadFile if ( pFileInfo->bZlibCompressed ) { - iReturnsize = _ansc_get_file_size((VOID*)(uintptr_t)pFileInfo->Handle); +#ifdef _64BIT_ARCH_SUPPORT_ + ULONG uHandle = pFileInfo->Handle; + iReturnsize = _ansc_get_file_size((VOID*)uHandle); +#else + iReturnsize = _ansc_get_file_size((VOID*)pFileInfo->Handle); +#endif if ( iReturnsize < 0 ) { return ANSC_STATUS_FAILURE; @@ -482,7 +487,12 @@ AnscGetFileSize { int iReadSize = (int)0; - iReturnSize = _ansc_get_file_size((VOID*)(uintptr_t)pFileInfo->Handle); +#ifdef _64BIT_ARCH_SUPPORT_ + ULONG uHandle = pFileInfo->Handle; + iReturnSize = _ansc_get_file_size((VOID*)uHandle); +#else + iReturnSize = _ansc_get_file_size((VOID*)pFileInfo->Handle); +#endif if ( iReturnSize < 0 ) { return 0; @@ -536,7 +546,12 @@ AnscGetFileSize else { /*CID: 59651 Improper use of negative value*/ - iReturnSize = _ansc_get_file_size((VOID*)(uintptr_t)pFileInfo->Handle); +#ifdef _64BIT_ARCH_SUPPORT_ + ULONG uHandle = pFileInfo->Handle; + iReturnSize = _ansc_get_file_size((VOID*)uHandle); +#else + iReturnSize = _ansc_get_file_size((VOID*)pFileInfo->Handle); +#endif if(iReturnSize < 0) { return 0; diff --git a/source/util_api/ansc/AnscPlatform/user_file_io.c b/source/util_api/ansc/AnscPlatform/user_file_io.c index e7ac18419..f62fcaf16 100644 --- a/source/util_api/ansc/AnscPlatform/user_file_io.c +++ b/source/util_api/ansc/AnscPlatform/user_file_io.c @@ -74,7 +74,6 @@ #include #include -#include #include "ansc_global.h" #include "user_base.h" @@ -309,9 +308,14 @@ inline int user_get_file_size(PVOID h) { int length = 0; - length = lseek((int)(uintptr_t)h, 0, SEEK_END); - lseek((int)(uintptr_t)h, 0, SEEK_SET); - return length; +#ifdef _64BIT_ARCH_SUPPORT_ + length = lseek((int)(ULONG)h, 0, SEEK_END); + lseek((int)(ULONG)h, 0, SEEK_SET); +#else + length = lseek((int)h, 0, SEEK_END); + lseek((int)h, 0, SEEK_SET); +#endif + return length; } /* diff --git a/source/util_api/ansc/AnscXmlDomParser/ansc_xml_dom_node_base.c b/source/util_api/ansc/AnscXmlDomParser/ansc_xml_dom_node_base.c index c504eac73..89c48a843 100644 --- a/source/util_api/ansc/AnscXmlDomParser/ansc_xml_dom_node_base.c +++ b/source/util_api/ansc/AnscXmlDomParser/ansc_xml_dom_node_base.c @@ -253,9 +253,17 @@ AnscXmlDomNodeRemove { AnscXmlWarning ( +#ifdef _64BIT_ARCH_SUPPORT_ "The child node queue of XML node '%s' is corrupted.cookie1= %p\n", +#else + "The child node queue of XML node '%s' is corrupted.cookie1= 0x%.8X\n", +#endif (char *)pXmlNode->ChildNodeQueueLock, +#ifdef _64BIT_ARCH_SUPPORT_ (void*)pNameAttr->StringData +#else + (unsigned int)pNameAttr->StringData +#endif ); } @@ -270,17 +278,30 @@ AnscXmlDomNodeRemove { AnscXmlWarning ( +#ifdef _64BIT_ARCH_SUPPORT_ "The child node queue of XML node is corrupted. cookie2= %p\n", (void*)pXmlNode->AttributesListLock +#else + "The child node queue of XML node is corrupted. cookie2= 0x%.8X\n", + (unsigned int)pXmlNode->AttributesListLock +#endif ); } else { AnscXmlWarning ( +#ifdef _64BIT_ARCH_SUPPORT_ "The child node queue of XML node '%s' is corrupted.cookie2= %p\n", +#else + "The child node queue of XML node '%s' is corrupted.cookie2= 0x%.8X\n", +#endif (char *)pXmlNode->AttributesListLock, +#ifdef _64BIT_ARCH_SUPPORT_ (void*)pNameAttr->StringData +#else + (unsigned int)pNameAttr->StringData +#endif ); } diff --git a/source/util_api/ccsp_msg_bus/ccsp_base_api.c b/source/util_api/ccsp_msg_bus/ccsp_base_api.c index 56e414a88..8df5fc08c 100644 --- a/source/util_api/ccsp_msg_bus/ccsp_base_api.c +++ b/source/util_api/ccsp_msg_bus/ccsp_base_api.c @@ -47,6 +47,12 @@ #endif #include #include "ccsp_trace.h" +#include +#include +#include +#ifdef CORD_ENABLED +#include +#endif /* For AnscEqualString */ #include "ansc_platform.h" @@ -2984,6 +2990,59 @@ int PSM_Set_Record_Value { UNREFERENCED_PARAMETER(ulRecordType); UNREFERENCED_PARAMETER(pSubSystemPrefix); + +#ifdef CORD_ENABLED + UNREFERENCED_PARAMETER(bus_handle); + + if (pRecordName == NULL || pValue == NULL) + return CCSP_CR_ERR_INVALID_PARAM; + + cord_rc_t cord_rc; + + switch (pValue->Syntax) + { + case SLAP_VAR_SYNTAX_int: + cord_rc = cord_set_i32(pRecordName, (int32_t)pValue->Variant.varInt, CORD_FLAG_PERSIST_ASYNC); + break; + case SLAP_VAR_SYNTAX_uint32: + cord_rc = cord_set_u32(pRecordName, (uint32_t)pValue->Variant.varUint32, CORD_FLAG_PERSIST_ASYNC); + break; + case SLAP_VAR_SYNTAX_bool: + cord_rc = cord_set_bool(pRecordName, (pValue->Variant.varBool != 0), CORD_FLAG_PERSIST_ASYNC); + break; + case SLAP_VAR_SYNTAX_string: + if (pValue->Variant.varString == NULL) + return CCSP_CR_ERR_INVALID_PARAM; + cord_rc = cord_set_string(pRecordName, pValue->Variant.varString, CORD_FLAG_PERSIST_ASYNC); + break; + case SLAP_VAR_SYNTAX_TYPE_ucharArray: + { + SLAP_UCHAR_ARRAY* var_uchar_array = pValue->Variant.varUcharArray; + if (var_uchar_array == NULL) + return CCSP_CR_ERR_INVALID_PARAM; + cord_rc = cord_set_blob(pRecordName, + var_uchar_array->Array.arrayUchar, + var_uchar_array->VarCount, + CORD_FLAG_PERSIST_ASYNC); + break; + } + default: + return CCSP_CR_ERR_INVALID_PARAM; + } + + switch (cord_rc) { + case CORD_RC_SUCCESS: return CCSP_SUCCESS; + case CORD_RC_NOT_OPEN: return CCSP_Message_Bus_ERROR; + case CORD_RC_INVALID_NAME: return CCSP_ERR_INVALID_PARAMETER_VALUE; + case CORD_RC_INVALID_FLAG: return CCSP_ERR_INVALID_PARAMETER_VALUE; + case CORD_RC_PERMISSION_DENIED: return CCSP_ERR_REQUEST_REJECTED; + case CORD_RC_PERSIST_FAILED: return CCSP_Message_Bus_OOM; + case CORD_RC_INVALID_ARG: return CCSP_ERR_INVALID_PARAMETER_VALUE; + } + return CCSP_Message_Bus_ERROR; + +#else /* !CORD_ENABLED */ + parameterValStruct_t val[1]; char buf[128]; char* var_string = 0; @@ -3061,7 +3120,73 @@ int PSM_Set_Record_Value if(var_string) bus_info->freefunc(var_string); return ret; + +#endif /* CORD_ENABLED */ +} +#ifdef CORD_ENABLED +static const int8_t B64_DEC[256] = { + /* 0x00-0x0F */ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + /* 0x10-0x1F */ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + /* 0x20-0x2F */ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63, + /* 0x30-0x3F */ 52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1, + /* 0x40-0x4F */ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14, + /* 0x50-0x5F */ 15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1, + /* 0x60-0x6F */ -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40, + /* 0x70-0x7F */ 41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1, + /* 0x80-0xFF */ + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 +}; + +unsigned char *base64_to_binary(const char *in, size_t in_len, size_t *out_len) { + if (!in || !out_len) return NULL; + if ((in_len % 4) != 0) return NULL; + + size_t padding = 0; + if (in_len >= 1 && in[in_len - 1] == '=') padding++; + if (in_len >= 2 && in[in_len - 2] == '=') padding++; + + size_t decoded_len = (in_len / 4) * 3 - padding; + unsigned char *out = (unsigned char *)malloc(decoded_len ? decoded_len : 1); + if (!out) return NULL; + + size_t o = 0; + for (size_t i = 0; i < in_len; i += 4) { + unsigned char c0 = (unsigned char)in[i]; + unsigned char c1 = (unsigned char)in[i + 1]; + unsigned char c2 = (unsigned char)in[i + 2]; + unsigned char c3 = (unsigned char)in[i + 3]; + + int8_t a = B64_DEC[c0]; + int8_t b = B64_DEC[c1]; + int8_t c = (c2 == '=') ? 0 : B64_DEC[c2]; + int8_t d = (c3 == '=') ? 0 : B64_DEC[c3]; + + if (a < 0 || b < 0 || (c2 != '=' && c < 0) || (c3 != '=' && d < 0)) { + free(out); + return NULL; + } + + uint32_t triple = ((uint32_t)a << 18) | + ((uint32_t)b << 12) | + ((uint32_t)c << 6) | + (uint32_t)d; + + if (o < decoded_len) out[o++] = (unsigned char)((triple >> 16) & 0xFF); + if (o < decoded_len) out[o++] = (unsigned char)((triple >> 8) & 0xFF); + if (o < decoded_len) out[o++] = (unsigned char)(triple & 0xFF); + } + + *out_len = decoded_len; + return out; } +#endif /* CORD_ENABLED */ int PSM_Get_Record_Value ( @@ -3073,11 +3198,86 @@ int PSM_Get_Record_Value ) { UNREFERENCED_PARAMETER(pSubSystemPrefix); + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; + +#ifdef CORD_ENABLED + + if (pRecordName == NULL || pValue == NULL) + return CCSP_CR_ERR_INVALID_PARAM; + + cord_value_t *pCordValue = NULL; + cord_rc_t cord_rc = cord_get(pRecordName, &pCordValue); + + switch (cord_rc) { + case CORD_RC_SUCCESS: break; + case CORD_RC_NOT_OPEN: return CCSP_Message_Bus_ERROR; + case CORD_RC_INVALID_NAME: return CCSP_ERR_NOT_EXIST; + case CORD_RC_PERMISSION_DENIED: return CCSP_ERR_REQUEST_REJECTED; + case CORD_RC_OUT_OF_MEMORY: return CCSP_ERR_MEMORY_ALLOC_FAIL; + default: return CCSP_Message_Bus_ERROR; + } + + int ret = CCSP_SUCCESS; + + switch (pCordValue->valueType) + { + case CORD_TYPE_I32: + if (ulRecordType) *ulRecordType = ccsp_int; + pValue->Syntax = SLAP_VAR_SYNTAX_int; + pValue->Variant.varInt = (int)pCordValue->i32Value; + break; + case CORD_TYPE_U32: + if (ulRecordType) *ulRecordType = ccsp_unsignedInt; + pValue->Syntax = SLAP_VAR_SYNTAX_uint32; + pValue->Variant.varUint32 = (uint32_t)pCordValue->u32Value; + break; + case CORD_TYPE_BOOL: + if (ulRecordType) *ulRecordType = ccsp_boolean; + pValue->Syntax = SLAP_VAR_SYNTAX_bool; + pValue->Variant.varBool = pCordValue->boolValue ? TRUE : SLAP_FALSE; + break; + case CORD_TYPE_STRING: + { + if (ulRecordType) *ulRecordType = ccsp_string; + pValue->Syntax = SLAP_VAR_SYNTAX_string; + if (pValue->Variant.varString) + bus_info->freefunc(pValue->Variant.varString); + size_t str_len = strlen(pCordValue->stringValue); + pValue->Variant.varString = (char *)bus_info->mallocfunc(str_len + 1); + if (pValue->Variant.varString == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(pValue->Variant.varString, pCordValue->stringValue); + break; + } + case CORD_TYPE_BLOB: + { + if (ulRecordType) *ulRecordType = ccsp_byte; + pValue->Syntax = SLAP_VAR_SYNTAX_TYPE_ucharArray; + size_t blob_len = pCordValue->blobValue.length; + SLAP_UCHAR_ARRAY *var_ucharArray = (SLAP_UCHAR_ARRAY *)bus_info->mallocfunc(sizeof(SLAP_UCHAR_ARRAY) + blob_len); + if (var_ucharArray == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + var_ucharArray->Size = sizeof(SLAP_UCHAR_ARRAY) + blob_len; + var_ucharArray->VarCount = (ULONG)blob_len; + var_ucharArray->Syntax = SLAP_VAR_SYNTAX_ucharArray; + memcpy(var_ucharArray->Array.arrayUchar, pCordValue->blobValue.pData, blob_len); + if (pValue->Variant.varUcharArray) + bus_info->freefunc(pValue->Variant.varUcharArray); + pValue->Variant.varUcharArray = var_ucharArray; + break; + } + default: + cord_free_values(pCordValue); + return CCSP_CR_ERR_UNSUPPORTED_DATATYPE; + } + + cord_free_values(pCordValue); + return ret; + +#else /* !CORD_ENABLED */ + char* parameterNames[1]; int size = 0; parameterValStruct_t **val = 0; int ret = -1; - CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; parameterNames[0] = (char *)pRecordName; ret = PSM_Get_Record_Value_rbus(bus_handle, parameterNames, 1, &size, &val); if(ret != CCSP_SUCCESS ) @@ -3168,6 +3368,8 @@ int PSM_Get_Record_Value } free_parameterValStruct_t(bus_handle , size, val); return ret; + +#endif /* CORD_ENABLED */ } #endif @@ -3181,6 +3383,145 @@ int PSM_Set_Record_Value2 ) { UNREFERENCED_PARAMETER(pSubSystemPrefix); + +#ifdef CORD_ENABLED + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; + + if (pRecordName == NULL || pVal == NULL) + return CCSP_CR_ERR_INVALID_PARAM; + + cord_rc_t cord_rc; + + char *endptr = NULL; + switch (ulRecordType) + { + case ccsp_int: + { + errno = 0; + long val_l = strtol(pVal, &endptr, 10); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_i32(pRecordName, (int32_t)val_l, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_unsignedInt: + { + errno = 0; + unsigned long val_ul = strtoul(pVal, &endptr, 10); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_u32(pRecordName, (uint32_t)val_ul, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_boolean: + if (strcmp(pVal, PSM_FALSE) && strcmp(pVal, PSM_TRUE)) + return CCSP_CR_ERR_INVALID_PARAM; + cord_rc = cord_set_bool(pRecordName, (strcasecmp(pVal, PSM_TRUE) == 0), CORD_FLAG_PERSIST_ASYNC); + break; + case ccsp_string: + cord_rc = cord_set_string(pRecordName, pVal, CORD_FLAG_PERSIST_ASYNC); + break; + case ccsp_long: + { + errno = 0; + long long val_ll = strtoll(pVal, &endptr, 10); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_i64(pRecordName, (int64_t)val_ll, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_unsignedLong: + { + errno = 0; + unsigned long long val_ull = strtoull(pVal, &endptr, 10); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_u64(pRecordName, (uint64_t)val_ull, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_float: + { + errno = 0; + float val_f = strtof(pVal, &endptr); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_float(pRecordName, val_f, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_double: + { + errno = 0; + double val_d = strtod(pVal, &endptr); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_double(pRecordName, val_d, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_byte: + { + errno = 0; + long val_b = strtol(pVal, &endptr, 10); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_i32(pRecordName, (int32_t)val_b, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_dateTime: + { + struct tm tm_val; + memset(&tm_val, 0, sizeof(tm_val)); + time_t time_val; + char *parse_end = strptime(pVal, "%Y-%m-%dT%H:%M:%S", &tm_val); + if (parse_end != NULL) + { + tm_val.tm_isdst = -1; + time_val = mktime(&tm_val); + if (time_val == (time_t)-1) + return CCSP_ERR_INVALID_PARAMETER_VALUE; + } + else + { + errno = 0; + long val_t = strtol(pVal, &endptr, 10); + if (errno != 0 || endptr == pVal || *endptr != '\0') + return CCSP_ERR_INVALID_PARAMETER_VALUE; + time_val = (time_t)val_t; + } + cord_rc = cord_set_datetime(pRecordName, time_val, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_base64: + { + size_t outbuf_len = 0;; + unsigned char *outbuf = base64_to_binary(pVal,strlen(pVal),&outbuf_len); + if (outbuf == NULL) + return CCSP_ERR_INVALID_PARAMETER_VALUE; + cord_rc = cord_set_blob(pRecordName,outbuf, outbuf_len, CORD_FLAG_PERSIST_ASYNC); + //Free the outbuf which is allocated in base64_to_binary fn for the conversion purpose. + free(outbuf); + //cord_rc = cord_set_string(pRecordName, pVal, CORD_FLAG_PERSIST_ASYNC); + break; + } + case ccsp_none: + return CCSP_CR_ERR_UNSUPPORTED_DATATYPE; + default: + return CCSP_CR_ERR_INVALID_PARAM; + } + + switch (cord_rc) { + case CORD_RC_SUCCESS: return CCSP_SUCCESS; + case CORD_RC_NOT_OPEN: return CCSP_Message_Bus_ERROR; + case CORD_RC_INVALID_NAME: return CCSP_ERR_INVALID_PARAMETER_VALUE; + case CORD_RC_INVALID_FLAG: return CCSP_ERR_INVALID_PARAMETER_VALUE; + case CORD_RC_PERMISSION_DENIED: return CCSP_ERR_REQUEST_REJECTED; + case CORD_RC_PERSIST_FAILED: return CCSP_Message_Bus_OOM; + case CORD_RC_INVALID_ARG: return CCSP_ERR_INVALID_PARAMETER_VALUE; + } + return CCSP_Message_Bus_ERROR; + +#else /* !CORD_ENABLED */ + + UNREFERENCED_PARAMETER(bus_handle); parameterValStruct_t val[1]; if(ulRecordType == ccsp_boolean) { @@ -3193,6 +3534,8 @@ int PSM_Set_Record_Value2 val[0].type = ulRecordType; val[0].parameterValue = (char *)pVal; return PSM_Set_Record_Value_rbus(bus_handle, 1, val); + +#endif /* CORD_ENABLED */ } int PSM_Get_Record_Value2 @@ -3204,9 +3547,100 @@ int PSM_Get_Record_Value2 char** pValue ) { - int ret = 0; UNREFERENCED_PARAMETER(pSubSystemPrefix); *pValue = NULL; + +#ifdef CORD_ENABLED + + if (pRecordName == NULL || pValue == NULL) + return CCSP_CR_ERR_INVALID_PARAM; + + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; + cord_value_t *pCordValue = NULL; + cord_rc_t cord_rc = cord_get(pRecordName, &pCordValue); + + switch (cord_rc) { + case CORD_RC_SUCCESS: break; + case CORD_RC_NOT_OPEN: return CCSP_Message_Bus_ERROR; + case CORD_RC_INVALID_NAME: return CCSP_ERR_NOT_EXIST; + case CORD_RC_PERMISSION_DENIED: return CCSP_ERR_REQUEST_REJECTED; + case CORD_RC_OUT_OF_MEMORY: return CCSP_ERR_MEMORY_ALLOC_FAIL; + default: return CCSP_Message_Bus_ERROR; + } + + char buf[64]; + int ret = CCSP_SUCCESS; + + switch (pCordValue->valueType) + { + case CORD_TYPE_I32: + if (ulRecordType) *ulRecordType = ccsp_int; + snprintf(buf, sizeof(buf), "%d", (int)pCordValue->i32Value); + *pValue = bus_info->mallocfunc(strlen(buf) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, buf); + break; + case CORD_TYPE_U32: + if (ulRecordType) *ulRecordType = ccsp_unsignedInt; + snprintf(buf, sizeof(buf), "%u", (unsigned int)pCordValue->u32Value); + *pValue = bus_info->mallocfunc(strlen(buf) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, buf); + break; + case CORD_TYPE_BOOL: + { + if (ulRecordType) *ulRecordType = ccsp_boolean; + const char *bstr = pCordValue->boolValue ? PSM_TRUE : PSM_FALSE; + *pValue = bus_info->mallocfunc(strlen(bstr) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, bstr); + break; + } + case CORD_TYPE_STRING: + if (ulRecordType) *ulRecordType = ccsp_string; + *pValue = bus_info->mallocfunc(strlen(pCordValue->stringValue) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, pCordValue->stringValue); + break; + case CORD_TYPE_I64: + if (ulRecordType) *ulRecordType = ccsp_long; + snprintf(buf, sizeof(buf), "%" PRId64, (int64_t)pCordValue->i64Value); + *pValue = bus_info->mallocfunc(strlen(buf) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, buf); + break; + case CORD_TYPE_U64: + if (ulRecordType) *ulRecordType = ccsp_unsignedLong; + snprintf(buf, sizeof(buf), "%" PRIu64, (uint64_t)pCordValue->u64Value); + *pValue = bus_info->mallocfunc(strlen(buf) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, buf); + break; + case CORD_TYPE_DOUBLE: + if (ulRecordType) *ulRecordType = ccsp_double; + snprintf(buf, sizeof(buf), "%.17g", pCordValue->doubleValue); + *pValue = bus_info->mallocfunc(strlen(buf) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, buf); + break; + case CORD_TYPE_DATETIME: + if (ulRecordType) *ulRecordType = ccsp_dateTime; + snprintf(buf, sizeof(buf), "%ld", (long)pCordValue->dateTimeValue); + *pValue = bus_info->mallocfunc(strlen(buf) + 1); + if (*pValue == NULL) { cord_free_values(pCordValue); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + strcpy(*pValue, buf); + break; + default: + cord_free_values(pCordValue); + return CCSP_CR_ERR_UNSUPPORTED_DATATYPE; + } + + cord_free_values(pCordValue); + return ret; + +#else /* !CORD_ENABLED */ + + int ret = 0; int n = 0; int size; char* pTmp = NULL; @@ -3233,6 +3667,8 @@ int PSM_Get_Record_Value2 } free_parameterValStruct_t(bus_handle , size, val); return ret; + +#endif /* CORD_ENABLED */ } int PSM_Del_Record @@ -3242,6 +3678,45 @@ int PSM_Del_Record char const * const pRecordName ) { +#ifdef CORD_ENABLED + char psmName[512] = ""; + errno_t rc = -1; + cord_rc_t crc = CORD_RC_SUCCESS; + + if (!pRecordName) { + return CCSP_ERR_INVALID_PARAMETER_VALUE; + } + + if (pSubSystemPrefix && pSubSystemPrefix[0] != 0) { + rc = strcpy_s(psmName, sizeof(psmName), pSubSystemPrefix); + ERR_CHK(rc); + } + rc = strcat_s(psmName, sizeof(psmName), CCSP_DBUS_PSM); + ERR_CHK(rc); + rc = strcat_s(psmName, sizeof(psmName), "."); + ERR_CHK(rc); + rc = strcat_s(psmName, sizeof(psmName), pRecordName); + ERR_CHK(rc); + + if ( pRecordName[strlen(pRecordName)-1] == '.' ) { + crc = cord_default_multi(psmName, CORD_FLAG_PERSIST_ASYNC); + } + else { + crc = cord_default(psmName, CORD_FLAG_PERSIST_ASYNC); + } + switch (crc) { + case CORD_RC_SUCCESS: return CCSP_SUCCESS; + case CORD_RC_NOT_OPEN: return CCSP_Message_Bus_ERROR; + case CORD_RC_INVALID_NAME: return CCSP_ERR_INVALID_PARAMETER_VALUE; + case CORD_RC_INVALID_FLAG: return CCSP_ERR_INVALID_PARAMETER_VALUE; + case CORD_RC_PERMISSION_DENIED: return CCSP_ERR_REQUEST_REJECTED; + case CORD_RC_PERSIST_FAILED: return CCSP_Message_Bus_OOM; + case CORD_RC_INVALID_ARG: return CCSP_ERR_INVALID_PARAMETER_VALUE; + } + return CCSP_Message_Bus_ERROR; + +#else /* !CORD_ENABLED */ + parameterAttributeStruct_t attr_val[1]; parameterInfoStruct_t **parameter; char psmName[256]; @@ -3316,8 +3791,9 @@ int PSM_Del_Record 1 ); } +#endif /* CORD_ENABLED */ + } - int PsmGroupGet(void *bus_handle, const char *subsys, const char *names[], int nname, parameterValStruct_t ***records, int *nrec) { @@ -3325,18 +3801,237 @@ int PsmGroupGet(void *bus_handle, const char *subsys, if (!bus_handle || !names || !records || !nrec) return CCSP_FAILURE; +#ifdef CORD_ENABLED +//cord_rc_t cord_get_multi(const char* pParameterNames[], size_t nParameterNames, size_t depth, cord_parameter_t** ppParameters, size_t *pnParameters); + cord_parameter_t* params = NULL; + size_t count = 0; + parameterValStruct_t **val = 0; + *nrec = 0; + cord_value_type_t valueType; + + cord_rc_t cord_rc = cord_get_multi((const char **)names, nname, 0, ¶ms,&count); + switch (cord_rc) { + case CORD_RC_SUCCESS: break; + case CORD_RC_NOT_OPEN: return CCSP_Message_Bus_ERROR; + case CORD_RC_INVALID_NAME: return CCSP_ERR_NOT_EXIST; + case CORD_RC_PERMISSION_DENIED: return CCSP_ERR_REQUEST_REJECTED; + case CORD_RC_OUT_OF_MEMORY: return CCSP_ERR_MEMORY_ALLOC_FAIL; + default: return CCSP_Message_Bus_ERROR; + } + + char buf[64]; + int ret = CCSP_SUCCESS; + int i = 0; + size_t len; + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; + if (bus_info == NULL) { cord_free_parameters(params); return CCSP_Message_Bus_ERROR; } + if(count) + { + *nrec = count; + val = bus_info->mallocfunc(count*sizeof(parameterValStruct_t *)); + if (val == NULL) { cord_free_parameters(params); return CCSP_ERR_MEMORY_ALLOC_FAIL; } + memset(val, 0, count*sizeof(parameterValStruct_t *)); + for (i = 0; i < count; i++) + { + val[i] = bus_info->mallocfunc(sizeof(parameterValStruct_t)); + if(NULL == val[i]){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memset(val[i], 0, sizeof(parameterValStruct_t)); + /*Get Name */ + const char* pname = params[i].pName; + if(NULL == pname){ret = CCSP_Message_Bus_ERROR;break;} + len = strlen(pname); + val[i]->parameterName = bus_info->mallocfunc(len + 1); + if(NULL == val[i]->parameterName){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterName, params[i].pName, len + 1); + /*Get Type*/ + valueType = params[i].value.valueType; + switch (valueType) + { + case CORD_TYPE_I32: + val[i]->type = ccsp_int; + snprintf(buf, sizeof(buf), "%d", (int)params[i].value.i32Value); + val[i]->parameterValue = bus_info->mallocfunc(strlen(buf) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + case CORD_TYPE_U32: + val[i]->type = ccsp_unsignedInt; + snprintf(buf, sizeof(buf), "%u", (unsigned int)params[i].value.u32Value); + val[i]->parameterValue = bus_info->mallocfunc(strlen(buf) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + case CORD_TYPE_BOOL: + val[i]->type = ccsp_boolean; + const char *bstr = params[i].value.boolValue ? true : false; + val[i]->parameterValue = bus_info->mallocfunc(strlen(bstr) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + + case CORD_TYPE_STRING: + val[i]->type = ccsp_string; + val[i]->parameterValue = bus_info->mallocfunc(strlen(params[i].value.stringValue) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, params[i].value.stringValue,strlen(params[i].value.stringValue) + 1); + break; + case CORD_TYPE_I64: + val[i]->type = ccsp_long; + snprintf(buf, sizeof(buf), "%" PRId64, (int64_t)params[i].value.i64Value); + val[i]->parameterValue = bus_info->mallocfunc(strlen(buf) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + case CORD_TYPE_U64: + val[i]->type = ccsp_unsignedLong; + snprintf(buf, sizeof(buf), "%" PRIu64, (uint64_t)params[i].value.u64Value); + val[i]->parameterValue = bus_info->mallocfunc(strlen(buf) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + case CORD_TYPE_DOUBLE: + val[i]->type = ccsp_double; + snprintf(buf, sizeof(buf), "%.17g", params[i].value.doubleValue); + val[i]->parameterValue = bus_info->mallocfunc(strlen(buf) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + case CORD_TYPE_DATETIME: + val[i]->type = ccsp_dateTime; + snprintf(buf, sizeof(buf), "%ld", (long)params[i].value.dateTimeValue); + val[i]->parameterValue = bus_info->mallocfunc(strlen(buf) + 1); + if(NULL == val[i]->parameterValue ){ret = CCSP_ERR_MEMORY_ALLOC_FAIL;break;} + memcpy(val[i]->parameterValue, buf,strlen(buf) + 1); + break; + default: + ret = CCSP_CR_ERR_UNSUPPORTED_DATATYPE; + break; + } + if(ret != CCSP_SUCCESS) break; + } + *records = val; + if(ret != CCSP_SUCCESS) + { + if(val) + { + for(int j = 0; j <= i; j++) { + if(val[j]) { + if(val[j]->parameterName) + bus_info->freefunc(val[j]->parameterName); + if(val[j]->parameterValue) + bus_info->freefunc(val[j]->parameterValue); + bus_info->freefunc(val[j]); + } + } + bus_info->freefunc(val); + val = NULL; + } + } + + } + cord_free_parameters(params); + return ret; + +#else /* !CORD_ENABLED */ + snprintf(psmName, sizeof(psmName), "%s%s", (subsys ? subsys : ""), CCSP_DBUS_PSM); return CcspBaseIf_getParameterValues(bus_handle, psmName, CCSP_DBUS_PATH_PSM, (char **)names, nname, nrec, records); -} +#endif /* CORD_ENABLED */ +} void PsmFreeRecords(void *bus_handle, parameterValStruct_t **records, int nrec) { free_parameterValStruct_t(bus_handle, nrec, records); } +#ifdef CORD_ENABLED +/** + * safe_atou - safely extract and convert the last path segment of pParameterName + * to an unsigned int. Skips any trailing dot before locating the segment. + * Returns 0 on success, -1 on NULL input, empty segment, non-numeric chars, or overflow. + */ +static inline int safe_atou(const char *pParameterName, unsigned int *out) +{ + if (!pParameterName || !out) + return -1; + + const size_t len = strlen(pParameterName); + if (len == 0) + return -1; + + /* Find end of last segment, skipping any trailing dot */ + const char *end = pParameterName + len; + if (*(end - 1) == '.') + end--; + + if (end == pParameterName) + return -1; + + /* Find start of last segment */ + const char *start = end; + while (start > pParameterName && *(start - 1) != '.') + start--; + + /* Copy segment into a local buffer for strtoul */ + size_t segLen = (size_t)(end - start); + if (segLen == 0 || segLen >= 32) + return -1; + + char *endptr; + unsigned long val; + errno = 0; + val = strtoul(start, &endptr, 10); + if (errno != 0 || endptr == start || *endptr != '\0' || val > UINT_MAX) + return -1; + + + *out = (unsigned int)val; + return 0; +} + +typedef struct cord_list_GetNextLevelInstances_List { + unsigned int* pInstanceArray; + size_t nCount, nCapacity; + bool callbackError; + void* bus_handle; +}GNLInstanceList; +static void cord_list_callback_GetNextLevelInstances(const char* pParameterName, cord_value_type_t valueType, void* pUserData) { + static const size_t kDefaultArraySize = 32; + GNLInstanceList *pList = (GNLInstanceList*)pUserData; + + if (!pList) return; + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)pList->bus_handle; + const size_t len = strlen(pParameterName); + if (valueType != CORD_TYPE_OBJECT_PATH || pParameterName[len - 1] != '.') { + pList->callbackError = true; + return; + } + + // Do we need to alloc or grow the array? + if (pList->nCount == pList->nCapacity) { + const size_t nNewCapacity = pList->nCapacity ? pList->nCapacity * 2 : kDefaultArraySize; + unsigned int* pNewInstanceArray = bus_info->mallocfunc(sizeof(*pList->pInstanceArray) * nNewCapacity); + + if (!pNewInstanceArray) { + pList->callbackError = true; + return; + } + pList->pInstanceArray = pNewInstanceArray; + pList->nCapacity = nNewCapacity; + } + //pListItem->pInstanceArray[pList->nCount] = safe_atou(); + if(0 == safe_atou(pParameterName, &pList->pInstanceArray[pList->nCount])) + pList->nCount++; + else { + pList->callbackError = true; + return; + } +}; +#endif /* CORD_ENABLED */ + int PsmGetNextLevelInstances ( void* bus_handle, @@ -3346,9 +4041,43 @@ int PsmGetNextLevelInstances unsigned int** ppInstanceArray ) { - char psmName[256]; + char psmName[512] = ""; errno_t rc = -1; +#ifdef CORD_ENABLED + *ppInstanceArray = NULL; + *pulNumInstance = 0; + + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; + if (pSubSystemPrefix && pSubSystemPrefix[0] != 0) { + rc = strcpy_s(psmName, sizeof(psmName), pSubSystemPrefix); + ERR_CHK(rc); + } + rc = strcat_s(psmName, sizeof(psmName), CCSP_DBUS_PSM); + ERR_CHK(rc); + rc = strcat_s(psmName, sizeof(psmName), "."); + ERR_CHK(rc); + rc = strcat_s(psmName, sizeof(psmName), pParentPath); + ERR_CHK(rc); + + GNLInstanceList list = {0}; + list.bus_handle = bus_handle; + cord_rc_t crc = cord_list(psmName, 1, cord_list_callback_GetNextLevelInstances, (void*)&list); + if (crc != CORD_RC_SUCCESS) { + return CCSP_Message_Bus_ERROR; + } + if (list.callbackError) { + if (list.pInstanceArray) { + bus_info->freefunc(list.pInstanceArray); + } + return CCSP_Message_Bus_OOM; + } + + *ppInstanceArray = list.pInstanceArray; + *pulNumInstance = list.nCount; + + return CCSP_SUCCESS; +#else /* !CORD_ENABLED */ if ( pSubSystemPrefix && pSubSystemPrefix[0] != 0 ) { rc = sprintf_s(psmName, sizeof(psmName), "%s%s", pSubSystemPrefix, CCSP_DBUS_PSM); @@ -3372,8 +4101,54 @@ int PsmGetNextLevelInstances pulNumInstance, ppInstanceArray ); +#endif /* !CORD_ENABLED */ + +} +#ifdef CORD_ENABLED +typedef struct cord_list_PsmEnumRecords_ListItem { + char *pParameterName; + cord_value_type_t valueType; + struct cord_list_PsmEnumRecords_ListItem *pNext; +}ERListItem; +typedef struct cord_list_PsmEnumRecords_List { + ERListItem *pHead; + size_t nCount; + bool nextLevel; + bool callbackError; +}ERList; + +static void cord_list_callback_PsmEnumRecords(const char* pParameterName, cord_value_type_t valueType, void* pUserData) { + ERList *pList = (ERList*)pUserData; + + if (!pList) return; + if (pList->nextLevel == false && valueType == CORD_TYPE_OBJECT_PATH) return; // PSM behaviour - only object/instance returned if nextLevel==true + + const size_t lenNameWithNull = strlen(pParameterName) + 1; + + // Append new list item + ERListItem *pListItem = malloc(sizeof(ERListItem) + lenNameWithNull); + if (!pListItem) { + pList->callbackError = true; + return; + } + pListItem->pParameterName = (char*)(pListItem + 1); + memcpy(pListItem->pParameterName, pParameterName, lenNameWithNull); + pListItem->valueType = valueType; + pListItem->pNext = pList->pHead; + pList->pHead = pListItem; + pList->nCount++; } +static void FreeList(ERList* pList) +{ + if(!pList->pHead) return; + while (pList->pHead) { + ERListItem *pItem = pList->pHead; + pList->pHead = pItem->pNext; + free(pItem); + } +} +#endif /* CORD_ENABLED */ int PsmEnumRecords ( @@ -3385,9 +4160,99 @@ int PsmEnumRecords PCCSP_BASE_RECORD* ppRecArray ) { - char psmName[256]; + char psmName[512] = ""; errno_t rc = -1; +#ifdef CORD_ENABLED + *ppRecArray = NULL; + *pulNumRec = 0; + + if (pSubSystemPrefix && pSubSystemPrefix[0] != 0) { + rc = strcpy_s(psmName, sizeof(psmName), pSubSystemPrefix); + ERR_CHK(rc); + } + rc = strcat_s(psmName, sizeof(psmName), CCSP_DBUS_PSM); + ERR_CHK(rc); + rc = strcat_s(psmName, sizeof(psmName), "."); + ERR_CHK(rc); + rc = strcat_s(psmName, sizeof(psmName), pParentPath); + ERR_CHK(rc); + ERList list = {0}; + list.nextLevel = nextLevel; + const size_t depth = nextLevel ? 1 : 0; + cord_rc_t crc = cord_list(psmName, depth, cord_list_callback_PsmEnumRecords, (void*)&list); + if (crc != CORD_RC_SUCCESS) { + return CCSP_Message_Bus_ERROR; + } + if (list.callbackError) { + //free linked list + FreeList(&list); + return CCSP_Message_Bus_OOM; + } + + // Alloc output array + CCSP_MESSAGE_BUS_INFO *bus_info = (CCSP_MESSAGE_BUS_INFO *)bus_handle; + PCCSP_BASE_RECORD pRecArray = NULL; + size_t recArraySize = list.nCount * sizeof(CCSP_BASE_RECORD); + if (bus_info && bus_info->mallocfunc) { + pRecArray = (PCCSP_BASE_RECORD)bus_info->mallocfunc(recArraySize); + if (pRecArray) { + memset(pRecArray, 0, recArraySize); + } + } else { + pRecArray = (PCCSP_BASE_RECORD)calloc(list.nCount, sizeof(CCSP_BASE_RECORD)); + } + + + if (!pRecArray) { + //free linked list + FreeList(&list); + return CCSP_Message_Bus_OOM; + } + size_t idxRecArray = 0; + size_t len = 0; + + // Traverse list, transcode to expected format. + while (list.pHead) { + ERListItem *pItem = list.pHead; + + if (pItem->valueType == CORD_TYPE_OBJECT_PATH) { + //last node name is all integer digits + len = strlen(pItem->pParameterName); + if (pItem->pParameterName[len-1] != '.') { + pRecArray[idxRecArray].RecordType = CCSP_BASE_INSTANCE; + //pRecArray[idxRecArray].InstanceNumber = safe_atou(); + if(0 != safe_atou(pItem->pParameterName, &(pRecArray[idxRecArray].Instance.InstanceNumber))); + CcspTraceError(("%s error while collecting the items\n", __FUNCTION__)); + + } + else { + pRecArray[idxRecArray].RecordType = CCSP_BASE_OBJECT; + strncpy(pRecArray[idxRecArray].Instance.Name, pItem->pParameterName, CCSP_BASE_PARAM_LENGTH-1); + pRecArray[idxRecArray].Instance.Name[CCSP_BASE_PARAM_LENGTH-1] = '\0'; + } + } + else { + pRecArray[idxRecArray].RecordType = CCSP_BASE_PARAM; + strncpy(pRecArray[idxRecArray].Instance.Name, pItem->pParameterName, CCSP_BASE_PARAM_LENGTH-1); + pRecArray[idxRecArray].Instance.Name[CCSP_BASE_PARAM_LENGTH-1] = '\0'; + } + + list.pHead = pItem->pNext; // Unlink this list item from list + free(pItem); + + idxRecArray++; + } + + *ppRecArray = pRecArray; + *pulNumRec = list.nCount; + + return CCSP_SUCCESS; + + + +#else /* !CORD_ENABLED */ + if ( pSubSystemPrefix && pSubSystemPrefix[0] != 0 ) { rc = sprintf_s(psmName, sizeof(psmName), "%s%s", pSubSystemPrefix, CCSP_DBUS_PSM); @@ -3412,6 +4277,8 @@ int PsmEnumRecords pulNumRec, ppRecArray ); +#endif /* CORD_ENABLED */ + } int PSM_Reset_UserChangeFlag @@ -3421,11 +4288,34 @@ int PSM_Reset_UserChangeFlag char const * const pathName ) { + +#ifdef CORD_ENABLED + static const char kPrefix[] = "UserChanged."; + static const size_t kPrefixLen = sizeof(kPrefix) - 1; + enum { kBufSize = 256 }; + static const size_t kMaxPathLen = kBufSize - kPrefixLen - 1; + + if (!pathName) { + return CCSP_ERR_INVALID_PARAMETER_VALUE; + } + + const size_t path_len = strnlen(pathName, kMaxPathLen + 1); + if (path_len > kMaxPathLen) { + return CCSP_ERR_INVALID_PARAMETER_VALUE; /* or a better “name too long” error */ + } + char record_name[kBufSize] = "UserChanged."; + memcpy(record_name + kPrefixLen, pathName, path_len); + record_name[kPrefixLen + path_len] = '\0'; + +#else /* !CORD_ENABLED */ + char record_name[256]; snprintf(record_name, sizeof(record_name), "UserChanged.%s", pathName); +#endif /* CORD_ENABLED */ return PSM_Del_Record(bus_handle, pSubSystemPrefix, record_name); + } /* The function is called to register event, if the interface name and data path is NULL. Default is register the base interface*/ diff --git a/source/util_api/ccsp_msg_bus/ccsp_message_bus.c b/source/util_api/ccsp_msg_bus/ccsp_message_bus.c index d684b2cb2..66dec2df5 100644 --- a/source/util_api/ccsp_msg_bus/ccsp_message_bus.c +++ b/source/util_api/ccsp_msg_bus/ccsp_message_bus.c @@ -38,7 +38,6 @@ #include #include #include -#include #include #include #include "ccsp_base_api.h" @@ -54,6 +53,9 @@ #include #include +#ifdef CORD_ENABLED +#include +#endif #ifdef _DEBUG // #define _DEBUG_LOCAL_ @@ -1116,6 +1118,11 @@ CCSP_Message_Bus_Init } /*CID: 110434 Resource leak*/ fclose(fp); +#ifdef CORD_ENABLED + if(CORD_RC_SUCCESS != cord_open()) + CcspTraceError(("<%s>: Cord open failed\n", __FUNCTION__)); + +#endif return 0; } @@ -1137,6 +1144,9 @@ CCSP_Message_Bus_Exit CcspTraceError(("<%s>: rbus_close fails with %d\n", __FUNCTION__,rc)); bus_info->freefunc(bus_info); bus_info = NULL; +#ifdef CORD_ENABLED + cord_close(); +#endif } static void @@ -1567,17 +1577,33 @@ void ccsp_handle_rbus_component_reply (void* bus_handle, rbusMessage msg, rbusVa case RBUS_INT64: { rbusMessage_GetInt64(msg, &i64); - n = snprintf(pTmp, 0, "%" PRId64, i64) + 1; +#ifdef _64BIT_ARCH_SUPPORT_ + n = snprintf(pTmp, 0, "%ld", i64) + 1; +#else + n = snprintf(pTmp, 0, "%lld", i64) + 1; +#endif *pStringValue = bus_info->mallocfunc(n); - snprintf(*pStringValue, (unsigned int)n, "%" PRId64, i64); +#ifdef _64BIT_ARCH_SUPPORT_ + snprintf(*pStringValue, (unsigned int)n, "%ld", i64); +#else + snprintf(*pStringValue, (unsigned int)n, "%lld", i64); +#endif break; } case RBUS_UINT64: { rbusMessage_GetInt64(msg, &i64); - n = snprintf(pTmp, 0, "%" PRIu64, (uint64_t)i64) + 1; +#ifdef _64BIT_ARCH_SUPPORT_ + n = snprintf(pTmp, 0, "%lu", (uint64_t)i64) + 1; +#else + n = snprintf(pTmp, 0, "%llu", (uint64_t)i64) + 1; +#endif *pStringValue = bus_info->mallocfunc(n); - snprintf(*pStringValue, (unsigned int)n, "%" PRIu64, (uint64_t)i64); +#ifdef _64BIT_ARCH_SUPPORT_ + snprintf(*pStringValue, (unsigned int)n, "%lu", (uint64_t)i64); +#else + snprintf(*pStringValue, (unsigned int)n, "%llu", (uint64_t)i64); +#endif break; } case RBUS_SINGLE: diff --git a/source/util_api/tls/components/TlsHandShaker/tls_hso_control.c b/source/util_api/tls/components/TlsHandShaker/tls_hso_control.c index 8acf8be41..f5e0952f5 100644 --- a/source/util_api/tls/components/TlsHandShaker/tls_hso_control.c +++ b/source/util_api/tls/components/TlsHandShaker/tls_hso_control.c @@ -475,12 +475,21 @@ TlsHsoCalKeys30 PTLS_RECORD_STATE pRecordStateR = (PTLS_RECORD_STATE )&pMyObject->RecordStateR; PTLS_MEC_INTERFACE pTlsMecIf = (PTLS_MEC_INTERFACE )pMyObject->hTlsMecIf; PTLS_CRYPTO_PROVIDER_OBJECT pTlsCryptoProvider = (PTLS_CRYPTO_PROVIDER_OBJECT)pTlsMecIf->GetTlsCryptoProvider(pTlsMecIf->hOwnerContext); +#ifdef _64BIT_ARCH_SUPPORT_ ANSC_CRYPTO_KEY* pMacSecretC = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->MacSecret : &pRecordStateW->MacSecret; ANSC_CRYPTO_KEY* pMacSecretS = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->MacSecret : &pRecordStateR->MacSecret; ANSC_CRYPTO_KEY* pCipherKeyC = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherKey : &pRecordStateW->CipherKey; ANSC_CRYPTO_KEY* pCipherKeyS = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherKey : &pRecordStateR->CipherKey; ANSC_CRYPTO_IV* pCipherIV_C = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherIV : &pRecordStateW->CipherIV; ANSC_CRYPTO_IV* pCipherIV_S = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherIV : &pRecordStateR->CipherIV; +#else + ANSC_CRYPTO_KEY* pMacSecretC = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->MacSecret : &pRecordStateW->MacSecret; + ANSC_CRYPTO_KEY* pMacSecretS = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->MacSecret : &pRecordStateR->MacSecret; + ANSC_CRYPTO_KEY* pCipherKeyC = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherKey : &pRecordStateW->CipherKey; + ANSC_CRYPTO_KEY* pCipherKeyS = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherKey : &pRecordStateR->CipherKey; + ANSC_CRYPTO_IV* pCipherIV_C = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherIV : &pRecordStateW->CipherIV; + ANSC_CRYPTO_IV* pCipherIV_S = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherIV : &pRecordStateR->CipherIV; +#endif PUCHAR pKeyBlock = (PUCHAR )NULL; ULONG write_key_length = 0; ULONG key_block_offset = 0; @@ -836,12 +845,21 @@ TlsHsoCalKeys31 PTLS_RECORD_STATE pRecordStateR = (PTLS_RECORD_STATE )&pMyObject->RecordStateR; PTLS_MEC_INTERFACE pTlsMecIf = (PTLS_MEC_INTERFACE )pMyObject->hTlsMecIf; PTLS_CRYPTO_PROVIDER_OBJECT pTlsCryptoProvider = (PTLS_CRYPTO_PROVIDER_OBJECT)pTlsMecIf->GetTlsCryptoProvider(pTlsMecIf->hOwnerContext); +#ifdef _64BIT_ARCH_SUPPORT_ ANSC_CRYPTO_KEY* pMacSecretC = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->MacSecret : &pRecordStateW->MacSecret; ANSC_CRYPTO_KEY* pMacSecretS = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->MacSecret : &pRecordStateR->MacSecret; ANSC_CRYPTO_KEY* pCipherKeyC = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherKey : &pRecordStateW->CipherKey; ANSC_CRYPTO_KEY* pCipherKeyS = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherKey : &pRecordStateR->CipherKey; ANSC_CRYPTO_IV* pCipherIV_C = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherIV : &pRecordStateW->CipherIV; ANSC_CRYPTO_IV* pCipherIV_S = (ANSC_CRYPTO_KEY* )(ULONG)(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherIV : &pRecordStateR->CipherIV; +#else + ANSC_CRYPTO_KEY* pMacSecretC = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->MacSecret : &pRecordStateW->MacSecret; + ANSC_CRYPTO_KEY* pMacSecretS = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->MacSecret : &pRecordStateR->MacSecret; + ANSC_CRYPTO_KEY* pCipherKeyC = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherKey : &pRecordStateW->CipherKey; + ANSC_CRYPTO_KEY* pCipherKeyS = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherKey : &pRecordStateR->CipherKey; + ANSC_CRYPTO_IV* pCipherIV_C = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateR->CipherIV : &pRecordStateW->CipherIV; + ANSC_CRYPTO_IV* pCipherIV_S = (ANSC_CRYPTO_KEY* )(pSecurityParams->ConnectionEnd == TLS_CONNECTION_END_server)? &pRecordStateW->CipherIV : &pRecordStateR->CipherIV; +#endif PUCHAR pKeyBlock = (PUCHAR )NULL; ULONG write_key_length = 0; ULONG key_block_offset = 0;