mmpduc.c

彩信MMS的全部代码

 
    *result = MMS_RESULT_OK;
    *length = 0;
    
    transactionId = generateMmsTransactionId(&transactionIdLen);

    
    if (createFromField( (MmsAddress *)&header->from, &from, &fromSize) == FALSE)
    {
        MMS_LOG_I(("%s(%d): Failed to convert From field\n",
            __FILE__, __LINE__));
        M_FREE(transactionId);
        transactionId = NULL;
        *result = MMS_RESULT_INVALID_ADDRESS;
        return NULL;    
    } 
                                             
    
    
    bufSize += TAG_SIZE + sizeof(MmsMessageType);           
    bufSize += TAG_SIZE + transactionIdLen;                  
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + ENCODED_D_INT_LEN;                
    bufSize += TAG_SIZE + fromSize + 1;                     
    bufSize += TAG_SIZE + getSizeOfAddress(header->to);     
    bufSize += TAG_SIZE + getSizeOfAddress(header->cc);     
    bufSize += TAG_SIZE + getSizeOfAddress(header->bcc);    
    bufSize += TAG_SIZE + ENCODED_D_INT_LEN;                
    bufSize += TAG_SIZE + ENCODED_D_INT_LEN;                
    bufSize += TAG_SIZE + ENCODED_OCTET_LEN;                
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    ctLen = strlen(contentLocation) + 1;
    bufSize += TAG_SIZE + ctLen;                            

    
    if (bufSize >= MMS_MAX_CHUNK_SIZE)              
    {
        MMS_LOG_I(("%s(%d): Header size (%lu) exceeded chunk size (%lu).\n",
            __FILE__, __LINE__, bufSize, MMS_MAX_CHUNK_SIZE));
        *result = MMS_RESULT_INVALID_HEADER_SIZE;
    }
    else if ( !validateAddressList( header->to) ||  
        !validateAddressList( header->cc) ||
        !validateAddressList( header->bcc))
    {
        MMS_LOG_I(("%s(%d): Invalid address size.\n", __FILE__, __LINE__));
        *result = MMS_RESULT_INVALID_ADDRESS;
    }
    else if (ctLen < 2)
    {
        MMS_LOG_I(("%s(%d): Content Location missing.\n", __FILE__, __LINE__));
        *result = MMS_RESULT_INVALID_CONTENT_LOCATION;
    } 

    if (*result != MMS_RESULT_OK)
    {
        M_FREE(from); 
        M_FREE(transactionId);
        return NULL;
    } 
    

    
    
    pduHeader = M_CALLOC((unsigned int)bufSize);
    
    
    valueOfTag.messageType = (UINT8)MMS_M_FORWARD_REQ;
    if (!mmsPduAppend( pduHeader,     
        bufSize,            
        &actLength,         
        X_MMS_MESSAGE_TYPE, 
        sizeof(UINT8),      
        valueOfTag))        
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Message-Type\n", __FILE__, __LINE__));
        M_FREE(from); 
        M_FREE(transactionId);
        M_FREE(pduHeader);
        *result = MMS_RESULT_ERROR_CREATING_FORWARD;
        return NULL;    
    }  
     
    
    valueOfTag.transactionId = transactionId;
    if (!mmsPduAppend(pduHeader, bufSize, &actLength, X_MMS_TRANSACTION_ID, 
        transactionIdLen, valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Transaction-Id\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_FORWARD;
        M_FREE(from); 
        M_FREE(transactionId);
        M_FREE(pduHeader);
        return NULL;    
    }  
    M_FREE(transactionId);
    transactionId = NULL;

    
    valueOfTag.version = (unsigned char)version;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_VERSION, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Version\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_FORWARD;
        M_FREE(from); 
        M_FREE(pduHeader);
        return NULL;    
    }  

    
    if (header->date != 0) 
    {
        valueOfTag.date = header->date;

        if (!mmsPduAppend( pduHeader, bufSize, &actLength, MMS_DATE, 
            sizeof(UINT32), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in Date\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(from); 
            M_FREE(pduHeader);
            return NULL;    
        }  
     } 

    
    valueOfTag.from = from;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, MMS_FROM, fromSize, 
        valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Could not add From to header\n", __FILE__, __LINE__));
        *result = MMS_RESULT_INVALID_ADDRESS;
        M_FREE(from); 
        M_FREE(pduHeader);
        return NULL;    
    }  
    M_FREE(from);
    from = NULL;
    
    
    if (header->to != NULL) 
    {
        if (createDestinationField( header->to, pduHeader, bufSize,
            &actLength, MMS_TO) == FALSE )
        {
            MMS_LOG_I(("%s(%d): Could not add To to header\n", __FILE__, __LINE__));
            *result = MMS_RESULT_INVALID_ADDRESS;
            M_FREE( pduHeader); 
            return NULL;
        } 
    } 

    
    if (header->cc != NULL) 
    {
        if (createDestinationField( header->cc, pduHeader, bufSize,
            &actLength, MMS_CC) == FALSE )
        {
            MMS_LOG_I(("%s(%d): Could not add Cc to header\n", __FILE__, __LINE__));
            *result = MMS_RESULT_INVALID_ADDRESS;
            M_FREE( pduHeader); 
            return NULL;
        } 
    } 

    
    if (header->bcc != NULL) 
    {
        if (createDestinationField( header->bcc, pduHeader, bufSize,
            &actLength, MMS_BCC) == FALSE )
        {
            MMS_LOG_I(("%s(%d): Could not add Bcc to header\n", __FILE__, __LINE__));
            *result = MMS_RESULT_INVALID_ADDRESS;
            M_FREE( pduHeader); 
            return NULL;
        } 
    } 
      
    
    if (header->expiryTime.sec != 0)
    {
        if ((codedValue = createTimeField(&size, &header->expiryTime)) == NULL)
        {
            MMS_LOG_I(("%s(%d): X-Mms-Expiry conversion failed.\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(pduHeader);
            return NULL;    
        }  
        
        valueOfTag.expiry = codedValue;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_EXPIRY, size, 
            valueOfTag))
        {
            MMS_LOG_I(("%s(%d): Error in X-Mms-Expiry\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(pduHeader);
            M_FREE(codedValue);
            return NULL;    
        } 

        M_FREE(codedValue);
        codedValue = NULL;
    }    

    
    if (header->deliveryTime.sec != 0)
    {
        if ((codedValue = createTimeField(&size, &header->deliveryTime)) == NULL)
        {
            MMS_LOG_I(("%s(%d): X-Mms-Delivery-Time error.\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(pduHeader);
            return NULL;    
        }  
        
        valueOfTag.deliveryTime = codedValue;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_DELIVERY_TIME, 
            size, valueOfTag))
        {
            MMS_LOG_I(("%s(%d): Error in X-Mms-Delivery-Time\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(pduHeader);
            M_FREE(codedValue);
            return NULL;    
        } 

        M_FREE(codedValue);
        codedValue = NULL;
    }    
   
    
    valueOfTag.reportAllowed = (UINT8)cfgGetInt(MMS_CFG_DELIVERY_REPORT);
    if (valueOfTag.reportAllowed == MMS_DELIVERY_REPORT_NO &&
        !mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_REPORT_ALLOWED, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Report-Allowed\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_FORWARD;
        M_FREE(pduHeader);
        return NULL;    
    }  

    
    if (header->deliveryReport != MMS_DELIVERY_REPORT_NOT_SET)
    {
        valueOfTag.deliveryReport = (UINT8)header->deliveryReport;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, 
            X_MMS_DELIVERY_REPORT, sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-DeliveryReport\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(pduHeader);
            return NULL;    
        }  
    } 

    
    if (header->readReply != MMS_READ_REPLY_NOT_SET)
    {
        valueOfTag.readReply = (UINT8)header->readReply;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_READ_REPLY, 
            sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Read-Reply\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_FORWARD;
            M_FREE(pduHeader);
            return NULL;    
        }  
    }    
    
    
    valueOfTag.contentLocation = contentLocation;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_CONTENT_LOCATION, 
        ctLen, valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Could not add Content Location\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_FORWARD;
        M_FREE(pduHeader);
        return NULL;    
    }  

    *length = (UINT32)actLength ; 
    return pduHeader;
} 












