/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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.
*/
/**
************************************************************************
* @file M4OSA_FileCommon.c
* @brief File common for Android
* @note This file implements functions used by both the file writer
* and file reader.
************************************************************************
*/
#ifndef USE_STAGEFRIGHT_CODECS
#error "USE_STAGEFRIGHT_CODECS is not defined"
#endif /*USE_STAGEFRIGHT_CODECS*/
#ifdef UTF_CONVERSION
#include <string.h>
#endif /*UTF_CONVERSION*/
#include <sys/stat.h>
#include <errno.h>
#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
#include "M4OSA_Semaphore.h"
#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
#include "M4OSA_Debug.h"
#include "M4OSA_FileCommon.h"
#include "M4OSA_FileCommon_priv.h"
#include "M4OSA_Memory.h"
#include "M4OSA_CharStar.h"
/**
************************************************************************
* @brief This function opens the provided URL and returns its context.
* If an error occured, the context is set to NULL.
* @param core_id: (IN) Core ID of the caller (M4OSA_FILE_READER or M4OSA_FILE_WRITER)
* @param context: (OUT) Context of the core file reader
* @param url: (IN) URL of the input file
* @param fileModeAccess: (IN) File mode access
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: at least one parameter is NULL
* @return M4ERR_ALLOC: there is no more memory available
* @return M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
* file
* @return M4ERR_FILE_NOT_FOUND: the file cannot be found
* @return M4ERR_FILE_LOCKED: the file is locked by an other
* application/process
* @return M4ERR_FILE_BAD_MODE_ACCESS: the file mode access is not correct
************************************************************************
*/
M4OSA_ERR M4OSA_fileCommonOpen(M4OSA_UInt16 core_id, M4OSA_Context* pContext,
M4OSA_Char* pUrl, M4OSA_FileModeAccess fileModeAccess)
{
M4OSA_Int32 i = 0;
M4OSA_Int32 iMode = 0;
M4OSA_Int32 iSize = 0;
M4OSA_Int32 iSavePos = 0;
M4OSA_Char mode[4] = "";
M4OSA_Char* pReadString = (M4OSA_Char*)"r";
M4OSA_Char* pWriteString = (M4OSA_Char*)"w";
M4OSA_Char* pAppendString = (M4OSA_Char*)"a";
M4OSA_Char* pBinaryString = (M4OSA_Char*)"b";
M4OSA_Char* pPlusString = (M4OSA_Char*)"+";
M4OSA_ERR err = M4NO_ERROR;
FILE* pFileHandler = M4OSA_NULL;
M4OSA_FileContext *pFileContext = M4OSA_NULL;
#ifdef UTF_CONVERSION
/*FB: to test the UTF16->UTF8 conversion into Video Artist*/
/*Convert the URL from UTF16 to UTF8*/
M4OSA_Void* tempConversionBuf;
M4OSA_UInt32 tempConversionSize = 1000;
tempConversionBuf = (M4OSA_Char*)M4OSA_32bitAlignedMalloc(tempConversionSize +1, 0, "conversion buf");
if(tempConversionBuf == M4OSA_NULL)
{
M4OSA_TRACE1_0("Error when allocating conversion buffer\n");
return M4ERR_PARAMETER;
}
M4OSA_ToUTF8_OSAL(pUrl, tempConversionBuf, &tempConversionSize);
((M4OSA_Char*)tempConversionBuf)[tempConversionSize ] = '\0';
printf("file open %s\n", tempConversionBuf);
#endif /*UTF CONVERSION*/
M4OSA_TRACE3_4("M4OSA_fileCommonOpen\t\tM4OSA_UInt16 %d\tM4OSA_Context* 0x%x\t"
"M4OSA_Char* %s\tfileModeAccess %d", core_id, pContext, pUrl, fileModeAccess);
M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, "M4OSA_fileCommonOpen: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER, "M4OSA_fileCommonOpen: pUrl is M4OSA_NULL");
M4OSA_DEBUG_IF2(0 == fileModeAccess, M4ERR_PARAMETER, "M4OSA_fileCommonOpen: fileModeAccess is 0");
/* Read mode not set for the reader */
M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && !(fileModeAccess & M4OSA_kFileRead),
M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileRead");
/* Read mode not set for the reader */
M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && !(fileModeAccess & M4OSA_kFileRead),
M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileRead");
/* M4OSAfileReadOpen cannot be used with Write file mode access */
M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && (fileModeAccess & M4OSA_kFileWrite),
M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileWrite");
/* Append and Create flags cannot be used with Read */
M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && (fileModeAccess & M4OSA_kFileAppend),
M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileAppend");
M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && (fileModeAccess & M4OSA_kFileCreate),
M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileCreate");
/* Write mode not set for the writer */
M4OSA_DEBUG_IF1((M4OSA_FILE_WRITER == core_id) && !(fileModeAccess & M4OSA_kFileWrite),
M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileWrite");
/* Create flag necessary for opening file */
if ((fileModeAccess & M4OSA_kFileRead) &&
(fileModeAccess & M4OSA_kFileWrite)&&(fileModeAccess & M4OSA_kFileCreate))
{
strncat((char *)mode, (const char *)pWriteString, (size_t)1);
strncat((char *)mode, (const char *)pPlusString, (size_t)1);
}
else
{
if(fileModeAccess & M4OSA_kFileAppend)
{
strncat((char *)mode, (const char *)pAppendString, (size_t)1);
}
else if(fileModeAccess & M4OSA_kFileRead)
{
strncat((char *)mode, (const char *)pReadString, (size_t)1);
}
else if(fileModeAccess & M4OSA_kFileWrite)
{
strncat((char *)mode, (const char *)pWriteString, (size_t)1);
}
if((fileModeAccess & M4OSA_kFileRead)&&(fileModeAccess & M4OSA_kFileWrite))
{
strncat((char *)mode,(const char *)pPlusString, (size_t)1);
}
}
if(!(fileModeAccess & M4OSA_kFileIsTextMode))
{
strncat((char *)mode, (const char *)pBinaryString,(size_t)1);
}
/*Open the file*/
#ifdef UTF_CONVERSION
/*Open the converted path*/
pFileHandler = fopen((const char *)tempConversionBuf, (const char *)mode);
/*Free the temporary decoded buffer*/
free(tempConversionBuf);
#else /* UTF_CONVERSION */
pFileHandler = fopen((const char *)pUrl, (const char *)mode);
#endif /* UTF_CONVERSION */
if (M4OSA_NULL == pFileHandler)
{
switch(errno)
{
case ENOENT:
{
M4OSA_DEBUG(M4ERR_FILE_NOT_FOUND, "M4OSA_fileCommonOpen: No such file or directory");
M4OSA_TRACE1_1("File not found: %s", pUrl);
return M4ERR_FILE_NOT_FOUND;
}
case EACCES:
{
M4OSA_DEBUG(M4ERR_FILE_LOCKED, "M4OSA_fileCommonOpen: Permission denied");
return M4ERR_FILE_LOCKED;
}
case EINVAL:
{
M4OSA_DEBUG(M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: Invalid Argument");
return M4ERR_FILE_BAD_MODE_ACCESS;
}
case EMFILE:
case ENOSPC:
case ENOMEM:
{
M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonOpen: Too many open files");
return M4ERR_ALLOC;
}
default:
{
M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_fileCommonOpen");
return M4ERR_NOT_IMPLEMENTED;
}
}
}
/* Allocate the file context */
pFileContext = (M4OSA_FileContext*) M4OSA_32bitAlignedMalloc(sizeof(M4OSA_FileContext),
core_id, (M4OSA_Char*)"M4OSA_fileCommonOpen: file context");
if (M4OSA_NULL == pFileContext)
{
fclose(pFileHandler);
M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonOpen");
return M4ERR_ALLOC;
}
pFileContext->file_desc = pFileHandler;
pFileContext->access_mode = fileModeAccess;
pFileContext->current_seek = SeekNone;
pFileContext->b_is_end_of_file = M4OSA_FALSE;
/**
* Note: Never use this expression "i = (value1 == value2) ? x: y;"
* because that doens't compile on other platforms (ADS for example)
* Use: if(value1 == value2)
* { i= x; ..etc
*/
pFileContext->coreID_write = 0;
pFileContext->coreID_read = 0;
pFileContext->m_DescrModeAccess = M4OSA_kDescNoneAccess;
if (M4OSA_FILE_READER == core_id)
{
pFileContext->coreID_read = core_id;
pFileContext->m_DescrModeAccess = M4OSA_kDescReadAccess;
}
else if (M4OSA_FILE_WRITER == core_id)
{
pFileContext->coreID_write = core_id;
pFileContext->m_DescrModeAccess = M4OSA_kDescWriteAccess;
}
pFileContext->read_position = 0;
pFileContext->write_position = 0;
/* Allocate the memory to store the URL string */
pFileContext->url_name = (M4OSA_Char*) M4OSA_32bitAlignedMalloc(strlen((const char *)pUrl)+1,
core_id, (M4OSA_Char*)"M4OSA_fileCommonOpen: URL name");
if (M4OSA_NULL == pFileContext->url_name)
{
fclose(pFileHandler);
free(pFileContext);
M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonOpen");
return M4ERR_ALLOC;
}
M4OSA_chrNCopy(pFileContext->url_name, pUrl, strlen((const char *)pUrl)+1);
/* Get the file name */
err = M4OSA_fileCommonGetFilename(pUrl, &pFileContext->file_name);
if(M4NO_ERROR != err)
{
fclose(pFileHandler);
free(pFileContext->url_name);
free(pFileContext);
M4OSA_DEBUG(err, "M4OSA_fileCommonOpen");
return err;
}
#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
M4OSA_semaphoreOpen(&(pFileContext->semaphore_context), 1); /* Allocate the semaphore */
#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
#ifdef USE_STAGEFRIGHT_CODECS
// Workaround for file system bug on Stingray/Honeycomb where a file re-created will keep
// the original file's size filled with 0s. Do not seek to the end to avoid ill effects
if(fileModeAccess & M4OSA_kFileAppend) {
/* Get the file size */
iSavePos = ftell(pFileHandler); /* 1- Check the first position */
fseek(pFileHandler, 0, SEEK_END); /* 2- Go to the end of the file*/
iSize = ftell(pFileHandler); /* 3- Check the file size */
fseek(pFileHandler, iSavePos, SEEK_SET);/* 4- go to the first position */
} else {
iSize = 0;
}
#else /* USE_STAGEFRIGHT_CODECS */
/* Get the file size */
iSavePos = ftell(pFileHandler); /* 1- Check the first position */
fseek(pFileHandler, 0, SEEK_END); /* 2- Go to the end of the file*/
iSize = ftell(pFileHandler); /* 3- Check the file size */
fseek(pFileHandler, iSavePos, SEEK_SET);/* 4- go to the first position */
#endif /* USE_STAGEFRIGHT_CODECS */
/* Warning possible overflow if the file is higher than 2GBytes */
pFileContext->file_size = iSize;
*pContext = pFileContext;
return M4NO_ERROR;
}
/**
************************************************************************
* @brief This function convert from UTF16 to UTF8
* @param pBufferIn: (IN) UTF16 input path
* @param pBufferOut: (OUT) UTF8 output path
* @param bufferOutSize: (IN/OUT) size of the output path
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: the output path size is not enough to contain
* the decoded path
************************************************************************
*/
#ifdef UTF_CONVERSION
M4OSA_ERR M4OSA_ToUTF8_OSAL (M4OSA_Void *pBufferIn, M4OSA_UInt8 *pBufferOut,
M4OSA_UInt32 *bufferOutSize)
{
M4OSA_UInt16 i;
wchar_t *w_str = (wchar_t *) pBufferIn;
M4OSA_UInt32 len, size_needed, size_given;
if (pBufferIn == NULL)
{
*pBufferOut=NULL;
*bufferOutSize=1;
}
else
{
len = wcslen(w_str);
size_needed = len+1;
size_given = *bufferOutSize;
*bufferOutSize=size_needed;
if (size_given < size_needed )
{
return M4ERR_PARAMETER;
}
else
{
for (i=0; i<len; i++)
{
pBufferOut[i]=(M4OSA_UInt8)w_str[i];
}
pBufferOut[len]=0;
}
}
return M4NO_ERROR;
}
#endif /*UTF CONVERSION*/
/**
************************************************************************
* @brief This function seeks at the provided position.
* @param context: (IN/OUT) Context of the core file reader
* @param seekMode: (IN) Seek access mode
* @param position: (IN/OUT) Position in the file
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: at least one parameter is NULL
* @return M4ERR_BAD_CONTEXT: provided context is not a valid one
* @return M4ERR_ALLOC: there is no more memory available
* @return M4ERR_FILE_INVALID_POSITION: the position cannot be reached
************************************************************************
*/
M4OSA_ERR M4OSA_fileCommonSeek(M4OSA_Context pContext,
M4OSA_FileSeekAccessMode seekMode,
M4OSA_FilePosition* pFilePos)
{
M4OSA_FileContext* pFileContext = pContext;
M4OSA_FilePosition fpos_current;
M4OSA_FilePosition fpos_seek;
M4OSA_FilePosition fpos_null = 0;
M4OSA_FilePosition fpos_neg_un = -1;
M4OSA_FilePosition fpos_file_size;
M4OSA_FilePosition fpos_seek_from_beginning;
M4OSA_TRACE3_3("M4OSA_fileCommonSeek\t\tM4OSA_Context 0x%x\t M4OSA_FileSeekAccessMode %d\tM4OSA_FilePosition* 0x%x",
pContext, seekMode, pFilePos);
M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, "M4OSA_fileCommonSeek");
M4OSA_DEBUG_IF2(0 == seekMode, M4ERR_PARAMETER, "M4OSA_fileCommonSeek");
M4OSA_DEBUG_IF2(M4OSA_NULL == pFilePos, M4ERR_PARAMETER, "M4OSA_fileCommonSeek");
fpos_file_size = pFileContext->file_size;
if(SeekRead == pFileContext->current_seek)
{
fpos_current = pFileContext->read_position;
}
else if(SeekWrite == pFileContext->current_seek)
{
fpos_current = pFileContext->write_position;
}
else
{
fpos_current = 0;
}
switch(seekMode)
{
case M4OSA_kFileSeekCurrent:
{
fpos_seek = *pFilePos;
break;
}
case M4OSA_kFileSeekBeginning:
{
fpos_seek = *pFilePos - fpos_current;
break;
}
case M4OSA_kFileSeekEnd:
{
fpos_seek = *pFilePos + fpos_file_size - fpos_current;
break;
}
default:
{
return M4ERR_PARAMETER;
}
}
fpos_seek_from_beginning = fpos_current + fpos_seek;
if(fseek(pFileContext->file_desc, fpos_seek, SEEK_CUR) != 0)
{
switch(errno)
{
case EINVAL:
{
/* meaning the value for origin is invalid or the position
specified by offset is before the beginning of the file */
return M4ERR_FILE_INVALID_POSITION;
}
case EBADF:
default:
{
return M4ERR_BAD_CONTEXT;/* file handle is invalid */
}
}
}
/* Set the returned position from the beginning of the file */
*pFilePos = fpos_seek_from_beginning;
/* SEEK done, reset end of file value */
pFileContext->b_is_end_of_file = M4OSA_FALSE;
return M4NO_ERROR;
}
/**
************************************************************************
* @brief This function asks to close the file (associated to the context)
* @note The context of the core file reader/writer is freed.
* @param context: (IN/OUT) Context of the core file reader
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: at least one parameter is NULL
* @return M4ERR_BAD_CONTEXT: provided context is not a valid one
* @return M4ERR_ALLOC: there is no more memory available
************************************************************************
*/
M4OSA_ERR M4OSA_fileCommonClose(M4OSA_UInt16 core_id, M4OSA_Context pContext)
{
M4OSA_FileContext* pFileContext = pContext;
M4OSA_Int32 i32_err_code=0;
M4OSA_TRACE3_2("M4OSA_fileCommonClose\tM4OSA_UInt16 %d\tM4OSA_Context 0x%x",
core_id, pContext);
M4OSA_DEBUG_IF2(M4OSA_NULL == pContext,
M4ERR_PARAMETER, "M4OSA_fileCommonClose: pContext is M4OSA_NULL");
#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context, M4ERR_BAD_CONTEXT,
"M4OSA_fileCommonClose: semaphore_context is M4OSA_NULL");
#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
free(pFileContext->url_name);
pFileContext->url_name = M4OSA_NULL;
free(pFileContext->file_name);
pFileContext->file_name = M4OSA_NULL;
i32_err_code = fclose(pFileContext->file_desc);
pFileContext->file_desc = M4OSA_NULL;
#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
M4OSA_semaphoreClose(pFileContext->semaphore_context);/* free the semaphore */
#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
free(pFileContext);
if (i32_err_code != 0)
{
M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_fileCommonClose");
return M4ERR_BAD_CONTEXT;
}
return M4NO_ERROR;
}
/**
************************************************************************
* @brief This function gets the file attributes (associated to the
* context)
* @param context: (IN) Context of the core file reader
* @param attribute: (OUT) The file attribute (allocated by the caller)
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: at least one parameter is NULL
* @return M4ERR_BAD_CONTEXT: provided context is not a valid one
************************************************************************
*/
M4OSA_ERR M4OSA_fileCommonGetAttribute(M4OSA_Context pContext, M4OSA_FileAttribute* pAttribute)
{
M4OSA_FileContext* fileContext = pContext;
struct stat TheStat;
M4OSA_TRACE3_2("M4OSA_fileCommonGetAttribute\tM4OSA_Context 0x%x\t"
"M4OSA_FileAttribute* 0x%x", pContext, pAttribute);
M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, "M4OSA_fileCommonGetAttribute");
M4OSA_DEBUG_IF2(M4OSA_NULL == pAttribute, M4ERR_PARAMETER, "M4OSA_fileCommonGetAttribute");
if(stat((char*)fileContext->url_name, &TheStat) != 0)
{
M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_fileCommonGetAttribute");
return M4ERR_BAD_CONTEXT;
}
pAttribute->creationDate.time = (M4OSA_Time)TheStat.st_ctime;
pAttribute->lastAccessDate.time = (M4OSA_Time)TheStat.st_atime;
pAttribute->modifiedDate.time = (M4OSA_Time)TheStat.st_mtime;
pAttribute->creationDate.timeScale = 1;
pAttribute->lastAccessDate.timeScale = 1;
pAttribute->modifiedDate.timeScale = 1;
pAttribute->creationDate.referenceYear = 1970;
pAttribute->lastAccessDate.referenceYear = 1970;
pAttribute->modifiedDate.referenceYear = 1970;
pAttribute->modeAccess = fileContext->access_mode;
return M4NO_ERROR;
}
/**
************************************************************************
* @brief This function gets the file URL (associated to the context).
* @note
* @param context: (IN) Context of the core file reader
* @param url: (OUT) The buffer containing the URL (allocated by
* M4OSA_fileCommonGetURL)
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER: at least one parameter is NULL
* @return M4ERR_BAD_CONTEXT: provided context is not a valid one
* @return M4ERR_ALLOC: there is no more memory available
************************************************************************
*/
M4OSA_ERR M4OSA_fileCommonGetURL(M4OSA_Context pContext, M4OSA_Char** pUrl)
{
M4OSA_FileContext* pFileContext = pContext;
M4OSA_UInt32 uiLength;
M4OSA_TRACE3_2("M4OSA_fileCommonGetURL\tM4OSA_Context 0x%x\tM4OSA_Char** 0x%x",
pContext, pUrl);
M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
"M4OSA_fileCommonGetURL: pContext is M4OSA_NULL");
M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER,
"M4OSA_fileCommonGetURL: pUrl is M4OSA_NULL");
uiLength = strlen((const char *)pFileContext->url_name)+1;
/* Allocate the memory to store the url_name */
*pUrl = (M4OSA_Char*)M4OSA_32bitAlignedMalloc(uiLength, M4OSA_FILE_COMMON,
(M4OSA_Char*)"M4OSA_fileCommonGetURL: url");
if(M4OSA_NULL == *pUrl)
{
M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonGetURL");
return M4ERR_ALLOC;
}
M4OSA_chrNCopy(*pUrl, pFileContext->url_name, uiLength);
return M4NO_ERROR;
}
/**
************************************************************************
* @brief This function gets a string containing the file name associated
* to the input URL.
* @note The user should not forget to delete the output string using
* M4OSA_strDestroy
* @param pUrl: (IN) The buffer containing the URL
* @param pFileName: (OUT) The string containing the URL. It is
* allocated inside this function
* @return M4NO_ERROR: there is no error
* @return M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
* file
* @return M4ERR_ALLOC: there is no more memory available
************************************************************************
*/
M4OSA_ERR M4OSA_fileCommonGetFilename(M4OSA_Char* pUrl, M4OSA_Char** pFileName)
{
M4OSA_Int32 i = 0;
M4OSA_Int32 iUrlLen = 0;
M4OSA_Int32 FileNameLen = 0;
M4OSA_Char* ptrUrl = M4OSA_NULL;
M4OSA_Char* ptrFilename = M4OSA_NULL;
M4OSA_TRACE3_2("M4OSA_fileCommonGetURL\tM4OSA_Char* %s\tM4OSA_Char** 0x%x",
pUrl, pFileName);
M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER,
"M4OSA_fileCommonGetFilename: pUrl is M4OSA_NULL");
M4OSA_DEBUG_IF2(M4OSA_NULL == pFileName, M4ERR_PARAMETER,
"M4OSA_fileCommonGetFilename: pFileName is M4OSA_NULL");
*pFileName = M4OSA_NULL;
/*Parse URL*/
iUrlLen = strlen((const char *)pUrl);
for(i=iUrlLen-1; i>=0; i--)
{
if (pUrl[i] != '\\' && pUrl[i] != '/')
{
FileNameLen++;
}
else
{
break; /* find the beginning of the file name */
}
}
ptrFilename = (M4OSA_Char*) M4OSA_32bitAlignedMalloc(FileNameLen+1, M4OSA_FILE_COMMON,
(M4OSA_Char*)"M4OSA_fileCommonGetFilename: Filename string");
if (ptrFilename == M4OSA_NULL)
{
M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonGetFilename");
return M4ERR_ALLOC;
}
ptrUrl = pUrl + (iUrlLen - FileNameLen);
M4OSA_chrNCopy(ptrFilename, ptrUrl, FileNameLen+1);
*pFileName = ptrFilename;
return M4NO_ERROR;
}