test-x400p-perf.c

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

			case SDT_TXC_TRANSMISSION_REQUEST_IND:
				printf("SDT_TXC_TRANSMISSION_REQUEST_IND:\n");
				return;
			default:
				printf("Unrecognized response primitive %ld!\n",
				       (long) p->lmi_primitive);
				goto do_get_again;
			}
		}
	}
}

void
info_req(int fd)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union LMI_primitives *p = (union LMI_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->info_req);
	ctrl.buf = cbuf;
	p->lmi_primitive = LMI_INFO_REQ;
	printf("\nAttempting info request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	do_lmi_get_msg(fd);
}

void
attach_req(int fd, uint16_t ppa)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union LMI_primitives *p = (union LMI_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->attach_req) + sizeof(ppa);
	ctrl.buf = cbuf;
	p->attach_req.lmi_primitive = LMI_ATTACH_REQ;
	bcopy(&ppa, p->attach_req.lmi_ppa, sizeof(ppa));
	printf("\nAttempting attach request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	do_lmi_get_msg(fd);
}

void
detach_req(int fd)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union LMI_primitives *p = (union LMI_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->detach_req);
	ctrl.buf = cbuf;
	p->lmi_primitive = LMI_DETACH_REQ;
	printf("\nAttempting detach request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	do_lmi_get_msg(fd);
}

void
enable_req(int fd)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union LMI_primitives *p = (union LMI_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->enable_req);
	ctrl.buf = cbuf;
	p->lmi_primitive = LMI_ENABLE_REQ;
	printf("\nAttempting enable request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	do_lmi_get_msg(fd);
}

void
disable_req(int fd)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union LMI_primitives *p = (union LMI_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->disable_req);
	ctrl.buf = cbuf;
	p->lmi_primitive = LMI_DISABLE_REQ;
	printf("\nAttempting disable request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	do_lmi_get_msg(fd);
}

void
sdt_daedt_start(int fd)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union SDT_primitives *p = (union SDT_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->daedt_start_req);
	ctrl.buf = cbuf;
	p->sdt_primitive = SDT_DAEDT_START_REQ;
	printf("\nAttempting DAEDT start request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	// do_lmi_get_msg(fd);
}

