Layer 4 - Transport Layer

Transcription

1 Layer 4 - Transport Layer Core of the protocol hierarchy: Network-independent, reliable and economical data transfer Tasks of the transport layer: Connection-oriented or connectionless data transfer Addressing of a certain communication process on a computer Error detection, error correction Flow control Multiplexing 1. Upward - several transport connections to one network connection 2. Downward - one transport connection to several network connections (e.g. if not sufficient capacity of a network connection is given) Weak quality guarantees: reliability Page 1

2 What do we need a Transport Layer for? Similarity to layer 3: Connection-oriented and connectionless data transmission (The Internet layer in connectionless, but in general layer 3 also could be connectionoriented) Addressing Flow control Is layer 4 redundant? No, because: The network layer belongs to the network carrier: A user does not have any control over network details and problems Hiding of technical details from higher layers Addressing of a destination process End-to-end view of a data flow Generally: Improvement of the quality of the data communication on layer 3 Page 2

3 Transport Protocols in the TCP/IP Reference Model Connection-oriented Connectionless HTTP FTP Telnet SMTP DNS SNMP TFTP Application Layer TCP UDP Transport Layer IGMP ICMP IP ARP RARP Internet Layer Ethernet Token Ring Token Bus Wireless LAN Host-to-Network Layer TCP (Transmission Control Protocol): Reliable, connection-oriented. UDP (User Datagram Protocol): Datagram principle, connectionless, unreliable, without flow control, permutation of a packet order can happen. Page 3

4 The Transport Layer TCP and UDP A Client process IP network Transport protocols are used by the application layer as communication services. They make communication available between application processes. UDP is a connectionless and fast protocol TCP is a connection-oriented and reliable protocol virtual connections only, using the connectionless IP for transmitting data B Server process Page 4

5 Characteristics of TCP Connection-oriented and reliable (error-free, keeps packet order, without duplicates) Error handling, acknowledgments, flow control (Sliding Window procedure) Byte stream, not message stream Segmentation (max. segment size of 64 KByte) Urgent -messages outside of flow control Limited QoS Addressing of the application by port numbers Port number Client Application layer Server 1 Server 2 IP address Transport layer Network layer Host-to-network layer Server waits on several ports Page 5

6 Port Numbers for TCP-based Applications File transfer Virtual terminal World Wide Web Routing information FTP telnet Electronic Mail SMTP HTTP BGP / Well known TCP ports RFC 1700 Port number is 16-bit address Ports from 0 to 1023 are reserved for standardized applications Ports from 1024 to can be specified by each host Page 6

7 TCP as a Safe Connection Establishes logical connections between two Sockets: IP address + 16 bit port number (48 bit address information) For an application, sockets are the access point to the network A socket can be used for several connections at the same time TCP connections are always full-duplex and point-to-point connections TPDUs exchanged between the two communicating stations are called segments Segments are being exchanged for realizing Connection establishment, Data transmission, Sending of confirmations, Connection termination. For simplicity: only one header format defined for all segments the task of a segment is marked by special flags Page 7

8 Connection-orientation of TCP Connection-oriented classically means use a determined connection (path) to send all data packets But: TCP sits on top of the connectionless IP and has no influence on the chosen path Thus: TCP in principal transfers the data connectionless, but adds control information in its header for appearing connection-oriented to higher-layer protocols Simple idea: Like on layer 2, number all segments before transmission On receiver side, check the stream of segments on completeness and correct order Re-transmit missing segments Page 8

9 The TCP Header Bit position Source Port Destination Port 20 byte default header Sequence Number Plus options Acknowledgement Number Up to data bytes HL Res. 6 Flags Window Size Checksum Options Urgent Pointer Padding Data Page 9

