Pentru a deschide un terminal nou:

Puteți folosi următoarele scurtături în terminal:

Pentru a naviga (scrolling) în cadrul unui terminal, mai ales atunci când o comandă afișează mult text, folosiți următoarele scurtături:

Alte scurtături utile:

Cea mai importantă formă de documentație în Linux, atunci când nu avem acces la Internet, o reprezintă paginile de manual, accesibile cu ajutorul comenzii man.

De exemplu, pentru a afișa informații despre comanda echo (comandă ce afișează un mesaj la ieșirea standard), vom folosi comanda:

student@uso:~$ man echo

Paginile de manual sunt adesea de mari dimensiuni și avem nevoie să le parcurgem rapid (să navigăm prin ele). Pentru aceasta, după ce deschidem pagina de manual a unei comenzi, putem folosi combinațiile de taste de mai jos pentru a naviga în pagină:

• Familiarizarea cu linia de comandă în Linux
• Familiarizarea cu comenzi simple în Bash (terminalul din Linux)
• Utilizarea comenzilor pentru operațiuni similare realizate până acum din interfața grafică
• Înțelegerea diferenței dintre căi relative și căi absolute
• Acomodarea lucrului cu arhive în linia de comandă

Pe parcursul laboratoarelor, pentru descărcarea fișierelor necesare laboratorului, vom folosi Git. Git este un sistem de controlul versiunii și e folosit pentru versionarea codului în proiectele software mari. Celor interesați să aprofundeze conceptele din spatele comenzii git, precum și utilizări avansate, le recomandăm cursul practic online de pe gitimmersion.

Informațiile despre laboratorul de USO se găsesc în acest repository Git.

În laboratorul curent, pe sistemul fizic, aveți deja clonat repository-ul Git în directorul ~/uso.git/. Vom preciza acest lucru pe parcursul laboratorului.

student@uso:~$ cd uso.git/
student@uso:~/uso.git$ git rm --cached -r .
student@uso:~/uso.git$ git reset --hard
student@uso:~/uso.git$ git clean -f -d
student@uso:~/uso.git$ git fetch origin
student@uso:~/uso.git$ git checkout -b lab-01-fs
student@uso:~/uso.git$ git rebase origin/lab-01-fs

Cam atât cu pregătirea laboratorului. Acum haideți să ne apucăm de treabă!

Orice calculator are nevoie să stocheze date de diferite tipuri undeva, de exemplu pe un hard drive (HDD), un stick de memorie USB, etc. Aceste date sunt organizate sub formă de fișiere, directoare și legături (link-uri).

Un director este de fapt tot un fișier ce conține adresele altor fișiere. În Linux, totul este reprezentat ca un fișier sau un director: hard-drive-ul, display-ul, keyboard-ul, etc.

Link-urile sunt legături între două puncte ale sistemului de fișiere. În general le folosim când vrem să ne ușurăm accesul la un fișier sau director, sau pentru a uniformiza accesul.

Sistemul de fișiere este folosit pentru a organiza ierarhic toate datele stocate pe un sistem.

În Linux, acesta are următoarea structură arborescentă, ce poate fi vizualizată folosind comanda tree:

Un director poate conține mai multe fișiere și directoare, iar directoarele la rândul lor pot conține alte fișiere și directoare.

În Linux, întreaga structură de directoare pornește din directorul root reprezentat de un singur slash /. Directorul root conține numeroase alte directoare ce stochează diferite tipuri de informații:

• /bin conține fișiere executabile, utilitare fundamentale cum ar fi cp, ls
• /boot conține toate fișierele necesare pentru bootarea cu succes a sistemului
• /etc conține fișiere de configurare
• /root este directorul home al utilizatorului privilegiat root
• /home conține directoarele home pentru toți utilizatorii din sistem

În directorul home al unui utilizator se găsesc fișiere personale, ce nu pot fi accesate de alți utilizatori.

După cum am spus la începutul laboratorului, datele sunt stocate pe un disk (hard-disk, SSD, CD-ROM). În Linux, există numeroase formate de stocare a datelor, numite și tipuri de sisteme de fișiere: ext4, ext3, ext2, ZFS, XFS. Acestea specifică modul în care datele sunt stocate și ulterior accesate de pe disk. Forma cea mai comună de stocare a datelor este ext4.

Ca o comparație între Windows și Linux, după cum știm Windows are disk-uri A, B, C, D, etc., în Linux trebuie ca disk-ul să fie legat la sistemul de fișiere într-un director ales. Această operație se numește montare și se realizează folosind comanda mount. Folosită fără niciun argument, ne va spune ce sisteme de fișiere sunt montate și în ce directoare sunt montate.

Pentru accesarea unui fișier sau director sunt posibile două moduri, în funcție de directorul curent:

• căi absolute: pornesc din directorul root
• căi relative: pornesc din directorul curent

Directorul curent este directorul în care utilizatorul se află la momentul actual. Directorul curent se afișează la apelul comanzii pwd (print working directory). Pentru schimbarea directorului curent se folosește comanda cd (change directory), urmată de numele directorului în care dorim să ajungem.

Să luăm ca exemplu următoarea structură de fișiere și directoare din laboratorul introductiv:

$ cd ~/uso.git/labs
$ tree
.
├── 00-intro
│   ├── support
│   └── wiki
│       ├── basics.wiki
│       ├── concepts.wiki
│       ├── demo.wiki
│       ├── get-a-life.wiki
│       ├── need-to-know.wiki
│       ├── nice-to-know.wiki
│       └── recap.wiki
├── 01-fs
│   ├── support
...

Dacă dorim să afișăm fișierul concepts.wiki folosind o cale absolută vom folosi comanda ls, astfel:

$ ls /home/student/uso.git/labs/00-intro/wiki/concepts.wiki 

Dacă ne aflăm curent în directorul labs, putem să folosim o cale relativă:

$ ls ./00-intro/wiki/concepts.wiki

Sau și mai simplu:

$ ls 00-intro/wiki/concepts.wiki

Dacă ne aflăm în directorul lab-01, putem să folosim de asemena o cale relativă, astfel:

$ ls ../00-intro/wiki/concepts.wiki

În Linux există două tipuri de utlizatori:

• neprivilegiați - nu pot modifica starea sistemului, nu pot realiza modificări ce afectează alți utilizatori
• privilegiați - au acces total asupra sistemului, de exemplu utilizatorul root

Utilizatorul root este prezent, în general, pe orice sistem Linux, rolul său fiind de administrare și gestionare a celorlalți utilizatori.

Pentru început, vrem să ne acomodăm cu cele mai importante comenzi din linia de comandă, în special cele care lucrează cu fișiere și directoare. Îndrumați de asistent, vom descoperi împreună cum putem folosi linia de comandă pentru a lucra cu sistemul de fișiere și pentru a face acțiuni mai rapid ca în interfața grafică.

Să începem!

Ne propunem să schimbăm utilizatorul curent cu utilizatorul root. Una din metodele existente constă în folosirea comenzii su (abreviere de la en. switch user).

student@uso:~$ sudo su
[sudo] password for student:
root@uso:/home/student#

Deschideți un terminal.

Ne propunem să lucrăm cu acele comenzi care ne ajută să parcurgem directoarele din sistemul de fișiere (adică să-l traversăm). Apoi să folosim comenzile pentru listarea conținutului unui director și pentru afișarea conținutului unui fișier.

Foarte importantă este distincția între o cale absolută (o cale către un director care pornește din directorul rădăcină, exemplu: /home/student) și o cale relativă la directorul curent (folosind intrările speciale . - directorul curent și .. - directorul părinte).

