mfetch.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 "cutils.h"     
#include "mmstypes.h"   
#include "mmsconf.h"    
#include "aapimms.h"    
#include "msig.h"       
#include "mmem.h"       
#include "mfetch.h"     
#include "mcpdu.h"      
#include "mmpdup.h"      
#include "mfieldp.h"    
#include "mutils.h"     
#include "mfreemms.h"   
#include "mrptr.h"                                         
#include "mnotify.h"    
#include "mconfig.h"    
#include "mcopy.h"      

#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
#include "mreceive.h"   
#endif 


 
enum MmsIntMsgInfo
{
    POS_ZERO,           
    POS_VERSION,        
    POS_HEADER_SIZE,
    POS_MEDIA_TYPE,
    POS_NUM_OF_MSG_INFO,
    POS_INT_MSG_NUMBER
};


enum MmsIntPartInfo
{
    POS_DATA_SIZE,
    POS_DATA_START,
    POS_ENTRY_SIZE,
    POS_ENTRY_START,
    POS_NENTRIES,
    POS_PART_MEDIA_TYPE,
    POS_CHARSET,
#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
    POS_LOCAL_DRM_ID,
#endif 
    POS_INT_PART_NUMBER
};

#ifdef MMS_PREPARATION_FOR_MEDIA_CHANGE

typedef struct
{
    UINT32 zero;        
    UINT32 version;     
    UINT32 headerSize;  
    UINT32 mediaType;   
    UINT32 nParts;      
} MmsFetchMsgInfo;
#endif


typedef struct
{
    UINT32 dataSize;
    UINT32 dataStart;
    UINT32 entrySize;
    UINT32 entryStart;
    UINT32 nEntries;
    UINT32 charset;
#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
    UINT32 localDrmId;
#endif 
    MmsKnownMediaType mediaType;
} MmsFetchPartInfo;


typedef struct
{
    CMN_BOOL isBusy;        
    CMN_BOOL isDeleteCancelled; 
    UINT32 srcFileId;
    void *cache;            
    UINT32 partNumber;
    struct 
    {
        CMN_BOOL isQueued; 
        MmsMsgId msgId; 
        void *data;     
    } queue;
    MmsFetchPartInfo part;
} MmhFetchInstanceData;

#ifdef MMS_EXTERNAL_DRM_ID_GENERATION

typedef struct
{
    
    unsigned char  *header;
    unsigned char  *body;
    unsigned char  *bodyBuf;
    UINT32         *dataToWrite;
    UINT32         *tempPointer;
    UINT32         partInfo[POS_INT_PART_NUMBER];
    UINT32         msgInfo[POS_INT_MSG_NUMBER];
    UINT32         messageSize;
    UINT32         clientMsgId;
    UINT32         bytesRead;
    CMN_BOOL       gotCompMsg;
    CMN_BOOL       isEntriesOk;
    MmsHeaderValue tag;
    void           *p;
    
    
    
    unsigned char *secBodyPointer;
    unsigned char *bodyPointer;
    
    UINT32    readFrom;
    UINT32    headerLen;
    UINT32    size;
    UINT32    countNumOfEntry;
    CMN_BOOL  isFinished;
    CMN_BOOL  isListOpen;
    CMN_BOOL  flag; 

    
} DrmVariables;

#endif 


#define MMS_MESSAGE_INFO_SIZE (POS_INT_MSG_NUMBER * sizeof(UINT32))
#define MMS_PART_INFO_SIZE (POS_INT_PART_NUMBER * sizeof(UINT32))

#define MMS_INFO_FILE_FORMAT_VERSION_CURRENT    1 















static MmhFetchInstanceData fsm;

#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
static DrmVariables drm;
#endif 


static MmsBodyPart *charsetCvtData(MmsBodyPart *part, UINT32 *charSet,
    MmsKnownMediaType mediaType);
static MmsResult createMsgInfoListCleanup(unsigned char *header);
static MmsResult deleteAllTempfiles(void);
static void deleteFolder(MmsFolderType folder, UINT8 ignoreFilter);
static MmsResult deleteMessage(MmsMsgId msgId);
static void deleteMessageIdList( MmsFetchDeleteList *msgList);
static void fsmRelease(void);
static MmsResult getAllBodyPartInfo(MmsMessagePart *bodyInfo, 
    const UINT32 *tempPointer, UINT32 clientMsgId, UINT32 entrySize, 
    unsigned char *entry, UINT32 headerMediaType);
static CMN_BOOL getAllEntries( UINT32 **dataToWrite,
    unsigned char *secBodyPointer, UINT32 *partInfo, CMN_BOOL gotCompMsg, 
    UINT32 *msgInfo, unsigned char *header, UINT32 messageSize, 
    UINT32 clientMsgId, UINT32 **tempPointer);
static void getAllMsg(const MmsSignal *sig);
static CMN_BOOL getBodyPart(const MmsSignal *sig);
static CMN_BOOL getContentTypeValues(UINT32 *partInfo, 
    const unsigned char *contentTypeStart, UINT32 size);
