# Ćwiczenia 9, grupa cz. 10-12, 15 grudnia 2022

###### tags: `SO22` `ćwiczenia` `pwit`

## Deklaracje

Gotowość rozwiązania zadania należy wyrazić poprzez postawienie X w odpowiedniej kolumnie! Jeśli pożądasz zreferować dane zadanie (co najwyżej jedno!) w trakcie dyskusji oznacz je znakiem ==X== na żółtym tle.

**UWAGA: Tabelkę wolno edytować tylko wtedy, gdy jest na zielonym tle!**

:::warning
**Uwaga**: Dzisiaj deklarujemy zadania **5 -- 8** z **listy 8** oraz **1 -- 4** z **listy 9**.

Formularz deklaracji **listy 8**:
[https://hackmd.io/@iiuwr-kba/SJnaGQJOj/edit](https://hackmd.io/@iiuwr-kba/SJnaGQJOj/edit)

:::

:::danger
| | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| ----------------------:| ----- | --- | --- | --- | --- | --- | --- | --- | --- |
Miriam Bouhajeb | X | X | X | X | | | | | |
Kacper Chmielewski | | X | X | | | | | | |
Jan Jankowicz | | X | X | | | X | X | X | |
Jakub Kaczmarek | | | | | | | | | |
Jarosław Kadecki | X | X | X | X | | | | | |
Zuzanna Kania | | X | | | | X | | | |
Julia Konefał | | | | | | | | | |
Daniel Sarniak | | | | | | | | | |
Paweł Tkocz | | X | | | | X | X | X | |
Miłosz Urbanik | X | X | X | X | | X | X | | |
Tomasz Wołczański | | | | | X | X | X | X | |
Radosław Śliwiński | | X | X | | | | | | |
:::

:::info
**Uwaga:** Po rozwiązaniu zadania należy zmienić kolor nagłówka na zielony.
:::

## Zadanie 1
:::success
Autor: Miriam Bouhajeb

Segment - pojedynczy fragment danych o pojemności 1024 bajtów

Pakiet - jednostka danych, powstała z podzielenia danych, które są wysyłane z jednego systemu do drugiego. Każdy z nich jest segmentem z dodanym nagłówkiem.

Datagramy - pakiety warstwy sieciowej

Ramka - jednostka komunikacji w warstwie łącza.
Warstwa łącza enkasułuje pakiety z warstwy sieciowej i enkapsułuje je w ramki. Jeśli rozmiar ramki jest zbyt duży, wtedy pakiet może być rozdzielony na mniejsze ramki.

Protokoły warstwy transportowej
Ich rolą jest transportowanie wiadomości wyższej warstwy - application-layer, pomiędzy endpointami.
Wyróżniamy dwa takie protokoły - UDP i TCP.

Protokoły warstwy transportowej
Ich rolą jest transportowanie wiadomości wyższej warstwy - application-layer, pomiędzy endpointami.
Wyróżniamy dwa takie protokoły - UDP i TCP.

Protokoły warstwy sieciowej
Są one odpowiedzialne za transportowanie pakietów warstwy sieciowej, zwanych datagramami, z jednego hosta do drugiego. Protokoły warstwy transportowej
przekazują segment warstwy transportowej i adres docelowy do warstwy sieciowej, niemalże jak nadawanie listu na pocztę z czyimś adresem. Warstwa sieciowa, udostępnia wtedy usługę dostarczenia segmentu do warswy transportowej hosta docelowego.
Jednym z protokołów warstwy transportowej jest protokół IP, który definiuje pola w datagramie, tak jak zachowania ich względem. W tej warstwie są też protokoły, które ustalają ścieżki datagramów
od źródła do końcowego hosta.

Protokoły warstwy łącza
Warstwa sieciowa wysyła datagramy które wędrują przez wiele routerów będących pomiędzy źródłem a celem. Aby wysyłać pakiety z jednego wierzchołka (hosta lub routera) do drugiego, warstwa sieciowa polega na warstwie łącza i jej protokołach. Warstwa sieciowa w każdym napotkanym wierzchołku przekazuje datagram warstwie łącza, która przekazuje go do innego wierzchołka, z którego znów protokoły warstwy łącza przekazują go do warstwy sieciowej.

:::

## Zadanie 2
:::success
Autor: Miłosz Urbanik
:::


UDP (user datagram protocol)
- protokół bezpołączeniowy, serwer i klient nie tworzą połączenia przed rozpoczęciem
transmisji danych
- przy użyciu jednego gniazda, możemy komunikować się z wieloma hostami
- używamy pary funkcji sendto() i recvfrom(), w których określamy adres hosta do
którego wysyłamy lub od którego odbieramy dane
- brak gwaracji co do kompletności przesłanych danych

TCP (transmission control protocol)
- protokół połączeniowy, serwer i klient tworzą pomiedzy sobą połączenie,
gniazdo ma przypisaną informację o parze hostów, które będą się komunikować
- odczyty zapisy, wykonywane przy użyciu read, write
- odbiór każdego segmentu jest potwierdzany, jeśli brak potwierdzenia - wyślij jeszcze raz

**Komunikacja duplexowa** (full-duplex)- w każdej chwili możliwe jest przesyłanie danych w obie strony,
**pól duplexowa** (half-duplex) - w danej chwili komunikacja może odbywać się tylko w jedną stronę (wysyłamy/odbieramy naprzemiennie)

- TCP dzieląc przesyłane dane na segmenty nadaje im numery, na ich podstawie można odtworzyć ich prawidłową kolejność. Każdy segment musi zostać potwierdzony, brak potwierdzenie skutkuje retransmisją.

- Zerwane połączenie - gniazdo TCP przechowuje informacje o czasie od ostatniej wymiany danych, a także liczbie retransmisji segmentu, gdy nie otrzymamy ACK. Po przekroczeniu granicznego czasu od ostatniego "kontaktu" lub granicznej liczby retransmisji, jądro zamknie gniazdo. Używanie funkcji systemowych na zamkniętym gnieździe zakończy się błędem, np `EPIPE` dla `read()`.
- Sterowanie przepływem - protokół TCP dynamicznie informuje jaką liczbę bajtów może jeszcze przyjąć, zapobiega to przepełnieniu bufora. Kontrola nad liczbą równocześnie nadawanych (oczekujących na potwierdzenie) segmentów pozwala na zredukowanie obciążenia sieci (nie nadajemy niepotrzebnie) i zwiększenie przepustowości.

## Zadanie 3
:::success
Autor: Jan Jankowicz
:::
>Omów diagram [7, 4.1] komunikacji klient-serwer używającej protokołu tcp(7) przy pomocy interfejsu gniazd strumieniowych.

Klient-serwer - serwer nasłuchuje i akceptuje nowe połączenia, a klient się łączy.

Klient najpierw tworzy socket (gniazdo), któremu określa sposób komunikacji z przyszłym serwerem (np. przez TPC za pomocą IPv4). Zwracany jest deskryptor tego socketa, do którego będzie można pisać, i z którego będzie można czytać jak ze zwykłego pliku w celu komunikacji ze zdalnym serwerem (podobnie jak rura).
Następnie klient próbuje się połączyć (TCP) za pomocą metody connect do innego serwera i powiązać otrzymany krok wcześniej socket z danym połączeniem. Tutaj również zostanie nadany adres IP dla tego socketa wraz z portem efemerycznym (ulotnym), po to by serwer, do którego się połączymy mógł również przesyłać informacje do klienta.

Aby połączenie mogło nastąpić, serwer musi akceptować prośby o nawiązanie połączenia. By do tego doszło, serwer także musi utworzyć odpowiednie gniazdo jak klient, a potem powiązać go za pomocą metody bind z pewnym lokalnym adresem IP i portem. Tak utworzony socket nie służy jednak do wymiany danych, ale do nawiązywania połączeń. Dalej dzięki metodzie listen nakazujemy systemowi nasłuchuchiwać na tym adresie próśb o nawiązanie połączenia. Tym sposobem serwer jest gotowy do akceptacji takich próśb za pomocą metody accept.

Jeśli udało się nawiązać połączenie metodą accept, to serwer otrzymuje nowy socket, a tym samym i klient, i serwer mogą pisać do swoich socketów i odczytywać z nich dane. Gdy klient wyśle EOF, to serwer odczyta tą informację i uznaje połączenie za zakończone, po czym ponownie może próbować zaakceptować nowe połączenie.

---

>W którym momencie następuje związanie gniazda z adresem lokalnym i zdalnym?

Z lokalnym u klienta przed connectem, a w serwerze w bind. Ze zdalnym w momencie nawiązania połączenia.

---

>Która ze stron komunikacji używa portów ulotnych (ang. ephemeral)?

Gniazdo klienta posiada tak określony port.

---

>Co specyfikuje drugi argument wywołania systemowego listen(2)?

Parametr 'int backlog' określa maksymalną długość kolejki połączeń oczekujących na zaakceptowanie.

---

>Z jakim numerem portu jest związane gniazdo przekazywane do i zwracane z accept(2)?

Z tym samym, który został mu nadany przez metodę bind. Jednak socket zwracany przez metodę accept ma również określony adres i port gniazda odbiorcy.

---

>Skąd serwer wie, że klient zakończył połączenie?

Serwer dowiaduje się o zakończeniu połączenia, gdy klient prześle EOF.

## Zadanie 4
:::success
Autor: Jarosław Kadecki


gniazda datagramowe - 

Klient nie ustanawia połączenia z serwerem tylko używa sendto() do wysyłania datagramów. Serwer nie akceptuje połączenia od klienta, jedynie używa recvfrom().

ssize_t recvfrom(int sockfd, void *buff, size_t nbytes, int flags, struct sockaddr *from,
socklen_t *addrlen)

sockfd, buff, nbytes - tak samo jak dla read
flags -

from - wskaźnik na strukturę zaawierającą adres nadawcy
addrlen - rozmiar struktury z adresem
Zwracana jest ilość odczytanych bajtów

ssize_t sendto(int sockfd, const void *buff, size_t nbytes, int flags, const
struct sockaddr *to, socklen_t addrlen)

sockfd, buff, nbytes - tak samo jak dla write
flags -

to - wskaźnik na strukturę zawierającą adres odbiorcy
addrlen - rozmiar struktury z adresem
Zwracana jest ilość wpisanych bajtów

Serwer UDP jest bezpołączeniowy, może obsługiwać dowolną ilość wysłanych datagramów, od różnych adresatów, bez konieczności rezerwowania dla nich gniazda.

Przy implementacji pokazanej na schemacie serwer używa jednego gniazda mogącego obsłużyć wielu klientów. Przy wykorzystaniu read() i write() nie możnabyłoby zidentyfikować nadawcy i prowadzić komunikacji w stronę klienta.

Użycie connect() przyporządkowuje gniazdo do klienta. Po jego użyciu wszelkie datagramy przekazane do gniazda są automatycznie jemu wysyłane. (dalej można użyć sendto() ale wtedy zgodnie z POSIX, argument to musi być równy NULL, a argument addrlen musi być równy 0).

Analogicznie dzieje się z otrzymywaniem datagramów. Jedyne datagramy zwracane przez jądo, wchodzące do gniazda, to te które wysłał skojarzony klient.(dalej można użyć recvfrom() ale wtedy zgodnie z POSIX, argument from musi być równy NULL, a argument addrlen musi być równy 0).

ssize_t recvmsg(int socket, struct msghdr *message, int flags)
ssize_t sendmsg(int socket, const struct msghdr *message, int flags)


Przy wykorzystaniu sendmsg i recvmsg nie mamy z góry narzuconych pól struktury message w momencie skojarzenia gniazda z adresatem (przy użyciu socket).

:::

## Zadanie 5
:::success
Autor: Tomasz Wołczański
:::

`read` może zwrócić *short count*, gdy w danym momencie zostało przetransmitowanych mniej danych niż zażądano, tzn. w buforze gniazda znajduje się mniej bajtów niż zażądana ilość. `write` zwróci *short count*, gdy bufor gniazda nie jest w stanie w danym momencie pomieścić żądanej liczby bajtów. Dodatkowo `read` i `write` mogą zwrócić *short count*, gdy zostaną przerwane przez sygnał.

Jeśli użyjemy funkcji `recvmsg` i datagram UDP zostanie obcięty przez jądro w trakcie kopiowania do bufora podanego przez użytkownika (bo rozmiar bufora był mniejszy niż rozmiar datagramu), to w polu `msg_flags` struktury przekazanej jako argument do `recvmsg` zostanie ustawiona flaga `MSG_TRUNC`.

Operacje na gniazdach (`read`, `write`, `sendto`, `recvfrom`, itd.) zwrócą błąd `EINTR`, gdy zostaną przerwane przez sygnał przed tym, jak przetransferują jakiekolwiek dane.

Gdy klient spróbuje zapisać do gniazda powiązanego z połączeniem, które serwer zdążył już zamknąć, do procesu klienta zostanie dostarczony sygnał `SIGPIPE`.

W kodzie funkcji `open_listenfd` użyto wywołania `setsockopt` z opcją `SO_REUSEADDR`, aby uniknąć błędu `EADDRINUSE` zwracanego przez `bind` po restarcie serwera. Błąd może wystąpić w następujących sytuacjach:
* od wyłączenia serwera do wywołania `bind` po restarcie nie minęło dostatecznie dużo czasu - punkt końcowy TCP z poprzedniej instancji serwera pozostaje w stanie `TIME_WAIT` przez jakiś czas po zakończeniu procesu serwera
* poprzednia instancja serwera utworzyła proces potomny do obsłużenia żądania i proces ten nie zakończył się do momentu wywołania `bind` w nowej instancji, a więc utrzymywał nadal punkt końcowy TCP na porcie serwera

W obu tych sytuacjach punkt końcowy nie jest w stanie przyjmować nowych połączeń. Zgodnie ze specyfikacją TCP, port powiązany z tym punktem końcowym może być użyty ponownie, ale domyślnie na Linuksie nie może (do jednego portu może być przypisane tylko jedno połączenie TCP). Użycie wywołania `setsockopt` z opcją `SO_REUSEADDR` powoduje, że w powyższych sytuacjach `bind` nie zwróci błędu, tzn. będziemy w stanie przypisać do portu gniazdo nasłuchujące pomimo tego, że istnieje jeszcze połączenie TCP powiązane z tym portem (które nie może przyjmować nowych połączeń).

int open_listenfd(char *port) {
    struct addrinfo hints, *listp, *p;
    int listenfd, optval=1;
    
    /* Get a list of potential server addresses */
    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_socktype = SOCK_STREAM; /* Accept connect. */
    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; /* ...on any IP addr */
    hints.ai_flags |= AI_NUMERICSERV; /* ...using port no. */
    Getaddrinfo(NULL, port, &hints, &listp);
    
    /* Walk the list for one that we can bind to */
    for (p = listp; p; p = p->ai_next) {
        /* Create a socket descriptor */
        if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0)
            continue; /* Socket failed, try the next */
        
        /* Eliminates "Address already in use" error from bind */
        Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval, sizeof(int));
        
        /* Bind the descriptor to the address */
        if (bind(listenfd, p->ai_addr, p->ai_addrlen) == 0)
            break; /* Success */
        Close(listenfd); /* Bind failed, try the next */
    }
    
    /* Clean up */
    Freeaddrinfo(listp);
    if (!p) /* No address worked */
        return -1;
    
    /* Make it a listening socket ready to accept conn. requests */
    if (listen(listenfd, LISTENQ) < 0) {
        Close(listenfd);
        return -1;
    }
    return listenfd;
}

