Internet Engineering Task Force (IETF) A. Bakker
Request for Comments: 7574 Vrije Universiteit Amsterdam
Category: Standards Track R. Petrocco
ISSN: 2070-1721 V. Grishchenko
Technische Universiteit Delft
July 2015 Peer-to-Peer Streaming Peer Protocol (PPSPP)
The Peer-to-Peer Streaming Peer Protocol (PPSPP) is a protocol for
disseminating the same content to a group of interested parties in a
streaming fashion. PPSPP supports streaming of both prerecorded (on-
demand) and live audio/video content. It is based on the peer-to-
peer paradigm, where clients consuming the content are put on equal
footing with the servers initially providing the content, to create a
system where everyone can potentially provide upload bandwidth. It
has been designed to provide short time-till-playback for the end
user and to prevent disruption of the streams by malicious peers.
PPSPP has also been designed to be flexible and extensible. It can
use different mechanisms to optimize peer uploading, prevent
freeriding, and work with different peer discovery schemes
(centralized trackers or Distributed Hash Tables). It supports
multiple methods for content integrity protection and chunk
addressing. Designed as a generic protocol that can run on top of
various transport protocols, it currently runs on top of UDP using
Low Extra Delay Background Transport (LEDBAT) for congestion control.
Status of This Memo
This is an Internet Standards Track document.
This document is a product of the Internet Engineering Task Force
(IETF). It represents the consensus of the IETF community. It has
received public review and has been approved for publication by the
Internet Engineering Steering Group (IESG). Further information on
Internet Standards is available in Section 2 of RFC 5741.
Information about the current status of this document, any errata,
and how to provide feedback on it may be obtained at
Copyright (c) 2015 IETF Trust and the persons identified as the
document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents
(http://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents
carefully, as they describe your rights and restrictions with respect
to this document. Code Components extracted from this document must
include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License.
Table of Contents
1. Introduction ....................................................51.1. Purpose ....................................................51.2. Requirements Language ......................................61.3. Terminology ................................................62. Overall Operation ...............................................92.1. Example: Joining a Swarm ...................................92.2. Example: Exchanging Chunks ................................102.3. Example: Leaving a Swarm ..................................103. Messages .......................................................113.1. HANDSHAKE .................................................113.1.1. Handshake Procedure ................................123.2. HAVE ......................................................143.3. DATA ......................................................153.4. ACK .......................................................153.5. INTEGRITY .................................................153.6. SIGNED_INTEGRITY ..........................................163.7. REQUEST ...................................................163.8. CANCEL ....................................................163.9. CHOKE and UNCHOKE .........................................173.10. Peer Address Exchange ....................................173.10.1. PEX_REQ and PEX_RES Messages ......................173.11. Channels .................................................193.12. Keep Alive Signaling .....................................204. Chunk Addressing Schemes .......................................214.1. Start-End Ranges ..........................................214.1.1. Chunk Ranges .......................................214.1.2. Byte Ranges ........................................214.2. Bin Numbers ...............................................224.3. In Messages ...............................................234.3.1. In HAVE Messages ...................................234.3.2. In ACK Messages ....................................24
12.6.10. PEX_RES ..........................................7712.6.11. Unsolicited Messages in General ..................7712.7. Exclude Bad or Broken Peers ..............................7713. References ....................................................7813.1. Normative References .....................................7813.2. Informative References ...................................79
Authors' Addresses ................................................851. Introduction
This document describes the Peer-to-Peer Streaming Peer Protocol
(PPSPP), designed for disseminating the same content to a group of
interested parties in a streaming fashion. PPSPP supports streaming
of both prerecorded (on-demand) and live audio/video content. It is
based on the peer-to-peer paradigm where clients consuming the
content are put on equal footing with the servers initially providing
the content, to create a system where everyone can potentially
provide upload bandwidth.
PPSPP has been designed to provide short time-till-playback for the
end user and to prevent disruption of the streams by malicious peers.
Central in this design is a simple method of identifying content
based on self-certification. In particular, content in PPSPP is
identified by a single cryptographic hash that is the root hash in a
Merkle hash tree calculated recursively from the content [MERKLE]
[ABMRKL]. This self-certifying hash tree allows every peer to
directly detect when a malicious peer tries to distribute fake
content. The tree can be used for both static and live content.
Moreover, it ensures only a small amount of information is needed to
start a download and to verify incoming chunks of content, thus
ensuring short start-up times.
PPSPP has also been designed to be extensible for different
transports and use cases. Hence, PPSPP is a generic protocol that
can run directly on top of UDP, TCP, or other protocols. As such,
PPSPP defines a common set of messages that make up the protocol,
which can have different representations on the wire depending on the
lower-level protocol used. When the lower-level transport allows,
PPSPP can also use different congestion control algorithms.
At present, PPSPP is set to run on top of UDP using LEDBAT for
congestion control [RFC6817]. Using LEDBAT enables PPSPP to serve
the content after playback (seeding) without disrupting the user who
may have moved to different tasks that use its network connection.
PPSPP is also flexible and extensible in the mechanisms it uses to
promote client contribution and prevent freeriding, that is, how to
deal with peers that only download content but never upload to
others. It also allows different schemes for chunk addressing and
content integrity protection, if the defaults are not fit for a
particular use case. In addition, it can work with different peer
discovery schemes, such as centralized trackers or fast Distributed
Hash Tables [JIM11]. Finally, in this default setup, PPSPP maintains
only a small amount of state per peer. A reference implementation of
PPSPP over UDP is available [SWIFTIMPL].
The protocol defined in this document assumes that a peer has already
discovered a list of (initial) peers using, for example, a
centralized tracker [PPSP-TP]. Once a peer has this list of peers,
PPSPP allows the peer to connect to other peers, request chunks of
content, and discover other peers disseminating the same content.
The design of PPSPP is based on our research into making BitTorrent
[BITTORRENT] suitable for streaming content [P2PWIKI]. Most PPSPP
messages have corresponding BitTorrent messages and vice versa.
However, PPSPP is specifically targeted towards streaming audio/video
content and optimizes time-till-playback. It was also designed to be
more flexible and extensible.
1.2. Requirements Language
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in RFC 2119 [RFC2119].
The basic unit of PPSPP communication. A message will have
different representations on the wire depending on the transport
protocol used. Messages are typically multiplexed into a
datagram for transmission.
A sequence of messages that is offered as a unit to the
underlying transport protocol (UDP, etc.). The datagram is
PPSPP's Protocol Data Unit (PDU).
Either a live transmission or a prerecorded multimedia file.
The basic unit in which the content is divided. For example, a
block of N kilobytes. A chunk may be of variable size.
Unique identifier for a chunk of content (e.g., an integer). Its
type depends on the chunk addressing scheme used.
An expression that denotes one or more chunk IDs.
chunk addressing scheme
Scheme for identifying chunks and expressing the chunk
availability map of a peer in a compact fashion.
chunk availability map
The set of chunks a peer has successfully downloaded and checked
the integrity of.
A number denoting a specific binary interval of the content
(i.e., one or more consecutive chunks) in the bin numbers chunk
addressing scheme (see Section 4).
content integrity protection scheme
Scheme for protecting the integrity of the content while it is
being distributed via the peer-to-peer network. That is, methods
for receiving peers to detect whether a requested chunk has been
modified, either maliciously by the sending peer or accidentally
The result of applying a cryptographic hash function, more
specifically a Modification Detection Code (MDC) [HAC01], such as
SHA-256 [FIPS180-4], to a piece of data.
Merkle hash tree
A tree of hashes whose base is formed by the hashes of the chunks
of content, and its higher nodes are calculated by recursively
computing the hash of the concatenation of the two child hashes
(see Section 5.1).
The root in a Merkle hash tree calculated recursively from the
content (see Section 5.1).
The hash of a subtree that is the unit of signing in the Unified
Merkle Tree content authentication scheme for live streaming (see
A group of peers participating in the distribution of the same
Unique identifier for a swarm of peers, in PPSPP a sequence of
bytes. For video on demand with content integrity protection
enabled, the identifier is the so-called root hash of a Merkle
hash tree over the content. For live streaming, the swarm ID is
a public key.
An entity that records the addresses of peers participating in a
swarm, usually for a set of swarms, and makes this membership
information available to other peers on request.
When Peer A is choking Peer B, it means that A is currently not
willing to accept requests for content from B.
Peer A is said to be seeding when A has downloaded a static
content file completely and is now offering it for others to
Peer A is said to be leeching when A has not completely
downloaded a static content file yet or is not offering to upload
it to others.
A logical connection between two peers. The channel concept
allows peers to use the same transport address for communicating
with different peers.
Unique, randomly chosen identifier for a channel, local to each
peer. So the two peers logically connected by a channel each
have a different channel ID for that channel.
A datagram has a heavy payload when it contains DATA messages,
SIGNED_INTEGRITY messages, or a large number of smaller messages.
In this document the prefixes kilo-, mega-, etc., denote base 1024.
2. Overall Operation
The basic unit of communication in PPSPP is the message. Multiple
messages are multiplexed into a single datagram for transmission. A
datagram (and hence the messages it contains) will have different
representations on the wire depending on the transport protocol used
(see Section 8).
The overall operation of PPSPP is illustrated in the following
examples. The examples assume that the content distributed is
static, UDP is used for transport, the Merkle Hash Tree scheme is
used for content integrity protection, and that a specific policy is
used for selecting which chunks to download.
2.1. Example: Joining a Swarm
Consider a user who wants to watch a video. To play the video, the
user clicks on the play button of a HTML5 <video> element shown in
his PPSPP-enabled browser. Imagine this element has a PPSPP URL (to
be defined elsewhere) identifying the video as its source. The
browser passes this URL to its peer-to-peer streaming protocol
handler. Let's call this protocol handler Peer A. Peer A parses the
URL to retrieve the transport address of a peer-to-peer streaming
protocol tracker and swarm metadata of the content. The tracker
address may be optional in the presence of a decentralized tracking
mechanism. The mechanisms for tracking peers are outside of the
scope of this document.
Peer A now registers with the tracker following the peer-to-peer
streaming protocol tracker specification [PPSP-TP] and receives the
IP address and port of peers already in the swarm, say, Peers B, C,
and D. At this point, the PPSPP starts operating. Peer A now sends
a datagram containing a PPSPP HANDSHAKE message to Peers B, C, and D.
This message conveys protocol options. In particular, Peer A
includes the ID of the swarm (part of the swarm metadata) as a
protocol option because the destination peers can listen for multiple
swarms on the same transport address.
Peers B and C respond with datagrams containing a PPSPP HANDSHAKE
message and one or more HAVE messages. A HAVE message conveys (part
of) the chunk availability of a peer; thus, it contains a chunk
specification that denotes what chunks of the content Peers B and C
have, respectively. Peer D sends a datagram with a HANDSHAKE and
HAVE messages, but also with a CHOKE message. The latter indicates
that Peer D is not willing to upload chunks to Peer A at present.
2.2. Example: Exchanging Chunks
In response to Peers B and C, Peer A sends new datagrams to Peers B
and C containing REQUEST messages. A REQUEST message indicates the
chunks that a peer wants to download; thus, it contains a chunk
specification. The REQUEST messages to Peers B and C refer to
disjoint sets of chunks. Peers B and C respond with datagrams
containing HAVE, DATA, and, in this example, INTEGRITY messages. In
the Merkle hash tree content protection scheme (see Section 5.1), the
INTEGRITY messages contain all cryptographic hashes that Peer A needs
to verify the integrity of the content chunk sent in the DATA
message. Using these hashes, Peer A verifies that the chunks
received from Peers B and C are correct against the trusted swarm ID.
Peer A also updates the chunk availability of Peers B and C using the
information in the received HAVE messages. In addition, it passes
the chunks of video to the user's browser for rendering.
After processing, Peer A sends a datagram containing HAVE messages
for the chunks it just received to all its peers. In the datagram to
Peers B and C, it includes an ACK message acknowledging the receipt
of the chunks and adds REQUEST messages for new chunks. ACK messages
are not used when a reliable transport protocol is used. When, for
example, Peer C finds that Peer A obtained a chunk (from Peer B) that
Peer C did not yet have, Peer C's next datagram includes a REQUEST
for that chunk.
Peer D also sends HAVE messages to Peer A when it downloads chunks
from other peers. When Peer D is willing to accept REQUESTs from
Peer A, Peer D sends a datagram with an UNCHOKE message to inform
Peer A. If Peer B or C decides to choke Peer A, they send a CHOKE
message and Peer A should then re-request from other peers. Peers B
and C may continue to send HAVE, REQUEST, or periodic keep-alive
messages such that Peer A keeps sending them HAVE messages.
Once Peer A has received all content (video-on-demand use case), it
stops sending messages to all other peers that have all content
(a.k.a. seeders). Peer A can also contact the tracker or another
source again to obtain more peer addresses.
2.3. Example: Leaving a Swarm
To leave a swarm in a graceful way, Peer A sends a specific HANDSHAKE
message to all its peers (see Section 8.4) and deregisters from the
tracker following the tracker specification [PPSP-TP]. Peers
receiving the datagram should remove Peer A from their current peer
list. If Peer A crashes ungracefully, peers should remove Peer A
from their peer list when they detect it no longer sends messages
(see Section 3.12).
No error codes or responses are used in the protocol; absence of any
response indicates an error. Invalid messages are discarded, and
further communication with the peer SHOULD be stopped. The rationale
is that it is sufficient to classify peers as either good or bad and
only use the good ones. A good peer is a peer that responds with
chunks; a peer that does not respond, or does not respond in time is
classified as bad. The idea is that, in PPSPP, the content is
available from multiple sources (unlike HTTP), so a peer should not
invest too much effort in trying to obtain it from a particular
source. This classification in good or bad allows a peer to deal
with slow, crashed, and (silent) malicious peers.
Multiple messages MUST be multiplexed into a single datagram for
transmission. Messages in a single datagram MUST be processed in the
strict order in which they appear in the datagram. If an invalid
message is found in a datagram, the remaining messages MUST be
For the sake of simplicity, one swarm of peers deals with one content
file or stream only. There is a single division of the content into
chunks that all peers in the swarm adhere to, determined by the
content publisher. Distribution of a collection of files can be done
either by using multiple swarms or by using an external storage
mapping from the linear byte space of a single swarm to different
files, transparent to the protocol. In other words, the audio/video
container format used is outside the scope of this document.
For Peer P to establish communication with Peer Q in Swarm S, the
peers must first exchange HANDSHAKE messages by means of a handshake
procedure. The initiating Peer P needs to know the metadata of Swarm
S, which consists of:
(a) the swarm ID of the content (see Sections 5.1 and 6),
(b) the chunk size used,
(c) the chunk addressing method used,
(d) the content integrity protection method used, and
(e) the Merkle hash tree function used (if applicable).
(f) If automatic content size detection (see Section 5.6) is not
used, the content length is also part of the metadata (for
This document assumes the swarm metadata is obtained from a trusted
source. In addition, Peer P needs to know a transport address for
Peer Q, obtained from a peer discovery/tracking protocol.
The payload of the HANDSHAKE message contains a sequence of protocol
options. The protocol options encode the swarm metadata just
described to enable an end-to-end check to see whether the peers are
in the right swarm. Additionally, the options encode a number of
per-peer configuration parameters. The complete set of protocol
options are specified in Section 7. The HANDSHAKE message also
contains a channel ID for multiplexing communication and security
(see Sections 3.11 and 12.1). A HANDSHAKE message MUST always be the
first message in a datagram.
3.1.1. Handshake Procedure
The handshake procedure for a peer, Peer P, to start communication
with another peer, Peer Q, in Swarm S is now as follows.
1. The first datagram the initiating Peer P sends to Peer Q MUST
start with a HANDSHAKE message. This HANDSHAKE message MUST
* A channel ID, chanP, randomly chosen as specified in
* The metadata of Swarm S, encoded as protocol options, as
specified in Section 7. In particular, the initiating Peer P
MUST include the swarm ID.
* The capabilities of Peer P, in particular, its supported
protocol versions, "Live Discard Window" (in case of a live
swarm) and "Supported Messages", encoded as protocol options.
This first datagram MUST be prefixed with the (destination)
channel ID 0; see Section 3.11. Hence, the datagram contains two
channel IDs: the destination channel ID prefixed to the datagram
and the channel ID chanP included in the HANDSHAKE message inside
the datagram. This datagram MAY also contain some minor
additional payload, e.g., HAVE messages to indicate Peer P's
current progress, but it MUST NOT include any heavy payload
(defined in Section 1.3), such as a DATA message. Allowing minor
payload minimizes the number of initialization round trips, thus
improving time-till-playback. Forbidding heavy payload prevents
an amplification attack (see Section 12.1).
2. The receiving Peer Q checks the HANDSHAKE message from Peer P.
If any check by Peer Q fails, or if Peers P and Q are not in the
same swarm, Peer Q MUST NOT send a HANDSHAKE (or any other)
message back, as the message from Peer P may have been spoofed
(see Section 12.1). Otherwise, if Peer Q is interested in
communicating with Peer P, Peer Q MUST send a datagram to Peer P
that starts with a HANDSHAKE message. This reply HANDSHAKE MUST
* A channel ID, chanQ, randomly chosen as specified in
* The metadata of Swarm S, encoded as protocol options, as
specified in Section 7. In particular, the responding Peer Q
MAY include the swarm ID.
* The capabilities of Peer Q, in particular, its supported
protocol versions, its "Live Discard Window" (in case of a
live swarm) and "Supported Messages", encoded as protocol
This reply datagram MUST be prefixed with the channel ID chanP
sent by Peer P in the first HANDSHAKE message (see Section 3.11).
This reply datagram MAY also contain some minor additional
payload, e.g., HAVE messages to indicate Peer Q's current
progress, or REQUEST messages (see Section 3.7), but it MUST NOT
include any heavy payload.
3. The initiating Peer P checks the reply datagram from Peer Q. If
the reply datagram is not prefixed with (destination) channel ID
chanP, Peer P MUST discard the datagram. Peer P SHOULD continue
to process datagrams from Peer Q that do meet this requirement.
This check prevents interference by spoofing, see Section 12.1.
If Peer P's channel ID is echoed correctly, the initiator Peer P
knows that the addressed Peer Q really responds.
4. Next, Peer P checks the HANDSHAKE message in the datagram from
Peer Q. If any check by Peer P fails, or Peer P is no longer
interested in communicating with Peer Q, Peer P MAY send a
HANDSHAKE message to inform Peer Q it will cease communication.
This closing HANDSHAKE message MUST contain an all zeros channel
ID and a list of protocol options. The list MUST either be empty
or contain the maximum version number Peer P supports, following
the min/max versioning scheme defined in [RFC6709], Section 4.1.
The datagram containing this closing HANDSHAKE message MUST be
prefixed with the (destination) channel ID chanQ. Peer P MAY
also simply cease communication.
5. If the addressed peer, Peer Q, does not respond to initiating
Peer P's first datagram, Peer P MAY resend that datagram until
Peer Q is considered dead, according to the rules specified in
6. If the reply datagram by Peer Q does pass the checks by Peer P,
and Peer P wants to continue interacting with Peer Q, Peer P can
now send REQUEST, PEX_REQ, and other messages to Peer Q.
Datagrams carrying these messages MUST be prefixed with the
channel ID chanQ sent by Peer Q. More specifically, because Peer
P knows that Peer Q really responds, Peer P MAY start sending
Peer Q messages with heavy payload. That means that Peer P MAY
start responding to any REQUEST messages that Peer Q may have
sent in this first reply datagram with DATA messages. Hence,
transfer of chunks can start soon in PPSPP.
7. If Peer Q receives any datagram (apparently) from Peer P that
does not contain channel ID chanQ, Peer Q MUST discard the
datagram but SHOULD continue to process datagrams from Peer P
that do meet this requirement. Once Peer Q receives a datagram
from Peer P that does contain the channel ID chanQ, Peer Q knows
that Peer P really received its reply datagram, and the three-way
handshake and channel establishment is complete. Peer Q MAY now
also start sending messages with heavy payload to Peer P.
8. If Peer P decides it no longer wants to communicate with Peer Q,
or vice versa, the peer SHOULD send a closing HANDSHAKE message
to the other, as described above.
The HAVE message is used to convey which chunks a peer has available
for download. The set of chunks it has available may be expressed
using different chunk addressing and availability map compression
schemes, described in Section 4. HAVE messages can be used both for
sending a complete overview of a peer's chunk availability as well as
for updates to that set.
In particular, whenever a receiving Peer P has successfully checked
the integrity of a chunk, or interval of chunks, it MUST send a HAVE
message to all peers Q1..Qn it wants to allow to download those
chunks. A policy in Peer P determines when the HAVE is sent. Peer P
may send it directly, or Peer P may wait either until it has other
data to send to Peer Qi or until it has received and checked multiple
chunks. The policy will depend on how urgent it is to distribute
this information to the other peers. This urgency is generally
determined in turn by the chunk picking policy (see Section 9.1). In
general, the HAVE messages can be piggybacked onto other messages.
Peers that do not receive HAVE messages are effectively prevented
from downloading the newly available chunks; hence, the HAVE message
can be used as a method of choking.
The HAVE message MUST contain the chunk specification of the received
and verified chunks. A receiving peer MUST NOT send a HAVE message
to peers for which the handshake procedure is still incomplete, see
Section 12.1. A peer SHOULD NOT send a HAVE message to peers that
have the complete content already (e.g., in video-on-demand
The DATA message is used to transfer chunks of content. The DATA
message MUST contain the chunk ID of the chunk and chunk itself. A
peer MAY send the DATA messages for multiple chunks in the same
datagram. The DATA message MAY contain additional information if
needed by the specific congestion control mechanism used. At
present, PPSPP uses LEDBAT [RFC6817] for congestion control, which
requires the current system time to be sent along with the DATA
message, so the current system time MUST be included.
ACK messages MUST be sent to acknowledge received chunks if PPSPP is
run over an unreliable transport protocol. ACK messages MAY be sent
if a reliable transport protocol is used. In the former case, a
receiving peer that has successfully checked the integrity of a
chunk, or interval of chunks C, MUST send an ACK message containing a
chunk specification for C. As LEDBAT is used, an ACK message MUST
contain the one-way delay, computed from the peer's current system
time received in the DATA message. A peer MAY delay sending ACK
messages as defined in the LEDBAT specification [RFC6817].
The INTEGRITY message carries information required by the receiver to
verify the integrity of a chunk. Its payload depends on the content
integrity protection scheme used. When the Merkle Hash Tree scheme
is used, an INTEGRITY message MUST contain a cryptographic hash of a
subtree of the Merkle hash tree and the chunk specification that
identifies the subtree.
As a typical example, when a peer wants to send a chunk and Merkle
hash trees are used, it creates a datagram that consists of several
INTEGRITY messages containing the hashes the receiver needs to verify
the chunk and the actual chunk itself encoded in a DATA message.
What are the necessary hashes and the exact rules for encoding them
into datagrams is specified in Sections 5.3, and 5.4, respectively.
The SIGNED_INTEGRITY message carries digitally signed information
required by the receiver to verify the integrity of a chunk in live
streaming. It logically contains a chunk specification, a timestamp,
and a digital signature. Its exact payload depends on the live
content integrity protection scheme used, see Section 6.1.
While bulk download protocols normally do explicit requests for
certain ranges of data (i.e., use a pull model, for example,
BitTorrent [BITTORRENT]), live streaming protocols quite often use a
push model without requests to save round trips. PPSPP supports both
models of operation.
The REQUEST message is used to request one or more chunks from
another peer. A REQUEST message MUST contain the specification of
the chunks the requester wants to download. A peer receiving a
REQUEST message MAY send out the requested chunks (by means of DATA
messages). When Peer Q receives multiple REQUESTs from the same Peer
P, Peer Q SHOULD process the REQUESTs in the order received.
Multiple REQUEST messages MAY be sent in one datagram, for example,
when a peer wants to request several rare chunks at once.
When live streaming via a push model, a peer receiving REQUESTs also
MAY send some other chunks in case it runs out of requests or for
some other reason. In that case, the only purpose of REQUEST
messages is to provide hints and coordinate peers to avoid
unnecessary data retransmission.
When downloading on-demand or live streaming content, a peer can
request urgent data from multiple peers to increase the probability
of it being delivered on time. In particular, when the specific
chunk picking algorithm (see Section 9.1), detects that a request for
urgent data might not be served on time, a request for the same data
can be sent to a different peer. When a Peer P decides to request
urgent data from a Peer Q, Peer P SHOULD send a CANCEL message to all
the peers to which the data has been previously requested. The
CANCEL message contains the specification of the chunks Peer P no
longer wants to request. In addition, when Peer Q receives a HAVE
message for the urgent data from Peer P, Peer Q MUST also cancel the
previous REQUEST(s) from Peer P. In other words, the HAVE message
acts as an implicit CANCEL.
3.9. CHOKE and UNCHOKE
Peer A can send a CHOKE message to Peer B to signal it will no longer
be responding to REQUEST messages from Peer B, for example, because
Peer A's upload capacity is exhausted. Peer A MAY send a subsequent
UNCHOKE message to signal that it will respond to new REQUESTs from
Peer B again (Peer A SHOULD discard old requests). When Peer B
receives a CHOKE message from Peer A, it MUST NOT send new REQUEST
messages and it cannot expect answers to any outstanding ones, as the
transfer of chunks is choked. When Peer B is choked but receives a
HAVE message from Peer A, it is not automatically unchoked and MUST
NOT send any new REQUEST messages. The CHOKE and UNCHOKE messages
are informational as responding to REQUESTs is OPTIONAL, see
3.10. Peer Address Exchange
3.10.1. PEX_REQ and PEX_RES Messages
Peer Exchange (PEX) messages are common in many peer-to-peer
protocols. They allow peers to exchange the transport addresses of
the peers they are currently interacting with, thereby reducing the
need to contact a central tracker (or Distributed Hash Table) to
discovery new peers. The strength of this mechanism is therefore
that it enables decentralized peer discovery: after an initial
bootstrap, a central tracker is no longer needed. Its weakness is
that it enables a number of attacks, so it should not be used on the
Internet unless extra security measures are in place.
PPSPP supports peer-address exchange on the Internet and in benign
private networks as an OPTIONAL feature (not mandatory to implement)
under certain conditions. The general mechanism works as follows.
To obtain some peer addresses, a Peer A MAY send a PEX_REQ message to
Peer B. Peer B MAY respond with one or more PEX_REScert messages.
Logically, a PEX_REScert reply message contains the address of a
single peer Ci. Peer B MUST have exchanged messages with Peer Ci in
the last 60 seconds to guarantee liveliness. Upon receipt, Peer A
may contact any or none of the returned peers Ci. Alternatively,
peers MAY ignore PEX_REQ and PEX_REScert messages if uninterested in
obtaining new peers or because of security considerations (rate
limiting) or any other reason. The PEX messages can be used to
construct a dedicated tracker peer.
To use PEX in PPSPP on the Internet, two conditions must be met:
1. Peer transport addresses must be relatively stable.
2. A peer must not obtain all its peer addresses through PEX.
The full security analysis for PEX messages can be found in
Section 12.2. Physically, a PEX_REScert message carries a swarm-
membership certificate rather than an IP address and port. A
membership certificate for Peer C states that Peer C at address
(ipC,portC) is part of Swarm S at Time T and is cryptographically
signed by an issuer. The receiver Peer A can check the certificate
for a valid signature by a trusted issuer, the right swarm, and
liveliness and only then consider contacting C. These swarm-
membership certificates correspond to signed node descriptors in
secure decentralized peer sampling services [SPS].
Several designs are possible for the security environment for these
membership certificates. That is, there are different designs
possible for who signs the membership certificates and how public
keys are distributed. Section 12.2.2 describes an example where a
central tracker acts as the Certification Authority.
In a hostile environment, such as the Internet, peers must also
ensure that they do not end up interacting only with malicious peers
when using the peer-address exchange feature. To this extent, peers
MUST ensure that part of their connections are to peers whose
addresses came from a trusted and secured tracker (see
In addition to the PEX_REScert, there are two other PEX reply
messages. The PEX_RESv4 message contains a single IPv4 address and
port. The PEX_RESv6 message contains a single IPv6 address and port.
They MUST only be used in a benign environment, such as a private
network, as they provide no guarantees that the host addressed
actually participates in a PPSPP swarm.
Once a PPSPP implementation has obtained a list of peers (either via
PEX, from a central tracker, or via a Distributed Hash Table (DHT)),
it has to determine which peers to actually contact. In this
process, a PPSPP implementation can benefit from information by
network or content providers to help improve network usage and boost
PPSPP performance. How a peer-to-peer (P2P) system like PPSPP can
perform these optimizations using the Application-Layer Traffic
Optimization (ALTO) protocol is described in detail in [RFC7285],
It is increasingly complex for peers to enable communication between
each other due to NATs and firewalls. Therefore, PPSPP uses a
multiplexing scheme, called channels, to allow multiple swarms to use
the same transport address. Channels loosely correspond to TCP
connections and each channel belongs to a single swarm, as
illustrated in Figure 1. As with TCP connections, a channel is
identified by a unique identifier local to the peer at each end of
the connection (cf. TCP port), which MUST be randomly chosen. In
other words, the two peers connected by a channel use different IDs
to denote the same channel. The IDs are different and random for
security reasons, see Section 12.1.
In the PPSP-over-UDP encapsulation (Section 8.3), when a Channel C
has been established between Peer A and Peer B, the datagrams
containing messages from Peer A to Peer B are prefixed with the four-
byte channel ID allocated by Peer B, and vice versa for datagrams
from Peer B to A. The channel IDs used are exchanged as part of the
handshake procedure, see Section 8.4. In that procedure, the channel
ID with value 0 is used for the datagram that initiates the
handshake. PPSPP can be used in combination with Session Traversal
Utilities for NAT (STUN) [RFC5389].
_________ _________ _________
| | | | | |
| Swarm | | Swarm | | Swarm |
| Mgr | | A | | B |
|_______| |_______| |_______|
| | / \
| | / \
____|____ ____|____ ______/__ _\_______
| | | | | | | |
| Chan | | Chan | | Chan | | Chan |
| 0 | | 481 | | 836 | | 372 |
|_______| |_______| |_______| |_______|
| | | |
| | | |
| UDP |
| port 6778 |
Network stack of a PPSPP peer that is reachable on UDP port 6778 and
is connected via channel 481 to one peer in Swarm A and two peers in
Swarm B via channels 836 and 372, respectively. Channel ID 0 is
special and is used for handshaking.
Figure 13.12. Keep Alive Signaling
A peer SHOULD send a "keep alive" message periodically to each peer
it is interested in, but has no other messages to send to them at
present. The goal of the keep alives is to keep a signaling channel
open to peers that are of interest. Which peers those are is
determined by a policy that decides which peers are of interest now
and in the near future. This document does not prescribe a policy,
but examples of interesting peers are (a) peers that have chunks on
offer that this client needs or (b) peers that currently do not have
interesting chunks on offer (because they are still downloading
themselves, or in live streaming) but gave good performance in the
past. When these peers have new chunks to offer, the peer that kept
a signaling channel open can use them again. Periodically sending
"keep alive" messages prevents other peers declaring the peer dead.
A guideline for declaring a peer dead when using UDP consists of a
three minute delay since that last packet has been received from that
peer and at least three datagrams having been sent to that peer
during the same period. When a peer is declared dead, the channel to
it is closed, no more messages will be sent to that peer and the
local administration about the peer is discarded. Busy servers can
force idle clients to disconnect by not sending keep alives. PPSPP
does not define an explicit message type for "keep alive" messages.
In the PPSP-over-UDP encapsulation they are implemented as simple
datagrams consisting of a four-byte channel ID only, see Sections 8.3