EMS/svc.ems
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init ems server code

Browse Source
This commit is contained in:
simonzhangsz
2024-09-27 15:39:34 +08:00
parent 9d4009aaca
commit 9930e4e58f
1551 changed files with 110216 additions and 102864 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
plat/mgcp/Makefile Normal file
View File

@@ -0,0 +1,99 @@
##----------------------------------------------------------##
## ##
## Universal Makefile for module template : V1.6.3 ##
## ##
## Created : Wei Liu 07/04/11 ##
## Revision: [Last]Wei Liu 07/07/07 ##
## ##
##----------------------------------------------------------##
##---------------------------------------------------------------------##
##--------------------------------------
##
## Project correlation(Customer define)
##
##--------------------------------------
## MODULE= [Module Name]
## TYPE = app/plat => Module Type
## DBUG_FLAGS_ADD = [Module Define Gcc Flags for Debug ]
## DBUG_FLAGS_ADD = [Module Define Gcc Flags for Release]
## BUILD = lib/exef => Output file format
## CFG = debug/release => Build Configuration
## SRC_PATH = [Source file path]
## INC_PATH = [Include file path]
## APP_PATH = [App Module path]
## PLT_PATH = [Plat Module path]
## PLT_LIB = [Needed plat lib for Link] => just for test or wxc2main
## APP_LIB = [Needed app lib for Link] => just for test or wxc2main
## LIB_ADD = [Needed Extend lib for Link] => just for test or wxc2main
## PLT_LIB e.g. = haepub fsm mng proto kernel aif mgc mgcp sip rtp \
## 8ecp bicc smpp xapp tcap mtp3 m2ua \
## snmp iptrans debug sccp public
##
## APP_LIB e.g. = msc vlr ssf hlr ae pps mnp smsc vms aas
## LIB_ADD e.g. = -liba3a8 -lm
## OBJ_ADD = [Extend third party object files needed]
## TEST_OBJ_PATH = [module object files Path for test ] => just for test
##---------------------------------------------------------------------##
MODULE = mgcp
TYPE = plat
DBUG_FLAGS_ADD =
RELS_FLAGS_ADD =
##Default commonly as below
BUILD = lib
CFG = debug
PLT_LIB =
APP_LIB =
LIB_ADD =
SRC_PATH = ./src
INC_PATH = ./src/include
PLT_PATH = ../../plat
APP_PATH = ../../mss
OBJ_ADD =
TEST_OBJ_PATH =
PREPROC_CMD =
POSTPROC_CMD =
##---------------------------------------------------------------------##
##--------------------------------------
##
## Make configuration(Customer define)
##
##--------------------------------------
## CCFLAG_SWITCH = on/off => gcc flag show on/off
## COVER_NEED = yes/no => PTF cover report needed
## COVER_REPORT_PATH = [path ] => PTF cover report path
CCFLAG_SWITCH = off
COVER_NEED = no
COVER_REPORT_PATH = ./output
MAKE_INCLUDE = $(HOME)/ems.git/include
##---------------------------------------------------------------------##
##--------------------------------------
##
## include makefile.rules (Do not change)
##
##--------------------------------------
include $(MAKE_INCLUDE)/Makefile.rules

311
plat/mgcp/src/include/mgcp.h Normal file
View File

