webrtc_sctp_recv (webrtc v0.1.0)

View Source

SCTP receive side: TSN tracking, SACK generation, reassembly and ordered delivery (RFC 9260 §6.2, §6.6, §6.7, §6.9, RFC 3758 §3.6, RFC 8260 §2.2.3, RFC 6525 §5.2.2).

Internal module of webrtc_sctp_assoc. The state is a #rcv{} record. Complete messages are returned as {message, Sid, Ppid, Data} events as soon as they can be delivered, so the receive buffer only holds fragments and ordered messages waiting for an earlier one. The advertised window is the configured buffer minus those bytes.

Summary

Functions

True when received data was not acknowledged yet (a SACK should be bundled with outgoing DATA, §6.1).

Build a SACK that fits in Room bytes (chunk included).

Complete deferred resets whose last TSN is now cumulatively received, then process the chunks held back for them (E4).

Is the request Seq still deferred?

Called once all chunks of a packet were processed: decide between an immediate and a delayed SACK.

Reset incoming streams once every TSN up to the sender's last assigned TSN was received; defer otherwise (E2).

Types

event/0

-type event() ::
          {message, 0..65535, 0..4294967295, binary()} |
          {message_too_large, 0..65535} |
          {stream_reset, [0..65535]}.

Functions

a_rwnd(Rcv)

-spec a_rwnd(#rcv{idata :: boolean(),
                  mis :: non_neg_integer(),
                  rbuf :: pos_integer(),
                  max_msg :: pos_integer(),
                  cum :: integer(),
                  highest :: integer(),
                  seen :: gb_sets:set(integer()),
                  dups :: [non_neg_integer()],
                  bytes :: non_neg_integer(),
                  streams ::
                      #{0..65535 =>
                            #istream{next :: non_neg_integer(),
                                     pending :: #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                  ra ::
                      #{term() =>
                            #ra{frags ::
                                    #{integer() => {boolean(), boolean(), non_neg_integer(), binary()}},
                                first :: undefined | integer(),
                                last :: undefined | integer(),
                                bytes :: non_neg_integer()}},
                  deferred :: [{integer(), [0..65535], non_neg_integer()}],
                  held ::
                      [{integer(),
                        #sctp_data{idata :: boolean(),
                                   tsn :: 0..4294967295,
                                   sid :: 0..65535,
                                   mid :: 0..4294967295,
                                   fsn :: 0..4294967295,
                                   ppid :: 0..4294967295,
                                   unordered :: boolean(),
                                   beginning :: boolean(),
                                   ending :: boolean(),
                                   immediate :: boolean(),
                                   data :: binary()}}],
                  discard :: #{0..65535 => true},
                  got_data :: boolean(),
                  first :: boolean(),
                  gap :: boolean(),
                  only_dups :: boolean(),
                  sack_now :: boolean(),
                  packets :: non_neg_integer(),
                  sack_at :: undefined | integer(),
                  sack_delay :: non_neg_integer(),
                  sack_freq :: pos_integer(),
                  stats :: #{atom() => non_neg_integer()}}) ->
                non_neg_integer().

ack_pending(Rcv)

-spec ack_pending(#rcv{idata :: boolean(),
                       mis :: non_neg_integer(),
                       rbuf :: pos_integer(),
                       max_msg :: pos_integer(),
                       cum :: integer(),
                       highest :: integer(),
                       seen :: gb_sets:set(integer()),
                       dups :: [non_neg_integer()],
                       bytes :: non_neg_integer(),
                       streams ::
                           #{0..65535 =>
                                 #istream{next :: non_neg_integer(),
                                          pending ::
                                              #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                       ra ::
                           #{term() =>
                                 #ra{frags ::
                                         #{integer() =>
                                               {boolean(), boolean(), non_neg_integer(), binary()}},
                                     first :: undefined | integer(),
                                     last :: undefined | integer(),
                                     bytes :: non_neg_integer()}},
                       deferred :: [{integer(), [0..65535], non_neg_integer()}],
                       held ::
                           [{integer(),
                             #sctp_data{idata :: boolean(),
                                        tsn :: 0..4294967295,
                                        sid :: 0..65535,
                                        mid :: 0..4294967295,
                                        fsn :: 0..4294967295,
                                        ppid :: 0..4294967295,
                                        unordered :: boolean(),
                                        beginning :: boolean(),
                                        ending :: boolean(),
                                        immediate :: boolean(),
                                        data :: binary()}}],
                       discard :: #{0..65535 => true},
                       got_data :: boolean(),
                       first :: boolean(),
                       gap :: boolean(),
                       only_dups :: boolean(),
                       sack_now :: boolean(),
                       packets :: non_neg_integer(),
                       sack_at :: undefined | integer(),
                       sack_delay :: non_neg_integer(),
                       sack_freq :: pos_integer(),
                       stats :: #{atom() => non_neg_integer()}}) ->
                     boolean().

True when received data was not acknowledged yet (a SACK should be bundled with outgoing DATA, §6.1).

add_streams(N, Rcv)