10 The TCP Header Source and Destination Port: port number of sender resp. receiver Sequence Number/Acknowledgment Number: Segments have a 32 bit sequence and acknowledgement number for the window mechanism in flow control (Sliding Window). Sequence and acknowledgement number count single bytes! The acknowledgement number indicates the next expected byte! Sequence numbers begin not necessarily with 0! A random value is chosen here to avoid a possible mix-up of segments for a new connection with old segments from the last connection which could maybe arrive late. Piggybacking, i.e. an acknowledgement can be sent in a data segment. HL: As in case of IP, also the TCP header has an indication of its length. The length is counted in 32-bit words. Res = Reserved for later use. Window Size: Size of the receiver s buffer for the connection. Used in flow control: the window of a flow indicates, how many bytes at the same time can be sent the size of the buffer indicates, how many bytes can be stored within the receiver. The window of flow control is adapted to this value. Page 10

11 The TCP Header Flags: URG (URGENT): When this flag is set the field urgent pointer becomes valid, to submit important data immediately even if flow control would not allow for. ACK: This bit is set, if an acknowledgement is sent. PSH (PUSH): Immediate forwarding of the data, no more waiting for further data (i.e. immediate transmission on sender side, immediate processing on receiver side without long buffering). RST (RESET): Reset a connection, e.g. during a host crash or a connecting rejection. The connection immediately is termindated. SYN (Synchronize): set to 1 for the establishment of a connection. FIN (Final): set to 1 for the termination of a connection. Urgent pointer: indicates, at which position in the data field the urgent data end (byte offset of the current sequence number). Option: additional functions: negotiation of a window scale; use of e.g. Selective Repeat instead of Go-Back-n in the event of an error; Indication of the Maximum Segment Size (MSS) to determine the size of the data field. Page 11

12 TCP Pseudo Header Checksum: serves among other things for the verification that the packet was delivered to the correct device. The checksum is computed using a pseudo header. The pseudo header is placed in front of the TCP header, the checksum is computed from both headers (the checksum field is occupied here with 0). The checksum is computed as the 1- complement of the sum of all 16-bit words of the segment including the pseudo header. The receiver also places the pseudo header in front of the received TCP header and executes the same algorithm (the result must be 0). Source address (IP) Destination address (IP) Protocol = 6 Length of the TCP segment Now: how are connection establishment, reliable data transmission, and connection termination implemented in TCP? Page 12

13 Connection Establishment Sounds easy is however nevertheless quite complicated: the network can lose packets, store packets, duplicate packets. Solution: Duplicate Sequence numbers Three-Way Handshake A connection establishment consists of three parts: The Connection Request (CR), The confirmation of the receiver that the connection establishment is accepted, Host 1 Host 2 The confirmation of the sender that the confirmation of the receiver was received and the sending request is still given. A compromise between reliability and complexity is to be obtained by this principle. Two variants of this procedure are implemented in TCP CR (seq=x) ACK (seq=y, ACK=x) ACK (seq=x+1, ACK=y) CR (seq=x) ACK (seq=y, ACK=x) REJECT (ACK=y) Host 1 Host 2 Page 13

14 1. Regular TCP Connection Establishment Client SYN, SEQ-No=x SYN, ACK, SEQ-No=y, ACK-No=x+1 ACK, ACK-No=y+1, SEQ-No=x+1 ACK-No = acknowledgement number SEQ-No = sequence number The ACK-No value only is valid if the ACK flag is set to 1! Server The server has to run and wait for connection requests on a certain port. The client connects by with a segment indicating the destination port, initial sequence number (x), and having set the SYN flag to 1 (to indicate that a new connection is to be established). The connection is accepted on server side if the destination port is identical to the one the server waits on, and if the server has enough resources (buffer space) for a new connection. Otherwise it is rejected (set RST flag). The server sends back a segment with set SYN flag to the client, and acknowledges at the same time the receipt of the client s SYN segment (with ACK-No=x+1). Also, an own initial number is passed to the client (y). The client sends an acknowledgement for the SYN segment of the server (ACK-No=y+1). The connection is established. Page 14

