test-q781.c

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

		FFLUSH(stdout);
		break;
	default:
		printf("                                  !(unknown %ld)\n", (long)p->sl_primitive);
		FFLUSH(stdout);
		break;
	}
	return UNKNOWN;
}

static int show_timeout = 0;
static int pt_event = 0;

static int
time_event(int event)
{
	if (verbose) {
		unsigned long msec;
		struct timeval now;
		gettimeofday(&now, NULL);
		if (!test_start)
			test_start = now.tv_sec;
		msec = (now.tv_sec - test_start) * 1000;
		msec += (now.tv_usec + 500UL) / 1000;
		printf("time: %lu msec\n", msec);
		FFLUSH(stdout);
	}
	return (event);
}

static int
wait_event(int wait)
{
	while (1) {
		struct pollfd pfd[] = {
			{pt_fd, POLLIN | POLLPRI, 0},
			{iut_fd, POLLIN | POLLPRI, 0}
		};
		if (timer_timeout) {
			timer_timeout = 0;
			if (show_timeout || verbose) {
				printf("                 |----timeout----|\n");
				FFLUSH(stdout);
				show_timeout--;
			}
			pt_event = TIMEOUT;
			return time_event(TIMEOUT);
		}
		// printf("polling:\n");
		// FFLUSH(stdout);
		pfd[0].fd = pt_fd;
		pfd[0].events =
		    POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND | POLLMSG | POLLERR | POLLHUP;
		pfd[0].revents = 0;
		pfd[1].fd = iut_fd;
		pfd[1].events =
		    POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND | POLLMSG | POLLERR | POLLHUP;
		pfd[1].revents = 0;
		switch (poll(pfd, 2, wait)) {
		case -1:
			// printf(" = = = ERROR = = =\n");
			// FFLUSH(stdout);
			break;
		case 0:
			// printf(" < + + + + + + + + (nothing)\n");
			// FFLUSH(stdout);
			pt_event = NO_MSG;
			return time_event(NO_MSG);
		case 1:
		case 2:
			// printf("polled:\n");
			// FFLUSH(stdout);
			if (pfd[0].revents) {
				int flags = 0;
				char cbuf[BUFSIZE];
				struct strbuf ctrl = { BUFSIZE, 0, cbuf };
				struct strbuf data = { BUFSIZE, 0, 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;
					if (ctrl.len > 0) {
						if ((pt_event = pt_decode_msg(ctrl.buf)) != UNKNOWN)
							return time_event(pt_event);
					} else if (data.len > 0) {
						if ((pt_event = pt_decode_data()) != UNKNOWN)
							return time_event(pt_event);
					}
				}
			}
			if (pfd[1].revents) {
				int flags = 0;
				char cbuf[BUFSIZE];
				struct strbuf ctrl = { BUFSIZE, 0, cbuf };
				struct strbuf data = { BUFSIZE, 0, 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) {
						if ((pt_event =
						     iut_decode_msg(ctrl.buf)) != UNKNOWN)
							return time_event(pt_event);
					} else if (data.len > 0) {
						if ((pt_event = iut_decode_data()) != UNKNOWN)
							return time_event(pt_event);
					}
				}
			}
		default:
			break;
		}
	}
}

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

#if 0
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()) {
			case SIOS:
				return check_snibs(0xff, 0xff);
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

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

static int
test_1_2(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch (event()) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 1:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIOS);
				start_tt(iutconf.sl.t2 * 10 + 200);
				beg_time = milliseconds("T2");
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch (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);
			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()) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 2;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 2:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				state = 3;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 3:
			switch (event()) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIO);
				start_tt(iutconf.sl.t3 * 10 + 200);
				beg_time = milliseconds("T3");
				state = 4;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 4:
			switch (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);
			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()) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 2;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 2:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 10 + 200);
				beg_time = milliseconds("T4(Pn)");
				state = 3;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 3:
			switch (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))
					return FAILURE;
				send(SIN);
				start_tt(iutconf.sl.t1 * 10 + 200);
				beg_time = milliseconds("T1");
				state = 4;
				break;
			default:
				return FAILURE;
			}
			break;
		case 4:
			switch (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);
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_5a(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch (event()) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				return FAILURE;
			}
			break;
		case 1:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 10 + 200);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch (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()) {
			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()) {
			case SIOS:
				send(SIOS2);
				signal(START);
				state = 1;
				break;
			default:
				return FAILURE;
			}
			break;
		case 1:
			switch (event()) {
			case SIOS:
				send(SIOS2);
				break;
			case SIO:
				send(SIO2);
				start_tt(iutconf.sl.t4n * 10 + 200);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch (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()) {
			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()) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				return INCONCLUSIVE;
			}
			break;
		case 1:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 10 + 200);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch (event()) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIN);
				break;
			case FISU:
				send(MSU);
				start_tt(1000);
				state = 3;
				break;
			default:
				return FAILURE;
			}
			break;
		case 3:
			switch (event()) {
			case IN_SERVICE:
			case IUT_MSU:
			case FISU:
			case TIMEOUT:
				return SUCCESS;
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_7(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch (event()) {
			case SIOS:
				send(SIOS);
				signal(START);
				state = 1;
				break;
			default:
				return FAILURE;
			}
			break;
		case 1:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 10 / 2);
				show_timeout = 1;
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch (event()) {
			case SIO:
				send(SIO);
				break;
			case SIN:
				send(SIN);
				break;
			case TIMEOUT:
				start_tt(iutconf.sl.t4n * 10 + 200);
				send(SIO);
				send(SIN);
				beg_time = milliseconds("T4(Pn)");
				state = 3;
				break;
			default:
				return FAILURE;
			}
			break;
		case 3:
			switch (event()) {
			case SIN:
				send(SIN);
				break;
			case FISU:
				return check_time("T4  ", beg_time, timer[t4n].lo, timer[t4n].hi);
			default:
				return FAILURE;
			}
			break;
		default:
			return SCRIPTERROR;
		}
	}
}

static int
test_1_8a(void)
{
	for (;;) {
		switch (state) {
		case 0:
			switch (event()) {
			case SIOS:
				send(SIOS);
				signal(LPO);
				signal(START);
				state = 1;
				break;
			default:
				return FAILURE;
			}
			break;
		case 1:
			switch (event()) {
			case SIOS:
				send(SIOS);
				break;
			case SIO:
				send(SIO);
				start_tt(iutconf.sl.t4n * 10 + 200);
				state = 2;
				break;
			default:
				return FAILURE;
			}
			break;
		case 2:
			switch (event()) {
			case IN_SERVICE:
			case RPR:
				break;
			case SIO:
				send(SIO);
			case SIN:
				send(SIN);
				break;
			case SIPO:
				send(FISU);
				start_tt(1000);
				state = 3;
				break;
			default:
				return FAILURE;
			}
			break;
		case 3:
			switch (event()) {
			case IN_SERVICE:
			case RPR: