mmpdup.c

彩信MMS的全部代码

        MMS_LOG_I(("%s(%d): Unable to parse TO in delivery report.",
            __FILE__, __LINE__));
    }
    else
    {
        mmsDelivery->to->name = tmpTo->current.name;
        mmsDelivery->to->address = tmpTo->current.address;
        mmsDelivery->to->addrType = tmpTo->current.addrType;
        M_FREE( tmpTo); 
        tmpTo = NULL;
    } 

    
    if (mmsPduGet( headerData, headerDataSize, MMS_DATE, &headerValue))
    {
        mmsDelivery->date = headerValue.date;
    } 
  
    
 
    if (mmsPduGet( headerData, headerDataSize, X_MMS_STATUS, &headerValue))
    {
        switch (headerValue.status)
        {
        case MMS_STATUS_EXPIRED: 
           mmsDelivery->status = MMS_STATUS_EXPIRED;
           break;
        case MMS_STATUS_RETRIEVED: 
           mmsDelivery->status = MMS_STATUS_RETRIEVED;
           break;
        case MMS_STATUS_REJECTED:     
           mmsDelivery->status = MMS_STATUS_REJECTED;
           break;
        case MMS_STATUS_DEFERRED:     
           mmsDelivery->status = MMS_STATUS_DEFERRED;
           break;
        case MMS_STATUS_INDETERMINATE:     
            mmsDelivery->status = MMS_STATUS_INDETERMINATE;
            break;
        case MMS_STATUS_FORWARDED:     
            mmsDelivery->status = MMS_STATUS_FORWARDED;
            break;
        case MMS_STATUS_UNRECOGNIZED: 
        default: 
           mmsDelivery->status = MMS_STATUS_UNRECOGNIZED;
        } 
    } 
} 