15 2. Irregular TCP Connection Establishment Client/Server Client/Server SYN, SEQ-No=x SYN, SEQ-No=y SYN, ACK, SEQ-No=x, ACK-No=y+1 SYN, ACK, SEQ-No=y, ACK-No=x+1 Maybe, two computers at the same time try to establish a connection to each other Connections are characterized by their endpoints; only one connection is established between a pair of endpoints. The endpoints are uniquely characterized: (IP Address 1, Port 1, IP Address 2, Port 2 ) Page 15

16 Data Transmission After connection establishment, all data is transferred in segments: Client Server SEQ=101, ACK=201, DATA 10 Byte SEQ=201, ACK=111 SEQ=111, ACK=201, DATA 50 Byte SEQ=201, ACK=161 Full-duplex connection Segmentation of a byte stream into segments. Usual sizes are 1500, 536 or 512 byte; thus IP fragmentation is avoided. Usual acknowledgement mechanism: all segments up to ACK-1 are confirmed. If the sender has a timeout before an ACK, he repeats the segment. To be more efficient: sliding window mechanism Usual procedure for repeating: Go- Back-N or Selective Repeat. Page 16

17 Flow Control Sliding Window To provide reliable data transfer, as on layer 2 a sliding window mechanism is used. Differences: The window size counts transmitted bytes (instead as frames as on layer 2) Window is shifted by n byte as soon as an ACK for n byte arrives Exception: Urgent data (URGENT flag is set) is sent immediately Characteristic: the window size can be changed during the transmission phase! Why? Segments have to be buffered to allow a sorting of out-of-order segments Segments are buffered till the receiving application process is able to process them Initial window bytes acknowledged Window slides Variable number of connections can exists, all sharing the same buffer Page 17

18 Dynamic Buffer Assignment ack/seq {0,, 15} 1 2 A Message <request 8 buffers> <ack = 15, buf = 4> B A asks for 8 places in B s buffer (8 bytes) B grants 4 buffer places for A and waits for segment 0 3 <seq = 0, data = byte1> A sends segment 0 (only 1 byte per segment, for simplicity) 4 <seq = 1, data = byte2> A sends segment 1 5 <seq = 2, data = byte3> A sends segment 2, segment is lost 6 <ack = 1, buf = 3> B ack s segments 0 and 1, buffer places are reduced to 3 7 <seq = 3, data = byte4> A sends segment 3 Timeout for segment 2 } 8 9 <seq = 4, data = byte5> <seq = 2, data = byte3> A sends segment 4 A repeats segment 2 10 <ack = 4, buf = 0> B acknowledges segments 2-4 sender is stopped (no buffer) 11 <ack = 4, buf = 1> B informs A about 1 buffer place 12 <ack = 4, buf = 2> B informs A about 2 buffer places 13 <seq = 5, data = byte6> A sends segment 5 14 <seq = 6, data = byte7> A sends segment 6; A is blocked (no more buffer) 15 <ack = 6, buf = 0> B acknowledges segments 5+6, but sender remains blocked 16 <ack = 6, buf = 4> B informs A about 4 buffer places A waits for buffer space Chapter B waits 3.5: that A TCP sends and data UDP Danger of deadlock; send control segments in regular time intervals Page 18

19 Dynamic Sliding Window - Example Application writes 2 KB Sender 2K SEQ = 0 Receiver Receiver buffer 0 4K Empty 2K ACK=2048 WIN=2048 Application writes 2 KB 2K SEQ = 2048 Full Sender is blocked Sender can transfer up to 2 KB ACK=4096 WIN=0 ACK=4096 WIN=2048 1K SEQ = 4096 Application reads 2 KB 2K 1K 2K Page 19

20 Silly Window Syndrome Receiver buffer is full Application reads 1 byte Space for 1 byte Header Header Transfer segment for window actualization New byte arrives Receiver buffer is full 1 byte Solution of Clark: The receiver must wait with the next window actualization until the receiver buffer again is reasonably empty Page 20

