mcpost.c

彩信MMS的全部代码

    case MMS_M_SEND_REQ :
        postMsg(instance);
        break;
    case MMS_M_NOTIFY_RESP :
    case MMS_M_ACKNOWLEDGE_IND :
    case MMS_M_READ_REC_IND :
    case MMS_M_FORWARD_REQ :
        postPdu(instance);
        break;
    default :
        MMS_LOG_I(("POST: Illegal type (%d)!\n", fsmInstance[instance]->param.type));

        postFinished( instance, MMS_RESULT_ERROR);
        return;
    } 
} 







static void postMore(long instance)
{
    UINT32 startPos = 0;
    UINT32 bytesToSend = 0;
    UINT32 bytesRead = 0;
    unsigned char *theMsg = NULL;
    FmResult res;
    MmsClientStatusData data;
    CohPostInstanceData *fsm;   

    fsm = fsmInstance[instance];
    res = fldrmgrOpenMessage( CMN_CLIENT_MMS, fsm->param.data.msgId, FM_READ);

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

    M_TIMER_RESET_I( M_FSM_COH_POST, instance); 

    


    
    if (fsm->msgSize - fsm->sent > MMS_POST_MAX_SIZE)
    {   
        bytesToSend = MMS_POST_MAX_SIZE;
    }
    else
    {   
        bytesToSend = fsm->msgSize - fsm->sent;
    } 

    MMS_LOG_I(("Send next %lu bytes of file, starting at %lu, entire size %lu\n",
        bytesToSend, fsm->sent, fsm->msgSize));

    if (bytesToSend == 0)
    {
        MMS_LOG_I(("%s(%d): No data but still requested to send!\n", 
            __FILE__, __LINE__));

        MMSa_httpRequestDataResponse( fsm->requestId,  NULL, 0, FALSE);
        postMsgAbort( instance, MMS_RESULT_MESSAGE_EMPTY);
        return;
    } 

    theMsg = M_ALLOC(bytesToSend);
    startPos = fsm->sent;
    res = fldrmgrGetMessage( CMN_CLIENT_MMS, fsm->param.data.msgId, startPos, 
        bytesToSend, &bytesRead, theMsg);
    if (res != FM_RESULT_OK)
    {
        MMS_LOG_I(("%s(%d): Error reading msg (%d)!\n", __FILE__, __LINE__, res));

        postMsgAbort( instance, MMS_RESULT_MESSAGE_EMPTY);
        MMSa_httpRequestDataResponse( fsm->requestId,  NULL, 0, FALSE);
        M_FREE(theMsg);
        return;
    }
    else if (bytesRead != bytesToSend)
    {
        MMS_LOG_I(("POST: Couldn't read entire msg (%d, %d)!\n",
            bytesRead, bytesToSend));

        postMsgAbort( instance, MMS_RESULT_MESSAGE_EMPTY);
        MMSa_httpRequestDataResponse( fsm->requestId,  NULL, 0, FALSE);
        M_FREE(theMsg);
        return;
    } 

    fsm->sent += bytesToSend;

    M_TIMER_SET_I( M_FSM_COH_POST, MMS_POST_TIMEOUT, instance);
    MMSa_httpRequestDataResponse( fsm->requestId,  (char *)theMsg, 
        (int)bytesToSend,           
        fsm->sent != fsm->msgSize); 

    M_FREE(theMsg); 

    (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, fsm->param.data.msgId);

    
    data.percentage = (int)(fsm->sent * 100 / fsm->msgSize);
    MMSa_status( MMS_CLIENT_STATUS_SENDING, fsm->param.data.msgId, data);
} 






