mcreate.c

彩信MMS的全部代码

            ret = MMS_RESULT_ERROR;
        }
         
        else if ( (ret = storeToFm( pduBody, FM_APPEND, length, *newMsgId))
            != MMS_RESULT_OK)
        {
            MMS_LOG_I(("MMS FSM MMH CREATE: Unable to store Read report body"));
        }
        else if ( (ret = createMsgInfoList( *newMsgId, 0)) != MMS_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Unable to create Read Report info list",
                __FILE__, __LINE__));
        }
        else if ( (fmResult = fldrmgrSetFlagValid( CMN_CLIENT_MMS, *newMsgId, 
            TRUE)) != FM_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Couldn't set the msg as valid.\n", 
                __FILE__, __LINE__));
            ret = checkFolderError( fmResult);
        } 
      
        
        M_FREE(pduBody);
        pduBody = NULL;

        
        if ( ret != MMS_RESULT_OK )
        {
            
            if ( fldrmgrDeleteMsg( CMN_CLIENT_MMS, *newMsgId, FALSE) != FM_RESULT_OK)
            {
                
                MMS_LOG_I(("MMS FSM MMH CREATE: Unable to delete file (%lu)", 
                    *newMsgId));
            } 

            *newMsgId = 0;
        } 

        if ( pduData != NULL)
        {
            M_FREE( pduData);
            pduData = NULL;
        } 

        if ( newHeader != NULL)
        {
            freeMmsAddressList( newHeader->to);
            if ( newHeader->contentType != NULL)
            {
                freeMmsContentType( newHeader->contentType);
                M_FREE( newHeader->contentType);
                newHeader->contentType = NULL;
            } 

            if ( newHeader->subject.text != NULL)
            {
                M_FREE( newHeader->subject.text);
                newHeader->subject.text = NULL;
            } 

            M_FREE( newHeader);
            newHeader = NULL;
        } 
    } 

    return ret;
} 








static unsigned char *createWspHeader(const MmsSetBodyParams *bodyParams,
    UINT32 *encHeaderLen)
{
    unsigned char *encHeader = NULL;    
    INT32 bytesRead = 0;
    UINT32 numOfEntries = 0;
    MmsResult mmsResult;

    *encHeaderLen = 0;

    
    if ( isMultiPart( bodyParams->contentType.knownValue))
    {
        
        bytesRead = FILEa_read( bodyParams->bodyPart.data.file.category,
            bodyParams->bodyPart.data.file.id, &numOfEntries, 0, sizeof(UINT32));

        if (bytesRead != (INT32)sizeof(UINT32))
        {   
            MMS_LOG_I(("%s(%d): unable to read numOfEntries\n",
                __FILE__, __LINE__));
            return NULL;
        } 
    } 

    
    encHeader = createWspBodyPartHead( bodyParams, encHeaderLen, 
        numOfEntries, &mmsResult);
    if (encHeader == NULL) 
    {   
        MMS_LOG_I(("%s(%d): unable to createWspBodyPartHead. Error=%d\n",
            __FILE__, __LINE__, (int)mmsResult));
        *encHeaderLen = 0;
    } 

    return encHeader;
} 







static void freeMmsSetBodyParams( MmsSetBodyParams *bodyParams)
{
    if ( bodyParams == NULL)
    { 
        return;
    } 
    
    if ( bodyParams->bodyPart.storageType == MMS_BODY_PART_AS_BUFFER &&
            bodyParams->bodyPart.data.buffer != NULL)
    { 
        M_FREE( bodyParams->bodyPart.data.buffer);
        bodyParams->bodyPart.data.buffer = NULL;
    } 
    
    freeMmsContentType( &bodyParams->contentType);
   
    if ( bodyParams->entryHeader != NULL)
    { 
        freeMmsEntryHeader( bodyParams->entryHeader);
        bodyParams->entryHeader = NULL;
    } 

    M_FREE( bodyParams);
    bodyParams = NULL;
} 




static void fsmRelease(void)
{
    memset( &fsm, 0, sizeof(fsm));
} 




void mmhCreateInit(void)
{
    fsmRelease();
    fsm.isBusy = FALSE;
    mSignalRegisterDst(M_FSM_MMH_CREATE, mmhCreateMain);
    
    MMS_LOG_I(("MMS FSM MMH CREATE: initialized\n"));
} 




