/** * 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 #include #include #include #include #if defined(_WIN32_WCE) #include "os_wm.h" #else #include #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 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; }