SK Zadanie 5

From Łukasz Graczykowski

Contents 1 Zadania 1.1 Zadanie 1 1.2 Zadanie 2 1.3 Zadanie 3 2 Protokół UDP 3 Zastosowania UDP 4 Broadcast 5 Multicast 6 Komunikacja UDP w Javie 7 Unicast/Broadcast 7.1 Klasa konfiguracyjna 7.2 Serwer 7.3 Ważniejsze miejsca programu 7.4 Klient 7.5 Ważniejsze miejsca w programie 7.6 Zadanie 1 7.7 Zadanie 2 8 Multicast 8.1 Serwer 8.2 Ważniejsze miejsca programu 8.3 Klient 8.4 Ważniejsze miejsca programu 8.5 Zadanie 3 9 Projekt nr 2

Zadania

Zadanie 1

(Unicast) W parach modyfikujemy podane na stronie przykłady:

Klient:

• Klient po uruchomieniu wysyła “Imię Nazwisko” (np. “Adam Szczurek”) użytkownika do serwera. Następnie odbiera potwierdzenie otrzymania wiadomości z serwera.
• Dalej klient odczytuje informację z konsoli: jeśli użytkownik wpisze “x”, to wysyła zapytanie do serwera o przesłanie listy wszystkich użytkowników; jeśli “z”, to program się kończy; jeśli użytkownik wpisze cokolwiek innego - jest to przesyłane jako kolejna nazwa użytkownika do serwera.

Serwer:

• Serwer dodaje kolenych użytkowników do tablicy: ArrayList<String> clients = new ArrayList<String>(); i przesyła do klienta tekst “Dodano klienta o nazwie: <nazwa>”.
• Jeśli serwer otrzyma “x”, to przesyła do klienta zawartość tablicy clients.

Zadanie 2

(Broadcast) Tworzymy program, który pozwala na sprawdzenie listy obecności na zajęciach (widocznej dla każdego użytkownika sieci).

W parach tworzymy jeden program, który wysyła i odbiera dane jednocześnie (2 wątki):

• Pierwszy wątek (odbierający): w pętli nasłuchuje na wybranym porcie (np. 9111) i jeśli coś otrzyma to wyświetla na ekran w formacie <Wiadomosc> <IP> <PORT>.
• Drugi wątek (wysyłający): w pętli co 1 s wysyła na adres Broadcast pakiet z informacją o loginie (tekst <Imie>).

Zadanie 3

(Multicast) Przerabiamy program z Zadania 2, aby działał na multicast.

Protokół UDP

UDP (User Datagram Protocol) jest protokołem transmisji danych, który ma następujące własności:

• Jest bezstanowy (tj. do wysłania komunikatu nie trzeba nawiązywać połączenia)
• Pakietowy (wysyłamy pakiety)
• Nie zapewnia retransmisji danych
• Opcjonalnie: zawiera sumę kontrolną
• Umożliwia wysyłanie danych do wielu użytkowników

Zastosowania UDP

• Wysyłanie danych do wielu użytkowników

Na przykład synchronizacja plików między wieloma serwerami w jednej sieci. Jeden z serwerów wysyła te same dane do wszystkich podłączonych klientów.

• Usługi zero-konfiguracji

W protokole TCP usługi, które pisaliśmy wymagały posiadania numeru IP serwera. Jest to całkiem uciążliwe w małych sieciach i sieciach ad-hoc. Chcielimbyśmy, by nasza sieć działała tak, że po podłączeniu nasz system może wykryć wszystkie usługi widoczne w sieci.

Tego typu rozwiązania często implementuje się za pomocą UDP. Przykładem może być usługa NetBIOS, będąca częścią systemu sieciowego systemu Microsoft Windows (odpowiednik w systemach Linux nazywa się SAMBA).

• Sieci peer-to-peer

Część sieci peer-to-peer korzysta z UDP zamiast z TCP, ponieważ nie potrzebują obsługi błędów (same posiadają sumy kontrolne poszczególnych plików, nie potrzebujemy zatem kontroli na poziomie protokołu).

