• Parancsnyelvet és nagytudású parancsértelmezőt (shell) tartalmazó többfelhasználós operációs rendszer, sokféle platformon implementálva. Szabadon használható változata, a Linux, már nagygépeken is terjed.

• Rengeteg közhasznú programot (parancsot, "utility"-t) tartalmaz, amik különösen "csapatban" igen erősek. Lényegében parancsnyelv alapú "programozói" operációs rendszer, konkrét esetekben esetleg - egymástól Unix verziónként igen eltérő - felhasználói felülettel (pl. "mc", "smit", "sysadmsh", "kde", ...). Igen erős programok: bash, sed, awk.

• Lényegében fastruktúrájú fájlrendszert tartalmaz, szabályozható hozzáférési jogosultságokkal.
  
  A pandora fájlrendszerének (összesen többszázezer fájl) egy része látható az ábrán. Néhány fájl funkciója (balról jobbra):
  • /dev/fd0h1440: HD floppy egység megnevezése a Linuxban.
  • /dev/null: A "szemétkosár" (nem lehet benne guberálni).
  • /sbin/e2fsck: Fájlrendszer ellenőrző program (ext2 tipusú fájlrendszerre.)
  • /bin/bash: A (szokásos Linux) shell.
  • /usr/local/jelentkezes/jelentkezes: A jelentkezes program.
  • /usr/bin/cc: A c nyelv fordítóprogramja.
  • /etc/inittab: A bootolást alapvetően szabályozó táblázat (szövegfájl).
  • /etc/motd: A login után minden képernyőn megjelenő üzenetet tartalmazza ez a szövegfájl.
  • /etc/passwd: Más rendszereen minden felhasználóról egy sort tartalmaz, a felhasználó legfontosabb adataival.
  • /h/m/maulis: Ádám "HOME" directoryja.
  • /h/public/m/maulis/public_html/index.html: Ádám honlapja. (Böngészőbeli hivatkozás a lapra: http://people.inf.elte.hu/maulis)
  • /h/public/c/csa/jelentkezes/progkor: a "progkor" hirdetésre jelentkezettek azonosítóit tartalmazza.

  A fizikai fájlokhoz és directorykhoz (amik speciális fájlok) ún. inode-számokat rendel a Unix. A felhasználó által használt nevek mindegyikéhez egy "név, inode-szám" alakú directory bejegyzés tartozik. Ezért tud ugyanaz a fájl több néven - akár különböző directorykban - is előfordulni. A "symbolic link" (szimbolikus link) olyan speciális fájl, ami egy (rajta keresztül is elérhető) fájl vagy directory nevét tartalmazza. A több néven történő elérésre - egyebek mellett - az alábbi példák szerepelnek az ábrán:

  • A /dev/sbin/e2fsck és /dev/sbin/fsck.ext2 abszolút egyenértékű nevek.
  • A /usr/bin/gcc, /usr/bin/cc, /etc/alternatives/cc ugyanazt a c fordító programot jelöli, amire /usr/bin/gcc-3.3 néven is hivatkozhatunk.
  • Ádám a honlapjá(nak kezdőfájljá)t /h/m/maulis/public/public_html/index.html és /h/public/m/maulis/public_html/index.html néven is elérheti. Mások, jogosultság híján csak az utóbbi néven. (Ha letörli a public sym.link fájlját, akkor már ő is csak a második néven érheti el, de nem veszíti el a honlapját.)
  A "lényegében fastruktúrájú fájlrendszer" tehát azt, hogy "összenőtt faágak", és "több ágon közös levél" is előfordulhat a bokron.
  A fenti ábra sok egyéb Unix-ban nagyon hasonló, az inode számok viszont teljesen mások lesznek.

  Egy fájlrendszeren belül az inode számok egyediek. Használni több fájlrendszert úgy lehet, hogy az ún. gyökér fájlrendszerre (a mount paranccsal) "felakaszthatunk" másik fájlrendszereket. Az ábrán ezeket az inode szám elé tett csillaggal jelöltem. Különböző fájlrendszerhez tartozó dolgok között csak "laza összenövés", azaz sym.link fordulhat elő.

A Unix többfelhasználós, több processzt "párhuzamosan" futtató op. rendszer, esetenként egyedi, többnyire (i)x-re végződő névvel. (SCO-Unix, Sinix, AIX, Xenix, Unixware, Linux, Solaris).

Shell = parancs értelmező program. Tkp. programozási nyelv, változókkal ("környezetváltozók"), utasításokkal ("parancsok").

• Környezetváltozók. Név-érték párok. A "név" alfanumerikus (+néhány egyéb jel, pl. "_"). Kisbetű, nagybetű (mint mindenütt) különbözik. Nincs típus (általában).
  Definíció: név=érték
  • PUBLIC=/h/public/c/csa/public/public_html
  • PS1="Irj be egy parancsot: "
  Hivatkozás: $név (ha kell: ${név})
  • vi $PUBLIC/vi.htm #a "vi leírás" szerkesztése a "vi" editorral
  • PATH=$PATH:$HOME/sajatparancsok:. #parancskészlet bővítése, ld. alább
  • ${KV:-alma} $KV vagy "alma"
  • ${#KV} $KV hossza (hány jel)
  • ${KV:$i:1} $KV $i-edik jele, ($i=0, 1, ..., ${#KV}-1)
  Előre definiált környezetváltozók.
  • HOME: "saját", login directory
  • PATH: dir1:dir2:... (parancskönyvtárak nevei)
  • PS1: elsődleges "prompt"
  • PS2: másodlagos (folytatósor) "prompt"
  • ...
  Exportálás parancsfájlokba (igazából "gyerekprocesszek"-be)
  • NEV1=ertek1
    NEV2=ertek2
    export NEV1 NEV2
  • export NEV3=ertek3
  Törlés:
  • unset KV1 KV2
  • KV1="" # ez nem törlés!
  • unset PATH # ez nem megy
  Nem változtatható, nem törölhető (az se változtathatja/törölheti, aki definiálta!):
  • readonly KV
  Listázás:
  • set: összes környezetváltozó
  • env: összes exportált környezetváltozó
  Új bash lehetőség: egydimenziós tömbök (index: 0,1,2,...)
  • a[1]=alma; a[3]=dió; echo ${a[1]} ${a[3]}
    alma dió
    echo elemek: ${a[*]}, elem_db=${#a[*]}, indexek: ${!a[*]}
    elemek: alma dió, elem_db=2, indexek: 1 3
  • unset a[3]; echo ${a[*]}
    alma
    unset a

• A Unix parancsok formája: parancsnév opciók fájlok/directoryk/egyebek # kommentár (Kommentár: #-jellel kezdődő szóval kezdődik.)
  • Parancsnév: egy shell "belső parancs", vagy egy programfájl ill. parancsfájl neve
    Ha csak fájlnév, akkor a $PATH directoryjaiban keresi a shell.
  • Opciók: a parancsvégrehajtás "hogyan"-jára vonatkozó "hangolás"
    Többnyire "-", ritkábban "+" jel mögött álló (többnyire egyetlen) jel (Linuxban "--" mögött álló jelsorozat is)
    ls -l -t $HOME   # a login könyvtár directory listája fordított időrendben
    ls -lt $HOME   # ugyanaz, mint az előző
    ls -lt   # ugyanaz, a munkadirectoryval
  • Fájlok/directoryk: relatív vagy abszolut (/...) fájlnevek/directorynevek.
  • Formai kivételek (pl):
    find $HOME -type f -name "*.jpg"   # jpeg fájlokat keres a HOME directorynkban
    dd if=file1 of=file2   # ugyanaz, mint "cp file1 file2"

  Pl:	cd $HOME	# Ugyanaz, mint "cd" vagy "cd   ~" : hazatérés
  	cd /win95/"Program Files"	# Helyköz van a fájlnévben (kerüljük!!!)
  	cp /etc/passwd .	# A /etc/passwd fájlt a munkakönyvtárba (.) másolja
  	man echo	# Infó a "/bin/echo" programról
  	man passwd	# Infó a jelszó változtatásról
  	man kpasswd	# Infó a jelszó változtatásról - régi pandora
  	man -S 5 passwd	# Infó a /etc/passwd fájlról (SEE ALSO passwd(5) alapján)
  	PS1="\w> "	# DOS-szerű prompt-beállítás (csak bash shell)
  	rm *.c /* mindet töröltem */	# Szanálás "gondos c-programozó" módra

Processz = egyedi azonosítóval(process-id=pid), "környezettel" (user, munkadirectory, környezetváltozók) rendelkező (rész)program. Program = parancsfájl(shell script) vagy bináris program. A ps parancs. $$ környezetváltozó (processzNr).

Daemon-ok (=háttérben futó kiszolgáló programok, pl. httpd) feladatai.

Foreground, background parancs végrehajtás.

Háttérben futtatás: parancs &
Ne használja a billenytűzetet és képernyőt.
pl: sleep 50 & (= vár 50 másodpercet, de közben dolgozhatunk)
kill $!       # $! = last backgr. processzNr

Editorok: vi (segédanyagok), emacs, pico, joe, wpe, mc editora.

A shell (sh, ksh, csh(kakukktojás), bash) feladatai:

1. Korábban kiadott parancsok visszahozása, editálása.(sh nem tudja, bash shell esetén DOSKEY-szerű lehetőségek)
2. A parancs szavakra bontása.
3. A ' és " jelek értelmezése.
   " jelek közötti parancsrészben csak a ("-ben is) jelekkel kezdett további parancsátalakítási feladatok lesznek végrehajtva.
   ' jelek közötti parancsrészben a további parancsátalakítási feladatok (4-12.) nem lesznek végrehajtva.
4. Az első szó alias(=rövidítések) helyettesítése, function hívások felismerése.
5. Standard input, standard output, standard error. Az input ill. output átirányítása: fájlból(<), másik parancsból(|) ill. fájlba(>), fájl végére(>>), másik parancsnak(|). A pipe fogalma.
   Szűrő (st.input-->st.output; a gyakorlatban: paraméter fájl(ok) vagy st. input --> st. output).
   Pipe minden tagját "subshell" hajtja végre, ami az összes környezetváltozót (nem csak az exportáltakat) örökli.
6. Kapcsos zárójelezés kifejtése. alma{fa,moly,csutka} = almafa almamoly almacsutka (sh nem tudja)
7. Szó elején levő tilde ( ~, ~csa/xyz, de nem /public/~csa) helyettesítése a(z aktuális) user $HOME directoryjának nevével.(sh nem tudja)
8. ("-ben is) Környezetváltozók behelyettesítése.
9. ("-ben is) Parancs a parancsban(`parancs` vagy $(parancs) (sh nem tudja) alakú parancs-rész) standard outputjának a parancsba helyettesítése.
10. ("-ben is) Aritmetikai kifejezések kiértékelése. Pl. $[2*2] (csak bash) vagy $((2*2)) ( / = egész osztás; % = mod)
11. A parancs szavakra bontása.
12. "Joker"(wildcard) karakter(eke)t tartalmazó szavak helyettesítése "rájuk illő" fájl vagy directory nevekkel a fájlstruktúra alapján. Eközben a fájl-/directorynevek mindegyikét egyetlen paraméternek tekinti a shell (akkor is, ha név pl. helyközt tartalmaz).
    

    * = akárhány akármi
    ? = egy akármi
    [aeiou] = egy a felsoroltak közül
    [b-z] = "a"-tól különböző kisbetű
    [A-Z0-9-] = nagybetű vagy számjegy vagy "-" jel
    [!A-Z0-9-] = nem az előbb felsorolt jelek       (A ! helyén ^ is állhat.)

13. A kapott parancs végrehajtása (belső parancs) vagy végrehajtatása (rel. parancsnév esetén a $PATH alapján).

4.	alias dir='/bin/ls -l'	# alias definiálása
	dir *.c >~/lista	#     és használata (dir. lista fájlba)
5.	help | less	# pipe: Linux infó a bash "belső" parancsairól
	help variables | less	# Néhány fontosabb környezetváltozó
	tail +25 t1 | head -24 | cut -c1-80	# A 2., képernyőnyi rész a t1 "textfile"-ból
	fgrep -i A *.txt|fgrep -i B|more	# Olyan sorok a .txt fájlokból, amikben "a" és "b" betű is van
	ls /etc/inittab /ect/x 1>van 2>nincs	# Standard output és standard error szétválasztása
	find / -name "*.dvi" -print | more	# A gépen található ".dvi" fájlok megkeresése
	echo valami nem stimmel 1>&2	# St. output átirányítása a "st. error"-ra
5,9	ls `cat f1` 2>&1 1>/dev/null|tee f2	# f1-ben felsorolt, nemlétezők: képernyőre + f2 fájlba (2>,1> sorrendje!)
9.	Userek=`cut -d: -f1 /etc/passwd`	# Környezetváltozóban az összes user_id
7,9.	echo ~maulis	# Eredmény: /h/m/maulis (pandora-n)
8,9.	KV=HOME;echo ${$KV}	# Eredmény: hibás a parancs!
	KV=HOME;echo \${$KV}	# Eredmény: $HOME (8. csak egyszer!)
	KV=HOME;echo $`echo $KV`	# Eredmény: $HOME (8. és 9. sorrendje!)
	KV=HOME;echo echo $`echo $KV` >x; . x	# Eredmény: /h/teacher/csa (pandora-n, csa-nak)
	KV=HOME;echo echo $`echo $KV`|sh	# Eredmény: /h/teacher/csa (pandora-n, csa-nak)
	KV=HOME;echo ${!KV}	# Ez is jó; nem régóta tudja a bash
8,10.	KV=HOME;echo ${KV:$((${#KV}-2)):2}	# Eredmény: $KV utolsó két jele
3,12.	rm -r d1 2>/dev/null	# Törlés, hibaüzenet nélkül (folyt. köv.)
	mkdir d1; cd d1	#     Directory kreálás és váltás
	echo 1234 >f1; grep [1-9] *	#     Eredmény: "1234"
	echo abcd >9; grep [1-9] *	#     Eredmény: ""
	grep "[1-9]" *	#     Eredmény: "f1:1234"
	echo grep [1-9] *	#     Eredmény: "grep 9 9 f1"
	echo grep "[1-9]" *	#     Eredmény: "grep [1-9] 9 f1"
12.	ls /e?c/i*tab	# Eredmény: /etc/inittab
	dd if=/e?c/i*tab	# Eredmény: "dd: /e?c/i*tab: No such file or directory"
	rm $NINCSILYEN/*	# Csak a directoryk és rejtett fájlok (. a név elején) maradnak meg

Több parancs egy sorban (köztük ";"). Egy parancs több sorban (sor végén "\", folytatósor, elsődleges, másodlagos prompt). A tee parancs. Az xargs parancs.

Pl:	cd ~/public; zip -9 -r ~/p *	# Publikus directory (pandora) csomagolása a "~/p.zip" fájlba.
	cut -d: -f5 /etc/passwd|cut -d" " -f2-|\     tr " " "\012" | sort|uniq -c|sort	# Az adott gép user-einek keresztnevei,     gyakorisági sorrendben (\012 = sorvégejel)
	tar -cvf /tmp/archiv $HOME .	# HOME és munkadir. összecsomagolása a /tmp/archiv fájlba
	tar -tvf /tmp/archiv | tee /tmp/arclis	# Az archívum listázása a /tmp/arclis fájlba és képernyőre
	echo * | xargs grep -i "alma"	# Akármekkora directory fájljaiban kis/nagy "almát" keres.

Sorvége jelzés MS-DOS (CR LF), Unix (LF) és Macintosh (CR) op. rendszerekben. Hexadecimális(CR=^M=0x0d LF=^J=0x0a), oktális(CR=\015 LF=\012), "backslash"(CR=\r, LF=\n) jelölésmód (újabban). Az echo, sed és tr parancsok.

Pl:	echo -e "\007"	# sípol egyet (-e csak Linuxban)
	tr -d "\012" <textfile	# a textfile sorait egyberakja (kell a "<" jel!
	tr -d "\015" <dosfile >unixfile	# DOS textfájlt Unix textfájllá konvertál
	sed "s/`echo -en '\015'`//" dosfile >unixfile	# DOS textfájlt Unix textfájllá konvertál
	sed "s/\r//" dosfile >unixfile	# ugyanaz, mint az előző, a legújabb sed-del
	sed "s/$/`echo -en '\015'`/" unixfile >dosfile	# Unix textfájlt DOS textfájllá konvertál
	sed "s/$/\r/" unixfile >dosfile	# ugyanaz, mint az előző, a legújabb sed-del

Megjegyzések:

• A bash-nak beadható a "CR" úgy, hogy előbb a CtrlV, aztán a Return billentyűt nyomjuk meg. (A Return helyén egyéb különleges billentyű - pl. TABulátor ("\t"), ESCape, ... - is állhat.)
• Egyes Linuxokban megjelent a todos ill. fromdos parancs, amikkel Linux fájl DOS fájllá alakítható ill. vissza. (Nem igazán "Unixos", hogy alaphelyzetben felülírják az input fájlt.)

A cd, pwd, ls, cp, cat, head, tail, cut, man, help(bash), more/less(Linux), alias, sort, uniq, fgrep, tar, zip, tee, find parancsok.
A "sort" és "uniq" parancsokra további példákat az alábbi, kidolgozott "gyakorló feladatokban" talál: IV. XV. XXI. 39.

A Unix fájl jogosultságok

Minden fájl/directory egyetlen tulajdonoshoz és csoporthoz tartozik.

• Csoportok: /etc/group
• Parancsok váltásra(csak root!):

  chown user_id file(ok)/directory(k)
  chgrp group_id file(ok)/directory(k)

• Parancs aktuális csoport váltására (csak olyanra, amihez hozzá tartozunk):

  newgrp group_id

• Lásd még: /etc/passwd.

A jogosultságok módosítása (chmod), default érték beállítása (umask)

bit

setuid

setgid

sticky

user r

user w

user x

group r

group w

group x

other r

other w

other x

beállítás

igen

nem

nem

igen

igen

igen

igen

nem

igen

nem

nem

igen

binárisan

1

0

0

1

1

1

1

0

1

0

0

1

chmod  (ls -l:  rwsr-x--x)

4

7

5

1

umask  (pl. a $HOME/.profile fájlba téve)

0

2

6

chmod 4751 file szimbólikusan: chmod u=rwxs,g=rx,o=x file
chmod u=rw,g=rw,o=rw file helyett chmod ugo=rw file vagy chmod a=rw file is írható
chmod o+r *.htm* mindenkinek olvasási jogot ad az aktuális directoryban levő html fájlokra, az egyéb jogok változatlanok. Ezt csak a szimbolikus megadás tudja.

A Unix fájlrendszer készítői oldalról nézve. (BSD-Unix "fast filesystem", ill. Linux "ext2" fájlrendszer alapján.)

Egy diszk felépítése
boot szektor	boot program	(pl. 8 MB-os) cilinder-csoportok
Egy cilinder-csoport (egymás alatti gyűrűk a diszkfelületeken) felépítése
szuperblokk	cilinder-csoport blokk	i-node tábla	adatblokkok
A szuperblokk főbb adatai (cilinder-csoportonként ismételve)
blokkméret (1/2, 1, 2, 4... KB) fragment méret (1/2, 1/4... blokk)	fájlrendszer méret (blokk)	i-node száma adatblokkok száma	cilinder-csoport felépítését leíró adatok
Egy cilinder-csoport blokk főbb adatai
használt i-node száma használt adatblokkok száma	szabad blokkok száma és helye(bittérkép) szabad i-node-ok száma és helye(bittérkép)		szabad fragmentek száma és helye(bittérkép)
Egy i-node adatai
A fájl tipusa (reg., dir., dev, sym.link, mount, stb.)	user, group, rwx bitek "link"-ek száma	utolsó módosítás, elérés, i-node mód. (32bit = Y2038!)	A fájl hossza (byte-okban) 10+1+1+1 adatblokk-cím
Egy directory egy sorának szerkezete
Fájlnév (max. 14-255 jel) Pl: . .. igen.hosszu.nevu.file		A fájl i-node-jának száma
A 10+1+1+1 blokkcím (A csak bináris nullákat tartalmazó blokk címe is bináris nulla, az adatblokk nem lesz letárolva !)
10 adatblokk címe	egy indirekt cím	egy duplán indirekt cím	egy triplán indirekt cím

Oldja meg a fentiek alapján az alábbi - korábbi félévbeli ZH - feladatot:

Egy Unix (Linux) fájlrendszerben a diszkblokk mérete 1024 byte, 1 diszkblokk címe 4 byte-ot foglal el. Hány adatblokkot foglal el egy 501760 byte méretű fájl? (501760=490x1024) (Adatblokk = az i-node területen kívüli, vagyis az adatterületen levő blokk.) Feltételezzük, hogy a fájl nem tartalmaz 1KB méretű vagy annál nagyobb összefüggő, bináris nullákból álló részt.

Ilyen fájlt Linuxban gyorsan előállíthat pl. a
     yes | head -250880 >file501760
paranccsal, figyelembevéve, hogy a paraméter nélküli "yes" végtelen sok 2 jelből (y+CR) álló sort "termel".

Az alábbi paranccsal ellenőrízheti a számítás helyességét:
      ls -ls file501760

Megjegyzés:

Linux "ext2" fájlrendszerre pontosan igazak az itt leírtak. A régi pandora-n használt IBM Risc fájlrendszer és a panda Linux ext3 fájlrendszere ún. "journaled filesystem". Ez azt jelenti, hogy létrehozáskor vagy módosításkor a fájl változásai (mint a tranzakciók az adatbáziskezelőkben) folyamatosan a diszkre kerülnek (memória "cache" használat nélkül!), egy "journal" (vagy "log") nevű összefüggő terület"-re, majd a változtatás befejezésével a szabad területre kerül a teljes megváltozott fájl nagy része vagy egésze, biztosítva ezzel, hogy ne legyen túl sok, szétszórt területen.

Módosítás közben történt crash (áramkimaradás, stb.) esetén az eredeti fájlból és a journal-ból vissza tudja állítani a rendszer az eredeti vagy a részben megváltozott fájlt. Ez feleslegessé teszi bootolás közben a teljes fájlrendszerre történő konzisztencia vizsgálatot (fsck), ami a mai soktíz vagy többszáz gigabájtos fájlrendszerekre már túlságosan időigényes.

A "journaled" fájlrendszerben nem pontosan az előzőkben leírtak szerint lesz tárolva a fájl. Azon kívül, hogy nem annyira szétszórtan tárolják a fájlt, egyéb (Unixonként más-más) optimalizálásokat is végeznek. Ez jelenti egyes esetekben azt, hogy az adatbáziskezelésben használt formában ("B fákban") tárolják a fájlrendszert, ami - röviden mondva - egy bonyolult, de effektív tartalomjegyzék-tartalom összerendelést tesz lehetővé. Apró optimalizálás pl. az IBM AIX-ben, hogy a kis directoryk tartalma az i-node-ba kerül.

A Red Hat 7.1 és a SuSE 7.0. Linux verziókban "ReiserFS" a fájlrendszer neve (Hans Reiser-ről elnevezve).

Igen nagyméretű, sok bináris nullával kezdődő fájl létrehozása igen kevés diszk-helyen:
  dd of=nagy_file seek=999999   # 999999 db, bináris nulla blokkal kezdődik a fájl.
  alma
  Ctrl+D
  ls -ls nagy_file

  4 -rw-rw-rw- 1 root root 511999493 Oct 27 19:01 nagy_file

Az eredményből látszik, hogy 3 adatblokk lett lefoglalva a 3-szoros indirekt címzésnek és egy további az "alma"-nak. (A fájl mérete viszont 511999493 byte, amiből 999999*512=511999488, ehhez jön még az alma 4 byte-ja és egy sorvége jel.)

Az mkdir, rm, rmdir, ln, mv, dd parancsok.

Hajtsuk végre az alábbi parancs sorozatot:
  rm -r dir1 2>/dev/null
  mkdir dir1
  cd dir1
  echo "alma dio mogyoro" >f1
  chmod 666 f1
  ln f1 f1.h
  chmod 600 f1.h
  sleep 60
  ln -s f1 f1.s
  chmod 664 f1.s
  ls -li

Miért a következő eredményt kapjuk (sikeres) végrehajtás után ?

Mit jelent az  ls -lsi /usr/bin/*grep  parancs outputja ?

A parancsfájl paraméterek ($#, $0, $1, ..., ${10}, ..., $*, $@). A shift parancs.

Aritmetika, a bc parancs (szűrő!).

Pl:	expr 2 \* 2	# 4
	a=2; expr $a \* $a	# 4
	a=2; let b=a*a; echo $b	# 4 (régi shellben nincs "let")
	a=2; b=a+1; echo $b	# Eredmény: "a+1" (string!)
	a=$((a+1))	# Ez is jó
	echo "ibase=16       ABCD" | bc	# Eredmény: 43981 (más parancs is írható így, sokszor egy hiányzó bezáró idézőjel ( " ' ` ) ugyanezt "eredményezi", nehezen érthető parancsfájl hibaként !)
	echo $((0xABCD))	# Ez is "hexadec ---> dec" konverzió
	echo $((16#ABCD))	# Meg ez is (más alappal is megy)

Egyszerű parancsfájlok.

	echo $((0x$1))	# a paraméterként adott hexadec. számot dec.-ra konvertálja
	echo "ibase=16       ${1}" | bc	# hexadec --> dec. konvertáló parancsfájl
	sed "s/<[^>]*>//g" $1 | more	# a param. html-fájl "tartalmát" mutatja (nem mindig jól)
	sort $1 | uniq -c | sort | tail -1	# Egy fájl "leggyakoribb" sora az előfordulási számával

A lehetséges parancs-indítások:

parancs

Új processz indul. Kell export, kell végrehajtási jog.
./parancs - ha a "." nincs a PATH-ban
`pwd`/parancs - az előzőnél jobb rekurzív parancsfájlra

. parancs

Új processz nem indul. Nem kell export, nem kell végrehajtási jog. (Így hajtódik végre Linux gépre történő belépéskor a ~/.profile, ~/.bash_login ill. ~/.bash_profile - növekvő prioritású login fájlok közül a létező legnagyobb prioritású.)

sh parancs

(Az sh helyén más shell is állhat) Új processz indul. Kell export, nem kell végrehajtási jog.

exec parancs

Új processz nem indul. Kell export, kell végrehajtási jog. A shell maga befejeződik!

Példa "$HOME/.profile" fájlra (minden Unixban lehet használni):

stty erase ^H                        # backspace
PS1="# "; export PS1                 # prompt
export PATH=$HOME/sajatbin:$PATH     # saját könyvtár
alias l="ls -ls"; alias lc="ls -Ca"  # alias-ok
export TERM=linux                    # TERMinál beállítás
umask 000                            # default: rwxrwxrwx
#
# Képernyő beállítások
Inverz=`tput rev`;  Bold=`tput bold`
Normal=`tput sgr0`; Del=`tput clear`; Home=`tput home`
# Pl: echo $Del$Home${Inverz}inverz${Normal}normál
#
# History beállítások, (részben) karakteres módra:
export HISTFILESIZE=10000; export HISTSIZE=1000
export HISTCONTROL=akarmi; shopt -s histappend
A=`tty`; export HISTFILE=$HOME/hist/his`basename $A`
trap "echo 'exit at '`date`' ---***--- előtte:' >>$HISTFILE;exit" TERM

A Unix parancsok státusz kimenete (visszatérési értéke; exit status). (0-255; 0="true")

$? környezetváltozó: utolsó parancs státusz kimenete

A test parancs fontosabb opciói (man test részletek):

-e file

True if file exists (directory is lehet!)

-d file

True if file exists and is a directory.

-f file

True if file exists and is a regular file.

-x file

True if file exists and is executable. (van "-r" és "-w" is)

file1 -nt file2

True if file1 is newer (according to modification date) than file2.

string1 = string2

True if the strings are equal.

string1 != string2

True if the strings are not equal.

! expr

True if expr is false.

expr1 -a expr2

True if both expr1 and expr2 are true.

expr1 -o expr2

True if either expr1 or expr2 is true.

arg1 OP arg2

OP is one of -eq (=), -ne (!=), -lt (<), -le (<=), -gt (>), or -ge (>=). (arithmetic binary operators)

Nincs mindenütt "string1 > string2" lehetőség (Többnyire output elirányítása jön létre helyette, nincs ">=" és "<=" sem! De vannak Unixok, ahol "\<" "\>", ... megy stringekre.)

string1 == string2 : régi shell-ben csak az "=" megy.

A shell ciklus- és elágaztató utasításai (for, while, repeat, case, if, break, continue). (Az alábbi help outputban a [] elhagyható parancsrészt jelöl!)

    if c1; then c2; [ elif c3; then c4; ]... [ else c5; ] fi
    for Name [in Words ... ;] do Commands; done     # Name: környezetváltozó
    for ((expr1; expr2; expr3)); do Commands; done  # A legújabb bash tudja
    case Word in [Pattern [| Pattern]...) Commands ;;]... esac
    while Commands; do Commands; done

1. példa: Az alábbi parancsfájl a standard outputra (képernyőre) írja a kapott paramétereket:

   for i in $*
    do
     echo $i
    done

   Ugyanezt megteszi a következő is:

   while [ $# != 0 ]
    do
     echo $1
     shift
    done

   Az alábbi változatok mindegyike abbahagyja a listázást, ha "alma" nevű paramétert talál:

   for i in $*
    do
     case $i in
      alma) echo "Ilyen buta paraméterrel nem foglalkozom"
            break;;
         *) echo $i;;
     esac
    done
   
   while [ $# != 0 ]
    do
     if [ $1 = "alma" ]
      then echo "Ilyen buta paraméterrel nem foglalkozom"; break
     fi
     echo $1
     shift
    done

   Megjegyzések:
   • A case esetében a ")" előtti mintákat a "joker" szabályok szerint illeszti a shell a case utáni szóra, azzal a plusz lehetőséggel, hogy case ágak összevonhatók úgy, hogy "minta1)" és "minta2)" helyett "minta1|minta2)"-t írunk. (Ld. az alábbi példát.)
   • A fenti for i in $* helyett for i in "$@" használata célszerűbb. Utóbbi akkor is jól működik, ha valamelyik paraméterben helyköz van.

2. példa: "IGEN_NEM" nevű parancsfájl, IGEN/NEM beolvasására a billentyűzetről a KERDES környezetváltozóban adott kérdésre: Eredmény: A VALASZ környezetváltozóban "I" vagy "N".

   VALASZ="X"
   while [ $VALASZ = "X" ]
    do
     echo -n $KERDES" "; read valasz
     case $valasz in
      i*|I*) VALASZ="I";exit 0;;
      n*|N*) VALASZ="N";exit 1;;
          *) echo Valaszoljon IGENnel vagy NEMmel !;;
     esac
    done

   Hívás (pl:)
   • KERDES="Szereti Ön a Unixot ?"
     . IGEN_NEM # "." azért, hogy a választ is megkapjuk !
     echo $VALASZ (Ebben az esetben a kék parancsok kihagyandók! (Miért?)
   • KERDES="Szereti Ön a Unixot ?"; export KERDES
     if IGEN_NEM
       then VALASZ="I"
       else VALASZ="N"
     fi
     echo $VALASZ

3. példa: "DILIS" nevű parancsfájl, a paraméterként adott directorynak a benne szereplő fájl(vagy aldir.)-nevek hossza szerint növekvő sorrendben történő listázására. Ha nem adunk meg paramétert, akkor az aktuális directoryra vonatkozzon a parancs.

   Ami új benne:

   • Zárójelezés:
     • { p1;p2;...; } : az adott shellnek csoportosít (a végén ;)
     • ( p1;p2;... ) : új shell (új processz) indul, "cd", környezetváltozó def., "shift" lokális lesz.
   • Parancs pár második tagjának feltételes végrehajtása:

     parancs1 && parancs2	=	if parancs1; then parancs2; fi
     parancs1 || parancs2	=	if parancs1; then :; else parancs2; fi

     • p1 && p2 # p2 akkor hajtódik végre, ha p1 sikerült (státusza 0)
     • p1 || p2 # p2 akkor hajtódik végre, ha p1 nem sikerült (státusza 1)

   case $# in
    1) cd $1 2>/dev/null || { echo Nem sikerült a \"cd $1\" >&2; exit 1; };;
    0) ;;
    *) echo Legfeljebb egy parametere lehet a parancsnak ! >&2; exit 1;;
   esac
   ( for i in *
      do
       echo "`echo $i | wc -c` $i"  # " nélkül elvesznek a vezető helyközök !
      done ) | sort >/tmp/xyz
   for i in `cut -c9- /tmp/xyz`     # már csak a nevek kellenek
    do
     if [ -d $i ]                   # ha directory
      then ls -ld $i                #   nem kell a belseje
      else ls -l $i                 # (Ehelyett a 4 sor helyett
     fi                             #   "ls -ld $i" is elég lenne)
    done
   rm /tmp/xyz 

   A kék sorok helyett ezt is írhatjuk:

       echo `echo $i | wc -c` $i
      done ) | sort -n >/tmp/xyz
   for i in `cut -d" " -f2 /tmp/xyz`

   Kérdés: Mit csinál az alábbi parancs ?

   . DILIS log out 

4. példa: Az alábbi rekurzív parancsfájl paramétere egy directory. Erre, és a belőle kiinduló struktúra fájljaira és (al)directoryjaira a publikus anyagokra szokásos jogosultságokat állítja be:

   chmod 711 "$1"
   cd "$1"
   for i in *
    do
     if [ -d "$i" ]
      then $0 "$i"
      else chmod 644 "$i"
     fi
    done

   Megjegyzés: A rekurzió ($0) nem működik, ha relatív névvel hívjuk, mert a "cd" elállítja a munkadirectoryt. Megoldás (Linux):
   • első sor: PRG=`readlink -f $0` # A script teljes útvonala kerül PRG-be.
   • rekurzió: then $PRG "$i"

   Nagy struktúrára időigényes az ilyen fájlonkénti beállítás. Az alábbi "csúnyább" megoldás először az egész struktúrára (rekurzív chmod-dal) 644-es jogokat állít be, aztán a directoryra és az aldirectorykra a "find"-ot használva 711-et. (Ez a megoldás nagyságrenddel - sok fájl, kevés directory esetén nagyságrendekkel - gyorsabb lehet a megelőzőnél.)

   chmod -R 644 $1
   chmod 711 $1
   find $1 -type d -exec chmod 711 {} \;

   Megjegyzés: A "find"-ban a "-exec" utáni utasítás minden, a find által talált fájlra/directoryra végrehajtódik. Mivel itt két utasítás (a "find" és a "-exec" utáni) keveredik, az utóbbinak a végét egy olyan pontosvesszővel kell jelezni, amit a shell továbbad a "find"-nak. A "-exec" utáni utasítás másik különlegessége az, hogy benne a "find" által talált fájlnévre kapcsos zárójelpárral hivatkozhatunk. (A script gyors, de a pandora-n és egyes Linuxokon nem működik, mert azok komolyan veszik, hogy letiltottuk az aldirectorykra a belépési jogunkat.)

   chmod -R 711 $1
   find $1 -type f -exec chmod 644 {} \;

   (Ez is elég gyors, és mindenütt is működik.)

5. példa: Egy kidolgozott gyakorló feladat egyszerűsített változata.

A cmp, wc, diff parancsok. A diff igen fontos a nagy projektek (program, könyv) "verzió kezelés"-ében.

A "for ((expr1; expr2; expr3)); do Commands; done" bash szerkezet ekvivalens az alábbival.

     ((expr1))
     while ((expr2))
       do
         Commands
         ((expr3))
       done

Itt
    ((expr))
egyenértékű azzal, hogy
    let "expr"

expr kiértékelés:

• környezetváltozók elé nem kell $ jel
• "c" műveletek (pl. i++, i<j, i==j )
• Nulla, mint eredmény státusz kimenete 1, minden másé 0. (!!) Pl. (próbálja ki!):

  ((2*1)); echo $?
  ((2*0)); echo $?

1. példa: Az alábbi parancsok mindegyike a háromjegyű számokat írja a standard outputra:

   for ((i=100;i<1000;i++)); do echo $i; done
   
   i=100; for ((;i<1000;)); do echo $i; let i++; done  # mutatja, mi hova való
   
   i=100; for ((;i<1000;)); do echo $i; ((i++)); done  # és hogyan lehet még írni
   
   for i in `seq 100 999`; do echo $i; done            # csak Linuxban van "seq"
   
   echo {1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9} | tr " " "\012"

2. példa: Sok részletre, és az indirekt változó kiértékelésre is példa a következő parancsfájl:

   for ((i=1,j=$#;i<=$#;ii=i++,jj=--j))
    do
     echo -n i=$i j=$j ii=$ii jj=$jj" "
     eval echo \$$j      # "echo $$j" vagy "echo ${$j}" nem megy!
                         # legújabb bash-ban: "echo ${!j}" megy!
    done

   Ha ezt meghívjuk "alma dio mogyoro" paraméterekkel, akkor az eredmény:

   i=1 j=3 ii= jj= mogyoro
   i=2 j=2 ii=1 jj=2 dio
   i=3 j=1 ii=2 jj=1 alma

Reguláris kifejezések. (rugalmas string megadásra)

   *             # akárhány (0,1,2...) megelőző jel
   .             # egy akármilyen jel
   .*            # akárhány (0,1,2...) akármilyen jel
   [aeiouAEIOU]  # egy jel a felsoroltak közül (angol ABC magánhangzó)
   [^a-z]        # egy jel a fel nem soroltak közül (nem kisbetű)
   ^reg_kif      # reg. kifejezés a sor elején
   reg_kif$      # reg. kifejezés a sor végén
   \(reg_kif\)   # kijelölt reg. kif. (hivatkozás: \1 \2 ...)

 Kiterjesztett reg. kif (csak egrep):
   +             # akárhány (1,2...) megelőző jel
   .+            # akárhány (1,2...) akármilyen jel
   ?             # 0 vagy 1 megelőző jel
   \{n\}         # pontosan "n" db megelőző jel
   \{m,n\}       # min. "m", max. "n" db megelőző jel
   reg_k1|reg_k2 # "reg_k1" vagy "reg_k2" valamelyike előfordul
   (reg_kif)     # csoportosítás (pl. "(bla)\{2,\}" = legalább "blabla")

Megjegyzés:

Ha a shell-en "megy keresztül" a reg. kif., akkor esetenként célszerű ("[", "*" esetén), máskor kötelező ("\", "|" esetén) idézőjelbe (egyszeresbe vagy kétszeresbe) tenni, hogy a shell ne "bántsa" ill. értse félre a beírtakat.

Példák:

  grep "procedure.*proc1"         # korábbi példa egyetlen paranccsal
  
  sed "s/<[^>]*>//g
       s/<[^>]*$//
       s/^[^<]*>//
       s/&aacute;/á/g
       s/&eacute;/é/g
       s/&iacute;/í/g
       s/&oacute;/ó/g
       s/&uacute;/ú/g
       s/&Aacute;/Á/g
       ...
       s/&ouml;/ö/g
       s/&Ouml;/Ö/g
       s/&uuml;/ü/g
       s/&Uuml;/Ü/g
       s/&otilde;/ő/g
       s/&Otilde;/Ő/g
       s/&ucirc;/ű/g
       s/&Ucirc;/Ű/g
       s/&amp;/\&/g
       s/&nbsp;/ /g
       s/&lt;/</g
       s/&gt;/>/g" $1 | more  # a param. html-fájlt mutatja
                                     # a paramétersorok végén ne maradjon helyköz!
                                          
  cat <<ITT_A_VEGE >/tmp/sedparam
  s/<[^>]*>//g
  s/<[^>]*$//
  ...
  s/&gt;/>/g
  ITT_A_VEGE
  sed -f /tmp/sedparam $1 | less       # Ugyanaz, mint az előző
                                          
  grep "^\([^ ]\).\1" eloadas.htm      # Sorok, amikre: 1.jel = 3. jel != helyköz

  sed "s/\([^ ]*\) \(.*\)/\2 \1/"      # vezetéknév - keresztnév csere

  man test | sed "s/.^H//g" >man.test  # "man" lap editorfájlba, olvashatóan

Az fgrep, grep, egrep parancsok.

Reguláris kifejezések használatára - és más dolgokra is - nagyobb lélegzetű, Linux X-Windows-ban futtatandó kidolgozott gyakorló feladatot is talál.

Az eddig szerepeltek közül sok mindenre példa a következő parancsfájl, ami "Progkor" Subject-tel levelet ír a pandora gépen mindenkinek, aki a "Progkör" tárgyra jelentkezett: Az itt kékkel írt levélbe egyedi megszólítások és honlapcímek kerülnek.

  jelentkezes --ta=csa --hi=progkor --li | grep "^ *[1-9]" | sed "s/^ *[^ ]* //" | while read
   do
    # A REPLY változóban "Név (user_id)" alakú sor van.
    NEV=`echo "$REPLY" | sed "s/ (.*//"`
    Uid=`echo "$REPLY" | sed "s/.*(//" | sed "s/)//"`
    echo "$NEV"       # így látom, hol tart a levélküldés
    # Ha a köv. parancsban az ITTAVEGE "" jelek között állna,
    #    akkor a levélszövegbe nem lenne a $NEV(név) és $Uid(user_id)
    #    aktuális értéke behelyettesítve
    # Ha az ITTAVEGE előtt - jel állna, akkor az ITTAVEGE sor
    #    kezdődhetne tabulátorjelekkel is, így viszont az
    #    ITTAVEGE szövegnek sor elején kell állnia
    mailx -s "Progkor" $Uid@inf.elte.hu <<ITTAVEGE
    Kedves $NEV !
  
    Jelentkezett a Programozasi Kornyezet targyra.
  
    A targy honlapjai: http://progkor.inf.elte.hu
                       http://people.inf.elte.hu/csa
  
    Ne feledkezzen meg  a kiirt beadando feladatok hataridore torteno
    elkesziteserol. ZH-t (maj. 8-an ill. 15-en) csak az irhat (vagyis
    a targyat ebben a felevben az vegezheti el), akinek a honlapja es
    Unix beadandoi hataridore elkeszulnek ill. be lesznek kuldve.

    A honlapjanak apr. 24-ig a pandora-n, az alabbi cimen kell lenni:
                       http://people.inf.elte.hu/$Uid

    Csizmazia Albert
  ITTAVEGE
    sleep 1               # hogy a mailx győzze a munkát
   done

Shell function-ök (export -f). P1, P1A, P2 shell scriptek (az aktuális directoryban):

P1
  echo 1. PARAMETER: $1
  echo 2. PARAMETER: $2
  . ./P1A $1 $2
  . ./P1A 12345 9876

P2
  # a definíció előzze meg a hívást
  function P2A ()
  # "function" és "()" egyike elég!
  { let local osszeg=$1+$2
    # az osszeg csak itt érvényes
    echo $1+$2=$osszeg
  }
  echo 1. PARAMETER: $1
  echo 2. PARAMETER: $2
  P2A $1 $2
  P2A 12345 9876

P1A
  let osszeg=$1+$2
  echo $1+$2=$osszeg

A
    ./P1 2005 1
    ./P2 2005 1
 hívások mindegyike azt írja ki (sor elejére), hogy:
    1. PARAMETER: 2005
    2. PARAMETER: 1
    2005+1=2006
    12345+9876=22221

Az awk program(ozási nyelv). (a=Aho, w=Weinberger, k=Kerninghan.)

Parancs forma:

awk awk_program input_fájl(ok)
awk -f awk_programot_tartalmazó_fájl input_fájl(ok)

Egy awk program struktogramja és kódja. A program 1, 2, 3 részei közül egyet is elég megadni.
Kódolási szabályok
Néhány további szabály
Változók: Nincs deklaráció, kezdőértékadás (0 vagy ""), típus (tartalomtól függően numerikus vagy string). $0; $1, $2, ... $NF : az aktuális input rekord; ill. annak a mezői. FS : mezőelválasztó (reguláris kifejezés; default: helyköz(ök); lehet üres, ekkor jelenként bont) FNR : a feldolgozott rekord sorszáma Tömbök: Egydimenziós, asszociatív (stringgel indexelt) tömbök. De: i="A"; j="B"; k="C"; x[i j k]="alma dio"     ugyanaz, mint: x["ABC"]="alma dio" Értékadás: a=a+1; a+=1; a++ $3=$1-($2+3*$4) ezer=10E2 darab["szeptember"]=darab["szeptember"]+1 string3="alma" "dio" "mogyoro"; string3="alma dio mogyoro" Relációk: = =   !=   <   <=   >   >= Logikai műveletek: && (és)   || (vagy)   ! (nem) Kiíratás: print kifejezések     Pl.(utolsó szó): print $NF printf "formátum_és_konstansok_keverten", kifejezések     (minden kifejezéshez 1 formátum)     Pl(nl): printf "%6d %s\n", FNR, $0 printf ... >"/dev/stderr" # fájlba (std. error-ra) írás Megjegyzés: sok nyelv (pl. c, python, php, perl) tartalmaz ugyanilyen printf parancsot, sőt a bash is, utóbbiban az awk-tól annyi az eltérés, hogy vessző helyett helyközzel kell tagolni az információkat. (Hosszabb leírás pl. itt található.) Formátumok: %s = string, %d vagy %i = egész szám, %f = szám tizedes ponttal, %e = lebegőpontos szám (stb) Ha a % és a formátum jel között "-" jel áll, balra illesztés történik. A % és a formátum jel között hosszmegadás is állhat: pl. %30s, %6d, %9.2f (9 hosszban, 2 tizedesre). A % és a formátum jel közötti "0" jel esetén a (vezető) helyközök helyére nulla kerül: pl. %02ds a 3-at 03-ként írja ki. Formázó konstansok: \n = újsor, \t=tabulátor, \f=form-feed(nyomtatón új lap), stb. Standard függvények: sqrt(2) = négyzetgyök gsub(reg_kifejezés, helyettesítő_string, string) = string-ben reg.kifejezés előfordulásait helyettesítő stringre cseréli length(string) = string hosszát adja (a szélén levő helyközökkel együtt) substr(string, kezdőindex, jelek_száma) = string kezdőindextől kezdődő (adott hosszúságú) részét adja tolower(string) = string-et kisbetűsre konvertál Saját függvények: # definíció function plusz(a,b) { c=a+b   return c } # használat { a=plusz(2,2)   b=plusz(a,3)   print b # 7-et ír ki } Egyéb: exit 1 break    # paraméter nélkül, ciklusban continue # paraméter nélkül, ciklusban next     # vedd a köv. input rekordot További részleteket a man paranccsal (Linuxban esetenként man gawk) tudhat meg.

1. Irjunk szűrőt, ami az input szöveg főátlójában levő jeleket írja ki, egymás alá:

       awk '{print substr($0,FNR,1}' "$@"

   Vagy:

       awk -F "" '{print $FNR}' "$@"

   Vagy:

       awk 'BEGIN {FS=""} {print $FNR}' "$@"

   Ugyanez, "átlósan" kiírva:

       awk '{ for (i=1;i<FNR;i++) printf " "
              print substr($0,FNR,1)
            }' "$@"

   Megoldás awk nélkül (minta, soronkénti feldolgozásra; ld. még help read vagy man read):

       i=1
       cat "$@" |\
        while read
         do
          j=1
          while [ $j -lt $i ]
           do
            echo -n " "
            let j=j+1
           done
          echo "$REPLY" | cut -c$i
          let i=i+1
         done

   Megjegyzés: A "$@" formájú paraméterhivatkozás (egy szűrőparancsba írva) alkalmas arra, hogy a parancsfájl helyközt tartalmazó paramétereket is jól kezeljen, és maga is szűrő legyen (vagyis a standard inputról dolgozzon, ha nem kap paramétert, és a kapott fájlokból, ha kapott paramétert.)

   Magyarázza meg (help read), miért nem azonos az alábbi két sor eredménye:

       echo "  alma dio "|while read; do echo /"$REPLY"/; done
       echo "  alma dio "|while read sor; do echo /"$sor"/; done

2. Az "env" parancs awk-val megvalósítva (az ENVIRON - előredefiniált - tömbre):

       awk 'BEGIN { for (x in ENVIRON) printf "%s=%s\n", x, ENVIRON[x] }'

3. A példa azt mutatja, hogyan lehet egy parancsfájl paramétereit az awk-nak átadni (vigyázat: a $1 scriptparaméter nem keverendő az awk-beli - az aktuális sor első "mező"-jét jelölő - $1-el !) :
   Az alábbi négy script mindegyike kiirja a 3. paraméterként (vagy a standard inputról) kapott fájl 1. és 2. paraméterként kapott (sorszámú) oszlopait, egymástól egy # jellel elválasztva:

       awk -v o1=$1 -v o2=$2 '{ printf "%s#%s\n", $o1, $o2 }' $3
   
       awk '{ printf "%s#%s\n", $o1, $o2 }' o1=$1 o2=$2 $3
   
       awk "{ printf \"%s#%s\n\", \$$1, \$$2 }" $3
   
       cat <<EDDIG >/tmp/awk1
       { printf "%s#%s\n", \$$1, \$$2 }
       EDDIG
       awk -f /tmp/awk1 $3
   
       p1=$1; export p1
       p2=$2; export p2
       awk '{ printf "%s#%s\n", $ENVIRON["p1"], $ENVIRON["p2"] }' $3

   Megjegyzések:

   1. Ha a fenti parancsfájlok valamelyikének OSZLOPOK a neve, akkor pl. a

      sed "s/:/ /g" /etc/passwd | OSZLOPOK 1 5

      parancs a Unix userek azonosítóját és vezetéknevét listázza.
       
   2. Konkrétan ugyanezt (teljes névvel) awk-val egyszerűbben így érhetnénk el:

      awk 'BEGIN {FS=":"} { printf "%s#%s\n", $1, $5 }' /etc/passwd

      Mivel ebben az esetben nem akarjuk, hogy a shell helyettesítéseket végezzen az awk programban, sima aposztróf(') jelek közé írtuk azt. (Az utóbbi sor példa awk-beli BEGIN használatára is.)

4. "awk" programokra különböző nehézségű további példákat az alábbi, kidolgozott "gyakorló feladatokban" talál: XXIII. 37. 38. 40.

Szignál küldés és kezelés Unixban. A ps, kill és trap parancsok.

A ps parancs eredménye: (STAT: R=fut(running), S=vár(sleeping))

  PID TTY STAT  TIME COMMAND

    1  ?  S     0:01 init [3] 
  ...
   79  1  S     0:00 -bash 
   80  2  S     0:00 -bash 
   81  3  S     0:00 -bash 
   83  5  S     0:00 -bash 
   84  6  S     0:00 /sbin/agetty 38400 tty6 linux 
   85  7  S     0:00 /sbin/agetty 38400 tty7 linux 
   86  8  S     0:00 -bash 
  225  8  S     0:00 xinit /root/.xinitrc.w95 
  ...
  855  4  S     0:00 -bash 
  923  3  S     0:00 vi floppy_u.html 
  926  4  R     0:00 ps

A vi "kilövése:

kill 923     # = kill -TERM 923

A tty4-en futó bash "kilövése:

kill -KILL 855     # = kill -9 855 ("kill 855" nem elég)

A trap -l parancs eredménye:

 0) EXIT          1) SIGHUP    2) SIGINT      3) SIGQUIT
 4) SIGILL        5) SIGTRAP   6) SIGIOT      7) SIGBUS
 8) SIGFPE        9) SIGKILL  10) SIGUSR1    11) SIGSEGV
