mfieldc.c

彩信MMS的全部代码

unsigned char *createTimeField(unsigned long *size, const MmsTime *theTime)
{ 
    unsigned char *value;
    unsigned char *to;
    unsigned char *pos;
    unsigned char cnvTime[ENCODED_DATE_LEN]; 
    INT32 consumedBytes = 0;

    *size = 0L;
    to = cnvTime;

    
    *to++ = SET_HIGH_BIT(theTime->type);

     
    to = cnvUint32ToLongInteger( theTime->sec, to, sizeof(cnvTime) - 1);
    if (to == NULL)
    {                     
        MMS_LOG_I(("%s(%d): time conversion failed.\n", 
            __FILE__, __LINE__));
        return NULL;
    } 

     
    consumedBytes = to - cnvTime;
    if (consumedBytes <= 0 || consumedBytes > (INT32)sizeof(cnvTime))
    {
        MMS_LOG_I(("%s(%d): Date larger than reserved space.\n", 
            __FILE__, __LINE__));
        return NULL;
    } 

    value = M_ALLOC(ENCODED_DATE_LEN);
         
    if ((pos = cnvUint32ToValueLength((UINT32)consumedBytes, value, 
        ENCODED_DATE_LEN)) == NULL)
    {
        MMS_LOG_I(("%s(%d): Value length conversion for time failed.\n", 
            __FILE__, __LINE__));
        M_FREE(value);
        value = NULL;
        return NULL;
    } 

    *size = (UINT32)consumedBytes + (unsigned long)(pos - value);
    if ((UINT32)(pos - value) - (UINT32)consumedBytes > 0) 
    {
        memcpy( pos, cnvTime, (UINT32)consumedBytes);   
    }
    else
    {
        MMS_LOG_I(("%s(%d): Final conversion for time failed.\n", 
            __FILE__, __LINE__));
        M_FREE (value); 
        value = NULL;
    }  

    return value; 
} 














CMN_BOOL createEncodedStringValue( const char *text, CmnCharset charset, 
    unsigned long *size, unsigned char **retPtr)
{
    CMN_BOOL ret;
    unsigned  maxDataSize;
    unsigned long sizeWritten;
    UINT32 dataSize;
    unsigned char *ptr;
    unsigned char *pTmp;

    sizeWritten = 0;
    
    
    maxDataSize = getSizeOfText(text) + 1 + MAX_VALUE_LENGTH_SIZE + UTF8_SIZE; 

    ptr = M_CALLOC(maxDataSize);
    *retPtr = ptr;
    *size = 0;

    switch (charset)
    {
    case CMN_CHARSET_US_ASCII:
        
        if (text[0] & QUOTE_REQUIRED)
        {
            *ptr = TEXT_QUOTE;
            ++ptr;
        } 

        strcpy( (char *)ptr, text);
        sizeWritten = getSizeOfText(text) + 1;
        ret = TRUE;
        break;
    case CMN_CHARSET_UTF_8:
        dataSize = getSizeOfText(text) + 1 + 1; 

        pTmp = ptr;
        ptr = cnvUint32ToValueLength( dataSize, (void *)ptr, maxDataSize);
        
        
        sizeWritten = (unsigned long)(ptr - pTmp); 

        
        *ptr++ = (CMN_CHARSET_UTF_8 | 0x80);  

        
        if (text[0] & QUOTE_REQUIRED)
        {
            *ptr = TEXT_QUOTE;
            ++ptr;
        } 
        
        strcpy( (char *)ptr, text);
        sizeWritten += dataSize; 
        ret = TRUE;
        break;
    
    case CMN_CHARSET_UTF_16BE:
    case CMN_CHARSET_UTF_16LE:
    case CMN_CHARSET_UTF_16:
    case CMN_CHARSET_UNKNOWN:
    case CMN_CHARSET_ISO_8859_1:
    case CMN_CHARSET_UCS_2:
    default :
        MMS_LOG_I(("%s(%d): invalid charset\n", __FILE__, __LINE__));
        ret = FALSE;
        break;
    } 
        
    *size = sizeWritten;
    return ret;
} 







void calculateSize( const MmsContentType *contentInfo, UINT32 *size)
{
    MmsAllParams *allParams;
    MmsContentType *cpyContent; 
    unsigned char *integerBuf;
    unsigned char *tempPointer;

    *size = 0; 
    cpyContent = ( MmsContentType *)contentInfo;

    if (cpyContent->knownValue == MMS_VALUE_AS_STRING)
    {
        if (cpyContent->strValue != NULL)
        {
            
            *size += strlen((const char *)cpyContent->strValue) + 1;
        } 
    }
    else
    {
        
        *size += 1;
    } 

    allParams = cpyContent->params;

    while (allParams != NULL) 
    {
        if ( allParams->type == MMS_PARAM_STRING)
        {
            *size += strlen((const char *)allParams->value.string) + 1;
            *size += 1; 
            if (allParams->param == MMS_START_REL)
            {
                
                *size += 2;
            } 
        }
        else
        {
            
            if (allParams->value.integer <= 127)
            {
                
                *size += 2;
            }
            else
            {
                integerBuf = M_ALLOC(5);
                tempPointer = (unsigned char *)cnvUint32ToLongInteger(
                        allParams->value.integer,integerBuf,5);
                
                
                *size += (unsigned long)(tempPointer - integerBuf + 1);
                M_FREE(integerBuf);
                integerBuf = NULL;
            } 
        } 

        allParams = allParams->next;
    } 
} 