## Zadanie 6
:::success
Autor: Miłosz Urbanik

:::

Zmodyfikowany kod programu

int main(int argc, char **argv) {
  struct addrinfo *p, *listp, hints;
  char buf[MAXLINE];
  int rc, flags;

  const char* service;
  char serv_port[5];

  if (argc == 2){
    service = NULL;
  } else if (argc == 3){
    service = argv[2];
  } else {
    app_error("usage: %s <domain name>\n", argv[0]);
  }

  /* Get a list of addrinfo records */
  memset(&hints, 0, sizeof(struct addrinfo));
  hints.ai_family = AF_UNSPEC; /* either ipv4 or ipv6 */
  hints.ai_socktype = 0; /* any socket address type, 
    TFTP would use SOCK_DGRAM, HTTP uses SOCK_STREAM */
  /* Connections only */
  if ((rc = getaddrinfo(argv[1], service, &hints, &listp)) != 0)
    gai_error(rc, "getaddrinfo");

  /* Walk the list and display each IP address */
  flags = NI_NUMERICHOST | NI_NUMERICSERV; /* Display address string instead of domain name, display port number instead of service name*/
  for (p = listp; p; p = p->ai_next) {
    Getnameinfo(p->ai_addr, p->ai_addrlen, buf, MAXLINE, serv_port, 5, flags);
    
    if(p->ai_family == AF_INET6) {
      printf("[%s]%s%s\n", buf, service ? ":" : "\00", service ? serv_port : "\00");
    } else {
      printf("%s%s%s\n", buf, service ? ":" : "\00", service ? serv_port : "\00");
    }
  }

  /* Clean up */
  freeaddrinfo(listp);

  return EXIT_SUCCESS;
}

