simuintp.c

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

#include "simu112.h"
#include "simuintp.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

DEVICEHEAD *device_head;
extern COMPRULEDATA comp_rule_data[MAX_SWITCH + 1];
COMPRULEDATA *get_comp_rule_data(char *switch_name);

/*
   char *tl1_params[MAX_PARAM_CNT+1] = {
   "sid","ctag","V","S1","S2","S3","S4","S5",
   "S6","dr1","dr2","dr3","dr4","dr5","dc1","dc2","dc3","dc4","dc5",
   "ac1","ac2","ac3","af1","af2","rg1","rg2","rg3","th1","th2","th3",
   "ct1","ct2","bl1","bl2","ln1","ln2","ln3","lc1","lc2",
   "nse","ac4","ac5","ac6",
   "ntsac1","ntsac2","ntsac3","ntsac4","ntsac5","ntsac6",
   "nzrav","nzrae","nzrbv","nzrbe","nzrab","nzrba","nzgnse",
   "nzvae","nzvbe","nzvab",NULL
   };
 */

char *tl1_params[MAX_PARAM_CNT + 1] =
{
	"sid", "ctag", "V", "S1", "S2", "S3", "S4", "S5",
	"S6", "dc1", "dc2", "dc3", "dc4", "dc5", "dc1", "dc2", "dc3", "dc4", "dc5",
"ac1", "ac2", "ac3", "af1", "af2", "rg1", "rg2", "rg3", "th1", "th2", "th3",
	"ct1", "ct2", "bl1", "bl2", "ln1", "ln2", "ln3", "lc1", "lc2",
	"nse", "ac4", "ac5", "ac6",
	"ntsac1", "ntsac2", "ntsac3", "ntsac4", "ntsac5", "ntsac6",
	"nzrav", "nzrae", "nzrbv", "nzrbe", "nzrab", "nzrba", "nzgnse",
	"nzvae", "nzvbe", "nzvab", "ORST", "DIALRST", "FEEDRST", "LOOPRST",
	"VBATVAL", "ILVAL", NULL
};

char tl1_val[MAX_PARAM_CNT + 1][12];

char *summary_code[MAX_SUM_CODES + 1] =
{
"AC1", "AC2", "AC3", "AF1", "AF2", "AF3", "AF5", "AF7", "AF8", "AF9", "AF10",
"AF12", "BL1", "BL2", "BL3", "BT1", "BT2", "BT3", "BT4", "BT5", "BT6", "BT7",
	"BT8", "BT9", "BT10", "BT11", "BT12", "BT13", "DL1", "DL3", "DL6", "DL7",
	"DL10", "DL11", "DL12", "DL13", "DL14", "DL15", "DL16", "DL21", "DL24",
	"DL25", "DLBP", "DL9X", "IU1", "IU3", "IU5", "IU6", "IU7", "IU8", "IU10",
	"IU11", "IU12", "IU14", "IU16", "IU17", "IU19", "IU21", "IU22", "IU24",
	"IU25", "MC1", "MC2", "MC5", "MC6", "MC12", "OP1", "OP2", "OP3", "OP4",
	"OP5", "OP7", "OP8", "OP11", "OP12", "OP15", "RF1", "RF2", "RF3", "RF4",
	"RF5", "RF6", "RF7", "RF8", "RF9", "RF10", "RF11", "RF12", "RF13", "RF14",
	"RF15", "RF16", "RF17", "RF18", "RF19", "RF20", "RF21", "RF22", "RF23",
	"RF24", "RF25", "RF26", "RF27", "RF28", "RF29", "RF30", "RF31", "RF32",
	"RF33", "RF34", "RF35", "RF36", "RF37", "RF38", "RF39", "RF40", "RF41",
	"RF42", "RF43", "RF44", "RF45", "RF46", "RF47", "RF48", "RF49", "RF50",
	"RF51", "RF52", "RF53", "RF54", "RG1", "RG2", "RG3", "RG4", "RG5", "RG6",
"RG7", "RG10", "RG11", "RG14", "RG19", "RG20", "RG21", "RGBT", "SG1", "SG2",
"SG3", "SG4", "SG7", "SG8", "SP4", "SP5", "SP6", "SP7", "SP8", "UX2", "UX3",
"UX4", "UX6", "QS1", "QS2", "QS3", "QS4", "QS5", "QS6", "QS7", "QS8", "QS9",
	"QS10", "CO1", "CO2", "CO3", "CO4", "CO5", "CO6", "CO7", "CO8",
	"CO9", "CO14", "CO15", "CO16", "CO17", "CO19", "CO21", NULL
};
char *ver_codes[MAX_VER_CODES + 1] =
{
	"0", "3", "6", "08", "11", "12", "13", "14", "17",
	"18", "21", "22", "25", "26",
	"31", "32", "33", "35", "41", "42", "46", "47", "98", "99",
	"N1", "P1", "", "N2", "P2", "27", "15", "16", "93", "96",
	"A1", "A2", "A3", "A4", "A5", "71", "RB", ""
};


