mcpost.c

彩信MMS的全部代码

        if ((instance = getInstance(sig)) != -1)
        {
            postMore(instance);
        } 
        break;
    case MMS_SIG_COH_POST_RSP : 
        MMS_LOG_I(("MMS FSM COH POST: Received MMS_SIG_COH_POST_RSP\n"));

        if ((instance = getInstance(sig)) != -1)
        {
            handleResponse( instance, sig);
        } 
        break;
    case MMS_SIG_COMMON_TIMER_EXPIRED :
        MMS_LOG_I(("MMS FSM COH POST: Received TIMER_EXPIRED\n"));

        if ((instance = getInstance(sig)) != -1)
        {
            postRetry( instance, MMS_RESULT_COMM_TIMEOUT);
        } 
        break;
    default:
        
        MMS_LOG_I(("MMS FSM COH POST: received unknown signal %d\n", sig->type));
        break;
    } 
    
    mSignalDelete(sig);
} 






void cohPostMore(long instance)
{
    M_SIGNAL_SENDTO_I( M_FSM_COH_POST, MMS_SIG_COH_POST_MORE, instance);
} 




void cohPostSetHttpHeader(void)
{
    unsigned size;
    char *userAgent = cfgGetStr(MMS_CFG_CLIENT_USER_AGENT);
    char *extraHeader = cfgGetStr(MMS_CFG_CLIENT_HTTP_HEADER);

    if (myHttpHeader != NULL)
    {
        M_FREE(myHttpHeader);
        myHttpHeader = NULL;
    } 

    size = sizeof(MMS_POST_HTTP_HEADER);
    if (userAgent != NULL && strlen(userAgent) > 0)
    {
        size += sizeof(MMS_USER_AGENT) + strlen(userAgent) + sizeof(MMS_NEWLINE);
    } 

    if (extraHeader != NULL && strlen(extraHeader) > 0)
    {
        size += strlen(extraHeader) + sizeof(MMS_NEWLINE);
    } 

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

    memset( myHttpHeader, 0, size); 
    if (userAgent != NULL && strlen(userAgent) > 0)
    {
        if (strlen(myHttpHeader) > 0)
        {
            strcat( myHttpHeader, "\n");
        } 

        strcat( myHttpHeader, MMS_USER_AGENT);
        strcat( myHttpHeader, userAgent);
    } 

    if (extraHeader != NULL && strlen(extraHeader) > 0)
    {
        if (strlen(myHttpHeader) > 0)
        {
            strcat( myHttpHeader, "\n");
        } 

        strcat( myHttpHeader, extraHeader);
    } 

    
    if (strlen(MMS_POST_HTTP_HEADER) > 0)
    {
        if (strlen(myHttpHeader) > 0)
        {
            strcat( myHttpHeader, "\n");
        } 

        strcat( myHttpHeader, MMS_POST_HTTP_HEADER);
    } 
} 





void cohPostTerminate(void)
{
    long i;

    
    for (i = 0L; i < MMS_MAX_FSM_POST_INSTANCES; ++i)
    {
        if (fsmInstance[i] != NULL)
        {
            MMS_LOG_I(("******* POST FSM active at terminate ******* %s %s %s%lu\n",
                fsmInstance[i]->uri == NULL ? 
                    "NULL" : fsmInstance[i]->uri, 
                fsmInstance[i]->transactionId == NULL ?
                    "NULL" : fsmInstance[i]->transactionId, 
                fsmInstance[i]->param.type == MMS_M_SEND_REQ ? 
                    "msgId=" : "pdu type=",
                fsmInstance[i]->param.type == MMS_M_SEND_REQ ? 
                    fsmInstance[i]->param.data.msgId : 
                    (UINT32)fsmInstance[i]->param.data.pdu.packet[1]));

            deleteInstance(i);
        } 
    } 

    if (myHttpHeader != NULL)
    {
        M_FREE(myHttpHeader);
        myHttpHeader = NULL;
    } 

    mSignalDeregister(M_FSM_COH_POST);
    
    MMS_LOG_I(("MMS FSM COH POST: terminated\n"));
} 







static void deleteInstance(long instance)
{
    CohPostInstanceData *fsm;   

    if (instance < 0 || instance >= MMS_MAX_FSM_POST_INSTANCES)
    {
        MMS_LOG_I(("%s(%d) Trying to delete wrong instance %ld\n", 
            __FILE__, __LINE__, instance));
        return;
    } 

    fsm = fsmInstance[instance];

    if (fsm == NULL)
    {
        MMS_LOG_I(("%s(%d) Trying to delete a NULL instance %ld\n", 
            __FILE__, __LINE__, instance));
        return;
    } 

    MMS_LOG_I(("====> POST deleting instance %ld, requesting FSM %d, returnSig %d\n", 
        instance, fsm->requestingFsm, fsm->returnSig, fsm->retries));
    MMS_LOG_I(("      retries %d, transactionId <%s>, requestId %d\n", 
        fsm->retries, fsm->transactionId == NULL ? "NULL" : fsm->transactionId, 
        fsm->requestId));

    M_TIMER_RESET_I( M_FSM_COH_POST, instance); 

    
    mmsWapCancelHttpOperation(fsm->requestId);

    
    mmsWapFreeRequestId(fsm->requestId);

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

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

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

    switch (fsm->param.type)
    {
    case MMS_M_SEND_REQ :
        break;
    case MMS_M_NOTIFY_RESP :
    case MMS_M_RETRIEVE_CONF :
    case MMS_M_ACKNOWLEDGE_IND :
    case MMS_M_READ_REC_IND :
    case MMS_M_FORWARD_REQ :
        M_FREE(fsm->param.data.pdu.packet);
        break;
    default :
        MMS_LOG_I(("POST: Illegal type (%d)!\n", fsm->param.type));
        break;
    } 

    M_FREE(fsmInstance[instance]);
    fsmInstance[instance] = NULL;

    
    M_SIGNAL_SENDTO_IUU( M_FSM_COH_WAP, MMS_SIG_COH_WAP_STOP, 0, 
        M_FSM_COH_POST, MMS_SIG_COH_POST_DISCONNECTED);
} 







static long getInstance(const MmsSignal *sig)
{
    long instance = sig->i_param;

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

    return instance;
} 








