Bazele programării bash

 

Bazele programării bash
1.Crearea de scripturi.
Un script este un fișier text executabil.
a)Pentru crearea unui fișier de tip text poate fi folosit un editor de text : vi,nano, mcedit, gedit
exemplu gedit script10.sh
Observație este indicat să se folosească extensia sh pentru scripturi dar nu este obligatoriu, se va executa și un script aflat în fișierul script10.txt
b)pentru a fi interpretat ca un script bash prima linie trebuie să conțină #!/bin/bash
c)Spațiile din text sunt interpretate diferit în funcție de context, se recomandă scrierea comenzilor pe linii separate.
Conținutul fișierului va avea următoarea formă:
#!/bin/bash
echo 'first try'
S-a folosit comanda echo ce are ca efect afișarea la ieșirea standard.
Acest script va afișa pe ecran terminal mesajul first try.
2.Dreptul de execuția pentru scripturi.
Pentru a rula un fișier bash comanda este bash fișier.sh .De asemenea poate fi lansat în execuție cu comanda ./fișier.sh. În acest caz fișierul trebuie să aibă drept de execuție.Un fișier text nu este în mod normal un fișier executabil.
Drepturile de acces în Unix sunt clare și simple.Sunt trei drepturi:citire(r), scriere(w) și execuție(x) și sunt trei categorii de utilizatori: proprietar(deținător)-owner(u), grupul din care face parte deținătorul-group(g) și alții(alți utilizatori ce nu sunt cuprinși in primele 2 categorii)-others(o). 
 
Pentru a modifica drepturile de acces ale unui fișier se poate folosi și (a) pentru toate cele trei categorii u,g și o.Pentru schimbare drepturi de acces se folosește comanda chmod. Sintaxa comenzii este chmod [opţiuni] permisiuni ţintă Opţiunile pot fi: -R, permisiunile vor fi setate recursiv -f, mod forţat -v, mod „verbose” (cu afişare pentru fiecare fişier procesat) -c, se afişează informaţii numai în cazul în care sunt efectuate schimbări asupra fişierului ţintă  
 
Permisiunile pot fi: Permisiuni în format octal Permisiuni în format text Permisiunile pot fi scrise în mod text intuitiv astfel:[grup_permisiuni][operaţie][permisiuni] grup_permisiuni reprezintă grupul de permisiuni asupra căruia se va efectua modificarea şi poate lua următoarele valori: „u” – pentru grupul „owner” „g” – pentru grupul „group” „o” – pentru grupul „others” „a” – pentru toate grupurile de mai sus operaţie reprezintă modul în care va fi efectuată schimbarea: „=” - atribuie în mod direct „-” - înlătură permisiunile specificate „+” - adaugă permisiunile specificate permisiuni reprezintă drepturile efective ce urmează a fi schimbate: „r” - permisiune de citire „w” - permisiune de scriere „x” - permisiune de execuţie „t” - setează bitul „sticky” „s” - setează SUID sau SGID  
 
Exemplu: Comanda „chmod u+rw,go+r script10.sh” va seta permisiunile de citire şi de scriere pentru grupul „owner” şi permisiunea de citire pentru grupul „others”şi „group”. Permisiunile pot fi scrise în mod octal rapid astfel:o-rwx 111=7,g-r x 101=5, o-r x 101=5, notându-se cu 1 existența permisiunii și cu 0 lipsa permisiunii pentru fiecare grup, iar numarul binar obținut este transformat în octal.Comanda în mod text are o exprimare laborioasă pentru un control strict al permisiunilor și de aceea este mai mult folosită comanda în format octal.Astfel pentru a se obține permisiunile (o-rwx, g-r x, o-r x) este și simplu și eficient să folosim comanda chmod 755 script10.sh
 
3.Execuția scripturilor.
Dupa salvarea fișierului putem rula scriptul cu urmatoarea comanda:
# ./script10.sh
Acest script va afișa pe ecran terminal mesajul first try. Pentru scripturi scrise in shell scripting este recomandat sa se foloseasca extensia .sh pentru a fi mai usor recunoscute.

Pentru execuția scripturilor aflate în alt director decât cel curent se va scrie calea întreagă pornind de la rădăcină
/home/used/script10.sh
Se observă că în acest caz dispare referința relativă '.' , folosindu-se referința absolută (fără punct)

Exercițiu. Scrieți următorul script:
#!/bin/bash
clear
echo 'Afișare calendar'
cal 
 
S-a folosit comanda clear ce determină ștergerea display terminal și comanda  
cal ce determină afișarea zilei curente ofolosind un calendar de tip lună.
4.Programarea execuției scripturilor
Crontab-ul se utilizează pentru execuția de proceduri automate .
Un fișier crontab conține instrucțiuni pentru bcron-sched daemon interpretate astfel : ”rulează această comandă la timpul și data specificată”. Acest serviciu este accesibil fiecărui utilizator și comenzile vor fi executate conform drepturilor de acces specifice.
O scurtă descriere
-execută comenzi în mod programat, la anumite momente de timp
-rulează la fiecare minut, verificând în mod normal conținutul directoarelor:
cron.d – scripturi speciale cron
cron.hourly – scripturi care vor fi executate din ora in ora
cron.daily – scripturi care vor fi executate zilnic
cron.weekly – scripturi care vor fi executate saptamanal
cron.monthly – scripturi care vor fi executate lunar
-se execută scripturile aflate în aceste directoare
-fișierul de configurare: /etc/crontab
-dacă variabila de mediu MAILTO este definită și nu este vidă, va putea fi trimis un e-mail conținând ieșirea standard a tuturor scripturilor executate
-actiunile executate de cron sunt jurnalizate in general in /var/log/cron

Formatul fișierului crontab:
Conține interpretorul sh și căile cunoscute din sistem

SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
Pe acest rând avem specificațiile fiecărei acțiuni programate

# m h dom mon dow user command

m-minut, putand lua valori intre 0 si 59
h-ora, putand lua valori intre 0 si 23
dom-zi din luna, putand lua valori intre 1 si 31
mon-luna, putand lua valori intre 1 si 12 sau nume de lună
dow-zi din saptamana, intre 0 si 7 (0 = duminică) sau nume de zile
Alte valori posibile
-“*” = orice valoare
-sunt permise intervalele de numere ”-”), liste de valori sau
intervale (separate prin virgulă) exemplu 1,3,7-20
-este permisă și o rată a valorilor (“/”) Intervalul "1-9/2" este același cu "1,3,5,7,9" și este diferit de ”1,2,3,4”.
-sunt separate prin spațiu
Câmpurile următoare conțin
-utilizator – utilizatorul sub care vor fi executate scripturile
-script – locația și numele scriptului care va fi executat