static void getHeader(const MmsSignal *sig, CMN_BOOL toStateMachine);
static CMN_BOOL getHeaderMediaType(UINT32 *partInfo, UINT32 *msgInfo, 
    unsigned char *header, UINT32 size);
static MmsResult getMessage(UINT32 clientMsgId, UINT32 *messageSize, 
    CMN_BOOL *gotCompMsg, unsigned char **header, UINT32 *bytesRead);
static void getMsgInfo(const MmsSignal *sig);
static CMN_BOOL getNotificationData( MmsMsgId msgId, char **trId, 
    MmsVersion *ver, MmsClassIdentifier *classId);
static void getNumOfMsg(const MmsSignal *sig);
static unsigned char *getPartInfo(unsigned char *bodyPointer, UINT32 *headerLen, 
    UINT32 *partInfo, UINT32 bufSize);
static CMN_BOOL getReqData(UINT32 msgId, UINT32 number);
static unsigned char *findContentType(unsigned char *entry, UINT32 size, 
    MmsKnownMediaType mediaType, UINT32 *headerLen, UINT32 entrySize, CMN_BOOL first);
static void mmhFetchMain(MmsSignal *sig);
static MmsResult moveMessage(const MmsSignal *sig);
static void sendResult(const MmsSignal *sig, CMN_BOOL toStateMachine,  
    MmsMessagePart *notifyPart, MmsResult mmsResult, MmsMsgType msgType, 
    MmsVersion version);
static CMN_BOOL setBusy(CMN_BOOL busy);

#ifdef MMS_EXTERNAL_DRM_ID_GENERATION
static MmsResult createMsgInfoListPreFinish(UINT32 drmId);
static MmsResult createMsgInfoListFinish(void);
static MmsResult createMsgInfoListInit(MmsMsgId clientMsgIdIn, MmsTimeSec time,void* pIn);
static MmsResult createMsgInfoListLoop(UINT32 drmId, CMN_BOOL firstEntry);
static void createMsgInfoListReturn(MmsResult ret, MmsMsgId msgId, void *data);
static MmsResult updateDrmId( MmsMsgId msgId, UINT32 drmId, INT32 bodypartId);
#endif 






static void fsmRelease(void)
{
    memset( &fsm, 0, sizeof(fsm));
    (void)setBusy(FALSE);
    fsm.isDeleteCancelled = FALSE;
} 




void mmhFetchInit(void)
{
    memset( &fsm, 0, sizeof(fsm));
    fsm.queue.isQueued = FALSE;
    (void)setBusy(FALSE);
    fsm.isDeleteCancelled = FALSE;

    mSignalRegisterDst(M_FSM_MMH_FETCH, mmhFetchMain);
    
    MMS_LOG_I(("MMS FSM MMH FETCH: initialized\n"));
} 