21 TCP Connection Termination Client Server Termination as two simplex connections FIN, SEQ-No=x, ACK-No=y ACK, SEQ-No=y, ACK-No=x+1 FIN, SEQ-No=y, ACK-No=x+1 Send a segment with set FIN flag If the FIN-segment is confirmed, the corresponding direction is switched off. The opposite direction remains however still opened, data can still be sent. The same procedure as above is to be repeated Use of timers to protect against data loss ACK, SEQ-No=x+1, ACK-No=y+1 Page 21

22 Connection Termination Timers To protect against data loss, timers are used otherwise, if one machine crashes during termination, the other one would wait forever before releasing reserved resources send FIN and start timer terminate connection send confirmation FIN FIN, ACK ACK send FIN and start timer terminate connection Host 1 Host 2 send FIN and start timer Timeout send FIN and start timer terminate connection send confirmation FIN FIN FIN, ACK ACK FIN, ACK send FIN and start timer send FIN and start timer terminate connection send FIN and start timer terminate connection send confirmation FIN FIN, ACK ACK send FIN and start timer Timeout terminate connection Host 1 Host 2 send FIN and start timer Timeout send FIN and start timer : : N Timeouts terminate connection FIN FIN FIN FIN FIN, ACK send FIN and start timer Timeout terminate connection Page 22

23 The Entire TCP Connection Normal path of server Normal path of client Unusual events Event/action pair Event: System call by user, arrival of segment, timeout Action: Send a control segment Page 23

24 States during a TCP Session State CLOSED LISTEN SYN RCVD SYN SENT ESTABLISHED FIN WAIT 1 FIN WAIT 2 TIME WAIT CLOSING CLOSE WAIT LAST ACK No active communications The server waits for a connection request A connection request was received and processed, wait for the last ACK of the connection establishment Application began to open a connection Connection established, transmit data Application starts a connection termination The other side confirms the connection termination Wait for late packets Connection termination The other side initiates a connection termination Wait for late packets Description Page 24

25 Used Timers Persistence timer Lehrstuhl für Informatik 4 Prevents a deadlock with a loss of the buffer release message of a receiver With expiration of the timer, the sender transfers a test segment. The response to this transmission contains the current buffer size of the receiver. If it is still zero, the timer is started again. Keep-alive timer If a connection is inactive for a longer time, at expiration of the timer it is examined whether the other side is still living If no response is given, the connection is terminated Disputed function Time Wait timer During the termination of a connection, the timer runs for the double packet life time to be sure that no more late packets arrive Page 25

26 The Entire TCP Connection Example Client Server Page 26 SYN/SEQ=2999/ACK=x/Window=2500/MSS=1460 ACK/SEQ=3000/ACK=2001/Window=2500 SYN, ACK/SEQ=2000/ACK=3000/Window=4200/MSS=1400 DATA 1400 byte/seq=3000/ack=2001/window=2500 DATA 1400 byte/seq=4400/ack=2001/window=2500 DATA 1400 byte/seq=5800/ack=2001/window=2500 ACK/SEQ=2001/ACK=4400/Window=4200 ACK/SEQ=2001/ACK=5800/Window=4200 ACK/SEQ=2001/ACK=7000/Window=4200 DATA 1400 byte/seq=7000/ack=2001/window=2500 DATA 1400 byte/seq=8400/ack=2001/window=2500 ACK/SEQ=2001/ACK=8400/Window=4200 ACK/SEQ=2001/ACK=9800/Window=4200 FIN, ACK/SEQ=9800/ACK=2001 FIN, ACK/SEQ=2001/ACK=9801 ACK/SEQ=9801/ACK=2002

27 Flow Control - Network Bottlenecks Next problem: when sending as much data as the receiver allows, the network can get overloaded Necessary: Congestion Control (by using a second transmission window) Assumption: packet loss is rarely because of transmission errors, rather because of overload situations Capacity of the receiver: Flow Control Window (Buffer) Capacity of the network: Congestion Window Page 27

