Socket UDPhf/verif/ens/an09-10/internet/udp-multicast.pdf · UDP provides unreliable transfer of...

Socket UDP

H. Fauconnier 1-1 M2-Internet Java

UDP

H. Fauconnier M2-Internet Java 2

M2-Internet Java 3

Socket programming with UDP

UDP: no “connection” between client and server

  no handshaking   sender explicitly attaches

IP address and port of destination to each segment

  OS attaches IP address and port of sending socket to each segment

  Server can extract IP address, port of sender from received segment

application viewpoint

UDP provides unreliable transfer of groups of bytes (“datagrams”)

between client and server

Note: the official terminology for a UDP packet is “datagram”. In this class, we instead use “UDP segment”.

H. Fauconnier

Running example

 Client:  User types line of text  Client program sends line to server

 Server:  Server receives line of text  Capitalizes all the letters  Sends modified line to client

 Client:  Receives line of text  Displays

M2-Internet Java 4 H. Fauconnier

M2-Internet Java 5

Client/server socket interaction: UDP Server (running on hostid)

close clientSocket

read datagram from clientSocket

create socket, clientSocket = DatagramSocket()

Client

Create datagram with server IP and port=x; send datagram via clientSocket

create socket, port= x. serverSocket = DatagramSocket()

read datagram from serverSocket

write reply to serverSocket specifying client address, port number

H. Fauconnier

M2-Internet Java 6

Example: Java client (UDP)

Output: sends packet (recall that TCP sent “byte stream”)

Input: receives packet (recall thatTCP received “byte stream”)

Client process

client UDP socket

H. Fauconnier

M2-Internet Java 7

Example: Java client (UDP)

import java.io.*; import java.net.*;

class UDPClient { public static void main(String args[]) 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();

Create input stream

Create client socket

Translate hostname to IP

address using DNS

H. Fauconnier

M2-Internet Java 8

Example: Java client (UDP), cont.

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);

clientSocket.send(sendPacket);

DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);

clientSocket.receive(receivePacket);

String modifiedSentence = new String(receivePacket.getData());

System.out.println("FROM SERVER:" + modifiedSentence); clientSocket.close(); } }

Create datagram with data-to-send,

length, IP addr, port

Send datagram to server

Read datagram from server

H. Fauconnier

M2-Internet Java 9

Example: Java server (UDP)

import java.io.*; import java.net.*;

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];

while(true) {

DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); serverSocket.receive(receivePacket);

Create datagram socket

at port 9876

Create space for received datagram

Receive datagram

H. Fauconnier

M2-Internet Java 10

Example: Java server (UDP), cont String sentence = new String(receivePacket.getData());

InetAddress IPAddress = receivePacket.getAddress();

int port = receivePacket.getPort();

String capitalizedSentence = sentence.toUpperCase();

sendData = capitalizedSentence.getBytes();

DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);

serverSocket.send(sendPacket); } } }

Get IP addr port #, of

sender

Write out datagram to socket

End of while loop, loop back and wait for another datagram

Create datagram to send to client

H. Fauconnier

UDP observations & questions  Both client server use DatagramSocket  Dest IP and port are explicitly attached to

segment.  What would happen if change both clientSocket

and serverSocket to “mySocket”?  Can the client send a segment to server without

knowing the server’s IP address and/or port number?

 Can multiple clients use the server?

M2-Internet Java 11 H. Fauconnier

DatagramPacket   Un paquet contient au plus 65,507 bytes   Pour construire les paquet

  public DatagramPacket(byte[] buffer, int length)   public DatagramPacket(byte[] buffer, int offset, int length)

  Pour construire et envoyer   public DatagramPacket(byte[] data, int length,

InetAddress destination, int port)   public DatagramPacket(byte[] data, int offset,

int length, InetAddress destination, int port)

  public DatagramPacket(byte[] data, int length, SocketAddress destination, int port)

  public DatagramPacket(byte[] data, int offset, int length, SocketAddress destination, int port)


Exemple String s = "On essaie…"; byte[] data = s.getBytes("ASCII");

