mutils.c

彩信MMS的全部代码

                {
                    MMS_LOG_I(("%s(%d): file couldn't be written.\n", 
                        __FILE__, __LINE__));
                    *dstSize = 0;
                    ret = FALSE;
                }
                else
                {
                    *dstSize += dstBytes;
                    curPos += dstBytes;
                    srcBytes = srcSize - srcBytes;
                } 
            } while (ret == TRUE && curPos < srcSize);

            M_FREE(dstData);
            dstData = NULL;
        } 
        break;
    default :
        

        dataWritten = FILEa_write(CMN_FILE_CATEGORY_TMP, fileId, dstData, 0, srcSize);
        if (dataWritten != srcSize)
        {
            
            MMS_LOG_I(("%s(%d): file couldn't be written.\n", 
                __FILE__, __LINE__));
            ret = FALSE;
        } 
        break;
    } 

    return ret;
} 












MmsBodyPart *mmsCharsetCvt(int *charset, const MmsBodyPart *srcData)
{
    MmsBodyPart *part = NULL;

    if (srcData == NULL || !validateCharSet(*charset))
    {
        
        return NULL;
    } 

    if (srcData->storageType == MMS_BODY_PART_AS_BUFFER)
    {
        part = mmsConvertTextBuffer( charset, srcData->data.buffer, 
            (long)srcData->dataSize);
    }
    else 
    {
        part = mmsConvertTextFile( charset, srcData->data.file.id);
    } 

    return part;
} 









static MmsBodyPart *mmsConvertTextBuffer(int *charset, 
    const unsigned char *sourceBuf, long srcSize)
{
    int tmpSize = 0;
    int dstSize = 0;
    int newCharset = 0;
    UINT32 fileId = 0;
    UINT32 outputFile;
    unsigned char *dstBuf = NULL;
    CMN_BOOL anyError = FALSE;
    MmsBodyPart *part = NULL; 

    if (*charset == CMN_CHARSET_UCS_2 || *charset == CMN_CHARSET_UTF_16)
    {
        
        checkBom( sourceBuf, &newCharset);
        if ( newCharset != 0)
        {
            *charset = newCharset;
        } 
    } 

    tmpSize = srcSize;
    dstBuf = mmsCvtBuf( charset, sourceBuf, &tmpSize, &dstSize);
    if (dstBuf != NULL)
    {
        
        part = M_CALLOC(sizeof(MmsBodyPart)); 
        part->storageType = MMS_BODY_PART_AS_BUFFER;
        part->dataSize = (UINT32)dstSize;
        part->data.buffer = dstBuf;
    }
    else
    {
        

        if (FILEa_create( CMN_FILE_CATEGORY_TMP, NULL, &outputFile) == -1)
        {
            MMS_LOG_I(("%s(%d): unable to create file!\n", __FILE__, __LINE__));
            return NULL;
        } 
        
        
        anyError = mmsCvtBufFile( charset, sourceBuf, srcSize, &dstSize, outputFile);
        FILEa_close( CMN_FILE_CATEGORY_TMP, outputFile);

        if (anyError)
        {
            MMS_LOG_I(("%s(%d): conversion failed!\n", __FILE__, __LINE__));
            FILEa_delete( CMN_FILE_CATEGORY_TMP, outputFile);
        }
        else
        {
            
            part = M_CALLOC(sizeof(MmsBodyPart)); 
            part->storageType = MMS_BODY_PART_AS_FILE;
            part->dataSize = (UINT32)dstSize;
            part->data.file.category = CMN_FILE_CATEGORY_TMP;
            part->data.file.id = fileId;
        } 
    } 

    return part;
} 








static MmsBodyPart *mmsConvertTextFile( int *charset, UINT32 inFile)
{
    int dstSize = 0;
    INT32 bufSize = 0;
    int readBytes = 0;
    int pos = 0;
    UINT32 outputFile;
    UINT32 fileId = 0;
    INT32 fileSize;
    unsigned char *buf = NULL;
    CMN_BOOL anyError = FALSE;
    MmsBodyPart *part = NULL; 

    if (FILEa_open( CMN_FILE_CATEGORY_TMP, inFile, FILE_OPTION_READ) == -1)
    {
        MMS_LOG_I(("%s(%d): unable to open file %d\n", __FILE__, __LINE__, inFile));
        return NULL;
    }
    else if ( (fileSize = FILEa_getSize(CMN_FILE_CATEGORY_TMP, inFile)) == -1)
    {
        MMS_LOG_I(("%s(%d): unable to query file size %d!\n", __FILE__, __LINE__));
        FILEa_close( CMN_FILE_CATEGORY_TMP, inFile);
        return NULL;
    }
    else if (FILEa_create( CMN_FILE_CATEGORY_TMP, NULL, &outputFile) == -1)
    {
        MMS_LOG_I(("%s(%d): unable to create file!\n", __FILE__, __LINE__));
        FILEa_close( CMN_FILE_CATEGORY_TMP, inFile);
        return NULL;
    } 
    
    if (fileSize > (INT32)MMS_MAX_CHUNK_SIZE)
    {
        bufSize = MMS_MAX_CHUNK_SIZE;
    }
    else
    {
        bufSize = fileSize;
    } 

    pos = 0;
    buf = M_CALLOC((MemSize)bufSize);
    while ( !anyError && (readBytes = FILEa_read( CMN_FILE_CATEGORY_TMP, 
        inFile, buf, pos, bufSize)) > 0)
    {
        anyError = mmsCvtBufFile( charset, buf, bufSize, &dstSize, outputFile);
        pos += readBytes;
    } 

    FILEa_close( CMN_FILE_CATEGORY_TMP, inFile);
    FILEa_close( CMN_FILE_CATEGORY_TMP, outputFile);
    M_FREE(buf);

    if (anyError)
    {
        MMS_LOG_I(("%s(%d): conversion failed!\n", __FILE__, __LINE__));
        FILEa_delete( CMN_FILE_CATEGORY_TMP, outputFile);
    }
    else
    {
        
        part = M_CALLOC(sizeof(MmsBodyPart)); 
        part->storageType = MMS_BODY_PART_AS_FILE;
        part->dataSize = (UINT32)dstSize;
        part->data.file.category = CMN_FILE_CATEGORY_TMP;
        part->data.file.id = fileId;
    } 

    return part;
} 