Utilizatorii își pot defini propriile fișiere crontab, localizate in
/var/cron/tabs/nume_utilizator . Utilizatorii care pot utiliza acest serviciu pot fi limitați prin intermediul /etc/cron.allow si cron.deny . Pot fi folosite si serviciile anacron si at

Exemplu
Avem următorul script

#!/bin/bash
echo "Useri logati sunt "
who>>stare.txt

Comanda who afișează lista utilizatorilor logați, terminalul pe care sunt logați, data și ora conectării. Operatorul >> redirecționează rezultatul comenzii who în fișierul stare.txt, și permite adăugarea rezultatului comenzii la sfârșitul fișierului (nu suprascrie conținutul fișierului).
Vom salva acest script în directorul /home/used cu denumirea script.sh
Pentru a fi programat dintr-un terminal rulăm comanda crontab -e. Va apărea o fereastră de selecție a editorului text (vi,nano,mcedit) și apoi se face programarea executării scriptului completând câmpurile din text. Salvarea fișierului se face în directorul indicat de editor. Crontab va prelua sarcina și va efectua programarea scriptului.
Pentru vizualizare cron-uri utilizator comanda este crontab -l. Pentru ștergerea cron-uri utilizator crontab -r.
Notă: Fișierul crontab poate fi salvat direct în folderele cron în cazul utilizatorului root. În acest caz, deși execuția se desfășoară conform planificării, crontab -l nu va vizualiza sarcina.
Shell-script pot fi asociate și altor procese.

5.Variabilele in Shell
In shell scripting există doua tipuri de variabile:
a)Variabilele sistemului, acestea sunt create si mentinute de catre linux, si sunt scrise cu majuscule;
b)Variabilele definite de catre utilizator, acestea sunt scrise cu litere mici.

Pentru a vizualiza valorile unor anumite variabile se da comanda echo referință variabilă.
Operatorul referință $ apelează valoarea stocată în variabila respectivă, de exemplu:
# echo $USER va afișa numele utilizator și nu $USER
# echo $HOME va afișa locația curentă (/home/used) și nu $HOME
Definire variabile
Sintaxa
nume_variabilă=valoare
Exemplu
# a=10
La definire varabilă nu trebuie lăsat spațiu în stânga sau dreapta semnului = .
În caz contrar se produc erori.
Salvați și executați urmatorul script care vă va familiariza cu modul de definire a variabilelor.
#!/bin/bash
clear
a=10
echo $a
Reguli în definirea variabilelor (atât cele ale sistemului cât și cele definite de utilizator)
-Variabilele pot fi formate din cel putin un caracter alfanumeric sau pot începe cu / conține un caracter "underscore" (_) urmat de cel putin un caracter alfanumeric.În shell scripting se face diferență între litere mari și mici. Astfel nr și Nr sunt două variabile distincte.
Comanda echo este folosita pentru a afisa pe ecran text sau valori ale unor variabile.
Sintaxa generală a comenzii este:
#echo [opțiuni] [șir de caractere, variabile...]
Opțiunile folosite sunt următoarele:
-e activează interpretarea caracterului backslash în șirul de caractere care urmează ( O\'Neily va fi interpretat ca O'Neily)
-E dezactivează interpretarea acestuia (O\'Neily va fi interpretat ca O'\Neily,
Dacă tagul -e este selectat sunt valide următoarele opțiuni în interiorul expresiei:
\\ afișează caracterul backslash în sine )
\a efectueaza o avertizare sonoră
\b are efectul apăsării tastei backspace de pe tastatură, șterge ultimul caracter afișat
\c șterge șirul de caractere care urmează acestei comenzi, va fi afișat doar ceea ce este în fața lui "\c"
\n face trecerea la o linie noua
\r are efectul apăsării tastei enter
\t afisează caracterul tab (salt cursor în cadrul aceleași linii cu un număr finit de caractere) -tab orizontal
\v -tab vertical

6.Operatii cu variabile.
Asupra variabilelor se pot efectua operații aritmetice (folosind operatori matematici) și operații logice (folosind operatori logici)

Operatorii matematici uzuali:
+ adunarea
- scăderea
/ împărțirea
% restul împărțirii( modulo)
*înmultirea

Pentru a evalua o expresie se folosesc parantezele mari sub următoarea sintaxă:
[ expresie ]
Returnează starea 0 ("true") sau 1 ("false") în funcție de evaluarea expresiei condiționale "expr". Expresiile pot să fie unare sau binare.
Operatori aritmetici folosiți în evaluarea expresiilor:
-eq (este egal cu)
-ne (nu este egal cu)
-lt (mai mic decat)
-le (mai mic sau egal decat)
-gt (mai mare decat)
-ge (mai mare sau egal decat)

7.Evaluarea aritmetică
Expandarea aritmetica permite evaluarea unei expresii aritmetice și substituirea ei cu rezultatul. Există două formate pentru expandarea aritmetica: a) $[expresie] b) $((expresie))
Expresia e tratată ca și cum ar fi între ghilimele înclinate, dar o ghilimea aflată între paranteze nu va fi tratată special. Toate elementele din expresie suportă expandarea de parametri, substituirea de comenzi și înlăturarea semnelor de citare. Substituirile aritmetice pot fi cuprinse unele în altele.
Exemplu:
f=2
echo $[f+2] afișează 4
Dacă expresia este invalidă, bash-ul scrie un mesaj indicând eșecul și nu are loc nici o substituire. Shell-ul permite evaluarea expresiilor aritmetice. Evaluarea se face în întregi lungi, fără verificarea depășirii, deși împărțirea prin zero este sesizată și semnalată ca eroare.
Un caz particular de evaluare îl constituie comanda let a cărei sintaxă este:
let arg [arg ...]
Fiecare "arg" este o expresie aritmetica, ce trebuie evaluată. Dacă ultimul "arg" este evaluat ca fiind 0, comanda "let" întoarce 1 la ieșire; altfel, întoarce 0. Exemplu
f=2
let f-2
echo $?
Se afișează 1
În acest exemplu s-a folosit operandul $? care este Exit Status - Starea de exit. Exit status are 2 valori care sunt folosite pentru a vedea dacă comanda sau scriptul au fost executate corect sau nu. Dacă valoarea returnata este 0 atunci comanda a fost executata cu succes iar dacă valoarea returnata este diferita de 0 atunci a apărut o eroare în executarea comenzii sau a scriptului. Pentru a avea valoarea stării de exit, se folosește variabila speciala $?.
8.Prioritatea operatorilor
Următorii operatori sunt grupați pe nivele de prioritate egală.
Nivelele sunt listate în ordinea descrescătoare a priorității.
1- + minus și plus unar
2! ~ negație logică și la nivel de bit
3* / % înmulțire, împărțire, rest
4+ - adunare, scădere
5<< >> deplasare bit cu bit, la stânga și la dreapta
6<= >= < > comparație
7== != egalitate și inegalitate
8& AND (ȘI) bit cu bit
9^ XOR (SAU EXCLUSIV) bit cu bit
10| OR (SAU) bit cu bit
11&& AND (ȘI) logic
12|| OR (SAU) logic
13= *= /= %= += -= <<= >>= &= ^= |= atribuire
Se observă diferența între operatorii folosiți la evaluarea logică și cei folosiți la evaluarea aritmetică.
Acești operatori au o formă binară, pentru evaluarea unei expresii se folosesc paranteze mari ceea ce indică că urmează o expresie. Returnează valoarea "true" dacă relația dintre "argumentul1" și "argumentul2" este cea verificată de operatorul matematic. Expresiile pot să fie unare sau binare. Expresiile unare sunt folosite la evaluarea string-urilor sau fișierelor.