• Wysyłanie wielu małych pakietów

Kiedy nasz system wysyla wiele krótkich wiadomości do wielu innych systemów. W takim przypadku okazuje się, że narzut na procedurę handshake TCP jest jest zbyt duży i całość działa mało wydajnie.

Przykład: protokół ustalania czasu (Network Time Protocol) korzysta z UDP do komunikacji z klientami.

• Rozwiązania wymagające niskich opóźnień (latencji)

W przypadku streamingu mediów (audio, video), czy oprogramowania gier sieciowych ważne jest, to by opóźnienie przesłanych informacji było minimalne.

Broadcast

Broadcast jest w zasadzie funkcjonalnością protokołu IP, ale skoro nie można z niego skorzystać z poziomu TCP to mówimy o nim dopiero teraz.

Załóżmy że mamy podsieć o masce: 255.255.254.0 i adresie IP 194.29.174.123, to jeśli wyślemy pakiet na adres 194.29.175.255 (adres w którym wszystkie miejsa w których maska przyjmuje wartość 0 są zamienione na 1) wiadomość taka zostanie wysłana do wszystkich komputerów w danej podsieci.

Maska podsieci (zapisana binarnie):

11111111 11111111 11111110 00000000

Adres komputera (zapisany binarnie):

11000010 00011101 10101110 01111011

Adres Broadcast (zapisany binarnie):

11000010 00011101 10101111 11111111

Multicast

Przesyłanie informacji od wszystkich użytkowników danej podsieci ma wiele zastosowań, ale ma poważne ograniczenia - wiadomości broadcast generalnie są wycinane przez routery, i nie nadają się do komunikacji poza siecią lokalną.

Rozważmy przykładowo telewizję internetową: jeśli korzysta z wiadomości unicast (do jednego odbiorcy) ilość pakietów które wysyła rośnie liniowo z ilością odbiorców - mimo, że każdy odbiorca dostaje taki sam obraz (a w zasadzie: taką samą listę pakietów).

By rozwiązać takie problemy stworzono wiadomości multicast, działają one w następujący sposób:

Zdefiniowano podsieć 224.0.0.0/4 jako podsieć zawierającą adresy multicast, adresy z tego zakresu te są przydzielane przez organizację IANA. Adresy te jednak nie oznaczają żadnych hostów, ale grupy multicast. Poszczególne komputery mogą wyrazić zainteresowanie uczestniczeniem w danej grupie multicast, informację tą wysyłają do swojego najbliższego routera (który, jeśli to konieczne, przesyła ową informację dalej). Od tej chwili pakiety wysłane na dany adres multicast będą przesyłane również do komputera, który zarejestrował się w do danej grupy.

Komunikacja UDP w Javie

Unicast/Broadcast

Klasa konfiguracyjna

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Config {
    public static final int PORT = 9000;
    public static final int BUFFER_SIZE = 1024;
    public static final InetAddress MULTICAST_ADDRESS;
    public static final int MULTICAST_PORT = 9000;
    static {
        try{
            MULTICAST_ADDRESS = InetAddress.getByName("239.255.42.99");
        }catch (UnknownHostException e){
            throw new RuntimeException(e);
        }
    }
}

Serwer

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UTPServer {

    public static void main(String[] args) throws Exception{

        //Otwarcie gniazda z okreslonym portem
        DatagramSocket datagramSocket = new DatagramSocket(Config.PORT);

        byte[] byteResponse = "OK".getBytes("utf8");

        while (true){

            DatagramPacket reclievedPacket
                    = new DatagramPacket( new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);

            datagramSocket.receive(reclievedPacket);

            int length = reclievedPacket.getLength();
            String message =
                    new String(reclievedPacket.getData(), 0, length, "utf8");

            // Port i host który wysłał nam zapytanie
            InetAddress address = reclievedPacket.getAddress();
            int port = reclievedPacket.getPort();

            System.out.println(message);
            Thread.sleep(1000); //To oczekiwanie nie jest potrzebne dla
            // obsługi gniazda

            DatagramPacket response
                    = new DatagramPacket(
                        byteResponse, byteResponse.length, address, port);

            datagramSocket.send(response);
        }
    }
}

