plxmmsmessage.c

mtk wap和mms代码。。适应mtk 25。26平台

/***************************************************************************
 *
 *                      Pollex Mobile Platform
 *
 * Copyright (c) 2004 by Pollex Mobile Software Co., Ltd. 
 *                       All Rights Reserved 
 *
 * Module   : 
 *
 * Purpose  : 
 *
\**************************************************************************/
#include "PlxMmsMessage.h"
#include "mmsfrrecord.h"

//macro
#define MAXMMSSIZE        (100*1024L)
#define MAX_CONT_NAME_LEN 16
#define MAX_CONT_TYPE_LEN 16
#define SUB_CHARSET       ";Charset=utf-8"

//#define MMS_MALLOC MMS_Malloc
//#define MMS_FREE   MMS_Free

typedef long (*READPROC)(void* param, char _HUGE* pBuf, long buflen);

//struct

//global

//private functions
/*aln_ stands for "add list node*/
//constructor
//static MmsAddListNode* aln_CreateListNode(void);
static MmsAddListNode* aln_CreateListNode_Data(void* pData);
//destructor
static MmsAddListNode* aln_ReleaseListNode(MmsAddListNode* list_node);

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*
 *                functions for MmsListNode                               *
 *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/***************************************************************************
* Function	aln_CreateListNode
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
/*MmsAddListNode* aln_CreateListNode(void)
{
    MmsAddListNode* node = 
        (MmsAddListNode*)MMS_MALLOC(sizeof(MmsAddListNode));

    if(!node)
        return NULL;

    MMS_Memset((void*)node, 0, sizeof(MmsAddListNode));

    return node;
}
*/
/***************************************************************************
* Function	aln_CreateListNode_Data
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
MmsAddListNode* aln_CreateListNode_Data(void* pData)
{
    MmsAddListNode* node = 
        (MmsAddListNode*)MMS_MALLOC(sizeof(MmsAddListNode));

    if(!node)
        return NULL;

    MMS_Memset((void*)node, 0, sizeof(MmsAddListNode));

    node->content = pData;
    
    return node;
}

/***************************************************************************
* Function	aln_ReleaseListNode
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
MmsAddListNode* aln_ReleaseListNode(MmsAddListNode* list_node)
{
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: aln_ReleaseListNode\r\n");
#endif
    if(!list_node)
    {
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: !list_node\r\n");
#endif
        return NULL;
    }
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: free %p\r\n", list_node);
#endif
    MMS_FREE(list_node);
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: free end\r\n");
#endif
    return NULL;
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*
 *                    private functions for MmsMessage                    *
 *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
//file read callback
static long MmsParamRead(void* param, char _HUGE* pBuf, long buflen);

static BOOL    mmsmsg_SavePhoneNum(MmsMessage* msg);
//static unsigned char MMS_HUGE* mmsmsg_ReadContentData(MmsMessage* msg, PMMSECONTENT content);
//static int mmsmsg_GetSubFromMsg(MmsMessage* msg);
static BOOL mmsmsg_SaveSub(MmsMessage* msg);
static void mmsmsg_SetLastError(MmsMessage* msg, int error);
static BOOL mmsmsg_IsSubValide(MmsMessage* msg);

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*
 *                    public functions for MmsMessage                     *
 *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/***************************************************************************
* Function	mmsmsg_CreateMmsMessage
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
MmsMessage* mmsmsg_CreateMmsMessage(void)
{
    MmsMessage* mmsmsg = NULL;

    mmsmsg = (MmsMessage*)MMS_MALLOC(sizeof(MmsMessage));
    if(!mmsmsg)
        return NULL;

    MMS_Memset((void*)mmsmsg, 0, sizeof(MmsMessage));

    mmsmsg->id = -1;
    mmsmsg->mode   = -1;
    mmsmsg->folder = (char*)MMSE_FOLDER_DRAFT;

    MMS_Memset((void*)&(mmsmsg->add_list), 0, sizeof(MmsAddList));
//    MMS_Memset((void*)&(mmsmsg->m_att_head), 0, sizeof(MmsAttHead));

    return mmsmsg;
}

/***************************************************************************
* Function	mmsmsg_ReleaseMmsMessage
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
MmsMessage* mmsmsg_ReleaseMmsMessage(MmsMessage* msg)
{
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: mmsmsg_ReleaseMmsMessage\r\n");
#endif

    if(!msg)
    {
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: !msg\r\n");
#endif
        return NULL;
    }

    //clean up add list
    al_RemoveAll(&(msg->add_list));
    
    //close message
    if(msg->mmse && msg->msg)
    {
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: will close message\r\n");
#endif
        MMSE_CloseMessage(msg->mmse, msg->msg);
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: close message end\r\n");
#endif
    }

    if(msg->sub)
        MMS_Free((void*)msg->sub);

    //release MmsMessage
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: will free msg = %p\r\n", msg);
#endif
    MMS_FREE(msg);
#ifdef MMS_DEBUG
    PlxTrace("MMSUI: free end\r\n");
#endif

    return NULL;
}

/***************************************************************************
* Function	mmsmsg_Init
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
BOOL mmsmsg_Init(MmsMessage* mmsmsg, void* mmse, long id)
{
    void*    msg  = NULL;

    if(!mmsmsg || !mmse || id < 0)
        return FALSE;

    mmsmsg->size = 0;

    //open message
    msg = MMSE_OpenMessage(mmse, id);
    if(!msg)
        return FALSE;

    mmsmsg->mmse = mmse;
    mmsmsg->msg  = msg;
    mmsmsg->nCurSlide = mmsmsg_GetCurSlideIndex(mmsmsg);

    return TRUE;
}

/***************************************************************************
* Function	mmsmsg_InitWithMode
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
int mmsmsg_InitWithMode(MmsMessage* mmsmsg, void* mmse, long id, 
                        enum EditMode mode, const char* folder)
{
    char* to = NULL;
    int   to_len;

#ifdef MMS_DEBUG
    PlxTrace("mmsmsg_InitWithMode, mode=%d\r\n", (int)mode);
#endif

    if(!mmsmsg || !mmse || mmsmsg->mmse)
        return INIT_ERR_FAILED;

    //record parameters
    mmsmsg->mmse   = mmse;
    mmsmsg->mode   = mode;
    mmsmsg->size   = 0;
    mmsmsg->folder = (char*)folder;

    //open a existing mms msg from template box
	if(mode == EditCreateNew || mode == EditTrans || mode == EditTempNew) //mode==EditCreateNew, id==-1  //-1 = new
    {                                                    //mode==EditTrans, id==a valid id
        mmsmsg->msg = MMSE_CreateMessage(mmse, id);
        if(!mmsmsg->msg)
        {
            if(MMSE_GetLastError(mmse) == MMSE_MM_NUMBER_ERROR)
                return INIT_ERR_MAXMSGNUM;
            if(MMSE_GetLastError(mmse) == MMSE_MM_SIZE_ERROR)
                return INIT_ERR_MSGTOOBIG;
	        return INIT_ERR_FAILED;
        }
    }
    else if(mode == EditReply || mode == EditReplyAll) //reply and reply all
	{
		mmsmsg->id = -1;
		mmsmsg->msg = MMSE_CreateMessage(mmse, mmsmsg->id);
        if(!mmsmsg->msg)
        {
            if(MMSE_GetLastError(mmse) == MMSE_MM_NUMBER_ERROR)
                return INIT_ERR_MAXMSGNUM;
	        return INIT_ERR_FAILED;
        }
	}
	else //open a existing message
    {
        MMSE_SelectFolder(mmse, mmsmsg->folder);
		mmsmsg->msg = MMSE_OpenMessage(mmse, id);
    }

    //open or create message failed
    if(!mmsmsg->msg)
	{
        return INIT_ERR_FAILED;
    }

    mmsmsg->nCurSlide = mmsmsg_GetCurSlideIndex(mmsmsg);

    //It's a existing mms msg
    if(mode >  EditTemp  && 
       mode != EditReply && 
       mode != EditReplyAll) 
    {
        //create a smil object by mmsmsg's content
//        if(mmsmsg_CreateSmil(mmsmsg))
        {
            //set receiver by edit mode
            switch(mode)
            {
/*            case EditTemp: //template
                m_str_to = "";
                break;
            
*/          
//            case EditTempNew:
            case EditTrans: //trans, no from, no to, and no msg id
                mmsmsg->id = -1;
                mmsmsg->to[0] = 0;
                mmsmsg->cc[0] = 0;
                mmsmsg->bcc[0] = 0;
                //mmsmsg->sub[0] = 0;
                mmsmsg->sub = NULL;
                mmsmsg->sub_len = 0;

                MMSE_SetHeaderField(mmse, mmsmsg->msg, "To", " ");
                MMSE_SetHeaderField(mmse, mmsmsg->msg, "Cc", " ");
                MMSE_SetHeaderField(mmse, mmsmsg->msg, "Bcc", " ");
                    
                to = (char*)MMSE_GetHeaderField(mmse, mmsmsg->msg, "Subject");
                if(to)
                {
                    mmsmsg->sub_len = MMS_Strlen(to) + 5;
                    mmsmsg->sub = (char*)MMS_Malloc(mmsmsg->sub_len);
                    if(!mmsmsg->sub)
                    {
                        mmsmsg->sub_len = 0;
                        break;
                    }

                    MMS_Strcpy(mmsmsg->sub, "FW:");
                    MMS_Strcat(mmsmsg->sub, to);
/*                    MMS_Memcpy((void*)(mmsmsg->sub+3),
                        (void*)to, MAX_SUB_LEN-3);
                    mmsmsg->sub[MAX_SUB_LEN-1] = 0;
*/
                }
                else
                {
                    mmsmsg->sub_len = MMS_Strlen("FW:")+1;
                    mmsmsg->sub = (char*)MMS_Malloc(mmsmsg->sub_len);
                    if(mmsmsg->sub)
                    {
                        MMS_Strcpy(mmsmsg->sub, "FW:");
                    }
                }

                break;