9.Evaluarea string-urilor și a fișierelor
Pentru stringuri (șiruri de caractere ) se definesc operatorii proprii.
Operatori pentru stringuri:
Operatori binari
stringul1 = stringul2 ("True" dacă stringul1 este egal cu stringul2)
stringul1 != stringul2 ("True" dacă stringul1 nu este egal cu stringul 2)
Operatori unari
stringul1 ("True" dacă stringul1 este nenul sau nedefinit)
-n stringul1 ("True" dacă stringul1 este nenul și există)
-z stringul1 ("True" dacă stringul1 este nul și există)

Pentru fișiere și directoare se definesc operatorii proprii.
Operatori unari
-b fișier "True" dacă "fișier" există și este tip bloc special.
-c fișier "True" dacă "fișier" există și e tip caracter special.
-d fișier "True" dacă "fișier" există și este un director.
-e fișier "True" dacă "fișier" există.
-f fișier "True" dacă "fișier" există și e un fișier obisnuit.
-g fișier "True" dacă "fișier" există și are setat bitul de "set-group-id".
-k fișier "True" dacă "fișier" are setat bitul "sticky".
-L fișier "True" dacă "fișier" există și este un link simbolic.
-p fișier "True" dacă "fișier" exists și este un "pipe" denumit.
-r fișier "True" dacă "fișier" există și poate fi citit.
-s fișier "True" dacă "fișier" există și are lungimea mai mare ca zero.
-S fișier "True" dacă "fișier" există și este un "socket".
-t fd "True" dacă fd este deschis pe un terminal.
-u fișier "True" dacă "fișier" există și are setat bitul de "set-user-id".
-w fișier "True" dacă "fișier" există și poate fi scris.
-x fișier "True" dacă "fișier" există și este executabil.
-O fișier "True" dacă "fișier" există și apartine de UID efectiv.
-G fișier "True" dacă "fișier" există și apartine de GID efectiv.

Operatori binari pentru fișiere
fișier1 -nt fișier2 "True" dacă "fișier1" e mai nou decât "fișier2" (după data ultimei modificări).
fișier1 -ot fișier2 "True" daca "fișier1" e mai vechi decât "fișier2".
fișier1 -ef fișier2 "True" dacă "fișier1" și "fișier2" au același număr de device și de inod.

Asupra operatorilor unari și binari se pot aplica operatorii logici.
Operatorii logici sunt:
! expresie (logic NOT)
expresie1 -a expresie2 (logic AND)
expresie1 -o expresie2 (logic OR)

Exemplu de operație logică
[ $num1 -gt 14 -a $num2 -eq 1 ]
Notă: Se observă apariția parantezelor mari [] ce definesc expresia de evaluat și foarte important spațiile delimitează atât operatorii cât și operanzii.

10.Utilizarea ghilimelelor
În programarea de tip shell bash există trei tipuri de ghilimele:
"ghilimele duble" - tot ceea ce se află între glilimele duble este considerat doar o înșiruire de caractere, cu excepția caracterelor \ și $.
Exemplu #echo -e "4 +\n5" -afișează 4 + și 5 pe următoarea linie.
'ghilimele simple' – nu va prelucra caracterul $
Exemplu
n=3
#echo -e '4 + $n\n5' va afișa 4+$n pe o linie și 5 pe linia următoare.
`ghilimele inclinate` - sunt folosite pentru a executa comanda aflată între acestea. Trebuie menționat că întotdeauna folosirea ghilimelelor înclinate are ca efect execuția comenzii shell care se află între acestea și folosirea în script a rezultatului obținut prin executarea comenzii respective.
Exemple:
#echo "Astazi este `date`"
Se observă că este afișată data de astazi.

11.Instrucțiunea de citire (read)
Aceasta instrucțiune este folosită pentru preluarea datelor de la un utilizator prin intermediul tastaturii și memorarea datelor în variabile.
Sintaxa
read variabila1, variabila2,... variabilaN
Exemplu: Următorul script îi cere utilizatorului numele și apoi așteaptă introducerea acestuia de la tastatură. Utilizatorul introduce numele la tastatură (după scrierea numelui trebuie apasată tasta ENTER) și numele introdus prin intermediul tastaturii este memorat în variabila fuser și apoi afișează calendarul lunii curente.
#gedit script.sh
#
#script pentru citire de la tastatura
#
echo "Numele dumneavoastra va rog:"
read fuser
echo "Buna $fuser, calendarul lunii `cal`"

12.Meta caracterele (folosite pentru specificarea globala a numelui unui fișier)
Meta caracterul:
* - înlocuiește orice caracter sau grup de caractere
? - înlocuiește un singur caracter
[...] - înlocuiește doar cu caracterele aflate între paranteze
Exemple

#ls /bin/[a-e]*
va afișa toate fișierele și directoarele din directorul /bin care încep cu litera a, b, c, d sau e.
#ls /bin/[!a-f]* sau #ls /bin/[^a-f]*
va afișa toate fișierele și directoarele din directorul /bin cu excepția celor care încep cu un caracter aflat în seria menționată.

