simutl1.c

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

#include "simu112.h"
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include "simuintp.h"
#ifndef WIN32_ENV
#ifndef HPUX
#include <sys/syslog.h>
#endif
#include <unistd.h>
#else
#include <WINSOCK.H>
#include <io.h>
#endif

CLIENT_STATUS *newClientStruct();
char *StringToupper(char *p);
int getSIMdriver(DRIVER_STATUS ** drv_ptr, int fd, char *ts_address, int ts_port, char *sim_drv_addr, int sim_drv_port);
static int clientRequest2(int fd, void *buffer, int cnt);

int tl1_get_cmd(char *tl1_cmd, long *type, int *cmd_num);
int tl1_get_param(char *tl1_cmd, char *param, char *buffer, int max_len);
int get_param_len(char *param_ptr, int max_len);

extern SOCKETSTRUCT so[MAX_FD];

char *ErrorCodeDefinitions[] =
{
	"S301",
	"S302",
	"S303",
	"S304",
	"S305",
	"S306",
	"S307",
	"S311",
	"S312",
	"S313",
	"S314",
	"S315",
	"S316",
	"S317",
	"S318",
	"S319",
	"S320",
	"S321",
	"S322",
	"S323",
	"S324",
	"S325",
	"S331",
	"S332",
	"S333",
	"S334",
	"S335",
	"S336",
	"S337",
	"S338",
	"S339",
	"S340"
};

COMMAND known_cmds[] =
{
	"TST-FULL", UNKNOWN, TST_FULL,
	"TST-LOOP", UNKNOWN, TST_LOOP,
	"TST-QUERY", UNKNOWN, TST_QUERY,
	"CONN-TSTSIG-SOUNDER", UNKNOWN, CONN_TSTSIG_SOUNDER,
	"CONN-TACC-POTS", UNKNOWN, CONN_TACC_POTS,
	"DISC-TACC", UNKNOWN, DISC_TACC,
	"MEAS-TN", UNKNOWN, MEAS_TN,
	"MEAS-FEEDVOL", UNKNOWN, MEAS_FEEDVOL,
	"MEAS-LOOPRING", UNKNOWN, MEAS_LOOPRING,
	"MEAS-OUTPLSE", UNKNOWN, MEAS_OUTPLSE,
	"MEAS-VG", UNKNOWN, MEAS_VG_DC,
	"MEAS-VG", UNKNOWN, MEAS_VG_AC,
	"MEAS-LOOP-CUREST", UNKNOWN, MEAS_LOOP_CUREST,
	"MEAS-LOOP-RES", UNKNOWN, MEAS_LOOP_RES,
	"MEAS-RES", UNKNOWN, MEAS_RES,
	"MEAS-CAPNC", UNKNOWN, MEAS_CAPNC,
	"MEAS-IMPED", UNKNOWN, MEAS_IMPED,
	"MEAS-NSE", UNKNOWN, MEAS_NSE,
	"MEAS-ISDN", UNKNOWN, MEAS_ISDN,
	"TST-RINGSGNL", UNKNOWN, TST_RINGSGNL,
	"CONN-MONEST", UNKNOWN, CONN_MONEST,
	"DISC-MON", UNKNOWN, DISC_MON,
	"CONN-MONBRDGD", UNKNOWN, CONN_MONBRDGD,
	"CONN-FMONBRDGD", UNKNOWN, CONN_FMONBRDGD,
	(char *) NULL, (long) NULL, (int) NULL
};

/* This function added to handle more than one command in same buffer */
int clientRequest(int fd, void *buffer, int cnt)
{
	int c;

	if (buffer == NULL)
	{
		c = clientRequest2(fd, buffer, cnt);
		return c;
	}
	for (;;)
	{
		c = clientRequest2(fd, buffer, cnt);
		if (c == 0)
			break;
		if (c == cnt)
			break;
		cnt = c;
	}
	return c;
}

