Mac OS X Terminal és Unix alapok

A Mac felhasználók többsége úgy gondolja, hogy számára tökéletesen elegendő a grafikus felület (GUI: Graphical User Interface), azzal szépen, biztonsággal mindent meg tud csinálni, amire szüksége van. Ez többnyire igaz is, de sokan vannak olyanok akik szeretnének mélyebben elmerülni az operációs rendszer rejtelmeiben, vagy éppen egy eszközt szeretnének amivel meg lehet oldani problémákat amikor a grafikus felület esetleges korlátaival találjuk magunkat szemben.
Sok izgalmas, érdekes dologgal találkozik aki erre a kalandra vállalkozik!

Az alábbi cikk eredetileg 2006-ban jelent meg folytatásokban azAlmalapban. Elektronikus formátumban itt: 12345 olvasható.

Mac OS X alapjait, a Terminal programból elérhető parancsokat tárgyalja még a Tigris (Tiger) korszakból. Jelen cikk az ott leírtak aktualizálása a Leopárd (Leopard) és a Hóleopárd (Snow Leopard) , illetve az Oroszlán (Lion) korszakra.

CLI: Command Line Interface

CLI-t, azaz a parancs üzemmódot a legegyszerűbben a Terminalprogramból érhetjük el. Ez a segédprogram az ApplicationsUtilitieskönyvtárban található, és sokan mondják, hogy “nagyon veszélyes” program, ezért félnek is tőle. Én úgy gondolom, hogy érdemesebb inkább megismerni és megtanulni az alapvető használati szabályokat.
Leegyszerűsítve két típusú parancs létezik. Az egyikkel csak információt kérünk a rendszerről, például kilistázzuk egy könyvtár, vagy állomány tartalmát, megnézzük az éppen futó programokat, keresünk a lemezen, vagy fájlok tartalmában, ellenőrizzük a diszk telítettségét … Ezekkel bátran próbálkozhatunk.

Azok a parancsok, amelyek eredménye már valamilyen változást eredményez, állományokat hoznak létre, törölnek, mozgatnak, megváltoztatják azok jellemzőit, hatással vannak a rendszer működésére, … már sokkal több figyelmet és körültekintést igényelnek. Tisztában kell lenni a saját rendszerünk felépítésével is, mert ugyanannak a parancsnak lehet más, esetleg meglepő eredménye különböző beállítások esetében! (Nem mindegy például az sem, hogy a telepítés során a Mac OS Extended, vagy az UFS, a UnixFile System lett kiválasztva.)

A legjobb, ha olyan gépen tudunk próbálkozni, amelyiken nincs fontos adat. Ha a saját gépünkön tudunk csak gyakorolni, akkor érdemes létrehozni egy új felhasználót (teszt) kifejezetten gyakorlási célra, méghozzá olyat, aki NEM rendelkezik admin jogosultsággal (nincs kipipálva az “Allow user to administer this computer” opció a System Preferences AccountsPassword oldalán).Adminisztrátori, vagy root jogosultsággal (lásd később) csak akkor ajánlott dolgozni, ha kellő tapasztalatot szereztünk és biztosan tudjuk, hogy mit csinálunk.

Nézzük mit találunk, ha kinyitjuk a Terminal ablakot!

Terminal

Nos, ennek a belseje nem annyira látványos, mint a grafikus felület (AQUA), de innen elérhető az operációs rendszer valódi arca a Darwin. ADarwinFreeBSD családjához tartozik, egy valódi Unix-szerű rendszer és igen tekintélyes ősökkel rendelkezik. A Unix első változatát Ken Thompson még 1969-ben írta meg, a cél egy többfelhasználós, többfeladatos operációs rendszer készítése volt. A kaliforniai Berkeley Egyetemen a 70-es évek vége óta fejlesztik ennek egyik változatát. Innen származik az elnevezés: BSD = Berkeley Software Distribution. Aki bármilyen Unix-szerű rendszert ismer, de különösen ha jártas a BSDrendszerekben, az otthonosan érezheti magát a Darwin környezetben is hiszen nagyon sok ismerős dologgal fog találkozni. Csak a nyelvjárásbeli különbségeket kell megismernie. Aki viszont nem, nos itt az ideje, hogy elkezdje az ismerkedést!

Terminal programot a grafikus felületről érjük el, ezért nem meglepő, hogy rendelkezik az ott megszokott beállítási lehetőségekkel. Egyszerre akár több Terminal ablakot is nyithatunk (FileNew Shell az Oroszlánelőtti verziókban, illetve ShellNew Window, vagy ShellNew Tabsegítségével a Lion-ban ), ami első pillanatban feleslegesnek tűnhet, gyakorlott használók azonban tudják, hogy sok esetben jelentősen megkönnyíti a munkát. Az Oroszlán előtti verziókban a Terminal >Window Settings … menüt kiválasztva, a Terminal Inspectorbanrugalmasan beállíthatjuk a számunkra szimpatikus színt, betűtípust, méretet, háttérképet, akár transzparenssé is tehetjük az ablakot:


Lion-ban jelentősen kibővült a lehetőségek tárháza. Érdemes körülnézni A TerminalPreferencesSettings ablakban.
A beállítások elmenthetők, és akár előírható az is, hogy automatikusan minden új Terminal ablak az elmentett beállításokkal nyíljon meg. Természetesen az igazi értéket a további professzionális beállítások sokasága jelenti, melyek lehetővé teszik, hogy a Terminal programot széles körben használhassuk a legkülönbözőbb feladatokra: szövegszerkesztés, rendszerkarbantartás, folyamatirányítás …

Shell

Terminal Inspector Shell gombját kiválasztva egy információs ablakot kapunk a Lion előtti verziókban. A Lion-ban pedig nyissuk ki az Inspector Info ablakát (A Shell menüben kattintsunk a Show Inspector sorra). Ebben az ablakban látható, hogy milyen shell program fut a Terminal-ban. Az aktuális shell program határozza meg azt, hogy milyen “nyelven” társaloghatunk az operációs rendszerrel. Több fajta shell program létezik, ezek sok tekintetben hasonlítanak egymásra, de mindegyiknek vannak sajátosságai.
Az alapot a Bourne shell (sh) jelenti. Ezt, vagy ezzel egyenértékű shellprogramot minden Unix-szerű rendszer tartalmaz. Megalkotója Stephen Bourne volt még 1977-ben. A Tigrisben a legtöbb az alapból választhatóshell programok száma (bashtcshcshzshksh), de akár továbbiak is telepíthetők szükség esetén. Fontos azonban tudni, hogy a Jaguárig aTenex C shell (tcsh) volt a default shell, a Párductól viszont a Bourne-Again shell (bash) lett az alapértelmezett program. De hogy ne legyen ilyen egyszerű az élet, ha valaki a Jaguár szerverről upgrade-elt Párducra, akkor vitte magával a korábbi shell-t, csak a Párduc új felhasználói kapták meg a bash alapbeállítást. Ezt azért fontos tudni, mert a lehetőségek, a konfiguráció, a beállítások tekintetében nagyon sok eltérés lehet a különböző shell programok között.

Bourne-again shell (tréfásan born-again) Brian Fox nevéhez főződik és 10 évvel fiatalabb, mint a Bourne shell. Fontos jellemzője, hogy “free software” és a legtöbb Linux rendszerben is ez az alapértelmezett shell program.

Leopard,  a Snow Leopard és a Lion alapértelmezett shell programja is abash.

A továbbiakban a bash shell-re fogunk koncentrálni. Ekkor a Terminal Inspector ablakban a

Shell: bash

információt látjuk.

UNIX parancsok – echo, su

A fenti információt másképpen is megkaphatjuk. Ha már nyitva van egyTerminal ablak, akkor adjuk ki a következő parancsot:

echo $SHELL

Ha az alapértelmezett shell programunk a bash, akkor az Enter billentyű megnyomása eredményeképpen azt látjuk a kurzor után, hogy:

/bin/bash

Ez is azt mutatja, hogy a bash nevű shell program rendelkezésünkre áll.

Unix-szal parancsok segítségével tudunk beszélgetni. A parancsok megadása után meg kell nyomni az Enter (vagy Return) billentyűt. Ekkor az aktuális shell program megpróbálja értelmezni a bevitt parancsot és vagy szól, hogy valamit nem ért, vagy végrehajtja az parancsot, pontosan úgy ahogy azt ő érti. (Már most az elején érdemes tisztázni, hogy ez nem mindig egyezik meg azzal, amit mi szerettünk volna, és jó tudni, hogy az esetek döntő többségében bizony neki van igaza! :)
A parancsokat pontosan kell begépelni: ne maradjon ki a space (üres karakter), általában fontos a kis- és nagybetűk megkülönböztetése. A fenti parancsban az echo a parancs neve, ami utána van az egy un. shell változó (ezt jelöli a név előtt álló dollár jel, és ennek értékét írattuk ki az echoparanccsal), ami tartalmazza az éppen futó shell program nevét.
A kurzor előtt is sok minden látható, erről majd később lesz szó, most megmutatom, hogyan lehet leegyszerűsíteni ezt a részt. Azt szeretném, ha például minden új sor a

teszt:

karakterekkel kezdődne a Terminal ablakban.

Ismételten javaslom, hogy aki még nem tette meg, hozzon létre egy új felhasználót a System Preferences >Accounts ablakában, a neve legyen:teszt és fontos, hogy kezdetben NE legyen adminisztrátori jogosultsága!

Ahhoz, hogy bejelentkezzünk egy másik felhasználó területére, nem szükséges kilépni és ismét bejelentkezni a grafikus felület Log Out / Log In parancsával, de nincs szükség a “Fast user switching” bekapcsolására sem. A Terminal erre egy sokkal egyszerűbb utat kínál! Gépeljük be a következő parancsot a Terminal ablakba:

su - teszt

majd meg kell adni a teszt felhasználó jelszavát és máris indul egy új shellprogram, de már az új felhasználó tárterületén vagyunk. Érdekes megemlíteni, hogy ha több Terminal ablakot is nyitunk, így akár két-három, vagy több különböző felhasználó területére is bejelentkezhetünk egyszerre. Sőt, később azt is látni fogjuk, hogy ezek a felhasználók nem csak a saját gépünkön, hanem bárhol lehetnek az Interneten, vagy más hálózaton, megfelelő feltételek fennállása esetén akkor is be tudunk lépni a felhasználók távoli gépen levő területére.

Fontos: ha rossz felhasználónevet adunk meg, vagy elgépeljük a jelszót, akkor kapunk egy “Sorry” üzenetet és maradunk a saját területünkön (tessék kipróbálni!).
Ha sikeresen bejelentkeztünk, akkor nincsen hiba üzenet, de megváltozott a kurzor előtti rész tartalma, jelezve, hogy felhasználót váltottunk. Ezt a részt fogjuk most leegyszerűsíteni. Gépeljük be először a következő parancsot:

echo "export PS1=\"\u: \"

Első pillanatra kissé bonyolultnak tűnhet, de az echo parancsot már ismerjük, ez kiírja a képernyőre a következő sorba az utána álló, idézőjelek közé tett karaktereket. (Megjegyzés: Amit az idézőjelek között látunk, az nem más, mint egy változó értékadása, amit természetesen még lehet tovább is variálni, és így később kedvünkre alakítgathatjuk majd a kurzor előtti területet, de kezdetnek elég ha a fenti példát kipróbáljuk.)
Nyomjuk meg a billentyűzeten a felfelé mutató nyilat és ismét megkapjuk a fent begépelt parancsot. Ez egy nagyon kellemes tulajdonsága a shellprogramnak: emlékszik a korábban megadott parancsokra és azok egyszerűen előhívhatók több lépésre visszamenőleg! Egészítsük ki a fenti parancsot az alábbi módon:

echo "export PS1=\"\u: \" " > .profile

