test-m2pa.c

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

		return ("NO_CONG");
	case __TEST_CLEARB:
		return ("CLEARB");
	}
	return ("(unexpected)");
}

const char *
ioctl_string(int cmd, intptr_t arg)
{
	switch (cmd) {
	case I_NREAD:
		return ("I_NREAD");
	case I_PUSH:
		return ("I_PUSH");
	case I_POP:
		return ("I_POP");
	case I_LOOK:
		return ("I_LOOK");
	case I_FLUSH:
		return ("I_FLUSH");
	case I_SRDOPT:
		return ("I_SRDOPT");
	case I_GRDOPT:
		return ("I_GRDOPT");
	case I_STR:
		if (arg) {
			struct strioctl *icp = (struct strioctl *) arg;

			switch (icp->ic_cmd) {
#if 0
			case _O_TI_BIND:
				return ("_O_TI_BIND");
			case O_TI_BIND:
				return ("O_TI_BIND");
			case _O_TI_GETINFO:
				return ("_O_TI_GETINFO");
			case O_TI_GETINFO:
				return ("O_TI_GETINFO");
			case _O_TI_GETMYNAME:
				return ("_O_TI_GETMYNAME");
			case _O_TI_GETPEERNAME:
				return ("_O_TI_GETPEERNAME");
			case _O_TI_OPTMGMT:
				return ("_O_TI_OPTMGMT");
			case O_TI_OPTMGMT:
				return ("O_TI_OPTMGMT");
			case _O_TI_TLI_MODE:
				return ("_O_TI_TLI_MODE");
			case _O_TI_UNBIND:
				return ("_O_TI_UNBIND");
			case O_TI_UNBIND:
				return ("O_TI_UNBIND");
			case _O_TI_XTI_CLEAR_EVENT:
				return ("_O_TI_XTI_CLEAR_EVENT");
			case _O_TI_XTI_GET_STATE:
				return ("_O_TI_XTI_GET_STATE");
			case _O_TI_XTI_HELLO:
				return ("_O_TI_XTI_HELLO");
			case _O_TI_XTI_MODE:
				return ("_O_TI_XTI_MODE");
			case TI_BIND:
				return ("TI_BIND");
			case TI_CAPABILITY:
				return ("TI_CAPABILITY");
			case TI_GETADDRS:
				return ("TI_GETADDRS");
			case TI_GETINFO:
				return ("TI_GETINFO");
			case TI_GETMYNAME:
				return ("TI_GETMYNAME");
			case TI_GETPEERNAME:
				return ("TI_GETPEERNAME");
			case TI_OPTMGMT:
				return ("TI_OPTMGMT");
			case TI_SETMYNAME:
				return ("TI_SETMYNAME");
			case TI_SETPEERNAME:
				return ("TI_SETPEERNAME");
			case TI_SYNC:
				return ("TI_SYNC");
			case TI_UNBIND:
				return ("TI_UNBIND");
#endif
			}
		}
		return ("I_STR");
	case I_SETSIG:
		return ("I_SETSIG");
	case I_GETSIG:
		return ("I_GETSIG");
	case I_FIND:
		return ("I_FIND");
	case I_LINK:
		return ("I_LINK");
	case I_UNLINK:
		return ("I_UNLINK");
	case I_RECVFD:
		return ("I_RECVFD");
	case I_PEEK:
		return ("I_PEEK");
	case I_FDINSERT:
		return ("I_FDINSERT");
	case I_SENDFD:
		return ("I_SENDFD");
#if 0
	case I_E_RECVFD:
		return ("I_E_RECVFD");
#endif
	case I_SWROPT:
		return ("I_SWROPT");
	case I_GWROPT:
		return ("I_GWROPT");
	case I_LIST:
		return ("I_LIST");
	case I_PLINK:
		return ("I_PLINK");
	case I_PUNLINK:
		return ("I_PUNLINK");
	case I_FLUSHBAND:
		return ("I_FLUSHBAND");
	case I_CKBAND:
		return ("I_CKBAND");
	case I_GETBAND:
		return ("I_GETBAND");
	case I_ATMARK:
		return ("I_ATMARK");
	case I_SETCLTIME:
		return ("I_SETCLTIME");
	case I_GETCLTIME:
		return ("I_GETCLTIME");
	case I_CANPUT:
		return ("I_CANPUT");
#if 0
	case I_SERROPT:
		return ("I_SERROPT");
	case I_GERROPT:
		return ("I_GERROPT");
	case I_ANCHOR:
		return ("I_ANCHOR");
#endif
#if 0
	case I_S_RECVFD:
		return ("I_S_RECVFD");
	case I_STATS:
		return ("I_STATS");
	case I_BIGPIPE:
		return ("I_BIGPIPE");
#endif
#if 0
	case I_GETTP:
		return ("I_GETTP");
	case I_AUTOPUSH:
		return ("I_AUTOPUSH");
	case I_HEAP_REPORT:
		return ("I_HEAP_REPORT");
	case I_FIFO:
		return ("I_FIFO");
	case I_PUTPMSG:
		return ("I_PUTPMSG");
	case I_GETPMSG:
		return ("I_GETPMSG");
	case I_FATTACH:
		return ("I_FATTACH");
	case I_FDETACH:
		return ("I_FDETACH");
	case I_PIPE:
		return ("I_PIPE");
#endif
	default:
		return ("(unexpected)");
	}
}

