Presentation on theme: "TCP Sockets Reliable Communication. TCP As mentioned before, TCP sits on top of other layers (IP, hardware) and implements Reliability In-order delivery."— Presentation transcript:
TCP As mentioned before, TCP sits on top of other layers (IP, hardware) and implements Reliability In-order delivery No duplicates Rate-limiting It allows you to write to another host on the network as if it were a file stream TCP 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 4567Port 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 172.20.40.12 Client 172.20.40.88 Port TCP 4567Port 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 -an Active Internet connections (including servers) Proto Recv-Q Send-Q Local Address Foreign Address (state) tcp4 0 411 192.168.1.6.57583 22.214.171.124.80 ESTABLISHED tcp4 0 406 192.168.1.6.57582 126.96.36.199.80 ESTABLISHED tcp4 0 0 192.168.1.6.57581 188.8.131.52.80 ESTABLISHED
Two Connections from Same Host Server 172.20.40.12 Client 172.20.40.88 Port TCP 4567Port TCP 4485 Port TCP 4568Port 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 InputStream OutputStream The inputStream on one side of the Socket is connected to the outputStream On 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 PrintStreamOutputStream Unicode rep of data InputStream Reader Buffered Reader
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 ack yet Ready To Send 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.java This 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 robust For TCP sockets, this is usually ASCII text Why? Binary is different from host to host You can easily debug ASCII it is usually fast enough for what TCP does You 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 ” (usually typing blind on windows machines) HTTP (web servers): GET /index.html SMTP (email) fake mail
HTTP telnet www.movesinstitute.org 80www.movesinstitute.org GET /index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <!-- InstanceBegin template="/Templates/level_1.dwt" codeOutsideHTMLIsLocked="false" -->
SMTP Fakemail telnet mustang.nps.edu 25 MAIL FROM: email@example.com@nps.edu RCPT TO: yourBuddy@nps.eduyourBuddy@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 the grounds that it’s simple. Going to a parallel implementation is 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