mfetch.c

彩信MMS的全部代码

            if (mmsResult != MMS_RESULT_OK)
            {
                createMsgInfoListReturn( mmsResult, fsm.queue.msgId,
                    fsm.queue.data);
            } 

            return FALSE;
        } 
#endif 

        fsm.isBusy = FALSE;
        return TRUE;
    } 
} 







static void getHeader(const MmsSignal *sig, CMN_BOOL toStateMachine)
{
    MmsResult           mmsResult       = MMS_RESULT_OK;
    MmsHeaderValue      headerValue;
    MmsMessagePart      *headerPart     = NULL;
    MmsMessagePart      *notifyPart     = NULL;
    UINT32              mainInfo[POS_INT_MSG_NUMBER] = {0}; 
    unsigned char       *headerData     = NULL;
    FmResult            fmResult        = FM_RESULT_OK;
    UINT32              bytesRead       = 0;
    MmsVersion          version         = MMS_VERSION_10;

    

    headerValue.messageType = MMS_M_NOTIFICATION_IND;
    if ((fmResult = fldrmgrOpenList( CMN_CLIENT_MMS, sig->u_param1, &fsm.cache,
        FM_READ_WRITE)) != FM_RESULT_OK)
    {
        mmsResult = checkFolderError(fmResult);
    } 
    else if ((fmResult = fldrmgrOpenMessage( CMN_CLIENT_MMS, sig->u_param1, 
        FM_READ)) != FM_RESULT_OK)
    {
        mmsResult = checkFolderError(fmResult);
    } 
    else 
    {
        
        fmResult = fldrmgrGetList( fsm.cache, 0UL, MMS_MESSAGE_INFO_SIZE, 
            &bytesRead, (unsigned char *)mainInfo);
        if (fmResult != FM_RESULT_OK)
        {
            mmsResult = checkFolderError(fmResult);
        } 
        else if (bytesRead < MMS_MESSAGE_INFO_SIZE)
        {
           mmsResult = MMS_RESULT_MESSAGE_ID_NOT_FOUND; 
        }
    } 

    if (mainInfo[POS_HEADER_SIZE] == 0UL && mmsResult == MMS_RESULT_OK)     
    {
        mmsResult = MMS_RESULT_MESSAGE_EMPTY;
    } 
    else if (mainInfo[POS_HEADER_SIZE] > MMS_MAX_CHUNK_SIZE && 
        mmsResult == MMS_RESULT_OK)
    {
        mmsResult = MMS_RESULT_INSUFFICIENT_MEMORY;
    }
    else if (mmsResult == MMS_RESULT_OK)
    {
        
        headerData = M_CALLOC(mainInfo[POS_HEADER_SIZE]);

        fmResult = fldrmgrGetMessage( CMN_CLIENT_MMS, sig->u_param1, 0UL, 
            mainInfo[POS_HEADER_SIZE], &bytesRead, headerData);
        
        if (fmResult != FM_RESULT_OK)
        {
            mmsResult = checkFolderError(fmResult);
        }
        
        else if ( !mmsPduGet( headerData, bytesRead, X_MMS_MESSAGE_TYPE, 
            &headerValue))
        {
            MMS_LOG_I(("getHeader: Missing message type. Illegal PDU.\n"));
            mmsResult = MMS_RESULT_MESSAGE_CORRUPT;
        }
        else if (headerValue.messageType == MMS_M_NOTIFICATION_IND)
        {
            notifyPart = M_CALLOC(sizeof(MmsMessagePart));
            mmsResult = parseMmsNotification(headerData, bytesRead, 
                &notifyPart->notification, &version);
            if (mmsResult != MMS_RESULT_OK)
            {
                freeMmsNotification(&notifyPart->notification);
                M_FREE(notifyPart);
                notifyPart = NULL;
            }
            else
            {
                
                notifyPart->notification.timeStamp = 
                    (MmsTimeSec)fldrmgrGetDate( CMN_CLIENT_MMS, sig->u_param1);
                MMS_LOG_I(("getHeader: Notification arrival time: %d\n", 
                    notifyPart->notification.timeStamp));
            } 
        }
        else 
        {
            headerPart = M_CALLOC(sizeof(MmsMessagePart)); 
            mmsResult = parseMmsHeader(headerData, bytesRead, 
                &headerPart->header, &version); 
            if (mmsResult != MMS_RESULT_OK)
            {
                freeMmsHeader(&headerPart->header);
                M_FREE(headerPart);
                headerPart = NULL;
            }
            else if (cfgGetInt(MMS_CFG_USE_RECEPTION_DATE) || 
                headerPart->header.date == 0)
            {   
                headerPart->header.date = 
                    (MmsTimeSec)fldrmgrGetDate( CMN_CLIENT_MMS, sig->u_param1);
            } 
        } 
    } 
    
    if (headerValue.messageType == MMS_M_NOTIFICATION_IND)
    {   
        sendResult(sig, toStateMachine, notifyPart, mmsResult, 
            MMS_MSG_NOTIFICATION, version);
    }
    else 
    {   
        sendResult(sig, toStateMachine, headerPart, mmsResult, 
            MMS_MSG_HEADER, version);
    } 

    M_FREE(headerData);
    headerData = NULL;
    (void)fldrmgrCloseList(fsm.cache);
    (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, sig->u_param1);
} 