Ważniejsze miejsca programu

Przygotowanie do odbierania połączeń UDP na zadanym portcie:

DatagramSocket datagramSocket = new DatagramSocket(9000);

Stworzenie pakietu który będzie odbierał dane:

DatagramPacket reclievedPacket
             = new DatagramPacket( new byte[BUFFER_SIZE], BUFFER_SIZE);

Odebranie pakietu:

datagramSocket.receive(reclievedPacket);

Tutaj jest kolejny detal implementacyjny w Javie: musimy przekształcić ciąg bajtów do instancji klasy string. Zakładamy że dane w pakiecie kodowane są za pomocą utf-8.

int length = reclievedPacket.getLength();
String message =
    new String(reclievedPacket.getData(), 0, length, "utf8");

Wysłanie odpowiedzi:

byte[] byteResponse = "OK".getBytes("utf8");
DatagramPacket response
                 = new DatagramPacket(
                     byteResponse, byteResponse.length, address, port);

Klient

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketTimeoutException;

public class UDPClient {

    public static void main(String[] args) throws IOException {
 
        String message = "tekst";
        InetAddress serverAddress = InetAddress.getByName("localhost");
        System.out.println(serverAddress);

                DatagramSocket socket = new DatagramSocket(); //Otwarcie gniazda
        byte[] stringContents = message.getBytes("utf8"); //Pobranie strumienia bajtów z wiadomosci

        DatagramPacket sentPacket = new DatagramPacket(stringContents, stringContents.length);
        sentPacket.setAddress(serverAddress);
        sentPacket.setPort(Config.PORT);
        socket.send(sentPacket);

        DatagramPacket reclievePacket = new DatagramPacket( new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
        socket.setSoTimeout(1010);

        try{
            socket.receive(reclievePacket);
            System.out.println("Serwer otrzymał wiadomość");
        }catch (SocketTimeoutException ste){
            System.out.println("Serwer nie odpowiedział, więc albo dostał wiadomość albo nie...");
        }
    }
}

Ważniejsze miejsca w programie

Wybieramy do jakiego adresu wysyłamy informacje:

InetAddress serverAddress = InetAddress.getByName(args[0]);

Wysłanie pakietu:

byte[] stringContents = message.getBytes("utf8"); //Pobranie strumienia bajtów z wiadomosci

DatagramPacket sentPacket = new DatagramPacket(stringContents, stringContents.length);
sentPacket.setAddress(serverAddress);
sentPacket.setPort(PORT);

Odebranie odpowiedzi.

Tutaj musimy się na chwilę zatrzymać: w TCP moglibyśmy po prostu poczekać na odpowiedź od serwera, tutaj nie możemy tak zrobić - przecież odpowiedź od serwera może po prostu nie nadejść... należy więc powiedzieć socketowi: poczekaj określony czas na odpowiedż, jeśli nie nadejdzie ona zgłoś wyjątek.

Ustawienie okresu oczekiwania na odpowiedź:

Uwaga: Argument metody setSoTimeout to maksymalny czas oczekiwania na odpowiedź w milisekundach.

socket.setSoTimeout(1010);

Odebranie danych:

DatagramPacket reclievePacket = new DatagramPacket(new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
try{
    socket.receive(reclievePacket);
    System.out.println("Serwer otrzymał wiadomość");
}catch (SocketTimeoutException ste){
    System.out.println("Serwer nie odpowiedział, więc albo dostał wiadomość albo nie...");
}

Zadanie 1

(Unicast) W parach modyfikujemy powyższe przykłady:

Klient:

• Klient po uruchomieniu wysyła “Imię Nazwisko” (np. “Adam Szczurek”) użytkownika do serwera. Następnie odbiera potwierdzenie otrzymania wiadomości z serwera.
• Dalej klient odczytuje informację z konsoli: jeśli użytkownik wpisze “x”, to wysyła zapytanie do serwera o przesłanielisty wszystkich użytkowników; jeśli “z”, to program się kończy; jeśli użytkownik wpisze cokolwiek innego - jest to przesyłane jako kolejna nazwa użytkownika do serwera.

Serwer:

• Serwer dodaje kolenych użytkowników do tablicy: ArrayList<String> clients = new ArrayList<String>(); i przesyła do klienta tekst “Dodano klienta o nazwie: <nazwa>”.
• Jeśli serwer otrzyma “x”, to przesyła do klienta zawartość tablicy clients.

Zadanie 2

(Broadcast) Tworzymy program, który pozwala na sprawdzenie listy obecności na zajęciach (widocznej dla każdego użytkownika sieci).

W parach tworzymy jeden program, który wysyła i odbiera dane jednocześnie (2 wątki):

• Pierwszy wątek (odbierający): w pętli nasłuchuje na wybranym porcie (np. 9111) i jeśli coś otrzyma to wyświetla na ekran w formacie <Wiadomosc> <IP> <PORT>.
• Drugi wątek (wysyłający): w pętli co 1 s wysyła na adres Broadcast pakiet z informacją o loginie (tekst <Imie>).

Multicast

Serwer

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;

public class MulticastServer {
    public static void main(String[] args) throws Exception{

        byte[] responseBytes = "ACK".getBytes();

        InetAddress group = Config.MULTICAST_ADDRESS;
        MulticastSocket s = new MulticastSocket(Config.MULTICAST_PORT);
        s.joinGroup(group);

        try{
            while (true){
                DatagramPacket recv = new DatagramPacket(new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
                s.receive(recv);
                String stringMsg = new String(recv.getData(), 0, recv.getLength(), "utf8");
                System.err.println("Got message: \"" + stringMsg + "\"");
                DatagramSocket responseSocket = new DatagramSocket();
                DatagramPacket response = new DatagramPacket(responseBytes, responseBytes.length);
                response.setAddress(recv.getAddress());
                response.setPort(recv.getPort());
                Thread.sleep(1000); // Ta linijka powoduje wstrzymanie wysyłania odpowiedzi przez
                // jedną sekundę --- nie ma ona związku z obsługą UDP.
                responseSocket.send(response);
            }
        }finally {
            s.leaveGroup(group);
        }
    }
}

Ważniejsze miejsca programu

Stworzenie gniazda multicast - oraz dołączenie do grupy mulitcast

InetAddress group = Config.MULTICAST_ADDRESS; 
MulticastSocket s = new MulticastSocket(Config.MULTICAST_PORT);
s.joinGroup(group);

Klient

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketTimeoutException;

public class MulticastClient {

public static void main(String[] args) throws Exception{
       DatagramSocket s = new DatagramSocket();

       byte[] message = "Test".getBytes("utf8");

 
       DatagramPacket packet = new DatagramPacket(message, message.length);
       packet.setPort(Config.PORT);
       packet.setAddress(Config.MULTICAST_ADDRESS);
       s.send(packet);

       System.out.println("Wysłałem pakiet");
       s.setSoTimeout(1000);
       DatagramPacket response = new DatagramPacket(new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
       try{
           s.receive(response);
           System.out.println("Odpowiedź: ");
           System.out.print(new String(response.getData(), 0,  response.getLength(), "utf8"));
       }catch (SocketTimeoutException e){
           System.out.println("Nie otrzymałem odpowiedzi");
       }
    }
}

Ważniejsze miejsca programu

Wysłanie pakietu na grupę multicast:

DatagramPacket packet = new DatagramPacket(message, message.length);
packet.setPort(Config.PORT);
packet.setAddress(Config.MULTICAST_ADDRESS);
s.send(packet);

Ustawienie timeoutu na odowiedź:

s.setSoTimeout(1000);

Zadanie 3

(Multicast) Przerabiamy program z Zadania 2, aby działał na multicast.

Projekt nr 2

Wybieramy (w parach) projekty z listy: http://www.if.pw.edu.pl/~lgraczyk/sk/html/pd2.html