12) SIGUSR2      13) SIGPIPE  14) SIGALRM    15) SIGTERM
16) SIGJUNK(16)  17) SIGCHLD  18) SIGCONT    19) SIGSTOP
20) SIGTSTP      21) SIGTTIN  22) SIGTTOU    23) SIGURG
24) SIGXCPU      25) SIGXFSZ  26) SIGVTALRM  27) SIGPROF
28) SIGWINCH     29) SIGIO    30) SIGPWR     31) SIGJUNK(31)

Pl:

trap "tput bel; echo Ne ütögesd a Ctrl+C-t !" INT
...
trap INT      # eredeti állapot
...
trap "" INT   # letiltja a Ctrl+C-t

trap "echo Ne felejtsd el ...;read" EXIT

trap "rm /tmp/tmp1 2>/dev/null;exit" INT
... >/tmp/tmp1
...
# Ha CtrlC miatt nem jut idáig a parancsfájl,
# akkor is törölve lesz a /tmp/tmp1.
rm /tmp/tmp1

trap "rm /tmp/tmp1 2>/dev/null" EXIT
... >/tmp/tmp1
...
# Ez a megoldás nem minden Unix-ban működik.

A Unix boot-olás. Az init parancs. Linux: ps -x | head -2:

   PID TTY STAT TIME COMMAND
     1  ?  SW   0:02 (init)

