Stream Control Transmission Protocol 

In computer networking, the Stream Control Transmission Protocol (SCTP) is a Transport Layer protocol, serving in a similar role as the popular protocols TCP and UDP. Indeed, it provides some of the same service features of both, ensuring reliable, in-sequence transport of messages with congestion control.

The protocol was defined by the IETF Signaling Transport (SIGTRAN) working group in 2000. RFC 4960 defines the protocol. RFC 3286 provides an introduction.

In the absence of native SCTP support in operating systems it is possible to tunnel SCTP over UDP,1, as well as mapping TCP API calls to SCTP ones.2

Contents

Message-based multi-streaming

Whereas TCP is stream-oriented, i.e., transports byte streams, SCTP is transaction-oriented, meaning it transports data in one or more messages. A message is a group of bytes sent in one transaction (transmit operation). Although TCP correctly reorders data that arrives out of order, it is concerned only with bytes. It does not honor message boundaries, i.e., the structure of data in terms of their original transmission units at the sender. SCTP, in contrast, conserves message boundaries by operating on whole messages in a fashion similar to the User Datagram Protocol (UDP). This means that a group of bytes that is sent in one transmission operation (transaction) is read exactly as that group, called message, at the receiver.

The term "multi-streaming" refers to the capability of SCTP to transmit several independent streams of messages in parallel, for example transmitting Web page images together with the Web page text. You can think of multi-streaming as bundling several TCP connections into a single SCTP association, operating on messages rather than bytes.

TCP preserves byte order in the stream by assigning a sequence number to each byte. SCTP, on the other hand, assigns a sequence number to each message sent in a stream. This allows independent ordering of messages in different streams. However, message ordering is optional in SCTP; a receiving application may choose to process messages in the order they are received instead of the order they were sent.

Benefits

Benefits of SCTP include:

The designers of SCTP originally intended it for the transport of telephony (Signaling System 7) protocols over IP, with the goal of duplicating some of the reliability attributes of the SS7 signaling network in IP. This IETF effort is known as SIGTRAN. In the meantime, other uses have been proposed, for example the Diameter protocol and Reliable server pooling ("RSerPool").

Motivations

Transmission Control Protocol (TCP) has provided the primary means to transfer data across the Internet in a reliable way.

However, TCP has imposed limitations on several applications. From RFC 4960:

These limitations affect the performance of IP over public switched telephone networks.

Comparison between transport layers

Feature Name UDP TCP SCTP
Connection oriented No Yes Yes
Reliable transport No Yes Yes
Preserve message boundary Yes No Yes
Ordered delivery No Yes Yes
Unordered delivery Yes No Yes
Data checksum Yes Yes Yes
Checksum size (bits) 16 16 32
Path MTU No Yes Yes
Congestion control No Yes Yes
Multiple streams No No Yes
Multi-homing support No No Yes
Bundling / Nagle No Yes Yes

Implementations

The following operating systems implement SCTP:

Various third-party implementations of SCTP exist for other operating systems. FreeBSD contains the SCTP reference implementation.3

Userspace library:

Packet structure

Main article: SCTP packet structure
Bits Bits 0 - 7 8 - 15 16 - 23 24 - 31
+0 Source port Destination port
32 Verification tag
64 Checksum
96 Chunk 1 type Chunk 1 flags Chunk 1 length
128 Chunk 1 data
Chunk N type Chunk N flags Chunk N length
Chunk N data

SCTP packets have a simpler basic structure than TCP or UDP packets. Each consists of two basic sections:

  1. The common header, which occupies the first 12 bytes and is highlighted in blue, and
  2. The data chunks, which occupy the remaining portion of the packet. The first chunk is highlighted in green, and the last of N chunks (Chunk N) is highlighted in red.

Each chunk has a type identifier that is one byte long yielding, at most, 255 different chunk types. RFC 4960 defines a list of chunk types and there are currently 15 types defined. The remainder of the chunk is a two byte length (maximum size of 65,535 bytes) and the data. If the chunk does not form a multiple of 4 bytes (i.e., the length is not a multiple of 4) then it is implicitly padded with zeros which are not included in the chunk length.

References

  1. ^ Ong, Lyndon; Randall R. Stewart; Qiaobing Xie. "Tunneling of SCTP over Single UDP Port".
  2. ^ Bickhar, Ryan; Paul D. Amer; Randall R. Stewart (2007). "Transparent TCP-to-SCTP Translation Shim Layer" (PDF). Retrieved on 2008-09-13.
  3. ^ a b "About FreeBSD's Technological Advances". The FreeBSD Project (2008-03-09). Retrieved on 2008-09-13. Excerpt: SCTP: FreeBSD 7.0 is the reference implementation for the new IETF Stream Control Transmission Protocol (SCTP) protocol, intended to support VoIP, telecommunications, and other applications with strong reliability and variable quality transmission through features such as multi-path delivery, fail-over, and multi-streaming.
  4. ^ "Stream Control Transmission Protocol (SCTP)". Hewlett-Packard Development Company.
  5. ^ "TCP/IP Networking". QNX Developer Support. QNX Software Systems. Retrieved on 2008-09-13.
  6. ^ "Solaris 10 Operating System Networking - Extreme Network Performance". Sun Microsystems. Retrieved on 2008-09-13.

See also

RFC history

External links