mfetch.c

彩信MMS的全部代码

        if (setBusy(TRUE) == FALSE)
        {
            

            MMSa_deleteTemporaryFilesResponse(MMS_RESULT_BUSY);
        }
        else
        {
            mmsResult = deleteAllTempfiles();
            MMSa_deleteTemporaryFilesResponse(mmsResult);
            (void)setBusy(FALSE);
        } 
        break;
    case MMS_SIG_MMH_COPY_FINISHED : 
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_COPY_FINISHED\n"));

        copy = (MmsCopyFile *)sig->p_param;
        if (copy == NULL)
        {
            MMS_LOG_I(("%s(%d): Illegal signal data\n", __FILE__, __LINE__));
        }
        else 
        {
            mmsResult = (MmsResult)sig->i_param;
            bodyPart = copy->callerData;
            bodyPart->data.file.id = copy->to.id;
            bodyPart->data.file.category = copy->to.category;
            if (mmsResult == MMS_RESULT_OK && bodyPart->data.file.id != 0)
            {
                fileSize = FILEa_getSize( (char)CMN_FILE_CATEGORY_TMP, 
                    bodyPart->data.file.id);
                FILEa_close(CMN_FILE_CATEGORY_TMP, bodyPart->data.file.id);
                bodyPart->dataSize = (UINT32)fileSize;
                bodyPart = charsetCvtData( bodyPart, &fsm.part.charset,
                    fsm.part.mediaType);
            }
            else if (bodyPart->data.file.id != 0)
            {   
                FILEa_close(CMN_FILE_CATEGORY_TMP, bodyPart->data.file.id);
                FILEa_delete(CMN_FILE_CATEGORY_TMP, bodyPart->data.file.id);
                fileSize = -1;
            } 

            (void)fldrmgrCloseList(fsm.cache);
            fsm.cache = NULL;
            (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, fsm.srcFileId);
            M_FREE(copy);

            
            MMSa_getBodyPartResponse( mmsResult, bodyPart, 
                fsm.srcFileId, fsm.partNumber);

#ifndef MMS_RETAIN_ADAPTER_PARAMETERS       
            freeMmsBodyPart(bodyPart);
            bodyPart = NULL;
#endif
        } 

        fsmRelease();
        (void)setBusy(FALSE);
        break;

    default:
        
        MMS_LOG_I(("%s(%d): received unknown signal %d\n", 
            __FILE__, __LINE__, sig->type));
        break;
    } 

    mSignalDelete(sig);
} 




void mmhFetchTerminate(void)
{
    fsmRelease();
    mSignalDeregister(M_FSM_MMH_FETCH);
    
    MMS_LOG_I(("MMS FSM MMH FETCH: terminated\n"));
} 






static MmsResult deleteAllTempfiles(void)
{
    MmsResult   mmsResult = MMS_RESULT_OK;
    int         nrOfMsgIds = 0;
    UINT32      *allIds;
    
    
    nrOfMsgIds = FILEa_getFileIds(CMN_FILE_CATEGORY_TMP, NULL, 0);
    if (nrOfMsgIds == -1)
    {
        mmsResult = MMS_RESULT_FILE_READ_ERROR;
    }
    else if (nrOfMsgIds > 0)
    {
        allIds = M_CALLOC((unsigned int)nrOfMsgIds * sizeof(UINT32));
        
        
        nrOfMsgIds = FILEa_getFileIds(CMN_FILE_CATEGORY_TMP, allIds, nrOfMsgIds);
        if (nrOfMsgIds == -1)
        {
            mmsResult = MMS_RESULT_FILE_READ_ERROR;
        } 
        else
        {
            while (nrOfMsgIds > 0)
            {
                --nrOfMsgIds;
                
                if (allIds[nrOfMsgIds] != 0)
                {
                    FILEa_close(CMN_FILE_CATEGORY_TMP, allIds[nrOfMsgIds]);
                    FILEa_delete(CMN_FILE_CATEGORY_TMP, allIds[nrOfMsgIds]);
                } 
            } 
        } 

        M_FREE(allIds);
        allIds = NULL;
    } 

    return mmsResult;
} 