A shutdown, init 0 és haltsys parancsok. Mi van a "CtrlAltDel" mögött a Linuxban ?

A /etc/inittab konfig. fájl:

# id:runlevels:action:process
# azonosító:futási szint:mikor/hogyan:parancs
#
# Default runlevel.
id:3:initdefault:

# System initialization (runs when system boots).
si:S:sysinit:/etc/rc.d/rc.S

# Script to run when going single user (runlevel 1).
su:1S:wait:/etc/rc.d/rc.K

# Script to run when going multi user.
rc:23456:wait:/etc/rc.d/rc.M

# What to do at the "Three Finger Salute".
ca::ctrlaltdel:/sbin/shutdown -t5 -rfn now

# Runlevel 0 halts the system.
l0:0:wait:/etc/rc.d/rc.0

# Runlevel 6 reboots the system.
l6:6:wait:/etc/rc.d/rc.6

# What to do when power fails (shutdown to single user).
pf::powerfail:/sbin/shutdown -f +5 "THE POWER IS FAILING"

# If power is back before shutdown, cancel the running shutdown.
pg:0123456:powerokwait:/sbin/shutdown -c "THE POWER IS BACK"

# If power comes back in single user mode, return to multi user mode.
ps:S:powerokwait:/sbin/init 5

# The getties in multi user mode on consoles an serial lines.
#
# NOTE NOTE NOTE adjust this to your getty or you will not be
#                able to login !!
#
# Note: for 'agetty' you use linespeed, line.
# for 'getty_ps' you use line, linespeed and also use 'gettydefs'
c1:1235:respawn:/sbin/agetty 38400 tty1 linux
c2:1235:respawn:/sbin/agetty 38400 tty2 linux
c3:1235:respawn:/sbin/agetty 38400 tty3 linux
c4:1235:respawn:/sbin/agetty 38400 tty4 linux
c5:1235:respawn:/sbin/agetty 38400 tty5 linux
c6:12345:respawn:/sbin/agetty 38400 tty6 linux
# Next 2 lines are new:
c7:1235:respawn:/sbin/agetty 38400 tty7 linux
c8:1235:respawn:/sbin/agetty 38400 tty8 linux

