test-x400p-cap2.c

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

		cntprm++;
	switch (p->sl_primitive) {
	case SL_REMOTE_PROCESSOR_OUTAGE_IND:
		if (!cntprm) {
			printf("                                  !rpo\n");
			FFLUSH(stdout);
		}
		return RPO;
	case SL_REMOTE_PROCESSOR_RECOVERED_IND:
		if (!cntprm) {
			printf("                                  !rpr\n");
			FFLUSH(stdout);
		}
		return RPR;
	case SL_IN_SERVICE_IND:
		printf("                                  !in service\n");
		FFLUSH(stdout);
		return IN_SERVICE;
	case SL_OUT_OF_SERVICE_IND:
		switch (p->out_of_service_ind.sl_reason) {
		case SL_FAIL_UNSPECIFIED:
			reason = "unspec";
			break;
		case SL_FAIL_CONG_TIMEOUT:
			reason = "T6";
			break;
		case SL_FAIL_ACK_TIMEOUT:
			reason = "T7";
			break;
		case SL_FAIL_ABNORMAL_BSNR:
			reason = "BSNR";
			break;
		case SL_FAIL_ABNORMAL_FIBR:
			reason = "FIBR";
			break;
		case SL_FAIL_SUERM_EIM:
			reason = "SUERM";
			break;
		case SL_FAIL_ALIGNMENT_NOT_POSSIBLE:
			reason = "AERM";
			break;
		case SL_FAIL_RECEIVED_SIO:
			reason = "SIO";
			break;
		case SL_FAIL_RECEIVED_SIN:
			reason = "SIN";
			break;
		case SL_FAIL_RECEIVED_SIE:
			reason = "SIE";
			break;
		case SL_FAIL_RECEIVED_SIOS:
			reason = "SIOS";
			break;
		case SL_FAIL_T1_TIMEOUT:
			reason = "T1";
			break;
		default:
			reason = "???";
			break;
		}
		printf("                                  !out of service (%s)\n", reason);
		FFLUSH(stdout);
		return OUT_OF_SERVICE;
	case SL_PDU_IND:
		printf("                                  !msu\n");
		FFLUSH(stdout);
		break;
	case SL_LINK_CONGESTED_IND:
		printf("                                  !congested\n");
		FFLUSH(stdout);
		break;
	case SL_LINK_CONGESTION_CEASED_IND:
		printf("                                  !congestion ceased\n");
		FFLUSH(stdout);
		break;
	case SL_RETRIEVED_MESSAGE_IND:
		printf("                                  !retrieved msg\n");
		FFLUSH(stdout);
		break;
	case SL_RETRIEVAL_COMPLETE_IND:
		printf("                                  !retrieval complete\n");
		FFLUSH(stdout);
		break;
	case SL_RB_CLEARED_IND:
		printf("                                  !rb cleared\n");
		FFLUSH(stdout);
		break;
	case SL_BSNT_IND:
		printf("                                  !bsnt\n");
		FFLUSH(stdout);
		break;
	case SL_RTB_CLEARED_IND:
		printf("                                  !rtb cleared\n");
		FFLUSH(stdout);
		break;
	case LMI_INFO_ACK:
		printf("                                  !(info ack)\n");
		FFLUSH(stdout);
		break;
	case LMI_OK_ACK:
		printf("                                  !(ok ack)\n");
		FFLUSH(stdout);
		break;
	case LMI_ERROR_ACK:
		printf("                                  !(error ack)\n");
		FFLUSH(stdout);
		break;
	case LMI_ENABLE_CON:
		printf("                                  !(enable con)\n");
		FFLUSH(stdout);
		break;
	case LMI_DISABLE_CON:
		// printf(" !(disable con)\n");
		// FFLUSH(stdout);
		break;
	case LMI_ERROR_IND:
		printf("                                  !(error ind)\n");
		FFLUSH(stdout);
		break;
	case LMI_STATS_IND:
		printf("                                  !(stats ind)\n");
		FFLUSH(stdout);
		break;
	case LMI_EVENT_IND:
		printf("                                  !(event ind)\n");
		FFLUSH(stdout);
		break;
	default:
		printf("                                  !(unknown %ld)\n", p->sl_primitive);
		FFLUSH(stdout);
		break;
	}
	return UNKNOWN;
}