@@ -0,0 +1,311 @@
#ifndef _MGCP__H
#define _MGCP__H
#include "../../../public/src/include/pub_sdp.h"
#include "../../../iptrans/src/include/iptrans.h"
#define MGCP_RET_CODE_TEMP_RSP 100
#define MGCP_RET_CODE_TEMP_RSP_DESC "temp response"
#define MGCP_RET_CODE_TRANS_OK 200
#define MGCP_RET_CODE_TRANS_OK_DESC "OK"
#define MGCP_RET_CODE_TRANS_TIME_OUT 406
#define MGCP_RET_CODE_TRANS_TIME_OUT_DESC "transaction time out"
#define MGCP_RET_CODE_INTERNAL_OVERLOAD 409
#define MGCP_RET_CODE_INTERNAL_OVERLOAD_DESC "internal overload"
#define MGCP_RET_CODE_UNEP 500
#define MGCP_RET_CODE_UNEP_DESC "endpoint unknow"
#define MGCP_RET_CODE_UNCMD 504
#define MGCP_RET_CODE_UNCMD_DESC "unknow or unsupport command"
#define MGCP_RET_CODE_RCD_ERR 509
#define MGCP_RET_CODE_RCD_ERR_DESC "remoto connection descriptor error"
#define MGCP_RET_CODE_INCONID 515
#define MGCP_RET_CODE_INCONID_DESC "incorrect connect id"
#define MGCP_RET_CODE_UNCLLID 516
#define MGCP_RET_CODE_UNCLLID_DESC "unknow call id"
#define MGCP_RET_CODE_UNMD 517
#define MGCP_RET_CODE_UNMD_DESC "unsupported or invalid mode"
#define MGCP_RET_CODE_UNPKG 518
#define MGCP_RET_CODE_UNPKG_DESC "unsupported or unknow package"
#define MGCP_RET_CODE_NES 522
#define MGCP_RET_CODE_NES_DESC "no such event or signal"
#define MGCP_RET_CODE_ILCO 524
#define MGCP_RET_CODE_ILCO_DESC "internal inconsistency in LocalConnectionOption"
#define MGCP_RET_CODE_UNRM 526
#define MGCP_RET_CODE_UNRM_DESC "unknow or unsupported RestartMethod"
#define MGCP_MAX_NUM_OF_SAP 1
#define MGCP_MAX_NUM_OF_PORT 8192
#define MGCP_MAX_USER_NAME_LEN 16
#define MGCP_MAX_MG_NAME_LEN 32
#define MGCP_MAX_DOMAIN_LEN 64
#define MGCP_COMMAND 1
#define MGCP_RESPONSE 2
#define MGCP_CMD_CRCX 1
#define MGCP_CMD_MDCX 2
#define MGCP_CMD_DLCX 3
#define MGCP_CMD_RQNT 4
#define MGCP_CMD_NTFY 5
#define MGCP_CMD_AUEP 6
#define MGCP_CMD_RSIP 7
#define MGCP_EP_NAME_STRUCTURED 1
#define MGCP_EP_NAME_UNSTRUCTURED 2
#define MGCP_EP_NAME_CHNL_WILDCAST 0xFFFF
#define MGCP_EP_NAME_TRK_WILDCAST 0xFF
#define MGCP_MG_TYPE_AudioCoder 1
#define MGCP_MG_TYPE_LGC_MG 2
#define MGCP_MG_TYPE_SSW_CSS 3
#define MGCP_MG_TYPE_ANALOG 11
#define MGCP_MG_TYPE_ANN 21
#define MGCP_PORT_TYPE_E1 1
#define MGCP_PORT_TYPE_T1 2
#define MGCP_PORT_TYPE_AALN 3
#define MGCP_CON_MODE_INACTIVE 0
#define MGCP_CON_MODE_RECVONLY 1
#define MGCP_CON_MODE_SENDONLY 2
#define MGCP_CON_MODE_SENDRECV 3
#define MGCP_RST_MODE_RESTART 0
#define MGCP_RST_MODE_FORCED 1
#define MGCP_RST_MODE_DISCONNECTED 2
#define MGCP_RST_MODE_GRACEFUL 3
#define MGCP_RST_MODE_CANCEL_GRACEFUL 4
#define MGCP_PKG_L 0
#define MGCP_PKG_D 1
#define MGCP_PKG_G 2
#define MGCP_SIG_DL 1
#define MGCP_SIG_BZ 2
#define MGCP_SIG_RT 3
#define MGCP_SIG_WT 4
#define MGCP_L_SIG_AW 1
#define MGCP_L_SIG_DL 2
#define MGCP_L_SIG_BZ 3
#define MGCP_L_SIG_WT 4
#define MGCP_L_SIG_NBZ 5
#define MGCP_L_SIG_RG 6
#define MGCP_L_SIG_E 7
#define MGCP_L_SIG_OT 8
#define MGCP_D_SIG_ONE 1
#define MGCP_D_SIG_TWO 2
#define MGCP_D_SIG_THREE 3
#define MGCP_D_SIG_FOUR 4
#define MGCP_D_SIG_FIVE 5
#define MGCP_D_SIG_SIX 6
#define MGCP_D_SIG_SEVEN 7
#define MGCP_D_SIG_EIGHT 8
#define MGCP_D_SIG_NINE 9
#define MGCP_D_SIG_ZERO 10
#define MGCP_D_SIG_STAR 11
#define MGCP_D_SIG_POUND 12
#define MGCP_D_SIG_WILD 13
#define MGCP_G_SIG_RT 1
#define MGCP_G_SIG_CF 2
#define MGCP_G_SIG_CG 3
#define MGCP_G_SIG_IT 4
#define MGCP_G_SIG_PT 5
#define MGCP_OBDENT_ZERO 0
#define MGCP_OBDENT_HU 1
#define MGCP_OBDENT_HD 2
#define MGCP_L_EVENT_HD 1
#define MGCP_L_EVENT_HU 2
#define MGCP_L_EVENT_HF 3
#define MGCP_L_EVENT_AW 4
#define MGCP_L_EVENT_NBZ 5
#define MGCP_L_EVENT_E 6
#define MGCP_L_EVENT_OC 7
#define MGCP_L_EVENT_OF 8
#define MGCP_D_EVENT_ONE 1
#define MGCP_D_EVENT_TWO 2
#define MGCP_D_EVENT_THREE 3
#define MGCP_D_EVENT_FOUR 4
#define MGCP_D_EVENT_FIVE 5
#define MGCP_D_EVENT_SIX 6
#define MGCP_D_EVENT_SEVEN 7
#define MGCP_D_EVENT_EIGHT 8
#define MGCP_D_EVENT_NINE 9
#define MGCP_D_EVENT_ZERO 10
#define MGCP_D_EVENT_STAR 11
#define MGCP_D_EVENT_POUND 12
#define MGCP_G_EVENT_MT 1
#define MGCP_G_EVENT_FT 2
#define MGCP_G_EVENT_LD 3
#define MGCP_G_EVENT_OF 4
#define MGCP_PACKAGE_MAX 3
#define MGCP_PACKAGE_AALN 0
#define MGCP_PACKAGE_SIG_NONE 0
#define MGCP_PKG_AALN_SIG_MAX 18
#define MGCP_OBD_ENT_MAX 3
#define MGCP_ENT_MAX 18
#define MGCP_REST_MOD_MAX 5
#define MGCP_PARA_FLAG_SL 0x00000001
#define MGCP_PARA_FLAG_C 0x00000002
#define MGCP_PARA_FLAG_I 0x00000004
#define MGCP_PARA_FLAG_L 0x00000008
#define MGCP_PARA_FLAG_M 0x00000010
#define MGCP_PARA_FLAG_S 0x00000020
#define MGCP_PARA_FLAG_RM 0x00000040
#define MGCP_PARA_FLAG_RD 0x00000080
#define MGCP_PARA_FLAG_R 0x00000100
#define MGCP_PARA_FLAG_O 0x00000200
#define MGCP_PARA_FLAG_SDP 0x00000400
#define MGCP_PARA_FLAG_TFO 0x00000800
#define MGCP_PARA_L_FLAG_ESS_CCI 0x00000001
#define MGCP_PARA_L_FLAG_ESS_CCD 0x00000002
typedef struct _MGCP_ESCCD
{
char domain[MGCP_MAX_DOMAIN_LEN];
WORD port;
}MGCP_ESCCD;
typedef struct _MGCP_SL
{
BYTE cmdRes; // command or response
DWORD transId; // transaction ID for command received
BYTE epNameMethod; // structured/unstructured
BYTE mgType; // Non-Virtual/ANN
BYTE portType; // E1/T1/Analog
BYTE trkNum; // trunk number
WORD chlNum; // channel number
char mgName[MGCP_MAX_MG_NAME_LEN];
WORD retCode; // return code, for response message only
char desc[64]; // descriptions
}MGCP_SL;
typedef struct _MGCP_C
{
char callId[33]; // max 32 hexadecimal digits
}MGCP_C;
typedef struct _MGCP_I
{
char conId[33]; // max 32 hexadecimal digits
}MGCP_I;
typedef struct _MGCP_L
{
BYTE flag;
BYTE p; // packetization period in ms
char codec[16]; // PCMA/PCMU/EVRC/QCELP
char esCci[32];
MGCP_ESCCD esCcd;
BYTE ecDisable; // echo canceller enable or disable
BYTE ssDisable; // silence suppression enable or disable
}MGCP_L;
typedef struct _MGCP_M
{
BYTE mode; // inactive/recvonly/sendonly/sendrecv
}MGCP_M;
typedef struct _MGCP_S
{
BYTE pkg; // package id
BYTE signal; // signal id
char reqId[32];
}MGCP_S;
typedef struct _MGCP_RM
{
BYTE rm; // restart mode, restart/forced
}MGCP_RM;
typedef struct _MGCP_RD
{
WORD rd; // restart delay, no delay/delay time
}MGCP_RD;
typedef struct _MGCP_R
{
BYTE pkg; // package id
BYTE event; // signal id
char reqId[32];
}MGCP_R;
typedef struct _MGCP_O
{
BYTE package; // package id
BYTE event; // event id
char reqId[32];
}MGCP_O;
typedef struct _MGCP_PARA
{
DWORD ip;
WORD localPort;
WORD peerPort;
DWORD flag;
MGCP_SL sl;
MGCP_C c;
MGCP_I i;
MGCP_L l;
MGCP_M m;
MGCP_S s;
MGCP_RM rm;
MGCP_RD rd;
MGCP_R r;
MGCP_O o;
PUB_SDP_MSG sdp;
}MGCP_PARA;
typedef struct _MGCP_SAP
{
char name[MGCP_MAX_USER_NAME_LEN]; // User name
// The MGCP module sends a indication to its user when it receives a
// MGCP CRCX/MDCX/DLCX/RQNT/NTFY/AUEP/RSIP command message
int (*MGCP_ind)(BYTE cmd, WORD *usrPort, WORD hdlPort, MGCP_PARA *para);
// The MGCP module sends this failure/success return code to the user
int (*MGCP_cnf)(BYTE cmd, WORD usrPort, WORD hdlPort, WORD retCode, MGCP_PARA *para);
}MGCP_SAP;
int mgcp_bind(MGCP_SAP *sap);
int MGCP_req(BYTE sapIndex, BYTE cmd, WORD usrPort, MGCP_PARA *para);
int MGCP_rsp(BYTE sapIndex, BYTE cmd, WORD usrPort, WORD hdlPort, WORD retCode, MGCP_PARA *para);
#endif

47
plat/mgcp/src/include/mgcp_const.h Normal file
View File

