msig.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 "cmntypes.h"   
#include "aapicmn.h"    
#include "gmem.h"       

#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "msig.h"       
#include "mmem.h"       






#define M_SIG_MAX_FREE_LIST_LENGTH   20











static MmsSignal    *m_signal_queue_first;
static MmsSignal    *m_signal_queue_last;



static MmsSignal    *m_signal_free_list;
static int          m_signal_free_list_length;


static MSignalFunction *m_signal_func[M_FSM_MAX_REGS];


#ifdef MMS_LOG_INTERNAL
static void logSignal(const MmsSignal *sig);
static const char *fsmName(MmsStateMachine fsm);
#endif





void mSignalFlush(MmsStateMachine dst, int id, long i_param, 
    unsigned long u_param1, unsigned long u_param2, const void *p_param)
{
    MmsSignal   *sig = m_signal_queue_first;
    MmsSignal   *prev = NULL;
    MmsSignal   *current = NULL;

    while (sig) 
    {
        if (sig->dst == dst && sig->type == id && sig->i_param == i_param &&
            sig->u_param1 == u_param1 && sig->u_param2 == u_param2 &&
            sig->p_param == p_param)
        {
            if (prev != NULL)
            {
                prev->next = sig->next;
            }
            else
            {
                m_signal_queue_first = sig->next;
            } 

            current = sig->next;
            mSignalDelete(sig);
            sig = current;
        }
        else
        {
            sig = sig->next;
        } 

        prev = sig;
    } 
} 




void mSignalInit (void)
{
    int i;
    
    m_signal_queue_first = m_signal_queue_last = NULL;
    m_signal_free_list = NULL;
    m_signal_free_list_length = 0;
    
    for (i = 0; i < M_FSM_MAX_REGS; i++)
    {
        m_signal_func[i] = NULL;
    }
}




void mSignalTerminate (void)
{
    MmsSignal   *sig;
    int           i;
    
    
    while (!mSignalQueueIsEmpty()) 
    {
        sig = m_signal_queue_first;
        m_signal_queue_first = sig->next;
        M_FREE(sig);
    }
    
    
    while (m_signal_free_list != NULL) 
    {
        sig = m_signal_free_list;
        m_signal_free_list = sig->next;
        M_FREE(sig);
    }
    
    
    for (i = 0; i < M_FSM_MAX_REGS; i++)
    {
        m_signal_func[i] = NULL;
    }
}




void mSignalProcess(void)
{
    MmsSignal           *signal;
    MSignalFunction     *func;
    int                  idx;
    
    signal = m_signal_queue_first;
    if (signal != NULL) 
    {
        m_signal_queue_first = signal->next;
        if (m_signal_queue_first == NULL)
        {
            m_signal_queue_last = NULL;
        }
        idx = signal->dst;
        if ((idx >= 0) && (idx < M_FSM_MAX_REGS) &&
            ((func = m_signal_func[idx]) != NULL))
        {
#ifdef MMS_LOG_INTERNAL
            logSignal(signal);
#endif
            func(signal);
        }
        else
        {
            mSignalDelete(signal);
        }
    }
}





int mSignalQueueIsEmpty (void)
{
    return m_signal_queue_first == NULL;
}




void mSignalDelete(MmsSignal *sig)
{
    if (sig == NULL)
    {
        return;
    }
    
    if (m_signal_free_list_length < M_SIG_MAX_FREE_LIST_LENGTH) 
    {
        sig->next = m_signal_free_list;
        m_signal_free_list = sig;
        m_signal_free_list_length++;
    }
    else
    {
        M_FREE(sig);
    }
}





void mSignalRegisterDst(MmsStateMachine dst, MSignalFunction *f)
{
    if (dst < M_FSM_MAX_REGS)
    {
        m_signal_func[dst] = f;
    }
    else
    {
        MMS_LOG_E(("mSignalRegisterDst: FSM dst (%d) out of bounds\n", dst));
    } 
}




