test-x400p-cap2.c

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

				       pt_fib | pt_fsn);
			break;
		case SIN2:
			if (!cntmsg)
				printf("    SIN  (%02x/%02x)[2]-------------->\n", pt_bib | pt_bsn,
				       pt_fib | pt_fsn);
			break;
		case SIE2:
			if (!cntmsg)
				printf("    SIE  (%02x/%02x)[2]-------------->\n", pt_bib | pt_bsn,
				       pt_fib | pt_fsn);
			break;
		case SIOS2:
			if (!cntmsg)
				printf("    SIOS (%02x/%02x)[2]-------------->\n", pt_bib | pt_bsn,
				       pt_fib | pt_fsn);
			break;
		case SIPO2:
			if (!cntmsg)
				printf("    SIPO (%02x/%02x)[2]-------------->\n", pt_bib | pt_bsn,
				       pt_fib | pt_fsn);
			break;
		case SIB2:
			if (!cntmsg)
				printf("    SIB  (%02x/%02x)[2]-------------->\n", pt_bib | pt_bsn,
				       pt_fib | pt_fsn);
			break;
		case SIX2:
			if (!cntmsg)
				printf("    LSSU (%02x/%02x)[2](corrupt)----->\n", pt_bib | pt_bsn,
				       pt_fib | pt_fsn);
			break;
		}
		FFLUSH(stdout);
		break;
	case SIB_S:
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		pt_buf[2] = 1;
		pt_buf[3] = SIB;
		len = 4;
		break;
	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 FISU:
		if (!cntmsg) {
			printf("    FISU (%02x/%02x) ---------------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
	case FISU_S:
		pt_buf[0] = pt_bib | pt_bsn;
		pt_buf[1] = pt_fib | pt_fsn;
		pt_buf[2] = 0;
		len = 3;
		break;
	case FISU_BAD_FIB:
		if (!cntmsg) {
			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) {
			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) {
			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) {
			printf("    MSU  (%02x/%02x) ---------------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		break;
	case MSU_S:
		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;
		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) {
			printf("    MSU  (%02x/%02x) (too long)------>\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		break;
	case MSU_SEVEN_ONES:
		msu_len = 256;
		pt_fsn = (pt_fsn + 1) & 0x7f;
		if (!cntmsg) {
			printf("    MSU  (%02x/%02x) (7 ones)-------->\n", pt_bib | pt_bsn,
			       pt_fib | pt_fsn);
			FFLUSH(stdout);
		}
		pt_fsn = (pt_fsn - 1) & 0x7f;
		{
			struct strioctl ctl;
			ctl.ic_cmd = SDT_IOCCABORT;
			ctl.ic_timout = 0;
			ctl.ic_len = 0;
			ctl.ic_dp = NULL;
			send(MSU_S);
			if (ioctl(pt_fd, I_STR, &ctl) < 0)
				return INCONCLUSIVE;
		}
		return SUCCESS;
	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) {
			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);
		ioc.ic_cmd = SDL_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 SUCCESS;
	case TX_MAKE:
		printf("   :reconnect Tx\n");
		FFLUSH(stdout);
		ioc.ic_cmd = SDL_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 SUCCESS;
	case FISU_FISU_1FLAG:
		printf("    FISU (%02x/%02x) ---FISU-F-FISU-->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		send(FISU_S);
		send(FISU_S);
		return SUCCESS;
	case FISU_FISU_2FLAG:
		printf("    FISU (%02x/%02x) --FISU-F-F-FISU->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		pt_flags = SDT_FLAGS_TWO;
		if (pt_config() != SUCCESS)
			return INCONCLUSIVE;
		send(FISU_S);
		send(FISU_S);
		pt_flags = SDT_FLAGS_ONE;
		if (pt_config() != SUCCESS)
			return INCONCLUSIVE;
		return SUCCESS;
	case MSU_MSU_1FLAG:
		printf("    MSU  (%02x/%02x) ----MSU-F-MSU--->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		send(MSU_S);
		send(MSU_S);
		return SUCCESS;
	case MSU_MSU_2FLAG:
		printf("    MSU  (%02x/%02x) ---MSU-F-F-MSU-->\n", pt_bib | pt_bsn,
		       pt_fib | pt_fsn);
		FFLUSH(stdout);
		pt_flags = SDT_FLAGS_TWO;
		if (pt_config() != SUCCESS)
			return INCONCLUSIVE;
		send(MSU_S);
		send(MSU_S);
		pt_flags = SDT_FLAGS_ONE;
		if (pt_config() != SUCCESS)
			return INCONCLUSIVE;
		return SUCCESS;
	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) {
			printf("    ???? (--/--) ---------------->\n");
			FFLUSH(stdout);
		}
		return FAILURE;
	}
	for (;;) {
		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) {
				printf("    ****ERROR: putmsg failed!\n");
				printf("               %s: %s\n", __FUNCTION__, strerror(errno));
				return FAILURE;
			}
			continue;
		}
		break;
	}
	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) {
			printf("                                  :msu\n");
			FFLUSH(stdout);
		}
	case SEND_MSU_S:
		if (msu_len > BUFSIZE - 10)
			msu_len = BUFSIZE - 10;
		p->sl_primitive = SL_PDU_REQ;
		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) {
			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) {
		char *label = NULL;
		switch (ret) {
		case FISU:
			if (show_fisus) {
				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) {
				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;
	// 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:
		// printf(" (tx wakeup)\n");
		// FFLUSH(stdout);
		break;
	case SDT_RC_CONGESTION_ACCEPT_IND:
	case SDT_RC_CONGESTION_DISCARD_IND:
	case SDT_RC_NO_CONGESTION_IND:
		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\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)