mutils.c

彩信MMS的全部代码

{
    MmsAddressList *listPointer;

    while (addressList != NULL)
    {
        listPointer = addressList->next;
        freeMmsAddress(&addressList->current);
        M_FREE(addressList);
        addressList = listPointer;
    } 
} 






void freeMmsMessageClass(MmsMessageClass *messageClass)
{
    if (messageClass != NULL && messageClass->textString != NULL)
    {
        M_FREE(messageClass->textString);
        messageClass->textString = NULL;
    } 
} 






void freeMmsContentType(MmsContentType *contentType)
{
    if (contentType == NULL)  
    {
        return; 
    }  

    if (contentType->strValue != NULL)
    {
        M_FREE( contentType->strValue);
        contentType->strValue = NULL;
    } 

    freeMmsParams(contentType->params);
} 






void freeMmsHeader(MmsHeader *mmsHeader)
{
    freeMmsAddress(&mmsHeader->from);
    freeMmsAddressList(mmsHeader->to);
    freeMmsAddressList(mmsHeader->cc);
    freeMmsAddressList(mmsHeader->bcc);
    freeMmsPrevSentBy(mmsHeader->previouslySentBy);
    freeMmsPrevSentDate(mmsHeader->previouslySentDate);
    freeMmsContentType(mmsHeader->contentType);
    freeMmsMessageClass(&mmsHeader->msgClass);
    M_FREE(mmsHeader->subject.text);
    M_FREE(mmsHeader->contentType);
    M_FREE(mmsHeader->replyChargingId);
    M_FREE(mmsHeader->serverMessageId);
} 






void freeMmsParams(MmsAllParams *params)
{
    MmsAllParams *next = NULL;  
    
    if (params == NULL)  
    {
        return; 
    }  

    while (params != NULL)
    {
        next = params->next;
        if (params->type == MMS_PARAM_STRING && params->value.string != NULL)
        {
            M_FREE(params->value.string);
            params->value.string = NULL;
        } 

        M_FREE(params);
        params = next;
    } 

} 






void freeMmsParamsEnc(MmsAllParamsEnc *params)
{
    MmsAllParamsEnc *next = NULL;  
    
    if (params == NULL)  
    {
        return; 
    }  

    while (params != NULL)
    {
        next = params->next;
        if (params->type == MMS_PARAM_STRING && params->value.string != NULL)
        {
            M_FREE(params->value.string);
            params->value.string = NULL;
        } 

        M_FREE(params);
        params = next;
    } 

} 






void freeMmsPrevSentBy(MmsPrevSentBy *mmsPrevSentBy)
{
    MmsPrevSentBy *p = NULL;
    MmsPrevSentBy *tmp = mmsPrevSentBy;
    
    if (tmp != NULL)
    {
        p = tmp->next;
        while (tmp)
        {
            freeMmsAddress(&tmp->sentBy);
            M_FREE(tmp);
            tmp = p;
            if (p != NULL)
            {
                p = p->next;
            } 
        } 
    } 
} 






void freeMmsPrevSentDate(MmsPrevSentDate *mmsPrevSentDate)
{
    MmsPrevSentDate *p = NULL;
    MmsPrevSentDate *tmp = mmsPrevSentDate;

    if (tmp != NULL)
    {
        p = tmp->next;
        while (tmp)
        {
            M_FREE(tmp);
            tmp = p;
            if (p != NULL)
            {
                p = p->next;
            } ;
        } 
    } 
} 






void freeMmsForward(MmsForward *mmsForward)
{
    freeMmsAddress(&mmsForward->from);
    freeMmsAddressList(mmsForward->to);
    freeMmsAddressList(mmsForward->cc);
    freeMmsAddressList(mmsForward->bcc);
    M_FREE(mmsForward);
} 






void freeMmsNotification(MmsNotification *mmsNotification)
{
    freeMmsAddress(&mmsNotification->from);
    freeMmsMessageClass(&mmsNotification->msgClass);
    M_FREE(mmsNotification->subject.text);
    M_FREE(mmsNotification->replyChargingId);
    M_FREE(mmsNotification->contentLocation);
    mmsNotification->subject.text = NULL;
    mmsNotification->replyChargingId = NULL;
    mmsNotification->contentLocation = NULL;

    if (mmsNotification->elementDescriptor != NULL)
    {
        freeMmsParamsEnc(mmsNotification->elementDescriptor->params);
        M_FREE(mmsNotification->elementDescriptor->contentReference);
        M_FREE(mmsNotification->elementDescriptor);
    } 
} 