13.Redirectarea intrărilor și ieșirilor standard
În cea mai mare parte comenzile au ieșirile spre monitor iar intrările sunt luate de la tastatură, dar în Linux, ca și în alte sisteme de operare, se pot trimite intrările/ ieșirile către fișiere.
Exemplu:
#ls
comanda de mai sus afișează rezultatul pe monitor. Pentru redirecționarea rezultatului într-un fișier va fi folosită comanda:
#ls > numele_fișierului
Există trei mari simboluri de redirectare:
>, >> si <
Simbolul ">"
Sintaxa:
#comanda_linux > numele_fișierului
Rezultatul rulării comenzii respective va fi trimis către fișier. Trebuie menționat faptul că dacă fișierul în care este trimis rezultatul nu există, atunci acesta este creat iar dacă există, conținutul acestuia va fi înlocuit.
Simbolul ">>"
Sintaxa:
#comanda_linux >> nume_fișier
Dacă fișierul nu există atunci el este creat iar dacă există, conținutul rezultat în urma rulării comenzii va fi pus la sfârșitul fișierului fără a se pierde nimic din informația conținută inițial în fișier.
Simbolul "<"
Sintaxa:
#comanda_linux < nume_fișier
Acest simbol este folosit pentru preluarea informațiilor necesare rulării comenzii nu din tastatură ci din fișierul respectiv.
Exemplu:
#cat < nume_fișier
De asemenea pot fi folosite mai multe simboluri de redirectare în aceeași linie de comandă, la fel ca în exemplul urmator:
#cat > lista
ubuntu
linux
mint
debian
#sort < lista > lista_sortata
#cat lista_sortata
debian
linux
mint
ubuntu
În exemplul anterior comanda sort a preluat datele de intrare din fișierul lista iar rezultatul a fost redirectat către fișierul lista_sortata. În acest mod de lucru fișierul sursă trebuie să fie diferit de fișierul destinație pentru a evita pierderea conținutului fișierului.

14.Organizarea fișierelor
Sistemul de fişiere este o metodă de organizare, stocare şi accesare a datelor informatice prezente pe un sistem de calcul. Sistemul de fişiere Linux este diferit faţă de sistemele de fişiere utilizate de alte sisteme de operare. La un sistem de tip UNIX, orice entitate care nu este un fişier, este un proces. Pe lângă fișierele tradiționale cu text, imagini,video etc deosebim și excepții de la regula nu e fișier e proces:
- Directoarele (d) sunt fişiere ce conţin o listă a numelor fişierelor conţinute de directorul în cauză.
- Fişiere speciale (c) sunt în general folosite pentru INPUT (introducere de date) sau OUTPUT (extragere de date). Aceste fişiere reprezintă „devices” (sau dispozitive) şi se găsesc în general în directorul „/dev”
- Fişiere SOCKET (s) reprezintă fişiere speciale folosite pentru comunicarea inter-procese printr-un mediu de reţea. Aceste fişiere sunt folosite pentru comunicaţii între diferite calculatoare sau reţele de calculatoare.
- Fişiere PIPE (p) sunt un fel de fişiere SOCKET cu rolul de a facilita comunicarea între procesele în desfăşurare.
- Legăturile (l) sunt folosite pentru a crea o legătură între un director sau un fişier astfel încât acesta să fie vizibil şi din alte locaţii.
În lista de mai sus, se observă că fiecare tip de fişiere are o literă delimitată de paranteze. Aceasta reprezintă prescurtarea tipului respectiv de fişier, şi poate fi observat în prima literă a şirului de permisiuni afişat prin comanda
„ls -l nume_fișier”.
Uzual utilizatorii recepționează organizarea datelor sub forma unei structuri arborescente ce pleacă din rădăcină (în Unix „/”). În realitate fiecărui fişier îi corespunde un identificator numeric numit inode, identificator care va conţine informaţii despre conţinutul, proprietarul şi locaţia fişierului pe disc. O tabelă de inode-uri se crează la instalarea sistemului de operare pe fiecare partiție .
Când un fişier este creat, acestuia i se atribuie un inode marcat ca fiind liber. Identificatorul în cauză va primi următoarele informaţii: proprietar, tipul de fişier, permisiuni, ora şi data la care fişierul a fost creat, ora şi data ultimei modificări al inode-ului curent, numărul de legături la fişierul respectiv, o adresă fizică pe disc şi dimensiunea fişierului. Pentru a afișa inode-ul unui fişier, se folosește comanda ls cu parametrul -i. Este de remarcat faptul că numele fișierului și al directorului nu sunt conținute în inode ca și faptul că fiecare partiţie are propriul său set de inode-uri .

