mcpdu.c

彩信MMS的全部代码

    case X_MMS_QUOTAS :
    case X_MMS_READ_REPLY :
    case X_MMS_READ_STATUS :
    case X_MMS_REPLY_CHARGING :
    case X_MMS_REPORT_ALLOWED :
    case X_MMS_RETRIEVE_STATUS :
    case X_MMS_SENDER_VISIBILITY :
    case X_MMS_STATUS :
    case X_MMS_STORE :
    case X_MMS_STORE_STATUS :
    case X_MMS_STORED :
    case X_MMS_TOTALS :
        *to = value.raw.aUint8;
        ++*length;
        break;
    case X_MMS_MM_STATE :
        *to = *value.raw.aUint8Ptr;
        ++*length;
        break;
    case X_MMS_ATTRIBUTES :
    case X_MMS_VERSION :
        *to = SET_HIGH_BIT(value.version);
        ++*length;
        break;
    
    case MMS_CONTENT :
    case MMS_ADDITIONAL_HEADERS :
        
    case APPLICATION_HEADER :
    default :
        MMS_LOG_I(("%s(%d): Can't append %d.\n", __FILE__, __LINE__, (int)tag));
        ret = FALSE;
        break;
    } 

    return ret;
} 














CMN_BOOL mmsPduExtractValue(unsigned char *pos, MmsHeaderTag tag, 
    MmsHeaderValue *value, unsigned long size)
{
    CMN_BOOL ret = TRUE;

    if (size <= 1)
    {
        MMS_LOG_I(("%s(%d): PDU end reached.\n", __FILE__, __LINE__));
        return FALSE;
    } 

    switch (tag)
    {
    case MMS_BCC :
    case MMS_CC :
    case MMS_CONTENT_TYPE :
    case MMS_FROM :
    case MMS_SUBJECT :
    case MMS_TO :
    case X_MMS_CONTENT_LOCATION :
    case X_MMS_DELIVERY_TIME :
    case X_MMS_ELEMENT_DESCRIPTOR :
    case X_MMS_EXPIRY :
    case X_MMS_MBOX_QUOTAS :
    case X_MMS_MBOX_TOTALS :
    case X_MMS_MESSAGE_CLASS :
    case X_MMS_MESSAGE_COUNT :
    case X_MMS_MM_FLAGS :
    case X_MMS_PREVIOUSLY_SENT_BY :
    case X_MMS_PREVIOUSLY_SENT_DATE :
    case X_MMS_REPLY_CHARGING_DEADLINE :
    case X_MMS_RESPONSE_STATUS :
    case X_MMS_RESPONSE_TEXT :
    case X_MMS_RETRIEVE_TEXT :
    case X_MMS_STORE_STATUS_TEXT :
        value->raw.aVoidPtr = ++pos;
        break;
    case MMS_MESSAGE_ID :
    case X_MMS_TRANSACTION_ID :
    case X_MMS_REPLY_CHARGING_ID :
        value->raw.aCharPtr = (char *)++pos;
        break;
    case X_MMS_ATTRIBUTES :
    case X_MMS_MM_STATE :
        value->raw.aUint8Ptr = (UINT8 *)++pos;
        break;
    case X_MMS_LIMIT :
    case X_MMS_START :
        if ( !cnvIntegerToUint32( ++pos, &value->raw.aUint32, size - 1) )
        {
            MMS_LOG_I(("%s(%d): UINT32 conversion failed (%d).\n", 
                __FILE__, __LINE__, tag));
            ret = FALSE;
        } 
        break;
    case MMS_DATE :
    case X_MMS_MESSAGE_SIZE :
    case X_MMS_REPLY_CHARGING_SIZE :
        if ( !cnvLongIntegerToUint32( ++pos, &value->raw.aUint32, size - 1) )
        {
            MMS_LOG_I(("%s(%d): UINT32 conversion failed (%d).\n", 
                __FILE__, __LINE__, tag));
            ret = FALSE;
        } 
        break;
    case X_MMS_DELIVERY_REPORT :
    case X_MMS_DISTRIBUTION_INDICATOR :
    case X_MMS_MESSAGE_TYPE :
    case X_MMS_PRIORITY :
    case X_MMS_QUOTAS :
    case X_MMS_READ_REPLY :
    case X_MMS_READ_STATUS :
    case X_MMS_REPLY_CHARGING :
    case X_MMS_REPORT_ALLOWED :
    case X_MMS_RETRIEVE_STATUS :
    case X_MMS_SENDER_VISIBILITY :
    case X_MMS_STATUS :
    case X_MMS_STORE :
    case X_MMS_STORE_STATUS :
    case X_MMS_STORED :
    case X_MMS_TOTALS :
        value->raw.aUint8 = *++pos;
        break;
    case X_MMS_VERSION :
        value->version = SKIP_HIGH_BIT(*++pos);
        break;
    case MMS_CONTENT :
        
        MMS_LOG_I(("%s(%d): Code is missing.\n", __FILE__, __LINE__));
        ret = FALSE;
        break;
    case MMS_ADDITIONAL_HEADERS :
        
        MMS_LOG_I(("%s(%d): Code is missing.\n", __FILE__, __LINE__));
        ret = FALSE;
        break;
    case APPLICATION_HEADER :
    default :
        ret = FALSE;
        break;
    } 

    return ret;
} 














