[FIX] Calculate correctly max payload size per UDP packet

apps/srt-file-transmit.cpp

@@ -180,7 +180,7 @@ int parse_args(FileTransmitConfig &cfg, int argc, char** argv)
         return 2;
     }
 
-    cfg.chunk_size    = stoul(Option<OutString>(params, "1456", o_chunk));
+    cfg.chunk_size    = stoul(Option<OutString>(params, "0", o_chunk));
     cfg.skip_flushing = Option<OutBool>(params, false, o_no_flush);
     cfg.bw_report     = stoi(Option<OutString>(params, "0", o_bwreport));
     cfg.stats_report  = stoi(Option<OutString>(params, "0", o_statsrep));
@@ -681,8 +681,11 @@ int main(int argc, char** argv)
     //
     // Set global config variables
     //
-    if (cfg.chunk_size != SRT_LIVE_MAX_PLSIZE)
+    if (cfg.chunk_size != 0)
         transmit_chunk_size = cfg.chunk_size;
+    else
+        transmit_chunk_size = SRT_MAX_PLSIZE_AF_INET;
+
     transmit_stats_writer = SrtStatsWriterFactory(cfg.stats_pf);
     transmit_bw_report = cfg.bw_report;
     transmit_stats_report = cfg.stats_report;

apps/transmitmedia.cpp

@@ -44,7 +44,7 @@ bool g_stats_are_printed_to_stdout = false;
 bool transmit_total_stats = false;
 unsigned long transmit_bw_report = 0;
 unsigned long transmit_stats_report = 0;
-unsigned long transmit_chunk_size = SRT_LIVE_MAX_PLSIZE;
+unsigned long transmit_chunk_size = SRT_MAX_PLSIZE_AF_INET6;
 
 class FileSource: public Source
 {
@@ -179,6 +179,36 @@ void SrtCommon::InitParameters(string host, map<string,string> par)
         m_adapter = host;
     }
 
