/***************************************************************************************
 *
 *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 *
 *  By downloading, copying, installing or using the software you agree to this license.
 *  If you do not agree to this license, do not download, install, 
 *  copy or use the software.
 *
 *  Copyright (C) 2014-2022, Happytimesoft Corporation, all rights reserved.
 *
 *  Redistribution and use in binary forms, with or without modification, are permitted.
 *
 *  Unless required by applicable law or agreed to in writing, software distributed 
 *  under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 *  CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
 *  language governing permissions and limitations under the License.
 *
****************************************************************************************/

#include "sys_inc.h"
#include "hqueue.h"
#include "linked_list.h"
#include "rfc_md5.h"
#include "word_analyse.h"
#include "digcalc.h"
#include "hsip.h"
#include "sip_util.h"

/*******************************************************\
 外部全局变量
\*******************************************************/
extern HSIP_CLASS hsip;

/*******************************************************/
MSGTSTR g_msg_str[] = 
{
	{SIP_MT_NULL,		"SIP_MT_NULL"},
	{SIP_MT_ACK,		"SIP_MT_ACK"},
	{SIP_MT_BYE,		"SIP_MT_BYE"},
	{SIP_MT_CAN,		"SIP_MT_CAN"},
	{SIP_MT_INV,		"SIP_MT_INV"},
	{SIP_MT_OPT,		"SIP_MT_OPT"},
	{SIP_MT_REG,		"SIP_MT_REG"},
	{SIP_MT_MSG,		"SIP_MT_MSG"}
};

char * sip_get_msg_type_string(SIP_MT mt)
{
	uint32 i;
	
	for (i=0; i<sizeof(g_msg_str)/sizeof(MSGTSTR); i++)
	{
		if (g_msg_str[i].mt == mt)
		{
			return g_msg_str[i].string;
		}			
	}

	return NULL;
}

EVENTSTR g_event_str[] =
{
	{CSE_NULL,				"CSE_NULL"},
	{CSE_Call_Recv,			"CSE_Call_Recv"},
	{CSE_Call_Send,			"CSE_Call_Send"},
	{CSE_Message_Recv,		"CSE_Message_Recv"},
	{CSE_Message_Send,		"CSE_Message_Send"},
	{CSE_Cancel_Recv,		"CSE_Cancel_Recv"},
	{CSE_Cancel_Send,		"CSE_Cancel_Send"},
	{CSE_PRACK_Recv,		"CSE_PRACK_Recv"},
	{CSE_PRACK_Send,		"CSE_PRACK_Send"},
	{CSE_Hang_Recv,			"CSE_Hang_Recv"},
	{CSE_Refer_Recv,		"CSE_Refer_Recv"},
	{CSE_Refer_Send,		"CSE_Refer_Send"},
	{CSE_Info_Recv,			"CSE_Info_Recv"},
	{CSE_Info_Send,			"CSE_Info_Send"},
	{CSE_202_Recv,			"CSE_202_Recv"},
	{CSE_3xx_Recv,			"CSE_3xx_Recv"},
	{CSE_4xx_Recv,			"CSE_4xx_Recv"},
	{CSE_5xx_Recv,			"CSE_5xx_Recv"},
	{CSE_6xx_Recv,			"CSE_6xx_Recv"},
	{CSE_100_Recv,			"CSE_100_Recv"},
	{CSE_180_Recv,			"CSE_180_Recv"},
	{CSE_IOK_Recv,			"CSE_IOK_Recv"},
	{CSE_MOK_Recv,			"CSE_MOK_Recv"},
	{CSE_COK_Recv,			"CSE_COK_Recv"},
	{CSE_ACK_Recv,			"CSE_ACK_Recv"},
	{CSE_BOK_Recv,			"CSE_BOK_Recv"},
	{CSE_TIMEOUT,			"CSE_TIMEOUTE"},
	{CSE_Call_Refer,		"CSE_Call_Refer"}
};

char * sip_get_event_string(CSEVT event)
{
	uint32 i;
	
	for (i=0; i<sizeof(g_event_str)/sizeof(EVENTSTR); i++)
	{
		if(g_event_str[i].event == event)
		{
			return g_event_str[i].string;
		}			
	}

	return (char*) "Unknow Event";
}