void
sdt_daedr_start(int fd)
{
	int ret;
	struct strbuf ctrl;
	char cbuf[BUFSIZE];
	union SDT_primitives *p = (union SDT_primitives *) cbuf;
	ctrl.maxlen = BUFSIZE;
	ctrl.len = sizeof(p->daedr_start_req);
	ctrl.buf = cbuf;
	p->sdt_primitive = SDT_DAEDR_START_REQ;
	printf("\nAttempting DAEDR start request\n");
	if ((ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else
		printf("Putmsg succeeded!\n");
	// do_lmi_get_msg(fd);
}

void
sdt_write(int fd)
{

#if 0
	const size_t len = 13;
	const char buf[] = "Hello World!";
#else
#if 0
	const size_t len = 46;
	const char buf[] = "THE QUICK BROWN FOX JUMPED OVER THE LAZY DOGS";
#else
#if 0
	const size_t len = 46;
	const uint8_t buf[] = {
		0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f,
		0xff, 0xff, 0xfe, 0xfc, 0xfa, 0xf8, 0xf0, 0xe0,
		0xc0, 0xa0, 0x80, 0x00, 0x01, 0x03, 0x07, 0x0f,
		0x1f, 0x3f, 0x7f, 0xff, 0xff, 0xfe, 0xfc, 0xfa,
		0xf8, 0xf0, 0xe0, 0xc0, 0xa0, 0x80, 0x00, 0x01,
		0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f
	};
#else
	const size_t len = 80;
	const uint8_t buf[] = {
		0x7f, 0x7f, 0x3f, 0x01, 0x02, 0x03, 0x04, 0x05,
		0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
		0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
		0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
		0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
		0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
		0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
		0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d,
		0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
		0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d
	};
#endif
#endif
#endif
	// int i;
	int ret;
	// for (i = 0; i < 10; i++) {
	printf("\nAttempting write\n");
	ret = write(fd, buf, len);
	if (ret < 0) {
		printf("error = %d\n", errno);
		perror("test");
		exit(2);
	} else {
		int i;
		printf("Write succeeded, wrote %d bytes!\n", ret);
		printf("Message[%ld]: ", (long) len);
		for (i = 0; i < len; i++) {
			printf("%02X ", buf[i]);
		}
		printf("\n");
	}
	// }
}

void
sdt_read(int fd)
{
	uint8_t buf[256];
	int i, ret;
	i = 0;
	printf("\nAttempting read\n");
	for (;;) {
		ret = read(fd, buf, 256);
		if (ret < 0) {
			if (errno == EAGAIN) {
				if (i++ < 100)
					continue;
			}
			if (errno == EBADMSG) {
				do_lmi_get_msg(fd);
				continue;
			}
			printf("error = %d\n", errno);
			perror("test");
			break;
		} else
			printf("Read succeeded, read %d bytes!\n", ret);
		if (ret > 0) {
			int i;
			uint8_t *c = buf;
			printf("Message[%d]: ", ret);
			for (i = 0; i < ret; i++, c++) {
				printf("%02X ", *c);
			}
			printf("\n");
		}
	}
}

int
sdt_ioctl(int fd, int cmd, void *arg, int len)
{
	struct strioctl ctl = { cmd, 0, len, arg };
	int ret;
	ret = ioctl(fd, I_STR, &ctl);
	if (ret < 0) {
		printf("return = %d\n", ret);
		printf("error = %d\n", errno);
		perror("sdt_ioctl");
		exit(2);
	}
	return ctl.ic_len;
}

void
do_ioctl(int fd, int cmd, int arg)
{
	int ret;
	ret = ioctl(fd, cmd, arg);
	if (ret < 0) {
		printf("return = %d\n", ret);
		printf("error = %d\n", errno);
		perror("do_ioctl");
		exit(2);
	}
}

void
sdl_config(int fd)
{
	unsigned char buf[256];
	sdl_config_t *c = (sdl_config_t *) buf;
	sdl_statem_t *s = (sdl_statem_t *) buf;
	sdt_ioctl(fd, SDL_IOCGCONFIG, buf, sizeof(sdl_config_t));
	printf("Config:\n");
	printf("  ifflags       = %lu\n", c->ifflags);
	printf("  iftype        = %lu\n", c->iftype);
	printf("  ifrate        = %lu\n", c->ifrate);
	printf("  ifgtype       = %lu\n", c->ifgtype);
	printf("  ifgrate       = %lu\n", c->ifgrate);
	printf("  ifgcrc        = %lu\n", c->ifgcrc);
	printf("  ifmode        = %lu\n", c->ifmode);
	printf("  ifclock       = %lu\n", c->ifclock);
	printf("  ifcoding      = %lu\n", c->ifcoding);
	printf("  ifframing     = %lu\n", c->ifframing);
	printf("  ifleads       = %lu\n", c->ifleads);
	printf("  ifalarms      = %lu\n", c->ifalarms);
	printf("  ifrxlevel     = %lu\n", c->ifrxlevel);
	printf("  iftxlevel     = %lu\n", c->iftxlevel);
	printf("  ifsync        = %lu\n", c->ifsync);
	printf("  ifsyncsrc[0]  = %lu\n", c->ifsyncsrc[0]);
	printf("  ifsyncsrc[1]  = %lu\n", c->ifsyncsrc[1]);
	printf("  ifsyncsrc[2]  = %lu\n", c->ifsyncsrc[2]);
	printf("  ifsyncsrc[3]  = %lu\n", c->ifsyncsrc[3]);
	sdt_ioctl(fd, SDL_IOCGSTATEM, buf, sizeof(sdl_statem_t));
	printf("State:\n");
	printf("  tx_state      = %lu\n", s->tx_state);
	printf("  rx_state      = %lu\n", s->rx_state);
}

void
sdt_config(int fd)
{
	unsigned char buf[256];
	sdt_config_t *c = (sdt_config_t *) buf;
	sdt_statem_t *s = (sdt_statem_t *) buf;
	printf("Getting configuration\n");
	sdt_ioctl(fd, SDT_IOCGCONFIG, buf, sizeof(sdt_config_t));
	printf("Config:\n");
	printf("  t8  = %lu\n", c->t8);
	printf("  Tin = %lu\n", c->Tin);
	printf("  Tie = %lu\n", c->Tie);
	printf("  T   = %lu\n", c->T);
	printf("  D   = %lu\n", c->D);
	printf("  Te  = %lu\n", c->Te);
	printf("  De  = %lu\n", c->De);
	printf("  Ue  = %lu\n", c->Ue);
	printf("  N   = %lu\n", c->N);
	printf("  m   = %lu\n", c->m);
	printf("  b   = %lu\n", c->b);
	sdt_ioctl(fd, SDT_IOCGSTATEM, buf, sizeof(sdt_statem_t));
	printf("State:\n");
	printf("  aerm_state.. = %lu\n", s->aerm_state);
	printf("    aborted_proving.... = %lu\n", s->aborted_proving);
	printf("    Ca................. = %lu\n", s->Ca);
	printf("    Ti................. = %lu\n", s->Ti);
	printf("  suerm_state. = %lu\n", s->suerm_state);
	printf("    Cs................. = %lu\n", s->Cs);
	printf("    Ns................. = %lu\n", s->Ns);
	printf("  eim_state... = %lu\n", s->eim_state);
	printf("    Ce................. = %lu\n", s->Ce);
	printf("    su_received........ = %lu\n", s->su_received);
	printf("    interval_error..... = %lu\n", s->interval_error);
	printf("  daedt_state. = %lu\n", s->daedt_state);
	printf("  daedr_state. = %lu\n", s->daedr_state);
	printf("    octet_counting_mode = %lu\n", s->octet_counting_mode);
	sdl_config(fd);
}

void
sdl_stats(int fd)
{
	unsigned char buf[256];
	sdl_stats_t *s = (sdl_stats_t *) buf;
	printf("Attempting stats collection\n");
	sdt_ioctl(fd, SDL_IOCGSTATS, buf, sizeof(sdl_stats_t));
	printf("Stats:\n");
	printf("  rx_octets............ = %lu\n", s->rx_octets);
	printf("  tx_octets............ = %lu\n", s->tx_octets);
	printf("  rx_overruns.......... = %lu\n", s->rx_overruns);
	printf("  tx_underruns......... = %lu\n", s->tx_underruns);
	printf("  rx_buffer_overflows.. = %lu\n", s->rx_buffer_overflows);
	printf("  tx_buffer_overflows.. = %lu\n", s->tx_buffer_overflows);