try { InetAddress ia =

InetAddress.getByName("www.liafa.jussieu.fr"); int port = 7;// existe-t-il? DatagramPacket dp = new DatagramPacket(data,

data.length, ia, port); } catch (IOException ex) }


Méthodes

 Adresses  public InetAddress getAddress( )

 public int getPort( )

 public SocketAddress

getSocketAddress( )

 public void setAddress(InetAddress remote)

 public void setPort(int port)

 public void setAddress(SocketAddress remote)


Méthodes (suite)

 Manipulation des données:  public byte[] getData( )

 public int getLength( )

 public int getOffset( )

 public void setData(byte[] data)

 public void setData(byte[] data, int offset, int length )

 public void setLength(int length)


Exemple import java.net.*; public class DatagramExample { public static void main(String[] args) { String s = "Essayons."; byte[] data = s.getBytes( ); try { InetAddress ia = InetAddress.getByName("www.liafa.jussieu.fr"); int port =7; DatagramPacket dp = new DatagramPacket(data, data.length, ia,

port); System.out.println(" Un packet pour" + dp.getAddress( ) + " port

" + dp.getPort( )); System.out.println("il y a " + dp.getLength( ) +

" bytes dans le packet"); System.out.println( new String(dp.getData( ), dp.getOffset( ), dp.getLength( ))); } catch (UnknownHostException e) { System.err.println(e); } } }


DatagramSocket

  Constructeurs   public DatagramSocket( ) throws SocketException

  public DatagramSocket(int port) throws SocketException

  public DatagramSocket(int port, InetAddress interface) throws SocketException

  public DatagramSocket(SocketAddress interface) throws SocketException

  (protected DatagramSocket(DatagramSocketImpl impl) throws SocketException)