MmsResult parseMmsHeader(unsigned char *headerData, UINT32 headerDataSize, 
    MmsHeader *mmsHeader, MmsVersion *version)
{
    MmsHeaderValue  headerValue;
    UINT32 size;
    UINT32 tempLen = 0;
    unsigned char *p = NULL;
    MmsPrevSentBy *currentSentBy = NULL;
    MmsPrevSentDate *currentSentDate = NULL;
    
    
    memset( mmsHeader, 0, sizeof(MmsHeader));
    mmsHeader->priority = MMS_PRIORITY_NOT_SET;
    mmsHeader->visibility = MMS_SENDER_VISIBILITY_NOT_SET;
    mmsHeader->readReply = MMS_READ_REPLY_NOT_SET;
    mmsHeader->msgClass.classIdentifier = MMS_MESSAGE_CLASS_NOT_SET;
    mmsHeader->msgClass.textString      = NULL;
    mmsHeader->previouslySentBy         = NULL;
    mmsHeader->previouslySentDate       = NULL;
    mmsHeader->replyChargingId          = NULL;

    parseFromAddress(headerData, headerDataSize, &mmsHeader->from); 
    mmsHeader->to = parseAddress(MMS_TO, headerData, headerDataSize); 
    mmsHeader->cc = parseAddress(MMS_CC, headerData, headerDataSize); 
    mmsHeader->bcc = parseAddress(MMS_BCC, headerData, headerDataSize);

    
    if (mmsPduGet( headerData, headerDataSize, MMS_SUBJECT, &headerValue))
    {
        UINT32 notUsed = 0; 
        size = (UINT32)(headerData - (unsigned char *)headerValue.subject) + 
            headerDataSize;

        parseEncodedStringValue( headerValue.subject, size, &notUsed, 
            &mmsHeader->subject);
    }   

    
    if (mmsPduGet( headerData, headerDataSize, MMS_DATE, &headerValue))
    {
        mmsHeader->date = headerValue.date;
    } 

    
    if (mmsPduGet(headerData, headerDataSize, MMS_CONTENT_TYPE, &headerValue))
    {
        size = (UINT32)(headerData - (unsigned char *)headerValue.contentType) + 
            headerDataSize;
        if (parseContentType( &mmsHeader->contentType, 
            (unsigned char *)headerValue.contentType, size) == NULL)
        {
            
            MMS_LOG_I(("parseMmsHeader: Invalid content type.\n"));
            return MMS_RESULT_INVALID_CONTENT_TYPE;
        } 
    } 
    else
    {
        
        MMS_LOG_I(("parseMmsHeader: Invalid content type.\n"));
        return MMS_RESULT_INVALID_CONTENT_TYPE;
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_MESSAGE_CLASS, &headerValue))
    {
        MmsMessageClass mc;

        mmsPduGetMessageClass( headerData, headerDataSize, &mc);
        switch (mc.classIdentifier)
        {
        case MMS_MESSAGE_CLASS_PERSONAL :
        case MMS_MESSAGE_CLASS_ADVERTISEMENT :
        case MMS_MESSAGE_CLASS_INFORMATIONAL :
        case MMS_MESSAGE_CLASS_AUTO :
            mmsHeader->msgClass.classIdentifier = mc.classIdentifier;
            mmsHeader->msgClass.textString      = NULL;
            break;
        case MMS_MESSAGE_CLASS_IS_TEXT:
            if (mc.textString != NULL)
            {
                tempLen = strlen(mc.textString) + 1;
                mmsHeader->msgClass.textString = M_CALLOC(tempLen);
                mmsHeader->msgClass.classIdentifier = MMS_MESSAGE_CLASS_IS_TEXT;
                strcpy(mmsHeader->msgClass.textString, mc.textString);
            } 
            break;
        case MMS_MESSAGE_CLASS_NOT_SET : 
        default :
            mmsHeader->msgClass.classIdentifier = MMS_MESSAGE_CLASS_NOT_SET;
            mmsHeader->msgClass.textString      = NULL;
            break;
        } 
    } 

    
    if ( !parseHeaderTime(headerData, headerDataSize, &mmsHeader->expiryTime, 
        X_MMS_EXPIRY))
    {
        
    } 

    
    if ( !parseHeaderTime(headerData, headerDataSize, &mmsHeader->deliveryTime, 
        X_MMS_DELIVERY_TIME))
    {
        
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_PRIORITY, &headerValue))
    {
        mmsHeader->priority = (MmsPriority)headerValue.priority;
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_SENDER_VISIBILITY,
        &headerValue))
    {
        mmsHeader->visibility = (MmsSenderVisibility)headerValue.senderVisibility;
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_READ_REPLY, &headerValue))
    {
        mmsHeader->readReply = (MmsReadReply)headerValue.readReply;
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_DELIVERY_REPORT, &headerValue))
    {
        mmsHeader->deliveryReport = (MmsDeliveryReport)headerValue.deliveryReport;
    } 
    
    
    if (mmsPduGet( headerData, headerDataSize, MMS_MESSAGE_ID, &headerValue))
    {
        if (headerValue.messageId != NULL)
        {
            tempLen = strlen((const char *)headerValue.messageId) + 1;
            mmsHeader->serverMessageId = M_ALLOC(tempLen);
            strcpy( mmsHeader->serverMessageId, headerValue.messageId);
        } 
    } 
    else
    {
        mmsHeader->serverMessageId = NULL;   
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_VERSION, &headerValue))
    {
        *version = (MmsVersion)headerValue.version;
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_REPLY_CHARGING, &headerValue))
    {
        mmsHeader->replyCharging = (MmsReplyCharging)headerValue.replyCharging;

        
        if ( !parseHeaderTime(headerData, headerDataSize, 
            &mmsHeader->replyChargingDeadline, X_MMS_REPLY_CHARGING_DEADLINE))
        {
            
        } 

        
        if (mmsPduGet(headerData, headerDataSize, X_MMS_REPLY_CHARGING_ID, 
            &headerValue))
        {
            tempLen = strlen((const char *)headerValue.replyChargingId) + 1;
            mmsHeader->replyChargingId = M_ALLOC( tempLen);
            strcpy(mmsHeader->replyChargingId, headerValue.replyChargingId);
        } 
        else
        {
            mmsHeader->replyChargingId = NULL;
        } 

        
        if (mmsPduGet(headerData, headerDataSize, 
            X_MMS_REPLY_CHARGING_SIZE, &headerValue))
        {
            mmsHeader->replyChargingSize = headerValue.replyChargingSize;
        } 
    } 
    else
    {
        mmsHeader->replyCharging = MMS_REPLY_CHARGING_NOT_SET;  
    } 

    
    p = headerData;
    size = headerDataSize;
    while (p != NULL && (UINT32)(p - headerData) < headerDataSize)
    {
        if (mmsPduGet(p, headerDataSize, X_MMS_PREVIOUSLY_SENT_BY, &headerValue))
        {
            if (p == headerData)
            {
                mmsHeader->previouslySentBy = M_CALLOC(sizeof(MmsPrevSentBy));
                currentSentBy = mmsHeader->previouslySentBy;
                currentSentBy->next = NULL;
            }
            else if (currentSentBy != NULL)
            {
                currentSentBy->next = M_CALLOC(sizeof(MmsPrevSentBy));
                currentSentBy = currentSentBy->next;
                currentSentBy->next = NULL;
            } 

            p = getPrevSentBy((char *)headerValue.previouslySentBy, 
                currentSentBy, (UINT32)((unsigned char *)headerValue.previouslySentBy - 
                headerData));
            if (p != NULL)
            {
                ++p;    
                size = headerDataSize - (UINT32)(p - headerData);
            } 
        } 
        else 
        {
            p = NULL;
        } 
    } 

    
    p = headerData;
    while (p != NULL && (UINT32)(p - headerData) < headerDataSize)
    {
        if (mmsPduGet(p, headerDataSize, X_MMS_PREVIOUSLY_SENT_DATE, &headerValue))
        {
            if (p == headerData)
            {
                mmsHeader->previouslySentDate = M_CALLOC(sizeof(MmsPrevSentDate));
                currentSentDate = mmsHeader->previouslySentDate;
                currentSentDate->next = NULL;
            }
            else if (currentSentDate != NULL)
            {
                currentSentDate->next = M_CALLOC(sizeof(MmsPrevSentDate));
                currentSentDate = currentSentDate ->next;
                currentSentDate->next = NULL;
            } 

            p = getPrevSentDate((char *)headerValue.previouslySentDate, 
                currentSentDate, 
                (UINT32)((unsigned char *)headerValue.previouslySentDate - headerData));
        } 
        else
        {
            p = NULL;   
        } 
    } 

    
    if (mmsPduGet(headerData, headerDataSize, X_MMS_DISTRIBUTION_INDICATOR, 
        &headerValue))
    {
        mmsHeader->distributionIndicator = 
            (MmsDistributionIndicator)headerValue.distributionIndicator;
    } 

    return MMS_RESULT_OK;
} 









