cc08_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					60000
#define RESULT_OTHER			-4
#define RESULT_NULL				-5
#define RESULT_BUSY				-6
#define RESULT_TIMEOUT		-7

FILE *lp;

int cc08_proc(int port_fd, char *phone_number, TESTMSG * testmsg);
int f_cc08_result_receive(int sock, char *szBuffer);
int f_cc08_test_process(int port_fd, char *phone_number, TESTMSG * testmsg);
int f_cc08_analysis(char *receive_str, TESTMSG * testmsg);
void f_cc08_get_res(char *result, char *val_str);
void f_cc08_get_cap(char *result, char *val_str);
void f_cc08_get_vol(char *result, char *val_str);
int f_cc08_get_code(char *str);

static char receive_str[2048];

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

Param:	int port_fd	- socket id
 	char *phone_number - a pointer to accessed telephone number
	TESTMSG * testmsg - struct of test message

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

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	lp = backup_log("./cc08_drv.log");
	/* lp=fopen("./cc08_drv.log","a+"); */
	fprintf(lp, "\n>>> Start C&C08 Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
	fflush(lp);
#endif
	ret = f_cc08_test_process(port_fd, phone_number, testmsg);

#ifdef DEBUG
	lt = time(NULL);
	ctime = localtime(&lt);
	fprintf(lp, "\n>>> Stop C&C08 Test at %4d.%02d.%02d %02d:%02d:%02d <<<\n", ctime->tm_year + 1900, 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;
		break;
	case RESULT_OTHER:
		ret = AM_UNREADY_ERROR;
		break;
	case RESULT_NULL:
		ret = 0;
		strcpy(testmsg->TestResult.TestConclusion, "V08");
		break;
	case RESULT_BUSY:
		ret = 0;
		strcpy(testmsg->TestResult.TestConclusion, "V6");
		break;
	case RESULT_TIMEOUT:
		ret = AM_TIME_OUT;
		break;
	}

	return (ret);

}
/* end of cc08_proc */


/*********************************************************
Function:int cc08_conn_switch(int port_fd, TESTREQMSG * testReqMsg, TESTMSG * testmsg)
Narrative:
	Detect if interface to switch runs well by sending a wakeup signal or a command.

Param:	int port_fd	- socket id
 	char *phone_number - a pointer to accessed telephone number
	TESTMSG * testmsg - struct of test message
 
Return:	0	OK.
	-1	No fd ready when timeout.
	-2	an error occur.
*********************************************************/
int cc08_conn_switch(int port_fd, char *phone_number, TESTMSG * testmsg)
{
	int ret, ret_val;
	receive_str[0] = 0;
	ret = cc08_proc(port_fd, phone_number, testmsg);
	if (ret == 0)
		ret_val = 0;
	else if (strlen(receive_str) == 0)
		ret_val = -1;
	else
		ret_val = -2;
	return ret_val;
}

/*********************************************************
Function:int f_cc08_test_process(int port_fd, char *phone_number, TESTMSG * testmsg)
Narrative:
	Test 12 specialities of line.

Param:	int port_fd - socket id
	char *phone_number - a pointer to accessed telephone number
	TESTMSG * testmsg - struct of test message

Return:	0	OK.
	-1	Error occur when writing port.
	-2	No fd ready when timeout.
	-3	An error occur.
*********************************************************/
int f_cc08_test_process(int port_fd, char *phone_number, TESTMSG * testmsg)
{
	char test_str[50];
	int ret;
	int i;

	f_trim_space(phone_number);

	poll(0, 0, 500);

	sprintf(test_str, "~C112OUTTEST:DN=%s,FORCE=0;\r", phone_number);
	writeport(port_fd, test_str);
	ret = f_cc08_result_receive(port_fd, receive_str);
	if (!ret)
		ret = f_cc08_analysis(receive_str, testmsg);

	return (ret);
}																/* end f_cc08_test_process */

/*********************************************************
Function:int f_cc08_result_receive(int sock, char *szBuffer)
Narrative:
	Receive testing return from switch.

Param:	int port_fd	- socket id
	char *szBuffer - char pointer to receive_str.

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_cc08_result_receive(int sock, char *szBuffer)
{
	int p;
	int retval, ret, rc;
	char ch;
	struct pollfd pollfdsp[1];

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

	retval = 0;
	p = 0;
	szBuffer[p] = '\0';
	while (1)
	{
		ret = poll(pollfdsp, 1, WAIT_TIME);
		if (ret < 0)
		{
			retval = -3;
			break;
		}
		else if (ret == 0)
		{
			retval = -2;
			break;
		}
		if (pollfdsp[0].revents & POLLIN)
		{
			rc = read(sock, &ch, 1);
			if (rc < 0)
			{
				retval = -3;
				break;
			}
			if (rc == 0)
			{
				retval = -1;
				break;
			}
			if (ch != 0)
			{
				szBuffer[p] = ch;
				++p;
				/* fprintf(lp,"%02x,%c\n",ch,ch); */
			}
			if (ch == ';')
			{
				szBuffer[p] = '\0';
#ifdef DEBUG
				fprintf(lp, "\nFinish\n");
#endif
				break;
			}
		}
	}
	szBuffer[p] = '\0';