# End of /etc/inittab

A boot-olás során végrehajtott parancsokat részletesen az inittab-ban hivatkozott - többnyire hosszú, bonyolult - scriptekben találjuk. Néhány jellemző részlet (egy Slackware Linux) installációból külön lapon látható.

A unix mount-olás. A /etc/fstab (vagy máshol /etc/vfstab) fájl. Pl:

device   mount_point  type   mount_options dump? fsck? (1=yes)

/dev/hda2    /        ext2        defaults   1     1
/dev/hdb2    /u       sysv        defaults   1     1
/dev/hdb4    /u2      ext2        defaults   1     1
/dev/hdb1    /j       ext2        defaults   1     1
/dev/hda3    /dosc    msdos       defaults   1     1
/dev/hdb3    /dosd    vfat        defaults   1     1
/dev/hda1    /w95     vfat        defaults   1     1
none         /proc    proc        defaults   1     1

A /etc/mtab fájl az alábbi "mount"-olások után:
    mount -t vfat /dev/hdc4 /zip       # ZIP drive
    mount -t msdos /dev/fd0 /mnt       # DOS floppy
    more /etc/mtab

/dev/hda2 / ext2 rw 1 1
/dev/hdb2 /u sysv rw 1 1
/dev/hdb4 /u2 ext2 rw 1 1
/dev/hdb1 /j ext2 rw 1 1
/dev/hda3 /dosc msdos rw 1 1
/dev/hdb3 /dosd vfat rw 1 1
/dev/hda1 /w95 vfat rw 1 1
none /proc proc rw 1 1
/dev/hdc4 /zip vfat rw 0 0
/dev/fd0 /mnt msdos rw 0 0