static void postMsg(long instance)
{
    UINT32 startPos = 0;
    UINT32 bytesToSend = 0;
    UINT32 bytesRead;
    unsigned char *theMsg = NULL;
    FmResult res;
    MmsClientStatusData data;
    CohPostInstanceData *fsm;   

    fsm = fsmInstance[instance];
    M_TIMER_RESET_I( M_FSM_COH_POST, instance); 

    
    res = fldrmgrOpenMessage( CMN_CLIENT_MMS, fsm->param.data.msgId, FM_READ);

    if (res == FM_RESULT_OK)
    {
        res = fldrmgrGetMessageSize( CMN_CLIENT_MMS, fsm->param.data.msgId, 
            (UINT32*)&fsm->msgSize);
    } 

    if (res != FM_RESULT_OK)
    {
        MMS_LOG_I(("Couldn't get size of msg. Error (%d)! Terminating!\n", res));

        postMsgAbort( instance, checkFolderError(res));
        return;
    }
    else if (fsm->msgSize == 0)
    {
        MMS_LOG_I(("Send empty message, size %lu\n", fsm->msgSize));

        postMsgAbort( instance, MMS_RESULT_MESSAGE_EMPTY);
        return;
    }
    else if (fsm->msgSize > MMS_POST_MAX_SIZE)
    {   
        bytesToSend = MMS_POST_MAX_SIZE;
    }
    else
    {   
        bytesToSend = fsm->msgSize;
    } 

    MMS_LOG_I(("Preparing to send first %lu bytes of %lu bytes large message\n",
        bytesToSend, fsm->msgSize));

    theMsg = (unsigned char *)M_CALLOC( (unsigned)bytesToSend);
    res = fldrmgrGetMessage( CMN_CLIENT_MMS, fsm->param.data.msgId, startPos, 
        bytesToSend, &bytesRead, theMsg);
    if (res != FM_RESULT_OK)
    {
        MMS_LOG_I(("POST: Couldn't read msg (%d)!\n", res));
        M_FREE(theMsg);
        postMsgAbort( instance, checkFolderError(res));
        return;
    }
    else if (bytesRead != bytesToSend)
    {
        MMS_LOG_I(("POST: Couldn't read entire msg (%lu, %lu)!\n",
            bytesRead, bytesToSend));
        M_FREE(theMsg);
        postMsgAbort( instance, MMS_RESULT_FILE_READ_ERROR);
        return;
    }
    else
    {
        fsm->sent = bytesToSend;
    } 

    









    fsm->transactionId = getTransactionId( (char *)theMsg, fsm->sent);

    
    if (fsm->param.origMsg != 0)
    {
       MmsHeaderValue read;
       
        
       if ( !mmsPduGet((char *)theMsg, fsm->sent, X_MMS_READ_REPLY, &read) && 
           read.readReply == MMS_READ_REPLY_NO)
       {
            
           if (!mmsPduGet((char *)theMsg, fsm->sent, X_MMS_DELIVERY_REPORT, &read) &&
               read.deliveryReport == MMS_DELIVERY_REPORT_NO)
           {
               fsm->param.origMsg = 0; 
           }  
       }  
    }  

#ifdef MMS_LOG_PROTOCOL
    mmsWapLog( FALSE, (int)fsm->sent, (char *)theMsg);
#endif 

    M_TIMER_SET_I( M_FSM_COH_POST, MMS_POST_TIMEOUT, instance);

    MMS_LOG_I(("====> POST Msg, transactionId <%s>, requestId %d\n", 
        fsm->transactionId == NULL ? "NULL" : fsm->transactionId, fsm->requestId));
    MMSa_http( fsm->requestId, MMS_HTTP_POST, fsm->uri, myHttpHeader, 
        (char *)theMsg, fsm->sent,  
        fsm->msgSize,               
        fsm->sent != fsm->msgSize); 

    M_FREE(theMsg); 

    (void)fldrmgrCloseMessage( CMN_CLIENT_MMS, fsm->param.data.msgId);

    
    data.percentage = (int)(fsm->sent * 100 / fsm->msgSize);
    MMSa_status( MMS_CLIENT_STATUS_SENDING, fsm->param.data.msgId, data);
} 