Urmăriți cu atenție secvența de comenzi de mai jos. Dacă vreți să dați și voi comenzile pe stația la care lucrați, folosiți cât mai des tasta TAB atunci când dați un parametru comenzii ls sau cd.

student@uso:~$ pwd
/home/student
student@uso:~$ ls
Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos  examples.desktop  uso.git  vm-actions-log.txt
student@uso:~$ cd uso.git/labs/01-fs/support/demo/
student@uso:~/.../01-fs/support/demo$ pwd
/home/student/uso.git/labs/01-fs/support/demo
student@uso:~/.../01-fs/support/demo$ tree
.
├── empty_directory
├── movies
│   ├── movie0.mkv
│   ├── movie0.srt
│   ├── movie1.mkv
│   ├── movie1.srt
│   ├── movie2.mkv
│   ├── movie2.srt
│   ├── movie3.mkv
│   ├── movie3.srt
│   ├── movie4.mkv
│   └── movie4.srt
└── music
    ├── ac_dc
    │   ├── angus
    │   ├── bon
    │   ├── brian
    │   ├── chris
    │   ├── cliff
    │   ├── dave
    │   ├── george
    │   ├── malcom
    │   ├── mark
    │   └── phil
    ├── cargo
    └── hammerfall
        ├── anders
        ├── jesper
        ├── joacim
        ├── magnus
        ├── oscar
        ├── pontus
        └── stefan
 
6 directories, 27 files

Acum că am văzut structura directoarelor, haideți să navigăm prin ele:

student@uso:~/.../01-fs/support/demo$ cd music   # aici am folosit o cale relativă la directorul curent
student@uso:~/.../support/demo/music$ ls
ac_dc  cargo  hammerfall
student@uso:~/.../support/demo/music$ cd ac_dc   # aici am folosit o cale relativă la directorul curent
student@uso:~/.../demo/music/ac_dc$ ls
angus  bon  brian  chris  cliff  dave  george  malcom  mark  phil
student@uso:~/.../demo/music/ac_dc$ cd .. # Am navigat în directorul părinte directorului ac_dc, care este /home/student/uso.git/labs/01-fs/support/demo/music
student@uso:~/.../support/demo/music$ ls -R
.:
ac_dc  cargo  hammerfall
 
./ac_dc:
angus  bon  brian  chris  cliff  dave  george  malcom  mark  phil
 
./cargo:
 
./hammerfall:
anders  jesper  joacim  magnus  oscar  pontus  stefan
 
student@uso:~/.../support/demo/music$ cd /home/student/uso.git/labs/01-fs/support/demo/music/hammerfall  # am fi putut folosi și cd hammerfall, dar am folosit cale absolută
student@uso:~/.../demo/music/hammerfall$ ls
anders  jesper  joacim  magnus  oscar  pontus  stefan

Lui ls îi putem da argument atât o cale relativă către un director sau un fișier, cât și o cale absolută:

student@uso:~/.../demo/music/hammerfall$ ls ../ac_dc/
angus  bon  brian  chris  cliff  dave  george  malcom  mark  phil
 
student@uso:~/.../demo/music/hammerfall$ ls -l ../ac_dc/brian
-rw-r--r-- 1 student student 0 aug 22 18:32 ../ac_dc/brian
 
student@uso:~/.../demo/music/hammerfall$ ls -l anders
-rw-r--r-- 1 student student 0 aug 22 18:43 anders
 
student@uso:~/.../demo/music/hammerfall$ ls -l /home/student/uso.git/labs/01-fs/support/demo/music/hammerfall/oscar
-rw-r--r-- 1 student student 0 aug 22 18:32 /home/student/uso.git/labs/01-fs/support/demo/music/hammerfall/oscar

Cum am văzut și mai sus, exemple de folosire a căilor relative sunt:

student@uso:~/.../support/demo/music$ ls hammerfall/        # ls h<TAB>
student@uso:~/.../support/demo/music$ ls -l .
student@uso:~/.../support/demo/music$ cd ac_dc/             # cd ./a<TAB>
student@uso:~/.../demo/music/ac_dc$ ls ../hammerfall/       # ls ../h<TAB>

Câteva exemple de utilizare a căilor absolute:

student@uso:~/.../demo$ ls /
student@uso:~/.../demo$ tree /home/student/uso.git/labs/01-fs/support/demo/music/hammerfall
student@uso:~/.../demo$ tree -L 1 ~

Acum să vedem câteva erori care pot să apară. Ce credeți că se întâmplă mai jos? Care este cauza erorii apărute, ce greșeală a fost făcută?

student@uso:~/.../demo/music/hammerfall$ ls brian
ls: cannot access 'brian': No such file or directory
 
student@uso:~/.../demo/music/hammerfall$ cd /home/student/uso.git/labs/01-fs/support/demo/music/scorpions
bash: cd: /home/student/uso.git/labs/01-fs/support/demo/music/scorpions: No such file or directory

Urmăriți exemplele de mai jos.

Ne propunem să navigăm rapid în directorul home al utilizatorului cu care suntem logați, indiferend de calea în care ne aflăm în momentul curent.

Rețineți că simbolul ~ (numit tilda) este o prescurtare pentru directorul home al utilizatorului. Putem folosi acest simbol împreună cu comanda cd pentru a duce acest exercițiu la bun sfârșit.

student@uso:~/.../support/demo/movies$ cd ~
student@uso:~$ pwd
/home/student

Un alt simbol bine de reținut - este o prescurtare pentru directorul anterior accesat.

student@uso:~$ cd -
/home/student/uso.git/labs/01-fs/support/demo/movies
student@uso:~/.../support/demo/movies$ pwd
/home/student/uso.git/labs/01-fs/support/demo/movies

Ca să putem lista recursiv conținutul unui director, putem folosi unul dintre utilitarele tree sau ls (cu opțiunea -R).

Vom folosi utilitarul tree.

student@uso:~/.../01-fs/support/demo$ tree
.
├── empty_directory
├── movies
│   ├── movie0.mkv
│   ├── movie0.srt
│   ├── movie1.mkv
│   ├── movie1.srt
│   ├── movie2.mkv
│   ├── movie2.srt
│   ├── movie3.mkv
│   ├── movie3.srt
│   ├── movie4.mkv
│   └── movie4.srt
└── music
    ├── ac_dc
    │   ├── angus
    │   ├── bon
    │   ├── brian
    │   ├── chris
    │   ├── cliff
    │   ├── dave
    │   ├── george
    │   ├── malcom
    │   ├── mark
    │   └── phil
    ├── cargo
    └── hammerfall
        ├── anders
        ├── jesper
        ├── joacim
        ├── magnus
        ├── oscar
        ├── pontus
        └── stefan
 
6 directories, 27 files

Putem limita adâncimea maximă pentru parcurgerea ierarhiei de fișiere folosind opțiunea -L <număr>:

student@uso:~/.../01-fs/support/demo$ tree -L 1
.
├── empty_directory
└── movies
 
2 directories, 0 files

O altă opțiune pentru utilitarul tree este -a. Folosind acest flag sunt afișate și fișierele ascunse (fișierele care au în componența numelui pe pe prima poziție caracterul .).

student@uso:~/.../01-fs/support/demo$ tree -a empty_directory/
empty_directory/
└── .not_really
 
0 directories, 1 file

Crearea unei ierarhii de directoare poate părea anevoioasă. Până acum cunoaștem comenzile mkdir și cd.

Opțiunea -p a comenzii mkdir reduce semnificativ efortul pentru a crea o ierarhie de directoare:

student@uso:~/.../support/demo/movies$ mkdir -p a/long/chain/of/directories
student@uso:~/.../support/demo/movies$ tree
.
├── a
│   └── long
│       └── chain
│           └── of
│               └── directories
├── movie0.mkv
├── movie0.srt
├── movie1.mkv
├── movie1.srt
├── movie2.mkv
├── movie2.srt
├── movie3.mkv
├── movie3.srt
├── movie4.mkv
└── movie4.srt
 
5 directories, 10 files

student@uso:~/.../support/demo/movies$ vim movie0.srt

Pentru a insera caractere în fisierul pe care l-am deschis trebuie să intrăm în modul de inserare. Pentru a intra în modul de inserare se folosește tasta i.

După ce am terminat de inserat caractere, ieșim dim modul de editare prin apăsarea tastei esc.

Pentru a ieși din fișier și pentru a salva introducem comanda :wq (: începe comanda nouă, w - write, q - quit).

Inspectăm conținutul curent al fișierului editat folosind comanda cat.

student@uso:~/.../support/demo/movies$ cat movie0.srt
Prima linie din subtitrare

Dorim să efectuăm o serie de operații (ex. copiere, mutare și ștergere) asupra unei ierarhii întregi de fișiere. O să folosim ierarhia de directoare pe care am creat-o în secțiunea 6.

Pentru început o sa copiem toată ierarhia din directorul movies în directorul părinte al acestuia.

student@uso:~/.../support/demo/movies$ cp -r a ../
student@uso:~/.../support/demo/movies$ tree ../a  # am folosit o cale relativă
../a
└── long
    └── chain
        └── of
            └── directories
 
4 directories, 0 files
student@uso:~/.../support/demo/movies$ tree a
a
└── long
    └── chain
        └── of
            └── directories
 
4 directories, 0 files

În acest moment avem aceeași ierarhie în două locuri. Dorim să ștergem ierarhia din directorul movies.

student@uso:~/.../support/demo/movies$ rm -r a/
student@uso:~/.../support/demo/movies$ ls
movie0.mkv  movie1.mkv  movie2.mkv  movie3.mkv  movie4.mkv
movie0.srt  movie1.srt  movie2.srt  movie3.srt  movie4.srt

Am folosit comanda rm cu opțiunea -r (en. recursive) pentru a șterge întreaga ierarhie. Pentru mai multe opțiune a comenzii rm consultați maginile de manual (man rm).

A rămas o singură operație de testat și anume mutarea. Vom folosi comanda mv. Vom muta directorul pe care l-am copiat mai devreme în directorul Desktop al utilizatorului curent.

student@uso:~/.../support/demo/movies$ cd ..
student@uso:~/.../01-fs/support/demo$ mv a ~/Desktop
student@uso:~/.../01-fs/support/demo$ tree ~/Desktop
/home/student/Desktop
└── a
    └── long
        └── chain
            └── of
                └── directories
 
5 directories, 0 files

Observăm că directorul pe care l-am mutat nu se mai află în directorul demo.

student@uso:~/.../01-fs/support/demo$ ls
empty_directory  movies  music

Ne propunem să mutăm toate subtitrările din directorul movies într-un director separat.

student@uso:~/demo$ ls -l
total 0
-rw-r--r-- 1 student student 0 aug 22 10:56 movie0.mkv
-rw-r--r-- 1 student student 0 aug 22 10:56 movie0.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie1.mkv
-rw-r--r-- 1 student student 0 aug 22 10:52 movie1.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie2.mkv
-rw-r--r-- 1 student student 0 aug 22 10:52 movie2.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie3.mkv
-rw-r--r-- 1 student student 0 aug 22 10:52 movie3.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie4.mkv
-rw-r--r-- 1 student student 0 aug 22 10:52 movie4.srt

Mai întâi trebuie să creăm un director destinație (sau să folosim unul existent).

student@uso:~/.../support/demo/movies$ mkdir subs
student@uso:~/.../support/demo/movies$ ls
movie0.mkv  movie1.mkv  movie2.mkv  movie3.mkv  movie4.mkv  subs
movie0.srt  movie1.srt  movie2.srt  movie3.srt  movie4.srt

Pentru a muta toate fișierele ce reprezintă o subtitrare (fișierele care au în nume extensia .srt) putem folosi un wildcard:

student@uso:~/demo$ mv *.srt subs/
student@uso:~/demo$ ls -l
total 4
-rw-r--r-- 1 student student    0 aug 22 10:56 movie0.mkv
-rw-r--r-- 1 student student    0 aug 22 10:52 movie1.mkv
-rw-r--r-- 1 student student    0 aug 22 10:52 movie2.mkv
-rw-r--r-- 1 student student    0 aug 22 10:52 movie3.mkv
-rw-r--r-- 1 student student    0 aug 22 10:52 movie4.mkv
drwxr-xr-x 2 student student 4096 aug 22 10:59 subs
student@uso:~/demo$ cd subs
student@uso:~/demo/subs$ ls -l
total 0
-rw-r--r-- 1 student student 0 aug 22 10:56 movie0.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie1.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie2.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie3.srt
-rw-r--r-- 1 student student 0 aug 22 10:52 movie4.srt

Așa cum am discutat în laboratorul trecut, în mediul Linux folosim adesea linia de comandă și scurtături de taste pentru a naviga în/între aplicații.

Pentru a deschide o aplicație grafică în Linux putem folosi butoanele și meniurile puse la dispoziție de mediul grafic sau putem folosi combinația de taste Alt+F2. Cu această combinație de taste se deschide un prompt în care tastăm numele aplicației pe care o vrem deschisă.

Apăsați combinația de taste Alt+F2 și apoi tastați la prompt șirul gedit și apoi apăsați tasta Enter. Vi se deschide editorul gedit cu care puteți crea și modifica fișiere. Puteți închide fereastra aplicației grafice folosind combinația de taste Alt+F4.

[1a] Porniți în mod similar browser-ul web Firefox tastând la prompt șirul firefox.

În anumite aplicații grafice precum browserele, putem deschide tab-uri (subferestre). Pentru aceasta, folosiți în Firefox combinația de taste Ctrl+t. Pentru a închide un tab de browser folosiți combinația de taste Ctrl+w. Atunci când aveți deschise mai multe tab-uri navigați între ele, respectiv, cu Alt+1, Alt+2, Alt+3 etc. Pentru a accesa din taste bara de adrese unde să tastați adresa unui site, folosiți combinația de taste Ctrl+l.

[1b] Deschideți 3 tab-uri în Firefox cu care accesați trei site-uri diferite la alegere. Apoi închideți primul și al treilea tab. Apoi închideți toată aplicația.

[1c] Deschideți o aplicație de tip terminal. Șirul de tastat la prompt este gnome-terminal. Apoi deschideți încă 2 tab-uri noi (pentru un total de 3) în terminal și navigați între ele. Apoi închideți-le pe rând.

[1d] Deschideți Firefox cu 3 tab-uri într-un workspace. Deschideți un terminal cu 3 tab-uri în alt workspace. Deschideți o aplicație gedit cu tab-uri în alt workspace. Apoi navigați între workspace-uri. Apoi aduceți aplicația terminal și aplicația gedit în același workspace cu Firefox.

Atunci când folosim terminalul, dorim adesea să căutăm comenzi pe care le-am folosit anterior. Pentru aceasta, în terminal, folosim combinația de taste Ctrl+r. În acel moment se schimbă prompt-ul și se cere introducerea unui șir de caractere. Acel șir este căutat în comenzile anterioare și sunt identificate. Funcționalitatea poartă numele de reverse history search.

