test-inet_raw.c

7号信令功能代码,为开源代码

}

int
inet_optmgmt_req(int fd, ulong flags)
{
	data.len = 0;
	ctrl.len = sizeof(cmd.tpi.optmgmt_req) + sizeof(opt_optm);
	cmd.tpi.type = T_OPTMGMT_REQ;
	cmd.tpi.optmgmt_req.MGMT_flags = flags;
	cmd.tpi.optmgmt_req.OPT_length = sizeof(opt_optm);
	cmd.tpi.optmgmt_req.OPT_offset = sizeof(cmd.tpi.optmgmt_req);
	bcopy(&opt_optm, (cmd.cbuf + sizeof(cmd.tpi.optmgmt_req)), sizeof(opt_optm));
	return put_msg(fd, 0, MSG_BAND, 0);
}

int
inet_bind_req(int fd, struct sockaddr_in *addr, int coninds)
{
	data.len = 0;
	ctrl.len = sizeof(cmd.tpi.bind_req) + sizeof(*addr);
	cmd.tpi.type = T_BIND_REQ;
	cmd.tpi.bind_req.ADDR_length = sizeof(*addr);
	cmd.tpi.bind_req.ADDR_offset = sizeof(cmd.tpi.bind_req);
	cmd.tpi.bind_req.CONIND_number = coninds;
	bcopy(addr, (&cmd.tpi.bind_req) + 1, sizeof(*addr));
	return put_msg(fd, 0, MSG_BAND, 0);
}

int
inet_unbind_req(int fd)
{
	data.len = 0;
	ctrl.len = sizeof(cmd.tpi.unbind_req);
	cmd.tpi.type = T_UNBIND_REQ;
	return put_msg(fd, 0, MSG_BAND, 0);
}

int
inet_unitdata_req(int fd, struct sockaddr_in *addr, const char *dat, size_t len, int wait)
{
	int ret;
	if (!dat)
		return (FAILURE);
	else {
		data.maxlen = len;
		data.len = len;
		data.buf = (char *) dat;
	}
	ctrl.len = sizeof(cmd.tpi.unitdata_req) + sizeof(*addr) + sizeof(opt_data);
	cmd.tpi.type = T_UNITDATA_REQ;
	cmd.tpi.unitdata_req.DEST_length = sizeof(*addr);
	cmd.tpi.unitdata_req.DEST_offset = sizeof(cmd.tpi.unitdata_req);
	cmd.tpi.unitdata_req.OPT_length = sizeof(opt_data);
	cmd.tpi.unitdata_req.OPT_offset = sizeof(cmd.tpi.unitdata_req) + sizeof(*addr);
	bcopy(addr, (cmd.cbuf + sizeof(cmd.tpi.unitdata_req)), sizeof(*addr));
	bcopy(&opt_data, (cmd.cbuf + sizeof(cmd.tpi.unitdata_req) + sizeof(*addr)),
	      sizeof(opt_data));
	ret = put_msg(fd, 0, MSG_BAND, wait);
	data.maxlen = BUFSIZE;
	data.len = 0;
	data.buf = dbuf;
	return (ret);
}

int
inet_conn_req(int fd, struct sockaddr_in *addr, const char *dat)
{
	if (!dat)
		data.len = 0;
	else {
		data.len = strlen(dat) + 1;
		strncpy(dbuf, dat, BUFSIZE);
	}
	ctrl.len = sizeof(cmd.tpi.conn_req) + sizeof(*addr) + sizeof(opt_conn);
	cmd.tpi.type = T_CONN_REQ;
	cmd.tpi.conn_req.DEST_length = sizeof(*addr);
	cmd.tpi.conn_req.DEST_offset = sizeof(cmd.tpi.conn_req);
	cmd.tpi.conn_req.OPT_length = sizeof(opt_conn);
	cmd.tpi.conn_req.OPT_offset = sizeof(cmd.tpi.conn_req) + sizeof(*addr);
	bcopy(addr, (cmd.cbuf + sizeof(cmd.tpi.conn_req)), sizeof(*addr));
	bcopy(&opt_conn, (cmd.cbuf + sizeof(cmd.tpi.conn_req) + sizeof(*addr)), sizeof(opt_conn));
	return put_msg(fd, 0, MSG_BAND, 0);
}

int
inet_conn_res(int fd, int fd2, const char *dat)
{
	if (!dat)
		fdi.databuf.len = 0;
	else {
		fdi.databuf.len = strlen(dat) + 1;
		strncpy(dbuf, dat, BUFSIZE);
	}
	fdi.ctlbuf.len = sizeof(cmd.tpi.conn_res);
	cmd.tpi.type = T_CONN_RES;
	cmd.tpi.conn_res.ACCEPTOR_id = 0;
	cmd.tpi.conn_res.SEQ_number = seq[fd];
	cmd.tpi.conn_res.OPT_offset = 0;
	cmd.tpi.conn_res.OPT_length = 0;
	return put_fdi(fd, fd2, 4, 0);
}

