mfieldc.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 "cutils.h"     

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


#define ENCODED_VALUE_LEN           6   
#define ENCODED_CHAR_SET_LEN        8   
#define ENCODED_D_INT_LEN          31   
#define ENCODED_OCTET_LEN           1   


#define ENCODED_DATE_LEN            (ENCODED_VALUE_LEN + ENCODED_OCTET_LEN + ENCODED_D_INT_LEN)

#define MAX_VALUE_LENGTH_SIZE       5   
#define TOKEN_SIZE                  1
#define QUOTE_MARK                  34
#define QUOTE_REQUIRED              0x80
#define TOKEN_GREATER_THEN          62  
#define TOKEN_LESSER_THEN           60  
#define UTF8_SIZE                   1
#define ADDRESS_PLMN                "/TYPE=PLMN"
#define ADDRESS_IPV4                "/TYPE=IPV4"
#define MAX_LEN_OF_TRANSACTION_ID   64  
















static CMN_BOOL createAddressField(const MmsAddress *addr, unsigned char **returnData,
    unsigned long *returnLength);
static unsigned long getSizeOfText(const char *text);
static CMN_BOOL setContentTypeParams(const MmsAllParams *param, unsigned char *value);
static CMN_BOOL setContentTypeValue(const MmsAllParams *param, UINT32 *size, 
    unsigned char *value, int mediaType, const unsigned char *strValue);








static CMN_BOOL setContentTypeParams(const MmsAllParams *param, unsigned char *value)
{
    CMN_BOOL isSuccesful = TRUE;
    int len;

    while (param != NULL && isSuccesful)
    {    
        switch (param->param)
        {
        case MMS_CHARSET :          
        case MMS_LEVEL :            
        case MMS_TYPE :             
        case MMS_TYPE_REL :    
        case MMS_START_REL :        
        case MMS_START_INFO_REL :   
        case MMS_NAME :   
        case MMS_FILENAME :   
            *value++ = SET_HIGH_BIT(param->param);
            if (param->type == MMS_PARAM_STRING)  
            {    
                if (param->param == MMS_START_REL)
                {
                    len = sprintf( (char *)value, "<%s>", (char *)param->value.string);
                    if (len == 0)
                    {
                        
                        MMS_LOG_I(("%s(%d): Content type w. wrong length\n", 
                            __FILE__, __LINE__));
                        return FALSE;
                    } 
                
                    value += len + 1; 
                }
                else
                {   
                    strcpy((char *)value, (char *)param->value.string);
                    value += strlen((char *)param->value.string) + 1;
                } 
            }
            else if (param->value.integer <= 127) 
            {   
                *value++ = SET_HIGH_BIT(param->value.integer);
            }
            else 
            {
                value = cnvUint32ToLongInteger(param->value.integer,value,5);
            }  

            param = (MmsAllParams *)param->next;
            break;
        default :
            isSuccesful = FALSE;
            break;
        } 
    } 
    
    return isSuccesful;
}  












static CMN_BOOL setContentTypeValue(const MmsAllParams *param, UINT32 *size, 
    unsigned char *value, int mediaType, const unsigned char *strValue)
{
    unsigned char *cpyValue; 
    
    cpyValue = value;

    
    if (*size > 1 && param != NULL)
    {
      
        if (*size > 30)
        {
            *cpyValue++ = 31;
            cpyValue = (unsigned char *)cnvUint32ToUintvar(*size,cpyValue,5);    
        }
        else
        {
            
            *cpyValue = (unsigned char)(*size & 0x000000ff);
            cpyValue += strlen( ( const char *)value);
        }

        *size += strlen((const char *)value);
    }  

     
    if (mediaType == MMS_VALUE_AS_STRING)
    {    
        strcpy((char *)cpyValue, (const char *)strValue);
        cpyValue += strlen((const char *)strValue) + 1;
    }
    else
    {    
        *cpyValue++ = SET_HIGH_BIT(mediaType);
    }

     
    if (param != NULL )
    {
        if (!setContentTypeParams(param, cpyValue))
        {
            return FALSE;
        }
    }  
    return TRUE;
}  












