Utilizarea sistemelor Linux / Unix in linie de comanda

Structura generală a unei comenzi în Bash

1. Numele Comenzii: Acesta este programul sau comanda pe care doriți să o executați. Este primul element pe care îl introduceți și spune shell-ului ce acțiune să efectueze.

2. Opțiuni: Opțiunile, adesea precedate de o singura liniuta sau doua liniute --, modifică comportamentul comenzii standard. Unele comenzi pot funcționa fără opțiuni, în timp ce altele accepta una sau mai multe opțiuni.

3. Argumente: Argumentele sunt țintele comenzii, cum ar fi numele fișierelor, directoarelor, utilizatorilor sau alte date asupra cărora comanda va acționa. Argumentele urmează după numele comenzii și orice opțiuni aplicabile.

4. Redirecționare: Bash permite redirecționarea intrării și ieșirii unei comenzi către și dinspre fișiere sau comenzi. Simbolurile comune includ > (redirecționează ieșirea standard), < (redirecționează intrarea standard), și | (pipe, care transmite ieșirea unei comenzi ca intrare pentru alta).

5. Controlul Execuției: Bash permite controlul asupra modului în care comenzi sunt executate, cum ar fi executarea în background (&), gruparea comenzilor (;, &&, ||).

# exemplu comanda simpla: pwd - print working directory
stud1016@sop:~$ pwd
# output:
/home/stud1016

# exemplu comanda cu argument: echo - afiseaza un sir de caractere pe ecran
stud1016@sop:~$ echo "Hello world!"
# output:
Hello world!

# exemplu comanda cu optiuni si redirectionare catre comanda 2
# numele comenzii: ls - comanda pentru listarea conținutului directorului.
# două opțiuni combinate: -l pt listare detaliată, -a pt a include fișierele ascunse
# redirecționare / Pipe: | - transmite ieșirea comenzii ls ca intrare pt comanda less
# numele comenzii (2): less - un program de paginare care permite navigarea prin conținutul prea lung pentru a fi afișat pe o singură pagină

stud1016@sop:~$ ls -la | less
# output:
total 28
drwxr-x---  5 stud1016 students 4096 Feb 21 14:00 .
drwxr-xr-x 56 root     root     4096 Feb  4 12:25 ..
-rw-------  1 stud1016 students 1863 Feb 20 17:58 .bash_history
drwx------  2 stud1016 students 4096 Feb 20 14:42 .cache
-rw-------  1 stud1016 students   20 Feb 21 14:00 .lesshst
drwxr-xr-x  2 stud1016 students 4096 Feb 21 12:51 seminar1
drwxr-xr-x  2 stud1016 students 4096 Feb 21 10:26 seminar2
-rw-r--r--  1 stud1016 students    0 Feb 21 10:26 temp.txt
stud1016@sop:~$

# se va reveni cu interpretarea outputului in sectiunea despre sistemul de permisiuni

Sistemul de fisiere si directoare

Sistemul de fișiere și directoare în Linux/Unix este structurat ierarhic, asemănător unui arbore, cu rădăcina acestui arbore reprezentată de directorul root, notat cu /. Acest sistem permite organizarea logică și eficientă a fișierelor și directoarelor pe un sistem de operare.

Iată câteva concepte cheie și caracteristici ale sistemului de fișiere în Linux/Unix:

Rădăcina /

Este nivelul cel mai înalt în ierarhia sistemului de fișiere. Toate fișierele și directoarele sunt subordonate acestui director root.

Directoare importante

• /bin și /usr/bin: Conțin fișiere executabile necesare pentru pornirea și rularea sistemului de operare, precum și programele utilizate frecvent de utilizatori.

• /boot: Conține fișierele necesare pentru procesul de boot al sistemului.

• /dev: Conține fișiere speciale sau noduri de dispozitiv care reprezintă sau controlează hardware-ul.

• /etc: Conține fișierele de configurare ale sistemului.

• /home: Conține directoarele personale ale utilizatorilor (cu excepția utilizatorului root).

• /lib și /usr/lib: Conțin bibliotecile de sistem necesare pentru executarea fișierelor binare aflate în /bin și /usr/bin.

• /root: Directorul personal al utilizatorului root (administratorul sistemului).

• /tmp: Folosit pentru stocarea fișierelor temporare.

• /usr: Conține majoritatea programelor și bibliotecilor utilizator. Subdirectoarele includ bin, lib, share, etc.

• /var: Conține fișiere care se modifică frecvent, cum ar fi loguri și baze de date.

Caracteristici

• Ierarhic: Organizarea în formă de arbore facilitează navigarea și gestionarea sistemului de fișiere.

• Permisiuni: Fiecare fișier și director are seturi de permisiuni asociate pentru proprietar, utilizatori din acelasi grup cu proprietarul și alții (utilizatori care fac parte din alt grup decat proprietarul), controlând cine poate citi, scrie sau executa un fișier sau director.

• Case-sensitive: Numele de fișiere și directoare sunt sensibile la majuscule și litere mici, astfel document.txt și Document.txt ar fi considerate distincte.

Fișiere - notiuni generale

