Menu

• Main page
• Calendar
• Hostel
• Legoland
• Organizers
• Poster Session
• Spread the word
• Talks
• Tutorials
• Map & Sightseeing
• Print Me
• Social Event
• Transport
• Links

Talk - TCP-to-SCTP Translation Shim Layer in the FreeBSD Kernel

Abstract

Stream Control Transmission Protocol (SCTP) is a connection-oriented, reliable, messaged-based, general purpose transport protocol with TCP-friendly congestion control, supporting advanced features not available in TCP or UDP, such as multistreaming and multihoming capabilities. Because SCTP is still a relatively new protocol, it has not yet been widely deployed in the Internet despite its advantages over TCP and UDP.

To encourage developers and end users to begin adopting SCTP and build momentum for more widespread SCTP deployment, we have developed a shim layer in the FreeBSD kernel which translates application-level system calls to TCP into corresponding calls to SCTP, allowing legacy TCP applications to communicate using SCTP as the end-to-end transport protocol "on the wire" without any modifications to the applications themselves. This translation occurs completely transparently, so legacy TCP applications will not even be aware that translation to SCTP is occurring in the kernel.

The shim allows for two modes of operation using SCTP at the transport layer: communication between two legacy TCP applications, or communication between one legacy TCP application and one native SCTP application. Allowing legacy TCP applications to use SCTP and interact with native SCTP applications provides a migration path that should encourage incremental SCTP deployment and allow users to begin taking advantage of SCTP's advanced features without worrying about interoperability issues between TCP and SCTP.

In this paper we present our shim design and FreeBSD kernel implementation, followed by experimental results of testing a variety of legacy TCP applications running over SCTP using the shim, including telnet, SSH, HTTP, and streaming audio. Additionally, we show that file transfers running over the shim perform equivalently to or better than those using a traditional TCP connection.

Talk Outline

• Motivations: Why use SCTP?
  • Multihoming for fault tolerance
  • Increased throughput with concurrent multipath transfer
• Implementation
  • FreeBSD kernel (4.10 and 7.0)
  • "Hidden" SCTP socket and hybrid TCP-SCTP approach
  • Client (active-open) behavior; connect()
  • Server (passive-open) behavior; bind(), listen(), sonewconn()
• Shim administration
  • Global sysctls to enable/disable shim
  • Shim rules table to dynamically control application shim use
• Experimental results
  • Legacy TCP applications communicating over shim/SCTP: Telnet, SSH, HTTP Streaming audio
  • Legacy TCP to native SCTP experiment with HTTP (Firefox/Apache)
  • File transfer performance for TCP vs shim/SCTP at various packet loss rates
• Demo shim/SCTP functionality and fault tolerance with streaming audio setup

Live Demo Proposal

If time and hardware availability permits, I would like to conduct a live demo of the shim implementation. For the demo I show live traffic captures while playing streaming audio between two systems (using Icecast and XMMS), first with traditional TCP connections, and then with SCTP connections after enabling the shim. During the shim demo, I disconnect one of two network paths between the systems and highlight SCTP's fault tolerance as transmission fails over to the redundant path and music playback continues uninterrupted.

Speaker

Ryan Bickhart is currently a software engineer with Cisco Systems where he works on the BGP routing protocol implementation in Cisco IOS. He was formerly a graduate research assistant at the University of Delaware's Protocol Engineering Lab where he first began learning and working with the FreeBSD kernel and completed the initial shim implementation. When not coding, he enjoys hiking, backpacking, and mountain biking.