CMN_BOOL mmsPduGet( void *header, unsigned long size, MmsHeaderTag tag, 
    MmsHeaderValue *value)
{
    unsigned char *offset = (unsigned char *)header;
    unsigned char *start = (unsigned char *)header;
    unsigned char searched = (unsigned char)(tag | 0x80);

    if (start == NULL)
    {
        return FALSE;
    } 

    

    if (tag == X_MMS_MESSAGE_TYPE)
    {
        if (SKIP_HIGH_BIT(*offset) == X_MMS_MESSAGE_TYPE && size > 1)
        {
            value->messageType = offset[1];

            return TRUE;
        } 

        return FALSE;
    } 
    
    while (offset != NULL && (unsigned long)(offset - start) < size)
    {
        
        if (searched != *offset)    
        {
            

            if (SKIP_HIGH_BIT(*offset) == MMS_CONTENT_TYPE)
            {
                return FALSE;
            } 

            offset = mmsPduNextTag( offset, (unsigned long)(start - offset) + size);
        }
        else                        
        {
            return mmsPduExtractValue( offset, tag, value, 
                (unsigned long)(start - offset) + size);
        } 
    } 

    return FALSE;
} 








void mmsPduGetMessageClass( void *header, unsigned long size, 
    MmsMessageClass *mc)
{
    MmsHeaderValue field;

    mc->classIdentifier = MMS_MESSAGE_CLASS_NOT_SET;
    mc->textString = NULL;
    if (mmsPduGet( header, size, X_MMS_MESSAGE_CLASS, &field))
    {
        if (*(unsigned char *)field.messageClass >= MMS_MESSAGE_CLASS_PERSONAL)
        {
            mc->classIdentifier = (MmsClassIdentifier) *(unsigned char *)field.messageClass;
        }
        else if (IS_TOKEN(*(unsigned char *)field.messageClass))
        {
            mc->classIdentifier = MMS_MESSAGE_CLASS_IS_TEXT;
            mc->textString = (char *)field.messageClass;
        } 
    } 
} 









unsigned char *mmsPduNextTag(unsigned char *pos, unsigned long length)
{
    unsigned char *startPos = pos;
    UINT32 aUint32;

    

    if (length < 2)
    {
        return NULL;
    } 

    if (*pos >= ALLOWED_STRING_CHAR_LIMIT)
    {
        
        ++pos;
    }
    else
    {
        
        pos = skipApplicationHeaderString( pos, 
            (unsigned long)(startPos - pos) + length);
        
        pos = mmsPduSkipString( pos, (unsigned long)(startPos - pos) + length);

        return pos;
    } 

    if (*pos < LENGTH_QUOTE)
    {
        
        if (*pos > length)
        {
            pos = NULL;
        }
        else
        {
            pos += *pos + 1;
        } 
    }
    else if (IS_LENGTH_QUOTE(*pos))
    {
        ++pos;  
        pos = (unsigned char *)cnvUintvarToUint32( pos, &aUint32, 
            (unsigned long)(startPos - pos) + length);

        
        if (pos == NULL)
        {
            return NULL;
        } 

        pos += aUint32;
        if (pos > (startPos + length))
        {
            return NULL;
        } 

        
        if ( *(pos - 1) != EOS )
        {
            return NULL;
        } 
    }
    else if (*pos < ALLOWED_STRING_CHAR_LIMIT)
    {
        pos = mmsPduSkipString( pos, (unsigned long)(startPos - pos) + length);
    }
    else
    {
        ++pos;
    } 

    return pos;
} 