const char *
signal_string(int signum)
{
	switch (signum) {
	case SIGHUP:
		return ("SIGHUP");
	case SIGINT:
		return ("SIGINT");
	case SIGQUIT:
		return ("SIGQUIT");
	case SIGILL:
		return ("SIGILL");
	case SIGABRT:
		return ("SIGABRT");
	case SIGFPE:
		return ("SIGFPE");
	case SIGKILL:
		return ("SIGKILL");
	case SIGSEGV:
		return ("SIGSEGV");
	case SIGPIPE:
		return ("SIGPIPE");
	case SIGALRM:
		return ("SIGALRM");
	case SIGTERM:
		return ("SIGTERM");
	case SIGUSR1:
		return ("SIGUSR1");
	case SIGUSR2:
		return ("SIGUSR2");
	case SIGCHLD:
		return ("SIGCHLD");
	case SIGCONT:
		return ("SIGCONT");
	case SIGSTOP:
		return ("SIGSTOP");
	case SIGTSTP:
		return ("SIGTSTP");
	case SIGTTIN:
		return ("SIGTTIN");
	case SIGTTOU:
		return ("SIGTTOU");
	case SIGBUS:
		return ("SIGBUS");
	case SIGPOLL:
		return ("SIGPOLL");
	case SIGPROF:
		return ("SIGPROF");
	case SIGSYS:
		return ("SIGSYS");
	case SIGTRAP:
		return ("SIGTRAP");
	case SIGURG:
		return ("SIGURG");
	case SIGVTALRM:
		return ("SIGVTALRM");
	case SIGXCPU:
		return ("SIGXCPU");
	case SIGXFSZ:
		return ("SIGXFSZ");
	default:
		return ("unknown");
	}
}

const char *
poll_string(short events)
{
	if (events & POLLIN)
		return ("POLLIN");
	if (events & POLLPRI)
		return ("POLLPRI");
	if (events & POLLOUT)
		return ("POLLOUT");
	if (events & POLLRDNORM)
		return ("POLLRDNORM");
	if (events & POLLRDBAND)
		return ("POLLRDBAND");
	if (events & POLLWRNORM)
		return ("POLLWRNORM");
	if (events & POLLWRBAND)
		return ("POLLWRBAND");
	if (events & POLLERR)
		return ("POLLERR");
	if (events & POLLHUP)
		return ("POLLHUP");
	if (events & POLLNVAL)
		return ("POLLNVAL");
	if (events & POLLMSG)
		return ("POLLMSG");
	return ("none");
}

