SK Zadanie 5

  {| align="right"
  | __TOC__
  |}

<span style="color:red">'''UWAGA! Zajęcia 4 - nowa kolejność'''</span>

==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 pyta użytkownika, czy chce poznać nazwiska innych, którzy łączyli się do serwera (y/n).
** Jeśli tak, to wysyła "y" do serwera, a następnie pobiera od niego pakiet z odpowiedzią i wyświetla ją na ekranie.
** Jeśli nie, to kończy działanie.

Serwer:
* Serwer w pętli przyjmuje pakiety przychodzące.
**Jeśli przychodząca wiadomość nie jest równa y (!message.equals("y")), to  dodaje kolejnych 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 “y”, 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: <code>255.255.254.0</code> i adresie IP <code>194.29.174.123</code>, to jeśli wyślemy pakiet na adres <code>194.29.175.255</code> (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ć <code>224.0.0.0/4</code> 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 UDPServer {
 
     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 receivedPacket
                     = new DatagramPacket( new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
 
             datagramSocket.receive(receivedPacket);
 
             int length = receivedPacket.getLength();
             String message =
                     new String(receivedPacket.getData(), 0, length, "utf8");
 
             // Port i host który wysłał nam zapytanie
             InetAddress address = receivedPacket.getAddress();
             int port = receivedPacket.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 receivedPacket
              = new DatagramPacket( new byte[BUFFER_SIZE], BUFFER_SIZE);

Odebranie pakietu:

 datagramSocket.receive(receivedPacket);

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 = receivedPacket.getLength();
 String message =
     new String(receivedPacket.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 recievePacket = new DatagramPacket( new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
         socket.setSoTimeout(1010);
 
         try{
             socket.receive(recievePacket);
             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("localhost");

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 <code>setSoTimeout</code> to maksymalny czas oczekiwania na odpowiedź w milisekundach.

 socket.setSoTimeout(1010);

Odebranie danych:

 DatagramPacket receivedPacket = new DatagramPacket(new byte[Config.BUFFER_SIZE], Config.BUFFER_SIZE);
 try{
     socket.receive(receivedPacket);
     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 pyta użytkownika, czy chce poznać nazwiska innych, którzy łączyli się do serwera (y/n).
** Jeśli tak, to wysyła "y" do serwera, a następnie pobiera od niego pakiet z odpowiedzią i wyświetla ją na ekranie.
** Jeśli nie, to kończy działanie.

Serwer:
* Serwer w pętli przyjmuje pakiety przychodzące.
**Jeśli przychodząca wiadomość nie jest równa y (!message.equals("y")), to  dodaje kolejnych 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 “y”, 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


== Rozwiązania ==
* Zadanie 1 (lista): [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad1_Lista/Zad1_Server.java Zad1_Server.java] [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad1_Lista/Zad1_Klient.java Zad1_Klient.java] [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad1_Lista/Config.java Config.java]

* Zadanie 2 (wątki, broadcast): [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad2_Watki/Zad2_KlientSerwer.java Zad2_KlientSerwer.java] [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad2_Watki/Config.java Config.java]

* Zadanie 2 (wątki, multicast): [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad3_Multicast/Zad3_KlientSerwer_Multicast.java Zad3_KlientSerwer_Multicast.java] [https://www.if.pw.edu.pl/~lgraczyk/SK2022/lato/UDP/Zad3_Multicast/Config.java Config.java]