## Zadanie 7
:::success
Autor: Jan Jankowicz
:::

Serwer:

#include "csapp.h"
#include "rio.h"

#define LISTENQ 1

static sigjmp_buf env;
static size_t nread = 0;

static void sigint_handler(int sig) {
  /* TODO: Change control flow so that it does not return to main loop. */
  siglongjmp(env, 1);
}

static void echo(int connfd) {
  size_t n;
  char buf[MAXLINE];
  rio_t rio;

  rio_readinitb(&rio, connfd);
  while ((n = Rio_readlineb(&rio, buf, MAXLINE))) {
    Rio_writen(connfd, buf, n);
    nread += n;
    /* XXX: Uncomment line below and watch client behaviour. */
    /* exit(0); */
  }
}

int main(int argc, char **argv) {
  if (argc != 2)
    app_error("usage: %s <port>\n", argv[0]);

  Signal(SIGINT, sigint_handler);

  int listenfd = Open_listenfd(argv[1], LISTENQ);

  /* TODO: Print bytes received after SIGINT has been received. */
  if (sigsetjmp(env, 1)) {
  	printf("Server received %zu bytes\n", nread);
  	exit(0);
  }

  while (1) {
    socklen_t clientlen = sizeof(struct sockaddr_storage);
    struct sockaddr_storage clientaddr; /* Enough space for any address */
    char client_hostname[MAXLINE], client_port[MAXLINE];
    int connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
    Getnameinfo((SA *)&clientaddr, clientlen, client_hostname, MAXLINE,
                client_port, MAXLINE, 0);
    printf("Connected to %s:%s\n", client_hostname, client_port);
    echo(connfd);
    Close(connfd);
  }
}

