mcget.c

彩信MMS的全部代码

        
        

        permanentError = TRUE;

        res = MMS_RESULT_COMM_ILLEGAL_PDU;
    }
    else if ( !mmsPduSanityCheck( theMsg, size) )
    {
        MMS_LOG_I(("%s(%d): Badly formatted PDU!\n", __FILE__, __LINE__));
        res = MMS_RESULT_COMM_ILLEGAL_PDU;
    }
    else if ( !mmsPduGet( theMsg, size, X_MMS_MESSAGE_TYPE, &read) )
    {
        MMS_LOG_I(("%s(%d): No data X_MMS_MESSAGE_TYPE header tag\n", 
            __FILE__, __LINE__));
        res = MMS_RESULT_COMM_HEADER_TAG;
    }
    else if (read.messageType != MMS_M_RETRIEVE_CONF)
    {
        MMS_LOG_I(("%s(%d): Wrong message type (%d)\n", __FILE__, __LINE__, 
            read.messageType));
        res = MMS_RESULT_COMM_UNEXPECTED_MESSAGE;
    }












    else if ( !mmsPduGet( theMsg, size, MMS_CONTENT_TYPE, &read) )
    {
        MMS_LOG_I(("%s(%d): No data MMS_CONTENT_TYPE header tag\n", 
            __FILE__, __LINE__));
        res = MMS_RESULT_COMM_HEADER_TAG;
    }
    else
    {
        
        if ( mmsPduGet( theMsg, size, X_MMS_RETRIEVE_STATUS, &read) )
        {
            fsm->retrieveStatus = (MmsRetrieveStatus)read.retrieveStatus;
            if (fsm->retrieveStatus != MMS_RTRV_STATUS_OK)
            {
                MMS_LOG_I(("%s(%d): Wrong retrieve status (%d)\n", 
                    __FILE__, __LINE__, fsm->retrieveStatus));
                if (fsm->retrieveStatus >= MMS_RTRV_STATUS_P_FAILURE)
                {
                    permanentError = TRUE;
                } 

                res = translateRetrieveStatus(fsm->retrieveStatus);
            } 
        } 

        
        if ( mmsPduGet( theMsg, size, X_MMS_RETRIEVE_TEXT, &read) )
        {
            fsm->retrieveText = M_ALLOCTYPE(MmsEncodedText);
            remain = (UINT32)(theMsg - (unsigned char *)read.retrieveText) + size;

            parseEncodedStringValue( read.retrieveText, remain, &notUsed, 
                fsm->retrieveText);
        } 

        
        if (res == MMS_RESULT_OK && 
            mmsPduGet( theMsg, size, X_MMS_TRANSACTION_ID, &read))
        {
            isDifferentTransactionId = fsm->notifTransId == NULL || 
                strcmp(fsm->notifTransId, read.transactionId) != 0;

            



            if (isDifferentTransactionId)
            {
                


                fsm->retrieveTransId = M_ALLOC(strlen(read.transactionId) + 1);
                strcpy( fsm->retrieveTransId, read.transactionId);
            } 
        } 
    } 

    M_FREE(theMsg);

    if (res != MMS_RESULT_OK && !permanentError)
    {
        getRetry( instance, res);
    }
    else
    {
        getFinished( instance, res);
    } 
} 







static void getFinished( long instance, MmsResult res)
{
    CohGetInstanceData *fsm;   
    MmsSigCohGetResultParam *param = M_ALLOCTYPE(MmsSigCohGetResultParam);

    M_TIMER_RESET_I( M_FSM_COH_GET, instance); 

    fsm = fsmInstance[instance];
    param->msgId = fsm->msgId;
    param->result = res;
    param->size = fsm->received;
    param->retrieveStatus = fsm->retrieveStatus;
    param->retrieveText = fsm->retrieveText;
    param->retrieveTransId = fsm->retrieveTransId;

    
    M_SIGNAL_SENDTO_IP( fsm->requestingFsm, fsm->returnSig, fsm->fsmInstance,
        param);

    deleteInstance(instance);
} 







static long getInstance(long instance)
{
    if (instance < 0L || instance >= MMS_MAX_FSM_GET_INSTANCES ||
        fsmInstance[instance] == NULL)
    {
        MMS_LOG_I(("GET getInstance: instance out of bounds (%ld)\n", instance));
        instance = -1L;
    } 

    return instance;
} 