const char *
poll_events_string(short events)
{
	static char string[256] = "";
	int offset = 0, size = 256, len = 0;

	if (events & POLLIN) {
		len = snprintf(string + offset, size, "POLLIN|");
		offset += len;
		size -= len;
	}
	if (events & POLLPRI) {
		len = snprintf(string + offset, size, "POLLPRI|");
		offset += len;
		size -= len;
	}
	if (events & POLLOUT) {
		len = snprintf(string + offset, size, "POLLOUT|");
		offset += len;
		size -= len;
	}
	if (events & POLLRDNORM) {
		len = snprintf(string + offset, size, "POLLRDNORM|");
		offset += len;
		size -= len;
	}
	if (events & POLLRDBAND) {
		len = snprintf(string + offset, size, "POLLRDBAND|");
		offset += len;
		size -= len;
	}
	if (events & POLLWRNORM) {
		len = snprintf(string + offset, size, "POLLWRNORM|");
		offset += len;
		size -= len;
	}
	if (events & POLLWRBAND) {
		len = snprintf(string + offset, size, "POLLWRBAND|");
		offset += len;
		size -= len;
	}
	if (events & POLLERR) {
		len = snprintf(string + offset, size, "POLLERR|");
		offset += len;
		size -= len;
	}
	if (events & POLLHUP) {
		len = snprintf(string + offset, size, "POLLHUP|");
		offset += len;
		size -= len;
	}
	if (events & POLLNVAL) {
		len = snprintf(string + offset, size, "POLLNVAL|");
		offset += len;
		size -= len;
	}
	if (events & POLLMSG) {
		len = snprintf(string + offset, size, "POLLMSG|");
		offset += len;
		size -= len;
	}
	return (string);
}

#if TEST_M2UA
const char *
service_type(t_uscalar_t type)
{
	switch (type) {
	case T_CLTS:
		return ("T_CLTS");
	case T_COTS:
		return ("T_COTS");
	case T_COTS_ORD:
		return ("T_COTS_ORD");
	default:
		return ("(unknown)");
	}
}

const char *
state_string(t_uscalar_t state)
{
	switch (state) {
	case TS_UNBND:
		return ("TS_UNBND");
	case TS_WACK_BREQ:
		return ("TS_WACK_BREQ");
	case TS_WACK_UREQ:
		return ("TS_WACK_UREQ");
	case TS_IDLE:
		return ("TS_IDLE");
	case TS_WACK_OPTREQ:
		return ("TS_WACK_OPTREQ");
	case TS_WACK_CREQ:
		return ("TS_WACK_CREQ");
	case TS_WCON_CREQ:
		return ("TS_WCON_CREQ");
	case TS_WRES_CIND:
		return ("TS_WRES_CIND");
	case TS_WACK_CRES:
		return ("TS_WACK_CRES");
	case TS_DATA_XFER:
		return ("TS_DATA_XFER");
	case TS_WIND_ORDREL:
		return ("TS_WIND_ORDREL");
	case TS_WREQ_ORDREL:
		return ("TS_WRES_ORDREL");
	case TS_WACK_DREQ6:
		return ("TS_WACK_DREQ6");
	case TS_WACK_DREQ7:
		return ("TS_WACK_DREQ7");
	case TS_WACK_DREQ9:
		return ("TS_WACK_DREQ9");
	case TS_WACK_DREQ10:
		return ("TS_WACK_DREQ10");
	case TS_WACK_DREQ11:
		return ("TS_WACK_DREQ11");
	default:
		return ("(unknown)");
	}
}
#endif				/* TEST_M2UA */

#if TEST_X400
void print_string(int child, const char *string);
void
print_ppa(int child, ppa_t * ppa)
{
	char buf[32];

	snprintf(buf, sizeof(buf), "%d:%d:%d", ((*ppa) >> 12) & 0x0f, ((*ppa) >> 8) & 0x0f, (*ppa) & 0x0ff);
	print_string(child, buf);
}
#endif				/* TEST_X400 */
void print_string_val(int child, const char *string, ulong val);
void
print_sdl_stats(int child, sdl_stats_t * s)
{
	if (s->rx_octets)
		print_string_val(child, "rx_octets", s->rx_octets);
	if (s->tx_octets)
		print_string_val(child, "tx_octets", s->tx_octets);
	if (s->rx_overruns)
		print_string_val(child, "rx_overruns", s->rx_overruns);
	if (s->tx_underruns)
		print_string_val(child, "tx_underruns", s->tx_underruns);
	if (s->rx_buffer_overflows)
		print_string_val(child, "rx_buffer_overflows", s->rx_buffer_overflows);
	if (s->tx_buffer_overflows)
		print_string_val(child, "tx_buffer_overflows", s->tx_buffer_overflows);
	if (s->lead_cts_lost)
		print_string_val(child, "lead_cts_lost", s->lead_cts_lost);
	if (s->lead_dcd_lost)
		print_string_val(child, "lead_dcd_lost", s->lead_dcd_lost);
	if (s->carrier_lost)
		print_string_val(child, "carrier_lost", s->carrier_lost);
}

