/*
* SRT - Secure, Reliable, Transport
* Copyright (c) 2017 Haivision Systems Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; If not, see
*/
#include
#include
#include "srt.h"
// Note that in this example application there's a listening
// socket, off which then a transmission socket is accepted,
// then this socket will be used for reading. Therefore the same
// function will be used for waiting for the listener to get the
// accepted socket ready and then to wait for read-readiness on
// the transmission socket. For a model of waiting for write-ready
// see test-c-client-bonding.c file.
int WaitForReadReady(int eid, SRTSOCKET ss)
{
int ready_in[2];
int ready_in_len = 2;
int ready_err[2];
int ready_err_len = 2;
int st = srt_epoll_wait(eid, ready_in, &ready_in_len, ready_err, &ready_err_len, -1,
0, 0, 0, 0);
// Note: with indefinite wait time we can either have a connection reported
// or possibly error. Also srt_epoll_wait never returns 0 - at least the number
// of ready connections is reported or -1 is returned for error, including timeout.
if (st < 1)
{
fprintf(stderr, "srt_epoll_wait: %s\n", srt_getlasterror_str());
return 0;
}
// Check if this was reported as error-ready, in which case it doesn't
// matter if read-ready.
if (ready_err[0] == ss)
{
fprintf(stderr, "srt_epoll_wait: socket @%d reported error\n", ss);
return 0;
}
if (ready_in[0] != ss)
{
fprintf(stderr, "srt_epoll_wait: socket @%d not reported ready\n", ss);
return 0;
}
return 1;
}
int main(int argc, char** argv)
{
int globstatus = 0;
int ss, st;
struct sockaddr_in sa;
int yes = 1;
struct sockaddr_storage their_addr;
SRT_SOCKGROUPDATA* grpdata = NULL;
if (argc < 3 || argc > 4)
{
fprintf(stderr, "Usage: %s [options]\n", argv[0]);
return 1;
}
printf("srt startup\n");
srt_startup();
// Since now, srt_cleanup() must be done before exiting.
printf("srt socket\n");
ss = srt_create_socket();
if (ss == SRT_ERROR)
{
fprintf(stderr, "srt_socket: %s\n", srt_getlasterror_str());
globstatus = 1;
goto cleanup;
}
// Now that the socket is created, jump to 'end' on error.
// Check options
int is_nonblocking = 0;
SRTSOCKET their_fd = SRT_INVALID_SOCK; // declared early because of gotos
int eid = -1;
int lsn_modes = SRT_EPOLL_IN | SRT_EPOLL_ERR;
int read_modes = lsn_modes;
if (argc > 3)
{
const char* opt = argv[3];
if (strchr(opt, 'n'))
is_nonblocking = 1;
}
printf("srt bind address\n");
if (0 == strcmp(argv[1], "0"))
{
memset(&sa, 0, sizeof sa);
}
else if (inet_pton(AF_INET, argv[1], &sa.sin_addr) != 1)
{
fprintf(stderr, "srt_bind: Can't resolve address: %s\n", argv[1]);
globstatus = 1;
goto end;
}
sa.sin_family = AF_INET;
sa.sin_port = htons(atoi(argv[2]));
printf("srt setsockflag: groupconnect\n");
srt_setsockflag(ss, SRTO_GROUPCONNECT, &yes, sizeof yes);
printf("srt bind\n");
st = srt_bind(ss, (struct sockaddr*)&sa, sizeof sa);
if (st == SRT_ERROR)
{
fprintf(stderr, "srt_bind: %s\n", srt_getlasterror_str());
globstatus = 1;
goto end;
}
if (is_nonblocking)
{
int blockingmode = 0;
srt_setsockflag(ss, SRTO_RCVSYN, &blockingmode, sizeof (blockingmode));
eid = srt_epoll_create();
srt_epoll_add_usock(eid, ss, &lsn_modes);
}
printf("srt listen\n");
// We set here 10, just for a case. Every unit in this number
// defines a maximum number of connections that can be pending
// simultaneously - it doesn't matter here if particular connection
// will belong to a bonding group or will be a single-socket connection.
st = srt_listen(ss, 10);
if (st == SRT_ERROR)
{
fprintf(stderr, "srt_listen: %s\n", srt_getlasterror_str());
globstatus = 1;
goto end;
}
// In this example, there will be prepared an array of 10 items.
// The listener, however, doesn't know how many member connections
// one bonded connection will contain, so a real application should be
// prepared for dynamically adjusting the array size.
const size_t N = 10;
grpdata = calloc(N, sizeof (SRT_SOCKGROUPDATA));
// In non-blocking mode you can't call srt_accept immediately.
// You must first wait for readiness on the listener socket.
if (is_nonblocking)
{
printf("srt wait for listener socket reporting in a new connection\n");
if (!WaitForReadReady(eid, ss))
goto end;
}
printf("srt accept\n");
int addr_size = sizeof their_addr;
their_fd = srt_accept(ss, (struct sockaddr *)&their_addr, &addr_size);
if (their_fd == -1)
{
fprintf(stderr, "srt_accept: %s\n", srt_getlasterror_str());
goto end;
}
printf("accepted socket: @%d\n", their_fd);
// You never know if `srt_accept` is going to give you a socket or a group.
// You have to check it on your own. The SRTO_GROUPCONNECT flag doesn't disallow
// single socket connections.
int isgroup = their_fd & SRTGROUP_MASK;
if (!isgroup)
{
fprintf(stderr, "srt_accept: Accepted @%d is not a group???\n", their_fd);
goto end;
}
if (is_nonblocking)
{
// NOTE: The SRTO_RCVSYN = false flag will be derived from
// the listener socket and we are going to read, so it matches
// the need. In case when you'd like to write to the accepted
// socket, you'd have to set also SRTO_SNDSYN = false.
srt_epoll_add_usock(eid, their_fd, &read_modes);
// The listener socket is no longer important.
srt_epoll_remove_usock(eid, ss);
}
// Still, use the same procedure for receiving, no matter if
// this is a bonded or single connection.
int i;
for (i = 0; i < 100; i++)
{
printf("srt recvmsg #%d... ",i);
char msg[2048];
SRT_MSGCTRL mc = srt_msgctrl_default;
mc.grpdata = grpdata;
mc.grpdata_size = N;
if (is_nonblocking)
{
// Block in epoll as srt_recvmsg2 will not block.
if (!WaitForReadReady(eid, their_fd))
goto end;
}
st = srt_recvmsg2(their_fd, msg, sizeof msg, &mc);
if (st == SRT_ERROR)
{
fprintf(stderr, "srt_recvmsg: %s\n", srt_getlasterror_str());
goto end;
}
printf("Got msg of len %d << %s (%s)\n", st, msg, isgroup ? "group" : "single");
if (!isgroup)
continue;
if (!mc.grpdata)
printf("Group status: [%zi] members > %zi, can't handle.\n", mc.grpdata_size, N);
else
{
printf(" ++ Group status [%zi]: ", mc.grpdata_size);
size_t z;
for (z = 0; z < mc.grpdata_size; ++z)
{
printf( "[%zd] result=%d state=%s ", z, mc.grpdata[z].result,
mc.grpdata[z].sockstate <= SRTS_CONNECTING ? "pending" :
mc.grpdata[z].sockstate == SRTS_CONNECTED ? "connected" : "broken");
}
printf("\n");
}
}
end:
if (eid != -1)
{
srt_epoll_release(eid);
}
free(grpdata);
printf("srt close\n");
st = srt_close(their_fd); // just for a case; broken socket should be wiped out anyway
if (st == SRT_ERROR)
{
fprintf(stderr, "srt_close: %s\n", srt_getlasterror_str());
// But not matter, we're finishing here.
}
st = srt_close(ss);
if (st == SRT_ERROR)
{
fprintf(stderr, "srt_close: %s\n", srt_getlasterror_str());
// But not matter, we're finishing here.
}
cleanup:
printf("srt cleanup\n");
srt_cleanup();
return globstatus;
}