Szabad Szoftver Alapok

A szabad szoftver szerzői joggal védett szoftver, melynek licence, vagyis a szerző által alkalmazott felhasználói engedély biztosítja.

Ezeket a szabadságjogokat a nemzetközi Szabad Szoftver Alapítvány határozta meg, ilyen licencek például a GNU GPL, az OSI által elismert szabad szoftver licencek, vagy a Creative Commons BY-SA. A legismertebb szabad szoftverek, melyeket világszerte használnak például a GNU/Linux operációs rendszer, az OpenOffice.org irodai program, a Firefox webböngésző, az MPlayer és VLC médialejátszó, a GIMP, Inkscape, Blender-3D grafikai programok, az Internetet vezérlő programok többsége, mint például az Internet Software Consortium BIND névfeloldója vagy az Apache webszerver és így tovább.

A szabad szoftverek néhány alapvető előnye:

A szabad szoftverek, legyen szó teljes szabad szoftver-terjesztésekről vagy csak 1-1 alkalmazásról szabadon beszerezhetők akár a hálózatról akár más hordozón.

Ha egy teljes-értékű szabad szoftver-rendszert szeretnénk beszerezni, a distrowatch.org alapján választhatunk, a rohamosan növekedő szabad szoftver közösségben látni fogjuk azt is, kinek melyik verzió a kedvence.

Ha csak 1-1 alkalmazást, például irodai szoftvert, grafikai, levelező, csevegő, multimédia szoftvert szeretnénk beszerezni, akkor a SourceForge vagy a FreshMeat oldalakról könnyen letölthetjük őket GNU/Linux, Windows, BSD, OpenSolaris, Mac OS X vagy más rendszerekre.

A szabad operációs rendszerek felhasználói könnyen távol tartják magukat a tulajdoni jogokkal korlátozott (proprietary) szoftverek használatától, ezzel együtt futtathatók ilyenek a szabad szoftvereken. Windows-alapú alkalmazásokat futtathatunk például a Wine segítségével, sőt a Qemu vagy bármely szimpatikus virtualizációs szoftverben könnyűszerrel futtathatunk akár egy Windows vagy akár bármely más szimpatikus operációs rendszert egy ablakban.

Ha bárhol nem-szabad rendszer, például Windows használatára kényszerülünk, azon is könnyedén használhatunk csak szabad alkalmazásokat, mivel ma már nem csak a szabad, hanem a nem-szabad szoftvereknél is az irodai, hálózati, grafikai, multimédia és a speciálisabb területeken is egyre inkább csak keresztplatformos alkalmazások születnek, így ugyanazokat az alkalmazásokat használhatjuk szabad és nem-szabad környezetben.

A hardver az info-kommunikációs technológia fizikai része, önmagában csak egy egyszerű műveletekre elviekben képes álló gép, míg a szoftver az a szellemi rész, mely ezek alapján lehetővé teszi összetett műveletek elvégzését.

A szoftvernek kell tehát utasítani a központi feldolgozó egységet, vagyis a CPU-t, a memóriát, háttértárakat, a felhasználói be- és kiviteli eszközöket, ezek minden info-kommunikációs eszköz alapjai ideértve a legkisebb telefonoktól kezdve a Top500.org címen található szuper-számítógépfürtökig (a legtöbb ilyen GNU/Linux operációs rendszer alatt üzemel).

A számítógépek legfőbb egysége a központi feldolgozó egység, CPU, ezért a számítógépek közötti legfőbb különbség az, hogy a bennük lévő CPU melyik CPU-családba vagy alcsaládba tartozik, ezeket hívjuk architektúráknak vagy al-architektúráknak, géptípusokoknak vagy gép-altípusoknak. A magáncélra manapság majdnem mindig használt architektúra a 32-bites Intel x86 architektúra, illetve egyre inkább annak az AMD cég által fejlesztett 64-bites altípusa. A szoftver-port egy adott szoftver alkalmazása valamilyen géptípusra vagy gép-altípusra. A szabad operációs rendszerek, különösen a GNU/Linux és a BSD rendszerek számos géptípuson és gép-altípuson futnak, akár egy kis ARM vagy akár x86, akár egy nagy S/390 vagy UltraSparc gépen szeretnénk kipróbálni csak a megfelelő port beszerzése szükséges és máris kipróbálhatjuk egy élő CD, DVD vagy BD lemezről és azonnal telepíthetjük is.

Az info-kommunikációs technológiában az adatokat általában fájlokban kezeljük. Ezek lehetnek a memóriában vagy a háttértárolón. Ez azért megfelelő adattípus, mert az összetartozó adatok nem feltétlenül egymás mellett vannak a tárolón. Így a gépen a szabad operációs rendszert indítva - akár élő lemez, akár telepített rendszer, akár telepítő esetén - a hardver adatait fájlokban látjuk; a rendszerek a fájlokat egy gyökér-csomóponttól kezdve hierarchikusan jelenítik meg, a POSIX-szabványos rendszereken a csomópontok jele: a / jel. Az egyes csomópontok címtárak (directory), melyek téves 'könyvtár' (library) fordítását a magyarban kezdi kiszorítani a munkakörnyezet szempontjából használt mappa kifejezés, a fizikai vagy logikai hardver-eszközökre a /dev/ útvonal alatt lévő fájlokon át tudunk hivatkozni.

Az operációs rendszerek - mint nevük is mutatja, a számítógép alapvető működetetését lehetővé tévő legalapvetőbb szoftverek. Mivel az általános operációs rendszer modelljét az 1960-as évek végétől a Unix-nál kezdték megalapozni, ezért ezek legalapvetőbb szabványa a POSIX - ISO/IEC 9945 - melyet az ISO a névadó Richard Matthew Stallman - RMS - közreműködésével szabványosítani az 1980-as években az IEEE 1003 szabvány alapján. Ez alapján működik együtt például a GNU/Linux, az OpenSolaris, a Mac OS X, a *BSD operációs rendszerek vagy az IBM, HP és más nagy cégek rendszerei. A Windows rendszer önmagában nem teljesíti a POSIX szabványt, van hozzá olyan kiegészítő, amivel rávehető a szabványosabb működésre.

Amint említettük a szabad operációs rendszerek, különösen a GNU/Linux és a BSD rendszerek számos géptípuson és gép-altípuson futnak, eljött tehát az idő - akármilyen gépünk is van -, hogy a megfelelő - vélhetően minimum x86 vagy a gépünkre még jobban illő - port beszerzése után, elindítsuk a letöltött úgynevezett lemezképfájlból a programmal megfelelően kiírt élő lemezt, vagy telepítőt, vagy, ha ha az már lefutott, akkor magát a telepített teljes szabad szoftver rendszert, és megnézzük összetevőit.

Egy teljes értékű általános operációs rendszer kritériumai:

A fenti kritériumoknak megfelelő általános célú operációs rendszerek ezen kívül általában tartalmazzák még általában az X Window grafikus kiszolgálót és legalább 1 olyan környezetet, mely erre épülve a fentiek közül egyes és más egyszerűbb tevékenységekhez kényelmes grafikus felületet nyújt, az ilyen környezeteket hívjuk grafikus asztali környezetnek (Desktop Environment - DE), vagy, ahogy itt is sokszor fogjuk hívni röviden munkakörnyezetnek. A munkakörnyezetek közös jellemzői:

Az általános munkakörnyezetek legfontosabb közös összetevői:

A szabad munkakörnyezetek és alkalmazások többsége a híres GIMP képszerkesztő programból származó GTK+ eszközkészlet aktuális változatára épül, így eszközeik: ikonjaik, fájlpárbeszédjeik és így tovább egységesek.

A legismertebb GTK+ alapú munkakörnyezetek ABC-rendben:

A GTK+ eszközkészlet mellett vannak más szabad szoftveres eszközkészletek is, például az FLTK, FOX vagy Qt, utóbbira épül a KDE munkakörnyezet.

Egy modern operációs rendszer boot-betöltőn keresztül töltődik be, a magáncélra általánosan használt x86-alapú gépeken a legáltalánosabb boot-betöltő a GRUB - GRand Unified Boot-loader, vagyis nagy egyesített boot-betöltő, segítségével a telepített operációs rendszereinket különböző módokon indíthatjuk el. A móddal azt is meghatározzuk, hogy az adott operációs rendszert, melyik rendszermag (kernel) képfájllal indítsuk, az indítás folyamatát később pontosan és részletesen tárgyaljuk, most nézzünk belőle csak ennyit:

Az operációs rendszer egyszerűen letölthető az Internetről többféle formában. Ezek közül legismertebbek a kisebb vagy nagyobb lemezképfájlok. Az operációs rendszereknek van élő (live) változata is, egy ilyen lemezképfájlból előállított lemezről indítva a gépet úgy futtathatjuk az operációs rendszert, hogy nem kell telepítenünk, a futó lemezről ki tudjuk próbálni, és ha tetszik, telepítjük. A további kisebb-nagyobb lemezképfájlok kifejezetten telepítők lemezek leképezései. Az elv itt az, hogy nem baj, ha a teljes operációs rendszer nem fér rá egy CD lemezre, letöltjük az 1. CD lemezképfájlt vagy a még kisebb hálózati (netinstall) telepítő lemezképfájlt, a megfelelő módú kiírással elkészítjük belőle a telepítő CD lemezt, elindítjuk a telepítést és a hiányzó összetevőket a hálózatról fogja letölteni.

Van egy olyan lehetőség is, hogy ha egy már meglévő operációs rendszer mellé telepítenénk az újat, akkor letöltjük az az alatt induló telepítő programot. Nincs szükségünk egy optikai lemez használatára, ilyen esetben így rendkívül kényelmesen indíthatjuk a telepítőt.

A rendszer telepítőjének futtatása máshonnan is lehetséges, például a legtöbb gép képes hálózati indításra, ez lehetővé teszi, hogy a szabad operációs rendszert úgy telepítsük, akár több gépre is, hogy az adott gép bekapcsolása után az egész telepítés magától megtörténjen.

Ismételjük, a szabad operációs rendszert bármilyen más rendszer megtartásával, azzal együttműködve is tudjuk telepíteni, ennek csak az a feltétele van, hogy az új rendszer számára szükséges helyet tudjuk biztosítani. A szükséges előfeltételek természetesen mindig szerepelnek a szabad operációs rendszer weblapján is megtalálható telepítő leírásban, például egy általános x86 port esetén: Intel 80486 vagy azzal kompatibilis CPU, 512 MiB RAM, 5 GiB háttértár, VGA kártya. Bármely szabad operációs rendszert tehát bármely már meglévő mellett is magabiztosan kipróbálhatunk, személyesen is megtapasztalhatjuk annak fent ismertetett előnyeit, és ha tetszik, áttérhetünk rá.

Az elindított telepítőt különféle módokban futtathatjuk. A legtöbb telepítő alapértelmezetten egy nagyon stabil, karakteres üzemmódú párbeszédes módban indul, de választhatjuk rögtön a grafikus telepítőt is.

A választás hatására betöltődik a szabad operációs rendszer magja, és egy indító memória fájlrendszer (initial ram disk, initrd), mely a telepítőt tartalmazza, létrehozza az alapvető eszközöket, mint például a Ctrl-Alt-Fx kombinációval használható szabvány távíró terminálokat.

A telepítés első lépése a nyelv kiválasztása, amit a telepítendő rendszer alapértelmezett nyelve is lesz, vagyis rögtön a saját nyelvünkön fog lefutni a telepítő is.

Ezután a telepítőnek át kell venni a telepítő hardver, az optikai médiumok, hálózat vezérlését. Mivel a hardvert a rendszermag vezérli, ezért az, hogy ez rendben megy-e, azon múlik, hogy rendszermag (kernel) rendelkezik-e támogatással az adott eszközhöz. A legtöbb szabad operációs rendszer a telepítőben olyan beállítású Linux kernelképfájlt használ, ami beépítve vagy modulból betölthetően szinte bármely optikai meghajtóhoz vagy általános hálózati csatolóhoz tartozó támogatást biztosítja. A telepítő leírások tartalmazzák a rendkívüli eseteket és azt, hogy ilyenkor milyen modult lehet más régi (flopi) vagy újabb (USB) eszközről betölteni.

Normál esetben rendben lezajlik az optikai és hálózati eszközök vezérlésének átvétele, megadhatjuk a gépünk saját, alhálózatban használható nevét is, például: 'debi1' :-), és a helyi tartomány nevet (domain) is befolyásolhatjuk (például 'attila'), így névfeloldás kérésnél az alhálózaton az azonos helyi tartomány név alatt lévő gépek között tud keresni a rendszer. (Névfeloldás kéréskor az 'attila' tartomány keresésére beállított gépek vissza fogják adni a saját például: debi1, debi2, debi3, vagy bármilyen más nevüket). Ezután a telepítő további összetevői betöltődnek, és csodák csodája a rendszer azonnal elkezdi használni az Internetet például a számítógép órájának beállítására sőt, néhány kisebb összetevőt is letölthet.

Ha egy operációs rendszert önállóan vagy másik mellé telepítünk, szüksége van egyes a háttértáron önállóan elfoglalt egyes fizikai részekre, ezek a háttértároló partíció részei, így a telepítő a partíciókezelőbe lép. Itt lehetőség nyílik arra, hogy automatikusan kiválassza a telepítés helyét a háttértároló olyan területén, ahol nincs partíció. Ha a partíciók most úgy vannak kijelölve, hogy lefedik az egész területet, akkor könnyedén kiválaszthatunk egyet, amelyet gond nélkül pár GB mérettel kisebbre vehetünk, az átméretezés után pedig már használhatjuk a fenti lehetőséget, hogy a partíciókezelő hozza létre az új, szabad operációs rendszer számára szükséges partíciókat. Egy másik lehetőség, hogy kézzel particionálunk, 2 partíciót szoktunk mindenképp létrehozni, egy a cserehely, ami minimum a fizikai memória mérete szokott lenni, de ajánlott akár a kétszerese is, jelenleg általában 2-3 GB. Több módon is felidézhetjük, hogy mennyi a fizikai memória, például átváltunk egy másik virtuális terminálra és ott kiadjuk a cat /proc/meminfo parancsot. Amit mindenképpen létre kell hozni az a mappaszerkezetünk gyökerét tartalmazó partíció és rajta lévő fájlrendszer (valamely GNU/Linux disztribúció esetén általában ext). Látható, hogy egyes mappák (például a sima felhasználók saját mappáit tartalmazó /home/, /usr/, /var/ és így tovább) tartalmát külön részeken is tárolhatjuk, ezeket a gyökérfájlrendszeren lévő gyökérmappába bejegyzett üres mappákba - ezek neve: csatolási pont - csatolja a rendszer (mount); de nem kötelező ezzel a lehetőséggel élnünk, azt is lehet, hogy mindent megtartunk 1, a gyökér fájlrendszeren. A telepítés innentől kezdve szinte már automatikus.

A telepítő innentől már mindössze pár lépést végez. Általában telepít egy kis alaprendszert, ami már alkalmas arra, hogy a rendszer további részeit feltelepítsük vele, meg kell adnunk a 0 azonosítójú, mellesleg szokásosan 'root' felhasználónévre hallgató legfelsőbb szintű felhasználó (superuser, su) jelszavát - ez lesz a rendszergazda, köznyelven root jelszó, és létrehozni egy normál felhasználót, mert minden esetben, mikor erre bármi lehetőség van, szigorúan normál felhasználóval jelentkezünk be, valamint, ha még nincs boot-kezelő telepítve az adott gépre, akkor ezt is elvégzi a telepítő.

Azután, miután az alaprendszer telepítése megtörtént, az általános szabad operációs rendszerek telepítésekor is lehetőség nyílik a rendszer más részeinek telepítésére, amennyiben például a kellő hely megvan, ilyenkor települ a teljes az asztali környezet, tehát maga X-kiszolgáló, az adott szabad operációs rendszer által alapértelmezetten szállított munkakörnyezet, általában a GNOME, az irodai, kommunikációs, grafikai, multimédiás programok, kellékek, és a sok játék közül néhány.

Miután a rendszer indíthatóan települt, a boot-kezelő is beállításra kerül és indíthatjuk is a rendszert.

Egy általános célú szabad operációs rendszer alapértelmezett telepítése esetén ilyenkor a gépünkön eddig is meglévő és újonnan telepített rendszerek és módok közti választási lehetőség után alapértelmezetten a frissen telepített szabad operációs rendszerünk elindul, és 15-30 másodperc múlva a rendszergazda jelszó segítségével egyébként testre szabható grafikus bejelentkezőt (ne feledjük, hivatalosan: dm) kapunk, és itt titkos jelszavunkkal hitelesítve beléphetünk az 1. grafikus virtuális terminálban futó csillogó-villogó munkakörnyezetbe.

A POSIX-szabványos rendszerek, így a szabad szoftver rendszerek minden része is szerver-kliens, vagyis kiszolgáló-ügyfél modellre épül. A rendszer bizonyos általános erőforrásokat szolgáltat, például különféle beállításokkal kezeli a be- és kiviteli eszközöket, amit az ügyfelek igénybe vesznek.

A rendszerbe tehát több felhasználó akár többszörösen is be tud jelentkezni és párhuzamosan programokat futtatni, akár távolról, akár közvetlenül a gép előtt is.

Mivel a legtöbb gépre fizikailag csak 1 billentyűzet és egy kijelző van rákötve, ezért virtuális terminál (vt) szolgáltatás biztosítja a helyi bejelentkezések lehetőségét.

A virtuális terminálok különféle típusúak lehetnek, a szabvány virtuális terminál a valódi távíró (TeleTYpe - TTY) típusú virtuális terminál, ehhez hasonlítanak az ál-terminálok (PTS), amelyek távoli bejelentkezéskor vagy az x-terminál-emulátorban nyílnak vagy a grafikus terminálok.

A legtöbb szabad operációs rendszer több-felhasználós futási szint esetén 6 TTY-t nyit, a 7. lesz ez első grafikus terminál, melyre egy általános telepítéskor a rendszer automatikusan vált.

A virtuális terminálok között a vezérlő (^), meta (M) és funkció billentyűkkel válthatunk, IBM PC stílusú billentyűzet esetén ez a Ctrl, Alt és Fx billentyűket jelenti. Valamennyi létrejött virtuális terminálón bejelentkezhetünk.

A bejelentkezés általános módja esetén, azt a telepítéskor vagy valamely később létrehozott sima felhasználónevünk megadásával kezdjük, ezt követi valamely ehhez tartozó hitelesítési adat, legegyszerűbben jelszó bevitele. A sikeres sikeres hitelesítés után a terminál típusától függően (tty-típusú vagy grafikus) elindul az alapértelmezett vagy általunk választott szabvány (*sh) vagy grafikus héj (x-munkafolyamat, x-session). A grafikus munkakörnyezet menüjében a terminál szót keresve ott is indíthatunk szabvány héjat, mely lehetővé teszi a kombinált, gépelős parancsok kiadását.

A rendszert alapesetben csak rendszergazda joggal lehet leállítani, szabvány héjban legegyszerűbben erre jó a su -c 'halt' parancs, ezt később még tisztázzuk. Ha a grafikus munkafolyamatba (x-session) grafikus felületből jelentkeztünk be, attól kaptunk egy olyan felhatalmazást, hogy a munkakörnyezetből is használhassuk a leállítás funkciót. Lehetőség van általánosan megadni, hogy egy adott felhasználó leállíthassa a rendszert, ennek legegyszerűbb módja, ha hozzáadjuk a powerdev csoporthoz az su -c 'adduser felhasználó powerdev' paranccsal, e parancsokról is lesz szó még később.

A grafikus munkakörnyezet képes jól kiegészíteni a szabvány héj környezetét, egyes esetekben érdemes használni, ezért telepítik az általános célú szabad operációs rendszerek alapból. A grafikus munkakörnyezettel egyes egyszerűbb feladatok kényelmesebben megoldhatók, bár jóval több erőforrást emészt fel gépünktől, míg a szabvány héj parancssoros környezete összetettebb, komolyabb feladatokra alkalmas.

A grafikus munkakörnyezetek általános felépítése jellemzően minden szabad operációs rendszeren (és a nem-szabadokon) is hasonló, átjárható.