CMN_BOOL mmsPduSanityCheck( void *data, unsigned long size)
{
    unsigned char *pdu = (unsigned char *)data;
    unsigned char *start = (unsigned char *)data;
    CMN_BOOL isHeader = TRUE;
#ifdef MMS_LOG_INTERNAL
    unsigned char tag = 0;
#endif 

    
    if (pdu == NULL || size < MIN_PDU_LENGTH)
    {
        MMS_LOG_I(("%s(%d): NULL pointer (%d) or size error (%lu) in PDU!\n", 
            __FILE__, __LINE__, pdu, size));
        return FALSE;
    } 

    
    if (SKIP_HIGH_BIT(pdu[0]) != X_MMS_MESSAGE_TYPE)
    {
        MMS_LOG_I(("%s(%d): TYPE error (%d) in PDU!\n", 
            __FILE__, __LINE__, (int)pdu[0]));
        return FALSE;
    } 

    


    while (pdu != NULL && isHeader && (unsigned long)(pdu - start) < size - 1)
    {
#ifdef MMS_LOG_INTERNAL
        tag = SKIP_HIGH_BIT(*pdu);
#endif 

        if (SKIP_HIGH_BIT(*pdu) == MMS_CONTENT_TYPE)
        {   
            ++pdu;
            pdu = skipContentType( pdu, (unsigned long)(start - pdu) + size);

            if (pdu != NULL)
            {
                isHeader = FALSE;
            } 
        }
        else
        {
            pdu = mmsPduNextTag( pdu, (unsigned long)(start - pdu) + size);
        } 
    } 

    if (pdu == NULL)
    {
        MMS_LOG_I(("%s(%d): TAG %d error in PDU!\n", __FILE__, __LINE__, tag));
        return FALSE;
    } 

    return TRUE;
} 










unsigned char *mmsPduSkipString(unsigned char *pos, unsigned long length)
{
    
    if (length == 0 || pos == NULL)
    {
        return NULL;
    } 

    
    while (--length && *++pos)
    {
        
    } 

    
    
    if (length > 0 && *pos == EOS)
    {
        ++pos;  
        return pos;
    } 

    MMS_LOG_I(("%s(%d): found no EOS within length.\n", __FILE__, __LINE__));

    return NULL;
} 
