static void getMsg(long instance)
{
    CohGetInstanceData *fsm;   

    fsm = fsmInstance[instance];

    M_TIMER_RESET_I( M_FSM_COH_GET, instance); 
    M_TIMER_SET_I( M_FSM_COH_GET, MMS_GET_TIMEOUT, instance);

#ifdef MMS_LOG_PROTOCOL
    {
        char str[320];

        
        if (sprintf( str, "GET %s", fsm->uri) > (int)sizeof(str))
        {
            MMS_LOG_I(("%s(%d): Wrote outside allocated memory!\n",
                __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        } 

        mmsWapLog( FALSE, (int)strlen(str), str);
    }
#endif 

    MMSa_http( fsm->requestId, MMS_HTTP_GET, fsm->uri, myHttpHeader,
        NULL, 0, 0, FALSE);
} 







static long getMsgInit(const MmsSignal *sig)
{
    long instance = -1L;
    CohGetInstanceData *fsm;   
    MmsSigCohGetParam   *param = (MmsSigCohGetParam *)sig->p_param;

    instance = selectInstance();

    
    if (instance == -1L)
    {
        MMS_LOG_I(("%s(%d): We're BUSY! Return!\n", __FILE__, __LINE__));

        
        M_SIGNAL_SENDTO_IU( sig->u_param1, sig->u_param2,  sig->i_param, 
            MMS_RESULT_BUSY); 

        return -1L;
    }
    else if (instance < 0L || instance >= MMS_MAX_FSM_GET_INSTANCES ||
        fsmInstance[instance] == NULL)
    {
        MMS_LOG_I(("%s(%d): instance out of bounds (%ld)\n", 
            __FILE__, __LINE__, instance));

        
         M_SIGNAL_SENDTO_IU(sig->u_param1, sig->u_param2, 
            sig->i_param, MMS_RESULT_ERROR); 

        return -1L;
    }
    else if (param == NULL || param->msgId == 0 || param->uri == NULL)
    {
        MMS_LOG_I(("%s(%d): Illegal indata: Parameters are not given correct!\n",
            __FILE__, __LINE__));

        
        M_SIGNAL_SENDTO_IU(sig->u_param1, sig->u_param2, 
            sig->i_param, MMS_RESULT_ERROR); 

        return -1L;
    } 

    
    fsm = fsmInstance[instance];
    fsm->requestingFsm = (MmsStateMachine)sig->u_param1;
    fsm->returnSig = (MmsSignalId)sig->u_param2;
    fsm->fsmInstance = sig->i_param;
    fsm->notifTransId = param->transactionId;
    fsm->retrieveTransId = NULL;

    fsm->expected = param->size;
    fsm->received = 0;
    fsm->retries = 0;
    fsm->msgId = param->msgId;
    fsm->retrieveStatus = MMS_RTRV_STATUS_NONE;
    fsm->retrieveText = NULL;

    
    fsm->uri = param->uri;
    M_FREE(param);  

    
    fsm->requestId = mmsWapGetRequestId();
    if (fsm->requestId == -1)
    {
        MMS_LOG_I(("%s(%d): No available request IDs! Terminating!\n",
            __FILE__, __LINE__));

        
        M_SIGNAL_SENDTO_IU(sig->u_param1, sig->u_param2, 
            sig->i_param, MMS_RESULT_BUSY); 

        deleteInstance(instance);
        return -1L;
    } 

    return instance;
} 







static void getRetry(long instance, MmsResult res)
{
    CohGetInstanceData *fsm;   

    fsm = fsmInstance[instance];
    if (++fsm->retries < cfgGetInt(MMS_CFG_GET_RETRY))
    {
        MMS_LOG_I(("******* GET Retry ******* %s %s %lu\n",
            fsm->uri == NULL ? "NULL" : fsm->uri, 
            fsm->notifTransId == NULL ? "NULL" : fsm->notifTransId, 
            fsm->msgId));

        
        mmsWapCancelHttpOperation(fsm->requestId);

        
        fsm->received = 0;

        if (fsm->retrieveText != NULL)
        {
            if (fsm->retrieveText->text != NULL)
            {
                M_FREE(fsm->retrieveText->text);
            } 

            M_FREE(fsm->retrieveText);
            fsm->retrieveText = NULL;
        } 

        if (fsm->retrieveTransId)
        {
            M_FREE(fsm->retrieveTransId);
            fsm->retrieveTransId = NULL;
        } 

        
        mmsWapFreeContentParams(fsm->cont);
        fsm->cont = NULL;

        fsm->requestId = mmsWapRenewRequestId(fsm->requestId);
        getMsg(instance);               
    }
    else
    {   
        getFinished( instance, res);
    } 
} 







static void handleResponse(long instance, const MmsSignal *sig)
{
    MmsResult res = MMS_RESULT_OK;
    FmResult fmRes = FM_RESULT_ERROR;
    CohGetInstanceData *fsm;   
    CMN_BOOL moreData = FALSE;
    CMN_BOOL fatalError = FALSE;
    MmsClientStatusData data;

    fsm = fsmInstance[instance];
    fsm->cont = (MmsHttpContent *)sig->p_param;
    if (fsm->cont == NULL)
    {
        MMS_LOG_I(("GET handleResponse: No data returned (%ld)\n", instance));
        res = MMS_RESULT_COMM_FAILED;
    }
    else if (fsm->cont->id != fsm->requestId)
    {
        MMS_LOG_I(("GET handleResponse: Wrong request ID %d != %d\n", 
            fsm->cont->id, fsm->requestId));
        res = MMS_RESULT_COMM_FAILED;
    }
    else if (fsm->cont->errorNo != MMS_RESULT_OK)
    {
        MMS_LOG_I(("GET handleResponse: Wrong server response %d\n", 
            fsm->cont->errorNo));
        res = fsm->cont->errorNo;
    }
    else if (fsm->cont->data == NULL)
    {
        MMS_LOG_I(("GET handleResponse: No data returned, moreData=%d, error=%d\n", 
            (int)fsm->cont->moreData, (int)fsm->cont->errorNo));
        moreData = fsm->cont->moreData;
        res = fsm->cont->errorNo;
    } 

#ifdef MMS_LOG_PROTOCOL
    if (fsm->cont->data == NULL)
    {
        char str[256];

        
        if (sprintf( str, "GET Response: No data, MMS_RESULT=%d", 
            fsm->cont->errorNo) > (int)sizeof(str))
        {
            MMS_LOG_I(("%s(%d): Wrote outside allocated memory!\n",
                __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return;
        } 

        mmsWapLog( TRUE, (int)strlen(str), str);
    }
    else if (fsm->received == 0)
    {
        
        mmsWapLog( TRUE, (int)fsm->cont->length, fsm->cont->data);
    } 
#endif 

    


    if (res == MMS_RESULT_OK && fsm->cont != NULL && fsm->cont->data != NULL)
    {
        if (cfgGetInt(MMS_CFG_MAX_DOWNLOAD_SIZE) > 0 && 
            fsm->received + fsm->cont->length > 
            (UINT32)cfgGetInt(MMS_CFG_MAX_DOWNLOAD_SIZE))
        {
            res = MMS_RESULT_MAX_DOWNLOAD_SIZE_EXCEEDED;
            fatalError = TRUE;
        }
        else
        {
            fmRes = fldrmgrSetMessage( CMN_CLIENT_MMS, fsm->msgId, 
                (unsigned char *)fsm->cont->data, fsm->cont->length, fsm->received);
            res = checkFolderError(fmRes);
            if (res != MMS_RESULT_OK)
            {
                fatalError = TRUE;
            } 
        
            fsm->received += fsm->cont->length;
            moreData = fsm->cont->moreData;

            

            if (fsm->expected > 0)
            {
                data.percentage = (int)(fsm->received * 100 / fsm->expected);
                MMSa_status( MMS_CLIENT_STATUS_RETRIEVING, fsm->msgId, data);
            } 
        } 
    } 

    
    mmsWapFreeContentParams(fsm->cont);
    fsm->cont = NULL;

    if (res == MMS_RESULT_CANCELLED_BY_USER || 
        res == MMS_RESULT_COMM_NETWORK_UNAVAILABLE || fatalError)
    {   


        getFinished( instance, res);
    }
    else if (res != MMS_RESULT_OK)
    {
        getRetry( instance, res);
    }
    else if (moreData)
    {
        M_TIMER_RESET_I( M_FSM_COH_GET, instance); 
        M_TIMER_SET_I( M_FSM_COH_GET, MMS_GET_TIMEOUT, instance);

        MMSa_httpResponseAck(fsm->requestId);
    }
    else
    {
        finalizeData(instance); 
    } 
} 







static long selectInstance(void)
{
    long i;
    
    for (i = 0L; i < MMS_MAX_FSM_GET_INSTANCES; i++) 
    {
        if (fsmInstance[i] == NULL)
        {
            
            fsmInstance[i] = (CohGetInstanceData *)M_CALLOC(sizeof(CohGetInstanceData));

            fsmInstance[i]->requestingFsm = M_FSM_MAX_REGS;
            fsmInstance[i]->returnSig = MMS_SIG_COMMON_BASE;
            
            return i;
        } 
    } 

    return -1L;
}