static char *getTransactionId( char *header, unsigned long length)
{
    MmsHeaderValue read;
    char *tid = NULL;
    unsigned long maxLen = 0L;
    unsigned long strSize = 0L;

    if ( mmsPduGet( header, length, X_MMS_TRANSACTION_ID, &read) && 
        read.transactionId != NULL)
    {
        maxLen = (unsigned long)header - (unsigned long)read.transactionId + 
            length;

        if (maxLen > 0)
        {
            strSize = strlen(read.transactionId) + 1;
            tid = M_ALLOC(strSize);
            strncpy( tid, read.transactionId, strSize - 1);
            tid[strSize - 1] = EOS;
        } 
    }
    else
    {
        tid = M_ALLOC(LEN_TRANSACTION_ID);
        if (sprintf( tid, "%ld", mmsWapGetUniqueId()) > LEN_TRANSACTION_ID)
        {
            MMS_LOG_I(("%s(%d): Wrote outside allocated memory!\n",
                __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
        } 
    } 

    return tid;
} 







static void handleResponse(long instance, const MmsSignal *sig)
{
    MmsResult           res = MMS_RESULT_OK;
    MmsHttpContent      *p; 
    CMN_BOOL            permanentError = FALSE;
    CohPostInstanceData *fsm;   

    fsm = fsmInstance[instance];

    
    p = fsm->cont = (MmsHttpContent *)sig->p_param;

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

        
        if (sprintf( str, "POST 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
    {
        
        mmsWapLog( TRUE, (int)fsm->cont->length, fsm->cont->data);
    } 
#endif 

    if (p == NULL)
    {
        MMS_LOG_I(("POST handleResponse: No data returned (%ld)\n", instance));
        res = MMS_RESULT_COMM_FAILED;
    }
    else if (p->id != fsm->requestId)
    {
        MMS_LOG_I(("POST handleResponse: Wrong request ID %d != %d\n", 
            p->id, fsm->requestId));
        res = MMS_RESULT_COMM_FAILED;
    }
    else if (p->errorNo != MMS_RESULT_OK)
    {
        MMS_LOG_I(("POST handleResponse: Error returned from stack, error (%d)\n", 
            p->errorNo));
        res = p->errorNo; 
    }
    else if (p->moreData)   
    {
        MMS_LOG_I(("POST handleResponse: Segmented data (%ld)\n", instance));
        M_TIMER_RESET_I( M_FSM_COH_POST, instance); 
        M_TIMER_SET_I( M_FSM_COH_POST, MMS_POST_TIMEOUT, instance);

        (void)packetReassemble( fsm, p->moreData);

        MMSa_httpResponseAck(fsm->requestId);   
        return;
    }
    else if (packetReassemble( fsm, p->moreData) == FALSE)
    {
        MMS_LOG_I(("POST handleResponse: Packet reassemble failed.\n", 
            res, fsm->requestId));
        res = MMS_RESULT_COMM_FAILED;
    }
    else if ( (res = checkResponseGeneral( fsm, p->data, p->length, 
        &permanentError)) != MMS_RESULT_OK)
    {
        MMS_LOG_I(("POST handleResponse: General failure res=%d, request ID=%d\n", 
            res, fsm->requestId));
    }
    else 
    {   
        switch (fsm->param.type)
        {
        case MMS_M_SEND_REQ :
            res = checkResponsePdu( fsm, p->data, p->length, &permanentError,
                MMS_M_SEND_CONF);
            break;
        case MMS_M_FORWARD_REQ :
            res = checkResponsePdu( fsm, p->data, p->length, &permanentError,
                MMS_M_FORWARD_CONF);
            break;
        case MMS_M_NOTIFY_RESP :
        case MMS_M_ACKNOWLEDGE_IND :
        case MMS_M_READ_REC_IND :
            
            break;
        default :
            MMS_LOG_I(("POST: Can't be here. Already tested (%d)!\n", fsm->param.type));
            return;
        } 
    }  

    if (res == MMS_RESULT_OK || res == MMS_RESULT_CANCELLED_BY_USER || 
        res == MMS_RESULT_COMM_NETWORK_UNAVAILABLE || permanentError )
    {
        postFinished(instance, res);
    }
    else
    {
        postRetry(instance, res);
    } 
} 












static CMN_BOOL packetReassemble(CohPostInstanceData *fsm, CMN_BOOL moreData)
{
    char *sumBuf;

    
    if (moreData) 
    {
        if (fsm->cont == NULL || fsm->cont->length == 0)
        {
            
        }
        else if (fsm->sarBuffer == NULL) 
        {
            fsm->sarBuffer = fsm->cont;
            fsm->cont = NULL;
        }
        else  
        {
            
            sumBuf = M_CALLOC( fsm->sarBuffer->length + fsm->cont->length);
            memcpy( sumBuf, fsm->sarBuffer->data, fsm->sarBuffer->length);
            memcpy( sumBuf + fsm->sarBuffer->length, fsm->cont->data,
                fsm->cont->length);
            M_FREE( fsm->sarBuffer->data);

            fsm->sarBuffer->data = sumBuf;
            fsm->sarBuffer->length += fsm->cont->length;

            mmsWapFreeContentParams(fsm->cont);
            fsm->cont = NULL;
        } 
    }
    else 
    {
        if (fsm->sarBuffer == NULL)
        {
            
        }
        else if (fsm->cont == NULL || fsm->cont->length == 0)
        {   
            mmsWapFreeContentParams(fsm->cont);
            fsm->cont = fsm->sarBuffer;
            fsm->sarBuffer = NULL;
        }
        else 
        {
            
            sumBuf = M_CALLOC( fsm->sarBuffer->length + fsm->cont->length);
            memcpy( sumBuf, fsm->sarBuffer->data, fsm->sarBuffer->length);
            memcpy( sumBuf + fsm->sarBuffer->length, fsm->cont->data,
                fsm->cont->length);
            M_FREE( fsm->sarBuffer->data);

            fsm->sarBuffer->data = sumBuf;
            fsm->sarBuffer->length += fsm->cont->length;

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

    return TRUE;
} 







static void postMsgAbort(long instance, MmsResult ret)
{
    (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, 
        fsmInstance[instance]->param.data.msgId);

    postFinished( instance, ret);
} 







static void postFinished( long instance, MmsResult res)
{
    MmsSigCohPostResultParam *param;
    CohPostInstanceData *fsm;   

    fsm = fsmInstance[instance];

    M_TIMER_RESET_I( M_FSM_COH_POST, instance); 

    if (fsm->param.isResponseRequested)
    {
        param = M_ALLOCTYPE(MmsSigCohPostResultParam);
        param->result = res;
        param->responseStatus = fsm->responseStatus;
        param->responseText = fsm->responseText;

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

    deleteInstance(instance);
} 






static void postIt(long instance)
{
    switch (fsmInstance[instance]->param.type)
    {