mmpduc.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 "aapifile.h"   

#include "aapicmn.h"    
#include "gmem.h"       
#include "fldrmgr.h"    

#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "mmem.h"       
#include "mcpdu.h"      
#include "mmpduc.h"     
#include "msig.h"       
#include "mconfig.h"    
#include "mutils.h"     
#include "mfieldc.h"    
#include "mfreemms.h"   



#define TAG_SIZE                    1
#define MAX_UINTVAR_SIZE            5
#define ENCODED_D_INT_LEN          31   
#define ENCODED_OCTET_LEN           1   
































unsigned char *createWspSendHeader( const MmsHeader *header, 
    const UINT32 numOfBodyParts, UINT32 *length, MmsResult *result, 
    MmsVersion version)
{
    unsigned char *pduHeader;       
    char *transactionId;       
    unsigned long transactionIdLen = 0; 
    unsigned long actLength = 0;         
    unsigned long bufSize = 0;          
    unsigned long fromSize = 0;
    unsigned long size = 0;
    unsigned char *codedValue;      
    unsigned char *from; 
    unsigned char *subject; 
    unsigned char nEntries[MAX_UINTVAR_SIZE];
    unsigned char *offset; 
    UINT32 tempSize;
    MmsHeaderValue valueOfTag;
    MmsResult resultInit = MMS_RESULT_OK;
 
    
    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_ERROR_CREATING_SEND_HEADER;
        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 + getSizeOfEncodedText(header->subject) + 1; 
    bufSize += TAG_SIZE + MAX_STR_LEN_MSG_CLASS + 1;        
    bufSize += TAG_SIZE + ENCODED_D_INT_LEN;                
    bufSize += TAG_SIZE + ENCODED_D_INT_LEN;                
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    if (version >= MMS_VERSION_11)  
    {
        bufSize += TAG_SIZE + sizeof(UINT8);                
        bufSize += TAG_SIZE + ENCODED_D_INT_LEN;            
        if (header->replyChargingId != NULL)
        {
            bufSize += TAG_SIZE + 
            strlen((char *)header->replyChargingId) + 1;    
        } 
        bufSize += TAG_SIZE + ENCODED_D_INT_LEN;            
    } 

    calculateSize( header->contentType, &tempSize);         
     
    bufSize += TAG_SIZE + tempSize + MAX_UINTVAR_SIZE;

    
    if ( isMultiPart( header->contentType->knownValue))
    {
        bufSize += MAX_UINTVAR_SIZE;
    } 

    
    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));
        resultInit = 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__));
        resultInit = MMS_RESULT_INVALID_ADDRESS;
    }
    else if ( !validateSubject( &header->subject))      
    {
        MMS_LOG_I(("%s(%d): Invalid subject size.\n", __FILE__, __LINE__));
        resultInit = MMS_RESULT_INVALID_SUBJECT;
    }
    else if ( !validateMessageClass( &header->msgClass))
    {
        MMS_LOG_I(("%s(%d): Invalid message class size.\n", __FILE__, __LINE__));
        resultInit = MMS_RESULT_INVALID_MSG_CLASS;
    } 

    if (resultInit != MMS_RESULT_OK)
    {
        M_FREE(from); 
        M_FREE(transactionId);
        *result = resultInit;

        return NULL;
    } 
    

    
    pduHeader = M_CALLOC((unsigned int)bufSize);
    
    



    
    valueOfTag.messageType = (UINT8)MMS_M_SEND_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_SEND_HEADER;

        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_SEND_HEADER;
        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_SEND_HEADER;
        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_SEND_HEADER;
            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_ERROR_CREATING_SEND_HEADER;
        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_ERROR_CREATING_SEND_HEADER;
            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_ERROR_CREATING_SEND_HEADER;
            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_ERROR_CREATING_SEND_HEADER;
            M_FREE( pduHeader); 
            return NULL;
        } 
    } 

    
    if (header->subject.text != NULL)
    {
        if (createEncodedStringValue(header->subject.text, 
             header->subject.charset, &size, &subject) == FALSE)
        {
            MMS_LOG_I(("%s(%d): Could not encode subject string\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(pduHeader); 
            return NULL;    
        } 

        valueOfTag.subject = subject;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, MMS_SUBJECT, size, 
            valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Could not add Subject\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(subject);
            M_FREE(pduHeader);
            return NULL;    
        }  

        M_FREE(subject);
    } 
    
     
    if (header->msgClass.classIdentifier != MMS_MESSAGE_CLASS_NOT_SET)
    {
        valueOfTag.messageClass = createMsgClass( &size, header->msgClass);
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_MESSAGE_CLASS, 
            size, valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): X-Mms-Message-Class\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(valueOfTag.messageClass);
            M_FREE(pduHeader);
            return NULL;    
        }  
        
        M_FREE(valueOfTag.messageClass);
        valueOfTag.messageClass = 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_SEND_HEADER;
            M_FREE(pduHeader);
            M_FREE(codedValue);
            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_SEND_HEADER;
            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_SEND_HEADER;
            M_FREE(pduHeader);
            M_FREE(codedValue);
            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_SEND_HEADER;
            M_FREE(pduHeader);
            M_FREE(codedValue);
            return NULL;    
        } 

        M_FREE(codedValue);
        codedValue = NULL;
    }    

    
    if (header->priority != MMS_PRIORITY_NOT_SET)
    {
        valueOfTag.priority = (UINT8)header->priority;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_PRIORITY, 
            sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in  X-Mms-Priority\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(pduHeader);
            return NULL;    
        }  
    } 
   
   
    if (header->visibility != MMS_SENDER_VISIBILITY_NOT_SET)
    {
        valueOfTag.senderVisibility = (UINT8)header->visibility;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, 
            X_MMS_SENDER_VISIBILITY, sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Visibility\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            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_SEND_HEADER;
            M_FREE(pduHeader);
            return NULL;    
        }  
    }