static unsigned char *getPrevSentBy(char *buf, MmsPrevSentBy *prevSentBy, 
    UINT32 bufLen)
{
    UINT32 length = 0;
    unsigned char *p = NULL;
    unsigned char count;
    long size = 0;

    if (buf == NULL || prevSentBy == NULL)
    {
        MMS_LOG_I(("%s(%d): getPrevSentBy Indata was NULL.",
            __FILE__, __LINE__));
        return NULL;
    } 

    p = cnvValueLengthToUint32(buf, &length, bufLen);
    if (p == NULL || length > bufLen)
    {
        MMS_LOG_I(("%s(%d): Illegal data %lu, %lu.", __FILE__, __LINE__,
            length, bufLen));
        return NULL;
    }
    else if (IS_SHORT_INTEGER(*p))
    {
        p = cnvShortIntegerToUchar( p, &count, bufLen - length);
        prevSentBy->forwardedCountValue = count;
    }
    else
    {   
        p = cnvLongIntegerToUint32( p, &prevSentBy->forwardedCountValue, 
            bufLen - length);
    } 

    size = (long)bufLen - (long)((char *)p - buf);
    if (p == NULL || size < 0)
    {
        MMS_LOG_I(("%s(%d): Illegal data %ld.", __FILE__, __LINE__, size));
        return NULL;
    } 

    (void)parseOneAddress( p, (UINT32)size, &prevSentBy->sentBy); 
    length = cmnStrnlen((const char *)p, (unsigned long)size);
    p += length;    
    
    return p;
} 









static unsigned char *getPrevSentDate(char *buf, MmsPrevSentDate *prevSentDate,
    UINT32 bufLen)
{
    UINT32 length = 0;
    unsigned char *p = NULL;
    long size = 0;

    if (buf == NULL || prevSentDate == NULL)
    {
        MMS_LOG_I(("%s(%d): getPrevSentDate Indata was NULL.",
            __FILE__, __LINE__));
        return NULL;
    } 

    p = cnvValueLengthToUint32(buf, &length, bufLen);
    if (p == NULL || length > bufLen)
    {
        MMS_LOG_I(("%s(%d): Illegal data %lu, %lu.", __FILE__, __LINE__,
            length, bufLen));
        return NULL;
    }
    else if (*p >= 128)
    {  
        p = cnvShortIntegerToUchar( p, 
            (unsigned char *)&prevSentDate->forwardedCountValue, 
            bufLen - length);
    }
    else
    {   
        p = cnvLongIntegerToUint32( p, &prevSentDate->forwardedCountValue, 
            bufLen - length);
    } 
    
    size = (long)bufLen - (long)((char *)p - buf);
    if (p == NULL || size < 0)
    {
        MMS_LOG_I(("%s(%d): Illegal data %ld.", __FILE__, __LINE__, size));
        return NULL;
    } 

    
    p = cnvLongIntegerToUint32( p, &prevSentDate->date, (UINT32)size);
    
    return p;
}