INT32 calculateEntryHeadersSize( MmsEntryHeader *entryHeader)
{
    MmsEntryHeader *entry = entryHeader;
    UINT32 size = 0;

    while ( entry != NULL)
    {
        switch ( entry->headerType)
        {
        case MMS_SHORT_CUT_SHIFT_DELIMITER:
            ++size;
            break;
        case MMS_SHIFT_DELIMITER:
            size += 2; 
            break;
        case MMS_WELL_KNOWN_CONTENT_ID: 
            ++size;
            if (entry->value.wellKnownFieldName != NULL)
            {
                
                size += strlen((const char *)entry->value.wellKnownFieldName)
                    + 3  
                    + 1; 
            } 
            break;
        case MMS_WELL_KNOWN_CONTENT_LOCATION: 
            ++size;
            if (entry->value.wellKnownFieldName != NULL)
            {
                
                size += strlen((const char *)entry->value.wellKnownFieldName) + 1;
            } 
            break;
        case MMS_WELL_KNOWN_CONTENT_DISPOSITION: 
            
            size += 1 + entry->value.contentDisposition.valueLength;

            
            if (IS_SHORT_LENGTH(entry->value.contentDisposition.valueLength))
            {
                ++size;
            }
            else
            {
                ++size; 
                size += cnvLenUintvar(entry->value.contentDisposition.valueLength);
            } 
            break;
        case MMS_APPLICATION_HEADER:
            
            if (entry->value.applicationHeader.name == NULL ||
                entry->value.applicationHeader.value == NULL)
            {
                MMS_LOG_I(("%s(%d): Invalid application header %d %d\n", 
                    __FILE__, __LINE__, entry->value.applicationHeader.name,
                    entry->value.applicationHeader.value));
                return -1;
            }
            else
            {
                size += 
                    strlen((const char *)entry->value.applicationHeader.name) + 1 +
                    strlen((const char *)entry->value.applicationHeader.value) + 1;
            } 
            break;
        default :
            MMS_LOG_I(("%s(%d): Received unknown entry header type\n", 
                __FILE__, __LINE__));
            return -1; 
        } 

        entry = entry->next;
    } 

    return (INT32)size;
} 