int
inet_discon_req(int fd, ulong seq)
{
	data.len = 0;
	ctrl.len = sizeof(cmd.tpi.discon_req);
	cmd.tpi.type = T_DISCON_REQ;
	cmd.tpi.discon_req.SEQ_number = seq;
	return put_msg(fd, 0, MSG_BAND, 0);
}

int
inet_ordrel_req(int fd)
{
	data.len = 0;
	ctrl.len = sizeof(cmd.tpi.ordrel_req);
	cmd.tpi.type = T_ORDREL_REQ;
	return put_msg(fd, 0, MSG_BAND, 0);
}

int
inet_ndata_req(int fd, ulong flags, const char *dat, size_t len, int wait)
{
	int ret;
	if (!dat)
		return (FAILURE);
	else {
		data.maxlen = len;
		data.len = len;
		data.buf = (char *) dat;
	}
	ctrl.len = sizeof(cmd.tpi.data_req);
	cmd.tpi.type = T_DATA_REQ;
	cmd.tpi.data_req.MORE_flag = flags & T_MORE;
	ret = put_msg(fd, 0, MSG_BAND, wait);
	data.maxlen = BUFSIZE;
	data.len = 0;
	data.buf = dbuf;
	return (ret);
}

int
inet_data_req(int fd, ulong flags, const char *dat, int wait)
{
	if (!dat)
		return (FAILURE);
	else {
		data.len = strlen(dat) + 1;
		strncpy(dbuf, dat, BUFSIZE);
	}
	ctrl.len = sizeof(cmd.tpi.data_req);
	cmd.tpi.type = T_DATA_REQ;
	cmd.tpi.data_req.MORE_flag = flags & T_MORE;
	return put_msg(fd, 0, MSG_BAND, wait);
}

int
inet_exdata_req(int fd, ulong flags, const char *dat)
{
	if (!dat)
		return (FAILURE);
	else {
		data.len = strlen(dat) + 1;
		strncpy(dbuf, dat, BUFSIZE);
	}
	ctrl.len = sizeof(cmd.tpi.exdata_req);
	cmd.tpi.type = T_EXDATA_REQ;
	cmd.tpi.exdata_req.MORE_flag = flags & T_MORE;
	return put_msg(fd, 1, MSG_BAND, 0);
}

int
inet_optdata_req(int fd, ulong flags, const char *dat, int wait)
{
	if (!dat)
		return (FAILURE);
	else {
		data.len = strlen(dat) + 1;
		strncpy(dbuf, dat, BUFSIZE);
	}
	ctrl.len = sizeof(cmd.tpi.optdata_req) + sizeof(opt_data);
	cmd.tpi.type = T_OPTDATA_REQ;
	cmd.tpi.optdata_req.DATA_flag = flags;
	cmd.tpi.optdata_req.OPT_length = sizeof(opt_data);
	cmd.tpi.optdata_req.OPT_offset = sizeof(cmd.tpi.optdata_req);
	bcopy(&opt_data, cmd.cbuf + sizeof(cmd.tpi.optdata_req), sizeof(opt_data));
	return put_msg(fd, flags & T_ODF_EX ? 1 : 0, MSG_BAND, wait);
}

int
inet_wait(int fd, int wait)
{
	return get_msg(fd, wait);
}

void
inet_sleep(unsigned long t)
{
	switch (show) {
	case 1:
		printf
		    ("/ / / / / / / / / / / / / / Waiting %04lu seconds / / / / / / / / / / / / / /\n",
		     t);
		break;
	case 2:
		printf("Waiting for %lu seconds...\n", t);
		break;
	}
	sleep(t);
	if (show == 2)
		printf(" ...done\n");
}

int
begin_tests(void)
{
	addr1.sin_family = AF_INET;
	addr1.sin_port = htons(port1);
	inet_aton("127.0.0.1", &addr1.sin_addr);

	addr2.sin_family = AF_INET;
	addr2.sin_port = htons(port2);
	inet_aton("127.0.0.2", &addr2.sin_addr);

	addr3.sin_family = AF_INET;
	addr3.sin_port = htons(port3);
	inet_aton("127.0.0.3", &addr3.sin_addr);

	state = 0;

	return (SUCCESS);
}

int
end_tests(void)
{
	return (SUCCESS);
}

int
preamble_X(void)
{
	return (SUCCESS);
}

int
postamble_X(void)
{
	return (SUCCESS);
}

int
preamble_0(void)
{
	if ((fd1 = inet_open(device)) < 0)
		return (FAILURE);
	if ((fd2 = inet_open(device)) < 0)
		return (FAILURE);
	if ((fd3 = inet_open(device)) < 0)
		return (FAILURE);

	return (SUCCESS);
}

int
postamble_0(void)
{
	do {
		if (inet_close(fd1) == FAILURE)
			break;
		if (inet_close(fd2) == FAILURE)
			break;
		if (inet_close(fd3) == FAILURE)
			break;
		return (SUCCESS);
	}
	while (0);
	return (FAILURE);
}