A grafikus munkakörnyezet általában a képernyő szélén tartalmaz paneleket, különféle elemekkel, melyek közül a legsűrűbben használt a legáltalánosabban használt grafikus programokat szépen, témákba rendező menü. A héj, így a grafikus héj legfontosabb célja mindig az, hogy programokat tudjunk indítani és kezelni, ezt teszi kényelmesebbé a menü, amúgy a munkakörnyezetből is elérhető parancssorból (például Alt+F2) bármely programunkat el tudjuk indítani. A paneleken állítunk még össze általában olyan elemeket, mint a feladatlista, mely szintén egy lehetőség a futó programok közti váltásra, naptárral kombinált óra, hangerő-szabályzó és más kisalkalmazások, gyorsindítók és munkaterület-váltó.

A gyorsbillentyű-kombinációkat, például az előbb látott Alt+F2 kombinációt, általában az ablakkezelő működteti, mely a munkakörnyezetek legfontosabb része, lehetővé teszi a programok indítását, a közöttük való előtér-háttér váltást, grafikus felhasználói felületet bezáró és más jelzések (szignálok) küldésére és így tovább.

A grafikus munkakörnyezetek beépített fájlkezelővel és egyszerű szövegszerkesztővel, terminál-emulátorral és folyamatkezelővel is rendelkeznek.

Az alkalmazásokat általános esetben a menüből indítjuk, és az megnyílik egy ablakban. Az ablak nem más, mint egy koordináta-pár, mely megmondja, hogy az előtérben hová kell kirajzolni a képernyőn. Az ablakkezelő ezen kívül egyéb elemeket is tud társítani egy ablakhoz, ilyen például a címsor mely például az ablakokat összesítő nézetekben hasznos, gombokkal, kezelőelemekkel, melyek különféle műveleteket tudnak egységesen küldeni az ablakoknak, így például leállató jelzést egy ablakban futó alkalmazásnak.

A grafikus munkakörnyezetekben általában több lehetőség van valamilyen mutató eszköz használatára például arra, hogy kiadjunk egy programindító parancsot. A legfőbb beviteli eszköz azonban továbbra is a billentyűzet, a parancsok többségét ezzel tudjuk kiadni, például egy mappa létrehozását elindíthatjuk a megfelelő menüpontra kattintva, de a nevét már mindenképpen gépeléssel visszük be, az összetett feladatokat elvégző parancsok kiadására a szabvány héj munkakörnyezete megfelelő.

A távíró típusú terminálokba bejelentkezve (tty vagy pts/) elindul a rendszerszintű vagy magunknak választott szabvány héj (*sh*) egy példánya parancsbeviteli jellel, mely mögé bevihetjük a parancsokat, esetleg többet ; jellel elválasztva.

Egy parancs általános felépítése:

parancsnév argumentum1 argumentum2 ...

Vagyis

Az argumentumok lehetnek opciók, először ezek jönnek, a parancs viselkedését befolyásolják, később pedig jöhetnek a fájlnév és egyéb argumentumok.

A GNU konvenció szerint az opcióknak vagy teljes neve lehet -- párossal bevezetve, vagy 1 betűs neve 1 - karakterrel bevezetve, melyek összevonhatók, például ps -Al vagy például az ls --all --directory [a-n]* ugyanaz, mint a ls -ad [a-n]*. Ebben az utóbbi példában, ami egyébként a fájlokat listázó ls parancs, az opciók után, a fájlnév és más argumentumok helyén egy olyan szabályos kifejezést (regular expression - regex) adtunk meg, ahol csak az a-n kezdőbetűjű fájlokat listázza.

Ez a héj, mely a bejelentkezés után adta nekünk a parancsot, a bejelentkező (login) héj, a logout paranccsal lehet kilépni belőle. Indíthatunk belőle például egy másik héjat, ez ilyenkor interaktív héj lesz, például az sh, netán már a fent említett su paranccsal, mely superuser vagy más azonosítóval indít egy interaktív héjat. Látni fogjuk, hogy ezt nem tudjul a logout csak az exit paranccsal lezárni. Mindkettőt helyettesíti a ^D billentyű-kombináció.

A szabvány héj tehát arra való, hogy a tetszőlegesen összetett, gépelős parancsokat ki tudjuk adni. Segít abban, hogy megismerjük ennek módját, és biztosít egy környezetet ehhez.

Amikor ránézünk a szabvány héjra, amit látunk, az néhány karakter és mögötte egy villogó karakter, a kurzor. A kurzor előtti karaktersorozat a testreszabott beviteli jel (prompt). E jel felépítése alább ismertetett beállításokból származik, alapértelmezetten elég bőbeszédű.

Az alapértelmezett beviteli jel kezdődik a szokásos ki@hol formával, vagyis visszaadja a felhasználónevet, majd azt egy @ (at) karakterrel elválasztva mutatja, hogy melyik gépen vagyunk, ezt egy : az egész beviteli jelet általában alapértelmezetten egy $ karakter zárja le. A kettő között egy ~ látható. Ez a rész mutatja, hogy a héj a mappaszerkezetünk mely pontján dolgozik most, vagyis az útvonalat. Egy adott mappa útvonalát abszolútan illetve ha szükséges relatívan is meg lehet adni, az abszolút útvonalat, mint már láttuk, kezdjük a / jellel jelölt gyökértől, és haladunk az almappákon át haladunk a cél felé, például a /etc/network/, /sbin/ vagy /homs/sas/ mappákat megnevezve. (Természetesen egy adott parancsban egy ezen belül lévő sima fájlt is megnevezhetünk.)

A speciális / jel tehát a gyökérmappa, és van még 3 hasznos: a ~ a saját, a . az aktuális, a .. pedig a szülő, ezeket majd látni fogjuk.

Ezt láthatjuk tehát, mikor bejelentkeztünk és elindult a héj, melyben parancsokat adhatunk ki és ezeket elindítja. A parancsok alapvetően külső parancsfájlokban vannak főleg a /bin/ (alaprendszer felhasználói programjai), /sbin/ (alaprendszer rendszergazdai programjai), /usr/bin/ (a rendszer további felhasználói programjai) és a /usr/sbin/ (a rendszer további rendszergazdai programjai) mappában, de van a héjnak néhány tucat belső parancsa is. Amikor csak egy parancs nevét mondom meg, a héj először megnézi, van-e ilyen belső parancsa, ha nincs, akkor fájlban keresi, erről alább.

A héj legalapvetőbb belső parancsa természetesen a help parancs.

A héj belsőhelp parancsa egy bő 1-oldalas kimenetet ad, közlekedni a Shift+PgUp/PgDn billentyű-kombinációkkal lehet. A kimenet mindenekelőtt megmondja, hogy most milyen változatú héjat használunk, továbbá elmondja azt, hogy melyek a belső parancsai, melyekről tovább olvashatunk, ezekről még mi is szólunk, illetve hivatkozik a régebbi man és az újabb info parancsok által használható dokumentációkra, mely parancsokat általában nem önmagában, hanem a minket érdeklő téma megadásával szoktuk meghívni, például az info firefox, info coreutils vagy info nano parancsokkal kaphatunk egy néhány oldalas dokumentációt ezekről a programokról. Az info programból a legtöbb esetben legegyszerűbben a 'q' billentyűvel tudunk kilépni, de a hivatalos kilépés a általános célra használt nagy tudású Emacs szerkesztő stílusú kombináció. Az Emacs stílusát ismerő programokban a kombinációknak a vezérlő billentyűs kombinációkat C- karakterekkel jelöljük, a fájl- és pufferműveletek futtatása a C-x kombinációval kezdődik, a teljes sorozat: C-x C-c (^X majd ^C). A próba után 2 megállapítást is tehetünk. Az egyik, hogy a karakteres üzemmódú programok többségét eredeti (ezt C jellel jelölik) nyelven jelenik meg, ami szinte mindig az Amerikai Egyesült Államokban beszélt angol (en_US) nyelv, bár időnként fogunk látni olyan szoftvert, ami saját nyelvünkön szólal meg. Másrészt a kilépés után visszakapjuk a beviteli jelet a korábban is látott jellemzőkkel. A kérdés az, honnan jönnek a szabvány héj parancssori felhasználói környezetének tulajdonságai, hogy milyen nyelvet keressen számunkra, hogyan épüljön fel a beviteli jel és így tovább?

A szabvány héj adott példányának környezeti tulajdonságait skaláris környezeti változók határozzák meg. A GNU/Linux terjesztésű szabad operációs rendszerek alatt, mint a help parancsból láthattuk, a GNU bash (Bourne Again Shell) az alapértelmezett szabvány héj változat, ebben vagyunk, az info bash paranccsal előhívható igen átfogó súgó leírja ezeket a környezeti változókat (environment variables), ebben láthatjuk, hogy például a nyelvet az adott héjpéldányra vonatkozóan a LANG skaláris környezeti változó állítja be. Egy másik fontos példa a PATH változó. Egy adott felhasználó PATH változájának aktuális értéke adja meg, hogy egy parancs nevénél a héj milyen mappákban keressen számára a megadott nevnek megfelelő programfájlt. Egy változó skaláris értékére a $VÁLTOZÓNÉV néven hivatkozunk, ezt a héj előbb látott belső echo parancsával írathajuk ki, tehát például az echo $PATH vagy echo $LANG vagy paranccsal.

Változókat bármikor felvehetünk vagy módosíthatunk az általános iskolában is látott VÁLTOZÓNÉV=érték formában, a név lehet kisbetűs is, a felhasználó tehát meg tudja változtatni az éppen használt héjpéldány környezeti beállításait, ha azt akarja, hogy a futtatás idejére ez a tulajdonság öröklődjön, tehát más általa indított héjpéldányokra is igaz legyen, akkor az export paranccsal vezeti be az értékadást. A szabvány héj környezetének alapértelmezett rendszerszintű és felhasználói beállításai természetesen beállítófájlokból, szabad, nyílt rendszer esetén akár programozható egyszerű szöveges fájlokból jönnek létre, tehát ilyen fájlokban van például a rendszer alapértelmezett nyelve, a beviteli el tulajdonságai és így tovább. A felhasználók saját mappáikban használhatnak egyes . karakterrel kezdődő nevű fájlokat, minden program először ezekben nézi, hogy a felhasználó milyen beállításokat kér. Ha nincs ilyen, akkor a /etc/ könyvtárban található rendszerszintű beállító fájlokat nézi, ezeket vizsgáljuk hamarosan.

A szabad operációs rendszerek támogatása kiemelkedően jó. Ennek alapját a szabványos és nyílt dokumentációk biztosítják, ez teszi lehetővé a civil és kereskedelmi támogatás szabad versenyét.

Minden dokumentáció elérhető a szabvány héjból is, és ehhez vannak grafikus felületek. A szabvány héj belső parancsait, mint már láttuk a help parancs adja vissza. A legismertebbek a belső, a héj számára munkakönyvtárat váltó cd, mely önmagában a saját mappánkba, amúgy a kívántba vált, a szövegrészletekből, változókból egy sornyi szöveget kiíró echo és a folyamatokat megölő vagy nekik más jelzéseket (szignálokat) küldő kill parancsok. A külső programfájlokról ez nem ír semmit.

Amint írtuk, a külső programfájlok elsősorban a /bin/, /sbin/, /usr/bin/ és /usr/sbin/ mappákban vannak. A felhasználó bármelyiket pusztán a programfájl nevét útvonala nélkül megadva is tudja futtatni, ha az adott programfájl útvonala szerepel az adott felhasználóra éppen érvényes PATH környezeti változójában. A GNU konvencióknak megfelelő programfájlokba mindig be van építve egy --help argumentumra hallgató kis, belső súgó, vagyis ezt mindig el tudjuk olvasni a firefox --help parancshoz hasonló módon.

A legkedveltebbek az adatbázisra épülő súgók, melyek minden parancsot és sok más témát is, szabványokat, beállítófájlokat és így tovább lefednek. Ezek a help által is hivatkozott, és már bemutatott régibb man, és újabb info rendszerek, utóbbi a régibbel felülről kompatibilis, így például az info interfaces parancs leírja a hálózati csatolóinkat beállító interfaces fájl pontos helyét teljes útvonalával, és hogy a hálózati csatolóink, hogyan induljanak.

A szoftverek több fájlból állnak, egyesek funkcionálisak, mások például a szerzői jogi bejegyzésre vonatkoznak, a szoftvercsomag olyan archívum fájl, mely mindezeket egyesíti, és a csomagban lévő valamennyi parancsot, dokumentációt és más fájlt a helyére teszi. Ezért minden csomag telepíti legalább a kötelező dokumentációs fájlokat annak szabványos helyére, mely a /usr/share/doc/*/csomagnév/ útvonal.

Van 1 fontos feladat-orientált dokumentációs forma is, a HOWTO magyarul HOGYAN dokumentáció, mely a /usr/share/doc/HOWTO/ mappába települ. Ezek a TLDP tükrökön is kötelezően elérhető szabványos dokumentációk, ilyen például a tldp.fsf.hu. Ezek a legfontosabb hálózati dokumentációk.

Természetesen jó naprakész lehetőség még az adott szoftver honlapján található dokumentáció megtekintése is.

Közeledünk az interaktív segítséghez, de még mielőtt ezt megtennénk, ott vannak még a lényegesebb dokumentációs gyűjtemények, mint amilyen például a Debian-Administration, az angol vagy magyar Wikipedia, vagy a keresők.

Ha mindezeket kimerítettük, és még nem találtuk a választ, akkor ott a támogatás, melyet mind a közösség, mind az üzleti világ, beleértve sok elismert hazai kis- és középvállalatot, illetve a világ 6 legnagyobb informatikai cégéből ötöt korrekt színvonalon biztosít.

Megbízhatóan működnek az elsősorban civil szervezetek által fenntartott levelezőlisták, fórumok és hasonlók, ezeket több ezer ember olvassa, nyílt archívummal, és bárki feliratkozhat, kérdezhet, a feladatot megoldó válasz általában néhány perc, legfeljebb 2-3 órán belül megérkezik.

Kiemelkedő lehetőség, hogy a szabad operációs rendszerekhez, vagy bármilyen szabad szoftverhez, miután ezek nyíltak, szabad versenyben, tehát rendkívül kedvező feltételekkel lehet kereskedelmi támogatást beszerezni, ráadásul, mivel nyílt forrású szoftverekről van szó, ez a támogatás nem csak a megbízható hálózatok kiépítését jelenti, hanem a szoftverek tetszőleges testreszabását is például kifejezetten egy magyar közintézmény igényeire.

Elmondható, hogy a szabad szoftverekhez van valódi támogatás, amely hatékonyan és megbízhatóan működik.

Grafikus munkakörnyezetünket több módon beállíthatjuk, például grafikus felületen. A kijelző kezelő (dm) dob egy személyes beállítás híján a telepítettek közül a rendszeren most alapértelmezett, például GNOME munkakörnyezetet indítja számunkra. Ha a saját felhasználónkkal eltérnénk attól a munkakörnyezettől, ami a rendszeren most alapértelmezettként be van állítva, akkor a telepített munkakörnyezetek közül a kijelző-kezelő megjelenésekor, a bejelentkezés előtt a Környezet menüben állíthatunk be egy másikat a. Ez a rendszerszintű alapértelmezéstől való eltérés a ~/.dmrc fájlban kerül elmentésre.

A választott munkakörnyezettől függetlenül az alapvető grafikus folyamat, tehát az X ablakozó rendszernek legfontosabb beállítása a hardver által biztosítani képes tartományból a képernyő alapértelmezett felbontásának és képfrissítési frekvenciájának beállítása. Erre minden grafikus munkakörnyezet felületében lehetőség van. Például az alap GNOME munkakörnyezetben ezt a beállítást is a Rendszer/Beállítások/Képernyő pontban találjuk. Ez is egyike azon beállításoknak, melyek az alap ablakozó kiszolgálóra, vagyis az X kiszolgálóra vonatkoznak. Ezeket a beállításokat a munkakörnyezettől függetlenül a ~/.xinitrc fájlban is le lehet helyezni.

A grafikus munkafolyamat/munkamenet összetevői szintén beállíthatók a minden munkakörnyezetben, például az alapértelmezett GNOME munkakörnyezet esetén a Rendszer/Beállítások/Munkamenetek pontban. E beállításokat ugyancsak a ~/.xinitrc fájlban is el lehet helyezni, bár ennek szabvány helye természetesen a ~/.xsession fájl, de ha valaki ilyen beállítófájlt akar létrehozni, általában a ~/.xinitrc-t használja. A grafikus munkafolyamat összetevői mindenesetre szintén leírhatók itt, vagyis, hogy, ha a grafikus munkafolyamatot kézzel, a startx paranccsal indítjuk, akkor az adott felhasználónak alapértelmezetten milyen munkakörnyezet és milyen programok induljanak hozzá azonnal.

A grafikus munkakörnyezet felhasználói beállítási lehetőségei tehát, mint minden más, mivel egyszerű szöveges fájlban vannak, a szabvány héjban is, annak legegyszerűbb eszközeivel is beállíthatók.

Az ls paranccsal listázhatjuk egy adott mappában található fájlokat. Ez alapértelmezetten csak a fájlbejegyzések nevét mutatja, a . karakterrel kezdődő beállítófájlokat nem, utóbbihoz a -a argumentum szükséges, tehát az ls -a paranccsal megtekinthetjük az összes fájlt.

A gépen számos szövegszerkesztő van, az alapértelmezett egyszerű szövegszerkesztő mindig elérhető editor néven is, ez a GNU rendszereken nem más, mint a GNU nano, melynek a szerkesztendő fájl nevét átadva szerkeszthetjük a kívánt beállító vagy bármely más fájlunkat, például a nano .dmrc parancs segítségével.

A rendszer beállító fájljai a grafikus és szabvány héj környezetből természetesen szintén lekérdezhető, módosíthatók.

Az alapértelmezett segédprogramok kiválasztása a /usr/bin/ mappában lévő jelképes (szimbolikus) lánc (symlink) segítségével valósul meg, a grafikus munkakörnyezetünkbe épített fájlkezelőt/fájlböngészőt indítva vagy egy tty-típusú terminálban ezt könnyen követhetjük.

Például a GNOME munkakörnyezetbe épített Nautilus fájlböngészőt indítva ugorhatunk a Fájlrendszer bejegyzésre, majd innen a /usr/bin/ mappába lépve és ott például az előbb említett editor fájl tulajdonságait megtekintve láthatjuk, hogy ez csak egy indító jelképes lánc (symlink), melynek végcélja alapértelmezett telepítés esetén még valóban a /bin/nano útvonalon elérhető nano egyszerű szövegszerkesztő, vagy például az alapértelmezett infobrowser a /usr/bin/info útvonalon elérhető info program és így tovább. A szabvány héj környezetéből a -l (--format=long) argumentummal előhívható részletes ls segítségével kérdezhetjük le, tehát például a ls -l /usr/bin/editor paranccsal.

A rendszerszintű beállítások valójában a /etc/ mappán keresztül valósulnak meg, alapvetően a /etc/ mappában vannak a rendszerszintű beállító fájlok. A felhasználókat például a /etc/passwd fájl tárolja. A grafikus munkakörnyezet fájlkezelőjében megnyithatjuk az adott grafikus munkakörnyezet alapértelmezett szövegszerkesztőjével vagy mással. Az egyes felhasználókat egyes sorok jelzik, úgy a rendszer saját felhasználói bejegyzései, mint a normál felhasználók sora végén láthatjuk az alapértelmezett felhasználói programot, ami GNU/Linux rendszer esetén rendszerint a már eddig is használt szabvány héj, a /bin/bash program. A szabvány héjban a szöveges fájlokat egyszerű esetben, az alapvetőn a fájlok összefűzésére (concatenate) írt cat paranccsal írjuk a képernyőre, de tudjuk, hogy ha hosszú a fájl, a terminálban nem biztos, hogy vissza fogunk tudni lapozni a tetejére, ezért a lapozó programokat használhatjuk (), az alapértelmezett a less lapozó program, ha nem áll rendelkezésre, akkor a klasszikus, ám rendkívül szerény tudású more. Az alapértelmezett grafikus munkafolyamat-kezelő a /usr/bin/x-session-manager (amúgy a which parancs megmondja, hogy egy adott parancs parancsfájlja mely mappában van).

A rendszerszintű beállításokat rendszergazda jog szerzésével tudjuk módosítani. A grafikus munkakörnyezetek általában közvetetten, a rendszergazda terminál segítségével támogatják ezt a lehetőséget. Sima felhasználóként futtatott szabvány héjban erre alapvetően a su parancs szolgál. Ha sikerül megadnunk a szükséges jelszót, akkor a meglévő héjunkból nyílik számunkra egy interaktív héj rendszergazda jogokkal. Ezt a megváltozott beviteli jelből is látjuk. Most bármit módosíthatunk a rendszeren. A rendszergazda jogot a lehető legrövidebb ideig használjuk, ha csak egy feladatra, akkor például a su -c 'nano /etc/passwd' formában, ha a meglévő héjból rendszergazda joggal futtatot héjat nyitottunk, haladéktalanul lépjünk ki belőle (emlékezzünk: az exit paranccsal vagy a ^D kombinációval) így visszakerülve a normál héjba.

A fejlesztők a szoftverek fejlesztésekor több fájlt használnak. Mindezt egy mappában teszik, melyet forrásfának hívunk, ilyen például a https://neumann-gep.svn.sf.net/svnroot/neumann-gep/ forrásfa. A forrásfában a kiadandó szoftveren kívül más fájlok, jegyzetek és egyebek is vannak. A szoftver kiadandó változatához tartozó fájlokból készíti a fejlesztő az eredeti forráscsomagot.

A szabad szoftver terjesztések munkatársai a különféle szoftver projektekből származó forráscsomagot úgy alakítják, hogy azok szépen, egységesen simuljanak bele az adott disztribúcióba és így tárolják a disztribúció forráscsomagjait.

A legtöbb disztribúció a forráscsomagokon kívül úgynevezett bináris csomagokat is terjeszt, ezek kézi konfiguráció nélkül közvetlenül telepíthetők az adott géptípusra.

A legritkább esetben dolgozunk kósza csomagfájlokkal, általában úgy dolgozunk, hogy az adott disztribúcióhoz tartozó tárolókat adunk meg, ezek aktuális állapotából naprakésszé tesszük a gépünkön az éppen elérhető csomagok aktuális adatbázisát, és ezután már csak a kívánt csomag nevére kell hivatkoznunk, azt a haladó szintű csomagkezelő eszköz tudni fogja, hogy mely tárolóban kell keresni, onnan teljesen automatikusan letölti és telepíti, azonnal használhatjuk is a szoftvert.

A forrás és bináris csomagfájlok önálló kezelése is lehetséges bizonyos feltételekkel. A forráscsomagok általában a GNU autoconf - GNU automake keretrendszerrel szállított tar archívumok, ezeket először kibontjuk a tar -xf szoftver.tar* paranccsal, majd cd szoftver/ paranccsal a kibontott mappába lépve lefuttatjuk a ./configure programot, ami előállítja a Makefile állományt. A make parancsot elkészíti a telepítendő fájlokat, majd a su -c 'make install' rendszerszinten telepíti a /usr/local/ mappába.

A szabad szoftver terjesztések alapvetően kétféle bináris csomagfájlokkal dolgozó csomagkezelőt használnak, az egyik a dpkg alapszintű csomagkezelő, a másik az rpm. A -i (vagy --install) opció tud közvetlenül telepíteni egy csomagfájlt, de csak abban az esetben, ha függőségei teljesültek, a dpkg -i csomag_5.5-1_i386.deb parancs lehet egy példa erre. A dpkg -l listázza a telepített csomagokat, a dpkg -L csomag pedig a csomagban lévő fájlokat listázza ki. A forrás és bináris csomagfájlok önálló kezelésének korlátja lehet, hogy a telepítésnek más csomagok telepítése lehet a feltétele, melyről kézzel kell gondoskodni.

A bináris csomagkezelővel telepített csomagok újrakonfigurálása ugyanakkor könnyű, ezt dpkg-alapú rendszereken a Debconf keretrendszer parancsai teszik meg, rpm-alapú rendszereken nincs egységes rendszer. Egy újrakonfigurálást mutat a dpkg-reconfigure csomag_neve példa.

1991-ben nyílt meg az út a szabad operációs rendszerek fejlesztése előtt, ekkor készült ekkor készült el a már meglévő GNU szoftverekhez használható Linux rendszermag (kernel).

1993-ban a Debian projekt a dpkg az alap Debian csomagkezelő, a dpkg fölé megvalósított egy olyan felületet, mely képes volt a függőségek automatikus kezelésére tárolókból, ez az APT - Advanced Package Tool - haladó csomagkezelő eszköz.

Az APT keretrendszer segítségével a kívánt szoftverek telepítését parancssoros és más karakteres és grafikus üzemmódú felületekkel egyaránt kényelmesen végezhetjük, ilyenek főleg az apt-get, apt-cache, aptitude vagy synaptic programok. Az APT a /etc/apt/sources.list fájlból veszi a csomagtárolók forráslistáját, ahol a csomag típusát a deb szó írja le, majd jön a tükör URL, disztribúció és összetevő, például a

 deb http://ftp.hu.debian.org/debian squeeze main 

formában. Ez tetszőlegesen bővíthető ugyanúgy a szabvány héjban szerkesztővel, mint a Synaptic grafikus csomagkezelővel.

Az aktuális tárolók forráslistája alapján egy helyi csomag-adatbázis van a rendszeren. Telepítés előtt ezt mindig naprakésszé tesszük, parancssorban az apt-get update, a Synaptic grafikus csomagkezelő használata esetén pedig az adatbázis frissítését végző Frissítés gombbal. Mind az apt-cache parancs kulcsszó alapú 'search' műveletével, például az apt-cache search music paranccsal, mind a Synaptic grafikus csomagkezelő felületén kereshetünk a sok-sok ezer szoftver között. A kívánt csomagokat az apt-get install csomagnév parancssori megoldással vagy a Synaptic grafikus csomagkezelőben kijelölve és alkalmazva telepíthetjük.

Ha még ennél is több csomagot kívánnánk telepítésre elérhetővé tenni, akkor először is a használt csomagtárolók forráslistáját bővíthetjük. Ezt megtehetjük egyaránt szerkesztővel, vagy a Synaptic grafikus csomagkezelő felület Beállítások/Tárolók pontjával. Még egyszer: ne feledjük, hogy telepítés előtt először mindig frissítenünk kell a helyi csomagadatbázist. Az éppen használt csomagtárolókat tartalmazó forráslistánkban lévő soroktól függően időnként bizonyos csomagok újabb verziói érhetők el.

Csak a telepített csomagjainkat egyaránt frissíthetjük az apt-get upgrade parancs segítségével vagy a Synaptic grafikus csomagkezelő felülettel.

1993-ban és onnantól folyamatosan a Debian projekt lehetővé tette az egész disztribúció leállítási/újraindítási kényszer nélküli frissítését. Ez tipikusan akkor szokott előfordulni, mikor a tárolónkban a disztribúció nevét eggyel frissebbre cseréljük, például most a

 deb http://ftp.hu.debian.org/debian lenny main 

sort tartalmazza, melyben a lenny disztribúciót az újabb squeeze disztribúcióra cseréljük, tehát a

 deb http://ftp.hu.debian.org/debian squeeze main 

formára módosítjuk a sort. Az apt-get update után ezután alkalmazhatjuk az apt-get dist-upgrade parancsot, mely az egész rendszerünket a lenny néven kiadott disztribúciónál már az annál eggyel modernebb squeeze nevű disztribúcióra cseréli.

A futó folyamatokat tudományosan processzeknek hívják és ál-fájlrendszerként megjelennek a könyvtárszerkezetben. A rendszerindításkor a különféle általunk használt fájlrendszereket az egységes mappa-szerkezetté összecsatoló /etc/fstab/ fájlban látjuk, hogy a folyamatokat a proc fájlrendszer típusként olvasott memóriából a /proc/ mappában mutatja a rendszer.

A /proc/ mappát ugyanúgy böngészhetjük, mint bármely másikat, a grafikus munkakörnyezetbe épített vagy a karakteres üzemmódú fájlkezelők valamelyikével vagy a már jól ismert ls paranccsal. Az 1-es init folyamattól kezdve minden folyamat kap egy folyamat-azonosítót (process id - PID). A számítástechnikában, amikor azonosítóról beszélünk, mindig egy számot értünk rajta, a rendszer alapvetően mindent számokkal tart nyilván, a kényelmesebb emberi használathoz ehhez társulhatnak nevek, így van ez a fájlbejegyzéseknél, felhasználóknál vagy a hálózati eszközöknél is. Miután nem lehet tudni, hogy különféle rendszeresemények hatására időnként milyen folyamatok futnak le, ezért nem jósolhatók meg, hogy melyik folyamat milyen azonosítóval jön létre, alapértelmezetten egy időben legfeljebb 2^16 folyamatot tud kezelni a rendszer. A /proc/ mappában egyéb fájlok mellett mindenekelőtt azt láthatjuk, hogy minden folyamatnak létrejön egy saját mappája, melyben tulajdonságait láthatjuk különböző fájlokban, melyet a fájlkezelőből megnyitható leafpad vagy más egyszerű szövegszerkesztővel, vagy természetesen a már jól ismert cat paranccsal olvashatunk.

A /proc/ mappának vannak még jellegzetes fájljai, melyekből mindig fontos, a futó rendszer aktuális állapotára vonatkozó információk nyerhetők. Ilyen például a már látott /proc/meminfo, /proc/cpuinfo és egyéb fájlok.

A folyamatkezelés a grafikus munkakörnyezetből és a szabvány héjban egyaránt lehetséges. A grafikus munkakörnyezetek támogatnak olyan, bármelyik panelünkre elhelyezhető kisalkalmazást, mely mutatja terhelést. Amennyiben olyan helyzet adódna, hogy a rendszer a nagy CPU terheléstől lassulni kezd, ez lehetővé teszi ennek gyors megoldását.

A folyamatoknak küldött leállító jelzés (SIGTERM) küldésén túl (például az ablakkezelőben a bezáró gombra kattintunk, vagy a gyorsbillentyűt használjuk, mely általában az Alt+F4) a leggyakrabban előforduló folyamatkezelő művelet folyamat "megölése" (SIGKILL) olyan esetben, mikor a folyamat nem válaszol a SIGTERM jelzésre (szignálra). A grafikus munkakörnyezetben erre kiválő eszköz a kis xkill program.

A munkakörnyezetek integrált folyamat- illetve egyes helyeken feladatkezelő/rendszerfigyelő alkalmazást is tartalmaznak. Ezeket megtaláljuk a menüben. Egy folyamat futása felfüggeszthető (SIGSTOP) és folytatható, az alkalmazás még támogathatja a megszakítás (SIGINT) vagy más jelzés küldését is.

A szabvány héj alatt is használható alapvető folyamatkezelő parancsokat a procps csomag telepíti. A legalapvetőbb ezek közül a ps lekérdező parancs. Alapértelmezetten 4 tulajdonságot ír a képernyőre és csak azokról a folyamatokról, melyeket az adott felhasználó az adott terminálból éppen futtat. Minden folyamat megjelenítéséhez például a -A kapcsolót használhatjuk.

A folyamatok be- és kimenetéhez különféle csatornák rendelhetők, alapvetően 3: a szabvány bemenet (0), szabvány kimenet (1) és szabvány hibacsatorna (2). A különféle csatornákon megjelenő adatok, melyeken szabályos kifejezések (regular expressions - regex) értelmezhetők különféle operátorokkal irányíthatók, például a parancs mögött álló > vagy >> illetve fájlnév a parancs kimenetét újra- vagy hozzáíró módon fájlba irányítja

A folyamatok | (pipe - pipa) karakterekkel csővezetékekbe rendezhetők (pipelines), minden pipa az előtte álló parancs kimenetét a következő parancs bemenetére irányítja, hogy ez az utóbbi parancs az így kapott adatokon még további feldolgozási műveleteket végezzen. Különösen gyakran használjuk ezt a grep szabályos kifejezések alapján nyomtató paranccsal abban az esetben, ha a grep programnak nem egy fájlból, hanem egy másik program kimenetéből kell egyes sorokat kiszűrni, például a procps csomagból települt most megismert, folyamatokat listázó ps parancs esetén jól kiszűrhetjük, mondjuk a 'd' betűt a sor végén tartalmazó folyamatokat a ps -A | grep d$ paranccsal. A másik eset, amire sűrűn használjuk a more vagy less vagz vélhetően utóbbira mutató pager lapozó parancsnak egy hosszú kimenet átadása, tehát például a ps -A | more, ps -A | more vagy ps -A | pager parancs. Gyakorlat: írassuk ki a leggyakrabban használt coreutils csomagban lévő parancsfájlokat és lehetőleg csak azokat. Tudjuk, hogy a kiválasztott csomagokból települt fájlokat a dpkg -L csomagnév írja ki, és hogy a parancsfájlok valamelyik bin/ mappába települnek, azon fájlok útvonalát tehát, melyek a bin/ szövegrészletet tartalmazzák megkaphatjuk a dpkg -L coreutils | grep bin/ paranccsal.

A folyamatok kezelése számos módon lehetséges, legalapvetőbben a kill parancs általi jelzések, szignálok küldésével. A kill parancs kötelező argumentuma természetesen a folyamatazonosító (PID), az alapértelmezett szignál természetesen a folyamatot önmaga lezárására utasító SIGTERM szignál. Ha leállítanánk és ez nem használ, akkor névvel vagy kóddal (például -SIGTERM = -9) opcióként átadhatunk más szignált is, például a kill -9 1232 formában.

A héjnak van egy saját folyamatkezelése is, ezek a munkák (jobs). A héj munkavezérlése (job control) számos dologra jó, például arra, hogy az előterében (foreground - fg) futó programon kívül több programot is futtathassunk ugyanabban a héjpéldányban. Példaképpen indítsuk el nano programot, írjunk bele pár betűt, majd nyomjuk le a ^Z billentyű-kombinációt, mely a szabvány héjban egy SIGSTOP jelzést küld az előtérben futó folyamatnak. A folyamat felfüggesztésre kerül, és megtudjuk, hogy ez az 1. munka a héjban, a munkák a jobs paranccsal kiírathatók. A munka folytatható a héj belső bg parancsának a munkaazonosítót átadva a háttérben, tehát jelen esetben a bg 1 paranccsal, miközben új programokat futtathatunk az előtérben. Az fg 1 parancs ismét az előtérbe helyezi a futó nano folyamatot. Láthatjuk, hogy annak tevékenysége valóban nem szakadt meg, amit beírtunk, továbbra is ott van. Egy folyamat eleve elindítható a héj hátterében a parancs végéhez az & karaktert hozzáfűzve, például a nano rizsa.txt& formában. A szabvány héj munkavezérlése további képességgel bír még, mely elolvasható például az info bash paranccsal előhívható dokumentációban, és amiből később még veszünk példákat.

A fájl tetszőleges adatok egy blokkja/tömbje, mely lehetővé teszi, bármely összefüggő egységekből álló nagyobb adat egységes kezelését, tehát valamennyi POSIX-jellegű rendszerben közös, hogy bármihez hozzá tudunk férni fájlként. Ebből az előnyből származik 'a Unixban minden fájl' szállóige, mely tehát a szabad szoftverekre is igaz. A POSIX szabványkészlet FHS - Fájlrendszer Hierarchia Szabványa leírja a fájlok helyét.

A különleges, rendszerint blokk (b - például valamennyi lemezszerű eszköz) vagy karakter (c - például hangkártya, terminálok, USB eszközök) típusú eszközleíró fájlokat a /dev/ mappában találjuk. A legtöbb tárolóeszközt SCSI lemez eszközként kezeli a rendszer, így például az SSD, SATA, USB vagy különféle kártyaolvasók médiumai, szinte mind-mind /dev/sd[a-z] nevet kapnak (a Linux rendszermag régebbi, alapban 4-re korlátozott számú szalagkábeles IDE meghajtókat hd jellel jelöli, a hda és hdc az elsődleges és másodlagos mesterek). Így tehát mikor egy egész eszköz elkülönített fizikai részeit, például partícióinak viszonyát szeretnénk szerkeszteni, /dev/sda vagy hasonló néven tudunk hivatkozni a lemez-meghajtó eszköz teljes fizikai mivoltára, például az fdisk vagy parted programban. A lemezen mindenképpen létrehozandó legalább 1-2 vagy további partíciók arab sorszámot kapnak, tehát például a /dev/sda2 nevet az 1. SCSI-ként kezelt lemez-maghajtó médium 2. partíciója. A partíciókon létrejövő köteteken kezeljük majd a fájlrendszereket, alapesetben 1 eszköz 1 partíciója 1 kötet, de összetetteb esetek is vannak, mikor például több lemez közt elosztva logikailag kezelnénk kötetcsoportokat mondjuk a Linux logikai kötet-kezelővel (lvm), ami a /dev/mapper/ mappa alatt hozza létre a kezelendő logikai blokkeszközt. E példában most maradjunk a legegyszerűbb esetnél, mikor a /dev/sda2 elsődleges partíció eszközünk 1 kötet, tehát közvetlenül hozunk rajta létre fájlrendszert.

Különféle típusú fájlrendszerek vannak és általában 3 dolgot teszünk velük: létrehozzuk őket az mkfs paranccsal, gyökérmappaként vagy az alá csatoljuk őket, hogy a rajtuk lévő fájlokat egy egységes szerkezetben lássuk a mount vagy a GNU/Hurd rendszer esetén a settrans paranccsal és beállított idő vagy csatolásszámonként vagy alkalomszerűen ellenőrizzük őket az fsck paranccsal. E keretprogramoknak a típust mindig a -t opcióval adjuk meg, bár használhatjuk követlenül mondjuk az mkfs.ext2 vagy e2fsck parancsokat is.

A GNU/Linux rendszerek alatt ma a legáltalánosabban használt fájlrendszer típus az ext2 típussal oda-vissza kompatibilis ext3 fájlrendszer típus. Tudja mindazt, amit egy POSIX-szabványos fájlrendszer típusnak tudni kell, például a felhasználók és felhasználói csoportok (/etc/groups) jogainak kezelését, naplóz és így tovább. Egy ext3 típusú fájlrendszert a /dev/sda2 köteten tehát például az mkfs -t ext3 /dev/sda2 paranccsal hozhatunk létre.

A legfontosabb művelet a csatolás (mount), eleve ezt teszi a rendszermag az induláskor egy olyan megnevezett eszközön lévő fájlrendszerre hivatkozva, melyre egy operációs rendszer gyökerét telepítettük. E gyökér alatt lévő üres csatolási pont (mount_point) mappákba csatolódnak azon mappák tartalmai, melyeket más fájlrendszerekre választottunk le. Például, ha a telepítésnél azt a praktikus gyakorlatot folytattuk, hogy a /home/ útvonal alatt a sima felhasználói hozzáféréseinkkel használt saját mappáinkat egy külön fájlrendszeren tároljuk mondjuk a /dev/sda3 köteten, akkor a mount /dev/sda3 /home/ parancs teszi a fájljainkat azok helyén láthatóvá. A /proc/ memóriában lévő fájlrendszer tartalma is így jelenik meg e mappában. A különféle fájlrendszereken lévő tartalmak kézi csatolásának lehetősége csak egy nagyon jó és fontos lehetőség, de természetesen ezt alapvetően a rendszer elvégzi helyettünk, éspedig a /etc/fstab fájlban lévő rendszerszintű beállító fájlrendszer táblázat alapján. Az aktuális csatolásokat a /etc/mtab tartalmazza, ami a sima mount paranccsal ki is íratható. A /etc/fstab fájlban lévő összerendelésekkel a mount csatolási_pont is elegendő, és e bejegyzésekben lehet eltérni az alapértelmezett (default) csatolási mód leírásában is található opcióktól. Láthatjuk például hogy az 'ro' (mint read-only) opcióval csak-olvashatóként is tudunk csatolni (vagy kimondottan előírhatjuk az 'rw' (mint read-write) az írható módot), a 'noauto' nem csatol fel rendszerindításkor, a 'user' lehetővé teszi egy adott fájlrendszer felcsatolását normál felhasználóval. Ehhez az is kell, hogy a csatolási_pont az adott felhasználó számára írható legyen, a jogokról pár bekezdéssel alább. A fent említettek fájlrendszer független csatolási opciók voltak, az összeset elérjük az info mount paranccsal.

Az fsck fájlrendszer ellenőrző parancs a POSIX szabványos fájlrendszerek metaadatain tárolt időtartam vagy csatolási szám után (melyet ext2/ext3 fájlrendszer esetén hangolni tudunk például a tune2fs paranccsal) automatikusan lefut. A futáskor mindig fontos, hogy az adott fájlrendszer ne legyen írhatóan módon felcsatolva. Az fsck és az mkfs programok nagyon érzékenyek, a legkisebb hiba nélkül kell lefutniuk, miközben rengeteg, egészen különböző fájlrenddszer típussal kapcsolatban kell elvégezni ezeket a műveleteket, éppen ezért ezekre különféle csomagokból települő fsck és mkfs programok vannak. Az ext2 vagy magasabb verziójú fájlrendszerek ilyen parancsait például az e2fsprogs csomag telepíti, benne a merev láncok (hard link, ilyet is az ln paranccsal tudunk létrehozni) által fsck.ext2[2-4] neveken is elérhető e2fsck parancs végzi el az ellenőrzést. Az fsck és az mkfs parancsok tehát csak keretprogramok, ténylegesen a kívánt fájlrendszer típusnak megfelelő programfájl futtatása történik (természetesen ha telepítve van az adott fájlrendszer típust kezelő programok csomagja). Előbbi a hivatkozott eszköz azonosító blokkján át (su -c 'blkid') megpróbálja azonosítani a hivatkozott fájlrendszer típusát, ha ez sikerül, automatikusan meghívja a szükséges programot. Az fsck nem szabványosított fájlrendszer-független opciói némelyike, például a -a vagy -y automatikus javítást igyekszik végezni. Jó tudni, hogy az e2fsprogs csomagból automatikusan települt a badblocks parancs is, mely képes fizikai hibák ellenőrzésére. Egy háttértárolón fizikailag tönkrement blokkokat persze nem lehet javítani, a rendszer a badblocks eredményének segítségével arra képes, hogy megjegyezze e hibás blokkokat és elkerülje használatukat. Az e2fsck például a -b opcióval fel tudja használni a badblocks programot. Kiemelt jelentősége van annak az ismeretnek, hogy a háttértárolók pár év alatt tönkremennek. Ezt alapvetően pénzzel lehet kezelni. Több mindent is tehetünk, az egyik a több-lemez eszközök (multi-disk, MD még szokott elnevezéssel: RAID) használata, ami lehet hardveres (MD (RAID) vezérlő kártya), vagy szoftveres megoldás az "mdadm" csomag parancsainak segítségével. Több-lemezes (md) eszköz használata esetén lehetőségünk van például két hasonló méretű fájlrendszer automatikus tükrözésére, melyek külön háttértárakon vannak. Mihelyst tapasztaljuk, hogy kezdenek hibás blokkok lenni a lemezen, onnantól fontosat ne, legfeljebb lényegtelen adatokat tároljunk rajta. A teljes vagy növekményes (inkriminális) biztonsági mentés egy csak erre a célra időnként automatikusan bekapcsolt távoli gépre, az egyik, vagy talán a legjobb megoldás.

A POSIX Fájlrendszer Hierarchia Szabvány (FHS) leírja a főbb mappákat, ahova a fájloknak kerülni kell, a /home/ mappát különös felhasználói adatbiztonság miatt gyakran leválasztják külön fájlrendszerre, a /usr/-t mérete miatt, a /boot/ leválasztása is jól jöhet, a /tmp mérete is könnyen fogható így, a /var/-ban pedig egyenesen több mappa is van, amit méret fogás miatt akár még külön is le szoktak választani, főleg sok felhasználó esetén. A /bin/, /dev/, /etc/, /lib/, /proc/ és /sbin/ nem választhatók le, nos, lássuk tehát a fontosabbakat:

A /bin/ mappát külön is érdemes szemügyre venni, hiszen itt van a szabvány héj alatt legtöbb legfontosabb parancs, különösen a coreutils csomag parancsai (dpkg -L coreutils | grep bin/), melyeket például a fájlkezelés során a legalapvetőbben használunk.

Az ls -l / parancsból látszanak a györkérmappa fájlbejegyzéseinek legfontosabb tulajdonságai:

drwxr-xr-x   2 root root  4096 jan 23 14.37  bin
lrwxrwxrwx   1 root root    11 2007 márc 21  cdrom -> media/cdrom
drwx------   2 root root 16384 2007 márc 21  lost+found
dr-xr-xr-x 101 root root     0 febr 26 07.05 proc
-rw-r--r--   1 root root     0 ápr 18 14.26  q
drwxrwxrwt  10 root root 20480 ápr 18 10.55  tmp

Az 1., 3. és 4. mezők a legfontosabbak. Utóbbi kettő mondja meg, hogy a fájlnak mely felhasználó a tulajdonosa (owner) és melyik csoportba tartozik (group). A gyökérmappa maga és abban minden fájlbejegyzés a 'root' felhasználó tulajdona és minden fájlbejegyzés a 'root' felhasználó csoportjába is tartozik. Az 1. mező 1. oszlopa a fájlbejegyzés típusát mondja meg, ami lehet directory (d - magyarul sajnos keverik a library - könyvtár kifejezéssel, ezért mi mappának hívjuk), sima fájl (-), symlink (l - jelképes lánc), pipeline file (p - csővezeték fájl), block device (b - blokkeszkök), character device (c - karaktereszköz) vagy network socket (s - hálózati socket). A hétköznapi életben a mappákkal (d), sima fájlokkal (-) és jelképes láncokkal (l) kell dolgoznunk.

Az 1. mező maradék 3x3 oszlopa adja 3 jogosultsági szinten, a tulajdonos felhasználó (u), a csoporttagok (g) és mások (o) szintjén a fájlra nézve a jogokat, vagyis fájl alapvető módját (mod). Az alap jogok rendre az olvasási (r,4), írási (w,2) és futtatási (x,1) jogok. A futtatási joggal rendelkező fájlokat próbálja meg majd a rendszer futtathatóként értelmezni, jellemzően tehát ilyenek vannak *bin/ mappákban. Mint már említettük, egy adott felhasználó PATH környezeti változójának aktuális értéke mondja meg, hogy egy programnévre hivatkozva, azt mely mappákban keresse a rendszer. Mappáknál a futtatási jog kell ahhoz, hogy a mappában ne csak dolgozhassunk egy ismert nevű fájllal, hanem ki is listázhassuk a mappa tartalmát, ezért a legtöbb mappára mind a tulajdonos felhasználónak, mind a csoportnak, mind mindenki másnak olvasási és futtatási joga van. A jelképes lánc (mint itt a /media/cdrom/ mappára ugrasztó /cdrom) a cél jogait mutatja, jelen esetben azt, hogy CD-ROM csatolási_pontját mindenki írhatja, hiszen a csatolási_pontra írási jognak kell lenni, hogy eredetileg üres voltába beolvashassa a csatolt fájlrendszer tartalmát. A lost+found mappára a tulajdonos root felhasználónak minden joga megvan, de még a root csoport tagjainak sincs meg a 3 jog egyike sem, ahogy másoknak sem. A /proc/ mappára mind a 3 jogosultsági szint tagjainak van olvasási és futtatási joga, nem kell rajt írási jognak beállítva lenni, lehet közvetlenül, interaktívan írni root felhasználóként, de felesleges. A q egy közönséges fájl, csak példaképp hoztam létre, nem program, nem kell rajta futtatási jognak lenni, így a 666 jogból jön le az alapértelmezett 022 umask és alakult ki a sima 644 jog (és nem 755). A /tmp/ mappán mindenkinek minden joga van, de van rajta egy speciális beállítás, a 'sticky' (ragadós) bit. Ez mappáknál azt adja, hogy a felhasználók a mappa általános írás joga ellenére csak az általuk futtatott folyamatok által futásuk alatt létrehozott átmeneti fájlokat törölhessék. A másik ilyen nevezetes módosító a 'setuid' (felhasználóazonosító állító) bit, mely 1-2 különleges és rendkívül óvatosan megírandó programfájlon, például a /sbin/passwd programfájlon látható, hogy azt ne az út indító felhasználó, hanem a programfájl bejegyzett tulajdonos felhasználójának (ez esetben a rendszergazda) jogaival futtassa, más különben nem tudná lecserélni a sima felhasználó a saját jelszavát a titkosított jelszavakat tartalmazó /etc/shadow fájlban. Egy másik ismert példa az X kiszolgálót indító /usr/bin/X programfájl, ahol azért van szükség arra, hogy a sima felhasználó a programfájlt azt szintén annak root tulajdonos felhasználó jogaival futtassa, mert az X kiszolgáló klasszikus változata még nem tud sima felhasználói jogokkal futni - ezért, és nem csak a hátrányos erőforrás pazarlás miatt nem használunk egy komoly, kimondottan szerver célú rendszeren grafikus felületet.

Egyes, például az ext2 vagy azzal kompatibilis típusú fájlrendszereken a fájloknak speciális attribútumai is lehetnek, speciálisan is használhatók. Természetesen az lsattr parancs képes kilistázni, hogy van-e valamilyen különleges attribútum beállítva a fájlra, és a chattr paranccsal lehet beállítani ilyeneket. Teljes referenciához nagy mélységben át kell tanulmányozni a dokumentációt, de azért megemlítünk pár érdekes lehetőséget.

A fájlkezelés a grafikus munkakörnyezetben legegyszerűbben valamely beépített fájlkezelő/fájlböngésző alkalmazásával, vagy külső fájlkezelő alkalmazással valósítható meg, mint amilyen például a Tux Commander (TC), vagy Double Commander (DC) alkalmazások. A legnépszerűbb GNOME munkakörnyezett beépített fájlböngészője a Nautilus, az Xfce munkakörnyezeté a Thunar, az LXDE munkakörnyezeté a PcManFM közös GTK+ eszközkészletük miatt kényelmesen használhatók egymás alatt. Mi most az alap GNOME munkakörnyezet beépített Nautilus programjának fájlböngésző üzemmódját nézzük.

A fájlkezelés legfontosabb tulajdonságai a Rendszer menü/Beállítások/Fájlkezelés ablak Viselkedés lapján érhetők el, például a valódi és nem a Kuka (Trash) mappába való törlés lehetősége illetve az, hogy a Nautilus egy mappa ikonjának ne csak helyi menüjével, hanem simán kattintva is más fájlkezelőkhöz hasonlóan böngésző módban nyíljon. Itt tehát mindig a fájlböngésző módot vesszük.

A fájlböngésző indításakor az alapértelmezetten a saját mappánkat mutatja ikonnézetben kevesebb információval. Átválthatunk listanézetre. A lista felett a Webböngészőkhöz hasonlóan látszik a címsáv (helysáv), ami mutatja a listázott hely útvonalát a fájlok hierarchikus rendszerében (FHS) - tehát jellemzően a /home/felhasználónév útvonalat.

A listanézet a fájlok néhány tulajdonságait mutatja, ezek bővíthetők a legelső tulajdonság a méret. A fájlok, mappák méretét jellemzően KB, KiB, MB, MiB és GB, GiB egységben adjuk meg, ahol a B a Bájt (szokványosan 8 bit), K, M, G a kilo, mega és giga a Ki, Mi, és Gi pedig a 2^10, 2^20 és 2^30 szorzót jelenti.

A listanézet akár a gyökértől mutatja az egész hierarchikus fájlrendszert, tehát a fát akár teljes mélységben, ezzel tehát lehetővé válik egy olyan ablak megnyitása, mely kijelzi a könyvtárak/mappák nevét, méretét és helyét illetve más tulajdonságait az egész mappa-szerkezetben.

A fájlokat nem csak böngészni, hanem keresni is lehet, erre beépített eszköz áll rendelkezésre a grafikus munkakörnyezetekben is, mely akár külön is elindítható a menüből, vagy például a Nautilus fájlböngésző esetén beépítve rendelkezésre áll. Keresni lehet egyszerűen a fájlok neve alapján, de hozzáadhatunk méret, időpont, tulajdonos és csoport és a bevont meghajtókra, fájlrendszerekre vonatkozó feltételeket.

A fájlok tartalmi típusát azok fejléce alapján felismeri a rendszer. Így például a sima szöveg-alapú fájlokat, melyek meghatározó számban vannak jelen a rendszeren felismerhetjük és rájuk hivatkozva a társított parancsok közül választva megnyithatjuk, például olvasásra vagy írásra.

Az adott környezetben alapértelmezett szövegszerkesztőt (editor) megnyithatjuk magában, egy létező sima szöveg-alapú vagy egy üres fájlra hivatkozva, a billentyűzet segítségével lehetővé válik a szövegbevitel a fájlba, majd az elnevezés és mentés valamely meghajtó meghatározott helyére a mappa-szerkezetünkben kiválasztott útvonal és egyedi névadás alapján.

A fájlok létrehozása a grafikus munkakörnyezet fájlkezelőjében legkönnyebben a Fájl menü adott pontjaival lehetséges. A nevet megadva létrehozhatunk olyan fájlt a saját mappán alatt esetleg máshol, ha tudunk még olyan mappáról, amiben írás (fájl létrehozása/törlése) jogunk van.

Fájlok rendezése név, méret, típus és módosítás dátuma szerint növekvő és csökkenő sorrendben szintén lehetséges a grafikus munkakörnyezetbe épített vagy más fájlkezelővel. A listanézet mezőinek nevén egyet vagy kettőt kattintva válthatunk rendezést.

Fájlok és mappák elnevezése olyan tartalommal bíró névvel ajánlatos ezért, ami segíti elrendezésüket és megtalálásukat. Nagybetű-érzékeny fájlrendszerekkel dolgozunk, melyek előrébb sorolódnak, ezt rögtön kihasználhatjuk, #+- karakterek megengedettek és a fájlok szélein szintén jól jönnek, szóköz tilos, hiszen ez az argumentumok alapvető elválasztója (szeparátor), helyette _ jelet használunk a túlzott idézőjelezgetés elkerülésére. Fájok és mappák elnevezésnél vegyük figyelembe, hogy legegyszerűbb balról-jobbra ABC-rendben keresni ezeket, a név ne legyen frappáns, de azért ne feledhető rövidítés.

Fájlok, mappák átnevezése a grafikus munkakörnyezetben legkönnyebben a fájl nevére hosszan kattintva lehetséges, ami szerkeszthetővé teszi a nevet. Az Enter billentyű leütése után a fájl átnevezésre kerül.

Miután minden szoftver, az operációs rendszer alapvető, összetevői és az alkalmazások és saját adatok is gyakorlatilag mindig fájl, az operációs rendszer használata gyakorlatilag mindig fájlkezelés, fájlok futtatása, olvasása, írása, másolása, mozgatása és így tovább. A fájlkezelés nélkülözhetetlen és az egyik legalapvetőbb számítástechnikai ismeret, néha 1, néha több fájlt kell kezelnünk.

Önálló fájl vagy mappa kijelölése, illetve fájlok és mappák összefüggő, vagy nem összefüggő csoportjának kijelölése mappák között a grafikus munkakörnyezetbe épített vagy más fájlkezelők egy képessége. A grafikus munkakörnyezet fájlkezelőjében egy önálló fájl vagy mappa kijelölése legegyszerűbben egy sima kattintással tehető meg. Fájlok és mappák összefüggő, vagy nem összefüggő csoportjának kijelölése a teljes mappaszerkezetünk mappái között a Shift és Ctrl billentyű segítségével lehetséges.

Fájlok és mappák mozgatása mappák és meghajtók között a grafikus munkakörnyezetbe épített vagy külső - például Tux Commander (TC) vagy Double Commander (DC) - fájlkezelővel kétféleképpen lehetséges. A beépített fájlkezelőben a kijelölt fájlokat a vágólapra vágjuk, majd a célhelyen beillesztjük. A több-paneles fájlkezelőkben a műveletet alapvetően okosabban és biztonságosabban végezhetjük el, a kijelölt fájlokat a helyi menüvel vagy a gyorsbillentyűvel közvetlenül és azonnal a célpanelben lévő mappába mozgathatjuk.

Fájlok és mappák másolása mappák között a fenti bekezdésben látható mozgatáshoz hasonló a beépített fájlkezelőben vágólapra másolás műveletével. Az önálló, több-paneles fájlkezelőkben a kijelölt fájlokat a helyi menüvel vagy a gyorsbillentyűvel közvetlenül és azonnal a célpanelben mappába mozgathatjuk.

Fájlok és mappák törlése és a lomtárba/kukába helyezése a grafikus munkakörnyezetben többféle módon lehetséges. A rendszer beállításai között a fájlkezelő viselkedésénél be lehet állítani, hogy a fájl helyi menüjében megjelenjen-e a közvetlen törlés. Az alapbeállítás általában az, hogy a kijelölt fájlokon a Delete billentyű önmagában való leütése a kukába névvel is társított, fizikailag általában a Trash mappába 'törli' valójában csupán helyezi át a fájlt.

Fájlok és mappák visszaállítása a lomtárból/kukából tehát valójában annyi, hogy a felhasználó ~/Trash mappájából a fájlokat visszamozgatjuk eredeti helyükre.

A lomtár/kuka kiürítése a Trash mappában lévő fájlbejegyzések törlését jelenti.

Amennyiben az adott fájlra az írási jog biztosítható, például mi vagyunk a fájl tulajdonos felhasználói, akkor a tartalom módosítása a grafikus munkakörnyezetben rendkívül egyszerű, hisz jellemzően bármilyen tartalmi típusú fájlhoz telepítve van a fájl helyi menüjével kiválasztható társított szerkesztő program. Ha letöltünk valamilyen új tartalmi típusú fájlt, és nincs hozzá, akkor természetesen a csomagkezelővel vagy a Programok telepítése/hozzáadása ponttal automatikusan telepíthetünk ezt szerkesztő programot.

A jogok kezelésének lehetőségei a grafikus munkakörnyezetben legegyszerűbben a beépített vagy önálló fájlkezelő/fájlböngésző segítségével lehetséges. A fájl helyi menüjével előhívható tulajdonságok közt találjuk a fájlra beállított alapvető jogokat a tulajdonos felhasználó (u), a csoport (g) és a többiek (o) szintjén. Azt, hogy a fájlkezelőt sima felhasználóként való használata során módunk legyen egyes műveletekhez rendszergazdaként hitelesíteni magunkat alapértelmezetten a sudoers beállításával tudjuk engedélyezni, vagy természetesen sokkal egyszerűbben dolgozhatunk a grafikus munkakörnyezetekből könnyen elérhető x-terminal-emulator-ral.

A fájltömörítés fogalma a számítógépes tudomány-ágak egy területe, melynek célja az adatok feldolgozása oly módon, hogy azok minél kevesebb helyet foglaljanak, vagy minél gyorsabban lehessen őket továbbítani. Az általános a veszteség-mentes tömörítés, mely főleg több fájl archívumánál hasznos, ezért általában itt használjuk.

Egy meghajtó mappáiban lévő fájlok tömörítése egy tömörített archívumba a grafikus munkakörnyezetben a beépített vagy külső fájlkezelővel fájlok kijelölésével kezdődik. Ezután a menüvel vagy a gyorsbillentyűvel kérjük a tömörített archívum létrehozásának lehetőségét, és ennek hatására a fájlkezelő gondoskodni fog az archiváló párbeszédéről. A párbeszédben nevet adva a létrehozandó archívumnak, jóváhagyjuk a műveletet és a tömörített archívum elkészül a kiválasztott típusban, mely általában egy gzip vagy bzip2 tar formájú archívum.

Fájlok kibontása egy meghajtó megadott helyéről a grafikus munkakörnyezetben is lehetséges. Rákattintunk az rákattintunk az archívumra és megnyílik a kibontó párbeszéd, ahol beállíthatjuk/módosíthatjuk a kibontási útvonalat esetleg más lehetőségeket.

A fájlkezelés a szabvány héjból messze a leghatásosabb, ráadásul ezek a legalapvetőbb technikák is. A szabvány héjból való fájlkezelés túlnyomó részét az operációs rendszer egyik nélkülözhetetlen összetevőjével a coreutils csomag által biztosított parancsok segítségével valósítjuk meg. Az ismert és általunk írt kis héjprogramok a legnagyobb fokú hordozhatóság érdekében a héj belső parancsain kívül főleg a coreutils parancsait használják. Eddig a mappákat listázó ls és a gyakorlatban főleg szövegfájlok kiíratására használt cat parancs alapvető használatát láthattuk. Most csak a coreutils és a fájlok alapvető kezelésére használt még néhány csomag legalapvetőbb programjait vázoljuk fel, többet vázolunk a héjprogramozás résznél.

A fájlok listázása tehát a coreutils ls parancs segítségével lehetséges. Alapértelmezetten a . karakterrel kezdődő beállító fájlokat és mappákat kivéve a héj számára aktuális munkamappa fájlbejegyzéseinek csak nevét listázza ABC-rendben. Minden fájlt a -a (--all), minden alapvető részletet pedig -l (--format=long) opcióval lehet listáztatni, tehát röviden az ls -al paranccsal. Ez többek között mutatja a fájl fájlrendszerben való bejegyzésének típusát, módját, a fájl tulajdonos felhasználóját és csoportját, méretét és persze nevét. Az ls -alR / mindenről kiírja ezeket.

Fájlok rendezése név, méret, típus és módosítás dátuma szerint növekvő és csökkenő sorrendben is lehetséges a szabvány héjban egyaránt. Mint láttuk, az ls parancs alapban balról jobbra ABC-ben rendez. A leírásból kiderül, hogy a méret a -S, a módosítás dátuma (mtime), pontos időpontja a sima -t opció alapján lehet az elsődleges rendezés alapja. Az ls a fájl tartalma alapján társított MIME adatait nem vizsgálja, csak a név alapján, áttételesen következtethetünk erre a tartalmi típusra a fájlnévben lévő utolsó pont utáni karakterek szokványával ("extension" azaz "kiterjesztés" névvel is említik), melyre a -X opciót használjuk. A -r (reverse) fordítja meg a sorrendet.

A fájlok és mappák elnevezésénél tartsuk a fenti szabályokat. A fájlok kezelésénél a szabvány héjban és egy jó programozói munkában is hasznos ez.

Egy fájl vagy mappa megtalálása a fájlrendszereken a findutils csomag find parancsának megadott kiinduló útvonalakkal majd feltételekkel lehetséges, vagyis a find parancs nyelvtana eltér a szokottól, mert előbb a fájlnév argumentumokat kell megadni, majd 1 kötőjellel jönnek a teljes nevű feltételek. A find /dev/ /etc/ -name "*a*" parancs például a /dev/ és /etc/ mappában lévő minden "a" karaktert tartalmazó nevű fájlt fog megtalálni és kiírni.

Fájlok keresése a fájl típusa alapján már lehetséges a find parancs használatával természetesen a -type kifejezéssel, ami után megadhatjuk a jól ismert 7 típus 1 betűs jelét. Ismétlésül ABC-rendben: b - blokkeszközfájl ("block device"), c - karaktereszközfájl ("character device"), d - mappa ("directory", helyesen "címtár" néven kéne nevezni), f - sima fájl ("file"), l - jelképes lánc ("link"), p - megnevezett cső ("pipe", "FIFO" néven is nevezik, mert valójában "1. be - 1. ki" veremtípusként kezeljük) és s - hálózati socket. A find parancs dokumentációjában természetesen megtaláljuk az összes, például a -size vagy a -perm keresési opciót, mely a fájlra vonatkozó jogok alapján keres.

A keresés eszközök használata fájlok és mappák megkereséséhez nem merül ki csak a find parancs használatával. Fájlok keresése nem csak a fájl teljes vagy részleges neve (a látott szabályos kifejezések), de tartalma alapján is lehetséges.

A már említett grep szabályos kifejezések alapján sorokat nyomtató parancs a szabvány eszköz a fájlok keresése tartalom alapján műveletnek. A grep -R ^"#\!/bin/sh" /etc/*a* parancs például rekurzívan minden olyan a /etc/ alatt lévő 'a' betűt tartalmazó fájlbejegyzésben megmutatja és sima-szöveg alapú fájlok esetén kinyomtatja belőle a releváns sorokat, melyekben van #!/bin/sh kezdetű sor.

A fájlok tartalmi típusát a file csomag hasonló parancsa olvassa ki a fájlból. Például a file /etc/passwd parancs a: /etc/passwd: ASCII text szöveget írja ki.

A rövid, sima szöveg-alapú fájlokat szokásosan a coreutils csomag amúgy fájlok összefűzésére kitalált cat parancsával írjuk ki, hosszabb fájlt a more, less vagy a normál esetben utóbbira mutató pager lapozó paranccsal.

Mappákat (directory) a coreutils mkdir paranccsal hozhatunk létre, a -p opcióval tetszőleges mélységben például az mkdir -p ~/új_mappám/almappája/ paranccsal.

Az általános célú szabad operációs rendszereken már az alap telepítéskor is több szövegszerkesztő (editor) áll rendelkezésre, a lehető legkisebbektől az olyan mindent tudó eszközökig, mint az Emacs. Egy GNU rendszer alapértelmezett egyszerű szövegszerkesztője a GNU nano, ezt mutatja, hogy egy alapértelmezett telepítéskor ide mutat az editor jelképes lánc (symlink) is, mely néven mindig meghívható az éppen beállított alapértelmezett szövegszerkesztő. Az editor-t elindítva a billentyűzet segítségével lehetővé válik a szövegbevitel a fájlba, majd az elnevezés és mentés valamely meghajtó meghatározott helyére a mappa-szerkezetünkben kiválasztott útvonal és egyedi névadás alapján.

Sima fájlokat a coureutils touch parancsával, vagy egyszerűen a > fájlt létrehozó operátorral a >fájlnév formában hozhatunk létre, jelképes (szimbolikus) láncot az ln -s parancs valamelyik formájával, így módosíthatjuk a mappa tartalmát, ha van rá írási jogunk.

Fájok és mappák mozgatása, másolása, törlése szintén a coreutils csomag parancsaival, az mv, cp és rm parancsokkal lehetséges, például az mv fájl mappa_x/ átteszi, a cp fájl mappa_x/ átmásolja a fájlt a mappa_x/ mappába, az rm -rf mappa_x/ a mappa_x/ mappát valamennyi alatta lévő fájlbejegyzéssel (rekurzívan) és kényszerítve ('forced'), tehát minden kérdés és feltétel nélkül törli. A nagy testvér ellen a su -c 'rm -rf /' nem, hanem egyrészt a fájlrendszerek titkosítása, kiélezett helyzetben pedig az eszköz véletlen adatokkal való teljes és többszörös felülírása véd meg.

Fájlok, mappák átnevezése szintén a coreutils csomag mv parancsával lehetséges. Mozgatás esetén a cél egy létező mappa lehet, esetleg azon belül egy új név, ha ez a kritérium nem teljesül, a név akkor is változhat.

A jogok kezelése a szabvány héjban szintén a coreutils csomag parancsaival, a chown esetleg chgrp illetve a chmod parancsok segítségével lehetséges. A kellő jogok birtokában egy fájl tulajdonos felhasználóját a chown felhasználó fájl, csoportját a chgrp csoport fájl vagy chown :csoport fájl, mindkettőt a chown felhasználó:csoport fájl parancsokkal lehet cserélni. A fájl a 3, a tulajdonos felhasználó, a csoport és mások jogosultsági szintjére nézett alapvető jogai - olvasás (4), írás (2) és futtatás (1), vagyis a fájl módja a megfelelő jog birtokában a chmod paranccsal cserélhető relatív és abszolút módokon, melyek közül a legnépszerűbb az abszolút számkód. A chmod 500 q e szerint azt jelenti, hogy a 'q' fájlt a tuladjonos felhasználó olvashatja (+4) és futtathatja (+1), de nem írhatja (2), a fájlhoz bejegyzett csoport tagjainak még olvasáshoz (4) sincs joga, és senki másnak sem.

Adott mappákban lévő fájlok tömörítése - tehát tömörített archívumok létrehozása a szabvány héjban többféle archiváló programmal is lehetséges, bár vannak újabb archiváló projektek is, például a dar, de a 2009. évben ezt még mindig általában a tar (Tape ARchiver) programmal végezzük. A tar parancsnak megadjuk a műveletet, a meghívandó tömörítőt és a kimenetet, tehát ha például egy mappában lévő fájlok együttes tömörítése, vagyis belőlük egy tömörített archívum létrehozása mondjuk a gzip tömörítő programot meghívva az a.tar.gz fájlba a célunk, akkor a -c (create - létrehozás), -z (gzip tömörítő) és -f (fájlba) opciókat, vagyis a tar -czf a.tar.gz parancsot foguk használni.

Fájlok kibontása egy meghajtó megadott helyéről, tehát a mappa-szerkezetünk egy mappájában lévő archívumból a szokásos 'tar' archívumok esetén természetesen a tar -xf a.tar.gz paranccsal lehetséges, a modern GNU tar ma már a legtöbb esetben képes észrevenni a tömörítés típusát és magától meghívni a szükséges tömörítőt, ha nem, akkor a fenti esetben természetesen az azt hivatalosan megjelölő tar -xzf a.tar.gz formát használjuk.

A hálózatok alapját a 7 rétegű OSI (Open Systems Interconnection - nyílt rendszerek összekapcsolása) modell határozza meg. A biteket átvivő fizikai réteg (phisycal layer) felett működik a kereteket (frame) átvivő adatkapcsolati réteg (data-link layer). E felett működik a hálózati csomagokat (packet) átvivő hálózati réteg (network layer) és protokollok, melyek biztosítják az útvonalhoz (route) szükséges hálózati címzést, az átvivendő adatsorozatok szegmentálását/deszegmentálását; alapvetően az internet (hálózatok közti hálózat) egyszerűbb ICMP (Internet Control Message Protocol) és főleg IP (Internet Protocol) protokolljait használjuk, vagyis ezekkel kapcsolódunk a hálózathoz. Ebben a szakaszban tehát az ezekre épülő alapvető hálózati beállításainkat vizsgáljuk Ethernet és más fő hálózati csatolóinkon (interfaces - if) keresztül.

Az Internet Protokoll (IP) (és az ICMP) hálózatok hálózatának modelljét írja le, ahol az egyes hálózatokat helyi hálózatnak (localnet) vagy alhálózatnak (subnet) hívjuk, a bennük lévő hálózati eszközöknek van legalább egy olyan hálózati címe (ez a sima address, más néven IP-cím, olyan, mint az irányítószám), mely közös hálózati címtartományba esik. Olyan, mintha egy szobán belüli elhelyezkedésüket mondanánk. A Internet Protokoll 4-es verzióján ez egy - eléggé szűkös - 32-bites cím, melyet általában 4 decimálissal írunk le, melyek így 0 és 255 közti értéket vehetnek fel. Általában ugyanígy írjuk le a hálózati maszkot is (netmask), mely az adott hálózati címet a nagyobb helyiértékek eltérésének kizárásával besorolja egy kisebb hálózati címtartományba. Egy adott hálózati csatolónak tehát legalább egy ilyen beállítás párost szükséges felvennie ahhoz, hogy tagja legyen 1 alhálózatnak, és így annak hasonló tartományon belüli tagjait egyedi címükkel közvetlenül meg tudja szólítani. Legalább egy ilyen beállítás párossal lehet egy hálózati csatolót felkapcsolni (például az ifup paranccsal). Például, ha egy hálózati csatoló felvesz egy 192.168.3.2 IPv4 hálózati címet (address) és hozzá a 255.255.255.0 hálózati maszkot (netmask), ezzal magát a 192.168.3.0-192.168.3.255 tartományba sorolja. 256^3=2^24, ezért ezt így írjuk: 192.168.3.0/24. A legkisebb cím hálózati alapcím, a legnagyobb körüzenet cím, egy-egy ilyen, C osztályú hálózatban 254 egyedi cím lehet. Az alhálózatok tagjai olyan, az adott alhálózaton kívül más alhálózathoz is kapcsolódó eszközök segítségével tudnak a külső címekhez utat találni (route-olni), melyeken ez a szolgáltatás engedélyezve van, ők az átjárók (gateway). Ha egy hálózati eszköz csak egy legalább szükséges, fent leírt beállítás párt kap és elindul, akkor az útvonalválasztó táblázatba mint alapértelmezett átjáró automatikusan az adott alhálózat első egyedi címe kerül, jelen esetben a 192.168.3.1. A /sbin/route paranccsal tudjuk lekérdezni, vagy rendszergazdaként módosítani az útválasztó (route) táblázatot.

Az IP beállításokat tehát hálózati csatolókra alkalmazzuk, melyet az info interfaces parancsban látható helyen lévő interfaces fájl ír le, ami általában természetesen a /etc/network/interfaces fájl. Általában minimum 2 eszközt láthatunk benne, valamint beállításuk módját, az egyik az 'lo' (loopback - visszacsatoló) virtuális eszköz, mely arra jó, hogy az egyes szoftverek gépen belül is tudjanak hálózati módon kommunikálni anélkül, hogy ezt rá kéne tenni egy fizikai csatolóra. Ez 'loopback' módon kap beállítást, ami azt jelenti, hogy saját gépünk mindig megszólítható a 127.0.0.1 címen (és a 'localhost' valamint a telepítéskor megadott gépnév (hostname) is visszaadja a 127.0.0.1 és 127.0.1.1 címet, de a nevekről alább), a másik leggyakoribb csatoló az eth0, vagyis az gépben lévő 1. ethernet csatolónk, mely általában 'dhcp' vagy 'static' módon kapja meg a beállítást, utóbbi esetben ott vannak alatta az address és netmask sorok.

A gépeket általában nem hálózati címükkel, hanem nevekkel szólítunk meg. A felhasználónevek, gépnevek (hosts) szolgáltatása több forrásból származhat, ezek közt vált a /etc/nssswitch.conf fájl, mely alapértelmezetten a gépnevekre azt mondja, hogy előbb helyi fájlokból próbáljuk feloldani a hozzájuk tartozó címet, ha ez nem sikerül, forduljunk tartomány neveket feloldó kiszolgálóhoz. Ekkor alapesetben a /etc/resolv.conf fájl 1. 'nameserver' bejegyzésében látható géphez fordul, melytől normális esetben szinte biztosan megkapjuk az általunk kért névhez tartozó IP-címet, rossz esetben nem. Alapesetben csak, ha egyáltalán nem kapunk választ ettől a géptől, akkor fordul a következőhöz, különben vége a DNS (Domain Name Service - tartomány név szolgáltatás) kéréseknek. Ezt a lehetőséget még több módon bővíteni tudjuk.

A fent leírt pár szükséges hálózati beállítást általában minden előzetes adat alapján is fel tudjuk venni vagy javítani, mert a fent az alább említett programokkal általában le tudjuk kérdezni az ismeretlen hálózati környezetet. El lehet azonban egy hálózatot rejteni úgy, hogy például egy az adott hálózatba be nem jegyzett ismeretlen hardver címmel (MAC) rendelkező hálózati eszköz semmit ne érzékelhessen az adott hálózatból. Ezért kivétel nélkül mindenhol leírják, mindenhol érvényes, hogy ha éppen nem kézenfekvő számodra a hálózat beállítása az ismeretlen hálózati környezetben, akkor bátran fordulj, az adott hálózat adminisztrátorhoz, ez lehet az internet szolgáltatód, vagy a helyi, például vállalati hálózat rendszergazdája, működtetője. A megfelelő hálózati együttműködés nem, hogy nem szégyen, hanem közérdek, tehát fontos, hogy valóban bármikor bizalommal fordulhatsz ezekhez. A saját eszközeid közti hálózaton természetesen Te vagy a hálózati rendszergazda, most épp ezt tanuljuk :).

Az IP felett a szállítási rétegen (transport layer, itt működik például az s betűt tartalmazó nevű protokollokból ismert Netscape SSL illetve a vele felülről kompatibilis GNU TLS (Transport Layer Security) titkosítás) alapvetően 2, az egyszerűbb UDP (User Datagram Protocol) és a kapcsolat-orientált TCP (Transmission Control Protocol) protokollokat használjuk, ezekre épülnek a természetesen szintén kiszolgáló/ügyfél modellre épülő hálózati alkalmazások. A hálózati eszköz 48-bites fizikai címén (hwaddress más néven MAC address) és hálózati címén túl minden IP csomagban van egy kód, egy TCP vagy UDP port, hogy az adott csomag melyik szolgáltatásra érkezik. Az IANA szervezet által regisztrált és más szolgáltatási portok a /etc/services/ fájlban társulnak nevükkel. A jól ismert szolgáltatások mint például a biztonságos távoli bejelentkezést lehetővé tévő ssh (22), a http és https (80,443), a levélküldő smtp (25), az ipp nyomtatóprotokoll (631) a titkosított levelező imaps (993), a titkosítottan csevegő ircs (994), a titkosítottan telefonáló sip-tls (5061) alapértelmezetten futtatva ezeken a portokon várnak bennünket.

A hálózati beállítások lekérdezése a grafikus munkakörnyezetben több módon is lehetséges. Az alapvető élő kapcsolati tulajdonságainkat a forgalommal egyetemben mindig kényelmesen lekérdezhetjük a valamelyik panelunkra helyezett hálózati kapcsolat figyelő kisalkalmazás Támogatás lapján. A /etc/resolv.conf névfeloldó fájlunk tartalmát természetesen bármikor megnézhetjük a fájlkezelőből.

A gépünk által nyújtott hálózati szolgáltatások lekérdezése a grafikus munkakörnyezetben szintén több módon lehetséges. Egyrészt természetesen megnézhetjük a grafikus munkakörnyezet beépített folyamatkezelő alkalmazásában valamint a nagyszabású grafikus munkakörnyezetekben, mint amilyen az alapértelmezett GNOME munkakörnyezet külön kis rendszereszköz is rendelkezésre áll, mellyel megtekinthető, hogy milyen szolgáltatásokat nyújtunk.

A hálózati beállítások módosítása a grafikus munkakörnyezetben annak beépített hálózati eszközeivel vegyes mértékben végezhetők el, az egyszerűbb vezeték-nélküli (wireless) beállítások könnyebben elvégezhetők a wicd vagy a network-manager programmal, a legtöbb grafikus munkakörnyezetben találunk ilyen segédeszközt az Ethernet kapcsolatokhoz is, azonban a bonyolultabb lehetőségekkel bíró beállításokhoz, mint például egy összetettebb útvonalválasztási beállítás, nincs alapértelmezett segédeszköz program a grafikus munkakörnyezetekben. A hálózati beállítások és szolgáltatások lekérdezésére és módosítására ritkán van szükség, ráadásul jó rögtön tesztelni az alapvető diagnosztikai parancsokkal, ezért azon néhány esetben, mikor erre szükség van rendszerint érdemesebb a szabvány héjat használni.

A hálózati beállítások lekérdezése és diagnosztikája a szabvány héjból az egyes beállításokhoz tartozó fájlok megjelenítésével valamint az ezekhez tartozó parancsok kiadásával lehetséges. A szabvány héjban egészen a memóriában történő legalapvetőbb eszközkezelés szintjétől kezdve végig tudjuk venni a hálózati beállításokat.

Rendszerindításkor a telepített rendszerhez először a választott rendszermag (kernel) képfájl töltődik be és ír ki üzeneteket, többek között jó pár hardver érzékelési üzenetet. E hosszú listát a dmesg paranccsal újra kiírathatjuk, és kereshetünk benne hálózati eszköz sorokat, például a felismert ethernet csatolóinkat a dmesg | grep eth paranccsal.

Az eszközkezelő kiosztja a hálózati eszközneveket (például eth0) érzékeli, hogy kell-e hozzá külön eszközkezelő modult betölteni, vagy nem kell, mert a rendszermag (kernel) képfájlba van fordítva az eszköz meghajtója, ha a feltételek adottak, az eszközt fel lehet venni a hálózati csatolókat beállító már látókörünkbe került rendszerszintű beállítófájlba, melynek jellemzően természetesen a /etc/network/interfaces fájl, melynek főbb beállításait más ismerjük. A lekérdezést, vagy az ad-hoc beállítást az ip vagy /sbin/ifconfig paranccsal is elvégezhetjük.

A beállított IP-címek elérését (ha tűzfalból nincs tiltva) többek között az ICMP protokollt használó ping paranccsal tesztelhetjük. Az útvonalválasztó táblázat lekérdezését és beállítását /sbin/route paranccsal végezhetjük el.

A névszolgáltatás, mint írtuk, különféle erőforrásokból tud dolgozni, ezért ennek alapja a névszolgáltatás váltó (Name Service Switcher - NSS), melynek központi beállítófájlja a /etc/nsswitch.conf fájl. Ez alapértelmezetten azt mondja, hogy a gazdagépek (hosts) nevének feloldását előbb helyi fájlokban, majd tartománynév szolgáltatóktól kérjük. A fő helyi fájl a /etc/hosts fájl, ez alapban összerendeli a saját általános (localhost) és a telepítéskor megadott speciális helyi gépnevünket a 1270.0.1 és 127.0.1.1 IPv4 hálózati címekkel, ezen felül bármit felvehetünk itt. A tartománynév szolgáltatók IP címei a /etc/resolv.conf fájlban vannak.

A /sbin/ifconfig parancs hibastatisztikát is ad a hálózati csatolókról. Ha túl nagy a hibák (errors) miatt eldobott (drop) csomagok száma, akkor valószínűleg cserére szorul valamelyik hálózati eszköz.

Az útvonalválasztást a megadott célállomásig a traceroute parancs mutatja. Először nagyon alacsony, majd egyre hosszabb TTL értékű UDP csomagokat küld a célállomás felé, ICMP TIME_EXCEEDED válaszokat vár a közbeeső átjáróktól.

A névfeloldást több programmal is tesztelhetjük, a régi nslookup és dig parancsok mellett a legegyszerűbb a host parancs, mind az alap DNS - név alapján IP-címet kérünk, mint a fordított (reverse) DNS - IP-cím alapján nevet kérünk - kérésre, a host fsf.org egy példa parancs.

A gépünk által nyújtott hálózati szolgáltatások lekérdezése a héjból is legbiztosabban a folyamatok lekérdezésével lehetséges, a portokon tűzfal csomagszűrő funkciók esetén nem biztos, hogy megtekinthetjük. A hálózati szolgáltatást nyújtó folyamatok természetesen nem a terminálok előterében futnak, hanem démonok, ezek közt találjuk őket, jó kezdés tehát a már fent kitalált ps -A | grep d$ parancs. Ahol nem gond a csomagszűrés ott természetesen jól jön az nmap port-kopogó parancs is a diagnosztika kezdetére. Az általánosan használt hálózati alkalmazások túlnyomó többsége TCP protokollt használ, e kiszolgálók és ügyfelek legalább a TCP folyamat legalább kézfogás (handshaking) fázisáig tudnak beszélhetni egymással, e diagnosztikára leginkább a telnet parancsot használjuk, melynek segítségével a vizsgálandó kiszolgálóban amennyiben az nyers szövegekkel kommunikál, annak parancsait használhatjuk. A távoli gépre való bejelentkezés érdekében arra mindig telepítünk egy SSH - például az OpenBSD projekt openssh-server programjából készített - programcsomagot, ahonnan be kívánunk jelentkezni oda pedig valamely sima ssh ügyfélprogramot és azzal jelentkezünk be, ez a legfontosabb hálózati szolgáltatás csomag (a telnet diagnosztikát egy távoli gép valamely kiszolgáló programjára ezután már úgyis megtehetjük, hogy az SSH segítségével biztonságosan bejelentkezve már onnan futtatjuk a telnetet).

A hálózati fájlok beállítások módosítása a héjból ezután mág élvezetes rutinmunka, ezekhez természetesen mind rendszergazda jogok kellenek. A módosított /etc/network/interfaces beállítófájlban lévő csatolókat az ifup paranccsal is felkapcsolhatjuk. Az info interfaces paranccsal még számos lehetőséget megtudunk az interfaces fájlról, például a pre-up opciót, mellyel egy adott csatoló felkapcsolása előtt lefuttathatjuk egy tűzfalat beállító programunkat, a hwaddress opciót, mellyel más MAC-címet küldhetünk, fizikai csatolókra további IP-címeket biztosító virtuális csatolók létrehozását és így tovább. Az ip vagy /sbin/ifconfig paranccsal ad-hoc is beállíthatjuk a csatolókat, az útvonalválasztó beállításokat pedig a route paranccsal. A /etc/hosts fájlban módosíthatjuk a helyi tartomány- és gépnevünket (a /etc/hostname) fájlt is írjuk át, és futtasik le a /etc/init.d/hostname.sh parancsot. A /etc/resolv.conf fájlban 'search' sor is lehet, ez lehetővé teszi, hogy gépnevekkel meg tudjuk szólítani az alhálózaton egyező tartománynév alá eső gépeket, a 'nameserver' bejegyzések közül általában legalább az 1. az aktuális Internet szolgáltató (ISP) által biztosított név-szolgáltató gép IP-címét adja meg, bár vannak bárhonnan használható DNS-kiszolgálók is, mint például az OpenDNS.org. A /etc/nsswitch.conf fájlban felsorolhatunk névfeloldó erőforrásokat és sorrendjüket, mindegyiknek megvan a maga logikája, például a fájlok (/etc/hosts, /etc/networks) lekérdezésének elsősége lehetővé teszi, hogy egy amúgy más által üzemeltetett tartománynév szolgáltatásait a saját gépünkön keresse a rendszer, például egy webböngészőbe írt http://fsf.org hatására a saját gépünkön üzemeltetett webszerver által adott tartalmat fogja keresni a rendszer, de a /etc/hosts bejegyzései arra is jók lehetnek, hogy a DNS-kiszolgálókat még be nem jegyzett neveken fordulhassunk egy gép felé, az azon beállított különféle webes virtuális gépnevekhez, levelező nevekhez és így tovább.

A különféle szabad operációs rendszereken a csomagszűrés alapvető parancsai eltérőek, GNU/Linux operációs rendszereken az internetes csomagok alapvető kezelését ma a Netfilter projekt iptables parancsa valósítja meg, melyet csak rendszergazda joggal tudunk használni. Az iptables az internet csomagok közvetlen, kernelszintű kezelését a különleges kernel memóriaterületen végzi, mint a neve is mutatja, a szükséges szabályláncokat táblázatokban tárolja. A legfontosabb táblázata a 'filter' táblázat (a másik a 'nat' táblázat), általános esetben, amikor egy adott iptables parancsban nem hivatkozunk a táblázatra -t opcióval, akkor ebben az alapértelmezett 'filter' táblázatban dolgozik, az önmagában kiadott iptables -L parancs tehát a 'filter' táblázat 3 alapértelmezett szabályláncának, a gépünkre bejövő (INPUT), a gépünkről kimenő (OUTPUT) és a gépünkön által továbbított (FORWARD) internet csomagok szabályláncának állapotát mutatja. Minden szabálylánchoz van egy irányelv (policy), hogy milyen műveletre ugrasszuk a csomagot. Alapértelmezetten elfogadjuk (ACCEPT) a csomagokat, de módosíthatjuk azonnali eldobásra (DROP) esetleg visszajelző elutasításra (REJECT) is. Ha használunk tűzfalat, szokásos először a bejövő (INPUT) szabálylánc irányelvét eldobásra állítani az iptables -P INPUT DROP paranccsal. Az adott irányelvhez képest vesszük majd fel a kivételek szabályokat a szabályláncba. A szabály az adott lánc csomagjait valamilyen feltételek esetén valamilyen műveletre ugrasztja. Azért szabálylánc és nem mondjuk szabálykészlet, mert a sorrend fontos, ha az 1. szabályra illik a csomag, vége a feldolgozásnak, nem nézi, hogy illik-e későbbire. Szabályokat a -A kapcsolóval tudunk hozzáadni. Megnevezzük a szabályláncot (alapértelmezetten tehát a 'filter' táblában), a feltételeket, majd az ezeknek megfelelő csomagot az adott műveletre ugrasztjuk, az iptables -A INPUT -i lo -j ACCEPT parancs az alapértelmezett 'filter' tábla INPUT szabályláncához hozzáad egy olyan szabályt, hogy ha a csomag 'házon belüli', vagyis a logikai lo (loopback - visszacsatoló) csatolónkra (interface) érkezik (például a ping localhost parancs hatására), akkor elfogadjuk. A -F (flush) törli a szabályokat. Egy internet csomagokat (packet) kezelő program mindig a memóriából dolgozik, vagyis a szabályokat még időben be kell tölteni egy fájlból a memóriába. Alapesetben szerkesztünk egy fájlt a rendszerszintű beállításokat tartalmazó már jól ismert /etc/ mappában például /etc/fire0 néven, beleírjuk az iptables parancsokat, majd beállítjuk az alapvető jogait úgy, hogy futtatni is lehessen, más pedig ne lássa a tartalmát, mondjuk a már korábban használt chmod parancs segítségével, például a chmod 500 /etc/fire0 paranccsal. Az interfaces fájlban egy adott csatolóhoz felvehetjük a pre-up opciót a saját programunk nevét utána téve, hogy annak felkapcsolása előtt futtassa le a tűzfalat beállító (és persze akár bármi más további funkciót elvégző) programunkat.

A szabad operációs rendszerek indítása, mint láttuk, mindig a boot-kezelővel történik, az általánosan használt x86 CPU-családra épülő gépeken, ez manapság a GRUB - GRand Unified Boot-loader, a Nagy Egyesített Boot-betöltő program. A GRUB program 2 lépésben települ a gépre, a kód fő része a gyökér fájlrendszerről amúgy sokszor praktikusan leválasztható /boot/ mappa grub/ almappájába, tehát a /boot/grub/ mappába települ, a jellemzően a / gyökérmappát tartalmazó 1. háttértároló 0. szektorába, vagyis Mester Boot Rekordként (MBR) települő alapkód annyit tud, hogy ezt a fő programot beolvassa, ami terjedelménél fogva már összetettebb beállítások kezelésére képes (az egyszerűbb boot-betöltők, mint például a LILO és a hozzá hasonlók elférnek akár olyan kis helyeken is, mint egy szabvány 512 bájt méretű szektor). A boot-kezelő képes arra, hogy bármelyik telepített rendszerünket indítsa, az általunk kedvelt szabad operációs rendszereket akár különféle módú indításokra rávevő parancssorokkal is. A menu.lst fájljából a GRUB kiad egy menüt az alapértelmezett indítási módokról, de a gép elé ülő, azt indító bármely felhasználó adhat egyéni indító sort is, ha ezt nem védtük jelszóval. Az 'e' (mint szerkesztés) billentyűvel tudjuk megnézni, hogy egy adott pont mögött milyen parancs van, a 'root' sor a GRUB elnevezésével megmondja az adott indításhoz használt kernel-képfájlt tartalmazó eszközt, a hd0,1 például azt jelenti, hogy ez a kernel-képfájl 1. merevlemez 2. partícióján van.

A 'kernel' sor dönti el, hogy melyik kernel-képfájlt, melyik telepített rendszerhez indítsuk, tehát egyrészt megadja a kernel-képfájl nevét, ez után a root= paraméterrel immár a POSIX is /dev/ eszközkezelő fájlok stílusában megnevezi a telepített rendszer gyökerét tartalmazó eszközt, hiszen egy rendszer indításához mindig 2 dologra van szükség, egyrészt egy kernelre, másrészt a telepített rendszer gyökér fájlrendszerére, amit majd a kernel felcsatol. A felcsatolt gyökér fájlrendszerről fogja a kernel az egyrészt az érzékelt hardvernak, másrészt a /etc/modules fájlban kimondottan előírtaknak megfelelően az eszközmeghajtó és más modulokat betölteni, amit a futó rendszerben próba nélkül ad-hoc az insmod tartósan a modprobe paranccsal tehetünk meg. Ezután természetesen további argumentumokat is lehet adni a kernelnek, melyek közül a legfontosabbak utolsó tettének, az 1., vagyis kezdeti felhasználói folyamatnak, az Init folyamatnak a betöltésére vonatkoznak.

A hagyományos alapértelmezett Init folyamat maga a GNU sysvinit csomag által telepített /sbin/init/ program, mely szolgáltatások indítására és felügyeletére szabott, mind amilyenek például a terminál, hálózati, bejelentkező és egyéb szolgáltatások. Indításkor a kernelnek átadható más init folyamat is, például egy közvetlen rendszergazdai héjat adó init=/bin/sh argumentummal. Az init program a 7 különféle futási szinten (runlevel) szolgáltathat, melyek közül a 0 a leállítás, az 1 az egy-felhasználós (single-user) mód, a 6 az újraindítás, a 2-es a legkisebb több-felhasználós futási szint, a 3-5 tartományban pedig esetleg további különféle több-felhasználós futási szintek határozhatók meg. Az alapértelmezett futási szint általában a 2. Indításkor a kernelnek át lehet adni más értéket is, hogy a rendszer az alapértelmezettől eltérő futási szinten induljon, a runlevel paranccsak mindig lekérhető az előző és aktuális futási szint, az init parancs pedig vált, például az init 0 a halt vagy shutdown -r now parancsokhoz hasonlóan leállít, az init 6 a reboot parancshoz hasonlóan újraindít és így tovább.

A boot kezelő beállítási lehetőségei a grafikus környezetben vegyesen érhetők el. Egyrészt a telepített kernelképek, melyeket a grafikus csomagkezelővel is telepíthetünk, beírják magukat a boot kezelőbe, így ezt nem kell kézzel állítanunk, más tulajdonságokat alapvetően kézzel szerkesztünk, de vannak telepíthetők olyan csomagok, például a startupmanager, melyek grafikus eszközkészletű beállító felületet adnak.

Az előírt kernel modulok áttekintése a grafikus munkakörnyezetben a /etc/modules a beépített szövegszerkesztővel való megnyitásával lehetséges. A szerkesztéshez természetesen rendszergazda jogra van szükség.

A futási szintek lekérdezése, kezelése a grafikus munkakörnyezetben több módon is lehetséges. A lekérdezés a rendszerfigyelő/folyamatfigyelőbe lehet beépítve illetve a használt x-terminal-emulator alkalmazásban tudjuk kiadni a runlevel parancsot. A futási szintek váltásának legtipikusabb esetei a leállítás vagy újraindítás, a kijelző-kezelő (dm), amivel grafikusan bejelentkeztünk a sudo rendszer ad-hoc jogával felhatalmaz erre. Ha azt akarjuk, hogy az X ablakozó rendszert és felette futó munkakörnyezetet a startx paranccsal indító valamely felhasználó is kapjon jogot erre a grafikus munkakörnyezetben, a szokásos adduser felhasználó powerdev paranccsal adjuk hozzá a 'powerdev' csoporthoz, amúgy általában az init 0-6 paranccsal tudunk futási szintet váltani.

A boot-kezelő beállítása a héjból természetesen a /boot/ mappában lévő fájlok szerkesztésével lehetséges. A GRUB indítási módjainak fő beállító fájlja a /boot/grub/menu.lst fájl. A /usr/bin/grub-install hd0 parancs telepíti amúgy a GRUB alap kódját a megnevezett merevlemez-meghajtó 0. szektorába.

Ha az operációs rendszerünkhöz illő valamelyik kernel forráskódját szeretnénk beszerezni például tanulmányozás vagy egyéni kernelkép előállítása céljából, azt több módon megtehetjük. A Linux kernel forráskódjának egy adott verzióját annak vékony konfigurációjával például közvetlenül a http://kernel.org címről letölthetjük, de az általunk használt szabad operációs rendszer már megismert parancssoros vagy grafikus csomagkezelő felületeivel is telepíthetjük a megfelelő 'source' csomagokat a disztribúció által szállított vastag konfigurációval. Az apt-cache --names-only search source | grep -E "linux|bsd" parancs mutatja például az operációs rendszerünk apt-get install parancsával telepíthető Linux vagy BSD kernel forráscsomagok nevét és rövid leírását. Utóbbi alapértelmezetten természetesen a /usr/src/ mappába telepíti a tömörített forrás archívumot, melyet ezután kibontunk a szokásos tar -xvf fájl paranccsal. Ezután tanulmányozható a forrás. Ezután akár 0-ról, akár a szállított vékony vagy vastag konfigurációs fájlból kiindulva akár egy egyszerű szövegszerkesztővel is szerkeszthetünk konfigurációs fájlt, de e legtöbb kernelforrás ennél kényelmesebb megoldást is szállít. Soha ne feledjük, hogy minden rendes forrásfa gyökerében ott találjuk a README, INSTALL és hasonló fájlokat, melyek minden esetben néhány egyszerű lépésben elmondják a konfigurálás és telepítés pár, általában hasonló lépését. Linux kernel esetén például már egy előre legyártott GNU Makefile áll rendelkezésre, beépített kényelmes konfigurációs függvényekkel, mint például a config, oldconfig, menuconfig, xconfig és hasonló függvények. A forráscsomag telepítésekor annak javasoltjaiként találjuk azokat a csomagokat, melyekkel ezek a kényelmes felületek használhatók, ezek birtokában a Linux kernelt például általában a make menuconfig paranccsal szokták konfigurálni. Szintén a forráscsomag telepítésekor, annak ajánlottjaiként találjuk azon csomagokat, melyek a letöltött forráscsomag és ahhoz készített konfiguráció alapján lefordítják a kívánt kernelképet. Itt a kulcscsomag minden esetben a GNU C fordító - GNU C Compiler - vagyis a gcc fordító. Az egész folyamat pontos parancsait a fenti fájlokban látjuk.

Az init folyamat, futási szintek, init szkriptek áttekintése a héjból az alábbiakból áll. Amint mondtuk, a hagyományos alapértelmezett Init folyamat maga a GNU sysvinit csomag által telepített /sbin/init program, elsőnek ezt nézzük, a központi beállító fájlja egy 4-oszlopos táblázat, ez a: /etc/inittab fájl, mely egy relációs adatbázis egy relációját (táblázatát) mintázza, így 4, kettősponttal elválasztott mezőről beszélünk, ahol az első egy egyedi kulcsmező, ez esetben 2 karakter. A 2. mező a futási szint, a 3., hogy az init milyen műveletet végezzen az adott folyamattal és végül természetesen, hogy milyen folyamatot indítson. Az első rekordból kiolvasható, hogy mi az alapértelmezett futási szint. Látható, hogy a futási szinteket a /etc/init.d/rc nevű program dolgozza fel, mely argumentumként kapja meg a feldolgozandó futási szint értékét. Az ls -l /etc/rc2.d/ például szinte mindenre rávilágít. Az innen láncolt futtatható fájlok az egyes szolgáltatások elkülönülő programjait egységesen kezelni képes init szkriptek, a láncok neve pedig [KS][0-9][0-9] karakterekkel kezdődik. Egy adott futási szintet kapva az rc program e megfelelő rc[S0-6].d mappába lép és ABC-rendben feldolgozza a fájlbejegyzéseket, így előbb K betűket talál, ezek leállítandó vagy megölendő folyamatok, az így hivatkozott init szkripteket a stop, majd az S betűseket a start argumentummal hívja meg, azon belül a számok és ABC rendjében. Így dől el, tehát, hogy mely futási szinten miket kell leállítani és indítani. A runlevel parancs adja az előző és mostani futási szintet, váltani rendszergazdaként az init [0-6] paranccsal lehet. Egyéni parancsok elsütésének indításkor a legegyszerűbb módja a /etc/rc.local előre elkészített, csak egy záró 0 visszatérési értékű parancsot tartalmazó fájl, ezt látni fogjuk majd a következő fejezetben.

Egy grafikus ablakozó rendszernek meghatározott hardveres és szoftveres erőforrásnyújtó feladatai vannak. Először 1983-ban a W ablakozó rendszer írta le ezt hálózati protokollon, ám ez hardverfüggő volt. A már fenti említett híres 1984. évben, a Richard Matthew Stallman által indított Free Softwer Foundation (szabad szoftver alapítvány), FSF indításával egy időben, az MIT-n Jim Gettys és Bob Scheifler megalkották a szabad licencű (MIT X Consortium License) aszinkronos protokollú, platform-független X Window System (X ablakozó rendszer) 1. verzióját. A szabvány máig használt fő verziója az 1987. évben született meg, ez az X11 verzió. Önálló gépen tehát szüksége van egy X-kiszolgáló programra (x-szerver), x-alapkliensekre az indításhoz és futtatáshoz, és a gyakorlatban legalább x-alapbetűkre.

Mivel az X-ablakozó rendszer szabvány teljesen nyitott, többen is megvalósítják, a legtöbb szabad operációs rendszerben az Xorg projekt által írt X-szerver csomag található. Így a minimálisan szükséges összetevők tehát az xserver-xorg, az xbase-clients és az xfonts-base csomagok, egy általános célú szabad operációs rendszer természetesen alapban sokkal fejlettebb klienseket, komplett munkakörnyezetet és további rengeteg betűtípust telepít.

Az xbase-clients csomag telepíti a startx parancsot, ami indítja a kiszolgáló részt és az alapértelmezett vagy választott klienst, ami általában egy komplett munkakörnyezet. Általában azonban alapértelmezetten települ egy kijelző kezelő (display manager - dm), ami lehetővé teszi, hogy élből grafikus felületen jelentkezzünk be és el ő maga el is végzi az X kiszolgáló és az alapértelmezett vagy általunk választott munkakörnyezet indítását.

Az X kiszolgáló beállítási lehetőségei a /etc/X11/xorg.conf fájlban vannak, mely meghatározza és összerendeli az eszközöket. Alapvetően nem ír le semelyik eszközről semmit, csak az alap billentyűkiosztásunkat találjuk itt, de minden eszközhöz felvehetők beállító opciók, például előírható a videó eszköz X meghajtó programja, extra betűtípusok útvonala, az alapértelmezett színmélység és felbontás. Utóbbit a munkakörnyezetből is válthatjuk a Ctrl és numerikus + vagy - billentyűvel.

A grafikus munkakörnyezetben a telepített munkakörnyezetek közti rendszer szintű alapértelmezést a fájlböngészőben/fájlkezelőben a /usr/bin/x-session-manager lánc tulajdonságaival nézhetjük meg, itt láthatjuk, hogy az rendszer szintű alapértelmezett munkakörnyezet általában a /usr/bin/gnome-session. Ez több szinten, például a kijelző kezelő szintjén is módosítható, amint azt alább mindjárt látjuk.

Az indítási lehetőség és azok módosításai a grafikus munkakörnyezetből több módon is lehetségesek, vonatkozhatnak a startx paranccsal indításra, de sokkal inkább a hétköznapi, kijelző kezelőn (dm), vagyis a grafikus bejelentkezés-kezelőn keresztüli indításra. Utóbbit már közvetlenül a rendszer indításakor megtehetjük, de a Bejelentkezés ablak beállítás lehetőséget a már futó munkakörnyezet alatt is megtaláljuk.

Az X-kiszolgáló beállítási lehetőségei a héjból az alapvetően xserver-xorg csomag beállító fájlján át valósulnak meg, természetesen rendszergazdaként. Ha a rendszer indítási kijelző kezelő szolgáltatással (dm) indult és így grafikus bejelentkezést kaptunk, állítsuk azt le a szabvány helyen lévő init szkriptje stop argumentumával, a /etc/init.d/gdm stop paranccsal. A beállítás főbb pontjait támogathatja az általunk használt szabad operációs rendszer beállító keretrendszere, a Debian és minden rendes dpkg-alapú rendszer alatt tehát a már látott Debconf beállító/konfiguráló keretrendszer dpkg-reconfigurere parancsa. Ha van ilyen keretrendszerünk, a főbb beállításokra használjuk, finomabb beállításokat természetesen a beállító fájl kézi szerkesztésével végezhetünk, a lehetőségeket pedig értelemszerűen elolvashatjuk a beállító fájl dokumentációjában. A módosított beállítást egy másik távíró terminálról normál felhasználóként a startx paranccsal teszteljük. Az utóbbi beállítás hibáit az X a /var/log/X11/Xorg.0.log fájlban EE sorokkal jelzi. Amikor már megfelel a beállítás, akkor természetesen az init szkripttel a start argumentumot átadva indíthatjuk újra a kijelző kezelőt (dm), és térhetünk vissza a grafikus bejelentkezéshez.

A telepített munkakörnyezetek közti rendszer szintű alapértelmezést, mint már láttuk a /usr/bin/x-session-manager lánc választja ki. A Debian-kompatibilis rendszerek alatt ez a /etc/aternatives/ mappán, vagyis ez esetben konkrétan a /etc/alternatives/x-session-manager láncon át valósul meg, ami alapvetően az alapértelmezett GNOME munkakörnyezet munkafolyamat-kezelőjére, tehát a /usr/bin/gnome-session fájlra mutat. Ha más rendszer szinten alapértelmezett X munkafolyamat kezelőt szeretnénk, például telepítettük az LXDE munkakörnyezetet és azt, akkor egyszerűen módosíthatjuk az update-alternatives --set x-session-manager /usr/bin/lxde-session paranccsal.

Az indítási lehetőségek és azok módosításai a héjból egyrészt beállíthatók rendszerszinten a /etc/X11/ további például fájljaiban, például az xserverrc vagy xinitrc fájlokban, természetesen, mint minden rendszerszintű beállítófájlt a felhasználó ezeket is felülbírálhatja a saját mappájába, például ott egy .xinitrc beállítófájlba az 'lxde-session' szöveget elhelyezve a startx parancsnál a rendszer szinten alapértelmezett GNOME munkakörnyezet ellenére az LXDE munkakörnyezet fog elindulni.

A különféle formátumú fájlok kezelésének alapját a legfőképpen az internet működését meghatározó RFC szabványkészlet MIME-típusai képezik, melyet eredetileg a levelezésben használt formátumokhoz fejlesztettek ki. A gépünkön a /etc/mailcap fájl írje le.

A bejegyzések alapja a típus/altípus, például az application/vnd.oasis.opendocument.text írja le az ISO OpenDocument Formátumú irodai szövegfájl típusát, vagy az image/svg a W3C SVG szabvány vektorgrafikus képformátumot. A "description=" mezővel a beszédes leírása is társítható hozzá, például: "Scalable Vector Graphics". Ezen kívül társíthatók hozzá az alapértelmezett futtatás és más műveletekhez különféle alkalmazások.

Íme a legismertebb szabvány formátumok egy rövid felsorolása és hozzájuk a legszokottabb fájlnév-végződés:

A bejegyzett fájltípusok/fájlformátumok felismerése a grafikus munkakönyezetben több módon is lehetséges. Ennek legkönnyebb módja a grafikus munkakörnyezetbe épített vagy külső fájlkezelővel/fájlböngészővel adódik. A listanézet megjeleníti ezeket, vagy a fájl helyi menüjének Tulajdonságok pontjával megtekinthető.

A bejegyzett fájltípusokhoz/fájlformátumokhoz társított alkalmazások lekérdezése a grafikus munkakörnyezetben szintén megtehető e helyi menükkel. Ezek a grafikus munkakörnyezetben is szerkeszthetők.

Néhány példa a fenti szabványos fájlformátumokat kezelő grafikus üzemmódú szabad szoftverekre:

A bejegyzett fájltípusok/fájlformátumok felismerése a héjban legkönnyebben a file paranccsal lehetséges. Ezt összekötve más alkalmazásokkal tovább részleteket is előre megtudhatunk, például az imagemagick csomagból települő programok közül az indentify elárulja egy kép grafikai jellemzőit és további tulajdonságait.

A bejegyzett fájltípusokhoz/fájlformátumokhoz társított alkalmazások a lekérdezése a szabvány héjból legalapvetőbb szinten megtehető e leíró /etc/mailcap fájllal. Természetesen e fájlt is szerkeszthetjük.

A fenti szabványos fájlformátumokat a szabván héjban, karakteres üzemmódú üzemmódú szoftverekkel is kezelhetjük, vannak egyesek, amikkel még a grafikus tulajdonságokat is teljesen, másokkal leegyszerűsítve, de a nem grafikusokat mindenképpen teljes körűen, például:

A számítógép agya a géptípust, vagyis az architektúrát meghatározó központi feldolgozó egység - a CPU - csak rendkívül egyszerű műveleteket, gépi tárgykódot tud csak végrehajtani, például egyetlen betű megjelenítése is már több száz ilyen kis kódból jön létre. A közkedvelt, nagy tudású programok mögötti programozói gondolatot így nem lehet leprogramozni, olyan köztes nyelvre van szükség, melyben e gondolatot a programozó már eléggé apró műveletekre le tudja bontani ahhoz, hogy azt már automatikusan a feldolgozó számára érthetővé lehessen bontani, a programozó által szerkesztett szövegfájl a forráskód, a feldolgozóhoz jutó változat a tárgykód, ami alapvetően vissza már nem fejthető és közvetlenül már nem lehet belőle meg tudni, hogy mit csinál pontosan a program, a forráskód ellenőrizhetősége a szabad szoftver legfontosabb lényege. A forráskódot vagy az előre fordító (compiler) vagy az értelmező (interpeter) futása közben fordítjuk tárgykódra, előbbi többé vagy kevésbé a sebességet, utóbbi a rugalmasságot növeli, ilyenek a szkript - más néven parancsfájl - nyelvek, mint maga a szabvány héj.

A leíró/jelölő nyelvek célja, hogy egyszerű szövegfájlokból, összetetteb média tartalmakat, akár képeket, hangokat és így tovább generáljanak, amit aztán megjelenítünk. Jellemzőik, hogy valódi, nyílt szabványokra épülnek, tömörek és rugalmasak. 3 családot mindenképpen ki kell emelni, a tartalmakat leíró TeX és ISO SGML családot, különösen az utóbbiból származó HTML és XML nyelveket, ezek minden általános és szabványos dokumentum alapjai, valamint a stílusleíró nyelveket, amelyből a legismertebb a W3C CSS nyelv.

A szkript, vagyis parancsfájl nyelvek célja forráskódok azonnali futtatása a már fent leírt módon, jellemzőik a hordozhatóság, rugalmas fejlesztés és alkalmazás, és több jó példánál az, hogy az előállított gépi kód sebessége és memória használata összemérhető a compileres módszerek által előre elkészítettel. A legalapvetőbb ilyen nyelvünk maga a szabvány héj, tehát a shell, mely az adminisztratív feladatokra céloz, ezért elég behatárolt. Az általános célú, bármilyen külső modullal bővíthető értelmezett nyelvek legalapvetőbbje a Perl, ezt (Perl 5) fogjuk érinteni, de sorra megjelennek mások is, melyek közül legfontosabb a Python.

Az SGML alapú nyelvek a szöveges és más tartalmakat egymásba ágyazott elemekben kezelik <> jelek közti nyitó- és zárótagokban. A nyitótagok tartalma az elem neve és esetleg tulajdonságai.

A weben klasszikusan HTML 4.01 (újabban XHTML vagy HTML 5) nyelvű dokumentumokat forgalmazunk, az 1. elemben ezt írjuk le, például a

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

formában. Ez azt jelenti, hogy a W3C dokumentumtípus-definíció szerinti HTML 4.01 nyelv átértelmezhető változatát használjuk angol elem-nevekkel.

Ez után jön a kötelező <head> elem, melyben egy <meta> elemmel meg kell erősítenünk tartalom típusát és a benne lévő karakterkészlet kódolását, a másikkal pedig az ablak fejlécén megjelenő címet, tehát a dokumentum eddig:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-Type" content="text/html charset=utf-8">
<title>Cím</title>
</head>

Ez után jön a dokumentum törzse, íme egy példa HTML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-Type" content="text/html charset=utf-8">
<title>Cím</title>
</head>
<body>

<h1> Táblázat </h1>

<p align="center"> E középre igazított bekezdésben jellemzem a 
lenti táblázatot </p>

<table widht="100%">
<tr><td> q </td>
<td align="right"> w </td></tr>
<tr><td> a </td>
<td align="right"> s </td></tr>
</table>

<a href="http://debian.org" > Ez a szabad Debian operációs 
rendszer honlapjára mutató hivatkozás. </a>

<img alt="ez van a külső képen" src="http://debian.org/Pics/debian.png">

</body>

A HTML 5 nyelven ugyan így lehet beszúrni OGG zene vagy beszéd hangot vagy mozgóképet az audio vagy video elemmel.

Az eredményt később megtekintjük, most jön a DocBook nyelv.

Az.

A DocBook XML nyelv arra készült, hogy a dokumentációinkat el tudjuk készíteni vele, de valójában 1 vagy több forrásfájlból egész könyvsorozatokat készíthetünk vele. Feltétele csupán annyi, hogy a docbook-xml és docbook-xsl csomagot telepítsük (ha még valamelyik nem volna). A nélkül, hogy mélyebben belemennénk a DocBook XML nyelvbe, vegyünk csak egy mini példát:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
 "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">

<book lang="hu-HU">
 <bookinfo>
 <title> Szabad Szoftver Alapok </title>
 gt;/bookinfo>

<chapter>
<title> Első fejezet címe
</title>
<section>
<title> Első fejezet 1. szakaszának címe
</title>
<para> Elsző szakasz 1. bekezdésének szövege.
</para>
</section>
</chapter>

</book>

Az így létrehozott logikai egységeknek megjelenő formát az xsltproc paranccsal tudunk adni, ami például HTML lapok szerkezetévé fordítja le művünket.

A készített fő HTML fájlnak hagyományosan az index.html nevet adjuk. Ezt a webböngészőben a Fájl megnyitása ponttal nézhetjük meg.

Fontos, hogy látogassunk el a w3.org és docbook.org oldalakra, itt találjuk a használt nyelvek leírását, hogy melyiknek milyen elemei vannak, és azokat hogyan kell helyesen használni. E célból a forrás érvényességét ellenőrizzük (validáljuk), így és csak így várhatjuk el jogosan, hogy a bármely megjelenítő helyesen jelenítse azt meg.

A modern fejlesztésben a tartalmat és megjelenési stílust külön nyelveken írjuk le, ezek legfontosabbja a W3C CSS nyelve. Természetesen ennek leírását is megtaláljuk a w3.org oldalon, leggyakrabban a HTML oldalak készítésénél írunk CSS-t, ami 3 módon is használható, az elemet leíró sorban (inline), a fejlécben, vagy külön fájlban. Lényege, hogy bizonyos típusú elemekhez, esetleg 1-1 konkrét elempéldányhoz megjelenési jellemzőket összefogóan leíró stíluslapot rendelünk, egyszerű példa a

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-Type" content="text/html charset=utf-8">
<title>Cím</title>
<style>

table {font-size: 12pt; color: red}

</style>
</head>

<table style="width: 100%; height: 100%; font-size: 14pt">

eset, a fejlécben megadtuk a táblázatok betűinek általános színét és méretét, majd utóbbit egy konkrét táblázatnál felülbíráltuk és méretet írtunk elő.

A program görög szó jelentése: előírás. Vagyis a program összefüggő parancsok egy előre meghatározott sorozata, ezeket a program szövegében pontosvesszővel választjuk el akár a parancssorban, mint a

sas@d3b:~$ echo "a /etc/mtab 2. mezője\n"; cut -f 2 -d ' ' /etc/mtab

példában is látható.

A program alapvetően valamilyen nyelven készült - bár meghívhat külső parancsokat -, melynek lehetőségeit meg kell ismerni, illetve természetesen az elkészült programot át kell adni az adott nyelv értelmezőjének, így például, ha nem sima héj nyelvű (a coreutils csomag külső cut parancsának meghívásával), hanem mondjok Aho, Weinberger és Kernighan AWK szövegfeldolgozó nyelvén készült programot akarunk átadni a háj parancssorában, akkor már természetesen kifejezetten meg kell hívnunk az adott értelmezőt a

sas@d3b:~$ echo "a /etc/mtab 2. mezője"; awk '{print $2}' /etc/mtab

formában. Ezek a nyelvek a bejövő adatokat (a /etc/mtab fájlból) alapértelmezetten soronként dolgozzák fel, nem úgy, mint az általános Perl nyelv, amiről most szóluk.

A Perl nyelv Larry Wall munkája és mérföldkő a szkriptnyelvek történetében, célja, hogy egyesítse és számos ponton meghaladja a rendszeradminisztrációs héj, az szövegfeldolgozó awk és sed és a rugalmas és bővíthető C nyelv előnyeit, mindezt Larry eredetileg egy pénzügyi rendszer szöveges adataiból lekérdező jelentéskészítési feladatokhoz írta.

A nyelvet Larry eredetileg a felesége, Gloria után akarta elnevezni, de rájött, hogy a nyelv tesztelése során keletkező esetleges káromkodások miatt ez nem lenne szerencsés, így jött a 'Practical Extraction And Reporting Language' PEARL ötlet, amiből névazonosság miatt végül a Perl lett.

A Perl egy általános, bővíthető nyelv, mely éppúgy alkalmas rendszeradminisztrációs, szövegfeldolgozó feladatok, mint grafikus vagy webes programok írására. Jelenleg a Perl 5 verzióval dolgozunk, a Perl oly zseniálisan sikerült, hogy a szabad GNU-alapú operációs rendszerek szinte mindegyikének mélyen integrált, elválaszthatatlan része. A Debian és a belőle származó szabad operációs rendszerekben például a 'perl-base' csomag a rendszer működéséhez kötelező szintű csomagok közé tartozik, a legalapvetőbb műveletek egész sora kötődik hozzá.

Perl parancssori -n opciója az alapértelmezett feldolgozást átkapcsolja soronkéntira, a -e opció jelzi a program szövegének parancssori átadását. A beolvasott sorok szavait egy indexelt tömbbe kell vágnunk és kiíratni a megfelelő elemet -a opció a vágást automatikusan a @F tömbbe vágja, vagy kézzel kell majd a Perl programban használnunk a split Perl vágó parancsot. Az

sas@d3b:~$ echo "a /etc/mtab 2. mezője"; perl -ane 'print $F[1]."\n"' /etc/mtab

sas@d3b:~$ echo "a /etc/mtab 2. mezője"; perl -ne 'split(/ /,$_); print $_[1]."\n"' /etc/mtab

mutatják e 2 lehetőséget.

Utóbbi a Perl nyelvben (is) használt több lehetőséggel is megismertet bennünket, bepillantást nyújt a Perl páratlanul rugalmas voltába is.

Az _ változó a témaváltozót, az épp beolvasott sort jelenti, melyet szétvágunk, úgy, hogy a szóközöket dobtuk el, mint a mezők elválasztóit, tehát a szavak lettek az egyes elemek. Az _ változó egy a 0 értéktől indexelt tömbbé alakult, így a [1] elem adja a 2. mezőt. A szép kimenet kedvéért a Perlben karakterláncokat összefűző . operátor segítségével minden kiírt szóhoz hozzáfűzünk egy új sor karaktert.

A programok igazi haszna persze az újra-felhasználhatóság, ezért tartjuk őket a háttértárak fájljaiba mentve, melyek első sorában speciális megjegyzésként szintén elhelyezhetjük az értelmezőt és mögötte, ha tetszik fenti és más opcióit, így a héj a programfájlunkat önállóan, csak nevére hivatkozva is tudja futtatni. Mi most nem használunk opciókat, mtab.pl programunk ezen első sora csak a

#!/usr/bin/perl

formájú lesz. E program belsejében fogjuk meghatározni a /etc/mtab fájl megnyitását és egy 'while' ciklust, amíg tart a fájl, az egész program tehát a

#!/usr/bin/perl

open(FI,'/etc/mtab');
while (<FI>)
{
split(/ /,$_);print $_[1]."\n";
}

képpen alakul.

Mivel a fájlokkal a memóriában dolgozunk, így először természetesen a fájl beolvassuk a memóriába valamilyen nevű fájlváltozóba. A név 1-2 lefoglalt, különleges fájlváltozón, mint például STDIN kívül bármi lehet, csak megszokás a fájlváltozóknak csupa nagybetűs nevet adni. A while ciklusnak előbb (feltételt) adunk, ami ebben az esetben a fájlváltozó lesz, melyre mindig <> jellel hivatkozunk, tehát, hogy amíg van sor a fájlban addig ismételgesse a már jól ismert ciklusmagot.

Végül pedig írunk egy CGI programot, hogy bepillantsunk a cégünket megjelenítő interaktív weblap készítésének egy apró, alap technikájába.

A web-kiszolgáló programokba betöltött vagy általában beépített CGI - Common Gateway Interface - általános átjáró felület - modul általánosan átjárhatóvá teszi az gépre telepített adott web-kiszolgáló és a szintén arra a gépre telepített bármilyen programnyelvek közti kommunikációját, a nélkül, hogy a web-kiszolgálónak bármi különlegeset kéne tudni ehhez, a weblap megírásához egyszerűen a megnevezett programhoz fordul, majd annak kimenetét a saját bemenetén kapva adja azt a felhasználónak.

Telepítsük mondjuk az apache2 csomagban található Apache 2 web-kiszolgáló programot, mely a www-data felhasználóval lesz a használható és nem meghatározott (default) virtuális web állomásaink (virtual hosts, sites, például www.domainem.hu vagy mail.domainem.hu) nyitólapját alapértelmezetten a /var/www/index.html fájlból veszi, és a 'default' állomás beállító fájljában olyan alapértelmezett beállítást is találunk, hogy a /cgi-bin/ útvonalra hivatkozva érjük el a /usr/lib/cgi-bin/ mappában elhelyezett, a www-data felhasználó által futtatható CGI programfájljainkat. Az index.html fájt módosítjuk egy rendes űrlapot tartalmazó valódi HTML kódra:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-Type" content="text/html charset=utf-8">
<title>Cím</title>
<style>

</style>
</head>

<form action="/cgi-bin/bent">
Vezetéknév: <input name="v">
Becenév: <input name="b">
<input type="submit">
</form>

A /usr/lib/cgi-bin/ mappában pedig kezdjük el a szokásos

#!/usr/bin/perl

print "Content-type: text/html\n\n";

formában az űrlap elemek neveivel kapott értékek alapján a weblap megírását. Tekintve, hogy bármilyen tartalmat küldhetünk a CGI programunkkal, a HTTP folyamat Content-type értékét is a CGI programunkban kell a web-kiszolgáló program bemenetére írni, ezután írhatunk majd bármi mást.

A web-kiszolgáló az %ENV nevű asszociatív (név=érték) tömbben kapja meg környezeti változóit, az űrlap elemek neveivel kapott értékeket az ezen belül formálisan skaláris, tartalmilag természetesen szintén asszociatív QUERY_STRING tömbben a név=érték&név2=érték formában. E példánkban 1. lépésben a &= karaktereket kivágva egy valóban formális q nevű asszociatív tömbbe vágjuk a %ENV asszociatív több skaláris QUERY_STRING értékét a %q=split(/&=/,$ENV{QUERY_STRING}) Perl paranccsal, majd laza EDDIG nyomtatásokkal megírjuk a HTML elejét és végét, közben pedig a q tömbükben lévő változóink értékét is felhasználó HTML részleteket is, ez hát első CGI programunk:

#!/usr/bin/perl

print "Content-type: text/html\n\n";


%q=split(/&=/,$ENV{QUERY_STRING});
print <<EDDIG;

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-Type" content="text/html charset=utf-8">
<title>Cím</title>
<style>

p {font-size: 14pt; color: red}

</style>
</head>

<p>Szia, $q{b};</p>
<p>Vezetékneved: $q{a};</p>
EDDIG

CGI programfájlunk lehetőleg legyen a www-data felhasználóé és természetesen legyen neki, mint tulajdonos felhasználónak futtatási joga rajta, tehát adjuk ki a su -c 'chown www-data: /usr/lib/cgi-bin/bent; chmod 544 /usr/lib/cgi-bin/bent' parancsot

Ha mindent jól csináltunk, akkor a http://localhost címet megtekintve és az űrlapba a Nagy Laca neveket beírva az űrlapot elküldve a bent programunk annak adatai alapján nagyjából az alábbi dinamikus weblapot teszi elénk:

Szia, Laca

Vezetékneved: Nagy

Az alapértelmezetten TCP/22 porton futó SSH - Secure SHell - vagyis biztonságos héj szolgáltatást eredetileg arra találták ki, hogy biztonságosan, tehát nyílt kulcsú titkosító infrastruktúra segítségével (PKI) futtathassunk héjat vagy bármilyen más programot a távoli gépünkön, de mára már bármilyen feladatra alkalmas, például fájlok biztonságos megosztására és így tovább. A nyílt kulcs titkosító infrastruktúra lényege egy egymásból ki nem található titkosító és feloldó kulcs-pár, melyet a levelek GPG aláírásától és titkosításától kezdve, a kommunikációs feladatok szinte bármelyikéig, beleértve az SSH-t általánosan használjuk. Az SSH legismertebb szabad megvalósítása jelenleg az OpenBSD projekt által írt openssh-server és openssh-client csomag, mivel ez a legalapvetőbb szolgáltatás, amivel egy eszközre csatlakozhatunk, gyakorlatilag mindig telepítjük a szervert és klienst tartalmazó ssh metacsomagot.

Az SSH kiszolgálót futtató gépre parancssorból az ssh gépnév (vagy ip-cím) paranccsal tudunk csatlakozni. Első alkalommal a 'yes' szó begépelésével elfogadjuk a távoli gép kulcs ujjlenyomatát.

Mint a legtöbb szolgáltatás, úgy az SSH esetén is alapértelmezetten a kiszolgáló által biztosított felhasználó-alapú hitelesítéssel jelentkezünk be, a kiszolgáló tehát tárol felhasználókat, egy ilyen távoli felhasználó nevében kell oda bejelentkeznünk az azon felhasználóhoz illő hitelesítési adatok, alapértelmezetten jelszó megadásával, ha, mint a fenti példában, a kapcsolódáskor nem mondtuk meg, hogy milyen a cél gépen tárolt felhasználó nevében szeretnénk oda bejelentkezni, akkor az ssh kliensünk megpróbálja megnézni, hogy ott, ahonnan kapcsolódunk, milyen felhasználónévvel vagyunk bejelentkezve, és ha ezt megtalálja, ezt fogja továbbküldeni, így a kiszolgáló ilyen bejegyzett felhasználót fog saját magán is keresni, és ehhez várja a hitelesítési adatokat. Ha a távoli gépre más felhasználónévvel kell bejelentkeznünk, mint aminél ülünk akkor a bejelentkezésre használni kívánt távoli felhasználónevet a távoli gép előtti szokásos távoli_felhasználónév@ formában, tehát például így: ssh attila@gépnév vagy ssh attila@192.168.9.7 formában fogjuk megadni (már természetesen ha ez a távoli gép hallgat erre az IPv4 címre).

A szolgáltatások saját maguk is szolgáltathatnak felhasználókat, vagy használhatják a rendszerszintű felhasználókat például a PAM beilleszthető hitelesítési modulok keretrendszer segítségével. Az általános célú GNU/Linux terjesztéseken például a szolgáltatások többsége alapértelmezetten úgy van beállítva, hogy a PAM rendszeren keresztül rögtön használhassa az adott gép rendszer szintű felhasználóit, ez igaz például a Debian alatt a helyi és az SSH kiszolgáló alap beállítására is, így ez a jelszó kérésnél olyan, mintha ezt a felhasználónevet is már fizikailag a távoli gépnél ülve ütöttük volna be.

Az ssh parancs mögött idézőjelekben rögtön azt is megmondhatjuk, milyen program fusson számunkra, de ha nem mondtunk ilyet, akkor - természetesen pont, mintha a távoli gépnél ülnénk - az alapértelmezett programunk, tehát egy héj indul el.

Ezután már úgy dolgozunk, mintha a távoli gépnél ülnénk, a programokat ott indítjuk, annyi a különbség, hogy a távoli gépen futtatott programok képét a saját képernyőnkön látjuk.

Természetesen a /etc/ssh/ mappában vannak az SSH különféle beállításai, például az adott SSH kiszolgáló telepítésekor generált gazdagép kulcs-párok. Kapcsolódáskor megkapjuk a nyilvános titkosító kulcsot, ezzel titkosítva küldjük az adatainkat, amit tehát csak az itt lévő privát kulcs párral fog tudni feloldani a nyilvános kulcsot küldött kiszolgáló és senki más.

A legfontosabb beállító fájl számunkra most az SSH kiszolgáló démoné a /etc/ssh/sshd_config fájlban. Vessünk egy pillantást a főbb beállításokra. Mindenekelőtt tartalmazza az alapértelmezett 22-es portot, amin figyel. Korlátozható, hogy milyen IP címeken figyeljen, és hogy az SSH alkalmazási protokoll mely verzióját használja (2). Meghatározza a gazdagép-kulcs fájlok helyét és a naplózási szintet. Beállíthatjuk, hogy engedélyezze-e a kiszolgáló az X továbbítással való kapcsolódást vagy, hogy a kiszolgálón az egyes felhasználók milyen fájlban tárolhatnak nyilvános kulcsokat, aminek párjával máshonnan hitelesíthetik magukat. Az X továbbításos kapcsolódáshoz az ssh parancsot a -X opcióval kell használni.

A hitelesítési beállítások a legfontosabbak. Tilthatjuk, hogy be lehessen lépni közvetlenül rendszergazda jelszóval. Ha már van kulcsunk, érdemes is. Engedélyezhetjük, és alapértelmezetten engedélyezve is van, a nyilvános kulcsú hitelesítést, ezt fogjuk is minél többször használni. Beállíthatunk gép-alapú (host-based) hitelesítést is. A hitelesítéshez megadhatjuk, hogy használhatja a PAM keretrendszert (például rendszerszintű felhasználók hitelesítéséhez) vagy csak neki írt felhasználói adatbázisból dolgozhat. A legtöbb általános célú szabad operációs rendszeren, különösen az általános célú GNU/Linux operációs rendszereken ez alapértelmezetten engedélyezve van. Ez teszi lehetővé, hogy a már eleve rendelkezésünkre álló rendszerszintű felhasználókkal bejelentkezzünk.

A kulcs-alapú hitelesítés nagyon jó és sokszor szükséges is. Az ssh-keygen paranccsal tudunk magunknak akár jelszavas, akár jelszó nélküli kulcs-párokat generálni a ~/.ssh mappánkban. Alapértelmezetten RSA kódolású kulcsokat generálunk, egy kulcs-pár nyilvános fele alapértelmezetten az id_rsa.pub a privát pedig az id_rsa fájl lesz. Az előállt kulcs-párok nyilvános részeivel mindig bővíteni kell a távoli felhasználó ~.ssh/authorized_keys fájlját. Tehát a ~/.ssh/id_rsa.pub tartalmát itt ki kell íratni és az eredményt át kell adni egy a gépen futtatott hozzáfűzve beíró parancsnak, ez tehát logikusan a cat ./~id_rsa.pub | ssh távoli_felhasználó@távoli_gép cat >>~/.ssh/authorized_keys tehető meg 1 mozdulattal. Fontos hogy a távoli authorized_keys fájl és a saját ~/.ssh/id_rsa fájlunk másnak ne legyen nyitott, a 600 jog a maximum. Ha jelszó nélkül kulcsot hoztunk létre, akkor a bejelentkezés jelszó nélkül, automatikusan megtörténik.

Fájlmegosztásra az ssh, ftp, nfs, smb és még számos szolgáltatást használhatunk. Mindenekelőtt az sshfs megoldást nézzük 2 okból, egyrészt már úgyis fut az SSH kiszolgáló a gépünkön, másrészt a legkényelmesebb használat, ha egy távoli mappát biztonságosan felcsatolunk a saját gépükön, és egyszerűen és észrevétlenül úgy dolgozunk a távoli fájlokon, mintha a saját gépünkön lennének, ezen igényeknek pedig az sshfs felel meg jelenleg legjobban.

Az sshfs használatához, először telepítjük e csomagot. Az SSHFS egy modern, kellő teljesítményű, biztonságos FUSE-alapú megoldás. A FUSE (Filesystem in Userspace) egy a modern, a felhasználói térben (userspace) lévő műveleteket lehetővé tévő udev eszközkezelőre épülő megoldás, ami tehát történetesen a fájlrendszerek ilyen kezelését teszi lehetővé. Így, ha az sshfs-sel 1. ízben telepítettünk egy FUSE-alapú megoldást, látni fogjuk, hogy az egyrészt betölti a 'fuse' kernelmodult, másrészt létrehoz egy 'fuse' csoportot, ez lesz az, melyen át a hozzáadott felhasználóknak joga lesz használni a FUSE szolgáltatásokat.

A megosztás élvezetéhez tehát már csak annyi kell, hogy a felhasználónkat hozzáadjuk ehhez a 'fuse' csoporthoz kézzel vagy a kényelmes su -c 'adduser felhasználónk fuse' paranccsal. Soha ne feledjük, hogy a csoportjogok hitelesítést, vagyis a login csomag által biztosított szolgáltatásokat igénylik, nagyon kényszerített esetben ezt persze hirtelen megoldhatjuk, minimum mondjuk egy sg paranccsal, legjobb persze egy új bejelentkezés.

Az sshfs mint egy sima mount paranccsal már használhatjuk is a megosztást! Vagyis hitelesítjük magunkat egy távoli gépen az ott lévő felhasználóval, felcsatolunk egy mappát, amit az általunk használt távoli felhasználó jogaival fogunk tudni használni, írni/olvasni. Tegyünk fel egy 192.168.1.9 IPv4-címen levő gépet, amihez társítottuk az "fsrv" nevet és amire egyetlen hálózati démont telepítettünk, természetesen egy SSH kiszolgáló csomagot, amibe be tudunk jelentkezni az ottani 'mikka' és 'riko' felhasználóval. Bármelyikkel jelentkezünk is be, látunk egy egy symlinket, ami egy share1/ mappába mutat. A 'mikka' felhasználó kapott jogot a mappa olvasására, de csak arra, 'riko' felhasználóval viszont írhatjuk is. Szeretnénk úgy felcsatolni a távoli mappát a helyi /mnt/fsrv1 mappánkba, hogy azt a távoli 'riko' felhasználó jogaival használhassuk, a helyi gépen is 'riko' felhasználó vagyunk, tehát nem kell átadnunk a riko@ felhasználónevet így a szokásos mount parancsunkhoz hasonlóan a sshfs fsrv:/share1/ri /mnt/fsrv1/ parancs segítségével máris kényelmesen használhatjuk a fájlmegosztást, a távoli gépen lévő fájlokat kényelmesen kezelhetjük a /mnt/fsrv1/ mappánkban.

Az egyetlen, amit még kényelmesen beállítanánk az az, hogy a csatolás egy sima felhasználó nevében történjen meg automatikusan a rendszerindításkor. Eddigi ismereteink alapján ezt már könnyen meg tudjuk tenni.

A legelegánsabb és legjobb megoldás természetesen, ha mindenekelőtt az sshfs dokumentációja alapján (vagyis a csatolandó fájlrendszert az sshfs# formával kezdve, fájltípusnak pedig a 'fuse' típust megadva) a társítást felvesszük a szokásos /etc/fstab fájlba a 'user' opcióval. (Természetesen a /mnt/fsrv1/ mappa legyen írható 'riko' felhasználóval.)

Az automatikus felcsatoláshoz természetesen az is kell, hogy az SSH kiszolgáló ne kérjen jelszót, tehát erre használjunk egy jelszó nélküli kulcsot.

Végül egyszerűen gondoskodjunk a társítás felcsatolásának megtörténtéről a /etc/rc.local fájlba írt su -c 'mount /mnt/fsrv1/' riko paranccsal.

Ha mindent jól csináltunk, akkor például egy asztali rendszer indításakor bejelentkezve azt fogjuk látni, hogy a felcsatolt távoli mappa mindenhol megjelenik a fájlkezelőben. Ennyi kellett bármilyen további hálózati szolgáltatás telepítése nélkül egy fájlmegosztás kialakításához, ez máris működik, mihelyst van legalább egy sima SSH kiszolgálót futtató eszközünk - márpedig melyiken ne lenne? - az sshfs csomagot telepítve pedig fájlmegosztásunkat egy időben akárhány gépről, akárhonnan biztonságosan használhatjuk.

A 2. megoldás ismertség tekintetében az FTP, melyhez már új portot kell nyitnunk, nem biztonságos, terhelés, tűzfal is szempontjából nehezen kezelhető. A feltöltést rosszul viseli, inkább néhány párhuzamos letöltésre lehet használni, olyan esetben, mikor nem kell titkosítás. E mellett előnye legfeljebb annyi, hogy a butább operációs rendszerek is alapban ismerik, nem kell hozzá a kliensen semmit telepíteni, a szerveren annál inkább.

Számos FTP démon létezik, ezek egyike a vsftpd, mely ftp felhasználóval fut, beállítófájlja a /etc/vsftpd.conf. Alapban csak egy módot, az anonymous ftp kapcsolódást engedélyezi csak olvasásra, ha írni is szeretnénk a megosztást, ezt kel hát lazítanunk.

A locale_enable és write_enable sorokkal engedélyezhetjük a helyi felhasználók bejelentkezését és hogy írhassák az általuk amúgy írható mappákat. A vsftpd beépítve támogatja a chroot lehetőséget, tehát beállítható, hogy a belépett felhasználók alapban csak egy adott mappát lássanak gyökér mappaként, ne tudjanak abból kilépni és böngészni a rendszert, vagy például teleírni a /var/mail/ vagy /tmp/ mappákat.

Ha egy szolgáltatás beállító fájlját módosítjuk, erről általában értesíteni kell a szolgáltatást annak init szkriptjével, mert a programok alapban csak induláskor olvassák el a beállításokat. Esetünkben tehát minimum a /etc/init.d/vsftpd reload parancs szükséges. A curlftpfs csomaggal csinálhatunk az sshfs megoldáshoz hasonló csatolást.

Az RFC RPC (Remote Procedure Call - távoli eljáráshívás) szabványra épül a főleg a 90-es évek elején írt Network Filesystem Protocol - tehát az NFS -, melyet szintén sok rendszer ismer, és mellyel szintén lehetséges a fájlmegosztás.

Az nfs-kernel-server csomag telepítése után a /etc/exports fájl segítségével lehetséges mappák exportálása megosztásra alapvetően a kliens gépe alapján simán vagy például (rw), tehát írási joggal. E lehetőségeket természetesen elmondja az info exports parancs. Alapban az NFS sem titkosít, ennyivel is kedvezőtlenebb az sshfs megoldásnál, megbízható belső hálózatnál felmerülhet a használata.

Az IBM régi SMB protokollja, bár nem túl biztonságos és lassú is, szintén felmerülhet fájlmegosztásként. E protokoll olvasója szinte minden általános célú operációs alapból rendszerbe be van építve, legfeljebb ennyi előnye van.

Szabad szoftverként a szolgáltatást a SaMBa nevű program valósítja meg, tehát a samba csomagot kell telepíteni. A /etc/smb.conf fájl "Share Definitions" szakaszában látható előre definiált megosztási példák formájában hozhatunk létre saját megosztásokat [neve] és alább a látott lehetséges opciói megadásával.

Az Internet Printing Protocol - IPP - a szabványos, hálózaton is használható TCP protokoll (631) nyomtatók használatára, mely a HTTP 1.1 protokollra épül, így egy webböngészőből is vezérelhető. Miután a nyomtatási munkákat (print jobs) ütemezni kell, a nyomtatás mindig egy természetesen kiszolgáló/ügyfél típusú nyomtató-rendszer szoftverre épül, ezek példányai képesek egymásnak is átadni a nyomtatási munkákat. A szabványos nyomtató-rendszerek alapja tehát mindig az IPP.

A szabad szoftverek világában többféle nyomtató szoftver-rendszer ismert, a legnépszerűbb a CUPS - Common Unix Printing System, mely képes a hozzáférés vezérlésre, hitelesítésre és az SSL/TLS használatán keresztül a titkosítás segítségével történő biztonságos nyomtatásra is.

A grafikus munkakörnyezetekben általában 2 mód is rendelkezésre áll a nyomtatók megosztására. Az egyik a munkakörnyezet segédeszköze, az alapértelmezett GNOME grafikus munkakörnyezet alatt más rendszer-feladatokhoz hasonlóan a Rendszer/Adminisztráció/Nyomtatás pontban találjuk, de sokkal általánosabban használhatjuk a webböngészőt is, saját gépünkön természetesen a localhost:631 címre hivatkozva. Az IPP-alapú nyomtató-rendszerünk által adott weblapok segítségével felvehetünk nyomtatókat és elvégezhetjük a megosztás adminisztratív feladatait, ehhez kérni fogja majd a rendszergazda vagy az lp csoport valamely tagjának hitelesítését.

Nyomtatók megosztása a szabvány héjban szintén több szokásos módon lehetséges. A legkényelmesebb mód természetesen itt is a webböngésző használata. Rengeteg karakteres üzemmódú webböngésző elérhető a csomagkezelőben, a rendszer alapértelmezetten telepít is egyet, például a w3m böngészőt, tehát például a w3m http://localhost:631 paranccsal ugyanúgy elérjük a fenti felületet. A nyomtató-rendszert természetesen a beállító fájlokban is módosíthatjuk, CUPS esetén ez természetesen a /etc/cups/ mappa. Ilyenkor szokásos módon ne feledjük, hogy a beállító fájlok módosítása után minimum az init szkript reload (esetleg restart) argumentumával újra be kell tölteni a nyomtató rendszer démon számára azokat.

A szabad szoftver az ISO, W3C, IETF és más hasonló szervezetek valódi, nyílt, szabad szabványaira épül. Reggeltől estig ilyen szabványokra épülő szoftvereket használunk az élet minden területén. Különösen akkor, mikor a hálózatot is használjuk dokumentumok, adatok átvitelére csakis a nyílt szabványok teszik lehetővé annak megbízható és biztonságos voltát. A szabad operációs rendszer és bármi más szabad szoftver használata esetén számos nélkülözhetetlen előnyt biztosítunk nem csak magunknak, hanem az összes partnerünknek is, többek közt az alábbiakat.

A szabad információs társadalom csak olyan társadalom lehet, mely betartja ezeket a szabványokat, melyben az állam biztosítja az ellenőrizhető, szabad szoftver használatának lehetőségét a közélet minden területén. Az, hogy az épülő információs társadalom szabad információs társadalom legyen, amely hatékonyan használja az informatikai eszközöket, hálózatot nélkülözhetetlen közügy, e cél érdekében pedig ragaszkodjunk a szabványos, szabad szoftver használatához és éljünk szabadon.

Köszönet a következőknek: