1 A TCP/IP Application Programming Perspective Chris Greenhalgh G53ACC.

1

A TCP/IP Application Programming Perspective

Chris Greenhalgh

G53ACC

2

Contents

• Overview

• IP layer, IP addresses and API

• Transport layer– TCP service, API and examples– UDP service, API and examples

Books: Comer ch.17, 18, 24 & 25 (part), 28-30 (part); Farley ch. 2

3

Overview

• The TCP/IP Internet Protocols– Internet =

Inter-Network

• Universal service: the illusion of a single network

Internal details

Concept (transparency:-)

Comer Fig. 17.3

4

TCP/IP reference model

IEEE802Ethernet,WiFi, …

IP

TCP, UDP

Comer Fig. 17.4

5

IP: Internet layer

• Deals with end-to-end communication between hosts on the Internet

• Identifies hosts using IP addresses– One per host network interface– Globally unique

• But only on the Internet proper• See also NAT & private IP addresses

(later notes)

6

IP v.4 addresses: 32 bits

• Normally written in dotted decimal notation:

Comer Fig. 18.3

7

One IP address per network interface (e.g.)

Host (computer)

Comer Fig. 18.9

8

Special IP v.4 addresses

Network =class bit(s) and prefix

Comer Fig. 18.1, 18.8

9

Address ranges, masks and CIDR addresses (e.g.)

CIDR notation

NB first 28 bits are 1s

NB bit-wise AND withMask value = prefix

Comer Fig. 18.7

10

Java API: java.net.InetAddress

• Instance = single IP address and/or DNS hostname – (see later notes for more detail of DNS)

• API Excerpts: public class InetAddress { // host may be dotted IP or DNS name

public static InetAddress getByName(String host) throws UnknownHostException;

public static InetAddress getLocalHost()

throws UnknownHostException;public String getHostAddress();public String getHostName();public boolean isMulticastAddress();

}

11

Transport Layer

• Allows multiple end-points per host

• Supports different qualities of service (QOS)– Connection oriented (stream) service

• Transport Control Protocol (TCP)

– Connectionless (datagram) service • User Datagram Protocol (UDP)

12

Transport Control Protocol (TCP)

• Specified in RFC793

• Service:– Connection between two processes– Reliable delivery– Bi-directional– With flow and congestion control– e.g. used for remote login, email, HTTP

• Acts as a “pipe” between two endpoints.

13

Connection-Oriented Services

• C.f. the telephone network– Pick up the phone = initiate a connection– Dial number = specify address of other party– Recipient answers phone = connection is

made– Speak = data is transferred in both directions– One or both parties hang up = break

connection

14

Ports

• Each transport protocol has a set of ‘ports’ on the network– TCP & UDP have 16 bit port numbers (0-65535)

• Transport level protocols identify source & destination port numbers– Network level protocol (IP) identifies source and

destination host

• Application can be bound to one particular IP and one particular port, or to any local IP and one particular port

15

Ports example

...1 2 3 4

Process A

Process B

Process C

Host=128.243.22.10

Network

PacketHost 128.243.22.10Port# 4

16

Special port numbers

• Fixed port numbers allocated by Internet Assigned Numbers Authority (IANA)– E.g. HTTP, tcp port 80

• “Low” port-numbers typically reserved for standard services– E.g. <1024

• Or application may obtain “next unused” local port number from OS

17

Sockets

• A socket– is an endpoint of communication

• Created and used within an application

– is bound to a particular port– has a type which specifies the type of

communications it supports • E.g. TCP (stream), UDP (datagram)

– communicates with sockets of the same type• May be linked to one specific socket, e.g. TCP, or may be

able to communicate with multiple other sockets, e.g. TCP server socket or UDP socket.

18

Java API: java.net.ServerSocket

• Used by server• API Excerpts: public class ServerSocket { // port 0 => next unused local port

public ServerSocket(int port) throws java.io.IOException;

public InetAddress getInetAddress();public int getLocalPort();public Socket accept()

throws java.io.IOException;public void close()

throws java.io.IOException;}

19

Java server skeleton