A df parancs eredménye (fájlrendszer infó):

Filesystem      1024-blocks  Used Available Capacity Mounted on

/dev/hda2          546401  477596    40581     92%   /
/dev/hdb2          354745  339972    14773     96%   /u
/dev/hdb4          446453  349570    73825     83%   /u2
/dev/hdb1          321516  287286    17624     94%   /j
/dev/hda3          320368  318800     1568    100%   /dosc
/dev/hdb3          515288  511160     4128     99%   /dosd
/dev/hda1          451344  444432     6912     98%   /w95
/dev/hdc4           98078   70878    27200     72%   /zip
/dev/fd0             1423     531      892     37%   /mnt

A more /proc/filesystems Linux parancs eredménye (a Linux által "ismert" fájlrendszerek):

      ext2
      minix
      msdos
      vfat
nodev proc
nodev nfs
      iso9660
      xenix
      sysv
      coherent

minix fájlrendszer létrehozása floppyn:
    mkfs -t minix /dev/fd0H1440 1440

A minix fájlrendszer fel-mountolása "readonly" módon, majd ezt követő mount eredménye:
    mount -r /dev/fd0 /mnt
    mount

/dev/hda2 on / type ext2 (rw)
/dev/hdb2 on /u type sysv (rw)
/dev/hdb4 on /u2 type ext2 (rw)
/dev/hdb1 on /j type ext2 (rw)
/dev/hda3 on /dosc type msdos (rw)
/dev/hdb3 on /dosd type vfat (rw)
/dev/hda1 on /w95 type vfat (rw)
none on /proc type proc (rw)
/dev/fd0 on /mnt type minix (ro)

