mutils.c

彩信MMS的全部代码

/*
 * Copyright (C) Obigo AB, 2002-2005.
 * All rights reserved.
 *
 * This software is covered by the license agreement between
 * the end user and Obigo AB, and may be 
 * used and copied only in accordance with the terms of the 
 * said agreement.
 *
 * Obigo AB assumes no responsibility or 
 * liability for any errors or inaccuracies in this software, 
 * or any consequential, incidental or indirect damage arising
 * out of the use of the software.
 *
 */











 



 

#include "cansilib.h"   
#include "cmnconf.h"    
#include "aapicmn.h"    

#include "aapifile.h"   
#include "codecvt.h"    

#include "aapicmn.h"    
#include "gmem.h"       
#include "fldrmgr.h"    
#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "mmem.h"       
#include "mutils.h"     
#include "mfreemms.h"   
#include "msig.h"       
#include "mconfig.h"    


















static void checkBom( const unsigned char *buf,  int *newCharset);
static unsigned char *mmsCvtBuf(int *charset, const unsigned char *srcData, 
    int *srcSize, int *dstSize);
static CMN_BOOL mmsCvtBufFile(int *charset, const unsigned char *srcData, 
    int srcSize, int *dstSize, UINT32 fileId);
static MmsBodyPart *mmsConvertTextBuffer(int *charset, const unsigned char *buf, 
    long bufSize);
static MmsBodyPart *mmsConvertTextFile(int *charset, UINT32 inFile);









MmsResult checkFolderError(FmResult fmResult)
{
    MmsResult returnResult;

    switch(fmResult)
    {
    case FM_RESULT_INDEX_FILE_CONVERTED :
        returnResult = MMS_RESULT_OK;
        MMS_LOG_I(("FM RESULT: index file is converted from old format.\n"));
        break;
    case FM_RESULT_INDEX_FILE_FULL :
        returnResult = MMS_RESULT_INDEX_FILE_FULL;
        MMS_LOG_I(("FM ERROR: index file is full!\n"));
        break;
    case FM_RESULT_INDEX_FILE_ERROR:
        returnResult = MMS_RESULT_INDEX_FILE_ERROR;
        MMS_LOG_I(("FM ERROR: index file is corrupt!\n"));
        MMSa_error( MMS_RESULT_RESTART_NEEDED);
        break;
    case FM_RESULT_FOLDER_NOT_FOUND:
        returnResult = MMS_RESULT_FOLDER_NOT_FOUND; 
        MMS_LOG_I(("FM ERROR: folder not found!\n"));
        break;
    case FM_RESULT_DISK_FULL:
        returnResult = MMS_RESULT_INSUFFICIENT_PERSISTENT_STORAGE;
        MMS_LOG_I(("FM ERROR: insufficient persistant storage!\n"));
        break;
    case FM_RESULT_FILE_ERROR :
        returnResult = MMS_RESULT_FILE_READ_ERROR;
        MMS_LOG_I(("FM ERROR: error from file system!\n"));
        break;
    case FM_RESULT_MEMORY_ERROR :
        returnResult = MMS_RESULT_INSUFFICIENT_MEMORY;
        MMS_LOG_I(("FM ERROR: not enough memory for the requested operation!\n"));
        break;
    case FM_RESULT_MSGID_NOT_FOUND :
        returnResult = MMS_RESULT_MESSAGE_ID_NOT_FOUND;
        MMS_LOG_I(("FM ERROR: message id could not be found!\n"));
        break;
    case FM_RESULT_OK :
        returnResult = MMS_RESULT_OK;
        break;
    case FM_RESULT_ERROR :
        returnResult = MMS_RESULT_ERROR;
        MMS_LOG_I(("FM ERROR: Parameter error in Folder Manager!\n"));
        break;
    default:
        returnResult = MMS_RESULT_ERROR;
        MMS_LOG_I(("FM ERROR: unknown error!\n"));
        break;
    } 

    return returnResult;
} 








CMN_BOOL copyAddress(MmsAddress *to, const MmsAddress *from)
{
    CMN_BOOL ret = FALSE;

    if (from == NULL)
    {   
        return FALSE;
    } 

    to->addrType = from->addrType;
    if ( !copyEncText(&to->name, &from->name))
    {
        MMS_LOG_I(("%s(%d) copy failed\n", __FILE__, __LINE__));
    }
    else if (from->address == NULL)
    {
        to->address = NULL;
        ret = TRUE;
    }
    else if ( (to->address = M_ALLOC( strlen(from->address) + 1)) != NULL)
    {
        strcpy( to->address, from->address);
        ret = TRUE;
    } 

    return ret;
}  








CMN_BOOL copyAddressList(MmsAddressList **toList, const MmsAddressList *fromList)
{
    MmsAddressList *to = NULL;
    MmsAddressList *aNew = NULL;
  
    *toList = NULL;
    if (fromList == NULL)
    {   
        return TRUE;
    } 

    while (fromList != NULL)
    {
        aNew = M_ALLOCTYPE(MmsAddressList);
        if (aNew == NULL)
        {
            MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
            freeMmsAddressList(*toList);
            *toList = NULL;
            return FALSE;
        }
        else if (to != NULL)     
        {
            to->next = aNew;
        } 

        to = aNew;
        if ( !copyAddress( &to->current, &fromList->current))
        {
            MMS_LOG_I(("%s(%d) Copy failed\n", __FILE__, __LINE__));
            freeMmsAddressList(*toList);
            *toList = NULL;
            return FALSE;
        } 

        to->next = NULL;

        if (*toList == NULL)   
        {
            *toList = to;
        } 

        fromList = fromList->next;
    } 

    return TRUE;
}  








CMN_BOOL copyContentType(MmsContentType *toContent, const MmsContentType *fromContent)
{
    MmsAllParams *to;
    MmsAllParams *from;
    UINT32 len = 0;

    if (fromContent == NULL)
    {   
        return TRUE;
    } 

    toContent->knownValue = fromContent->knownValue;
    if ( fromContent->strValue == NULL)
    {
        toContent->strValue = NULL;
    }
    else
    {
        len = strlen( (const char *)fromContent->strValue) + 1;
        toContent->strValue = M_ALLOC(len);
        if (toContent->strValue == NULL)
        {
            MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
            return FALSE;
        } 

        strcpy((char *)toContent->strValue, (const char *)fromContent->strValue);
    } 

    if (fromContent->params == NULL)
    {
        toContent->params = NULL;
        return TRUE;
    } 

    from = fromContent->params;
    to = toContent->params = M_ALLOC(sizeof(MmsAllParams));
    if (to == NULL)
    {
        MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
        freeMmsContentType(toContent);
        return FALSE;
    } 

    while (from != NULL)
    {
        to->param = from->param;
        to->type = from->type;
        if (from->type == MMS_PARAM_STRING)
        {
            if (from->value.string == NULL)
            {
                to->value.string = NULL;
            }
            else
            {
                len = strlen( (const char *)from->value.string) + 1;
                to->value.string = M_ALLOC(len);
                if (to->value.string == NULL)
                {
                    MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                    freeMmsContentType(toContent);
                    return FALSE;
                } 

                strcpy( (char *)to->value.string, 
                    (const char *)from->value.string);
            } 
        
        }
        else if (from->type == MMS_PARAM_INTEGER)
        {
            to->value.integer = from->value.integer;
        } 
    
        from = from->next;
        if (from != NULL)
        {
            to->next = M_ALLOC(sizeof(MmsAllParams));
            if (to->next == NULL)
            {
                MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                freeMmsContentType(toContent);
                return FALSE;
            } 

            to = to->next;
        }
        else
        {
            to->next = NULL;
        } 
    } 

    return TRUE;
} 








CMN_BOOL copyEncText(MmsEncodedText *to, const MmsEncodedText *from)
{
    CMN_BOOL ret = FALSE;

    if (from == NULL)
    {   
        return TRUE;
    } 

    to->charset = from->charset;
    if (from->text == NULL)
    {
        to->text = NULL;
        ret = TRUE;
    }
    else if ( (to->text = M_ALLOC( strlen(from->text) + 1)) != NULL)
    {
        strcpy( to->text, from->text);
        ret = TRUE;
    } 

    return ret;
} 