-spec add_streams(non_neg_integer(),
                  #rcv{idata :: boolean(),
                       mis :: non_neg_integer(),
                       rbuf :: pos_integer(),
                       max_msg :: pos_integer(),
                       cum :: integer(),
                       highest :: integer(),
                       seen :: gb_sets:set(integer()),
                       dups :: [non_neg_integer()],
                       bytes :: non_neg_integer(),
                       streams ::
                           #{0..65535 =>
                                 #istream{next :: non_neg_integer(),
                                          pending ::
                                              #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                       ra ::
                           #{term() =>
                                 #ra{frags ::
                                         #{integer() =>
                                               {boolean(), boolean(), non_neg_integer(), binary()}},
                                     first :: undefined | integer(),
                                     last :: undefined | integer(),
                                     bytes :: non_neg_integer()}},
                       deferred :: [{integer(), [0..65535], non_neg_integer()}],
                       held ::
                           [{integer(),
                             #sctp_data{idata :: boolean(),
                                        tsn :: 0..4294967295,
                                        sid :: 0..65535,
                                        mid :: 0..4294967295,
                                        fsn :: 0..4294967295,
                                        ppid :: 0..4294967295,
                                        unordered :: boolean(),
                                        beginning :: boolean(),
                                        ending :: boolean(),
                                        immediate :: boolean(),
                                        data :: binary()}}],
                       discard :: #{0..65535 => true},
                       got_data :: boolean(),
                       first :: boolean(),
                       gap :: boolean(),
                       only_dups :: boolean(),
                       sack_now :: boolean(),
                       packets :: non_neg_integer(),
                       sack_at :: undefined | integer(),
                       sack_delay :: non_neg_integer(),
                       sack_freq :: pos_integer(),
                       stats :: #{atom() => non_neg_integer()}}) ->
                     #rcv{idata :: boolean(),
                          mis :: non_neg_integer(),
                          rbuf :: pos_integer(),
                          max_msg :: pos_integer(),
                          cum :: integer(),
                          highest :: integer(),
                          seen :: gb_sets:set(integer()),
                          dups :: [non_neg_integer()],
                          bytes :: non_neg_integer(),
                          streams ::
                              #{0..65535 =>
                                    #istream{next :: non_neg_integer(),
                                             pending ::
                                                 #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                          ra ::
                              #{term() =>
                                    #ra{frags ::
                                            #{integer() =>
                                                  {boolean(), boolean(), non_neg_integer(), binary()}},
                                        first :: undefined | integer(),
                                        last :: undefined | integer(),
                                        bytes :: non_neg_integer()}},
                          deferred :: [{integer(), [0..65535], non_neg_integer()}],
                          held ::
                              [{integer(),
                                #sctp_data{idata :: boolean(),
                                           tsn :: 0..4294967295,
                                           sid :: 0..65535,
                                           mid :: 0..4294967295,
                                           fsn :: 0..4294967295,
                                           ppid :: 0..4294967295,
                                           unordered :: boolean(),
                                           beginning :: boolean(),
                                           ending :: boolean(),
                                           immediate :: boolean(),
                                           data :: binary()}}],
                          discard :: #{0..65535 => true},
                          got_data :: boolean(),
                          first :: boolean(),
                          gap :: boolean(),
                          only_dups :: boolean(),
                          sack_now :: boolean(),
                          packets :: non_neg_integer(),
                          sack_at :: undefined | integer(),
                          sack_delay :: non_neg_integer(),
                          sack_freq :: pos_integer(),
                          stats :: #{atom() => non_neg_integer()}}.

build_sack(Room, Rcv)

-spec build_sack(pos_integer(),
                 #rcv{idata :: boolean(),
                      mis :: non_neg_integer(),
                      rbuf :: pos_integer(),
                      max_msg :: pos_integer(),
                      cum :: integer(),
                      highest :: integer(),
                      seen :: gb_sets:set(integer()),
                      dups :: [non_neg_integer()],
                      bytes :: non_neg_integer(),
                      streams ::
                          #{0..65535 =>
                                #istream{next :: non_neg_integer(),
                                         pending ::
                                             #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                      ra ::
                          #{term() =>
                                #ra{frags ::
                                        #{integer() =>
                                              {boolean(), boolean(), non_neg_integer(), binary()}},
                                    first :: undefined | integer(),
                                    last :: undefined | integer(),
                                    bytes :: non_neg_integer()}},
                      deferred :: [{integer(), [0..65535], non_neg_integer()}],
                      held ::
                          [{integer(),
                            #sctp_data{idata :: boolean(),
                                       tsn :: 0..4294967295,
                                       sid :: 0..65535,
                                       mid :: 0..4294967295,
                                       fsn :: 0..4294967295,
                                       ppid :: 0..4294967295,
                                       unordered :: boolean(),
                                       beginning :: boolean(),
                                       ending :: boolean(),
                                       immediate :: boolean(),
                                       data :: binary()}}],
                      discard :: #{0..65535 => true},
                      got_data :: boolean(),
                      first :: boolean(),
                      gap :: boolean(),
                      only_dups :: boolean(),
                      sack_now :: boolean(),
                      packets :: non_neg_integer(),
                      sack_at :: undefined | integer(),
                      sack_delay :: non_neg_integer(),
                      sack_freq :: pos_integer(),
                      stats :: #{atom() => non_neg_integer()}}) ->
                    {#rcv{idata :: boolean(),
                          mis :: non_neg_integer(),
                          rbuf :: pos_integer(),
                          max_msg :: pos_integer(),
                          cum :: integer(),
                          highest :: integer(),
                          seen :: gb_sets:set(integer()),
                          dups :: [non_neg_integer()],
                          bytes :: non_neg_integer(),
                          streams ::
                              #{0..65535 =>
                                    #istream{next :: non_neg_integer(),
                                             pending ::
                                                 #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                          ra ::
                              #{term() =>
                                    #ra{frags ::
                                            #{integer() =>
                                                  {boolean(), boolean(), non_neg_integer(), binary()}},
                                        first :: undefined | integer(),
                                        last :: undefined | integer(),
                                        bytes :: non_neg_integer()}},
                          deferred :: [{integer(), [0..65535], non_neg_integer()}],
                          held ::
                              [{integer(),
                                #sctp_data{idata :: boolean(),
                                           tsn :: 0..4294967295,
                                           sid :: 0..65535,
                                           mid :: 0..4294967295,
                                           fsn :: 0..4294967295,
                                           ppid :: 0..4294967295,
                                           unordered :: boolean(),
                                           beginning :: boolean(),
                                           ending :: boolean(),
                                           immediate :: boolean(),
                                           data :: binary()}}],
                          discard :: #{0..65535 => true},
                          got_data :: boolean(),
                          first :: boolean(),
                          gap :: boolean(),
                          only_dups :: boolean(),
                          sack_now :: boolean(),
                          packets :: non_neg_integer(),
                          sack_at :: undefined | integer(),
                          sack_delay :: non_neg_integer(),
                          sack_freq :: pos_integer(),
                          stats :: #{atom() => non_neg_integer()}},
                     #sctp_sack{cum_tsn :: 0..4294967295,
                                a_rwnd :: 0..4294967295,
                                gaps :: [{0..65535, 0..65535}],
                                dups :: [0..4294967295]}}.

