mmpduc.c

彩信MMS的全部代码

   
    if (header->readReply != MMS_READ_REPLY_NOT_SET)
    {
        valueOfTag.readReply = (UINT8)header->readReply;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_READ_REPLY, 
            sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Read-Reply\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(pduHeader);
            return NULL;    
        }  
    }    
 
    


    
    if (version >= MMS_VERSION_11 && header->replyChargingId != NULL)
    {
        valueOfTag.replyChargingId = header->replyChargingId;
        if (!mmsPduAppend(pduHeader, bufSize, &actLength, X_MMS_REPLY_CHARGING_ID, 
            strlen(valueOfTag.replyChargingId) + 1, valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Reply-Charging-Id\n",
                __FILE__, __LINE__));
            M_FREE(pduHeader); 
            return NULL;    
        }  
    } 
    if (version >= MMS_VERSION_11 && 
        header->replyCharging != MMS_REPLY_CHARGING_NOT_SET)
    {
        
        valueOfTag.replyCharging = (UINT8)header->replyCharging;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_REPLY_CHARGING, 
            sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Read-Reply\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(pduHeader);
            return NULL;    
        }  
        
        
        if (header->replyChargingDeadline.sec > 0)
        {
            if ((codedValue = createTimeField(&size, 
                &header->replyChargingDeadline)) == NULL)
            {
                MMS_LOG_I(("%s(%d): X-Mms-Reply-Charging-Deadline"
                    "conversion failed.\n", __FILE__, __LINE__));
                *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
                M_FREE(pduHeader);
                M_FREE(codedValue);
                return NULL;    
            }  
        
            valueOfTag.replyChargingDeadline = codedValue;
            if (!mmsPduAppend( pduHeader, bufSize, &actLength, 
                X_MMS_REPLY_CHARGING_DEADLINE, size, valueOfTag))
            {
                MMS_LOG_I(("%s(%d): Error in X-Mms-Reply-Charging-Deadline\n",
                    __FILE__, __LINE__));
                *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
                M_FREE(pduHeader);
                M_FREE(codedValue);
                return NULL;    
            } 

            M_FREE(codedValue);
            codedValue = NULL;
        } 

        
        if (header->replyChargingSize > 0)
        {
            valueOfTag.replyChargingSize = header->replyChargingSize;
            if (!mmsPduAppend( pduHeader, bufSize, &actLength,
                X_MMS_REPLY_CHARGING_SIZE, sizeof(UINT32), valueOfTag))
            { 
                MMS_LOG_I(("%s(%d): Error in X-Mms-Reply-Charging-Size\n",
                    __FILE__, __LINE__));
                *result = MMS_RESULT_ERROR_CREATING_FORWARD;
                M_FREE(pduHeader);
                return NULL;    
            }  
        }  
    } 

    


    if (header->contentType != NULL)
    {
        if ((codedValue = (unsigned char *)createContentType(
            (UINT32 *)&size, header->contentType)) == NULL)
        {
            MMS_LOG_I(("%s(%d): Content-Type conversion failed.\n",
                __FILE__, __LINE__));
            *result = MMS_RESULT_INVALID_CONTENT_TYPE;
            M_FREE(pduHeader);
            return NULL;   
        }  
    
        valueOfTag.contentType = codedValue;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, MMS_CONTENT_TYPE, 
            size, valueOfTag))
        {
            MMS_LOG_I(("%s(%d): Error appending Content-Type\n", __FILE__, __LINE__));
            *result = MMS_RESULT_ERROR_CREATING_SEND_HEADER;
            M_FREE(pduHeader);
            return NULL;   
        } 

        M_FREE(codedValue);
        codedValue = NULL;
    } 

    


    if ( isMultiPart( header->contentType->knownValue))
    {
        
        if ( (offset = cnvUint32ToUintvar( numOfBodyParts, nEntries,
            MAX_UINTVAR_SIZE)) == NULL)
        {
            MMS_LOG_I(("%s(%d): Conversion to uintvar failed %d.\n",
                __FILE__, __LINE__, numOfBodyParts));
        }
        else
        {
            
            memcpy( &pduHeader[actLength], nEntries, (UINT32)(offset - nEntries));
            actLength += (UINT32)(offset - nEntries);
        } 
    }  

    *length = (UINT32)actLength; 
    return pduHeader;
} 