CMN_BOOL validateCharSet(int charSet)
{
    CMN_BOOL retValue;

    switch (charSet)
    {
    case CMN_CHARSET_US_ASCII:
    case CMN_CHARSET_UTF_16BE:
    case CMN_CHARSET_UTF_16LE:
    case CMN_CHARSET_UTF_16:
    case CMN_CHARSET_UCS_2:
    case CMN_CHARSET_ISO_8859_1:
        retValue = TRUE;
        break;
    case CMN_CHARSET_UTF_8:         
    default:
        retValue = FALSE;
        break;
    }  

    return retValue;
} 








static void checkBom( const unsigned char *buf,  int *newCharset)
{
    unsigned char bom_LE[2] = {0xFF, 0xFE};
    unsigned char bom_BE[2] = {0xFE, 0xFF};

    if ( memcmp( buf,  bom_LE, 2) == 0)
    {   
        *newCharset = CMN_CHARSET_UTF_16LE;
    } 
    else if ( memcmp( buf,  bom_BE, 2) == 0)
    {   
        *newCharset = CMN_CHARSET_UTF_16BE;
    }
    else
    {
        *newCharset = CMN_CHARSET_UCS_2;
    }
} 







CMN_BOOL validateAddressList( const MmsAddressList *addrList)
{
    MmsAddressList *tmpPtr;
    UINT32 tempSize;
    tmpPtr = (MmsAddressList *)addrList;
   
    while (tmpPtr != NULL) 
    {
        tempSize = 0;
        if ( tmpPtr->current.name.text != NULL)
        {
            tempSize = strlen( tmpPtr->current.name.text);
        } 

        if ( tmpPtr->current.address != NULL)
        {
            tempSize += strlen( tmpPtr->current.address);
        
        } 

        if ( tempSize > MAX_ADDRESS_LEN)
        {
            return FALSE;
        } 

        tmpPtr = tmpPtr->next;
    } 

    return TRUE;
} 







CMN_BOOL validateAddress( const MmsAddress *address)
{
    UINT32 tempSize = 0;

    if ( address != NULL) 
    {
        if ( address->name.text != NULL)
        {
            tempSize = strlen( address->name.text);
        } 

        if ( address->address != NULL)
        {
            tempSize += strlen( address->address);
        
        } 

        if ( tempSize > MAX_ADDRESS_LEN)
        {
            return FALSE;
        } 
    } 

    return TRUE;
} 







CMN_BOOL validateSubject( const MmsEncodedText *subject)
{
    if ( subject->text != NULL)
    {
        if ( strlen( subject->text) > MAX_SUBJECT_LEN)
        {
            return FALSE;        
        }
    } 

    return TRUE;
} 







CMN_BOOL validateMessageClass( const MmsMessageClass *msgClass)
{
    if( msgClass->classIdentifier == MMS_MESSAGE_CLASS_IS_TEXT)
    {
        if ( msgClass->textString != NULL )
        {
            if( strlen( msgClass->textString) > MAX_STR_LEN_MSG_CLASS)
            {
                return FALSE;
            } 
        } 
    } 

    return TRUE;
} 