Rendszeresen futtatandó feladatok:

A crontab parancs.
    -rws--x--x 1 root bin 9236 May 23 1996 /usr/bin/crontab

A cron daemon és a crontab táblázat (user-enként). (pl. /var/spool/cron/crontabs/csa)

#perc óra nap hónap hét_napja parancs
0,10,20,30,40,50 * * * * /usr/lib/atrun >/dev/null 2>&1 # 10 percenként
0 0 1 * mon-fri /home/lajos/ment # munkanapokon és minden 1-én, éjfélkor
0 23-7/2,12 * * * /home/lajos/p1 # 23-tól reggel 7-ig 2 óránként és délben
* * * * * touch $HOME/na_latod_fut_a_cron # teszt

A crontab lehetőségei (csa user számára):

crontab ~/sajat_tab    # = cp ~/sajat_tab /var/spool/cron/crontabs/csa

crontab -l >~/sajat_tab# = cp /var/spool/cron/crontabs/csa ~/sajat_tab

crontab -r  # = rm /var/spool/cron/crontabs/csa

crontab -e  # = vi /var/spool/cron/crontabs/csa (nem minden Unix-ban!)

1. /etc/cron.allow vagy /var/spool/cron/allow:   user_id-k, akiknek megengedett;
2. /etc/cron.deny vagy /var/spool/cron/deny:   user_id-k, akiknek nem megengedett;