static int show_timeout = 0;

static int
wait_event(int wait)
{
	int ret = SUCCESS;
	while (1) {
		struct pollfd pfd[] = {
			{pt_fd, POLLIN | POLLPRI, 0},
			{iut_fd, POLLIN | POLLPRI, 0}
		};
		if (timer_timeout) {
			timer_timeout = 0;
			if (show_timeout) {
				printf("                 |----timeout----|\n");
				FFLUSH(stdout);
				show_timeout--;
			}
			return TIMEOUT;
		}
		// printf("polling:\n");
		// FFLUSH(stdout);
		switch (poll(pfd, 2, wait)) {
		case -1:
			// printf(" = = = ERROR = = =\n");
			// FFLUSH(stdout);
			break;
		case 0:
			// printf(" < + + + + + + + + (nothing)\n");
			// FFLUSH(stdout);
			return NO_MSG;
		case 1:
		case 2:
			// printf("polled:\n");
			// FFLUSH(stdout);
			if (pfd[0].revents & (POLLIN | POLLPRI)) {
				int flags = 0;
				unsigned char cbuf[BUFSIZE];
				struct strbuf ctrl = { BUFSIZE, 0, (char *)cbuf }, data = {
				BUFSIZE, 0, (char *)pt_buf};
				// printf("getmsg from pt:\n");
				// FFLUSH(stdout);
				if (getmsg(pt_fd, &ctrl, &data, &flags) == 0) {
					// printf("gotmsg from pt [%d,%d]:\n",ctrl.len,data.len);
					// FFLUSH(stdout);
					if (data.len > 0)
						iut_len = data.len;	/* iut_len??? */
					if (ctrl.len > 0
					    && (ret = pt_decode_msg((unsigned char *)ctrl.buf)) != UNKNOWN)
						return ret;
					if (data.len > 0 && (ret = pt_decode_data()) != UNKNOWN)
						return ret;
				}
			}
			if (pfd[1].revents & (POLLIN | POLLPRI)) {
				int flags = 0;
				unsigned char cbuf[BUFSIZE];
				struct strbuf ctrl = { BUFSIZE, 0, (char *)cbuf }, data = {
				BUFSIZE, 0, (char *)iut_buf};
				// printf("getmsg from iut:\n");
				// FFLUSH(stdout);
				if (getmsg(iut_fd, &ctrl, &data, &flags) == 0) {
					// printf("gotmsg from iut [%d,%d]:\n",ctrl.len,data.len);
					// FFLUSH(stdout);
					if (data.len > 0)
						iut_len = data.len;
					if (ctrl.len > 0
					    && (ret = iut_decode_msg((unsigned char *)ctrl.buf)) != UNKNOWN)
						return ret;
					if (data.len > 0 && (ret = iut_decode_data()) != UNKNOWN)
						return ret;
				}
			}
		default:
			break;
		}
	}
}

static int
get_event(void)
{
	return wait_event(-1);
}

static int
check_snibs(unsigned char bsnib, unsigned char fsnib)
{
	int ret = FAILURE;
	if ((iut_bib | iut_bsn) == bsnib && (iut_fib | iut_fsn) == fsnib)
		ret = SUCCESS;
	printf("                 check b/f sn/ib:  ---> (%02x/%02x)\n", bsnib, fsnib);
	FFLUSH(stdout);
	return ret;
}