Un fișier este o colecție de date stocate pe un dispozitiv de stocare, cum ar fi un hard disk, SSD, USB drive, sau server de rețea, care sunt tratate ca o unitate singură de către sistemul de operare. Fișierele pot conține orice tip de date: text, imagini, programe, setări de configurare, cod executabil, sau orice alt tip de informație care poate fi salvată digital.

Sistemele de operare folosesc fișiere pentru a organiza și a gestiona datele, permițând utilizatorilor și aplicațiilor să creeze, să modifice, să stocheze și să acceseze informații într-o manieră structurată și eficientă.

Caracteristici principale ale fișierelor

• Nume și Extensie: Fiecare fișier are un nume unic în contextul directorului său. Majoritatea fișierelor au și o extensie (de exemplu, .txt, .jpg, .exe), care indică tipul fișierului și determină ce program poate deschide fișierul respectiv.

• Permisiuni: Sistemele de operare moderne atribuie permisiuni fișierelor, controlând cine poate citi, scrie sau executa fișierul.

• Metadata: Pe lângă datele propriu-zise, fișierele pot include și metadata, adică informații despre fișier, cum ar fi data creării, data ultimei modificări, dimensiunea fișierului, și permisiunile acestuia.

• Tipuri de Fișiere: Există diferite tipuri de fișiere, incluzând fișiere de text, binare, executabile, și speciale (cum ar fi linkurile simbolice și directoarele în sistemele Unix/Linux).

Fișierele sunt fundamentale pentru funcționarea sistemelor de calcul și a aplicațiilor software. Ele permit:

• Stocarea Persistentă: Datele salvate în fișiere rămân disponibile și după repornirea computerului, oferind o formă de stocare persistentă.

• Organizarea Datelor: Sistemele de fișiere permit organizarea logică a datelor în directoare și subdirectoare, facilitând gestionarea eficientă a unei cantități mari de informații.

• Partajarea și Transferul de Date: Fișierele pot fi ușor partajate între utilizatori sau transferate între sisteme diferite, facilitând colaborarea și comunicarea.

Crearea fișierelor din shell-ul Linux/Unix poate fi realizată prin mai multe metode și comenzi. Iată câteva dintre cele mai uzuale comenzi, împreună cu exemple de utilizare:

Crearea fișierelor

touch

Comanda touch este cel mai simplu mod de a crea fișiere noi. Dacă fișierul specificat nu există, el va fi creat gol.

~$ touch fisier_nou.txt
~$ ls
fisier_nou.txt

Aceasta comandă creează un fișier gol numit fisier_nou.txt.

echo

Comanda echo este folosită pentru a afișa o linie de text, dar poate fi redirecționată pentru a crea un fișier cu conținut.

~$ ls #directorul este gol
~$ echo "Acesta este un text" > fisier_cu_text.txt
~$ ls
fisier_cu_text.txt

Aceasta comandă creează un fișier numit fisier_cu_text.txt și adaugă textul "Acesta este un text" în el. Dacă fișierul există deja, acesta va fi suprascris.

printf

Similar cu echo, dar oferă mai mult control asupra formatării output-ului.

~$ printf "Linia 1\nLinia 2\n" > fisier_printf.txt

Această comandă creează un fișier numit fisier_printf.txt și adaugă două linii de text în el.

cat

Comanda cat poate fi folosită pentru a combina mai multe comenzi și pentru a crea fișiere cu conținut specific.

~$ cat > fisier_cat.txt
Acesta este un text.
CTRL+D

Această secvență creează fisier_cat.txt și așteaptă ca utilizatorul să introducă textul de la tastatură. Pentru a încheia și a salva fișierul, apăsați CTRL+D.

Redirecționarea Output-ului unei comenzi

Orice comandă care generează output poate fi redirecționată pentru a crea un nou fișier.

~$ ls -l > lista_directoare.txt

Aceasta comandă creează un fișier numit lista_directoare.txt care conține lista detaliată a fișierelor și directoarelor din directorul curent.

> vs >>: Folosind > va suprascrie fișierul dacă acesta există, în timp ce >> va adăuga la sfârșitul fișierului fără a-l suprascrie.

~$ echo "Hello World" > fisier_cu_text.txt
~$ echo "Acesta este un nou rand" >> fisier_cu_text.txt
~$ cat fisier_cu_text.txt
Hello World
Acesta este un nou rand

Aceasta comandă adaugă un nou rând la fișierul existent fisier_cu_text.txt fără a șterge conținutul existent

Vizualizarea conținutului fișierelor

cat

Afișează întregul conținut al fișierului pe ecran.

~$ cat fisier.txt

less

Permite navigarea prin conținutul fișierului o pagină odată, oferind posibilitatea de a merge înainte și înapoi.

~$ less fisier.txt

head

Afișează primele linii din fișier (implicit primele 10 linii).

~$ head fisier.txt

tail

Afișează ultimele linii din fișier (implicit ultimele 10 linii). Foarte util pentru a vizualiza cele mai recente intrări în fișiere de log.

~$ tail fisier.txt

grep

Caută într-un fișier text pentru un anumit șir de caractere și afișează toate liniile care conțin acel șir.

