mreceive.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 "aapifile.h"   
#include "aapicmn.h"    
#include "gmem.h"       
#include "fldrmgr.h"    

#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "msig.h"       
#include "mmem.h"       
#include "mcpdu.h"      
#include "mreceive.h"   
#include "mcget.h"      
#include "mcpost.h"     
#include "mcwap.h"      
#include "mfetch.h"     
#include "mnotify.h"    
#include "mutils.h"     
#include "mconfig.h"    
#include "mmpdup.h"      
#include "mmpduc.h"     








typedef enum
{
    STATE_IDLE,     
    STATE_DELAYED_RETRIEVAL_ACTIVE,
    STATE_IMMEDIATE_RETRIEVAL_ACTIVE
} RetrievalState;


typedef struct
{
    RetrievalState state;
    MmsMsgId notifIdToRetrieve; 
    MmsMsgId msgIdToRetrieve;   
    CMN_BOOL retrieveCancelled; 

    
    unsigned long requestingFsm;
    long returnSignal;
    MmsSigMsrReceiveParam *param;
    UINT32 seqId;
} MsrReceiveInstanceData;















static MsrReceiveInstanceData fsm;


static void deleteUnusedFile(MmsMsgId msgId);
static void fsmClear(void);
static char *getTransactionId(unsigned char *pdu, UINT32 len);
static void msrReceiveMain(MmsSignal *sig);
static MmsResult msgPreparationCheck( UINT32 size, UINT32 *msgId);
static void postAcknowledgeInd(char *transId);
static MmsResult startImmediateRetrieval(const MmsSigMsrReceiveParam *p);









static void deleteUnusedFile(MmsMsgId msgId)
{
    FmResult fmResult; 
    MmsResult result;

    fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, msgId, TRUE);
    result = checkFolderError(fmResult);
    if (result != MMS_RESULT_OK)
    {   
        MMS_LOG_I(("%s(%d): Folder Mgr error %d when removing file %d\n", 
            __FILE__, __LINE__, fmResult, msgId));
    } 
} 





static void fsmClear(void)
{
    fsm.param = NULL;   
    fsm.state = STATE_IDLE;
    fsm.notifIdToRetrieve = 0;
    fsm.msgIdToRetrieve = 0;
    fsm.retrieveCancelled = FALSE;

    fsm.requestingFsm = M_FSM_MAX_REGS; 
    fsm.returnSignal = 0;
    fsm.seqId = 0;
} 








static char *getTransactionId(unsigned char *pdu, UINT32 len)
{
    MmsHeaderValue trId;

    if (!mmsPduGet( pdu, len, X_MMS_TRANSACTION_ID, &trId) || 
        trId.transactionId == NULL)
    {
         return NULL; 
    }   

    return trId.transactionId; 
} 














static MmsResult msgPreparationCheck( UINT32 size, UINT32 *msgId)
{
    MmsResult ret = MMS_RESULT_ERROR;    
    FmResult fmResult;                  

    if ((fmResult = fldrmgrCreateMsg( CMN_CLIENT_MMS, msgId, MMS_INBOX, 
        FALSE)) != FM_RESULT_OK)   
    {
        MMS_LOG_I(("%s(%d): Error creating empty msg (%d).\n", 
            __FILE__, __LINE__, (int)fmResult));
        
        ret = checkFolderError(fmResult);
    }
    else if ((fmResult = fldrmgrSetMessageSize( CMN_CLIENT_MMS, *msgId, 
        size))== FM_RESULT_OK) 
    {
        ret = MMS_RESULT_OK;
    }  
    else 
    {
        MMS_LOG_I(("%s(%d): Error setting msg size (%d).\n", 
            __FILE__, __LINE__, (int)fmResult));
        
        ret = checkFolderError(fmResult);

        
        fmResult = fldrmgrCloseMessage( CMN_CLIENT_MMS, *msgId);
        if (fmResult != FM_RESULT_OK)
        {
            
            MMS_LOG_I(("%s(%d): Disk full and can't close file. Error=%d.\n", 
                __FILE__, __LINE__, (int)fmResult));
        } 

        fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, *msgId, TRUE);
        if (checkFolderError(fmResult) != MMS_RESULT_OK)
        {
            
            MMS_LOG_I(("%s(%d): Disk full and can't delete file. Error=%d.\n", 
                __FILE__, __LINE__, (int)fmResult));
        } 
    } 

    return ret; 
} 





void msrReceiveFreeParam(MmsSigMsrReceiveParam *p)
{
    if (p != NULL)
    {
        M_FREE(p->pdu);
        M_FREE(p);
    } 
} 