unsigned char *createWspNotifyRespIndMsg(const MmsNotifyRespInd *header,
    UINT32 *length, MmsVersion version)
{ 
    unsigned char *pduHeader;  
    unsigned long bufSize = 0; 
    MmsHeaderValue valueOfTag;  
    unsigned long actLength = 0;     

    *length = 0;
    if (header->transactionId == NULL || strlen( (char *)header->transactionId) < 1)
    {
        MMS_LOG_I(("%s(%d): Transaction ID mandatory.\n", __FILE__, __LINE__));

        return NULL;
    } 

    
    
    bufSize += TAG_SIZE + sizeof(MmsMessageType);           
    bufSize += TAG_SIZE + 
        strlen((char *)header->transactionId) + 1;          
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + sizeof(UINT8);                     
    bufSize += TAG_SIZE + sizeof(UINT8);                    
   
    pduHeader = (unsigned char *)M_CALLOC((unsigned int)bufSize);
     
     
    valueOfTag.messageType = (UINT8)MMS_M_NOTIFY_RESP;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_MESSAGE_TYPE,
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Message-Type\n", __FILE__, __LINE__));
        M_FREE(pduHeader);
        pduHeader = NULL;
        return NULL;    
    }  

      
    valueOfTag.transactionId = header->transactionId;
    if (!mmsPduAppend(pduHeader, bufSize, &actLength, X_MMS_TRANSACTION_ID, 
        strlen(valueOfTag.transactionId) + 1, valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Transaction-Id\n", __FILE__, __LINE__));
        M_FREE(pduHeader); 
        pduHeader = NULL;
        return NULL;    
    }  
     
     
    valueOfTag.version = (unsigned char)version;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_VERSION, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Version\n", __FILE__, __LINE__));
        M_FREE(pduHeader); 
        pduHeader = NULL;
        return NULL;    
    }  

     
    valueOfTag.priority = (UINT8)header->status;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_STATUS, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Status\n", __FILE__, __LINE__));
        M_FREE(pduHeader);
        pduHeader = NULL;
        return NULL;    
    }  
 
    if (header->allowed != MMS_DELIVERY_REPORT_NOT_SET)
    {
         
        valueOfTag.reportAllowed = (UINT8)header->allowed;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_REPORT_ALLOWED, 
            sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Report-Allowed\n", __FILE__, __LINE__));
            M_FREE(pduHeader);
            pduHeader = NULL;
            return NULL;    
        }  
    } 

    *length = (UINT32)actLength; 
    return pduHeader;   
}  
   











unsigned char *createWspAcknowledgeIndMsg(const MmsAcknowledgeInd *header,
    UINT32 *length, MmsVersion version) 
{
    unsigned char *pduHeader;  
    unsigned long bufSize = 0; 
    MmsHeaderValue valueOfTag;  
    unsigned long actLength = 0;  

     
    
    bufSize += TAG_SIZE + sizeof(MmsMessageType);           
    bufSize += TAG_SIZE + 
        strlen((char *)header->transactionId) + 1;          
    bufSize += TAG_SIZE + sizeof(UINT8);                    
    bufSize += TAG_SIZE + sizeof(UINT8);                    
   
    pduHeader = (unsigned char *)M_CALLOC((unsigned int)bufSize);

      
    valueOfTag.messageType = (UINT8)MMS_M_ACKNOWLEDGE_IND;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_MESSAGE_TYPE,
        sizeof(UINT8), valueOfTag)) 
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Message-Type\n", __FILE__, __LINE__));
        M_FREE(pduHeader);
        pduHeader = NULL;
        return NULL;    
    }  

      
    valueOfTag.transactionId = header->transactionId;
    if (!mmsPduAppend(pduHeader, bufSize, &actLength, X_MMS_TRANSACTION_ID, 
        strlen(valueOfTag.transactionId) + 1, valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Transaction-Id\n", __FILE__, __LINE__));
        M_FREE(pduHeader); 
        pduHeader = NULL;
        return NULL;    
    }  
     
     
    valueOfTag.version = (unsigned char)version;
    if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_VERSION, 
        sizeof(UINT8), valueOfTag))
    { 
        MMS_LOG_I(("%s(%d): Error in X-Mms-Version\n", __FILE__, __LINE__));
        M_FREE(pduHeader); 
        pduHeader = NULL;
        return NULL;    
    }  

    
    if ( (MmsDeliveryReport)header->allowed != MMS_DELIVERY_REPORT_NOT_SET)
    {
        valueOfTag.reportAllowed = (UINT8)header->allowed;
        if (!mmsPduAppend( pduHeader, bufSize, &actLength, X_MMS_REPORT_ALLOWED, 
            sizeof(UINT8), valueOfTag))
        { 
            MMS_LOG_I(("%s(%d): Error in X-Mms-Report-Allowed\n",
                __FILE__, __LINE__));
            M_FREE(pduHeader);
            pduHeader = NULL;
            return NULL;    
        }  
    }  

    *length = (UINT32)actLength; 
    return pduHeader;    
}  