Klient:

#include "csapp.h"
#include "rio.h"

int main(int argc, char **argv) {
  if (argc != 3)
    app_error("usage: %s <host> <port>\n", argv[0]);

  char *host = argv[1];
  char *port = argv[2];

  char buf[MAXLINE];
  rio_t rio;
  int clientfd;

  clientfd = Open_clientfd(host, port);
  rio_readinitb(&rio, clientfd);

  while (Fgets(buf, MAXLINE, stdin) != NULL) {
    Rio_writen(clientfd, buf, strlen(buf));
    /* XXX: Uncomment line below and watch server behaviour. */
    /* exit(0); */
    Rio_readlineb(&rio, buf, MAXLINE);
    Fputs(buf, stdout);
  }
  Close(clientfd);

  return EXIT_SUCCESS;
}

## Zadanie 8
:::success
Autor: Paweł Tkocz
:::

#include "csapp.h"
#include "rio.h"

#define LISTENQ 10
#define MAXCLIENTS (PAGE_SIZE / sizeof(client_t))

typedef struct client {
  pid_t pid;    /* Client process id */
  size_t nread; /* Numer of bytes received so far */
} client_t;

/* TODO: Need to define context to be used with sigsetjmp & siglongjmp. */
static sigjmp_buf env;

static client_t *client = NULL;
static sig_atomic_t nclients = 0;
static size_t nread = 0; /* number of bytest received on all connections */