Linuxban további crontab directoryk és fájlok:

• /etc/crontab fájl. Sorainak szerkezete: "mikor ki mit".
• /etc/cron.d directory.
• /etc/cron.hourly directory.
• /etc/cron.daily directory.
• /etc/cron.weekly directory.
• /etc/cron.monthly directory.

További parancsok:

umount /dev/fd0

lemountolás

umount /mnt

Ugyanaz, mint az előző

comm f1 f2

3-oszlopos lista: csk f1-ben, csak f2-ben ill. mindkettőben meglevő fájlokról. (f1 és f2 legyen rendezett)

du

Directory blokkjainak száma

who am I

Ki jelentkezett be a terminálon

who

Ki dolgozik éppen a gépen

last

Ki dolgozik ill. dolgozott a gépen

lastlog

Ki dolgozott már a gépen

finger

Ki dolgozik éppen a gépen

finger -l userid

User info

uuencode/uudecode

(Bináris) fájl át-/vissza-kódolása ASCII formába

hostname

A gép neve

tty

A terminál (device)neve

touch *.c

File dátum frissítes (file létrehozás, ha nem volt)

basename /usr/doc/faq/howto/README.gz

README.gz

dirname /usr/doc/faq/howto/README.gz

/usr/doc/faq/howto

stty erase ^H