~$ grep "cuvant_cautat" fisier.txt #se va reveni intr-un context mai detaliat

Editarea conținutului fișierelor

Pentru editarea fișierelor, sunt disponibile mai mulți editoare de text în linia de comandă, fiecare cu propriile sale caracteristici și comenzi.

nano: Un editor de text simplu și intuitiv, potrivit pentru începători.

~$ nano fisier.txt

În nano, folosiți tastatura pentru a edita textul. Pentru a salva și ieși, apăsați Ctrl + O pentru a salva modificările, apoi Ctrl + X pentru a ieși din editor.

vi sau vim: Editoarele de text mai avansate, oferind funcționalități extinse pentru editarea eficientă a textului. vim este o versiune îmbunătățită a vi.

~$ vi fisier.txt

sau

~$ vim fisier.txt

În vi/vim, veți începe în modul "normal". Pentru a începe editarea, apăsați i. După editare, apăsați Esc pentru a reveni la modul normal, apoi tastați :wq pentru a salva și ieși, sau :q! pentru a ieși fără a salva.

Crearea directoarelor si navigarea

mkdir

Comanda mkdir (make directory) este folosită pentru a crea unul sau mai multe directoare noi.

Pentru a crea un singur director:

~$ mkdir nume_director

Pentru a crea mai multe directoare în același timp:

~$ mkdir director1 director2 director3
~$ ls
director1  director2  director3

Pentru a crea un director și toate directoarele părinte necesare (opțiunea -p):

~$ mkdir -p director/parinte/subdirector
~$ tree # comanda s-ar putea sa nu fie implicit instalata
.
└── director
    └── parinte
        └── subdirector

. și ..

. reprezintă directorul curent. Poate fi folosit în diverse comenzi pentru a indica directorul actual. De exemplu, pentru a lista conținutul directorului curent folosind ls:

~$ ls .      # utilizarea . este redundanda in acest caz

.. reprezintă directorul părinte al directorului curent. Este folosit pentru a naviga înapoi în ierarhia de directoare sau pentru a referi fișiere/directoare relativ la directorul părinte.

cd

Comanda cd (change directory) este utilizată pentru a schimba directorul curent.

Pentru a naviga la un director specific:

~$ cd /calea/catre/director

Pentru a reveni la directorul home al utilizatorului:

~$ cd        # sau cd ~

Pentru a merge la directorul părinte al directorului curent:

~$ cd ..

ls

Comanda ls listează conținutul unui director.

Pentru a lista fișierele și directoarele din directorul curent:

~$ ls

Pentru a lista conținutul inclusiv fișierele ascunse (încep cu .):

~$ ls -a

Pentru a lista conținutul cu detalii (cum ar fi permisiunile, proprietarul, dimensiunea):

~$ ls -l # cum a fost ilustrat la inceputul paginii cele 2 se pot combina: ls -la

dir

Similar cu ls în multe distribuții, dir listează conținutul directoarelor:

~$ dir

tree

Comanda tree afișează o structură de arbore a directorului curent și a subdirectoarelor sale. Aceasta poate fi foarte utilă pentru a obține o vedere de ansamblu asupra ierarhiei de fișiere/directoare.

Pentru a afișa structura în formă de arbore a directorului curent și a subdirectoarelor:

~$ tree

Pentru a limita afișarea la un anumit nivel de adâncime (de exemplu, 2 nivele):

~$ tree -L 2

Pentru a utiliza comanda tree, s-ar putea să fie necesar să o instalezi prima dată folosind managerul de pachete al distribuției tale, deoarece nu este întotdeauna instalată implicit.

Stergerea fisierelor si directoarelor

Stergerea fișierelor și directoarelor din linia de comandă Linux/Unix se poate realiza prin mai multe metode, folosind comenzi precum rm, rmdir, și opțiuni ca -r. Fiecare dintre aceste comenzi și opțiuni are un scop specific și trebuie utilizată cu prudență, deoarece ștergerea fișierelor în modul terminal este de obicei ireversibilă.

rm

Comanda rm (remove) este folosită pentru a șterge fișiere și directoare.

Pentru a șterge un singur fișier:

~$ touch fisier.txt 
~$ ls
fisier.txt
~$ rm fisier.txt
~$ ls
~$ # directorul este gol

Pentru a șterge mai multe fișiere simultan:

~$ rm fisier1.txt fisier2.txt fisier3.txt

Utilizarea caracterului * (wildcard)

Caracterul * poate fi folosit pentru a se potrivi cu orice număr de caractere în numele fișierului sau directorului, facilitând ștergerea mai multor fișiere care îndeplinesc un anumit șablon.

Pentru a șterge toate fișierele .txt din directorul curent:

~$ rm *.txt

rmdir

Comanda rmdir este specializată în ștergerea directoarelor goale. Nu va șterge un director dacă acesta conține fișiere sau alte directoare.

Pentru a șterge un director gol:

~$ ls
director_cu_continut director_gol
~$ rmdir director_cu_continut
rmdir: failed to remove 'director_cu_continut/': Directory not empty
~$ rmdir director_gol
~$ ls
director_cu_continut