static client_t *findclient(pid_t pid) {
  for (int i = 0; i < MAXCLIENTS; i++)
    if (client[i].pid == pid)
      return &client[i];
  return NULL;
}

static client_t *addclient(void) {
  client_t *c = findclient(0);
  if (c) {
    c->pid = -1; /* XXX: must be filled in after fork */
    c->nread = 0;
    nclients++;
  }
  return c;
}

static void delclient(pid_t pid) {
  client_t *c = findclient(pid);
  assert(c != NULL);
  nread += c->nread;
  c->pid = 0;
  nclients--;
}

static void sigchld_handler(int sig) {
  pid_t pid;
  /* TODO: Delete clients as they die. */
  for(int i=0; i<MAXCLIENTS; i++){
	pid = client[i].pid;
	if(pid != 0 && Waitpid(pid, NULL, WNOHANG)){
		safe_printf("[%d] Disconnected\n", pid);
		delclient(pid);
	}
  }
}

static void sigint_handler(int sig) {
  safe_printf("Server received quit request!\n");
  /* TODO: Change control flow so that it does not return to main loop. */
  siglongjmp(env, 1);
}

static void echo(client_t *c, int connfd) {
  size_t n;
  char buf[MAXLINE];
  rio_t rio;

  rio_readinitb(&rio, connfd);
  while ((n = Rio_readlineb(&rio, buf, MAXLINE))) {
    Rio_writen(connfd, buf, n);
    c->nread += n;
    /* XXX: Uncomment line below and watch client behaviour. */
    /* exit(0); */
  }
}