int pars_params[MAX_PARS_PARAMS] =
{DR4_I, DR5_I, DC4_I, DC5_I, LC1_I, LC2_I,
 NTSAC2_I, NTSAC4_I, NTSAC6_I,
 NZVAE_I, NZVBE_I, NZVAB_I};

void rawToreal(TESTRESULT test_result, TESTVALUE * test_value, dbl_set * p_dbl_flags);
void set_sum_ver_code(TESTVALUE test_value, sum_set * p_sum_flags, ver_set * p_ver_flags, COMPRULEDATA * p_comp_rule_data);
void summaryCheck(sum_set * p_sum_flags, int vercode);
int vercodeCheck(ver_set * p_ver_flags);
void assignSumCode(sum_set * p_sum_flag);
static int check_for_pars(int param_i);
static void add_d_to_buffer(dbl_set * p_dbl_flags, char *TL1Response, int param_i);
static int is_line_present(int start_i, int end_i);
static int is_d_line_present(dbl_set * p_dbl_flags, int start_i, int end_i);
void TL1FmtResponse(dbl_set * p_dbl_flags, char *TL1Response);
int get_vercode_from_result(char *result, char *vername);
/******************************************
 *comment:                                *
 *       get sumcode and vercode,then     *
 *return the TL1 format response to client*
 ******************************************/
void getTL1response(TESTRESULT test_result, char *TL1response)
{
	dbl_set tl1_dbl_flags, *p_dbl_flags;
	sum_set summary_codes_flags, *p_sum_flags;
	ver_set ver_codes_flags, *p_ver_flags;
	TESTVALUE test_value;
	int ver_code;
	char vercode_str[10];
	int i;
	COMPRULEDATA *p_comp_rule_data;

	p_dbl_flags = &tl1_dbl_flags;
	p_sum_flags = &summary_codes_flags;
	p_ver_flags = &ver_codes_flags;
	DBL_ZERO(p_dbl_flags);
	SUM_ZERO(p_sum_flags);
	VER_ZERO(p_ver_flags);
	/*translate original data into test_value->type data */
	rawToreal(test_result, &test_value, p_dbl_flags);
	p_comp_rule_data = get_comp_rule_data(test_result.SwitchName);
	if (p_comp_rule_data && p_comp_rule_data->index_head)
	{
/*
   printf("index:\n");
   for (i=0;i<p_comp_rule_data->index_head->count;++i)
   {
   printf("%d,%s,first:%d,last:%d\n",(p_comp_rule_data->index_head->comp_index+i)->item,
   (p_comp_rule_data->index_head->comp_index+i)->item_str,
   (p_comp_rule_data->index_head->comp_index+i)->first,
   (p_comp_rule_data->index_head->comp_index+i)->last );
   }
   printf("compare_table:\n");
   for (i=0;i<p_comp_rule_data->index_head->count;++i)
   {
   printf("%s,%d,%f,%f,%s\n",(p_comp_rule_data->compare_table+i)->item
   ,(p_comp_rule_data->compare_table+i)->range
   ,(p_comp_rule_data->compare_table+i)->upper
   ,(p_comp_rule_data->compare_table+i)->lower
   ,(p_comp_rule_data->compare_table+i)->sumcode );
   }
 */
		set_sum_ver_code(test_value, p_sum_flags, p_ver_flags, p_comp_rule_data);
	}
	else
	{
		/*printf("NULL!\n"); */
	}
	if (!strncmp(test_result.TestConclusion, "V6", 2))
	{
		VER_SET(VER6, p_ver_flags);
	}
	else if (!strncmp(test_result.TestConclusion, "V08", 3))
	{
		VER_SET(VER08, p_ver_flags);
	}
	else if (!strncmp(test_result.TestConclusion, "V13", 3))
	{
		VER_SET(VER13, p_ver_flags);
	}
	/* Deal with the OutLine and InLine test result if they have values.
	   First consider the InLine error, if no InLine error then we deal with
	   the OutLine error */
	if (test_result.OutResult[0] != 0)
	{
		if (test_result.DialToneResult[0] == '1' || test_result.DialToneResult[0] == '2')
			ver_code = VER32;					/* InLine error */
		else if (test_result.FeedVolResult[0] == '1' || test_result.LoopRingResult[0] == '1')
			ver_code = VER31;					/* InLine error */
		else
			/* OutLine error */
		{
			ver_code = get_vercode_from_result(test_result.OutResult, vercode_str);
			if (ver_code != -1)
				VER_SET(ver_code, p_ver_flags);
		}
	}
	ver_code = vercodeCheck(p_ver_flags);
	if (ver_code != -1)
		strcpy(tl1_val[V_I], ver_codes[ver_code]);
	summaryCheck(p_sum_flags, ver_code);
	assignSumCode(p_sum_flags);
	TL1FmtResponse(p_dbl_flags, TL1response);
}
/******************************************************
 *comment:                                            *
 *       get comp_rule_data                           *
 ******************************************************/
