king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd5f7aa4152'
${ noResults }
v811_spc009/external/usrsctp/programs/tsctp_upcall.c

763 lines
20 KiB
Raw Blame History

/*
* 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(&note_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;
}
Reference in new issue View Git Blame Copy Permalink