unsigned char *createEntryHeaders( MmsEntryHeader *entryHeader, 
    unsigned char *buffer, int bufSize)
{
    int remainingSize;
    unsigned char *offset = buffer;
    MmsEntryHeader *entry = entryHeader;

    while (entry != NULL)
    {
        switch ( entry->headerType)
        {
        case MMS_SHORT_CUT_SHIFT_DELIMITER:
            *offset++ = entry->value.shortCutShiftDelimiter;
            break;
        case MMS_SHIFT_DELIMITER:
            
            *offset++ = (unsigned char)entry->headerType;
            *offset++ = entry->value.shiftDelimiter;
            break;
        case MMS_WELL_KNOWN_CONTENT_DISPOSITION:
            













            
            switch (entry->value.contentDisposition.dispositionType)
            {
            case MMS_DISPOSITION_FORM_DATA: 
                
                *offset++ = SET_HIGH_BIT((unsigned char)entry->headerType);

                
                remainingSize = (int)bufSize - (int)(offset - buffer);
                if (remainingSize <= 0 || (offset = cnvUint32ToValueLength(
                    entry->value.contentDisposition.valueLength, offset,
                    (UINT32)remainingSize)) == NULL)
                {
                    MMS_LOG_I(("%s(%d): Value-length conversion failed.\n", 
                        __FILE__, __LINE__));
                    return NULL;
                } 

                
                *offset++ = (UINT8)entry->value.contentDisposition.dispositionType;

                
                if (entry->value.contentDisposition.params == NULL)
                {
                    

                }
                else if (entry->value.contentDisposition.params->param != MMS_NAME)
                {
                    MMS_LOG_I(("%s(%d): Unknown Form-data parameter.\n", 
                        __FILE__, __LINE__));
                } 
                else if (entry->value.contentDisposition.params->value.string != NULL)
                {
                    
                    *offset++ = 
                        SET_HIGH_BIT((UINT8)entry->value.contentDisposition.params->param);
                    strcpy( (char *)offset, (const char *)
                        entry->value.contentDisposition.params->value.string);
                    offset += strlen( (const char *)
                        entry->value.contentDisposition.params->value.string);
                } 
                *offset++ = 0;                
                break;
            case MMS_DISPOSITION_ATTACHMENT: 
                
                *offset++ = SET_HIGH_BIT((unsigned char)entry->headerType);

                remainingSize = (int)bufSize - (int)(offset - buffer);
                if (remainingSize <= 0 || (offset = cnvUint32ToValueLength(
                    entry->value.contentDisposition.valueLength, offset,
                    (UINT32)remainingSize)) == NULL)
                {
                    MMS_LOG_I(("%s(%d): Value-length conversion failed.\n", 
                        __FILE__, __LINE__));
                    return NULL;
                } 
                              
                
                *offset++ = (UINT8)entry->value.contentDisposition.dispositionType;

                
                if (entry->value.contentDisposition.params == NULL)
                {
                    

                }
                else if (entry->value.contentDisposition.params->param != MMS_FILENAME)
                {
                    MMS_LOG_I(("%s(%d): Unknown Attachment parameter in Content-disposition.\n", 
                        __FILE__, __LINE__));
                }
                else if (entry->value.contentDisposition.params->value.string != NULL)
                {
                    
                    *offset++ = 
                        SET_HIGH_BIT((UINT8)entry->value.contentDisposition.params->param);
                    strcpy( (char *)offset, (const char *)
                        entry->value.contentDisposition.params->value.string);
                    offset += strlen( (const char *)
                        entry->value.contentDisposition.params->value.string);
                } 
                *offset++ = 0;
                break;
                
            default:
                
                MMS_LOG_I(("%s(%d): Received unknown Content-Disposition type\n", 
                    __FILE__, __LINE__));
                return NULL;
            } 
            break;            
        
        case MMS_WELL_KNOWN_CONTENT_ID: 
            
            *offset++ = SET_HIGH_BIT((unsigned char)entry->headerType);

            

            *offset++ = QUOTE_MARK;
            *offset++ = TOKEN_LESSER_THEN;
            strcpy( (char *)offset, ( const char *)
                entry->value.wellKnownFieldName);
            offset += strlen( (const char *)entry->value.wellKnownFieldName);
            *offset++ = TOKEN_GREATER_THEN;
            *offset++ = 0;
            break;

        case MMS_WELL_KNOWN_CONTENT_LOCATION: 
            
            *offset++ = SET_HIGH_BIT((unsigned char)entry->headerType);

            

            strcpy( (char *)offset, (const char *)
                entry->value.wellKnownFieldName);
            offset += strlen( (const char *)entry->value.wellKnownFieldName);
            *offset++ = 0;
            break;

        case MMS_APPLICATION_HEADER:
            
            strcpy( (char *)offset, 
                (const char *)entry->value.applicationHeader.name);
            offset += 
                strlen((const char *)entry->value.applicationHeader.name) + 1;
            strcpy( (char *)offset, (const char *)
                entry->value.applicationHeader.value );
            offset += 
                strlen((const char *)entry->value.applicationHeader.value) + 1;
            break;
        default :
            MMS_LOG_I(("%s(%d): Received unknown entry header type\n", 
                __FILE__, __LINE__));
            return NULL;
        } 

        entry = entry->next;
    } 

    return offset;
} 








unsigned long getSizeOfAddress( MmsAddressList *addrList)
{
    unsigned long length = 0;
    MmsAddressList *tmpPtr;
    tmpPtr = addrList;
   
    while (tmpPtr != NULL) 
    { 
        if ( tmpPtr->current.address != NULL)
        {
            length += strlen(tmpPtr->current.address) + sizeof(ADDRESS_PLMN);
        } 
        
        length += getSizeOfEncodedText(tmpPtr->current.name);
        ++length;   
     
        tmpPtr = tmpPtr->next;
    } 

    return length;
} 







unsigned long getSizeOfEncodedText(MmsEncodedText eText)
{ 
   unsigned long len = 0;             
   
   if (eText.text != NULL)
   {
        len = getSizeOfText(eText.text);
        len += ENCODED_VALUE_LEN;    
        len += ENCODED_CHAR_SET_LEN; 
   } 

   return len; 
} 







static unsigned long getSizeOfText(const char *text)
{ 
   unsigned long len = 0;             
   
   if (text != NULL)
   {
        len = strlen(text);
        if (text[0] & QUOTE_REQUIRED)
        {
            ++len; 
        } 
   } 

   return len; 
} 









char *generateMmsTransactionId(unsigned long *length)
{    
    char *string = NULL; 

    string  = M_ALLOC( (MemSize)MAX_LEN_OF_TRANSACTION_ID);
    *length = (unsigned long)( 1 + sprintf( string, "%ld", mmsWapGetUniqueId())); 

    return string; 
}