int main(int argc, char **argv) {
  if (argc != 2)
    app_error("usage: %s <port>\n", argv[0]);

  sigset_t sig_mask;
  sigemptyset(&sig_mask);
  sigaddset(&sig_mask, SIGCHLD);

  Signal(SIGCHLD, sigchld_handler);
  Signal(SIGINT, sigint_handler);

  client =
    Mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);

  int listenfd = Open_listenfd(argv[1], LISTENQ);

  /* TODO: Wait for all clients to quit and print a message with nread. */
  if(sigsetjmp(env, 1)){
    sigset_t mask;
    sigfillset(&mask);
    sigdelset(&mask, SIGCHLD);
    Sigprocmask(SIG_SETMASK, &mask, NULL);
    while(nclients > 0)
	    Sigsuspend(&mask);
    printf("\nServer received %ld bytes\n", nread);
    exit(0);
  }


  while (1) {
    socklen_t clientlen = sizeof(struct sockaddr_storage);
    struct sockaddr_storage clientaddr; /* Enough space for any address */
    int connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);

    static char client_hostname[MAXLINE], client_port[MAXLINE];
    Getnameinfo((SA *)&clientaddr, clientlen, client_hostname, MAXLINE,
                client_port, MAXLINE, 0);

    sigset_t mask;
    Sigprocmask(SIG_BLOCK, &sig_mask, &mask);

    /* TODO: Start client in subprocess, close unused file descriptors. */
    client_t *client = addclient();
    pid_t  pid = Fork();
    if(pid==0){
	Close(listenfd);
	Signal(SIGINT, SIG_IGN);
	echo(client, connfd);
	Close(connfd);
	exit(0);
    }
    client->pid = pid;
    Close(connfd);
    printf("[%d] Connected to %s:%s\n", pid, client_hostname, client_port);
    Sigprocmask(SIG_SETMASK, &mask, NULL);
  }
}

## Zadanie 9
:::danger
Autor: dodeklarować lub PWit
:::