mfieldp.c

彩信MMS的全部代码

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

    while (remainingLength > 0)
    {
        if ( (offset = parseParamEnc( 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;
} 












static unsigned char *parseParamUntyped( unsigned char *buf, UINT32 size,
    MmsAllParams *param)
{
    UINT32 value = 0; 
    unsigned char *startPos = buf;

    if (buf == NULL || (UINT32)(buf - startPos) > size)
    {
        MMS_LOG_I(("%s(%d): Parameter parsing fault.\n", __FILE__, __LINE__));
        return NULL;
    } 

    
    MMS_LOG_I(("%s(%d): Unhandled parameter type.\n", __FILE__, __LINE__));

    



    
    buf = mmsPduSkipString( buf, size);
    if (buf == NULL || (UINT32)(buf - startPos) >= size)
    {
        MMS_LOG_I(("%s(%d): Invalid Untyped-parameter. Data missing.\n",
            __FILE__, __LINE__));
        return NULL;
    } 

    
    if (IS_SHORT_INTEGER(*buf))
    {   
        ++buf;
    }
    else if (IS_LONG_INTEGER(*buf))
    {   
        buf = cnvLongIntegerToUint32( buf, &value, 
            size - (unsigned long)(buf - startPos));
    } 
    else
    {   
        buf = mmsPduSkipString( buf, size - (unsigned long)(buf - startPos));
    } 

    if (buf == NULL || (UINT32)(buf - startPos) > size)
    {
        MMS_LOG_I(("%s(%d): Parameter parsing fault.\n", __FILE__, __LINE__));
        return NULL;
    } 

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

    return buf;
} 












static unsigned char *parseParamEncUntyped( unsigned char *buf, UINT32 size,
    MmsAllParamsEnc *param)
{
    unsigned char *startPos = buf;

    if (buf == NULL || (UINT32)(buf - startPos) > size)
    {
        MMS_LOG_I(("%s(%d): Parameter parsing fault.\n", __FILE__, __LINE__));
        return NULL;
    } 

    
    MMS_LOG_I(("%s(%d): Unhandled parameter type.\n", __FILE__, __LINE__));

    
    buf = mmsPduSkipString( buf, size);
    if (buf == NULL || (UINT32)(buf - startPos) >= size)
    {
        MMS_LOG_I(("%s(%d): Invalid Untyped-parameter. Data missing.\n",
            __FILE__, __LINE__));
        return NULL;
    } 

    
    if (IS_SHORT_INTEGER(*buf))
    {   
        ++buf;
    }
    else if (IS_TEXT_STRING(*buf))
    {   
        buf = mmsPduSkipString( buf, size - (unsigned long)(buf - startPos));
    }
    else
    {
        MMS_LOG_I(("%s(%d): Parameter value is of invalid type.\n", __FILE__, __LINE__));
        return NULL;
    } 

    if (buf == NULL || (UINT32)(buf - startPos) > size)
    {
        MMS_LOG_I(("%s(%d): Parameter parsing fault.\n", __FILE__, __LINE__));
        return NULL;
    } 

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

    return buf;
} 









static CMN_BOOL skipEntryHeader(unsigned char **entryHeader, UINT32 *size)
{
    unsigned char *eHeader;
    unsigned char *offset;
    UINT32 eSize = *size;
    UINT32 value;
    CMN_BOOL result = TRUE;

    if (entryHeader == NULL || *entryHeader == NULL || *size < 1)
    {
        
        return FALSE;
    } 

    eHeader = *entryHeader;
    switch (SKIP_HIGH_BIT(*eHeader))
    {
        
    case MMS_WELL_KNOWN_CONTENT_MD5:
    case MMS_WELL_KNOWN_CONTENT_RANGE:
        
        ++eHeader;
        --eSize;
        offset = cnvValueLengthToUint32( eHeader, &value, eSize);
        if (offset == NULL)
        {   
            result = FALSE;
            break;
        } 
        
        eSize -= (UINT32)(offset - eHeader);
        eHeader += value; 
        break;

        
    case MMS_WELL_KNOWN_CONTENT_BASE:
        ++eHeader;
        --eSize;
        
        for ( ; *eHeader; ++eHeader, --eSize)
        {
            if (eSize == 0)
            {   
                return FALSE;
            } 
        } 
        break;

    case MMS_WELL_KNOWN_CONTENT_ENCODING:
        ++eHeader;
        --eSize;
        if (eSize == 0)
        {
            result = FALSE;
        }
        else if (IS_SHORT_INTEGER(*eHeader))
        {   
            ++eHeader;
            --eSize;
        }
        else 
        {
            
            for ( ; *eHeader; ++eHeader, --eSize)
            {
                if (eSize == 0)
                {   
                    return FALSE;
                } 
            } 
        } 
        break;

        
    case MMS_WELL_KNOWN_CONTENT_LANGUAGE:
        ++eHeader;
        --eSize;
        if (eSize == 0)
        {
            result = FALSE;
        }
        
        else if (*eHeader == ANY_LANGUAGE_VALUE)
        {   
            ++eHeader; 
            --eSize;
        }
        
        else if (IS_SHORT_INTEGER(*eHeader))
        {   
            ++eHeader;
            --eSize;
        }
        
        else if (IS_LONG_INTEGER(*eHeader))
        {   
            offset = cnvLongIntegerToUint32( eHeader, &value, eSize);
            if (offset == NULL)
            {   
                result = FALSE;
                break;
            } 

            eSize -= (UINT32)(offset - eHeader);
            eHeader = offset; 
        }
        else 
        {
            
            for ( ; *eHeader; ++eHeader, --eSize)
            {
                if (eSize == 0)
                {   
                    return FALSE;
                } 
            } 
        } 
        break;

        
    case MMS_WELL_KNOWN_CONTENT_LENGTH:
        ++eHeader;
        --eSize;
        if (eSize == 0)
        {
            result = FALSE;
        }
        
        else if (IS_SHORT_INTEGER(*eHeader))
        {   
            ++eHeader;
            --eSize;
        }
        
        else if (IS_LONG_INTEGER(*eHeader))
        {   
            offset = cnvLongIntegerToUint32( eHeader, &value, eSize);
            if ( offset == NULL)
            {   
                result = FALSE;
                break;
            } 

            eSize -= (UINT32)(offset - eHeader);
            eHeader = offset; 
        }
        else
        {   
            result = FALSE;
        } 
        break;
        
    default:
        
        MMS_LOG_I(("%s(%d): Received an unknown well-known field name\n",
            __FILE__, __LINE__));
        result = FALSE;
        break;
    } 

    *entryHeader = eHeader;
    *size = eSize;

    return result;
} 















static unsigned char *splitAddressString(unsigned char *str, char **addr,
    char **text, MmsAddressType* adrType)
{
    unsigned char *lesser = NULL;   
    unsigned char *greater = NULL;  
    unsigned char *tmpPtr;  
    int lengthOfStr = 0;     
    int len;
    char *tptr;             
    unsigned char *commaPos = NULL;

    *addr = NULL; 
    *text = NULL; 
    *adrType = MMS_ADDRESS_UNKNOWN; 
    if (str == NULL)
    {
        MMS_LOG_I(("%s(%d): No memory allocated \n", __FILE__, __LINE__));

        return NULL; 
    } 

    tmpPtr = str; 
      
    while (*tmpPtr != '\0')
    {
        if (*tmpPtr == TOKEN_LESSER_THEN)
        {
            if (greater != NULL)  
            {
                MMS_LOG_I(("%s(%d): Incorrect address field. > before <.\n", 
                    __FILE__, __LINE__));
                return NULL; 
            } 

            lesser = tmpPtr; 
        }
        else if (*tmpPtr == TOKEN_GREATER_THEN)
        {
            if (lesser == NULL) 
            {
                MMS_LOG_I(("%s(%d): Incorrect address field. > before <.\n", 
                    __FILE__, __LINE__));
                return NULL; 
            } 

            greater = tmpPtr; 
        } 
        
        

        if (*tmpPtr == ',' && commaPos == NULL)
        {
            commaPos = tmpPtr + 1;
            while (IS_LWS(*commaPos))   
            {
                ++commaPos;
            } 
#ifdef MMS_ACCEPT_COMMA_SEPARATED_ADDRESSES
            break; 
#endif 
        } 

        ++tmpPtr; 
        ++lengthOfStr;
    }  

    
    if (lengthOfStr <= 0) 
    {
        MMS_LOG_I(("%s(%d): Address length is %d.\n", 
            __FILE__, __LINE__, lengthOfStr));
        return NULL; 
    }
    else if (lesser != NULL && greater == NULL)
    {
        MMS_LOG_I(("%s(%d): Address is missing >.\n", 
            __FILE__, __LINE__));
        return NULL; 
    }
    else if (lesser == NULL && greater != NULL)
    {
        MMS_LOG_I(("%s(%d): Address is missing <.\n", 
            __FILE__, __LINE__));
        return NULL; 
    }
    else if (lesser == NULL && greater == NULL) 
    {  
         
        *addr = (char *)M_CALLOC((UINT32)(lengthOfStr + 1));
        memcpy( *addr, str, (unsigned int)lengthOfStr);
        
        
   
        if ( (tptr = strstr(*addr, TYPE_PLMN)) != NULL)
        {
            *tptr = '\0'; 
            *adrType = MMS_ADDRESS_PLMN;
        }
        else if ( (tptr = strstr(*addr, TYPE_IPV4)) != NULL)
        {
           *tptr = '\0'; 
           *adrType = MMS_ADDRESS_IPV4;
        }
        else if ( (tptr = strstr(*addr, TYPE_EMAIL)) != NULL)
        {
           *tptr = '\0'; 
           *adrType = MMS_ADDRESS_EMAIL;
        }
        else if ( (tptr = strstr(*addr, TYPE_UNKNOWN)) != NULL)
        {
            MMS_LOG_I(("%s(%d): Unknown address type for %s.\n", 
                __FILE__, __LINE__, addr));
            M_FREE(*addr);
            *addr = NULL;
            return NULL;
        }
        else 
        {
           *adrType = MMS_ADDRESS_EMAIL;
        } 
    }
    else
    { 
        
        
        
           
        len = (int)(greater - lesser); 
        if (len > 1)    
        {  
            *addr = (char *)M_CALLOC((UINT32)len); 
            memcpy( *addr, lesser + 1, (UINT32)(len - 1)); 
        } 

         
        len = (int)(lesser - str); 
        if (len > 0)
        {
            *text = (char *)M_CALLOC((UINT32)(len + 1));
            memcpy( *text, str, (UINT32)len);           

             
            tptr = *text + len - 1;
            while (tptr >= *text && *tptr == ' ') 
            {
               *tptr = '\0';
               --tptr; 
            }  
        } 

        *adrType = MMS_ADDRESS_EMAIL;
    } 

#ifdef MMS_ACCEPT_COMMA_SEPARATED_ADDRESSES
    return commaPos; 
#else
    return NULL; 
#endif 
}