static MmsResult getAllBodyPartInfo(MmsMessagePart *bodyInfo, 
    const UINT32 *tempPointer, UINT32 clientMsgId, UINT32 entrySize, 
    unsigned char *entry, UINT32 headerMediaType)
{ 
    long                read            = MMS_MESSAGE_INFO_SIZE;
    UINT32              partNumber      = 0UL;
    unsigned char      *oneEntry        = NULL;
    unsigned char      *startPos        = NULL;
    UINT32              headerLen       = 0;
    MmsKnownMediaType   preMediaType    = MMS_TYPE_ANY_ANY;
    MmsBodyInfoList    *firstBodyInfo   = NULL;
    MmsBodyInfoList    *prePointer      = NULL; 
    FmResult            fmResult        = FM_RESULT_OK;
    MmsResult           mmsResult       = MMS_RESULT_OK;
    UINT32              chunkSize       = 0;
    CMN_BOOL            first           = TRUE;

    
    bodyInfo->messageInfo.numOfEntries = 0;

    
    while (read < (long)((bodyInfo->messageInfo.numOfMsgInfo * 
        MMS_PART_INFO_SIZE) + MMS_MESSAGE_INFO_SIZE))
    {
        
        if (entrySize > MMS_MAX_CHUNK_SIZE)
        {
            if (isMultiPart((MmsKnownMediaType)headerMediaType))
            {
                fmResult = fldrmgrGetMessage( CMN_CLIENT_MMS, clientMsgId, 
                    tempPointer[POS_ENTRY_START], tempPointer[POS_ENTRY_SIZE], 
                    &chunkSize, entry);
            }
            else
            {
                fmResult = fldrmgrGetMessage( CMN_CLIENT_MMS, clientMsgId, 
                    0, bodyInfo->messageInfo.headerSize, 
                    &chunkSize, entry);
            } 
            if (fmResult != FM_RESULT_OK)
            {
                mmsResult = checkFolderError(fmResult);
            } 
        } 

        
        if (first)
        {
            

            if (entrySize > MMS_MAX_CHUNK_SIZE)
            {
                oneEntry = findContentType((unsigned char *)(entry), 
                    entrySize, (MmsKnownMediaType)headerMediaType, &headerLen, 
                    chunkSize, TRUE);
            }
            else
            {
                oneEntry = findContentType((unsigned char *)(entry + 
                    tempPointer[POS_ENTRY_START]), 
                    entrySize, (MmsKnownMediaType)headerMediaType, &headerLen, 
                    entrySize -  tempPointer[POS_ENTRY_START], TRUE);
            } 
            first = FALSE;
        }
        else
        {
            

            if (entrySize > MMS_MAX_CHUNK_SIZE)
            {
                oneEntry = findContentType( entry, entrySize, preMediaType, 
                    &headerLen, chunkSize, FALSE);
            }
            else
            {
                oneEntry = findContentType((unsigned char *)(entry + 
                    tempPointer[POS_ENTRY_START]), 
                    entrySize, preMediaType, &headerLen, 
                    entrySize - tempPointer[POS_ENTRY_START], FALSE);
            } 
        } 
        
        if (read == (long)MMS_MESSAGE_INFO_SIZE )
        {
            bodyInfo->messageInfo.list = M_CALLOC(sizeof(MmsBodyInfoList));
            firstBodyInfo = bodyInfo->messageInfo.list;
        } 
        else
        {
            prePointer = bodyInfo->messageInfo.list;
            bodyInfo->messageInfo.list->next = M_CALLOC(sizeof(MmsBodyInfoList));
            bodyInfo->messageInfo.list = bodyInfo->messageInfo.list->next;
        } 
        
        startPos = oneEntry;
        oneEntry = parseContentType(&bodyInfo->messageInfo.list->contentType, 
            oneEntry, headerLen);
        
        if (oneEntry == NULL)
        {
            MMS_LOG_I(("%s(%d): Illegal PDU.\n", __FILE__, __LINE__));
            return MMS_RESULT_MESSAGE_CORRUPT;
        }
        
        else if ((headerLen - (UINT32)(oneEntry - startPos)) != 0UL && 
            tempPointer[POS_ENTRY_SIZE] > 0)
        {
            oneEntry = parseEntryHeader(oneEntry, (headerLen - 
                (UINT32)(oneEntry - startPos)), bodyInfo->messageInfo.list);
            if (oneEntry == NULL)
            {
                MMS_LOG_I(("%s(%d): Illegal PDU.\n", __FILE__, __LINE__));
                return MMS_RESULT_MESSAGE_CORRUPT;
            }
        } 

        if (partNumber == 0)
        {
            if (tempPointer[POS_NENTRIES] == 0 && tempPointer[POS_DATA_SIZE] > 0)
            {
                
                bodyInfo->messageInfo.numOfEntries = 1;
            }
            else
            {
                
                bodyInfo->messageInfo.numOfEntries = tempPointer[POS_NENTRIES];
            } 
        } 
        else if (prePointer != NULL)
        {
            prePointer->numOfEntries =  tempPointer[POS_NENTRIES];
        } 

        
        bodyInfo->messageInfo.list->number = partNumber++;

        
        bodyInfo->messageInfo.list->numOfEntries = 0UL;
        
        
        bodyInfo->messageInfo.list->size = tempPointer[POS_DATA_SIZE];

#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
        bodyInfo->messageInfo.list->localDrmId = tempPointer[POS_LOCAL_DRM_ID];
#endif   

        read += (long)MMS_PART_INFO_SIZE;
        
        preMediaType = (MmsKnownMediaType)tempPointer[POS_PART_MEDIA_TYPE];
        tempPointer += POS_INT_PART_NUMBER;
    } 

    if (bodyInfo->messageInfo.list != NULL)
    {
        bodyInfo->messageInfo.list->next = NULL;
    } 

    bodyInfo->messageInfo.list = firstBodyInfo;

    return mmsResult;
} 