CMN_BOOL copyEntryHeader(MmsEntryHeader **to, const MmsEntryHeader *from)
{
    MmsEntryHeader *toPtr   = NULL;
    MmsEntryHeader *fromPtr = (MmsEntryHeader *)from;
    UINT32 tmpVal = 0;
    
    *to = NULL;
    
    if (fromPtr == NULL)
    {   
        return TRUE;
    }
    else if ( (toPtr = M_CALLOC(sizeof(MmsEntryHeader))) == NULL)
    {
        MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
        return FALSE;
    } 

    *to = toPtr;
    while (fromPtr != NULL)
    {
        
        toPtr->headerType = fromPtr->headerType;
        
        switch ( fromPtr->headerType)
        {
        case MMS_SHORT_CUT_SHIFT_DELIMITER:
            toPtr->value.shortCutShiftDelimiter = 
                fromPtr->value.shortCutShiftDelimiter;
            break;
        case MMS_SHIFT_DELIMITER:
            toPtr->value.shiftDelimiter = fromPtr->value.shiftDelimiter;
            break;
        case MMS_APPLICATION_HEADER:
            if (fromPtr->value.applicationHeader.name != NULL)
            {
                tmpVal = strlen( (const char *)
                    fromPtr->value.applicationHeader.name) + 1;
                toPtr->value.applicationHeader.name = M_CALLOC(tmpVal);
                if (toPtr->value.applicationHeader.name == NULL)
                {
                    MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                    freeMmsEntryHeader(*to);
                    return FALSE;
                } 

                strcpy( (char *)toPtr->value.applicationHeader.name,
                    (char *)fromPtr->value.applicationHeader.name);
            } 

            if (fromPtr->value.applicationHeader.value != NULL)
            {
                tmpVal = strlen( (const char *)
                    fromPtr->value.applicationHeader.value) + 1;
                toPtr->value.applicationHeader.value = M_CALLOC( tmpVal);
                if (toPtr->value.applicationHeader.value == NULL)
                {
                    MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                    freeMmsEntryHeader(*to);
                    return FALSE;
                } 

                strcpy( (char *)toPtr->value.applicationHeader.value,
                    (char *)fromPtr->value.applicationHeader.value);
            } 
            break;
        case MMS_WELL_KNOWN_CONTENT_DISPOSITION:
            toPtr->value.contentDisposition.valueLength = 
                fromPtr->value.contentDisposition.valueLength;
            toPtr->value.contentDisposition.dispositionType =
                fromPtr->value.contentDisposition.dispositionType;
            if (copyParams( &toPtr->value.contentDisposition.params,
                fromPtr->value.contentDisposition.params) == FALSE)
            {
                MMS_LOG_I(("%s(%d) Couldn't copy params\n", __FILE__, __LINE__));
            } 
            break;
        case MMS_WELL_KNOWN_CONTENT_ID:
        case MMS_WELL_KNOWN_CONTENT_LOCATION:
            if (fromPtr->value.wellKnownFieldName != NULL)
            {
                tmpVal = strlen( (const char *)
                    fromPtr->value.wellKnownFieldName) + 1;
                toPtr->value.wellKnownFieldName = M_CALLOC(tmpVal);
                if (toPtr->value.wellKnownFieldName == NULL)
                {
                    MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                    freeMmsEntryHeader(*to);
                    return FALSE;
                } 

                strcpy( (char *)toPtr->value.wellKnownFieldName, 
                    (char *)fromPtr->value.wellKnownFieldName);
            } 
            break;
        default :
            MMS_LOG_I(("copyEntryHeader: unknown type!\n"));
            break;
        } 

        fromPtr = fromPtr->next;
        if ( fromPtr != NULL)
        {
            toPtr->next = M_CALLOC( sizeof(MmsEntryHeader));
            if (toPtr->next == NULL)
            {
                MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                freeMmsEntryHeader(*to);
                return FALSE;
            } 

            toPtr = toPtr->next;
        }
        else
        {
            toPtr->next = NULL;
        } 
    } 

    return TRUE;
} 








CMN_BOOL copyParams(MmsAllParams **to, const MmsAllParams *from)
{
    MmsAllParams *aNew = NULL;      
    MmsAllParams *current = NULL;   
    UINT32 size;
    CMN_BOOL isOk = TRUE;   
  
    *to = NULL;
    if (from == NULL)
    {   
        return TRUE;
    } 

    while (from != NULL && isOk)
    {
        aNew = M_CALLOC(sizeof(MmsAllParams));
        if (aNew == NULL)
        {
            MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
            isOk = FALSE;   
            break;
        }
        else if (current != NULL)   
        {
            current->next = aNew;
        } 

        current = aNew;
        current->next = NULL;
        current->param = from->param;
        current->type = from->type;
        switch (from->type)
        {
        case MMS_PARAM_INTEGER :
            current->value.integer = from->value.integer;
            break;
        case MMS_PARAM_STRING :
            size = strlen( (char *)from->value.string) + 1;
            current->value.string = M_ALLOC(size);
            if (current->value.string == NULL)
            {
                MMS_LOG_I(("%s(%d) Out of memory\n", __FILE__, __LINE__));
                isOk = FALSE;   
                break;
            } 

            memcpy( current->value.string, from->value.string, size);
            break;
        default :
            MMS_LOG_I(("%s(%d) Invalid parameter type.\n", __FILE__, __LINE__));
            isOk = FALSE;
            break;
        } 

        if (*to == NULL)   
        {
            *to = current;
        } 

        from = from->next;
    } 

    if ( !isOk )    
    {
        freeMmsParams(*to);
        *to = NULL;
    } 

    return isOk;
} 






void freeMmsAddressList(MmsAddressList *addressList)