Előadás emlékeztető - UNIX

Több oldalról közelíthető a Unix (a megismerés szempontjából).

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").

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,9ls `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 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.

Kiegészítő jogosultságok
setuid bitsetgid bitsticky bit
setuid bit (rwsrwxrwx)
programfájl a fájl jogaival fut (nem a futtató jogaival!)
setgid bit (rwxrwsrwx)
programfájl a fájl csoportjának jogaival fut
sticky bit (rwxrwxrwt)
(program)fájl: a memóriában maraddirectory: "rwx" directoryban csak saját fájl/aldirectory módosítható/törölhető.
A 3x3 rwx (read, write, execute) jogosultság
tulajdonos (user)a tulajdonos csoport (group)többiek (other)
Fájlra
r: olvasásw: írás (módosítás)x: végrehajtás
Directoryra
r: olvasásw: írás (módosítás)
új fájl/aldir. felvétele a directoryba, fájl/aldir. törlése a directoryból
x: a directory alatti "részfa" elérése
Linux ext2/ext3: további 8-14 jogosultság kezelhető a chattr (root, vagy setuid), listázható az lsattr paranccsal.
Ezekkel egy fájl pl. módosíthatatlanná, törölhetetlenné tehető még a root számára is, a "hagyományos" jogoktól függetlenül.
"Alakul" a dolog. (A pandora-n pl. - 2004 elején - 9 jogról szól a man chattr, de 14-et listáz az lsattr.)
Egyes Unixokban (pl. IBM AIX) acl kezdetű parancsokkal egy-egy fájlra user-enként szabályozhatók a jogosultságok.

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 -lrwsr-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 szektorboot program(pl. 8 MB-os) cilinder-csoportok
Egy cilinder-csoport (egymás alatti gyűrűk a diszkfelületeken) felépítése
szuperblokkcilinder-csoport blokki-node táblaadatblokkok
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.fileA 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ímeegy indirekt címegy duplán indirekt címegy 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 ?

inode számtipus + rwxlinktulaj.csop.byteut. mód. dát.fájlnév
101173-rw-rw-r-- 2csa users 17Oct 29 15:25f1
101173-rw-rw-r-- 2csa users 17Oct 29 15:25f1.h
101174lrwxrwxrwx 1csa users 2Oct 29 15:26f1.s -> f1

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

i-nodeblokktipus + rwxlinktulaj.csop.byteut. mód. dát.fájlnév
18484 0lrwxrwxrwx 1root root 4Mar 29 1997/usr/bin/egrep -> grep
18483 0lrwxrwxrwx 1root root 4Mar 29 1997/usr/bin/fgrep -> grep
1848264-rwxr-xr-x 1root bin 64161Aug 17 1995/usr/bin/grep
18537 2-rwxr-xr-x 1root bin 1331May 19 1994/usr/bin/zgrep
18442 2-rwxr-xr-x 1root bin 1203Sep 25 1994/usr/bin/zipgrep

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 test helyett a [ test-opció ] belső parancs is írható. (Fontos, hogy a szögletes zárójeleket helyközök vegyék körül!)

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:

  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:)

  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:

    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):

    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:

  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.
Részletesebb leírás (példákkal) külön lapon található.

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.

Példák:
  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 Unix futási szintek (runlevel 0-6). (init 0, init 1, init 6)

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:

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.


Csizmazia Albert csa@inf.elte.hu