test-q781-pipe.c

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

			printf("    FISU (%02x/%02x) (bad fib)------->\n", pt_bib | pt_bsn,
			       (pt_fib | pt_fsn) ^ 0x80);
			FFLUSH(stdout);
		}
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = (pt_fib | pt_fsn) ^ 0x80;
		pt_buf[2] = 0;
		len = 3;
		break;
	case LSSU_CORRUPT:
		if (!cntmsg || verbose) {
			printf("    LSSU (%02x/%02x) (corrupt)------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
	case LSSU_CORRUPT_S:
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		pt_buf[2] = 0xff;
		pt_buf[3] = 0xff;
		len = 4;
		break;
	case FISU_CORRUPT:
		if (!cntmsg || verbose) {
			printf("    FISU (%02x/%02x) (corrupt)------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
	case FISU_CORRUPT_S:
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		pt_buf[2] = 0xff;
		len = 3;
		break;
	case MSU:
		if (msu_len > BUFSIZE - 10)
			msu_len = BUFSIZE - 10;
		pt_fsn = (pt_fsn + 1) & 0x7f;
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		pt_buf[2] = msu_len;
		memset(&pt_buf[3], 'B', msu_len);
		len = msu_len + 3;
		if (!cntmsg || verbose) {
			printf("    MSU  (%02x/%02x) ---------------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		break;
	case MSU_TOO_LONG:
		pt_fsn = (pt_fsn + 1) & 0x7f;
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		pt_buf[2] = 63;
		memset(&pt_buf[3], 'A', 280);
		len = 283;
		if (!cntmsg || verbose) {
			printf("    MSU  (%02x/%02x) (too long)------>\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		break;
	case MSU_SEVEN_ONES:
		pt_fsn = (pt_fsn + 1) & 0x7f;
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		len = 2;
		if (!cntmsg || verbose) {
			printf("    MSU  (%02x/%02x) (7 ones)-------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		return FAILURE;	/* can't do this */
	case MSU_TOO_SHORT:
		pt_fsn = (pt_fsn + 1) & 0x7f;
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		len = 2;
		if (!cntmsg || verbose) {
			printf("    MSU  (%02x/%02x) (too short)----->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		break;
	case TX_BREAK:
		printf("   :break Tx\n");
		FFLUSH(stdout);
		return FAILURE;	/* can't do this */
		ioc.ic_cmd = DEV_IOCCDISCTX;
		ioc.ic_timout = 0;
		ioc.ic_len = 0;
		ioc.ic_dp = NULL;
		if (ioctl(pt_fd, I_STR, &ioc) < 0) {
			printf("    ****ERROR: ioctl failed!\n");
			printf("               %s: %s\n", __FUNCTION__, strerror(errno));
			return FAILURE;
		}
		return FAILURE;	/* can't do this */
	case TX_MAKE:
		printf("   :reconnect Tx\n");
		FFLUSH(stdout);
		return FAILURE;	/* can't do this */
		ioc.ic_cmd = DEV_IOCCCONNTX;
		ioc.ic_timout = 0;
		ioc.ic_len = 0;
		ioc.ic_dp = NULL;
		if (ioctl(pt_fd, I_STR, &ioc) < 0) {
			printf("    ****ERROR: ioctl failed!\n");
			printf("               %s: %s\n", __FUNCTION__, strerror(errno));
			return FAILURE;
		}
		return FAILURE;	/* can't do this */
	case FISU_FISU_1FLAG:
		printf("    FISU (%02x/%02x) ---FISU-F-FISU-->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		return FAILURE;	/* can't do this */
	case FISU_FISU_2FLAG:
		printf("    FISU (%02x/%02x) --FISU-F-F-FISU->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		return FAILURE;	/* can't do this */
	case MSU_MSU_1FLAG:
		printf("    MSU  (%02x/%02x) ----MSU-F-MSU--->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		return FAILURE;	/* can't do this */
	case MSU_MSU_2FLAG:
		printf("    MSU  (%02x/%02x) ---MSU-F-F-MSU-->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		return FAILURE;	/* can't do this */
	case POWER_ON:
		label = "power on";
		goto dummy_command;
	case START:
		label = "start";
		goto dummy_command;
	case STOP:
		label = "stop";
		goto dummy_command;
	case LPO:
		label = "set lpo";
		goto dummy_command;
	case LPR:
		label = "clear lpo";
		goto dummy_command;
	case EMERG:
		label = "set emerg";
		goto dummy_command;
	case CEASE:
		label = "clear emerg";
		goto dummy_command;
	case CONG_A:
		label = "make congestion state";
		goto dummy_command;
	case CONG_D:
		label = "make congestion state";
		goto dummy_command;
	case NO_CONG:
		label = "clear congestion state";
		goto dummy_command;
	      dummy_command:
		printf("   :%s\n", label);
		FFLUSH(stdout);
		return SUCCESS;
	default:
		if (!cntmsg || verbose) {
			printf("    ???? (--/--) ---------------->\n");
			FFLUSH(stdout);
		}
		return FAILURE;
	}
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->daedt_transmission_req);
	ctrl.buf = cbuf;
	data.maxlen = BUFSIZE;
	data.len = len;
	data.buf = (char *)pt_buf;
	p->daedt_transmission_req.sdt_primitive = SDT_DAEDT_TRANSMISSION_REQ;
	if (putmsg(pt_fd, NULL, &data, 0) < 0) {
		if (errno == EAGAIN || errno == EINTR)
			return FAILURE;
		printf("    ****ERROR: putmsg failed!\n");
		printf("               %s: %s\n", __FUNCTION__, strerror(errno));
		return FAILURE;
	}
	return ret;
}

#define signal iut_signal

static int
signal(int action)
{
	int ret;
	char cbuf[BUFSIZE];
	char dbuf[BUFSIZE];
	struct strbuf ctrl = { sizeof(*cbuf), 0, cbuf };
	struct strbuf data = { sizeof(*dbuf), 0, dbuf };
	union SL_primitives *p = (union SL_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.buf = cbuf;
	if (action != oldact) {
		oldact = action;
		// if ( cntact ) {
		// printf(" Ct=%d\n", cntact+1);
		// FFLUSH(stdout);
		// }
		cntact = 0;
	} else if (!expand)
		cntact++;
	switch (action) {
	case POWER_ON:
		printf("                                  :power on\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_POWER_ON_REQ;
		ctrl.len = SL_POWER_ON_REQ_SIZE;
		goto signal_iut_putmsg;
	case START:
		printf("                                  :start\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_START_REQ;
		ctrl.len = SL_START_REQ_SIZE;
		goto signal_iut_putmsg;
	case STOP:
		printf("                                  :stop\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_STOP_REQ;
		ctrl.len = SL_STOP_REQ_SIZE;
		goto signal_iut_putmsg;
	case LPO:
		printf("                                  :set lpo\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_LOCAL_PROCESSOR_OUTAGE_REQ;
		ctrl.len = SL_LOCAL_PROC_OUTAGE_REQ_SIZE;
		goto signal_iut_putmsg;
	case LPR:
		printf("                                  :clear lpo\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_RESUME_REQ;
		ctrl.len = SL_RESUME_REQ_SIZE;
		goto signal_iut_putmsg;
	case CONG_A:
		printf("                                  :make congestion state\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_CONGESTION_ACCEPT_REQ;
		ctrl.len = SL_CONG_ACCEPT_REQ_SIZE;
		goto signal_iut_putmsg;
	case CONG_D:
		printf("                                  :make congestion state\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_CONGESTION_DISCARD_REQ;
		ctrl.len = SL_CONG_DISCARD_REQ_SIZE;
		goto signal_iut_putmsg;
	case NO_CONG:
		printf("                                  :clear congestion state\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_NO_CONGESTION_REQ;
		ctrl.len = SL_NO_CONG_REQ_SIZE;
		goto signal_iut_putmsg;
	case CLEARB:
		printf("                                  :clear buffers\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_CLEAR_BUFFERS_REQ;
		ctrl.len = SL_CLEAR_BUFFERS_REQ_SIZE;
		goto signal_iut_putmsg;
	case EMERG:
		printf("                                  :set emerg\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_EMERGENCY_REQ;
		ctrl.len = SL_EMERGENCY_REQ_SIZE;
		goto signal_iut_putmsg;
	case CEASE:
		printf("                                  :clear emerg\n");
		FFLUSH(stdout);
		p->sl_primitive = SL_EMERGENCY_CEASES_REQ;
		ctrl.len = SL_EMERGENCY_CEASES_REQ_SIZE;
	      signal_iut_putmsg:
		if ((ret = putmsg(iut_fd, &ctrl, NULL, RS_HIPRI)) < 0) {
			printf("                                   ****ERROR: putmsg failed!\n");
			printf("                                              %s: %s\n",
			       __FUNCTION__, strerror(errno));
			return FAILURE;
		}
		return SUCCESS;
	case COUNT:
		printf("                                   Ct=%d\n", count);
		FFLUSH(stdout);
		return SUCCESS;
	case TRIES:
		printf("                                   %d iterations\n", tries);
		FFLUSH(stdout);
		return SUCCESS;
	case ETC:
		printf("                                     .\n");
		printf("                                     .\n");
		printf("                                     .\n");
		FFLUSH(stdout);
		return SUCCESS;
	case SEND_MSU:
		if (!cntact || verbose) {
			printf("                                  :msu\n");
			FFLUSH(stdout);
		}
	case SEND_MSU_S:
		if (msu_len > BUFSIZE - 10)
			msu_len = BUFSIZE - 10;
		p->sl_primitive = SL_PDU_REQ;
		p->pdu_req.sl_mp = 0;
		ctrl.len = SL_PDU_REQ_SIZE;
		memset(dbuf, 'B', msu_len);
		data.len = msu_len;
		if ((ret = putmsg(iut_fd, NULL, &data, 0)) < 0) {
			printf("                                   ****ERROR: putmsg failed!\n");
			printf("                                              %s: %s\n",
			       __FUNCTION__, strerror(errno));
			return FAILURE;
		}
		return SUCCESS;
	default:
		if (!cntact || verbose) {
			printf("                                  :????\n");
			FFLUSH(stdout);
		}
		return FAILURE;
	}
}

static int show_msus = 1;
static int show_fisus = 1;

static int
pt_decode_data(void)
{
	int ret;
	// printf("pt decode data:\n"); FFLUSH(stdout);
	// FFLUSH(stdout);
	iut_bib = pt_buf[0] & 0x80;
	iut_bsn = pt_buf[0] & 0x7f;
	iut_fib = pt_buf[1] & 0x80;
	iut_fsn = pt_buf[1] & 0x7f;
	iut_li = pt_buf[2] & 0x3f;
	iut_sio = pt_buf[3] & 0x7;
	pt_bsn = iut_fsn;
	switch (iut_li) {
	case 0:
		ret = FISU;
		break;
	case 1:
		ret = iut_sio = pt_buf[3] & 0x7;
		switch (iut_sio) {
		case SIO:
		case SIN:
		case SIE:
		case SIOS:
		case SIPO:
		case SIB:
			break;
		default:
			ret = SIX;
			break;
		}
		break;
	case 2:
		ret = iut_sio = pt_buf[4] & 0x7;
		switch (iut_sio) {
		case SIO:
		case SIN:
		case SIE:
		case SIOS:
		case SIPO:
		case SIB:
			break;
		default:
			ret = SIX2;
			break;
		}
		break;
	default:
		ret = MSU;
		break;
	}
	if (show_fisus || ret != FISU) {
		if (ret != oldret || oldisb != (((iut_bib | iut_bsn) << 8) | (iut_fib | iut_fsn))) {
			// if (oldisb == (((iut_bib | iut_bsn) << 8) | (iut_fib | iut_fsn)) &&
			// ((ret == FISU && oldret == MSU) || (ret == MSU && oldret == FISU))) {
			// if (ret == MSU && !expand)
			// cntmsg++;
			// } else
			// cntret = 0;
			oldret = ret;
			oldisb = ((iut_bib | iut_bsn) << 8) | (iut_fib | iut_fsn);
			// if (cntret) {
			// printf(" Ct=%d\n", cntret + 1);
			// FFLUSH(stdout);
			// }
			cntret = 0;
		} else if (!expand)
			cntret++;
	}
	if (!cntret || verbose) {
		char *label = NULL;
		switch (ret) {
		case FISU:
			if (show_fisus || verbose) {
				printf("                 <---------------- FISU (%02x/%02x)\n",
				       iut_bib | iut_bsn, iut_fib | iut_fsn);
				FFLUSH(stdout);
			}
			break;
		case SIO:
			label = "SIO ";
			goto show_lssu;
		case SIN:
			label = "SIN ";
			goto show_lssu;
		case SIE:
			label = "SIE ";
			goto show_lssu;
		case SIOS:
			label = "SIOS";
			goto show_lssu;
		case SIPO:
			label = "SIPO";
			goto show_lssu;
		case SIB:
			label = "SIB ";
		      show_lssu:
			switch (iut_li) {
			case 1:
				printf("                 <---------------- %s (%02x/%02x)\n", label,
				       iut_bib | iut_bsn, iut_fib | iut_fsn);
				break;
			case 2:
				printf("                 <---------------- %s (%02x/%02x)[%d]\n",
				       label, iut_bib | iut_bsn, iut_fib | iut_fsn, iut_li);
				break;
			}
			FFLUSH(stdout);
			break;
		case SIX:
			printf("                 <-------(corrupt) LSSU (%02x/%02x)[%d]\n",
			       iut_bib | iut_bsn, iut_fib | iut_fsn, iut_li);
			FFLUSH(stdout);
			break;
		case SIX2:
			printf("                 <-------(corrupt) LSSU (%02x/%02x)[%d]\n",
			       iut_bib | iut_bsn, iut_fib | iut_fsn, iut_li);
			FFLUSH(stdout);
			break;
		case MSU:
			if (show_msus || verbose) {
				printf("                 <---------------- MSU  (%02x/%02x)[%d]\n",
				       iut_bib | iut_bsn, iut_fib | iut_fsn, iut_len - 3);
				FFLUSH(stdout);
			}
			break;
		}
	}
	return ret;
}

static int
pt_decode_msg(unsigned char *buf)
{
	union SDT_primitives *p = (union SDT_primitives *) buf;
	if (verbose) {
		printf("pt decode msg:\n");
		FFLUSH(stdout);
		FFLUSH(stdout);
	}
	switch (p->sdt_primitive) {
	case SDT_RC_SIGNAL_UNIT_IND:
		return pt_decode_data();
	case SDT_IAC_CORRECT_SU_IND:
		printf("   !correct su\n");
		FFLUSH(stdout);
		break;
	case SDT_IAC_ABORT_PROVING_IND:
		printf("   !abort proving\n");
		FFLUSH(stdout);
		break;
	case SDT_LSC_LINK_FAILURE_IND:
		printf("   !link failure\n");
		FFLUSH(stdout);
		break;
	case SDT_TXC_TRANSMISSION_REQUEST_IND:
		if (verbose) {
			printf("   (tx wakeup)\n");
			FFLUSH(stdout);
		}
		break;
	case SDT_RC_CONGESTION_ACCEPT_IND:
		printf("   !congestion accept\n");
		FFLUSH(stdout);
		break;
	case SDT_RC_CONGESTION_DISCARD_IND:
		printf("   !congestion discard\n");
		FFLUSH(stdout);
		break;
	case SDT_RC_NO_CONGESTION_IND:
		printf("   !no congestion\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->sdt_primitive);
		FFLUSH(stdout);
		break;
	}
	return UNKNOWN;
}

static int
iut_decode_data(void)
{
	printf("                                  !msu [%d bytes]\n", iut_len);
	if (verbose) {
		int i;
		printf("                                 ");
		for (i = 0; i < iut_len; i++)
			printf(" %02x", iut_buf[i]);
		printf("\n");
	}
	FFLUSH(stdout);
	return IUT_MSU;
}

static int
iut_decode_msg(unsigned char *buf)
{
	char *reason;
	union SL_primitives *p = (union SL_primitives *) buf;
	if (p->sl_primitive != oldprm) {
		oldprm = p->sl_primitive;
		cntprm = 0;
	} else if (!expand)
		cntprm++;
	switch (p->sl_primitive) {
	case SL_REMOTE_PROCESSOR_OUTAGE_IND:
		if (!cntprm || verbose) {
			printf("                                  !rpo\n");
			FFLUSH(stdout);
		}
		return RPO;
	case SL_REMOTE_PROCESSOR_RECOVERED_IND:
		if (!cntprm || verbose) {
			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("                                  !pdu\n");
		printf("                                  !msu [%d bytes]\n", iut_len);
		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);