A nagyobb jel egyszerűen átirányítja a kiíratást és egy fájlba ír a képernyő helyett. A fájl neve a .profile lesz. (Ne feledkezzünk meg az Enter billentyűről a parancs végén.)
Ellenőrizzük, sikerült-e pontosan begépelni a fenti példát! Lépjünk ki az imént indított shell programból úgy, hogy beírjuk az

exit

parancsot. Ekkor kapunk egy logout üzenetet, hiszen kiléptünk egy unixfelhasználó területéről, majd jelentkezzünk be hozzá ismét a már ismert “su -teszt” paranccsal. A jelszó megadása után a következő sorban most már ezt fogjuk látni:

teszt:

és ezután villog a kurzor. A parancsok végrehajtása után mindig ezt kapjuk vissza.  Ettől kezdve innen lehet tudni, hogy a shell program várja a következő utasításunkat. Kipróbálhatjuk azt is, hogy nyitunk egy újTerminal ablakot (File menü New Shell kiválasztásával Oroszlán előtti verziókban, illetve Shell menü New Window, vagy New Tabkiválasztásával a Lion-ban), és ott is bejelentkezünk a teszt nevű felhasználó területére. A kurzor előtti rész itt is ugyanaz lesz. Most a tesztfelhasználó területén vagyunk, itt nyugodtan tesztelhetünk, gyakorolhatunk.

Fájlok – cat

Láttuk, hogy az echo parancs eredményét át lehet irányítani egy fájlba. Ez valóban nagyon egyszerű, de ugyanakkor oda kell rá figyelni! Lazán felülír egy létező állományt, ha annak a nevét adjuk meg a nagyobb jel mögött!

Nem kérdez semmit, nem figyelmeztet, hogy ilyen fájl már létezik.

Feltételezi, hogy átgondoltuk és pontosan tudjuk, hogy mit és miért csinálunk. Megér egy próbát a dolog! Adjuk ki a

teszt: echo "valami eredeti" > aminta

parancsot. Ez létrehozza az aminta nevű fájlt és az idézőjelek közé tett szöveget beleírja. Ezután próbáljuk ki, hogy:

teszt: cat aminta

ahol a cat parancs a minta fájlba imént írt szöveget kiírja a képernyőre, azaz megmutatja, hogy mi van a fájlban.

Ha most kiadjuk a

teszt: echo "ez fog megmaradni" > aminta

parancsot, akkor az könyörtelenül kicseréli az aminta fájl tartalmát az új szövegre, a fájl régi tartalma elveszett, nincs visszalépési lehetőség!

Nézzük meg most is az aminta fájl tartalmát a cat paranccsal!
Nos ebből már kezd érthetővé válni, miért is érdemes egy teszt felhasználó területén megfizetni a tanulópénzt.

Gyakoroljuk az echo parancsot és hozzunk létre még néhány a-betűvel kezdődő mintafájlt!

Megjegyzés
: többsoros szöveget is írhatunk a fájlba, ha a záró idézőjel előtt új sor (Enter) billentyűt nyomunk akár többször is, mert az echoparancsot csak a második idézőjel utáni Enter megnyomását követően kezdi értelmezni a shell. Közben ideiglenesen megváltozik a prompt, ezzel is jelezve, hogy egy parancs megadása közben vagyunk.

Emlékezzünk a felfelé mutató nyíl használatára, amivel könnyen visszahozhatunk korábbi parancsokat. A felfelé és a lefelé mutató billentyűkkel lépkedhetünk visszafelé és előrefelé a korábban kiadott parancsok között. A vízszintes nyíl billentyűkkel pedig az aktuális parancsok belsejében mozoghatunk, ahol karaktereket törölhetünk (delete) és beszúrhatunk, így egyszerűen módosítva a korábbi parancsokat, könnyedén és gyorsan létrehozhatunk újakat.

Tekintsük a következő feladatot:
Gyűjtsük össze a grafikus környezetben az aktuális könyvtárban az összes a-betűvel kezdődő fájlból minden sor második szavát, töröljük ezekből az összes nem betű karaktert, a kisbetűket változtassuk a megfelelő nagybetűre és végül a szavakat ABC sorrendben írassuk ki a képernyőre, de ismétlődés nélkül és sorszámozzuk is meg őket! (A pontosság kedvéért: a betűkarakter az angol ABC betűit jelenti.)

Most mutatok egy lehetséges parancssori megoldást:

teszt: cat a* | awk '{print $2}' | sed s/[^a-zA-Z]//g | tr '[a-z]' '[A-Z]' | sort | uniq | cat -n

mindezt egy sorba kell begépelni! Érdemes kipróbálni!
Aki elég változatos és sok példát készített az echo parancs gyakorlása során, annak biztosan tetszik az eredmény.
A későbbiekben még visszatérünk ennek az értelmezésére!
Ez egy szép példa a unix szövegszerkesztési és folyamatvezérlési képességeinek bemutatására.

Beszéd – say

A Macintosh régóta híres beszédességéről, sok olyan program létezik, amelyik képes szövegek felolvasására. A Terminal-ban ez egy nagyon kézenfekvő lehetőség, csak be kell írni a say parancsot és a kívánt szöveget:

teszt: say almalap

Ha nincs lekapcsolva a hangerő, máris kedvenc lapunk nevét halljuk, bár kicsit tört magyarsággal. Angol szövegekkel nyílván jobbal boldogul.
Ha az f opcióval megadjuk egy szöveges fájl nevét, akkor annak tartalmát fogja felolvasni:

teszt: say -f fájl-neve

Ha az o opciót adjuk meg, akkor egy hangfájlba menthetjük el a felolvasott szöveget:

teszt: say -o teszt.aiff Olvasom a lapot

Ezt könnyen ellenőrizhetjük, írjuk be a következő parancsot:

teszt: open .

ennek segítségével kinyitunk egy Finder ablakot (az open parancs után egy szóköz karaktert kell írni a pont előtt!) és a grafikus, megszokott környezetben meggyőződhetünk róla, hogy valóban ott van egy teszt.aiffnevű hangfájl, amit rögtön vissza is hallgathatunk!

Dátum – date, history

Milyen nap volt 1999. január 10-én? Szeretnénk gyorsan választ kapni erre a kérdésre, de éppen nincs kéznél egy 1999-es naptár. Persze ott van a grafikus iCal program amit megnyitunk, majd kattintgatunk egy párat és megkapjuk a választ. Egy picit gyorsabb, ha beírjuk a következő parancsot a Terminal-ban:

teszt: cal 1 1999

és máris látható, hogy a keresett nap vasárnap volt. Ha csak a calparancsot írjuk be, akkor az aktuális hónap napjait mutatja, ha pedig csak egy számot írunk a cal parancs után, akkor azt évként értelmezi, tehát a

teszt: cal 3006

parancs eredményeképpen a 3006-os év naptára varázsolódik az ablakba. Fent láttuk, hogyha két számot adunk meg, akkor az elsőt a hónap sorszámának, a másodikat pedig az év sorszámának tekinti. Ha az első szám 1-nél kisebb, vagy 12-nél nagyobb, akkor udvariasan figyelmeztet, hogy 1 és 12 közötti értéket illene megadnunk. Az évek számát pedig 1 és 9999 között várja!
Végül még egy érdekesség: ha a j opciót is megadjuk, akkor a napokat január 1-től kezdve sorszámozza, tehát pl. a

teszt: cal -j 4 2006

parancsot beírva, könnyen leolvasható, hogy 2006. április utolsó napja az év 120. napja.

date parancs kiírja az aktuális dátumot és időpontot. Az első részben láttuk, hogy a nagyobb jel segítségével parancsok kimenetét át lehet irányítani például egy fájlba. Próbáljuk ki:

teszt: date > idopont

majd ellenőrizzük a cat paranccsal az idopont nevű fájl tartalmát. Már láttuk, hogy az átirányítás kérdezés nélkül felülírja egy létező fájl tartalmát! Ha a fenti parancsot többször kiadjuk, akkor az idopont fájltartalma mindig az az időpont lesz, amikor utoljára kiadtuk aparancsot.
Természetesen van arra lehetőség, hogy megőrizzük a korábbi dátumokat is! Ha a nagyobb jelet megduplázzuk, akkor az aktuális parancs eredménye hozzáíródik a megadott fájlhoz, tehát nem törlődik annak korábbi tartalma. Adjuk ki többször egymás után a

teszt: date >> idopont

parancsot.
Szeretnék emlékeztetni arra, hogy a felfelé mutató nyíllal előhívhatjuk a korábbi parancsokat, tehát nem kell ismét begépelni azokat. Ezután a catparanccsal kiíratva a fájl tartalmát, megtaláljuk abban a parancs kiadási dátumokat. A korábban bevitt parancsokat nem csak az imént említett nyíl billentyűkkel tudjuk előhívni, hanem rendelkezésünkre áll egy speciális parancs is:

teszt: history

Ennek hatására megkapjuk a korábban kiadott parancsok sorszámozott listáját.

Számolás – dc, units

Van egy számológép, ami mindig kéznél van a Terminal ablakban. Vegyünk egy mély lélegzetet, írjuk be a dc parancsot és küldjük el, majd beírjuk az első számot, elküldjük, jöhet a második szám, ezt is elküldjük, majd beírva egy műveleti jelet, elküldjük és végül beírunk egy p betűt (pops) és ezt is elküldjük és máris láthatjuk az eredményt. Szorozzuk meg 123-at 456-tal:

teszt: dc
123
456
*
p
56088

dc programból a q betű (quit) elküldésével léphetünk ki. Kicsit szokatlan a használata! Ez tény.
De ha most beírunk két 500 jegyű számot és összeszorozzuk őket, akkor jön az igazi meglepetés: a dc megcsinálja! Tessék kipróbálni!
Zsebszámológépeink számolási korlátait messze felülmúlja, jó tudni, hogy van egy ilyen lehetőség a tarsolyunkban.

Egy másik, szintén kevéssé ismert ügyes program a units. Ha például km/h-t szeretnénk m/s-ra, inchet méterre, köbmétert gallonra, vagy centimétert feet-re (láb) váltani, csak gépeljük be ezt a parancsot:

teszt: units
You have: 100 km/hour
You want: m/s
* 27.777778
/ 0.036
You have: 300 inch
You want: m
* 7.62
/ 0.1312336
You have: m^3
You want: gallons
* 264.17205
/ 0.0037854118
You have: 150 cm
You want: feet
* 4.9212598
/ 0.2032

Ötszáz különböző mértékegység közül válogathatunk!

Ebből a programból a CTRLc billentyűk együttes lenyomásával lehet kilépni.
Érdemes megjegyezni ezt a billentyűkombinációt, általában is használhatjuk parancsok futásának megszakítására. Pl. az iménti dcparancsból is kiléphetünk ennek segítségével is.

Dokumentáció – man

man (manual) parancs segítségével sok mindent megtudhatunk a parancsokról. Gyakran egyszerű példákat is találunk használatukra. Próbáljuk ki például:

teszt: man units

de érdemes az eddig megismert parancsokról (például man dcman cal, vagy man man :) és a későbbiekről is további információkat gyűjteni az operációs rendszerbe beépített manuálok (dokumentáció) alapján. Gyakran kiderül, hogy egy egyszerűnek látszó parancs rendkívül sokszínű tud lenni, különböző opciók megadásával kiválóan testre szabhatjuk.

Kapcsolat – telnet, ftp, sftp, ssh, curl

Már láttuk, hogy a su parancs segítségével egy Terminal ablakon belül egyszerűen átjelentkezhetünk egy másik felhasználó területére.
Lehetőség van azonban arra is, hogy a hálózaton levő másik számítógépre jelentkezzünk be a Terminal ablakon keresztül, és ott szinte ugyanúgy dolgozzunk, mintha közvetlenül a másik gép előtt ülnénk. Amennyiben ez a hálózat például az Internet, akkor így akár a világ másik felén levő számítógépen is dolgozhatunk. Erre a telnet parancs szolgált sokáig, de ma már csak nagyon kevés számítógépen engedélyezik a használatát, mert ennek során a megadott jelszó kódolatlanul utazik a másik gépre, és menet közben könnyen elkapható, mások által is olvasható. A mai biztonsági előírásoknak ez már egyáltalán nem felel meg. Helyette az ssh parancs használata sokkal elterjedtebb, ennek során a jelszó a bejelentkezéskor titkosítva lesz elküldve a távoli gépre. Alakja:

teszt: ssh -l felhasználó-név távoli-gépneve

A távoli gépen biztosítani és engedélyezni kell az adott felhasználó számára, hogy ezen a módon be tudjon jelentkezni. Ha a bejelentkezés sikeres volt, ugyanazokat a parancsokat adhatjuk ki, mintha egy Terminalablakot nyitottunk volna az előttünk levő gépen.

Az ftp egy másik gyakran használt program, aminek a segítségével távoli gépre bejelentkezünk és onnan fájlokat letöltünk, esetleg bizonyos fájlműveleteket is végrehajtunk.
Régebben nagyon gyakori volt az ftp parancssori használata, ma már a grafikus programok háttérbe szorítják, de hasznos lehet ha ismerjük a használatát, ami igazán nem bonyolult. Nézzük például, hogyan tudunk bejelentkezni az Apple ftp szerverére (vagy ha ezzel nem sikerül kapcsolatba lépni, keressünk másik nyílvános ftp szervert és próbálkozzunk azzal):

teszt: ftp ftp.apple.com

Ha a kapcsolat létrejött, akkor a távoli gép kéri a bejelentkezési nevünket. Ez vagy ismert a számunkra, vagy ha nem akkor meg lehet próbálni anonymous-ként bejelentkezni. Egyszerűen írjuk be az anonymous szót és küldjük el. Ha ez engedélyezve van a távoli gépen (a nyilvános ftp szerverek általában ilyenek), akkor általában még megkérdezi az email címünket. Illik megadni, de ha nem tesszük, attól még többnyire be fog engedni. Több-kevesebb üdvözlő szöveg után kapunk egy új promptot:

ftp>

ez jelöli, hogy a távoli ftp szerver várja az utasításainkat. A legfontosabbak a következők. Az ls paranccsal kérhetünk egy listát a távoli gépen levő állományokról:

ftp> ls
drwxrwxrwx 3 ftpprod ftpprod 102 May 7 2003 Apple_Support_Area
drwxrwxr-x 20 ftpprod ftpprod 680 Aug 20 2007 developer
drwxrwxr-x 37 ftpprod ftpprod 1258 May 18 2004 emagic
drwxrwxr-x 11 ftpprod ftpprod 374 Mar 9 2004 filemaker
........

A d betűvel kezdődő sorok könyvtárakat jelölnek a távoli gépen, a könyvtár neve pedig a sor végén látható. A könyvtárakba a cd paranccsal lehet belépni. Például lépjünk be és nézzük meg mi van a filemaker nevű könyvtárban:

ftp> cd filemaker
ftp> ls
drwxrwxr-x 7 ftpprod ftpprod 238 Nov 5 2002 Updaters
drwxrwxr-x 4 ftpprod ftpprod 136 Aug 19 2004 applications
-rwxrwxr-x 1 ftpprod ftpprod 44 Feb 21 2003 distribution.txt
drwxrwxr-x 4 ftpprod ftpprod 136 Jan 20 2004 downloads
drwxrwxr-x 8 ftpprod ftpprod 272 Jul 2 2004 misc
drwxrwxr-x 7 ftpprod ftpprod 238 Mar 19 2004 open_source
drwxrwxr-x 6 ftpprod ftpprod 204 Nov 2 2001 quicktime
drwxrwxr-x 8 ftpprod ftpprod 272 Mar 9 2004 solutions
drwxrwxr-x 4 ftpprod ftpprod 136 Sep 26 2003 trial_software

….

Itt is vannak alkönyvtárak, de találtunk egy szöveges fájlt is. Töltsük le ezt a saját gépünkre, erre a get parancs szolgál:

ftp> get distribution.txt

Az ftp programból az exit, a close, a bye, vagy a quit parancsokkal léphetünk ki. Van lehetőség bőven! Ezután például a már jól ismert catparanccsal megnézhetjük a distribution.txt fájl tartalmát.

get parancs hatásával ellenkező irányú állománymozgást érhetünk el a put parancs segítségével.
Ezzel tudunk fájlokat feltölteni a távoli ftp szerverre, ha ez ott engedélyezve van.

Az ftp program testvére az sftp program, ami ssh alapon működik, ezért ez egy secure ftp program. Persze ennek nem nyilvános szerverek esetében, hanem akkor van értelme, ha biztonságos adatcserét szeretnénk végrehajtani távoli gépek között. Ekkor a felhasználónév és a hozzátartozó jelszó ismeretére is szükség van.

Mindkét ftp program lehetőséget biztosít arra, hogy bejelentkezés után parancsokat adjunk ki a távoli gépen, fájlokat töröljünk, könyvtárakat hozzunk létre …

Mutatok még egy érdekességet:

teszt: curl -O http://www.almalap.hu/img/alma.gif

és máris letöltöttük az Almalap nyilvános szerveréről a kis alma logót (feltéve, hogy nem gépeltünk el semmit és a szerver is elérhető :-) .
Aki nem hiszi járjon utána, például a már ismert

open .

 

parancs segítségével megnézheti, hogy a logó ott van az aktuális könyvtárában. Ilyen az eredeti:

Akit mélyebben érdekel a fenti programok használata, érdemes a manparanccsal tanulmányoznia őket.

Processzek – ps, top

Operációs rendszerünk jó pár beépített programmal rendelkezik. Amikor elindítunk egy ilyen programot, azt úgy mondjuk, hogy kiadunk egy parancsot. Láttuk, hogy a parancs kiadása vagy egyszerűen a program nevének megadásával történik, vagy különböző opciókkal kiegészíthetjük és ezáltal számunkra hasznosabb feltételekkel is indíthatjuk. Amikor egy parancs segítségével elindítunk egy programot, akkor elindul egy új processz. A ps parancs (process status) segítségével kilistázhatjuk az aktuálisan futó processzeket:

teszt: ps

Ennek hatására kapunk egy listát az éppen futó saját processzeinkről. Ebben a listában két oszlopra szeretném felhívni a figyelmet:
- az első oszlopban áll egy szám (PID), ez a processz egyedi azonosítója,
- az ötödik oszlopban áll a parancs neve, amivel az adott processz elindult.

Legalább egy processz mindig fut, mert amikor elindítjuk a Terminalt, akkor elindul egy shell. Érdemes kipróbálni a következőt: az egyik ablakban elindítjuk a units parancsot, majd egy másik ablakban a psparancsot.

Ugyanaz a program több példányban is futhat. Nyissunk ki több Terminaltés adjuk ki a dc parancsot legalább két ablakban és egy másikban a psparancsot.
Látni fogjuk, hogy a shell és az említett programok is több példányban futnak, mindegyik más és más PID számmal rendelkezik.
Ha opcióval együtt indítjuk a ps parancsot, például:

teszt: ps -ax

akkor egy sokkal részletesebb listát kapunk a gépen futó összes processzről (amikor elindítjuk a gépünket egy sor program gondoskodik a háttérben, hogy kiszolgálja kívánságainkat és más felhasználók is indíthatnak processzeket). Alapesetben a ps parancs növekvő PID szerint írja ki a listát, de ezt is lehet befolyásolni. A ps -axm parancs a memória használat, a ps -axr pedig az aktuális processzor használat alapján rendezi a listát. Érdemes megfigyelni, hogy az ax, mr és még további opciókat is tetszés szerint variálhatjuk, és ennek függvényében más és más típusú listát kapunk. A PID használatára még hamarosan visszatérünk!

Van még egy érdekes parancs a processzek listázására. Ez dinamikusan, periodikusan frissülve szolgáltat információkat: PID, CPU használat, memória használat …, illetve többek között az összes futó processz számáról, állapotáról, valamint a memória, a CPU kihasználtságáról is tájékoztat. Ez az ActivityMonitor nevű grafikus program (Applications/Utilities mappában található) Terminal-beli megfelelője, a neve top:

teszt: top

A parancsból a q billentyű megnyomásával, vagy a CTRLcbillentyűkombinációval tudunk kilépni.
Érdemes kipróbálni például a top -u változatot, a processzeket így a pillanatnyi memória használatuk sorrendjében láthatjuk.

A gyilkos – kill

Most megismerkedünk egy profi gyilkossal!
A parancs neve stílszerűen: kill.
Annak ellenére, hogy nem gyilkolásra lett kitalálva, hanem arra, hogy különböző szignálokat küldjön a futó processzeknek, mégis leggyakrabban arra használják, hogy beragadt processzeket kilőjenek vele. A parancs alap formája:

teszt: kill PID

ahol a PID a processz sorszáma, amit például a ps parancs által szolgáltatott lista első oszlopában találunk meg.

Figyelem! Ha elnézzük a sorszámot, tehát rosszul írjuk be a PID számot, akkor két eset lehetséges, vagy nincs az adott sorszámmal rendelkező processz, vagy van. Az első esetben csak egy hibajelzést kapunk arról, hogy ilyen sorszámmal nem létezik processz, a második esetben viszont kellemetlen meglepetés is érhet minket. Példaképpen megemlítem, hogy saját magunk alatt is vághatjuk a fát, kilőhetjük a Terminal-ban futó saját shell processzünket.
Tessék kipróbálni!
Vannak azonban olyan processzek amelyek nem reagálnak a sima killparancsra, vagy éppen annyira beragadtak, hogy azért nem veszik az adást. Ilyenkor lehet fokozni az élvezetet, és a -9 -es opcióval keményebben is kiadhatjuk a parancsot:

teszt: kill -9 PID

Vannak olyan parancsok, amik rögtön végrehajtódnak, elvégzik a dolgukat és maguktól leállnak, visszakapjuk a promptot és újabb parancs beírására vár a shell. Ilyen például a korábbiak közül a say, a cal, a date vagy a killparancs.
De több olyan paranccsal is találkoztunk, amelyek indítás után folyamatosan futnak, és a saját parancsaikra várnak. Ilyen például a dc, aunits, a top.

Azt is láttuk, hogy az utóbbiakból általában a CTRLcbillentyűkombinációval lehet kilépni, azaz megszakítani a futásukat, de többnyire vannak saját beépített megszakító parancsaik is (q, quit,exit,…). Azonban már velem is előfordult többször is, hogy nem sikerült így kilőni egy processzt. Vagy lefagyott és nem reagált, vagy eleve úgy lett megírva a program, hogy ne lehessen szabványosan kilépni belőle. Ilyenkor meg lehet próbálni a CTRLz billentyűkombinációt, ami felfüggeszti a processzek futását. Ezután a ps paranccsal megkeressük a felfüggesztett (vagy beragadt) processz PID értékét és először a kill parancs alap változatával megpróbáljuk kilőni. Az erősebb változatot (a -9 opcióval) csak akkor használjuk, ha az első csütörtököt mondott.
Előfordulhat olyan eset, hogy a grafikus Force Quit Applications nem tud segíteni egy beragadt program kilövésében, ilyenkor érdemes a Terminalkill parancsával próbálkozni!

Könyvtárak, fájlok, listák – ls, cd

Korábban már láttuk, hogy az

open .

parancs segítségével meg tudjuk nézni, hogy mi van az aktuális könyvtárban. Természetesen ezt megtehetjük a Terminal ablakban, a grafikus felület használata nélkül is. Aki figyelmesen olvasta az eddigieket, az ki is találhatja a megfelelő parancsot, hiszen már találkoztunk vele, igaz az ftp program belső parancsaként!
Ha kiadjuk az ls parancsot, akkor kapunk egy listát a könyvtárban levő állományokról, de rögtön egy érdekes különbséget is megfigyelhetünk:


Az ftp program ls parancsa egy sokkal részletesebb listát adott, míg most a nevek egy egyszerű listáját láthatjuk csupán.
shell-ben egy kicsit más az ls parancs alapértelmezése.
Korábban láttuk azt is, hogy egy parancs hatása jelentősen befolyásolható azzal, ha különböző opciókkal egészítjük ki. Nos így van ez az ls paranccsal is, próbáljuk ki az l, illetve az la opciókkal:

teszt: ls -l
teszt: ls -la

Az első parancs eredménye már nagyon hasonlít arra, amivel az ftp-nél találkoztunk, ennek értelmezésével később részletesebben is foglalkozunk, most csupán arra emlékeztetnék, hogy ha egy sor d-betűvel kezdődik, akkor az egy könyvtárt jelöl, amibe a cd (change directory) paranccsal be is léphetünk. Ha az a opciót is odabiggyesztjük a végére, akkor egy kicsit részletesebb listát kapunk, és un. rejtett (hidden) állományok is láthatóvá válnak.
Aki elvégezte a cikk elején bemutatott prompt beállítást, az most az

ls -la

parancs eredményeként látni fogja a .profile nevű fájlt a listában, amit még az echo parancs segítségével alkottunk meg. A rejtett fájlok neve tehát egy ponttal kezdődik, és jellemzően különböző programok használják őket működésük során. A .profile fájlt a shell program használja, ennek segítségével lehet beállítani a prompt formáját, tartalmát. Hamarosan ismét meg fogjuk változtatni!

Van még egy olyan rejtett állomány, aminek érdemes megjegyezni a nevét. Ez a .Trash. Igen a kuka. Ha a grafikus felületen valamit kidobunk a kukába, akkor azt a Finder ebbe a könyvtárba rakja. Ha bejelentkeztünk ateszt felhasználóhoz és kiadjuk a fenti második parancsot, akkor nagy valószínűséggel nem fogunk .Trash nevű könyvtárt találni. Vajon miért nem? Az nyert aki arra tippelt, hogy azért mert a teszt felhasználó grafikus felületén még nem dobtunk semmit a kukába, ezért a Finder még nem hozta létre ezt a könyvtárt. Nyissunk most egy másik Terminal ablakot, ott a saját felhasználói területünkön vagyunk, és adjuk ki ott is az utóbbi listázó parancsot.
Itt már nagy valószínűséggel megtaláljuk a .Trash nevű könyvtárt. (Ha mégsem akkor dobjunk valami feleslegeset a kukába a grafikus felületen.)
Ha az ls parancs után megadjuk egy könyvtár nevét, akkor annak a tartalmát fogja kilistázni, tehát az iménti esetben az

teszt: ls -l .Trash

parancs hatására látnunk kell a kukába dobott állományt, vagy állományokat.
Miért érdekes ez számunkra, hiszen a grafikus felületen a kukára kattintva sokkal egyszerűbben megkapjuk ugyanezt? Ez igaz, de aki sokat használja a gépét előbb utóbb találkozhat olyan esettel, amikor a kuka ürítése beragad, vagy nagyon sokáig kell várni, hogy végre megtörténjen a törlés (például már nagyon sok minden van a kukában). Vannak trükkök aFinderben is, de ha egyik sem segít, érdemes próbálkozni a Terminal-lal és megkisérelni innen törölni a .Trash könyvtár tartalmát.

Most már csak azt kellene tudni, ezt hogyan tudjuk megtenni! Ennek a cikknek a végére ez is kiderül.

Most gépünk olyan területein fogunk körülnézni ahol a Finder segítségével még nem jártunk (feltéve persze, hogy nem telepítettünk a Finder szolgáltatásait bővítő grafikus segédprogramokat …). Adjuk ki a

cd /

parancsot. Ezzel a fájlrendszerünk kezdőpontjába érkeztünk.

unix fájlrendszer úgynevezett fa struktúrában épül fel, ennek van egy kiindulópontja, amit gyökérnek (root) nevezünk. Innen ágazik ki minden:


De először nézzük meg mit találunk a root könyvtárban! Vannak itt a grafikus környezetből már jól ismert könyvtár nevek: Applications,SystemUsers, de van egy sor olyan könyvtár ahol a rendszer működését biztosító, segítő állományok, programok vannak. Például az

ls bin

a bin nevű könyvtár tartalmát fogja kilistázni (feltéve, hogy előtte a cdparanccsal beléptünk a root könyvtárba), ahol örömmel fedezhetünk fel ismerős parancs neveket: catdateechokillps. Aki kevésnek találja az itt látható program választékot, annak javaslom adja ki a következő listázó parancsot:

teszt: ls /usr/bin

… és ez még nem minden! Lehet még tovább keresgélni.
De tessék csak figyelmesen megnézni az iménti parancsot! Ebben két újdonság is van.

Az első az, hogy egy per (/) jel van a könyvtárnév elején.
A könyvtárnevet alapvetően kétféleképpen adhatjuk meg: vagy a per jellel kezdjük, vagy nem.

- Ha kirakjuk a per jelet, akkor a shell úgy értelmezi, hogy a gyökér könyvtárban kell keresni az utána következő könyvtárt – ezt nevezzük abszolút útvonal megadásnak.
- Ha viszont nem tesszük ki, akkor a shell abban a könyvtárban kezdi keresni a megadott könyvtárt, amelyikben éppen vagyunk – ezt nevezzük relatív útvonal megadásnak.

A kettő között tehát az a különbség, hogy az abszolút útvonal megadással mindig a gyökér könyvtártól indulunk, a relatív útvonal megadás viszont azt teszi lehetővé, hogy az éppen aktuális könyvtár pozíciónkból kiindulva keressük meg a könyvtárunkat.

A másik újdonság pedig az, hogy két könyvtárnév is szerepel az ls parancs után, és a kettőt szintén egy per jel választja el egymástól. A könyvtárstruktúrában egy ágon szereplő könyvtárnevek felsorolásával így egy, kettő, vagy akár több szinttel is feljebb található könyvtárakat is kijelölhetünk és természetesen nem csupán az ls, hanem más olyan parancsokban is, ahol valamelyik könyvtárra szeretnénk hivatkozni.

Akinek ez újdonság, az kérem hogy feltétlenül álljon meg itt egy kicsit, és végezze el a következő gyakorlatokat annak érdekében, hogy pontosan érthető legyen amiről most beszélünk:
- lépjen be a gyökér könyvtárba (cd /),
- lépjen be a Users könyvtárba (cd /Users),
- lépjen be a teszt könyvtárba (cd teszt),
- az ls paranccsal nézze meg, hogy ismerős helyen jár-e (ls -l),
- lépjen be innen egyszerre a usr könyvtárban található bin könyvtárba (cd/usr/bin),
- listázza ki innen ismét a teszt könyvtár tartalmát (ls -l /Users/teszt) és
- az aktuális könyvtár tartalmát is (ls -l) …

cd és az ls parancsok segítségével bejárhatjuk és feltérképezhetjük az egész fa struktúrát. (Csak emlékeztetőül: a d betűvel kezdődő sorokat kell keresnünk a listában, hogy megtaláljuk az alkönyvtárakat.).

A könyvtárstruktúrában való bolyongást megkönnyíti néhány hasznos dolog. Érdemes megjegyezni őket!
- Ha elkezdjük írni egy könyvtár, vagy fájl nevét majd megnyomjuk aTabulátor billentyűt, akkor a shell kiegészíti nekünk azt, feltéve, hogy a folytatás egyértelmű. Például elég beírni, hogy …

teszt: cd /A

megnyomni a Tab billentyűt és megkapjuk az Applications nevet (feltéve, hogy nincs másik A betűvel kezdődő állomány a gyökér könyvtárban).

- Ha éppen nem emlékszünk, hogy pontosan merre is járunk, van egy parancs, amelyik mindig megmondja ezt nekünk:

teszt: pwd

- A fa struktúrában mindig egyértelmű, hogy melyik az eggyel alattunk levő könyvtár (feltéve, hogy nem a gyökér könyvtárban vagyunk, hiszen ott már nincs alattunk semmi).
A következő paranccsal tudunk eggyel visszalépni:

teszt: cd ..

Igen, egyszerűen két ponttal lehet hivatkozni arra a könyvtárra, ami tartalmazza az aktuális könyvtárt. Ha ide belépünk és kilistázzuk, akkor láthatjuk annak a könyvtárnak a nevét a listában, ahonnan érkeztünk. Ezt lehet fokozni is, a

cd ../../

parancs két szinttel lép vissza a fa struktúrában.

- Akárhol is járunk, egy rövid parancs segítségével egyből haza tudunk jutni:

teszt: cd ~

hatására mindig az aktuális felhasználó saját könyvtárába tudunk belépni. Minden felhasználónak van egy saját könyvtára (Home), amit a rendszer nyilvántart, és belépéskor ez lesz az aktuális könyvtár. A teszt felhasználó esetében ez alapértelmezésben: /Users/teszt.

- A
teszt: cd -

parancs az előző helyünkre repít minket. Tehát a shell emlékszik, hogy az aktuális könyvtárba honnan léptünk be, és oda tudunk visszalépni ezzel a paranccsal.
Érdemes végiggondolni a három utóbbi parancs közötti különbséget!

- Egy meglepő változat a következő parancs:

teszt: cd ./

Ez tulajdonképpen nem csinál semmi mást, minthogy beléptet abba a könyvtárba, ahol éppen vagyunk! Ez első hallásra meglepőnek tűnhet, de például programok parancssori futtatásánál jól hasznosítható, hogy az aktuális könyvtárra így tudunk hivatkozni.

Már láttuk, hogy hogyan lehet megváltoztatni a prompt-ot. Most ismét módosítjuk egy kicsit, hogy folyamatosan lehessen látni, hogy melyik az aktuális könyvtár ahol éppen vagyunk. Adjuk ki a következő parancsokat:

teszt: cd ~
teszt: echo "export PS1=\"\w \u: \"" > .profile

Egy pici módosítás van a múltkorihoz képest, az eredmény mégis látványos lesz. Ha indítunk egy új Terminal ablakot és abban bejelentkezünk a tesztfelhasználóhoz, akkor a prompt mindig mutatni fogja az aktuális könyvtárt, tehát hogy éppen hol vagyunk.

Feltétlenül javaslom a fenti parancsok alapos kipróbálását, érdemes barangolni, körülnézni egy kicsit a fájlrendszerben és megtanulni, megszokni használatukat.

Törlés, építés – rm, mkdir

Aki most kezdi az ismerkedést a unix-szal, az feltétlenül jelentkezzen át a su paranccsal a teszt felhasználó területére és ott próbálgassa a következő parancsokat.
Amennyiben a saját területén próbálkozik valaki hasonló parancsokkal, különösen ha még admin jogosultsággal is rendelkezik, akkor könnyen előfordulhat, hogy számára fontos fájlokat elveszít és/vagy újra kell telepítenie az egész operációs rendszert a gépen!

Elég egyetlen karaktert elírni, egyetlen billentyűt félreütni és megtörténhet a baj. Érdemes kezdetben olyan területen gyakorolni, ahol nem tudunk kárt okozni.

Fájlokat már létre tudunk hozni (pl. dateidopont), de időnként szükség lehet a felesleges állományok törlésére. Erre szolgál az rm parancs:

teszt: rm idopont

Nem kérdez semmit, csak töröl, amennyiben az rm parancs után egy létező fájl nevét adtuk meg! Ez nem újdonság, láttunk már hasonlót, amikor állományokat kérdezés nélkül felülírt a shell.

Megjegyzés: a fájl nevét megadhatjuk teljes elérési útvonallal (abszolút megadás), tehát nem kell belépni abba a könyvtárba ahol a fájl található, hanem akárhol is vagyunk, bármelyik fájlt törölhetjük így egy lépésben, ha van hozzá jogosultságunk. Különösen kezdetben ezt NEM javaslom, könnyű elgépelni az elérési útvonalat és esetleg másik állományt törlünk a kívánt helyett. Biztonságosabb belépni az adott könyvtárba (cd), kilistázni annak a tartalmát (ls), és csak azután törölni ami felesleges.

