mfieldp.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 "cmntypes.h"   
#include "aapicmn.h"    
#include "gmem.h"       
#include "cutils.h"     

#include "mmsconf.h"    
#include "mmstypes.h"   
#include "aapimms.h"    
#include "mmem.h"       
#include "mcpdu.h"      
#include "mfieldp.h"    
#include "fldrmgr.h"
#include "mutils.h"     


#define TOKEN_GREATER_THEN  62                  
#define TOKEN_LESSER_THEN   60                  

#define TYPE_PLMN                 "/TYPE=PLMN"  
#define TYPE_IPV4                 "/TYPE=IPv4"
#define TYPE_EMAIL                "/TYPE=EMAIL" 
#define TYPE_UNKNOWN              "/TYPE="

#define ANY_LANGUAGE_VALUE  128
















static MmsEncodedText *charsetCvtEncodedString( const MmsEncodedText *fromText, 
    const UINT32 fromBufferSize);
static MmsKnownMediaType convertToMmsKnownMediaType( UINT32 mediaValue);
static void copyString( unsigned char *to, const unsigned char *from, UINT32 size);
static unsigned char *parseContentDisposition(unsigned char *headerStart, UINT32 bufSize, 
    MmsEntryHeader *entryHeader);
static unsigned char *parseContentIdLocation(unsigned char *headerStart, UINT32 bufSize, 
    MmsEntryHeader *entryHeader);
static unsigned char *parseParam( unsigned char *buf, UINT32 size, 
    MmsAllParams *param);
static unsigned char *parseParamEnc( unsigned char *buf, UINT32 size, 
    MmsAllParamsEnc *param);
static unsigned char *parseParams( unsigned char *buf, UINT32 size,
     MmsAllParams **params);
static unsigned char *parseParamsEnc( unsigned char *buf, UINT32 size,
     MmsAllParamsEnc **params);
static unsigned char *parseParamUntyped( unsigned char *buf, UINT32 size, 
    MmsAllParams *param);
static unsigned char *parseParamEncUntyped( unsigned char *buf, UINT32 size, 
    MmsAllParamsEnc *param);
static unsigned char *splitAddressString(unsigned char *str, char **addr, 
    char **text, MmsAddressType* adrType);
static CMN_BOOL skipEntryHeader(unsigned char **entryHeader, UINT32 *size);








static MmsEncodedText *charsetCvtEncodedString( const MmsEncodedText *fromText, 
    const UINT32 fromBufferSize)
{
    MmsBodyPart *convPart;
    MmsBodyPart *retPart;
    MmsEncodedText *toText;
    int charSet = 0;
    
    toText = NULL; 

    
    if ( fromText == NULL || fromText->text == NULL)
    {
        return NULL;
    } 

    convPart = M_CALLOC( sizeof( MmsBodyPart));
    convPart->storageType = MMS_BODY_PART_AS_BUFFER;
    convPart->data.buffer = (unsigned char *)fromText->text;
    convPart->dataSize = fromBufferSize;
    charSet = fromText->charset;

    retPart = mmsCharsetCvt( &charSet, convPart);
    if ( retPart == NULL)
    {
        
        toText = NULL;
    }
    else if ( retPart->storageType == MMS_BODY_PART_AS_FILE)
    {
        
        MMS_LOG_I(("%s(%d): Converted data too large for buffer\n", 
            __FILE__, __LINE__));

        FILEa_close( CMN_FILE_CATEGORY_TMP, retPart->data.file.id);
        FILEa_delete( CMN_FILE_CATEGORY_TMP, retPart->data.file.id);
        M_FREE( retPart);
        retPart = NULL;
        toText = NULL;
    }
    else 
    {
        
        toText = (MmsEncodedText *)M_CALLOC( sizeof( MmsEncodedText));
        toText->text = (char *)retPart->data.buffer;
        toText->charset = (CmnCharset)charSet;
        M_FREE(retPart);
    }

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

    return toText;
} 








