sp30_drv.c

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

				if (!first_flag && p > 2 && szBuffer[p - 1] == 0xff)
					break;								/* skip 0x00 */
			default:
				if (!first_flag)
				{
					szBuffer[p] = ch;
					++p;
					*len = p;
				}
				break;
			}
			if (!first_flag)
				previous_char = ch;
		}
	}
	szBuffer[p] = '\0';
	switch (retval)
	{
	case 0:
#ifdef DEBUG
		write_msg("Receive OK!", (unsigned char *) "", 0);
#endif
		break;
	case -1:
#ifdef DEBUG
		write_msg("Receive 0, exit!", (unsigned char *) "", 0);
#endif
		break;
	case -2:
#ifdef DEBUG
		write_msg("Server no respone!", (unsigned char *) "", 0);
#endif
		break;
	case -3:
#ifdef DEBUG
		write_msg("Server port down!", (unsigned char *) "", 0);
#endif
		break;
	}
	return (retval);
}

/*********************************************************
Function:int f_sp30_send_frame(int sock, unsigned char *buf, int len)
Narrative:
	Send a  trimed frame to switch.

Param:	int sock - socket id
	unsigned char *buf - a pointer to string to be sent
	int len - length of string.

Return:	>0  OK.
	<0	Fail.
*********************************************************/
int f_sp30_send_frame(int sock, unsigned char *buf, int len)
{
	int i, j;
	int new_len;
	unsigned char temp_str[100];

	/* check the sending buffer, if there are exist the char '0xff' in the middle, 
	   then add '0x00' behind the '0xff' */
	new_len = len;
	for (i = 0, j = 0; i < len; ++i)
	{
		if (buf[i] == 0xff && i > 1 && i < len - 2)
		{
			temp_str[j] = buf[i];
			temp_str[j + 1] = 0x00;
			j += 2;
			++new_len;
		}
		else
		{
			temp_str[j] = buf[i];
			++j;
		}
	}
	write_msg("send:", temp_str, new_len);
	return (write(sock, temp_str, new_len));
}

/*********************************************************
Function:void f_formulate(unsigned char *str, unsigned sno, unsigned rno, int len)
Narrative:
	Trim string.

Param:	unsigned char *str - a pointer to string should be trimed
	unsigned sno - 
	unsigned rno - 
	int len - length of string trimed

Return:	None.
*********************************************************/
void f_formulate(unsigned char *str, unsigned sno, unsigned rno, int len)
{
	int i;
	unsigned char *p;
	unsigned char sum;
	int datalen;

	sum = 0;
	str[2] = (sno << 4) | rno;
	p = str + 2;
	datalen = len - 5;
	for (i = 0; i < datalen; i++)
	{
		sum += (unsigned char) *(p + i);
	}
	sum %= 256;
	str[len - 3] = 256 - sum;
}

/*********************************************************
Function:void f_show_result(char *head, unsigned char *buf, int len)
Narrative:
	Show head of message.

Param:	char *head - a pointer to head of message
	unsigned char *buf - a pointer to recieved string
	int msg_len - length of recieved string

Return:	None.
*********************************************************/
void f_show_result(char *head, unsigned char *buf, int len)
{
	int i;
	printf("%s", head);
	for (i = 0; i < len; i++)
		printf("%02X,", buf[i]);
	printf("\n");
}

/*********************************************************
Function:int f_link_switch(int port_fd)
Narrative:
	Send link frame to switch.

Param:	int port_fd	- socket id

Return:	0	Link fail.
	1	Link OK.

*********************************************************/
int f_link_switch(int port_fd)
{
	int flag, i, ret;
	flag = 0;
	i = 0;
	do
	{
		write_msg("send link frame! \"0xff 0xfe\"", (unsigned char *) "", 0);
		f_sp30_send_frame(port_fd, (unsigned char *) "\xff\xfe", 2);
		f_sp30_send_frame(port_fd, (unsigned char *) "\xff\xfe", 2);
		f_sp30_send_frame(port_fd, (unsigned char *) "\xff\xfe", 2);
		f_sp30_send_frame(port_fd, (unsigned char *) "\xff\xfe", 2);
		write_msg("i=", (unsigned char *) &i, 2);
		ret = f_sp30_result_receive(port_fd, receive_str, &receive_len);
		if (!ret)
		{
			write_msg("receive:", receive_str, receive_len);
			from_sno = receive_str[2] >> 4;
			from_rno = receive_str[2] & 0x0f;
			if (receive_str[2] == 0x00 && receive_str[3] == 0x20)
			{
				flag = 1;
			}
			else
				flag = 1;
		}
		else if (ret == -1 || ret == -3)	/* receive error: receive 0 or port down */
		{
			break;
		}
		++i;
	}
	while (!flag && i < 6);
	return flag;
}

/*********************************************************
Function:void f_send_ack(int port_fd)
Narrative:
	Write vissible character to logfile.

Param:	int port_fd	- socket id

Return:	0   OK.
	-1	No expected string.
	-2	No fd ready when timeout.
	-3	An error occur when performing poll or read.
*********************************************************/
void f_send_ack(int port_fd)
{
	if (sp30_version == SP30)
		to_sno = from_rno;
	else
		to_sno = 0;
	to_rno = (from_sno + 1) % 8;
	write_msg("send ack!", (unsigned char *) "", 0);
	f_formulate(ack_frame, to_sno, to_rno, 9);
	f_sp30_send_frame(port_fd, ack_frame, 9);
}

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

Param:	int port_fd	- socket id
	char *phone_number - a pointer to accessed telephone number
	int max_retrys - max times to try 

Return:	0   Access line fail.
	1	OK.
	2	Invalid telephone number.
	3	Line busy.
*********************************************************/
int f_sp30_access_line(int port_fd, char *phone_number, int max_retrys)
{
	int flag, i, ret;
	unsigned char this_to_sno;
	unsigned char line_status = 0;
	unsigned char test_status = 0;
	flag = 0;
	i = 0;
	write_msg("send access line!", (unsigned char *) "", 0);
	to_sno = from_rno;
	if (receive_str[3] == 0x30 || receive_str[3] == 0x20)
	{
		to_rno = (from_sno + 1) % 8;
	}
	access_line_frame[8] = sp30_version == SP30 ? 0x96 : 0x64;
	access_line_frame[12] = 0x01;
	f_sp30_make_phone_number(access_line_frame, phone_number);
	f_formulate(access_line_frame, to_sno, to_rno, 43);
	f_sp30_send_frame(port_fd, access_line_frame, 43);
	this_to_sno = to_sno;
	while (!flag && i < max_retrys)
	{
		write_msg("i=", (unsigned char *) &i, 2);
		ret = f_sp30_result_receive(port_fd, receive_str, &receive_len);
		if (!ret)
		{
			write_msg("receive:", receive_str, receive_len);
			from_sno = receive_str[2] >> 4;
			from_rno = receive_str[2] & 0x0f;
			if (receive_str[3] == 0x30 && receive_str[6] == 0x03 &&
					(receive_str[8] == 0x96 || receive_str[8] == 0x64) &&
					(receive_str[22] == 0x00 || receive_str[22] == 0x01))
			{
				test_status = receive_str[22];
				line_status = receive_str[23];
				if ((line_status == 0x01 || line_status == 0x08) && test_status == 0x00)
					flag = 1;
				else if (line_status == 0x05 || line_status == 0x06)
					flag = 2;							/* NULL */
				else
					flag = 3;							/* Busy */
				/*
				   f_send_ack(port_fd);
				   ret=f_sp30_result_receive(port_fd,receive_str,&receive_len);
				   if (!ret)
				   {
				   write_msg("receive:",receive_str,receive_len);
				   from_sno=receive_str[2]>>4;
				   from_rno=receive_str[2]&0x0f;
				   }
				 */
				write_msg("Access Line OK! Linestatus=", (unsigned char *) &line_status, 1);
				write_msg("                Teststatus=", (unsigned char *) &test_status, 1);
			}
			else
			{
				if ((to_sno + 1) % 8 != from_rno)
				{
					to_sno = this_to_sno;
					to_rno = (from_sno + 1) % 8;
					write_msg("from_rno does not right!", (unsigned char *) "", 0);
					f_formulate(access_line_frame, to_sno, to_rno, 43);
					f_sp30_send_frame(port_fd, access_line_frame, 43);
				}
				else
				{
					f_send_ack(port_fd);
				}
			}
		}
		else
		{
			if (ret == 1)							/* verify error */
			{
				/*from_rno=receive_str[2]&0x0f;
				   to_rno=from_rno; */
			}
			to_sno = this_to_sno;
			write_msg("no respone!\nsend access line frame!", (unsigned char *) "", 0);
			f_formulate(access_line_frame, to_sno, to_rno, 43);
			f_sp30_send_frame(port_fd, access_line_frame, 43);
		}
		++i;
	}
	return flag;
}