Build a SACK that fits in Room bytes (chunk included).

check_deferred(Rcv)

-spec check_deferred(#rcv{idata :: boolean(),
                          mis :: non_neg_integer(),
                          rbuf :: pos_integer(),
                          max_msg :: pos_integer(),
                          cum :: integer(),
                          highest :: integer(),
                          seen :: gb_sets:set(integer()),
                          dups :: [non_neg_integer()],
                          bytes :: non_neg_integer(),
                          streams ::
                              #{0..65535 =>
                                    #istream{next :: non_neg_integer(),
                                             pending ::
                                                 #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                          ra ::
                              #{term() =>
                                    #ra{frags ::
                                            #{integer() =>
                                                  {boolean(), boolean(), non_neg_integer(), binary()}},
                                        first :: undefined | integer(),
                                        last :: undefined | integer(),
                                        bytes :: non_neg_integer()}},
                          deferred :: [{integer(), [0..65535], non_neg_integer()}],
                          held ::
                              [{integer(),
                                #sctp_data{idata :: boolean(),
                                           tsn :: 0..4294967295,
                                           sid :: 0..65535,
                                           mid :: 0..4294967295,
                                           fsn :: 0..4294967295,
                                           ppid :: 0..4294967295,
                                           unordered :: boolean(),
                                           beginning :: boolean(),
                                           ending :: boolean(),
                                           immediate :: boolean(),
                                           data :: binary()}}],
                          discard :: #{0..65535 => true},
                          got_data :: boolean(),
                          first :: boolean(),
                          gap :: boolean(),
                          only_dups :: boolean(),
                          sack_now :: boolean(),
                          packets :: non_neg_integer(),
                          sack_at :: undefined | integer(),
                          sack_delay :: non_neg_integer(),
                          sack_freq :: pos_integer(),
                          stats :: #{atom() => non_neg_integer()}}) ->
                        {#rcv{idata :: boolean(),
                              mis :: non_neg_integer(),
                              rbuf :: pos_integer(),
                              max_msg :: pos_integer(),
                              cum :: integer(),
                              highest :: integer(),
                              seen :: gb_sets:set(integer()),
                              dups :: [non_neg_integer()],
                              bytes :: non_neg_integer(),
                              streams ::
                                  #{0..65535 =>
                                        #istream{next :: non_neg_integer(),
                                                 pending ::
                                                     #{non_neg_integer() =>
                                                           {non_neg_integer(), binary()}}}},
                              ra ::
                                  #{term() =>
                                        #ra{frags ::
                                                #{integer() =>
                                                      {boolean(),
                                                       boolean(),
                                                       non_neg_integer(),
                                                       binary()}},
                                            first :: undefined | integer(),
                                            last :: undefined | integer(),
                                            bytes :: non_neg_integer()}},
                              deferred :: [{integer(), [0..65535], non_neg_integer()}],
                              held ::
                                  [{integer(),
                                    #sctp_data{idata :: boolean(),
                                               tsn :: 0..4294967295,
                                               sid :: 0..65535,
                                               mid :: 0..4294967295,
                                               fsn :: 0..4294967295,
                                               ppid :: 0..4294967295,
                                               unordered :: boolean(),
                                               beginning :: boolean(),
                                               ending :: boolean(),
                                               immediate :: boolean(),
                                               data :: binary()}}],
                              discard :: #{0..65535 => true},
                              got_data :: boolean(),
                              first :: boolean(),
                              gap :: boolean(),
                              only_dups :: boolean(),
                              sack_now :: boolean(),
                              packets :: non_neg_integer(),
                              sack_at :: undefined | integer(),
                              sack_delay :: non_neg_integer(),
                              sack_freq :: pos_integer(),
                              stats :: #{atom() => non_neg_integer()}},
                         [non_neg_integer()],
                         [event()]}.

Complete deferred resets whose last TSN is now cumulatively received, then process the chunks held back for them (E4).

cum_tsn(Rcv)

-spec cum_tsn(#rcv{idata :: boolean(),
                   mis :: non_neg_integer(),
                   rbuf :: pos_integer(),
                   max_msg :: pos_integer(),
                   cum :: integer(),
                   highest :: integer(),
                   seen :: gb_sets:set(integer()),
                   dups :: [non_neg_integer()],
                   bytes :: non_neg_integer(),
                   streams ::
                       #{0..65535 =>
                             #istream{next :: non_neg_integer(),
                                      pending :: #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                   ra ::
                       #{term() =>
                             #ra{frags ::
                                     #{integer() => {boolean(), boolean(), non_neg_integer(), binary()}},
                                 first :: undefined | integer(),
                                 last :: undefined | integer(),
                                 bytes :: non_neg_integer()}},
                   deferred :: [{integer(), [0..65535], non_neg_integer()}],
                   held ::
                       [{integer(),
                         #sctp_data{idata :: boolean(),
                                    tsn :: 0..4294967295,
                                    sid :: 0..65535,
                                    mid :: 0..4294967295,
                                    fsn :: 0..4294967295,
                                    ppid :: 0..4294967295,
                                    unordered :: boolean(),
                                    beginning :: boolean(),
                                    ending :: boolean(),
                                    immediate :: boolean(),
                                    data :: binary()}}],
                   discard :: #{0..65535 => true},
                   got_data :: boolean(),
                   first :: boolean(),
                   gap :: boolean(),
                   only_dups :: boolean(),
                   sack_now :: boolean(),
                   packets :: non_neg_integer(),
                   sack_at :: undefined | integer(),
                   sack_delay :: non_neg_integer(),
                   sack_freq :: pos_integer(),
                   stats :: #{atom() => non_neg_integer()}}) ->
                 0..4294967295.