void freeMmsEntryHeader(MmsEntryHeader *entryHeader)
{
    MmsEntryHeader *tempPointer = NULL;

    while (entryHeader != NULL)
    {
        tempPointer = entryHeader->next;
        if (entryHeader->headerType == MMS_WELL_KNOWN_CONTENT_LOCATION ||
            entryHeader->headerType == MMS_WELL_KNOWN_CONTENT_ID)
        {
            M_FREE(entryHeader->value.wellKnownFieldName);
            entryHeader->value.wellKnownFieldName = NULL;
        }
        else if (entryHeader->headerType == MMS_WELL_KNOWN_CONTENT_DISPOSITION &&
                 entryHeader->value.contentDisposition.params != NULL)
        {
            freeMmsParams(entryHeader->value.contentDisposition.params);
        }
        else if (entryHeader->headerType == MMS_APPLICATION_HEADER)
        {
            if (entryHeader->value.applicationHeader.name != NULL)
            {
                M_FREE(entryHeader->value.applicationHeader.name);
                entryHeader->value.applicationHeader.name = NULL;
            } 

            if (entryHeader->value.applicationHeader.value != NULL)
            {
                M_FREE(entryHeader->value.applicationHeader.value);
                entryHeader->value.applicationHeader.value = NULL;
            } 
        } 

        M_FREE(entryHeader);
        entryHeader = tempPointer;
    } 
} 







void freeMmsMessageInfo(MmsMessageInfo *messageInfo)
{
    MmsBodyInfoList *ctList;

    while (messageInfo->list != NULL)
    {
        ctList = messageInfo->list->next;
        freeMmsContentType(messageInfo->list->contentType);
        M_FREE(messageInfo->list->contentType);
        freeMmsEntryHeader(messageInfo->list->entryHeader);
        M_FREE(messageInfo->list);
        messageInfo->list = ctList;
    } 
} 












