Going Up the Stack
Of course it does not stop at the transport layer and with the use of MPTCP. Customised applications
can do this themselves.
For example, the “mosh” application is an example of a serial form of address agility, where the session
state is a shared secret, and the server will accept a reconnection from any client’s IP address, as long as
the client can demonstrate its knowledge of the shared secret.
Extending the TCP data transfer model to enlist multiple active TCP sessions at the application level in
a load balancing configuration is also possible, in a manner not all that different from MPTCP.
Of course one could take this further and rather than use multiple TCP sessions between the same two
endpoints you could instead share the same server’s data across multiple endpoints, and use multiple
TCP sessions to these multiple servers. At this point you have something that looks remarkably like the
peer-to-peer data distribution architecture.
Another approach is to format the data stream into “messages”, and permit multiple messages to be
sent across diverse paths between the two communicating systems. This approach, SCTP, is similar to
MPTCP in that it can take advantage of multiple addresses to support multiple paths. It combines the
message transaction qualities of UDP with the reliable in-sequenced transport services of TCP. The
problem of course in today’s network is that because it is neither TCP nor UDP many forms of
middleware, including NATs, are often hostile to SCTP and drop SCTP packets. One more cost of the
escalation of middleware in today’s Internet. These days innovation in protocol models is limited by the
rather narrow rules applied by network middleware, and the approximate rule of thumb in today’s
Internet is that its TCP, UDP or middleware fodder!
It has been observed a number of times that the abstraction of a network protocol stack is somewhat
arbitrary, and its possible to address exactly the same set of requirements at many different levels in the
reference stack. In the work on multi-path support in the Internet we've seen approaches that exploit
parallel data streams at the data link layer, the IP layer, within routing, in the transport layer and in the
application layer. Each have their respective strengths and weaknesses.
But what worries me is what happens if you inadvertently encounter a situation where you have all of these approaches active at the same time? Is the outcome one of amazing efficiency, or paralysing complexity?