test-sctp_t.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

				case 5: printf("                    |                               |  v<----- OPEN         \n"); break;
			}
			break;
		case 2: printf("\n%d-OPEN: sctp_n\n", fd); break;
	}
	return(fd);
}
int sctp_close(int fd)
{
	int ret;
	if ( (ret = close(fd)) < 0 )
		printf("ERROR: close: [%d] %s\n", errno, strerror(errno));
	else
	switch ( show ) {
		case 1:
			switch ( fd )
			{
				case 3: printf("CLOSE         ----->X                               |  |                    \n"); break;
				case 4: printf("                                                    X<-+------ CLOSE        \n"); break;
				case 5: printf("                                                       X<----- CLOSE        \n"); break;
			}
			break;
		case 2: printf("\n%d-CLOSE:\n",fd); break;
	}
	return(ret);
}
int sctp_info_req(int fd)
{
	data.len = 0;
	ctrl.len = sizeof(cmd.tpi.info_req);
	cmd.tpi.type = T_INFO_REQ;
	return put_msg(fd, 0, MSG_HIPRI, 0);
}

int sctp_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 sctp_bind_req(int fd, addr_t *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 sctp_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 sctp_conn_req(int fd, addr_t *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 sctp_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 sctp_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 sctp_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 sctp_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 sctp_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 sctp_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 sctp_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 sctp_wait(int fd, int wait)
{
	return get_msg(fd,wait);
}

void sctp_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.port = htons(10000);
	inet_aton("127.0.0.3",     &addr1.addr[0]);
	inet_aton("127.0.0.2",     &addr1.addr[1]);
	inet_aton("127.0.0.1",     &addr1.addr[2]);

	addr2.port = htons(10001);
	inet_aton("127.0.0.3",     &addr2.addr[0]);
	inet_aton("127.0.0.2",     &addr2.addr[1]);
	inet_aton("127.0.0.1",     &addr2.addr[2]);

	addr3.port = htons(10001);
	inet_aton("127.0.0.3",     &addr3.addr[0]);
	inet_aton("127.0.0.2",     &addr3.addr[1]);
	inet_aton("127.0.0.1",     &addr3.addr[2]);

	state = 0;

	return(SUCCESS);
}

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

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

	return(SUCCESS);
}

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

int preamble_1(void)
{
	state = 0;
	for ( ;; ) {
		switch ( state ) {
			case 0:
				if ( (fd1 = sctp_t_open()) < 0 ) break;
				state = 1;
			case 1:
				if ( (fd2 = sctp_t_open()) < 0 ) break;
				state = 2;
			case 2:
				if ( (fd3 = sctp_t_open()) < 0 ) break;
				state = 3;
			case 3:
				if ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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 ( sctp_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(void)
{
	opt_optm.dbg_val = SCTP_OPTION_RANDOM;
	return preamble_3b();
}
int preamble_7(void)
{
	opt_optm.mac_val = SCTP_HMAC_SHA_1;
	return preamble_1();
}
int preamble_8(void)
{
	opt_optm.mac_val = SCTP_HMAC_MD5;
	return preamble_1();
}

int postamble_1(void)
{
	uint failed = -1;
	state = 0;
	for ( ;; ) {
		switch ( state ) {
			case 0:
				if ( sctp_unbind_req(fd1) == FAILURE ) { failed = state;
					state = 1;
					continue;
				}
				if ( expect(fd1, SHORT_WAIT, T_OK_ACK) == FAILURE ) failed = state;
				state = 1;
			case 1:
				if ( sctp_unbind_req(fd2) == FAILURE ) { failed = state;
					state = 2;
					continue;
				}
				if ( expect(fd2, SHORT_WAIT, T_OK_ACK) == FAILURE ) failed = state;
				state = 2;
			case 2:
				if ( sctp_unbind_req(fd3) == FAILURE ) { failed = state;
					state = 3;