static void mmhFetchMain(MmsSignal *sig)
{
    MmsBodyPart *bodyPart;
    INT32 fileSize = -1;
    MmsResult mmsResult;
    FmResult fmResult;
    MmsCopyFile *copy;
    MmsFetchDeleteList *msgList;

    switch (sig->type)
    {
    case MMS_SIG_MMH_GET_HEADER:        
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_GET_HEADER\n"));
        if (fsm.isBusy == TRUE)
        {
            MMSa_getMessageResponse(MMS_RESULT_BUSY, MMS_MSG_HEADER, NULL);
        }
        else
        {
            fsm.isBusy = TRUE;
            getHeader( sig, FALSE);
            (void)setBusy(FALSE);
        } 
        break;
    case MMS_SIG_MMH_GET_MSG_INFO:     
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_GET_MSG_INFO\n"));
        if (fsm.isBusy == TRUE)
        {
            MMSa_getMessageResponse(MMS_RESULT_BUSY, MMS_MSG_INFO, NULL);
        }
        else
        {
            fsm.isBusy = TRUE;
            getMsgInfo(sig); 
            (void)setBusy(FALSE);
        } 
        break;
#ifdef MMS_EXTERNAL_DRM_ID_GENERATION 
    case MMS_SIG_MMH_SET_ID_INFO_INIT:     
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_SET_ID_INFO_INIT\n"));
        if (setBusy(TRUE) == FALSE)
        {
            
            fsm.queue.isQueued = TRUE;
            fsm.queue.msgId = (MmsMsgId)sig->u_param1;
            fsm.queue.data = sig->p_param;
        }
        else
        {
            mmsResult = createMsgInfoListInit( (MmsMsgId)sig->u_param1,
                0, sig->p_param);
            if (mmsResult != MMS_RESULT_OK)
            {
                createMsgInfoListReturn( mmsResult, (MmsMsgId)sig->u_param1,
                    sig->p_param);
            } 
        } 
        break;
    case MMS_SIG_MMH_SET_ID_INFO:     
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_SET_ID_INFO\n"));
        
        if (sig->i_param == 0)
        {
            mmsResult = createMsgInfoListPreFinish(sig->u_param1);
        }
        else
        {
            mmsResult = createMsgInfoListLoop(sig->u_param1, FALSE);
        }

        if (mmsResult != MMS_RESULT_OK)
        {
            createMsgInfoListReturn( mmsResult, drm.clientMsgId,
                drm.p);
        } 
        break;
    case MMS_SIG_MMH_SET_DRM_ID:     
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_SET_DRM_ID\n"));        
        mmsResult = updateDrmId( sig->u_param2, sig->u_param1, sig->i_param);
        MMSa_setDrmIdResponse( mmsResult, sig->u_param2);
        break;
#endif 
    case MMS_SIG_MMH_GET_BODYPART:    
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_GET_BODYPART\n"));
        if (setBusy(TRUE) == FALSE)
        {
            MMSa_getBodyPartResponse( MMS_RESULT_BUSY, NULL, 
                sig->u_param1, sig->u_param2);
        }
        else if (getBodyPart(sig)) 
        {
            (void)setBusy(FALSE);
        } 
        break;
    case MMS_SIG_MMH_GET_HEADER_TO_SM:  
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_GET_HEADER_TO_SM\n"));
        if (setBusy(TRUE) == FALSE)
        {
            M_SIGNAL_SENDTO_IUP(sig->i_param, (int)sig->u_param2, 
                MMS_RESULT_BUSY, sig->u_param1, NULL);
        }
        else
        {
            getHeader( sig, TRUE);
            (void)setBusy(FALSE);
        } 
        break;
    case MMS_SIG_MMH_GET_IDS:           
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_GET_IDS\n"));
        getAllMsg(sig); 
        break;
    case MMS_SIG_MMH_GET_NUM_OF_IDS:    
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_GET_NUM_OF_IDS\n"));
        getNumOfMsg(sig); 
        break;
    case MMS_SIG_MMH_DELETE_FOLDER:     
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_DELETE_FOLDER\n"));
        if (fsm.isBusy)
        {
            MMSa_deleteFolderResponse(MMS_RESULT_BUSY);
        }
        else
        {
            fsm.isBusy = TRUE;
            fsm.isDeleteCancelled = FALSE;
            deleteFolder((MmsFolderType)sig->u_param1, (UINT8)sig->u_param2);
        } 
        break;
    case MMS_SIG_MMH_DELETE_MSG_ID_LIST_CANCEL:
    case MMS_SIG_MMH_DELETE_FOLDER_CANCEL: 
        


        fsm.isDeleteCancelled = TRUE;
        break;
    case MMS_SIG_MMH_DELETE_MSG:        
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_DELETE_MSG\n"));
        
        mmsResult = deleteMessage((MmsMsgId)sig->u_param1);
        MMSa_deleteMessageResponse(mmsResult);
        break;
    case MMS_SIG_MMH_DELETE_MSG_ID_LIST_CONTINUE:
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_DELETE_MSG_ID_LIST_CONTINUE\n"));
        if (fsm.isDeleteCancelled)
        {
            M_SIGNAL_SENDTO_UP( M_FSM_MMH_FETCH, 
                MMS_SIG_MMH_DELETE_MSG_ID_LIST_FINISHED, 
                MMS_RESULT_CANCELLED_BY_USER, sig->p_param);
            fsm.isDeleteCancelled = FALSE;
        }
        else
        {
            deleteMessageIdList((MmsFetchDeleteList *)sig->p_param);
        } 
        break;
    case MMS_SIG_MMH_DELETE_MSG_ID_LIST_FINISHED:
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_DELETE_MSG_ID_LIST_FINISHED %ld\n",
            (long)sig->u_param1));

        mmsResult = (MmsResult)sig->u_param1;
        msgList = (MmsFetchDeleteList *)sig->p_param;
        if (mmsResult != MMS_RESULT_BUSY && msgList->total > 0)
        {   

            fmResult = fldrmgrIndexTableSave(MMS_SAVE_BOTH_FILES);
            if (mmsResult == MMS_RESULT_OK)
            {   
                mmsResult = checkFolderError(fmResult);
            } 
        } 

        if (msgList->operation == MMS_SIG_MMH_DELETE_FOLDER)
        {
            if (mmsResult == MMS_RESULT_OK && msgList->moreExists)
            {
                mmsResult = MMS_RESULT_MORE_MESSAGES_EXISTS;
            } 

            MMSa_deleteFolderResponse(mmsResult);
        }
        else
        {
            MMSa_deleteMessageIdListResponse(mmsResult);
        } 

        M_FREE(msgList->msgIds);
        M_FREE(msgList);
        (void)setBusy(FALSE);
        break;
    case MMS_SIG_MMH_MOVE_MSG:          
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_MOVE_MSG\n"));
        
        mmsResult = moveMessage(sig);
        MMSa_moveMessageResponse(mmsResult);
        break;
    case MMS_SIG_MMH_DELETE_TEMP_FILES: 
        MMS_LOG_I(("MMS FSM MMH FETCH: MMS_SIG_MMH_DELETE_TEMP_FILES\n"));