rm -r

Opțiunea -r (recursivă) cu comanda rm permite ștergerea directoarelor și a conținutului acestora, inclusiv alte subdirectoare și fișiere.

Pentru a șterge un director și toate fișierele și subdirectoarele sale:

~$ rm -r nume_director

Alte opțiuni și comenzi comune

rm -rf: Combinația -rf este folosită pentru a șterge recursiv și forțat directoare și fișiere.

Opțiunea -f (force) înlătură interogările de confirmare, ceea ce face comanda periculoasă dacă nu este folosită cu atenție.

~$ rm -rf nume_director

rm -i: Opțiunea -i solicită confirmare înainte de a șterge fiecare fișier, ceea ce poate preveni ștergerile accidentale.

~$ rm -i fisier.txt

Copierea, mutarea si redenumirea fisierelor si directoarelor

Comanda cp este folosită pentru a copia fișiere și directoare.

Copierea unui fișier într-un alt fișier:

~$ cp sursa.txt destinatie.txt

Acesta va copia conținutul sursa.txt în destinatie.txt. Dacă destinatie.txt nu există, va fi creat.

Copierea unui fișier într-un director:

~$ cp fisier.txt /calea/directorului/

Copiază fisier.txt în directorul specificat.

Copierea recursivă a unui director:

~$ cp -r director_sursa director_destinatie

Opțiunea -r (recursiv) permite copierea întregului director director_sursa, inclusiv subdirectoarele și fișierele acestuia, în director_destinatie.

Mutarea și redenumirea fișierelor și directoarelor: mv

Comanda mv este folosită atât pentru a muta cât și pentru a redenumi fișiere și directoare.

Mutarea unui fișier:

~$ mv sursa.txt /calea/directorului/

Mută sursa.txt în directorul specificat.

Redenumirea unui fișier:

~$ mv nume_vechi.txt nume_nou.txt

Schimbă numele fișierului nume_vechi.txt în nume_nou.txt. Comanda funcționează similar și pentru directoare.

Alte comenzi și opțiuni comune

Opțiunea -i (interactiv): Atât pentru cp, cât și pentru mv, adăugarea opțiunii -i va solicita confirmare înainte de a suprascrie fișierele existente, prevenind astfel pierderea accidentală a datelor.

~$ cp -i sursa.txt destinatie.txt
~$ mv -i nume_vechi.txt nume_nou.txt

Opțiunea -v (verbose): Această opțiune oferă detalii despre procesul de copiere sau mutare, afișând fișierele pe măsură ce sunt copiate sau mutate.

~$ cp -v sursa.txt destinatie.txt
~$ mv -v nume_vechi.txt nume_nou.txt

Opțiunea -u (update): Cu cp, această opțiune copiază doar atunci când fișierul sursă este mai nou decât fișierul de destinație sau când fișierul de destinație nu există.

~$ cp -u sursa.txt destinatie.txt

Cautarea in structura de fisiere si directoare si in continutul lor

Căutarea în structura de fișiere și directoare: find

Comanda find este extrem de versatilă și permite căutarea fișierelor și directoarelor bazată pe o varietate de criterii, cum ar fi numele, dimensiunea, tipul și data modificării.

Căutarea fișierelor după nume:

~$ find /calea/de/start -name "nume_fisier.txt"

Acest exemplu caută un fișier numit nume_fisier.txt începând cu directorul /calea/de/start și în toate subdirectoarele sale.

Căutarea fișierelor modificate în ultimele 7 zile:

~$ find /calea/de/start -mtime -7

-mtime -7 limitează căutarea la fișierele modificate în ultimele 7 zile.

Căutarea fișierelor cu dimensiunea mai mare de 500MB:

~$ find /calea/de/start -type f -size +500M

Căutarea și execuția unei comenzi pe fișierele găsite:

~$ find /calea/de/start -type f -name "*.txt" -exec grep "text_cautat" {} \;

Aceasta comandă caută toate fișierele .txt și execută grep pentru a căuta un șir de caractere specific în fiecare fișier găsit.

Căutarea în conținutul fișierelor: grep

grep este o comandă folosită pentru a căuta șiruri de caractere sau expresii regulate în conținutul fișierelor.

Căutarea unui text în fișiere:

~$ grep "text_cautat" fisier.txt

Acest exemplu caută șirul "text_cautat" în fisier.txt.

Căutarea recursivă în multiple fișiere:

~$ grep -r "text_cautat" /calea/de/start

Opțiunea -r permite căutarea recursivă în toate fișierele din directorul /calea/de/start și subdirectoarele sale.

Căutarea cu afișarea numărului liniei:

~$ grep -n "text_cautat" fisier.txt

-n afișează numărul liniei unde a fost găsit textul.

Utilizarea locate pentru căutarea rapidă a fișierelor

Comanda locate caută într-o bază de date indexată numele de fișiere și directoare, oferind rezultate rapide pentru căutările pe scară largă.

Căutarea unui fișier în baza de date indexată:

~$ locate nume_fisier

Aceasta comandă va returna toate căile care conțin nume_fisier.

Exemple suplimentare

Căutarea cu find folosind expresii booleene:

~$ find /calea/de/start \( -name "*.txt" -o -name "*.log" \)

Caută fișiere care au extensia .txt sau .log.

Folosirea grep cu expresii regulate:

~$ grep "^[0-9]" fisier.txt

Caută liniile care încep cu o cifră în fisier.txt.

Expresiile regulate (sau regex, de la Regular Expressions) sunt șiruri de caractere care formează un pattern de căutare, folosite pentru a identifica, căuta, și manipula textul bazat pe anumite modele. Acestea sunt extrem de puternice și flexibile, fiind utilizate în programare, procesarea textelor, analiza datelor, și în diverse utilitare de sistem pentru a efectua operații complexe pe texte, cum ar fi căutări, înlocuiri, și validări de format.

Utilizatorii

În Linux, fiecare persoană care accesează sistemul este identificată printr-un utilizator. Fiecare utilizator are un ID unic (User ID sau UID) și poate avea asociate diverse informații, cum ar fi un director home (spațiul său personal de lucru), un shell (interpretorul de comenzi implicit) și alte setări. Există două tipuri principale de utilizatori:

• Utilizatori obișnuiți: Au acces limitat, în principal în propriile directoare home și în zonele sistemului unde au fost acordate explicit drepturi. Acești utilizatori nu pot modifica setările sistemului care afectează alți utilizatori.

• Utilizatorul root: Este utilizatorul administrator cu acces complet la sistem. Root poate modifica orice fișier, rula orice comandă și schimba orice setare. Datorită puterii sale, utilizarea contului root trebuie făcută cu prudență.

Grupuri

Grupurile sunt colecții de utilizatori, care permit administrarea mai ușoară a permisiunilor. Fiecare grup are un ID unic (Group ID sau GID) și poate include mai mulți utilizatori. Linux folosește grupuri pentru a asigna permisiuni care se aplică mai multor utilizatori simultan, făcând mai ușor controlul accesului la fișiere și directoare.

Utilizatorii pot aparține mai multor grupuri, dar au un grup principal (primary group) și pot avea mai multe grupuri secundare (supplementary groups). Când un utilizator creează un fișier nou, grupul principal al utilizatorului este, în mod implicit, asociat cu acel fișier ca grup proprietar.

Comenzi de baza

whoami: Afișează numele utilizatorului curent. Este utilă pentru verificarea rapidă a identității utilizatorului sub care rulați comenzi în terminal.

~$ whoami
stud1016

users: Afișează lista utilizatorilor curent autentificați pe sistem. Această comandă este utilă pentru a vedea cine este logat pe sistem în acel moment.

~$ users
mihaigheorghe stud1016

passwd: Permite schimbarea parolei utilizatorului curent sau a altui utilizator, dacă este executată de root. Este una dintre cele mai importante comenzi de securitate, permițând utilizatorilor să își mențină parolele securizate.

Schimbarea parolei utilizatorului curent:

~$ passwd
password for mihaigheorghe: #silent prompt: nu se vede cursorul cand se tasteaza
New password:
Retype new password:
passwd: password updated successfully

Schimbarea parolei unui alt utilizator (necesită drepturi de root):

~$ sudo passwd nume_utilizator

sudo: Oferă drepturi de administrator (root) pentru rularea comenzi. Este esențială pentru executarea sarcinilor care necesită permisiuni de nivel superior.

~$ sudo comanda

Alte comenzi relevante

id: Afișează ID-ul utilizatorului (UID), grupurile (GID) și alte informații legate de cont. Este utilă pentru a obține detalii despre drepturile unui utilizator.

~$ id
uid=1052(mihaigheorghe) gid=100(users) groups=100(users),27(sudo)

sau:

~$ id
uid=1017(stud1016) gid=30003(students) groups=30003(students),1047(STUDENTI)

useradd: Comandă pentru crearea unui nou utilizator pe sistem.

~$ sudo useradd nume_utilizator

userdel: Șterge un utilizator din sistem, inclusiv directorul său home și poșta, dacă se specifică opțiunile corespunzătoare.

~$ sudo userdel nume_utilizator

groups: Afișează grupurile cărora un utilizator este membru.

~$ groups mihaigheorghe
mihaigheorghe : users sudo
~$ groups stud1016
stud1016 : students STUDENTI

Sistemul de permisiuni

Sistemul de fișiere Linux utilizează permisiuni pentru a controla accesul la fișiere și directoare. Aceste permisiuni sunt definite pentru trei categorii de utilizatori:

• Proprietarul (Owner): Utilizatorul care deține fișierul sau directorul.

• Grupul (Group): Grupul asociat cu fișierul sau directorul.

• Alții (Others): Toți ceilalți utilizatori de pe sistem.

Permisiunile pot fi setate pentru a permite sau restricționa citirea (read), scrierea (write) și executarea (execute) fișierelor sau directoarelor.

În listarea detaliată a fișierelor și directoarelor se pot observa permisiunile elementelor din directorul curent (sau sursă). În exemplul de mai jos, prima coloană reprezintă codificarea (cu ajutorul a 10 caractere) permisiunilor pentru fiecare fișier sau director.

