test-q784.c

OpenSS7 This the fourth public release of the OpenSS7 Master Package. See README in the release for

struct prim mprim = {
	CC_TOKEN_REQUEST | CC_MANAGEMENT,
	31,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	{{0,}, 0},
	{{0,}, 0},
	{{0,}, 0},
	{{0,}, 0}
};

static int verbose = 0;
static int show_msg = 0;
static int show_acks = 0;

/* 
 *  -------------------------------------------------------------------------
 *
 *  Timer Functions
 *
 *  -------------------------------------------------------------------------
 */

/* 
 *  Timer values for tests: each timer has a low range (minus error margin)
 *  and a high range (plus error margin).
 */

static long timer_scale = 1;

#define TEST_TIMEOUT 5000

typedef struct timer_range {
	long lo;
	long hi;
} timer_range_t;

enum {
	t1 = 0, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15,
	t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29,
	t30, t31, t32, t33, t34, t35, t36, t37, t38, tmax
};

#undef HZ
#define HZ 1000

/* *INDENT-OFF* */
static timer_range_t timer[tmax] = {
	{(15 * HZ),		(60 * HZ)},		/* T1 15-60 seconds */
	{(3 * 60 * HZ),		(3 * 60 * HZ)},		/* T2 3 minutes */
	{(2 * 60 * HZ),		(2 * 60 * HZ)},		/* T3 2 minutes */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T4 5-15 minutes */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T5 5-15 minutes */
	{(10 * HZ),		(32 * HZ)},		/* T6 10-32 seconds (specified in Q.118) */
	{(20 * HZ),		(30 * HZ)},		/* T7 20-30 seconds */
	{(10 * HZ),		(15 * HZ)},		/* T8 10-15 seconds */
	{(2 * 60 * HZ),		(4 * 60 * HZ)},		/* T9 2-4 minutes (specified in Q.118) */
	{(4 * HZ),		(6 * HZ)},		/* T10 4-6 seconds */
	{(15 * HZ),		(20 * HZ)},		/* T11 15-20 seconds */
	{(15 * HZ),		(60 * HZ)},		/* T12 15-60 seconds */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T13 5-15 minutes */
	{(15 * HZ),		(60 * HZ)},		/* T14 15-60 seconds */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T15 5-15 minutes */
	{(15 * HZ),		(60 * HZ)},		/* T16 15-60 seconds */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T17 5-15 minutes */
	{(15 * HZ),		(60 * HZ)},		/* T18 15-60 seconds */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T19 5-15 minutes */
	{(15 * HZ),		(60 * HZ)},		/* T20 15-60 seconds */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T21 5-15 minutes */
	{(15 * HZ),		(60 * HZ)},		/* T22 15-60 seconds */
	{(5 * 60 * HZ),		(15 * 60 * HZ)},	/* T23 5-15 minutes */
	{(1 * HZ),		(2 * HZ)},		/* T24 < 2 seconds */
	{(1 * HZ),		(10 * HZ)},		/* T25 1-10 seconds */
	{(1 * 60 * HZ),		(3 * 60 * HZ)},		/* T26 1-3 minutes */
	{(4 * 60 * HZ),		(4 * 60 * HZ)},		/* T27 4 minutes */
	{(10 * HZ),		(10 * HZ)},		/* T28 10 seconds */
	{(300 * HZ / 1000),	(600 * HZ / 1000)},	/* T29 300-600 milliseconds */
	{(5 * HZ),		(10 * HZ)},		/* T30 5-10 seconds */
	{(6 * 60 * HZ),		(7 * 60 * HZ)},		/* T31 > 6 minutes */
	{(3 * HZ),		(5 * HZ)},		/* T32 3-5 seconds */
	{(12 * HZ),		(15 * HZ)},		/* T33 12-15 seconds */
	{(12 * HZ),		(15 * HZ)},		/* T34 12-15 seconds */
	{(15 * HZ),		(20 * HZ)},		/* T35 15-20 seconds */
	{(15 * HZ),		(20 * HZ)},		/* T36 15-20 seconds */
	{(2 * HZ),		(4 * HZ)},		/* T37 2-4 seconds */
	{(15 * HZ),		(20 * HZ)}		/* T38 15-20 seconds */
};
/* *INDENT-ON* */

long test_start = 0;

static int state;

/* 
 *  Return the current time in milliseconds.
 */
