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. 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:
Opțiunile
folosite de comandă sau program.
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ță
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.
Descarcă articolul în format PDF