@@ -0,0 +1,47 @@
#ifndef _MGCP_CONST__H
#define _MGCP_CONST__H
#define MGCP_REQUEST 1
#define MGCP_INDICATION 2
#define MGCP_TRANS_IDLE_STATE 0
#define MGCP_TRANS_AWAIT_PEER_RESPONSE_STATE 1
#define MGCP_TRANS_AWAIT_USER_RESPONSE_STATE 2
#define MGCP_TRANS_INIT_STATE 3
#define MGCP_MUTIPLE_T1S 100
#define MGCP_MAX_RETRANS_TIMER (10 * MGCP_MUTIPLE_T1S)
#define MGCP_RETRANS_TIMER (2 * MGCP_MUTIPLE_T1S)
#define MGCP_TIME_WAIT_TIMER (5 * MGCP_MUTIPLE_T1S)
#define MGCP_INT_PORT_2727 4966
#define MGCP_INT_PORT_2427 4967
#define MGCP_MAX_RET_CODE_INDEX 20
#define MGCP_RET_CODE_TRANS_TIME_OUT_INDEX 0
#define MGCP_RET_CODE_INTERNAL_OVERLOAD_INDEX 1
#define MGCP_RET_CODE_UNEP_INDEX 2
#define MGCP_RET_CODE_UNCMD_INDEX 3
#define MGCP_RET_CODE_RCD_ERR_INDEX 4
#define MGCP_RET_CODE_INCONID_INDEX 5
#define MGCP_RET_CODE_UNCLLID_INDEX 6
#define MGCP_RET_CODE_UNMD_INDEX 7
#define MGCP_RET_CODE_UNPKG_INDEX 8
#define MGCP_RET_CODE_NES_INDEX 9
#define MGCP_RET_CODE_ILCO_INDEX 10
#define MGCP_RET_CODE_UNRM_INDEX 11
#define MGCP_RET_CODE_TRANS_OK_INDEX 12
#define MGCP_RET_CODE_TEMP_RSP_INDEX 13
#define MGCP_MAX_ASCIIIN_LEN 4096
#define MGCP_MAX_ASCIIOUT_LEN 4096
#define MGCP_MAX_ASCITMP_LEN 4096
#define MONITOR_NONE 0x0000
#define MONITOR_ERROR 0x0001
#define MONITOR_MG0_MSG 0x0002
#define MONITOR_MG1_MSG 0x0004
#define MONITOR_MG2_MSG 0x0008
#define MONITOR_ALL 0xffff
#endif

10
plat/mgcp/src/include/mgcp_debug.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef _MGCP_DEBUG__H
#define _MGCP_DEBUG__H
void mgcp_mon(void);
int mgcp_debug_set(void);
int mgcp_asciout_proc(BYTE *outStr);
int mgcp_hex_to_ascii(BYTE *fromHex, BYTE fromLen, BYTE *toAsc);
int mgcp_log_err(BYTE *errMsg);
#endif

62
plat/mgcp/src/include/mgcp_def.h Normal file
View File

@@ -0,0 +1,62 @@
#ifndef _MGCP_DEF__H
#define _MGCP_DEF__H
#include "mgcp_pub.h"
#include "mgcp.h"
#include "mgcp_const.h"
#include "mgcp_struct.h"
MGCP_SAP mgcpSap[MGCP_MAX_NUM_OF_SAP];
MGCP_PORT mgcpPort[MGCP_MAX_NUM_OF_PORT];
WORD mgcpTransStart[MGCP_MAX_NUM_OF_PORT];
WORD mgcpPortSelect;
char mgcpCmdToStr[8][5] = {{""}, {"CRCX"}, {"MDCX"}, {"DLCX"}, {"RQNT"}, {"NTFY"}, {"AUEP"}, {"RSIP"}};
char mgcpConModeToStr[4][9] = {{"inactive"}, {"recvonly"}, {"sendonly"}, {"sendrecv"}};
char mgcpPkgToStr[MGCP_PACKAGE_MAX][8] = {{"L"},{"D"},{"G"}};
char mgcpAalnSigToStr[MGCP_PACKAGE_MAX][MGCP_PKG_AALN_SIG_MAX][16] = {{"", "aw", "dl", "bz", "wt", "nbz", "rg", "e", "ot"}
, {"", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "*", "#", "[0-9*#](N)"}
, {"", "rt", "cf", "cg", "it", "pt"}};
char mgcpEntToStr[MGCP_PACKAGE_MAX][MGCP_ENT_MAX][16] = {{"", "hd", "hu", "hf", "aw", "nbz", "e", "oc", "of"}
, {"", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "*", "#","[0-9#*](N)"}
, {"", "mt", "ft", "ld", "of"}
};
char mgcpRestModToStr[MGCP_REST_MOD_MAX][16] = {{"restart"}, {"forced"}, {"disconnected"}, {"graceful"}, {"cancel-graceful"}};
BYTE mgcpMaxPkgSig[MGCP_PACKAGE_MAX] = {8, 13, 5};
BYTE mgcpMaxPkgEvent[MGCP_PACKAGE_MAX] = {8, 13, 4};
message_list mgcpSdMsg;
message_list mgcpRvMsg;
MGCP_PARA mgcpRespPara;
MGCP_RET_CODE mgcpRetCode[MGCP_MAX_RET_CODE_INDEX] = { {MGCP_RET_CODE_TRANS_TIME_OUT, MGCP_RET_CODE_TRANS_TIME_OUT_DESC}
, {MGCP_RET_CODE_INTERNAL_OVERLOAD, MGCP_RET_CODE_INTERNAL_OVERLOAD_DESC}
, {MGCP_RET_CODE_UNEP, MGCP_RET_CODE_UNEP_DESC}
, {MGCP_RET_CODE_UNCMD, MGCP_RET_CODE_UNCMD_DESC}
, {MGCP_RET_CODE_RCD_ERR, MGCP_RET_CODE_RCD_ERR_DESC}
, {MGCP_RET_CODE_INCONID, MGCP_RET_CODE_INCONID_DESC}
, {MGCP_RET_CODE_UNCLLID, MGCP_RET_CODE_UNCLLID_DESC}
, {MGCP_RET_CODE_UNMD,MGCP_RET_CODE_UNMD_DESC}
, {MGCP_RET_CODE_UNPKG, MGCP_RET_CODE_UNPKG_DESC}
, {MGCP_RET_CODE_NES, MGCP_RET_CODE_NES_DESC}
, {MGCP_RET_CODE_ILCO, MGCP_RET_CODE_ILCO_DESC}
, {MGCP_RET_CODE_UNRM, MGCP_RET_CODE_UNRM_DESC}
, {MGCP_RET_CODE_TRANS_OK, MGCP_RET_CODE_TRANS_OK_DESC}
, {MGCP_RET_CODE_TEMP_RSP, MGCP_RET_CODE_TEMP_RSP_DESC}
};
BYTE mgcpAsciInBuf[MGCP_MAX_ASCIIIN_LEN];
BYTE mgcpAsciOutBuf[MGCP_MAX_ASCIIOUT_LEN];
BYTE mgcpAsciTempBuf[MGCP_MAX_ASCITMP_LEN];
WORD mgcpMonitorFg;
char dbgmgNamemg[3][MGCP_MAX_MG_NAME_LEN];
#endif

42
plat/mgcp/src/include/mgcp_ext.h Normal file
View File

