blob: 0ecfac0c0ac5ed67f820720fe972b5dba2fe8d5b [file] [log] [blame]
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
#include <stddef.h>
#include <stdint.h>
#include <functional>
#include <vector>
#include "absl/strings/string_view.h"
#include "api/array_view.h"
#include "net/dcsctp/common/sequence_numbers.h"
#include "net/dcsctp/packet/chunk/forward_tsn_common.h"
#include "net/dcsctp/packet/data.h"
#include "net/dcsctp/public/dcsctp_handover_state.h"
#include "net/dcsctp/public/dcsctp_message.h"
namespace dcsctp {
// Implementations of this interface will be called when data is received, when
// data should be skipped/forgotten or when sequence number should be reset.
// As a result of these operations - mainly when data is received - the
// implementations of this interface should notify when a message has been
// assembled, by calling the provided callback of type `OnAssembledMessage`. How
// it assembles messages will depend on e.g. if a message was sent on an ordered
// or unordered stream.
// Implementations will - for each operation - indicate how much additional
// memory that has been used as a result of performing the operation. This is
// used to limit the maximum amount of memory used, to prevent out-of-memory
// situations.
class ReassemblyStreams {
// This callback will be provided as an argument to the constructor of the
// concrete class implementing this interface and should be called when a
// message has been assembled as well as indicating from which TSNs this
// message was assembled from.
using OnAssembledMessage =
std::function<void(rtc::ArrayView<const UnwrappedTSN> tsns,
DcSctpMessage message)>;
virtual ~ReassemblyStreams() = default;
// Adds a data chunk to a stream as identified in `data`.
// If it was the last remaining chunk in a message, reassemble one (or
// several, in case of ordered chunks) messages.
// Returns the additional number of bytes added to the queue as a result of
// performing this operation. If this addition resulted in messages being
// assembled and delivered, this may be negative.
virtual int Add(UnwrappedTSN tsn, Data data) = 0;
// Called for incoming FORWARD-TSN/I-FORWARD-TSN chunks - when the sender
// wishes the received to skip/forget about data up until the provided TSN.
// This is used to implement partial reliability, such as limiting the number
// of retransmissions or the an expiration duration. As a result of skipping
// data, this may result in the implementation being able to assemble messages
// in ordered streams.
// Returns the number of bytes removed from the queue as a result of
// this operation.
virtual size_t HandleForwardTsn(
UnwrappedTSN new_cumulative_ack_tsn,
rtc::ArrayView<const AnyForwardTsnChunk::SkippedStream>
skipped_streams) = 0;
// Called for incoming (possibly deferred) RE_CONFIG chunks asking for
// either a few streams, or all streams (when the list is empty) to be
// reset - to have their next SSN or Message ID to be zero.
virtual void ResetStreams(rtc::ArrayView<const StreamID> stream_ids) = 0;
virtual HandoverReadinessStatus GetHandoverReadiness() const = 0;
virtual void AddHandoverState(DcSctpSocketHandoverState& state) = 0;
virtual void RestoreFromState(const DcSctpSocketHandoverState& state) = 0;
} // namespace dcsctp