test-tirdwr.c

This a separate release of the OpenSS7 X/Open XTI/TLI library, TLI modules (timod, tirdwr) and the I

}

/*
 *  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;
	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;
}

/*
 *  -------------------------------------------------------------------------
 *
 *  Injected event encoding and display functions.
 *
 *  -------------------------------------------------------------------------
 */

static int
do_signal(int fd, int action)
{
	int flags = MSG_BAND, band = 0;
	struct strbuf ctrl_buf, data_buf, *ctrl = &ctrl_buf, *data = &data_buf;
	char cbuf[256], dbuf[256];
	union T_primitives *p = (typeof(p)) cbuf;
	struct strioctl ic;
	ic.ic_cmd = 0;
	ic.ic_timout = 200;
	ic.ic_len = sizeof(cbuf);
	ic.ic_dp = cbuf;
	ctrl->maxlen = 0;
	ctrl->buf = cbuf;
	data->maxlen = 0;
	data->buf = dbuf;
	if (fd == top_fd) {
		switch (action) {
		case __TEST_PUSH:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "---I_PUSH(tirdwr)-->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			if (ioctl(top_fd, I_PUSH, "tirdwr") < 0) {
				last_errno = errno;
				if (verbose) {
					lockf(fileno(stdout), F_LOCK, 0);
					fprintf(stdout, "***************ERROR: ioctl I_PUSH failed\n");
					fprintf(stdout, "                    : %s; %s\n", __FUNCTION__, strerror(last_errno));
					fflush(stdout);
					lockf(fileno(stdout), F_ULOCK, 0);
				}
				return (FAILURE);
			}
			return (SUCCESS);
		case __TEST_POP:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "---I_POP(tirdwr)--->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			if (ioctl(top_fd, I_POP, NULL) < 0) {
				last_errno = errno;
				if (verbose) {
					lockf(fileno(stdout), F_LOCK, 0);
					fprintf(stdout, "***************ERROR: ioctl I_POP failed\n");
					fprintf(stdout, "                    : %s; %s\n", __FUNCTION__, strerror(last_errno));
					fflush(stdout);
					lockf(fileno(stdout), F_ULOCK, 0);
				}
				return (FAILURE);
			}
			return (SUCCESS);
		case __TEST_WRITE:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--write(2)--------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			data->len = sprintf(dbuf, "Write test data.");
			if (write(top_fd, dbuf, data->len) < 0) {
				last_errno = errno;
				if (verbose) {
					lockf(fileno(stdout), F_LOCK, 0);
					fprintf(stdout, "***************ERROR: write failed\n");
					fprintf(stdout, "                    : %s; %s\n", __FUNCTION__, strerror(last_errno));
					fflush(stdout);
					lockf(fileno(stdout), F_ULOCK, 0);
				}
				return FAILURE;
			}
			return SUCCESS;
		case __TEST_WRITEV:
		{
			struct iovec vector[4];
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--writev(2)-------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			vector[0].iov_base = dbuf;
			vector[0].iov_len = sprintf(vector[0].iov_base, "Writev test datum for vector 0.");
			vector[1].iov_base = dbuf + vector[0].iov_len;
			vector[1].iov_len = sprintf(vector[1].iov_base, "Writev test datum for vector 1.");
			vector[2].iov_base = dbuf + vector[1].iov_len;
			vector[2].iov_len = sprintf(vector[2].iov_base, "Writev test datum for vector 2.");
			vector[3].iov_base = dbuf + vector[2].iov_len;
			vector[3].iov_len = sprintf(vector[3].iov_base, "Writev test datum for vector 3.");
			if (writev(top_fd, vector, 4) < 0) {
				last_errno = errno;
				if (verbose) {
					lockf(fileno(stdout), F_LOCK, 0);
					fprintf(stdout, "***************ERROR: writev failed\n");
					fprintf(stdout, "                    : %s; %s\n", __FUNCTION__, strerror(last_errno));
					fflush(stdout);
					lockf(fileno(stdout), F_ULOCK, 0);
				}
				return FAILURE;
			}
			return SUCCESS;
		}
		case __TEST_PUTMSG_DATA:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--putmsg(2)-------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl = NULL;
			data->len = sprintf(dbuf, "Putmsg test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_PUTPMSG_DATA:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--putpmsg(2)------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl = NULL;
			data->len = sprintf(dbuf, "Putpmsg band test data.");
			flags = MSG_BAND;
			band = 1;
			break;
		case __TEST_CONN_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_CONN_REQ------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->conn_req);
			data = NULL;
			p->conn_req.PRIM_type = T_CONN_REQ;
			p->conn_req.DEST_length = 0;
			p->conn_req.DEST_offset = 0;
			p->conn_req.OPT_length = 0;
			p->conn_req.OPT_offset = 0;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_CONN_RES:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_CONN_RES------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->conn_res);
			data = NULL;
			p->conn_res.PRIM_type = T_CONN_RES;
			p->conn_res.ACCEPTOR_id = 0;
			p->conn_res.OPT_length = 0;
			p->conn_res.OPT_offset = 0;
			p->conn_res.SEQ_number = 0;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_DISCON_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_DISCON_REQ----->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->discon_req);
			data = NULL;
			p->discon_req.PRIM_type = T_DISCON_REQ;
			p->discon_req.SEQ_number = 0;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_DATA_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_DATA_REQ------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->data_req);
			p->data_req.PRIM_type = T_DATA_REQ;
			p->data_req.MORE_flag = 0;
			data->len = sprintf(dbuf, "Normal test message.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_EXDATA_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_EXDATA_REQ----->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->exdata_req);
			p->exdata_req.PRIM_type = T_EXDATA_REQ;
			p->exdata_req.MORE_flag = 0;
			data->len = sprintf(dbuf, "Expedited test message.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_INFO_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_INFO_REQ------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->info_req);
			p->info_req.PRIM_type = T_INFO_REQ;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_BIND_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_BIND_REQ------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->bind_req);
			p->bind_req.PRIM_type = T_BIND_REQ;
			p->bind_req.ADDR_length = 0;
			p->bind_req.ADDR_offset = 0;
			p->bind_req.CONIND_number = 0;
			data = NULL;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_UNBIND_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_UNBIND_REQ----->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->unbind_req);
			p->unbind_req.PRIM_type = T_UNBIND_REQ;
			data = NULL;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_UNITDATA_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_UNITDATA_REQ--->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->unitdata_req);
			p->unitdata_req.PRIM_type = T_UNITDATA_REQ;
			p->unitdata_req.DEST_length = 0;
			p->unitdata_req.DEST_offset = 0;
			p->unitdata_req.OPT_length = 0;
			p->unitdata_req.OPT_offset = 0;
			data->len = sprintf(dbuf, "Unit test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_OPTMGMT_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_OPTMGMT_REQ---->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->optmgmt_req);
			p->optmgmt_req.PRIM_type = T_OPTMGMT_REQ;
			p->optmgmt_req.OPT_length = 0;
			p->optmgmt_req.OPT_offset = 0;
			p->optmgmt_req.MGMT_flags = T_NEGOTIATE;
			data = NULL;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_ORDREL_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_ORDREL_REQ----->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->ordrel_req);
			p->ordrel_req.PRIM_type = T_ORDREL_REQ;
			data->len = sprintf(dbuf, "Orderly release data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_OPTDATA_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_OPTDATA_REQ---->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->optdata_req);
			p->optdata_req.PRIM_type = T_OPTDATA_REQ;
			p->optdata_req.DATA_flag = T_ODF_EX | T_ODF_MORE;
			p->optdata_req.OPT_length = 0;
			p->optdata_req.OPT_offset = 0;
			data->len = sprintf(dbuf, "Option data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_ADDR_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_ADDR_REQ------->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->addr_req);
			p->addr_req.PRIM_type = T_ADDR_REQ;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_CAPABILITY_REQ:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--T_CAPABILITY_REQ->|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->capability_req);
			p->capability_req.PRIM_type = T_CAPABILITY_REQ;
			p->capability_req.CAP_bits1 = TC1_INFO | TC1_ACCEPTOR_ID;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_O_TI_GETINFO:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "--ioctl(2)--------->|  |  O_TI_GETINFO                 |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}