@@ -0,0 +1,42 @@
#ifndef _MGCP_EXT__H
#define _MGCP_EXT__H
#include "mgcp_pub.h"
#include "mgcp.h"
#include "mgcp_const.h"
#include "mgcp_struct.h"
extern MGCP_SAP mgcpSap[MGCP_MAX_NUM_OF_SAP];
extern MGCP_PORT mgcpPort[MGCP_MAX_NUM_OF_PORT];
extern WORD mgcpTransStart[MGCP_MAX_NUM_OF_PORT];
extern WORD mgcpPortSelect;
extern char mgcpCmdToStr[8][5];
extern char mgcpConModeToStr[4][9];
extern char mgcpPkgToStr[MGCP_PACKAGE_MAX][8];
extern char mgcpAalnSigToStr[MGCP_PACKAGE_MAX][MGCP_PKG_AALN_SIG_MAX][16];
extern char mgcpEntToStr[MGCP_PACKAGE_MAX][MGCP_ENT_MAX][16];
extern char mgcpRestModToStr[MGCP_REST_MOD_MAX][8];
extern BYTE mgcpMaxPkgSig[MGCP_PACKAGE_MAX];
extern BYTE mgcpMaxPkgEvent[MGCP_PACKAGE_MAX];
extern message_list mgcpSdMsg;
extern message_list mgcpRvMsg;
extern MGCP_PARA mgcpRespPara;
extern MGCP_RET_CODE mgcpRetCode[MGCP_MAX_RET_CODE_INDEX];
extern BYTE mgcpAsciInBuf[MGCP_MAX_ASCIIIN_LEN];
extern BYTE mgcpAsciOutBuf[MGCP_MAX_ASCIIOUT_LEN];
extern BYTE mgcpAsciTempBuf[MGCP_MAX_ASCITMP_LEN];
extern WORD mgcpMonitorFg;
extern char dbgmgNamemg[3][MGCP_MAX_MG_NAME_LEN];
#endif

10
plat/mgcp/src/include/mgcp_msg.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef _MGCP_MSG__H
#define _MGCP_MSG__H
void mgcp_recv_msg();
int mgcp_send_msg(WORD port, BYTE cmdRes);
int mgcp_send_incmd_rsp(DWORD transId, BYTE retCodeIndex);
int mgcp_send_rsp(WORD port, BYTE retCodeIndex);
int mgcp_ep_id_encode(MGCP_SL *sl, char *endPointId);
#endif

55
plat/mgcp/src/include/mgcp_pub.h Normal file
View File

@@ -0,0 +1,55 @@
#ifndef _MGCP_PUB__H
#define _MGCP_PUB__H
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <memory.h>
#include <netdb.h>
#include <setjmp.h>
#include <unistd.h>
#include <signal.h>
//by simon at 23/9/22
//#include <stropts.h>
#include <time.h>
#include <syslog.h>
#include <termio.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/io.h>
#include <sys/poll.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/socket.h>
#include <sys/select.h>
#ifndef _T_BYTE
#define _T_BYTE
typedef unsigned char BYTE;
#endif
#ifndef _T_WORD
#define _T_WORD
typedef unsigned short WORD;
#endif
#ifndef _T_DWORD
#define _T_DWORD
typedef unsigned int DWORD;
#endif
#endif

31
plat/mgcp/src/include/mgcp_struct.h Normal file
View File

@@ -0,0 +1,31 @@
#ifndef _MGCP_STRUCT__H
#define _MGCP_STRUCT__H
#include "mgcp.h"
#include "mgcp_const.h"
typedef struct _MGCP_PORT
{
BYTE flag; // used or not
BYTE sapIndex;
BYTE state; // mgcp transaction state
BYTE state2; // mgcp transaction state #2
BYTE cmd; // mgcp command
BYTE reqInd; // request or indication
BYTE gotProvRes; // got provisional response flag
WORD usrPort;
DWORD timer;
DWORD transId; // transaction id
MGCP_PARA para; // operation specific parameters, used for command
// MGCP_PARA paraAux; // auxilliary parameters, used for response
}MGCP_PORT;
typedef struct _MGCP_RET_CODE
{
WORD retCode;
char desc[64];
}MGCP_RET_CODE;
#endif

8
plat/mgcp/src/include/mgcp_trans.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef _MGCP_TRANS__H
#define _MGCP_TRANS__H
void mgcp_trans_proc();
int mgcp_match_client_trans(DWORD transId);
int mgcp_match_server_trans(DWORD transId);
#endif

249
plat/mgcp/src/mgcp.c Normal file
View File

