• Szerző: Sallai András
• Copyright © 2009, Sallai András
• Szerkesztve: 2009-2023
• Licenc: CC BY-SA 4.0
• Web: https://szit.hu

Ez az írás a Linux alapú számítógépes operációs rendszerek parancssori lehetőségeinek bemutatásával foglalkozik. Az ismertetésre kerülő parancsok nagy része, bármely unix alapú rendszeren használható. A parancsok kidolgozása Debian GNU/Linuxon történt.

A gyakorláshoz szükséged lesz egy Linuxra. Néhány Linuxot megtalálsz az alábbi helyeken online futtatva, de egyik sem Debian. Van köztük egyszerű parancssoros felület, ami tulajdonképpen csak egy Unix parancssor, és van köztük grafikus felület.

• http://s-macke.github.io/jor1k/
• https://bellard.org/jslinux/
• http://jslinux.org/
• https://copy.sh/v86/

Ez a Linux egy JavaScriptben írt számítógép-emulátoron fut.

Előrelépést jelenthet, ha letöltesz egy Live CD/Live DVD képfájlt. Ehhez a Knoppix vagy a Linux Mint rendszert ajánlom. Ki kell írnod egy DVD-re a letöltött képfájlt, majd indítsd a rendszert a DVD-ről. A DVD-ről induló rendszert – amely telepítés nélkül használható – Live rendszernek nevezzük. A Live rendszer nem bántja a merevlemezre telepített rendszered. A Live rendszeren mentett állományaid viszont nem maradnak meg, hacsaknem pendrive-ra mentesz.

A harmadik lehetőség, hogy telepítesz egy Linuxot. Ha számítógépen, ahova telepíteni szeretnéd a Linuxot már van egy rendszer, akkor ajánlom, hogy először egy virtuális számítógépre telepíts Linuxot. Ide már mehet például a Debian GNU/Linux

Ha már nem okoz gondot a particionálás a telepítőben, vagy egy üres merevlemez áll rendelkezésedre, vagy az adatok nem számítanak az adott gépen, telepítsd fel saját Linuxodat.

A leírásokban nem használok fájlkezelő programot, csak tisztán parancssort. Fájlkezelő ugyan van, de előbb tanuljunk meg dolgozni fájlkezelő nélkül. Így bármely unixon és Linuxon boldogulni fogunk.

Gyakorolj! „Nem kell sokat, csak csináld”.

A Linux indulása után várja, hogy bejelentkezzünk. Ehhez egy várakozási jelet jelenít meg:

login:

A login után kell beírnunk a felhasználónevünket.

login: joska

Ha a rendszerben a felhasználónevünk joska, akkor azt a login: után beírjuk. Egy <Enter> leütésével tudatjuk a rendszerrel, hogy végeztünk a bevitellel. A felhasználónév beírása után a password: várakozási jelet látjuk, amely a jelszavunk beírására szólít fel:

password: 

A jelszó gépelésénél a képernyőn nem jelenek meg a begépelt karakterek.

Ha kapunk egy rendszerhez hozzáférést, akkor az első dolgunk szokott lenni a jelszó megváltoztatása. Ezt a „passwd” parancs kiadásával tudjuk megtenni:

passwd

A felhasználó a passwd paranccsal megváltoztathatja saját jelszavát. A parancs először bekéri a jelenlegi jelszót, majd kétszer az új jelszót.

Rendszergazdaként, azaz a root felhasználóval mások jelszavát is megváltoztathatjuk. Ehhez adjuk meg a kívánt felhasználónevet a passwd parancs paramétereként.

A Linuxos rendszer úgy van összeállítva, hogy a rendszergazda nem tudja megmondani számodra a jelszavadat, ha már megváltoztattad. Ha elveszett, akkor legfeljebb újat tud adni.

Ha te magad is rendszergazda vagy a Linuxban, mert mondjuk most telepítetted, akkor például a joska felhasználónak a következő módon tudod megváltoztatni a jelszavát:

passwd joska

Ez a parancs persze csak rendszergazdaként belépve fog sikerülni, vagy ha te vagy a joska felhasználó.

Ha valahova bejelentkeztünk, akkor ki is kell tudnunk jönni onnan. Nézzük, hogyan lehet szabályosan kijelentkezni a rendszerből.

A rendszerből kijelentkezni a logout paranccsal lehetséges:

logout

A kijelentkezés további parancsokkal is lehetséges. Az egyik az exit parancs, a másik egy billentyűkombináció: Ctrl+D.

Az exit és logout között az a különbség, ha vannak félretett munkák (jobok), akkor az exit nem lép ki. A logout mindenképpen kilép.

A linuxos rendszerekben a Ctrl+D billentyűkombináció fájlvége jel küldésére is használatos néhány parancs illetve, program esetén. Ha ilyen programmal dolgozunk, előfordulhat, hogy csak fájlvége jelet akartunk küldeni, de véletlenül kétszer nyomtuk meg a Ctrl-D billentyűkombinációt, így azonnal ki is jelentkeztünk.

Egy Linuxos rendszeren ha grafikus felületet is telepítettünk, akkor lehetőség van a grafikus bejelentkezésre is, de mi most csak parancssorral foglalkozunk ebben a részben.

Ha valaki feltelepítette a grafikus felületet és szeretne parancssorra átkapcsolni, a következőket kell tudnia:

Egy linuxos rendszer alapértelmezetten 6 azaz hat darab karakteres felületen ad belépési lehetőségeket. Ezek neve: teletype, vagy röviden csak tty. Vagyis van hat darab teletype-unk, amelyek 1-től 6-ig vannak számozva. Indulás után az tty1-en vagyunk. A többi teletype-t az F2, F3, stb. funkcióbillentyűkkel érhetjük el, egészen F6-ig, a lenyomott „Alt” billentyű mellett. A második tty tehát ezzel a billentyűkombinációval érhető el: Alt+F2. A harmadik: Alt+F3, stb.

A Linuxos rendszerek lehetővé teszik ugyancsak hat darab grafikus felülete indítását is. Ebből általában egyet használ mindenki. A grafikus felületet indítható karakteres felületen belépés után, vagy automatikusan indul ha telepítve van egy megjelenítéskezelő (XDM, KDM vagy GDM).

Karakteres felületről grafikus felületre váltás Alt+F7 billentyűkombinációval valósítható meg. Ha grafikus felületről karakteresre szeretnénk váltani, akkor szükséges egy Ctrl billentyű is. A tty1, karakteres felület grafikus felületről tehát így kapcsolható: Ctrl+Alt+F1. Ugyanígy érjük el a többit is. Persze ha már karakteres felületen vagyunk, akkor elég az Alt billentyű.

Ha karakteres felületen dolgozunk, ezt szokták konzolnak hívni. Ha távolról jelentkezünk be vagy grafikus felületről indítunk egy parancssoros felületet, akkor terminálról beszélünk.

A grafikus felületen, egy ablakban indított parancssoros programokat virtuális terminálnak hívjuk. Ebből végtelen sokat indíthatunk (a memória határáig).

Ha GNOME grafikus környezetet telepítettünk, akkor a virtuális terminálunk lehet rendszergazdai és felhasználói. Elérésük:

• Alkalmazások → Kellékek → Terminál
• Alkalmazások → Kellékek → Rendszergazda terminál

• Mit vár a rendszer, ha a következőt írja: login:
• Milyen paranccsal tudjuk megváltoztatni a jelszavunkat?
• Milyen utasításokkal léphetünk ki a rendszerből?
• Ha van grafikus felület telepítve, hogyan tudunk konzolos felületre váltani?
• Milyen grafikus bejelentkezési felületek vannak?
• Hogyan tudunk egy újabb felületen bejelentkezni konzolt használva?
• A linuxos rendszergazda ki tudja deríteni a felhasználók jelszavát?
• Hány darab konzolos felület áll rendelkezésre?
• Töltsön le egy linuxos Live CD-ét
  • Például Knoppix
  • Derítse ki, milyen felhasználónévvel lehet belépni a rendszerbe

A sikeres felhasználói azonosítás után a Linux parancsot vár. Ezt egy várakozási jellel adja értésünkre. A várakozási jel felhasználók és rendszergazdák számára is más. A felhasználók számára egy dollárjelet ($) jelenít meg a rendszer, a rendszergazdának pedig egy kettős-keresztet (#). A várakozási jel ki van bővítve némi információval. Tartalmazza a bejelentkezett felhasználónevet, a gép nevét és az aktuális könyvtárat.

joska@iskolazo:~$

joska@iskolazo:~$

Ez a fajta várakozási jel a Debian GNU/Linuxra jellemző, de általában hasonló a többi linuxos rendszerben is. A felhasználónevet egy szeparátor követi (@). A gépnevet szintén, amely egy kettőspont (:). A kettőspont után egy tilde karakter (~) látható, amely a felhasználó saját könyvtárát jelképezi. A joska felhasználó esetében ez a /home/joska. A parancsokat a Bash nevű parancsértelmező várja, amelyre a dollárjel is utal.

A root felhasználónak az alapértelmezett várakozási jele eltérő. A várakozási jelben az utolsó karakter egy kettős kereszt („#”).

root@iskolazo:~#

A rendszergazda, azaz root felhasználó is a bash parancsértelmezőt használja, viszont ő a rendszer teljes jogú felhasználója. Éppen ezért ne használjuk felhasználói feladatokra. Csak akkor használjuk ezt a hozzáférést, ha valóban szükség van a rendszergazdai jogokra.

Minden operációs rendszer úgynevezett változókban tárol információkat a programok számára. Mivel ezek a változók a programok környezetéből elérhetők, környezeti változóknak is hívjuk őket. A PS1 is egy ilyen környezeti változó. Bármely környezeti változónak a tartalmát megtekinthetjük az echo parancs segítségével. Ilyenkor a környezeti változó neve elé egy dollárjelet kell írni: $PS1. Az echo paranccsal ekkor így jeleníthetjük meg:

echo $PS1

• Mit jelent a várakozási jel?
• Debian GNU/Linux rendszeren mi a felhasználók alapértelmezett várakozási jele?
• Mit jelent a várakozási jelben a „~” karakter?
• A Debian GNU/Linux rendszerben mi a root felhasználó alapértelmezett várakozási jele?
• Milyen környezeti változó tartalmazza a várakozási jel beállításait?
• Hogyan épül fel a Debian GNU/Linux felhasználói várakozási jel?

Minden operációs rendszerben léteznek úgynevezett környezeti változók. Ezek az operációs rendszerről vagy programjainkról tárolnak információkat. A környezeti változók a rendszer indulása után automatikusan beállításra kerülnek.

A környezeti változók megtekintése:

printenv

Paraméter nélkül az összes környezeti változót kiírja, amelynek van értéke.

Megadhatjuk melyik változót szeretnénk:

printenv PATH

vagy

printenv HOME

vagy

printenv SHELL

A set paranccsal vigyáznunk kell, mert Shellenként másként viselkedik. Ráadásul az alapértelmezetten futó Bash parancsértelmezőben egészen mást csinál paraméterezve, minta mondjuk a csh, vagy ksh környezetben.

A set parancs önmagában kiadva, mindenesetre kiírja a környezeti változókat, de a különféle parancsértelmezők esetén más, más kimenetet kapunk:

set

A kimenet általában túl fut a képernyőn. A kimenetet képernyőoldalakra tördelhetjük a less paranccsal:

set | less

A grep parancs segítségével, megmondhatjuk, hogy csak azokat a sorokat szeretném látni, ahol szerepel, például a PATH szó:

set | grep PATH

Beállítható saját változó is:

export TEST_VAR=hello

Nézzük meg az eredményt:

set | grep TEST_VAR

vagy:

printenv

A változó megszüntetése:

unset TEST_VAR

Érdekes, hogy a Bash esetén a set másként működik a többi parancsértelmezővel szemben, az unset viszont ugyanazt csinálja. Az unset bármely paraméterként megadott változót megszüntet.

Próbáljuk ki a fenti parancsokat.

Egy változót beállíthatunk az export parancs nélkül is. Így is beállítható a TEST_VAR változó:

TEST_VAR=hello

Akkor mi a különbség? Ha használom az export parancsot, akkor az aktuális parancssorból indított folyamatok is látni fogják a TEST_VAR változót. Ha nem használom az export parancsot, akkor ezek a folyamatok nem látják. Próbáljuk ki:

BARAT_VAR=Feri

Ellenőrizzük, hogy létezik-e a változó:

echo $BARAT_VAR

Létezik, műküdik. Most indítsunk egy másik terminált. Lehet xterm vagy mate-termianl, vagy ami rendelkezésünkre áll:

xterm

Nézzük meg ebben a terminálban a BARAT_VAR változó tartalmát:

echo $BARAT_VAR

Semmi. Most lépjünk ki az új terminálból, majd futtassuk a parancsot újra, de most az export paranccsal:

export BARAT_VAR=Feri

Indítsunk egy xterm terminált:

xterm

Majd ebben a terminálban nézzük meg a változónkat:

echo $BARAT_VAR

Itt is látszik a tartalma.

Saját rendszer szintű környezeti változók bevezetése a /etc/environment állományban lehetséges. Az állomány alapértelmezetten üres. Vegyük fel a következő sorokat:

Z1=első
Z2=második

Egy sor egy változó.

Indítsuk újra a rendszert, majd a set paranccsal írassuk ki az összes változót:

set

Az /etc/environment fájlban létrehozott változók még grafikus felületen is érvényesek.

A PATH változó esetén, ügyelni kell arra, hogy felülírja a változót. A PATH változó egész tartalmát itt meg kell adni:

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Néhány leírás szerint a setenv parancs is használható a változók beállítására, de ez csak a csh parancsértelmezőben áll rendelkezésre.

Az env parancsot arra használhatjuk, hogy egy parancsot módosított környezetben futtassunk. Paraméter nélkül kiírja a környezeti változókat.

env

Mint fentebb már írtam a set parancs másként viselkedik a különböző parancsértelmezők esetén. A Bash set parancsa a Bash számára állít be pozíció szerinti paramétereket, úgy mint

• $1, $2, $3

Legyen a GYUMOLCS változó, értéke alma:

set GYUMOLCS=alma

Értékét így tudjuk kiolvasni:

echo $1

Ha több paramétert is szeretnénk megadni:

set alma körte barack

echo $1
alma

echo $2
körte

echo $3
barack

A pozíciónális paraméterekből bármikor lekérhetők az értékek.

A PS1 környezeti változó megismerése előtt nézzük meg az echo parancs használatát. Az echo egy szöveget ír a képernyőre.

echo "Helló Világ!"

Az echo a szöveg végén egy sortörést is a képernyőre küld, amiről lebeszélhető a -n kapcsolóval.

echo -n "Helló Világ!"

Különleges karakterek is engedélyezhetők a -e kapcsolóval:

echo -e "Helló\nVilág!"

Vegyük észre ez utóbbi példánkban a „\n” különleges karaktereket. Ez például sortörést jelet küld a képernyőre.

Különleges karakterek táblázata:

Az echo parancsot úgy is használhatjuk, mint egy ls. Az összes .txt kiterjesztésű állomány megjelenítése:

echo *.txt

Az echo parancsnak két változatát használhatjuk. Az egyik:

• a parancsértelmező beépített parancsa
• külső parancs

Figyeljük meg a type echo kimenetét:

$ type echo
echo egy beépített parancs

Alapból tehát ezt használjuk. Ha mégis a külső parancsot szeretnénk hasznáni meg kell adnunk a teljes útvonalat:

/bin/echo

Fentebb már láttuk, hogy a PS1 környezeti változó tartalmát így tudjuk megnézni:

echo $PS1

Azt is láttuk, hogy a várakozási jel ki van egészítve felhasználó- és gépnévvel, azt követően pedig az aktuális könyvtárral. A PS1 környezeti változóban van leírva ez a forma. Ha megnézzük a fenti parancs eredményét, akkor ehhez hasonlót kell látnunk Debian GNU/Linux 6, 7 és 8 verzió esetén:

Konzolon:

${debian_chroot:+($debian_chroot)}\u@\h:\w\$

Ha grafikus felületen indítottunk egy virtuális terminált, akkor ez egy kicsit másként néz ki:

\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\u@\h:\w\$

Ezek a beállítások biztosítják a várakozási jel fentiek szerinti megjelenítését.

Természetesen megadhatunk más beállításokat is. A környezeti változókat mindig az export paranccsal szokás beállítani, mert ez teszi lehetővé, hogy más folyamatok indítása után is érvényes legyen a beállítás. Az alábbi beállítás a terminál színezését mutatja be:

export PS1='${debian_chroot:+($debian_chroot)}\[\033[01;34m\]\u@\h\[\033[00m\]:\w\$ '

Vegyük észre, hogy az export parancs után írt PS1 környezeti változó elé nem írtunk „$” karaktert. Fentebb említettük, hogy erre csak akkor van szükség ha hivatkozunk rá, tehát példának okárét kiíratjuk azt.

A fenti prompt nagyon hosszú tud lenni ha van egy nagyon hosszú könyvtárútvonalunk. Ilyenkor beállíthatunk egy egyszerű várakozási jelet, amely csak egy dollárjelet meg egy szóközt jelenít meg:

export PS1="$ "

Akkor használjuk, ha az útvonal nagyon hosszú szeretnénk egy egyszerű várakozási jelet.

Ezek a beállítások persze nem véglegesek, újraindítás vagy ki-, és bejelentkezés után a környezeti változó tartalma eredetire visszaáll.

Ez a várakozás jel újraindítás után azonban nem érvényes. Ha újraindítás után is szeretnék látni, akkor a /home/joska/.bashrc állomány végére írhatjuk a következő sort

export PS1='$ '

Ez is szép megoldás:

export PS1="Irj be egy parancsot: "

Prompt a felhasználónév, dollárjel és egy szóköz:

export PS1="\u\$ "

Prompt a hostnév, dollárjel és egy szóköz:

export PS1="\h\$ "

Prompt az aktuális könyvtár, dollárjel és egy szóköz:

export PS1="\w\$ "

De keverhetjük:

export PS1="\u\h\$ "

Így viszont nincs elválasztó kettő között. Szokásos szeparátor a „@” karakter„.

export PS1="\u@\h\$ "

• Mire való az echo parancs?
• Milyen különleges karaktereket használhatunk az echo paranccsal?
• Hogyan állíthatjuk be, hogy a várakozási jel a felhasználónévből és egy dollárjelből álljon?
• Hogyan állíthatjuk be, hogy a várakozási jel a számítógép nevéből és egy dollárjelből álljon?
• Mit jelent az útvonalban a ”~„ karakter?
• Készítsen egy ilyen várakozási jelet: „C:\> ”

Ha várakozási jel nem tájékoztat arról, milyen néven léptünk be, akkor használjuk a whoami parancsot.

Ki vagyok én?

whoami

Esetleg így:

who am i

Ez a parancs kiírja a felhasználónevünket. Például:

joska

Mit lehet rólam tudni? Néha azt is szeretnénk tudni, milyen csoportokban van benne a felhasználónk. Ebben segít az id parancs.

id

A kimenet ehhez hasonló lehet:

uid=1000(joska) gid=1000(joska) csoportok=1000(joska),
4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),108(lpadmin),
125(sambashare),126(vboxusers),1002(teachers)

Jóval több információt ad. Megmondja milyen csoportokba tartozunk felhasználóként.

Az id parancs az -un kapcsolóval úgy viselkedik mint a whoami parancs:

id -un

Általában szeretnénk tudni ki volt utoljára bejelentkezve, vagy mikor használták utoljára a hozzáférésünket (használata-e illetéktelen). Ebben segít a last parancs:

last

A last parancs kimenete persze túl fut a képernyőn, ha már sokszor használtuk a Linuxot. Ezt tördelhetjük a more paranccsal így:

last | more

Használhatjuk ebből a célból a less parancsot is:

last | less

A less parancs felületéből egy billentyűvel tudunk kilépni:

Q

Csak a jelenlegi kapcsolatok:

last -ap now

Van amikor csak egyszerűen arra vagyunk kíváncsiak ki van bejelentkezve:

users

Ha azt is szeretnénk látni honnan léptek be, akkor a következő parancsot használjuk:

who

who -u

A legtöbb információt azonban a következő parancs adja:

w

Ez a parancs azt is kiírja, a bejelentkezett felhasználók mit csinálnak. Ezért ügyelnünk kell arra, hogy ha olyan parancsot használunk, amely paraméterként jelszót vár, azt ne futtassuk parancssorból önmagában. Hagyjuk, hogy a programunk kérje azt be.

Belépések listázása:

lslogins

Csak valódi felhasználók:

lslogins -u

A finger parancs alapértelmezetten nem érhető el.

A finger információkat közöl egy felhasználóról. Eredetileg e-mail címek alapján lehetett lekérdezni, több információt. Ha valahol van finger szolgáltatás, ez természetesen most is működik.

Egy Linuxos rendszeren a felhasználónevet beírva, bővebb információkat nyújt róla:

• teljes neve
• könyvtára
• shell
• milyen TTY-on jelentkezett be
• mennyi ideje van bejelentkezve
• van-e új level
• dolgozik-e valamilyen terven

A finger eredetileg a BSD UNIX részeként jelent meg.

A telepítéshez rendszergazdai jogok szükségesek:

apt install finger

A használathoz egyszerűen beírhatjuk a finger parancsot:

finger

De egy felhasználó megadható paraméterként. Így több információt jelenít meg, a kívánt felhasználóról:

finger janos

A plan:

nano ~/.plan

A felhasználó leírhatja éppen min dolgozik.

• Mi a különbség a „who” és a „w” parancs között?
• Írja bent.txt fájlba kik vannak éppen a rendszerbe bejelentkezve.
• Mire való az users parancs?
• Hogyan nézhetjük, meg mikor volt utoljára újraindítva a rendszer?
• Hogyan nézhetjük, meg kik voltak bejelentkezve a rendszerbe?
• Hogyan kérdezzük le az aktuális dátumot?
• Mire való a „whoami” program?
• Mit csinál a „id -un” parancs?

Az aktuális dátumot a date paranccsal lehet lekérdezni:

date
2013. jan.  8., kedd, 20.39.43 CET

A dátum és időbeállításokról később bővebben is lesz szó.

A lekérdezések formája beállítható, ahogy azt az alábbiakban látjuk.

Csak az óra lekérdezése:

date +%H

Óra perc:

date +%H:%M

Évszám:

date +%Y

Évszám, hónappal és nappal

date +%Y-%m-%d

A dátum kiíratható unix formátumban is:

$ date +%s
1539114959
$ date -d @1417827123
2014. dec.  6., szombat, 01:52:03 CET
$ 

A cal megmutatja az aktuális hónapot és évet. Az aktuális hónap minden napját külön is megjeleníti, naptárszerűen.

Naptárat jelenít meg.

A cal parancs magyar kézikönyve sajnos elavult a Debian GNU/Linux 6.x rendszerekben. Helyette nézzük meg az angol nyelvűt. Például:

man -L us cal

Használhatjuk a cal helyett a ncal parancsot is.

A cal és az ncal parancsok a bsdmainutils csomag részei.

A cal ma már csak egy szimbolikus link a ncal programra. Ha az ncal nézetben, hétfővel kezdődő naptárat szeretnénk, használjuk az ncal -b parancsot:

ncal -b

Adott hónap az évben:

ncal -m 10

Az adott hónap előtt és után is egy hónap megjelenítése:

ncal -b -3

Szeptemberben így augusztus, szeptember és október jelenik meg.

ncal -b -3 -m 10

Így szeptember, október és november jelenik meg.

ncal -y 2020

Még pluszban hány hónap jelenjen meg, az aktuális után:

ncal -A 3

Még pluszban hány hónap jelenjen meg, az aktuális előtt:

ncal -B 3

Adott év, adott hónapja:

ncal -d 2020-4

vagy:

ncal -d 2020-04
ncal -d 2020-04 -A 2

Kiírja mennyi ideje fut a rendszer, milyen terhelésnek van kitéve.

uptime

Az uname a kernelről ad információt:

uname

Kapcsoló nélkül csak annyit mond, hogy „Linux”. Ez az információ jelenik meg a -s hatására is.

A -m kapcsoló kiírja milyen hardvert használunk:

uname -m

Vagy:

uname --machine

A válasz például:

• x86_64

A -r megadja a kernel verziószámát:

uname -r
4.9.0-4-amd64

Az összes információt a -a kapcsolóval írja a képernyőre:

uname -a

A processzor adatai:

cat /proc/cpuinfo

A memória adatai:

cat /proc/meminfo

Használt és szabad memória, cserehellyel együtt:

free

df -h

du

A felhasználók alapértelmezésben, belépés után a saját könyvtárukba kerülnek, amelynek a jele ”~„. Alapértelmezés az is, hogy az aktuális könyvtár megjelenik a várakozási-jelben. Ha változtattunk várakozási-jelen és már nem az alapértelmezett könyvtárban állunk, szeretnénk tudni az aktuális könyvtár nevét, útvonalastól együtt. Ezt a pwd parancs begépelésével tehetjük meg. A pwd a present work directory vagy a print working directory rövidítése.

pwd

A joska nevű felhasználó például ezt láthatja, ha a saját könyvtárában áll:

/home/joska

Általában szeretnénk a könyvtár tartalmát listázni. Szeretnénk látni milyen újabb könyvtárakat és fájlokat tartalmaz. Erre a célra az „ls” parancsot használhatjuk.

ls

Az ls kapcsolók nélkül kiadva az aktuális könyvtár tartalmát mutatja. Ha először lépünk be egy linuxos hozzáférésünkre, akkor valószínűleg nem találunk a saját könyvtárunkban állományt.

A rejtett állományok abban különböznek a többitől, hogy ponttal (.) kezdődnek. Ha először lépünk be egy hozzáférésünkre valószínűleg már vannak rejtett fájlok, csak nem látjuk őket. A -a kapcsolóval megtekinthetők a rejtett fájlok is:

ls -a

Egy következő kapcsoló a fájlokról a lehető legtöbb információt adja számunkra, ez a -l. Long azaz hosszú kimenet kapunk a kapcsolóval:

ls -l

Ha még nincs más könyvtárunk használjuk az „a” kapcsolót is:

ls -la

Az eredmény valami ilyesmi lehet:

összesen 28
drwxr-xr-x 3 joska joska 4096 febr  24 23.49 .
drwxr-xr-x 4 root  root  4096 dec   13 18.37 ..
-rw------- 1 joska joska   92 febr  25 00.04 .bash_history
-rw-r--r-- 1 joska joska  220 dec   13 18.37 .bash_logout
-rw-r--r-- 1 joska joska 3184 dec   13 18.37 .bashrc
drwx------ 2 joska joska 4096 febr  24 23.49 .mc
-rw-r--r-- 1 joska joska  675 dec   13 18.37 .profile

Az ls parancsnak megadható, hogy melyik könyvtárat listázza számunkra. A gyökér könyvtár listázása a következő módon történhet:

ls /

Vagy a /bin könyvtár listázása:

ls /bin

Fentebb már láttuk a -l kapcsoló hatását (-a -val együtt):

összesen 28
drwxr-xr-x 3 joska joska 4096 febr  24 23.49 .
drwxr-xr-x 4 root  root  4096 dec   13 18.37 ..
-rw------- 1 joska joska   92 febr  25 00.04 .bash_history
-rw-r--r-- 1 joska joska  220 dec   13 18.37 .bash_logout
-rw-r--r-- 1 joska joska 3184 dec   13 18.37 .bashrc
drwx------ 2 joska joska 4096 febr  24 23.49 .mc
-rw-r--r-- 1 joska joska  675 dec   13 18.37 .profile

A kimenet első elemének a neve egy pont (.), a másodiknak pedig két pont (..). Az egy pont magában az aktuális könyvtárat jelképezi, a két pont egymás után pedig a szülőkönyvtárat jelképezi.

A parancs először az állományról kiírja, hogy milyen fajta állomány. A Unix alapú rendszerekben a könyvtárak is állományként vannak kezelve, ezért a könyvtárat egy speciális állománynak is tekinthetjük. Így van ez a számítógép hardver eszközeivel is. Minden eszköz egy állományként érhető el a rendszerben. Ezért szoktuk mondani, hogy a Linuxban minden állomány.

Minden sor 10 darab karakterrel kezdődik. Ebből az első az állomány típusa, a többi kilenc az állományhoz tartozó jogokat mutatja.

A következő szám az állományra mutató linkek számát mutatja. A linkekről lásd később a link létrehozása című részt.

A linkek száma után az állomány tulajdonosa, amit a csoport neve követ. A Debian GNU/Linux rendszerekben egy felhasználó létrehozásakor létrejön egy a nevével azonos csoport is. Így lehet, hogy a csoportnév megegyezik a tulajdonos nevével.

A következő szám az állomány mérete. Könyvtárak esetén itt a blokk mérettét látjuk.

Ezt követi az utolsó módosítás dátuma, és végül az állomány neve.

Ha listázott elem egy könyvtár, akkor a méret résznél a fájlrendszerben használatos blokkméret fog megjelenni.

A könyvtárak és fájlok a -l kapcsolóval megkülönböztethetők, de előfordul, hogy ezen kapcsoló nélkül is szeretném látni, hogy mivel van dolgom. Ezt a -F kapcsolóval tehetem meg:

ls -F

A fájlok és könyvtárak számára legkisebb lefoglalható egység a fájlrendszertől függ. ext3 és ext4 fájlrendszeren ez 4096 bytes. Ha futtatjuk a ls -ld parancsot, akkor látjuk az adott könyvtár számára mennyi helyet foglalunk:

ls -ld munka

A kimenet pedig ehhez hasonló lehet:

drwxr-xr-x joska joska 4096 márc   9 10.26 munka/

A könyvtár számára a 4096 a kezdeti lefoglalt hely (fájlok számára is). A könyvtárban eltárolt fájlok sokasodása után ez nőhet, a következő például 4096 valamelyik szorzatára.

Az alábbi parancs létrehoz néhány fájlt:

mkdir munka
cd munka

Hozzunk létre 200 fájlt:

for ((i=0; i<200; i++)); do touch aaaaaaaaaa_$i; done

Nézzük meg a ls -ld kimenetét a könyvtáron:

ls -ld .
drwxr-xr-x joska joska 12288 márc 12 07.03

Ezek után az aktuális könyvtár listázásánál a méret: 12288

Ne felejtsük el, hogy más fájlrendszernél ezek az értékek eltérhetnek.

Egy könyvtár vagy fájl listázása esetén a jogok után ritka esetben megjelenhet plusz (+) vagy pont (.) karakter:

drwxr-xr-x+ joska joska 12288 márc 12 07.03 Nev

vagy:

drwxr-xr-x. joska joska 12288 márc 12 07.03 Nev

A plusz (+) karakter arra utal, hogy a fájlhoz (vagy könyvtárhoz) külön ACL bejegyzések is tartoznak. Ha pont (.) karakter van a jogok után, akkor ez SELinux címkék bejegyzésére utal.

Ha mindkettő van (ACL és SELinux címke is), akkor a plusz (+) karakter látszik. További információk az ACL és az SELinux lapokon.

Könyvtárakat az „mkdir” paranccsal hozhatunk létre. Az mk, a make szóból, a dir pedig a directory szóból származik. Paraméterként több könyvtárat is megadhatunk. A linuxos, illetve unixos rendszerek kis és nagybetű érzékenyek. A következő példában szereplő nevek két külön könyvtárat jelölnek:

• Informatika
• informatika

A parancs szintaxisa:

mkdir konyvtar_neve ...

A mai Linuxok már UTF-8-as kódolást használják a rendszer minden szintjén, így használhatunk ékezetes könyvtárneveket is. Ezzel azonban gond lehet, ha más rendszerre visszük a könyvtárainkat.

Egyszerre több könyvtárat is létrehozhatunk, ha szóközzel tagolva felsoroljuk, vagy kapcsos zárójelek között vesszővel tagoljuk azokat. Utóbbi esetben szóköz nem lehet köztük:

mkdir elso masodik harmadik

mkdir {elso,masodik,harmadik}

Ha útvonalat is megadunk egy könyvtár létrehozásánál a -p kapcsoló segítségével, az útvonalban szereplő nem létező könyvtárak automatikusan létrejönnek:

mkdir -p /home/joska/munka/dolgozok/human/gizi

Ha már vannak újabb könyvtáraink szeretnék „belépni” azokba.

A példa kedvéért, hozzuk létre saját könyvtárunkban a jarmu nevű könyvtárat. Tegyük fel, hogy a saját könyvtárunk a /home/joska. A „pwd” parancs tanúsága szerint pedig ebben a könyvtárban állunk. Kiadtuk a könyvtárlétrehozás parancsát:

mkdir jarmu

Szeretnénk az új könyvtárba belépni, vagyis könyvtárat cserélni. Erre a „cd” parancs ad lehetőséget:

cd jarmu

A „pwd” paranccsal ellenőrizzük a könyvtárváltás meglétét.

A „cd” parancs első „c” betűje a „change” szóból van, a „d” betű pedig a „directory” szóból.

Ha jól dolgoztunk a pwd parancs kimenete most a következő:

/home/joska/jarmu

Most a „jarmu” könyvtáron belül hozzunk létre egy „szeker” nevű könyvtárat:

mkdir szeker

Lépjünk bele:

cd szeker

Ezek után a pwd kimenete:

/home/joska/jarmu/szeker

Most vissza kellene lépni az előző könyvtárba. Az előző könyvtárat két pont jelképezi:

..

Másként, ha most éppen a /home/joska/jarmu/szeker könyvtárban állunk akkor a két pont a /home/joska/jarmu könyvtárat jelképezi. Ha szeretnénk visszalépni a jarmu könyvtárba, akkor megtehetjük, hogy a teljes útvonal megadásával így lépek vissza:

cd /home/joska/jarmu

De ugyanezt az eredményt érhetjük el, ha cd paranccsal használjuk a két pontot:

cd ..

Ez utóbbi parancs bármely könyvtárban is állunk, azt eredményezi, hogy egy könyvtárral feljebb kerülünk.

Ugyanígy használhatjuk a gyökérkönyvtár jelét a fájlrendszer gyökerébe jutáshoz:

cd /

Ezzel a fájlrendszer gyökerébe jutunk.

Van még egy különleges karakter, amely a saját könyvtárunkat jelképezi. Ez a következő:

~

Tilde karakternek hívják. Bármely könyvtárban is állok a könyvtárstruktúrában, ha kiadom a következő parancsot, a saját könyvtárunkba fogok jutni:

cd ~

Vegyük észre, hogy a várakozási jelben is szerepel egy tilde karakter (Legtöbb linuxos terjesztésben így van beállítva a várakozási jel).

A saját könyvtárunkba visszaléphetünk egyszerűen a cd paranccsal is:

cd

Az utoljára használt könyvtárba is könnyedén visszaléphetünk:

cd -

Az rmdir parancs segítségével minden megadott üres könyvtárat törölhetünk:

rmdir konyvtarnev

Itt is használható a -p kapcsoló. A parancs így a legbelső könyvtárat törli, ha az üres, és utána a többit, egyenként. Legyen a példa kedvéért egy ilyen könyvtárszerkezet:

egy/ketto/harom

Kiadjuk a törlésre az utasítást:

rmdir egy/ketto/harom

A parancs először törli a harom könyvtárat, ha az üres. Utána a ketto könyvtárat, ha az előző sikeres volt és a ketto üres. Végül ha az előző kettő sikeres volt, akkor törli az egy könyvtárat is.

A könyvtár átnevezését az mv paranccsal hajtjuk végre, amely az angol move szóból származik. Magyarul mozgatás jelent. A parancsot valójában arra találták ki, hogy egy állományt egy másik helyre mozgassunk. Viszont ha a mozgatás helye a kiindulási pont, akkor csak átnevezés történik.

Szintaxisa a következő:

mv eredetikonyvtar ujkonyvtar

mv konyvtar001 konyvtar002/

A konyvtar002 könyvtárba mozgatjuk a konyvtár001 nevű könyvtárat.

cp -R dir1 dir2

Ha a dir2 már egy létező könyvtár, akkor annak tartalmába másol! Ha nincs dir2 könyvtára akkor az aktuális könyvtárban létrehozza a dir2 könyvtárat.

A -R kapcsoló hatására valójában rekurzív másolásra adunk parancsot, de könyvtármásolásnál éppen ezt szeretnénk.

A könyvtárnevek maximális hossza 256 bájt. De az ékezetesekkel duplán kell számolnunk.

tree

Könyvtár szerkezet a saját könyvtártól kiindulva:

tree ~

A Dokumentum könyvtár szerkezete jogokkal:

tree -p Dokumentumok

• Milyen könyvtárkezelő parancsok vannak?
• Hozzon létre egy „tudas” nevű könyvtárat saját könyvtárában.
• Hozzon létre egy „jarmu” nevű könyvtárat saját könyvtárban.
• Milyen paranccsal nézzük meg, melyik könyvtárban vagyunk éppen?
• Milyen parancssorral léphetünk a gyökérkönyvtárba (egy parancs)?
• Lépjen saját könyvtárába.
  • A „jarmu” nevű könyvtárban a következő alkönyvtárakat hozza létere:
    • Citroen
    • Daewoo
    • Fiat
    • Ford
    • Lada
    • Mercedes
    • Nissan
    • Opel
    • Peugeot
• Lépjen be a /sys/block könyvtárba. Derítse ki milyen állományok vannak ebben a könyvtárban.
• Lépjen be a /sys/block/sda könyvtárba, ha az létezik. Milyen állományok vannak benne?

A Linuxos könyvtárszerkezet felépítése egy fához hasonlítható. Van egy gyökér a kiinduláspont, és abból újabb könyvtárak, alkönyvtárak nyílnak. A kiindulópontot azaz a gyökeret egyetlen karakterrel jelezzük: ”/„. A perjel tehát a gyökér. Ha a merevlemez több részre ún. partícióra van felosztva, gyökér akkor is csak egy van, így nem kell különféle jelöléssekkel ellátni a gyökér könyvtárat. Jó kérdés lehet, hogy akkor a többi partíciót hol és hogyan érjük el. A plusz partíciók egy-egy könyvtár alkönyvtáraiban érhetők el. A rendszergazda azokat bárhova felcsatolhatja, igaz van mindegyiknek egy megszokott helye.

A felhasználók könyvtárai a „home” nevű könyvtárban találhatók. Hogy ez rögtön a gyökér könyvtárból nyílik, így szoktuk leírni:

/home

A /home könyvtáron belül vannak a felhasználók könyvtárai. Legyen például egy joska, egy mari és egy janos nevű felhasználó. A joska felhasználói könyvtárát ekkor így írhatjuk le:

/home/joska

Mari felhasználó könyvtára:

/home/mari

János felhasználó könyvtára:

/home/janos

Fa formájú szerkezetben ezt így írhatjuk le:

/
|--home
     |--janos
     |--joska
     |--mari

Ha Jánosnak van a saját könyvtárában egy Dokumentumok alkönyvtár, akkor a faszerkezet így néz ki:

/
|--home
     |--janos
     |    |--Dokumentumok
     |--joska
     |--mari

Itt szeretném megjegyezni, hogy a Linuxos fájlrendszer kis- és nagybetű érzékeny. Tehát egy „dokumentumok” és egy „Dokumentumok” nevű könyvtár, két különböző könyvtár.

További példa kedvéért Jánosnak legyen a Dokumentumok mellett egy Tervek és egy a tervekből nyíló Programozas könyvtára:

/
|--home
     |--janos
     |    |--Dokumentumok
     |    |--Tervek
     |          |--Programozas
     |--joska
     |--mari

A valósában a gyökérkönyvtárból is több könyvtár nyílik. A következő példában legyen pluszban egy „var” könyvtár is ábrázolva. A var könyvtárban a rendszer a változó adatokat tárolja:

/
|--home
|    |--janos
|    |    |--Dokumentumok
|    |    |--Tervek
|    |          |--Programozas
|    |--joska
|    |--mari
|--var

A „var” könyvtárból nyíljon egy „log” nevű könyvtár amelyben a naplófájlok vannak:

/
|--home
|    |--janos
|    |    |--Dokumentumok
|    |    |--Tervek
|    |          |--Programozas
|    |--joska
|    |--mari
|--var
    |--log

Ezzel a faszerkezettel tehát leírható az egész könyvtár hierarchia.

A „log” könyvtár útvonalát egyetlen sorba, ezek után így írhatjuk fel:

/var/log

A János nevű felhasználó Dokumentumok könyvtára egyetlen sorban:

/home/janos/Dokumentumok

A János nevű felhasználó „Programozas” könyvtára így írható le:

/home/janos/Tervek/Programozas

A János nevű felhasználó „Tervek” könyvtára így írható le:

/home/janos/Tervek

Esetleg az egyértelműbb jelzés miatt a könyvtár nevek végére tehetünk egy ”/„ karaktert:

  /var/log/
  /home/janos/Dokumentumok/
  /home/janos/Tervek/Programozas/
  /home/janos/Tervek/

Így tudjuk, hogy nem egy fájlról van szó.

• /
  • bin
  • boot
  • dev
    • hda0
    • hda1
  • etc
  • home
    • jozsi
    • mari
    • kati
    • eszter
    • peter
  • lib
  • media
  • mnt
  • opt
  • proc
  • root
  • sbin
  • srv
  • sys
  • tmp
  • usr
    • bin
    • include
    • lib
    • local
    • sbin
    • share
  • var
    • log
    • mail
    • www

Most nézzük, mi micsoda.

• /bin Az alapparancsok programjai itt vannak elhelyezve.
• /boot A rendszerindításhoz szükséges fájlok helye.
• /dev A számítógép minden eszköze (hardvere) ebben a könyvtárban egy fájl formájában leképezésre kerül.
  • /dev/sr0 A CD-ROM elérése.
• /etc A rendszer beállításait tároljuk itt.
• /home A felhasználók saját könyvtárai.
• /lib Osztott programkönyvtárak, elsősorban a kernel, a /bin és az /sbin könyvtárak számára.
• /lost+found Fájlrendszer sérülése után a helyreállító program ide helyezi azokat a fájlokat amit nem képes helyre állítani.
• /media Más fájlrendszerek automatikusan ide kerülnek felcsatolásra.
  • /media/cdrom0
• /mnt Kézzel csatlakoztatott más fájlrendszerek.
  • /mnt/cdrom Ha kézzel csatolunk egy CD-ROM-t a fájlrendszerbe, akkor azt ide szokás.
• /proc A memória leképezése fájlokra.
• /root A root (rendszergazda) felhasználó saját könyvtára.
• /sbin A rendszergazda parancsainak programjai itt találhatók.
• /srv A szolgáltatásokat nyújtó programok adatállományai (mint a home).
• /sys Néhány kernelobjektum itt van leképezve.
• /tmp Ideiglenes fájlok helye.
• /usr A programok könyvtárai.
  • /usr/bin/ : Futtatható programok a felhasználók számára.
  • /usr/include/ : A programozáshoz szükséges „include” fájlok helye.
  • /usr/lib/ : Osztott programkönyvtárak.
  • /usr/sbin/ : A root felhasználók programjai.
  • /usr/share/ : Architektúra független adatok.
  • /usr/src/ : Forráskódok. (Debian csomagok fordításához; Lásd még a /usr/local/src/ könyvtárat)
  • /usr/X11R6/ : Az „X Window System” könyvtára.
  • /usr/local/ : A rendszer-adminisztrátor által telepített programok helye.
    • /usr/local/bin : helyi bináris programok és scriptek helye, stb.
    • /usr/local/src : Forráskódok helye (Nem debianos eszközök telepítési helye.)
• /var Gyakran változó fájlok helye.

Link: http://wiki.debian.org/FilesystemHierarchyStandard

• Mit tartalmaz a /tmp könyvtár?
• Mit tartalmaz a /bin könyvtár?
• Mit tartalmaz a /home könyvtár?
• Mit tartalmaz a /media könyvtár?
• Mit tartalmaz a /proc könyvtár?

Egy fájl létrehozásához a legegyszerűbb parancs a touch. Igaz eredeti célja, hogy egy fájl időbélyegét megváltoztassuk, de ha egy állomány nem létezik amelynek időbélyegét aktualizálni szeretnénk, akkor azt létrehozza. Természetesen a fájl tartalma üres lesz. A touch parancs nem kérdez semmit, csak elkészíti az állományt:

touch fajlneve.txt

Az echo paranccsal is létrehozhatunk fájlokat. Ekkor az echo után írt „Szöveg” a fájlba kerül.

echo "alma" > gyumolcsok.txt

Egy fájl törlése:

rm fajlnev

Törlés rekurzívan:

rm -r konyvtarnev

Az rm parancs alapvetően fájlok törlésére lett kitalálva, ezért könyvtárat csak úgy tudunk törölni vele, ha beállítjuk a rekurzívitást.

A könyvtár és tartalmának törlése:

rm -r könyvtárnév

Az egész könyvtárfa törlése a gyökértől kiindulva:

rm -r /

A -f kapcsolóval kérdés nélkül törölhetők az állományok. A nem létező állományok miatt sincs visszajelzés:

rm -f vmi.txt

Egyszerre több fájl is törölhető:

rm vmi1 vmi2 vmi3

Ha óvatosak szeretnénk lenni, ezért minden fájl törlése előtt elvárnánk egy kérdés, hogy törölhetjük-e, akkor használjuk az -i kapcsolót:

rm -i vmi1 vmi2 vmi3

Ha kérdés nélkül szeretnék egy könyvtárat, tartalmukkal együtt töröli, használjuk a -f és -r kapcsolókat:

rm -rf könyvtárnév

A -r mondja meg, hogy legyen rekurzív a művelet, a -f pedig, hogy ne problémázzon az rm parancs.

Az rm parancs mellett használható a „*” jelölése, amely bármilyen szövegre illeszkedik. a .txt kiterjesztésű fájlok törlése:

rm *.txt

A csillag karakter persze állhat a bárhol a mintában.

mv fajl001 fajl002

Az mv parancs valójában a fájlok mozgatására lett kitalálva, de ha nem adunk meg könyvtárat, vagyis ugyanabba a könyvtárba mozgatunk, akkor tulajdonképpen átnevezés történik.

Átnevezés {} használatával:

mv fel.txt{,.elavult}

Az eredmény: fel.txt.elavult

Adott állomány mozgatása adott könyvtárba:

mv fajl konyvtar

vagy:

mv fajl konyvtar/

A fajl nevű állományt a konyvtar nevű mappába mozgatjuk.

Több fájl is mozgatható egy könyvtárba, a lényeg, hogy a könyvtár neve legyen az utolsó:

mv fajl1 fajl2 fajl3 konyvtar

Az aktuális könyvtárban szeretnénk a file1 állományról egy file2 másolatot:

cp fajl01 fajl02

Adott egy „munka” nevű könyvtár az aktuális könyvtáron belül. Ebbe szeretnénk másolni a file1 nevű állományt, ugyanezen a néven:

cp fajl01 munka/

A -u, vagy hosszabban --update kapcsolóval, a nem kerülnek másolásra azok a nem-könyvtár fájlok, amelyek azonos vagy újabb módosítási idővel rendelkeznek.

cp -u *.c cel

Gyakran szükség van arra, hogy gyorsan belenézzünk egy fájlba. Erre használható például a cat parancs:

cat fajlnev

more fajlnev

less fajlnev

split -b 1440000 fajlnev

Régebben ha floppy lemezre akartunk másolni, pont ekkora méretre kellett darabolnunk a fájlt. A fenti parancs segítségével a fajlnev nevű állományt 1440000 byte nagyságú részekre lett feldarabolva. A fájlokat automatikusan elnevezi ehhez hasonlóan:

• xaa
• xab
• xac
• stb

A darabolt fájlokat előbb-utóbb szeretnénk összeszerkeszteni. Ezt a cat paranccsal tehetjük meg az alábbi formában:

cat x* >> fajlnev

A csillag, azt jelenti, hogy minden könyvtár ami x-el kezdődik.

Fájlok szerkesztésére nagyon sok eszköz áll rendelkezésre. Lehet parancssorból a sed paranccsal szerkeszteni. Vagy lehet erre a célra kitalált szövegszerkesztőket használni. Legyen például a virag.txt nevű állomány amit szeretnénk szerkeszteni:

vi virag.txt

vagy

nano virag.txt

vagy

mcedit virag.txt

Az Midnight Commander beépített szövegszerkesztője. Valójában egy szimbolikus link az mc parancsra. Ebből következik, hogy a használatához az „mc” csomagnak telepítve kell lennie a gépünkön.

A vim a vi továbbfejlesztése. Alapértelmezetten nincs telepítve.

A vim telepítése:

apt install vim

Használata:

vim adat.txt

A nano szövegszerkesztő alapvető billentyűkombinációi Ctrl gombbal működnek. Ezt maga a szövegszerkesztő is tudatja velünk, de a Ctrl helyett egy „^” karaktert látunk mindig. A mentés például a Ctrl+O billentyűkombinációval történhet, amit így látunk:

^O

Vagy a kilépés Ctrl + X billentyűkombináció, amelyet így látunk:

^X

A vágólapos szerkesztési műveleteket kezdjük a kijelöléssel. Először meg kell mondani, hogy most kijelölés jön. A kijelölés végét nem kell jelezni (ellentétben az mceditel). Ha kijelöltük azt amit vágólapra szeretnénk tenni, akkor el kell dönteni ezt hogyan szeretnénk. A kijelölt szöveg kivágásával, vagy másolásával. Ennek megfelelő billentyűkombinációt nyomunk. Ezt követően arra a helyre lépünk, ahova a szöveget be kell illeszteni, amit Ctrl + U kombinációval tehetünk meg.

A Ctrl + K billentyűkombinációt használhatjuk kijelölés nélkül is. Ekkor azt a sort vágja ki, amelyikben éppen állt a kurzor a Ctrl + K lenyomásakor.

Amikor létrehozunk egy állományt a merevlemezen létrehozunk számára egy inode nevű bejegyzést. Az inode tartalmazza a következő információkat:

• időbélyegek
• méret
• tulajdonos
• csoport
• jogok
• elfoglalt blokk méret
• IO-blokk méret

A fájl neve nem az inode-ban tárolódik. A fájlnév a szülő könyvtár tartalmi részében tárolódik. A név mellett egy mutató jön létre a fájl inode-ra. Ezt nevezzük linknek.

További linkeket hozhatunk létre az ln paranccsal:

touch fruit.txt
ln fruit.txt frutta.txt

A fruit.txt és a frutta.txt is ugyanarra az inode-ra mutat. Ellenőrizzük az ls paranccsal. A -i kapcsoló megmutatja inode azonosítót:

ls -li fruit.txt frutta.txt

A lehetséges kimenet:

1059029 -rw-r--r-- 2 janos janos 2 okt   12 21:06 fruit.txt
1059029 -rw-r--r-- 2 janos janos 2 okt   12 21:06 frutta.txt

Ha már két merev link mutat egy fájlra, a fájl csak akkor törlődik, ha mindkét linket töröljük.

Vegyük a következő példát. Létrehozok egy fájlt:

touch erdo.txt

Most létrehozok egy rámutató linket:

ln erdo.txt fak.txt

Most törlöm a erdo.txt-t:

rm erdo.txt

A fájl maga nem kerül törlésre, mert a fak.txt nevű link még az állományra mutat. Az állomány törlése csak ekkor történhet meg.

Az ls -l parancs kimenetében vegyük észre a linkek számát.

A szimbolikus link másként viselkedik, mint a merev link, ezért is nevezzük szimbolikusnak.

A szimbolikus link létrehozásakor létrejön egy új inode bejegyzés. Az ebben található mutató viszont nem célként megadott inode-ra mutat. Helyette a célhoz tartozó névre mutat (ami egy merev link neve).

Ennek eredménye, ha töröljük a merev linket, a szimbolikus link nem fog mutatni sehova.

Szimbolikus link létrehozása

ln -s fajlnev linkfajlra

A fájlrendszerben szimbolikus linkre példa:

ls -l /vmlinuz

A kísérletezéshez lehetőleg újonnan telepített Linuxot használjunk, ahol a háttérben nagy eséllyel nem jönnek létre újabb fájlok, nincs még szolgáltatás telepítve.

Kísérletképpen hozzuk létre a fruit.txt állományt, ha az még nem létezik. A kísérlet folytatása előtt nézzük meg az adott fájlrendszeren mennyi a szabadon felhasználható inode:

stat -f fruit.txt

A kimenet utolsó sorában például ilyet láthatunk:

Inode-ok: összes: 36626432   szabad: 35042423

Vagyis van 35042423 szabad inode.

Most hozzunk létre egy obst.txt nevű szimbolikus linket, ami a fruit.txt-re mutat:

touch fruit.txt
ln -s fruit.txt obst.txt

Most nézzük meg a hozzájuk tartozó inode azonosítókat:

ls -li fruit.txt obst.txt

A fruit.txt és az obst.txt inode azonosítói különböznek.

Most nézzük meg újra, hány szabad inode van:

stat -f fruit.txt

A kimenet utolsó sora ilyen lehet:

Inode-ok: összes: 36626432   szabad: 35042422

A szabad inode-ok számra eggyel csökkent, azaz létrejött egy új inode.

A stat parancs még több információt szolgáltat egy állományról vagy egy könyvtárról.

stat fajlnev

Például:

stat log.txt

  File: "log.txt"
  Size: 0         	Blocks: 0          IO Block: 4096   szabályos üres fájl
Device: 802h/2050d	Inode: 1461005     Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1000/  andras)   Gid: ( 1000/  andras)
Access: 2012-01-15 23:00:17.365731988 +0100
Modify: 2011-08-09 22:35:50.584228887 +0200
Change: 2011-08-09 22:35:50.584228887 +0200

stat konyvtarnev

Magáról a fájlrendszerről kaphatunk információt a -f kapcsoló megadásával:

stat -f fajlnev

Például:

stat -f log.txt

  File: "log.txt"
    ID: 3f4e5580b0204b72 Namelen: 255     Type: ext2/ext3
Block size: 4096       Fundamental block size: 4096
Blocks: Total: 9612076    Free: 4608081    Available: 4119806
Inodes: Total: 2444624    Free: 2115881

Ha írunk a fájlba, akkor módosul a mtime (Modify time), de ezzel együtt a ctime (Change time) is. A ctime viszont módosul még néhány esetben. Ha például módosítom a fájl jogait, vagy tulajdonsát, akkor a ctime érték frissül.

A -c vagy a --format kapcsolóval kiírathatjuk (többek között) mit ért (hány bájt-ot) a stat blokkméret alatt:

stat --format=%B fajlnev

$ stat --format=%B vmi.txt
512

A fájlrendszer blokkokra van felosztva. Jelenleg szokásos blokkméret 4096 bájlt.

Ha nem lenne ez a felosztás, gondban lennénk, ha egy fájl bővíteni szeretnénk.

Ezért, ha egy kisméretű fájl, például 2 bájt méretű fájl létrehozunk, annak is le van foglalva 4096 bájt hely.

Ha fájl bővítjük így is törve lehet, ha elfogy a 4096 bájt hely. A fájl következő blokkja más helyen jön létre. A fájl így önmagában is töredezett lesz.

Ha törlünk egy fájl, akkor a fájlokat összeségében nézve is töredezettség alakul ki.

Ezért az ext4 fájlrendszer egy 4096 bájt lefoglalt hely után is hagy valamennyi helyet újabb lefoglalható blokkoknak.

A fájlok lemezen foglalt helyét és méretét tudhatjuk meg a „du” parancs segítségével. A du alapértelmezésként a lemezen elfoglalt helyet mutatja meg blokkméretben. 1 blokk 1 kibibájt-nak számít, azaz 1024 bájtnak.

Ha bájt-ban szeretnénk megkapni pontosan mekkora az állomány mérete, akkor a -b vagy --bytes kapcsolót kell használnunk.

Hozzunk létre saját könyvtárunkban egy fájlt:

cd ~
echo "Lorem ipsum doloest amet" > lorem.txt

Nézzük meg a helyfoglalását:

du lorem.txt

Az eredmény:

4	lorem.txt

Nem négy bájt. Négy kibibájt (4 * 1024 bájt). Ennyi helyet foglal a lemezen. A du parancs tehát alapértelmezésben 1024-es blokkokkal számol.

Ha be van állítva a POSIXLY_CORRECT környezeti változó, akkor 512 bájtos blokkokkal kell számolnunk. Állítsuk be a változót és nézzük meg újra a parancs kimenetét:

set -o posix
export POSIXLY_CORRECT
du lorem.txt

Megjegyzés: A korábbi Bash változatokban (Debian10 előtt), nem volt szükség az export parancsra. Ugyanakkor, a set és export helyett megfelel egy export POSIXLY_CORRECT=1 utasítás is.

A kimenet:

8	lorem.txt

A kimenetben most 8 blokk, vagyis 8 darab 512 bájtos helyet foglal az állományunk, ami 4096 bájt összesen.

A POSIXLY_CORRECT környezeti változót azért szokták beállítani, hogy a programok úgy működjenek, hogy megfeleljenek a POSIX szabványnak. A POSIXLY_CORRECT kikapcsolásához:

set +o posix

A set Bash belső parancsa, több információért nézd meg a leírását:

help set

Most nézzük meg a valós méretét:

du -b lorem.txt

vagy:

du --bytes lorem.txt

26 bájtot kapunk:

26	lorem.txt

Nézzük meg a stat paranccsal is a lorem.txt lefoglalt blokkméretét. Vegyük észre a különbséget. A stat azt mondja 8 blokk, mert az eleve 512 bájt mérettel számol.

Ebből láthatjuk, hogy az adott fájlrendszer blokkmérete 4096 bájt.

A teszteléshez létrehozhatunk egy 4096 bájt nagyságú fájlt:

dd if=/dev/zero of=teszt.txt bs=1024 count=4

Nézzük meg a du paranccsal hány blokkot foglal:

$ du teszt
4       teszt.txt

Most adjunk hozzá még két bájtot:

echo a >> teszt.txt

Megjegyzés: egy sortörés is hozzáíródik, azért 2 bájt.

Ellenőrizzük újra:

$ du teszt
8       teszt.txt

A fájlnevek tartalmazhatnak ékezetes fájlneveket, számokat, alulvonást (_), kötőjelet, pontot stb.

Vegyük észre, hogy a 255 a karakterek száma helyett a szükséges bájtokat tartalmazza. A magyar ékezetes betűk például 2 bájtosak.

A fájlnevek lehetséges hossza fájlrendszerfüggő, de általában mindenhol 255.

Próbáljunk meg létrehozni egy olyan fájlt, amelynek a neve 255 bájt hosszú:

touch 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234

A fájl létrejön. Most próbáljunk meg 256-tal:

touch 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345
touch: '0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345' elérése sikertelen: Túl hosszú fájlnév

A fájl nem hozható létre a hibaüzenet: Túl hosszú fájlnév.

A példában megadott fájlnév hosszát magunk is ellenőrizhetjük a wc -c segítségével. Vegyünk egy rövidebb fájl nevet ami csak 3 karakterből áll. Vegyük a fenti fájlnévnek csak az első 3 karakterét, hogy megnézzük hogyan működik a wc -c.

echo 012 | wc -c
4

Az echo 012 | wc -c eredménye 4, tehát eggyel több, mint ahány karakter van. Most másoljuk az 012 három helyére a fent megadott teljes fájlnevet, ellenőrizzük az eredményt.

Megjegyzés: Egy útvonal maximális hossza 4096 karakter.

A kernel forrásában a limits.h fejállományban van definiálva a maximális nagyság.

• https://github.com/torvalds/linux/blob/master/include/uapi/linux/limits.h

[...]
#define NAME_MAX         255	/* # chars in a file name */
#define PATH_MAX        4096	/* # chars in a path name including nul */
[...]

Ha gépünkön telepítve vannak a fejállományok, akkor ott is ellenőrizhetjük. 4.9.0-3-as kernel esetén:

/usr/src/linux-headers-4.9.0-3-common/include/uapi/linux/limits.h

Ha a fájlok nevei alapján szeretnénk keresni, használjuk a find parnacsot:

find /usr/share -name *.png

Az első paraméter, megmondja, hol keressünk. A -name kapcsoló után megmondom, milyen fájlokra vagyok kíváncsi. A példában a bármilyen fájlnév, aminek kiterjesztése .png, szeretném, látni a találati listában.

Az aktuális könyvtártól is kereshetünk:

find . -name "*.png"

Ha fájlokat tartalom alapján szeretnénk keresni, akkor használjuk a grep parancsot rekurzívan.

Például szeretnénk megkeresni azokat a fájlokat, amelyekben szerepel Ian Murdock neve:

grep -r -l "Ian Murdock" /usr/share/doc

• A -r --recursive kapcsoló rekurzívvá teszi a keresést.
• A -l --files-with-matches kapcsoló hatására csak a fájlok nevei jelennek meg.

Használhatjuk a find parancsot is, de szükséges mellé a grep parancs:

find . -name "*.txt" -print | xargs grep "Nagy József"

Olyan .txt kiterjesztésű fájlokat keresünk, amelyben szerepel a „Nagy József” név.

A -P --perl-regexp kapcsolóval Perl reguláris kifejezés is használható

A find és grep parancsról később részletesen is szó esik.

A locate parancs:

A locate parancs telepítése:

apt install locate

locate minta

Létezik egy /var/lib/mlocate/mlocate.db nevű adatbázis, amely segít megtalálni állományokat. Az adatbázis a következő paranccsal frissíthető:

updatedb

• Milyen fájlszerkesztő parancsok vannak?
• Milyen paranccsal hozhatunk létre egy új üres állományt?
• Milyen paranccsal törölhetek egy állományt?
• Milyen paranccsal nevezhetek át egy állományt? Írjon példát.
• Milyen paranccsal mozgathatok egy saját könyvtáramból egy alkönyvtárba egy fájlt. Írjon példát.
• Milyen paranccsal kérhetünk statisztikát egy fájlról? (jogok, elérése, változtatás, csere ideje).
• Milyen paranccsal kereshetünk fájlokat név alapján?
• Milyen paranccsal kereshetünk fájlokat tartalmuk alapján?

Egy billentyűzet és egy monitor, amely egy számítógéphez kapcsolódik.

Eredetileg a nagygépes Unix rendszerekhez több terminál is csatlakozott. Esetleg egy PC-t is lehetett terminálként használni. A Linuxot ma leggyakrabban nem nagygépre, hanem egy PC-re telepítjük. A PC-hez pedig egyetlen monitor és billentyűzet kapcsolódik alapesetben. Mi ezt tekintjük most terminálnak. A Linux lehetővé teszi, hogy több felületen is belépjünk, mintha több terminálunk lenne. Ezek nem valódi terminálok, így a linuxos terminálokat „virtuális terminálként” szoktuk említeni.

A nagyszámítógép, amelyhez a terminálok kapcsolódnak. Host számítógép alatt mi most PC-t fogjuk érteni, amelyen dolgozunk.

Az első Unix terminálok, amelyek egy billentyűzetből és egy nyomtatóból álltak. Rövidítve TTY. Egy Linuxos rendszeren parancssoros felületen 6 helyen léphetünk be. Ezeket teletype névvel illetjük az ASR33 teletype után. Szokás még terminál néven is említeni.

Terminál nevének kiíratása:

tty

Terminál paramétereinek beállítása:

stty

Paraméter nélkül kiírja a Linux milyen beállításokkal használja a terminált.

Több információt nyerhetünk a ”-a„ kapcsolóval:

stty -a

A kisbetűk nagybetűvé alakítása:

stty olcuc

A kisbetűk nagybetűvé alakításának kikapcsolása:

stty -olcuc

További információkért lásd a man stty parancsot.

Milyen terminált használunk:

echo $TERM

showkey

• Honnan ered a terminál elnevezés?
• Mit jelent a host?
• Írjon egy Teletype típust.
• Milyen paranccsal írathatjuk ki a terminálunk nevét?
• Milyen paranccsal állathatjuk be a terminálunkat?
• Milyen paranccsal állatja be, hogy minden beírt betű nagybetűs legyen?
• Melyik környezeti változó tartalmazza a terminálunk nevét?

Jó néhány parancsot megismertünk, de általában szeretnénk a parancsokról többet megtudni. Esetleg azt is szeretnénk tudni, hogy a parancsokat megvalósító programok valójában hol találhatók. Esetleg szükségünk van egy parancsra de azt sem tudjuk hol, milyen néven keressük. A következő fejezet ezeket a problémákat járja végig.

Alapvetően kétféle parancs van. Ezek:

• belső
• külső

A parancsokat a parancsértelmező fogadja. A parancsértelmező először megnézi, hogy a kiadott parancsot ő maga fogja-e végrehajtani. Ha nem ismeri, akkor egy külső programot keres, amelyet futtat.

A belső parancsok gyűjteményéről a „help” parancs tájékoztat minket.

help

A help valójában egy belső parancs amit Bash értelmez.

