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 tildă) 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!

Pentru a căuta un fișier în sistemul de fișiere putem folosi comanda locate. Aceasta se folosește în felul următor:

student@uso:~$ locate --help
Usage: locate [OPTION]... [PATTERN]...

Putem observa că după locate trebuie să menționăm opțiunile precum și pattern-ul, adică cuvântul cheie pe care îl căutam. Putem afla aceste opțiuni prin folosirea comenzii man locate sau locate –help.

Vom căuta cuvântul cheie slayer, adică fișierul slayer în sistemul de fișiere.

student@uso:~$ locate slayer

Putem observa că nu există niciun rezultat. Asta deoarece locate caută într-o bază de date creată la un moment dat. Dacă fisierul slayer a fost adaugat ulterior, baza de date trebuie actualizată. Putem face asta folosind (folosiți parola student atunci când este cerută):

student@uso:~$ sudo updatedb
[sudo] password for student:

Încercând din nou:

student@uso:~$ locate slayer
/home/student/uso.git/lab02/demo/slayer

[1a] Căutați fișierul pwd în ierarhia de fișiere a sistemului curent.

[1b] Căutați fișiere cu extensia .odt în ierarhia de fișiere a sistemului curent.

Putem crea directoare folosind comanda mkdir. Aceasta se folosește în felul următor:

student@uso:~/uso.git$ mkdir --help
Usage: mkdir [OPTION]... DIRECTORY...
Create the DIRECTORY(ies), if they do not already exist.

Cuvântul cheie mkdir urmat de opțiuni și de numele directorului pe care vrem să îl creăm. Putem afla aceste opțiuni prin folosirea comenzii man mkdir sau mkdir –help la fel ca la utilitarele locate și grep.

Să creăm un director pornind de la ~/uso.git. Mergem în acest director folosind cd ~/uso.git

student@uso:~/uso.git$ mkdir director_nou
student@uso:~/uso.git$ ls -l director_nou/
total 8
drwxr-xr-x  2 student student 4096 aug 22 23:35 ./
drwxr-xr-x 15 student student 4096 aug 22 23:35 ../

Am folosit utlitarul mkdir fără nicio opțiune. Atentie! După fiecare comandă executată este bine să verificăm că aceasta s-a executat cu succes. După cum vedeți, am verificat folosind utlitarul ls -l. Să creăm încă un director în cadrul acestuia, dar să rămânem în calea ~/uso.git.

student@uso:~/uso.git$ mkdir -p director_nou/alt_director
student@uso:~/uso.git$ ls -l director_nou/
total 4
drwxr-xr-x 2 student student 4096 aug 22 23:38 alt_director

Am folosit opțiunea -p de data aceasta pentru a crea un director într-o altă cale față de cea curentă. Este echivalent cu:

student@uso:~/uso.git$ cd director_nou/
student@uso:~/uso.git/director_nou$ mkdir un_al2lea_director
student@uso:~/uso.git/director_nou$ ls -l
total 8
drwxr-xr-x 2 student student 4096 aug 22 23:38 alt_director
drwxr-xr-x 2 student student 4096 aug 22 23:39 un_al2lea_director

[2a] Creați o ierarhie de directoare în directorul curent conform celei de mai jos. Hint: Frunzele sunt fișiere, nu directoare (nu se termină în /).

student@uso$ tree .
.
|-- ac_dc
|   |-- angus
|   |-- bon
|   |-- brian
|   |-- chris
|   |-- cliff
|   |-- dave
|   |-- george
|   |-- malcom
|   |-- mark
|   `-- phil
|-- cargo
|-- hammerfall
|   |-- anders
|   |-- jesper
|   |-- joacim
|   |-- magnus
|   |-- oscar
|   |-- pontus
|   `-- stefan
|-- iris
|-- metallica
|-- nightwish
|-- nirvana
|-- phoenix
`-- slayer

Putem muta directorul un_al2lea_director în alt_director fiind în ~/uso.git:

student@uso:~/uso.git/director_nou$ cd ~/uso.git/
student@uso:~/uso.git$ mv director_nou/un_al2lea_director/ director_nou/alt_director/
student@uso:~/uso.git$ ls -l director_nou/
total 4
drwxr-xr-x 3 student student 4096 aug 22 23:41 alt_director
student@uso:~/uso.git$ ls -l director_nou/alt_director/
total 4
drwxr-xr-x 2 student student 4096 aug 22 23:39 un_al2lea_director

Putem șterge acel director fiind în ~/uso.git:

student@uso:~/uso.git$ rmdir director_nou/alt_director/un_al2lea_director
student@uso:~/uso.git$ ls -l director_nou/alt_director/
total 0

Am folosit utilitarul rmdir pentru a sterge un director (remove directory). Bineînteles, am verificat la sfârșit că operația s-a executat cu succes și directorul nu mai există.

[2b] În directorul . (conform ierarhiei de mai sus) creați un director numit muzica și mutați întregul conținut al . în muzica. Ștergeți directorul hammerfall.

[2c] Editați fișierul metallica cu 5 nume de melodii. Pentru rezolvarea acestui exercițiu va trebui să folosiți vim.

Putem crea archive folosind diferite extensii. E bine să știm să creăm diferite tipuri de arhive deoarece fiecare are beneficiul ei. Astfel, pentru arhiva.zip folosim:

student@uso:~/uso.git$ zip backup.zip -r *
  adding: README.md (deflated 18%)
  adding: TW Warhammer/ (stored 0%)
  adding: TW Warhammer/.gitignore (stored 0%)
  adding: TW Warhammer/Greenskins/ (stored 0%)
[...]

Pentru arhiva.tar.gz:

student@uso:~/uso.git$ tar -zcvf backup.tar.gz *
README.md
TW Warhammer/
TW Warhammer/.gitignore
TW Warhammer/Greenskins/
[...]

Pentru arhiva.tar.bz2:

student@uso:~/uso.git$ tar -cvjSf backup.tar.bz2 *
README.md
TW Warhammer/
TW Warhammer/.gitignore
TW Warhammer/Greenskins/
TW Warhammer/Greenskins/Grimgor Ironhide/
[...]

Putem observa rezultatul:

student@uso:~/uso.git$ ls -l
total 91124
drwxr-xr-x 15 student student     4096 aug 23 00:58  ./
drwxr-xr-x 21 student student     4096 aug 23 00:58  ../
drwxr-xr-x  8 student student     4096 aug 20 20:57  .git/
-rw-r--r--  1 student student      146 aug 20 20:57  README.md
drwxr-xr-x  4 student student     4096 aug 20 20:57 'TW Warhammer'/
-rw-r--r--  1 student student 30916450 aug 23 00:58  backup.tar.bz2
-rw-r--r--  1 student student 31132786 aug 23 00:58  backup.tar.gz
-rw-r--r--  1 student student 31187418 aug 23 00:52  backup.zip

Utilitarele zip și tar au diferite opțiuni pentru arhivare și dezarhivare. Acestea se pot vedea folosind man tar / man zip sau tar --help / zip --help

[3a] Folosind ierarhia uso/labs/01-fs creați arhive de tipul zip, tar.gz și tar.bz2 ce vor conține întreaga ierarhie. Un exemplu de arhiva este 01-fs.zip.

[3b] Afișați conținutul arhivei.

[3c] Dezarhivați arhiva într-un director numit backup.

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.

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