28 Control Algorithm in the Internet Each sender maintains two windows for the number of bytes which can be sent: 1. Flow Control Window: granted receiver buffer 2. Congestion Window: network granted capacity (cwnd) Minimum of both windows is the number of bytes which can be sent maximally With connection establishment, the sender initializes the congestion window to the size of the maximum segment (MSS, the MTU the sender is able to send) Maximum segment is sent If an acknowledgement arrives before timeout, double the congestion window (Slow Start Algorithm), otherwise reset it to the initial value. Thus a grope takes place up to the transmission capacity. Enlargement stops with reaching the flow control window Refinement by introduction of a threshold value ssthresh (at the beginning 64 Kbyte): - Only linear enlargement by one maximum segment size (Congestion Avoidance) - With a timeout the threshold value is put back to half of the maximum window size reached before Page 28

29 Control Algorithm in the Internet Congestion Avoidance, groping to the maximum capacity Overload assumed, reduce the data amount Be more careful in the next attempt Slow start, fast utilization of the free capacity Start with one segment Page 29

30 Fast Retransmit and Fast Recovery Slow Start is not well suited when only a single packet is lost Fast Retransmit The receiver should send a duplicate ACK immediately when an out-of-order segment arrives When the sender has received 3 duplicate ACKs, it performs a retransmission of the segment which seems to be missing. Hopefully, the acknowledgement for the repeated segment arrives before a timeout for this segment occurs. Fast Retransmit has to be enhanced to be useful in overload situations Fast Recovery When the third ACK is received, reduce ssthresh to max(current size/2, 2*MSS) Retransmit the missing segment, set cwnd to ssthresh + 3*MSS For each more duplicated ACK, increment cwnd by MSS This reduces cwnd by the amount of lost segments to adapt to the network situation If the new cwnd (and the receiver s buffer) allows, send a segment When the next (normal) ACK arrives, set cwnd to ssthresh to go on normally Page 30

31 Timer Management with TCP TCP uses several timers: Retransmission timer (for repeating a transmission) But: how to select the timer value? Probability density of the time till an acknowledgement arrives: 0.3 T 0.3 T 1 T 2 Wahrscheinlichkeit Probability Wahrscheinlichkeit Probability Problem on the transport layer: T 1 is too small: too many retransmissions Roundtrip-Time Trip [ms] Data Link Layer Round Roundtrip-Time Trip Time [ms] [ms] Transport Layer T 2 is too large: inefficient for actual packet loss Page 31

32 Retransmission Timer Only meaningful solution: dynamic algorithm, which can adapt the timer by current measurements of the network performance. Algorithm of Jacobson (1988): TCP manages a variable RTT (Round Trip Time) for each connection RTT is the momentarily best estimation of the round trip time to the target computer and back When sending a segment, a timer started which measures, which time the acknowledgement needs and initiates a retransmission if necessary. If the acknowledgement arrives before expiration of the timer (after a time unit t), RTT is updated: RTT = α RTT + (1 - α) t α is a smoothing factor, typically The choice of the timeout is based on RTT: Timeout = β RTT At the beginning, β was chose as 2, but this was too inflexible Page 32

33 Retransmission Timer Improvement (Jacobsson): select β proportionally to the standard deviation of the arrival time of acknowledgements Computation of β: β = α β + (1 - α) RTT - t The factor α does not need to be the same as during the RTT computation Standard timeout interval: Timeout = RTT + 4 β The factor 4 was determined on the one hand by trying out, on the other hand because it is fast and simple to use in computations. Alternative, very simple proposal, which is used in most TCP implementations: Double the timeout as long as an acknowledgement arrives in time. Page 33

34 Working with TCP Server side The receiving application process (server) has to run at first The server provides a socket over which connection requests are received (i.e. a port is made available) In order to be able to receive requests of several clients, the server provides a new socket for a connection request of each client Client side The client generates a socket The client creates a request with IP address and port of the server When the client creates its socket, a connection establishment to the server is made Page 34