static void deleteFolder( MmsFolderType folder, UINT8 ignoreFilter)
{
    UINT32 nrFound = 0;
    UINT32 numberOfMsg;
    MmsFetchDeleteList *msgList;
    FmResult fmResult;
    MmsResult mmsResult = MMS_RESULT_OK;

    msgList = M_CALLOC(sizeof(MmsFetchDeleteList));
    msgList->next = 0;
    msgList->operation = MMS_SIG_MMH_DELETE_FOLDER;

    fmResult = fldrmgrGetNumberOfMsg( CMN_CLIENT_MMS, (UINT16)folder, FM_IS_ANY, 
        &numberOfMsg);
    if (fmResult != FM_RESULT_OK)
    {
        mmsResult = checkFolderError(fmResult);
    }
    else if (numberOfMsg > 0)
    {
        

        if (numberOfMsg * sizeof(MmsMsgId) > MMS_MAX_CHUNK_SIZE)
        { 
            numberOfMsg = MMS_MAX_CHUNK_SIZE / sizeof(MmsMsgId);
            msgList->moreExists = TRUE;
        } 

        msgList->msgIds = M_CALLOC( numberOfMsg * sizeof(MmsMsgId));
        
        fmResult = fldrmgrGetMsgDataList( CMN_CLIENT_MMS, ignoreFilter, 
            (UINT16)folder, 0, numberOfMsg, &nrFound, msgList->msgIds, 
            NULL, NULL, NULL);
        mmsResult = checkFolderError(fmResult);
        msgList->total = nrFound;
    } 

    
    if (mmsResult != MMS_RESULT_OK || nrFound < 1)
    {
        M_SIGNAL_SENDTO_UP( M_FSM_MMH_FETCH, 
            MMS_SIG_MMH_DELETE_MSG_ID_LIST_FINISHED, mmsResult, msgList);
    }
    else
    {
        M_SIGNAL_SENDTO_P( M_FSM_MMH_FETCH, 
            MMS_SIG_MMH_DELETE_MSG_ID_LIST_CONTINUE, msgList);
    } 
} 







static MmsResult deleteMessage(MmsMsgId msgId)
{
    FmResult fmResult;
    MmsResult mmsResult = MMS_RESULT_OK;
    char *trId = NULL;
    MmsVersion ver;
    MmsClassIdentifier classId;

    if (getNotificationData( msgId, &trId, &ver, &classId))
    {   
        if (cfgGetInt(MMS_CFG_EXTRA_NOTIFY_RESP))
        {
            M_SIGNAL_SENDTO_UUP( M_FSM_MSR_NOTIFY, MMS_SIG_MSR_SEND_NOTIFY_RESP, 
                ver, classId, trId);
        }
        else
        {
            M_FREE(trId);
        } 

        
        msrNotifyRemoveId(NOTIF_DELAYED, msgId);
    }
    else 
    {
        
        (void)mrpthRemove(msgId);

        fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, msgId, TRUE);
        mmsResult = checkFolderError(fmResult);
    } 

    return mmsResult;
} 






static void deleteMessageIdList( MmsFetchDeleteList *msgList)
{
    UINT32 pos;         
    UINT32 nrDeleted;   
    CMN_BOOL isNotif;
    MmsClientStatusData status;
    FmResult fmResult;
    MmsResult mmsResult = MMS_RESULT_OK;

    
    for ( pos = msgList->next, nrDeleted = 0; 
        mmsResult == MMS_RESULT_OK && pos < msgList->total && 
            nrDeleted < MMS_NR_OF_DELETE_FOLDER_MSG; 
        ++pos, ++nrDeleted)
    {
        
        fmResult = fldrmgrGetFlag( CMN_CLIENT_MMS, msgList->msgIds[pos], 
            CMN_ATTRIBUTE_NOTIF, &isNotif);
        if (fmResult != FM_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Message ID %ul not found\n", __FILE__, __LINE__,
                msgList->msgIds[pos]));
        }
        else if (isNotif)
        {
            mmsResult = deleteMessage(msgList->msgIds[pos]);
        }
        else 
        {
            
            (void)mrpthRemove(msgList->msgIds[pos]);

            fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, msgList->msgIds[pos], 
                FALSE);
            mmsResult = checkFolderError(fmResult);
        } 

        status.percentage = (int)((pos + 1) * 100 / msgList->total);
        MMSa_status( MMS_CLIENT_STATUS_DELETING, msgList->msgIds[pos], status);
    } 

    msgList->next = pos; 

    
    if (mmsResult != MMS_RESULT_OK || pos >= msgList->total)
    {
        M_SIGNAL_SENDTO_UP( M_FSM_MMH_FETCH, 
            MMS_SIG_MMH_DELETE_MSG_ID_LIST_FINISHED, mmsResult, msgList);
    }
    else
    {
        M_SIGNAL_SENDTO_P( M_FSM_MMH_FETCH, 
            MMS_SIG_MMH_DELETE_MSG_ID_LIST_CONTINUE, msgList);
    } 
} 