teszt felhasználó saját könyvtárában ki lehet próbálni az rm parancs következő, igen hatékony változatát: ez minden fájlt ki fog törölni a könyvtárak kivételével. Tehát a

teszt: cd ~

paranccsal belépünk a teszt felhasználó saját könyvtárába, ahol csak tesztelésre szánt anyagaink vannak Ellenőrizzük is le:

ls -l

Ezután beírjuk, hogy:

teszt: rm *

A csillag azt jelenti a shell számára, hogy sorra veszi az összes állományt az aktuális könyvtárban és megpróbálja azokat törölni. A könyvtárakat nem törli ily módon, de a többit igen, tessék csak megnézni az eredményt ismét egy ls -l paranccsal. Most már csak csupa d-betűvel kezdődő sor maradt ha kiadtuk a fenti rm parancsot.

Ez egyrészt nagyon hasznos parancs ha sok mindent szeretnénk egyszerre törölni, másrészt viszont veszélyes is, hiszen ha nem figyelünk eléggé, könnyen beleeshetnek a szórásba fontos anyagok is!

Álljunk itt meg egy pillanatra. Ha már csak könyvtáraink maradtak, nézzük meg hogyan lehet újat létrehozni. Erre szolgál az mkdir (make directory) parancs:

teszt: mkdir minta1

Ez a parancs létrehozza a minta1 nevű könyvtárt. Próbáljuk ki most az

teszt: mkdir minta2/minta3

parancsot.
Erre egy hibaüzenetet kapunk, amennyiben a minta2 nevű könyvtár nem létezik. A probléma könnyen orvosolható két lépésben: először hozzuk létre a minta2 könyvtárt, és azután adjuk ki ismét az előző parancsot.

unix azonban szereti a kényelmes megoldásokat, ezért most is egyszerűsíthetjük a munkát, ha ismerjük a p opciót. A következő parancs

teszt: mkdir -p minta/minta/minta/minta

már automatikusan létrehozza a közbülső könyvtárakat is amennyiben azok nem léteznének.

Próbáljuk most kitörölni az imént létrehozott minta1 könyvtárt. Már láttuk, hogy ha kiadjuk az rm minta1 parancsot, a shell nem fogja kitörölni, hanem figyelmeztet, hogy könyvtárról van szó! Semmi gond, akkor mondjuk meg neki, hogy könyvtárt kell törölni és használjuk a d(directory) opciót:

teszt: rm -d minta1

Kész, a minta1 könyvtár törölve, figyelmeztetés nem volt!

Megjegyzés: könyvtárak törlésére szolgál az rmdir parancs is.

Ezen felbuzdulva próbáljuk ki a következő parancsot:

rm -d minta

Megint csak hiba üzenetet kapunk, most az a baj, hogy a minta nevű könyvtár nem üres. Mit lehet ilyenkor tenni? A cd paranccsal belépünk a legbelső könyvtárba, ott mindent törlünk, visszalépünk egyet a cd ..paranccsal és töröljük a könyvtárt a d opcióval. Ezt addig folytatjuk amíg mindent töröltünk, amire nincs szükség a továbbiakban.
Hát ez így elég unalmas, főleg ha sok tisztogatni valónk van. Természetesen ezt is lehet egyszerűbben csinálni, mégpedig az R(recursive) opció segítségével. (Az opciók megadásánál fontos figyelni a kis- és a nagybetűkre!). Az

teszt: rm -R minta

parancs akkor is kitörli a minta nevű könyvtárt, ha az nem üres! Természetesen mindent töröl, ami benne volt. Kérdezés nélkül és nincs visszalépési lehetőség. Könnyű hozzászokni az R opció használatához, hiszen sokkal kényelmesebb, mint lépésről-lépésre törölgetni mindent. Viszont nagyon veszélyes is lehet ha figyelmetlenül használjuk, különösen ha még a *- gal is kombináljuk! Nagyon könnyen eltüntethetünk fontos állományokat!

Emlékeztetnék a beépített manuálok használatára, az rm parancs feltétlenül megérdemli, hogy alaposabban is tanulmányozzuk (man rm).

Felhasználók

unix egyik legnagyobb erőssége, hogy kezdetektől fogva többfelhasználós rendszerként fejlesztették, így lehetőség van arra, hogy ugyanazt a gépet többen is használhassák úgy, hogy közben saját adataik védve legyenek, ugyanakkor meghatározott adatokat, programokat többen is használhassanak, megoszthassanak egymással.

Biztonsági szempontból még akkor is nagyon hasznos lehet legalább két felhasználót létrehozni a gépünkön, ha azt csak egyedül használjuk. Amikor először telepítjük a Mac OS-t, akkor létrehozunk egy felhasználót, akiadminisztrátori jogosultságokkal is rendelkezik. Ha létrehozunk egy másik felhasználót is, akinek nem adunk admin jogokat, és azt használjuk mindennapi munkánk során, akkor nem érhet olyan meglepetés minket, hogy pl. egy képet szeretnénk megnyitni, ami valójában csak egy képnek álcázott program, és kattintásunk eredményeképpen automatikusan kitöröl egy sor rendszerállományt, vagy összekavarja azok hozzáférési jogosultságát.

Megjegyzés: ha jelenleg csak egy felhasználónk van a gépen, arról is levehetjük az admin jogosultságot. Ehhez csak azt kell tenni, hogy létre kell hozni egy másik felhasználót és annak bejelölni az admin jogosultságot (System Preferences >AccountsAllow user to administer this computer) és ezután már megengedi a rendszer, hogy a mindennapok során használt felhasználónkról levegyük azt.
Ez a beállítás csupán olyan “kellemetlenségekkel”jár, hogy programok telepítésekor, fájlok törlésekor, könyvtárak megnyitásakor gyakrabban kapunk egy felszólítást, hogy azonosítsuk magunkat, tehát egy felhasználó (admin) nevet és jelszót kér a rendszer mielőtt az adott műveletet végrehajtaná. Ugyanakkor éppen ez jelenti a nagyobb biztonságot, hiszen van időnk és lehetőségünk eldönteni, hogy engedélyezzük-e az adott műveletet, vagy sem.

Jogosultságok

A hozzáférési jogosultságok azt határozzák meg, hogy a gépen levő állományokkal, programokkal ki mit csinálhat, illetve mit nem. Ezt a unixalapból széleskörűen szabályozza, de az Apple még rátett egy lapáttal, amikor bevezette az ACL (AccessControl Lists) rendszert. De ez már inkább rendszer-adminisztrátorok számára érdekes és fontos terület, mi most nézzük meg kicsit részletesebben a jogosultságok alapjait.

Már láttuk, hogy az ls parancsot az l opcióval megadva, egy részletes listát kapunk a vizsgált könyvtár tartalmáról. Jó lenne megérteni ezen lista egyes részeinek a jelentését.
Kezdjük egy kis ismétléssel! Lépjünk be kedvenc teszt felhasználónk területére, hozzuk létre itt a jogosult nevű alkönyvtárt, abba belépve aminta nevű fájlt (aminek tartalma most lényegtelen) és listázzuk ki az újonnan létrehozott könyvtár tartalmát. Egy lehetséges megoldást mutat a következő ábra:


A lista eredménye pedig így néz ki:

-rw-r--r-- 1 teszt teszt 6 Jul 25 12:01 minta

Kezdjük a végéről: a jobb oldalon látható az új könyvtárban levő egyetlen fájl neve: minta.

Előtte áll egy dátum, ami a minta fájl módosításának dátuma. Kezdetben természetesen ez a létrehozás dátuma, később viszont, ha módosítjuk a fájlt, akkor ez a dátum is meg fog változni. Ellenőrizzük például úgy, hogy hozzáfűzünk egy új szót: echo mente >> minta és listázzuk ki ismét a könyvtárt.

Érdekes megjegyezni, hogy a touch paranccsal is létre lehet hozni új (üres) fájlt. Ha a -t opcióval hívjuk meg, akkor pedig tetszés szerint módosíthatjuk a fenti módosítási dátumot. Például a

teszt: touch -t 200606011201 minta

parancs 2006. június 1. 12 óra 1 percre állítja a dátumot. Akit ez részletesebben is érdekel, javaslom a manuál fellapozását: man touch.

A dátum előtt álló szám a fájl mérete bájtokban. Jelen példában éppen 6, de ez nyílván függ a fájl tartalmától.
A fájlméret előtt kétszer is látható a teszt szó. Nos ez nem azért van, mert a unix dadog, hanem ez két különböző dolgot jelöl. Az első a minta fájltulajdonosát, a második pedig a csoportját mutatja meg. A tulajdonos az érthető, hiszen a teszt felhasználó területén tevékenykedünk, logikus, ha az itt létrehozott új állomány az ő tulajdonába kerül. A csoport már kicsit érdekesebb.

Egy nagyobb unix rendszeren lehetséges, hogy nagyon sok felhasználó van. Hasznos lehet, ha őket csoportokba tudjuk rendezni. Az egy csoportba tartozó felhasználók például láthatják a közös fájlok tartalmát, azok közül egyeseket bárki módosíthat és/vagy futtathat is a csoport tagjai közül. A csoportokba sorolást rendszer-adminisztrátori jogosultságokkal lehet elvégezni.

A felhasználó neve előtt is van egy szám, ez is megérdemel néhány gondolatot. Úgy hívják, hogy láncszám (linkcount). Kezdetben az értéke 1.
Adjuk ki most a következő parancsokat:

teszt: ln minta k-minta
teszt: ln -s minta l-minta

majd listázzuk ki a könyvtár tartalmát. Látszólag most van két újabb fájl, és több apróság is megváltozott a listában. Ha a cat paranccsal kilistázzuk őket, azt tapasztaljuk, hogy mind a három fájlnak pontosan ugyanaz a tartalma! Az első parancs létrehozott egy úgynevezett linket (hardlink) aminta fájlról. Ennek az az értelme, hogy a minta nevű fájl a k-minta névre is hallgat. (Természetesen a k-minta helyett bármilyen más nevet is adhattunk volna.) Ugyanaz a fájl tehát különböző nevek alatt is elérhető aunix-ban. Ha összehasonlítjuk a minta és a k-minta sorát a listában, láthatjuk, hogy csak a névben különböznek egymástól. A láncszám viszont megváltozott, 2-re növekedett. Ha egy újabb linket is létrehozunk hasonló módon a minta fájlra, akkor már 3-ra fog növekedni a láncszám és ezen az újabb néven is elérhetővé válik ugyanaz a fájl. Több előnye is van ennek a technikának. A bevezetőben említettem, hogy a unix-nak nagyon sok fajta ága van, és ezek mindegyike folyamatosan fejlődik. Előfordul az is, hogy átvesznek egymástól bizonyos megoldásokat. Ennek lehet olyan következménye, hogy ugyanazzal a névvel kellene elnevezni egy újonnan bevezetett fájlt, mint ahogy a mi rendszerünkben korábban már egy másikat elneveztünk. Az ilyen névütközéseket fel lehet oldani a linkeléssel. Ezen kívül ügyes technikákkal jelentős helymegtakarítás is elérthető használatával.

A második link egy kicsit különbözik ettől, ezt a -s opcióval adtuk meg, ésszimbolikus (vagy soft) linknek nevezik. Ez egy új fájlt hoz létre, ami azonban csak egy mutató fájl, megmutatja, hogy hol van az eredeti, amire szeretnénk hivatkozni. Ennek a mérete is kisebb, és a lista elején álló betűk is megváltoztak. A szimbolikus link sora egy l betűvel kezdődik a listában. A szimbolikus link később alakult ki a unix fejlődése során, és szélesebb körben, bonyolultabb fájlrendszerek esetében is használható.
A lényeg itt is az, hogy ugyanazt a fájlt többféleképpen is elérhetjük.