[1e] Folosind Ctrl+r căutați în istoricul de comenzi ale shell-ului comenzi care conțineau șirul man (de la manual). După prima comandă găsită în istorie, dacă apăsați Ctrl+r din nou vă va găsi următoarea comandă, și tot așa.

Adesea, în mediul din linia de comandă, dorim să vedem conținut de fișiere. Pentru aceasta folosim comanda cat urmată de numele fișierului.

Tastați la promptul unui terminal comanda

cat /etc/passwd

și apăsați Enter. Ca urmare a tastării comenzii, ni se afișează pe ecran conținutul fișierului /etc/passwd.

[2a] Afișați conținutul fișierului /etc/hosts și navigați în sus sau în jos în afișarea terminalului.

O altă formă de vizualizare a unui fișier este cu ajutorul comenzii less. Urmată de numele unui fișier putem vedea și parcurge fișierul.

Tastați la promtpul unui terminal comanda

less /etc/hosts

și apăsați Enter. Ca urmare a tastării comenzii ni se afișează pe ecran conținutul fișierului /etc/hosts.

Puteți naviga în acest fișier folosind săgețile și alte taste de navigare. Pentru a ieși din ecranul de afișare folosiți tasta q.

Dacă dorim să scriem un fișier avem nevoie de un editor. Putem folosi Gedit sau putem folosi Vim. Haideți să folosim Vim, pentru a ne acomoda. Tastați comanda:

vim msg.txt

și apăsați Enter. Vă apare ecranul editorului Vim. Acum urmați pașii:

1. Apăsați tasta i ca să intrați în modul insert de introducere de conținut. Observați că apare în colțul din stânga jos mesajul INSERT.
2. Acum scrieți textul ana are mere.
3. Acum apăsați tasta Esc pentru a părăsi modul insert. Observați că dispare din colțul stânga jos mesajul INSERT.
4. Acum apăsați tastele :w<Enter>. Aceasta este comanda de salvare a fișierului.
5. Acum apăsați tastele :q<Enter>. Aceasta este comanda de ieșire.

Acum ați scris textul ana are mere în fișierul msg.txt.

[2b] Folosiți, pe rând, comanda cat și comanda less pentru a afișa conținutul fișierului msg.txt.

[2c] Folosiți Vim pentru a crea fișierul quote.txt cu mesajul Go ahead, make my day!. Apoi folosiți, pe rând, comanda cat și comanda less pentru a afișa conținutul fișierului quote.txt.

Contul privilegiat (root) este folosit în Linux pentru a realiza acțiuni privilegiate. De exemplu, nu putem vedea conținutul fișierului /etc/sudoers decât ca root. Astfel, dacă rulăm comanda

cat /etc/sudoers

vom primi mesajul

cat: /etc/sudoers: Permission denied

pentru că nu avem permisiuni.

Pentru a rula ca utilizatorul root, prefixăm comanda de mai sus cu altă comandă, anume sudo. Comanda sudo rulează comanda de după ea cu permisiuni de root. Astfel, comanda de mai jos va reuși și va afișa conținutul fișierului /etc/sudoers:

sudo cat /etc/sudoers

Dacă este cazul, la promptul de parolă cerut veți introduce parola utilizatorului student, care este tot student.

Dacă vrem să obținem un prompt în care orice comandă rulează ca root vom folosi comanda

sudo su

Ca urmare a rulării comenzii sudo su vom avea acum un prompt nou, numit prompt de root, identificabil prin faptul că acum promptul se închide în simbolul # (diez) în loc de $ (dollar). Pentru a reveni înapoi la utilizatorul student vom folosi comanda exit.

[3a] Deschideți un terminal cu 4 tab-uri. În două tab-uri obțineți prompt de root; în unul din aceste două tab-uri afișați fișierul /etc/sudoers iar în celălalt fișierul /etc/shadow.

Acum o să lucrăm la partea cea mai vizibilă dintr-un sistem de operare: sistemul de fișiere. Adică vom crea, șterge, modifica și afișa fișiere, directoare, link-uri. Să începem!

Pentru a începe acest tutorial trebuie să vă asigurați că sunteți în directorul potrivit. Rulați comanda cd ~/uso.git/labs/01-fs/support/basics/.

Listarea conținutului directorului curent se face folosind comanda ls.

student@uso:~/.../01-fs/support/basics$ ls
grotesque  'hacker-s secret'   rookiss  'toddler-s bottle'

Observăm că prin utilizarea comenzii ls putem vedea ce avem în directorul curent, dar nu și în subdirectoarele acestuia. Un mod pentru a putea vizualiza întreaga ierarhie începând cu directorul curent este utilizarea utilitarului tree. Dacă acesta nu este instalat, rulați comanda sudo apt-get install tree.

student@uso:~/.../01-fs/support/basics$ tree .
.
├── grotesque
│   ├── asg
│   ├── coin2
│   └── do you dare
│       ├── ascii
│       ├── dos4fun
│       ├── elf
│       ├── hunter
│       ├── hunting
│       ├── mipstake
│       └── rootkit
├── hacker-s secret
│   ├── hard
│   │   ├── malware
│   │   └── pwnsandbox
│   ├── medium
│   │   ├── softmmu
│   │   └── tiney
│   └── really hard
│       ├── exploitable
│       └── nuclear
├── rookiss
│   ├── ascii easy.pdf
│   ├── brain fuck
│   ├── echo2
│   ├── fix.pdf
│   ├── loveletter
│   ├── otp.pdf
│   └── syscall
└── toddler-s bottle
    ├── bof
    │   ├── easy
    │   │   ├── bof-bof-bof
    │   │   ├── bof1.txt
    │   │   ├── bof2.txt
    │   │   ├── bof3.txt
    │   │   ├── bof4.txt
    │   │   ├── bof5.txt
    │   │   ├── can-you-bof
    │   │   └── random-bof.txt
    │   ├── hard
    │   │   └── I bet you can-t
    │   └── medium
    │       └── getting-serious-here
    ├── collision
    ├── fd
    ├── flag
    ├── input
    ├── passcode
    │   ├── passcode1
    │   ├── passcode2
    │   └── random-org
    └── random
 
13 directories, 40 files

Vrem să afisăm calea curentă pentru a vedea în ce director ne aflăm. Vom folosi comanda pwd. După aceea, vom lista conținutul directorului pentru a-l inspecta.

student@uso:~/.../01-fs/support/basics$ pwd
/home/student/uso.git/labs/01-fs/support/basics
student@uso:~/.../01-fs/support/basics$ ls
grotesque  'hacker-s secret'   rookiss  'toddler-s bottle'

De multe ori avem nevoie să ne plasăm cu un director în spate. Pentru a ajunge în directorul părinte folosim comanda cd ... E bine să verificăm de fiecare dată că ne aflăm în directorul în care trebuie.

student@uso:~/.../01-fs/support/basics$ pwd
/home/student/uso.git/labs/01-fs/support/basics
student@uso:~/.../01-fs/support/basics$ cd ..
student@uso:~/uso.git/labs/01-fs/support$ pwd
/home/student/uso.git/labs/01-fs/support

După folosirea comenzii tree știm întreaga ierarhie și cunoaștem calea pană la un anumit subdirector. Vrem să ajungem acolo. Putem face asta prin comenzi succesive de tipul cd subdirector sau putem folosi o singură comandă pentru a ne ușura munca.