15.Operații cu fișiere și foldere
Pentru ca un program să ruleze fără specificarea căii de acces locația sa trebuie conținută in variabila sistem $PATH. Se poate modifica temporar conținutul variabilei $PATH cu comanda
export $PATH=$PATH:/cale_acces_nouă
Pentru schimbări permanente asupra setărilor de acest fel, trebuie modificate
fişierele de configurare ale aplicaţiei shell. Accesarea unui fișier se face folosind fie o cale relativă fie o cale absolută. Calea relativă reprezintă o porțiune din structura ierarhică a sistemului de fişiere și are ca referință calea curentă (afișare cu comanda pwd) şi va varia în funcţie de directorul curent, pe când o cale absolută va reprezenta mereu aceeaşi locaţie, şi va avea ca punct de referinţă directorul rădăcină. O cale absolută va începe mereu cu caracterul „/” reprezentând directorul de referinţă.
Crearea directoarelor se face cu comanda mkdir urmată de numele
directorului ce urmează a fi creat. Pentru schimbarea directorului curent se
va folosi comanda cd urmat de adresa directorului ce urmează a fi schimbat.
Copierea fişierelor și a directorelor se face folosind utilitarul cp astfel cp [-R] sursa destinaţie – parametrul R este opţional şi va avea ca efect copierea completă cu tot cu subdirectoare. Prin sursă definim fişierul sau directorul sursă respectiv , iar prin destinație definim fişierul sau directorul destinaţie.
Mutarea fişierelor și a directoarelor se face folosind comanda mv, folosită şi pentru redenumirea fişierelor. Comandă va primi doi parametri, primul fiind fişierul/folderul ce trebuie mutat (cunoscut şi drept sursă) iar al doilea fiind destinaţia. În cazul în care sursă şi destinaţia se referă la acelaşi director, fişierul/folderul sursă va fi redenumit în fişierul/folderul destinaţie.
Comanda mv /tmp/mov /home/used va avea ca efect mutarea folderului mov în directorul /home/used cu tot cu fișierele și folderele conținute
Ştergerea fişierelor sau a directoarelor se face folosind comanda
rm [-R] țintă. Comanda nu poate să şteargă implicit decât un singur fişier, însă, folosind parametrul -r (ştergere recursivă), instrucţiunea poate să şteargă întregi ierarhii de directoare. Pentru a şterge un director se poate folosi şi comanda rmdir, însă acesta trebuie să fie gol.
Pentru localizarea unui fișier se folosesc, în principal, comnzile:
- comanda which [-a] este folosită pentru căutarea unui program folosind $PATH. Aceasta caută în lista de directoare inclusă, fişierul executabil primit ca parametru şi va returna locaţia/locațiile fişierului căutat, în cazul în care acesta există. Parametrul opţional -a va lista toate locațiile în care programul a fost găsit.Nu va returna rezultat dacă va găsi doar legături simbolice (l) .
Prin legătura se înțelege un mecanism de legare a două sau mai multe fişiere la o singură resursă fixă (alt fişier). Există două tipuri de legături (sau link-uri):
Hard link – reprezintă un mecanism de asociere a două sau mai multor fişiere cu acelaşi inode. Rezultatul imediat va fi că două sau mai multe fişiere diferite vor fi legate la acelaşi inode. Ca urmare a acestui fapt, acest tip de legături nu pot fi pe partiţii diferite, din moment ce inode-urile sunt unice pentru fiecare partiţie.
Soft link – mai este cunoscut şi drept symbolic link, şi nu este altceva decât un fişier care arătă spre un alt fişier, conţinând informaţii despre numele, calea şi locaţia fizică a fişierului spre care arată şi, drept urmare, pot aparține unor partiţii diferite.
Crearea link-urilor se face foarte simplu, utilizând comanda ln:
ln -s /home/used/b /home/used/lk sau ln -P /home/used/b /home/used/lk (implicit )
Apelarea funcţiei ln va avea ca rezultat crearea unei conexiuni către fişierul „b” numită „lk”. Tipul de legătură este soft link, atestat prin prezenţa parametrului -s, caz în care opțiunile -P sau -L devin invalide . În cazul în care nu se doreşte crearea unei legături de tip soft, ci din contră se doreşte crearea unei legături hard link, atunci trebuie folosit parametrul -P sau -L.
-comanda find este un utilitar folosit pentru căutarea unor fişiere în cadrul structurii de directoare, utilizatorul putând să descrie un set de filtre pentru limitarea numărului de rezultate găsite. În cazul comenzii find se pot folosi metacaracterele. Filtrele permit căutarea după conţinutul fişierelor, data creării, modificării, dimensiunea lor, etc.De asemenea se pot urmări legăturile simbolice.

16.Utilizarea PIPE |
Se poate conecta ieșirea unei comenzi de intrarea unei alte comenzi fără folosirea unui fișier temporar.
Această metodă poate fi folosită pentru rularea a două sau mai multe comenzi în aceeași linie de comandă.
Sintaxa
#comanda1 | comanda2
Exemple:
#who | sort
Această comandă va returna o listă a utilizatorilor logați pe mașina respectivă într-o ordine sortată.
#who | grep root
Comanda grep va selecta din datele de intrare doar liniile care conțin cuvântul root. Efectul acestei comenzi conectate va fi de returnare doar a logările cu userul root.
O altă posibilitate de folosire o reprezintă crearea filtrelor. Dacă în linux o comandă își accepta intrarea din intrarea standard și rezultatul acesteia este o ieșire standard atunci comanda respectivă este cunoscuta sub numele de filtru.
Exemplu:
Fișierul nume.txt conține 30 de linii și din acesta am dori să extragem liniile de la 11 la 15 în fișierul flist.
Pentru aceasta vom folosi comanda urmatoare:
#tail -n +11 < nume.txt |head -n +5 > flist
Comanda tail extrage ultimile 10 linii ale unui fișier,iar comanda head extrage primele 10 lini ale unui fișier și s-au folosit
opțiunea -n pentru a decala și limita numărul de înregistrări solicitate. În acest comandă head este un filtru
deoarece intrarea acesteia este preluată din rezultatul comenzii tail și rezultatul acesteia este direcționat în fișierul flist.
 Un alt exemplu îl reprezintă comanda următoare:
#sort < snume | uniq -c > u_snume
Comanda uniq -c listează și numărul de apariții pentru fiecare tag.
Un alt mod de folosire a pipe este lista.O listă este o secvență de una sau mai multe pipeline, separate prin unul dintre operatorii ;, &, &&, ||, și încheiată prin ; sau & sau .
Dintre acești operatori de listă, && și || au prioritate egală, fiind urmați de ; si &, care au tot prioritate egală între ei.
Dacă o comandă se încheie cu operatorul de control &, shellul execută comanda în background, într-un subshell. Shellul nu așteaptă să se încheie execuția comenzii, și starea de ieșire este 0. Comenzile despărțite prin ; sunt executate secvențial (liniar); shellul asteaptă ca fiecare comandă să se termine, pe rând. Starea întoarsă este starea de ieșire a ultimei comenzi executate.
Operatorii de control && și || denotă liste SI și liste SAU, respectiv. O listă SI are forma:
comanda1 && comanda2
Comanda 2 este executată dacă și numai dacă prima comandă întoarce o stare de ieșire 0.
O lista SAU are forma
comanda1 || comanda2
Comanda 2 este executata dacă și numai dacă prima comandă întoarce o stare de ieșire diferită de 0. Starea de ieșire a unei liste SI sau SAU este starea de ieșire a ultimei comenzi executate din listă.

17.Comenzi multiple pe aceeași linie de comandă
Sintaxa
#comanda1; comanda2
Exemple
#date; who
Comanda de mai sus va afișa data curentă urmată de userul curent. O altă formă dar identică în privința rezultatului este :
#date who
Interpretarea generală a compilatorului este că după comandă apare argumentele comenzii de exemplu:
#ls -l script.sh
Va fi afișate doar datele pentru fișierul script.sh.
ls este numele unei comenzi efective și shell-ul o execută luând ca argument script.sh. Orice altceva de pe acea linie este citit ca fiind un argument pentru comanda respectivă.
În cazul comenzii #tail -n +15 script.sh
Numele comenzii este tail iar -n și +10 opțiuni de execuție și script.sh este argument al acestei comenzi.
Notă:
$# deține numărul de argumente specificate în linia de comandă. Iar $* sau $@ se referă la toate argumentele date scriptului.