35 Socket Primitives in TCP For communication via TCP, a set of primitives exists which an application programmer can use for initializing and carrying out a communication. The essential primitives are: Primitively SOCKET BIND LISTEN ACCEPT CONNECT SEND RECEIVE CLOSE Meaning Creation of a new network access point Assign a local address with the socket Wait for arriving connecting requests Accept a connecting request Attempt of a connection establishment Send data over the connection Receive data on the connection Release of the connection Page 35

36 Socket Programming in TCP Server (on host hostid) create socket, port=x, for incoming request: welcomesocket = ServerSocket () TCP wait for incoming Connection establishment connection request connectionsocket = welcomesocket.accept () read request from connectionsocket write reply to connectionsocket close connectionsocket Client create socket, connect to hostid, port=x clientsocket = Socket () send request using clientsocket read reply from clientsocket close clientsocket Page 36

37 Example: Java Client (TCP) import java.io.*; import java.net.*; class TCPClient { Buffers for user input are provided Create client socket, establish connection Create data stream for the socket public static void main(string argv[]) throws Exception { String sentence; String modifiedsentence; BufferedReader infromuser = new BufferedReader(new InputStreamReader(System.in)); Socket clientsocket = new Socket( hostname, 6789); CONNECT DataOutputStream outtoserver = new DataOutputStream(clientSocket.getOutputStream ()); Page 37

38 Example: Java Client (TCP) Create data stream from the socket BufferedReader infromserver = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); Send to server sentence = infromuser.readline(); outtoserver.writebytes(sentence + \ n ); SEND Receive from server modifiedsentence = infromserver.readline(); RECEIVE System.out.println( FROM SERVER: + modifiedsentence); clientsocket.close(); } } Page 38

39 Example: Java Server (TCP) import java.io.*; import java.net.*; class TCPServer { Provide default socket on port 6789 Wait for incoming connection requests Link buffer with the socket public static void main(string arg []) throws Exception { String clientsentence; String capitalizedsentence; BIND ServerSocket welcomesocket = new ServerSocket(6789); while (true) { LISTEN Socket connectionsocket = welcomesocket.accept(); BufferedReader infromclient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream())); Page 39

40 Example: Java Server (TCP) Link outgoing data stream with the socket DataOutputStream outtoclient = new DataOutputStream(connectionSocket.getOutputStream()); Read from socket clientsentence = infromclient.readline(); RECEIVE capitalizedsentence = clientsentence.touppercase() + \ n ; Write on socket } } } outtoclient.writebytes(capitalizedsentence); Go back, wait on next request SEND Page 40

41 The User Datagram Protocol (UDP) Alternative to TCP; principle: Keep it simple! 8 byte header Like IP: connectionless and unreliable Small reliability, but fast exchange of information Used for fast data transfer, and for transfer of only short messages (to avoid the connection establishment overhead) No acknowledgement of packets on the UDP layer, incorrect packets simply are discarded. Duplication, sequence order permutation, and packet loss are possible. The checksum offers the only possibility of testing the packets on transfer errors Possible: ACKs and retransmissions are controlled by the application. Use in multicast (not possible with TCP) Why at all a protocol if no function is implemented? Only the addition of a port to a network address marks communication clearly. Page 41

42 UDP Header Lehrstuhl für Informatik 4 Bit Positon Source Port Message Length Destination Port Checksum Data Addressing of the applications by port numbers Message length indicates the overall length (header + data) in 32-bit words Checksum (optional!) IP does not have a checksum for the data part, therefore it can be a meaningful addition here. Execution of the computation as for TCP Data are filled up if necessary to an even byte number (because Message Length is indicated in 32-bit words) Page 42

43 UDP-based Applications Automatic Address Assignment Routing Information Name service Network Management DNS BOOTP File Transfer TFTP SNMP RIP 53 67/ / Well known UDP ports (up to 1023) Page 43

44 Socket Programming with UDP Server (on host hostid) Client create socket, port=x, for incoming request: serversocket = DatagramSocket() read request from serversocket create socket, clientsocket = DatagramSocket() Create, address (hostid, port=x), send datagram request using clientsocket write reply to serversocket specifying client host address, port number read reply from clientsocket close clientsocket Page 44

