ewsd_drv.c

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

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

			if (ch == 0x10)
				writeport2(port_fd, str_link_resp);

			if (ch == str_lilde[p])
			{
				++p;
				if (p == strlen(str_lilde))
				{
					poll(0, 0, 10);
					result = 0;
					break;
				}
			}
			else
				p = 0;

			if (ch == str_lnoavailable[o])
			{
				++o;
				if (o == strlen(str_lnoavailable))
				{
					poll(0, 0, 10);
					result = -5;
					break;
				}
			}
			else
				o = 0;

			if (ch == str_lbusy[q])
			{
				++q;
				if (q == strlen(str_lbusy))
				{
					poll(0, 0, 10);
					result = -6;
					break;
				}
			}
			else
				q = 0;
		}
	}

#ifdef DEBUG
	fprintf(lp, "\nsend Access string OK!\n");
	fflush(lp);
#endif
	if (result == 0)
	{
#ifdef DEBUG
		fprintf(lp, "\nAccess line OK!\n");
#endif
	}
	if (result == -5)
	{
#ifdef DEBUG
		fprintf(lp, "Invalid Number!\n");
#endif
	}
	if (result == -6)
	{
#ifdef DEBUG
		fprintf(lp, "Line busy!\n");
#endif
	}
	return (result);
}

/*********************************************************
Function:int f_ewsd_test_process(int port_fd, TESTMSG * testmsg)
Narrative:
	Send test command to switch and get test value.

Param:	int port_fd	- socket id
	TESTMSG * testmsg	- struct of test message

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_test_process(int port_fd, TESTMSG * testmsg)
{
	char *test_str;
	char result[50];
	int ret;
	int fail_time, stat;

	fail_time = 0;
	stat = 0;
	while (fail_time < MAX_FAIL_TIMES && stat < STAT_FINISH)
	{
		switch (stat)
		{
		case STAT_DCV_AB:
			test_str = str_dcv_ab;
			break;
		case STAT_DCV_AG:
			test_str = str_dcv_ae;
			break;
		case STAT_DCV_BG:
			test_str = str_dcv_be;
			break;
		case STAT_ACV_AB:
			test_str = str_acv_ab;
			break;
		case STAT_ACV_AG:
			test_str = str_acv_ae;
			break;
		case STAT_ACV_BG:
			test_str = str_acv_be;
			break;
		case STAT_RES_AB:
			test_str = str_res_ab;
			break;
		case STAT_RES_AG:
			test_str = str_res_ae;
			break;
		case STAT_RES_BG:
			test_str = str_res_be;
			break;
		case STAT_CAP_AB:
			test_str = str_cap_ab;
			break;
		case STAT_CAP_AG:
			test_str = str_cap_ae;
			break;
		case STAT_CAP_BG:
			test_str = str_cap_be;
			break;
		}

		ret = writeport1(port_fd, test_str);

#ifdef DEBUG
		fprintf(lp, "stat=%d,ret=%d,fail_time=%d\n", stat, ret, fail_time);
		fflush(lp);
#endif

		ret = f_ewsd_test_receive(port_fd, result, 9000);
#ifdef DEBUG
		fprintf(lp, "after f_ewsd_test_receive()::ret=%d\n", ret);
		fflush(lp);
#endif
		if (!ret)
		{
			ret = f_ewsd_trim_result(result, stat, testmsg);
			if (!ret)
			{
				stat++;
				continue;
			}
			else
			{
				fail_time++;
				continue;
			}
		}
		else
		{
			fail_time++;
			continue;
		}
	}

	return (ret);
}

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

Param:	int port_fd - socket id
	char *result - a point to receive_str
	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_test_receive(int port_fd, char *result, int wait_time)
{
	struct pollfd pollfdsp[1];
	char ch;
	char str_resp_head[] =
	{0x11, 0x0f, 0x16, 0x00};
	char *str_receive;
	int p, q, rc, ret, flag;

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

	flag = 0;
	p = 0;
	q = 0;
	str_receive = result;
	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 == 0x0)
				continue;
#ifdef DEBUG
			fprintf(lp, "%02X,%c\n", (unsigned char) ch, ch);
#endif

			if (ch == 0x10)
			{
				writeport2(port_fd, str_link_resp);
				continue;
			}
			if (ch == str_resp_head[p] && flag == 0)
			{
				++p;
				if (p == strlen(str_resp_head))
					flag = 1;

			}
			else
				p = 0;

			if (flag)
			{
				str_receive[q] = ch;
				++q;
			}

			if (q >= 7)
			{
				str_receive[q] = 0;
				break;
			}
		}
	}

	return (0);
}

/*********************************************************
Function:int f_ewsd_trim_result(char *result, int stat, TESTMSG * testmsg)
Narrative:
	Get test values from recieved string.

Param:	char *result - a point to receive_str
	int stat - lable of test state
	TESTMSG * testmsg	- struct of test message

Return:	0	OK.		
*********************************************************/
int f_ewsd_trim_result(char *result, int stat, TESTMSG * testmsg)
{
	int i;
	float val, dw;
	char *p, *q;
	char str1[30], str2[12];

	p = result;
	q = str1;
	i = 3;
	memset(str2, 0, sizeof(str2));

	if (*(p + 2) == 0x03)
		val = 9999.9;
	else
	{
		while (*(p + i))
		{
			if (*(p + i) == 0x0a)
				*(p + i) = 0;
			*q = *(p + i) + 0x30;
			i++;
			q++;
		}
		*q = 0;

		val = atof(str1);
	}

	if (*(p + 2) == 0x02)
		val *= (-1);

	if (*(p + 1) == 0x04)
		dw = 10;

	if (*(p + 1) == 0x05)
		dw = 10;

	if (*(p + 1) == 0x06)
		dw = 1000;

	if (*(p + 1) == 0x07)
		dw = 10;

	if (*(p + 1) == 0x08)
		dw = 0.1;

	if (*(p + 1) == 0x09)
		dw = 100;

	val = val / dw;

#ifdef DEBUG
	fprintf(lp, "stat=%d,value_result=%s,val=%9.3f\n", stat, p, val);
	fflush(lp);
#endif
	if (val > 99998.992)
		val = 99998.992;
	switch (stat)
	{
	case STAT_DCV_AB:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
/*      strcpy(testmsg->TestResult.TG2_DCvol,str2); */
		break;
	case STAT_DCV_AG:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TG2_DCvol, str2);
		break;
	case STAT_DCV_BG:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.RG2_DCvol, str2);
		break;
	case STAT_ACV_AB:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TG_ACvol, str2);
		break;
	case STAT_ACV_AG:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TG_ACvol, str2);
		break;
	case STAT_ACV_BG:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.RG_ACvol, str2);
		break;
	case STAT_RES_AB:
		sprintf(str2, "%9.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TR2_DCres, str2);
		break;
	case STAT_RES_AG:
		sprintf(str2, "%9.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TG2_DCres, str2);
		break;
	case STAT_RES_BG:
		sprintf(str2, "%9.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.RG2_DCres, str2);
		break;
	case STAT_CAP_AB:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TR_cap, str2);
		break;
	case STAT_CAP_AG:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.TG_cap, str2);
		break;
	case STAT_CAP_BG:
		sprintf(str2, "%8.3f", val);
		str2[sizeof(str2) - 1] = 0;
		strcpy(testmsg->TestResult.RG_cap, str2);
		break;
	}
	return (0);
}


