mmsparser.cpp

mms message parser

#include "stdafx.h"

#include "Common.h"
#include "Log.h"
#include "MmsParser.h"
#include "Log.h"
#include "mailcoder.h"
#include "mmscontent.h"
#include "mmsstring.h"

#include "wspparser.h"

extern Logger *mplog;

MmsParser::MmsParser()
{
	message_type = INVALID_TYPE;
	buf = NULL;
	attachments_area_ptr = NULL;
	contentItem = new MmsContent;
}

MmsParser::~MmsParser()
{
	delete contentItem;
}

MmsItemListNode *MmsParser::
	create_new_itemnode(int type, char *name, char *content)
{
	MmsItemListNode *pNew;
	char *name_new;
	char *content_new;

	name_new = (char *)malloc(strlen(name) + 1);
	if (name_new == NULL)
		return NULL;

	content_new = (char *)malloc(strlen(content) + 1);
	if (content_new == NULL)
		return NULL;

	strcpy(name_new, name);
	strcpy(content_new, content);

	pNew = new MmsItemListNode;
	pNew->item_type = type;
	pNew->name = name_new;
	pNew->content = content_new;

	return pNew;
}

/********
 *change the sending address of a mms_request message
 ****************/
int MmsParser::fill_mms_item_list(char *mms_buf, int mms_buf_length, CPtrList *&pList)
{
	char *p, *buf_tail;
	int msg_type;
	char tmp_str[MAX_TMP_STRING_LENGTH];


	bool loop_stop = 0;
	unsigned char head_mark;

	p = (char *)mms_buf;
	buf_tail = mms_buf + mms_buf_length;

	mplog->write(LOG_LEVEL_DEBUG, __FILE__, __LINE__, 
		"Begin parser MMS SEND_REQ head.");

	pList = new CPtrList;

	int i = 0;
	while (*p && !loop_stop && p < buf_tail)
	{
		i ++;
		head_mark = (unsigned)*p;
		
		mplog->write(LOG_LEVEL_FINE, __FILE__, __LINE__, 
			"Find head mark %2d [0x%x].", i, head_mark);
		
		switch(head_mark)
		{
		
			case MMS_HEAD_BCC:
				while (*p++ !=0);
				break;

			case MMS_HEAD_CC:
				while (*p++ !=0);
				break;

			case MMS_HEAD_CON_LOCA:
				{
					int i;

					p++;

					i = 0;
					while (*p !=0)
					{
						tmp_str[i++] = *p++;
					}

					tmp_str[i] = 0;
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						tmp_str));
					p++;
				}
				
				break;

			case MMS_HEAD_CON_TYPE:
				{
					int ptr_mov;

					p++;

					contentItem->set_content_head_buf(p);
					contentItem->get_head_html(tmp_str);
					ptr_mov = contentItem->get_content_type_length();
					p += ptr_mov;

					pList->AddTail(create_new_itemnode(head_mark,
								get_mms_item_name((unsigned char)head_mark),
									tmp_str));

					// the last item
					attachments_area_ptr = p;
					attachments_area_length = buf_tail - p;
					return msg_type;
					
					break;
				}

			case MMS_HEAD_DATE:
				{
					int len;
					long data_long;
					char *expir_token_str[3] = {"Absolute", "Relative", "INVALID"};
					char *next_mark_pos;
					char *time_str;

					p++; 
					next_mark_pos = p + (*p) + 1;

					data_long = read_wsp_long(p, len);

					//transfer the long seconds to time string
					struct tm *ptm = localtime(&data_long);
					if (ptm == NULL) 
						time_str = "INVALID TIME STAMP";
					else 
						time_str = asctime(ptm);

					sprintf(tmp_str, "%s", time_str);
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						tmp_str));

					p = next_mark_pos;
				
				}
				break;

			case MMS_HEAD_DLRV_RPT:
				{
					char *dlr_report_str[3] = {"Yes", "No", "INVALID"};
					int n;

					p ++;
					n = (unsigned char)(*p) - 128;
					
					// if n is invalid
					if (n < 0 || n > 1) 
						n = 2;
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						dlr_report_str[n]));

					p++;
				}
				
				break;

			case MMS_HEAD_DLRV_TIME:
				{
					long len;
					int ptr_mov;
				
					p++; 
					len = read_wsp_value_length(p, ptr_mov);
					
					p+=len + 1;
				}
				break;

			case MMS_HEAD_EXPIRE:
				{
					int size, expir_len;
					int expir_token;
					char *expir_token_str[3] = {"Absolute", "Relative", "INVALID"};
					long expir_long;
					char *next_mark_pos;

					long len;
					int ptr_mov;
				
					p++; 
					len = read_wsp_value_length(p, ptr_mov);

					next_mark_pos = p + len + 1;

					p+= ptr_mov;

					size = len;
					expir_token = ((unsigned char)*p++) - 128;
					if (expir_token < 0 || expir_token > 1)
						expir_token = 2;

					expir_len = size - 1;
					expir_long = read_wsp_long(p, expir_len);

					switch(expir_token)
					{
					case 0:
						{
							char *time_str;
							struct tm *ptm = localtime(&expir_long);
							if (ptm == NULL) 
								time_str = "INVALID TIME STAMP";
							else 
								time_str = asctime(ptm);

							sprintf(tmp_str, "%s (%s)", 
								time_str, expir_token_str[expir_token]);
						}
						break;
					case 1:
							sprintf(tmp_str, "%d (%s)", 
								expir_long, expir_token_str[expir_token]);
						break;
					default:
						sprintf(tmp_str, "%d (INVALID_EXPIRE_TOKEN)", 
								expir_long, expir_token_str[expir_token]);
					};

					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						tmp_str));

					p = next_mark_pos;
				
				}
				break;

			case MMS_HEAD_FROM:
					{
					int ptr_mov, from_token;
					long len;
					char *from_token_str[3] = {"Address-Present", "Insert-Address", "INVALID"};
					char *next_mark_pos;

					p++;
					
					len = read_wsp_value_length(p, ptr_mov);
					
					next_mark_pos = p + len + ptr_mov;

					// get the from_token
					p += ptr_mov;
					from_token = ((unsigned char)*p++) - 128;

					if (from_token < 0 || from_token > 2)
						from_token = 2;

					strcpy(from_msisdn, p);

					sprintf(tmp_str, "%s(%s)", p, from_token_str[from_token]);
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						tmp_str));
					
					p = next_mark_pos;
				}
								
				break;

			case MMS_HEAD_MSG_CLASS:
				{
					char *calss_str[5] = {"Personal", "Advertisement", 
						"Informational", "Auto", "INVALID"};
					int n;

					p ++;
					n = (unsigned char)(*p) - 128;
					
					// if n is invalid
					if (n < 0 || n > 3) 
						n = 4;
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						calss_str[n]));

					p++;
				}

				break;

			case MMS_HEAD_MSG_ID:
			
				{
					int i;

					p++;

					i = 0;
					while (*p !=0)
					{
						tmp_str[i++] = *p++;
					}

					tmp_str[i] = 0;

					strcpy(msg_id, tmp_str);
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						tmp_str));
					p++;
				}
								
				break;
				break;

			case MMS_HEAD_MSG_TYPE:
				p ++;// move to the next byte(msgtype_value)
				
				pList->AddTail(create_new_itemnode(head_mark,
					get_mms_item_name((unsigned char)head_mark),
					get_mms_type_name((unsigned char)*p)));

				msg_type = (unsigned char)*p;
				
				p++; // move to the next byte(header_mark)
				break;

			case MMS_HEAD_VERSION:  
				{
					char vch;
					char major_v, minor_v;
					
					p++;

					vch = *p++;

					major_v = (vch & 0x70) >> 4;
					minor_v = (vch & 0x0f);

					sprintf(tmp_str, "%d.%d", major_v, minor_v);
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),
						tmp_str));
				}
				
				break;

			case MMS_HEAD_MSG_SIZE:
				{
					long size_long;
					int size_len;

					p++;
					
					size_long = read_wsp_long(p, size_len);

					sprintf(tmp_str, "%d", size_long);
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),
						tmp_str));
			
					p+=(*p) + 1;;				
				}
				break;

			case MMS_HEAD_MSG_PRIO:
				{
					char *priority_str[4] = {"Low", "Normal", "High", "INVALID"};
					int n;

					p ++;
					n = (unsigned char)(*p) - 128;
					
					// if n is invalid
					if (n < 0 || n > 1) 
						n = 2;
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						priority_str[n]));

					p++;
				}
				
				break;

			case MMS_HEAD_READ_RPT:
				{
					char *rpt_str[3] = {"Yes", "No", "INVALID"};
					int n;

					p ++;
					n = (unsigned char)(*p) - 128;
					
					// if n is invalid
					if (n < 0 || n > 1) 
						n = 2;

					if (n == 0)
						read_reply_flag	= 1;
					else
						read_reply_flag = 0;
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						rpt_str[n]));

					p++;
				}
				
				break;

			case MMS_HEAD_RPT_ALLOW:
				p+=2;
				break;

			case MMS_HEAD_RSP_STAT:
				p+=2;
				break;

			case MMS_HEAD_RSP_TXT:
				while (*p++ !=0);
				break;

			case MMS_HEAD_SEND_VISIB:
				p+=2;
				break;

			case MMS_HEAD_STATUS:
				{
					char *status_str[8] = {"Expired",
						"Retrieved",
						"Rejected",
						"Deferred",
						"Unrecognised",
						"Indeterminate",
						"Forwarded"
						"INVALID"};
					int n;

					p ++;
					n = (unsigned char)(*p) - 128;
					
					// if n is invalid
					if (n < 0 || n > 1) 
						n = 2;
					
					pList->AddTail(create_new_itemnode(head_mark,
						get_mms_item_name((unsigned char)head_mark),											
						status_str[n]));

					p++;
				}
				break;

			case MMS_HEAD_SUBJECT:
				{
					char tmp_str[MAX_SUBJECT_LENGTH];
					char *sub_final;
					int j = 0;
					MIME_STRING_CODE code = NO_CODE;

					p ++;
					
					//if the the subject item is a coded string
					if (*p < 0x20 || *p > 0x80) 
					{
						if (*p == 0x1f)  //the length of the subject >= 0x1f