COMPRULEDATA *get_comp_rule_data(char *switch_name)
{
	static COMPRULEDATA *p;
	int ok_flag = 0;
	p = comp_rule_data;						/* comp_rule_data -- declare at simumain.c */
	while (p->SwitchName[0] != '\0')
	{
		if (!strcmp(p->SwitchName, switch_name))
		{
			ok_flag = 1;
			break;
		}
		++p;
	}
	if (!ok_flag)
		p = NULL;										/* Not found, then set to NULL */
	return (p);
}

/******************************************************
 *comment:                                            *
 *       translate original data into double type data*
 ******************************************************/
void rawToreal(TESTRESULT test_result, TESTVALUE * test_value, dbl_set * p_dbl_flags)
{
	memset((void *) test_value, 0, sizeof(TESTVALUE));
	memset((void *) tl1_val, 0, sizeof(tl1_val));
	if (test_result.TR2_DCres[0] != '\0')
	{
		test_value->TR2_DCres = atof(test_result.TR2_DCres);
		strcpy(tl1_val[DR1_I], test_result.TR2_DCres);
		DBL_SET(DR1_I, p_dbl_flags);
		test_value->TR2_DCres_flag = 1;
	}
	if (test_result.TG2_DCres[0] != '\0')
	{
		test_value->TG2_DCres = atof(test_result.TG2_DCres);
		strcpy(tl1_val[DR2_I], test_result.TG2_DCres);
		DBL_SET(DR2_I, p_dbl_flags);
		test_value->TG2_DCres_flag = 1;
	}
	if (test_result.RG2_DCres[0] != '\0')
	{
		test_value->RG2_DCres = atof(test_result.RG2_DCres);
		strcpy(tl1_val[DR3_I], test_result.RG2_DCres);
		DBL_SET(DR3_I, p_dbl_flags);
		test_value->RG2_DCres_flag = 1;
	}
	if (test_result.TG2_DCvol[0] != '\0')
	{
		test_value->TG2_DCvol = atof(test_result.TG2_DCvol);
		strcpy(tl1_val[DR4_I], test_result.TG2_DCvol);
		DBL_SET(DR4_I, p_dbl_flags);
		test_value->TG2_DCvol_flag = 1;
	}
	if (test_result.RG2_DCvol[0] != '\0')
	{
		test_value->RG2_DCvol = atof(test_result.RG2_DCvol);
		strcpy(tl1_val[DR5_I], test_result.RG2_DCvol);
		DBL_SET(DR5_I, p_dbl_flags);
		test_value->RG2_DCvol_flag = 1;
	}
	if (test_result.TG_ACvol[0] != '\0')
	{
		test_value->TG_ACvol = atof(test_result.TG_ACvol);
		strcpy(tl1_val[AF1_I], test_result.TG_ACvol);
		DBL_SET(AF1_I, p_dbl_flags);
		test_value->TG_ACvol_flag = 1;
	}
	if (test_result.RG_ACvol[0] != '\0')
	{
		test_value->RG_ACvol = atof(test_result.RG_ACvol);
		strcpy(tl1_val[AF2_I], test_result.RG_ACvol);
		DBL_SET(AF2_I, p_dbl_flags);
		test_value->RG_ACvol_flag = 1;
	}
	if (test_result.TR_ACres[0] != '\0')
	{
		test_value->TR_ACres = atof(test_result.TR_ACres);
		strcpy(tl1_val[AC1_I], test_result.TR_ACres);
		DBL_SET(AC1_I, p_dbl_flags);
		test_value->TR_ACres_flag = 1;
	}
	if (test_result.TG_ACres[0] != '\0')
	{
		test_value->TG_ACres = atof(test_result.TG_ACres);
		strcpy(tl1_val[AC2_I], test_result.TG_ACres);
		DBL_SET(AC2_I, p_dbl_flags);
		test_value->TG_ACres_flag = 1;
	}
	if (test_result.RG_ACres[0] != '\0')
	{
		test_value->RG_ACres = atof(test_result.RG_ACres);
		strcpy(tl1_val[AC3_I], test_result.RG_ACres);
		DBL_SET(AC3_I, p_dbl_flags);
		test_value->RG_ACres_flag = 1;
	}
	if (test_result.TR_cap[0] != '\0')
	{
		test_value->TR_cap = atof(test_result.TR_cap);
		strcpy(tl1_val[AC4_I], test_result.TR_cap);
		DBL_SET(AC4_I, p_dbl_flags);
		test_value->TR_cap_flag = 1;
	}
	if (test_result.TG_cap[0] != '\0')
	{
		test_value->TG_cap = atof(test_result.TG_cap);
		strcpy(tl1_val[AC5_I], test_result.TG_cap);
		DBL_SET(AC5_I, p_dbl_flags);
		test_value->TG_cap_flag = 1;
	}
	if (test_result.RG_cap[0] != '\0')
	{
		test_value->RG_cap = atof(test_result.RG_cap);
		strcpy(tl1_val[AC6_I], test_result.RG_cap);
		DBL_SET(AC6_I, p_dbl_flags);
		test_value->RG_cap_flag = 1;
	}
	if (test_result.LongBal[0] != '\0')
	{
		test_value->LongBal = atof(test_result.LongBal);
		strcpy(tl1_val[BL1_I], test_result.LongBal);
		DBL_SET(BL1_I, p_dbl_flags);
		test_value->LongBal_flag = 1;
	}
	if (test_result.CapBal[0] != '\0')
	{
		test_value->CapBal = atof(test_result.CapBal);
		strcpy(tl1_val[BL2_I], test_result.CapBal);
		DBL_SET(BL2_I, p_dbl_flags);
		test_value->CapBal_flag = 1;
	}
	if (test_result.MetalNoise[0] != '\0')
	{
		test_value->MetalNoise = atof(test_result.MetalNoise);
		strcpy(tl1_val[NSE_I], test_result.MetalNoise);
		DBL_SET(NSE_I, p_dbl_flags);
		test_value->MetalNoise_flag = 1;
	}
	if (test_result.TG_Line[0] != '\0')
	{
		test_value->TG_Line = atof(test_result.TG_Line);
		strcpy(tl1_val[LC1_I], test_result.TG_Line);
		DBL_SET(LC1_I, p_dbl_flags);
		test_value->TG_Line_flag = 1;
	}
	if (test_result.TG_Line[0] != '\0')
	{
		test_value->RG_Line = atof(test_result.TG_Line);
		strcpy(tl1_val[LC2_I], test_result.RG_Line);
		DBL_SET(LC2_I, p_dbl_flags);
		test_value->RG_Line_flag = 1;
	}
	if (test_result.BatteryVol[0] != '\0')
	{
		test_value->BatteryVol = atof(test_result.BatteryVol);
		/*reserved:now I don't know how to process it */
		test_value->BatteryVol_flag = 1;
	}

	if (test_result.OutResult[0] != '\0')
	{
		strcpy(tl1_val[AN_ORST_I], test_result.OutResult);
		DBL_SET(AN_ORST_I, p_dbl_flags);
		test_value->OutResult = 1;
	}

	if (test_result.DialToneResult[0] != '\0')
	{
		strcpy(tl1_val[AN_DIALRST_I], test_result.DialToneResult);
		DBL_SET(AN_DIALRST_I, p_dbl_flags);
		test_value->DialToneResult = 1;
	}
	if (test_result.FeedVolResult[0] != '\0')
	{
		strcpy(tl1_val[AN_FEEDRST_I], test_result.FeedVolResult);
		DBL_SET(AN_FEEDRST_I, p_dbl_flags);
		test_value->FeedVolResult = 1;
	}
	if (test_result.LoopRingResult[0] != '\0')
	{
		strcpy(tl1_val[AN_LOOPRST_I], test_result.LoopRingResult);
		DBL_SET(AN_LOOPRST_I, p_dbl_flags);
		test_value->LoopRingResult = 1;
	}
	if (test_result.VBatValue[0] != '\0')
	{
		strcpy(tl1_val[AN_VBATVAL_I], test_result.VBatValue);
		DBL_SET(AN_VBATVAL_I, p_dbl_flags);
		test_value->VBatValue = 1;
	}
	if (test_result.ILoopValue[0] != '\0')
	{
		strcpy(tl1_val[AN_ILVAL_I], test_result.ILoopValue);
		DBL_SET(AN_ILVAL_I, p_dbl_flags);
		test_value->ILoopValue = 1;
	}
}

/*******************************************
 *comment:                                 *
 *   set the original summary code set     *
 *return void                              *
 *******************************************/
void set_sum_ver_code(TESTVALUE test_value,
											sum_set * p_sum_flags,
											ver_set * p_ver_flags,
											COMPRULEDATA * p_comp_rule_data)
{
	int i;
	if (test_value.TR2_DCres_flag == 1)
	{
		i = setSumCode(test_value.TR2_DCres, "ab_res", p_comp_rule_data);
		if (i != -1)
			SUM_SET(i, p_sum_flags);
		i = setVercode(i, test_value);
		if (i != -1)
			VER_SET(i, p_ver_flags);
	}
	if (test_value.TG2_DCres_flag == 1)