deferred_seq(Seq, Rcv)

-spec deferred_seq(non_neg_integer(),
                   #rcv{idata :: boolean(),
                        mis :: non_neg_integer(),
                        rbuf :: pos_integer(),
                        max_msg :: pos_integer(),
                        cum :: integer(),
                        highest :: integer(),
                        seen :: gb_sets:set(integer()),
                        dups :: [non_neg_integer()],
                        bytes :: non_neg_integer(),
                        streams ::
                            #{0..65535 =>
                                  #istream{next :: non_neg_integer(),
                                           pending ::
                                               #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                        ra ::
                            #{term() =>
                                  #ra{frags ::
                                          #{integer() =>
                                                {boolean(), boolean(), non_neg_integer(), binary()}},
                                      first :: undefined | integer(),
                                      last :: undefined | integer(),
                                      bytes :: non_neg_integer()}},
                        deferred :: [{integer(), [0..65535], non_neg_integer()}],
                        held ::
                            [{integer(),
                              #sctp_data{idata :: boolean(),
                                         tsn :: 0..4294967295,
                                         sid :: 0..65535,
                                         mid :: 0..4294967295,
                                         fsn :: 0..4294967295,
                                         ppid :: 0..4294967295,
                                         unordered :: boolean(),
                                         beginning :: boolean(),
                                         ending :: boolean(),
                                         immediate :: boolean(),
                                         data :: binary()}}],
                        discard :: #{0..65535 => true},
                        got_data :: boolean(),
                        first :: boolean(),
                        gap :: boolean(),
                        only_dups :: boolean(),
                        sack_now :: boolean(),
                        packets :: non_neg_integer(),
                        sack_at :: undefined | integer(),
                        sack_delay :: non_neg_integer(),
                        sack_freq :: pos_integer(),
                        stats :: #{atom() => non_neg_integer()}}) ->
                      boolean().

Is the request Seq still deferred?

handle_data(Sctp_data, Rcv)

-spec handle_data(#sctp_data{idata :: boolean(),
                             tsn :: 0..4294967295,
                             sid :: 0..65535,
                             mid :: 0..4294967295,
                             fsn :: 0..4294967295,
                             ppid :: 0..4294967295,
                             unordered :: boolean(),
                             beginning :: boolean(),
                             ending :: boolean(),
                             immediate :: boolean(),
                             data :: binary()},
                  #rcv{idata :: boolean(),
                       mis :: non_neg_integer(),
                       rbuf :: pos_integer(),
                       max_msg :: pos_integer(),
                       cum :: integer(),
                       highest :: integer(),
                       seen :: gb_sets:set(integer()),
                       dups :: [non_neg_integer()],
                       bytes :: non_neg_integer(),
                       streams ::
                           #{0..65535 =>
                                 #istream{next :: non_neg_integer(),
                                          pending ::
                                              #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                       ra ::
                           #{term() =>
                                 #ra{frags ::
                                         #{integer() =>
                                               {boolean(), boolean(), non_neg_integer(), binary()}},
                                     first :: undefined | integer(),
                                     last :: undefined | integer(),
                                     bytes :: non_neg_integer()}},
                       deferred :: [{integer(), [0..65535], non_neg_integer()}],
                       held ::
                           [{integer(),
                             #sctp_data{idata :: boolean(),
                                        tsn :: 0..4294967295,
                                        sid :: 0..65535,
                                        mid :: 0..4294967295,
                                        fsn :: 0..4294967295,
                                        ppid :: 0..4294967295,
                                        unordered :: boolean(),
                                        beginning :: boolean(),
                                        ending :: boolean(),
                                        immediate :: boolean(),
                                        data :: binary()}}],
                       discard :: #{0..65535 => true},
                       got_data :: boolean(),
                       first :: boolean(),
                       gap :: boolean(),
                       only_dups :: boolean(),
                       sack_now :: boolean(),
                       packets :: non_neg_integer(),
                       sack_at :: undefined | integer(),
                       sack_delay :: non_neg_integer(),
                       sack_freq :: pos_integer(),
                       stats :: #{atom() => non_neg_integer()}}) ->
                     {ok,
                      #rcv{idata :: boolean(),
                           mis :: non_neg_integer(),
                           rbuf :: pos_integer(),
                           max_msg :: pos_integer(),
                           cum :: integer(),
                           highest :: integer(),
                           seen :: gb_sets:set(integer()),
                           dups :: [non_neg_integer()],
                           bytes :: non_neg_integer(),
                           streams ::
                               #{0..65535 =>
                                     #istream{next :: non_neg_integer(),
                                              pending ::
                                                  #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                           ra ::
                               #{term() =>
                                     #ra{frags ::
                                             #{integer() =>
                                                   {boolean(), boolean(), non_neg_integer(), binary()}},
                                         first :: undefined | integer(),
                                         last :: undefined | integer(),
                                         bytes :: non_neg_integer()}},
                           deferred :: [{integer(), [0..65535], non_neg_integer()}],
                           held ::
                               [{integer(),
                                 #sctp_data{idata :: boolean(),
                                            tsn :: 0..4294967295,
                                            sid :: 0..65535,
                                            mid :: 0..4294967295,
                                            fsn :: 0..4294967295,
                                            ppid :: 0..4294967295,
                                            unordered :: boolean(),
                                            beginning :: boolean(),
                                            ending :: boolean(),
                                            immediate :: boolean(),
                                            data :: binary()}}],
                           discard :: #{0..65535 => true},
                           got_data :: boolean(),
                           first :: boolean(),
                           gap :: boolean(),
                           only_dups :: boolean(),
                           sack_now :: boolean(),
                           packets :: non_neg_integer(),
                           sack_at :: undefined | integer(),
                           sack_delay :: non_neg_integer(),
                           sack_freq :: pos_integer(),
                           stats :: #{atom() => non_neg_integer()}},
                      [event()],
                      [webrtc_sctp_param:cause()]} |
                     {abort, webrtc_sctp_param:cause()}.

