ewsd_drv.c

仿真测试接口程序。根据电总《用户接入网管理功能与管理接口技术规范》之《与112集中受理系统接口规范》

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include "simdrv.h"
#include "simu112.h"
#include "simufunc.h"

#define MAX_FAIL_TIMES		4
#define WAIT_TIME			5000
/*
   #define RESULT_OTHER   -4
   #define RESULT_NULL      -5
   #define RESULT_BUSY      -6
   #define RESULT_TIMEOUT   -7
 */
#define STAT_DCV_AB				0
#define STAT_DCV_BG				1
#define STAT_DCV_AG				2
#define STAT_ACV_AB				3
#define STAT_ACV_BG				4
#define STAT_ACV_AG				5
/*
   #define STAT_BAT_AB        6
   #define STAT_CUR_BG        7
   #define STAT_CUR_AG        8
 */
#define STAT_CAP_AB				6
#define STAT_CAP_BG				7
#define STAT_CAP_AG				8
#define STAT_RES_AB				9
#define STAT_RES_BG				10
#define STAT_RES_AG				11
#define STAT_FINISH				12


static char str_dial1[] =
{0x15, 0x00};
static char str_dial1_1[] =
{0x0f, 0x04, 0x0b, 0x00};
//static char str_dial2[] =
//{0x0f, 0x04, 0x09, 0x0f, 0x04, 0x09, 0x0f, 0x04, 0x08, 0x00};
static char str_acc[] =
{0x0f, 0x04, 0x06, 0x0f, 0x04, 0x01, 0x0f, 0x04, 0x0a, 0x0f, 0x04, 0x0a, 0x0f, 0x04, 0x0a, 0x0f, 0x04, 0x0a, 0x00};
static char str_dcv_ab[] =
{0x0f, 0x03, 0x01, 0x00};
static char str_dcv_ae[] =
{0x0f, 0x01, 0x01, 0x00};
static char str_dcv_be[] =
{0x0f, 0x02, 0x01, 0x00};
static char str_acv_ab[] =
{0x0f, 0x03, 0x02, 0x00};
static char str_acv_ae[] =
{0x0f, 0x01, 0x02, 0x00};
static char str_acv_be[] =
{0x0f, 0x02, 0x02, 0x00};
static char str_res_ab[] =
{0x0f, 0x03, 0x03, 0x00};
static char str_res_ae[] =
{0x0f, 0x01, 0x03, 0x00};
static char str_res_be[] =
{0x0f, 0x02, 0x03, 0x00};
static char str_cap_ab[] =
{0x0f, 0x03, 0x04, 0x00};
static char str_cap_ae[] =
{0x0f, 0x01, 0x04, 0x00};
static char str_cap_be[] =
{0x0f, 0x02, 0x04, 0x00};
static char str_in[] =
{0x0f, 0x0a, 0x06, 0x00};
static char str_out[] =
{0x0f, 0x02, 0x07, 0x00};
static char str_sub_rel[] =
{0x0f, 0x0a, 0x09, 0x00};
static char str_rel[] =
{0x0f, 0x07, 0x09, 0x1a, 0x00};
static char str_link_resp[] =
{0x11, 0x00};
static char str_link_sig[] =
{0x10, 0x00};
static char str_wait1[] =
{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x00};
static char str_link_aaa[] =
{0xff, 0x00};
FILE *lp;

char *f_make_access_str1(char *conv_string);
int f_ewsd_send_dial(int port_fd, char *dial_number);
int f_ewsd_access(int port_fd, char *phone_number);
int f_ewsd_test_process(int port_fd, TESTMSG * testmsg);
void f_ewsd_test_end(int port_fd);
int f_ewsd_dial1_receive(int port_fd, int wait_time);
int f_ewsd_dial2_receive(int port_fd, int wait_time);
int f_ewsd_test_receive(int port_fd, char *result, int wait_time);
int f_ewsd_trim_result(char *result, int stat, TESTMSG * testmsg);
int f_link_5000(int port_fd, int wait_time);

static char receive_str[2048];