static MmsKnownMediaType convertToMmsKnownMediaType( UINT32 mediaValue)
{
    MmsKnownMediaType mmsValue;

    switch ((MmsKnownMediaType)mediaValue)
    {
    case MMS_TYPE_ANY_ANY:
    case MMS_TYPE_TEXT_ANY:
    case MMS_TYPE_TEXT_HTML:
    case MMS_TYPE_TEXT_PLAIN:
    case MMS_TYPE_TEXT_X_HDML:
    case MMS_TYPE_TEXT_X_TTML:
    case MMS_TYPE_TEXT_X_VCALENDAR:
    case MMS_TYPE_TEXT_X_VCARD:
    case MMS_TYPE_TEXT_VND_WAP_WML:
    case MMS_TYPE_TEXT_VND_WAP_WMLSCRIPT:
    case MMS_TYPE_TEXT_VND_WAP_CHANNEL:
    case MMS_TYPE_MULTIPART_ANY:
    case MMS_TYPE_MULTIPART_MIXED:
    case MMS_TYPE_MULTIPART_FORM_DATA:
    case MMS_TYPE_MULTIPART_BYTERANGES:
    case MMS_TYPE_MULTIPART_ALTERNATIVE:
    case MMS_TYPE_APP_ANY:
    case MMS_TYPE_APP_JAVA_VM:
    case MMS_TYPE_APP_X_WWW_FORM_URLENCODED:
    case MMS_TYPE_APP_X_HDMLC:
    case MMS_TYPE_APP_VND_WAP_WMLC:
    case MMS_TYPE_APP_VND_WAP_WMLSCRIPTC:
    case MMS_TYPE_APP_VND_WAP_CHANNELC:
    case MMS_TYPE_APP_VND_WAP_UAPROF:
    case MMS_TYPE_APP_VND_WAP_WTLS_CA_CERTIFICATE:
    case MMS_TYPE_APP_VND_WAP_WTLS_USER_CERTIFICATE:
    case MMS_TYPE_APP_X_X509_CA_CERT:
    case MMS_TYPE_APP_X_X509_USER_CERT:
    case MMS_TYPE_IMAGE_ANY:
    case MMS_TYPE_IMAGE_GIF:
    case MMS_TYPE_IMAGE_JPEG:
    case MMS_TYPE_IMAGE_TIFF:
    case MMS_TYPE_IMAGE_PNG:
    case MMS_TYPE_IMAGE_VND_WAP_WBMP:
    case MMS_VND_WAP_MULTIPART_ANY:
    case MMS_VND_WAP_MULTIPART_MIXED:
    case MMS_TYPE_APP_VND_WAP_MPART_FORM_DATA:
    case MMS_TYPE_APP_VND_WAP_MPART_BYTERANGES:
    case MMS_VND_WAP_MULTIPART_ALTERNATIVE:
    case MMS_TYPE_APP_XML:
    case MMS_TYPE_TEXT_XML:
    case MMS_TYPE_APP_VND_WAP_WBXML:
    case MMS_TYPE_APP_X_X968_CROSS_CERT:
    case MMS_TYPE_APP_X_X968_CA_CERT:
    case MMS_TYPE_APP_X_X968_USER_CERT:
    case MMS_TYPE_TEXT_VND_WAP_SI:
    case MMS_TYPE_APP_VND_WAP_SIC:
    case MMS_TYPE_TEXT_VND_WAP_SL:
    case MMS_TYPE_APP_VND_WAP_SLC:
    case MMS_TYPE_TEXT_VND_WAP_CO:
    case MMS_TYPE_APP_VND_WAP_COC:
    case MMS_VND_WAP_MULTIPART_RELATED:
    case MMS_TYPE_APP_VND_WAP_SIA:
    case MMS_TYPE_TEXT_VND_WAP_CONNECTIVITY_XML:
    case MMS_TYPE_APP_VND_WAP_CONNECTIVITY_WBXML:
    case MMS_TYPE_APP_PKCS7_MIME:
    case MMS_TYPE_APP_VND_WAP_HASHED_CERTIFICATE:
    case MMS_TYPE_APP_VND_WAP_SIGNED_CERTIFICATE:
    case MMS_TYPE_APP_VND_WAP_CERT_RESPONSE:
    case MMS_TYPE_APP_XHTML_XML:
    case MMS_TYPE_APP_WML_XML:
    case MMS_TYPE_TEXT_CSS:
    case MMS_TYPE_APP_VND_WAP_MMS_MESSAGE:
    case MMS_TYPE_APP_VND_WAP_ROLLOVER_CERTIFICATE:
    case MMS_TYPE_APP_VND_WAP_LOCC_WBXML:
    case MMS_TYPE_APP_VND_WAP_LOC_XML:
    case MMS_TYPE_APP_VND_WAP_SYNCML_DM_WBXML:
    case MMS_TYPE_APP_VND_WAP_SYNCML_DM_XML:
    case MMS_TYPE_APP_VND_WAP_SYNCML_NOTIFICATION:
    case MMS_TYPE_APP_VND_WAP_XHTML_XML:
    case MMS_TYPE_APP_VND_WV_CSP_CIR:
    case MMS_TYPE_APP_VND_OMA_DD_XML:
    case MMS_TYPE_APP_VND_OMA_DRM_MESSAGE:
    case MMS_TYPE_APP_VND_OMA_DRM_CONTENT:
    case MMS_TYPE_APP_VND_OMA_DRM_R_XML:
    case MMS_TYPE_APP_VND_OMA_DRM_R_WBXML:
    case MMS_TYPE_APP_VND_WV_CSP_XML:
    case MMS_TYPE_APP_VND_WV_CSP_WBXML:
        mmsValue = (MmsKnownMediaType)mediaValue;
        break;
    
    case MMS_VALUE_AS_STRING: 
    default :
        MMS_LOG_I(("convertMediaType: Received unknown media value: %d\n", 
            mediaValue ));
        mmsValue = MMS_TYPE_ANY_ANY;
        break;
    } 

    return mmsValue;
} 






