simuresp.c

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

										test_msg.CorrelationTag,
										vercode_str,
										test_msg.TestResult.LoopRes,
										test_msg.TestResult.TestConclusion);
						break;
					case MEAS_RES:
						sprintf(cs_ptr->TL1response + strlen(cs_ptr->TL1response),
										" %04d-%02d-%02d %02d:%02d:%02d\r\nM  %s COMPLD\r\n%s TG=%s,RG=%s,RT=%s\r\n%s\r\n;",
										ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday,
										ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
										test_msg.CorrelationTag,
										vercode_str,
										test_msg.TestResult.TG2_DCres, test_msg.TestResult.RG2_DCres, test_msg.TestResult.TR2_DCres,
										test_msg.TestResult.TestConclusion);
						/*printf("here:%s\n",test_msg.TestResult.TG2_DCres); */
						break;
					case MEAS_CAPNC:
						sprintf(cs_ptr->TL1response + strlen(cs_ptr->TL1response),
										" %04d-%02d-%02d %02d:%02d:%02d\r\nM  %s COMPLD\r\n%s TG=%s,RG=%s,RT=%s\r\n%s\r\n;",
										ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday,
										ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
										test_msg.CorrelationTag,
										vercode_str,
										test_msg.TestResult.TG_cap, test_msg.TestResult.RG_cap, test_msg.TestResult.TR_cap,
										test_msg.TestResult.TestConclusion);
						break;
					case MEAS_IMPED:
						sprintf(cs_ptr->TL1response + strlen(cs_ptr->TL1response),
										" %04d-%02d-%02d %02d:%02d:%02d\r\nM  %s COMPLD\r\n%s TG=%s,RG=%s,RT=%s\r\n%s\r\n;",
										ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday,
										ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
										test_msg.CorrelationTag,
										vercode_str,
										test_msg.TestResult.TG_imped, test_msg.TestResult.RG_imped, test_msg.TestResult.TR_imped,
										test_msg.TestResult.TestConclusion);
						break;
					case MEAS_NSE:
						sprintf(cs_ptr->TL1response + strlen(cs_ptr->TL1response),
										" %04d-%02d-%02d %02d:%02d:%02d\r\nM  %s COMPLD\r\n Not support now!\n\r\n;",
										ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday,
										ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
						break;
					}
					so_write(sd, cs_ptr->TL1response, strlen(cs_ptr->TL1response));
				}
				break;
			case CONN_TACC_POTS:
			case DISC_TACC:
				time(&tt);
				ptm = localtime(&tt);
				/*printf("TestConclusion:%s\n",test_msg.TestResult.TestConclusion); */
				if (strncmp(test_msg.TestResult.TestConclusion, "ok", 2) == 0)
				{
					sprintf(cs_ptr->TL1response + strlen(cs_ptr->TL1response),
									" %04d-%02d-%02d %02d:%02d:%02d\r\nM  %s COMPLD\r\n;",
									ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday,
									ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
									test_msg.CorrelationTag);
				}
				else
				{
					buf[0] = 'S';
					strncpy(&buf[1], test_msg.Error, 3);
					buf[4] = '\0';
					for (i = 0; i < NUMBER_ERROR_CODES; i++)
					{
						if (strcmp(buf, ErrorCodeDefinitions[i]) == 0)
							break;
					}
					if (i < NUMBER_ERROR_CODES)
						deny(cs_ptr->tid, drv_ptr->ctag, cs_ptr->TL1response, SERR(i));
					else
					{
						/*can't access the cause of line error */
						deny(cs_ptr->tid, drv_ptr->ctag, cs_ptr->TL1response, S305);
					}
				}
				/*printf("respond:%s\n",cs_ptr->TL1response,strlen(cs_ptr->TL1response)); */
				so_write(sd, cs_ptr->TL1response, strlen(cs_ptr->TL1response));
				if (test_msg.CommandType == CONN_TACC_POTS)
					cs_ptr->line_on = 1;
				else
					cs_ptr->line_on = 0;
				/*printf("line_on=%d\n",cs_ptr->line_on); */
				break;
			case MEAS_TN:
			case MEAS_FEEDVOL:
			case MEAS_LOOPRING:
			case TST_RINGSGNL:
			case MEAS_OUTPLSE:
			case CONN_TSTSIG_SOUNDER:
			case MEAS_ISDN:
			case CONN_MONEST:
			case DISC_MON:
			case CONN_MONBRDGD:
			case CONN_FMONBRDGD:
				if (test_msg.Error[0] != '\0')
				{
					buf[0] = 'S';
					strncpy(&buf[1], test_msg.Error, 3);
					buf[4] = '\0';
					for (i = 0; i < NUMBER_ERROR_CODES; i++)
					{
						if (strcmp(buf, ErrorCodeDefinitions[i]) == 0)
							break;
					}
					if (i < NUMBER_ERROR_CODES)
						deny(cs_ptr->tid, drv_ptr->ctag, cs_ptr->TL1response, SERR(i));
					else
					{
						/*can't access the cause of line error */
						deny(cs_ptr->tid, drv_ptr->ctag, cs_ptr->TL1response, S305);
					}
					so_write(sd, cs_ptr->TL1response, strlen(cs_ptr->TL1response));
				}
				else
				{
					time(&tt);
					ptm = localtime(&tt);
					sprintf(cs_ptr->TL1response + strlen(cs_ptr->TL1response),
								" %04d-%02d-%02d %02d:%02d:%02d\r\nM  %s COMPLD\r\n%s\r\n;",
									ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday,
									ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
							 test_msg.CorrelationTag, test_msg.TestResult.TestConclusion);
					so_write(sd, cs_ptr->TL1response, strlen(cs_ptr->TL1response));
				}
				break;
			default:
				deny(cs_ptr->tid, drv_ptr->ctag, cs_ptr->TL1response, S324);
				so_write(sd, cs_ptr->TL1response, strlen(cs_ptr->TL1response));
				break;
			}
			drv_ptr->status = DRV_IDLE;
			if (drv_ptr->timer_id)
				killEventTimer(drv_ptr->timer_id);
			drv_ptr->timer_id = 0;
			cs_ptr->current_process = CLIENT;
			/*free the cs_ptr */
		}
	}
	return cnt;										/* number of chars left in buffer */
}

void driverIdleTimeout(void *cbptr)
{
	DRIVER_STATUS *drv_ptr, *pre_drv_ptr;
	CLIENT_STATUS *cs_ptr;
	drv_ptr = (DRIVER_STATUS *) cbptr;

	/*tell client simdrv is timeout */
	cs_ptr = so[drv_ptr->client_fd].clientStatus;
	while (cs_ptr)
	{
		if (strcmp(cs_ptr->test_req_msg.CorrelationTag, drv_ptr->ctag) == 0)
			break;
		cs_ptr = cs_ptr->next;
	}
	if (!cs_ptr)
	{
		/*abort */
	}
	else
	{
		deny(cs_ptr->tid, drv_ptr->ctag, cs_ptr->TL1response, S321);
		so_write(cs_ptr->himself_fd, cs_ptr->TL1response, strlen(cs_ptr->TL1response));
	}

	so[drv_ptr->himself_fd].count--;
	if (so[drv_ptr->himself_fd].count <= 0)
	{
		so_close(drv_ptr->himself_fd);
		so[drv_ptr->himself_fd].count = 0;
		/*consider how to restart the ip link */
	}
	else
	{
		/*free drv_ptr space */
		pre_drv_ptr = so[drv_ptr->himself_fd].driverStatus;
		if (pre_drv_ptr == drv_ptr)
		{
			so[drv_ptr->himself_fd].driverStatus = NULL;
			free(drv_ptr);
		}
		else
		{
			while ((pre_drv_ptr->next != drv_ptr) && (pre_drv_ptr->next))
				pre_drv_ptr = pre_drv_ptr->next;
			if (pre_drv_ptr->next)
			{
				pre_drv_ptr->next = drv_ptr->next;
				free(drv_ptr);
			}
		}
	}
	/*kill timer id of driver */
	killEventTimer(drv_ptr->timer_id);
	drv_ptr->timer_id = 0;
}

static TIMERSTRUCT timers[MAX_TIMERS];
void killEventTimer(unsigned int timerid)
{
	if ((timerid == 0) || (timerid > MAX_TIMERS))
	{
		return;
	}
	memset((void *) &timers[timerid - 1], 0, sizeof(TIMERSTRUCT));
}

unsigned int setEventTimer(unsigned int delay,
													 TIMER_PROC lptc, void *cbptr, unsigned int flags)
{
	int i;

	/* find an empty slot */
	for (i = 0; i < MAX_TIMERS; i++)
	{
		/* test slot */
		if (timers[i].delay == 0)
		{
			/* use this slot */
			timers[i].delay = delay;
			timers[i].lptc = lptc;
			timers[i].cbptr = cbptr;
			timers[i].flags = flags;
			timers[i].start = time(NULL);
			return (i + 1);
		}
	}
	/* if here not slots found */
	return 0;
}

unsigned int processTimers()
{
	unsigned int i, j, k;
	time_t t;

	t = time(NULL);
	for (i = j = k = 0; i < MAX_TIMERS; i++)
	{
		if (timers[i].delay == 0)
		{
			/* no timer here */
			continue;
		}
		k = (unsigned int) difftime(t, timers[i].start);
		if (k >= timers[i].delay)
		{
			/* process the event */
			if ((timers[i].lptc != NULL) && (timers[i].cbptr != NULL))
			{
				timers[i].lptc(timers[i].cbptr);
			}
			if (timers[i].flags & TIME_PERIODIC)
			{
				timers[i].start = t;
			}
			else
			{
				memset((void *) &timers[i], 0, sizeof(TIMERSTRUCT));
				continue;
			}
		}
		/* Determine if this change our return value */
		/* j is the minimum time remaining */
		/* calculate the remaining time */
		k = timers[i].delay - (unsigned int) difftime(t, timers[i].start);
		if (k == 0)
			k = 1;
		if (j == 0)
			j = k;
		if (k < j)
			j = k;
	}
	return j;
}