45 Example: Java Client (UDP) import java.io.*; import java.net.*; Provide buffer for input data stream Create client socket Translate hostname into IP address class UDPClient { public static void main(string arg []) throws Exception { BufferedReader infromuser = new BufferedReader(new InputStreamReader(System.in)); DatagramSocket clientsocket = new DatagramSocket(); InetAddress IPAddress = InetAddress.getByName( hostname ); byte[] senddata = new byte[1024]; byte[] receivedata = new byte[1024]; String sentence = infromuser.readline(); senddata = sentence.getbytes (); Page 45

46 Example: Java Client (UDP) Create datagram Send datagram Read datagram from the server DatagramPacket send-pack = new DatagramPacket(sendData, senddata.length, IPAddress, 9876); clientsocket.send(send-pack); DatagramPacket receivepacket = new DatagramPacket(receiveData, receivedata.length); clientsocket.receive(receivepacket); String modifiedsentence = new String(receivePacket.getData()); } System.out.println( FROM SERVER: + modifiedsentence); clientsocket.close(); } Page 46

47 Example: Java Server (UDP) import java.io.*; import java.net.*; Create datagram socket class UDPServer { public static void main(string args[]) throws Exception { DatagramSocket serversocket = new DatagramSocket(9876); byte[] receivedata = new byte[1024]; byte[] senddata = new byte[1024]; Reserve buffer for received datagrams Receive datagram while (true) { DatagramPacket receivepacket = new DatagramPacket(receiveData, receivedata.length); serversocket.receive(receivepacket); Page 47

48 Example: Java Server (UDP) String sentence = new String(receivePacket.getData()); Get IP address and port of the client InetAddress IPAddress = receivepacket.getaddress(); int port = receivepacket.getport(); String capitalizedsentence = sentence.touppercase(); Create datagram for the client Write datagram to socket } } senddata = capitalizedsentence.getbytes(); DatagramPacket sendpacket = new DatagramPacket(sendData, senddata.length, IPAddress, port); serversocket.send(sendpacket); } Wait for the next datagram Page 48

49 Layer 4 Conclusion TCP is used by most application layer protocols (web pages, file transfer, , ), UDP is used if the connection establishment causes too much overhead (network management, name service, ) If speed is important, also UDP is to be preferred (nevertheless, for Internet radio, implementations for both protocols exist) Also further layer 4 protocols were developed but have not become prominent except RTP: RTP sits on top of UDP (still a layer 4 protocol) Adds no control functionality Adds additional header information for providing information like sequence numbers Applications can use of RTP to make use of these information for implementing own control functionality Thus, using RTP allows an application for a trade-off between speed and reliability Page 49

50 Implementation Example In the following: exemplarily implementation of a simplified TCP-like transport protocol, which covers the following segment types: TPDU CALL REQUEST CALL ACCEPTED CLEAR REQUEST CLEAR CONFIRMATION DATA CREDIT Meaning Attempt of a connection establishment Answer to CALL REQUEST Attempt of a connection termination Answer to CLEAR REQUEST Data transmission Control data for the management of the window size Page 50

51 Implementation Example A connection can have one of the following states: Idle no connection is established. Waiting a CONNECT took place, CALL REQUEST is sent. Queued the CALL REQUEST was received but not yet processed. Established connection establishment finished. Sending wait for transmission permission. Receiving the receiver executed a RECEIVE. Disconnecting local call of DISCONNECT. Page 51

52 Implementation Example Page 52

53 Implementation Example Page 53

54 Implementation Example Page 54

55 Implementation Example Page 55

56 Implementation Example Page 56

57 Implementation Example Page 57

58 Implementation Example Page 58

59 Implementation Example Page 59

60 Representation of the protocol as finite state machine Page 60

61 Implementation Example Representation of protocol as finite State Machine (graphical form) Page 61