test-timod.c

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

			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 (verbose > 3) {
			lockf(fileno(stdout), F_LOCK, 0);
			fprintf(stdout, "putpmsg to bot: [%d,%d]\n", ctrl ? ctrl->len : -1, data ? data->len : -1);
			lockf(fileno(stdout), F_ULOCK, 0);
			fflush(stdout);
		}
		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 ((last_prim = 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);
			}
			ret = __TEST_DATA_IND;
			break;
		case T_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);
			}
			ret = __TEST_EXDATA_IND;
			break;
		case T_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);
			}
			ret = __TEST_INFO_ACK;
			break;
		case T_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);
			}
			ret = __TEST_BIND_ACK;
			break;
		case T_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);
			}
			ret = __TEST_ERROR_ACK;
			break;
		case T_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);
			}
			ret = __TEST_OK_ACK;
			break;
		case T_UNITDATA_IND:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_UNITDATA_REQ----|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ret = __TEST_UNITDATA_IND;
			break;
		case T_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);
			}
			ret = __TEST_UDERROR_IND;
			break;
		case T_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);
			}
			ret = __TEST_OPTMGMT_ACK;
			break;
		case T_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);
			}
			ret = __TEST_ORDREL_IND;
			break;
		case T_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);
			}
			if (p->optdata_ind.DATA_flag & T_ODF_EX)
				ret = __TEST_EXP_OPTDATA_IND;
			else
				ret = __TEST_NRM_OPTDATA_IND;
			break;
		case T_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);
			}
			ret = __TEST_ADDR_ACK;
			break;
		case T_CAPABILITY_ACK:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_CPABILITY_ACK---|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ret = __TEST_CAPABILITY_ACK;
			break;
		default:
			if (verbose) {
				lockf(fileno(stdout), F_LOCK, 0);
				fprintf(stdout, "<-T_????_???--------|  |                               |                    [%d]\n", state);
				fflush(stdout);
				lockf(fileno(stdout), F_ULOCK, 0);
			}
			ret = DECODEERROR;
			break;
		}
		if (data && data->len >= 0)
			if (do_decode_data(fd, data) != __TEST_DATA)
				return (FAILURE);
		return (ret);
	}
	if (fd == bot_fd) {
		switch ((last_prim = p->type)) {
		case T_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);
			}
			ret = __TEST_CONN_REQ;
			break;
		case T_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);
			}
			ret = __TEST_CONN_RES;
			break;
		case T_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);
			}
			ret = __TEST_DISCON_REQ;
			break;
		case T_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);
			}
			ret = __TEST_DATA_REQ;
			break;
		case T_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);
			}
			ret = __TEST_EXDATA_REQ;
			break;
		case T_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);
			}
			ret = __TEST_INFO_REQ;
			break;
		case T_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);
			}
			ret = __TEST_BIND_REQ;
			break;
		case T_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);
			}
			ret = __TEST_UNBIND_REQ;
			break;
		case T_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);
			}
			ret = __TEST_UNITDATA_REQ;
			break;
		case T_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);
			}
			ret = __TEST_OPTMGMT_REQ;
			break;
		case T_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);
			}
			ret = __T