static int clientRequest2(int fd, void *buffer, int cnt)
{
	int count, i, res;
	char buf[80];
	char *tmp_ptr;
	CLIENT_STATUS *cs_ptr, *cs_tmp_ptr;
	DRIVER_STATUS *drv_ptr;
	int ctag_present;
	int tsn_present;
	int tid_present;
	int tn_present;
	int exk_present;
	int v5en_present;
	int offhook_present;
	int num_present;
	int loop_present;
	int channel_present;
	int grade_present;

	long cmd_type;
	int cmd_num;
	int tsn;
	char TSN[6];
	char tid[25];
	char tn[25];
	char exk[25];
	char ctag[7];
	char v5en[21];
	char offhook[8];
	char num[2];
	char loop[5];
	char channel[6];
	char grade[2];

	char sim_drv_addr[20];
	int sim_drv_port;

	char cmd[TL1_MAX];

	if (buffer == NULL)
	{															/* EOF on client fd */
		/* look for all client structs using this port, notify of disconnect */
		so_close(fd);								/* so_close client socket */
		return (0);
	}

	if ((tmp_ptr = strchr(buffer, ';')) == NULL)
		return (cnt);								/* entire command not yet received */

	count = tmp_ptr - (char *) buffer + 1;	/* length of response */

	/* copy command into cmd buffer so we can play with it */

	memset(cmd, 0, sizeof(cmd));
	/*  test for command too long */
	/* note we fall thru with partial command which should error */
	if (count > (sizeof(cmd) - 1))
	{
		i = sizeof(cmd) - 1;
	}
	else
	{
		i = count;
	}
	memcpy(cmd, buffer, i);

	/* move any remaining chars in buffer to beginning, adjust count */
	i = 0;
	if (cnt > count)
	{
		for (; i < (cnt - count); i++)
			*((char *) buffer + i) = *((char *) buffer + i + count);
	}
	memset(((char *) buffer + i), 0, count);	/* zero remainder of buffer */
	cnt -= count;
	if (cnt < 0)
		cnt = 0;

	/* Now we will remove white space and convert to all upper case */
	RemoveWhitespace(cmd);

	fLogInfo("TL1 cmd=%s\n", cmd);

	StringToupper(cmd);
	/* set up client_status struct */
	cmd_type = 0;
	if (tl1_get_cmd(cmd, &cmd_type, &cmd_num) != PRS_SUCCESS)
	{
		deny(tid, ctag, buf, S324);
		so_write(fd, buf, strlen(buf));
		return (cnt);
	}
	memset(tid, 0, sizeof(tid));
	tl1_get_param(cmd, "TID", tid, sizeof(tid) - 1);
	if (*tid)
	{
		tid_present = 1;
	}
	else
		tid_present = 0;
	memset(buf, 0, sizeof(buf));
	tsn = 0;
	tl1_get_param(cmd, "TSN", TSN, sizeof(TSN));
	if (*TSN)
	{
		tsn = atoi(TSN);
		tsn_present = 1;
	}
	else
	{
		tsn_present = 0;
	}
	memset(tn, 0, sizeof(tn));
	tl1_get_param(cmd, "TN", tn, sizeof(tn) - 1);
	if (*tn)
	{
		tn_present = 1;
	}
	else
		tn_present = 0;
	memset(v5en, 0, sizeof(v5en));
	tl1_get_param(cmd, "V5EN", v5en, sizeof(v5en) - 1);
	if (*v5en)
	{
		v5en_present = 1;
	}
	else
		v5en_present = 0;
	memset(exk, 0, sizeof(exk));
	tl1_get_param(cmd, "EXK", exk, sizeof(exk) - 1);
	if (*exk)
	{
		exk_present = 1;
	}
	else
		exk_present = 0;
	memset(offhook, 0, sizeof(offhook));
	tl1_get_param(cmd, "OFFHOOK", offhook, sizeof(offhook) - 1);
	if (*offhook)
	{
		offhook_present = 1;
	}
	else
		offhook_present = 0;
	memset(num, 0, sizeof(num));
	tl1_get_param(cmd, "NUM", num, sizeof(num) - 1);
	if (*num)
	{
		num_present = 1;
	}
	else
		num_present = 0;
	memset(loop, 0, sizeof(loop));
	tl1_get_param(cmd, "LOOP", loop, sizeof(loop) - 1);
	if (*loop)
	{
		loop_present = 1;
	}
	else
		loop_present = 0;
	memset(channel, 0, sizeof(channel));
	tl1_get_param(cmd, "CHANNEL", channel, sizeof(channel) - 1);
	if (*channel)
	{
		channel_present = 1;
	}
	else
		channel_present = 0;
	memset(grade, 0, sizeof(grade));
	tl1_get_param(cmd, "GRADE", grade, sizeof(grade) - 1);
	if (*grade)
	{
		grade_present = 1;
	}
	else
		grade_present = 0;
	memset(ctag, 0, sizeof(ctag));
	tl1_get_param(cmd, "CTAG", ctag, sizeof(ctag) - 1);
	if (!*ctag)
	{
		*ctag = '0';
		ctag_present = 0;
	}
	else
		ctag_present = 1;

	fLogInfo("V5EN=%s\n",v5en);

/****************************************/
	/* dispatch tl1 command based on params */
/****************************************/

	/*printf("CTAG=%s\n",ctag); */
	if (cmd_num == TST_FULL || cmd_num == TST_LOOP || cmd_num == TST_QUERY || cmd_num == CONN_TACC_POTS)
	{
		if (!(ctag_present && tn_present && (exk_present || tid_present) && cmd_type))
		{
			/*lack of some parameter in command */
			deny(tid, ctag, buf, S317);
			so_write(fd, buf, strlen(buf));
			return (cnt);
		}
	}
	else
	{
		if (!ctag_present)
		{
			/*lack of some parameter in command */
			deny(tid, ctag, buf, S317);
			so_write(fd, buf, strlen(buf));
			return (cnt);
		}
	}

	/* validate tsn range */
	if (tsn_present &&
			((tsn < 0) || (tsn > 999)))
	{
		deny(tid, ctag, buf, S318);
		so_write(fd, buf, strlen(buf));
		return (cnt);
	}

	/*all parameter are presented */

	/* look for client struct on this port, with this tn&exk */
	cs_ptr = so[fd].clientStatus;
	if (cmd_num == TST_FULL || cmd_num == TST_LOOP || cmd_num == TST_QUERY || cmd_num == CONN_TACC_POTS)
	{
		/*
		   if (cs_ptr)
		   {
		   printf("TeleNumber=%s,tn=%s,ExkNumber=%s,exk=%s\n",cs_ptr->test_req_msg.TeleNumber,tn,cs_ptr->test_req_msg.ExkNumber,exk);
		   printf("cs_ptr->current_process=%d\n",cs_ptr->current_process);
		   }
		 */
		if ((cs_ptr) && (cs_ptr->current_process != CLIENT))
		{
			/*the same test item comes from the same client */
			deny(tid, ctag, buf, S319);
			so_write(fd, buf, strlen(buf));
			return (cnt);
		}
		if (!cs_ptr)
		{														/* if no struct available, get new one */
			cs_ptr = newClientStruct();
			if (!cs_ptr)
			{
				deny(tid, ctag, buf, S320);
				so_write(fd, buf, strlen(buf));
				return (cnt);
			}
			cs_ptr->tsn = tsn;
		}
		strcpy(cs_ptr->test_req_msg.TeleNumber, tn);
		strcpy(cs_ptr->test_req_msg.V5EN, v5en);
		strcpy(cs_ptr->test_req_msg.ExkNumber, exk);
		strcpy(cs_ptr->test_req_msg.Tid, tid);	/* add by DZH. 1998.11.2 */
	}
	else
	{															/* line must be accessed first */
		if (cs_ptr)
		{
			printf("cs_ptr->test_req_msg.TSN=%s,TSN=%s\n", cs_ptr->test_req_msg.TSN, TSN);
			if (strcmp(cs_ptr->test_req_msg.TSN, TSN) != 0)		/* not access line */
				cs_ptr = NULL;
		}
		if (!cs_ptr)
		{														/* if not found, then deny */
			deny(tid, ctag, buf, S323);
			so_write(fd, buf, strlen(buf));
			return (cnt);
		}
	}
	strcpy(cs_ptr->test_req_msg.OffHook, offhook);
	strcpy(cs_ptr->test_req_msg.Num, num);
	strcpy(cs_ptr->test_req_msg.Loop, loop);
	strcpy(cs_ptr->test_req_msg.Channel, channel);
	strcpy(cs_ptr->test_req_msg.Grade, grade);
	strcpy(cs_ptr->test_req_msg.TSN, TSN);
	/*printf("TSN=%s\n",cs_ptr->test_req_msg.TSN); */
	res = getSIMterm(&cs_ptr->test_req_msg, sim_drv_addr, &sim_drv_port);
	if (res == 1)
	{															/*can't be found */
		/* printf("res is %d\n",res); */
		free(cs_ptr);
		deny(tid, ctag, buf, S316);	/* not found */
		so_write(fd, buf, strlen(buf));
		return (cnt);
	}
	else if (res == 2)
	{															/* busy */
		free(cs_ptr);
		deny(tid, ctag, buf, S311);	/* OCCUPY */
		so_write(fd, buf, strlen(buf));
		return (cnt);
	}
	if (res == 0)
	{
		i = atoi(cs_ptr->test_req_msg.TSPortNo);
		res = getSIMdriver(&drv_ptr, fd, cs_ptr->test_req_msg.TSAddress, i, sim_drv_addr, sim_drv_port);
		if (res < 0)
		{														/*is busy */
			free(cs_ptr);
			switch (res)
			{
			case -1:
				deny(tid, ctag, buf, S311);
				break;
			case -2:
				deny(tid, ctag, buf, S322);
				break;
			default:
				deny(tid, ctag, buf, S320);
			}
			so_write(fd, buf, strlen(buf));
			return (cnt);
		}
		else
		{
			/*else res is the driver_fd */
			/*add to the tail of clientStatus */
			if (cs_ptr->current_process == NEW)
			{
				so[fd].count++;
				cs_tmp_ptr = so[fd].clientStatus;
				if (cs_tmp_ptr == NULL)
					so[fd].clientStatus = cs_ptr;
				else
				{
					while (cs_tmp_ptr->next)
						cs_tmp_ptr = cs_tmp_ptr->next;
					cs_tmp_ptr->next = cs_ptr;
				}
			}
			strcpy(cs_ptr->test_req_msg.CorrelationTag, ctag);
			cs_ptr->test_req_msg.CommandType = (char) cmd_num;
			cs_ptr->current_process = DRIVER;
/*      strcpy(cs_ptr->test_req_msg.TeleNumber,tn);
   strcpy(cs_ptr->test_req_msg.ExkNumber,exk); */
			cs_ptr->test_req_msg.EndFlag = ';';
			cs_ptr->tsn = tsn;
			cs_ptr->driver_fd = res;
			cs_ptr->himself_fd = fd;
			drv_ptr->client_fd = fd;
			strcpy(drv_ptr->ctag, ctag);
			/*must formulize the response head here */
			strcpy(cs_ptr->tid, normalizeTCP(cs_ptr->test_req_msg.TSAddress, cs_ptr->test_req_msg.TSPortNo));
			sprintf(cs_ptr->TL1response, "\n   \"S,%s\"", cs_ptr->tid);
			so_write(res, (void *) &cs_ptr->test_req_msg, sizeof(TESTREQMSG));
			/* printf("send_drv:%d\n",res); */
			so[res].status = STATUS_READY;
			/*set event timer of the driver */
			if (drv_ptr->timer_id)
				killEventTimer(drv_ptr->timer_id);
			drv_ptr->timer_id = setEventTimer(120, driverIdleTimeout, (void *) drv_ptr, TIME_ONESHOT);
		}
	}
	return cnt;										/* number of chars left in buffer */
}

/***************************************************************
*return >=0 socket fd                                          *
*       -1: busy                                               *
*       -2: connect to simdrv failure                          *
*       -3: alloc error                                        *
*       -4: no fd can be assigned                              *
****************************************************************/
int getSIMdriver(DRIVER_STATUS ** driver_ptr, int fd, char *ts_address, int ts_port, char *sim_drv_addr, int sim_drv_port)
{
	DRIVER_STATUS *drv_temp_ptr, *drv_ptr;
	int i, sd;

	for (i = 0; i < MAX_FD; i++)
	{
		if (so[i].whichType == IS_SIMDRV)
		{
			for (drv_ptr = so[i].driverStatus; drv_ptr != NULL; drv_ptr = drv_ptr->next)
			{
				if ((drv_ptr->client_fd == fd) && (drv_ptr->ts_port == ts_port) && (strcmp(drv_ptr->ts_address, ts_address) == 0))
				{
					if (drv_ptr->status == DRV_IDLE)
					{
						drv_ptr->status = DRV_BUSY;
						*driver_ptr = drv_ptr;
						return i;
					}
					if (drv_ptr->status == DRV_BUSY)
						return -1;
				}
			}
			drv_ptr = so[i].driverStatus;
			if ((drv_ptr->simdrv_port == sim_drv_port) && (strcmp(drv_ptr->simdrv_address, sim_drv_addr) == 0))
			{
				drv_temp_ptr = malloc(sizeof(DRIVER_STATUS));
				if (drv_temp_ptr == NULL)
				{
					return -3;
				}
				so[i].count++;
				memset(drv_temp_ptr, 0, sizeof(DRIVER_STATUS));
				while (drv_ptr->next)
					drv_ptr = drv_ptr->next;
				drv_ptr->next = drv_temp_ptr;
				drv_ptr->status = DRV_BUSY;
				strcpy(drv_ptr->ts_address, ts_address);
				drv_ptr->ts_port = ts_port;
				drv_ptr->himself_fd = i;
				*driver_ptr = drv_ptr;
				return i;
			}
		}
	}															/*for i<MAX_FD */
	sd = connectToSIMdrv(sim_drv_addr, NULL, sim_drv_port);
	if (sd < 0)
		return -2;									/*can't start sim_driver */
	else
	{
		/*generate new driver struct */
		attachSocket(sd, driverResponse, IS_SIMDRV);

		drv_temp_ptr = malloc(sizeof(DRIVER_STATUS));
		if (drv_temp_ptr == NULL)
		{
			so_close(sd);
			return -3;
		}
		memset(drv_temp_ptr, 0, sizeof(DRIVER_STATUS));
		drv_ptr = so[sd].driverStatus = drv_temp_ptr;
		drv_ptr->status = DRV_BUSY;
		strcpy(drv_ptr->ts_address, ts_address);
		drv_ptr->ts_port = ts_port;
		drv_ptr->himself_fd = sd;
		*driver_ptr = drv_ptr;
		so[i].driver_fd = sd;
		so[sd].client_fd = i;
	}
	return sd;
}

