TCP Sockets

Reliable Communication

TCP

As mentioned before, TCP sits on top of other layers (IP, hardware) and implements

• Reliability• In-order delivery• No duplicates• Rate-limitingIt allows you to write to another host on the network

as if it were a file streamTCP only passes bytes; it is completely agnostic

about what they mean. Making sense of the bytes is up to you, the programmer (or the protocol receiving the bytes)

Review

To connect to a host, we need to specify:• What host we will be talking to, either

directly via IP number, or indirectly via DNS name

• What port on the host we will be talking to; a number in the range 0-64K

Socket

A “socket” describes a connection between two hosts To set up a stream between two hosts you need a “socket pair” that describes the connection between the client and the server Server

172.20.40.12

Client

172.20.40.88

Port TCP 4567 Port TCP 4485

Socket

The socket pair can be described as ((172.20.40.12, 4567), (172.20.40.88, 4485))

The client IP, a client port, the server IP, and the well-known port we connect to on the server

If you’re picky, you also need to specify whether this is TCP or UDP. This is often omitted, though, because it’s usually clear from the context which is being used

Server Socket

The standard technique is: client initiates connection to server

Before we can establish a connection, we have to have something waiting for the connection on the server side

This is a “server socket”, a piece of software that waits for clients to connect.

Server Socket

Waiting for a connection at 172.20.40.88, 4485

Server

Server

172.20.40.12

Client

172.20.40.88

Port TCP 4567 Port TCP 4485

Multiple Connections

What if two people want to connect to a web server at the same time?

Notice that the socket connection has a unique ID based on the socket pair. If two hosts connect, or even if two programs from the same host connect

You can see this with “netstat -an”

Netstat

hodad-5:MV3500 mcgredo$ netstat -anActive Internet connections (including servers)Proto Recv-Q Send-Q Local Address Foreign Address (state)tcp4 0 411 192.168.1.6.57583 74.125.53.95.80 ESTABLISHEDtcp4 0 406 192.168.1.6.57582 74.125.53.95.80 ESTABLISHEDtcp4 0 0 192.168.1.6.57581 64.236.68.229.80 ESTABLISHED

Two Connections from Same Host

Server

172.20.40.12

Client

172.20.40.88

Port TCP 4567 Port TCP 4485

Port TCP 4568 Port TCP 4485

What are the socket pairs here?

Connection Process (Java)

The server starts a server socket on a port; this will listen on, for example 172.20.81.12 on port 1234

The client initiates a connection from its IP to the server. The client picks an unused port on the client machine, and this port is used in the socket pair. The client port is sometimes called an “ephemeral port”

At this point we have a socket pair. The client code returns a socket object, and the server code returns a similar socket object

Note that a Socket object is not a ServerSocket object!

Socket

Socket

InputStream

InputStream

OutputStream

OutputStream

The inputStream on one side of theSocket is connected to the outputStreamOn the other side, and vice versa

Input & Output Streams

Input & Output streams are standard Java objects that know how to read & write bytes only. They don’t know about higher level concepts like Unicode characters, integers, floating point numbers, etc

But: are you convinced that with enough work you could write a class that figured out what four bytes represented as a floating point number?

Luckily for you, there are classes in the standard Java library that do this for you

Input & Output Streams

PrintStream OutputStream

Unicode rep of data

InputStreamInputStream

ReaderBufferedReader

Other Streams

There are also Java library streams for reading & writing binary values, and streams for reading and writing Java objects (!)

Remember, bytes are bytes; sockets are agnostic about what they mean. We have to come to some sort of a priori agreement on what we’ll be sending so we’ll know what to expect on the receiving side

The string value “17.4” is not the same as a binary floating point number representing 17.4

Sliding Window

• TCP works via something called a“sliding window”. Simplified, it looks something like this:

Sent, Ack’d

Sent, No ackyet

Ready To Send

Sliding Window

Sliding Window

• The rate at which it sends depends on how quickly it gets acks back. If the window is a fixed size, it can’t move right until the leftmost data is ack’d

• This means you may not be able to send new data until old data is acked! For something like position updates this is bad

• But this can be used to do rate limiting, congestion control, etc.

Example Code

See TcpServer.java, TcpClient.javaThis simply establishes a connection and

sends a simple message and response

Message Format?

So what type message should you send?Since you get to make it up, it’s good for you if

you pick something simple and robustFor TCP sockets, this is usually ASCII textWhy? • Binary is different from host to host• You can easily debug ASCII• it is usually fast enough for what TCP doesYou can use binary formats, but your default first

attempt should be ASCII

Examples of TCP Message Formats

You can establish your own interactive TCP connection to a server with “telnet <hostname> <port>” (usually typing blind on windows machines)

HTTP (web servers): GET /index.htmlSMTP (email) fake mail

HTTP

• telnet www.movesinstitute.org 80• GET /index.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><!-- InstanceBegin template="/Templates/level_1.dwt" codeOutsideHTMLIsLocked="false" --><head>

SMTP Fakemail

telnet mustang.nps.edu 25MAIL FROM: admiral@nps.edu

RCPT TO: yourBuddy@nps.edu

DATA

You are instructed to appear at the next inspection in a speedo

.

QUIT

Note the period on a line by itself

Stateless vs. Stateful Protocols

Note a subtle difference between the HTTP and SMTP protocols

HTTP is stateless--you send one text command, the server processes that, and then the socket connection can be torn down and the server completely forgets that it ever talked to you before

A stateful protocol depends on prior commands sent from the client. The RCPT TO and DATA commands depend on the prior MAIL FROM command.

Stateless protocols are good. They scale well, and are simple.

Sequential vs Parallel

What happens to our simple ping-pong example if the server takes a long time to process a command?

How can we fix this?Use a thread per client connection--then

we can go back and do another accept() wile the first command is still processing

This is a parallel server

TCP Protocols

• You want to use text for the protocol commands if you possibly can

• Keep it simple. Simple can be debugged and may actually work. Complex will not. If you possibly can, start off with a sequential, stateless server

Matrix

Stateless

Stateful

Sequential Parallel

X

Try for a stateless, sequential protocol if you can, on thegrounds that it’s simple. Going to a parallel implementationis not bad, but a stateful protocol can be much more complex

Assignment

Write a client and server that accepts a simple position command for an entity. Include an entity identifier and position (x,y,z)

Write a simple HTTP client program that sends a request for a URL to a server and gets a response back