unsigned char *createWspBodyPartHead( const MmsSetBodyParams *dataValues, 
    UINT32 *length, UINT32 numOfSubEntries, MmsResult *result)
{
    UINT32 sizeOfContentType;
    UINT32 maxSize;
    INT32 headersLen;
    unsigned char *tmpPtr;    
    unsigned char *offset;
    unsigned char *pduData;
    unsigned char *contentTypeData;
    UINT32 dataSize;
    
    *length = 0;

    
    headersLen = calculateEntryHeadersSize( dataValues->entryHeader);    
    if ( headersLen < 0 || 
        validateEntryHeaders( dataValues->entryHeader, result) == FALSE)
    {
        MMS_LOG_I(("%s(%d): Invalid entry headers %d %d\n", 
            __FILE__, __LINE__, headersLen, (int)*result));
        return NULL;
    } 

    
    if ( (contentTypeData = createContentType( &sizeOfContentType, 
        &dataValues->contentType)) == NULL)
    {
        MMS_LOG_I(("%s(%d): Error creating contentType\n", __FILE__, __LINE__));
        return NULL;
    } 

    
    maxSize = MAX_UINTVAR_SIZE +        
        MAX_UINTVAR_SIZE +              
        MAX_UINTVAR_SIZE +              
        (UINT32)headersLen + sizeOfContentType; 

    pduData = M_CALLOC(maxSize);
    offset = pduData;

    
    tmpPtr = cnvUint32ToUintvar( sizeOfContentType + (UINT32)headersLen, offset,
        maxSize - *length);
    *length += (unsigned long)(tmpPtr - offset);
    offset = tmpPtr;

    
    if ( dataValues->bodyPart.storageType == MMS_BODY_PART_AS_BUFFER)
    {
        dataSize = dataValues->bodyPart.dataSize;
    }
    else 
    {
        
        dataSize = (UINT32)FILEa_getSize( dataValues->bodyPart.data.file.category,
            dataValues->bodyPart.data.file.id);
        if (isMultiPart(dataValues->contentType.knownValue))
        {  

            dataSize -= sizeof(UINT32); 
        } 
    } 

    tmpPtr = cnvUint32ToUintvar( dataSize, offset, maxSize - *length);
    *length += (unsigned long)(tmpPtr - offset);
    offset = tmpPtr;
    
    
    memcpy( offset, contentTypeData, sizeOfContentType);
    offset += sizeOfContentType;
    *length += sizeOfContentType;
    M_FREE( contentTypeData);
    contentTypeData = NULL;
        
    
    if (dataValues->entryHeader != NULL)
    {
        offset = createEntryHeaders( dataValues->entryHeader, offset, 
            (int)(maxSize - *length));
    } 

    



    if (numOfSubEntries != 0)
    {
        tmpPtr = cnvUint32ToUintvar( numOfSubEntries, offset, 
            maxSize - *length);
        *length += (unsigned long)(tmpPtr - offset);
        offset = tmpPtr; 
    } 

    if (offset != NULL)
    {
        *length = (unsigned long)(offset - pduData);
    }
    else
    {
        
        *length = 0;
        M_FREE(pduData);
        pduData = NULL;
        MMS_LOG_I(("%s(%d): Error creating entry headers\n", __FILE__, __LINE__));
    } 

    return pduData;   
} 










unsigned char *createWspForward( const MmsForward *header, char *contentLocation, 
    UINT32 *length, MmsResult *result, unsigned char version)
{    
    unsigned char *pduHeader = NULL;    
    char          *transactionId = NULL; 
    unsigned long transactionIdLen = 0; 
    unsigned long actLength = 0;         
    unsigned long bufSize = 0;          
    unsigned long fromSize = 0;
    unsigned long size = 0;
    unsigned long ctLen = 0;            
    unsigned char *codedValue = NULL;   
    unsigned char *from = NULL; 
    MmsHeaderValue valueOfTag;