void deny(char *tid, char *ctag, char *buffer, char *errcode)
{
	time_t tt;
	struct tm *ptm;
	char *buf_ptr;

	if (*tid == 0)
		strcpy(tid, "ltsc");
	strcpy(buffer, "\n   ");
	buf_ptr = buffer + strlen(buffer);
	if (strchr(tid, ','))
	{
		*buf_ptr++ = '"';
	}
	strcpy(buf_ptr, tid);
	if (*(buf_ptr - 1) == '"')
	{
		buf_ptr = buffer + strlen(buffer);
		*buf_ptr++ = '"';
		*buf_ptr++ = 0;
	}
	/* Date and time */
	time(&tt);
	ptm = localtime(&tt);
	sprintf(buffer + strlen(buffer),
					" %02d-%02d-%02d %02d:%02d:%02d\r\nM  ",
					ptm->tm_year, ptm->tm_mon + 1, ptm->tm_mday,
					ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
	sprintf(buffer + strlen(buffer),
					"%s DENY\r\n   %s\r\n;", ctag, errcode);
}

/*:*************************************************************************
   TITLE: RemoveWhitespace (char * pstr )
   returns pointer to a result string.
   FUNCTION:   
   Removes characters from a string that are less than or equal
   0x20 if value.  This efectively removes whitespace.
   Note: This routine depends on ASCII character set
   ************************************************************************** */
char *RemoveWhitespace(char *pstr)
{
	int i, j;
	/* remove control characters which may be in buffer */
	/* also remove white space. */
	for (i = j = 0;; i++)
	{
		if (pstr[i] == '\000')
		{														/* end of string */
			pstr[j] = '\000';
			break;
		}
		if (pstr[i] > ' ')
		{