int
preamble_1(void)
{
	state = 0;
	for (;;) {
		switch (state) {
		case 0:
			if ((fd1 = inet_open(device)) < 0)
				break;
			state = 1;
		case 1:
			if ((fd2 = inet_open(device)) < 0)
				break;
			state = 2;
		case 2:
			if ((fd3 = inet_open(device)) < 0)
				break;
			state = 3;
		case 3:
			if (inet_optmgmt_req(fd1, T_NEGOTIATE) == FAILURE)
				break;
			state = 4;
		case 4:
			if (expect(fd1, SHORT_WAIT, T_OPTMGMT_ACK) == FAILURE)
				break;
			state = 5;
		case 5:
			if (inet_bind_req(fd1, &addr1, 0) == FAILURE)
				break;
			state = 6;
		case 6:
			if (expect(fd1, NORMAL_WAIT, T_BIND_ACK) == FAILURE)
				break;
			state = 7;
		case 7:
			if (inet_optmgmt_req(fd2, T_NEGOTIATE) == FAILURE)
				break;
			state = 8;
		case 8:
			if (expect(fd2, SHORT_WAIT, T_OPTMGMT_ACK) == FAILURE)
				break;
			state = 9;
		case 9:
			if (inet_bind_req(fd2, &addr2, 5) == FAILURE)
				break;
			state = 10;
		case 10:
			if (expect(fd2, NORMAL_WAIT, T_BIND_ACK) == FAILURE)
				break;
			state = 11;
		case 11:
			if (inet_optmgmt_req(fd3, T_NEGOTIATE) == FAILURE)
				break;
			state = 12;
		case 12:
			if (expect(fd3, SHORT_WAIT, T_OPTMGMT_ACK) == FAILURE)
				break;
			state = 13;
		case 13:
			if (inet_bind_req(fd3, &addr3, 0) == FAILURE)
				break;
			state = 14;
		case 14:
			if (expect(fd3, NORMAL_WAIT, T_BIND_ACK) == FAILURE)
				break;
			return (SUCCESS);
		}
		return (FAILURE);
	}
}

int
preamble_2(void)
{
	state = 0;
	for (;;) {
		switch (state) {
		case 0:
			if (preamble_1() == FAILURE)
				break;
			state = 15;
		case 15:
			if (inet_conn_req(fd1, &addr2, NULL) == FAILURE)
				break;
			state = 16;
		case 16:
			if (expect(fd1, SHORT_WAIT, T_OK_ACK) == FAILURE)
				break;
			state = 17;
		case 17:
			if (expect(fd2, LONG_WAIT, T_CONN_IND) == FAILURE)
				break;
			state = 18;
		case 18:
			if (inet_conn_res(fd2, fd3, NULL) == FAILURE)
				break;
			state = 19;
		case 19:
			if (expect(fd2, SHORT_WAIT, T_OK_ACK) == FAILURE)
				break;
			state = 20;
		case 20:
			if (expect(fd1, LONG_WAIT, T_CONN_CON) == FAILURE)
				break;
			return (SUCCESS);
		}
		return (FAILURE);
	}
}

int
preamble_2b(void)
{
	state = 0;
	for (;;) {
		switch (state) {
		case 0:
			if (preamble_1() == FAILURE)
				break;
			state = 15;
		case 15:
			if (inet_conn_req(fd1, &addr2, "Hello World!") == FAILURE)
				break;
			state = 16;
		case 16:
			if (expect(fd1, SHORT_WAIT, T_OK_ACK) == FAILURE)
				break;
			state = 17;
		case 17:
			if (expect(fd2, LONG_WAIT, T_CONN_IND) == FAILURE)
				break;
			state = 18;
		case 18:
			if (inet_conn_res(fd2, fd3, "Hello There!") == FAILURE)
				break;
			state = 19;
		case 19:
			if (expect(fd2, SHORT_WAIT, T_OK_ACK) == FAILURE)
				break;
			state = 20;
		case 20:
			if (expect(fd1, LONG_WAIT, T_CONN_CON) == FAILURE)
				break;
			state = 21;
		case 21:
			if (expect(fd3, NORMAL_WAIT, T_EXDATA_IND) == FAILURE)
				break;
			state = 22;
		case 22:
			if (expect(fd1, NORMAL_WAIT, T_EXDATA_IND) == FAILURE)
				break;
			return (SUCCESS);
		}
		return (FAILURE);
	}
}
int
preamble_3(void)
{
	return preamble_1();
}

int
preamble_3b(void)
{
	opt_optm.rcv_val = T_YES;
	opt_optm.ist_val = 32;
	opt_optm.ost_val = 32;
	opt_conn.ist_val = 32;
	opt_conn.ost_val = 32;
	return preamble_2();
}

int
preamble_4(void)
{
	opt_optm.dbg_val = SCTP_OPTION_DROPPING;
	return preamble_2();
}

int
preamble_4b(void)
{
	opt_optm.dbg_val = SCTP_OPTION_RANDOM;
	return preamble_2();
}

int
preamble_5(void)
{
	// opt_optm.dbg_val =
	// SCTP_OPTION_BREAK|SCTP_OPTION_DBREAK|SCTP_OPTION_DROPPING;
	opt_optm.dbg_val = SCTP_OPTION_BREAK;
	return preamble_2();
}

int
preamble_6(