static void getMsgInfo(const MmsSignal *sig)
{
    UINT32              size            = 0UL;
    UINT32             *tempPointer     = NULL;
    MmsResult           mmsResult       = MMS_RESULT_OK;
    MmsMessagePart     *bodyInfo        = NULL;
    FmResult            fmResult        = FM_RESULT_OK;  
    UINT32              bytesRead       = 0;
    UINT32             *infoList        = NULL;
    unsigned char      *entry           = NULL;
    UINT32              headerMediaType = 0;

    bodyInfo = M_CALLOC(sizeof(MmsMessagePart));
    bodyInfo->messageInfo.list    = NULL;

    if (fldrmgrOpenList( CMN_CLIENT_MMS, sig->u_param1, &fsm.cache, 
        FM_READ) != FM_RESULT_OK)
    {
        mmsResult = MMS_RESULT_FILE_READ_ERROR;
    }
    else if (fldrmgrOpenMessage( CMN_CLIENT_MMS, sig->u_param1, FM_READ) 
        != FM_RESULT_OK)
    {
        mmsResult = MMS_RESULT_FILE_READ_ERROR;
    } 
    else 
    {
        fmResult = fldrmgrGetListSize( CMN_CLIENT_MMS, sig->u_param1, &size);
        if (fmResult != FM_RESULT_OK)
        {
            mmsResult = checkFolderError(fmResult);
        } 
        else if (size < MMS_MESSAGE_INFO_SIZE)
        {
            mmsResult = MMS_RESULT_MESSAGE_ID_NOT_FOUND;
        } 
    } 

    
    if (size >= (long)MMS_MESSAGE_INFO_SIZE && mmsResult == MMS_RESULT_OK)
    {
        infoList = M_CALLOC((unsigned int)size); 
        
        fmResult = fldrmgrGetList( fsm.cache, 0UL, size, &bytesRead, 
            (unsigned char *)infoList);
        if (fmResult != FM_RESULT_OK)
        {
            mmsResult = checkFolderError(fmResult);
        } 
        
        tempPointer = infoList;

        
        bodyInfo->messageInfo.headerSize = tempPointer[POS_HEADER_SIZE];
        bodyInfo->messageInfo.numOfMsgInfo = tempPointer[POS_NUM_OF_MSG_INFO];
        headerMediaType = tempPointer[POS_MEDIA_TYPE];

        
        fmResult = fldrmgrGetMessageSize( CMN_CLIENT_MMS, sig->u_param1, &bytesRead);
        if (fmResult != FM_RESULT_OK)
        {
            mmsResult = checkFolderError(fmResult);
        } 

        if (bytesRead < MMS_MAX_CHUNK_SIZE && mmsResult == MMS_RESULT_OK)
        {
            entry = M_CALLOC(bytesRead);
            
            fmResult = fldrmgrGetMessage( CMN_CLIENT_MMS, sig->u_param1, 0UL, 
                bytesRead, &bytesRead, entry);
            if (fmResult != FM_RESULT_OK)
            {
                mmsResult = checkFolderError(fmResult);
            } 
        }
        else if (mmsResult == MMS_RESULT_OK)
        {
            entry = M_CALLOC(MMS_MAX_CHUNK_SIZE);
        } 
       
        if (mmsResult == MMS_RESULT_OK)
        {
            tempPointer += POS_INT_MSG_NUMBER;
            
            
            mmsResult = getAllBodyPartInfo(bodyInfo, tempPointer, sig->u_param1, 
                bytesRead, entry, headerMediaType);
        } 
        
        M_FREE(infoList);
        M_FREE(entry);
        infoList = NULL;
        entry = NULL;
    } 
    
    (void)fldrmgrCloseList(fsm.cache);
    (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, sig->u_param1);
      
    
    MMSa_getMessageResponse(mmsResult, MMS_MSG_INFO, bodyInfo);

#ifndef MMS_RETAIN_ADAPTER_PARAMETERS
    
    freeMmsMessageInfo(&bodyInfo->messageInfo);
    M_FREE(bodyInfo);
    bodyInfo = NULL;
#endif
} 









static MmsBodyPart *charsetCvtData(MmsBodyPart *part, UINT32 *charSet,
    MmsKnownMediaType mediaType)
{
    MmsBodyPart *newPart = part;
    int         myCharset = 0;

    
    if (isText(mediaType))
    {
        if (*charSet == CMN_CHARSET_UNKNOWN)
        {
            *charSet = CMN_CHARSET_US_ASCII;
        } 

        myCharset = (int)*charSet;
        newPart = mmsCharsetCvt(&myCharset, part);
        
        if (newPart == NULL)
        {
            newPart = part;
        }
        else
        {
            if (part->storageType == MMS_BODY_PART_AS_BUFFER)
            {
                M_FREE(part->data.buffer);