mfieldp.c

彩信MMS的全部代码

                M_FREE(entryHeaderList->entryHeader);
                entryHeaderList->entryHeader = NULL;
            }
            else 
            {
                M_FREE(current);
                current = previous;
                current->next = NULL;
            } 

            if (skipEntryHeader( &headerPos, &remainingSize) == FALSE)
            {
                MMS_LOG_I(("%s(%d): ERROR: Unrecognized well-known field name\n", 
                    __FILE__, __LINE__));

                
                headerPos = headerStart + bufSize;
                remainingSize = 0;
            } 
        } 

    } 

    return headerPos;
} 












void parseFromAddress(unsigned char *headerData, const UINT32 headerSize,
    MmsAddress *from)
{ 
    MmsHeaderValue  headerValue;    
    UINT32 valueLength = 0;          
    unsigned char *tmpBuf;             
    unsigned long size;
    MmsEncodedText eText; 
    UINT32 lengthOfString; 

    if (from == NULL)
    {
        return; 
    } 

    from->address = NULL;
    from->name.text = NULL;
    from->name.charset = CMN_CHARSET_UNKNOWN;   
    from->addrType = MMS_ADDRESS_EMAIL;

     
    if (mmsPduGet(headerData,  headerSize, MMS_FROM, &headerValue))
    {  
        size = (UINT32)headerData - (UINT32)headerValue.from + headerSize;

         
        tmpBuf = (unsigned char *)cnvValueLengthToUint32( headerValue.from, 
            &valueLength, size);

        if (valueLength == 0 || tmpBuf == NULL)
        {
            return;  
        } 
       
        
        if ((MmsFromType)*tmpBuf == MMS_FROM_INSERT_ADDRESS || 
            valueLength <= 1L)    
        {
            


        }    
        
        else if ((MmsFromType)*tmpBuf == MMS_FROM_ADDRESS_PRESENT)  
        {
            ++tmpBuf; 
            size = (UINT32)headerData - (UINT32)tmpBuf + headerSize;
            parseEncodedStringValue(tmpBuf, size, &lengthOfString, &eText);

            if (lengthOfString == 0)
            {   
                return;
            }
            else if (lengthOfString > valueLength) 
            { 
                MMS_LOG_I(("%s(%d): Field is too long\n", __FILE__, __LINE__));
            } 
            else
            {
                (void)splitAddressString((unsigned char *)eText.text, 
                    &from->address, &from->name.text, &from->addrType);
                from->name.charset = eText.charset;
            } 

            M_FREE(eText.text); 
            eText.text = NULL;
        } 
    } 
} 










CMN_BOOL parseHeaderTime(unsigned char *headerData, UINT32 headerDataSize, 
    MmsTime *someTime, MmsHeaderTag tag)
{
    MmsHeaderValue  headerValue;
    unsigned char *ptr;
    UINT32 size;
    UINT32 dummy;

    someTime->type = MMS_TIME_ABSOLUTE;
    someTime->sec = 0;
    if (headerData == NULL)
    {
        MMS_LOG_I(("%s(%d): Wrong data \n", __FILE__, __LINE__));
        return FALSE;
    }
    else if (!mmsPduGet( headerData, headerDataSize, tag, &headerValue))
    {
        return FALSE;
    } 

    
    ptr = headerValue.expiry;
    size = (UINT32)(headerData - ptr) + headerDataSize;

    ptr = cnvValueLengthToUint32( ptr, &dummy, size);
    if (ptr == NULL)
    {
        MMS_LOG_I(("%s(%d): Illegal date format\n", __FILE__, __LINE__));
        return FALSE;
    } 

    someTime->type = (MmsTimeType)*ptr;
    if (someTime->type != MMS_TIME_ABSOLUTE && someTime->type != MMS_TIME_RELATIVE)
    {
        MMS_LOG_I(("%s(%d): Illegal date format %d\n", __FILE__, __LINE__,
            someTime->type));
        return FALSE;
    } 

    ++ptr; 
    size = (UINT32)(headerData - ptr) + headerDataSize;
    if (cnvLongIntegerToUint32( ptr, &someTime->sec, size) == NULL) 
    {
        MMS_LOG_I(("%s(%d): Illegal date format\n", __FILE__, __LINE__));
        return FALSE; 
    } 

    return TRUE;
} 