handle_forward_tsn(_, Rcv)

-spec handle_forward_tsn(tuple(),
                         #rcv{idata :: boolean(),
                              mis :: non_neg_integer(),
                              rbuf :: pos_integer(),
                              max_msg :: pos_integer(),
                              cum :: integer(),
                              highest :: integer(),
                              seen :: gb_sets:set(integer()),
                              dups :: [non_neg_integer()],
                              bytes :: non_neg_integer(),
                              streams ::
                                  #{0..65535 =>
                                        #istream{next :: non_neg_integer(),
                                                 pending ::
                                                     #{non_neg_integer() =>
                                                           {non_neg_integer(), binary()}}}},
                              ra ::
                                  #{term() =>
                                        #ra{frags ::
                                                #{integer() =>
                                                      {boolean(),
                                                       boolean(),
                                                       non_neg_integer(),
                                                       binary()}},
                                            first :: undefined | integer(),
                                            last :: undefined | integer(),
                                            bytes :: non_neg_integer()}},
                              deferred :: [{integer(), [0..65535], non_neg_integer()}],
                              held ::
                                  [{integer(),
                                    #sctp_data{idata :: boolean(),
                                               tsn :: 0..4294967295,
                                               sid :: 0..65535,
                                               mid :: 0..4294967295,
                                               fsn :: 0..4294967295,
                                               ppid :: 0..4294967295,
                                               unordered :: boolean(),
                                               beginning :: boolean(),
                                               ending :: boolean(),
                                               immediate :: boolean(),
                                               data :: binary()}}],
                              discard :: #{0..65535 => true},
                              got_data :: boolean(),
                              first :: boolean(),
                              gap :: boolean(),
                              only_dups :: boolean(),
                              sack_now :: boolean(),
                              packets :: non_neg_integer(),
                              sack_at :: undefined | integer(),
                              sack_delay :: non_neg_integer(),
                              sack_freq :: pos_integer(),
                              stats :: #{atom() => non_neg_integer()}}) ->
                            {ok,
                             #rcv{idata :: boolean(),
                                  mis :: non_neg_integer(),
                                  rbuf :: pos_integer(),
                                  max_msg :: pos_integer(),
                                  cum :: integer(),
                                  highest :: integer(),
                                  seen :: gb_sets:set(integer()),
                                  dups :: [non_neg_integer()],
                                  bytes :: non_neg_integer(),
                                  streams ::
                                      #{0..65535 =>
                                            #istream{next :: non_neg_integer(),
                                                     pending ::
                                                         #{non_neg_integer() =>
                                                               {non_neg_integer(), binary()}}}},
                                  ra ::
                                      #{term() =>
                                            #ra{frags ::
                                                    #{integer() =>
                                                          {boolean(),
                                                           boolean(),
                                                           non_neg_integer(),
                                                           binary()}},
                                                first :: undefined | integer(),
                                                last :: undefined | integer(),
                                                bytes :: non_neg_integer()}},
                                  deferred :: [{integer(), [0..65535], non_neg_integer()}],
                                  held ::
                                      [{integer(),
                                        #sctp_data{idata :: boolean(),
                                                   tsn :: 0..4294967295,
                                                   sid :: 0..65535,
                                                   mid :: 0..4294967295,
                                                   fsn :: 0..4294967295,
                                                   ppid :: 0..4294967295,
                                                   unordered :: boolean(),
                                                   beginning :: boolean(),
                                                   ending :: boolean(),
                                                   immediate :: boolean(),
                                                   data :: binary()}}],
                                  discard :: #{0..65535 => true},
                                  got_data :: boolean(),
                                  first :: boolean(),
                                  gap :: boolean(),
                                  only_dups :: boolean(),
                                  sack_now :: boolean(),
                                  packets :: non_neg_integer(),
                                  sack_at :: undefined | integer(),
                                  sack_delay :: non_neg_integer(),
                                  sack_freq :: pos_integer(),
                                  stats :: #{atom() => non_neg_integer()}},
                             [event()]} |
                            {abort, webrtc_sctp_param:cause()}.

new(Cfg)

-spec new(#cfg{local_port :: 0..65535,
               remote_port :: 0..65535,
               mtu :: pos_integer(),
               max_mtu :: pos_integer(),
               os :: 1..65535,
               mis :: 1..65535,
               rbuf :: pos_integer(),
               send_buffer :: pos_integer(),
               max_message_size :: pos_integer(),
               rto_initial :: pos_integer(),
               rto_min :: pos_integer(),
               rto_max :: pos_integer(),
               max_backoff :: pos_integer() | infinity,
               max_burst :: pos_integer(),
               assoc_max_retrans :: non_neg_integer() | infinity,
               max_init_retrans :: non_neg_integer(),
               cookie_life :: pos_integer(),
               hb_interval :: pos_integer() | infinity,
               sack_delay :: 0..500,
               sack_freq :: pos_integer(),
               interleaving :: boolean(),
               zero_checksum :: boolean(),
               secret :: binary()}) ->
             #rcv{idata :: boolean(),
                  mis :: non_neg_integer(),
                  rbuf :: pos_integer(),
                  max_msg :: pos_integer(),
                  cum :: integer(),
                  highest :: integer(),
                  seen :: gb_sets:set(integer()),
                  dups :: [non_neg_integer()],
                  bytes :: non_neg_integer(),
                  streams ::
                      #{0..65535 =>
                            #istream{next :: non_neg_integer(),
                                     pending :: #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                  ra ::
                      #{term() =>
                            #ra{frags ::
                                    #{integer() => {boolean(), boolean(), non_neg_integer(), binary()}},
                                first :: undefined | integer(),
                                last :: undefined | integer(),
                                bytes :: non_neg_integer()}},
                  deferred :: [{integer(), [0..65535], non_neg_integer()}],
                  held ::
                      [{integer(),
                        #sctp_data{idata :: boolean(),
                                   tsn :: 0..4294967295,
                                   sid :: 0..65535,
                                   mid :: 0..4294967295,
                                   fsn :: 0..4294967295,
                                   ppid :: 0..4294967295,
                                   unordered :: boolean(),
                                   beginning :: boolean(),
                                   ending :: boolean(),
                                   immediate :: boolean(),
                                   data :: binary()}}],
                  discard :: #{0..65535 => true},
                  got_data :: boolean(),
                  first :: boolean(),
                  gap :: boolean(),
                  only_dups :: boolean(),
                  sack_now :: boolean(),
                  packets :: non_neg_integer(),
                  sack_at :: undefined | integer(),
                  sack_delay :: non_neg_integer(),
                  sack_freq :: pos_integer(),
                  stats :: #{atom() => non_neg_integer()}}.