/*********************************************************
Function:int f_sp30_test_MLCT(int port_fd, int max_retrys)
Narrative:
	Test MLCT.

Param:	int port_fd	- socket id
	int max_retrys - max times to try 

Return:	0   Test MLCT fail.
	1	OK.
	2	High voltage.
*********************************************************/
int f_sp30_test_MLCT(int port_fd, int max_retrys)
{
	int flag, i, ret, j;
	unsigned char this_to_sno;
	write_msg("send start test!", (unsigned char *) "", 0);
	flag = 0;
	i = 0;
	to_sno = from_rno;
	if (receive_str[3] == 0x30)
	{
		to_rno = (from_sno + 1) % 8;
	}
	this_to_sno = to_sno;
	test_frame[8] = sp30_version == SP30 ? 0x97 : 0x66;
	test_frame[12] = 0x10;				/* test MLCT */
	f_formulate(test_frame, to_sno, to_rno, 33);
	f_sp30_send_frame(port_fd, test_frame, 33);
	while (!flag && i < max_retrys)
	{
		write_msg("i=", (unsigned char *) &i, 2);
		ret = f_sp30_result_receive(port_fd, receive_str, &receive_len);
		if (!ret)
		{
			write_msg("receive:", receive_str, receive_len);
			from_sno = receive_str[2] >> 4;
			from_rno = receive_str[2] & 0x0f;
			if (receive_str[3] == 0x30 && receive_str[6] == 0x03 && (receive_str[8] == 0x66 || receive_str[8] == 0x97) && receive_str[22] == 0x03 && receive_str[24] == 0x10)
			{
				if (receive_str[26] == 0x03)
				{
					flag = 1;
					/*
					   j=0;
					   do
					   {
					   f_send_ack(port_fd);
					   ret=f_sp30_result_receive(port_fd,receive_str,&receive_len);
					   if (!ret)
					   {
					   write_msg("receive:",receive_str,receive_len);
					   from_sno=receive_str[2]>>4;
					   from_rno=receive_str[2]&0x0f;
					   }
					   ++j;
					   } while (ret && j<1);
					 */
					write_msg("Test MLCT OK!", (unsigned char *) "", 0);
				}
				else if (receive_str[26] == 0x00)
				{
					flag = 2;
					f_send_ack(port_fd);
					ret = f_sp30_result_receive(port_fd, receive_str, &receive_len);
					write_msg("High Volt!", (unsigned char *) "", 0);
				}
			}
			else
			{
				if ((to_sno + 1) % 8 != from_rno)
				{
					to_sno = this_to_sno;
					to_rno = (from_sno + 1) % 8;
					write_msg("from_rno does not right!", (unsigned char *) "", 0);
					f_formulate(test_frame, to_sno, to_rno, 33);
					f_sp30_send_frame(port_fd, test_frame, 33);
				}
				else
				{
					/*f_send_ack(port_fd); */
					to_sno = this_to_sno;
					to_rno = (from_sno + 1) % 8;
					write_msg("from_rno does not right!", (unsigned char *) "", 0);
					f_formulate(test_frame, to_sno, to_rno, 33);
					f_sp30_send_frame(port_fd, test_frame, 33);
				}
			}
		}
		else
		{
			if (ret == 1)							/* verify error */
			{
				/*from_rno=receive_str[2]&0x0f;
				   to_rno=from_rno; */
			}
			to_sno = this_to_sno;
			write_msg("no respone!\nsend test frame!", (unsigned char *) "", 0);
/*
   to_sno=from_rno;
   to_rno=(from_sno+1)%8;
   f_formulate(ack_frame,to_sno,to_rno,9);
   f_sp30_send_frame(port_fd, ack_frame, 9);
 */
			f_formulate(test_frame, to_sno, to_rno, 33);
			f_sp30_send_frame(port_fd, test_frame, 33);

		}
		++i;
		/*sleep(1); */
	}
	return flag;
}

/*********************************************************
Function:int f_sp30_test_V_R_CAP(int port_fd, int max_retrys, TESTMSG * testmsg)
Narrative:
	Test 12 specialities of line.

Param:	int port_fd	- socket id
	int max_retrys - max times to try
	TESTMSG * testmsg	- struct of test message

Return:	0   Test fail.
	1	Test OK.
********************************************************/
int f_sp30_test_V_R_CAP(int port_fd, int max_retrys, TESTMSG * testmsg)
{
	int flag, i, ret;
	unsigned char this_to_sno;
	int pack_type;
	unsigned char result_str[24];
	memset(result_str, 0, 24);
	write_msg("send start test V_R_CAP!", (unsigned char *) "", 0);
	flag = 0;