static struct evt2name l_evt_name[] =
{
	{PUEVT_NULL,			"PUEVT_NULL"},
	{PUEVT_REGING,			"PUEVT_REGING"},
	{PUEVT_REG_PASS,		"PUEVT_REG_PASS"},
	{PUEVT_REG_FAIL,		"PUEVT_REG_FAIL"},
	{PUEVT_CALL_IN,			"PUEVT_CALL_IN"},
	{PUEVT_CALL_OUT,		"PUEVT_CALL_OUT"},
	{PUEVT_AUTH_REQ,		"PUEVT_AUTH_REQ"},
	{PUEVT_AUTH_PASS,		"PUEVT_AUTH_PASS"},
	{PUEVT_AUTH_FAIL,		"PUEVT_AUTH_FAIL"},
	{PUEVT_TIMEOUT,			"PUEVT_TIMEOUT"},
	{PUEVT_M_TIMEOUT,		"PUEVT_M_TIMEOUT"},
	{PUEVT_M_DTMF,			"PUEVT_M_DTMF"},
	{PUEVT_S_DTMF,			"PUEVT_S_DTMF"},
	{PUEVT_ALERT,			"PUEVT_ALERT"},
	{PUEVT_CONNECT,			"PUEVT_CONNECT"},
	{PUEVT_REINVITE,		"PUEVT_REINVITE"},
	{PUEVT_HANGUP,			"PUEVT_HANGUP"},
	{PUEVT_BUSY,			"PUEVT_BUSY"},
	{PUEVT_CANCEL_FINISH,	"PUEVT_CANCEL_FINISH"},
	{PUEVT_CALL_TERMINATE,	"PUEVT_CALL_TERMINATE"},
	{PUEVT_TMEP_UNAVAILABLE,"PUEVT_TMEP_UNAVAILABLE"},
	{PUEVT_CALL_FORBIDDEN,	"PUEVT_CALL_FORBIDDEN"},
	{PUEVT_ERROR,			"PUEVT_ERROR"},
	{PUEVT_LINE_FREE,		"PUEVT_LINE_FREE"},
	{PUEVT_R_MSG,			"PUEVT_R_MSG"},
	{PUEVT_ROSTER_RLY,		"PUEVT_ROSTER_RLY"},
	{PUEVT_ROSTER_ADD,		"PUEVT_ROSTER_ADD"},
	{PUEVT_ROSTER_STATE,	"PUEVT_ROSTER_STATE"},
	{PUEVT_ROSTER_NEW,		"PUEVT_ROSTER_NEW"},
	{PUEVT_ROSTER_DEL,		"PUEVT_ROSTER_DEL"},
	{PUEVT_CAMERA_ALARM,	"PUEVT_CAMERA_ALARM"},
	{PUEVT_T_MSG_F,			"PUEVT_T_MSG_F"},
	{PUEVT_M_VIDEO_OK,		"PUEVT_M_VIDEO_OK"},
	{PUEVT_MAX,				"PUEVT_MAX"}

};

char * sip_get_puaevt_name(PUAEVT evt)
{
	if (evt < PUEVT_MAX)
	{
		return l_evt_name[evt].name;
	}		
	else
	{
		return l_evt_name[PUEVT_MAX].name;
	}		
}

static struct cmd2name l_cmd_name[] =
{
	{PUCMD_NULL,		"PUCMD_NULL"},
	{PUCMD_ALERTING,	"PUCMD_ALERTING"},
	{PUCMD_DISCONNECT,	"PUCMD_DISCONNECT"},
	{PUCMD_FORBID,		"PUCMD_FORBID"},
	{PUCMD_BUSY,		"PUCMD_BUSY"},
	{PUCMD_NOUSER,		"PUCMD_NOUSER"},
	{PUCMD_CONNECT,		"PUCMD_CONNECT"},
	{PUCMD_ACCEPT,		"PUCMD_ACCEPT"},
	{PUCMD_REJECT,		"PUCMD_REJECT"},
	{PUCMD_CALL,		"PUCMD_CALL"},
	{PUCMD_REINVITE,	"PUCMD_REINVITE"},
	{PUCMD_PLAY,		"PUCMD_PLAY"},
	{PUCMD_REFER,		"PUCMD_REFER"},
	{PUCMD_UPLOAD_JPG,	"PUCMD_UPLOAD_JPG"},
	{PUCMD_UPLOAD_VRF,	"PUCMD_UPLOAD_VRF"},
	{PUCMD_TMSG,		"PUCMD_TMSG"},
	{PUCMD_AROSTER,		"PUCMD_AROSTER"},
	{PUCMD_DROSTER,		"PUCMD_DROSTER"},
	{PUCMD_MAX,			"PUCMD_MAX"}
};

char * sip_get_puacmd_name(PUACMD cmd)
{
	if (cmd < PUCMD_MAX)
	{
		return l_cmd_name[cmd].name;
	}		
	else
	{
		return l_cmd_name[PUCMD_MAX].name;
	}		
}

/***********************************************************************\
 日志文件消息记录函数
\***********************************************************************/
void sip_rx_msg_log(char * msg_buf, uint32 rx_ip, uint16 rx_port)
{
	char time_str[64];
	struct in_addr in;

	in.s_addr = rx_ip;

	get_time_str(time_str, sizeof(time_str));
	
//	if(hsip.log_rx_all == 1)
	{
		log_lock_start("RX << %s:%u [%s]\r\n", inet_ntoa(in), ntohs(rx_port), time_str);
		log_lock_end(msg_buf);
	}
}

void sip_tx_msg_log(char * msg_buf, uint32 tx_ip, uint16 tx_port)
{
	char time_str[64];
	struct in_addr in;

	in.s_addr = tx_ip;

	get_time_str(time_str, sizeof(time_str));

//	if(hsip.log_tx_all == 1)
	{
		log_lock_start("TX >> %s:%u [%s]\r\n", inet_ntoa(in), ntohs(tx_port), time_str);
		log_lock_end(msg_buf);
	}
}