@@ -0,0 +1,249 @@
/****************************************************************/
/* MGCP Implementation Program */
/* Version 9.0.1 */
/* Designed By Ying Min */
/* Last Update: 2007-3-26 */
/****************************************************************/
#include "./include/mgcp_pub.h"
#include "./include/mgcp.h"
#include "./include/mgcp_const.h"
#include "./include/mgcp_def.h"
#include "./include/mgcp_struct.h"
#include "./include/mgcp_msg.h"
#include "./include/mgcp_trans.h"
#include "./include/mgcp_debug.h"
void mgcp_init(void)
{
printf("MGCP Init Start!\n");
memset((BYTE *) &mgcpSap[0], 0, sizeof(MGCP_SAP) * MGCP_MAX_NUM_OF_SAP);
memset((BYTE *) &mgcpPort[0], 0, sizeof(MGCP_PORT) * MGCP_MAX_NUM_OF_PORT);
memset((BYTE *) &mgcpTransStart[0], 0, sizeof(WORD) * MGCP_MAX_NUM_OF_PORT);
mgcpPortSelect = 1;
mgcp_debug_set();
printf("MGCP Init Complete!\n");
}
// Called every 10 ms
void mgcp_t10ms()
{
static DWORD cnt_10ms = 0;
if (!(++cnt_10ms % 10))
{ // 100 ms
mgcp_mon();
}
}
void mgcp_timer(void)
{
mgcp_recv_msg();
mgcp_trans_proc();
mgcp_t10ms();
}
int mgcp_sap_init(BYTE sapIndex)
{
if (sapIndex >= MGCP_MAX_NUM_OF_SAP)
return -1;
memset((BYTE *) &mgcpSap[sapIndex], 0, sizeof(MGCP_SAP));
return 0;
}
int mgcp_port_init(WORD port)
{
if(port >= MGCP_MAX_NUM_OF_PORT)
return -1;
memset((BYTE *) &mgcpPort[port], 0, sizeof(MGCP_PORT));
return 0;
}
int mgcp_bind(MGCP_SAP *sap)
{
if ((sap == NULL) ||
(sap->MGCP_ind == NULL) ||
(sap->MGCP_cnf == NULL))
return -1;
if ((mgcpSap[0].MGCP_ind != NULL) ||
(mgcpSap[0].MGCP_cnf != NULL))
return -1;
memcpy((BYTE *) &mgcpSap[0], sap, sizeof(MGCP_SAP));
mgcpSap[0].name[MGCP_MAX_USER_NAME_LEN - 1] = '\0';
return 0;
}
int mgcp_unbind(MGCP_SAP *sap, BYTE sapIndex)
{
if ((sap == NULL) || (sapIndex >= MGCP_MAX_NUM_OF_SAP))
return -1;
if (strcmp(sap->name, mgcpSap[sapIndex].name) != 0)
return -1;
if (mgcp_sap_init(sapIndex) < 0)
return -1;
return 0;
}
int mgcp_get_port()
{
WORD port = mgcpPortSelect;
WORD i;
if ((port >= MGCP_MAX_NUM_OF_PORT) || (port == 0))
{
if ((mgcpMonitorFg & MONITOR_ERROR) == MONITOR_ERROR)
{
sprintf(mgcpAsciTempBuf, "mgcpPortSelect may be changed\n port=%d\n", port);
mgcp_log_err(mgcpAsciTempBuf);
}
port = 1;
}
for (i = 1; i < MGCP_MAX_NUM_OF_PORT; i++)
{
if (mgcpPort[port].flag == 1)
{
if (++port >= MGCP_MAX_NUM_OF_PORT)
port = 1;
continue;
}
mgcpPort[port].flag = 1;
mgcpPortSelect = port + 1;
if (mgcpPortSelect >= MGCP_MAX_NUM_OF_PORT)
mgcpPortSelect = 1;
return port;
}
return -1;
}
int MGCP_req(BYTE sapIndex, BYTE cmd, WORD usrPort, MGCP_PARA *para)
{
int port;
if ((sapIndex >= MGCP_MAX_NUM_OF_SAP) ||
(cmd < MGCP_CMD_CRCX) ||
(cmd > MGCP_CMD_RSIP) ||
(para == NULL))
return -1;
if ((port = mgcp_get_port()) < 0)
return -1;
mgcpPort[port].sapIndex = sapIndex;
mgcpPort[port].usrPort = usrPort;
mgcpPort[port].cmd = cmd;
mgcpPort[port].reqInd = MGCP_REQUEST;
memcpy((BYTE *) &mgcpPort[port].para, para, sizeof(MGCP_PARA));
return port;
}
int MGCP_cancel_req(BYTE sapIndex, BYTE cmd, WORD usrPort, WORD hdlPort)
{
MGCP_PORT *trans;
if ((sapIndex >= MGCP_MAX_NUM_OF_SAP) ||
(cmd < MGCP_CMD_CRCX) ||
(cmd > MGCP_CMD_RSIP) ||
(hdlPort >= MGCP_MAX_NUM_OF_PORT) ||
(hdlPort == 0))
return -1;
trans = &mgcpPort[hdlPort];
if ((trans->cmd != cmd) ||
(trans->reqInd != MGCP_REQUEST))
return -1;
trans->cmd = 0;
return 0;
}
int MGCP_rsp(BYTE sapIndex, BYTE cmd, WORD usrPort, WORD hdlPort, WORD retCode, MGCP_PARA *para)
{
if ((sapIndex >= MGCP_MAX_NUM_OF_SAP) ||
(cmd < MGCP_CMD_CRCX) ||
(cmd > MGCP_CMD_RSIP) ||
(para == NULL) ||
(hdlPort >= MGCP_MAX_NUM_OF_PORT) ||
(hdlPort == 0))
return -1;
memcpy((BYTE *) &mgcpPort[hdlPort].para, para, sizeof(MGCP_PARA));
if ((retCode >=200) && (retCode < 300))
{
mgcpPort[hdlPort].para.sl.retCode = retCode;
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_TRANS_OK_INDEX].desc);
}
else if ((retCode >=100) && (retCode < 200))
{
mgcpPort[hdlPort].para.sl.retCode = retCode;
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_TEMP_RSP_INDEX].desc);
}
else
{
mgcpPort[hdlPort].para.sl.retCode = retCode;
switch(retCode)
{
case MGCP_RET_CODE_TRANS_TIME_OUT:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_TRANS_TIME_OUT_INDEX].desc);
case MGCP_RET_CODE_INTERNAL_OVERLOAD:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_TRANS_TIME_OUT_INDEX].desc);
case MGCP_RET_CODE_UNEP:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_UNEP_INDEX].desc);
case MGCP_RET_CODE_UNCMD:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_UNCMD_INDEX].desc);
case MGCP_RET_CODE_RCD_ERR:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_RCD_ERR_INDEX].desc);
case MGCP_RET_CODE_INCONID:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_INCONID_INDEX].desc);
case MGCP_RET_CODE_UNCLLID:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_UNCLLID_INDEX].desc);
case MGCP_RET_CODE_UNMD:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_UNMD_INDEX].desc);
case MGCP_RET_CODE_UNPKG:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_UNPKG_INDEX].desc);
case MGCP_RET_CODE_NES:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_NES_INDEX].desc);
case MGCP_RET_CODE_ILCO:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_ILCO_INDEX].desc);
case MGCP_RET_CODE_UNRM:
strcpy(mgcpPort[hdlPort].para.sl.desc, mgcpRetCode[MGCP_RET_CODE_UNRM_INDEX].desc);
default:
strcpy(mgcpPort[hdlPort].para.sl.desc, "FAILED");
}
}
return 0;
}

585
plat/mgcp/src/mgcp_debug.c Normal file
View File

@@ -0,0 +1,585 @@
#include "./include/mgcp_pub.h"
#include "./include/mgcp.h"
#include "./include/mgcp_const.h"
#include "./include/mgcp_struct.h"
#include "./include/mgcp_ext.h"
#include "../../debug/src/include/debug.h"
#define MGCP_DEBUG_ID 19
#define MGCP_VER_DEBUG "R9V0_02"
extern char *mgcp_clrncpy(char *dst, char *src, WORD len);
static char ascii[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
static BYTE log_help[] = {
"MGCP Debug Monitor Help:\n\r\
\n\r\
1.[help] display help menu\n\r\
2.[log all/none] display all/none logs\n\r\
3.[log error on/off] display error logs\n\r\
4.[log mg-mg_name on/off] display MGCP specific mg msg logs\n\r\
5.[list] display all mg which have been log\n\r"
};
static WORD disp_page[10];
static BYTE *disp_ptr = (BYTE *) disp_page;
static DWORD debug_status_id[20] =
{
1,3,6,1,4,1,1373,1,1,2,3,1,2,MGCP_DEBUG_ID + 2,1
};
static BYTE debug_status = 1;
static DWORD debug_name_id[20] =
{
1,3,6,1,4,1,1373,1,1,2,3,1,2,MGCP_DEBUG_ID + 2,2
};
static DWORD debug_ascin_id[20] =
{
1,3,6,1,4,1,1373,1,1,2,3,1,2,MGCP_DEBUG_ID + 2,3
};
static DWORD debug_ascout_id[20] =
{
1,3,6,1,4,1,1373,1,1,2,3,1,2,MGCP_DEBUG_ID + 2,4
};
static DWORD debug_page_title[20] =
{
1,3,6,1,4,1,1373,1,1,2,3,1,2,MGCP_DEBUG_ID + 2,1,1
};
static DWORD debug_page_line[20] =
{
1,3,6,1,4,1,1373,1,1,2,3,1,2,MGCP_DEBUG_ID + 2,1,2,1
};
const static BYTE PAGE_POINT = 14;
const static BYTE LINE_POINT = 15;
const static BYTE BASE_ID_LEN = 15;
static BYTE title1_p[] =
{
" MGCP Page 01 mgcpPort Status\n\r\
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15\n\r\
Subpage\n\r\
Trans_Status\n\r"
};
BYTE mgcp_disp_line(BYTE page, BYTE line)
{
BYTE disp_length;
disp_length = 16;
disp_ptr = (BYTE *) disp_page;
switch (page)
{
case 1: // Page 1: SG Para
if (line == 0)
{
disp_ptr = (BYTE *) &disp_page[page];
disp_length = 2;
}
else
disp_ptr = (BYTE *) &mgcpPort[disp_page[page]];
break;
default:
disp_length = 0;
break;
}
return disp_length;
}
void mgcp_disp_page(BYTE page)
{
BYTE disp_line;
BYTE disp_length;
debug_page_line[PAGE_POINT] = page + 5;
for (disp_line = 0; disp_line < 22; disp_line++)
{
disp_length = mgcp_disp_line(page, disp_line);
debug_page_line[LINE_POINT] = disp_line + 2;
debug_page_line[LINE_POINT + 1] = 2; // Data Pointer
debug_set_response(BASE_ID_LEN + 2, debug_page_line, disp_ptr, disp_length);
}
}
int mgcp_debug_set(void)
{
BYTE page;
BYTE data[10];
BYTE *ptr;
bzero(disp_page, 20);
ptr = data;
debug_set_response(BASE_ID_LEN, debug_status_id, &debug_status, 1);
debug_set_response(BASE_ID_LEN, debug_name_id, MGCP_VER_DEBUG, 10);
debug_set_response(BASE_ID_LEN, debug_ascin_id, mgcpAsciInBuf, 4096);
debug_set_response(BASE_ID_LEN, debug_ascout_id, mgcpAsciOutBuf, 4096);
for (page = 1; page < 2; page++)
{
switch (page)
{
case 1: //page 1
ptr = title1_p;
break;
default:
break;
}
debug_page_title[PAGE_POINT] = 5 + page;
debug_set_response(BASE_ID_LEN + 1, debug_page_title, ptr, strlen(ptr));
mgcp_disp_page(page);
}
return 1;
}
int mgcp_asciout_proc(BYTE *outStr)
{
int outLen;
outLen = strlen(outStr);
if (outLen + strlen(mgcpAsciOutBuf) > MGCP_MAX_ASCIIOUT_LEN - 2)
{
strcpy(mgcpAsciOutBuf, outStr);
}
else
strcat(mgcpAsciOutBuf, outStr);
return 1;
}
void mgcp_mon(void)
{
BYTE inPage, errFg = 0;
BYTE *asciiInPtr = NULL;
BYTE *mgNM = NULL;
// BYTE *trkNM = NULL;
// BYTE *chlNM = NULL;
BYTE *poo = NULL;
BYTE *strStart = NULL;
BYTE tmp[128];
// BYTE tmptrkNum;
// WORD tmpchlNum;
WORD strLen, num;
if ((strLen = strlen(mgcpAsciInBuf)) > 0)
{
inPage = mgcpAsciInBuf[0] - 1;
asciiInPtr = mgcpAsciInBuf + 1;
if (inPage > 7)
errFg = 1;
else if (strcmp(asciiInPtr,"c") == 0)
{
}
else if (strcmp(asciiInPtr,"log error on") == 0)
{
mgcpMonitorFg = mgcpMonitorFg | MONITOR_ERROR;
}
else if (strcmp(asciiInPtr,"log error off") == 0)
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_ERROR);
}
else if (strncmp(asciiInPtr,"log mg-", 7) == 0)
{
if (NULL == (poo = strrchr(asciiInPtr, 'o')))
{
errFg = 1;
}
else
{
mgNM = strchr(asciiInPtr, '-');
if (poo <= mgNM)
{
errFg = 1;
}
else
{
mgcp_clrncpy(tmp, mgNM+1, poo-mgNM-1);
if (0 == strcmp(poo, "on"))
{
if(mgcpMonitorFg == MONITOR_ALL)
{
mgcp_asciout_proc("Status is log all\n\r");
}
else if (((mgcpMonitorFg & MONITOR_MG0_MSG) == MONITOR_MG0_MSG)
&& ((mgcpMonitorFg & MONITOR_MG1_MSG) == MONITOR_MG1_MSG)
&& ((mgcpMonitorFg & MONITOR_MG2_MSG) == MONITOR_MG2_MSG)
&&(mgcpMonitorFg != MONITOR_ALL))
{
mgcp_asciout_proc("Can not log more MG\n\r");
}
else
{
if ((((mgcpMonitorFg & MONITOR_MG0_MSG) == MONITOR_MG0_MSG) && (0 == strcmp(dbgmgNamemg[0], tmp)))
|| (((mgcpMonitorFg & MONITOR_MG1_MSG) == MONITOR_MG1_MSG) && (0 == strcmp(dbgmgNamemg[1], tmp)))
|| (((mgcpMonitorFg & MONITOR_MG2_MSG) == MONITOR_MG2_MSG) && (0 == strcmp(dbgmgNamemg[2], tmp))))
{
mgcp_asciout_proc("MG already be on\n\r");
}
else
{
if (((mgcpMonitorFg & MONITOR_MG0_MSG) == 0) && (0 == strcmp(dbgmgNamemg[0], tmp)))
{
mgcpMonitorFg |= MONITOR_MG0_MSG;
}
else if (((mgcpMonitorFg & MONITOR_MG1_MSG) == 0) && (0 == strcmp(dbgmgNamemg[1], tmp)))
{
mgcpMonitorFg |= MONITOR_MG1_MSG;
}
else if (((mgcpMonitorFg & MONITOR_MG2_MSG) == 0) && (0 == strcmp(dbgmgNamemg[2], tmp)))
{
mgcpMonitorFg |= MONITOR_MG2_MSG;
}
else if ((mgcpMonitorFg & MONITOR_MG0_MSG) == 0)
{
strcpy(dbgmgNamemg[0], tmp);
mgcpMonitorFg |= MONITOR_MG0_MSG;
}
else if ((mgcpMonitorFg & MONITOR_MG1_MSG) == 0)
{
strcpy(dbgmgNamemg[1], tmp);
mgcpMonitorFg |= MONITOR_MG1_MSG;
}
else
{
strcpy(dbgmgNamemg[2], tmp);
mgcpMonitorFg |= MONITOR_MG2_MSG;
}
}
}
}
else if (0 == strcmp(poo, "off"))
{
if (mgcpMonitorFg == MONITOR_NONE)
{
mgcp_asciout_proc("Status is log none\n\r");
}
else if((mgcpMonitorFg == MONITOR_ALL)
||((mgcpMonitorFg | MONITOR_MG0_MSG | MONITOR_MG1_MSG | MONITOR_MG2_MSG | MONITOR_ERROR) == MONITOR_ALL))
{
if (mgcpMonitorFg == MONITOR_ALL)
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG0_MSG);
strcpy(dbgmgNamemg[0], tmp);
}
else if (((mgcpMonitorFg & MONITOR_MG0_MSG) == MONITOR_MG0_MSG)
||((mgcpMonitorFg & MONITOR_MG1_MSG) == MONITOR_MG1_MSG)
||((mgcpMonitorFg & MONITOR_MG2_MSG) == MONITOR_MG2_MSG))
{
if(((0 == strcmp(dbgmgNamemg[0], tmp)) && ((mgcpMonitorFg & MONITOR_MG0_MSG) == 0))
||((0 == strcmp(dbgmgNamemg[1], tmp)) && ((mgcpMonitorFg & MONITOR_MG1_MSG) == 0))
||((0 == strcmp(dbgmgNamemg[2], tmp)) && ((mgcpMonitorFg & MONITOR_MG2_MSG) == 0)))
{
mgcp_asciout_proc("MG already be off\n\r");
}
else if ((mgcpMonitorFg & MONITOR_MG0_MSG) == MONITOR_MG0_MSG)
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG0_MSG);
strcpy(dbgmgNamemg[0], tmp);
}
else if ((mgcpMonitorFg & MONITOR_MG1_MSG) == MONITOR_MG1_MSG)
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG1_MSG);
strcpy(dbgmgNamemg[1], tmp);
}
else
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG2_MSG);
strcpy(dbgmgNamemg[2], tmp);
}
}
else
{
mgcp_asciout_proc("Can not off more MG\n\r");
}
}
else if (0 == strcmp(dbgmgNamemg[0], tmp))
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG0_MSG);
}
else if (0 == strcmp(dbgmgNamemg[1], tmp))
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG1_MSG);
}
else if (0 == strcmp(dbgmgNamemg[2], tmp))
{
mgcpMonitorFg = mgcpMonitorFg & (~MONITOR_MG2_MSG);
}
else
{
mgcp_asciout_proc("MG has not been on\n\r");
}
}
else
{
errFg = 1;
}
}
}
}
/* else if (strncmp(asciiInPtr,"log trk-", 8) == 0)
{
if (NULL == (poo = strrchr(asciiInPtr, 'o')))
{
errFg = 1;
}
else
{
mgNM = strchr(asciiInPtr, '-');
if (NULL == (trkNM = strchr(mgNM+1, '-')))
{
errFg = 1;
}
else
{
mgcp_clrncpy(tmp, mgNM+1, trkNM-mgNM-1);
tmptrkNum = strtoul(trkNM+1, NULL, 10);
if (0 == strcmp(poo, "on"))
{
strcpy(dbgmgNametrk, tmp);
dbgtrkNumtrk = tmptrkNum;
mgcpMonitorFg |= MONITOR_TRK_MSG;
}
else if (0 == strcmp(poo, "off"))
{
if ((0 == strcmp(dbgmgNamemg, tmp))||((0 == strcmp(dbgmgNametrk, tmp))&&(dbgtrkNumtrk == tmptrkNum)))
{
strcpy(dbgmgNametrk, tmp);
dbgtrkNumtrk = tmptrkNum;
mgcpMonitorFg &= (~MONITOR_TRK_MSG);
}
else
{
mgcp_asciout_proc("trk already be off!\n\r");
}
}
else
{
errFg = 1;
}
}
}
}
else if (strncmp(asciiInPtr,"log chl-", 8) == 0)
{
if (NULL == (poo = strrchr(asciiInPtr, 'o')))
{
errFg = 1;
}
else
{
mgNM = strchr(asciiInPtr, '-');
if (NULL == (trkNM = strchr(mgNM+1, '-')))
{
errFg = 1;
}
else
{
if (NULL == (chlNM = strchr(trkNM, '-')))
{
errFg = 1;
}
else
{
mgcp_clrncpy(tmp, mgNM+1, trkNM-mgNM-1);
tmptrkNum = strtoul(trkNM+1, NULL, 10);
tmpchlNum = strtoul(chlNM+1, NULL, 10);
if (0 == strcmp(poo, "on"))
{
strcpy(dbgmgNamechl, tmp);
dbgtrkNumchl = tmptrkNum;
dbgchlNumchl = tmpchlNum;
mgcpMonitorFg |= MONITOR_TRK_MSG;
}
else if (0 == strcmp(poo, "off"))
{
if ((0 == strcmp(dbgmgNamemg, tmp))||((0 == strcmp(dbgmgNametrk, tmp))&&(dbgtrkNumtrk == tmptrkNum))
||((0 == strcmp(dbgmgNamechl, tmp))&&(dbgtrkNumchl == tmptrkNum)&&(dbgchlNumchl == tmpchlNum)))
{
strcpy(dbgmgNamechl, tmp);
dbgtrkNumchl = tmptrkNum;
dbgchlNumchl = tmpchlNum;
mgcpMonitorFg &= (~MONITOR_TRK_MSG);
}
else
{
mgcp_asciout_proc("chl already be off!\n\r");
}
}
else
{
errFg = 1;
}
}
}
}
}
*/
else if (strcmp(asciiInPtr, "list") == 0)
{
if ((mgcpMonitorFg & MONITOR_MG0_MSG) == MONITOR_MG0_MSG)
{
sprintf(mgcpAsciTempBuf, "MG :%s on\r\n", dbgmgNamemg[0]);
mgcp_asciout_proc(mgcpAsciTempBuf);
}
else
{
sprintf(mgcpAsciTempBuf, "MG :%s off\r\n", dbgmgNamemg[0]);
mgcp_asciout_proc(mgcpAsciTempBuf);
}
if ((mgcpMonitorFg & MONITOR_MG1_MSG) == MONITOR_MG1_MSG)
{
sprintf(mgcpAsciTempBuf, "MG :%s on\r\n", dbgmgNamemg[1]);
mgcp_asciout_proc(mgcpAsciTempBuf);
}
else
{
sprintf(mgcpAsciTempBuf, "MG :%s off\r\n", dbgmgNamemg[1]);
mgcp_asciout_proc(mgcpAsciTempBuf);
}
if ((mgcpMonitorFg & MONITOR_MG2_MSG) == MONITOR_MG2_MSG)
{
sprintf(mgcpAsciTempBuf, "MG :%s on\r\n", dbgmgNamemg[2]);
mgcp_asciout_proc(mgcpAsciTempBuf);
}
else
{
sprintf(mgcpAsciTempBuf, "MG :%s off\r\n", dbgmgNamemg[2]);
mgcp_asciout_proc(mgcpAsciTempBuf);
}
}
else if (strcmp(asciiInPtr,"log all") == 0)
{
strcpy(dbgmgNamemg[0], "");
strcpy(dbgmgNamemg[1], "");
strcpy(dbgmgNamemg[2], "");
mgcpMonitorFg = MONITOR_ALL;
}
else if (strcmp(asciiInPtr,"log none") == 0)
{
strcpy(dbgmgNamemg[0], "");
strcpy(dbgmgNamemg[1], "");
strcpy(dbgmgNamemg[2], "");
mgcpMonitorFg = MONITOR_NONE;
}
else if (strcmp(asciiInPtr,"help") == 0)
{
mgcp_asciout_proc(log_help);
}
else if (isdigit(asciiInPtr[0]))
{
num = strtoul(asciiInPtr, NULL, 10);
disp_page[inPage] = num;
mgcp_disp_page(inPage);
}
else if ((strStart = strstr(asciiInPtr, ">")) != NULL)
{
num = strtoul(strStart + 1, NULL, 10);
disp_page[inPage] += num;
mgcp_disp_page(inPage);
}
else if ((strStart = strstr(asciiInPtr, "<"))!= NULL)
{
num = strtoul(strStart + 1, NULL, 10);
disp_page[inPage] -= num;
mgcp_disp_page(inPage);
}
else
errFg = 1;
if (errFg == 0)
mgcp_asciout_proc("Command OK!\n\r");
else
mgcp_asciout_proc("Command Error!\n\r");
strcpy(mgcpAsciInBuf, "\0");
}
}
int mgcp_hex_to_ascii(BYTE *fromHex, BYTE fromLen, BYTE *toAsc)
{
int i, j;
j = 0;
for (i = 0; i< fromLen; i++)
{
toAsc[j] = ascii[fromHex[i] >> 4];
j++;
toAsc[j] = ascii[fromHex[i] & 0x0F];
j++;
toAsc[j] = ' ';
j++;
}
toAsc[j] = '\0';
return 1;
}
int mgcp_log_err(BYTE *errMsg)
{
if ((mgcpMonitorFg & MONITOR_ERROR) == MONITOR_ERROR)
{
mgcp_asciout_proc("\33[31m");
if (strlen(errMsg) >= MGCP_MAX_ASCITMP_LEN)
sprintf(mgcpAsciTempBuf, "log msg is too long: %d\n\r", strlen(errMsg));
else
sprintf(mgcpAsciTempBuf, "%s\n\r", errMsg);
strcat(mgcpAsciTempBuf, "\33[37m");
mgcp_asciout_proc(mgcpAsciTempBuf);
}
return 1;
}