student@uso:~/uso.git/labs/01-fs/support$ cd ~/uso.git/labs/01-fs/support/basics/
student@uso:~/.../01-fs/support/basics$ tree .
.
├── grotesque
│   ├── asg
│   ├── coin2
│   └── do you dare
│       ├── ascii
│       ├── dos4fun
│       ├── elf
│       ├── hunter
│       ├── hunting
│       ├── mipstake
│       └── rootkit
├── hacker-s secret
│   ├── hard
│   │   ├── malware
│   │   └── pwnsandbox
│   ├── medium
│   │   ├── softmmu
│   │   └── tiney
│   └── really hard
│       ├── exploitable
│       └── nuclear
├── rookiss
│   ├── ascii easy.pdf
│   ├── brain fuck
│   ├── echo2
│   ├── fix.pdf
│   ├── loveletter
│   ├── otp.pdf
│   └── syscall
└── toddler-s bottle
    ├── bof
    │   ├── easy
    │   │   ├── bof-bof-bof
    │   │   ├── bof1.txt
    │   │   ├── bof2.txt
    │   │   ├── bof3.txt
    │   │   ├── bof4.txt
    │   │   ├── bof5.txt
    │   │   ├── can-you-bof
    │   │   └── random-bof.txt
    │   ├── hard
    │   │   └── I bet you can-t
    │   └── medium
    │       └── getting-serious-here
    ├── collision
    ├── fd
    ├── flag
    ├── input
    ├── passcode
    │   ├── passcode1
    │   ├── passcode2
    │   └── random-org
    └── random
 
13 directories, 40 files
student@uso:~/.../01-fs/support/basics$ cd grotesque/do<TAB>
student@uso:~/.../basics/grotesque/do you dare$ pwd
/home/student/uso.git/labs/01-fs/support/basics/grotesque/do you dare

Câteodată vrem să ne plasăm într-un alt subdirector din ierarhia mare care nu se află în calea curentă. Avem iarăși de ales între pași mici, succesivi sau folosirea unei sigure comenzi pentru a ne poziționa altundeva.

student@uso:~/.../basics/grotesque/do you dare$ pwd
/home/student/uso.git/labs/01-fs/support/basics/grotesque/do you dare
student@uso:~/.../basics/grotesque/do you dare$ cd ../../rookiss
student@uso:~/.../support/basics/rookiss$ pwd
/home/student/uso.git/labs/01-fs/support/basics/rookiss

Până acum ne-am jucat cu ierarhia dată de echipa de USO, dar cum facem dacă vrem să ajungem în directorul /usr/local? Folosim o cale absolută pentru a naviga direct acolo fără a ne face griji de directorul în care ne aflăm, cât va trebui să ne deplasăm în spate (sau în față) pentru a ajunge unde vrem.

student@uso:~/.../support/basics/rookiss$ cd /usr/local
student@uso:/usr/local$ pwd
/usr/local

Pentru a ajunge în directorul home al utilizatorului curent de oriunde ne-am afla, folosim:

student@uso:/usr/local$ cd ~ # 'tilda'
student@uso:~$ pwd
/home/student

Până a trece mai departe, trebuie să vă asigurați că ați înțeles cum trebuie navigarea printr-o ierarhie de directoare. Pentru asta, parcurgeți următoarele exerciții după care verificați cu asistentul că totul este în regulă.

1. Plasați-vă în directorul hacker-s\ secret/medium.
2. Navigați în sistemul de fișiere către directorul toddler-s\ bottle/bof/easy pornind din directorul home al utilizatorului curent.
3. Ajungeți înapoi în directorul home al utilizatorului curent fără a folosi simbolul tilda(~).

Plasați-vă din nou în directorul /uso.git/labs/01-fs/support/basics.

După cum am observat mai sus, listarea conținutului unui director se poate face folosind comanda ls. Această formă de utilizator nu ne prezintă foarte multe informații despre fișierele din directorul inspectat (dimensiune, drepturi, tip, etc.). Folosind argumentul -l al lui ls putem lista conținutul unui director în format lung. Astfel, putem afla mai multe informații despre fișiere, cum ar fi (în ordine): drepturile asupra fișierului, numărul de linkuri către fișier, numele ownerului, numele grupului owner, dimensiunea fișierului, data ultimei modificări și numerele acestuia.

student@uso:~/.../01-fs/support/basics$ ls -l
total 16
drwxr-xr-x 3 student student 4096 aug 21 22:17  grotesque
drwxr-xr-x 5 student student 4096 aug 21 22:17 'hacker-s secret'
drwxr-xr-x 2 student student 4096 aug 21 22:17  rookiss
drwxr-xr-x 4 student student 4096 aug 21 22:17 'toddler-s bottle'

Putem lista conținutul unui director altul decât cel în care ne aflăm dacă dăm comenzii ls, ca argument, calea către acesta (fie absolută, fie relativă).

student@uso:~/.../01-fs/support/basics$ ls hacker-s\ secret/hard/
malware     pwnsandbox

Utilizarea simplă a comenzii ls fără a-i da un argument special nu ne afisează fișierele acunse dintr-un director. Pentru asta, folosim argumentul -a. De remarcat, numele fișierelor ascunse încep cu ..

student@uso:~/.../01-fs/support/basics$ cd hacker-s\ secret/really\ hard/
student@uso:~/.../basics/hacker-s secret/really hard$ ls -a
.  ..  .unexploitable  exploitable  nuclear

Câteodată un director poate avea foarte multe intrări, iar noi să dorim inspectăm doar o parte dintre ele. Spre exemplu, vrem să aflăm mai multe informații despre fișierele cu extensia .pdf. Pentru asta, vom folosi wildcards.

student@uso:~/.../basics/hacker-s secret/really hard$ cd ~/uso.git/labs/01-fs/support/basics
student@uso:~/.../01-fs/support/basics$ cd rookiss
student@uso:~/.../support/basics/rookis$ pwd
/home/student/uso.git/labs/01-fs/support/basics/rookiss
student@uso:~/.../support/basics/rookis$ ls *.pdf
'ascii easy.pdf'   fix.pdf   otp.pdf

Până a trece mai departe, trebuie să vă asigurați că ați înțeles și reținut cum puteți lista conținutul unui director sub diverse forme. Pentru asta, parcurgeți următoarele exerciții după care verificați cu asistentul că totul este în regulă. Recomandăm folosirea paginii de manual pentru utilitarul ls (man ls). Vă va da informații despre toate argumentele pe care le puteți da comenzii ls. Putem da oricate argumente comenzii ls, fie sub forma ls -a -b -c, fie ls -abc.

1. Să se listeze in format lung conținutul directorului grotesque/do\ you\ dare/ cu afișarea dimensiunii fișierelor în format human readable. (Hint: man ls și căutați după șirul human readable).
2. Afișati conținutul directorului toddler-s\ bottle/ cu afișarea unui simbol pentru tipul de fișier. Remarcați diferențele dintre fișiere. (Hint: classify)
3. Listați directorul hacker-s\ secret/hard fără a naviga către el.
4. Listați întreg conținutul directorului grotesque/ (inclusiv fișiere ascunse).
5. Listați doar fișierele cu extensia .txt din directorul toddler-s\ bottle/bof/easy folosind o singură comandă.
6. Plasati-vă în directorul toddler-s\ bottle/passcode și afisați toate fișierele ale căror nume au prefixul passcode.

Contul privilegiat (root) este folosit în Linux pentru a realiza acțiuni privilegiate. De exemplu, nu putem vedea conținutul fișierului /etc/sudoers decât ca root. Astfel, dacă rulăm comanda

cat /etc/sudoers

vom primi mesajul

cat: /etc/sudoers: Permission denied

pentru că nu avem permisiuni.

Pentru a rula ca utilizatorul root, prefixăm comanda de mai sus cu altă comandă, anume sudo. Comanda sudo rulează comanda de după ea cu permisiuni de root. Astfel, comanda de mai jos va reuși și va afișa conținutul fișierului /etc/sudoers:

sudo cat /etc/sudoers

Dacă este cazul, la promptul de parolă cerut veți introduce parola utilizatorului student, care este tot student.

Dacă vrem să obținem un prompt în care orice comandă rulează ca root vom folosi comanda

sudo su

Ca urmare a rulării comenzii sudo su vom avea acum un prompt nou, numit prompt de root, identificabil prin faptul că acum promptul se închide în simbolul # (diez) în loc de $ (dollar). Pentru a reveni înapoi la utilizatorul student vom folosi comanda exit.

[3a] Deschideți un terminal cu 4 tab-uri. În două tab-uri obțineți prompt de root; în unul din aceste două tab-uri afișați fișierul /etc/sudoers iar în celălalt fișierul /etc/shadow.

Acum o să lucrăm la partea cea mai vizibilă dintr-un sistem de operare: sistemul de fișiere. Adică vom crea, șterge, modifica și afișa fișiere, directoare, link-uri. Să începem!

cd ~/uso.git/labs

De multe ori dorim să salvăm rezultatul afișat de o comandă (output) într-un fișier pentru a-l consulta ulterior. Acest lucru este util pentru comenzile care afișează multe informații pe care nu le putem vizualiza ușor sau pentru a reține snapshot-uri ale rulării unei comenzi pe care să le comparăm între ele. De exemplu, dacă rulăm comanda

ls > out.txt

Vom obține în fișierul out.txt rezultatul rulării comenzii ls. Putem verifica acest lucru cu ajutorul comenzii

cat out.txt

Operatorul > din shell este numit operator de redirectare, cu ajutorul căruia redirectăm rezutatul comenzii (adică ieșirea standard, standard output) în fișierul trimis ca argument.

Un caz de utilizare este atunci când dorim să rulăm o comandă fără a ne preocupa rezultatul rulării acesteia. În acest caz redirectăm ieșirea standard a comenzii la fișierul special /dev/null. Fișierul special /dev/null este un fișier de tipul “gaură neagră”: orice informație redirectată acolo se pierde.

Pentru a exemplifica redirectarea în fișierul special /dev/null vom folosi utilitarul/comanda strace. Comanda strace monitorizează apelurile pe care le face o altă comandă către sistemul de operare (strace – system call tracing). Pentru început rulăm comanda de mai jos și obținem rezultatul indicat:

student@uso:~/uso.git/labs$ strace ls
execve("/bin/ls", ["ls"], 0x7ffdde615410 /* 35 vars */) = 0
brk(NULL)                               = 0x5651b5da3000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
[...]
write(1, "00-intro  01-fs  02-process  03-"..., 10900-intro  01-fs  02-process  03-user  04-appdev  05-cli  06-hw-boot  07-storage  08-net  09-vm	10-sec	11-ctf
[...]

Comanda strace primește ca argument o altă comandă și argumentele aceleia. În cazul de mai sus, a primit ca argument comanda ls. Apoi comanda strace afișează la ieșirea standard (standard output) rezultatul comenzii primite ca argument (la noi ls) iar la ieșirea de eroare standard (standard error) rezultatul propriu (adică sumarul apelurilor pe care îl face comanda primită ca argument la sistemul de operare).

[1a] Ne dorim să afișăm la terminal doar rezultatul comenzii strace, adică apelurile realizate de comanda primită ca argument, fără să ne preocupe rezultatul comenzii. Pentru aceasta redirectăm ieșirea standard la /dev/null, adică în acel fișier special gaură neagră. Rulăm acum fără redirectare și cu redirectare comenzile de mai jos pentru a investiga fișierele deschise de comanda ls:

student@uso:~/uso.git/labs$ strace -e openat ls
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpcre.so.3", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/proc/filesystems", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/share/locale/locale.alias", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/UTF-8/LC_CTYPE", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
00-intro  01-fs  02-process  03-user  04-appdev  05-cli  06-hw-boot  07-storage  08-net  09-vm	10-sec	11-ctf	strace.out
+++ exited with 0 +++
student@uso:~/uso.git/labs$ strace -e openat ls > /dev/null
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpcre.so.3", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/proc/filesystems", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/share/locale/locale.alias", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/UTF-8/LC_CTYPE", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
+++ exited with 0 +++

În cazul redirectării ieșirii standard la fișierul special /dev/null folosind operatorul >, observăm că nu mai apare listarea de fișiere 00-intro … reprezentând rezultatul comenzii ls.

[1b] Într-o situație ne interesează să redirectăm rezultatul comenzii strace într-un fișier; adică acea înlănțuire de apeluri efectuate de comanda primită ca argument către sistemul de operare. Pentru aceasta, folosim operatorul 2> de redirectare a ieșirii de eroare standard (standard error) ca mai jos:

student@uso:~/uso.git/labs$ strace -e openat ls 2> strace.out
00-intro  01-fs  02-process  03-user  04-appdev  05-cli  06-hw-boot  07-storage  08-net  09-vm	10-sec	11-ctf

În comanda de mai sus ieșirea de eroare standard (standard error) a fost redirectată în fișierul strace.out; adică rezultatul comenzii strace, adică șirul de apeluri ale comenzii ls la sistemul de operare. La terminal a fost afișată ieșirea standard a comenzii, adică rezultatul comenzii ls.

Verificăm faptul că redirectarea a avut loc cu succes afișând conținutul fișierului strace.out cu ajutorul comenzii

student@uso:~/uso.git/labs$ cat strace.out
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpcre.so.3", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/proc/filesystems", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/share/locale/locale.alias", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/UTF-8/LC_CTYPE", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
+++ exited with 0 +++

Observăm că, așa cum ne așteptam, rezultatul comenzii strace (lista de apeluri) a fost redirectată cu succes în fișier prin redirectarea ieșirii de eroare standard (standard error).

[1c] Ne poate interesa să redirectăm și rezultatul comenzii strace într-un fișier și rezultatul comenzii primite ca argument. În acest caz folosim atât operatorul > de redirectare a ieșirii standard (standard output) cât și operatorul 2> de redirectare a ieșirii de eroare standard (standard error). Pentru aceasta folosim comanda:

student@uso:~/uso.git/labs$ strace -e openat ls 2> strace.out > ls.out

În comanda de mai sus am redirectat ieșirea standard (standard output), adică rezultatul comenzii ls, în fișierul ls.out și ieșirea de eroare standard (standard error), adică rezultatul comenzii strace, în fișierul strace.out. Putem verifica acest lucru prin afișarea conținutului celor două fișiere:

student@uso:~/uso.git/labs$ cat strace.out
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpcre.so.3", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/proc/filesystems", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/share/locale/locale.alias", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/usr/lib/locale/UTF-8/LC_CTYPE", O_RDONLY|O_CLOEXEC) = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
+++ exited with 0 +++
student@uso:~/uso.git/labs$ cat ls.out
00-intro
01-fs
02-process
03-user
04-appdev
05-cli
06-hw-boot
07-storage
08-net
09-vm
10-sec
11-ctf
ls.out
strace.out

Observăm că cele două fișiere obținute în urma redirectării (strace.out și ls.out) conțin rezultatele rulării comenzilor.

[1d] Construiți o comandă strace care să nu afișeze nimic la terminal și să aibă în fișierul strace.out apelurile de deschidere de fișiere realizate de comanda ps.

[1e] Utilitarul grep este folosit pentru a căuta un șir de caractere într-un fișier. De exemplu comanda de mai jos caută șirul root în fișierul /etc/passwd:

student@uso:~/uso.git/labs$ grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash

După rularea unei comenzi putem folosi comanda echo $? pentru a vedea dacă s-a rulat cu succes. De exemplu, dacă după rularea comenzii grep de mai sus, rulăm comanda de verificare a unei rulări cu succes, obținem:

student@uso:~/uso.git/labs$ echo $?
0

Rezultatul 0 înseamnă o comandă anterioară s-a rulat cu succes.

Construiți o comanda grep cu redirectare care să nu afișeze nimic la terminal (nici standard output, nici standard error). Iar după rularea acelei comenzi să verificați rularea cu succes. Pentru a verifica faptul că ați construit comanda grep cum trebuie, folosind secvența de comenzi de mai jos:

student@uso:~/uso.git/labs$ grep 'a' /etc/passwd TODO
student@uso:~/uso.git/labs$ echo $?
0
student@uso:~/uso.git/labs$ grep 'aaa' /etc/passwd TODO
student@uso:~/uso.git/labs$ echo $?
1
student@uso:~/uso.git/labs$ grep 'aaa' /etc/pass TODO
student@uso:~/uso.git/labs$ echo $?
2

În loc de TODO trebuie să completați cu acele părți din construcție care folosesc redirectre pentru a nu afișa nimic la terminal.

cd ~/uso.git/labs/01-fs

[2a] Aflându-vă în directorul ~/uso.git/labs/01-fs, creați o arhivă .zip cu numele support-g.zip și o arhivă .tar.gz cu numele support-g.tar.gz cu toate intrările (fișiere, directoare etc.) care încep cu litera g din directorul support/.

Verificați-vă folosind comanda de afișare a conținutului unei arhive .zip, respectiv comanda de afișare a conținutului unei arhive .tar.gz.

[2b] Aflându-vă în directorul ~/uso.git/labs/01-fs, creați o arhivă .zip cu numele 01-fs-g.zip și o arhivă .tar.gz cu numele 01-fs-g.tar.gz cu toate intrările (fișiere, directoare etc.) care încep cu litera g din directorul support/ și toate intrările (fișiere, directoare etc.) care încep cu litera g din directorul wiki/.

Verificați-vă folosind comanda de afișare a conținutului unei arhive .zip, respectiv comanda de afișare a conținutului unei arhive .tar.gz.

[2c] Putem actualiza o arhivă adăugând sau ștergând un fișier din cadrul ei. De exemplu în arhiva de 01-fs-g.zip de mai sus putem adăuga fișierul wiki/recap.wiki folosind comanda

student@uso:~/uso.git/labs/01-fs$ zip 01-fs-g.zip wiki/recap.wiki
  adding: wiki/recap.wiki (stored 0%)

Putem verifica adăugarea cu succes a fișierului wiki/recap.wiki folosind comanda

student@uso:~/uso.git/labs/01-fs$ unzip -l 01-fs-g.zip
Archive:  01-fs-g.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
        0  2018-08-24 14:52   support/get-a-life/
        0  2018-08-24 14:52   support/get-a-life/3-template/
[...]
        0  2018-08-24 14:52   wiki/get-a-life.wiki
        0  2018-08-24 14:52   wiki/recap.wiki
---------                     -------
    12120                     32 files

Observăm în rezultatul comenzii existența fișierului wiki/recap.wiki, deci a fost adăugat cu succes.

Putem șterge fișiere dintr-o arhivă .zip. De exemplu, pentru a șterge fișierul wiki/get-a-life.wiki din arhiva 01-fs-g.zip folosim opțiunea -d a comenzii zip:

student@uso:~/uso.git/labs/01-fs$ zip -d 01-fs-g.zip wiki/get-a-life.wiki
updating: wiki/get-a-life.wiki (stored 0%)

[2d] Adăugați fișierele wiki/demo.wiki și wiki/basics.wiki la arhiva 01-fs-g.zip. Ștergeți fișierele support/get-a-life/2-passwd/reader.c și support/get-a-life/4-rename/4.tex din arhiva 01-fs-g.zip.

[2e] O arhivă .tar.gz este de fapt o arhivă .tar comprimată cu utilitarul gzip. Fiind trecută prin două filtre de prelucrare, nu putem adăuga și șterge fișiere din acea arhivă. Putem face însă, acest lucru pe o arhivă .tar.

Lucrul cu arhive .tar este similar lucrului pe arhive .tar.gz numai că acum lipsește opțiunea z din comanda tar. Adică:

• creăm o arhivă .tar folosind comanda

  tar cvf my.tar file1 file2 dir1 dir2 ...

• dezarhivăm o arhivă .tar folosind comanda

  tar xvf my.tar

• listăm conținutul unei arhive .tar folosind comanda

  tar tf my.tar

Creați o arhivă 01-fs-g.tar cu cu toate intrările (fișiere, directoare etc.) care încep cu litera g din directorul support/ și toate intrările (fișiere, directoare etc.) care încep cu litera g din directorul wiki/. Listați conținutul arhivei.

[2f] Adăugați fișierele wiki/demo.wiki și wiki/basics.wiki la arhiva 01-fs-g.tar. Ștergeți fișierele support/get-a-life/2-passwd/reader.c și support/get-a-life/4-rename/4.tex din arhiva 01-fs-g.tar.

O situație frecventă în lucrul cu fișiere este să parcurgem toate fișierele dintr-o ierarhie. Eventual să facem apoi operații pe toate aceste fișiere: să schimbăm permisiuni, să afișăm informații, să ștergem unele fișiere. Pentru aceasta folosim utilitarul find.

În mod implicit find afișează recursiv toate intrările din directorul curent, așa cum se vede când rulăm comanda

student@uso:~/uso.git/labs/01-fs$ find
.
./wiki
./wiki/basics.wiki
./wiki/concepts.wiki
./wiki/demo.wiki
./wiki/get-a-life.wiki
./wiki/nice-to-know.wiki
./wiki/recap.wiki
./wiki/need-to-know.wiki
./01-fs-g.zip
./support
./support/.gitignore
./support/get-a-life
[...]

Dacă-i dăm un argument un director, va afișa recursiv toate intrările din acel director. De exemplu, comanda de mai jos afișează toate intrările din ierarhia /var/lib/apt/:

student@uso:~/uso.git/labs/01-fs$ find /var/lib/apt
/var/lib/apt
/var/lib/apt/mirrors
/var/lib/apt/mirrors/partial
/var/lib/apt/daily_lock
/var/lib/apt/lists
[...]

[3a] Putem afișa folosind find doar anumite tipuri de intrări, de exemplu doar fișiere. Pentru a afișa doar fișierele din directorul curent folosim opțiunea -type f, la fel ca în comanda de mai jos:

student@uso:~/uso.git/labs/01-fs$ find -type f
./wiki/basics.wiki
./wiki/concepts.wiki
./wiki/demo.wiki
./wiki/get-a-life.wiki
./wiki/nice-to-know.wiki
./wiki/recap.wiki
[...]

Observăm în output că sunt afișate numai fișiere, folosind opțiunea -type f.

[3b] Putem afișa fișierele care corespund unui anumit pattern. De exemplu pentru a afișa toate fișierele cu extensia .tex vom folosi opțiunea -name, la fel în comanda de mai jos:

student@uso:~/uso.git/labs/01-fs$ find -type f -name '*.tex'
./support/nice-to-know/fruits/pear.tex
./support/get-a-life/4-rename/5.tex
./support/get-a-life/4-rename/3.tex
[...]

Observăm că sunt afișate numai fișierele cu extensia .tex.

[3c] Putem folosi comanda find pentru a aplica o altă comandă pe intrările găsite. De exemplu dacă dorim să ștergem toate fișierele cu extensia .c vom folosi opțiunea -exec, la fel ca în comanda de mai jos:

student@uso:~/uso.git/labs/01-fs$ find -type f -name '*.c'
./support/nice-to-know/fruits/apple.c
./support/get-a-life/2-passwd/reader.c
student@uso:~/uso.git/labs/01-fs$ find -type f -name '*.c' -exec rm {} \;
student@uso:~/uso.git/labs/01-fs$ find -type f -name '*.c'
student@uso:~/uso.git/labs/01-fs$

Dacă la început aveam două fișiere cu extensia .c (./support/nice-to-know/fruits/apple.c și ./support/get-a-life/2-passwd/reader.c) după rularea comenzii find acele fișiere dispar.

[3d] Pe baza celor de mai sus, ștergeți toate fișierele temporare din ierarhia curentă.

În directorul ~/uso.git/labs/01-fs/support/04-compile/ găsiți un set de fișiere și un fișier Makefile pentru compilarea lor. Există o eroare ce ține de căi în sistemul de fișiere, astfel că nu merge compilarea în momentul rulării comenzii make.

Corectați eroarea și obțineți fișierul executabil write_hello.

Conectați un stick USB pe un port USB al sistemului vostru. Folosiți linia de comandă pentru a copia ierarhia curentă (~/uso.git/labs/01-fs/support/04-compile/) pe stick.

sudo umount <mount-point>

Comenzile pe care le rulăm au la bază fișiere executabile în sistemul de fișiere. În momentul în care dăm o comandă, shell-ul caută într-o listă predefinită de directoare existența unui executabil cu ajutorul căruia să ruleze comanda respectivă. De exemplu, comanda ls folosește executabilul /bin/ls, astfel că rularea celor două comenzi de mai jos este echivalentă:

ls
/bin/ls

Similar, comanda find folosește executabilul /usr/bin/find, comanda zip folosește executabilul /usr/bin/zip și așa mai departe.

Directoarele în care caută shell-ul executabile aferente unei comenzi se găsesc într-o construcție de tip variabilă de mediu numită PATH. Vom vorbi mai multe despre variabile și variabile de mediu la un laborator viitor. Pe moment, este suficient să știm că pentru a afișa valoarea variabilei PATH folosim comanda

student@uso:~/uso.git/labs/01-fs$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

Directoarele afișate, conținute de variabila PATH sunt afișate în rezultatul comenzii, separate prin caracterul : (două puncte, colon). Asta înseamnă ca dacă un utilizator tastează comanda ls, shell-ul va căuta, în ordine, existența executabilului /usr/local/sbin/ls, apoi /usr/local/bin/ls, apoi /usr/sbin/ls și așa mai departe. Când găsește un executabil îl va rula, ducând la afișarea rezultatului comenzii la terminal.

Calea către executabilul aferent unei comenzi poate fi afișată folosind comanda which urmată de numele comnezii, ca mai jos:

student@uso:~/uso.git/labs/01-fs$ which ls
/bin/ls
student@uso:~/uso.git/labs/01-fs$ which find
/usr/bin/find
student@uso:~/uso.git/labs/01-fs$ which zip
/usr/bin/zip

În rulările celor trei comenzi which de mai sus am obținut calea către fișierele executabilele aferente respectiv comenzilor ls, find și zip.

Putem verifica faptul că acele fișiere sunt executabile prin folosirea comenzii file urmată de calea către fișierul executabil, ca mai jos:

student@uso:~/uso.git/labs/01-fs$ file /bin/ls
/bin/ls: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=9567f9a28e66f4d7ec4baf31cfbf68d0410f0ae6, stripped
student@uso:~/uso.git/labs/01-fs$ file /usr/bin/find
/usr/bin/find: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=b920f53e0c67a31d8ef07b84b1344f87a0e82d71, stripped
student@uso:~/uso.git/labs/01-fs$ file /usr/bin/zip
/usr/bin/zip: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=c828586e6e7cf929500a5b9c04faece9eceed5cc, stripped

În rezultatul rulării celor trei comenzi file de mai sus vedem că apare informația ELF, dynamically linked. Fără a intra în detalii, acest lucru este indiciul că aceste fișiere sunt, într-adevăr, fișiere executabile.

[6a] Găsiți fișierele executabilele aferente comenzilor useradd, iotop, tar, gzip. Verificați că cele patru fișiere indicate sunt fișiere executabile.

Bonus: De ce fișierele executabile pentru useradd și iotop se găsesc într-un director care conține sbin/ pe când tar și gzip se găsesc într-un director care conține bin/ (fără s)? Folosiți Internetul și Google pentru aflarea răspunsului.

[1a] Intrați în directorul ~/uso.git/labs/01-fs/support/get-a-life/1-to_delete. Folosind linia de comandă, ștergeți fișierul -to_delete.

[1b] Creați și ștergeți un fișier cu Enter în nume, folosind linia de comandă.

[1c] Creați un fișier de 32MB cu date random. (Hint: dd)

[2a] Intrați în directorul uso/labs/01-fs/support/get-a-life/2-passwd. Rulați comanda make și verificați folosind ls că a fost creat executabilul reader. Binarul afișează la consolă conținutul fișierului primit că argument (Ex: ./reader ~/.bash_history). În schimb, /etc/passwd a fost blocat de programator din motive de securitate. Încercați totuși să afișați /etc/passwd folosind executabilul dat.

[3a] Intrați în directorul uso/labs/01-fs/support/get-a-life/3-template. Creați fișierele laborator-01.wiki … laborator-12.wiki care au același conținut că și template.wiki, cu excepția primei linii în care se va modifica numărul laboratorului.

[3b] Intrați în directorul uso/labs/01-fs/support/get-a-life/4-rename. Redenumiți fișierele 1.tex, 2.tex, … 20.tex în 01.tex, 02.tex, … , 20.tex.

[3c] Creați o arhivă zip cu toate fișierele cu extensia .conf din ierarhia /etc/. (Hint: find)

[4a] Găsiți toate fișierele executabile din ierarhia /etc/.

[4b] Găsiți toate fișierele care nu au ca grup root-ul din ierarhia /etc/.

[5a] De ce useradd este vizibil doar pentru root (cu which) dar nu și pentru utilizatorul obișnuit?

[5b] De ce comanda cd sau exit nu este vizibilă cu which?

• Linie de comandă, comenzi, argumente/opțiuni
• Directorul curent: pwd. Navigare prin directoare: cd. Listarea conținutului: ls. Sistemul de fișiere în Linux are o structură arborescentă/ierarhică: ls -R, tree
• Redenumire fișiere, mutare fișiere: mv
• Copiere fișiere: cp
• Linux manpages and offline help: man
• Wildcard listing use-case: Listarea tuturor fișierelor cu extensia .conf din directorul etc din rădăcină:

ls /etc/*.conf

• Copiere/ștergere recursivă a directoarelor care nu sunt goale: rm -r my_dir, cp -r my_dir
• rmdir vs. rm vs. rm -rf
• Afișarea conținutului unor fișiere: cat file. Semnificația cat este de concatenare a fișierelor primite ca argument de intrare și de afișare la ieșirea standard a conținutului: cat file1 file2 file3 … . Dacă nici un fișier nu e dat ca argument de intrare, atunci cat va aștepta date de la intrarea standard (tastatură) până când este apăsata combinația de taste CTRL+d.
• Căutarea în sistemul de fișiere: locate
• Editarea de fișiere text: vim
• Arhivare/dezarhivare: tar, zip
• Redirectări, ieșire standard, ieșire de eroare standard: >, 2>
• Parcurgerea fișierelor dintr-o ierarhie: find
• Comenzi și executabie: PATH, which, file