unsigned char *createContentType(UINT32 *size,      
    const MmsContentType *contentInfo)
{
    unsigned char *value = NULL;

     
    calculateSize( contentInfo, size);

    


    value = M_CALLOC((unsigned int)(*size + 5));
    
     
    if (contentInfo->knownValue != MMS_VALUE_AS_STRING)
    {
        if (!setContentTypeValue(contentInfo->params, size, value, 
            contentInfo->knownValue, NULL))
        {
            M_FREE(value);
            value = NULL;
        } 
    }
    else if (contentInfo->knownValue == MMS_VALUE_AS_STRING)
    {
        if (!setContentTypeValue(contentInfo->params, size, value, 
            contentInfo->knownValue, contentInfo->strValue))
        {
            M_FREE(value);
            value = NULL;
        } 
    }
    else
    {
        M_FREE( value);
        value = NULL;
        *size = 0;
    }  
    
    return value;
}  










unsigned char *createMsgClass(unsigned long *size,
    MmsMessageClass msgClass)
{
    unsigned char *value;
    
     



    if (msgClass.classIdentifier == MMS_MESSAGE_CLASS_IS_TEXT)
    {
        *size = strlen(msgClass.textString) + 1;
        value = M_ALLOC(*size);
        strcpy( (char *)value, msgClass.textString);
    }
    else
    {
        *size = sizeof(UINT8);
        value = M_ALLOC(*size); 
        *value = SET_HIGH_BIT(msgClass.classIdentifier);
    } 
    return value; 
}  










CMN_BOOL createFromField( const MmsAddress *fromAddr, unsigned char **buf,
    unsigned long *bufLength)
{
    unsigned long maxDataSize = 0;
    unsigned char *pTmp;
    unsigned char *ptr;
    unsigned long encTextSize;
    unsigned char *encTextBuf;
    char *tmpVal;
    MmsAddress *from = NULL;
    CMN_BOOL ret = FALSE;
    
    *buf = NULL;

    
    if (fromAddr->address != NULL && strlen(fromAddr->address) > 0)
    {
        
        if ( createAddressField( fromAddr, &encTextBuf, &encTextSize))
        {
             
            maxDataSize = MAX_VALUE_LENGTH_SIZE + TOKEN_SIZE + encTextSize;
            
            ptr = M_CALLOC((unsigned) maxDataSize);
            *buf = ptr; 
            ptr = (unsigned char*)cnvUint32ToValueLength((UINT32)TOKEN_SIZE + 
                encTextSize, (void *)ptr, maxDataSize);
            *bufLength = (unsigned long)(ptr - *buf);
            *ptr++ = MMS_FROM_ADDRESS_PRESENT;
            memcpy( ptr, encTextBuf, (unsigned)encTextSize);
            *bufLength += 1 + encTextSize;
            ret = TRUE;

            M_FREE( encTextBuf);
            encTextBuf = NULL;
        }  
    }  
    else if (cfgGetInt( MMS_CFG_FROM_ADDRESS_INSERT_TYPE) == MMS_FROM_INSERT_ADDRESS)
    {   
        maxDataSize = MAX_VALUE_LENGTH_SIZE + TOKEN_SIZE;
        ptr = M_CALLOC( (unsigned)maxDataSize);
        *buf = ptr;
        pTmp = ptr;
        ptr = cnvUint32ToValueLength( (UINT32)sizeof(unsigned char), 
            (void *)ptr, maxDataSize);
        *ptr = MMS_FROM_INSERT_ADDRESS;
        *bufLength = (unsigned long)(ptr - pTmp);
        *bufLength += TOKEN_SIZE;
        
        ret = TRUE;
    }
    else  
    {
         
        if ( (tmpVal = cfgGetStr( MMS_CFG_FROM_ADDRESS)) == NULL)
        {
            MMS_LOG_I(("%s(%d): Configuration error. No from address set.\n", 
                __FILE__, __LINE__));
        } 
        else
        {
            from = M_CALLOC( sizeof( MmsAddress));
            from->address = M_ALLOC( strlen( tmpVal) + 1);
            strcpy( from->address, tmpVal);
 
            
            if ( cfgGetInt( MMS_CFG_FROM_ADDRESS_TYPE) == MMS_ADDRESS_PLMN)
            {
                from->addrType = MMS_ADDRESS_PLMN;
            }
            else
            {
                from->addrType = MMS_ADDRESS_EMAIL;
                from->name.charset = CMN_CHARSET_UTF_8;  
            
                
                if ( (tmpVal = cfgGetStr( MMS_CFG_FROM_NAME)) == NULL)
                {
                    from->name.text  = NULL;
                }
                else
                {
                    from->name.text = M_ALLOC( strlen( tmpVal) + 1);
                    strcpy( from->name.text, tmpVal);
                }  
            }  

            
            if ( createAddressField( from, &encTextBuf, &encTextSize))
            {
                 
                maxDataSize = MAX_VALUE_LENGTH_SIZE + TOKEN_SIZE + encTextSize;
                
                ptr = M_CALLOC((unsigned) maxDataSize);
                *buf = ptr; 
                ptr = (unsigned char*)cnvUint32ToValueLength((UINT32)TOKEN_SIZE 
                    + encTextSize, (void *)ptr, maxDataSize);
                *bufLength = (unsigned long)(ptr - *buf);
                *ptr++ = MMS_FROM_ADDRESS_PRESENT;
                memcpy(ptr, encTextBuf, (unsigned)encTextSize);
                *bufLength += 1 + encTextSize;
                ret = TRUE;

                M_FREE( encTextBuf);
                encTextBuf = NULL;
            }  

            freeMmsAddress(from);
            M_FREE(from);
            from = NULL;
        }  
    }  
    
    return ret;
} 



