static CMN_BOOL mmhCreateIsBusy(MmsSignal *sig)
{
    CMN_BOOL shouldAbort = FALSE;

    if (fsm.isBusy)
    {
        shouldAbort = TRUE;

        switch (sig->type)
        {
        case MMS_SIG_MMH_CREATE_MSG :
            MMSa_createMessageResponse( MMS_RESULT_BUSY, 0);
            break;
        case MMS_SIG_MMH_CREATE_MULTI_PART_MSG :
            MMSa_createMultiPartEntryResponse( MMS_RESULT_BUSY, 0);
            break;
        case MMS_SIG_MMH_SET_HEADER :
            freeMmsHeader((MmsHeader *)sig->p_param);
            M_FREE(sig->p_param);
            MMSa_setMessageHeaderResponse( MMS_RESULT_BUSY);
            break;
        case MMS_SIG_MMH_SET_BODY_PART:
            freeMmsSetBodyParams( (MmsSetBodyParams *)sig->p_param);
            MMSa_setMessageBodyResponse( MMS_RESULT_BUSY);
            break;
        case MMS_SIG_MMH_DONE_MSG :
            MMSa_createMessageDoneResponse( MMS_RESULT_BUSY, 0L);
            break;
        case MMS_SIG_MMH_CREATE_RR :
            M_SIGNAL_SENDTO_IU( sig->i_param, sig->u_param2, MMS_RESULT_BUSY, 0);
            break;
        case MMS_SIG_MMH_CREATE_FORWARD :
            freeMmsForward((MmsForward *)sig->p_param);
            M_SIGNAL_SENDTO_IUUP(sig->i_param, sig->u_param1, MMS_RESULT_BUSY, 
                0, MMS_M_FORWARD_REQ, NULL);
            break;
        default :
            
            shouldAbort = FALSE;
            break;
        } 
    } 

    return shouldAbort;
} 