static long postMsgInit(MmsSignal *sig)
{
    long instance = -1L;
    UINT32 port = MMS_INVALID_CFG_VARIABLE;
    unsigned len = 0;
    char *server = NULL;
    char *uri = NULL;
    char *scheme = NULL;
    MmsResult result = MMS_RESULT_OK;
    CohPostInstanceData *fsm;   
    MmsSigCohPostParam *param;
    MmsSigCohPostResultParam *resultParam;

    param = (MmsSigCohPostParam *)sig->p_param;

    
    instance = selectInstance();
    server = cfgGetStr(MMS_CFG_PROXY_RELAY);
    port = cfgGetInt(MMS_CFG_PORT);
    uri = cfgGetStr(MMS_CFG_POST_URI);
    scheme = cfgGetStr(MMS_CFG_SCHEME);

    
    if (instance == -1L)
    {
        MMS_LOG_I(("%s(%d): We're BUSY! Return!\n", __FILE__, __LINE__));
        result = MMS_RESULT_BUSY;
    }
    else if (instance < 0L || instance >= MMS_MAX_FSM_POST_INSTANCES ||
        fsmInstance[instance] == NULL)
    {
        MMS_LOG_I(("%s(%d): instance out of bounds (%ld)\n",
            __FILE__, __LINE__, instance));
        result = MMS_RESULT_ERROR;
    }
    else if (scheme == NULL || server == NULL || 
        port == MMS_INVALID_CFG_VARIABLE || uri == NULL)
    {
        MMS_LOG_I(("Illegal configuration: Missing scheme, server, port or URI!\n"));
        result = MMS_RESULT_CONFIG_ERROR;
    }
    else if (param == NULL)
    {
        MMS_LOG_I(("%s(%d): Parameter error (%d)\n", 
            __FILE__, __LINE__, param));
        result = MMS_RESULT_ERROR;
    }
    else if (param->type < MMS_M_SEND_REQ || param->type > MMS_M_FORWARD_CONF)
    {
        MMS_LOG_I(("%s(%d): Illegal POST requested %d\n", __FILE__, __LINE__,
            param->type));
        result = MMS_RESULT_ERROR;
    } 

    


    if (result != MMS_RESULT_OK || instance == -1L || uri == NULL || 
        server == NULL || scheme == NULL)
    {
        resultParam = M_ALLOCTYPE(MmsSigCohPostResultParam);
        resultParam->result = result;
        resultParam->responseStatus = MMS_RSP_STATUS_NONE;
        resultParam->responseText = NULL;

        
        M_SIGNAL_SENDTO_IP( sig->u_param1, sig->u_param2, sig->i_param, resultParam);

        if (param != NULL && param->type != MMS_M_SEND_REQ)
        {
            M_FREE(param->data.pdu.packet);
        } 

        if (sig->p_param != NULL)
        {
            M_FREE(sig->p_param);
        } 
        
        deleteInstance(instance);
        return -1L;
    } 

    fsm = fsmInstance[instance];

    
    fsm->requestingFsm = (MmsStateMachine)sig->u_param1;
    fsm->returnSig = (MmsSignalId)sig->u_param2;
    fsm->fsmInstance = sig->i_param;

    
    fsm->retries = 0;
    fsm->param.type = param->type;
    fsm->param.isResponseRequested = param->isResponseRequested;
    fsm->param.origMsg = param->origMsg;
    fsm->responseStatus = MMS_RSP_STATUS_NONE;
    fsm->responseText = NULL;

    
    switch (fsm->param.type)
    {
    case MMS_M_SEND_REQ :
        fsm->param.data.msgId = param->data.msgId;
        break;
    case MMS_M_NOTIFY_RESP :
    case MMS_M_ACKNOWLEDGE_IND :
    case MMS_M_READ_REC_IND :
    case MMS_M_FORWARD_REQ :
        fsm->param.data.pdu = param->data.pdu;
        break;
    default :
        MMS_LOG_I(("POST: Can't be here. Already tested (%d)!\n", fsm->param.type));
        return -1L;
    } 

    M_FREE(sig->p_param);

    
    len = strlen(scheme) + strlen(server) + 1 + LEN_POST_PORT + strlen(uri) + 1;
    fsm->uri = M_ALLOC(len);
    if (port == 0)
    {
        if (sprintf( fsm->uri, "%s%s%s", scheme, server, uri) > (int)len)
        {
            MMS_LOG_I(("%s(%d): Wrote outside allocated memory\n",
                __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return -1L;
        } 
    }
    else if (sprintf( fsm->uri, "%s%s:%lu%s", scheme, server, port, uri) > (int)len)
    {
        MMS_LOG_I(("%s(%d): Wrote outside allocated memory\n",
            __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return -1L;
    } 

    
    fsm->requestId = mmsWapGetRequestId();
    if (fsm->requestId == -1)
    {
        MMS_LOG_I(("No available request IDs! Terminating!\n"));

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

        deleteInstance(instance);
        return -1L;
    } 

    return instance;
} 






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

    fsm = fsmInstance[instance];

    

    if (fsm->param.origMsg != 0 && fsm->param.type == MMS_M_FORWARD_REQ)
    {
       MmsHeaderValue read;
       
        
       if ( !mmsPduGet((char *)fsm->param.data.pdu.packet, fsm->param.data.pdu.length,
           X_MMS_READ_REPLY, &read) && read.readReply == MMS_READ_REPLY_NO)
       {
            
           if ( !mmsPduGet((char *)fsm->param.data.pdu.packet, fsm->param.data.pdu.length,
               X_MMS_DELIVERY_REPORT, &read) && read.readReply == MMS_READ_REPLY_NO)
           {
               fsm->param.origMsg = 0; 
           }  
       }         
    } 
     
    M_TIMER_RESET_I( M_FSM_COH_POST, instance); 
    
    
    fsm->sent = fsm->msgSize = fsm->param.data.pdu.length;
    fsm->transactionId = getTransactionId( (char *)fsm->param.data.pdu.packet,
        fsm->param.data.pdu.length);

#ifdef MMS_LOG_PROTOCOL
    mmsWapLog( FALSE, (int)fsm->sent, (char *)fsm->param.data.pdu.packet);
#endif 

    M_TIMER_SET_I( M_FSM_COH_POST, MMS_POST_TIMEOUT, instance);

    MMS_LOG_I(("====> POST PDU, transactionId <%s>, requestId %d\n", 
        fsm->transactionId == NULL ? "NULL" : fsm->transactionId, fsm->requestId));
    MMSa_http( fsm->requestId, MMS_HTTP_POST, fsm->uri, myHttpHeader, 
        (char *)fsm->param.data.pdu.packet, 
        fsm->sent,                  
        fsm->msgSize,               
        fsm->sent != fsm->msgSize); 
} 







static void postRetry(long instance, MmsResult ret)
{
    CohPostInstanceData *fsm;   

    fsm = fsmInstance[instance];
    if (++fsm->retries < cfgGetInt(MMS_CFG_POST_RETRY))
    {
        MMS_LOG_I(("******* POST Retry ******* %s %s %s%lu\n",
            fsm->uri, fsm->transactionId == NULL ? "NULL" : fsm->transactionId, 
            fsm->param.type == MMS_M_SEND_REQ ? "msgId=" : "pdu type=",
            fsm->param.type == MMS_M_SEND_REQ ? 
                fsm->param.data.msgId : (UINT32)fsm->param.data.pdu.packet[1]));

        
        mmsWapCancelHttpOperation(fsm->requestId);

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

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

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

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

        fsm->requestId = mmsWapRenewRequestId(fsm->requestId);
        postIt(instance);               
    }
    else
    {
        
        postFinished( instance, ret);
    } 
} 







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

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

    return -1L;
}