18.Utilizarea argumentelor în linia de comandă
Opțiunile de utilizare ale argumentelor sunt multiple și depind de comanda sau utilitarul folosit.Pot fi grupate în două categorii principale:
1. Opțiunile folosite de comandă sau program.
2. Fișierele sau grupul de fișiere necesare.
Dacă considerăm comanda
#md nume_director
md este comanda iar nume_director este directorul pe care dorim să îl creăm.
De asemenea pot fi transmise prin intermediul liniei de comandă anumite argumente scriptului pe care îl rulăm.
În cazul scripturilor shell:
#script.sh albert 2
script.sh este numele scriptului rulat albert reprezintă primul argument trecut scriptului prin intermediul liniei de comandă iar 2 reprezintă cel de-al doilea argument.
Dacă dorim să ne referim la aceste argumente le vom apela astfel :
$0 reprezinta numele scriptului
$1 are valoarea albert
$2 are valoarea 2
În acest exemplu variabila predefinita $# are valoarea 2 deoarece au fost introduse două argumente.Pot fi folosite un număr de maxim 9 argumente notate de la $1 la $9.
Vom crea un script care să afișeze și să prelucreze argumentele liniei de comandă.

#!/bin/sh
#
#folosirea argumentelor
#
echo "Numarul de argumente din linia de comanda este de $#"
echo "$0 este numele scriptului"
echo "$1 reprezinta primul argument"
echo "$2 reprezinta cel de al doilea argument"
echo "toate argumentele sunt: $* sau $@"
fnume=$1$2
cal>>$fnume
num=$[$2-1]
fnume=$1$num
cal>>$fnume
Pentru rulare se va folosi comenda:
#./script.sh albert 2 
În urma execuției acestui script se vor crea două fișiere 
albert2 și albert1 în care va fi stocat calendarul lunii curente.
Nu se pot atribui alte valori parametrilor utilizați la lansarea scriptului.
Următoarele declaratii devin invalide dacă sunt utilizate în acest script:
$1=2; $2=3

18.Procesele sub Unix
Un proces reprezintă un program în execuţie şi are ataşate o serie de informaţii specifice precum instrucţiunile programului, resurse folosite (precum fişiere deschise), unul sau mai multe fire de execuţie şi alte informaţii necesare procesului de execuţie în paralel.
O listare a proceselor poate fi efectuată prin comanda ps aux
Aici apare o listă a tuturor proceselor de pe sistemul nostru în momentul de față. Fiecărui proces în linux îi este asociat un PID sau process-id format dintr-un număr care ia valori între 0 și 65535.

Orice proces Linux va avea un set de caracteristici comune, ce oferă informaţii despre acesta:
- PID – sau Process ID, este un identificator de proces sub forma unui număr întreg unic.
- PPID – similar cu PID, cu excepţia că reprezintă identificatorul procesului care a dat naştere procesului curent (cunoscut şi ca proces părinte)
- Terminalul ataşat – prescurtat şi TTY, reprezintă terminalul la care procesul curent este legat.
- RUID – Real User ID, reprezintă identificatorul utilizatorului care a lansat aplicaţia. Similar există şi EUID (sau Effective User ID) pentru identificarea drepturilor reale la resursele sistemului.
- RGID şi EGID – similar cu RUID şi EUID, doar că se referă la identificatorul grupului de utilizatori.
- factorul nice – folosit pentru a determina, aşa cum sugerează şi numele, „factorul de prietenie” al procesului cu scopul stabilirii priorităţii de execuţie (bazat pe factorul nice şi istoricul de utilizare al procesorului).
Procesele pot rula în mod normal în două moduri: foreground respectiv background. Dintre procesele interactive, marea majoritate funcţionează în modul foreground. Diferenţa dintre cele două moduri se rezumă strict la interacţiunea cu interfaţa cu utilizatorul, mai exact la ocuparea consolei din care respectivul proces a fost lansat. În acest mod, consola nu va fi eliberată până la terminarea programului care o ocupă .Ca alternativă, programele pot rula şi în modul background pentru a permite terminalului de pe care rulează să primească şi alte comenzi în acelaşi timp, execuţia având loc în fundal şi fiind guvernată de aceleaşi reguli ca orice alt proces. Acestea sunt procesele care de regulă au un timp de execuţie mare sau nu necesită interacţiunea cu utilizatorul.
Exemplu:

 
19.Comenzi linux referitoare la procese
 
ps - pentru afisarea proceselor care ruleaza in momentul respectiv
kill {PID} - pentru oprirea procesului identificat prin pid-ul din cadrul comenzii
killall {numele-procesului} - pentru oprirea procesului cu numele respectiv.
Nota: atentie sa nu dati kill procesului sshd. ps -ag - pentru aflarea de informatii despre toate procesele care ruleaza
kill 0 - pentru oprirea tuturor proceselor cu exceptia propriei conexiuni pe sistem
ps aux - pentru afisarea proceselor si o lista a userilor carora apartin aceste procese
top - pentru obtinerea unei liste a proceselor cu utilizarea memoriei si a procesorului de catre acestea, cu update in timp real
pstree - pentru obtinerea unei structuri arborescente a proceselor
pkill -care va lua ca parametru direct numele procesului. Comanda pkill nu va afişa PID-urile proceselor, ci le va comanda terminarea.