next_timeout(Rcv)

-spec next_timeout(#rcv{idata :: boolean(),
                        mis :: non_neg_integer(),
                        rbuf :: pos_integer(),
                        max_msg :: pos_integer(),
                        cum :: integer(),
                        highest :: integer(),
                        seen :: gb_sets:set(integer()),
                        dups :: [non_neg_integer()],
                        bytes :: non_neg_integer(),
                        streams ::
                            #{0..65535 =>
                                  #istream{next :: non_neg_integer(),
                                           pending ::
                                               #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                        ra ::
                            #{term() =>
                                  #ra{frags ::
                                          #{integer() =>
                                                {boolean(), boolean(), non_neg_integer(), binary()}},
                                      first :: undefined | integer(),
                                      last :: undefined | integer(),
                                      bytes :: non_neg_integer()}},
                        deferred :: [{integer(), [0..65535], non_neg_integer()}],
                        held ::
                            [{integer(),
                              #sctp_data{idata :: boolean(),
                                         tsn :: 0..4294967295,
                                         sid :: 0..65535,
                                         mid :: 0..4294967295,
                                         fsn :: 0..4294967295,
                                         ppid :: 0..4294967295,
                                         unordered :: boolean(),
                                         beginning :: boolean(),
                                         ending :: boolean(),
                                         immediate :: boolean(),
                                         data :: binary()}}],
                        discard :: #{0..65535 => true},
                        got_data :: boolean(),
                        first :: boolean(),
                        gap :: boolean(),
                        only_dups :: boolean(),
                        sack_now :: boolean(),
                        packets :: non_neg_integer(),
                        sack_at :: undefined | integer(),
                        sack_delay :: non_neg_integer(),
                        sack_freq :: pos_integer(),
                        stats :: #{atom() => non_neg_integer()}}) ->
                      integer() | infinity.

packet_done(Now, Rcv)

-spec packet_done(integer(),
                  #rcv{idata :: boolean(),
                       mis :: non_neg_integer(),
                       rbuf :: pos_integer(),
                       max_msg :: pos_integer(),
                       cum :: integer(),
                       highest :: integer(),
                       seen :: gb_sets:set(integer()),
                       dups :: [non_neg_integer()],
                       bytes :: non_neg_integer(),
                       streams ::
                           #{0..65535 =>
                                 #istream{next :: non_neg_integer(),
                                          pending ::
                                              #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                       ra ::
                           #{term() =>
                                 #ra{frags ::
                                         #{integer() =>
                                               {boolean(), boolean(), non_neg_integer(), binary()}},
                                     first :: undefined | integer(),
                                     last :: undefined | integer(),
                                     bytes :: non_neg_integer()}},
                       deferred :: [{integer(), [0..65535], non_neg_integer()}],
                       held ::
                           [{integer(),
                             #sctp_data{idata :: boolean(),
                                        tsn :: 0..4294967295,
                                        sid :: 0..65535,
                                        mid :: 0..4294967295,
                                        fsn :: 0..4294967295,
                                        ppid :: 0..4294967295,
                                        unordered :: boolean(),
                                        beginning :: boolean(),
                                        ending :: boolean(),
                                        immediate :: boolean(),
                                        data :: binary()}}],
                       discard :: #{0..65535 => true},
                       got_data :: boolean(),
                       first :: boolean(),
                       gap :: boolean(),
                       only_dups :: boolean(),
                       sack_now :: boolean(),
                       packets :: non_neg_integer(),
                       sack_at :: undefined | integer(),
                       sack_delay :: non_neg_integer(),
                       sack_freq :: pos_integer(),
                       stats :: #{atom() => non_neg_integer()}}) ->
                     #rcv{idata :: boolean(),
                          mis :: non_neg_integer(),
                          rbuf :: pos_integer(),
                          max_msg :: pos_integer(),
                          cum :: integer(),
                          highest :: integer(),
                          seen :: gb_sets:set(integer()),
                          dups :: [non_neg_integer()],
                          bytes :: non_neg_integer(),
                          streams ::
                              #{0..65535 =>
                                    #istream{next :: non_neg_integer(),
                                             pending ::
                                                 #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                          ra ::
                              #{term() =>
                                    #ra{frags ::
                                            #{integer() =>
                                                  {boolean(), boolean(), non_neg_integer(), binary()}},
                                        first :: undefined | integer(),
                                        last :: undefined | integer(),
                                        bytes :: non_neg_integer()}},
                          deferred :: [{integer(), [0..65535], non_neg_integer()}],
                          held ::
                              [{integer(),
                                #sctp_data{idata :: boolean(),
                                           tsn :: 0..4294967295,
                                           sid :: 0..65535,
                                           mid :: 0..4294967295,
                                           fsn :: 0..4294967295,
                                           ppid :: 0..4294967295,
                                           unordered :: boolean(),
                                           beginning :: boolean(),
                                           ending :: boolean(),
                                           immediate :: boolean(),
                                           data :: binary()}}],
                          discard :: #{0..65535 => true},
                          got_data :: boolean(),
                          first :: boolean(),
                          gap :: boolean(),
                          only_dups :: boolean(),
                          sack_now :: boolean(),
                          packets :: non_neg_integer(),
                          sack_at :: undefined | integer(),
                          sack_delay :: non_neg_integer(),
                          sack_freq :: pos_integer(),
                          stats :: #{atom() => non_neg_integer()}}.