unsigned char *parseOneAddress(unsigned char *addrValue, UINT32 size, MmsAddress *address)
{
    UINT32 encodedLength = 0;
    MmsEncodedText etext; 
    unsigned char *offset = NULL;
    unsigned char *endPointer = NULL;
    long len; 

    parseEncodedStringValue( addrValue, size, &encodedLength, &etext);
    if (encodedLength > 0)
    {
        address->name.charset = etext.charset;                  
        offset = splitAddressString((unsigned char*)etext.text, 
            &address->address, &address->name.text, &address->addrType);

        len = offset - (unsigned char*)etext.text;
        if (offset != NULL && len >= 0 && len <= (long)size)
        {
            endPointer = addrValue + len;
        } 

        M_FREE(etext.text);     
        etext.text = NULL;
    } 

    return endPointer;
} 












static unsigned char *parseParam( unsigned char *buf, UINT32 size,
    MmsAllParams *param)
{
    UINT32 tmpUint;
    UINT32 len;
    UINT32 value = 0; 
    unsigned char *lastPos = buf + size;

    
    param->param = MMS_UNHANDLED;
    param->type = MMS_PARAM_INTEGER;
    param->value.integer = 0;

    if (size < 2)   
    {
        MMS_LOG_I(("%s(%d): Too little data for a parameter\n",
            __FILE__, __LINE__));
        return NULL;
    }
    else if (IS_SHORT_INTEGER(*buf))
    {   
        value = (UINT32)SKIP_HIGH_BIT(*buf);
        ++buf;
    }
    else if (IS_LONG_INTEGER(*buf))
    {   
        buf = cnvLongIntegerToUint32( buf, &value, size);
    } 
    else if (IS_TOKEN(*buf)) 
    {
        return parseParamUntyped( buf, size, param);
    }
    else
    {
        MMS_LOG_I(("%s(%d): Unknown parameter format %d\n", 
            __FILE__, __LINE__, (int)*buf));
        buf = NULL;
    } 

    if (buf == NULL || lastPos - buf < 0)
    {
        MMS_LOG_I(("%s(%d): Unable to parse param %d\n", 
            __FILE__, __LINE__, (int)buf));
        return NULL;
    } 

    switch ( (MmsParam)value)
    {
    case MMS_CHARSET : 
        if (IS_ANY_CHARSET(*buf))
        {   
            param->type = MMS_PARAM_INTEGER;
            param->value.integer = CMN_CHARSET_UTF_8; 
        }
        else if (IS_SHORT_INTEGER(*buf))
        {   
            param->type = MMS_PARAM_INTEGER;
            param->value.integer = (CmnCharset)SKIP_HIGH_BIT(*buf);
            ++buf;
        }
        else if (IS_LONG_INTEGER(*buf))
        {   
            buf = cnvLongIntegerToUint32( buf, &tmpUint, (UINT32)(lastPos - buf));
            if (buf == NULL)
            {
                MMS_LOG_I(("%s(%d): Unable to convert Long-integer to UINT32\n",
                    __FILE__, __LINE__));
                return NULL;  
            }
            else
            {
                param->type = MMS_PARAM_INTEGER;
                param->value.integer = (CmnCharset)tmpUint;
            } 
        }
        else if (*buf == '"')
        {   
            
            len = cmnStrnlen( (const char *)buf, (UINT32)(lastPos - buf)) + 1;
            buf += len;
            param->type = MMS_PARAM_INTEGER;
            param->value.integer = CMN_CHARSET_UNKNOWN;
        }
        else
        {
            MMS_LOG_I(("%s(%d): Unable to convert CHAR_SET datatype\n",
                __FILE__, __LINE__));
            return NULL;  
        } 
        break;

    case MMS_LEVEL:
        
        if (IS_SHORT_INTEGER(*buf))
        {
            param->type = MMS_PARAM_INTEGER;
            param->value.integer = SKIP_HIGH_BIT(*buf);
            ++buf;
        }
        else
        {   
            param->type = MMS_PARAM_STRING;
            
            len = cmnStrnlen( (const char *)buf, (UINT32)(lastPos - buf)) + 1;
            param->value.string = M_CALLOC(len); 
            memcpy( param->value.string, buf, len - 1);
            buf += len;
        } 
        break;
    case MMS_TYPE:
        
        param->type = MMS_PARAM_INTEGER;

        if (IS_SHORT_INTEGER(*buf))
        {
            param->value.integer = SKIP_HIGH_BIT(*buf);
            ++buf;
        }
        else
        {   
            buf = cnvLongIntegerToUint32( buf, &tmpUint, (UINT32)(lastPos - buf));
            if (buf == NULL)
            {
                MMS_LOG_I(("%s(%d): Unable to convert long-integer to UINT32\n",
                    __FILE__, __LINE__));
                return NULL;  
            }
            else
            {
                param->value.integer = tmpUint;
            } 
        } 
        break;
    case MMS_START_REL:
    case MMS_START_REL_ENCODING_14:
        
        param->type = MMS_PARAM_STRING;
        
        len = cmnStrnlen( (const char *)buf, (UINT32)(lastPos - buf)) + 1;
        param->value.string = M_CALLOC(len); 
        copyString( param->value.string, buf, len - 1);
        buf += len;
        break;
    case MMS_TYPE_REL:                      
    case MMS_START_INFO_REL:                
    case MMS_START_INFO_REL_ENCODING_14:    
    case MMS_NAME:                          
    case MMS_NAME_ENCODING_14:              
    case MMS_FILENAME:                      
    case MMS_FILENAME_ENCODING_14:          
        param->type = MMS_PARAM_STRING;
        
        len = cmnStrnlen( (const char *)buf, (UINT32)(lastPos - buf)) + 1;
        param->value.string = M_CALLOC(len); 
        memcpy( param->value.string, buf, len - 1);
        buf += len;
        break;    
    default :
        MMS_LOG_I(("%s(%d): Unknown param %d.\n", __FILE__, __LINE__, value));
        return NULL;
    } 

    param->param = (MmsParam)value;

    return buf;
} 