void msrReceiveInit(void)
{
    memset( &fsm, 0, sizeof(fsm));

    fsm.param = NULL;
    fsmClear();

    mSignalRegisterDst(M_FSM_MSR_RECEIVE, msrReceiveMain);
    
    MMS_LOG_I(("MMS FSM MSR RECEIVE: initialized\n"));
} 






static void msrReceiveMain(MmsSignal *sig)
{
    UINT32 msgId;                       
    MmsSigCohGetParam *mmsSigCohGetPar; 
    MmsSigCohGetResultParam *getResult; 
    MmsSigCohPostResultParam *postParam;
    MmsClientStatusData data;
    MmsResult ret = MMS_RESULT_OK;       
    FmResult fmResult;                  
    MmsMessagePart *mHeader;
    
    switch (sig->type)
    {
    case MMS_SIG_MSR_RECEIVE_CANCEL :
        
        MMS_LOG_I(("MMS FSM MSR RECEIVE: MMS_SIG_MSR_RECEIVE_CANCEL\n"));
        
        
        if (fsm.state == STATE_DELAYED_RETRIEVAL_ACTIVE)
        {
            


            if ((MmsMsgId)sig->u_param1 == fsm.notifIdToRetrieve) 
            {
                fsm.retrieveCancelled = TRUE;
                cohGetCancel(fsm.msgIdToRetrieve);
            } 
        }
        else if (fsm.state == STATE_IMMEDIATE_RETRIEVAL_ACTIVE)
        {
            



            if ((MmsMsgId)sig->u_param1 == fsm.msgIdToRetrieve) 
            {
                fsm.retrieveCancelled = TRUE;
                cohGetCancel(fsm.msgIdToRetrieve);
            } 
        } 
        break;

    case MMS_SIG_MSR_RECEIVE_IMMEDIATE :
        if (fsm.state != STATE_IDLE)
        {
            MMS_LOG_I(("%s(%d): Receive busy\n", __FILE__, __LINE__));
            ((MmsSigMsrReceiveParam *)sig->p_param)->result = MMS_RESULT_BUSY;
            M_SIGNAL_SENDTO_P( sig->u_param1, sig->i_param, sig->p_param);
        }
        else
        {
            fsm.state = STATE_IMMEDIATE_RETRIEVAL_ACTIVE;

            fsm.param = (MmsSigMsrReceiveParam *)sig->p_param;
            fsm.requestingFsm = sig->u_param1;
            fsm.returnSignal = sig->i_param;
            fsm.msgIdToRetrieve = 0; 
            fsm.notifIdToRetrieve = fsm.param->notifId;
            ret = startImmediateRetrieval(fsm.param);
            if (ret != MMS_RESULT_OK)
            {
                fsm.param->result = ret;
                M_SIGNAL_SENDTO_P( fsm.requestingFsm, fsm.returnSignal, fsm.param);

                fsm.param = NULL;  
                fsmClear();
            } 
        } 
        break;
    case MMS_SIG_MSR_RECEIVE_DELAYED :
        MMS_LOG_I(("MMS FSM MSR RECEIVE: MMS_SIG_MSR_RECEIVE_DELAYED\n"));
       
        
        if (fsm.state != STATE_IDLE) 
        {
            MMSa_retrieveMessageResponse( MMS_RESULT_BUSY, (MmsMsgId)0,
                MMS_RTRV_STATUS_NONE, NULL);
        }
        else if ((MmsMsgId)sig->u_param1 == 0)  
        {    
            MMSa_retrieveMessageResponse( MMS_RESULT_MESSAGE_ID_NOT_FOUND,
                (MmsMsgId)sig->u_param1, MMS_RTRV_STATUS_NONE, NULL);
        }     
        else
        {
            
            fsm.retrieveCancelled = FALSE;
            fsm.state = STATE_DELAYED_RETRIEVAL_ACTIVE;
            fsm.msgIdToRetrieve = 0; 
            fsm.notifIdToRetrieve = (MmsMsgId)sig->u_param1;

            M_SIGNAL_SENDTO_IUU( M_FSM_MMH_FETCH,
                MMS_SIG_MMH_GET_HEADER_TO_SM, M_FSM_MSR_RECEIVE,
                fsm.notifIdToRetrieve, MMS_SIG_MSR_RECEIVE_GET_HEADER_RSP);
        }  
        break;

    case MMS_SIG_MSR_RECEIVE_GET_HEADER_RSP:
        



        mHeader = (MmsMessagePart*)sig->p_param;
        if (fsm.retrieveCancelled)
        {
            ret = MMS_RESULT_CANCELLED_BY_USER;