Primul caracter indică dacă avem de a face cu un director (va fi d) sau un fișier (va fi -)

Următoarele 9 caractere reprezintă privilegiile grupate (read, write, execute) pentru proprietar, grup sau alții. În cazul în care, în raport cu un tip de utilizator o permisiune nu este activă, va fi marcata cu -.

~$ ls -la
total 48
drwxr-xr-x 12 root           root           4096 Feb  8 11:21 .
drwxr-xr-x 19 root           root           4096 Jan 19 19:11 ..
-rw-------  1 stud1016       students       3106 Feb 24 18:12 .bash_history
drwx------  2 stud1016       students       4096 Feb 20 14:42 .cache
drwxr-x---  4 cosmin         users          4096 Feb  8 11:39 cosmin
drwxr-x--- 24 daq            users          4096 Feb 18 07:22 daq
drwxr-x---  2 diana          users          4096 Jan 31 21:29 diana
drwxr-x---  8 jupyter-cosmin users          4096 Feb  8 11:49 jupyter-cosmin
drwxr-xr-x 14 jupyter-mihai  users          4096 Feb 26 14:54 jupyter-mihai
drwxr-x---  2 madalina       users          4096 Jan 31 21:30 madalina
-rw-r--r--  1 mihaigheorghe  users             0 Feb 26 17:30 temp.txt

Ex: -rw------- 1 stud1016 students 3106 Feb 24 18:12 .bash_history

Indică faptul ca avem de a face cu un fișier ascuns .bash_history (numele incepe cu .), al cărui owner este utilizatorul stud1016 și are grupul students. În raport cu ownerul există urmatoarele privilegii: citire, scriere dar nu și execuție conform codificării rw-. Utilizatorii din grupul students sau utilizatorii din alte grupuri, alții decât proprietarul nu au niciun privilegiu în raport cu acest fișier.

Considerând că fiecare triadă de privilegii reprezintă un număr codificat binar, pe 3 biți unde un bit are valoarea 1 dacă există permisiune, respectiv 0 dacă nu există permisiune, putem reprezenta concis permisiunile pentru fișierul dat exemplu drept 600.

Prin comparație, directorul cosmin din exemplul de mai sus, are privilegiile 750.

Comanda chmod

Comanda chmod modifică permisiunile fișierelor și directoarelor. Poate fi utilizată atât cu notație simbolică, cât și numerică.

Notatie simbolică: chmod [who][+|-|=][permissions] file

• who: u (user), g (group), o (others), a (all)

• + (adaugă permisiuni), - (elimină permisiuni), = (setează permisiunile exact)

• permissions: r, w, x

Notatie numerică: chmod [mode] file

• mode: Suma valorilor pentru permisiuni (r=4, w=2, x=1) pentru fiecare categorie.

Acordă permisiunea de executie pentru proprietar:

~$ chmod u+x fisier

Setează permisiunile pentru proprietar (citire și scriere), grup (citire) și alții (nicio permisiune):

~$ chmod 640 fisier

Aici, 6 (4+2) înseamnă citire și scriere pentru utilizator, 4 înseamnă citire pentru grup, iar 0 înseamnă nicio permisiune pentru alții.

Acordă tuturor permisiunea de a citi un fișier:

~$ chmod a+r fisier

Elimină permisiunea de scriere pentru grup și alții:

~$ chmod go-w fisier

Alte comenzi

La momentul interogării, pe sop.ase.ro erau disponibile 1540 de comenzi distincte. Deși numărul poate fi intimidand, maturitatea și popularitatea sistemelor Unix / Linux face ca găsirea unei comenzi specifice sau exemple de utilizare să fie foarte facile printr-o simplă căutare pe Internet sau utilizarea de servicii populare de Generative AI precum ChatGPT sau Gemini.

*pentru identificarea numarului de comenzi executabile:

find /bin /usr/bin /sbin /usr/sbin -type f -executable | wc -l

man

Comanda man afișează manualul pentru alte comenzi, oferind detalii despre utilizarea și opțiunile lor.

~$ man ls

Afișează manualul pentru comanda ls.

history

Afișează istoricul comenzilor introduse în terminal.

~$ history | tail
465  cat fisier_cu_text.txt
468  cd
469  ls
470  cd seminar1
471  ls
472  whoami
473  users
474  id
475  groups
476  ls -la
477  history

Afișează ultimele comenzi utilizate.

alias

Creează un pseudonim pentru o comandă, scurtând comenzi lungi sau frecvente.

~$ alias ll='ls -la'

După acest alias, tastați ll pentru a executa ls -la.

pushd

Salvează directorul curent într-un stivă și te mută într-un nou director.

~$ cd usr
~$ pushd /var/www
/var/www /usr

Salvează directorul curent și schimbă directorul la /var/www.

popd

Te întoarce la ultimul director salvat cu pushd.

~$ popd

Te mută înapoi la directorul anterior salvat.

exit

Închide terminalul curent sau sesiunea shell.

~$ exit

Închide sesiunea curentă.

date

Afișează data și ora curentă.

~$ date
Mon Feb 26 18:03:04 EET 2024

Afișează data și ora sistemului.

top

Afișează informații în timp real despre procesele rulând în sistem.

~$ top
top - 18:03:57 up 3 days, 7 min,  2 users,  load average: 0.00, 0.00, 0.00
Tasks: 226 total,   1 running, 225 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  3.1 sy,  0.0 ni, 96.9 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :  15990.0 total,  12898.0 free,    371.8 used,   2720.2 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.  15278.0 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
  27954 stud1016  20   0    8060   4072   3248 R   6.7   0.0   0:00.01 top
      1 root      20   0  166604  12184   8432 S   0.0   0.1   0:08.83 systemd
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.07 kthreadd

Afișează procesele active și utilizarea resurselor.

1. Zona de sumar

Partea superioară a ecranului afișează un sumar al stării sistemului, incluzând:

• Timpul de funcționare: Cât timp a fost sistemul în funcțiune de la ultima repornire.

• Numărul de utilizatori conectați: Câți utilizatori sunt logați în sistem.

• Load average: Media încărcării sistemului pe ultimele 1, 5 și 15 minute. Reflectă numărul de procese care așteaptă activ să fie rulate de CPU sau așteaptă intrarea/scrierea pe disc.

2. Utilizarea CPU

Această secțiune arată procentajul timpului CPU utilizat pentru diferite tipuri de procese:

• us (user space): Timpul petrecut rulând cod în spațiul utilizator.

• sy (system): Timpul petrecut rulând cod în kernel (spațiul de sistem).

• ni (nice): Timpul petrecut rulând procese cu prioritate modificată.

• id (idle): Timpul CPU inactiv.

• wa (I/O wait): Timpul petrecut așteptând intrări/ieșiri.

• hi (hardware IRQ): Timpul petrecut de către CPU în tratarea întreruperilor hardware.

• si (software interrupts): Timpul petrecut de către CPU în tratarea întreruperilor software.

• st (steal time): Timpul "furat" de alte sisteme de operare într-un mediu virtualizat.

3. Utilizarea memoriei

Informații despre memoria sistemului, inclusiv:

• Mem: Memoria fizică totală, utilizată, liberă, în cache.

• Swap: Spațiul de swap total, utilizat și liber.

4. Procesele

Lista proceselor care rulează, cu detalii pentru fiecare, precum:

• PID: Numărul de identificare al procesului.

• USER: Utilizatorul care a pornit procesul.

• PR: Prioritatea procesului.

• NI: Valoarea nice, care influențează prioritatea procesului.

• VIRT: Memoria virtuală totală utilizată de proces.

• RES: Memoria rezidentă, cât de multă memorie fizică folosește procesul.

• SHR: Memoria partajată cu alte procese.

• S: Starea procesului (de exemplu, S pentru sleeping, R pentru running).

• %CPU: Procentajul de utilizare a CPU de către proces.

• %MEM: Procentajul de memorie utilizat de proces din totalul memoriei fizice.

• TIME+: Timpul total de CPU utilizat de proces de când a fost pornit.

• COMMAND: Comanda care a lansat procesul.

kill

Termină procesele specificate prin PID (Process ID).

~$ kill 1234

Termină procesul cu PID-ul 1234.

sed

sed (Stream Editor) este utilizat pentru a procesa text bazat pe anumite reguli.

~$ sed 's/vechi/nou/g' fisier.txt #se va reveni intr-un context mai detaliat

Înlocuiește toate instanțele cuvântului "vechi" cu "nou" în fisier.txt.

sort

Ordonează liniile dintr-un fișier text.

cat > fisier.txt
-4
100
2
8
salut
101
3000
hello

~$ sort fisier.txt
-4
100
101
2
3000
8
hello
salut

~$ sort -n temp.txt
-4
hello
salut
2
8
100
101
3000

Ordonează alfabetic liniile din fisier.txt. Opțiunea n presupune ordonarea matematică.

du

Afișează utilizarea spațiului pe disc de către fișierele și directoarele specificate.

~$ du -sh /var/www
20K     /var/www

Afișează dimensiunea totală a directorului /var/www.

df

Raportează utilizarea spațiului pe disc al sistemelor de fișiere.

~$ df -h
Filesystem                         Size  Used Avail Use% Mounted on
tmpfs                              1.6G  1.3M  1.6G   1% /run
/dev/mapper/ubuntu--vg-ubuntu--lv   88G   25G   60G  29% /
tmpfs                              7.9G     0  7.9G   0% /dev/shm
tmpfs                              5.0M     0  5.0M   0% /run/lock
/dev/sda2                          974M  252M  655M  28% /boot
tmpfs                              1.6G  4.0K  1.6G   1% /run/user/1017
tmpfs                              1.6G  4.0K  1.6G   1% /run/user/1052

Afișează utilizarea spațiului pe disc într-un format ușor de citit (opțiunea h indică afișarea într-un format human-readable).

chown

1. Schimbarea proprietarului unui fișier: Pentru a schimba proprietarul fișierului document.txt în utilizatorul marius, comanda este:

   ~$ sudo chown marius document.txt

   Această comandă va face pe marius noul proprietar al fișierului document.txt.