static long
now(void)
{
	long ret;
	struct timeval now;
	if (gettimeofday(&now, NULL)) {
		printf("***************ERROR: couldn't get time!\n");
		printf("                      %s: %s\n", __FUNCTION__, strerror(errno));
		FFLUSH(stdout);
		return (0);
	}
	if (!test_start)	/* avoid blowing over precision */
		test_start = now.tv_sec;
	ret = (now.tv_sec - test_start) * 1000L;
	ret += (now.tv_usec + 999L) / 1000L;
	return ret;
}
static long
milliseconds(char *t)
{
	printf("                    .  .              :                .                    \n");
	printf("                    .  .            %6s             .                    (%d)\n", t,
	       state);
	printf("                    .  .              :                .                    \n");
	FFLUSH(stdout);
	return now();
}
static long
milliseconds_2nd(char *t)
{
	printf("                    .  .              :   :            .                    \n");
	printf("                    .  .              : %6s         .                    (%d)\n", t,
	       state);
	printf("                    .  .              :   :            .                    \n");
	FFLUSH(stdout);
	return now();
}

/* 
 *  Check the current time against the beginning time provided as an argnument
 *  and see if the time inverval falls between the low and high values for the
 *  timer as specified by arguments.  Return SUCCESS if the interval is within
 *  the allowable range and FAILURE otherwise.
 */
static int
check_time(const char *t, long i, long lo, long hi)
{
	float tol, dlo, dhi, itv;
	itv = i * timer_scale;
	dlo = lo;
	dhi = hi;
	tol = 100 * timer_scale;
	itv = itv / 1000;
	dlo = dlo / 1000;
	dhi = dhi / 1000;
	tol = tol / 1000;
	printf("                    |  |(%7.3g <= %7.3g <= %7.3g)| %s             (%d)\n",
	       dlo - tol, itv, dhi + tol, t, state);
	FFLUSH(stdout);
	if (dlo - tol <= itv && itv <= dhi + tol)
		return SUCCESS;
	else
		return FAILURE;
}

static int
time_event(int event)
{
	if (verbose) {
		float t, m;
		struct timeval now;
		gettimeofday(&now, NULL);
		if (!test_start)
			test_start = now.tv_sec;
		t = (now.tv_sec - test_start);
		m = now.tv_usec;
		m = m / 1000000;
		t += m;
		printf
		    ("                    |  | %11.6g                   |                    (%d)\n",
		     t, state);
		FFLUSH(stdout);
	}
	return (event);
}

static int timer_timeout = 0;

static void
timer_handler(int signum)
{
	if (signum == SIGALRM)
		timer_timeout = 1;
	return;
}

static int
timer_sethandler(void)
{
	sigset_t mask;
	struct sigaction act;
	act.sa_handler = timer_handler;
	act.sa_flags = SA_RESTART | SA_ONESHOT;
	act.sa_restorer = NULL;
	sigemptyset(&act.sa_mask);
	if (sigaction(SIGALRM, &act, NULL))
		return FAILURE;
	sigemptyset(&mask);
	sigaddset(&mask, SIGALRM);
	sigprocmask(SIG_UNBLOCK, &mask, NULL);
	return SUCCESS;
}

/* 
 *  Start an interval timer as the overall test timer.
 */
static int
start_tt(long duration)
{
	struct itimerval setting = {
		{0, 0},
		{duration / 1000, (duration % 1000) * 1000}
	};
	if (timer_sethandler())
		return FAILURE;
	if (setitimer(ITIMER_REAL, &setting, NULL))
		return FAILURE;
	timer_timeout = 0;
	return SUCCESS;
}
static int
start_st(long duration)
{
	long sdur = (duration + timer_scale - 1) / timer_scale;
	return start_tt(sdur);
}

static int
stop_tt(void)
{
	struct itimerval setting = { {0, 0}, {0, 0} };
	sigset_t mask;
	struct sigaction act;
	if (setitimer(ITIMER_REAL, &setting, NULL))
		return FAILURE;
	act.sa_handler = SIG_DFL;
	act.sa_flags = 0;
	act.sa_restorer = NULL;
	sigemptyset(&act.sa_mask);
	if (sigaction(SIGALRM, &act, NULL))
		return FAILURE;
	timer_timeout = 0;
	sigemptyset(&mask);
	sigaddset(&mask, SIGALRM);
	sigprocmask(SIG_BLOCK, &mask, NULL);
	return SUCCESS;
}