20.Servicii
Crearea unui proces implică apelarea mecanismului numit fork, prin care acesta crează o copie identică a sa, însă cu un PID diferit. După terminarea mecanismului de forking, spaţiul de adresare al procesului este înlocuit cu cel reprezentativ pentru noul proces (procedeu numit exec) şi astfel, noul proces este gata de execuţie. În ceea ce priveşte execuţia propriu-zisă, o
practică comună este aceea de transformare în daemon a proceselor fiu ale unui program, pentru ca acestea să poată rula chiar şi după terminarea procesului părinte.
Procesul rădăcină, care este părintele tuturor proceselor ce rulează la un moment dat, se numeşte init. Init va efectua sarcini precum montarea sistemului de fişiere, pornirea serviciilor aferente sistemului, sau chiar încărcarea interfeţei grafice.
În Linux, init este executat cu un parametru, cunoscut şi ca run-level, prin care se specifică modul în care se doreşte iniţializarea sistemului. Valoarea acestui parametru este un număr întreg între 1 şi 6, şi semnalează ce componente ale sistemului vor fi iniţializate, fiecare nivel având o serie de script-uri ce vor fi executate. Aceste scripturi sunt de obicei stocate în directoare dedicate fiecărui nivel (de regulă în /etc/rc[n].d unde [n] reprezintă run level), iar fişierul principal de configurare în /etc/inittab.
Nivele run-level:
-nivelul 0 – halt (shutdown)
-nivelul 1 – single user
-nivelele 2-5 – multi-user cu console şi mod grafic
-nivelul 6 – reboot
După terminarea iniţializării procesului init, acesta este clonat prin procedeul fork, devenind un nou proces, numit getty. Acesta are rolul de a porni consolele virtuale aferente sistemului, de regulă în număr de 6-8 (acest număr fiind configurabil în /etc/inittab).
Serviciile oferă diverse funcţionalităţi fie local, fie unei reţele de calculatoare. Acestea sunt ca orice alt program într-un sistem Linux, cu menţiunea că sunt denumiţi Daemons şi că rulează în continuu, de regulă pornind odată cu sistemul (pot fi și lansați ulterior în execuție din folderul /etc/init.d ). Programele de acest tip rulează de regulă în fundal şi aşteptă cereri către serviciile pe care le oferă.
Ca orice entitate dinamică, procesele au un ciclu de viaţă foarte bine definit, acestea născându-se, evoluând şi terminându-se după reguli bine puse la punct. Nevoia creării unui proces nou este evidentă: acest lucru se întâmplă ori de cât ori este nevoie să fie instalat un nou program.
Procesele în Linux, urmează o structură de organizare arborescentă. Afişarea structurii arborescente a procesele se realizează, în principal, cu comanda pstree. Procesele în cadrul sistemului Linux pot fi create numai din alte procese, acestea devenind procese fiu (sau children). Urmând structura de arbore, fiecare proces poate fi reprezentat printr-un nod, rădăcina fiind părintele tuturor proceselor create. Nodurile din arborele de procese, pot avea la rândul lor alte procese de tip fiu, creându-se astfel o structură ierarhică foarte bine definită.
Cazuri excepţionale pot avea loc atunci când un proces fiu îşi termină execuţia, în timp ce procesul părinte nu aşteaptă acest lucru; acest tip de procese se numesc procese zombie.
Terminarea execuţiei unui proces în mod normal (dacă nu este terminat forţat) are loc printr-un mecanism ce returnează un rezultat procesului părinte (numit exit status). Acest rezultat reprezintă un număr, ce oferă datele necesare privind modul în care procesul şi-a derulat și încetat activitatea. Dat fiind faptul că Unix a fost scris în totalitate folosind C această interpretare a execuției procesului ca fiind o funcție ce returnează un rezultat este naturală. Diferența față de o funcție clasică C este dată de posibilitatea ca procesul fiu să continue execuția chiar dacă procesul tată și-a încetat activitatea.

21.Programarea structurată
Pentru a realiza scripturi adaptate modului de funcționare al sistemului și pentru realizarea unor sarcini complexe este necesară folosirea programării structurate.
În cadrul programării structurate deosebim 2 tipuri de structuri principale:
-structuri de decizie :if, select și case
-structuri repetitive (de buclă) while,until și for.

Structura if este folosită pentru luarea deciziilor în scripturile shell, prin evaluarea unei expresii. Dacă valoarea expresiei este 1 sau YES atunci comanda este executată. Se vor executa toate comenzile până când se va întâlni (dacă e cazul) comanda else , după aceea se va execta instrucțiunea ce urmează după fi (sfârșit apel).
Dacă condiția evaluată este falsă execuția comenzilor va trece direct la instrucțiunile aflate înte comenzile else și fi.
Sintaxă:

if [ expresie ]
then
#dacă condiția este adevărată sau dacă exit status al condiției este 0 (zero)
comanda1
comanda2
...
else
comanda11
comanda22
......
fi

[ expresie ] opereaza cu:
* Intregi (Numere fara punct zecimal)
* Tipuri de fișiere
* Caractere ale stringurilor
Exemplu
#!/bin/bash
num1=`date +%d`
num2=`date +%k`
if [ $num1 -eg 15 -a $num 2 -gt 16 ] then
ifdown -a
etc/init.d/dhcp3-server stop
cp /etc/dhcp3/dhcpd.conf /eth/dhcpd.conf.bak2
rm /etc/dhcp3/dhcpd.conf
cp /etc/dhcp3/dhcpd.conf.bak /etc/dhcp3/dhcpd.conf
etc/init.d/networking stop
/sbin/ifconfig eth1 192.168.30.2 netmask 255.255.255.0 broadcast 192.168.30.255
etc/init.d/networking start
etc/init.d/dhcp3-server start
else
ifdown -a
cp /etc/dhcp3/dhcpd.conf /eth/dhcpd.conf.bak
rm /etc/dhcp3/dhcpd.conf
cp /etc/dhcp3/dhcpd.conf.bak2 /etc/dhcp3/dhcpd.conf
etc/init.d/networking stop
/sbin/ifconfig eth1 192.168.33.2 netmask 255.255.255.0 broadcast 192.168.33.255
etc/init.d/networking start
etc/init.d/dhcp3-server start
fi

Acest script modifică comportamentul serverului dhcp în data de 15 a lunii după ora 17.

Structura Select

Sintaxa
select nume in cuvinte; do lista ; done

Lista cuvinte de după "in" este expandată luând în considerare ca separator caracterul spațiu, generând o listă de itemi. Setul de cuvinte expandate este printat pe ieșirea standard, fiecare fiind precedat de un număr. Dacă partea "in cuvinte" este omisă, sunt printați parametrii poziționali ($0, $1,etc). Apoi este afișat un prompt și este citită o linie de la intrarea standard. Dacă linia constă în numărul corespunzator unuia dintre itemurile afișate, atunci "nume" ia ca valoare acel item. Dacă linia este goală, atunci itemi sunt afișați din nou. Dacă se citește EOF, comanda se încheie. Orice altă valoare citită determină ca "nume" să fie setat ca "null". Linia citită este salvată în variabila REPLY. Lista este executată după fiecare selecție până când este executată o comandă de "break" sau "return". Starea de ieșire pentru "select" este starea de ieșire a ultimei comenzi executate din listă, sau zero dacă nu s-a executat nici o comandă.

Exemplu
#!/bin/bash
echo "selectati o cifra" ;
select nume in alfa beta gama ;
do
echo "ati selectat $nume";
echo "selectand cifra $REPLY "
break
done

Comanda break determină ieșirea din structură și executarea comenzii ce urmează după done.

Structura Case

Sintaxa instrucțiunii bash case.