void
print_sdt_stats(int child, sdt_stats_t * s)
{
	if (s->tx_bytes)
		print_string_val(child, "tx_bytes", s->tx_bytes);
	if (s->tx_sus)
		print_string_val(child, "tx_sus", s->tx_sus);
	if (s->tx_sus_repeated)
		print_string_val(child, "tx_sus_repeated", s->tx_sus_repeated);
	if (s->tx_underruns)
		print_string_val(child, "tx_underruns", s->tx_underruns);
	if (s->tx_aborts)
		print_string_val(child, "tx_aborts", s->tx_aborts);
	if (s->tx_buffer_overflows)
		print_string_val(child, "tx_buffer_overflows", s->tx_buffer_overflows);
	if (s->tx_sus_in_error)
		print_string_val(child, "tx_sus_in_error", s->tx_sus_in_error);
	if (s->rx_bytes)
		print_string_val(child, "rx_bytes", s->rx_bytes);
	if (s->rx_sus)
		print_string_val(child, "rx_sus", s->rx_sus);
	if (s->rx_sus_compressed)
		print_string_val(child, "rx_sus_compressed", s->rx_sus_compressed);
	if (s->rx_overruns)
		print_string_val(child, "rx_overruns", s->rx_overruns);
	if (s->rx_aborts)
		print_string_val(child, "rx_aborts", s->rx_aborts);
	if (s->rx_buffer_overflows)
		print_string_val(child, "rx_buffer_overflows", s->rx_buffer_overflows);
	if (s->rx_sus_in_error)
		print_string_val(child, "rx_sus_in_error", s->rx_sus_in_error);
	if (s->rx_sync_transitions)
		print_string_val(child, "rx_sync_transitions", s->rx_sync_transitions);
	if (s->rx_bits_octet_counted)
		print_string_val(child, "rx_bits_octet_counted", s->rx_bits_octet_counted);
	if (s->rx_crc_errors)
		print_string_val(child, "rx_crc_errors", s->rx_crc_errors);
	if (s->rx_frame_errors)
		print_string_val(child, "rx_frame_errors", s->rx_frame_errors);
	if (s->rx_frame_overflows)
		print_string_val(child, "rx_frame_overflows", s->rx_frame_overflows);
	if (s->rx_frame_too_long)
		print_string_val(child, "rx_frame_too_long", s->rx_frame_too_long);
	if (s->rx_frame_too_short)
		print_string_val(child, "rx_frame_too_short", s->rx_frame_too_short);
	if (s->rx_residue_errors)
		print_string_val(child, "rx_residue_errors", s->rx_residue_errors);
	if (s->rx_length_error)
		print_string_val(child, "rx_length_error", s->rx_length_error);
	if (s->carrier_cts_lost)
		print_string_val(child, "carrier_cts_lost", s->carrier_cts_lost);
	if (s->carrier_dcd_lost)
		print_string_val(child, "carrier_dcd_lost", s->carrier_dcd_lost);
	if (s->carrier_lost)
		print_string_val(child, "carrier_lost", s->carrier_lost);
}

void
print_sl_stats(int child, sl_stats_t * s)
{
	if (s->sl_dur_in_service)
		print_string_val(child, "sl_dur_in_service", s->sl_dur_in_service);
	if (s->sl_fail_align_or_proving)
		print_string_val(child, "sl_fail_align_or_proving", s->sl_fail_align_or_proving);
	if (s->sl_nacks_received)
		print_string_val(child, "sl_nacks_received", s->sl_nacks_received);
	if (s->sl_dur_unavail)
		print_string_val