Called once all chunks of a packet were processed: decide between an immediate and a delayed SACK.

reset_incoming(Sids, LastW, Seq, Rcv)

-spec reset_incoming([0..65535],
                     0..4294967295,
                     non_neg_integer(),
                     #rcv{idata :: boolean(),
                          mis :: non_neg_integer(),
                          rbuf :: pos_integer(),
                          max_msg :: pos_integer(),
                          cum :: integer(),
                          highest :: integer(),
                          seen :: gb_sets:set(integer()),
                          dups :: [non_neg_integer()],
                          bytes :: non_neg_integer(),
                          streams ::
                              #{0..65535 =>
                                    #istream{next :: non_neg_integer(),
                                             pending ::
                                                 #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                          ra ::
                              #{term() =>
                                    #ra{frags ::
                                            #{integer() =>
                                                  {boolean(), boolean(), non_neg_integer(), binary()}},
                                        first :: undefined | integer(),
                                        last :: undefined | integer(),
                                        bytes :: non_neg_integer()}},
                          deferred :: [{integer(), [0..65535], non_neg_integer()}],
                          held ::
                              [{integer(),
                                #sctp_data{idata :: boolean(),
                                           tsn :: 0..4294967295,
                                           sid :: 0..65535,
                                           mid :: 0..4294967295,
                                           fsn :: 0..4294967295,
                                           ppid :: 0..4294967295,
                                           unordered :: boolean(),
                                           beginning :: boolean(),
                                           ending :: boolean(),
                                           immediate :: boolean(),
                                           data :: binary()}}],
                          discard :: #{0..65535 => true},
                          got_data :: boolean(),
                          first :: boolean(),
                          gap :: boolean(),
                          only_dups :: boolean(),
                          sack_now :: boolean(),
                          packets :: non_neg_integer(),
                          sack_at :: undefined | integer(),
                          sack_delay :: non_neg_integer(),
                          sack_freq :: pos_integer(),
                          stats :: #{atom() => non_neg_integer()}}) ->
                        {done,
                         #rcv{idata :: boolean(),
                              mis :: non_neg_integer(),
                              rbuf :: pos_integer(),
                              max_msg :: pos_integer(),
                              cum :: integer(),
                              highest :: integer(),
                              seen :: gb_sets:set(integer()),
                              dups :: [non_neg_integer()],
                              bytes :: non_neg_integer(),
                              streams ::
                                  #{0..65535 =>
                                        #istream{next :: non_neg_integer(),
                                                 pending ::
                                                     #{non_neg_integer() =>
                                                           {non_neg_integer(), binary()}}}},
                              ra ::
                                  #{term() =>
                                        #ra{frags ::
                                                #{integer() =>
                                                      {boolean(),
                                                       boolean(),
                                                       non_neg_integer(),
                                                       binary()}},
                                            first :: undefined | integer(),
                                            last :: undefined | integer(),
                                            bytes :: non_neg_integer()}},
                              deferred :: [{integer(), [0..65535], non_neg_integer()}],
                              held ::
                                  [{integer(),
                                    #sctp_data{idata :: boolean(),
                                               tsn :: 0..4294967295,
                                               sid :: 0..65535,
                                               mid :: 0..4294967295,
                                               fsn :: 0..4294967295,
                                               ppid :: 0..4294967295,
                                               unordered :: boolean(),
                                               beginning :: boolean(),
                                               ending :: boolean(),
                                               immediate :: boolean(),
                                               data :: binary()}}],
                              discard :: #{0..65535 => true},
                              got_data :: boolean(),
                              first :: boolean(),
                              gap :: boolean(),
                              only_dups :: boolean(),
                              sack_now :: boolean(),
                              packets :: non_neg_integer(),
                              sack_at :: undefined | integer(),
                              sack_delay :: non_neg_integer(),
                              sack_freq :: pos_integer(),
                              stats :: #{atom() => non_neg_integer()}}} |
                        {deferred,
                         #rcv{idata :: boolean(),
                              mis :: non_neg_integer(),
                              rbuf :: pos_integer(),
                              max_msg :: pos_integer(),
                              cum :: integer(),
                              highest :: integer(),
                              seen :: gb_sets:set(integer()),
                              dups :: [non_neg_integer()],
                              bytes :: non_neg_integer(),
                              streams ::
                                  #{0..65535 =>
                                        #istream{next :: non_neg_integer(),
                                                 pending ::
                                                     #{non_neg_integer() =>
                                                           {non_neg_integer(), binary()}}}},
                              ra ::
                                  #{term() =>
                                        #ra{frags ::
                                                #{integer() =>
                                                      {boolean(),
                                                       boolean(),
                                                       non_neg_integer(),
                                                       binary()}},
                                            first :: undefined | integer(),
                                            last :: undefined | integer(),
                                            bytes :: non_neg_integer()}},
                              deferred :: [{integer(), [0..65535], non_neg_integer()}],
                              held ::
                                  [{integer(),
                                    #sctp_data{idata :: boolean(),
                                               tsn :: 0..4294967295,
                                               sid :: 0..65535,
                                               mid :: 0..4294967295,
                                               fsn :: 0..4294967295,
                                               ppid :: 0..4294967295,
                                               unordered :: boolean(),
                                               beginning :: boolean(),
                                               ending :: boolean(),
                                               immediate :: boolean(),
                                               data :: binary()}}],
                              discard :: #{0..65535 => true},
                              got_data :: boolean(),
                              first :: boolean(),
                              gap :: boolean(),
                              only_dups :: boolean(),
                              sack_now :: boolean(),
                              packets :: non_neg_integer(),
                              sack_at :: undefined | integer(),
                              sack_delay :: non_neg_integer(),
                              sack_freq :: pos_integer(),
                              stats :: #{atom() => non_neg_integer()}}}.