static CMN_BOOL getNotificationData( MmsMsgId msgId, char **trId, 
    MmsVersion *ver, MmsClassIdentifier *classId)
{
    FmResult        fmResult;
    MmsHeaderValue  mt;
    MmsHeaderValue  mv;
    MmsHeaderValue  mc;
    MmsHeaderValue  mi;
    unsigned char   *pdu = NULL;
    UINT32          bytesRead = 0;
    CMN_BOOL        ret = FALSE;
    unsigned        len;

    *trId = NULL;
    if (fldrmgrOpenMessage( CMN_CLIENT_MMS, msgId, FM_READ) != FM_RESULT_OK)
    {
        MMS_LOG_I(("%s(%d): Couldn't open file.\n", __FILE__, __LINE__));
        return FALSE;
    } 

    pdu = M_CALLOC(MMS_MAX_NOTIFICATION_SIZE);
    fmResult = fldrmgrGetMessage( CMN_CLIENT_MMS, msgId, 0UL, 
        MMS_MAX_NOTIFICATION_SIZE, &bytesRead, pdu);
    if (fmResult != FM_RESULT_OK)
    {
        MMS_LOG_I(("%s(%d): Couldn't read file.\n", __FILE__, __LINE__));
    }
    else if ( !mmsPduGet( pdu, bytesRead, X_MMS_MESSAGE_TYPE, &mt))
    {
        MMS_LOG_I(("%s(%d): Missing message type.\n", __FILE__, __LINE__));
    }
    else if (mt.messageType != MMS_M_NOTIFICATION_IND)
    {
        
    }
    else if ( !mmsPduGet( pdu, bytesRead, X_MMS_VERSION, &mv))
    {
        MMS_LOG_I(("%s(%d): Missing version.\n", __FILE__, __LINE__));
    }
    else if ( !mmsPduGet( pdu, bytesRead, X_MMS_MESSAGE_CLASS, &mc))
    {
        MMS_LOG_I(("%s(%d): Missing Msg Class.\n", __FILE__, __LINE__));
    }
    else if ( !mmsPduGet( pdu, bytesRead, X_MMS_TRANSACTION_ID, &mi))
    {
        MMS_LOG_I(("%s(%d): Missing transaction ID.\n", __FILE__, __LINE__));
    }
    else
    {
        len = strlen(mi.transactionId) + 1;
        *trId = M_CALLOC(len);
        strcpy( *trId, mi.transactionId);

        *ver = (MmsVersion)mv.version;
        *classId = (MmsClassIdentifier) *(unsigned char *)mc.messageClass;;

        ret = TRUE;
    } 
    
    M_FREE(pdu);
    (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, msgId);

    return ret;
} 







static MmsResult moveMessage(const MmsSignal *sig)
{
    FmResult fmResult = FM_RESULT_OK;
    MmsResult mmsResult = MMS_RESULT_OK;

    if (sig->u_param2 == FM_ALL_FOLDERS)
    {
        mmsResult = MMS_RESULT_FOLDER_NOT_FOUND;
    }
    else
    {
        fmResult = fldrmgrMoveMsg( CMN_CLIENT_MMS, sig->u_param1, 
            (UINT16)sig->u_param2);
        mmsResult = checkFolderError(fmResult);
    } 

    return mmsResult;
} 










static void sendResult(const MmsSignal *sig, CMN_BOOL toStateMachine,
    MmsMessagePart *part, MmsResult mmsResult, MmsMsgType msgType, 
    MmsVersion version)
{
    
    if (toStateMachine == FALSE)
    {
        MMS_LOG_I(("sendResult: Notification arrival time: %lu\n", 
            part == NULL ? 0 : part->notification.timeStamp));
        MMSa_getMessageResponse( mmsResult, msgType, part);

#ifndef MMS_RETAIN_ADAPTER_PARAMETERS
        if (part != NULL)
        {
            if (msgType == MMS_MSG_HEADER)
            {
                freeMmsHeader(&part->header);
                M_FREE(part);
                part = NULL;
            }
            else
            {
                freeMmsNotification(&part->notification);
                M_FREE(part);
                part = NULL;
            } 
        } 
#endif
    }
    else
    {
        M_SIGNAL_SENDTO_IUUP( sig->i_param, (int)sig->u_param2, 
            mmsResult, msgType, version, part);
    } 
} 








static CMN_BOOL setBusy(CMN_BOOL newValue)
{
    
    if (newValue == TRUE) 
    {
        if (fsm.isBusy) 
        {
            return FALSE;
        }
        else
        {
            fsm.isBusy = TRUE;
            return TRUE;
        } 
    }
    else 
    {
#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
        
        if (fsm.queue.isQueued) 
        {
            MmsResult mmsResult;
            fsm.queue.isQueued = FALSE; 

            
            mmsResult = createMsgInfoListInit( fsm.queue.msgId, 0,
                fsm.queue.data);