/*            case EditNew: //edit new
                m_str_to = "";
                break;
*/          
//            case EditTempEdit:
            case EditOld: //edit a existing message
                to = (char*)MMSE_GetHeaderField(mmse, 
			                    mmsmsg->msg, "To");
                mmsmsg->to[0] = 0;
                mmsmsg->cc[0] = 0;
                mmsmsg->bcc[0] = 0;
                //mmsmsg->sub[0] = 0;
                mmsmsg->sub = NULL;
                mmsmsg->sub_len = 0;
                //to
			    if(to)
				{
                    to_len = MMS_Strlen(to);
                    if(to_len >= MAX_TO_LEN)
                    {
                        MMS_Strncpy(mmsmsg->to, to, MAX_TO_LEN-1);
                        mmsmsg->to[MAX_TO_LEN-1] = 0;
                    }
                    else
                        MMS_Strcpy(mmsmsg->to, to);
				}
                
                //cc
                to = (char*)MMSE_GetHeaderField(mmse, 
			                    mmsmsg->msg, "Cc");
                if(to)
                {
                    to_len = MMS_Strlen(to);
                    if(to_len >= MAX_TO_LEN)
                    {
                        MMS_Strncpy(mmsmsg->cc, to, MAX_TO_LEN-1);
                        mmsmsg->cc[MAX_TO_LEN-1] = 0;
                    }
                    else
                        MMS_Strcpy(mmsmsg->cc, to);
				}
                
                //bcc
                to = (char*)MMSE_GetHeaderField(mmse, 
			                    mmsmsg->msg, "Bcc");
                if(to)
                {
                    to_len = MMS_Strlen(to);
                    if(to_len >= MAX_TO_LEN)
                    {
                        MMS_Strncpy(mmsmsg->bcc, to, MAX_TO_LEN-1);
                        mmsmsg->bcc[MAX_TO_LEN-1] = 0;
                    }
                    else
                        MMS_Strcpy(mmsmsg->bcc, to);
				}

                //sub
                to = (char*)MMSE_GetHeaderField(mmse, mmsmsg->msg, "Subject");
                if(to)
                {
                    mmsmsg->sub_len = MMS_Strlen(to) + 1;
                    mmsmsg->sub = (char*)MMS_Malloc(mmsmsg->sub_len);
                    if(!mmsmsg->sub)
                    {
                        mmsmsg->sub_len = 0;
                        break;
                    }

                    MMS_Strcpy(mmsmsg->sub, to);
                }

                break;
            }
        } //if(CreateSmil())
    }
    else if(mode < EditTemp && mode == /*-1*/EditCreateNew) //new, no to
    {
        //mmsmsg->m_str_to = NULL;
        mmsmsg->to[0] = 0;
        mmsmsg->cc[0] = 0;
        mmsmsg->bcc[0] = 0;
    }
	else if(mode == EditReply) //reply, to = from
	{
		char* from = NULL;
        void* msg  = NULL;
	
#ifdef MMS_DEBUG
    PlxTrace("EditReply\r\n");
#endif

        MMSE_SelectFolder(mmse, mmsmsg->folder);
        msg = MMSE_CreateMessage(mmse, id);

        from = (char*)MMSE_GetHeaderField(mmse, 
			            msg, "From");
        if(from)
        {
            to_len = MMS_Strlen(from);
            if(to_len >= MAX_TO_LEN)
            {
                MMS_Strncpy(mmsmsg->to, from, MAX_TO_LEN-1);
                mmsmsg->to[MAX_TO_LEN-1] = 0;
            }
            else
            {
                MMS_Strcpy(mmsmsg->to, from);
            }
		}

        //sub
        //mmsmsg->sub[0] = 0;
        mmsmsg->sub = NULL;
        mmsmsg->sub_len = 0;

        to = (char*)MMSE_GetHeaderField(mmse, msg, "Subject");
        if(to)
        {
#ifdef MMS_DEBUG
    PlxTrace("sub=%s\r\n", to);
#endif
            mmsmsg->sub_len = MMS_Strlen(to) + 5;
            mmsmsg->sub = (char*)MMS_Malloc(mmsmsg->sub_len);
            if(!mmsmsg->sub)
            {
                mmsmsg->sub_len = 0;
                MMSE_CloseMessage(mmse, msg);
                return 0;
            }

            MMS_Strcpy(mmsmsg->sub, "RE:");
#ifdef MMS_DEBUG
    PlxTrace("sub=%s\r\n", mmsmsg->sub);
#endif
            MMS_Strcat(mmsmsg->sub, to);

#ifdef MMS_DEBUG
    PlxTrace("sub=%s\r\n", mmsmsg->sub);
#endif
        }
        else
        {
            mmsmsg->sub_len = MMS_Strlen("RE:") + 1;
            mmsmsg->sub = (char*)MMS_Malloc(mmsmsg->sub_len);
            if(mmsmsg->sub)
                MMS_Strcpy(mmsmsg->sub, "RE:");
        }

        MMSE_CloseMessage(mmse, msg);
    }
	else if(mode == EditReplyAll) //reply all, to = from+to,cc=cc
	{
		char*  from  = NULL;
        char*  to    = NULL;
        char*  cc    = NULL;
        int    len   = MAX_TO_LEN-1;
        int    from_len = 0;
        int    cc_len = 0;

        //open the original message