static unsigned char *parseParamEnc( unsigned char *buf, UINT32 size,
    MmsAllParamsEnc *param)
{
    UINT32 len;
    UINT32 value = 0; 
    unsigned char *lastPos = buf + size;

    
    param->param = MMS_PARAM_ENC_UNHANDLED;
    param->type = MMS_PARAM_INTEGER;
    param->value.integer = 0;

    






    if (buf == NULL || size < 2)   
    {
        MMS_LOG_I(("%s(%d): Too little data for a parameter\n",
            __FILE__, __LINE__));
        return NULL;
    }
    else if (IS_SHORT_INTEGER(*buf))
    {   
        value = (UINT32)SKIP_HIGH_BIT(*buf);
        ++buf;
    }
    else 
    {
        return parseParamEncUntyped( buf, size, param);
    } 

    if (lastPos - buf <= 0)
    {
        MMS_LOG_I(("%s(%d): Unable to parse param\n", __FILE__, __LINE__));
        return NULL;
    } 

    switch ( (MmsParamEnc)value)
    {
    case MMS_PARAM_ENC_TYPE : 
        
        if (IS_SHORT_INTEGER(*buf))
        {
            param->type = MMS_PARAM_INTEGER;
            param->value.integer = SKIP_HIGH_BIT(*buf);
            ++buf;
        }
        else    
        {
            param->type = MMS_PARAM_STRING;
            
            len = cmnStrnlen( (const char *)buf, (UINT32)(lastPos - buf)) + 1;
            param->value.string = M_CALLOC(len); 
            memcpy( param->value.string, buf, len - 1);
            buf += len;
        } 
        break;
    default :
        MMS_LOG_I(("%s(%d): Unknown param %d.\n", __FILE__, __LINE__, value));
        return NULL;
    } 

    param->param = (MmsParamEnc)value;

    return buf;
} 














static unsigned char *parseParams( unsigned char *buf, UINT32 size,
    MmsAllParams **params)
{
    INT32 remainingLength = (INT32)size;  
    MmsAllParams *tmpParam;  
    MmsAllParams *previous;  
    unsigned char *offset = buf;   
   
    *params = M_CALLOC( sizeof( MmsAllParams));
    tmpParam = *params;
    previous = tmpParam;

    while (remainingLength > 0)
    {
        if ( (offset = parseParam( offset, (UINT32)remainingLength, tmpParam)) == NULL)
        {    
           
            
            if ( tmpParam == *params)
            {
                *params = NULL;
            } 
            
            
            if (previous != NULL)
            {
                previous->next = NULL;
            } 

            MMS_LOG_I(("%s(%d): Unable to parse all params\n", __FILE__, __LINE__));

            M_FREE( tmpParam);
            return NULL;
        } 
        else
        {
            remainingLength = (INT32)size - (INT32)(offset - buf);
            if (remainingLength > 0)
            {
                tmpParam->next = M_CALLOC( sizeof( MmsAllParams));
                previous = tmpParam;
                tmpParam = tmpParam->next;
            } 

            tmpParam->next = NULL;
        }       
    } 
    
    return offset;
}