szimbolikus link egyik legfőbb előnye a hard linkkel szemben, hogy például ha behelyezünk egy DVD-t a meghajtónkba, akkor arról is belinkelhetünk fájlokat a saját könyvtárunkba, vagy ahová szeretnénk.
Ha a DVD-t kivesszük, akkor persze hibajelzést kapunk amikor egy onnan belinkelt fájlra hivatkozunk, de később ha visszatesszük azt, akkor már ismét működni fog!

Megjegyzés: A szimbolikus link legjobban arra hasonlít, amikor a Grafikus felületen a “Make alias” paranccsal készítünk egy mutatót egy tetszőleges fájlra.

Szövegek olvasása – more, less, head, tail, wc

Ha hosszú állományokat szeretnénk olvasgatni, nagyon kellemes parancs a more:

teszt: more text-fájl

(A text-fájl lehet pl. egy ReadMe fájl, egy log-fájl, vagy éppen egy saját dokumentum is.)
Ez kiírja a fájl elejét, de csak annyi sort, amennyi éppen kifér az aktuális Terminal ablakban. Ha nagyobb ablakot nyitunk, akkor többet ír ki. Lapozni egyszerűen a szóközbillentyű nyomogatásával lehet. A bal alsó sarokban azt is láthatjuk, hogy az állomány hány százalékát néztük meg eddig.
Kicsit bajban vagyunk, ha nem emlékszünk pontosan, hogy mit olvastunk az előző oldalon, visszalapozni ugyanis nem tudunk vele, tehát ki kell lépni (q-billentyű, vagy ctrl+c – ezeket már jól ismerjük!) és kezdhetjük elölről.
Aki többre vágyik, ismerkedjen meg a less paranccsal!

teszt: less text-fájl

Lapozni itt is a szóköz billentyűvel lehet előre, visszafelé pedig például a b billentyűvel(backward).

A

teszt: less -?

parancs egy mindig kéznél levő segítség. Megmutatja, hogy milyen billentyű kombinációk segítségével, hogyan tudunk lépkedni, ugrálni, keresni a fájlban előre, hátra soronként, oldalanként, fél oldalanként, hogyan lehet a fájl elejére, végére ugrani és még sok minden mást. Fontos tulajdonsága, hogy nagy méretű fájlokat, például log-fájlokat is gyorsan és hatékonyan lehet nézegetni a segítségével. Nagyon hasznos kis program állományok nézegetésére.

Előfordul, hogy csak a fájl első, vagy utolsó néhány sorára vagyunk kíváncsiak. Erre van közvetlen megoldás is, a

teszt: head -n 2 text-fájl
teszt: tail -n 7 text-fájl

parancsok rendre a text-fájl első kettő, illetve az utolsó 7 sorát listázzák csak ki.

És ha már itt tartunk, akkor ne feledkezzünk meg a wc (word … count) programról sem! A

wc -c text-fájl
wc -w text-fájl
wc -l text-fájl

parancsok rendre megmondják, hogy a text-fájl-ban hány karakter, mennyi szó és hány sor van.

Jogosultságok folytatás: chmod

Ezután a kis kitérő után térjünk vissza az ls -l lista értelmezéséhez. Most már csak a lista elején álló 10 karakter magyarázata maradt hátra.

-rw-r--r-- 1 teszt teszt 6 Jul 25 12:01 minta

Az első karakter mutatja a fájltípust: általános fájl esetében egy kis vonalat találunk itt, könyvtár esetében d-betűt, a szimbolikus linket pedig egy l-betű jelöli. Ezek a legfontosabbak, ezekkel már találkoztunk is.
A következő 9 karaktert pedig 3-szor 3-as bontásban kell nézni: az első 3 karakter a tulajdonosra vonatkozik, a második 3-as a csoportra, a harmadik pedig a többiek hozzáférési jogosultságait mutatja. Három betű szerepelhet itt: az r, a w és az x.
Ezek a Read, a Write és az eXecute szavakból származnak, magyarul: olvasás, írás és végrehajtás. A következő, konkrét példák megvilágítják ezen kódok jelentését. Ha az adott betű látható, akkor a jogosultság él, ha csak egy kis vonal helyettesíti, akkor tiltva van.
A minta fájl első 3-as csoportjában szerepel az r és a w betű, ez azt jelenti, hogy a minta fájl olvasható és írható a tulajdonosa (teszt nevű felhasználó) által. A másik két hármas csoportban csak egy-egy r betű található, ez azt jelenti, hogy a teszt nevű csoport tagjai és mindenki más is csak olvashatja ezt a fájlt.

Adjuk ki most a

teszt: chmod u-r minta

parancsot. A chmod (change mode) parancs segítségével megváltoztathatjuk a jogosultságokat. Az u betű a user (felhasználó) rövidítése, így a fenti parancs azt jelenti, hogy vegyük el a felhasználótól az olvasási jogot.
Most egy érdekes helyzet állt elő: a tulajdonos nem tudja olvasni a fájlt, tessék csak kipróbálni a cat minta parancsot! Az eredmény “Permission denied“, azaz a jogosultság megtagadva. Ugyanakkor a többieknek van olvasási joga a fájlhoz, tehát ha egy másik Terminal ablakból, ahol nem vagyunk bejelentkezve a teszt felhasználóhoz, kiadjuk a

cat /Users/teszt/jogosult/minta

parancsot, akkor már el tudjuk olvasni annak a tartalmát.

Megjegyzés
: ehhez a “jogosult” könyvtár megfelelő beállítása is szükséges, hamarosan látni fogjuk ezt is!

Szeretnénk visszaadni a tulajdonosnak az olvasási jogosultságot? Egyszerű, a fenti parancsban csak egy plusz jelet kell írni:

teszt: chmod u+r minta

Ha az u-betű helyett g, illetve o jelet írunk, akkor a csoport (group), illetve a többiek (other) beállításait tudjuk megváltoztatni.
Ha mindenkitől el szeretnénk venni az olvasási jogosultságot, akkor az a betűt használhatjuk (all):

teszt: chmod a-r minta

Ekkor senki sem tudja olvasni a fájl tartalmát, mindaddig amíg vissza nem állítjuk az olvasási jogosultságot valamilyen formában.

A fájlra vonatkozó írás jogosultságokat ugyanígy tudjuk állítani. Ha elvesszük a tulajdonos írás jogosultságát, akkor nem tudja módosítani a fájl tartalmát. Próbáljuk ki:

teszt: chmod u-w minta

Vajon mi történik a

echo masik >> minta

parancs hatására? Bizony csak egy hiba üzenetet kapunk: nincs jogunk ezt megtenni.

Szövegszerkesztés: pico, nano

Eléggé fapados volt, ahogy a fájlok tartalmát eddig változtatgattuk. Az kétségtelen, hogy a kimenet átirányítása egy nagyon hasznos művelet a unix-ban, de jó lenne már valami közvetlen módszert is látni fájlok tartalmának szerkesztésére, hiszen a unix messze földről híres a fájlok manipulálásában.
A klasszikus file editor az un. vi (kimondva: viáj) program, amit sokan nem kedvelnek, mert nagyon nehézkes a használata. Azért érdemes róla tudni, hogy sokáig ez volt az editor program. Az igaz, hogy rengeteget kell tanulni ahhoz, hogy valaki hatékonyan és jól tudja használni, de aki megtanulta és nap, mint nap használja, az rá se néz más hasonló programokra. Rengeteget tud és kiválóan programozható.
Mindez persze nem vigasztalja azokat, akik nem napi rendszerességgel használják a unix-ot. Nekik valóban értelmetlen ezzel bíbelődni. Aki mégis kíváncsi rá, annak jó hír, hogy most már van egy továbbfejlesztett változata is: vim (a man vim paranccsal érdemes kezdeni az ismerkedést).

Az egyik legjobban elterjedt, legemberbarátibb unixos szövegszerkesztő program a pico, vagy új nevén a nano. (A Tigris, Leopard, Snow Leopard és a Lion alatt is mindkét néven elérhető.) Ha kiadjuk a

teszt: nano minta

parancsot, akkor az aktuális Terminal ablakunkat birtokba veszi a szövegszerkesztő program, kilistázza a kérdéses fájlt és nagyon egyszerűen módosíthatjuk azt. A nyíl billentyűkkel mozoghatunk a szövegben fel, le, jobbra, balra, a delete billentyűvel törölhetünk a kurzortól balra, ha lenyomunk egy karakter billentyűt, akkor a megfelelő karakter megjelenik a kurzor helyén. Egyszóval éppen úgy működik, ahogy azt egy karakteres szövegszerkesztőtől elvárja az ember. A Terminal ablak alján állandóan láthatjuk a leggyakrabban használt billentyű parancsokat.
Például a ctrl+w-t lenyomva kereshetünk a szövegben: csak meg kell adni a keresendő karaktersorozatot, majd Enter és a kurzor máris ott villog a keresett rész első előfordulásának helyén. Ha ismét megnyomjuk a ctrl+w-t, majd az Enter-t, akkor a kurzor a következő találati helyen villog.

Amikor készen vagyunk a szükséges javításokkal, akkor a ctrl+x billentyűkombinációval léphetünk ki a nano programból. Ekkor a Terminal képernyő alján levő párbeszédre kell figyelni. Megkérdezi a program, hogy el akarjuk-e menteni a változtatásokat.
Lehetőség van itt visszalépni:
- ha megnyomjuk az n gombot (No), akkora program kilép és a fájl marad az eredeti állapotában, a változtatások elvesztek,
- ha viszont szeretnénk elmenteni a módosításokat, akkor az y gombot (Yes) kell megnyomni.

Az utóbbi esetben felajánlja azt, hogy a változtatásokat a korábbi fájlnév alatt menti el, vagy meg is változtathatjuk azt, ha új néven szeretnénk menteni, megőrizve a régi állományt is.

Aki becsülettel követte a fenti sorokat, annak a mentés ugyanazon a néven nem fog sikerülni! Ugyanúgy, mint a fenti átirányításnál, ami felülírta volna a minta fájlt, most is csak egy hiba üzenetet kapunk, hogy ehhez bizony nincs jogosultságunk.
Nagy gond azért nincs, elmenthetjük más néven, vagy pedig nyithatunk egy másik Terminal ablakot, ahol visszaállítjuk az írásjogot (chmod u+w minta) a fájlra, és azután már el tudjuk menteni a nano programon belül is az eredeti nevén!

Érdemes próbálkozni, gyakorolni, hamarosan használni is fogjuk új ismerősünket! Akinek a vim és a nano nem elég, javaslom a “terminal text editors” keresést a Google-ban, és kedvére lubickolhat a találati listában amíg megtalálja szíve választottját. Van miből válogatni bőven …

Jogosultságok folytatás: futtatható fájlok

Van még egy harmadik jogosultság, amit nem vizsgáltunk eddig. Ha az x betű látható a listában, akkor az azt jelenti, hogy a fájl végrehajtható, vagy úgyis mondhatjuk, hogy futtatható. Na de mi értelme van, hogy például a minta fájlt futtassuk. Semmi! Hiszen ez csak egy szöveges fájl. Hát akkor írjunk egy programot, azt már érdemes lesz futtatni! Legyen a neve, mondjuk udv és ha lefuttatjuk, akkor írja ki a képernyőre, hogy: Most nagyon meleg van!

Kezdjük a programozást úgy, hogy:

teszt: nano udv

A szövegszerkesztő segítségével gépeljük be pontosan a következő két sort:

#!/bin/sh
echo "Most nagyon meleg van!"

majd mentsük el és adjunk neki futás jogot:

teszt: chmod u+x udv

Ha sikerült és kilistázzuk, akkor a megfelelő sorban ezt látjuk:

-rwxr--r-- 1 teszt teszt 40 Jul 25 12:02 udv