#define ISUP_MT_IAM	  1UL	/* 0x01 - 0b00000001 - Initial address */
#define ISUP_MT_SAM	  2UL	/* 0x02 - 0b00000010 - Subsequent address */
#define ISUP_MT_INR	  3UL	/* 0x03 - 0b00000011 - Information request */
#define ISUP_MT_INF	  4UL	/* 0x04 - 0b00000100 - Information */
#define ISUP_MT_COT	  5UL	/* 0x05 - 0b00000101 - Continuity */
#define ISUP_MT_ACM	  6UL	/* 0x06 - 0b00000110 - Address complete */
#define ISUP_MT_CON	  7UL	/* 0x07 - 0b00000111 - Connect (not old ANSI) */
#define ISUP_MT_FOT	  8UL	/* 0x08 - 0b00001000 - Forward transfer */
#define ISUP_MT_ANM	  9UL	/* 0x09 - 0b00001001 - Answer */
#define ISUP_MT_REL	 12UL	/* 0x0c - 0b00001100 - Release */
#define ISUP_MT_SUS	 13UL	/* 0x0d - 0b00001101 - Suspend */
#define ISUP_MT_RES	 14UL	/* 0x0e - 0b00001110 - Resume */
#define ISUP_MT_RLC	 16UL	/* 0x10 - 0b00010000 - Release complete */
#define ISUP_MT_CCR	 17UL	/* 0x11 - 0b00010001 - Continuity check request */
#define ISUP_MT_RSC	 18UL	/* 0x12 - 0b00010010 - Reset circuit */
#define ISUP_MT_BLO	 19UL	/* 0x13 - 0b00010011 - Blocking */
#define ISUP_MT_UBL	 20UL	/* 0x14 - 0b00010100 - Unblcoking */
#define ISUP_MT_BLA	 21UL	/* 0x15 - 0b00010101 - Blocking acknowledgement */
#define ISUP_MT_UBA	 22UL	/* 0x16 - 0b00010110 - Unblocking acknowledgement */
#define ISUP_MT_GRS	 23UL	/* 0x17 - 0b00010111 - Circuit group reset */
#define ISUP_MT_CGB	 24UL	/* 0x18 - 0b00011000 - Circuit group blocking */
#define ISUP_MT_CGU	 25UL	/* 0x19 - 0b00011001 - Circuit group unblocking */
#define ISUP_MT_CGBA	 26UL	/* 0x1a - 0b00011010 - Circuit group blocking acknowledgement */
#define ISUP_MT_CGUA	 27UL	/* 0x1b - 0b00011011 - Circuit group unblocking acknowledgement */
#define ISUP_MT_CMR	 28UL	/* 0x1c - 0b00011100 - Call Modification Request (not old ANSI) */
#define ISUP_MT_CMC	 29UL	/* 0x1d - 0b00011101 - Call Modification Completed (not old ANSI) */
#define ISUP_MT_CMRJ	 30UL	/* 0x1e - 0b00011110 - Call Modification Reject (not old ANSI) */
#define ISUP_MT_FAR	 31UL	/* 0x1f - 0b00011111 - Facility request */
#define ISUP_MT_FAA	 32UL	/* 0x20 - 0b00100000 - Facility accepted */
#define ISUP_MT_FRJ	 33UL	/* 0x21 - 0b00100001 - Facility reject */
#define ISUP_MT_FAD	 34UL	/* 0x22 - 0b00100010 - Facility Deactivated (old Bellcore only) */
#define ISUP_MT_FAI	 35UL	/* 0x23 - 0b00100011 - Facility Information (old Bellcore only) */
#define ISUP_MT_LPA	 36UL	/* 0x24 - 0b00100100 - Loop back acknowledgement */
#define ISUP_MT_DRS	 39UL	/* 0x27 - 0b00100111 - Delayed release (not old ANSI) */
#define ISUP_MT_PAM	 40UL	/* 0x28 - 0b00101000 - Pass along */
#define ISUP_MT_GRA	 41UL	/* 0x29 - 0b00101001 - Circuit group reset acknowledgement */
#define ISUP_MT_CQM	 42UL	/* 0x2a - 0b00101010 - Circuit group query */
#define ISUP_MT_CQR	 43UL	/* 0x2b - 0b00101011 - Circuit group query response */
#define ISUP_MT_CPG	 44UL	/* 0x2c - 0b00101100 - Call progress */
#define ISUP_MT_USR	 45UL	/* 0x2d - 0b00101101 - User-to-user information */
#define ISUP_MT_UCIC	 46UL	/* 0x2e - 0b00101110 - Unequipped circuit identification code */
#define ISUP_MT_CFN	 47UL	/* 0x2f - 0b00101111 - Confusion */
#define ISUP_MT_OLM	 48UL	/* 0x30 - 0b00110000 - Overload */
#define ISUP_MT_CRG	 49UL	/* 0x31 - 0b00110001 - Charge information */
#define ISUP_MT_NRM	 50UL	/* 0x32 - 0b00110010 - Network resource management */
#define ISUP_MT_FAC	 51UL	/* 0x33 - 0b00110011 - Facility */
#define ISUP_MT_UPT	 52UL	/* 0x34 - 0b00110100 - User part test */
#define ISUP_MT_UPA	 53UL	/* 0x35 - 0b00110101 - User part available */
#define ISUP_MT_IDR	 54UL	/* 0x36 - 0b00110110 - Identification request */
#define ISUP_MT_IRS	 55UL	/* 0x37 - 0b00110111 - Identification response */
#define ISUP_MT_SGM	 56UL	/* 0x38 - 0b00111000 - Segmentation */
#define ISUP_MT_CRA	233UL	/* 0xe9 - 0b11101001 - Circuit Reservation Ack (old Bellcore/ANSI
				   2000) */