import java.net.Socket;import java.net.ServerSocket;import java.io.IOException;public class ReverseServerTCP { public static void main(String [] args) { try { int port = Integer.parseInt(args[0]); ServerSocket s = new ServerSocket(port); while (true) {

Socket c = s.accept(); // handle client...

} } catch (IOException e) { /* ... */ }}

20

Java API: java.net.Socket

• Used by client and server (once connected)• API Excerpts: public class Socket { // constructors only used by client public Socket(String host, int port) throws UnknownHostException, IOException; public Socket(InetAddress host, int port) throws IOException; public InetAddress getInetAddress(); public int getPort(); public java.io.InputStream getInputStream() throws IOException; public java.io.OutputStream getOutputStream()

throws IOException; public void close() throws IOException;}

21

Sample client (and full server)

• See ACCExamples– tcp/ReverseClientTCP.java– tcp/ReverseServerTCP.java

• Note: relies on java.io framework - TCP just moves a sequence of bytes– Use raw streams and/or BufferedInput/OutputStreams

if you want to exchange particular byte sequences– Use Reader/Writer if you want to exchange text– Use DataInput/DataOutput if you want to marshall

java primitive types– Use ObjectInputStream/ObjectOutputStream if you

want to marshall Java Serializable objects

22

TCP Client and server structure

• Server– new ServerSocket(port)– serverSkt.accept()

• returns new Socket

– skt.getInputStream• read, etc.

– skt.getOutputStream• write, etc.

– skt.close()

• Client– new Socket(host, port)

– skt.getOutputStream• write, etc.

– skt.getInputStream• read, etc.

– skt.close()

connect

request

response

23

Multi-threaded server execution

Main thread

accept()

Client-specific thread(s)

ServerSocket

client Socket(s)

new Thread().start() [UNIX: fork()]

24

User Datagram Protocol (UDP)

• Specified in RFC 768

• Connectionless

• Datagrams can be transmitted to– A single machine– A group of machines (multicast or broadcast)

• Bidirectional

• Unreliable

• Maximum payload 64Kbytes (65535 bytes)

25

Connectionless Services analogy

• Can be compared to the postal service– A letter is put into an envelope (data into a

datagram)– The envelope is addressed to the recipient– The envelope is put in the post box and

enters the delivery system– The envelope arrives (hopefully) at the

destination

26

Connectionless Services

• Unreliable– May never arrive– No indication if the delivery is successful

• Unordered– May arrive in a different order

(a variety of possible routes)

• Rarely (but occasionally) duplicated• Error-checked (corrupt packets usually

detected and discarded)

27

UDP and TCP

• Uses sockets API for both UDP and TCP– stream type for TCP– datagram type for UDP

• Uses port numbers for both– but UDP port 53 is NOT same as TCP port 53

28

UDP uses

• Very simple request/response protocols– small maximum size, e.g. DNS

• No 3-way handshake delay (cf. TCP)• No reliability overhead/retransmit delay

– E.g. for streamed audio, video

• But:– no flow control, congestion control

(can be added, but quite tricky and more overhead again)

29

Java API: java.net.DatagramSocket

• Used by client and server• API Excerpts: public class DatagramSocket {

public DatagramSocket() throws SocketException;

public DatagramSocket(int port) throws SocketException;

public int getLocalPort();public void setSoTimeout(int timeout)

throws SocketException;public void send(DatagramPacket p)

throws IOException;public void receive(DatagramPacket p)

throws IOException;public void close();

}

30

Java API: java.net.DatagramPacket

• Instance combines:– Application data - byte array– Actual size used (number of bytes)– Source/destination InetAddress– Source/destination port

• Source if received, destination if sending

• API Excerpts: see over

31

• public class DatagramPacket { public DatagramPacket(byte[] buf, int offset,

int length); public DatagramPacket(byte[] buf, int length); public DatagramPacket(byte[] buf, int offset,

int length, InetAddress address, int port); public DatagramPacket(byte[] buf, int length, InetAddress address, int port); public InetAddress getAddress(); public int getPort(); public byte[] getData(); public int getLength(); public void setAddress(InetAddress iaddr); public void setPort(int iport); public void setData(byte[] buf); public void setData(byte[] buf, int offset, int length); public void setLength(int length);}

32

Sample UDP client and server

• See ACCExamples– unicast/ReverseClientUnicast.java– unicast/ReverseServerUnicast.java

• Note: can still use java.io framework - UDP just moves an array of bytes (<=65535)– Can get/set bytes directly– Can use ByteArrayInput/OutputStream to read/write

bytes as streams• Can combine with DataInput/Output or

ObjectInput/OutputStream as used with TCP

33

UDP Client and server structure

• Server– new DatagramSocket()– loop:

• new DatagramPacket()

• skt.receive(pkt)

• new DatagramPacket()

• skt.send(pkt)

– GC DatagramSocket

• Client– new DatagramSocket()– work:

• new DatagramPacket()

• skt.send(pkt)

• new DatagramPacket()

• skt.receive(pkt)

– GC DatagramSocket

request

response