unsigned char *createWspReadReport(const MmsHeader *header, UINT32 *length, 
    MmsResult *result, MmsReadStatus readStatus, MmsVersion version)
{ 
    unsigned char *pduHeader = NULL;    
    unsigned long actLength = 0;         
    unsigned long bufSize = 0;          
    unsigned long fromSize = 0;
    unsigned char *from = NULL; 
    MmsHeaderValue valueOfTag;
    MmsAddressList addressList;
    MmsAddress emptyFrom;

    *result = MMS_RESULT_OK;
    *length = 0;
    memset(&addressList, 0, sizeof(MmsAddressList));

    if (header->serverMessageId == NULL || 
        strlen( (char *)header->serverMessageId) < 1)
    {
        MMS_LOG_I(("%s(%d): Server Message ID mandatory.\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
        return NULL;
    } 

    
    emptyFrom.address = NULL;   
    if (createFromField( (MmsAddress *)&emptyFrom, &from, &fromSize) == FALSE)
    {
        MMS_LOG_I(("%s(%d): Failed to convert From field\n", __FILE__, __LINE__));
        *result = MMS_RESULT_INVALID_ADDRESS;
        return NULL;
    } 
                                             
    
    
    bufSize += TAG_SIZE + sizeof(MmsMessageType);           
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + 
        strlen((char *)header->serverMessageId) + 1;        
    bufSize += TAG_SIZE + getSizeOfAddress(&addressList);   
    bufSize += TAG_SIZE + fromSize + 1;                     
    bufSize += TAG_SIZE + ENCODED_D_INT_LEN;                
    bufSize += TAG_SIZE + sizeof(UINT8);                     

    if (bufSize >= MMS_MAX_CHUNK_SIZE)              
    {
        MMS_LOG_I(("%s(%d): Header size (%lu) exceeded chunk size (%lu).\n",
            __FILE__, __LINE__, bufSize, MMS_MAX_CHUNK_SIZE));
        *result = MMS_RESULT_INVALID_HEADER_SIZE;
        M_FREE(from);
        return NULL;
    } 

    pduHeader = (unsigned char *)M_CALLOC((unsigned int)bufSize);

    valueOfTag.messageType = (UINT8)MMS_M_READ_REC_IND;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_MESSAGE_TYPE,
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Message-Type\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
        M_FREE(from);
        M_FREE(pduHeader); 
        return NULL;
    } 

    valueOfTag.version = (unsigned char)version;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_VERSION, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Version\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
        M_FREE(from);
        M_FREE(pduHeader); 
        return NULL;
    } 

    valueOfTag.messageId = header->serverMessageId;
    if (!mmsPduAppend(pduHeader, bufSize, &actLength, MMS_MESSAGE_ID, 
        strlen(valueOfTag.messageId) + 1, valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in Server-Message-Id\n", __FILE__, __LINE__));
        *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
        M_FREE(from);
        M_FREE(pduHeader); 
        return NULL;
    }  

    
    if (copyAddress(&addressList.current, &header->from) == FALSE)
    {
        MMS_LOG_I(("%s(%d): Failed copy From field\n", __FILE__, __LINE__));
        *result = MMS_RESULT_INVALID_ADDRESS;
        M_FREE(from);
        M_FREE(pduHeader); 
        return NULL;
    }
    else if ( !validateAddressList(&addressList))    
    {
        MMS_LOG_I(("%s(%d): Invalid address size.\n", __FILE__, __LINE__));
        *result = MMS_RESULT_INVALID_ADDRESS;
        freeMmsAddress(&addressList.current);
        M_FREE(from);
        M_FREE(pduHeader); 
        return NULL;
    }
    else if (createDestinationField(&addressList, pduHeader, bufSize,
        &actLength, MMS_TO) == FALSE )
    {
        MMS_LOG_I(("%s(%d): Could not add To to header\n", __FILE__, __LINE__));
        freeMmsAddress(&addressList.current);
        M_FREE(from);
        M_FREE( pduHeader); 
        *result = MMS_RESULT_INVALID_ADDRESS;
        return NULL;
    } 

    freeMmsAddress(&addressList.current);

    
    valueOfTag.from = from;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, MMS_FROM, fromSize, 
        valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Could not add From to header\n", __FILE__, __LINE__));
        M_FREE(from); 
        M_FREE(pduHeader);
        *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
        return NULL;
    }  

    M_FREE(from);
    from = NULL;
    
    
    if (header->date != 0) 
    {
        valueOfTag.date = header->date;

        if (!mmsPduAppend( pduHeader, bufSize, &actLength, MMS_DATE, 
            sizeof(UINT32), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in Date\n", __FILE__, __LINE__));
            M_FREE(pduHeader);
            *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
            return NULL;    
        }  
    } 

    
    valueOfTag.readStatus = (UINT8)readStatus;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_READ_STATUS, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in readStatus\n", __FILE__, __LINE__));
        M_FREE(pduHeader);
        *result = MMS_RESULT_ERROR_CREATING_READ_REPORT;
        return NULL;    
    }  

    *length = actLength;
    return pduHeader;   
}