| /** |
| * Copyright(c) 2011 Trusted Logic. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name Trusted Logic nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <stdio.h> |
| #include <ctype.h> |
| #include <string.h> |
| |
| #if defined(_WIN32_WCE) |
| #include "os_wm.h" |
| #else |
| #include <errno.h> |
| #endif |
| |
| #include "smc_properties_parser.h" |
| #include "lib_manifest2.h" |
| #include "s_error.h" |
| |
| /* --------------------------------------------------------------------------------- |
| Defines |
| ---------------------------------------------------------------------------------*/ |
| |
| #define STRUE "true" |
| #define SFALSE "false" |
| |
| #if defined(_WIN32_WCE) |
| #define GET_LAST_ERR GetLastError() |
| #else |
| #define GET_LAST_ERR errno |
| #endif |
| |
| #if defined (LINUX) || defined (__SYMBIAN32__) || defined (__ANDROID32__) |
| #define STRICMP strcasecmp |
| #elif defined(_WIN32_WCE) |
| #define STRICMP _stricmp |
| #else |
| #define STRICMP stricmp |
| #endif |
| |
| |
| /* --------------------------------------------------------------------------------- |
| Logs and Traces. |
| ---------------------------------------------------------------------------------*/ |
| #ifdef __SYMBIAN32__ |
| #include "os_symbian.h" |
| #elif NDEBUG |
| /* Compile-out the traces */ |
| #define TRACE_ERROR(...) |
| #define TRACE_WARNING(...) |
| #define TRACE_INFO(...) |
| #else |
| #include <stdarg.h> |
| static void TRACE_ERROR(const char* format, ...) |
| { |
| va_list ap; |
| va_start(ap, format); |
| fprintf(stderr, "TRACE: ERROR: "); |
| vfprintf(stderr, format, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| } |
| |
| static void TRACE_WARNING(const char* format, ...) |
| { |
| va_list ap; |
| va_start(ap, format); |
| fprintf(stderr, "TRACE: WARNING: "); |
| vfprintf(stderr, format, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| } |
| |
| static void TRACE_INFO(const char* format, ...) |
| { |
| va_list ap; |
| va_start(ap, format); |
| fprintf(stderr, "TRACE: "); |
| vfprintf(stderr, format, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| } |
| #endif /* NDEBUG */ |
| |
| /* --------------------------------------------------------------------------------- |
| private functions. |
| ---------------------------------------------------------------------------------*/ |
| |
| static NODE* static_listFindNodeElement(NODE* pList,char* pName,bool bIsCaseSensitive) |
| { |
| int32_t nCmp; |
| |
| assert(pName!=NULL); |
| |
| while (pList!=NULL) |
| { |
| if (bIsCaseSensitive) |
| { |
| nCmp=strcmp(pName,pList->pName); |
| } |
| else |
| { |
| nCmp=STRICMP(pName,pList->pName); |
| } |
| if (nCmp>0) |
| { |
| pList=pList->pRight; |
| } |
| else if (nCmp<0) |
| { |
| pList=pList->pLeft; |
| } |
| else |
| { |
| break; |
| } |
| } |
| return pList; |
| } |
| |
| |
| static S_RESULT static_listSortedAddNode(NODE* pList,NODE* pNode) |
| { |
| int32_t nCmp; |
| |
| do { |
| nCmp=strcmp(pNode->pName,pList->pName); |
| if (nCmp>0) |
| { |
| if (pList->pRight!=NULL) |
| { |
| pList=pList->pRight; |
| } |
| else |
| { |
| pList->pRight=pNode; |
| /* update linked list */ |
| pNode->pPrevious=pList; |
| pNode->pNext=pList->pNext; |
| if (pList->pNext!=NULL) |
| { |
| pList->pNext->pPrevious=pNode; |
| } |
| pList->pNext=pNode; |
| return S_SUCCESS; |
| } |
| } |
| else if (nCmp<0) |
| { |
| if (pList->pLeft!=NULL) |
| { |
| pList=pList->pLeft; |
| } |
| else |
| { |
| pList->pLeft=pNode; |
| /* update linked list */ |
| pNode->pNext=pList; |
| pNode->pPrevious=pList->pPrevious; |
| if (pList->pPrevious!=NULL) |
| { |
| pList->pPrevious->pNext=pNode; |
| } |
| pList->pPrevious=pNode; |
| return S_SUCCESS; |
| } |
| } |
| } while (nCmp!=0); |
| |
| TRACE_ERROR("%s already exist !\n",pNode->pName); |
| return S_ERROR_ITEM_EXISTS; |
| } |
| |
| |
| static S_RESULT SMCPropListSortedAdd(LIST* pList,NODE* pNode) |
| { |
| S_RESULT nResult; |
| |
| assert(pList!=NULL && pNode!=NULL); |
| |
| if (pNode->pName==NULL) |
| { |
| TRACE_ERROR("Trying to insert a NULL node name !\n"); |
| return S_ERROR_BAD_PARAMETERS; |
| } |
| |
| if (pList->pRoot==NULL) |
| { |
| pList->pRoot=pNode; |
| pList->pFirst=pNode; |
| return S_SUCCESS; |
| } |
| else |
| { |
| nResult=static_listSortedAddNode(pList->pRoot,pNode); |
| /* update the first node of the linked list */ |
| if (nResult==S_SUCCESS && pNode->pPrevious==NULL) |
| { |
| pList->pFirst=pNode; |
| } |
| } |
| return nResult; |
| } |
| |
| |
| static NODE* SMCPropListFindElement(LIST* pList,char* pName,bool bIsCaseSensitive) |
| { |
| if (pList->pRoot!=NULL) |
| { |
| return static_listFindNodeElement(pList->pRoot,pName,bIsCaseSensitive); |
| } |
| return NULL; |
| } |
| |
| |
| static S_RESULT SMCPropYacc(uint8_t* pBuffer, uint32_t nBufferLength, |
| CONF_FILE* pConfFile) |
| { |
| S_RESULT nError=S_SUCCESS; |
| LIST *pPublicPropertyList=NULL; |
| LIST *pPrivatePropertyList=NULL; |
| PROPERTY* pProperty=NULL; |
| SERVICE_SECTION* pServSection; |
| SERVICE_SECTION* pPreviousService=NULL; |
| |
| uint8_t* pName; |
| uint32_t nNameLength; |
| uint8_t* pValue; |
| uint32_t nValueLength; |
| char* pNameZ = NULL; |
| char* pValueZ = NULL; |
| LIB_MANIFEST2_CONTEXT sParserContext; |
| char serviceManifestName[1024]; |
| |
| sParserContext.pManifestName = "Configuration File"; |
| sParserContext.pManifestContent = pBuffer; |
| sParserContext.nManifestLength = nBufferLength; |
| sParserContext.nType = LIB_MANIFEST2_TYPE_SOURCE_WITH_SECTIONS; |
| |
| libManifest2InitContext(&sParserContext); |
| |
| while (true) |
| { |
| nError = libManifest2GetNextItem( |
| &sParserContext, |
| &pName, |
| &nNameLength, |
| &pValue, |
| &nValueLength); |
| if (nError == S_ERROR_ITEM_NOT_FOUND) |
| { |
| /* End of parsing */ |
| nError = S_SUCCESS; |
| break; |
| } |
| else if (nError != S_SUCCESS) |
| { |
| /* Error */ |
| goto error; |
| } |
| |
| /* Duplicate name and value in as zero-terminated strings */ |
| /* Unclean: those strings are not going to be deallocated |
| This is not a problem because this code is run in a tool |
| */ |
| pNameZ = malloc(nNameLength+1); |
| if (pNameZ == NULL) |
| { |
| nError = S_ERROR_OUT_OF_MEMORY; |
| goto error; |
| } |
| memcpy(pNameZ, pName, nNameLength); |
| pNameZ[nNameLength] = 0; |
| |
| if (pValue == NULL) |
| { |
| /* It's a section */ |
| if (STRICMP(pNameZ, SYSTEM_SECTION_NAME) == 0) |
| { |
| free(pNameZ); |
| pPublicPropertyList=&pConfFile->sSystemSectionPropertyList; |
| } |
| else |
| { |
| pServSection=(SERVICE_SECTION*)SMCPropListFindElement( |
| &pConfFile->sDriverSectionList, |
| pNameZ, |
| false); |
| if (pServSection==NULL) |
| { |
| pServSection=(SERVICE_SECTION*)SMCPropListFindElement( |
| &pConfFile->sPreinstalledSectionList, |
| pNameZ, |
| false); |
| } |
| if (pServSection==NULL) |
| { |
| pServSection=(SERVICE_SECTION*)SMCPropListFindElement( |
| &pConfFile->sSectionList, |
| pNameZ, |
| false); |
| if (pServSection==NULL) |
| { |
| nError=S_ERROR_ITEM_NOT_FOUND; |
| goto error; |
| } |
| } |
| free(pNameZ); |
| |
| pServSection->inSCF=true; |
| if (pPreviousService!=NULL) |
| { |
| pPreviousService->pNextInSCF=pServSection; |
| } |
| else |
| { |
| pConfFile->pFirstSectionInSCF=pServSection; |
| } |
| pPreviousService=pServSection; |
| |
| pPublicPropertyList=&pServSection->sPublicPropertyList; |
| pPrivatePropertyList=&pServSection->sPrivatePropertyList; |
| } |
| } |
| else |
| { |
| /* It's a property definition */ |
| pValueZ = malloc(nValueLength+1); |
| if (pValueZ == NULL) |
| { |
| nError = S_ERROR_OUT_OF_MEMORY; |
| goto error; |
| } |
| memcpy(pValueZ, pValue, nValueLength); |
| pValueZ[nValueLength] = 0; |
| |
| pProperty=(PROPERTY*)malloc(sizeof(PROPERTY)); |
| if (pProperty==NULL) |
| { |
| nError=S_ERROR_OUT_OF_MEMORY; |
| goto error; |
| } |
| memset(pProperty, 0x00, sizeof(PROPERTY)); |
| pProperty->sNode.pName=pNameZ; |
| |
| pProperty->pValue=pValueZ; |
| |
| if (pPrivatePropertyList==NULL) |
| { |
| nError=SMCPropListSortedAdd(pPublicPropertyList,(NODE*)pProperty); |
| if (nError!=S_SUCCESS) |
| { |
| goto error; |
| } |
| } |
| else |
| { |
| if ((nValueLength > strlen(CONFIG_PROPERTY_NAME)) && |
| (memcmp(pProperty->sNode.pName, CONFIG_PROPERTY_NAME, strlen(CONFIG_PROPERTY_NAME)) == 0)) |
| { |
| nError=SMCPropListSortedAdd(pPrivatePropertyList,(NODE*)pProperty); |
| } |
| else |
| { |
| nError=SMCPropListSortedAdd(pPublicPropertyList,(NODE*)pProperty); |
| } |
| if (nError!=S_SUCCESS) |
| { |
| goto error; |
| } |
| } |
| } |
| } |
| |
| error: |
| if (nError!=S_SUCCESS) |
| { |
| switch (nError) |
| { |
| case S_ERROR_BAD_FORMAT: |
| /* Error message already output */ |
| break; |
| case S_ERROR_WRONG_SIGNATURE: |
| TRACE_ERROR("Configuration file: wrong service UUID: %s\n", pValueZ); |
| break; |
| case S_ERROR_OUT_OF_MEMORY: |
| TRACE_ERROR("Out of memory\n"); |
| break; |
| case S_ERROR_ITEM_NOT_FOUND: |
| TRACE_ERROR("Configuration file: service \"%s\" not found\n", pNameZ); |
| break; |
| } |
| } |
| return nError; |
| } |
| |
| |
| S_RESULT static_readFile(const char* pFilename, void** ppFile, uint32_t* pnFileLength) |
| { |
| S_RESULT nResult = S_SUCCESS; |
| long nFilesize; |
| FILE* pFile = NULL; |
| void *pBuff = NULL; |
| |
| // open file and get its size... |
| if ((pFile = fopen(pFilename, "rb")) == NULL) |
| { |
| TRACE_ERROR("static_readFile: fopen(%s) failed [%d]", pFilename, GET_LAST_ERR); |
| nResult = S_ERROR_ITEM_NOT_FOUND; |
| return nResult; |
| } |
| if (fseek(pFile, 0, SEEK_END) != 0) |
| { |
| TRACE_ERROR("static_readFile: fseek(%s) failed [%d]", pFilename, GET_LAST_ERR); |
| nResult = S_ERROR_UNDERLYING_OS; |
| goto error; |
| } |
| nFilesize = ftell(pFile); |
| if (nFilesize < 0) |
| { |
| TRACE_ERROR("static_readFile: ftell(%s) failed [%d]", pFilename, GET_LAST_ERR); |
| nResult = S_ERROR_UNDERLYING_OS; |
| goto error; |
| } |
| rewind(pFile); |
| |
| // allocate the buffer |
| pBuff = malloc(nFilesize + 1); |
| if (pBuff == NULL) |
| { |
| TRACE_ERROR("static_readFile: out of memory"); |
| nResult = S_ERROR_OUT_OF_MEMORY; |
| goto error; |
| } |
| |
| // read the file |
| if (fread(pBuff, sizeof(uint8_t), (size_t)nFilesize, pFile) != (size_t)nFilesize) |
| { |
| TRACE_ERROR("static_readFile: fread failed [%d]", GET_LAST_ERR); |
| nResult = S_ERROR_UNDERLYING_OS; |
| goto error; |
| } |
| ((char*)pBuff)[nFilesize] = 0; |
| |
| *ppFile = pBuff; |
| *pnFileLength = nFilesize; |
| return S_SUCCESS; |
| |
| error: |
| if (pBuff != NULL) |
| free(pBuff); |
| fclose(pFile); |
| |
| *ppFile = NULL; |
| *pnFileLength = 0; |
| return nResult; |
| } |
| |
| |
| |
| |
| |
| /* --------------------------------------------------------------------------------- |
| API functions. |
| ---------------------------------------------------------------------------------*/ |
| |
| char* SMCPropGetSystemProperty(CONF_FILE* pConfFile, char* pPropertyName) |
| { |
| PROPERTY* pProperty; |
| |
| pProperty=(PROPERTY*)SMCPropListFindElement( |
| &pConfFile->sSystemSectionPropertyList, |
| pPropertyName, |
| true); |
| if (pProperty!=NULL) |
| { |
| return pProperty->pValue; |
| } |
| return NULL; |
| } |
| |
| uint32_t SMCPropGetSystemPropertyAsInt(CONF_FILE* pConfFile, char* pPropertyName) |
| { |
| uint32_t nValue; |
| char* pValue=SMCPropGetSystemProperty(pConfFile,pPropertyName); |
| |
| if (libString2GetStringAsInt(pValue, &nValue) == S_SUCCESS) |
| { |
| return nValue; |
| } |
| return 0; |
| } |
| |
| |
| S_RESULT SMCPropParseConfigFile(char* pConfigFilename,CONF_FILE* pConfFile) |
| { |
| S_RESULT nError=S_SUCCESS; |
| void* pFile; |
| uint32_t nFileLength; |
| bool bReuseManifest; |
| |
| assert(pConfFile!=NULL); |
| |
| TRACE_INFO("Processing configuration file '%s'", pConfigFilename); |
| |
| if(pConfigFilename != NULL) |
| { |
| nError=static_readFile(pConfigFilename,&pFile,&nFileLength); |
| if (nError!=S_SUCCESS) |
| { |
| goto error; |
| } |
| bReuseManifest = true; |
| } |
| else |
| { |
| assert(0); |
| } |
| |
| nError=SMCPropYacc(pFile,nFileLength,pConfFile); |
| |
| if(pConfigFilename != NULL) |
| { |
| free(pFile); |
| } |
| |
| error: |
| return nError; |
| } |