A help parancs paraméterezhető, lekérdezhető vele egy konkrét parancs lírása:

help cd

További opciók használatához kérjünk segítéget:

help --help

Valamihez szeretnék parancsot találni. Például könyvtárkezeléshez keresek egy parancsot. Ha telepített rendszer magyar, akkor kereshetek magyar szavakra is. A parancsok kereséséhez egyik lehetséges program az apropos.

Az apropos parancs, a parancsok leírásában keres azt a szót amit megadunk. Keressünk olyan parancsokat, amelyek a hardverrel kapcsolatosak.

apropos hardware

A program kiírja azoknak a programoknak a neveit amelyeknek a leírása tartalmazza a hardware szót.

adjtime_config (5)   - information about hardware clock setting and drift factor
arch (1)             - print machine hardware name (same as uname -m)
discover (1)         - hardware detection utility
discover-pkginstall (8) - intsall packages for available hardware using disco...
hwdb (7)             - Hardware Database
hwinfo (8)           - probe for hardware
report-hw (1)        - dump information on the system's hardware
SDL_GetVideoInfo (3) - returns a pointer to information about the video hardware
sensors-detect (8)   - detect hardware monitoring chips
systemd-hwdb (8)     - hardware database management tool
tc-mqprio (8)        - Multiqueue Priority Qdisc (Offloaded Hardware QOS)
wdctl (8)            - show hardware watchdog status

Magyar nyelvű szóra is kereshetünk:

apropos hardver

Figyeljük meg, hogy a leírásból egy rövid kivonatot is közöl a parancsról, ami leírja mire való a parancs.

$ apropos hardver
hwclock (1)          - a hardveróra (Real Time Clock) lekérdezése és beá...

Ha valamelyik parancs felkeltette az érdeklődésünket és többet szeretnénk róla tudni, használjuk a man parancsot.

man hwclock

Ha elindítottuk a „man hwclock” parancsot, kilépni a „Q” billentyűvel tudunk.

Időzítéssel kapcsolatos programok:

apropos schedule

Ext4 fájlrendszerrel kapcsolatos parancsok:

apropos ext4

Az apropos nem csak parancsokat és programokat talál, mivel a leírás nem biztos, hogy programról vagy parancsról szól.

Ha tudjuk egy parancsnak a nevét, és egy rövid leírást szeretnék mire is jó, akkor használhatjuk a whatis parancsot:

whatis ls

A parancsnak érdemes kipróbálni help paraméterét is:

ls --help

Néhány parancsnak több karakterből álló paramétere csak egy kötőjellel van bevezetve: -help. De az is lehet, hogy csak egy karakter kell: -h Ez mindig az adott program írójától függ. A szabvány szerint több karakteres opciókat mindig két kötőjellel vezetjük, az egy karaktereseket egy kötőjellel.

Előfordulhat, hogy szeretnénk tudni hol található egy program. Például egy scriptet akarunk írni, amelyben az egész útvonalat szeretnénk felvenni. Nekiállhatnánk keresni is, de van egy parancs amelyik megmondja hol van:

which ls

A which parancsot pontosan erre a célra találták ki. A kimenet újaban ez:

/usr/bin/ls

Próbáljuk meg más parancsokkal is.

A type parancs segítségével megtudhatjuk egy adott parancsról, hogy azt a shell tudja, beépített parancsként, vagy valahol a fájlrendszerben egy önálló program. Maga a type bash shell része:

$ type type

Még néhány beépített parancs:

$ type pwd
pwd egy beépített parancs

$ type cd
cd egy beépített parancs

Ha parancs nem shell parancs akkor kiírja annak útvonalát a which utasításhoz hasonlóan:

$ type cp
cp: /bin/cp

Fentebb már láttuk, hogy a programok rövid leírását a whatis parancs megadja, a bővebb leírást pedig a „man”. Ne felejtsük el, hogyan léphetünk ki a man parancs környezetéből. Ezt a „q” billentyű lenyomásával tehetjük meg.

man ls

A kézikönyvek nem csak parancsokat írnak le. Kézikönyvük van a rendszerhívásoknak, az osztott könyvtáraknak, a speciális fájloknak (például dev), fájlformátumoknak, unixos játékoknak, a rendszer-adminisztrátori parancsoknak és a kernel rutinoknak.

A kézikönyv, angolul manual, innen a parancs röviden: man. A kézikönyveknek 9 típusra oszthatók. Ezek:

1. Futtatható programok vagy shell parancsok
2. Rendszerhívások (a kernel függvényei)
3. Osztott könyvtári függvények
4. Speciális fájlok (rendszerint /dev)
5. Fájlformátumok, konverziók (pl. /etc/passwd)
6. Jétékok
7. Egyéb (makrócsomagok, man(7), groff(7)
8. Rendszer-adminisztrátori parancsok (a root felhasználó számára)
9. Kernel rutinok

Az eredeti Unix kézikönyveknek csak 7 típusa volt, Linuxban ez 9-re bővült.

Egy kézikönyv a következő fejezetekre tagolható:

• NAME - rövid leírás
• SYNOPSIS - szintaktikai leírás, vagy áttekintés
• CONFIGURATION - beállítások
• DESCRIPTION - leírás
• OPTIONS - kapcsolók
• EXIT STATUS - kilépési kódok
• RETURN VALUE - visszatérési érték
• ERRORS - hibák
• ENVIRONMENT - környezet
• FILES - fájlok
• VERSIONS - verziók
• CONFORMING TO - egyezések
• NOTES - megjegyzések
• BUGS - a program hibái
• EXAMPLE - példák
• AUTHORS - tulajdonos
• SEE ALSO - „lásd még”

Ezeken kívül, kézikönyvenként előfordulhatnak egyedi fejezetek is, ha leírás azt igényli.

Nézzünk néhány példát: A ps parancs:

man ps

A chmod parancs:

man chmod

A chown parancs:

man chown

Előfordulhat, hogy szeretnénk egy parancs eredeti angol nyelvű verzióját megnézni, mert a magyar nyelvűben nem találjuk a keresett információt (ez előfordulhat, ha például a magyarítást nem frissítették az adott programnál). A Debian GNU/Linux 6.x-es rendszerben például a magyar ps kézikönyv nem tartalmazza a <, N, L, s, l, + státuszok leírását. Az angol nyelvű verzióban azonban megtaláljuk. A nyelv beállításhoz használjuk a -L kapcsolót:

man -L en ps

A nyelvet az ISO-639 szabvány szerint kell beírni.

• Hogyan tudom megnézni a „cd” belső parancshoz tartozó segítő leírást?
• Hogyan tudom megnézni a crontab parancshoz tartozó 5-ös típusú kézikönyvet?
• Milyen fejezetekből állhat egy kézikönyv?
• Milyen paranccsal tudom megnézni, hogy a firefox parancs hol található a fájlrendszerben?
• Milyen paranccsal kereshetek parancsokat?
• Milyen fejezetei vannak az mkfs parancs kézikönyvének?

A szintaxis a parancsok kiadásának formális leírása.

A parancsot begépelve parancssornak nevezzük.

A Linuxos rendszerben egymás után több parancsot is beírhatok pontosvesszővel tagolva:

parancs1 ; parancs2 ; parancsN

A parancsokat && karakterpárossal is tagolhatjuk:

parancs1 && parancs2

Ekkor a parancs2 csak akkor fog végrehajtódni, ha az első sikeres volt.

A prancssort két részre lehet osztani. A parancs neve és az argumentumok.

Példa:

ls -1 -F fajlnev1

A példában az ls a parancs neve ami után jön az pedig mind argumentum. Itt az ls parancsnak három paramétere van.

Az argumentumokat kapcsolókra és paraméterekre osztjuk fel.

Kapcsolók vagy opciók a parancs nevét követik. Egy vagy két kötőjel vezeti be őket. Ha egy kötőjel van, átláthatóbb egy hosszú parancssor. Ha hosszú formát használjuk olvashatóbb. Hogy egy-egy parancs esetén mi van megvalósítva, az csak a programozón múlik.

Az opciók módosítják a parancs végrehajtását.

A paraméterek az opciókat követik. Egy vagy több is lehet belőlük.

A paraméterek határozzák meg, min kell végrehajtani a parancsot.

ls -1 -F  file1 file2 file3

Két opció: -1 -F

Három paraméter: file1 file2 file3

ls -1 -F file1

ls -F -1 file1

ls -1F file1

ls -F1 file1

A -1 és -F opciókat egyetlen kötőjellel is megadhatom. Ilyenkor a két opciót leírom egymás mellé. A sorrend lényegtelen.

Whitespace karakter a szóköz és a tabulátor, sortörés stb. A parancs neve, az opciók és a paraméterek között szóköz vagy tabulátor egy vagy több is szerepelhet:

ls <szóköz>-l<szóköz>-F<szóköz>file1

ls <tab>-l<tab>-F<tab>file1

ls <szóköz><tab>-l<szóköz>-F<tab><tab><tab>file1

A parancsot pedig egy sortöréssel zárjuk.

Az előző argumentumot felhasználhatjuk !$ beírásával.

mkdir Dokumentumok
cd !$

Használhatjuk az <Alt>+<.> billentyűkombinációt is.

Tegyük fel, hogy szeretnénk létrehozni a dir1 könyvtárban egy dir2 könyvtárat. Beírjuk:

mkdir dir1/dir2

De kiderül, hogy a dir1 könyvtár nem is ebben a könyvtárban van. A megfelelő könyvtárba váltunk, majd megismételjük a parancsot:

!!

A parancsokat több sorban is írhatjuk, a „\” karakter segítségével. Legyen például a következő parancs:

ls -l -i -a /usr/share/doc

Két sorba írhatjuk, ha „\” karaktert írunk az első sor végére:

$ ls -l -i -a \
> /usr/share/doc

A mintába beírtam a várakozási jelet is, ami az első sorban „$ ”.

Ha „\” karaktert írunk az első sor végére, a következő sorban, a másodlagos várakozási jel jelenik meg, ami alapértelmezetten ”>„ karakter. Ez után folytathatjuk a parancsot.

Törhetjük akár több sorba is a parancsot:

$ ls \
> -l \
> -i \
> -a \
> /usr/share/doc

• Mi az opció?
• Mi a paraméter?
• Mutasson példát az opciók felcserélhetőségére.
• Mi a Whitespace?
• Hány Whitespace szerepelhet egy parancs neve után?
• Milyen karakterrel kell a sor végére írni, ha a parancsot a következő sorban szeretnénk folytatni?

A Unix rendszerből származnak a szabványos fájlok. Fájloknak nevezzük, mert fájlként is elérhetők.

Az alábbi táblázat egy összefoglalót ad ezekről.

A programozó feladata, hogy olyan programot írjon, amely a külön kimenetre írja a normál kimenetet és a hibakimenetet. Az így megírt programok kimenetét szét tudjuk válogatni, külön fájlokba.

Az stdin a Standard Input rövidítése, magyarul szabványos bemenet. Ez alapértelmezetten a billentyűzet, azonosítója a 0.

Az stdout a Standard Output rövidítése, magyarul szabványos kimenet. Ez alapértelmezetten a képernyő, azonosítója 1-s.

Az stderr a Standard Error rövidítése, magyarul szabványos hibakimenet. Ez is alapértelmezetten a képernyő, azonosítója 2-s.

A cat parancs egy olyan parancs, amely szabványos bemenetről olvas (stdin), és szabványos kimenetre (stdout) ír.

Próbáljuk ki. Csak írjuk be, hogy cat, majd Enter. A következő példában, néhány leütött billentyűt is beírtam:

cat<Enter>
alma<Enter>
alma
körte<Enter>
körte
<Ctrl>+<D>

Az Enter után, a cat szabványos bemenetről, azaz a billentyűzetről vár adatokat. Beírjuk, hogy alma, ekkor befejeződik a sor bevitele, a cat kiírja az alma szót a szabványos kimenetre. Ezt követően egy újabb sorban a cat megint a szabványos bemenetről vár adatokat. Beírjuk körte, az Enter megnyomása után, megint a szabványos kimenetre ír. A folyamatot a Ctrl+d billentyűkombinációval szakítjuk meg.

Most a billentyűzetről fogunk olvasni, a kimenet az stdout helyett viszont egy állomány lesz. Az átirányítást a nagyobb-mint (>) karakterrel fogjuk megvalósítani.

A gyumolcs.txt fájl tartalmát a képernyő helyett a gyumolcs2.txt fájlba irányítom:

cat > gyumolcs.txt
szilva
barack
körte
alma<Ctrl>+<D>

A bevitelt a <Ctrl>+<D> billentyűkombinációval szakítjuk meg, amellyel tulajdonképpen „fájlvége jelet” küldünk a rendszernek.

Bármely program, ha a stdout-ra (képernyőre) ír annak kimenetét átirányíthatjuk fájlba.

Néhány program a normál üzenetek mellett hibaüzeneteket is a képernyőre íródnak. Ezek a hibaüzenetek nem kerülnek fájlba az előbbi átirányítás esetén: A hibaüzenetek átirányítását is megoldhatjuk azonban:

Tegyük fel, hogy nem létezik az aktuális könyvtárban nincs „aaaa” nevű könyvtár és fájl sem, amikor kiadjuk a következő parancsot:

ls aaaa

Az eredmény a képernyőre íródik.

ls: aaaa nem érhető el: Nincs ilyen fájl vagy könyvtár

Ha ezt megpróbáljuk fájlba irányítani a fenti módon nem járunk sikerrel, mivel ez az az üzenet a stdout helyett a stderr-re íródik. Persze alapértelmezetten az is képernyő. Az alapértelmezett kimenet száma a „2”. Meg kell mondanunk, hogy a 2-es számú kimenet szeretnénk fájlba irányítani:

ls aaaa 2> a.txt

Ezek után a képernyőre nem ír semmit a parancs. Az a.txt fájlban viszont:

ls: aaaa nem érhető el: Nincs ilyen fájl vagy könyvtár

A gyumolcs.txt fájl tartalmát a képernyőre írom:

cat < gyumolcs.txt

A cat bemenete alapértelmezetten a billentyűzet. Mi most azt mondtuk, hogy ez egy fájl legyen.

Az adatokat a gyumolcs.txt fájlból vesszük. A gyumolcs.txt fájl tartalmát a képernyő helyett a gyumolcs2.txt fájlba irányítom:

cat < gyumolcs.txt > gyumolcs2.txt

Ha a fájl nemlétezik akkor létrehozza. Ha létezik felülírja.

A kimenet átirányítását a nagyobb-mint (>) karakterrel végeztük. Ez mint láttuk felülírja a létező fájlt. Néha azonban ezt szeretnénk elkerülni, és szeretnénk a már meglévő fájl végéhez fűzni. Ezt kettő darab nagyobb-mint jel egymásután írásával érjük el:

echo "banán" >> gyumolcs.txt

A fenti parancs a gyumolcs.txt fájl végéhez fűzi a „banán” szöveget.

Néha szeretnénk a hibaüzeneteket és a normál üzeneteket is fájlba irányítani. Az alábbi program normál és hibaüzeneteket is generál.

program > kimenet 2>&1

vagy:

program &> kimenet.txt

A kimenet stdout és az stderr képernyőre és fájlba írása, példa:

dir letezofaj.txt nemletezofajl.txt 2>&1 | tee kimenetifajl.txt 

A „tee” parancs egyszerre ír fájlba és a képernyőre.

A parancs után a képernyőn és a kimenetifajl.txt állományban is:

dir: nemletezofajl.txt nem érhető el: Nincs ilyen fájl vagy könyvtár
letezofajl.txt

Az alapértelmezett kimenet és az alapértelmezett hibakimenet szétválasztása a programozásnál kezdődik. A megértéshez vegyünk egy egyszerű C programot, amely a képernyőre ír. Képernyőre ír például a printf() függvény:

printf("Egy\n");

Ugyanezt csinálja a következő utasítás is:

fprintf(stdout, "Egy\n");

Csak itt meg kellett adni, hogy az alapértelmezett kimenet nevét: stdout.

A következő utasítás azt mondja, hogy írjunk az alapértelmezett hibakimenetre:

fprintf(stderr,"Három\n");

A programozó tehát néha azt mondhatja, hogy írjunk a képernyőre, de legyen megkülönböztetve a példában a „Három” szó kiíratása, mert az a hibakimenetre megy. A „\n” az sortörés.

Lássunk egy komplett programot:

main.c

#include <stdio.h>
main()
{
    printf("Egy\n");
    fprintf(stdout, "Kettő\n");
    fprintf(stderr, "Három\n");
}

A programban a „Egy” és „Kettő” szavak az alapértelmezett kimenetre mennek. Az alapértelmezett kimenet száma 1. A „Három” szó viszont a már a hibakimenetre megy, melynek száma 2.

Ha gépünkön telepítve van a gcc fordító, akkor fordítsuk le a programot:

gcc -o main main.c

Elkészül egy main nevű állomány. Ha futtatjuk:

./main

a képernyőre íródik mind a három szám:

Egy
Kettő
Három

Most használjuk az átirányítást. Irányítsuk fájlba az alapértelmezett kimenetet:

./main > naplo.txt

vagy:

./main 1> naplo.txt

Ekkor a „Három szót a képernyőre íjra a program, az „Egy” és a „Kettő” viszont a naplo.txt nevű állományba kerül.

Most irányítsuk az alapértelmezett hibakimenetet a állományba:

./main 2> naplo.txt

Most a képernyőre íródik az „Egy” és a „Kettő” szó, a „Három” pedig állományba.

Ha pedig mind két kimenetet állományba szeretném irányítani, akkor:

./main &> naplo.txt

Ekkor mind a három szó fájlba kerül.

Láthatjuk, hogy a stdout és stderr technika lehetővé teszi, hogy elválasszuk egy program normál üzeneteit a hibaüzenetektől, ami céljainktól függően néha nagyon jól jöhet.

A következőkben a szintén átirányítást fogunk használni, azonban most egy másik program számára adjuk át a kimenetet. Ezt a pipe (|) karakter segítségével valósítjuk meg.

cat gyumolcs.txt | sort

Létrehozunk egy állományt.

cat > gyumolcs3.txt
körte
szilva
barack
alma
szilva<Ctrl>+<D>

Az állomány tartalmaz néhány ismétlődést. Ezt kezelni tudjuk az uniq paranccsal. Az uniq parancs azonban csak rendezett állománnyal képes dolgozni. Először tehát rendeznünk kell a tartalmat.

cat gyumolcs3.txt | sort | uniq

Esetleg ha szeretnénk megszámoltatni a sorok számát is, akkor:

cat gyumolcs3.txt | sort | uniq | wc -l 

Az egésznek az eredményét pedig ugyancsak fájlba irányíthatjuk:

cat gyumolcs3.txt | sort | uniq | wc -l > gyumolcsszam.txt

A ”>” karakter önmagában is kiadható, mint egy parancs. Ha utána írunk egy állományt, annak tartalma törlődik. Így használható állományok tartalmának törlésére:

> vmi.txt

• Mi a stdin?
• Mi a stdout?
• Mire használjuk a „<” karaktert?
• Mire használjuk a „>” karaktert?
• Mire használjuk a „|” karaktert?
• Mit csinál a 2> átirányítás?
• Mit csinál a 1> átirányítás?
• Mit csinál a &> átirányítás?
• Írassuk a ki a belépett felhasználók neveit, a kimenetet a users.txt fájlba irányítva.
• Mit csinál a következő parancs: > gyumolcsok.txt

Egy parancsot úgy tudunk végrehajtani, ha tudjuk melyik könyvtárban van, akkor beírjuk az útvonalát és egy <Enter>-t nyomunk. Például gcc paranccsal szeretnénk egy programot lefordítani, akkor ezt írhatjuk:

/usr/bin/gcc -o main main.c

Ehhez tudnunk kell, hogy a gcc parancs az /usr/bin könyvtárban van. Szerencsére nem kell ezt nekünk megjegyezni. A rendszer biztosít számunkra egy PATH nevű környezeti változót. Ha ez tartalmazza az /usr/bin karaktersorozatot akkor a gcc parancs kiadásánál a parancsértelmező megnézi, hogy van-e az /usr/bin/ könyvtárban gcc parancs. Ha van akkor végrehajtja. Persze a PATH változóban egyszerre több útvonal is megadható, egymástól kettősponttal elválasztva. Felhasználóként az útvonal nekem például így néz ki:

/home/andras/bin:/usr/local/bin:/usr/bin:/bin:/usr/games

Ezt le tudjuk kérdezni például az „echo” paranccsal, mint azt már fentebb tettük a PS1 környezeti változóval:

echo $PATH

Próbáljuk ki a parancsot. A parancsértelmező ezekben a könyvtárakban keresi az általunk kiadott parancsot. Ha a parancs útvonala nincs a PATH változóban, akkor kénytelen vagyunk beírni az útvonalat. Ilyen parancs lehet például az ifconfig, amely a hálózati kártyák beállítását kérdezi le. Az ifconfig parancs a /sbin könyvtárban van, ami az átlag felhasználónak nincs útvonalban. Igaz a felhasználó nem végezhet vele beállításokat, de a kártya beállításait lekérdezheti. Ehhez viszont meg kell adnia a teljes elérési utat:

/sbin/ifconfig

Felmerülhet a kérdés, mi van akkor ha egy parancs több könyvtárban is szerepel, amelyik útvonalban van. Ekkor az a parancs hajtódik végre, amelyik a PATH változóban hamarabb szerepel. Ha a másik parancsot szeretnénk, akkor meg kell adjuk a teljes elérési utat.

Parancssor beállítása általánosságban:

export PATH=$PATH:/új/útvonal

A példa kedvéért a joska nevű felhasználó szeretné beállítani a saját könyvtárában (/home/joska) lévő „programok” nevű könyvtárat útvonalba. Ekkor parancssorban kiadjuk a következő parancsot:

export PATH=$PATH:/home/joska/programok

Ezek után a /home/joska/programok nevű mappában lévő program futtathatók bárhonnan.

Ez az útvonal így csak az aktuális konzolon lesz elérhető. Ha kilépünk, akkor már nem. Ha szeretnénk újra- belepés, indítás után is elérni akkor be kell másolnunk például a /home/joska/.bashrc fájl utolsó sorába. Ez után a következő belépés után az útvonalnak élnie kell. A .bashrc fájlt szerkeszthejtük így:

mcedit /home/joska/.bashrc

Vagy ha éppen a /home/joska könyvtárban állunk akkor csak röviden:

mcedit .bashrc

Parancssorból egyetlen paranccsal is megoldhatjuk a fájl végére írást:

echo "export PATH=$PATH:/home/joska/programok" >> /home/joska/.bashrc

Ha ezt használjuk, akkor vigyázzunk a kettő darab nagyobb-mint jelre. Ha csak egyet írunk, akkor felülírjuk az egész .bashrc fájlt. Ha biztosra akarunk menni akkor előbb készítsünk róla biztonsági másolatot:

cp /home/joska/.bashrc /home/joska/.bashrc_mentes

• Az operációs rendszer hol tárolja a parancsok útvonalait?
• Hogyan tudjuk megtekinteni az aktuális útvonalakat?
• Milyen paranccsal állítom be az útvonalat?
• Állítsuk be saját könyvtárunkban létrehozott prg nevű könyvtárban is keresse a parancsértelmező a parancsokat.

Belépés után a rendszer, egy környezetet biztosít számunkra. Kapunk egy parancsértelmezőt és különböző változókat. Lesz egy saját könyvtárunk, amit home könyvtárnak is hívunk. A home fiókok a /home főkönyvtárban kapnak helyet, alapértelmezetten.

Minden felhasználó könyvtárába megjelenik két állomány is:

.bashrc
.profile

A könyvtárunkban az első használat során létrejön egy állomány:

.bash_history

Ebben tárolódnak a használt parancsaink.

Parancssorban a le és fel billentyűkkel lapozhatjuk az eddig használt parancsokat.

Keresésre is lehetőség van. Ez akkor hasznos, ha már régen használtuk a parancsot, így könnyebb megtalálni. Legyen a régen használt parancs például:

ssh -i ~/.ssh/janos_zold_rsa janos@zold.and

A kereséshez elsőként nyomjuk meg a <Ctrl> + <R> billentyűt. Ekkor a következő várakozási jel jelenik meg:

(reverse-i-search)`':

Írjuk be: ssh -i Írás közben a keresési eredmények rögtön megjelennek. Ha azt a parancsot látjuk, amelyet szeretnénk alkalmazni, csak nyomjuk meg a <Tab> billentyűt. A parancs ezek után várja, hogy az <Enter> billentyűvel végrehajtsuk.

A használt parancsokat a history nevű paranccsal is megjeleníthetjük. Egy idő után olyan sok parancs van, hogy túl fut a képernyőn. A more vagy a less szűrővel, tördelhetjük a képernyőt:

history | less

• Melyik az a két állomány, ami a felhasználó létrehozásakor annak könyvtárába másolódik.
• Mit tárol a Linux a historyban?
• Milyen billentyű kombinációval kereshetünk a használt parancsok között?

Az archiválás nem egyenlő a tömörítéssel. Az archiválás azt jelenti több könyvtárat és/vagy fájlt egyetlen fájlba mozgatunk, vagyis egyetlen fájlként szeretnénk kezelni. Erre a tar parancs használható.

A konyvtar nevű könyvtár és tartalmát szeretnénk az fajlnev.tar állományba elhelyezni. A következő parancsot használhatjuk:

tar -cf fajlnev.tar konyvtar

A -cf tulajdonképpen két kapcsoló, egy -c és egy -f, de azok összevonhatók. A -c create szóból, az archív elkészítésre utal, a -f pedig a fájlra, vagyis utána adjuk meg az archív fájl nevét.

Egy .tar archív a -x kapcsolóval csomagolható ki. A x a eXtract szóból van. Példa egy fájl kibontására:

tar -x -f fajlnev.tar

tar -czf archive.tar.gz konyvtar

• A -c kapcsoló megmondja, hogy készíteni kell egy archivot.
• A -z megmondja, hogy archivot tömöríteni is kell.
• A -f után adjuk meg a kimeneti fájl nevét
  • A kimeneti fájl a példában a: archive.tar.gz
• A „konyvtar”, amit archiválni és tömöríteni kell.

A példában a -c, -z és -f kapcsolókat halmoztuk: -czf

Halmozás nélkül az eredeti parancs:

tar -c -z -f archive.tar.gz konyvtar

A tömörített archive kibontása:

tar -xf archive.tar

eXtract [UK: ɪkˈstrækt] [US: ɪkˈstrækt] kibont

Tömörített archive kibontása:

tar -xzf archive.tar.gz

Használt kapcsolók

• -c, --create
• -f, --file fájlnév
• -z, --gzip, --ungzip
• -x, --extract, --get
• -t, --list
• -W, --verify (-c kapcsolóval)
• -v, --verbose bőbeszédű

verify [UK: ˈverɪfaɪ] [US: ˈverəˌfaɪ] átvizsgál, bizonyít, ellenőriz

• Adott három állomány: ser1, ser2, ser3.
  • Archiválja őket egy ser.tar nevű fájlba
• Adott a ser.tar nevű archív fájl.
  • Csomagolja ki a tar parancs segítségével.
• Adott a ser.tar nevű archív fájl.
  • Listázza ki, milyen állományok vannak benne.
• Készítsen a dir1 nevű könyvtárról egy archívumot.
  • Archiválás közben ellenőrizze a fájlokat.
• Adott három állomány: ser1, ser2 ser3.
  • Számolja ki, hány bájt összesen a 3 fájl.
  • Archiválja a 3 fájlt egy állományba.
  • Írassa ki, hány bájt lett az archív fájl.

Linux alatt szinte minden tömörítő eljárás megvalósításra került. A következő lista a teljesség igénye nélkül tartalmaz tömörítő programokat:

• xz
• arc
• gzip
• bzip2
• pbzip2
• lrzip
• lzip
• p7zip
• rzip (nagy fájlokhoz)
• ncompress (csomag; parancs: compress)

További parancsokért nézzük meg a gzip kézikönyvét:

man gzip

További csomagokért nézzünk szét a csomagok között:

apt-cache search compress

Tar fájl tömörítése:

gzip fajlnev.tar

Eredmény:

fajlnev.tar.gz

gunzip fajlnev.tar.gz

Eredmény:

fajlnev.tar

Mostanában népszerű a xz-utils csomagban található tömörítő program. Az LZMA2 algoritmust használja. Az xz tulajdonképpen a 7z lecsupaszított változatának is tekintik (A 7z bzip2, LZMA2 és LZMA eljárásokat kombinálja).

Tömörítés:

xz fajlnev.tar

Kapunk egy fájlt fajlnev.tar.xz nevű fájlt.

Kibontás:

unxz fajlnev.tar.xz

Az xz-utils telepítésével létrejön egy lzma nevű szimbolikus link is. Így használható ez is tömörítésre:

lzma fajlnev.tar

Ennek eredménye egy fajlnev.tar.lzma csomag. Néhány esetben ez jobb tömörítési arányt adhat mint az xz parancs.

A zcat tömörített fájlok tartalmát jeleníti meg.

zcat /var/log/user.log.2.gz

A zcat tömörített fájlok tartalmát teszi lapozhatóvá.

zless /var/log/user.log.2.gz

A zgrep tömörített fájlok tartalmát szűrhetővé teszi.

zgrep postfix /var/log/user.log.2.gz

A programról „program” néven beszélünk amíg az egy háttértárolón van. Ha elindítottuk a programot, akkor bekerül a memóriába, ekkor folyamatról beszélünk. A folyamat tehát egy futó program a memóriában, másként végrehajtás alatt lévő program. Angolul task vagy process néven találkozunk vele. Az átlagfelhasználó persze nem szokta ezeket neveket használni, egyszerűen csak programként beszél róla.

A folyamatok újabb folyamatokat indíthatnak. Amikor elindítunk egy parancsot, azt eleve egy parancsértelmező programban tesszük. A parancsértelmezőből indított folyamat szülője maga a parancsértelmező. Valójában minden folyamat visszavezethető a hierarchiában egy közös ősfolyamatra, ennek neve: „init”.

A folyamat előállítása, tulajdonképpen egy program futtatása. Két eset lehetséges, a rendszer vagy tudja hol van az elindítani kívánt program, vagy mi magunk mondjuk meg hol találhatók azok. A következő lista azon könyvtárakat sorolja fel, ahol nagy valószínűséggel találunk indítható programokat:

• /bin
• /sbin
• /usr/bin
• /usr/sbin

Egyéb helyek:

• /usr/games
• /usr/local/bin
• /usr/local/sbin

Szeretnénk például futtatni az ifconfig parancsot. Írjuk be:

/sbin/ifconfig

Vagy a dmesg parancs:

/bin/dmesg

Ha egy parancs útvonalban van, akkor nem kell megadnunk a teljes útvonalat. Elég az ifconfig, vagy a dmesg parancs kiadása.

Ha egy parancs az aktuális könyvtárban van, végigírhatjuk a teljes útvonalat, vagy a „./” karakterpárossal jelzem, hogy helyben keresendő a parancs.

A felhasználóknak szokás a saját könyvtárukban egy „bin” nevű könyvtár létrehozása, amelyben elhelyezhetik saját programjaikat, scriptjeiket. A joska felhasználó például ide rakja saját programjait:

/home/joska/bin/

A folyamatok száma a rendszerben korlátozott. A maximálisan létrehozható folyamatok száma alapértelmezésben: 32768. A rendszeredben a maximális értéket így derítheted ki:

cat /proc/sys/kernel/pid_max

Egy felhasználó azonban nem hozhat létre 32768 számot. A felhasználói limit lekérdezése:

ulimit -u

A folyamatok vagy angolosan processzek a ps parancs segítségével listázhatók. Paraméter nélkül használva csak az aktuális terminálról indított folyamatokról informál minket:

ps 

PID TTY          TIME CMD
8205 pts/2    00:00:00 bash
8215 pts/2    00:00:00 ps

Indítsunk három folyamatot, amelyet rögtön a háttérbe is teszünk:

nano &
mcedit &
yes > /dev/null &

A folyamataink megtekintése:

ps

  PID TTY          TIME CMD
 2975 pts/0    00:00:00 bash
22403 pts/0    00:00:00 nano
22407 pts/0    00:00:00 mcedit
22409 pts/0    00:02:59 yes
22411 pts/0    00:00:00 ps

Nézzük meg milyen állapotban vannak a háttérbe tett folyamatok (ps a):

...
22403 pts/2    T      9:58 nano
22407 pts/2    T      0:00 mcedit
22409 pts/2    R      0:00 yes
...

A harmadik oszlop mutatja a státuszokat.

Az R futó (runing), a T megállított (terminate, de lehet trace vagyis nyomkövetett. Láthatjuk, ahogy a nano és az mcedit programokat háttérbe tettük, azok megállított állapotba kerültek. A yes parancs viszont futó állapotba került. A yes parancs csak az y karaktert írja a képernyőre szünet nélkül. Mi persze ezt a /dev/null-ba irányítottuk. Amikor az „&” karakterrel háttérbe tesszük a folyamat nem áll meg.

Megnézhetjük az össze folyamatot a ps ax paranccsal:

ps ax

A kapcsolókat nem vezettük be kötőjellel.

Ezek után ehhez hasonló kimenetet láthatunk (részlet másolata):

PID TTY      STAT   TIME COMMAND
...
 4244 ?        S      0:01 /usr/sbin/apache2 -k start
 4245 ?        S      0:00 /usr/sbin/apache2 -k start
...
 8474 ?        S      0:01 [kworker/1:2]
 8509 ?        R      0:01 [kworker/1:1]
 8572 pts/2    R+     0:00 ps ax

A PID oszlop tartalmazza a folyamatazonosítókat (process identity) az első oszlopban.

A TTY oszlop azt mutatja, hogy a folyamat TeleTYpe-hoz van-e kötve. A szolgáltatást nyújtó démon programok nincsenek.

A STAT oszlop a folyamat állapotáról tájékoztat.

A TIME oszlop mutatja, hogy a processzor idejéből mennyit használ.

Az utolsó oszlopban (COMMAND) a futtatott parancs nevét látjuk kapcsolókkal együtt.

A -f kapcsoló a full szóból ered, használata teljes kiemenet ad:

ps ax -f

Az „f” alparancs viszont megmutatja a gyermek szülő kapcsolatokat:

ps axf

Például egy részlet:

 1366 ?        Ss     0:00 /usr/sbin/apache2 -k start
 2522 ?        S      0:00  \_ /usr/sbin/apache2 -k start
 2523 ?        S      0:00  \_ /usr/sbin/apache2 -k start
 2524 ?        S      0:00  \_ /usr/sbin/apache2 -k start
 2525 ?        S      0:00  \_ /usr/sbin/apache2 -k start
 2526 ?        S      0:00  \_ /usr/sbin/apache2 -k start

A folyamatot indító felhasználók mutatása:

ps axu

A STAT mezőhöz járulékos jelzések adhatók a BSD szerinti formátumban. A man -L en ps kézikönyvben találunk róla infot:

A folyamatok állapotai az fs/proc/array.c állományban vannak leírva, a task_state_array[] tömbben.

Néhány példa:

ps -f

UID        PID  PPID  C STIME TTY          TIME CMD
andras   22290 22151  0 07:32 pts/5    00:00:00 bash
andras   23071 22290  0 11:40 pts/5    00:00:00 ps -f

• UID felhasználó azonosító
• PID folyamatazonosító
• PPID szülőfolyamat azonosítója
• C processzor kihasználtság
• STIME indulási idő
• TTY melyik teletájphoz van kötve
• TIME felhalmozott processzoridő
• CMD indító parancs

Egy paraméterek esetén, pl. -f:

• USER A folyamat tulajdonosa
• %CPU A CPU idő osztva a folyamat futási idejével.
• %MEM A folyamat rezidens része a fizikai memóriában
• VSZ Az egész folyamat virtuális-memória használata (KiB)
• RSS A folyamat azon része, amely a fizikai memóriában van (KiB)
• STAT Többkarakteres folyamatállapot
• START A folyamat indulási ideje vagy dátuma
• COMMAND parancs az összes argumentummal

ps -o pid,stat,cmd
  PID STAT CMD
 3823 Ss   bash
 4582 R+   ps -o pid,stat,cmd

ps a -o user,tty,cmd

A -ef kapcsolópárossal a folyamatok szüleinek PID-t is láthatjuk, ez a PPID.

Az oszlopok ekkor így néznek ki:

UID    PID   PPID  C  STIME  TTY  TIME     CMD
root   1     0     0  10:24  ?    00:00:01 /sbin/init
root   2     0     0  10:24  ?    00:00:00 [kthreadd]
root   3     2     0  10:24  ?    00:00:00 [ksoftirqd/0]
root   4     2     0  10:24  ?    00:00:00 [kworker/0:0]
root   5     2     0  10:24  ?    00:00:00 [kworker/0:0H]
...

ps ax | grep -w Z

A postfix gyermekei:

ps -ef --forest | grep -v grep | grep postfix

Az apache2 gyermekei:

ps -ef --forest | grep -v grep | grep apache2

ps f -C apache2

A folyamatot elsőként mindig próbáljuk meg normál módon leállítani, a 15-ös jelzéssel. Ha ez nem megy, csak és csakis akkor forduljunk a 9-es jelzéshez.

kill -15 PIDSZÁM

kill -9 PIDSZÁM

A PIDSZÁMOT a „ps ax” parancs kimenetéből nézhetjük ki. Ha leállítandó program azonosítója 4852, akkor így állítjuk le:

kill -9 4852

A Linuxos rendszerben a folyamatok jelzésekkel kommunikálnak egymással. A használható jelzéseket kilistázhatod a következő paranccsal:

kill -l

További információkat olvashatsz a jelzésekről a man7 signal kézikönyvből.

Egy folyamat egyes jelzéseket figyelmen kívül hagyhat, másokat kötelezően figyelembe kell vennie. Egyes jelzéshez tartozik alapértelmezett művelet, egyesekhez nem.

Az alábbi táblázatban 31 jelzést látunk. Ezek az első Bell Laboratórium létrehozott Unixból származnak. A POSIX szabvány alapján, további jelzésekkel egészült ki a jelzések listája, 34-től 64-ig.

man 7 signal kézikönyv alapján:

• Termi - megállítja a folyamatot
• Core - megállítja a folyamatot, majd a kidumpolja a core adatokat
• Stop - megállítja a folyamatot
• Cont - folytatja a folyamatot, ha az meg volt állítva
• Ign - elutasítja a folyamatot

A kill paranccsal lekérdezhetjük egy jelzés száma alapján a nevét. Például:

kill -l 1

Démon folyamat újraindítása:

killall -HUP pidszám

Egy 0 számú szignállal azt is megvizsgálhatjuk, hogy egy folyamat fut vagy nem fut.

A kernelfolyamatok nem fogadnak el jelzéseket, azokat figyelmen kívül hagyják.

Olvasnivalók: man signal, man 7 signal

A folyamatokat ideiglenesen leállíthatjuk a Ctrl+Z billentyűkombinációval.

Indítsuk el a nano nevű szövegszerkesztő programot:

nano

Az indítás után a Ctrl+Z billentyűkombinációval tegyük háttérbe. Most indítsunk egy másik nano nevű programot, tegyük ezt is háttérbe a Ctrl+Z billentyűkkel. Indítsunk egy vi nevű szövegszerkesztőt. Tegyük a Ctrl+Z-vel háttérbe. Most indítsunk egy mutt nevű levelező programot. Tegyük háttérbe ezt is.

Ezek után nézzük meg a háttérbe tett folyamatokat a „jobs” paranccsal:

jobs

Az eredmény ehhez hasonló:

[1]   Megállítva              nano
[2]   Megállítva              nano
[3]-  Megállítva              vi
[4]+  Megálíltva              mutt

A megállított nano, vi és mutt programokat látjuk. Mindegyik kapott egy sorszámot. A sorszámokat használhatjuk annak jelzésére, hogy melyiket szeretnénk előtérbe hozni.

Előtérbe az „fg” paranccsal hozhatjuk a folyamatokat. Ha csak önmagában adom ki az „fg” parancsot, akkor az utolsót, esetünkben a mutt nevű folyamatot hozza vissza. Az „fg” parancsnak azonban paraméterként megadhatok egy sorszámot is. Például a második nano program visszahívása:

fg 2

Egy folyamat persze már indításkor is háttérbe tehető:

yes > /dev/null &

Ha az fg parancsnak nem adunk meg paramétert, akkor a legkisebb azonosító számú programot fogja előtérbe hozni.

A yes parancs folyamatosan a képernyőre írja a paraméterként megadott szöveget, és a coreutils csomagban található. Ha nem adunk meg paramétert akkor az y betűt írja. Használhatjuk tesztekhez. Például irányítsuk a y betűk sorozatát a /dev/null állományba:

yes > /dev/null

Így kapunk egy programot, amely folyamatosan a fut. A termináltól úgy tudom elszakítani, hogy a tanult módon háttérbe helyezem:

Ctrl + Z

Vagy már indításkor is a háttérbe helyezhetjük:

yes > /dev/null &

Az elindított folyamatok számát ellenőrizzük, majd hozzuk előtérbe azokat és szakítsuk meg. Megszakítás a következő billentyűkombinációval:

Ctrl + C

A használható parancs:

pstree

Csak a jozsi felhasználó folyamatainak megjelenítése:

pstree joszi

A pstree kimenete átadható a less parancsnak lapozás céljából:

pstree | less

Vagy:

pstree joszi | less

A példa kedvéért indítsunk két folyamatot, amit leállítunk. Feltételezzük, hogy a felhasználónevünk „tibi”. A teendők a következők:

nano <Ctrl>+<Z>
nano <Ctrl>+<Z>
pstree -c tibi

Lehetséges kimenet (ha tibi csak egyszer lépett, és csak ezeket a programokat futtatja egy teletájpról):

bash─┬─nano
     └─nano

Folyamatok valós idejű figyelése

Kilépés:

q

A h billentyűvel lekérdezhetjük a használható billentyűket:

h

A folyamatok által használt fájlokat és socketeket az fuser paranccsal tudjuk vizsgálni.

Szeretnénk látni azoknak a folyamatoknak a PID-jét, amelyeket az aktuális felhasználó használ:

fuser .

A kimenet:

.:                   21384c

A példában szereplő PID szám végén van egy „c” karakter. Ez a hozzáférés típusát mondja meg számunkra. Lássuk milyen típusok vannak még:

A részletek megmutatásához írjuk be a -v kapcsolót:

fuser -v .

A kimenet:

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
.:                   joska     21384 ..c.. bash

Melyik program használt egy adott portot?

Vizsgáljuk meg rootként a 80-as portot:

fuser -v -n tcp 80

A kimenet:

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
80/tcp:              root       1416 F.... apache2
                     www-data   1539 F.... apache2
                     www-data   1540 F.... apache2
                     www-data   1541 F.... apache2
                     www-data   1542 F.... apache2
                     www-data   1543 F.... apache2
                     www-data   2856 F.... apache2
                     www-data   2909 F.... apache2
                     www-data   2925 F.... apache2
                     www-data   2926 F.... apache2

fuser -v -n tcp 12345

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
12345/tcp:           andras     3097 F.... server

A mount paranccsal felcsatolt /mnt/valami könyvtárat valami foglalja. A következő parancs leállítja ezt a programot:

fuser -vmk /mnt/valami

./fuser

fuser -v server 

Eredmény:

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
server:              andras     3097 ...e. server

fuser -v /var/run/mysqld/mysqld.sock 

Eredmény:

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
/var/run/mysqld/mysqld.sock:
                     mysql      1905 F.... mysqld

fuser -v -k server

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
server:              andras     3097 ...e. server

Ha program terminálhoz van kötve, akkor a következőt láthatjuk:

./server
Kilőve

fuser -v -i -k server

                     FELHASZNÁLÓ  PID HOZZÁFÉRÉS PARANCS
server:              andras     3199 ...e. server
Kilövi a(z) 3199 folyamatot? (i/N) 

fuser -v -i -k ./

Eredmény:

./:                            FELHASZNÁLÓ    PID    HOZZÁFÉRÉS  PARANCS
                               joska          1231   ..c..       bash
                               joska          1327   ..c..       nano
                               joska          1343   ..c..       mcedit
                               joska          1345   ..c..       yes
Kilövi a(z)  1282 folyamatot? (i/N) n
Kilövi a(z)  1327 folyamatot? (i/N) i
Kilövi a(z)  1343 folyamatot? (i/N) i
Kilövi a(z)  1345 folyamatot? (i/N) i
[1]   Kilőve                  nano
[2]   Kilőve                  mcedit
[3]   Kilőve                  yes

A pgrep és pkill parancsok segítségével a folyamatlistát tudjuk megszűrni minta alapján. A mintában használhatók helyettesítő karakterek is, a man 7 regex alapján.

A rendszerben több felhasználó is indíthatott nano szövegszerkesztőt. Mi most a joska nevű felhasználó által indított nano folyamat PID számára vagyunk kíváncsiak:

pgrep -u joska nano

Szeretnénk leállítani mindenáron a joska által indított nano folyamatokat:

pkill -9 -u joska nano

A pgrep és a pkill persze igazán akkor hasznos, ha mintákat is használunk.

A felhasználókat megadhatjuk a UID alapján is. A root felhasználó folyamatai:

pgrep -lu 0

A pidof segítségével folyamatok azonosítóját deríthetjük ki. Indítsunk egy nano programot, majd tegyük a Ctrl+Z-vel háttérbe. Majd futtassuk a következő parancsot:

pidof nano

A parancs az összes nano folyamat PID számát kiírja. Lehetséges kimenet:

3745 3694 3693

Folyamatok memóriatérképének riportja.

$ pmap 5350

Egy futtatás lehetséges kimenete:

$ pmap 915
915:   ./test
0000559510372000      4K r-x-- test
0000559510572000      4K r---- test
0000559510573000      4K rw--- test
00005595116cd000    132K rw---   [ anon ]
00007efdffcb3000   1620K r-x-- libc-2.24.so
00007efdffe48000   2048K ----- libc-2.24.so
00007efe00048000     16K r---- libc-2.24.so
00007efe0004c000      8K rw--- libc-2.24.so
00007efe0004e000     16K rw---   [ anon ]
00007efe00053000    140K r-x-- ld-2.24.so
00007efe00276000      4K r---- ld-2.24.so
00007efe00277000      4K rw--- ld-2.24.so
00007efe00278000     12K rw---   [ anon ]
00007efe0027b000     12K rw---   [ anon ]
00007fff3003e000    132K rw---   [ stack ]
00007fff30143000      8K r----   [ anon ]
00007fff30145000      8K r-x--   [ anon ]
ffffffffff600000      4K r-x--   [ anon ]
 total             4176K

• Hogyan tudjuk listázni a rendszer összes folyamatát?
• Hogyan tudjuk megjeleníteni a folyamatokat valós időben?
• Milyen jelzést kell küldeni egy folyamatnak, hogy biztosan leálljon?

A <Tab> billentyű, parancs-, fájl- és könyvtárnevek kiegészítésére használható.

A következő feladatokhoz saját könyvtárunkban hozzunk létre egy bil nevű könyvtárat. Lépjünk a bil könyvtárba, majd itt dolgozzunk tovább.

mkdir bil
cd bil

Hozzunk létre egy fájlt:

touch kedvenc_hosszu_fajlnev.txt

Ha szeretnénk megnézni a tartalmát a cat paranccsal, csak gépeljük be a cat parancs után az első betűt, majd nyomjunk tabulátort.

cat k<Tab>

A <Tab> billentyű kiegészíti a fájlnevet.

Most hozzunk létre egy másik fájlt:

touch kartel_tanacs_jegyzet.txt

Ha most újra szeretnénk megnézni az első fájl tartalmát:

cat k<Tab>

Nem történik semmi. Ha újra megnyomjuk a <Tab> billentyűt kiírja a két fájl, mutatva, hogy nem tudja melyiket kell megjeleníteni.

cat k<Tab><Tab>
kedvenc_hosszu_fajlnev.txt
kartel_tanacs_jegyzet.txt

Be kell írnunk a további karakterekből 1-t, majd újból megnyomni a <Tab> billentyűt.

cat ke<Tab>

Most hozzunk létre egy kedvenc_rovid_fajlnev.txt nevű fájlt:

touch kedvenc_rovid_fajlnev.txt

Ha szeretnénk újra megnézni a kedvenc_hosszu_fajlnev.txt állományt, akkor, begépeljük:

cat ke<Tab>

A fájlnév csak kedvenc_ részig lesz kiegészítve, mivel eddig egyezik a két ke kezdetű fájl. Ekkor nyomjunk újra <Tab> billentyűt.

cat kedvenc_<Tab>

A le és a fel billentyűvel lapozhatunk a kiadott parancsok között. A fel billentyűvel visszafele lapozunk, a le billentyűvel előre.

A Ctrl+R billentyűkombináció arra való, hogy az előző parancsokban keressünk. Nyomjuk meg a Ctrl+R billentyűkombinációt, majd írjuk be a keresett parancs részletét.

<Ctrl>+<R>
export

A következő jelenik meg:

(reverse-i-search)`':

A gépelés közben máris megjelennek az egyezést mutató régebbi parancsok.

Ha nem található a minta:

(failed reverse-i-search)`ga':

Alapértelmezetten csak egy találat jelenik meg. Több eredmény megjelenítéshez nyomjuk meg újra a Ctrl+R billentyűt. Tulajdonképpen lapozhatunk a parancsokban.

A keresést a Ctrl+C billentyűkombinációval szakíthatjuk meg, egy Enter lenyomásával újra aktiválhatjuk.

Kilépés a Ctrl+G billentyűkombinációval.

A Ctlr+S megállítja, megfagyasztja a terminált. Olyankor jöhet jól ha valamilyen parancs adatokat ír a képernyőre, ami nem fér el, ezért folyamatosan továbbítja azt, mi pedig szeretnénk beleolvasni, így megállítanánk.

A képernyő továbbítása folytatható a Ctrl+Q billentyűkombinációval.

A példa kedvéért kereshetünk a csomagok között, amit leállíthatunk:

apt search a

A sor elejére a <Home> vagy a <Ctrl>+<a> billentyűvel mozoghatunk.

• Home, Ctrl+a

A sor végére az <End> vagy a <Ctrl>+<e> billentyűvel mozoghatunk.

• End, Ctrl+e

Váltás az aktuális kurzorpozíció és a sor eleje között.

• Ctrl+x, Ctrl+x

Egy parancs kiadása után ha megnyomjuk az <Alt>+<.> billentyűkombinációt, az utoljára beírt argumentum a parancssorba íródik.

Az aktuális folyamatot a háttérbe teszi. A háttérbe tett folyamat az fg és bg parancsokkal szabályozhatók.

Az aktuális folyamatot megszakítja.

A folyamatnak SIGINT jelet küldönk.

A képernyő törlése.

A kurzor előtti részt egy speciális vágólapra helyezi.

A kurzor utáni részt egy speciális vágólapra helyezi.

A speciális vágólapról beilleszti a tartalmat, amely a Ctrl+U vagy Ctrl+K billentyűparanccsal került oda.

A kurzortól balra kivágja a szót és speciális vágólapra teszi.

A kurzor alatti és kurzor előtti két karakter cseréje.

Kilép a terminálból.

Ha beragadt egy SSH munkamenet, mert például lejárt a váratlanul eltölthető idő, szeretnénk kilépni:

• Enter, ~, .

Kurzor előtt sor törlése

Alt + Delete

Kurzor utáni szó törlése:

Alt + d

Vissza:

Alt + b

Előre:

Alt + f

Az aktuális parancs szerkesztése $EDITOR-ban:

• Ctrl + x, Ctrl + e

1. Mire jó a Tab billentyű?
2. Mi történik, ha parancskiegészítést kérek, de hasonló kezdetű állomány több is létezik?
3. Mire használható a Ctrl+D karakter?
4. Mire való a Ctrl+A billentyűkombinációt?
5. Mire való a Ctrl+E billentyűkombinációt?
6. Mire való a Ctrl+U billentyűkombinációt?
7. Mire való a Ctrl+K billentyűkombinációt?
8. Mi a különbség a Ctrl+U és a Ctrl+K billentyű között?
9. Mit csinál a Ctrl+T a Bashben?
10. Mit töröl a Ctrl+W a Bashben?
11. Mire jó a Ctrl+L a Bashben?
12. Mire jó a Ctrl+Z a Bashben?

A szűrők a bemenetükre került adatokkal csinálnak valamit, majd a kimenetre küldik.

A cat az egyetlen szűrő, amely a bemenetre érkező adatokkal semmit nem csinál. Változatlanul írja azokat a képernyőre. Mégis ez a parancs – mint azt feljebb láttuk – amellyel a legtöbb dolgot tehetjük. Ezek:

• állomány tartalmának megjelenítése
• állomány létrehozása
• állományok összemásolása
• állományok másolása
• állományhoz fűzés

Állomány létrehozása:

cat > dolgozok.txt

Állomány tartalma:

cat dolgozok.txt

Állományok összemásolása:

cat fajl1 fajl2 fajl3 > egyfajl.txt

Állományok másolása:

cat < eredeti > masolat

A fájl végéhez fűzünk:

cat >> dolgozok.txt
Szabó Gábor 830000
[Ctrl]+[D]

A fájl végéhez fűzők:

cat >> dolgozok.txt <<VEGE
Nagy József 800000
Kis Béla 570000
Jég Lajos 750000
VEGE

cat > filenev.txt
tartalom
...
<Ctrl>+<D>

cat < filenev

vagy

cat filenev

cat < filenev > filenev2

cat file1 file2 file3 > file4

A bemenetre érkező sorokból bizonyos oszlopok törlése

Szintaxis:

colrm [startoszlop [ végoszlop ]]

A példa kedvéért adott az alábbi tabulátorral tagolt állomány a következő tartalommal:

tanulok.txt

001	Alex Brown	85	5
002	Dan Igor	40	3
003	Barton Flex	56	3
004	Rock Brain	78	4

Szeretnénk a nevek oszlopait eltüntetni.

Megoldás:

cat tanulok | colrm 9 24

Eredmény:

cel.txt

001	85	5
002	40	3
003	56	3 
004	78	4

Nagyobb példafájl:

tanulok_a.txt

001	Alex Brown	85	5
002	Dan Igor	40	3
003	Barton Flex	56	3
004	Rock Brain	78	4
005	Kis István	72	4
006	Nagy Béla	70	4
007	Fehér Tamás	28	1
008	Kékes Imre	45	4
009	Per Béla	78	4
010	Zöld Elek	78	4
011	Piros Gábor	23	1
012	Fék Lajos	28	4
013	Elmúlt Tibor	78	4
014	Leendő Tamás	28	4
015	Pék Gergő	78	4
016	Rob Sándor	18	1
017	Kékedi Imre	70	4
018	Nagy Lajos	85	4

Egyéb használat

ifconfig eth0 | colrm 1 10

cat /var/log/syslog | colrm 1 16 | colrm 30

cat /var/log/auth.log.1 | colrm 70

Utóbbi példában ha szimplán az állomány tartalmát listázom, azok kilógnak a következő sorban. A célom, hogy átláthatóbb sorokat szeretnék, de jelenleg csaka sorok elejére vagyok kíváncsi.

Csak bizonyos oszlopokat szeretnénk megjeleníteni.

Szintaxis:

cut [opció] … [fájl] ...

Adott az alábbi szóközökkel tagolt állomány:

tanulok2.txt

001 Alex Brown        85    5
002 Dan Igor          40    3
003 Barton Flex       56    3
004 Rock Brain        78    4

Megoldás:

cat tanulok2.txt | cut -c4-22

Az eredmény:

 Alex Brown        
 Dan Igor          
 Barton Flex       
 Rock Brain 

tanulok.txt

001	Alex Brown	85	5
002	Dan Igor	40	3
003	Barton Flex	56	3
004	Rock Brain	78	4

Megoldás:

cut -f2 <  tanulok.txt

A futtatás eredménye:

cut -f2 < tanulok.txt 
Alex Brown
Dan Igor
Barton Flex
Rock Brain

tanulok3.txt

001:Alex Brown:85:5
002:Dan Igor:40:3
003:Barton Flex:56:3
004:Rock Brain:78:4

Megoldás:

cut -f2 -d : tanulok3.txt

A -d kapcsoló után szóközzel vagy a nélkül megadjuk az elválasztójelet. A -d kapcsolóval szinte bármit megadhatunk szeparátornak.

Eredmény:

cut -f2 -d: tanulok3.txt 
Alex Brown
Dan Igor
Barton Flex
Rock Brain

cut -f 2,3,7 -d : tanulok3.txt

Eredmény:

cut -f 2,3,4 -d: tanulok3.txt 
Alex Brown:85:5
Dan Igor:40:3
Barton Flex:56:3
Rock Brain:78:4

A tr paranccsal minden szóköz csak egyszer fog szerepelni:

cat tanulok3 | tr -s ' ' | cut -f 1 -d' '

Legyen egy összetett feladat: Le kell állítani a zombi folyamatokat. A ps paranccsal kiíratjuk az összes folyamatot. A grep paranccsal szűrök csak a zombi állapotban lévő folyamatokra. A tr paranccsal az egyes oszlopok közötti szóközöket 1 darabra csökkentem. A soreleji szóközöket törlöm az awk paranccsal. A cut paranccsal az első oszlopot megjelenítem, mivel ezek a szülőfolyamatok. Végül a kill paranccsal törlöm a zombikat. Szükség van egy xargs parancsra is, mert a kill parancs így kapja meg paraméterként a ppid értékeket.

ps -o ppid,pid,stat | \
  grep -w Z | \
  tr -s ' ' | \
  awk '{$1=$1};1' | \
  cut -f1 -d' ' | \
  xargs kill -9

A következő parancsok használatához szükséges az mcrypt nevű csomag telepítése. A telepítéshez lásd a csomagkezelés részt a „Rendszer” fejezetben.

Adott az alábbi állomány a következő tartalommal:

nyilt.txt

Holnap este érkezem.

Szeretnénk titkosítani az állományt.

Titkosítás:

mcrypt nyilt.txt

A futtatás eredménye:

mcrypt nyilt.txt 
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase: 
Enter passphrase: 
 
File nyilt.txt was encrypted.

A parancs bekért egy jelszót kétszer, majd létrehozza a következő állományt:

nyilt.txt.nc

A nyilt.txt.nc szöveg tartalmát ha megnézzük olvashatatlan szöveg lesz. Így már elküldhetjük a titkos üzenetet. Ezek után az üzenet vevőjének vissza kell kódolni az üzenetet.

A visszafejtés a következő paranccsal lehetséges:

mdecrypt nyilt.txt.nc

A futtatás eredménye:

mdecrypt nyilt.txt.nc 
Enter passphrase: 
File nyilt.txt.nc was decrypted.

A parancs bekéri a jelszót, majd elkészíti a nyilt.txt.nc állományt visszakódolva a nyilt.txt nevű fájlt.

A crypt parancsot a mcrypt csomag valósítja meg. Régi unixból ismert parancs, amely a stdin-ről várja a bemenetet, és a stdout-ra ír.

crypt < nyilt.txt > titkos.txt 
Unix crypt(1) emulation program using mcrypt(1).
 
Use crypt -h for more help.
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase: 
Enter passphrase: 
 
Stdin was encrypted.

Persze ebben a formában is használahtó:

crypt > titkos.nc
Unix crypt(1) emulation program using mcrypt(1).
 
Use crypt -h for more help.
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase: 
Enter passphrase: 
 
Holnap este érkezem.
Stdin was encrypted.

Visszafele ugyanígy:

crypt < titkos.nc 
Unix crypt(1) emulation program using mcrypt(1).
 
Use crypt -h for more help.
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase: 
Enter passphrase: 
 
Holnap este érkezem.
Stdin was encrypted.

Adott mintát tartalmazó sorok megjelenítése

Szintaxisa:

grep  [ kapcsolók ]  minta    [ fájl ... ]

Adott az alábbi belépési napló:

belepesinaplo.txt

2005.10.25 18:30 alex 196.145.43.3
2005.10.26 18:30 joe 216.45.3.2
2005.10.26 18:44 richard 196.145.43.3
2005.10.28 22:31 joe 196.145.43.3
2005.10.29 18:00 alex 196.145.43.3

A futtatás eredménye:

grep alex belepesinaplo.txt
 
2005.10.25 18:30 alex 196.145.43.3
2005.10.29 18:00 alex 196.145.43.3

A grep -v azokat jeleníti meg, amelyek nem tartalmazzák a sorokat.

grep -v alex belepesinaplo.txt
2005.10.26 18:30 joe 216.45.3.2
2005.10.26 18:44 richard 196.145.43.3
2005.10.28 22:31 joe 196.145.43.3

Az alábbi naplóállomány a következő mezőket tartalmazza:

naplo.log

2005.12.25 18:30 alex 196.145.43.3 1960 bytes
2005.12.26 18:30 joe 216.45.3.2 1512 bytes
2005.12.26 18:44 richard 196.145.43.3 2005 bytes
2005.12.28 22:31 joe 196.145.43.3 2006 bytes
2005.12.29 18:00 alex 196.145.43.3 2050 bytes
2006.01.02 08:25 joe 195.166.29.5 2008 bytes
2006.01.02 12:20 alex 195.165.1.1 2005 bytes

Feladatunk, hogy listázzuk a 2006-os eseményeket. Ha most a fentebb tárgyalt módon csak ennyit írunk:

grep 2006 naplo.log

úgy azok a sorok is megjelennek, ahol a letöltött byte-ok száma 2006. Nekünk nem jó. Jeleznünk kell, hogy csak azokat a sorokat szeretnénk megjeleníteni, ahol a 2006 a sor elején szerepel. Ehhez a ^ karaktert használjuk:

grep ^2006 naplo.log

Csak a fájlnevek megjelenítése tartalom alapján: Például keressük az aktuális könyvtárban, az összes fájl között, azokat a fájlokat, amelyek tartalmazzák a VGA szót, megjeleníteni azonban csak a fájlneveket szeretnénk:

Készítsünk egy fájlt:

echo "Egy VGA felbontásra van szükség" > adat.txt

grep VGA *

Ha csak a fájl nevét szeretném:

grep -l VGA *

naplo.log

2005.12.25 18:30 alex 196.145.43.3 1960 bytes
2005.12.26 18:30 joe 216.45.3.2 1512 bytes
2005.12.26 18:44 richard 196.145.43.3 2005 bytes
2005.12.28 22:31 joe 196.145.43.3 2006 bytes
2005.12.29 18:00 alex 196.145.43.3 2050 bytes
2006.01.02 08:25 joe 195.166.29.5 2008 bytes
2006.01.02 12:20 alex 195.165.1.1 2005 bytes
2006.01.03 07:02 mari 195.165.2.45 2007 bytes

A fenti állományban azokat a sorokat keressük, ahol a letöltés 2005, 2006, 2007 vagy 2008 van.

grep "200[5678] bytes" naplo.log

A negyedik karakter csak a szögletes zárójelben „[ ]” megadott négy karakter egyikére illeszkedik. Az 5,6,7 vagy 8-as karakterek valamelyikére. A szám után kötelezően egy szóköznek, majd utána bytes karakterek megköveteltek.

A szögletes zárójel lehetővé teszi intervallumok megadását [5-8]:

grep "200[5-8] bytes" naplo.log

Az intervallumok megadására használhatók betűk is:

[a-z] 

Az előbbi minta például az angol ábécé összes kisbetűjére illeszkedik. A nagybetűk:

[A-Z]

Természetesen megadhatók kisebb intervallumok is:

[c-k]

grep -v "^$" filename

grep . filename

grep -v '^[[:space:]]*$' filename

grep -v '#' filename

grep -v '\#' filename

A rekurzív keresés bekapcsolja a fájl megjelenítést. Keressük például a „Rewrite” szót az apache2 konfigurációs állományaiban:

grep -r "Rewrite" /etc/apache2/

Adott az alábbi naplóállomány részlet (/var/log/syslog):

Feb 21 18:32:12 server postfix: Connection, 
Feb 21 18:32:12 server postfix: LOGIN, user=test@server.hu, 
Feb 21 18:32:46 server postix: LOGOUT, user=test@server.hu
Feb 21 18:32:12 server pop3d: Connection, 
Feb 21 18:32:12 server pop3d: LOGIN, user=test@server.hu, 
Feb 21 18:32:46 server pop3d: LOGOUT, user=test@server.hu

Csak a pop3d-t tartalmazó sorokat szeretnék megjeleníteni.

grep pop3d /var/log/syslog

Adott egy konfigurációs állomány (dspam.conf) ami tele van megjegyzésekkel. Szeretném kiszűrni a megjegyzés sorokat és csak a beállításokat szeretném:

#
# DSPAM Home: Specifies the base directory to be used for DSPAM storage
#
Home /var/spool/dspam

Ekkor:

grep '^[^#]' dspam.conf

grep -lir "keresett szöveg" /utvonal/konyvtar

Nem egyezik meg a grep -E használatával, mert annál több reguláris kifejezést ismer ha ezt használjuk.

Ehhez hasonló reguláris kifejezések is használhatók:

+,?, | és ()

Fix vagy fast grep rövidítése. Megegyezik a grep -F használatával

Normál szövegként értelmezzük a mintát szabályos kifejezések helyett.

A szabályos kifejezések területén, például a (.) pont speciális jelentéssel bír.

fgrep stdio.h /usr/include/*

Adatoszlopok összemásolása

Állományok oszlopainak összemásolása egy fájlba, egymás mellé

Szintaxis:

paste   [ kapcsolók ... ]  [ fájl ... ]

Van 4 darab fájl:

• sroszam
• nev
• szuletesnap
• telefonszam

sorszam

001
002
003

nev

Alex
Brown
Joe

szuletesnap

1985.07.11
1987.01.12
1999.12.22

telefonszam

(1) 335-3345
(37) 332-328
(48) 183-981

Szeretnénk egyetlen fájlban egymás mellé összemásolni.

Megoldás:

paste sorszam nev szuletesnap telefon  > info.txt

Eredmény:

info.txt

001 	Alex	1987.07.11	(1)335-3345
002 	Brown	1987.01.12	(37) 332-328
003 	Joe	1999.12.22	(48) 143-981

Megoldása

paste -d ' ' sorszam nev szuletesnap telefon  > info

Eredmény:

info

001 Alex 1987.07.11 (1)335-3345
002 Brown 1987.01.12	(37) 332-328
003 Joe 1999.12.22 (48) 143-981

Tagoláshoz persze bármit megadhatunk pl.:

  -d ':'

Adott egy dolgozok nevű állomány, amiben oszlopokban szeretnénk megcserélni.

dolgozok

Név	Fizetés	Beosztás
Alex	130000	festő
Brown	150000	asztalos
Joe	170000	villanyszerelő

Megoldás:

cut -f1 dolgozok  >  nev
cut -f2 dolgozok >  fizetes
cut -f3 dolgozok >  beosztas
 
paste nev beosztas fizetes >  dolgozok2
 
more dolgozok2
 
rm nev beosztas fizetes

A bemenetre érkező adatokat rendezi.

A sort parancsot Adatok rendezése és összemásolása

Ha a bemenet egy másik programtól jön csővezetéken:

cat filenev.txt | sort

Ha a program bemenete egy állomány:

sort < filenev.txt

sort -r nevek.txt
sort --reverse nevek.txt

sort -o ujfajl.txt  nevek.txt

Átirányítással:

sort nevek.txt > ujfajl.txt

Ha így használjuk:

sort nevek.txt > nevek.txt

A nevek.txt tartalma elveszett, mert a kimeneti fájl előkészítése megtörténik annak olvasása előtt.

Itt lehet ugyanaz a név:

sort -o nevek.txt  nevek.txt

sort nevek1 nevek2 nevek3 > osszes

Egy fájlba rendezi a 3 fájl tartalmát

A gyümölcs fájl tartalma:

gyumolcs.txt

korte
alma
szilva
barack

Eredmény:

sort gyumolcs.txt
alma
barack
korte
szilva

gy.txt

1 körte
2 alma
3 szilva

Második oszlop szerint szeretnénk rendezni:

sort -k +2 < gy.txt

-k oszlopszám

Magyar nyelvű környezetben a magyar helyesírásnak megfelelően rendez a sort. Ezen lehet változtatni, péládul:

LC_COLLATE=en_US.UTF-8 sort gy.txt

vagy csak

LC_COLLATE=C sort gy.txt

Ha számok vannak egy oszlopban, akkor is betűrendet néz a sort. A szám alapján rendezést a -n kapcsolóval érhetjük el.

szamok.txt

90
700
5

sort -n szamok.txt

sort --numeric-sort szamok.txt

Egy sort megfordít

A rev parancsot karakterek sorrendjének megfordítása használjuk.

Szintaxis:

rev [fájl …]

A bemenet lehet a STDIN is.

Legszemléletesebben egy egyszerű állományon láthatjuk a működését. Az adat.txt állomány tartalma legyen a következő:

adat.txt

12345
abcde
AxAxA

Futtatás:

rev adat.txt
54321
edcba
AxAxA

A spell egy helyesírás ellenőrző program. A unixos rendszerekből származik. A spell csomag telepítése után használható.

A spell a paraméterként megadott állományból kiírja azokat a szavakat amiket helytelennek tart.

Magyar helyesírásh ell.-hez: ihungarian csomag kell telepítve legyen.

(magyar környezeteben ékezet gondok)

Adott a következő fájl:

gy.txt

barcak
szilve
eper
körte
alme

A harmadik szó helyes, a többit helytelen.

Végrehajtás:

spell gy.txt

A parancs az eper szó kivételével kiír minden sort.

A hunspell csomag használata esetén rávehetjük annak használatára is:

spell -i /usr/bin/ispell gy.txt

A hunspell csomag használata esetén rávehetjük annak használatára is:

spell -i /usr/bin/hunspell gy.txt

Ez egy interaktív helyesírás ellenőrző program.

Indítás:

ispell gy.txt

Az indítás után a program kiírja a hibás szót, majd lehetőségeket kínál a változtatásra. Számokkal adhatjuk meg, mire szeretnénk javítani. Ha ez nem egyezik az általunk kívánt lehetőséggel, akkor az r lenyomása után mást is beírhatunk. A program minden lehetőséget kiír a képernyő alján.

 barcak              File: gy.txt
 
 
barcak
 
 0: barack
 1: barnak
 2: bar�ak
 
 
 
 
 
 
 
[SP] <number> R)epl A)ccept I)nsert L)ookup U)ncap Q)uit e(X)it or ? for help

Hátránya, hogy nem ismeri az UTF-8 kódolásul ékezeteseket.

• http://magyarispell.sourceforge.net/magyarispell.pdf

Interaktív helyesírás ellenőrző program. UTF-8-as környezetben kezeli az ékezetes karaktereket. Felülete hasonlít az ispell programhoz.

Használatához telepíteni kell az aspell csomagot, a magyar helyesírás ellenőrzéshez pedig a aspell-hu csomagot.

Adott a következő állomány:

gy.txt

Szeretem a gyümölcsöket. Kedvenceim az alme, körti, szilve és a barakc.

aspell check gy.txt

barck
szilva
körite
alme





                                                                                
1) barack                               4) barik
2) Barcs                                5) barok
3) Barok                                6) barék


i) Ignore                               I) Ignore all
r) Replace                              R) Replace all
a) Add                                  l) Add Lower
b) Abort                                x) Exit
                                                                                
? 

A módok lekérdezése:

aspell dump modes

Nem kérünk backup fájlt és Markdown fájlt ellenőrzünk

aspell check --dont-backup --mode=markdown valami.md

Adott a következő állomány:

gy.txt

Szeretem a gyümölcsöket. Kedvenceim az alme, körti, szilve és a barakc.

Ellenőrzés:

hunspell gy.txt

Felülete:

        barck           File: gy.txt




barck

 0: barack
 1: barok
 2: barik
 3: barék
 4: barcsik
 5: Barcs
 6: barcsi
 7: barchesz







[SPACE] R)epl A)ccept I)nsert U)ncap S)tem Q)uit e(X)it or ? for help

Előnyök:

• http://manpages.ubuntu.com/manpages/hardy/hu/man1/hunspell.1.html

Kiválasztott karakterek cseréje.

tr [kapcsolók] … készlet1 [készlet2]

Adatokat olvas a stdin-ről készlet1-beli előfordulását keresi, ha talál lecseréli a készlet2-beli párjával.

Kis a nagy A lesz:

tr a A < regifajl > ujfajl

Kis a,b,c nagy A,B,C lesz:

tr abc ABC < regifajl > ujfajl

Minden nagybetű kicsi lesz:

tr A-Z a-z < regifajl > ujfajl

tr éáóö eaoo < ekezetes > ekezetlen

Az ékezetlenítés UTF-8-as környezetben nem jól működik. Helyette ajánlott a sed parancs használata.

Az ismétlődő sorokat csak egyszer jeleníti meg.

Rendezett, Ismétlődő sorok törlése

uniq [kapcsoló] ... [bemenet [kimenet]]

adat

alma
körte
alma
barack
szilva
körte

uniq adat
alma
körte
alma
barack
szilva
körte

adat

alma
körte
alma
barack
szilva
körte

sort adat | uniq
alma
barack
körte
szilva

Sorok megszámolása

Sorok, szavak és karakterek számolása

Szintaxis:

wc [kapcsoló] ... [fájl] ...

Adott egy állomány:

adat

alma
körte
barack
szilva

Végrehajtás:

wc adat
 4 4 25

Amit kaptunk:

• 4 sor
• 4 szó
• 25 byte

Gyakori használat.

wc -l

Csak sorok számolása

Sorszámozás

• A sorokat sorszámozza.
• A számok a sor elé kerülnek.

Példa a használatra:

nl -n rz -w3 -s:

• (-n rz) jobbra zárt, előnullázva
• (-w 3) számjegyek száma
• (-s :) szeparátor

Eredmény:

001:adat1:adat2

A bemenetet megfordítja, az utolsó sortól írja ki.

eredeti.txt

alma     	40 db
körte	 	53 db
barack		25 db
szilva		27 db

uj.txt

szilva		27 db
barack		25 db
körte		53 db
alma		40 db

tabulátorok szóközökre cserélése

tanulok_tab.txt

001	Alex Brown	85	5
002	Dan Igor	40	3
003	Barton Flex	56	3
004	Rock Brain	78	4

Végrehajtás:

expand tanulok_tab.txt > tanulok_szokoz.txt

Szóközök tabulátorra cserélése.

Adott a következő állomány szóközökkel tagolva:

tanulok_szokoz.txt

001     Alex Brown      85      5
002     Dan Igor        40      3
003     Barton Flex     56      3
004     Rock Brain      78      4

Végrehajtás:

unexpand -a tanulok_szokoz.txt > tanulok_tab.txt

• (-a) Ne csak a bevezető szóközöket és tabulátorokat, hanem az összeset alakítsa át tab karakterekké.

Összefűzés

Minden egyes azonos összekapcsolási mezővel rendelkező bementi sorpárhoz kiír egy sort a szabványos kimenetre.

nev

1 János
2 Ferenc
3 István
4 Kati

szul

1 1981
4 1934
2 1945
3 1967

Végrehajtás:

join nev szul
1 János 1981
2 Ferenc 1934
3 István 1945
4 Kati 1967

Az állományok tartalmazhatnak üres sorokat. De ha nincs rendezve, akkor nem mindig jó az eredmény.

Sorok tördelése a megadott mezőszámmal:

fold -w 70 file.txt

Tegyük fel, hogy kaptam egy e-mailt, amelyben egy szöveges fájl van, de a levelet úgy írták, hogy nem törtek sort a képernyő jobb szélre érve, ezért a mi olvasó programunkban kilóg a képernyőről.

level.txt

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam condimentum blandit sapien non volutpat. Vivamus posuere massa euismod libero varius et mollis velit aliquam. Donec ultrices placerat consequat. Phasellus sit amet est non lorem vestibulum placerat iaculis vitae justo. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus bibendum feugiat eleifend. Duis tincidunt tempus eros, ac laoreet magna suscipit eu. Praesent quis facilisis lacus. Quisque imperdiet egestas lectus dapibus iaculis. Morbi egestas nulla eu magna sagittis vitae eleifend lacus sodales. Nullam vel nunc nisl. Vestibulum eget sapien eros. Donec ac pellentesque odio. In hac habitasse platea dictumst.

(Ezt az állományt letöltheted így is:)

curl http://szit.hu/wiki/download/level.txt > level.txt

Ekkor tördelhetjük az állományt a fenti mint alapján:

fold -w 70 level.txt

Kifejezés kiértékelése

expr 1 + 2
3

expr 1 ”<” 2
1

expr 1 ”>” 2
0

expr length "alma a"
6

expr 3 "*" 2
6

expr 1 = 2
0

Topológikus rendezést hajt végre egy fájlon.

Szintaxis:

tsort [fájl]

Ha nincs fájl megadva, akkor STDIN-ről olvas.

Átadunk a tsort-nak egy „X történt Y előtt” típusú, párokból álló listát, és megvizsgáljuk, hogyan rendezi azt. Megjegyezzük, hogy adott részleges rendezés esetén nem mindig létezik egyértelműen teljes rendezés is.

Adott a következő állomány:

szul.txt

Éva János
Erika János
Péter Éva
Zoltán Erika

Alkalmazás

tsort < szul.txt
Péter
Zoltán
Éva
Erika
János

A diff két fájl összehasonlítása való, sorról sorra. A használat során, listázza a két összehasonlított állomány eltérő részeit.

gy1.txt

alma
körte
barack
szilva

gy2.txt

alma
körte
szilva

diff gy1.txt gy2.txt 
3d2
< barack

Két könyvtár összehasonlítása:

diff elso masodik 
Csak elso -ben: egy.txt
Csak masodik -ben: ketto.txt

A program kiírja, ha egy fájl csak az egyik könyvtárban van.

Csak a különbséget mutató fájlok mutatása:

diff -qr elsoKonyvtar masodikKonyvtar

$ cat gy1.txt gy2.txt 
alma
korte
barack
szilva
malna

alma
korte
szilva

$ diff gy2.txt gy1.txt 
2a3
> barack
3a5
> malna

A kimenet általában olyan sorokból áll, amely egy számmal (vagy tartománnyal) kezdődik, majd azt követi az ábécé a, d vagy c betűje, és újra egy szám (vagy tartomány) következik. Például: 2a3. Taromány esetén két szám jelenik, meg vesszővel tagolva.

Az első szám az első fájl (eredeti fájl) sorát (vagy tartományát) mutatja, az utolsó szám (vagy tartomány) a második (új fájl) sorát mutatja.

A betűk a következőket jelentik:

• a - append- hozzáfűzés
• d - delete - törlés
• c - change - megváltozott

A fenti 2a3, azt jelenti, hogy az első fájl 2-dik sora után kell fűzni a második fájl 3-dik sorát, annak érdekében, hogy a fájlok azonosak legyenek.

A > karakter a második fájl 3-dik sorát jelenti. Ha < karakter látunk, akkor az első sor megadott állományát látjuk.

A --- csak szeparátor.

Példa:

# cat gy1.txt gy2.txt 
alma
korte
barack
meggy
szilva
malna

alma
korte
szilva
banan

# diff gy2.txt gy1.txt 
2a3,4
> barack
> meggy
4c6,7
< banan
---
> malna
> 

Az első fájl, 2-dik sorát cserélni kell a másik fájl 2-dik sorával, annak érdekében, hogy azonos fájlt kapjunk.

A -u vagy --unified kapcsoló szükséges.

diff gy2.txt gy1.txt -u
--- gy2.txt	2021-03-05 07:27:14.588727794 +0000
+++ gy1.txt	2021-03-05 07:26:29.708436467 +0000
@@ -1,4 +1,7 @@
 alma
 korte
+barack
+meggy
 szilva
-banan
+malna
+

A patch program foltozásra való. A foltot a diff programmal készítjük, majd patch paranccsal fűzzük a régi állományhoz.

Például adott a következő állomány:

gy1.txt

alma
barack
körte
szilva

Lemásoljuk az állományt:

cp gy1.txt gy2.txt

A gy2.txt állományban változásokat viszünk véghez.

Az állomány ezek után így néz ki:

gy2.txt

alma
banán
barack
citrom
körte
szilva

A folt elkészítése:

diff -cBN gy1.txt gy2.txt > gy2.patch

Végrehajtás során:

diff -cBN gy1.txt gy2.txt > gy2.patch
*** gy1.txt	2011-11-20 00:12:50.000000000 +0100
--- gy2.txt	2011-11-20 00:45:58.000000000 +0100
***************
*** 1,4 ****
--- 1,6 ----
  alma
+ banán
  barack
+ citrom
  körte
  szilva

Ha ezek után valakinek meg van gy1.txt állomány, a javítások alkalmazásához a foltot kell megszerezni. Akinek csak a gy1.txt állomány van, megszerzi a foltot, majd alkalmazza a gy1.txt állományon.

A gy2.patch állományt a gy1.txt állománnyal azonos könyvtárba másolom. A patch alkalmazása ez után:

A folt alkalmazása:

patch < gy2.patch

Akkor hasznos ez a folthasználat alkalmazása ha az eredeti állomány nagyon nagy, nagyon komplex és szeretnénk egy apróbb vagy nagyobb változtatást alkalmazni az eredeti állományon.

A programozók gyakran használják a foltozást. Ha belejavítanak egy állományba, akkor csak elkészítik a régi és új állomány különbségét (folt), majd ezt visszaküldik az eredeti fejlesztőnek. Az eredeti fejlesztőnek csak foltot kell letöltenie, amelyet alkalmaz az eredeti állományon.

Három fájl összehasonlítása sorról sorra.

Két állomány összehasonlítása, tartalmuk interaktív egyesítése.

A két állomány tartalmát két oszlopban jeleníti meg, nagyon szemléletesen a különbségeket.

Két fájl összehasonlítása

Alapértelmezés szerint azonos állományok esetén nem ír ki semmit, eltérés esetén jelzi az eltérés sor- és bájtszámát.

Sorról-sorra összehasonlít két rendezett fájlt.

A comm három oszlopban írja ki két állomány összehasonlításának eredményét. Az első oszlopban csak azok a sorok szerepelnek, amelyek csak az első, a másodikban azok amelyek csak a második, végül a harmadikban azok amelyek mindkét állományban előfordulnak.

Egy állomány végét írja ki.

Például:

tail /var/log/syslog

A tail a -f kapcsolóval folyamatosan a képernyőre írja az állomány változásait.

Beállítható hány sor jelenjen meg. 100 sor megjelenítése:

tail -100 /var/log/syslog

Egy állomány elejét írja ki. Alapértelmezetten az első 10 sort jeleníti meg.

head /var/log/syslog

Beállítható hány sor jelenjen meg:

head -100 /var/log/syslog | less

A fájlvége jeleket cserélhetjük az egyes operációs rendszerek számára. A fájl végét valamelyik rendszerben 1 bájt jelzi, valamelyikben kettő. Két bájt van használatban:

• CR - ^M
• LF - ^J

A fájlvége jelek az egyes rendszereken:

• Windows: CR LF
• Linux, Mac OS X: LF
• Apple: CR

Telepítés:

apt install dos2unix

Telepítés a következő parancsokat kapjuk:

• dos2unix
• unix2dos
• mac2unix
• unix2mac

A unix2dos szintaxisa:

unix2dos [options] [-c convmode] [-o file ...] [-n infile outfile ...]

Kapcsolók:

[-fhkLlqV]  [--force]  [--help]  [--keepdate]  [--license]  [--newline]
[--quiet] [--version]

Legyen egy vmi.txt nevű fájl, amely Unix rendszeren (Linux vagy Mac OS X) készült, így a sortörés LF bájt lett. Windowsos sortörést szeretnénk:

• unix2dos vmi.txt

Ha fel van telepítve a Midnight Commander, a szerkesztőjével nyissuk meg az elkészült fájlt:

mcedit vmi.txt

Az eredmény látható. Mivel az mcedit nem ismeri CR LF közül az CR bájtot, ^M karaktereket jelenít meg helyette.

A -n kapcsolóval beállítható a kimeneti fájl is:

unix2dos -n vmi.txt uj.txt

Bináris és nem szabályos fájlokat, mint a linkeket automatikusan átlép a program, ha csak nem használjuk a --force kapcsolót.

A -c kapcsoló: -c --convmode konverziósmód

Módok a következők lehetnek:

• ascii
• mac
• 7bit
• iso

További példák:

unix2dos a.txt -c 7bit b.txt

unix2dos -c ascii a.txt -c 7bit b.txt

unix2dos < in.txt | iconv -f ISO-8859-1 -t CP850 > out.txt

Több információért:

man dos2unix

ASCII karaktersorozatok keresése. Tipikusan bináris fájlokban szoktunk keresni olvasható szöveget. Például egy futtatható .exe vagy elf binárisban szeretnénk látni ki írta, hátha szerepel benne.

strings /usr/bin/ls

A tee parancs a bemenetét fájlba és az alapértelmezett kimenetre irányítja egyszerre. Akkor lehet hasznos, ha a fájlba írás mellett szeretnék a képernyőre is írni vagy a kimenetet egy másik programnak csővezetéken továbbadni.

Fájlba és képernyőre:

cat fajl.txt | tee kimenet.txt

Fájlba és másik programnak:

cat fajl.txt | tee kimenet.txt | sort

Esetleg:

cat fajl.txt | tee kimenet.txt | sort | rendezettkimenet.txt

A dd parancs fájlok másolására használható.

Legy például egy gy.txt állomány:

cat > gy.txt
szilva
körte
alma
barack

Készítsünk róla másolatot:

dd if=gy.txt of=masolat.txt

Nagybetűssé alakítás:

dd if=gy.txt of=masolat conv=ucase

Sajnos ez utóbbi csak az angol ábécé betűivel működik.

Kisbetűssé:

dd if=gy.txt of=masolat conv=lcase

Az adatok kiírása fizikailag később történhet, mivel az operációs rendszer átmeneti tárolójába kerülnek. Ha szeretnénk az adatok fizikai kiírását azonnal, akkor adjuk meg a fdatasync jelölőt:

dd if=gy.txt of=masolat conv=fdatasync

Ha fájlokhoz tartozó metaadatok azonnali kiírását is szeretnénk, akkor:

dd if=gy.txt of=masolat conv=fsync

További részletek:

dd --help

Az aktuális időt írja ki az adott időzónában.

Grinwicsi középidő például:

zdump UTC

Észak-amerikai idő lekérdezése:

zdump EST

Közép-európai idő lekérdezése:

zdump CET

Japán idő lekérdezése:

zdump Japan

Eredmény:

Japan  Sun Nov 20 20:32:16 2011 JST

A használható paraméterek listája:

ls /usr/share/zoneinfo

Megmérhetjük mennyi idő alatt hajtódik végre egy parancs

Valósidő és folyamatidő. Statisztika mennyi ideig tartott a parancs végrehajtása.

Például:

time ls /usr/bin

Eredményhalmaz:

real	0m1.232s
user	0m0.028s
sys	0m0.048s

Vagy

time sleep 60
 
real	1m0.009s
user	0m0.000s
sys	0m0.004s

Statisztika a programfutásról

times ls -l /

Eredmény:

0m3.948s 0m1.392s
0m24.246s 0m3.240s

Várakozás meghatározott ideig. Alapértelmezett mértékegység a másodperc:

sleep 5

5 másodpercig vár

A hardveróra lekérdezése és beállítása. Ez a parancs csak root felhasználóként használható.

Az rdate csomag egy távoli gépről kérdezi le az időt.

rdate -p -n time.kfki.hu

Alapértelmezetten be is állítja az operációs rendszer idejét. Ez azonban csak root felhasználóként tehető meg.

A -n kapcsoló az RFC 2030 SNTP protokoll használatára utasít. Eredeti időprotokoll az RFC 868. De ezt a példában szereplő kifki.hu intézet már régen nem szolgáltatja.

Mi a FIFO?

• Elnevezett csövek
• Elnevezett pipe-ok
• Egy különleges fájltípus

Mire jó?

Független folyamatok közötti adatcserét tesz lehetővé.

mkfifo pipeneve
 
echo "Információ" > pipeneve &
 
cat pipeneve

Az első sorral elkészítjük a FIFO-t. A második sorral teszünk bele információt, amely háttérbe kerül a végére tett & jel segítségével.

A cat pipeneve paranccsal olvassuk ki a FIFO tartalmát. A FIFO tartalma csak egyszer olvasható ki. A kiolvasással a háttérbe tett folyamat leáll.

Az ulimit felhasználói limitek lekérdezésére és beállítására való.

Pl.:

ulimit -a

core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 16382
max locked memory       (kbytes, -l) unlimited
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 95
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) unlimited
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

Ehhez hasonló eredményt kaphatunk. Az egyes tulajdonságoknak megfelelő kapcsoló a kimenetben látható. Például, ha csak a verem (stack) méretét akarom lekérdezni:

ulimit -s

Vagy felhasználóként mennyi folyamatot és szálat indíthatok.

Lásd bővebben: ulimit

A nyitott fájlokat mutatja

COMMAND    PID       USER   FD      TYPE     DEVICE SIZE/OFF       NODE NAME
init         1       root  cwd   unknown                                /proc/1/cwd (readlink: Permission denied)
init         1       root  rtd   unknown                                /proc/1/

A dátum kiíratására és beállítására való. Szimplán, paraméterek nélkül kiírj a dátumot:

date

Eredmény:

2012. jan. 15., vasárnap, 11.07.34 CET

Ha csak az aktuális évszámot szeretném:

date +%Y

Az év, hó és nap, kötőjelekkel tagolva:

date +%Y-%m-%d

Az év, hó és nap, tagolás nélkü:

date +%Y%m%d

Az idő lekérdezése, kettősponttal tagolva:

date +%H:%M

A kötőjeles forma megint:

date +%F

A kettőspontos forma újra:

date +%R

Vegyesen szóközzel tagolva:

date "+%F %R"

A következő paranccsal beállíthatom az időt (Ehhez rendszergazdai jogok kellenek):

date 01151114

A mintában Január 15-öt állítok be, 11 óra és 14 percre. Ez persze csak rendszergazdaként fog működni.

Így is lehet:

date --set 1998-11-02 
date --set 21:08:0

Néha előfordul, hogy egy időbélyeg számként van eltárolva, és szeretnénk olvashatóbb formában látni:

date -d @1344444444

BSD rendszeren ugyanez:

date -r 1344444444

A Linux operációs rendszerben meghatározhatók a folyatok prioritása. Egy nagyobb prioritású folyamat több processzoridőt kap. Nagyobb terhelés esetén ez lényeges lehet.

Linux alatt fordított prioritás van. Minél kisebb számot adunk meg a prioritás annál nagyobb. A prioritás a következő intervallumban állítható:

-20 ..19

A folyamat akkor kapja a legtöbb processzoridőt, ha -20 a prioritása.

A ps kimenetében is megnézhetjük egy folyamat prioritását, ha használjuk a -l kapcsolót. Az oszlopok közül a nyolcadikban látjuk a prioritásokat, „NI” fejléccel.

Prioritás beállítása indításkor.

nice -n 5 nano

Prioritás állítása futás közben.

renice  2 -p 28488
28488: régi prioritás: 0, új prioritás: 2

A logger programmal felhasználóként is írhatunk egy /var/log/syslog könyvtárba.

logger<Enter>
Ami a naplóba megy

A naplóba dátummal, felhasználónévvel bekerül amit írtunk.

Az alias parancs segítségével a parancsoknak megadhatunk alapértelmezett kapcsolókat.

Az alias szintaktikája:

alias [-p] [név=['parancs']]

A szintaktikából kiderül, hogy önmagában is kiadható az utasítás, de a név után a parancs sem kötelező elem.

Az alias parancs önmagában kiírja az aliaszokat:

alias

Ha például szeretnénk a -l kapcsolót folyamatosan megadni, akkor a következő parancsot adjuk ki:

alias ls="ls -l"

Másik példa: <cdoe bash> alias p=„pwd” </code>

Harmadik példa:

alias dir='ls -la'

Negyedik példa:

alias df="df -h"

Ötödik példa:

alias rm="rm -i"
alias cp="cp -i"

Az összes definiált alias megjelenítése:

alias -p

A -p kapcsoló valójában olyan, mint amikor kapcsolók nélkül adjuk ki az alias parancsot.

A beállított aliasok újabb munkamenet esetén elvesznek. Ezért írjuk őket ~/.bashrc fájlba. Ugyanakkor nézünk szét ebben a fájlban az alias parancs után kutatva. A Debian GNU/Linux 6.x rendszerekben itt van néhány előre definiált alias, és egy lehetőség, mely szerint ~/.bash_aliases fájlban is meghatározhatunk újabb aliasokat.

Ha ideiglenesen szeretnénk kikapcsolni az aliast tegyünk az adott parancs elé egy „\” jel karakteret:

\ls

A parancsokat egyszerűsíthetjük is:

alias l='ls -al'

A parancs részben megadható több parancs is:

alias pl='ls; pwd'

Más aliasokra is hivatkozhatunk:

alias pl='l; p'

Egyszerre több alias is létrehozható:

alias l="ls -l"; p="pwd"; 

Csővezetékkel és grep párossal megoldható, hogy csak az alkönyvtárakat listázzuk:

alias dir="ls -al | grep ^d"

Tegyük fel, hogy van egy ilyen aliasunk:

alias l="ls -a"

Az l ezek után használható paraméterrel is:

l /bin

De kapcsolók is megadhatók:

l -l /bin

Olyankor is hasznos lehet, az alias, ha sokszor akarunk szerkeszteni egy állományt, ami alkönyvtárakban van nagyobb mélységben:

alias e="nano /etc/network/interfaces"

Ha Windowsos parancsokat szeretnénk:

alias md="mkdir"
alias dir="ls"
alias del="rm -i"
alias copy="cp"
alias rd="rmdir" 
alias rename="mv" 

Az aliasnak van egy párja az unalias. Ezzel a paranccsal törölhetők az aliasok. Szintaktikája:

unalias [-a] név [név ...]

Példák:

unalias ls
unalias l

Például keresem a main.c fájlt, amely az aktuális könyvtár valamelyik alkönyvtárban van:

find -name main.c

Lehetséges eredmény:

./c/main.c

find /usr -name abook

find -name main.c | xargs tar -cf valami.tar

A fájlok statisztikájánál már volt szó arról, hogy egy Linux háromféle időbélyeget tárol egy fájlról.

• mtime – modify time – A fájl módosítása
• atime – access time – A fájl olvasása
• ctime – change time – Az inode módosítása

Az emberek ezekből általában az atime-ot ismerik, ami megmondja számunkra, a fájlt mikor olvasták utoljára.

Három napnál régebben olvasott fájlok:

find . -atime +3

Esetleg, ha a gyökérből értelmezve akarom futtatni:

find . -atime +3 -exec ls \;

Az utolsó három napban módosított fájl:

find . -mtime -3

Az utolsó 3 napban módosított txt fájlok:

find . -name '*.txt' -mtime -3

A 10000 kbytenál nagyobb fájlok:

find . -size +10000k

find /utvonal/konyvtar -type f -exec grep -l "Amit keresek" {} +

find . -name "*.py" -exec rm '{}' \;

df

A df parancs paraméter nélkül, megmutatja hány darab 1 kilóbájtos blokk van az adott lemezen. Ebből mennyi foglalt és mennyi szabad.

df -h

A df lehetséges kimenete:

Fájlrendszer    1K-blokk     Fogl.   Szabad Fo.% Csatol. pont
/dev/sda1       95989516  20279928 70810468  23% /
udev               10240         0    10240   0% /dev
tmpfs            1196760      9572  1187188   1% /run
tmpfs            2991900     31884  2960016   2% /dev/shm
tmpfs               5120         4     5116   1% /run/lock
tmpfs            2991900         0  2991900   0% /sys/fs/cgroup
/dev/sda7      576615976 487657136 59645356  90% /home
tmpfs             598380         4   598376   1% /run/user/118
tmpfs             598380        20   598360   1% /run/user/1000

Az udev partíció egy virtuális partíció, az eszközök számára. Az udev minden eszközt a /dev könyvtárban képez le eszközcsomóponttá, egy fájl formájában. A tmpfs partíciók virtuális partíciók a fizikai memóriában, ami gyorsítást szolgálja.

Humánus kimenet, a tmpfs-ek kizárása, fájlrendszerek típusa:

df -hT -x tmpfs -x devtmpfs

free

Lehetséges kimenet:

             total       used       free     shared    buffers     cached
Mem:       5983800    4464320    1519480      97496    1050080    1560168
-/+ buffers/cache:    1854072    4129728
Swap:      2929660          0    2929660

A terjesztéssel kapcsolatos információk megjelenítése:

lsb_release -a

Lehetséges kimenet:

No LSB modules are available.
Distributor ID:	Debian
Description:	Debian GNU/Linux 6.0.5 (squeeze)
Release:	6.0.5
Codename:	squeeze

cpuinfo.sh

#/bin/bash
 
MHZ=`cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq`
 
echo CPU Sebesség: $(($MHZ/1000)) MHz

A processzor adatai:

cat /proc/cpuinfo

vagy:

lscpu

Hány bites a processzorod:

grep flags /proc/cpuinfo

Ha fenti kimenetben látod az lm szót, akkor 64-bites.

A setterm parancs segítségével megváltoztathatjuk a terminálunk színeit.

setterm -background white -foreground blue -store

Virtuális terminálon nem működik.

man setterm

Hexaszerkesztésre több csomagot is találunk parancssorban, nekem eddig a hexedit jött be a legjobban.

hexedit

Telepítés:

apt-get install hexedit

mkdir ~/munka/hex
cp /bin/ls ~/munka/hex/ls
hexedit ~/munka/hex/ls

Indítás:

bc

Kilépés:

quit

Segítség:

man bc

Összeadás:

3+2

Kivonás:

3-2

Osztás:

14/3

Szorzás:

3*5

Hatványozás:

2^8

Gyökvonás:

sqrt(9)

10 → 2

ibase=10
obase=2
5
101

10 → 16

ibase=10
obase=16
12
C

Bemeneti számrendszer kiíratása:

print ibase,"\n"

2 → 10

ibase=2
ibase=10
100
4

#!/usr/bin/bc
 
print "Első szám: "
a = read()
print "Második szám: "
b = read()
c = a + b
print "Összeg: ", c, "\n"
quit

#!/usr/bin/bc

print "Első szám: "
szam1 = read()

print "Második szám: "
szam2 = read()

if (szam1>szam2)
    print "Az első szám nagyobb\n"

if(szam1<szam2)
    print "A második szám nagyobb\n"

quit

A bc képes dolgozni az alapértelemzett bemenetről. Vagyis csővezetékből is képes adatokat venni:

echo 3 + 5 | bc

vagy:

echo 8 "*" 512 | bc

Váltás kettes számrendszerbe (10 → 2):

janos@iskolazo:~$ echo "obase=2; 5" | bc
101

Váltás kettes számrendszerből tízes számrendszerbe (2 → 10):

janos@iskolazo:~$ echo "ibase=2; 101; obase=10;" | bc
5

A -l kapcsolóval betöltődik néhány függvény:

• s(x) – x szinusza; x-t radiánban várja
• c(x) – x koszinusza; x-t radiánban várja
• a(x) – x arkusz tangense; radiánnal tér vissza
• l(x) – természetes alapú logaritmus
• e(x) – e^x értéke
• j(n,x) – n-nedik Bessel függvénye

A PI értéke nincs tárolva, de könnyen megkapjuk:

pi=4*a(1)
3.14159265358979323844

A fokot ezek után így számolhatjuk radiánba, majd annak vehetjük szinuszát:

fok=1
pi=4*a(1)
rad=fok*pi/180
print s(rad)

Alapértelmezett bemenetről szögfüggvények:

janos@iskolazo:~$ echo "pi=4*a(1); fok=1; rad=fok*pi/180 ;s(rad )" | bc -l
.01745240643728351281

Az iconv parancs, állományokat konvertál más karakterkódolásra.

A használható karakterkódolások a -l kapcsolóval kérdezhetők le:

iconv -l

Milyen ANSI kódolások támogatottak:

iconv -l | grep -i ansi

Az eredmény ilyen lehet:

ANSI_X3.4-1968//
ANSI_X3.4-1986//
ANSI_X3.4//
ANSI_X3.110-1983//
ANSI_X3.110//
MS-ANSI//

Használatra példa:

iconv -f ISO8859-2 -t UTF8 -o kimenet.txt bemenet.txt

Vagy:

iconv -f MS-ANSI -t UTF8 -o kimenet.txt bemenet.txt

Ha nem tudjuk milyen kódolású amit szeretnénk átkódolni, használhatjuk a file parancsot:

file szoveg.txt 
szoveg.txt: UTF-8 Unicode text, with CRLF line terminators

A file utasítással információt kérhetünk állományokról.

Milyen kódolású egy fájl:

file -i /etc/apache2/apache2.conf

file /bin/ls

A számítógép architektúrájának kiíratása. Az eredmény például i686. Megegyezik az uname -m paranccsal.

arch

uname -m

A gép mennyi ideje megy, mekkora az rendszerterhelés.

Az uptime parancs lehetséges kimenete:

10:37:00 up  1:06,  3 users,  load average: 0,79, 0,82, 0,71

A load average értéke például 0.01 0.01 1.00, a processzorok átlagos elérési ideje.

• első szám: rövid távon
• második szám: közép távon
• harmadik szám: hosszú távon

Ha 1.00-nál a szám kisebb akkor a processzor mindent azonnal kiszolgál. Ha nagyobb mint 1.00, akkor a proceszeknek várakoznia kell.

CRC összeg számítás:

cksum fájlnév

Ellenőrző összeg számítása, BSD és System V algoritmusai:

sum fájlnév

MD5 ellenőrző összeg készítése:

md5sum fájlnév.kit > md5szam.txt

MD5 ellenőrzése:

md5sum -v -c md5szam.txt

A -v hatására kiírja ha az állomány rendben: OK Ha nem ok, akkor: FAILED

A when nevű parancs egy minimális személyi kalendáriumot valósít meg. Letölthető a weboldaláról, git tárolóból.

Debian alapú rendszereken csomagból telepíthetjük:

apt-get install when

Telepítés után kapunk egy „when” parancsot.

Első indításkor a következő üzenetet kapjuk:

You can now set up your calendar. This involves creating a directory ~/.when, and making
a couple of files in it. If you want to do this, type y and hit return.

Az üzenet szerint beállíthatjuk a kalendáriumunkat, amihez létre kell hozni egy ~/.when könyvtárat. Ha ezt az üzenet megértettük, akkor várja, hogy „y” leütésével nyugtázzuk, majd közli mi az alapértelmezett szövegszerkesztő.

y
You can edit your calendar file using your favorite editor. Please enter the command you
want to use to run your editor, or hit return to accept this default:
  emacs -nw

Én beírtam az „mcedit” parancsot, mivel ezt a szövegszerkesztőt szeretem.

mcedit
You can now add items to your calendar file. Do ``when --help'' for more information.
Szo 2015 szept 26   4:50

A kalendárium szerkesztése ezek után:

when e

Ha az előbb a mcedit szövegszerkesztőt beírtuk, akkor azonnal el is indul, amely szerkeszti számunkra a ~/.when/calendar állományt.

Írjunk be egy teszteseményt:

• szept 26 Tesztesemény

A csillag azt jelenti az év minden napján. A szeptembert magyarul beírva is értelmezi a program. A napot 26-ra állítottam a példában. Mentés után lépjünk ki a szerkesztőből és futtassuk a „when” parancsot.

$ when
Szo 2015 szept 26   4:52

today      2015 szept 26 Tesztesemény

A program kiírja az aktuális napot, és az aktuális eseményt, ha van ilyen bejegyezve, a fenti példához hasonlóan.

Csökkenti vagy növeli egy fájl méretét a megadott méretre.

Figyelem: a csökkentés vagy növelés után egyes parancsok nem a fájl valós méretet mutatják. Ha más eszközzel írjuk a fájlt, a helyzet rendeződik.

A fájl méretét a -s, illetve a --size=MÉRET kapcsolóval adjuk meg.

trunate -s 0 egy.txt

Ha nulla értéket adunk meg, akkor a fájl tartalmát töröljük.

Ha megadott méret nagyobb mint a fájl aktuális mérete, akkor az üres részek 0 bájttal töltődnek fel. A kísérlethez hozzunk létre egy fájl:

echo vmi1 > egy.txt

Nézzük meg méretét:

$ ls -l
összesen 4
-rw-r--r-- 1 janos janos 5 szept 19 19:20 egy.txt

Állítsuk be új fájlméretet:

truncate -s 3 egy.txt

Nézzük meg újra a fájl méretét:

$ ls -l
összesen 4
-rw-r--r-- 1 janos janos 3 szept 19 19:20 egy.txt

Ha a megadott méret kisebb mint az eredeti fájlméret, akkor a fájl tartalmát egyszerűen levágja.

truncate -s 15 egy.txt

Az SMB megosztások eléréséhez itt az smbclient parnacsot használjuk. Ehhez telepítve kell legyen egy ilyen nevű csomag.

Egy állomány feltöltése:

smbclient --user kati -c "put vmi.txt" //192.168.1.4/homes

A kati felhasználó könyvtárába töltjük fel a vmi.txt fájlt. Ha az aktuális felhasználó (ahol kiadjuk a smbclient parancsot) megegyezik a megosztás felhasználónevével, akkor nem kötelező a --user kapcsoló:

smbclient -c "put vmi.txt" //192.168.1.4/homes

Elérés interaktív módon:

smbclient //192.168.1.4/homes

Vagy van amikor a szerveren a megosztás csak „home”:

smbclient //172.16.0.1/home

Esetleg így:

smbclient --user joska  //server/home

Általánosan használt parancsok

Az smb megosztások elérhetők az smbnetfs csomag smbnetfs parancsával, de jelenleg bugos.

A yes parancs mint láttuk, folyamatosan a „yes” szót írja a képernyőre. A folyamatkezelés fejezetben a folyamatok bemutatására használtam. A yes parancs használható arra is, hogy olyan parancsok és scriptek számára, amely bemenetként ezt a szót várja, átadjuk számára csővezetéken keresztül:

yes | script.sh

Ha van egy parancs ami ad egy kimenetet, utána kilép, a watch jól jöhet. Folyamatosan figyeli, hogy változott-e a kimenet:

watch ip r

Ezt az írást (most erre az egy lapra gondolok: Linux parancssor) még 2009-ben itt kezdtem el írni:

• http://hu.wikibooks.org/wiki/Linux/Parancssor

Itt azonban kötekedett az ottani „vezető”, hogy hogyan alakítsam a tartalmat, mit írjak még, ne csak a parancssort tartalmazza a leírásom. Én azonban csak a parancssorról akartam írni, mert arról is lehet több könyvnyi anyagot írni. Na meg legyen hasonló a „Win” leíráshoz. Ezt megelégeltem. Tulajdonképpen akkor gondoltam, hogy szükség lenne egy saját wikire. Íme a SzitWiki (https://szit.hu). Remélem másnak is hasznára válik.

• http://www.gnu.org/software/bash/manual/html_node/ (2018)
• http://hu.opensuse.org/Dokument%C3%A1ci%C3%B3/SL9.3/Rendszer/A_Linux_f%C3%A1jlrendszerei (2018)
• http://www.thegeekstuff.com/2012/02/linux-fuser-command/ (2018)
• http://thesmithfam.org/blog/2006/05/23/bash-socket-programming-with-devtcp-2/ (2018)
• http://linux.about.com/od/commands/a/blcmdl1_findx.htm (2018)
• https://linuxbox.hu/find (2018)
• http://www.comptechdoc.org/os/linux/programming/linux_pgsignals.html (2018; Jelzések)
• http://www.nano-editor.org (2018; Nano)
• http://www.linfo.org/alias.html (2018)

• grep --help
• man grep