#ifdef DEBUG
	fprintf(lp, "Server Replied:p=%d\n%s\n", p, szBuffer);
	fflush(lp);
#endif
	switch (retval)
	{
	case 0:
#ifdef DEBUG
		fprintf(lp, "\nReceive OK!\n");
#endif
		break;
	case -1:
#ifdef DEBUG
		fprintf(lp, "Receive 0, exit\n");
#endif
		break;
	case -2:
#ifdef DEBUG
		fprintf(lp, "Server no respone!\n");
#endif
		break;
	case -3:
#ifdef DEBUG
		fprintf(lp, "\nServer port down!\n");
#endif
		break;
	}
	return (retval);
}

/*********************************************************
Function:f_cc08_analysis(char *receive_str, TESTMSG * testmsg)
Narrative:
	Get test value from receive_str from switch.

Param:	char *receive_str - a pointer to receive_str
	TESTMSG * testmsg - struct of test message

Return:	0	OK.
	RESULT_BUSY	equitpment congest.
	RESULT_NULL	invalid number.
	RESULT_OTHER	an error occur.
*********************************************************/
int f_cc08_analysis(char *receive_str, TESTMSG * testmsg)
{
	char temp_str[30];
	char *p, *q, *r;
	char state;
	int ret;
	int code;

	p = (char *) strstr(receive_str, "STATE=");
	if (!p)
		return (RESULT_OTHER);
	else
	{
		state = p[6];
		switch (state)
		{
		case '0':
			ret = 0;
			break;
		case '1':
		case '2':
		case '6':
		case '7':
			ret = RESULT_BUSY;
			return (ret);
		case '4':
			ret = RESULT_NULL;
			return (ret);
		default:
			ret = RESULT_OTHER;
			return (ret);
		}
		/* get AB Res */
		p = (char *) strstr(receive_str, "RAB=");
		p += 4;
		f_cc08_get_res(testmsg->TestResult.TR2_DCres, p);

		/* get AG Res */
		p = (char *) strstr(receive_str, "RAG=");
		p += 4;
		f_cc08_get_res(testmsg->TestResult.TG2_DCres, p);

		/* get BG Res */
		p = (char *) strstr(receive_str, "RBG=");
		p += 4;
		f_cc08_get_res(testmsg->TestResult.RG2_DCres, p);

		/* get AB DCVol  -- skip */
		/*
		   p = (char*)strstr(receive_str,"DVAB=");
		   p += 5;
		   f_cc08_get_vol(testmsg->TestResult.TR2_DCres,p);
		 */

		/* get AG DCVol */
		p = (char *) strstr(receive_str, "DVAG=");
		p += 5;
		f_cc08_get_vol(testmsg->TestResult.TG2_DCvol, p);

		/* get BG DCVol */
		p = (char *) strstr(receive_str, "DVBG=");
		p += 5;
		f_cc08_get_vol(testmsg->TestResult.RG2_DCvol, p);

		/* get AG ACVol */
		p = (char *) strstr(receive_str, "AVAG=");
		p += 5;
		f_cc08_get_vol(testmsg->TestResult.TG_ACvol, p);

		/* get BG ACVol */
		p = (char *) strstr(receive_str, "AVBG=");
		p += 5;
		f_cc08_get_vol(testmsg->TestResult.RG_ACvol, p);

		/* get AB Cap */
		p = (char *) strstr(receive_str, "CAB=");
		p += 4;
		f_cc08_get_cap(testmsg->TestResult.TR_cap, p);

		/* get AG Cap */
		p = (char *) strstr(receive_str, "CAG=");
		p += 4;
		f_cc08_get_cap(testmsg->TestResult.TG_cap, p);

		/* get BG Cap */
		p = (char *) strstr(receive_str, "CBG=");
		p += 4;
		f_cc08_get_cap(testmsg->TestResult.RG_cap, p);

		p = (char *) strstr(receive_str, "RESULT=");
		if (p != NULL)
		{
			p += 7;
			code = f_cc08_get_code(p);
			switch (code)
			{
			case 0:
				strcpy(temp_str, "0");
				break;
			case 1:
				strcpy(temp_str, "25");	/* 碰电力线 */
				break;
			case 2:
			case 3:
			case 4:
			case 8:
				strcpy(temp_str, "23");	/* 混线 */
				break;
			case 5:
			case 6:
			case 7:
				strcpy(temp_str, "24");	/* 地气 */
				break;
			case 9:
				strcpy(temp_str, "21");	/* 绝缘不良 */
				break;
			case 10:
			case 11:
			case 12:
			case 13:
				strcpy(temp_str, "26");	/* 漏电 */
				break;
			case 14:
				strcpy(temp_str, "22");	/* 断线 */
				break;
			case 15:
				strcpy(temp_str, "27");	/* 话机未挂 */
				break;
			default:
				strcpy(temp_str, "41");	/* 不确定 */
				break;
			}
			strcpy(testmsg->TestResult.OutResult, temp_str);
		}
		else
		{
			ret = RESULT_OTHER;
			return (ret);
		}
	}
	return (0);
}