static void mmhCreateMain(MmsSignal *sig)
{
    MmsResult result = MMS_RESULT_OK;
    FmResult fmResult;
    UINT32 messageSize = 0;
    UINT32 msgId = 0;
    MmsSetBodyParams *bodyParams;
    MmsHeader *header;
    MmsMessagePart *msgPart = NULL;
    unsigned char *pdu = NULL;
    unsigned char *headerData = NULL;
    char *uri = NULL;
    UINT32 bytesRead = 0;
    UINT32 theDate;
    UINT8 flag;
    MmsReadReportInfo *info = NULL;
    MmsVersion version;
    CMN_BOOL isRead;
    MmsMessageType msgType;
    MmsCopyFile *copy;
    MmsMmhCreateSetBodyParams *setParams;

    
    if (mmhCreateIsBusy(sig))
    {
        MMS_LOG_I(("%s(%d): MMH CREATE received signal %d when busy\n",
            __FILE__, __LINE__, sig->type));
        mSignalDelete(sig);
        return;
    } 

    switch (sig->type)
    {
    case MMS_SIG_MMH_CREATE_MSG :
        MMS_LOG_I(("MMS FSM MMH CREATE: MMS_SIG_MMH_CREATE_MSG\n"));

        fsm.isBusy = TRUE;
        fmResult = fldrmgrCreateMsg( CMN_CLIENT_MMS, &msgId, MMS_DRAFTS, FALSE);
        result = checkFolderError( fmResult);
        fsm.isBusy = FALSE;

        MMSa_createMessageResponse( result, msgId);
        break;
    
    case MMS_SIG_MMH_CREATE_MULTI_PART_MSG :
        fsm.isBusy = TRUE;

        if ( FILEa_create( CMN_FILE_CATEGORY_TMP, NULL, &msgId) < 0)
        {
            result = MMS_RESULT_INSUFFICIENT_PERSISTENT_STORAGE;
        }
                
        else if ( (UINT32)FILEa_write( CMN_FILE_CATEGORY_TMP, msgId, 
            (void *)&sig->u_param1, 0, sizeof( UINT32)) != sizeof(UINT32))
        {
            result = MMS_RESULT_INSUFFICIENT_PERSISTENT_STORAGE;
        } 
        
        
        FILEa_close( CMN_FILE_CATEGORY_TMP, msgId);
        fsm.isBusy = FALSE;

        MMSa_createMultiPartEntryResponse( result, msgId);
        break;

    case MMS_SIG_MMH_SET_HEADER :
        MMS_LOG_I(("MMS FSM MMH CREATE received: MMS_SIG_MMH_SET_HEADER\n"));
        header = (MmsHeader *)sig->p_param;
        fsm.isBusy = TRUE;
        result = storeWspHeader( sig->u_param1, sig->u_param2, header);
        if (result != MMS_RESULT_OK)
        {   
            fmResult = fldrmgrCloseMessage ( CMN_CLIENT_MMS, sig->u_param1);
            if (fmResult != FM_RESULT_OK)
            {
                MMS_LOG_I(("%s(%d): Couldn't close the msg.\n", 
                    __FILE__, __LINE__));
            } 

            fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, sig->u_param1, FALSE);
            if (fmResult != FM_RESULT_OK)
            {   
                MMS_LOG_I(("MMS FSM MMH CREATE: Unable to delete file!\n"));
            } 
        } 

        fsm.isBusy = FALSE;
        freeMmsHeader(header);
        M_FREE(header);
        MMSa_setMessageHeaderResponse( result);
        break;

    case MMS_SIG_MMH_SET_BODY_PART:
        MMS_LOG_I(("MMS FSM MMH CREATE received: MMS_SIG_MMH_SET_BODY_PART\n"));
        bodyParams = (MmsSetBodyParams *)sig->p_param;
        fsm.isBusy = TRUE;

        

        createBodyPart( bodyParams); 
        break;
    case MMS_SIG_MMH_COPY_FINISHED : 
        MMS_LOG_I(("MMS FSM MMH CREATE: 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
        {
            setParams = (MmsMmhCreateSetBodyParams *)copy->callerData;
            setParams->result = (MmsResult)sig->i_param;
            M_SIGNAL_SENDTO_P( M_FSM_MMH_CREATE, MMS_SIG_MMH_SET_BODY_PART_FINISHED, 
                setParams);
            M_FREE(copy);
        } 
        break;
    case MMS_SIG_MMH_SET_BODY_PART_FINISHED:
        setParams = (MmsMmhCreateSetBodyParams *)sig->p_param;
        if (setParams == NULL)
        {
            MMS_LOG_I(("%s(%d): Illegal signal data\n", __FILE__, __LINE__));
        }
        else 
        {
            closeFiles(setParams);
            bodyParams = (MmsSetBodyParams *)setParams->bodyParams;
            freeMmsSetBodyParams( bodyParams);
            MMSa_setMessageBodyResponse( setParams->result);
            M_FREE(setParams);
        } 

        fsmRelease();
        fsm.isBusy = FALSE;
        break;
    case MMS_SIG_MMH_DONE_MSG :
        MMS_LOG_I(("MMS FSM MMH CREATE: MMS_SIG_MMH_DONE_MSG\n"));
        fsm.isBusy = TRUE;
        if ( (result = createMsgDone( sig->u_param1, &messageSize)) !=
            MMS_RESULT_OK)
        {
            MMS_LOG_I(("%s(%d): Error %d when creating the info file.\n", 
                __FILE__, __LINE__, result));
        } 

        
        fmResult = fldrmgrCloseMessage ( CMN_CLIENT_MMS, sig->u_param1);
        if (fmResult != FM_RESULT_OK && result == MMS_RESULT_OK)
        {
            result = checkFolderError( fmResult);
            MMS_LOG_I(("%s(%d): Couldn't close the msg.\n", 
                __FILE__, __LINE__));
        } 
        
        
        if ( result != MMS_RESULT_OK)
        {
            fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, sig->u_param1, TRUE);
            if ( checkFolderError( fmResult) != MMS_RESULT_OK)
            {   
                MMS_LOG_I(("MMS FSM MMH CREATE: Unable to delete file!\n"));
            } 
        }
        else
        {
            

            fmResult = fldrmgrSetFlagValid( CMN_CLIENT_MMS, sig->u_param1, TRUE);
            result = checkFolderError( fmResult);
            if (result != MMS_RESULT_OK)
            {
                MMS_LOG_I(("%s(%d): Couldn't set the msg as valid.\n", 
                    __FILE__, __LINE__));
            } 
        } 

        MMSa_createMessageDoneResponse( result, messageSize);
        fsm.isBusy = FALSE;
        break;

    case MMS_SIG_MMH_CREATE_RR :
        MMS_LOG_I(("MMS FSM MMH CREATE: MMS_SIG_MMH_CREATE_RR\n"));
        fsm.isBusy = TRUE;

        
        fsm.callingFsm = (unsigned long)sig->i_param;    
        fsm.returnSignal = sig->u_param1;
        fsm.altReturnSignal = sig->u_param2;
        info = (MmsReadReportInfo *)sig->p_param;
        fsm.readStatus = info->readStatus;
        fsm.readRepMsgId = info->msgId;

        M_SIGNAL_SENDTO_IUU( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_HEADER_TO_SM, 
            M_FSM_MMH_CREATE, info->msgId, MMS_SIG_MMH_CREATE_RR_GOT_HEADER);
        M_FREE(info);
        break;