case expresie in
pattern1 )
instrucțiuni;;
pattern2 )
instrucțiuni;;
...
esac

O comandă "case" mai întii expandează cuvântul și-l compară pe rând, pentru a-i găsi echivalentul, cu fiecare model, spre deosebire de expandarea de la select se prelucrează metacaracterele ?,* și [...].
Când se găsește o echivalență, se execută lista de comenzi corespunzătoare . După prima echivalare nu se mai caută altă echivalență. Starea de ieșire este zero dacă nu se găsește nici o echivalență cu vreun model. Altfel, este starea de ieșire a ultimei comenzi executate din listă.

Exemplu
Următorul script tipărește numărul de linii, numărul de cuvinte și șterge liniile în care se găsește un cuvânt transmis ca argument scriptului.

$ cat fileop.sh
#!/bin/bash
# Check 3 arguments are given #
if [ $# -lt 3 ]
then
echo "Usage : $0 option pattern filename"
exit
fi
# Check the given file is exist #
if [ ! -f $3 ]
then
echo "Filename given \"$3\" doesn't exist"
exit
fi
case "$1" in
# Count number of lines matches
-i) echo "Number of lines matches with the pattern $2 :"
grep -c -i $2 $3
;;
# Count number of words matches
-c) echo "Number of words matches with the pattern $2 :"
grep -o -i $2 $3 | wc -l
;;
# print all the matched lines
-p) echo "Lines matches with the pattern $2 :"
grep -i $2 $3
;;
# Delete all the lines matches with the pattern
-d) echo "After deleting the lines matches with the pattern $2 :"
sed -n "/$2/!p" $3
;;
*) echo "Invalid option"
;;
esac
Referință
http://www.thegeekstuff.com/2010/07/bash-case-statement/

Structuri repetitive
Sunt trei structuri repetitive:for, while, until
O buclă reprezintă repetarea execuției unei instrucțiuni sau a unui grup de instrucțiuni. În mod normal o buclă nu trebuie să se repete la infinit și ca atare există o condiție ce se verifică la fiecare intrare în buclă. Dacă condiția de buclă nu mai este îndeplinită se continuă execuția scriptului cu următoare instrucțiune de după buclă. Marcajul de sfârșit de buclă este realizat prin cuvântul cheie done care arată sfârșitul buclei. O altă modalitate de asigurare a finității buclei o constitue executarea buclei de un număr finit de pași după care se iese din buclă.
Deși while și until au practic aceeași sintaxă există o diferență majoră în cazul while bucla se execută cât timp condiția este adevărată pe când until se execută până condiția devine adevărată.
WHILE
while [ condiție ]
do
instrucțiune(i)...
done

Exemplu:
#!/bin/bash
lim=10
a=1
while [ "$a" -le $lim ]
do
echo -n "$a "
let "a+=1"
done

UNTIL
until [ condiție ]
do
instrucțiune(i)...
done

FOR
Avem în cazul lui for două sintaxe diferite una asemănătoare cu for din C și alta asemănătoare cu foreach din <algoritm.h>
a)
for variable in [lista]
do
instrucțiune(i)...
done

Exemplu
for num in 1 2 3 4 5 6 7 8 9
do
echo $num
done

b)
for ((variabilă=valoare_inițială; a <= limită; variabila incrementată/decrementată))
do
instrucțiune(i)...
done

Exemplu
#!/bin/bash
lim=9
for ((a=1; a < = lim ; a++))
do
echo -n "$a "
done

Functii  
Ca majoritatea limbajelor de programare și scripturile shell 
pot conține funcții ce sunt definite în interiorul scriptului și
apelate ulterior pentru execuție.

Declararea unei funcții se face urmând sintaxa :
function nume( ) {
}
Apelul unei funcții se face prin numele său. 
Unei funcții i se pot transmite parametri.
 

22.Shell-uri de login
În Unix, există o serie de fișiere de inițializare, de configurare și de istoric a shell-ului. Numele acestor fișiere este diferit pentru fiecare tip de shell.

În momentul iniţializării, shell-ul bash accesează procesul init, cu identificatorul PID=1. Acesta iniţiază un proces getty, care deschide un terminal cu intrările și ieșirile standard:standard input, standard output şi standard error.
Ca rezultat va apărea un prompter de login pe ecran. În continuare se execută programul /bin/login, care cere o parolă, criptează şi verifică parola, setând un mediu iniţial de lucru şi pornind shell-ul de login (care în cazul nostru este
/bin/bash). După aceea, procesul bash caută fişierul de configurare  etc/profile şi execută comenzile din acesta. În continuare, se caută în directorul home un fişier de configurare iniţială denumit .bash_profile. După executarea comenzilor din acest fişier, se va executa o comandă din fişierul ENV al utilizatorului, de regulă .bashrc şi, în cele din urmă, prompter-ul
(semnul $ pentru utilizatorul obişnuit sau # pentru root) este afişat pe ecran, aşteptând introducerea de comenzi.
Dacă dorim modificarea shell-ului la linia de comandă, putem să introducem simplu numele shell-ului şi să apăsăm ENTER. De exemplu, dacă vrem să folosim Bourne Again shell, nu avem decât să introducem bash la linia de comandă, urmat de tasta ENTER:.
Personalizare mediu
Utilizatorul root sau fiecare utilizator poate scrie un fisier script care să fie executat la fiecare inceput de sesiune de lucru script numit $HOME/.profile sau $HOME/.bash_profile in cazul când se utilizează bash-ul ca shell implicit .
În plus poate avea un script care să fie rulat atunci când se deconecteaza de la sistem (adică la logout); acest script se numește $HOME/.bash_logout în cazul shell-ului bash. Există două fișiere de inițializare valabile pentru toți utilizatorii, și anume fișierele /etc/profile și /etc/environment. La deschiderea unei noi sesiuni de lucru, mai întâi sunt executate script-urile de sistem (din directorul /etc/), si abia apoi cele particulare utilizatorului respectiv ( din directorul $HOME/). Un aspect major constă în faptul că se verifică existența acestor fișiere și dacă ele există sunt executate. Ordinea de căutare și execuție a fișierelor este cea prezentată.
În plus, există si niste fisiere de configurare, si anume un fișier global, numit /etc/bashrc, si un fișier specific fiecarui utilizator, numit $HOME/.bashrc (acestea sunt numele in cazul shell-ului bash).Există un fisier de istoric, numit $HOME/.bash_history, care păstrează ultimele comenzi tastate .Ștergerea istoricului se face cu comanda history -c.