2. Schimbarea proprietarului și grupului unui fișier: Dacă doriți să schimbați atât proprietarul, cât și grupul pentru fișierul raport.pdf în marius și grupul editors, respectiv, utilizați:

   ~$ sudo chown marius:editors raport.pdf

   Acest lucru va atribui utilizatorul marius ca proprietar și editors ca grup al fișierului raport.pdf.

3. Schimbarea proprietarului unui director și a conținutului său: Pentru a schimba proprietarul directorului Proiecte și a tuturor fișierelor și subdirectoarelor din interiorul său în utilizatorul ana, folosiți opțiunea -R (recursive):

   ~$ sudo chown -R ana Proiecte/

   Aceasta va face pe ana proprietarul directorului Proiecte, precum și al tuturor elementelor conținute.

4. Schimbarea grupului unui fișier fără a modifica proprietarul: Dacă doriți doar să schimbați grupul unui fișier, lăsând proprietarul neschimbat, folosiți : înainte de numele grupului, fără a specifica un nume de utilizator:

   ~$ sudo chown :nougrup fisier.txt

Comenzi funny

cowsay

cowsay este o comandă care generează un ASCII art al unei vaci care "spune" textul furnizat ca argument.

~$ cowsay "Hello, world!"

Output-ul va fi ceva de genul:

 _____________
< Hello, world! >
 -------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

cowthink

Similar cu cowsay, dar generează o vacă care "gândește" textul, nu îl spune.

~$ cowthink "Ce zi frumoasa!"

Output-ul ar arăta similar, dar cu "bule" de gândire în loc de dialog.

sl

Comanda sl (Steam Locomotive) afișează o locomotivă în mișcare prin terminal.

~$ sl

Nu există parametri pentru personalizare; pur și simplu rulează comanda și bucură-te de trenul care trece prin terminalul tău.

fortune

fortune afișează citate aleatoare, zicale, glume sau proverbe.

~$ fortune
Your mode of life will be changed for the better because of new developments.

Output-ul este un text scurt, adesea amuzant sau înțelept.

figlet

figlet generează text mare în ASCII art, folosind caractere standard.

~$ figlet Salut
  mmmm         ""#             m
 #"   "  mmm     #    m   m  mm#mm
 "#mmm  "   #    #    #   #    #
     "# m"""#    #    #   #    #
 "mmm#" "mm"#    "mm  "mm"#    "mm

~$

Acesta va afișa cuvântul "Salut" într-un font mare, ASCII.

toilet

Similar cu figlet, dar oferă mai multe opțiuni de personalizare, cum ar fi fonturi și culori.

~$ toilet -f bigmono9 -F gay "Salut"

Aceasta comandă va afișa "Salut" într-un font mare și cu culori curcubeu.

cmatrix

cmatrix afișează o simulare a efectului Matrix în terminal, cu caractere care cad în mod aleatoriu.

~$ cmatrix

Pentru a opri, pur și simplu apasă CTRL+C.

echo "tulaS" | rev

Această comandă utilizează echo pentru a afișa un text, iar rev inversează textul.

~$ echo "tulaS" | rev

Output-ul va fi "Salut", deoarece rev inversează ordinea caracterelor.

Controlul executiei comenzilor

În terminalul Linux, semnele ;, &&, și || sunt utilizate pentru a controla execuția secvențială a mai multor comenzi. Fiecare dintre aceste semne are un scop și o utilizare specifică:

; (Punct și virgulă)

Punctul și virgula ; este folosit pentru a separa comenzi, permițându-le să fie executate succesiv, indiferent de rezultatul executării anterioare. Adică, a doua comandă va fi executată după finalizarea primei comenzi, chiar dacă prima comandă eșuează.

~$ echo "Prima comanda"; ls /un_director_inexistent

Acest exemplu va afișa mesajul "Prima comanda", apoi va încerca să listeze conținutul unui director care nu există, generând un mesaj de eroare.

&& (ȘI logic)

Operatorul && este folosit pentru a executa a doua comandă doar dacă prima comandă se execută cu succes (adică se termină cu statusul de ieșire 0, care indică succesul).

~$ mkdir nou_director && cd nou_director

Aici, comanda cd nou_director va fi executată numai dacă mkdir nou_director reușește să creeze directorul.

|| (SAU logic)

Operatorul || este folosit pentru a executa a doua comandă doar dacă prima comandă eșuează (adică se termină cu un status de ieșire diferit de 0).

~$ cd /un_director_inexistent || echo "Directorul nu există."

În acest caz, mesajul "Directorul nu există." va fi afișat doar dacă încercarea de a schimba directorul în /un_director_inexistent eșuează.

Utilizare combinată

Aceste semne pot fi, de asemenea, combinate pentru a crea lanțuri logice complexe de comenzi.

Exemplu combinat:

~$ cd /un_director && echo "Director schimbat cu succes!" || echo "Eroare la schimbarea directorului."

Acest exemplu încearcă să schimbe directorul. Dacă operația reușește, va afișa "Director schimbat cu succes!". Dacă schimbarea directorului eșuează, va afișa "Eroare la schimbarea directorului."