MmsStatus checkStatus(UINT8 status)
{
    MmsStatus retStatus = MMS_STATUS_UNRECOGNIZED;
    
    switch (status)
    {
    case MMS_STATUS_EXPIRED: 
    case MMS_STATUS_RETRIEVED: 
    case MMS_STATUS_REJECTED:     
    case MMS_STATUS_DEFERRED:     
       retStatus = (MmsStatus)status;
       break;
    case MMS_STATUS_UNRECOGNIZED: 
    default: 
       retStatus = MMS_STATUS_UNRECOGNIZED;
    } 

    return retStatus;
} 








static void copyString( unsigned char *to, const unsigned char *from, UINT32 size)
{
    
















    UINT32 i = 0;

    if (IS_QUOTED_STRING_QUOTE(from[i]) || IS_TEXT_QUOTE(from[i]))
    {
        ++i;
    } 

    if (from[i] == TOKEN_LESSER_THEN)
    {
        ++i;
    } 

    while (from[i] && size-- && from[i] != TOKEN_GREATER_THEN)
    {
        *to++ = from[i++];
    } 

    if (size > 0)
    {
        *to = EOS;
    } 
} 










MmsAddressList* parseAddress(MmsHeaderTag tag, unsigned char *headerData,
    UINT32 headerDataSize) 
{
    unsigned int index = 0;
    MmsAddressList *adrList = NULL;
    MmsAddressList *startOfList = NULL; 
    MmsHeaderValue  headerValue;
    unsigned char *addrValue;
    unsigned char *start;
    UINT32 size = 0;

    
    while (index <= headerDataSize)
    {
        if (!mmsPduGet( headerData + index,  (headerDataSize - index),
            tag, &headerValue))
        {   
            return startOfList;
        }
        else 
        {
            switch (tag) 
            {
            case MMS_BCC:
                addrValue = (unsigned char *)headerValue.bcc;
                break;
            case MMS_CC:
                addrValue = (unsigned char *)headerValue.cc;
                break;
            case MMS_TO: 
                addrValue = (unsigned char *)headerValue.to;
                break; 
            case MMS_FROM:  
            default: 
                return (MmsAddressList*)NULL; 
            }  
            
            start = addrValue;
            while (addrValue != NULL) 
            {
                if (adrList == NULL)
                {  
                    adrList = M_CALLOC( sizeof(MmsAddressList));
                    startOfList = adrList; 
                } 
                else
                {
                    adrList->next = M_CALLOC( sizeof(MmsAddressList));
                    adrList = adrList->next;
                } 
            
                size = headerDataSize - (UINT32)(addrValue - headerData);
                addrValue = parseOneAddress( addrValue, size, &adrList->current);
            } 
            
             
            index = (unsigned int)(start - headerData) + strlen( (const char *)start) + 1; 
            if (adrList != NULL)
            {
                adrList->next = NULL;
            } 
        } 
    } 
    
    return startOfList;
} 


























