diff options
Diffstat (limited to 'programs/tsctp_upcall.c')
-rw-r--r-- | programs/tsctp_upcall.c | 762 |
1 files changed, 762 insertions, 0 deletions
diff --git a/programs/tsctp_upcall.c b/programs/tsctp_upcall.c new file mode 100644 index 00000000..21f6bba9 --- /dev/null +++ b/programs/tsctp_upcall.c @@ -0,0 +1,762 @@ +/* + * Copyright (C) 2005-2013 Michael Tuexen + * Copyright (C) 2011-2013 Irene Ruengeler + * Copyright (C) 2014-2019 Felix Weinrank + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/types.h> +#ifdef _WIN32 +#include <winsock2.h> +#include <ws2tcpip.h> +#include <stdlib.h> +#include <crtdbg.h> +#include <sys/timeb.h> +#else +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <sys/time.h> +#include <unistd.h> +#include <pthread.h> +#endif +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <signal.h> +#include <errno.h> +#include <inttypes.h> +#ifdef LINUX +#include <getopt.h> +#endif +#include <usrsctp.h> +#include "programs_helper.h" + +#define TSCTP_CLIENT 1 +#define TSCTP_SERVER 2 + +#define DEFAULT_LENGTH 1024 +#define DEFAULT_NUMBER_OF_MESSAGES 1024 +#define DEFAULT_PORT 5001 +#define BUFFERSIZE (1<<16) + +static int par_verbose = 0; +static int par_very_verbose = 0; +static unsigned int done = 0; + +struct tsctp_meta { + uint8_t par_role; + uint8_t par_stats_human; + uint8_t par_ordered; + uint64_t par_messages; + uint64_t par_message_length; + uint64_t par_runtime; + + uint64_t stat_messages; + uint64_t stat_message_length; + uint64_t stat_notifications; + uint64_t stat_recv_calls; + struct timeval stat_start; + + uint64_t stat_fragment_sum; + + char *buffer; +}; + +#ifndef timersub +#define timersub(tvp, uvp, vvp) \ + do { \ + (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; \ + (vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; \ + if ((vvp)->tv_usec < 0) { \ + (vvp)->tv_sec--; \ + (vvp)->tv_usec += 1000000; \ + } \ + } while (0) +#endif + +#ifdef _WIN32 +static void +gettimeofday(struct timeval *tv, void *ignore) +{ + struct timeb tb; + + ftime(&tb); + tv->tv_sec = (long)tb.time; + tv->tv_usec = tb.millitm * 1000; +} +#endif + + +char Usage[] = +"Usage: tsctp [options] [address]\n" +"Options:\n" +" -a set adaptation layer indication\n" +" -E local UDP encapsulation port (default 9899)\n" +" -f fragmentation point\n" +" -H human readable statistics" +" -l message length\n" +" -L bind to local IP (default INADDR_ANY)\n" +" -n number of messages sent (0 means infinite)/received\n" +" -D turns Nagle off\n" +" -R socket recv buffer\n" +" -S socket send buffer\n" +" -T time to send messages\n" +" -u use unordered user messages\n" +" -U remote UDP encapsulation port\n" +" -v verbose\n" +" -V very verbose\n" +; + +static void handle_upcall(struct socket *upcall_socket, void *upcall_data, int upcall_flags); + +static const char *bytes2human(uint64_t bytes) +{ + char *suffix[] = {"", "K", "M", "G", "T"}; + char suffix_length = sizeof(suffix) / sizeof(suffix[0]); + int i = 0; + double human_size = bytes; + static char output[200]; + + if (bytes > 1024) { + for (i = 0; (bytes / 1024) > 0 && i < suffix_length - 1; i++) { + human_size = bytes / 1024.0; + bytes /= 1024; + } + } + + if (snprintf(output, sizeof(output), "%.02lf %s", human_size, suffix[i]) < 0) { + output[0] = '\0'; + } + return output; +} + + +static void +handle_accept(struct socket *upcall_socket, void *upcall_data, int upcall_flags) +{ + struct socket *conn_sock; + struct sockaddr_in remote_addr; + socklen_t addr_len = sizeof(struct sockaddr_in); + struct tsctp_meta *meta_listening, *meta_accepted; + char addrbuf[INET_ADDRSTRLEN]; + + meta_listening = (struct tsctp_meta *) upcall_data; + + memset(&remote_addr, 0, sizeof(struct sockaddr_in)); + if (((conn_sock = usrsctp_accept(upcall_socket, (struct sockaddr *) &remote_addr, &addr_len)) == NULL) && (errno != EINPROGRESS)) { + perror("usrsctp_accept"); + exit(EXIT_FAILURE); + } + + if (par_verbose) { + printf("Connection accepted from %s:%d\n", inet_ntop(AF_INET, &(remote_addr.sin_addr), addrbuf, INET_ADDRSTRLEN), ntohs(remote_addr.sin_port)); + } + + meta_accepted = malloc(sizeof(struct tsctp_meta)); + if (!meta_accepted) { + printf("malloc() failed!\n"); + exit(EXIT_FAILURE); + } + + memset(meta_accepted, 0, sizeof(struct tsctp_meta)); + + meta_accepted->par_role = meta_listening->par_role; + meta_accepted->par_stats_human = meta_listening->par_stats_human; + meta_accepted->buffer = malloc(BUFFERSIZE); + + if (!meta_accepted->buffer) { + printf("malloc() failed!\n"); + exit(EXIT_FAILURE); + } + + usrsctp_set_upcall(conn_sock, handle_upcall, meta_accepted); +} + +static void +handle_upcall(struct socket *upcall_socket, void *upcall_data, int upcall_flags) +{ + int events = usrsctp_get_events(upcall_socket); + struct tsctp_meta* tsctp_meta = (struct tsctp_meta*) upcall_data; + + struct sctp_recvv_rn rn; + ssize_t n; + struct sockaddr_storage addr; + int recv_flags = 0; + socklen_t len = (socklen_t)sizeof(struct sockaddr_storage); + unsigned int infotype = 0; + socklen_t infolen = sizeof(struct sctp_recvv_rn); + struct sctp_rcvinfo *rcvinfo = (struct sctp_rcvinfo *) &rn; + memset(&rn, 0, sizeof(struct sctp_recvv_rn)); + struct timeval note_time; + union sctp_notification *snp; + struct sctp_paddr_change *spc; + struct timeval time_now; + struct timeval time_diff; + float seconds; + struct sctp_sndinfo snd_info; + + if (events & SCTP_EVENT_READ) { + while ((n = usrsctp_recvv(upcall_socket, tsctp_meta->buffer, BUFFERSIZE, (struct sockaddr *) &addr, &len, (void *)&rn, &infolen, &infotype, &recv_flags)) > 0) { + + if (!tsctp_meta->stat_recv_calls) { + gettimeofday(&tsctp_meta->stat_start, NULL); + } + tsctp_meta->stat_recv_calls++; + + if (recv_flags & MSG_NOTIFICATION) { + tsctp_meta->stat_notifications++; + gettimeofday(¬e_time, NULL); + if (par_verbose) { + printf("notification arrived at %f\n", note_time.tv_sec + (double)note_time.tv_usec / 1000000.0); + + snp = (union sctp_notification *)tsctp_meta->buffer; + if (snp->sn_header.sn_type == SCTP_PEER_ADDR_CHANGE) { + spc = &snp->sn_paddr_change; + printf("SCTP_PEER_ADDR_CHANGE: state=%d, error=%d\n",spc->spc_state, spc->spc_error); + } + } + } else { + if (par_very_verbose) { + if (infotype == SCTP_RECVV_RCVINFO) { + printf("Message received - %zd bytes - %s - sid %u - tsn %u %s\n", + n, + (rcvinfo->rcv_flags & SCTP_UNORDERED) ? "unordered" : "ordered", + rcvinfo->rcv_sid, + rcvinfo->rcv_tsn, + (recv_flags & MSG_EOR) ? "- EOR" : "" + ); + + } else { + printf("Message received - %zd bytes %s\n", n, (recv_flags & MSG_EOR) ? "- EOR" : ""); + } + } + tsctp_meta->stat_fragment_sum += n; + if (recv_flags & MSG_EOR) { + tsctp_meta->stat_messages++; + if (tsctp_meta->stat_message_length == 0) { + tsctp_meta->stat_message_length = tsctp_meta->stat_fragment_sum; + } + } + } + } + + if (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK) { + perror("usrsctp_recvv"); + exit(EXIT_FAILURE); + } + + if (n == 0) { + done = 1; + + gettimeofday(&time_now, NULL); + timersub(&time_now, &tsctp_meta->stat_start, &time_diff); + seconds = time_diff.tv_sec + (double)time_diff.tv_usec / 1000000.0; + + if (tsctp_meta->par_stats_human) { + printf("Connection closed - statistics\n"); + + printf("\tmessage size : %" PRIu64 "\n", tsctp_meta->stat_message_length); + printf("\tmessages : %" PRIu64 "\n", tsctp_meta->stat_messages); + printf("\trecv() calls : %" PRIu64 "\n", tsctp_meta->stat_recv_calls); + printf("\tnotifications : %" PRIu64 "\n", tsctp_meta->stat_notifications); + printf("\ttransferred : %sByte\n", bytes2human(tsctp_meta->stat_message_length * tsctp_meta->stat_messages)); + printf("\truntime : %.2f s\n", seconds); + printf("\tgoodput : %sBit/s\n", bytes2human((double) tsctp_meta->stat_message_length * (double) tsctp_meta->stat_messages / seconds * 8)); + + } else { + printf("%" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %f, %f, %" PRIu64 "\n", + tsctp_meta->stat_message_length, + tsctp_meta->stat_messages, + tsctp_meta->stat_recv_calls, + tsctp_meta->stat_message_length * tsctp_meta->stat_messages, + seconds, + (double) tsctp_meta->stat_message_length * (double) tsctp_meta->stat_messages / seconds, + tsctp_meta->stat_notifications); + } + fflush(stdout); + usrsctp_close(upcall_socket); + + free(tsctp_meta->buffer); + free(tsctp_meta); + return; + } + } + + if ((events & SCTP_EVENT_WRITE) && tsctp_meta->par_role == TSCTP_CLIENT && !done) { + + memset(&snd_info, 0, sizeof(struct sctp_sndinfo)); + if (tsctp_meta->par_ordered == 0) { + snd_info.snd_flags |= SCTP_UNORDERED; + } + + while ((n = usrsctp_sendv(upcall_socket, tsctp_meta->buffer, tsctp_meta->par_message_length, NULL, 0, &snd_info, (socklen_t)sizeof(struct sctp_sndinfo), SCTP_SENDV_SNDINFO, 0)) > 0) { + if (tsctp_meta->stat_messages == 0) { + gettimeofday(&tsctp_meta->stat_start, NULL); + } + tsctp_meta->stat_messages++; + + if (par_very_verbose) { + printf("Message #%" PRIu64 " sent\n", tsctp_meta->stat_messages); + } + + if (tsctp_meta->par_messages && tsctp_meta->par_messages == tsctp_meta->stat_messages) { + break; + } + } + + if (errno != EAGAIN && errno != EWOULDBLOCK) { + done = 1; + usrsctp_close(upcall_socket); + printf("client socket %p closed\n", (void *)upcall_socket); + free(tsctp_meta->buffer); + free(tsctp_meta); + return; + } + + gettimeofday(&time_now, NULL); + timersub(&time_now, &tsctp_meta->stat_start, &time_diff); + seconds = time_diff.tv_sec + (double)time_diff.tv_usec / 1000000.0; + + if ((tsctp_meta->par_messages && tsctp_meta->par_messages == tsctp_meta->stat_messages) || + (tsctp_meta->par_runtime && tsctp_meta->par_runtime <= seconds)) { + + if (par_verbose) { + printf("Runtime or max messages reached - finishing...\n"); + } + + done = 1; + usrsctp_close(upcall_socket); + free(tsctp_meta->buffer); + free(tsctp_meta); + return; + } + } + + return; +} + +int main(int argc, char **argv) +{ +#ifndef _WIN32 + int c; +#endif + struct socket *psock = NULL; + struct sockaddr_in local_addr; + struct sockaddr_in remote_addr; + int optval; + uint16_t local_port; + uint16_t remote_port; + uint16_t local_udp_port; + uint16_t remote_udp_port; + int rcvbufsize = 0; + int sndbufsize = 0; + socklen_t intlen; + int nodelay = 0; + struct sctp_assoc_value av; + struct sctp_udpencaps encaps; + struct tsctp_meta *meta; + + uint16_t par_port = DEFAULT_PORT; + uint8_t par_stats_human = 0; + int par_ordered = 1; + int par_message_length = DEFAULT_LENGTH; + int par_messages = DEFAULT_NUMBER_OF_MESSAGES; + int par_runtime = 0; + +#ifdef _WIN32 + unsigned long src_addr; +#else + in_addr_t src_addr; +#endif + int fragpoint = 0; + struct sctp_setadaptation ind = {0}; +#ifdef _WIN32 + char *opt; + int optind; +#endif + + remote_udp_port = 0; + local_udp_port = 9899; + src_addr = htonl(INADDR_ANY); + + memset((void *) &remote_addr, 0, sizeof(struct sockaddr_in)); + memset((void *) &local_addr, 0, sizeof(struct sockaddr_in)); + +#ifndef _WIN32 + while ((c = getopt(argc, argv, "a:DE:f:Hl:L:n:p:R:S:T:uU:vV")) != -1) + switch(c) { + case 'a': + ind.ssb_adaptation_ind = atoi(optarg); + break; + case 'D': + nodelay = 1; + break; + case 'E': + local_udp_port = atoi(optarg); + break; + case 'f': + fragpoint = atoi(optarg); + break; + case 'H': + par_stats_human = 1; + break; + case 'l': + par_message_length = atoi(optarg); + break; + case 'L': + if (inet_pton(AF_INET, optarg, &src_addr) != 1) { + printf("Can't parse %s\n", optarg); + exit(EXIT_FAILURE); + } + break; + case 'n': + par_messages = atoi(optarg); + break; + case 'p': + par_port = atoi(optarg); + break; + case 'R': + rcvbufsize = atoi(optarg); + break; + case 'S': + sndbufsize = atoi(optarg); + break; + case 'T': + par_runtime = atoi(optarg); + par_messages = 0; + break; + case 'u': + par_ordered = 0; + break; + case 'U': + remote_udp_port = atoi(optarg); + break; + case 'v': + par_verbose = 1; + break; + case 'V': + par_verbose = 1; + par_very_verbose = 1; + break; + default: + fprintf(stderr, "%s", Usage); + exit(1); + } +#else + for (optind = 1; optind < argc; optind++) { + if (argv[optind][0] == '-') { + switch (argv[optind][1]) { + case 'a': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + ind.ssb_adaptation_ind = atoi(opt); + break; + case 'D': + nodelay = 1; + break; + case 'E': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + local_udp_port = atoi(opt); + break; + case 'f': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + fragpoint = atoi(opt); + break; + case 'H': + par_stats_human = 1; + break; + case 'l': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + par_message_length = atoi(opt); + break; + case 'L': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + inet_pton(AF_INET, opt, &src_addr); + break; + case 'n': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + par_messages = atoi(opt); + break; + case 'p': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + par_port = atoi(opt); + break; + case 'R': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + rcvbufsize = atoi(opt); + break; + case 'S': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + sndbufsize = atoi(opt); + break; + case 'T': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + par_runtime = atoi(opt); + par_messages = 0; + break; + case 'u': + par_ordered = 0; + break; + case 'U': + if (++optind >= argc) { + printf("%s", Usage); + exit(1); + } + opt = argv[optind]; + remote_udp_port = atoi(opt); + break; + case 'v': + par_verbose = 1; + break; + case 'V': + par_verbose = 1; + par_very_verbose = 1; + break; + default: + printf("%s", Usage); + exit(1); + } + } else { + break; + } + } +#endif + + meta = malloc(sizeof(struct tsctp_meta)); + if (!meta) { + printf("malloc() failed!\n"); + exit(EXIT_FAILURE); + } + + memset(meta, 0, sizeof(struct tsctp_meta)); + + meta->buffer = malloc(BUFFERSIZE); + if (!meta->buffer) { + printf("malloc() failed!\n"); + exit(EXIT_FAILURE); + } + + meta->par_stats_human = par_stats_human; + meta->par_message_length = par_message_length; + meta->par_messages = par_messages; + meta->par_ordered = par_ordered; + meta->par_runtime = par_runtime; + + if (optind == argc) { + meta->par_role = TSCTP_SERVER; + local_port = par_port; + remote_port = 0; + } else { + meta->par_role = TSCTP_CLIENT; + local_port = 0; + remote_port = par_port; + } + local_addr.sin_family = AF_INET; +#ifdef HAVE_SIN_LEN + local_addr.sin_len = sizeof(struct sockaddr_in); +#endif + local_addr.sin_port = htons(local_port); + local_addr.sin_addr.s_addr = src_addr; + + usrsctp_init(local_udp_port, NULL, debug_printf_stack); +#ifdef SCTP_DEBUG + usrsctp_sysctl_set_sctp_debug_on(SCTP_DEBUG_ALL); +#endif + usrsctp_sysctl_set_sctp_blackhole(2); + usrsctp_sysctl_set_sctp_no_csum_on_loopback(0); + usrsctp_sysctl_set_sctp_enable_sack_immediately(1); + + if (!(psock = usrsctp_socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP, NULL, NULL, 0, NULL))) { + perror("user_socket"); + exit(EXIT_FAILURE); + } + + optval = 1; + if (usrsctp_setsockopt(psock, IPPROTO_SCTP, SCTP_RECVRCVINFO, &optval, sizeof(optval)) < 0) { + perror("usrsctp_setsockopt SCTP_RECVRCVINFO"); + } + + usrsctp_set_non_blocking(psock, 1); + + if (usrsctp_bind(psock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in)) == -1) { + perror("usrsctp_bind"); + exit(1); + } + + if (usrsctp_setsockopt(psock, IPPROTO_SCTP, SCTP_ADAPTATION_LAYER, (const void*)&ind, (socklen_t)sizeof(struct sctp_setadaptation)) < 0) { + perror("setsockopt"); + } + + if (meta->par_role == TSCTP_SERVER) { + if (rcvbufsize) { + if (usrsctp_setsockopt(psock, SOL_SOCKET, SO_RCVBUF, &rcvbufsize, sizeof(int)) < 0) { + perror("setsockopt: rcvbuf"); + } + } + if (par_verbose) { + intlen = sizeof(int); + if (usrsctp_getsockopt(psock, SOL_SOCKET, SO_RCVBUF, &rcvbufsize, (socklen_t *)&intlen) < 0) { + perror("getsockopt: rcvbuf"); + } else { + fprintf(stdout, "Receive buffer size: %d.\n", rcvbufsize); + } + } + + if (usrsctp_listen(psock, 1) < 0) { + perror("usrsctp_listen"); + exit(EXIT_FAILURE); + } + + usrsctp_set_upcall(psock, handle_accept, meta); + + while (1) { +#ifdef _WIN32 + Sleep(1000); +#else + sleep(1); +#endif + } + + } else { + memset(&encaps, 0, sizeof(struct sctp_udpencaps)); + encaps.sue_address.ss_family = AF_INET; + encaps.sue_port = htons(remote_udp_port); + if (usrsctp_setsockopt(psock, IPPROTO_SCTP, SCTP_REMOTE_UDP_ENCAPS_PORT, (const void*)&encaps, (socklen_t)sizeof(struct sctp_udpencaps)) < 0) { + perror("setsockopt"); + } + + remote_addr.sin_family = AF_INET; +#ifdef HAVE_SIN_LEN + remote_addr.sin_len = sizeof(struct sockaddr_in); +#endif + if (!inet_pton(AF_INET, argv[optind], &remote_addr.sin_addr.s_addr)){ + printf("error: invalid destination address\n"); + exit(EXIT_FAILURE); + } + remote_addr.sin_port = htons(remote_port); + + memset(meta->buffer, 'X', BUFFERSIZE); + + usrsctp_set_upcall(psock, handle_upcall, meta); + + usrsctp_setsockopt(psock, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, sizeof(nodelay)); + + if (fragpoint) { + av.assoc_id = 0; + av.assoc_value = fragpoint; + if (usrsctp_setsockopt(psock, IPPROTO_SCTP, SCTP_MAXSEG, &av, sizeof(struct sctp_assoc_value)) < 0) { + perror("setsockopt: SCTP_MAXSEG"); + } + } + + if (sndbufsize) { + if (usrsctp_setsockopt(psock, SOL_SOCKET, SO_SNDBUF, &sndbufsize, sizeof(int)) < 0) { + perror("setsockopt: sndbuf"); + } + } + + if (par_verbose) { + intlen = sizeof(int); + if (usrsctp_getsockopt(psock, SOL_SOCKET, SO_SNDBUF, &sndbufsize, (socklen_t *)&intlen) < 0) { + perror("setsockopt: SO_SNDBUF"); + } else { + fprintf(stdout,"Send buffer size: %d.\n", sndbufsize); + } + } + + if (usrsctp_connect(psock, (struct sockaddr *) &remote_addr, sizeof(struct sockaddr_in)) == -1 ) { + if (errno != EINPROGRESS) { + perror("usrsctp_connect"); + exit(EXIT_FAILURE); + } + } + + while (!done) { +#ifdef _WIN32 + Sleep(1000); +#else + sleep(1); +#endif + } + + if (par_verbose) { + printf("Finished... \n"); + } + } + + while (usrsctp_finish() != 0) { +#ifdef _WIN32 + Sleep(1000); +#else + sleep(1); +#endif + } + + return 0; +} |