/*

* SRT - Secure, Reliable, Transport

* Copyright (c) 2018 Haivision Systems Inc.

*

* This Source Code Form is subject to the terms of the Mozilla Public

* License, v. 2.0. If a copy of the MPL was not distributed with this

* file, You can obtain one at http://mozilla.org/MPL/2.0/.

*

*/

/*****************************************************************************

Copyright (c) 2001 - 2011, The Board of Trustees of the University of Illinois.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above

copyright notice, this list of conditions and the

following disclaimer.

* 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.

* Neither the name of the University of Illinois

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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.

*****************************************************************************/

/*****************************************************************************

written by

Yunhong Gu, last updated 02/28/2012

modified by

Haivision Systems Inc.

*****************************************************************************/

// Set this to 5 to fake "lost" handshake packets 5 times in a row

#define SRT_ENABLE_FAKE_LOSS_HS 0

#include "platform_sys.h"

#include "srt_attr_defs.h"

// Linux specific

#ifdef SRT_ENABLE_BINDTODEVICE

#include <linux/if.h>

#endif

#if !HAVE_CXX11

// for pthread_once

#include <pthread.h>

#endif

// Again, just in case when some "smart guy" provided such a global macro

#ifdef min

#undef min

#endif

#ifdef max

#undef max

#endif

#include <cmath>

#include <sstream>

#include <fstream>

#include <algorithm>

#include <iterator>

#include "srt.h"

#include "access_control.h" // Required for SRT_REJX_FALLBACK

#include "queue.h"

#include "api.h"

#include "core.h"

#include "logging.h"

#include "crypto.h"

#include "logging_api.h" // Required due to containing extern srt_logger_config

#include "logger_fas.h"

using namespace std;

using namespace srt::sync;

using namespace srt::logging;

using namespace hvu; // ofmt

#if HVU_ENABLE_LOGGING

static const char* const s_hs_side[] = { "DRAW", "INITIATOR", "RESPONDER" };

#endif

namespace srt