/*********************************************************
Function:void f_cc08_get_res(char *result, char *val_str)
Narrative:
	Get value of resistance from received string from switch.

Param:	char *result - value of resistance
	char *val_str - received string from switch

Return:	None.
*********************************************************/
void f_cc08_get_res(char *result, char *val_str)
{
	char temp_str[30];
	char *p, *q;
	float val;
	float dw;
	dw = 1;
	p = val_str;
	q = temp_str;

	while (*p)
	{
		if (*p != ' ')
		{
			*q = *p;
			++q;
			if (*p == 'm' || *p == 'M')
			{
				dw = 1000;
				break;
			}
			else if (*p == 'k' || *p == 'K')
			{
				dw = 1;
				break;
			}
			else if (*p == ',' || *p == ';')
			{
				dw = 1 / 1000;
				break;
			}
			else if (*p == '*' || *p == 'V')
			{
				result[0] = '\0';				/* set to "NULL" */
				return;
			}
			else if (*p == 'E')
			{
				sprintf(result, "%9.3f", 99999.0);	/* set to Maximum */
				return;
			}
			else if (*p == 'N')
			{
				strcpy(result, "0");		/* set to Minimize */
				return;
			}
		}
		++p;
	}
	*q = '\0';
	val = atof(temp_str) * dw;
	sprintf(result, "%9.3f", val);
}

/*********************************************************
Function:void f_cc08_get_vol(char *result, char *val_str)
Narrative:
	Get value of voltage from received string from switch.

Param:	char *result - value of voltage
	char *val_str - received string from switch

Return:	None.
*********************************************************/
void f_cc08_get_vol(char *result, char *val_str)
{
	char temp_str[30];
	char *p, *q;
	float val;
	float dw;
	dw = 1;
	p = val_str;
	q = temp_str;

	while (*p)
	{
		if (*p != ' ')
		{
			*q = *p;
			++q;
			if (*p == 'm' || *p == 'M')
			{
				dw = 1000000L;
				break;
			}
			else if (*p == 'k' || *p == 'K')
			{
				dw = 1000;
				break;
			}
			else if (*p == ',' || *p == ';')
			{
				dw = 1;
				break;
			}
			else if (*p == '*' || *p == 'V')
			{
				result[0] = '\0';				/* set to "NULL" */
				return;
			}
			else if (*p == 'E')
			{
				sprintf(result, "%8.3f", 99999.0);	/* set to Maximum */
				return;
			}
			else if (*p == 'N')
			{
				strcpy(result, "0");		/* set to Minimize */
				return;
			}
		}
		++p;
	}
	*q = '\0';
	val = atof(temp_str) * dw;
	sprintf(result, "%8.3f", val);
}


/*********************************************************
Function:void f_cc08_get_cap(char *result, char *val_str)
Narrative:
	Get value of capacitance from received string from switch.

Param:	char *result - value of capacitance
	char *val_str - received string from switch

Return:	None.
*********************************************************/
void f_cc08_get_cap(char *result, char *val_str)
{
	char temp_str[30];
	char *p, *q;
	float val;
	float dw;
	dw = 1;
	p = val_str;
	q = temp_str;

	while (*p)
	{
		if (*p != ' ')
		{
			*q = *p;
			++q;
			if (*p == 'm' || *p == 'M')
			{
				dw = 1000000L;
				break;
			}
			else if (*p == 'k' || *p == 'K')
			{
				dw = 1000;
				break;
			}
			else if (*p == ',' || *p == ';')
			{
				dw = 1;
				break;
			}
			else if (*p == '*' || *p == 'V')
			{
				result[0] = '\0';				/* set to "NULL" */
				return;
			}
			else if (*p == 'E')
			{
				sprintf(result, "%8.3f", 99999.0);	/* set to Maximum */
				return;
			}
			else if (*p == 'N')
			{
				strcpy(result, "0");		/* set to Minimize */
				return;
			}
		}
		++p;
	}
	*q = '\0';
	val = atof(temp_str) * dw / 1000;
	sprintf(result, "%8.3f", val);
}

/*********************************************************
Function:int f_cc08_get_code(char *str)
Narrative:
	Get test conclusion value from received string from switch.

Param:	char *str - char pointer to test conclusion code
 
Return:	None.
*********************************************************/
int f_cc08_get_code(char *str)
{
	char *p;
	int i;
	char temp[10];
	p = str;
	temp[0] = 0;
	i = 0;
	while (*p != '\0' && *p != ';' && *p != ' ' && *p != ',' && i < 10)
	{
		temp[i] = *p;
		++p;
		++i;
	}
	temp[i] = 0;
	return (atoi(temp));
}