# SO Lista 4 Pseudoterminale, pliki i katalogi

## Zadanie 1 Olek
:::spoiler Łiskacz

void tty_curpos(int fd, int *x, int *y)
{
  // termios, old termios
  struct termios ts, ots;

  // ts = tcgetattr()
  tcgetattr(fd, &ts);
  // ots = ts
  memcpy(&ots, &ts, sizeof(struct termios));
  // Wyłączamy ECHO, ICANON i CREAD.
  // ECHO - pokazuj użytkownikowi wprowadzane znaki.
  // ICANON - obsługa znaków specjalnych.
  // CREAD - odbieraj nowe dane (zdaniem dokumentacji FreeBSD bezużyteczne).
  ts.c_lflag &= ~(ECHO | ICANON | CREAD);
  // TCSADRAIN - zmiany nie dotyczą danych w buforze.
  // TCSAFLUSH - zmiany nie dotyczą bufora, niezatwierdzone wejście
  //             jest usuwane.
  tcsetattr(fd, TCSADRAIN, &ts);

  /* How many characters in the input queue. */
  int m = 0;
  // FIONREAD == TIOCINQ - Get the number of bytes in the input buffer.
  ioctl(fd, TIOCINQ, &m);

  /* Read them all. */
  // Wczytujemy zawartość bufora wejścia w jądrze (czyszcząc go).
  char discarded[m];
  m = Read(fd, discarded, m);

  // CPR Cursor Position Report (również Device Status Report).
  // Sterownik terminala wypisze aplikacji `ESC[n;mR`, gdzie
  // n - rząd, m - kolumna. Zapisujemy to w buf.
  Write(fd, CPR(), sizeof(CPR()));
  char buf[20];
  int n = Read(fd, buf, 19);
  buf[n] = '\0';

  // Włączamy ICANON i wypełniamy z powrotem bufor wejścia.
  ts.c_lflag |= ICANON;
  tcsetattr(fd, TCSADRAIN, &ts);
  for (int i = 0; i < m; i++)
    // TIOCSTI - Insert the given byte in the input queue. (Faking input)
    ioctl(fd, TIOCSTI, discarded + i);

  // Przywracamy stary stan termios (ECHO, CREAD).
  tcsetattr(fd, TCSADRAIN, &ots);
  // Czytamy CPR.
  sscanf(buf, "\033[%d;%dR", x, y);
}

:::

> funkcja `tty_curpos` z terminal.c

void tty_curpos(int fd, int *x, int *y) {
  struct termios ts, ots;

  tcgetattr(fd, &ts); // ustawia obecny stan atrybutów terminala w strukturze ts
  memcpy(&ots, &ts, sizeof(struct termios));
  ts.c_lflag &= ~(ECHO | ICANON);
  ts.c_cflag &= ~CREAD;
  tcsetattr(fd, TCSADRAIN, &ts); 
  // ustawia zmienioną strukturę ts jako atrybuty terminala
  // TCSADRAIN -
  // the change occurs after all output written to fd
  // has been transmitted. This function should be 
  // used when changing parameters that affect output.

  /* How many characters in the input queue. */
  int m = 0;
  
#ifdef LINUX
  ioctl(fd, TIOCINQ, &m);
#endif

  /* Read them all. */
  char discarded[m];
  m = Read(fd, discarded, m);

  Write(fd, CPR(), sizeof(CPR()));
  char buf[20];
  int n = Read(fd, buf, 19);
  buf[n] = '\0';

  ts.c_lflag |= ICANON;
  tcsetattr(fd, TCSADRAIN, &ts);
  for (int i = 0; i < m; i++)
    ioctl(fd, TIOCSTI, discarded + i);

  tcsetattr(fd, TCSADRAIN, &ots);
  sscanf(buf, "\033[%d;%dR", x, y);
}

---

CPR - cursor position report

Local modes:
    ECHO        /* enable echoing */
    ICANON      /* canonicalize input lines */
Control modes:
    CREAD       /* enable receiver */

> `termios` struct

struct termios {
 tcflag_t c_iflag; /* Input flags */
 tcflag_t c_oflag; /* Output flags */
 tcflag_t c_cflag; /* Control flags */
 tcflag_t c_lflag; /* Local modes */
 cc_t c_line; /* Line discipline (nonstandard)*/
 cc_t c_cc[NCCS]; /* Terminal special characters */
 speed_t c_ispeed; /* Input speed (nonstandard; unused) */
 speed_t c_ospeed; /* Output speed (nonstandard; unused) */
};

## Zadanie 2 kasia