Látjuk, hogy megjelent az x-betű a tulajdonos jogait mutató első karakter-hármasban.
Hogyan lehet futtatni ezt a programot? Biztosan mindenki emlékszik rá, már utaltam erre: egyszerűen a neve elé kell egy pontot és egy törtvonalat írni:

teszt: ./udv

és persze Enter. Máris lefuttattuk első shell programunkat, vagy más néven shell script-et!

./ megmondja a shell programnak, hogy az aktuális könyvtárban keresse azt a programot, aminek a neve az udv, tehát csupán meg kell mondani neki, hol van a futtatható program. Ezt megtehetjük kicsit hosszabban is, megadhatjuk a program abszolút elérési útvonalát is:

teszt: /Users/teszt/jogosult/udv

Az eredmény most is ugyanaz lesz ha a sor végén lenyomjuk az Enter-t. Ezt a hosszabb útvonal megadást bárki megteheti a gépen. Például nyithatunk egy új Terminal ablakot, ahol nem vagyunk teszt felhasználóként bejelentkezve, és ott is beírhatjuk, hogy:

akarki: /Users/teszt/jogosult/udv

Ekkor a jól ismert hiba üzenet következik, nincs jogosultságunk a fenti program futtatásához! Semmi gond, a teszt felhasználós Terminal-ban adjuk ki

chmod a+x udv

parancsot. Most már működni fog a másik Terminal-ban is az udv program, hiszen mindenkinek megadtuk a futtatási jogot.

Megjegyzés: A chmod parancsban a jogosultságokat egy oktális számhármas segítségével is beállíthatjuk. Pl. a chmod 644 minta egyből visszaállítja a kezdeti beállításokat, akármit is ügyködtünk időközben a chmod paranccsal.

Futtatható könyvtárak!?

Nos aki azt gondolja, hogy most már mindent ért az nézze meg, hogy a  jogosult könyvtár milyen jogosultságokkal rendelkezik! Lépjünk be a teszt felhasználó Home könyvtárába (cd ~) és listázzuk ki azt:

drwxr-xr-x 9 teszt teszt 306 Jul 25 12:03 jogosult

Odáig rendbe van, hogy d-betűvel kezdődik, hiszen könyvtár, de mit jelent az a sok x-betű a jogosultságok listájában. Nem akarjuk mi futtatni a könyvtárt, mi értelme lenne annak? Vegyük is le gyorsan a futásjogot (chmod a-x jogosult), majd lépjünk be. Az eredmény elszomorító:

Permission denied

… a belépés megtagadva. Adjunk most csak magunknak futtatási jogot (chmod u+x jogosult):

drwxr--r-- 9 teszt teszt 306 Jul 25 12:04 jogosult

Húúú, fellélegezhetünk, most már beenged, és láthatjuk, hogy minden változatlan a könyvtáron belül. A shell script-ünk futtatható, mindent látunk, módosíthatunk.

Adjuk meg ismét mindenkinek a futtatási jogot a script-re (chmod a+x udv). Próbáljuk futtatni a másik Terminal-ból, a másik felhasználó területéről, a teljes elérési úttal.
Az imént ez még működött. De most nem! Mert a script-et tartalmazó könyvtáron csak a tulajdonosnak van futtatási joga, másoknak nincs. De innen nem csak futtatni nem tudjuk, olvasni, írni sem, még akkor sem, ha mindenkinek mindent engedélyezünk:

-rwxrwxrwx 1 teszt teszt 40 Jul 25 12:05 /Users/teszt/jogosult/udv

Érdemes kipróbálni!

chmod parancs használható a -R opcióval is. Ha ezt használjuk, akkor fokozottan ügyeljünk, mert a kiindulási könyvtártól lefelé az összes alkönyvtárban is elvégzi a megadott beállításokat, ami nem mindig a várt eredményt szolgáltatja. Korábban már találkoztunk a * (csillag) karakter használatával. A chmod -R u-r * parancs az aktuális könyvtártól kezdve abban, és minden alkönyvtárában az összes könyvtár és fájl esetében törli az olvasási jogosultságot.

Az alkönyvtárak elérhetetlenek lesznek! Az eredeti állapot visszaállítása pedig bonyolultabb fájlstruktúra esetében nem biztos, hogy egyszerű, vagy szinte lehetetlen a rendszer újratelepítése nélkül!

A Disk Utility program Permission repair opciója a szabványos hozzáférési jogosultságokat próbálja visszaállítani a rendszeren, ha azok esetleg megsérültek. Rendszerfrissítések előtt azért is érdemes lefuttatni ezt a programrészt, hiszen látható, hogy nem megfelelő beállítás esetén előfordulhat, hogy az új rendszer egyes részeit igen, másokat viszont nem tudja felrakni a telepítő, ami kisebb-nagyobb problémákat okozhat.

Mozgatás, másolás: mv, cp

Idáig sokfajta fájl műveletet megismertünk, de a kép még korántsem teljes. Fájlokat átnevezni az mv (move) paranccsal lehet. Két változat van, az egyik esetben megadjuk a fájl nevét és az új nevet:

teszt: mv fajlnev ujnev

a másik változatban pedig egy könyvtárnevet adunk meg, ahová átmozgatjuk a fájlt:

teszt: mv fajlneve konyvtarnev

Az utóbbi esetben a második operandus egy létező könyvtár neve kell, hogy legyen.
A neveket megadhatjuk abszolút, vagy relatív útvonal megadással is.

Ahogy már korábban is említettem, figyelni kell a nevek megadására. Az mv fajlnev ujnev parancs rákérdezés nélkül felülírja az “ujnev” nevű fájlt, ha az már létezik, így annak eredeti tartalma már nem lesz visszaállítható.

A

teszt: mv *.jpg kepek

parancs az összes .jpg kiterjesztésű fájlt átmozgatja a kepek nevű könyvtárba. A csillag karakterrel, az úgynevezett helyettesítő karakterrel már többször találkoztunk. Helyébe bármilyen karaktersorozatot képzelhetünk.

Megjegyzés: Érdemes megjegyezni, hogy ha közben ugyanazon a partíción maradunk, akkor a fájl elhelyezkedése fizikailag nem változik meg a diszken, csak az elérési útvonal lesz más. Ezért van az, hogy nagy méretű fájlok mozgatása is pillanatok alatt megtörténik.

cp (copy) parancs annyiban különbözik az előzőtől, hogy fizikailag is készít egy másolatot. A fájl az eredeti nevén és az új néven is elérhető lesz. Ugyanaz a két alapváltozata van, mint az előbbi parancsnak.
A

teszt: cp A* Documents

parancs az összes A-betűvel kezdődő fájlról készít egy másolatot a Documents nevű könyvtárba.

