Protocols

• Mainly concerned with two layers of the full network stack:
  • application
    • e.g. HTTP, FTP
  • transport
    • e.g. TCP, UDP

Protocols

• We're all (likely) familiar with HTTP and FTP!
• HTTP and FTP use TCP for their transport layer
• TCP has certain characteristics that fit the use-case:
  • connection-based
  • reliable packet delivery
  • in-order packet delivery
• When requesting data or a file, you typically want all of its data in order
  • as opposed to, say, a jigsaw puzzle of 500 packets that when correctly assembled form the .zip file or HTML page you actually want

Protocols

• UDP is the transport protocol that implements the bare minimum for sending outgoing data of any kind
• if you want any other characteristics, those need to be implemented on the application layer
• Games that update in real-time (MMOs, FPSes, etc.) typically use UDP for this reason, with some custom application layer that's game-specific

 

• It is possible to use TCP for real-time games, but this only works in the very best-case scenarios
  • These games don't need every packet, only the most recent ones to describe current game state
  • This is known as head-of-line blocking

Protocols

Hello, would you like to hear a TCP joke?

Yes, I’d like to hear a TCP joke.

OK, I will tell you a TCP joke.

OK, I will hear a TCP joke.

Are you ready to hear a TCP joke?

Yes, I am ready to hear a TCP joke.

OK, I am about to send the TCP joke. It will last 10 seconds, it has two characters, it does not have an explicit setting, it ends with a punchline.

OK, I am ready to get your TCP joke that will last 10 seconds, has two characters, does not have an explicit setting, and ends with a punchline.

I’m sorry, your connection has timed out… Hello, would you like to hear a TCP joke?

Protocols

I'd tell you a UDP joke, but you probably wouldn't get it.

Protocols in Browsers

• My recent DevTricks talks and hackathon project have been about writing or porting games from native desktop applications to be run in a browser
  • i.e. emscripten
• So, of course, I had to think about what kind of network communication browsers allow right now

Protocols in Browsers

• Problem: Most games of the kind I want to make use UDP. Most browsers do not have easy means to use UDP.
  • Javascript typically uses WebSockets, which is built on top of TCP
  • QUIC uses UDP, but its implementation enforces in-order packet delivery, thus head-of-line blocking
  • WebRTC allows for peer-based connections
    • ... which might work, but overly complex for games with dedicated servers (requires ICE, STUN, TURN)

Protocols in Browsers

• Even bigger problem: Allowing for UDP as-is in a browser is a very, VERY bad idea, and there are good reasons why this isn't a thing
  • ​Imagine a site that serves javascript that sends UDP packets to some DDoS target
  • Imagine a site that serves js that makes a user's browser send UDP packets to try and get information about a corporate network and relays that info over https
  • No encryption or authentication -- those are assumed to be implemented at application layer

netcode.io

• A current attempt at an application layer protocol that allows for the desired functionality of UDP that covers the problems inherent to UDP in browsers
• Characteristics:
  • Connection-based
  • Encrypted
  • Authenticated
• There is a reference implementation here:
    https://github.com/networkprotocol/netcode.io

netcode.io

• Three portions:
  • Web backend (REST API)
    • to form authenticated connections between server and client
  • Dedicated server(s)
    • where the actual state of the game lives
  • Clients
    • people actually playing the game
    • not necessarily browsers, but potentially includes them by design

netcode.io

• Current state:
  • Reference implementations exist
  • Ports to C#, GoLang, Rust exist
  • Ports to Unity and Unreal Engine 4 exist
  • Use in a browser still requires users to install a browser plugin
• Not sure where the future of this is, honestly
  • Is plugin installation going to affect user adoption?
  • Are browsers going to implement this natively at some point?

but it's neat and I like exploring what's possible and why things are the way they are

Sources:

• http://www.firewall.cx/
• https://gafferongames.com/post/why_cant_i_send_udp_packets_from_a_browser/
• https://github.com/networkprotocol/netcode.io
• https://github.com/networkprotocol/netcode.io/blob/master/STANDARD.md
• https://github.com/RedpointGames/netcode.io-browser