:::info
A pseudoterminal is a pair of virtual character devices that provide a bidirectional communication channel. One end of the channel is called the master; the other end is called the slave. The slave end of the pseudoterminal provides an interface that behaves exactly like a classical terminal. A process that expects to be connected to a terminal, can open the slave end of a pseudoterminal and then be driven by a program that has opened the master end. Anything that is written on the master end is provided to the process on the slave end as though it was input typed on a terminal.
:::


Następnie wykonujemy ``strace -f -e read,write -o script.log script -T timing -c dash`` i znowu wpisujemy jakies polecenia, zaglądamy do pliku ``script.log``.

> IGNCR - ignore CR
> ICRNL - map CR to NL (ala CRMOD)
> CR - \r - \(Carriage Return\) moves the cursor to the beginning of the line without advancing to the next line.

jak ustawimy jedną z tych flag to nie mozemy wyslac zadnego polecenia w dashu - przycisk ENTER pojawia się jako \M zamiast działać

## Zadanie 3 Kuba

Ostatni proces w potoku jest dzieckiem powłoki i wszystkie inne procesy są dziećmi ostatniego procesu, dzieje się tak z tego powodu, że ostatni proces jest dzieckiem powłoki, a powłoka ma dostęp do informacji, że działanie całego potoku zakończyło się.

Kolejność wywołań :

1. Powłoka sh (949) wywołuje fork, powstaje dziecko sh (1988).
2. Wywoływany jest dwa razy pipe w sh (1988).
3. sh (1988) wywołuje dwukrotnie fork, powstają kolejne dzieci sh (1989) i sh (1990). W każdym dziecku przy użyciu dup2 zmieniane jest wejście pipe’a na stdout, a wyjście jest zamykane przez close. W rodzicu (sh (1988)) wyjście pipe’a ustawiane jest na stdin przy użyciu dup2, a wejście jest zamykane przez close.
4. Na tak przygotowanych procesach (1989 i 1990) uruchamiane są kolejno przez execve programy ps -ef oraz grep sh.
5. W sh (1988) wywoływane jest polecenie creat do stworzenia pliku wyjściowego cnt, cnt jest ustawiane na stdout a następnie wykonywane jest polecenie execve z argumentem wc -l (1988).
6. Na końcu, po wykonaniu powyższych poleceń zostanie wykonany waitpid.

Obsługa niepowodzenia w execve należy do programisty, jedną z możliwości jest zakończenie działania programu. Ominięcie jednego niepowodzenia przyniosłoby nieoczekiwane rezultaty, zakładając że nie zadziała np. ps -ef, na wejściu grep sh nie będzie nic, przez co cały pipeline się zawiesi. Warto wiedzieć o tym, że przez setpgrp(2) ustawiana jest cała grupa procesów, dzięki czemu przy niepowodzeniu można łatwo wysłać sygnał do wszystkich procesów i je zakończyć.

## Zadanie 4

## Zadanie 5 Marcin

Aby odczytać katalog, należy użyć funkcji ``opendir(3)`` oraz ``readdir(3)`` (korzysta z syscalla reddirenties? do sprawdzenia). ``read(2)`` i ``write(2)`` służą do operacji na plikach.
:::::spoiler ``man opendir``
:::::
:::::spoiler ``man readdir``
* moja (xD nie to czego szukasz) 
* [z neta](https://www.man7.org/linux/man-pages/man3/readdir.3.html) 

:::::
[**Rekord katalogu**](https://unix.stackexchange.com/questions/186992/what-is-directory-entry) (ang. directory entry) to w istocie mapowanie nazw plików do ich inody(która jest wskaźnikiem na informacje o pliku). Rekord katalogu istnieje bo użytkownik bawi sie zwykle nazwami plików a kernel nie rozumie nazw plików. Dlatego rekord zawiera nazwę pliku i strukturę informacji opisujących atrybuty pliku takie jak typ pliku (plik zwykły, katalog), rozmiar pliku, właściciel pliku, uprawnienia dla pliku, czy datę ostatniej modyfikacji. Używając `stat` można wczytać strukturę informacji zawierającą wszystkie atrybuty (inaczej **metadane**) pliku/katalogu.
Wywołanie na moim komputerze `stat UnityProjects`

  Plik: Unity_Projects/
  rozmiar: 110       	bloków: 0          bloki I/O: 4096   katalog
Urządzenie: 0,38	inody: 109714      dowiązań: 1
Dostęp: (0755/drwxr-xr-x)  Uid: ( 1000/strzelacz48)   Gid: ( 1000/strzelacz48)
Kontekst: unconfined_u:object_r:user_home_t:s0
Dostęp:      2022-11-03 16:25:40.148523719 +0100
Modyfikacja: 2022-11-03 16:25:03.882484085 +0100
Zmiana:      2022-11-03 16:25:03.882484085 +0100
Utworzenie:  2022-11-03 16:24:46.201465414 +0100

`ls -U` można użyć aby terminal wypisał nieposortowany w żaden sposób zawartość katalogu i sprawdzić na żywo (porównać) czy jest posortowany.
`stat /`

  Plik: /
  rozmiar: 158       	bloków: 0          bloki I/O: 4096   katalog
Urządzenie: 0,34	inody: 256         dowiązań: 1
Dostęp: (0555/dr-xr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Kontekst: system_u:object_r:root_t:s0
Dostęp:      2022-11-03 10:10:44.845385300 +0100
Modyfikacja: 2022-11-03 00:03:51.371693597 +0100
Zmiana:      2022-11-03 00:03:51.371693597 +0100
Utworzenie:  2022-10-27 19:28:00.958955651 +0200

Wynika z tego, że katalog / zawiera 1(możliwe błędy z linuxsem)? **twardych dowiązań** (ang. hard links), które tworzą nową nazwę dla danego zasobu i zapisują ją w nowej lokalizacji (nie kasując poprzedniej), a same dowiązania nie odwołują się do samego katalogu, lecz do jego zawartości. Inną definicją dowiązania twardego jest liczba wskaźników na inode’y plików, które wliczają się do licznika referencji do pliku.

W moim przypadku dowiązanie jest tylko jedno. W każdym katalogu musi być co najmniej 1.
Po wywołaniu `ls -al` zostaną wylistowane wszystkie katalogi i linki:

Nas głównie interesować będą katalogi zaznaczone ciemnym niebieskim, tzn. `.`, `..`, `boot`, `.cache`, `dev`, `etc`, `home`, `lost+found`, `media`, `mnt`, `opt`, `proc`, `root`, `run`, `snap`, `srv`, `sys`, `usr`, `var` oraz `tmp`. Na wydruku ls jest 20, a w stat jest 1?(Po zliczeniu ich wyjaśnia się liczba dowiązań, których jest 20). W każdym z tych katalogów jest stworzony *hard link* do katalogu `..`, którym w tym przypadku jest `/`.
## Zadanie 6 Kornelia

- access(path, F_OK) - funkcaja `access` sprawdza uprawnienia dostępu do pliku o ścieżce `path`, `F_OK` oznacza, że sprawdzamy czy plik istnieje; funkcja zwróci 0 jeśli plik ma żądane uprawnienia (w przypadku F_OK jeśli istnieje)
- O_CREAT - pozwala funkcji `open` na utworzenie pliku o podanej ścieżce, jeśli taki jeszcze nie istnieje
- O_WRONLY - otwieranie pliku w trybie `write-only`
- 0700 - użytkownik (właściciel pliku) ma uprawnienia rwx

TOCTTOU (Time Of Check To Time Of Use) - błąd spowodowany wyścigiem, który może wystąpić jeśli pomiędzy sprawdzeniem stanu i wykorzystaniem wyniku tego sprawdzenienia istnieje odstęp czasu (w którym sprawdzony stan może ulec zmianie)

W zadaniu wyścig jest pomiędzy wywołaniem `access` i `open`. Jeśli `access` zwróci -1 (plik nie istnieje), to chcemy go utworzyć wywołaniem `open`. Pomiędzy tymi wywołaniami inny proces może otworzyć plik, wtedy oba procesy zwrócą `true` i dostaną blokadę.

Rozwiązanie - użyć jednej funkcji zamiast dwóch :

bool f_lock(const char *path) {
 return Open(path, O_CREAT|O_EXCL|O_WRONLY, 0700) >= 0;
 }

`O_CREAT` + `O_EXCL` -> funkcja `open` utworzy plik o podanej ścieżce (jeśli taki nie istnieje) lub zakończy się z błędem `EEXIST` (jeśli plik, który próbujemy utworzyć już istnieje)

Błąd TOCTTOU sprawia, że program jest podatny na atak. W momencie, gdy program znajduje się pomiędzy sprawdzeniem poprawności operacji a wykonaniem związanego z tym działania, atakujący może np. podmienić plik przez dowiązanie, w wyniku czego może uzyskać dostęp do wrażliwych danych. Ogólniej : TOCTTOU może prowadzić do eskalacji uprawnień (można będzie wykonać operacje, do których nie zostały przyznane uprawnienia).

:::spoiler Przykład z wikipedii
Uprawnienia dostępu zostały sprawdzone dla pliku *file*, po czym zostało utworzone dowiązanie *file -> /etc/passwd*. Funkcja *write* będzie teraz pisała do pliku */etc/passwd*, który może nie posiadać uprawnień do zapisu.
:::

---

## Zadanie 7

## Zadanie 8