static unsigned char *parseContentDisposition(unsigned char *headerStart, 
    UINT32 bufSize, MmsEntryHeader *entryHeader)
{
    unsigned char *tmpHeaderPos;
    UINT32  valueLength = 0;
    MmsAllParams *tmpParam;
    MmsContentDispositionType dispType;
    
    memset( entryHeader, 0, sizeof(MmsEntryHeader));
    if (SKIP_HIGH_BIT(*headerStart) == MMS_WELL_KNOWN_CONTENT_DISPOSITION)
    {
        
        entryHeader->headerType = MMS_WELL_KNOWN_CONTENT_DISPOSITION;
        ++headerStart;  
        --bufSize;      
        
        
        tmpHeaderPos = cnvValueLengthToUint32( headerStart, &valueLength, bufSize);
        if (tmpHeaderPos == NULL || tmpHeaderPos > headerStart + bufSize)
        {
            MMS_LOG_I(("%s(%d): Unable to parse WSP Value-length in "
                "Content-disposition (%d)\n", __FILE__, __LINE__, tmpHeaderPos));
            headerStart = NULL;
        }
        else
        {
            
            entryHeader->value.contentDisposition.valueLength = valueLength;
            bufSize -= (UINT32)(tmpHeaderPos - headerStart);
            headerStart = tmpHeaderPos;
            
            
            dispType = (MmsContentDispositionType)*headerStart;
            
            entryHeader->value.contentDisposition.dispositionType = dispType;
            entryHeader->value.contentDisposition.params = NULL;
            ++headerStart;  
            --bufSize;      

            if (dispType != MMS_DISPOSITION_FORM_DATA &&
                dispType != MMS_DISPOSITION_ATTACHMENT &&
                dispType != MMS_DISPOSITION_INLINE)
            {
                MMS_LOG_I(("%s(%d): Unknown WSP Content-disposition type (%d)\n",
                    __FILE__, __LINE__, dispType));
            }
            else if (bufSize > 0 && valueLength > 0)
            {
                
                tmpParam = M_CALLOC(sizeof(MmsAllParams));                    
                tmpHeaderPos = parseParam( headerStart, bufSize, tmpParam);
                if (tmpHeaderPos == NULL || 
                    tmpHeaderPos > headerStart + bufSize)
                {
                    MMS_LOG_I(("%s(%d): No parameter parsed/provided in "
                        "WSP Content-disposition\n", __FILE__, __LINE__));
                    M_FREE(tmpParam);
                    tmpHeaderPos = NULL;
                }
                else if (dispType == MMS_DISPOSITION_FORM_DATA && 
                    tmpParam->param != MMS_NAME)
                {
                    MMS_LOG_I(("%s(%d): Unknown Parameter in WSP "
                        "Content-disposition Form-data (%d)\n",
                        __FILE__, __LINE__, tmpParam->param));
                    M_FREE(tmpParam);
                }
                else if (dispType == MMS_DISPOSITION_ATTACHMENT && 
                    tmpParam->param != MMS_FILENAME)
                {
                    MMS_LOG_I(("%s(%d): Unknown Parameter in WSP "
                        "Content-disposition Attachment (%d)\n",
                        __FILE__, __LINE__, tmpParam->param));
                    M_FREE(tmpParam);
                }
                else if (dispType == MMS_DISPOSITION_INLINE && 
                    tmpParam->param != MMS_FILENAME)
                {
                    MMS_LOG_I(("%s(%d): Unknown Parameter in WSP "
                        "Content-disposition Inline (%d)\n",
                        __FILE__, __LINE__, tmpParam->param));
                    M_FREE(tmpParam);
                }
                else
                {   
                    tmpParam->next = NULL;                       
                    entryHeader->value.contentDisposition.params = tmpParam;
                }