sctp_test.c

SCTP 协议实现源代码

					printf("\n\t\trecvmsg() returned ");
				       	printf("0 !!!!\n");
					fflush(stdout);
				}

				print_message(poll_sks[i].sk, &inmessage,
					error);

				inmessage.msg_control = incmsg;
				inmessage.msg_controllen = sizeof(incmsg);
				iov.iov_len = REALLY_BIG;
			}
			
			/* Is this socket writeable?  */
			if (tosend && FD_ISSET(poll_sks[i].sk, obitsp)) {

				FD_CLR(poll_sks[i].sk, obitsp);

				/* Pick an association.  */
				assoc_i = next_assoc(i, poll_sks[i].assoc_i,
						assoc_pattern);
				if (assoc_i < 0) {
					/* No work to do on any associations.
					 * We are probably done. */
					if (!listeners) {
						done = 1;
					}
					continue;
				}
				poll_sks[i].assoc_i = assoc_i;

				as = poll_sks[i].assoc_state;
				n_msg_size = next_msg_size(as[assoc_i].msg_cnt);
				n_order = as[assoc_i].order_state =
					next_order(as[assoc_i].order_state,
					order_pattern);
				n_stream = as[assoc_i].stream_state =
					next_stream(as[assoc_i].stream_state,
					stream_pattern);

				/* Set the destination port.  */
				if (s_rem.ss_family == AF_INET6)
					( (struct sockaddr_in6 *)&s_rem)->
						sin6_port =
						htons(as[assoc_i].rem_port);
				else
					( (struct sockaddr_in *)&s_rem)->
						sin_port =
						htons(as[assoc_i].rem_port);

				/* Send a message thru the association.  */
				if (send_r(poll_sks[i].sk, n_stream, n_order,
					n_msg_size, assoc_i) < 0) {
					/* Don't increment counter if there
					 * is a problem of sending.
					 */
					continue;
				}

				/* Increment counters. */
				if (++as[assoc_i].msg_cnt >= MSG_CNT) {
					as[assoc_i].msg_cnt = 0;
				}
				if (++as[assoc_i].msg_sent >=
					repeat_count) {
					fprintf(stderr, "Association #%d in ",
						assoc_i);
					fprintf(stderr, "sk=%d has ",
						poll_sks[i].sk);
					fprintf(stderr, "completed %d msg as ",
						as[assoc_i].msg_sent);
					fprintf(stderr, "cycle %d.\n",
						++as[assoc_i].cycle);

					/* In the mixed mode, -x not only
					 * specify the longer repeat cycle,
					 * but it also mean to run the test
					 * forever.
					 */
					if (xflag) {
						as[assoc_i].msg_sent = 0;
					}

				}

			}
		}
	}

clean_up:
	for (i = 0; i < sks; i++) {
		close(poll_sks[i].sk);
		if (poll_sks[i].assoc_state) {
			free(poll_sks[i].assoc_state);
		}
	}

	if (ibitsp) free(ibitsp);
	if (obitsp) free(obitsp);
	if (xbitsp) free(xbitsp);

	if (iov.iov_base) free(iov.iov_base);

} /* mixed_mode_test() */

void start_test(int role)
{
	int sk;
	int i = 0;
	
	DEBUG_PRINT(DEBUG_NONE, "\nStarting tests...\n");

	repeat_count = repeat;


	if (MIXED == role) {
		repeat_count = repeat_count * msg_cnt;  /* Repeat per assoc. */
		mixed_mode_test();
		return;
	}

	sk = socket_r();
	bind_r(sk, &s_loc);

	if (role == SERVER) {
		listen_r(sk, 100);
	}

	if (!debug_level) {
		printf("     ");
	}

	for(i = 0; i < repeat_count; i++) {
		
		if (role == SERVER) {
			DEBUG_PRINT(DEBUG_NONE,
				    "Server: Receiving packets.\n");
			server(sk);
		} else {
			DEBUG_PRINT(DEBUG_NONE,
				    "Client: Sending packets.(%d/%d)\n",
		    		    i+1, repeat_count);
			client(sk);
		}

		fflush(stdout);
	}

	close_r(sk);

} /* start_test() */