static int
test_1_1a(void)
{
	for (;;) {
		switch (state) {
		case 0:
			send(SIOS);
			signal(POWER_ON);
			state = 1;
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				return check_snibs(0xff, 0xff);
			default:
				break;
			case TIMEOUT:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_1b(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch ((event = get_event())) {
			case SIOS:
				send(POWER_ON);
				send(SIOS);
				return check_snibs(0xff, 0xff);
			default:
				break;
			case TIMEOUT:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_2(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				break;
			case TIMEOUT:
				return INCONCLUSIVE;
			}
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIOS);
				start_tt(iutconf.sl.t2 * 20);
				beg_time = milliseconds("T2", iutconf.sl.t2);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch ((event = get_event())) {
			case OUT_OF_SERVICE:
				break;
			case SIO:
				send(SIOS);
				break;
			case SIOS:
				return check_time("T2  ", beg_time, timer[t2].lo, timer[t2].hi,
						  100);
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_3(void)
{
	for (;;) {
		switch (state) {
		case 0:
			state = 1;
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 2;
				break;
			default:
				break;
			case TIMEOUT:
				return INCONCLUSIVE;
			}
			break;
		case 2:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				state = 3;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 3:
			switch ((event = get_event())) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIO);
				start_tt(iutconf.sl.t3 * 20);
				beg_time = milliseconds("T3", iutconf.sl.t3);
				state = 4;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 4:
			switch ((event = get_event())) {
			case SIN:
				send(SIO);
				break;
			case OUT_OF_SERVICE:
				break;
			case SIOS:
				return check_time("T3  ", beg_time, timer[t3].lo, timer[t3].hi,
						  100);
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_4(void)
{
	for (;;) {
		switch (state) {
		case 0:
			state = 1;
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 2;
				break;
			default:
				break;
			case TIMEOUT:
				return INCONCLUSIVE;
			}
			break;
		case 2:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 20);
				beg_time = milliseconds("T4(Pn)", iutconf.sl.t4n);
				state = 3;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 3:
			switch ((event = get_event())) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIN);
				break;
			case FISU:
				if (check_time("T4  ", beg_time, timer[t4n].lo, timer[t4n].hi, 200))
					return FAILURE;
				send(SIN);
				start_tt(iutconf.sl.t1 * 20);
				beg_time = milliseconds("T1", iutconf.sl.t1);
				state = 4;
				break;
			default:
				return FAILURE;
			}
			break;
		case 4:
			switch ((event = get_event())) {
			case FISU:
				send(SIN);
				break;
			case OUT_OF_SERVICE:
				break;
			case SIOS:
				return check_time("T1  ", beg_time, timer[t1].lo, timer[t1].hi,
						  100);
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_5a(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				break;
			case TIMEOUT:
				return FAILURE;
			}
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 20);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch ((event = get_event())) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIN);
				break;
			case FISU:
				send(FISU);
				start_tt(1000);
				state = 3;
				break;
			default:
				return FAILURE;
			}
			break;
		case 3:
			switch ((event = get_event())) {
			case IN_SERVICE:
				break;
			case FISU:
				send(FISU);
				break;
			case TIMEOUT:
				return SUCCESS;
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_5b(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS2);
				signal(START);
				state = 1;
				break;
			default:
				break;
			case TIMEOUT:
				return FAILURE;
			}
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS2);
				break;
			case SIO:
				send(SIO2);
				start_tt(iutconf.sl.t4n * 20);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch ((event = get_event())) {
			case SIO:
				send(SIO2);
				break;
			case SIN:
				send(SIN2);
				break;
			case FISU:
				send(FISU);
				start_tt(1000);
				state = 3;
				break;
			default:
				return FAILURE;
			}
			break;
		case 3:
			switch ((event = get_event())) {
			case IN_SERVICE:
				break;
			case FISU:
				send(FISU);
				break;
			case TIMEOUT:
				return SUCCESS;
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_6(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				break;
			case TIMEOUT:
				return INCONCLUSIVE;
			}
			break;
		case 1:
			switch ((event = get_event())) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 20);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch ((event = get_event())) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIN);
				break;
			case FISU:
				send(MSU);
				start_tt(1000);
				state = 3;
				break;