Reset incoming streams once every TSN up to the sender's last assigned TSN was received; defer otherwise (E2).

sack_wanted(Now, Rcv)

-spec sack_wanted(integer(),
                  #rcv{idata :: boolean(),
                       mis :: non_neg_integer(),
                       rbuf :: pos_integer(),
                       max_msg :: pos_integer(),
                       cum :: integer(),
                       highest :: integer(),
                       seen :: gb_sets:set(integer()),
                       dups :: [non_neg_integer()],
                       bytes :: non_neg_integer(),
                       streams ::
                           #{0..65535 =>
                                 #istream{next :: non_neg_integer(),
                                          pending ::
                                              #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                       ra ::
                           #{term() =>
                                 #ra{frags ::
                                         #{integer() =>
                                               {boolean(), boolean(), non_neg_integer(), binary()}},
                                     first :: undefined | integer(),
                                     last :: undefined | integer(),
                                     bytes :: non_neg_integer()}},
                       deferred :: [{integer(), [0..65535], non_neg_integer()}],
                       held ::
                           [{integer(),
                             #sctp_data{idata :: boolean(),
                                        tsn :: 0..4294967295,
                                        sid :: 0..65535,
                                        mid :: 0..4294967295,
                                        fsn :: 0..4294967295,
                                        ppid :: 0..4294967295,
                                        unordered :: boolean(),
                                        beginning :: boolean(),
                                        ending :: boolean(),
                                        immediate :: boolean(),
                                        data :: binary()}}],
                       discard :: #{0..65535 => true},
                       got_data :: boolean(),
                       first :: boolean(),
                       gap :: boolean(),
                       only_dups :: boolean(),
                       sack_now :: boolean(),
                       packets :: non_neg_integer(),
                       sack_at :: undefined | integer(),
                       sack_delay :: non_neg_integer(),
                       sack_freq :: pos_integer(),
                       stats :: #{atom() => non_neg_integer()}}) ->
                     boolean().

start(_, Rcv)

-spec start(map(),
            #rcv{idata :: boolean(),
                 mis :: non_neg_integer(),
                 rbuf :: pos_integer(),
                 max_msg :: pos_integer(),
                 cum :: integer(),
                 highest :: integer(),
                 seen :: gb_sets:set(integer()),
                 dups :: [non_neg_integer()],
                 bytes :: non_neg_integer(),
                 streams ::
                     #{0..65535 =>
                           #istream{next :: non_neg_integer(),
                                    pending :: #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                 ra ::
                     #{term() =>
                           #ra{frags ::
                                   #{integer() => {boolean(), boolean(), non_neg_integer(), binary()}},
                               first :: undefined | integer(),
                               last :: undefined | integer(),
                               bytes :: non_neg_integer()}},
                 deferred :: [{integer(), [0..65535], non_neg_integer()}],
                 held ::
                     [{integer(),
                       #sctp_data{idata :: boolean(),
                                  tsn :: 0..4294967295,
                                  sid :: 0..65535,
                                  mid :: 0..4294967295,
                                  fsn :: 0..4294967295,
                                  ppid :: 0..4294967295,
                                  unordered :: boolean(),
                                  beginning :: boolean(),
                                  ending :: boolean(),
                                  immediate :: boolean(),
                                  data :: binary()}}],
                 discard :: #{0..65535 => true},
                 got_data :: boolean(),
                 first :: boolean(),
                 gap :: boolean(),
                 only_dups :: boolean(),
                 sack_now :: boolean(),
                 packets :: non_neg_integer(),
                 sack_at :: undefined | integer(),
                 sack_delay :: non_neg_integer(),
                 sack_freq :: pos_integer(),
                 stats :: #{atom() => non_neg_integer()}}) ->
               #rcv{idata :: boolean(),
                    mis :: non_neg_integer(),
                    rbuf :: pos_integer(),
                    max_msg :: pos_integer(),
                    cum :: integer(),
                    highest :: integer(),
                    seen :: gb_sets:set(integer()),
                    dups :: [non_neg_integer()],
                    bytes :: non_neg_integer(),
                    streams ::
                        #{0..65535 =>
                              #istream{next :: non_neg_integer(),
                                       pending :: #{non_neg_integer() => {non_neg_integer(), binary()}}}},
                    ra ::
                        #{term() =>
                              #ra{frags ::
                                      #{integer() => {boolean(), boolean(), non_neg_integer(), binary()}},
                                  first :: undefined | integer(),
                                  last :: undefined | integer(),
                                  bytes :: non_neg_integer()}},
                    deferred :: [{integer(), [0..65535], non_neg_integer()}],
                    held ::
                        [{integer(),
                          #sctp_data{idata :: boolean(),
                                     tsn :: 0..4294967295,
                                     sid :: 0..65535,
                                     mid :: 0..4294967295,
                                     fsn :: 0..4294967295,
                                     ppid :: 0..4294967295,
                                     unordered :: boolean(),
                                     beginning :: boolean(),
                                     ending :: boolean(),
                                     immediate :: boolean(),
                                     data :: binary()}}],
                    discard :: #{0..65535 => true},
                    got_data :: boolean(),
                    first :: boolean(),
                    gap :: boolean(),
                    only_dups :: boolean(),
                    sack_now :: boolean(),
                    packets :: non_neg_integer(),
                    sack_at :: undefined | integer(),
                    sack_delay :: non_neg_integer(),
                    sack_freq :: pos_integer(),
                    stats :: #{atom() => non_neg_integer()}}.