int
main(int argc, char *argv[])
{
	int c, role = NOT_DEFINED;
	char *interface = NULL;
	struct sockaddr_in *t_addr;
	struct sockaddr_in6 *t_addr6;
	
        /* Parse the arguments.  */
        while ((c = getopt(argc, argv, ":H:L:P:S:a:h:p:c:d:lm:sx:X:o:t:M:r:w:Di:")) >= 0 ) {

                switch (c) {
		case 'H':
			local_host = optarg;
			break;
		case 'L':
			role = MIXED;
			listeners = atoi(optarg);
			if (listeners > MAX_POLL_SKS) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'P':
			local_port = atoi(optarg);
			break;
		case 'S':
			role = MIXED;
			tosend = atoi(optarg);
			if (tosend > MAX_POLL_SKS) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'a':
			assoc_pattern = atoi(optarg);
			if (assoc_pattern <  ASSOC_PATTERN_SEQUENTIAL
			    || assoc_pattern > ASSOC_PATTERN_RANDOM ) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'h':
			remote_host = optarg;
			break;
		case 'D':
			drain = 1;
			do_exit = 0;
			break;
		case 'p':
			remote_port = atoi(optarg);
			break;
		case 's':
			if (role != NOT_DEFINED) {
				printf("%s: only -s or -l\n", argv[0]);
				usage(argv[0]);
				exit(1);
			}
			role = CLIENT;
			break;
		case 'l':
			if (role != NOT_DEFINED) {
				printf("%s: only -s or -l\n", argv[0]);
				usage(argv[0]);
				exit(1);
			}
			role = SERVER;
			break;
		case 'd':
			debug_level = atoi(optarg);
			if (debug_level < DEBUG_NONE
			    || debug_level > DEBUG_MAX) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'x':
			repeat = atoi(optarg);
			if (!repeat) {
				xflag = 1;
				repeat = BIG_REPEAT;
			}
			break;
		case 'X':
			msg_cnt = atoi(optarg);
			if ((msg_cnt <= 0) || (msg_cnt > MSG_CNT)) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'c':
			test_case = atoi(optarg);
			if (test_case > NCASES) {
				usage(argv[0]);
				exit(1);
			}
			if (test_case < 0) {
				size_arg = -test_case;
			}
			
			break;
		case 'o':
			order_pattern = atoi(optarg);
			if (order_pattern <  ORDER_PATTERN_UNORDERED
			    || order_pattern  > ORDER_PATTERN_RANDOM ) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 't':
			stream_pattern = atoi(optarg);
			if (stream_pattern <  STREAM_PATTERN_SEQUENTIAL
			    || stream_pattern > STREAM_PATTERN_RANDOM ) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'M':
			max_stream = atoi(optarg);
			if (max_stream <  0
			    || max_stream >= (1<<16)) {
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'r':
			seed = atoi(optarg);
			break;
		case 'm':
			max_msgsize = atoi(optarg);
#if 0
			if ((max_msgsize < DEFAULT_MIN_WINDOW) ||
			    (max_msgsize > 65515)) {
				usage(argv[0]);
				exit(1);
			}
#endif
			break;
		case 'i':
			interface = optarg;
			break;
		case '?':
		default:
			usage(argv[0]);
			exit(0);
		}
	} /* while() */

	if (NOT_DEFINED == role) {
		usage(argv[0]);
		exit(1);
	}


	if (SERVER == role && NULL == local_host && remote_host != NULL) {
		fprintf (stderr, "%s: Server needs local address, "
			 "not remote address\n", argv[0]);
		usage(argv[0]);
		exit(1);
	}
	if (CLIENT == role && NULL == remote_host) {
		fprintf (stderr, "%s: Client needs at least remote address "
			 "& port\n", argv[0]);
		usage(argv[0]);
		exit(1);
	}
	if (MIXED == role) {
		if (listeners && NULL == local_host) {
			fprintf (stderr, "%s: Servers need local address\n",
				argv[0]);
			usage(argv[0]);
			exit(1);
		}
		if (tosend && NULL == remote_host) {
			fprintf (stderr, "%s: Clients need remote address ",
				argv[0]);
			fprintf (stderr, "& port\n");
			usage(argv[0]);
			exit(1);
		}
	}

	if (optind < argc) {
                fprintf(stderr, "%s: non-option arguments are illegal: ",
                        argv[0]);
                while (optind < argc)
                        fprintf(stderr, "%s ", argv[optind++]);
                fprintf (stderr, "\n");
                usage(argv[0]);
                exit(1);
	}

	if (remote_host != NULL && remote_port != 0) {
		struct addrinfo *res;
		int error;
		char *host_s, *serv_s;

		if ((host_s = malloc(NI_MAXHOST)) == NULL) {
			fprintf(stderr, "\n*** host_s malloc failed!!! ***\n");
			exit(1);
		}
		if ((serv_s = malloc(NI_MAXSERV)) == NULL) {
			fprintf(stderr, "\n*** serv_s malloc failed!!! ***\n");
			exit(1);
		}

		error = getaddrinfo(remote_host, 0, NULL, &res);
		if (error) {
			printf("%s.\n", gai_strerror(error));
			usage(argv[0]);
			exit(1);
		}

		switch (res->ai_family) {
			case AF_INET:
				t_addr = (struct sockaddr_in *)&s_rem;

				t_addr->sin_family = AF_INET;
				t_addr->sin_port = htons(remote_port);
				inet_pton(AF_INET, remote_host,
					      &t_addr->sin_addr);

				r_len = sizeof (struct sockaddr_in);
#ifdef __FreeBSD__
				t_addr->sin_len = r_len;
#endif
				break;
			case AF_INET6:

				t_addr6 = (struct sockaddr_in6 *)&s_rem;
				
				if (interface)
					t_addr6->sin6_scope_id =
						if_nametoindex(interface);
				t_addr6->sin6_family = AF_INET6;
				t_addr6->sin6_port = htons(remote_port);
				inet_pton(AF_INET6, remote_host,
					      &t_addr6->sin6_addr);

				r_len = sizeof (struct sockaddr_in6);

#ifdef __FreeBSD__
				t_addr6->sin6_len = r_len;
#endif
				break;
		}

		getnameinfo((struct sockaddr *)&s_rem, r_len, host_s,
			    NI_MAXHOST, serv_s, NI_MAXSERV, NI_NUMERICHOST);
			

		DEBUG_PRINT(DEBUG_MAX, "remote:addr=%s, port=%s, family=%d\n",
			    host_s, serv_s, res->ai_family);
        }

	if (local_host != NULL) {
		struct addrinfo *res;
		int error;
		char *host_s, *serv_s;
		struct sockaddr_in *t_addr;
		struct sockaddr_in6 *t_addr6;

		if ((host_s = malloc(NI_MAXHOST)) == NULL) {
			fprintf(stderr, "\n*** host_s malloc failed!!! ***\n");
			exit(1);
		}
		if ((serv_s = malloc(NI_MAXSERV)) == NULL) {
			fprintf(stderr, "\n*** serv_s malloc failed!!! ***\n");
			exit(1);
		}

		if (strcmp(local_host, "0") == 0)
			local_host = "0.0.0.0";

		error = getaddrinfo(local_host, 0, NULL, &res);
		if (error) {
			printf("%s.\n", gai_strerror(error));
			usage(argv[0]);
			exit(1);
		}

			
		switch (res->ai_family) {
			case AF_INET:
				t_addr = (struct sockaddr_in *)&s_loc;
				t_addr->sin_family = AF_INET;
				t_addr->sin_port = htons(local_port);
				inet_pton(AF_INET, local_host,
					      &t_addr->sin_addr);

				l_len = sizeof (struct sockaddr_in);
#ifdef __FreeBSD__
				t_addr->sin_len = l_len;
#endif
				break;
			case AF_INET6:
				t_addr6 = (struct sockaddr_in6 *)&s_loc;

				if (interface)
					t_addr6->sin6_scope_id =
						if_nametoindex(interface);
				t_addr6->sin6_family = AF_INET6;
				t_addr6->sin6_port = htons(local_port);

				inet_pton(AF_INET6, local_host,
					      &t_addr6->sin6_addr);

				l_len = sizeof (struct sockaddr_in6);

#ifdef __FreeBSD__
				t_addr6->sin6_len = l_len;
#endif
				break;
		}

		error = getnameinfo((struct sockaddr *)&s_loc, l_len, host_s,
			    NI_MAXHOST, serv_s, NI_MAXSERV, NI_NUMERICHOST);

		if (error)
			printf("%s..\n", gai_strerror(error));

		DEBUG_PRINT(DEBUG_MAX, "local:addr=%s, port=%s, family=%d\n",
			    host_s, serv_s, res->ai_family);
        }


	/* A half-hearted attempt to seed rand() */
	if (seed == 0 ) {
		seed = time(0);
		DEBUG_PRINT(DEBUG_NONE, "seed = %d\n", seed);	
	}
	
	srand(seed);

	/* Let the testing begin. */
	start_test(role);

	return 0;

} /*  main() */