{

static inline char fmt_onoff(bool val) { return val ? '+' : '-'; }

// Mark unused because it's only used in HLOGC

SRT_ATR_UNUSED static inline const char* fmt_yesno(bool val) { return val ? "yes" : "no"; }

const size_t SRT_CMD_HSREQ_MINSZ = 8; // Minimum Compatible (1.x.x) packet size (bytes)

const size_t SRT_CMD_HSREQ_SZ = 12; // Current version packet size

SRT_STATIC_ASSERT(SRT_CMD_HSREQ_SZ <= SRT_CMD_MAXSZ, "error: SRT_CMD_MAXSZ too small");

// Handshake Request (Network Order)

// 0[31..0]: SRT version SRT_DEF_VERSION

// 1[31..0]: Options 0 [ | SRT_OPT_TSBPDSND ][ | SRT_OPT_HAICRYPT ]

// 2[31..16]: TsbPD resv 0

// 2[15..0]: TsbPD delay [0..60000] msec

//

//#define SRT_CMD_HSRSP 2 /* SRT Handshake Response (receiver) */

const size_t SRT_CMD_HSRSP_MINSZ = 8; // Minimum Compatible (1.x.x) packet size (bytes)

const size_t SRT_CMD_HSRSP_SZ = 12; // Current version packet size */

SRT_STATIC_ASSERT(SRT_CMD_HSRSP_SZ <= SRT_CMD_MAXSZ, " error: SRT_CMD_MAXSZ too small");

// Handshake Response (Network Order)

// 0[31..0]: SRT version SRT_DEF_VERSION

// 1[31..0]: Options 0 [ | SRT_OPT_TSBPDRCV [| SRT_OPT_TLPKTDROP ]][ | SRT_OPT_HAICRYPT]

// [ | SRT_OPT_NAKREPORT ] [ | SRT_OPT_REXMITFLG ]

// 2[31..16]: TsbPD resv 0

// 2[15..0]: TsbPD delay [0..60000] msec

//

// IMPORTANT!!! This array must be ordered by value, because std::binary_search is performed on it!

extern const SRT_SOCKOPT srt_post_opt_list [SRT_SOCKOPT_NPOST] = {

SRTO_SNDSYN,

SRTO_RCVSYN,

SRTO_LINGER,

SRTO_SNDTIMEO,

SRTO_RCVTIMEO,

SRTO_MAXBW,

SRTO_INPUTBW,

SRTO_OHEADBW,

SRTO_SNDDROPDELAY,

SRTO_DRIFTTRACER,

SRTO_MININPUTBW,

SRTO_LOSSMAXTTL,

SRTO_MAXREXMITBW

};

const int32_t

SRTO_R_PREBIND = BIT(0), //< cannot be modified after srt_bind()

SRTO_R_PRE = BIT(1), //< cannot be modified after connection is established

SRTO_POST_SPEC = BIT(2); //< executes some action after setting the option

struct SrtOptionAction

{

int flags[SRTO_E_SIZE];

std::map<SRT_SOCKOPT, std::string> private_default;

SrtOptionAction()

{

// Set everything to 0 to clear all flags

// When an option isn't present here, it means that:

// * it is not settable, or

// * the option is POST (non-restricted)

// * it has no post-actions

// The post-action may be defined independently on restrictions.

memset(flags, 0, sizeof flags);

flags[SRTO_MSS] = SRTO_R_PREBIND;

flags[SRTO_FC] = SRTO_R_PRE;

flags[SRTO_SNDBUF] = SRTO_R_PREBIND;

flags[SRTO_RCVBUF] = SRTO_R_PREBIND;

flags[SRTO_UDP_SNDBUF] = SRTO_R_PREBIND;

flags[SRTO_UDP_RCVBUF] = SRTO_R_PREBIND;

flags[SRTO_RENDEZVOUS] = SRTO_R_PRE;

flags[SRTO_REUSEADDR] = SRTO_R_PREBIND;

flags[SRTO_MAXBW] = SRTO_POST_SPEC;

flags[SRTO_SENDER] = SRTO_R_PRE;

flags[SRTO_TSBPDMODE] = SRTO_R_PRE;

flags[SRTO_LATENCY] = SRTO_R_PRE;

flags[SRTO_INPUTBW] = SRTO_POST_SPEC;

flags[SRTO_MININPUTBW] = SRTO_POST_SPEC;

flags[SRTO_OHEADBW] = SRTO_POST_SPEC;

flags[SRTO_PASSPHRASE] = SRTO_R_PRE;

flags[SRTO_PBKEYLEN] = SRTO_R_PRE;

flags[SRTO_IPTTL] = SRTO_R_PREBIND;

flags[SRTO_IPTOS] = SRTO_R_PREBIND;

flags[SRTO_TLPKTDROP] = SRTO_R_PRE;

flags[SRTO_SNDDROPDELAY] = SRTO_POST_SPEC;

flags[SRTO_NAKREPORT] = SRTO_R_PRE;

flags[SRTO_VERSION] = SRTO_R_PRE;

flags[SRTO_CONNTIMEO] = SRTO_R_PRE;

flags[SRTO_LOSSMAXTTL] = SRTO_POST_SPEC;

flags[SRTO_RCVLATENCY] = SRTO_R_PRE;

flags[SRTO_PEERLATENCY] = SRTO_R_PRE;

flags[SRTO_MINVERSION] = SRTO_R_PRE;

flags[SRTO_STREAMID] = SRTO_R_PRE;

flags[SRTO_CONGESTION] = SRTO_R_PRE;

flags[SRTO_MESSAGEAPI] = SRTO_R_PRE;

flags[SRTO_PAYLOADSIZE] = SRTO_R_PRE;

flags[SRTO_TRANSTYPE] = SRTO_R_PREBIND;

flags[SRTO_KMREFRESHRATE] = SRTO_R_PRE;

flags[SRTO_KMPREANNOUNCE] = SRTO_R_PRE;

flags[SRTO_ENFORCEDENCRYPTION] = SRTO_R_PRE;

flags[SRTO_IPV6ONLY] = SRTO_R_PREBIND;

flags[SRTO_PEERIDLETIMEO] = SRTO_R_PRE;

#ifdef SRT_ENABLE_BINDTODEVICE

flags[SRTO_BINDTODEVICE] = SRTO_R_PREBIND;

#endif

#if SRT_ENABLE_BONDING

flags[SRTO_GROUPCONNECT] = SRTO_R_PRE;

flags[SRTO_GROUPMINSTABLETIMEO]= SRTO_R_PRE;

#endif

flags[SRTO_PACKETFILTER] = SRTO_R_PRE;

flags[SRTO_RETRANSMITALGO] = SRTO_R_PRE;

#ifdef SRT_ENABLE_AEAD

flags[SRTO_CRYPTOMODE] = SRTO_R_PRE;

#endif

// For "private" options (not derived from the listener

// socket by an accepted socket) provide below private_default

// to which these options will be reset after blindly

// copying the option object from the listener socket.

// Note that this option cannot have runtime-dependent

// default value, like options affected by SRTO_TRANSTYPE.

// Options may be of different types, but this value should be only

// used as a source of the value. For example, in case of int64_t you'd

// have to place here a string of 8 characters. It should be copied

// always in the hardware order, as this is what will be directly

// passed to a setting function.

private_default[SRTO_STREAMID] = string();

}

};

const SrtOptionAction s_sockopt_action;

CUDTUnited& CUDT::uglobal()

{

static CUDTUnited instance;

return instance;

}

#ifdef SRT_ENABLE_RATE_MEASUREMENT

void RateMeasurement::pickup(const clock_time& time)

{

// Check if the time has passed the period.

clock_interval diff;

if (!passedInterval(time, (diff)))

{

HLOGC(bslog.Debug, log << "RateMeasurement: too early, " << FormatDuration<DUNIT_MS>(diff)

<< " with begin TS=" << FormatTime(m_beginTime) << " now=" << FormatTime(time));

// Still collect data for the current period.

return;

}

// Doesn't matter what `diff` really is. Enough that we have

// this time aligned with 10ms resolution calls 10 times.

Slice slice;

{

// Lock for the moment of taking the data

sync::ScopedLock lk (m_lock);

slice.packets = m_nInstaPackets;

slice.bytes = m_nInstaBytes;

slice.begin_time = m_beginTime;

m_nInstaPackets = 0;

m_nInstaBytes = 0;

m_beginTime = time;

}

HLOGC(bslog.Debug, log << "RateMeasurement: passed " << FormatDuration<DUNIT_MS>(diff)

<< " extracted packets=" << slice.packets << " bytes=" << slice.bytes

<< " now beginTS=" << FormatTime(m_beginTime));

// Ok, now stickpile the slice.

// If the container is empty, do not stockpile empty slices.

if (m_slices.empty() && slice.bytes == 0)

{

HLOGC(bslog.Debug, log << "... NOT COLLECTING packet with " << slice.bytes << " bytes to " << m_slices.size() << " total");

// Empty-to-empty: DO NOT stockpile.

// NOTE: the container is never cleared when it has

// any older data, so this situation is only possible:

// - in the beginning

// - in the long run if it happened that 10 slices in

// a row were empty.

// So in this case we simply wait for having the first

// packets with something notified. We also know that

// the rate was initially 0 and it remains so now.

return;

}

// We either have something and have pushed an empty slice

// or we have pushed filled slice onto the empty container.

// Still, we need at least 5 samples to start measuring.

m_slices.push_back(slice);

// NOTE: this is also a situation that might have happened

// in the beginning, or after a long period without sending.

// If that period happens, the sending rate is also cleared,

// in any case we need to wait for the minimum samples.

if (m_slices.size() < MIN_SLICES)

{

HLOGC(bslog.Debug, log << "... NOT MEASURING: still " << m_slices.size() << " < 5 slices");

return;

}

// Keep track of only 10 last slices

if (m_slices.size() > MAX_SLICES)

{

m_slices.pop_front();

// After a slice was removed, there's already a chance

// that all other slices are also 0. Check the minimum

// number of slices + 1 and drop all that are empty

size_t end_range = 0; // default: nothing to delete

for (size_t i = 0; i < m_slices.size(); ++i)

{

if (i > MIN_SLICES + 1)

break;

if (m_slices[i].bytes > 0)

break;

// This can be skipped and check the next one.

end_range = i;

}

// PARANOID

if (end_range >= m_slices.size())

end_range = m_slices.size() - 1; // at least 1 element must stay

m_slices.erase(m_slices.begin(), m_slices.begin() + end_range);

m_beginTime = m_slices[0].begin_time;

HLOGC(bslog.Debug, log << "... Dropping 1 oldest + " << end_range << " empty slices, TS=" << FormatTime(m_beginTime));

}

// Check also if the begin time is older than 2* period; if so,

// reset it to that value

if (m_slices.size() > 1) // with 1 always m_beginTime = m_slices[0].begin_time

{

clock_time earliest = m_slices[1].begin_time - milliseconds_from(SLICE_INTERVAL_MS*2);

if (m_beginTime < earliest)

{

HLOGC(bslog.Debug, log << "... BEGIN TIME too old TS=" << FormatTime(m_beginTime)

<< " - fixed to " << FormatTime(earliest));

m_beginTime = earliest;

m_slices[0].begin_time = earliest;

}

}

// Ok, so we have enough samples to record the measurement.

// (so we have at least one)

Summary sum (m_slices[0].begin_time);

for (size_t i = 0; i < m_slices.size(); ++i)

{

sum.consume(m_slices[i]);

}

m_currentPktRate = sum.ratePackets(time);

m_currentByteRate = sum.rateBytes(time, m_SysHeaderSize + CPacket::HDR_SIZE);

HLOGC(bslog.Debug, log << "... CALCULATED from " << m_slices.size() << " slices: total TD=" << FormatDuration(time - m_slices[0].begin_time)

<< " packets=" << sum.packets << " bytes=" << sum.bytes << " pkt-rate=" << m_currentPktRate << " byte-rate=" << m_currentByteRate);

}

#endif

SRT_TSA_DISABLED

void CUDT::construct()

{

m_pSndBuffer = NULL;

m_pRcvBuffer = NULL;

m_pSndLossList = NULL;

m_pRcvLossList = NULL;

m_iReorderTolerance = 0;

// How many times so far the packet considered lost has been received

// before TTL expires.

m_iConsecEarlyDelivery = 0;

m_iConsecOrderedDelivery = 0;

m_pMuxer = NULL;

m_MuxNode = SocketHolder::none(); // Mark that it doesn't belong to any multiplexer

m_TransferIPVersion = AF_UNSPEC; // Will be set after connection

// Will be reset to 0 for HSv5, this value is important for HSv4.

m_iSndHsRetryCnt = SRT_MAX_HSRETRY + 1;

m_PeerID = SRT_SOCKID_CONNREQ;

m_bOpened = false;

m_bListening = false;

m_bConnecting = false;

m_bConnected = false;

m_bClosing = false;

m_bShutdown = false;

m_bBreaking = false;

m_bBroken = false;

m_bBreakAsUnstable = false;

// TODO: m_iBrokenCounter should be still set to some default.

m_bPeerHealth = true;

m_RejectReason = SRT_REJ_UNKNOWN;

m_tsLastReqTime.store(steady_clock::time_point());

m_SrtHsSide = HSD_DRAW;

m_uPeerSrtVersion = 0; // Not defined until connected.

m_iTsbPdDelay_ms = 0;

m_iPeerTsbPdDelay_ms = 0;

m_bPeerTsbPd = false;

m_bTsbPd = false;

m_bTsbPdNeedsWakeup = false;

m_bGroupTsbPd = false;

m_bPeerTLPktDrop = false;

m_bBufferWasFull = false;

m_bManaged = false;

// Will be updated on first send

#ifdef SRT_ENABLE_MAXREXMITBW

m_zSndAveragePacketSize = 0;

m_zSndMaxPacketSize = 0;

#endif

// Initialize mutex and condition variables.

initSynch();

// TODO: Uncomment when the callback is implemented.

// m_cbPacketArrival.set(this, &CUDT::defaultPacketArrival);

}

CUDT::CUDT(CUDTSocket* parent)

: m_parent(parent)

#ifdef SRT_ENABLE_MAXREXMITBW

// , m_SndRexmitRate(sync::steady_clock::now())

, m_SndRexmitShaper(CSrtConfig::DEF_MSS)

#endif

, m_iISN(-1)

, m_iPeerISN(-1)

// Explicitly calling constructors of Mutex for the sake of thread sanitizer

// (without this it cannot precisely declare, where particular mutex was created

// and makes it hard to identify the mutex it reported).

, m_RcvTsbPdStartupLock()

, m_ConnectionLock()

, m_SendBlockLock()

, m_RcvBufferLock()

, m_RecvAckLock()

, m_RecvLock()

, m_SendLock()

, m_RcvLossLock()

, m_StatsLock()

{

construct();

(void)SRT_DEF_VERSION;

// Runtime fields

#if SRT_ENABLE_BONDING

m_HSGroupType = SRT_GTYPE_UNDEFINED;

#endif

m_bTLPktDrop = true; // Too-late Packet Drop

m_pCache = NULL;

// This is in order to set it ANY kind of initial value, however

// this value should not be used when not connected and should be

// updated in the handshake. When this value is 0, it means that

// packets shall not be sent, as the other party doesn't have a

// room to receive and store it. Therefore this value should be

// overridden before any sending happens.

m_iFlowWindowSize = 0;

}

CUDT::CUDT(CUDTSocket* parent, const CUDT& ancestor)

: m_parent(parent)

#ifdef SRT_ENABLE_MAXREXMITBW

// , m_SndRexmitRate(sync::steady_clock::now())

, m_SndRexmitShaper(CSrtConfig::DEF_MSS)

#endif

, m_iISN(-1)

, m_iPeerISN(-1)

// Explicit mutex

, m_RcvTsbPdStartupLock()

, m_ConnectionLock()

, m_SendBlockLock()

, m_RcvBufferLock()

, m_RecvAckLock()

, m_RecvLock()

, m_SendLock()

, m_RcvLossLock()

, m_StatsLock()

{

construct();

// XXX Consider all below fields (except m_bReuseAddr) to be put

// into a separate class for easier copying.

m_config = ancestor.m_config;

// Reset values that shall not be derived to default ones.

// These declarations should be consistent with SRTO_R_PRIVATE flag.

for (size_t i = 0; i < Size(s_sockopt_action.flags); ++i)

{

const string* pdef = map_getp(s_sockopt_action.private_default, SRT_SOCKOPT(i));

if (pdef)

{

try

{

// Ignore errors here - this is a development-time granted

// value, not user-provided value.

m_config.set(SRT_SOCKOPT(i), pdef->data(), (int) pdef->size());

}

catch (...)

{

LOGC(gglog.Error, log << "IPE: failed to set a declared default option!");

}

}

}

m_SrtHsSide = ancestor.m_SrtHsSide; // actually it sets it to HSD_RESPONDER

m_bTLPktDrop = ancestor.m_bTLPktDrop;

m_iReorderTolerance = m_config.iMaxReorderTolerance; // Initialize with maximum value

// Runtime

m_pCache = ancestor.m_pCache;

}

CUDT::~CUDT()

{

// release mutex/condition variables

destroySynch();

// destroy the data structures

delete m_pSndBuffer;

delete m_pRcvBuffer;

delete m_pSndLossList;

delete m_pRcvLossList;

}

void CUDT::setOpt(SRT_SOCKOPT optName, const void* optval, int optlen)

{

if (m_bBroken || m_bClosing)

throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);

// Match check (confirm optName as index for s_sockopt_action)

if (int(optName) < 0 || int(optName) >= int(SRTO_E_SIZE))

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

// Restriction check

const int oflags = s_sockopt_action.flags[optName];

ScopedLock cg (m_ConnectionLock);

ScopedLock sendguard (m_SendLock);

ScopedLock recvguard (m_RecvLock);

HLOGC(aclog.Debug,

log << CONID() << "OPTION: #" << optName << " value:" << FormatBinaryString((uint8_t*)optval, optlen));

if (IsSet(oflags, SRTO_R_PREBIND) && m_bOpened)

throw CUDTException(MJ_NOTSUP, MN_ISBOUND, 0);

if (IsSet(oflags, SRTO_R_PRE) && (m_bConnected || m_bConnecting || m_bListening))

throw CUDTException(MJ_NOTSUP, MN_ISCONNECTED, 0);

// Option execution. If this returns -1, there's no such option.

const int status = m_config.set(optName, optval, optlen);

if (status == -1)

{

LOGC(aclog.Error, log << CONID() << "OPTION: #" << optName << " UNKNOWN");

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

}

// Post-action, if applicable

if (IsSet(oflags, SRTO_POST_SPEC) && m_bConnected)

{

switch (optName)

{

case SRTO_MAXBW:

updateCC(TEV_INIT, EventVariant(TEV_INIT_RESET));

break;

case SRTO_INPUTBW:

case SRTO_MININPUTBW:

updateCC(TEV_INIT, EventVariant(TEV_INIT_INPUTBW));

break;

case SRTO_OHEADBW:

updateCC(TEV_INIT, EventVariant(TEV_INIT_OHEADBW));

break;

case SRTO_LOSSMAXTTL:

m_iReorderTolerance = m_config.iMaxReorderTolerance;

default: break;

}

}

}

void CUDT::getOpt(SRT_SOCKOPT optName, void *optval, int &optlen)

{

ScopedLock cg(m_ConnectionLock);

switch (optName)

{

case SRTO_MSS:

*(int *)optval = m_config.iMSS;

optlen = sizeof(int);

break;

case SRTO_SNDSYN:

*(bool *)optval = m_config.bSynSending;

optlen = sizeof(bool);

break;

case SRTO_RCVSYN:

*(bool *)optval = m_config.bSynRecving;

optlen = sizeof(bool);

break;

case SRTO_ISN:

*(int *)optval = m_iISN;

optlen = sizeof(int);

break;

case SRTO_FC:

*(int *)optval = m_config.iFlightFlagSize;

optlen = sizeof(int);

break;

// For SNDBUF/RCVBUF values take the variant that uses more memory.

// It is not possible to make sure what "family" is in use without

// checking if the socket is bound. This will also be the exact size

// of the memory in use.

case SRTO_SNDBUF:

*(int *)optval = m_config.iSndBufSize * m_config.bytesPerPkt();

optlen = sizeof(int);

break;

case SRTO_RCVBUF:

*(int *)optval = m_config.iRcvBufSize * m_config.bytesPerPkt();

optlen = sizeof(int);

break;

case SRTO_LINGER:

if (optlen < (int)(sizeof(linger)))

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

*(linger *)optval = m_config.Linger;

optlen = sizeof(linger);

break;

case SRTO_UDP_SNDBUF:

*(int *)optval = m_config.iUDPSndBufSize;

optlen = sizeof(int);

break;

case SRTO_UDP_RCVBUF:

*(int *)optval = m_config.iUDPRcvBufSize;

optlen = sizeof(int);

break;

case SRTO_RENDEZVOUS:

*(bool *)optval = m_config.bRendezvous;

optlen = sizeof(bool);

break;

case SRTO_SNDTIMEO:

*(int *)optval = m_config.iSndTimeOut;

optlen = sizeof(int);

break;

case SRTO_RCVTIMEO:

*(int *)optval = m_config.iRcvTimeOut;

optlen = sizeof(int);

break;

case SRTO_REUSEADDR:

*(bool *)optval = m_config.bReuseAddr;

optlen = sizeof(bool);

break;

case SRTO_MAXBW:

if (size_t(optlen) < sizeof(m_config.llMaxBW))

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

*(int64_t *)optval = m_config.llMaxBW;

optlen = sizeof(int64_t);

break;

case SRTO_INPUTBW:

if (size_t(optlen) < sizeof(m_config.llInputBW))

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

*(int64_t*)optval = m_config.llInputBW;

optlen = sizeof(int64_t);

break;

case SRTO_MININPUTBW:

if (size_t(optlen) < sizeof (m_config.llMinInputBW))

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

*(int64_t*)optval = m_config.llMinInputBW;

optlen = sizeof(int64_t);

break;

case SRTO_OHEADBW:

*(int32_t *)optval = m_config.iOverheadBW;

optlen = sizeof(int32_t);

break;

#ifdef SRT_ENABLE_MAXREXMITBW

case SRTO_MAXREXMITBW:

if (size_t(optlen) < sizeof(m_config.llMaxRexmitBW))

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

*(int64_t*)optval = m_config.llMaxRexmitBW;

optlen = sizeof(int64_t);

break;

#endif

case SRTO_STATE:

*(int32_t *)optval = uglobal().getStatus(m_SocketID);

optlen = sizeof(int32_t);

break;

case SRTO_EVENT:

{

int32_t event = 0;

if (m_bBroken)

event |= SRT_EPOLL_ERR;

else

{

enterCS(m_RecvLock);

if (m_pRcvBuffer && isRcvBufferReady())

event |= SRT_EPOLL_IN;

leaveCS(m_RecvLock);

if (m_pSndBuffer && (m_config.iSndBufSize > m_pSndBuffer->getCurrBufSize()))

event |= SRT_EPOLL_OUT;

}

*(int32_t *)optval = event;

optlen = sizeof(int32_t);

break;

}

case SRTO_SNDDATA:

if (m_pSndBuffer)

*(int32_t *)optval = m_pSndBuffer->getCurrBufSize();

else

*(int32_t *)optval = 0;

optlen = sizeof(int32_t);

break;

case SRTO_RCVDATA:

if (m_pRcvBuffer)

{

ScopedLock lck(m_RcvBufferLock);

*(int32_t *)optval = m_pRcvBuffer->getRcvDataSize();

}

else

*(int32_t *)optval = 0;

optlen = sizeof(int32_t);

break;

case SRTO_IPTTL:

if (m_bOpened)

*(int32_t *)optval = channel()->getIpTTL();

else

*(int32_t *)optval = m_config.iIpTTL;

optlen = sizeof(int32_t);

break;

case SRTO_IPTOS:

if (m_bOpened)

*(int32_t *)optval = channel()->getIpToS();

else

*(int32_t *)optval = m_config.iIpToS;

optlen = sizeof(int32_t);

break;

case SRTO_BINDTODEVICE:

#ifdef SRT_ENABLE_BINDTODEVICE

if (optlen < IFNAMSIZ)

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

if (m_bOpened && channel()->getBind(((char*)optval), optlen))

{

optlen = strlen((char*)optval);

break;

}

// Fallback: return from internal data

optlen = (int)m_config.sBindToDevice.copy((char*)optval, (size_t)optlen - 1);

((char*)optval)[optlen] = '\0';

#else

LOGC(smlog.Error, log << "SRTO_BINDTODEVICE is not supported on that platform");

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

#endif

break;

case SRTO_SENDER:

*(bool *)optval = m_config.bDataSender;

optlen = sizeof(bool);

break;

case SRTO_TSBPDMODE:

*(bool *)optval = m_config.bTSBPD;

optlen = sizeof(bool);

break;

case SRTO_LATENCY:

case SRTO_RCVLATENCY:

if (m_bConnected)

*(int32_t *)optval = m_iTsbPdDelay_ms;

else

*(int32_t *)optval = m_config.iRcvLatency;

optlen = sizeof(int32_t);

break;

case SRTO_PEERLATENCY:

if (m_bConnected)

*(int32_t *)optval = m_iPeerTsbPdDelay_ms;

else

*(int32_t *)optval = m_config.iPeerLatency;

optlen = sizeof(int32_t);

break;

case SRTO_TLPKTDROP:

if (m_bConnected)

*(bool *)optval = m_bTLPktDrop;

else

*(bool *)optval = m_config.bTLPktDrop;

optlen = sizeof(bool);

break;

case SRTO_SNDDROPDELAY:

*(int32_t *)optval = m_config.iSndDropDelay;

optlen = sizeof(int32_t);

break;

case SRTO_PBKEYLEN:

*(int32_t *)optval = (int32_t) m_CryptoControl.keylen(); // Running Key length.(may be 0)

optlen = sizeof(int32_t);

break;

case SRTO_KMSTATE:

if (m_config.bDataSender)

*(int32_t *)optval = m_CryptoControl.kmState().snd;

else

*(int32_t *)optval = m_CryptoControl.kmState().rcv;

optlen = sizeof(int32_t);

break;

case SRTO_SNDKMSTATE: // State imposed by Agent depending on PW and KMX

*(int32_t *)optval = m_CryptoControl.kmState().snd;

optlen = sizeof(int32_t);

break;

case SRTO_RCVKMSTATE: // State returned by Peer as informed during KMX

*(int32_t *)optval = m_CryptoControl.kmState().rcv;

optlen = sizeof(int32_t);

break;

case SRTO_LOSSMAXTTL:

*(int32_t*)optval = m_config.iMaxReorderTolerance;

optlen = sizeof(int32_t);

break;

case SRTO_NAKREPORT:

*(bool *)optval = m_config.bRcvNakReport;

optlen = sizeof(bool);

break;

case SRTO_VERSION:

*(int32_t *)optval = m_config.uSrtVersion;

optlen = sizeof(int32_t);

break;

case SRTO_PEERVERSION:

*(int32_t *)optval = m_uPeerSrtVersion;

optlen = sizeof(int32_t);

break;

case SRTO_CONNTIMEO:

*(int*)optval = (int) count_milliseconds(m_config.tdConnTimeOut);

optlen = sizeof(int);

break;

case SRTO_DRIFTTRACER:

*(bool*)optval = m_config.bDriftTracer;

optlen = sizeof(bool);

break;

case SRTO_MINVERSION:

*(uint32_t *)optval = m_config.uMinimumPeerSrtVersion;

optlen = sizeof(uint32_t);

break;

case SRTO_STREAMID:

if (size_t(optlen) < m_config.sStreamName.size() + 1)

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

optlen = (int)m_config.sStreamName.copy((char*)optval, (size_t)optlen - 1);

((char*)optval)[optlen] = '\0';

break;

case SRTO_CONGESTION:

if (size_t(optlen) < m_config.sCongestion.size() + 1)

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

optlen = (int)m_config.sCongestion.copy((char*)optval, (size_t)optlen - 1);

((char*)optval)[optlen] = '\0';

break;

case SRTO_MESSAGEAPI:

optlen = sizeof(bool);

*(bool *)optval = m_config.bMessageAPI;

break;

case SRTO_PAYLOADSIZE:

optlen = sizeof(int);

*(int *)optval = (int) payloadSize();

break;

case SRTO_KMREFRESHRATE:

optlen = sizeof(int);

*(int*)optval = (int)m_config.uKmRefreshRatePkt;

break;

case SRTO_KMPREANNOUNCE:

optlen = sizeof(int);

*(int*)optval = (int)m_config.uKmPreAnnouncePkt;

break;

#if SRT_ENABLE_BONDING

case SRTO_GROUPCONNECT:

optlen = sizeof (int);

*(int*)optval = m_config.iGroupConnect;

break;

case SRTO_GROUPMINSTABLETIMEO:

optlen = sizeof(int);

*(int*)optval = (int)m_config.uMinStabilityTimeout_ms;

break;

case SRTO_GROUPTYPE:

optlen = sizeof (int);

*(int*)optval = m_HSGroupType;

break;

#endif

case SRTO_ENFORCEDENCRYPTION:

optlen = sizeof(bool);

*(bool *)optval = m_config.bEnforcedEnc;

break;

case SRTO_IPV6ONLY:

optlen = sizeof(int);

*(int *)optval = m_config.iIpV6Only;

break;

case SRTO_PEERIDLETIMEO:

*(int *)optval = m_config.iPeerIdleTimeout_ms;

optlen = sizeof(int);

break;

case SRTO_PACKETFILTER:

if (size_t(optlen) < m_config.sPacketFilterConfig.size() + 1)

throw CUDTException(MJ_NOTSUP, MN_INVAL, 0);

optlen = (int)m_config.sPacketFilterConfig.copy((char*)optval, (size_t)optlen - 1);

((char*)optval)[optlen] = '\0';

break;

case SRTO_RETRANSMITALGO:

*(int32_t *)optval = m_config.iRetransmitAlgo;

optlen = sizeof(int32_t);

break;

#ifdef SRT_ENABLE_AEAD

case SRTO_CRYPTOMODE:

*(int32_t*)optval = m_CryptoControl.getCryptoMode();

optlen = sizeof(int32_t);

break;

#endif

default:

throw CUDTException(MJ_NOTSUP, MN_NONE, 0);

}

}

#if SRT_ENABLE_BONDING

SRT_ERRNO CUDT::applyMemberConfigObject(const SRT_SocketOptionObject& opt)

{

SRT_SOCKOPT this_opt = SRTO_VERSION;

for (size_t i = 0; i < opt.options.size(); ++i)

{

SRT_SocketOptionObject::SingleOption* o = opt.options[i];

HLOGC(smlog.Debug, log << CONID() << "applyMemberConfigObject: OPTION @" << m_SocketID << " #" << o->option);

this_opt = SRT_SOCKOPT(o->option);

setOpt(this_opt, o->storage, o->length);