CMN_BOOL validateEntryHeaders( MmsEntryHeader *entryHeader, MmsResult *result)
{
    MmsEntryHeader *entry = entryHeader;
    UINT32 size = 0;

    while (entry != NULL)
    {
        size = 0;
        switch ( entry->headerType)
        {
        case MMS_WELL_KNOWN_CONTENT_ID: 
            
            size += 1 + strlen( (const char *)entry->value.wellKnownFieldName)
                + 2  
                + 1; 

            if (size > MAX_MMS_ENTRY_HEADER_VALUE_LEN)
            {   
                MMS_LOG_I(("validateEntryHeaders: Content id field too long\n"));
                *result = MMS_RESULT_INVALID_CONTENT_ID;
                return FALSE;
            } 
            break;
        case MMS_WELL_KNOWN_CONTENT_LOCATION: 
            
            size += 1 + strlen((const char *)entry->value.wellKnownFieldName) + 1;
            
            if (size > MAX_MMS_ENTRY_HEADER_VALUE_LEN)
            {   
                MMS_LOG_I(("validateEntryHeaders: Content location field too long\n"));
                *result = MMS_RESULT_INVALID_CONTENT_LOCATION;
                return FALSE;
            } 
            break;
        case MMS_WELL_KNOWN_CONTENT_DISPOSITION: 
            
            switch (entry->value.contentDisposition.dispositionType)
            {
            case MMS_DISPOSITION_FORM_DATA: 
                
                if (entry->value.contentDisposition.params == NULL)
                {
                    

                }
                else if (entry->value.contentDisposition.params->param != MMS_NAME)
                {
                    MMS_LOG_I(("%s(%d): Unhandled Form-data parameter %d.\n", 
                        __FILE__, __LINE__,
                        entry->value.contentDisposition.params->param));
                    *result = MMS_RESULT_ERROR;
                    return FALSE;
                }
                else if (entry->value.contentDisposition.params->type == MMS_PARAM_INTEGER)
                {      
                    size += 1 + 1;
                }
                else
                {      
                    size += 1 + strlen((const char *)
                            entry->value.contentDisposition.params->value.string);
                } 
                break;
            case MMS_DISPOSITION_ATTACHMENT: 
                
                if (entry->value.contentDisposition.params == NULL)
                {
                    

                }
                else if (entry->value.contentDisposition.params->param != MMS_FILENAME)
                {
                    MMS_LOG_I(("%s(%d): Unknown Attachment parameter in "
                        "Content-disposition %d.\n", __FILE__, __LINE__,
                        entry->value.contentDisposition.params->param));
                    *result = MMS_RESULT_ERROR;
                    return FALSE;
                }
                else if (entry->value.contentDisposition.params->type == MMS_PARAM_INTEGER)
                {      
                    size += 1 + 1;
                }
                else
                {      
                    size += 1 + strlen((const char *)
                        entry->value.contentDisposition.params->value.string);
                } 
                break;
            default:
                
                MMS_LOG_I(("%s(%d): Received unknown Content-Disposition type %d\n", 
                    __FILE__, __LINE__, 
                    entry->value.contentDisposition.dispositionType));
                *result = MMS_RESULT_ERROR;
                return FALSE;
            } 

            if (size > MAX_MMS_ENTRY_HEADER_VALUE_LEN)
            {
                
                MMS_LOG_I(("%s(%d): Content-disposition is too long\n",
                    __FILE__, __LINE__, size));
                *result = MMS_RESULT_INVALID_APPLICATION_HEADER;
                return FALSE;
            } 
            break;
        case MMS_APPLICATION_HEADER: 
            if (entry->value.applicationHeader.name == NULL ||
                entry->value.applicationHeader.value == NULL)
            {
                MMS_LOG_I(("%s(%d): Application header corrupt %d %d\n",
                    __FILE__, __LINE__, entry->value.applicationHeader.name,
                    entry->value.applicationHeader.value));
                *result = MMS_RESULT_INVALID_APPLICATION_HEADER;
                return FALSE;
            } 

            
            size += 
                strlen((const char *)entry->value.applicationHeader.name) + 1 +
                strlen((const char *)entry->value.applicationHeader.value) + 1;

            if (size > MAX_MMS_ENTRY_HEADER_VALUE_LEN)
            {
                
                MMS_LOG_I(("validateEntryHeaders: Application header too long\n"));
                *result = MMS_RESULT_INVALID_APPLICATION_HEADER;
                return FALSE;
            } 
            break;
        case MMS_SHORT_CUT_SHIFT_DELIMITER:
        case MMS_SHIFT_DELIMITER:
        default :
            break;
        } 

        entry = entry->next;
    } 
    
    return TRUE;
} 







MmsForward *copyMmsForward(const MmsForward *mmsForward)
{
    MmsForward *retForward = NULL;
    CMN_BOOL copyIsOk = TRUE;

    if (mmsForward != NULL)
    {
        retForward = M_CALLOC(sizeof(MmsForward));

        copyIsOk = copyAddressList(&retForward->bcc, mmsForward->bcc);
        if (copyIsOk == TRUE)
        {
            copyIsOk = copyAddressList(&retForward->cc, mmsForward->cc);
        } 
        if (copyIsOk == TRUE)
        {
            copyIsOk = copyAddressList(&retForward->to, mmsForward->to);
        } 
        if (copyIsOk == TRUE)
        {
            retForward->date = mmsForward->date;
            retForward->deliveryReport = mmsForward->deliveryReport;
            retForward->deliveryTime = mmsForward->deliveryTime;
            retForward->expiryTime = mmsForward->expiryTime;
            retForward->readReply = mmsForward->readReply;
        } 
        else
        {
          freeMmsForward(retForward);
          retForward = NULL;
        } 
    } 

    return retForward;
}