test-tirdwr.c

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

			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_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_CONN_IND------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->conn_ind);
			p->conn_ind.PRIM_type = T_CONN_IND;
			p->conn_ind.SRC_length = 0;
			p->conn_ind.SRC_offset = 0;
			p->conn_ind.OPT_length = 0;
			p->conn_ind.OPT_offset = 0;
			p->conn_ind.SEQ_number = 0;
			data->len = sprintf(dbuf, "Connection indication test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_CONN_CON:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_CONN_CON------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->conn_con);
			p->conn_con.PRIM_type = T_CONN_CON;
			p->conn_con.RES_length = 0;
			p->conn_con.RES_offset = 0;
			p->conn_con.OPT_length = 0;
			p->conn_con.OPT_offset = 0;
			data->len = sprintf(dbuf, "Connection confirmation test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_DISCON_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_DISCON_IND----- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->discon_ind);
			p->discon_ind.PRIM_type = T_DISCON_IND;
			p->discon_ind.DISCON_reason = 0;
			p->discon_ind.SEQ_number = 0;
			data->len = sprintf(dbuf, "Disconnection indication test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_DATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_DATA_IND------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->data_ind);
			p->data_ind.PRIM_type = T_DATA_IND;
			p->data_ind.MORE_flag = 0;
			data->len = sprintf(dbuf, "Normal test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_EXDATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_EXDATA_IND----- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->exdata_ind);
			p->data_ind.PRIM_type = T_EXDATA_IND;
			p->data_ind.MORE_flag = 0;
			data->len = sprintf(dbuf, "Expedited test data.");
			flags = MSG_BAND;
			band = 1;
			break;
		case __TEST_INFO_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_INFO_ACK------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->info_ack);
			p->info_ack.PRIM_type = T_INFO_ACK;
			p->info_ack.TSDU_size = 0;
			p->info_ack.ETSDU_size = 0;
			p->info_ack.CDATA_size = 0;
			p->info_ack.DDATA_size = 0;
			p->info_ack.ADDR_size = 0;
			p->info_ack.OPT_size = 0;
			p->info_ack.TIDU_size = 0;
			p->info_ack.SERV_type = 0;
			p->info_ack.CURRENT_state = 0;
			p->info_ack.PROVIDER_flag = 0;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_BIND_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_BIND_ACK------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->bind_ack);
			p->bind_ack.PRIM_type = T_BIND_ACK;
			p->bind_ack.ADDR_length = 0;
			p->bind_ack.ADDR_offset = 0;
			p->bind_ack.CONIND_number = 0;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_ERROR_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_ERROR_ACK------ (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->error_ack);
			p->error_ack.PRIM_type = T_ERROR_ACK;
			p->error_ack.ERROR_prim = 0;
			p->error_ack.TLI_error = 0;
			p->error_ack.UNIX_error = 0;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_OK_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_OK_ACK--------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->ok_ack);
			p->ok_ack.PRIM_type = T_OK_ACK;
			p->ok_ack.CORRECT_prim = 0;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_UNITDATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_UNIDATA_IND---- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->unitdata_ind);
			p->unitdata_ind.PRIM_type = T_UNITDATA_IND;
			p->unitdata_ind.SRC_length = 0;
			p->unitdata_ind.SRC_offset = 0;
			p->unitdata_ind.OPT_length = 0;
			p->unitdata_ind.OPT_offset = 0;
			data->len = sprintf(dbuf, "Unit test data indication.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_UDERROR_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_UDERROR_IND---- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->uderror_ind);
			p->uderror_ind.PRIM_type = T_UDERROR_IND;
			p->uderror_ind.DEST_length = 0;
			p->uderror_ind.DEST_offset = 0;
			p->uderror_ind.OPT_length = 0;
			p->uderror_ind.OPT_offset = 0;
			p->uderror_ind.ERROR_type = 0;
			data = NULL;
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_OPTMGMT_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_OPTMGMT_ACK---- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->optmgmt_ack);
			p->optmgmt_ack.PRIM_type = T_OPTMGMT_ACK;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_ORDREL_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_ORDREL_IND----- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->ordrel_ind);
			p->ordrel_ind.PRIM_type = T_ORDREL_IND;
			data->len = sprintf(dbuf, "Orderly release indication test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_EXP_OPTDATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_OPTDATA_IND---- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->optdata_ind);
			p->optdata_ind.PRIM_type = T_OPTDATA_IND;
			p->optdata_ind.DATA_flag = T_ODF_EX;
			p->optdata_ind.OPT_length = 0;
			p->optdata_ind.OPT_offset = 0;
			data->len = sprintf(dbuf, "Option data indication test data.");
			flags = MSG_BAND;
			band = 1;
			break;
		case __TEST_NRM_OPTDATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_OPTDATA_IND---- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->optdata_ind);
			p->optdata_ind.PRIM_type = T_OPTDATA_IND;
			p->optdata_ind.DATA_flag = 0;
			p->optdata_ind.OPT_length = 0;
			p->optdata_ind.OPT_offset = 0;
			data->len = sprintf(dbuf, "Option data indication test data.");
			flags = MSG_BAND;
			band = 0;
			break;
		case __TEST_ADDR_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_ADDR_ACK------- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->addr_ack);
			p->addr_ack.PRIM_type = T_ADDR_ACK;
			p->addr_ack.LOCADDR_length = 0;
			p->addr_ack.LOCADDR_offset = 0;
			p->addr_ack.REMADDR_length = 0;
			p->addr_ack.REMADDR_offset = 0;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		case __TEST_CAPABILITY_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                    |  |< - - - - - - - - - - - - - - -|<-T_CAPABILITY_ACK- (%d)\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ctrl->len = sizeof(p->capability_ack);
			p->capability_ack.PRIM_type = T_CAPABILITY_ACK;
			p->capability_ack.CAP_bits1 = TC1_INFO | TC1_ACCEPTOR_ID;
			p->capability_ack.INFO_ack.TSDU_size = 0;
			p->capability_ack.INFO_ack.ETSDU_size = 0;
			p->capability_ack.INFO_ack.CDATA_size = 0;
			p->capability_ack.INFO_ack.DDATA_size = 0;
			p->capability_ack.INFO_ack.ADDR_size = 0;
			p->capability_ack.INFO_ack.OPT_size = 0;
			p->capability_ack.INFO_ack.TIDU_size = 0;
			p->capability_ack.INFO_ack.SERV_type = 0;
			p->capability_ack.INFO_ack.CURRENT_state = 0;
			p->capability_ack.INFO_ack.PROVIDER_flag = 0;
			p->capability_ack.ACCEPTOR_id = 0;
			data = NULL;
			flags = MSG_HIPRI;
			band = 0;
			break;
		default:
			return SCRIPTERROR;
		}
		if (putpmsg(bot_fd, ctrl, data, band, flags) < 0) {
			last_errno = errno;
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "                                              ****ERROR: putpmsg failed\n");
				fprintf(stdout, "                                              ****ERROR: %s; %s\n", __FUNCTION__, strerror(last_errno));
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			return FAILURE;
		}
		return SUCCESS;
	}
	return SCRIPTERROR;
}