2740
plat/mgcp/src/mgcp_msg.c Normal file
View File

File diff suppressed because it is too large Load Diff

300
plat/mgcp/src/mgcp_trans.c Normal file
View File

@@ -0,0 +1,300 @@
#include "./include/mgcp_pub.h"
#include "./include/mgcp.h"
#include "./include/mgcp_const.h"
#include "./include/mgcp_ext.h"
#include "./include/mgcp_struct.h"
#include "./include/mgcp_msg.h"
int mgcp_create_trans_id(WORD port)
{
if (port >= MGCP_MAX_NUM_OF_PORT)
return -1;
mgcpTransStart[port]++;
mgcpPort[port].transId = (port << 16) | mgcpTransStart[port];
return 0;
}
int mgcp_match_client_trans(DWORD transId)
{
WORD port;
DWORD srcIp;
MGCP_PORT *trans;
port = transId >> 16;
if (port >= MGCP_MAX_NUM_OF_PORT)
return -1;
trans = &mgcpPort[port];
if (trans->flag == 0)
return -1;
srcIp = mgcpRvMsg.msgSrcIP;
if ((trans->reqInd == MGCP_REQUEST)
&& (trans->transId == transId)
&& (trans->para.ip == srcIp))
return port;
return -1;
}
int mgcp_match_server_trans(DWORD transId)
{
WORD port;
DWORD srcIp;
MGCP_PORT *trans;
srcIp = mgcpRvMsg.msgSrcIP;
for (port = 1; port < MGCP_MAX_NUM_OF_PORT; port++)
{
trans = &mgcpPort[port];
if (trans->flag == 0)
continue;
if ((trans->reqInd == MGCP_INDICATION)
&& (trans->transId == transId)
&& (trans->para.ip == srcIp))
{
if (1 == trans->state2)
{
mgcp_send_msg(port, MGCP_RESPONSE);
trans->timer = MGCP_TIME_WAIT_TIMER;
}
return port;
}
}
return -1;
}
BYTE mgcp_trans_init_proc(WORD port)
{
if (port >= MGCP_MAX_NUM_OF_PORT)
return 0;
memset((BYTE *) &mgcpPort[port], 0, sizeof(MGCP_PORT));
return 1;
}
BYTE mgcp_trans_idle_proc(WORD port)
{
BYTE cmd;
MGCP_PARA *para;
MGCP_PORT *trans;
if (port >= MGCP_MAX_NUM_OF_PORT)
return 0;
trans = &mgcpPort[port];
cmd = trans->cmd;
if ((cmd < MGCP_CMD_CRCX) || (cmd > MGCP_CMD_RSIP))
return 3;
para = &trans->para;
if (para->sl.cmdRes == MGCP_COMMAND)
{
para->sl.cmdRes = 0;
if (trans->reqInd == MGCP_REQUEST)
{
mgcp_create_trans_id(port);
if (mgcp_send_msg(port, MGCP_COMMAND) < 0)
{
if (mgcpSap[0].MGCP_cnf == NULL)
return 3;
mgcpSap[0].MGCP_cnf(trans->cmd, trans->usrPort, port, MGCP_RET_CODE_TRANS_TIME_OUT, &trans->para);
return 3;
}
trans->timer = MGCP_MAX_RETRANS_TIMER;
return 1;
}
else if (trans->reqInd == MGCP_INDICATION)
{
if (mgcpSap[0].MGCP_ind == NULL)
return 3;
if (mgcpSap[0].MGCP_ind(cmd, &trans->usrPort, port, para) < 0)
return 3;
trans->timer = MGCP_MAX_RETRANS_TIMER;
return 2;
}
else
return 3;
}
return 3;
}
BYTE mgcp_trans_await_peer_response_proc(WORD port)
{
MGCP_PORT *trans;
MGCP_SL *sl;
if (port >= MGCP_MAX_NUM_OF_PORT)
return 0;
trans = &mgcpPort[port];
sl = &trans->para.sl;
if ((trans->cmd < MGCP_CMD_CRCX) || (trans->cmd > MGCP_CMD_RSIP))
return 1;
if (sl->cmdRes == MGCP_RESPONSE)
{
if (mgcpSap[0].MGCP_cnf == NULL)
return 1;
if (mgcpSap[0].MGCP_cnf(trans->cmd, trans->usrPort, port, sl->retCode, &trans->para) < 0)
return 1;
else
{
if ((sl->retCode < 100) ||
(sl->retCode >= 200))
return 1;
sl->cmdRes = 0;
trans->gotProvRes = 1;
}
}
if (trans->timer > 0)
{
if (--trans->timer == 0)
{
if (mgcpSap[0].MGCP_cnf == NULL)
return 1;
mgcpSap[0].MGCP_cnf(trans->cmd, trans->usrPort, port, MGCP_RET_CODE_TRANS_TIME_OUT, &trans->para);
return 1;
}
else if ((trans->gotProvRes == 0) &&
((trans->timer % MGCP_RETRANS_TIMER) == 0))
mgcp_send_msg(port, MGCP_COMMAND);
}
return 0;
}
BYTE mgcp_trans_await_user_response_proc(WORD port)
{
MGCP_PORT *trans;
MGCP_SL *sl;
if (port >= MGCP_MAX_NUM_OF_PORT)
return 0;
trans = &mgcpPort[port];
sl = &trans->para.sl;
switch (trans->state2 & 1)
{
case 0:
if (sl->cmdRes == MGCP_RESPONSE)
{
if (mgcp_send_msg(port, MGCP_RESPONSE) < 0)
return 1;
if ((sl->retCode < 100) ||
(sl->retCode >= 200))
{
trans->state2 = 1;
trans->timer = MGCP_TIME_WAIT_TIMER;
return 0;
}
sl->cmdRes = 0;
trans->gotProvRes = 1;
}
if (trans->timer > 0)
{
if (--trans->timer == 0)
{
if (mgcp_send_rsp(port, MGCP_RET_CODE_TRANS_TIME_OUT_INDEX) < 0)
return 1;
trans->state2 = 1;
trans->timer = MGCP_TIME_WAIT_TIMER;
return 0;
}
}
break;
case 1:
if (trans->timer > 0)
{
if (--trans->timer == 0)
return 1;
}
break;
}
return 0;
}
void mgcp_trans_proc()
{
WORD port;
for (port = 1; port < MGCP_MAX_NUM_OF_PORT; port++)
{
if (mgcpPort[port].flag != 1)
continue;
switch (mgcpPort[port].state)
{
case MGCP_TRANS_IDLE_STATE:
switch (mgcp_trans_idle_proc(port))
{
case 0:
break;
case 1:
mgcpPort[port].state = MGCP_TRANS_AWAIT_PEER_RESPONSE_STATE;
break;
case 2:
mgcpPort[port].state = MGCP_TRANS_AWAIT_USER_RESPONSE_STATE;
break;
case 3:
mgcpPort[port].state = MGCP_TRANS_INIT_STATE;
break;
}
break;
case MGCP_TRANS_AWAIT_PEER_RESPONSE_STATE:
switch (mgcp_trans_await_peer_response_proc(port))
{
case 0:
break;
case 1:
mgcpPort[port].state = MGCP_TRANS_INIT_STATE;
break;
}
break;
case MGCP_TRANS_AWAIT_USER_RESPONSE_STATE:
switch (mgcp_trans_await_user_response_proc(port))
{
case 0:
break;
case 1:
mgcpPort[port].state = MGCP_TRANS_INIT_STATE;
break;
}
break;
case MGCP_TRANS_INIT_STATE:
switch (mgcp_trans_init_proc(port))
{
case 0:
break;
case 1:
mgcpPort[port].state = MGCP_TRANS_IDLE_STATE;
break;
}
break;
}
}
}