/*********************************************************
Function:void f_ewsd_test_end(int port_fd)
Narrative:
	Send release command to switch.

Param:	int port_fd - socket id

Return:	None.
*********************************************************/
void f_ewsd_test_end(int port_fd)
{
	writeport1(port_fd, str_rel);
}

/*********************************************************
Function:char *f_make_access_str1(char *conv_string)
Narrative:
	Generate accessing string to dial port of EWSD switch.

Param:	char *phone_number - a pionter to telephone number of accessed line.

Return:	str_return	Trimed string of telephone number.
		
*********************************************************/
char *f_make_access_str1(char *conv_string)
{
	char *p, *q;
	static char str_return[50];
	p = conv_string;
	q = str_return;
	for (; *p != 0; ++p)
	{
		if (*p == '0')
			*p += 0x0a;
		*q = 0x0f;
		*(q + 1) = 0x04;
		*(q + 2) = *p - 0x30;
		q += 3;
	}
	*q = 0;

#ifdef DEBUG
	fprintf(lp, "\nthe accessed telephone number: %s\n", str_return);
	fflush(lp);
#endif

	return (str_return);
}


/*********************************************************
Function:int f_link_5000(int port_fd, int wait_time)
Narrative:
	Send back signal '\x11\' responding signal '\x10' from switch

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

Return:	-2	No fd ready when timeout.
	-3	An error occur.

*********************************************************/
int f_link_5000(int port_fd, int wait_time)
{
	struct pollfd pollfdsp[1];
	char ch;
	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 == 0x10)
				writeport2(port_fd, str_link_resp);

		}
	}
}