void mSignalDeregister(MmsStateMachine dst)
{
    if (dst < M_FSM_MAX_REGS)
    {
        m_signal_func[dst] = NULL;
    }
    else
    {
        MMS_LOG_E(("mSignalDeregister: FSM dst (%d) out of bounds\n", dst));
    } 
}




MmsSignal *mSignalSendTo(MmsStateMachine dst, int signum, long i_param, 
    unsigned long u_param1, unsigned long u_param2, void *p_param)
{
    MmsSignal *signal = NULL;
    
    if (m_signal_free_list == NULL)
    {
        signal = M_ALLOCTYPE(MmsSignal);
    }
    else 
    {
        signal = m_signal_free_list;
        m_signal_free_list = signal->next;
        --m_signal_free_list_length;
    } 
    
    if (signal != NULL)
    {
        signal->type = signum;
        signal->dst = dst;
        signal->i_param = i_param;
        signal->u_param1 = u_param1;
        signal->u_param2 = u_param2;
        signal->p_param = p_param;
    
        signal->next = NULL;
        if (m_signal_queue_last != NULL) 
        {
            m_signal_queue_last->next = signal;
            m_signal_queue_last = signal;
        }
        else 
        {
            m_signal_queue_first = m_signal_queue_last = signal;
        } 
    } 

    return signal;
} 




void mSignalPrepend (MmsSignal *sig)
{
    if (sig == NULL)
    {
        return;
    }
    
    sig->next = m_signal_queue_first;
    if (m_signal_queue_last == NULL)
    {
        m_signal_queue_last = sig;
    }
    m_signal_queue_first = sig;
}

#ifdef MMS_LOG_INTERNAL
#define MMS_SIGNAL_TRACE_PREFIX "MMS Sig: "



static void logSignal(const MmsSignal *sig)
{
    static CMN_BOOL isFirst = TRUE;
    
    if (isFirst)
    {
        MMS_LOG_I(( MMS_SIGNAL_TRACE_PREFIX "%-12s %-6s %-7s %-8s %-8s %9s\n", 
            "FSM", "SIGNAL", "I_PARAM", "U_PARAM1", "U_PARAM2", "P_PARAM"));
        MMS_LOG_I(( MMS_SIGNAL_TRACE_PREFIX "%-12s %-6s %-7s %-8s %-8s %9s\n", 
            "===", "======", "=======", "========", "========", "======="));

        isFirst = FALSE;
    } 

    MMS_LOG_I(( MMS_SIGNAL_TRACE_PREFIX "%-12s %6d %7d %8u %8u %9u\n", 
        fsmName(sig->dst), sig->type,
        (int)sig->i_param, (unsigned int)sig->u_param1,
        (unsigned int)sig->u_param2, (unsigned int)sig->p_param ));
} 




static const char *fsmName(MmsStateMachine fsm)
{
    switch (fsm)
    {
    case M_FSM_MMH_COPY :
        return "MMH Copy";
    case M_FSM_MMH_CREATE :
        return "MMH Create";
    case M_FSM_MMH_FETCH :
        return "MMH Fetch";
    case M_FSM_MMH_IMPORT :
        return "MMH Import";
    case M_FSM_MSR_SEND :
        return "MSR Send";
    case M_FSM_MSR_RECEIVE :
        return "MSR Receive";
    case M_FSM_MSR_NOTIFY :
        return "MSR Notify";
    case M_FSM_COH_GET :
        return "COH Get";
    case M_FSM_COH_PUSH_RECEIVE :
        return "COH PushRcv";
    case M_FSM_COH_POST :
        return "COH Post";
    case M_FSM_CORE_CONFIG :
        return "CORE Config";
    case M_FSM_CORE_MAIN :
        return "CORE Main";
    case M_FSM_CREATE_SMIL :
        return "SMIL Create";
    case M_FSM_SMIL_PARSE_HANDLER:
        return "SMIL Parse";
    case M_FSM_COH_WAP :
        return "COH WAP";
    default :
        return "Unknown";
    } 
} 
#endif