void convertDateToString(UINT32 t, char *s)
{
    unsigned char m[12]  = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    unsigned char m4[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    
    UINT32 mins;
    UINT32 hours;
    UINT32 days;
    UINT32 months;
    UINT32 years;
    UINT32 i;
    UINT32 nly;
    const unsigned char *days_in_month;

    
    days = (UINT32)(t / 86400);
    t = t % 86400;

    hours = (UINT32)(t / 3600);
    t = t % 3600;

    mins = (UINT32)(t / 60);

    



    years = (days / 365);
    days = (days % 365);

    

    nly = ((years + 1) / 4);
    if (days < nly) 
    {
        years--;
        days = (days + 365 - nly);
    }
    else 
    {
        days -= nly;
    } 

    



    if (((years + 2) % 4) == 0)
    {
        days_in_month = m4;
    }
    else
    {
        days_in_month = m;
    } 

    for (i = 0; i < 12; i++) 
    {
        if (days < days_in_month[i])
        {
            break;
        } 

        days -= days_in_month[i];
    } 
    
    months = i;

    



    sprintf( s, "%02d/%02d/%04d %02d:%02d", (int)(days + 1), (int)(months + 1), 
        (int)(years + 1970), (int)hours, (int)mins);
} 







CMN_BOOL isMultiPart( MmsKnownMediaType value)
{
    CMN_BOOL ret;

    switch ( value)
    {
    case MMS_VND_WAP_MULTIPART_ANY:
    case MMS_VND_WAP_MULTIPART_MIXED:
    case MMS_VND_WAP_MULTIPART_ALTERNATIVE:
    case MMS_VND_WAP_MULTIPART_RELATED:
    case MMS_TYPE_MULTIPART_ANY:                  
    case MMS_TYPE_MULTIPART_MIXED:                 
    case MMS_TYPE_MULTIPART_FORM_DATA:               
    case MMS_TYPE_MULTIPART_BYTERANGES:               
    case MMS_TYPE_MULTIPART_ALTERNATIVE:  
    case MMS_TYPE_APP_VND_WAP_MPART_FORM_DATA:   
    case MMS_TYPE_APP_VND_WAP_MPART_BYTERANGES:   
        ret = TRUE;
        break;
    case MMS_TYPE_APP_VND_OMA_DRM_MESSAGE:
        
        if (cfgGetInt(MMS_CFG_EXTERNAL_DRM_PARSER)) 
        {
            ret = FALSE;
        }
        else
        {
            ret = TRUE;
        } 
        break;
    default :
        ret = FALSE;
        break;
    } 

    return ret;
} 







CMN_BOOL isText( MmsKnownMediaType value)
{
    CMN_BOOL ret;

    switch( value)
    {
    case MMS_TYPE_TEXT_ANY:
    case MMS_TYPE_TEXT_HTML:
    case MMS_TYPE_TEXT_PLAIN:
    case MMS_TYPE_TEXT_X_VCALENDAR:
    case MMS_TYPE_TEXT_X_VCARD:
        
        ret = TRUE;
        break;
    default :
        
        ret = FALSE;
        break;
    } 

    return ret;
} 













static unsigned char *mmsCvtBuf(int *charset, const unsigned char *srcData, 
    int *srcSize, int *dstSize)
{
    char *dstData = NULL;
    int length = 0;
    MMS_CHAR_CONV_TYPE *cvtFunction = NULL;
    int totalSize = 2*MMS_MAX_CHUNK_SIZE;   



    
    length = *srcSize; 
    switch (*charset)
    {
    case CMN_CHARSET_US_ASCII:
    case CMN_CHARSET_UTF_16BE:
    case CMN_CHARSET_UTF_16LE:
    case CMN_CHARSET_UTF_16:
    case CMN_CHARSET_UCS_2:
    case CMN_CHARSET_ISO_8859_1:
        cvtFunction = MMS_CHAR_CONV_FUNC_FIND(*charset, CMN_CHARSET_UTF_8);
        if (cvtFunction == NULL)
        {
            MMS_LOG_I(("%s(%d): Conversion function (%d) not found.\n",
                __FILE__, __LINE__, *charset));
        }
        else
        {
            





            (void)cvtFunction((const char *)srcData, &length, NULL, &totalSize);
            *charset = CMN_CHARSET_UTF_8;
            if ((UINT32)totalSize <= MMS_MAX_CHUNK_SIZE)
            {
                dstData = M_CALLOC((unsigned int)totalSize); 
                (void)cvtFunction((const char *)srcData, &length, dstData, &totalSize);
            }
            else
            {
                




                MMS_LOG_I(("%s(%d): Converted data larger than "
                    "MMS_MAX_CHUNK_SIZE (%d > %d). Must be stored on file.\n",
                    __FILE__, __LINE__, totalSize, MMS_MAX_CHUNK_SIZE));
                dstData = NULL;
            } 
        } 

        *srcSize = length;
        *dstSize = totalSize;
        break;
    default :
        dstData = M_ALLOC((MemSize)*srcSize);
        memcpy( dstData, srcData, (unsigned int)*srcSize);
        *dstSize = *srcSize;
        break;
    } 

    return (unsigned char *)dstData;
} 














static CMN_BOOL mmsCvtBufFile( int *charset, const unsigned char *srcData, 
    int srcSize, int *dstSize, UINT32 fileId)
{
    char *dstData = NULL;
    int srcBytes = 0;
    int dstBytes = 0;
    long dataWritten = 0;
    INT32 curPos = 0;
    CMN_BOOL ret = TRUE;
    MMS_CHAR_CONV_TYPE *cvtFunction = NULL;
    
    *dstSize = 0;
    switch (*charset)
    {
    case CMN_CHARSET_US_ASCII:
    case CMN_CHARSET_UTF_16BE:
    case CMN_CHARSET_UTF_16LE:
    case CMN_CHARSET_UTF_16:
    case CMN_CHARSET_UCS_2:
    case CMN_CHARSET_ISO_8859_1:
        cvtFunction = MMS_CHAR_CONV_FUNC_FIND( *charset, CMN_CHARSET_UTF_8);
        if (cvtFunction == NULL)
        {
            MMS_LOG_I(("%s(%d): Conversion function (%d) not found.\n",
                __FILE__, __LINE__, *charset));
            ret = FALSE;
        }
        else
        {
            *charset = CMN_CHARSET_UTF_8;
            srcBytes = srcSize; 
            dstData = M_CALLOC(MMS_MAX_CHUNK_SIZE);
            do
            {
                dstBytes = MMS_MAX_CHUNK_SIZE;

                



                (void)cvtFunction((const char *)(srcData + curPos), &srcBytes, 
                    dstData, &dstBytes);
                dataWritten = FILEa_write(CMN_FILE_CATEGORY_TMP, fileId, dstData, 
                    curPos, dstBytes);

                if (dataWritten != dstBytes)