terminál (backspace) beállítás

fsck

Diszk (fájlrendszer) ellenőrzés

mkuser ...

Userid létrehozás

adduser ...

Userid létrehozás (Linux)

at 2400 -m -f parancsfile

Köv. éjfélkor indítja a parancsfájlt, az eredményről "mail"-t kapunk. (Fájlok: /etc/at.allow, /etc/at.deny)

zip, gzip, compress, pack

Fájl tömörítés.

nohup parancs

A "parancs" kijelentkezés után (background) tovább fut

nice parancs

A "parancs" csökkentett priorítással fut

ulimit ...

"ulimit -a" megmutatja a felhasználó rendelkezésére álló rendszer erőforrások korlátait. (Pl. html cgi user részére korlátozva az erőforrásokat, védhetjük a rendszerünket olyan rosszindulatú "kimerítés" ellen, ami óriási html csomagok ráküldésével állhatna elő.)

Néhány további téma röviden.

Néhány eddig nem vagy alig érintett Unix ismeretre utalok röviden az alábbiakban. Ez legfeljebb arra elég, hogy tudják, minek kell bizonyos problémák, feladatok esetén részletesebben utánanézni.

• A sed néhány további lehetősége. ("d" parancs, címek, címtartományok kijelőlése, "cimke" és "goto".)
  ("sed" használatára példákat az alábbi, kidolgozott "gyakorló feladatokban" talál: 37. 39. 40.)
• A set parancs az összes környezetváltozót listázza. Különböző opciókkal egész mást csinál. Néhány fontosabb ezek közül: A "set -e" parancsot követően az első hibás (nem 0 státuszkimenetű) parancs után a shell befejezi a munkát. (Igy "nem hibatűrő" parancsfájlok kezdődjenek.) A "set -o vi" parancs (bash esetén felesleges!) azt eredményezi, hogy a "visszahozott" korábbi parancssorok a "vi" soreditálási szabályai szerint módosíthatók. A "set -x" parancsot követően minden végrehajtott parancsról információkat ír a bash a standard outputra. (A parancsfájl hibakeresést segítheti a dolog, "set -" hatástalanítja ezt az "execution trace" beállítást.) Ha a "set" parancs argumentumokat (nem - jellel kezdődő paramétereket) kap, azok a "set"-et követően a pozícionális paraméterek ($1, $2, ...) helyébe lépnek.
• Az apropos parancs megmondja egy stringről, hogy melyik "man" lapok NAME részében fordul elő.
• A terminfo (régebben termcap) egy olyan "képernyő adatbázis", amiben rengeteg termináltipusra megadják, hogy milyen jelsorozatokat kell küldeni a terminálra bizonyos hatások (pl. pozícionálás, törlés, szín vagy fényesség) beállítására. Ugyanitt adható meg pl. az is, hogy milyen billentyűkombináció jelenti az F1, F2, ... funkcióbillentyűket.
  A termcap csak "source" formában létezik, a terminfo-hoz is tartozik olvasható "source", de azt a "tic" paranccsal le kell fordítani. A fordításnak a (többnyire a /usr/lib/terminfo aldirectoryjaiban tárolt). eredményét használják a Unix alatt futó programok. A terminfo ill. termcap "source" fájlok megértése és készítése fáradságos, időigényes feladat. (A termcap "source" a captoinfo paranccsal alakítható át terminfo "source" formába.)
• A tput paranccsal tudunk shell szinten "képernyőfüggetlenül" írni képernyővezérlő parancsokat. Ezekben a terminál-hatás "terminfo"-s nevét adjuk meg paraméterül, eredményül pedig a hatást kiváltó, terminálfüggő jelsorozatot kapjuk. Ehhez a terminál tipusát a TERM környezetváltozóban be kell állítani, amit maga a Unix rendszer - többnyire jól - megtesz. A lehetőségek rugalmassága azzal is növelhető, hogy a /usr/lib/terminfo helyett más adatbázist is használhatunk, ha a saját terminfo directory nevét betesszük az exportált TERMINFO nevű környezetváltozóba.
  Néhány példa a tput használatára:

        tput clear             # törli a képernyőt
        tput bold              # fényesebb betűket ír
        tput rev               # inverzbe megy át
        tput blink             # villogó betűket ír
        tput setb n            # háttérszín legyen "n" (n=0,1,2,3,4,5,6,7; csak Linux)
        tput setf n            # betűszín legyen "n" (n=0,1,2,3,4,5,6,7; csak Linux)
        tput sgr0              # újra normál betűket és színeket ír
        tput bel               # sípoló hangot ad
        tput cup 12 40         # a 12. sor 40. oszlopára pozícionál
        tput reset             # esetleg visszaállítható vele az "elrontott képernyő"

• A billentyűzet átkonfigurálására Unixonként egészen más fájlokba kell belenyúlni, az ezt aktivizáló parancsok sem egységesek. A "telnet" maga is "belejátszik" abba, hogy mit kap a Unix egy billentyű leütése után. Linuxhoz a linux.tty, SCO-Unixhoz a sco.tty letölthető fájlok segíthetnek annak, aki erre a fáradságos munkára kényszerül.
• Ugyanennyire nem egységes a belső kódokat a képernyőn megjelenítő fontkészlet kiválasztása sem. Linuxban a setfont parancs szolgál erre a célra. (Paraméter nélkül használva arra is jó lehet, hogy a "grafikus módba átment" terminált visszaállítsuk karakteres módba.)
• Minden Unix tartalmaz legalább néhány olyan parancsot, amivel DOS floppy-ra alapvető feladatokat végre lehet hajtani. A Linuxban legalább az mcopy és mdir parancsokat (a lovardában pl.) célszerű ismerni. (Van hozzájuk "man", de azt ismerve, hogy "m" betű nélküli DOS megfelelőjük mire való, "man" nélkül is kitalálható a használatuk.) Az összes többi Unixban doscp ill. dosdir felel meg az előbbi két parancsnak, és doscat, dosls, dosmkdir, dosrmdir, dosformat szokott lenni a további teljes választék.(A parancsok nagyjából azt tudják, amit a "dos" előtag nélküli Unix ill. DOS megfelelőjük.)