capimms.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 "fldrmgr.h"    
#include "gmem.h"       

#include "mms_vrsn.h"   
#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "capimms.h"    
#include "msig.h"       
#include "mtimer.h"     
#include "mmem.h"       
#include "mcpdu.h"      
#include "mcreate.h"    
#include "mfetch.h"     
#include "mimport.h"    
#include "msend.h"      
#include "mreceive.h"   
#include "mnotify.h"    
#include "mcget.h"      
#include "mcnotif.h"    
#include "mcpost.h"     
#include "mmain.h"      
#include "mconfig.h"    
#include "mcwap.h"      
#include "mutils.h"     
#include "mrptr.h"      
#include "slcreate.h"   
#include "slparhlr.h"   
#include "slutil.h"     
















#if defined USE_G_MALLOC



    static char mmsMemory[MMS_MALLOC_MEM_SIZE];
#endif










void MMSc_createMessage(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_createMessage(void)\n"));

    sig = M_SIGNAL_SENDTO( M_FSM_MMH_CREATE, MMS_SIG_MMH_CREATE_MSG);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_createMultiPartEntry( UINT32 numOfEntries)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_createMultiPartEntry(void)\n"));

    sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_CREATE, 
        MMS_SIG_MMH_CREATE_MULTI_PART_MSG, numOfEntries);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_createMessageDone(MmsMsgId msgId)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_createMessageDone(%lu)\n", msgId));
    
    sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_CREATE, MMS_SIG_MMH_DONE_MSG, msgId);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_deleteFolder( MmsFolderType folder, UINT8 ignoreFilter)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_deleteFolder(%lu,%lu)\n", (long)folder, (long)ignoreFilter));

    sig = M_SIGNAL_SENDTO_UU( M_FSM_MMH_FETCH, MMS_SIG_MMH_DELETE_FOLDER, 
        folder, ignoreFilter);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_deleteFolderCancel(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_deleteFolderCancel()\n"));

    sig = M_SIGNAL_SENDTO( M_FSM_MMH_FETCH, MMS_SIG_MMH_DELETE_FOLDER_CANCEL);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_deleteMessage(MmsMsgId msgId)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_deleteMessage(%lu)\n", msgId));

    sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_FETCH, MMS_SIG_MMH_DELETE_MSG, msgId);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_deleteMessageIdList( const MmsMsgId msgId[], UINT32 number)
{
    MmsSignal *sig;
    MmsFetchDeleteList *msgList;

    MMS_LOG_E(("MMSc_deleteMessageIdList(%lu...,%lu)\n", 
        msgId == NULL ? 0 : (UINT32)msgId[0], number));

    if (number == 0 || msgId == NULL)
    {
        MMS_LOG_I(("%s(%d): No action requested.\n", __FILE__, __LINE__));
        return;
    } 

    if (number * sizeof(UINT32) > MMS_MAX_CHUNK_SIZE)
    {
        MMS_LOG_I(("%s(%d): Too much heap memory needed\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_INSUFFICIENT_MEMORY);
        return;
    } 
    
    msgList = M_CALLOC(sizeof(MmsFetchDeleteList));
    if (msgList == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 

    msgList->msgIds = M_CALLOC(number * sizeof(UINT32));
    if (msgList->msgIds == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 

    msgList->operation = MMS_SIG_MMH_DELETE_MSG_ID_LIST_CONTINUE;
    memcpy( msgList->msgIds, msgId, number * sizeof(UINT32));
    msgList->total = number;
    msgList->next = 0;

    sig = M_SIGNAL_SENDTO_P( M_FSM_MMH_FETCH, 
        MMS_SIG_MMH_DELETE_MSG_ID_LIST_CONTINUE, msgList);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_deleteMessageIdListCancel(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_deleteMessageIdListCancel()\n"));

    sig = M_SIGNAL_SENDTO( M_FSM_MMH_FETCH, MMS_SIG_MMH_DELETE_MSG_ID_LIST_CANCEL);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_deleteTemporaryFiles(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_deleteTemporaryFiles(void)\n"));

    sig = M_SIGNAL_SENDTO( M_FSM_MMH_FETCH, MMS_SIG_MMH_DELETE_TEMP_FILES);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_forwardReq(const MmsForward *forward, MmsMsgId msgId)
{
    MmsSignal *sig;
    MmsForward *mmsForward = NULL;
    MMS_LOG_E(("MMSc_forwardReq\n"));
    
    if (forward == NULL)
    {
        MMS_LOG_I(("%s(%d): No action requested.\n", __FILE__, __LINE__));
        return;
    } 

    mmsForward = copyMmsForward(forward);
    
    sig = M_SIGNAL_SENDTO_UP(M_FSM_MSR_SEND, MMS_SIG_MSR_CREATE_FORWARD, 
        msgId, mmsForward);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 

#ifdef MMS_STANDARD_INTERFACE





void MMSc_getConfigInt(MmsConfigInt variable)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getConfigInt(%d)\n", variable));

    sig = M_SIGNAL_SENDTO_U( M_FSM_CORE_CONFIG, MMS_SIG_CORE_GET_CONFIG_INT, 
        variable);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 
#endif 

#ifdef MMS_STANDARD_INTERFACE





void MMSc_getConfigStr(MmsConfigStr variable)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getConfigStr(%d)\n", variable));
    
    sig = M_SIGNAL_SENDTO_U( M_FSM_CORE_CONFIG, MMS_SIG_CORE_GET_CONFIG_STR, 
        variable);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 
#endif 






void MMSc_getMessage(MmsMsgId msgId, MmsMsgType msgType)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getMessage(%lu,%d)\n", msgId, msgType));
        
    switch(msgType)
    {
    case MMS_MSG_HEADER:
        sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_HEADER, 
            msgId);
        if (sig == NULL)
        {
            MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        } 
        break;
    case MMS_MSG_INFO:
        sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_MSG_INFO, 
            msgId);
        if (sig == NULL)
        {
            MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        } 
        break;
    case MMS_MSG_NOTIFICATION:
        sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_HEADER, 
            msgId); 
        if (sig == NULL)
        {
            MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        } 
        break;
    default:
        MMS_LOG_I(("MMSc_getMessage: Illegal message type %d\n", msgType));
        break;
    } 
} 






void MMSc_getBodyPart(MmsMsgId msgId, UINT32 number)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getBodyPart( %lu %lu)\n", msgId, number));
    
    sig = M_SIGNAL_SENDTO_UU( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_BODYPART, 
        msgId, number);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 

#ifdef MMS_EXTERNAL_DRM_ID_GENERATION





void MMSc_getDrmIdResponse( MmsMsgId msgId, UINT32 drmId, UINT32 contFinish)
{
    MmsSignal *sig;
    
    MMS_LOG_E(("MMSc_getDrmIdResponse(%d,%d,%d)\n", 
        (int)msgId, (int)drmId, (int)contFinish));
    
    sig = M_SIGNAL_SENDTO_IUU(M_FSM_MMH_FETCH, MMS_SIG_MMH_SET_ID_INFO,
        contFinish, drmId, msgId);
    
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
    
} 
#endif 







void MMSc_getMessageDate( MmsMsgId msgId)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getMessageDate(%lu)\n", msgId));

    sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_CREATE, MMS_SIG_MMH_GET_DATE, msgId);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_getMessageIdList(MmsFolderType folder, UINT32 startPos, UINT32 maxIds)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getMessageIdList(%d,%lu,%lu)\n", folder, startPos, 
        maxIds));

    sig = M_SIGNAL_SENDTO_IUU(M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_IDS, folder, 
        startPos, maxIds);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_getMessageMetadata(MmsMsgId msgId)
{
    MmsSignal *sig;
     
    MMS_LOG_E(( "MMSc_getMessageMetadata(id=%lu)\n", msgId));

    sig = M_SIGNAL_SENDTO_U(M_FSM_MMH_CREATE, MMS_SIG_MMH_GET_METADATA, msgId);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_getMessageRead(MmsMsgId msgId)
{
    MmsSignal *sig;
     
    MMS_LOG_E(( "MMSc_getMessageRead(id=%lu)\n", msgId));

    sig = M_SIGNAL_SENDTO_U( M_FSM_MMH_CREATE, MMS_SIG_MMH_GET_IS_READ, msgId);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_getNumberOfMessages(MmsFolderType folder)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_getNumberOfMessages(%d)\n", folder));

    sig = M_SIGNAL_SENDTO_I( M_FSM_MMH_FETCH, MMS_SIG_MMH_GET_NUM_OF_IDS, 
        folder);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 






void MMSc_httpRequestData(MmsRequestId requestId)
{
    long instance = -1L;

    MMS_LOG_E(("MMSc_httpRequestData(%d)\n", requestId));

    if ( (instance = cohPostInstance(requestId)) != -1L )
    {
        cohPostMore(instance);
    }
    else
    {
        MMS_LOG_E(("%s(%d): instance not found for request %d\n", 
            __FILE__, __LINE__, requestId));
    } 
} 






void MMSc_httpResponse(MmsRequestId id, const char *headers, void *data, 
    int length, CMN_BOOL moreData, MmsResult errorNo)
{
    long instance = -1L;
    MmsSignal *sig;
    MmsHttpContent *cont = (MmsHttpContent *)M_ALLOC(sizeof(MmsHttpContent));

    
    MMS_LOG_E(("MMSc_httpResponse(%d, %d, %d, %d, %d, %d)\n", 
        id, headers, data, length, moreData, (int)errorNo));

    if (cont == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 

    memset( cont, 0, sizeof(MmsHttpContent)); 
    cont->id = id;
    cont->length = (UINT32)length;
    cont->moreData = moreData;
    cont->errorNo = errorNo;

    if ((UINT32)length > MMS_MAX_CHUNK_SIZE)
    {
        MMS_LOG_I(("%s(%d): Returned data (%d bytes) may overflow "
            "MMS memory pool. Data will be discarded.\n", 
            __FILE__, __LINE__, length));
        MMS_LOG_I(("%s(%d): Data length will be cleared and errorNo set to "
            "MMS_RESULT_COMM_ENTITY_TOO_LARGE.\n", __FILE__, __LINE__));

        


        length = 0;
        cont->length = 0;
        cont->data = NULL;
        cont->errorNo = MMS_RESULT_COMM_ENTITY_TOO_LARGE;
    }