#define ISUP_MT_CRM	234UL	/* 0xea - 0b11101010 - Circuit Reservation (old Bellcore/ANSI 2000) 
				 */
#define ISUP_MT_CVR	235UL	/* 0xeb - 0b11101011 - Circuit Validation Response (old
				   Bellcore/ANSI 2000) */
#define ISUP_MT_CVT	236UL	/* 0xec - 0b11101100 - Circuit Validation Test (old Bellcore/ANSI
				   2000) */
#define ISUP_MT_EXM	237UL	/* 0xed - 0b11101101 - Exit (old Bellcore/ANSI 2000) */
#define ISUP_MT_NON	248UL	/* 0xf8 - 0b11111000 - National Notification (Spain) */
#define ISUP_MT_LLM	252UL	/* 0xfc - 0b11111100 - National Malicious Call (Spain) */
#define ISUP_MT_CAK	253UL	/* 0xfd - 0b11111101 - Charge Acknowledgement (Singapore) */
#define ISUP_MT_TCM	254UL	/* 0xfe - 0b11111110 - Tariff Charge (Singapore) */
#define ISUP_MT_MCP	255UL	/* 0xff - 0b11111111 - Malicious Call Print (Singapore) */

#define ISUP_PT_CGPN	 10UL	/* 0x0a - 0b00001010 - Calling party number */