A
teszt: cp egyik/* masik

parancs az egyik könyvtárból minden fájlt átmásol a masik könyvtárba. Ha az egyik könyvtár alkönyvtárakat is tartalmaz, azok nem lesznek így átmásolva. A jól ismert -R opció ezt is megoldja, a

teszt: cp -R egyik/* masik

parancs már az egyik könyvtár teljes tartalmát átmásolja a másik könyvtárba, feltéve ugye, hogy van hozzá jogosultságunk.

Keresés: find, locate, grep

A legsokoldalúbb unix parancsok egyikével ismerkedünk most meg és közben felelevenítünk néhány korábban tanult fontos jelölést is. A find szó annyit tesz angolul, hogy megtalál. Nézzük meg mire juthatunk a segítségével, bátran próbáljuk ki a következő parancsokat:

teszt: find ~ -name "*.txt

Megtalálja a saját könyvtárunkban az összes olyan fájlt, amelyik végződése: txt.

Az *alma* opció hatására az összes olyan nevet keresi, amiben szerepel az alma szó.

A
teszt: find . -name "*.txt

változat az aktuális könyvtárban és annak alkönyvtáraiban keres,
a

teszt: find / -name "*.txt

pedig az egész fájlrendszert végignézi a txt-végű fájlok keresése érdekében. Nagyobb rendszerek esetében ez kicsit hosszabb ideig is eltarthat, ugyanis a find valós idejű keresést végez, nem használ adatbázist, nem indexel, emiatt mindig az aktuális eredményt szolgáltatja.

Megjegyzés: gyorsabb eredményt kaphatunk a locate paranccsal, ami viszont a legfrissebb fájlokat nem biztos, hogy megtalálja (man locate).

Még néhány tanulságos példa:

teszt: find . -empty

Megkeresi az üres fájlokat az aktuális könyvtártól kezdve.

teszt: find ~ -newer valami.fajl

Megtalálja a valami.fajl-nál újabb állományokat a saját tárterületünkön.

teszt: find / -mmin -10

Megtalálja azokat a fájlokat a rendszeren, amik 10 percen belül módosítva lettek.

Figyelem, a helyzet melegszik!

teszt: find . -name "*.sh" -exec chmod a+x {} \;

Az aktuális könyvtártól lefelé megkeresi az összes sh kiterjesztésű fájlt és beállítja a mindenkire vonatkozó futtatási jogot mindegyikre.

teszt: find /Users/Valaki/Sites -name "*.txt" -exec cat {} \;

A Valaki felhasználó Sites könyvtárától kezdve megkeresi az összes txt végződésű fájlt és kilistázza azokat. Átirányítással ( > ) akár egyetlen text fájlba is összefűzhetjük őket.

És most tessék vigyázni!

teszt: find / -name "*torolheto*" -delete

Megkeresi a rendszerben az összes olyan fájlt aminek a neve tartalmazza a “torolheto” szót és rögtön ki is törli azokat amennyiben a find parancsot futtató felhasználónak jogosultsága van ehhez!

És ez csak egy kis ízelítő volt a find parancs által nyújtott lehetőségek széles tárházából.

Lehet finnyáskodni, hogy a Spotlight az a fájlok belsejében is tud keresni. Nos, erre is van megoldás a unix-ban is.

Egy szöveges fájlban a

teszt: grep keresőszó text-fájl

parancs segítségével megkereshetjük azokat a sorokat, ahol a “keresőszó” karaktersorozat található.
Nem egy szóra keresünk rá, hanem egy karaktersorozatra, ami akár egy szó része is lehet.

Ha a fájlnév helyett a csillag helyettesítőkaraktert alkalmazzuk, akkor már sokkal több találatunk is lehet, mivel a program az aktuális könyvtárban található összes fájlt végignézi:

teszt: grep keresőszó *

A parancs ekkor kiírja az összes találatot: a fájl nevét és azt a sort, ahol a keresett karakterlánc található.

Tovább növekedhet a találatok száma, ha még a -R opciót is megadjuk, mivel ekkor a keresést az aktuális könyvtártól lefelé az összes alkönyvtárban is elvégzi:

teszt: grep keresőszó -R *

Ha a karakterlánc több szóból áll, akkor idézőjelek közé kell azokat tenni.

Megemlítem, hogy a reguláris kifejezések használatával nagyon hatékony keresésekre van lehetőség.

Például a

teszt: grep [0-9] text-fájl

parancs hatására megkapjuk a fenti fájl azon sorait, amelyikben szám karakter szerepel. Itt a szögletes zárójelen belül megadtuk a keresett karakterek egy tartományát. Fel is sorolhattuk volna 0-tól 9-ig a számjegyeket, de így nyílván elegánsabb. A [39] reguláris kifejezést használva azokat a sorokat tudnánk megkeresni, amelyekben a 3-as, vagy a 9-es karakter szerepel.

A reguláris kifejezések iránt érdeklődők számára ajánlom például a következő oldalt:

http://www.regular-expressions.info

Akik gyakran használják a grep parancsot hasznos segítséget jelenthet a grep parancs két változata: az fgrep és a cgrep (lásd. man page).

Folyamatvezérlés: pipe

A pipe ige angolul annyit tesz, hogy “csövön át továbbít“. Ezt nem nehéz elképzelni, de hogy ennek a technológiának a segítségével a unix mi mindenre képes, az még több éves gyakorlattal rendelkezőknek is tud meglepetést okozni.
Nézzünk először egy egyszerű példát. Korábban láttuk, hogy a ps parancs kilistázza az aktuálisan futó processzeket. Előfordulhat, hogy ez a lista akár több képernyőoldalt is betölt és ha meg kell találni benne egy adott processzt, az nem is olyan könnyű feladat. Például a Safari beragadt, és szeretnénk a kill paranccsal kilőni. Ehhez szükségünk van a processz azonosítóra (PID), ami a ps lista első oszlopában szerepel. Ilyenkor a ps parancs eredményét bevezetjük egy képzeletbeli csőbe, az onnan kilépő sorokat a grep paranccsal megvizsgáljuk, és csak azt a sort, vagy azokat a sorokat íratjuk ki, amikben a Safari szó szerepel. Elmondani sokkal bonyolultabb, mint megvalósítani:

teszt: ps -ax | grep Safari

Általában két eredményt is kapunk, az egyik a Safari program, a másik pedig a “Safari” karaktersorozatot kereső grep parancs, hiszen ennek a sorában is szerepel a Safari szó.
A megvalósításhoz pedig mindössze annyit kellett tenni, hogy a ps, illetve agrep parancsot összekapcsoltuk a pipe jellel (|). Emiatt a ps parancs eredménye nem jelenik meg közvetlenül a képernyőn, hanem át lett irányítva a csővezeték segítségével a grep parancs számára, mintha az egy fájlt olvasna, és abban keresgélne.

Nagyon egyszerűen megszámolhatjuk, hogy éppen hány futó processzünk van. A ps parancs eredményét most a wc parancs számára kell átvezetnünk, és az rögtön megszámolja a beérkező sorok számát:

teszt: ps -x | wc -l

Megjegyzés: bár a fenti példában a két függőleges vonal karakter nagyon hasonló,  mégsem ugyanaz. Az első a pipe jel, ami általában a jobb oldali shift billentyű felett található a billentyűzeten, a második pedig a line szó kezdőbetűje, tehát egy l-betű.

Még az elején mutattam egy példát, ami akkor még talán meglepő és egyben megdöbbentő is lehetett azok számára, akik először találkoztak hasonlóval. Abból is látható, hogy a csövezetékek egész hálózatát lehet felépíteni, így szinte röptében lehetséges unix parancsok sorozatát elvégezni egymás után, úgy hogy az előző eredményét rögtön átvezetjük a következő parancs bemeneteként és máris elvégezzük rajta a következő műveletet:

teszt: cat a* | awk '{print $2}' | sed s/[^a-zA-Z]//g | tr '[a-z]' '[A-Z]' | sort | uniq | cat -n

Nézzük ennek egy rövid magyarázatát.
cat paranccsal fájlokat listázhatunk. A csillag karakter helyettesítő karakter, tehát az összes a-betűvel kezdődő fájlt kilistázzuk és elvégezzük rajtuk a következő parancsokat.
Az awk egy nagyon sok mindent tudó folyamatkezelő parancs, amelyik lehetővé teszi a sorok egyes részleteinek keresését, átrendezését, azokon végzett összetett műveletek elvégzését. Itt éppen kiválasztja a bemenetére érkező sorok második szavát és csak azt továbbítja a következő parancs bemenetére.
sed egy folyamat szövegszerkesztő, ami úgy működik, hogy a rajta áthaladó sorokon elvégzi a kijelölt műveleteket. A reguláris kifejezések segítségével most a sed program kiválasztja a nem betű karaktereket és törli azokat (kicseréli az üres karakterrel), csak a maradék karaktereket továbbítja.
tr parancs egyszerűen a kis betűket a megfelelő nagybetűre változtatja a rajta áthaladó karakterfolyamon. Itt is láthatjuk a reguláris kifejezések használatát.
sort parancs hatása a nevéből is kitalálható, képes ABC sorrendbe rendezni a rajta áthaladó szavakat.
uniq parancs figyeli, hogy van-e ismétlődés az egymást követő sorok között, és ha igen, akkor csak egyet hagy meg belőlük.
Végül ismét a cat parancs kapja meg az eddigi műveletek eredményét, de mivel itt az n opcióval hívjuk meg, ezért úgy írja ki a sorokat, hogy mindegyiket egy sorszámmal lát el.

Ugye már mondanom sem kell, hogy a man awkman sedman tr, man sort és a man unique parancsok sok további érdekességet elárulnak ezekről a parancsokról.

Az iménti példa egyszerre tanulságos és motiváló. Kellő gyakorlással bárki össze tud állítani hozzá hasonló kis erőműveket, amihez persze még sok gyakorlásra és a unix parancsok kellő ismeretére van szükség.

Végezetül, egy olyan területre barangolunk, ahol a teszt felhasználó korlátaiba ütközünk.

Admin és root felhasználó – sudo, su

Igaz, még a Jaguár korszakból, de kerültem olyan szituációba, hogy az Apple menü Software update … opciója besokalt. Kiírta ugyan, hogy van új verzió, amit lehetne telepíteni, de hiába kértem, hogy tegye is azt meg, nem történt semmi. Az ilyenkor szokásos varázslatok (Permission repair, Parameter reset, …. ) egyike sem segített. Végül a Terminal programban a softwareupdate parancs jóvoltából sikerült telepíteni az operációs rendszer újabb verzióját, és azután már az Apple menüből is működtek ismét a későbbi frissítések.

A
teszt: softwareupdate -l

parancs kilistázza a potenciális frissitéseket.

A
teszt: softwareupdate -i iCal-9.1.2

parancs pedig telepíti az iCal program 9. generációjának legfrissebb verzióját.
Nos,itt azért van egy kis csapda. Mégpedig az, hogy az install opció root jogosultságokat igényel!
Anélkül futtatva csak egy hibaüzenetet kapunk: “Must be run as root“, azaz super userként (root) kell futtatnunk!
Eddig mindig azt hangsúlyoztam, hogy használjuk a teszt felhasználót gyakorlásként, akinek nincsenek adminisztrátori jogosultságai. Most már elég tapasztalatunk van ahhoz, hogy kellő körültekintéssel más felhasználók területén is használjuk a Terminal parancsokat.
Fontos tudni azt is, hogy mi a különbség az admin és a root jogosultságok között. Már tudjuk, hogy a Mac OS telepítésekor létrehozunk egy felhasználót, akinek alapértelmezés szerint admin jogosultságai vannak. Ez alapvetően elegendő a legtöbb adminisztrációs feladat elvégzéséhez.
Láttuk, hogy a unix széleskörűen szabályozza a felhasználói jogosultságokat. Eredetileg a unix-ban vannak felhasználók és és van egy kiemelt felhasználó, akit super user-nek, vagy root-nak neveznek. Ez utóbbinak gyakorlatilag mindenhez van jogosultsága.
Az Apple biztonsági szempontok alapján a rendszer telepítésekor nem aktivizálja a root felhasználót, helyette ad admin jogosultságot egy, vagy több felhasználónak.
Bizonyos feladatok elvégzéséhez, azonban root jogosultságra van szükség. Ezt kétféleképpen is elérhetjük. Ideiglenesen egy rövid időre, vagy úgy, hogy aktivizáljuk a root usert.

Ideiglenesen root jogosultságokhoz juthatunk a sudo parancs segítségével.
Nézzük először a sudo parancsot a megszokott teszt felhasználó területén:

teszt: sudo softwareupdate -i iCal-9.1.2

erre bizony egy figyelmeztető hibajelzést kapunk:
teszt not in the sudoers file. This incident will be reported.
Egy olyan felhasználó akart root jogosultságot szerezni, akinek erre nincs felhatalmazása, ezért erről az eseményről egy feljegyzés készül a logfájlokban. Ez akár egy támadási kísérletnek a jele is lehet, a rendszeradminisztrátor feladata ennek az eldöntése.

Az, hogy ki használhatja a sudo parancsot, nagyon finoman szabályozható. Érdemes belenézni a /etc könyvtárban levő sudoers nevű fájlba. Az

teszt: ls -l /etc/sudoers
-r--r----- 1 root wheel 629 Mar 21 2005 /etc/sudoers

parancs segítségével láthatjuk, hogy ennek a fájlnak a tulajdonosa a root felhasználó, és csak ő, illetve a wheel nevű, rendszerszintű csoport tagjai olvashatják.
Egyetlen reményünk, hogy belenézhessünk ebbe a fájlba az, ha az eredeti felhasználó rendelkezik elegendő jogosultsággal ahhoz, hogy használja a sudo parancsot. És valóban, az admin jogosultsággal rendelkező felhasználók alapértelmezésben jogosultak erre, próbáljuk ki a

adminuser$ sudo cat /etc/sudoers

parancsot egy admin felhasználó területéről.
Ismét egy kis meglepetés ér minket, mert egy jelszót kér a rendszer. Vajon milyen jelszót kell itt megadni? Bármilyen meglepő is, az admin jogosultsággal rendelkező felhasználó jelszavát kell beírni. Tehát a rendszer meggyőződik arról, hogy aki ideiglenesen root jogosultságot szeretne szerezni, az tényleg az a felhasználó, akinek a területén vagyunk, és nem engedi, hogy akárki, aki éppen arra téved és meglátja a nyitott Terminal ablakot root jogosultságot szerezzen. Ehhez ismerni kell az admin jelszót. Ezután egy rövid ideig többször is kiadhatjuk a sudo parancsot, de ha kicsit később tesszük ugyanezt, akkor ismét kéri az admin jelszónkat a rendszer. Most már a

adminuser$ sudo softwareupdate -i iCal-9.1.2

parancs is működni fog (feltéve, hogy létezik a megadott szoftverfrissítés!).

Amennyiben gyakran, illetve sok mindent szeretnénk root jogosultsággal elvégezni, akkor fárasztó lehet mindig a sudo parancsot használni. Ekkor érdemes lehet a root felhasználót aktivizálni. Az Apple biztonsági megfontolások alapján ezt nagyon nem javasolja, de ha biztosan tudja valaki, hogy erre van szüksége, akkor a Tigris-ben az Applications/Utlities folderben levő Netinfo Manager programban, a Leopard-ban a Utilities folderben levő Directory Utility programban lehet bekapcsolni. A Snow Leopard-ban annyi változás történt, hogy a Directory Utility program átkerült a /System/Library/CoreServices/ folderbe.

Ezután a Terminal programban elég annyit beírni, (egy admin felhasználó területén) hogy

adminuser$ su -

meg kell adni az imént lefoglalt jelszót és máris root felhasználóként szárnyalhatunk a rendszerünkben. Csodálatos a szabadság érzése, most gyakorlatilag mindent szabad, törölhetünk, módosíthatunk kedvünkre, amit csak akarunk! Ezt a változatot azonban kimondottan csakis akkor használjuk, amikor már kellő jártasságot szereztünk a Terminal és a unix használatában, és biztosak vagyunk abban is, hogy illetéktelenek nem fognak beletúrni a rendszerünkbe miközben éppen halaszthatatlan ügyünket végezzük egy másik helyiségben …

Természetesen ugyanott, ahol bekapcsoltuk, a root felhasználó ki is kapcsolható, és azzal visszaáll az eredeti biztonsági szint.

Érdemes az Interneten körülnézni, sok hasznos oldalt lehet találni a témával kapcsolatban.

Végezetül még egy fontos megjegyzés.
Már a bevezetőben is láttuk, hogy a unix-nak nagyon sok változata, megvalósítása létezik, még az OS X különböző verziói is tartalmaznak eltéréséket. Ezért nagyon fontos, hogy ha valahol találunk bizonyos problémára üdvözítő megoldást, mindig meg kell győződni arról, hogy az a mi rendszerünkre alkalmazható-e, ott ugyanúgy működik-e vagy nem. Kísérletezésre nagyon hasznos a korábbiakban sokat használt teszt felhasználó.