/*********************************************************
Function:int ewsd_proc(int port_fd, char *phone_number, char *dial_number, TESTMSG * testmsg)
Narrative:
		Called in simdrv.c. It is the main flow of ewsd_drv driver.

Param:	int port_fd	- socket id
 	char *phone_number - a pointer to accessed telephone number
	char *dial_number - a pointer to EWSD dial test number just like '998' ,'996' etc
	TESTMSG * testmsg	- struct of test message

Return: 0   OK or Null TelephoneNumber or Line Busy.
	AM_NO_RESPONSE
	AM_PORT_DOWN
	AM_UNREADY_ERROR
	AM_TIME_OUT
*********************************************************/
int ewsd_proc(int port_fd, char *phone_number, char *dial_number, TESTMSG * testmsg)
{
	int ret, i;
	int fail_count;
	struct tm *ctime;
	time_t lt;

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	lp = backup_log("./ewsd_drv.log");
	fprintf(lp, "\n>>> Start EWSD Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year > 90 ? ctime->tm_year + 1900 : ctime->tm_year + 2000, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
#endif
	fail_count = 0;
	ret = 1;

	while (fail_count < MAX_FAIL_TIMES && ret)
	{
		ret = f_ewsd_send_dial(port_fd, dial_number);
		++fail_count;
	}


#ifdef DEBUG
	fprintf(lp, "ret=%d, fail_count=%d\n", ret, fail_count);
	fprintf(lp, "Start f_ewsd_access!\n");
	fflush(lp);
#endif


	if (!ret)
	{
		ret = f_ewsd_access(port_fd, phone_number);
	}

#ifdef DEBUG
	fprintf(lp, "ret=%d\n", ret);
	fprintf(lp, "Start f_ewsd_test_process!\n");
	fflush(lp);
#endif

	if (!ret)
	{
		ret = f_ewsd_test_process(port_fd, testmsg);
	}

#ifdef DEBUG
	fprintf(lp, "ret=%d\n", ret);
	fprintf(lp, "Start f_ewsd_test_end!\n");
	fflush(lp);
#endif

	if (!ret || ret == -5 || ret == -6)
	{
		f_ewsd_test_end(port_fd);
	}

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	fprintf(lp, "\n>>> Stop EWSD Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year > 90 ? ctime->tm_year + 1900 : ctime->tm_year + 2000, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
	fclose(lp);
#endif

	switch (ret)
	{
	case -1:
		ret = AM_UNREADY_ERROR;
		break;
	case -2:
		ret = AM_NO_RESPONSE;
		break;
	case -3:
		ret = AM_PORT_DOWN;
	case -4:
		ret = AM_UNREADY_ERROR;
		break;
	case -5:
		ret = 0;
		strcpy(testmsg->TestResult.TestConclusion, "V08");
		break;
	case -6:
		ret = 0;
		strcpy(testmsg->TestResult.TestConclusion, "V6");
		break;
	case -7:
		ret = AM_TIME_OUT;
		break;
	}

	return (ret);

}
/* end of ewsd_drv */

/*********************************************************
Function:int ewsd_conn_switch(int port_fd, char *dial_number)
Narrative:
	Detect if interface to switch runs well by sending a wakeup signal or a command.

Param:	int port_fd	- socket id
 
Return:	0	OK.
	-1	No fd ready when timeout.
	-2	an error occur.
*********************************************************/
int ewsd_conn_switch(int port_fd, char *dial_number)
{
	int ret_val;
	struct tm *ctime;
	time_t lt;

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	lp = backup_log("./ewsd_drv.log");
	fprintf(lp, "\n>>> Start EWSD Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year > 90 ? ctime->tm_year + 1900 : ctime->tm_year + 2000, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
#endif

	receive_str[0] = 0;
	if (!f_ewsd_send_dial(port_fd, dial_number))
		ret_val = 0;
	else if (strlen(receive_str) == 0)
		ret_val = -1;
	else
		ret_val = -2;

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	fprintf(lp, "\n>>> Stop EWSD Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year > 90 ? ctime->tm_year + 1900 : ctime->tm_year + 2000, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
	fclose(lp);
#endif

	return ret_val;

}

/*********************************************************
Function:int f_ewsd_send_dial(int port_fd, char *dial_number);
Narrative:
	Send dial string to access switch.

Param:	int port_fd	- socket id
	char *dial_number - a pointer to EWSD dial test number just like '998' ,'996' etc

Return:	0   OK.
	-1	An error of hangup occur when reading.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
*********************************************************/
int f_ewsd_send_dial(int port_fd, char *dial_number)
{
	int ret, i;

/*  send str_dial1  */
	writeport1(port_fd, str_dial1);
	sleep(1);
	writeport1(port_fd, str_dial1_1);
	ret = f_ewsd_dial1_receive(port_fd, 5000);

	writeport2(port_fd, str_link_resp);

/*  send str_dial2  */

	writeport1(port_fd, f_make_access_str1(dial_number));

	ret = f_ewsd_dial2_receive(port_fd, 4000);
	return (ret);
}
/* end of f_ewsd_send_dial */

/*********************************************************
Function:int f_ewsd_dial1_receive(int port_fd, int wait_time)
Narrative:
	Recieve responded string from switch after sending dial1.

Param:	int port_fd	- socket id
	int wait_time - poll system call waiting time

Return:	0   OK.
	-1	An error of hangup occur when reading.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
********************************************************/
int f_ewsd_dial1_receive(int port_fd, int wait_time)
{
	struct pollfd pollfdsp[1];
	char ch;
	char str_dial1_resp[] =
	{0x11, 0x0f, 0x00};
	int p, rc, ret;

	pollfdsp[0].fd = port_fd;
	pollfdsp[0].events = POLLIN;
	pollfdsp[0].revents = 0;

	p = 0;
	while (1)
	{
		ret = poll(pollfdsp, 1, wait_time);
		if (ret < 0)
			return (-3);
		if (ret == 0)
			return (-2);

		if (pollfdsp[0].revents & POLLIN)
		{
			rc = read(port_fd, &ch, 1);
			if (rc <= 0)
				return (-3);

			if (ch == 0)
				continue;
#ifdef DEBUG
			fprintf(lp, "%02X,%c\n", (unsigned char) ch, ch);
#endif

			if (ch == str_link_sig[p])
			{
				++p;
				if (p == strlen(str_link_sig))
				{

#ifdef DEBUG
					fprintf(lp, "\nsend dial1 string OK!\n");
					fflush(lp);
#endif
					return (0);
				}
			}
			else
				p = 0;
		}
	}
}

/*********************************************************
Function:int f_ewsd_dial2_receive(int port_fd, int wait_time)
Narrative:
	Recieve responded string after send command.

Param:	int port_fd - socket id
	int wait_time - poll system call waiting time

Return:	0	OK.
	-1	An error of hangup occur when reading.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
*********************************************************/
int f_ewsd_dial2_receive(int port_fd, int wait_time)
{
	struct pollfd pollfdsp[1];
	char ch;
	char str_dial2_resp[] =
	{0x07, 0x08, 0x0a, 0x00};
	int p, rc, ret;

	pollfdsp[0].fd = port_fd;
	pollfdsp[0].events = POLLIN;
	pollfdsp[0].revents = 0;

	p = 0;

_continue:

	while (1)
	{
		ret = poll(pollfdsp, 1, wait_time);
		if (ret < 0)
			return (-3);
		if (ret == 0)
			return (-2);

		if (pollfdsp[0].revents & POLLIN)
		{
			rc = read(port_fd, &ch, 1);
			if (rc <= 0)
				return (-3);

			if (ch == 0)
				continue;
#ifdef DEBUG
			fprintf(lp, "%02X,%c\n", (unsigned char) ch, ch);
#endif

			if (ch == 0x10)
			{
				break;
			}

			if (ch == str_dial2_resp[p])
			{

				++p;
				if (p == strlen(str_dial2_resp))
				{
#ifdef DEBUG
					fprintf(lp, "\nsend dial2 string OK!\n");
					fflush(lp);
#endif
					return (0);
				}
			}
			else
				p = 0;
		}
	}
	writeport2(port_fd, str_link_resp);
	goto _continue;
}

/*********************************************************
Function:int f_ewsd_access(int port_fd, char *phone_number)
Narrative:
	Access line.

Param:	int port_fd	- socket id
	char *phone_number - a pointer to telephone number of accessed line.

Return:	0	OK.
	-1	An error of hangup occur when reading.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
	-5	Ivalid telephone number.
	-6	Line busy.
*********************************************************/
int f_ewsd_access(int port_fd, char *phone_number)
{
	struct pollfd pollfdsp[1];
	char ch;
	int o, p, q, rc, ret;
	int result;										/* 0 - Access OK  1 - Line Busy  2 - Lock Out  3 - Channel Busy */
	char str_lilde[] =
	{0x11, 0x0c, 0x00};
	char str_lbusy[] =
	{0x11, 0x0d, 0x00};
	char str_lnoavailable[] =
	{0x11, 0x0e, 0x00};
	char str_llockout[] =
	{0x11, 0x0c, 0x11, 0x0d, 0x00};
	char str_acc_state_offhook[] =
	{0x11, 0x0c, 0x00};
	char str_acc_state_onhook[] =
	{0x11, 0x0d, 0x00};


	pollfdsp[0].fd = port_fd;
	pollfdsp[0].events = POLLIN;
	pollfdsp[0].revents = 0;

	f_trim_space(phone_number);

#ifdef DEBUG
	fprintf(lp, "\nphone number: %s\n", phone_number);
	fflush(lp);
#endif
	/* send Access string to switch port */
	writeport1(port_fd, f_make_access_str1(phone_number));

	result = 0;
	p = 0;
	q = 0;
	o = 0;
	while (1)
	{
		ret = poll(pollfdsp, 1, 9000);
		if (ret < 0)
			return (-3);
		if (ret == 0)
			return (-2);

		if (pollfdsp[0].revents & POLLIN)
		{
			rc = read(port_fd, &ch, 1);
			if (rc <= 0)
				return (-3);