/* Events and Actions */
enum {
	IAM = 2, SAM, INR, INF, COT, ACM, CON, FOT, ANM, REL, SUS, RES, RLC,
	CCR, RSC, BLO, UBL, BLA, UBA, GRS, CGB, CGU, CGBA, CGUA, CMR, CMC,
	CMRJ, FAR, FAA, FRJ, FAD, FAI, LPA, DRS, PAM, GRA, CQM, CQR, CPG, USR,
	UCIC, CFN, OLM, CRG, NRM, FAC, UPT, UPA, IDR, IRS, SGM, CRA, CRM, CVR,
	CVT, EXM, NON, LLM, CAK, TCM, MCP, PAUSE, RESUME, RESTART_COMPLETE,
	USER_PART_UNKNOWN, USER_PART_UNEQUIPPED, USER_PART_UNAVAILABLE,
	CONGESTION,
	INFO_REQ, OPTMGMT_REQ, BIND_REQ, UNBIND_REQ, ADDR_REQ, SETUP_REQ,
	MORE_INFO_REQ, INFORMATION_REQ, CONT_CHECK_REQ, CONT_TEST_REQ,
	CONT_REPORT_REQ, SETUP_RES, PROCEEDING_REQ, ALERTING_REQ,
	PROGRESS_REQ, IBI_REQ, CONNECT_REQ, SETUP_COMPLETE_REQ, FORWXFER_REQ,
	SUSPEND_REQ, SUSPEND_RES, SUSPEND_REJECT_REQ, RESUME_REQ, RESUME_RES,
	RESUME_REJECT_REQ, REJECT_REQ, RELEASE_REQ, RELEASE_RES,
	RESET_REQ, RESET_RES, BLOCKING_REQ, BLOCKING_RES, UNBLOCKING_REQ,
	UNBLOCKING_RES, QUERY_REQ,
	QUERY_RES, STOP_REQ,
	CPC_OK_ACK, CPC_ERROR_ACK, CPC_INFO_ACK, CPC_BIND_ACK,
	CPC_OPTMGMT_ACK, CPC_ADDR_ACK, CPC_CALL_REATTEMPT_IND, CPC_SETUP_IND,
	CPC_MORE_INFO_IND, CPC_INFORMATION_IND, CPC_CONT_CHECK_IND,
	CPC_CONT_TEST_IND, CPC_CONT_REPORT_IND, CPC_SETUP_CON,
	CPC_PROCEEDING_IND, CPC_ALERTING_IND, CPC_PROGRESS_IND, CPC_IBI_IND,
	CPC_CONNECT_IND, CPC_SETUP_COMPLETE_IND, CPC_FORWXFER_IND,
	CPC_SUSPEND_IND, CPC_SUSPEND_CON, CPC_SUSPEND_REJECT_IND,
	CPC_RESUME_IND, CPC_RESUME_CON, CPC_RESUME_REJECT_IND, CPC_REJECT_IND,
	CPC_CALL_FAILURE_IND, CPC_RELEASE_IND, CPC_RELEASE_CON, CPC_RESET_IND,
	CPC_RESET_CON, CPC_BLOCKING_IND, CPC_BLOCKING_CON, CPC_UNBLOCKING_IND,
	CPC_UNBLOCKING_CON, CPC_QUERY_IND, CPC_QUERY_CON, CPC_STOP_IND,
	CPC_MAINT_IND, CPC_START_RESET_IND,
	MGM_OK_ACK, MGM_ERROR_ACK, MGM_INFO_ACK, MGM_BIND_ACK,
	MGM_OPTMGMT_ACK, MGM_ADDR_ACK, MGM_CALL_REATTEMPT_IND, MGM_SETUP_IND,
	MGM_MORE_INFO_IND, MGM_INFORMATION_IND, MGM_CONT_CHECK_IND,
	MGM_CONT_TEST_IND, MGM_CONT_REPORT_IND, MGM_SETUP_CON,
	MGM_PROCEEDING_IND, MGM_ALERTING_IND, MGM_PROGRESS_IND, MGM_IBI_IND,
	MGM_CONNECT_IND, MGM_SETUP_COMPLETE_IND, MGM_FORWXFER_IND,
	MGM_SUSPEND_IND, MGM_SUSPEND_CON, MGM_SUSPEND_REJECT_IND,
	MGM_RESUME_IND, MGM_RESUME_CON, MGM_RESUME_REJECT_IND, MGM_REJECT_IND,
	MGM_CALL_FAILURE_IND, MGM_RELEASE_IND, MGM_RELEASE_CON, MGM_RESET_IND,
	MGM_RESET_CON, MGM_BLOCKING_IND, MGM_BLOCKING_CON, MGM_UNBLOCKING_IND,
	MGM_UNBLOCKING_CON, MGM_QUERY_IND, MGM_QUERY_CON, MGM_STOP_IND,
	MGM_MAINT_IND, MGM_START_RESET_IND,
	IBI, RINGING, COMMUNICATION, TONE, LOOPBACK,
	NO_MSG
};

static const char *
scope_string(int s)
{
	switch (s) {
	case ISUP_SCOPE_CT:
		return ("ct");
	case ISUP_SCOPE_CG:
		return ("cg");
	case ISUP_SCOPE_TG:
		return ("tg");
	case ISUP_SCOPE_SR:
		return ("sr");
	case ISUP_SCOPE_SP:
		return ("sp");
	case ISUP_SCOPE_DF:
		return ("df");
	case ISUP_SCOPE_CIC:
		return ("cic");
	default:
		return ("??");
	}
}

const char *
event_string(int e)
{
	switch (e) {
	case IAM:
		return ("IAM");
	case SAM:
		return ("SAM");
	case INR:
		return ("INR");
	case INF:
		return ("INF");
	case COT:
		return ("COT");
	case ACM:
		return ("ACM");
	case CON:
		return ("CON");
	case FOT:
		return ("FOT");
	case ANM:
		return ("ANM");
	case REL:
		return ("REL");
	case SUS:
		return ("SUS");