+    int fam_to_limit_size = AF_INET6; // take the less one as default
+
+    // Try to interpret host and adapter first
+    sockaddr_any host_sa, adapter_sa;
+
+    if (host != "")
+    {
+        host_sa = CreateAddr(host);
+        fam_to_limit_size = host_sa.family();
+        if (fam_to_limit_size == AF_UNSPEC)
+            Error("Failed to interpret 'host' spec: " + host);
+    }
+
+    if (adapter != "" && adapter != host)
+    {
+        adapter_sa = CreateAddr(adapter);
+        fam_to_limit_size = adapter_sa.family();
+
+        if (fam_to_limit_size == AF_UNSPEC)
+            Error("Failed to interpret 'adapter' spec: " + adapter);
+
+        if (host_sa.family() != AF_UNSPEC && host_sa.family() != adapter_sa.family())
+        {
+            Error("Both host and adapter specified and they use different IP versions");
+        }
+    }
+
+    if (fam_to_limit_size != AF_INET)
+        fam_to_limit_size = AF_INET6;
+
     if (par.count("tsbpd") && false_names.count(par.at("tsbpd")))
     {
         m_tsbpdmode = false;
@@ -195,8 +225,9 @@ void SrtCommon::InitParameters(string host, map<string,string> par)
     if ((par.count("transtype") == 0 || par["transtype"] != "file")
         && transmit_chunk_size > SRT_LIVE_DEF_PLSIZE)
     {
-        if (transmit_chunk_size > SRT_LIVE_MAX_PLSIZE)
-            throw std::runtime_error("Chunk size in live mode exceeds 1456 bytes; this is not supported");
+        size_t size_limit = (size_t)SRT_MAX_PLSIZE(fam_to_limit_size);
+        if (transmit_chunk_size > size_limit)
+            throw std::runtime_error(Sprint("Chunk size in live mode exceeds ", size_limit, " bytes; this is not supported"));
 
         par["payloadsize"] = Sprint(transmit_chunk_size);
     }

docs/API/API-functions.md

@@ -172,6 +172,7 @@ Since SRT v1.5.0.
 | [SRT_REJ_GROUP](#SRT_REJ_GROUP)              | 1.4.2     | The group type or some group settings are incompatible for both connection parties                             |
 | [SRT_REJ_TIMEOUT](#SRT_REJ_TIMEOUT)          | 1.4.2     | The connection wasn't rejected, but it timed out                                                               |
 | [SRT_REJ_CRYPTO](#SRT_REJ_CRYPTO)            | 1.5.2     | The connection was rejected due to an unsupported or mismatching encryption mode                               |
+| [SRT_REJ_SETTINGS](#SRT_REJ_SETTINGS)        | 1.6.0     | The connection was rejected because settings on both parties are in collision and cannot negotiate common values |
 | <img width=290px height=1px/>                |           |                                                                                                                |
 
 <h4 id="error-codes">Error Codes</h4>
@@ -3068,6 +3069,21 @@ and above is reserved for "predefined codes" (`SRT_REJC_PREDEFINED` value plus
 adopted HTTP codes). Values above `SRT_REJC_USERDEFINED` are freely defined by
 the application.
 
+#### SRT_REJ_CRYPTO
+
+Settings for `SRTO_CRYPTOMODE` on both parties are not compatible with one another.
+See [`SRTO_CRYPTOMODE`](API-socket-options.md#SRTO_CRYPTOMODE) for details.
+
+#### SRT_REJ_SETTINGS
+
+Settings for various transmission parameters that are supposed to be negotiated
+during the handshake (in order to agree upon a common value) are under restrictions
+that make finding common values for them impossible. Cases include:
+
+* `SRTO_PAYLOADSIZE`, which is nonzero in live mode, is set to a value that
+exceeds the free space in a single packet that results from the value of the
+negotiated MSS value
+
 
 [:arrow_up: &nbsp; Back to List of Functions & Structures](#srt-api-functions)
 

docs/API/API-socket-options.md

@@ -922,20 +922,86 @@ The default value is 0x010000 (SRT v1.0.0).
 
 | OptName              | Since | Restrict | Type       |  Units  | Default  | Range  | Dir | Entity |
 | -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
-| `SRTO_MSS`           |       | pre-bind | `int32_t`  | bytes   | 1500     | 76..   | RW  | GSD    |
-
-Maximum Segment Size. Used for buffer allocation and rate calculation using
-packet counter assuming fully filled packets. Each party can set its own MSS
-value independently. During a handshake the parties exchange MSS values, and
-the lowest is used.
-
-*Generally on the internet MSS is 1500 by default. This is the maximum
-size of a UDP packet and can be only decreased, unless you have some unusual
-dedicated network settings. MSS is not to be confused with the size of the UDP
-payload or SRT payload - this size is the size of the IP packet, including the
-UDP and SRT headers*
-
-THe value of `SRTO_MSS` must not exceed `SRTO_UDP_SNDBUF` or `SRTO_UDP_RCVBUF`.
+| `SRTO_MSS`           |       | pre-bind | `int32_t`  | bytes   | 1500     | 116..  | RW  | GSD    |
+
+Maximum Segment Size. This value represents the maximum size of a UDP packet
+sent by the system. Therefore the value of `SRTO_MSS` must not exceed the
+values of `SRTO_UDP_SNDBUF` or `SRTO_UDP_RCVBUF`. It is used for buffer
+allocation and rate calculation using packet counter assuming fully filled
+packets. 
+
+This value is a sum of:
+
+* IP header (20 bytes for IPv4 or 32 bytes for IPv6)
+* UDP header (8 bytes)
+* SRT header (16 bytes)
+* remaining space (as the maximum payload size available for a packet)
+
+For the default 1500 the "remaining space" part is effectively 1456 for IPv4
+and 1444 for IPv6.
+
+Note that the IP version used here is not the domain of the underlying UDP
+socket, but the in-transmission IP version. This is effectively IPv4 in the
+following cases:
+
+* when the current socket's binding address is of IPv4 domain
+* when the peer's address is an IPv6-mapped-IPv4 address
+
+The IPv6 transmission case is assumed only if the peer's address is a true IPv6 address 
+(not IPv4 mapped). It is then not possible to determine the payload size limit 
+until the connection is established. SRT operations that must allocate any 
+resources according to this value prior to connecting will assume IPv4 transmission 
+because this way, in the worst case, they allocate more space than needed .
+
+This value can be set on both connection parties independently, but after
+connection `SRTO_MSS` gets a negotiated value, which is the lesser
+of the two. If this effective value is too small for either of the
+connection peers, the connection is rejected (or late-rejected on the caller
+side).
+
+This value then controls:
+
+* The maximum size of the payload in a single UDP packet ("remaining space"). 
+
+* The size of the memory space allocated for a single packet in the sender
+and receiver buffers. This value is equal to "SRT header" + "remaining space"
+in the IPv4 layout case (1472 bytes per packet for MSS=1500). The reason for it
+is that some buffer resources are allocated prior to the connection, so this
+value must fit both IPv4 and IPv6 for buffer memory allocation.
+
+The default value of 1500 corresponds to the standard MTU size for network devices. It
+is recommended that this value be set to the maximum MTU size of
+the network device that you will use for the connection.
+
+The recommendations for the value of `SRTO_MSS` differ between file and live modes.
+
+In live mode a single call to the `srt_send*` function may only send data
+that fits in one packet. This size is defined by the `SRTO_PAYLOADSIZE`
+option (defult: 1316), and it is also the size of the data in a single UDP
+packet. To save memory space, you may want then to set `SRTO_MSS` in live mode to
+a value for which the "remaining space" matches the `SRTO_PAYLOADSIZE` value (for
+the default value of 1316 this will be 1360 for IPv4 and 1372 for IPv6). For security reasons, 
+this is not done by default: it may potentially lead to the inability to read an incoming UDP 
+packet if its size is for some reason bigger than the negotiated MSS, which may in turn lead 
+to unpredictable behaviour and hard-to-detect errors. You should set such a value only if 
+the peer is trusted (that is, you can be certain that you will never receive an oversized UDP 
+packet over the link used for the connection). You should also consider the limitations of
+`SRTO_PAYLOADSIZE`.
+
+In the file mode `SRTO_PAYLOADSIZE` has a special value 0 that means no limit
+for one single packet sending, and therefore bigger portions of data are
+internally split into smaller portions, each one using the maximum available
+"remaining space". The best value of `SRTO_MSS` for this case is then equal to
+the current network device's MTU size. Setting a greater value is possible
+(maximum for the system API is 65535), but it may lead to packet fragmentation
+on the system level. This is highly unwanted in SRT because:
+
+* SRT also performs its own fragmentation, so it would be counter-productive
+* It would use more system resources to no advantage
+* SRT is unaware of it, so the resulting statistics would be slightly misleading
+
+System-level packet fragmentation cannot be reliably turned off,
+so safest approach is to avoid it by using appropriate parameters.
 
 [Return to list](#list-of-options)
 
@@ -1032,7 +1098,7 @@ Cases when negotiation succeeds:
 | fec,cols:10          | fec,cols:10,rows:20 | fec,cols:10,rows:20,arq:onreq,layout:even                  
 | fec,layout:staircase | fec,cols:10         | fec,cols:10,rows:1,arq:onreq,layout:staircase 
 
-In these cases the configuration is rejected with SRT_REJ_FILTER code:
+In these cases the configuration is rejected with `SRT_REJ_FILTER` code:
 
 | Peer A                | Peer B              | Error reason
 |-----------------------|---------------------|--------------------------
@@ -1089,12 +1155,51 @@ encrypted connection, they have to simply set the same passphrase.
 | -------------------- | ----- | -------- | ---------- | ------- | -------- | ------ | --- | ------ |
 | `SRTO_PAYLOADSIZE`   | 1.3.0 | pre      | `int32_t`  | bytes   | \*       | 0.. \* | W   | GSD    |
 
-Sets the maximum declared size of a single call to sending function in Live
-mode. When set to 0, there's no limit for a single sending call.
+Sets the data limitation mode and the maximum data size for sending at once.
+
+The default value is 0 in the file mode and 1316 in live mode (this is one of
+the options modified together with `SRTO_TRANSTYPE`).
+
+If the value is 0, this means a "file mode", in which the call to `srt_send*`
+is not limited to a size fitting in one single packet, that is, the supplied
+data will be split into multiple pieces fitting in a single UDP packet, if
+necessary, as well as every packet will use the maximum space available
+in a UDP packet (except the last in the stream or in the message) according to
+the `SRTO_MSS` setting and others that may influence this size (such as
+`SRTO_PACKETFILTER` and `SRTO_CRYPTOMODE`).
+
+If the value is greater than 0, this means a "live mode", and the value
+defines the maximum size of:
+
+* the single call to a sending function (`srt_send*`)
+* the payload supplied in every single data packet
+
+This value can be set to a greater value than the default 1316, but the maximum
+possible value is limited by the following factors:
+
+* 1500 is the default MSS (see `SRTO_MSS`), including headers, which are:
+   * 20 bytes for IPv4 or 32 bytes for IPv6
+   * 8 bytes for UDP
+   * 16 bytes for SRT
+
+This alone gives the limit of 1456 for IPv4 and 1444 for IPv6. This limit may
+be however further decreased in the following cases:
+
+* 4 bytes reserved for FEC, if you use the builtin FEC packet filter (see `SRTO_PACKETFILTER`)
+* 16 bytes reserved for the authentication tag, if you use AES GCM (see `SRTO_CRYPTOMODE`)
+
+**WARNING**: The option setter will reject the setting if this value is too
+great, but note that not every limitation can be checked prior to connection.
+This includes:
+
+* MSS defined by the peer, which may override MSS set in the agent
+* The in-transmission IP version - see `SRTO_MSS` for details
 
-For Live mode: Default value is 1316, but can be increased up to 1456. Note that
-with the `SRTO_PACKETFILTER` option additional header space is usually required,
-which decreases the maximum possible value for `SRTO_PAYLOADSIZE`.
+These values also influence the "remaining space" in the packet to be used for
+payload. If during the handshake it turns out that this "remaining space" is
+less than the value set for `SRTO_PAYLOADSIZE` (including when it remains with
+the default value), the connection will be rejected with the `SRT_REJ_SETTINGS`
+code.
 
 For File mode: Default value is 0 and it's recommended not to be changed.
 

srtcore/api.cpp

@@ -3157,7 +3157,14 @@ void srt::CUDTUnited::updateMux(CUDTSocket* s, const sockaddr_any& reqaddr, cons
         m.m_pSndQueue = new CSndQueue;
         m.m_pSndQueue->init(m.m_pChannel, m.m_pTimer);
         m.m_pRcvQueue = new CRcvQueue;
-        m.m_pRcvQueue->init(128, s->core().maxPayloadSize(), m.m_iIPversion, 1024, m.m_pChannel, m.m_pTimer);
+
+        // We can't use maxPayloadSize() because this value isn't valid until the connection is established.
+        // We need to "think big", that is, allocate a size that would fit both IPv4 and IPv6.
+        const size_t payload_size = s->core().m_config.iMSS - CPacket::HDR_SIZE - CPacket::udpHeaderSize(AF_INET);
+
+        HLOGC(smlog.Debug, log << s->core().CONID() << "updateMux: config rcv queue qsize=" << 128
+                << " plsize=" << payload_size << " hsize=" << 1024);
+        m.m_pRcvQueue->init(128, payload_size, m.m_iIPversion, 1024, m.m_pChannel, m.m_pTimer);
 
         // Rewrite the port here, as it might be only known upon return
         // from CChannel::open.

srtcore/buffer_tools.cpp

@@ -102,12 +102,12 @@ void AvgBufSize::update(const steady_clock::time_point& now, int pkts, int bytes
     m_dTimespanMAvg   = avg_iir_w<1000, double>(m_dTimespanMAvg, timespan_ms, elapsed_ms);
 }
 
-CRateEstimator::CRateEstimator(int /*family*/)
+CRateEstimator::CRateEstimator(int family)
     : m_iInRatePktsCount(0)
     , m_iInRateBytesCount(0)
     , m_InRatePeriod(INPUTRATE_FAST_START_US) // 0.5 sec (fast start)
     , m_iInRateBps(INPUTRATE_INITIAL_BYTESPS)
-    , m_iFullHeaderSize(CPacket::UDP_HDR_SIZE + CPacket::HDR_SIZE)
+    , m_iFullHeaderSize(CPacket::udpHeaderSize(family) + CPacket::HDR_SIZE)
 {}
 
 void CRateEstimator::setInputRateSmpPeriod(int period)