CMN_BOOL createDestinationField( MmsAddressList *addrList, 
    unsigned char *pduHeader, unsigned long bufSize, 
    unsigned long *actLength, MmsHeaderTag headerTag)
{
    unsigned char *buffer;
    unsigned long addressLength;
    MmsHeaderValue valueOfTag;
 
    MmsAddressList *listPtr;
    MmsAddress *addr;

    listPtr = addrList;

    while ( listPtr)
    {
        addr = &listPtr->current;

        if ( createAddressField( addr, &buffer, &addressLength) == FALSE)
        {
            MMS_LOG_I(("%s(%d): Failed to create address field\n", 
                __FILE__, __LINE__));
            return FALSE;    
        }
        else
        {
            valueOfTag.to = buffer;

            if ( !mmsPduAppend( pduHeader, bufSize, actLength, headerTag,
                addressLength, valueOfTag))
            { 
                MMS_LOG_I(("%s(%d): Couldn't add address to header\n", 
                    __FILE__, __LINE__));

                M_FREE(buffer); 
                buffer = NULL;
                return FALSE;    
            }  
            
            M_FREE(buffer); 
            buffer = NULL;
        } 
        
        listPtr = listPtr->next;
    }   
    
    return TRUE;
} 










static CMN_BOOL createAddressField( const MmsAddress *addr, 
    unsigned char **returnData, unsigned long *returnLength)
{
    unsigned long size;    
    CMN_BOOL ret;
    CmnCharset charset;
    char *ptr;

    if (addr->address == NULL) 
    {
        return FALSE; 
    } 
   
    size = CMN_MAX( sizeof(ADDRESS_PLMN), sizeof(ADDRESS_IPV4));
    if (addr->name.text == NULL)
    {
        size += strlen(addr->address) + 1;
        charset = CMN_CHARSET_US_ASCII;
    }
    else
    {
        size += strlen(addr->name.text) + strlen(addr->address) + 4;
                
        charset = addr->name.charset;
    } 

    ptr = M_CALLOC(size);
    if (addr->addrType == MMS_ADDRESS_EMAIL)
    {
        if ( (addr->name.text == NULL))
        {
            strcpy( ptr, addr->address);
        }
        else if (sprintf( ptr, "%s <%s>", addr->name.text, addr->address) > (int)size)
        {
            MMS_LOG_I(("%s(%d): Memory overwritten!\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return FALSE;
        } 
    }
    else if (addr->addrType == MMS_ADDRESS_IPV4)
    {
        if (sprintf( ptr, "%s%s", addr->address, ADDRESS_IPV4) > (int)size)
        {
            MMS_LOG_I(("%s(%d): Memory overwritten!\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return FALSE;
        } 
    }
    else 
    {
        if (addr->addrType != MMS_ADDRESS_PLMN)
        {
            MMS_LOG_I(("%s(%d): Unknown address type %d. Defaulting to PLMN type.\n", 
                __FILE__, __LINE__, (int)addr->addrType));
        } 

        if (sprintf( ptr, "%s%s", addr->address, ADDRESS_PLMN) > (int)size)
        {
            MMS_LOG_I(("%s(%d): Memory overwritten!\n", __FILE__, __LINE__));
            MMSa_error(MMS_RESULT_RESTART_NEEDED);
            return FALSE;
        } 
    } 

    ret = createEncodedStringValue( ptr, charset, returnLength, returnData);
    M_FREE(ptr);
    
    return ret;
}