Exemple java.net.*; public class UDPPortScanner {

public static void main(String[] args) {

for (int port = 1024; port <= 65535; port++) { try { // exception si utilisé

DatagramSocket server = new DatagramSocket(port); server.close( ); } catch (SocketException ex) { System.out.println("Port occupé" + port + ".");

} // end try } // end for } }


Envoyer et recevoir

  public void send(DatagramPacket dp) throws IOException

  public void receive(DatagramPacket dp) throws IOException


Un exemple: Echo

 UDPServeur  UDPEchoServeur

 UDPEchoClient •  SenderThread •  ReceiverThread


Echo: UDPServeur import java.net.*; import java.io.*; public abstract class UDPServeur extends Thread { private int bufferSize; protected DatagramSocket sock; public UDPServeur(int port, int bufferSize) throws SocketException { this.bufferSize = bufferSize; this.sock = new DatagramSocket(port); } public UDPServeur(int port) throws SocketException { this(port, 8192); } public void run() { byte[] buffer = new byte[bufferSize]; while (true) { DatagramPacket incoming = new DatagramPacket(buffer, buffer.length); try { sock.receive(incoming); this.respond(incoming); } catch (IOException e) { System.err.println(e); } } // end while } public abstract void respond(DatagramPacket request); }


UDPEchoServeur public class UDPEchoServeur extends UDPServeur { public final static int DEFAULT_PORT = 2222; public UDPEchoServeur() throws SocketException { super(DEFAULT_PORT);

} public void respond(DatagramPacket packet) {

try { byte[] data = new byte[packet.getLength()]; System.arraycopy(packet.getData(), 0, data, 0, packet.getLength());

try { String s = new String(data, "8859_1");

System.out.println(packet.getAddress() + " port " + packet.getPort() + " reçu " + s); } catch (java.io.UnsupportedEncodingException ex) {}

DatagramPacket outgoing = new DatagramPacket(packet.getData(), packet.getLength(), packet.getAddress(), packet.getPort());

sock.send(outgoing); } catch (IOException ex) { System.err.println(ex);

} }

}


Client: UDPEchoClient

public class UDPEchoClient { public static void lancer(String hostname, int port) { try { InetAddress ia = InetAddress.getByName(hostname); SenderThread sender = new SenderThread(ia, port); sender.start(); Thread receiver = new ReceiverThread(sender.getSocket()); receiver.start(); } catch (UnknownHostException ex) { System.err.println(ex); } catch (SocketException ex) { System.err.println(ex); }

} // end lancer }


ReceiverThread class ReceiverThread extends Thread { DatagramSocket socket; private boolean stopped = false; public ReceiverThread(DatagramSocket ds) throws SocketException {

this.socket = ds; }

public void halt() { this.stopped = true; }

public DatagramSocket getSocket(){ return socket;

} public void run() { byte[] buffer = new byte[65507];

while (true) { if (stopped) return;

DatagramPacket dp = new DatagramPacket(buffer, buffer.length); try { socket.receive(dp);

String s = new String(dp.getData(), 0, dp.getLength()); System.out.println(s);

Thread.yield(); } catch (IOException ex) {System.err.println(ex); } }

} }


SenderThread

public class SenderThread extends Thread { private InetAddress server; private DatagramSocket socket; private boolean stopped = false; private int port; public SenderThread(InetAddress address, int port) throws SocketException { this.server = address; this.port = port; this.socket = new DatagramSocket(); this.socket.connect(server, port); } public void halt() { this.stopped = true; } //…


SenderThread //… public DatagramSocket getSocket() { return this.socket; }

public void run() {

try { BufferedReader userInput = new BufferedReader(new

InputStreamReader(System.in)); while (true) { if (stopped) return;

String theLine = userInput.readLine(); if (theLine.equals(".")) break; byte[] data = theLine.getBytes();

DatagramPacket output = new DatagramPacket(data, data.length, server, port);

socket.send(output); Thread.yield(); }

} // end try catch (IOException ex) {System.err.println(ex); }

} // end run }


Autres méthodes   public void close( )   public int getLocalPort( )   public InetAddress getLocalAddress( )   public SocketAddress getLocalSocketAddress( )   public void connect(InetAddress host, int port)   public void disconnect( )   public void disconnect( )   public int getPort( )   public InetAddress getInetAddress( )   public InetAddress getRemoteSocketAddress( )


Options   SO_TIMEOUT

  public synchronized void setSoTimeout(int timeout) throws SocketException

  public synchronized int getSoTimeout( ) throws IOException   SO_RCVBUF

  public void setReceiveBufferSize(int size) throws SocketException   public int getReceiveBufferSize( ) throws SocketException

  SO_SNDBUF   public void setSendBufferSize(int size) throws SocketException   int getSendBufferSize( ) throws SocketException

  SO_REUSEADDR (plusieurs sockets sur la même adresse)   public void setReuseAddress(boolean on) throws SocketException   boolean getReuseAddress( ) throws SocketException

  SO_BROADCAST   public void setBroadcast(boolean on) throws SocketException   public boolean getBroadcast( ) throws SocketException


Multicast

29 H. Fauconnier

M2-Internet Java

M2-Internet Java 4-30

R1

R2

R3 R4

source duplication

R1

R2

R3 R4

in-network duplication

duplicate creation/transmission duplicate

duplicate

Broadcast Routing  Deliver packets from srce to all other nodes  Source duplication is inefficient:

❒ Source duplication: how does source determine recipient addresses

H. Fauconnier


In-network duplication

 Flooding: when node receives brdcst pckt, sends copy to all neighbors   Problems: cycles & broadcast storm

 Controlled flooding: node only brdcsts pkt if it hasn’t brdcst same packet before  Node keeps track of pckt ids already brdcsted  Or reverse path forwarding (RPF): only forward

pckt if it arrived on shortest path between node and source

 Spanning tree  No redundant packets received by any node

H. Fauconnier


A

B

G

D E

c

F

A

B

G

D E

c

F

(a) Broadcast initiated at A (b) Broadcast initiated at D

Spanning Tree

 First construct a spanning tree  Nodes forward copies only along spanning

tree

H. Fauconnier


A

B

G

D E

c

F 1

2

3

4

5

(a)  Stepwise construction of spanning tree

A

B

G

D E

c

F

(b) Constructed spanning tree

Spanning Tree: Creation   Center node   Each node sends unicast join message to center

node   Message forwarded until it arrives at a node already

belonging to spanning tree

H. Fauconnier

Multicast

 Groupe: adresse IP de classe D  Un hôte peut joindre un groupe

 Protocole pour établir les groupes (IGMP)  Protocole et algorithme pour le routage

M2-Internet Java 4-34 H. Fauconnier

IGMP

 IGMP (internet Group Management Protocol  Entre un hôte et son routeur (multicast)

•  Membership_query: du routeur vers tous les hôtes pour déterminer quels hôtes appartiennent à quels groupe

•  Membership_report: des hôtes vers le routeur •  Membership_leave: pour quitter un groupe (optionnel)


Multicast Routing: Problem Statement  Goal: find a tree (or trees) connecting

routers having local mcast group members   tree: not all paths between routers used   source-based: different tree from each sender to rcvrs   shared-tree: same tree used by all group members

Shared tree Source-based trees H. Fauconnier 1-36 M2-Internet Java

Approaches for building mcast trees

Approaches:  source-based tree: one tree per source

  shortest path trees   reverse path forwarding

 group-shared tree: group uses one tree  minimal spanning (Steiner)   center-based trees

…we first look at basic approaches, then specific protocols adopting these approaches


Shortest Path Tree

 mcast forwarding tree: tree of shortest path routes from source to all receivers  Dijkstra’s algorithm

R1

R2

R3

R4

R5

R6 R7

2 1

6

3 4 5

i

router with attached group member

router with no attached group member link used for forwarding, i indicates order link added by algorithm

LEGEND S: source


Reverse Path Forwarding

if (mcast datagram received on incoming link on shortest path back to center)

then flood datagram onto all outgoing links else ignore datagram

 rely on router’s knowledge of unicast shortest path from it to sender

 each router has simple forwarding behavior:


Reverse Path Forwarding: example

•  result is a source-specific reverse SPT –  may be a bad choice with asymmetric links

R1

R2

R3

R4

R5

R6 R7

router with attached group member

router with no attached group member datagram will be forwarded

LEGEND S: source

datagram will not be forwarded


Reverse Path Forwarding: pruning   forwarding tree contains subtrees with no mcast

group members   no need to forward datagrams down subtree   “prune” msgs sent upstream by router with no

downstream group members

R1

R2

R3

R4

R5

R6 R7

router with attached group member router with no attached group member prune message

LEGEND S: source

links with multicast forwarding

P

P

P


Shared-Tree: Steiner Tree

 Steiner Tree: minimum cost tree connecting all routers with attached group members

 problem is NP-complete  excellent heuristics exists  not used in practice:

  computational complexity   information about entire network needed  monolithic: rerun whenever a router needs to

join/leave


Center-based trees

 single delivery tree shared by all  one router identified as “center” of tree  to join:

  edge router sends unicast join-msg addressed to center router

  join-msg “processed” by intermediate routers and forwarded towards center

  join-msg either hits existing tree branch for this center, or arrives at center

  path taken by join-msg becomes new branch of tree for this router


Center-based trees: an example

Suppose R6 chosen as center:

R1

R2

R3

R4

R5

R6 R7

router with attached group member router with no attached group member path order in which join messages generated

LEGEND

2 1

3

1


Internet Multicasting Routing: DVMRP

 DVMRP: distance vector multicast routing protocol, RFC1075

 flood and prune: reverse path forwarding, source-based tree  RPF tree based on DVMRP’s own routing tables

constructed by communicating DVMRP routers   no assumptions about underlying unicast   initial datagram to mcast group flooded

everywhere via RPF   routers not wanting group: send upstream prune

msgs H. Fauconnier 1-45 M2-Internet Java

DVMRP: continued…  soft state: DVMRP router periodically (1 min.)

“forgets” branches are pruned:  mcast data again flows down unpruned branch  downstream router: reprune or else continue to

receive data  routers can quickly regraft to tree

  following IGMP join at leaf  odds and ends

  commonly implemented in commercial routers  Mbone routing done using DVMRP


Tunneling Q: How to connect “islands” of multicast

routers in a “sea” of unicast routers?

  mcast datagram encapsulated inside “normal” (non-multicast-addressed) datagram

  normal IP datagram sent thru “tunnel” via regular IP unicast to receiving mcast router

  receiving mcast router unencapsulates to get mcast datagram

physical topology logical topology


PIM: Protocol Independent Multicast

  not dependent on any specific underlying unicast routing algorithm (works with all)

  two different multicast distribution scenarios :

Dense:   group members densely

packed, in “close” proximity.   bandwidth more plentiful

Sparse:   # networks with group members

small wrt # interconnected networks   group members “widely dispersed”   bandwidth not plentiful


Consequences of Sparse-Dense Dichotomy: Dense   group membership by

routers assumed until routers explicitly prune

  data-driven construction on mcast tree (e.g., RPF)

  bandwidth and non-group-router processing profligate

Sparse:   no membership until

routers explicitly join   receiver- driven

construction of mcast tree (e.g., center-based)

  bandwidth and non-group-router processing conservative


PIM- Dense Mode

flood-and-prune RPF, similar to DVMRP but   underlying unicast protocol provides RPF info for incoming

datagram   less complicated (less efficient) downstream flood than DVMRP

reduces reliance on underlying routing algorithm   has protocol mechanism for router to detect it is a leaf-node

router


PIM - Sparse Mode

  center-based approach   router sends join msg

to rendezvous point (RP)   intermediate routers

update state and forward join

  after joining via RP, router can switch to source-specific tree   increased performance:

less concentration, shorter paths

R1

R2

R3

R4

R5

R6 R7

join

join

join

all data multicast from rendezvous point

rendezvous point


PIM - Sparse Mode

sender(s):   unicast data to RP,

which distributes down RP-rooted tree

  RP can extend mcast tree upstream to source

  RP can send stop msg if no attached receivers   “no one is listening!”

R1

R2

R3

R4

R5

R6 R7

join

join

join

all data multicast from rendezvous point

rendezvous point


Multicast

 Géré par les routeurs  Pas de garantie…

  Importance du ttl •  (Évaluation)

–  Local:0 –  Sous-réseau local:1 –  Pays:48 –  Continent:64 –  Le monde:255


Multicast

 Un groupe est identifié par une adresse IP (classe D) entre 224.0.0.0 et 239.255.255.255

 Une adresse multicast peut avoir un nom  Exemple ntp.mcast.net 224.0.1.1


Sockets multicast

 Extension de DatagramSocket   public class MulticastSocket extends DatagramSocket

 Principe:  Créer une MulticastSocket  Rejoindre un group: joinGroup()

•  Créer DatagramPacket –  Receive()

• leaveGroup()  Close()


Création try {

MulticastSocket ms = new MulticastSocket( );

// send datagrams...

}catch (SocketException se){System.err.println(se);}

-------

try {

SocketAddress address = new InetSocketAddress("192.168.254.32", 4000);

MulticastSocket ms = new MulticastSocket(address);

// receive datagrams...

}catch (SocketException ex) {System.err.println(ex);}


Création try {

MulticastSocket ms = new MulticastSocket(null);

ms.setReuseAddress(false);

SocketAddress address = new InetSocketAddress(4000);

ms.bind(address);

// receive datagrams...

}catch (SocketException ex) { System.err.println(ex);}


Rejoindre… try {

MulticastSocket ms = new MulticastSocket(4000);

InetAddress ia = InetAddress.getByName("224.2.2.2"); ms.joinGroup(ia);

byte[] buffer = new byte[8192];

while (true) {

DatagramPacket dp = new DatagramPacket(buffer, buffer.length);

ms.receive(dp);

String s = new String(dp.getData( ), "8859_1");

System.out.println(s);

}

}catch (IOException ex) { System.err.println(ex);}


send try {

InetAddress ia =

InetAddress.getByName("experiment.mcast.net");

byte[] data = "un packet…\r\n".getBytes( );

int port = 4000;

DatagramPacket dp = new DatagramPacket(data, data.length, ia, port);

MulticastSocket ms = new MulticastSocket( );

ms.send(dp,64);

}catch (IOException ex) {System.err.println(ex);}


Socket UDPhf/verif/ens/an09-10/internet/udp-multicast.pdf · UDP provides unreliable transfer of...

Documents

Transcript of Socket UDPhf/verif/ens/an09-10/internet/udp-multicast.pdf · UDP provides unreliable transfer of...