static int
top_signal(int action)
{
	return do_signal(top_fd, action);
}

static int
bot_signal(int action)
{
	return do_signal(bot_fd, action);
}

/*
 *  -------------------------------------------------------------------------
 *
 *  Received event decoding and display functions.
 *
 *  -------------------------------------------------------------------------
 */

static int
do_decode_data(int fd, struct strbuf *data)
{
	if (fd == top_fd) {
		if (verbose) {
			lockf(fileno(stdout), F_LOCK, 0);
			fprintf(stdout, "<-DATA--------------|  |                               |                    [%d]\n", state);
			fflush(stdout);
			lockf(fileno(stdout), F_ULOCK, 0);
		}
		return (__TEST_DATA);
	}
	if (fd == bot_fd) {
		if (verbose) {
			lockf(fileno(stdout), F_LOCK, 0);
			fprintf(stdout, "                    |  |- - - - - - - - - - - - - - - >|--DATA------------> (%d)\n", state);
			fflush(stdout);
			lockf(fileno(stdout), F_ULOCK, 0);
		}
		return (__TEST_DATA);
	}
	return (DECODEERROR);
}
static int
do_decode_ctrl(int fd, struct strbuf *ctrl, struct strbuf *data)
{
	int ret;
	union T_primitives *p = (union T_primitives *) ctrl->buf;
	if (fd == top_fd) {
		switch (p->type) {
		case T_CONN_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_CONN_IND--------|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ret = __TEST_CONN_IND;
			break;
		case T_CONN_CON:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_CONN_CON--------|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ret = __TEST_CONN_CON;
			break;
		case T_DISCON_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_DISCON_IND------|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ret = __TEST_DISCON_IND;
			break;
		case T_DATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_DATA_IND--------|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);