capimms.c

彩信MMS的全部代码

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






void MMSc_setMessageRead( MmsMsgId msgId, CMN_BOOL isRead)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_setMessageRead(%lu, %d)\n", msgId, isRead));

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






void MMSc_start(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("MMSc_start(void)\n"));
    MMS_LOG_E(("Starting the Teleca MMS Client version %s\n", MMS_VERSION));
    
    
#if defined USE_G_MALLOC
    if (gMemInit( CMN_CLIENT_MMS, mmsMemory, (unsigned)MMS_MALLOC_MEM_SIZE) != 0)
    {
        MMS_LOG_E(("gMemInit failed.\n"));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
    } 
#endif 
    
    
    mSignalInit();
    mTimerInit();

    
    coreMainInit();

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






void MMSc_terminate(MmsShutdown condition)
{
    MmsSignal *sig;

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

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






void MMSc_timerExpired(void)
{
    MMS_LOG_E(("MMSc_timerExpired(void)\n"));

    mTimerExpired();
} 






CMN_BOOL MMSc_wantsToRun(void)
{
    return !mSignalQueueIsEmpty();
} 







void SMILc_cancelParserHandler(void)
{
    MmsSignal *sig;
    
    MMS_LOG_E(("SMILc_cancelParseHandler(void)\n"));

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







void SMILc_createCancel(void)
{
    MmsSignal *sig;

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

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






void SMILc_createEnd(void)
{
    MmsSignal *sig;

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

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






























void SMILc_createHead(const SmilHead *head)
{
    SmilHead *pData;
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_createHead(%d)\n", head));

    
    pData = sluCopyHead(head);
    if (pData == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
    
    
    sig = M_SIGNAL_SENDTO_P(M_FSM_CREATE_SMIL, SLC_SIG_CREATE_HEAD, pData);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 


















void SMILc_createPar(const SmilPar *par)
{
    SmilPar *pData;
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_createPar(%d)\n", par));

    
    pData = sluCopyPar(par);
    if (pData == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
    
    
    sig = M_SIGNAL_SENDTO_P(M_FSM_CREATE_SMIL, SLC_SIG_CREATE_PAR, pData);
    if (sig == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 
} 











void SMILc_parsedHeadResponse(void)
{
    MmsSignal *sig;

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

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










void SMILc_parsedParResponse(void)
{
    MmsSignal *sig;

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

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











void SMILc_parserAcknowledgeData(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_parserAcknowledgeData()\n"));

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


















void SMILc_parserCharacterData(const char *charData, int len, int mode) 
{
    SlphCharacterData *ptr;
    MmsSignal *sig;


    MMS_LOG_E(("SMILc_parserCharacterData(%d %d %d)\n", charData, len, mode));

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

    ptr->len = len;
    ptr->mode = mode;

    if (charData)
    {

        ptr->charData = M_ALLOC(sizeof(char) * ((UINT32)len + 1));
        memcpy(ptr->charData, charData, (UINT32)len);
    }
    else
    {
       ptr->charData = NULL;
    }

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















void SMILc_parserDone(SmilResult result)
{
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_parserDone(%d)\n", result));

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













void SMILc_parserEndElement(void)
{
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_parserEndElement()\n"));

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

















void SMILc_parserHandler(SmilMsg *msg)
{
    SmilMsg *newMsg;
    unsigned char *buffer;
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_parserHandler(%d)\n", msg));

    if (! msg)
    {
        MMS_LOG_I(("SMILc_parserHandler: NULL param received.\n"));
        SMILa_parserHandlerResponse(SMIL_RESULT_MISSING_DATA);
        return;
    }
   
    newMsg = (SmilMsg *)M_ALLOC(sizeof(SmilMsg));
    if (newMsg == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 

    memset( newMsg, 0, sizeof(SmilMsg)); 
    if (SMIL_MSG_STORED_IN_BUFFER == msg->storageType)
    {
        if (msg->dataSize == 0)
        {
            M_FREE(newMsg);
            SMILa_parserHandlerResponse(SMIL_RESULT_BUFFER_SIZE_ZERO);
            return;
        }   
        else
        {
            buffer = M_ALLOC(msg->dataSize + 1);
            if (buffer == NULL)
            {
                MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
                MMSa_error(MMS_RESULT_RESTART_NEEDED);
                return;
            } 
            newMsg->data.buffer = buffer;

            memcpy(newMsg->data.buffer, msg->data.buffer, msg->dataSize);

            
            newMsg->data.buffer[msg->dataSize] = '\0';
        }
    }
    else 
    {
        newMsg->data.file.id =  msg->data.file.id;
        newMsg->data.file.category = msg->data.file.category;
    }

    newMsg->storageType = msg->storageType;
    newMsg->dataSize = msg->dataSize; 

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

















void SMILc_parserStartElement(int elementType, SlphAttribute *attrs,
    int numAttrs)
{
    SlphStartElem *pNewStartElem;
    SlphAttribute *pNewAttrs;
    char *pTmpCh;
    UINT32 strLen;
    int i;
    MmsSignal *sig;

    MMS_LOG_E(("SMILc_parserStartElement(%d, %d, %d)\n", elementType, attrs, numAttrs));
    pNewStartElem = M_ALLOC(sizeof(SlphStartElem));
    if (pNewStartElem == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 

    pNewStartElem->element = elementType;
    if (attrs && numAttrs > 0)   
    {
        pNewStartElem->numAttrs = numAttrs;

        pNewAttrs = (SlphAttribute*)M_ALLOC(sizeof(SlphAttribute) * (UINT32)numAttrs);
        if (pNewAttrs == NULL)
        {
            MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        } 

        memset( pNewAttrs, 0, sizeof(SlphAttribute) * (UINT32)numAttrs); 
        pNewStartElem->attrs = pNewAttrs;
        for (i = 0; i < numAttrs; ++i)
        {
            pNewAttrs[i].valueType = attrs[i].valueType;
            pNewAttrs[i].name = attrs[i].name;

            if (SLPH_STRING == attrs[i].valueType)
            {
                
                strLen = strlen(attrs[i].value.data) + 1;
                pTmpCh = M_ALLOC(strLen);

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

                strcpy(pTmpCh, attrs[i].value.data);
                pNewAttrs[i].value.data = pTmpCh;
            }
            else
            {
                
                pNewAttrs[i].value.i = attrs[i].value.i;
            }
        }
    }
    else
    {
        
        pNewStartElem->numAttrs = 0;

        pNewStartElem->attrs = NULL;
    }

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