CMN_BOOL mmsPduUnrecognized( void *data, unsigned long size)
{
    UINT32 strSize;
    UINT32 length;
    unsigned char *pdu = (unsigned char *)data;
    CMN_BOOL isUnrecognized = FALSE;
    MmsSigCohPostParam *post;
    MmsNotifyRespInd    notifyResp;
    MmsHeaderValue  ver;
    MmsHeaderValue  trId;

    trId.transactionId = TRANSACTION_ID_DEFAULT;
    ver.version = MMS_VERSION_PREVIOUS_MAJOR;

    if (pdu == NULL || size <= POS_TYPE_DATA ||
        SKIP_HIGH_BIT(pdu[POS_TYPE_TAG]) != X_MMS_MESSAGE_TYPE )
    {
        MMS_LOG_I(("%s(%d): PDU is invalid, size=%lu, data=0x%x\n", 
            __FILE__, __LINE__, size, pdu == NULL ? 0 : pdu[POS_TYPE_TAG]));
        isUnrecognized = TRUE;
    }
    else if ( !mmsPduGet( data, size, X_MMS_VERSION, &ver) )
    {
        MMS_LOG_I(("%s(%d): No X_MMS_VERSION header tag\n", 
            __FILE__, __LINE__));
        isUnrecognized = TRUE;
    }
    else
    {
        switch (pdu[POS_TYPE_DATA])
        {
        case MMS_M_SEND_CONF :
        case MMS_M_NOTIFICATION_IND :
        case MMS_M_FORWARD_CONF :
        case MMS_M_MBOX_STORE_CONF :
        case MMS_M_MBOX_VIEW_CONF :
        case MMS_M_MBOX_UPLOAD_CONF :
        case MMS_M_MBOX_DELETE_CONF :
            if ( !mmsPduGet( data, size, X_MMS_TRANSACTION_ID, &trId))
            {
                trId.transactionId = TRANSACTION_ID_DEFAULT;
                MMS_LOG_I(("%s(%d): Mandatory field X-Mms-Transaction-ID is missing\n",
                    __FILE__, __LINE__));
                isUnrecognized = TRUE;
            } 
            break;
        case MMS_M_RETRIEVE_CONF :
        case MMS_M_DELIVERY_IND :
        case MMS_M_READ_ORIG_IND :
        case MMS_M_MBOX_DESCR :
            
            break;
        case MMS_M_SEND_REQ :
        case MMS_M_NOTIFY_RESP :
        case MMS_M_ACKNOWLEDGE_IND :
        case MMS_M_READ_REC_IND :
        case MMS_M_FORWARD_REQ :
        case MMS_M_MBOX_STORE_REQ :
        case MMS_M_MBOX_VIEW_REQ :
        case MMS_M_MBOX_UPLOAD_REQ :
        case MMS_M_MBOX_DELETE_REQ :
        default :
            MMS_LOG_I(("%s(%d): This PDU shouldn't be sent to a client 0x%x\n",
                __FILE__, __LINE__, pdu[POS_TYPE_DATA]));
            isUnrecognized = TRUE;
            break;
        } 
    } 

    if (isUnrecognized || 
        ver.version <= MMS_VERSION_PREVIOUS_MAJOR ||
        ver.version >= MMS_VERSION_NEXT_MAJOR)
    {
        strSize = strlen(trId.transactionId) + 1;
        if (strSize <= MMS_MAX_CHUNK_SIZE)
        {
            
            notifyResp.transactionId = trId.transactionId;
            notifyResp.status = MMS_STATUS_UNRECOGNIZED;
            notifyResp.allowed = MMS_DELIVERY_REPORT_NOT_SET;

            post = (MmsSigCohPostParam *)M_CALLOC(sizeof(MmsSigCohPostParam));
            post->isResponseRequested = FALSE;
            post->type = MMS_M_NOTIFY_RESP; 
            post->data.pdu.packet = createWspNotifyRespIndMsg( &notifyResp, 
                &length, MMS_VERSION_10);   
            post->data.pdu.length = length;

            if (post->data.pdu.packet == NULL)
            {
                MMS_LOG_I(("%s(%d): Couldn't create M-NotifyResp.ind!\n",
                    __FILE__, __LINE__));
                M_FREE(post);
            }
            else
            {
                M_SIGNAL_SENDTO_IUUP( M_FSM_COH_POST, MMS_SIG_COH_POST, 0, 0, 
                    0, post); 
            } 

            isUnrecognized = TRUE;
        } 
    } 

    return isUnrecognized;
} 














static unsigned char *skipApplicationHeaderString(unsigned char *pos, 
    unsigned long length)
{
    
    if (length == 0 || pos == NULL)
    {
        return NULL;
    } 

    
    while (length > 0 && IS_APPLICATION_HEADER(*pos))
    {
        ++pos;
        --length;
    } 

    
    if (length > 0 && *pos == EOS)
    {
        ++pos;  
        return pos;
    } 

    MMS_LOG_I(("COH: skipApplicationHeaderString found 0x%02x at %lu\n", 
        *pos, length));

    return NULL;
} 














static unsigned char *skipContentType(unsigned char *pos, unsigned long length)
{
    unsigned char *startPos = pos;
    UINT32  valueLen;

    
    if (length == 0)
    {
        return NULL;
    } 

    
    if (*pos <= LENGTH_QUOTE)   
    {                           
        
        if ( (pos = (unsigned char *)cnvValueLengthToUint32( pos, 
            &valueLen, length)) == NULL)
        {
            return NULL;
        } 

        pos += valueLen;
    }                           
    else if (*pos & SHORT_FLAG) 
    {                           
        ++pos;
    }
    else                        
    {                   
        pos = mmsPduSkipString( pos, length);
    } 

    return (pos == NULL) || (pos > startPos + length) ? NULL : pos;
}